Mi aplicación de Android está siendo llamada por una intención que está pasando información (pendiente en la barra de estado).

Cuando presiono el botón de inicio y vuelvo a abrir mi aplicación manteniendo presionado el botón de inicio, vuelve a llamar a la intención y los mismos extras siguen ahí.

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

este es el código que no se ejecuta como se supone que debe hacerlo

    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

        }

    }

Y mi intención:

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

¿Hay alguna forma de borrar la intención o comprobar si se ha utilizado antes?

ACTUALIZAR:

¡No me di cuenta de que se haría tanto referencia a esta respuesta cuando la escribí por primera vez hace más de 5 años!

Aclararé para señalar que según la respuesta de @ tato-rodrigo, esto no lo ayudará a detectar una intención ya manejada en algunas situaciones.

También debo señalar que puse "claro" entre comillas por una razón: realmente no está borrando la intención al hacer esto, solo está utilizando la eliminación del extra como una señal de que esta intención ya ha sido vista por la actividad .

Tuve exactamente el mismo problema.

La respuesta anterior me puso en el camino correcto y encontré una solución aún más simple, use:

getIntent().removeExtra("key"); 

llamada al método para "borrar" el Intent.

Es un poco tarde para responder ya que esto se preguntó hace un año, pero espero que esto ayude a otros en el futuro.

EDITAR: Estoy editando para publicar la solución completa que estoy usando.

Esta solución funcionará si el problema es "No se ejecuta algún código cuando la actividad comienza desde el Historial (Aplicaciones recientes)" .

En primer lugar, declare un booleanen su Activitypara indicar si Intentya se consumió:

    private boolean consumedIntent;

Luego, almacene y restaure de manera segura este valor usando los métodos onSaveInstanceStatey onCreatepara manejar los cambios de configuración y los casos en los que el sistema puede matarlo Activitycuando pasa a 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
    }

Ahora, verifique si puede ejecutar su código bajo el 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
        }
    }

Además, si Activityestá configurado para singleTop, debe restablecer su bandera cuando Intentse entregue una nueva .

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

Hace que la respuesta funcione para borrar un extra:

    getIntent().removeExtra("key"); 

Otro comando útil es:

    getIntent().setAction("");

También puede etiquetar una intención llamando a:

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

y luego simplemente verifique el valor.

Cuando lanzamos aplicaciones de Android desde Historial (Aplicaciones recientes), la aplicación podría iniciarse principalmente con tres indicadores de intención diferentes.

1. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
   Esto es cuando se inicia la actividad desde el historial de una aplicación que se minimizó (mantenga presionada la tecla de inicio).
   Valor constante: 1048576 (0x00100000)
2. FLAG_ACTIVITY_NEW_TASK
   Esto es cuando la actividad se inicia mediante "hacer clic en el icono de la aplicación" o mediante " Filtros de intención ". Aquí, la actividad se convertirá en el comienzo de una nueva tarea en esta pila de historial.
   Valor constante: 268435456 (0x10000000)
3. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY | FLAG_ACTIVITY_NEW_TASK
   Esto es cuando la aplicación se cerró presionando el botón Atrás y luego se reanudó desde el Historial (aplicaciones recientes).
   Valor constante: 269484032 (0x10100000)

El valor constante se puede recuperar mediante getIntent().getFlags()

En el tercer caso, Android recarga los últimos valores de Intent de su memoria. Por lo tanto, la intención de su aplicación ( getIntent) tendrá valores de la última intención que lanzó la aplicación.

En realidad, la aplicación debería comportarse como si fuera un lanzamiento nuevo, con valores de intención para un lanzamiento nuevo en lugar de los valores de intención del lanzamiento anterior. Este comportamiento se puede ver si inicia la aplicación haciendo clic en el ícono de la aplicación, nunca tendrá valores de intención antiguos. Esto se debe a que Android usa el siguiente filtro de intención para este escenario

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

Pero en el tercer caso (la aplicación que se cerró, se inicia desde el Historial de aplicaciones recientes), el sistema operativo Android usa esa última intención que inició la aplicación antes de salir (presionando el botón Atrás). Así que terminas teniendo valores de intención antiguos y el flujo de la aplicación no es el adecuado.

Eliminar la intención es una forma de resolverlo, ¡pero no resolvería el problema por completo! A medida que el sistema operativo Android recarga el Intent desde el último lanzamiento de las aplicaciones, y no la última instancia del intent de lanzamiento.

Una forma limpia de evitar que esto suceda es manejarlo obteniendo el tipo de Intent para determinar el tipo de lanzamiento.

Así que en su LaunchActivity (la que tiene la intención de filtro definido en el manifiesto), se puede utilizar el siguiente código en el onCreate(), onStart()o onResume()los 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();
        }
    }

Supongo normalLaunch()que no debería usar parámetros del Intent; de lo contrario, necesitaría segregar y optimizar su método de lanzamiento predeterminado para no usar los parámetros de Intent.

Borrar un objeto de intención :

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

La respuesta corta es de ninguna manera

