@hugebug4ever/react-native-unity 0.0.1

package/android/src/main/java/com/hugebug4ever/rnunity/UnityRuntimeModule.kt

@@ -0,0 +1,46 @@
+package com.hugebug4ever.rnunity
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+
+internal class UnityRuntimeModule(private val context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context), TurboModule, LifecycleEventListener, ActivityEventListener {
+
+  init {
+    context.addLifecycleEventListener(this)
+    context.addActivityEventListener(this)
+    UnityRuntimeController.bind(context, context.currentActivity)
+  }
+
+  override fun getName() = NAME
+
+  @ReactMethod fun start(detachedBehavior: String, promise: Promise) = UnityRuntimeController.start(detachedBehavior, promise)
+  @ReactMethod fun pause(promise: Promise) = UnityRuntimeController.pause(promise)
+  @ReactMethod fun resume(promise: Promise) = UnityRuntimeController.resume(promise)
+  @ReactMethod fun unload(promise: Promise) = UnityRuntimeController.unload(promise)
+  @ReactMethod fun getState(promise: Promise) = promise.resolve(UnityRuntimeController.stateName())
+  @ReactMethod fun getDiagnostics(promise: Promise) = promise.resolve(UnityRuntimeController.diagnostics())
+  @ReactMethod fun sendMessage(gameObject: String, methodName: String, message: String, promise: Promise) =
+    UnityRuntimeController.sendMessage(gameObject, methodName, message, promise)
+  @ReactMethod fun addListener(eventName: String) = Unit
+  @ReactMethod fun removeListeners(count: Double) = Unit
+
+  override fun onHostResume() {
+    UnityRuntimeController.updateActivity(context.currentActivity)
+    UnityRuntimeController.setAppBackground(false)
+  }
+  override fun onHostPause() = UnityRuntimeController.setAppBackground(true)
+  override fun onHostDestroy() = Unit
+  override fun onNewIntent(intent: Intent) = Unit
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) = Unit
+
+  companion object { const val NAME = "UnityRuntime" }
+}
+

package/android/src/main/java/com/hugebug4ever/rnunity/UnityRuntimeState.kt

@@ -0,0 +1,16 @@
+package com.hugebug4ever.rnunity
+
+internal enum class UnityRuntimeState(val wireName: String) {
+  IDLE("idle"),
+  STARTING("starting"),
+  RUNNING_DETACHED("runningDetached"),
+  RUNNING_ATTACHED("runningAttached"),
+  PAUSED_DETACHED("pausedDetached"),
+  PAUSED_ATTACHED("pausedAttached"),
+  UNLOADING("unloading"),
+  QUITTED("quitted"),
+  FAILED("failed")
+}
+
+internal enum class PauseReason { USER, APP_BACKGROUND, NO_HOST }
+

package/app.plugin.js

@@ -0,0 +1,2 @@
+module.exports = require('./plugin/build').default;
+

