Added UnifiedPush support

Cargo.toml

@@ -2,7 +2,7 @@
 name = "tauri-plugin-notifications"
 version = "0.4.3"
 authors = ["You"]
-description = "A Tauri v2 plugin for sending notifications on desktop and mobile platforms with support for system notifications and push delivery via FCM and APNs."
+description = "A Tauri v2 plugin for sending notifications on desktop and mobile platforms with support for system notifications and push delivery via FCM, APNs, and UnifiedPush."
 edition = "2021"
 rust-version = "1.77.2"
 exclude = ["/examples", "/dist-js", "/guest-js", "/node_modules"]
@@ -13,6 +13,7 @@ repository = "https://github.com/Choochmeque/tauri-plugin-notifications"
 [features]
 default = ["notify-rust"]
 push-notifications = []
+unified-push = []
 notify-rust = ["dep:notify-rust"]
 
 [dependencies]

README.md

@@ -68,6 +68,40 @@ Without this feature enabled:
 - Push notification registration code is disabled
 - The `registerForPushNotifications()` function will return an error if called
 
+### UnifiedPush Support
+
+The `unified-push` feature is **disabled by default**. UnifiedPush is a decentralized push notification protocol that allows apps to receive push notifications through various distributors (like NextPush, ntfy, etc.) instead of being locked into FCM or APNs.
+
+To enable UnifiedPush support on Android:
+
+```toml
+[dependencies]
+tauri-plugin-notifications = { version = "0.4", features = ["unified-push"] }
+```
+
+**Note:** UnifiedPush is currently only supported on Android. It can be used alongside FCM or as a standalone push notification solution.
+
+To enable both FCM and UnifiedPush:
+
+```toml
+[dependencies]
+tauri-plugin-notifications = { version = "0.4", features = ["push-notifications", "unified-push"] }
+```
+
+**What is UnifiedPush?**
+
+UnifiedPush is an open standard for push notifications that gives users control over their notification delivery. Instead of relying solely on Google's FCM or Apple's APNs, apps can receive notifications through user-chosen distributors:
+
+- **NextPush** - A UnifiedPush distributor with server-side support
+- **ntfy** - Simple, self-hostable push notification service
+- **Other distributors** - Any app implementing the UnifiedPush protocol
+
+**Benefits:**
+- User privacy - users choose their notification provider
+- No Google Services dependency required
+- Works with self-hosted solutions
+- Open protocol that any distributor can implement
+
 ### Desktop Notification Backend (notify-rust)
 
 The `notify-rust` feature is **enabled by default** and provides cross-platform desktop notifications using the [notify-rust](https://crates.io/crates/notify-rust) crate.
@@ -105,6 +139,17 @@ Configure the plugin permissions in your `capabilities/default.json`:
 }
 ```
 
+If you enabled the `unified-push` feature, also add the UnifiedPush permission set:
+
+```json
+{
+  "permissions": [
+    "notifications:default",
+    "notifications:allow-unified-push"
+  ]
+}
+```
+
 Register the plugin in your Tauri app:
 
 ```rust
@@ -390,6 +435,63 @@ try {
 }
 ```
 
+#### UnifiedPush (Android)
+
+UnifiedPush provides a decentralized alternative to FCM, giving users control over their push notification delivery.
+
+```typescript
+import {
+  registerForUnifiedPush,
+  getUnifiedPushDistributors,
+  saveUnifiedPushDistributor,
+  onUnifiedPushMessage,
+  onUnifiedPushEndpoint
+} from '@choochmeque/tauri-plugin-notifications-api';
+
+// Check available UnifiedPush distributors
+const { distributors } = await getUnifiedPushDistributors();
+console.log('Available distributors:', distributors);
+
+// If no distributor is selected, prompt user to choose one
+if (distributors.length === 0) {
+  console.error('No UnifiedPush distributor installed. Please install NextPush or ntfy.');
+} else {
+  // Save the selected distributor (e.g., NextPush)
+  await saveUnifiedPushDistributor(distributors[0]);
+
+  // Listen for new endpoints
+  const unlistenEndpoint = await onUnifiedPushEndpoint((data) => {
+    console.log('UnifiedPush endpoint:', data.endpoint);
+    // Send this endpoint to your server to send push notifications
+  });
+
+  // Listen for incoming messages
+  const unlistenMessage = await onUnifiedPushMessage((data) => {
+    console.log('UnifiedPush message received:', data);
+  });
+
+  // Register for UnifiedPush
+  const { endpoint, instance } = await registerForUnifiedPush();
+  console.log('Registered with UnifiedPush:', endpoint);
+}
+```
+
+**Sending UnifiedPush notifications:**
+
+Once you have the endpoint URL, your server can send notifications by making an HTTP POST request to the endpoint:
+
+```bash
+curl -X POST "https://your-distributor-url/endpoint" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "title": "Hello",
+    "body": "This is a UnifiedPush notification",
+    "data": {
+      "custom": "data"
+    }
+  }'
+```
+
 ### Rust
 
 ```rust
