bare-ndk 0.1.0 → 0.1.1

package/CMakeLists.txt

@@ -1,27 +1,72 @@
 cmake_minimum_required(VERSION 4.0)
 
-set(ANDROID_STL c++_shared)
-
 find_package(cmake-bare REQUIRED PATHS node_modules/cmake-bare)
 find_package(cmake-fetch REQUIRED PATHS node_modules/cmake-fetch)
 
-project(bare_android C)
+project(bare_android C CXX)
 
 fetch_package("github:holepunchto/bare@1.24.5")
 fetch_package("github:holepunchto/libpath")
+fetch_package("github:holepunchto/libjstl")
+fetch_package("github:holepunchto/libjnitl")
+
+find_package(Java)
+
+include(UseJava)
+
+add_bare_module(bare_ndk)
+
+target_sources(
+  ${bare_ndk}
+  PRIVATE
+    binding.cc
+)
+
+target_link_libraries(
+  ${bare_ndk}
+  PUBLIC
+    jstl
+    jnitl
+    android
+)
+
+set(ANDROID_JAR ${ANDROID_HOME}/platforms/${ANDROID_PLATFORM}/android.jar)
+
+add_jar(
+  bare_runtime_classes
+  SOURCES
+    lib/runtime/Activity.java
+  INCLUDE_JARS
+    ${ANDROID_JAR}
+  OUTPUT_NAME classes
+)
+
+find_program(d8 d8 PATHS ${ANDROID_HOME}/build-tools/* NO_DEFAULT_PATH)
+
+add_custom_command(
+  TARGET bare_runtime_classes
+  POST_BUILD
+  COMMAND
+    ${d8}
+      $<IF:$<CONFIG:Debug>,--debug,--release>
+      --lib ${ANDROID_JAR}
+      --output ${CMAKE_BINARY_DIR}
+      ${CMAKE_BINARY_DIR}/classes.jar
+)
 
 add_library(bare_runtime SHARED)
 
 target_sources(
   bare_runtime
   PRIVATE
-    lib/runtime.c
+    lib/runtime.cc
 )
 
 set_target_properties(
   bare_runtime
   PROPERTIES
-  C_STANDARD 99
+  C_STANDARD 11
+  CXX_STANDARD 20
   POSITION_INDEPENDENT_CODE ON
   OUTPUT_NAME bare
 )
@@ -34,15 +79,11 @@ target_link_libraries(
     log_static
     rlimit_static
     path_static
-)
-
-target_link_libraries(
-  bare_runtime
   PRIVATE
+    jnitl
     android
 )
 
-
 target_link_options(
   bare_runtime
   PRIVATE
@@ -62,4 +103,9 @@ find_library(
 
 install(TARGETS bare_runtime LIBRARY DESTINATION ${target})
 
-install(FILES ${android_stl} DESTINATION ${target}/bare)
+install(
+  FILES
+    ${android_stl}
+    ${CMAKE_BINARY_DIR}/classes.dex
+  DESTINATION ${target}/bare
+)

package/README.md

@@ -1,6 +1,6 @@
 # bare-ndk
 
-Android NDK runtime for Bare.
+Android NDK bindings and runtime for Bare.
 
 ## License
 

package/binding.cc

@@ -0,0 +1,44 @@
+#include <assert.h>
+#include <bare.h>
+#include <js.h>
+#include <utf.h>
+
+#include "lib/activity.h"
+#include "lib/web-view.h"
+
+static js_value_t *
+bare_ndk_exports(js_env_t *env, js_value_t *exports) {
+  int err;
+
+#define V(name, fn) \
+  { \
+    js_value_t *val; \
+    err = js_create_function(env, name, -1, fn, nullptr, &val); \
+    assert(err == 0); \
+    err = js_set_named_property(env, exports, name, val); \
+    assert(err == 0); \
+  }
+
+  V("activityInit", bare_ndk_activity_init)
+  V("activityContentView", bare_ndk_activity_content_view)
+
+  V("webViewInit", bare_ndk_web_view_init)
+  V("webViewDebuggingEnabled", bare_ndk_web_view_debugging_enabled)
+  V("webViewLoadURL", bare_ndk_web_view_load_url)
+  V("webViewLoadData", bare_ndk_web_view_load_data)
+#undef V
+
+#define V(name, n) \
+  { \
+    js_value_t *val; \
+    err = js_create_int32(env, n, &val); \
+    assert(err == 0); \
+    err = js_set_named_property(env, exports, name, val); \
+    assert(err == 0); \
+  }
+#undef V
+
+  return exports;
+}
+
+BARE_MODULE(bare_ndk, bare_ndk_exports)

package/binding.js

@@ -0,0 +1 @@
+module.exports = require.addon()

package/index.js

@@ -0,0 +1,2 @@
+exports.Activity = require('./lib/activity')
+exports.WebView = require('./lib/web-view')

package/lib/activity.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <assert.h>
+#include <bare.h>
+#include <jnitl.h>
+#include <js.h>
+#include <jstl.h>
+
+#include <android/native_activity.h>
+
+#include "view.h"
+
+extern ANativeActivity *bare_native_activity;
+
+struct bare_ndk_activity_t {
+  java_global_ref_t<java_object_t<"android/app/Activity">> handle;
+
+  java_global_ref_t<java_class_t<"android/app/Activity">> init;
+
+  java_env_t java;
+};
+
+static js_value_t *
+bare_ndk_activity_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  auto activity = new bare_ndk_activity_t();
+
+  activity->java = bare_native_activity->env;
+
+  activity->init = java_class_t<"android/app/Activity">(activity->java);
+
+  activity->handle = java_object_t<"android/app/Activity">(activity->java, bare_native_activity->clazz);
+
+  js_external_t<bare_ndk_activity_t> handle;
+  err = js_create_external(env, activity, handle);
+  assert(err == 0);
+
+  return static_cast<js_value_t *>(handle);
+}
+
+static js_value_t *
+bare_ndk_activity_content_view(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, nullptr, nullptr);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_ndk_activity_t *activity;
+  err = js_get_value(env, js_external_t<bare_ndk_activity_t>(argv[0]), activity);
+  assert(err == 0);
+
+  bare_ndk_view_t *view;
+  err = js_get_value(env, js_external_t<bare_ndk_view_t>(argv[1]), view);
+  assert(err == 0);
+
+  auto set_content_view = activity->init.get_method<void(java_object_t<"android/view/View">)>("setContentView");
+
+  set_content_view(activity->handle, view->handle);
+
+  return nullptr;
+}

package/lib/activity.js

@@ -0,0 +1,13 @@
+const binding = require('../binding')
+
+class NDKActivity {
+  constructor() {
+    this._handle = binding.activityInit()
+  }
+
+  contentView(view) {
+    binding.activityContentView(this._handle, view._handle)
+  }
+}
+
+module.exports = new NDKActivity()

package/lib/runtime/Activity.java

@@ -0,0 +1,47 @@
+package to.holepunch.bare;
+
+import android.content.res.AssetManager;
+import android.os.Bundle;
+
+public final class Activity extends android.app.Activity {
+  static {
+    System.loadLibrary("bare");
+  }
+
+  private native void
+  setup(Bundle state, AssetManager assets);
+
+  private native void
+  teardown();
+
+  private native void
+  suspend();
+
+  private native void
+  resume();
+
+  @Override
+  protected void
+  onCreate(Bundle state) {
+    setup(state, getAssets());
+    super.onCreate(state);
+  }
+
+  protected void
+  onDestroy() {
+    teardown();
+    super.onDestroy();
+  }
+
+  protected void
+  onPause() {
+    suspend();
+    super.onPause();
+  }
+
+  protected void
+  onResume() {
+    resume();
+    super.onResume();
+  }
+}

package/lib/{runtime.c → runtime.cc}

@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <bare.h>
+#include <jnitl.h>
 #include <js.h>
 #include <log.h>
 #include <sys/timerfd.h>
@@ -7,6 +8,7 @@
 #include <uv.h>
 
 #include <android/asset_manager.h>
+#include <android/asset_manager_jni.h>
 #include <android/looper.h>
 #include <android/native_activity.h>
 
@@ -21,9 +23,13 @@ static bare_t *bare;
 
 static int bare__timer;
 
+static ANativeActivity bare__native_activity;
+
+ANativeActivity *bare_native_activity = &bare__native_activity;
+
 static void
 bare__on_shutdown(uv_async_t *handle) {
-  uv_close((uv_handle_t *) handle, NULL);
+  uv_close(reinterpret_cast<uv_handle_t *>(handle), nullptr);
 }
 
 static void
@@ -37,7 +43,7 @@ bare__on_platform_thread(void *data) {
   err = uv_async_init(&loop, &bare__platform_shutdown, bare__on_shutdown);
   assert(err == 0);
 
-  err = js_create_platform(&loop, NULL, &bare__platform);
+  err = js_create_platform(&loop, nullptr, &bare__platform);
   assert(err == 0);
 
   uv_barrier_wait(&bare__platform_ready);
@@ -73,7 +79,7 @@ bare__run(void) {
     spec.it_value.tv_nsec = (timeout % 1000) * 1000000;
   }
 
-  timerfd_settime(bare__timer, 0, &spec, NULL);
+  timerfd_settime(bare__timer, 0, &spec, nullptr);
 }
 
 static int
@@ -90,59 +96,25 @@ bare__on_timeout(int fd, int events, void *data) {
   return 1;
 }
 
-static void
-bare__on_destroy(ANativeActivity *activity) {
-  int err;
-
-  ALooper *looper = ALooper_forThread();
-
-  err = ALooper_removeFd(looper, bare__loop->backend_fd);
-  assert(err == 1);
-
-  err = ALooper_removeFd(looper, bare__timer);
-  assert(err == 1);
-
-  close(bare__timer);
-
-  err = uv_async_send(&bare__shutdown);
-  assert(err == 0);
-
-  err = bare_terminate(bare);
-  assert(err == 0);
-
-  err = bare_run(bare, UV_RUN_NOWAIT);
-  assert(err >= 0);
-}
-
-static void
-bare__on_pause(ANativeActivity *activity) {
+extern "C" void
+Java_to_holepunch_bare_Activity_setup(JNIEnv *env, jobject self, jobject state, jobject assets) {
   int err;
 
-  err = bare_suspend(bare, 0);
-  assert(err == 0);
-}
-
-static void
-bare__on_resume(ANativeActivity *activity) {
-  int err;
+  bare__native_activity.env = env;
 
-  err = bare_resume(bare);
-  assert(err == 0);
-}
+  bare__native_activity.clazz = env->NewGlobalRef(self);
 
-void
-ANativeActivity_onCreate(ANativeActivity *activity, void *state, size_t len) {
-  int err;
+  bare__native_activity.assetManager = AAssetManager_fromJava(env, assets);
 
   err = log_open("bare", 0);
   assert(err == 0);
 
-  uv_setup_args(0, NULL);
+  uv_setup_args(0, nullptr);
 
   err = uv_barrier_init(&bare__platform_ready, 2);
   assert(err == 0);
 
-  err = uv_thread_create(&bare__platform_thread, bare__on_platform_thread, NULL);
+  err = uv_thread_create(&bare__platform_thread, bare__on_platform_thread, nullptr);
   assert(err == 0);
 
   uv_barrier_wait(&bare__platform_ready);
@@ -154,31 +126,67 @@ ANativeActivity_onCreate(ANativeActivity *activity, void *state, size_t len) {
   err = uv_async_init(bare__loop, &bare__shutdown, bare__on_shutdown);
   assert(err == 0);
 
-  err = bare_setup(bare__loop, bare__platform, NULL, 0, NULL, NULL, &bare);
+  err = bare_setup(bare__loop, bare__platform, nullptr, 0, nullptr, nullptr, &bare);
   assert(err == 0);
 
-  AAsset *asset = AAssetManager_open(activity->assetManager, "app.bundle", AASSET_MODE_BUFFER);
+  AAsset *asset = AAssetManager_open(bare__native_activity.assetManager, "app.bundle", AASSET_MODE_BUFFER);
 
   uv_buf_t entry = uv_buf_init((char *) AAsset_getBuffer(asset), AAsset_getLength(asset));
 
-  err = bare_load(bare, "bare:/app.bundle", &entry, NULL);
+  err = bare_load(bare, "bare:/app.bundle", &entry, nullptr);
   (void) err;
 
   AAsset_close(asset);
 
   ALooper *looper = ALooper_forThread();
 
-  err = ALooper_addFd(looper, bare__loop->backend_fd, ALOOPER_POLL_CALLBACK, ALOOPER_EVENT_INPUT, bare__on_poll, NULL);
+  err = ALooper_addFd(looper, bare__loop->backend_fd, ALOOPER_POLL_CALLBACK, ALOOPER_EVENT_INPUT, bare__on_poll, nullptr);
   assert(err == 1);
 
   bare__timer = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
 
-  err = ALooper_addFd(looper, bare__timer, ALOOPER_POLL_CALLBACK, ALOOPER_EVENT_INPUT, bare__on_timeout, NULL);
+  err = ALooper_addFd(looper, bare__timer, ALOOPER_POLL_CALLBACK, ALOOPER_EVENT_INPUT, bare__on_timeout, nullptr);
   assert(err == 1);
 
-  activity->callbacks->onDestroy = bare__on_destroy;
-  activity->callbacks->onPause = bare__on_pause;
-  activity->callbacks->onResume = bare__on_resume;
-
   bare__run();
 }
+
+extern "C" void
+Java_to_holepunch_bare_Activity_teardown(JNIEnv *env, jobject self) {
+  int err;
+
+  ALooper *looper = ALooper_forThread();
+
+  err = ALooper_removeFd(looper, bare__loop->backend_fd);
+  assert(err == 1);
+
+  err = ALooper_removeFd(looper, bare__timer);
+  assert(err == 1);
+
+  close(bare__timer);
+
+  err = uv_async_send(&bare__shutdown);
+  assert(err == 0);
+
+  err = bare_terminate(bare);
+  assert(err == 0);
+
+  err = bare_run(bare, UV_RUN_NOWAIT);
+  assert(err >= 0);
+}
+
+extern "C" void
+Java_to_holepunch_bare_Activity_suspend(JNIEnv *env, jobject self) {
+  int err;
+
+  err = bare_suspend(bare, 0);
+  assert(err == 0);
+}
+
+extern "C" void
+Java_to_holepunch_bare_Activity_resume(JNIEnv *env, jobject self) {
+  int err;
+
+  err = bare_resume(bare);
+  assert(err == 0);
+}

package/lib/view.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <assert.h>
+#include <bare.h>
+#include <jnitl.h>
+#include <js.h>
+
+struct bare_ndk_view_t {
+  java_global_ref_t<java_object_t<"android/view/View">> handle;
+};

package/lib/view.js

@@ -0,0 +1,5 @@
+module.exports = class NDKView {
+  constructor(handle = null) {
+    this._handle = handle
+  }
+}

package/lib/web-view.h

@@ -0,0 +1,161 @@
+#pragma once
+
+#include <assert.h>
+#include <bare.h>
+#include <jnitl.h>
+#include <js.h>
+#include <jstl.h>
+
+#include "activity.h"
+
+struct bare_ndk_web_view_t {
+  java_global_ref_t<java_object_t<"android/webkit/WebView">> handle;
+
+  java_global_ref_t<java_class_t<"android/webkit/WebView">> init;
+
+  js_env_t *env;
+  js_ref_t *ctx;
+};
+
+static void
+bare_ndk_web_view__on_release(js_env_t *env, bare_ndk_web_view_t *web_view) {
+  int err;
+
+  err = js_delete_reference(env, web_view->ctx);
+  assert(err == 0);
+
+  delete web_view;
+}
+
+static js_value_t *
+bare_ndk_web_view_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, nullptr, nullptr);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_ndk_activity_t *activity;
+  err = js_get_value(env, js_external_t<bare_ndk_activity_t>(argv[0]), activity);
+  assert(err == 0);
+
+  auto web_view = new bare_ndk_web_view_t();
+
+  web_view->env = env;
+
+  web_view->init = java_class_t<"android/webkit/WebView">(activity->java);
+
+  web_view->handle = web_view->init(java_object_t<"android/content/Context">(activity->java, activity->handle));
+
+  err = js_create_reference(env, argv[1], 1, &web_view->ctx);
+  assert(err == 0);
+
+  js_external_t<bare_ndk_web_view_t> handle;
+  err = js_create_external<bare_ndk_web_view__on_release>(env, web_view, handle);
+  assert(err == 0);
+
+  return static_cast<js_value_t *>(handle);
+}
+
+static js_value_t *
+bare_ndk_web_view_debugging_enabled(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, nullptr, nullptr);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_ndk_activity_t *activity;
+  err = js_get_value(env, js_external_t<bare_ndk_activity_t>(argv[0]), activity);
+  assert(err == 0);
+
+  bool enabled;
+  err = js_get_value(env, js_boolean_t(argv[1]), enabled);
+  assert(err == 0);
+
+  auto init = java_class_t<"android/webkit/WebView">(activity->java);
+
+  auto set_debugging_enabled = init.get_static_method<void(bool)>("setWebContentsDebuggingEnabled");
+
+  set_debugging_enabled(enabled);
+
+  return nullptr;
+}
+
+static js_value_t *
+bare_ndk_web_view_load_url(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, nullptr, nullptr);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_ndk_web_view_t *web_view;
+  err = js_get_value(env, js_external_t<bare_ndk_web_view_t>(argv[0]), web_view);
+  assert(err == 0);
+
+  std::string url;
+  err = js_get_value(env, js_string_t(argv[1]), url);
+  assert(err == 0);
+
+  auto load_url = web_view->init.get_method<void(std::string)>("loadUrl");
+
+  load_url(web_view->handle, url);
+
+  return nullptr;
+}
+
+static js_value_t *
+bare_ndk_web_view_load_data(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 6;
+  js_value_t *argv[6];
+
+  err = js_get_callback_info(env, info, &argc, argv, nullptr, nullptr);
+  assert(err == 0);
+
+  assert(argc == 6);
+
+  bare_ndk_web_view_t *web_view;
+  err = js_get_value(env, js_external_t<bare_ndk_web_view_t>(argv[0]), web_view);
+  assert(err == 0);
+
+  std::string data;
+  err = js_get_value(env, js_string_t(argv[1]), data);
+  assert(err == 0);
+
+  std::string mime_type;
+  err = js_get_value(env, js_string_t(argv[2]), mime_type);
+  assert(err == 0);
+
+  std::string encoding;
+  err = js_get_value(env, js_string_t(argv[3]), encoding);
+  assert(err == 0);
+
+  std::string base_url;
+  err = js_get_value(env, js_string_t(argv[4]), base_url);
+  assert(err == 0);
+
+  std::string history_url;
+  err = js_get_value(env, js_string_t(argv[5]), history_url);
+  assert(err == 0);
+
+  auto load_data = web_view->init.get_method<void(std::string, std::string, std::string, std::string, std::string)>("loadDataWithBaseURL");
+
+  load_data(web_view->handle, base_url, data, mime_type, encoding, history_url);
+
+  return nullptr;
+}

package/lib/web-view.js

@@ -0,0 +1,33 @@
+const binding = require('../binding')
+const NDKActivity = require('./activity')
+const NDKView = require('./view')
+
+module.exports = class NDKWebView extends NDKView {
+  constructor() {
+    super()
+
+    this._handle = binding.webViewInit(NDKActivity._handle, this)
+  }
+
+  static debuggingEnabled(enabled = true) {
+    binding.webViewDebuggingEnabled(NDKActivity._handle, enabled)
+    return this
+  }
+
+  loadURL(url) {
+    binding.webViewLoadURL(this._handle, url)
+    return this
+  }
+
+  loadData(data, mimeType, encoding, baseURL = 'about:blank', historyURL = baseURL) {
+    binding.webViewLoadData(
+      this._handle,
+      data,
+      mimeType || 'text/html; charset=utf-8',
+      encoding || 'UTF-8',
+      baseURL,
+      historyURL
+    )
+    return this
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bare-ndk",
-  "version": "0.1.0",
-  "description": "Android NDK runtime for Bare",
+  "version": "0.1.1",
+  "description": "Android NDK bindings and runtime for Bare",
   "exports": {
     "./package": "./package.json",
     ".": "./index.js",
@@ -10,7 +10,7 @@
   "files": [
     "index.js",
     "runtime.js",
-    "binding.c",
+    "binding.cc",
     "binding.js",
     "CMakeLists.txt",
     "lib",