Android: मैं AsyncTask के onPreExecute () में पैरामीटर कैसे पास कर सकता हूं?

Question

मैं एक AsyncTaskलोडिंग ऑपरेशन के लिए उपयोग करता हूं जिसे मैंने एक आंतरिक वर्ग के रूप में लागू किया है।

में onPreExecute()मैं एक लोड हो रहा है संवाद जो मैं तो में फिर से छिपाने दिखाने के onPostExecute()। लेकिन कुछ लोडिंग ऑपरेशन के लिए मुझे पहले से पता है कि वे बहुत जल्दी खत्म हो जाएंगे इसलिए मैं लोडिंग डायलॉग प्रदर्शित नहीं करना चाहता।

मैं इसे एक बूलियन पैरामीटर द्वारा इंगित करना चाहता था जिसे मैं पास कर सकता था onPreExecute()लेकिन स्पष्ट रूप से किसी कारण से onPreExecute()कोई पैरामीटर नहीं लेता है।

स्पष्ट वर्कअराउंड शायद मेरे AsyncTask में या बाहरी वर्ग में एक सदस्य फ़ील्ड बनाने के लिए होगा जिसे मुझे हर लोडिंग ऑपरेशन से पहले सेट करना होगा लेकिन यह बहुत सुरुचिपूर्ण नहीं लगता है। क्या ऐसा करने के लिए इससे अच्छा तरीका है?

Answer 1

आप कंस्ट्रक्टर को ओवरराइड कर सकते हैं। कुछ इस तरह:

private class MyAsyncTask extends AsyncTask<Void, Void, Void> {

    public MyAsyncTask(boolean showLoading) {
        super();
        // do stuff
    }

    // doInBackground() et al.
}

फिर, जब कार्य को बुलाते हैं, तो कुछ ऐसा करें:

new MyAsyncTask(true).execute(maybe_other_params);

---

संपादित करें: यह सदस्य चर बनाने की तुलना में अधिक उपयोगी है क्योंकि यह कार्य आह्वान को सरल बनाता है। ऊपर दिए गए कोड की तुलना करें:

MyAsyncTask task = new MyAsyncTask();
task.showLoading = false;
task.execute();

Comments

यह वही है जो मैंने अभी किया है। मैं अभी भी एक सदस्य चर की जरूरत है, लेकिन AsyncTask में है और बाहरी वर्ग नहीं है अगर तुम क्या मतलब है। मैंने यही किया है: निजी वर्ग MyAsyncTask में AsyncTask <Void, Void, Void> {Private boolean showLoading फैली हुई है; सार्वजनिक MyAsyncTask (बूलियन शोऑलडिंग) {सुपर (); this.showLoading = showLoading; // do सामान} संरक्षित शून्य onPreExecute () {if (showLading) {// ...}} // doInBackground () et al। }

— स्टीवन मेलिओपोलोस

हाँ, यह बहुत ज्यादा विचार था :)

— फेलिक्स

वास्तव में आपको AsynkTask कंस्ट्रक्टर में सुपर () की आवश्यकता नहीं है।

— ostergaard

Answer 2

1) मेरे लिए है कि async कार्य के लिए सबसे सरल तरीका गुजर पैरामीटर इस तरह है

// To call the async task do it like this
Boolean[] myTaskParams = { true, true, true };
myAsyncTask = new myAsyncTask ().execute(myTaskParams);

यहाँ जैसे async कार्य की घोषणा और उपयोग करें

private class myAsyncTask extends AsyncTask<Boolean, Void, Void> {

