java.lang.IllegalArgumentException: विंडो प्रबंधक से संलग्न नहीं देखें

Question

मेरे पास एक गतिविधि है जो AsyncTask शुरू करती है और ऑपरेशन की अवधि के लिए प्रगति संवाद दिखाती है। गतिविधि को रोटेशन या कीबोर्ड स्लाइड द्वारा पुनः बनाए जाने की घोषणा नहीं की गई है।

    <activity android:name=".MyActivity" 
              android:label="@string/app_name"
              android:configChanges="keyboardHidden|orientation"
              >
        <intent-filter>
        </intent-filter>
    </activity>

एक बार कार्य पूरा हो जाने पर, मैं संवाद को समाप्त कर देता हूं, लेकिन कुछ फोन पर (फ्रेमवर्क: 1.5, 1.6) ऐसी त्रुटि डाली जाती है:

java.lang.IllegalArgumentException: View not attached to window manager
    at android.view.WindowManagerImpl.findViewLocked(WindowManagerImpl.java:356)
    at android.view.WindowManagerImpl.removeView(WindowManagerImpl.java:201)
    at android.view.Window$LocalWindowManager.removeView(Window.java:400)
    at android.app.Dialog.dismissDialog(Dialog.java:268)
    at android.app.Dialog.access$000(Dialog.java:69)
    at android.app.Dialog$1.run(Dialog.java:103)
    at android.app.Dialog.dismiss(Dialog.java:252)
    at xxx.onPostExecute(xxx$1.java:xxx)

मेरा कोड है:

final Dialog dialog = new AlertDialog.Builder(context)
    .setTitle("Processing...")
    .setCancelable(true)
    .create();

final AsyncTask<MyParams, Object, MyResult> task = new AsyncTask<MyParams, Object, MyResult>() {

    @Override
    protected MyResult doInBackground(MyParams... params) {
        // Long operation goes here
    }

    @Override
    protected void onPostExecute(MyResult result) {
        dialog.dismiss();
        onCompletion(result);
    }
};

task.execute(...);

dialog.setOnCancelListener(new OnCancelListener() {
    @Override
    public void onCancel(DialogInterface arg0) {
        task.cancel(false);
    }
});

dialog.show();

