Meu aplicativo Android está sendo chamado por um intent que está passando informações (pendenteintent na barra de status).

Quando eu clico no botão home e reabra meu aplicativo segurando o botão home, ele chama a intenção novamente e os mesmos extras ainda estão lá.

    @Override
    public void onSaveInstanceState(Bundle savedInstanceState) {
      super.onSaveInstanceState(savedInstanceState);
    }
    @Override
    public void onRestoreInstanceState(Bundle savedInstanceState) {
      super.onRestoreInstanceState(savedInstanceState);
    }

este é o código que não funciona como deveria

    String imgUrl;
    Bundle extras = this.getIntent().getExtras();


    if(extras != null){
        imgUrl = extras.getString("imgUrl");
        if( !imgUrl.equals(textView01.getText().toString()) ){

            imageView.setImageDrawable( getImageFromUrl( imgUrl ) );
            layout1.setVisibility(0);
            textView01.setText(imgUrl);//textview to hold the url

        }

    }

E minha intenção:

public void showNotification(String ticker, String title, String message, 
    String imgUrl){
    String ns = Context.NOTIFICATION_SERVICE;
    NotificationManager mNotificationManager = 
        (NotificationManager) getSystemService(ns);
    int icon = R.drawable.icon;        // icon from resources
    long when = System.currentTimeMillis();         // notification time
    CharSequence tickerText = ticker;              // ticker-text

    //make intent
    Intent notificationIntent = new Intent(this, activity.class);
    notificationIntent.putExtra("imgUrl", imgUrl);
    notificationIntent.setFlags(
        PendingIntent.FLAG_UPDATE_CURRENT | 
        PendingIntent.FLAG_ONE_SHOT);
    PendingIntent contentIntent = 
        PendingIntent.getActivity(this, 0, 
        notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT | 
        PendingIntent.FLAG_ONE_SHOT);

    //make notification
    Notification notification = new Notification(icon, tickerText, when);
    notification.setLatestEventInfo(this, title, message, contentIntent);
    //flags
    notification.flags = Notification.FLAG_SHOW_LIGHTS | 
        Notification.FLAG_ONGOING_EVENT | 
        Notification.FLAG_ONLY_ALERT_ONCE | 
        Notification.FLAG_AUTO_CANCEL;
    //sounds
    notification.defaults |= Notification.DEFAULT_SOUND;
    //notify
    mNotificationManager.notify(1, notification);
}

Existe alguma maneira de limpar o intent ou verificar se ele já foi usado antes?

ATUALIZAR:

Eu não sabia que essa resposta seria muito referida quando a escrevi pela primeira vez, há mais de 5 anos!

Vou esclarecer para apontar que, de acordo com a resposta @ tato-rodrigo, isso não ajudará você a detectar uma intenção já tratada em algumas situações.

Além disso, devo apontar que coloquei "claro" entre aspas por um motivo - você não está realmente limpando a intenção ao fazer isso, você está apenas usando a remoção do extra como um sinalizador de que essa intenção já foi vista pela atividade .

Eu tive exatamente o mesmo problema.

A resposta acima me colocou no caminho certo e encontrei uma solução ainda mais simples, use o:

getIntent().removeExtra("key"); 

chamada de método para "limpar" o Intent.

É um pouco tarde para responder, já que isso foi perguntado há um ano, mas espero que isso ajude outras pessoas no futuro.

EDITAR: Estou editando para postar a solução completa que estou usando.

Esta solução funcionará se o problema for "Não executar algum código quando a atividade começar no histórico (aplicativos recentes)" .

Em primeiro lugar, declare um booleanem seu Activitypara indicar se o Intentjá foi consumido:

    private boolean consumedIntent;

Em seguida, armazene e restaure esse valor com segurança usando os métodos onSaveInstanceStatee onCreatepara lidar com alterações de configuração e casos em que o sistema pode interromper o seu Activityquando for para segundo plano.

    private final String SAVED_INSTANCE_STATE_CONSUMED_INTENT = "SAVED_INSTANCE_STATE_CONSUMED_INTENT";

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putBoolean(SAVED_INSTANCE_STATE_CONSUMED_INTENT, consumedIntent);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //set content view ...

        if( savedInstanceState != null ) {
            consumedIntent = savedInstanceState.getBoolean(SAVED_INSTANCE_STATE_CONSUMED_INTENT);
        }

        //other initializations
    }

