Saya membaca tentang AsyncTask, dan saya mencoba program sederhana di bawah ini. Tapi sepertinya itu tidak berhasil. Bagaimana saya bisa membuatnya bekerja?

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

Saya hanya mencoba mengubah label setelah 5 detik dalam proses latar belakang.

Ini main.xml saya :

<?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>

Oke, Anda mencoba mengakses GUI melalui utas lainnya. Ini, pada dasarnya, bukan praktik yang baik.

AsyncTask mengeksekusi semua yang ada di doInBackground()dalam utas lainnya, yang tidak memiliki akses ke GUI di mana pandangan Anda berada.

preExecute()dan postExecute()menawarkan Anda akses ke GUI sebelum dan sesudah pengangkatan berat terjadi di utas baru ini, dan Anda bahkan dapat melewati hasil operasi panjang postExecute()untuk kemudian menunjukkan hasil pemrosesan.

Lihat baris ini di mana Anda nanti memperbarui TextView Anda:

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

Masukkan mereka onPostExecute().

Anda kemudian akan melihat teks TextView Anda diperbarui setelah doInBackgroundselesai.

Saya perhatikan bahwa pendengar onClick Anda tidak memeriksa untuk melihat Tampilan mana yang telah dipilih. Saya menemukan cara termudah untuk melakukan ini adalah melalui pernyataan switch. Saya memiliki kelas lengkap yang diedit di bawah ini dengan semua saran untuk menyimpan kebingungan.

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

Jawaban lengkap saya ada di sini , tetapi di sini ada gambar penjelasan untuk melengkapi jawaban lain pada halaman ini. Bagi saya, memahami kemana semua variabel pergi adalah bagian yang paling membingungkan di awal.

Saya yakin ini dijalankan dengan benar, tetapi Anda mencoba mengubah elemen UI di utas latar dan itu tidak akan berhasil.

Revisi panggilan Anda dan AsyncTask sebagai berikut:

Kelas Panggilan

Catatan: Saya pribadi menyarankan untuk menggunakan di onPostExecute()mana pun Anda mengeksekusi utas AsyncTask Anda dan tidak di kelas yang memperluas AsyncTask itu sendiri. Saya pikir itu membuat kode lebih mudah dibaca terutama jika Anda memerlukan AsyncTask di beberapa tempat yang menangani hasil yang sedikit berbeda.

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

Kelas LongThread (meluas 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";
}      

Konsep dan kode di sini

Saya telah membuat contoh sederhana untuk menggunakan AsyncTask dari Android. Dimulai dengan onPreExecute(), doInBackground(), publishProgress()dan akhirnya onProgressUpdate().

Dalam hal ini, doInBackground () berfungsi sebagai utas latar, sedangkan karya lainnya di Utas UI. Anda tidak dapat mengakses elemen UI di doInBackground (). Urutannya sama dengan yang saya sebutkan.

Namun, jika Anda perlu memperbarui widget dari doInBackground, Anda dapat publishProgressdari doInBackgroundyang akan memanggil onProgressUpdateuntuk memperbarui widget UI Anda.

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

Sebut saja seperti ini di aktivitas Anda:

new TestAsync().execute();

Referensi Pengembang Di Sini

Pindahkan dua baris ini:

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

keluar dari doInBackgroundmetode AsyncTask Anda dan memasukkannya ke dalam onPostExecutemetode tersebut. Anda AsyncTaskakan terlihat seperti ini:

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

Latar Belakang / Teori

AsyncTask memungkinkan Anda untuk menjalankan tugas pada utas latar belakang, saat menerbitkan hasil ke utas UI.

Pengguna harus selalu dapat berinteraksi dengan aplikasi sehingga penting untuk menghindari memblokir utas utama (UI) dengan tugas-tugas seperti mengunduh konten dari web.

Ini sebabnya kami menggunakan AsyncTask.

Ia menawarkan antarmuka yang mudah dengan membungkus antrian pesan dan penangan utas UI yang memungkinkan Anda mengirim dan memproses objek dan pesan yang dapat dijalankan dari utas lainnya .

Penerapan

AsyncTask adalah kelas generik. (Dibutuhkan tipe parameter dalam konstruktornya.)

Ini menggunakan tiga jenis generik ini:

Params - jenis parameter yang dikirim ke tugas setelah eksekusi.

Progress - jenis unit kemajuan yang diterbitkan selama perhitungan latar belakang.

Result - jenis hasil perhitungan latar belakang.

Tidak semua tipe selalu digunakan oleh tugas yang tidak sinkron. Untuk menandai suatu tipe sebagai tidak digunakan, cukup gunakan tipe Void:

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

Tiga parameter ini sesuai dengan tiga fungsi utama yang dapat Anda timpa AsyncTask:

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

Untuk menjalankan AsyncTask

• Panggil execute()dengan parameter untuk dikirim ke tugas latar belakang.

Apa yang terjadi

1. Pada utas utama / UI , onPreExecute()disebut.

   • Untuk menginisialisasi sesuatu di utas ini. (Misalnya, memperlihatkan bilah progres pada antarmuka pengguna.)

2. Di utas latar belakang , doInBackground(Params...)disebut.

   • ( Paramsditeruskan melalui execute.)
   • Di mana tugas jangka panjang harus terjadi.

   • Harus mengganti setidaknya doInBackground()untuk menggunakan AsyncTask.

   • Panggilan publishProgress(Progress...)untuk memperbarui antarmuka pengguna dengan tampilan kemajuan (mis. Animasi UI atau teks log dicetak) saat perhitungan latar belakang masih dijalankan.

     • Penyebab onProgressUpdate()untuk dipanggil.

