鸿蒙5.0开发进阶:NDK代码开发-Node-API使用指南(使用Node-API接口进行array相关开发)

鸿蒙4.0开发笔记之ArkTS语法的基础数据类型[DevEco Studio开发](七) 变量名称可以包含数字和字母。变量名不能以数字开头。除了下划线 _ 和美元 $ 符号外,不能包含其他特殊字符,包括空格。不能使用关键字和保留字(已经定义了特殊含义的单词)在TypeScript的语法中,声明变量需要加上前缀关键字let。//变量声明并赋值:变量的初始化//变量声明,后面需要再单独赋值age = 25在HarmonyOS的ArkTS语法里,也是TypeScript中,undefined和null两者各自有自己的类型分别叫做undefined和null。 阅读详情

往期鸿蒙5.0全套实战文章必看:(文中附带全栈鸿蒙5.0学习资料)


使用Node-API接口进行array相关开发

简介

使用Node-API接口进行array相关开发时,调用相关接口可以在Node-API模块中直接操作和处理ArkTS中的数组。

基本概念

使用Node-API接口进行数组(array)相关开发时,涉及的基本概念主要包括数组的创建、访问、修改、遍历以及与数组相关的操作。这些概念对于理解如何在Node-API模块中与ArkTS数组交互非常重要。以下是一些关键概念:

  • 数组的创建:在Node-API模块中需要创建一个新的ArkTS数组,可以使用napi_create_array接口创建数组,将数组传递给ArkTS层。
  • 数组相关操作:在Node-API模块中通过对应的接口获取ArkTS数组的长度、检索指定索引处的元素以及设置指定索引处的元素值,从而实现Node-API模块与ArkTS数组的交互。
  • TypedArray:ArkTS中的TypedArray是一种用来描述二进制数据的类数组数据视图,可以简单理解为一种指定元素类型的数组,TypedArray没有直接构造器,但是可以用它的子类构造器构造TypedArray类型的数据。TypedArray的子类有:Int8Array、Uint8Array、Uint8ClampedArray、Int16Array、Int32Array等。
  • DataView:DataView是ArkTS中的一种视图,是可以从ArrayBuffer对象中读写多种数值类型的底层接口。
  • ArrayBuffer:ArrayBuffer是固定长度的二进制数据缓冲区。

场景和功能介绍

使用Node-API接口进行数组相关开发时,可以处理各种涉及ArkTS数组的操作和交互场景。以下是几个具体的使用场景介绍:

接口描述
napi_create_array用于在Node-API模块中向ArkTS层创建一个ArkTS数组对象。
napi_create_array_with_length用于在Node-API模块中向ArkTS层创建指定长度的ArkTS数组时。
napi_get_array_length用于在Node-API模块中获取ArkTS数组对象的长度。
napi_is_array用于在Node-API模块中判断一个napi_value值是否为数组。
napi_set_element用于在Node-API模块中对ArkTS数组对象的特定索引处设置一个值。
napi_get_element用于在Node-API模块中从ArkTS数组对象的特定索引处获取一个值。
napi_has_element用于在Node-API模块中判断ArkTS数组对象请求索引处是否包含元素。
napi_delete_element用于在Node-API模块中从ArkTS数组对象中删除请求索引对应的元素。
napi_create_typedarray用于在Node-API模块中创建指定类型的TypedArray,例如Uint8Array、Int32Array等,通常用于将Node-API模块中的数据转换为ArkTS中的TypedArray,以便进行高性能的数据处理操作。
napi_is_typedarray用于在Node-API模块中判断一个给定的napi_value是否为TypedArray对象。
napi_get_typedarray_info用于在Node-API模块中获得某个TypedArray的各种属性。
napi_create_dataview用于在Node-API模块中创建一个DataView对象,可以访问和操作二进制数据。
napi_is_dataview用于在Node-API模块中判断给定的napi_value是否为ArkTS中的DataView对象。
napi_get_dataview_info用于在Node-API模块中获得某个DataView的各种属性。

使用示例

Node-API接口开发流程参考使用Node-API实现跨语言交互开发流程,本文仅对接口对应C++及ArkTS相关代码进行展示。具体使用见示例。

napi_create_array

用于在Node-API模块中创建一个ArkTS数组。

cpp部分代码

#include "napi/native_api.h"

static constexpr int INT_NUM_5 = 5; // 数组长度

static napi_value CreateArray(napi_env env, napi_callback_info info)
{
    // 创建一个空数组
    napi_value jsArray = nullptr;
    napi_create_array(env, &jsArray);
    // 将创建好的数组进行赋值
    for (int i = 0; i < INT_NUM_5; i++) {
        napi_value element;
        napi_create_int32(env, i, &element);
        napi_set_element(env, jsArray, i, element);
    }
    // 返回已创建好的数组
    return jsArray;
}

接口声明

// index.d.ts
export const createArray: () => number[];

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

hilog.info(0x0000, 'testTag', 'Test Node-API napi_create_array:%{public}s', JSON.stringify(testNapi.createArray()));

napi_create_array_with_length

用于在Node-API模块中创建一个具有指定长度的ArkTS数组。

cpp部分代码

#include "napi/native_api.h"

