2012-12-24 11 views
7

Sto cercando di capire le differenze tra i tre metodi di gestione dell'interazione dell'interfaccia utente.Come modificare questo codice di esempio per mostrare le differenze tra i tre metodi di aggiornamento dell'interfaccia utente di BlackBerry

Sono davvero confuso con questi tre termini quando si cerca di capirli in un caso reale.

Il codice seguente mostra la funzione del metodo invokeAndWait, ma se lo sostituisco con invokeLater o getEventLock() il programma funzionerà esattamente allo stesso modo.

Qualcuno potrebbe modificare il codice per mostrare le differenze tra i tre metodi per l'aggiornamento dell'interfaccia utente?

public final class HelloWorldMainScreen extends MainScreen 
{ 
    private LabelField labelField; 
    public HelloWorldMainScreen() 
    {   
     labelField = new LabelField("Hello World");  
     add(labelField); 
     MainScreenUpdaterThread thread = new MainScreenUpdaterThread(this); 
     thread.start(); 
    } 

    public void appendLabelText(String text){ 
     labelField.setText(labelField.getText()+"\n"+text); 
    } 
} 

public class MainScreenUpdaterThread extends Thread { 
    HelloWorldMainScreen mainScreen; 

    public MainScreenUpdaterThread(HelloWorldMainScreen mainScreen){ 
     this.mainScreen = mainScreen; 
    } 

    public void run(){ 
     for (int i = 0; i < 10; i++) { 
      try{ 
       Thread.sleep(5000); 
      }catch(InterruptedException ex){}; 
      UiApplication.getUiApplication().invokeAndWait(new Runnable() { 

       public void run() { 
        mainScreen.appendLabelText("Update");     
       } 
      }); 
     } 
    } 
} 

Questi tre concetti sono molto confusa per molte persone che iniziano in modo che qualsiasi codice sorgente esplicativo descrivendo le loro funzioni saranno fortemente utile per nessuno, credo.

Grazie in anticipo!

risposta

6

mia comprensione per tre diversi approcci:

  • Application.getEventLock() - ottenere il blocco evento il più presto possibile
  • UiApplication.invokeLater() - mettere Runnable nella coda di eventi e sarà eseguito dopo tutti gli altri compiti che sono stati messi davanti a questa coda
  • UiApplication.invokeAndWait() - uguale a quello precedente ad eccezione chiamando discussione verrà interrotta fino a quando verrà eseguito Runnable

La mia opinione personale non usa mai il primo metodo. Non penso che nessuno dei miei compiti di disegnare o dell'interfaccia utente siano più prioritari rispetto ad altre attività già inserite nella coda degli eventi.

Io uso principalmente il secondo metodo e l'ho usato una volta l'ultimo quando ho implementato alcune selezioni di finestre popup modali.

2

getEventLock(): recupera il blocco eventi dell'interfaccia utente dell'applicazione. I thread di lavoro devono essere sincronizzati su questo thread se desiderano eseguire il codice serializzato con il thread di eventi. Il thread di lavoro deve contenere il blocco solo per un breve periodo di tempo, poiché questa azione mette in pausa il dispatcher di thread.

Qualsiasi operazione riguardante l'interfaccia utente del dispositivo deve essere eseguita con il blocco in attesa. Il sistema dell'interfaccia utente garantisce inoltre che tutti i metodi che invoca verranno eseguiti su un thread che ha già il blocco.

Un'applicazione non deve mai chiamare notificare o attendere su questo oggetto.

invokeLater(): Inserisce l'oggetto eseguibile nella coda eventi di questa applicazione. Richiamare questo metodo, passando un oggetto runnable, per fare richiamare il metodo run() dell'oggetto sul thread di invio, dopo che tutti gli eventi in sospeso sono stati elaborati.

Se non è presente alcun thread di invio eventi (ad esempio hasEventThread() restituisce false), l'ultimo elemento da accodare viene rilasciato quando la coda supera il limite di dimensioni.Nota: se un'applicazione non ha un thread di eventi, è possibile richiamare setAcceptEvents (booleano) per informare il sistema di runtime che l'applicazione non accetta più eventi. Tutti gli eventi in coda a tale applicazione vengono quindi scartati.

invokeAndWait(): Inserisce l'oggetto eseguibile nella coda eventi di questa applicazione e attende fino a quando non viene elaborato. Richiamare questo metodo, passando un oggetto runnable, per fare richiamare il metodo run() dell'oggetto sul thread di invio, dopo che tutti gli eventi in sospeso sono stati elaborati.

Questo metodo si blocca fino a quando non viene elaborato l'evento di inserimento (ovvero finché non viene restituito il metodo run() dell'oggetto eseguibile).

È possibile chiamare questo metodo sul thread di invio eventi. In questo caso il runnable verrà eseguito immediatamente.

Se non è presente alcun thread di invio eventi (ad esempio hasEventThread() restituisce false), l'ultimo elemento da accodare viene rilasciato quando la coda supera il limite di dimensioni. Nota: se un'applicazione non ha un thread di eventi, è possibile richiamare setAcceptEvents (booleano) per informare il sistema di runtime che l'applicazione non accetta più eventi. Tutti gli eventi in coda a tale applicazione vengono quindi scartati.

documentazione API: http://www.blackberry.com/developers/docs/4.3.0api/net/rim/device/api/system/Application.html#invokeLater(java.lang.Runnable)