AsyncTask Android उदाहरण


680

मैं के बारे में पढ़ रहा था AsyncTask, और मैंने नीचे दिए गए सरल कार्यक्रम की कोशिश की। लेकिन काम होता नहीं दिख रहा है। मैं इसे कैसे कारगर बना सकता हूं?

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

मैं पृष्ठभूमि प्रक्रिया में 5 सेकंड के बाद लेबल को बदलने की कोशिश कर रहा हूं।

यह मेरा 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>

1
इसके अलावा आप doInBackground () विधि से publishprogress () कॉल करके प्रगति दिखा सकते हैं।
ओसम सिप

3
यहाँ asynctask उदाहरण है AsyncTask उदाहरण
समीर मांगरोलिया

यहाँ छवि डाउनलोड करने का एक उदाहरण भी है: android-ios-tutorials.com/182/…
Houcine

AsyncTask - डिज़ाइन पैटर्न: stackoverflow.com/questions/5058661/…
हेनरीचूंग

3
सरल उदाहरण ... आपको लिंक
c49

जवाबों:


702

ठीक है, आप GUI को किसी अन्य थ्रेड के माध्यम से एक्सेस करने का प्रयास कर रहे हैं। यह, मुख्य में, अच्छा अभ्यास नहीं है।

AsyncTask doInBackground()दूसरे धागे के अंदर सब कुछ निष्पादित करता है , जिसमें GUI तक पहुंच नहीं है जहां आपके विचार हैं।

preExecute()और postExecute()इस नए धागे में भारी उठाने से पहले और बाद में आपको GUI तक पहुंच प्रदान करते हैं, और आप लंबे ऑपरेशन के परिणाम को पारित कर सकते हैं और postExecute()फिर प्रसंस्करण के किसी भी परिणाम को दिखा सकते हैं।

इन पंक्तियों को देखें, जहाँ आप बाद में अपना TextView अपडेट कर रहे हैं:

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

उन्हें अंदर रखो onPostExecute()

फिर आप doInBackgroundपूर्ण के बाद अपने TextView पाठ को अपडेट करके देखेंगे ।

मैंने देखा कि आपका ऑनक्लिक श्रोता यह देखने के लिए जाँच नहीं करता है कि किस दृश्य को चुना गया है। मुझे यह करने का सबसे आसान तरीका है स्विच स्टेटमेंट। मेरे पास भ्रम को बचाने के लिए सभी सुझावों के साथ एक सम्पूर्ण कक्षा है।

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

2
मैं यह करने में असमर्थ हूँ <code> btn.setOnClickListener (यह); </ code> ग्रहण त्रुटि देता है ----- "विधि setOnClickListener (View.OnClickListener) प्रकार में देखें तर्क (AsyncTaskActivity) के लिए लागू नहीं है"
फॉक्स

मैं पाठ की सेटिंग को स्थिर नहीं होने के लिए बदलने की सलाह दूंगा, लेकिन onPostExecute(String result)विधि से तर्क ले सकता हूं । यह भविष्य के पाठकों के लिए यह स्पष्ट कर देगा कि तर्क वापसी मूल्य से आबाद है doInBackground(String... params)
एरिक

@ एरिक टोबियास - यह सटीक चीजें पहले से ही टिप्पणी अनुभाग में की गई हैं। मैं अपने पूर्ण उदाहरण में उपयोगकर्ताओं के सवाल का जवाब दे रहा था।
ग्राहम स्मिथ

1
एक परिशिष्ट और Google सीडर के रूप में (और वर्तमान में किसी से यह सामान सीखना जो कि मैं इस पार कैसे आया हूं): यूआई अपडेट का अधिकांश हिस्सा आप उस चीज के लिए करेंगे, जहां आपको उपयोगकर्ता को वापस रिपोर्ट की जाने वाली प्रगति की आवश्यकता होती है, जो ऑन-प्रोग्रू यूडेटड बैक कॉल में है जिसे मुख्य UI थ्रेड में निष्पादित किया जाता है।
रिचीह

1
यह निश्चित रूप से गड़बड़ कर देगा यदि आपकी गतिविधि को किसी भी कारण से घुमाया या नष्ट किया जाता है ...
सैम