@@ -452,6 +554,69 @@ Registers the app for push notifications (mobile only). On Android, this retriev
 
 **Returns:** `Promise<string>` - The device push token
 
+### `unregisterForPushNotifications()`
+Unregisters the app from push notifications (mobile only). Deletes the FCM token on Android.
+
+**Returns:** `Promise<void>`
+
+> **Breaking change:** `unregisterForPushNotifications()` previously returned `Promise<string>`. It now returns `Promise<void>` since the native side no longer resolves with a value.
+
+### `registerForUnifiedPush()`
+Registers the app for UnifiedPush notifications (Android only). UnifiedPush is a decentralized push notification protocol that allows receiving notifications through various distributors.
+
+**Returns:** `Promise<UnifiedPushEndpoint>` - An object containing:
+- `endpoint`: The URL where push messages should be sent
+- `instance`: The instance identifier for this registration
+- `pubKeySet` (optional): VAPID public-key set for encrypted push (contains `pubKey` and `auth` fields)
+
+### `unregisterFromUnifiedPush()`
+Unregisters the app from UnifiedPush notifications (Android only).
+
+**Returns:** `Promise<void>`
+
+### `getUnifiedPushDistributors()`
+Gets the list of available UnifiedPush distributors installed on the device (Android only). Distributors are apps that handle push notification delivery (e.g., NextPush, ntfy).
+
+**Returns:** `Promise<{ distributors: string[] }>`
+
+### `saveUnifiedPushDistributor(distributor: string)`
+Saves the selected UnifiedPush distributor (Android only). This sets which distributor app should be used for handling push notifications.
+
+**Parameters:**
+- `distributor`: The package name of the distributor to use
+
+**Returns:** `Promise<void>`
+
+### `getUnifiedPushDistributor()`
+Gets the currently selected UnifiedPush distributor (Android only).
+
+**Returns:** `Promise<{ distributor: string }>`
+
+### `onUnifiedPushEndpoint(callback: (data: UnifiedPushEndpoint) => void)`
+Listens for new UnifiedPush endpoint events. This event is triggered when a new UnifiedPush endpoint is registered or updated.
+
+**Returns:** `Promise<PluginListener>` with `unlisten()` method
+
+### `onUnifiedPushMessage(callback: (data: Record<string, unknown>) => void)`
+Listens for UnifiedPush message events. This event is triggered when a push message is received through UnifiedPush.
+
+**Returns:** `Promise<PluginListener>` with `unlisten()` method
+
+### `onUnifiedPushUnregistered(callback: (data: { instance: string }) => void)`
+Listens for UnifiedPush unregistration events. This event is triggered when the app is unregistered from UnifiedPush.
+
+**Returns:** `Promise<PluginListener>` with `unlisten()` method
+
+### `onUnifiedPushError(callback: (data: { message: string, instance?: string }) => void)`
+Listens for UnifiedPush error events. This event is triggered when there's an error with UnifiedPush registration or delivery.
+
+**Returns:** `Promise<PluginListener>` with `unlisten()` method
+
+### `onUnifiedPushTempUnavailable(callback: (data: { instance: string }) => void)`
+Listens for UnifiedPush temporary-unavailability events. Fired when the distributor app is temporarily unavailable (e.g. being updated). The existing registration remains valid; wait for an `onUnifiedPushEndpoint` callback before sending push messages again.
+
+**Returns:** `Promise<PluginListener>` with `unlisten()` method
+
 ### `sendNotification(options: Options | string)`
 Sends a notification to the user. Can be called with a simple string for the title or with a detailed options object.
 

android/build.gradle.kts