मैंने जो भी पढ़ा है ( http://bend-ing.blogspot.com/2008/11/properly-handle-progress-dialog-in.html ) और एंड्रॉइड स्रोतों में देखा, यह ऐसा करने के लिए केवल संभावित स्थिति जैसा दिखता है अपवाद तब था जब गतिविधि नष्ट हो गई थी। लेकिन जैसा कि मैंने उल्लेख किया है, मैं बुनियादी घटनाओं के लिए गतिविधि मनोरंजन को मना करता हूं।

तो किसी भी सुझाव बहुत सराहना की है।

Comments

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

— पराग कदम

Answer 1

मुझे भी कभी-कभी यह त्रुटि मिलती है जब मैं संवाद को खारिज करता हूं और onPostExecute विधि से गतिविधि समाप्त करता हूं। मुझे लगता है कि संवाद के सफलतापूर्वक खारिज होने से पहले कभी-कभी गतिविधि समाप्त हो जाती है।

सरल, अभी तक प्रभावी समाधान जो मेरे लिए काम करता है

@Override
protected void onPostExecute(MyResult result) {
    try {
        if ((this.mDialog != null) && this.mDialog.isShowing()) {
            this.mDialog.dismiss();
        }
    } catch (final IllegalArgumentException e) {
        // Handle or log or ignore
    } catch (final Exception e) {
        // Handle or log or ignore
    } finally {
        this.mDialog = null;
    }  
}

Comments

सरल उपाय? हाँ। प्रभावी? शायद इस मामले में। क्या मैं इसकी सिफारिश करूंगा? नहीं! उस तरह सभी अपवादों को न निगलें ! मैं IllegalArgumentException को भी नहीं पकड़ पाऊंगा, लेकिन दूसरे समाधान की तलाश करूंगा।

— साइमन फोर्सबर्ग

क्योंकि आमतौर पर खाली कोशिश करने वाला एक बुरा विचार है ... हालांकि यह कभी-कभी सही काम हो सकता है।

— थॉमस

@Damjan आपकी प्रतिक्रिया से आप अपवाद टाइप पकड़ने का सुझाव देते हैं। वैसे, यह Google द्वारा एक बुरा अभ्यास है। आप इसके बारे में यहां पढ़ सकते हैं: डोंट कैच जेनरिक एक्सेप्शन ।

— यानि

मेरा मानना ​​है कि यह एक प्रभावी सुधार है। सामान्य मामलों में, हमें ऐसा नहीं करना चाहिए, लेकिन चूंकि एंड्रॉइड फ्रेमवर्क हमारे लिए कोई आसान चेक प्रदान नहीं करता है, इसलिए हमें असामान्य तरीके का उपयोग करना होगा। साथ ही, यदि कोई डायलॉग इज ऑफिंग () कॉलिंग है जैसा कि हम उम्मीद करते हैं, तो हमें इस तरह के हैक की आवश्यकता नहीं है।

— SXC

जब तक कुछ बेहतर नहीं मिल जाता है, जल्दी ठीक करें

— रोहित तिग्गा

Answer 2

यहां मेरा "बुलेट प्रूफ" समाधान है, जो उन सभी अच्छे उत्तरों का संकलन है जो मुझे इस विषय पर मिले (@Damjan और @ काछी के लिए धन्यवाद)। यहां अपवाद केवल तभी निगल लिया जाता है जब अन्य सभी तरीकों का पता लगाने में सफल नहीं हुआ। मेरे मामले में मुझे स्वचालित रूप से संवाद बंद करने की आवश्यकता है और यह ऐप को क्रैश से बचाने का एकमात्र तरीका है। मुझे आशा है कि यह आपकी मदद करेगा! यदि आपके पास टिप्पणी या बेहतर समाधान है तो कृपया वोट दें और टिप्पणी छोड़ दें। धन्यवाद!

public void dismissWithCheck(Dialog dialog) {
        if (dialog != null) {
            if (dialog.isShowing()) {

                //get the Context object that was used to great the dialog
                Context context = ((ContextWrapper) dialog.getContext()).getBaseContext();

                // if the Context used here was an activity AND it hasn't been finished or destroyed
                // then dismiss it
                if (context instanceof Activity) {

                    // Api >=17
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                        if (!((Activity) context).isFinishing() && !((Activity) context).isDestroyed()) {
                            dismissWithTryCatch(dialog);
                        }
                    } else {

                        // Api < 17. Unfortunately cannot check for isDestroyed()
                        if (!((Activity) context).isFinishing()) {
                            dismissWithTryCatch(dialog);
                        }
                    }
                } else
                    // if the Context used wasn't an Activity, then dismiss it too
                    dismissWithTryCatch(dialog);
            }
            dialog = null;
        }
    }

    public void dismissWithTryCatch(Dialog dialog) {
        try {
            dialog.dismiss();
        } catch (final IllegalArgumentException e) {
            // Do nothing.
        } catch (final Exception e) {
            // Do nothing.
        } finally {
            dialog = null;
        }
    }

Comments

बहुत अच्छा समाधान! सेटिंग dialog = nullका कोई प्रभाव नहीं पड़ता है। और StatusEventDialogसिर्फ पढ़ना चाहिए Dialog।

— होजेबेल

StatusEventDialog को डायलॉग में बदलना चाहिए।

— श्रीकांत करुमनघाट

इस उत्तर स्वीकार किए जाते हैं एक, बहुत अच्छी तरह से नियंत्रित किया जाना चाहिए

— blueware

मैं समझता हूं कि आप "सही" होना चाहते हैं और केवल तभी प्रयास / कैच का उपयोग करें जब तक मामला isDestroyed()उपलब्ध न हो, लेकिन व्यावहारिक उद्देश्यों के लिए यह केवल कोशिश / कैच का हमेशा उपयोग करने के लिए समान नहीं होगा?

— ३

Answer 3

मुझे वर्कअराउंड हो सकता है।

एक ही मुद्दा रहा था, जहां मैं एक के ListViewमाध्यम से (फ़ाइल सिस्टम के माध्यम से ) बहुत सारी वस्तुओं को लोड कर रहा हूं AsyncTask। था onPreExecute()एक ऊपर फायरिंग ProgressDialog, और फिर दोनों onPostExecute()और onCancelled()(जब काम के माध्यम से स्पष्ट रूप से रद्द कर दिया गया कहा जाता है AsyncTask.cancel()) के माध्यम से इसे बंद करने .cancel()।

