Add UnifiedPush support for push notifications

Implement UnifiedPush as an alternative push notification provider,
allowing users to receive notifications via a distributor app (e.g. ntfy)
without relying on Google's FCM infrastructure.

- Add UnifiedPushProvider with distributor-aware registration
- Add UnifiedPushManager for registration lifecycle and retry logic
- Add UnifiedPushReceiver for message and endpoint handling
- Add UnifiedPushWorker for background retry with backoff
- Add UnifiedPush distributor selection in Push provider settings
- Add IgnoreViolationRule for UnifiedPush connector StrictMode violations
- Add protobuf-java exclusion to avoid conflict with protobuf-javalite
- Add UnifiedPush guard in FcmPushProvider.isActive() and FCM onNewToken
- Extend MessagingManager with Map<String, Any> message handler
- Add 11 unit tests for UnifiedPush message parsing
- Add unifiedpush-connector 3.0.9 dependency

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: aaronstealth

app/gradle.lockfile

@@ -1796,4 +1796,15 @@
             column="42"/>
     </issue>
 
+    <issue
+        id="ExportedReceiver"
+        message="Exported receiver does not require permission"
+        errorLine1="        &lt;receiver"
+        errorLine2="         ~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="1024"
+            column="9"/>
+    </issue>
+
 </issues>

app/lint-baseline.xml

