webentwicklung-frage-antwort-db.com.de

Was ist der Zweck von Looper und wie benutzt man es?

Ich bin neu bei Android. Ich möchte wissen, was die Looper-Klasse tut und wie sie verwendet wird. Ich habe die Android Looper-Klassendokumentation gelesen aber ich kann sie nicht vollständig verstehen ... Ich habe sie an vielen Orten gesehen, aber ihren Sinn nicht verstanden. Kann mir jemand helfen, indem er den Zweck von Looper definiert und wenn möglich auch ein einfaches Beispiel gibt?

414
Khawar Raza

Was ist Looper?

Looper ist eine Klasse, die zum Ausführen von Messages (Runnables) in einer Warteschlange verwendet wird. Normale Threads haben keine solche Warteschlange, z. Einfacher Thread hat keine Warteschlange. Es wird einmal ausgeführt, und nachdem die Ausführung der Methode abgeschlossen ist, führt der Thread keine weitere Message (Runnable) aus.

Wo können wir Looper-Klasse verwenden?

Wenn jemand mehrere Nachrichten (Runnables) ausführen möchte, sollte er die Looper-Klasse verwenden, die für das Erstellen einer Warteschlange im Thread verantwortlich ist. Wenn Sie beispielsweise eine Anwendung schreiben, die Dateien aus dem Internet herunterlädt, können Sie die Looper-Klasse verwenden Dateien zum Herunterladen in die Warteschlange stellen.

Wie es funktioniert?

Es gibt eine prepare() Methode, um den Looper vorzubereiten. Dann können Sie die loop()-Methode verwenden, um eine Nachrichtenschleife im aktuellen Thread zu erstellen. Jetzt ist Ihr Looper bereit, die Anforderungen in der Warteschlange auszuführen, bis Sie die Schleife beenden.

Hier ist der Code, mit dem Sie den Looper vorbereiten können.

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();
      }
  }
374
Dharmendra

Sie können besser verstehen, was Looper im Kontext des GUI-Frameworks ist. Looper kann zwei Dinge tun.

1) Looper transformiert einen normalen Thread, der beendet wird, wenn seine run () -Methode in etwas kontinuierlich ausgeführt wird, bis die Android-App ausgeführt wird, die im GUI-Framework benötigt wird () Methode return. Aber lassen Sie mich klarstellen, was ich darunter verstehe.

2) Looper stellt eine Warteschlange bereit, in der zu erledigende Jobs in die Warteschlange gestellt werden, was auch im GUI-Framework erforderlich ist.

Wie Sie vielleicht wissen, erstellt das System beim Start einer Anwendung einen Ausführungsthread für die Anwendung, der als "main" bezeichnet wird, und Android-Anwendungen werden normalerweise vollständig in einem einzigen Thread ausgeführt, der standardmäßig als "Haupt-Thread" bezeichnet wird. Main-Thread ist jedoch kein geheimer, spezieller Thread. Es ist nur ein normaler Thread, der Threads ähnelt, die Sie mit new Thread()-Code erstellen. Das heißt, er wird beendet, wenn die run () -Methode zurückkehrt! Denken Sie an ein Beispiel unten. 

public class HelloRunnable implements Runnable {
    public void run() {
        System.out.println("Hello from a thread!");
    }

    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }
}

