react-native-qpush 0.0.0-stage → 1.0.0

package/android/src/main/java/com/qpush/reactnative/QPushNotificationRenderer.kt

@@ -0,0 +1,256 @@
+package com.qpush.reactnative
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.media.RingtoneManager
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import java.util.Random
+
+/** Builds and posts notifications for QPush payloads (NotificationCompat). */
+internal object QPushNotificationRenderer {
+  const val DEFAULT_CHANNEL_ID = "qpush_default"
+  const val NOTIFICATION_TAG = "qpush"
+  const val EXTRA_QPUSH_ID = "qpush_id"
+
+  // Trampoline intent extras.
+  const val EXTRA_PAYLOAD = "qpush_payload"
+  const val EXTRA_ACTION_ID = "qpush_action_id"
+  const val EXTRA_NOTIFICATION_ID = "qpush_android_notification_id"
+
+  private const val DEFAULT_SMALL_ICON = "ic_stat_qpush_default"
+  private const val META_DEFAULT_ACCENT_COLOR = "com.qpush.NotificationAccentColor.DEFAULT"
+  private const val LARGE_ICON_SIZE = 256
+  private const val BIG_PICTURE_SIZE = 1440
+
+  private val random = Random()
+
+  /** Renders the notification. Blocking (downloads images): call off the main thread. */
+  fun render(context: Context, payload: QPushPayload) {
+    val appContext = context.applicationContext
+    if (payload.isSilent) {
+      QPushLog.d("Notification ${payload.id} has no visible content, not displayed")
+      return
+    }
+    val manager = NotificationManagerCompat.from(appContext)
+    if (!manager.areNotificationsEnabled()) {
+      QPushLog.i("Notifications are disabled, ${payload.id} not displayed")
+      return
+    }
+
+    val channelId = ensureChannel(appContext, payload.channelId)
+    val notificationId = payload.androidNotificationId
+    val builder = NotificationCompat.Builder(appContext, channelId)
+      .setSmallIcon(resolveSmallIcon(appContext, payload.smallIcon))
+      .setAutoCancel(true)
+      .setShowWhen(true)
+      .setWhen(System.currentTimeMillis())
+      .setPriority(mapPriority(payload.priority))
+      .setContentIntent(openIntent(appContext, payload, null, notificationId))
+      .addExtras(Bundle().apply { putString(EXTRA_QPUSH_ID, payload.id) })
+
+    payload.title?.let { builder.setContentTitle(it) }
+    payload.body?.let { builder.setContentText(it) }
+
+    resolveAccentColor(appContext, payload.accentColor)?.let { builder.setColor(it) }
+    mapVisibility(payload.visibility)?.let { builder.setVisibility(it) }
+    payload.group?.let { builder.setGroup(it) }
+
+    // Sound / vibration (pre-Oreo; on Android 8+ the channel decides).
+    val sound = resolveSound(appContext, payload.sound)
+    if (sound != null) {
+      builder.setSound(sound)
+      builder.setDefaults(NotificationCompat.DEFAULT_VIBRATE or NotificationCompat.DEFAULT_LIGHTS)
+    } else {
+      builder.setDefaults(NotificationCompat.DEFAULT_ALL)
+    }
+
+    val largeIcon: Bitmap? = QPushImages.load(appContext, payload.largeIcon, LARGE_ICON_SIZE)
+    largeIcon?.let { builder.setLargeIcon(it) }
+
+    val bigPicture: Bitmap? = payload.image?.let { QPushImages.load(appContext, it, BIG_PICTURE_SIZE) }
+    if (bigPicture != null) {
+      val style = NotificationCompat.BigPictureStyle().bigPicture(bigPicture)
+      payload.title?.let { style.setBigContentTitle(it) }
+      payload.body?.let { style.setSummaryText(it) }
+      if (largeIcon != null) style.bigLargeIcon(null as Bitmap?)
+      builder.setStyle(style)
+      if (largeIcon == null) builder.setLargeIcon(bigPicture)
+    } else if (!payload.body.isNullOrEmpty()) {
+      builder.setStyle(NotificationCompat.BigTextStyle().bigText(payload.body))
+    }
+
+    for (button in payload.buttons.take(3)) {
+      val icon = QPushImages.resourceId(appContext, button.icon)
+      builder.addAction(
+        NotificationCompat.Action.Builder(icon, button.text, openIntent(appContext, payload, button.id, notificationId))
+          .build(),
+      )
+    }
+
+    try {
+      manager.notify(NOTIFICATION_TAG, notificationId, builder.build())
+      payload.group?.let { postGroupSummary(appContext, it, channelId, payload) }
+      QPushLog.d("Displayed notification ${payload.id}")
+    } catch (e: SecurityException) {
+      // POST_NOTIFICATIONS revoked between the check and notify().
+      QPushLog.w("Not allowed to post notifications", e)
+    }
+  }
+
+  /** Android 7+ only groups notifications that have a summary. */
+  private fun postGroupSummary(context: Context, group: String, channelId: String, payload: QPushPayload) {
+    if (Build.VERSION.SDK_INT < 24) return
+    val summary = NotificationCompat.Builder(context, channelId)
+      .setSmallIcon(resolveSmallIcon(context, payload.smallIcon))
+      .setGroup(group)
+      .setGroupSummary(true)
+      .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
+      .setAutoCancel(true)
+      .setContentIntent(openIntent(context, null, null, null))
+    resolveAccentColor(context, payload.accentColor)?.let { summary.setColor(it) }
+    try {
+      NotificationManagerCompat.from(context).notify(NOTIFICATION_TAG, groupSummaryId(group), summary.build())
+    } catch (e: SecurityException) {
+      QPushLog.w("Not allowed to post the group summary", e)
+    }
+  }
+
+  fun groupSummaryId(group: String): Int = "group:$group".hashCode()
+
+  private fun openIntent(context: Context, payload: QPushPayload?, actionId: String?, notificationId: Int?): PendingIntent {
+    val intent = Intent(context, QPushNotificationOpenActivity::class.java).apply {
+      addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_ANIMATION)
+      payload?.let { putExtra(EXTRA_PAYLOAD, it.raw) }
+      actionId?.let { putExtra(EXTRA_ACTION_ID, it) }
+      notificationId?.let { putExtra(EXTRA_NOTIFICATION_ID, it) }
+    }
+    var flags = PendingIntent.FLAG_UPDATE_CURRENT
+    if (Build.VERSION.SDK_INT >= 23) flags = flags or PendingIntent.FLAG_IMMUTABLE
+    return PendingIntent.getActivity(context, random.nextInt(), intent, flags)
+  }
+
+  /** Returns a usable channel id, creating `qpush_default` when needed. */
+  fun ensureChannel(context: Context, requested: String?): String {
+    if (Build.VERSION.SDK_INT < 26) return requested ?: DEFAULT_CHANNEL_ID
+    val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (requested != null) {
+      if (manager.getNotificationChannel(requested) != null) return requested
+      QPushLog.w("Notification channel \"$requested\" does not exist, using $DEFAULT_CHANNEL_ID")
+    }
+    if (manager.getNotificationChannel(DEFAULT_CHANNEL_ID) == null) {
+      val channel = NotificationChannel(
+        DEFAULT_CHANNEL_ID,
+        context.getString(R.string.qpush_default_channel_name),
+        NotificationManager.IMPORTANCE_HIGH,
+      )
+      channel.enableVibration(true)
+      manager.createNotificationChannel(channel)
+    }
+    return DEFAULT_CHANNEL_ID
+  }
+
+  /** Payload icon -> `ic_stat_qpush_default` -> app icon. */
+  fun resolveSmallIcon(context: Context, name: String?): Int {
+    QPushImages.resourceId(context, name).takeIf { it != 0 }?.let { return it }
+    QPushImages.resourceId(context, DEFAULT_SMALL_ICON).takeIf { it != 0 }?.let { return it }
+    val appIcon = context.applicationInfo.icon
+    return if (appIcon != 0) appIcon else android.R.drawable.ic_dialog_info
+  }
+
+  /** `FF0070F3`, `#0070F3`, ... -> ARGB int. */
+  fun parseColor(value: String?): Int? {
+    if (value.isNullOrBlank()) return null
+    var hex = value.trim().removePrefix("#")
+    if (hex.length == 6) hex = "FF$hex"
+    if (hex.length != 8) return null
+    return hex.toLongOrNull(16)?.toInt()
+  }
+
+  private fun resolveAccentColor(context: Context, value: String?): Int? =
+    parseColor(value) ?: parseColor(QPushStore.manifestString(context, META_DEFAULT_ACCENT_COLOR))
+
+  private fun resolveSound(context: Context, name: String?): Uri? {
+    if (name.isNullOrBlank()) return null
+    if (name.equals("default", ignoreCase = true)) {
+      return RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
+    }
+    val resourceName = name.substringBeforeLast('.')
+    @Suppress("DiscouragedApi")
+    val id = context.resources.getIdentifier(resourceName, "raw", context.packageName)
+    if (id == 0) return null
+    return Uri.parse("${ContentResolver.SCHEME_ANDROID_RESOURCE}://${context.packageName}/$id")
+  }
+
+  /** 10 -> high, 5 -> default (protocol). */
+  private fun mapPriority(priority: Int?): Int = when {
+    priority == null -> NotificationCompat.PRIORITY_HIGH
+    priority >= 9 -> NotificationCompat.PRIORITY_HIGH
+    priority >= 5 -> NotificationCompat.PRIORITY_DEFAULT
+    priority >= 1 -> NotificationCompat.PRIORITY_LOW
+    else -> NotificationCompat.PRIORITY_MIN
+  }
+
+  /** 1 public, 0 private, -1 secret. */
+  private fun mapVisibility(visibility: Int?): Int? = when (visibility) {
+    1 -> NotificationCompat.VISIBILITY_PUBLIC
+    0 -> NotificationCompat.VISIBILITY_PRIVATE
+    -1 -> NotificationCompat.VISIBILITY_SECRET
+    else -> null
+  }
+
+  // ---------------------------------------------------------------------------
+  // Removal
+  // ---------------------------------------------------------------------------
+
+  fun clearAll(context: Context) {
+    val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (Build.VERSION.SDK_INT >= 23) {
+      for (notification in manager.activeNotifications) {
+        if (notification.tag == NOTIFICATION_TAG) manager.cancel(notification.tag, notification.id)
+      }
+    } else {
+      manager.cancelAll()
+    }
+  }
+
+  fun remove(context: Context, qpushId: String) {
+    val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (Build.VERSION.SDK_INT >= 23) {
+      for (notification in manager.activeNotifications) {
+        if (notification.tag == NOTIFICATION_TAG &&
+          notification.notification.extras?.getString(EXTRA_QPUSH_ID) == qpushId
+        ) {
+          manager.cancel(notification.tag, notification.id)
+        }
+      }
+    } else {
+      manager.cancel(NOTIFICATION_TAG, qpushId.hashCode())
+    }
+  }
+
+  fun removeGroup(context: Context, group: String) {
+    val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (Build.VERSION.SDK_INT >= 23) {
+      for (notification in manager.activeNotifications) {
+        if (notification.tag == NOTIFICATION_TAG && notification.notification.group == group) {
+          manager.cancel(notification.tag, notification.id)
+        }
+      }
+    } else {
+      manager.cancel(NOTIFICATION_TAG, groupSummaryId(group))
+    }
+  }
+
+  fun cancel(context: Context, notificationId: Int) {
+    NotificationManagerCompat.from(context).cancel(NOTIFICATION_TAG, notificationId)
+  }
+}

