"Android.view.WindowManager $ BadTokenException: impossibile aggiungere la finestra" su buider.show ()

Dal mio main activity, devo chiamare una classe interna e in un metodo all'interno della classe, devo mostrare AlertDialog. Dopo averlo chiuso, quando viene premuto il pulsante OK, inoltra a Google Play per l'acquisto.

Le cose funzionano perfettamente per la maggior parte delle volte, ma per pochi utenti si blocca builder.show()e posso vedere " "android.view.WindowManager$BadTokenException:Impossibile aggiungere la finestra" dal registro di arresto anomalo.

Il mio codice è più o meno così:

public class classname1 extends Activity{

  public void onCreate(Bundle savedInstanceState) {
    this.requestWindowFeature(Window.FEATURE_NO_TITLE);
    super.onCreate(savedInstanceState);
    setContentView(R.layout.<view>); 

    //call the <className1> class to execute
  }

  private class classNamename2 extends AsyncTask<String, Void, String>{

    protected String doInBackground(String... params) {}

    protected void onPostExecute(String result){
      if(page.contains("error")) 
      {
        AlertDialog.Builder builder = new AlertDialog.Builder(classname1.this);
        builder.setCancelable(true);
        builder.setMessage("");
        builder.setInverseBackgroundForced(true);
        builder.setNeutralButton("Ok",new DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int whichButton){
            dialog.dismiss();
            if(!<condition>)
            {
              try
              {
                String pl = ""; 

                mHelper.<flow>(<class>.this, SKU, RC_REQUEST, 
                  <listener>, pl);
              }

              catch(Exception e)
              {
                e.printStackTrace();
              }
            }  
          }
        });

        builder.show();
      }
    }
  }
}

Ho anche visto l'errore in un altro avviso in cui non sto inoltrando a nessun altro activity. È semplice così:

AlertDialog.Builder builder = new AlertDialog.Builder(classname1.this);
    builder.setCancelable(true);

    //if successful
    builder.setMessage(" ");
    builder.setInverseBackgroundForced(true);
    builder.setNeutralButton("Ok",new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int whichButton){
            // dialog.dismiss();
                   }
    });
    builder.show();
}

android.view.WindowManager$BadTokenException: Unable to add window"

Problema:

Questa eccezione si verifica quando l'app tenta di inviare una notifica all'utente dal thread in background (AsyncTask) aprendo una finestra di dialogo.

Se stai tentando di modificare l'interfaccia utente dal thread in background (di solito da onPostExecute () di AsyncTask) e se l'attività entra nella fase di completamento, ad esempio) chiamando esplicitamente finish (), l'utente che preme il pulsante home o indietro o la pulizia dell'attività eseguita da Android, allora tu ottenere questo errore.

Motivo :

Il motivo di questa eccezione è che, come dice il messaggio di eccezione, l'attività è terminata ma si sta tentando di visualizzare una finestra di dialogo con un contesto dell'attività finita. Poiché non esiste una finestra per la visualizzazione della finestra di dialogo, il runtime Android genera questa eccezione.

Soluzione:

Usa il isFinishing()metodo chiamato da Android per verificare se questa attività è in fase di completamento: che si tratti di una chiamata esplicita finish () o di una pulizia dell'attività eseguita da Android. Utilizzando questo metodo è molto facile evitare di aprire la finestra di dialogo dal thread in background al termine dell'attività.

Mantieni anche un weak referenceper l'attività (e non un riferimento forte in modo che l'attività possa essere distrutta una volta non necessaria) e controlla se l'attività non sta finendo prima di eseguire qualsiasi interfaccia utente utilizzando questo riferimento di attività (cioè mostrando una finestra di dialogo).

ad es .

private class chkSubscription extends AsyncTask<String, Void, String>{

  private final WeakReference<login> loginActivityWeakRef;

  public chkSubscription (login loginActivity) {
    super();
    this.loginActivityWeakRef= new WeakReference<login >(loginActivity)
  }

