Quel est le but de Looper et comment l'utiliser?

Question

Je suis nouveau sur Android. Je veux savoir ce que fait la classe Looper et comment l'utiliser. J'ai lu la documentation de la classe Android Looper mais je suis incapable de la comprendre complètement. Je l'ai vu dans beaucoup d'endroits mais incapable de comprendre son but. Quelqu'un peut-il m'aider en définissant l'objectif de Looper et aussi en donnant un exemple simple si possible?

Answer 1

Qu'est-ce que le Looper?

Looper est une classe qui est utilisée pour exécuter les Messages(Runnables) dans une file d'attente. Normal threads n'ont pas une telle file d'attente, simples, par exemple, le thread n'a pas de file d'attente. Il s'exécute une fois et après l'exécution de la méthode des finitions, de l'exécution du thread d'un autre Message(Runnable).

Où l'on peut utiliser de l'Arpenteuse de la classe?

Si quelqu'un veut exécuter plusieurs messages(Runnables) puis il faut utiliser la fonction Looper classe qui est responsable de la création d'une file d'attente dans le fil. Par exemple, lors de l'écriture d'une application qui télécharge des fichiers à partir d'internet, nous pouvons utiliser de l'Arpenteuse de la classe pour mettre des fichiers en téléchargement dans la file d'attente.

Comment cela fonctionne?

Il est prepare() méthode pour préparer le Looper. Ensuite, vous pouvez utiliser la boucle() méthode pour créer une boucle de message dans le thread actuel et maintenant votre Looper est prêt à exécuter les demandes dans la file d'attente jusqu'à la fermeture de la boucle.

Voici le code qui vous permet de préparer le Looper.

class LooperThread extends Thread {
      public Handler mHandler;

      @Override
      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              @Override
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

Answer 2

Looper permet d'exécuter les tâches de manière séquentielle sur un seul thread. Et le gestionnaire définit les tâches que nous devons exécuter. C'est un scénario typique que j'essaie d'illustrer dans l'exemple:

 class SampleLooper {
@Override
public void run() {
  try {
    // preparing a looper on current thread     
    // the current thread is being detected implicitly
    Looper.prepare();

    // now, the handler will automatically bind to the
    // Looper that is attached to the current thread
    // You don't need to specify the Looper explicitly
    handler = new Handler();

    // After the following line the thread will start
    // running the message loop and will not normally
    // exit the loop unless a problem happens or you
    // quit() the looper (see below)
    Looper.loop();
  } catch (Throwable t) {
    Log.e(TAG, "halted due to an error", t);
  } 
}
}
 

Maintenant, nous pouvons utiliser le gestionnaire dans d'autres threads (disons ui thread) pour publier la tâche sur Looper à exécuter.

 handler.post(new Runnable()
{
public void run() {
//This will be executed on thread using Looper.
    }
});
 

Sur le thread d'interface utilisateur, nous avons un Looper implicite qui nous permet de gérer les messages sur le thread ui.

Answer 3

Android Looper est un wrapper pour attacher MessageQueue de Threads et il gère la File d'attente de traitement. Il a l'air très laconique dans Android de la documentation et de nombreuses fois nous pouvons être confrontés, Arpenteuse de l'INTERFACE liée aux questions d'accès. Si nous ne comprenons pas les bases, il devient très difficile à manipuler.

Voici un Article qui explique Arpenteuse du cycle de vie, comment l'utiliser et l'utilisation du Looper de Gestionnaire- http://prasanta-paul.blogspot.kr/2013/09/android-looper-and-toast-from.html Espérons que cela aide.

Answer 4

Un Looper a synchronisé MessageQueue qui est utilisé pour traiter les Messages placés dans la file d'attente. Il met en œuvre un Thread Spécifique de la structure de Stockage. Seulement un Looper/Thread Principales méthodes comprennent la préparation de(),la boucle() et quit(). prepare() inititializes le Thread courant comme un Looper. Préparer méthode statique qui utilise le ThreadLocal classe comme indiqué ci-dessous.

   public static void prepare(){
     ...
    sThreadLocal.set
    (new Looper());
   }

préparer() doit être appelé explicitilly avant l'exécution de la boucle d'événements.
loop() exécute la boucle d'événements qui attend les Messages d'arriver sur un Thread du messagequeue. Une fois le prochain Message est reçu,la boucle() la méthode distribue le Message à sa cible gestionnaire quit() arrête la boucle d'événements. Il n'a pas terminer la boucle,mais au lieu de cela, il place en file d'attente d'un message spécial

Un Looper peut être programmé dans un Fil de discussion par le biais de plusieurs étapes

1) Extend Thread

2) Call Looper.prepapare() to initialize Thread as a looper

3) Create one or more Handlers to process the incoming messages

4) Call Looper.loop() to process messages until the loop is told to quit. 

Answer 5

La gestion de plusieurs éléments vers le bas ou vers le bas dans un service est un meilleur exemple.

Les gestionnaires et AsnycTasks sont souvent utilisés pour propager des événements / messages entre l'interface utilisateur (thread) et un thread de travail ou pour retarder les actions. Donc, ils sont plus liés à l'interface utilisateur.

Plus spécifique, un Looper gère les tâches (runnables, futures) dans une file d'attente liée au thread en arrière-plan - même sans interaction de l'utilisateur ou une interface utilisateur affichée (l'application télécharge un fichier en arrière-plan pendant un appel).