添加事件监听
======

NDK接口为组件提供了事件监听能力。本文介绍组件事件监听、布局和绘制送显事件监听以及深浅色变更事件监听的使用方法。

#### 监听组件事件

NDK接口支持监听UI组件自身状态变化和用户交互事件。

首先，可使用[addNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#addnodeeventreceiver)函数添加组件事件的监听器，该监听器会监听该组件上发生的所有事件，例如：点击事件、焦点事件。然后，使用[registerNodeEvent](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#registernodeevent)函数声明组件需要监听的事件，NDK接口支持的事件范围可以查询[ArkUI\_NodeEventType](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#arkui_nodeeventtype)枚举。

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/f6/v3/JG0ccLWJRG2w8H9DnvvecA/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260709T132315Z&HW-CC-Expire=86400&HW-CC-Sign=173831FC0C361D7837BE2BA2E70521B1CE9E3770815068A3EFEDD5E4DFC6FA28)

*   事件注册需要声明[addNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#addnodeeventreceiver)监听器注册和[registerNodeEvent](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#registernodeevent)事件类型，监听器只能监听已声明的事件。
    
*   需要关注事件的反注册逻辑，如在组件销毁前调用[removeNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#removenodeeventreceiver)移除事件监听器，[unregisterNodeEvent](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#unregisternodeevent)通知ArkUI框架已监听的事件不再需要监听。
    
*   [addNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#addnodeeventreceiver)可以添加多个函数指针，每个函数指针都会在对应事件触发时触发，对应的[removeNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#removenodeeventreceiver)需要传递对应的函数指针用于移除监听。
    
*   [registerNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#registernodeeventreceiver)是全局监听函数，不同于[addNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#addnodeeventreceiver)，[registerNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#registernodeeventreceiver)能够监听所有Native组件的事件触发，但只能传递一个函数指针，多次调用使用最后一次的函数指针进行回调，释放时使用[unregisterNodeEventReceiver](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1#unregisternodeeventreceiver)进行释放。
    

以下示例均需基于[接入ArkTS页面](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/ndk-access-the-arkts-page)，详细代码请参考[完整示例](#完整示例)。

#### \[h2\]监听节点事件

通过addNodeEventReceiver对节点绑定事件处理函数，接着通过调用registerNodeEvent注册对应的事件监听。

定义[ArkUI\_NativeNodeAPI\_1](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-arkui-nativemodule-arkui-nativenodeapi-1)类型的指针。

ArkUI\_NativeNodeAPI\_1 \*nodeAPI = nullptr;

调用[OH\_ArkUI\_GetModuleInterface](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-interface-h#oh_arkui_getmoduleinterface)接口给定义的指针赋值。

OH\_ArkUI\_GetModuleInterface(ARKUI\_NATIVE\_NODE, ArkUI\_NativeNodeAPI\_1, nodeAPI);

定义事件触发回调函数。

void NodeEventReceiver(ArkUI\_NodeEvent \*event) {
  // 设置对应的事件类型触发时进行的操作，如NODE\_ON\_CLICK\_EVENT
};

创建一个节点，将事件触发回调函数绑定到该节点并进行事件注册。

auto button = nodeAPI->createNode(ARKUI\_NODE\_BUTTON);
nodeAPI->addNodeEventReceiver(button, NodeEventReceiver);
nodeAPI->registerNodeEvent(button, NODE\_ON\_CLICK\_EVENT, 0, nullptr);

详细的事件类型请参考[ArkUI\_NodeEventType](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#arkui_nodeeventtype)。

通过unregisterNodeEvent解注册对应的事件类型，再通过removeNodeEventReceiver卸载事件处理函数。

解注册对应的事件类型。

nodeAPI->unregisterNodeEvent(button, NODE\_ON\_CLICK\_EVENT);

卸载事件处理函数。

nodeAPI->removeNodeEventReceiver(button, NodeEventReceiver);

#### \[h2\]监听全局事件

使用registerNodeEventReceiver注册全局的事件处理函数，对事件进行统一的监听，结束后可使用unregisterNodeEventReceiver进行释放。

注册全局的事件处理函数。

nodeAPI->registerNodeEventReceiver(\[\](ArkUI\_NodeEvent \*event) {
    // 从组件事件中获取基础事件对象
    auto \*inputEvent = OH\_ArkUI\_NodeEvent\_GetInputEvent(event);
    // 从组件事件获取事件类型
    auto eventType = OH\_ArkUI\_NodeEvent\_GetEventType(event);
    // ...
    switch (eventType) {
        case NODE\_ON\_CLICK\_EVENT: {
            // 触发点击事件所进行的操作，从基础事件获取事件信息
            // ...
        }
        default: {
            break;
        }
    }
});

解注册全局的事件处理函数。

nodeAPI->unregisterNodeEventReceiver();

#### \[h2\]完整示例

1.  在ArkUINode基类对象中封装事件注册及监听接口调用的方法。
    
    // ArkUINode.h
    // 提供通用属性和事件的封装。
    
    #ifndef MYAPPLICATION\_ARKUINODE\_H
    #define MYAPPLICATION\_ARKUINODE\_H
    
    #include "ArkUIBaseNode.h"
    #include "NativeModule.h"
    
    #include <arkui/native\_node.h>
    #include <arkui/native\_type.h>
    
    namespace NativeModule {
    
    class ArkUINode : public ArkUIBaseNode {
    public:
        explicit ArkUINode(ArkUI\_NodeHandle handle) : ArkUIBaseNode(handle)
        {
            nativeModule\_ = NativeModuleInstance::GetInstance()->GetNativeNodeAPI();
            // 事件触发时需要通过函数获取对应的事件对象，这边通过设置节点自定义数据将封装类指针保持在组件上，方便后续事件分发。
            nativeModule\_->setUserData(handle\_, this);
            // 注册节点监听事件接收器。
            nativeModule\_->addNodeEventReceiver(handle\_, ArkUINode::NodeEventReceiver);
        }
    
        ~ArkUINode() override
        {
            if (onClick\_) {
                nativeModule\_->unregisterNodeEvent(handle\_, NODE\_ON\_CLICK\_EVENT);
            }
            if (onTouch\_) {
                nativeModule\_->unregisterNodeEvent(handle\_, NODE\_TOUCH\_EVENT);
            }
            if (onDisappear\_) {
                nativeModule\_->unregisterNodeEvent(handle\_, NODE\_EVENT\_ON\_DISAPPEAR);
            }
            if (onAppear\_) {
                nativeModule\_->unregisterNodeEvent(handle\_, NODE\_EVENT\_ON\_APPEAR);
            }
            nativeModule\_->removeNodeEventReceiver(handle\_, ArkUINode::NodeEventReceiver);
        }
        // 设置节点宽度
        void SetWidth(float width)
        {
            if (!handle\_) {
                return;
            }
            ArkUI\_NumberValue value\[\] = {{.f32 = width}};
            ArkUI\_AttributeItem item = {value, 1};
            nativeModule\_->setAttribute(handle\_, NODE\_WIDTH, &item);
        }
        // 设置节点宽度（百分比形式）
        void SetPercentWidth(float percent)
        {
            if (!handle\_) {
                return;
            }
            ArkUI\_NumberValue value\[\] = {{.f32 = percent}};
            ArkUI\_AttributeItem item = {value, 1};
            nativeModule\_->setAttribute(handle\_, NODE\_WIDTH\_PERCENT, &item);
        }
        // 设置节点高度
        void SetHeight(float height)
        {
            if (!handle\_) {
                return;
            }
            ArkUI\_NumberValue value\[\] = {{.f32 = height}};
            ArkUI\_AttributeItem item = {value, 1};
            nativeModule\_->setAttribute(handle\_, NODE\_HEIGHT, &item);
        }
        // 设置节点高度（百分比形式）
        void SetPercentHeight(float percent)
        {
            if (!handle\_) {
                return;
            }
            ArkUI\_NumberValue value\[\] = {{.f32 = percent}};
            ArkUI\_AttributeItem item = {value, 1};
            nativeModule\_->setAttribute(handle\_, NODE\_HEIGHT\_PERCENT, &item);
        }
        // 设置节点背景颜色
        void SetBackgroundColor(uint32\_t color)
        {
            if (!handle\_) {
                return;
            }
            ArkUI\_NumberValue value\[\] = {{.u32 = color}};
            ArkUI\_AttributeItem item = {value, 1};
            nativeModule\_->setAttribute(handle\_, NODE\_BACKGROUND\_COLOR, &item);
        }
        // 处理通用事件。
        void RegisterOnClick(const std::function<void(ArkUI\_NodeEvent \*event)> &onClick)
        {
            if (!handle\_) {
                return;
            }
            onClick\_ = onClick;
            // 注册点击事件。
            nativeModule\_->registerNodeEvent(handle\_, NODE\_ON\_CLICK\_EVENT, 0, nullptr);
        }
    
        void RegisterOnTouch(const std::function<void(int32\_t type, float x, float y)> &onTouch)
        {
            if (!handle\_) {
                return;
            }
            onTouch\_ = onTouch;
            // 注册触碰事件。
            nativeModule\_->registerNodeEvent(handle\_, NODE\_TOUCH\_EVENT, 0, nullptr);
        }
    
        void RegisterOnDisappear(const std::function<void()> &onDisappear)
        {
            if (!handle\_) {
                return;
            }
            onDisappear\_ = onDisappear;
            // 注册卸载事件。
            nativeModule\_->registerNodeEvent(handle\_, NODE\_EVENT\_ON\_DISAPPEAR, 0, nullptr);
        }
    
        void RegisterOnAppear(const std::function<void()> &onAppear)
        {
            if (!handle\_) {
                return;
            }
            onAppear\_ = onAppear;
            // 注册挂载事件。
            nativeModule\_->registerNodeEvent(handle\_, NODE\_EVENT\_ON\_APPEAR, 0, nullptr);
        }
    
    protected:
        // 事件监听器函数指针。
        static void NodeEventReceiver(ArkUI\_NodeEvent \*event)
        {
            // 获取事件发生的UI组件对象。
            auto nodeHandle = OH\_ArkUI\_NodeEvent\_GetNodeHandle(event);
            // 获取保持在UI组件对象中的自定义数据，返回封装类指针。
            auto \*node = reinterpret\_cast<ArkUINode \*>(
                NativeModuleInstance::GetInstance()->GetNativeNodeAPI()->getUserData(nodeHandle));
            // 基于封装类实例对象处理事件。
            node->ProcessNodeEvent(event);
        }
        void ProcessNodeEvent(ArkUI\_NodeEvent \*event)
        {
            auto eventType = OH\_ArkUI\_NodeEvent\_GetEventType(event);
            switch (eventType) {
                case NODE\_ON\_CLICK\_EVENT: {
                    if (onClick\_) {
                        onClick\_(event);
                    }
                    break;
                }
                case NODE\_TOUCH\_EVENT: {
                    if (onTouch\_) {
                        auto \*uiInputEvent = OH\_ArkUI\_NodeEvent\_GetInputEvent(event);
                        float x = OH\_ArkUI\_PointerEvent\_GetX(uiInputEvent);
                        float y = OH\_ArkUI\_PointerEvent\_GetY(uiInputEvent);
                        auto type = OH\_ArkUI\_UIInputEvent\_GetAction(uiInputEvent);
                        onTouch\_(type, x, y);
                    }
                }
                case NODE\_EVENT\_ON\_DISAPPEAR: {
                    if (onDisappear\_) {
                        onDisappear\_();
                    }
                    break;
                }
                case NODE\_EVENT\_ON\_APPEAR: {
                    if (onAppear\_) {
                        onAppear\_();
                    }
                    break;
                }
                default: {
                    // 组件特有事件交给子类处理
                    OnNodeEvent(event);
                }
            }
        }
    
        virtual void OnNodeEvent(ArkUI\_NodeEvent \*event) {}
    
        void OnAddChild(const std::shared\_ptr<ArkUIBaseNode> &child) override
        {
            nativeModule\_->addChild(handle\_, child->GetHandle());
        }
    
        void OnRemoveChild(const std::shared\_ptr<ArkUIBaseNode> &child) override
        {
            nativeModule\_->removeChild(handle\_, child->GetHandle());
        }
    
        void OnInsertChild(const std::shared\_ptr<ArkUIBaseNode> &child, int32\_t index) override
        {
            nativeModule\_->insertChildAt(handle\_, child->GetHandle(), index);
        }
    
    private:
        std::function<void(ArkUI\_NodeEvent \*event)> onClick\_;
        std::function<void()> onDisappear\_;
        std::function<void()> onAppear\_;
        std::function<void(int32\_t type, float x, float y)> onTouch\_;
    };
    } // namespace NativeModule
    
    #endif // MYAPPLICATION\_ARKUINODE\_H
    
2.  在ArkUIListNode对象中注册列表事件[NODE\_LIST\_ON\_SCROLL\_INDEX](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#arkui_nodeeventtype)。
    
    // ArkUIListNode.h
    // 列表封装类对象
    
    #ifndef MYAPPLICATION\_ARKUILISTNODE\_H
    #define MYAPPLICATION\_ARKUILISTNODE\_H
    
    #include "ArkUINode.h"
    
    namespace NativeModule {
    class ArkUIListNode : public ArkUINode {
    public:
        ArkUIListNode()
            : ArkUINode((NativeModuleInstance::GetInstance()->GetNativeNodeAPI())->createNode(ARKUI\_NODE\_LIST)) {}
    
        ~ArkUIListNode() override { nativeModule\_->unregisterNodeEvent(handle\_, NODE\_LIST\_ON\_SCROLL\_INDEX); }
    
        void SetScrollBarState(bool isShow)
        {
            if (!handle\_) {
                return;
            }
            ArkUI\_ScrollBarDisplayMode displayMode =
                isShow ? ARKUI\_SCROLL\_BAR\_DISPLAY\_MODE\_ON : ARKUI\_SCROLL\_BAR\_DISPLAY\_MODE\_OFF;
            ArkUI\_NumberValue value\[\] = {{.i32 = displayMode}};
            ArkUI\_AttributeItem item = {value, 1};
            nativeModule\_->setAttribute(handle\_, NODE\_SCROLL\_BAR\_DISPLAY\_MODE, &item);
        }
    
        // 注册列表相关事件。
        void RegisterOnScrollIndex(const std::function<void(int32\_t index)> &onScrollIndex)
        {
            if (!handle\_) {
                return;
            }
            onScrollIndex\_ = onScrollIndex;
            nativeModule\_->registerNodeEvent(handle\_, NODE\_LIST\_ON\_SCROLL\_INDEX, 0, nullptr);
        }
    
    protected:
       // 处理List相关事件。
        void OnNodeEvent(ArkUI\_NodeEvent \*event) override
        {
            auto eventType = OH\_ArkUI\_NodeEvent\_GetEventType(event);
            switch (eventType) {
                case NODE\_LIST\_ON\_SCROLL\_INDEX: {
                    auto index = OH\_ArkUI\_NodeEvent\_GetNodeComponentEvent(event)->data\[0\];
                    if (onScrollIndex\_) {
                        onScrollIndex\_(index.i32);
                    }
                }
                default: {
                }
            }
        }
    
    private:
        std::function<void(int32\_t index)> onScrollIndex\_;
    };
    } // namespace NativeModule
    
    #endif // MYAPPLICATION\_ARKUILISTNODE\_H
    
3.  在文本列表项中添加事件监听函数，本示例以点击事件（[NODE\_ON\_CLICK\_EVENT](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#arkui_nodeeventtype)）为例，添加事件响应的具体信息。
    
    // NormalTextListExample.h
    // 文本列表示例。
    
    #ifndef MYAPPLICATION\_NORMALTEXTLISTEXAMPLE\_H
    #define MYAPPLICATION\_NORMALTEXTLISTEXAMPLE\_H
    
    #include "ArkUIBaseNode.h"
    #include "ArkUIListItemNode.h"
    #include "ArkUIListNode.h"
    #include "ArkUITextNode.h"
    #include <hilog/log.h>
    
    const unsigned int LOG\_PRINT\_DOMAIN = 0xF811;
    const unsigned int LOOP\_SIZE = 30;
    const unsigned int FONT\_SIZE = 16;
    const unsigned int HEIGHT\_SIZE = 200;
    const float PERCENT\_WIDTH\_1 = 1;
    const float PERCENT\_HEIGHT\_1 = 1;
    
    namespace NativeModule {
    
    std::shared\_ptr<ArkUIBaseNode> CreateTextListExample()
    {
        // 创建组件并挂载
        // 1：创建List组件。
        auto list = std::make\_shared<ArkUIListNode>();
        list->SetPercentWidth(PERCENT\_WIDTH\_1);
        list->SetPercentHeight(PERCENT\_HEIGHT\_1);
        // 2：创建ListItem子组件并挂载到List上。
        for (int32\_t i = 0; i < LOOP\_SIZE; ++i) {
            auto listItem = std::make\_shared<ArkUIListItemNode>();
            auto textNode = std::make\_shared<ArkUITextNode>();
            textNode->SetTextContent(std::to\_string(i));
            textNode->SetFontSize(FONT\_SIZE);
            textNode->SetPercentWidth(PERCENT\_WIDTH\_1);
            textNode->SetHeight(HEIGHT\_SIZE);
            textNode->SetBackgroundColor(0xFFfffacd);
            textNode->SetTextAlign(ARKUI\_TEXT\_ALIGNMENT\_CENTER);
            listItem->AddChild(textNode);
            // 列表项注册点击事件。
            auto onClick = \[\](ArkUI\_NodeEvent \*event) {
                // 从组件事件中获取基础事件对象
                auto \*inputEvent = OH\_ArkUI\_NodeEvent\_GetInputEvent(event);
                if (inputEvent == nullptr) {
                    return;
                }
                // 从组件事件获取事件类型
                auto eventType = OH\_ArkUI\_NodeEvent\_GetEventType(event);
                OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                             "NdkAddInteractionEvent\_eventInfo inputEvent = %{public}p", inputEvent);
                OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                             "NdkAddInteractionEvent\_eventInfo eventType = %{public}d", eventType);
                auto componentEvent = OH\_ArkUI\_NodeEvent\_GetNodeComponentEvent(event);
                // 获取组件事件中的数字类型数据
                OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                             "NdkAddInteractionEvent\_eventInfo componentEvent = %{public}p", componentEvent);
                // 获取触发该事件的组件对象
                auto nodeHandle = OH\_ArkUI\_NodeEvent\_GetNodeHandle(event);
                if (nodeHandle == nullptr) {
                    return;
                }
                OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                             "NdkAddInteractionEvent\_eventInfo nodeHandle = %{public}p", nodeHandle);
                // 根据eventType来区分事件类型，进行差异化处理，其他获取事件信息的接口也可类似方式来进行差异化的处理
                switch (eventType) {
                    case NODE\_ON\_CLICK\_EVENT: {
                        // 触发点击事件所进行的操作，从基础事件获取事件信息
                        auto x = OH\_ArkUI\_PointerEvent\_GetX(inputEvent);
                        auto y = OH\_ArkUI\_PointerEvent\_GetY(inputEvent);
                        auto displayX = OH\_ArkUI\_PointerEvent\_GetDisplayX(inputEvent);
                        auto displayY = OH\_ArkUI\_PointerEvent\_GetDisplayY(inputEvent);
                        auto windowX = OH\_ArkUI\_PointerEvent\_GetWindowX(inputEvent);
                        auto windowY = OH\_ArkUI\_PointerEvent\_GetWindowY(inputEvent);
                        auto pointerCount = OH\_ArkUI\_PointerEvent\_GetPointerCount(inputEvent);
                        auto xByIndex = OH\_ArkUI\_PointerEvent\_GetXByIndex(inputEvent, 0);
                        auto yByIndex = OH\_ArkUI\_PointerEvent\_GetYByIndex(inputEvent, 0);
                        auto displayXByIndex = OH\_ArkUI\_PointerEvent\_GetDisplayXByIndex(inputEvent, 0);
                        auto displayYByIndex = OH\_ArkUI\_PointerEvent\_GetDisplayYByIndex(inputEvent, 0);
                        auto windowXByIndex = OH\_ArkUI\_PointerEvent\_GetWindowXByIndex(inputEvent, 0);
                        auto windowYByIndex = OH\_ArkUI\_PointerEvent\_GetWindowYByIndex(inputEvent, 0);
                        auto pointerId = OH\_ArkUI\_PointerEvent\_GetPointerId(inputEvent, 0);
                        auto pressure = OH\_ArkUI\_PointerEvent\_GetPressure(inputEvent, 0);
                        auto action = OH\_ArkUI\_UIInputEvent\_GetAction(inputEvent);
                        auto eventTime = OH\_ArkUI\_UIInputEvent\_GetEventTime(inputEvent);
                        auto sourceType = OH\_ArkUI\_UIInputEvent\_GetSourceType(inputEvent);
                        auto type = OH\_ArkUI\_UIInputEvent\_GetType(inputEvent);
                        std::string eventInfo =
                            "x: " + std::to\_string(x) + ", y: " + std::to\_string(y) +
                            ", displayX: " + std::to\_string(displayX) + ", displayY: " + std::to\_string(displayY) +
                            ", windowX: " + std::to\_string(windowX) + ", windowY: " + std::to\_string(windowY) +
                            ", pointerCount: " + std::to\_string(pointerCount) + ", xByIndex: " + std::to\_string(xByIndex) +
                            ", yByIndex: " + std::to\_string(yByIndex) +
                            ", displayXByIndex: " + std::to\_string(displayXByIndex) +
                            ", displayYByIndex: " + std::to\_string(displayYByIndex) +
                            ", windowXByIndex: " + std::to\_string(windowXByIndex) +
                            ", windowYByIndex: " + std::to\_string(windowYByIndex) +
                            ", pointerId: " + std::to\_string(pointerId) + ", pressure: " + std::to\_string(pressure) +
                            ", action: " + std::to\_string(action) + ", eventTime: " + std::to\_string(eventTime) +
                            ", sourceType: " + std::to\_string(sourceType) + ", type: " + std::to\_string(type);
                        OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                                     "NdkAddInteractionEvent\_eventInfoOfCommonEvent eventInfo = %{public}s",
                                     eventInfo.c\_str());
                    }
                    default: {
                        break;
                    }
                }
            };
            listItem->RegisterOnClick(onClick);
            list->AddChild(listItem);
        }
        // 3：注册List相关监听事件.
        list->RegisterOnScrollIndex(\[\](int32\_t index) { OH\_LOG\_INFO(LOG\_APP, "on list scroll index: %{public}d", index); });
        // 4: 注册挂载事件。
        list->RegisterOnAppear(\[\]() { OH\_LOG\_INFO(LOG\_APP, "on list mount to tree"); });
        // 5: 注册卸载事件。
        list->RegisterOnDisappear(\[\]() { OH\_LOG\_INFO(LOG\_APP, "on list unmount from tree"); });
        return list;
    }
    } // namespace NativeModule
    
    #endif // MYAPPLICATION\_NORMALTEXTLISTEXAMPLE\_H
    
    由于使用了日志打印接口[OH\_LOG\_Print](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-log-h#oh_log_print)和[OH\_LOG\_INFO](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-log-h#oh_log_info)，需要在CMakeLists.txt中添加对libhilog\_ndk.z.so的引用。
    
    add\_library(entry SHARED napi\_init.cpp NativeEntry.cpp)
    target\_link\_libraries(entry PUBLIC libace\_napi.z.so libace\_ndk.z.so libhilog\_ndk.z.so)
    

#### 监听组件布局和绘制送显事件

从API version 16开始，NDK接口针对UI组件的布局或绘制送显完成，提供了注册与取消监听函数的方式。开发者可使用如下接口监听指定节点布局完成或者绘制送显完成的时机，并注册相应的回调函数。

可使用[OH\_ArkUI\_RegisterLayoutCallbackOnNodeHandle](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_registerlayoutcallbackonnodehandle)注册组件布局完成的回调方法。

可使用[OH\_ArkUI\_RegisterDrawCallbackOnNodeHandle](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_registerdrawcallbackonnodehandle)注册绘制送显完成的回调方法。

可使用[OH\_ArkUI\_UnregisterLayoutCallbackOnNodeHandle](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_unregisterlayoutcallbackonnodehandle)取消组件布局完成的回调方法注册。

可使用[OH\_ArkUI\_UnregisterDrawCallbackOnNodeHandle](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_unregisterdrawcallbackonnodehandle)取消绘制送显完成的回调方法注册。

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/a5/v3/Yl-h7J9FQPqKTo3LAMiMWQ/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260709T132315Z&HW-CC-Expire=86400&HW-CC-Sign=A090B674CBED983A0FBA424EB7DA577099C0A2313A6B51069DF2DED896FA95E1)

[OH\_ArkUI\_RegisterLayoutCallbackOnNodeHandle](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_registerlayoutcallbackonnodehandle)和[OH\_ArkUI\_RegisterDrawCallbackOnNodeHandle](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_registerdrawcallbackonnodehandle)能够监听组件的布局完成或者绘制送显完成事件触发，但只能传递一个函数指针，多次调用使用最后一次的函数指针进行回调。

以下示例基于[接入ArkTS页面](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/ndk-access-the-arkts-page)章节，提供组件布局和绘制送显事件监听的开发指导。

在ArkUITextNode对象中封装上述监听组件布局和绘制送显事件接口的调用方法。

// ArkUITextNode.h
// 实现文本组件的封装类。
#ifndef MYAPPLICATION\_ARKUITEXTNODE\_H
#define MYAPPLICATION\_ARKUITEXTNODE\_H

#include <arkui/native\_type.h>
#include <arkui/native\_node.h>
#include <hilog/log.h>
#include "ArkUINode.h"
#include <string>

// ...
namespace NativeModule {
const unsigned int LOG\_PRINT\_DOMAIN = 0xFF00;
// 布局完成的回调方法
void OnLayoutCompleted(void \*userData)
{
    OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "Callback", "the text\_node is layout completed");
}
// 绘制送显完成的回调方法
void OnDrawCompleted(void \*userData)
{
    OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "Callback", "the text\_node is draw completed");
}
// ...
class ArkUITextNode : public ArkUINode {
public:
    ArkUITextNode()
        : ArkUINode((NativeModuleInstance::GetInstance()->GetNativeNodeAPI())->createNode(ARKUI\_NODE\_TEXT)) {}
    void SetFontSize(float fontSize)
    {
        ArkUI\_NumberValue value\[\] = {{.f32 = fontSize}};
        ArkUI\_AttributeItem item = {value, 1};
        nativeModule\_->setAttribute(handle\_, NODE\_FONT\_SIZE, &item);
    }
    void SetFontColor(uint32\_t color)
    {
        ArkUI\_NumberValue value\[\] = {{.u32 = color}};
        ArkUI\_AttributeItem item = {value, 1};
        nativeModule\_->setAttribute(handle\_, NODE\_FONT\_COLOR, &item);
    }
    void SetTextContent(const std::string &content)
    {
        ArkUI\_AttributeItem item = {nullptr, 0, content.c\_str()};
        nativeModule\_->setAttribute(handle\_, NODE\_TEXT\_CONTENT, &item);
    }
    void SetTextAlign(ArkUI\_TextAlignment align)
    {
        ArkUI\_NumberValue value\[\] = {{.i32 = align}};
        ArkUI\_AttributeItem item = {value, 1};
        nativeModule\_->setAttribute(handle\_, NODE\_TEXT\_ALIGN, &item);
    }
    void SetLayoutCallBack(int32\_t nodeId)
    {
        OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "Callback", "set layout callback");
        // 注册布局完成的回调方法
        OH\_ArkUI\_RegisterLayoutCallbackOnNodeHandle(handle\_, handle\_, OnLayoutCompleted);
    }
    void ResetLayoutCallBack()
    {
        OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "Callback", "reset layout callback");
        // 取消注册布局完成的回调方法
        OH\_ArkUI\_UnregisterLayoutCallbackOnNodeHandle(handle\_);
    }
    void SetDrawCallBack(int32\_t nodeId)
    {
        OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "Callback", "set draw callback");
        // 注册绘制送显完成的回调方法
        OH\_ArkUI\_RegisterDrawCallbackOnNodeHandle(handle\_, handle\_, OnDrawCompleted);
    }
    void ResetDrawCallBack()
    {
        OH\_LOG\_Print(LOG\_APP, LOG\_INFO, LOG\_PRINT\_DOMAIN, "Callback", "reset draw callback");
        // 取消注册绘制送显完成的回调方法
        OH\_ArkUI\_UnregisterDrawCallbackOnNodeHandle(handle\_);
    }
    void SetInspectorId(std::string inspectorId)
    {
        ArkUI\_AttributeItem item = {nullptr, 0, inspectorId.c\_str()};
        nativeModule\_->setAttribute(handle\_, NODE\_ID, &item);
    }
    // ...
};
} // namespace NativeModule

