【OpenHarmony】L1 新增SA

已于 2023-07-17 16:59:25 修改
阅读量831 收藏 2
点赞数 2
分类专栏： OpenHarmony 文章标签： c语言
于 2023-04-11 21:27:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kemin123/article/details/130070895
版权

OpenHarmony L1 新增SA

根据OpenHarmony开源社区的samgr_lite的说明文档，写一个SA的demo。
https://gitee.com/openharmony/systemabilitymgr_samgr_lite

环境与设备说明

当前文档记录时，使用的是OpenHarmony4.0版本。
使用的L1设备是Hi3516，对应编译类型是ipcamera_hispark_taurus和ipcamera_hispark_taurus_linux，内核分别是liteos-a和linux。
另外，L0设备Hi3861，是单进程，没有IPC，没有SA。

demo代码

目录树

mymodule/lite/frameworks	# SA框架
├── mini					# L0对外接口实现的存放目录
├── small					# L1的SA存放目录
│   └── include				# 头文件存放目录
│       └── my_module_define.h
│   └── src				    # 源文件存放目录
│       └── my_module_client_proxy.c
│       └── my_module_feature.c
│       └── my_module_server.c
│       └── my_module_service.c
│   └── BUILD.gn			 # L1编译配置脚本
├── BUILD.gn          		 # L0L1编译配置脚本

mymodule/lite/interfaces	# 对外提供接口头文件路径
├── innerkits				# C/C++使用
│   └── my_module_interface.h
├── kits					# JS或其他使用

my_module_define.h

用于存放L1的SA代码常用的宏

#ifndef MY_MODULE_DEFINE_H
#define MY_MODULE_DEFINE_H

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#define MAX_DATA_LEN 1024
#define MODULE_STACK_SIZE 0x1000
#define MODULE_QUEUE_SIZE 20
#define EXAMPLE_SERVICE "example_service"
#define EXAMPLE_FEATURE "example_feature"

#define EXAMPLE_SUCCESS 0
#define EXAMPLE_FAILED (-1)

typedef enum {
    MY_MODULE_MSG_PROC,
    MY_MODULE_MSG_TIME_PROC,
    MY_MODULE_MSG_HELLO,
    MY_MODULE_MSG_ID_MAX
} MyModuleMsgID;

typedef struct {
    int result;
    size_t messageLen;
    uint8_t *message;
} ServiceRspMsg;

#endif // MY_MODULE_DEFINE_H

my_module_server.c

L1的SA的开发服务

#include <unistd.h>
#include <stdio.h>
#include <ohos_init.h>
#include <iunknown.h>
#include "samgr_lite.h"
#include "my_module_define.h"

typedef struct {
    INHERIT_SERVICE;
    Identity identity;
} ExampleServer;

static const char *GetName(Service *service);
static BOOL Initialize(Service *service, Identity identity);
static BOOL MessageHandle(Service *service, Request *msg);
static TaskConfig GetTaskConfig(Service *service);
// 创建服务对象
static ExampleServer g_example = {
    .GetName = GetName,
    .Initialize = Initialize,
    .MessageHandle = MessageHandle,
    .GetTaskConfig = GetTaskConfig,
    {-1, -1, NULL}
};
//实现服务的生命周期函数
static const char *GetName(Service *service)
{
    (void)service;
    return EXAMPLE_SERVICE;
}

static BOOL Initialize(Service *service, Identity identity)
{
    ExampleServer *example = (ExampleServer *)service;
    example->identity = identity;
    return TRUE;
}

static BOOL MessageHandle(Service *service, Request *msg)
{
    ExampleServer *example = (ExampleServer *)service;
    (void)example;
    switch (msg->msgId) {
    case MY_MODULE_MSG_PROC:
        //业务处理
        break;
    default: break;
    }
    return FALSE;
}

