Powiadomienie nie wyświetla się w Oreo

183

Normalny Konstruktor powiadomień nie wyświetla powiadomień na Androidzie O.

Jak mogę wyświetlić powiadomienie na Androidzie 8 Oreo?

Czy jest jakiś nowy kod do dodania do wyświetlania powiadomień na Androidzie O?

amorenew
źródło
3
Zapomniałem ustawić „.setChannelId” na NotificationCompat.Builder, a teraz działa w oreo (8.0)
varotariya vajsi
Sprawdź, czy to może pomóc freakyjolly.com/android-useful-methods-and-functions/#3method
Code Spy

Odpowiedzi:

265

W Androidzie O konieczne jest używanie kanału z Konstruktorem powiadomień

poniżej znajduje się przykładowy kod:

// Sets an ID for the notification, so it can be updated.
int notifyID = 1; 
String CHANNEL_ID = "my_channel_01";// The id of the channel. 
CharSequence name = getString(R.string.channel_name);// The user-visible name of the channel.
int importance = NotificationManager.IMPORTANCE_HIGH;
NotificationChannel mChannel = new NotificationChannel(CHANNEL_ID, name, importance);
// Create a notification and set the notification channel.
Notification notification = new Notification.Builder(MainActivity.this)
            .setContentTitle("New Message")
            .setContentText("You've received new messages.")
            .setSmallIcon(R.drawable.ic_notify_status)
            .setChannelId(CHANNEL_ID)
            .build();

Lub ze zgodnością obsługi poprzez:

NotificationCompat notification =
        new NotificationCompat.Builder(this)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setChannelId(CHANNEL_ID).build();



NotificationManager mNotificationManager =
            (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
 mNotificationManager.createNotificationChannel(mChannel);

// Issue the notification.
mNotificationManager.notify(notifyID , notification);

lub jeśli chcesz prostej poprawki, użyj następującego kodu:

NotificationManager mNotificationManager =
            (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       mNotificationManager.createNotificationChannel(mChannel);
    }

Aktualizacje: odwołanie NotificationCompat.Builder

NotificationCompat.Builder(Context context)

Ten konstruktor został uznany za przestarzały na poziomie API 26.0.0, więc powinieneś go użyć

Builder(Context context, String channelId)

więc nie ma takiej potrzeby setChannelIdz nowym konstruktorem.

I powinieneś użyć najnowszej biblioteki AppCompat obecnie 26.0.2

compile "com.android.support:appcompat-v7:26.0.+"

Źródło z kanału programistów Androida na Youtube

Możesz także sprawdzić oficjalne Dokumenty na Androida

amorenew
źródło
4
Musisz także utworzyć kanał, zanim będzie można go użyć. Zobacz developer.android.com/reference/android/app/…
Guillaume Perrot
2
setChannel jest przestarzałe na rzecz setChannelId
Guillaume Perrot
1
Nie, pojawia się błąd, jeśli nie utworzysz kanału przynajmniej raz w całym okresie instalacji aplikacji.
Guillaume Perrot
1
@amorenew najwyraźniej miałem niewłaściwą nazwę kanału. Już działa. Dzięki, ale twoja odpowiedź nie jest kompletna ... musisz najpierw utworzyć kanał za pomocą mNotificationManager.createNotificationChannel (mChannel); (Zrobiłem to w mojej klasie aplikacji) ... zobacz dokumenty Google w tym celu. Może dodaj to do swojej odpowiedzi.
JPM
2
Jakie zależności / wersje należy kierować, aby uzyskać nowy NotificationCompat.Builder(Context, String)konstruktor? Używam (między innymi): - compileSdkVersion 26- buildToolsVersion '26.0.2'- compile 'com.android.support:appcompat-v7:26.0.0-beta2' a jednak nadal nie akceptuje mojego konstruktora za pomocą kontekstu i łańcucha. Jakieś pomysły?
Loisaida Sam Sandberg,
92

Tutaj zamieszczam funkcję szybkiego rozwiązania z celową obsługą

public void showNotification(Context context, String title, String body, Intent intent) {
    NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

    int notificationId = 1;
    String channelId = "channel-01";
    String channelName = "Channel Name";
    int importance = NotificationManager.IMPORTANCE_HIGH;

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
        NotificationChannel mChannel = new NotificationChannel(
                channelId, channelName, importance);
        notificationManager.createNotificationChannel(mChannel);
    }

    NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context, channelId)
            .setSmallIcon(R.mipmap.ic_launcher)
            .setContentTitle(title)
            .setContentText(body);

    TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);
    stackBuilder.addNextIntent(intent);
    PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(
            0,
            PendingIntent.FLAG_UPDATE_CURRENT
    );
    mBuilder.setContentIntent(resultPendingIntent);

    notificationManager.notify(notificationId, mBuilder.build());
}
FinalDark
źródło
To samo tutaj. Tylko jeden, który pracował dla mnie 4 dla FCM i Androida> = 8.
YingYang
1
szybkie i proste
alfian5229,
Dziękuję bardzo. Spędziłem godziny na rozwiązywaniu problemów z powodu braku powiadomień. Więc jeśli chcesz tylko, aby jeden wyskakował, upewnij się, że utworzyłeś NotificationChannel za pomocą NotificationManager dla Androida Oreo +.
Joxon,
ten kod jest najłatwiejszy do wdrożenia i zrozumienia, jest nawet aktualny na grudzień 2019 r. Dzięki.
Pradeep Dhawan
Jaka jest różnica między powiadomieniemManager.notify a startForeground w systemie Android?
użytkownik1090751
76

