@usergist/feedback-react-native 0.1.0

package/android/src/main/java/studio/usergist/feedback/UserGistPushModule.kt

@@ -0,0 +1,344 @@
+package studio.usergist.feedback
+
+import android.Manifest
+import android.app.Activity
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import com.facebook.react.bridge.Arguments
+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.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.gms.tasks.OnCompleteListener
+import com.google.firebase.messaging.FirebaseMessaging
+
+/**
+ * Native bridge for the UserGist push pipeline on Android.
+ *
+ * Responsibilities:
+ *   - Request POST_NOTIFICATIONS at runtime on Android 13+.
+ *   - Surface the current FCM token via FirebaseMessaging.getInstance().token.
+ *   - Forward token-refresh + RemoteMessage delivery to JS.  The actual
+ *     RemoteMessage handling lives in UserGistFirebaseMessagingService;
+ *     this module exposes only the imperative side (JS -> native calls).
+ */
+@Suppress("UNUSED_PARAMETER")
+class UserGistPushModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), LifecycleEventListener, ActivityEventListener {
+
+  init {
+    // Wire ourselves into the static event-emit helper so the Firebase
+    // service can hand events back without holding a strong reference to
+    // the React module.
+    UserGistPushEventBus.attach(reactContext)
+    reactContext.addLifecycleEventListener(this)
+    reactContext.addActivityEventListener(this)
+  }
+
+  override fun getName(): String = NAME
+
+  private val securePreferences by lazy {
+    val masterKey = MasterKey.Builder(reactApplicationContext)
+      .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+      .build()
+    EncryptedSharedPreferences.create(
+      reactApplicationContext,
+      "usergist_react_native_secure",
+      masterKey,
+      EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+      EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
+    )
+  }
+
+  override fun onHostResume() {
+    currentActivity?.intent?.let { consumeNotificationIntent(it) }
+  }
+
+  override fun onHostPause() = Unit
+  override fun onHostDestroy() = Unit
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) = Unit
+
+  override fun onNewIntent(intent: Intent) {
+    consumeNotificationIntent(intent)
+  }
+
+  private fun consumeNotificationIntent(intent: Intent) {
+    val extras = intent.extras ?: return
+    val keys = extras.keySet().filter { it.startsWith("usergist_") }
+    if (keys.isEmpty()) return
+    val body = Arguments.createMap()
+    val data = Arguments.createMap()
+    for (key in keys) {
+      val value = extras.getString(key) ?: continue
+      val normalized = key.removePrefix("usergist_")
+      when (normalized) {
+        "title" -> body.putString("title", value)
+        "body" -> body.putString("body", value)
+        "delivery_id" -> body.putString("deliveryId", value)
+        "action_identifier" -> body.putString("actionIdentifier", value)
+        else -> data.putString(key, value)
+      }
+      intent.removeExtra(key)
+    }
+    body.putMap("data", data)
+    UserGistPushEventBus.emitNotificationOpened(body)
+  }
+
+  // MARK: - Exported methods
+
+  @ReactMethod
+  fun enablePush(_options: ReadableMap?, promise: Promise) {
+    // Android < 13: notification permission is install-time, no runtime
+    // prompt. We can short-circuit straight to the token fetch.
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+      val areEnabled = NotificationManagerCompat.from(reactApplicationContext).areNotificationsEnabled()
+      if (!areEnabled) {
+        promise.resolve(buildResult(granted = false, status = "denied", token = null))
+        return
+      }
+      fetchTokenAndResolve(promise, status = "authorized")
+      return
+    }
+    val activity = currentActivity
+    if (activity == null) {
+      // No activity: can't ask for permission. Resolve with current state.
+      val granted = ActivityCompat.checkSelfPermission(
+        reactApplicationContext,
+        Manifest.permission.POST_NOTIFICATIONS
+      ) == PackageManager.PERMISSION_GRANTED
+      if (granted) {
+        fetchTokenAndResolve(promise, status = "authorized")
+      } else {
+        promise.resolve(buildResult(granted = false, status = "not_determined", token = null))
+      }
+      return
+    }
+    val already = ActivityCompat.checkSelfPermission(
+      activity,
+      Manifest.permission.POST_NOTIFICATIONS
+    ) == PackageManager.PERMISSION_GRANTED
+    if (already) {
+      fetchTokenAndResolve(promise, status = "authorized")
+      return
+    }
+    val permAware = activity as? PermissionAwareActivity
+    if (permAware == null) {
+      // Fallback: classic ActivityCompat, no result callback we can hook.
+      ActivityCompat.requestPermissions(
+        activity,
+        arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+        REQUEST_CODE
+      )
+      // Without a callback we can't know the outcome — resolve as
+      // not_determined so the caller can re-call after the dialog closes.
+      promise.resolve(buildResult(granted = false, status = "not_determined", token = null))
+      return
+    }
+    permAware.requestPermissions(
+      arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+      REQUEST_CODE,
+      PermissionListener { _, _, grantResults ->
+        val grantedNow = grantResults.isNotEmpty() &&
+          grantResults[0] == PackageManager.PERMISSION_GRANTED
+        if (grantedNow) {
+          fetchTokenAndResolve(promise, status = "authorized")
+        } else {
+          promise.resolve(buildResult(granted = false, status = "denied", token = null))
+        }
+        true
+      }
+    )
+  }
+
+  @ReactMethod
+  fun disablePush(promise: Promise) {
+    FirebaseMessaging.getInstance().deleteToken()
+      .addOnCompleteListener { promise.resolve(null) }
+  }
+
+  @ReactMethod
+  fun getPushPermissionStatus(promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+      val areEnabled = NotificationManagerCompat.from(reactApplicationContext).areNotificationsEnabled()
+      promise.resolve(if (areEnabled) "authorized" else "denied")
+      return
+    }
+    val granted = ActivityCompat.checkSelfPermission(
+      reactApplicationContext,
+      Manifest.permission.POST_NOTIFICATIONS
+    ) == PackageManager.PERMISSION_GRANTED
+    promise.resolve(if (granted) "authorized" else "denied")
+  }
+
+  @ReactMethod
+  fun setBadgeCount(_count: Double, promise: Promise) {
+    // Android does not expose a portable badge API; some launchers honour
+    // a ShortcutBadger-style broadcast but it's launcher-specific. No-op
+    // for now; consumers who need it can use ShortcutBadger directly.
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun getInitialNotification(promise: Promise) {
+    promise.resolve(UserGistPushEventBus.takeInitialNotification())
+  }
+
+  @ReactMethod
+  fun secureGetItem(key: String, promise: Promise) {
+    runCatching { securePreferences.getString(key, null) }
+      .onSuccess(promise::resolve)
+      .onFailure { promise.reject("secure_read_failed", it) }
+  }
+
+  @ReactMethod
+  fun secureSetItem(key: String, value: String, promise: Promise) {
+    runCatching {
+      check(securePreferences.edit().putString(key, value).commit())
+    }.onSuccess { promise.resolve(null) }
+      .onFailure { promise.reject("secure_write_failed", it) }
+  }
+
+  @ReactMethod
+  fun secureRemoveItem(key: String, promise: Promise) {
+    runCatching { check(securePreferences.edit().remove(key).commit()) }
+      .onSuccess { promise.resolve(null) }
+      .onFailure { promise.reject("secure_remove_failed", it) }
+  }
+
+  @ReactMethod
+  fun secureMultiRemove(keys: ReadableArray, promise: Promise) {
+    runCatching {
+      val edit = securePreferences.edit()
+      for (index in 0 until keys.size()) {
+        edit.remove(keys.getString(index))
+      }
+      check(edit.commit())
+    }.onSuccess { promise.resolve(null) }
+      .onFailure { promise.reject("secure_remove_failed", it) }
+  }
+
+  // Required for RN's NativeEventEmitter API even though we emit from a
+  // separate static bus — RN will warn otherwise.
+  @ReactMethod
+  fun addListener(_eventName: String?) { /* no-op */ }
+
+  @ReactMethod
+  fun removeListeners(_count: Double) { /* no-op */ }
+
+  // MARK: - Internal
+
+  private fun fetchTokenAndResolve(promise: Promise, status: String) {
+    FirebaseMessaging.getInstance().token.addOnCompleteListener(
+      OnCompleteListener { task ->
+        if (!task.isSuccessful) {
+          val msg = task.exception?.localizedMessage ?: "fcm_token_unavailable"
+          promise.resolve(buildResult(granted = true, status = status, token = null, error = msg))
+          return@OnCompleteListener
+        }
+        val token = task.result
+        // Emit on top of resolving so JS gets both the resolution AND the
+        // refresh-style event (idempotent on the server side).
+        UserGistPushEventBus.emitToken(token)
+        promise.resolve(buildResult(granted = true, status = status, token = token))
+      }
+    )
+  }
+
+  private fun buildResult(
+    granted: Boolean,
+    status: String,
+    token: String?,
+    error: String? = null
+  ): WritableMap {
+    val map = Arguments.createMap()
+    map.putBoolean("granted", granted)
+    map.putString("status", status)
+    map.putString("platform", "android")
+    if (token != null) map.putString("token", token)
+    if (error != null) map.putString("error", error)
+    return map
+  }
+
+  companion object {
+    const val NAME = "UserGistPush"
+    private const val REQUEST_CODE = 0x52A1 // arbitrary 16-bit; "RA" in hex
+  }
+}
+
+/**
+ * Static bus owned by the UserGistFirebaseMessagingService; lets the service
+ * forward events to JS without holding a strong reference to the
+ * (possibly-not-yet-initialized) React Native bridge.
+ */
+internal object UserGistPushEventBus {
+  @Volatile private var reactContext: ReactApplicationContext? = null
+  private val pending: MutableList<Pair<String, WritableMap>> = mutableListOf()
+  private var initialNotification: WritableMap? = null
+
+  @Synchronized
+  fun attach(ctx: ReactApplicationContext) {
+    this.reactContext = ctx
+    val drained = pending.toList()
+    pending.clear()
+    for ((name, body) in drained) {
+      send(name, body)
+    }
+  }
+
+  fun emitToken(token: String) {
+    val map = Arguments.createMap()
+    map.putString("token", token)
+    map.putString("platform", "android")
+    emit("UserGistPush:tokenReceived", map)
+  }
+
+  fun emitNotificationReceived(body: WritableMap) {
+    emit("UserGistPush:notificationReceived", body)
+  }
+
+  @Synchronized
+  fun emitNotificationOpened(body: WritableMap) {
+    if (initialNotification == null) {
+      // Snapshot so getInitialNotification() can return it once.
+      initialNotification = Arguments.createMap().apply { merge(body) }
+    }
+    emit("UserGistPush:notificationOpened", body)
+  }
+
+  @Synchronized
+  fun takeInitialNotification(): WritableMap? {
+    val v = initialNotification
+    initialNotification = null
+    return v
+  }
+
+  @Synchronized
+  private fun emit(name: String, body: WritableMap) {
+    val ctx = reactContext
+    if (ctx == null || !ctx.hasActiveReactInstance()) {
+      if (pending.size >= 100) pending.removeAt(0)
+      pending.add(name to body)
+      return
+    }
+    send(name, body)
+  }
+
+  private fun send(name: String, body: WritableMap) {
+    val ctx = reactContext ?: return
+    ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(name, body)
+  }
+}