Nun wenden wir dieses einfache Prinzip auf Android-Apps an. Was würde passieren, wenn eine Android-App auf einem normalen Thread läuft? Ein Thread namens "main" oder "UI" oder was auch immer startet Ihre Anwendung und zeichnet alle Benutzeroberflächen. Der erste Bildschirm wird den Benutzern angezeigt. So was jetzt? Der Haupt-Thread endet? Nein, das sollte nicht Es sollte warten, bis Benutzer etwas tun, oder? Aber wie können wir dieses Verhalten erreichen? Nun, wir können es mit Object.wait() oder Thread.sleep() versuchen. Zum Beispiel beendet der Haupt-Thread seinen ersten Job, um den ersten Bildschirm anzuzeigen, und schläft. Es wird geweckt, was bedeutet, dass es unterbrochen wird, wenn ein neuer Job abgerufen wird. So weit so gut, aber in diesem Moment brauchen wir eine warteschlangenähnliche Datenstruktur, um mehrere Jobs zu halten. Denken Sie an einen Fall, in dem ein Benutzer den Bildschirm seriell berührt und eine Aufgabe längere Zeit in Anspruch nimmt. Wir müssen also über eine Datenstruktur verfügen, um Jobs auf First-In-First-Out-Art zu halten. Sie können sich auch vorstellen, dass das Implementieren eines ständig laufenden und prozessjobbasierten Threads mit Interrupt nicht einfach ist und zu komplexem und häufig nicht pflegbarem Code führt. Wir würden lieber einen neuen Mechanismus für diesen Zweck schaffen, und das ist, was Looper ausmacht. Das offizielles Dokument der Looper-Klasse sagt, "Threads ist standardmäßig keine Nachrichtenschleife zugeordnet", und Looper ist eine Klasse, mit der "eine Nachrichtenschleife für einen Thread ausgeführt wird". Jetzt können Sie verstehen, was es bedeutet. 

Um die Dinge klarer zu machen, überprüfen wir den Code, in dem der Haupt-Thread umgewandelt wird. Alles geschieht in ActivityThread-Klasse . In seiner main () -Methode finden Sie unten Code, der einen normalen Haupt-Thread in etwas umwandelt, was wir brauchen.

public final class ActivityThread {
    ...
    public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();
        Looper.loop();
        ...
    }
}

und Looper.loop() method loop unendlich und entkalken eine Nachricht und verarbeiten jeweils eine Nachricht:

public static void loop() {
    ...
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        ...
        msg.target.dispatchMessage(msg);
        ...
    }
}

Grundsätzlich handelt es sich bei Looper um eine Klasse, die ein Problem lösen soll, das im GUI-Framework auftritt. Diese Bedürfnisse können aber auch in anderen Situationen auftreten. Eigentlich ist es ein ziemlich bekanntes Muster für Multi-Threads-Anwendungen, und Sie können mehr darüber in "Concurrent Programming in Java" von Doug Lea erfahren. Sie können sich auch vorstellen, dass diese Art von Mechanismus im Android-Framework nicht einzigartig ist, aber das gesamte GUI-Framework muss möglicherweise etwas ähnlich sein. Sie können fast denselben Mechanismus im Java Swing-Framework finden.

239
김준호

Mit Looper können Aufgaben sequenziell in einem einzelnen Thread ausgeführt werden. Ein Handler definiert die Aufgaben, die ausgeführt werden müssen. Es ist ein typisches Szenario, das ich in diesem Beispiel veranschaulichen möchte:

class SampleLooper extends Thread {
@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);
  } 
}
}

Jetzt können wir den Handler in einigen anderen Threads (z. B. Ui-Thread) verwenden, um die Task auf Looper zur Ausführung zu veröffentlichen.

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

Auf dem UI-Thread haben wir einen impliziten Looper, mit dem wir die Nachrichten auf dem UI-Thread bearbeiten können.

73
user2834274

Android Looper ist ein Wrapper zum Anhängen von MessageQueue an Thread und verwaltet die Warteschlangenverarbeitung. In der Android-Dokumentation sieht es sehr kryptisch aus, und oft sind wir mit Looper-bezogenen Problemen beim Zugriff auf die Benutzeroberfläche konfrontiert. Wenn wir die Grundlagen nicht verstehen, wird es sehr schwierig, damit umzugehen. 

Hier ist ein Artikel , der Looper Lebenszyklus erklärt, wie man ihn benutzt und wie Looper in Handler verwendet wird.

 enter image description here

Looper = Thread + MessageQueue

31
user542954

Definition von Looper & Handler:

Looper ist eine Klasse, die einen Thread in einen Pipeline-Thread umwandelt, und Handler gibt Ihnen einen Mechanismus, mit dem Sie Tasks aus anderen Threads in den Thread verschieben können. 

Einzelheiten:

Ein PipeLine-Thread ist also ein Thread, der über einen Handler weitere Aufgaben von anderen Threads annehmen kann.