static TaskConfig GetTaskConfig(Service *service)
{
    (void)service;
    TaskConfig config = {LEVEL_HIGH, PRI_BELOW_NORMAL, MODULE_STACK_SIZE, MODULE_QUEUE_SIZE, SINGLE_TASK};
    return config;
}
//向SAMGR注册服务及接口
static void Init(void)
{
    SAMGR_GetInstance()->RegisterService((Service *)&g_example);
}
//定义服务的初始化入口
SYS_SERVICE_INIT(Init);

my_module_feature.c

L1的SA的开发服务的子功能

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <securec.h>
#include <ohos_init.h>
#include <iunknown.h>
#include "samgr_lite.h"
#include "iproxy_client.h"
#include "iproxy_server.h"
#include "my_module_define.h"

typedef struct {
    INHERIT_SERVER_IPROXY;
} ExampleFeatureApi;

typedef struct {
    INHERIT_FEATURE;
    INHERIT_IUNKNOWNENTRY(ExampleFeatureApi);
    Identity identity;
    Service *parent;
} ExampleFeature;

static const char *FEATURE_GetName(Feature *feature);
static void FEATURE_OnInitialize(Feature *feature, Service *parent, Identity identity);
static void FEATURE_OnStop(Feature *feature, Identity identity);
static BOOL FEATURE_OnMessage(Feature *feature, Request *request);
static int32_t Invoke(IServerProxy *iProxy, int funcId, void *origin, IpcIo *req, IpcIo *reply);
//创建功能对象
static ExampleFeature g_example = {
    .GetName = FEATURE_GetName,
    .OnInitialize = FEATURE_OnInitialize,
    .OnStop = FEATURE_OnStop,
    .OnMessage = FEATURE_OnMessage,
    SERVER_IPROXY_IMPL_BEGIN,
        .Invoke = Invoke,
    IPROXY_END,
    .identity = {-1, -1, NULL},
};
//实现功能的生命周期函数
static const char *FEATURE_GetName(Feature *feature)
{
    (void)feature;
    return EXAMPLE_FEATURE;
}

static void FEATURE_OnInitialize(Feature *feature, Service *parent, Identity identity)
{
    ExampleFeature *exampleFeature = (ExampleFeature *)feature;
    exampleFeature->identity = identity;
    exampleFeature->parent = parent;
}

static void FEATURE_OnStop(Feature *feature, Identity identity)
{
    (void)feature;
    (void)identity;
    g_example.identity.queueId = NULL;
    g_example.identity.featureId = -1;
    g_example.identity.serviceId = -1;
}

static BOOL FEATURE_OnMessage(Feature *feature, Request *request)
{
    (void)feature;
    if (request->msgId == MY_MODULE_MSG_PROC) {
        Response response = {.data = "Yes, you did!", .len = 0};
        SAMGR_SendResponse(request, &response);
        return TRUE;
    }
    return FALSE;
}

static int32_t Invoke(IServerProxy *iProxy, int funcId, void *origin, IpcIo *req, IpcIo *reply)
{
    (void)origin;
    if ((iProxy == NULL) || (req == NULL) || (reply == NULL)) {
        return EXAMPLE_FAILED;
    }
    size_t tempLen = 0;
    uint8_t *buf = NULL;
    switch (funcId) {
        case MY_MODULE_MSG_HELLO:
            buf = ReadString(req, &tempLen);
            printf("[feature] tempLen:%u\n\r", tempLen);
            printf("[feature] req: %s\n\r", buf);
            WriteInt32(reply, EXAMPLE_SUCCESS);
            WriteString(reply, "Hello world");
            break;
        default:
            WriteInt32(reply, EXAMPLE_FAILED);
            break;
    }
    return EXAMPLE_SUCCESS;
}
//向SAMGR注册功能及接口
static void Init(void)
{
    SAMGR_GetInstance()->RegisterFeature(EXAMPLE_SERVICE, (Feature *)&g_example);
    SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(g_example));
}
//定义功能的初始化入口：
SYS_FEATURE_INIT(Init);

my_module_client_proxy.c

