OpenHarmony轻量型系统服务管理部件

最新推荐文章于 2025-03-11 18:17:32 发布
最新推荐文章于 2025-03-11 18:17:32 发布
阅读量682 收藏 8
点赞数 4
CC 4.0 BY-SA版权
分类专栏： OpenHarmony 移动开发 HarmonyOS 文章标签： 微服务 鸿蒙开发 harmonyos NAPI 华为 分布式 Openharmony
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/maniuT/article/details/136912245

简介

由于平台资源有限，且硬件平台多样，因此需要屏蔽不同硬件架构和平台资源的不同、以及运行形态的不同，提供统一化的系统服务开发框架。根据RISC-V、Cortex-M、Cortex-A不同硬件平台，分为两种硬件平台，以下简称M核、A核。

  • M核：处理器架构为Cortex-M或同等处理能力的硬件平台，系统内存一般低于512KB，无文件系统或者仅提供一个可有限使用的轻量级文件系统，遵循CMSIS接口规范。
  • A核：处理器架构为Cortex-A或同等处理能力的硬件平台，内存资源大于512KB，文件系统完善，可存储大量数据，遵循POSIX接口规范。

系统服务框架基于面向服务的架构，提供了服务开发、服务的子功能开发、对外接口的开发、以及多服务共进程、进程间服务调用等开发能力。其中：

  • M核：包含服务开发、服务的子功能开发、对外接口的开发以及多服务共进程的开发框架。
  • A核：在M核能力基础之上，包含了进程间服务调用、进程间服务调用权限控制、进程间服务接口的开发等能力。

系统架构

图 1 面向服务的架构

  • Provider：服务的提供者，为系统提供能力（对外接口）。
  • Consumer：服务的消费者，调用服务提供的功能（对外接口）。
  • Samgr：作为中介者，管理Provider提供的能力，同时帮助Consumer发现Provider的能力。

图 2 系统服务开发框架主体对象：

  • SamgrLite：主要提供服务的注册与发现能力。
  • Service：开发服务时，需要实现的服务的生命周期接口。
  • Feature：开发功能时，需要实现的功能的生命周期接口。
  • IUnknown：基于IUnknown开发服务或功能的对外接口。
  • IClientProxy：IPC调用时，消费者的消息发送代理。
  • IServerProxy：IPC调用时，开发者需要实现提供者的消息处理接口。

目录

表 1 系统服务框架源代码目录结构

名称描述
interfaces/kits/samgr_lite/samgrM核和A核系统服务框架对外接口定义。
interfaces/kits/samgr_lite/registryA核进程间服务调用的对外接口定义。
interfaces/kits/samgr_lite/communication/broadcastM核和A核进程内事件广播服务的对外接口定义。
services/samgr_lite/samgr/adapterPOSIX和CMSIS接口适配层来屏蔽A核M核接口差异。
services/samgr_lite/samgr/registryM核服务注册发现的桩函数。
services/samgr_lite/samgr/sourceM核和A核系统服务开发框架基础代码。
services/samgr_lite/samgr_clientA核进程间服务调用的注册与发现。
services/samgr_lite/samgr_serverA核进程间服务调用的IPC地址管理和访问控制。
services/samgr_lite/samgr_endpointA核IPC通信消息收发包管理。
services/samgr_lite/communication/broadcastM核和A核进程内事件广播服务。

约束

  • 系统服务开发框架统一使用C开发。
  • 同进程内服务间调用统一使用IUnknown接口对外象，消息接口统一由IUnknown接口传递给本服务。
  • 服务名和功能名必需使用常量字符串且长度小于16个字节。
  • M核：系统依赖上bootstrap服务，在系统启动函数中调用OHOS_SystemInit()函数。
  • A核：系统依赖samgr库，在main函数中调用SAMGR_Bootstrap()函数。

开发服务

  • 继承并重新定义服务：
typedef struct ExampleService {
    INHERIT_SERVICE;
    INHERIT_IUNKNOWNENTRY(DefaultFeatureApi);
    Identity identity;
} ExampleService;
  • 实现服务的生命周期函数：
