capacitor-push-signal 0.0.2 → 0.0.4

package/android/src/main/java/com/antonseagull/cap/push/signal/PushSignalCenter.kt

@@ -7,28 +7,61 @@ import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
 import android.os.Build
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.core.app.NotificationCompat
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
 import com.google.android.gms.tasks.Tasks
 import com.google.firebase.FirebaseApp
 import com.google.firebase.FirebaseOptions
 import com.google.firebase.messaging.FirebaseMessaging
 import com.google.firebase.messaging.RemoteMessage
+import java.net.HttpURLConnection
+import java.net.URL
 import java.util.Collections
 import java.util.UUID
 import java.util.WeakHashMap
 import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
 
 internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
   private const val EXTRA_HANDLED = "pushsignal.handled"
   private const val CHANNEL_ID = "push_signal_default"
+  private const val IMAGE_CONNECT_TIMEOUT_MS = 8_000
+  private const val IMAGE_READ_TIMEOUT_MS = 8_000
+  private const val IMAGE_MAX_BYTES = 5L * 1024L * 1024L
+
+  private const val TOKEN_TIMEOUT_SECONDS = 10L
+  private const val TOKEN_MAX_ATTEMPTS = 5
+  private const val TOKEN_INITIAL_RETRY_DELAY_MS = 1_000L
+  private const val TOKEN_MAX_RETRY_DELAY_MS = 8_000L
+
+  private const val PROVIDER_FCM = "fcm"
+  private const val PROVIDER_HMS = "hms"
+  private const val PROVIDER_MI_PUSH = "mi_push"
+  private const val PROVIDER_OPPO_PUSH = "oppo_push"
+  private const val PROVIDER_VIVO_PUSH = "vivo_push"
+  private const val PROVIDER_MEIZU_PUSH = "meizu_push"
+  private const val PROVIDER_UNKNOWN = "unknown"
+
+  /** Service apps used to positively confirm an alternative provider on the device. */
+  private const val PACKAGE_HMS = "com.huawei.hwid"
+  private const val PACKAGE_MI_PUSH = "com.xiaomi.xmsf"
+
+  private const val TAG = "PushSignal"
 
   private val lock = Any()
   private val mainHandler = Handler(Looper.getMainLooper())
+  private val notifyExecutor = Executors.newSingleThreadExecutor()
   @Volatile private var application: Application? = null
   @Volatile private var currentActivity: Activity? = null
   @Volatile private var onMessage: ((PushMessage) -> Unit)? = null