#endif // MYAPPLICATION\_ARKUITEXTNODE\_H

// NormalTextListExample.h
// 自定义接入入口函数

#ifndef MYAPPLICATION\_NORMALTEXTLISTEXAMPLE\_H
#define MYAPPLICATION\_NORMALTEXTLISTEXAMPLE\_H

#include "ArkUIBaseNode.h"
#include "ArkUIListItemNode.h"
#include "ArkUIListNode.h"
#include "ArkUITextNode.h"
#include <hilog/log.h>
#define SIZE\_16 16
#define SIZE\_100 100
#define COLOR\_BACKGROUND 0xFFfffacd

namespace NativeModule {

std::shared\_ptr<ArkUIBaseNode> CreateTextListExample()
{
    // 创建组件并挂载
    // 1：使用智能指针创建List组件。
    auto list = std::make\_shared<ArkUIListNode>();
    list->SetPercentWidth(1);
    list->SetPercentHeight(1);
    // 2：创建ListItem子组件并挂载到List上。
    for (int32\_t i = 0; i < 1; ++i) {
        auto listItem = std::make\_shared<ArkUIListItemNode>();
        auto textNode = std::make\_shared<ArkUITextNode>();
        textNode->SetTextContent(std::to\_string(i));
        textNode->SetFontSize(SIZE\_16);
        textNode->SetPercentWidth(1);
        textNode->SetHeight(SIZE\_100);
        textNode->SetBackgroundColor(COLOR\_BACKGROUND);
        textNode->SetTextAlign(ARKUI\_TEXT\_ALIGNMENT\_CENTER);
        // 在当前节点注册布局回调
        textNode->SetLayoutCallBack(i);
        // 在当前节点注册绘制送显回调
        textNode->SetDrawCallBack(i);
        listItem->AddChild(textNode);
        list->AddChild(listItem);
    }
    return list;
}
} // namespace NativeModule

