@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/lucent/platform/android_activity.cpp

@@ -0,0 +1,258 @@
+// Lucent runtime — Android: the app's Activities for Lucent code (the
+// current one, activity results, permissions, lifecycle events), through
+// dev.lucent.LucentActivities. Built only into Android apps.
+#ifdef __ANDROID__
+
+#include <array>
+#include <cstdint>
+#include <map>
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "android.h"
+#include "android_requests.h"
+
+namespace lucent::jni {
+
+namespace {
+
+/// Lifecycle events, numbered as LucentActivities numbers them.
+constexpr std::array<const char*, 7> kEvents = {"created", "started", "resumed", "paused", "stopped", "destroyed", "newIntent"};
+
+jclass activities();
+
+void forgetOnPlatform(OperationId id) {
+  JNIEnv* e = env();
+  static jmethodID forget = staticMethod(activities(), "forget", "(J)V");
+
+  e->CallStaticVoidMethod(activities(), forget, static_cast<jlong>(id));
+  check(e);
+}
+
+Requests<NativeRef>& results() {
+  static auto* requests = new Requests<NativeRef>(forgetOnPlatform);
+  return *requests;
+}
+
+Requests<Array<bool>>& permissionRequests() {
+  static auto* requests = new Requests<Array<bool>>(forgetOnPlatform);
+  return *requests;
+}
+
+/// What each permission request asked for, to answer in its order.
+std::mutex askedMutex;
+std::map<OperationId, Array<String>>& asked() {
+  static auto* m = new std::map<OperationId, Array<String>>();
+  return *m;
+}
+
+struct Subscription {
+  size_t event;
+  ActivityHandler handler;
+  /// Where the handler runs: the context that subscribed.
+  ContextRef context;
+};
+
+std::mutex subscriptionsMutex;
+std::map<uint64_t, Subscription>& subscriptions() {
+  static auto* m = new std::map<uint64_t, Subscription>();
+  return *m;
+}
+
+/// Runs a native method's body; a Lucent error is reported, never thrown into Java.
+template <class F>
+void guarded(const char* what, F f) {
+  try {
+    f();
+  } catch (...) {
+    reportUncaught(std::current_exception(), what);
+  }
+}
+
+void JNICALL onResult(JNIEnv* e, jclass, jlong id, jint resultCode, jobject data) {
+  guarded("activity result", [&] {
+    LocalFrame frame(e);
+    jclass cls = findClass("android/app/Instrumentation$ActivityResult");
+    static jmethodID init = method(cls, "<init>", "(ILandroid/content/Intent;)V");
+
+    NativeRef result = wrap(e, e->NewObject(cls, init, resultCode, data), "Instrumentation.ActivityResult");
+    results().deliver(static_cast<OperationId>(id), std::move(result));
+  });
+}
+
+void JNICALL onPermissions(JNIEnv* e, jclass, jlong id, jobjectArray permissions, jintArray grants) {
+  guarded("permission result", [&] {
+    Array<String> requested;
+    {
+      std::lock_guard<std::mutex> g(askedMutex);
+      auto it = asked().find(static_cast<OperationId>(id));
+      if (it == asked().end()) return;
+
+      requested = it->second;
+      asked().erase(it);
+    }
+
+    // A dismissed dialog answers with nothing: none granted.
+    std::map<std::u16string, bool> granted;
+    if (permissions && grants) {
+      Array<String> names = fromStringArray(e, permissions, "permissions");
+      Array<double> codes = fromIntArray(e, grants, "grants");
+
+      for (size_t i = 0; i < names.size() && i < codes.size(); i++)
+        granted[names.at(i).toUtf16()] = codes.at(i) == 0;  // PackageManager.PERMISSION_GRANTED
+    }
+
+    Array<bool> answer;
+    for (size_t i = 0; i < requested.size(); i++) {
+      auto it = granted.find(requested.at(i).toUtf16());
+      answer.push(it != granted.end() && it->second);
+    }
+
+    permissionRequests().deliver(static_cast<OperationId>(id), std::move(answer));
+  });
+}
+
+void JNICALL onFailed(JNIEnv* e, jclass, jlong id, jstring code, jstring message) {
+  guarded("activity request", [&] {
+    Error error = makeError(fromJString(e, message, "message"));
+    error->code = fromJString(e, code, "code");
+    auto op = static_cast<OperationId>(id);
+
+    if (!results().fail(op, error)) permissionRequests().fail(op, error);
+
+    std::lock_guard<std::mutex> g(askedMutex);
+    asked().erase(op);
+  });
+}
+
+void JNICALL onEvent(JNIEnv* e, jclass, jint kind, jobject activity, jobject intent) {
+  guarded("activity event", [&] {
+    std::vector<Subscription> matching;
+    {
+      std::lock_guard<std::mutex> g(subscriptionsMutex);
+      for (const auto& [id, s] : subscriptions())
+        if (s.event == static_cast<size_t>(kind)) matching.push_back(s);
+    }
+
+    if (matching.empty()) return;
+
+    // Global references, released on whatever thread drops the last one.
+    NativeRef a = wrap(e, e->NewLocalRef(activity), "Activity");
+    Opt<NativeRef> i = wrapOpt(e, intent ? e->NewLocalRef(intent) : nullptr);
+
+    // A turn of the subscribing context (the legacy module context's holds the Lucent lock).
+    for (auto& s : matching)
+      ExecutionContext::of(s.context).post([handler = s.handler, a, i] {
+        try {
+          handler(a, i);
+        } catch (...) {
+          reportUncaught(std::current_exception(), "activity event handler");
+        }
+      });
+  });
+}
+
+jclass activities() {
+  static jclass cls = [] {
+    JNIEnv* e = env();
+    jclass c = findClass("dev/lucent/LucentActivities");
+    JNINativeMethod natives[] = {
+        {const_cast<char*>("onResult"), const_cast<char*>("(JILandroid/content/Intent;)V"), reinterpret_cast<void*>(onResult)},
+        {const_cast<char*>("onPermissions"), const_cast<char*>("(J[Ljava/lang/String;[I)V"), reinterpret_cast<void*>(onPermissions)},
+        {const_cast<char*>("onFailed"), const_cast<char*>("(JLjava/lang/String;Ljava/lang/String;)V"), reinterpret_cast<void*>(onFailed)},
+        {const_cast<char*>("onEvent"), const_cast<char*>("(ILandroid/app/Activity;Landroid/content/Intent;)V"), reinterpret_cast<void*>(onEvent)},
+    };
+    e->RegisterNatives(c, natives, 4);
+    check(e);
+    return c;
+  }();
+  return cls;
+}
+
+/// The scope a request belongs to: the calling context's root.
+std::shared_ptr<Scope> requestScope() {
+  ExecutionContext* context = ExecutionContext::current();
+  return (context ? *context : ExecutionContext::legacy()).root();
+}
+
+}  // namespace
+
+Opt<NativeRef> currentActivity() {
+  JNIEnv* e = env();
+  static jmethodID current = staticMethod(activities(), "current", "()Landroid/app/Activity;");
+
+  jobject a = e->CallStaticObjectMethod(activities(), current);
+  check(e);
+  return wrapOpt(e, a);
+}
+
+Promise<NativeRef> startActivityForResult(const NativeRef& intent, Opt<AbortSignal> signal) {
+  return results().start(requestScope(), std::move(signal), [&](OperationId id) {
+    JNIEnv* e = env();
+    static jmethodID start = staticMethod(activities(), "startForResult", "(JLandroid/content/Intent;)V");
+
+    e->CallStaticVoidMethod(activities(), start, static_cast<jlong>(id), unwrap(intent));
+    check(e);
+  });
+}
+
+Promise<Array<bool>> requestPermissions(const Array<String>& permissions, Opt<AbortSignal> signal) {
+  return permissionRequests().start(requestScope(), std::move(signal), [&](OperationId id) {
+    {
+      std::lock_guard<std::mutex> g(askedMutex);
+      asked()[id] = permissions;
+    }
+
+    JNIEnv* e = env();
+    LocalFrame frame(e);
+    static jmethodID request = staticMethod(activities(), "requestPermissions", "(J[Ljava/lang/String;)V");
+
+    e->CallStaticVoidMethod(activities(), request, static_cast<jlong>(id), toStringArray(e, permissions));
+    check(e);
+  });
+}
+
+Fn<void()> onActivityEvent(const String& event, ActivityHandler handler) {
+  std::string name = event.toUtf8();
+  size_t kind = 0;
+  while (kind < kEvents.size() && name != kEvents[kind]) kind++;
+  if (kind == kEvents.size()) throwTypeError(("Unknown Activity event: " + name).c_str());
+
+  static std::atomic<uint64_t> next{1};
+  uint64_t id = next++;
+
+  bool first;
+  {
+    std::lock_guard<std::mutex> g(subscriptionsMutex);
+    first = subscriptions().empty();
+    subscriptions().emplace(id, Subscription{kind, std::move(handler), ExecutionContext::currentRef()});
+  }
+
+  JNIEnv* e = env();
+  static jmethodID listen = staticMethod(activities(), "listen", "(Z)V");
+  if (first) {
+    e->CallStaticVoidMethod(activities(), listen, JNI_TRUE);
+    check(e);
+  }
+
+  return Fn<void()>([id] {
+    bool last;
+    {
+      std::lock_guard<std::mutex> g(subscriptionsMutex);
+      if (!subscriptions().erase(id)) return;
+      last = subscriptions().empty();
+    }
+
+    if (last) {
+      JNIEnv* env_ = env();
+      env_->CallStaticVoidMethod(activities(), listen, JNI_FALSE);
+      check(env_);
+    }
+  });
+}
+
+}  // namespace lucent::jni
+
+#endif  // __ANDROID__