static napi_value CreateArrayWithLength(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value argv[1] = {nullptr};
    napi_value jsArray = nullptr;
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    // 获取传递的数组长度
    int32_t length = 0;
    napi_get_value_int32(env, argv[0], &length);
    // 使用napi_create_array_with_length创建指定长度的数组
    napi_create_array_with_length(env, length, &jsArray);
    // 返回数组
    return jsArray;
}

接口声明

// index.d.ts
export const createArrayWithLength: (length: number) => void[];

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

let array = testNapi.createArrayWithLength(6);
hilog.info(0x0000, 'testTag', 'Test Node-API napi_create_array_with_length:%{public}d', array.length);

napi_get_array_length

获取给定array的长度。

cpp部分代码

#include "napi/native_api.h"

static napi_value GetArrayLength(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_value result;
    uint32_t length;
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 检查参数是否为数组
    bool is_array;
    napi_is_array(env, args[0], &is_array);
    if (!is_array) {
        napi_throw_type_error(env, nullptr, "Argument must be an array");
        return nullptr;
    }
    napi_get_array_length(env, args[0], &length);
    // 创建返回值
    napi_create_uint32(env, length, &result);
    return result;
}

接口声明

// index.d.ts
export const getArrayLength: (arr: Array<any>) => number | void;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

const arr = [0, 1, 2, 3, 4, 5];
hilog.info(0x0000, 'testTag', 'Test Node-API get_array_length:%{public}d', testNapi.getArrayLength(arr));

napi_is_array

判断给定ArkTS值是否为数组。

cpp部分代码

#include "napi/native_api.h"

static napi_value IsArray(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 调用napi_is_array接口判断给定入参是否为array数组
    bool result;
    napi_status status;
    status = napi_is_array(env, args[0], &result);
    if (status != napi_ok) {
        napi_throw_error(env, nullptr, "Node-API napi_is_array fail");
        return nullptr;
    }
    // 将结果转成napi_value类型返回
    napi_value returnValue;
    napi_get_boolean(env, result, &returnValue);

    return returnValue;
}

接口声明

// index.d.ts
export const isArray: <T>(data: Array<T> | T) => boolean | void;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'
try {
  let value = new Array<number>(1);
  let data = "123";
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_is_array: %{public}s', testNapi.isArray<number>(value));
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_is_array: %{public}s', testNapi.isArray<string>(data));
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_is_array error: %{public}s', error.message);
}

napi_set_element

用于在ArkTS数组中设置指定索引位置的元素。

对于以索引值为键的object,可以使用napi_set_element来设置属性值。

cpp部分代码

#include "napi/native_api.h"

static constexpr int INT_ARG_2 = 2; // 入参索引

static napi_value NapiSetElement(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 3;
    napi_value args[3] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 检查第一个参数是否为数组
    bool isArr = false;
    napi_is_array(env, args[0], &isArr);
    if (!isArr) {
        napi_throw_type_error(env, nullptr, "Argument should be an object of type array");
        return nullptr;
    }
    // 获取要设置的元素索引
    double index = 0;
    napi_get_value_double(env, args[1], &index);
    // 将传入的值设置到数组指定索引位置
    napi_set_element(env, args[0], static_cast<uint32_t>(index), args[INT_ARG_2]);

    return nullptr;
}

接口声明

export const napiSetElement: <T>(arr: Array<T>, index: number, value: T) => void;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'
let arr = [10, 20, 30];
testNapi.napiSetElement<number | string>(arr, 1, 'newElement');
testNapi.napiSetElement<number | string>(arr, 2, 50);
hilog.info(0x0000, 'testTag', 'Test Node-API napi_set_element arr: %{public}s', arr.toString());
hilog.info(0x0000, 'testTag', 'Test Node-API napi_set_element arr[3]: %{public}s', arr[3]);
interface MyObject {
  first: number;
  second: number;
}
let obj: MyObject = {
  first: 1,
  second: 2
};
testNapi.napiSetElement<number | string | Object>(arr, 4, obj);
let objAsString = JSON.stringify(arr[4]);
hilog.info(0x0000, 'testTag', 'Test Node-API napi_set_element arr[4]: %{public}s', objAsString);

napi_get_element

用于从ArkTS数组中获取请求索引位置的元素值。请求索引值应在数组的有效范围内,如果索引超出数组长度,函数会返回undefined。

cpp部分代码

#include "napi/native_api.h"

static napi_value NapiGetElement(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 2;
    napi_value args[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 获取请求元素的索引值
    uint32_t index;
    napi_get_value_uint32(env, args[1], &index);
    // 获取请求索引位置的元素值并存储在result中
    napi_value result;
    napi_get_element(env, args[0], index, &result);

    return result;
}

接口声明

// index.d.ts
export const napiGetElement: <T>(arr: Array<T>, index: number) => number | string | Object | boolean | undefined;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

interface MyObject {
  first: number;
  second: number;
}
let obj: MyObject = {
  first: 1,
  second: 2
};
let arr = [10, 'hello', null, obj];
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[0]: %{public}d', testNapi.napiGetElement<number | string | null | Object>(arr, 0));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[1]: %{public}s', testNapi.napiGetElement<number | string | null | Object>(arr, 1));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[2]: %{public}s', testNapi.napiGetElement<number | string | null | Object>(arr, 2));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[3]: %{public}s', testNapi.napiGetElement<number | string | null | Object>(arr, 3));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[4]: %{public}s', JSON.stringify(testNapi.napiGetElement(arr, 4)));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[null]: %{public}s', testNapi.napiGetElement<number | string | null | Object>(arr, 5));

