@granite-js/micro-frontend 2.0.0

package/android/src/main/cpp/BundleEvaluator.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+namespace granite::microfrontend {
+
+struct BundleEvaluator : facebook::jni::HybridClass<BundleEvaluator> {
+  static constexpr auto kJavaDescriptor =
+      "Lrun/granite/microfrontend/BundleEvaluator;";
+
+  static void registerNatives();
+
+  static void evaluateFileSync(
+      facebook::jni::alias_ref<jhybridobject>,
+      jlong runtimePointer,
+      facebook::jni::alias_ref<facebook::jni::JString> filePath,
+      facebook::jni::alias_ref<facebook::jni::JString> sourceUrl);
+};
+
+} // namespace granite::microfrontend

package/android/src/main/cpp/FileReader.cpp

@@ -0,0 +1,92 @@
+#include "FileReader.h"
+
+#include <cerrno>
+#include <cstring>
+#include <fcntl.h>
+#include <new>
+#include <sys/stat.h>
+#include <unistd.h>
+
+namespace granite::microfrontend::io {
+namespace {
+
+class FileDescriptor final {
+public:
+  explicit FileDescriptor(int value) : value_(value) {}
+  ~FileDescriptor() { close(value_); }
+
+  FileDescriptor(const FileDescriptor &) = delete;
+  FileDescriptor &operator=(const FileDescriptor &) = delete;
+
+  int get() const { return value_; }
+
+private:
+  int value_;
+};
+
+std::string errorMessage(const std::string &message, const std::string &path,
+                         int errorNumber) {
+  return message + ": " + path + " (" + std::strerror(errorNumber) + ")";
+}
+
+}
+
+FileReaderError::FileReaderError(FileReaderErrorKind kind,
+                                 const std::string &message)
+    : std::runtime_error(message), kind_(kind) {}
+
+FileReaderErrorKind FileReaderError::kind() const { return kind_; }
+
+std::string readFileToMemory(const std::string &path) {
+  std::string source;
+
+  {
+    const int fileDescriptor = open(path.c_str(), O_RDONLY);
+    if (fileDescriptor < 0) {
+      const int errorNumber = errno;
+      throw FileReaderError(
+          FileReaderErrorKind::NotFound,
+          errorMessage("Bundle file cannot be opened", path, errorNumber));
+    }
+    FileDescriptor file(fileDescriptor);
+
+    struct stat fileStat {};
+    if (fstat(file.get(), &fileStat) < 0) {
+      const int errorNumber = errno;
+      throw FileReaderError(
+          FileReaderErrorKind::StatFailed,
+          errorMessage("Bundle file cannot be inspected", path, errorNumber));
+    }
+
+    try {
+      source.resize(static_cast<size_t>(fileStat.st_size));
+    } catch (const std::bad_alloc &) {
+      throw FileReaderError(FileReaderErrorKind::AllocationFailed,
+                            "Bundle file cannot fit in memory: " + path);
+    }
+
+    size_t offset = 0;
+    while (offset < source.size()) {
+      const ssize_t bytesRead =
+          read(file.get(), source.data() + offset, source.size() - offset);
+      if (bytesRead < 0) {
+        if (errno == EINTR) {
+          continue;
+        }
+        const int errorNumber = errno;
+        throw FileReaderError(
+            FileReaderErrorKind::ReadFailed,
+            errorMessage("Bundle file cannot be read", path, errorNumber));
+      }
+      if (bytesRead == 0) {
+        source.resize(offset);
+        break;
+      }
+      offset += static_cast<size_t>(bytesRead);
+    }
+  }
+
+  return source;
+}
+
+}

package/android/src/main/cpp/FileReader.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace granite::microfrontend::io {
+
+enum class FileReaderErrorKind {
+  NotFound,
+  StatFailed,
+  AllocationFailed,
+  ReadFailed,
+};
+
+class FileReaderError : public std::runtime_error {
+public:
+  FileReaderError(FileReaderErrorKind kind, const std::string &message);
+
+  FileReaderErrorKind kind() const;
+
+private:
+  FileReaderErrorKind kind_;
+};
+
+std::string readFileToMemory(const std::string &path);
+
+}

package/android/src/main/cpp/onLoad.cpp

