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 //定义一变量，用来缓存创建的观察者的指针。 127 static HiAppEvent_Watcher *systemEventWatcher; 128 129 // 开发者可以自行实现获取已监听到事件的回调函数，其中events指针指向内容仅在该函数内有效。 130 static void OnTake(const char *const *events, uint32_t eventLen) { 131 Json::Reader reader(Json::Features::strictMode()); 132 Json::FastWriter writer; 133 for (int i = 0; i < eventLen; ++i) { 134 Json::Value eventInfo; 135 if (reader.parse(events[i], eventInfo)) { 136 auto domain = eventInfo["domain_"].asString(); 137 auto name = eventInfo["name_"].asString(); 138 auto type = eventInfo["type_"].asInt(); 139 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.domain=%{public}s", domain.c_str()); 140 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.name=%{public}s", name.c_str()); 141 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.eventType=%{public}d", type); 142 if (domain == DOMAIN_OS && name == EVENT_RESOURCE_OVERLIMIT) { 143 auto time = eventInfo["time"].asInt64(); 144 auto pid = eventInfo["pid"].asInt(); 145 auto uid = eventInfo["uid"].asInt(); 146 auto resourceType = eventInfo["resourceType"].asString(); 147 auto bundleName = eventInfo["bundle_name"].asString(); 148 auto bundleVersion = eventInfo["bundle_version"].asString(); 149 auto memory = writer.write(eventInfo["memory"]); 150 auto externalLog = writer.write(eventInfo["external_log"]); 151 std::string logOverLimit = eventInfo["log_over_limit"].asBool() ? "true":"false"; 152 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.time=%{public}lld", time); 153 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.pid=%{public}d", pid); 154 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.uid=%{public}d", uid); 155 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.resource_type=%{public}s", resourceType.c_str()); 156 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_name=%{public}s", bundleName.c_str()); 157 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_version=%{public}s", bundleVersion.c_str()); 158 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.memory=%{public}s", memory.c_str()); 159 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.external_log=%{public}s", externalLog.c_str()); 160 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.log_over_limit=%{public}d", logOverLimit.c_str()); 161 } 162 } 163 } 164 } 165 166 // 开发者可以自行实现订阅回调函数，以便对获取到的事件打点数据进行自定义处理。 167 static void OnTrigger(int row, int size) { 168 // 接收回调后，获取指定数量的已接收事件。 169 OH_HiAppEvent_TakeWatcherData(systemEventWatcher, row, OnTake); 170 } 171 172 static napi_value RegisterWatcher(napi_env env, napi_callback_info info) { 173 // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。 174 systemEventWatcher = OH_HiAppEvent_CreateWatcher("onTriggerWatcher"); 175 // 设置订阅的事件为EVENT_RESOURCE_OVERLIMIT。 176 const char *names[] = {EVENT_RESOURCE_OVERLIMIT}; 177 // 开发者订阅感兴趣的事件，此处订阅了系统事件。 178 OH_HiAppEvent_SetAppEventFilter(systemEventWatcher, DOMAIN_OS, 0, names, 1); 179 // 开发者设置已实现的回调函数，需OH_HiAppEvent_SetTriggerCondition设置的条件满足方可触发。 180 OH_HiAppEvent_SetWatcherOnTrigger(systemEventWatcher, OnTrigger); 181 // 开发者可以设置订阅触发回调的条件，此处是设置新增事件打点数量为2个时，触发onTrigger回调。 182 OH_HiAppEvent_SetTriggerCondition(systemEventWatcher, 1, 0, 0); 183 // 使观察者开始监听订阅的事件。 184 OH_HiAppEvent_AddWatcher(systemEventWatcher); 185 return {}; 186 } 187 ``` 188 1895. 将RegisterWatcher注册为ArkTS接口： 190 191 编辑"napi_init.cpp"文件，将RegisterWatcher注册为ArkTS接口： 192 193 ```c++ 194 static napi_value Init(napi_env env, napi_value exports) 195 { 196 napi_property_descriptor desc[] = { 197 { "registerWatcher", nullptr, RegisterWatcher, nullptr, nullptr, nullptr, napi_default, nullptr } 198 }; 199 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 200 return exports; 201 } 202 ``` 203 204 编辑"index.d.ts"文件，定义ArkTS接口： 205 206 ```typescript 207 export const registerWatcher: () => void; 208 ``` 209 2106. 编辑"EntryAbility.ets"文件，在onCreate()函数中新增接口调用： 211 212 ```typescript 213 import testNapi from 'libentry.so' 214 import hidebug from '@kit.PerformanceAnalysisKit' 215 export default class EntryAbility extends UIAbility { 216 onCreate(want, launchParam) { 217 // 启动时，注册系统事件观察者 218 testNapi.registerWatcher(); 219 } 220 } 221 ``` 222 2237. 编辑工程中的“entry > src > main > ets > pages > Index.ets”文件，添加按钮并在其onClick函数构造资源泄漏场景，以触发资源泄漏事件。 224 此处需要使用[hidebug.setAppResourceLimit](../reference/apis-performance-analysis-kit/js-apis-hidebug.md#hidebugsetappresourcelimit12)设置内存限制，造成内存泄漏，同步在“开发者选项”中打开“系统资源泄漏日志”(打开或关闭开关均需重启设备)。接口示例代码如下： 225 226 ```ts 227 import hidebug from "@ohos.hidebug"; 228 229 @Entry 230 @Component 231 struct Index { 232 @State leakedArray: string[][] = []; 233 234 build() { 235 Column() { 236 Row() { 237 Column() { 238 Button("pss leak") 239 .onClick(() => { 240 hidebug.setAppResourceLimit("pss_memory", 1024, true); 241 for (let i = 0; i < 20 * 1024; i++) { 242 this.leakedArray.push(new Array(1).fill("leak")); 243 } 244 }) 245 } 246 } 247 .height('100%') 248 .width('100%') 249 } 250 } 251 } 252 ``` 253 2548. 点击DevEco Studio界面中的运行按钮，运行应用工程，等待15~30分钟，会上报应用内存泄漏事件。 255 同一个应用，24小时内至多上报一次内存泄漏，如果短时间内要二次上报，需要重启设备。 256 2579. 内存泄漏事件上报后，可以在Log窗口看到对系统事件数据的处理日志： 258 259 ```text 260 08-07 03:53:35.314 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.domain=OS 261 08-07 03:53:35.314 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.name=RESOURCE_OVERLIMIT 262 08-07 03:53:35.314 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.eventType=1 263 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.time=1502049167732 264 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.pid=1587 265 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.uid=20010043 266 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.resource_type=pss_memory 267 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.bundle_name=com.example.myapplication 268 08-07 03:53:35.349 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.bundle_version=1.0.0 269 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} 270 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"] 271 08-07 03:53:35.350 1719-1738/? I A00000/testTag: HiAppEvent eventInfo.params.log_over_limit=false 272 ``` 273 27410. 移除事件观察者： 275 276 ```c++ 277 static napi_value RemoveWatcher(napi_env env, napi_callback_info info) { 278 // 使观察者停止监听事件 279 OH_HiAppEvent_RemoveWatcher(systemEventWatcher); 280 return {}; 281 } 282 ``` 283 28411. 销毁事件观察者： 285 286 ```c++ 287 static napi_value DestroyWatcher(napi_env env, napi_callback_info info) { 288 // 销毁创建的观察者，并置systemEventWatcher为nullptr。 289 OH_HiAppEvent_DestroyWatcher(systemEventWatcher); 290 systemEventWatcher = nullptr; 291 return {}; 292 } 293 ``` 294