Mon application Android est appelée par une intention qui transmet des informations (en attente d'intention dans la barre d'état).

Lorsque j'appuie sur le bouton d'accueil et que je rouvre mon application en maintenant le bouton d'accueil, il appelle à nouveau l'intention et les mêmes extras sont toujours là.

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

c'est le code qui ne fonctionne pas comme prévu

    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

        }

    }

Et mon intention:

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-t-il un moyen d'effacer l'intention ou de vérifier s'il a déjà été utilisé?

METTRE À JOUR:

Je ne savais pas que cette réponse serait autant mentionnée lorsque je l'ai écrite pour la première fois il y a plus de 5 ans!

Je clarifierai pour souligner que selon la réponse @ tato-rodrigo, cela ne vous aidera pas à détecter une intention déjà gérée dans certaines situations.

Je dois également souligner que je mets «effacer» entre guillemets pour une raison - vous n'effacez pas vraiment l'intention en faisant cela, vous utilisez simplement la suppression de l'extra comme indicateur que cette intention a déjà été vue par l'activité .

J'ai eu exactement le même problème.

La réponse ci-dessus m'a mis sur la bonne voie et j'ai trouvé une solution encore plus simple, utilisez le:

getIntent().removeExtra("key"); 

appel de méthode pour "effacer" l'intention.

C'est un peu tard pour répondre car cela a été demandé il y a un an, mais j'espère que cela aidera d'autres à l'avenir.

EDIT: J'édite pour publier la solution complète que j'utilise.

Cette solution fonctionnera si le problème est "Ne pas exécuter du code lorsque l'activité démarre à partir de l'historique (applications récentes)" .

Tout d'abord, déclarez un booleandans votre Activitypour indiquer si le Intenta déjà été consommé:

    private boolean consumedIntent;

Ensuite, stockez et restaurez en toute sécurité cette valeur à l'aide des méthodes onSaveInstanceStateet onCreatepour gérer les modifications de configuration et les cas où le système peut vous tuer Activitylorsqu'il passe en arrière-plan.

    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
    }

Maintenant, vérifiez si vous pouvez exécuter votre code sous onResumemethod.

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

De plus, si votre Activityest configuré sur singleTop, vous devez réinitialiser votre indicateur lorsqu'un nouveau Intentest livré.

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

Maks answer fonctionne pour effacer un extra:

    getIntent().removeExtra("key"); 

Une autre commande utile est:

    getIntent().setAction("");

Vous pouvez également baliser une intention en appelant:

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

puis vérifiez simplement la valeur.

Lorsque nous lançons des applications Android à partir de l'historique (applications récentes), l'application peut être lancée avec principalement trois indicateurs d'intention différents.

1. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
   C'est à ce moment que l'activité est lancée à partir de l'historique d'une application qui a été minimisée (appuyez longuement sur la touche d'accueil).
   Valeur constante: 1048576 (0x00100000)
2. FLAG_ACTIVITY_NEW_TASK
   C'est à ce moment que l'activité est lancée via "cliquer sur l'icône de l'application" ou via " Filtres d'intention ". Ici, l'activité deviendra le début d'une nouvelle tâche sur cette pile d'historique.
   Valeur constante: 268435456 (0x10000000)
3. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY | FLAG_ACTIVITY_NEW_TASK
   C'est à ce moment que l'application a été fermée en appuyant sur le bouton Retour, puis à partir de l'historique (applications récentes).
   Valeur constante: 269484032 (0x10100000)

La valeur constante peut être récupérée via getIntent().getFlags()

Dans le troisième cas, Android recharge les dernières valeurs d'intention de sa mémoire. L'intention de votre application ( getIntent) aura donc les valeurs de la dernière intention qui a lancé l'application.

En fait, l'application doit se comporter comme s'il s'agissait d'un nouveau lancement, avec des valeurs d'intention pour un nouveau lancement plutôt que les valeurs d'intention du lancement précédent. Ce comportement peut être observé si vous lancez l'application en cliquant sur l'icône de l'application, elle n'aura jamais d'anciennes valeurs d'intention. En effet, Android utilise le filtre d'intention suivant pour ce scénario

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

Mais dans le troisième cas (l'application qui a été fermée, est lancée à partir de l'historique des applications récentes), Android OS utilise cette dernière intention qui a lancé l'application avant qu'elle ne soit fermée (en appuyant sur le bouton retour). Vous finissez donc par avoir d'anciennes valeurs d'intention et le flux d'application n'est pas approprié.

Supprimer l'intention est un moyen de le résoudre, mais cela ne résoudrait pas complètement le problème! Lorsque le système d'exploitation Android recharge l'intention à partir du dernier lancement des applications, et non de la dernière instance de l'intention de lancement.

Un moyen simple d'éviter que cela ne se produise est de le gérer en obtenant le type d' intention pour déterminer le type de lancement.

Donc , dans votre LaunchActivity (celui qui a le filtre défini dans l' intention manifeste), vous pouvez utiliser le code suivant dans les onCreate(), onStart()ou les onResume()méthodes.

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

Je présume normalLaunch(), ne devrait pas utiliser les paramètres de l'intention; Sinon, vous devrez séparer et optimiser votre méthode de lancement par défaut pour ne pas utiliser les paramètres d'intention.

Effacer un objet d' intention :

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

La réponse courte est impossible

Longue réponse. Il n’existe pas d’intention «ponctuelle». De l'expérience, il est observé que l'histoire récente de l'activité dans les androïdes modernes n'est rien de plus qu'une «histoire d'intention». La dernière intention transmise à l'activité est simplement connectée au système et c'est l'affaire. Les gens ci-dessus suggèrent d'utiliser

setAction("")

Mais cela ne fonctionne pas car l'intention est déjà enregistrée jusqu'au moment où vous l'obtenez dans la méthode onNewIntent () ou onStart ().

J'ai résolu le problème en évitant d'utiliser des intentions. Mon problème était similaire à celui posté par l'auteur. J'ai essayé d'implémenter Global Exit depuis l'application via le contrôle dans la zone de notification. Il doit arrêter le service sous-jacent et fermer toutes les activités de l'application. Vous pouvez trouver le même comportement dans l'application Waze.

L'algorithme:

1. Créez PendingIntent pour le contrôle de notification qui passe l'action "Quitter" à l'activité. Mais à l'activité spéciale qui est un simple proxy.
2. Le code onStart () de l'activité proxy analyse l'intention, vérifie l'action et définit l'état de certains modèles sur "Exited".
3. Le code onStart () de l'activité proxy efface l'intention d'origine à l'aide de setIntent (""), puis la transmet à l'activité de destination "Root" en appelant startActivity (intent).
4. Le code de l'activité du proxy onStart () appelle finish ().
5. À l'intérieur de onStart () et onNewIntent () de l'activité de destination vérifie l'état du modèle et appelle finish () s'il est "Exited" (et appelle aussi stopService () dans mon cas).

J'espère que cela aidera quelqu'un car je n'ai pas trouvé de réponse sur Internet.

Assurez - vous que vous utilisez PendingIntent.FLAG_UPDATE_CURRENT drapeau pour PendingIntent .

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

Où mPutIntentest votre Intent.

J'espère que ceci vous aidera.

J'ai récemment eu ce problème et je l'ai résolu en ajoutant un horodatage comme paramètre supplémentaire à l'intention:

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

Après cela, enregistrez l'horodatage dans les préférences partagées:

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

J'ai exactement le même problème. Ma solution était d'ajouter une booleanvariable qui était définie quand Intentétait «utilisé» et une ifdéclaration basée sur cela booleanpour vérifier si vous deviez utiliser Intentou non.

Lorsque vous avez terminé de traiter l'intention, procédez comme suit:

setIntent(null);

Vous ne verrez plus cette intention traitée et vous ne masquerez pas le problème en modifiant le contenu de l'intention traitée.

Je n'ai pas trouvé de moyen de supprimer Intent Extra . Aucune des réponses sur la suppression des extras de l'intention ne fonctionne si vous activez «Ne pas conserver les activités » dans les options du développeur (de cette façon, vous pouvez détruire l'activité et revenir pour tester si les extras sont toujours là).

Pour résoudre le problème, j'ai stocké la valeur booléenne dans SharedPreferences après le traitement des extras d'intention. Lorsque la même intention est renvoyée à l'activité, je vérifie la valeur SharedPreference et décide de traiter l'intent supplémentaire. Si vous envoyez un autre nouveau Intent Extra à la même activité, vous définissez la valeur SharedPreference sur false et Activity la traitera. Exemple :

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

}

Même après avoir effacé manuellement les extras Intent et Intent après leur analyse, il semble que Activity.getIntent () retournera toujours l'intention d'origine qui a démarré l'activité.

Pour contourner cela, je recommande quelque chose comme ceci:

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

De cette façon, il existe un mécanisme pour vider l'intention d'origine tout en conservant la possibilité de conserver explicitement certaines parties des extras d'intention / intention d'origine.

Notez que je n'ai pas testé tous les modes de lancement d'activité.

Le moyen le plus simple est d'éviter d'appeler getIntent () à partir de méthodes autres que onCreate (). Mais cela posera un problème lors du prochain lancement si l'utilisateur a quitté notre activité en appuyant sur le bouton Accueil. Je pense que ce problème n'a pas de solution entièrement fonctionnelle.

Je suis confronté au même problème et j'essaie d'utiliser les méthodes ci-dessus mais cela ne fonctionne pas.

Je pense que cela peut être à cause du mode de lancement de l'acitvity que j'ai utilisé en mode singleTop.

Lorsque j'utilise une application en arrière-plan et que j'utilise RamEater pour simuler un problème, cette intention a toujours un supplément, même si je la définis comme null ou que je supprime la clé.

Le problème est résolu en utilisant le stockage des préférences sur Android pour vérifier que le transfert est passé.

Ce n'est pas une bonne pratique d'ajouter un autre extra juste pour savoir si les extras ont été consommés ou non, pourquoi ne pas le faire?:

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

Que dis-tu de ça? Définit newIntent comme intention.

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

Que diriez-vous lorsque vous souhaitez effacer l'intention - le remplacer par un vide?

par exemple.

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

J'espère que cela aidera tout le monde. Alors d'abord, nous avons l'intention

//globally
Intent myIntent;

Placez-le quelque part sur Créer

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

Maintenant, définissons ceci afin que chaque fois que notre application soit détruite ou quittée, nous supprimerons les données

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

Vous avez l'idée, si cela ne suffit pas, trouvez simplement plus de rappels `` sur ''

Bien que le Intent.removeExtra("key")supprime une clé spécifique des extras, il existe également la méthode Intent.replaceExtras (Bundle) , qui peut être utilisée pour supprimer tous les extras de l'intention, si elle nullest passée en paramètre.

À partir de la documentation:

Remplacez complètement les extras dans l'intention par le lot d'extras donné.

Paramètres
extras Le nouvel ensemble d'extras dans l'intention, ou null pour effacer tous les extras.

Étant donné que les méthodes putXXX () initialisent les extras avec un nouveau Bundle s'il est nul, ce n'est pas un problème.

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