嵌入式系统开发 -基于分布式系统OpenHarmony 课件汇 朱明 05 OpenHarmony的服务框架-09-小型系统应用开发

基于OpenHarmony的嵌入式开发

第五章OpenHarmony的服务框架安全边距5.1基础数据服务[5.1.0]基础数据服务

服务是现代操作系统中的重要功能，服务能够将不同的硬件设备资源和软件系统资源进行归类和集中，对外提供一整套能够实现发现、注册和调用的机制，实现对特定功能的集中化操作。极大程度的简化操作系统、驱动框架、第三方应用的操作复杂度。

OpenHarmony的服务框架具有实现编程开发多样性的重要特点。基于OpenHarmony的服务框架（SAFWK，SystemAbilityFramework），通过LiteIPC等机制，向外提供了与开发语言无关的接口，实现了底层汇编和C语言到更丰富的编程语言的过渡。基于OpenHarmony的嵌入式开发2安全边距5.1基础数据服务[5.1.0]基础数据服务

OpenHarmony子系统架构图基于OpenHarmony的嵌入式开发3系统服务框架基于面向服务的架构，提供了服务（Service）开发、特性（Feature）开发、对外接口（IUnknown）的开发、以及多服务共进程、进程间服务调用等开发能力。在不同的内核平台（性能平台）上，也提供了不同的能力。（1）LiteOS-M内核：包括服务开发、服务的子功能开发、对外接口的开发以及多服务共进程的开发框架。LiteOS-M上服务框架依赖依赖bootstrap服务，在系统启动函数中调用HOS_SystemInit()函数。（2）LiteOS-A内核：在LiteOS-M内核能力基础之上，包括了进程间服务调用、进程间服务调用权限控制、进程间服务接口的开发等能力。安全边距5.1基础数据服务[5.1.1]Vector结构体

Vector是一种动态数组，支持根据键-值进行查找等操作，在服务框架中，用于存放各种服务对象。基于OpenHarmony的嵌入式开发4/*ThisclassisapplicabletotheClanguagedevelopmentscenariowherethedatavolumeissmall*anddynamicexpansionisrequired.\n*/typedefstructSimpleVector{/**Maximumnumberofdatarecordsthatcanbestored.Theinitialvalueis<b>0</b>.*/

int16max;/**Peakvalueofthenumberofstoreddatarecords.Theinitialvalueis<b>0</b>.*/int16top;/**Numberofdatarecordsthathavebeenreleased.Theinitialvalueis<b>0</b>.*/int16free;/**Datastoragepointer*/void**data;/*Convertsadataelementintoakeyforcomparison.Thekeyisprovidedbyusers,andthedefaultvalueis<b>NULL</b>.*/VECTOR_Keykey;/*Comparesthesizesofkey1andkey2,whichareprovidedbyusers.Thevalue<b>1</b>indicatesthatkey1isgreater*thankey2,thevalue<b>0</b>indicatesthatkey1isequaltokey2,andthevalue<b>-1</b>indicatesthatkey1isless*thankey2.Thedefaultvalueis<b>NULL</b>*/VECTOR_Comparecompare;}Vector;/foundation/distributedschedule/samgr_lite/interfaces/kits/samgr/common.hdata的最大存储范围，即data[max]top表示当前存储在data中的最大地址，即data[top]=XXX存储指针

free表示记录释放的data[index]的数量data是具体存放数据的地址，也是整个vector的关键，注意data类型key是函数指针，用于将一个数据元素转变为key进行比compare是函数指针，用于比较两个key是否相同。key和compare主要在Vector创建时使用。安全边距5.1基础数据服务[5.1.1]Vector结构体

Vector_Make操作：VECTOR_Make函数所执行的仅仅是简单的赋初值功能，并返回创建的Vector对象，函数传入了key和compare函数。

VECTOR_Clear操作：执行对某个vector结构体空间的释放，在执行前，应先调用SAMGR_Free将data所指的空间释放，再释放空间。基于OpenHarmony的嵌入式开发5VectorVECTOR_Make(VECTOR_Keykey,VECTOR_Comparecompare){Vectorvector={0,0,0,NULL,key,compare};returnvector;}voidVECTOR_Clear(Vector*vector){if(vector==NULL){...}if(vector->data==NULL){...}SAMGR_Free(vector->data);vector->max=0;vector->top=0;vector->free=0;vector->data=NULL;}安全边距5.1基础数据服务[5.1.1]Vector结构体

