@gjsify/node-gi 0.59.0 → 0.60.0

package/src/android-gdk.cc

@@ -0,0 +1,291 @@
+// SPDX-License-Identifier: MIT
+// Android only: bring GDK's Android backend up without GTK's RuntimeApplication.
+//
+// GDK's Android backend is initialized by gdk_android_initialize(env, classloader,
+// context) — the only exported entry point into it; everything else it needs
+// (gdk_android_set_latest_activity in particular) is hidden. GTK ships one caller:
+// JNI_OnLoad in libgtk-4.so, which runs when something calls
+// System.loadLibrary("gtk-4") and which passes NULL for the context, plus
+// RuntimeApplication.startRuntime(), which passes the android.app.Application — and
+// also spawns GTK's own thread and dlopens an application library with a main().
+//
+// A JS host cannot use either. It is not the Application (NativeScript is), so
+// startRuntime is out; and the NULL context from JNI_OnLoad is not enough: gtk_init
+// calls Context.getSystemService() on it and the process dies with
+// "JNI DETECTED ERROR IN APPLICATION: can't call ... getSystemService ... on null
+// object". GIRepository's own dlopen of libgtk-4.so does not run JNI_OnLoad at all.
+//
+// So node-gi calls gdk_android_initialize itself, with the context the host names:
+// the same (Application, app classloader) pair startRuntime uses, and nothing else of
+// it. GTK's comment on that call — "This is *really* questionable, as thiz isn't
+// actually an activity. I've updated the code to handle this case" — is the upstream
+// licence for an Application here: it carries gtk_init over until a real
+// ToplevelActivity reports itself through GdkContext._set_latest_activity().
+//
+// Opt-in, never automatic: dlopening libgtk-4.so pulls in the whole GTK stack, and a
+// host that only wants GLib must not pay for it. See __NODE_GI_ANDROID_GDK in
+// host.nativescript.js.
+
+#include "common.h"
+
+#ifdef __ANDROID__
+
+#include <dlfcn.h>
+#include <jni.h>
+
+#include <mutex>
+#include <string>
+
+// Both set by JNI_OnLoad at the bottom of this file; file-static so both ends see them.
+// The bootstrap class name is the only thing that travels the other way: JNI_OnLoad needs
+// it to find the app's classloader, and only the host knows what the app called it.
+static JavaVM* g_vm = nullptr;
+static jobject g_app_loader = nullptr;
+static std::string g_bootstrap_class;
+
+namespace nodegi {
+
+namespace {
+
+// Describe-and-clear: the exception text is the whole diagnosis, and leaving it pending
+// turns the next JNI call into an abort.
+bool Failed(JNIEnv* env) {
+  if (env->ExceptionCheck() == JNI_FALSE) return false;
+  env->ExceptionDescribe();
+  env->ExceptionClear();
+  return true;
+}
+
+// App classes are invisible to FindClass from here: with no Java frame below the Node-API
+// call, ART resolves against the system classloader, which does not know com.tns.* — the
+// same reason a one-argument Class.forName() fails on this thread. Hence the loader
+// JNI_OnLoad cached, with the thread's context loader and plain FindClass behind it for a
+// host whose classes the system loader does have.
+jclass LoadAppClass(JNIEnv* env, const std::string& jni_name) {
+  std::string dotted = jni_name;
+  for (char& c : dotted)
+    if (c == '/') c = '.';
+
+  jobject loader = g_app_loader;
+  if (loader == nullptr) {
+    jclass thread_class = env->FindClass("java/lang/Thread");
+    jmethodID current =
+        env->GetStaticMethodID(thread_class, "currentThread", "()Ljava/lang/Thread;");
+    jobject thread = env->CallStaticObjectMethod(thread_class, current);
+    if (Failed(env) || thread == nullptr) return nullptr;
+    jmethodID get_loader = env->GetMethodID(thread_class, "getContextClassLoader",
+                                            "()Ljava/lang/ClassLoader;");
+    loader = env->CallObjectMethod(thread, get_loader);
+    if (Failed(env) || loader == nullptr)
+      return static_cast<jclass>(env->FindClass(jni_name.c_str()));
+  }
+
+  jclass loader_class = env->FindClass("java/lang/ClassLoader");
+  jmethodID load_class = env->GetMethodID(loader_class, "loadClass",
+                                          "(Ljava/lang/String;)Ljava/lang/Class;");
+  jstring name = env->NewStringUTF(dotted.c_str());
+  auto found = static_cast<jclass>(env->CallObjectMethod(loader, load_class, name));
+  if (Failed(env) || found == nullptr)
+    return static_cast<jclass>(env->FindClass(jni_name.c_str()));
+  return found;
+}
+
+// androidHasJavaVm() -> boolean
+//
+// Whether JNI_OnLoad has run, i.e. whether the addon has a JavaVM and the app's
+// classloader. Both arrive together and neither can be obtained any other way, so this
+// one answer covers both — the host asks before and after the bootstrap load.
+Napi::Value AndroidHasJavaVm(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), g_vm != nullptr);
+}
+
+// androidRegisterJniBootstrap(jniClassName) -> undefined
+//
+// Names the class the host is about to initialize to trigger JNI_OnLoad, in JNI form
+// ('dev/example/JniBootstrap'). JNI_OnLoad looks it up to reach the app's classloader:
+// during a load that ART performs, FindClass resolves against the classloader of the
+// class that called System.loadLibrary, which is the one moment app classes are visible
+// to this library. Must therefore be called BEFORE that load.
+Napi::Value AndroidRegisterJniBootstrap(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "androidRegisterJniBootstrap(jniClassName): a string is required")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  g_bootstrap_class = info[0].As<Napi::String>().Utf8Value();
+  return env.Undefined();
+}
+
+bool g_initialized = false;
+// Both JS threads of a NativeScript app share this library — the UI thread and a Worker,
+// and in the stage-5 spike both import node-gi — so the one-time guard needs a lock of its
+// own: gdk_android_initialize has none, and a second run leaks another set of global refs
+// and re-registers every native.
+std::mutex g_init_mutex;
+
+// androidInitGdk(contextClass, contextMethod, contextSignature) -> boolean
+//
+// contextClass/contextMethod name a static method returning the android.content.Context
+// to hand GDK, in JNI form — e.g. ('com/tns/NativeScriptApplication', 'getInstance',
+// '()Landroid/app/Application;'). The host names it because only the host knows how to
+// reach its Application without @hide APIs (android.app.ActivityThread is one).
+// Idempotent, per process rather than per thread — see g_init_mutex.
+Napi::Value AndroidInitGdk(const Napi::CallbackInfo& info) {
+  Napi::Env napi_env = info.Env();
+  std::lock_guard<std::mutex> guard(g_init_mutex);
+  if (g_initialized) return Napi::Boolean::New(napi_env, true);
+
+  if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
+    Napi::TypeError::New(napi_env,
+                         "androidInitGdk(contextClass, contextMethod, contextSignature): "
+                         "three strings in JNI form are required")
+        .ThrowAsJavaScriptException();
+    return napi_env.Undefined();
+  }
+  std::string class_name = info[0].As<Napi::String>().Utf8Value();
+  std::string method_name = info[1].As<Napi::String>().Utf8Value();
+  std::string signature = info[2].As<Napi::String>().Utf8Value();
+
+  if (g_vm == nullptr) {
+    Napi::Error::New(napi_env,
+                     "androidInitGdk: no JavaVM — this addon's JNI_OnLoad never ran. "
+                     "Initialize an app class that calls System.loadLibrary(\"node_gi\") "
+                     "first; a dlopen of the library does not run it.")
+        .ThrowAsJavaScriptException();
+    return napi_env.Undefined();
+  }
+
+  // A thread this call attaches has to be detached again: ART aborts a thread that exits
+  // while still attached ("Native thread exiting without having called
+  // DetachCurrentThread"). Safe because gdk_android_initialize keeps the JavaVM and global
+  // refs, never a JNIEnv, and GDK reattaches per call through its own thread-env guard.
+  JNIEnv* env = nullptr;
+  bool attached = false;
+  if (g_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+    if (g_vm->AttachCurrentThread(&env, nullptr) == JNI_OK)
+      attached = true;
+    else
+      env = nullptr;
+  }
+  if (env == nullptr) {
+    Napi::Error::New(napi_env, "androidInitGdk: could not attach this thread to the JavaVM")
+        .ThrowAsJavaScriptException();
+    return napi_env.Undefined();
+  }
+
+  // gdk_android_initialize keeps global refs to both arguments, so a local frame is
+  // enough and nothing here outlives it.
+  env->PushLocalFrame(16);
+  std::string error;
+  do {
+    jclass provider = LoadAppClass(env, class_name);
+    if (Failed(env) || provider == nullptr) {
+      error = "androidInitGdk: no class " + class_name + " on this thread's classloader";
+      break;
+    }
+    jmethodID getter = env->GetStaticMethodID(provider, method_name.c_str(), signature.c_str());
+    if (Failed(env) || getter == nullptr) {
+      error = "androidInitGdk: " + class_name + " has no static " + method_name + signature;
+      break;
+    }
+    jobject context = env->CallStaticObjectMethod(provider, getter);
+    if (Failed(env) || context == nullptr) {
+      error = "androidInitGdk: " + class_name + "." + method_name + "() returned no Context";
+      break;
+    }
+
+    // The classloader GDK resolves org.gtk.android.* with has to be the one that holds
+    // them: the loader of the app's own classes, which is the context's.
+    jclass class_class = env->FindClass("java/lang/Class");
+    jmethodID get_loader = env->GetMethodID(class_class, "getClassLoader",
+                                            "()Ljava/lang/ClassLoader;");
+    jobject loader = env->CallObjectMethod(env->GetObjectClass(context), get_loader);
+    if (Failed(env) || loader == nullptr) {
+      error = "androidInitGdk: the Context's class has no classloader";
+      break;
+    }
+
+    // RTLD_GLOBAL: the backend resolves GDK symbols out of this handle later, and
+    // GIRepository may have loaded libgtk-4.so locally already.
+    void* gtk = dlopen("libgtk-4.so", RTLD_NOW | RTLD_GLOBAL);
+    if (gtk == nullptr) {
+      error = std::string("androidInitGdk: dlopen(libgtk-4.so) failed: ") + dlerror();
+      break;
+    }
+    using InitFn = int (*)(JNIEnv*, jobject, jobject);
+    auto initialize = reinterpret_cast<InitFn>(dlsym(gtk, "gdk_android_initialize"));
+    if (initialize == nullptr) {
+      error = "androidInitGdk: libgtk-4.so exports no gdk_android_initialize "
+              "(GTK built without the Android backend?)";
+      break;
+    }
+    if (initialize(env, loader, context) == 0) {
+      error = "androidInitGdk: gdk_android_initialize() refused — see the GTK log";
+      break;
+    }
+    g_initialized = true;
+  } while (false);
+  env->PopLocalFrame(nullptr);
+  if (attached) g_vm->DetachCurrentThread();
+
+  if (!g_initialized) {
+    Napi::Error::New(napi_env, error).ThrowAsJavaScriptException();
+    return napi_env.Undefined();
+  }
+  return Napi::Boolean::New(napi_env, true);
+}
+
+}  // namespace
+
+void InitAndroidGdk(Napi::Env env, Napi::Object exports) {
+  exports.Set("androidHasJavaVm", Napi::Function::New(env, AndroidHasJavaVm));
+  exports.Set("androidRegisterJniBootstrap",
+              Napi::Function::New(env, AndroidRegisterJniBootstrap));
+  exports.Set("androidInitGdk", Napi::Function::New(env, AndroidInitGdk));
+}
+
+}  // namespace nodegi
+
+// Runs when ART loads this library on behalf of a class — not on the dlopen that the JS
+// runtime does. Two things are available here and nowhere else: the JavaVM, and a
+// FindClass that resolves against the app's classloader rather than the system one.
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* /*reserved*/) {
+  g_vm = vm;
+  if (g_bootstrap_class.empty()) return JNI_VERSION_1_6;
+
+  JNIEnv* env = nullptr;
+  if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK || env == nullptr)
+    return JNI_VERSION_1_6;
+
+  env->PushLocalFrame(4);
+  jclass bootstrap = env->FindClass(g_bootstrap_class.c_str());
+  if (!nodegi::Failed(env) && bootstrap != nullptr) {
+    jmethodID get_loader = env->GetMethodID(env->GetObjectClass(bootstrap), "getClassLoader",
+                                            "()Ljava/lang/ClassLoader;");
+    jobject loader = env->CallObjectMethod(bootstrap, get_loader);
+    if (!nodegi::Failed(env) && loader != nullptr) g_app_loader = env->NewGlobalRef(loader);
+  }
+  env->PopLocalFrame(nullptr);
+  return JNI_VERSION_1_6;
+}
+
+#else
+
+namespace nodegi {
+
+// Off Android there is no JavaVM and no Android GDK backend to initialize; the exports
+// stay so a host can ask without branching on the platform first.
+static Napi::Value AndroidFalse(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), false);
+}
+
+void InitAndroidGdk(Napi::Env env, Napi::Object exports) {
+  exports.Set("androidHasJavaVm", Napi::Function::New(env, AndroidFalse));
+  exports.Set("androidRegisterJniBootstrap", Napi::Function::New(env, AndroidFalse));
+  exports.Set("androidInitGdk", Napi::Function::New(env, AndroidFalse));
+}
+
+}  // namespace nodegi
+
+#endif

