Je lisais AsyncTasket j'ai essayé le programme simple ci-dessous. Mais cela ne semble pas fonctionner. Comment puis-je le faire fonctionner?

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) {
        }
    }
}

J'essaie juste de changer l'étiquette après 5 secondes en arrière-plan.

Voici mon 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, vous essayez d'accéder à l'interface graphique via un autre thread. Ceci, dans l'ensemble, n'est pas une bonne pratique.

L'AsyncTask exécute tout à l' doInBackground()intérieur d'un autre thread, qui n'a pas accès à l'interface graphique où se trouvent vos vues.

preExecute()et postExecute()vous offre un accès à l'interface graphique avant et après le levage de charges lourdes dans ce nouveau thread, et vous pouvez même transmettre le résultat de la longue opération à postExecute()pour afficher ensuite les résultats du traitement.

Voir ces lignes où vous mettez ultérieurement à jour votre TextView:

TextView txt = findViewById(R.id.output);
txt.setText("Executed");

Mettez-les onPostExecute().

Vous verrez alors votre texte TextView mis à jour après la doInBackgroundfin.

J'ai remarqué que votre écouteur onClick ne vérifie pas quelle vue a été sélectionnée. Je trouve que la façon la plus simple de le faire est via les instructions switch. J'ai un cours complet édité ci-dessous avec toutes les suggestions pour éviter la confusion.

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;
    AsyncTask<?, ?, ?> runningTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        btn = findViewById(R.id.button1);

        // Because we implement OnClickListener, we only
        // have to pass "this" (much easier)
        btn.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        // Detect the view that was "clicked"
        switch (view.getId()) {
        case R.id.button1:
            if (runningTask != null)
                runningTask.cancel(true);
            runningTask = new LongOperation();
            runningTask.execute();
            break;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Cancel running task(s) to avoid memory leaks
        if (runningTask != null)
            runningTask.cancel(true);
    }

    private final class LongOperation extends AsyncTask<Void, Void, String> {

        @Override
        protected String doInBackground(Void... params) {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // We were cancelled; stop sleeping!
                }
            }
            return "Executed";
        }

        @Override
        protected void onPostExecute(String result) {
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText("Executed"); // txt.setText(result);
            // You might want to change "executed" for the returned string
            // passed into onPostExecute(), but that is up to you
        }
    }
}

Ma réponse complète est ici , mais voici une image explicative pour compléter les autres réponses sur cette page. Pour moi, comprendre où allaient toutes les variables était la partie la plus déroutante au début.

Je suis sûr qu'il s'exécute correctement, mais vous essayez de modifier les éléments d'interface utilisateur dans le thread d'arrière-plan et cela ne fonctionnera pas.

Modifiez votre appel et AsyncTask comme suit:

Classe d'appel

Remarque: Je suggère personnellement d'utiliser onPostExecute()partout où vous exécutez votre thread AsyncTask et non dans la classe qui étend AsyncTask elle-même. Je pense que cela rend le code plus facile à lire, surtout si vous avez besoin de AsyncTask à plusieurs endroits pour gérer les résultats légèrement différents.

new LongThread() {
    @Override public void onPostExecute(String result) {
        TextView txt = (TextView) findViewById(R.id.output);
        txt.setText(result);
    }
}.execute("");

Classe LongThread (étend 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";
}      

Concept et code ici

J'ai créé un exemple simple d'utilisation d'AsyncTask d'Android. Cela commence par onPreExecute(), doInBackground(), publishProgress()et enfin onProgressUpdate().

En cela, doInBackground () fonctionne comme un thread d'arrière-plan, tandis que d'autres fonctionnent dans le thread d'interface utilisateur. Vous ne pouvez pas accéder à un élément d'interface utilisateur dans doInBackground (). La séquence est la même que celle que j'ai mentionnée.

Cependant, si vous devez mettre à jour un widget à partir de doInBackground, vous pouvez appeler à publishProgresspartir doInBackgroundduquel mettre onProgressUpdateà jour votre widget UI.

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);
    }
}

Appelez ça comme ça dans votre activité:

new TestAsync().execute();

Référence développeur ici

Déplacez ces deux lignes:

TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");

hors de la doInBackgroundméthode de votre AsyncTask et les mettre dans la onPostExecuteméthode. Votre AsyncTaskdevrait ressembler à ceci:

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);
    }
}

Contexte / Théorie

AsyncTask vous permet d'exécuter une tâche sur un thread d'arrière-plan, tout en publiant les résultats sur le thread d'interface utilisateur.

L'utilisateur doit toujours pouvoir interagir avec l'application, il est donc important d'éviter de bloquer le thread principal (UI) avec des tâches telles que le téléchargement de contenu à partir du Web.

C'est pourquoi nous utilisons un AsyncTask.

Il offre une interface simple en encapsulant la file d'attente de messages de threads d'interface utilisateur et le gestionnaire qui vous permettent d'envoyer et de traiter des objets exécutables et des messages à partir d'autres threads .

la mise en oeuvre