एक ही "java.lang.IllegalArgumentException समझे: विंडो मैनेजर से जुड़ी नहीं देखें" त्रुटि जब मैं संवाद को onCancelled()विधि में मार रहा था AsyncTask(मैंने इसे उत्कृष्ट शेल्व्स ऐप में किया है )।

वर्कअराउंड में एक सार्वजनिक फ़ील्ड बनाना था AsyncTaskजिसमें ProgressDialogनिम्न शामिल हैं :

public ProgressDialog mDialog;

फिर, onDestroy()जब मैं अपना रद्द करता हूं AsyncTask, तो मैं संबंधित संवाद को भी मार सकता हूं:

AsyncTask.mDialog.cancel();

कॉलिंग AsyncTask.cancel()करता ट्रिगर onCancelled()में AsyncTaskहै, लेकिन समय है कि विधि कहा जाता है से किसी कारण से, देखें पहले से ही नष्ट कर दिया गया है और इस तरह रद्द संवाद विफल हो रहा है।

Comments

मुझे लगता है कि UserTask कार्यान्वयन सिर्फ @Paul के रूप में उत्कृष्ट है। सोर्स कोड यहाँ है: code.google.com/p/shelves/source/browse/trunk/Shelves/src/org/…

— Evi Song

हालांकि उपयोग का मामला एक ही परियोजना में पाया जा सकता है: code.google.com/p/shelves/source/browse/trunk/Shelves/src/org/…

— Evi Song

Answer 4

यहाँ इस समस्या को हल करने का सही समाधान है:

public void hideProgress() {
    if(mProgressDialog != null) {
        if(mProgressDialog.isShowing()) { //check if dialog is showing.

            //get the Context object that was used to great the dialog
            Context context = ((ContextWrapper)mProgressDialog.getContext()).getBaseContext();

            //if the Context used here was an activity AND it hasn't been finished or destroyed
            //then dismiss it
            if(context instanceof Activity) { 
                if(!((Activity)context).isFinishing() && !((Activity)context).isDestroyed()) 
                    mProgressDialog.dismiss();
            } else //if the Context used wasnt an Activity, then dismiss it too
                mProgressDialog.dismiss();
        }
        mProgressDialog = null;
    }
}

नेत्रहीन रूप से सभी अपवादों को पकड़ने के बजाय, यह समाधान समस्या की जड़ को संबोधित करता है: एक संवाद को मंद करने की कोशिश जब संवाद को शुरू करने के लिए उपयोग की गई गतिविधि पहले ही समाप्त हो चुकी है। मेरे Nexus 4 पर चल रहे किटकैट पर काम करना, लेकिन Android के सभी संस्करणों के लिए काम करना चाहिए।

Comments

isDestroyedएपीआई 17+ की आवश्यकता है

— एंड्रॉइडर्स

आपको nPro पर mProgressDialog सेट करने की आवश्यकता क्यों है? क्या वह मेमोरी लीक से संबंधित है? क्या आप समझा सकते हैं?

— पवन

@ पवन, यह मेरे अंत में एक कार्यान्वयन विवरण है। यह आवश्यक नहीं है, यह इस वर्ग के कार्य का तरीका है। एक प्रगति संवाद छिपे होने के बाद, मैं इसे शून्य पर सेट करता हूं। जब कोई उपयोगकर्ता एक और प्रगति संवाद दिखाना चाहता है, तो एक नया उदाहरण त्वरित किया जाता है।

— कच्ची

निश्चित रूप से! ((गतिविधि) संदर्भ) .isFinishing () की आवश्यकता है, धन्यवाद! :)

— डैनियल क्रैज़्ज़कोव्स्की

Answer 5

मैं 'दामजन' के एक मत से सहमत हूँ।
यदि आप कई संवादों का उपयोग करते हैं, तो onDestroy () या onStop () में सभी संवाद बंद कर देना चाहिए।
तब आप आवृत्ति को कम करने में सक्षम हो सकते हैं 'java.lang.IllegalArgumentException: देखें विंडो प्रबंधक से जुड़ा नहीं' अपवाद होता है।

@Override
protected void onDestroy() {
    Log.d(TAG, "called onDestroy");
    mDialog.dismiss();
    super.onDestroy();
}