    @Override
    protected Void doInBackground(Boolean...pParams) 
    {
        Boolean param1, param2, param3;

        //

          param1=pParams[0];    
          param2=pParams[1];
          param3=pParams[2];    
      ....
}                           

2) async-task को पास करने के तरीके async-Task इन्फ्रास्ट्रक्चर (धागा, मेसेंजहैंडलर, ...) कोडिंग से बचने के लिए, कई बार आप उन तरीकों को पास करने पर विचार कर सकते हैं, जिन्हें आपके async-task में एक पैरामीटर के रूप में निष्पादित किया जाना चाहिए। उदाहरण के बाद इस दृष्टिकोण की रूपरेखा। इसके अलावा आपको कंस्ट्रक्टर में आरंभीकरण मापदंडों को पारित करने के लिए एसिंक्स-टास्क को उप-करने की आवश्यकता हो सकती है।

 /* Generic Async Task    */
interface MyGenericMethod {
    int execute(String param);
}

protected class testtask extends AsyncTask<MyGenericMethod, Void, Void>
{
    public String mParam;                           // member variable to parameterize the function
    @Override
    protected Void doInBackground(MyGenericMethod... params) {
        //  do something here
        params[0].execute("Myparameter");
        return null;
    }       
}

// to start the asynctask do something like that
public void startAsyncTask()
{
    // 
    AsyncTask<MyGenericMethod, Void, Void>  mytest = new testtask().execute(new MyGenericMethod() {
        public int execute(String param) {
            //body
            return 1;
        }
    });     
}

Answer 3

क्यों, कैसे और कौन से पैरामीटर Asynctask <> के लिए दिए गए हैं, यहां विस्तार से देखें । मुझे लगता है कि यह सबसे अच्छा स्पष्टीकरण है।

Google का Android दस्तावेज़ कहता है कि:

एक एसिंक्रोनस कार्य को 3 सामान्य प्रकारों द्वारा परिभाषित किया जाता है, जिन्हें Params, Progress and Result, और 4 चरण, onPreExecute, doInBackground, onProgressUpdate और onPostExecute कहा जाता है।

AsyncTask के सामान्य प्रकार:

अतुल्यकालिक कार्य द्वारा उपयोग किए जाने वाले तीन प्रकार निम्नलिखित हैं:

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

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

आप आगे उल्लेख कर सकते हैं: http://developer.android.com/reference/android/os/AsyncTask.html

या आप शंकर-गणेश के ब्लॉग को संदर्भित करके AsyncTask की भूमिका को स्पष्ट कर सकते हैं

अच्छी तरह से एक विशिष्ट AsyncTask वर्ग की संरचना इस प्रकार है:

private class MyTask extends AsyncTask<X, Y, Z>

    protected void onPreExecute(){ 

    } 

नया थ्रेड प्रारंभ करने से पहले इस विधि को निष्पादित किया जाता है। कोई इनपुट / आउटपुट मान नहीं है, इसलिए केवल चर या जो कुछ भी आपको लगता है कि आपको करने की आवश्यकता है, आरंभ करें।

protected Z doInBackground(X...x){

}

AsyncTask क्लास में सबसे महत्वपूर्ण तरीका। आपको पृष्ठभूमि के मुख्य भाग से अलग थ्रेड में, वह सब सामान रखना होगा जो आप पृष्ठभूमि में करना चाहते हैं। यहां हमारे पास "X" प्रकार की वस्तुओं का एक इनपुट मान है (क्या आप हेडर में देखते हैं? हमारे पास "... AsyncTask का विस्तार है" ये इनपुट मापदंडों के प्रकार हैं) और प्रकार से एक वस्तु लौटाते हैं "Z"।

संरक्षित शून्य onProgressUpdate (Y y) {

} इस विधि को विधि publishProgress (y) का उपयोग करके कहा जाता है और इसका उपयोग आमतौर पर तब किया जाता है जब आप किसी प्रगति या जानकारी को मुख्य स्क्रीन में दिखाना चाहते हैं, जैसे कि प्रगति बार जो आप पृष्ठभूमि में कर रहे हैं उसकी प्रगति दिखा रही है।

संरक्षित शून्य onPostExecute (Z z) {

} बैकग्राउंड में ऑपरेशन के बाद इस विधि को कहा जाता है। एक इनपुट पैरामीटर के रूप में आपको doInBackground विधि का आउटपुट पैरामीटर प्राप्त होगा।