  protected String doInBackground(String... params) {
    //web service call
  }

  protected void onPostExecute(String result) {
    if(page.contains("error")) //when not subscribed
    {
      if (loginActivityWeakRef.get() != null && !loginActivityWeakRef.get().isFinishing()) {
        AlertDialog.Builder builder = new AlertDialog.Builder(login.this);
        builder.setCancelable(true);
        builder.setMessage(sucObject);
        builder.setInverseBackgroundForced(true);

        builder.setNeutralButton("Ok",new DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int whichButton){
            dialog.dismiss();
          }
        });

        builder.show();
      }
    }
  }
}

Aggiornare :

Gettoni finestra:

Come suggerisce il nome, un token finestra è un tipo speciale di token Binder che il gestore delle finestre utilizza per identificare in modo univoco una finestra nel sistema. I token delle finestre sono importanti per la sicurezza perché impediscono alle applicazioni dannose di disegnare sopra le finestre di altre applicazioni. Il window manager protegge da ciò richiedendo alle applicazioni di passare il token della finestra della loro applicazione come parte di ogni richiesta di aggiungere o rimuovere una finestra. Se i token non corrispondono, il window manager rifiuta la richiesta e genera un'eccezione BadTokenException . Senza i token di finestra, questo passaggio di identificazione necessario non sarebbe possibile e il gestore di finestre non sarebbe in grado di proteggersi da applicazioni dannose.

 Uno scenario del mondo reale:

Quando un'applicazione viene avviata per la prima volta,  ActivityManagerService  crea un tipo speciale di token finestra denominato token finestra dell'applicazione, che identifica in modo univoco la finestra contenitore di primo livello dell'applicazione. Il gestore delle attività fornisce questo token sia all'applicazione che al gestore delle finestre e l'applicazione invia il token al gestore delle finestre ogni volta che desidera aggiungere una nuova finestra allo schermo. Ciò garantisce un'interazione sicura tra l'applicazione e il gestore delle finestre (rendendo impossibile aggiungere finestre sopra altre applicazioni) e rende anche facile per il gestore delle attività effettuare richieste dirette al gestore delle finestre.

Avevo una finestra di dialogo che mostrava la funzione:

void showDialog(){
    new AlertDialog.Builder(MyActivity.this)
    ...
    .show();
}

Ho ricevuto questo errore e ho dovuto controllare isFinishing()prima di chiamare questa funzione di visualizzazione della finestra di dialogo.

if(!isFinishing())
    showDialog();

Il motivo possibile è il contesto della finestra di dialogo di avviso. Potresti aver terminato l'attività, quindi sta cercando di aprirsi in quel contesto ma che è già chiuso. Prova a cambiare il contesto di quella finestra di dialogo con la tua prima attività perché non sarà finita fino alla fine.

per esempio

piuttosto che questo.

AlertDialog alertDialog = new AlertDialog.Builder(this).create();

prova ad usare

AlertDialog alertDialog = new AlertDialog.Builder(FirstActivity.getInstance()).create();

• per prima cosa non puoi estendere AsyncTask senza sovrascrivere doInBackground

• secondo prova a creare AlterDailog dal builder, quindi chiama show ().

  private boolean visible = false;
  class chkSubscription extends AsyncTask<String, Void, String>
  {
  
      protected void onPostExecute(String result)
      {
          AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
          builder.setCancelable(true);
          builder.setMessage(sucObject);
          builder.setInverseBackgroundForced(true);
          builder.setNeutralButton("Ok", new DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int whichButton)
              {
                  dialog.dismiss();
              }
          });
  
          AlertDialog myAlertDialog = builder.create();
          if(visible) myAlertDialog.show();
      }
  
      @Override
      protected String doInBackground(String... arg0)
      {
          // TODO Auto-generated method stub
          return null;
      }
  }
  
  
  @Override
  protected void onResume()
  {
      // TODO Auto-generated method stub
      super.onResume();
      visible = true;
  }
  
  @Override
  protected void onStop()
  {
      visible = false; 
      super.onStop();
  }