@@ -0,0 +1,9 @@
+#include "BundleEvaluator.h"
+
+#include <fbjni/fbjni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    granite::microfrontend::BundleEvaluator::registerNatives();
+  });
+}

package/android/src/main/java/com/teleport/extensions/Float.kt

@@ -0,0 +1,12 @@
+package com.teleport.extensions
+
+import android.content.res.Resources
+
+internal val Float.dp: Double
+  get() = (this / displayDensity).toDouble()
+
+internal val Float.px: Double
+  get() = (this * displayDensity).toDouble()
+
+private val displayDensity: Float
+  get() = Resources.getSystem().displayMetrics.density

package/android/src/main/java/com/teleport/extensions/View.kt

@@ -0,0 +1,10 @@
+package com.teleport.extensions
+
+import android.view.View
+
+internal fun View.screenLocation(): IntArray =
+  IntArray(2).also {
+    getLocationOnScreen(it)
+  }
+
+internal fun View.isDetached(): Boolean = !isAttachedToWindow

package/android/src/main/java/com/teleport/global/PortalRegistry.kt

@@ -0,0 +1,117 @@
+package com.teleport.global
+
+import android.view.View
+import com.facebook.react.bridge.UiThreadUtil
+import com.teleport.host.PortalHostView
+import com.teleport.portal.PortalView
+import java.lang.ref.WeakReference
+
+/**
+ * Matches source [PortalView] instances with destination [PortalHostView] instances by name.
+ *
+ * The registry is confined to the Android UI thread because it stores and invokes [View]
+ * instances. Callers must not access it from background threads.
+ */
+object PortalRegistry {
+  private val hosts: MutableMap<String, MutableList<WeakReference<PortalHostView>>> = HashMap()
+  private val pendingPortals: MutableMap<String, MutableList<WeakReference<PortalView>>> = HashMap()
+
+  fun registerHost(
+    name: String,
+    view: PortalHostView,
+  ) {
+    UiThreadUtil.assertOnUiThread()
+    val namedHosts = hosts.getOrPut(name) { mutableListOf() }
+    namedHosts.removeAll { it.get() == null || it.get() === view }
+    namedHosts.add(WeakReference(view))
+    notifySubscribers(name)
+  }
+
+  fun unregisterHost(
+    name: String,
+    view: PortalHostView,
+  ) {
+    UiThreadUtil.assertOnUiThread()
+    hosts[name]?.let { namedHosts ->
+      namedHosts.removeAll { it.get() == null || it.get() === view }
+      if (namedHosts.isEmpty()) {
+        hosts.remove(name)
+      }
+    }
+    notifySubscribers(name)
+  }
+
+  private fun notifySubscribers(name: String) {
+    pendingPortals[name]?.let { portals ->
+      val iterator = portals.iterator()
+      while (iterator.hasNext()) {
+        val portalRef = iterator.next()
+        portalRef.get()?.onHostChanged() ?: iterator.remove()
+      }
+    }
+  }
+
+  fun notifyHostLayoutChanged(name: String) {
+    UiThreadUtil.assertOnUiThread()
+    pendingPortals[name]?.let { portals ->
+      val iterator = portals.iterator()
+      while (iterator.hasNext()) {
+        val portalRef = iterator.next()
+        portalRef.get()?.onHostLayoutChanged() ?: iterator.remove()
+      }
+    }
+  }
+
+  /**
+   * Prefer an attached destination in the source View's Window. If the source
+   * belongs to a detached controller surface, or no same-window destination
+   * exists, use the most recently registered attached host from another Window.
+   */
+  fun resolveHost(
+    name: String?,
+    sourceView: View,
+  ): PortalHostView? {
+    UiThreadUtil.assertOnUiThread()
+    if (name == null) return null
+
+    val namedHosts = hosts[name] ?: return null
+    namedHosts.removeAll { it.get() == null }
+    if (namedHosts.isEmpty()) {
+      hosts.remove(name)
+      return null
+    }
+
+    val liveHosts = namedHosts.mapNotNull { it.get() }
+    val sourceWindowToken = sourceView.windowToken
+    if (sourceView.isAttachedToWindow && sourceWindowToken != null) {
+      liveHosts.lastOrNull {
+        it.isAttachedToWindow && it.windowToken == sourceWindowToken
+      }?.let { return it }
+    }
+
+    return liveHosts.lastOrNull { it.isAttachedToWindow }
+  }
+
+  fun registerPendingPortal(
+    hostName: String,
+    portal: PortalView,
+  ) {
+    UiThreadUtil.assertOnUiThread()
+    val portals = pendingPortals.getOrPut(hostName) { mutableListOf() }
+    portals.removeAll { it.get() == null || it.get() == portal }
+    portals.add(WeakReference(portal))
+  }
+
+  fun unregisterPendingPortal(
+    hostName: String,
+    portal: PortalView,
+  ) {
+    UiThreadUtil.assertOnUiThread()
+    pendingPortals[hostName]?.let { portals ->
+      portals.removeAll { it.get() == null || it.get() == portal }
+      if (portals.isEmpty()) {
+        pendingPortals.remove(hostName)
+      }
+    }
+  }
+}