Oprócz tej odpowiedzi musisz utworzyć kanał powiadomień, zanim będzie można go użyć.

  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

      /* Create or update. */
      NotificationChannel channel = new NotificationChannel("my_channel_01",
          "Channel human readable title", 
          NotificationManager.IMPORTANCE_DEFAULT);
      mNotificationManager.createNotificationChannel(channel);
  }

Musisz także korzystać z kanałów, tylko jeśli Twój targetSdkVersion ma 26 lub więcej.

Jeśli używasz NotificationCompat.Builder, musisz także zaktualizować wersję beta biblioteki pomocy technicznej: https://developer.android.com/topic/libraries/support-library/revisions.html#26-0-0- beta2 (aby móc wywołać setChannelIdkonstruktora kompatybilności).

Bądź ostrożny, ponieważ ta aktualizacja biblioteki podnosi minSdkLevel do 14.

Guillaume Perrot
źródło
To spowoduje wyświetlenie ostrzeżenia, jeśli min. API jest niższe niż 26. Dodaj @TargetApi (26) tuż przed utworzeniem kanału, aby zignorować ostrzeżenie.
s-hunter
Jeśli masz przykładowy przykład w kodzie, nie wyświetli on ostrzeżenia, szybka poprawka ma inne sugestie, jedną z nich jest otoczyć kod, jeśli sprawdzasz wersję. Jeśli dostroisz sprawdzanie wersji if, Android Studio może być zdezorientowany i może go nie wykryć.
Guillaume Perrot
11
public class MyFirebaseMessagingServices extends FirebaseMessagingService {
    private NotificationChannel mChannel;
    private NotificationManager notifManager;
    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        if (remoteMessage.getData().size() > 0) {
            try {
                JSONObject jsonObject = new JSONObject(remoteMessage.getData());
                displayCustomNotificationForOrders(jsonObject.getString("title"), jsonObject.getString("description"));
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    private void displayCustomNotificationForOrders(String title, String description) {
        if (notifManager == null) {
            notifManager = (NotificationManager) getSystemService
                    (Context.NOTIFICATION_SERVICE);
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationCompat.Builder builder;
            Intent intent = new Intent(this, Dashboard.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            PendingIntent pendingIntent;
            int importance = NotificationManager.IMPORTANCE_HIGH;
            if (mChannel == null) {
                mChannel = new NotificationChannel
                        ("0", title, importance);
                mChannel.setDescription(description);
                mChannel.enableVibration(true);
                notifManager.createNotificationChannel(mChannel);
            }
            builder = new NotificationCompat.Builder(this, "0");

            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP |
                    Intent.FLAG_ACTIVITY_SINGLE_TOP);
            pendingIntent = PendingIntent.getActivity(this, 1251, intent, PendingIntent.FLAG_ONE_SHOT);
            builder.setContentTitle(title)  
                    .setSmallIcon(getNotificationIcon()) // required
                    .setContentText(description)  // required
                    .setDefaults(Notification.DEFAULT_ALL)
                    .setAutoCancel(true)
                    .setLargeIcon(BitmapFactory.decodeResource
                            (getResources(), R.mipmap.logo))
                    .setBadgeIconType(R.mipmap.logo)
                    .setContentIntent(pendingIntent)
                    .setSound(RingtoneManager.getDefaultUri
                            (RingtoneManager.TYPE_NOTIFICATION));
            Notification notification = builder.build();
            notifManager.notify(0, notification);
        } else {

            Intent intent = new Intent(this, Dashboard.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            PendingIntent pendingIntent = null;

            pendingIntent = PendingIntent.getActivity(this, 1251, intent, PendingIntent.FLAG_ONE_SHOT);

            Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
            NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)
                    .setContentTitle(title)
                    .setContentText(description)
                    .setAutoCancel(true)
                    .setColor(ContextCompat.getColor(getBaseContext(), R.color.colorPrimary))
                    .setSound(defaultSoundUri)
                    .setSmallIcon(getNotificationIcon())
                    .setContentIntent(pendingIntent)
                    .setStyle(new NotificationCompat.BigTextStyle().setBigContentTitle(title).bigText(description));

            NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            notificationManager.notify(1251, notificationBuilder.build());
        }
    }

    private int getNotificationIcon() {
        boolean useWhiteIcon = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP);
        return useWhiteIcon ? R.mipmap.logo : R.mipmap.logo;
    }
}
Mohsinali
źródło
Bez ustawienia setChannelId (CHANNEL_ID) w NotificationCompat.Builder nie wyświetla powiadomień.
Shihab Uddin
7

Jeśli nie możesz otrzymać powiadomienia wypychanego w wersji 26+ SDK?

twoje rozwiązanie jest tutaj:

public static void showNotification(Context context, String title, String messageBody) {

        boolean isLoggedIn = SessionManager.getInstance().isLoggedIn();
        Log.e(TAG, "User logged in state: " + isLoggedIn);

        Intent intent = null;
        if (isLoggedIn) {
            //goto notification screen
            intent = new Intent(context, MainActivity.class);
            intent.putExtra(Extras.EXTRA_JUMP_TO, DrawerItems.ITEM_NOTIFICATION);
        } else {
            //goto login screen
            intent = new Intent(context, LandingActivity.class);
        }

        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0 /* Request code */, intent, PendingIntent.FLAG_ONE_SHOT);