Agora, verifique se você pode executar seu código no onResumemétodo.

    @Override
    protected void onResume() {
        super.onResume();

        //check if this intent should run your code
        //for example, check the Intent action
        boolean shouldThisIntentTriggerMyCode = [...];
        Intent intent = getIntent();
        boolean launchedFromHistory = intent != null ? (intent.getFlags() & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) != 0 : false;
        if( !launchedFromHistory && shouldThisIntentTriggerMyCode && !consumedIntent ) {
            consumedIntent = true;
            //execute the code that should be executed if the activity was not launched from history
        }
    }

Além disso, se Activityestiver configurado para singleTop, você deve redefinir seu sinalizador quando um novo Intentfor entregue.

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        setIntent(intent);
        consumedIntent = false;
    }

A resposta do Maks funciona para limpar um extra:

    getIntent().removeExtra("key"); 

Outro comando útil é:

    getIntent().setAction("");

Você também pode marcar uma intent chamando:

    getIntent().putExtra("used", true);

e depois é só verificar o valor.

Quando lançamos aplicativos Android do History (Recent Apps), o aplicativo pode ser iniciado com três sinalizadores de Intent diferentes.

1. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
   É quando a atividade está sendo iniciada a partir do histórico de um aplicativo que foi minimizado (pressione longamente a tecla home).
   Valor constante: 1048576 (0x00100000)
2. FLAG_ACTIVITY_NEW_TASK
   É quando a atividade é iniciada por meio de "clicar no ícone do aplicativo" ou por meio de " Filtros de intenção ". Aqui, a atividade se tornará o início de uma nova tarefa nesta pilha de histórico.
   Valor constante: 268435456 (0x10000000)
3. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY | FLAG_ACTIVITY_NEW_TASK
   Isso é quando o aplicativo foi encerrado pressionando o botão Voltar e, em seguida, reiniciado do Histórico (aplicativos recentes).
   Valor constante: 269484032 (0x10100000)

O valor constante pode ser recuperado via getIntent().getFlags()

No terceiro caso, o Android recarrega os últimos valores de Intent de sua memória. Portanto, a intenção do seu aplicativo (getIntent ) do terá valores do último intent que iniciou o aplicativo.

Na verdade, o aplicativo deve se comportar como se fosse um novo lançamento, com valores de intents para um novo lançamento, em vez dos valores de intent do lançamento anterior. Esse comportamento pode ser visto se você iniciar o aplicativo clicando no ícone do aplicativo, ele nunca terá valores de intenção antigos. Isso ocorre porque o Android usa o seguinte filtro de intent para este cenário

 <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER"/>
 </intent-filter>

Mas, no terceiro caso (aplicativo que foi encerrado, é iniciado a partir do histórico de aplicativos recentes), o sistema operacional Android usa a última intenção que iniciou o aplicativo antes de ser encerrado (pressionando o botão Voltar). Então, você acaba tendo valores de intent antigos e o fluxo do aplicativo não é adequado.

Remover a intenção é uma maneira de resolver, mas não resolveria o problema completamente! À medida que o Android OS recarrega o intent do último lançamento do aplicativo, e não da última instância do intent de lançamento.

Uma maneira limpa de evitar que isso aconteça é lidar com isso obtendo o tipo de Intent para determinar o tipo de inicialização.

Assim, no seu LaunchActivity (aquele que tem o filtro de intenção definida no manifesto), você pode usar o seguinte código nos onCreate(), onStart()ou onResume()métodos.

if(getIntent().getFlags() == (Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY)) {
    //app is launched from recent apps after it was closed
        normalLaunch();
    } else {
        String intentAction = getIntent().getAction();
        String scheme = getIntent().getScheme();
        //app is launched via other means
        // URL intent scheme, Intent action etc
        if("https".equalsIgnoreCase(scheme)) {
            // URL intent for browser
        } else if("com.example.bb".equalsIgnoreCase(intentAction)) {
            // App launched via package name
        } else {
            // App was launched via Click on App Icon, or other means
            normalLaunch();
        }
    }

Presumo normalLaunch()que não deva usar parâmetros do Intent; caso contrário, você precisaria separar e otimizar seu método de inicialização padrão para não usar parâmetros de intent.

Limpando um objeto de intent :

intent.replaceExtras(new Bundle());
intent.setAction("");
intent.setData(null);
intent.setFlags(0);

A resposta curta é jeito nenhum

Resposta longa. Não existe essa coisa de intenção "one-shot". A partir da experiência, é observado que o histórico de atividades recentes em Androids modernos nada mais é do que "histórico de intenções". A última intenção passada à atividade é simplesmente registrada no sistema e esse é o negócio. O pessoal acima sugere o uso

setAction("")

Mas não funciona porque a intenção já está registrada até o momento em que você a coloca dentro do método onNewIntent () ou onStart ().

