订阅崩溃事件（C/C++）
=============

#### 简介

本文介绍如何使用HiAppEvent提供的C/C++接口订阅应用崩溃事件。详细使用说明请参考[hiappevent.h](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-hiappevent-h)。

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/46/v3/MKguykAoQXKIEU_6QwQFnA/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073454Z&HW-CC-Expire=86400&HW-CC-Sign=84A5BA08532289DC1F336AC41CDDEDB08C64BEAFD66BE2500072A5B22BA13EFE)

使用C/C++接口订阅JsError和NativeCrash崩溃事件。

#### 接口说明

| 接口名 | 描述 |
| :-- | :-- |
| int OH\_HiAppEvent\_AddWatcher(HiAppEvent\_Watcher \*watcher) | 添加应用事件观察者，以添加对应用事件的订阅。 |
| int OH\_HiAppEvent\_RemoveWatcher(HiAppEvent\_Watcher \*watcher) | 移除应用事件观察者，以移除对应用事件的订阅。 |

#### 开发步骤

#### \[h2\]添加事件观察者

**在应用启动后，在执行业务逻辑前添加事件观察者，以确保订阅到崩溃事件。否则，应用可能因崩溃而退出，无法订阅崩溃事件。**

以用户点击按钮触发崩溃事件为例，开发步骤如下：

