java.lang.IllegalArgumentException: vista non allegata al gestore finestre

Ho un'attività che avvia AsyncTask e mostra la finestra di avanzamento per la durata dell'operazione. L'attività è dichiarata NON essere ricreata mediante rotazione o scorrimento della tastiera.

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

Una volta completata l'attività, rifiuto la finestra di dialogo, ma su alcuni telefoni (framework: 1.5, 1.6) viene generato tale errore:

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)

Il mio codice è:

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

Da quello che ho letto ( http://bend-ing.blogspot.com/2008/11/properly-handle-progress-dialog-in.html ) e visto nelle fonti Android, sembra l'unica situazione possibile per ottenerlo l'eccezione è quando l'attività è stata distrutta. Ma come ho già detto, proibisco attività ricreative per eventi di base.

Quindi ogni suggerimento è molto apprezzato.

Anch'io ricevo questo errore a volte quando chiudo la finestra di dialogo e finisco l'attività dal metodo onPostExecute. Immagino che a volte l'attività venga completata prima che il dialogo venga chiuso correttamente.

Soluzione semplice ma efficace che funziona per me

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

Ecco la mia soluzione "a prova di proiettile", che è la raccolta di tutte le buone risposte che ho trovato su questo argomento (grazie a @Damjan e @Kachi). Qui l'eccezione viene ingoiata solo se tutti gli altri modi di rilevamento non sono riusciti. Nel mio caso devo chiudere automaticamente la finestra di dialogo e questo è l'unico modo per proteggere l'app da crash. Spero che ti possa aiutare! Per favore, vota e lascia commenti se hai commenti o una soluzione migliore. Grazie!

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

Potrei avere una soluzione alternativa.

Stava avendo lo stesso problema, in cui sto caricando molti elementi (tramite il file system) in un ListViewtramite un AsyncTask. Ho dovuto onPreExecute()accendere un ProgressDialog, e poi entrambi onPostExecute()e onCancelled()(chiamato quando l'attività viene annullata esplicitamente tramite AsyncTask.cancel()) chiudendolo tramite .cancel().

Ho avuto lo stesso errore "java.lang.IllegalArgumentException: vista non allegata al gestore di finestre" quando stavo uccidendo la finestra di dialogo nel onCancelled()metodo del AsyncTask(l'avevo visto fatto nell'eccellente app Shelves ).

La soluzione alternativa era quella di creare un campo pubblico nel AsyncTaskche contenga ProgressDialog:

public ProgressDialog mDialog;

Quindi, onDestroy()quando annullo il mio AsyncTask, posso anche uccidere la finestra di dialogo associata tramite:

AsyncTask.mDialog.cancel();

Chiamando AsyncTask.cancel()DOES si attiva onCancelled()in AsyncTask, ma per qualche motivo quando viene chiamato quel metodo, la vista è già stata distrutta e quindi annullare la finestra di dialogo non riesce.

Ecco la soluzione corretta per risolvere questo problema:

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

Invece di cogliere ciecamente tutte le eccezioni, questa soluzione affronta la radice del problema: cercare di ridimensionare una finestra di dialogo quando l'attività utilizzata per inizializzare la finestra di dialogo è già stata completata. Funziona sul mio Nexus 4 con KitKat, ma dovrebbe funzionare con tutte le versioni di Android.

concordo con l'opinione di "Damjan".
se usi molte finestre di dialogo, dovresti chiudere tutte le finestre di dialogo in onDestroy () o onStop ().
allora potresti essere in grado di ridurre la frequenza 'si verifica l'eccezione' java.lang.IllegalArgumentException: vista non allegata al gestore finestre '.

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

ma poco superiore ...
per renderlo più chiaro, si impedisce di mostrare qualsiasi finestra dopo OnDestroy chiamato.
non uso come di seguito. ma è chiaro.

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

in bocca al lupo!

Usa questo.

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

Ho avuto lo stesso problema, puoi risolverlo:

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

Penso che il tuo codice sia corretto a differenza dell'altra risposta suggerita. onPostExecute verrà eseguito sul thread dell'interfaccia utente. Questo è il punto centrale di AsyncTask: non devi preoccuparti di chiamare runOnUiThread o trattare con i gestori. Inoltre, secondo i documenti, dismiss () può essere tranquillamente richiamato da qualsiasi thread (non sono sicuro che abbiano reso questa un'eccezione).

Forse è un problema di temporizzazione in cui dialog.dismiss () viene chiamato dopo che l'attività non viene più visualizzata?

Che ne dite di testare cosa succede se si commenta setOnCancelListener e quindi si chiude l'attività mentre l'attività in background è in esecuzione? Quindi onPostExecute proverà a chiudere una finestra di dialogo già ignorata. Se l'app si arresta in modo anomalo, probabilmente puoi semplicemente verificare se la finestra di dialogo è aperta prima di eliminarla.

Ho lo stesso identico problema, quindi lo proverò nel codice.

alex,

Potrei sbagliarmi qui, ma sospetto che più telefoni "in the wild" abbiano un bug che li induca a cambiare orientamento su applicazioni contrassegnate come orientate staticamente. Questo succede un po 'sul mio telefono personale e su molti dei telefoni di prova che il nostro gruppo utilizza (inclusi droid, n1, g1, hero). In genere un'app contrassegnata come orientata staticamente (forse in verticale) si stenderà per un secondo o due usando un orientamento orizzontale, quindi tornerà immediatamente indietro. Il risultato finale è che anche se non vuoi che la tua app cambi orientamento, devi essere pronto a farlo. Non so in quali condizioni esatte sia possibile riprodurre questo comportamento, non so se sia specifico per una versione di Android. Tutto quello che so è che l'ho visto accadere molte volte :(

Ti consiglio di utilizzare la soluzione fornita nel link che hai pubblicato che suggerisce di ignorare il metodo Activity onCreateDialog e di consentire al sistema operativo Android di gestire il ciclo di vita dei tuoi dialoghi. Mi sembra che anche se non vuoi che la tua attività cambi orientamento, sta cambiando orientamento da qualche parte. Puoi provare a rintracciare un metodo che impedirà sempre il cambio di orientamento, ma sto cercando di dirti che personalmente non credo che ci sia un modo infallibile che funziona su tutti gli attuali telefoni Android sul mercato.

Ciò che ha funzionato per me il più delle volte è verificare se l'attività non sta finendo.

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

L'attività è dichiarata NON essere ricreata mediante rotazione o scorrimento della tastiera.

Ho appena avuto lo stesso problema. Correzione per livello API 13 o superiore.
Dai documenti Android:

Nota: se l'applicazione è indirizzata al livello API 13 o superiore (come dichiarato dagli attributi minSdkVersion e targetSdkVersion), è necessario dichiarare anche la configurazione "screenSize", poiché cambia anche quando un dispositivo passa da orientamento verticale a orizzontale.

Quindi ho cambiato il mio manifest in questo:

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

E ora funziona benissimo. L'attività non viene ricreata quando ruoto il telefono, la finestra di dialogo di avanzamento e la visualizzazione rimangono invariati. Nessun errore per me.

Prima di tutto fai la gestione degli errori ovunque tu stia provando a chiudere la finestra di dialogo.

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

Se il problema persiste, ignoralo nel metodo onStop () dell'attività.

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

Ho avuto lo stesso problema durante l'utilizzo di un pulsante per sincronizzare un elenco dal server: 1) faccio clic sul pulsante 2) Viene visualizzata una finestra di dialogo durante il download dell'elenco dal server 3) Ruoto il dispositivo su un altro orientamento 4) java.lang .IllegalArgumentException: vista non allegata al gestore finestre su postExecute () di AsyncTask durante progress.dismiss ().

Mentre provavo la correzione, ho capito che anche se il problema non si verifica, il mio elenco non mostrava tutti gli elementi.

Ho pensato che quello che volevo fosse che AsyncTask finisse (e chiudesse la finestra di dialogo) prima che l'attività venisse distrutta, così ho fatto dell'oggetto asynctask un attributo e ho ignorato il metodo onDestroy ().

Se l'asynctask impiega molto tempo, forse l'utente sentirà che il dispositivo è lento, ma penso che sia il prezzo che paga per provare a cambiare l'orientamento del dispositivo mentre viene visualizzata la finestra di dialogo di avanzamento. E anche se ci vuole un po 'di tempo, l'app non si arresta in modo anomalo.

private AsyncTask<Boolean, Void, Boolean> atask;

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

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

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

Potrebbe sotto il codice funziona per te, funziona perfettamente per me:

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

Non definire la vista a livello globale se la si chiama dal servizio in background.