@dynatrace/react-native-plugin 2.341.1 → 2.343.1

package/README.md

@@ -23,20 +23,20 @@ If you want to start using this plugin and are not a Dynatrace customer yet, hea
 * React v16.8 or newer
 * React Native v0.60 or newer
 * For Android users: 
-  * SDK version 21+
-  * Gradle version 7.0+ ([How to update?](#updating-to-gradle-7))
+  * SDK version 23+
+  * Gradle version 8.1.1+ ([How to update?](#updating-to-gradle-7))
   * Android Gradle plugin version 7.0+
-  * Java 11
+  * Java 17
   * Kotlin 2.0.21 - see [Kotlin Compatibility Note](#kotlin-compatibility-note)
   * Jetpack Compose 1.4 - 1.10 - see [Compose Compatibility Note](#compose-compatibility-note)
-* For iOS users: Minimum iOS 12
+* For iOS users: Minimum iOS 15
 * NodeJS 16.0.0+ since our dependencies require NodeJS 16.0.0
 
 ## Agent Versions
 These agent versions are configured in this plugin:
 
-* Android Agent: 8.341.1.1004
-* iOS Agent: 8.341.1.1010
+* Android Agent: 8.343.1.1038
+* iOS Agent: 8.343.1.1007
 
 ## Quick Setup
 
@@ -1049,7 +1049,7 @@ If masking is active for an interaction, the event still contains the same struc
   "ui_element.components": ["Pressable"],
   "ui_element.id": "App/View/Pressable",
   "ui_element.name_origin": "component",
-  "interaction.name": "touch",
+  "interaction.type": "touch",
   "positions": [{ "x": 120, "y": 460 }],
   "ui_element.responder.detected_name": "Pressable",
   "ui_element.responder.components": ["Pressable"],
@@ -1160,6 +1160,7 @@ npx instrumentDynatrace [optional: config=... gradle=... plist=...]
 * `gradle=C:\MyReactAndroidProject\build.gradle`: The location of the root build.gradle file. We will assume that the other gradle file resides in `/app/build.gradle`. This will add the whole agent dependencies automatically for you and will update the configuration.
 * `plist=C:\MyReactIOSProject\projectName\info.plist`: Tell the script where your info.plist file is. The plist file is used for updating the configuration for the agent. 
 * `config=C:\SpecialFolderForDynatrace\dynatrace.config.js`: If you have not got your config file in the root folder of the React Native project but somewhere else.
+* `--reset`: Clear any previously-persisted custom config path and revert the Metro/Babel transformer to the default `dynatrace.config.js` lookup. Useful after switching between build flavors.
 
 If `plist=...` is not provided, the plugin tries to resolve `Info.plist` automatically in this order:
 
@@ -1188,6 +1189,22 @@ Our scripts assumes that the usual React Native project structure is given. The
 * `plist=C:\MyReactIOSProject\projectName\info.plist`: Tell the script where your info.plist file is. The plist file is used for updating the configuration for the agent. 
 * `config=C:\SpecialFolderForDynatrace\dynatrace.config.js`: If you have not got your config file in the root folder of the React Native project but somewhere else.
 
+### DYNATRACE_CONFIG environment variable
+
+As an alternative to `config=`, you can set the `DYNATRACE_CONFIG` environment variable to specify the config file path. This is particularly useful in CI pipelines and Xcode schemes where multiple build flavors each need their own config file, because it does not require changing the instrumentation script — only the environment of the build step.
+
+```
+DYNATRACE_CONFIG=dynatrace.config.prod.js npx instrumentDynatrace
+```
+
+**Precedence (highest to lowest):**
+
+1. `config=` CLI argument — always wins
+2. `DYNATRACE_CONFIG` environment variable
+3. Default `dynatrace.config.js` in the project root
+
+> **Note:** `DYNATRACE_CONFIG` applies to the **Metro/Babel transformer** as well as `npx instrumentDynatrace`. This means you can set it in your Xcode scheme's environment variables to ensure the correct config is used during iOS archive/bundling, independently of what was passed to the instrumentation step.
+
 Examples:
 
  * React Native v0.60.1 or newer:
@@ -2071,7 +2088,19 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 <br/><br/>
 ## Changelog
 
-In Progress
+2.343.1
+* Updated Android (8.343.1.1038) & iOS Agent (8.343.1.1007)
+* Added User Actions feature
+* Raised minimum platform requirements for Android and iOS
+  * Android API level: 21 → 23
+  * Java: 11 → 17
+  * AGP: 7.0+ → 8.1.1+
+  * iOS SDK: 12 → 15
+* Fixed iOS archive/bundle crash (`ENOENT: no such file or directory`) in projects that use app-specific config files (e.g. `dynatrace.config.prod.js`) instead of the default `dynatrace.config.js` at the repo root. The config resolution code was unconditionally reading the config file before `require()`, causing a hard crash in the Metro/Babel transformer instead of a graceful "config not found" fallback. Discovered via external report from a monorepo setup with multiple build flavors.
+* Fixed custom config path (`config=` argument to `npx instrumentDynatrace`) being lost between build steps: previously, running `npx instrumentDynatrace` without arguments in a subsequent build step (e.g. a generic iOS build phase) would silently delete the persisted custom path, causing Metro bundler to fall back to the hardcoded `dynatrace.config.js` and crash. The custom path is now preserved until explicitly overridden.
+* Added `DYNATRACE_CONFIG` environment variable as an alternative way to specify the config file path for the Metro/Babel transformer.
+* Added `npx instrumentDynatrace --reset` flag to clear a previously-persisted custom config path and revert the Metro/Babel transformer to the default `dynatrace.config.js` lookup. Useful after switching between build flavors that each use a different config file.
+* Fixed incorrect `start_time` on Android app start events when `3rd_gen_enabled` is false. The `EventPipeline` was suppressing the `forwardAppStartEvent` timing-correction call along with all other 3rd-gen events, causing the native Dynatrace SDK to report its own stale process-creation timestamp instead of the actual JS bundle load time.
 
 2.341.1
 * Updated Android (8.341.1.1004) & iOS Agent (8.341.1.1010)
@@ -2084,7 +2113,6 @@ In Progress
 * Updated `@babel/runtime` to latest major version
 * Fixed security vulnerabilities in `ws` and `brace-expansion` dependencies
 
-
 2.339.1
 * Updated Android (8.339.1.1004) & iOS Agent (8.339.1.1011)
 * Enabled User Interaction Feature by default

package/android/build.gradle

@@ -8,6 +8,14 @@ def isNewArchitectureEnabled() {
     return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
+// Build-time master switch for the screenshot self-monitoring (replay metrics) feature.
+// Defaults to enabled; disable for a build with -PdynatraceReplayMetricsEnabled=false
+// (or set dynatraceReplayMetricsEnabled=false in gradle.properties). When false, the monitor is
+// never registered, regardless of the remote `replay_metrics_enabled` flag.
+def isReplayMetricsBuildEnabled() {
+    return !project.hasProperty("dynatraceReplayMetricsEnabled") || project.dynatraceReplayMetricsEnabled == "true"
+}
+
 buildscript {
     repositories {
 		google()
@@ -43,12 +51,13 @@ android {
     }
 
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', 21)
+        minSdkVersion safeExtGet('minSdkVersion', 23)
         targetSdkVersion safeExtGet('targetSdkVersion', 31)
         versionCode 1
         versionName "1.0"
 
         buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        buildConfigField "boolean", "REPLAY_METRICS_ENABLED", isReplayMetricsBuildEnabled().toString()
     }
 
     lintOptions {
@@ -72,7 +81,7 @@ repositories {
 }
 
 dependencies {
-	implementation 'com.dynatrace.agent:agent-android:8.341.1.1004'
+	implementation 'com.dynatrace.agent:agent-android:8.343.1.1038'
     implementation "com.facebook.react:react-native:${safeExtGet('reactNative', '+')}"
 }
   

package/android/src/main/java/com/dynatrace/android/agent/DynatraceAppStartModule.kt

@@ -1,6 +1,5 @@
 package com.dynatrace.android.agent
 
-import android.os.SystemClock
 import com.dynatrace.android.agent.model.AppStartMeasurement
 import com.dynatrace.android.agent.model.AppStartMeasurementType
 import com.facebook.react.bridge.Arguments
@@ -31,52 +30,31 @@ private val buffer: Queue<AppStartMeasurement> = ConcurrentLinkedQueue()
  * Setup to register all time points which we want to use to report correct app startup time.
  */
 fun setupAppStartListener() {
-    val initTimestamp = System.currentTimeMillis() - SystemClock.elapsedRealtime();
     ReactMarker.addListener { name: ReactMarkerConstants?, _: String?, _: Int ->
         when (name) {
             ReactMarkerConstants.RELOAD -> {
                 buffer.clear()
-                buffer.add(
-                    AppStartMeasurement(
-                        AppStartMeasurementType.RELOAD.value,
-                        initTimestamp + SystemClock.elapsedRealtime()
-                    )
-                )
+                buffer.add(AppStartMeasurement(AppStartMeasurementType.RELOAD.value, TimeLineProvider.getSystemTime()))
             }
 
-            ReactMarkerConstants.CONTENT_APPEARED -> buffer.add(
-                AppStartMeasurement(
-                    AppStartMeasurementType.CONTENT_APPEARED.value,
-                    initTimestamp + SystemClock.elapsedRealtime()
-                )
-            )
+            ReactMarkerConstants.CONTENT_APPEARED -> {
+                buffer.add(AppStartMeasurement(AppStartMeasurementType.CONTENT_APPEARED.value, TimeLineProvider.getSystemTime()))
+            }
 
             ReactMarkerConstants.DOWNLOAD_END -> buffer.add(
-                AppStartMeasurement(
-                    AppStartMeasurementType.DOWNLOAD_END.value,
-                    initTimestamp + SystemClock.elapsedRealtime()
-                )
+                AppStartMeasurement(AppStartMeasurementType.DOWNLOAD_END.value, TimeLineProvider.getSystemTime())
             )
 
             ReactMarkerConstants.DOWNLOAD_START -> buffer.add(
-                AppStartMeasurement(
-                    AppStartMeasurementType.DOWNLOAD_START.value,
-                    initTimestamp + SystemClock.elapsedRealtime()
-                )
+                AppStartMeasurement(AppStartMeasurementType.DOWNLOAD_START.value, TimeLineProvider.getSystemTime())
             )
 
             ReactMarkerConstants.RUN_JS_BUNDLE_END -> buffer.add(
-                AppStartMeasurement(
-                    AppStartMeasurementType.RUN_JS_BUNDLE_END.value,
-                    initTimestamp + SystemClock.elapsedRealtime()
-                )
+                AppStartMeasurement(AppStartMeasurementType.RUN_JS_BUNDLE_END.value, TimeLineProvider.getSystemTime())
             )
 
             ReactMarkerConstants.RUN_JS_BUNDLE_START -> buffer.add(
-                AppStartMeasurement(
-                    AppStartMeasurementType.RUN_JS_BUNDLE_START.value,
-                    initTimestamp + SystemClock.elapsedRealtime()
-                )
+                AppStartMeasurement(AppStartMeasurementType.RUN_JS_BUNDLE_START.value, TimeLineProvider.getSystemTime())
             )
 
             else -> {
@@ -126,4 +104,4 @@ internal class DynatraceAppStartModule(reactContext: ReactApplicationContext?) :
     override fun getName(): String {
         return APP_START_MODULE
     }
-}
+}

package/android/src/main/java/com/dynatrace/android/agent/DynatraceConfigurationModule.kt

@@ -25,6 +25,7 @@ internal class DynatraceConfigurationModule(reactContext: ReactApplicationContex
     
     init {
         setupInternalListener()
+        reactApplicationContext?.let { ScreenshotSelfMonitor.initialize(it) }
     }
 
     /**

package/android/src/main/java/com/dynatrace/android/agent/DynatraceRNBridgeImpl.kt

@@ -308,6 +308,47 @@ class DynatraceRNBridgeImpl(
         HybridBridge.forwardAppStartEvent(JSONObject(DynatraceUtils.toHashMap(attributes)), appStartKeys.toArrayList() as ArrayList<String>)
     }
 
+    fun setAutomaticUserActionDetection(enabled: Boolean) {
+        HybridBridge.setAutomaticUserActionDetection(enabled)
+    }
+
+    fun createUserAction(
+        actionId: String,
+        name: String,
+        completeAutomatically: Boolean,
+        properties: ReadableMap?
+    ) {
+        val jsonProperties = properties?.let {
+            JSONObject(DynatraceUtils.toHashMap(it))
+        }
+        HybridBridge.createUserAction(
+            actionId,
+            name,
+            completeAutomatically,
+            jsonProperties
+        )
+    }
+
+    fun addEventStringPropertyToUserAction(actionId: String, key: String, value: String) {
+        HybridBridge.addEventPropertyToUserAction(actionId, key, value)
+    }
+
+    fun addEventDoublePropertyToUserAction(actionId: String, key: String, value: Double) {
+        HybridBridge.addEventPropertyToUserAction(actionId, key, value)
+    }
+
+    fun addEventBooleanPropertyToUserAction(actionId: String, key: String, value: Boolean) {
+        HybridBridge.addEventPropertyToUserAction(actionId, key, value)
+    }
+
+    fun completeUserAction(actionId: String) {
+        HybridBridge.completeUserAction(actionId)
+    }
+
+    fun setCompleteUserActionAutomatically(actionId: String, enabled: Boolean) {
+        HybridBridge.setCompleteUserActionAutomatically(actionId, enabled)
+    }
+
     fun startView(name: String) {
         Dynatrace.startView(name)
     }

package/android/src/main/java/com/dynatrace/android/agent/DynatraceUtils.kt

@@ -1,6 +1,7 @@
 package com.dynatrace.android.agent
 
 import android.util.Log
+import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType

package/android/src/main/java/com/dynatrace/android/agent/ScreenshotSelfMonitor.kt

@@ -0,0 +1,175 @@
+package com.dynatrace.android.agent
+
+import android.util.Log
+import com.dynatrace.android.agent.conf.ConfigurationSubscriber
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import java.util.concurrent.atomic.AtomicBoolean
+
+private const val TAG = "dtxScreenshotSelfMonitor"
+
+/**
+ * Remote feature-flag key in the cross-platform configuration map that turns screenshot
+ * self-monitoring on. Monitoring is off unless the server delivers this flag as `true`, which keeps
+ * the per-frame UI-change observation dormant for apps where it isn't enabled.
+ */
+private const val CONFIG_KEY_REPLAY_METRICS = "replay_metrics_enabled"
+
+// DEM-26735: replay metrics experiment sunsets on 2026-10-15T00:00:00Z; remove this class after that date.
+private const val EXPERIMENT_EXPIRY_EPOCH_MS = 1_792_022_400_000L
+
+/**
+ * Drives the screenshot self-monitoring feature.
+ *
+ * Responsibilities:
+ *  - Subscribes to the agent configuration and toggles monitoring based on
+ *    [CONFIG_KEY_REPLAY_METRICS].
+ *  - When enabled, registers a [UIChangeScreenshotListener] on the current activity and keeps it
+ *    bound to the foreground activity across the React host lifecycle.
+ *
+ * Threading: configuration is delivered on a background thread, but [ViewTreeObserver][android.view.ViewTreeObserver]
+ * registration must happen on the main thread. All monitoring state ([monitoringEnabled],
+ * [uiChangeListener], [lifecycleListenerRegistered]) is therefore confined to the UI thread —
+ * config toggles are posted there and the host lifecycle callbacks already run there — so no locking
+ * is required.
+ *
+ * A single instance is registered for the lifetime of the React instance via [initialize].
+ */
+internal class ScreenshotSelfMonitor private constructor(
+    private val reactApplicationContext: ReactApplicationContext
+) : LifecycleEventListener, ConfigurationSubscriber {
+
+    private var monitoringEnabled = false
+    private var uiChangeListener: UIChangeScreenshotListener? = null
+    private var lifecycleListenerRegistered = false
+
+    private fun register() {
+        // The publisher immediately notifies us with the current configuration on registration.
+        HybridBridge.addConfigurationSubscriber(this)
+    }
+
+    override fun notify(configuration: Map<String, Any>) {
+        val flagEnabled = configuration[CONFIG_KEY_REPLAY_METRICS] as? Boolean ?: false
+        val enabled = flagEnabled && !isExperimentExpired()
+        if (flagEnabled && !enabled) {
+            Log.d(TAG, "notify: $CONFIG_KEY_REPLAY_METRICS=true but experiment expired — treating as disabled")
+        } else {
+            Log.d(TAG, "notify: $CONFIG_KEY_REPLAY_METRICS = $flagEnabled")
+        }
+        UiThreadUtil.runOnUiThread { setMonitoringEnabled(enabled) }
+    }
+
+    private fun isExperimentExpired(): Boolean =
+        System.currentTimeMillis() >= EXPERIMENT_EXPIRY_EPOCH_MS
+
+    private fun setMonitoringEnabled(enabled: Boolean) {
+        if (enabled == monitoringEnabled) {
+            Log.d(TAG, "setMonitoringEnabled: no change (still $enabled)")
+            return
+        }
+        monitoringEnabled = enabled
+
+        if (enabled) {
+            Log.d(TAG, "$CONFIG_KEY_REPLAY_METRICS enabled — starting screenshot self-monitoring")
+            registerUIChangeListener()
+        } else {
+            Log.d(TAG, "$CONFIG_KEY_REPLAY_METRICS disabled — stopping screenshot self-monitoring")
+            deregisterUIChangeListener()
+        }
+    }
+
+    private fun registerUIChangeListener() {
+        if (uiChangeListener != null) return
+
+        if (!lifecycleListenerRegistered) {
+            reactApplicationContext.addLifecycleEventListener(this)
+            lifecycleListenerRegistered = true
+        }
+
+        val activity = reactApplicationContext.currentActivity
+        if (activity == null) {
+            Log.w(TAG, "No current activity — UIChangeScreenshotListener registration deferred to onHostResume")
+            return
+        }
+
+        val listener = UIChangeScreenshotListener()
+        if (!listener.registerOn(activity)) {
+            Log.w(TAG, "Failed to register OnDrawListener")
+            return
+        }
+        uiChangeListener = listener
+        Log.d(TAG, "UIChangeScreenshotListener registered")
+    }
+
+    private fun deregisterUIChangeListener() {
+        if (lifecycleListenerRegistered) {
+            reactApplicationContext.removeLifecycleEventListener(this)
+            lifecycleListenerRegistered = false
+        }
+        uiChangeListener?.unregister()
+        uiChangeListener = null
+        Log.d(TAG, "UIChangeScreenshotListener deregistered")
+    }
+
+    // Host lifecycle callbacks are delivered on the UI thread.
+    override fun onHostResume() {
+        if (!monitoringEnabled) return
+
+        val activity = reactApplicationContext.currentActivity
+        if (activity == null) {
+            if (uiChangeListener != null) {
+                Log.d(TAG, "onHostResume: no activity, tearing down UIChangeScreenshotListener")
+                deregisterUIChangeListener()
+            }
+            return
+        }
+
+        // Deferred registration: monitoring was enabled before an activity was available
+        if (uiChangeListener == null) {
+            Log.d(TAG, "onHostResume: attempting deferred UIChangeScreenshotListener registration")
+            registerUIChangeListener()
+            return
+        }
+
+        val listener = uiChangeListener ?: return
+        Log.d(TAG, "onHostResume: re-registering UIChangeScreenshotListener on current activity")
+        listener.unregister()
+        if (!listener.registerOn(activity)) {
+            Log.w(TAG, "onHostResume: failed to re-register UIChangeScreenshotListener, tearing down")
+            deregisterUIChangeListener()
+        }
+    }
+
+    override fun onHostPause() {
+        Log.d(TAG, "onHostPause: unregistering UIChangeScreenshotListener")
+        uiChangeListener?.unregister()
+    }
+
+    override fun onHostDestroy() {
+        Log.d(TAG, "onHostDestroy: deregistering UIChangeScreenshotListener")
+        deregisterUIChangeListener()
+    }
+
+    companion object {
+        private val initialized = AtomicBoolean(false)
+
+        /**
+         * Creates and registers the single [ScreenshotSelfMonitor] for the current React instance.
+         * Safe to call multiple times (e.g. from different module init paths / architectures); only
+         * the first call takes effect.
+         */
+        @JvmStatic
+        fun initialize(reactApplicationContext: ReactApplicationContext) {
+            // Build-time master switch (see android/build.gradle isReplayMetricsBuildEnabled()).
+            // When disabled the monitor is never registered, so the remote flag can't turn it on.
+            if (!BuildConfig.REPLAY_METRICS_ENABLED) {
+                Log.d(TAG, "screenshot self-monitoring disabled at build time — not registering")
+                return
+            }
+            if (initialized.compareAndSet(false, true)) {
+                ScreenshotSelfMonitor(reactApplicationContext).register()
+            }
+        }
+    }
+}

package/android/src/main/java/com/dynatrace/android/agent/UIChangeScreenshotListener.kt

@@ -0,0 +1,124 @@
+package com.dynatrace.android.agent
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.util.Log
+import android.view.ViewTreeObserver
+import java.lang.ref.WeakReference
+import java.util.concurrent.atomic.AtomicBoolean
+
+private const val TAG = "dtxScreenshotSelfMonitor"
+private const val DEBOUNCE_MS = 500L
+private const val MAX_DEBOUNCE_MS = 2000L
+
+/**
+ * Self-monitoring listener that mirrors the Session Replay UI-change detection, but instead of
+ * capturing a screenshot it only increments the cross-platform screenshot counter via
+ * [HybridBridge.trackCrossPlatformScreenshot].
+ *
+ * The purpose is to estimate how many screenshots the Session Replay UI-change listener *would*
+ * take in production, without shipping the (not yet published) Session Replay package.
+ *
+ * It observes [ViewTreeObserver.OnDrawListener] on the current activity's decor view and debounces
+ * bursts of draws (a settled UI is reported once). Both [lastDrawTime] and [firstDrawTime] are only
+ * touched on the main thread (`onDraw` and the Handler-posted [captureRunnable]).
+ */
+internal class UIChangeScreenshotListener : ViewTreeObserver.OnDrawListener {
+
+    private val pending = AtomicBoolean(false)
+    private val handler = Handler(Looper.getMainLooper())
+    private var registeredActivity: WeakReference<Activity>? = null
+
+    private var lastDrawTime = 0L
+    private var firstDrawTime = 0L
+
+    private val captureRunnable = Runnable { performCapture() }
+
+    override fun onDraw() {
+        val now = SystemClock.uptimeMillis()
+        lastDrawTime = now
+        if (pending.compareAndSet(false, true)) {
+            firstDrawTime = now
+            handler.postDelayed(captureRunnable, DEBOUNCE_MS)
+        }
+    }
+
+    fun registerOn(activity: Activity): Boolean {
+        if (registeredActivity?.get() === activity) return true
+
+        // Clean up previous registration if switching activities
+        unregister()
+
+        val decorView = activity.window?.decorView
+        if (decorView == null) {
+            Log.w(TAG, "Cannot register: decorView is null")
+            return false
+        }
+        val observer = decorView.viewTreeObserver
+        if (!observer.isAlive) {
+            Log.w(TAG, "Cannot register: ViewTreeObserver is not alive")
+            return false
+        }
+
+        observer.addOnDrawListener(this)
+        registeredActivity = WeakReference(activity)
+        Log.d(TAG, "Registered OnDrawListener on DecorView")
+        return true
+    }
+
+    fun unregister() {
+        val activity = registeredActivity?.get()
+        if (activity != null) {
+            try {
+                val decorView = activity.window?.decorView
+                val observer = decorView?.viewTreeObserver
+                if (observer != null && observer.isAlive) {
+                    observer.removeOnDrawListener(this)
+                }
+            } catch (e: IllegalStateException) {
+                Log.w(TAG, "Expected cleanup issue removing OnDrawListener", e)
+            } catch (e: Exception) {
+                Log.e(TAG, "Unexpected error removing OnDrawListener", e)
+            }
+        }
+        registeredActivity = null
+        dispose()
+    }
+
+    private fun performCapture() {
+        if (registeredActivity?.get() == null) {
+            // Leave pending=true so onDraw won't schedule further captures
+            Log.w(TAG, "Activity reference lost (GC'd) — capture abandoned")
+            handler.removeCallbacks(captureRunnable)
+            return
+        }
+
+        val now = SystemClock.uptimeMillis()
+        val elapsed = now - lastDrawTime
+        val sinceFirst = now - firstDrawTime
+
+        // Reschedule if UI still active, unless max wait exceeded
+        if (elapsed < DEBOUNCE_MS && sinceFirst < MAX_DEBOUNCE_MS) {
+            val remaining = DEBOUNCE_MS - elapsed
+            Log.d(TAG, "UI still active, rescheduling in ${remaining}ms")
+            handler.postDelayed(captureRunnable, remaining)
+            return
+        }
+
+        pending.set(false)
+
+        try {
+            Log.d(TAG, "Tracking cross-platform screenshot (self-monitoring)")
+            HybridBridge.trackCrossPlatformScreenshot()
+        } catch (e: Exception) {
+            Log.e(TAG, "trackCrossPlatformScreenshot failed during UI change capture", e)
+        }
+    }
+
+    fun dispose() {
+        handler.removeCallbacks(captureRunnable)
+        pending.set(false)
+    }
+}

package/android/src/new/java/com/dynatrace/android/agent/DynatraceRNBridge.kt

@@ -179,6 +179,39 @@ class DynatraceRNBridge(
         impl.forwardAppStartEvent(attributes, appStartKeys)
     }
 
+    override fun setAutomaticUserActionDetection(enabled: Boolean) {
+        impl.setAutomaticUserActionDetection(enabled)
+    }
+
+    override fun createUserAction(
+        actionId: String,
+        name: String,
+        completeAutomatically: Boolean,
+        properties: ReadableMap?
+    ) {
+        impl.createUserAction(actionId, name, completeAutomatically, properties)
+    }
+
+    override fun addEventStringPropertyToUserAction(actionId: String, key: String, value: String) {
+        impl.addEventStringPropertyToUserAction(actionId, key, value)
+    }
+
+    override fun addEventDoublePropertyToUserAction(actionId: String, key: String, value: Double) {
+        impl.addEventDoublePropertyToUserAction(actionId, key, value)
+    }
+
+    override fun addEventBooleanPropertyToUserAction(actionId: String, key: String, value: Boolean) {
+        impl.addEventBooleanPropertyToUserAction(actionId, key, value)
+    }
+
+    override fun completeUserAction(actionId: String) {
+        impl.completeUserAction(actionId)
+    }
+
+    override fun setCompleteUserActionAutomatically(actionId: String, enabled: Boolean) {
+        impl.setCompleteUserActionAutomatically(actionId, enabled)
+    }
+
     override fun startView(name: String) {
         impl.startView(name)
     }

package/android/src/old/java/com/dynatrace/android/agent/DynatraceRNBridge.kt

@@ -197,6 +197,46 @@ class DynatraceRNBridge(
         impl.forwardAppStartEvent(attributes, appStartKeys)
     }
 
+    @ReactMethod
+    fun setAutomaticUserActionDetection(enabled: Boolean) {
+        impl.setAutomaticUserActionDetection(enabled)
+    }
+
+    @ReactMethod
+    fun createUserAction(
+        actionId: String,
+        name: String,
+        completeAutomatically: Boolean,
+        properties: ReadableMap?
+    ) {
+        impl.createUserAction(actionId, name, completeAutomatically, properties)
+    }
+
+    @ReactMethod
+    fun addEventStringPropertyToUserAction(actionId: String, key: String, value: String) {
+        impl.addEventStringPropertyToUserAction(actionId, key, value)
+    }
+
+    @ReactMethod
+    fun addEventDoublePropertyToUserAction(actionId: String, key: String, value: Double) {
+        impl.addEventDoublePropertyToUserAction(actionId, key, value)
+    }
+
+    @ReactMethod
+    fun addEventBooleanPropertyToUserAction(actionId: String, key: String, value: Boolean) {
+        impl.addEventBooleanPropertyToUserAction(actionId, key, value)
+    }
+
+    @ReactMethod
+    fun completeUserAction(actionId: String) {
+        impl.completeUserAction(actionId)
+    }
+
+    @ReactMethod
+    fun setCompleteUserActionAutomatically(actionId: String, enabled: Boolean) {
+        impl.setCompleteUserActionAutomatically(actionId, enabled)
+    }
+
     @ReactMethod
     fun startView(name: String) {
         impl.startView(name)

package/files/plugin.gradle

@@ -1,4 +1,4 @@
 // TEMPLATE: plugin-gradle.template
 dependencies {
-	classpath 'com.dynatrace.tools.android:gradle-plugin:8.341.1.1004'
+	classpath 'com.dynatrace.tools.android:gradle-plugin:8.343.1.1038'
 }