लेकिन थोड़ा अधिक ...
इसे और अधिक स्पष्ट करने के लिए, आप onDestroy नामक किसी भी डायलॉग को दिखाने से रोकते हैं।
मैं नीचे के रूप में उपयोग नहीं करते। लेकिन यह स्पष्ट है।

private boolean mIsDestroyed = false;

private void showDialog() {
    closeDialog();

    if (mIsDestroyed) {
        Log.d(TAG, "called onDestroy() already.");
        return;
    }

    mDialog = new AlertDialog(this)
        .setTitle("title")
        .setMessage("This is DialogTest")
        .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
            }
        })
        .create();
    mDialog.show();
}

private void closeDialog() {
    if (mDialog != null) {
        mDialog.dismiss();
    }
}

@Override
protected void onDestroy() {
    Log.d(TAG, "called onDestroy");
    mIsDestroyed = true;
    closeDialog();
    super.onDestroy();
}

सौभाग्य!

Comments

मैं हमेशा खाली कैच ब्लॉक से बचना पसंद करूंगा। एक कोशिश के लायक है, लेकिन चूंकि यह त्रुटि पैदा करना कठिन है - केवल समय ही बताएगा कि क्या यह वास्तव में काम कर रहा है। फिर भी धन्यवाद।

— Dr Fichman

खाली कैच ब्लॉक क्या है? मैं कोशिश / पकड़ का उपयोग नहीं करते। एक mIsDestroyed चर काम करने से अधिक है। लेकिन अगर आप दूसरे सूत्र में काम करने के बाद उस डायलॉग कोड को लिखते हैं, तो आपको इस चर की आवश्यकता हो सकती है। जब अन्य धागा काम कर रहा है, यदि गतिविधि समाप्त हो गई है, तो आप इस अपवाद को देख सकते हैं।

— हॉगुन

मेरे पास एक ही संभावना थी और जब मैंने @Override public void onPause () {if (डायलॉग! = Null) डायलॉग.dismiss () जोड़ा; super.onPause (); } वर्तमान तक मेरे पास यह त्रुटि नहीं है ... इसलिए मुझे लगता है कि यह आपके उत्तर की तरह ही है और इसका वास्तव में उपयोगी है

— क्रिस सिम

@ क्रिसमिस हैलो! onPuase () और onDestroy () विकृति है। जब गतिविधि onPuase होती है, तो संवाद बंद हो जाता है। और जब आप ऐप निष्पादित करते हैं, तो डायलॉग नहीं दिखाया जाता है। क्या आप इसे करना चाहते हैं?

— होगुन

@ हॉगुन बेशक, मेरा मतलब वही है, मैं संवाद को विराम देने के बजाए बंद कर रहा हूं क्योंकि मुझे इसकी आवश्यकता है कि विराम न दें। दूसरे, मैं इसे बंद कर रहा हूं जब यह शून्य नहीं है। दूसरों के लिए इसे समझाने के लिए धन्यवाद।

— क्रिस सिम

Answer 6

इसे इस्तेमाल करो।

if(_dialog!=null && _dialog.isShowing())
_dialog.dismiss();

Comments

यह लगभग वही समाधान है जो @Damjan ने प्रस्तावित किया था।

— यूरी

यह पर्याप्त नहीं है, IllegalArgumentException अभी भी इस चेक के साथ होती है।

— मर्फी

मैंने एक ही समाधान किया, लेकिन फिर भी यह नहीं पता कि यह प्रभावी है या नहीं। केवल अंतर है, मैंने दो को नेस्ट किया है यदि यह सुनिश्चित हो कि दूसरा भाग .isShowing () का मूल्यांकन नहीं किया जाएगा यदि वह अशक्त है।

— निक

यह पर्याप्त नहीं है।

— trante

@ निक: ifइस तरह के मामलों में कई लोगों को घोंसला बनाने की आवश्यकता नहीं है , जावा के &&ऑपरेटर का आलसी मूल्यांकन (जिसे शॉर्ट-सर्कुइंग भी कहा जाता है), जिसका अर्थ है कि 2 ऑपरेंड का मूल्यांकन नहीं किया जाता है यदि पहला मूल्यांकन किया जाता है false(जिसका अर्थ है परिणाम &&हमेशा रहेंगे falseवैसे भी, इसलिए "सुस्त" मूल्यांकन)। इसी तरह ||इसके 2 ऑपरेंड का मूल्यांकन नहीं होगा यदि पहले वाला मूल्यांकन करता है true। नोट: &और |ऑपरेटरों के पास यह व्यवहार नहीं है और इस तरह हमेशा दोनों ऑपरेंड का मूल्यांकन करते हैं।

