L'attività ha fatto trapelare la finestra che era stata inizialmente aggiunta

Cos'è questo errore e perché succede?

05-17 18:24:57.069: ERROR/WindowManager(18850): Activity com.mypkg.myP has leaked window com.android.internal.policy.impl.PhoneWindow$DecorView@44c46ff0 that was originally added here
05-17 18:24:57.069: ERROR/WindowManager(18850): android.view.WindowLeaked: Activity ccom.mypkg.myP has leaked window com.android.internal.policy.impl.PhoneWindow$DecorView@44c46ff0 that was originally added here
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.view.ViewRoot.<init>(ViewRoot.java:231)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:148)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:91)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.view.Window$LocalWindowManager.addView(Window.java:424)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.Dialog.show(Dialog.java:239)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at com.mypkg.myP$PreparePairingLinkageData.onPreExecute(viewP.java:183)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.os.AsyncTask.execute(AsyncTask.java:391)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at com.mypkg.myP.onCreate(viewP.java:94)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1047)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2544)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2621)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.ActivityThread.access$2200(ActivityThread.java:126)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1932)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.os.Handler.dispatchMessage(Handler.java:99)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.os.Looper.loop(Looper.java:123)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at android.app.ActivityThread.main(ActivityThread.java:4595)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at java.lang.reflect.Method.invokeNative(Native Method)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at java.lang.reflect.Method.invoke(Method.java:521)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:860)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:618)
05-17 18:24:57.069: ERROR/WindowManager(18850):     at dalvik.system.NativeStart.main(Native Method)

Stai cercando di mostrare una finestra di dialogo dopo essere uscito da un'attività.

[MODIFICARE]

Questa domanda è una delle principali ricerche su Google per gli sviluppatori Android, pertanto l'aggiunta di alcuni punti importanti dai commenti, che potrebbe essere più utile per il futuro investigatore senza approfondire la conversazione di commento.

Risposta 1 :

Stai cercando di mostrare una finestra di dialogo dopo essere uscito da un'attività.

Risposta 2

Questo errore può essere un po 'fuorviante in alcune circostanze (anche se la risposta è ancora completamente accurata) - vale a dire nel mio caso è stata generata un'eccezione non gestita in un AsyncTask, che ha causato l'arresto dell'attività, quindi un dialogo progressdia aperto ha causato questa eccezione ... la "vera" eccezione era un po 'prima nel registro

Risposta 3

Chiama dismiss () sull'istanza di Dialog che hai creato prima di uscire dalla tua attività, ad esempio in onPause () o onDestroy ()

La soluzione è quella di chiamare dismiss()l' Dialogutente creato viewP.java:183prima di uscire Activity, ad es onPause(). Tutti i Windows & Dialogs devono essere chiusi prima di lasciare un Activity.

Se si utilizza AsyncTask, probabilmente quel messaggio di registro può essere ingannevole. Se guardi nel tuo registro, potresti trovare un altro errore, probabilmente uno nel tuo doInBackground()metodo AsyncTask, che sta facendo Activityesplodere la tua corrente , e quindi una volta che AsyncTaskritorna .. beh, conosci il resto. Alcuni altri utenti hanno già spiegato che qui :-)

Ho innescato questo errore chiamando erroneamente hide()invece che dismiss()su un AlertDialog.

È possibile ottenere questa eccezione solo per un errore semplice / stupido, chiamando (ad esempio) accidentalmente finish()dopo aver visualizzato un AlertDialog, se si perde un'istruzione di chiamata di interruzione in un'istruzione switch ...

   @Override
   public void onClick(View v) {
    switch (v.getId()) {
        case R.id.new_button:
            openMyAlertDialog();
            break; <-- If you forget this the finish() method below 
                       will be called while the dialog is showing!
        case R.id.exit_button:
            finish();
            break;
        }
    }

Il finish()metodo chiuderà il Activity, ma AlertDialogè ancora visualizzato!

Quindi, quando stai fissando attentamente il codice, cercando problemi di threading difettosi o codifica complessa e simili, non perdere di vista la foresta per gli alberi. A volte può essere solo qualcosa di semplice e stupido come una dichiarazione di rottura mancante. :)

Le risposte a questa domanda erano tutte corrette, ma un po 'confuse per me capire davvero il perché. Dopo aver giocato per circa 2 ore, il motivo di questo errore (nel mio caso) mi ha colpito:

