Android => Powiadomienia

Tworzenie prostego powiadomienia

Ten przykład pokazuje, jak utworzyć proste powiadomienie, które uruchamia aplikację, gdy użytkownik ją kliknie.

Określ treść powiadomienia:

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

Utwórz zamiar strzału po kliknięciu:

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

Na koniec zbuduj powiadomienie i pokaż je

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

Powiadomienie z Ticker dla starszych urządzeń

Oto, jak zrobić powiadomienie heads-up dla odpowiednich urządzeń i użyć Ticker dla starszych urządzeń.

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

Oto, jak to wygląda na Androida Marshmallow z powiadomieniem Heads Up:

Oto jak to wygląda na Androidzie KitKat z Tickerem:

We wszystkich wersjach Androida Notification jest wyświetlane w szufladzie powiadomień.

Android 6.0 Marshmallow:

Android 4.4.x KitKat:

Ustalanie różnych priorytetów w powiadomieniu

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

Gdy powiadomienie zawiera obraz i chcesz automatycznie rozwinąć obraz, gdy otrzymane powiadomienie używa „PRIORITY_MAX”, możesz użyć innych poziomów priorytetu zgodnie z wymaganiami

Informacje o różnych poziomach priorytetów:

PRIORITY_MAX - służy do krytycznych i pilnych powiadomień, które ostrzegają użytkownika o stanie krytycznym czasowo lub wymagającym rozwiązania, zanim będzie mógł kontynuować określone zadanie.

PRIORITY_HIGH - służy przede wszystkim do ważnej komunikacji, takiej jak wiadomości lub czaty z treściami szczególnie interesującymi dla użytkownika. Powiadomienia o wysokim priorytecie wywołują wyświetlenie powiadomienia heads-up.

PRIORITY_DEFAULT - Użyj dla wszystkich powiadomień, które nie mieszczą się w żadnym z innych opisanych tutaj priorytetów.

PRIORITY_LOW - służy do powiadomień, o których użytkownik ma być informowany, ale które są mniej pilne. Powiadomienia o niskim priorytecie zwykle pojawiają się na dole listy, co sprawia, że są dobrym wyborem w przypadku publicznych lub niekierowanych aktualizacji społecznościowych: użytkownik poprosił o powiadomienie o nich, ale powiadomienia te nigdy nie powinny mieć pierwszeństwa przed pilnymi lub bezpośrednia komunikacja.

PRIORITY_MIN - Użyj do informacji kontekstowych lub w tle, takich jak informacje o pogodzie lub kontekstowe informacje o lokalizacji. Powiadomienia o minimalnym priorytecie nie pojawiają się na pasku stanu. Użytkownik odkrywa je po rozszerzeniu obszaru powiadomień.

Odniesienia: Wytyczne dotyczące projektowania materiałów - powiadomienia

Planowanie powiadomień

Czasami wymagane jest wyświetlenie powiadomienia w określonym czasie, co niestety nie jest trywialne w systemie Android, ponieważ nie ma metody setTime() ani podobnej do powiadomień. W tym przykładzie przedstawiono kroki niezbędne do zaplanowania powiadomień za pomocą AlarmManager :

Dodaj BroadcastReceiver że słucha Intent s emitowany przez Android AlarmManager .

To jest miejsce, w którym budujesz swoje powiadomienie na podstawie dodatków dostarczonych z 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);
       }
   }

Zarejestruj BroadcastReceiver w AndroidManifest.xml pliku (w przeciwnym razie odbiorca nie otrzyma żadnych Intent S od strony AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

Zaplanuj powiadomienie , przekazując PendingIntent dla swojego BroadcastReceiver z potrzebnymi dodatkami Intent do systemu AlarmManager . Twój BroadcastReceiver otrzyma Intent gdy nadejdzie określony czas i wyświetli powiadomienie. Następująca metoda planuje powiadomienie:

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

Należy pamiętać, że 42 powyżej musi być unikalny dla każdego zaplanowanego powiadomienia, w przeciwnym razie PendingIntent zastąpi się wzajemnie, powodując niepożądane efekty!

Anuluj powiadomienie , odbudowując powiązany PendingIntent i anulując je w System AlarmManager . Następująca metoda anuluje powiadomienie:

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

Pamiętaj, że 42 powyżej musi pasować do liczby z kroku 3!

Ustaw niestandardowe powiadomienie - pokaż pełny tekst treści

Jeśli chcesz wyświetlać długi tekst w kontekście, musisz ustawić niestandardową treść.

Na przykład masz to:

Ale chcesz, aby Twój tekst był w pełni widoczny:

Wszystko, co musisz zrobić, to dodać styl do treści, jak poniżej:

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

Ustaw niestandardową ikonę powiadomienia za pomocą biblioteki `Picasso`.

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

A następnie zdefiniuj układ w folderze układów:

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

Dynamiczne uzyskiwanie prawidłowego rozmiaru piksela dla dużej ikony

Jeśli tworzysz obraz, dekodujesz obraz lub zmieniasz rozmiar obrazu, aby dopasować go do dużego obszaru obrazu powiadomienia, możesz uzyskać prawidłowe wymiary pikseli, takie jak:

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

Ciągłe powiadomienia za pomocą przycisku akcji

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

Zarejestruj odbiornik emisji dla tej samej akcji, aby obsłużyć zdarzenie kliknięcia przycisku akcji.

Modified text is an extract of the original Stack Overflow Documentation

Licencjonowany na podstawie CC BY-SA 3.0

Nie związany z Stack Overflow

Android
Powiadomienia

Szukaj…