La mia app Android viene chiamata da un intento che sta passando informazioni (in attesa nella barra di stato).

Quando premo il pulsante Home e riapro la mia app tenendo premuto il pulsante Home, richiama nuovamente l'intento e gli stessi extra sono ancora lì.

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

questo è il codice che non funziona come dovrebbe

    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 il mio intento:

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

C'è un modo per cancellare l'intento o verificare se è stato utilizzato in precedenza?

AGGIORNARE:

Non mi rendevo conto che questa risposta sarebbe stata citata così tanto quando l'ho scritta per la prima volta più di 5 anni fa!

Chiarisco per sottolineare che come per la risposta di @ tato-rodrigo questo non ti aiuterà a rilevare un intento già gestito in alcune situazioni.

Inoltre vorrei sottolineare ho messo "chiaro" tra virgolette per una ragione - che si sta non cancellando in realtà l'intento in questo modo, si sta usando solo la rimozione della extra come una bandiera che questo intento è stato visto da l'attività già .

Ho avuto esattamente lo stesso problema.

La risposta sopra mi ha messo sulla strada giusta e ho trovato una soluzione ancora più semplice, usa il:

getIntent().removeExtra("key"); 

chiamata al metodo per "cancellare" l'Intent.

È un po 'tardi per rispondere da quando è stato chiesto un anno fa, ma si spera che questo aiuti gli altri in futuro.

EDIT: sto modificando per pubblicare la soluzione completa che sto usando.

Questa soluzione funzionerà se il problema è "Non eseguire codice quando l'attività inizia dalla cronologia (app recenti)" .

Prima di tutto, dichiara una booleannel tuo Activityper indicare se Intentera già consumato:

    private boolean consumedIntent;

Quindi, memorizzare e ripristinare in modo sicuro questo valore utilizzando i metodi onSaveInstanceStatee onCreateper gestire le modifiche alla configurazione e i casi in cui il sistema potrebbe interromperti Activityquando passa in background.

    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
    }

Ora, controlla se puoi eseguire il codice con il onResumemetodo.

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

Inoltre, se sei Activityconfigurato per singleTop, dovresti reimpostare il flag quando ne Intentviene consegnato uno nuovo .

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

La risposta di Maks funziona per cancellare un extra:

    getIntent().removeExtra("key"); 

Un altro comando utile è:

    getIntent().setAction("");

Puoi anche taggare un intento chiamando:

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

e quindi controlla il valore.

Quando avviamo le app Android dalla cronologia (app recenti), l'app potrebbe essere avviata principalmente con tre diversi flag di intento.

1. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
   Questo è quando l'attività viene avviata dalla cronologia di un'app che è stata ridotta a icona (premere a lungo il tasto Home).
   Valore costante: 1048576 (0x00100000)
2. FLAG_ACTIVITY_NEW_TASK
   Questo è quando l'attività viene avviata tramite "clic sull'icona dell'applicazione" o tramite " filtri di intenzione ". Qui l'attività diventerà l'inizio di una nuova attività in questo stack di cronologia.
   Valore costante: 268435456 (0x10000000)
3. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY | FLAG_ACTIVITY_NEW_TASK
   Questo è quando l'app è stata chiusa premendo il pulsante Indietro e quindi ripresa dalla cronologia (app recenti).
   Valore costante: 269484032 (0x10100000)

Il valore costante può essere recuperato tramite getIntent().getFlags()

Nel terzo caso, Android ricarica gli ultimi valori di Intent dalla sua memoria. Quindi l'intent ( getIntent) della tua app avrà valori dall'ultimo intento che ha avviato l'app.

In realtà, l'app dovrebbe comportarsi come se fosse un nuovo lancio, con valori di intenti per un nuovo lancio piuttosto che i valori di intenti del lancio precedente. Questo comportamento può essere visto se avvii l'app facendo clic sull'icona dell'app, non avrà mai i vecchi valori di intento. Questo perché Android utilizza il seguente filtro per intenti per questo scenario

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