        //Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        //Bitmap largeIcon = BitmapFactory.decodeResource(getResources(), R.drawable.ic_app_notification_icon);

        String channel_id = createNotificationChannel(context);

        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(context, channel_id)
                .setContentTitle(title)
                .setContentText(messageBody)
                .setStyle(new NotificationCompat.BigTextStyle().bigText(messageBody))
                /*.setLargeIcon(largeIcon)*/
                .setSmallIcon(R.drawable.app_logo_color) //needs white icon with transparent BG (For all platforms)
                .setColor(ContextCompat.getColor(context, R.color.colorPrimaryDark))
                .setVibrate(new long[]{1000, 1000})
                .setSound(Settings.System.DEFAULT_NOTIFICATION_URI)
                .setContentIntent(pendingIntent)
                .setPriority(Notification.PRIORITY_HIGH)
                .setAutoCancel(true);

        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        notificationManager.notify((int) ((new Date(System.currentTimeMillis()).getTime() / 1000L) % Integer.MAX_VALUE) /* ID of notification */, notificationBuilder.build());
    }

public static String createNotificationChannel(Context context) {

        // NotificationChannels are required for Notifications on O (API 26) and above.
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

            // The id of the channel.
            String channelId = "Channel_id";

            // The user-visible name of the channel.
            CharSequence channelName = "Application_name";
            // The user-visible description of the channel.
            String channelDescription = "Application_name Alert";
            int channelImportance = NotificationManager.IMPORTANCE_DEFAULT;
            boolean channelEnableVibrate = true;
//            int channelLockscreenVisibility = Notification.;

            // Initializes NotificationChannel.
            NotificationChannel notificationChannel = new NotificationChannel(channelId, channelName, channelImportance);
            notificationChannel.setDescription(channelDescription);
            notificationChannel.enableVibration(channelEnableVibrate);
//            notificationChannel.setLockscreenVisibility(channelLockscreenVisibility);

            // Adds NotificationChannel to system. Attempting to create an existing notification
            // channel with its original values performs no operation, so it's safe to perform the
            // below sequence.
            NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
            assert notificationManager != null;
            notificationManager.createNotificationChannel(notificationChannel);

            return channelId;
        } else {
            // Returns null for pre-O (26) devices.
            return null;
        }
    }

NotificationCompat.Builder powiadomienieBuilder = nowe NotificationCompat.Builder (kontekst, identyfikator_kanału)

-> Tutaj otrzymasz powiadomienie push za pomocą channel_id w urządzeniu, które składa się z wersji SDK 26+.

-> Ponieważ NotificationCompat.Builder(context) metoda jest przestarzała, teraz będziesz używać zaktualizowanej wersji, która ma dwa parametry: jeden to kontekst, drugi to identyfikator_kanału.

-> NotificationCompat.Builder(context, channel_id) zaktualizowana metoda. Spróbuj.

-> W wersji 26+ SDK urządzenia za każdym razem utworzysz channel_id.

Książę
źródło
Dzięki, że użyłem statycznego
notifcation_id
5

Skorzystaj z tej klasy dla systemu Android 8 Notification

