1# 订阅资源泄漏事件（C/C++） 2 3## 接口说明 4 5API接口的具体使用说明（参数使用限制、具体取值范围等）请参考[HiAppEvent](../reference/apis-performance-analysis-kit/_hi_app_event.md#hiappevent)。 6 7**订阅接口功能介绍：** 8 9| 接口名 | 描述 | 10|-------------------------------------------------------------| -------------------------------------------- | 11| int OH_HiAppEvent_AddWatcher(HiAppEvent_Watcher *watcher) | 添加应用事件观察者，以添加对应用事件的订阅。 | 12| int OH_HiAppEvent_RemoveWatcher(HiAppEvent_Watcher *watcher) | 移除应用事件观察者，以移除对应用事件的订阅。 | 13 14## 开发步骤 15 161. 新建Native C++工程，并将jsoncpp导入到新建工程内，目录结构如下： 17 18 ```yml 19 entry: 20 src: 21 main: 22 cpp: 23 - json: 24 - json.h 25 - json-forwards.h 26 - types: 27 libentry: 28 - index.d.ts 29 - CMakeLists.txt 30 - napi_init.cpp 31 - jsoncpp.cpp 32 ets: 33 - entryability: 34 - EntryAbility.ets 35 - pages: 36 - Index.ets 37 ``` 38 392. 编辑"CMakeLists.txt"文件，添加源文件及动态库： 40 41 ```cmake 42 # 新增jsoncpp.cpp(解析订阅事件中的json字符串)源文件 43 add_library(entry SHARED napi_init.cpp jsoncpp.cpp) 44 # 新增动态库依赖libhiappevent_ndk.z.so和libhilog_ndk.z.so(日志输出) 45 target_link_libraries(entry PUBLIC libace_napi.z.so libhilog_ndk.z.so libhiappevent_ndk.z.so) 46 ``` 47 483. 编辑"napi_init.cpp"文件，导入依赖的文件，并定义LOG_TAG： 49 50 ```c++ 51 #include "napi/native_api.h" 52 #include "json/json.h" 53 #include "hilog/log.h" 54 #include "hiappevent/hiappevent.h" 55 56 #undef LOG_TAG 57 #define LOG_TAG "testTag" 58 ``` 59 604. 订阅系统事件： 61 62 - onReceive类型观察者： 63 64 编辑"napi_init.cpp"文件，定义onReceive类型观察者相关方法： 65 66 ```c++ 67 //定义一变量，用来缓存创建的观察者的指针。 68 static HiAppEvent_Watcher *systemEventWatcher; 69 70 static void OnReceive(const char *domain, const struct HiAppEvent_AppEventGroup *appEventGroups, uint32_t groupLen) { 71 for (int i = 0; i < groupLen; ++i) { 72 for (int j = 0; j < appEventGroups[i].infoLen; ++j) { 73 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.domain=%{public}s", appEventGroups[i].appEventInfos[j].domain); 74 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.name=%{public}s", appEventGroups[i].appEventInfos[j].name); 75 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.eventType=%{public}d", appEventGroups[i].appEventInfos[j].type); 76 if (strcmp(appEventGroups[i].appEventInfos[j].domain, DOMAIN_OS) == 0 && 77 strcmp(appEventGroups[i].appEventInfos[j].name, EVENT_RESOURCE_OVERLIMIT) == 0) { 78 Json::Value params; 79 Json::Reader reader(Json::Features::strictMode()); 80 Json::FastWriter writer; 81 if (reader.parse(appEventGroups[i].appEventInfos[j].params, params)) { 82 auto time = params["time"].asInt64(); 83 auto pid = params["pid"].asInt(); 84 auto uid = params["uid"].asInt(); 85 auto resourceType = params["resourceType"].asString(); 86 auto bundleName = params["bundle_name"].asString(); 87 auto bundleVersion = params["bundle_version"].asString(); 88 auto memory = writer.write(params["memory"]); 89 auto externalLog = writer.write(eventInfo["external_log"]); 90 std::string logOverLimit = eventInfo["log_over_limit"].asBool() ? "true":"false"; 91 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.time=%{public}lld", time); 92 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.pid=%{public}d", pid); 93 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.uid=%{public}d", uid); 94 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.resource_type=%{public}s", resourceType.c_str()); 95 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_name=%{public}s", bundleName.c_str()); 96 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_version=%{public}s", bundleVersion.c_str()); 97 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.memory=%{public}s", memory.c_str()); 98 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.external_log=%{public}s", externalLog.c_str()); 99 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.log_over_limit=%{public}d", logOverLimit.c_str()); 100 } 101 } 102 } 103 } 104 } 105 106 static napi_value RegisterWatcher(napi_env env, napi_callback_info info) { 107 // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。 108 systemEventWatcher = OH_HiAppEvent_CreateWatcher("onReceiverWatcher"); 109 // 设置订阅的事件为EVENT_RESOURCE_OVERLIMIT。 110 const char *names[] = {EVENT_RESOURCE_OVERLIMIT}; 111 // 开发者订阅感兴趣的事件，此处订阅了系统事件。 112 OH_HiAppEvent_SetAppEventFilter(systemEventWatcher, DOMAIN_OS, 0, names, 1); 113 // 开发者设置已实现的回调函数，观察者接收到事件后回立即触发OnReceive回调。 114 OH_HiAppEvent_SetWatcherOnReceive(systemEventWatcher, OnReceive); 115 // 使观察者开始监听订阅的事件。 116 OH_HiAppEvent_AddWatcher(systemEventWatcher); 117 return {}; 118 } 119 ``` 120 121 - onTrigger类型观察者： 122 123 编辑"napi_init.cpp"文件，定义OnTrigger类型观察者相关方法： 124 125 ```c++ 126 // 开发者可以自行实现获取已监听到事件的回调函数，其中events指针指向内容仅在该函数内有效。 127 static void OnTake(const char *const *events, uint32_t eventLen) { 128 Json::Reader reader(Json::Features::strictMode()); 129 Json::FastWriter writer; 130 for (int i = 0; i < eventLen; ++i) { 131 Json::Value eventInfo; 132 if (reader.parse(events[i], eventInfo)) { 133 auto domain = eventInfo["domain_"].asString(); 134 auto name = eventInfo["name_"].asString(); 135 auto type = eventInfo["type_"].asInt(); 136 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.domain=%{public}s", domain.c_str()); 137 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.name=%{public}s", name.c_str()); 138 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.eventType=%{public}d", type); 139 if (domain == DOMAIN_OS && name == EVENT_RESOURCE_OVERLIMIT) { 140 auto time = eventInfo["time"].asInt64(); 141 auto pid = eventInfo["pid"].asInt(); 142 auto uid = eventInfo["uid"].asInt(); 143 auto resourceType = eventInfo["resourceType"].asString(); 144 auto bundleName = eventInfo["bundle_name"].asString(); 145 auto bundleVersion = eventInfo["bundle_version"].asString(); 146 auto memory = writer.write(eventInfo["memory"]); 147 auto externalLog = writer.write(eventInfo["external_log"]); 148 std::string logOverLimit = eventInfo["log_over_limit"].asBool() ? "true":"false"; 149 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.time=%{public}lld", time); 150 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.pid=%{public}d", pid); 151 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.uid=%{public}d", uid); 152 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.resource_type=%{public}s", resourceType.c_str()); 153 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_name=%{public}s", bundleName.c_str()); 154 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_version=%{public}s", bundleVersion.c_str()); 155 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.memory=%{public}s", memory.c_str()); 156 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.external_log=%{public}s", externalLog.c_str()); 157 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.log_over_limit=%{public}d", logOverLimit.c_str()); 158 } 159 } 160 } 161 } 162 163 // 开发者可以自行实现订阅回调函数，以便对获取到的事件打点数据进行自定义处理。 164 static void OnTrigger(int row, int size) { 165 // 接收回调后，获取指定数量的已接收事件。 166 OH_HiAppEvent_TakeWatcherData(systemEventWatcher, row, OnTake); 167 } 168 169 static napi_value RegisterWatcher(napi_env env, napi_callback_info info) { 170 // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。 171 systemEventWatcher = OH_HiAppEvent_CreateWatcher("onTriggerWatcher"); 172 // 设置订阅的事件为EVENT_RESOURCE_OVERLIMIT。 173 const char *names[] = {EVENT_RESOURCE_OVERLIMIT}; 174 // 开发者订阅感兴趣的事件，此处订阅了系统事件。 175 OH_HiAppEvent_SetAppEventFilter(systemEventWatcher, DOMAIN_OS, 0, names, 1); 176 // 开发者设置已实现的回调函数，需OH_HiAppEvent_SetTriggerCondition设置的条件满足方可触发。 177 OH_HiAppEvent_SetWatcherOnTrigger(systemEventWatcher, OnTrigger); 178 // 开发者可以设置订阅触发回调的条件，此处是设置新增事件打点数量为2个时，触发onTrigger回调。 179 OH_HiAppEvent_SetTriggerCondition(systemEventWatcher, 1, 0, 0); 180 // 使观察者开始监听订阅的事件。 181 OH_HiAppEvent_AddWatcher(systemEventWatcher); 182 return {}; 183 } 184 ``` 185 1865. 将RegisterWatcher注册为ArkTS接口： 187 188 编辑"napi_init.cpp"文件，将RegisterWatcher注册为ArkTS接口： 189 190 ```c++ 191 static napi_value Init(napi_env env, napi_value exports) 192 { 193 napi_property_descriptor desc[] = { 194 { "registerWatcher", nullptr, RegisterWatcher, nullptr, nullptr, nullptr, napi_default, nullptr } 195 }; 196 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 197 return exports; 198 } 199 ``` 200 201 编辑"index.d.ts"文件，定义ArkTS接口： 202 203 ```typescript 204 export const registerWatcher: () => void; 205 ``` 206 2076. 编辑"EntryAbility.ets"文件，在onCreate()函数中新增接口调用： 208 209 ```typescript 210 import testNapi from 'libentry.so' 211 import hidebug from '@kit.PerformanceAnalysisKit' 212 export default class EntryAbility extends UIAbility { 213 onCreate(want, launchParam) { 214 // 启动时，注册系统事件观察者 215 testNapi.registerWatcher(); 216 } 217 } 218 ``` 219 2207. 编辑工程中的“entry > src > main > ets > pages > Index.ets”文件，添加按钮并在其onClick函数构造资源泄漏场景，以触发资源泄漏事件。 221 此处需要使用[hidebug.setAppResourceLimit](../reference/apis-performance-analysis-kit/js-apis-hidebug.md#hidebugsetappresourcelimit12)设置内存限制，造成内存内存泄漏，需要同步在“开发者选项”中打开“系统资源泄漏日志”(打开或关闭开关均需重启设备)。接口示例代码如下： 222 223 ```ts 224 import hidebug from "@ohos.hidebug"; 225 226 @Entry 227 @Component 228 struct Index { 229 @State leakedArray: string[][] = []; 230 231 build() { 232 Column() { 233 Row() { 234 Column() { 235 Button("pss leak") 236 .onClick(() => { 237 hidebug.setAppResourceLimit("pss_memory", 1024, true); 238 for (let i = 0; i < 20 * 1024; i++) { 239 this.leakedArray.push(new Array(1).fill("leak")); 240 } 241 }) 242 } 243 } 244 .height('100%') 245 .width('100%') 246 } 247 } 248 } 249 ``` 250 2518. 点击DevEco Studio界面中的运行按钮，运行应用工程，等待15~30分钟，会上报应用内存泄漏事件。 252 同一个应用，24小时内至多上报一次内存泄漏，如果短时间内要二次上报，需要重启设备。 253 2549. 内存泄漏事件上报后，可以在Log窗口看到对系统事件数据的处理日志： 255 256 ```text 257 08-07 03:53:35.314 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.domain=OS 258 08-07 03:53:35.314 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.name=RESOURCE_OVERLIMIT 259 08-07 03:53:35.314 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.eventType=1 260 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.time=1502049167732 261 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.pid=1587 262 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.uid=20010043 263 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.resource_type=pss_memory 264 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.bundle_name=com.example.myapplication 265 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.bundle_version=1.0.0 266 08-07 03:53:35.350 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.memory={"pss":2100257,"rss":1352644,"sys_avail_mem":250272,"sys_free_mem":60004,"sys_total_mem":1992340,"vss":2462936} 267 08-07 03:53:35.350 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.external_log=["/data/storage/el2/log/resourcelimit/RESOURCE_OVERLIMIT_1725614572401_6808.log","/data/storage/el2/log/resourcelimit/RESOURCE_OVERLIMIT_1725614572412_6808.log"] 268 08-07 03:53:35.350 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.log_over_limit=false 269 ``` 270 27110. 移除事件观察者： 272 273 ```c++ 274 static napi_value RemoveWatcher(napi_env env, napi_callback_info info) { 275 // 使观察者停止监听事件 276 OH_HiAppEvent_RemoveWatcher(systemEventWatcher); 277 return {}; 278 } 279 ``` 280 28111. 销毁事件观察者： 282 283 ```c++ 284 static napi_value DestroyWatcher(napi_env env, napi_callback_info info) { 285 // 销毁创建的观察者，并置systemEventWatcher为nullptr。 286 OH_HiAppEvent_DestroyWatcher(systemEventWatcher); 287 systemEventWatcher = nullptr; 288 return {}; 289 } 290 ``` 291