鸿蒙0基础学习【订阅公共事件（C/C++）】进程线程通信

蒸糕笑QAQ

486人浏览 · 2025-07-10 14:47:50

蒸糕笑QAQ · 2025-07-10 14:47:50 发布

场景介绍

通过[OH_CommonEvent_CreateSubscriber]创建的订阅者可以对某个公共事件进行订阅，如果有订阅的事件发布那么订阅了这个事件的订阅者将会收到该事件及其传递的参数，也可以通过订阅者对象进一步处理有序公共事件。

接口说明

接口名	描述
[CommonEvent_SubscribeInfo* OH_CommonEvent_CreateSubscribeInfo(const char* events[], int32_t eventsNum)]	创建订阅者信息。
[void OH_CommonEvent_DestroySubscribeInfo(CommonEvent_SubscribeInfo* info)]	销毁订阅者信息。
[CommonEvent_Subscriber* OH_CommonEvent_CreateSubscriber(const CommonEvent_SubscribeInfo* info, CommonEvent_ReceiveCallback callback)]	创建订阅者。
[void OH_CommonEvent_DestroySubscriber(CommonEvent_Subscriber* subscriber)]	销毁订阅者。
[CommonEvent_ErrCode OH_CommonEvent_Subscribe(const CommonEvent_Subscriber* subscriber)]	订阅事件。
[bool OH_CommonEvent_AbortCommonEvent(CommonEvent_Subscriber* subscriber)]	中止当前的有序公共事件。
[bool OH_CommonEvent_ClearAbortCommonEvent(CommonEvent_Subscriber* subscriber)]	取消当前有序公共事件的中止状态。
[bool OH_CommonEvent_FinishCommonEvent(CommonEvent_Subscriber* subscriber)]	结束对当前有序公共事件的处理。

开发步骤

引用头文件。

#include <cstdint>
#include <cstdio>
#include <cwchar>
#include <string.h>
#include "hilog/log.h"
#include "BasicServicesKit/oh_commonevent.h"

在CMake脚本中添加动态链接库。

target_link_libraries(entry PUBLIC
    libace_napi.z.so
    libhilog_ndk.z.so
    libohcommonevent.so
)

创建订阅者信息。

通过[OH_CommonEvent_CreateSubscribeInfo]创建订阅者信息。

CommonEvent_SubscribeInfo* CreateSubscribeInfo(const char* events[], int32_t eventsNum, const char* permission, const char* bundleName) {
    int32_t ret = -1;
    // 创建订阅者信息
    CommonEvent_SubscribeInfo* info = OH_CommonEvent_CreateSubscribeInfo(events, eventsNum);


    // 设置订阅者权限
    ret = OH_CommonEvent_SetPublisherPermission(info, permission);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "OH_CommonEvent_SetPublisherPermission ret <%{public}d>.", ret);
    
    // 设置订阅者包名称
    ret = OH_CommonEvent_SetPublisherBundleName(info, bundleName);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "OH_CommonEvent_SetPublisherBundleName ret <%{public}d>.", ret);
    return info;
}


// 销毁订阅者信息
void DestroySubscribeInfo(CommonEvent_SubscribeInfo* info) {
    OH_CommonEvent_DestroySubscribeInfo(info);
    info = nullptr;
}

创建订阅者。

先创建订阅者时通过传入公共事件的回调函数[CommonEvent_ReceiveCallback]，事件发布时，订阅者会接收到回调数据[CommonEvent_RcvData]。

// 公共事件回调函数
void OnReceive(const CommonEvent_RcvData *data) {
    // 获取回调公共事件名称
    const char *event = OH_CommonEvent_GetEventFromRcvData(data);
    
    // 获取回调公共事件结果代码
    int code = OH_CommonEvent_GetCodeFromRcvData(data);
    
    // 获取回调公共事件自定义结果数据
    const char *retData = OH_CommonEvent_GetDataStrFromRcvData(data);
    
    // 获取回调公共事件包名称
    const char *bundle = OH_CommonEvent_GetBundleNameFromRcvData(data);
    
    // 获取回调公共事件附件信息
    const CommonEvent_Parameters *parameters = OH_CommonEvent_GetParametersFromRcvData(data);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "event: %{public}s, code: %{public}d, data: %{public}s, bundle: %{public}s", event, code, retData, bundle);
}

