Hakkında okuyordum AsyncTaskve aşağıdaki basit programı denedim. Ama işe yaramıyor gibi görünüyor. Nasıl çalıştırabilirim?

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

Sadece arka plan işleminde 5 saniye sonra etiketi değiştirmeye çalışıyorum.

Bu benim 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>

Tamam, GUI'ye başka bir iş parçacığı üzerinden erişmeye çalışıyorsunuz. Bu, esas olarak, iyi bir uygulama değildir.

AsyncTask doInBackground(), görünümlerinizin bulunduğu GUI'ye erişimi olmayan başka bir iş parçacığının içindeki her şeyi yürütür .

preExecute()ve postExecute()bu yeni iş parçacığında ağır kaldırma gerçekleşmeden önce ve sonra GUI'ye erişmenizi sağlar ve hatta uzun işlemin sonucunu işlem postExecute()sonuçlarını göstermek için bile geçebilirsiniz .

Daha sonra TextView'inizi güncellediğiniz şu satırlara bakın:

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

Koy onları onPostExecute().

Ardından, doInBackgroundtamamlandıktan sonra TextView metninizin güncellendiğini göreceksiniz .

OnClick dinleyicinizin hangi Görünüm'ün seçildiğini kontrol etmediğini fark ettim. Bunu yapmanın en kolay yolunun anahtar ifadeleri olduğunu düşünüyorum. Ben karışıklığı kurtarmak için tüm önerileri ile aşağıda düzenlenmiş tam bir sınıf var.

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

Tam cevabım burada , ama bu sayfadaki diğer cevapları tamamlamak için açıklayıcı bir resim. Benim için, tüm değişkenlerin nereye gittiğini anlamak başlangıçta en kafa karıştırıcı kısımdı.

Eminim düzgün çalışıyor, ancak arka plan iş parçacığında UI öğelerini değiştirmeye çalışıyorsunuz ve bu olmayacak.

Çağrınızı ve AsyncTask'ı aşağıdaki gibi revize edin:

Arama Sınıfı

Not: Şahsen onPostExecute()AsyncTask iş parçacığını çalıştırdığınız her yerde kullanmanızı öneririm , AsyncTask'ın kendisini genişleten sınıfta değil. Ben özellikle AsyncTask sonuçları biraz farklı sonuçları işleme birden gerekiyorsa kodu okumayı kolaylaştırır düşünüyorum.

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

LongThread sınıfı (AsyncTask öğesini genişletir):

@Override
protected String doInBackground(String... params) {
    for (int i = 0; i < 5; i++) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    return "Executed";
}      

Kavram ve kod burada

Android AsyncTask'ı kullanmak için basit bir örnek oluşturdum. onPreExecute(), doInBackground(), publishProgress()Sonunda ve sonunda başlar onProgressUpdate().

Burada, doInBackground () bir arka plan iş parçacığı olarak çalışır, diğer UI iş parçacığı çalışır. DoInBackground () içindeki bir UI öğesine erişemezsiniz. Dizi, bahsettiğim gibi aynı.

Eğer herhangi bir widget'ı güncellemeniz gerekiyorsa Ancak doInBackgroundyapabilirsiniz publishProgressdan doInBackgroundhangi arayacak onProgressUpdateUI widget'ı güncellemek için.

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

Faaliyetinizde şöyle deyin:

new TestAsync().execute();

Geliştirici Referansı Buraya

Bu iki satırı hareket ettirin:

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

AsyncTask'in doInBackgroundyönteminden çıkar ve yöntemi uygula onPostExecute. Bunun AsyncTaskgibi bir şey olmalı:

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

Geçmiş / Teori

AsyncTask , sonuçları UI iş parçacığında yayınlarken arka plan iş parçacığında bir görev çalıştırmanıza olanak tanır.

Kullanıcı her zaman uygulama ile etkileşimde bulunabilmelidir, bu nedenle ana (UI) iş parçacığını web'den içerik indirme gibi görevlerle engellemekten kaçınmak önemlidir .

Bu yüzden bir kullanıyoruz AsyncTask.

Çalıştırılabilir nesneleri ve mesajları diğer iş parçacıklarından göndermenizi ve işlemenizi sağlayan UI iş parçacığı ileti kuyruğunu ve işleyicisini sararak basit bir arabirim sunar .

uygulama

AsyncTask genel bir sınıftır. (Yapıcısında parametreli tipler alır .)

Bu üç genel türü kullanır :

Params - yürütme sonrasında göreve gönderilen parametrelerin türü.

Progress - arka plan hesaplaması sırasında yayınlanan ilerleme birimlerinin türü.

Result - arka plan hesaplamasının sonucunun türü.

Tüm türler her zaman zaman uyumsuz bir görev tarafından kullanılmaz. Bir türü kullanılmamış olarak işaretlemek için Void türünü kullanmanız yeterlidir:

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

Bu üç parametre , geçersiz kılabileceğiniz üç birincil işleve karşılık gelirAsyncTask :

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

AsyncTask'ı yürütmek için

• execute()Arka plan görevine gönderilecek parametreleri içeren çağrı .

Ne oluyor

1. On ana / UI iş parçacığı , onPreExecute()denir.

   • Bu iş parçacığında bir şey başlatmak için. (Örneğin, kullanıcı arayüzünde bir ilerleme çubuğu gösterin.)

2. Bir arka plan iş parçacığında , doInBackground(Params...)çağrılır.

   • ( Paramsüzerinden geçildi execute.)
   • Uzun süren görevin olması gereken yer.

   • doInBackground()AsyncTask kullanmak için en azından geçersiz kılınmalıdır.

   • publishProgress(Progress...)Arka plan hesaplaması devam ederken kullanıcı arabirimini bir ilerleme göstergesiyle (ör. UI animasyonu veya yazdırılan günlük metni) güncellemek için arayın .

     • Aranacak nedenler onProgressUpdate().