static const char *GetName(Service *service)
{
    return EXAMPLE_SERVICE;
}

static BOOL Initialize(Service *service, Identity identity)
{
    ExampleService *example = (ExampleService *)service;
    // 保存服务的唯一身份标识，用来自己的IUnknown接口对服务发消息时使用。
    example->identity = identity;
    return TRUE;
}
static BOOL MessageHandle(Service *service, Request *msg)
{
    ExampleService *example = (ExampleService *)service;
    switch (msg->msgId) {
        case MSG_SYNC:
            // 业务处理
            break;
        default:break;
    }
    return FALSE;
}
static TaskConfig GetTaskConfig(Service *service)
{
    TaskConfig config = {LEVEL_HIGH, PRI_BELOW_NORMAL,
                         0x800, 20, SHARED_TASK};
    return config;
}
  • 创建服务对象：
static ExampleService g_example = {
    .GetName = GetName,
    .Initialize = Initialize,
    .MessageHandle = MessageHandle,
    .GetTaskConfig = GetTaskConfig,
    SERVER_IPROXY_IMPL_BEGIN,
        .Invoke = NULL,
        .SyncCall = SyncCall,
    IPROXY_END,
};
  • 向SAMGR注册服务及接口：
static void Init(void)
{
    SAMGR_GetInstance()->RegisterService((Service *)&g_example);
    SAMGR_GetInstance()->RegisterDefaultFeatureApi(EXAMPLE_SERVICE, GET_IUNKNOWN(g_example));
}
  • 定义服务的初始化入口：
SYSEX_SERVICE_INIT(Init);

开发服务的子功能

  • 继承并重新定义功能：
typedef struct DemoFeature {
    INHERIT_FEATURE;
    INHERIT_IUNKNOWNENTRY(DemoApi);
    Identity identity;
    Service *parent;
} DemoFeature;
  • 实现功能的生命周期函数：
static const char *FEATURE_GetName(Feature *feature)
{
    return EXAMPLE_FEATURE;
}

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

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

static BOOL FEATURE_OnMessage(Feature *feature, Request *request)
{
    if (request->msgId == MSG_PROC) {
        Response response = {.data = "Yes, you did!", .len = 0};
        SAMGR_SendResponse(request, &response);
        return TRUE;
    } else {
        if (request->msgId == MSG_TIME_PROC) {
            LOS_Msleep(WAIT_FEATURE_PROC * 10);
            if (request->msgValue) {
                SAMGR_PrintServices();
            } else {
                SAMGR_PrintOperations();
            }
            AsyncTimeCall(GET_IUNKNOWN(g_example));
            return FALSE;
        }
    }
    return FALSE;
}
  • 创建功能对象：
static DemoFeature g_example = {
   .GetName = FEATURE_GetName,
   .OnInitialize = FEATURE_OnInitialize,
   .OnStop = FEATURE_OnStop,
   .OnMessage = FEATURE_OnMessage,
   DEFAULT_IUNKNOWN_ENTRY_BEGIN,
       .AsyncCall = AsyncCall,
       .AsyncTimeCall = AsyncTimeCall,
       .SyncCall = SyncCall,
       .AsyncCallBack = AsyncCallBack,
   DEFAULT_IUNKNOWN_ENTRY_END,
   .identity = {-1, -1, NULL},
};
  • 向SAMGR注册功能及接口：
static void Init(void){
    SAMGR_GetInstance()->RegisterFeature(EXAMPLE_SERVICE, (Feature *)&g_example);
    SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(g_example));
}
  • 定义功能的初始化入口：
SYSEX_FEATURE_INIT(Init);

开发进程内对外接口

  • 定义IUnknown接口：
typedef struct DemoApi {
    INHERIT_IUNKNOWN;
    BOOL (*AsyncCall)(IUnknown *iUnknown, const char *buff);
    BOOL (*AsyncTimeCall)(IUnknown *iUnknown);
    BOOL (*SyncCall)(IUnknown *iUnknown, struct Payload *payload);
    BOOL (*AsyncCallBack)(IUnknown *iUnknown, const char *buff, Handler handler);
} DemoApi;
  • 定义IUnknown的引用对象：