public class NotificationHelper {

private Context mContext;
private NotificationManager mNotificationManager;
private NotificationCompat.Builder mBuilder;
public static final String NOTIFICATION_CHANNEL_ID = "10001";

public NotificationHelper(Context context) {
    mContext = context;
}

/**
 * Create and push the notification 
 */
public void createNotification(String title, String message)
{    
    /**Creates an explicit intent for an Activity in your app**/
    Intent resultIntent = new Intent(mContext , SomeOtherActivity.class);
    resultIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    PendingIntent resultPendingIntent = PendingIntent.getActivity(mContext,
            0 /* Request code */, resultIntent,
            PendingIntent.FLAG_UPDATE_CURRENT);

    mBuilder = new NotificationCompat.Builder(mContext);
    mBuilder.setSmallIcon(R.mipmap.ic_launcher);
    mBuilder.setContentTitle(title)
            .setContentText(message)
            .setAutoCancel(false)
            .setSound(Settings.System.DEFAULT_NOTIFICATION_URI)
            .setContentIntent(resultPendingIntent);

    mNotificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O)
    {
        int importance = NotificationManager.IMPORTANCE_HIGH;
        NotificationChannel notificationChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, "NOTIFICATION_CHANNEL_NAME", importance);
        notificationChannel.enableLights(true);
        notificationChannel.setLightColor(Color.RED);
        notificationChannel.enableVibration(true);
        notificationChannel.setVibrationPattern(new long[]{100, 200, 300, 400, 500, 400, 300, 200, 400});
        assert mNotificationManager != null;
        mBuilder.setChannelId(NOTIFICATION_CHANNEL_ID);
        mNotificationManager.createNotificationChannel(notificationChannel);
    }
    assert mNotificationManager != null;
    mNotificationManager.notify(0 /* Request Code */, mBuilder.build());
  }
}
Jimale Abdi
źródło
4

Wypróbuj ten kod:

public class FirebaseMessagingServices extends com.google.firebase.messaging.FirebaseMessagingService {
    private static final String TAG = "MY Channel";
    Bitmap bitmap;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        super.onMessageReceived(remoteMessage);
        Utility.printMessage(remoteMessage.getNotification().getBody());

        // Check if message contains a data payload.
        if (remoteMessage.getData().size() > 0) {
            Log.d(TAG, "Message data payload: " + remoteMessage.getData());

            String title = remoteMessage.getData().get("title");
            String body = remoteMessage.getData().get("body");
            String message = remoteMessage.getData().get("message");
            String imageUri = remoteMessage.getData().get("image");
            String msg_id = remoteMessage.getData().get("msg-id");
          

            Log.d(TAG, "1: " + title);
            Log.d(TAG, "2: " + body);
            Log.d(TAG, "3: " + message);
            Log.d(TAG, "4: " + imageUri);
          

            if (imageUri != null)
                bitmap = getBitmapfromUrl(imageUri);

            }

            sendNotification(message, bitmap, title, msg_id);
                    
        }


    }

    private void sendNotification(String message, Bitmap image, String title,String msg_id) {
        int notifyID = 0;
        try {
            notifyID = Integer.parseInt(msg_id);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }

        String CHANNEL_ID = "my_channel_01";            // The id of the channel.
        Intent intent = new Intent(this, HomeActivity.class);
        intent.putExtra("title", title);
        intent.putExtra("message", message);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);


        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
                PendingIntent.FLAG_ONE_SHOT);

        Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, "01")
                .setContentTitle(title)
                .setSmallIcon(R.mipmap.ic_notification)
                .setStyle(new NotificationCompat.BigTextStyle()
                        .bigText(message))
                .setContentText(message)
                .setAutoCancel(true)
                .setSound(defaultSoundUri)
                .setChannelId(CHANNEL_ID)
                .setContentIntent(pendingIntent);

        if (image != null) {
            notificationBuilder.setStyle(new NotificationCompat.BigPictureStyle()   //Set the Image in Big picture Style with text.
                    .bigPicture(image)
                    .setSummaryText(message)
                    .bigLargeIcon(null));
        }


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

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {       // For Oreo and greater than it, we required Notification Channel.
           CharSequence name = "My New Channel";                   // The user-visible name of the channel.
            int importance = NotificationManager.IMPORTANCE_HIGH;

            NotificationChannel channel = new NotificationChannel(CHANNEL_ID,name, importance); //Create Notification Channel
            notificationManager.createNotificationChannel(channel);
        }

        notificationManager.notify(notifyID /* ID of notification */, notificationBuilder.build());
    }

    public Bitmap getBitmapfromUrl(String imageUrl) {     //This method returns the Bitmap from Url;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoInput(true);
            connection.connect();
            InputStream input = connection.getInputStream();
            Bitmap bitmap = BitmapFactory.decodeStream(input);
            return bitmap;

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;

        }

    }

}

Rohit Mhatre
źródło
Użyłem tego kodu, ale drogie powiadomienie z obrazem nie jest widoczne, gdy aplikacja w tle ma jakieś rozwiązanie, proszę o pomoc.
Mohsin Khan
Zależy to od niektórych czynników, takich jak: - 1. Czy jesteś podłączony do sieci .. ??? 2. Czy adres URL obrazu jest poprawny (sprawdź imageurl, naciskając imageurl w przeglądarce)
Rohit Mhatre
3

Aplikacja demonstracyjna powiadomień dla systemu Android dla systemu Android O oraz niższych wersji API. Oto najlepsza aplikacja demo na GitHub-Demo 1 i GitHub-Demo 2 .