— मथियास

Answer 7

मेरे पास एक ही समस्या थी, आप इसे हल कर सकते हैं:

@Override
protected void onPostExecute(MyResult result) {
    try {
        if ((this.mDialog != null) && this.mDialog.isShowing()) {
            this.mDialog.dismiss();
        }
    } catch (final IllegalArgumentException e) {
        // Handle or log or ignore
    } catch (final Exception e) {
        // Handle or log or ignore
    } finally {
        this.mDialog = null;
    }  
}

Answer 8

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

शायद यह एक समय का मुद्दा है जहां गतिविधि के बाद डायलॉगवाद () को बुलाया जा रहा है जो अब प्रदर्शित नहीं होता है?

यदि आप setOnCancelListener पर टिप्पणी करते हैं और फिर पृष्ठभूमि कार्य चल रहा है तो गतिविधि से बाहर निकलने पर परीक्षण करने के बारे में क्या होगा? तब आपका onPostExecute पहले से खारिज किए गए संवाद को खारिज करने की कोशिश करेगा। यदि ऐप क्रैश हो जाता है, तो संभवतः आप यह जांच सकते हैं कि क्या संवाद खारिज करने से पहले खुला है।

मुझे ठीक वैसी ही समस्या हो रही है इसलिए मैं इसे कोड में आज़माने जा रहा हूं।

Comments

