react-native-userleap 4.0.0 → 4.1.0

package/android/build.gradle

@@ -1,81 +1,90 @@
 // android/build.gradle
-// based on:
 //
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/build.gradle
+// Modernized for React Native 0.85:
 //
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/app/build.gradle
-def DEFAULT_COMPILE_SDK_VERSION = 28
-def DEFAULT_BUILD_TOOLS_VERSION = '30.0.2'
-def DEFAULT_MIN_SDK_VERSION = 16
-def DEFAULT_TARGET_SDK_VERSION = 28
+//   - Applies the `com.facebook.react` plugin so RN's codegen runs against
+//     our TurboModule spec in `../src/` and generates the Java abstract base
+//     class our Kotlin module inherits from plus the C++ JNI glue the New
+//     Architecture autolinking links against. Codegen is configured by the
+//     `react { ... }` block below. `jsRootDir` MUST point at the isolated
+//     `src/` dir (not the package root) so codegen scans only our spec and
+//     not the sibling `example/` app's node_modules.
+//   - Applies the Kotlin plugin so `UserLeapModule.kt` compiles.
+//   - Sets `namespace` (required by Android Gradle Plugin 8+).
+//   - Targets Java 17 / Kotlin (matches RN 0.85's host-app build).
+//
+// Versions for compileSdk / buildTools / NDK / Java are pulled from the
+// host application's rootProject.ext via safeExtGet, so consumers can
+// override them centrally without editing this file.
+
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
+
 buildscript {
-    // The Android Gradle plugin is only required when opening the android folder stand-alone.
-    // This avoids unnecessary downloads and potential conflicts when the library is included as a
-    // module dependency in an application project.
-    // ref: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html#sec:build_script_external_dependencies
+    // Standalone-only block: dependencies here only apply when the
+    // wrapper is opened directly in Android Studio. Consuming apps
+    // provide their own AGP / Kotlin classpath via their root build.
     if (project == rootProject) {
         repositories {
             google()
-            jcenter()
+            mavenCentral()
         }
         dependencies {
-            classpath 'com.android.tools.build:gradle:7.0.4'
+            classpath "com.android.tools.build:gradle:8.7.2"
+            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.20"
         }
     }
 }
+
 apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+apply plugin: 'com.facebook.react'
+
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
-    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
+    namespace "com.userleap.reactnative"
+    compileSdkVersion safeExtGet('compileSdkVersion', 36)
+    buildToolsVersion safeExtGet('buildToolsVersion', '35.0.0')
+
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
     }
+
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
-        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
-        versionCode 1
-        versionName "1.0"
+        minSdkVersion safeExtGet('minSdkVersion', 24)
+        targetSdkVersion safeExtGet('targetSdkVersion', 36)
     }
+
     lintOptions {
         abortOnError false
     }
 }
+
+react {
+    jsRootDir = file("../src/")
+    libraryName = "RNUserLeapBindingsSpec"
+    codegenJavaPackageName = "com.userleap.reactnative"
+}
+
 repositories {
-    // ref: https://www.baeldung.com/maven-local-repository
-    maven {
-        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        url "$rootDir/../node_modules/react-native/android"
-    }
-    maven {
-        // Android JSC is installed from npm
-        url "$rootDir/../node_modules/jsc-android/dist"
-    }
-    mavenCentral {
-        // We don't want to fetch react-native from Maven Central as there are
-        // older versions over there.
-        content {
-            excludeGroup "com.facebook.react"
-        }
-    }
+    mavenCentral()
     google()
     maven { url 'https://www.jitpack.io' }
 }
+
 dependencies {
-    implementation 'com.facebook.react:react-native:+'  // From node_modules
+    implementation 'com.facebook.react:react-native:+'
     implementation "androidx.webkit:webkit:1.8.0"
 
     // Use conditional logic for local vs Maven
     if (findProject(':userleap-android-sdk') != null) {
         implementation project(':userleap-android-sdk')
     } else {
-        implementation ("com.userleap:userleap-android-sdk:2.26.2") // update this version on android updates
+        implementation ("com.userleap:userleap-android-sdk:2.27.0") // update this version on android updates
     }
-}
+}