wprowadź opis zdjęcia tutaj

Attaullah
źródło
Zastanów się nad opublikowaniem minimalnego fragmentu kodu dotyczącego działania aplikacji zamiast udostępniania linków do zewnętrznego źródła bez przypisania / powiązania tego, kto jest właścicielem źródeł. (Te źródła mogą również ulec awarii w dowolnym momencie bez możliwości uzyskania do nich dostępu).
Edric,
2

To jest błąd w Firebase API w wersji 11.8.0, więc jeśli zmniejszysz wersję API, nie napotkasz tego problemu.

M.Noman
źródło
Właściwie to sprawdziłem. Jeśli pracujesz na emulatorze Androida - sprawdź swoją aplikację na urządzeniu fizycznym. Nowe emulatory jakoś nie wyświetlają powiadomień.
deadfish
Nie, w rzeczywistości był to błąd w wersji Firebase 11.8.0, a teraz został naprawiony w nowszej wersji 12.0.0. W
celach
2

Miałem ten sam problem na Oreo i odkryłem, że jeśli najpierw utworzysz swój kanał za pomocą NotificationManager.IMPORTANCE_NONE, a następnie zaktualizujesz go później, kanał zachowa pierwotny poziom ważności.

Jest to poparte dokumentacją szkoleniową Google Notification, która stwierdza:

Po utworzeniu kanału powiadomień nie można zmienić zachowań powiadomień - użytkownik ma wtedy pełną kontrolę.

Usunięcie i ponowna instalacja aplikacji pozwoli zresetować zachowania kanału.

Najlepiej unikać używania IMPORTANCE_NONE, chyba że chcesz ukryć powiadomienia dla tego kanału, tzn. Użyć cichych powiadomień.

Kent Muller
źródło
1

Oto jak to robisz

private fun sendNotification() {
    val notificationId = 100
    val chanelid = "chanelid"
    val intent = Intent(this, MainActivity::class.java)
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
    val pendingIntent = PendingIntent.getActivity(this, 0, intent, 0)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { // you must create a notification channel for API 26 and Above
        val name = "my channel"
        val description = "channel description"
        val importance = NotificationManager.IMPORTANCE_DEFAULT
        val channel = NotificationChannel(chanelid, name, importance);
        channel.setDescription(description);
        // Register the channel with the system; you can't change the importance
        // or other notification behaviors after this
        val notificationManager = getSystemService(NotificationManager::class.java)
        notificationManager.createNotificationChannel(channel)
    }

    val mBuilder = NotificationCompat.Builder(this, chanelid)
            .setSmallIcon(R.drawable.ic_notification)
            .setContentTitle("Want to Open My App?")
            .setContentText("Open my app and see good things")
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            .setContentIntent(pendingIntent)
            .setAutoCancel(true) // cancel the notification when clicked
            .addAction(R.drawable.ic_check, "YES", pendingIntent) //add a btn to the Notification with a corresponding intent

    val notificationManager = NotificationManagerCompat.from(this);
    notificationManager.notify(notificationId, mBuilder.build());
}

Przeczytaj pełny samouczek na => https://developer.android.com/training/notify-user/build-notification

EdgeDev
źródło
1

CHANNEL_IDw NotificationChannel i Notification.Builder musi być taki sam, wypróbuj ten kod:

String CHANNEL_ID = "my_channel_01";
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Solveta Unread", NotificationManager.IMPORTANCE_DEFAULT);


Notification.Builder notification = new Notification.Builder(getApplicationContext(), CHANNEL_ID);
Zeero0
źródło
1

Cóż, w moim przypadku mam system Android 8.1.0 i numer modelu vivo1811 i próbowałem ze wszystkimi powyższymi rozwiązaniami, ale nic nie działa.

W końcu napisałem do pomocy technicznej Firebase, a następnie przy dalszym debugowaniu otrzymałem komunikat „Nie udało się wysłać do zatrzymanej aplikacji”: Upewnij się, że aplikacja nie została wymuszona .

I to była odpowiedź zespołu Firebase ->

Jest to znany problem spowodowany optymalizacją baterii wdrożoną przez niektórych producentów OEM. Po przesunięciu aplikacji w przełączniku aplikacji jest ona traktowana tak, jakby została zatrzymana w sposób wymuszony, co nie jest domyślnym zachowaniem Androida. Niefortunnym efektem ubocznym jest to, że może spowodować, że usługa FCM przestanie działać. Pracujemy nad poprawą tego zachowania od samego końca, ale faktyczna poprawka musi pochodzić od strony OEM.

Tutaj OEM oznacza producenta oryginalnego sprzętu .

B.shruti
źródło
0

Dla każdego, kto zmaga się z tym po wypróbowaniu powyższych rozwiązań, upewnij się, że identyfikator kanału użyty podczas tworzenia kanału powiadomień jest identyczny z identyfikatorem kanału ustawionym w Konstruktorze powiadomień.