typedef struct DemoRefApi {
    INHERIT_IUNKNOWNENTRY(DemoApi);
} DemoRefApi;
  • 初始化接口对象：
static DemoRefApi api = {
    DEFAULT_IUNKNOWN_ENTRY_BEGIN,
        .AsyncCall = AsyncCall,
        .AsyncTimeCall = AsyncTimeCall,
        .SyncCall = SyncCall,
        .AsyncCallBack = AsyncCallBack,
    DEFAULT_IUNKNOWN_ENTRY_END,
};
  • 注册服务接口：
SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(api));

调用进程内服务

  • 获取服务的对外接口：
DemoApi *demoApi = NULL;
IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
if (iUnknown == NULL) {
    return NULL;
}
int result = iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&demoApi);
if (result != 0 || demoApi == NULL) {
    return NULL;
}
  • 接口调用：
if (demoApi->AsyncCallBack == NULL) {
    return NULL;
}
demoApi->AsyncCallBack((IUnknown *)demoApi, "I wanna async call callback good result!", AsyncHandler);
  • 释放接口：
int32 ref = demoApi->Release((IUnknown *)demoApi);

开发跨进程间对外接口

  • 继承IServerProxy替代继承IUnknown：INHERIT_SERVER_IPROXY
typedef struct DemoFeatureApi {
    INHERIT_SERVER_IPROXY;
    BOOL (*AsyncCall)(IUnknown *iUnknown, const char *buff);
    BOOL (*AsyncTimeCall)(IUnknown *iUnknown);
    BOOL (*SyncCall)(IUnknown *iUnknown, struct Payload *payload);
    BOOL (*AsyncCallBack)(IUnknown *iUnknown, const char *buff, IOwner notify, INotifyFunc handler);
} DemoFeatureApi;
  • 初始化IServerProxy对象：
static DemoFeature g_example = {
    SERVER_IPROXY_IMPL_BEGIN,
    .Invoke = Invoke,
    .AsyncCall = AsyncCall,
    .AsyncTimeCall = AsyncTimeCall,
    .SyncCall = SyncCall,
    .AsyncCallBack = AsyncCallBack,
    IPROXY_END,
};
  • 实现Invoke函数来处理Ipc消息：
static int32 Invoke(IServerProxy *iProxy, int funcId, void *origin, IpcIo *req, IpcIo *reply)
{
    DemoFeatureApi *api = (DemoFeatureApi *)iProxy;
    BOOL ret;
    size_t len = 0;
    switch (funcId) {
        case ID_ASYNCALL:
            ret = api->AsyncCall((IUnknown *)iProxy, (char *)IpcIoPopString(req, &len));
            IpcIoPushBool(reply, ret);
            break;
        case ID_ASYNTIMECALL:
            ret = api->AsyncTimeCall((IUnknown *)iProxy);
            IpcIoPushBool(reply, ret);
            break;
        case ID_SYNCCALL: {
            struct Payload payload;
            payload.id = IpcIoPopInt32(req);
            payload.value = IpcIoPopInt32(req);
            payload.name = (char *)IpcIoPopString(req, &len);
            ret = api->SyncCall((IUnknown *)iProxy, &payload);
            IpcIoPushString(reply, ret ? "TRUE" : "FALSE");
        }
            break;
        case ID_ASYNCCALLBACK: { // convert to sync proxy
            IpcIoPushString(reply, "Yes, you did!");
            IpcIoPushBool(reply, TRUE);
        }
            break;
        default:
            IpcIoPushBool(reply, FALSE);
            break;
    }
    return EC_SUCCESS;
}
  • 注册接口：与进程内接口注册一致
SAMGR_GetInstance()->RegisterFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE, GET_IUNKNOWN(g_example));

调用跨进程间服务

  • 获取跨进程服务的对外接口：
