@lucent-lang/lucent 0.0.4 → 0.1.0

package/runtime/native/android/src/main/java/dev/lucent/LucentActivities.java

@@ -0,0 +1,292 @@
+// Generated by Lucent. Do not edit.
+package dev.lucent;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The app's Activities as Lucent code sees them: the current one, their
+ * lifecycle events, and requests for an activity result or a permission.
+ *
+ * Activities are held weakly: Lucent never keeps one alive. A request runs
+ * in its own translucent Activity (LucentRequestActivity), so it works
+ * whatever the app's Activity is, and survives the app's Activity being
+ * recreated while the request is out. Permission requests run one at a
+ * time, as Android requires. Everything here runs on the main thread except
+ * current(), which any thread may call.
+ */
+public final class LucentActivities implements Application.ActivityLifecycleCallbacks {
+  /** Lifecycle events, as native code numbers them. */
+  static final int CREATED = 0, STARTED = 1, RESUMED = 2, PAUSED = 3, STOPPED = 4, DESTROYED = 5, NEW_INTENT = 6;
+
+  /** Request kinds. */
+  static final int RESULT = 0, PERMISSIONS = 1;
+
+  private static final String TAG = "Lucent";
+  private static final Handler main = new Handler(Looper.getMainLooper());
+  private static volatile boolean installed;
+  private static volatile WeakReference<Activity> current = new WeakReference<>(null);
+  /** Whether native code listens to lifecycle events. */
+  private static volatile boolean listening;
+
+  /** Requests by id, and the request Activity of each while it runs. */
+  private static final Map<Long, Request> requests = new HashMap<>();
+  /** Permission requests waiting for the one in flight. */
+  private static final ArrayDeque<Request> waiting = new ArrayDeque<>();
+  private static Request askingPermissions;
+
+  static final class Request {
+    final long id;
+    final int kind;
+    final Intent intent;
+    final String[] permissions;
+    WeakReference<LucentRequestActivity> activity = new WeakReference<>(null);
+
+    Request(long id, int kind, Intent intent, String[] permissions) {
+      this.id = id;
+      this.kind = kind;
+      this.intent = intent;
+      this.permissions = permissions;
+    }
+  }
+
+  private LucentActivities() {}
+
+  /** Called once per process, before any Activity (LucentInitializer), or on first use. */
+  public static synchronized void install(Application app) {
+    if (installed) return;
+
+    app.registerActivityLifecycleCallbacks(new LucentActivities());
+    installed = true;
+  }
+
+  /** The Activity in front: the last one created, started or resumed and not destroyed. Null if none. */
+  public static Activity current() {
+    return current.get();
+  }
+
+  public static void listen(boolean on) {
+    listening = on;
+  }
+
+  // --- requests, from native code -------------------------------------------------
+
+  public static void startForResult(long id, Intent intent) {
+    main.post(() -> launch(new Request(id, RESULT, intent, null)));
+  }
+
+  public static void requestPermissions(long id, String[] permissions) {
+    main.post(() -> {
+      Request r = new Request(id, PERMISSIONS, null, permissions);
+
+      if (askingPermissions != null) {
+        waiting.add(r);
+        return;
+      }
+
+      askingPermissions = r;
+      launch(r);
+    });
+  }
+
+  /**
+   * Forgets a request: its answer, if it still comes, is dropped. Closes
+   * the Activity it started when Android lets the app (not a dialog of
+   * another app or of the system).
+   */
+  public static void forget(long id) {
+    main.post(() -> {
+      Request r = requests.remove(id);
+      if (r == null) {
+        waiting.removeIf(w -> w.id == id);
+        return;
+      }
+
+      Log.d(TAG, "request " + id + " forgotten: a later answer is dropped");
+
+      LucentRequestActivity a = r.activity.get();
+      if (a != null) a.abandon();
+
+      next(r);
+    });
+  }
+
+  private static void launch(Request r) {
+    Activity from = current.get();
+
+    if (from == null || from.isFinishing() || from.isDestroyed()) {
+      onFailed(r.id, "ERR_NO_ACTIVITY", "There is no Activity in front to ask from");
+      next(r);
+      return;
+    }
+
+    requests.put(r.id, r);
+    Log.d(TAG, "request " + r.id + " started from " + from.getLocalClassName());
+    from.startActivity(LucentRequestActivity.intent(from, r.id));
+  }
+
+  /** The request Activity for `id` was created: the request, unless it was forgotten meanwhile. */
+  static Request attach(long id, LucentRequestActivity activity) {
+    Request r = requests.get(id);
+    if (r != null) r.activity = new WeakReference<>(activity);
+    return r;
+  }
+
+  static void answered(Request r, int resultCode, Intent data) {
+    if (!settle(r, "result " + resultCode)) return;
+
+    onResult(r.id, resultCode, data);
+    next(r);
+  }
+
+  static void answered(Request r, String[] permissions, int[] grants) {
+    if (!settle(r, grants.length + " permission answers")) return;
+
+    onPermissions(r.id, permissions, grants);
+    next(r);
+  }
+
+  /** The request could not be made, or its Activity finished without an answer. */
+  static void failed(Request r, String code, String message) {
+    if (!settle(r, code)) return;
+
+    onFailed(r.id, code, message);
+    next(r);
+  }
+
+  /** Takes `r` for its answer: false, and the answer dropped, if it was forgotten meanwhile. */
+  private static boolean settle(Request r, String answer) {
+    if (requests.remove(r.id) == null) {
+      Log.d(TAG, "request " + r.id + ": dropped a late answer (" + answer + ")");
+      return false;
+    }
+
+    Log.d(TAG, "request " + r.id + " answered: " + answer);
+    return true;
+  }
+
+  /** After a permission request, the next one. */
+  private static void next(Request done) {
+    if (done != askingPermissions) return;
+
+    askingPermissions = waiting.poll();
+    if (askingPermissions != null) launch(askingPermissions);
+  }
+
+  // --- the lifecycle -------------------------------------------------------------
+
+  private static boolean tracked(Activity a) {
+    // The request Activity is Lucent's own: it is never "the current Activity".
+    return !(a instanceof LucentRequestActivity);
+  }
+
+  private static void event(int kind, Activity a, Intent intent) {
+    if (listening) onEvent(kind, a, intent);
+  }
+
+  @Override
+  public void onActivityCreated(Activity a, Bundle saved) {
+    if (!tracked(a)) return;
+
+    current = new WeakReference<>(a);
+    newIntents(a);
+    event(CREATED, a, null);
+  }
+
+  @Override
+  public void onActivityStarted(Activity a) {
+    if (!tracked(a)) return;
+
+    current = new WeakReference<>(a);
+    event(STARTED, a, null);
+  }
+
+  @Override
+  public void onActivityResumed(Activity a) {
+    if (!tracked(a)) return;
+
+    current = new WeakReference<>(a);
+    event(RESUMED, a, null);
+  }
+
+  @Override
+  public void onActivityPaused(Activity a) {
+    if (tracked(a)) event(PAUSED, a, null);
+  }
+
+  @Override
+  public void onActivityStopped(Activity a) {
+    if (tracked(a)) event(STOPPED, a, null);
+  }
+
+  @Override
+  public void onActivitySaveInstanceState(Activity a, Bundle out) {}
+
+  @Override
+  public void onActivityDestroyed(Activity a) {
+    if (!tracked(a)) return;
+
+    if (current.get() == a) current = new WeakReference<>(null);
+    event(DESTROYED, a, null);
+  }
+
+  /**
+   * New intents reach an Activity in onNewIntent, which no callback reports:
+   * AndroidX activities (ComponentActivity, React Native's) take listeners,
+   * found by name so that Lucent's Java needs no AndroidX.
+   */
+  private static void newIntents(Activity a) {
+    Method add;
+    Class<?> consumer;
+    try {
+      consumer = Class.forName("androidx.core.util.Consumer", false, a.getClassLoader());
+      add = a.getClass().getMethod("addOnNewIntentListener", consumer);
+    } catch (ReflectiveOperationException e) {
+      return;
+    }
+
+    WeakReference<Activity> held = new WeakReference<>(a);
+    InvocationHandler onIntent = (proxy, m, args) -> {
+      switch (m.getName()) {
+        case "accept":
+          Activity at = held.get();
+          if (at != null) event(NEW_INTENT, at, (Intent) args[0]);
+          return null;
+        case "equals":
+          return proxy == args[0];
+        case "hashCode":
+          return System.identityHashCode(proxy);
+        default:
+          return "Lucent new intent listener";
+      }
+    };
+
+    try {
+      add.invoke(a, Proxy.newProxyInstance(a.getClassLoader(), new Class<?>[] {consumer}, onIntent));
+    } catch (ReflectiveOperationException e) {
+      // No listener: new intents go unreported for this Activity.
+    }
+  }
+
+  // --- to native code ------------------------------------------------------------
+
+  private static native void onResult(long id, int resultCode, Intent data);
+
+  private static native void onPermissions(long id, String[] permissions, int[] grants);
+
+  private static native void onFailed(long id, String code, String message);
+
+  private static native void onEvent(int kind, Activity activity, Intent intent);
+}