Sto creando Dialog in onCreatee lo utilizzo con showe hide. Per me la causa principale non era il licenziamento onBackPressed, ovvero il completamento Homedell'attività.

@Override
public void onBackPressed() {
new AlertDialog.Builder(this)
                .setTitle("Really Exit?")
                .setMessage("Are you sure you want to exit?")
                .setNegativeButton(android.R.string.no, null)
                .setPositiveButton(android.R.string.yes,
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog,
                                    int which) {
                                Home.this.finish();
                                return;
                            }
                        }).create().show();

Stavo finendo l'attività Home onBackPressedsenza chiudere / chiudere le mie finestre di dialogo.

Quando ho chiuso i miei dialoghi, il crash è scomparso.

new AlertDialog.Builder(this)
                .setTitle("Really Exit?")
                .setMessage("Are you sure you want to exit?")
                .setNegativeButton(android.R.string.no, null)
                .setPositiveButton(android.R.string.yes,
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog,
                                    int which) {
                                networkErrorDialog.dismiss() ;
                                homeLocationErrorDialog.dismiss() ;
                                currentLocationErrorDialog.dismiss() ;
                                Home.this.finish();
                                return;
                            }
                        }).create().show();

Provo a risolverlo.

 AlertDialog.Builder builder = new AlertDialog.Builder(
                   this);
            builder.setCancelable(true);
            builder.setTitle("Opss!!");

            builder.setMessage("You Don't have anough coins to withdraw. ");
            builder.setMessage("Please read the Withdraw rules.");
            builder.setInverseBackgroundForced(true);
            builder.setPositiveButton("OK",
                    (dialog, which) -> dialog.dismiss());
            builder.create().show();

Prova questo :

    public class <class> extends Activity{

    private AlertDialog.Builder builder;

    public void onCreate(Bundle savedInstanceState) {
                    this.requestWindowFeature(Window.FEATURE_NO_TITLE);
                    super.onCreate(savedInstanceState);

                setContentView(R.layout.<view>); 

                builder = new AlertDialog.Builder(<class>.this);
                builder.setCancelable(true);
                builder.setMessage(<message>);
                builder.setInverseBackgroundForced(true);

        //call the <className> class to execute
}

    private class <className> extends AsyncTask<String, Void, String>{

    protected String doInBackground(String... params) {

    }
    protected void onPostExecute(String result){
        if(page.contains("error")) //when not subscribed
        {   
           if(builder!=null){
                builder.setNeutralButton("Ok",new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton){
                    dialog.dismiss();
                        if(!<condition>)
                        {
                        try
                        {
                        String pl = ""; 

                        mHelper.<flow>(<class>.this, SKU, RC_REQUEST, 
                        <listener>, pl);
                        }

                        catch(Exception e)
                        {
                        e.printStackTrace();
                        }
                    }  
                }
            });

            builder.show();
        }
    }

}
}

con questa idea delle variabili globali, ho salvato l'istanza MainActivity in onCreate (); Variabile globale Android

public class ApplicationController extends Application {

    public static MainActivity this_MainActivity;
}

e Apri finestra di dialogo in questo modo. ha funzionato.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Global Var
    globals = (ApplicationController) this.getApplication();
    globals.this_MainActivity = this;
}

e in un thread, apro una finestra di dialogo come questa.

AlertDialog.Builder alert = new AlertDialog.Builder(globals.this_MainActivity);

1. Apri MainActivity
2. Inizia un thread.
3. Apri finestra di dialogo dal thread -> lavoro.
4. Fai clic sul pulsante "Indietro" (onCreate verrà chiamato e rimuoverà il primo MainActivity)
5. Inizierà la nuova MainActivity. (e salva la sua istanza nelle globali)
6. Apri la finestra di dialogo dal primo thread -> si aprirà e funzionerà.

:)