napi_has_element

用于判断ArkTS数组是否具有指定索引的元素。如果索引超出了对象的有效范围,函数返回false,表示没有元素。

cpp部分代码

#include "napi/native_api.h"

static napi_value NapiHasElement(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 2;
    napi_value args[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 获取要判断的元素的索引
    uint32_t index;
    napi_get_value_uint32(env, args[1], &index);
    // 判断指定索引位置的元素是否存在
    bool hasElement = true;
    napi_has_element(env, args[0], index, &hasElement);
    // 将bool结果转换为napi_value并返回
    napi_value result;
    napi_get_boolean(env, hasElement, &result);
    return result;
}

接口声明

// index.d.ts
export const napiHasElement: <T>(arr: Array<T>, index: number) => boolean;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

let arr = [10, 'hello', null, 'world'];
hilog.info(0x0000, 'testTag', 'Test Node-API napi_has_element arr[0]: %{public}s', testNapi.napiHasElement<number | string | null>(arr, 0));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_has_element arr[7]: %{public}s', testNapi.napiHasElement<number | string | null>(arr, 7));

napi_delete_element

用于从ArkTS数组对象中删除请求索引的元素。

cpp部分代码

#include "napi/native_api.h"

static napi_value NapiDeleteElement(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 2;
    napi_value args[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 获取要删除的元素的索引
    uint32_t index;
    napi_get_value_uint32(env, args[1], &index);
    // 尝试删除请求索引位置的元素
    bool deleted = true;
    napi_delete_element(env, args[0], index, &deleted);
    // 将bool结果转换为napi_value并返回
    napi_value result;
    napi_get_boolean(env, deleted, &result);
    return result;
}

接口声明

// index.d.ts
export const napiDeleteElement: <T>(arr: Array<T>, index: number) => boolean;

ArkTS侧示例代码

// 需要同时导入前文示例代码中的napiHasElement、napiGetElement接口
import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

let arr = [10, 'hello', null, 'world'];
hilog.info(0x0000, 'testTag', 'Test Node-API napi_has_element arr[0]: %{public}s', testNapi.napiHasElement<number | string | null>(arr, 0));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_delete_element arr[0]: %{public}s', testNapi.napiDeleteElement<number | string | null>(arr, 0));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_has_element deleted arr[0]: %{public}s', testNapi.napiHasElement<number | string | null>(arr, 0));
hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_element arr[0]: %{public}d', testNapi.napiGetElement<number | string | null>(arr, 0));

napi_create_typedarray

用于在Node-API模块中通过现有的ArrayBuffer创建指定类型的ArkTS TypedArray。

cpp部分代码

#include "napi/native_api.h"

static napi_value CreateTypedArray(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    int32_t typeNum = 0;
    napi_get_value_int32(env, args[0], &typeNum);
    napi_typedarray_type arrayType;
    // 用于存储每个元素的大小
    size_t elementSize = 0;
    // 根据传递的类型值选择创建对应的类型数组
    arrayType = static_cast<napi_typedarray_type>(typeNum);
        switch (typeNum) {
    case napi_int8_array:
    case napi_uint8_array:
    case napi_uint8_clamped_array:
        elementSize = sizeof(int8_t);
        break;
    case napi_int16_array:
    case napi_uint16_array:
        elementSize = sizeof(int16_t);
        break;
    case napi_int32_array:
    case napi_uint32_array:
        elementSize = sizeof(int32_t);
        break;
    case napi_float32_array:
        elementSize = sizeof(float);
        break;
    case napi_float64_array:
        elementSize = sizeof(double);
        break;
    case napi_bigint64_array:
    case napi_biguint64_array:
        elementSize = sizeof(int64_t);
        break;
    default:
    // 默认创建napi_int8_array类型
        arrayType = napi_int8_array;
        elementSize = sizeof(int8_t);
        break;
    }
    size_t length = 3;
    napi_value arrayBuffer = nullptr;
    napi_value typedArray = nullptr;
    void *data;
    // 创建一个ArrayBuffer
    napi_create_arraybuffer(env, length * elementSize, (void **)&data, &arrayBuffer);
    // 根据给定类型创建TypedArray
    napi_create_typedarray(env, arrayType, length, arrayBuffer, 0, &typedArray);
    return typedArray;
}

接口声明

// index.d.ts
export const enum TypedArrayTypes {
  INT8_ARRAY = 0,
  UINT8_ARRAY,
  UINT8_CLAMPED_ARRAY,
  INT16_ARRAY,
  UINT16_ARRAY,
  INT32_ARRAY,
  UINT32_ARRAY,
  FLOAT32_ARRAY,
  FLOAT64_ARRAY,
  BIGINT64_ARRAY,
  BIGuINT64_ARRAY,
}
export const createTypedArray: <T>(type: TypedArrayTypes) => T;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

// 传递要创建的类型值
let typedArray = testNapi.createTypedArray<Int8Array>(testNapi.TypedArrayTypes["INT8_ARRAY"]);
if (typedArray instanceof Int8Array) {
    hilog.info(0x0000, 'testTag', ' Node-API napi_create_typedarray: Int8Array');
}
let uint8Array = testNapi.createTypedArray<Uint8Array>(testNapi.TypedArrayTypes["UINT8_ARRAY"]);
if (uint8Array instanceof Uint8Array) {
    hilog.info(0x0000, 'testTag', ' Node-API napi_create_typedarray: Uint8Array');
}

需要对use-napi-process.md中的模块初始化部分进行修改,具体见如下:

#include <string>

EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports)
{
    // 定义的TypedArray类型供ArkTS侧使用,用于存放typedArrayTypes类型,使用示例见ArkTS侧的createTypedArray函数
    napi_value typedArrayTypes;
    napi_create_object(env, &typedArrayTypes);
    napi_value typeIndex;
    std::string typeKeys[] = {
        "INT8_ARRAY",   "UINT8_ARRAY",   "UINT8_CLAMPED_ARRAY", "INT16_ARRAY",      "UINT16_ARRAY",    "INT32_ARRAY",
        "UINT32_ARRAY", "FLOAT32_ARRAY", "FLOAT64_ARRAY",       "BIGINT64_ARRAY", "BIGUINT64_ARRAY",
    };
    for (int32_t i = 0; i < sizeof(typeKeys) / sizeof(typeKeys[0]); i++) {
        napi_create_int32(env, i, &typeIndex);
        napi_set_named_property(env, typedArrayTypes, typeKeys[i].c_str(), typeIndex);
    }
    napi_property_descriptor desc[] = {
        {"createTypedArray", nullptr, CreateTypedArray, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"TypedArrayTypes", nullptr, nullptr, nullptr, nullptr, typedArrayTypes, napi_default, nullptr}
    };
    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
    return exports;
}
EXTERN_C_END

