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

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

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


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

简介

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

基本概念

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

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

接口说明

接口功能说明
OH_JSVM_CreateArray创建一个新的 JavaScript 数组对象
OH_JSVM_CreateArrayWithLength创建一个指定长度的 JavaScript 数组对象
OH_JSVM_CreateTypedarray在现有的 ArrayBuffer 上创建一个 JavaScript TypedArray 对象,TypedArray 对象在底层数据缓冲区上提供类似数组的视图,其中每个元素都具有相同的底层二进制标量数据类型。需要注意,对于入参有以下要求:(length * size_of_element) + byte_offset 要不大于传入数组的大小(以字节为单位),size_of_element 指数组中元素的数据类型的大小,否则会引发 RangeError 异常。
OH_JSVM_CreateDataview在现有的 ArrayBuffer 上创建一个 JavaScript DataView 对象,DataView 对象在底层数据缓冲区上提供类似数组的视图,该 ArrayBuffer 允许有不同大小和类型的元素。要求 byte_length + byte_offset 小于或等于传入数组的字节大小,否则会引发 RangeError 异常。
OH_JSVM_GetArrayLength返回 Array 对象的长度
OH_JSVM_GetTypedarrayInfo获取 TypedArray(类型化数组)对象的信息
OH_JSVM_GetDataviewInfo获取 Dataview 对象的信息
OH_JSVM_IsArray判断一个 JavaScript 对象是否为 Array 类型对象
OH_JSVM_SetElement在给定对象的指定索引处设置元素
OH_JSVM_GetElement获取给定对象指定索引处的元素
OH_JSVM_HasElement若给定对象的指定索引处拥有属性,获取该元素
OH_JSVM_DeleteElement尝试删除给定对象的指定索引处的元素
OH_JSVM_IsDataview判断一个 JavaScript 对象是否为 Dataview 类型对象
OH_JSVM_IsTypedarray判断一个 JavaScript 对象是否为 Typedarray 类型对象

使用示例

JSVM-API 接口开发流程参考使用 JSVM-API 实现 JS 与 C/C++ 语言交互开发流程,本文仅对接口对应 C++ 相关代码进行展示。

OH_JSVM_CreateArray

创建一个新的 JavaScript 数组对象。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// CreateArray注册回调
static int DIFF_VALUE_FIVE = 5;
// OH_JSVM_CreateArray的样例方法
static JSVM_Value CreateArray(JSVM_Env env, JSVM_CallbackInfo info)
{
    // 创建一个空数组
    JSVM_Value array = nullptr;
    JSVM_Status status = OH_JSVM_CreateArray(env, &array);
    // 对创建的数组进行赋值
    for (int i = 0; i < DIFF_VALUE_FIVE; i++) {
        JSVM_Value element;
        OH_JSVM_CreateInt32(env, i, &element);
        OH_JSVM_SetElement(env, array, i, element);
    }
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM CreateArray fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM CreateArray success");
    }
    return array;
}
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = CreateArray},
};
static JSVM_CallbackStruct *method = param;
// CreateArray方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"createArray", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
  function testCreateArray() {
    return createArray();
  }
  testCreateArray();
)JS";

OH_JSVM_CreateArrayWithLength

创建一个指定长度的 JavaScript 数组对象。

cpp 部分代码:

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_CreateArrayWithLength的样例方法
static JSVM_Value CreateArrayWithLength(JSVM_Env env, JSVM_CallbackInfo info)
{
    size_t argc = 1;
    JSVM_Value argv[1] = {nullptr};
    JSVM_Value result = nullptr;
    // 解析传递的参数OH_JSVM_GetCbInfo
    OH_JSVM_GetCbInfo(env, info, &argc, argv, nullptr, nullptr);
    // 获取传递的数组长度
    int32_t length;
    OH_JSVM_GetValueInt32(env, argv[0], &length);
    // 使用OH_JSVM_CreateArrayWithLength创建传递固定长度的数组
    JSVM_Status status = OH_JSVM_CreateArrayWithLength(env, length, &result);
    if (status == JSVM_OK) {
        // 给创建的数组设置值
        for (int32_t i = 0; i < length; i++) {
            JSVM_Value value;
            OH_JSVM_CreateInt32(env, i, &value);
            OH_JSVM_SetElement(env, result, i, value);
        }
        OH_LOG_INFO(LOG_APP, "JSVM CreateArrayWithLength success");
    } else {
        OH_LOG_ERROR(LOG_APP, "JSVM CreateArrayWithLength fail");
    }
    return result;
}
// CreateArrayWithLength注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = CreateArrayWithLength},
};
static JSVM_CallbackStruct *method = param;
// CreateArrayWithLength方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"createArrayWithLength", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let num = 7;
function testCreateArrayWithLength(num){
    return createArrayWithLength(num);
}
testCreateArrayWithLength(num);
)JS";