Respuesta larga. No existe la intención "única". A partir del experimento, se observa que la historia de actividad reciente en los androides modernos no es más que una "historia de intenciones". La última intención pasada a la actividad simplemente se registra en el sistema y ese es el trato. La gente de arriba sugiere usar

setAction("")

Pero no funciona porque la intención ya está registrada hasta el momento en que la ingresa en el método onNewIntent () o onStart ().

Resolví el problema evitando el uso de intenciones. Mi problema era similar al publicado por el autor. Intenté implementar Global Exit desde la aplicación a través del control en el área de notificación. Debe detener el servicio subyacente y cerrar todas las actividades de la aplicación. Puede encontrar el mismo comportamiento en la aplicación Waze.

El algoritmo:

1. Cree PendingIntent para el control de notificaciones que pasa la acción "Salir" a la actividad. Pero a la actividad especial que es un simple proxy.
2. El código onStart () de actividad de proxy analiza la intención, verifica la acción y establece el estado de algún modelo en "Salido".
3. El código onStart () de la actividad de proxy borra la intención original usando setIntent ("") y luego la reenvía a la actividad "Root" de destino llamando a startActivity (intent).
4. Actividad de proxy en el código de inicio () invocar fin ().
5. Dentro de onStart () y onNewIntent () de la actividad de destino, verifique el estado del modelo y llame a finish () si está "Salido" (y también llame a stopService () en mi caso).

Espero que esto ayude a alguien porque no encontré la respuesta en Internet.

Asegúrese de que está utilizando PendingIntent.FLAG_UPDATE_CURRENT bandera para PendingIntent .

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

Donde mPutIntentesta tu Intent.

Espero que esto te ayudará.

Recientemente tuve este problema y lo resolví agregando una marca de tiempo como parámetro adicional a la intención:

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

Después de eso, guarde la marca de tiempo en las preferencias compartidas:

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

Tengo exactamente el mismo problema. Mi solución fue agregar la booleanvariable que se estableció cuando Intentse 'usó' y una ifdeclaración basada en esto booleanpara verificar si debe usar Intento no.

Cuando haya terminado de procesar la intención, haga esto:

setIntent(null);

No volverá a ver ese Intent procesado y no ocultará el problema editando el contenido del Intent procesado.

No pude encontrar una manera de eliminar Intent Extra . Ninguna de las respuestas sobre eliminar extra de la intención funciona si habilita "No conservar actividades " en las Opciones de desarrollador (de esa manera, puede destruir la actividad y volver para probar si los extras todavía están allí).

Como solución al problema, almacené un valor booleano en SharedPreferences después de que se procesan los Intent Extras. Cuando se vuelve a entregar el mismo Intent a la Actividad, verifico el valor SharedPreference y decido procesar el Intent Extra. En caso de que envíe otro Intent Extra nuevo a la misma actividad, hace que el valor SharedPreference sea falso y Activity lo procesará. Ejemplo :

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

}

Incluso después de borrar manualmente los extras Intent e Intent después de haber sido analizados, parece que Activity.getIntent () siempre devolverá el Intent original que inició la Activity.

Para evitar esto, recomiendo algo como esto:

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 esta manera, hay un mecanismo para volcar el Intent original mientras se conserva la capacidad de retener explícitamente ciertas partes de los extras del Intent / Intent original.

Tenga en cuenta que no he probado todos los modos de inicio de actividad.

La forma más sencilla es evitar llamar a getIntent () desde métodos distintos a onCreate (). Pero esto causará problemas durante el próximo lanzamiento si el usuario abandona nuestra Actividad tocando el botón Inicio. Creo que este problema no tiene una solución completamente funcional.

Me enfrento al mismo problema e intento usar los métodos anteriores, pero no funciona.

Creo que puede ser la causa del modo de inicio de la actividad que usé el modo singleTop.

Cuando utilizo la aplicación en segundo plano y uso RamEater para simular un problema, esa intención siempre tiene más, incluso si la configuro como nula o elimino la clave.

El problema desapareció al usar el almacenamiento de preferencias en Android para verificar que se haya pasado.

No es una buena práctica agregar otro extra solo para saber si los extras se han consumido o no, ¿por qué no hacer esto ?:

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

¿Qué tal esto? Establece newIntent como intent.

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

¿Qué tal si desea borrar la intención, reemplazarla por una vacía?

p.ej.

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

Con suerte, esto ayudará a todos. Así que primero tenemos la intención

//globally
Intent myIntent;

Coloque esto en algún lugar en Crear

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

Ahora configuremos esto para que cada vez que nuestra aplicación se destruya o salga, eliminemos los datos

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

Entiende la idea, si esto no es suficiente, busque más devoluciones de llamada 'on'

Si bien Intent.removeExtra("key")eliminará una clave específica de los extras, también existe el método Intent.replaceExtras (Bundle) , que se puede usar para eliminar todos los extras del Intent, si nullse pasa como parámetro.

De los documentos:

Reemplaza por completo los extras del Intent con el paquete de extras dado.

Parámetros
extras El nuevo conjunto de extras en el Intent, o null para borrar todos los extras.

Debido a que los métodos putXXX () inicializan los extras con un Bundle nuevo si es nulo, esto no es un problema.

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