napi_is_typedarray

用于在Node-API模块中判断ArkTS侧给定的napi_value是否为TypedArray对象。

cpp部分代码

#include "napi/native_api.h"

static napi_value IsTypedarray(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 调用napi_is_typedarray接口判断给定入参类型是否为TypedArray。
    bool result = false;
        napi_status status;
    status = napi_is_typedarray(env, args[0], &result);
    if (status != napi_ok) {
        napi_throw_error(env, nullptr, "Node-API napi_is_typedarray fail");
        return nullptr;
    }
    // 将结果转成napi_value类型返回。
    napi_value returnValue = nullptr;
    napi_get_boolean(env, result, &returnValue);

    return returnValue;
}

接口声明

// index.d.ts
export const isTypedarray: (data: Object) => boolean | void;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'
try {
  let value = new Uint8Array([1, 2, 3, 4]);
  let data = "123";
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_is_typedarray: %{public}s', testNapi.isTypedarray(value));
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_is_typedarray: %{public}s', testNapi.isTypedarray(data));
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_is_typedarray error: %{public}s', error.message);
}

napi_get_typedarray_info

获取给定TypedArray的各种属性。

cpp部分代码

#include "napi/native_api.h"

static napi_value GetTypedarrayInfo(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数,第一个参数为需要获得的信息的TypedArray类型数据,第二个参数为需要获得的信息类型的枚举值
    size_t argc = 2;
    napi_value args[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 将第二个参数转为int32类型便于比较
    int32_t infoTypeParam;
    napi_get_value_int32(env, args[1], &infoTypeParam);
    // 定义枚举类型与ArkTS侧枚举类型InfoType顺序含义一致
    enum InfoType { INFO_TYPE = 1, INFO_LENGTH, INFO_ARRAY_BUFFER, INFO_BYTE_OFFSET };
    void *data;
    napi_typedarray_type type;
    size_t byteOffset, length;
    napi_value arraybuffer;
    // 调用接口napi_get_typedarray_info获得TypedArray类型数据的信息
    napi_get_typedarray_info(env, args[0], &type, &length, &data, &arraybuffer, &byteOffset);
    napi_value result;
    // 根据属性名,返回TypedArray对应的属性值
    switch (infoTypeParam) {
    case INFO_TYPE:
        // 如果传入的参数是int8类型的TypedArray数据,它的类型(type)为napi_int8_array
        napi_value int8_type;
        napi_get_boolean(env, type == napi_int8_array, &int8_type);
        result = int8_type;
        break;
    case INFO_LENGTH:
        // TypedArray中元素的字节长度
        napi_value napiLength;
        napi_create_int32(env, length, &napiLength);
        result = napiLength;
        break;
    case INFO_BYTE_OFFSET:
        // TypedArray数组的第一个元素所在的基础原生数组中的字节偏移量
        napi_value napiByteOffset;
        napi_create_int32(env, byteOffset, &napiByteOffset);
        result = napiByteOffset;
        break;
    case INFO_ARRAY_BUFFER:
        // TypedArray下的ArrayBuffer
        result = arraybuffer;
        break;
    default:
        break;
    }
    return result;
}

接口声明

// index.d.ts
export const getTypedarrayInfo: <T>(typeArray: T, infoType: number) => ArrayBuffer | number | boolean;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

// 传入TypedArray类型数据。TypedArray是一种用来描述二进制数据的类数组数据视图,没有直接构造器,可以用其子类构造类数组
// TypedArray的子类有: Int8Array Uint8Array Uint8ClampedArray Int16Array Int32Array等
let int8Array = new Int8Array([15, 7]);
// 定义枚举类型 这些都是TypedArray的属性
enum InfoType {
    TYPE = 1, // 传入的TypedArray的类型
    LENGTH = 2, // 传入的TypedArray的长度
    ARRAY_BUFFER = 3, // TypedArray下的ArrayBuffer
    BYTE_OFFSET = 4 // 数组的第一个元素所在的基础原生数组中的字节偏移量
};
let arrbuff = testNapi.getTypedarrayInfo(int8Array, InfoType.ARRAY_BUFFER) as ArrayBuffer;
// 将arraybuffer转为数组
let arr = new Array(new Int8Array(arrbuff));
hilog.info(0x0000, 'Node-API', 'get_typedarray_info_arraybuffer: %{public}s', arr.toString());
hilog.info(0x0000, 'Node-API', 'get_typedarray_info_isIn8Array: %{public}s', testNapi.getTypedarrayInfo(int8Array, InfoType.TYPE).toString());
hilog.info(0x0000, 'Node-API', 'get_typedarray_info_length: %{public}d', testNapi.getTypedarrayInfo(int8Array, InfoType.LENGTH));
hilog.info(0x0000, 'Node-API', 'get_typedarray_info_byte_offset: %{public}d', testNapi.getTypedarrayInfo(int8Array, InfoType.BYTE_OFFSET));

napi_create_dataview

创建dataview对象,便于访问和操作二进制数据,需要提供一个指向二进制数据的缓冲区,并指定要包含的字节数。

cpp部分代码

#include "napi/native_api.h"

static napi_value CreateDataView(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_value arraybuffer = nullptr;
    napi_value result = nullptr;
    // DataView的字节长度
    size_t byteLength = 12;
    // 字节偏移量
    size_t byteOffset = 4;
    // 获取回调函数的参数信息
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 将参数转换为对象类型
    napi_coerce_to_object(env, args[0], &arraybuffer);
    // 创建一个数据视图对象,并指定字节长度和字节偏移量
    napi_status status = napi_create_dataview(env, byteLength, arraybuffer, byteOffset, &result);
    if (status != napi_ok) {
        // 抛出创建DataView内容失败的错误
        napi_throw_error(env, nullptr, "Failed to create DataView");
        return nullptr;
    }
    // 获取DataView的指针和长度信息
    uint8_t *data = nullptr;
    size_t length = 0;
    napi_get_dataview_info(env, result, &length, (void **)&data, nullptr, nullptr);
    // 为DataView赋值
    for (size_t i = 0; i < length; i++) {
        data[i] = static_cast<uint8_t>(i + 1);
    }
    return result;
}

接口声明

// index.d.ts
export const createDataView: (arraybuffer:ArrayBuffer) => DataView | void;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

const arrayBuffer = new ArrayBuffer(16);
const dataView = testNapi.createDataView(arrayBuffer) as DataView;
hilog.info(0x0000, 'testTag', 'Test Node-API dataView:%{public}d', dataView.byteLength);
hilog.info(0x0000, 'testTag', 'Test Node-API dataView第一个数据:%{public}d', dataView.getInt8(0));

napi_is_dataview

用于在Node-API模块中判断ArkTS侧给定的napi_value是否为DataView。

cpp部分代码

#include "napi/native_api.h"

static napi_value IsDataView(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    // 调用napi_is_dataview接口判断给定入参是否为DataView数据。
    bool result;
    napi_status status;
    status = napi_is_dataview(env, args[0], &result);
    if (status != napi_ok) {
        napi_throw_error(env, nullptr, "Node-API napi_is_dataview fail");
        return nullptr;
    }
    // 将结果转成napi_value类型返回。
    napi_value returnValue;
    napi_get_boolean(env, result, &returnValue);

    return returnValue;
}

接口声明

// index.d.ts
export const isDataView: (date: DataView | string) => boolean | void;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'
try {
  let buffer = new ArrayBuffer(16);
  let dataView = new DataView(buffer);
  let data = "123";
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_is_dataview: %{public}s', testNapi.isDataView(dataView));
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_is_dataview: %{public}s', testNapi.isDataView(data));
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_is_dataview error: %{public}s', error.message);
}

napi_get_dataview_info

获取给定DataView的各种属性。

cpp部分代码

#include "napi/native_api.h"

static napi_value GetDataViewInfo(napi_env env, napi_callback_info info)
{
    // 获取ArkTS侧传入的参数
    size_t argc = 2;
    napi_value args[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 将第二个参数转为int32类型的数字
    int32_t infoType;
    napi_get_value_int32(env, args[1], &infoType);
    size_t byteLength;
    void *data;
    napi_value arrayBuffer;
    size_t byteOffset;
    // 定义枚举类型与ArkTS侧枚举类型InfoType顺序含义一致
    enum InfoType { BYTE_LENGTH = 0, ARRAY_BUFFER, BYTE_OFFSET };
    // 获取dataview信息
    napi_get_dataview_info(env, args[0], &byteLength, &data, &arrayBuffer, &byteOffset);
    napi_value result;
    switch (infoType) {
        case BYTE_LENGTH:
            // 返回查询DataView的字节数
            napi_value napiByteLength;
            napi_create_int32(env, byteLength, &napiByteLength);
            result = napiByteLength;
            break;
        case ARRAY_BUFFER:
            // 返回查询DataView的arraybuffer
            result = arrayBuffer;
            break;
        case BYTE_OFFSET:
            // 返回查询DataView的偏移字节量
            napi_value napiByteOffset;
            napi_create_int32(env, byteOffset, &napiByteOffset);
            result = napiByteOffset;
            break;
        default:
            break;
    }
    return result;
}

接口声明

// index.d.ts
export const getDataViewInfo: (dataView: DataView, infoType: number) => ArrayBuffer | number;

ArkTS侧示例代码

import hilog from '@ohos.hilog'
import testNapi from 'libentry.so'

// 创建一个ArrayBuffer
let arrayBuffer = new Int8Array([2, 5]).buffer;
// 使用arrayBuffer创建一个dataView
let dataView = new DataView(arrayBuffer);
// 定义一个枚举类型
enum InfoType {
    BYTE_LENGTH = 0,
    ARRAY_BUFFER = 1,
    BYTE_OFFSET = 2,
};
// 传入DataView类型参数查询DataView的字节数
hilog.info(0x0000, 'Node-API', 'get_dataview_info_bytelength %{public}d', testNapi.getDataViewInfo(dataView, InfoType.BYTE_LENGTH));
// 传入DataView类型参数查询DataView的ArrayBuffer
let arrbuff = testNapi.getDataViewInfo(dataView, InfoType.ARRAY_BUFFER) as ArrayBuffer;
// 将arraybuffer转为数组
let arr = Array.from(new Int8Array(arrbuff));
hilog.info(0x0000, 'Node-API', 'get_dataview_info_arraybuffer %{public}s', arr.toString());
// 传入DataView类型参数查询DataView开始投影的数据缓冲区中的字节偏移量
hilog.info(0x0000, 'Node-API', 'get_dataview_info_byteoffset %{public}d', testNapi.getDataViewInfo(dataView, InfoType.BYTE_OFFSET));

以上代码如果要在native cpp中打印日志,需在CMakeLists.txt文件中添加以下配置信息(并添加头文件:#include "hilog/log.h"):

// CMakeLists.txt
add_definitions( "-DLOG_DOMAIN=0xd0d0" )
add_definitions( "-DLOG_TAG=\"testTag\"" )
target_link_libraries(entry PUBLIC libhilog_ndk.z.so)

鸿蒙二进制数组创建 c++层数据都是二进制,需要转换成arrayBuffer透传到ets层给业务使用,但是鸿蒙的使用下面两个api创建出来的二进制数组数据都是错误的。 阅读详情

相关推荐

N-Api&C++ array buffer数据传递预处理

【代码】N-Api&C++ array buffer数据传递预处理。

Hens_Hello_Mr的博客 1846

鸿蒙TypeScript入门学习第11天【Array(数组)】

数组对象是使用单独的变量名来存储一系列的值。数组非常常用。这样看起来就简洁多了。如果数组声明时未设置类型,则会被认为是 any 类型,在初始化时根据第一个元素的类型来推断数组的类型。

鸿蒙的技术博客 4708

Godot引擎HarmonyOS支付与账号SDK开发实战:架构设计与安全实现

在移动应用开发中,应用内支付(IAP)和统一账号系统是支撑产品商业化的核心技术组件。其原理在于通过安全的授权与交易流程,连接用户、应用与支付渠道,实现数字商品与服务的变现。这项技术的核心价值在于为开发者提供了标准化的商业闭环解决方案,能有效提升用户支付体验、保障交易安全,并便于跨平台生态整合。典型的应用场景广泛覆盖游戏、工具软件及订阅服务等领域。本文聚焦于为跨平台游戏引擎Godot适配HarmonyOS生态,深入探讨如何通过三层桥接架构(Godot C++模块、JNI层、HarmonyOS服务层)解决引擎与

weixin_30634661的博客 399

鸿蒙5.0开发进阶:NDK开发-使用Node-API接口进行array相关开发

使用Node-API接口进行数组(array)相关开发时,涉及的基本概念主要包括数组的创建、访问、修改、遍历以及与数组相关的操作。

Androidbye的博客 1384

Godot游戏集成HarmonyOS支付与账号SDK:GDExtension桥接实战

在跨平台游戏开发中,原生系统服务调用是连接游戏逻辑与平台生态的核心技术。其原理在于通过桥接层,将游戏引擎的脚本环境与操作系统的原生API进行通信,通常涉及JNI或Native API交互。这项技术的价值在于,它使开发者能够在不重写核心游戏逻辑的前提下,无缝接入平台的商业化、用户认证等关键能力,从而提升应用的变现效率和用户体验。在应用场景上,尤其适用于需要在特定操作系统(如HarmonyOS)上实现应用内购买、订阅服务或统一账号登录的游戏项目。本文以Godot引擎为例,详细阐述了如何通过GDExtension

weixin_30258901的博客 359

Simulink实战:火电机组一次调频与AGC协同控制建模与仿真解析

本文详细解析了如何使用Simulink进行火电机组一次调频与AGC协调控制的建模与仿真。通过系统架构设计、参数设置和模块实现,阐述了如何实现两者的协同控制,确保电网频率稳定。文章提供了实用的建模技巧、参数整定经验和性能评估方法,为电力系统仿真工程师提供了有价值的实践指导。

c7d8e9的博客 310

鸿蒙5.0&next开发【使用Node-API接口进行array相关开发】NDK开发

使用Node-API接口进行array相关开发时,调用相关接口可以在Node-API模块中直接操作和处理ArkTS中的数组。

bbq的博客 949

学习C++的递归函数(包含汉诺塔讲解)

简单来讲,递归函数就是函数本身自己调用自己,那么函数又是什么呢?#include <stdio.h> //这行是头文件,不同的头文件可以用不同的函数int main() //这里就是一个main函数//这里是你要编写程序的内容return 0;(这是个小细节如下)所以我们平时用来练习的就是一个main函数,而且是一个整型类型的函数,而这也是最后一句话为什么要加一句 return 0;了,因为它最后要返回整数类型,其它整数也可以,但是大家规定为0,这是C++自带的函数。

2302_81032013的博客 2596

鸿蒙 NDK开发:Array相关交互(十一)

本文介绍了Node-API中操作ArkTS数组、TypedArray和DataView的核心接口及使用方法。主要内容包括: 数组操作:通过napi_create_array等接口创建、访问和修改数组元素; TypedArray处理:支持创建Int8Array等类型化数组,并获取其属性信息; DataView操作:实现二进制数据的灵活读写; 使用示例:提供了创建数组、判断类型、设置元素等典型场景的代码实现; 注意事项:强调类型检查、索引范围验证等关键点。 这些接口为NDK开发中处理ArkTS数组数据提供了标准

梦想不只是梦与想的博客 281

常用的串口通信工具MobaXterm、Bus Hound、SScom等

本文介绍了四种PC端串口通信工具的功能和使用方法:MobaXterm支持SSH、FTP、串口等多种协议;Bus Hound用于监控CAN和串口数据;SScom专为串口和网口通信设计;ScriptCommunicator可进行串口通信并绘制波形图。每种工具都有详细的操作步骤图示,包括参数设置、数据监控等关键功能,并提供了官方和个人下载地址。这些工具各有特点,适用于不同的串口通信和数据分析场景。

sanqima的专栏 2534

存储关键技术·RAID技术·RAID2.0·华为RAID2.0+·华为服务器·云计算

一.RAID基本概念 常见的RAID级别组合RAID级别 二.RAID的数据组织形式 三.RAID的数据保护功能 方法一:镜像方法二:奇偶校验算法(XOR) 四.RAID热备和重构 1.热备(Hot Spare)的定义2.热备的分类3.热备的工作原理 五.RAID 2.0技术 1.RAID 2.02.RAID 2.0+3.华为RAID 2.0+ 六.RAID 2.0+块虚拟化技术 1.什么会出现RAID 2.0+技术?2.什么是RAID 2.0?3.RAID 2.0+的原理是什么?

qq_47480932的博客 3320

鸿蒙5.0&next开发【跨语言调用复杂参数传递开发】NDK开发

开发者为了提高程序运行效率,通常需要将一些运算量较大的内容放在C++环境中运行,因此经常需要进行ArkTS与C++之间的数据传递。本文以常见的五种数据类型:Array(uint8Array)、Object、HashMap、PixelMap、Class为例,向开发者介绍如何进行复杂参数的跨语言传递。

zhenggaoxiao232的博客 986

高通SA8295P音频接口深度解析:全面掌握SA8295P的LS-I2S、PCM/TDM与高性能音频处理技术设计

SA8295P提供丰富的音频接口选项,包括LS-I2S、PCM/TDM和HS-I2S接口,具备灵活的配置选项,适合各种高保真音频和高速数据传输应用。结合LS-I2S和PCM/TDM接口:在复杂的音频编解码器设计中,可结合使用LS-I2S和PCM/TDM接口,以处理和传输不同的音频数据流。使用HS-I2S接口:在软件定义无线电(SDR)系统中,高速I2S接口可处理高速数据流,如无线电信号的解码和处理。LS-I2S(低速I2S)接口是SA8295P的一部分,提供了丰富的音频数据传输选项。

weixin_43199439的博客 1410

鸿蒙NDK实战:JSVM-API桥接WebAssembly实现高性能计算

WebAssembly(Wasm)是一种为高性能计算设计的二进制指令格式,它允许C/C++、Rust等语言编译成可在多种环境中安全、高效运行的字节码。其核心原理是提供接近原生速度的沙箱化执行环境,通过线性内存模型和精简指令集实现跨平台性能优化。在移动应用开发中,尤其在处理图像渲染、音视频编解码、物理模拟等计算密集型任务时,Wasm能有效突破JavaScript引擎的性能瓶颈。鸿蒙(HarmonyOS)的JSVM-API为原生层与JavaScript引擎提供了交互通道,结合NDK(Native Develop

weixin_30314793的博客 273

使用Qt编译Qt WebEngine

这就是使用Qt编译Qt WebEngine模块的基本步骤。通过按照上述步骤,您应该能够成功编译和使用Qt WebEngine来嵌入Web内容到您的Qt应用程序中。Qt WebEngine是Qt框架的一个模块,它提供了一个现代的Web浏览器引擎,可以在Qt应用程序中嵌入Web内容。首先,需要获取Qt的源代码。如果尚未安装,可以从Qt官方网站下载并安装Qt。完成Qt的安装后,您可以构建并运行Qt WebEngine示例来验证编译是否成功。这将把编译好的Qt库文件和头文件安装到之前指定的安装目录中。

DevForge的博客 3020

把 NAST 变成你的遥控器:用 ABAP 程序精确触发与处理 Output Type

摘要 SAP中的Message Control机制通过NAST表记录输出状态,支持自动触发打印、邮件等操作。关键步骤包括: 构造NAST记录:定义输出类型、介质、处理状态等参数 调用处理函数:使用RV_MESSAGE_UPDATE_SINGLE更新表,通过WFMC_MESSAGES_PROCESS执行输出 典型应用场景: 单据补发(如PO邮件重发) 外部系统集成触发输出 故障恢复处理积压消息 注意事项: 需提交事务确保更新生效 区分S/4HANA新旧输出体系 正确处理派发时间(VSZTP)和状态(VSTAT

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 261

鸿蒙NDK开发:ArkTS与C++基础类型转换实战指南

在跨平台应用开发中,数据类型转换是连接不同编程语言生态的核心基础。其原理在于建立一套类型映射机制,通过接口描述语言(IDL)约定和通用值容器(如napi_value),在保证类型安全的前提下实现高效数据传递。这项技术的价值在于能够复用成熟的C/C++原生库,直接操作硬件,从而显著提升应用性能,尤其在图形处理、音视频编解码等计算密集型场景中至关重要。在鸿蒙应用开发中,NDK(Native Development Kit)正是实现这一目标的关键工具,它通过显式类型转换机制,让ArkTS与C++能够安全对话。本文

weixin_30945039的博客 415

详解AUTOSAR:DaVinci Configurator导入ARXML配置(拓展篇—2)

DaVinci Configurator导入ARXML配置。

不脱发的程序猿 3337

在鸿蒙 PC 上用 Rust 写一个 2048:ArkTS 负责界面,Rust 负责灵魂

鸿蒙应用的主力语言是 ArkTS(声明式 UI,类 TypeScript)。但很多场景下,我们希望把核心逻辑游戏规则、状态机这类纯逻辑,用 Rust 写既安全又好测,还能脱离 UI 单独跑单元测试;同一份 Rust 逻辑未来可复用到其它平台;鸿蒙提供 N-API(Node-API)桥接,ohos.rs把 napi-rs 适配到了鸿蒙,让 Rust 函数可以像 C++ native 模块一样被 ArkTSimport。逻辑层:纯 Rust,编译为cdylib,导出一个Game类。桥接。

DecorateCC的博客 5585

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

HarmonyOS 鸿蒙原生应用调用 C/C++ 三方库 —— NAPI 开发完整指南

本文系统介绍NAPI(Node-API)在HarmonyOS中的使用方法,帮助开发者实现ArkTS与C/C++代码的互操作。主要内容包括: NAPI核心概念:介绍napi_env、napi_value等关键概念及模块注册机制 开发环境配置:详细说明工程配置、CMake设置和类型声明 开发全流程:从函数编写、参数获取到类型转换和模块注册的完整步骤 数据类型转换:覆盖数值、字符串、布尔值、数组等类型的双向转换方法 实战指导:提供完整示例、API速查表、调试技巧和常见问题解决方案 文章强调NAPI在性能计算、复用

猫哥 的沉淀、积累、总结。天天学习,好好向上...c/c++,嵌入式 linux,Android,HarmonyOS,AIOT) 1217

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

面试题kkk

这篇文章摘要主要涵盖了Android开发中的核心知识点和技术难点,包括数据结构、Java与Kotlin语言特性、多线程与并发、内存管理、安卓组件与UI、IPC通信、数据库、多媒体处理、设计模式、性能优化、跨端开发等多个方面。文章详细解析了常见数据结构的使用与实现、JVM机制、内存泄漏分析与解决方案、Activity生命周期、事件分发机制、Handler原理、音视频处理、设计模式应用等核心内容,并提供了实际项目中的技术卡点与解决方案。此外,还涉及了性能优化策略、跨端开发差异、技术方案设计思路以及Git常用命令

mix39的博客 933

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

鸿蒙 Array<类型> 和 类型[] 区别是什么

虽然两者在语法上等价,但在类型检查的严格性上有所不同。使用Array时,TypeScript会进行更严格的类型检查。// 错误,因为包含非数字元素string`在这种情况下,使用Array可以提供更严格的类型保护,确保数组中的每个元素都符合指定的类型。在鸿蒙开发中,Array和类型[]在语法上是等价的,它们都可以用来声明一个数组。‌在鸿蒙开发中,Array和类型[]在语法上是等价的,它们都表示一个数组类型。这两种写法在功能上是完全相同的,都是声明了一个包含整数的数组。

亮亮的博客 337

鸿蒙HarmonyOS4.0开发应用学习笔记

鸿蒙harmonyos4.0学习笔记

用作学习记录 4852

HarmonyOS开发:ArkTs常见数据类型(一)

本文针对开发中常用的数据类型,做一个简单的概述,便于第一次接触到ArkTs语言开发的同学,能够快速的对数据类型做一个了解。

知足常乐 4045

C++对JS Object的操作

N-API提供一些API来创建JavaScript所有类型值。

Hens_Hello_Mr的博客 1419

JS中操作数组的方法(全)

元素,并返回该元素的值。此方法会更改数组的长度。

weixin_55697644的博客 4430
上一篇: 鸿蒙5.0开发进阶:NDK代码开发-Node-API使用指南(使用Node-API扩展能力接口)
下一篇: 鸿蒙5.0开发进阶:NDK代码开发-Node-API使用指南(使用Node-API接口进行ArrayBuffer相关开发)
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值