OH_JSVM_CreateTypedarray

在现有的 ArrayBuffer上 创建一个 JavaScript TypedArray 对象,TypedArray 对象在底层数据缓冲区上提供类似数组的视图,其中每个元素都具有相同的底层二进制标量数据类型。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_CreateTypedarray的样例方法
static int DIFF_VALUE_THREE = 3;
static JSVM_Value CreateTypedArray(JSVM_Env env, JSVM_CallbackInfo info)
{
    size_t argc = 1;
    JSVM_Value args[1] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    int32_t typeNum;
    OH_JSVM_GetValueInt32(env, args[0], &typeNum);
    JSVM_TypedarrayType arrayType;
    // 用于存储每个元素的大小
    size_t elementSize = 0;
    // 转换为JSVM_TypedarrayType类型
    arrayType = static_cast<JSVM_TypedarrayType>(typeNum);
    switch (typeNum) {
    case JSVM_INT8_ARRAY:
    case JSVM_UINT8_ARRAY:
    case JSVM_UINT8_CLAMPED_ARRAY:
        elementSize = sizeof(int8_t);
        break;
    case JSVM_INT16_ARRAY:
    case JSVM_UINT16_ARRAY:
        elementSize = sizeof(int16_t);
        break;
    case JSVM_INT32_ARRAY:
    case JSVM_UINT32_ARRAY:
        elementSize = sizeof(int32_t);
        break;
    case JSVM_FLOAT32_ARRAY:
        elementSize = sizeof(float);
        break;
    case JSVM_FLOAT64_ARRAY:
        elementSize = sizeof(double);
        break;
    case JSVM_BIGINT64_ARRAY:
    case JSVM_BIGUINT64_ARRAY:
        elementSize = sizeof(int64_t);
        break;
    default:
        // 默认创建JSVM_INT8_ARRAY类型
        arrayType = JSVM_INT8_ARRAY;
        elementSize = sizeof(int8_t);
        break;
    }
    size_t length = DIFF_VALUE_THREE;
    JSVM_Value arrayBuffer = nullptr;
    JSVM_Value typedArray = nullptr;
    void *data;
    // 创建一个ArrayBuffer
    OH_JSVM_CreateArraybuffer(env, length * elementSize, (void **)&data, &arrayBuffer);
    // 根据给定类型创建TypedArray
    JSVM_Status status = OH_JSVM_CreateTypedarray(env, arrayType, length, arrayBuffer, 0, &typedArray);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM CreateTypedArray fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM CreateTypedArray success");
    }
    return typedArray;
}
// CreateTypedArray注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = CreateTypedArray},
};
static JSVM_CallbackStruct *method = param;
// CreateTypedArray方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"createTypedArray", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
const type = {
    INT8_ARRAY: 0,
    UINT8_ARRAY: 1,
    UINT8_CLAMPED_ARRAY: 2,
    INT16_ARRAY: 3,
    UINT16_ARRAY: 4,
    INT32_ARRAY: 5,
    UINT32_ARRAY: 6,
    FLOAT32_ARRAY: 7,
    FLOAT64_ARRAY: 8,
    BIGINT64_ARRAY: 9,
    BIGUINT64_ARRAY: 10
};
createTypedArray(type.INT8_ARRAY);
createTypedArray(type.INT32_ARRAY);
)JS";

OH_JSVM_CreateDataview

在现有的 ArrayBuffer 上创建一个 JavaScript DataView 对象,DataView 对象在底层数据缓冲区上提供类似数组的视图。

cpp部分代码

