react-native-qpush 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,368 @@
+package com.qpush.reactnative
+
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.core.app.ActivityCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+
+/**
+ * Native module `QPushPush`. The user / subscription / HTTP state machine
+ * lives in TypeScript; this module only does what must be native: storage,
+ * FCM token, permission, notifications and events.
+ */
+class QPushPushModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+
+  companion object {
+    const val NAME = "QPushPush"
+    private const val POST_NOTIFICATIONS = "android.permission.POST_NOTIFICATIONS"
+    private const val PERMISSION_REQUEST_CODE = 0xBEAC
+  }
+
+  /** Callbacks waiting for the app to come back to the foreground (settings screen, permission dialog). */
+  private val resumeWaiters = ArrayList<() -> Unit>()
+
+  init {
+    reactContext.addLifecycleEventListener(this)
+    QPushEventBus.attach(this)
+    if (reactContext.hasCurrentActivity()) QPushEventBus.hostResumed = true
+  }
+
+  override fun getName(): String = NAME
+
+  override fun invalidate() {
+    QPushEventBus.detach(this)
+    reactContext.removeLifecycleEventListener(this)
+    super.invalidate()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+
+  internal fun canEmit(): Boolean = reactContext.hasActiveReactInstance()
+
+  internal fun sendEvent(name: String, body: Map<String, Any?>) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(name, toWritableMap(body))
+  }
+
+  private fun toWritableMap(body: Map<String, Any?>): WritableMap {
+    val map = Arguments.createMap()
+    for ((key, value) in body) {
+      when (value) {
+        null -> map.putNull(key)
+        is String -> map.putString(key, value)
+        is Boolean -> map.putBoolean(key, value)
+        is Int -> map.putInt(key, value)
+        is Long -> map.putDouble(key, value.toDouble())
+        is Double -> map.putDouble(key, value)
+        is Float -> map.putDouble(key, value.toDouble())
+        else -> map.putString(key, value.toString())
+      }
+    }
+    return map
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    // Required by NativeEventEmitter.
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // Required by NativeEventEmitter.
+  }
+
+  @ReactMethod
+  fun setJsReady() {
+    QPushEventBus.setJsReady()
+  }
+
+  @ReactMethod
+  fun displayForegroundNotification(displayId: String) {
+    QPushEventBus.display(displayId)
+  }
+
+  @ReactMethod
+  fun preventForegroundDisplay(displayId: String) {
+    QPushEventBus.prevent(displayId)
+  }
+
+  // ---------------------------------------------------------------------------
+  // LifecycleEventListener
+  // ---------------------------------------------------------------------------
+
+  override fun onHostResume() {
+    QPushEventBus.hostResumed = true
+    val waiters: List<() -> Unit>
+    synchronized(resumeWaiters) {
+      waiters = ArrayList(resumeWaiters)
+      resumeWaiters.clear()
+    }
+    for (waiter in waiters) {
+      try {
+        waiter()
+      } catch (e: Exception) {
+        QPushLog.e("Resume callback failed", e)
+      }
+    }
+  }
+
+  override fun onHostPause() {
+    QPushEventBus.hostResumed = false
+  }
+
+  override fun onHostDestroy() {
+    QPushEventBus.hostResumed = false
+  }
+
+  private fun onNextResume(callback: () -> Unit) {
+    synchronized(resumeWaiters) { resumeWaiters.add(callback) }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Storage
+  // ---------------------------------------------------------------------------
+
+  @ReactMethod
+  fun getItem(key: String, promise: Promise) {
+    try {
+      promise.resolve(QPushStore.get(reactContext, key))
+    } catch (e: Exception) {
+      promise.reject("qpush_storage", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun setItem(key: String, value: String, promise: Promise) {
+    try {
+      QPushStore.set(reactContext, key, value)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("qpush_storage", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun removeItem(key: String, promise: Promise) {
+    try {
+      QPushStore.remove(reactContext, key)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("qpush_storage", e.message, e)
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Device & push registration
+  // ---------------------------------------------------------------------------
+
+  @ReactMethod
+  fun getDeviceInfo(promise: Promise) {
+    try {
+      promise.resolve(QPushDeviceInfo.collect(reactContext))
+    } catch (e: Exception) {
+      promise.reject("qpush_device_info", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun registerForPush(fcmParams: ReadableMap?, promise: Promise) {
+    val params = fcmParams?.let { parseFcmParams(it) }
+    if (fcmParams != null && params == null) {
+      QPushLog.w("Incomplete FCM params from the server, falling back to the default FirebaseApp")
+    }
+    QPushFcm.register(reactContext, params) { result ->
+      val map = Arguments.createMap()
+      if (result.token != null) map.putString("token", result.token) else map.putNull("token")
+      result.notificationTypes?.let { map.putInt("notificationTypes", it) }
+      result.error?.let { map.putString("error", it) }
+      promise.resolve(map)
+    }
+  }
+
+  private fun parseFcmParams(map: ReadableMap): FcmParams? {
+    fun read(key: String): String? =
+      if (map.hasKey(key) && !map.isNull(key)) map.getString(key)?.takeIf { it.isNotEmpty() } else null
+    val projectId = read("project_id") ?: return null
+    val appId = read("app_id") ?: return null
+    val apiKey = read("api_key") ?: return null
+    val senderId = read("sender_id") ?: return null
+    return FcmParams(projectId, appId, apiKey, senderId)
+  }
+
+  // ---------------------------------------------------------------------------
+  // Permission
+  // ---------------------------------------------------------------------------
+
+  private fun notificationsEnabled(): Boolean =
+    NotificationManagerCompat.from(reactContext).areNotificationsEnabled()
+
+  private fun hasPostPermission(): Boolean =
+    Build.VERSION.SDK_INT < 33 ||
+      ContextCompat.checkSelfPermission(reactContext, POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
+
+  private fun permissionStatus(): String = when {
+    hasPostPermission() && notificationsEnabled() -> "granted"
+    Build.VERSION.SDK_INT >= 33 && !hasPostPermission() && !QPushStore.isPermissionRequested(reactContext) ->
+      "notDetermined"
+    else -> "denied"
+  }
+
+  @ReactMethod
+  fun getPermissionStatus(promise: Promise) {
+    promise.resolve(permissionStatus())
+  }
+
+  @ReactMethod
+  fun canRequestPermission(promise: Promise) {
+    if (Build.VERSION.SDK_INT < 33 || hasPostPermission()) {
+      promise.resolve(false)
+      return
+    }
+    val activity = reactContext.currentActivity
+    val canAsk = !QPushStore.isPermissionRequested(reactContext) ||
+      (activity != null && ActivityCompat.shouldShowRequestPermissionRationale(activity, POST_NOTIFICATIONS))
+    promise.resolve(canAsk)
+  }
+
+  @ReactMethod
+  fun registerForProvisionalAuthorization(promise: Promise) {
+    // iOS only concept; on Android report whether notifications can be shown.
+    promise.resolve(notificationsEnabled() && hasPostPermission())
+  }
+
+  @ReactMethod
+  fun requestPermission(fallbackToSettings: Boolean, promise: Promise) {
+    if (hasPostPermission() && notificationsEnabled()) {
+      promise.resolve(true)
+      return
+    }
+    if (Build.VERSION.SDK_INT < 33 || hasPostPermission()) {
+      // No runtime prompt exists: notifications were disabled in system settings.
+      if (fallbackToSettings) openSettingsAndResolve(promise) else promise.resolve(false)
+      return
+    }
+
+    val activity = reactContext.currentActivity
+    if (activity == null) {
+      QPushLog.w("requestPermission: no current activity")
+      promise.resolve(false)
+      return
+    }
+    val requestedBefore = QPushStore.isPermissionRequested(reactContext)
+    val canPrompt = !requestedBefore || ActivityCompat.shouldShowRequestPermissionRationale(activity, POST_NOTIFICATIONS)
+    if (!canPrompt) {
+      // Permanently denied: the system will not show the dialog any more.
+      if (fallbackToSettings) openSettingsAndResolve(promise) else promise.resolve(false)
+      return
+    }
+
+    QPushStore.setPermissionRequested(reactContext)
+    val permissionAware = activity as? PermissionAwareActivity
+    if (permissionAware != null) {
+      permissionAware.requestPermissions(
+        arrayOf(POST_NOTIFICATIONS),
+        PERMISSION_REQUEST_CODE,
+        PermissionListener { requestCode, _, grantResults ->
+          if (requestCode != PERMISSION_REQUEST_CODE) return@PermissionListener false
+          val granted = grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED
+          promise.resolve(granted && notificationsEnabled())
+          true
+        },
+      )
+    } else {
+      // Not a ReactActivity: request and read the result when the dialog closes.
+      onNextResume { promise.resolve(hasPostPermission() && notificationsEnabled()) }
+      ActivityCompat.requestPermissions(activity, arrayOf(POST_NOTIFICATIONS), PERMISSION_REQUEST_CODE)
+    }
+  }
+
+  private fun openSettingsAndResolve(promise: Promise) {
+    if (!openNotificationSettings()) {
+      promise.resolve(false)
+      return
+    }
+    onNextResume { promise.resolve(hasPostPermission() && notificationsEnabled()) }
+  }
+
+  private fun openNotificationSettings(): Boolean {
+    val intent = if (Build.VERSION.SDK_INT >= 26) {
+      Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).putExtra(Settings.EXTRA_APP_PACKAGE, reactContext.packageName)
+    } else {
+      Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.fromParts("package", reactContext.packageName, null))
+    }
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    return try {
+      val activity = reactContext.currentActivity
+      if (activity != null) activity.startActivity(intent) else reactContext.startActivity(intent)
+      true
+    } catch (e: Exception) {
+      QPushLog.w("Could not open notification settings", e)
+      false
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Notifications
+  // ---------------------------------------------------------------------------
+
+  @ReactMethod
+  fun clearAll() {
+    QPushNotificationRenderer.clearAll(reactContext)
+  }
+
+  @ReactMethod
+  fun removeNotification(notificationId: String) {
+    QPushNotificationRenderer.remove(reactContext, notificationId)
+  }
+
+  @ReactMethod
+  fun removeGroupedNotifications(groupKey: String) {
+    QPushNotificationRenderer.removeGroup(reactContext, groupKey)
+  }
+
+  @ReactMethod
+  fun clearBadge(promise: Promise) {
+    // Launcher badges follow the notifications on Android.
+    promise.resolve(0)
+  }
+
+  @ReactMethod
+  fun setAutoOpenUrls(enabled: Boolean) {
+    QPushStore.setAutoOpenUrls(reactContext, enabled)
+  }
+
+  @ReactMethod
+  fun setLogLevel(level: Double) {
+    QPushLog.level = level.toInt()
+  }
+
+  @ReactMethod
+  fun beginBackgroundTask(promise: Promise) {
+    // Not needed on Android (the process keeps running in background).
+    promise.resolve(-1)
+  }
+
+  @ReactMethod
+  fun endBackgroundTask(taskId: Double) {
+    // No-op on Android.
+  }
+}

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

@@ -0,0 +1,15 @@
+package com.qpush.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class QPushPushPackage : ReactPackage {
+  @Suppress("OVERRIDE_DEPRECATION", "DEPRECATION")
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(QPushPushModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    emptyList()
+}

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

@@ -0,0 +1,108 @@
+package com.qpush.reactnative
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.content.pm.PackageManager
+import org.json.JSONArray
+
+/**
+ * SharedPreferences shared by the JS layer (through the module's
+ * getItem/setItem) and native code that may run without the JS runtime
+ * (FirebaseMessagingService, notification trampoline).
+ */
+internal object QPushStore {
+  private const val PREFS_NAME = "qpush_sdk"
+
+  // Written by the JS layer.
+  const val KEY_APP_ID = "app_id"
+  const val KEY_SERVER_URL = "server_url"
+  const val KEY_SUBSCRIPTION_ID = "subscription_id"
+
+  // Native only.
+  private const val KEY_AUTO_OPEN_URLS = "qpush_native_auto_open_urls"
+  private const val KEY_PERMISSION_REQUESTED = "qpush_native_permission_requested"
+  private const val KEY_RECENT_NOTIFICATIONS = "qpush_native_recent_notification_ids"
+  const val KEY_FCM_MODE = "qpush_native_fcm_mode"
+  const val KEY_DEFAULT_APP_TOKEN = "qpush_native_default_app_token"
+
+  private const val META_SUPPRESS_LAUNCH_URLS = "com.qpush.suppressLaunchURLs"
+  private const val MAX_RECENT_NOTIFICATIONS = 100
+
+  private val lock = Any()
+
+  fun prefs(context: Context): SharedPreferences =
+    context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+
+  fun get(context: Context, key: String): String? = prefs(context).getString(key, null)
+
+  /** Synchronous write: callers run off the main thread and may be killed right after. */
+  fun set(context: Context, key: String, value: String) {
+    prefs(context).edit().putString(key, value).commit()
+  }
+
+  fun remove(context: Context, key: String) {
+    prefs(context).edit().remove(key).commit()
+  }
+
+  fun isPermissionRequested(context: Context): Boolean =
+    prefs(context).getBoolean(KEY_PERMISSION_REQUESTED, false)
+
+  fun setPermissionRequested(context: Context) {
+    prefs(context).edit().putBoolean(KEY_PERMISSION_REQUESTED, true).apply()
+  }
+
+  fun setAutoOpenUrls(context: Context, enabled: Boolean) {
+    prefs(context).edit().putBoolean(KEY_AUTO_OPEN_URLS, enabled).apply()
+  }
+
+  /** Runtime setting wins; otherwise the manifest meta-data `com.qpush.suppressLaunchURLs`. */
+  fun autoOpenUrls(context: Context): Boolean {
+    val prefs = prefs(context)
+    if (prefs.contains(KEY_AUTO_OPEN_URLS)) return prefs.getBoolean(KEY_AUTO_OPEN_URLS, true)
+    return !manifestFlag(context, META_SUPPRESS_LAUNCH_URLS)
+  }
+
+  @Suppress("DEPRECATION")
+  fun manifestFlag(context: Context, key: String): Boolean {
+    return try {
+      val info = context.packageManager.getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
+      info.metaData?.getBoolean(key, false) ?: false
+    } catch (e: Exception) {
+      false
+    }
+  }
+
+  @Suppress("DEPRECATION")
+  fun manifestString(context: Context, key: String): String? {
+    return try {
+      val info = context.packageManager.getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
+      info.metaData?.get(key)?.toString()
+    } catch (e: Exception) {
+      null
+    }
+  }
+
+  /**
+   * Remembers notification ids to drop FCM duplicates. Returns `true` when the
+   * id was already seen.
+   */
+  fun markNotificationSeen(context: Context, notificationId: String): Boolean {
+    synchronized(lock) {
+      val prefs = prefs(context)
+      val ids = try {
+        JSONArray(prefs.getString(KEY_RECENT_NOTIFICATIONS, "[]"))
+      } catch (e: Exception) {
+        JSONArray()
+      }
+      for (i in 0 until ids.length()) {
+        if (ids.optString(i) == notificationId) return true
+      }
+      val updated = JSONArray()
+      val start = maxOf(0, ids.length() - (MAX_RECENT_NOTIFICATIONS - 1))
+      for (i in start until ids.length()) updated.put(ids.optString(i))
+      updated.put(notificationId)
+      prefs.edit().putString(KEY_RECENT_NOTIFICATIONS, updated.toString()).commit()
+      return false
+    }
+  }
+}

package/android/src/main/res/values/qpush_strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <!-- Name of the default notification channel (qpush_default). Override it in
+       your app's res/values*/strings.xml to localize it. -->
+  <string name="qpush_default_channel_name">Notifications</string>
+</resources>

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/withQPush');