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 16以实现对写数组越界场景生成的踩内存事件订阅为例，说明开发步骤。 17 181. 新建Native C++工程，并将jsoncpp导入到新建工程内，目录结构如下： 19 20 ```yml 21 entry: 22 src: 23 main: 24 cpp: 25 - json: 26 - json.h 27 - json-forwards.h 28 - types: 29 libentry: 30 - index.d.ts 31 - CMakeLists.txt 32 - napi_init.cpp 33 - jsoncpp.cpp 34 ets: 35 - entryability: 36 - EntryAbility.ets 37 - pages: 38 - Index.ets 39 ``` 40 412. 编辑"CMakeLists.txt"文件，添加源文件及动态库： 42 43 ```cmake 44 # 新增jsoncpp.cpp(解析订阅事件中的json字符串)源文件 45 add_library(entry SHARED napi_init.cpp jsoncpp.cpp) 46 # 新增动态库依赖libhiappevent_ndk.z.so和libhilog_ndk.z.so(日志输出) 47 target_link_libraries(entry PUBLIC libace_napi.z.so libhilog_ndk.z.so libhiappevent_ndk.z.so) 48 ``` 49 503. 编辑"napi_init.cpp"文件，导入依赖的文件，并定义LOG_TAG： 51 52 ```c++ 53 #include "napi/native_api.h" 54 #include "json/json.h" 55 #include "hilog/log.h" 56 #include "hiappevent/hiappevent.h" 57 58 #undef LOG_TAG 59 #define LOG_TAG "testTag" 60 ``` 61 624. 订阅系统事件： 63 64 - onReceive类型观察者： 65 66 编辑"napi_init.cpp"文件，定义onReceive类型观察者相关方法： 67 68 ```c++ 69 //定义一变量，用来缓存创建的观察者的指针。 70 static HiAppEvent_Watcher *systemEventWatcher; 71 72 static void OnReceive(const char *domain, const struct HiAppEvent_AppEventGroup *appEventGroups, uint32_t groupLen) { 73 for (int i = 0; i < groupLen; ++i) { 74 for (int j = 0; j < appEventGroups[i].infoLen; ++j) { 75 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.domain=%{public}s", appEventGroups[i].appEventInfos[j].domain); 76 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.name=%{public}s", appEventGroups[i].appEventInfos[j].name); 77 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.eventType=%{public}d", appEventGroups[i].appEventInfos[j].type); 78 if (strcmp(appEventGroups[i].appEventInfos[j].domain, DOMAIN_OS) == 0 && 79 strcmp(appEventGroups[i].appEventInfos[j].name, EVENT_ADDRESS_SANITIZER) == 0) { 80 Json::Value params; 81 Json::Reader reader(Json::Features::strictMode()); 82 Json::FastWriter writer; 83 if (reader.parse(appEventGroups[i].appEventInfos[j].params, params)) { 84 auto time = params["time"].asInt64(); 85 auto bundleVersion = params["bundle_version"].asString(); 86 auto bundleName = params["bundle_name"].asString(); 87 auto pid = params["pid"].asInt(); 88 auto uid = params["uid"].asInt(); 89 auto type = params["type"].asString(); 90 auto boolFlag = params["log_over_limit"].asBool(); 91 std::string logOverLimit = params["log_over_limit"].asBool() ? "true" : "false"; 92 auto externalLog = writer.write(params["external_log"]); 93 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.time=%{public}lld", time); 94 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_version=%{public}s", bundleVersion.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.pid=%{public}d", pid); 97 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.uid=%{public}d", uid); 98 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.type=%{public}s", type.c_str()); 99 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.external_log=%{public}s", externalLog.c_str()); 100 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.log_over_limit=%{public}s", logOverLimit.c_str()); 101 } 102 } 103 } 104 } 105 } 106 107 static napi_value RegisterWatcher(napi_env env, napi_callback_info info) { 108 // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。 109 systemEventWatcher = OH_HiAppEvent_CreateWatcher("onReceiverWatcher"); 110 // 设置订阅的事件为EVENT_ADDRESS_SANITIZER。 111 const char *names[] = {EVENT_ADDRESS_SANITIZER}; 112 // 开发者订阅感兴趣的事件，此处订阅了系统事件。 113 OH_HiAppEvent_SetAppEventFilter(systemEventWatcher, DOMAIN_OS, 0, names, 1); 114 // 开发者设置已实现的回调函数，观察者接收到事件后回立即触发OnReceive回调。 115 OH_HiAppEvent_SetWatcherOnReceive(systemEventWatcher, OnReceive); 116 // 使观察者开始监听订阅的事件。 117 OH_HiAppEvent_AddWatcher(systemEventWatcher); 118 return {}; 119 } 120 ``` 121 122 - onTrigger类型观察者： 123 124 编辑"napi_init.cpp"文件，定义OnTrigger类型观察者相关方法： 125 126 ```c++ 127 //定义一变量，用来缓存创建的观察者的指针。 128 static HiAppEvent_Watcher *systemEventWatcher; 129 130 // 开发者可以自行实现获取已监听到事件的回调函数，其中events指针指向内容仅在该函数内有效。 131 static void OnTake(const char *const *events, uint32_t eventLen) { 132 Json::Reader reader(Json::Features::strictMode()); 133 Json::FastWriter writer; 134 for (int i = 0; i < eventLen; ++i) { 135 Json::Value eventInfo; 136 if (reader.parse(events[i], eventInfo)) { 137 auto domain = eventInfo["domain_"].asString(); 138 auto name = eventInfo["name_"].asString(); 139 auto type = eventInfo["type_"].asInt(); 140 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.domain=%{public}s", domain.c_str()); 141 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.name=%{public}s", name.c_str()); 142 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.eventType=%{public}d", type); 143 if (domain == DOMAIN_OS && name == EVENT_ADDRESS_SANITIZER) { 144 auto time = eventInfo["time"].asInt64(); 145 auto bundleVersion = eventInfo["bundle_version"].asString(); 146 auto bundleName = eventInfo["bundle_name"].asString(); 147 auto pid = eventInfo["pid"].asInt(); 148 auto uid = eventInfo["uid"].asInt(); 149 auto asanType = eventInfo["type"].asString(); 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.bundle_version=%{public}s", bundleVersion.c_str()); 154 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.bundle_name=%{public}s", bundleName.c_str()); 155 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.pid=%{public}d", pid); 156 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.uid=%{public}d", uid); 157 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.crash_type=%{public}s", asanType.c_str()); 158 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.external_log=%{public}s", externalLog.c_str()); 159 OH_LOG_INFO(LogType::LOG_APP, "HiAppEvent eventInfo.params.log_over_limit=%{public}s", logOverLimit.c_str()); 160 } 161 } 162 } 163 } 164 165 // 开发者可以自行实现订阅回调函数，以便对获取到的事件打点数据进行自定义处理。 166 static void OnTrigger(int row, int size) { 167 // 接收回调后，获取指定数量的已接收事件。 168 OH_HiAppEvent_TakeWatcherData(systemEventWatcher, row, OnTake); 169 } 170 171 static napi_value RegisterWatcher(napi_env env, napi_callback_info info) { 172 // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。 173 systemEventWatcher = OH_HiAppEvent_CreateWatcher("onTriggerWatcher"); 174 // 设置订阅的事件为EVENT_ADDRESS_SANITIZER。 175 const char *names[] = {EVENT_ADDRESS_SANITIZER}; 176 // 开发者订阅感兴趣的事件，此处订阅了系统事件。 177 OH_HiAppEvent_SetAppEventFilter(systemEventWatcher, DOMAIN_OS, 0, names, 1); 178 // 开发者设置已实现的回调函数，需OH_HiAppEvent_SetTriggerCondition设置的条件满足方可触发。 179 OH_HiAppEvent_SetWatcherOnTrigger(systemEventWatcher, OnTrigger); 180 // 开发者可以设置订阅触发回调的条件，此处是设置新增事件打点数量为1个时，触发onTrigger回调。 181 OH_HiAppEvent_SetTriggerCondition(systemEventWatcher, 1, 0, 0); 182 // 使观察者开始监听订阅的事件。 183 OH_HiAppEvent_AddWatcher(systemEventWatcher); 184 return {}; 185 } 186 ``` 187 1885. 构造地址越界错误： 189 190 编辑"napi_init.cpp"文件，定义Test方法, 方法中对一个整数数组进行越界访问： 191 192 ```c++ 193 static napi_value Test(napi_env env, napi_callback_info info) 194 { 195 int a[10]; 196 a[10] = 1; 197 return {}; 198 } 199 ``` 200 2016. 将RegisterWatcher和Test注册为ArkTS接口： 202 203 编辑"napi_init.cpp"文件，将RegisterWatcher和Test注册为ArkTS接口： 204 205 ```c++ 206 static napi_value Init(napi_env env, napi_value exports) 207 { 208 napi_property_descriptor desc[] = { 209 { "registerWatcher", nullptr, RegisterWatcher, nullptr, nullptr, nullptr, napi_default, nullptr }, 210 { "test", nullptr, Test, nullptr, nullptr, nullptr, napi_default, nullptr} 211 }; 212 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); 213 return exports; 214 } 215 ``` 216 217 编辑"index.d.ts"文件，定义ArkTS接口： 218 219 ```typescript 220 export const registerWatcher: () => void; 221 export const test: () => void; 222 ``` 223 2247. 编辑"EntryAbility.ets"文件，在onCreate()函数中新增接口调用： 225 226 ```typescript 227 // 导入依赖模块 228 import testNapi from 'libentry.so' 229 230 // 在onCreate()函数中新增接口调用 231 // 启动时，注册系统事件观察者 232 testNapi.registerWatcher(); 233 ``` 234 2358. 编辑“entry > src > main > ets > pages > Index.ets”文件，新增按钮触发踩内存事件： 236 237 ```ts 238 import testNapi from 'libentry.so' 239 240 @Entry 241 @Component 242 struct Index { 243 build() { 244 Row() { 245 Column() { 246 Button("address-sanitizer").onClick(() => { 247 testNapi.test(); 248 }) 249 } 250 .width('100%') 251 } 252 .height('100%') 253 } 254 } 255 ``` 256 2579. 点击DevEco Studio界面中的“entry”，点击“Edit Configurations”，点击“Diagnostics”，勾选“Address Sanitizer”，保存设置。点击DevEco Studio界面中的运行按钮，运行应用工程，然后在应用界面中点击按钮“address-sanitizer”，触发一次踩内存事件。应用崩溃后重新进入应用，可以在Log窗口看到对系统事件数据的处理日志： 258 259 ```text 260 HiAppEvent eventInfo.domain=OS 261 HiAppEvent eventInfo.name=ADDRESS_SANITIZER 262 HiAppEvent eventInfo.eventType=1 263 HiAppEvent eventInfo.params.time=1713148093326 264 HiAppEvent eventInfo.params.bundle_version=1.0.0 265 HiAppEvent eventInfo.params.bundle_name=com.example.myapplication 266 HiAppEvent eventInfo.params.pid=3378 267 HiAppEvent eventInfo.params.uid=20020140 268 HiAppEvent eventInfo.params.type="stack-buffer-overflow" 269 HiAppEvent eventInfo.params.external_log=["/data/storage/el2/log/hiappevent/ADDRESS_SANITIZER_1713148093326_3378.log"] 270 HiAppEvent eventInfo.params.log_over_limit=false 271 ``` 272 27310. 移除事件观察者： 274 275 ```c++ 276 static napi_value RemoveWatcher(napi_env env, napi_callback_info info) { 277 // 使观察者停止监听事件 278 OH_HiAppEvent_RemoveWatcher(systemEventWatcher); 279 return {}; 280 } 281 ``` 282 28311. 销毁事件观察者： 284 285 ```c++ 286 static napi_value DestroyWatcher(napi_env env, napi_callback_info info) { 287 // 销毁创建的观察者，并置systemEventWatcher为nullptr。 288 OH_HiAppEvent_DestroyWatcher(systemEventWatcher); 289 systemEventWatcher = nullptr; 290 return {}; 291 } 292 ``` 293