Bdtjtk

In addition to this answer, you need to create the notification channel before it can be used.

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

  }

Also you need to use channels only if your targetSdkVersion is 26 or higher.

If you are using NotificationCompat.Builder, you also need to update to the beta version of the support library: https://developer.android.com/topic/libraries/support-library/revisions.html#26-0-0-beta2 (to be able to call setChannelId on the compat builder).

Be careful as this library update raises minSdkLevel to 14.

Here i post some quick solution function with intent handling

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

}

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;

    }

}

Android Notification Demo App for Android O as well as lower API versions.
Here is best demo app on GitHub-Demo 1 and GitHub-Demo 2.

Try this Code :

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;



        }



    }



}

If you can't get the push notification in 26+ SDK version?

your solution is here:

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 notificationBuilder = new NotificationCompat.Builder(context, channel_id)

-> Here you will get push notification using channel_id in your device which is consist 26+ SDK version.

-> Because, the NotificationCompat.Builder(context) is deprecated method now you will use an updated version which is having two parameters one is context, other is channel_id.

-> NotificationCompat.Builder(context, channel_id) updated method. try it.

-> In 26+ SDK version of device you will create channel_id every time.

This is bug in firebase api version 11.8.0, So if you reduce API version you will not face this issue.

Here's how you do it

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

}

Read full tutorial at => https://developer.android.com/training/notify-user/build-notification

For anyone struggling with this after trying the above solutions, ensure that the channel id used when creating the notification channel is identical to the channel id you set in the Notification builder.

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)

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

    }

In android Oreo,notification app is done by using channels and NotificationHelper class.It should have a channel id and channel name.

First u have to create a NotificationHelper Class

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 Notification.Builder getEDMTChannelNotification(String title,String body)

{

    return new Notification.Builder(getApplicationContext(),EDMT_CHANNEL_ID)

            .setContentText(body)

            .setContentTitle(title)

            .setSmallIcon(R.mipmap.ic_launcher_round)

            .setAutoCancel(true);

}

}

Create a button in activity xml file,then In the main activity

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

        }

    });



}

Then run ur project

Following method will show Notification, having big text and freeze enabled( Notification will not get removed even after user swipes ). We need NotificationManager service

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

}

Method to Remove Notifications

public static void removeNotification(Context context){

    NotificationManager notificationManager =

            (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);

    notificationManager.cancelAll();

}

Source Link

NotificationCompat.Builder(Context context)

already deprecated for version greater than or equal android Oreo. You can change implementation into using

NotificationCompat.Builder(Context context, String channelId)

The Notification Channel features is added from Api level 26 (in oreo). the below code is working fine on my side, hope it will help you

 private void sendNotification(Context ctx, String title, int notificationNumber, String message, String subtext, Intent intent) {       

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

        }



    }

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