const val CHANNEL_ID = "EXAMPLE_CHANNEL_ID"

// create notification channel
val notificationChannel = NotificationChannel(CHANNEL_ID, 
NOTIFICATION_NAME, NotificationManager.IMPORTANCE_HIGH)

// building notification
NotificationCompat.Builder(context)
                    .setSmallIcon(android.R.drawable.ic_input_add)
                    .setContentTitle("Title")
                    .setContentText("Subtitle")   
                    .setPriority(NotificationCompat.PRIORITY_MAX)
                    .setChannelId(CHANNEL_ID)
Jules
źródło
0
private void addNotification() {
                NotificationCompat.Builder builder =
                new NotificationCompat.Builder(this)
                .setSmallIcon(R.drawable.ic_launcher_background)
                .setContentTitle("Notifications Example")
                .setContentText("This is a test notification");
                Intent notificationIntent = new Intent(this, MainActivity.class);
                PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent,
                PendingIntent.FLAG_UPDATE_CURRENT);
                builder.setContentIntent(contentIntent);
                // Add as notification
                NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O)
                {
                NotificationChannel nChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, "NOTIFICATION_CHANNEL_NAME", NotificationManager.IMPORTANCE_HIGH);
                nChannel.enableLights(true);
                assert manager != null;
                builder.setChannelId(NOTIFICATION_CHANNEL_ID);
                manager.createNotificationChannel(nChannel);
                }
                assert manager != null;
                manager.notify(0, builder.build());
    }
Brijesh padsala
źródło
0

Poniższa metoda pokaże powiadomienie z włączonym dużym tekstem i zamrożeniem (powiadomienie nie zostanie usunięte nawet po przesunięciu przez użytkownika). Potrzebujemy usługi NotificationManager

public static void showNotificationOngoing(Context context,String title) {
        NotificationManager notificationManager =
                (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);

        PendingIntent contentIntent = PendingIntent.getActivity(context, 0,
                new Intent(context, MainActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);

        Notification.Builder notificationBuilder = new Notification.Builder(context)
                .setContentTitle(title + DateFormat.getDateTimeInstance().format(new Date()) + ":" + accuracy)
                .setContentText(addressFragments.toString())
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentIntent(contentIntent)
                .setOngoing(true)
                .setStyle(new Notification.BigTextStyle().bigText(addressFragments.toString()))
                .setAutoCancel(true);
        notificationManager.notify(3, notificationBuilder.build());
}

Metoda usuwania powiadomień

public static void removeNotification(Context context){
    NotificationManager notificationManager =
            (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
    notificationManager.cancelAll();
}

Link źródłowy

Code Spy
źródło
0
NotificationCompat.Builder(Context context)

już nieaktualne dla wersji większej lub równej Android Oreo. Możesz zmienić implementację na używanie

NotificationCompat.Builder(Context context, String channelId)
latifalbr
źródło
0
fun pushNotification(message: String?, clickAtion: String?) {
        val ii = Intent(clickAtion)
        ii.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
        val pendingIntent = PendingIntent.getActivity(this, REQUEST_CODE, ii, PendingIntent.FLAG_ONE_SHOT)

        val soundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)

        val largIcon = BitmapFactory.decodeResource(applicationContext.resources,
                R.mipmap.ic_launcher)


        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        val channelId = "default_channel_id"
        val channelDescription = "Default Channel"
// Since android Oreo notification channel is needed.
//Check if notification channel exists and if not create one
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            var notificationChannel = notificationManager.getNotificationChannel(channelId)
            if (notificationChannel != null) {
                val importance = NotificationManager.IMPORTANCE_HIGH //Set the importance level
                notificationChannel = NotificationChannel(channelId, channelDescription, importance)
               // notificationChannel.lightColor = Color.GREEN //Set if it is necesssary
                notificationChannel.enableVibration(true) //Set if it is necesssary
                notificationManager.createNotificationChannel(notificationChannel)


                val noti_builder = NotificationCompat.Builder(this)
                        .setContentTitle("MMH")
                        .setContentText(message)
                        .setSmallIcon(R.drawable.ic_launcher_background)
                        .setChannelId(channelId)
                        .build()
                val random = Random()
                val id = random.nextInt()
                notificationManager.notify(id,noti_builder)

            }

        }
        else
        {
            val notificationBuilder = NotificationCompat.Builder(this)
                    .setSmallIcon(R.mipmap.ic_launcher).setColor(resources.getColor(R.color.colorPrimary))
                    .setVibrate(longArrayOf(200, 200, 0, 0, 0))
                    .setContentTitle(getString(R.string.app_name))

                    .setLargeIcon(largIcon)
                    .setContentText(message)
                    .setAutoCancel(true)
                    .setStyle(NotificationCompat.BigTextStyle().bigText(message))
                    .setSound(soundUri)
                    .setContentIntent(pendingIntent)


            val random = Random()
            val id = random.nextInt()
            notificationManager.notify(id, notificationBuilder.build())

        }



    }