L1的客户端代理


#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <pthread.h>
#include <registry.h>
#include <securec.h>
#include <ohos_errno.h>
#include <ohos_types.h>
#include <iunknown.h>
#include "samgr_lite.h"
#include "iproxy_server.h"
#include "iproxy_client.h"
#include "my_module_define.h"

typedef struct {
    INHERIT_CLIENT_IPROXY;
    int32_t(*HandleModuleMsgSync)(IUnknown *iUnknown, const char *buff);
    // int32_t(*HandleModuleMsgAsync)(IUnknown *iUnknown, const char *buff);
} MyModuleClientProxy;

typedef struct {
    INHERIT_IUNKNOWNENTRY(MyModuleClientProxy);
} MyMoudleClientEntry;

static MyModuleClientProxy *g_clientProxy;
static int32_t HandleModuleMsgSync(IUnknown *iUnknown, const char *buff);
static void *CreateClient(const char *service, const char *feature, uint32 size);
static void DestroyClient(const char *service, const char *feature, void *iproxy);

static int32_t ModuleSamgrInitialize(void)
{
    int32_t ret = (int32_t)SAMGR_RegisterFactory(EXAMPLE_SERVICE, EXAMPLE_FEATURE, CreateClient, DestroyClient);
    if (ret != EXAMPLE_SUCCESS) {
        return EXAMPLE_FAILED;
    }
    return EXAMPLE_SUCCESS;
}

static void *CreateClient(const char *service, const char *feature, uint32 size)
{
    (void)service;
    (void)feature;
    uint32 len = size + sizeof(MyMoudleClientEntry);
    uint8 *client = malloc(len);
    if (client == NULL) {
        return NULL;
    }
    (void)memset_s(client, len, 0, len);
    MyMoudleClientEntry *entry = (MyMoudleClientEntry *)&client[size];
    entry->ver = ((uint16)CLIENT_PROXY_VER | (uint16)DEFAULT_VERSION);
    entry->ref = 1;
    entry->iUnknown.QueryInterface = IUNKNOWN_QueryInterface;
    entry->iUnknown.AddRef = IUNKNOWN_AddRef;
    entry->iUnknown.Release = IUNKNOWN_Release;
    entry->iUnknown.Invoke = NULL;
    entry->iUnknown.HandleModuleMsgSync = HandleModuleMsgSync;
    // entry->iUnknown.HandleModuleMsgAsync = HandleModuleMsgAsync;
    return client;
}

void DestroyClient(const char *service, const char *feature, void *iproxy)
{
    (void)service;
    (void)feature;
    if (iproxy != NULL) {
        free(iproxy);
        iproxy = NULL;
    }
}

static int32_t GetModuleClientApi()
{
    IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
    if (iUnknown == NULL) {
        return EXAMPLE_FAILED;
    }
    int32_t ret = iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&g_clientProxy);
    if (ret != EXAMPLE_SUCCESS || g_clientProxy == NULL) {
        return EXAMPLE_FAILED;
    }
    return EXAMPLE_SUCCESS;
}
// 消息回调函数
static int HandleModuleMsgCb(void *owner, int code, IpcIo *reply)
{
    (void)code;
    if ((owner == NULL) || (reply == NULL)) {
        return EXAMPLE_FAILED;
    }

    ServiceRspMsg *respInfo = (ServiceRspMsg *)owner;

    if (!ReadInt32(reply, &respInfo->result)) {
        return EXAMPLE_FAILED;
    }
    if (respInfo->result == EXAMPLE_SUCCESS) {
        respInfo->message = ReadString(reply, &respInfo->messageLen);
        printf("[HandleModuleMsgCb] message:%s\n\r", respInfo->message);
    }
    return EXAMPLE_SUCCESS;
}

