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
doInBackground(): Hier wird der Code ausgeführt, der im Hintergrund laufen soll. Über die MethodepublishProgress()können mehrmals Ergebnisse an den UI-Thread gesendet werden.onPreExecute(): Diese Methode wird ausgeführt, bevor die Hintergrundverarbeitung beginnt.onPostExecute(): Diese Methode wird nach Abschluss der Hintergrundverarbeitung aufgerufen und erhält das Ergebnis vondoInBackground().onProgressUpdate(): Diese Methode empfängt Fortschrittsupdates vondoInBackground(), veröffentlicht durchpublishProgress().
Generische Typen der AsyncTask-Klasse
- Params: Typ der Parameter, die an die Aufgabe bei der Ausführung gesendet werden.
- Progress: Typ der Fortschrittseinheiten, die während der Hintergrundberechnung veröffentlicht werden.
- 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:
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:
<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
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.
