鸿蒙5.0开发进阶:NDK开发-使用JSVM-API接口创建多个引擎执行JS代码并销毁

鸿蒙开发实战(HarmonyOS)JSVM-API支持的数据类型和接口 是一个枚举数据类型,表示JSVM-API接口返回的状态信息。 阅读详情

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


场景介绍

开发者通过createJsCore方法来创建一个新的JS基础运行时环境,并通过该方法获得一个CoreID,通过evaluateJS方法使用CoreID对应的运行环境来运行JS代码,在JS代码中创建promise并异步调取TS侧设定的callback函数,最后使用releaseJsCore方法来释放CoreID对应的运行环境。

使用示例

1.接口声明和编译配置

接口声明

// index.d.ts
export const createJsCore: (fun: Function) => number;
export const releaseJsCore: (a: number) => void;
export const evaluateJS: (a: number, str: string) => string;

编译配置

// CMakeLists.txt
# the minimum version of CMake.
cmake_minimum_required(VERSION 3.4.1)
project(MyApplication)

set(NATIVERENDER_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})

if(DEFINED PACKAGE_FIND_FILE)
include(${PACKAGE_FIND_FILE})
endif()

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

add_library(entry SHARED create_jsvm_runtime.cpp)
target_link_libraries(entry PUBLIC libace_napi.z.so libjsvm.so libhilog_ndk.z.so)

2.新建多个JS运行时环境并运行JS代码


// create_jsvm_runtime.cpp
#include "napi/native_api.h"
#include "ark_runtime/jsvm.h"
#include <bits/alltypes.h>
#include <deque>
#include <map>
#include <unistd.h>
#include <hilog/log.h>
#include <cstring>
#include <string>
#include <vector>
#include <sstream>

#define LOG_TAG "TEST_TAG"
// 用于获取并抛出最后一个错误信息。通过OH_JSVM_GetLastErrorInfo获取错误信息,
// 如果没有挂起的异常且错误信息存在,则通过 OH_JSVM_ThrowError 抛出错误。
#define GET_AND_THROW_LAST_ERROR(env) \
do { \
const JSVM_ExtendedErrorInfo* errorInfo = nullptr; \
OH_JSVM_GetLastErrorInfo((env), &errorInfo); \
bool isPending = false; \
OH_JSVM_IsExceptionPending((env), &isPending); \
JSVM_Value error; \
if (isPending && JSVM_OK == OH_JSVM_GetAndClearLastException((env), &error)) { \
\
JSVM_Value stack; \
OH_JSVM_GetNamedProperty((env), error, "stack", &stack); \
\
JSVM_Value message; \
OH_JSVM_GetNamedProperty((env), error, "message", &message); \
\
char stackstr[256]; \
OH_JSVM_GetValueStringUtf8(env, stack, stackstr, 256, nullptr); \
OH_LOG_INFO(LOG_APP, "JSVM error stack: %{public}s", stackstr); \
char messagestr[256]; \
OH_JSVM_GetValueStringUtf8(env, message, messagestr, 256, nullptr); \
OH_LOG_INFO(LOG_APP, "JSVM error message: %{public}s", messagestr); \
} \
if (!isPending && errorInfo != nullptr) { \
const char* errorMessage = \
errorInfo->errorMessage != nullptr ? errorInfo->errorMessage : "empty error message"; \
OH_JSVM_ThrowError((env), nullptr, errorMessage); \
} \
} while (0)

// 用于调用theCall并检查其返回值是否为JSVM_OK。
// 如果不是,则调用GET_AND_THROW_LAST_ERROR处理错误并返回retVal。
#define JSVM_CALL_BASE(env, theCall, retVal) \
do { \
if ((theCall) != JSVM_OK) { \
GET_AND_THROW_LAST_ERROR((env)); \
return retVal; \
} \
} while (0)

// JSVM_CALL_BASE的简化版本,返回nullptr
#define JSVM_CALL(env, theCall) JSVM_CALL_BASE(env, theCall, nullptr)

using namespace std;
// 定义map管理每个独立vm环境
static map<int, JSVM_VM*> g_vmMap;
static map<int, JSVM_Env*> g_envMap;
static map<int, napi_env> g_napiEnvMap;
static map<int, napi_ref> g_callBackMap;
static map<int, JSVM_CallbackStruct*> g_callBackStructMap;
static uint32_t ENVTAG_NUMBER = 0;
static std::mutex envMapLock;
static int aa = 0;

class Task {
public:
virtual ~Task() = default;
virtual void Run() = 0;
};
static map<int, deque<Task *>> g_taskQueueMap;

