Was ist der Zweck von Looper und wie wird er verwendet?

Question

Ich bin neu bei Android. Ich möchte wissen, was die Looper Klasse und wie man sie benutzt. Ich habe die Android Dokumentation der Looper-Klasse aber ich bin nicht in der Lage, sie vollständig zu verstehen. Ich habe es an vielen Stellen gesehen, aber ich kann seinen Zweck nicht verstehen. Kann mir jemand helfen, indem er den Zweck von Looper und wenn möglich auch mit einem einfachen Beispiel?

Answer 1

Handhabung mehrerer Down- oder Upload-Positionen in einer Dienst ist ein besseres Beispiel.

Handler y AsnycTask werden häufig zur Verbreitung von Ereignisse/Nachrichten zwischen den UI (Thread) und ein Arbeits-Thread oder um Maßnahmen zu verzögern. Sie sind also eher mit der Benutzeroberfläche verbunden.

A Looper übernimmt Aufgaben ( Lauffähige Güter, Futures ) in einer threadbezogenen Warteschlange im Hintergrund - auch ohne Benutzerinteraktion oder eine angezeigte Benutzeroberfläche (die Anwendung lädt während eines Anrufs eine Datei im Hintergrund herunter).

Answer 2

Ich werde versuchen, den Zweck der Looper-Klasse so einfach wie möglich zu erklären. Bei einem normalen Java-Thread sagen wir, wenn die Run-Methode die Ausführung abgeschlossen hat, hat der Thread seine Aufgabe erledigt und lebt danach nicht mehr. Was aber, wenn wir weitere Aufgaben in unserem Programm mit demselben Thread ausführen wollen, der nicht mehr lebt? Oh, jetzt gibt es ein Problem, richtig? Ja, denn wir wollen weitere Aufgaben ausführen, aber der Thread ist nicht mehr am Leben. An dieser Stelle kommt der Looper ins Spiel, um uns zu retten. Looper ist, wie der Name schon sagt, eine Schleife. Looper ist nichts anderes als eine Endlosschleife innerhalb Ihres Threads. Er hält den Thread so lange am Leben, bis wir explizit die Methode quit() aufrufen. Der Aufruf der quit()-Methode auf dem unendlich lebendigen Thread führt dazu, dass die Bedingung in der Endlosschleife innerhalb des Threads falsch ist, so dass die Endlosschleife beendet wird, der Thread also stirbt oder nicht mehr lebendig ist. Und es ist wichtig, die quit()-Methode auf dem Thread aufzurufen, an den der Looper angehängt ist, da er sonst wie ein Zombie in Ihrem System lebt. Wenn wir zum Beispiel einen Hintergrund-Thread erstellen wollen, um mehrere Aufgaben zu erledigen, erstellen wir einen einfachen Java-Thread und verwenden die Looper-Klasse, um einen Looper vorzubereiten und den vorbereiteten Looper mit diesem Thread zu verknüpfen, so dass unser Thread so lange leben kann, wie wir wollen, weil wir jederzeit quit() aufrufen können, wenn wir unseren Thread beenden wollen. Der Looper hält unseren Thread am Leben, so dass wir in der Lage sind, mehrere Aufgaben mit demselben Thread auszuführen, und wenn wir fertig sind, rufen wir quit() auf, um den Thread zu beenden. Was, wenn unser Haupt-Thread oder UI-Thread die vom Hintergrund-Thread oder Nicht-UI-Thread berechneten Ergebnisse auf einigen UI-Elementen anzeigen soll? Für diesen Zweck gibt es das Konzept der Handler; Mit Hilfe von Handlern können wir die Interprozesskommunikation durchführen oder sagen wir, über Handler können zwei Threads miteinander kommunizieren. Der Haupt-Thread hat also einen zugeordneten Handler und der Hintergrund-Thread kommuniziert mit dem Haupt-Thread über diesen Handler, um die Aufgabe zu erledigen, die von ihm berechneten Ergebnisse auf einigen UI-Elementen des Haupt-Threads anzuzeigen. Ich weiß, dass ich hier nur die Theorie erkläre, aber versuchen Sie, das Konzept zu verstehen, denn ein tiefes Verständnis des Konzepts ist sehr wichtig. Ich werde unten einen Link posten, der Sie zu einer kleinen Videoreihe über Looper, Handler und HandlerThread führt, und ich empfehle Ihnen dringend, sich diese anzusehen, denn dort werden all diese Konzepte anhand von Beispielen erläutert.

https://www.youtube.com/watch?v=rfLMwbOKLRk&list=PL6nth5sRD25hVezlyqlBO9dafKMc5fAU2&index=1

Answer 3

Ich versuche, ein Beispiel in Kotlin zu geben. Hier ist unten der Code Beispiel.

Zunächst müssen wir die Variable Handler aus dem Handler instanziieren (der mitgelieferte Looper anstelle des Standardhandlers), der nach dem Hauptthread fragt (Looper.getMainLooper()).

Die Funktion getAllCourses() muss LiveData zurückgeben, so dass wir handler.postDelayed() verwenden, um der Nachrichtenwarteschlange hinzugefügt zu werden und nach x Millisekunden, die in der Konstante SERVICE_LATENCY_IN_MILLIS angegeben sind, ausgeführt zu werden.

Es steht Ihnen frei, meine Erklärung durch weitere Formulierungen zu ergänzen, um mehr Klarheit zu schaffen.

class RemoteDataSource private constructor(private val jsonHelper: JsonHelper) {

    private val handler = Handler(Looper.getMainLooper())

    companion object {
        private const val SERVICE_LATENCY_IN_MILLIS: Long = 2000

        @Volatile
        private var instance: RemoteDataSource? = null

        fun getInstance(helper: JsonHelper): RemoteDataSource =
                instance ?: synchronized(this) {
                    RemoteDataSource(helper).apply { instance = this }
                }
    }

    fun getAllCourses(): LiveData<ApiResponse<List<CourseResponse>>> {
        EspressoIdlingResource.increment()
        val resultCourse = MutableLiveData<ApiResponse<List<CourseResponse>>>()
        handler.postDelayed({
            resultCourse.value = ApiResponse.success(jsonHelper.loadCourses())
            EspressoIdlingResource.decrement()
        }, SERVICE_LATENCY_IN_MILLIS)
        return resultCourse
    }