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

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

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


使用JSVM-API接口创建多个引擎执行JS代码并销毁

场景介绍

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

使用示例

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

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

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

#define CHECK_COND(cond)                                                                                               \
  do {                                                                                                               \
      if (!(cond)) {                                                                                                 \
          OH_LOG_ERROR(LOG_APP, "jsvm fail file: %{public}s line: %{public}d ret = false", __FILE__, __LINE__);      \
          return -1;                                                                                                 \
      }                                                                                                              \
  } while (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;
  JSVM_CALL(OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL));

  JSVM_CALL(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 = -1;
  // 通过当前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_ERROR(LOG_APP, "JSVM API TEST: CreatePromise envID failed");
      return nullptr;
  }
  JSVM_Value promise;
  JSVM_Deferred deferred;
  JSVM_CALL(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;
          if (OH_JSVM_CreateInt32(env_, envID, &result) != JSVM_OK) {
              return;
          }
          if (OH_JSVM_ResolveDeferred(env_, deferred_, result) != JSVM_OK) {
              return;
          }
      }

  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];
  JSVM_CALL(OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL));
  double num1, num2;
  JSVM_CALL(OH_JSVM_GetValueDouble(env, args[0], &num1));
  JSVM_CALL(OH_JSVM_GetValueDouble(env, args[1], &num2));
  JSVM_Value sum = nullptr;
  JSVM_CALL(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(OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL));

  bool isStrictEquals = false;
  JSVM_CALL(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;
}

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

// 提供创建JSVM运行环境的对外接口并返回对应唯一ID
static int CreateJsCore(uint32_t *result) {
  OH_LOG_INFO(LOG_APP, "JSVM CreateJsCore START");
  g_taskQueueMap[ENVTAG_NUMBER] = deque<Task *>{};

  if (g_aa == 0) {
      JSVM_InitOptions init_options;
      memset(&init_options, 0, sizeof(init_options));
      CHECK(OH_JSVM_Init(&init_options));
      g_aa++;
  }
  std::lock_guard<std::mutex> lock_guard(envMapLock);

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

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

  // 注册用户提供的本地函数的回调函数指针和数据,通过JSVM-API暴露给js
  for (int i = 0; i < 4; 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 = 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},
      {"createPromise", NULL, &g_callBackStructMap[ENVTAG_NUMBER][3], NULL, NULL, NULL, JSVM_DEFAULT},
  };
  CHECK(OH_JSVM_CreateEnv(*g_vmMap[ENVTAG_NUMBER], sizeof(descriptors) / sizeof(descriptors[0]), descriptors,
                          g_envMap[ENVTAG_NUMBER]));
  CHECK(OH_JSVM_CloseVMScope(*g_vmMap[ENVTAG_NUMBER], vmScope));

  OH_LOG_INFO(LOG_APP, "JSVM CreateJsCore END");
  *result = ENVTAG_NUMBER;
  ENVTAG_NUMBER++;
  return 0;
}

// 对外提供释放JSVM环境接口,通过envId释放对应环境
static int ReleaseJsCore(uint32_t coreEnvId) {
  OH_LOG_INFO(LOG_APP, "JSVM ReleaseJsCore START");
  CHECK_COND(g_envMap.count(coreEnvId) != 0 && g_envMap[coreEnvId] != nullptr);

  std::lock_guard<std::mutex> lock_guard(envMapLock);

  CHECK(OH_JSVM_DestroyEnv(*g_envMap[coreEnvId]));
  g_envMap[coreEnvId] = nullptr;
  g_envMap.erase(coreEnvId);
  CHECK(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);
  g_taskQueueMap.erase(coreEnvId);

  OH_LOG_INFO(LOG_APP, "JSVM ReleaseJsCore END");
  return 0;
}