static int DIFF_VALUE_FOUR = 4;
static int DIFF_VALUE_TWELVE = 12;
// OH_JSVM_CreateDataview的样例方法
static JSVM_Value CreateDataView(JSVM_Env env, JSVM_CallbackInfo info)
{
    // 获取js侧传入的两个参数
    size_t argc = 2;
    JSVM_Value args[2] = {nullptr};
    JSVM_Value arrayBuffer = nullptr;
    JSVM_Value result = nullptr;
    // DataView的字节长度
    size_t byteLength = DIFF_VALUE_TWELVE;
    // 字节偏移量
    size_t byteOffset = DIFF_VALUE_FOUR;
    // 获取回调函数的参数信息
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 将参数转换为对象类型
    OH_JSVM_CoerceToObject(env, args[0], &arrayBuffer);
    // 创建一个数据视图对象,并指定字节长度和字节偏移量
    JSVM_Status status = OH_JSVM_CreateDataview(env, byteLength, arrayBuffer, byteOffset, &result);
    // 获取DataView的指针和长度信息
    uint8_t *data = nullptr;
    size_t length = 0;
    // 为DataView赋值
    for (size_t i = 0; i < length; i++) {
        data[i] = static_cast<uint8_t>(i + 1);
    }
    int32_t infoType;
    OH_JSVM_GetValueInt32(env, args[1], &infoType);
    size_t returnLength;
    JSVM_Value returnArrayBuffer = nullptr;
    size_t returnOffset;
    enum InfoType { BYTE_LENGTHE, ARRAY_BUFFERE, BYTE_OFFSET };
    // 获取dataview信息
    OH_JSVM_GetDataviewInfo(env, result, &returnLength, (void **)&data, &returnArrayBuffer, &returnOffset);
    JSVM_Value returnResult = nullptr;
    switch (infoType) {
    case BYTE_LENGTHE:
        JSVM_Value len;
        OH_JSVM_CreateInt32(env, returnLength, &len);
        returnResult = len;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM CreateDataView fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM CreateDataView success, returnLength: %{public}d", returnLength);
        }
        break;
    case ARRAY_BUFFERE:
        bool isArraybuffer;
        OH_JSVM_IsArraybuffer(env, returnArrayBuffer, &isArraybuffer);
        JSVM_Value isArray;
        OH_JSVM_GetBoolean(env, isArraybuffer, &isArray);
        returnResult = isArray;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM CreateDataView fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM CreateDataView success, isArraybuffer: %{public}d", isArraybuffer);
        }
        break;
    case BYTE_OFFSET:
        JSVM_Value offset;
        OH_JSVM_CreateInt32(env, returnOffset, &offset);
        returnResult = offset;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM CreateDataView fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM CreateDataView success, returnOffset: %{public}d", returnOffset);
        }
        break;
    default:
        break;
    }
    return returnResult;
}
// CreateDataView注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = CreateDataView},
};
static JSVM_CallbackStruct *method = param;
// CreateDataView方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"createDataView", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
 let BYTE_LENGTH = 0;
 createDataView(new ArrayBuffer(16), BYTE_LENGTH);
 let IS_ARRAYBUFFER = 1;
 createDataView(new ArrayBuffer(16), IS_ARRAYBUFFER);
 let BYTE_OFFSET = 2;
 createDataView(new ArrayBuffer(16), BYTE_OFFSET);
)JS";

OH_JSVM_GetArrayLength

返回 Array 对象的长度。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_GetArrayLength的样例方法
static JSVM_Value GetArrayLength(JSVM_Env env, JSVM_CallbackInfo info)
{
    size_t argc = 1;
    JSVM_Value args[1] = {nullptr};
    JSVM_Value result = nullptr;
    uint32_t length;
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 检查参数是否为数组
    bool isArray = false;
    OH_JSVM_IsArray(env, args[0], &isArray);
    if (!isArray) {
        OH_LOG_INFO(LOG_APP, "JSVM Argument must be an array");
        return nullptr;
    }
    OH_JSVM_GetArrayLength(env, args[0], &length);
    // 创建返回值
    OH_JSVM_CreateInt32(env, length, &result);
    OH_LOG_INFO(LOG_APP, "JSVM length: %{public}d", length);
    return result;
}
// GetArrayLength注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = GetArrayLength},
};
static JSVM_CallbackStruct *method = param;
// GetArrayLength方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"getArrayLength", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let data = [0, 1, 2, 3, 4, 5];
getArrayLength(data);
)JS";

OH_JSVM_GetTypedarrayInfo