// 自定义Consoleinfo方法
static JSVM_Value Consoleinfo(JSVM_Env env, JSVM_CallbackInfo info) {
size_t argc = 1;
JSVM_Value args[1];
char log[256] = "";
size_t log_length;
OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL);

OH_JSVM_GetValueStringUtf8(env, args[0], log, 255, &log_length);
log[255] = 0;
OH_LOG_INFO(LOG_APP, "JSVM API TEST: %{public}s", log);
return nullptr;
}

// 自定义创建Promise方法用以在JS代码中创建Promise
static JSVM_Value CreatePromise(JSVM_Env env, JSVM_CallbackInfo info) {
OH_LOG_INFO(LOG_APP, "JSVM API TEST: CreatePromise start");
int envID = 0;
// 通过当前env获取envID
for (auto it = g_envMap.begin(); it != g_envMap.end(); ++it) {
if (*it->second == env) {
envID = it->first;
break;
}
}
if (envID == -1) {
OH_LOG_INFO(LOG_APP, "JSVM API TEST: CreatePromise envID faild");
return nullptr;
}
JSVM_Value promise;
JSVM_Deferred deferred;
OH_JSVM_CreatePromise(env, &deferred, &promise);
// 设计ReadTask类用以将promise对象的deferred加入执行队列
class ReadTask : public Task {
public:
ReadTask(JSVM_Env env, JSVM_Deferred deferred, int envNum) : env_(env), envID_(envNum), deferred_(deferred) {}
void Run() override {
//string str = "TEST RUN OH_JSVM_ResolveDeferred";
int envID = 0;
for (auto it = g_envMap.begin(); it != g_envMap.end(); ++it) {
if (*it->second == env_) {
envID = it->first;
break;
}
}
OH_LOG_INFO(LOG_APP, "JSVM API TEST: CreatePromise %{public}d", envID);
JSVM_Value result;
OH_JSVM_CreateInt32(env_, envID, &result);
OH_JSVM_ResolveDeferred(env_, deferred_, result);
}
private:
JSVM_Env env_;
int envID_;
JSVM_Deferred deferred_;
};
g_taskQueueMap[envID].push_back(new ReadTask(env, deferred, envID));
OH_LOG_INFO(LOG_APP, "JSVM API TEST: CreatePromise end");
return promise;
}

// 自定义Add方法
static JSVM_Value Add(JSVM_Env env, JSVM_CallbackInfo info) {
size_t argc = 2;
JSVM_Value args[2];
OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL);
double num1, num2;
OH_JSVM_GetValueDouble(env, args[0], &num1);
OH_JSVM_GetValueDouble(env, args[1], &num2);
JSVM_Value sum = nullptr;
OH_JSVM_CreateDouble(env, num1 + num2, &sum);
return sum;
}

// 自定义AssertEqual方法
static JSVM_Value AssertEqual(JSVM_Env env, JSVM_CallbackInfo info) {
size_t argc = 2;
JSVM_Value args[2];
JSVM_CALL(env, OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL));

bool isStrictEquals = false;
OH_JSVM_StrictEquals(env, args[0], args[1], &isStrictEquals);

if (isStrictEquals) {
OH_LOG_INFO(LOG_APP, "JSVM API TEST RESULT: PASS");
} else {
OH_LOG_INFO(LOG_APP, "JSVM API TEST RESULT: FAILED");
}
return nullptr;
}

// 用以在native层中调用TS侧传入的Callback函数
static JSVM_Value OnJSResultCallback(JSVM_Env env, JSVM_CallbackInfo info) {
size_t argc = 3;
JSVM_Value args[3];
JSVM_CALL(env, OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL));
int callId = 0;
OH_JSVM_GetValueInt32(env, args[0], &callId);
napi_value callArgs[2] = {nullptr, nullptr};
size_t size;
size_t size1;

OH_JSVM_GetValueStringUtf8(env, args[1], nullptr, 0, &size);
char Str1[size + 1];
OH_JSVM_GetValueStringUtf8(env, args[1], Str1, size + 1, &size);

OH_JSVM_GetValueStringUtf8(env, args[2], nullptr, 0, &size1);
char Str2[size1 + 1];
OH_JSVM_GetValueStringUtf8(env, args[2], Str2, size1 + 1, &size1);

