Jak wyświetlić wiele powiadomień w systemie Android

Otrzymuję tylko jedno powiadomienie, a jeśli nadejdzie kolejne powiadomienie, zastępuje poprzednie, a oto mój kod

private static void generateNotification(Context context, String message,
        String key) {
    int icon = R.drawable.ic_launcher;
    long when = System.currentTimeMillis();
    NotificationManager notificationManager = (NotificationManager) context
            .getSystemService(Context.NOTIFICATION_SERVICE);
    Notification notification = new Notification(icon, message, when);

    String title = context.getString(R.string.app_name);

    Intent notificationIntent = new Intent(context,
            FragmentOpenActivity.class);
    notificationIntent.putExtra(key, key);
    // set intent so it does not start a new activity
    notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP
            | Intent.FLAG_ACTIVITY_SINGLE_TOP);
    PendingIntent intent = PendingIntent.getActivity(context, 0,
            notificationIntent, 0);
    notification.setLatestEventInfo(context, title, message, intent);
    notification.flags |= Notification.FLAG_AUTO_CANCEL;

    notification.defaults |= Notification.DEFAULT_SOUND;

    // notification.sound = Uri.parse("android.resource://" +
    // context.getPackageName() + "your_sound_file_name.mp3");
    notification.defaults |= Notification.DEFAULT_VIBRATE;
    notificationManager.notify(0, notification);

}

po prostu zastąp swoją linię tym

 notificationManager.notify(Unique_Integer_Number, notification);

mam nadzieję, że ci to pomoże.

Prosty identyfikator notyfikacji musi być zmienny.

Po prostu utwórz losową liczbę dla notification_id.

    Random random = new Random();
    int m = random.nextInt(9999 - 1000) + 1000;

lub możesz użyć tej metody do tworzenia liczb losowych zgodnie z tieorange (to nigdy się nie powtórzy):

    int m = (int) ((new Date().getTime() / 1000L) % Integer.MAX_VALUE);

i zastąp tę linię, aby dodać parametr dla identyfikatora powiadomienia, aby wygenerować liczbę losową

    notificationManager.notify(m, notification);

U mnie zadziałało korzystanie ze wspólnych preferencji

SharedPreferences prefs = getSharedPreferences(Activity.class.getSimpleName(), Context.MODE_PRIVATE);
int notificationNumber = prefs.getInt("notificationNumber", 0);
...

notificationManager.notify(notificationNumber , notification);
SharedPreferences.Editor editor = prefs.edit();
notificationNumber++;
editor.putInt("notificationNumber", notificationNumber);
editor.commit();

Zastąp swoją linię tym.

notificationManager.notify((int) ((new Date().getTime() / 1000L) % Integer.MAX_VALUE), notification);

domyślam się, że to komuś pomoże ..
w poniższym kodzie "not_nu" to losowy int .. PendingIntent i Notification mają ten sam identyfikator .. tak, że po każdym kliknięciu powiadomienia intencja będzie kierować do innej aktywności ..

private void sendNotification(String message,String title,JSONObject extras) throws JSONException {
   String id = extras.getString("actionParam");
    Log.e("gcm","id  = "+id);
    Intent intent = new Intent(this, OrderDetailActivty.class);
    intent.putExtra("id", id);
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    final int not_nu=generateRandom();
    PendingIntent pendingIntent = PendingIntent.getActivity(this, not_nu /* Request code */, intent,
            PendingIntent.FLAG_ONE_SHOT);

    Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
    NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)
            .setSmallIcon(R.mipmap.ic_cart_red)
            .setContentTitle(title)
            .setContentText(message)
            .setAutoCancel(true)
            .setSound(defaultSoundUri)
            .setContentIntent(pendingIntent);

    NotificationManager notificationManager =
            (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

    notificationManager.notify(not_nu /* ID of notification */, notificationBuilder.build());
}
public int generateRandom(){
    Random random = new Random();
    return random.nextInt(9999 - 1000) + 1000;
}

W miejscu uniqueIntNowstawienia unikalnej liczby całkowitej w następujący sposób:

mNotificationManager.notify(uniqueIntNo, builder.build());

Musisz dodać unikalny identyfikator do każdego z powiadomień, aby nie łączyły się ze sobą. Możesz użyć tego linku w celach informacyjnych:

https://github.com/sanathe06/AndroidGuide/tree/master/ExampleCompatNotificationBuilder

Rozwiązałem swój problem w ten sposób ...

