Displaying Local Notifications and Action Buttons in Android

Course: Android App Development

Topic: Displaying Local Notifications and Action Buttons

Course Link: Android App Development Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction to Local Notifications

Local notifications are messages generated directly by an Android application and displayed outside its main user interface. They allow an app to inform users about reminders, completed downloads, pending tasks, scheduled events, and other important updates.

Notifications generally appear in the device's notification drawer and may also appear on the lock screen or as a heads-up notification, depending on system settings, channel importance, and user preferences.

Action buttons make notifications interactive. Instead of opening the application for every operation, a user can tap a button to complete a quick task such as marking a reminder as completed, snoozing an alert, or dismissing a pending action.

For example, a task management app might display a notification saying “Submit your assignment today” with buttons such as “Done” and “Snooze”. These buttons can trigger application logic without requiring the user to navigate through several screens.

2. Learning Objectives

• Understand local notifications and their purpose.
• Learn the components of an Android notification.
• Create and manage notification channels.
• Request notification permission on Android 13 and later.
• Display notifications using NotificationCompat.
• Open a specific screen when a notification is tapped.
• Add action buttons using PendingIntent.
• Handle notification actions with BroadcastReceiver.
• Update, cancel, and group notifications.
• Test notification behavior across Android versions.
• Build a reminder application with interactive notifications.

3. What Is a Local Notification?

A local notification is generated by the application on the device rather than being delivered as a remote push message from a server. It can be triggered by a user action, a scheduled reminder, a background operation, or an application event.

Examples of Local Notifications

• A study app reminds a student to revise a chapter.
• A task manager notifies the user that a task is due.
• A music app displays playback controls.
• A download manager reports that a file has finished downloading.
• A fitness app displays a scheduled activity reminder.
• A shopping app reminds a user about a locally saved shopping task.

Local Notifications vs Push Notifications

4. Important Components of an Android Notification

5. Adding Notification Permission

Starting with Android 13, API level 33, applications generally need the runtime notification permission to display ordinary notifications. The application must declare the permission in its manifest and request it at runtime where applicable.

AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-permission
        android:name="android.permission.POST_NOTIFICATIONS" />

    <application
        android:allowBackup="true"
        android:label="Reminder App"
        android:supportsRtl="true">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Important: Declaring the permission does not grant it. On Android 13 and later, request it at runtime when the user understands why notifications are useful. On earlier Android versions, ordinary notifications do not use this runtime permission, although users can still disable notifications through system settings.

6. Requesting Notification Permission in Kotlin

The Activity Result API provides a lifecycle-aware way to request notification permission. The following example requests permission on Android 13 and later.

import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {

    private val notificationPermissionLauncher =
        registerForActivityResult(
            ActivityResultContracts.RequestPermission()
        ) { isGranted ->
            if (isGranted) {
                Toast.makeText(
                    this,
                    "Notifications enabled",
                    Toast.LENGTH_SHORT
                ).show()
            } else {
                Toast.makeText(
                    this,
                    "Notifications are not enabled",
                    Toast.LENGTH_LONG
                ).show()
            }
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Set up the activity layout here.
    }

    private fun requestNotificationPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            val permission = Manifest.permission.POST_NOTIFICATIONS

            if (ContextCompat.checkSelfPermission(
                    this,
                    permission
                ) != PackageManager.PERMISSION_GRANTED
            ) {
                notificationPermissionLauncher.launch(permission)
            }
        }
    }
}

Call requestNotificationPermission() from an appropriate user action, such as when the user enables reminders. If permission is denied, explain the impact and allow the user to continue using unrelated application features.

7. Creating a Notification Channel

Notification channels were introduced in Android 8.0, API level 26. Every notification posted on Android 8.0 and later must belong to a channel. Users can configure the behavior of each channel through system settings.

For example, a reminder application might use separate channels for daily reminders, task updates, and important alerts.

import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build

private const val REMINDER_CHANNEL_ID = "reminder_channel"

fun createNotificationChannel(context: Context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channel = NotificationChannel(
            REMINDER_CHANNEL_ID,
            "Task Reminders",
            NotificationManager.IMPORTANCE_DEFAULT
        ).apply {
            description = "Notifications for scheduled task reminders"
        }

        val manager = context.getSystemService(
            Context.NOTIFICATION_SERVICE
        ) as NotificationManager

        manager.createNotificationChannel(channel)
    }
}