मैंने डिमिस () कोड में भी देखा, और वास्तव में, इसे किसी भी धागे से सुरक्षित रूप से बुलाया जा सकता है। BTW, मुझे परीक्षण में समस्या है, क्योंकि यह समस्या उपयोगकर्ताओं के फोन पर होती है, और मैं कभी भी अपने आप को पुन: उत्पन्न करने में सक्षम नहीं था :-( इसलिए कोड का विश्लेषण करके यह पता लगाने की कोशिश कर रहा हूं ... समय के अनुसार। मैं इस पर सोच रहा था। लेकिन ऐसी स्थिति की कल्पना नहीं कर सकते हैं कि डायलॉग से पहले गतिविधि को कैसे बंद किया जा सकता है। यदि बैक दबाया जाता है, तो वह पहले डायलॉग को रद्द कर देगा। और गतिविधि को प्रकट फ़ाइल द्वारा मना कर दिया जाता है, लेकिन हो सकता है कि यह अभी भी कुछ कैसे बनाया जा सकता है? मुझे पता है अगर तुम कुछ मिल जाए!

— एलेक्स 2k8

Answer 9

एलेक्स,

मैं यहां गलत हो सकता हूं, लेकिन मुझे संदेह है कि कई फोन 'वाइल्ड' में एक बग है, जो उन्हें उन अनुप्रयोगों पर उन्मुखीकरण स्विच करने का कारण बनता है जो सांख्यिकीय रूप से उन्मुख के रूप में चिह्नित हैं। यह मेरे व्यक्तिगत फोन पर काफी कुछ होता है, और कई परीक्षण फोन पर हमारे समूह का उपयोग करता है (droid, n1, g1, नायक सहित)। आमतौर पर सांख्यिकीय रूप से उन्मुख (शायद लंबवत) के रूप में चिह्नित एक ऐप क्षैतिज अभिविन्यास का उपयोग करके एक या दो सेकंड के लिए खुद को बाहर कर देगा, और फिर वापस स्विच करेगा। अंतिम परिणाम यह है कि भले ही आप अपने ऐप को अभिविन्यास स्विच नहीं करना चाहते हैं, आपको तैयार रहना होगा कि यह हो सकता है। मुझे नहीं पता कि यह व्यवहार किन सटीक परिस्थितियों में पुन: पेश किया जा सकता है, मुझे नहीं पता कि यह एंड्रॉइड के संस्करण के लिए विशिष्ट है या नहीं। मुझे पता है कि मैंने इसे बहुत बार देखा है :(

मैं आपके द्वारा पोस्ट किए गए लिंक में दिए गए समाधान का उपयोग करने की सलाह दूंगा जो गतिविधि onCreateDialog पद्धति को ओवरराइड करने का सुझाव देता है और Android OS को आपके संवाद के जीवनचक्र का प्रबंधन करने देता है। यह मेरी तरह दिखता है, भले ही आप अपनी गतिविधि को झुकाव को बदलना नहीं चाहते हों, यह कहीं न कहीं उन्मुखीकरण को बदल रहा है। आप एक ऐसी विधि को ट्रैक करने का प्रयास कर सकते हैं जो हमेशा अभिविन्यास स्विचन को रोकेगी, लेकिन मैं आपको यह बताने की कोशिश कर रहा हूं कि मुझे व्यक्तिगत रूप से विश्वास नहीं है कि एक मूर्खतापूर्ण तरीका है जो बाजार में सभी मौजूदा एंड्रॉइड फोन पर काम करता है।

Comments

आप अपने डिवाइस को ओरिएंटेशन स्विच करने से रख सकते हैं, लेकिन अन्य कॉन्फ़िगरेशन परिवर्तनों का एक समूह है जो आपकी गतिविधि को नष्ट / पुन: बनाता है - एक कीबोर्ड को अंदर या बाहर खिसका रहा है।

— मैक्सिमम जूल

Answer 10

मेरे लिए ज्यादातर समय जो काम किया है वह यह सत्यापित करना है कि गतिविधि समाप्त नहीं हो रही है या नहीं।

if (!mActivity.isFinishing()) {
    dialog.dismiss();
}

Answer 11

गतिविधि को रोटेशन या कीबोर्ड स्लाइड द्वारा पुनः बनाए जाने की घोषणा नहीं की गई है।

बस वही समस्या है। एपीआई स्तर 13 या हाइगर के लिए ठीक करें।
Android डॉक्स से:

नोट: यदि आपका एप्लिकेशन API स्तर 13 या उच्चतर (जैसा कि minSdkVersion और targetSdkVersion विशेषताओं द्वारा घोषित किया गया है) को लक्षित करता है, तो आपको "स्क्रीनसाइज़" कॉन्फ़िगरेशन भी घोषित करना चाहिए, क्योंकि यह तब भी बदलता है जब कोई उपकरण पोर्ट्रेट और लैंडस्केप ओरिएंटेशन के बीच बदल जाता है।

इसलिए मैंने इस पर अपनी उपस्थिति बदल दी है:

<activity
        android:name="MyActivity"
        android:configChanges="orientation|screenSize"
        android:label="MyActivityName" >
</activity>

और अब यह ठीक काम करता है। जब मैं फोन घुमाता हूं, तो गतिविधि फिर से नहीं बनती है, संवाद और प्रगति समान रहती है। मेरे लिए कोई त्रुटि नहीं।

Comments

यह कोई हल नहीं है। उदाहरण के लिए मेरे पास और Adob ​​से Adview गतिविधि है और इसे आकार में परिवर्तन के लिए गतिविधि को फिर से बनाना चाहिए।

— बत्तमीसी

Answer 12

सबसे पहले त्रुटि से निपटने के लिए जहां आप कभी भी संवाद को खारिज करने की कोशिश कर रहे हैं।

 if ((progressDialog != null) && progressDialog.isShowing()) {
            progressDialog.dismiss();
            progressDialog = null;
        }

यदि वह ठीक नहीं करता है तो इसे onStop () गतिविधि की विधि में खारिज कर दें।

 @Override
    protected void onStop() {
        super.onStop();
        if ((progressDialog != null) && progressDialog.isShowing()) {
            progressDialog.dismiss();
            progressDialog = null;
        }
    }

Answer 13

सर्वर से सूची को सिंक करने के लिए बटन का उपयोग करते समय मुझे यही समस्या थी: 1) मैं बटन पर क्लिक करता हूं 2) सर्वर 3 से सूची को डाउलोड करने के दौरान एक प्रगति संवाद दिखाता है) मैं डिवाइस को अन्य अभिविन्यास 4 में बदल देता हूं) java.lang .IllegalArgumentException: प्रगति के दौरान AsyncTask के postExecute () पर विंडो मैनेजर के साथ संलग्न नहीं देखें।