@@ -98,7 +131,9 @@ internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
 
   fun fetchToken(): String {
     val context = application
-      ?: throw IllegalStateException("PushSignal is not initialized")
+      ?: throw PushSignalException("E_NOT_INITIALIZED", "PushSignal is not initialized")
+
+    ensurePlayServices(context)
 
     try {
       if (FirebaseApp.getApps(context).isEmpty()) {
@@ -106,29 +141,229 @@ internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
       }
       FirebaseApp.getInstance()
     } catch (error: IllegalStateException) {
-      throw IllegalStateException(
+      throw PushSignalException(
+        "E_FIREBASE_CONFIG",
         "Firebase is not configured. Call initialize({ project_id, mobilesdk_app_id, current_key, project_number }) or add google-services.json.",
         error
       )
     }
 
-    val task = FirebaseMessaging.getInstance().token
-    val token = try {
-      Tasks.await(task)
-    } catch (error: Exception) {
-      throw IllegalStateException(
-        "Failed to get an FCM token. Call initialize({ project_id, mobilesdk_app_id, current_key, project_number }) or add google-services.json.",
-        error
-      )
-    }
+    val token = awaitTokenWithRetry(context)
 
     if (token.isNullOrEmpty()) {
-      throw IllegalStateException("Firebase returned an empty FCM token")
+      throw PushSignalException("E_FCM_TOKEN", "Firebase returned an empty FCM token")
     }
 
     return token
   }
 
+  /**
+   * Fails fast with an actionable message when Google Play services cannot serve FCM
+   * (for example a China-only ROM without GMS). The message names the provider the
+   * device should use instead, so the cause is obvious in JS logs.
+   */
+  private fun ensurePlayServices(context: Context) {
+    val status = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context)
+    if (status == ConnectionResult.SUCCESS) {
+      return
+    }
+
+    val code = when (status) {
+      ConnectionResult.SERVICE_MISSING -> "E_GMS_MISSING"
+      ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED -> "E_GMS_UPDATE_REQUIRED"
+      ConnectionResult.SERVICE_DISABLED -> "E_GMS_DISABLED"
+      ConnectionResult.SERVICE_INVALID -> "E_GMS_INVALID"
+      else -> "E_GMS_UNAVAILABLE"
+    }
+
+    val reason = when (status) {
+      ConnectionResult.SERVICE_MISSING ->
+        "Google Play services are missing on this device, so the standard Google push service (FCM) cannot be used."
+      ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED ->
+        "Google Play services are outdated. Update them in the Play Store and try again."
+      ConnectionResult.SERVICE_DISABLED ->
+        "Google Play services are disabled. Enable them in the device settings and try again."
+      ConnectionResult.SERVICE_INVALID ->
+        "Google Play services are invalid or corrupted on this device. Reinstalling them usually helps."
+      else ->
+        "Google Play services are unavailable (code $status), so the standard Google push service (FCM) cannot be used."
+    }
+
+    val diagnostics = diagnose(context)
+    val message = listOfNotNull(reason, diagnostics.hint).joinToString(" ")
+    Log.w(TAG, "Play services check failed ($code): $message")
+    throw PushSignalException(code, message)
+  }
+
+  /**
+   * Collects device and provider diagnostics without throwing. Used both by the
+   * `getDiagnostics` API and to enrich errors with a concrete replacement service.
+   */
+  fun diagnose(context: Context): PushDiagnostics {
+    val status = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context)
+    val gmsAvailable = status == ConnectionResult.SUCCESS
+    val provider = resolveProvider(context, gmsAvailable)
+    val hint = providerHint(provider, gmsAvailable)
+
+    return PushDiagnostics(
+      platform = "android",
+      gmsAvailable = gmsAvailable,
+      gmsStatus = status,
+      manufacturer = Build.MANUFACTURER ?: "",
+      brand = Build.BRAND ?: "",
+      model = Build.MODEL ?: "",
+      provider = provider.id,
+      providerName = provider.name,
+      providerInstalled = provider.installed,
+      hint = hint,
+    )
+  }
+
+  private data class ProviderInfo(
+    val id: String,
+    val name: String,
+    val installed: Boolean?,
+  )
+
+  /**
+   * Picks the push provider this device should use. Checks the standard Google
+   * service first, then positively confirms an installed alternative, then falls
+   * back to the manufacturer mapping. Class reflection cannot see another
+   * provider's SDK unless the host bundles it, so package checks and the
+   * manufacturer are the reliable signals.
+   */
+  private fun resolveProvider(context: Context, gmsAvailable: Boolean): ProviderInfo {
+    if (gmsAvailable) {
+      return ProviderInfo(PROVIDER_FCM, "Firebase Cloud Messaging (FCM)", true)
+    }
+
+    if (isPackageInstalled(context, PACKAGE_HMS)) {
+      return ProviderInfo(PROVIDER_HMS, "HMS Push Kit (Huawei Push)", true)
+    }
+    if (isPackageInstalled(context, PACKAGE_MI_PUSH)) {
+      return ProviderInfo(PROVIDER_MI_PUSH, "Mi Push (Xiaomi Push)", true)
+    }
+
+    val keys = setOf(Build.MANUFACTURER, Build.BRAND)
+      .filterNotNull()
+      .map { it.uppercase() }
+
+    return when {
+      keys.any { it.contains("HUAWEI") || it.contains("HONOR") } ->
+        ProviderInfo(PROVIDER_HMS, "HMS Push Kit (Huawei Push)", false)
+      keys.any { it.contains("XIAOMI") || it.contains("REDMI") || it.contains("POCO") } ->
+        ProviderInfo(PROVIDER_MI_PUSH, "Mi Push (Xiaomi Push)", false)
+      keys.any { it.contains("OPPO") || it.contains("ONEPLUS") || it.contains("REALME") } ->
+        ProviderInfo(PROVIDER_OPPO_PUSH, "OPPO Push (HeyTap)", false)
+      keys.any { it.contains("VIVO") || it.contains("IQOO") } ->
+        ProviderInfo(PROVIDER_VIVO_PUSH, "vivo Push", false)
+      keys.any { it.contains("MEIZU") } ->
+        ProviderInfo(PROVIDER_MEIZU_PUSH, "Meizu Push", false)
+      else ->
+        ProviderInfo(PROVIDER_UNKNOWN, "unknown", null)
+    }
+  }
+
+  private fun providerHint(provider: ProviderInfo, gmsAvailable: Boolean): String? {
+    if (gmsAvailable) {
+      return null
+    }
+    val device = listOfNotNull(Build.MANUFACTURER, Build.BRAND)
+      .filter { it.isNotBlank() }
+      .distinct()
+      .joinToString("/")
+
+    return when (provider.id) {
+      PROVIDER_HMS ->
+        "This device ($device) has no usable Google Play services, so FCM will not issue a token. Use HMS Push Kit (Huawei Push) instead of the standard Google service."
+      PROVIDER_MI_PUSH ->
+        "This device ($device) has no usable Google Play services, so FCM will not issue a token. Use Mi Push (Xiaomi Push) instead of the standard Google service."
+      PROVIDER_OPPO_PUSH ->
+        "This device ($device) has no usable Google Play services, so FCM will not issue a token. Use OPPO Push (HeyTap) instead of the standard Google service."
+      PROVIDER_VIVO_PUSH ->
+        "This device ($device) has no usable Google Play services, so FCM will not issue a token. Use vivo Push instead of the standard Google service."
+      PROVIDER_MEIZU_PUSH ->
+        "This device ($device) has no usable Google Play services, so FCM will not issue a token. Use Meizu Push instead of the standard Google service."
+      else ->
+        "No usable Google Play services were found and no known push provider was detected on this ROM, so FCM cannot be used. Integrate another push provider (HMS, Mi Push, OPPO/vivo/Meizu Push)."
+    }
+  }
+
+  private fun isPackageInstalled(context: Context, packageName: String): Boolean {
+    return try {
+      context.packageManager.getPackageInfo(packageName, 0)
+      true
+    } catch (_: PackageManager.NameNotFoundException) {
+      false
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  /**
+   * FCM returns SERVICE_NOT_AVAILABLE for transient conditions (no Google account yet,
+   * Play services still starting, flaky network). Xiaomi/MIUI devices hit this often,
+   * so retry with backoff before surfacing the failure.
+   */
+  private fun awaitTokenWithRetry(context: Context): String? {
+    var delayMs = TOKEN_INITIAL_RETRY_DELAY_MS
+    var lastError: Exception? = null
+
+    for (attempt in 1..TOKEN_MAX_ATTEMPTS) {
+      try {
+        return Tasks.await(
+          FirebaseMessaging.getInstance().token,
+          TOKEN_TIMEOUT_SECONDS,
+          TimeUnit.SECONDS
+        )
+      } catch (error: Exception) {
+        lastError = error
+        if (attempt == TOKEN_MAX_ATTEMPTS || !isRetryableTokenError(error)) {
+          break
+        }
+        Log.w(TAG, "FCM token attempt $attempt/$TOKEN_MAX_ATTEMPTS failed: ${error.message}. Retrying in ${delayMs}ms")
+        try {
+          Thread.sleep(delayMs)
+        } catch (_: InterruptedException) {
+          Thread.currentThread().interrupt()
+          break
+        }
+        delayMs = (delayMs * 2).coerceAtMost(TOKEN_MAX_RETRY_DELAY_MS)
+      }
+    }
+
+    val cause = lastError
+    val diagnostics = diagnose(context)
+    val message = listOfNotNull(
+      "Failed to get an FCM token: ${cause?.message ?: "unknown error"}.",
+      "Make sure the device is signed into a Google account, Google Play services are up to date, " +
+        "and the app is allowed to use background data.",
+      "Call initialize({ project_id, mobilesdk_app_id, current_key, project_number }) or add google-services.json.",
+      diagnostics.hint,
+    ).joinToString(" ")
+    Log.w(TAG, "Failed to get an FCM token: $message")
+    throw PushSignalException("E_FCM_TOKEN", message, cause)
+  }
+
+  private fun isRetryableTokenError(error: Throwable): Boolean {
+    var current: Throwable? = error
+    while (current != null) {
+      if (current is java.io.IOException || current is java.util.concurrent.TimeoutException) {
+        return true
+      }
+      val message = current.message?.uppercase() ?: ""
+      if (
+        message.contains("SERVICE_NOT_AVAILABLE") ||
+        message.contains("TIMEOUT") ||
+        message.contains("INTERNAL_SERVER_ERROR")
+      ) {
+        return true
+      }
+      current = current.cause
+    }
+    return false
+  }
+
   fun emitMessage(remoteMessage: RemoteMessage) {
     val message = remoteMessage.toPushMessage()
     runOnMain { deliverMessage(message) }
@@ -169,18 +404,7 @@ internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
     val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
       ?: return
 
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      val existing = manager.getNotificationChannel(CHANNEL_ID)
-      if (existing == null) {
-        manager.createNotificationChannel(
-          NotificationChannel(
-            CHANNEL_ID,
-            "Notifications",
-            NotificationManager.IMPORTANCE_HIGH
-          )
-        )
-      }
-    }
+    ensureChannel(manager)
 
     val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
       ?: return
@@ -188,6 +412,7 @@ internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
     launchIntent.putExtra("google.message_id", message.id ?: UUID.randomUUID().toString())
     message.title?.let { launchIntent.putExtra("gcm.notification.title", it) }
     message.body?.let { launchIntent.putExtra("gcm.notification.body", it) }
+    message.imageUrl?.let { launchIntent.putExtra("imageUrl", it) }
     message.data.forEach { (key, value) ->
       launchIntent.putExtra(key, value)
     }
@@ -200,6 +425,42 @@ internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
       PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
     )
 
+    val imageUrl = message.imageUrl
+    if (imageUrl.isNullOrBlank()) {
+      manager.notify(requestCode, buildNotification(context, message, pendingIntent, null))
+      return
+    }
+
+    notifyExecutor.execute {
+      val bitmap = downloadBitmap(imageUrl)
+      runOnMain {
+        manager.notify(requestCode, buildNotification(context, message, pendingIntent, bitmap))
+      }
+    }
+  }
+
+  private fun ensureChannel(manager: NotificationManager) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return
+    }
+    if (manager.getNotificationChannel(CHANNEL_ID) != null) {
+      return
+    }
+    manager.createNotificationChannel(
+      NotificationChannel(
+        CHANNEL_ID,
+        "Notifications",
+        NotificationManager.IMPORTANCE_HIGH
+      )
+    )
+  }
+
+  private fun buildNotification(
+    context: Context,
+    message: PushMessage,
+    pendingIntent: PendingIntent,
+    bitmap: Bitmap?,
+  ): android.app.Notification {
     val builder = NotificationCompat.Builder(context, CHANNEL_ID)
       .setSmallIcon(smallIcon(context))
       .setContentTitle(message.title.orEmpty())
@@ -210,7 +471,48 @@ internal object PushSignalCenter : Application.ActivityLifecycleCallbacks {
       .setDefaults(NotificationCompat.DEFAULT_SOUND)
       .setNumber(1)
 
-    manager.notify(requestCode, builder.build())
+    if (bitmap != null) {
+      builder
+        .setLargeIcon(bitmap)
+        .setStyle(
+          NotificationCompat.BigPictureStyle()
+            .bigPicture(bitmap)
+            .bigLargeIcon(null as Bitmap?)
+        )
+    }
+
+    return builder.build()
+  }
+
+  private fun downloadBitmap(imageUrl: String): Bitmap? {
+    var connection: HttpURLConnection? = null
+    return try {
+      connection = (URL(imageUrl).openConnection() as HttpURLConnection).apply {
+        connectTimeout = IMAGE_CONNECT_TIMEOUT_MS
+        readTimeout = IMAGE_READ_TIMEOUT_MS
+        instanceFollowRedirects = true
+        requestMethod = "GET"
+      }
+      val code = connection.responseCode
+      if (code !in 200..299) {
+        return null
+      }
+      val length = connection.contentLengthLong
+      if (length > IMAGE_MAX_BYTES) {
+        return null
+      }
+      connection.inputStream.use { input ->
+        val bytes = input.readBytes()
+        if (bytes.size > IMAGE_MAX_BYTES) {
+          return null
+        }
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+      }
+    } catch (_: Exception) {
+      null
+    } finally {
+      connection?.disconnect()
+    }
   }
 
   private fun smallIcon(context: Context): Int {
@@ -374,7 +676,8 @@ private fun Intent.toPushMessage(): PushMessage {
     extras.getString("gcm.n.body")
       ?: extras.getString("gcm.notification.body")
       ?: extras.getString("body"),
-    data
+    data,
+    resolveImageUrl(null, data),
   )
 }
 
@@ -387,11 +690,18 @@ private fun AndroidFirebaseConfig.hasRequiredFields(): Boolean {
 
 private const val EXTRA_HANDLED_KEY = "pushsignal.handled"
 
+internal fun resolveImageUrl(notificationImageUrl: String?, data: Map<String, String>): String? {
+  return notificationImageUrl?.takeIf { it.isNotBlank() }
+    ?: data["image"]?.takeIf { it.isNotBlank() }
+    ?: data["imageUrl"]?.takeIf { it.isNotBlank() }
+}
+
 internal fun RemoteMessage.toPushMessage(): PushMessage {
   return PushMessage(
     messageId,
     notification?.title,
     notification?.body,
-    data
+    data,
+    resolveImageUrl(notification?.imageUrl?.toString(), data),
   )
 }

package/android/src/main/java/com/antonseagull/cap/push/signal/PushSignalPlugin.kt

@@ -50,7 +50,8 @@ class PushSignalPlugin : Plugin() {
       if (error == null) {
         call.resolve()
       } else {
-        call.reject(error.message, error)
+        val code = (error as? PushSignalException)?.code ?: "E_INIT"
+        call.reject(error.message, code, error, diagnosticsData())
       }
     }
   }
@@ -63,18 +64,38 @@ class PushSignalPlugin : Plugin() {
         val token = PushSignalCenter.fetchToken()
         val result =
           JSObject().apply {
-            put("platform", "android")
             put("token", token)
           }
         call.resolve(result)
       } catch (error: Exception) {
-        call.reject(error.message, error)
+        val code = (error as? PushSignalException)?.code ?: "E_CREDENTIALS"
+        call.reject(error.message, code, error, diagnosticsData())
       }
     }
   }
 
   @PluginMethod