napi_create_string_utf8(g_napiEnvMap[callId], Str1, size + 1, &callArgs[0]);
napi_create_string_utf8(g_napiEnvMap[callId], Str2, size1 + 1, &callArgs[1]);
napi_value callback = nullptr;
// 通过callId获取在创建当前JSVM环境时传入的TS回调方法
napi_get_reference_value(g_napiEnvMap[callId], g_callBackMap[callId], &callback);
napi_value ret;
// 执行TS回调方法
napi_call_function(g_napiEnvMap[callId], nullptr, callback, 2, callArgs, &ret);
char retStr[256];
napi_get_value_string_utf8(g_napiEnvMap[callId], ret, retStr, 256, &size);

JSVM_Value returnVal;
OH_JSVM_CreateStringUtf8(env, retStr, JSVM_AUTO_LENGTH, &returnVal);
return returnVal;
}

std::string napiValueToString(napi_env env, napi_value nValue) {
size_t buffLen = 0;
napi_get_value_string_utf8(env, nValue, nullptr, 0, &buffLen);
char buffer[buffLen + 1];
napi_get_value_string_utf8(env, nValue, buffer, buffLen + 1, &buffLen);

return buffer;
}

static std::string fromOHStringValue(JSVM_Env &env, JSVM_Value &value) {
size_t size;
JSVM_Status status;
status = OH_JSVM_GetValueStringUtf8(env, value, nullptr, 0, &size);
char resultStr[size + 1];
status = OH_JSVM_GetValueStringUtf8(env, value, resultStr, size + 1, &size);
return resultStr;
}

static void CreateArkJSContext() {
JSVM_Status status;
JSVM_InitOptions init_options;
memset(&init_options, 0, sizeof(init_options));
if (aa == 0) {
OH_JSVM_Init(&init_options);
aa++;
}

// 虚拟机实例
g_vmMap[ENVTAG_NUMBER] = new JSVM_VM;
JSVM_CreateVMOptions options;
memset(&options, 0, sizeof(options));
status = OH_JSVM_CreateVM(&options, g_vmMap[ENVTAG_NUMBER]);
JSVM_VMScope vmScope;
OH_JSVM_OpenVMScope(*g_vmMap[ENVTAG_NUMBER], &vmScope);

// 新环境
g_envMap[ENVTAG_NUMBER] = new JSVM_Env;
g_callBackStructMap[ENVTAG_NUMBER] = new JSVM_CallbackStruct[5];

// 注册用户提供的本地函数的回调函数指针和数据,通过JSVM-API暴露给js
for (int i = 0; i < 5; i++) {
g_callBackStructMap[ENVTAG_NUMBER][i].data = nullptr;
}
g_callBackStructMap[ENVTAG_NUMBER][0].callback = Consoleinfo;
g_callBackStructMap[ENVTAG_NUMBER][1].callback = Add;
g_callBackStructMap[ENVTAG_NUMBER][2].callback = AssertEqual;
g_callBackStructMap[ENVTAG_NUMBER][3].callback = OnJSResultCallback;
g_callBackStructMap[ENVTAG_NUMBER][4].callback = CreatePromise;
JSVM_PropertyDescriptor descriptors[] = {
{"consoleinfo", NULL, &g_callBackStructMap[ENVTAG_NUMBER][0], NULL, NULL, NULL, JSVM_DEFAULT},
{"add", NULL, &g_callBackStructMap[ENVTAG_NUMBER][1], NULL, NULL, NULL, JSVM_DEFAULT},
{"assertEqual", NULL, &g_callBackStructMap[ENVTAG_NUMBER][2], NULL, NULL, NULL, JSVM_DEFAULT},
{"onJSResultCallback", NULL, &g_callBackStructMap[ENVTAG_NUMBER][3], NULL, NULL, NULL, JSVM_DEFAULT},
{"createPromise", NULL, &g_callBackStructMap[ENVTAG_NUMBER][4], NULL, NULL, NULL, JSVM_DEFAULT},
};
status = OH_JSVM_CreateEnv(*g_vmMap[ENVTAG_NUMBER], sizeof(descriptors) / sizeof(descriptors[0]), descriptors, g_envMap[ENVTAG_NUMBER]);
OH_JSVM_CloseVMScope(*g_vmMap[ENVTAG_NUMBER], vmScope);
}

