notifications: no-ntfy persistent listener + rich MessagingStyle (multi-sender, image support, group summary)
This commit is contained in:
@@ -62,23 +62,36 @@
|
||||
|
||||
<service
|
||||
android:name=".MatrixSyncService"
|
||||
android:foregroundServiceType="dataSync"
|
||||
android:process=":listener"
|
||||
android:foregroundServiceType="specialUse|dataSync"
|
||||
android:exported="false"
|
||||
android:stopWithTask="false" />
|
||||
|
||||
<service
|
||||
android:name=".UnifiedPushService"
|
||||
android:exported="false">
|
||||
<intent-filter>
|
||||
<action android:name="org.unifiedpush.android.connector.PUSH_EVENT" />
|
||||
</intent-filter>
|
||||
android:stopWithTask="false">
|
||||
<property
|
||||
android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
|
||||
android:value="matrix_message_listener" />
|
||||
</service>
|
||||
|
||||
<receiver
|
||||
android:name=".BootReceiver"
|
||||
android:exported="true">
|
||||
android:exported="true"
|
||||
android:enabled="true">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.BOOT_COMPLETED" />
|
||||
<action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
|
||||
<action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
|
||||
<action android:name="android.intent.action.QUICKBOOT_POWERON" />
|
||||
<action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
|
||||
</intent-filter>
|
||||
</receiver>
|
||||
|
||||
<receiver
|
||||
android:name=".ListenerWatchdogReceiver"
|
||||
android:process=":listener"
|
||||
android:exported="false"
|
||||
android:enabled="true">
|
||||
<intent-filter>
|
||||
<action android:name="com.paarrot.app.LISTENER_WATCHDOG" />
|
||||
<action android:name="com.paarrot.app.LISTENER_RESTART" />
|
||||
</intent-filter>
|
||||
</receiver>
|
||||
</application>
|
||||
@@ -86,31 +99,18 @@
|
||||
<!-- Permissions -->
|
||||
|
||||
<uses-permission android:name="android.permission.INTERNET" />
|
||||
<uses-permission android:name="android.permission.WAKE_LOCK" />
|
||||
<uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
|
||||
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
|
||||
<uses-permission android:name="android.permission.VIBRATE" />
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
|
||||
<uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
|
||||
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
|
||||
<uses-permission android:name="android.permission.RECORD_AUDIO" />
|
||||
<uses-permission android:name="android.permission.CAMERA" />
|
||||
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
|
||||
<uses-permission android:name="android.permission.BLUETOOTH" />
|
||||
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
|
||||
|
||||
<!-- Android 11+ package visibility for UnifiedPush distributors (ntfy, etc.) -->
|
||||
<queries>
|
||||
<intent>
|
||||
<action android:name="org.unifiedpush.android.distributor.REGISTER" />
|
||||
</intent>
|
||||
<intent>
|
||||
<action android:name="org.unifiedpush.android.distributor.UNREGISTER" />
|
||||
</intent>
|
||||
<intent>
|
||||
<action android:name="org.unifiedpush.android.distributor.LINK" />
|
||||
</intent>
|
||||
<intent>
|
||||
<action android:name="android.intent.action.VIEW" />
|
||||
<data android:scheme="unifiedpush" />
|
||||
</intent>
|
||||
<package android:name="io.heckel.ntfy" />
|
||||
</queries>
|
||||
</manifest>
|
||||
|
||||
@@ -5,17 +5,23 @@ import android.content.Context
|
||||
import android.content.Intent
|
||||
|
||||
/**
|
||||
* Re-registers UnifiedPush after boot when credentials still exist.
|
||||
* Starts the message listener again after boot / update when credentials still exist.
|
||||
*/
|
||||
class BootReceiver : BroadcastReceiver() {
|
||||
|
||||
override fun onReceive(context: Context, intent: Intent) {
|
||||
if (intent.action != Intent.ACTION_BOOT_COMPLETED) return
|
||||
|
||||
val prefs = context.getSharedPreferences(SyncServicePlugin.PREFS, Context.MODE_PRIVATE)
|
||||
prefs.getString(MatrixSyncService.EXTRA_HOMESERVER, null) ?: return
|
||||
prefs.getString(MatrixSyncService.EXTRA_TOKEN, null) ?: return
|
||||
|
||||
UnifiedPushManager.register(context, activity = null)
|
||||
val action = intent.action ?: return
|
||||
when (action) {
|
||||
Intent.ACTION_BOOT_COMPLETED,
|
||||
Intent.ACTION_LOCKED_BOOT_COMPLETED,
|
||||
Intent.ACTION_MY_PACKAGE_REPLACED,
|
||||
"android.intent.action.QUICKBOOT_POWERON",
|
||||
"com.htc.intent.action.QUICKBOOT_POWERON",
|
||||
-> {
|
||||
if (!MatrixSyncService.hasCredentials(context)) return
|
||||
MatrixSyncService.scheduleKeepAlive(context)
|
||||
MatrixSyncService.requestSyncFetch(context, "boot:$action")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
package com.paarrot.app
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.util.Log
|
||||
|
||||
/**
|
||||
* Keeps the Matrix message listener alive after OEM kills, idle, or package update.
|
||||
* Each fire re-chains the next one-shot watchdog alarm.
|
||||
*
|
||||
* Health is the persisted sync heartbeat (works across UI vs `:listener` processes).
|
||||
*/
|
||||
class ListenerWatchdogReceiver : BroadcastReceiver() {
|
||||
|
||||
override fun onReceive(context: Context, intent: Intent?) {
|
||||
val action = intent?.action ?: ACTION_WATCHDOG
|
||||
val healthy = MatrixSyncService.isListenerHealthy(context)
|
||||
val ageMs = MatrixSyncService.heartbeatAgeMs(context)
|
||||
val inProc = MatrixSyncService.isListenerRunning()
|
||||
Log.i(
|
||||
TAG,
|
||||
"watchdog fired action=$action healthy=$healthy heartbeatAgeMs=$ageMs inProcAlive=$inProc",
|
||||
)
|
||||
if (!MatrixSyncService.hasCredentials(context)) {
|
||||
Log.w(TAG, "watchdog skip — no credentials")
|
||||
return
|
||||
}
|
||||
// Always re-arm the chain first — even if start fails under OEM limits.
|
||||
MatrixSyncService.scheduleKeepAlive(context)
|
||||
val needsRestart = action == ACTION_RESTART || !healthy
|
||||
if (needsRestart) {
|
||||
Log.w(TAG, "watchdog restarting reason=${if (action == ACTION_RESTART) "explicit" else "stale-or-missing-heartbeat"}")
|
||||
MatrixSyncService.requestSyncFetch(context, "watchdog:$action")
|
||||
} else {
|
||||
Log.i(TAG, "watchdog ok — listener healthy, no restart")
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "PaarrotWatchdog"
|
||||
const val ACTION_WATCHDOG = "com.paarrot.app.LISTENER_WATCHDOG"
|
||||
const val ACTION_RESTART = "com.paarrot.app.LISTENER_RESTART"
|
||||
}
|
||||
}
|
||||
@@ -1,11 +1,18 @@
|
||||
package com.paarrot.app;
|
||||
|
||||
import android.Manifest;
|
||||
import android.content.pm.PackageManager;
|
||||
import android.os.Build;
|
||||
import android.os.Bundle;
|
||||
import android.webkit.WebView;
|
||||
import androidx.core.app.ActivityCompat;
|
||||
import androidx.core.content.ContextCompat;
|
||||
import androidx.core.view.ViewCompat;
|
||||
import com.getcapacitor.BridgeActivity;
|
||||
|
||||
public class MainActivity extends BridgeActivity {
|
||||
private boolean askedNotifications = false;
|
||||
|
||||
@Override
|
||||
protected void onCreate(Bundle savedInstanceState) {
|
||||
registerPlugin(SyncServicePlugin.class);
|
||||
@@ -13,18 +20,47 @@ public class MainActivity extends BridgeActivity {
|
||||
registerPlugin(PluginStoragePlugin.class);
|
||||
super.onCreate(savedInstanceState);
|
||||
setupImageKeyboardSupport();
|
||||
ensureListener();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onResume() {
|
||||
super.onResume();
|
||||
// Keep native sync suppression in sync with the real Activity lifecycle.
|
||||
MatrixSyncService.appInForeground = true;
|
||||
MatrixSyncService.setAppInForeground(this, true);
|
||||
ensureListener();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
|
||||
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
|
||||
if (requestCode == REQUEST_NOTIFICATIONS
|
||||
&& grantResults.length > 0
|
||||
&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {
|
||||
MatrixSyncService.requestSyncFetch(this, MatrixSyncService.MODE_LISTENER);
|
||||
}
|
||||
}
|
||||
|
||||
/** Keep the foreground listener up once this phone has a saved login. */
|
||||
private void ensureListener() {
|
||||
if (Build.VERSION.SDK_INT >= 33
|
||||
&& ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS)
|
||||
!= PackageManager.PERMISSION_GRANTED) {
|
||||
if (!askedNotifications) {
|
||||
askedNotifications = true;
|
||||
ActivityCompat.requestPermissions(
|
||||
this,
|
||||
new String[] {Manifest.permission.POST_NOTIFICATIONS},
|
||||
REQUEST_NOTIFICATIONS
|
||||
);
|
||||
}
|
||||
return;
|
||||
}
|
||||
MatrixSyncService.requestSyncFetch(this, MatrixSyncService.MODE_LISTENER);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onPause() {
|
||||
MatrixSyncService.appInForeground = false;
|
||||
MatrixSyncService.setAppInForeground(this, false);
|
||||
super.onPause();
|
||||
}
|
||||
|
||||
@@ -39,4 +75,6 @@ public class MainActivity extends BridgeActivity {
|
||||
new ImageKeyboardContentReceiver()
|
||||
);
|
||||
}
|
||||
|
||||
private static final int REQUEST_NOTIFICATIONS = 4101;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,7 +1,16 @@
|
||||
package com.paarrot.app
|
||||
|
||||
import android.Manifest
|
||||
import android.app.Activity
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.PackageManager
|
||||
import android.net.Uri
|
||||
import android.os.Build
|
||||
import android.os.PowerManager
|
||||
import android.provider.Settings
|
||||
import androidx.core.app.ActivityCompat
|
||||
import androidx.core.content.ContextCompat
|
||||
import com.getcapacitor.JSObject
|
||||
import com.getcapacitor.Plugin
|
||||
import com.getcapacitor.PluginCall
|
||||
@@ -12,13 +21,12 @@ import com.getcapacitor.annotation.CapacitorPlugin
|
||||
* Capacitor plugin that controls [MatrixSyncService] from JS.
|
||||
*
|
||||
* JS API:
|
||||
* - `start({ homeserverUrl, accessToken, userId, deviceId })` — persist credentials and register UnifiedPush
|
||||
* - `triggerPing({ reason })` — force a one-shot fetch (for testing/manual wake)
|
||||
* - `stop()` — clear persisted credentials and unregister UnifiedPush
|
||||
* - `start({ homeserverUrl, accessToken, userId, deviceId })` — persist credentials and keep the listener running
|
||||
* - `triggerPing({ reason })` — make sure the listener is running
|
||||
* - `stop()` — clear persisted credentials and stop the listener
|
||||
* - `setAppForeground({ foreground })` — tell the service whether the app UI is visible
|
||||
* - `getStatus()` — returns current fetch and UnifiedPush state
|
||||
* - `requestDistributorSetup()` — clear saved distributor and re-open OS picker
|
||||
* - `resolveUnifiedPushGateway({ endpoint })` — native Matrix gateway discovery
|
||||
* - `getStatus()` — returns whether the listener is running and battery is unrestricted
|
||||
* - `requestBatteryExemption()` — ask Android to leave the listener unrestricted
|
||||
* - `clearRoomNotifications({ roomId })` — dismiss native tray notifs for a room
|
||||
* - `setNotificationGroups({ rooms })` — persist space/DM grouping for tray nesting
|
||||
* - `showNotification({ title, body, roomId, groupId, groupName, kind, largeIconBase64 })`
|
||||
@@ -26,13 +34,8 @@ import com.getcapacitor.annotation.CapacitorPlugin
|
||||
@CapacitorPlugin(name = "MatrixBackgroundSync")
|
||||
class SyncServicePlugin : Plugin() {
|
||||
|
||||
fun emitUnifiedPushEvent(eventName: String, payload: JSObject) {
|
||||
notifyListeners(eventName, payload, true)
|
||||
}
|
||||
|
||||
override fun load() {
|
||||
super.load()
|
||||
UnifiedPushManager.setPlugin(this)
|
||||
NotificationNavStore.plugin = this
|
||||
NotificationNavStore.handleIntent(activity?.intent)
|
||||
}
|
||||
@@ -46,7 +49,6 @@ class SyncServicePlugin : Plugin() {
|
||||
}
|
||||
|
||||
override fun handleOnDestroy() {
|
||||
UnifiedPushManager.clearPlugin(this)
|
||||
if (NotificationNavStore.plugin === this) {
|
||||
NotificationNavStore.plugin = null
|
||||
}
|
||||
@@ -71,7 +73,7 @@ class SyncServicePlugin : Plugin() {
|
||||
call.resolve(result)
|
||||
}
|
||||
|
||||
/** Persists Matrix credentials and starts UnifiedPush registration. */
|
||||
/** Persists Matrix credentials and keeps the message listener in the foreground. */
|
||||
@PluginMethod
|
||||
fun start(call: PluginCall) {
|
||||
val homeserver = call.getString("homeserverUrl")
|
||||
@@ -86,11 +88,13 @@ class SyncServicePlugin : Plugin() {
|
||||
.putString(MatrixSyncService.EXTRA_TOKEN, token)
|
||||
.putString(MatrixSyncService.EXTRA_USER_ID, userId)
|
||||
.putString(MatrixSyncService.EXTRA_DEVICE_ID, deviceId)
|
||||
.apply()
|
||||
.commit()
|
||||
|
||||
UnifiedPushManager.register(context, activity)
|
||||
|
||||
call.resolve()
|
||||
askNotificationPermission()
|
||||
MatrixSyncService.scheduleKeepAlive(context)
|
||||
MatrixSyncService.requestSyncFetch(context, MatrixSyncService.MODE_LISTENER)
|
||||
val ignored = askBatteryExemption(context, activity)
|
||||
call.resolve(JSObject().put("batteryIgnored", ignored))
|
||||
}
|
||||
|
||||
/** Manually triggers a one-shot sync fetch (mainly for diagnostics/testing). */
|
||||
@@ -104,9 +108,9 @@ class SyncServicePlugin : Plugin() {
|
||||
/** Stops the sync service and erases persisted credentials. */
|
||||
@PluginMethod
|
||||
fun stop(call: PluginCall) {
|
||||
MatrixSyncService.cancelKeepAlive(context)
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().clear().apply()
|
||||
context.stopService(Intent(context, MatrixSyncService::class.java))
|
||||
UnifiedPushManager.unregister(context)
|
||||
call.resolve()
|
||||
}
|
||||
|
||||
@@ -117,49 +121,40 @@ class SyncServicePlugin : Plugin() {
|
||||
*/
|
||||
@PluginMethod
|
||||
fun setAppForeground(call: PluginCall) {
|
||||
MatrixSyncService.appInForeground = call.getBoolean("foreground", false) ?: false
|
||||
val foreground = call.getBoolean("foreground", false) ?: false
|
||||
MatrixSyncService.setAppInForeground(context, foreground)
|
||||
call.resolve()
|
||||
}
|
||||
|
||||
/** Returns whether the sync service is currently running. */
|
||||
@PluginMethod
|
||||
fun getStatus(call: PluginCall) {
|
||||
val am = context.getSystemService(Context.ACTIVITY_SERVICE)
|
||||
as android.app.ActivityManager
|
||||
@Suppress("DEPRECATION")
|
||||
val running = am.getRunningServices(Int.MAX_VALUE)
|
||||
.any { it.service.className == MatrixSyncService::class.java.name }
|
||||
val result = UnifiedPushManager.getStatus(context).apply { put("running", running) }
|
||||
call.resolve(result)
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the saved UnifiedPush distributor and opens the OS default-distributor
|
||||
* picker (`unifiedpush://link`), then re-registers on success.
|
||||
*/
|
||||
@PluginMethod
|
||||
fun requestDistributorSetup(call: PluginCall) {
|
||||
val currentActivity = activity
|
||||
?: return call.reject("Activity required to select a UnifiedPush distributor")
|
||||
UnifiedPushManager.requestDistributorSetup(context, currentActivity) { success ->
|
||||
call.resolve(JSObject().put("success", success))
|
||||
try {
|
||||
val result = JSObject()
|
||||
// The service runs in :listener, so its in-memory flag is not shared with this plugin process.
|
||||
val running =
|
||||
MatrixSyncService.hasCredentials(context) && MatrixSyncService.isListenerHealthy(context)
|
||||
result.put("running", running)
|
||||
result.put("listening", running)
|
||||
result.put("batteryIgnored", isBatteryIgnored(context))
|
||||
val notificationsAllowed =
|
||||
Build.VERSION.SDK_INT < 33 ||
|
||||
ContextCompat.checkSelfPermission(
|
||||
context,
|
||||
Manifest.permission.POST_NOTIFICATIONS,
|
||||
) == PackageManager.PERMISSION_GRANTED
|
||||
result.put("notificationsAllowed", notificationsAllowed)
|
||||
call.resolve(result)
|
||||
} catch (e: Exception) {
|
||||
call.reject("getStatus failed: ${e.message}", e)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves the Matrix push gateway for a UnifiedPush endpoint using native HTTP
|
||||
* so discovery is not blocked by missing CORS headers in the WebView.
|
||||
*/
|
||||
/** Asks Android to leave Paarrot out of battery optimization so the listener stays up. */
|
||||
@PluginMethod
|
||||
fun resolveUnifiedPushGateway(call: PluginCall) {
|
||||
val endpoint = call.getString("endpoint")
|
||||
?: return call.reject("endpoint required")
|
||||
Thread {
|
||||
val gateway = UnifiedPushManager.resolveMatrixGateway(endpoint)
|
||||
bridge?.executeOnMainThread {
|
||||
call.resolve(JSObject().put("gatewayUrl", gateway))
|
||||
}
|
||||
}.start()
|
||||
fun requestBatteryExemption(call: PluginCall) {
|
||||
val ignored = askBatteryExemption(context, activity)
|
||||
call.resolve(JSObject().put("ignored", ignored))
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -227,5 +222,39 @@ class SyncServicePlugin : Plugin() {
|
||||
|
||||
companion object {
|
||||
const val PREFS = "sync_service_prefs"
|
||||
|
||||
fun isBatteryIgnored(context: Context): Boolean {
|
||||
val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
|
||||
return pm.isIgnoringBatteryOptimizations(context.packageName)
|
||||
}
|
||||
|
||||
fun askBatteryExemption(context: Context, activity: Activity?): Boolean {
|
||||
if (isBatteryIgnored(context)) return true
|
||||
val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
|
||||
data = Uri.parse("package:${context.packageName}")
|
||||
}
|
||||
if (activity != null) {
|
||||
activity.startActivity(intent)
|
||||
} else {
|
||||
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
context.startActivity(intent)
|
||||
}
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
private fun askNotificationPermission() {
|
||||
if (Build.VERSION.SDK_INT < 33) return
|
||||
val act = activity ?: return
|
||||
if (ContextCompat.checkSelfPermission(act, Manifest.permission.POST_NOTIFICATIONS)
|
||||
== PackageManager.PERMISSION_GRANTED
|
||||
) {
|
||||
return
|
||||
}
|
||||
ActivityCompat.requestPermissions(
|
||||
act,
|
||||
arrayOf(Manifest.permission.POST_NOTIFICATIONS),
|
||||
4101,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,390 +0,0 @@
|
||||
package com.paarrot.app
|
||||
|
||||
import android.app.Activity
|
||||
import android.app.AlertDialog
|
||||
import android.app.AppOpsManager
|
||||
import android.content.Context
|
||||
import android.content.pm.PackageManager
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.Process
|
||||
import android.os.SystemClock
|
||||
import android.util.Log
|
||||
import com.getcapacitor.JSArray
|
||||
import com.getcapacitor.JSObject
|
||||
import org.json.JSONObject
|
||||
import org.unifiedpush.android.connector.FailedReason
|
||||
import org.unifiedpush.android.connector.INSTANCE_DEFAULT
|
||||
import org.unifiedpush.android.connector.UnifiedPush
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
|
||||
/** Coordinates UnifiedPush registration state and bridges events back to JS. */
|
||||
object UnifiedPushManager {
|
||||
private const val TAG = "UnifiedPushManager"
|
||||
private const val PREFS = "unifiedpush_prefs"
|
||||
private const val KEY_ENDPOINT = "endpoint"
|
||||
private const val KEY_INSTANCE = "instance"
|
||||
private const val KEY_LAST_FAILURE = "last_failure"
|
||||
private const val EVENT_NEW_ENDPOINT = "unifiedPushNewEndpoint"
|
||||
private const val EVENT_UNREGISTERED = "unifiedPushUnregistered"
|
||||
private const val EVENT_REGISTRATION_FAILED = "unifiedPushRegistrationFailed"
|
||||
private const val DEFAULT_MESSAGE = "Paarrot notifications"
|
||||
private const val REGISTER_DELAY_MS = 750L
|
||||
private const val IGNORE_UNREGISTER_MS = 2_500L
|
||||
const val DEFAULT_MATRIX_GATEWAY = "https://matrix.gateway.unifiedpush.org/_matrix/push/v1/notify"
|
||||
|
||||
private val mainHandler = Handler(Looper.getMainLooper())
|
||||
|
||||
@Volatile
|
||||
private var plugin: SyncServicePlugin? = null
|
||||
|
||||
@Volatile
|
||||
private var setupGeneration = 0
|
||||
|
||||
@Volatile
|
||||
private var ignoreUnregisteredUntilElapsed = 0L
|
||||
|
||||
fun setPlugin(plugin: SyncServicePlugin) {
|
||||
this.plugin = plugin
|
||||
}
|
||||
|
||||
fun clearPlugin(plugin: SyncServicePlugin) {
|
||||
if (this.plugin === plugin) {
|
||||
this.plugin = null
|
||||
}
|
||||
}
|
||||
|
||||
fun register(context: Context, activity: Activity?) {
|
||||
val savedDistributor = runCatching { UnifiedPush.getSavedDistributor(context) }.getOrNull().orEmpty()
|
||||
if (savedDistributor.isNotBlank()) {
|
||||
requestRegistration(context)
|
||||
return
|
||||
}
|
||||
|
||||
if (activity == null) {
|
||||
dispatchRegistrationFailed(FailedReason.ACTION_REQUIRED.name, INSTANCE_DEFAULT)
|
||||
return
|
||||
}
|
||||
|
||||
// Prefer an explicit in-app picker so the user always sees something;
|
||||
// tryUseDefaultDistributor is silent when only one distributor is installed.
|
||||
requestDistributorSetup(context, activity) { success ->
|
||||
if (!success) {
|
||||
dispatchRegistrationFailed(FailedReason.ACTION_REQUIRED.name, INSTANCE_DEFAULT)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows an in-app distributor picker, then registers after a short delay.
|
||||
*
|
||||
* Important: we intentionally avoid calling [UnifiedPush.removeDistributor] before the
|
||||
* user picks. That sent an UNREGISTER that could arrive *after* the new REGISTER and
|
||||
* wipe the fresh endpoint (looked like "found ntfy but never connects").
|
||||
*/
|
||||
fun requestDistributorSetup(context: Context, activity: Activity, onDone: (Boolean) -> Unit) {
|
||||
val gen = ++setupGeneration
|
||||
ignoreUnregisteredUntilElapsed = SystemClock.elapsedRealtime() + IGNORE_UNREGISTER_MS
|
||||
clearEndpoint(context)
|
||||
clearLastFailure(context)
|
||||
|
||||
val distributors = runCatching { UnifiedPush.getDistributors(context) }
|
||||
.getOrDefault(emptyList())
|
||||
Log.i(TAG, "Distributor setup: found=${distributors.joinToString()}")
|
||||
if (distributors.isEmpty()) {
|
||||
Log.w(TAG, "No UnifiedPush distributors installed")
|
||||
persistLastFailure(context, "NO_DISTRIBUTOR")
|
||||
dispatchRegistrationFailed(FailedReason.ACTION_REQUIRED.name, INSTANCE_DEFAULT)
|
||||
onDone(false)
|
||||
return
|
||||
}
|
||||
|
||||
val labels = distributors.map { packageName ->
|
||||
distributorLabel(context, packageName)
|
||||
}.toTypedArray()
|
||||
|
||||
// Guard against cancel + dismiss double-firing the callback.
|
||||
val finished = java.util.concurrent.atomic.AtomicBoolean(false)
|
||||
val finish: (Boolean) -> Unit = { success ->
|
||||
if (finished.compareAndSet(false, true)) onDone(success)
|
||||
}
|
||||
|
||||
activity.runOnUiThread {
|
||||
AlertDialog.Builder(activity)
|
||||
.setTitle("Choose push distributor")
|
||||
.setItems(labels) { _, which ->
|
||||
val chosen = distributors.getOrNull(which)
|
||||
if (chosen.isNullOrBlank()) {
|
||||
finish(false)
|
||||
return@setItems
|
||||
}
|
||||
activateDistributor(context, chosen, gen, finish)
|
||||
}
|
||||
.setNegativeButton(android.R.string.cancel) { _, _ -> finish(false) }
|
||||
.setOnCancelListener { finish(false) }
|
||||
.show()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves [chosen] as the distributor and registers after a delay so any prior
|
||||
* UNREGISTER from a distributor switch can settle first.
|
||||
*/
|
||||
private fun activateDistributor(
|
||||
context: Context,
|
||||
chosen: String,
|
||||
gen: Int,
|
||||
finish: (Boolean) -> Unit,
|
||||
) {
|
||||
ignoreUnregisteredUntilElapsed = SystemClock.elapsedRealtime() + IGNORE_UNREGISTER_MS
|
||||
val previous = runCatching { UnifiedPush.getSavedDistributor(context) }.getOrNull().orEmpty()
|
||||
Log.i(TAG, "Activating distributor=$chosen previous=$previous")
|
||||
|
||||
if (previous.isNotBlank() && previous != chosen) {
|
||||
runCatching { UnifiedPush.removeDistributor(context) }
|
||||
.onFailure { Log.w(TAG, "removeDistributor failed: ${it.message}") }
|
||||
}
|
||||
|
||||
mainHandler.postDelayed({
|
||||
if (gen != setupGeneration) {
|
||||
Log.w(TAG, "Skipping stale distributor activation gen=$gen current=$setupGeneration")
|
||||
finish(false)
|
||||
return@postDelayed
|
||||
}
|
||||
|
||||
runCatching { UnifiedPush.saveDistributor(context, chosen) }
|
||||
.onFailure {
|
||||
Log.w(TAG, "saveDistributor failed: ${it.message}")
|
||||
persistLastFailure(context, "SAVE_FAILED")
|
||||
finish(false)
|
||||
return@postDelayed
|
||||
}
|
||||
|
||||
val saved = runCatching { UnifiedPush.getSavedDistributor(context) }.getOrNull()
|
||||
if (saved != chosen) {
|
||||
Log.e(TAG, "Distributor not saved after saveDistributor (got=$saved)")
|
||||
persistLastFailure(context, "SAVE_NOT_PERSISTED")
|
||||
finish(false)
|
||||
return@postDelayed
|
||||
}
|
||||
|
||||
requestRegistration(context)
|
||||
// Report true once register was requested; JS polls for the endpoint.
|
||||
finish(true)
|
||||
|
||||
// One retry if the distributor is slow to ack.
|
||||
mainHandler.postDelayed({
|
||||
if (gen != setupGeneration) return@postDelayed
|
||||
if (!getEndpoint(context).isNullOrBlank()) return@postDelayed
|
||||
Log.w(TAG, "No endpoint yet after ${REGISTER_DELAY_MS}ms — retrying register")
|
||||
requestRegistration(context)
|
||||
|
||||
// OEM "App Boot" / AUTO_START can silently drop NEW_ENDPOINT (seen on TCL).
|
||||
mainHandler.postDelayed({
|
||||
if (gen != setupGeneration) return@postDelayed
|
||||
if (!getEndpoint(context).isNullOrBlank()) return@postDelayed
|
||||
val reason = if (isAutoStartRestricted(context)) {
|
||||
"AUTO_START_BLOCKED"
|
||||
} else {
|
||||
"NO_ENDPOINT"
|
||||
}
|
||||
Log.w(TAG, "Still no endpoint after register retries — $reason")
|
||||
persistLastFailure(context, reason)
|
||||
dispatchRegistrationFailed(reason, INSTANCE_DEFAULT)
|
||||
}, 4_000L)
|
||||
}, REGISTER_DELAY_MS)
|
||||
}, if (previous.isNotBlank() && previous != chosen) REGISTER_DELAY_MS else 150L)
|
||||
}
|
||||
|
||||
/** Human-readable label for a distributor package (falls back to package name). */
|
||||
private fun distributorLabel(context: Context, packageName: String): String {
|
||||
return try {
|
||||
val pm = context.packageManager
|
||||
val appInfo = pm.getApplicationInfo(packageName, 0)
|
||||
val label = pm.getApplicationLabel(appInfo)?.toString().orEmpty()
|
||||
if (label.isNotBlank() && label != packageName) "$label ($packageName)" else packageName
|
||||
} catch (_: PackageManager.NameNotFoundException) {
|
||||
packageName
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Discovers the Matrix push gateway for a UnifiedPush endpoint via native HTTP
|
||||
* (WebView `fetch` fails — ntfy responses omit CORS headers).
|
||||
*/
|
||||
fun resolveMatrixGateway(endpoint: String): String {
|
||||
return try {
|
||||
val endpointUrl = URL(endpoint)
|
||||
val discoveryUrl = URL(
|
||||
endpointUrl.protocol,
|
||||
endpointUrl.host,
|
||||
endpointUrl.port,
|
||||
"/_matrix/push/v1/notify",
|
||||
)
|
||||
val conn = discoveryUrl.openConnection() as HttpURLConnection
|
||||
try {
|
||||
conn.requestMethod = "GET"
|
||||
conn.connectTimeout = 4_000
|
||||
conn.readTimeout = 6_000
|
||||
conn.setRequestProperty("Accept", "application/json")
|
||||
if (conn.responseCode != 200) return DEFAULT_MATRIX_GATEWAY
|
||||
|
||||
val body = JSONObject(conn.inputStream.bufferedReader().readText())
|
||||
val gateway =
|
||||
body.optString("gateway").takeIf { it.isNotBlank() }
|
||||
?: body.optJSONObject("unifiedpush")?.optString("gateway")
|
||||
if (gateway == "matrix") discoveryUrl.toString() else DEFAULT_MATRIX_GATEWAY
|
||||
} finally {
|
||||
conn.disconnect()
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Matrix gateway discovery failed: ${e.message}")
|
||||
DEFAULT_MATRIX_GATEWAY
|
||||
}
|
||||
}
|
||||
|
||||
fun unregister(context: Context) {
|
||||
runCatching {
|
||||
UnifiedPush.unregister(context, INSTANCE_DEFAULT)
|
||||
}.onFailure {
|
||||
Log.w(TAG, "Failed to unregister UnifiedPush: ${it.message}")
|
||||
}
|
||||
val previousEndpoint = getEndpoint(context)
|
||||
clearEndpoint(context)
|
||||
dispatchUnregistered(previousEndpoint, INSTANCE_DEFAULT)
|
||||
}
|
||||
|
||||
fun getStatus(context: Context): JSObject {
|
||||
val status = JSObject()
|
||||
status.put("endpoint", getEndpoint(context) ?: "")
|
||||
status.put("instance", getInstance(context) ?: INSTANCE_DEFAULT)
|
||||
status.put("registered", !getEndpoint(context).isNullOrBlank())
|
||||
status.put("distributor", runCatching { UnifiedPush.getSavedDistributor(context) }.getOrDefault(""))
|
||||
status.put("lastFailure", getLastFailure(context) ?: "")
|
||||
status.put("autoStartBlocked", isAutoStartRestricted(context))
|
||||
val distributors = JSArray()
|
||||
runCatching { UnifiedPush.getDistributors(context) }
|
||||
.getOrDefault(emptyList())
|
||||
.forEach { distributors.put(it) }
|
||||
status.put("distributors", distributors)
|
||||
return status
|
||||
}
|
||||
|
||||
/**
|
||||
* TCL / some OEMs expose an AUTO_START app-op. When it is not MODE_ALLOWED,
|
||||
* [AppBootManager] drops distributor broadcasts such as NEW_ENDPOINT, so
|
||||
* UnifiedPush never finishes registering even though ntfy is selected.
|
||||
*/
|
||||
private fun isAutoStartRestricted(context: Context): Boolean {
|
||||
return try {
|
||||
val appOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
|
||||
val mode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
|
||||
appOps.unsafeCheckOpNoThrow("android:auto_start", Process.myUid(), context.packageName)
|
||||
} else {
|
||||
@Suppress("DEPRECATION")
|
||||
appOps.checkOpNoThrow("android:auto_start", Process.myUid(), context.packageName)
|
||||
}
|
||||
mode != AppOpsManager.MODE_ALLOWED && mode != AppOpsManager.MODE_DEFAULT
|
||||
} catch (_: Exception) {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fun onNewEndpoint(context: Context, endpoint: String, instance: String) {
|
||||
Log.i(TAG, "onNewEndpoint instance=$instance endpoint=$endpoint")
|
||||
clearLastFailure(context)
|
||||
val previousEndpoint = getEndpoint(context)
|
||||
persistEndpoint(context, endpoint, instance)
|
||||
val payload = JSObject().apply {
|
||||
put("endpoint", endpoint)
|
||||
put("instance", instance)
|
||||
put("previousEndpoint", previousEndpoint ?: "")
|
||||
}
|
||||
dispatch(EVENT_NEW_ENDPOINT, payload)
|
||||
}
|
||||
|
||||
fun onRegistrationFailed(context: Context, reason: String, instance: String) {
|
||||
Log.w(TAG, "onRegistrationFailed reason=$reason instance=$instance")
|
||||
persistLastFailure(context, reason)
|
||||
dispatchRegistrationFailed(reason, instance)
|
||||
}
|
||||
|
||||
fun onUnregistered(context: Context, instance: String) {
|
||||
if (SystemClock.elapsedRealtime() < ignoreUnregisteredUntilElapsed) {
|
||||
Log.i(TAG, "Ignoring unregistered during setup window instance=$instance")
|
||||
return
|
||||
}
|
||||
Log.i(TAG, "onUnregistered instance=$instance")
|
||||
val previousEndpoint = getEndpoint(context)
|
||||
clearEndpoint(context)
|
||||
dispatchUnregistered(previousEndpoint, instance)
|
||||
}
|
||||
|
||||
private fun requestRegistration(context: Context) {
|
||||
runCatching {
|
||||
Log.i(TAG, "Calling UnifiedPush.register instance=$INSTANCE_DEFAULT")
|
||||
UnifiedPush.register(context, INSTANCE_DEFAULT, DEFAULT_MESSAGE, null)
|
||||
}.onFailure {
|
||||
Log.w(TAG, "UnifiedPush register failed: ${it.message}")
|
||||
persistLastFailure(context, FailedReason.INTERNAL_ERROR.name)
|
||||
dispatchRegistrationFailed(FailedReason.INTERNAL_ERROR.name, INSTANCE_DEFAULT)
|
||||
}
|
||||
}
|
||||
|
||||
private fun dispatchUnregistered(previousEndpoint: String?, instance: String) {
|
||||
val payload = JSObject().apply {
|
||||
put("previousEndpoint", previousEndpoint ?: "")
|
||||
put("instance", instance)
|
||||
}
|
||||
dispatch(EVENT_UNREGISTERED, payload)
|
||||
}
|
||||
|
||||
private fun dispatchRegistrationFailed(reason: String, instance: String) {
|
||||
val payload = JSObject().apply {
|
||||
put("reason", reason)
|
||||
put("instance", instance)
|
||||
}
|
||||
dispatch(EVENT_REGISTRATION_FAILED, payload)
|
||||
}
|
||||
|
||||
private fun dispatch(eventName: String, payload: JSObject) {
|
||||
plugin?.emitUnifiedPushEvent(eventName, payload)
|
||||
}
|
||||
|
||||
private fun persistEndpoint(context: Context, endpoint: String, instance: String) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.putString(KEY_ENDPOINT, endpoint)
|
||||
.putString(KEY_INSTANCE, instance)
|
||||
.apply()
|
||||
}
|
||||
|
||||
private fun clearEndpoint(context: Context) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.remove(KEY_ENDPOINT)
|
||||
.remove(KEY_INSTANCE)
|
||||
.apply()
|
||||
}
|
||||
|
||||
private fun persistLastFailure(context: Context, reason: String) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.putString(KEY_LAST_FAILURE, reason)
|
||||
.apply()
|
||||
}
|
||||
|
||||
private fun clearLastFailure(context: Context) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.remove(KEY_LAST_FAILURE)
|
||||
.apply()
|
||||
}
|
||||
|
||||
private fun getLastFailure(context: Context): String? =
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(KEY_LAST_FAILURE, null)
|
||||
|
||||
private fun getEndpoint(context: Context): String? =
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(KEY_ENDPOINT, null)
|
||||
|
||||
private fun getInstance(context: Context): String? =
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(KEY_INSTANCE, null)
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
package com.paarrot.app
|
||||
|
||||
import android.util.Log
|
||||
import org.unifiedpush.android.connector.FailedReason
|
||||
import org.unifiedpush.android.connector.PushService
|
||||
import org.unifiedpush.android.connector.data.PushEndpoint
|
||||
import org.unifiedpush.android.connector.data.PushMessage
|
||||
|
||||
/** Receives UnifiedPush events and turns push messages into Matrix fetch wakes. */
|
||||
class UnifiedPushService : PushService() {
|
||||
|
||||
override fun onNewEndpoint(endpoint: PushEndpoint, instance: String) {
|
||||
Log.i(TAG, "UnifiedPush endpoint updated for instance=$instance")
|
||||
UnifiedPushManager.onNewEndpoint(applicationContext, endpoint.url, instance)
|
||||
}
|
||||
|
||||
override fun onMessage(message: PushMessage, instance: String) {
|
||||
Log.d(TAG, "UnifiedPush wake ping received for instance=$instance, bytes=${message.content.size}")
|
||||
MatrixSyncService.requestSyncFetch(applicationContext, "unifiedpush_message")
|
||||
}
|
||||
|
||||
override fun onRegistrationFailed(reason: FailedReason, instance: String) {
|
||||
Log.w(TAG, "UnifiedPush registration failed: $reason")
|
||||
UnifiedPushManager.onRegistrationFailed(applicationContext, reason.name, instance)
|
||||
}
|
||||
|
||||
override fun onUnregistered(instance: String) {
|
||||
Log.i(TAG, "UnifiedPush unregistered for instance=$instance")
|
||||
UnifiedPushManager.onUnregistered(applicationContext, instance)
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val TAG = "UnifiedPushService"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user