Gnyaneshwar Vandakar
źródło
1
Ten fragment kodu może rozwiązać problem, ale nie wyjaśnia, dlaczego ani w jaki sposób odpowiada na pytanie. Dołącz wyjaśnienie swojego kodu , ponieważ to naprawdę pomaga poprawić jakość Twojego postu. Pamiętaj, że w przyszłości odpowiadasz na pytanie czytelników, a ci ludzie mogą nie znać przyczyn Twojej sugestii kodu. Możesz użyć przycisku edycji , aby poprawić tę odpowiedź, aby uzyskać więcej głosów i reputację!
Brian Tompsett - 汤 莱恩
0

Poniższy fragment kodu działa dla mnie w Oreo, możesz spróbować. mam nadzieję, że to zadziała

private void sendNotification (Kontekst ctx, tytuł ciągu, int powiadomienieNumer, komunikat ciągu, podtekst ciągu, zamiar zamiaru) {
try {

            PendingIntent pendingIntent = PendingIntent.getActivity(ctx, notificationNumber, intent,
                    PendingIntent.FLAG_UPDATE_CURRENT);
            Uri url = null;           
            NotificationCompat.Builder notificationBuilder = null;
            try {
                if (Build.VERSION.SDK_INT >= 26) {

                    try{
                        NotificationManager notificationManager = (NotificationManager)getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);
                        notificationManager.deleteNotificationChannel(CHANNEL_ID_1);
                        notificationManager.deleteNotificationChannel(CHANNEL_ID_2);

                        if(!intent.getStringExtra("type").equalsIgnoreCase(""+TYPE_REQUEST)){
                            NotificationChannel breaking = new NotificationChannel(CHANNEL_ID_1, CHANNEL_ID_1_NAME, NotificationManager.IMPORTANCE_HIGH);
                            breaking.setShowBadge(false);
                            breaking.enableLights(true);
                            breaking.enableVibration(true);
                            breaking.setLightColor(Color.WHITE);
                            breaking.setVibrationPattern(new long[]{100, 200, 100, 200, 100, 200, 100});
                            breaking.setSound(url,new AudioAttributes.Builder().build());

                            notificationBuilder = new NotificationCompat.Builder(this,CHANNEL_ID_1)
                                    .setSmallIcon(R.mipmap.ic_launcher);
                            notificationManager.createNotificationChannel(breaking);

                        }else{

                            NotificationChannel politics = new NotificationChannel(CHANNEL_ID_2,CHANNEL_ID_2_NAME, NotificationManager.IMPORTANCE_DEFAULT);
                            politics.setShowBadge(false);
                            politics.enableLights(true);
                            politics.enableVibration(true);
                            politics.setLightColor(Color.BLUE);
                            politics.setVibrationPattern(new long[]{100, 200, 100, 200, 100});
                            politics.setSound(url,new AudioAttributes.Builder().build());

                            notificationBuilder = new NotificationCompat.Builder(this,CHANNEL_ID_2)
                                    .setSmallIcon(R.mipmap.ic_launcher);
                            notificationManager.createNotificationChannel(politics);
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }

                } else {
                    notificationBuilder = new NotificationCompat.Builder(ctx)
                            .setSmallIcon(R.mipmap.ic_launcher);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            if (notificationBuilder == null) {
                notificationBuilder = new NotificationCompat.Builder(ctx)
                        .setSmallIcon(R.mipmap.ic_launcher);
            }


            notificationBuilder.setContentTitle(title);          
            notificationBuilder.setSubText(subtext);
            notificationBuilder.setAutoCancel(true);

            notificationBuilder.setContentIntent(pendingIntent);
            notificationBuilder.setNumber(notificationNumber);
            NotificationManager notificationManager =
                    (NotificationManager) ctx.getSystemService(Context.NOTIFICATION_SERVICE);

            notificationManager.notify(notificationNumber, notificationBuilder.build());

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
Ghanshyam
źródło
0

W Androidzie Oreo aplikacja powiadomień odbywa się przy użyciu kanałów i klasy NotificationHelper. Powinna mieć identyfikator kanału i nazwę kanału.

Najpierw musisz utworzyć klasę NotificationHelper

public class NotificationHelper extends ContextWrapper {

private static final String EDMT_CHANNEL_ID="com.example.safna.notifier1.EDMTDEV";
private static final String EDMT_CHANNEL_NAME="EDMTDEV Channel";
private NotificationManager manager;

public  NotificationHelper(Context base)
{
    super(base);
    createChannels();
}
private void createChannels()
{
    NotificationChannel edmtChannel=new NotificationChannel(EDMT_CHANNEL_ID,EDMT_CHANNEL_NAME,NotificationManager.IMPORTANCE_DEFAULT);
    edmtChannel.enableLights(true);
    edmtChannel.enableVibration(true);
    edmtChannel.setLightColor(Color.GREEN);
    edmtChannel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);

    getManager().createNotificationChannel(edmtChannel);

}
public NotificationManager getManager()
{
   if (manager==null)
       manager=(NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
   return manager;

}
public NotificationCompat.Builder getEDMTChannelNotification(String title,String body)
{
    return new NotificationCompat.Builder(getApplicationContext(),EDMT_CHANNEL_ID)
            .setContentText(body)
            .setContentTitle(title)
            .setSmallIcon(R.mipmap.ic_launcher_round)
            .setAutoCancel(true);
    }
}

Utwórz przycisk w pliku xml działania, a następnie W głównym działaniu

protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    helper=new NotificationHelper(this);

    btnSend=(Button)findViewById(R.id.btnSend);

    btnSend.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            String title="Title";
            String content="Content";
            Notification.Builder builder=helper.getEDMTChannelNotification(title,content);
            helper.getManager().notify(new Random().nextInt(),builder.build());
        }
    });

}