IClientProxy *demoApi = NULL;
IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
if (iUnknown == NULL) {
    return NULL;
}
int result = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, (void **)&demoApi);
if (result != 0 || demoApi == NULL) {
    return NULL;
}
  • 调用Ipc消息接口：
IpcIo request;char data[250];
IpcIoInit(&request, data, sizeof(data), 0);
demoApi->Invoke(demoApi, 0, &request, NULL, NULL);
  • 释放接口：
int32 ref = demoApi->Release((IUnknown *)demoApi);

开发跨进程间服务调用客户端代理

  • 定义IPC接口客户端代理：
typedef struct DemoClientProxy {
    INHERIT_CLIENT_IPROXY;
    BOOL (*AsyncCall)(IUnknown *iUnknown, const char *buff);
    BOOL (*AsyncTimeCall)(IUnknown *iUnknown);
    BOOL (*SyncCall)(IUnknown *iUnknown, struct Payload *payload);
    BOOL (*AsyncCallBack)(IUnknown *iUnknown, const char *buff, IOwner notify, INotifyFunc handler);
} DemoClientProxy;
typedef struct DemoClientEntry {
    INHERIT_IUNKNOWNENTRY(DemoClientProxy);
} DemoClientEntry;
  • 实现客户端代理封装Ipc消息接口：
static BOOL AsyncCall(IUnknown *iUnknown, const char *buff)
{
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    IpcIoPushString(&request, buff);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_ASYNCALL, &request, NULL, NULL);
    return ret == EC_SUCCESS;
}

static BOOL AsyncTimeCall(IUnknown *iUnknown)
{
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_ASYNTIMECALL, &request, NULL, NULL);
    return ret == EC_SUCCESS;
}

static int Callback(IOwner owner, int code, IpcIo *reply)
{
    size_t len = 0;
    return strcpy_s(owner, MAX_DATA_LEN, (char *)IpcIoPopString(reply, &len));
}

static BOOL SyncCall(IUnknown *iUnknown, struct Payload *payload)
{
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    IpcIoPushInt32(&request, payload->id);
    IpcIoPushInt32(&request, payload->value);
    IpcIoPushString(&request, payload->name);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_SYNCCALL, &request, data, Callback);
    data[MAX_DATA_LEN - 1] = 0;
    HILOG_INFO(HILOG_MODULE_APP, "[TID:0x%lx]Remote response is %s!", pthread_self(), data);
    return ret == EC_SUCCESS;
}

struct CurrentNotify {
    IOwner notify;
    INotifyFunc handler;
};

static int CurrentCallback(IOwner owner, int code, IpcIo *reply)
{
    struct CurrentNotify *notify = (struct CurrentNotify *)owner;
    size_t len = 0;
    char *response = (char *)IpcIoPopString(reply, &len);
    HILOG_INFO(HILOG_MODULE_APP, "[TID:0x%lx]Notify Remote response is %s!", pthread_self(), response);
    notify->handler(notify->notify, response);
    return EC_SUCCESS;
}

static BOOL AsyncCallBack(IUnknown *iUnknown, const char *buff, IOwner notify, INotifyFunc handler)
{
    struct CurrentNotify owner = {notify, handler};
    DemoClientProxy *proxy = (DemoClientProxy *)iUnknown;
    IpcIo request;
    char data[MAX_DATA_LEN];
    IpcIoInit(&request, data, MAX_DATA_LEN, 0);
    IpcIoPushString(&request, buff);
    int ret = proxy->Invoke((IClientProxy *)proxy, ID_ASYNCCALLBACK, &request, &owner, CurrentCallback);
    return ret == EC_SUCCESS;
}
  • 实现客户端代理的工厂方法：