package/android/src/main/java/com/userleap/reactnative/UserLeapModule.kt

@@ -0,0 +1,336 @@
+package com.userleap.reactnative
+
+import android.app.Activity
+import android.util.Log
+import androidx.fragment.app.FragmentActivity
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.userleap.EventListener
+import com.userleap.EventName
+import com.userleap.EventPayload
+import com.userleap.SprigEvent
+import com.userleap.SprigSurveyResult
+import com.userleap.SurveyState
+import com.userleap.UserLeap
+import com.userleap.SprigUserInterfaceMode
+import org.json.JSONObject
+
+class UserLeapModule(reactContext: ReactApplicationContext) :
+    NativeUserLeapBindingsSpec(reactContext) {
+
+    private val reactContext: ReactApplicationContext = reactContext
+
+    // listenerLock guards activeListeners and `alive` so init-time registration and invalidate() cannot race.
+    private val listenerLock = Any()
+    private val activeListeners: MutableMap<EventName, EventListener> = HashMap()
+    @Volatile private var alive = true
+
+    init {
+        synchronized(listenerLock) {
+            registerAllNativeListeners()
+        }
+    }
+
+    // Tear down SDK subscriptions here so a late callback can't hit a dead module ("emit after invalidation").
+    override fun invalidate() {
+        synchronized(listenerLock) {
+            alive = false
+            unregisterAllNativeListeners()
+        }
+        super.invalidate()
+    }
+
+    private fun toCamelCase(upperSnakeCase: String): String {
+        val parts = upperSnakeCase.lowercase().split("_")
+        val sb = StringBuilder(parts[0])
+        for (i in 1 until parts.size) {
+            sb.append(parts[i].replaceFirstChar { it.uppercase() })
+        }
+        return sb.toString()
+    }
+
+    private fun surveyResultToWritableMap(result: SprigSurveyResult): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("surveyState", result.surveyState.name)
+        map.putInt("surveyId", result.surveyId)
+        return map
+    }
+
+    private fun wrapResultCallback(callback: Callback?): ((SprigSurveyResult) -> Unit)? {
+        if (callback == null) return null
+        return { result -> callback.invoke(surveyResultToWritableMap(result)) }
+    }
+
+    private fun stringifyMap(map: ReadableMap?): Map<String, String> {
+        if (map == null) return emptyMap()
+        return map.toHashMap()
+            .entries
+            .filter { it.key != null && it.value != null }
+            .associate { it.key!! to it.value.toString() }
+    }
+
+    private fun getFragmentActivity(): FragmentActivity? {
+        val activity: Activity? = currentActivity
+        return activity as? FragmentActivity
+    }
+
+    override fun visitorIdentifier(): Double {
+        return UserLeap.visitorIdentifier?.toDouble() ?: 0.0
+    }
+
+    override fun visitorIdentifierString(): String {
+        return UserLeap.visitorIdentifierString ?: ""
+    }
+
+    override fun getSdkVersion(): String {
+        return UserLeap.sdkVersion
+    }
+
+    override fun configure(environmentId: String, configuration: ReadableMap) {
+        UserLeap.configure(
+            reactContext,
+            environmentId,
+            stringifyMap(configuration),
+            getFragmentActivity()
+        )
+    }
+
+    override fun setPreviewKey(previewKey: String) {
+        UserLeap.setPreviewKey(previewKey)
+    }
+
+    override fun setUserIdentifier(identifier: String) {
+        UserLeap.setUserIdentifier(identifier)
+    }
+
+    override fun setEmailAddress(emailAddress: String) {
+        UserLeap.setEmailAddress(emailAddress)
+    }
+
+    override fun logout() {
+        UserLeap.logout()
+    }
+
+    override fun setVisitorAttribute(key: String, value: String) {
+        UserLeap.setVisitorAttribute(key, value)
+    }
+
+    override fun setVisitorAttributes(attributes: ReadableMap) {
+        UserLeap.setVisitorAttributes(stringifyMap(attributes))
+    }
+
+    override fun removeVisitorAttributes(keys: ReadableArray) {
+        val list = keys.toArrayList().mapNotNull { it?.toString() }
+        UserLeap.removeVisitorAttributes(list)
+    }
+
+    override fun setVisitorAttributesAndIdentify(
+        attributes: ReadableMap,
+        userId: String?,
+        partnerAnonymousId: String?
+    ) {
+        UserLeap.setVisitorAttributes(
+            stringifyMap(attributes),
+            userId,
+            partnerAnonymousId
+        )
+    }
+
+    override fun presentSurvey() {
+        UserLeap.presentSurvey(null)
+    }
+
+    override fun dismissActiveSurvey() {
+        UserLeap.dismissActiveSurvey()
+    }
+
+    override fun pauseDisplayingSurveys() {
+        UserLeap.pauseDisplayingSurveys()
+    }
+
+    override fun unpauseDisplayingSurveys() {
+        UserLeap.unpauseDisplayingSurveys()
+    }
+
+    override fun trackAndPresent(eventName: String) {
+        // The SDK requires a FragmentActivity; bail out gracefully if the current activity isn't one.
+        val activity = getFragmentActivity()
+        if (activity == null) {
+            Log.w(TAG, "trackAndPresent('$eventName') skipped: current activity is not a FragmentActivity")
+            return
+        }
+        UserLeap.trackAndPresent(eventName, activity)
+    }
+
+    override fun trackIdentifyAndPresent(
+        eventName: String,
+        userId: String?,
+        partnerAnonymousId: String?
+    ) {
+        val activity = getFragmentActivity()
+        if (activity == null) {
+            Log.w(TAG, "trackIdentifyAndPresent('$eventName') skipped: current activity is not a FragmentActivity")
+            return
+        }
+        UserLeap.trackAndPresent(eventName, userId, partnerAnonymousId, activity)
+    }
+
+    override fun overrideUserInterfaceMode(mode: Double) {
+        val modeInt = mode.toInt()
+        SprigUserInterfaceMode.values().firstOrNull { it.value == modeInt }?.let {
+            UserLeap.overrideUserInterfaceMode(it)
+        }
+    }
+
+    override fun trackEvent(eventName: String, surveyResultCallback: Callback) {
+        trackEventAndIdentify(eventName, null, null, surveyResultCallback)
+    }
+
+    override fun trackEventWithProperties(
+        eventName: String,
+        userId: String?,
+        partnerAnonymousId: String?,
+        properties: ReadableMap,
+        surveyResultCallback: Callback
+    ) {
+        val payload = EventPayload(
+            eventName,
+            userId,
+            partnerAnonymousId,
+            stringifyMap(properties),
+            wrapResultCallback(surveyResultCallback),
+            null, // shouldShowSurveyCallback
+            null  // deprecated callback
+        )
+        UserLeap.track(payload)
+    }
+
+    override fun trackEventAndIdentify(
+        eventName: String,
+        userId: String?,
+        partnerAnonymousId: String?,
+        surveyResultCallback: Callback
+    ) {
+        val payload = EventPayload(
+            eventName,
+            userId,
+            partnerAnonymousId,
+            null, // properties
+            wrapResultCallback(surveyResultCallback),
+            null, // shouldShowSurveyCallback
+            null  // deprecated callback
+        )
+        UserLeap.track(payload)
+    }
+
+    // Callback is `Callback?`: the RN bridge can pass null at runtime, so guard before invoking it.
+    override fun track(eventName: String, surveyStateCallback: Callback?) {
+        trackAndIdentify(eventName, null, null, surveyStateCallback)
+    }
+
+    override fun trackWithProperties(
+        eventName: String,
+        userId: String?,
+        partnerAnonymousId: String?,
+        properties: ReadableMap,
+        surveyStateCallback: Callback?
+    ) {
+        UserLeap.track(
+            eventName,
+            userId,
+            partnerAnonymousId,
+            stringifyMap(properties)
+        ) { state: SurveyState -> surveyStateCallback?.invoke(state.name) }
+    }
+
+    override fun trackAndIdentify(
+        eventName: String,
+        userId: String?,
+        partnerAnonymousId: String?,
+        surveyStateCallback: Callback?
+    ) {
+        UserLeap.track(eventName, userId, partnerAnonymousId) {
+            state: SurveyState -> surveyStateCallback?.invoke(state.name)
+        }
+    }
+
+    override fun getSupportedEventNames(): com.facebook.react.bridge.WritableArray {
+        val array = Arguments.createArray()
+        for (eventName in EventName.values()) {
+            if (eventName == EventName.REPLAY_EVENTS_UPLOADED_COMPLETED) continue
+            array.pushString(toCamelCase(eventName.name))
+        }
+        return array
+    }
+
+    // Caller must hold listenerLock.
+    private fun registerAllNativeListeners() {
+        if (!alive) return
+        for (eventName in EventName.values()) {
+            // Skip the deprecated alias - it would double-fire alongside REPLAY_EVENTS_UPLOAD_COMPLETED.
+            if (eventName == EventName.REPLAY_EVENTS_UPLOADED_COMPLETED) continue
+            if (activeListeners.containsKey(eventName)) continue
+
+            val listener = EventListener { event -> emitEventToJS(event) }
+            activeListeners[eventName] = listener
+            try {
+                UserLeap.addEventListener(eventName, listener)
+            } catch (t: Throwable) {
+                Log.w(TAG, "Failed to register native listener for $eventName", t)
+                activeListeners.remove(eventName)
+            }
+        }
+    }
+
+    // Caller must hold listenerLock.
+    private fun unregisterAllNativeListeners() {
+        for ((eventName, listener) in activeListeners) {
+            try {
+                UserLeap.removeEventListener(eventName, listener)
+            } catch (t: Throwable) {
+                Log.w(TAG, "Failed to remove native listener for $eventName", t)
+            }
+        }
+        activeListeners.clear()
+    }
+
+    private fun emitEventToJS(event: SprigEvent) {
+        if (!alive) return
+
+        val jsName = toCamelCase(event.name.name)
+        val json = buildEventJson(event)
+        val envelope = Arguments.createMap().apply {
+            putString("name", jsName)
+            putString("json", json)
+        }
+        try {
+            emitOnSprigEvent(envelope)
+        } catch (t: Throwable) {
+            Log.w(TAG, "Failed to emit '$jsName' to JS", t)
+        }
+    }
+
+    private fun buildEventJson(event: SprigEvent): String {
+        return try {
+            if (event.name == EventName.LOGGING_EVENT) {
+                JSONObject()
+                    .put("message", event.logMessage ?: "")
+                    .put("level", event.logLevel.toString().lowercase())
+                    .toString()
+            } else {
+                event.data?.toString() ?: "{}"
+            }
+        } catch (t: Throwable) {
+            Log.w(TAG, "Failed to build JSON payload for ${event.name}", t)
+            "{}"
+        }
+    }
+
+    companion object {
+        private const val TAG = "UserLeapModule"
+    }
+}