// 提供创建JSVM运行环境的对外接口并返回对应唯一ID
static napi_value CreateJsCore(napi_env env1, napi_callback_info info) {
OH_LOG_ERROR(LOG_APP, "JSVM CreateJsCore START");
size_t argc = 1;
napi_value argv[1];
napi_get_cb_info(env1, info, &argc, argv, nullptr, nullptr);
if (argc < 1) {
OH_LOG_ERROR(LOG_APP, "JSVM CreateJsCore the number of params must be one");
return nullptr;
}
g_napiEnvMap[ENVTAG_NUMBER] = env1;
g_taskQueueMap[ENVTAG_NUMBER] = deque<Task *>{};
// 将TS侧传入的回调函数与env对应存储方便后续调用
napi_ref callFun;
napi_create_reference(env1, argv[0], 1, &callFun);
g_callBackMap[ENVTAG_NUMBER] = callFun;
napi_value coreID = 0;
{
std::lock_guard<std::mutex> lock_guard(envMapLock);
CreateArkJSContext();
napi_create_uint32(env1, ENVTAG_NUMBER, &coreID);
ENVTAG_NUMBER++;
}
OH_LOG_ERROR(LOG_APP, "JSVM CreateJsCore END");
return coreID;
}

// 对外提供释放JSVM环境接口,通过envId释放对应环境
static napi_value ReleaseJsCore(napi_env env1, napi_callback_info info) {
OH_LOG_ERROR(LOG_APP, "JSVM ReleaseJsCore START");
size_t argc = 1;
napi_value argv[1];
napi_get_cb_info(env1, info, &argc, argv, nullptr, nullptr);
if (argc < 1) {
OH_LOG_ERROR(LOG_APP, "JSVM ReleaseJsCore the number of params must be one");
return nullptr;
}

uint32_t coreEnvId;
napi_status status = napi_get_value_uint32(env1, argv[0], &coreEnvId);
if (status != napi_ok) {
OH_LOG_ERROR(LOG_APP, "JSVM CreateJsCore napi_get_value_uint32 faild");
return nullptr;
}
if (g_envMap.count(coreEnvId) == 0 ) {
OH_LOG_ERROR(LOG_APP, "JSVM CreateJsCore not has env ");
return nullptr;
}
if (g_envMap[coreEnvId] != nullptr) {
std::lock_guard<std::mutex> lock_guard(envMapLock);
OH_JSVM_DestroyEnv(*g_envMap[coreEnvId]);
g_envMap[coreEnvId] = nullptr;
g_envMap.erase(coreEnvId);
OH_JSVM_DestroyVM(*g_vmMap[coreEnvId]);
g_vmMap[coreEnvId] = nullptr;
g_vmMap.erase(coreEnvId);
delete [] g_callBackStructMap[coreEnvId];
g_callBackStructMap[coreEnvId] = nullptr;
g_callBackStructMap.erase(coreEnvId);
napi_delete_reference(env1, g_callBackMap[coreEnvId]);
g_callBackMap.erase(coreEnvId);
g_taskQueueMap.erase(coreEnvId);
}
OH_LOG_ERROR(LOG_APP, "JSVM ReleaseJsCore END");
return nullptr;
}