package/src/android-log.cc

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: MIT
+// Android only: route GLib's messages into logcat.
+//
+// On Android an app's stdout/stderr go to /dev/null unless something redirects them,
+// so GLib's default handlers — which write to stderr — lose every g_warning,
+// g_critical and g_message a GI call produces. The failure mode is the expensive one:
+// GTK reports precisely why it refused to start, and the report never leaves the
+// process. GTK's own Android runtime installs these four handlers in startRuntime()
+// (refs/gtk/gdk/android/gdkandroidruntime.c), but startRuntime also loads an
+// application library and spawns GTK's own thread, so a node-gi host must not call
+// it — this is the piece of it that a host still needs.
+//
+// Installed from Init, not on request: a host that has not asked for logging still
+// wants to be told why GI failed, and there is no other sink on this platform.
+// g_log_set_default_handler / g_log_set_writer_func are process-global and
+// last-call-wins, so a later logSetWriterFunc (private.cc) still overrides this.
+//
+// GLib is not the only writer: a foreign C library that does fprintf(stderr, ...) and
+// abort() (libepoxy's "eglQueryDisplayAttribEXT() not found" was the case) never reaches
+// a GLib handler. So fd 1 and fd 2 themselves are pointed at pipes that a reader thread
+// forwards to logcat line by line.
+
+#include "common.h"
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cstdio>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace nodegi {
+
+// Whether `fd` is the /dev/null an app process starts with. Anything else (a terminal
+// under `adb shell`, a file or pipe a host or the launcher set up) is a sink somebody
+// chose, and taking it over would hide output from them.
+static bool IsDevNull(int fd) {
+  struct stat fd_st, null_st;
+  return fstat(fd, &fd_st) == 0 && stat("/dev/null", &null_st) == 0 && S_ISCHR(fd_st.st_mode) &&
+         fd_st.st_rdev == null_st.st_rdev;
+}
+
+// Longest line forwarded whole; logcat truncates an entry near 4 KiB anyway, and a
+// writer that never sends '\n' must not grow the buffer without bound.
+static const size_t kMaxLine = 4000;
+
+struct StdioPipe {
+  int read_fd;
+  int priority;
+  const char* tag;
+};
+
+static void ForwardLoop(StdioPipe pipe_info) {
+  std::string line;
+  char buf[1024];
+  for (;;) {
+    ssize_t n = read(pipe_info.read_fd, buf, sizeof buf);
+    if (n < 0 && errno == EINTR) continue;
+    if (n <= 0) break;
+    for (ssize_t i = 0; i < n; i++) {
+      if (buf[i] == '\n') {
+        __android_log_write(pipe_info.priority, pipe_info.tag, line.c_str());
+        line.clear();
+      } else {
+        line.push_back(buf[i]);
+        if (line.size() >= kMaxLine) {
+          __android_log_write(pipe_info.priority, pipe_info.tag, line.c_str());
+          line.clear();
+        }
+      }
+    }
+  }
+  if (!line.empty()) __android_log_write(pipe_info.priority, pipe_info.tag, line.c_str());
+}
+
+static void RedirectFd(int fd, int priority, const char* tag) {
+  if (!IsDevNull(fd)) return;
+  int fds[2];
+  if (pipe2(fds, O_CLOEXEC) != 0) return;
+  if (dup2(fds[1], fd) < 0) {
+    close(fds[0]);
+    close(fds[1]);
+    return;
+  }
+  close(fds[1]);
+  // Two pipes rather than one: priority is per entry, and stderr must stay WARN so a
+  // logcat filter on `*:W` still shows it.
+  std::thread(ForwardLoop, StdioPipe{fds[0], priority, tag}).detach();
+}
+
+// Once per process: Init runs once per env, but fd 1/2 are process-wide.
+//
+// Limit: abort() ends the process, and the reader thread with it. stderr is made
+// unbuffered so the message at least reaches the pipe before the abort, but whether the
+// reader has forwarded it by then is a race the tombstone still backs up.
+static void InstallStdioRedirect() {
+  static std::once_flag once;
+  std::call_once(once, [] {
+    RedirectFd(STDOUT_FILENO, ANDROID_LOG_INFO, "stdout");
+    RedirectFd(STDERR_FILENO, ANDROID_LOG_WARN, "stderr");
+    setvbuf(stdout, nullptr, _IOLBF, 0);
+    setvbuf(stderr, nullptr, _IONBF, 0);
+  });
+}
+
+static void AndroidPrintHandler(const char* message) {
+  __android_log_print(ANDROID_LOG_INFO, "print", "%s", message);
+}
+
+static void AndroidPrinterrHandler(const char* message) {
+  __android_log_print(ANDROID_LOG_WARN, "print", "%s", message);
+}
+
+static int AndroidPriority(GLogLevelFlags log_level) {
+  if (log_level & G_LOG_LEVEL_ERROR) return ANDROID_LOG_FATAL;
+  if (log_level & G_LOG_LEVEL_CRITICAL) return ANDROID_LOG_ERROR;
+  if (log_level & G_LOG_LEVEL_WARNING) return ANDROID_LOG_WARN;
+  if (log_level & G_LOG_LEVEL_MESSAGE) return ANDROID_LOG_INFO;
+  if (log_level & G_LOG_LEVEL_INFO) return ANDROID_LOG_INFO;
+  if (log_level & G_LOG_LEVEL_DEBUG) return ANDROID_LOG_DEBUG;
+  return ANDROID_LOG_WARN;
+}
+
+static void AndroidLogHandler(const gchar* log_domain, GLogLevelFlags log_level,
+                              const gchar* message, gpointer) {
+  __android_log_print(AndroidPriority(log_level),
+                      log_domain != nullptr ? log_domain : "**", "%s", message);
+}
+
+static GLogWriterOutput AndroidLogWriter(GLogLevelFlags log_level, const GLogField* fields,
+                                         gsize n_fields, gpointer) {
+  const gchar* domain = nullptr;
+  const gchar* message = nullptr;
+  for (gsize i = 0; (domain == nullptr || message == nullptr) && i < n_fields; i++) {
+    if (g_strcmp0(fields[i].key, "GLIB_DOMAIN") == 0)
+      domain = static_cast<const gchar*>(fields[i].value);
+    else if (g_strcmp0(fields[i].key, "MESSAGE") == 0)
+      message = static_cast<const gchar*>(fields[i].value);
+  }
+  // liblog answers with the bytes it wrote, or a negative errno: anything above zero is
+  // a delivery. Reporting UNHANDLED on one sends GLib to its default writer, i.e. to the
+  // stderr this whole file exists because of.
+  int rc = __android_log_print(AndroidPriority(log_level),
+                               domain != nullptr ? domain : "**", "%s",
+                               message != nullptr ? message : "(empty)");
+  return rc > 0 ? G_LOG_WRITER_HANDLED : G_LOG_WRITER_UNHANDLED;
+}
+
+// androidLogBridge() -> boolean — whether GLib's messages reach logcat.
+static Napi::Value AndroidLogBridge(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), true);
+}
+
+void InitAndroidLog(Napi::Env env, Napi::Object exports) {
+  g_set_print_handler(AndroidPrintHandler);
+  g_set_printerr_handler(AndroidPrinterrHandler);
+  g_log_set_default_handler(AndroidLogHandler, nullptr);
+  g_log_set_writer_func(AndroidLogWriter, nullptr, nullptr);
+  InstallStdioRedirect();
+  exports.Set("androidLogBridge", Napi::Function::New(env, AndroidLogBridge));
+}
+
+}  // namespace nodegi
+
+#else
+
+namespace nodegi {
+
+static Napi::Value AndroidLogBridge(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(), false);
+}
+
+// Off Android stderr is a real sink and GLib's own handlers are the right ones; the
+// export stays so a caller can ask without branching on the platform first.
+void InitAndroidLog(Napi::Env env, Napi::Object exports) {
+  exports.Set("androidLogBridge", Napi::Function::New(env, AndroidLogBridge));
+}
+
+}  // namespace nodegi
+
+#endif