AsyncTask est une classe générique. (Il prend des types paramétrés dans son constructeur.)

Il utilise ces trois types génériques:

Params - le type des paramètres envoyés à la tâche lors de l'exécution.

Progress - le type des unités de progression publiées lors du calcul en arrière-plan.

Result - le type du résultat du calcul d'arrière-plan.

Tous les types ne sont pas toujours utilisés par une tâche asynchrone. Pour marquer un type comme inutilisé, utilisez simplement le type Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

Ces trois paramètres correspondent à trois fonctions principales dans lesquelles vous pouvez remplacer AsyncTask:

• doInBackground(Params...)
• onProgressUpdate(Progress...)
• onPostExecute(Result)

Pour exécuter AsyncTask

• Appel execute()avec paramètres à envoyer à la tâche en arrière-plan.

Ce qui se produit

1. Sur le thread principal / UI , onPreExecute()est appelé.

   • Pour initialiser quelque chose dans ce fil. (Par exemple, afficher une barre de progression sur l'interface utilisateur.)

2. Sur un fil d'arrière - plan , doInBackground(Params...)est appelé.

   • ( Paramsont été passés via execute.)
   • Où la tâche de longue haleine devrait se produire.

   • Doit remplacer au moins doInBackground()pour utiliser AsyncTask.

   • Appelez publishProgress(Progress...)pour mettre à jour l'interface utilisateur avec un affichage de la progression (par exemple, animation de l'interface utilisateur ou texte du journal imprimé) pendant que le calcul en arrière-plan est toujours en cours d'exécution.

     • Fait onProgressUpdate()appeler.

3. Sur le thread d'arrière - plan, un résultat est renvoyé par doInBackground().

   • (Cela déclenche l'étape suivante.)

4. Sur le thread principal / UI , onPostExecute()est appelé avec le résultat renvoyé.

Exemples

Dans les deux exemples, la «tâche de blocage» est un téléchargement à partir du Web.

• L'exemple A télécharge une image et l'affiche dans une ImageView, tandis que
• L'exemple B télécharge certains fichiers .

Exemple A

La doInBackground()méthode télécharge l'image et la stocke dans un objet de type BitMap. La onPostExecute()méthode prend le bitmap et le place dans 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);
    }
}

Exemple B

 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");
     }
 }

Exemple d'exécution B

new DownloadFilesTask().execute(url1, url2, url3);

Lorsqu'une tâche asynchrone est exécutée, la tâche passe par quatre étapes:

1. onPreExecute ()
2. doInBackground (Params ...)
3. onProgressUpdate (Progress ...)
4. onPostExecute (Résultat)

Voici un exemple de démonstration:

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");
    }
 }

Et une fois que vous avez créé, une tâche est exécutée très simplement:

new DownloadFilesTask().execute(url1, url2, url3);

Exemple le plus court pour faire simplement quelque chose de manière asynchrone:

class MyAsyncTask extends android.os.AsyncTask {
    @Override
    protected Object doInBackground(Object[] objects) {
        // Do something asynchronously
        return null;
    }
}

Pour l'exécuter:

(new MyAsyncTask()).execute();

Comment mémoriser les paramètres utilisés dans AsyncTask?

Ne le fais pas

Si vous êtes nouveau dans AsyncTask, il est très courant de se tromper lors de l'écriture d'une AsyncTask. Les principaux coupables sont les paramètres utilisés dans la tâche AsyncTask, c'est-à-dire AsyncTask<A, B, C>. Sur la base des A, B, C (arguments) signature des méthodes, ce qui rend les choses encore plus confuses.

Rester simple!

La clé est de ne pas mémoriser . Si vous pouvez visualiser ce que votre tâche doit vraiment faire, écrire la tâche AsyncTask avec la signature correcte à la première tentative serait un jeu d'enfant. Il suffit de comprendre ce que votre Input, Progresset Outputsont, et vous serez bon d'aller.

Qu'est-ce qu'une AsyncTask?

AsyncTask est une tâche d'arrière-plan qui s'exécute dans le thread d'arrière-plan. Il prend un Input, effectue Progresset donne un Output.

-À- dire , AsyncTask<Input, Progress, Output>.

Par exemple:

Quelle est la relation avec les méthodes?

Entre AsyncTasketdoInBackground()