static std::mutex mutexLock;
// 对外提供执行JS代码接口,通过coreID在对应的JSVN环境中执行JS代码
static napi_value EvaluateJS(napi_env env, napi_callback_info info) {
OH_LOG_ERROR(LOG_APP, "JSVM EvaluateJS START");
size_t argc = 2;
napi_value args[2] = {nullptr};
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
uint32_t envId;
napi_status status = napi_get_value_uint32(env, args[0], &envId);
if (status != napi_ok) {
OH_LOG_ERROR(LOG_APP, "EvaluateJS first param should be number");
return nullptr;
}

if (g_envMap.count(envId) == 0 || g_envMap[envId] == nullptr) {
OH_LOG_ERROR(LOG_APP, "EvaluateJS env is null");
return nullptr;
}
std::string dataStr = napiValueToString(env, args[1]);
napi_value res = nullptr;
std::lock_guard<std::mutex> lock_guard(mutexLock);
{
// open vm scope
JSVM_VMScope vmscope;
OH_JSVM_OpenVMScope(*g_vmMap[envId], &vmscope);
// open env scope
JSVM_EnvScope envscope;
OH_JSVM_OpenEnvScope(*g_envMap[envId], &envscope);
// open handle scope
JSVM_HandleScope handlescope;
OH_JSVM_OpenHandleScope(*g_envMap[envId], &handlescope);
// compile js script
JSVM_Value sourcecodevalue;
OH_JSVM_CreateStringUtf8(*g_envMap[envId], dataStr.c_str(), dataStr.size(), &sourcecodevalue);
JSVM_Script script;
OH_JSVM_CompileScript(*g_envMap[envId], sourcecodevalue, nullptr, 0, true, nullptr, &script);
// run js script
JSVM_Value result;
OH_JSVM_RunScript(*g_envMap[envId], script, &result);
JSVM_ValueType type;
OH_JSVM_Typeof(*g_envMap[envId], result, &type);
OH_LOG_INFO(LOG_APP, "JSVM API TEST type: %{public}d", type);
// Execute tasks in the current env event queue
while (!g_taskQueueMap[envId].empty()) {
auto task = g_taskQueueMap[envId].front();
g_taskQueueMap[envId].pop_front();
task->Run();
delete task;
}

if (type == JSVM_STRING) {
std::string stdResult = fromOHStringValue(*g_envMap[envId], result);
napi_create_string_utf8(env, stdResult.c_str(), stdResult.length(), &res);
} else if (type == JSVM_BOOLEAN) {
bool ret = false;
std::string stdResult;
OH_JSVM_GetValueBool(*g_envMap[envId], result, &ret);
ret ? stdResult = "true" : stdResult = "false";
napi_create_string_utf8(env, stdResult.c_str(), stdResult.length(), &res);
} else if (type == JSVM_NUMBER) {
int32_t num;
OH_JSVM_GetValueInt32(*g_envMap[envId], result, &num);
std::string stdResult = std::to_string(num);
napi_create_string_utf8(env, stdResult.c_str(), stdResult.length(), &res);
} else if (type == JSVM_OBJECT) {
JSVM_Value objResult;
OH_JSVM_JsonStringify(*g_envMap[envId], result, &objResult);
std::string stdResult = fromOHStringValue(*g_envMap[envId], objResult);
napi_create_string_utf8(env, stdResult.c_str(), stdResult.length(), &res);
}
bool aal = false;
OH_JSVM_PumpMessageLoop(*g_vmMap[envId], &aal);
OH_JSVM_PerformMicrotaskCheckpoint(*g_vmMap[envId]);
OH_JSVM_CloseHandleScope(*g_envMap[envId], handlescope);
OH_JSVM_CloseEnvScope(*g_envMap[envId], envscope);
OH_JSVM_CloseVMScope(*g_vmMap[envId], vmscope);
}
OH_LOG_ERROR(LOG_APP, "JSVM EvaluateJS END");
return res;
}

模块注册

// create_jsvm_runtime.cpp
EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports) {
    napi_property_descriptor desc[] = {
        {"createJsCore", nullptr, CreateJsCore, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"releaseJsCore", nullptr, ReleaseJsCore, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"evaluateJS", nullptr, EvaluateJS, nullptr, nullptr, nullptr, napi_default, nullptr}
    };

    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
    return exports;
}
EXTERN_C_END

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

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

3.ArkTS侧示例代码

import { hilog } from '@kit.PerformanceAnalysisKit';
import testNapi from 'libentry.so';

function MyCallback(a:string, b:string):string {
    console.log("TEST MyCallback run: " + a);
    b = "callback done";
    console.log("TEST MyCallback run: " + b);
    return "callback pass";
}

function MyCallback2(a:string, b:string):string {
  console.log("TEST MyCallback2 start: a =  " + a);
  console.log("TEST MyCallback2 start: b =  " + b);
  return "MyCallback2 pass";
}

@Entry
@Component
struct Index {
  @State message: string = 'Hello World';

  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            let sourcecodestr = `{
          let a = "hello World";
          consoleinfo(a);
          const mPromise = createPromise();
          mPromise.then((result) => {
          assertEqual(result, 0);
          onJSResultCallback(result, "abc", "v");
          });
          a;
          };`;

            let sourcecodestr1 = `{
          let a = "second hello";
          consoleinfo(a);
          let b = add(99, 1);
          assertEqual(100, b);
          assertEqual(add(99, 1), 100);
          createPromise().then((result) => {
          assertEqual(result, 1);
          consoleinfo(onJSResultCallback(result, '999','666'));
          });
          a;
          };`;

            // 创建首个运行环境,并绑定TS回调
            const coreId = testNapi.createJsCore(MyCallback);
            console.log("TEST coreId: " + coreId);
            // 在首个运行环境中执行JS代码
            console.log("TEST evaluateJS :   " + testNapi.evaluateJS(coreId, sourcecodestr));

            //创建第二个运行环境,并绑定TS回调
            const coreId1 = testNapi.createJsCore(MyCallback2);
            console.log("TEST coreId: " + coreId1);
            // 在第二个运行环境中执行JS代码
            console.log("TEST evaluateJS :   " + testNapi.evaluateJS(coreId1, sourcecodestr1));

            // 释放首个运行环境
            testNapi.releaseJsCore(coreId);
            // 释放第二个运行环境
            testNapi.releaseJsCore(coreId1);
            hilog.info(0x0000, 'testTag', 'Test NAPI end');
          })
      }
      .width('100%')
    }
    .height('100%')
  }
}