Resolvi o problema evitando o uso de intents. Meu problema era semelhante ao postado pelo autor. Tentei implementar a Saída Global do aplicativo via controle na área de notificação. Ele deve interromper o serviço subjacente e fechar todas as atividades do aplicativo. Você pode encontrar o mesmo comportamento no aplicativo Waze.

O algoritmo:

1. Crie PendingIntent para controle de notificação que passa a ação "Sair" para a atividade. Mas para a atividade especial, que é um simples proxy.
2. O código onStart () da atividade de proxy analisa a intenção, verifica a ação e define o estado de algum modelo como "Exited".
3. O código onStart () da atividade proxy limpa o intent original usando setIntent ("") e, em seguida, o encaminha para a atividade "Root" de destino chamando startActivity (intent).
4. O código onStart () da atividade do proxy invoca o finish ().
5. Dentro de onStart () e onNewIntent () da atividade de destino, verifique o estado do modelo e chame finish () se for "Exited" (e também chame stopService () no meu caso).

Espero que ajude alguém porque não encontrei a resposta na internet.

Certifique-se de que você está usando PendingIntent.FLAG_UPDATE_CURRENT bandeira para PendingIntent .

PendingIntent pendingIntent = PendingIntent.getActivity(this, 100, mPutIntent, PendingIntent.FLAG_UPDATE_CURRENT);

Onde mPutIntentestá o seuIntent .

Espero que isso ajude você.

Recentemente, tive esse problema e o resolvi adicionando um carimbo de data / hora como um parâmetro extra ao intent:

private void launchActivity(Context context) {
    Intent intent = new Intent(context, MainActivity.class);
    intent.putExtra("KEY_EXTRA_TIMESTAMP", System.currentTimeMillis());
    context.startActivity(intent);
}

Depois disso, salve o carimbo de data / hora nas preferências compartilhadas:

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

    long time = getIntent().getLongExtra("KEY_EXTRA_TIMESTAMP", -1);
    long previousTime = getPreferences(MODE_PRIVATE).getLong("timestamp", -1);

    //ignore if the timestamp is the same as the previous one  
    if (time != previousTime) {
        handleIntent(getIntent());
        if (time != -1) {
            //save the timestamp
            getPreferences(MODE_PRIVATE).edit().putLong("timestamp", time).apply();
        }
    }
}

Eu tenho exatamente o mesmo problema. Minha solução foi adicionar a booleanvariável que foi definida quando Intentfoi 'usado' e uma ifinstrução baseada nisso booleanpara verificar se você deveria usar Intentou não.

Quando terminar de processar o Intent, faça o seguinte:

setIntent(null);

Você não verá aquele Intent processado novamente e não mascarará o problema editando o conteúdo do Intent processado.

Não consegui encontrar uma maneira de remover o Intent Extra . Nenhuma das respostas sobre a remoção de extras da intenção funciona se você ativar "Não manter atividades " nas Opções do desenvolvedor (dessa forma, você pode destruir a atividade e voltar para testar se os extras ainda estão lá).

Como solução para o problema, armazenei o valor booleano em SharedPreferences após o processamento dos Intent Extras. Quando o mesmo Intent é reenviado para a Activity, eu verifico o valor SharedPreference e decido processar o Intent Extra. Caso você envie outro novo Intent Extra para a mesma Activity, você torna o valor SharedPreference falso e Activity irá processá-lo. Exemplo :

// Start Activity with Intent Extras
Intent intent = new Intent(context, MyActivity.class);
intent.putExtra("someData", "my Data");
// Set data as not processed
context.getSharedPreferences(BuildConfig.APPLICATION_ID, Context.MODE_PRIVATE).edit().putBoolean("myActivityExtraProccessed", false).commit();
context.startActivity(intent);

...

public class MyActivity{

    ...
    public void someMethod(){
        boolean isExtrasProcessed = context.getSharedPreferences(BuildConfig.APPLICATION_ID, Context.MODE_PRIVATE).getBoolean("myActivityExtraProccessed", false);  
         if (!isExtrasProcessed) {
              // Use Extras

              //Set data as processed
              context.getSharedPreferences(BuildConfig.APPLICATION_ID, Context.MODE_PRIVATE).edit().putBoolean("myActivityExtraProccessed", true).commit();
         }
    }

}

Mesmo depois de limpar manualmente os extras de Intent e Intent depois de terem sido analisados, parece que Activity.getIntent () sempre retornará o Intent original que iniciou a Activity.