VECTOR_Add操作：将element添加到data[top]中。基本流程如下：

①当top<max时，将element直接存入data[top]位置，返回top++；

②当top>=max时，由于可能存在free的空间，所以进行循环，当有空闲位置(data[i]==NULL)时将element存入，并返回位置i，通过registerService函数可知返回的i存储为serviceId，所以返回的实际是当前存储对象的位置；③若没有找到空闲的位置，则需要对vector进行空间扩展；④分配新的空间，空间大小为原空间大小+4；⑤将原data中的数据复制到新空间中；⑥将新空间更新到vector中；⑦重复第一步的操作，需要注意的是，return先返回的是top的位置，表示当前存储element的位置，然后再执行++操作，用于下一次对象存储的开始top起点。基于OpenHarmony的嵌入式开发6free表示记录释放的data[index]的数量安全边距5.1基础数据服务[5.1.1]Vector结构体

VECTOR_At操作：根据所给的index返回data[index]

VECTOR_Swap操作：将index对应的element提取并返回,如果传入了新的element则将其覆盖index对应的旧element，传入NULL则free++表示多一块空闲空间，将旧element对应位置指针置为NULL。基于OpenHarmony的嵌入式开发7void*VECTOR_At(Vector*vector,int16index){if(vector==NULL||vector->top<=index||index<0){returnNULL;}returnvector->data[index];}返回的是void指针类型void*VECTOR_Swap(Vector*vector,int16index,void*element){if(vector==NULL||vector->top<=index||index<0){...}if(element==NULL){

vector->free++;}void*oldElement=vector->data[index];vector->data[index]=element;returnoldElement;}安全边距5.1基础数据服务[5.1.1]Vector结构体

VECTOR_Find/VECTOR_FindByKey：查找element对应index函数基于OpenHarmony的嵌入式开发8int16VECTOR_FindByKey(Vector*vector,constvoid*key)

{if(vector==NULL||key==NULL){returnINVALID_INDEX;}int16i;for(i=0;i<vector->top;++i){if(vector->data[i]==NULL){

continue;}void*first=(vector->key!=NULL)?vector->key(vector->data[i]):vector->data[i];if(first==key){

returni;}if(vector->compare==NULL||first==NULL){

continue;}if(vector->compare(first,key)==0){returni;}}returnINVALID_INDEX;}int16VECTOR_Find(Vector*vector,constvoid*element){if(vector==NULL||element==NULL){returnINVALID_INDEX;}returnVECTOR_FindByKey(vector,(vector->key==NULL)?element:vector->key(element));}安全边距5.1基础数据服务[5.1.2]Service

Service（服务）指一个特定的模块在SAMGR中所注册的对象。SA的服务中心通过Vector保存了多个服务，每一个服务对应着一个线程池和消息队列，又对应着0个或若干个feature。基于OpenHarmony的嵌入式开发9/*@briefIndicatesthebasictypeofaservice.*Youneedtoimplementthefunctionpointersof<b>Service</b>

*/structService{

/*ThisfunctioniscalledbySamgrduringserviceregistrationandstartup.*Youneedto

implementthisfunction.*/

constchar*(*GetName)(Service*service);

/*AfterSamgrassignstaskstoaservice,theservicecallsthefunctioninitsowntasks.*Youneedtoimplementthisfunction.*/

BOOL(*Initialize)(Service*service,Identityidentity);

/*Thisfunctionisusedtoprocessrequestssentbythecallerthrough{@linkIUnknown}.*Youneedtoimplementthisfunction.*/

BOOL(*MessageHandle)(Service*service,Request*request);

/*Thisfunctionisusedtoreturntaskconfigurations.Youneedtoimplementthisfunction.*/

TaskConfig(*GetTaskConfig)(Service*service);};注册和启动时调用，返回最长16字节常量字符串，作为服务名称服务初始化服务消息处理函数返回服务的Task配置项，包括服务的优先级、栈尺寸、队列尺寸和Task类型等配置内容/foundation/distributedschedule/samgr_lite/interfaces/kits/samgr/service.h安全边距5.1基础数据服务[5.1.2]Service