Der Looper wird so benannt, weil er die Schleife implementiert - er nimmt die nächste Aufgabe, führt sie aus, dann die nächste und so weiter. Der Handler wird als Handler bezeichnet, da er die nächste Task jedes Mal von einem anderen Thread handhabt oder annimmt und an Looper (Thread oder PipeLine-Thread) weiterleitet.

Beispiel:

Ein sehr gutes Beispiel für einen Looper and Handler- oder PipeLine-Thread ist das Herunterladen mehrerer Bilder oder das Hochladen nacheinander in einem einzigen Thread auf einen Server (Http), anstatt einen neuen Thread für jeden Netzwerkaufruf im Hintergrund zu starten.

Lesen Sie hier mehr über Looper und Handler und die Definition von Pipeline-Thread:

Android Muts: Intro zu Loopers und Handlern

11
ahmadalibaloch

Ein Looper hat eine synchronizedMessageQueue, die zur Verarbeitung von Nachrichten verwendet wird, die in die Warteschlange gestellt werden.

Es implementiert ein Thread Specific Storage Pattern.

Nur eine Looper pro Thread. Zu den wichtigsten Methoden gehören prepare(), loop() und quit().

prepare() initialisiert die aktuelle Thread als Looper. prepare() ist eine static-Methode, die wie unten gezeigt die ThreadLocal-Klasse verwendet.

   public static void prepare(){
       ...
       sThreadLocal.set
       (new Looper());
   }
  1. prepare() muss vor dem Ausführen der Ereignisschleife explizit aufgerufen werden. 
  2. loop() führt die Ereignisschleife aus, die darauf wartet, dass Messages im Messagequeue eines bestimmten Threads ankommen. Sobald die nächste Nachricht empfangen wird, sendet die loop()-Methode die Nachricht an ihren Ziel-Handler
  3. quit() beendet die Ereignisschleife. Die Schleife wird nicht beendet, sondern eine spezielle Nachricht in die Warteschlange gestellt

Looper kann in einer Thread über mehrere Schritte programmiert werden

  1. Thread erweitern

  2. Rufen Sie Looper.prepare() auf, um den Thread als Looper zu initialisieren.

  3. Erstellen Sie eine oder mehrere Handler (s), um die eingehenden Nachrichten zu verarbeiten

  4. Rufen Sie Looper.loop() auf, um Nachrichten zu verarbeiten, bis der Schleife quit() mitgeteilt wird. 
7
Theo

Lebensdauer von Java Thread ist nach Abschluss der run()-Methode beendet. Derselbe Thread kann nicht erneut gestartet werden. 

Looper wandelt normale Thread in eine Nachrichtenschleife um. Schlüsselmethoden von Looper sind:

void prepare ()

Initialisieren Sie den aktuellen Thread als Looper. Dadurch haben Sie die Möglichkeit, Handler zu erstellen, die dann auf diesen Looper verweisen, bevor Sie die Schleife tatsächlich starten. Stellen Sie sicher, dass Sie loop () aufrufen, nachdem Sie diese Methode aufgerufen haben, und beenden Sie sie mit dem Aufruf von quit ().

void loop ()

Führen Sie die Nachrichtenwarteschlange in diesem Thread aus. Rufen Sie quit () auf, um die Schleife zu beenden.

void quit()

Beendet den Greifer.

Bewirkt, dass die Methode loop () beendet wird, ohne dass weitere Nachrichten in der Nachrichtenwarteschlange verarbeitet werden.

Dieser mindorks Artikel von Janishar erklärt die Kernkonzepte auf Nizza Weise.

 enter image description here

Looper ist einem Thread zugeordnet. Wenn Sie Looper für den UI-Thread benötigen, gibt Looper.getMainLooper() den zugeordneten Thread zurück. 

Sie müssen Looper mit einem Handler verknüpfen.

Looper, Handler und HandlerThread sind die Lösung von Android zur Lösung der Probleme der asynchronen Programmierung.

Sobald Sie Handler haben, können Sie unterhalb der APIs aufrufen.