Para contornar isso, recomendo algo assim:

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // The Intent provided by getIntent() (and its extras) will persist through a restore
    // via savedInstance.  Because of this, restoring this activity from a
    // an instance that was originally started with extras (deep-link or 
    // pre-defined destination) may cause un-desired behavior
    // (ie...infinite loop of sending the user directly to somewhere else because of a
    // pre-defined alternate destination in the Intent's extras).
    //
    // To get around this, if restoring from savedInstanceState, we explicitly
    // set a new Intent *** to override the original Intent that started the activity.***
    // Note...it is still possible to re-use the original Intent values...simply
    // set them in the savedInstanceState Bundle in onSavedInstanceState.
    if (savedInstanceState != null) {
        // Place savedInstanceState Bundle as the Intent "extras"
        setIntent(new Intent().putExtras(savedInstanceState));
    }

    processIntent(getIntent())
}

private void processIntent(Intent intent) {
    if (getIntent().getExtras() == null) {
        // Protection condition
        return;
    }

    doSomething(intent.getExtras.getString("SOMETHING_I_REALLY_NEED_TO_PERSIST"));

    final String somethingIDontWantToPersist = 
        intent.getExtras.getString("SOMETHING_I_DONT_WANT_TO_PERSIST");

    if(somethingIDontWantToPersist != null) {
        doSomething(somethingIDontWantToPersist);
    }
}

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save selective extras from original Intent...
    savedInstanceState.putString("SOMETHING_I_REALLY_NEED_TO_PERSIST", "persistedValued");
    super.onSaveInstanceState(savedInstanceState);
}

Dessa forma, há um mecanismo para descartar o Intent original enquanto ainda retém a capacidade de reter explicitamente certas partes dos extras do Intent / Intent originais.

Observe que não testei todos os modos de inicialização de atividade.

A maneira direta é evitar chamar getIntent () de métodos diferentes de onCreate (). Mas isso causará problemas durante o próximo lançamento se o usuário deixar nossa atividade tocando no botão Início. Acho que esse problema não tem uma solução totalmente funcional.

Eu enfrento o mesmo problema e tento usar os métodos acima, mas não funciona.

Eu acho que pode ser a causa do modo de inicialização da atividade que usei o modo singleTop.

Quando eu uso o aplicativo em segundo plano e uso o RamEater para simular o problema, essa intenção sempre tem um valor extra, mesmo que seja definida como nula ou removida a chave.

O problema foi resolvido usando o armazenamento de preferência no Android para verificar se havia passado.

Não é uma boa prática adicionar outro extra apenas para saber se os extras foram consumidos ou não, porque não fazer isto ?:

if (intent.hasExtra(EXTRA_NAME) && intent.getBooleanExtra(EXTRA_NAME, false)) {
    // consume extra here after that set it to false
    putExtra(EXTRA_NAME, false)
}   

Que tal agora? Define newIntent como a intenção.

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    setIntent(intent);
}

Que tal quando você deseja limpar a intenção - substituí-la por uma vazia?

por exemplo.

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    setIntent(intent);
}

@Override 
public void onResume() {
    super.onResume();

    Intent theIntent = getIntent();
    if ("myaction".equals(theIntent.getAction()) {
         handleIntent();
         onNewIntent(new Intent());  // <--- "clear" the intent by setting empty one
    }
}

Espero que isso ajude a todos. Então, primeiro temos a intenção

//globally
Intent myIntent;

Coloque isso em algum lugar em Criar

myIntent = getIntent();
String data = myIntent.getStringExtra("yourdata");
//Your process here

Agora vamos definir isso para que toda vez que nosso aplicativo for destruído ou encerrado, removeremos os dados

@Override
protected void onDestroy() {
    //TODO: Clear intents
    super.onDestroy();
    myIntent.removeExtra("data");
}
@Override
protected void onBackPressed() {
    //TODO: Clear intents
    super.onBackPressed();
    myIntent.removeExtra("data");
}

Você entendeu, se isso não for suficiente, encontre mais chamadas de retorno ativas

Enquanto o Intent.removeExtra("key")irá remover uma chave específica dos extras, há também o método Intent.replaceExtras (Bundle) , que pode ser usado para excluir todos os extras do Intent, se nullfor passado como um parâmetro.

Dos documentos:

Substitua completamente os extras no Intent pelo Pacote de extras fornecido.

Parâmetros
extras O novo conjunto de extras no Intent, ou null para apagar todos os extras.

Como os métodos putXXX () inicializam os extras com um novo Bundle se for nulo, isso não é problema.

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 
intent.addCategory(Intent.CATEGORY_HOME);  
startActivity(intent);