鸿蒙 NAPI 与 C/C++ 原生互操作

// entry/src/main/cpp/napi_init.cpp
#include "napi/native_api.h"
#include <hilog/log.h>

static napi_value Add(napi_env env, napi_callback_info info) {
  size_t argc = 2;
  napi_value args[2] = { nullptr };
  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

  double a = 0.0;
  double b = 0.0;
  napi_get_value_double(env, args[0], &a);
  napi_get_value_double(env, args[1], &b);

  napi_value result = nullptr;
  napi_create_double(env, a + b, &result);
  return result;
}

static napi_value Init(napi_env env, napi_value exports) {
  napi_property_descriptor desc[] = {
    { "add", nullptr, Add, nullptr, nullptr, nullptr, napi_default, nullptr }
  };
  napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
  return exports;
}

static napi_module demoModule = {
  .nm_version = 1,
  .nm_flags = 0,
  .nm_filename = nullptr,
  .nm_register_func = Init,
  .nm_modname = "entry",
  .nm_priv = nullptr,
  .reserved = { 0 },
};

extern "C" __attribute__((constructor)) void RegisterModule(void) {
  napi_module_register(&demoModule);
}

static std::string GetString(napi_env env, napi_value value) {
  size_t len = 0;
  napi_get_value_string_utf8(env, value, nullptr, 0, &len);
  std::string result(len, '\0');
  napi_get_value_string_utf8(env, value, &result[0], len + 1, &len);
  return result;
}

static napi_value Md5(napi_env env, napi_callback_info info) {
  size_t argc = 1;
  napi_value args[1] = { nullptr };
  if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok || argc < 1) {
    napi_throw_error(env, nullptr, "expect 1 argument");
    return nullptr;
  }
  if (!IsString(env, args[0])) {
    napi_throw_type_error(env, "E_TYPE", "argument must be a string");
    return nullptr;
  }
  const std::string input = GetString(env, args[0]);
  const std::string digest = ComputeMd5(input);

  napi_value result = nullptr;
  napi_create_string_utf8(env, digest.c_str(), digest.size(), &result);
  return result;
}

struct CallbackCtx {
  napi_env env = nullptr;
  napi_ref callbackRef = nullptr;
};

static void InvokeCallback(CallbackCtx* ctx, const std::string& message) {
  napi_value global = nullptr;
  napi_get_global(ctx->env, &global);

  napi_value callback = nullptr;
  napi_get_reference_value(ctx->env, ctx->callbackRef, &callback);

  napi_value argv[1] = { nullptr };
  napi_create_string_utf8(ctx->env, message.c_str(), message.size(), &argv[0]);

  napi_value ignored = nullptr;
  napi_call_function(ctx->env, global, callback, 1, argv, &ignored);
}

struct AsyncCtx {
  napi_env env = nullptr;
  napi_async_work work = nullptr;
  napi_ref callbackRef = nullptr;
  std::string input;
  std::string output;
};

static void ExecuteAsync(napi_env env, void* data) {
  AsyncCtx* ctx = static_cast<AsyncCtx*>(data);
  // 这个函数跑在 NAPI 工作线程，禁止调用任何 napi_* 接口
  ctx->output = HeavyCompute(ctx->input);
}

static void CompleteAsync(napi_env env, napi_status status, void* data) {
  AsyncCtx* ctx = static_cast<AsyncCtx*>(data);
  // 回到 JS 线程，这里才可以创建值并调用回调
  napi_value argv[2] = { nullptr, nullptr };
  napi_get_undefined(env, &argv[0]);
  napi_create_string_utf8(env, ctx->output.c_str(), ctx->output.size(), &argv[1]);

  napi_value callback = nullptr;
  napi_get_reference_value(env, ctx->callbackRef, &callback);
  napi_value global = nullptr;
  napi_get_global(env, &global);
  napi_value ignored = nullptr;
  napi_call_function(env, global, callback, 2, argv, &ignored);

  napi_delete_reference(env, ctx->callbackRef);
  napi_delete_async_work(env, ctx->work);
  delete ctx;
}