1.  获取该示例工程依赖的jsoncpp文件，打开链接[HiAppEvent示例工程EventSub](https://gitcode.com/openharmony/applications_app_samples/tree/master/code/DocsSample/PerformanceAnalysisKit/HiAppEvent/EventSub)，点击“下载当前目录”，下载EventSub工程文件。
    
2.  新建Native C++工程，并将上述文件导入到新建工程，目录结构如下。
    
    entry:
      libs:    //  放置jsoncpp关联三方库的文件夹
      src:
        main:
          cpp:
            - thirdparty:
                jsoncpp:    //  放置jsoncpp关联三方库的文件夹
            - types:
                libentry:
                  - index.d.ts
            - CMakeLists.txt
            - napi\_init.cpp
          ets:
            - entryability:
                - EntryAbility.ets
            - pages:
                - Index.ets
    
    该示例工程中jsoncpp库文件对应的源码来自[三方开源库jsoncpp](https://github.com/open-source-parsers/jsoncpp/archive/refs/tags/1.9.6.tar.gz)。
    
3.  在"CMakeLists.txt"文件中，添加源文件和动态库。
    
    add\_library(entry SHARED napi\_init.cpp)
    # 新增动态库依赖libhiappevent\_ndk.z.so和libhilog\_ndk.z.so(日志输出)
    target\_link\_libraries(entry PUBLIC libace\_napi.z.so libhilog\_ndk.z.so libhiappevent\_ndk.z.so)
    set(GZ\_FILE "${CMAKE\_CURRENT\_SOURCE\_DIR}/thirdparty/jsoncpp/src/jsoncpp-1.9.6.tar.gz")
    set(DEST\_DIR "${CMAKE\_CURRENT\_SOURCE\_DIR}/../../../build")
    # 检查是否存在entry/build目录
    execute\_process(COMMAND ${CMAKE\_COMMAND} -E make\_directory ${DEST\_DIR})
    # 解压jsoncpp-1.9.6.tar.gz到entry/build，得到jsoncpp头文件的目录
    execute\_process(COMMAND tar -xzf ${GZ\_FILE} -C ${DEST\_DIR}
        WORKING\_DIRECTORY ${DEST\_DIR})
    
    # 新增三方库依赖libjsoncpp.so(解析订阅事件中的json字符串)
    target\_link\_libraries(entry PRIVATE ${CMAKE\_CURRENT\_SOURCE\_DIR}/thirdparty/jsoncpp/${OHOS\_ARCH}/lib/libjsoncpp.so)
    target\_include\_directories(entry PRIVATE ${DEST\_DIR}/jsoncpp-1.9.6/include/json)
    
4.  在"napi\_init.cpp"文件中，导入依赖文件，并定义LOG\_TAG。
    
    #include "napi/native\_api.h"
    // 根据工程中三方库jsoncpp的位置适配引用json.h的路径
    #include "../../../build/jsoncpp-1.9.6/include/json/json.h"
    #include "hiappevent/hiappevent.h"
    #include "hiappevent/hiappevent\_param.h"
    #include "hilog/log.h"
    
    #undef LOG\_TAG
    #define LOG\_TAG "testTag"
    
5.  订阅系统事件。
    
    *   onReceive类型观察者
        
        在"napi\_init.cpp"文件中，定义onReceive类型观察者的方法：
        
        static void OnReceiveCrashEvent(const char \*domain, const struct HiAppEvent\_AppEventGroup \*appEventGroups,
            uint32\_t groupLen)
        {
            for (int i = 0; i < groupLen; ++i) {
                for (int j = 0; j < appEventGroups\[i\].infoLen; ++j) {
                    const struct HiAppEvent\_AppEventInfo &appEventInfo = appEventGroups\[i\].appEventInfos\[j\];
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.domain=%{public}s", appEventInfo.domain);
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.name=%{public}s", appEventInfo.name);
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.eventType=%{public}d", appEventInfo.type);
                    if (strcmp(appEventInfo.domain, DOMAIN\_OS) != 0 || strcmp(appEventInfo.name, EVENT\_APP\_CRASH) != 0) {
                        continue;
                    }
                    Json::Value params;
                    Json::Reader reader(Json::Features::strictMode());
                    Json::FastWriter writer;
                    if (reader.parse(appEventInfo.params, params)) {
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.time=%{public}lld",
                            params\["time"\].asInt64());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.crash\_type=%{public}s",
                            params\["crash\_type"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.foreground=%{public}d",
                            params\["foreground"\].asBool());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.release\_type=%{public}s",
                            params\["release\_type"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.cpu\_abi=%{public}s",
                            params\["cpu\_abi"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.app\_running\_unique\_id=%{public}s",
                            params\["app\_running\_unique\_id"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.bundle\_version=%{public}s",
                            params\["bundle\_version"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.bundle\_name=%{public}s",
                            params\["bundle\_name"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.pid=%{public}d", params\["pid"\].asInt());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.uid=%{public}d", params\["uid"\].asInt());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.uuid=%{public}s",
                            params\["uuid"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.exception=%{public}s",
                            writer.write(params\["exception"\]).c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.hilog.size=%{public}d",
                            params\["hilog"\].size());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.process\_life\_time=%{public}d",
                            params\["process\_life\_time"\].asInt());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.memory=%{public}s",
                            writer.write(params\["memory"\]).c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.external\_log=%{public}s",
                            writer.write(params\["external\_log"\]).c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.log\_over\_limit=%{public}d",
                            params\["log\_over\_limit"\].asBool());
                    }
                }
            }
        }
        
        // 定义变量，用来缓存创建的观察者的指针。
        static HiAppEvent\_Watcher \*systemEventWatcherR;
        
        static napi\_value RegisterWatcherCrashEvent(napi\_env env, napi\_callback\_info info)
        {
            // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。
            systemEventWatcherR = OH\_HiAppEvent\_CreateWatcher("AppCrashWatcherR");
            // 设置订阅的事件名称为EVENT\_APP\_CRASH，即崩溃事件。
            const char \*names\[\] = {EVENT\_APP\_CRASH};
            // 开发者订阅感兴趣的事件，此处订阅了系统事件。
            OH\_HiAppEvent\_SetAppEventFilter(systemEventWatcherR, DOMAIN\_OS, 0, names, 1);
            // 开发者设置已实现的回调函数，观察者接收到事件后回立即触发OnReceiveCrashEvent回调。
            OH\_HiAppEvent\_SetWatcherOnReceive(systemEventWatcherR, OnReceiveCrashEvent);
            // 使观察者开始监听订阅的事件。
            OH\_HiAppEvent\_AddWatcher(systemEventWatcherR);
        
            // 1. 创建配置对象
            HiAppEvent\_Config\* config = OH\_HiAppEvent\_CreateConfig();
        
            // 2. 设置各项配置参数
            // 开启寄存器扩展内存打印
            OH\_HiAppEvent\_SetConfigItem(config, OH\_APP\_CRASH\_PARAM\_EXTEND\_PC\_LR\_PRINTING, "true");
        
            // 设置日志截断大小为 2MB
            OH\_HiAppEvent\_SetConfigItem(config, OH\_APP\_CRASH\_PARAM\_LOG\_FILE\_CUTOFF\_SZ\_BYTES, "2097152");
        
            // 开启简化 VMA 映射信息打印
            OH\_HiAppEvent\_SetConfigItem(config, OH\_APP\_CRASH\_PARAM\_SIMPLIFY\_VMA\_PRINTING, "true");
        
            // 开启拼接应用日志
            OH\_HiAppEvent\_SetConfigItem(config, OH\_APP\_CRASH\_PARAM\_MERGE\_CPPCRASH\_APP\_LOG, "true");
        
            // native崩溃场景，使能minidump
            OH\_HiAppEvent\_SetConfigItem(config, OH\_APP\_CRASH\_PARAM\_COLLECT\_MINIDUMP, "true");
        
            // 3. 应用配置到 EVENT\_APP\_CRASH 事件
            int ret = OH\_HiAppEvent\_SetEventConfig(EVENT\_APP\_CRASH, config);
            if (ret == HIAPPEVENT\_SUCCESS) {
                OH\_LOG\_INFO(LogType::LOG\_APP, "Successfully set APP\_CRASH event configurations.");
            }
        
            // 4. 销毁配置对象
            OH\_HiAppEvent\_DestroyConfig(config);
        
            return {};
        }
        
    *   onTrigger类型观察者
        
        在"napi\_init.cpp"文件中，定义OnTrigger类型观察者：
        
        // 开发者可以自行实现获取已监听到事件的回调函数，其中events指针指向内容仅在该函数内有效。
        static void OnTakeCrash(const char \*const \*events, uint32\_t eventLen)
        {
            Json::Reader reader(Json::Features::strictMode());
            Json::FastWriter writer;
            for (int i = 0; i < eventLen; ++i) {
                Json::Value eventInfo;
                if (reader.parse(events\[i\], eventInfo)) {
                    auto domain =  eventInfo\["domain\_"\].asString();
                    auto name = eventInfo\["name\_"\].asString();
                    auto type = eventInfo\["type\_"\].asInt();
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.WatcherType=OnTrigger");
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.domain=%{public}s", domain.c\_str());
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.name=%{public}s", name.c\_str());
                    OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.eventType=%{public}d", type);
                    if (domain ==  DOMAIN\_OS && name == EVENT\_APP\_CRASH) {
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.time=%{public}lld",
                            eventInfo\["time"\].asInt64());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.crash\_type=%{public}s",
                            eventInfo\["crash\_type"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.foreground=%{public}d",
                            eventInfo\["foreground"\].asBool());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.app\_running\_unique\_id=%{public}s",
                            eventInfo\["app\_running\_unique\_id"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.bundle\_version=%{public}s",
                            eventInfo\["bundle\_version"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.bundle\_name=%{public}s",
                            eventInfo\["bundle\_name"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.pid=%{public}d", eventInfo\["pid"\].asInt());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.uid=%{public}d", eventInfo\["uid"\].asInt());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.uuid=%{public}s",
                            eventInfo\["uuid"\].asString().c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.exception=%{public}s",
                            writer.write(eventInfo\["exception"\]).c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.hilog.size=%{public}d",
                            eventInfo\["hilog"\].size());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.process\_life\_time=%{public}d",
                            eventInfo\["process\_life\_time"\].asInt());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.memory=%{public}s",
                            writer.write(eventInfo\["memory"\]).c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.external\_log=%{public}s",
                            writer.write(eventInfo\["external\_log"\]).c\_str());
                        OH\_LOG\_INFO(LogType::LOG\_APP, "HiAppEvent eventInfo.params.log\_over\_limit=%{public}d",
                            eventInfo\["log\_over\_limit"\].asBool());
                    }
                }
            }
        }
        
        // 定义变量，用来缓存创建的观察者的指针。
        static HiAppEvent\_Watcher \*systemEventWatcherT;
        
        // 开发者可以自行实现订阅回调函数，以便对获取到的事件打点数据进行自定义处理。
        static void OnTriggerCrash(int row, int size)
        {
            // 接收回调后，获取指定数量的已接收事件。
            OH\_HiAppEvent\_TakeWatcherData(systemEventWatcherT, row, OnTakeCrash);
        }
        
        static napi\_value RegisterWatcherClickCrash(napi\_env env, napi\_callback\_info info)
        {
            // 开发者自定义观察者名称，系统根据不同的名称来识别不同的观察者。
            systemEventWatcherT = OH\_HiAppEvent\_CreateWatcher("AppCrashWatcherT");
            // 设置订阅的事件为EVENT\_APP\_CRASH。
            const char \*names\[\] = {EVENT\_APP\_CRASH};
            // 开发者订阅感兴趣的事件，此处订阅了系统事件。
            OH\_HiAppEvent\_SetAppEventFilter(systemEventWatcherT, DOMAIN\_OS, 0, names, 1);
            // 开发者设置已实现的回调函数，需OH\_HiAppEvent\_SetTriggerCondition设置的条件满足方可触发。
            OH\_HiAppEvent\_SetWatcherOnTrigger(systemEventWatcherT, OnTriggerCrash);
            // 开发者可以设置订阅触发回调的条件，此处是设置新增事件打点数量为1个时，触发OnTriggerCrash回调。
            OH\_HiAppEvent\_SetTriggerCondition(systemEventWatcherT, 1, 0, 0);
            // 使观察者开始监听订阅的事件。
            OH\_HiAppEvent\_AddWatcher(systemEventWatcherT);
            return {};
        }
        
6.  将RegisterWatcher注册为ArkTS接口。
    
    在"napi\_init.cpp"文件中，将RegisterWatcher注册为ArkTS接口：
    
    static napi\_value Init(napi\_env env, napi\_value exports)
    {
        napi\_property\_descriptor desc\[\] = {
            // ···
            { "registerWatcherCrashEvent", nullptr, RegisterWatcherCrashEvent, nullptr, nullptr, nullptr, napi\_default,
                nullptr },
            { "registerWatcherClickCrash", nullptr, RegisterWatcherClickCrash, nullptr, nullptr, nullptr, napi\_default,
                nullptr },
            // ···
        };
        napi\_define\_properties(env, exports, sizeof(desc) / sizeof(desc\[0\]), desc);
        return exports;
    }
    
    在"index.d.ts"文件中，定义ArkTS接口：
    
    export const registerWatcherClickCrash: () => void;
    export const registerWatcherCrashEvent: () => void;
    
7.  在"EntryAbility.ets"文件的onCreate()函数中添加接口调用。
    
    // 在onCreate()函数中添加C API接口调用
    // 启动时，注册崩溃事件观察者
    testNapi.registerWatcherClickCrash();
    // 启动时，注册按钮点击事件观察者
    testNapi.registerWatcherCrashEvent();
    
8.  在"Index.ets"文件中，新增按钮触发崩溃事件。
    
    *   构造JsError类型崩溃
    
    Button('JsError')
      .type(ButtonType.Capsule)
      .margin({
        top: 20
      })
      .backgroundColor('#0D9FFB')
      .width('80%')
      .height('5%')
      .onClick(() => {
        // 在按钮点击函数中构造一个crash场景，触发应用崩溃事件
        JSON.parse('');
      })
    
    *   构造MergeLogNativeCrash拼接应用日志类型崩溃
        
        编辑工程中的“entry > src > main > ets > pages > Index.ets”文件，导入依赖模块。示例代码如下：
        
        import { fileIo } from '@kit.CoreFileKit';
        
        编辑工程中的“entry > src > main > ets > pages > Index.ets”文件，添加按钮并在其onClick函数中构造崩溃场景，以触发崩溃事件。示例代码如下：
        
        Button('MergeLogNativeCrash')
        .type(ButtonType.Capsule)
        .margin({
          top: 20
        })
        .backgroundColor('#0D9FFB')
        .width('80%')
        .height('5%')
        .onClick(() => {
          // 模拟创建 applog，假设应用包名为 com.samples.eventsub
          let filePath : string = "/data/storage/el2/log/com.samples.eventsub\_CppCrash\_AppMerge.log";
          let file = fileIo.openSync(filePath, fileIo.OpenMode.CREATE | fileIo.OpenMode.READ\_WRITE);
          let str: string = "only test for merge app log!";
        
          let writeLen = fileIo.writeSync(file.fd, str);
          console.info("hiappevent write data to file succeed and size is:" + writeLen);
          fileIo.closeSync(file);
        
          // 在按钮点击函数中构造一个crash场景，触发应用崩溃事件
          testNapi.testNullptr();
        })
        
9.  点击运行按钮启动应用工程。在应用界面中单击“JsError”或“MergeLogNativeCrash”按钮触发崩溃事件。系统生成崩溃日志并回调。
    

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/6a/v3/TwJRrFVMTjiW70JFq-5ylg/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260612T073454Z&HW-CC-Expire=86400&HW-CC-Sign=F2835E0B12821A76740E0F9000338DB8FF4113E06327CBEA0496DC3FD6885728)