鸿蒙第16篇——数据持久化 本文介绍的数据持久化是指鸿蒙应用的数据持久化存储。它是将内存中的数据通过文件或数据库的形式保存到设备存储中。鸿蒙支持多种数据存储方式, 包括用户首选项Preferences、 键值型数据库KV-Store和关系型数据库。 阅读详情

相关推荐

Java判断地图坐标(经度,纬度)是否在多边形区域或圆形区域内

​欢迎光临我的博客查看最新文章:在地图上,可以使用经纬度确定一个位置,如上海体育场(121.449391,31.188228),如果知道了2个地点的经纬度,我们就能在地图上找到其位置及2点的距离,百度地图或高德地图提供了相应的服务;如果将多个坐标点连成多边形区域,如何判断某个坐标点是否在多边形区域内,如下工具类。

river106的博客 3945

鸿蒙HarmonyOS开发之单例

单例模式确保一个类只有一个实例,并提供一个全局访问点来获取这个实例。

qq_14863717的博客 2951

【PyBind11+anaconda+opencv+windows11+cmake+wsl+vscode】从入门到跑通。构建基于opencv c++的python package

如何安装请详见上文 【PyBind11+anaconda+opencv+windows11+cmake+wsl+vscode】从入门到跑通。构建基于opencv c++的python接口_子韵如初的博客-优快云博客w不需要安装啥x11 、 xming直接mobxterm可以搞定点击右上角的X server打开可视化服务器然后 apt install x11-apps -yxclock 搞定从mobxterm可以看到display的端口X11显示可视化的原理是就是通过X协议,类似于http对linux于w

weixin_43953700的博客 3万+

鸿蒙仓颉语言【cryptocj 库】(介绍与SHA、MD5、HMAC摘要算法)

cryptocj 是一个安全的密码库,包括常用的密码算法、常用的密钥生成和签名验证。 该库是对 C 语言的 openSSL 封装的仓颉加密算法

鸿蒙的技术博客 1690

超实用!用ChimeraX对AlphaFold 结果可视化(中): 蛋白结构美化篇

而一般需要的背景颜色是无色(白色),有三种方法可以更改背景颜色,这里我们介绍两种方法,第三种在下一小节中讲解。如果想选中蛋白链中的某一结构区域或者某些位点,可以用Ctrl+Shift+鼠标左键,或在软件窗口中点击。在这个窗口中可以对蛋白的主链、侧链、表面等颜色进行修改,只用在。,即可在右下角看到我们蛋白的序列信息,在这里面直接用鼠标选择要选择的结构域。就会有更多的颜色供我们选择,如果有特定的色号还可以在这个界面继续选择。后面的颜色(②),就可以选择想要的任何背景颜色(③)。就可以选择软件推荐的常用颜色。

m0_63153079的博客 5494

我每天如何使用 ChatGPT

我偶尔会用这个功能作为开始。我本人非常喜欢阅读,让 ChatGPT 来概括所有文章,感觉就像身处于但丁描述的地狱的某个层次那样痛苦。然而,有时一些文章实在是太啰嗦、无聊,或者写得让人不愉快(比如一个无趣记者对一个让人讨厌的人进行的漫无焦点的采访)。我需要获取这些文章中的一些信息,以便保持信息的更新和了解。在晚期资本主义的广告经济下,很多文章只在一个段落里提供新信息,其余都是无聊的填充内容,只是为了展示糟糕的广告,这实在是对人们的时间和生命的一种浪费。我有几次利用 ChatGPT 来。

KevinDai007的博客 3786

鸿蒙中如何像Android一样finish销毁Activity

// Destroys the current ability slice. //这是销毁当前的slice terminate​() // Destroys the host ability. //然后销毁当前的Ability terminateAbility​() 举个栗子start一个新的Ability后销毁当前的ability需要下面3行代码 Intent intent_t = new Intent(); Operation operation1 = .

gsrkuang的博客 1906

RT-DETR升级:TGRS2026 CKConv结合RepC3 | 方向特征与跨阶段融合协同,小目标漏检率大幅下降

小目标鲁棒性提升:CKConv方向选择性抑制背景噪声,RepC3跨阶段传递保留深层微弱热信号,显著改善低对比度、低信噪比场景下的检测精度。

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 161

鸿蒙5.0开发进阶:NDK代码开发-JSVM-API调优&高性能使用案例(使用JSVM-API接口创建多个引擎执行JS代码并销毁)