static int32_t HandleModuleMsgSync(IUnknown *iUnknown, const char *buff)
{
    MyModuleClientProxy *proxy = (MyModuleClientProxy *)iUnknown;
    // IPC消息传入
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    (void)WriteString(&request, buff);

    // IPC消息获取
    ServiceRspMsg reply = { 0 };

    // 使用同步调用IPC
    int ret = proxy->Invoke((IClientProxy *)proxy, MY_MODULE_MSG_HELLO, &request, &reply, HandleModuleMsgCb);
    if (ret != EXAMPLE_SUCCESS) {
        return EXAMPLE_FAILED;
    }
    if (reply.result != EXAMPLE_SUCCESS) {
        return EXAMPLE_FAILED;
    }
    return EXAMPLE_SUCCESS;
}

// static int32_t HandleModuleMsgAsync(IUnknown *iUnknown, const char *buff)
// {
//     MyModuleClientProxy *proxy = (MyModuleClientProxy *)iUnknown;
//     // IPC消息传入
//     IpcIo request;
//     char data[MAX_DATA_LEN];
//     IpcIoInit(&request, data, MAX_DATA_LEN, 0);
//     WriteString(&request, buff);

//     // 使用异步调用IPC
//     int ret = proxy->Invoke((IClientProxy *)proxy, MY_MODULE_MSG_HELLO, &request, NULL, NULL);
//     return ret == EC_SUCCESS;
// }

int HandleModule(void)
{
    int32_t ret = ModuleSamgrInitialize();
    if (ret != EXAMPLE_SUCCESS) {
        return EXAMPLE_FAILED;
    }
    ret = GetModuleClientApi();
    if ((ret != EXAMPLE_SUCCESS) || (g_clientProxy == NULL)) {
        return EXAMPLE_FAILED;
    }
    if (g_clientProxy->HandleModuleMsgSync == NULL) {
        return EXAMPLE_FAILED;
    }
    ret = g_clientProxy->HandleModuleMsgSync((IUnknown *)g_clientProxy, "Hi");
    if (ret != EXAMPLE_SUCCESS) {
        printf("[HandleModule] ret:%d\n\r", ret);
    }
    (void)g_clientProxy->Release((IUnknown *)g_clientProxy);
    return EXAMPLE_SUCCESS;
}

moduleservice.c

#include <stdio.h>
#include <unistd.h>
#include <samgr_lite.h>

#define MY_MODULE_SLEEP_TIME 2

int main(void)
{
    sleep(MY_MODULE_SLEEP_TIME);
    printf("my_module-start:SAMGR_Bootstrap\r\n");
    SAMGR_Bootstrap();
    while (1) {
        pause();
    }
    return 0;
}

small目录下的BUILD.gn

import("//build/lite/config/component/lite_component.gni")
CFLAGS_COMMON = [
  "-ftrapv",
  "-Werror",
  "-Wextra",
  "-Wshadow",
  "-fstack-protector-all",
  "-D_FORTIFY_SOURCE=2",
  "-Wformat=2",
  "-Wfloat-equal",
  "-Wdate-time",
]

INCLUDE_COMMON = [ "include" ]

# L1 server
shared_library("my_module_server") {
  sources = [
    "src/my_module_feature.c",
    "src/my_module_server.c",
  ]
  cflags = CFLAGS_COMMON
  cflags += [ "-fPIC" ]
  ldflags = [ "-pthread" ]
  include_dirs = INCLUDE_COMMON
  deps = [ "//foundation/systemabilitymgr/samgr_lite/samgr:samgr" ]
}

# L1 client
shared_library("my_module_client") {
  sources = [ "src/my_module_client_proxy.c" ]
  cflags = CFLAGS_COMMON
  cflags += [ "-fPIC" ]
  ldflags = [ "-pthread" ]
  include_dirs = INCLUDE_COMMON
  include_dirs += [ "../../../interfaces/innerkits" ]
  deps = [ "//foundation/systemabilitymgr/samgr_lite/samgr:samgr" ]
}