X, Y और Z प्रकार के बारे में क्या?

जैसा कि आप उपरोक्त संरचना से घटा सकते हैं:

X – The type of the input variables value you want to set to the background process. This can be an array of objects.

 Y – The type of the objects you are going to enter in the onProgressUpdate method.

 Z – The type of the result from the operations you have done in the background process.

हम बाहर के वर्ग से इस कार्य को कैसे कहते हैं? बस निम्नलिखित दो पंक्तियों के साथ:

MyTask myTask = new MyTask();

myTask.execute(x);

जहाँ X, X प्रकार का इनपुट पैरामीटर है।

एक बार जब हमारा कार्य चल जाता है, तो हम "बाहर" से इसकी स्थिति का पता लगा सकते हैं। "GetStatus ()" विधि का उपयोग करना।

myTask.getStatus (); और हम निम्नलिखित स्थिति प्राप्त कर सकते हैं:

रनिंग - इंगित करता है कि कार्य चल रहा है।

PENDING - इंगित करता है कि कार्य अभी तक निष्पादित नहीं किया गया है।

समाप्त - इंगित करता है कि onPostExecute (Z) समाप्त हो गया है।

AsyncTask का उपयोग करने के बारे में संकेत

OnPreExecute, doInBackground और onPostExecute को मैन्युअल रूप से कॉल न करें। यह स्वचालित रूप से सिस्टम द्वारा किया जाता है।

आप किसी अन्य AsyncTask या थ्रेड के अंदर एक AsyncTask कॉल नहीं कर सकते। यूआई थ्रेड में विधि निष्पादित की कॉल किया जाना चाहिए।

OnPostExecute को UI थ्रेड में निष्पादित किया गया है (यहां आप एक और AsyncTask कॉल कर सकते हैं!)।

कार्य के इनपुट पैरामीटर ऑब्जेक्ट सरणी हो सकते हैं, इस तरह से आप जो भी वस्तुएं और प्रकार चाहते हैं, डाल सकते हैं।

Answer 4

आप या तो कार्य निर्माता में पैरामीटर पास कर सकते हैं या जब आप निष्पादन कहते हैं:

AsyncTask<Object, Void, MyTaskResult>

पहला पैरामीटर (ऑब्जेक्ट) doInBackground में पारित किया गया है। तीसरा पैरामीटर (MyTaskResult) doInBackground द्वारा लौटाया गया है। आप उन्हें अपने इच्छित प्रकारों में बदल सकते हैं। तीन बिंदुओं का अर्थ है कि शून्य या अधिक वस्तुओं (या उनमें से एक सरणी) को तर्क (नों) के रूप में पारित किया जा सकता है।

public class MyActivity extends AppCompatActivity {

    TextView textView1;
    TextView textView2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);    
        textView1 = (TextView) findViewById(R.id.textView1);
        textView2 = (TextView) findViewById(R.id.textView2);

        String input1 = "test";
        boolean input2 = true;
        int input3 = 100;
        long input4 = 100000000;

        new MyTask(input3, input4).execute(input1, input2);
    }

    private class MyTaskResult {
        String text1;
        String text2;
    }

    private class MyTask extends AsyncTask<Object, Void, MyTaskResult> {
        private String val1;
        private boolean val2;
        private int val3;
        private long val4;


        public MyTask(int in3, long in4) {
            this.val3 = in3;
            this.val4 = in4;

            // Do something ...
        }

        protected void onPreExecute() {
            // Do something ...
        }

        @Override
        protected MyTaskResult doInBackground(Object... params) {
            MyTaskResult res = new MyTaskResult();
            val1 = (String) params[0];
            val2 = (boolean) params[1];

            //Do some lengthy operation    
            res.text1 = RunProc1(val1);
            res.text2 = RunProc2(val2);

            return res;
        }

        @Override
        protected void onPostExecute(MyTaskResult res) {
            textView1.setText(res.text1);
            textView2.setText(res.text2);

        }
    }

}