@@ -25,9 +25,13 @@ android {
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles("consumer-rules.pro")
 
-        // Enable push notifications based on Cargo feature flag
         val enablePush = buildProperties.getProperty("enablePushNotifications", "false").toBoolean()
         buildConfigField("boolean", "ENABLE_PUSH_NOTIFICATIONS", "$enablePush")
+
+        val enableUnifiedPush = buildProperties.getProperty("enableUnifiedPush", "false").toBoolean()
+        buildConfigField("boolean", "ENABLE_UNIFIED_PUSH", "$enableUnifiedPush")
+
+        manifestPlaceholders["unifiedPushReceiverEnabled"] = "$enableUnifiedPush"
     }
 
     buildTypes {
@@ -73,6 +77,9 @@ dependencies {
 
     implementation(platform("com.google.firebase:firebase-bom:34.7.0"))
     implementation("com.google.firebase:firebase-messaging-ktx:24.1.2")
+
+    implementation("org.unifiedpush.android:connector:3.3.2")
+
     testImplementation("junit:junit:4.13.2")
     testImplementation("io.mockk:mockk-android:1.14.9")
     testImplementation("io.mockk:mockk-agent:1.14.9")

android/settings.gradle

@@ -23,7 +23,6 @@ dependencyResolutionManagement {
     repositories {
         mavenCentral()
         google()
-
     }
 }
 

android/src/main/AndroidManifest.xml

@@ -14,14 +14,26 @@
             </intent-filter>
         </receiver>
 
-        <!-- Firebase Cloud Messaging Service for handling push notifications -->
         <service
             android:name="app.tauri.notification.TauriFirebaseMessagingService"
             android:exported="false">
             <intent-filter>
                 <action android:name="com.google.firebase.MESSAGING_EVENT" />
             </intent-filter>
         </service>
+
+        <receiver
+            android:name="app.tauri.notification.TauriUnifiedPushMessagingService"
+            android:exported="true"
+            android:enabled="${unifiedPushReceiverEnabled}">
+            <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" />
+                <action android:name="org.unifiedpush.android.connector.TEMP_UNAVAILABLE" />
+            </intent-filter>
+        </receiver>
     </application>
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />

android/src/main/java/app/tauri/notification/JSObjectUtils.kt

@@ -0,0 +1,96 @@
+package app.tauri.notification
+
+import app.tauri.plugin.JSArray
+import app.tauri.plugin.JSObject
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Shared helpers for recursively converting native Kotlin values (Maps, Lists, primitives)
+ * into [JSObject] / [JSArray] structures understood by the Tauri plugin bridge.
+ *
+ * Both [NotificationPlugin] and [TauriUnifiedPushMessagingService] need to convert
+ * the push-data maps they receive into JS-bridge types; keeping the logic in one
+ * place prevents the two copies from drifting apart.
+ */
+internal object JSObjectUtils {
+
+    /**
+     * Recursively put [value] into [target] under [key].
+     * Handles String, Int, Long, Double, Boolean, Map, and List types.
+     */
+    fun putValueToJSObject(target: JSObject, key: String, value: Any) {
+        when (value) {
+            is String -> target.put(key, value)
+            is Int -> target.put(key, value)
+            is Long -> target.put(key, value)
+            is Double -> target.put(key, value)
+            is Boolean -> target.put(key, value)
+            is Map<*, *> -> {
+                val nestedObj = JSObject()
+                @Suppress("UNCHECKED_CAST")
+                val map = value as Map<String, Any>
+                for ((k, v) in map) {
+                    putValueToJSObject(nestedObj, k, v)
+                }
+                target.put(key, nestedObj)
+            }
+            is List<*> -> target.put(key, convertListToJSArray(value))
+            else -> target.put(key, value.toString())
+        }
+    }
+
+    /**
+     * Recursively convert a [List] into a [JSArray], handling nested maps, lists, and primitives.
+     */
+    fun convertListToJSArray(list: List<*>): JSArray {
+        val arr = JSArray()
+        for (item in list) {
+            when (item) {
+                is String -> arr.put(item)
+                is Int -> arr.put(item)
+                is Long -> arr.put(item)
+                is Double -> arr.put(item)
+                is Boolean -> arr.put(item)
+                is Map<*, *> -> {
+                    val nestedObj = JSObject()
+                    @Suppress("UNCHECKED_CAST")
+                    val map = item as Map<String, Any>
+                    for ((k, v) in map) {
+                        putValueToJSObject(nestedObj, k, v)
+                    }
+                    arr.put(nestedObj)
+                }
+                is List<*> -> arr.put(convertListToJSArray(item))
+                null -> arr.put(JSONObject.NULL)
+                else -> arr.put(item.toString())
+            }
+        }
+        return arr
+    }
+
+    /**
+     * Recursively convert a raw [JSONObject] value into a native Kotlin type
+     * (Map for objects, List for arrays, or the primitive itself).
+     */
+    fun jsonValueToNative(value: Any): Any {
+        return when (value) {
+            is JSONObject -> {
+                val map = mutableMapOf<String, Any>()
+                for (key in value.keys()) {
+                    map[key] = jsonValueToNative(value.get(key))
+                }
+                map
+            }
+            is JSONArray -> {
+                val list = mutableListOf<Any>()
+                for (i in 0 until value.length()) {
+                    list.add(jsonValueToNative(value.get(i)))
+                }
+                list
+            }
+            else -> value
+        }
+    }
+}
+