Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden
Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden

Kategorien

Apache

Databases

Docker

JavaScript

Kubernetes

Linux Basis

MySQL

Python

React

Security

Ubuntu

AsyncTask in Android: Ein Leitfaden zur Hintergrundverarbeitung

Erfahren Sie, wie Sie mit Android AsyncTask schwere Aufgaben im Hintergrund ausführen und Ihre App reaktionsfähig halten. In diesem Tutorial zeigen wir Ihnen Schritt für Schritt, wie Sie AsyncTask implementieren und Ihre Benutzeroberfläche entlasten. Tauchen Sie ein in die Welt der effizienten Hintergrundverarbeitung für Android-Apps!

 

Was ist Android AsyncTask?

Android AsyncTask ist eine abstrakte Klasse, die es uns ermöglicht, schwere Aufgaben im Hintergrund auszuführen und gleichzeitig den UI-Thread leicht und reaktionsfähig zu halten. Android-Anwendungen laufen auf einem einzelnen Thread, was bedeutet, dass zeitaufwändige Aufgaben die Anwendung nicht reagieren lassen können. Um dies zu vermeiden, verwenden wir AsyncTask, um diese Aufgaben im Hintergrund auszuführen und die Ergebnisse an den UI-Thread zurückzugeben.

Wichtige Methoden der AsyncTask-Klasse

  1. doInBackground(): Hier wird der Code ausgeführt, der im Hintergrund laufen soll. Über die Methode publishProgress() können mehrmals Ergebnisse an den UI-Thread gesendet werden.
  2. onPreExecute(): Diese Methode wird ausgeführt, bevor die Hintergrundverarbeitung beginnt.
  3. onPostExecute(): Diese Methode wird nach Abschluss der Hintergrundverarbeitung aufgerufen und erhält das Ergebnis von doInBackground().
  4. onProgressUpdate(): Diese Methode empfängt Fortschrittsupdates von doInBackground(), veröffentlicht durch publishProgress().

Generische Typen der AsyncTask-Klasse

  1. Params: Typ der Parameter, die an die Aufgabe bei der Ausführung gesendet werden.
  2. Progress: Typ der Fortschrittseinheiten, die während der Hintergrundberechnung veröffentlicht werden.
  3. Result: Typ des Ergebnisses der Hintergrundberechnung.

Beispiel für eine AsyncTask-Anwendung

Um eine AsyncTask zu starten, muss der folgende Code in der MainActivity-Klasse vorhanden sein:

Copy<br /> Code 


MyTask myTask = new MyTask();
myTask.execute();

In diesem Beispiel haben wir eine Beispielklasse verwendet, die AsyncTask erweitert, und die execute-Methode wird verwendet, um den Hintergrundthread zu starten. Beachten Sie:

  • Die AsyncTask-Instanz muss im UI-Thread erstellt und aufgerufen werden.
  • Die in der AsyncTask-Klasse überschriebenen Methoden sollten niemals manuell aufgerufen werden, sie werden automatisch aufgerufen.
  • AsyncTask kann nur einmal aufgerufen werden, ein weiterer Aufruf führt zu einer Ausnahme.

Projektstruktur

Das XML-Layout ist in der activity_main.xml definiert und sieht wie folgt aus:

Copy<br /> Code 


<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <TextView
        android:id="@+id/tv_time"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="10pt"
        android:textColor="#444444"
        android:layout_alignParentLeft="true"
        android:layout_marginRight="9dip"
        android:layout_marginTop="20dip"
        android:layout_marginLeft="10dip"
        android:text="Sleep time in Seconds:"/>
    <EditText
        android:id="@+id/in_time"
        android:layout_width="150dip"
        android:layout_height="wrap_content"
        android:background="@android:drawable/editbox_background"
        android:layout_toRightOf="@id/tv_time"
        android:layout_alignTop="@id/tv_time"
        android:inputType="number"
        />
    <Button
        android:id="@+id/btn_run"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Run Async task"
        android:layout_below="@+id/in_time"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="64dp" />
    <TextView
        android:id="@+id/tv_result"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="7pt"
        android:layout_below="@+id/btn_run"
        android:layout_centerHorizontal="true" />
</RelativeLayout>

Java-Code für die MainActivity

Copy<br /> Code 


package com.journaldev.asynctask;

import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    private Button button;
    private EditText time;
    private TextView finalResult;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        time = (EditText) findViewById(R.id.in_time);
        button = (Button) findViewById(R.id.btn_run);
        finalResult = (TextView) findViewById(R.id.tv_result);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                AsyncTaskRunner runner = new AsyncTaskRunner();
                String sleepTime = time.getText().toString();
                runner.execute(sleepTime);
            }
        });
    }

    private class AsyncTaskRunner extends AsyncTask<String, String, String> {

        private String resp;
        ProgressDialog progressDialog;

        @Override
        protected String doInBackground(String... params) {
            publishProgress("Sleeping..."); // Calls onProgressUpdate()
            try {
                int time = Integer.parseInt(params[0])*1000;

                Thread.sleep(time);
                resp = "Slept for " + params[0] + " seconds";
            } catch (InterruptedException e) {
                e.printStackTrace();
                resp = e.getMessage();
            } catch (Exception e) {
                e.printStackTrace();
                resp = e.getMessage();
            }
            return resp;
        }

        @Override
        protected void onPostExecute(String result) {
            progressDialog.dismiss();
            finalResult.setText(result);
        }

        @Override
        protected void onPreExecute() {
            progressDialog = ProgressDialog.show(MainActivity.this,
                    "ProgressDialog",
                    "Wait for "+time.getText().toString()+ " seconds");
        }

        @Override
        protected void onProgressUpdate(String... text) {
            finalResult.setText(text[0]);
        }
    }
}

 

Fazit

Die AsyncTask-Klasse ermöglicht es Android-Entwicklern, zeitaufwändige Aufgaben im Hintergrund auszuführen und dabei die Benutzeroberfläche reaktionsfähig zu halten. Das obige Beispiel zeigt eine einfache Implementierung, bei der eine Aufgabe für eine bestimmte Zeit pausiert und den Fortschritt an die Benutzeroberfläche meldet.

Testen Sie unsere Cloud-Plattform für eine effiziente Android-Entwicklung!

Nutzen Sie die Vorteile unserer Cloud-Plattform und optimieren Sie Ihre Android-Apps mit AsyncTask. Starten Sie jetzt Ihre kostenlose Testversion und erleben Sie, wie unsere leistungsstarke Infrastruktur Ihre Entwicklung beschleunigt und vereinfacht. Keine Kreditkarte erforderlich, einfach registrieren und loslegen!

Try for free!

You might be interested in:

https://www.centron.de/en/glossary/server-2/
https://www.centron.de/en/glossary/query-2/