@dolami-inc/react-native-expo-unity 0.2.0 → 0.3.0

package/README.md

@@ -2,8 +2,6 @@
 
 Unity as a Library (UaaL) bridge for React Native / Expo.
 
-> ⚠️ **iOS only** — Android support is coming soon.
-
 ## Install
 
 ```bash
@@ -61,9 +59,11 @@ import { postMessage, pauseUnity, resumeUnity, unloadUnity, isInitialized } from
 
 ## Setup
 
-### 1. Unity project — add plugin
+### 1. Unity project — add plugins
+
+Copy the platform bridge files into your Unity project:
 
-Copy the plugin files into your Unity project:
+**iOS:**
 
 ```bash
 # From node_modules after install
@@ -71,23 +71,35 @@ cp node_modules/@dolami-inc/react-native-expo-unity/plugin/NativeCallProxy.h  <U
 cp node_modules/@dolami-inc/react-native-expo-unity/plugin/NativeCallProxy.mm <UnityProject>/Assets/Plugins/iOS/
 ```
 
-### 2. Unity project — build iOS
+**Android:**
+
+No plugin files need to be copied — the `NativeCallProxy` Java class ships with the module and is available at runtime automatically. Your Unity C# code calls it via `AndroidJavaClass` (see [Messaging Guide](docs/messaging.md)).
 
-> 📹 **Video guide** (click to play):
->
-> [![Xcode export settings](xcode-settings-thumb.jpg)](xcode-settings.mp4)
+### 2. Unity project — build for your target platform
+
+#### iOS
 
 1. Unity → File → Build Settings → iOS → Build
 2. Open generated Xcode project
 3. Select `NativeCallProxy.h` in Libraries/Plugins/iOS/
 4. Set Target Membership → `UnityFramework` → **Public**
 5. **Select the `Data` folder** in the Project Navigator
-6. In the right panel under **Target Membership**, check **`UnityFramework`** ✅
-   > ⚠️ **This is critical.** Without this, the `Data` folder (which contains `global-metadata.dat` and all Unity assets) will NOT be included inside `UnityFramework.framework`. The app will crash at launch with: `Could not open .../global-metadata.dat — IL2CPP initialization failed`
+6. In the right panel under **Target Membership**, check **`UnityFramework`**
+   > **This is critical.** Without this, the `Data` folder (which contains `global-metadata.dat` and all Unity assets) will NOT be included inside `UnityFramework.framework`. The app will crash at launch with: `Could not open .../global-metadata.dat — IL2CPP initialization failed`
 7. Build `UnityFramework` scheme
 
+#### Android
+
+1. Unity → File → Build Settings → Android
+2. Check **Export Project** (do not "Build" directly — you need the Gradle project)
+3. Set Scripting Backend to **IL2CPP**
+4. Set Target Architectures: **ARMv7** and **ARM64**
+5. Click **Export** and save to a directory (e.g. `unity/builds/android`)
+
 ### 3. Copy build artifacts to your RN project
 
+#### iOS
+
 Create `unity/builds/ios/` in your project root and copy the built framework and static libraries:
 
 ```bash
@@ -111,6 +123,18 @@ The podspec references these files **directly by path** — nothing is copied or
 
 > Custom path? Set `EXPO_UNITY_PATH` environment variable pointing to your Unity build directory, or pass `unityPath` to the config plugin (see step 4).
 
+#### Android
+
+The Unity export directory (containing the `unityLibrary` folder) should be at `unity/builds/android/` in your project root. The config plugin will automatically include the `:unityLibrary` Gradle module.
+
+```bash
+# Verify the structure
+ls unity/builds/android/unityLibrary
+# Should show: libs/  src/  build.gradle  etc.
+```
+
+> Custom path? Set `EXPO_UNITY_ANDROID_PATH` environment variable, or pass `androidUnityPath` to the config plugin.
+
 ### 4. Add the config plugin to `app.json`
 
 ```json
@@ -123,22 +147,37 @@ The podspec references these files **directly by path** — nothing is copied or
 }
 ```
 