792

मेरा पूरा उत्तर यहाँ है , लेकिन इस पृष्ठ पर अन्य उत्तरों के पूरक के लिए एक व्याख्यात्मक छवि है। मेरे लिए, यह समझना कि सभी चर कहाँ जा रहे थे, शुरुआत में सबसे भ्रमित करने वाला हिस्सा था।

यहाँ छवि विवरण दर्ज करें


3
paramsएक सरणी है। (ऊपर के उदाहरण में, यह एक Stringसरणी थी।) यह आपको एक ही प्रकार के कई मापदंडों में पारित करने की अनुमति देता है। तो फिर तुम साथ उन लोगों के मापदंडों का उपयोग कर सकते params[0], params[1], params[2]उदाहरण में, आदि, वहाँ केवल एक ही था Stringमें paramsसरणी। आप विभिन्न प्रकार के एक से अधिक पैरामीटर में पारित करने के लिए की जरूरत है (उदाहरण के लिए, एक Stringऔर एक int), देखने के इस सवाल का
सुरगाछ

73

मुझे यकीन है कि यह ठीक से निष्पादित हो रहा है, लेकिन आप पृष्ठभूमि के धागे में UI तत्वों को बदलने की कोशिश कर रहे हैं और ऐसा नहीं करेंगे।

निम्नानुसार अपने कॉल और AsyncTask को संशोधित करें:

कक्षा बुला रहा है

नोट: मैं व्यक्तिगत रूप से सुझाव देता हूं कि onPostExecute()आप जहां भी अपने AsyncTask थ्रेड को निष्पादित करते हैं, उसका उपयोग करते हैं और उस वर्ग में नहीं जो खुद AsyncTask का विस्तार करता है। मुझे लगता है कि यह कोड को पढ़ना आसान बनाता है, खासकर यदि आपको परिणामों को थोड़ा अलग करने के लिए कई स्थानों पर AsyncTask की आवश्यकता होती है।

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

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

7
एक उदाहरण प्रदान करने के लिए धन्यवाद जो गतिविधि से AsyncTask को डिकम्पोज करता है
sthomps

1
हां, आखिरकार कोई व्यक्ति कार्य और गतिविधि को डिकॉउंड करता है। धन्यवाद onPostExecute। और गतिविधि में ओवरराइड करना शानदार है।
mcy

58

संकल्पना और कोड यहाँ

मैंने Android के AsyncTask का उपयोग करने के लिए एक सरल उदाहरण बनाया है। इसके साथ शुरू होता है onPreExecute(), doInBackground(), publishProgress()और अंत में onProgressUpdate()

इसमें doInBackground () बैकग्राउंड थ्रेड के रूप में काम करता है, जबकि UI थ्रेड में अन्य कार्य करता है। आप doInBackground () में UI तत्व तक नहीं पहुँच सकते। अनुक्रम वही है जैसा मैंने उल्लेख किया है।

हालाँकि, यदि आपको किसी भी विजेट को अपडेट करने की आवश्यकता है doInBackground, तो आप वह कर सकते publishProgressहैं doInBackgroundजिससे आप onProgressUpdateअपने 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);
    }
}

इसे अपनी गतिविधि में इस तरह से कॉल करें:

new TestAsync().execute();

डेवलपर संदर्भ यहां


3
जावा में आम तौर पर बड़े अक्षरों के साथ कक्षाएं शुरू होती हैं, जो आमतौर पर एक संकेतन के बाद होती है
वामसी पवन महेश

20

इन दो लाइनों को स्थानांतरित करें:

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

अपने AsyncTask की doInBackgroundविधि से बाहर निकलें और उन्हें onPostExecuteविधि में रखें। आपका AsyncTaskकुछ इस तरह दिखना चाहिए:

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

अरे मैं क्या सेवा पर async कार्य कर रहा हूँ मैं मुख्य ui थ्रेड के लिए कुछ मूल्य वापस करना चाहता हूँ।
दीपन

@Dipen - इस चर्चा को देखें । दो मुद्दे हैं: एक से रिपोर्टिंग परिणाम AsyncTask, जो मेरे उत्तर पते; और ui थ्रेड के लिए एक सेवा से मूल्य भेज रहा है, जिसे अन्य चर्चा संबोधित करती है। ये मुद्दे स्वतंत्र हैं।
टेड होप

