Android => meldingen

Een eenvoudige melding maken

Dit voorbeeld laat zien hoe u een eenvoudige melding maakt waarmee een toepassing wordt gestart wanneer de gebruiker erop klikt.

Geef de inhoud van de melding op:

NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
        .setSmallIcon(R.drawable.ic_launcher) // notification icon
        .setContentTitle("Simple notification") // title
        .setContentText("Hello word") // body message
        .setAutoCancel(true); // clear notification when clicked

Creëer de intentie om bij klik te schieten:

Intent intent = new Intent(this, MainActivity.class);
PendingIntent pi = PendingIntent.getActivity(this, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);
mBuilder.setContentIntent(pi);

Bouw ten slotte de melding en toon deze

NotificationManager mNotificationManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify(0, mBuilder.build());

Let op melding met ticker voor oudere apparaten

Hier leest u hoe u een heads-upmelding kunt maken voor geschikte apparaten en een ticker kunt gebruiken voor oudere apparaten.

// Tapping the Notification will open up MainActivity
Intent i = new Intent(this, MainActivity.class);

// an action to use later
// defined as an app constant:
// public static final String MESSAGE_CONSTANT = "com.example.myapp.notification";
i.setAction(MainActivity.MESSAGE_CONSTANT);
// you can use extras as well
i.putExtra("some_extra", "testValue");

i.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent notificationIntent = PendingIntent.getActivity(this, 999, i, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this.getApplicationContext());
builder.setContentIntent(notificationIntent);
builder.setAutoCancel(true);
builder.setLargeIcon(BitmapFactory.decodeResource(this.getResources(), android.R.drawable.ic_menu_view));
builder.setSmallIcon(android.R.drawable.ic_dialog_map);
builder.setContentText("Test Message Text");
builder.setTicker("Test Ticker Text");
builder.setContentTitle("Test Message Title");

// set high priority for Heads Up Notification
builder.setPriority(NotificationCompat.PRIORITY_HIGH);
builder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);

// It won't show "Heads Up" unless it plays a sound
if (Build.VERSION.SDK_INT >= 21) builder.setVibrate(new long[0]);

NotificationManager mNotificationManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify(999, builder.build());

Zo ziet het eruit op Android Marshmallow met de Heads Up-melding:

Hier is hoe het eruit ziet op Android KitKat met de Ticker:

Op alle Android-versies wordt de Notification weergegeven in de meldingslade.

Android 6.0 Marshmallow:

Android 4.4.x KitKat:

Verschillende prioriteiten instellen voor meldingen

 NotificationCompat.Builder mBuilder =

        (NotificationCompat.Builder) new NotificationCompat.Builder(context)

        .setSmallIcon(R.drawable.some_small_icon)
        .setContentTitle("Title")
        .setContentText("This is a test notification with MAX priority")
        .setPriority(Notification.PRIORITY_MAX);

Wanneer de melding een afbeelding bevat en u de afbeelding automatisch wilt uitbreiden wanneer de melding wordt ontvangen, gebruikt u "PRIORITY_MAX", kunt u andere prioriteitsniveaus gebruiken volgens de vereisten

Verschillende prioriteitsniveaus:

PRIORITY_MAX - Gebruik dit voor kritieke en urgente meldingen die de gebruiker waarschuwen voor een tijdkritieke situatie of die moet worden opgelost voordat ze met een bepaalde taak kunnen doorgaan.

PRIORITY_HIGH - Gebruik dit voornamelijk voor belangrijke communicatie, zoals bericht- of chatgebeurtenissen met inhoud die bijzonder interessant is voor de gebruiker. Meldingen met hoge prioriteit activeren het heads-up meldingenscherm.

PRIORITY_DEFAULT - Gebruik voor alle meldingen die niet onder een van de andere prioriteiten vallen die hier worden beschreven.