doInBackground()et onPostExecute(),onProgressUpdate () `sont également liés

Comment écrire cela dans le code?

DownloadTask extends AsyncTask<String, Integer, String>{

    // Always same signature
    @Override
    public void onPreExecute()
    {}

    @Override
    public String doInbackGround(String... parameters)
    {
        // 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... parameters)
    {
        // Show in spinner, and access UI elements
    }

}

Comment allez-vous exécuter cette tâche?

new DownLoadTask().execute("Paradise.mp3");

Lorsque vous êtes dans le thread de travail, vous ne pouvez pas manipuler directement les éléments de l'interface utilisateur sur Android.

Lorsque vous utilisez AsyncTask, veuillez comprendre les méthodes de rappel.

Par exemple:

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;
    }
}

Pour info: pour accéder au thread d'interface utilisateur à partir d'un thread de travail, vous utilisez la méthode runOnUiThread () ou la méthode de publication dans votre vue.

Par exemple:

runOnUiThread(new Runnable() {
    textView.setText("something.");
});

or
    yourview.post(new Runnable() {
    yourview.setText("something");
});

Cela vous aidera à mieux connaître les choses. Par conséquent, dans votre cas, vous devez définir votre affichage de texte dans la méthode onPostExecute ().

Je recommanderais de vous faciliter la vie en utilisant cette bibliothèque pour les travaux d'arrière-plan:

https://github.com/Arasthel/AsyncJobLibrary

C'est aussi simple que ça ...

AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {

    @Override
    public void doOnBackground() {
        startRecording();
    }
});

Exemple de tâche asynchrone avec demande 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);
    }
}

Simplement:

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

Vous devez déclarer le bouton surclicklistener. Une fois cliqué, il appelle la classe AsyncTask DownloadJson.

Le processus sera indiqué ci-dessous:

@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);
        }
    }

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(),
                          "An error is occurred due to some problem",
                          Toast.LENGTH_LONG);
        toast.setGravity(Gravity.TOP, 25, 400);
        toast.show();
    }

}

Mise à jour: mars 2020

Selon la documentation officielle du développeur Android , AsyncTask est désormais obsolète.

Il est recommandé d'utiliser à la place des corourines kotlin . Simplement, il vous permet d'écrire des tâches asynchrones dans un style séquentiel.

Exemple d'exemple AsyncTask avec progression

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();
        }
    }
}

Tâche ASync;

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;
        }
    }

}

En travaillant avec AsyncTask, il est nécessaire de créer un successeur de classe et d'enregistrer la mise en œuvre des méthodes nécessaires pour nous. Dans cette leçon, nous examinerons trois méthodes:

doInBackground - sera exécuté dans un nouveau thread, et ici nous résolvons toutes nos tâches difficiles. Parce qu'un thread non principal n'a pas accès à l'interface utilisateur.

onPreExecute - exécuté avant doInBackground et a accès à l'interface utilisateur

onPostExecute - exécuté après doInBackground (ne fonctionne pas si AsyncTask a été annulé - à ce sujet dans les prochaines leçons) et a accès à l'interface utilisateur.

Voici la classe MyAsyncTask:

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");
  }
}

Et voici comment appeler votre activité ou fragment:

MyAsyncTask myAsyncTask = new MyAsyncTask();
myAsyncTask.execute();

si vous ouvrez la classe AsyncTask, vous pouvez voir le code ci-dessous.

public abstract class AsyncTask<Params, Progress, Result> {
    @WorkerThread
    protected abstract Result doInBackground(Params... params);
    @MainThread
    protected void onPreExecute() {
    }
    @SuppressWarnings({"UnusedDeclaration"})
    @MainThread
    protected void onPostExecute(Result result) {
    }
}

Fonctionnalités AsyncTask

1. AsyncTask est une classe abstraite
2. AsyncTask a 3 paramètres génériques.
3. AsyncTask a une méthode abstraite de doInBackground, onPreExecute, onPostExecute
4. doInBackground est WorkerThread (vous ne pouvez pas mettre à jour l'interface utilisateur)
5. onPreExecute est MainThread
6. onPostExecute est MainThread (vous pouvez mettre à jour l'interface utilisateur)

exemple

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_login);
    mEmailView = (AutoCompleteTextView) findViewById(R.id.email);

    AsyncTask<Void, Void, Post> asyncTask = new AsyncTask<Void, Void, Post>() {
        @Override
        protected Post doInBackground(Void... params) {
            try {
                ApiClient defaultClient = Configuration.getDefaultApiClient();
                String authorization = "eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoxLCJleHAiOjE1ODIxMzM4MTB9.bA3Byc_SuB6jzqUGAY4Pyt4oBNg0VfDRctZ8-PcPlYg"; // String | JWT token for Authorization
                ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
                Bearer.setApiKey(authorization);
                PostApi apiInstance = new PostApi();
                String id = "1"; // String | id
                Integer commentPage = 1; // Integer | Page number for Comment
                Integer commentPer = 10; // Integer | Per page number For Comment
                Post result;
                try {
                    result = apiInstance.apiV1PostsIdGet(id, authorization, commentPage, commentPer);
                } catch (ApiException e) {
                    e.printStackTrace();
                    result = new Post();
                }
                return result;
            } catch (Exception e) {
                e.printStackTrace();
                return new Post();
            }
        }

        @Override
        protected void onPostExecute(Post post) {
            super.onPostExecute(post);
            if (post != null) {
                mEmailView.setText(post.getBody());
                System.out.print(post);
            }
        }
    };
    asyncTask.execute();
}

Modifiez votre code comme indiqué ci-dessous:

@Override
protected void onPostExecute(String result) {

    runOnUiThread(new Runnable() {
        public void run() {
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText("Executed");
        }
    });
}