通过[CommonEvent_Parameters]传入key来获取附加信息内容。

void GetParameters(const CommonEvent_RcvData *data) {
    // 获取回调公共事件附件信息
    bool exists = false;
    const CommonEvent_Parameters *parameters = OH_CommonEvent_GetParametersFromRcvData(data);


    // 检查公共事件附加信息中是否包含某个键值对信息
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "intKey");
    // 获取公共事件附加信息中int数据信息
    int intValue = OH_CommonEvent_GetIntFromParameters(parameters, "intKey", 10);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, intValue = %{public}d", exists, intValue);
    
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "boolKey");
    // 获取公共事件附加信息中bool数据信息
    bool boolValue = OH_CommonEvent_GetBoolFromParameters(parameters, "boolKey", false);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, boolValue = %{public}d", exists, boolValue);


    exists = OH_CommonEvent_HasKeyInParameters(parameters, "longKey");
    // 获取公共事件附加信息中long数据信息
    long longValue = OH_CommonEvent_GetLongFromParameters(parameters, "longKey", 1111111111);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, longValue = %{public}ld", exists, longValue);


    exists = OH_CommonEvent_HasKeyInParameters(parameters, "doubleKey");
    // 获取公共事件附加信息中double数据信息
    double doubleValue = OH_CommonEvent_GetDoubleFromParameters(parameters, "doubleKey", 11.11);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, doubleValue = %{public}f", exists, doubleValue);


    exists = OH_CommonEvent_HasKeyInParameters(parameters, "charKey");
    // 获取公共事件附加信息中char数据信息
    char charValue = OH_CommonEvent_GetCharFromParameters(parameters, "charKey", 'A');
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, charValue = %{public}c", exists, charValue);
    
    int** arr = new int*;
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "intArrayKey");
    // 获取公共事件附加信息中int数组信息
    int32_t intArraySize = OH_CommonEvent_GetIntArrayFromParameters(parameters, "intArrayKey", arr);
    if (intArraySize <= 0 || *arr == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "exists = %{public}d, Failed to get int array or invalid size: %{public}d", exists, intArraySize);
    } else {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, intArraySize = %{public}d", exists, intArraySize);
        for (int i = 0; i < intArraySize; i++) {
            OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "<%{public}d>", *((*arr) + i));
        }
    }
    
    long** longArray = new long*;
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "longArrayKey");
    // 获取公共事件附加信息中long数组信息
    int32_t longArraySize = OH_CommonEvent_GetLongArrayFromParameters(parameters, "longArrayKey", longArray);
    if (longArraySize <= 0 || *longArray == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "exists = %{public}d, Failed to get long array or invalid size: %{public}d", exists, longArraySize);
    } else {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, longArraySize = %{public}d", exists, longArraySize);
        for (int i = 0; i < longArraySize; i++) {
            OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "<%{public}ld>", *((*longArray) + i));
        }
    }


    double** doubleArray = new double*;
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "doubleArrayKey");
    // 获取公共事件附加信息中double数组信息
    int32_t doubleArraySize = OH_CommonEvent_GetDoubleArrayFromParameters(parameters, "doubleArrayKey", doubleArray);
    if (doubleArraySize <= 0 || *doubleArray == nullptr) {
       OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "exists = %{public}d, Failed to get double array or invalid size: %{public}d", exists, doubleArraySize);
    } else {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, doubleArraySize = %{public}d", exists, doubleArraySize);
        for (int i = 0; i < doubleArraySize; i++) {
            OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "<%{public}f>", *((*doubleArray) + i));
        }
    }


    char** charArray = new char*;
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "charArrayKey");
    // 获取公共事件附加信息中char数组信息
    int32_t charArraySize = OH_CommonEvent_GetCharArrayFromParameters(parameters, "charArrayKey", charArray);
    if (charArraySize <= 0 || *charArray == nullptr) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "exists = %{public}d, Failed to get charArray or invalid size: %{public}d", exists, charArraySize);
    } else {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "charArray as string: %{public}s", *charArray);
    }


    bool** boolArray = new bool*;
    exists = OH_CommonEvent_HasKeyInParameters(parameters, "boolArrayKey");
    // 获取公共事件附加信息中bool数组信息
    int32_t boolArraySize = OH_CommonEvent_GetBoolArrayFromParameters(parameters, "boolArrayKey", boolArray);
    if (boolArraySize <= 0 || *boolArray == nullptr) {
       OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "exists = %{public}d, Failed to get boolArray or invalid size: %{public}d", exists, boolArraySize);
    } else {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "exists = %{public}d, boolArraySize = %{public}d", exists, boolArraySize);
        for (int i = 0; i < boolArraySize; i++) {
            OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "<%{public}d>", *((*boolArray) + i));
        }
    }
}

