Ich las über AsyncTask
und versuchte das einfache Programm unten. Aber es scheint nicht zu funktionieren. Wie kann ich es funktionieren lassen?
public class AsyncTaskActivity extends Activity {
Button btn;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = (Button) findViewById(R.id.button1);
btn.setOnClickListener((OnClickListener) this);
}
public void onClick(View view){
new LongOperation().execute("");
}
private class LongOperation extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... params) {
for(int i=0;i<5;i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
return null;
}
@Override
protected void onPostExecute(String result) {
}
@Override
protected void onPreExecute() {
}
@Override
protected void onProgressUpdate(Void... values) {
}
}
}
Ich versuche gerade, das Etikett nach 5 Sekunden im Hintergrund zu ändern.
Das ist meine main.xml :
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="fill_parent"
Android:layout_height="fill_parent"
Android:orientation="vertical" >
<ProgressBar
Android:id="@+id/progressBar"
style="?android:attr/progressBarStyleHorizontal"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:indeterminate="false"
Android:max="10"
Android:padding="10dip">
</ProgressBar>
<Button
Android:id="@+id/button1"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text="Start Progress" >
</Button>
<TextView Android:id="@+id/output"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:text="Replace"/>
</LinearLayout>
Ok, Sie versuchen über einen anderen Thread auf die GUI zuzugreifen. Dies ist im Wesentlichen keine gute Praxis.
Die AsyncTask führt alles in doInBackground()
innerhalb eines anderen Threads aus, der keinen Zugriff auf die GUI hat, in der sich Ihre Ansichten befinden.
preExecute()
und postExecute()
bieten Ihnen Zugriff auf die grafische Benutzeroberfläche, bevor und nachdem das schwere Anheben in diesem neuen Thread erfolgt. Sie können sogar das Ergebnis des langen Vorgangs an postExecute()
übergeben, um dann alle Ergebnisse der Verarbeitung anzuzeigen.
Sehen Sie sich diese Zeilen an, wo Sie Ihre TextView später aktualisieren:
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
setze sie in PostExecute()
Anschließend wird der TextView-Text nach Abschluss der doInBackground
-Datei aktualisiert.
EDIT: Ich habe festgestellt, dass Ihr onClick-Listener nicht prüft, welche Ansicht ausgewählt wurde. Am einfachsten finde ich das über Schalteranweisungen. Ich habe eine vollständige Klasse mit allen Vorschlägen, um Verwirrung zu speichern.
import Android.app.Activity;
import Android.os.AsyncTask;
import Android.os.Bundle;
import Android.provider.Settings.System;
import Android.view.View;
import Android.widget.Button;
import Android.widget.TextView;
import Android.view.View.OnClickListener;
public class AsyncTaskActivity extends Activity implements OnClickListener {
Button btn;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = (Button) findViewById(R.id.button1);
// because we implement OnClickListener we only have to pass "this"
// (much easier)
btn.setOnClickListener(this);
}
public void onClick(View view) {
// detect the view that was "clicked"
switch (view.getId()) {
case R.id.button1:
new LongOperation().execute("");
break;
}
}
private class LongOperation extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... params) {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.interrupted();
}
}
return "Executed";
}
@Override
protected void onPostExecute(String result) {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed"); // txt.setText(result);
// might want to change "executed" for the returned string passed
// into onPostExecute() but that is upto you
}
@Override
protected void onPreExecute() {}
@Override
protected void onProgressUpdate(Void... values) {}
}
}
Meine vollständige Antwort ist hier , aber hier ist ein erläuterndes Bild, um die anderen Antworten auf dieser Seite zu ergänzen. Für mich war es am Anfang am verwirrendsten, zu wissen, wo alle Variablen hingingen.
Ich bin sicher, dass es ordnungsgemäß ausgeführt wird, aber Sie versuchen, die Benutzeroberflächenelemente im Hintergrund-Thread zu ändern.
Überarbeiten Sie Ihren Anruf und Ihre AsyncTask wie folgt:
Klasse aufrufen
Hinweis: Ich persönlich empfehle die Verwendung von onPostExecute()
überall dort, wo Sie Ihren AsyncTask-Thread ausführen, und nicht in der Klasse, die AsyncTask selbst erweitert. Ich denke, es macht den Code leichter zu lesen, besonders wenn Sie die AsyncTask an mehreren Stellen benötigen, um die Ergebnisse etwas anders zu behandeln.
new LongThread()
{
@Override public void onPostExecute(String result)
{
TextView txt = (TextView) findViewById(R.id.output);
txt.setText(result);
}
}.execute("");
LongThread-Klasse (erweitert AsyncTask):
@Override
protected String doInBackground(String... params) {
for(int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return "Executed";
}
Ich habe ein einfaches Beispiel für die Verwendung von AsyncTask von Android erstellt. Es beginnt mit onPreExecute(), doInBackground(), publishProgress()
und schließlich onProgressUpdate()
.
In diesem Fall arbeitet doInBackground () als Hintergrund-Thread, während andere im UI-Thread arbeiten. Sie können in doInBackground () nicht auf ein Oberflächenelement zugreifen. Die Reihenfolge ist dieselbe wie ich erwähnt habe.
Wenn Sie jedoch ein Widget von doInBackground
aus aktualisieren müssen, können Sie publishProgress
von doInBackground
aus aufrufen, wodurch onProgressUpdate
aufgerufen wird, um Ihr UI-Widget zu aktualisieren.
class TestAsync extends AsyncTask<Void, Integer, String>
{
String TAG = getClass().getSimpleName();
protected void onPreExecute (){
super.onPreExecute();
Log.d(TAG + " PreExceute","On pre Exceute......");
}
protected String doInBackground(Void...arg0) {
Log.d(TAG + " DoINBackGround","On doInBackground...");
for(int i=0; i<10; i++){
Integer in = new Integer(i);
publishProgress(i);
}
return "You are at PostExecute";
}
protected void onProgressUpdate(Integer...a){
super.onProgressUpdate(a);
Log.d(TAG + " onProgressUpdate", "You are in progress update ... " + a[0]);
}
protected void onPostExecute(String result) {
super.onPostExecute(result);
Log.d(TAG + " onPostExecute", "" + result);
}
}
Nenne es in deiner Aktivität so:
new TestAsync().execute();
Verschieben Sie diese beiden Zeilen:
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
aus der AsyncTask-Methode doInBackground
und fügen Sie sie in die Methode onPostExecute
ein. Ihre AsyncTask
sollte ungefähr so aussehen:
private class LongOperation extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... params) {
try {
Thread.sleep(5000); // no need for a loop
} catch (InterruptedException e) {
Log.e("LongOperation", "Interrupted", e);
return "Interrupted";
}
return "Executed";
}
@Override
protected void onPostExecute(String result) {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText(result);
}
}
AsyncTask ermöglicht das Ausführen einer Aufgabe in einem Hintergrundthread, während die Ergebnisse im UI-Thread veröffentlicht werden.
Der Benutzer sollte immer in der Lage sein, mit der App zu interagieren, damit wichtigm das Blockieren des Hauptthreads (UI) zu vermeiden mit Aufgaben wie dem Herunterladen von Inhalten aus dem Web.
Deshalb verwenden wir ein
AsyncTask
.Es bietet eine unkomplizierte Oberfläche, indem die Nachrichtenwarteschlange und den Handler des UI-Threads umbrochen werden, mit denen Sie ausführbare Objekte und Nachrichten von anderen Threads senden und verarbeiten können.
AsyncTask ist eine generische Klasse. (Es braucht parametrisierte Typen in seinem Konstruktor.)
Es verwendet diese drei generische Typen:
Params
- Der Typ der Parameter, die bei der Ausführung an die Task gesendet werden.
Progress
- Der Typ der während der Hintergrundberechnung veröffentlichten Fortschrittseinheiten.
Result
- Der Typ des Ergebnisses der Hintergrundberechnung.
Nicht alle Typen werden immer von einer asynchronen Task verwendet. Um einen Typ als unbenutzt zu markieren, verwenden Sie einfach den Typ Void:
private class MyTask extends AsyncTask<Void, Void, Void> { ... }
Diese drei Parameter entsprechen drei Hauptfunktionen Sie können AsyncTask
überschreiben:
doInBackground(Params...)
onProgressUpdate(Progress...)
onPostExecute(Result)
m AsyncTask auszuführen
execute()
mit Parametern auf, die an die Hintergrundaufgabe gesendet werden sollen.Was passiert
On Haupt-/UI-Thread, onPreExecute()
wird aufgerufen.
Auf einem Hintergrund-Thread wird doInBackground(Params...)
aufgerufen.
Params
wurden über execute
übergeben.)Muss mindestens doInBackground()
überschreiben, um AsyncTask verwenden zu können.
Rufen Sie publishProgress(Progress...)
auf, um die Benutzeroberfläche mit einer Fortschrittsanzeige (z. B. UI-Animation oder gedruckter Protokolltext) zu aktualisieren, während die Hintergrundberechnung noch ausgeführt wird.
onProgressUpdate()
aufgerufen wird.Am Hintergrund-Thread wird ein Ergebnis von doInBackground()
zurückgegeben.
On main/UI thread, onPostExecute()
wird mit dem zurückgegebenen Ergebnis aufgerufen.
In beiden Beispielen ist die "Blockierungsaufgabe" ein Download aus dem Internet.
Die Methode doInBackground()
lädt das Bild herunter und speichert es in einem Objekt vom Typ BitMap. Die onPostExecute()
-Methode nimmt die Bitmap und platziert sie in der ImageView.
class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
ImageView bitImage;
public DownloadImageTask(ImageView bitImage) {
this.bitImage = bitImage;
}
protected Bitmap doInBackground(String... urls) {
String urldisplay = urls[0];
Bitmap mBmp = null;
try {
InputStream in = new Java.net.URL(urldisplay).openStream();
mBmp = BitmapFactory.decodeStream(in);
} catch (Exception e) {
Log.e("Error", e.getMessage());
e.printStackTrace();
}
return mBmp;
}
protected void onPostExecute(Bitmap result) {
bitImage.setImageBitmap(result);
}
}
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}
Ausführung von Beispiel B
new DownloadFilesTask().execute(url1, url2, url3);
Wenn eine asynchrone Task ausgeführt wird, durchläuft die Task 4 Schritte:
Unten ist ein Demo-Beispiel
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
protected Long doInBackground(URL... urls) {
int count = urls.length;
long totalSize = 0;
for (int i = 0; i < count; i++) {
totalSize += Downloader.downloadFile(urls[i]);
publishProgress((int) ((i / (float) count) * 100));
// Escape early if cancel() is called
if (isCancelled()) break;
}
return totalSize;
}
protected void onProgressUpdate(Integer... progress) {
setProgressPercent(progress[0]);
}
protected void onPostExecute(Long result) {
showDialog("Downloaded " + result + " bytes");
}
}
und wenn Sie einmal erstellt haben, wird eine Aufgabe sehr einfach ausgeführt:
new DownloadFilesTask().execute(url1, url2, url3);
Ich hoffe, dies wird dir helfen...
Das kürzeste Beispiel, um etwas asynchron zu machen:
class MyAsyncTask extends Android.os.AsyncTask {
@Override
protected Object doInBackground(Object[] objects) {
//do something asynchronously
return null;
}
}
Um es auszuführen:
(new MyAsyncTask()).execute();
Wenn Sie sich im Arbeitsthread befinden, können Sie die Benutzeroberflächenelemente auf Android nicht direkt bearbeiten.
Wenn Sie AsyncTask verwenden, verstehen Sie die Callback-Methoden.
Zum Beispiel:
public class MyAyncTask extends AsyncTask<Void, Void, Void>{
@Override
protected void onPreExecute() {
// Here you can show progress bar or something on the similar lines.
// Since you are in a UI thread here.
super.onPreExecute();
}
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
// After completing execution of given task, control will return here.
// Hence if you want to populate UI elements with fetched data, do it here.
}
@Override
protected void onProgressUpdate(Void... values) {
super.onProgressUpdate(values);
// You can track you progress update here
}
@Override
protected Void doInBackground(Void... params) {
// Here you are in the worker thread and you are not allowed to access UI thread from here.
// Here you can perform network operations or any heavy operations you want.
return null;
}
}
FYI: Um von einem Arbeitsthread auf den UI-Thread zuzugreifen, verwenden Sie entweder die runOnUiThread () - Methode oder die post-Methode für Ihre Ansicht.
Zum Beispiel:
runOnUiThread(new Runnable() {
textView.setText("something.");
});
or
yourview.post(new Runnable() {
yourview.setText("something");
});
Dies hilft Ihnen, die Dinge besser zu kennen. In Ihrem Fall müssen Sie daher Ihre Textansicht in der onPostExecute () -Methode festlegen.
Nicht
Wenn Sie mit AsyncTask noch nicht vertraut sind, werden Sie beim Schreiben einer AsyncTask häufig verwirrt. Haupttäter sind die in der AsyncTask verwendeten Parameter, dh AsyncTask<A,B,C>
. Basierend auf der A unterscheidet sich die Signatur der Methoden B, C (Argumente), was die Sache noch verwirrender macht.
Der Schlüssel ist Nicht merken. Wenn Sie sich vorstellen können, was Ihre Aufgabe wirklich tun muss, dann wäre das Schreiben der AsyncTask mit der richtigen Signatur beim ersten Versuch ein Kinderspiel. Finden Sie einfach heraus, was Ihre Eingabe, Ihr Fortschritt und Ihre Ausgabe sind, und Sie werden gut sein.
AsyncTask sind Hintergrundaufgaben, die im Hintergrundthread ausgeführt werden. Es nimmt einen Input, führt Progress aus und gibt Output.
dh
AsyncTask<Input,Progress,Output>
.
Zwischen
AsyncTask
unddoInBackground()
doInBackground()
undonPostExecute(),
onProgressUpdate () `sind auch verbunden
Wie schreibe ich das in den Code?
DownloadTask extends AsyncTask<String,Integer,String>{
// Always same signature
@Override
public void onPreExecute()
{}
@Override
public String doInbackGround(String... params)
{
// Download code
int downloadPerc = // calculate that
publish(downloadPerc);
return "Download Success";
}
@Override
public void onPostExecute(String result)
{
super.onPostExecute(result);
}
@Override
public void onProgressUpdate(Integer... params)
{
// show in spinner, access UI elements
}
}
Wie werden Sie diese Aufgabe ausführen?
new DownLoadTask().execute("Paradise.mp3");
Ich würde empfehlen, Ihr Leben zu erleichtern, indem Sie diese Bibliothek für Hintergrundarbeiten verwenden https://github.com/Arasthel/AsyncJobLibrary
es ist so einfach ..
AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {
@Override
public void doOnBackground() {
startRecording();
}
});
Detaillierte Anleitung zur AsyncTask-Erklärung
Was ist AsyncTask?
AsyncTask ist eine Android-Klasse, mit der wir komplexe Vorgänge wie z
Es lindert die Spannung der Entwickler
Wenn du
AsyncTask ist keine bessere Option für Sie. AsyncTask wird hauptsächlich für kurze Operationen verwendet (höchstens einige Sekunden)
Wie verwende ich AsyncTask in deiner App?
AsyncTask verwendet Generics-Datentypen
AsyncTask hilft uns, die Benutzeroberfläche innerhalb ihrer Methoden zu aktualisieren.
Diese Methoden werden auf dem Hauptthread ausgeführt. Deshalb können Sie UI-Elemente aktualisieren.
Füge deine schwierige Aufgabe in doInBackgrund () hinzu
und rufen Sie AsyncTask mit execute () method auf.
Vollständiger ausführlicher Tutorial-Link unten
Beispiel für eine asynchrone Aufgabe mit der Anforderung POST:
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("key1", "value1"));
params.add(new BasicNameValuePair("key1", "value2"));
new WEBSERVICEREQUESTOR(URL, params).execute();
class WEBSERVICEREQUESTOR extends AsyncTask<String, Integer, String>
{
String URL;
List<NameValuePair> parameters;
private ProgressDialog pDialog;
public WEBSERVICEREQUESTOR(String url, List<NameValuePair> params)
{
this.URL = url;
this.parameters = params;
}
@Override
protected void onPreExecute()
{
pDialog = new ProgressDialog(LoginActivity.this);
pDialog.setMessage("Processing Request...");
pDialog.setIndeterminate(false);
pDialog.setCancelable(false);
pDialog.show();
super.onPreExecute();
}
@Override
protected String doInBackground(String... params)
{
try
{
DefaultHttpClient httpClient = new DefaultHttpClient();
HttpEntity httpEntity = null;
HttpResponse httpResponse = null;
HttpPost httpPost = new HttpPost(URL);
if (parameters != null)
{
httpPost.setEntity(new UrlEncodedFormEntity(parameters));
}
httpResponse = httpClient.execute(httpPost);
httpEntity = httpResponse.getEntity();
return EntityUtils.toString(httpEntity);
} catch (Exception e)
{
}
return "";
}
@Override
protected void onPostExecute(String result)
{
pDialog.dismiss();
try
{
}
catch (Exception e)
{
}
super.onPostExecute(result);
}
}
Einfach:
LongOperation MyTask = new LongOperation();
MyTask.execute();
private class AsyncTaskDemo extends AsyncTask<Void, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
// Showing progress dialog
progressDialog = new ProgressDialog(this);
progressDialog.setMessage("Loading...");
progressDialog.setCancelable(false);
progressDialog.show();
}
@Override
protected Void doInBackground(Void... arg0) {
//do code here
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
// Dismiss the progress dialog
if (progressDialog.isShowing()) {
progressDialog.dismiss();
}
}
@Override
protected void onCancelled() {
super.onCancelled();
progressDialog.dismiss();
Toast toast = Toast.makeText(getActivity(),
"Error is occured due to some probelm", Toast.LENGTH_LONG);
toast.setGravity(Gravity.TOP, 25, 400);
toast.show();
}
}
Sie müssen die Schaltfläche onclicklistener deklarieren. Sobald Sie die AsyncTask-Klasse DownloadJson aufgerufen haben, wird der Vorgang unten angezeigt:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btn = (Button) findViewById(R.id.button1);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new DownloadJson().execute();
}
});
}
// DownloadJSON AsyncTask
private class DownloadJson extends AsyncTask<Void, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected Void doInBackground(Void... params) {
newlist = new ArrayList<HashMap<String, String>>();
json = jsonParser.makeHttpRequest(json, "POST");
try {
newarray = new JSONArray(json);
for (int i = 0; i < countdisplay; i++) {
HashMap<String, String> eachnew = new HashMap<String, String>();
newobject = newarray.getJSONObject(i);
eachnew.put("id", newobject.getString("ID"));
eachnew.put("name", newobject.getString("Name"));
newlist.add(eachnew);
}
}
} catch (JSONException e) {
Log.e("Error", e.getMessage());
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(Void args) {
newlisttemp.addAll(newlist);
NewAdapterpager newadapterpager = new NewAdapterpager(ProcesssActivitypager.this,newlisttemp);
newpager.setAdapter(newadapterpager);
}
}
Ändern Sie Ihren Code wie folgt:
@Override
protected void onPostExecute(String result) {
runOnUiThread(new Runnable() {
public void run() {
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");
}
});
}
Während der Arbeit mit AsyncTask ist es notwendig, einen Klassennachfolger anzulegen und darin die Implementierung der für uns notwendigen Methoden zu registrieren. In dieser Lektion werden drei Methoden behandelt:
doInBackground - wird in einem neuen Thread ausgeführt, hier lösen wir alle unsere schwierigen Aufgaben. Da nicht-primärer Thread - hat keinen Zugriff auf die Benutzeroberfläche.
onPreExecute - Wird vor doInBackground ausgeführt und hat Zugriff auf die Benutzeroberfläche
onPostExecute - wird nach doInBackground ausgeführt (funktioniert nicht, wenn AsyncTask abgebrochen wurde - dazu in den nächsten Lektionen), hat Zugriff auf die Benutzeroberfläche
Diese MyAsyncTask-Klasse
class MyAsyncTask extends AsyncTask<Void, Void, Void> {
@Override
protected void onPreExecute() {
super.onPreExecute();
tvInfo.setText("Start");
}
@Override
protected Void doInBackground(Void... params) {
//your background method
return null;
}
@Override
protected void onPostExecute(Void result) {
super.onPostExecute(result);
tvInfo.setText("Finish");
}
}
Und so rufen Sie Ihre Aktivität oder Ihr Fragment auf
MyAsyncTask myAsyncTask = new MyAsyncTask ();
myAsyncTask.execute();
Beispiel für AsyncTask-Beispiel mit Fortschritt
import Android.animation.ObjectAnimator;
import Android.os.AsyncTask;
import Android.support.v7.app.AppCompatActivity;
import Android.os.Bundle;
import Android.util.Log;
import Android.view.View;
import Android.view.animation.AccelerateDecelerateInterpolator;
import Android.view.animation.DecelerateInterpolator;
import Android.view.animation.LinearInterpolator;
import Android.widget.Button;
import Android.widget.ProgressBar;
import Android.widget.TextView;
public class AsyncTaskActivity extends AppCompatActivity implements View.OnClickListener {
Button btn;
ProgressBar progressBar;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn = (Button) findViewById(R.id.button1);
btn.setOnClickListener(this);
progressBar = (ProgressBar)findViewById(R.id.pbar);
}
public void onClick(View view) {
switch (view.getId()) {
case R.id.button1:
new LongOperation().execute("");
break;
}
}
private class LongOperation extends AsyncTask<String, Integer, String> {
@Override
protected String doInBackground(String... params) {
Log.d("AsyncTask", "doInBackground");
for (int i = 0; i < 5; i++) {
try {
Log.d("AsyncTask", "task "+(i + 1));
publishProgress(i + 1);
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.interrupted();
}
}
return "Completed";
}
@Override
protected void onPostExecute(String result) {
Log.d("AsyncTask", "onPostExecute");
TextView txt = (TextView) findViewById(R.id.output);
txt.setText(result);
progressBar.setProgress(0);
}
@Override
protected void onPreExecute() {
Log.d("AsyncTask", "onPreExecute");
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("onPreExecute");
progressBar.setMax(500);
progressBar.setProgress(0);
}
@Override
protected void onProgressUpdate(Integer... values) {
Log.d("AsyncTask", "onProgressUpdate "+values[0]);
TextView txt = (TextView) findViewById(R.id.output);
txt.setText("onProgressUpdate "+values[0]);
ObjectAnimator animation = ObjectAnimator.ofInt(progressBar, "progress", 100 * values[0]);
animation.setDuration(1000);
animation.setInterpolator(new LinearInterpolator());
animation.start();
}
}
}
ASync-Aufgabe;
public class MainActivity extends AppCompatActivity {
private String ApiUrl="your_api";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
MyTask myTask=new MyTask();
try {
String result=myTask.execute(ApiUrl).get();
Toast.makeText(getApplicationContext(),result,Toast.LENGTH_SHORT).show();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public class MyTask extends AsyncTask<String,Void,String>{
@Override
protected String doInBackground(String... strings) {
String result="";
HttpURLConnection httpURLConnection=null;
URL url;
try {
url=new URL(strings[0]);
httpURLConnection=(HttpURLConnection) url.openConnection();
InputStream inputStream=httpURLConnection.getInputStream();
InputStreamReader reader=new InputStreamReader(inputStream);
result=getData(reader);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
public String getData(InputStreamReader reader) throws IOException{
String result="";
int data=reader.read();
while (data!=-1){
char now=(char) data;
result+=data;
data=reader.read();
}
return result;
}
}
}