鸿蒙(HarmonyOS)实战开发篇——基于Napi调用ArkTS/系统接口

场景描述：

app应用在native侧调用 系统库/arkts模块的方法。

应用经常会遇到如下的业务诉求：

场景一：系统提供了ArkTS 接口，但未提供对应的NDK接口，当伙伴使用C++ 代码实现业务逻辑时，部分系统能力需要依赖系统ArkTS接口；

场景二: 系统仅提供了ArkTS 异步接口，未提供对应的NDK接口，当伙伴使用C++ 代码实现业务逻辑时，部分系统能力需要依赖系统ArkTS 异步接口；

场景三：伙伴在 TS 侧已定义接口，未实现对应的NDK接口，当伙伴使用C++ 代码实现业务逻辑时，想直接使用已有的TS 接口；

方案描述：

场景一： 系统提供了ArkTS 接口，但未提供对应的NDK接口，当伙伴使用C++ 代码实现业务逻辑时，部分系统能力需要依赖系统ArkTS接口；

例如： 获取设备的屏幕宽高。

方案：

通过napi_load_module 的方式调用系统模块接口。

核心代码

static napi_value GetDisplaySize(napi_env env, napi_callback_info info) {

  // 获取arkts侧的系统库路径

  char path[64] = "@ohos.display";

  size_t typeLen = 0;

  napi_value string;

  napi_create_string_utf8(env, path,  typeLen, &string);

  // 加载系统库

  napi_value sysModule;

  napi_load_module(env, path, &sysModule);

  // 获取系统库中的"getDefaultDisplaySync"方法

  napi_value func = nullptr;

  napi_get_named_property(env, sysModule, "getDefaultDisplaySync", &func);

  napi_value funcResult;

  napi_call_function(env, sysModule, func, 0, nullptr, &funcResult);

  napi_value widthValue = nullptr;

  napi_get_named_property(env, funcResult, "width", &widthValue);

  double width;

  napi_get_value_double(env, widthValue, &width);

  OH_LOG_INFO( LOG_APP,  "width: %{public}f", width);

  napi_value heightValue = nullptr;

  napi_get_named_property(env, funcResult, "height", &heightValue);

  double height;

  napi_get_value_double(env, heightValue, &height);

  OH_LOG_INFO(LOG_APP, "height: %{public}f", height);

  // TODO: 业务拿到width 和 height，可以进一步处理具体业务逻辑

  return nullptr;

}

运行结果：

场景二：

系统仅提供了ArkTS 异步接口，未提供对应的NDK接口，当伙伴使用C++ 代码实现业务逻辑时，部分系统能力需要依赖系统ArkTS 异步接口；

例如： 如何访问系统定义的异步ArkTS方法。

方案

通过创建线程安全函数的方式 调用系统的异步接口

核心代码： 回调到JS层

static void CallJs(napi_env env, napi_value jsCb, void *context, void *data) {

  if (env == nullptr) {

    return;

  }

  napi_value undefined = nullptr;

  napi_value promise = nullptr;

  char str[] = "wlan0";

  napi_value sysModule;

  napi_load_module(env, "@ohos.net.statistics", &sysModule);

  napi_value param;

  napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &param);

  napi_call_function(env, sysModule, jsCb, 1, &param, &promise);

  napi_value thenFunc = nullptr;

  if (napi_get_named_property(env, promise, "then", &thenFunc) != napi_ok) {

    return;

  }

  napi_value resolvedCallback;

  napi_value rejectedCallback;

  napi_create_function(env, "resolvedCallback", NAPI_AUTO_LENGTH, ResolvedCallback, data, &resolvedCallback);

  napi_create_function(env, "rejectedCallback", NAPI_AUTO_LENGTH, RejectedCallback, data, &rejectedCallback);

  napi_value argv[2] = {resolvedCallback, rejectedCallback};

  napi_call_function(env, promise, thenFunc, 2, argv, nullptr);

}

// 执行异步任务

static void ExecuteWork(napi_env env, void *data) {

  CallbackData *callbackData = reinterpret_cast<CallbackData *>(data);

  std::promise<double> promise;

  auto future = promise.get_future();

  // 调用线程安全函数

  napi_call_threadsafe_function(callbackData->tsfn, &promise, napi_tsfn_nonblocking);

  try {

    auto result = future.get();

    OH_LOG_INFO(LOG_APP, "getIfaceRxBytes Result from JS %{public}f", result);

  } catch (const std::exception &e) {

    // OH_LOG_INFO(LOG_APP, "XXX, Result from JS %{public}s", e.what());

  }

}

