@nayan-ui/engine 0.0.0-stage → 1.0.0-beta.3

package/native/android/src/main/java/com/nayanui/engine/EngineSurfaceView.java

@@ -0,0 +1,234 @@
+package com.nayanui.engine;
+
+import android.content.Context;
+import java.nio.charset.StandardCharsets;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import android.graphics.SurfaceTexture;
+import android.view.Surface;
+import android.view.MotionEvent;
+import android.view.ScaleGestureDetector;
+import android.view.Choreographer;
+import android.view.TextureView;
+
+/**
+ * A surface the Rust renderer draws into (Vulkan, or OpenGL ES when Vulkan isn't usable). A
+ * TextureView keeps the last frame in the view tree during navigation's removal animation, even
+ * after React stops rendering. JS refers to it by `surfaceId`.
+ */
+public class EngineSurfaceView extends TextureView implements TextureView.SurfaceTextureListener, Choreographer.FrameCallback {
+  private int surfaceId = -1;
+  private Surface surface;
+  private int width;
+  private int height;
+  private int drawingId = -1;
+  private int drawingMode;
+  private int drawingBackground = 0xffffff;
+  private boolean drawingTick;
+  private long lastDrawingEvent;
+  private int drawingPointer = -1;
+  private boolean pencil;
+  private float lastX, lastY;
+  private final float density;
+  private final ScaleGestureDetector scaleDetector;
+
+  public EngineSurfaceView(Context context) {
+    super(context);
+    setSurfaceTextureListener(this);
+    density = context.getResources().getDisplayMetrics().density;
+    scaleDetector = new ScaleGestureDetector(context, new ScaleGestureDetector.SimpleOnScaleGestureListener() {
+      @Override public boolean onScale(ScaleGestureDetector detector) {
+        nativeDrawingTransform(drawingId, 0, 0, detector.getScaleFactor());
+        return true;
+      }
+    });
+  }
+
+  public void setSurfaceId(int id) {
+    if (id == surfaceId) {
+      return;
+    }
+    if (surfaceId >= 0) {
+      nativeDetach(surfaceId);
+    }
+    surfaceId = id;
+    attach();
+  }
+
+  /**
+   * Stops the renderer, but leaves the texture visible until navigation removes the view. Hiding it
+   * here would replace the game's last frame with an empty screen during the exit animation.
+   */
+  public void release() {
+    stopDrawing();
+    drawingId = -1;
+    if (surfaceId >= 0) {
+      nativeDetach(surfaceId);
+      surfaceId = -1;
+    }
+    releaseSurface();
+  }
+
+  private void attach() {
+    if (surfaceId >= 0 && surface != null && surface.isValid() && width > 0 && height > 0) {
+      nativeAttach(surfaceId, surface, width, height);
+      if (drawingId >= 0) nativeDrawingInvalidate(drawingId);
+      startDrawing();
+    }
+  }
+
+  @Override
+  public void onSurfaceTextureAvailable(SurfaceTexture texture, int w, int h) {
+    surface = new Surface(texture);
+    width = w;
+    height = h;
+    attach();
+  }
+
+  @Override
+  public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int w, int h) {
+    width = w;
+    height = h;
+    attach();
+  }
+
+  @Override
+  public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
+    stopDrawing();
+    // Wait for the renderer before Android destroys the texture. Keep the id so a screen covered by
+    // another route can attach a new surface when it comes back from the back stack.
+    if (surfaceId >= 0) {
+      nativeDetach(surfaceId);
+    }
+    releaseSurface();
+    return true;
+  }
+
+  @Override
+  public void onSurfaceTextureUpdated(SurfaceTexture texture) {}
+
+  private void releaseSurface() {
+    if (surface != null) {
+      surface.release();
+      surface = null;
+    }
+  }
+
+  public void setDrawingId(int id) {
+    stopDrawing();
+    drawingId = id;
+    if (id >= 0) nativeDrawingInvalidate(id);
+    startDrawing();
+  }
+  public void setDrawingMode(int mode) {
+    if (drawingPointer >= 0) nativeDrawingTouch(drawingId, 3, 0, 0, 1);
+    drawingPointer = -1;
+    drawingMode = mode;
+  }
+  public void setDrawingBackground(int color) {
+    drawingBackground = color;
+    if (drawingId >= 0) nativeDrawingInvalidate(drawingId);
+  }
+  private void startDrawing() {
+    if (!drawingTick && drawingId >= 0 && surface != null && isShown() && hasWindowFocus()) {
+      drawingTick = true;
+      Choreographer.getInstance().postFrameCallback(this);
+    }
+  }
+  private void stopDrawing() {
+    drawingTick = false;
+    Choreographer.getInstance().removeFrameCallback(this);
+    if (drawingPointer >= 0) nativeDrawingTouch(drawingId, 2, lastX, lastY, 1);
+    drawingPointer = -1;
+  }
+  @Override public void doFrame(long frameTimeNanos) {
+    if (!drawingTick || drawingId < 0 || surface == null) return;
+    nativeDrawingPresent(drawingId, surfaceId, width / density, height / density, drawingBackground);
+    if (frameTimeNanos - lastDrawingEvent >= 100_000_000L && getContext() instanceof ReactContext) {
+      lastDrawingEvent = frameTimeNanos;
+      byte[] data = nativeDrawingEvent(drawingId);
+      if (data != null) {
+        String state = new String(data, StandardCharsets.UTF_8);
+        ReactContext context = (ReactContext)getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, getId());
+        if (dispatcher != null) dispatcher.dispatchEvent(new DrawingChangeEvent(UIManagerHelper.getSurfaceId(context), getId(), drawingId, state));
+      }
+    }
+    Choreographer.getInstance().postFrameCallback(this);
+  }
+  private static final class DrawingChangeEvent extends Event<DrawingChangeEvent> {
+    private final String state;
+    private final int document;
+    DrawingChangeEvent(int surface, int view, int document, String state) { super(surface, view); this.document = document; this.state = state; }
+    @Override public String getEventName() { return "topDrawingChange"; }
+    @Override public boolean canCoalesce() { return true; }
+    @Override protected WritableMap getEventData() { WritableMap data = Arguments.createMap(); data.putString("state", state); data.putInt("documentId", document); return data; }
+  }
+  @Override public void onWindowFocusChanged(boolean focused) {
+    super.onWindowFocusChanged(focused);
+    if (focused) startDrawing(); else stopDrawing();
+  }
+  @Override protected void onDetachedFromWindow() {
+    stopDrawing();
+    super.onDetachedFromWindow();
+  }
+  @Override protected void onWindowVisibilityChanged(int visibility) {
+    super.onWindowVisibilityChanged(visibility);
+    if (visibility == VISIBLE) startDrawing(); else stopDrawing();
+  }
+  @Override public boolean onTouchEvent(MotionEvent event) {
+    if (drawingId < 0) return super.onTouchEvent(event);
+    getParent().requestDisallowInterceptTouchEvent(true);
+    int action = event.getActionMasked();
+    if (action == MotionEvent.ACTION_DOWN) {
+      drawingPointer = -1;
+      lastX = event.getX() / density;
+      lastY = event.getY() / density;
+      pencil = event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS || event.getToolType(0) == MotionEvent.TOOL_TYPE_ERASER;
+      if (drawingMode == 0) {
+        drawingPointer = event.getPointerId(0);
+        nativeDrawingTouch(drawingId, event.getToolType(0) == MotionEvent.TOOL_TYPE_ERASER ? 4 : 0, lastX, lastY, pencil ? event.getPressure() : 1);
+      }
+    }
+    if (!pencil) scaleDetector.onTouchEvent(event);
+    if (action == MotionEvent.ACTION_POINTER_DOWN && !pencil) {
+      if (drawingPointer >= 0) nativeDrawingTouch(drawingId, 3, 0, 0, 1);
+      drawingPointer = -1;
+      lastX = event.getX() / density;
+      lastY = event.getY() / density;
+    }
+    if (action == MotionEvent.ACTION_MOVE) {
+      int index = drawingPointer < 0 ? -1 : event.findPointerIndex(drawingPointer);
+      if (index >= 0) {
+        for (int h = 0; h < event.getHistorySize(); h++) nativeDrawingTouch(drawingId, 1, event.getHistoricalX(index, h) / density, event.getHistoricalY(index, h) / density, pencil ? event.getHistoricalPressure(index, h) : 1);
+        lastX = event.getX(index) / density;
+        lastY = event.getY(index) / density;
+        nativeDrawingTouch(drawingId, 1, lastX, lastY, pencil ? event.getPressure(index) : 1);
+      } else if (drawingMode != 0 || event.getPointerCount() > 1) {
+        float x = event.getX() / density, y = event.getY() / density;
+        if (!scaleDetector.isInProgress()) nativeDrawingTransform(drawingId, x - lastX, y - lastY, 1);
+        lastX = x;
+        lastY = y;
+      }
+    }
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL || (action == MotionEvent.ACTION_POINTER_UP && event.getPointerId(event.getActionIndex()) == drawingPointer)) {
+      if (drawingPointer >= 0) nativeDrawingTouch(drawingId, action == MotionEvent.ACTION_CANCEL ? 3 : 2, lastX, lastY, 1);
+      drawingPointer = -1;
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) { pencil = false; getParent().requestDisallowInterceptTouchEvent(false); }
+    }
+    return true;
+  }
+  private static native void nativeDrawingPresent(int drawing, int surface, float width, float height, int color);
+  private static native void nativeDrawingTouch(int drawing, int phase, float x, float y, float pressure);
+  private static native void nativeDrawingTransform(int drawing, float dx, float dy, float scale);
+  private static native byte[] nativeDrawingEvent(int drawing);
+  private static native void nativeDrawingInvalidate(int drawing);
+
+  private static native boolean nativeAttach(int surfaceId, Surface surface, int width, int height);
+
+  private static native void nativeDetach(int surfaceId);
+}