package/runtime/native/android/src/main/java/dev/lucent/LucentChildren.java

@@ -0,0 +1,174 @@
+// Generated by Lucent. Do not edit.
+package dev.lucent;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * One host view's React children, in React Native's order, and the slot of
+ * its current mount (lucent:ui's `slot`). Main thread.
+ *
+ * <p>Who owns what: React Native owns each child (it creates, updates, lays
+ * out and destroys it, and says where it goes: added or removed at an index
+ * of the component's children). The host owns the slot and the children's
+ * place in it: it makes a slot for each mount of a component taking
+ * children, puts every child React Native adds in it in React Native's
+ * order, takes out the ones React Native removes, and does nothing else to
+ * them. The setup owns the slot's place in the view it returns.
+ *
+ * <p>Plain Java over {@link Slots}, so its rules run anywhere: the shell
+ * ({@link LucentHostView}) gives it Android's views.
+ *
+ * @param <V> a view
+ * @param <S> a slot
+ */
+final class LucentChildren<V, S> {
+  /** What the host does to its views and slots. */
+  interface Slots<V, S> {
+    /** A new, empty slot. */
+    S make();
+
+    /** The slot `child` is in (the current mount's or an earlier one's), or null. */
+    S slotOf(V child);
+
+    /** Whether `child` is in any view. */
+    boolean hasParent(V child);
+
+    /** Puts `child` in `slot` just below `next`, a child already in it, or above every child without one. */
+    void insert(S slot, V child, V next);
+
+    /** Takes `child` out of `slot`. */
+    void remove(S slot, V child);
+
+    /** Whether `slot` is in `content`, or is it. */
+    boolean within(S slot, V content);
+  }
+
+  private final Slots<V, S> slots;
+  private final String name;
+  private final boolean takesChildren;
+  private final Consumer<String> report;
+  private final List<V> children = new ArrayList<>();
+  private S slot;
+  /** Whether children given to a component taking none were reported. */
+  private boolean refused;
+
+  /**
+   * The children of a view of the component registered as `name`, which takes React children if
+   * `takesChildren`; what goes wrong goes to `report`.
+   */
+  LucentChildren(Slots<V, S> slots, String name, boolean takesChildren, Consumer<String> report) {
+    this.slots = slots;
+    this.name = name;
+    this.takesChildren = takesChildren;
+    this.report = report;
+  }
+
+  /** The current mount's slot, or null (no mount, or no children taken). */
+  S slot() {
+    return slot;
+  }
+
+  int count() {
+    return children.size();
+  }
+
+  /** React Native's child at `index`, or null. */
+  V childAt(int index) {
+    return index >= 0 && index < children.size() ? children.get(index) : null;
+  }
+
+  /** React Native adds `child` at `index` of the component's children. */
+  void add(V child, int index) {
+    int count = children.size();
+
+    if (index < 0 || index > count) {
+      report.accept("[lucent] " + name + ": React Native added a child at " + index + " of " + count);
+      index = index < 0 ? 0 : count;
+    }
+
+    children.add(index, child);
+
+    if (!takesChildren && !refused) {
+      refused = true;
+      report.accept(
+          "[lucent] "
+              + name
+              + " takes no React children: React Native gave it "
+              + children.size()
+              + ", which it does not show");
+    }
+
+    place(child);
+  }
+
+  /** React Native removes the child at `index` of the component's children. */
+  void remove(int index) {
+    if (index < 0 || index >= children.size()) {
+      report.accept("[lucent] " + name + ": React Native removed a child at " + index + " of " + children.size());
+      return;
+    }
+
+    V child = children.remove(index);
+    // Out of the slot it was put in (an earlier mount's, if React Native kept it past a recycle).
+    S in = slots.slotOf(child);
+
+    if (in != null) slots.remove(in, child);
+  }
+
+  /** A mount starts: a new slot holding every child, if the component takes them; the slot. */
+  S startMount() {
+    slot = takesChildren ? slots.make() : null;
+
+    for (V child : children) place(child);
+
+    return slot;
+  }
+
+  /** The mount's setup returned `content`: its slot should be in it. */
+  void mountedContent(V content) {
+    if (slot != null && content != null && !slots.within(slot, content))
+      report.accept(
+          "[lucent] "
+              + name
+              + "'s setup did not put its slot in the view it returned: its React children do not show");
+  }
+
+  /** The mount ends (the view is recycled): its slot goes. */
+  void endMount() {
+    // React Native removes a view's children before it recycles the view: any left stay where they are.
+    if (!children.isEmpty())
+      report.accept(
+          "[lucent] "
+              + name
+              + " was recycled holding "
+              + children.size()
+              + " React children: they stay where React Native left them");
+
+    children.clear();
+    slot = null;
+    refused = false;
+  }
+
+  /** Puts `child` in the slot, below the next child there: React Native's order. */
+  private void place(V child) {
+    if (slot == null || slots.slotOf(child) == slot) return;
+
+    if (slots.hasParent(child)) {
+      report.accept("[lucent] " + name + ": a React child is in another view: React Native keeps it there");
+      return;
+    }
+
+    for (int i = children.indexOf(child) + 1; i < children.size(); i++) {
+      V next = children.get(i);
+
+      if (slots.slotOf(next) == slot) {
+        slots.insert(slot, child, next);
+        return;
+      }
+    }
+
+    slots.insert(slot, child, null);
+  }
+}

package/runtime/native/android/src/main/java/dev/lucent/LucentHostView.java

@@ -0,0 +1,232 @@
+// Generated by Lucent. Do not edit.
+package dev.lucent;
+
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import com.facebook.react.modules.i18nmanager.I18nUtil;
+import java.util.Arrays;
+
+/**
+ * The view React Native mounts for a Lucent component: a shell holding the
+ * view the component's setup returns, filling its content box (Yoga's
+ * border and padding are the shell's padding). React Native lays the
+ * shell out; the shell lays its content out, which React Native's layout
+ * would not, and measures it for the C++ host when the shadow tree needs
+ * its size. The React children React Native adds to the shell (through its
+ * manager) never go in it: they go in the slot of a component taking them
+ * ({@link LucentChildren}), whose place the shell passes on to the C++
+ * host, for Yoga to lay them out in it.
+ */
+public final class LucentHostView extends FrameLayout {
+  /** The C++ host (LucentViews), 0 while none. */
+  long host;
+
+  /** React Native's children of the component, and the current mount's slot for them. */
+  final LucentChildren<View, LucentSlotView> children;
+
+  private boolean relayoutPosted;
+
+  /** The slot's place and the content box last passed on (pixels), and the direction: unchanged ones are not. */
+  private final int[] placed = new int[9];
+
+  private final Runnable relayout =
+      () -> {
+        relayoutPosted = false;
+        measure(
+            MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.EXACTLY));
+        layout(getLeft(), getTop(), getRight(), getBottom());
+
+        // The content may have changed size though no Lucent code ran (the
+        // host hears of that itself): measured if the shadow tree needs its size.
+        if (host != 0) LucentViews.contentChanged(host);
+      };
+
+  /** A shell for the component registered as `name`, which takes React children if `takesChildren`. */
+  public LucentHostView(Context context, String name, boolean takesChildren) {
+    super(context);
+    children = new LucentChildren<>(new Slots(context, this), name, takesChildren, LucentViews::report);
+
+    // What the content draws outside its box shows (a scaled Compose body),
+    // as a React Native view's children do by default.
+    setClipChildren(false);
+    setClipToPadding(false);
+  }
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+
+    if (host != 0) LucentViews.attach(host);
+  }
+
+  /** Shows `content`, the view the component's setup returned (the C++ host calls it). */
+  void setContent(View content) {
+    if (getChildCount() == 1 && getChildAt(0) == content) return;
+
+    removeAllViews();
+
+    if (content == null) return;
+
+    children.mountedContent(content);
+
+    if (content.getParent() instanceof ViewGroup) ((ViewGroup) content.getParent()).removeView(content);
+
+    addView(content, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+  }
+
+  /**
+   * A new slot for the React children of the mount starting, holding every
+   * child (the C++ host calls it), or null if the component takes none.
+   */
+  ViewGroup makeSlot() {
+    // The mount's C++ host has been told nothing yet.
+    Arrays.fill(placed, Integer.MIN_VALUE);
+
+    return children.startMount();
+  }
+
+  /**
+   * The content's size in density-independent pixels, up to `maxWidth` ×
+   * `maxHeight` (infinite: no bound), or null without content or while it
+   * is in no window. The C++ host calls it on the main thread.
+   */
+  float[] measureContent(float maxWidth, float maxHeight) {
+    if (getChildCount() != 1) return null;
+
+    View content = getChildAt(0);
+
+    // Out of a window, a view may not be able to measure what it shows (a
+    // ComposeView composes with its window's recomposer, and throws before
+    // it has one): the shell's next layout, once the content is attached,
+    // measures it (the relayout backstop).
+    if (!content.isAttachedToWindow()) {
+      requestLayout();
+      return null;
+    }
+
+    float density = density();
+
+    // A view caches its measurement by spec: a change that asked for no
+    // layout (a native one) would get the old size back, from the content
+    // or from any view inside it (a ComposeView's composition view).
+    forceLayoutTree(content);
+    content.measure(bound(maxWidth, density), bound(maxHeight, density));
+
+    float[] size = {content.getMeasuredWidth() / density, content.getMeasuredHeight() / density};
+
+    // Back to the size it is laid out at: the next layout pass may keep it.
+    content.measure(
+        MeasureSpec.makeMeasureSpec(content.getWidth(), MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(content.getHeight(), MeasureSpec.EXACTLY));
+
+    return size;
+  }
+
+  /**
+   * The slot is at `x`, `y` (`width` × `height`) in the shell, in pixels:
+   * passed on to the C++ host with the content box, unless nothing changed.
+   */
+  void placeSlot(int x, int y, int width, int height) {
+    boolean rtl = getLayoutDirection() == LAYOUT_DIRECTION_RTL;
+    int left = getPaddingLeft();
+    int top = getPaddingTop();
+    int[] now = {
+      x,
+      y,
+      width,
+      height,
+      left,
+      top,
+      getWidth() - left - getPaddingRight(),
+      getHeight() - top - getPaddingBottom(),
+      rtl ? 1 : 0
+    };
+
+    if (host == 0 || Arrays.equals(now, placed)) return;
+
+    System.arraycopy(now, 0, placed, 0, now.length);
+
+    // React Native's layout reads a right-to-left style's left and right as start and end if it swaps them.
+    boolean swapped = rtl && I18nUtil.getInstance().doLeftAndRightSwapInRTL(getContext());
+
+    LucentViews.slotPlaced(host, Arrays.copyOf(now, 8), rtl, swapped);
+  }
+
+  private static void forceLayoutTree(View view) {
+    view.forceLayout();
+
+    if (view instanceof ViewGroup) {
+      ViewGroup group = (ViewGroup) view;
+
+      for (int i = 0; i < group.getChildCount(); i++) forceLayoutTree(group.getChildAt(i));
+    }
+  }
+
+  /** Pixels per density-independent pixel: the scale layout rounds to. */
+  float density() {
+    return getResources().getDisplayMetrics().density;
+  }
+
+  private static int bound(float max, float density) {
+    return Float.isInfinite(max)
+        ? MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)
+        : MeasureSpec.makeMeasureSpec((int) Math.floor(max * density), MeasureSpec.AT_MOST);
+  }
+
+  @Override
+  public void requestLayout() {
+    super.requestLayout();
+
+    // Called while constructing, before the field is set.
+    if (relayout != null && !relayoutPosted) {
+      relayoutPosted = true;
+      post(relayout);
+    }
+  }
+
+  /** Android's views and slots, as LucentChildren handles them. */
+  private static final class Slots implements LucentChildren.Slots<View, LucentSlotView> {
+    private final Context context;
+    private final LucentHostView host;
+
+    Slots(Context context, LucentHostView host) {
+      this.context = context;
+      this.host = host;
+    }
+
+    @Override
+    public LucentSlotView make() {
+      return new LucentSlotView(context, host, host::placeSlot);
+    }
+
+    @Override
+    public LucentSlotView slotOf(View child) {
+      return child.getParent() instanceof LucentSlotView ? (LucentSlotView) child.getParent() : null;
+    }
+
+    @Override
+    public boolean hasParent(View child) {
+      return child.getParent() != null;
+    }
+
+    @Override
+    public void insert(LucentSlotView slot, View child, View next) {
+      slot.addView(child, next == null ? -1 : slot.indexOfChild(next));
+    }
+
+    @Override
+    public void remove(LucentSlotView slot, View child) {
+      slot.removeView(child);
+    }
+
+    @Override
+    public boolean within(LucentSlotView slot, View content) {
+      for (Object v = slot; v instanceof View; v = ((View) v).getParent()) if (v == content) return true;
+
+      return false;
+    }
+  }
+}