Interagir com tópicos de UI em Java / J2ME

votos
5

Eu estou escrevendo um aplicativo J2ME. Uma das peças é algo que as pesquisas o conteúdo de um diretório periodicamente e, se existem coisas novas, pinta-las na tela. Eu tenho feito isso por ter a forma UI lançar uma linha de pesquisa com um ponteiro de volta para si mesmo, e quando o fio de votação encontra algo que chama de volta para o formulário e chama um método syncrhonized para atualizar é display. Isso parece funcionar bem.

A pergunta que eu tenho é esta. Em C # /. NET eu sei que não é bom ter tópicos não-UI atualizar a interface do usuário, e a maneira correta de lidar com isso é a delegar-lo até o segmento.

Por exemplo, o seguinte:

public void DoSomeUIThing()
{
    if (this.uiComponent.InvokeRequired)
    {
        this.uiComponent.Invoke(someDelegateThatCallsBackToThis);
    }
    else
    {
        this.uiComponent.Text = This is the update I want to happen;
    }
}

Existe um equivalente J2ME para saber como gerir este processo? Como cerca de Java? Ou será que Java / J2ME apenas jogar mais agradável em relação a isso? Se não, como isso é feito?

[EDIT] Parece que balanço suporta o que eu estou perguntando sobre a via () métodos SwingUtilities.invokeLater () e invokeAndWait. Existe uma estrutura equivalente para J2ME?

Publicado 15/11/2008 em 15:09
fonte usuário
Em outras línguas...                            


5 respostas

votos
5

Em relação a Java, o que você está descrevendo parece um SwingWorker (segmento de trabalho) .

Quando um programa Balanço precisa executar uma tarefa de longa duração, que geralmente usa um dos segmentos de trabalho, também conhecidos como os fios de fundo.

Um programa de balanço inclui os seguintes tipos de tópicos:

  • fios iniciais, os segmentos que executam o código do pedido inicial.
  • O segmento de eventos expedição, onde todo o código de manipulação de eventos é executado. A maioria dos códigos que interage com a estrutura de balanço também deve executar em esta discussão.
  • threads de trabalho, também conhecidas como linhas de fundo, onde as tarefas de fundo demoradas são executados.

Regra de thread único :
Uma vez que um componente Swing tem sido realizado, todo o código que possa afetar ou dependem do estado desse componente deve ser executado no thread-despachar evento.

Quando usado em um contexto J2EE, você precisa ter cuidado quando você está fazendo referência a um SwingWorker de um EJB .

Em relação J2ME , isso depende se você estiver desenvolvendo sua aplicação como um MIDlet padrão que será executado em qualquer dispositivo habilitado para MIDP, ou , por exemplo, como um RIMlet, uma aplicação baseada em CLDC que usa APIs específicas do BlackBerry e, portanto, será executado apenas em BlackBerry dispositivos.

Porque ao contrário de aulas de interface do usuário do MIDP, RIM são semelhantes ao Swing no sentido de que as operações de UI ocorrer no segmento de eventos, que não é thread-safe como em MIDP. Para executar código no segmento de eventos, um aplicativo deve obter um bloqueio no objeto de evento, ou usar invokeLater () ou invokeAndWait () - trabalho extra para o desenvolvedor, mas a sofisticação vem com uma etiqueta de preço.

Mas para LCDUI , você pode acessar um formulário de vários segmentos .

Respondeu 15/11/2008 em 15:26
fonte usuário

votos
4

Há muitos perfis de Java ME. Se você quer dizer MIDP, então Display.runSeriallyé o que você quer.

Para AWT (Swing) você usaria EventQueue.invokeLater( SwingUtilities.invokeLatersó é necessária devido ao Java 1.1 não ter o EventQueuemétodo - 1.2 está prestes a celebrar o seu décimo aniversário). Para a API DOM comum, usar DOMService.invokeLater.

Não importa o que reivindica uma API GUI pode fazer sobre thread-segurança são provavelmente errado (algumas das reivindicações de balanço são removidos em JDK7 porque eles não são implementáveis). Em qualquer caso, o código do aplicativo improvável que seja thread-safe.

Respondeu 15/11/2008 em 18:54
fonte usuário

votos
1

Eu posso atestar que o kit de ferramentas UI MIDP é realmente thread-safe, como eu tenho grandes MIDlets com GUI complexo rodando em milhões de telefones feitos por quase todos os fabricantes, e eu nunca vi um problema a esse respeito.

Respondeu 23/04/2010 em 17:05
fonte usuário

votos
1

Se você desenvolver sob SWT isso é feito por meio de asyncExec () do objeto de exibição. Você passa um objeto implementando Runnable para que o segmento interface do usuário executa as alterações feitas em outro segmento.

Este é um exemplo emprestado aqui

public void itemRemoved(final ModelEvent me)
{
   final TableViewer tableViewer = this.viewer;

   if (tableViewer != null)
   {
      display.asyncExec(new Runnable()
      {
         public void run()
         {
            tableViewer.remove(me.getItem());
         }
      }
   }
}
Respondeu 15/11/2008 em 16:16
fonte usuário

votos
1

Para aplicativos J2ME você provavelmente vai querer mantê-lo simples. A principal coisa é tocar componentes de interface do usuário apenas no segmento de eventos. A maneira direta de fazer isso é usar invokeLater ou invokeAndWait . Dependendo de suas bibliotecas, você não terá acesso a nada mais do que isso. Em geral, se estes não são fornecidos em sua plataforma que provavelmente equivale a não haver suporte de thread e não ser um problema. Por exemplo a amora faz apoiá-lo .

Respondeu 15/11/2008 em 16:04
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more