जैसा कि मैंने ठीक करने की कोशिश की मुझे लगा कि अगर समस्या नहीं होती है तो भी मेरी सूची सभी आइटम नहीं दिखा रही है।

मुझे लगा कि जो मैं चाहता था कि एस्किनटस्क को खत्म करने के लिए (और डायलॉग को खारिज कर दिया जाए) इससे पहले कि एक्टिविस्ट को नष्ट कर दिया जाए, इसलिए मैंने एसिंक्टस्क ऑब्जेक्ट को एक विशेषता बना दिया और ऑनडेस्ट्रॉय () विधि को ओवरराइड कर दिया।

यदि एसिंक्टस्क में बहुत समय लगता है तो उपयोगकर्ता को शायद यह महसूस होगा कि डिवाइस धीमा है, लेकिन मुझे लगता है कि डिवाइस की अभिविन्यास को बदलने की कोशिश करने के लिए वह कीमत चुकाता है जबकि प्रगति संवाद दिख रहा है। और भले ही ऐप को क्रैश होने में कुछ समय लगे।

private AsyncTask<Boolean, Void, Boolean> atask;

@Override
protected void onDestroy() {
    if (atask!=null)
        try {
            atask.get();
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {
        }
    super.onDestroy();
}

Answer 14

@Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);

            if (progressDialog != null && progressDialog.isShowing()) {
                Log.i(TAG, "onPostexucte");
                progressDialog.dismiss();
}
}

Comments

हालांकि यह कोड स्निपेट इस सवाल का जवाब दे सकता है कि यह समस्या को हल करने के बारे में कुछ स्पष्टीकरण प्रदान करता है कि भविष्य के आगंतुकों को साइट पर अपना जवाब समझने में मदद मिलेगी

— RobV

Answer 15

आप के लिए काम के नीचे Migh काम करता है, यह मेरे लिए पूरी तरह से ठीक काम करता है:

private void viewDialog() {
    try {
        Intent vpnIntent = new Intent(context, UtilityVpnService.class);
        context.startService(vpnIntent);
        final View Dialogview = View.inflate(getBaseContext(), R.layout.alert_open_internet, null);
        final WindowManager.LayoutParams params = new WindowManager.LayoutParams(
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.TYPE_SYSTEM_ALERT,
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                        | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_DIM_BEHIND,
                PixelFormat.TRANSLUCENT);
        params.gravity = Gravity.CENTER_HORIZONTAL | Gravity.CENTER_VERTICAL;
        windowManager.addView(Dialogview, params);

        Button btn_cancel = (Button) Dialogview.findViewById(R.id.btn_canceldialog_internetblocked);
        Button btn_okay = (Button) Dialogview.findViewById(R.id.btn_openmainactivity);
        RelativeLayout relativeLayout = (RelativeLayout) Dialogview.findViewById(R.id.rellayout_dialog);

            btn_cancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Handler handler = new Handler(Looper.getMainLooper());
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                if (Dialogview != null) {
//                                ( (WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
                                    windowManager.removeView(Dialogview);
                                }
                            } catch (final IllegalArgumentException e) {
                                e.printStackTrace();
                                // Handle or log or ignore
                            } catch (final Exception e) {
                                e.printStackTrace();
                                // Handle or log or ignore
                            } finally {
                                try {
                                    if (windowManager != null && Dialogview != null) {
//                                    ((WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
                                        windowManager.removeView(Dialogview);
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                            //    ((WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
//                        windowManager.removeView(Dialogview);


                        }
                    });
                }
            });
            btn_okay.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Handler handler = new Handler(Looper.getMainLooper());
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            //        ((WindowManager) getApplicationContext().getSystemService(WINDOW_SERVICE)).removeView(Dialogview);
                            try {
                                if (windowManager != null && Dialogview != null)
                                    windowManager.removeView(Dialogview);
                                Intent intent = new Intent(getBaseContext(), SplashActivity.class);
                                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
//                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);


                                context.startActivity(intent);
                            } catch (Exception e) {
                                windowManager.removeView(Dialogview);
                                e.printStackTrace();
                            }
                        }
                    });
                }
            });
        } catch (Exception e) {
            //` windowManager.removeView(Dialogview);
            e.printStackTrace();
        }
    }

अगर आप इसे पृष्ठभूमि सेवा से कहते हैं, तो विश्व स्तर पर अपने दृष्टिकोण को परिभाषित न करें।