@@ -41,6 +41,11 @@ class FirebaseCloudMessagingService : FirebaseMessagingService() {
     override fun onNewToken(token: String) {
         mainScope.launch {
             Timber.d("Refreshed token: $token")
+            if (messagingManager.isUnifiedPushEnabled()) {
+                // Updating registration while using UnifiedPush will overwrite its token, so ignore new FCM tokens.
+                Timber.d("Not trying to update registration since UnifiedPush is being used.")
+                return@launch
+            }
             if (!serverManager.isRegistered()) {
                 Timber.d("Not trying to update registration since we aren't authenticated.")
                 return@launch

app/src/full/kotlin/io/homeassistant/companion/android/notifications/FirebaseCloudMessagingService.kt

@@ -1,5 +1,6 @@
 package io.homeassistant.companion.android.push
 
+import io.homeassistant.companion.android.common.data.prefs.PrefsRepository
 import io.homeassistant.companion.android.common.push.PushProvider
 import io.homeassistant.companion.android.common.push.PushRegistrationResult
 import io.homeassistant.companion.android.common.util.MessagingTokenProvider
@@ -14,6 +15,7 @@ import timber.log.Timber
  */
 @Singleton
 class FcmPushProvider @Inject constructor(
+    private val prefsRepository: PrefsRepository,
     private val messagingTokenProvider: MessagingTokenProvider,
 ) : PushProvider {
 
@@ -30,6 +32,8 @@ class FcmPushProvider @Inject constructor(
     }
 
     override suspend fun isActive(): Boolean {
+        // FCM is active only when UnifiedPush is not enabled and a valid token exists.
+        if (prefsRepository.isUnifiedPushEnabled()) return false
         return try {
             val token = messagingTokenProvider()
             !token.isBlank()

app/src/full/kotlin/io/homeassistant/companion/android/push/FcmPushProvider.kt

@@ -9,7 +9,7 @@ import io.homeassistant.companion.android.common.push.PushProvider
 
 /**
  * Dagger module that provides push provider implementations for the full flavor.
- * Includes FCM and WebSocket providers.
+ * Includes FCM, WebSocket, and UnifiedPush providers.
  */
 @Module
 @InstallIn(SingletonComponent::class)
@@ -22,4 +22,8 @@ abstract class PushProviderModule {
     @Binds
     @IntoSet
     abstract fun bindWebSocketPushProvider(provider: WebSocketPushProvider): PushProvider
+
+    @Binds
+    @IntoSet
+    abstract fun bindUnifiedPushProvider(provider: UnifiedPushProvider): PushProvider
 }

app/src/full/kotlin/io/homeassistant/companion/android/push/PushProviderModule.kt

@@ -1021,6 +1021,18 @@
                 android:value="true" />
         </service>
 
+        <receiver
+            android:name=".unifiedpush.UnifiedPushReceiver"
+            android:enabled="true"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="org.unifiedpush.android.connector.MESSAGE"/>
+                <action android:name="org.unifiedpush.android.connector.UNREGISTERED"/>
+                <action android:name="org.unifiedpush.android.connector.NEW_ENDPOINT"/>
+                <action android:name="org.unifiedpush.android.connector.REGISTRATION_FAILED"/>
+            </intent-filter>
+        </receiver>
+
         <receiver
             android:name=".notifications.NotificationActionReceiver"
             android:enabled="true"

app/src/main/AndroidManifest.xml

@@ -102,6 +102,7 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
@@ -284,6 +285,57 @@ class MessagingManager @Inject constructor(
 
     private val mainScope: CoroutineScope = CoroutineScope(Dispatchers.Main + Job())
 
+    suspend fun isUnifiedPushEnabled(): Boolean = prefsRepository.isUnifiedPushEnabled()
+
+    suspend fun setUnifiedPushEnabled(enabled: Boolean) = prefsRepository.setUnifiedPushEnabled(enabled)
+
+    fun handleMessage(
+        notificationData: Map<String, Any>,
+        source: String,
+        serverId: Int = ServerManager.SERVER_ID_ACTIVE,
+    ) {
+        val flattened = mutableMapOf<String, String>()
+        if (notificationData.containsKey("data")) {
+            for ((key, value) in notificationData["data"] as Map<*, *>) {
+                if (key == "actions" && value is List<*>) {
+                    value.forEachIndexed { i, action ->
+                        if (action is Map<*, *>) {
+                            flattened["action_${i + 1}_key"] = action["action"].toString()
+                            flattened["action_${i + 1}_title"] = action["title"].toString()
+                            action["uri"]?.let { uri -> flattened["action_${i + 1}_uri"] = uri.toString() }
+                            action["behavior"]?.let { behavior ->
+                                flattened["action_${i + 1}_behavior"] =
+                                    behavior.toString()
+                            }
+                        }
+                    }
+                } else {
+                    flattened[key.toString()] = value.toString()
+                }
+            }
+        }
+        // Message and title are in the root unlike all the others.
+        listOf("message", "title").forEach { key ->
+            if (notificationData.containsKey(key)) {
+                flattened[key] = notificationData[key].toString()
+            }
+        }
+        if (notificationData.containsKey("registration_info")) {
+            val registrationInfo = notificationData["registration_info"]
+            if (registrationInfo is Map<*, *> && registrationInfo.containsKey("webhook_id")) {
+                flattened["webhook_id"] = registrationInfo["webhook_id"].toString()
+            }
+        }
+        if (!flattened.containsKey("webhook_id")) {
+            runBlocking {
+                serverManager.getServer(serverId)
+            }?.let { server ->
+                flattened["webhook_id"] = server.connection.webhookId.toString()
+            }
+        }
+        handleMessage(flattened, source)
+    }
+
     fun handleMessage(notificationData: Map<String, String>, source: String) {
         mainScope.launch {
             var now = System.currentTimeMillis()

app/src/main/kotlin/io/homeassistant/companion/android/notifications/MessagingManager.kt

@@ -0,0 +1,57 @@
+package io.homeassistant.companion.android.push
+
+import android.content.Context
+import dagger.hilt.android.qualifiers.ApplicationContext
+import io.homeassistant.companion.android.common.data.prefs.PrefsRepository
+import io.homeassistant.companion.android.common.push.PushProvider
+import io.homeassistant.companion.android.common.push.PushRegistrationResult
+import io.homeassistant.companion.android.unifiedpush.UnifiedPushManager
+import javax.inject.Inject
+import javax.inject.Singleton
+import org.unifiedpush.android.connector.UnifiedPush
+import timber.log.Timber
+
+/**
+ * Push provider implementation backed by UnifiedPush.
+ *
+ * UnifiedPush allows receiving push notifications via a user-chosen distributor app
+ * (e.g. ntfy, NextPush) without relying on Google's FCM infrastructure.
+ *
+ */
+@Singleton
+class UnifiedPushProvider @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val prefsRepository: PrefsRepository,
+    private val unifiedPushManager: UnifiedPushManager,
+) : PushProvider {
+
+    override val name: String = NAME
+
+    override suspend fun isAvailable(): Boolean {
+        val distributors = UnifiedPush.getDistributors(context)
+        return distributors.isNotEmpty()
+    }
+
+    override suspend fun isActive(): Boolean = prefsRepository.isUnifiedPushEnabled()
+
+    override suspend fun register(): PushRegistrationResult? {
+        val distributor = UnifiedPush.getAckDistributor(context)
+        if (distributor == null) {
+            Timber.d("No UnifiedPush distributor acknowledged")
+            return null
+        }
+        // Registration happens asynchronously via UnifiedPushReceiver.
+        // The actual PushRegistrationResult will be created when onNewEndpoint is called.
+        UnifiedPushManager.register(context)
+        return null // Async - result delivered via UnifiedPushReceiver.onNewEndpoint
+    }
+
+    override suspend fun unregister() {
+        UnifiedPushManager.unregister(context)
+        prefsRepository.setUnifiedPushEnabled(false)
+    }
+
+    companion object {
+        const val NAME = "UnifiedPush"
+    }
+}

app/src/main/kotlin/io/homeassistant/companion/android/push/UnifiedPushProvider.kt

@@ -565,11 +565,27 @@ class SettingsFragment(
             lifecycleScope.launch(Dispatchers.IO) {
                 val entries = mutableListOf<String>()
                 val values = mutableListOf<String>()
+                val pm = requireContext().packageManager
 
                 val providers = presenter.getAvailablePushProviders()
                 for (provider in providers) {
-                    entries.add(provider.second)
-                    values.add(provider.first)
+                    if (provider.first == "UnifiedPush") {
+                        val distributors = presenter.getUnifiedPushDistributors()
+                        for (distributor in distributors) {
+                            val label = try {
+                                pm.getApplicationLabel(
+                                    pm.getApplicationInfo(distributor, PackageManager.GET_META_DATA),
+                                ).toString()
+                            } catch (_: PackageManager.NameNotFoundException) {
+                                distributor
+                            }
+                            entries.add("UnifiedPush ($label)")
+                            values.add("${SettingsPresenter.PUSH_PROVIDER_UP_PREFIX}$distributor")
+                        }
+                    } else {
+                        entries.add(provider.second)
+                        values.add(provider.first)
+                    }
                 }
 
                 val activeValue = presenter.getActivePushProviderValue()

app/src/main/kotlin/io/homeassistant/companion/android/settings/SettingsFragment.kt

@@ -11,6 +11,7 @@ interface SettingsPresenter {
     companion object {
         const val SUGGESTION_ASSISTANT_APP = "assistant_app"
         const val SUGGESTION_NOTIFICATION_PERMISSION = "notification_permission"
+        const val PUSH_PROVIDER_UP_PREFIX = "UnifiedPush:"
     }
 
     fun init(view: SettingsView)
@@ -21,10 +22,11 @@ interface SettingsPresenter {
     fun getSuggestionFlow(): StateFlow<SettingsHomeSuggestion?>
     suspend fun getServersFlow(): Flow<List<Server>>
     suspend fun getNotificationRateLimits(): RateLimitResponse?
-    suspend fun showChangeLog(context: Context)
-    suspend fun isChangeLogPopupEnabled(): Boolean
-    suspend fun setChangeLogPopupEnabled(enabled: Boolean)
+    fun getUnifiedPushDistributors(): List<String>
     fun getAvailablePushProviders(): List<Pair<String, String>>
     fun getActivePushProviderValue(): String
     fun handlePushProviderChange(value: String?)
+    suspend fun showChangeLog(context: Context)
+    suspend fun isChangeLogPopupEnabled(): Boolean
+    suspend fun setChangeLogPopupEnabled(enabled: Boolean)
 }