Android Push Notifications With FCM: The Complete Implementation Guide

// build.gradle.kts
dependencies {
    implementation(platform("com.google.firebase:firebase-bom:33.0.0"))
    implementation("com.google.firebase:firebase-messaging")
}

class TaskNotificationService : FirebaseMessagingService() {
    
    // Called when app is in foreground and a message arrives
    override fun onMessageReceived(message: RemoteMessage) {
        val title = message.notification?.title ?: message.data["title"] ?: return
        val body = message.notification?.body ?: message.data["body"] ?: return
        val taskId = message.data["task_id"]
        
        showNotification(title, body, taskId)
    }
    
    // Called when FCM token is refreshed — send new token to your server
    override fun onNewToken(token: String) {
        sendTokenToServer(token)
    }
    
    private fun showNotification(title: String, body: String, taskId: String?) {
        val intent = Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            taskId?.let { putExtra("task_id", it) }
        }
        
        val pendingIntent = PendingIntent.getActivity(
            this, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )
        
        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_notification)
            .setContentTitle(title)
            .setContentText(body)
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            .setAutoCancel(true)
            .setContentIntent(pendingIntent)
            .build()
        
        NotificationManagerCompat.from(this)
            .notify(System.currentTimeMillis().toInt(), notification)
    }
    
    companion object {
        const val CHANNEL_ID = "task_reminders"
    }
}

AndroidManifest.xml

<service
    android:name=".notifications.TaskNotificationService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        createNotificationChannels()
    }
    
    private fun createNotificationChannels() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val taskReminders = NotificationChannel(
                "task_reminders",
                "Task Reminders",
                NotificationManager.IMPORTANCE_DEFAULT
            ).apply {
                description = "Reminders for upcoming and overdue tasks"
                enableVibration(true)
            }
            
            val urgentAlerts = NotificationChannel(
                "urgent_alerts",
                "Urgent Alerts",
                NotificationManager.IMPORTANCE_HIGH
            ).apply {
                description = "Critical alerts requiring immediate attention"
            }
            
            val manager = getSystemService(NotificationManager::class.java)
            manager.createNotificationChannels(listOf(taskReminders, urgentAlerts))
        }
    }
}

class NotificationPermissionHandler(private val activity: AppCompatActivity) {
    
    private val requestPermissionLauncher = activity.registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            onPermissionGranted()
        } else {
            onPermissionDenied()
        }
    }
    
    fun requestIfNeeded() {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return
        
        when {
            ContextCompat.checkSelfPermission(
                activity, Manifest.permission.POST_NOTIFICATIONS
            ) == PackageManager.PERMISSION_GRANTED -> {
                // Already granted — nothing to do
            }
            activity.shouldShowRequestPermissionRationale(
                Manifest.permission.POST_NOTIFICATIONS
            ) -> {
                // Show explanation dialog first, then request
                showRationaleDialog()
            }
            else -> {
                requestPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
            }
        }
    }
    
    private fun showRationaleDialog() {
        MaterialAlertDialogBuilder(activity)
            .setTitle("Enable Reminders")
            .setMessage("Allow notifications to receive task reminders when they're due.")
            .setPositiveButton("Enable") { _, _ ->
                requestPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
            }
            .setNegativeButton("Not Now", null)
            .show()
    }
}

class FCMTokenManager(
    private val userRepository: UserRepository,
    private val preferences: EncryptedSharedPreferences
) {
    
    suspend fun refreshToken() {
        try {
            val token = Firebase.messaging.getToken().await()
            val storedToken = preferences.getString("fcm_token", null)
            
            if (token != storedToken) {
                userRepository.updateFCMToken(token)
                preferences.edit().putString("fcm_token", token).apply()
            }
        } catch (e: Exception) {
            Timber.e(e, "Failed to refresh FCM token")
        }
    }
}

refreshToken()

onNewToken()

// Let users choose what they want
data class NotificationPreferences(
    val taskReminders: Boolean = true,
    val overdueAlerts: Boolean = true,
    val weeklyDigest: Boolean = false,
    val marketingUpdates: Boolean = false
)