@posthog/react-native-plugin 2.2.3 → 2.3.0

package/android/build.gradle

@@ -85,6 +85,6 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.posthog:posthog-android:3.54.0"
+  implementation "com.posthog:posthog-android:3.58.0"
 }
 

package/android/src/main/java/com/posthogreactnativeplugin/PosthogReactNativePluginModule.kt

@@ -1,6 +1,8 @@
 package com.posthogreactnativeplugin
 
+import android.content.Intent
 import android.util.Log
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -8,6 +10,7 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.JavascriptException
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.posthog.PostHog
 import com.posthog.PostHogConfig
 import com.posthog.android.PostHogAndroid
@@ -42,6 +45,7 @@ class PosthogReactNativePluginModule(
       decideReplayConfig = getMap(sessionReplayConfig, "decideReplayConfig"),
       nativeErrorTrackingAutocapture = getBoolean(errorTrackingConfig, "nativeAutocapture", false),
       exceptionStepsConfig = getMap(errorTrackingConfig, "exceptionSteps"),
+      pushConfig = getMap(pluginConfig, "push"),
       promise = promise,
     )
   }
@@ -63,6 +67,7 @@ class PosthogReactNativePluginModule(
       decideReplayConfig = decideReplayConfig,
       nativeErrorTrackingAutocapture = false,
       exceptionStepsConfig = null,
+      pushConfig = null,
       promise = promise,
     )
   }