Call createNotificationChannel(this) during application setup, for example in the Activity's onCreate() method. Creating an existing channel with the same ID is safe, but users control many channel settings after creation. Changing the importance in code does not override user choices for an existing channel.

8. Creating a Basic Local Notification

AndroidX's NotificationCompat.Builder provides a compatibility-friendly API for creating notifications across Android versions.

First, add the AndroidX Core library if it is not already available through your project's dependencies:

dependencies {
    implementation("androidx.core:core-ktx:1.17.0")
}

The version shown is an example. Use a stable version compatible with your Android Gradle Plugin and project configuration.

Basic Notification Code

import android.app.PendingIntent
import android.content.Intent
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat

private const val NOTIFICATION_ID = 1001

fun showReminderNotification() {
    val intent = Intent(this, MainActivity::class.java)

    val pendingIntent = PendingIntent.getActivity(
        this,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT or
            PendingIntent.FLAG_IMMUTABLE
    )

    val notification = NotificationCompat.Builder(
        this,
        REMINDER_CHANNEL_ID
    )
        .setSmallIcon(R.drawable.ic_notification)
        .setContentTitle("Study Reminder")
        .setContentText("It's time to revise today's lesson.")
        .setContentIntent(pendingIntent)
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setAutoCancel(true)
        .build()

    NotificationManagerCompat.from(this)
        .notify(NOTIFICATION_ID, notification)
}

Icon requirement: Replace R.drawable.ic_notification with a valid small notification icon in your project's drawable resources. Notification icons should be designed for Android's notification system and should not depend on a full-color launcher icon.

On Android 13 and later, call this function only when notification permission is granted. Otherwise, the notification may not be displayed and the system may report a permission-related security exception.

9. Understanding PendingIntent

A PendingIntent is a token that allows the Android system or another application component to execute a predefined operation on behalf of your application later. Notifications use PendingIntent objects to respond to taps and action buttons.

For modern Android development, choose the PendingIntent type that matches the operation. Use explicit intents for internal application components, select appropriate request codes, and use immutable PendingIntents unless mutability is specifically required.

10. Opening a Screen When a Notification Is Tapped

The notification's content intent defines the default action when the user taps the notification body. For example, it can open a task details screen.

val detailIntent = Intent(
    this,
    TaskDetailsActivity::class.java
).apply {
    putExtra("TASK_ID", 101)
}

val detailPendingIntent = PendingIntent.getActivity(
    this,
    101,
    detailIntent,
    PendingIntent.FLAG_UPDATE_CURRENT or
        PendingIntent.FLAG_IMMUTABLE
)

val notification = NotificationCompat.Builder(
    this,
    REMINDER_CHANNEL_ID
)
    .setSmallIcon(R.drawable.ic_notification)
    .setContentTitle("Task Due")
    .setContentText("Tap to view task details.")
    .setContentIntent(detailPendingIntent)
    .setAutoCancel(true)
    .build()

In TaskDetailsActivity, retrieve the task identifier from the Intent and load the corresponding task. Avoid placing sensitive information directly in notification text because notifications may be visible on the lock screen.

11. What Are Notification Action Buttons?

Action buttons provide quick operations directly from a notification. They are particularly useful when the user needs to perform a simple action without opening the main application screen.

Examples include:

• Done: Mark a task as completed.
• Snooze: Remind the user again later.
• Dismiss: Clear an alert or acknowledge an event.
• Reply: Respond to a message from the notification.
• Open: Navigate to a related screen when appropriate.

Expanded notifications can display up to three action buttons, depending on system presentation. Action buttons should provide useful operations and should not merely duplicate the default action of tapping the notification body.

12. Handling Action Buttons with BroadcastReceiver

A BroadcastReceiver can handle quick notification actions without opening an Activity. The following example shows how a task reminder can be marked as completed.

Step 1: Create a BroadcastReceiver

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import androidx.core.app.NotificationManagerCompat

class ReminderActionReceiver : BroadcastReceiver() {