ServiceImpl结构体：保存服务实现过程中的内部数据基于OpenHarmony的嵌入式开发10structServiceImpl{Service*service;IUnknown*defaultApi;TaskPool*taskPool;Vectorfeatures;int16serviceId;uint8inited;Operationsops;};Service*service，指向当前ServiceImpl对象所对应的具体的service对象，这些具体的service对象都是Service类的子类对象IUnknown*defaultApi，继承了IUnknown接口的service的接口默认APITaskPool*taskPool，samgr为service创建的taskPool的指针，同时创建了还有消息队列，queueId同时保存在taskPool中Vectorfeatures，feature需要依赖于对应的service才能注册和运行，一个service可以有0个、1个或多个feature。service本身不记录其所对应的feature的信息，由ServiceImpl.features完成int16serviceId，当前ServiceImpl对象指针保存在g_samgrImpl.servicesvector内的data[serviceId]中uint8inited，标记当前ServiceImpl对应的service的状态，service只有在init后才能注册feature。service在处理消息事件的时候，状态也要对应置为SVC_BUSY，处理完消息后返回SVC_IDLE状态enumInitStatus{SVC_INIT=0,SVC_IDLE,SVC_BUSY,};Operationsops，记录service处理消息事件的时间戳、msg、步骤和是否存在异常等信息安全边距5.1基础数据服务[5.1.3]Feature

Feature（功能或特性）指在一个服务对象中，能够对外提供的具体的可以调用的接口，一个服务可以对应多个Feature

基于OpenHarmony的嵌入式开发11/***@briefDefinesthebaseclassofafeature.*/structFeature{/*ThisfunctionisimplementedbydevelopersandcalledbySamgrduringfeatureregistration*andstartup.*/

constchar*(*GetName)(Feature*feature);/*Thisfunctionisimplementedbydevelopers.AfterSamgrdispatchestaskstoaservice,the*servicecallsthisfunctioninitsowntasks.*/

void(*OnInitialize)(Feature*feature,Service*parent,Identityidentity);/*ThisfunctionisimplementedbydevelopersandiscalledbySamgrwhenafeatureis*deregisteredtostoprunningservices.*/

void(*OnStop)(Feature*feature,Identityidentity);/*Thisfunctionisimplementedbydeveloperstoprocessrequestssentbycallersthrough*IUnknown.*/

BOOL(*OnMessage)(Feature*feature,Request*request);};/foundation/distributedschedule/samgr_lite/interfaces/kits/samgr/feature.h注册和启动时调用，返回最长16字节常量字符串，作为特性名称特性初始化特性停止，服务在取消注册或停止特性时调用特性消息处理函数，用于处理调用者通过IUnknown传递的请求安全边距5.1基础数据服务[5.1.4]IUnknown

IUnknown：OpenHarmony的一种基本COM组件（ComponentObjectModel，组件对象模型）基于OpenHarmony的嵌入式开发12/***@briefDefinesthe<b>IUnknown</b>class.**Youneedtoinheritthisstructurewhendevelopingasubclassofthe<b>IUnknown</b>interface.\n**/structIUnknown{/***Queriesthesubclassobjectofthe<b>IUnknown</b>interfaceofaspecifiedversion*(downcasting).*/

int(*QueryInterface)(IUnknown*iUnknown,intversion,void**target);/**Addsthereferencecount.*/

int(*AddRef)(IUnknown*iUnknown);/**Releasethereferencetoan<b>IUnknown</b>interface.*/int(*Release)(IUnknown*iUnknown);};/foundation/distributedschedule/samgr_lite/interfaces/kits/samgr/iunknown.hIUnknown的引用计数,用计数每增加1（AddRef）就代表当前组件被一个对象引用，每减少1（Release）就代表当前组件减少了一个引用者，当引用计数为0时，就代表已经没有对象使用它，其生命周期也就就到此结束，可以释放其所占用的资源。QueryInterface，查询接口，是一种自表述接口，可以通过QueryInterface查询某个对象是否支持某些特定的接口，若支持该接口，则在target参数返回指向该接口的指针，否则返回错误。安全边距5.1基础数据服务[5.1.4]IUnknown