// 异步任务完成回调

static void WorkComplete(napi_env env, napi_status status, void *data) {

  CallbackData *callbackData = reinterpret_cast<CallbackData *>(data);

  napi_release_threadsafe_function(callbackData->tsfn, napi_tsfn_release);

  napi_delete_async_work(env, callbackData->work);

  callbackData->tsfn = nullptr;

  callbackData->work = nullptr;

}

static napi_value CallAsyncFunc(napi_env env, napi_callback_info info) {

  size_t argc = 1;

  napi_value jsCb = nullptr;

  CallbackData *callbackData = nullptr;

  napi_get_cb_info(env, info, &argc, &jsCb, nullptr, reinterpret_cast<void **>(&callbackData));

  napi_value sysModule;

  napi_load_module(env, "@ohos.net.statistics", &sysModule);

  napi_value getIfaceRxBytesFunc ;

  napi_get_named_property(env, sysModule, "getIfaceRxBytes", &getIfaceRxBytesFunc);

  // 创建一个线程安全函数

  napi_value resourceName = nullptr;

  napi_create_string_utf8(env, "CallAsyncFunc", NAPI_AUTO_LENGTH, &resourceName);

  napi_create_threadsafe_function(env, getIfaceRxBytesFunc, nullptr, resourceName, 0, 1, callbackData, nullptr, callbackData, CallJs,

    &callbackData->tsfn);

  // 创建一个异步任务

  napi_create_async_work(env, nullptr, resourceName, ExecuteWork, WorkComplete, callbackData, &callbackData->work);

  // 将异步任务加入到异步队列中

  napi_queue_async_work(env, callbackData->work);

  return nullptr;

}

运行结果

场景三:

伙伴在 ArkTS/TS 侧已定义接口，当伙伴使用C++ 代码实现业务逻辑时，想直接使用已有的TS 接口；

例如： 如何调用自定义的 ArkTS/TS方法；

方案

核心代码

步骤一: ObjectUtil.ts 导出相关接口

namespace ObjectUtil {

  export function isNull(obj) {

    return obj === null;

  }

  export function isUndefined(obj) {

    return obj === undefined;

  }

  export function isNullOrUndefined(obj) {

    return isNull(obj) || isUndefined(obj);

  }

  export function toString(obj, defaultValue = '') {

    if (this.isNullOrUndefined(obj)) {

      return defaultValue;

    }

    else {

      return obj.toString();

    }

  }

}

export default ObjectUtil;

步骤二：必须在 build-profile.json5添加ets文件配置

// 必须在build-profile.json5添加配置

"arkOptions": {

  "runtimeOnly": {

    "sources": [

    './src/main/ets/common/ObjectUtil.ts',

    ],

    "packages": [

    ]

  }

},

步骤三: 在native 获取ets 模块导出的变量

/*

* 获取某个TS/JS模块导出变量

* 入参：

* path - 在工程文件夹下从ets开始的绝对路径名

* key - 待加载TS/JS模块导出变量的属性名

* 返回值：获取的TS/JS模块导出变量

*/

static napi_value GetNativeModule(napi_env env, const char *modulePath, const char *key)

{

  napi_value module;

  // 通过modulePath获取对应TS/JS模块的导出对象

  napi_load_module(env, modulePath, &module);

  napi_value outputObject = nullptr;

  // 通过对象属性名key，从导出模块变量

  napi_get_named_property(env, module, key, &outputObject );

  return outputObject ;

}

步骤四：获取方法并调用demo示例（获取/ets/common/ObjectUtil 的isNull方法，并调用isNull方法判断一个对象是否为null）

/*

* 调用系统库/ets/common/ObjectUtil模块导出方法 /ets/common/ObjectUtil 的isNull方法

* 返回值：标志是否加载成功的布尔值

*/

static napi_status CallIsNullFun(napi_env env, napi_value inputObject)

{

  const char moduleName[] = "/ets/common/ObjectUtil";

  const char funcName[] = "isNull";

  napi_value isNullFun = GetNativeModule(env, moduleName, funcName);

  

  napi_value inputArgs[1] = inputObject;

  napi_value result;

  // infoFun为"/ets/common/ObjectUtil"模块中获取的函数方法

  // inputArgs为待执行方法的入参，result为出参

  napi_call_function(env, undefined, isNullFun , 1, inputArgs, result);

  

  return result ;

}