PRIORITY_LOW - Gebruik deze voor meldingen waarvan u wilt dat de gebruiker op de hoogte wordt gehouden, maar die minder urgent zijn. Meldingen met lage prioriteit worden meestal onderaan de lijst weergegeven, waardoor ze een goede keuze zijn voor dingen zoals openbare of niet-gerichte sociale updates: de gebruiker heeft gevraagd om een melding te ontvangen, maar deze meldingen mogen nooit voorrang krijgen op dringende of directe communicatie.

PRIORITY_MIN - Gebruik voor contextuele of achtergrondinformatie zoals weersinformatie of contextuele locatie-informatie. Meldingen met minimale prioriteit worden niet weergegeven in de statusbalk. De gebruiker ontdekt ze bij het uitbreiden van de meldingsschaduw.

Referenties: Richtlijnen voor materiaalontwerp - meldingen

Planning meldingen

Soms is het vereist om een melding op een specifiek tijdstip weer te geven, een taak die helaas niet triviaal is op het Android-systeem, omdat er geen methode setTime() of vergelijkbaar voor meldingen. In dit voorbeeld worden de stappen beschreven die nodig zijn om meldingen te plannen met de AlarmManager :

Voeg een BroadcastReceiver die luistert naar Intent uitgezonden door de Android AlarmManager .

Dit is de plaats waar u uw melding samenstelt op basis van de extra's die bij de Intent :

   public class NotificationReceiver extends BroadcastReceiver {
       @Override
       public void onReceive(Context context, Intent intent) {
           // Build notification based on Intent
           Notification notification = new NotificationCompat.Builder(context)
               .setSmallIcon(R.drawable.ic_notification_small_icon)
               .setContentTitle(intent.getStringExtra("title", ""))
               .setContentText(intent.getStringExtra("text", ""))
               .build();
           // Show notification
           NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
           manager.notify(42, notification);
       }
   }