开发者通过createJsCore方法来创建一个新的JS基础运行时环境..........

Androidbye的博客 343

C# WPF上位机开发(利用tcp/ip网络访问plc)

【 声明:版权所有,欢迎转载,请勿用于商业用途。 联系信箱:feixiaoxing @163.com】 c# wpf如果是用来开发非标上位机的,那么和plc的通信肯定是少不了的。而且,大部分plc都支持modbus协议,所以这个时候如果有一个库可以帮助我们和plc设备进行modbus通信,那就非常方便的。目前NuGet下关于modbus的函数库还是有一些的,比如EasyModbus。

嵌入式-老费,一个分享专业嵌入式知识的blog 2530

【ROS机器人系统】实验4 ROS简单应用:激光SLAM与导航

ROS简单应用:激光SLAM与导航 (1)了解机器人和SLAM之间关系 (2)了解激光SLAM (3)了解gmapping和导航

南京大学软件工程硕士在读 2148

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

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

weixin_30314793的博客 273

【SAP HANA 24】HANA与Oracle SQL语法对照表

HANA SQL参考及Oracle 语法对照

探索 Java 编程的技巧、最佳实践和解决方案。本博客提供针对 Java 开发者的实用指南,涵盖从基础到高级话题,旨在提升编程效率和技能。 1428

鸿蒙 PC ArkUI 实战:任务看板的跨列拖放与键盘移动

桌面看板得允许人改主意:拖着卡片经过另一列,最后也可能把它放回原处。把“开始拖”和“任务状态已变”当成同一件事,会让取消操作尤其难处理。以下分别用鼠标投放和卡片上的移动入口,验证同一张任务卡怎样完成状态变更。拖动桌面看板上的任务时,松手的位置才决定任务应该去哪。如果在拖起时就从原列移除卡片,用户拖出窗口或放回原列后,还要额外处理恢复。本例用「待处理、进行中、已完成」三列展示五条模拟任务。宽窗用鼠标拖放,窄窗用标签切换列表,卡片上的移动按钮也支持键盘。

程序猿追的博客 50

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

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

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

Flutter 修复 desktop_drop 鸿蒙电脑自由窗口文件拖拽:让非原点窗口准确命中并读取附件