package/runtime/cpp/lucent/platform/android_requests.h

@@ -0,0 +1,140 @@
+// Lucent runtime — requests Android answers later: an activity result, a
+// permission request. Each is an Operation under a scope, keyed by its id,
+// which the platform side echoes back with the answer.
+//
+// The answer may come from any thread (Android's main thread): it settles
+// the promise on the context that asked. A request cancelled first (its
+// signal aborted, its scope disposed) is forgotten on the platform side,
+// which drops the answer if it still comes: cancelling does not close a
+// dialog the platform already shows. No JNI here, so the host tests run it.
+#pragma once
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <utility>
+
+#include "../abort.h"
+#include "../async.h"
+#include "../execution.h"
+#include "../scope.h"
+
+namespace lucent::jni {
+
+template <class T>
+class Requests {
+ public:
+  /// Tells the platform side to forget a request (cancelled before its answer).
+  using Forget = std::function<void(OperationId)>;
+  /// Sends a request to the platform side, under its id.
+  using Launch = std::function<void(OperationId)>;
+
+  explicit Requests(Forget forget) : forget_(std::move(forget)) {}
+
+  Requests(const Requests&) = delete;
+  Requests& operator=(const Requests&) = delete;
+
+  /// Starts a request under `scope` and returns its promise, settled on the
+  /// calling context. An aborted `signal` (now or later) or a disposed scope
+  /// cancels it with an AbortError; `launch` throwing rejects it.
+  Promise<T> start(const std::shared_ptr<Scope>& scope, Opt<AbortSignal> signal, const Launch& launch) {
+    Promise<T> promise;
+    AbortSignal aborts = signal.has() ? signal.get() : nullptr;
+
+    Opt<Error> abortedBy;
+    if (aborts && aborts->aborted.load()) abortedBy = aborts->reason;
+
+    auto op = Operation<T>::start(
+        scope,
+        [&](const std::shared_ptr<Operation<T>>& started) -> std::function<void()> {
+          OperationId id = started->token().operation;
+
+          {
+            std::lock_guard<std::mutex> g(m_);
+            pending_.emplace(id, started);
+          }
+
+          launch(id);
+
+          uint64_t listener = 0;
+          if (aborts) {
+            std::weak_ptr<Operation<T>> weak = started;
+            std::weak_ptr<AbortSignalObject> from = aborts;
+            listener = aborts->add([weak, from] {
+              auto op = weak.lock();
+              auto signal = from.lock();
+              if (op && signal) op->cancel(signal->reason);
+            });
+          }
+
+          // After the outcome: unlisten, and forget a request the platform did not answer.
+          std::weak_ptr<Operation<T>> weak = started;
+          return [this, id, aborts, listener, weak] {
+            if (aborts && listener) aborts->remove(listener);
+
+            bool answered;
+            {
+              std::lock_guard<std::mutex> g(m_);
+              answered = pending_.erase(id) == 0;
+            }
+
+            auto op = weak.lock();
+            if (!answered && op && op->state() == OperationState::Cancelled) forget_(id);
+          };
+        },
+        abortedBy);
+
+    // A launch that threw failed the operation; it never reached the platform.
+    if (op->state() != OperationState::Pending) {
+      std::lock_guard<std::mutex> g(m_);
+      pending_.erase(op->token().operation);
+    }
+
+    op->onSettled([promise](const typename Operation<T>::Outcome& outcome) {
+      if (outcome.state == OperationState::Succeeded) {
+        promise.resolve(*outcome.value);
+      } else {
+        promise.reject(outcome.error);
+      }
+    });
+
+    return promise;
+  }
+
+  /// The platform's answer: true if it settled a pending request, false
+  /// for one already settled or cancelled (a late answer, dropped).
+  bool deliver(OperationId id, ::lucent::detail::Stored<T> value) {
+    auto op = take(id);
+    return op && op->succeed(std::move(value));
+  }
+
+  /// The platform could not answer (no Activity, say).
+  bool fail(OperationId id, Error error) {
+    auto op = take(id);
+    return op && op->fail(std::move(error));
+  }
+
+  /// Requests the platform has not answered.
+  size_t pending() const {
+    std::lock_guard<std::mutex> g(m_);
+    return pending_.size();
+  }
+
+ private:
+  std::shared_ptr<Operation<T>> take(OperationId id) {
+    std::lock_guard<std::mutex> g(m_);
+    auto it = pending_.find(id);
+    if (it == pending_.end()) return nullptr;
+
+    auto op = it->second.lock();
+    pending_.erase(it);
+    return op;
+  }
+
+  const Forget forget_;
+  mutable std::mutex m_;
+  std::map<OperationId, std::weak_ptr<Operation<T>>> pending_;
+};
+
+}  // namespace lucent::jni