Registreer de BroadcastReceiver in uw AndroidManifest.xml bestand (anders ontvangt de ontvanger geen Intent van de AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

Plan een melding door een PendingIntent voor uw BroadcastReceiver met de benodigde Intent extra's door te geven aan de AlarmManager van het systeem. Uw BroadcastReceiver ontvangt de Intent zodra de opgegeven tijd is aangekomen en geeft de melding weer. De volgende methode plant een melding:

public static void scheduleNotification(Context context, long time, String title, String text) {
    Intent intent = new Intent(context, NotificationReceiver.class);
    intent.putExtra("title", title);
    intent.putExtra("text", text);
    PendingIntent pending = PendingIntent.getBroadcast(context, 42, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    // Schdedule notification
    AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    manager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, time, pending);
}

Houd er rekening mee dat de 42 hierboven uniek moet zijn voor elke geplande melding, anders zullen de PendingIntent elkaar vervangen en ongewenste effecten veroorzaken!

Annuleer een melding door de bijbehorende PendingIntent opnieuw op te PendingIntent en te annuleren op de AlarmManager van het systeem. De volgende methode annuleert een melding:

public static void cancelNotification(Context context, String title, String text) {
    Intent intent = new Intent(context, NotificationReceiver.class);
    intent.putExtra("title", title);
    intent.putExtra("text", text);
    PendingIntent pending = PendingIntent.getBroadcast(context, 42, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    // Cancel notification
    AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    manager.cancel(pending);
}

Merk op dat de 42 hierboven moet overeenkomen met het nummer van stap 3!

Stel aangepaste melding in - toon de volledige inhoudstekst

Als u een lange tekst in de context wilt weergeven, moet u een aangepaste inhoud instellen.

U hebt bijvoorbeeld dit:

Maar u wilt dat uw tekst volledig wordt weergegeven:

Het enige dat u hoeft te doen, is een stijl aan uw inhoud toevoegen zoals hieronder:

  private void generateNotification(Context context) {
        String message = "This is a custom notification with a very very very very very very very very very very long text";
        Bitmap largeIcon = BitmapFactory.decodeResource(getResources(), android.R.drawable.ic_dialog_alert);

        NotificationCompat.Builder builder = new NotificationCompat.Builder(context);

        builder.setContentTitle("Title").setContentText(message)
                .setSmallIcon(android.R.drawable.ic_dialog_alert)
                .setLargeIcon(largeIcon)
                .setAutoCancel(true)
                .setWhen(System.currentTimeMillis())
                .setStyle(new NotificationCompat.BigTextStyle().bigText(message));

        Notification notification = builder.build();
        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
        notificationManager.notify(101, notification);
    }

Stel een aangepast meldingspictogram in met behulp van de `Picasso`-bibliotheek.

    PendingIntent pendingIntent = PendingIntent.getActivity(context,
    uniqueIntentId, intent, PendingIntent.FLAG_CANCEL_CURRENT);

    final RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.remote_view_notification);
    remoteViews.setImageViewResource(R.id.remoteview_notification_icon, R.mipmap.ic_navigation_favorites);

    Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
    NotificationCompat.Builder notificationBuilder =
            new NotificationCompat.Builder(context)
                    .setSmallIcon(R.mipmap.ic_navigation_favorites) //just dummy icon
                    .setContent(remoteViews) // here we apply our view
                    .setAutoCancel(true)
                    .setContentIntent(pendingIntent)
                    .setPriority(NotificationCompat.PRIORITY_DEFAULT);

    final Notification notification = notificationBuilder.build();

    if (android.os.Build.VERSION.SDK_INT >= 16) {
        notification.bigContentView = remoteViews;
    }

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

    notificationManager.notify(uniqueIntentId, notification);


    //don't forget to include picasso to your build.gradle file.
    Picasso.with(context)
            .load(avatar)
            .into(remoteViews, R.id.remoteview_notification_icon, uniqueIntentId, notification);

En definieer vervolgens een lay-out in uw lay-outmap:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@android:color/white"
    android:orientation="vertical">



    <ImageView
        android:id="@+id/remoteview_notification_icon"
        android:layout_width="60dp"
        android:layout_height="60dp"
        android:layout_marginRight="2dp"
        android:layout_weight="0"
        android:scaleType="centerCrop"/>
</LinearLayout>

Dynamisch de juiste pixelgrootte verkrijgen voor het grote pictogram

Als u een afbeelding maakt, een afbeelding decodeert of het formaat van een afbeelding aanpast aan het grote meldingsgebied, kunt u de juiste pixelafmetingen als volgt krijgen:

Resources resources = context.getResources();
int width  = resources.getDimensionPixelSize(android.R.dimen.notification_large_icon_width);
int height = resources.getDimensionPixelSize(android.R.dimen.notification_large_icon_height);

Lopende melding met actieknop

// Cancel older notification with same id,
NotificationManager notificationMgr = (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationMgr.cancel(CALL_NOTIFY_ID);// any constant value
    
// Create Pending Intent,
Intent notificationIntent = null;
PendingIntent contentIntent = null;            
notificationIntent = new Intent (context, YourActivityName); 
contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT); 
        
// Notification builder 
builder = new NotificationCompat.Builder(context);
builder.setContentText("Ongoing Notification..");
builder.setContentTitle("ongoing notification sample");
builder.setSmallIcon(R.drawable.notification_icon);
builder.setUsesChronometer(true);
builder.setDefaults(Notification.DEFAULT_LIGHTS);
builder.setContentIntent(contentIntent);
builder.setOngoing(true);
    
// Add action button in the notification 
Intent intent = new Intent("action.name");
PendingIntent pIntent = PendingIntent.getBroadcast(context, 1, intent, 0);
builder.addAction(R.drawable.action_button_icon, "Action button name",pIntent); 
 
// Notify using notificationMgr
Notification finalNotification = builder.build();
notificationMgr.notify(CALL_NOTIFY_ID, finalNotification);

Registreer een uitzendontvanger voor dezelfde actie om een gebeurtenis met een klik op een actieknop te verwerken.

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

Android
meldingen

Zoeken…