获取 TypedArray(类型化数组)对象的信息。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_GetTypedarrayInfo的样例方法
static JSVM_Value GetTypedArrayInfo(JSVM_Env env, JSVM_CallbackInfo info)
{
    // 获取并解析参数,第一个参数为需要获得的信息的TypedArray类型数据,第二个参数为需要获得的信息类型的枚举值
    size_t argc = 2;
    JSVM_Value args[2] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);

    // 将第二个参数转为int32类型便于比较
    int32_t infoTypeParam;
    OH_JSVM_GetValueInt32(env, args[1], &infoTypeParam);
    // 定义枚举类型与ArkTS侧枚举类型infoType顺序含义一致
    enum InfoType { INFO_TYPE, INFO_LENGTH, INFO_ARRAY_BUFFER, INFO_BYTE_OFFSET };
    void *data;
    JSVM_TypedarrayType type;
    size_t byteOffset, length;
    JSVM_Value arrayBuffer = nullptr;
    // 调用接口OH_JSVM_GetTypedarrayInfo获得TypedArray类型数据的信息
    JSVM_Status status = OH_JSVM_GetTypedarrayInfo(env, args[0], &type, &length, &data, &arrayBuffer, &byteOffset);
    JSVM_Value result = nullptr;
    // 根据属性名,返回TypedArray对应的属性值
    switch (infoTypeParam) {
    case INFO_TYPE:
        // 如果传入的参数是int8类型的TypedArray数据,它的类型(type)为JSVM_INT8_ARRAY
        JSVM_Value int8_type;
        OH_JSVM_GetBoolean(env, type == JSVM_INT8_ARRAY, &int8_type);
        result = int8_type;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetTypedArrayInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetTypedArrayInfo success, JSVM_INT8_ARRAY: %{public}d", type == JSVM_INT8_ARRAY);
        }
        break;
    case INFO_LENGTH:
        // TypedArray中的元素数
        JSVM_Value jsvmLength;
        OH_JSVM_CreateInt32(env, length, &jsvmLength);
        result = jsvmLength;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetTypedArrayInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetTypedArrayInfo success, length: %{public}d", length);
        }
        break;
    case INFO_BYTE_OFFSET:
        // TypedArray数组的第一个元素所在的基础原生数组中的字节偏移量
        JSVM_Value jsvmOffset;
        OH_JSVM_CreateInt32(env, byteOffset, &jsvmOffset);
        result = jsvmOffset;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetTypedArrayInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetTypedArrayInfo success, byteOffset: %{public}d", byteOffset);
        }
        break;
    case INFO_ARRAY_BUFFER:
        // TypedArray下的ArrayBuffer
        bool isArrayBuffer;
        OH_JSVM_IsArraybuffer(env, arrayBuffer, &isArrayBuffer);
        JSVM_Value isArray;
        OH_JSVM_GetBoolean(env, isArrayBuffer, &isArray);
        result = isArray;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetTypedArrayInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetTypedArrayInfo success, isArrayBuffer: %{public}d", isArrayBuffer);
        }
        break;
    default:
        break;
    }
    return result;
}
// GetTypedArrayInfo注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = GetTypedArrayInfo},
};
static JSVM_CallbackStruct *method = param;
// GetTypedArrayInfo方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"getTypedArrayInfo", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
// is JSVM_INT8_ARRAY
getTypedArrayInfo(new Int8Array(3), 0);
// length
getTypedArrayInfo(new Int8Array(5), 1);
// is_arraybuffer
getTypedArrayInfo(new Int8Array(5), 2);
// byteoffset
getTypedArrayInfo(new Int8Array(1), 3);
)JS";

OH_JSVM_GetDataviewInfo

获取 Dataview 对象的信息。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_GetDataviewInfo的样例方法
static JSVM_Value GetDataViewInfo(JSVM_Env env, JSVM_CallbackInfo info)
{
    // 获取并解析参数,第一个参数为需要获得的信息的DataView类型数据,第二个参数为需要获得的信息类型的枚举值
    size_t argc = 2;
    JSVM_Value args[2] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 将第二个参数转为int32类型的数字
    int32_t infoType;
    OH_JSVM_GetValueInt32(env, args[1], &infoType);
    size_t byteLength;
    void *data;
    JSVM_Value arrayBuffer = nullptr;
    size_t byteOffset;
    // 定义枚举类型与ArkTS侧枚举类型infoType顺序含义一致
    enum infoTypeEnum { BYTE_LENGTHE, ARRAY_BUFFERE, BYTE_OFFSET };
    // 获取dataview信息
    JSVM_Status status = OH_JSVM_GetDataviewInfo(env, args[0], &byteLength, &data, &arrayBuffer, &byteOffset);
    JSVM_Value result = nullptr;
    switch (infoType) {
    case BYTE_LENGTHE:
        // 返回查询DataView的长度
        JSVM_Value len;
        OH_JSVM_CreateInt32(env, byteLength, &len);
        result = len;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetDataViewInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetDataViewInfo success, byteLength: %{public}d", byteLength);
        }
        break;
    case ARRAY_BUFFERE:
        // 判断DataView的Info里的arraybuffer是否为arraybuffer
        bool isArrayBuffer;
        OH_JSVM_IsArraybuffer(env, arrayBuffer, &isArrayBuffer);
        JSVM_Value isArray;
        OH_JSVM_GetBoolean(env, isArrayBuffer, &isArray);
        result = isArray;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetDataViewInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetDataViewInfo success, isArrayBuffer: %{public}d", isArrayBuffer);
        }
        break;
    case BYTE_OFFSET:
        // 返回查询DataView的偏移量
        JSVM_Value offset;
        OH_JSVM_CreateInt32(env, byteOffset, &offset);
        result = offset;
        if (status != JSVM_OK) {
            OH_LOG_ERROR(LOG_APP, "JSVM GetDataViewInfo fail");
        } else {
            OH_LOG_INFO(LOG_APP, "JSVM GetDataViewInfo success, byteOffset: %{public}d", byteOffset);
        }
        break;
    default:
        break;
    }
    return result;
}
// GetDataViewInfo注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = GetDataViewInfo},
};
static JSVM_CallbackStruct *method = param;
// GetDataViewInfo方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"getDataViewInfo", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
// bytelength
getDataViewInfo(new DataView(new Int8Array([2,5]).buffer), 0);
// is arraybuffer
let data = 'a';
let isarraybuffer = 1;
getDataViewInfo(data, isarraybuffer);
// is arraybuffer
data = new DataView(new Int8Array([2,5,3]).buffer);
isarraybuffer = 1;
getDataViewInfo(data, isarraybuffer);
// byte_offset
data = new DataView(new Int8Array([2,5,3]).buffer);
isarraybuffer = 2;
getDataViewInfo(data, isarraybuffer);
)JS";