-The plugin automatically configures the required Xcode build settings:
+The plugin automatically configures:
+
+**iOS:**
 - `ENABLE_BITCODE = NO` — Unity does not support bitcode
 - `CLANG_CXX_LANGUAGE_STANDARD = c++17` — required for Unity headers
-- `FRAMEWORK_SEARCH_PATHS` — adds the Unity build artifacts directory
+- Embeds `UnityFramework.framework` via a build script phase
+
+**Android:**
+- Includes `:unityLibrary` module in `settings.gradle`
+- Adds `flatDir` repository for Unity's native libs
+- Adds `ndk.abiFilters` for `armeabi-v7a` and `arm64-v8a`
 
-If your Unity artifacts are in a custom path, pass the option:
+If your Unity artifacts are in custom paths:
 
 ```json
-["@dolami-inc/react-native-expo-unity", { "unityPath": "/absolute/path/to/unity/builds/ios" }]
+["@dolami-inc/react-native-expo-unity", {
+  "unityPath": "/absolute/path/to/unity/builds/ios",
+  "androidUnityPath": "/absolute/path/to/unity/builds/android"
+}]
 ```
 
 ### 5. Build
 
 ```bash
+# iOS
 expo prebuild --platform ios --clean
 expo run:ios --device
+
+# Android
+expo prebuild --platform android --clean
+expo run:android
 ```
 
 ## Lifecycle