package/android/src/main/java/com/teleport/host/PortalHostView.kt

@@ -0,0 +1,97 @@
+package com.teleport.host
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.views.view.ReactViewGroup
+import com.teleport.global.PortalRegistry
+
+/**
+ * Native-owned destination for children moved out of a [com.teleport.portal.PortalView].
+ *
+ * A named host registers while attached to a Window. The matching source view keeps React/Fabric
+ * ownership of its children and only reparents their Android views into this container.
+ */
+class PortalHostView(
+  context: Context?,
+) : ReactViewGroup(context) {
+  private var name: String? = null
+  private var isInBatch = false
+  private var batchBaseIndex = 0
+  private var hasPendingCleanup = false
+
+  fun setName(newName: String?) {
+    if (name == newName) return
+
+    hasPendingCleanup = false
+    name?.let { PortalRegistry.unregisterHost(it, this) }
+    name = newName
+    newName?.let { PortalRegistry.registerHost(it, this) }
+  }
+
+  fun cleanup() {
+    if (isAttachedToWindow) {
+      hasPendingCleanup = true
+      return
+    }
+
+    cleanupNow()
+  }
+
+  /**
+   * Returns the index at which a portal child should be inserted.
+   *
+   * Within a single Fabric commit all mutations run synchronously on the main
+   * thread.  The first call in a commit records the current child count as
+   * the "base"; subsequent calls in the same commit reuse that base so that
+   * bottom-to-top Fabric ordering is compensated by [addView] at a specific index.
+   * A [Handler.post] resets the flag after the commit finishes.
+   */
+  fun nextInsertionIndexForChildAt(childIndex: Int): Int {
+    if (!isInBatch) {
+      isInBatch = true
+      batchBaseIndex = childCount
+      Handler(Looper.getMainLooper()).post { isInBatch = false }
+    }
+    return minOf(batchBaseIndex + childIndex, childCount)
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    // A host can be named before its Activity installs it into the Window.
+    // Register again on attach so detached controller surfaces resolve the
+    // currently visible Activity host deterministically.
+    name?.let { PortalRegistry.registerHost(it, this) }
+  }
+
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int,
+  ) {
+    super.onLayout(changed, left, top, right, bottom)
+    name?.let { PortalRegistry.notifyHostLayoutChanged(it) }
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+
+    if (hasPendingCleanup) {
+      cleanupNow()
+    } else {
+      // Keep the name so a temporary detach can register again on attach, but
+      // stop routing children into a host that is no longer visible.
+      name?.let { PortalRegistry.unregisterHost(it, this) }
+    }
+  }
+
+  private fun cleanupNow() {
+    name?.let { PortalRegistry.unregisterHost(it, this) }
+    name = null
+    isInBatch = false
+    batchBaseIndex = 0
+    hasPendingCleanup = false
+  }
+}

package/android/src/main/java/com/teleport/host/PortalHostViewManager.kt