static std::mutex mutexLock;
// 对外提供执行JS代码接口,通过coreID在对应的JSVN环境中执行JS代码
static int EvaluateJS(uint32_t envId, const char *source, std::string &res) {
  OH_LOG_INFO(LOG_APP, "JSVM EvaluateJS START");

  CHECK_COND(g_envMap.count(envId) != 0 && g_envMap[envId] != nullptr);

  JSVM_Env env = *g_envMap[envId];
  JSVM_VM vm = *g_vmMap[envId];
  JSVM_VMScope vmScope;
  JSVM_EnvScope envScope;
  JSVM_HandleScope handleScope;
  JSVM_Value result;

  std::lock_guard<std::mutex> lock_guard(mutexLock);
  {
      // 创建JSVM环境
      CHECK_RET(OH_JSVM_OpenVMScope(vm, &vmScope));
      CHECK_RET(OH_JSVM_OpenEnvScope(*g_envMap[envId], &envScope));
      CHECK_RET(OH_JSVM_OpenHandleScope(*g_envMap[envId], &handleScope));

      // 通过script调用测试函数
      JSVM_Script script;
      JSVM_Value jsSrc;
      CHECK_RET(OH_JSVM_CreateStringUtf8(env, source, JSVM_AUTO_LENGTH, &jsSrc));
      CHECK_RET(OH_JSVM_CompileScript(env, jsSrc, nullptr, 0, true, nullptr, &script));
      CHECK_RET(OH_JSVM_RunScript(env, script, &result));

      JSVM_ValueType type;
      CHECK_RET(OH_JSVM_Typeof(env, 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) {
          CHECK_COND(fromOHStringValue(env, result, res) != -1);
      } else if (type == JSVM_BOOLEAN) {
          bool ret = false;
          CHECK_RET(OH_JSVM_GetValueBool(env, result, &ret));
          ret ? res = "true" : res = "false";
      } else if (type == JSVM_NUMBER) {
          int32_t num;
          CHECK_RET(OH_JSVM_GetValueInt32(env, result, &num));
          res = std::to_string(num);
      } else if (type == JSVM_OBJECT) {
          JSVM_Value objResult;
          CHECK_RET(OH_JSVM_JsonStringify(env, result, &objResult));
          CHECK_COND(fromOHStringValue(env, objResult, res) != -1);
      }
  }
  {
      bool aal = false;
      CHECK_RET(OH_JSVM_PumpMessageLoop(*g_vmMap[envId], &aal));
      CHECK_RET(OH_JSVM_PerformMicrotaskCheckpoint(*g_vmMap[envId]));
      CHECK_RET(OH_JSVM_CloseHandleScope(*g_envMap[envId], handleScope));
      CHECK_RET(OH_JSVM_CloseEnvScope(*g_envMap[envId], envScope));
      CHECK_RET(OH_JSVM_CloseVMScope(*g_vmMap[envId], vmScope));
  }
  OH_LOG_INFO(LOG_APP, "JSVM EvaluateJS END");
  return 0;
}

static int32_t TestJSVM() {
  const char source1[] = "{\
      let a = \"hello World\";\
      consoleinfo(a);\
      const mPromise = createPromise();\
      mPromise.then((result) => {\
        assertEqual(result, 0);\
      });\
      a;\
  };";

  const char source2[] = "{\
      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);\
      });\
      a;\
  };";

  // 创建首个运行环境,并绑定TS回调
  uint32_t coreId1;
  CHECK_COND(CreateJsCore(&coreId1) == 0);
  OH_LOG_INFO(LOG_APP, "TEST coreId: %{public}d", coreId1);
  // 在首个运行环境中执行JS代码
  std::string result1;
  CHECK_COND(EvaluateJS(coreId1, source1, result1) == 0);
  OH_LOG_INFO(LOG_APP, "TEST evaluateJS: %{public}s", result1.c_str());

  // 创建第二个运行环境,并绑定TS回调
  uint32_t coreId2;
  CHECK_COND(CreateJsCore(&coreId2) == 0);
  OH_LOG_INFO(LOG_APP, "TEST coreId: %{public}d", coreId2);
  // 在第二个运行环境中执行JS代码
  std::string result2;
  CHECK_COND(EvaluateJS(coreId2, source2, result2) == 0);
  OH_LOG_INFO(LOG_APP, "TEST evaluateJS: %{public}s", result2.c_str());

  // 释放首个运行环境
  CHECK_COND(ReleaseJsCore(coreId1) == 0);
  // 释放第二个运行环境
  CHECK_COND(ReleaseJsCore(coreId2) == 0);
  OH_LOG_INFO(LOG_APP, "Test NAPI end");

  return 0;
}

一张微服务地图的十年演进:Spring Cloud 核心、扩展与工具组件的定位、原理与选型 本文把 Spring Cloud 当作一张微服务地图来读:先说明它是由 Commons 抽象层、实现层和 Boot 装配层构成的发行版,再沿一次请求梳理注册发现、负载均衡、声明式调用、容错限流、网关、配置、追踪与总线七类核心组件的原理与换代,并扩展到云平台、服务网格、消息流、批处理、安全与周边生态。仿真实测:默认参数下实例宕机平均 242 秒才被感知,优雅下线降到 47 秒;一个慢实例让轮询的 P99 达 49 秒,P2C 仅 203 毫秒。最后给出退场替代表、技术栈组合、升级路线和决策树。 阅读详情

相关推荐

VS2103+Intel2013+MSMPI运行Fortran并行程序

VS2103+Intel2013+MSMPI运行Fortran并行程序MSMPI安装新建Fortran90项目编写Fortran并行程序在cmd运行编译完成的执行文件 MSMPI安装 我这里采用的是Microsoft MPI v9.0.1,可以点此下载。下载完成后同时安装msmpisdk.msi、msmpisetup.exe两个文件,安装位置默认即可。 其中msmpisdk.msi的默认安装路径在C:\Program Files (x86)\Microsoft SDKs\MPI,该文件包含了mpi环境所需

weixin_43176703的博客 2939

【鸿蒙开发示例代码】js注入与执行

本示例基于H5游戏,通过arkui的button实现对游戏实现基本控制,展示webview的JS注入与执行能力,及native应用与H5的通信能力。

weixin_44349071的博客 704

Mmdetection用自己的数据集训练Mask_RCNN

将自己数据的标签写入配置文件,在data前一行添加自己的标签列表,同时在train,val,test中添加classes = classes,如果不添加,模型就会默认读取coco原始数据集的80个标签,与自己的数据集对应不上就会报错。2.打开第二个文件coco_instance.py,将data_root路径改为你自己coco数据集的位置(注意一定要以/结尾),修改输出图片尺寸(根据自己的数据集决定)3.将标注完的数据转为Mask_rcnn训练所需的数据集格式。4.将数据集放到训练代码文件夹中。

m0_64298393的博客 3475

鸿蒙5.0&next开发【使用JSVM-API接口创建多个引擎执行JS代码并销毁】使用JSVM-API实现JS与C/C++语言交互

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

bbq的博客 178

Jetson Nano官方镜像下载&烧录

在NVIDIA Jetson Nano开发者套件上安装NVIDIA官方Ubuntu镜像

weixin_44222088的博客 8861

5.4 磁悬浮轴承控制系统仿真:在MATLAB/Simulink中搭建包含功放、传感器模型的闭环系统模型,进行稳定性与动态性能仿真

磁悬浮轴承控制系统仿真方法 摘要:磁悬浮轴承控制系统仿真需建立包含转子动力学、传感器、控制器、功率放大器和电磁执行器的高保真非线性模型。通过MATLAB/Simulink搭建闭环系统,重点建模传感器带宽限制与噪声、功放饱和特性以及电磁力非线性。仿真分析包括时域阶跃响应、扰动抑制测试,频域稳定性分析(伯德图、奈奎斯特图),以及参数摄动下的鲁棒性验证。关键要验证控制算法在非线性因素影响下的稳定性和动态性能,为实际系统实现提供可靠依据。仿真中需特别注意物理量单位一致性和数字控制离散化效应。

技术工作者 1108

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

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

Androidbye的博客 395

折叠式共源共栅运放设计实战:Cadence Virtuoso完整流程

在模拟IC设计中,运放是信号链的核心模块,而共源共栅结构凭借高增益、高输出阻抗的特性,成为高性能放大器的经典选择。其中,折叠式共源共栅运放通过电流折叠技术,在不牺牲增益的前提下显著改善输出摆幅与输入共模范围,尤其适合1.8V低压工艺下的高动态范围应用。本文从共源共栅放大器的基本原理出发,解析其技术价值与典型应用场景,并基于0.18μm工艺,系统展示如何利用Cadence Virtuoso完成从电路结构分析、管子尺寸推导到原理图绘制、仿真调试的完整设计闭环。内容涵盖增益、带宽、相位裕度等关键指标的优化方法,以

weixin_34277853的博客 369

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

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

weixin_30314793的博客 273

2018安徽省青少年信息学奥林匹克(AHOI)初中组

12 种合法的排列分别为:1, 3, 2, 4, 2, 3, 1, 4, 3, 1, 4, 2, 3, 2, 4, 1, 1, 3, 4, 2, 2, 3,4,1,1,4,2,3, 2,4,1,3, 4,1,3,2, 4,2,3,1, 1,4,3,2, 2,4,3,1。分为 2 组,一组的队员实力值是{4, 5, 2, 3},一组是{-4, -3, -5},其中最小的组人数为 3,可以发现没有比 3 更优的分法了。[0, 1, 1, 2]同样不是合法的分组方案,因为出现了两个实力值为 1 的选手。

weixin_42358969的博客 1143

coze 怎么读取excel文件,使用循环,数据库完成LLM问答并存储

本文介绍了如何在Coze平台实现&quot;Excel读取+循环处理+LLM问答+数据库存储&quot;的工作流。主要分为三个步骤:1)使用代码节点解析Excel文件为问答对数组;2)通过循环节点遍历问答对,调用LLM节点生成回答;3)利用数据库节点将问答结果存储到Coze内置数据库中。文中提供了代码示例和节点配置说明,并强调了注意事项如Excel格式要求、LLM调用频率控制等。该工作流适用于批量构建知识库问答系统并持久化存储结果。

ZhangJiqun&191cm&85kg 1803

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

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

程序猿追的博客 51

第67步 时间序列建模实战:ARIMA建模(Stata)

第67步 时间序列建模实战:ARIMA建模(Stata)

Jet4505的博客 6823

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

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

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

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

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

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

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

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

weixin_46316564的博客 232

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

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

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

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

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

鸿蒙 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的博客 723

操作系统安全体系能到哪一步?卓伊凡:服务端看认证,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万+

HarmonyOS 分布式深度:跨端迁移、数据对象与多设备协同

本文深入解析鸿蒙分布式能力实战,聚焦跨端迁移、协同与共享三大形态,详解权限配置、设备发现、onContinue状态管理及分布式数据对象、KV同步机制。强调“先分清场景”“前置条件必全”“数据需重验”,揭示迁移失败、同步失效等七大常见坑,指导开发者规避陷阱,实现真实可用的多设备协同。

信息安全领域优质创作者|操作系统领域专家 143
上一篇: 鸿蒙5.0开发进阶:NDK代码开发-JSVM-API典型使用场景指南(JSVM-API调试&定位)
下一篇: 鸿蒙5.0开发进阶:NDK代码开发-JSVM-API调优&高性能使用(使用 code cache 加速编译)
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值