IUnknown：OpenHarmony的一种基本COM组件（ComponentObjectModel，组件对象模型）基于OpenHarmony的嵌入式开发13intIUNKNOWN_QueryInterface(IUnknown*iUnknown,intver,void**target){if(iUnknown==NULL||target==NULL){returnEC_INVALID;}IUnknownEntry*entry=GET_OBJECT(iUnknown,IUnknownEntry,iUnknown);if((entry->ver&(uint16)ver)!=ver){returnEC_INVALID;}if(ver==OLD_VERSION&&entry->ver!=OLD_VERSION&&(entry->ver&(uint16)DEFAULT_VERSION)!=DEFAULT_VERSION){returnEC_INVALID;}*target=iUnknown;iUnknown->AddRef(iUnknown);returnEC_SUCCESS;}typedefstructIUnknownEntry{/**VersioninformationofIUnknowninterface.*/uint16ver;/**ReferencecountofIUnknowninterface.*/int16ref;IUnknowniUnknown;}IUnknownEntry;安全边距5.1基础数据服务[5.1.5]Message：与消息相关的结构体

Identity：决定请求和响应对应服务或功能的id

基于OpenHarmony的嵌入式开发14/***@briefIdentifiesaserviceandfeature.**Youcanusethisstructuretoidentitya{@linkIUnknown}featuretowhichmessageswillbe*sentthroughtheasynchronousfunctionof{@linkIUnknown}.\n**/structIdentity{/**ServiceID*/int16serviceId;/**FeatureID*/int16featureId;/**MessagequeueID*/MQueueIdqueueId;};安全边距5.1基础数据服务[5.1.5]Message：与消息相关的结构体

Request：保存请求的消息id与数据内容基于OpenHarmony的嵌入式开发15/***@briefDefinesarequest.**Youcanusethisstructuretodefinetherequestthatwillbesenttoafeaturethroughthe*asynchronousfunctionof{@linkIUnknown}.\n*Request,whichisdatathatispackedtosendtoafeature.\n*Ifthedataisnotemptyandthelengthisnot0,thesystemautomaticallyreleasesthedata.\n**/structRequest{/**MessageID*/int16msgId;/**Datalength*/int16len;/**Datacontent*/void*data;/**Messagevalue,whichisdefinedbydevelopers*/uint32msgValue;};安全边距5.1基础数据服务[5.1.5]Message：与消息相关的结构体