Sai già, dalla lettura di altre risposte, che l' X has leaked window DecorView@d9e6131[]errore ha significa che una finestra di dialogo era aperta quando l'app è stata chiusa. Ma perché?

È possibile che l'app si sia arrestata in modo anomalo per qualche altro motivo mentre la finestra di dialogo era aperta

Ciò ha comportato la chiusura dell'app a causa di alcuni bug nel codice, che hanno portato alla finestra di dialogo aperta contemporaneamente alla chiusura dell'app a causa dell'altro errore.

Quindi, guarda attraverso la tua logica. Risolvi il primo errore, quindi il secondo errore si risolverà da solo

Un errore ne provoca un altro, che ne causa un altro, come DOMINOS!

Questo problema si presenta quando si tenta di mostrare una finestra di dialogo dopo essere usciti da un'attività.

Ho appena risolto questo problema semplicemente scrivendo il seguente codice:

@Override
public void onDestroy(){
    super.onDestroy();
    if ( progressDialog!=null && progressDialog.isShowing() ){
        progressDialog.cancel();
    }
}

Fondamentalmente, da quale classe hai iniziato progressDialog, sovrascrivi il metodo Distruggi e fai in questo modo. Ha risolto il problema "L'attività ha perso la finestra".

Di recente ho affrontato lo stesso problema.

Il motivo alla base di questo problema è che l'attività viene chiusa prima che la finestra di dialogo venga chiusa. Vi sono vari motivi per cui ciò accada. Anche quelli menzionati nei post precedenti sono corretti.

Mi sono trovato in una situazione, perché nel thread stavo chiamando una funzione che stava gettando un'eccezione. Per questo motivo la finestra veniva respinta e quindi l'eccezione.

Chiudi la finestra di dialogo quando l'attività viene distrutta

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

Questo potrebbe aiutare.

if (! isFinishing()) {

    dialog.show();

    }

Ho avuto lo stesso oscuro messaggio di errore e non avevo idea del perché. Dati gli indizi delle risposte precedenti, ho modificato le mie chiamate non GUI in mDialog.finish () in mDialog.dismiss () e gli errori sono scomparsi. Ciò non ha influito sul comportamento del mio widget, ma è stato sconcertante e avrebbe potuto benissimo segnalare un'importante perdita di memoria.

Stavo ottenendo questi registri nella mia applicazione di riproduzione video. Questi messaggi venivano generati mentre il video player era chiuso. È interessante notare che ho usato questi registri una volta ogni poche volte in modo casuale. Inoltre la mia applicazione non prevede alcun progressdialog. Alla fine, ho risolto questo problema con l'implementazione di seguito.

@Override
protected void onPause()
{
    Log.v("MediaVideo", "onPause");
    super.onPause();
    this.mVideoView.pause();
    this.mVideoView.setVisibility(View.GONE);
}

@Override
protected void onDestroy()
{
    Log.v("MediaVideo", "onDestroy");
    super.onDestroy();
}

@Override
protected void onResume()
{
    Log.v("MediaVideo", "onResume");
    super.onResume();
    this.mVideoView.resume();
}

Sostituisci OnPausecon with call mVideoView.pause()e il set visibilityto GONE. In questo modo ho potuto risolvere il " Activity has leaked window" problema dell'errore di registro.

Stavo avendo lo stesso problema e ho trovato questa pagina e, sebbene la mia situazione fosse diversa, ho chiamato finishda un ifblocco prima che definisse la casella di avviso.

Quindi, semplicemente chiamare dismissnon funzionerebbe (poiché non è stato ancora fatto) ma dopo aver letto la risposta di Alex Volovoy e aver capito che era la casella di avviso che lo causava. Ho provato ad aggiungere una dichiarazione di ritorno subito dopo la fineif blocco e questo ha risolto il problema.

Ho pensato che una volta che hai chiamato finish, ha fermato tutto e finito proprio lì, ma non lo fa. Sembra andare alla fine del blocco di codice in cui si trova, quindi termina.

Quindi, se vuoi implementare una situazione in cui a volte finirà prima di fare un po 'di codice, devi mettere una dichiarazione di ritorno subito dopo il traguardo o continuerà ad andare e agire come se il traguardo fosse chiamato alla fine del blocco di codice non nel modo in cui lo hai chiamato. Ecco perché stavo ottenendo tutti quegli strani errori.

