Android => Benachrichtigungen

Erstellen einer einfachen Benachrichtigung

In diesem Beispiel wird veranschaulicht, wie eine einfache Benachrichtigung erstellt wird, mit der eine Anwendung gestartet wird, wenn der Benutzer darauf klickt.

Geben Sie den Inhalt der Benachrichtigung an:

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

Erstellen Sie die Absicht, mit einem Klick abzufeuern:

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

Erstellen Sie schließlich die Benachrichtigung und zeigen Sie sie

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

Heads Up-Benachrichtigung mit Ticker für ältere Geräte

So erstellen Sie eine Heads-Up-Benachrichtigung für fähige Geräte und einen Ticker für ältere Geräte.

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

So sieht es auf Android Marshmallow mit der Heads Up-Benachrichtigung aus:

So sieht es auf Android KitKat mit dem Ticker aus:

Bei allen Android-Versionen wird die Notification im Notification angezeigt.

Android 6.0 Eibisch:

Android 4.4.x KitKat:

Einstellen verschiedener Prioritäten in der Benachrichtigung

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

Wenn die Benachrichtigung ein Bild enthält und Sie das Bild automatisch erweitern möchten, wenn die Benachrichtigung "PRIORITY_MAX" erhalten hat, können Sie je nach Anforderung andere Prioritätsstufen verwenden

Verschiedene Prioritätsstufen Info:

PRIORITY_MAX - Verwenden Sie diese Option für kritische und dringende Benachrichtigungen, die den Benutzer auf einen zeitkritischen Zustand aufmerksam machen oder aufgelöst werden müssen, bevor er mit einer bestimmten Aufgabe fortfahren kann.

PRIORITY_HIGH - Wird hauptsächlich für wichtige Kommunikation verwendet, z. B. Nachrichten- oder Chat-Ereignisse mit Inhalten, die für den Benutzer besonders interessant sind. Benachrichtigungen mit hoher Priorität lösen die Anzeige der Heads-Up-Benachrichtigungen aus.

PRIORITY_DEFAULT - Verwenden Sie diese Option für alle Benachrichtigungen, die nicht zu den anderen hier beschriebenen Prioritäten gehören.

PRIORITY_LOW - Verwenden Sie diese Option für Benachrichtigungen, über die der Benutzer informiert werden soll, die jedoch weniger dringend sind. Benachrichtigungen mit niedriger Priorität werden in der Regel am Ende der Liste angezeigt. Dies macht sie zu einer guten Wahl für öffentliche oder ungerichtete soziale Updates: Der Benutzer hat darum gebeten, über sie benachrichtigt zu werden. Diese Benachrichtigungen sollten jedoch niemals Vorrang vor dringenden oder dringenden Aktionen haben direkte Kommunikation.

PRIORITY_MIN - Wird für Kontext- oder Hintergrundinformationen wie Wetterinformationen oder Kontextinformationen verwendet. Benachrichtigungen mit der niedrigsten Priorität werden nicht in der Statusleiste angezeigt. Der Benutzer entdeckt sie beim Erweitern des Benachrichtigungsbereichs.

Referenzen: Richtlinien für Materialdesign - Benachrichtigungen

Benachrichtigungen planen

Manchmal ist es erforderlich, eine Benachrichtigung zu einem bestimmten Zeitpunkt anzuzeigen, eine Aufgabe, die auf dem Android-System leider nicht trivial ist, da es keine Methode setTime() oder ähnliches für Benachrichtigungen gibt. In diesem Beispiel werden die Schritte beschrieben, die zum AlarmManager Benachrichtigungen mit dem AlarmManager :

Fügen Sie eine BroadcastReceiver , die zuhört Intent s vom Android ausgestrahlt AlarmManager .

Dies ist der Ort, an dem Sie Ihre Benachrichtigung auf der Grundlage der mit dem Intent bereitgestellten Extras erstellen:

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

Registrieren Sie die BroadcastReceiver in Ihrer AndroidManifest.xml Datei (sonst wird der Empfänger nicht erhalten keine Intent s aus dem AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

PendingIntent Sie eine Benachrichtigung, indem Sie einen PendingIntent für Ihren BroadcastReceiver mit den erforderlichen Intent Extras an den AlarmManager des Systems AlarmManager . Ihr BroadcastReceiver empfängt die Intent sobald die angegebene Zeit eingetroffen ist, und zeigt die Benachrichtigung an. Die folgende Methode plant eine Benachrichtigung:

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

Bitte beachten Sie, dass die 42 oben für jede geplante Benachrichtigung eindeutig sein müssen. Andernfalls werden sich die PendingIntent gegenseitig ersetzen, was zu unerwünschten Effekten führt!

Brechen Sie eine Benachrichtigung ab, indem Sie den zugehörigen PendingIntent und ihn im System AlarmManager . Die folgende Methode bricht eine Benachrichtigung ab:

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

Beachten Sie, dass die 42 oben mit der Nummer aus Schritt 3 übereinstimmen muss!

Benutzerdefinierte Benachrichtigung festlegen - Den gesamten Inhaltstext anzeigen

Wenn Sie möchten, dass ein langer Text im Kontext angezeigt wird, müssen Sie einen benutzerdefinierten Inhalt festlegen.

Zum Beispiel haben Sie Folgendes:

Sie wünschen jedoch, dass Ihr Text vollständig angezeigt wird:

Alles, was Sie tun müssen, ist, Ihren Inhalten einen Stil wie folgt hinzuzufügen :

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

Benutzerdefiniertes Benachrichtigungssymbol mithilfe der `Picasso`-Bibliothek einstellen

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

Und definieren Sie dann ein Layout in Ihrem Layoutordner:

<?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>

Dynamisches Abrufen der korrekten Pixelgröße für das große Symbol

Wenn Sie ein Bild erstellen, ein Bild dekodieren oder die Größe eines Bilds an den großen Benachrichtigungsbildbereich anpassen, können Sie die korrekten Pixelabmessungen wie folgt ermitteln:

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

Laufende Benachrichtigung mit Aktionstaste

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

Registrieren Sie einen Broadcast-Empfänger für dieselbe Aktion, um das Klickereignis für die Aktionsschaltflächen zu bearbeiten.

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

Android
Benachrichtigungen

Suche…