void *DEMO_CreatClient(const char *service, const char *feature, uint32 size)
{
    (void)service;
    (void)feature;
    uint32 len = size + sizeof(DemoClientEntry);
    uint8 *client = malloc(len);
    (void)memset_s(client, len, 0, len);
    DemoClientEntry *entry = (DemoClientEntry *)&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.AsyncCall = AsyncCall;
    entry->iUnknown.AsyncTimeCall = AsyncTimeCall;
    entry->iUnknown.SyncCall = SyncCall;
    entry->iUnknown.AsyncCallBack = AsyncCallBack;
    return client;
}
void DEMO_DestroyClient(const char *service, const char *feature, void *iproxy)
{
    free(iproxy);
}
  • 将客户端代理的工厂方法注册到SAMGR：
SAMGR_RegisterFactory(EXAMPLE_SERVICE, EXAMPLE_FEATURE, DEMO_CreatClient, DEMO_DestroyClient);
  • 获取跨进程服务的对外接口：
DemoClientProxy *demoApi = NULL;
IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(EXAMPLE_SERVICE, EXAMPLE_FEATURE);
if (iUnknown == NULL) {
   return NULL;
}
int result = iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&demoApi);
if (result != 0 || demoApi == NULL) {
   return NULL;
}
  • 调用跨进程服务的客户端代理接口：
if (demoApi->AsyncCallBack == NULL) {
    return NULL;
}
demoApi->AsyncCallBack((IUnknown *)demoApi,
                       "I wanna async call callback good result!", NULL, AsyncHandler);
  • 释放接口：
int32 ref = demoApi->Release((IUnknown *)demoApi);

为了能让大家更好的学习鸿蒙（HarmonyOS NEXT）开发技术，这边特意整理了《鸿蒙开发学习手册》（共计890页），希望对大家有所帮助：https://qr21.cn/FV7h05

《鸿蒙开发学习手册》：

如何快速入门：https://qr21.cn/FV7h05

  1. 基本概念
  2. 构建第一个ArkTS应用
  3. ……

开发基础知识：https://qr21.cn/FV7h05

  1. 应用基础知识
  2. 配置文件
  3. 应用数据管理
  4. 应用安全管理
  5. 应用隐私保护
  6. 三方应用调用管控机制
  7. 资源分类与访问
  8. 学习ArkTS语言
  9. ……

基于ArkTS 开发：https://qr21.cn/FV7h05

  1. Ability开发
  2. UI开发
  3. 公共事件与通知
  4. 窗口管理
  5. 媒体
  6. 安全
  7. 网络与链接
  8. 电话服务
  9. 数据管理
  10. 后台任务(Background Task)管理
  11. 设备管理
  12. 设备使用信息统计
  13. DFX
  14. 国际化开发
  15. 折叠屏系列
  16. ……

鸿蒙开发面试真题（含参考答案）：https://qr18.cn/F781PH

鸿蒙开发面试大盘集篇（共计319页）：https://qr18.cn/F781PH

1.项目开发必备面试题
2.性能优化方向
3.架构方向
4.鸿蒙开发系统底层方向
5.鸿蒙音视频开发方向
6.鸿蒙车载开发方向
7.鸿蒙南向开发方向