@@ -189,13 +228,25 @@ public void LoadAvatar(string json) { /* ... */ }
 ### Unity → RN
 
 ```csharp
+// iOS — uses extern "C" DllImport
 #if UNITY_IOS && !UNITY_EDITOR
 [DllImport("__Internal")]
 private static extern void sendMessageToMobileApp(string message);
 #endif
 
-// Recommended: JSON format
-sendMessageToMobileApp("{\"event\":\"image_taken\",\"data\":{\"path\":\"/tmp/photo.jpg\"}}");
+// Android — uses AndroidJavaClass
+private static void SendToMobile(string message) {
+#if UNITY_IOS && !UNITY_EDITOR
+    sendMessageToMobileApp(message);
+#elif UNITY_ANDROID && !UNITY_EDITOR
+    using (var proxy = new AndroidJavaClass("com.expounity.bridge.NativeCallProxy")) {
+        proxy.CallStatic("sendMessageToMobileApp", message);
+    }
+#endif
+}
+
+// Usage:
+SendToMobile("{\"event\":\"image_taken\",\"data\":{\"path\":\"/tmp/photo.jpg\"}}");
 ```
 
 ```tsx
@@ -216,16 +267,17 @@ sendMessageToMobileApp("{\"event\":\"image_taken\",\"data\":{\"path\":\"/tmp/pho
 
 - **Expo SDK 54+**
 - **React Native New Architecture** (Fabric) — old architecture not supported
-- **Physical iOS device** — Unity renders only on device; Simulator shows a placeholder view
-- **Unity build artifacts** — must be copied manually into your project (~2GB, not bundled via npm)
+- **Physical device** — iOS: Unity renders only on device, Simulator shows a placeholder. Android: physical device or emulator with ARM support.
+- **Unity build artifacts** — must be exported/copied manually into your project (not bundled via npm)
 
 ## Platform Support
 
 | Platform | Status |
 |---|---|
-| iOS Device | ✅ Supported |
-| iOS Simulator | ⚠️ Not supported — renders a placeholder view |
-| Android | 🚧 Coming soon |
+| iOS Device | Supported |
+| iOS Simulator | Not supported — renders a placeholder view |
+| Android Device | Supported |
+| Android Emulator | Supported (ARM-based emulators only) |
 
 ## Limitations
 

package/android/build.gradle

@@ -0,0 +1,39 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'expo-module-gradle-plugin'
+
+group = 'expo.modules.unity'
+version = '0.2.0'
+
+android {
+  namespace "expo.modules.unity"
+  compileSdk 35
+
+  defaultConfig {
+    minSdk 24
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+// Resolve unity-classes.jar from the Unity Android export.
+// Users set EXPO_UNITY_PATH or it defaults to <rootProject>/unity/builds/android.
+def unityBuildPath = System.getenv("EXPO_UNITY_PATH") ?: "${rootProject.projectDir}/../unity/builds/android"
+def unityClassesJar = file("${unityBuildPath}/unityLibrary/libs/unity-classes.jar")
+
+dependencies {
+  implementation project(':expo-modules-core')
+
+  if (unityClassesJar.exists()) {
+    compileOnly files(unityClassesJar)
+  } else {
+    println "[expo-unity] WARNING: unity-classes.jar not found at ${unityClassesJar}. Android build will fail if Unity symbols are referenced."
+  }
+}

package/android/src/main/java/com/expounity/bridge/NativeCallProxy.java

@@ -0,0 +1,29 @@
+package com.expounity.bridge;
+
+/**
+ * Bridge for Unity -> React Native messaging on Android.
+ *
+ * Unity C# code calls this via AndroidJavaClass:
+ *   var proxy = new AndroidJavaClass("com.expounity.bridge.NativeCallProxy");
+ *   proxy.CallStatic("sendMessageToMobileApp", message);
+ *
+ * The module registers a MessageListener during initialization to receive messages.
+ */
+public class NativeCallProxy {
+
+    public interface MessageListener {
+        void onMessage(String message);
+    }
+
+    private static MessageListener listener;
+
+    public static void registerListener(MessageListener newListener) {
+        listener = newListener;
+    }
+
+    public static void sendMessageToMobileApp(String message) {
+        if (listener != null) {
+            listener.onMessage(message);
+        }
+    }
+}

package/android/src/main/java/expo/modules/unity/ExpoUnityModule.kt

@@ -0,0 +1,62 @@
+package expo.modules.unity
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoUnityModule : Module() {
+
+    override fun definition() = ModuleDefinition {
+        Name("ExpoUnity")
+
+        Events("onUnityMessage")
+
+        Function("postMessage") { gameObject: String, methodName: String, message: String ->
+            UnityBridge.getInstance().sendMessage(gameObject, methodName, message)
+        }
+
+        Function("pauseUnity") { pause: Boolean ->
+            UnityBridge.getInstance().setPaused(pause)
+        }
+
+        Function("unloadUnity") {
+            UnityBridge.getInstance().unload()
+        }
+
+        Function("isInitialized") {
+            UnityBridge.getInstance().isInitialized
+        }
+
+        View(ExpoUnityView::class) {
+            Events("onUnityMessage")
+
+            Prop("autoUnloadOnUnmount") { view: ExpoUnityView, value: Boolean ->
+                view.autoUnloadOnUnmount = value
+            }
+        }
+
+        OnActivityEntersBackground {
+            val bridge = UnityBridge.getInstance()
+            if (bridge.isInitialized) {
+                bridge.wasRunningBeforeBackground = true
+                bridge.setPaused(true)
+            } else {
+                bridge.wasRunningBeforeBackground = false
+            }
+        }
+
+        OnActivityEntersForeground {
+            val bridge = UnityBridge.getInstance()
+            if (bridge.wasRunningBeforeBackground) {
+                bridge.setPaused(false)
+                bridge.wasRunningBeforeBackground = false
+            }
+        }
+
+        OnActivityDestroys {
+            val bridge = UnityBridge.getInstance()
+            if (bridge.isInitialized) {
+                bridge.unload()
+            }
+        }
+    }
+}

package/android/src/main/java/expo/modules/unity/ExpoUnityView.kt

@@ -0,0 +1,81 @@
+package expo.modules.unity
+
+import android.content.Context
+import android.util.Log
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.ExpoView
+
+class ExpoUnityView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+
+    companion object {
+        private const val TAG = "ExpoUnity"
+    }
+
+    val onUnityMessage by EventDispatcher()
+    var autoUnloadOnUnmount: Boolean = true
+
+    init {
+        // post {} dispatches to main thread. setupUnity -> initialize runs
+        // synchronously when already on main thread, so mountUnityView sees the
+        // fully-initialized player without a race condition.
+        post { setupUnity() }
+    }
+
+    private fun setupUnity() {
+        val activity = appContext.currentActivity ?: run {
+            Log.w(TAG, "No activity available for Unity initialization")
+            return
+        }
+
+        val bridge = UnityBridge.getInstance()
+
+        if (!bridge.isInitialized) {
+            bridge.initialize(activity)
+        }
+
+        bridge.onMessage = { message ->
+            post {
+                onUnityMessage(mapOf("message" to message))
+            }
+        }
+
+        mountUnityView()
+    }
+
+    private fun mountUnityView() {
+        val playerView = UnityBridge.getInstance().unityPlayerView ?: run {
+            Log.w(TAG, "Unity player view not available yet")
+            return
+        }
+
+        // Remove from previous parent if needed
+        (playerView.parent as? ViewGroup)?.removeView(playerView)
+
+        addView(
+            playerView,
+            FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT
+            )
+        )
+    }
+
+    override fun onDetachedFromWindow() {
+        val bridge = UnityBridge.getInstance()
+        bridge.onMessage = null
+
+        if (bridge.isInitialized) {
+            if (autoUnloadOnUnmount) {
+                bridge.unload()
+                Log.i(TAG, "Auto-unloaded (view detached)")
+            } else {
+                bridge.setPaused(true)
+                Log.i(TAG, "Auto-paused on unmount (autoUnloadOnUnmount=false)")
+            }
+        }
+
+        super.onDetachedFromWindow()
+    }
+}

package/android/src/main/java/expo/modules/unity/UnityBridge.kt

@@ -0,0 +1,126 @@
+package expo.modules.unity
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import com.expounity.bridge.NativeCallProxy
+import com.unity3d.player.IUnityPlayerLifecycleEvents
+import com.unity3d.player.UnityPlayer
+
+/**
+ * Singleton managing the UnityPlayer lifecycle.
+ * Android equivalent of ios/UnityBridge.mm.
+ */
+class UnityBridge private constructor() : IUnityPlayerLifecycleEvents, NativeCallProxy.MessageListener {
+
+    companion object {
+        private const val TAG = "ExpoUnity"
+
+        @Volatile
+        private var instance: UnityBridge? = null
+
+        @JvmStatic
+        fun getInstance(): UnityBridge {
+            return instance ?: synchronized(this) {
+                instance ?: UnityBridge().also { instance = it }
+            }
+        }
+    }
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    var unityPlayer: UnityPlayer? = null
+        private set
+
+    var onMessage: ((String) -> Unit)? = null
+
+    /** Tracked here (not on the Module) so it survives module recreation. */
+    var wasRunningBeforeBackground: Boolean = false
+
+    val isInitialized: Boolean
+        get() = unityPlayer != null
+
+    /**
+     * Returns the UnityPlayer view for embedding. UnityPlayer extends FrameLayout.
+     */
+    val unityPlayerView: View?
+        get() = unityPlayer
+
+    fun initialize(activity: Activity) {
+        if (isInitialized) return
+
+        val runInit = Runnable {
+            try {
+                val player = UnityPlayer(activity, this)
+                unityPlayer = player
+
+                NativeCallProxy.registerListener(this)
+
+                Log.i(TAG, "Unity initialized")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to initialize Unity", e)
+            }
+        }
+
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            runInit.run()
+        } else {
+            mainHandler.post(runInit)
+        }
+    }
+
+    fun sendMessage(gameObject: String, methodName: String, message: String) {
+        if (!isInitialized) return
+        UnityPlayer.UnitySendMessage(gameObject, methodName, message)
+    }
+
+    fun setPaused(paused: Boolean) {
+        if (!isInitialized) return
+        val action = Runnable {
+            if (paused) {
+                unityPlayer?.pause()
+            } else {
+                unityPlayer?.resume()
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            action.run()
+        } else {
+            mainHandler.post(action)
+        }
+    }
+
+    fun unload() {
+        if (!isInitialized) return
+        Log.i(TAG, "unload called")
+        val action = Runnable {
+            unityPlayer?.unload()
+            Log.i(TAG, "unload completed")
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            action.run()
+        } else {
+            mainHandler.post(action)
+        }
+    }
+
+    // IUnityPlayerLifecycleEvents
+
+    override fun onUnityPlayerUnloaded() {
+        Log.i(TAG, "onUnityPlayerUnloaded")
+        unityPlayer = null
+    }
+
+    override fun onUnityPlayerQuitted() {
+        Log.i(TAG, "onUnityPlayerQuitted")
+        unityPlayer = null
+    }
+
+    // NativeCallProxy.MessageListener (Unity -> RN)
+
+    override fun onMessage(message: String) {
+        onMessage?.invoke(message)
+    }
+}

package/app.plugin.js

@@ -1,22 +1,36 @@
-const { withXcodeProject } = require('@expo/config-plugins');
+const {
+  withXcodeProject,
+  withSettingsGradle,
+  withAppBuildGradle,
+} = require('@expo/config-plugins');
 const path = require('path');
 const fs = require('fs');
 
 /**
  * Expo Config Plugin for @dolami-inc/react-native-expo-unity.
  *
+ * iOS:
  * - Injects required Xcode build settings (bitcode, C++17)
  * - Adds a build phase that embeds UnityFramework.framework into the app
  *   bundle at build time (device builds only)
  *
+ * Android:
+ * - Includes the :unityLibrary Gradle module from the Unity export
+ * - Adds flatDir repos for Unity's .aar/.jar libs
+ * - Adds the unityLibrary dependency and NDK abiFilters
+ *
  * @param {object} config - Expo config
- * @param {{ unityPath?: string }} options
- *   unityPath — absolute path to the Unity iOS build artifacts directory.
- *   Defaults to `<projectRoot>/unity/builds/ios`.
+ * @param {object} options
+ * @param {string} [options.unityPath] — absolute path to the Unity iOS build
+ *   artifacts directory. Defaults to `<projectRoot>/unity/builds/ios`.
  *   Can also be set via the EXPO_UNITY_PATH environment variable.
+ * @param {string} [options.androidUnityPath] — absolute path to the Unity
+ *   Android export directory. Defaults to `<projectRoot>/unity/builds/android`.
+ *   Can also be set via the EXPO_UNITY_ANDROID_PATH environment variable.
  */
 const withExpoUnity = (config, options = {}) => {
-  return withXcodeProject(config, (config) => {
+  // -- iOS --
+  config = withXcodeProject(config, (config) => {
     const xcodeProject = config.modResults;
     const projectRoot = config.modRequest.projectRoot;
 
@@ -25,7 +39,7 @@ const withExpoUnity = (config, options = {}) => {
       process.env.EXPO_UNITY_PATH ||
       path.join(projectRoot, 'unity', 'builds', 'ios');
 
-    // -- Build settings --
+    // Build settings
     const configurations = xcodeProject.pbxXCBuildConfigurationSection();
     for (const key of Object.keys(configurations)) {
       const configuration = configurations[key];
@@ -37,16 +51,11 @@ const withExpoUnity = (config, options = {}) => {
       settings['CLANG_CXX_LANGUAGE_STANDARD'] = '"c++17"';
     }
 
-    // -- Embed UnityFramework via build script phase --
-    // UnityFramework is a dynamic framework that must be embedded (copied)
-    // into the app bundle's Frameworks/ directory, otherwise dyld fails at
-    // launch. We use a shell script build phase instead of vendored_frameworks
-    // because the pod source may live in a read-only package manager cache.
+    // Embed UnityFramework via build script phase
     const frameworkSrc = path.join(unityPath, 'UnityFramework.framework');
     if (fs.existsSync(frameworkSrc)) {
       const target = xcodeProject.getFirstTarget();
 
-      // Shell script that copies and codesigns the framework (device only).
       const script = [
         'if [ "${PLATFORM_NAME}" = "iphoneos" ]; then',
         '  FRAMEWORK_SRC="' + frameworkSrc + '"',
@@ -73,6 +82,88 @@ const withExpoUnity = (config, options = {}) => {
 
     return config;
   });
+
+  // -- Android: settings.gradle --
+  config = withSettingsGradle(config, (config) => {
+    const projectRoot = config.modRequest.projectRoot;
+    const androidUnityPath =
+      options.androidUnityPath ||
+      process.env.EXPO_UNITY_ANDROID_PATH ||
+      path.join(projectRoot, 'unity', 'builds', 'android');
+
+    const contents = config.modResults.contents;
+
+    // Include :unityLibrary module
+    const includeSnippet = `include ':unityLibrary'`;
+    const projectSnippet = `project(':unityLibrary').projectDir = new File('${androidUnityPath}/unityLibrary')`;
+
+    if (!contents.includes(includeSnippet)) {
+      config.modResults.contents =
+        contents +
+        `\n// Unity as a Library\n${includeSnippet}\n${projectSnippet}\n`;
+    }
+
+    // Add flatDir repos for Unity's native libs
+    const flatDirSnippet = `flatDir { dirs "\${project(':unityLibrary').projectDir}/libs" }`;
+    if (!config.modResults.contents.includes(flatDirSnippet)) {
+      // Insert into dependencyResolutionManagement.repositories or allprojects.repositories
+      const repoBlockRegex =
+        /dependencyResolutionManagement\s*\{[\s\S]*?repositories\s*\{/;
+      const allProjectsRegex = /allprojects\s*\{[\s\S]*?repositories\s*\{/;
+
+      if (repoBlockRegex.test(config.modResults.contents)) {
+        config.modResults.contents = config.modResults.contents.replace(
+          repoBlockRegex,
+          (match) => `${match}\n        ${flatDirSnippet}`
+        );
+      } else if (allProjectsRegex.test(config.modResults.contents)) {
+        config.modResults.contents = config.modResults.contents.replace(
+          allProjectsRegex,
+          (match) => `${match}\n        ${flatDirSnippet}`
+        );
+      } else {
+        // Fallback: append a standalone block
+        config.modResults.contents +=
+          `\nallprojects {\n    repositories {\n        ${flatDirSnippet}\n    }\n}\n`;
+      }
+    }
+
+    return config;
+  });
+
+  // -- Android: app/build.gradle --
+  config = withAppBuildGradle(config, (config) => {
+    let contents = config.modResults.contents;
+
+    // Add unityLibrary dependency
+    const depSnippet = `implementation project(':unityLibrary')`;
+    if (!contents.includes(depSnippet)) {
+      const depsRegex = /dependencies\s*\{/;
+      if (depsRegex.test(contents)) {
+        contents = contents.replace(
+          depsRegex,
+          (match) => `${match}\n    ${depSnippet}`
+        );
+      }
+    }
+
+    // Add NDK abiFilters
+    const abiSnippet = `ndk { abiFilters 'armeabi-v7a', 'arm64-v8a' }`;
+    if (!contents.includes('abiFilters')) {
+      const defaultConfigRegex = /defaultConfig\s*\{/;
+      if (defaultConfigRegex.test(contents)) {
+        contents = contents.replace(
+          defaultConfigRegex,
+          (match) => `${match}\n        ${abiSnippet}`
+        );
+      }
+    }
+
+    config.modResults.contents = contents;
+    return config;
+  });
+
+  return config;
 };
 
 module.exports = withExpoUnity;

package/docs/lifecycle.md

@@ -118,7 +118,16 @@ useFocusEffect(
 | Unity paused | Same as running (frozen in RAM) |
 | Unity unloaded | ~80-180MB retained (Unity limitation) |
 
-**Paused Unity does not use CPU/GPU.** No battery drain. Only concern is memory pressure — iOS may kill your app if system memory is low.
+**Paused Unity does not use CPU/GPU.** No battery drain. Only concern is memory pressure — the OS may kill your app if system memory is low.
+
+## Platform Notes
+
+The lifecycle behavior is consistent across iOS and Android:
+
+- **iOS:** UnityFramework is loaded from a dynamic framework bundle. The app delegate subscriber handles background/foreground transitions.
+- **Android:** UnityPlayer (which extends `FrameLayout`) is managed by a singleton bridge. Activity lifecycle hooks in the Expo module handle background/foreground transitions.
+
+On both platforms, Unity is a singleton — only one instance exists per app process.
 
 ## Auto vs Manual
 

package/docs/messaging.md

@@ -44,15 +44,25 @@ public static class RNBridge
     private static extern void sendMessageToMobileApp(string message);
     #endif
 
+    /// Send a raw string message to React Native
+    public static void Send(string message)
+    {
+        #if UNITY_IOS && !UNITY_EDITOR
+        sendMessageToMobileApp(message);
+        #elif UNITY_ANDROID && !UNITY_EDITOR
+        using (var proxy = new AndroidJavaClass("com.expounity.bridge.NativeCallProxy"))
+        {
+            proxy.CallStatic("sendMessageToMobileApp", message);
+        }
+        #endif
+    }
+
     /// Send a structured event to React Native
     public static void SendEvent(string eventName, object data = null)
     {
         var msg = new EventMessage { @event = eventName, data = data };
         string json = JsonUtility.ToJson(msg);
-
-        #if UNITY_IOS && !UNITY_EDITOR
-        sendMessageToMobileApp(json);
-        #endif
+        Send(json);
     }
 
     [System.Serializable]
@@ -68,10 +78,16 @@ public static class RNBridge
 // RNBridge.SendEvent("image_taken", new { path = "/tmp/photo.jpg", w = 828, h = 1792 });
 ```
 
+### Platform Details
+
+**iOS:** The `sendMessageToMobileApp` function is defined as an `extern "C"` symbol in the `NativeCallProxy.mm` file that you copy into your Unity project's `Assets/Plugins/iOS/`. At runtime, UnityBridge registers itself as the `NativeCallsProtocol` handler and receives the message.
+
+**Android:** The `NativeCallProxy` Java class ships with the module at `com.expounity.bridge.NativeCallProxy`. Unity C# code calls it via `AndroidJavaClass` — no additional plugin files need to be copied. At runtime, `UnityBridge` registers itself as a `MessageListener` and receives the message.
+
 ## React Native Implementation
 
 ```tsx
-import { UnityView } from "react-native-expo-unity";
+import { UnityView } from "@dolami-inc/react-native-expo-unity";
 
 interface UnityEvent<T = unknown> {
   event: string;

package/expo-module.config.json

@@ -1,7 +1,10 @@
 {
-  "platforms": ["ios"],
+  "platforms": ["ios", "android"],
   "ios": {
     "modules": ["ExpoUnityModule"],
     "appDelegateSubscribers": ["ExpoUnityAppDelegateSubscriber"]
+  },
+  "android": {
+    "modules": ["expo.modules.unity.ExpoUnityModule"]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dolami-inc/react-native-expo-unity",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Unity as a Library (UaaL) bridge for React Native / Expo",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -12,6 +12,7 @@
   "files": [
     "src/",
     "ios/",
+    "android/",
     "plugin/",
     "docs/",
     "app.plugin.js",