#endif // MYAPPLICATION\_NORMALTEXTLISTEXAMPLE\_H

#### 监听深浅色变更事件

ArkUI开发框架在NDK接口提供了以组件为注册单位的系统深浅色变更事件。开发者可使用[OH\_ArkUI\_RegisterSystemColorModeChangeEvent](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/capi-native-node-h#oh_arkui_registersystemcolormodechangeevent)注册回调函数，当系统深浅色发生变更时，会通知注册在组件上的回调，从而实现NDK侧的深浅色变更事件监听。

![](https://contentcenter-vali-drcn.dbankcdn.cn/pvt_2/DeveloperAlliance_scene_100_1/2d/v3/TurAeBqARdKpTB_qPxPQqA/note_3.0-zh-cn.png?HW-CC-KV=V1&HW-CC-Date=20260709T132315Z&HW-CC-Expire=86400&HW-CC-Sign=2B52B6C0E47B8395A9CF9112E6D30A4D9683C70D086CD0096EF9E0F9558535A8)

*   一个回调内可以自行设计多个组件的深浅色变更。
    
*   同一组件仅能注册一个系统深浅变更回调。
    
*   建议将注册操作放置于页面生命周期中不会被销毁的节点上，以避免因节点销毁导致回调失效的问题。
    

struct ColorModeInfo {
    const char\* lightMsg;
    const char\* darkMsg;
};

// 注册回调函数
void onColorModeChange(ArkUI\_SystemColorMode colorMode, void \*userData)
{
    ColorModeInfo\* info = static\_cast<ColorModeInfo\*>(userData);
    if (colorMode == ARKUI\_SYSTEM\_COLOR\_MODE\_LIGHT) {
        OH\_LOG\_Print(LOG\_APP, LOG\_ERROR, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                     "NdkAddInteractionEvent\_Light mode: ", info->lightMsg);
    } else if (colorMode == ARKUI\_SYSTEM\_COLOR\_MODE\_DARK) {
        OH\_LOG\_Print(LOG\_APP, LOG\_ERROR, LOG\_PRINT\_DOMAIN, "\[Sample\_NdkAddInteractionEvent\]",
                     "NdkAddInteractionEvent\_Dark mode: ", info->darkMsg);
    }
}

ArkUI\_NodeHandle testColorModeChange(ArkUI\_NativeNodeAPI\_1 \*nodeAPI) {
    ArkUI\_NodeHandle text = nodeAPI->createNode(ARKUI\_NODE\_TEXT);
    static ColorModeInfo info = {"Light mode", "Dark mode"};
    OH\_ArkUI\_RegisterSystemColorModeChangeEvent(text, &info, onColorModeChange);

    ArkUI\_AttributeItem itemstring = {nullptr, 0, ("test\_light\_dark")};
    nodeAPI->setAttribute(text, NODE\_TEXT\_CONTENT, &itemstring);

    return text;
}