Response：主要包含响应的内容基于OpenHarmony的嵌入式开发16/***@briefDefinesaresponse.**Thisstructureisusedtosendaresponseafterthemessageprocessingfunctionofaservice*orfeatureprocessesarequest.\n*Ifthedataisnotemptyandthelengthisnot0,thesystemautomaticallyreleasesthedata.\n**/structResponse{/**Datacontent*/void*data;/**Datalength*/int16len;#ifdefMINI_SAMGR_LITE_RPCvoid*reply;#endif};安全边距5.1基础数据服务[5.1.5]Message：与消息相关的结构体

Exchange：消息管理的基础，函数对与请求与响应的功能性调用都是以Exchange结构体的内容作为基础的其他结构体：TaskConfig（Definestaskconfigurationsforaservice,includingthetaskpriority,

stacksize,queuesize,tasktype,andsharedtaskID）、TaskPool和Operations等基于OpenHarmony的嵌入式开发17structExchange{Identityid;

/**<Thetargetserviceorfeatureidentity.*/Requestrequest;Responseresponse;shorttype;

/**<Theexchangetype.*/Handlerhandler;

/**<asyncresponseorimmediatelyrequestcallbackfunction*/uint32*sharedRef;

/**<usetosharetherequestandresponseforsavingmemory*/};安全边距5.1基础数据服务[5.1.6]SamgrLiteImpl

SamgrLiteImpl基于OpenHarmony的嵌入式开发18structSamgrLiteImpl{SamgrLitevtbl;MutexIdmutex;BootStatusstatus;Vectorservices;TaskPool*sharedPool[MAX_POOL_NUM];};vtbl：用于实现SamgrLite的函数指针，通过指针的关联就可以通过vtbl中的函数对service、feature和api进行注册、注销和获取API等操作；mutex：mutex是互斥锁，用于保证多线程下共享数据的同步，其实现方法取决于内核，每一个SamgrLiteImpl对应唯一的mutexId。status：service启动的状态typedefenum{BOOT_SYS=0,

//将要启动系统Service

BOOT_SYS_WAIT=1,

//正在启动系统Service

BOOT_APP=2,

//将要启动APPServcie

BOOT_APP_WAIT=3,

//正在启动APPServcie

BOOT_DYNAMIC=4,

//将要启动DynamicServcie

BOOT_DYNAMIC_WAIT=5,

//正在启动DynamicService

}BootStatus;services表示在注册Servcie时将一个servcieImpl结构体追加到Vector末尾，用于后续的初始化，通过该方法实现对所有注册的子系统的管理sharedPool[MAX_POOL_NUM]则表示为每个service创建的taskPool资源，通过GetTaskConfig()返回每个service运行时的task参数配置安全边距5.2服务框架的启动和注册[5.2.1]服务框架的启动过程

SAMGR_Bootstrap()函数完成服务框架启动

LiteOS-M服务框架需要依赖bootstrap服务，在系统启动函数中调用系统初始化函数实现LiteOS-A服务框架启动，是由服务框架支持的进程在其main()函数中调用相关函数实现的。

SAMGR_Bootstrap()会启动已经注册的服务，对所有系统启动时尚未初始化的服务进行初始化，使得整个系统进入DYNAMIC平稳运行的状态。服务创建的最小完整流程：①注册系统服务(service)；②注册系统服务特性(feature)；③通过samgr启动并初始化所有的系统服务和功能基于OpenHarmony的嵌入式开发19安全边距5.2服务框架的启动和注册[5.2.1]服务框架的启动过程

SAMGR_Bootstrap()函数完成服务框架启动基于OpenHarmony的嵌入式开发20进入SAMGR_Bootstrap()获取已经创建的g_samgrImpl检查互斥锁是否初始化创建日志信息退出当前函数清看门狗创建临时的Vector创建互斥锁迁移BootStatus

状态否是将未初始化的服务加入到临时VectorvoidSAMGR_Bootstrap(void){SamgrLiteImpl*samgr=GetImplement();if(samgr->mutex==NULL){HILOG_INFO(HILOG_MODULE_SAMGR,"Samgrisnotinit,noservice!");return;}WDT_Reset(WDG_SVC_BOOT_TIME);VectorinitServices=VECTOR_Make(NULL,NULL);MUTEX_Lock(samgr->mutex);samgr->status=TO_NEXT_STATUS(samgr->status);int16size=VECTOR_Size(&(samgr->services));int16i;for(i=0;i<size;++i){ServiceImpl*serviceImpl=(ServiceImpl*)VECTOR_At(&(samgr->services),i);if(serviceImpl==NULL||serviceImpl->inited!=SVC_INIT){continue;}VECTOR_Add(&initServices,serviceImpl);}……安全边距5.2服务框架的启动和注册[5.2.1]服务框架的启动过程

SAMGR_Bootstrap()函数完成服务框架启动基于OpenHarmony的嵌入式开发21进入SAMGR_Bootstrap()获取已经创建的g_samgrImpl检查互斥锁是否初始化创建日志信息退出当前函数清看门狗创建临时的Vector创建互斥锁迁移BootStatus

状态否是将未初始化的服务加入到临时Vector释放护互斥锁初始化Vector中保存的服务清空释放Vector检查初始化是否完成创建日志信息函数结束是否MUTEX_Unlock(samgr->mutex);HILOG_INFO(HILOG_MODULE_SAMGR,BOOT_FMT(samgr->status),

VECTOR_Size(&initServices));InitializeAllServices(&initServices);VECTOR_Clear(&initServices);int32err=InitCompleted();if(err!=EC_SUCCESS){HILOG_INFO(HILOG_MODULE_SAMGR,

"Gotonextbootstepreturncode:%d",err);}}安全边距5.2服务框架的启动和注册[5.2.2]服务框架的注册过程示例（broadcast服务）（1）注册系统服务：Init基于OpenHarmony的嵌入式开发22staticvoidInit(void)

{SAMGR_GetInstance()->RegisterService((Service*)&g_broadcastService);}/foundation/distributedschedule/samgr_lite/communication/broadcast/source/broadcast_service.cSamgrLite*SAMGR_GetInstance(void)

{if(g_samgrImpl.mutex==NULL){

//g_samgrImpl没有初始化，调用Init并返回g_samgrImpl.vtblInit();}

return&(GetImplement()->vtbl);}/foundation/distributedschedule/samgr_lite/samgr/source/samgr_lite.ctypedefstructSamgrLite{BOOL(*RegisterService)(Service*service);Service*(*UnregisterService)(constchar*name);BOOL(*RegisterFeature)(constchar*serviceName,Feature*feature);……}staticvoidInit(void)

{WDT_Start(WDG_SAMGR_INIT_TIME);g_samgrImpl.vtbl.RegisterService=RegisterService;g_samgrImpl.vtbl.UnregisterService=UnregisterService;g_samgrImpl.vtbl.RegisterFeature=RegisterFeature;……}广播服务的初始化函数安全边距5.2服务框架的启动和注册[5.2.2]服务框架的注册过程示例（broadcast服务）（1）注册系统服务:RegisterService基于OpenHarmony的嵌入式开发23staticBOOLRegisterService(Service*service){if(IsInvalidService(service)){returnFALSE;}

SamgrLiteImpl*samgr=GetImplement();MUTEX_Lock(samgr->mutex);

int16pos=VECTOR_FindByKey(&(samgr->services),(void*)service->GetName(service));if(pos>=0){MUTEX_Unlock(samgr->mutex);returnFALSE;}if(VECTOR_Num(&(samgr->services))>=MAX_SERVICE_NUM){MUTEX_Unlock(samgr->mutex);returnFALSE;}

ServiceImpl*serviceImpl=SAMGR_CreateServiceImpl(service,samgr->status);if(serviceImpl==NULL){MUTEX_Unlock(samgr->mutex);returnFALSE;}

serviceImpl->serviceId=VECTOR_Add(&(samgr->services),serviceImpl);MUTEX_Unlock(samgr->mutex);if(serviceImpl->serviceId==INVALID_INDEX){SAMGR_Free(serviceImpl);returnFALSE;}returnTRUE;}返回初始化好的SamgrLiteImpl对象匹配给定的Name，返回index创建一个serviceImpl

调用VECTOR_Add添加新的serviceImpl

安全边距5.2服务框架的启动和注册[5.2.2]服务框架的注册过程示例（broadcast服务）（2）注册系统服务特性Feature：Init基于OpenHarmony的嵌入式开发24staticvoidInit(void)

{PubSubFeature*feature=&g_broadcastFeature;feature->relations.topic=-1;feature->relations.callbacks.consumer=NULL;UtilsListInit(&feature->relations.callbacks.node);UtilsListInit(&feature->relations.node);feature->mutex=MUTEX_InitValue();

SAMGR_GetInstance()->RegisterFeature(BROADCAST_SERVICE,(Feature*)feature);PubSubImplement*apiEntry=BCE_CreateInstance((Feature*)feature);

SAMGR_GetInstance()->RegisterFeatureApi(BROADCAST_SERVICE,

PUB_SUB_FEATURE,GET_IUNKNOWN(*apiEntry));}创建全局g_broadcastFeature，PubSubFeature类型与Service类似的，注册特性Feature返回PubSubImplement类型对象PubSubImplement*BCE_CreateInstance(Feature*feature){g_pubSubImplement.feature=(PubSubFeature*)feature;return&g_pubSubImplement;}注册FeatureApi将传入的PubSubFeature添加到全局的g_pubSubImplement.feature中安全边距5.2服务框架的启动和注册[5.2.2]服务框架的注册过程示例（broadcast服务）（2）注册系统服务特性Feature：RegisterFeature基于OpenHarmony的嵌入式开发25staticBOOLRegisterFeature(constchar*serviceName,Feature*feature){if(IsInvalidFeature(feature)){returnFALSE;}

ServiceImpl*serviceImpl=GetService(serviceName);if(serviceImpl==NULL||serviceImpl->inited!=SVC_INIT){returnFALSE;}if(DEFAULT_GetFeature(serviceImpl,feature->GetName(feature))!=NULL){returnFALSE;}int16featureId=DEFAULT_AddFeature(serviceImpl,feature);if(featureId<0){returnFALSE;}returnTRUE;}feature是否有效条件为feature及其GetName、OnInitialize、OnMessage和OnStop都不为空通过serviceName查找，返回ServiceImpl对象FeatureImpl*DEFAULT_GetFeature(ServiceImpl*serviceImpl,constchar*featureName)根据serviceImpl和featurename通过Vector查找操作返回FeatureImpl（null）int16DEFAULT_AddFeature(ServiceImpl*serviceImpl,Feature*feature)将featureImpl写入到serviceImpl->features.data[featureId]，返回featureId通过featureImpl建立起feature和serviceImpl的联系安全边距5.2服务框架的启动和注册[5.2.2]服务框架的注册过程示例（broadcast服务）（2）注册系统服务特性Feature：RegisterFeatureApi（3）服务初始化：启动SAMGR_Bootstrap()，将所有已经注册但尚未初始化启动的服务进行初始化启动基于OpenHarmony的嵌入式开发26staticBOOLRegisterFeatureApi(constchar*serviceName,constchar*feature,IUnknown*publicApi)

{if(IsInvalidIUnknown(publicApi)){

returnFALSE;}

ServiceImpl*serviceImpl=GetService(serviceName);if(serviceImpl==NULL){returnFALSE;}if(feature==NULL){if(serviceImpl->defaultApi!=NULL){

returnFALSE;}

serviceImpl->defaultApi=publicApi;returnTRUE;}

FeatureImpl*featureImpl=DEFAULT_GetFeature(serviceImpl,feature);if(featureImpl==NULL){returnFALSE;}returnSAMGR_AddInterface(featureImpl,publicApi);}IUnknown是否有效，条件为iUnknown存在，以及QueryInterface、AddRef和Release指针函数已经实现通过serviceName查找，返回ServiceImpl对象将默认的API设置为传入的publicApi根据serviceImpl和featureName，通过VECTOR_FindByKey操作返回featureImpl实际实现：featureImpl->iUnknown=iUnknown;安全边距5.3异步调用[5.3.1]消息调用的相关接口（1）SAMGR_SendRequest：发送请求基于OpenHarmony的嵌入式开发27/*Sendsarequesttoaserviceorfeatureofaspecifiedidentity.Thisfunctioniscalledbyaservicetosendmessagestoitsownfeaturesthroughthe

asynchronousfunctionofIUnknown*/int32SAMGR_SendRequest(constIdentity*identity,constRequest*request,Handlerhandler){if(request==NULL||identity==NULL){returnEC_INVALID;}Exchangeexchange={*identity,*request,{NULL,0},MSG_NON,handler,NULL};exchange.id.queueId=NULL;if(handler!=NULL){exchange.id.queueId=SAMGR_GetCurrentQueueID();exchange.type=MSG_CON;}returnQUEUE_Put(identity->queueId,&exchange,0,DONT_WAIT);}identity：pointertotheIDofthefeatureorservicethatprocessesthemessage.request：pointertotherequest.handler：functionhandlingtheresponse.IfthevalueisNULL,noresponseisrequired.structExchange{Identityid;

/**<Thetargetserviceorfeatureidentity.*/Requestrequest;Responseresponse;shorttype;

/**<Theexchangetype.*/Handlerhandler;

/**<asyncresponseorimmediatelyrequestcallbackfunction*/uint32*sharedRef;

/**<usetosharetherequestandresponseforsavingmemory*/};安全边距5.3异步调用[5.3.1]消息调用的相关接口（2）SAMGR_SendResponse：响应请求

基于OpenHarmony的嵌入式开发28/*

Sendsaresponseafterprocessingarequest.Thisfunctioniscalledtosendaresponseafter*processingarequestbyMessageHandleofaserviceorOnMessageofafeature.*/int32SAMGR_SendResponse(constRequest*request,constResponse*response)

{

if(request==NULL){returnEC_INVALID;}Exchange*exchange=GET_OBJECT(request,Exchange,request);if(exchange->type!=MSG_CON){returnEC_INVALID;}if(exchange->handler==NULL){

returnEC_SUCCESS;}exchange->type=MSG_ACK;exchange->response.data=NULL;exchange->response.len=0;if(response!=NULL){exchange->response=*response;}

if(exchange->id.queueId==NULL){exchange->handler(&exchange->request,&exchange->response);returnEC_SUCCESS;}

int32ret=SharedSend(exchange->id.queueId,exchange,1);if(ret!=EC_SUCCESS){exchange->handler(&exchange->request,&exchange->response);(void)FreeReference(exchange);}returnEC_SUCCESS;}request：pointertotheoriginalrequest.response：pointertotheresponsecontent.notaskqueue,then

calltheresponseprocessorincurrenttask.Sendbacktotheorigintoprocessthetask.安全边距5.3异步调用[5.3.1]消息调用的相关接口（3）SAMGR_SendSharedRequest

：发送共享请求

（4）SAMGR_SendSharedDirectRequest：直接发送请求和响应基于OpenHarmony的嵌入式开发29/*

Sendsarequesttomultipleservicesorfeaturestosavememory.Thisfunctionisusedtopublishtopics*fortheBroadcastservicetobroadcastmessages.*/uint32*SAMGR_SendSharedRequest(constIdentity*identity,constRequest*request,

uint32*token,Handlerhandler);identity：pointertotheIDsofservicesorfeatures,towhichrequestsaresent.request：pointertotherequest.token：pointertoreferencecounting.handler：functionhandlingtheresponse.IfthevalueisNULL,noresponseisrequired./*Sendsarequestandresponseofacallertothefeaturethread.Thehandlerisdirectly

calledtoprocessthe*requestandresponsewithoutusingthemessageprocessingfunctions.Thisfunctionisusedtopublishtopics*fortheBroadcastservicetobroadcastmessages.Thevalueofreferencecountingisincrementedbyoneeach

*timethisfunctioniscalled.*/int32SAMGR_SendSharedDirectRequest(constIdentity*id,constRequest*req,constResponse*resp,uint32**ref,Handlerhandler);id：pointertotheIDsofservicesorfeatures,towhichtherequestand

responsearesent.request：pointertotherequest.resp：pointertotheresponse.ref：referencecounting.handler：functionforhandlingtherequestandresponse.Thisparameter

cannotbeNULL安全边距5.3异步调用[5.3.1]消息调用的相关接口（5）SAMGR_MsgRecv

：读取消息

（6）SharedSend：发送共享信息基于OpenHarmony的嵌入式开发30int32SAMGR_MsgRecv(MQueueIdqueueId,uint8*interMsg,uint32size)

{if(queueId==NULL||interMsg==NULL||size==0){returnEC_INVALID;}if(memset_s(interMsg,size,0x00,size)!=EOK){returnEC_FAILURE;}returnQUEUE_Pop(queueId,interMsg,0,WAIT_FOREVER);}staticint32SharedSend(MQueueIdqueueId,Exchange*exchange,intinitRef)

{/*ifthemsgdataandresponseisNULL,wejustdirectcopy,noneedsharedthemessage.*/if((exchange->request.data==NULL||exchange->request.len<=0)&&(exchange->response.data==NULL||exchange->response.len<=0)){returnQUEUE_Put(queueId,exchange,0,DONT_WAIT);}/*1.addreference*/……(*(exchange->sharedRef))++;

……}与硬件/系统密切相关LiteOS-A：/foundation/distributedschedule/samgr_lite/samgr/adapter/posixLiteOS-M：/foundation/distributedschedule/samgr_lite/samgr/adapter/cmsis安全边距5.3异步调用[5.3.1]消息调用的相关接口

QUEUE_Put：CMSIS

vs.POSIX基于OpenHarmony的嵌入式开发31intQUEUE_Put(MQueueIdqueueId,constvoid*element,uint8pri,inttimeout)

{uint32_twaitTime=(timeout<=0)?0:(uint32_t)timeout;

osStatus_tret=osMessageQueuePut(queueId,element,pri,waitTime);if(ret!=osOK){returnEC_BUSBUSY;}returnEC_SUCCESS;}intQUEUE_Put(