# L1 service bin
executable("my_module_service") {
  sources = [ "src/my_module_service.c" ]
  cflags = CFLAGS_COMMON
  ldflags = [ "-pthread" ]
  include_dirs = INCLUDE_COMMON
  deps = [
    ":my_module_server",
    "//foundation/systemabilitymgr/samgr_lite/samgr:samgr",
  ]
}

small上一级目录的BUILD.gn

import("//build/lite/config/component/lite_component.gni")
lite_component("my_module_lite") {
  if (ohos_kernel_type == "liteos_m") {
    features = []
  } else {
    features = [
      "small:my_module_client",
      "small:my_module_service",
    ]
  }
}

my_module_interface.h

对外提供接口

#ifndef MY_MODULE_INTERFACE_H
#define MY_MODULE_INTERFACE_H

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* __cplusplus */

// 自定义接口
int HandleModule(void);

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* __cplusplus */

#endif // MY_MODULE_INTERFACE_H

SA的IPC提供的接口

foundation/communication/ipc/interfaces/innerkits/c/ipc/include/serializer.h

代码编译

关于代码编译问题，可以查看这篇文章：
【OpenHarmony】L0L1 添加子系统/组件

新增启动进程

拿hispark_taurus举例：
在目录vendor\hisilicon\hispark_taurus\init_configs下，对文件
init_liteos_a_3516dv300.cfg 和

init_liteos_a_3516dv300_mksh.cfg 进行修改

“jobs” -> {“name” : “init” …} -> "cmds"下，增加

"start my_module_service"

以及在"services"下增加

 {
     "name" : "my_module_service",
     "path":["/bin/my_module_service"], 
     "uid":0', 
     "gid":0, 
     "once":1, 
     "importance":0, 
     "caps":[]
}

注意：正式代码，不建议给uid和gid设置为0，root权限。uid和gid不为0时，遇到调用底层接口报错，可以在"caps"增加对应的linux的能力capability。

新增SA的IPC权限

修改文件base\security\permission_lite\services\ipc_auth\include\policy_preset.h
增加内容：

FeaturePolicy mymoduleFeature[] = {
    {
        "example_feature",
        {
            {
                .type = RANGE,
                .uidMin = 0,
                .uidMax = __INT_MAX__,
            },
        },
    },
};

以及在g_presetPolicies[]里面增加

{"example_service", mymoduleFeature, 1}

注意，“example_service"对应my_module_define.h里的"example_service”，且其长度最长15个字节。

生成文件

编译生成的bin文件在
out/hispark_taurus/ipcamera_hispark_taurus/bin

编译生成的so文件在
out/hispark_taurus/ipcamera_hispark_taurus/usr/lib

smaple样例

写一个测试样例，调用interfaces的接口，测试客户端与服务端的IPC。

my_module_smaple.c

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <my_module_interface.h>

int main(int argc, char **argv)
{
	int ret = HandleModule();
	printf("[test] ret: %d\n\r", ret);
	return 0;
}

BUILD.gn

自行完成

更多

运行smaple样例之后，日志串口会打印

[ERR][hello_test:thread2]LiteIpcRead failed ERROR: -132

其中LiteIpcRead属于是内核里IPC通信机制，在目录kernel里。
而-132，对应的错误码是ERFKILL（Linux内核错误码大全）。是因为my_module_smaple.c里执行完业务接口后，就直接return 0了，导致IPC的信号断开。
如果不想出现这句报错打印，在my_module_smaple.c最后添加

while (1) {
    pause();
}

这个SA的demo，有些部分与开源社区提供的文档有出入。我遇到的一些问题，也会放到Q&A里面，欢迎大家留言交流。

相关链接

【OpenHarmony】从入门到肝疼