14

पृष्ठभूमि / सिद्धांत

AsyncTask आपको UI थ्रेड पर परिणाम प्रकाशित करते हुए, एक पृष्ठभूमि थ्रेड पर एक कार्य चलाने की अनुमति देता है।

उपयोगकर्ता हमेशा अनुप्रयोग के साथ बातचीत करने के लिए तो यह है सक्षम होना चाहिए महत्वपूर्ण मुख्य (यूआई) धागा अवरुद्ध से बचने के लिए इस तरह के वेब से सामग्री डाउनलोड के रूप में कार्य के साथ।

यही कारण है कि हम एक का उपयोग करें AsyncTask

यह UI थ्रेड संदेश कतार और हैंडलर को लपेटकर एक सरल इंटरफ़ेस प्रदान करता है जो आपको अन्य थ्रेड से रन करने योग्य ऑब्जेक्ट और संदेश भेजने और संसाधित करने की अनुमति देता है

कार्यान्वयन

AsyncTask एक सामान्य वर्ग है। (यह अपने निर्माता में पैरामीटर प्रकार लेता है ।)

यह इन तीन सामान्य प्रकारों का उपयोग करता है :

Params - निष्पादन पर कार्य को भेजे गए मापदंडों का प्रकार।

Progress - पृष्ठभूमि गणना के दौरान प्रकाशित प्रगति इकाइयों का प्रकार।

Result - पृष्ठभूमि गणना के परिणाम का प्रकार।

सभी प्रकार हमेशा एक अतुल्यकालिक कार्य द्वारा उपयोग नहीं किए जाते हैं। अप्रयुक्त के रूप में एक प्रकार को चिह्नित करने के लिए, बस शून्य प्रकार का उपयोग करें:

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

ये तीन पैरामीटर तीन प्राथमिक कार्यों के अनुरूप हैं जिन्हें आप में ओवरराइड कर सकते हैं AsyncTask:

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

AsyncTask को निष्पादित करने के लिए

  • execute()पृष्ठभूमि कार्य को भेजे जाने वाले मापदंडों के साथ कॉल करें ।

क्या होता है

  1. पर मुख्य / यूआई धागा , onPreExecute()कहा जाता है।

    • इस धागे में कुछ इनिशियलाइज़ करने के लिए। (जैसे यूजर इंटरफेस पर एक प्रगति बार दिखाते हैं।)
  2. एक पर पृष्ठभूमि धागा , doInBackground(Params...)कहा जाता है।

    • (के Paramsमाध्यम से पारित किया गया execute।)
    • जहां लंबे समय से चल रहा कार्य होना चाहिए।
    • doInBackground()AsyncTask का उपयोग करने के लिए कम से कम ओवरराइड करना चाहिए ।

    • publishProgress(Progress...)प्रगति के प्रदर्शन के साथ उपयोगकर्ता इंटरफ़ेस को अपडेट करने के लिए कॉल करें (जैसे यूआई एनीमेशन या लॉग टेक्स्ट मुद्रित), जबकि पृष्ठभूमि गणना अभी भी निष्पादित कर रही है।

      • onProgressUpdate()कहलाने का कारण ।
  3. पर पृष्ठभूमि धागा एक परिणाम से दिया जाता है doInBackground()

    • (यह अगले चरण को ट्रिगर करता है।)
  4. पर मुख्य / यूआई धागा , onPostExecute()लौट आए परिणाम के साथ कहा जाता है।

उदाहरण

दोनों उदाहरणों में "ब्लॉकिंग टास्क" वेब से डाउनलोड है।

  • उदाहरण A एक छवि को डाउनलोड करता है और इसे ImageView में प्रदर्शित करता है, जबकि
  • उदाहरण B कुछ फ़ाइलों को डाउनलोड करता है

उदाहरण ए

doInBackground()विधि प्रकार बिटमैप का एक उद्देश्य में छवि और यह भंडार डाउनलोड करता है। onPostExecute()विधि बिटमैप लेता है और imageView में यह देता है।