@@ -76,6 +81,7 @@ class PosthogReactNativePluginModule(
     decideReplayConfig: ReadableMap?,
     nativeErrorTrackingAutocapture: Boolean,
     exceptionStepsConfig: ReadableMap?,
+    pushConfig: ReadableMap?,
     promise: Promise,
   ) {
     val initRunnable =
@@ -92,17 +98,23 @@ class PosthogReactNativePluginModule(
           val anonymousId = getString(sdkOptions, "anonymousId", "")
           val theSdkVersion = getString(sdkOptions, "sdkVersion", "")
           val theFlushAt = getInt(sdkOptions, "flushAt", DEFAULT_FLUSH_AT)
+          val theOptOut = getBoolean(sdkOptions, "optOut", false)
+          // Default true: an older JS layer that never sends this keeps native's own fetch.
+          val thePreloadFeatureFlags = getBoolean(sdkOptions, "preloadFeatureFlags", true)
 
           // Forward custom headers (e.g. Authorization for a reverse proxy) so the native SDK
           // attaches them to the requests it sends directly (session replay, crash uploads).
           val theRequestHeaders =
-            getMap(sdkOptions, "requestHeaders")?.toHashMap()
+            getMap(sdkOptions, "requestHeaders")
+              ?.toHashMap()
               ?.filterValues { it is String }
               ?.mapValues { it.value as String }
 
           val config =
             PostHogAndroidConfig(apiKey, host).apply {
               debug = debugValue
+              optOut = theOptOut
+              preloadFeatureFlags = thePreloadFeatureFlags
               captureDeepLinks = false
               captureApplicationLifecycleEvents = false
               captureScreenViews = false
@@ -112,8 +124,10 @@ class PosthogReactNativePluginModule(
 
               // Keep the native exception-steps buffer aligned with the JS layer (one logical buffer).
               // Absent keys fall back to the native defaults the helpers receive.
-              errorTrackingConfig.exceptionSteps.enabled = getBoolean(exceptionStepsConfig, "enabled", errorTrackingConfig.exceptionSteps.enabled)
-              errorTrackingConfig.exceptionSteps.maxBytes = getInt(exceptionStepsConfig, "maxBytes", errorTrackingConfig.exceptionSteps.maxBytes)
+              errorTrackingConfig.exceptionSteps.enabled =
+                getBoolean(exceptionStepsConfig, "enabled", errorTrackingConfig.exceptionSteps.enabled)
+              errorTrackingConfig.exceptionSteps.maxBytes =
+                getInt(exceptionStepsConfig, "maxBytes", errorTrackingConfig.exceptionSteps.maxBytes)
 
               // React Native rethrows fatal JS errors natively as JavascriptException.
               // The JS layer already captured them, so drop the native duplicate.
@@ -130,7 +144,10 @@ class PosthogReactNativePluginModule(
               val throttleDelayMs =
                 when {
                   hasKey(sdkReplayConfig, "throttleDelayMs") -> getInt(sdkReplayConfig, "throttleDelayMs", DEFAULT_THROTTLE_DELAY_MS)
-                  hasKey(sdkReplayConfig, "androidDebouncerDelayMs") -> getInt(sdkReplayConfig, "androidDebouncerDelayMs", DEFAULT_THROTTLE_DELAY_MS)
+                  hasKey(
+                    sdkReplayConfig,
+                    "androidDebouncerDelayMs",
+                  ) -> getInt(sdkReplayConfig, "androidDebouncerDelayMs", DEFAULT_THROTTLE_DELAY_MS)
                   else -> DEFAULT_THROTTLE_DELAY_MS
                 }
 
@@ -147,6 +164,25 @@ class PosthogReactNativePluginModule(
                 snapshotEndpoint = endpoint
               }
 
+              // Only set when present: the legacy start() path predates push, and there the
+              // native defaults (both true) must win, matching posthog-android on its own.
+              if (hasKey(pushConfig, "capturePushNotificationSubscriptions")) {
+                capturePushNotificationSubscriptions =
+                  getBoolean(pushConfig, "capturePushNotificationSubscriptions", true)
+              }
+              if (hasKey(pushConfig, "capturePushNotificationOpened")) {
+                capturePushNotificationOpened = getBoolean(pushConfig, "capturePushNotificationOpened", true)
+              }
+
+              // Installed only when JS asked for it: an uninvited bridging provider would
+              // change how the native SDK handles a 401 on the subscription call.
+              if (getBoolean(pushConfig, "pushIdentityProviderEnabled", false)) {
+                pushModule = this@PosthogReactNativePluginModule
+                pushIdentityProvider = { distinctId, appId, completion ->
+                  requestPushIdentityToken(distinctId, appId, completion)
+                }
+              }
+
               if (theSdkVersion.isNotEmpty()) {
                 sdkName = "posthog-react-native"
                 sdkVersion = theSdkVersion
@@ -155,6 +191,8 @@ class PosthogReactNativePluginModule(
           PostHogAndroid.setup(context, config)
 
           setIdentify(config.cachePreferences, distinctId, anonymousId)
+
+          captureColdStartPushOpenIfNeeded(config)
         } catch (e: Throwable) {
           logError(method, e)
         } finally {
@@ -222,6 +260,50 @@ class PosthogReactNativePluginModule(
     }
   }
 
+  // Calls the native SDK rather than writing preferences like identify() does: reset() is what
+  // unregisters the logged-out user's push subscription and re-registers under the new identity.
+  @ReactMethod
+  fun reset(
+    distinctId: String,
+    anonymousId: String,
+    promise: Promise,
+  ) {
+    try {
+      PostHog.reset()
+      // Native reset() mints its own anonymous id; overwrite it with the JS one so the two
+      // SDKs stay on the same identity. Must run after reset(), which needs the pre-reset
+      // distinctId to know which subscription to unregister. Known gap (as on iOS): native's
+      // async push re-registration can read the identity before this write lands and register
+      // under a throwaway id; retryPending() converges it on the next flush.
+      setIdentify(PostHog.getConfig<PostHogConfig>()?.cachePreferences, distinctId, anonymousId)
+    } catch (e: Throwable) {
+      logError("reset", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  // Runtime consent changes must reach native: it persists its own opt-out flag and only reads
+  // the JS value at setup(), so a refreshed FCM token could otherwise auto-register after the
+  // user opted out. optIn() also resumes deferred push work on the next flush.
+  @ReactMethod
+  fun setOptOut(
+    optOut: Boolean,
+    promise: Promise,
+  ) {
+    try {
+      if (optOut) {
+        PostHog.optOut()
+      } else {
+        PostHog.optIn()
+      }
+    } catch (e: Throwable) {
+      logError("setOptOut", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
   private fun setIdentify(
     cachePreferences: PostHogPreferences?,
     distinctId: String,
@@ -327,15 +409,228 @@ class PosthogReactNativePluginModule(
     Log.println(Log.ERROR, POSTHOG_TAG, "Method $method, error: $error")
   }
 
+  // These reject instead of this module's usual swallow-and-resolve convention: a failed
+  // registration is a distinct signal, not a silent success. The JS layer's public methods
+  // never throw, so the rejection is what gives it something to log.
+  @ReactMethod
+  fun registerPushNotificationToken(
+    deviceToken: String?,
+    appId: String?,
+    promise: Promise,
+  ) {
+    try {
+      if (deviceToken.isNullOrBlank()) {
+        // A blank token is dropped silently by the native SDK, so surface it here
+        // instead of reporting false success.
+        promise.reject(
+          PUSH_ERROR_CODE,
+          "registerPushNotificationToken: deviceToken is blank; token not registered.",
+        )
+        return
+      }
+      val resolvedAppId = appId?.trim()?.takeIf { it.isNotEmpty() } ?: firebaseProjectId
+      if (resolvedAppId.isNullOrEmpty()) {
+        val message =
+          "registerPushNotificationToken: no appId provided and no Firebase project id " +
+            "could be resolved, skipping. Pass appId explicitly if this app does not use Firebase."
+        Log.w(POSTHOG_TAG, message)
+        promise.reject(PUSH_ERROR_CODE, message)
+        return
+      }
+      PostHog.registerPushNotificationToken(deviceToken, resolvedAppId)
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      logError("registerPushNotificationToken", e)
+      promise.reject(PUSH_ERROR_CODE, e)
+    }
+  }
+
+  @ReactMethod
+  fun unregisterPushNotificationToken(promise: Promise) {
+    try {
+      PostHog.unregisterPushNotificationToken()
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      logError("unregisterPushNotificationToken", e)
+      promise.reject(PUSH_ERROR_CODE, e)
+    }
+  }
+
+  @ReactMethod
+  fun capturePushNotificationOpened(
+    properties: ReadableMap,
+    promise: Promise,
+  ) {
+    try {
+      // subtitle is iOS-only; posthog-android's capturePushNotificationOpened has no
+      // subtitle parameter, so JS's value is dropped here.
+      val title = if (hasKey(properties, "title")) properties.getString("title") else null
+      val body = if (hasKey(properties, "body")) properties.getString("body") else null
+      val payload = if (hasKey(properties, "payload")) properties.getMap("payload")?.toHashMap() else null
+      val action = if (hasKey(properties, "action")) properties.getString("action") else null
+      PostHog.capturePushNotificationOpened(title, body, payload, action)
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      logError("capturePushNotificationOpened", e)
+      promise.reject(PUSH_ERROR_CODE, e)
+    }
+  }
+
+  // posthog-android's open-capture integration registers ActivityLifecycleCallbacks during
+  // setup(), which the bridge reaches only after the launch Activity was created — so the
+  // cold-start tray tap it exists for is the one creation it can never observe here. Read
+  // the launch intent directly, then strip the marker so the integration (or a re-run)
+  // can't capture the same tap again from this intent object.
+  private fun captureColdStartPushOpenIfNeeded(config: PostHogAndroidConfig) {
+    if (!config.capturePushNotificationOpened) {
+      return
+    }
+    val intent = currentActivity?.intent ?: return
+    // A relaunch from recents redelivers the original tray intent to a fresh activity;
+    // capturing it would count a days-old tap as a new open.
+    if (intent.flags and Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY != 0) {
+      return
+    }
+    try {
+      intent.getStringExtra(GOOGLE_MESSAGE_ID) ?: return
+      // Unmarshalling extras throws BadParcelableException on a Parcelable class this
+      // classloader lacks; read before stripping the marker so a failed read leaves the
+      // intent as the native integration expects it.
+      val payload =
+        intent.extras?.let { bundle ->
+          bundle.keySet().associateWith { key ->
+            @Suppress("DEPRECATION")
+            bundle.get(key)
+          }
+        }
+      intent.removeExtra(GOOGLE_MESSAGE_ID)
+      PostHog.capturePushNotificationOpened(null, null, payload, null)
+    } catch (e: Throwable) {
+      logError("capturePushNotificationOpened", e)
+    }
+  }
+
+  @ReactMethod
+  fun providePushIdentityToken(
+    requestId: String?,
+    token: String?,
+    promise: Promise,
+  ) {
+    try {
+      if (requestId != null) {
+        pushIdentityCompletions.remove(requestId)?.invoke(token)
+      }
+    } catch (e: Throwable) {
+      logError("providePushIdentityToken", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
+  // Required by NativeEventEmitter on the old architecture; events are broadcast via
+  // RCTDeviceEventEmitter, so there is nothing to do here.
+  @ReactMethod
+  fun addListener(eventName: String?) = Unit
+
+  @ReactMethod
+  fun removeListeners(count: Int) = Unit
+
+  override fun invalidate() {
+    if (pushModule === this) {
+      // Decline mints fast after teardown instead of stalling the native 10s watchdog.
+      pushModule = null
+    }
+    super.invalidate()
+  }
+
   companion object {
     const val NAME = "PosthogReactNativePlugin"
     const val POSTHOG_TAG = "PostHog"
 
+    // FCM stamps this extra on the tray-tap launch intent; mirrors posthog-android's
+    // PostHogActivityLifecycleCallbackIntegration.
+    private const val GOOGLE_MESSAGE_ID = "google.message_id"
+
     // Default session replay configuration values
     const val DEFAULT_MASK_ALL_TEXT_INPUTS = true
     const val DEFAULT_MASK_ALL_IMAGES = true
     const val DEFAULT_CAPTURE_LOG = true
     const val DEFAULT_FLUSH_AT = 20
     const val DEFAULT_THROTTLE_DELAY_MS = 1000
+
+    private const val PUSH_ERROR_CODE = "PosthogReactNativePluginError"
+    private const val PUSH_IDENTITY_EVENT = "PostHogPushIdentityRequest"
+    private const val PUSH_IDENTITY_REPLY_TTL_MS = 15_000L
+
+    // Modules die on every bridge reload, so the provider closure resolves the live
+    // module through this static reference at call time, not a captured setup-time one.
+    @Volatile
+    private var pushModule: PosthogReactNativePluginModule? = null
+
+    private val pushIdentityCompletions = java.util.concurrent.ConcurrentHashMap<String, (String?) -> Unit>()
+
+    private fun requestPushIdentityToken(
+      distinctId: String,
+      appId: String,
+      completion: (String?) -> Unit,
+    ) {
+      val module = pushModule
+      val context = module?.reactApplicationContext
+      if (module == null || context == null || !context.hasActiveReactInstance()) {
+        declinePushIdentity(completion, "no React instance attached")
+        return
+      }
+      val requestId = UUID.randomUUID().toString()
+      pushIdentityCompletions[requestId] = completion
+      try {
+        val params =
+          Arguments.createMap().apply {
+            putString("requestId", requestId)
+            putString("distinctId", distinctId)
+            putString("appId", appId)
+          }
+        context
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit(PUSH_IDENTITY_EVENT, params)
+      } catch (e: Throwable) {
+        pushIdentityCompletions.remove(requestId)
+        declinePushIdentity(completion, "failed to reach JS: ${e.message}")
+        return
+      }
+      // The native SDK's own 10s mint watchdog handles the fallback; this only drops the
+      // entry so a late JS reply is ignored and the completion doesn't leak.
+      UiThreadUtil.runOnUiThread({ pushIdentityCompletions.remove(requestId) }, PUSH_IDENTITY_REPLY_TTL_MS)
+    }
+
+    // A null identity token sends the request unauthenticated, which a project requiring
+    // identity verification rejects server-side. Log the reason so that failure is
+    // greppable and distinct from a host that deliberately returned null.
+    private fun declinePushIdentity(
+      completion: (String?) -> Unit,
+      reason: String,
+    ) {
+      Log.w(POSTHOG_TAG, "Push subscription will be sent unauthenticated: $reason")
+      completion(null)
+    }
+
+    @Volatile private var cachedFirebaseProjectId: String? = null
+
+    // No Firebase dependency here, so the project id is looked up reflectively and any
+    // failure (class missing, Firebase not initialized) is swallowed. Only a successful lookup
+    // is cached: getInstance() throws until Firebase initializes, so memoizing the null would
+    // strand every later token-refresh call with no resolvable appId for the process lifetime.
+    private val firebaseProjectId: String?
+      get() =
+        cachedFirebaseProjectId
+          ?: try {
+            val firebaseAppClass = Class.forName("com.google.firebase.FirebaseApp")
+            val firebaseApp = firebaseAppClass.getMethod("getInstance").invoke(null)
+            val options = firebaseAppClass.getMethod("getOptions").invoke(firebaseApp)
+            (options?.javaClass?.getMethod("getProjectId")?.invoke(options) as? String)?.also {
+              cachedFirebaseProjectId = it
+            }
+          } catch (e: Throwable) {
+            null
+          }
   }
 }

package/ios/PosthogReactNativePlugin-Bridging-Header.h

@@ -1,2 +1,3 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>

package/ios/PosthogReactNativePlugin.mm

@@ -1,6 +1,7 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(PosthogReactNativePlugin, NSObject)
+@interface RCT_EXTERN_MODULE(PosthogReactNativePlugin, RCTEventEmitter)
 
 RCT_EXTERN_METHOD(setup:(NSString)sessionId
                  withSdkOptions:(NSDictionary)sdkOptions
@@ -42,6 +43,32 @@ RCT_EXTERN_METHOD(addExceptionStep:(NSString)message
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(reset:(NSString)distinctId
+                 withAnonymousId:(NSString)anonymousId
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(registerPushNotificationToken:(NSString)deviceToken
+                 withAppId:(NSString)appId
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(unregisterPushNotificationToken:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setOptOut:(BOOL)optOut
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(capturePushNotificationOpened:(NSDictionary)properties
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(providePushIdentityToken:(NSString)requestId
+                 withToken:(NSString)token
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
 + (BOOL)requiresMainQueueSetup
 {
   return NO;