@babylonjs/react-native 0.4.0-alpha.4 → 0.4.0-alpha.43

package/android/src/main/java/com/babylonreactnative/BabylonNativeInterop.java

@@ -7,169 +7,118 @@ import android.view.MotionEvent;
 import android.view.Surface;
 
 import com.facebook.react.bridge.ActivityEventListener;
-import com.facebook.react.bridge.JavaScriptContextHolder;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
 
-import java.util.Hashtable;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
+public final class BabylonNativeInterop {
 
-final class BabylonNativeInterop {
-    // JNI interface
-    static {
-        System.loadLibrary("BabylonNative");
+    private static class BabylonNative {
+        static {
+            System.loadLibrary("BabylonNative");
+        }
+
+        public static native void initialize(Context context, long jsiRuntimeRef, CallInvokerHolder jsCallInvokerHolder);
+        public static native void setCurrentActivity(Activity activity);
+        public static native void pause();
+        public static native void resume();
+        public static native void updateView(Surface surface);
+        public static native void renderView();
+        public static native void resetView();
+        public static native void updateXRView(Surface surface);
+        public static native boolean isXRActive();
+        public static native void setTouchButtonState(int pointerId, boolean isDown, int x, int y);
+        public static native void setTouchPosition(int pointerId, int x, int y);
     }
 
-    private static boolean isInitialized;
-    private static final Hashtable<JavaScriptContextHolder, CompletableFuture<Long>> nativeInstances = new Hashtable<>();
-
-    private static native void initialize(Context context);
-    private static native void setCurrentActivity(Activity activity);
-    private static native void pause();
-    private static native void resume();
-    private static native long create(long jsiRuntimeRef, CallInvokerHolder callInvokerHolder, Surface surface);
-    private static native void refresh(long instanceRef, Surface surface);
-    private static native void setPointerButtonState(long instanceRef, int pointerId, int buttonId, boolean isDown, int x, int y);
-    private static native void setPointerPosition(long instanceRef, int pointerId, int x, int y);
-    private static native void reset(long instanceRef);
-    private static native void destroy(long instanceRef);
-
-    // Must be called from the Android UI thread
-    static void setView(ReactContext reactContext, Surface surface) {
-        // This is global initialization that only needs to happen once
-        if (!BabylonNativeInterop.isInitialized) {
-            BabylonNativeInterop.initialize(reactContext);
-            BabylonNativeInterop.isInitialized = true;
+    private static LifecycleEventListener lifeCycleEventListener;
+    private static ActivityEventListener activityEventListener;
+
+    public static void initialize(ReactContext reactContext) {
+        long jsiRuntimeRef = reactContext.getJavaScriptContextHolder().get();
+        CallInvokerHolder jsCallInvokerHolder = reactContext.getCatalystInstance().getJSCallInvokerHolder();
+        BabylonNative.initialize(reactContext, jsiRuntimeRef, jsCallInvokerHolder);
+
+        if (BabylonNativeInterop.lifeCycleEventListener != null) {
+            reactContext.removeLifecycleEventListener(lifeCycleEventListener);
         }
 
-        BabylonNativeInterop.destroyOldNativeInstances(reactContext);
-
-        CompletableFuture<Long> instanceRefFuture = BabylonNativeInterop.getOrCreateFuture(reactContext);
-
-        reactContext.runOnJSQueueThread(() -> {
-            Long instanceRef = instanceRefFuture.getNow(null);
-            if (instanceRef == null)
-            {
-                long jsiRuntimeRef = reactContext.getJavaScriptContextHolder().get();
-                if (jsiRuntimeRef == 0) {
-                    instanceRefFuture.complete(0L);
-                } else {
-                    instanceRef = BabylonNativeInterop.create(jsiRuntimeRef, reactContext.getCatalystInstance().getJSCallInvokerHolder(), surface);
-                    final long finalInstanceRef = instanceRef;
-
-                    reactContext.addLifecycleEventListener(new LifecycleEventListener() {
-                        @Override
-                        public void onHostResume() {
-                            BabylonNativeInterop.setCurrentActivity(reactContext.getCurrentActivity());
-                            BabylonNativeInterop.resume();
-                        }
-
-                        @Override
-                        public void onHostPause() {
-                            BabylonNativeInterop.pause();
-                        }
-
-                        @Override
-                        public void onHostDestroy() {
-                            BabylonNativeInterop.deinitialize();
-                        }
-                    });
-
-                    reactContext.addActivityEventListener(new ActivityEventListener() {
-                        @Override
-                        public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
-                            // Nothing to do here
-                        }
-
-                        @Override
-                        public void onNewIntent(Intent intent) {
-                            BabylonNativeInterop.setCurrentActivity(reactContext.getCurrentActivity());
-                        }
-                    });
-
-                    instanceRefFuture.complete(finalInstanceRef);
-                }
-            } else if (instanceRef != 0) {
-                BabylonNativeInterop.refresh(instanceRef, surface);
+        BabylonNativeInterop.lifeCycleEventListener = new LifecycleEventListener() {
+            @Override
+            public void onHostResume() {
+                BabylonNative.setCurrentActivity(reactContext.getCurrentActivity());
+                BabylonNative.resume();
             }
-        });
-    }
 
-    static void reportMotionEvent(ReactContext reactContext, MotionEvent motionEvent) {
-        CompletableFuture<Long> instanceRefFuture = BabylonNativeInterop.nativeInstances.get(reactContext.getJavaScriptContextHolder());
-        if (instanceRefFuture != null) {
-            Long instanceRef = instanceRefFuture.getNow(null);
-            if (instanceRef != null) {
-                int maskedAction = motionEvent.getActionMasked();
-                boolean isPointerDown = maskedAction == MotionEvent.ACTION_DOWN || maskedAction == MotionEvent.ACTION_POINTER_DOWN;
-                boolean isPointerUp = maskedAction == MotionEvent.ACTION_UP || maskedAction == MotionEvent.ACTION_POINTER_UP;
-                boolean isPointerMove = maskedAction == MotionEvent.ACTION_MOVE;
-
-                if (isPointerDown || isPointerUp) {
-                    int pointerIndex = motionEvent.getActionIndex();
-                    int pointerId = motionEvent.getPointerId(pointerIndex);
-                    int buttonId = motionEvent.getActionButton();
-                    int x = (int)motionEvent.getX(pointerIndex);
-                    int y = (int)motionEvent.getY(pointerIndex);
-                    BabylonNativeInterop.setPointerButtonState(instanceRef, pointerId, buttonId, isPointerDown, x, y);
-                } else if (isPointerMove) {
-                    for (int pointerIndex = 0; pointerIndex < motionEvent.getPointerCount(); pointerIndex++) {
-                        int pointerId = motionEvent.getPointerId(pointerIndex);
-                        int x = (int)motionEvent.getX(pointerIndex);
-                        int y = (int)motionEvent.getY(pointerIndex);
-                        BabylonNativeInterop.setPointerPosition(instanceRef, pointerId, x, y);
-                    }
-                }
+            @Override
+            public void onHostPause() {
+                BabylonNative.pause();
             }
+
+            @Override
+            public void onHostDestroy() {
+            }
+        };
+
+        reactContext.addLifecycleEventListener(lifeCycleEventListener);
+
+        if (BabylonNativeInterop.activityEventListener != null) {
+            reactContext.removeActivityEventListener(BabylonNativeInterop.activityEventListener);
         }
+
+        BabylonNativeInterop.activityEventListener = new ActivityEventListener() {
+            @Override
+            public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+                // Nothing to do here
+            }
+
+            @Override
+            public void onNewIntent(Intent intent) {
+                BabylonNative.setCurrentActivity(reactContext.getCurrentActivity());
+            }
+        };
+
+        reactContext.addActivityEventListener(BabylonNativeInterop.activityEventListener);
     }
 
-    // Must be called from the Android UI thread
-    static CompletionStage<Long> whenInitialized(ReactContext reactContext) {
-        return BabylonNativeInterop.getOrCreateFuture(reactContext);
+    public static void updateView(Surface surface) {
+        BabylonNative.updateView(surface);
     }
 
-    // Must be called from the JavaScript thread
-    static void deinitialize() {
-        BabylonNativeInterop.destroyOldNativeInstances(null);
+    public static void renderView() {
+        BabylonNative.renderView();
     }
 
-    static void reset(ReactContext reactContext) {
-        JavaScriptContextHolder jsContext = reactContext.getJavaScriptContextHolder();
-        CompletableFuture<Long> instanceRefFuture = BabylonNativeInterop.nativeInstances.get(jsContext);
-        if (instanceRefFuture != null) {
-            Long instanceRef = instanceRefFuture.getNow(null);
-            if (instanceRef != null) {
-                BabylonNativeInterop.reset(instanceRef);
-            }
-        }
+    public static void resetView() {
+        BabylonNative.resetView();
     }
 
-    private static CompletableFuture<Long> getOrCreateFuture(ReactContext reactContext) {
-        JavaScriptContextHolder jsContext = reactContext.getJavaScriptContextHolder();
-        CompletableFuture<Long> instanceRefFuture = BabylonNativeInterop.nativeInstances.get(jsContext);
-        if (instanceRefFuture == null)
-        {
-            instanceRefFuture = new CompletableFuture<>();
-            BabylonNativeInterop.nativeInstances.put(jsContext, instanceRefFuture);
-        }
-        return instanceRefFuture;
+    public static void updateXRView(Surface surface) {
+        BabylonNative.updateXRView(surface);
+    }
+
+    public static boolean isXRActive() {
+        return BabylonNative.isXRActive();
     }
 
-    private static void destroyOldNativeInstances(ReactContext currentReactContext) {
-        Iterator<Map.Entry<JavaScriptContextHolder, CompletableFuture<Long>>> nativeInstanceIterator = BabylonNativeInterop.nativeInstances.entrySet().iterator();
-        while (nativeInstanceIterator.hasNext()) {
-            Map.Entry<JavaScriptContextHolder, CompletableFuture<Long>> nativeInstanceInfo = nativeInstanceIterator.next();
-            if (currentReactContext == null || nativeInstanceInfo.getKey() != currentReactContext.getJavaScriptContextHolder()) {
-                Long oldInstanceRef = nativeInstanceInfo.getValue().getNow(null);
-                if (oldInstanceRef != null && oldInstanceRef != 0) {
-                    BabylonNativeInterop.destroy(oldInstanceRef);
-                }
-                nativeInstanceIterator.remove();
+    public static void reportMotionEvent(MotionEvent motionEvent) {
+        int maskedAction = motionEvent.getActionMasked();
+        boolean isPointerDown = maskedAction == MotionEvent.ACTION_DOWN || maskedAction == MotionEvent.ACTION_POINTER_DOWN;
+        boolean isPointerUp = maskedAction == MotionEvent.ACTION_UP || maskedAction == MotionEvent.ACTION_POINTER_UP;
+        boolean isPointerMove = maskedAction == MotionEvent.ACTION_MOVE;
+
+        if (isPointerDown || isPointerUp) {
+            int pointerIndex = motionEvent.getActionIndex();
+            int pointerId = motionEvent.getPointerId(pointerIndex);
+            int x = (int)motionEvent.getX(pointerIndex);
+            int y = (int)motionEvent.getY(pointerIndex);
+            BabylonNative.setTouchButtonState(pointerId, isPointerDown, x, y);
+        } else if (isPointerMove) {
+            for (int pointerIndex = 0; pointerIndex < motionEvent.getPointerCount(); pointerIndex++) {
+                int pointerId = motionEvent.getPointerId(pointerIndex);
+                int x = (int)motionEvent.getX(pointerIndex);
+                int y = (int)motionEvent.getY(pointerIndex);
+                BabylonNative.setTouchPosition(pointerId, x, y);
             }
         }
     }

package/android/src/main/java/com/babylonreactnative/EngineView.java

@@ -11,6 +11,7 @@ import android.view.PixelCopy;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
+import android.widget.FrameLayout;
 
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.UIManagerModule;
@@ -18,36 +19,79 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 
 import java.io.ByteArrayOutputStream;
 
-public final class EngineView extends SurfaceView implements SurfaceHolder.Callback, View.OnTouchListener {
-    private final ReactContext reactContext;
+public final class EngineView extends FrameLayout implements SurfaceHolder.Callback, View.OnTouchListener {
+    private static final FrameLayout.LayoutParams childViewLayoutParams = new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+    private final SurfaceView primarySurfaceView;
+    private final SurfaceView xrSurfaceView;
     private final EventDispatcher reactEventDispatcher;
+    private Runnable renderRunnable;
 
     public EngineView(ReactContext reactContext) {
         super(reactContext);
-        this.reactContext = reactContext;
-        this.getHolder().addCallback(this);
+
+        this.primarySurfaceView = new SurfaceView(reactContext);
+        this.primarySurfaceView.setLayoutParams(EngineView.childViewLayoutParams);
+        this.primarySurfaceView.getHolder().addCallback(this);
+        this.addView(this.primarySurfaceView);
+
+        this.xrSurfaceView = new SurfaceView(reactContext);
+        this.xrSurfaceView.setLayoutParams(childViewLayoutParams);
+        this.xrSurfaceView.getHolder().addCallback(new SurfaceHolder.Callback() {
+            @Override
+            public void surfaceCreated(SurfaceHolder holder) {
+                // surfaceChanged is also called when the surface is created, so just do all the handling there
+            }
+
+            @Override
+            public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+                BabylonNativeInterop.updateXRView(holder.getSurface());
+            }
+
+            @Override
+            public void surfaceDestroyed(SurfaceHolder holder) {
+                BabylonNativeInterop.updateXRView(null);
+            }
+        });
+        this.xrSurfaceView.setVisibility(View.INVISIBLE);
+        this.addView(this.xrSurfaceView);
+
         this.setOnTouchListener(this);
-        this.reactEventDispatcher = this.reactContext.getNativeModule(UIManagerModule.class).getEventDispatcher();
+
+        this.reactEventDispatcher = reactContext.getNativeModule(UIManagerModule.class).getEventDispatcher();
     }
 
     @Override
     public void surfaceCreated(SurfaceHolder surfaceHolder) {
-        // surfaceChanged is also called when the surface is created, so just do all the handling there
+        this.renderRunnable = new Runnable() {
+            @Override
+            public void run() {
+                if (BabylonNativeInterop.isXRActive()) {
+                    EngineView.this.xrSurfaceView.setVisibility(View.VISIBLE);
+                } else {
+                    EngineView.this.xrSurfaceView.setVisibility(View.INVISIBLE);
+                }
+
+                BabylonNativeInterop.renderView();
+                EngineView.this.postOnAnimation(this);
+            }
+        };
+        this.postOnAnimation(this.renderRunnable);
     }
 
     @Override
     public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int width, int height) {
-        BabylonNativeInterop.setView(this.reactContext, surfaceHolder.getSurface());
+        BabylonNativeInterop.updateView(surfaceHolder.getSurface());
     }
 
     @Override
     public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
-
+        this.removeCallbacks(this.renderRunnable);
+        this.renderRunnable = null;
     }
 
     @Override
     public boolean onTouch(View view, MotionEvent motionEvent) {
-        BabylonNativeInterop.reportMotionEvent(this.reactContext, motionEvent);
+        BabylonNativeInterop.reportMotionEvent(motionEvent);
         return true;
     }
 
@@ -70,13 +114,18 @@ public final class EngineView extends SurfaceView implements SurfaceHolder.Callb
         helperThread.start();
         final Handler helperThreadHandler = new Handler(helperThread.getLooper());
 
+        SurfaceView surfaceView = this.primarySurfaceView;
+        if (BabylonNativeInterop.isXRActive()) {
+            surfaceView = this.xrSurfaceView;
+        }
+
         // Request the pixel copy.
-        PixelCopy.request(this, bitmap, (copyResult) ->  {
+        PixelCopy.request(surfaceView, bitmap, (copyResult) ->  {
             // If the pixel copy was a success then convert the image to a base 64 encoded jpeg and fire the event.
             String encoded = "";
             if (copyResult == PixelCopy.SUCCESS) {
                 ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream();
-                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayStream);
+                bitmap.compress(Bitmap.CompressFormat.JPEG, 80, byteArrayStream);
                 byte[] byteArray = byteArrayStream.toByteArray();
                 bitmap.recycle();
                 encoded = Base64.encodeToString(byteArray, Base64.DEFAULT);

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from './EngineView';
+export * from './EngineHook';
+export * from './NativeCapture';
+export * from './FontFace';

package/index.js

@@ -0,0 +1,5 @@
+export * from './EngineView';
+export * from './EngineHook';
+export * from './NativeCapture';
+export * from './FontFace';
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../Modules/@babylonjs/react-native/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC"}

package/ios/BabylonModule.mm

@@ -19,16 +19,15 @@ RCT_EXPORT_MODULE();
 @synthesize bridge = _bridge;
 
 RCT_EXPORT_METHOD(initialize:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    [BabylonNativeInterop whenInitialized:self.bridge resolve:resolve];
-}
-
-RCT_EXPORT_METHOD(whenInitialized:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    [BabylonNativeInterop whenInitialized:self.bridge resolve:resolve];
+    self.bridge.jsCallInvoker->invokeAsync([bridge{ self.bridge }, resolve]() {
+        [BabylonNativeInterop initialize:bridge];
+        resolve([NSNull null]);
+    });
 }
 
-RCT_EXPORT_METHOD(reset:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    self.bridge.jsCallInvoker->invokeAsync([resolve]() {
-        [BabylonNativeInterop reset];
+RCT_EXPORT_METHOD(resetView:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [BabylonNativeInterop resetView];
         resolve([NSNull null]);
     });
 }

package/ios/BabylonNativeInterop.h

@@ -4,8 +4,11 @@
 #import <React/RCTBridge.h>
 
 @interface BabylonNativeInterop : NSObject
-+ (void)setView:(RCTBridge*)bridge jsRunLoop:(NSRunLoop*)jsRunLoop mktView:(MTKView*)mtkView;
-+ (void)reportTouchEvent:(NSSet<UITouch*>*)touches withEvent:(UIEvent*)event;
-+ (void)whenInitialized:(RCTBridge*)bridge resolve:(RCTPromiseResolveBlock)resolve;
-+ (void)reset;
++ (void)initialize:(RCTBridge*)bridge;
++ (void)updateView:(MTKView*)mtkView;
++ (void)renderView;
++ (void)resetView;
++ (void)updateXRView:(MTKView*)mtkView;
++ (bool)isXRActive;
++ (void)reportTouchEvent:(MTKView*)mtkView touches:(NSSet<UITouch*>*)touches event:(UIEvent*)event;
 @end