package/runtime/cpp/lucent/platform/compose.h

@@ -0,0 +1,256 @@
+// Lucent runtime — a component's Compose content (lucent:compose), for the
+// generated glue of *.android.lucent.tsx components.
+//
+// The content's body is generated Kotlin: a composable reading a state
+// holder (`<registration>State`), and a host object (`<registration>Host`)
+// that gives it to the runtime's host of Compose content
+// (dev.lucent.compose.LucentComposition), which makes the ComposeView
+// showing it with the context of the view hosting the mount. The
+// component's setup, in C++, writes the holder: an effect per value the
+// body reads (a prop, a signal, a value computed by setup code) sets its
+// Compose state, and each setup function the body calls (an action) is a
+// Kotlin function object whose calls enter the main context. Everything
+// here runs on the main thread, in the main context.
+#pragma once
+
+#include <jni.h>
+
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "../array.h"
+#include "../execution.h"
+#include "../function.h"
+#include "../items.h"
+#include "android.h"
+
+namespace lucent::compose {
+
+namespace detail {
+
+/// The runtime's host of Compose content (runtime/native/android/src/compose), and how a host object makes one.
+constexpr const char* kComposition = "dev/lucent/compose/LucentComposition";
+constexpr const char* kCreate = "(Landroid/content/Context;Ljava/lang/Object;)Ldev/lucent/compose/LucentComposition;";
+
+inline jobject box(JNIEnv* e, double v) { return jni::boxDouble(e, v); }
+inline jobject box(JNIEnv* e, bool v) { return jni::boxBoolean(e, v); }
+inline jobject box(JNIEnv* e, const String& v) { return jni::toJString(e, v); }
+
+template <class T>
+jobject box(JNIEnv* e, const Opt<T>& v) {
+  return v.has() ? box(e, v.get()) : nullptr;
+}
+
+/// A Kotlin function's argument (boxed), as the Lucent function takes it.
+template <class T>
+struct Unbox;
+
+template <>
+struct Unbox<double> {
+  static double from(JNIEnv* e, jobject o) { return jni::unboxNumber(e, o); }
+};
+
+template <>
+struct Unbox<bool> {
+  static bool from(JNIEnv* e, jobject o) { return jni::unboxBoolean(e, o); }
+};
+
+template <>
+struct Unbox<String> {
+  static String from(JNIEnv* e, jobject o) { return jni::fromJString(e, static_cast<jstring>(o), "a Compose argument"); }
+};
+
+template <class T>
+struct Unbox<Opt<T>> {
+  static Opt<T> from(JNIEnv* e, jobject o) { return o ? Opt<T>(Unbox<T>::from(e, o)) : Opt<T>(null); }
+};
+
+/// `invoke(Ljava/lang/Object;…)`: how NativeProxy keys a FunctionN's method.
+template <size_t N>
+const char* invokeKey() {
+  static const std::string key = [] {
+    std::string k = "invoke(";
+    for (size_t i = 0; i < N; i++) k += "Ljava/lang/Object;";
+    return k + ")";
+  }();
+  return key.c_str();
+}
+
+}  // namespace detail
+
+// --- plain data, encoded for the Kotlin side (emit/toolkit-values.ts) -----------------------
+//
+// Each returns a local reference; the Holder's setters free them.
+
+inline jobject value(double v) { return jni::boxDouble(jni::env(), v); }
+inline jobject value(bool v) { return jni::boxBoolean(jni::env(), v); }
+inline jobject value(const String& v) { return jni::toJString(jni::env(), v); }
+
+/// null when `v` is null or undefined, else `each` of its value.
+template <class T, class F>
+jobject optional(const Opt<T>& v, F each) {
+  return v.has() ? each(v.get()) : nullptr;
+}
+
+/// An Object[] of `each` of the elements.
+template <class T, class F>
+jobject array(const Array<T>& a, F each) {
+  return jni::toObjectArray(jni::env(), a, "java/lang/Object", each);
+}
+
+/// An object's fields, in order: an Object[] taking the references.
+inline jobject record(std::initializer_list<jobject> fields) {
+  JNIEnv* e = jni::env();
+  jobjectArray out = e->NewObjectArray(static_cast<jsize>(fields.size()), jni::findClass("java/lang/Object"), nullptr);
+  jsize i = 0;
+
+  for (jobject f : fields) {
+    e->SetObjectArrayElement(out, i++, f);
+    if (f) e->DeleteLocalRef(f);
+  }
+
+  return out;
+}
+
+/**
+ * One mount's content: its Kotlin state holder, and the ComposeView once
+ * made. Copies share it. Made, written and disposed on the main context.
+ */
+class Holder {
+ public:
+  /// A new holder of `stateClass`, shown by `hostClass` (JNI class names).
+  static Holder create(const char* stateClass, const char* hostClass) {
+    JNIEnv* e = jni::env();
+    jni::LocalFrame frame(e);
+    jclass cls = jni::findClass(stateClass);
+    jobject state = e->NewObject(cls, jni::method(cls, "<init>", "()V"));
+    jni::check(e);
+
+    Holder h;
+    jmethodID set = jni::method(cls, "set", "(ILjava/lang/Object;)V");
+    jmethodID setAction = jni::method(cls, "setAction", "(ILjava/lang/Object;)V");
+    jmethodID listSetter = jni::method(cls, "setList", "(ILjava/lang/Object;)V");
+    h.s_ = std::make_shared<Shared>(Shared{jni::wrap(e, state, stateClass), set, setAction, listSetter, {}, {}, hostClass});
+    return h;
+  }
+
+  /// Sets the Compose state `slot` holds: the body recomposes where it reads it.
+  template <class T>
+    requires(!std::is_invocable_v<T>)
+  void set(int slot, const T& value) const {
+    JNIEnv* e = jni::env();
+    jni::LocalFrame frame(e);
+    call(e, s_->set, slot, detail::box(e, value));
+  }
+
+  /// Sets it to what `encode` makes (a local reference, freed here): encoded plain data.
+  template <class F>
+    requires std::is_invocable_r_v<jobject, F>
+  void set(int slot, F encode) const {
+    JNIEnv* e = jni::env();
+    jni::LocalFrame frame(e);
+    call(e, s_->set, slot, encode());
+  }
+
+  /**
+   * Sets list `slot` to the records `encode` makes (a local reference,
+   * freed here): the body merges them into its items by key.
+   */
+  template <class F>
+  void setList(int slot, F encode) const {
+    JNIEnv* e = jni::env();
+    jni::LocalFrame frame(e);
+    call(e, s_->listSetter, slot, encode());
+  }
+
+  /**
+   * Gives the body `f` as the Kotlin function action `slot` holds (a
+   * kotlin.jvm.functions.FunctionN): a call from Compose (a click) runs it
+   * now, in the main context, and what it throws is reported.
+   */
+  template <class... A>
+  void setAction(int slot, Fn<void(A...)> f, const char* site) const {
+    JNIEnv* e = jni::env();
+    jni::LocalFrame frame(e);
+    std::string iface = "kotlin/jvm/functions/Function" + std::to_string(sizeof...(A));
+    const void* identity = f.identity();
+    jobject fn = jni::proxyFor(
+        e, iface.c_str(), identity,
+        {{detail::invokeKey<sizeof...(A)>(),
+          [f = std::move(f)](JNIEnv* env, jobjectArray args) -> jobject {
+            callNowIn(ExecutionContext::main(), [&] { invoke(env, f, args, std::index_sequence_for<A...>{}); });
+            return nullptr;
+          }}},
+        site);
+    call(e, s_->setAction, slot, fn);
+  }
+
+  /**
+   * The ComposeView showing the content, made once, with the context of
+   * the view hosting the mount: setup calls it (the value of compose()).
+   */
+  NativeRef content() const {
+    if (s_->view) return s_->view;
+
+    auto context = jni::hostContext();
+
+    if (!context.has())
+      throwError(String::fromLatin1("Error"), String::fromLatin1("compose() runs only in a component's setup"));
+
+    JNIEnv* e = jni::env();
+    jni::LocalFrame frame(e);
+    jclass host = jni::findClass(s_->host);
+    jmethodID create = jni::staticMethod(host, "create", detail::kCreate);
+    jobject composition = e->CallStaticObjectMethod(host, create, jni::unwrap(context), jni::unwrap(s_->state));
+    jni::check(e);
+
+    static jmethodID getView =
+        jni::method(jni::findClass(detail::kComposition), "getView", "()Landroid/view/View;");
+    jobject view = e->CallObjectMethod(composition, getView);
+    jni::check(e);
+
+    s_->composition = jni::wrap(e, composition, "the host of a component's Compose content");
+    s_->view = jni::wrap(e, view, "a ComposeView");
+    return s_->view;
+  }
+
+  /// The mount went: its composition ends, or never starts; the view is not shown again.
+  void dispose() const {
+    if (!s_->composition) return;
+
+    JNIEnv* e = jni::env();
+    static jmethodID end = jni::method(jni::findClass(detail::kComposition), "dispose", "()V");
+
+    e->CallVoidMethod(jni::unwrap(s_->composition), end);
+    jni::check(e);
+  }
+
+ private:
+  struct Shared {
+    NativeRef state;
+    jmethodID set;
+    jmethodID setAction;
+    jmethodID listSetter;
+    /// Once made: the runtime's host of the content, and its view.
+    NativeRef composition;
+    NativeRef view;
+    const char* host;
+  };
+
+  std::shared_ptr<Shared> s_;
+
+  void call(JNIEnv* e, jmethodID setter, int slot, jobject value) const {
+    e->CallVoidMethod(jni::unwrap(s_->state), setter, static_cast<jint>(slot), value);
+    jni::check(e);
+  }
+
+  template <class... A, size_t... I>
+  static void invoke(JNIEnv* e, const Fn<void(A...)>& f, jobjectArray args, std::index_sequence<I...>) {
+    f(detail::Unbox<A>::from(e, jni::arg(e, args, static_cast<int>(I)))...);
+  }
+};
+
+}  // namespace lucent::compose