OH_JSVM_IsArray

判断一个 JavaScript 对象是否为 Array 类型对象。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_IsArray的样例方法
static JSVM_Value IsArray(JSVM_Env env, JSVM_CallbackInfo info)
{
    size_t argc = 1;
    JSVM_Value args[1] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    bool result = false;
    JSVM_Status status = OH_JSVM_IsArray(env, args[0], &result);
    JSVM_Value returnValue = nullptr;
    OH_JSVM_GetBoolean(env, result, &returnValue);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM IsArray fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM IsArray success, IsArray: %{public}d", result);
    }
    return returnValue;
}
// IsArray注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = IsArray},
};
static JSVM_CallbackStruct *method = param;
// IsArray方法别名,TS侧调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"isArray", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let data = [1, 2, 3, 4, 5];
isArray(data);
)JS";

OH_JSVM_SetElement

在给定对象的指定索引处设置元素。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_SetElement的样例方法
static int DIFF_VALUE_THREE = 3;
static JSVM_Value SetElement(JSVM_Env env, JSVM_CallbackInfo info) {
    size_t argc = DIFF_VALUE_THREE;
    JSVM_Value args[3] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    int32_t index = 0;
    OH_JSVM_GetValueInt32(env, args[1], &index);
    JSVM_Status status = OH_JSVM_SetElement(env, args[0], index, args[2]);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM SetElement fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM SetElement success");
    }
    return args[0];
}
// SetElement注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = SetElement},
};
static JSVM_CallbackStruct *method = param;
// SetElement方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"setElement", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
setElement(3);
)JS";

OH_JSVM_GetElement

获取给定对象指定索引处的元素。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_GetElement的样例方法
static JSVM_Value GetElement(JSVM_Env env, JSVM_CallbackInfo info) {
    // 获取js侧传入的两个参数
    size_t argc = 2;
    JSVM_Value args[2] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 获取请求元素的索引值
    uint32_t index;
    OH_JSVM_GetValueUint32(env, args[1], &index);
    // 获取请求索引位置的元素值并存储在result中
    JSVM_Value result = nullptr;
    JSVM_Status status = OH_JSVM_GetElement(env, args[0], index, &result);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM GetElement fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM GetElement success");
    }
    return result;
}
// GetElement注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = GetElement},
};
static JSVM_CallbackStruct *method = param;
// GetElement方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"getElement", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let arr = [10, 'hello', null, true];
getElement(arr, 3);
)JS";

OH_JSVM_HasElement

若给定对象的指定索引处拥有属性,获取该元素。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_HasElement的样例方法
static JSVM_Value HasElement(JSVM_Env env, JSVM_CallbackInfo info)
{
    // 获取js侧传入的两个参数
    size_t argc = 2;
    JSVM_Value args[2] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 获取要判断的元素的索引
    uint32_t index;
    OH_JSVM_GetValueUint32(env, args[1], &index);
    // 判断指定索引位置的元素是否存在
    bool hasElement = true;
    JSVM_Status status = OH_JSVM_HasElement(env, args[0], index, &hasElement);
    // 将boolean结果转换为JSVM_Value并返回
    JSVM_Value result = nullptr;
    OH_JSVM_GetBoolean(env, hasElement, &result);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM hasElement fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM hasElement: %{public}d", hasElement);
    }
    return result;
}
// HasElement注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = HasElement},
};
static JSVM_CallbackStruct *method = param;
// HasElement方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"hasElement", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let arr = [10, 'hello', null, true];
hasElement(arr, 0);
hasElement(arr, 4);
)JS";