private picked(File aDirectory){
     if(aDirectory.length()==0){
        setResult(RESULT_CANCELED, new Intent()); 
        finish(); 
        return;
    }
     AlertDialog.Builder alert= new AlertDialog.Builder(this); // Start dialog builder
     alert
        .setTitle("Question")
        .setMessage("Do you want to open that file?"+aDirectory.getName());
    alert
        .setPositiveButton("OK", okButtonListener)
        .setNegativeButton("Cancel", cancelButtonListener);
    alert.show();
}

Se non inserisci il reso subito dopo che ho chiamato finish, si comporterà come se lo avessi chiamato dopo il alert.show(); e quindi direbbe che la finestra trapelava finendo subito dopo aver fatto apparire la finestra di dialogo, anche se quello è non è il caso, pensa ancora di si.

Ho pensato di aggiungere questo come qui in quanto mostra che il comando di fine ha agito diversamente, quindi ho pensato che lo facesse e immagino che ci siano altre persone che la pensano allo stesso modo prima di scoprirlo.

Questa non è la risposta alla domanda ma è rilevante per l'argomento.

Se l'attività ha definito un attributo nel manifest

 android:noHistory="true"

quindi dopo aver eseguito onPause (), il contesto dell'attività viene perso. Quindi tutte le viste che usano questo contesto potrebbero dare questo errore.

Non solo prova a mostrare un avviso, ma può anche essere invocato quando finisci una particolare istanza di attività e provi ad avviare una nuova attività / servizio o provi a fermarlo.

Esempio:

OldActivity instance;

    oncreate() {
       instance=this;
    }
    instance.finish();
    instance.startActivity(new Intent(ACTION_MAIN).setClass(instance, NewActivity.class));

Generalmente questo problema si verifica a causa della finestra di dialogo di avanzamento: è possibile risolverlo utilizzando uno dei seguenti metodi nella propria attività:

 // 1):
          @Override
                protected void onPause() {
                    super.onPause();
                    if ( yourProgressDialog!=null && yourProgressDialog.isShowing() )
                  {
                        yourProgressDialog.cancel();
                    }
                }

       // 2) :
         @Override
            protected void onDestroy() {
                super.onDestroy();
                if ( yourProgressDialog!=null && yourProgressDialog.isShowing()
               {
                    yourProgressDialog.cancel();
                }
            }

Ho avuto il problema quando ho finito un'attività quando è stato ancora mostrato un ProgressDialog.

Quindi prima nascondi la finestra di dialogo e poi termina l'attività.

Prova questo codice:

public class Sample extends Activity(){
@Override
 public void onCreate(Bundle instance){

}
 @Override
    public void onStop() {
        super.onStop();
      progressdialog.dismiss(); // try this
    }

}

Questo può essere se si verifica un errore nella doInBackground()funzione e si dispone di questo codice.

Prova ad aggiungere finalmente la finestra di dialogo. Inizialmente controlla e correggi la doInBackground()funzione

protected void onPreExecute() {
     super.onPreExecute();
     pDialog = new ProgressDialog(CreateAccount.this);
     pDialog.setMessage("Creating Product..");
     pDialog.setIndeterminate(false);
     pDialog.setCancelable(true);
     pDialog.show();

 }

 protected String doInBackground(String...args) {
     ERROR CAN BE IS HERE
 }

 protected void onPostExecute(String file_url) {
     // dismiss the dialog once done
     pDialog.dismiss();

Questo è accaduto a me quando sto usando ProgressDialogin AsyncTask. In realtà sto usando il hide()metodo in onPostExecute. Sulla base della risposta del @alex Volovoy ho bisogno di usare dismiss()con ProgressDialogper rimuoverlo in OnPostExecute e il suo fare.

progressDialog.hide(); // Don't use it, it gives error

progressDialog.dismiss(); // Use it

L' Activity has leaked window that was originally added...errore " " si verifica quando si tenta di mostrare un avviso dopo che Activityè efficace finished.

Hai due opzioni AFAIK:

1. Ripensa al login del tuo avviso: chiama dismiss()ildialog prima realmente di uscire la vostra attività.
2. Inserisci il dialogin un thread diverso ed eseguilo su quello thread(indipendente dalla corrente activity).

ecco una soluzione quando si desidera chiudere AlertDialog ma non si desidera mantenere un riferimento ad esso all'interno dell'attività.

la soluzione richiede di avere androidx.lifecycle dipendenza nel progetto (credo che al momento del commento sia un requisito comune)

questo ti consente di delegare il rifiuto della finestra di dialogo a un oggetto esterno (osservatore) e non devi più preoccupartene, perché viene annullato automaticamente quando l'attività muore. (ecco la prova: https://github.com/googlecodelabs/android-lifecycles/issues/5 ).

così, l'osservatore mantiene il riferimento al dialogo e l'attività mantiene il riferimento all'osservatore. quando "onPause" accade - l'osservatore chiude la finestra di dialogo e quando "onDestroy" accade - l'attività rimuove l'osservatore, quindi non si verificano perdite (beh, almeno non vedo più errori nel logcat)

// observer
class DialogDismissLifecycleObserver( private var dialog: AlertDialog? ) : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        dialog?.dismiss()
        dialog = null
    }
}
// activity code
private fun showDialog() {
        if( isDestroyed || isFinishing ) return
        val dialog = AlertDialog
            .Builder(this, R.style.DialogTheme)
            // dialog setup skipped
            .create()
        lifecycle.addObserver( DialogDismissLifecycleObserver( dialog ) )
        dialog.show()
}