OpenHarmony应用开启Service以及完成自启动和常驻
龚礼鹏的博客
05-28 2057
由于有需求实现一个后台常驻服务，这里就是来实现在鸿蒙里面如何实现后台服务并且实现自启动和常驻。
OpenHarmony实战：小型系统编译构建
m0_64420071的博客
04-03 1886
搭建OpenHarmony基础环境
鸿蒙内核源码分析表,鸿蒙内核源码分析(双向链表篇) | 谁是内核最重要结构体 ? | 开篇致敬鸿蒙内核开发者 | v1.10...
weixin_34452086的博客
05-31 123
谁是鸿蒙内核最重要的结构体?答案一定是: LOS_DL_LIST(双向链表),它长这样.typedefstructLOS_DL_LIST{//双向链表，内核最重要结构体structLOS_DL_LIST*pstPrev;/**structLOS_DL_LIST*pstNext;/**}LOS_DL_LIST;结构体够简单了吧,只有前后两个指向自己的指针,但恰恰是因为太简单,所以...
openharmony 北向开发基础:ohos自定义子系统,自定义部件,调用hilog部件,hilog日志封装傻瓜式教程
她的吻让他
08-17 1581
为了客服上述单部件创建的so库无法被另一部件gn模板调用的问题,本章节讲解如何使用部件间依赖首先用白话描述下几个关键名词子系统:子系统是一个逻辑上的概念,是鸿蒙模块化构建的第一层,由若干个部件组成,在形式上表现为一个子系统文件夹内部有多个部件文件夹,子系统目录的位置一般为源码根目录,在//build/subsystem_config.json 中可以增删编辑你需要的子系统。
【OpenHarmony】标准系统 新增子系统/部件
Kemin123的博客
07-17 1138
标准系统新增部件
如何给openharmony增加一个部件暨如何阅读openharmony部件的代码
weixin_54516968的博客
08-09 543
openharmony部件介绍
OpenHarmony实战开发——轻量型系统服务管理部件
m0_70748458的博客
04-29 732
由于平台资源有限，且硬件平台多样，因此需要屏蔽不同硬件架构和平台资源的不同、以及运行形态的不同，提供统一化的系统服务开发框架。根据RISC-V、Cortex-M、Cortex-A不同硬件平台，分为两种硬件平台，以下简称M核、A核。M核：处理器架构为Cortex-M或同等处理能力的硬件平台，系统内存一般低于512KB，无文件系统或者仅提供一个可有限使用的轻量级文件系统，遵循CMSIS接口规范。
OpenHarmony 实战开发 ——轻量型系统服务管理部件
liuhaojiabin的博客
11-21 947
由于平台资源有限，且硬件平台多样，因此需要屏蔽不同硬件架构和平台资源的不同、以及运行形态的不同，提供统一化的系统服务开发框架。根据RISC-V、Cortex-M、Cortex-A不同硬件平台，分为两种硬件平台，以下简称M核、A核。M核：处理器架构为Cortex-M或同等处理能力的硬件平台，系统内存一般低于512KB，无文件系统或者仅提供一个可有限使用的轻量级文件系统，遵循CMSIS接口规范。
OpenHarmony轻量系统开发【1】初始OpenHarmony
m0_70748458的博客
05-21 1285
OpenHarmony是由开放原子开源基金会（OpenAtom Foundation）孵化及运营的开源项目，目标是面向全场景、全连接、全智能时代，基于开源的方式，搭建一个智能终端设备操作系统的框架和平台，促进万物互联产业的繁荣发展。技术架构如下：中查看。特别是内核层的多内核设计、HDF驱动框架、分布式能力等。OpenHarmony是一个面向全场景，支持各类设备的系统。这里的设备就包括像MCU单片机这样资源较少的芯片，也支持像RK3568这样的多核CPU。
OpenHarmony轻量系统中内核资源主要管理方式
m0_70748458的博客
07-12 1070
轻量系统中内核资源多采用数组与空闲链表相结合的方式。除了OpenHarmony轻量系统，其他嵌入式系统中这类的数据存储方式也比较常见。这种方式有如下几个突出的优点● 简单易懂● 读写效率高● 代码紧凑搭建开发环境Windows 开发环境的搭建Ubuntu 开发环境搭建Linux 与 Windows 之间的文件共享……构建子系统启动流程子系统分布式任务调度子系统分布式通信子系统驱动子系统……
【开源鸿蒙】OpenHarmony 5.0轻量系统最小开发环境搭建
码工许师傅
10-24 4705
本文将会介绍，如何下载源代码和工具链，让磁盘占用尽可能小的同时，还可以进行轻量系统上的OpenHarmony开发（进行源码编译构建）。最终实现了将磁盘占用从完整源码的67G减少到了15G，不到完整源码的四分之一磁盘占用！
OFCA-OpenHarmony课后习题答案
热门推荐
踏雨歌青春，诗酒趁年华
05-20 1万+
本文是 OFCA-OpenHarmony 认证模拟考试的习题答案，涵盖 OpenHarmony 的多内核设计、权限申请、通知发布、系统线程、启动过程、分布式软总线、模块导入、文件管理、公共事件等多个方面。每道题目均提供了详细的选择项和正确答案，旨在帮助考生熟悉考试内容，掌握关键知识点，提高通过认证考试的几率。
系统架构设计——OpenHarmony系统简介
庄小焱
05-26 7847
主要是介绍OpenHarmony 鸿蒙-面向全场景的分布式操作系统的新的技术点和一些新的概念，同时学习OpenHarmony 鸿蒙-面向全场景的分布式操作系统的具体的使用了开发。
OpenHarmony体系架构深度解析
2302_80853925的博客
03-11 1096
fill:#333;color:#333;color:#333;fill:none;important;important;important;important;important;important;important;important;支撑服务接口内核层系统服务层框架层应用层。
OpenHarmony之系统功能框架分析
qq_45766510的博客
12-24 861
本篇将介绍一些有关系统功能框架的一些相关内容，并对其相应的部分进行介绍。接下来，为本篇的正文内容。 引入 由于平台资源有限，且硬件平台多样，因此需要屏蔽不同硬件架构和平台资源的不同、以及运行形态的不同，提供统一化的系统服务开发框架。因此提供了统一的系统功能（SA）框架来协调硬件架构（例如Cortex-M和Cortex-A）具体介绍为： Cortex-M 处理器架构为Cortex-M或同等处理能力的硬件平台，系统内存一般**低于512KB**，无文件系统或者仅提供一个可有限使用的*轻量级*文件
OpenHarmony（鸿蒙南向开发）——子系统开发内核
maniuT的博客
08-02 1666
OpenHarmony的Linux内核基于开源Linux内核LTS分支演进，在此基线基础上，回合CVE补丁及OpenHarmony特性，作为OpenHarmony Common Kernel基线。针对不同的芯片，各厂商合入对应的板级驱动补丁，完成对OpenHarmony的基线适配。Linux社区LTS 4.19.y分支信息请查看kernel官网。Linux社区LTS 5.10.y分支信息请查看kernel官网。
HarmonyOS Next 大文件拷贝案例_鸿蒙next 拷贝本地文件(3)
2401_83946261的博客
04-09 1115
有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。为了能够帮助大家快速掌握**鸿蒙（HarmonyOS NEXT）**应用开发技术知识。在此给大家分享一下我结合鸿蒙最新资料整理出来的鸿蒙南北向开发学习路线以及整理的最新版鸿蒙学习文档资料。这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了。
【OpenHarmony】OpenHarmony 简介 ( HarmonyOS / OpenHarmony - Android / AOSP 对比关联 | 鸿蒙开发者定位及使用的开发语言和开发工具)
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-26 7113
一、OpenHarmony 简介 1、OpenHarmony 由来 2、OpenHarmony 架构 3、OpenHarmony 特点 二、HarmonyOS / OpenHarmony - Android / AOSP 对比关联 1、HarmonyOS 与 Android 的关系 2、HarmonyOS 与 OpenHarmony 的关系 3、HarmonyOS 与 OpenHarmony 的版本迭代 三、鸿蒙开发者定位及使用的开发语言和开发工具
OpenHarmony：操作系统的内核架构
2401_82546228的博客
01-12 2105
OpenHarmony的Linux内核基于开源Linux内核LTS分支演进，在此基线基础上，回合CVE补丁及OpenHarmony特性，作为OpenHarmony Common Kernel基线。针对不同的芯片，各厂商合入对应的板级驱动补丁，完成对OpenHarmony的基线适配。内核的Patch组成模块，在编译构建流程中，针对具体芯片平台，合入对应的架构驱动代码，进行编译对应的内核镜像。所有补丁来源均遵守GPL-2.0协议。
南向开发保姆
最新发布
03-21
| **移植指南** | [轻量系统芯片移植指南](引用4) | 子系统裁剪、部件适配、编译调试 | | **API实战** | [上传下载功能开发教程](引用5) | 网络任务管理、接口调用实践 | | **驱动开发** | [WLAN开发手册](引用3) | ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值