package/index.d.ts

@@ -11,6 +11,84 @@ declare namespace UserLeap {
         dark: number;
     };
 
+    /** Lifecycle event names for {@link addEventListener}. */
+    const SprigEventName: {
+        sdkReady: "sdkReady";
+        visitorIdUpdated: "visitorIdUpdated";
+        surveyHeight: "surveyHeight";
+        surveyStateReturned: "surveyStateReturned";
+        surveyWillPresent: "surveyWillPresent";
+        surveyPresented: "surveyPresented";
+        surveyAppeared: "surveyAppeared";
+        questionAnswered: "questionAnswered";
+        surveyCloseRequested: "surveyCloseRequested";
+        surveyWillClose: "surveyWillClose";
+        surveyClosed: "surveyClosed";
+        surveyCompleted: "surveyCompleted";
+        replayCapture: "replayCapture";
+        replayCaptureStarted: "replayCaptureStarted";
+        replayCaptureStopped: "replayCaptureStopped";
+        replayCaptureCompleted: "replayCaptureCompleted";
+        replayRenderingCompleted: "replayRenderingCompleted";
+        replayUploadCompleted: "replayUploadCompleted";
+        replayEventsUploadCompleted: "replayEventsUploadCompleted";
+        loggingEvent: "loggingEvent";
+    };
+
+    type SprigEventNameValue =
+        | "sdkReady"
+        | "visitorIdUpdated"
+        | "surveyHeight"
+        | "surveyStateReturned"
+        | "surveyWillPresent"
+        | "surveyPresented"
+        | "surveyAppeared"
+        | "questionAnswered"
+        | "surveyCloseRequested"
+        | "surveyWillClose"
+        | "surveyClosed"
+        | "surveyCompleted"
+        | "replayCapture"
+        | "replayCaptureStarted"
+        | "replayCaptureStopped"
+        | "replayCaptureCompleted"
+        | "replayRenderingCompleted"
+        | "replayUploadCompleted"
+        | "replayEventsUploadCompleted"
+        | "loggingEvent";
+
+    interface SprigEventSubscription {
+        remove(): void;
+    }
+
+    /**
+     * Severity tag on an emitted `loggingEvent` (read-only — host apps receive it,
+     * they don't set it). Android emits the real level; iOS has no log-level
+     * concept and always reports "info".
+     */
+    type SprigLogLevel = "info" | "debug" | "warning" | "error" | "critical";
+
+    /** Canonical payload for `loggingEvent`. */
+    interface SprigLoggingEventData {
+        type: "loggingEvent";
+        message: string;
+        level: SprigLogLevel;
+    }
+
+    interface SprigEventData {
+        /** Echoes the event name (e.g. "surveyPresented"). */
+        type?: string;
+        /** Survey identifier when the event is survey-scoped. */
+        surveyId?: number;
+        /** Survey state when the event carries one (e.g. surveyStateReturned). */
+        surveyState?: string;
+        /** Log message text on `loggingEvent`. */
+        message?: string;
+        /** Log level on `loggingEvent`. */
+        level?: SprigLogLevel;
+        [key: string]: any;
+    }
+
     function overrideUserInterfaceMode(mode: SprigUserInterfaceMode): void;
     function visitorIdentifier(): number;
     function visitorIdentifierString(): string;
@@ -60,5 +138,17 @@ declare namespace UserLeap {
     function unpauseDisplayingSurveys(): void;
     function trackAndPresent(event: string): void;
     function trackIdentifyAndPresent(event: string, userId: string | undefined, partnerAnonymousId: string | undefined): void;
+
+    /** Subscribe to a native SDK lifecycle event; `.remove()` unsubscribes only this listener. */
+    function addEventListener(
+        eventName: SprigEventNameValue,
+        callback: (data: SprigEventData) => void
+    ): SprigEventSubscription;
+
+    /** Remove every listener for the given event name, or all listeners if no name is given. */
+    function removeAllEventListeners(eventName?: SprigEventNameValue): void;
+
+    /** Lifecycle event names this platform's SDK emits (cached; `[]` when unavailable). */
+    function getSupportedEventNames(): SprigEventNameValue[];
 }
 export default UserLeap;