package/src/common.h

@@ -19,11 +19,28 @@
 #ifndef NODE_GI_SRC_COMMON_H_
 #define NODE_GI_SRC_COMMON_H_
 
+// NODE_GI_HAS_LIBUV — may this build REFERENCE libuv at all? Not "is there an
+// event loop": bionic resolves every symbol at dlopen, so a single
+// uv_timer_start left in the object file makes the whole addon fail to load on
+// Android, whatever the call site does at runtime. The Android host is
+// NativeScript's V8 runtime, a Node-API host with no libuv of its own
+// (napi_get_uv_event_loop always fails there), so the uv bridge in loop.cc is
+// compiled out and the ALooper pump beside it takes over.
+#ifndef NODE_GI_HAS_LIBUV
+#ifdef __ANDROID__
+#define NODE_GI_HAS_LIBUV 0
+#else
+#define NODE_GI_HAS_LIBUV 1
+#endif
+#endif
+
 #ifndef _WIN32
 #include <dlfcn.h>  // dlopen/dlsym the GtkWidgetClass template API (no GTK link)
 #endif
 #include <napi.h>
+#if NODE_GI_HAS_LIBUV
 #include <uv.h>
+#endif
 
 #include <girepository/girepository.h>
 #include <girepository/girffi.h>  // gi_callable_info_create_closure + ffi_cif
@@ -178,6 +195,12 @@ const ForeignStructOps* ForeignOpsForInfo(GIBaseInfo* iface);
 void InitCairo(Napi::Env env, Napi::Object exports);
 // win32: probeHostOpenGL / preloadOpenGL / currentGLStrings (opengl-win32.cc); a no-op elsewhere.
 void InitOpenGLWin32(Napi::Env env, Napi::Object exports);
+// Android: install GLib's print/log/writer handlers onto logcat (android-log.cc), where
+// stderr goes nowhere. Elsewhere only the `androidLogBridge` probe, answering false.
+void InitAndroidLog(Napi::Env env, Napi::Object exports);
+// Android: androidInitGdk(), the opt-in GDK bring-up that replaces GTK's
+// RuntimeApplication (android-gdk.cc). Elsewhere the export answers false.
+void InitAndroidGdk(Napi::Env env, Napi::Object exports);
 
 // ---- GJS-exact 64-bit integer marshalling helpers (shared) -------------------
 //