post (Runnable r)

Bewirkt, dass Runnable R der Nachrichtenwarteschlange hinzugefügt wird. Das ausführbare Programm wird auf dem Thread ausgeführt, an den dieser Handler angehängt ist.

boolean sendMessage (Message msg)

Schiebt eine Nachricht am Ende der Nachrichtenwarteschlange nach allen anstehenden Nachrichten vor der aktuellen Uhrzeit. Es wird in handleMessage (Message) im Thread dieses Handlers empfangen.

HandlerThread ist eine praktische Klasse zum Starten eines neuen Threads, der einen Looper hat. Der Looper kann dann zum Erstellen von Handler-Klassen verwendet werden

In einigen Szenarien können Sie Runnable-Tasks nicht auf dem UI-Thread ausführen. z.B. Netzwerkoperationen: Senden Sie eine Nachricht an einen Socket, öffnen Sie eine URL und rufen Sie den Inhalt durch Lesen von InputStream ab.

In diesen Fällen ist HandlerThread nützlich. Sie können Looper object von HandlerThread abrufen und eine Handler für HandlerThread anstelle des Hauptthreads erstellen.

Der HandlerThread Code wird wie folgt aussehen:

@Override
public void run() {
    mTid = Process.myTid();
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();
    Looper.loop();
    mTid = -1;
}

Siehe nachstehenden Post für Beispielcode:

Android: Toast in einem Thread

5
Ravindra babu

Diese Antwort hat nichts mit der Frage zu tun, aber die Verwendung von Looper und die Art und Weise, wie die Benutzer den Handler und den Looper in ALLEN Antworten erstellt haben, sind schlichtweg schlechte Praxis (einige Erklärungen sind jedoch korrekt). Ich muss folgendes posten:

HandlerThread thread = new HandlerThread(threadName);
thread.start();
Looper looper = thread.getLooper();
Handler myHandler = new Handler(looper);

und für eine vollständige Implementierung

4
TacB0sS

Der Umgang mit mehreren Daunen oder Upload-Elementen in einem Service ist ein besseres Beispiel.

Handler und AsnycTask werden häufig verwendet, um Events/Messages zwischen dem UI (Thread) und einem Arbeitsthread zu verbreiten oder Aktionen zu verzögern. Sie sind also mehr mit der Benutzeroberfläche verbunden.

Eine Looper verarbeitet Aufgaben (Runnables, Futures) in einer Thread-bezogenen Warteschlange im Hintergrund - auch ohne Benutzerinteraktion oder angezeigte Benutzeroberfläche (die App lädt während eines Anrufs eine Datei im Hintergrund herunter).

3
Thorsten

Grundlegendes zu Looper-Threads

Ein Java-Thread eine Ausführungseinheit, die entworfen wurde, um eine Aufgabe in ihrer run () -Methode auszuführen und danach zu beenden:  enter image description here

Aber in Android gibt es viele Anwendungsfälle, in denen wir einen Thread am Leben erhalten und auf Benutzereingaben ereignisse warten müssen, z. Benutzeroberflächenthread aka Main Thread.

Der Hauptthread in Android ist ein Java-Thread, der zuerst von JVM beim Start einer App gestartet wird und so lange ausgeführt wird, bis der Benutzer ihn schließt oder auf eine nicht behandelte Ausnahme stößt.

Wenn eine Anwendung gestartet wird, erstellt das System einen Ausführungsthread für die Anwendung mit dem Namen "main". Dieser Thread ist sehr wichtig, da er für das Versenden von Ereignissen an die entsprechenden Widgets der Benutzeroberfläche zuständig ist, einschließlich Zeichnungsereignissen.

/ - enter image description here

Hier ist zu beachten, dass der Haupt-Thread zwar ein Java-Thread ist, aber weiterhin Benutzerereignisse abhört und Frames mit 60 fps auf dem Bildschirm zeichnet und dennoch nicht nach jedem Zyklus stirbt. wie ist es so

Die Antwort lautet Looper-Klasse : Looper ist eine Klasse, die verwendet wird, um einen Thread am Leben zu erhalten und eine Nachrichtenwarteschlange zu verwalten, um Aufgaben für diesen Thread auszuführen.