Le eccezioni trapelate dalla finestra hanno due motivi:

1) mostrando la finestra di dialogo quando non esiste Contesto attività, per risolvere questo problema dovresti mostrare la finestra di dialogo solo se sei sicuro che l'attività esiste:

if(getActivity()!= null && !getActivity().isFinishing()){
        Dialog.show();
}

2) non chiudere la finestra di dialogo in modo appropriato, per risolvere utilizzare questo codice:

@Override
public void onDestroy(){
    super.onDestroy();
    if ( Dialog!=null && Dialog.isShowing() ){
        Dialog.dismiss();
}
}

Devi fare Progressdialogoggetto nel onPreExecutemetodo di AsyncTaske dovresti dismissfarlo sul onPostExecutemetodo.

La soluzione migliore è semplicemente aggiungere la finestra di dialogo nel tentativo di catturare e chiudere la finestra di dialogo quando si verificano eccezioni

Basta usare il codice qui sotto

 try {
        dialog.show();
    } catch (Exception e) {
        dialog.dismiss();
    }

Nel mio caso, il motivo era che ho dimenticato di includere un'autorizzazione nel file manifest di Android.

Come l'ho scoperto? Bene, proprio come dice @Bobby in un commento sotto la risposta accettata, scorri ancora più in alto nei tuoi registri e vedrai il primo motivo o evento che ha lanciato l'eccezione. Apparentemente, il messaggio "L'attività ha trapelato la finestra che era stata inizialmente aggiunta" è solo un'eccezione risultante da qualunque sia la prima eccezione.

Prova sotto il codice, funzionerà ogni volta che chiuderai la finestra di avanzamento e vedrà se la sua istanza è disponibile o meno.

try {
        if (null != progressDialog && progressDialog.isShowing()) {
            progressDialog.dismiss();
            progressDialog = null;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

La soluzione migliore è mettere questo prima di mostrare progressbaroprogressDialog

if (getApplicationContext().getWindow().getDecorView().isShown()) {

  //Show Your Progress Dialog

}

Assicurati solo che la tua attività non si chiuda in modo imprevisto a causa di alcune eccezioni sollevate da qualche parte nel tuo codice. Generalmente accade nell'attività asincrona quando l'attività affronta la chiusura forzata nel metodo doinBackground e quindi asynctask ritorna al metodo onPostexecute.

Ho un'altra soluzione per questo, e vorrei sapere se ti sembra valido: invece di chiudere in onDestroy, che sembra essere la soluzione principale, sto estendendo ProgressDialog ...

public class MyProgressDialog extends ProgressDialog {

  private boolean isDismissed;

  public MyProgressDialog(Context context) {
    super(context);
  }

  @Override
  public void onDetachedFromWindow() {
    super.onDetachedFromWindow();
    dismiss();
  }

  @Override
  public void dismiss() {
    if (isDismissed) {
      return;
    }
    try {
      super.dismiss();
    } catch (IllegalArgumentException e) {
      // ignore
    }
    isDismissed = true;
  }

Questo è preferibile, AFAIC, perché non devi tenere la finestra di dialogo di avanzamento come membro, basta sparare (mostra) e dimenticare