Cómo mostrar múltiples notificaciones en Android


103

Recibo solo una notificación y si llega otra notificación, reemplaza la anterior y aquí está mi código

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

}

3
Según el documento oficial, no debe mostrar varias notificaciones de una aplicación, debe apilar todas las notificaciones. Eche un vistazo: developer.android.com/design/patterns/notifications_k.html
Gowtham Kumar

Respuestas:


134

solo reemplaza tu línea con esto

 notificationManager.notify(Unique_Integer_Number, notification);

Espero que te ayude.


2
qué hay Unique_Integer_Numberen su código ... y qué código debe reemplazar
Kartheek s

4
Un número entero único significa que debe establecer un valor entero que nunca se repetirá. ejemplo 0,1,2,3,4,5, .... !!!!
Sanket Shah

2
notificationManager.notify (1, notificación); notificationManager.notify (2, notificación);
Sanket Shah

1
¿Cómo se incrementará automáticamente a medida que llegue la notificación?
Mitesh Shah

21
generando un entero único: (int) ((new Date (). getTime () / 1000L)% Integer.MAX_VALUE);
Andrii Kovalchuk

87

Se debe cambiar el id. De notificación simple.

Simplemente cree un número aleatorio para notification_id.

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

o puede usar este método para crear un número aleatorio como lo indica tieorange (esto nunca se repetirá):

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

y reemplace esta línea para agregar un parámetro para la identificación de notificación para generar un número aleatorio

    notificationManager.notify(m, notification);

8
Un poco hacky y se encuentra con la posibilidad de que termine con la misma identificación de notificación, pero esto funciona si necesita algo realmente rápido.
Muhammad Abdul-Rahim

1
Si veo esto bien, el apporach de tieorange solo funciona con segundos. Entonces, si tiene varias notificaciones en el mismo segundo, esto no funcionará.
prueba el

1
@testing es correcto. por eso tengo un segundo paso, m + = random.nextInt (100) + 1; esto podría ser un paso más, pero es más seguro. Vi que el método anterior fallaba en los últimos minutos de una aplicación de subasta / oferta. ¡Por eso agregué otra línea por seguridad!
user3833732

27

El uso de preferencias compartidas funcionó para mí

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

5
Esta es una forma bastante inteligente de hacerlo si también necesita realizar un seguimiento de cada notificación enviada. Probablemente una de las respuestas más inteligentes aquí.
Muhammad Abdul-Rahim

12

Reemplace su línea con esto.

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

¿No es difícil eliminar la notificación de un tipo de carga útil en particular con este enfoque?
Sethuraman Srinivasan

8

Supongo que esto ayudará a alguien ...
en el siguiente código, "not_nu" es un int aleatorio. PendingIntent y Notification tienen la misma ID .. de modo que en cada notificación, haga clic en intent dirigirse a una actividad diferente ..

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

Mis notificaciones aún no se apilan, ¿hay algo específico que deba hacer además de lo que muestra aquí?
Lion789

¿Qué hace ese cálculo random.nextInt allí ... puedes explicarlo? 9999-1000 ???? qué es eso ...
Radu

@Radu como puede ver en el código "notificationManager.notify (" toma un int (ID para notificación) como el primer parámetro. Si este Int (ID) es el mismo para una nueva notificación, reemplazará al anterior y mostrará el nuevo. si este Int (ID) es diferente, la nueva notificación se trata por separado y se muestra como pilas. Por lo tanto, la notificación anterior permanece. y para lograr esto, estamos creando un int aleatorio y lo asignamos como ID. "random.nextInt (9999 - 1000) + 1000; "con este código.
Muneef M

@ Lion789 solo tiene que usar una ID diferente para nuevas notificaciones, luego debería acumular las notificaciones.
Muneef M

new NotificationCompat.Builder (esto); está obsoleto en Android Oreo. Consulte los documentos y utilice la implementación del canal de notificación.
TapanHP

5

En el lugar de uniqueIntNoponer un número entero único como este:

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


3

Resolví mi problema así ...

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

3

Otra forma de hacerlo es tomar la fecha actual, convertirla en larga, solo tomar los últimos 4 dígitos. Existe una alta probabilidad de que el número sea único.

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

¿Por qué usar solo los últimos cuatro dígitos y no la fecha y hora en sí?
Muhammad Abdul-Rahim

4
Aquí hay un código un poco más corto:int notificationId = System.currentTimeMillis()%10000;
bvk256

¿Por qué solo 4 dígitos?
Pavel Biryukov

2

Solo necesita cambiar su diagrama unifilar de notificationManager.notify(0, notification);a notificationManager.notify((int) System.currentTimeMillis(), notification);...

Esto cambiará la identificación de la notificación cada vez que aparezca la nueva notificación


1
notificationManager.notify(0, notification);

Pon este código en lugar de 0

new Random().nextInt() 

Como a continuación, funciona para mí

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

1
De la opinión: Hola, no responda sólo con el código fuente. Intente proporcionar una descripción agradable sobre cómo funciona su solución. Ver: ¿Cómo escribo una buena respuesta? . Gracias
sɐunıɔ ןɐ qɐp

0

El problema es tu notificationId. Piense en ello como un índice de matriz. Cada vez que actualiza su notificación, el notificationIdes el lugar que se necesita para almacenar valor. Como no está incrementando su valor int (en este caso, su notificationId), esto siempre reemplaza al anterior. La mejor solución, supongo, es incrementarla justo después de actualizar una notificación. Y si desea mantenerlo persistente, puede almacenar el valor de su notificationIdin sharedPreferences. Siempre que regrese, puede simplemente tomar el último valor entero ( notificationIdalmacenado sharedPreferences) y usarlo.


0

A continuación se muestra el código para pasar la identificación de notificación única:

//"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.

Restablezca notificationIden savedPreferencesun rango específico como lo hice en 1000. Por lo tanto, no creará ningún problema en el futuro. Déjame saber si necesitas más información detallada o alguna consulta. :)


hola, ¿puedes publicar el código completo? Sabemos que para generar múltiples notificaciones necesitamos una identificación única, pero después de generarla también tenemos que cancelar esa notificación en particular ... hay un problema para guardar y obtener cada identificación única en mi caso, si puedes ayudar por favor
Jayman Jani

0

Utilice el siguiente método en su código.

Llamada de método: -

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

Método:-

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

-1

Un simple contador puede resolver su problema.

private Integer notificationId = 0;

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

NotificationManager.notify(incrementNotificationId, notification);

-1
declare class member
static int i = 0;

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

-1
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")
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.