class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
    ImageView bitImage;

    public DownloadImageTask(ImageView bitImage) {
        this.bitImage = bitImage;
    }

    protected Bitmap doInBackground(String... urls) {
        String urldisplay = urls[0];
        Bitmap mBmp = null;
        try {
            InputStream in = new java.net.URL(urldisplay).openStream();
            mBmp = BitmapFactory.decodeStream(in);
        } catch (Exception e) {
            Log.e("Error", e.getMessage());
            e.printStackTrace();
        }
        return mBmp;
    }

    protected void onPostExecute(Bitmap result) {
        bitImage.setImageBitmap(result);
    }
}

उदाहरण बी

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

उदाहरण बी निष्पादन

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

बहुत अच्छा .. लेकिन मुझे रिटर्न टाइप क्लैशिंग के बारे में त्रुटि मिलती रहती है - असंगत रिटर्न टाइप का उपयोग करने का प्रयास। मैंने सभी प्रकार के रिटर्न प्रकार, एक ही त्रुटि की कोशिश की है।
जॉन ktejik

हाय @johnktejik, आप उस विशिष्ट समस्या को खोजना चाहते हैं। हो सकता है कि आपके साथ ऐसा हो रहा हो: The-return-type-is-incompatible-with-asynctask
TT--

1
अति उत्कृष्ट! संपादन में जाने पर विचार करें ?
पीटर मोर्टेंसन

12

जब एक अतुल्यकालिक कार्य निष्पादित किया जाता है, तो कार्य चार चरणों से गुजरता है:

  1. onPreExecute ()
  2. doInBackground (पैरामीटर ...)
  3. onProgressUpdate (प्रगति ...)
  4. onPostExecute (परिणाम)

नीचे एक डेमो उदाहरण है:

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

और आपके द्वारा बनाए जाने के बाद, एक कार्य को बहुत ही सरलता से निष्पादित किया जाता है:

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

निष्पादन योग्य को चलाने योग्य के रूप में एक प्रतिपादक की अपेक्षा करता है। यह स्ट्रिंग को स्वीकार नहीं करता है। आपके url का प्रकार क्या है? स्ट्रिंग या नहीं

10

कुछ अतुल्यकालिक रूप से करने के लिए सबसे छोटा उदाहरण:

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

इसे चलाने के लिए:

(new MyAsyncTask()).execute();

10

AsyncTask में प्रयुक्त मापदंडों को कैसे याद किया जाए?

नहीं

यदि आप AsyncTask में नए हैं तो AsyncTask लिखते समय भ्रमित होना बहुत आम है। मुख्य अपराधी AsyncTask में उपयोग किए जाने वाले पैरामीटर हैं, अर्थात AsyncTask<A, B, C>। विधियों के ए, बी, सी (तर्कों) के आधार पर हस्ताक्षर अलग-अलग होते हैं जो चीजों को और भी भ्रमित करते हैं।

इसे सरल रखें!

कुंजी याद नहीं है । यदि आप कल्पना कर सकते हैं कि आपके कार्य को वास्तव में क्या करने की आवश्यकता है, तो पहले प्रयास में सही हस्ताक्षर के साथ AsyncTask लिखना केक का एक टुकड़ा होगा। बस यह पता लगाने क्या आपके Input, Progressऔर Outputहैं, और आप जाने के लिए अच्छा होगा।

तो एक AsyncTask क्या है?

AsyncTask एक बैकग्राउंड टास्क है जो बैकग्राउंड थ्रेड में चलता है। यह एक लेता है Input, प्रदर्शन करता है Progressऔर एक देता है Output

यानी , AsyncTask<Input, Progress, Output>

उदाहरण के लिए:

यहां छवि विवरण दर्ज करें

विधियों के साथ क्या संबंध है?

के बीच AsyncTaskऔरdoInBackground()

यहां छवि विवरण दर्ज करें