/**
     * Issues a notification to inform the user that server has sent a message.
     */
    private static void generateNotification(Context context, String message,
            String keys, String msgId, String branchId) {
        int icon = R.drawable.ic_launcher;
        long when = System.currentTimeMillis();
        NotificationCompat.Builder nBuilder;
        Uri alarmSound = RingtoneManager
                .getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        nBuilder = new NotificationCompat.Builder(context)
                .setSmallIcon(R.drawable.ic_launcher)
                .setContentTitle("Smart Share - " + keys)
                .setLights(Color.BLUE, 500, 500).setContentText(message)
                .setAutoCancel(true).setTicker("Notification from smartshare")
                .setVibrate(new long[] { 100, 250, 100, 250, 100, 250 })
                .setSound(alarmSound);
        String consumerid = null;
        Integer position = null;
        Intent resultIntent = null;
        if (consumerid != null) {
            if (msgId != null && !msgId.equalsIgnoreCase("")) {
                if (key != null && key.equalsIgnoreCase("Yo! Matter")) {
                    ViewYoDataBase db_yo = new ViewYoDataBase(context);
                    position = db_yo.getPosition(msgId);
                    if (position != null) {
                        resultIntent = new Intent(context,
                                YoDetailActivity.class);
                        resultIntent.putExtra("id", Integer.parseInt(msgId));
                        resultIntent.putExtra("position", position);
                        resultIntent.putExtra("notRefresh", "notRefresh");
                    } else {
                        resultIntent = new Intent(context,
                                FragmentChangeActivity.class);
                        resultIntent.putExtra(key, key);
                    }
                } else if (key != null && key.equalsIgnoreCase("Message")) {
                    resultIntent = new Intent(context,
                            FragmentChangeActivity.class);
                    resultIntent.putExtra(key, key);
                }.
.
.
.
.
.
            } else {
                resultIntent = new Intent(context, FragmentChangeActivity.class);
                resultIntent.putExtra(key, key);
            }
        } else {
            resultIntent = new Intent(context, MainLoginSignUpActivity.class);
        }
        PendingIntent resultPendingIntent = PendingIntent.getActivity(context,
                notify_no, resultIntent, PendingIntent.FLAG_UPDATE_CURRENT);
        if (notify_no < 9) {
            notify_no = notify_no + 1;
        } else {
            notify_no = 0;
        }
        nBuilder.setContentIntent(resultPendingIntent);
        NotificationManager nNotifyMgr = (NotificationManager) context
                .getSystemService(context.NOTIFICATION_SERVICE);
        nNotifyMgr.notify(notify_no + 2, nBuilder.build());
    }

Innym sposobem, aby to zrobić, jest zmierzenie aktualnej daty na długie, po prostu weź ostatnie 4 cyfry. Istnieje duże prawdopodobieństwo, że liczba będzie niepowtarzalna.

    long time = new Date().getTime();
    String tmpStr = String.valueOf(time);
    String last4Str = tmpStr.substring(tmpStr.length() -5);
    int notificationId = Integer.valueOf(last4Str);

Wystarczy zmienić jedną linię z notificationManager.notify(0, notification);na notificationManager.notify((int) System.currentTimeMillis(), notification);...

Spowoduje to zmianę identyfikatora powiadomienia za każdym razem, gdy pojawi się nowe powiadomienie

notificationManager.notify(0, notification);

Umieść ten kod zamiast 0

new Random().nextInt() 

Jak poniżej to działa dla mnie

notificationManager.notify(new Random().nextInt(), notification);

Problem dotyczy twojego notificationId. Pomyśl o tym jak o indeksie tablicy. Za każdym razem, gdy aktualizujesz powiadomienie, notificationIdjest miejscem przechowywania wartości. Ponieważ nie zwiększasz wartości int (w tym przypadku swojej notificationId), zawsze zastępuje ona poprzednią. Myślę, że najlepszym rozwiązaniem jest zwiększenie go zaraz po zaktualizowaniu powiadomienia. A jeśli chcesz, aby był trwały, możesz przechowywać wartość swojego pliku notificationIdin sharedPreferences. Za każdym razem, gdy wrócisz, możesz po prostu pobrać ostatnią wartość całkowitą ( notificationIdprzechowywaną w sharedPreferences) i użyć jej.

Poniżej znajduje się kod dla unikalnego identyfikatora powiadomienia o przepustce:

//"CommonUtilities.getValudeFromOreference" is the method created by me to get value from savedPreferences.
String notificationId = CommonUtilities.getValueFromPreference(context, Global.NOTIFICATION_ID, "0");
int notificationIdinInt = Integer.parseInt(notificationId);

notificationManager.notify(notificationIdinInt, notification);

// will increment notification id for uniqueness
notificationIdinInt = notificationIdinInt + 1;
CommonUtilities.saveValueToPreference(context, Global.NOTIFICATION_ID, notificationIdinInt + "");
//Above "CommonUtilities.saveValueToPreference" is the method created by me to save new value in savePreferences.

Resetuj notificationIdw savedPreferencesokreślonym zakresie, tak jak zrobiłem to na 1000. Więc nie spowoduje to żadnych problemów w przyszłości. Daj mi znać, jeśli potrzebujesz bardziej szczegółowych informacji lub zapytań. :)

Użyj następującej metody w swoim kodzie.

Wywołanie metody: -

notificationManager.notify(getCurrentNotificationId(getApplicationContext()), notification);

Metoda:-

  *Returns a unique notification id.
         */

        public static int getCurrentNotificationId(Context iContext){

            NOTIFICATION_ID_UPPER_LIMIT = 30000; // Arbitrary number.

            NOTIFICATION_ID_LOWER_LIMIT = 0;
            SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(iContext);
        int previousTokenId= sharedPreferences.getInt("currentNotificationTokenId", 0);

        int currentTokenId= previousTokenId+1;

        SharedPreferences.Editor editor= sharedPreferences.edit();

        if(currentTokenId<NOTIFICATION_ID_UPPER_LIMIT) {

            editor.putInt("currentNotificationTokenId", currentTokenId); // }
        }else{
            //If reaches the limit reset to lower limit..
            editor.putInt("currentNotificationTokenId", NOTIFICATION_ID_LOWER_LIMIT);
        }

        editor.commit();

        return currentTokenId;
    }

Prosty licznik może rozwiązać Twój problem.

private Integer notificationId = 0;

private Integer incrementNotificationId() {
   return notificationId++;
}

NotificationManager.notify(incrementNotificationId, notification);

declare class member
static int i = 0;

mNotificationManager.notify(++i, mBuilder.build());

val notifyIdLong = ((Date().time / 1000L) % Integer.MAX_VALUE)
var notifyIdInteger = notifyIdLong.toInt()
if (notifyIdInteger < 0) notifyIdInteger = -1  * notifyIdInteger // if it's -ve change to positive
notificationManager.notify(notifyIdInteger, mBuilder.build())
log.d(TAG,"notifyId = $notifyIdInteger")