    override fun onReceive(
        context: Context,
        intent: Intent
    ) {
        val notificationId =
            intent.getIntExtra("NOTIFICATION_ID", -1)

        when (intent.action) {
            "ACTION_MARK_DONE" -> {
                val taskId = intent.getIntExtra("TASK_ID", -1)

                // Update the task in a repository or database.
                // Keep this operation small or delegate longer work
                // to an appropriate background mechanism.

                if (notificationId != -1) {
                    NotificationManagerCompat.from(context)
                        .cancel(notificationId)
                }
            }
        }
    }
}

For this simplified example, the database update is represented by a comment. A real application should update persistent task state through a repository or database. If the operation is lengthy, use an appropriate asynchronous or persistent background mechanism rather than performing substantial work inside onReceive().

Step 2: Register the Receiver

<application ...>
    <receiver
        android:name=".ReminderActionReceiver"
        android:enabled="true"
        android:exported="false" />
</application>

The receiver is not exported because it is intended for internal application actions. Explicit PendingIntents should target the receiver directly.

Step 3: Add the Action Button

val notificationId = 1001
val taskId = 101

val doneIntent = Intent(
    this,
    ReminderActionReceiver::class.java
).apply {
    action = "ACTION_MARK_DONE"
    putExtra("TASK_ID", taskId)
    putExtra("NOTIFICATION_ID", notificationId)
}

val donePendingIntent = PendingIntent.getBroadcast(
    this,
    taskId,
    doneIntent,
    PendingIntent.FLAG_UPDATE_CURRENT or
        PendingIntent.FLAG_IMMUTABLE
)

val notification = NotificationCompat.Builder(
    this,
    REMINDER_CHANNEL_ID
)
    .setSmallIcon(R.drawable.ic_notification)
    .setContentTitle("Assignment Reminder")
    .setContentText("Complete your assignment today.")
    .addAction(
        R.drawable.ic_done,
        "Done",
        donePendingIntent
    )
    .setAutoCancel(true)
    .build()

Replace R.drawable.ic_done with an appropriate drawable resource. The addAction() method associates the button with the PendingIntent that executes when the user taps it.

13. Adding a Snooze Action

A snooze action allows a user to postpone a reminder. In a complete application, tapping Snooze should update the reminder's next scheduled time and arrange for a new notification to be displayed later.

val snoozeIntent = Intent(
    this,
    ReminderActionReceiver::class.java
).apply {
    action = "ACTION_SNOOZE"
    putExtra("TASK_ID", taskId)
    putExtra("NOTIFICATION_ID", notificationId)
}

val snoozePendingIntent = PendingIntent.getBroadcast(
    this,
    taskId + 10000,
    snoozeIntent,
    PendingIntent.FLAG_UPDATE_CURRENT or
        PendingIntent.FLAG_IMMUTABLE
)

val notification = NotificationCompat.Builder(
    this,
    REMINDER_CHANNEL_ID
)
    .setSmallIcon(R.drawable.ic_notification)
    .setContentTitle("Study Reminder")
    .setContentText("Ready to study?")
    .addAction(
        R.drawable.ic_snooze,
        "Snooze",
        snoozePendingIntent
    )
    .build()

Add handling for ACTION_SNOOZE inside the receiver. For reliable deferred reminders, store the new reminder time persistently and use a suitable scheduling API. WorkManager is appropriate for deferrable work, but it does not guarantee an exact execution time. If the product truly requires an exact alarm, evaluate Android's exact-alarm APIs and their restrictions.

14. Handling Notification Permission Denial

If the user denies notification permission, the application should respect that choice. Do not repeatedly display permission prompts or assume notifications are enabled just because the application created a channel.

• Explain which useful features will be unavailable without notifications.
• Keep core application features usable.
• Provide in-app reminders or status messages as alternatives where practical.
• Offer a user-initiated route to notification settings if the user wants to enable notifications later.
• Check notification permission and app-level notification settings before attempting to display a notification.

Notification permission is only one possible reason a notification may not appear. The user can also disable the app's notifications or a specific channel through system settings.

15. Updating an Existing Notification

To update a notification, call notify() again with the same notification ID. The system replaces the existing notification with the updated content.

NotificationManagerCompat.from(this).notify(
    1001,
    updatedNotification
)

This is useful for updating download status, reminder details, or progress information. Keep notification IDs stable when you intend to update a specific notification. Use distinct IDs when multiple independent notifications must remain visible.

