Android => anmälningar

Skapa ett enkelt meddelande

Detta exempel visar hur man skapar en enkel avisering som startar en applikation när användaren klickar på den.

Ange meddelandets innehåll:

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

Skapa avsikt att skjuta på klick:

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

Bygg slutligen meddelandet och visa den

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

Heads Up Meddelande med Ticker för äldre enheter

Så här gör du ett Heads Up-meddelande för kapabla enheter och använder en Ticker för äldre enheter.

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

Så här ser det ut på Android Marshmallow med meddelandet om Heads Up:

Så här ser det ut på Android KitKat med Ticker:

På alla Android-versioner, den Notification visas i lådan anmälan.

Android 6.0 Marshmallow:

Android 4.4.x KitKat:

Ställa in olika prioriteringar i anmälan

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

När meddelandet innehåller bild och du automatiskt vill expandera bilden när meddelandet mottogs använder "PRIORITY_MAX", kan du använda andra prioritetsnivåer enligt krav

Olika prioritetsnivåinformation:

PRIORITY_MAX - Används för kritiska och brådskande meddelanden som varnar användaren mot ett tillstånd som är tidskritiskt eller måste lösas innan de kan fortsätta med en viss uppgift.

PRIORITY_HIGH - Används främst för viktig kommunikation, till exempel meddelanden eller chatthändelser med innehåll som är särskilt intressant för användaren. Meddelanden med hög prioritet aktiverar meddelandeskärmen för heads-up.

PRIORITY_DEFAULT - Används för alla aviseringar som inte faller inom någon av de andra prioriteringarna som beskrivs här.

PRIORITY_LOW - Används för aviseringar som du vill att användaren ska informeras om, men som är mindre brådskande. Meddelanden med låg prioritet tenderar att dyka upp längst ner på listan, vilket gör dem till ett bra val för saker som offentliga eller underriktade sociala uppdateringar: Användaren har begärt att bli underrättad om dem, men dessa meddelanden bör aldrig ha företräde framför brådskande eller direkt kommunikation.

PRIORITY_MIN - Används för kontextuell eller bakgrundsinformation som väderinformation eller kontextuell platsinformation. Meddelanden om lägsta prioritet visas inte i statusfältet. Användaren upptäcker dem när de utvidgar meddelandeskuggan.

Referenser: Riktlinjer för materialdesign - aviseringar

Planera aviseringar

Ibland krävs det att visa ett meddelande vid en viss tidpunkt, en uppgift som tyvärr inte är trivial i Android-systemet, eftersom det inte finns någon metod setTime() eller liknande för aviseringar. Detta exempel beskriver stegen som krävs för att schemalägga aviseringar med AlarmManager :

Lägg till en BroadcastReceiver som lyssnar på Intent s som sänds av Android AlarmManager .

Det här är platsen där du bygger din anmälan baserat på de tillägg som medföljs 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);
       }
   }

Registrera BroadcastReceiver i din AndroidManifest.xml fil (annars får inte mottagaren några Intent från AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

Schemalägg ett meddelande genom att skicka ett PendingIntent för din BroadcastReceiver med nödvändiga Intent tillbehör till systemet AlarmManager . Din BroadcastReceiver kommer att få Intent när den angivna tiden har kommit och visa meddelandet. Följande metod schemalägg en anmälan:

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

Observera att 42 ovan måste vara unika för varje schemalagd meddelande, annars kommer PendingIntent ersätta varandra orsakar oönskade effekter!

Avbryt en avisering genom att bygga om den tillhörande PendingIntent och avbryta den på systemet AlarmManager . Följande metod avbryter en avisering:

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

Observera att 42 ovan måste matcha antalet från steg 3!

Ställ in anpassad avisering - visa hela innehållstexten

Om du vill ha en lång text som ska visas i sammanhanget måste du ange ett anpassat innehåll.

Till exempel har du det här:

Men du önskar att din text visas helt:

Allt du behöver göra är att lägga till en stil till ditt innehåll som nedan:

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

Ställ in anpassad meddelandeikon med hjälp av `Picasso`-biblioteket.

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

Och definiera sedan en layout i din layoutmapp:

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

Få dynamiskt rätt pixelstorlek för den stora ikonen

Om du skapar en bild, avkodar en bild eller ändrar storleken på en bild för att passa det stora meddelandebildområdet, kan du få rätt pixeldimension så:

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

Pågående meddelande med åtgärdsknapp

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

Registrera en sändningsmottagare för samma åtgärd för att hantera åtgärdsknappklickhändelse.

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

Android
anmälningar

Sök…