3. Di utas latar hasil dikembalikan doInBackground().

   • (Ini memicu langkah selanjutnya.)

4. Pada utas utama / UI , onPostExecute()dipanggil dengan hasil yang dikembalikan.

Contohnya

Dalam kedua contoh, "tugas pemblokiran" adalah pengunduhan dari web.

• Contoh A mengunduh gambar dan menampilkannya di ImageView, sementara
• Contoh B mengunduh beberapa file .

Contoh A

The doInBackground()Metode download gambar dan menyimpannya dalam sebuah objek dari tipe bitmap. The onPostExecute()Metode mengambil bitmap dan menempatkannya di ImageView tersebut.

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

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

Contoh B eksekusi

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

Saat tugas asinkron dijalankan, tugas melewati empat langkah:

1. onPreExecute ()
2. doInBackground (Params ...)
3. padaProgressUpdate (Kemajuan ...)
4. onPostExecute (Hasil)

Di bawah ini adalah contoh demo:

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

Dan begitu Anda membuat, tugas dijalankan dengan sangat sederhana:

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

Contoh terpendek untuk hanya melakukan sesuatu secara tidak sinkron:

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

Untuk menjalankannya:

(new MyAsyncTask()).execute();

Bagaimana cara menghafal parameter yang digunakan dalam AsyncTask?

Jangan

Jika Anda baru mengenal AsyncTask, maka sangat umum untuk bingung saat menulis AsyncTask. Penyebab utama adalah parameter yang digunakan dalam AsyncTask, yaitu AsyncTask<A, B, C>,. Berdasarkan tanda tangan A, B, C (argumen) dari metode yang berbeda yang membuat segalanya lebih membingungkan.

Tetap sederhana!

Kuncinya adalah jangan menghafal . Jika Anda dapat memvisualisasikan apa yang benar-benar perlu dilakukan oleh tugas Anda, maka tulis AsyncTask dengan tanda tangan yang benar pada upaya pertama adalah sepotong kue. Cari tahu apa yang Anda Input, Progressdan Outputapa, dan Anda akan baik untuk pergi.

Jadi apa itu AsyncTask?

AsyncTask adalah tugas latar belakang yang berjalan di utas latar belakang. Dibutuhkan Input, melakukan Progressdan memberi Output.

Yaitu , AsyncTask<Input, Progress, Output>.

Sebagai contoh:

Apa hubungannya dengan metode?

Antara AsyncTaskdandoInBackground()

doInBackground()dan onPostExecute(),onProgressUpdate () `juga terkait

Bagaimana cara menuliskannya dalam kode?

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
    }

}

Bagaimana Anda menjalankan tugas ini?

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

Ketika Anda berada di utas pekerja, Anda tidak bisa secara langsung memanipulasi elemen UI di Android.

Saat Anda menggunakan AsyncTask, harap pahami metode panggilan balik.

Sebagai contoh:

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: Untuk mengakses utas UI dari utas pekerja, Anda dapat menggunakan metode runOnUiThread () atau memposting metode pada tampilan Anda.

Contohnya:

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

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

Ini akan membantu Anda mengetahui hal-hal dengan lebih baik. Karenanya dalam kasus Anda, Anda perlu mengatur tampilan teks Anda pada metode onPostExecute ().

Saya akan merekomendasikan membuat hidup Anda lebih mudah dengan menggunakan perpustakaan ini untuk pekerjaan latar belakang:

https://github.com/Arasthel/AsyncJobLibrary

Sesederhana ini ...

AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {

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

Contoh Tugas Async dengan permintaan 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);
    }
}

Secara sederhana:

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

Anda perlu mendeklarasikan tombol onclicklistener. Setelah diklik, ia memanggil kelas AsyncTask DownloadJson.

Prosesnya akan ditunjukkan di bawah ini:

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

}

Pembaruan: Maret 2020

Menurut dokumentasi resmi pengembang Android , AsyncTask sekarang tidak digunakan lagi.

Dianjurkan untuk menggunakan korlin kotlin sebagai gantinya. Sederhananya, ini memungkinkan Anda untuk menulis tugas yang tidak sinkron dengan gaya berurutan.

Contoh AsyncTask contoh dengan progres

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

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

}

Saat bekerja dengan AsyncTask, perlu untuk membuat kelas-penerus dan di dalamnya untuk mendaftarkan implementasi metode yang diperlukan bagi kita. Dalam pelajaran ini kita akan melihat tiga metode:

doInBackground - akan dieksekusi di utas baru, dan di sini kita menyelesaikan semua tugas sulit kita. Karena utas non-primer tidak memiliki akses ke UI.

onPreExecute - dieksekusi sebelum doInBackground dan memiliki akses ke UI

onPostExecute - dieksekusi setelah doInBackground (tidak berfungsi jika AsyncTask dibatalkan - tentang hal ini dalam pelajaran berikutnya) dan memiliki akses ke UI.

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

Dan ini cara menelepon dalam Aktivitas atau Fragmen Anda:

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

jika Anda membuka kelas AsyncTask Anda dapat melihat kode di bawah ini.

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

Fitur AsyncTask

1. AsyncTask adalah kelas abstrak
2. AsyncTask memiliki 3 param generik.
3. AsyncTask memiliki metode abstrak doInBackground, onPreExecute, onPostExecute
4. doInBackground is WorkerThread (Anda tidak dapat memperbarui UI)
5. onPreExecute adalah MainThread
6. onPostExecute adalah MainThread (Anda dapat memperbarui UI)

contoh

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

Ubah kode Anda seperti yang diberikan di bawah ini:

@Override
protected void onPostExecute(String result) {

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