Threads sind standardmäßig nicht mit einer Nachrichtenschleife verknüpft. Sie können diese jedoch zuweisen, indem Sie in der run-Methode Looper.prepare () aufrufen und dann Looper.loop () aufrufen.

Ziel von Looper ist es, einen Thread am Leben zu halten und auf den nächsten Zyklus des Eingabeobjekts Message zu warten, um eine Berechnung durchzuführen, die andernfalls nach dem ersten Ausführungszyklus zerstört wird.

Wenn Sie genauer wissen möchten, wie Looper Message Objektwarteschlange verwaltet, können Sie sich den Quellcode von Looperclass ansehen:

https://github.com/aosp-mirror/platform_frameworks_base/blob/master/core/Java/Android/os/Looper.Java

Im Folgenden finden Sie ein Beispiel dafür, wie Sie einen Looper Thread erstellen und mit der Klasse Activity mithilfe von LocalBroadcast kommunizieren können.

class LooperThread : Thread() {

    // sendMessage success result on UI
    private fun sendServerResult(result: String) {
        val resultIntent = Intent(ServerService.ACTION)
        resultIntent.putExtra(ServerService.RESULT_CODE, Activity.RESULT_OK)
        resultIntent.putExtra(ServerService.RESULT_VALUE, result)
        LocalBroadcastManager.getInstance(AppController.getAppController()).sendBroadcast(resultIntent)
    }

    override fun run() {
        val looperIsNotPreparedInCurrentThread = Looper.myLooper() == null

        // Prepare Looper if not already prepared
        if (looperIsNotPreparedInCurrentThread) {
            Looper.prepare()
        }

        // Create a handler to handle messaged from Activity
        handler = Handler(Handler.Callback { message ->
            // Messages sent to Looper thread will be visible here
            Log.e(TAG, "Received Message" + message.data.toString())

            //message from Activity
            val result = message.data.getString(MainActivity.BUNDLE_KEY)

            // Send Result Back to activity
            sendServerResult(result)
            true
        })

        // Keep on looping till new messages arrive
        if (looperIsNotPreparedInCurrentThread) {
            Looper.loop()
        }
    }

    //Create and send a new  message to looper
    fun sendMessage(messageToSend: String) {
        //Create and post a new message to handler
        handler!!.sendMessage(createMessage(messageToSend))
    }


    // Bundle Data in message object
    private fun createMessage(messageToSend: String): Message {
        val message = Message()
        val bundle = Bundle()
        bundle.putString(MainActivity.BUNDLE_KEY, messageToSend)
        message.data = bundle
        return message
    }

    companion object {
        var handler: Handler? = null // in Android Handler should be static or leaks might occur
        private val TAG = javaClass.simpleName

    }
}

Verwendung :

 class MainActivity : AppCompatActivity() {

    private var looperThread: LooperThread? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // start looper thread
        startLooperThread()

        // Send messages to Looper Thread
        sendMessage.setOnClickListener {

            // send random messages to looper thread
            val messageToSend = "" + Math.random()

            // post message
            looperThread!!.sendMessage(messageToSend)

        }   
    }

    override fun onResume() {
        super.onResume()

        //Register to Server Service callback
        val filterServer = IntentFilter(ServerService.ACTION)
        LocalBroadcastManager.getInstance(this).registerReceiver(serverReceiver, filterServer)

    }

    override fun onPause() {
        super.onPause()

        //Stop Server service callbacks
     LocalBroadcastManager.getInstance(this).unregisterReceiver(serverReceiver)
    }


    // Define the callback for what to do when data is received
    private val serverReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val resultCode = intent.getIntExtra(ServerService.RESULT_CODE, Activity.RESULT_CANCELED)
            if (resultCode == Activity.RESULT_OK) {
                val resultValue = intent.getStringExtra(ServerService.RESULT_VALUE)
                Log.e(MainActivity.TAG, "Server result : $resultValue")

                serverOutput.text =
                        (serverOutput.text.toString()
                                + "\n"
                                + "Received : " + resultValue)

                serverScrollView.post( { serverScrollView.fullScroll(View.FOCUS_DOWN) })
            }
        }
    }

    private fun startLooperThread() {

        // create and start a new LooperThread
        looperThread = LooperThread()
        looperThread!!.name = "Main Looper Thread"
        looperThread!!.start()

    }

    companion object {
        val BUNDLE_KEY = "handlerMsgBundle"
        private val TAG = javaClass.simpleName
    }
}