static napi_value RunAsync(napi_env env, napi_callback_info info) {
  size_t argc = 2;
  napi_value args[2] = { nullptr };
  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

  AsyncCtx* ctx = new AsyncCtx();
  ctx->env = env;
  ctx->input = GetString(env, args[0]);
  napi_create_reference(env, args[1], 1, &ctx->callbackRef);

  napi_value resourceName = nullptr;
  napi_create_string_utf8(env, "RunAsync", NAPI_AUTO_LENGTH, &resourceName);
  napi_create_async_work(env, nullptr, resourceName, ExecuteAsync, CompleteAsync,
    ctx, &ctx->work);
  napi_queue_async_work(env, ctx->work);
  return nullptr;
}

static napi_value ComputeAsync(napi_env env, napi_callback_info info) {
  size_t argc = 1;
  napi_value args[1] = { nullptr };
  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

  napi_deferred deferred = nullptr;
  napi_value promise = nullptr;
  napi_create_promise(env, &deferred, &promise);

  AsyncCtx* ctx = new AsyncCtx();
  ctx->env = env;
  ctx->input = GetString(env, args[0]);
  ctx->deferred = deferred;

  napi_value resourceName = nullptr;
  napi_create_string_utf8(env, "ComputeAsync", NAPI_AUTO_LENGTH, &resourceName);
  napi_create_async_work(env, nullptr, resourceName, ExecuteAsync, CompletePromise,
    ctx, &ctx->work);
  napi_queue_async_work(env, ctx->work);
  return promise;
}

static void CompletePromise(napi_env env, napi_status status, void* data) {
  AsyncCtx* ctx = static_cast<AsyncCtx*>(data);
  napi_value value = nullptr;
  napi_create_string_utf8(env, ctx->output.c_str(), ctx->output.size(), &value);
  napi_resolve_deferred(env, ctx->deferred, value);
  napi_delete_async_work(env, ctx->work);
  delete ctx;
}

static napi_value Subscribe(napi_env env, napi_callback_info info) {
  size_t argc = 1;
  napi_value args[1] = { nullptr };
  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

  napi_value resourceName = nullptr;
  napi_create_string_utf8(env, "NativeEvent", NAPI_AUTO_LENGTH, &resourceName);

  napi_threadsafe_function tsfn = nullptr;
  napi_create_threadsafe_function(env, args[0], nullptr, resourceName,
    0, 1, nullptr, nullptr, nullptr, OnJsThread, &tsfn);

  // 交给原生库，在任意线程调用
  NativeLib::Start([tsfn](const std::string& event) {
    // 这一步是线程安全的，内部会把调用排到 JS 线程队列
    napi_call_threadsafe_function(tsfn, strdup(event.c_str()), napi_tsfn_nonblocking);
  });
  return nullptr;
}

static void OnJsThread(napi_env env, napi_value jsCallback, void* context, void* data) {
  // 这个函数一定在 JS 线程执行
  char* text = static_cast<char*>(data);
  if (env != nullptr && jsCallback != nullptr) {
    napi_value arg = nullptr;
    napi_create_string_utf8(env, text, NAPI_AUTO_LENGTH, &arg);
    napi_value global = nullptr;
    napi_get_global(env, &global);
    napi_value ignored = nullptr;
    napi_call_function(env, global, jsCallback, 1, &arg, &ignored);
  }
  free(text);
}

cmake_minimum_required(VERSION 3.5.0)
project(hashmodule)

set(NATIVERENDER_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})

include_directories(${NATIVERENDER_ROOT_PATH}
                    ${NATIVERENDER_ROOT_PATH}/include)

add_library(entry SHARED
    napi_init.cpp
    hash.cpp)

target_link_libraries(entry PUBLIC
    libace_napi.z.so
    libhilog_ndk.z.so
    libcrypto.z.so)

{
  "buildOption": {
    "externalNativeOptions": {
      "path": "./src/main/cpp/CMakeLists.txt",
      "arguments": "-DCMAKE_BUILD_TYPE=Release",
      "cppFlags": "-std=c++17",
      "abiFilters": ["arm64-v8a", "x86_64"]
    }
  }
}

// hash.cpp
#include <openssl/sha.h>
#include <string>

std::string ComputeSha256(const unsigned char* data, size_t length) {
  unsigned char digest[SHA256_DIGEST_LENGTH];
  SHA256(data, length, digest);
  static const char* hex = "0123456789abcdef";
  std::string out(SHA256_DIGEST_LENGTH * 2, '\0');
  for (size_t i = 0; i < SHA256_DIGEST_LENGTH; ++i) {
    out[i * 2] = hex[digest[i] >> 4];
    out[i * 2 + 1] = hex[digest[i] & 0x0F];
  }
  return out;
}