-  fun checkPermissions(call: PluginCall) {
+  fun getDiagnostics(call: PluginCall) {
+    executor.execute {
+      try {
+        PushSignalCenter.attach(context)
+        call.resolve(PushSignalCenter.diagnose(context).toJSObject())
+      } catch (error: Exception) {
+        call.reject(error.message, "E_DIAGNOSTICS", error)
+      }
+    }
+  }
+
+  private fun diagnosticsData(): JSObject? {
+    return try {
+      PushSignalCenter.diagnose(context).toJSObject()
+    } catch (_: Exception) {
+      null
+    }
+  }
+
+  @PluginMethod
+  override fun checkPermissions(call: PluginCall) {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
       val result = JSObject()
       result.put("receive", "granted")
@@ -85,7 +106,7 @@ class PushSignalPlugin : Plugin() {
   }
 
   @PluginMethod
-  fun requestPermissions(call: PluginCall) {
+  override fun requestPermissions(call: PluginCall) {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
       getPermissionState(PUSH_NOTIFICATIONS) == PermissionState.GRANTED
     ) {
@@ -122,6 +143,7 @@ private fun PushMessage.toJSObject(): JSObject {
   id?.let { map.put("id", it) }
   title?.let { map.put("title", it) }
   body?.let { map.put("body", it) }
+  imageUrl?.let { map.put("imageUrl", it) }
   val dataMap = JSObject()
   data.forEach { (key, value) ->
     dataMap.put(key, value)
@@ -129,3 +151,18 @@ private fun PushMessage.toJSObject(): JSObject {
   map.put("data", dataMap)
   return map
 }
+
+private fun PushDiagnostics.toJSObject(): JSObject {
+  val map = JSObject()
+  map.put("platform", platform)
+  map.put("gmsAvailable", gmsAvailable)
+  map.put("gmsStatus", gmsStatus)
+  map.put("manufacturer", manufacturer)
+  map.put("brand", brand)
+  map.put("model", model)
+  map.put("provider", provider)
+  map.put("providerName", providerName)
+  providerInstalled?.let { map.put("providerInstalled", it) }
+  hint?.let { map.put("hint", it) }
+  return map
+}