package/cli/index.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const VERSION_PATTERN = /^6000\.3\./;
+
+function fail(message) {
+  console.error(`[rn-unity] ${message}`);
+  process.exitCode = 1;
+}
+
+function parseArgs(values) {
+  const result = { _: [] };
+  for (let i = 0; i < values.length; i += 1) {
+    const value = values[i];
+    if (value.startsWith('--')) result[value.slice(2)] = values[++i] ?? true;
+    else result._.push(value);
+  }
+  return result;
+}
+
+function appRoot(args) {
+  return path.resolve(String(args.project || process.cwd()));
+}
+
+function readConfig(root) {
+  const packagePath = path.join(root, 'package.json');
+  const packageJson = fs.existsSync(packagePath)
+    ? JSON.parse(fs.readFileSync(packagePath, 'utf8'))
+    : {};
+  let expo = packageJson.expo || {};
+  const appConfigPath = path.join(root, 'app.config.js');
+  if (fs.existsSync(appConfigPath)) {
+    try {
+      const loaded = require(appConfigPath);
+      expo = loaded.expo || loaded.default?.expo || loaded.default || loaded;
+    } catch {
+      // Doctor continues with package.json and filesystem checks.
+    }
+  }
+  return {
+    packageJson,
+    expo,
+    androidExportPath: path.resolve(root, packageJson.reactNativeUnity?.androidExportPath || 'unity/builds/android/unityLibrary'),
+    iosExportPath: path.resolve(root, packageJson.reactNativeUnity?.iosExportPath || 'unity/builds/ios'),
+  };
+}
+
+function installedEditors() {
+  const result = spawnSync('unity', ['editors', '--installed', '--format', 'json'], {
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+  });
+  if (result.status !== 0) return [];
+  try {
+    return JSON.parse(result.stdout).data || [];
+  } catch {
+    return [];
+  }
+}
+
+function doctor(args) {
+  const root = appRoot(args);
+  const config = readConfig(root);
+  const requestedPlatform = args.platform;
+  if (requestedPlatform && !['android', 'ios', 'all'].includes(requestedPlatform)) {
+    return fail('--platform must be android, ios, or all');
+  }
+  const platforms = requestedPlatform === 'all' || (!requestedPlatform && process.platform === 'darwin')
+    ? new Set(['android', 'ios'])
+    : new Set([requestedPlatform || 'android']);
+  const checks = [];
+  const check = (name, ok, detail, required = true) => checks.push({ name, ok, detail, required });
+  const deps = { ...config.packageJson.dependencies, ...config.packageJson.devDependencies };
+  check('React Native package', Boolean(deps['react-native']), deps['react-native'] || 'not found');
+  check('New Architecture', config.expo.newArchEnabled === true, `newArchEnabled=${String(config.expo.newArchEnabled)}`);
+  const editors = installedEditors();
+  const editor = editors.find((item) => VERSION_PATTERN.test(item.version));
+  check('Unity 6000.3 editor', Boolean(editor), editor?.version || 'not installed');
+  if (platforms.has('android')) {
+    check('Android unityLibrary', fs.existsSync(path.join(config.androidExportPath, 'build.gradle')), config.androidExportPath);
+    check('Android manifest', fs.existsSync(path.join(config.androidExportPath, 'src/main/AndroidManifest.xml')), 'src/main/AndroidManifest.xml');
+    const unityPropertiesPath = path.join(config.androidExportPath, '..', 'gradle.properties');
+    const unityProperties = fs.existsSync(unityPropertiesPath) ? fs.readFileSync(unityPropertiesPath, 'utf8') : '';
+    const abiLine = unityProperties.match(/^unity\.abiFilters=(.+)$/m)?.[1] || 'not found';
+    check('Android x86_64 ABI', abiLine.split(',').includes('x86_64'), abiLine);
+    const settings = path.join(root, 'android', 'settings.gradle');
+    const appGradle = path.join(root, 'android', 'app', 'build.gradle');
+    check('Android Gradle integration',
+      fs.existsSync(settings) && fs.readFileSync(settings, 'utf8').includes("include ':unityLibrary'") &&
+        fs.existsSync(appGradle) && fs.readFileSync(appGradle, 'utf8').includes("implementation project(':unityLibrary')"),
+      'settings.gradle and app/build.gradle');
+  } else {
+    check('Android checks', true, 'not requested', false);
+  }
+  if (platforms.has('ios')) {
+    check('iOS Unity project', fs.existsSync(path.join(config.iosExportPath, 'Unity-iPhone.xcodeproj')), config.iosExportPath);
+    const podfile = path.join(root, 'ios', 'Podfile');
+    check('iOS Podfile integration', fs.existsSync(podfile) && fs.readFileSync(podfile, 'utf8').includes('ReactNativeUnity.configure_unity_project'), podfile);
+  } else {
+    check('iOS checks', true, 'not requested on this host', false);
+  }
+  const conflicts = ['@azesmway/react-native-unity', 'react-native-unity-view'].filter((name) => deps[name]);
+  check('Conflicting packages', conflicts.length === 0, conflicts.join(', ') || 'none');
+  for (const item of checks) console.log(`${item.required ? (item.ok ? 'PASS' : 'FAIL') : 'SKIP'}  ${item.name}: ${item.detail}`);
+  if (checks.some((item) => item.required && !item.ok)) process.exitCode = 1;
+}
+
+function exportUnity(args) {
+  const platform = args.platform;
+  if (!['android', 'ios'].includes(platform)) return fail('--platform must be android or ios');
+  if (!args['unity-project']) return fail('--unity-project is required');
+  if (!args.output) return fail('--output is required');
+  const editor = installedEditors().find((item) => VERSION_PATTERN.test(item.version) && item.location);
+  if (!editor) return fail('Unity 6000.3 editor not found');
+  const projectPath = path.resolve(String(args['unity-project']));
+  const outputPath = path.resolve(String(args.output));
+  const result = spawnSync(editor.location, [
+    '-batchmode', '-quit', '-nographics',
+    '-projectPath', projectPath,
+    '-executeMethod', 'ReactNativeUnity.Editor.Exporter.ExportFromCommandLine',
+    '-rnUnityPlatform', platform,
+    '-rnUnityOutput', outputPath,
+    '-logFile', '-',
+  ], { stdio: 'inherit' });
+  if (result.error) return fail(result.error.message);
+  if (result.status !== 0) return fail(`Unity export failed with exit code ${result.status}`);
+}
+
+const args = parseArgs(process.argv.slice(2));
+switch (args._[0]) {
+  case 'doctor': doctor(args); break;
+  case 'export': exportUnity(args); break;
+  default:
+    console.log('Usage: rn-unity doctor [--project path] [--platform android|ios|all]\n       rn-unity export --platform android|ios --unity-project path --output path');
+    if (args._[0]) process.exitCode = 1;
+}

