Android, wie man mit asyntasks progressdialog arbeitet

Asynctask hat 4 override-Methoden onPreExecute() , doInBackground() , onProgressUpdate() , onPostExecute() außer onProgressUpdate alle funktionieren. Was soll ich tun, damit onProgressUpdate () funktioniert? Kann mir bitte jemand kurz erklären, was nützt onProgressUpdate() , was sollte in diesem schreiben?

   

onProgressUpdate() wird verwendet, um den Fortschritt asynchroner Operationen über diese Methode zu steuern. Beachten Sie den Parameter mit dem Datentyp Integer . Dies entspricht dem zweiten Parameter in der classndefinition. Dieser callback kann innerhalb des Hauptteils der doInBackground() -Methode durch Aufrufen von publishProgress() .

Beispiel

 import android.app.Activity; import android.content.Context; import android.os.AsyncTask; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.TextView; public class AsyncTaskExample extends Activity { protected TextView _percentField; protected Button _cancelButton; protected InitTask _initTask; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); _percentField = (TextView) findViewById(R.id.percent_field); _cancelButton = (Button) findViewById(R.id.cancel_button); _cancelButton.setOnClickListener(new CancelButtonListener()); _initTask = new InitTask(); _initTask.execute(this); } protected class CancelButtonListener implements View.OnClickListener { public void onClick(View v) { _initTask.cancel(true); } } /** * sub-class of AsyncTask */ protected class InitTask extends AsyncTask { // -- run intensive processes here // -- notice that the datatype of the first param in the class definition matches the param passed to this // method // -- and that the datatype of the last param in the class definition matches the return type of this method @Override protected String doInBackground(Context... params) { // -- on every iteration // -- runs a while loop that causes the thread to sleep for 50 milliseconds // -- publishes the progress - calls the onProgressUpdate handler defined below // -- and increments the counter variable i by one int i = 0; while (i < = 50) { try { Thread.sleep(50); publishProgress(i); i++; } catch (Exception e) { Log.i("makemachine", e.getMessage()); } } return "COMPLETE!"; } // -- gets called just before thread begins @Override protected void onPreExecute() { Log.i("makemachine", "onPreExecute()"); super.onPreExecute(); } // -- called from the publish progress // -- notice that the datatype of the second param gets passed to this method @Override protected void onProgressUpdate(Integer... values) { super.onProgressUpdate(values); Log.i("makemachine", "onProgressUpdate(): " + String.valueOf(values[0])); _percentField.setText((values[0] * 2) + "%"); _percentField.setTextSize(values[0]); } // -- called if the cancel button is pressed @Override protected void onCancelled() { super.onCancelled(); Log.i("makemachine", "onCancelled()"); _percentField.setText("Cancelled!"); _percentField.setTextColor(0xFFFF0000); } // -- called as soon as doInBackground method completes // -- notice that the third param gets passed to this method @Override protected void onPostExecute(String result) { super.onPostExecute(result); Log.i("makemachine", "onPostExecute(): " + result); _percentField.setText(result); _percentField.setTextColor(0xFF69adea); _cancelButton.setVisibility(View.INVISIBLE); } } } 

Die 4 Schritte

Wenn eine asynchrone Task ausgeführt wird, durchläuft die Task 4 Schritte:

onPreExecute (), wird im UI-Thread aufgerufen, bevor die Task ausgeführt wird. Dieser Schritt wird normalerweise zum Einrichten der Aufgabe verwendet, z. B. durch Anzeigen einer Fortschrittsleiste in der Benutzeroberfläche.

doInBackground (Params …), wird im Hintergrund-Thread aufgerufen, unmittelbar nachdem onPreExecute () die Ausführung beendet hat. Dieser Schritt wird verwendet, um eine Hintergrundberechnung durchzuführen, die sehr lange dauern kann. Die Parameter der asynchronen Task werden an diesen Schritt übergeben. Das Ergebnis der Berechnung muss von diesem Schritt zurückgegeben werden und wird an den letzten Schritt zurückgegeben. Dieser Schritt kann auch publishProgress (Progress …) verwenden, um eine oder mehrere Fortschrittseinheiten zu veröffentlichen. Diese Werte werden im Schritt onProgressUpdate (Progress …) im UI-Thread veröffentlicht.

onProgressUpdate (Progress …), wird im UI-Thread nach einem Aufruf von publishProgress (Progress …) aufgerufen. Der Zeitpunkt der Ausführung ist nicht definiert. Diese Methode wird verwendet, um jede Art von Fortschritt in der Benutzerschnittstelle anzuzeigen, während die Hintergrundberechnung noch ausgeführt wird. Zum Beispiel kann damit eine Fortschrittsleiste animiert oder Protokolle in einem Textfeld angezeigt werden.

onPostExecute (Result), wird auf dem UI-Thread aufgerufen, nachdem die Hintergrundberechnung abgeschlossen ist. Das Ergebnis der Hintergrundberechnung wird diesem Schritt als Parameter übergeben.

Beispiel

 private class DownloadFilesTask extends AsyncTask { 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"); } } 

Die generischen Typen von AsyncTask Die drei Typen, die von einer asynchronen Task verwendet werden, sind die folgenden:

Params, der Typ der Parameter, die bei Ausführung an den Task gesendet werden.

Fortschritt, der Typ der Fortschritts-Einheiten, die während der Hintergrundberechnung veröffentlicht wurden.

Ergebnis, der Typ des Ergebnisses der Hintergrundberechnung.

Ja, Sie haben Recht, in AsyncTask gibt es vier Methoden

Wenn eine asynchrone Task ausgeführt wird, durchläuft die Task 4 Schritte:

 onPreExecute() 

Wird im UI-Thread unmittelbar nach der Ausführung der Task aufgerufen. Dieser Schritt wird normalerweise zum Einrichten der Aufgabe verwendet, z. B. durch Anzeigen einer Fortschrittsleiste in der Benutzeroberfläche.

 doInBackground(Params...) 

Wird im Hintergrundthread onPreExecute() unmittelbar nachdem onPreExecute() Ausführung beendet hat. Dieser Schritt wird verwendet, um eine Hintergrundberechnung durchzuführen, die sehr lange dauern kann. Die Parameter der asynchronen Task werden an diesen Schritt übergeben. Das Ergebnis der Berechnung muss von diesem Schritt zurückgegeben werden und wird an den letzten Schritt zurückgegeben. Dieser Schritt kann auch publishProgress(Progress...) , um eine oder mehrere Fortschrittseinheiten zu veröffentlichen. Diese Werte werden im Schritt onProgressUpdate(Progress...) im UI-Thread veröffentlicht.

 onProgressUpdate(Progress...) 

publishProgress(Progress...) nach einem Aufruf von publishProgress(Progress...) im UI-Thread publishProgress(Progress...) . Der Zeitpunkt der Ausführung ist nicht definiert. Diese Methode wird verwendet, um jede Art von Fortschritt in der Benutzerschnittstelle anzuzeigen, während die Hintergrundberechnung noch ausgeführt wird. Zum Beispiel kann damit eine Fortschrittsleiste animiert oder Protokolle in einem Textfeld angezeigt werden.

 onPostExecute(Result) 

Wird auf dem UI-Thread nach Abschluss der Hintergrundberechnung aufgerufen. Das Ergebnis der Hintergrundberechnung wird diesem Schritt als Parameter übergeben.

Für weitere Informationen klicken Sie hier

onProgressUpdate wird auf dem UI-Thread ausgeführt, nachdem publishProgress aufgerufen wurde. Aus der AsyncTask-Dokumentation – Ihr Code sollte ungefähr so ​​aussehen

 private class DownloadFilesTask extends AsyncTask { 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)); } return totalSize; } protected void onProgressUpdate(Integer... progress) { setProgressPercent(progress[0]); } protected void onPostExecute(Long result) { showDialog("Downloaded " + result + " bytes"); } } 
 hey this might help you?? 

Der Fortschrittsbalken wird automatisch verschwinden, wenn Sie die Antwort erhalten

 User_AsyncTaskk extends AsyncTask public class User_AsyncTask extends AsyncTask { String response = ""; @Override protected void onPreExecute() { try { if (progressDialog != null) progressDialog.cancel(); } catch (Exception e) { } progressDialog = ProgressDialog.show(DisplayDetails.this, "", "Please wait...", true, true); progressDialog.setCancelable(false); progressDialog.show(); } protected String doInBackground(String... params) { try { //Complete ur Code Log.i("AUTO ", "response is : " + response); return response; } catch (Exception e) { } } @Override protected void onPostExecute(String s) { if (progressDialog != null) { progressDialog.dismiss(); progressDialog = null; } try { } catch (Exception e) { } }