“Android.view.WindowManager $ BadTokenException: Não é possível adicionar janela” em buider.show ()

Do meu principal activity, preciso chamar uma classe interna e, em um método dentro da classe, preciso mostrar AlertDialog. Depois de dispensá-lo, quando o botão OK for pressionado, encaminhe para o Google Play para compra.

As coisas funcionam perfeitamente na maioria das vezes, mas para poucos usuários está travando builder.show()e posso ver "android.view.WindowManager$BadTokenException:Não é possível adicionar janela "no log de travamento. Por favor, sugira.

Meu código é mais ou menos assim:

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

Também vi o erro em outro alerta onde não estou encaminhando para nenhum outro activity. É simples assim:

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:

Essa exceção ocorre quando o aplicativo está tentando notificar o usuário do thread de segundo plano (AsyncTask) abrindo uma caixa de diálogo.

Se você estiver tentando modificar a IU a partir do thread de segundo plano (geralmente de onPostExecute () de AsyncTask) e se a atividade entrar no estágio de finalização, ou seja, chamar explicitamente finish (), usuário pressionando o botão home ou voltar ou limpeza de atividade feita pelo Android, então você obter este erro.

Razão:

O motivo dessa exceção é que, como diz a mensagem de exceção, a atividade foi concluída, mas você está tentando exibir uma caixa de diálogo com um contexto da atividade concluída. Como não há janela para a caixa de diálogo exibir o tempo de execução do Android, essa exceção é lançada.

Solução:

Use o isFinishing()método que é chamado pelo Android para verificar se esta atividade está em processo de finalização: seja uma chamada final explícita () ou limpeza de atividade feita pelo Android. Usando este método, é muito fácil evitar a abertura da caixa de diálogo do thread de fundo quando a atividade está terminando.

Além disso, mantenha um weak referencepara a atividade (e não uma referência forte para que a atividade possa ser destruída quando não for necessária) e verifique se a atividade não está terminando antes de executar qualquer IU usando esta referência de atividade (ou seja, mostrando uma caixa de diálogo).

por exemplo .

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

Atualização:

Tokens de janela:

Como o próprio nome indica, um token de janela é um tipo especial de token Binder que o gerenciador de janelas usa para identificar exclusivamente uma janela no sistema. Os tokens de janela são importantes para a segurança porque tornam impossível que aplicativos maliciosos sejam colocados sobre as janelas de outros aplicativos. O gerenciador de janelas protege contra isso exigindo que os aplicativos passem o token de janela de seu aplicativo como parte de cada solicitação para adicionar ou remover uma janela. Se os tokens não corresponderem, o gerenciador de janelas rejeita a solicitação e lança uma BadTokenException . Sem os tokens de janela, essa etapa de identificação necessária não seria possível e o gerenciador de janelas não seria capaz de se proteger de aplicativos maliciosos.

 Um cenário do mundo real:

Quando um aplicativo é inicializado pela primeira vez, o  ActivityManagerService  cria um tipo especial de token de janela chamado token de janela de aplicativo, que identifica exclusivamente a janela de contêiner de nível superior do aplicativo. O gerenciador de atividades fornece esse token para o aplicativo e o gerenciador de janelas, e o aplicativo envia o token para o gerenciador de janelas cada vez que deseja adicionar uma nova janela à tela. Isso garante uma interação segura entre o aplicativo e o gerenciador de janelas (tornando impossível adicionar janelas em cima de outros aplicativos) e também torna mais fácil para o gerenciador de atividades fazer solicitações diretas ao gerenciador de janelas.

Tive uma caixa de diálogo mostrando a função:

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

Eu estava recebendo este erro e só tive que verificar isFinishing()antes de chamar esta caixa de diálogo que mostra a função.

if(!isFinishing())
    showDialog();

O possível motivo é o contexto da caixa de diálogo de alerta. Você pode ter terminado aquela atividade então ela está tentando abrir naquele contexto, mas que já está fechado. Tente mudar o contexto desse diálogo para a sua primeira atividade, porque ele não será concluído até o final.

por exemplo

em vez disso.

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

tente usar

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

• primeiro você não pode estender AsyncTask sem substituir doInBackground

• em seguida, tente criar AlterDailog a partir do construtor e, em seguida, chame 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();
  }

Estou criando Dialog em onCreatee usando-o com showe hide. Para mim a causa raiz não foi demitir onBackPressed, que foi encerrar a Homeatividade.

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

Eu estava terminando a Atividade doméstica onBackPressedsem fechar / dispensar meus diálogos.

Quando descartei minhas caixas de diálogo, a falha desapareceu.

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

Eu tento resolver isso.

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

Experimente isto:

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

}
}

com essa ideia de variáveis ​​globais, salvei a instância MainActivity em onCreate (); Variável global Android

public class ApplicationController extends Application {

    public static MainActivity this_MainActivity;
}

e abrir diálogo como este. funcionou.

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

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

e em um tópico, eu abro um diálogo como este.

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

1. Abrir MainActivity
2. Comece um tópico.
3. Abra a caixa de diálogo do tópico -> trabalho.
4. Clique no "botão Voltar" (onCreate será chamado e removerá primeiro MainActivity)
5. Nova MainActivity será iniciada. (e salve sua instância para globais)
6. Abra a caixa de diálogo do primeiro tópico -> ela abrirá e funcionará.

:)