3. Açık plan iş parçacığı bir sonuç döndürülür doInBackground().

   • (Bu bir sonraki adımı tetikler.)

4. On ana / UI iş parçacığı , onPostExecute()döndürülen sonuçla denir.

Örnekler

Her iki örnekte de "engelleme görevi" web'den indirilir.

• Örnek A, bir görüntüyü indirir ve bir ImageView'da görüntüler.
• Örnek B bazı dosyaları indirir .

Örnek A

doInBackground()Yöntem tipi bitmap nesnesi görüntüyü ve saklar indirir. onPostExecute()Yöntem bitmap alır ve ImageView yerleştirir.

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

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

Örnek B yürütme

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

Zaman uyumsuz bir görev yürütüldüğünde, görev dört adımdan geçer:

1. OnPreExecute ()
2. doInBackground (Parametreler ...)
3. onProgressUpdate (İlerleme ...)
4. OnPostExecute (Sonuç)

Aşağıda bir demo örneği verilmiştir:

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

Ve bir kez yarattığınızda, bir görev çok basit bir şekilde yürütülür:

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

Sadece eşzamansız bir şey yapmak için en kısa örnek:

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

Çalıştırmak için:

(new MyAsyncTask()).execute();

AsyncTask'ta kullanılan parametreler nasıl ezberlenir?

Yapma

AsyncTask'ta yeniyseniz, AsyncTask yazarken kafanız karışır. Ana suçlular AsyncTask'te kullanılan parametrelerdir, yani AsyncTask<A, B, C>. Göre , A, B, C (bağımsız) kafa daha fazla şeyler kılan yöntemler farklıdır imza.

Basit tutun!

Anahtar ezberlemek değil . Görevinizin gerçekten ne yapması gerektiğini görselleştirebiliyorsanız, AsyncTask'ı ilk denemede doğru imzayla yazmak çocuk oyuncağı olacaktır. Sadece senin anlamaya Input, Progressve Output, ve gitmek için iyi olacaktır.

Peki bir AsyncTask nedir?

AsyncTask, arka plan iş parçacığında çalışan bir arka plan görevidir. Bir alır Input, gerçekleştirir Progressve verir Output.

Yani , AsyncTask<Input, Progress, Output>.

Örneğin:

Yöntemlerle ilişkisi nedir?

arasında AsyncTaskvedoInBackground()

doInBackground()ve onPostExecute(),onProgressUpdate () `de ilgili

Kodda nasıl yazılır?

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
    }

}

Bu Görevi nasıl yürüteceksin?

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

Çalışan iş parçacığında, Android'deki UI öğelerini doğrudan değiştiremezsiniz.

AsyncTask kullanırken lütfen geri arama yöntemlerini anlayın.

Örneğin:

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: Çalışan iş parçacığından UI iş parçacığına erişmek için, görünümünüzde runOnUiThread () yöntemini veya post yöntemini kullanırsınız.

Örneğin:

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

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

Bu, işleri daha iyi bilmenize yardımcı olacaktır. Bu durumda, metin görünümünüzü onPostExecute () yönteminde ayarlamanız gerekir.

Arka plan çalışmaları için bu kütüphaneyi kullanarak hayatınızı kolaylaştırmanızı tavsiye ederim:

https://github.com/Arasthel/AsyncJobLibrary

Bu kadar basit ...

AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {

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

POST isteği ile örnek Asenkron Görev:

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

basitçe:

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

Tıklama listesindeki düğmeyi bildirmeniz gerekir. Tıklandığında, AsyncTask sınıfı DownloadJson'u çağırır.

İşlem aşağıda gösterilecektir:

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

}

Güncelleme: Mart 2020

Android geliştirici resmi belgelerine göre , AsyncTask artık kullanımdan kaldırıldı.

Bunun yerine kotlin corourines kullanılması önerilir . Basitçe, senkronize olmayan görevleri sıralı bir tarzda yazmanıza izin verir.

İlerleyen AsyncTask örneği örneği

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 Görevi;

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

}

AsyncTask ile çalışırken, bir sınıf halefi oluşturmak ve içinde bizim için gerekli yöntemlerin uygulanmasını kaydetmek gerekir. Bu derste üç yönteme bakacağız:

doInBackground - yeni bir iş parçacığında yürütülecek ve burada tüm zor görevlerimizi çözüyoruz . Çünkü birincil olmayan bir iş parçacığının kullanıcı arayüzüne erişimi yok.

onPreExecute - doInBackground'dan önce yürütülür ve kullanıcı arayüzüne erişimi vardır

OnPostExecute - sonra yürütülür (AsyncTask iptal edildiğinde çalışmaz - sonraki derslerde bu konuda) ve kullanıcı arayüzüne erişimi vardır.

Bu MyAsyncTask sınıfı:

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

Aktivitenizde veya Parçanızda şu şekilde arama yapabilirsiniz:

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

AsyncTask sınıfını açarsanız aşağıdaki kodu görebilirsiniz.

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

AsyncTask özellikleri

1. AsyncTask soyut bir sınıftır
2. AsyncTask'ın 3 genel parametresi vardır.
3. AsyncTask'ın soyut yöntemi doInBackground, onPreExecute, onPostExecute
4. doInBackground WorkerThread (kullanıcı arayüzünü güncelleyemezsiniz)
5. onPreExecute MainThread olduğunu
6. onPostExecute MainThread (kullanıcı arayüzünü güncelleyebilirsiniz)

misal

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

Kodunuzu aşağıda belirtildiği gibi değiştirin:

@Override
protected void onPostExecute(String result) {

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