@@ -0,0 +1,41 @@
+package com.teleport.host
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.PortalHostViewManagerDelegate
+import com.facebook.react.viewmanagers.PortalHostViewManagerInterface
+import com.facebook.react.views.view.ReactViewGroup
+import com.teleport.managers.TeleportViewManager
+
+@ReactModule(name = PortalHostViewManager.NAME)
+class PortalHostViewManager :
+  TeleportViewManager(),
+  PortalHostViewManagerInterface<ReactViewGroup> {
+  private val delegate = PortalHostViewManagerDelegate(this)
+
+  override fun getName(): String = NAME
+
+  override fun getDelegate(): ViewManagerDelegate<ReactViewGroup> = delegate
+
+  override fun createTeleportView(context: ThemedReactContext): ReactViewGroup = PortalHostView(context)
+
+  override fun onDropViewInstance(view: ReactViewGroup) {
+    super.onDropViewInstance(view)
+
+    (view as? PortalHostView)?.cleanup()
+  }
+
+  @ReactProp(name = "name")
+  override fun setName(
+    view: ReactViewGroup?,
+    name: String?,
+  ) {
+    (view as? PortalHostView)?.setName(name)
+  }
+
+  companion object {
+    const val NAME = "PortalHostView"
+  }
+}

package/android/src/main/java/com/teleport/host/PortalReactRootView.kt