OH_JSVM_DeleteElement

尝试删除给定对象的指定索引处的元素。

cpp部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_DeleteElement的样例方法
static JSVM_Value DeleteElement(JSVM_Env env, JSVM_CallbackInfo info) {
    // 获取js侧传入的两个参数
    size_t argc = 2;
    JSVM_Value args[2] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 获取要删除的元素的索引
    uint32_t index;
    OH_JSVM_GetValueUint32(env, args[1], &index);
    // 尝试删除请求索引位置的元素
    bool deleted = true;
    JSVM_Status status = OH_JSVM_DeleteElement(env, args[0], index, &deleted);
    // 将boolean结果转换为JSVM_Value并返回
    JSVM_Value result = nullptr;
    OH_JSVM_GetBoolean(env, deleted, &result);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM DeleteElement fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM DeleteElement: %{public}d", deleted);
    }
    return result;
}
// DeleteElement注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = DeleteElement},
};
static JSVM_CallbackStruct *method = param;
// DeleteElement方法别名,供JS调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"deleteElement", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let arr = [10, 'hello', null, true];
deleteElement(arr, 0);
)JS";

OH_JSVM_IsDataview

判断一个 JavaScript 对象是否为 Dataview类型对象。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_IsDataview的样例方法
static JSVM_Value IsDataView(JSVM_Env env, JSVM_CallbackInfo info) {
    size_t argc = 1;
    JSVM_Value args[1] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    // 调用OH_JSVM_IsDataview接口判断给定入参是否为DataView数据。
    bool result = false;
    JSVM_Status status = OH_JSVM_IsDataview(env, args[0], &result);
    JSVM_Value isDateView = nullptr;
    OH_JSVM_GetBoolean(env, result, &isDateView);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM IsDataView fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM IsDataView: %{public}d", result);
    }
    return isDateView;
}
// IsDataView注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = IsDataView},
};
static JSVM_CallbackStruct *method = param;
// IsDataView方法别名,TS侧调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"isDataView", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
let buffer = new ArrayBuffer(16);
let dataView = new DataView(buffer);
isDataView(dataView);
)JS";

OH_JSVM_IsTypedarray

判断一个 JavaScript 对象是否为 Typedarray 类型对象。

cpp 部分代码

// hello.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <hilog/log.h>
// OH_JSVM_IsTypedarray的样例方法
static JSVM_Value IsTypedarray(JSVM_Env env, JSVM_CallbackInfo info) {
    size_t argc = 1;
    JSVM_Value args[1] = {nullptr};
    OH_JSVM_GetCbInfo(env, info, &argc, args, nullptr, nullptr);
    bool result = false;
    JSVM_Status status = OH_JSVM_IsTypedarray(env, args[0], &result);
    JSVM_Value isTypedArray = nullptr;
    OH_JSVM_GetBoolean(env, result, &isTypedArray);
    if (status != JSVM_OK) {
        OH_LOG_ERROR(LOG_APP, "JSVM IsTypedarray fail");
    } else {
        OH_LOG_INFO(LOG_APP, "JSVM IsTypedarray: %{public}d", result);
    }
    return isTypedArray;
}
// IsTypedarray注册回调
static JSVM_CallbackStruct param[] = {
    {.data = nullptr, .callback = IsTypedarray},
};
static JSVM_CallbackStruct *method = param;
// IsTypedarray方法别名,TS侧调用
static JSVM_PropertyDescriptor descriptor[] = {
    {"isTypedarray", nullptr, method++, nullptr, nullptr, nullptr, JSVM_DEFAULT},
};
// 样例测试js
const char *srcCallNative = R"JS(
isTypedarray(new Uint16Array([1, 2, 3, 4]));
)JS";

HarmonyOS Next开发学习手册——JSVM-API调试&定位 JSVM,既标准JS引擎,是严格遵守Ecmascript规范的JavaScript代码执行引擎。详情参考: JSVM。基于JSVM的JS代码调试调优能力包括:Debugger、CPU Profiler、Heap Snapshot、Heap Statistics。本文将介绍调试、CPU Profiler、Heap Snapshot的使用方法。 阅读详情

相关推荐

鸿蒙二进制数组创建

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

2401_82772199的博客 1805

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

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

鸿蒙的技术博客 4708

鸿蒙入门实战-ArkTS开发

