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**:
 
 - Protect CMAKE_SYSTEM_VERSION to avoid empty values when cross-building. ([#1720](https://github.com/getsentry/sentry-native/pull/1720))

CMakeLists.txt

@@ -841,6 +841,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

@@ -1,6 +1,10 @@
 cmake_minimum_required(VERSION 3.10)
 project(Sentry-Android LANGUAGES C CXX)
 
+if(POLICY CMP0079)
+	cmake_policy(SET CMP0079 NEW)
+endif()
+
 # Add sentry-android shared library
 add_library(sentry-android SHARED src/main/jni/sentry.c)
 
@@ -12,9 +16,30 @@ endif()
 # make sure that we build it as a shared lib instead of a static lib
 set(BUILD_SHARED_LIBS ON)
 set(SENTRY_BUILD_SHARED_LIBS ON)
+set(SENTRY_TRANSPORT "custom" CACHE STRING "" FORCE)
 
 # Adding sentry-native project
 add_subdirectory(${SENTRY_NATIVE_SRC} sentry_build)
+target_sources(sentry PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}/src/main/jni/sentry_android_transport.c
+)
+
+if(SENTRY_BACKEND STREQUAL "native")
+	find_package(curl REQUIRED CONFIG)
+	# TODO: SENTRY_TRANSPORT=curl
+	target_sources(sentry-crash PRIVATE
+		${SENTRY_NATIVE_SRC}/src/transports/sentry_http_transport_curl.c
+	)
+	target_compile_definitions(sentry-android PRIVATE SENTRY_BACKEND_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")
+	target_link_libraries(sentry-crash PRIVATE curl::curl_static)
+	target_link_libraries(sentry-android PRIVATE dl)
+endif()
 
 # Android logging library
 find_library(LOG_LIB log)

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/jni/sentry.c

@@ -1,12 +1,16 @@
 #include <string.h>
 #include <stdbool.h>
-#include <stdio.h>
 #include <sentry.h>
 #include <jni.h>
 
-#define ENSURE(Expr) \
-    if (!(Expr))     \
-        return
+#if defined(SENTRY_BACKEND_NATIVE)
+#include <dlfcn.h>
+#include <limits.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+#endif
 
 #define ENSURE_OR_FAIL(Expr) \
     if (!(Expr))          \
@@ -59,6 +63,31 @@ static char *call_get_string(JNIEnv *env, jobject obj, jmethodID mid) {
     return NULL;
 }
 
+#if defined(SENTRY_BACKEND_NATIVE)
+static void set_handler_path(sentry_options_t *options) {
+    Dl_info info;
+    if (dladdr((void *)set_handler_path, &info) == 0 || !info.dli_fname) {
+        return;
+    }
+
+    const char *slash = strrchr(info.dli_fname, '/');
+    if (!slash) {
+        return;
+    }
+
+    const char daemon_name[] = "libsentry-crash.so";
+    size_t dir_len = (size_t)(slash - info.dli_fname + 1);
+    if (dir_len + sizeof(daemon_name) > PATH_MAX) {
+        return;
+    }
+
+    char handler_path[PATH_MAX];
+    memcpy(handler_path, info.dli_fname, dir_len);
+    memcpy(handler_path + dir_len, daemon_name, sizeof(daemon_name));
+    sentry_options_set_handler_path(options, handler_path);
+}
+#endif
+
 JNIEXPORT void JNICALL
 Java_io_sentry_ndk_NativeScope_nativeSetTag(
         JNIEnv *env,
@@ -282,26 +311,6 @@ Java_io_sentry_ndk_NativeScope_nativeClearAttachments(JNIEnv *env, jclass cls) {
     sentry_clear_attachments();
 }
 
-static void send_envelope(sentry_envelope_t *envelope, void *data) {
-    const char *outbox_path = (const char *) data;
-    char envelope_id_str[40];
-
-    sentry_uuid_t envelope_id = sentry_uuid_new_v4();
-    sentry_uuid_as_string(&envelope_id, envelope_id_str);
-
-    size_t outbox_len = strlen(outbox_path);
-    size_t final_len = outbox_len + 42; // "/" + envelope_id_str + "\0" = 42
-    char *envelope_path = sentry_malloc(final_len);
-    ENSURE(envelope_path);
-    int written = snprintf(envelope_path, final_len, "%s/%s", outbox_path, envelope_id_str);
-    if (written > outbox_len && written < final_len) {
-        sentry_envelope_write_to_file(envelope, envelope_path);
-    }
-
-    sentry_free(envelope_path);
-    sentry_envelope_free(envelope);
-}
-
 // sentry_backend.h
 extern void sentry__backend_preload(void);
 
@@ -337,10 +346,7 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     (*env)->DeleteLocalRef(env, options_cls);
 
     char *outbox_path = NULL;
-    sentry_transport_t *transport = NULL;
-    bool transport_owns_path = false;
     sentry_options_t *options = NULL;
-    bool options_owns_transport = false;
     char *dsn_str = NULL;
     char *release_str = NULL;
     char *environment_str = NULL;
@@ -350,6 +356,10 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     options = sentry_options_new();
     ENSURE_OR_FAIL(options);
 
+#if defined(SENTRY_BACKEND_NATIVE)
+    set_handler_path(options);
+#endif
+
     // session tracking is enabled by default, but the Android SDK already handles it
     sentry_options_set_auto_session_tracking(options, 0);
 
@@ -362,15 +372,6 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     outbox_path = call_get_string(env, sentry_ndk_options, outbox_path_mid);
     ENSURE_OR_FAIL(outbox_path);
 
-    transport = sentry_transport_new(send_envelope);
-    ENSURE_OR_FAIL(transport);
-    sentry_transport_set_state(transport, outbox_path);
-    sentry_transport_set_free_func(transport, sentry_free);
-    transport_owns_path = true;
-
-    sentry_options_set_transport(options, transport);
-    options_owns_transport = true;
-
     // give sentry-native its own database path it can work with, next to the outbox
     size_t outbox_len = strlen(outbox_path);
     size_t final_len = outbox_len + 15; // len(".sentry-native\0") = 15
@@ -383,6 +384,8 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     }
     sentry_options_set_database_path(options, database_path);
     sentry_free(database_path);
+    sentry_free(outbox_path);
+    outbox_path = NULL;
 
     dsn_str = call_get_string(env, sentry_ndk_options, dsn_mid);
     ENSURE_OR_FAIL(dsn_str);
@@ -423,12 +426,7 @@ Java_io_sentry_ndk_SentryNdk_initSentryNative(
     return (jint) rv;
 
     fail:
-    if (!transport_owns_path) {
-        sentry_free(outbox_path);
-    }
-    if (!options_owns_transport) {
-        sentry_transport_free(transport);
-    }
+    sentry_free(outbox_path);
     sentry_options_free(options);
     return (jint) -1;
 }

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

@@ -0,0 +1,126 @@
+#include "sentry_alloc.h"
+#include "sentry_logger.h"
+#include "sentry_options.h"
+#include "sentry_path.h"
+#include "sentry_transport.h"
+
+#include <errno.h>
+#include <sentry.h>
+#include <stdio.h>
+#include <string.h>
+
+#define ENSURE(Expr)                                                           \
+    if (!(Expr))                                                               \
+    return
+
+static int
+android_transport_startup(const sentry_options_t *options, void *data)
+{
+    char **outbox_path = data;
+    if (!outbox_path || !options->run || !options->run->run_path) {
+        return 1;
+    }
+
+    sentry_path_t *database_path = sentry__path_dir(options->run->run_path);
+    if (!database_path) {
+        return 1;
+    }
+    sentry_path_t *files_dir = sentry__path_dir(database_path);
+    sentry__path_free(database_path);
+    if (!files_dir) {
+        return 1;
+    }
+
+    sentry_path_t *outbox_dir = sentry__path_join_str(files_dir, "outbox");
+    sentry__path_free(files_dir);
+    if (!outbox_dir) {
+        return 1;
+    }
+
+    if (sentry__path_create_dir_all(outbox_dir) != 0) {
+        SENTRY_WARNF("android transport startup: mkdir failed for %s: %s",
+            outbox_dir->path, strerror(errno));
+        sentry__path_free(outbox_dir);
+        return 1;
+    }
+
+    char *outbox_path_str = sentry_malloc(strlen(outbox_dir->path) + 1);
+    if (!outbox_path_str) {
+        sentry__path_free(outbox_dir);
+        return 1;
+    }
+    strcpy(outbox_path_str, outbox_dir->path);
+    sentry__path_free(outbox_dir);
+
+    sentry_free(*outbox_path);
+    *outbox_path = outbox_path_str;
+    return 0;
+}
+
+static void
+send_envelope(sentry_envelope_t *envelope, void *data)
+{
+    const char *outbox_path = (const char *)data;
+    char envelope_id_str[40];
+
+    sentry_uuid_t envelope_id = sentry_uuid_new_v4();
+    sentry_uuid_as_string(&envelope_id, envelope_id_str);
+
+    size_t outbox_len = strlen(outbox_path);
+    size_t final_len = outbox_len + 42; // "/" + envelope_id_str + "\0" = 42
+    char *envelope_path = sentry_malloc(final_len);
+    ENSURE(envelope_path);
+    int written = snprintf(
+        envelope_path, final_len, "%s/%s", outbox_path, envelope_id_str);
+    if (written > outbox_len && written < final_len) {
+        sentry_envelope_write_to_file(envelope, envelope_path);
+    }
+
+    sentry_free(envelope_path);
+    sentry_envelope_free(envelope);
+}
+
+static void
+android_transport_send_envelope(sentry_envelope_t *envelope, void *data)
+{
+    char **outbox_path = data;
+    if (!outbox_path || !*outbox_path) {
+        SENTRY_WARN(
+            "android transport send_envelope: outbox path not initialized");
+        sentry_envelope_free(envelope);
+        return;
+    }
+    send_envelope(envelope, *outbox_path);
+}
+
+static void
+android_transport_free(void *data)
+{
+    char **outbox_path = data;
+    if (!outbox_path) {
+        return;
+    }
+    sentry_free(*outbox_path);
+    sentry_free(outbox_path);
+}
+
+sentry_transport_t *
+sentry__transport_new_default(void)
+{
+    char **outbox_path = sentry__calloc(1, sizeof(*outbox_path));
+    if (!outbox_path) {
+        return NULL;
+    }
+
+    sentry_transport_t *transport
+        = sentry_transport_new(android_transport_send_envelope);
+    if (!transport) {
+        sentry_free(outbox_path);
+        return NULL;
+    }
+
+    sentry_transport_set_state(transport, outbox_path);
+    sentry_transport_set_free_func(transport, android_transport_free);
+    sentry_transport_set_startup_func(transport, android_transport_startup);
+    return transport;
+}