Fix a few idempotency and use-after-free issues (#15)

Author: matthargett

Include/AndroidExtensions/Globals.h

@@ -1,17 +1,24 @@
 #pragma once
 
 #include <jni.h>
+#include <android/asset_manager_jni.h>
 #include <arcana/containers/ticketed_collection.h>
 #include "JavaWrappers.h"
 
 namespace android::global
 {
     void Initialize(JavaVM* javaVM, jobject appContext);
+    // Overload supporting headless scenarios without a Context.
+    // Safe to call multiple times (e.g., hot reloads).
+    void Initialize(JavaVM* javaVM, jobject appContext, jobject assetManager);
 
     JNIEnv* GetEnvForCurrentThread();
 
     android::content::Context GetAppContext();
 
+    void SetAssetManager(jobject assetManager);
+    AAssetManager* GetAssetManager();
+
     android::app::Activity GetCurrentActivity();
     void SetCurrentActivity(jobject currentActivity);
     using AppStateChangedCallback = std::function<void()>;

Include/AndroidExtensions/StdoutLogger.h

@@ -5,4 +5,5 @@ namespace android::StdoutLogger
 {
     void Start();
     void Stop();
-}
+    bool IsStarted();
+}

Source/Globals.cpp

@@ -1,4 +1,6 @@
 #include <AndroidExtensions/Globals.h>
+#include <android/asset_manager_jni.h>
+#include <jni.h>
 #include <stdexcept>
 
 namespace android::global
@@ -8,6 +10,8 @@ namespace android::global
         JavaVM* g_javaVM{};
         jobject g_appContext{};
         jobject g_currentActivity{};
+        jobject g_assetManagerObject{};
+        AAssetManager* g_assetManager{};
 
         thread_local struct Env final
         {
@@ -57,9 +61,39 @@ namespace android::global
     }
 
     void Initialize(JavaVM* javaVM, jobject context)
+    {
+        Initialize(javaVM, context, nullptr);
+    }
+
+    void Initialize(JavaVM* javaVM, jobject context, jobject assetManager)
     {
         g_javaVM = javaVM;
-        g_appContext = GetEnvForCurrentThread()->NewGlobalRef(android::content::Context{context}.getApplicationContext());
+        JNIEnv* env = GetEnvForCurrentThread();
+
+        if (g_appContext != nullptr)
+        {
+            env->DeleteGlobalRef(g_appContext);
+            g_appContext = nullptr;
+        }
+
+        if (context != nullptr)
+        {
+            g_appContext = env->NewGlobalRef(
+                android::content::Context{context}.getApplicationContext());
+        }
+
+        if (assetManager != nullptr)
+        {
+            SetAssetManager(assetManager);
+        }
+        else if (context != nullptr)
+        {
+            SetAssetManager(android::content::Context{context}.getAssets());
+        }
+        else
+        {
+            SetAssetManager(nullptr);
+        }
     }
 
     JNIEnv* GetEnvForCurrentThread()
@@ -127,4 +161,29 @@ namespace android::global
     {
         return g_requestPermissionsResultEvent.AddHandler(std::move(onAddRequestPermissionsResult));
     }
+
+    void SetAssetManager(jobject assetManager)
+    {
+        JNIEnv* env = GetEnvForCurrentThread();
+
+        if (g_assetManagerObject != nullptr)
+        {
+            env->DeleteGlobalRef(g_assetManagerObject);
+            g_assetManagerObject = nullptr;
+        }
+
+        if (assetManager == nullptr)
+        {
+            g_assetManager = nullptr;
+            return;
+        }
+
+        g_assetManagerObject = env->NewGlobalRef(assetManager);
+        g_assetManager = AAssetManager_fromJava(env, g_assetManagerObject);
+    }
+
+    AAssetManager* GetAssetManager()
+    {
+        return g_assetManager;
+    }
 }

Source/StdoutLogger.cpp

@@ -4,11 +4,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <mutex>
 
 namespace
 {
-    int fd_stdout[2];
-    int fd_stderr[2];
+    std::mutex g_stateMutex;
+    bool g_started = false;
+    int fd_stdout[2] = {-1, -1};
+    int fd_stderr[2] = {-1, -1};
 
     void thread_func(int fd, int prio)
     {
@@ -65,16 +68,58 @@ namespace android::StdoutLogger
 {
     void Start()
     {
+        std::lock_guard<std::mutex> lock(g_stateMutex);
+
+        if (g_started)
+        {
+            return;
+        }
+
         redirect(fd_stdout, fileno(stdout), thread_func_stdout);
         redirect(fd_stderr, fileno(stderr), thread_func_stderr);
+
+        g_started = true;
     }
 
     void Stop()
     {
-        close(fd_stdout[1]);
-        close(fd_stdout[0]);
+        std::lock_guard<std::mutex> lock(g_stateMutex);
+
+        if (!g_started)
+        {
+            return;
+        }
+
+        g_started = false;
+
+        if (fd_stdout[1] != -1)
+        {
+            close(fd_stdout[1]);
+            fd_stdout[1] = -1;
+        }
 
-        close(fd_stderr[1]);
-        close(fd_stderr[0]);
-   }
-}
+        if (fd_stdout[0] != -1)
+        {
+            close(fd_stdout[0]);
+            fd_stdout[0] = -1;
+        }
+
+        if (fd_stderr[1] != -1)
+        {
+            close(fd_stderr[1]);
+            fd_stderr[1] = -1;
+        }
+
+        if (fd_stderr[0] != -1)
+        {
+            close(fd_stderr[0]);
+            fd_stderr[0] = -1;
+        }
+    }
+
+    bool IsStarted()
+    {
+        std::lock_guard<std::mutex> lock(g_stateMutex);
+        return g_started;
+    }
+}