PendingIntent fonctionne correctement pour la première notification mais incorrectement pour le reste

  protected void displayNotification(String response) {
    Intent intent = new Intent(context, testActivity.class);
    PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);

    Notification notification = new Notification(R.drawable.icon, "Upload Started", System.currentTimeMillis());
    notification.setLatestEventInfo(context, "Upload", response, pendingIntent);

    nManager.notify((int)System.currentTimeMillis(), notification);
}

Cette fonction sera appelée plusieurs fois. Je voudrais que chacun notificationlance testActivity en cliquant dessus Malheureusement, seule la première notification lance testActivity. Cliquez sur le reste pour réduire la fenêtre de notification.

Informations supplémentaires: La fonction displayNotification()est dans une classe appelée UploadManager. Contextest passé à UploadManagerpartir du activityqui instancie. La fonction displayNotification()est appelée plusieurs fois à partir d'une fonction, également dans UploadManager, qui s'exécute dans un fichier AsyncTask.

Edit 1: J'ai oublié de mentionner que je passe la réponse String en Intent intenttant que extra.

  protected void displayNotification(String response) {
    Intent intent = new Intent(context, testActivity.class);
    intent.putExtra("response", response);
    PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);

Cela fait une grande différence car j'ai besoin de la "réponse" supplémentaire pour refléter la réponse String lorsque la notification a été créée. Au lieu de cela, en utilisant PendingIntent.FLAG_UPDATE_CURRENT, la "réponse" supplémentaire reflète la réponse String lors du dernier appel displayNotification().

Je sais pourquoi cela vient de la lecture de la documentation FLAG_UPDATE_CURRENT. Cependant, je ne sais pas comment contourner ce problème pour le moment.

Ne pas utiliser Intent.FLAG_ACTIVITY_NEW_TASKpour PendingIntent.getActivity, utilisez plutôt FLAG_ONE_SHOT

Copié à partir des commentaires:

Ensuite, définissez une action factice sur l'intention, sinon les extras sont supprimés. Par exemple

intent.setAction(Long.toString(System.currentTimeMillis()))

J'avais du mal avec RemoteViewset plusieurs différents Intentspour chacun Buttonsur HomeScreenWidget. A travaillé une fois ajoutés:

1. intent.setAction(Long.toString(System.currentTimeMillis()));

2. PendingIntent.FLAG_UPDATE_CURRENT

        PackageManager pm = context.getPackageManager();

        Intent intent = new Intent(context, MyOwnActivity.class);
        intent.putExtra("foo_bar_extra_key", "foo_bar_extra_value");
        intent.setAction(Long.toString(System.currentTimeMillis()));
        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0,
                intent, PendingIntent.FLAG_UPDATE_CURRENT);
        RemoteViews views = new RemoteViews(context.getPackageName(),
                R.layout.widget_layout);
        views.setOnClickPendingIntent(my_button_r_id_received_in_parameter, pendingIntent);

Set Action Résolu cela pour moi. Voici ma compréhension de la situation:

J'ai plusieurs widgets qui ont un PendingIntent attaché à chacun. Chaque fois qu'un était mis à jour, ils étaient tous mis à jour. Les Flags sont là pour décrire ce qui se passe avec les PendingIntents qui sont exactement les mêmes.

La description de FLAG_UPDATE_CURRENT se lit beaucoup mieux maintenant:

Si le même PendingIntent que vous créez existe déjà, mettez à jour tous les anciens avec le nouveau PendingIntent que vous créez.

La définition d'exactement la même chose concerne l'ensemble de PendingIntent SAUF les extras. Ainsi, même si vous avez des extras différents pour chaque intention (pour moi, j'ajoutais appWidgetId), ils sont identiques pour Android.

L'ajout de .setAction avec une chaîne unique factice indique au système d'exploitation. Ceux-ci sont complètement différents et ne mettent rien à jour. En fin de compte, voici mon implémentation qui fonctionne comme je le voulais, où chaque widget a sa propre configuration Intent attachée:

Intent configureIntent = new Intent(context, ActivityPreferences.class);

configureIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);

configureIntent.setAction("dummy_unique_action_identifyer" + appWidgetId);

PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, configureIntent,
    PendingIntent.FLAG_UPDATE_CURRENT);

MISE À JOUR

Une solution encore meilleure au cas où vous travaillez avec des diffusions. Les PendingIntents uniques sont également définis par des codes de demande uniques. Voici ma solution:

//Weee, magic number, just want it to be positive nextInt(int r) means between 0 and r
int dummyuniqueInt = new Random().nextInt(543254); 
PendingIntent pendingClearScreenIntent = PendingIntent.getBroadcast(context, 
    dummyuniqueInt, clearScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT);

Je vois des réponses mais pas d'explications. De plus, aucune des réponses n'aborde toutes les solutions possibles, je vais donc essayer de clarifier cela.

Documentation:

Si vous avez vraiment besoin de plusieurs objets PendingIntent distincts actifs en même temps (par exemple pour les utiliser comme deux notifications qui sont toutes les deux affichées en même temps), vous devrez vous assurer qu'il y a quelque chose de différent à leur sujet pour les associer à des PendingIntents. Il peut s'agir de l'un des attributs Intent considérés par Intent.filterEquals, ou de différents entiers de code de requête fournis à getActivity (Context, int, Intent, int), getActivities (Context, int, Intent [], int), getBroadcast (Context, int , Intent, int) ou getService (Context, int, Intent, int).

Cause du problème:

Vous créez 2 notifications avec 2 intentions en attente. Chaque intention en attente est associée à une intention:

Intent intent = new Intent(context, testActivity.class);

Cependant, ces 2 intentions sont égales, par conséquent, lorsque votre deuxième notification arrive, elle lancera la première intention.

Solution:

Vous devez rendre chaque intention unique, afin qu'aucune intention en attente ne soit jamais égale. Comment rendre les intentions uniques? Pas par les extras que vous mettez putExtra(). Même si les extras sont différents, les intentions peuvent toujours être égales. Pour rendre chaque intention unique, vous devez définir une valeur unique pour l'action d'intention, ou les données, ou le type, ou la classe, ou la catégorie, ou le code de demande: (l'un d'entre eux fonctionnera)

• action: intent.setAction(...)
• Les données: intent.setData(...)
• type: intent.setType(...)
• classe: intent.setClass(...)
• Catégorie: intent.addCategory(...)
• code requis: PendingIntent.getActivity(context, YOUR_UNIQUE_CODE, intent, Intent.FLAG_ONE_SHOT);

Remarque : la définition d'un code de requête unique peut être délicate car vous avez besoin d'un int, tandis que System.currentTimeMillis()renvoie long, ce qui signifie que certains chiffres seront supprimés. Par conséquent, je recommanderais soit d'aller avec la catégorie ou l' action et de définir une chaîne unique.

J'ai eu le même problème et j'ai pu le résoudre en changeant le drapeau en:

PendingIntent contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);

Comme indiqué dans la documentation, utilisez un code de demande unique:

Si vous avez vraiment besoin de plusieurs objets PendingIntent distincts actifs en même temps (par exemple pour les utiliser comme deux notifications qui sont toutes les deux affichées en même temps), vous devrez vous assurer qu'il y a quelque chose de différent à leur sujet pour les associer à des PendingIntents. Il peut s'agir de l'un des attributs Intent considérés par Intent.filterEquals, ou de différents entiers de code de requête fournis à getActivity (Context, int, Intent, int), getActivities (Context, int, Intent [], int), getBroadcast (Context, int , Intent, int) ou getService (Context, int, Intent, int).

Fwiw, j'ai eu plus de chance avec PendingIntent.FLAG_CANCEL_CURRENTqu'avec PendingIntent.FLAG_UPDATE_CURRENT.

J'ai eu le même problème et je l'ai résolu par les étapes ci-dessous

1) Effacez n'importe quel indicateur d'intention

intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);

2) insérez intent.setAction par le code ci-dessous

 intent.setAction(Long.toString(System.currentTimeMillis()));

3) pour Pendingintent, insérez le code ci-dessous

   PendingIntent Pintent = PendingIntent.getActivity(ctx,0, intent,PendingIntent.FLAG_UPDATE_CURRENT);

