51. Notifications in Android

Notifications in Android play a crucial role in maintaining user engagement and providing timely information. They are a powerful tool for Android developers, allowing them to communicate with users even when the app is not actively in use. In this section, we'll delve into the intricacies of implementing notifications in Android using Kotlin, exploring various types of notifications, customization options, and best practices.

At its core, a notification is a message that Android displays outside of your app's UI to provide the user with reminders, communication from other people, or other timely information from your app. Users can tap the notification to open your app or take an action directly from the notification.

Creating a Basic Notification

To create a notification, you need to use the NotificationCompat.Builder class. This class helps you to build a notification by setting its various attributes. Here's a basic example:

val builder = NotificationCompat.Builder(this, CHANNEL_ID)
    .setSmallIcon(R.drawable.notification_icon)
    .setContentTitle("My notification")
    .setContentText("Hello World!")
    .setPriority(NotificationCompat.PRIORITY_DEFAULT)

In the example above, CHANNEL_ID is a string unique to your app that the system uses to identify your app's notification channel. The setSmallIcon() method is required, and it specifies the icon that appears in the notification.

The setContentTitle() and setContentText() methods define the title and text content of the notification, respectively. The setPriority() method sets the priority of the notification, which affects how the notification is displayed to the user.

Notification Channels

Starting with Android 8.0 (API level 26), all notifications must be assigned to a channel. A notification channel allows you to group notifications together, making it easier for users to manage them. To create a notification channel, you can use the following code:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    val name = getString(R.string.channel_name)
    val descriptionText = getString(R.string.channel_description)
    val importance = NotificationManager.IMPORTANCE_DEFAULT
    val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
        description = descriptionText
    }
    val notificationManager: NotificationManager =
        getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    notificationManager.createNotificationChannel(channel)
}

Here, we first check if the device is running Android 8.0 or higher. If it is, we create a new NotificationChannel object, specifying the channel ID, name, and importance level. The channel is then registered with the system using the NotificationManager.

Adding Actions to Notifications

Notifications can include actions, allowing users to interact with them without opening the app. For example, a messaging app might allow users to reply to a message directly from the notification. To add an action, use the addAction() method:

val replyIntent = Intent(this, ReplyActivity::class.java)
val replyPendingIntent: PendingIntent =
    PendingIntent.getActivity(this, 0, replyIntent, PendingIntent.FLAG_UPDATE_CURRENT)

val action = NotificationCompat.Action.Builder(R.drawable.reply_icon, "Reply", replyPendingIntent).build()

val builder = NotificationCompat.Builder(this, CHANNEL_ID)
    .setSmallIcon(R.drawable.notification_icon)
    .setContentTitle("New Message")
    .setContentText("You have a new message.")
    .addAction(action)

In this example, we create an Intent that opens ReplyActivity when the action is tapped. We then wrap this intent in a PendingIntent, which is used to execute the action. Finally, we build the action using NotificationCompat.Action.Builder and add it to the notification using addAction().

Customizing Notification Layouts

While the default notification layout is sufficient for many use cases, Android also allows you to create custom notification layouts using a RemoteViews object. This is particularly useful when you need to display more complex information or interactive elements.

To create a custom notification layout, define a layout in XML and inflate it using RemoteViews:

val remoteViews = RemoteViews(packageName, R.layout.custom_notification)

val builder = NotificationCompat.Builder(this, CHANNEL_ID)
    .setSmallIcon(R.drawable.notification_icon)
    .setContent(remoteViews)

In this snippet, R.layout.custom_notification refers to an XML layout resource that defines the custom notification layout. The setContent() method is then used to set this custom layout for the notification.

Handling Notification Interactions

When a user interacts with a notification, such as by tapping it, you typically want to perform some action, like opening a specific activity. This is handled using PendingIntent. Here's how you can set up a notification to open an activity when tapped:

val intent = Intent(this, TargetActivity::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val pendingIntent: PendingIntent = PendingIntent.getActivity(this, 0, intent, 0)

val builder = NotificationCompat.Builder(this, CHANNEL_ID)
    .setSmallIcon(R.drawable.notification_icon)
    .setContentTitle("Notification Title")
    .setContentText("Notification Content")
    .setContentIntent(pendingIntent)
    .setAutoCancel(true)

In this example, we create an Intent that opens TargetActivity. We then wrap this intent in a PendingIntent and set it on the notification using setContentIntent(). The setAutoCancel(true) method ensures that the notification is dismissed when the user taps it.

Best Practices for Notifications

To ensure that your notifications are effective and user-friendly, consider the following best practices:

• Use Clear and Concise Text: Make sure the notification's title and content are clear and concise. Avoid using jargon or unnecessary details.
• Set Appropriate Priority Levels: Use the appropriate priority level for your notifications to ensure they are displayed correctly and do not overwhelm the user.
• Respect User Preferences: Allow users to control which notifications they receive by providing settings within your app.
• Use Notification Channels Wisely: Group similar types of notifications into channels to help users manage them more easily.
• Test on Different Devices: Test your notifications on a variety of devices and OS versions to ensure they work as expected across different environments.

By following these best practices, you can create notifications that provide value to users without being intrusive or overwhelming.

In conclusion, notifications are a powerful feature in Android app development, allowing you to keep users informed and engaged. By understanding how to create, customize, and manage notifications effectively, you can enhance the user experience and improve the overall functionality of your app.

Next page of the Free Ebook:

70Working with Android Sensors

6 minutes