Kemin123
关注
专栏目录
OpenHarmony源码(十):编译子系统
myxuan475的专栏
11-23 692
loader 过程先扫描 preloader 过程生成的parts_config.json ，subsystem_config.json等文件生成 gen，build_config 目录， 将所有的子系统的bundle.json, ohos.build, BUILD.gn 生成新的BUILD.gn 放在build_config。扫描到的各个子系统的bundle.json, ohos.build, BUILD.gn 会生成新的BUILD.gn 放在out/build_configs/对应子系统目录。
OpenHarmony SA服务编写
qq_56547921的博客
01-02 706
系统启动后，init进程会遍历init目录下的sa cfg文件,解析cfg文件中指定的xml文件，并根据xml中定义的sa port号，到sa 定义文件中找到对应sa, 将sa添加到localAbilityManager的ability_map中。后续init启动sa_main后，sa_main会遍历ablity_map中的所有sa，并依次拉起对应的sa动态库文件.z.so，并添加到system_ability_manager中。cfg文件对应为文件目录中的service/etc/*.cfg;
openharmony L1 新增SA（老方法已弃用）
Kemin123的博客
07-04 716
根据openharmony开源社区的samgr_lite的说明文档，写一个SA的demo https://gitee.com/openharmony/distributedschedule_samgr_litemymodule └─lite  │ BUILD.gn  │  ├─mini  └─small    │ BUILD.gn    │    ├─include    │ module_define.h    │    └─src      moduleclient.c      modulefeatu
OpenHarmony南向开发 SA服务SELinux权限配置一站式傻瓜式教程
最新发布
她的吻让他
08-09 946
SELinux是Security Enhanced Linux 的缩写，也就是安全强化的 Linux，旨在增强传统Linux操作系统的安全性，解决传统Linux系统中自主访问控制（DAC）系统中的各种权限问题（如root权限过高等）。这里举一个例子便于理解，假设系统中某个服务进程出现了一个漏洞，使得某个远程用户可以访问系统的敏感文件（如/etc/dev）。
OpenHarmony L1（3.0）串口功能开发
isoftstone_HOS的博客
05-10 1188
OpenHarmony 3.0 LTS是面向全场景的开源分布式操作系统，能够在物联网上使用。可以支持三种系统类型，标准系统、轻量系统和小型系统。本文提供了在OpenHarmony 3.0 LTS实现串口调试功能的开发方案。本文介绍了在OpenHarmony 3.0 LTS系统上重串口功能实现到应用开发的整套流程。简单的API接口开发，可直接依赖系统模块。难点主要在轻量级系统开发，读者可参考开源鸿蒙中轻量级系统服务管理部件中的相关介绍进行开发。
openharmony L1级开机启动项服务设置实例
Linuxprobe18的博客
03-28 857
导读 openharmony L1级开发板需将一个执行文件转换为开机服务运行至开发板中，即开机时执行运行程序。由于当前使用的为L1级开发板与L2级开发板存在一定的差异。本次已L1级进行测试讲解。 设备 君正开发板：x2000，软件：oepenharmony 3.0 准备 我们通过打印显示的方式验证开机启动项是否启动成功。其中代码样例如下： lts@ubuntu:~/x2000/test$ ls BUILD.gn etc ohos.build test.c 其中test.c用于编
OpenHarmony 如何使用闭源动态库(L1)
qq_32605779的博客
05-13 226
之前写过一篇文章关于富设备使用闭源动态库的文章, 但是OpenHarmony3.0 linux内核的L1集成闭源动态库，在源码中调用跟L2不一样，也是耗费了一点点时间才在源码中调用成功。在本文档中就把这个使用的配置做简单的记录。富设备使用闭源动态库。
【OpenHarmony】关于L1 Hi3516连接网络的相关说明
Kemin123的博客
04-13 792
虽然Hi3516有显示器，可以通过交互界面去连接wifi，这样操作的有点是便捷，缺点也很明显，wifi名和不能带有特殊符号命令，wifi密码只能填数字。在//vendor/hisilicon/hispark_taurus/init_configs/BUILD.gn，增加。在//vendor/hisilicon/hispark_taurus/init_configs/BUILD.gn，增加。在//vendor/hisilicon/hispark_taurus/ BUILD.gn，增加。
Openharmony重要特性之一浅析分布式软总线
流风的专栏
08-04 7091
​ 分布式软总线能做什么？​ 1.1 通过共享一个局域网(wifi或蓝牙)，可以发现设备。​ 通过设备名等关键字可以查找到在共享的网络中所有设备，并进行通信。关键是不需要预告知晓对方设备的IP地址与端口。​ 1.2 支持消息、字节、流、文件的数据传输能力。​ 实际应用中，可以将文字、图片、文件或音视频流进行传输。​ 1.3 支持富设备、小型设备、轻量设备。​ 实际应用中，可以做到跨设备间使用。笔者在L0与L2、L2与L2等两类设备间测试通过。
深信服大云L1考试题库
09-24
深信服大云考试L1，今天下午的考试，无答案。8月份考试60题，9月份考试考试50题，两次考试题目重复率不到10%。
OpenHarmony IPC服务的动态加载(拉起)流程(L2)
10-02
OpenHarmony采用模块化设计，分为L1、L2、L3等多个层次。L1层主要涉及硬件抽象，L2层则处理系统服务和框架，L3层及以上则包括应用和开发者接口等。因此，L2层的IPC服务拉起流程对系统的整体运行至关重要。 动态加载...
无法启动此程序，因为计算机丢失api-ms-win-core-path-l1-1-0.dll的解决方案
热门推荐
weixin_43178406的博客
07-20 5万+
本文主要介绍了无法启动此程序，因为计算机丢失api-ms-win-core-path-l1-1-0.dll的解决方案，希望能对使用Python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案 文章目录 1. 问题描述 2. 解决方案
openharmony的SA介绍与编写--开鸿智谷
weixin_42538558的博客
04-02 1189
【OpenHarmony】L1 烧录的启动参数
Kemin123的博客
04-12 235
【代码】【OpenHarmony】L1 烧录的启动参数。
OpenHarmony服务启动框架
weixin_44205232的博客
05-24 1264
从上面代码我们可以知道服务的启动最终调用到了SystemAbility的start函数，由于我们注册的时候注册的是HCameraService，所以会调用到HCameraService的start函数。可以看到他是通过执行system/bin/sa_main程序导入了/system/profile/camera_service.xml配置文件启动的camera_service服务就和Android的init.rc中启动native进程是类似的。在3.2小节中启动ability走的时run函数。
OpenHarmony源码学习之编译构建
phmatthaus的专栏
01-01 988
OpenHarmony是由开放原子开源基金会（OpenAtom Foundation）孵化及运营的开源项目，目标是面向全场景、全连接、全智能时代、基于开源的方式，搭建一个智能终端设备操作系统的框架和平台，促进万物互联产业的繁荣发展。最近在学习OpenHarmony源代码，个人认为学习有三个阶段，分别是看实操写（归纳总结），本着追求学习的终极目标，因此有了这篇文章。构建工具由shell脚本python脚本gnninjiaclang/llvm等构成。
OpenHarmony 实现的一个IPC的客户端和服务端(L2)
qq_32605779的博客
05-14 520
挺长时间没接触L2的设备开发，再看OpenHarmony3.1代码时候，发现3.1与3.0相比：编译的ohos.build已经去掉，取而代之的是bundle.json，有的目录结构也发生了变化。此文档：OpenHarmony 3.1代码基础。3.1的编译配置(与3.0比，有些调整)IPC动态库服务端工程。IPC客户端。safwk加载动态库服务端。客户端和服务端的通信.想对IPC通信了解深入，可以结合下面两篇文章和代码一起分析学习：OpenHarmony IPC通信(L2)
Openharmony的编译构建--进阶篇2
流风的专栏
02-01 7473
openharmony 编译构建 BUILD.gn bundle.json
OpenHarmony SA启动流程
qq_40662086的博客
07-31 834
SA全称 System Ability，表示系统服务。当OH上面的APP调用client想访问service时候需要通过SA访问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值