ArkTS通过struct声明组件名,并通过@Component和@Entry装饰器,来构成一个自定义组件。使用@Entry和@Component装饰的自定义组件作为页面的入口,会在页面加载时首先进行渲染。@Entry@Component例如ToDoList组件对应如下整个代办页面。图1ToDoList待办列表使用@Component装饰的自定义组件,如ToDoItem这个自定义组件则对应如下内容,作为页面的组成部分。@Component图2ToDoItem。

m0_62167422的博客 1788

JSVM实现可伸缩视频编码(SVC)

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、JSVM安装和测试1.安装2.测试二、编码2.解码3.解码SVC视频 前言 这篇文章主要介绍了Ubuntu16.04下如何使用JSVM来实现可伸缩视频编码。主要参考了https://github.com/ChristianKreuzberger/DASH-SVC-Toolchain和https://blog.csdn.net/qq_41895113/article/details/80561218 提示:以下是本篇文章正

sf1256的博客 1858

Java服务端虚拟机JSVM参考软件解析

本文还有配套的精品资源,点击获取 简介:Java服务端虚拟机(JSVM)是Java平台的重要组成部分,负责执行Java字节码。本教程深入解析了JSVM的架构、优化技术、应用场景、调试工具、安全性以及未来的发展方向,旨在帮助开发者深入了解和优化Java应用的运行机制。 1. Java虚拟机架构详解 1.1 Java虚拟机的基本概念 Java虚拟机(JVM...

weixin_32099703的博客 1604

从零构建基于ZYNQ与AD9361的SDR信号源:FPGA逻辑与射频前端的协同设计

本文详细介绍了从零开始构建基于ZYNQ与AD9361的SDR信号源的完整流程。通过解析FPGA逻辑与射频前端的协同设计,重点阐述了如何利用FPGA生成基带信号,并通过ARM处理器配置AD9361,最终实现一个可编程的2.4GHz载波信号发生器。内容涵盖硬件选型、Vivado环境搭建、AXI总线通信、LVDS接口设计及软件驱动开发,为SDR开发者提供了实用的实战指南。

weixin_29200485的博客 215

探秘JSVM:一款为编译器学习者打造的JavaScript虚拟机

探秘JSVM:一款为编译器学习者打造的JavaScript虚拟机 在编程世界里,理解底层运作机制是提升技能的关键一步。今天,我们向您推荐一个专为编译器和字节码研究者设计的开源项目——JSVM(JavaScript Virtual Machine)。这个项目将帮助您更直观地测试和调试类似汇编语言的代码。 1. 指令集:简单而强大 JSVM采用了一种简单的指令集,包括定义标签、推送栈值、数据存储和各种...

gitblog_00092的博客 740

STM32学习笔记【江科协】【4-2】OLED显示屏

可以注意到接电源的GND和VCC同时和PB6、PB7号口连接,我们可以直接不初始化这两个引脚解决,因为STM32的引脚上电后,如果不初始化,默认是浮空输入的模式,在这个模式下,引脚不会输出电平,所以不会有什么影响,或者直接给PB6口输出低电平,PB7口输出高电平,用GPIO口直接给OLED供电,这个也是没问题的,因为OLED的功率很小这个也是可以驱动的,不过用GPIO口供电不是很规范,实际项目还是用电源供电。然后点击这里放大镜里面带d的图标,进入调试模式,这个界面里,

m0_74651303的博客 1595

JSVM介绍

JSVM是 Scalable Video Coding (SVC) 的参考代码. 目前还在开发中. JSVM 提供了 Visual Studio & GCC 4.0 两种编译方案. JSVM Solution 中包含了多个 Project。 分别是     ( 1 ) 库      H264AVCCommonLibStatic :  SVC的基本库  , 同时被编码和解码

暂时为空 3351

什么是论文的创新点?公式化描述算是创新点吗?

写科研论文时,挑战之一就是如何让你的工作“脱颖而出”,也就是要有创新性。不管实验多么精确、推导多么复杂,若没有真正的创新,论文很可能会被拒。关于如何创新问题上,我最近在看刘雪峰老师的《科技论文写作指南》,看到了很多关于写作的新论述,在这里和大家进行分享。

加百力 的技术博客 1928

SAP MTO实战:从销售订单到生产订单的精准触发与配置详解

本文深入解析SAP系统中按订单生产(MTO)模式的核心流程与配置。详细阐述了如何通过精准配置物料主数据策略组、需求类型及计划策略(如策略50),实现从销售订单自动触发生产订单的完整链路。文章结合实战案例,指导用户打通销售与生产环节,并提供了关键事务代码与常见问题排查指南,助力企业实现以销定产,优化库存与成本控制。

weixin_29300931的博客 217

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

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

weixin_30314793的博客 273

车载面试题目(ADAS)

多数功能都是依靠的前置传感器(经过Lidar、Radar、Camera融合),比如ACC、AEB、LKA、NOA、TJA、FCW等,只有少数涉及周视传感器,比如BSD、CVW、DOW。③如果前面有车切速度小于自车车速,自车减速对减速度有要求,比如3.5m/m2,④如果前车静止了,自车有个跟停距离要求,比如2-3m。试验场有不同曲率的弯道,比如125m、250m、500m的,根据需求跟车行驶,看是否会减速,能不能驶出弯道等。迭代内容:底层通讯、网络管理、诊断、刷写、信息安全、OTA。

qq_43475097的博客 2298

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

鸿蒙harmonyos4.0学习笔记

用作学习记录 4852

COMSOL报错调试总结(不定期更新)

COMSOL报错调试总结1. 可定位错误1.1 除零错误1.2 未定义变量值1.3 边界条件/材料属性等缺失2. 难定位错误2.1. 装配期间内存不足 官方给的案例总是非常完美,运行流畅,结果完美。但是自己做模型时候就总是报错,而且不像自己coding的程序那样可以明确定位哪里出了bug。这里把我碰到的一些报错问题以及调试方法记录下来~ 部分来源于以下参考来源: http://wap.sciencenet.cn/blog-1467490-1118453.html?mobile=1 1. 可定位错误 以下错误

jessica0307的博客 8万+

Visual Studio Installer下载失败的5种修复方法(含DNS修改/补丁安装)

本文针对Visual Studio Installer下载安装文件失败的问题,提供了从网络层到系统层的深度排查与修复指南。详细介绍了DNS修改、代理配置、防火墙设置、系统服务检查等5种核心修复方法,并包含离线安装与手动补丁等替代方案,帮助开发者彻底解决安装难题。

sprite的博客 1630

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

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

亮亮的博客 337

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

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

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

Androidbye的博客 1384

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

JSVM使用简介

做毕业设计之中,研究了很久JSVM的使用。本来是想到网上,看一下人家的简介的,结果什么也没找到。所以,就自己对它的使用文档研究了一翻。其实,只看jsvm的sofeware menu是看不懂怎么用的。后来,经过不断的探讨,我基本上摸透了这个软件。由于,这样很多人都来问我。所以,我这里直接写出来,跟大家分享好了。    注意事项:   (1)由于,我使用的是windows系统,所以下面都是局限于w

nkwangjie的专栏 2318

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

JSVM基础实验

1. SVC基础知识   关于SVC的基本意义,可以参看【1】【2】【3】中的论述。SVC(scalable video coding)的可分级视频编码概念,简而言之,就是把视频序列分成不同的部分并赋予不同的等级,这样的思想已经渊源流传,并非H.264/SVC所独创。2007年由ITU推出的H.264/SVC标准,继承了H.264的高效压缩性,随着网络应用的普及,SVC的灵活码流适应性和对不同

lanzily99的专栏 2737

JSVM的安装与运行

Jsvm的安装稍简单,只需要将jsvm文件夹拷贝进虚拟机,再进行make就好了。具体操作如下:找到JSVM文件夹,将文件全部复制到虚拟机 打开终端,进入jsvm-&gt;JSVM-&gt;H264Extension-&gt;build-&gt;linux,进行make 这样就安装好了编码尝试首先尝试单层编码模式,回到jsvm目录下,进入bin文件夹,新建文档,我命名为one_level.cfg,打...

qq_41895113的博客 2832

鸿蒙开发的知识点(ArkTS阶段)

ArkTS相关知识点

weixin_60387218的博客 3529

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

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

weixin_55697644的博客 4430

揭秘OpenHarmony“御用”JSVM:从V8内核到毫秒级启动的引擎实战解析

OpenHarmony JSVM 是基于 V8 引擎的 JavaScript 虚拟机实现,采用分层架构设计,实现了高效的 JavaScript 执行环境与 OpenHarmony 系统的深度集成。创建JSVM_Env__实例。创建Platform线程池。OpenHarmony系统。JavaScript源码。返回Isolate实例。返回Context实例。封装为JSVM_Env。封装为JSVM_VM。

m0_67505153的博客 1216

JSVM2 使用说明

1.序言... 2.JSVM2 框架介绍... 3.JSVM2 使用说明... 3.1如何在页面上部署jsvm环境。... 3.2如何设置当前jsvm的环境变量。... 3.3如何使用jsvm中的类 3.JSVM2 使用说明 3.1如何在页面上部署jsvm环境。 JSVM2 软件包中有一个引导文件:jsre.js, 在页面中创建一个 <script&g...

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值