通过[OH_CommonEvent_CreateSubscriber]创建订阅者，传入订阅者信息[CommonEvent_SubscribeInfo]和事件回调函数[OnReceive]

// 创建订阅者
CommonEvent_Subscriber* CreateSubscriber(CommonEvent_SubscribeInfo* info) {
    return OH_CommonEvent_CreateSubscriber(info, OnReceive);
}


// 销毁订阅者
void DestroySubscriber(CommonEvent_Subscriber* Subscriber) {
    OH_CommonEvent_DestroySubscriber(Subscriber);
    Subscriber = nullptr;
}

订阅事件。

通过[OH_CommonEvent_Subscribe]订阅事件。

void Subscribe(CommonEvent_Subscriber* subscriber) {
    // 通过传入订阅者来订阅事件
    int32_t ret = OH_CommonEvent_Subscribe(subscriber);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "OH_CommonEvent_Subscribe ret <%{public}d>.", ret);
}

（可选）当订阅的事件为有序公共事件时，可以选择进一步处理有序公共事件。

根据订阅者设置的优先级等级，优先将公共事件发送给优先级较高的订阅者，等待其成功接收该公共事件之后再将事件发送给优先级较低的订阅者。如果有多个订阅者具有相同的优先级，则他们将随机接收到公共事件。

注意

在订阅者收到公共事件之后，才能通过以下接口进一步处理有序公共事件。
- 中止当前的有序公共事件。
  
  通过[OH_CommonEvent_AbortCommonEvent]与[OH_CommonEvent_FinishCommonEvent]配合使用，可以中止当前的有序公共事件，使该公共事件不再向下一个订阅者传递。

void AbortCommonEvent(CommonEvent_Subscriber* subscriber) {
    // 判断是否为有序公共事件
    if(!OH_CommonEvent_IsOrderedCommonEvent(subscriber)) {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "Not ordered common event.");
        return;
    }
    // 中止有序事件
    if(OH_CommonEvent_AbortCommonEvent(subscriber)) {
        if(OH_CommonEvent_FinishCommonEvent(subscriber)) {
            // 获取当前有序公共事件是否处于中止状态
            OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "Abort common event success, Get abort <%{public}d>.",   OH_CommonEvent_GetAbortCommonEvent(subscriber));
        }
    } else {
       OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "Abort common event failed.");
    }
}

取消当前有序公共事件的中止状态。

通过[OH_CommonEvent_ClearAbortCommonEvent]与[OH_CommonEvent_FinishCommonEvent]配合使用，可以取消当前有序公共事件的中止状态，使该公共事件继续向下一个订阅者传递。

