Android Notification

The CHANNEL_ID and NOTIFICATION_ID are two important components in the notification system of Android, each serving a specific function.

1. `CHANNEL_ID` (Notification Channel ID)

Purpose: The CHANNEL_ID is a unique string identifier used to group and manage notifications. Starting from Android 8.0 (Oreo, API level 26), notifications must be assigned to a notification channel. Notification channels allow users to control notification settings (like sound, vibration, and importance) for different types of notifications.
Function:
- Each notification channel is identified by a CHANNEL_ID.
- Notifications with the same CHANNEL_ID will belong to the same channel and inherit its behavior/settings.
- Channels help the user manage preferences for specific notification types, like enabling/disabling specific kinds of notifications.
Usage:
- When you create a notification for Android 8.0 and above, you need to specify a CHANNEL_ID for it. If the channel doesn’t exist, you must create it before sending the notification.
Example in the code:
```
// Unique string identifier for the channel
private static final String CHANNEL_ID = "connectivity_channel";
```
This line defines a channel called "connectivity_channel". If it doesn’t exist, the app will create it and assign notifications to this channel.

In the code:
```
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Connectivity Status", NotificationManager.IMPORTANCE_DEFAULT);
notificationManager.createNotificationChannel(channel);
```
This creates a channel named "Connectivity Status" with default importance and associates it with CHANNEL_ID. Notifications with this ID will behave according to the settings of this channel.

2. `NOTIFICATION_ID` (Notification Identifier)

Purpose: The NOTIFICATION_ID is an integer identifier that uniquely distinguishes one notification from another in your app. It allows the system to update or dismiss specific notifications.
Function:
- Each time you create a notification, you pass a NOTIFICATION_ID to the NotificationManager.notify() method.
- If you send another notification with the same NOTIFICATION_ID, it updates the previous notification rather than creating a new one.
- If you want multiple notifications to show up individually, each notification should have a different NOTIFICATION_ID.
- You can also use this ID to cancel or dismiss the notification programmatically by calling NotificationManager.cancel(NOTIFICATION_ID).
Usage:
- In the example, NOTIFICATION_ID is used to identify the connectivity status notification.
Example in the code:
```
// Unique ID for the notification
private static final int NOTIFICATION_ID = 1;
```
This sets the notification ID to 1. Whenever the network state changes, the same NOTIFICATION_ID is used to update the existing notification rather than creating a new one each time.
```
notificationManager.notify(NOTIFICATION_ID, builder.build());
```
This line tells the system to either display or update the notification associated with NOTIFICATION_ID. If the ID 1 is already in use (an active notification), it will update the existing notification; otherwise, it will create a new notification.

Summary:

CHANNEL_ID: A string identifier for notification channels. It groups notifications into categories (channels), which users can control.
NOTIFICATION_ID: A unique integer identifier for individual notifications. It allows you to update or remove a specific notification by referencing its ID.

The CHANNEL_ID in Android becomes useful when you need to manage different types of notifications with varying importance, behavior, or user preferences, especially starting from Android 8.0 (Oreo, API level 26), where Notification Channels were introduced.

Notification Channels allow users to customize the behavior of different categories of notifications, such as turning them on/off, setting the priority, or changing the notification sound for each channel. Without notification channels, users wouldn't have this granular control.

Examples and Solutions

Example 1: A Messaging App with Different Notification Types

Scenario: Imagine you have a messaging app that generates several types of notifications:

New Message Notifications – High priority, users want to be alerted immediately.
Friend Request Notifications – Medium priority, users want to know but it's not urgent.
Promotional or System Updates – Low priority, users might not want these interrupting them.

Problem Without CHANNEL_ID:

All notifications would behave the same way (e.g., same sound, vibration, or visibility), and users wouldn’t have the ability to control each notification type individually.
If users want to mute promotional notifications but still receive message alerts, they can’t do that.

Solution with CHANNEL_ID: You can create three separate notification channels, each with its own behavior. Users can then adjust notification settings for each channel individually.

Implementing Notification Channels

Create Multiple Channels with Different IDs:

private static final String CHANNEL_ID_MESSAGES = "messages_channel";
private static final String CHANNEL_ID_FRIEND_REQUESTS = "friend_requests_channel";
private static final String CHANNEL_ID_PROMOTIONS = "promotions_channel";

public void createNotificationChannels(Context context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel messageChannel = new NotificationChannel(
                CHANNEL_ID_MESSAGES,
                "Messages",
                NotificationManager.IMPORTANCE_HIGH // High importance for new messages
        );
        messageChannel.setDescription("Notifications for new messages.");

        NotificationChannel friendRequestChannel = new NotificationChannel(
                CHANNEL_ID_FRIEND_REQUESTS,
                "Friend Requests",
                NotificationManager.IMPORTANCE_DEFAULT // Medium importance for friend requests
        );
        friendRequestChannel.setDescription("Notifications for new friend requests.");

        NotificationChannel promotionsChannel = new NotificationChannel(
                CHANNEL_ID_PROMOTIONS,
                "Promotions",
                NotificationManager.IMPORTANCE_LOW // Low importance for promotions
        );
        promotionsChannel.setDescription("Notifications for promotional offers and updates.");

        // Register the channels with the system
        NotificationManager manager = context.getSystemService(NotificationManager.class);
        manager.createNotificationChannel(messageChannel);
        manager.createNotificationChannel(friendRequestChannel);
        manager.createNotificationChannel(promotionsChannel);
    }
}

Send Notifications with Corresponding CHANNEL_ID:

For New Message Notifications:

NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID_MESSAGES)
        .setSmallIcon(R.drawable.ic_message)
        .setContentTitle("New Message")
        .setContentText("You have a new message.")
        .setPriority(NotificationCompat.PRIORITY_HIGH);

notificationManager.notify(1, builder.build());

For Friend Request Notifications:

NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID_FRIEND_REQUESTS)
        .setSmallIcon(R.drawable.ic_friend_request)
        .setContentTitle("Friend Request")
        .setContentText("You have a new friend request.")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT);

notificationManager.notify(2, builder.build());

For Promotional Notifications:

NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID_PROMOTIONS)
        .setSmallIcon(R.drawable.ic_promotion)
        .setContentTitle("New Promotion")
        .setContentText("Check out our latest offers.")
        .setPriority(NotificationCompat.PRIORITY_LOW);

notificationManager.notify(3, builder.build());

Benefits:

User Control: Users can disable or lower the importance of Promotional Notifications while keeping New Message Notifications at a high priority with sound and vibration.
Granular Notification Management: Instead of all notifications being treated the same way, users can fine-tune how they want to be notified for each category.
Improved User Experience: Users won’t get overwhelmed with unnecessary notifications, and important notifications (like new messages) will always get their attention.

Complete Code

NotificationHelper.java

import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.content.Context;
import android.os.Build;
import androidx.core.app.NotificationCompat;

public class NotificationHelper {

    private static final String CHANNEL_ID_MESSAGES = "messages_channel";
    private static final String CHANNEL_ID_FRIEND_REQUESTS = "friend_requests_channel";
    private static final String CHANNEL_ID_PROMOTIONS = "promotions_channel";

    private static final int NOTIFICATION_ID_MESSAGE = 1;
    private static final int NOTIFICATION_ID_FRIEND_REQUEST = 2;
    private static final int NOTIFICATION_ID_PROMOTION = 3;

    private Context context;
    private NotificationManager notificationManager;

    public NotificationHelper(Context context) {
        this.context = context;
        notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

        // Create notification channels
        createNotificationChannels();
    }

    private void createNotificationChannels() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Create the Messages channel
            NotificationChannel messageChannel = new NotificationChannel(
                    CHANNEL_ID_MESSAGES,
                    "Messages",
                    NotificationManager.IMPORTANCE_HIGH
            );
            messageChannel.setDescription("Notifications for new messages");

            // Create the Friend Requests channel
            NotificationChannel friendRequestChannel = new NotificationChannel(
                    CHANNEL_ID_FRIEND_REQUESTS,
                    "Friend Requests",
                    NotificationManager.IMPORTANCE_DEFAULT
            );
            friendRequestChannel.setDescription("Notifications for new friend requests");

            // Create the Promotions channel
            NotificationChannel promotionsChannel = new NotificationChannel(
                    CHANNEL_ID_PROMOTIONS,
                    "Promotions",
                    NotificationManager.IMPORTANCE_LOW
            );
            promotionsChannel.setDescription("Notifications for promotions and offers");

            // Register the channels with the system
            notificationManager.createNotificationChannel(messageChannel);
            notificationManager.createNotificationChannel(friendRequestChannel);
            notificationManager.createNotificationChannel(promotionsChannel);
        }
    }

    // Send notification for new messages
    public void sendNewMessageNotification(String messageText) {
        Notification notification = new NotificationCompat.Builder(context, CHANNEL_ID_MESSAGES)
                .setSmallIcon(R.drawable.ic_message) // Replace with your own icon
                .setContentTitle("New Message")
                .setContentText(messageText)
                .setPriority(NotificationCompat.PRIORITY_HIGH)
                .setAutoCancel(true)
                .build();

        notificationManager.notify(NOTIFICATION_ID_MESSAGE, notification);
    }

    // Send notification for friend requests
    public void sendFriendRequestNotification(String friendName) {
        Notification notification = new NotificationCompat.Builder(context, CHANNEL_ID_FRIEND_REQUESTS)
                .setSmallIcon(R.drawable.ic_friend_request) // Replace with your own icon
                .setContentTitle("Friend Request")
                .setContentText(friendName + " sent you a friend request")
                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                .setAutoCancel(true)
                .build();

        notificationManager.notify(NOTIFICATION_ID_FRIEND_REQUEST, notification);
    }

    // Send notification for promotions
    public void sendPromotionNotification(String promotionText) {
        Notification notification = new NotificationCompat.Builder(context, CHANNEL_ID_PROMOTIONS)
                .setSmallIcon(R.drawable.ic_promotion) // Replace with your own icon
                .setContentTitle("New Promotion")
                .setContentText(promotionText)
                .setPriority(NotificationCompat.PRIORITY_LOW)
                .setAutoCancel(true)
                .build();

        notificationManager.notify(NOTIFICATION_ID_PROMOTION, notification);
    }
}

`MainActivity.java`

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private NotificationHelper notificationHelper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Create NotificationHelper instance
        notificationHelper = new NotificationHelper(this);

        // Trigger notifications as needed
        notificationHelper.sendNewMessageNotification("You have a new message from John");
        notificationHelper.sendFriendRequestNotification("Alice");
        notificationHelper.sendPromotionNotification("Get 20% off on your next purchase!");
    }
}

Benefits of This Structure

Centralization: Moving the channel creation logic into the NotificationHelper keeps all notification-related code in one place, making it easier to manage.
Cleaner MainActivity: The MainActivity is now cleaner and focused on UI and activity management rather than handling notifications.
Initialization: The notification channels are automatically created when the NotificationHelper is instantiated, ensuring that the channels are ready for use when you need to send notifications.

This structure is more maintainable and adheres to good coding practices.

Maulana Firdaus

Cari Blog Ini