package/ios/RNUnityNativeBridge.mm

@@ -0,0 +1,6 @@
+#import "RNUnityRuntimeController.h"
+
+extern "C" void RNUnitySendMessage(const char *message) {
+  NSString *value = message ? [NSString stringWithUTF8String:message] : @"";
+  [[RNUnityRuntimeController shared] receiveMessage:value];
+}

package/ios/RNUnityRuntimeController.h

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+FOUNDATION_EXPORT NSNotificationName const RNUnityStateChangeNotification;
+FOUNDATION_EXPORT NSNotificationName const RNUnityMessageNotification;
+FOUNDATION_EXPORT NSNotificationName const RNUnityErrorNotification;
+
+@class RNUnityView;
+
+@interface RNUnityRuntimeController : NSObject
++ (instancetype)shared;
+- (void)start:(NSString *)detachedBehavior resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (void)pause:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (void)resume:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (void)unload:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (void)sendMessage:(NSString *)gameObject methodName:(NSString *)methodName message:(NSString *)message resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (void)attachHost:(RNUnityView *)host;
+- (void)detachHost:(NSString *)hostId;
+- (void)setApplicationBackgrounded:(BOOL)backgrounded;
+- (NSString *)stateName;
+- (NSString *)diagnosticsJSON;
+- (void)receiveMessage:(NSString *)message;
+@end
+
+NS_ASSUME_NONNULL_END
+

package/ios/RNUnityRuntimeController.mm

