feat: Managed layer initializes native SDK on Android

CHANGELOG.md

@@ -4,8 +4,9 @@
 
 ### API Changes
 
-- The native layer on iOS no longer self-initializes before the Unity game starts. Instead, it accepts the options at the end of the configure call. To restore the old behavior, users can opt-in to initializing native first via `IosInitializeNativeFirst`. Note that using this option comes with the limitation of baking the options into the generated Xcode project at build-time. ([#1915](https://github.com/getsentry/sentry-unity/pull/1915))
-
+- The native layer on mobile platforms (iOS and Android) no longer self-initializes before the Unity game starts. Previously, the SDK would use the options at build-time and bake them into the native layer. Instead, the SDK will now take the options passed into the `Configure` callback and use those to initialize the native SDKs. This allows users to modify the native SDK's options at runtime programmatically.
+The initialization behaviour is controlled by `IosNativeInitializationType` and `AndroidNativeInitializationType` options. These can be set from `Runtime` (default) to `BuildTime` to restore the previous flow and bake the options into the native projects. ([#1915](https://github.com/getsentry/sentry-unity/pull/1915), [#1924](https://github.com/getsentry/sentry-unity/pull/1924))
+
 ### Dependencies
 
 - Bump CLI from v2.39.0 to v2.39.1 ([#1922](https://github.com/getsentry/sentry-unity/pull/1922))

src/Sentry.Unity.Android/JniExecutor.cs

@@ -50,20 +50,26 @@ private void DoWork()
                             _taskCompletionSource?.SetResult(null);
                             break;
                         }
-                    case Func<bool?> func1:
+                    case Func<bool> func1:
                         {
                             var result = func1.Invoke();
                             _taskCompletionSource?.SetResult(result);
                             break;
                         }
-                    case Func<string?> func2:
+                    case Func<bool?> func2:
                         {
                             var result = func2.Invoke();
                             _taskCompletionSource?.SetResult(result);
                             break;
                         }
+                    case Func<string?> func3:
+                        {
+                            var result = func3.Invoke();
+                            _taskCompletionSource?.SetResult(result);
+                            break;
+                        }
                     default:
-                        throw new ArgumentException("Invalid type for _currentTask.");
+                        throw new NotImplementedException($"Task type '{_currentTask?.GetType()}' with value '{_currentTask}' is not implemented in the JniExecutor.");
                 }
             }
             catch (Exception e)

src/Sentry.Unity.Android/SentryJava.cs

@@ -1,10 +1,13 @@
 using System;
+using Sentry.Extensibility;
 using UnityEngine;
 
 namespace Sentry.Unity.Android;
 
 internal interface ISentryJava
 {
+    public bool IsEnabled(IJniExecutor jniExecutor);
+    public bool Init(IJniExecutor jniExecutor, SentryUnityOptions options);
     public string? GetInstallationId(IJniExecutor jniExecutor);
     public bool? CrashedLastRun(IJniExecutor jniExecutor);
     public void Close(IJniExecutor jniExecutor);
@@ -40,6 +43,93 @@ internal class SentryJava : ISentryJava
 {
     private static AndroidJavaObject GetSentryJava() => new AndroidJavaClass("io.sentry.Sentry");
 
+    public bool IsEnabled(IJniExecutor jniExecutor)
+    {
+        return jniExecutor.Run(() =>
+        {
+            using var sentry = GetSentryJava();
+            return sentry.CallStatic<bool>("isEnabled");
+        });
+    }
+
+    public bool Init(IJniExecutor jniExecutor, SentryUnityOptions options)
+    {
+        jniExecutor.Run(() =>
+        {
+            using var sentry = new AndroidJavaClass("io.sentry.android.core.SentryAndroid");
+            using var context = new AndroidJavaClass("com.unity3d.player.UnityPlayer")
+                .GetStatic<AndroidJavaObject>("currentActivity");
+
+            sentry.CallStatic("init", context, new AndroidOptionsConfiguration(androidOptions =>
+            {
+                androidOptions.Call("setDsn", options.Dsn);
+                androidOptions.Call("setDebug", options.Debug);
+                androidOptions.Call("setRelease", options.Release);
+                androidOptions.Call("setEnvironment", options.Environment);
+
+                var sentryLevelClass = new AndroidJavaClass("io.sentry.SentryLevel");
+                var levelString = GetLevelString(options.DiagnosticLevel);
+                var sentryLevel = sentryLevelClass.GetStatic<AndroidJavaObject>(levelString);
+                androidOptions.Call("setDiagnosticLevel", sentryLevel);
+
+                if (options.SampleRate.HasValue)
+                {
+                    androidOptions.SetIfNotNull("setSampleRate", options.SampleRate.Value);
+                }
+
+                androidOptions.Call("setMaxBreadcrumbs", options.MaxBreadcrumbs);
+                androidOptions.Call("setMaxCacheItems", options.MaxCacheItems);
+                androidOptions.Call("setSendDefaultPii", options.SendDefaultPii);
+                androidOptions.Call("setEnableNdk", options.NdkIntegrationEnabled);
+                androidOptions.Call("setEnableScopeSync", options.NdkScopeSyncEnabled);
+
+                // Options that are not to be set by the user
+                // We're disabling some integrations as to not duplicate event or because the SDK relies on the .NET SDK
+                // implementation of certain feature - i.e. Session Tracking
+
+                // Note: doesn't work - produces a blank (white) screenshot
+                androidOptions.Call("setAttachScreenshot", false);
+                androidOptions.Call("setEnableAutoSessionTracking", false);
+                androidOptions.Call("setEnableActivityLifecycleBreadcrumbs", false);
+                androidOptions.Call("setAnrEnabled", false);
+                androidOptions.Call("setEnableScopePersistence", false);
+            }, options.DiagnosticLogger));
+        });
+
+        return IsEnabled(jniExecutor);
+    }
+
+    internal class AndroidOptionsConfiguration : AndroidJavaProxy
+    {
+        private readonly Action<AndroidJavaObject> _callback;
+        private readonly IDiagnosticLogger? _logger;
+
+        public AndroidOptionsConfiguration(Action<AndroidJavaObject> callback, IDiagnosticLogger? logger)
+            : base("io.sentry.Sentry$OptionsConfiguration")
+        {
+            _callback = callback;
+            _logger = logger;
+        }
+
+        public override AndroidJavaObject? Invoke(string methodName, AndroidJavaObject[] args)
+        {
+            try
+            {
+                if (methodName != "configure" || args.Length != 1)
+                {
+                    throw new Exception($"Invalid invocation: {methodName}({args.Length} args)");
+                }
+
+                _callback(args[0]);
+            }
+            catch (Exception e)
+            {
+                _logger?.LogError(e, "Error in SentryJava.OptionsConfiguration.");
+            }
+            return null;
+        }
+    }
+
     public string? GetInstallationId(IJniExecutor jniExecutor)
     {
         return jniExecutor.Run(() =>
@@ -165,6 +255,17 @@ public ScopeCallback(Action<AndroidJavaObject> callback) : base("io.sentry.Scope
             return null;
         }
     }
+
+    // https://github.com/getsentry/sentry-java/blob/db4dfc92f202b1cefc48d019fdabe24d487db923/sentry/src/main/java/io/sentry/SentryLevel.java#L4-L9
+    internal static string GetLevelString(SentryLevel level) => level switch
+    {
+        SentryLevel.Debug => "DEBUG",
+        SentryLevel.Error => "ERROR",
+        SentryLevel.Fatal => "FATAL",
+        SentryLevel.Info => "INFO",
+        SentryLevel.Warning => "WARNING",
+        _ => "DEBUG"
+    };
 }
 
 internal static class AndroidJavaObjectExtension
@@ -186,6 +287,8 @@ public static void SetIfNotNull<T>(this AndroidJavaObject javaObject, string pro
     }
     public static void SetIfNotNull(this AndroidJavaObject javaObject, string property, int? value) =>
         SetIfNotNull(javaObject, property, value, "java.lang.Integer");
+    public static void SetIfNotNull(this AndroidJavaObject javaObject, string property, bool value) =>
+        SetIfNotNull(javaObject, property, value, "java.lang.Boolean");
     public static void SetIfNotNull(this AndroidJavaObject javaObject, string property, bool? value) =>
         SetIfNotNull(javaObject, property, value, "java.lang.Boolean");
 }

src/Sentry.Unity.Android/SentryNativeAndroid.cs

@@ -39,6 +39,16 @@ public static void Configure(SentryUnityOptions options, ISentryUnityInfo sentry
 
         JniExecutor ??= new JniExecutor();
 
+        if (SentryJava.IsEnabled(JniExecutor))
+        {
+            options.DiagnosticLogger?.LogDebug("The native SDK is already initialized");
+        }
+        else if (!SentryJava.Init(JniExecutor, options))
+        {
+            options.DiagnosticLogger?.LogError("Failed to initialize Android Native Support");
+            return;
+        }
+
         options.NativeContextWriter = new NativeContextWriter(JniExecutor, SentryJava);
         options.ScopeObserver = new AndroidJavaScopeObserver(options, JniExecutor);
         options.EnableScopeSync = true;
@@ -98,6 +108,8 @@ public static void Configure(SentryUnityOptions options, ISentryUnityInfo sentry
                 options.DiagnosticLogger?.LogDebug("Failed to create new 'Default User ID'.");
             }
         }
+
+        options.DiagnosticLogger?.LogInfo("Successfully configured the native SDK");
     }
 
     /// <summary>

src/Sentry.Unity.Editor/Android/AndroidManifestConfiguration.cs

@@ -72,6 +72,13 @@ internal AndroidManifestConfiguration(
 
     public void OnPostGenerateGradleAndroidProject(string basePath)
     {
+        if (_options is null)
+        {
+            _logger.LogWarning("Android native support disabled because Sentry has not been configured. " +
+                              "You can do that through the editor: {0}", SentryWindow.EditorMenuPath);
+            return;
+        }
+
         if (_scriptingImplementation != ScriptingImplementation.IL2CPP)
         {
             if (_options is { AndroidNativeSupportEnabled: true })
@@ -130,7 +137,18 @@ internal void ModifyManifest(string basePath)
 
         androidManifest.AddDisclaimerComment();
 
-        _logger.LogDebug("Configuring Sentry options on AndroidManifest: {0}", basePath);
+        if (_options?.AndroidNativeInitializationType is NativeInitializationType.Runtime)
+        {
+            _logger.LogDebug("Setting 'auto-init' to 'false'. The Android SDK will be initialized at runtime.");
+            androidManifest.SetAutoInit(false);
+            _ = androidManifest.Save();
+
+            return;
+        }
+
+        _logger.LogInfo("Adding Sentry options to the AndroidManifest.");
+        _logger.LogDebug("Modifying AndroidManifest: {0}", basePath);
+
         androidManifest.SetSDK("sentry.java.android.unity");
         _logger.LogDebug("Setting DSN: {0}", _options!.Dsn);
         androidManifest.SetDsn(_options.Dsn!);
@@ -419,6 +437,9 @@ internal void RemovePreviousConfigurations()
     public void AddDisclaimerComment() =>
         _applicationElement.AppendChild(_applicationElement.OwnerDocument.CreateComment(Disclaimer));
 
+    internal void SetAutoInit(bool enableAutoInit)
+        => SetMetaData($"{SentryPrefix}.auto-init", enableAutoInit.ToString());
+
     internal void SetDsn(string dsn) => SetMetaData($"{SentryPrefix}.dsn", dsn);
 
     internal void SetSampleRate(float sampleRate) =>

src/Sentry.Unity.iOS/SentryNativeCocoa.cs

@@ -87,7 +87,7 @@ internal static void Configure(SentryUnityOptions options, ISentryUnityInfo sent
             }
         }
 
-        options.DiagnosticLogger?.LogInfo("Successfully initialized the native SDK");
+        options.DiagnosticLogger?.LogInfo("Successfully configured the native SDK");
     }
 
     /// <summary>

src/Sentry.Unity/SentryUnityOptions.cs

@@ -150,16 +150,34 @@ public sealed class SentryUnityOptions : SentryOptions
     public bool IosNativeSupportEnabled { get; set; } = true;
 
     /// <summary>
-    /// Whether the SDK should initialize the native SDK before the Unity game. This bakes the options at build-time into
-    /// the generated Xcode project
+    /// Whether the SDK should initialize the native SDK before the game starts. This bakes the options at build-time into
+    /// the generated Xcode project. Modifying the options at runtime will not affect the options used to initialize
+    /// the native SDK.
     /// </summary>
+    /// <remarks>
+    /// When set to <see cref="NativeInitializationType.BuildTime"/>, the options are written and hardcoded into the
+    /// Gradle project during the build process. This means that the options cannot be changed at runtime, as they are
+    /// embedded into the project itself.
+    /// </remarks>
     public NativeInitializationType IosNativeInitializationType { get; set; } = NativeInitializationType.Runtime;
 
     /// <summary>
     /// Whether the SDK should add native support for Android
     /// </summary>
     public bool AndroidNativeSupportEnabled { get; set; } = true;
 
+    /// <summary>
+    /// Whether the SDK should initialize the native SDK before the game starts. This bakes the options at build-time into
+    /// the generated Gradle project. Modifying the options at runtime will not affect the options used to initialize
+    /// the native SDK.
+    /// </summary>
+    /// <remarks>
+    /// When set to <see cref="NativeInitializationType.BuildTime"/>, the options are written and hardcoded into the
+    /// Gradle project during the build process. This means that the options cannot be changed at runtime, as they are
+    /// embedded into the project itself.
+    /// </remarks>
+    public NativeInitializationType AndroidNativeInitializationType { get; set; } = NativeInitializationType.Runtime;
+
     /// <summary>
     /// Whether the SDK should add the NDK integration for Android
     /// </summary>