16. Cancelling Notifications

Applications can remove a notification when its task is complete or when the notification is no longer relevant.

import androidx.core.app.NotificationManagerCompat

// Cancel one notification.
NotificationManagerCompat.from(this)
    .cancel(1001)

// Cancel all notifications posted by the app.
NotificationManagerCompat.from(this)
    .cancelAll()

Use cancelAll() carefully because it removes every notification posted by the app, including notifications unrelated to the current screen or workflow.

17. Notification Channels and Importance

Notification channel importance influences how notifications are presented on Android 8.0 and later. The user can change the channel's settings, so the application should not assume that the requested importance always determines the final behavior.

Choose channel importance based on the actual importance of the content. Avoid using high importance for routine messages simply to make them more noticeable.

18. Notification Styles

Android provides different notification styles for presenting different kinds of information. Use a style that matches the content rather than placing large amounts of text into a basic notification.

Example: BigTextStyle

val notification = NotificationCompat.Builder(
    this,
    REMINDER_CHANNEL_ID
)
    .setSmallIcon(R.drawable.ic_notification)
    .setContentTitle("Weekly Study Plan")
    .setContentText("Your study plan is ready.")
    .setStyle(
        NotificationCompat.BigTextStyle()
            .bigText(
                "Review Kotlin fundamentals, practice Android " +
                "layouts, and complete the weekly coding exercise."
            )
    )
    .build()

19. Grouping Related Notifications

When an application posts multiple notifications, grouping can help keep the notification drawer organized. For example, a task manager can group multiple reminders under a common summary.

private const val TASK_GROUP_KEY = "task_reminders"

val notification = NotificationCompat.Builder(
    this,
    REMINDER_CHANNEL_ID
)
    .setSmallIcon(R.drawable.ic_notification)
    .setContentTitle("Task Due")
    .setContentText("One of your tasks is due today.")
    .setGroup(TASK_GROUP_KEY)
    .build()

For a complete notification group, create a summary notification with the same group key. Group behavior and presentation can vary by Android version and device interface.

20. Scheduling Local Reminders

Displaying a notification and scheduling the time when it should appear are separate tasks. A notification builder creates the notification content, while a scheduling mechanism determines when the application should post it.

For reminders that can be delivered flexibly, WorkManager may be appropriate. For exact-time alarms, consider AlarmManager and review the platform's exact-alarm permissions and restrictions. Choose based on the application's actual timing requirements.

Example Scheduling Flow

1. The user creates a reminder and selects a time.
2. The application stores the reminder details in persistent storage.
3. The application schedules the appropriate background operation or alarm.
4. When the operation executes, the app checks the reminder state.
5. The application posts a local notification if it is still relevant.
6. The user selects an action such as Done or Snooze.
7. The app updates the reminder state and cancels or reschedules the notification as needed.

Do not assume that ordinary WorkManager tasks execute at an exact minute. Exact alarms also have platform restrictions, and behavior must be tested across the Android versions supported by the application.

21. Security and Privacy Best Practices

• Do not place passwords, authentication tokens, or other secrets in notification text or Intent extras.
• Use explicit PendingIntents for internal activities and receivers.
• Use FLAG_IMMUTABLE unless the PendingIntent genuinely needs to be mutable.
• Use appropriate request codes and Intent identity to prevent one notification's action from unexpectedly replacing another's.
• Validate task IDs and other data before changing persistent state.
• Keep internal receivers non-exported unless external access is intentionally required.
• Consider lock-screen visibility before displaying private messages or account information.
• Respect user notification settings and permission choices.
• Make action handlers safe to execute more than once where practical.

22. Common Errors and Troubleshooting

23. Practical Project: Task Reminder Application

Project objective: Build a simple Android reminder application that displays local notifications and supports quick actions.

Functional Requirements

1. Create a screen for entering a task title and reminder details.
2. Request notification permission on Android 13 and later.
3. Create a notification channel for task reminders.
4. Display a notification with a title and description.
5. Open the task details screen when the notification body is tapped.
6. Add a Done action that updates the task's completion status.
7. Add a Snooze action that updates the reminder schedule.
8. Persist task data in a local database.
9. Cancel or update notifications when task status changes.
10. Handle denied permission and disabled channel settings gracefully.

Suggested Application Flow