JsError通过进程内采集故障信息触发回调，速度快。NativeCrash采取进程外采集故障信息，平均耗时约2秒，具体受业务线程数量和进程间通信影响。订阅崩溃事件后，故障信息采集完成会异步上报，不阻塞当前业务。

#### \[h2\]验证观察者是否订阅到崩溃事件

在应用未主动捕获崩溃异常和主动捕获崩溃异常的两种场景中，崩溃事件的回调时机不同。开发者需要在每种情况下验证是否订阅到崩溃事件。

**应用未主动捕获崩溃异常场景**

若应用未主动捕获崩溃异常，则系统处理崩溃后应用将退出。**应用下次启动时**，HiAppEvent将崩溃事件上报给已注册的监听，完成回调。

从API version 21开始，若应用无法启动或长时间未启动，开发者可以参考[使用FaultLogExtensionAbility订阅事件](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/fault-log-extension-app-events-arkts)回调重写的函数，进行延迟上报。

**应用主动捕获崩溃异常场景**

若应用主动捕获崩溃异常，HiAppEvent事件将在**应用退出前**触发回调，例如：

1.  异常处理中未主动退出的应用崩溃后不会退出。
    
    采用[errorManager.on](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-app-ability-errormanager#errormanageronerror)方法捕获异常会导致JsError类型的崩溃事件在应用退出前触发回调。若应用注册[崩溃信号](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/cppcrash-guidelines#系统处理的崩溃信号)处理函数但未主动退出，会导致NativeCrash类型的崩溃事件在应用退出前触发回调。
    
2.  异常处理耗时过长，会导致应用退出延迟。
    

在开发调试阶段，HiAppEvent上报事件完成回调后，可在DevEco Studio的HiLog窗口查看订阅的崩溃事件内容。

HiAppEvent eventInfo.domain=OS
HiAppEvent eventInfo.name=APP\_CRASH
HiAppEvent eventInfo.eventType=1
HiAppEvent eventInfo.params.time=1503045716054
HiAppEvent eventInfo.params.crash\_type=JsError
HiAppEvent eventInfo.params.foreground=1
HiAppEvent eventInfo.params.app\_running\_unique\_id=365426736245712514
HiAppEvent eventInfo.params.bundle\_version=1.0.0
HiAppEvent eventInfo.params.bundle\_name=com.samples.eventsub
HiAppEvent eventInfo.params.pid=2610
HiAppEvent eventInfo.params.uid=20010044
HiAppEvent eventInfo.params.uuid=7c3b1579c8ca8629af3858f8145254c2867ee402dc16ee18034337aae258620b
HiAppEvent eventInfo.params.exception={"message":"Unexpected Text in JSON: Empty Text","name":"SyntaxError","stack":"    at anonymous (entry|entry|1.0.0|src/main/ets/pages/Index.ts:163:22)\\n","thread\_name":"amples.eventsub"}
HiAppEvent eventInfo.params.hilog.size=100
HiAppEvent eventInfo.params.process\_life\_time=25
HiAppEvent eventInfo.params.memory={"rss":181964,"sys\_avail\_mem":1230456,"sys\_free\_mem":676940,"sys\_total\_mem":2001932}
HiAppEvent eventInfo.params.external\_log=\["/data/storage/el2/log/hiappevent/APP\_CRASH\_1503045716408\_2610.log","/data/storage/el2/log/hiappevent/APP\_CRASH\_1503045716409\_2610.dmp"\]
HiAppEvent eventInfo.params.log\_over\_limit=0

#### \[h2\]移除并销毁事件观察者

1.  移除事件观察者。
    
    static napi\_value RemoveWatcherCrash(napi\_env env, napi\_callback\_info info)
    {
        // 使观察者停止监听crash事件
        OH\_HiAppEvent\_RemoveWatcher(systemEventWatcherR);
        OH\_HiAppEvent\_RemoveWatcher(systemEventWatcherT);
        return {};
    }
    
2.  销毁事件观察者。
    
    static napi\_value DestroyWatcherCrash(napi\_env env, napi\_callback\_info info)
    {
        // 销毁创建的观察者，并置eventWatcher为nullptr。
        OH\_HiAppEvent\_DestroyWatcher(systemEventWatcherR);
        OH\_HiAppEvent\_DestroyWatcher(systemEventWatcherT);
        systemEventWatcherR = nullptr;
        systemEventWatcherT = nullptr;
        return {};
    }