J'espère travailler avec toi

PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);

Dans PendingIntent se trouvent deux paramètres int, le second et le dernier. Le deuxième est "code de demande" et il doit s'agir d'un numéro unicue (par exemple l'ID de votre notification), sinon si (comme dans votre exemple, il vaut zéro, il sera toujours écrasé).

// Use pending Intent and  also use unique id for display notification....
// Get a PendingIntent containing the entire back stack
PendingIntent notificationPendingIntent = stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT);
NotificationManager mNotificationManager = (NotificationManager)  sqlitewraper.context.getSystemService(Context.NOTIFICATION_SERVICE);
// Issue the notification
mNotificationManager.notify(id, builder.build());

pour envoyer des données plus correctement, vous devez envoyer avec l'intention en attente l'id de notification comme ceci: PendingIntent pendingIntent = PendingIntent.getActivity (context, (int) System.currentTimeMillis () , intent, PendingIntent.FLAG_UPDATE_CURRENT);

J'ai le même problème et j'utilise PendingIntent.html.FLAG_UPDATE_CURRENT pour le résoudre.

J'ai vérifié le code source. Dans ActivityManagerService.java , la méthode clé est la suivante. Lorsque l'indicateur est PendingIntent.FLAG_UPDATE_CURRENT et que updateCurrent est true. Certains extras seront remplacés par de nouveaux et nous obtiendrons un PendingIntent remplacé.

    IIntentSender getIntentSenderLocked(int type, String packageName,
            int callingUid, int userId, IBinder token, String resultWho,
            int requestCode, Intent[] intents, String[] resolvedTypes, int flags,
            Bundle bOptions) {

// ... omitted

        final boolean noCreate = (flags&PendingIntent.FLAG_NO_CREATE) != 0;
        final boolean cancelCurrent = (flags&PendingIntent.FLAG_CANCEL_CURRENT) != 0;
        final boolean updateCurrent = (flags&PendingIntent.FLAG_UPDATE_CURRENT) != 0;
        flags &= ~(PendingIntent.FLAG_NO_CREATE|PendingIntent.FLAG_CANCEL_CURRENT
                |PendingIntent.FLAG_UPDATE_CURRENT);

        PendingIntentRecord.Key key = new PendingIntentRecord.Key(
                type, packageName, activity, resultWho,
                requestCode, intents, resolvedTypes, flags, bOptions, userId);
        WeakReference<PendingIntentRecord> ref;
        ref = mIntentSenderRecords.get(key);
        PendingIntentRecord rec = ref != null ? ref.get() : null;
        if (rec != null) {
            if (!cancelCurrent) {
                if (updateCurrent) {
                    if (rec.key.requestIntent != null) {
                        rec.key.requestIntent.replaceExtras(intents != null ?
                                intents[intents.length - 1] : null);
                    }
                    if (intents != null) {
                        intents[intents.length-1] = rec.key.requestIntent;
                        rec.key.allIntents = intents;
                        rec.key.allResolvedTypes = resolvedTypes;
                    } else {
                        rec.key.allIntents = null;
                        rec.key.allResolvedTypes = null;
                    }
                }
                return rec;
            }
            rec.canceled = true;
            mIntentSenderRecords.remove(key);
        }

J'ai eu le même problème et j'ai pu le résoudre en changeant le drapeau en:

LayoutInflater factory = LayoutInflater.from(this);            
      final View textEntryView = factory.inflate(R.layout.appointment, null);
      AlertDialog.Builder bulider= new AlertDialog.Builder(PatientDetail.this);
      final AlertDialog alert=bulider.create();


        bulider.setTitle("Enter Date/Time");
        bulider.setView(textEntryView);
        bulider.setPositiveButton("Save", new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int which) {
                      EditText typeText=(EditText) textEntryView.findViewById(R.id.Editdate);
                      EditText input1 =(EditText) textEntryView.findViewById(R.id.Edittime);
                      getDateAndTime(typeText.getText().toString(),input1.getText().toString());
                }
            });
        bulider.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {

                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });

        bulider.show();

    }