修复鸿蒙版 desktop_drop 插件在窗口下半区拖放无响应及文件读取失败问题,通过修正坐标换算(扣除标题栏高度)与路径转换(剥离 file:// 协议头),确保文件准确交付。经双窗口复现验证,修复后可稳定接收并读取同沙箱文件,完整代码已提交至 CPF-Flutter 仓库,支持社区交流与后续维护。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 97

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

React Native 鸿蒙端侧 OCR 实战:TurboModule 与纯 TS 引擎的逐字契约

本文以鸿蒙真机上的 React Native 0.84 工程为例,详解三大难题:通过 TurboModule 接入 HarmonyOS Core Vision Kit 实现端侧离线 OCR;规避 Metro 预置头导致的 require 不存在问题;实现 npm 包与 HAR 双形态交付。项目采用 codegen 生成 ArkTS 接口,结合纯 TS 回退引擎,确保跨引擎逐字符一致,并通过 autolinking 支持无缝集成。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 113

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

20 嵌入式系统架构:架构模式、实时操作系统、鸿蒙案例

嵌入式架构模式怎么选、RTOS 和通用操作系统差在哪、优先级反转怎么破?本篇把前后台、中断驱动、管态目态几种结构排成一条演进线,手把手算 RMS 可调度界限、判断任务集能不能跑得动,再把优先级继承与优先级天花板两种解法对上号,配鸿蒙案例讲清工程落地。

weixin_46316564的博客 232

Flutter 修复 audio_waveforms 鸿蒙波形提取句柄与内存驻留:多段语音备忘录预览与切歌释放

修复 Flutter 鸿蒙版 audio_waveforms 库在语音备忘录连续预览与切歌时的资源泄漏问题,补全文件关闭、提取取消与播放器释放逻辑,通过两段式 Worker 停止机制与零字节 EOS 处理,实现 144 轮切换无句柄残留、内存稳定。修复版已提交至 CPF-Flutter/fluttertpc_audio_waveforms,支持鸿蒙系统高效波形提取与资源管理。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 31

鸿蒙 PC 桌面端应用上架实战:图匠流程图编辑器从上游 draw.io 发行包到 AGC 过审的 SIGABRT 收敛之路

鸿蒙 PC 桌面端应用上架实战:图匠流程图编辑器从上游 draw.io 发行包到 AGC 过审的 SIGABRT 收敛之路

wei_shuo的博客 1万+

RN鸿蒙空间音频实战

示例仓库:https://atomgit.com/m0_37170006/react-native-ohos-spatial-audio 社区导引:框架源码与版本发布见 https://atomgit.com/CPF-RN/ohos_react_native/tree/0.84-main CPF-RN 鸿蒙社区:https://atomgit.com/CPF-rn。

buhuisuanfa的博客 2万+

HarmonyOS PC 端适配实战:断点、分栏与键鼠交互

本文详解鸿蒙HarmonyOS在PC端的适配核心:以断点系统按窗口宽度(sm/md/lg)动态布局,结合GridRow与Navigation实现响应式分栏;重点强调键鼠交互(焦点、hover、右键、快捷键、滚轮)占七成工作量;通过交互模式抽象统一触屏与鼠标逻辑;强制声明最小窗口尺寸并自测小窗口场景;最终以“列表+详情”真实案例展示数据层一致、展示层双态的适配策略。

信息安全领域优质创作者|操作系统领域专家 244

鸿蒙沉浸光感开发适配

设备材质档位:EXQUISITE(精致,全光效,高性能设备)、GENTLE(均衡,默认)、SMOOTH(轻量,仅基础效果,低算力设备)、ADAPTIVE(自适应,系统自动识别算力选档,业务首选);用户系统设置三档(强/均衡默认/弱):本质是对透明度、反色率、折射强度的精细调控。用户的三档偏好由系统底层自动映射到渲染参数,应用只需一次定义材质,界面就会随用户设置平滑过渡,完全不需要针对三档分别写适配。

qq_63223749的博客 480

开源鸿蒙三方库适配实践:把 jsonrepair 搬到 ArkTS,端侧修好大模型吐出的坏 JSON

本文介绍了将 jsonrepair 移植至鸿蒙 ArkTS 严格模式的实践,解决大模型输出 JSON 格式错误问题。通过重构语法、优化性能,实现毫秒级修复(1MB 文本从 17.7 秒降至 127 毫秒),支持边流边修,界面实时渲染结构树。修复库已开源,提供 HAP 示范应用与完整测试验证,适用于端侧结构化输出场景。

LucianaiB的博客 713

操作系统安全体系能到哪一步?卓伊凡:服务端看认证,Ubuntu看默认,欧拉看体系,鸿蒙是另一条路

操作系统安全体系当前已实现分层保障:内核级强制访问控制(如SELinux、AppArmor)、默认攻击面收窄、密码学加密与制度化测评构成四重防线。在官方测评中,华为欧拉V3、阿里云服务器等三款系统达Ⅰ级安全可靠标准,鸿蒙桌面则首获Ⅱ级认证。Ubuntu高版本默认安全工程化出色,但加固也可能引入新漏洞。欧拉与鸿蒙技术路线不同——前者为服务端Linux加固体系,后者为终端微内核+形式化验证架构,二者可协同构建“端云安全”,但不可混为一谈。安全本质是相对的,需结合场景、运维能力与测评体系理性选型。

一颗优雅草科技-央千澈的优快云博客~只想无穷无尽的学习~作息早8-晚8 195

【鸿蒙心迹】应用沙箱与文件管理——fs 接口与安全路径实战(HarmonyOS 7.x)

文件写到哪了?为什么读不到?跨应用分享文件怎么传?——应用沙箱隔离让文件操作和传统 OS 不同。本文用图片缓存/文档导出/跨应用分享为案例,讲清沙箱目录结构、fs 接口、FileUri 权限,附 5 个踩坑。

腾讯云创作之星、华为云云享专家,深耕电商全栈高并发系统实战,分享可商用商城项目源码。 698

Flutter 适配鸿蒙手表屏幕形状:让计时卡片按圆屏和方屏布局

本文基于 wear_plus 1.2.4 版本,为鸿蒙系统补全屏幕形状查询功能,使 WatchShape 能正确返回 round 等形状信息。通过在原 Dart 接口不变的前提下,新增鸿蒙平台处理器,实现与 Android 一致的异步查询逻辑。对照实验验证:适配后页面可从“查询未接入”变为“圆屏已确认”,日志成功接收系统回执,布局行为保持一致。完整代码开源至 oh-flutter/wear_plus,支持 Flutter 鸿蒙穿戴设备开发。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 2万+
上一篇: 鸿蒙5.0开发进阶:NDK开发-JSVM-API调试&定位
下一篇: 鸿蒙5.0开发进阶:NDK开发-使用 code cache 加速编译
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值