User Creates a Task
        |
        v
Save Task to Local Database
        |
        v
Schedule Reminder
        |
        v
Post Local Notification
        |
        +----------------------+
        |                      |
        v                      v
      Done                   Snooze
        |                      |
        v                      v
Update Task Status      Update Reminder Time
        |                      |
        v                      v
Cancel Notification     Schedule Again

Expected Outcome

The application should display reminders when permitted, open the relevant screen when the notification is tapped, and execute quick actions through their PendingIntents. It should preserve task data and respond gracefully when notifications are disabled.

24. Testing Checklist

• Test notification display on Android versions before Android 8.0 and on Android 8.0 or later.
• Test Android 13 and later with notification permission granted.
• Test notification permission denied.
• Disable the notification channel in system settings and verify the app remains usable.
• Tap the notification body and verify the correct screen opens.
• Tap each action button and confirm the correct operation executes.
• Test multiple notifications with different IDs.
• Test updating and cancelling notifications.
• Verify that different reminders do not overwrite each other's PendingIntents.
• Test the lock-screen presentation and privacy of notification content.
• Test scheduling and snoozing across device restarts where relevant.
• Test reminder behavior under battery-saving conditions.

25. Interview Questions and Answers

Q1. What is a local notification in Android?

A local notification is generated by an application on the device to communicate reminders, updates, or events to the user outside the main app interface.

Q2. What is a notification channel?

A notification channel groups notifications into a category whose behavior users can manage in system settings. Channels are required for notifications on Android 8.0 and later.

Q3. What is PendingIntent?

PendingIntent is a token that allows the system to execute a predefined operation on behalf of an application, such as opening an Activity or sending a broadcast.

Q4. Why is POST_NOTIFICATIONS required?

On Android 13 and later, apps generally need this runtime permission to display ordinary notifications, unless a specific exemption applies.

Q5. How do notification action buttons work?

Action buttons are configured with PendingIntent objects. When a user taps a button, Android executes the associated operation, such as broadcasting an action to a receiver.

Q6. How can an app update an existing notification?

Call the notification manager's notify() method again using the same notification ID and the updated notification object.

Q7. What is the difference between notification priority and channel importance?

Priority is used by compatibility APIs for older Android behavior, while channel importance controls notification behavior on Android 8.0 and later. User settings can affect the final presentation.

Q8. How can an app cancel a notification?

Use NotificationManagerCompat.cancel() with the notification ID or cancelAll() to remove all notifications posted by the app.

Q9. Can action buttons work without opening an Activity?

Yes. A button can use a broadcast PendingIntent to invoke a BroadcastReceiver, allowing the application to perform a quick operation without opening a screen.

Q10. Should WorkManager be used for every scheduled notification?

No. WorkManager suits deferrable work, while AlarmManager may be more appropriate when a genuinely exact alarm is required and platform rules permit it.

26. Quick Revision Checklist

• Local notifications communicate device-side events and reminders.
• Use NotificationCompat.Builder to create notification content.
• Create notification channels on Android 8.0 and later.
• Request POST_NOTIFICATIONS on Android 13 and later where applicable.
• Use a valid small icon and a stable notification ID.
• Use a content PendingIntent to open the relevant screen.
• Use action PendingIntents for Done, Snooze, and other quick operations.
• Use BroadcastReceiver for short, appropriate action handling.
• Update or cancel notifications using their IDs.
• Respect user settings, privacy, and permission decisions.
• Use the scheduling API that matches the timing requirements.

27. Official Learning Resources

• Notifications Overview — Android Developers
• Create a Notification — Android Developers
• Notification Runtime Permission — Android Developers
• Schedule Alarms — Android Developers
• Persistent Background Work — Android Developers

Conclusion

Local notifications help Android applications deliver timely updates, reminders, and task information. Notification action buttons make these messages more useful by allowing users to perform quick operations without opening the application.

By creating notification channels, requesting permission appropriately, configuring PendingIntent objects, handling actions safely, and respecting device settings, developers can build notification experiences that are reliable, secure, and user-friendly. Testing across Android versions is essential because notification permissions, channel behavior, and background scheduling differ across platform releases.

Explore the course: Android App Development Training

Book a demo: Register for a Course Demo

Visit JustAcademy: JustAcademy Official Website