@@ -0,0 +1,116 @@
+package com.teleport.host
+
+import android.view.MotionEvent
+import android.view.View
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactRootView
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.config.ReactFeatureFlags
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.events.EventDispatcher
+
+class PortalReactRootView(
+  context: ThemedReactContext,
+  private val reactHost: ReactHost,
+  surfaceId: Int,
+  private val moduleName: String,
+) : ReactRootView(context) {
+  private val touchDispatcher = JSTouchDispatcher(this)
+  private val pointerDispatcher =
+      if (ReactFeatureFlags.dispatchPointerEvents) {
+        JSPointerDispatcher(this)
+      } else {
+        null
+      }
+
+  private val eventDispatcher: EventDispatcher?
+    get() =
+        reactHost.currentReactContext?.let {
+          UIManagerHelper.getEventDispatcher(it, UIManagerType.FABRIC)
+        }
+
+  init {
+    setIsFabric(true)
+    setRootViewTag(surfaceId)
+  }
+
+  override fun onMeasure(
+    widthMeasureSpec: Int,
+    heightMeasureSpec: Int,
+  ) {
+    super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+
+    val childWidthSpec = MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY)
+    val childHeightSpec = MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
+    for (index in 0 until childCount) {
+      getChildAt(index).measure(childWidthSpec, childHeightSpec)
+    }
+  }
+
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int,
+  ) {
+    for (index in 0 until childCount) {
+      getChildAt(index).layout(0, 0, right - left, bottom - top)
+    }
+  }
+
+  override fun onChildStartedNativeGesture(
+    childView: View?,
+    ev: MotionEvent,
+  ) {
+    val dispatcher = eventDispatcher ?: return
+    touchDispatcher.onChildStartedNativeGesture(ev, dispatcher)
+    childView?.let {
+      pointerDispatcher?.onChildStartedNativeGesture(it, ev, dispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(
+    childView: View,
+    ev: MotionEvent,
+  ) {
+    val dispatcher = eventDispatcher ?: return
+    touchDispatcher.onChildEndedNativeGesture(ev, dispatcher)
+    pointerDispatcher?.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    val exception = if (t is Exception) t else RuntimeException(t)
+    currentReactContext?.handleException(exception) ?: throw exception
+  }
+
+  override fun getUIManagerType(): Int = UIManagerType.FABRIC
+
+  override fun getJSModuleName(): String = moduleName
+
+  override fun dispatchJSTouchEvent(event: MotionEvent) {
+    val dispatcher = eventDispatcher ?: return
+    touchDispatcher.handleTouchEvent(event, dispatcher, currentReactContext)
+  }
+
+  override fun dispatchJSPointerEvent(
+    event: MotionEvent,
+    isCapture: Boolean,
+  ) {
+    val dispatcher = eventDispatcher ?: return
+    pointerDispatcher?.handleMotionEvent(event, dispatcher, isCapture)
+  }
+
+  override fun hasActiveReactContext(): Boolean =
+      currentReactContext?.hasActiveReactInstance() == true
+
+  override fun hasActiveReactInstance(): Boolean = hasActiveReactContext()
+
+  override fun getCurrentReactContext(): ReactContext? = reactHost.currentReactContext
+
+  override fun isViewAttachedToReactInstance(): Boolean = hasActiveReactContext()
+}

package/android/src/main/java/com/teleport/managers/TeleportViewManager.kt

@@ -0,0 +1,27 @@
+package com.teleport.managers
+
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.view.ReactViewManager
+
+abstract class TeleportViewManager : ReactViewManager() {
+  protected abstract fun createTeleportView(context: ThemedReactContext): ReactViewGroup
+
+  fun forceBoxNone(view: ReactViewGroup) {
+    super.setPointerEvents(view, "box-none")
+  }
+
+  override fun createViewInstance(context: ThemedReactContext): ReactViewGroup =
+    createTeleportView(context).also {
+      forceBoxNone(it)
+    }
+
+  override fun prepareToRecycleView(
+    reactContext: ThemedReactContext,
+    view: ReactViewGroup,
+  ): ReactViewGroup {
+    super.prepareToRecycleView(reactContext, view)
+    forceBoxNone(view)
+    return view
+  }
+}

package/android/src/main/java/com/teleport/portal/PortalLayoutStateController.kt

@@ -0,0 +1,107 @@
+package com.teleport.portal
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.StateWrapper
+import com.teleport.extensions.dp
+import com.teleport.extensions.isDetached
+import com.teleport.extensions.screenLocation
+import com.teleport.host.PortalHostView
+
+internal class PortalLayoutStateController(
+  private val sourceView: View,
+) {
+  private var lastLayout = PortalLayoutState.EMPTY
+  private var stateWrapper: StateWrapper? = null
+
+  fun setStateWrapper(wrapper: StateWrapper?) {
+    stateWrapper = wrapper
+  }
+
+  fun updateIfNeeded(
+    hostName: String?,
+    host: PortalHostView?,
+  ) {
+    val wrapper = stateWrapper
+    val activeHost = activeHost(hostName, host)
+
+    when {
+      wrapper == null -> Unit
+      activeHost == null -> resetIfNeeded()
+      else -> publishIfChanged(wrapper, createLayoutState(activeHost))
+    }
+  }
+
+  fun resetIfNeeded() {
+    val wrapper = stateWrapper
+
+    if (wrapper != null) {
+      publishIfChanged(wrapper, PortalLayoutState.EMPTY)
+    }
+  }
+
+  private fun activeHost(
+    hostName: String?,
+    host: PortalHostView?,
+  ): PortalHostView? =
+    if (hostName == null || host == null || host.isDetached()) {
+      null
+    } else {
+      host
+    }
+
+  private fun publishIfChanged(
+    wrapper: StateWrapper,
+    nextLayout: PortalLayoutState,
+  ) {
+    if (lastLayout != nextLayout) {
+      lastLayout = nextLayout
+      wrapper.updateState(nextLayout.toMap())
+    }
+  }
+
+  private fun createLayoutState(host: PortalHostView): PortalLayoutState {
+    val hostLocation = host.screenLocation()
+    // A detached controller surface has no Window coordinate space. Its children
+    // are already physically parented by the destination host, so use the host
+    // origin as the logical source origin and avoid applying a screen inset twice.
+    val sourceLocation =
+      if (sourceView.isDetached()) {
+        hostLocation
+      } else {
+        sourceView.screenLocation()
+      }
+
+    return PortalLayoutState(
+      hostWidth = host.width.toFloat().dp,
+      hostHeight = host.height.toFloat().dp,
+      offsetX = (hostLocation[0] - sourceLocation[0]).toFloat().dp,
+      offsetY = (hostLocation[1] - sourceLocation[1]).toFloat().dp,
+    )
+  }
+}
+
+private data class PortalLayoutState(
+  val hostWidth: Double,
+  val hostHeight: Double,
+  val offsetX: Double,
+  val offsetY: Double,
+) {
+  fun toMap() =
+    Arguments.createMap().apply {
+      putDouble("hostWidth", hostWidth)
+      putDouble("hostHeight", hostHeight)
+      putDouble("offsetX", offsetX)
+      putDouble("offsetY", offsetY)
+    }
+
+  companion object {
+    val EMPTY =
+      PortalLayoutState(
+        hostWidth = 0.0,
+        hostHeight = 0.0,
+        offsetX = 0.0,
+        offsetY = 0.0,
+      )
+  }
+}