package/native/android/src/main/java/com/nayanui/engine/EngineSurfaceViewManager.java

@@ -0,0 +1,45 @@
+package com.nayanui.engine;
+
+import androidx.annotation.NonNull;
+import java.util.Map;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+public class EngineSurfaceViewManager extends SimpleViewManager<EngineSurfaceView> {
+  @NonNull
+  @Override
+  public String getName() {
+    return "NayanEngineSurface";
+  }
+
+  @NonNull
+  @Override
+  protected EngineSurfaceView createViewInstance(@NonNull ThemedReactContext context) {
+    return new EngineSurfaceView(context);
+  }
+
+  // React unmounted the screen; stop rendering while its last texture finishes the exit animation.
+  @Override
+  public void onDropViewInstance(@NonNull EngineSurfaceView view) {
+    view.release();
+    super.onDropViewInstance(view);
+  }
+
+  @Override
+  public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+    return MapBuilder.of("topDrawingChange", MapBuilder.of("registrationName", "onDrawingChange"));
+  }
+
+  @ReactProp(name = "surfaceId", defaultInt = -1)
+  public void setSurfaceId(EngineSurfaceView view, int surfaceId) {
+    view.setSurfaceId(surfaceId);
+  }
+  @ReactProp(name = "drawingId", defaultInt = -1)
+  public void setDrawingId(EngineSurfaceView view, int id) { view.setDrawingId(id); }
+  @ReactProp(name = "drawingMode", defaultInt = 0)
+  public void setDrawingMode(EngineSurfaceView view, int mode) { view.setDrawingMode(mode); }
+  @ReactProp(name = "drawingBackground", defaultInt = 0xffffff)
+  public void setDrawingBackground(EngineSurfaceView view, int color) { view.setDrawingBackground(color); }
+}

package/native/android/src/main/java/com/nayanui/engine/NayanEnginePackage.java

@@ -0,0 +1,24 @@
+package com.nayanui.engine;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Collections;
+import java.util.List;
+
+/** Registers the EngineSurface view (the native module is a C++ TurboModule, registered separately). */
+public class NayanEnginePackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext context) {
+    return Collections.emptyList();
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext context) {
+    return Collections.singletonList(new EngineSurfaceViewManager());
+  }
+}

package/native/core/build/EngineCore.xcframework/Info.plist

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libengine_core.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libengine_core.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libengine_core.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64-simulator</string>
+			<key>LibraryPath</key>
+			<string>libengine_core.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/native/core/include/drawing-licenses.txt

@@ -0,0 +1,58 @@
+Drawing renderer dependencies
+=============================
+
+raqote 0.8.5
+https://github.com/jrmuizel/raqote
+
+Copyright (c) 2019 Jeff Muizelaar
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+svgtypes 0.16.1 (MIT option)
+https://github.com/linebender/svgtypes
+
+Copyright (c) 2018 Yevhenii Reizner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+