poc(native): Add Android support for out-of-process crash handling

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+**Features**:
+
+- Native: add Android support. ([#1725](https://github.com/getsentry/sentry-native/pull/1725))
+
 **Fixes**:
 
 - Reject overly deep msgpack payloads during deserialization. ([#1727](https://github.com/getsentry/sentry-native/pull/1727))

CMakeLists.txt

@@ -187,6 +187,8 @@ elseif(SENTRY_TRANSPORT STREQUAL "curl")
 	set(SENTRY_TRANSPORT_CURL TRUE)
 elseif(SENTRY_TRANSPORT STREQUAL "none")
 	set(SENTRY_TRANSPORT_NONE TRUE)
+elseif(SENTRY_TRANSPORT STREQUAL "stdout")
+	set(SENTRY_TRANSPORT_STDOUT TRUE)
 elseif(SENTRY_TRANSPORT STREQUAL "pshttp")
 	# Not implemented here, but in the downstream SDK
 	if(NOT PROSPERO)
@@ -841,6 +843,11 @@ elseif(SENTRY_BACKEND_NATIVE)
 		${PROJECT_SOURCE_DIR}/src
 		${PROJECT_SOURCE_DIR}/src/backends/native
 	)
+	if(SENTRY_WITH_LIBUNWINDSTACK)
+		target_include_directories(sentry-crash PRIVATE
+			${PROJECT_SOURCE_DIR}/external/libunwindstack-ndk/include
+		)
+	endif()
 
 	# Link same libraries as sentry
 	target_link_libraries(sentry-crash PRIVATE ${_SENTRY_PLATFORM_LIBS})

ndk/gradle.properties

@@ -50,3 +50,6 @@ systemProp.org.gradle.internal.http.socketTimeout=120000
 android.nonTransitiveRClass=true
 
 android.suppressUnsupportedCompileSdk=34
+
+# TODO: clean up
+sentryBackend=native

ndk/lib/CMakeLists.txt

@@ -13,9 +13,27 @@ endif()
 set(BUILD_SHARED_LIBS ON)
 set(SENTRY_BUILD_SHARED_LIBS ON)
 
+if(SENTRY_BACKEND STREQUAL "native")
+	find_package(curl REQUIRED CONFIG)
+	if(NOT TARGET CURL::libcurl)
+		add_library(CURL::libcurl INTERFACE IMPORTED)
+		target_link_libraries(CURL::libcurl INTERFACE curl::curl_static)
+	endif()
+	set(SENTRY_TRANSPORT "curl" CACHE STRING "" FORCE)
+endif()
+
 # Adding sentry-native project
 add_subdirectory(${SENTRY_NATIVE_SRC} sentry_build)
 
+if(SENTRY_BACKEND STREQUAL "native")
+	set_target_properties(sentry-crash PROPERTIES
+		PREFIX "lib"
+		OUTPUT_NAME "sentry-crash"
+		SUFFIX ".so"
+	)
+	target_link_options(sentry-crash PRIVATE "-Wl,-z,max-page-size=16384")
+endif()
+
 # Android logging library
 find_library(LOG_LIB log)
 

ndk/lib/api/sentry-native-ndk.api

@@ -96,7 +96,9 @@ public final class io/sentry/ndk/NdkOptions {
 	public fun getSdkName ()Ljava/lang/String;
 	public fun getTracesSampleRate ()F
 	public fun isDebug ()Z
+	public fun isTombstoneEnabled ()Z
 	public fun setNdkHandlerStrategy (Lio/sentry/ndk/NdkHandlerStrategy;)V
+	public fun setTombstoneEnabled (Z)V
 	public fun setTracesSampleRate (F)V
 }
 

ndk/lib/build.gradle.kts

@@ -5,6 +5,7 @@ plugins {
 }
 
 var sentryNativeSrc: String = "${project.projectDir}/../.."
+val sentryBackend = providers.gradleProperty("sentryBackend").orElse("inproc").get()
 
 android {
     compileSdk = 35
@@ -18,6 +19,7 @@ android {
         externalNativeBuild {
             cmake {
                 arguments.add(0, "-DANDROID_STL=c++_static")
+                arguments.add(0, "-DSENTRY_BACKEND=$sentryBackend")
                 arguments.add(0, "-DSENTRY_NATIVE_SRC=$sentryNativeSrc")
             }
         }
@@ -51,6 +53,7 @@ android {
     }
 
     buildFeatures {
+        prefab = true
         prefabPublishing = true
         buildConfig = true
     }
@@ -100,6 +103,9 @@ android {
 }
 
 dependencies {
+    // TODO: this was the first match on maven central..
+    implementation("io.github.vvb2060.ndk:curl:8.18.0")
+
     compileOnly("org.jetbrains:annotations:23.0.0")
 
     testImplementation("androidx.test.ext:junit:1.3.0")
@@ -137,10 +143,12 @@ dependencies {
  *
  */
 afterEvaluate {
-    tasks.getByName("prefabReleasePackage") {
+    tasks.matching { it.name.startsWith("prefab") && it.name.endsWith("Package") }.configureEach {
         doLast {
-            project.fileTree("build/intermediates/prefab_package/") {
+            project.fileTree("build/intermediates/") {
                 include("**/abi.json")
+                include("**/prefab_publication.json/debug")
+                include("**/prefab_publication.json/release")
             }.forEach { file ->
                 file.writeText(file.readText().replace("c++_static", "none"))
             }

ndk/lib/src/main/java/io/sentry/ndk/NdkOptions.java

@@ -15,6 +15,7 @@ public final class NdkOptions {
   private NdkHandlerStrategy ndkHandlerStrategy =
       NdkHandlerStrategy.SENTRY_HANDLER_STRATEGY_DEFAULT;
   private float tracesSampleRate = 0;
+  private boolean tombstoneEnabled = false;
 
   public NdkOptions(
       @NotNull String dsn,
@@ -88,4 +89,12 @@ public void setTracesSampleRate(final float tracesSampleRate) {
   public float getTracesSampleRate() {
     return tracesSampleRate;
   }
+
+  public void setTombstoneEnabled(final boolean tombstoneEnabled) {
+    this.tombstoneEnabled = tombstoneEnabled;
+  }
+
+  public boolean isTombstoneEnabled() {
+    return tombstoneEnabled;
+  }
 }

ndk/lib/src/main/java/io/sentry/ndk/SentryNdk.java

@@ -2,6 +2,7 @@
 
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 @ApiStatus.Internal
 public final class SentryNdk {
@@ -20,6 +21,16 @@ private SentryNdk() {}
    */
   private static native int initSentryNative(@NotNull final NdkOptions options);
 
+  private static native void nativeInitCrashDaemon(
+      @NotNull String shmPath, int notifyFd, int readyFd);
+
+  private static native @Nullable String nativeRunCrashDaemon(
+      int appPid, long appTid, int notifyFd, int readyFd, @NotNull String shmPath);
+
+  private static native boolean nativeSendEnvelope(@NotNull String path, long timeout);
+
+  private static native void nativeCloseCrashDaemon();
+
   private static native void shutdown();
 
   /**
@@ -57,6 +68,28 @@ public static void init(@NotNull final NdkOptions options) {
     }
   }
 
+  public static void initCrashDaemon(
+      @NotNull String shmPath, int notifyFd, int readyFd) {
+    loadNativeLibraries();
+    nativeInitCrashDaemon(shmPath, notifyFd, readyFd);
+  }
+
+  public static @Nullable String runCrashDaemon(
+      int appPid, long appTid, int notifyFd, int readyFd, @NotNull String shmPath) {
+    loadNativeLibraries();
+    return nativeRunCrashDaemon(appPid, appTid, notifyFd, readyFd, shmPath);
+  }
+
+  public static boolean sendEnvelope(@NotNull String path, long timeout) {
+    loadNativeLibraries();
+    return nativeSendEnvelope(path, timeout);
+  }
+
+  public static void closeCrashDaemon() {
+    loadNativeLibraries();
+    nativeCloseCrashDaemon();
+  }
+
   /** Closes the NDK integration */
   public static void close() {
     loadNativeLibraries();
@@ -80,4 +113,5 @@ public static synchronized void loadNativeLibraries() {
       nativeLibrariesLoaded = true;
     }
   }
+
 }

ndk/lib/src/main/jni/sentry.c

@@ -1,9 +1,19 @@
 #include <string.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <sentry.h>
 #include <jni.h>
 
+extern void sentry_android_crash_daemon_init(
+    const char *shm_path, int notify_fd, int ready_fd) __attribute__((weak));
+extern char *sentry_android_crash_daemon_run(int app_pid,
+    uint64_t app_tid, int notify_fd, int ready_fd,
+    const char *shm_path) __attribute__((weak));
+extern bool sentry_android_crash_daemon_send(
+    const char *path, uint64_t timeout) __attribute__((weak));
+extern void sentry_android_crash_daemon_close(void) __attribute__((weak));
+
 #define ENSURE(Expr) \
     if (!(Expr))     \
         return
@@ -333,6 +343,7 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     jmethodID handler_strategy_mid = (*env)->GetMethodID(env, options_cls, "getNdkHandlerStrategy", "()I");
 
     jmethodID traces_sample_rate_mid = (*env)->GetMethodID(env, options_cls, "getTracesSampleRate", "()F");
+    jmethodID tombstone_enabled_mid = (*env)->GetMethodID(env, options_cls, "isTombstoneEnabled", "()Z");
 
     (*env)->DeleteLocalRef(env, options_cls);
 
@@ -350,6 +361,15 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     options = sentry_options_new();
     ENSURE_OR_FAIL(options);
 
+    // Minidumps take precedence over native envelopes during processing. When
+    // tombstone merging is enabled, use native-only mode so the native envelope
+    // can be enriched; otherwise attach a minidump for extra crash context.
+    jboolean tombstone_enabled =
+        (jboolean)(*env)->CallBooleanMethod(env, sentry_ndk_options, tombstone_enabled_mid);
+    sentry_options_set_crash_reporting_mode(options,
+        tombstone_enabled ? SENTRY_CRASH_REPORTING_MODE_NATIVE
+                          : SENTRY_CRASH_REPORTING_MODE_NATIVE_WITH_MINIDUMP);
+
     // session tracking is enabled by default, but the Android SDK already handles it
     sentry_options_set_auto_session_tracking(options, 0);
 
@@ -433,6 +453,97 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     return (jint) -1;
 }
 
+JNIEXPORT void JNICALL
+Java_io_sentry_ndk_SentryNdk_nativeInitCrashDaemon(
+        JNIEnv *env,
+        jclass cls,
+        jstring shm_path,
+        jint notify_fd,
+        jint ready_fd) {
+    if (!shm_path) {
+        return;
+    }
+
+    const char *shm_path_chars = (*env)->GetStringUTFChars(env, shm_path, 0);
+    if (!shm_path_chars) {
+        return;
+    }
+
+    if (sentry_android_crash_daemon_init) {
+        sentry_android_crash_daemon_init(
+            shm_path_chars, (int) notify_fd, (int) ready_fd);
+    }
+
+    (*env)->ReleaseStringUTFChars(env, shm_path, shm_path_chars);
+}
+
+JNIEXPORT jstring JNICALL
+Java_io_sentry_ndk_SentryNdk_nativeRunCrashDaemon(
+        JNIEnv *env,
+        jclass cls,
+        jint app_pid,
+        jlong app_tid,
+        jint notify_fd,
+        jint ready_fd,
+        jstring shm_path) {
+    if (!shm_path) {
+        return NULL;
+    }
+
+    const char *shm_path_chars = (*env)->GetStringUTFChars(env, shm_path, 0);
+    if (!shm_path_chars) {
+        return NULL;
+    }
+
+    char *envelope_path = NULL;
+    if (sentry_android_crash_daemon_run) {
+        envelope_path = sentry_android_crash_daemon_run((int) app_pid,
+            (uint64_t) app_tid, (int) notify_fd, (int) ready_fd,
+            shm_path_chars);
+    }
+
+    (*env)->ReleaseStringUTFChars(env, shm_path, shm_path_chars);
+    if (!envelope_path) {
+        return NULL;
+    }
+
+    jstring rv = (*env)->NewStringUTF(env, envelope_path);
+    sentry_free(envelope_path);
+    return rv;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_io_sentry_ndk_SentryNdk_nativeSendEnvelope(
+        JNIEnv *env,
+        jclass cls,
+        jstring path,
+        jlong timeout) {
+    if (!path) {
+        return JNI_FALSE;
+    }
+
+    const char *path_chars = (*env)->GetStringUTFChars(env, path, 0);
+    if (!path_chars) {
+        return JNI_FALSE;
+    }
+
+    bool sent = false;
+    if (sentry_android_crash_daemon_send) {
+        sent = sentry_android_crash_daemon_send(
+            path_chars, (uint64_t) timeout);
+    }
+
+    (*env)->ReleaseStringUTFChars(env, path, path_chars);
+    return sent ? JNI_TRUE : JNI_FALSE;
+}
+
+JNIEXPORT void JNICALL
+Java_io_sentry_ndk_SentryNdk_nativeCloseCrashDaemon(JNIEnv *env, jclass cls) {
+    if (sentry_android_crash_daemon_close) {
+        sentry_android_crash_daemon_close();
+    }
+}
+
 JNIEXPORT void JNICALL
 Java_io_sentry_ndk_NativeModuleListLoader_nativeClearModuleList(JNIEnv *env, jclass cls) {
     sentry_clear_modulecache();

ndk/sample/CMakeLists.txt

@@ -6,15 +6,15 @@ set(SENTRY_BUILD_SHARED_LIBS ON)
 
 add_library(ndk-sample SHARED src/main/cpp/ndk-sample.cpp)
 
-# Adding sentry-native project
-add_subdirectory(${SENTRY_NATIVE_SRC} sentry_build)
+# Use sentry-native from the NDK library's Prefab package
+find_package(sentry-native-ndk REQUIRED CONFIG)
 
 # Android logging library
 find_library(LOG_LIB log)
 
 target_link_libraries(ndk-sample PRIVATE
 	${LOG_LIB}
-	$<BUILD_INTERFACE:sentry::sentry>
+	sentry-native-ndk::sentry
 )
 # Support 16KB page sizes
 target_link_options(ndk-sample PRIVATE "-Wl,-z,max-page-size=16384")

ndk/sample/build.gradle.kts

@@ -3,12 +3,13 @@ plugins {
     kotlin("android")
 }
 
-var sentryNativeSrc: String = "${project.projectDir}/../.."
-
 android {
     compileSdk = 35
     namespace = "io.sentry.ndk.sample"
-    buildFeatures.buildConfig = true
+    buildFeatures {
+        buildConfig = true
+        prefab = true
+    }
 
     defaultConfig {
         applicationId = "io.sentry.ndk.sample"
@@ -20,7 +21,6 @@ android {
         externalNativeBuild {
             cmake {
                 arguments.add(0, "-DANDROID_STL=c++_shared")
-                arguments.add(0, "-DSENTRY_NATIVE_SRC=$sentryNativeSrc")
             }
         }