Android AlarmManager Example: Scheduling Tasks with AlarmManager

By the end of this page, you will understand what Android AlarmManager is, when to use it, how to schedule a future task with it, and how a BroadcastReceiver works together with it. You will also see a complete beginner-friendly example and learn common mistakes to avoid.

AlarmManager is an Android system service used to schedule work to happen at a specific time in the future, even if your app is not currently open.

In Android, you often need code to run later rather than immediately. For example:

• show a reminder at 8:00 AM
• trigger a background action after a delay
• schedule repeating behavior
• wake your app to handle time-based events

AlarmManager does not directly run your code. Instead, it usually sends a PendingIntent at the scheduled time. That PendingIntent can:

• start a BroadcastReceiver
• start a service
• launch an activity

A common beginner pattern is:

1. Get the AlarmManager system service
2. Create an Intent
3. Wrap the Intent in a PendingIntent
4. Schedule it using methods like set()
5. Receive the alarm in a BroadcastReceiver

Why this matters:

• Mobile apps often depend on time-based events
• Android may stop or delay background work if you do it incorrectly
• AlarmManager is one of the standard tools for scheduled tasks

Important note: in modern Android, AlarmManager is best for events such as reminders or alarms. For general background work, is often preferred.

Think of AlarmManager like setting an alarm clock for your app.

• AlarmManager is the clock
• Intent is the note telling Android what should happen
• PendingIntent is the sealed instruction Android is allowed to use later
• BroadcastReceiver is the person who hears the alarm and reacts to it

So the process is:

• You set the alarm now
• Android keeps track of the time
• When the time arrives, Android delivers the instruction
• Your receiver runs the code you prepared

Basic syntax

AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

Intent intent = new Intent(this, AlarmReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(
        this,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
);

long triggerAtMillis = System.currentTimeMillis() + 10_000;

alarmManager.set(AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent);

What this does

• getSystemService(Context.ALARM_SERVICE) gets the Android alarm service
• Intent points to AlarmReceiver
• PendingIntent.getBroadcast(...) tells Android to send a broadcast later
• System.currentTimeMillis() + 10_000 means 10 seconds from now
• set(...) schedules the alarm

Beginner-friendly complete example

MainActivity.java

Consider this code:

AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(this, AlarmReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(
        this,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
);
long triggerTime = System.currentTimeMillis() + 5000;
alarmManager.set(AlarmManager.RTC_WAKEUP, triggerTime, pendingIntent);

Here is what happens step by step:

1. getSystemService(Context.ALARM_SERVICE) asks Android for the system alarm scheduler.
2. An Intent is created that targets AlarmReceiver.
3. That intent is wrapped in a PendingIntent so Android can use it later on your app's behalf.
4. System.currentTimeMillis() gets the current time in milliseconds.
5. + 5000 adds 5 seconds.
6. alarmManager.set(...) tells Android to fire the at that future time.

AlarmManager is useful when the timing itself is important.

Common real-world uses

• Reminder apps: trigger a reminder at a specific clock time
• Medication alerts: notify the user at scheduled intervals
• Calendar apps: fire event reminders before meetings
• Wake-up alarms: launch alarm behavior at a chosen time
• Time-based notifications: send a notification later in the day

Example scenarios

• A to-do app reminds users about a task at 6:00 PM
• A prayer time app schedules alerts for each prayer time
• A study app reminds users every evening to review flashcards

If the job is “run this at a meaningful time,” AlarmManager may fit well.

If the job is “run some background work eventually,” WorkManager is usually better.

In real Android projects, developers often use AlarmManager in a few common patterns.

1. Scheduling notifications

A receiver is triggered by AlarmManager, and the receiver creates a notification.

2. Guard clauses

Developers usually check for null and invalid times before scheduling.

if (alarmManager == null) {
    return;
}

if (triggerTime <= System.currentTimeMillis()) {
    return;
}

3. Updating existing alarms

Using the same request code and matching intent lets you replace an existing scheduled alarm.

PendingIntent pendingIntent = PendingIntent.getBroadcast(
        context,
        100,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
);

4. Canceling alarms

Real apps often allow the user to turn reminders off.

alarmManager.cancel(pendingIntent);
pendingIntent.cancel();

5. Exact alarms for precise timing

When exact timing matters, developers may use methods like setExact() instead of .

1. Forgetting to register the BroadcastReceiver

If the receiver is not declared in AndroidManifest.xml, the alarm may not reach it.

Broken example:

<!-- Receiver missing -->

Fix:

<receiver android:name=".AlarmReceiver" />

2. Expecting AlarmManager to directly run activity code

AlarmManager usually triggers a PendingIntent, not a random method call in your activity.

Broken idea:

// AlarmManager does not call this method directly later
myMethod();

Fix: schedule a BroadcastReceiver, service, or activity launch.

3. Using the wrong PendingIntent type

If you want to trigger a broadcast, use getBroadcast().

Broken example:

set() vs setExact()

RTC_WAKEUP vs ELAPSED_REALTIME_WAKEUP

Quick reference

Get the service

AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

Create the target intent

Intent intent = new Intent(this, AlarmReceiver.class);

Wrap it in a pending intent

PendingIntent pendingIntent = PendingIntent.getBroadcast(
        this,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
);

Schedule an alarm

long time = System.currentTimeMillis() + 5000;
alarmManager.set(AlarmManager.RTC_WAKEUP, time, pendingIntent);

Schedule an exact alarm

alarmManager.setExact(AlarmManager.RTC_WAKEUP, time, pendingIntent);

Cancel an alarm

What is AlarmManager in Android?

AlarmManager is a system service that schedules actions to happen at a future time.

Does AlarmManager run code directly?

No. It usually triggers a PendingIntent, which then starts a receiver, service, or activity.

When should I use AlarmManager instead of WorkManager?

Use AlarmManager when the exact time matters, such as reminders or alarm clocks. Use WorkManager for deferred background tasks.

Why is my alarm not firing?

Common reasons include an unregistered receiver, incorrect PendingIntent, duplicate request codes, or modern Android battery restrictions.

What is a BroadcastReceiver used for here?

It receives the alarm event when Android sends the scheduled broadcast.

Can I repeat alarms with AlarmManager?

Yes, Android supports repeating alarms, but many apps now prefer more battery-aware approaches depending on the use case.

Do I need permissions for basic AlarmManager usage?

• BroadcastReceiver — receives the alarm event when it is triggered.
• PendingIntent — gives Android permission to perform an action later.
• Intent — describes what action should happen.
• WorkManager — alternative for background work that does not need exact timing.
• NotificationManager — often used after an alarm fires to show a notification.
• Service — sometimes started by an alarm for longer-running work.
• Android Manifest — where receivers are declared so Android can find them.