package/android/src/main/java/com/qpush/reactnative/QPushPayload.kt

@@ -0,0 +1,114 @@
+package com.qpush.reactnative
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Action button of a QPush notification. */
+internal data class QPushButton(
+  val id: String,
+  val text: String,
+  val icon: String?,
+  val url: String?,
+)
+
+/**
+ * Decoded `data["qpush"]` JSON (see docs/sdk-protocol.md, "Push payloads").
+ * Missing keys are `null` and mean "use the default".
+ */
+internal data class QPushPayload(
+  val id: String,
+  val title: String?,
+  val body: String?,
+  val image: String?,
+  val largeIcon: String?,
+  val smallIcon: String?,
+  val accentColor: String?,
+  val sound: String?,
+  val channelId: String?,
+  val priority: Int?,
+  val group: String?,
+  val collapseId: String?,
+  val visibility: Int?,
+  val url: String?,
+  val buttons: List<QPushButton>,
+  /** The original JSON string, forwarded untouched to JS. */
+  val raw: String,
+) {
+  /** Data-only payload without visible content (nothing to render). */
+  val isSilent: Boolean
+    get() = title.isNullOrEmpty() && body.isNullOrEmpty() && image.isNullOrEmpty()
+
+  /** Id used with NotificationManager: notifications sharing a collapse_id replace each other. */
+  val androidNotificationId: Int
+    get() = (collapseId ?: id).hashCode()
+
+  fun buttonUrl(actionId: String?): String? =
+    if (actionId == null) null else buttons.firstOrNull { it.id == actionId }?.url
+
+  companion object {
+    fun parse(raw: String?): QPushPayload? {
+      if (raw.isNullOrEmpty()) return null
+      val json = try {
+        JSONObject(raw)
+      } catch (e: Exception) {
+        QPushLog.w("Invalid qpush payload", e)
+        return null
+      }
+      val id = json.string("id") ?: return null
+      return QPushPayload(
+        id = id,
+        title = json.string("title"),
+        body = json.string("body"),
+        image = json.string("image"),
+        largeIcon = json.string("large_icon"),
+        smallIcon = json.string("small_icon"),
+        accentColor = json.string("accent_color"),
+        sound = json.string("sound"),
+        channelId = json.string("channel_id"),
+        priority = json.int("priority"),
+        group = json.string("group"),
+        collapseId = json.string("collapse_id"),
+        visibility = json.int("visibility"),
+        url = json.string("url"),
+        buttons = parseButtons(json.opt("buttons")),
+        raw = raw,
+      )
+    }
+
+    private fun parseButtons(value: Any?): List<QPushButton> {
+      val array = when (value) {
+        is JSONArray -> value
+        is String -> try {
+          JSONArray(value)
+        } catch (e: Exception) {
+          return emptyList()
+        }
+        else -> return emptyList()
+      }
+      val buttons = ArrayList<QPushButton>()
+      for (i in 0 until array.length()) {
+        val entry = array.optJSONObject(i) ?: continue
+        val id = entry.string("id") ?: continue
+        val text = entry.string("text") ?: continue
+        buttons.add(QPushButton(id, text, entry.string("icon"), entry.string("url")))
+      }
+      return buttons
+    }
+
+    /** `optString` returns "null" for JSON null and "" for missing keys; normalize both to null. */
+    private fun JSONObject.string(key: String): String? {
+      if (!has(key) || isNull(key)) return null
+      val value = opt(key)?.toString() ?: return null
+      return if (value.isEmpty()) null else value
+    }
+
+    private fun JSONObject.int(key: String): Int? {
+      if (!has(key) || isNull(key)) return null
+      return when (val value = opt(key)) {
+        is Number -> value.toInt()
+        is String -> value.trim().toDoubleOrNull()?.toInt()
+        else -> null
+      }
+    }
+  }
+}