Können wir stattdessen Async Task oder Intent Services verwenden?

  • Asynchrone Tasks sollen einen kurzen Vorgang im Hintergrund ausführen und Fortschritte und Ergebnisse im UI-Thread liefern. Asynchrone Aufgaben haben Grenzen, so dass Sie nicht mehr als 128 Asynchrone Aufgaben erstellen können und ThreadPoolExecutor erlauben nur bis zu 5 asynchrone Aufgaben .

  • IntentServices ist auch dazu gedacht, Hintergrundaufgaben für eine etwas längere Dauer zu erledigen, und Sie können LocalBroadcast verwenden, um mit Activity zu kommunizieren. Aber die Dienste werden nach der Ausführung der Aufgabe zerstört. Wenn Sie es für eine lange Zeit laufen lassen möchten, müssen Sie Dinge wie while(true){...} tun.

Andere sinnvolle Anwendungsfälle für Looper Thread:

  • Wird für die bidirektionale Socket-Kommunikation verwendet, bei der der Server weiterhin den Client-Socket abhört und die Bestätigung zurückschreibt

  • Bitmap-Verarbeitung im Hintergrund. Übergeben Sie die Bild-URL an den Looper-Thread, um Filtereffekte anzuwenden, und speichern Sie sie am temporären Speicherort. Anschließend wird der temporäre Pfad des Bildes gesendet.

1
Hitesh Sahu

Was ist Looper

VON DOCS

Looper

Looper Klasse, die zum Ausführen einer Meldungsschleife für eine thread verwendet wird. Threads ist standardmäßig keine Nachrichtenschleife zugeordnet. Um einen zu erstellen, rufen Sie prepare() in dem Thread auf, der die Schleife ausführen soll, und dann loop(), damit er Nachrichten verarbeitet, bis die Schleife angehalten wird. 

  • Eine Looper ist eine Nachrichtenbehandlungsschleife:
  • Ein wichtiger Charakter von Looper ist, dass er mit dem Thread verknüpft ist, in dem der Looper erstellt wird
  • Die Looper-Klasse unterhält eine MessageQueue , die Listennachrichten enthält. Ein wichtiger Charakter von Looper ist, dass er mit dem Thread verknüpft ist, in dem der Looper erstellt wird.
  • Die Variable Looper wird so benannt, weil sie die Schleife implementiert. Sie nimmt die nächste Aufgabe, führt sie aus, dann die nächste und so weiter. Die Variable Handler wird als Handler bezeichnet, weil jemand keinen besseren Namen erfinden konnte
  • Android Looper ist eine Java-Klasse in der Android-Benutzeroberfläche, die zusammen mit der Handler-Klasse UI-Ereignisse verarbeitet, z. B. das Klicken von Schaltflächen, das erneute Erstellen von Bildschirmen und die Ausrichtung.

Wie es funktioniert?

 enter image description here

Looper erstellen

Ein Thread erhält eine Looper und MessageQueue durch Aufruf von Looper.prepare() nach dessen Ausführung. Looper.prepare() identifiziert den aufrufenden Thread, erstellt ein Looper- und MessageQueue-Objekt und ordnet den Thread zu

BEISPIELCODE

class MyLooperThread extends Thread {

      public Handler mHandler; 

      public void run() { 

          // preparing a looper on current thread  
          Looper.prepare();

          mHandler = new Handler() { 
              public void handleMessage(Message msg) { 
                 // process incoming messages here
                 // this will run in non-ui/background thread
              } 
          }; 

          Looper.loop();
      } 
  }

Weitere Informationen finden Sie unter Post

0
Nilesh Rathod