Android BroadcastReceiver Example Tutorial
BroadcastReceiver is one of the core Android components that you’ve probably heard of, but might not have fully explored yet. Think of it as your app’s way of listening to system-wide or custom messages – like getting notifications when the device boots up, when battery levels change, or when your own app components need to communicate. Whether you’re building apps that need to respond to system events, creating automated workflows, or just trying to make your Android apps more responsive to their environment, mastering BroadcastReceiver is essential. This tutorial will walk you through everything from basic concepts to real-world implementations, complete with working code examples and practical use cases that’ll make your apps smarter and more integrated with the Android ecosystem.
How BroadcastReceiver Works Under the Hood
BroadcastReceiver operates on Android’s publish-subscribe messaging pattern. When system events occur or apps send custom broadcasts, Android’s ActivityManager distributes these messages to all registered receivers that match the intent filters. It’s basically like having a radio that’s tuned to specific frequencies – your receiver only picks up the broadcasts it’s designed to handle.
Here’s what happens in the workflow:
• **Intent Broadcasting**: System or apps send broadcast intents
• **Intent Resolution**: Android matches intents with registered receivers
• **Receiver Activation**: Matching receivers get instantiated and executed
• **Message Processing**: Your onReceive() method handles the broadcast
• **Cleanup**: Receiver instance gets destroyed after processing
The beauty of this system is that receivers can be registered statically (in AndroidManifest.xml) or dynamically (in code), giving you flexibility in how your app responds to events. Static receivers persist even when your app isn’t running, while dynamic ones only work when your app is active.
One crucial thing to understand: BroadcastReceiver instances have a very short lifespan (about 10 seconds). They’re not meant for long-running operations – think of them as quick event handlers that trigger other components or perform lightweight tasks.
Setting Up BroadcastReceiver: Step-by-Step Implementation
Let’s dive into creating a practical BroadcastReceiver. We’ll build one that monitors battery level changes and network connectivity – perfect examples of system events you might want to track.
**Step 1: Create the Receiver Class**
public class SystemEventReceiver extends BroadcastReceiver {
private static final String TAG = "SystemEventReceiver";
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action == null) return;
switch (action) {
case Intent.ACTION_BATTERY_CHANGED:
handleBatteryChange(context, intent);
break;
case ConnectivityManager.CONNECTIVITY_ACTION:
handleNetworkChange(context);
break;
case Intent.ACTION_BOOT_COMPLETED:
handleBootCompleted(context);
break;
default:
Log.d(TAG, "Unhandled action: " + action);
}
}
private void handleBatteryChange(Context context, Intent intent) {
int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
float batteryPct = level * 100 / (float) scale;
Log.d(TAG, "Battery level: " + batteryPct + "%");
// Trigger actions based on battery level
if (batteryPct < 15) {
// Launch power saving mode or send notification
NotificationHelper.showLowBatteryNotification(context);
}
}
private void handleNetworkChange(Context context) {
ConnectivityManager cm = (ConnectivityManager)
context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork != null &&
activeNetwork.isConnectedOrConnecting();
Log.d(TAG, "Network connected: " + isConnected);
if (isConnected) {
// Resume data sync or downloads
startBackgroundSync(context);
} else {
// Pause operations that require network
pauseNetworkOperations(context);
}
}
private void handleBootCompleted(Context context) {
Log.d(TAG, "Device boot completed");
// Start background services or schedule alarms
schedulePeriodicTasks(context);
}
private void startBackgroundSync(Context context) {
Intent serviceIntent = new Intent(context, SyncService.class);
context.startService(serviceIntent);
}
private void pauseNetworkOperations(Context context) {
// Cancel pending network requests
// Save current state for later resumption
}
private void schedulePeriodicTasks(Context context) {
AlarmManager alarmManager = (AlarmManager)
context.getSystemService(Context.ALARM_SERVICE);
// Schedule recurring tasks
}
}
**Step 2: Register in AndroidManifest.xml (Static Registration)**
**Step 3: Add Required Permissions**
**Step 4: Dynamic Registration (Alternative/Additional)**
public class MainActivity extends AppCompatActivity {
private SystemEventReceiver receiver;
@Override
protected void onResume() {
super.onResume();
receiver = new SystemEventReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_BATTERY_CHANGED);
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
registerReceiver(receiver, filter);
}
@Override
protected void onPause() {
super.onPause();
if (receiver != null) {
unregisterReceiver(receiver);
receiver = null;
}
}
}
**Step 5: Create Custom Broadcasts**
public class CustomBroadcastHelper {
public static final String ACTION_DATA_SYNC_COMPLETE =
"com.yourapp.DATA_SYNC_COMPLETE";
public static final String ACTION_USER_PREFERENCE_CHANGED =
"com.yourapp.USER_PREFERENCE_CHANGED";
public static void sendDataSyncComplete(Context context, boolean success) {
Intent intent = new Intent(ACTION_DATA_SYNC_COMPLETE);
intent.putExtra("success", success);
intent.putExtra("timestamp", System.currentTimeMillis());
context.sendBroadcast(intent);
}
public static void sendOrderedBroadcast(Context context, String message) {
Intent intent = new Intent(ACTION_USER_PREFERENCE_CHANGED);
intent.putExtra("message", message);
// Ordered broadcasts are delivered to receivers in priority order
context.sendOrderedBroadcast(intent, null);
}
}
Real-World Examples and Use Cases
Let's explore some practical scenarios where BroadcastReceiver shines, along with both successful implementations and common pitfalls.
**Use Case 1: Server Monitoring App**
For those managing servers, you might want an Android app that responds to connectivity changes to check server status:
public class ServerMonitorReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
ConnectivityManager cm = (ConnectivityManager)
context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (isNetworkAvailable(cm)) {
// Network is back, check server status
Intent serviceIntent = new Intent(context, ServerStatusService.class);
serviceIntent.putExtra("servers", getMonitoredServers());
context.startService(serviceIntent);
}
}
}
private boolean isNetworkAvailable(ConnectivityManager cm) {
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
return activeNetwork != null && activeNetwork.isConnected();
}
private String[] getMonitoredServers() {
return new String[]{
"https://mangohost.net/vps",
"https://mangohost.net/dedicated",
"192.168.1.100:22",
"your-production-server.com"
};
}
}
**Use Case 2: Automated Backup Trigger**
public class BackupTriggerReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intent.ACTION_POWER_CONNECTED.equals(action)) {
// Device plugged in, good time for backup
if (isWifiConnected(context) && isBatteryLevelSufficient(context)) {
triggerBackup(context);
}
} else if ("android.intent.action.MY_PACKAGE_REPLACED".equals(action)) {
// App updated, backup preferences
backupAppSettings(context);
}
}
private void triggerBackup(Context context) {
JobScheduler jobScheduler = (JobScheduler)
context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
JobInfo jobInfo = new JobInfo.Builder(1001,
new ComponentName(context, BackupJobService.class))
.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)
.setRequiresCharging(false)
.build();
jobScheduler.schedule(jobInfo);
}
}
**Comparison Table: BroadcastReceiver vs Alternatives**
| Feature | BroadcastReceiver | JobScheduler | WorkManager | AlarmManager |
|---------|-------------------|--------------|-------------|-------------|
| System Event Response | ✓ Excellent | ✗ Limited | ✗ Limited | ✗ Time-based only |
| Battery Optimization | ✗ Can be aggressive | ✓ Optimized | ✓ Highly optimized | ✗ Can drain battery |
| Doze Mode Compatibility | ✗ Limited | ✓ Good | ✓ Excellent | ✗ Affected |
| Background Execution | ✗ 10s limit | ✓ Unlimited | ✓ Unlimited | ✓ Unlimited |
| Network Requirements | ✗ Manual check | ✓ Built-in constraints | ✓ Built-in constraints | ✗ Manual check |
| API Level Support | ✓ All levels | 21+ | 14+ (with backport) | ✓ All levels |
**Positive Case: Smart Home Integration**
public class SmartHomeReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (Intent.ACTION_USER_PRESENT.equals(intent.getAction())) {
// User unlocked device, they're active
sendHomeAutomationCommand(context, "user_active");
} else if (Intent.ACTION_SCREEN_OFF.equals(intent.getAction())) {
// Screen off, user might be away
schedulePresenceCheck(context);
}
}
private void sendHomeAutomationCommand(Context context, String command) {
// Integration with home automation systems
Intent serviceIntent = new Intent(context, HomeAutomationService.class);
serviceIntent.putExtra("command", command);
serviceIntent.putExtra("timestamp", System.currentTimeMillis());
context.startService(serviceIntent);
}
}
**Negative Case: Common Pitfalls and Solutions**
// ❌ WRONG: Long-running operation in onReceive()
public class BadReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// This will cause ANR (Application Not Responding)
try {
Thread.sleep(15000); // Never do this!
performDatabaseOperation(); // Long operation
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// ✅ CORRECT: Delegate to service or use async operations
public class GoodReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// Quick processing only
if (isValidIntent(intent)) {
// Start service for heavy lifting
Intent serviceIntent = new Intent(context, ProcessingService.class);
serviceIntent.putExtras(intent.getExtras());
context.startService(serviceIntent);
// Or use AsyncTask for moderate operations
new QuickProcessingTask().execute(intent);
}
}
private static class QuickProcessingTask extends AsyncTask {
@Override
protected Void doInBackground(Intent... intents) {
// Process in background thread
return null;
}
}
}
**Performance Statistics and Best Practices**
According to Android's battery optimization studies:
• Apps with excessive broadcast receivers consume 23% more battery on average
• Properly implemented receivers add less than 1% battery overhead
• Static receivers can increase app startup time by 15-30ms per receiver
• Dynamic receivers have virtually no startup impact
**Advanced Integration with Other Tools**
BroadcastReceiver pairs excellently with:
• **Retrofit** for API calls triggered by network changes
• **Room Database** for local data management
• **Firebase** for remote notifications and real-time updates
• **Dagger/Hilt** for dependency injection in receivers
@HiltAndroidApp
public class MyApplication extends Application { }
public class NetworkAwareReceiver extends BroadcastReceiver {
@Inject
ApiService apiService;
@Inject
DatabaseRepository repository;
@Override
public void onReceive(Context context, Intent intent) {
// Hilt injection works in receivers with proper setup
AndroidInjection.inject(this, context);
if (isNetworkConnected(context)) {
// Use injected dependencies
syncDataWithServer();
}
}
}
Automation and Scripting Possibilities
BroadcastReceiver opens up fascinating automation opportunities, especially for developers managing server infrastructure or IoT devices:
**Server Deployment Automation**
public class DeploymentReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if ("com.yourapp.DEPLOYMENT_TRIGGER".equals(intent.getAction())) {
String environment = intent.getStringExtra("environment");
String commitHash = intent.getStringExtra("commit_hash");
// Trigger deployment pipeline
triggerDeployment(context, environment, commitHash);
}
}
private void triggerDeployment(Context context, String env, String commit) {
// Could integrate with:
// - Jenkins API calls
// - Docker container management
// - Kubernetes deployments
// - Server monitoring setup
Intent deployIntent = new Intent(context, DeploymentService.class);
deployIntent.putExtra("target_servers", getServerList(env));
deployIntent.putExtra("commit", commit);
context.startService(deployIntent);
}
private String[] getServerList(String environment) {
switch (environment) {
case "production":
return new String[]{"https://mangohost.net/vps", "prod-server-2"};
case "staging":
return new String[]{"https://mangohost.net/dedicated", "staging-server"};
default:
return new String[]{};
}
}
}
**System Health Monitoring**
public class SystemHealthReceiver extends BroadcastReceiver {
private static final int LOW_MEMORY_THRESHOLD = 100 * 1024 * 1024; // 100MB
@Override
public void onReceive(Context context, Intent intent) {
switch (intent.getAction()) {
case Intent.ACTION_DEVICE_STORAGE_LOW:
handleLowStorage(context);
break;
case Intent.ACTION_BATTERY_LOW:
handleLowBattery(context);
break;
case "android.intent.action.APPLICATION_RESTRICTIONS_CHANGED":
handleRestrictionChanges(context);
break;
}
}
private void handleLowStorage(Context context) {
// Clean cache, compress logs, notify admin
cleanupStorageSpace(context);
notifySystemAdmin(context, "Low storage detected");
}
private void cleanupStorageSpace(Context context) {
// Automated cleanup procedures
File cacheDir = context.getCacheDir();
deleteOldFiles(cacheDir, 7); // Delete files older than 7 days
// Compress and upload logs
compressAndUploadLogs(context);
}
}
The automation possibilities are endless – from triggering server maintenance routines when the device connects to specific WiFi networks, to automatically starting VPN connections for secure server access, or even coordinating multiple Android devices in a server monitoring setup.
Conclusion and Recommendations
BroadcastReceiver is a powerful tool that, when used correctly, can make your Android apps incredibly responsive and integrated with the system. The key is understanding its limitations and using it as a lightweight event dispatcher rather than a heavy processing component.
**When to use BroadcastReceiver:**
• Responding to system events (boot, network changes, battery status)
• Inter-app communication
• Triggering background services based on events
• Creating automation workflows
• Building server monitoring or IoT control apps
**When NOT to use BroadcastReceiver:**
• Long-running operations (use Services or JobScheduler instead)
• Frequent periodic tasks (use WorkManager)
• UI updates (use LiveData or EventBus)
• Heavy computational work
**Best practices summary:**
• Keep onReceive() methods under 10 seconds
• Use static registration sparingly to avoid battery drain
• Always validate intent data before processing
• Delegate heavy work to Services or background threads
• Consider using LocalBroadcastManager for internal app communication
• Test thoroughly on different Android versions and OEM customizations
For server administrators and infrastructure developers, BroadcastReceiver can be particularly valuable when building monitoring apps or automation tools. Whether you're managing a single VPS or a complex dedicated server infrastructure, having mobile apps that can respond intelligently to system events adds another layer of flexibility to your monitoring and management toolkit.
The future of Android development is moving toward more battery-conscious approaches with WorkManager and JobScheduler, but BroadcastReceiver remains essential for immediate event response. Master it now, and you'll have a solid foundation for building truly reactive Android applications that work seamlessly with the broader Android ecosystem.
This article incorporates information and material from various online sources. We acknowledge and appreciate the work of all original authors, publishers, and websites. While every effort has been made to appropriately credit the source material, any unintentional oversight or omission does not constitute a copyright infringement. All trademarks, logos, and images mentioned are the property of their respective owners. If you believe that any content used in this article infringes upon your copyright, please contact us immediately for review and prompt action.
This article is intended for informational and educational purposes only and does not infringe on the rights of the copyright owners. If any copyrighted material has been used without proper credit or in violation of copyright laws, it is unintentional and we will rectify it promptly upon notification. Please note that the republishing, redistribution, or reproduction of part or all of the contents in any form is prohibited without express written permission from the author and website owner. For permissions or further inquiries, please contact us.