Następnie uruchom swój projekt

CodMania
źródło
0

Musisz utworzyć kanał powiadomień dla poziomu API powyżej 26 (oreo).

`NotificationChannel channel = new NotificationChannel(STRING_ID,CHANNEL_NAME,NotificationManager.IMPORTANCE_HIGH);

STRING_ID = identyfikator kanału string string jest taki sam jak w Notification.Builder jak ten

`Notification notification = new Notification.Builder(this,STRING_ID)
            .setSmallIcon(android.R.drawable.ic_menu_help)
            .setContentTitle("Hello Notification")
            .setContentText("It is Working")
            .setContentIntent(pendingIntent)
            .build();`

Identyfikator kanału w powiadomieniu i w powiadomieniu powinien być taki sam Cały kod wygląda tak ... '

@RequiresApi(api = Build.VERSION_CODES.O)
  private void callNotification2() {

    Intent intent = new Intent(getApplicationContext(),MainActivity.class);
    PendingIntent pendingIntent = PendingIntent.getActivity(this,11, 
    intent,PendingIntent.FLAG_UPDATE_CURRENT);
    Notification notification = new Notification.Builder(this,"22")
            .setSmallIcon(android.R.drawable.ic_menu_help)
            .setContentTitle("Hello Notification")
            .setContentText("It is Working")
            .setContentIntent(pendingIntent)
            .build();
    NotificationChannel channel = new 
    NotificationChannel("22","newName",NotificationManager.IMPORTANCE_HIGH);
    NotificationManager manager = (NotificationManager) 
    getSystemService(NOTIFICATION_SERVICE);
    manager.createNotificationChannel(channel);
    manager.notify(11,notification);

    }'
Ajay Singh
źródło
0

Przede wszystkim, jeśli nie wiesz, z Androida Oreo, tj. Interfejsu API na poziomie 26, obowiązkowe jest, aby powiadomienia były przesyłane ponownie z kanałem.

W takim przypadku wiele samouczków może Cię pomylić, ponieważ pokazują one inny przykład powiadomienia powyżej oreo i poniżej.

Oto wspólny kod, który działa zarówno na oreo powyżej, jak i poniżej:

String CHANNEL_ID = "MESSAGE";
String CHANNEL_NAME = "MESSAGE";

NotificationManagerCompat manager = NotificationManagerCompat.from(MainActivity.this);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    NotificationChannel channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME,
    NotificationManager.IMPORTANCE_DEFAULT);
    manager.createNotificationChannel(channel);
}

Notification notification = new NotificationCompat.Builder(MainActivity.this,CHANNEL_ID)
        .setSmallIcon(R.drawable.ic_android_black_24dp)
        .setContentTitle(TitleTB.getText().toString())
        .setContentText(MessageTB.getText().toString())
        .build();
manager.notify(getRandomNumber(), notification); // In case you pass a number instead of getRandoNumber() then the new notification will override old one and you wont have more then one notification so to do so u need to pass unique number every time so here is how we can do it by "getRandoNumber()"
private static int getRandomNumber() {
    Date dd= new Date();
    SimpleDateFormat ft =new SimpleDateFormat ("mmssSS");
    String s=ft.format(dd);
    return Integer.parseInt(s);
}

Samouczek wideo: WIDEO YOUTUBE

Jeśli chcesz pobrać to demo: GitHub Link

Vaibhav Mojidra
źródło
-1
    NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, "CHANNEL_ID")
            ........

    NotificationManager mNotificationManager =
            (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        CharSequence name = "Hello";// The user-visible name of the channel.
        int importance = NotificationManager.IMPORTANCE_HIGH;
        NotificationChannel mChannel = new NotificationChannel(CHANNEL_ID, name, importance);
        mNotificationManager.createNotificationChannel(mChannel);
    }
    mNotificationManager.notify(notificationId, notificationBuilder.build());
Pradeep Kumar S.
źródło