doInBackground()और onPostExecute(),onProgressUpdate () `भी संबंधित हैं

यहां छवि विवरण दर्ज करें

कोड में यह कैसे लिखें?

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
    }

}

आप इस कार्य को कैसे चलाएंगे?

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

6

जब आप कार्यकर्ता थ्रेड में होते हैं, तो आप सीधे एंड्रॉइड पर यूआई तत्वों को हेरफेर नहीं कर सकते।

जब आप AsyncTask का उपयोग कर रहे हैं तो कृपया कॉलबैक विधियों को समझें।

उदाहरण के लिए:

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 करें: वर्कर थ्रेड से UI थ्रेड तक पहुँचने के लिए, आप या तो runOnUiThread () मेथड या पोस्ट मेथड को अपने दृष्टिकोण पर उपयोग करते हैं।

उदाहरण के लिए:

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

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

इससे आपको चीजों को बेहतर तरीके से जानने में मदद मिलेगी। इसलिए आप के मामले में, आपको अपने टेक्स्टव्यू को onPostExecute () विधि में सेट करने की आवश्यकता है।


5

मैं इस लाइब्रेरी को पृष्ठभूमि के कामों के लिए इस्तेमाल करके आपके जीवन को आसान बनाने की सलाह दूंगा:

https://github.com/Arasthel/AsyncJobLibrary

यह सरल है ...

AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {

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

3

POST अनुरोध के साथ नमूना Async टास्क:

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


1

आपको बटन onclicklistener घोषित करने की आवश्यकता है। एक बार क्लिक करने पर, यह AsyncTask क्लास डाउनलोडजसन कहलाता है।

प्रक्रिया नीचे दिखाई जाएगी:

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

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

}

1

अपडेट: मार्च 2020

Android डेवलपर आधिकारिक दस्तावेज के अनुसार , AsyncTask अब पदावनत कर दिया गया है।

इसकी जगह कोटलिन कॉरिन का उपयोग करने की सिफारिश की गई है । बस, यह आपको अनुक्रमिक शैली में अतुल्यकालिक कार्यों को लिखने की अनुमति देता है।


0

नमूना AsyncTask उदाहरण प्रगति के साथ

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

0

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

}

क्लास के MyTaskअंदर क्लास क्यों है MainActivity? क्या वह प्रथा है?
पीटर मोर्टेंसन

0

AsyncTask के साथ काम करते समय, हमारे लिए आवश्यक विधियों के कार्यान्वयन को पंजीकृत करने के लिए एक वर्ग-उत्तराधिकारी बनाना और उसमें आवश्यक है। इस पाठ में हम तीन तरीकों को देखेंगे:

doInBackground - एक नए धागे में निष्पादित किया जाएगा, और यहाँ हम अपने सभी कठिन कार्यों को हल करते हैं। क्योंकि गैर-प्राथमिक थ्रेड में UI तक पहुँच नहीं है।

onPreExecute - doInBackground से पहले निष्पादित और UI तक पहुँच है

onPostExecute - doInBackground के बाद निष्पादित किया गया (यदि AsyncTask को रद्द कर दिया गया था - तो अगले पाठों में इसके बारे में) काम नहीं करता है और UI तक इसकी पहुँच है।

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

और यह आपकी गतिविधि या फ्रैगमेंट में कॉल करने का तरीका है:

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

पुन "अगले अध्यायों में इस बारे में" : क्या है कि का उल्लेख करता है? जैसे, यह कहाँ से लिया गया है?
पीटर मोर्टेंसन

0

यदि आप AsyncTask क्लास खोलते हैं तो आप नीचे कोड देख सकते हैं।

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 सुविधाएँ

  1. AsyncTask अमूर्त वर्ग है
  2. AsyncTask में 3 जेनेरिक परमेस हैं।
  3. AsyncTask में सार विधि doInBackground, onPreExecute, onPostExecute है
  4. doInBackground WorkerThread है (आप UI को अपडेट नहीं कर सकते हैं)
  5. onPreExecute MainThread है
  6. onPostExecute MainThread है (आप UI को अपडेट कर सकते हैं)

उदाहरण

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

-1

अपना कोड नीचे दिए अनुसार बदलें:

@Override
protected void onPostExecute(String result) {

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

1
आपको runOnUiThread का उपयोग करने की आवश्यकता नहीं होनी चाहिए क्योंकि onPostExecute हमेशा थ्रेड 1 पर चलता है (क्या यह नहीं?)
justdan0227
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.