package/android/src/main/java/studio/usergist/feedback/UserGistPushPackage.kt

@@ -0,0 +1,18 @@
+package studio.usergist.feedback
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * Registers UserGistPushModule with the React Native bridge. Picked up via
+ * autolinking — see react-native.config.js at the package root.
+ */
+class UserGistPushPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(UserGistPushModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    emptyList()
+}

package/dist/NativeUserGistPush.d.ts

@@ -0,0 +1,35 @@
+import type { TurboModule } from 'react-native';
+export interface EnablePushOptions {
+    readonly skipPermissionRequestIfDenied?: boolean;
+    readonly environment?: 'sandbox' | 'production';
+    /** Disable delegate interception when the host forwards tokens/messages via Push. */
+    readonly installDelegateProxy?: boolean;
+}
+export interface EnablePushResult {
+    readonly granted: boolean;
+    readonly status: 'authorized' | 'provisional' | 'denied' | 'not_determined';
+    readonly token?: string;
+    readonly platform: 'ios' | 'android';
+    readonly error?: string;
+}
+export type PushPermissionStatus = 'authorized' | 'provisional' | 'denied' | 'not_determined';
+export interface Spec extends TurboModule {
+    enablePush(options: {
+        [key: string]: unknown;
+    } | null): Promise<EnablePushResult>;
+    disablePush(): Promise<void>;
+    getPushPermissionStatus(): Promise<PushPermissionStatus>;
+    setBadgeCount(count: number): Promise<void>;
+    getInitialNotification(): Promise<{
+        [key: string]: unknown;
+    } | null>;
+    secureGetItem(key: string): Promise<string | null>;
+    secureSetItem(key: string, value: string): Promise<void>;
+    secureRemoveItem(key: string): Promise<void>;
+    secureMultiRemove(keys: ReadonlyArray<string>): Promise<void>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeUserGistPush.d.ts.map

package/dist/NativeUserGistPush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeUserGistPush.d.ts","sourceRoot":"","sources":["../src/NativeUserGistPush.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,OAAO,CAAA;IAChD,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,GAAG,YAAY,CAAA;IAC/C,qFAAqF;IACrF,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CACxC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,GAAG,QAAQ,GAAG,gBAAgB,CAAA;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,MAAM,oBAAoB,GAC5B,YAAY,GACZ,aAAa,GACb,QAAQ,GACR,gBAAgB,CAAA;AAEpB,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,UAAU,CAAC,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACjF,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5B,uBAAuB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAA;IACxD,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3C,sBAAsB,IAAI,OAAO,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;IACpE,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAClD,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxD,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5C,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7D,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACpC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrC;;AAED,wBAA4D"}

package/dist/NativeUserGistPush.js

@@ -0,0 +1,13 @@
+// TurboModule spec for the UserGist push native module.
+//
+// React Native's codegen consumes this file and generates the native
+// scaffolding that lets the new architecture (Bridgeless / Fabric)
+// resolve our module without going through the legacy bridge.
+//
+// At runtime, `src/native/push-bridge.ts` first tries
+// `TurboModuleRegistry.getEnforcing<Spec>('UserGistPush')` and falls back
+// to `NativeModules.UserGistPush` so the package works in both
+// architectures (RN 0.72 → 0.79+).
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('UserGistPush');
+//# sourceMappingURL=NativeUserGistPush.js.map

package/dist/NativeUserGistPush.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeUserGistPush.js","sourceRoot":"","sources":["../src/NativeUserGistPush.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,EAAE;AACF,qEAAqE;AACrE,mEAAmE;AACnE,8DAA8D;AAC9D,EAAE;AACF,sDAAsD;AACtD,0EAA0E;AAC1E,+DAA+D;AAC/D,mCAAmC;AAGnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAsClD,eAAe,mBAAmB,CAAC,GAAG,CAAO,cAAc,CAAC,CAAA"}

package/dist/Provider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface Props {
+    readonly children?: React.ReactNode;
+}
+export declare function UserGistProvider({ children }: Props): React.ReactElement;
+export {};
+//# sourceMappingURL=Provider.d.ts.map

package/dist/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../src/Provider.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAmD,MAAM,OAAO,CAAA;AA0EvE,UAAU,KAAK;IACb,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CACpC;AAUD,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,GAAG,KAAK,CAAC,YAAY,CAoTxE"}