@@ -0,0 +1,316 @@
+#import "RNUnityRuntimeController.h"
+#import "RNUnityView.h"
+#import <UnityFramework/UnityFramework.h>
+#import <mach-o/ldsyms.h>
+
+NSNotificationName const RNUnityStateChangeNotification = @"RNUnity:stateChange";
+NSNotificationName const RNUnityMessageNotification = @"RNUnity:message";
+NSNotificationName const RNUnityErrorNotification = @"RNUnity:error";
+
+typedef NS_ENUM(NSInteger, RNUnityState) {
+  RNUnityStateIdle,
+  RNUnityStateStarting,
+  RNUnityStateRunningDetached,
+  RNUnityStateRunningAttached,
+  RNUnityStatePausedDetached,
+  RNUnityStatePausedAttached,
+  RNUnityStateUnloading,
+  RNUnityStateQuitted,
+  RNUnityStateFailed,
+};
+
+@interface RNUnityRuntimeController () <UnityFrameworkListener>
+@property(nonatomic) RNUnityState state;
+@property(nonatomic) NSInteger generation;
+@property(nonatomic) NSTimeInterval lastTransitionAt;
+@property(nonatomic, strong, nullable) UnityFramework *framework;
+@property(nonatomic, weak, nullable) RNUnityView *host;
+@property(nonatomic, weak, nullable) RNUnityView *pendingHost;
+@property(nonatomic, strong) NSMutableSet<NSString *> *pauseReasons;
+@property(nonatomic, strong) NSMutableArray<RCTPromiseResolveBlock> *startResolves;
+@property(nonatomic, strong) NSMutableArray<RCTPromiseRejectBlock> *startRejects;
+@property(nonatomic, copy, nullable) RCTPromiseResolveBlock unloadResolve;
+@property(nonatomic, copy, nullable) RCTPromiseRejectBlock unloadReject;
+@property(nonatomic, copy, nullable) NSString *pendingStartBehavior;
+@property(nonatomic, copy, nullable) RCTPromiseResolveBlock pendingStartResolve;
+@property(nonatomic, copy, nullable) RCTPromiseRejectBlock pendingStartReject;
+@property(nonatomic, copy) NSString *defaultDetachedBehavior;
+@property(nonatomic, strong, nullable) NSDictionary *lastError;
+@property(nonatomic, strong, nullable) dispatch_block_t unloadTimeout;
+@end
+
+@implementation RNUnityRuntimeController
+
++ (instancetype)shared {
+  static RNUnityRuntimeController *controller;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{ controller = [RNUnityRuntimeController new]; });
+  return controller;
+}
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _state = RNUnityStateIdle;
+    _pauseReasons = [NSMutableSet set];
+    _startResolves = [NSMutableArray array];
+    _startRejects = [NSMutableArray array];
+    _defaultDetachedBehavior = @"pause";
+    _lastTransitionAt = NSDate.date.timeIntervalSince1970 * 1000;
+  }
+  return self;
+}
+
+- (void)onMain:(dispatch_block_t)block {
+  if (NSThread.isMainThread) block(); else dispatch_async(dispatch_get_main_queue(), block);
+}
+
+- (NSString *)stateName {
+  switch (_state) {
+    case RNUnityStateIdle: return @"idle";
+    case RNUnityStateStarting: return @"starting";
+    case RNUnityStateRunningDetached: return @"runningDetached";
+    case RNUnityStateRunningAttached: return @"runningAttached";
+    case RNUnityStatePausedDetached: return @"pausedDetached";
+    case RNUnityStatePausedAttached: return @"pausedAttached";
+    case RNUnityStateUnloading: return @"unloading";
+    case RNUnityStateQuitted: return @"quitted";
+    case RNUnityStateFailed: return @"failed";
+  }
+}
+
+- (BOOL)isRunningOrPaused {
+  return _state >= RNUnityStateRunningDetached && _state <= RNUnityStatePausedAttached;
+}
+
+- (void)transition:(RNUnityState)next {
+  if (_state == next) return;
+  _state = next;
+  _lastTransitionAt = NSDate.date.timeIntervalSince1970 * 1000;
+  NSDictionary *event = @{ @"state": self.stateName, @"generation": @(_generation) };
+  [NSNotificationCenter.defaultCenter postNotificationName:RNUnityStateChangeNotification object:self userInfo:event];
+  [_host emitState:self.stateName generation:_generation];
+}
+
+- (NSDictionary *)error:(NSString *)code message:(NSString *)message cause:(nullable NSString *)cause {
+  return @{
+    @"code": code, @"message": message, @"state": self.stateName,
+    @"generation": @(_generation), @"nativeCause": cause ?: @"",
+  };
+}
+
+- (void)reject:(RCTPromiseRejectBlock)reject code:(NSString *)code message:(NSString *)message {
+  reject(code, message, nil);
+}
+
+- (nullable UnityFramework *)loadFramework:(NSError **)error {
+  UnityFramework *framework = [UnityFramework getInstance];
+  if (framework) return framework;
+  NSString *path = [NSBundle.mainBundle pathForResource:@"UnityFramework" ofType:@"framework" inDirectory:@"Frameworks"];
+  NSBundle *bundle = path ? [NSBundle bundleWithPath:path] : nil;
+  if (!bundle || ![bundle loadAndReturnError:error]) return nil;
+  return [UnityFramework getInstance];
+}
+
+- (void)start:(NSString *)detachedBehavior resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [self onMain:^{
+    self.defaultDetachedBehavior = [detachedBehavior isEqualToString:@"keepRunning"] ? @"keepRunning" : @"pause";
+    if (self.state == RNUnityStateStarting) {
+      [self.startResolves addObject:resolve]; [self.startRejects addObject:reject]; return;
+    }
+    if ([self isRunningOrPaused]) { resolve(nil); return; }
+    if (self.state == RNUnityStateUnloading) {
+      if (self.pendingStartReject) self.pendingStartReject(@"E_UNLOADING", @"A newer start request replaced this queued request", nil);
+      self.pendingStartBehavior = self.defaultDetachedBehavior;
+      self.pendingStartResolve = resolve; self.pendingStartReject = reject; return;
+    }
+    if (self.state == RNUnityStateQuitted) { [self reject:reject code:@"E_PROCESS_RESTART_REQUIRED" message:@"Unity has quit in this process"]; return; }
+    if (self.state == RNUnityStateFailed) { [self reject:reject code:@"E_NATIVE_INVARIANT" message:@"Unity runtime is in a failed state"]; return; }
+    [self startNewGeneration:resolve reject:reject];
+  }];
+}
+
+- (void)startNewGeneration:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  _generation += 1;
+  [self transition:RNUnityStateStarting];
+  [_startResolves addObject:resolve]; [_startRejects addObject:reject];
+  NSError *error = nil;
+  UnityFramework *framework = [self loadFramework:&error];
+  if (!framework) {
+    [self fail:@"E_RUNTIME_START_FAILED" message:@"UnityFramework could not be loaded" cause:error.localizedDescription];
+    for (RCTPromiseRejectBlock item in _startRejects) item(@"E_RUNTIME_START_FAILED", error.localizedDescription, error);
+    [_startResolves removeAllObjects]; [_startRejects removeAllObjects]; return;
+  }
+  _framework = framework;
+  [framework setExecuteHeader:&_mh_execute_header];
+  [framework setDataBundleId:"com.unity3d.framework"];
+  [framework registerFrameworkListener:self];
+  char *argv[] = { (char *)"rn-unity" };
+  [framework runEmbeddedWithArgc:1 argv:argv appLaunchOpts:@{}];
+  [self transition:RNUnityStateRunningDetached];
+  if ([_defaultDetachedBehavior isEqualToString:@"pause"] && !_pendingHost) [self addPauseReason:@"NO_HOST"];
+  if (_pendingHost) [self attachNow:_pendingHost];
+  for (RCTPromiseResolveBlock item in _startResolves) item(nil);
+  [_startResolves removeAllObjects]; [_startRejects removeAllObjects];
+}
+
+- (void)attachHost:(RNUnityView *)host {
+  [self onMain:^{
+    if (!host.window || host.bounds.size.width <= 0 || host.bounds.size.height <= 0) return;
+    if (self.host && ![self.host.hostId isEqualToString:host.hostId]) {
+      [host emitError:[self error:@"E_HOST_IN_USE" message:@"Another UnityView is already attached" cause:nil]]; return;
+    }
+    self.pendingHost = host;
+    if ([self isRunningOrPaused]) [self attachNow:host];
+  }];
+}
+
+- (void)attachNow:(RNUnityView *)host {
+  UIView *root = _framework.appController.rootView;
+  if (!root) return;
+  _host = host; _pendingHost = nil;
+  [host mountUnityView:root];
+  [self removePauseReason:@"NO_HOST"];
+  [self transition:_pauseReasons.count == 0 ? RNUnityStateRunningAttached : RNUnityStatePausedAttached];
+  [host emitReadyWithState:self.stateName generation:_generation];
+}
+
+- (void)detachHost:(NSString *)hostId {
+  [self onMain:^{
+    if (![self.host.hostId isEqualToString:hostId]) {
+      if ([self.pendingHost.hostId isEqualToString:hostId]) self.pendingHost = nil;
+      return;
+    }
+    RNUnityView *oldHost = self.host;
+    [oldHost unmountUnityView:self.framework.appController.rootView];
+    self.host = nil;
+    if ([oldHost.detachedBehavior isEqualToString:@"pause"]) [self addPauseReason:@"NO_HOST"];
+    [self transition:self.pauseReasons.count == 0 ? RNUnityStateRunningDetached : RNUnityStatePausedDetached];
+  }];
+}
+
+- (void)addPauseReason:(NSString *)reason {
+  BOOL wasRunning = _pauseReasons.count == 0;
+  [_pauseReasons addObject:reason];
+  if (wasRunning) [_framework pause:YES];
+  [self syncPauseState];
+}
+
+- (void)removePauseReason:(NSString *)reason {
+  if (![_pauseReasons containsObject:reason]) return;
+  [_pauseReasons removeObject:reason];
+  if (_pauseReasons.count == 0) [_framework pause:NO];
+  [self syncPauseState];
+}
+
+- (void)syncPauseState {
+  if (![self isRunningOrPaused]) return;
+  BOOL attached = _host != nil;
+  [self transition:_pauseReasons.count == 0
+    ? (attached ? RNUnityStateRunningAttached : RNUnityStateRunningDetached)
+    : (attached ? RNUnityStatePausedAttached : RNUnityStatePausedDetached)];
+}
+
+- (void)pause:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [self onMain:^{ if (![self isRunningOrPaused]) { [self reject:reject code:@"E_RUNTIME_NOT_READY" message:@"Unity is not running"]; return; } [self addPauseReason:@"USER"]; resolve(nil); }];
+}
+
+- (void)resume:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [self onMain:^{ if (![self isRunningOrPaused]) { [self reject:reject code:@"E_RUNTIME_NOT_READY" message:@"Unity is not running"]; return; } [self removePauseReason:@"USER"]; resolve(nil); }];
+}
+
+- (void)setApplicationBackgrounded:(BOOL)backgrounded {
+  [self onMain:^{ if (![self isRunningOrPaused]) return; if (backgrounded) [self addPauseReason:@"APP_BACKGROUND"]; else [self removePauseReason:@"APP_BACKGROUND"]; }];
+}
+
+- (void)unload:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [self onMain:^{
+    if (self.state == RNUnityStateIdle) { resolve(nil); return; }
+    if (self.state == RNUnityStateUnloading) { [self reject:reject code:@"E_UNLOADING" message:@"Unity is already unloading"]; return; }
+    if (self.state == RNUnityStateQuitted) { [self reject:reject code:@"E_PROCESS_RESTART_REQUIRED" message:@"Unity has quit in this process"]; return; }
+    if (self.state == RNUnityStateFailed) { [self reject:reject code:@"E_NATIVE_INVARIANT" message:@"Unity runtime is in a failed state"]; return; }
+    [self.host unmountUnityView:self.framework.appController.rootView];
+    self.host = nil; self.pendingHost = nil; [self.pauseReasons removeAllObjects];
+    [self transition:RNUnityStateUnloading];
+    self.unloadResolve = resolve; self.unloadReject = reject;
+    NSInteger token = self.generation;
+    dispatch_block_t timeout = dispatch_block_create(0, ^{
+      if (self.state == RNUnityStateUnloading && self.generation == token) {
+        [self fail:@"E_UNLOAD_TIMEOUT" message:@"Unity did not report unload completion" cause:nil];
+        if (self.unloadReject) self.unloadReject(@"E_UNLOAD_TIMEOUT", @"Unity did not report unload completion", nil);
+        self.unloadResolve = nil; self.unloadReject = nil;
+        if (self.pendingStartReject) {
+          self.pendingStartReject(@"E_PROCESS_RESTART_REQUIRED", @"Unity unload timed out; restart the app process before starting Unity again", nil);
+        }
+        self.pendingStartResolve = nil; self.pendingStartReject = nil; self.pendingStartBehavior = nil;
+      }
+    });
+    self.unloadTimeout = timeout;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 15 * NSEC_PER_SEC), dispatch_get_main_queue(), timeout);
+    [self.framework unloadApplication];
+  }];
+}
+
+- (void)unityDidUnload:(NSNotification *)notification {
+  [self onMain:^{
+    if (self.state != RNUnityStateUnloading) return;
+    if (self.unloadTimeout) dispatch_block_cancel(self.unloadTimeout);
+    [self.framework unregisterFrameworkListener:self]; self.framework = nil;
+    [self transition:RNUnityStateIdle];
+    if (self.unloadResolve) self.unloadResolve(nil);
+    self.unloadResolve = nil; self.unloadReject = nil;
+    if (self.pendingStartResolve) {
+      RCTPromiseResolveBlock nextResolve = self.pendingStartResolve;
+      RCTPromiseRejectBlock nextReject = self.pendingStartReject;
+      self.defaultDetachedBehavior = self.pendingStartBehavior ?: @"pause";
+      self.pendingStartResolve = nil; self.pendingStartReject = nil; self.pendingStartBehavior = nil;
+      [self startNewGeneration:nextResolve reject:nextReject];
+    }
+  }];
+}
+
+- (void)unityDidQuit:(NSNotification *)notification {
+  [self onMain:^{
+    [self.framework unregisterFrameworkListener:self]; self.framework = nil; [self transition:RNUnityStateQuitted];
+    if (self.unloadReject) self.unloadReject(@"E_PROCESS_RESTART_REQUIRED", @"Unity quit during unload", nil);
+    self.unloadResolve = nil; self.unloadReject = nil;
+    if (self.pendingStartReject) self.pendingStartReject(@"E_PROCESS_RESTART_REQUIRED", @"Unity has quit in this process", nil);
+    self.pendingStartResolve = nil; self.pendingStartReject = nil; self.pendingStartBehavior = nil;
+  }];
+}
+
+- (void)sendMessage:(NSString *)gameObject methodName:(NSString *)methodName message:(NSString *)message resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [self onMain:^{
+    if (![self isRunningOrPaused]) { [self reject:reject code:@"E_RUNTIME_NOT_READY" message:@"Unity is not ready for messages"]; return; }
+    [self.framework sendMessageToGOWithName:gameObject.UTF8String functionName:methodName.UTF8String message:message.UTF8String];
+    resolve(nil);
+  }];
+}
+
+- (void)receiveMessage:(NSString *)message {
+  [self onMain:^{
+    NSDictionary *event = @{ @"generation": @(self.generation), @"message": message };
+    [NSNotificationCenter.defaultCenter postNotificationName:RNUnityMessageNotification object:self userInfo:event];
+    [self.host emitMessage:message generation:self.generation];
+  }];
+}
+
+- (void)fail:(NSString *)code message:(NSString *)message cause:(nullable NSString *)cause {
+  [self transition:RNUnityStateFailed];
+  _lastError = [self error:code message:message cause:cause];
+  [NSNotificationCenter.defaultCenter postNotificationName:RNUnityErrorNotification object:self userInfo:_lastError];
+  [_host emitError:_lastError];
+}
+
+- (NSString *)diagnosticsJSON {
+  NSMutableDictionary *data = [@{
+    @"state": self.stateName, @"generation": @(_generation),
+    @"pauseReasons": _pauseReasons.allObjects, @"lastTransitionAt": @(_lastTransitionAt),
+    @"unityVersion": @"6000.3.x", @"packageVersion": @"0.1.0-next.14",
+  } mutableCopy];
+  if (_host) data[@"hostId"] = _host.hostId;
+  if (_lastError) data[@"lastError"] = _lastError;
+  NSData *json = [NSJSONSerialization dataWithJSONObject:data options:0 error:nil];
+  return [[NSString alloc] initWithData:json encoding:NSUTF8StringEncoding];
+}
+
+@end

package/ios/RNUnityView.h

@@ -0,0 +1,17 @@
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNUnityView : RCTViewComponentView
+@property(nonatomic, readonly) NSString *hostId;
+@property(nonatomic, copy) NSString *detachedBehavior;
+- (void)mountUnityView:(UIView *)view;
+- (void)unmountUnityView:(nullable UIView *)view;
+- (void)emitReadyWithState:(NSString *)state generation:(NSInteger)generation;
+- (void)emitMessage:(NSString *)message generation:(NSInteger)generation;
+- (void)emitState:(NSString *)state generation:(NSInteger)generation;
+- (void)emitError:(NSDictionary *)error;
+@end
+
+NS_ASSUME_NONNULL_END
+