void ClearAbortCommonEvent(CommonEvent_Subscriber* subscriber) {
    // 判断是否为有序公共事件
    if(!OH_CommonEvent_IsOrderedCommonEvent(subscriber)) {
        OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "Not ordered common event.");
        return;
    }
    // 中止有序事件
    if(!OH_CommonEvent_AbortCommonEvent(subscriber)) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "Abort common event failed.");
        return;
    }
    // 取消中止有序事件
    if(OH_CommonEvent_ClearAbortCommonEvent(subscriber)) {
        if(OH_CommonEvent_FinishCommonEvent(subscriber)) {
            // 获取当前有序公共事件是否处于中止状态
            OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "Clear abort common event success, Get abort <%{public}d>.",   OH_CommonEvent_GetAbortCommonEvent(subscriber));
        }
    } else {
       OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "Clear abort common event failed.");
    }
}

修改有序公共事件的内容。

通过[OH_CommonEvent_SetCodeToSubscriber]与[OH_CommonEvent_SetDataToSubscriber]设置有序公共事件的代码和数据。

void SetToSubscriber(CommonEvent_Subscriber* subscriber, const int32_t code, const char* data) {
    // 设置有序公共事件的代码
    if(!OH_CommonEvent_SetCodeToSubscriber(subscriber, code)) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "OH_CommonEvent_SetCodeToSubscriber failed.");
        return;
    }
    // 设置有序公共事件的数据
    size_t dataLength = strlen(data);
    if(!OH_CommonEvent_SetDataToSubscriber(subscriber, data, dataLength)) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, 1, "CES_TEST", "OH_CommonEvent_SetDataToSubscriber failed.");
        return;
    }
}


void GetFromSubscriber(CommonEvent_Subscriber* subscriber) {
    // 获取有序公共事件的数据和代码
    const char* data = OH_CommonEvent_GetDataFromSubscriber(subscriber);
    int32_t code = OH_CommonEvent_GetCodeFromSubscriber(subscriber);
    OH_LOG_Print(LOG_APP, LOG_INFO, 1, "CES_TEST", "Subscriber data <%{public}s>, code <%{public}d>.", data, code);
}

本文提到的 [相关技术点] 只是冰山一角！勉费《HarmonyOS全栈开发实战》+《鸿蒙项目源码合集》，涵盖基础到进阶，助你快速上手鸿蒙！👉 点我【下方】立拿

在这里插入图片描述

欢迎加入Laval社区

社区规范：仅讨论OpenHarmony相关问题。

更多推荐

一次地图文字颜色异常排查：RGB565 和 ARGB8888 不能混为一谈

在适配轻量地图渲染时，我遇到过一类很有迷惑性的现象：路名文字有时接近黑色，有时偏红，重新进入页面后颜色还可能变化。第一反应通常是字体绘制或屏幕像素格式有问题，但沿渲染链继续检查后，真正的异常出现在更早的颜色数据边界。这次排查最重要的收获，是要把“缓冲区像素格式”和“画笔颜色格式”分开理解。两种格式描述的不是同一件事 RGB565 描述的是像素缓冲区布局。一个像素占 16 位，红色 5 位、绿色

Laval社区

给轻量地图组件补充异步任务投递：从网络回调安全返回地图线程

在完善轻量地图组件的异步网络能力时，我遇到的核心问题并不是“怎样发出一个异步请求”，而是请求完成以后，怎样安全地把结果交还给地图引擎。网络回调可能运行在协议栈线程，地图状态却通常要求在固定任务线程中串行修改。如果直接从网络线程进入地图引擎，短期内可能看不出问题，但在并发请求、页面退出或重复回调时，很容易出现数据竞争和生命周期错误。地图线程在框架中的作用轻量地图内部会同时维护视图状态、瓦片缓存

Laval社区

给 OpenHarmony 轻量地图组件补充离线能力：一次公共接口演进实践

在参与 OpenHarmony 轻量地图组件共建时，我尝试为地图模块补充离线资源管理能力。最初看起来，这项工作只是增加查询、下载、暂停和删除接口，但真正开始梳理后，我发现难点并不在函数数量，而在于如何让新能力自然地进入原有框架，同时不破坏已有实现。这次修改让我对轻量地图组件的分层、代理线程和公共接口兼容有了更具体的认识。从现有调用链开始轻量地图组件并不是应用直接调用某个地图 SDK，而是通过一