Ma nel terzo caso (l'app che è stata chiusa, viene avviata dalla cronologia delle app recenti), il sistema operativo Android utilizza l'ultimo intento che ha avviato l'app prima che venisse chiusa (premendo il pulsante Indietro). Quindi finisci per avere vecchi valori di intenti e il flusso dell'app non è corretto.

Rimuovere l'intento è un modo per risolverlo, ma non risolverebbe completamente il problema! Quando il sistema operativo Android ricarica l'intento dall'ultimo avvio delle app e non dall'ultima istanza dell'intento di avvio.

Un modo pulito per evitare che ciò accada è gestirlo ottenendo il tipo di Intent per determinare il tipo di lancio.

Quindi nel tuo LaunchActivity (quella che ha il filtro intento definito nel manifesto), è possibile utilizzare il seguente codice nei onCreate(), onStart()o onResume()metodi.

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(), non dovrebbe utilizzare i parametri dall'intento; altrimenti sarebbe necessario separare e ottimizzare il metodo di avvio predefinito per non utilizzare i parametri Intent.

Cancellazione di un oggetto intento :

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

La risposta breve è Assolutamente no

Risposta lunga. Non esiste l'intento "one-shot". Dall'esperimento si è osservato che la storia delle attività recenti nei moderni Androidi non è altro che "Storia degli intenti". L'ultimo intento passato all'attività viene semplicemente registrato nel sistema e questo è l'affare. Le persone sopra suggeriscono di usare

setAction("")

Ma non funziona perché l'intento è già registrato fino al momento in cui lo ottieni nel metodo onNewIntent () o onStart ().

Ho risolto il problema evitando l'uso di intenti. Il mio problema era simile a quello pubblicato dall'autore. Ho provato a implementare l'uscita globale dall'applicazione tramite il controllo nell'area di notifica. Dovrebbe arrestare il servizio sottostante e chiudere tutte le attività dell'app. Puoi trovare lo stesso comportamento nell'applicazione Waze.

L'algoritmo:

1. Crea PendingIntent per il controllo delle notifiche che passa l'azione "Exit" all'attività. Ma all'attività speciale che è un semplice proxy.
2. Il codice Proxy activity onStart () analizza l'intento, controlla l'azione e imposta lo stato di alcuni modelli su "Exited".
3. Il codice dell'attività proxy onStart () cancella l'intento originale utilizzando setIntent ("") e quindi lo inoltra all'attività "Root" di destinazione chiamando startActivity (intent).
4. Attività proxy sul codice Start () invoca finish ().
5. All'interno di onStart () e onNewIntent () dell'attività di destinazione, controlla lo stato del modello e chiama finish () se è "Exited" (e nel mio caso chiama anche stopService ()).

Spero che questo possa aiutare qualcuno perché non ho trovato la risposta su Internet.

Assicurarsi che si sta utilizzando PendingIntent.FLAG_UPDATE_CURRENT bandiera per PendingIntent .

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

Dov'è il mPutIntenttuo Intent.

Spero che questo ti possa aiutare.

Recentemente ho avuto questo problema e l'ho risolto aggiungendo un timestamp come parametro extra all'intento:

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

Successivamente, salva il timestamp nelle preferenze condivise:

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

Ho esattamente lo stesso problema. La mia soluzione è stata quella di aggiungere la booleanvariabile che era stata impostata quando Intentera stata "usata" e ifun'istruzione basata su questa booleanper verificare se dovresti usare Intento meno.

Quando hai finito di elaborare l'Intent, fai questo:

setIntent(null);

Non vedrai più quell'Intento elaborato e non maschererai il problema modificando i contenuti dell'Intento elaborato.

Non sono riuscito a trovare un modo per rimuovere Intent Extra . Nessuna delle risposte sulla rimozione di extra dall'intento funziona se abiliti "Non mantenere attività " dalle Opzioni sviluppatore (in questo modo puoi distruggere l'attività e tornare per verificare se gli extra sono ancora presenti).

Come soluzione al problema, ho memorizzato il valore booleano in SharedPreferences dopo l' elaborazione degli Intent Extras. Quando lo stesso Intent viene riconsegnato all'attività, controllo il valore SharedPreference e decido di elaborare l'Intent Extra. Nel caso in cui invii un altro nuovo Intent Extra alla stessa Activity, rendi falso il valore SharedPreference e Activity lo elaborerà. Esempio :

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

}

Anche dopo aver cancellato manualmente gli extra Intent e Intent dopo che sono stati analizzati, sembra che Activity.getIntent () restituirà sempre l'Intent originale che ha avviato l'attività.

Per aggirare questo problema, consiglio qualcosa del genere:

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

In questo modo, esiste un meccanismo per scaricare l'Intent originale pur mantenendo la capacità di conservare esplicitamente alcune parti degli extra Intent / Intent originali.

Tieni presente che non ho testato tutte le modalità di avvio delle attività.

Il modo più semplice è evitare di chiamare getIntent () da metodi diversi da onCreate (). Ma questo causerà problemi durante il prossimo avvio se l'utente ha lasciato la nostra attività toccando il pulsante Home. Penso che questo problema non abbia una soluzione completamente funzionale.

Affronto lo stesso problema e provo a usare i metodi sopra ma non funziona.

Penso che possa essere la causa della modalità di avvio di acitvity che ho usato in modalità singleTop.

Quando utilizzo l'app in background e utilizzo RamEater per simulare il problema, l'intento ha sempre qualcosa in più, anche se lo imposto null o rimuovo la chiave.

Il problema è stato risolto utilizzando l'archiviazione delle preferenze su Android per verificare che fosse passato.

Non è una buona pratica aggiungere un altro extra solo per sapere se gli extra sono stati consumati o meno, perché non farlo ?:

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

Cosa ne pensi di questo? Imposta newIntent come intento.

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

Che ne dici di quando desideri cancellare l'intento, sostituirlo con uno vuoto?

per esempio.

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

Si spera che questo aiuterà tutti. Quindi prima otteniamo l'intento

//globally
Intent myIntent;

Mettilo da qualche parte su Crea

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

Ora impostiamo questo in modo che ogni volta che la nostra app viene distrutta o chiusa, rimuoveremo i dati

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

Hai l'idea, se questo non è abbastanza basta trovare più callback "on"

Mentre Intent.removeExtra("key")rimuoverà una chiave specifica dagli extra, c'è anche il metodo Intent.replaceExtras (Bundle) , che può essere utilizzato per eliminare tutti gli extra dall'Intent, se nullviene passato come parametro.

Dai documenti:

Sostituisci completamente gli extra nell'intento con il pacchetto di extra fornito.

Parametri
extra Il nuovo set di extra nell'intento o null per cancellare tutti gli extra.

Poiché i metodi putXXX () inizializzano gli extra con un nuovo Bundle se è nullo, questo non è un problema.

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