@dynatrace/react-native-plugin 2.341.1 → 2.345.1

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()
@@ -21,7 +29,9 @@ buildscript {
 }
 
 apply plugin: 'com.android.library'
-apply plugin: 'org.jetbrains.kotlin.android'
+if (!project.extensions.findByName('kotlin')) {
+    apply plugin: 'org.jetbrains.kotlin.android'
+}
 
 if (isNewArchitectureEnabled()) {
     apply plugin: 'com.facebook.react'
@@ -43,12 +53,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 {
@@ -59,8 +70,10 @@ android {
         main {
             if (isNewArchitectureEnabled()) {
                 java.srcDirs += ['src/new']
+                kotlin.srcDirs += ['src/new']
             } else {
                 java.srcDirs += ['src/old']
+                kotlin.srcDirs += ['src/old']
             }
         }
     }
@@ -72,7 +85,7 @@ repositories {
 }
 
 dependencies {
-	implementation 'com.dynatrace.agent:agent-android:8.341.1.1004'
+	implementation 'com.dynatrace.agent:agent-android:8.345.1.1003'
     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-runtime.gradle

@@ -1,33 +1,17 @@
-import org.gradle.process.ExecOperations
-import javax.inject.Inject
-
-abstract class RunLineOffsetTask extends DefaultTask {
-    @Internal
-    abstract DirectoryProperty getWorkingDirectory()
-
-    @Inject
-    abstract ExecOperations getExecOperations()
-
-    @TaskAction
-    void run() {
-        execOperations.exec {
-            workingDir workingDirectory.get().asFile
-            if (System.getProperty('os.name').toLowerCase().contains('windows')) {
-                commandLine 'cmd', '/c', 'npx', 'lineOffsetDynatrace'
-            } else {
-                commandLine 'npx', 'lineOffsetDynatrace'
-            }
-        }
-    }
-}
-
-android.applicationVariants.all { variant ->
-    if (variant.buildType.name == "release") {
-        def lineOffsetTask = tasks.register("runLineOffset${variant.name.capitalize()}", RunLineOffsetTask) {
-            workingDirectory = layout.projectDirectory
-        }
-        variant.mergeAssetsProvider.configure { task ->
-            task.dependsOn(lineOffsetTask)
-        }
-    }
-}
+// Intentionally left empty. DO NOT DELETE THIS FILE.
+//
+// Apps instrumented with an older version of this plugin have the following
+// line hard-coded in their android/app/build.gradle:
+//
+//   apply from: "../../node_modules/@dynatrace/react-native-plugin/files/plugin-runtime.gradle"
+//
+// That line lives in the customer's own build.gradle, so we cannot reliably
+// remove it on upgrade. If this file were missing, the `apply from:` above
+// would fail the Gradle build for every app that still has that line.
+//
+// Previously this script registered a release-build Gradle task that ran
+// `npx lineOffsetDynatrace` for line-offset analysis. That is no longer needed:
+// auto-instrumentation moved to a Babel plugin and capturing moved to native,
+// so the script is now a no-op kept purely for backward compatibility.
+//
+// New installs no longer add the `apply from:` line at all.

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.345.1.1003'
 }