鸿蒙5.0开发进阶:使用NDK接口构建UI(嵌入ArkTS组件)

鸿蒙(HarmonyOS)项目方舟框架(ArkUI)之Toast组件 操作系统: Windows 10 专业版、IDE:DevEco Studio 3.1、SDK:HarmonyOS 3.1。的应用场景也非常广泛,比如网络请求出错了可以弹一个。 阅读详情

嵌入ArkTS组件

ArkUI在Native侧提供的能力作为ArkTS的子集,部分能力不会在Native侧提供,如声明式UI语法,自定义struct组件,UI高级组件。

针对需要使用ArkTS侧独立能力的场景,ArkUI开发框架提供了Native侧嵌入ArkTS组件的能力,该能力依赖ComponentContent机制,通过ComponentContent完成对ArkTS组件的封装,然后将封装对象转递到Native侧,通过Native侧的OH_ArkUI_GetNodeHandleFromNapiValue接口转化为ArkUI_NodeHandle对象用于Native侧组件挂载使用。

说明

  • 通过OH_ArkUI_GetNodeHandleFromNapiValue接口获得的ArkUI_NodeHandle对象只能作为子组件参数使用,如addChild接口的第二个参数,将该对象使用在其他场景下,如setAttribute设置属性将不生效并返回错误码。

  • 针对Native侧修改ArkTS组件的场景,需要在Native侧通过Node-API方式构建ArkTS侧的更新数据,再通过ComponentContent的update接口更新。

  • 构建自定义组件时,相关函数如measureNode等无法对ArkTS模块内部的组件进行调用。

以下示例代码在接入ArkTS页面章节基础上引入ArkTS的Refresh组件。

图1 Refresh组件挂载文本列表

  1. 注册ArkTS组件创建函数给Native侧,以便Native侧调用,创建函数使用ComponentContent能力进行封装。

    // MixedModule.ets
    // 使用ComponentContent能力创建ArkTS组件
    
    import { NodeContent,  UIContext, RefreshModifier, ComponentContent } from '@kit.ArkUI';
    
    // 定义Native侧和ArkTS进行交互的数据对象。
    interface NativeRefreshAttribute {
      isRefreshing: boolean;
      width?: number;
      height?: number;
      backgroundColor?: number;
      refreshOffset?: number;
      pullToRefresh?: boolean
      onRefreshing?: () => void;
      onOffsetChange?: (offset: number) => void;
    }
    
    // 定义@Builder函数的入参格式。
    interface RefreshAttribute {
      isRefreshing: boolean;
      // 属性设置通过Modifier优化性能
      modifier?: RefreshModifier;
      slot?: NodeContent;
      onRefreshing?: () => void;
      onOffsetChange?: (offset: number) => void;
    }
    
    // ComponentContent封装ArkTS组件依赖全局@Builder函数,涉及复杂自定义组件场景,可以在@Builder函数中嵌套@Component自定义组件。
    // @Builder函数提供入参方式,方便后续通过ComponentContent的update接口进行参数更新。
    @Builder
    function mixedRefresh(attribute: RefreshAttribute) {
      Refresh({ refreshing: attribute.isRefreshing }) {
        // Refresh作为容器组件,需要使用ContentSlot机制预留子组件占位
        ContentSlot(attribute.slot)
      }.attributeModifier(attribute.modifier)
      .onRefreshing(() => {
        console.info("on onRefreshing");
        if (attribute.onRefreshing) {
          console.info("on native onRefreshing");
          attribute.onRefreshing();
        }
      })
      .onOffsetChange((value: number) => {
        console.info("on offset change: " + value);
        if (attribute.onOffsetChange) {
          console.info("on native onOffsetChange");
          attribute.onOffsetChange(value);
        }
      })
    }
    
    // 定义创建函数的返回值,用于ArkTS侧和Native侧的交互。
    interface MixedModuleResult {
      // 定义针对Refresh构建函数的封装对象,用于Native侧转化为ArkUI_NodeHandle对象。
      content?: ComponentContent<RefreshAttribute>;
      // Refresh作为容器组件,需要使用ContentSlot机制挂载Native侧的子组件。
      childSlot?: NodeContent;
    }
    
    // 提供创建ArkTS组件的入口函数。
    export function createMixedRefresh(value: NativeRefreshAttribute): MixedModuleResult {
      console.info("createMixedRefresh");
      // 通过AppStorage对象在Ability启动的时候保持UI上下文对象。
      let uiContent = AppStorage.get<UIContext>("context");
      let modifier = new RefreshModifier();
      if (value.width) {
        modifier.width(value.width)
      }
      if (value.height) {
        modifier.height(value.height)
      }
      if (value.backgroundColor) {
        modifier.backgroundColor(value.backgroundColor)
      }
      if (value.pullToRefresh) {
        modifier.pullToRefresh(value.pullToRefresh)
      }
      if (value.refreshOffset) {
        modifier.refreshOffset(value.refreshOffset)
      }
      // 创建NodeContent插槽对象用于Refresh子组件挂载。
      let nodeSlot = new NodeContent();
      // 通过ComponentContent创建Refresh组件并将它封装起来。
      let content = new ComponentContent<RefreshAttribute>(uiContent!, wrapBuilder<[RefreshAttribute]>(mixedRefresh),
        {
          isRefreshing: value.isRefreshing,
          modifier: modifier,
          slot: nodeSlot,
          onRefreshing: value.onRefreshing,
          onOffsetChange: value.onOffsetChange
        });
      // 将Refresh组件的封装对象及其子组件插槽对象传递给Native侧。
      return { content: content, childSlot: nodeSlot };
    }
    
    // 定义Refresh组件的更新函数,用于Native侧更新。
    // 在更新场景下,需要将Refresh组件的封装对象及其子组件插槽对象返回,防止组件重新创建。
    export function updateMixedRefresh(refresh: ComponentContent<RefreshAttribute>, childSlot: NodeContent,
      value: NativeRefreshAttribute): void {
      let modifier = new RefreshModifier();
      if (value.width) {
        modifier.width(value.width)
      }
      if (value.height) {
        modifier.height(value.height)
      }
      if (value.backgroundColor) {
        modifier.backgroundColor(value.backgroundColor)
      }
      if (value.pullToRefresh) {
        modifier.pullToRefresh(value.pullToRefresh)
      }
      if (value.refreshOffset) {
        modifier.refreshOffset(value.refreshOffset)
      }
      // 调用ComponentContent的update接口进行更新。
      refresh.update({
        isRefreshing: value.isRefreshing,
        modifier: modifier,
        slot: childSlot,
        onRefreshing: value.onRefreshing,
        onOffsetChange: value.onOffsetChange
      })
    }
  2. 将创建和更新函数注册给Native侧。

    // entry.ets
    import nativeNode from 'libentry.so';
    import { NodeContent } from '@kit.ArkUI';
    import { createMixedRefresh, updateMixedRefresh } from './MixedModule'
    
    @Entry
    @Component
    struct Index {
      private rootSlot = new NodeContent();
      @State @Watch('changeNativeFlag') showNative: boolean = false;
    
      aboutToAppear(): void {
        // 设置uiContext;
        AppStorage.setOrCreate<UIContext>("context", this.getUIContext());
        // 设置混合模式下的builder函数。
        nativeNode.registerCreateMixedRefreshNode(createMixedRefresh);
        nativeNode.registerUpdateMixedRefreshNode(updateMixedRefresh);
      }
    
      changeNativeFlag(): void {
        if (this.showNative) {
          // 创建NativeModule组件挂载
          nativeNode.createNativeRoot(this.rootSlot)
        } else {
          // 销毁NativeModule组件
          nativeNode.destroyNativeRoot()
        }
      }
    
      build() {
        Column() {
          Button(this.showNative ? "HideNativeUI" : "ShowNativeUI").onClick(() => {
            this.showNative = !this.showNative
          })
          Row() {
            // ArkTS插入Native组件。
            ContentSlot(this.rootSlot)
          }.layoutWeight(1)
        }
        .width('100%')
        .height('100%')
      }
    }
    // native_init.cpp
    #include "ArkUIMixedRefresh.h"
    #include "NativeEntry.h"
    #include "napi/native_api.h"
    
    EXTERN_C_START
    static napi_value Init(napi_env env, napi_value exports) {
        napi_property_descriptor desc[] = {
            {"createNativeRoot", nullptr, NativeModule::CreateNativeRoot, nullptr, nullptr, nullptr, napi_default, nullptr},
            // 注册混合模式创建方法。
            {"registerCreateMixedRefreshNode", nullptr, NativeModule::ArkUIMixedRefresh::RegisterCreateRefresh, nullptr,
             nullptr, nullptr, napi_default, nullptr},
            // 注册混合模式更新方法。
            {"registerUpdateMixedRefreshNode", nullptr, NativeModule::ArkUIMixedRefresh::RegisterUpdateRefresh, nullptr,
             nullptr, nullptr, napi_default, nullptr},
            {"destroyNativeRoot", nullptr, NativeModule::DestroyNativeRoot, nullptr, nullptr, nullptr, napi_default,
             nullptr}};
        napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
        return exports;
    }
    EXTERN_C_END
    
    static napi_module demoModule = {
        .nm_version = 1,
        .nm_flags = 0,
        .nm_filename = nullptr,
        .nm_register_func = Init,
        .nm_modname = "entry",
        .nm_priv = ((void *)0),
        .reserved = {0},
    };
    
    extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
  3. Native侧通过Node-API保存创建和更新函数,用于后续调用。

    // ArkUIMixedRefresh.h
    // 混合模式交互类。
    
    #ifndef MYAPPLICATION_ARKUIMIXEDREFRESH_H
    #define MYAPPLICATION_ARKUIMIXEDREFRESH_H
    
    #include "ArkUIMixedNode.h"
    
    #include <optional>
    
    #include <arkui/native_node_napi.h>
    #include <js_native_api_types.h>
    
    namespace NativeModule {
    
    class ArkUIMixedRefresh : public ArkUIMixedNode {
    public:
    static napi_value RegisterCreateRefresh(napi_env env, napi_callback_info info);
    static napi_value RegisterUpdateRefresh(napi_env env, napi_callback_info info);
    };
    
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_ARKUIMIXEDREFRESH_H
    // ArkUIMixedRefresh.cpp
    // 混合模式交互类。
    
    #include "ArkUIMixedRefresh.h"
    #include <hilog/log.h>
    
    namespace NativeModule {
    namespace {
    napi_env g_env;
    napi_ref g_createRefresh;
    napi_ref g_updateRefresh;
    } // namespace
    
    napi_value ArkUIMixedRefresh::RegisterCreateRefresh(napi_env env, napi_callback_info info) {
        size_t argc = 1;
        napi_value args[1] = {nullptr};
    
        napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    
        g_env = env;
        napi_ref refer;
        // 创建引用之后保存,防止释放。
        napi_create_reference(env, args[0], 1, &refer);
    
        g_createRefresh = refer;
        return nullptr;
    }
    
    napi_value ArkUIMixedRefresh::RegisterUpdateRefresh(napi_env env, napi_callback_info info) {
        size_t argc = 1;
        napi_value args[1] = {nullptr};
    
        napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    
        g_env = env;
        napi_ref refer;
        // 创建引用之后保存,防止释放。
        napi_create_reference(env, args[0], 1, &refer);
    
        g_updateRefresh = refer;
        return nullptr;
    }
    
    } // namespace NativeModule
  4. 抽象混合模式下组件的基类,用于通用逻辑管理。

    // ArkUIMixedNode.h
    // 混合模式基类。
    
    #ifndef MYAPPLICATION_ARKUIMIXEDNODE_H
    #define MYAPPLICATION_ARKUIMIXEDNODE_H
    
    #include <js_native_api.h>
    #include <js_native_api_types.h>
    
    #include "ArkUIBaseNode.h"
    #include "NativeModule.h"
    
    namespace NativeModule {
    
    // Wrap ArkTS Node
    class ArkUIMixedNode : public ArkUIBaseNode {
    public:
        ArkUIMixedNode(ArkUI_NodeHandle handle, napi_env env, napi_ref componentContent)
            : ArkUIBaseNode(handle), env_(env), componentContent_(componentContent) {}
    
        // 在基类析构的时候需要把混合模式在ArkTS侧的对象释放掉。
        ~ArkUIMixedNode() override { napi_delete_reference(env_, componentContent_); }
    
    protected:
        napi_env env_;
        napi_ref componentContent_;
    };
    
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_ARKUIMIXEDNODE_H
  5. 实现Refresh组件的混合模式封装对象。

    // ArkUIMixedRefresh.h
    // Refresh混合模式在Native侧的封装对象。
    
    #ifndef MYAPPLICATION_ARKUIMIXEDREFRESH_H
    #define MYAPPLICATION_ARKUIMIXEDREFRESH_H
    
    #include "ArkUIMixedNode.h"
    #include "ArkUIBaseNode.h"
    
    #include <optional>
    
    #include <arkui/native_node_napi.h>
    #include <js_native_api_types.h>
    
    namespace NativeModule {
    
    // 定义Native侧和ArkTS侧的交互数据结构。
    struct NativeRefreshAttribute {
        std::optional<bool> isRefreshing;
        std::optional<float> width;
        std::optional<float> height;
        std::optional<uint32_t> backgroundColor;
        std::optional<float> refreshOffset;
        std::optional<bool> pullToRefresh;
        std::function<void()> onRefreshing;
        std::function<void(float)> onOffsetChange;
    };
    
    class ArkUIMixedRefresh : public ArkUIMixedNode {
    public:
        // 调用ArkTS的方法创建Refresh组件。
        static const std::shared_ptr<ArkUIMixedRefresh> Create(const NativeRefreshAttribute &attribute);
    
        ArkUIMixedRefresh(ArkUI_NodeHandle handle, ArkUI_NodeContentHandle contentHandle, napi_env env,
                          napi_ref componentContent, napi_ref nodeContent)
            : ArkUIMixedNode(handle, env, componentContent), contentHandle_(contentHandle), nodeContent_(nodeContent) {}
    
        ArkUIMixedRefresh() : ArkUIMixedNode(nullptr, nullptr, nullptr) {}
    
        ~ArkUIMixedRefresh() override { napi_delete_reference(env_, nodeContent_); } // 释放子节点占位组件插槽对象。
    
        void SetWidth(float width) { attribute_.width = width; }
    
        void SetHeight(float height) { attribute_.height = height; }
    
        void SetBackgroundColor(uint32_t color) { attribute_.backgroundColor = color; }
    
        void SetRefreshState(bool isRefreshing) { attribute_.isRefreshing = isRefreshing; }
    
        void SetPullToRefresh(bool pullToRefresh) { attribute_.pullToRefresh = pullToRefresh; }
    
        void SetRefreshOffset(float offset) { attribute_.refreshOffset = offset; }
    
        void SetRefreshCallback(const std::function<void()> &callback) { attribute_.onRefreshing = callback; }
    
        void SetOnOffsetChange(const std::function<void(float)> &callback) { attribute_.onOffsetChange = callback; }
    
        // 避免频繁跨语言,在Native侧缓存属性事件,批量通知。
        void FlushMixedModeCmd();
    
        static napi_value RegisterCreateRefresh(napi_env env, napi_callback_info info);
        static napi_value RegisterUpdateRefresh(napi_env env, napi_callback_info info);
    
    protected:
        void OnAddChild(const std::shared_ptr<ArkUIBaseNode> &child) override {
            assert(contentHandle_);
            // 使用NodeContent挂载组件(可以使用ArkTS在Native侧通过ComponentContent的转化对象,也可以是纯Native组件)到ArkTS组件下面。
            OH_ArkUI_NodeContent_AddNode(contentHandle_, child->GetHandle());
        }
    
        void OnRemoveChild(const std::shared_ptr<ArkUIBaseNode> &child) override {
            assert(contentHandle_);
            // 使用NodeContent卸载组件。
            OH_ArkUI_NodeContent_RemoveNode(contentHandle_, child->GetHandle());
        }
    
        void OnInsertChild(const std::shared_ptr<ArkUIBaseNode> &child, int32_t index) override {
            assert(contentHandle_);
            // 使用NodeContent插入组件。
            OH_ArkUI_NodeContent_InsertNode(contentHandle_, child->GetHandle(), index);
        }
    
    private:
        // 使用napi接口创建ArkTS侧的数据结构。
        static napi_value CreateRefreshAttribute(const NativeRefreshAttribute &attribute, void *userData);
    
        ArkUI_NodeContentHandle contentHandle_;
        napi_ref nodeContent_;
        NativeRefreshAttribute attribute_;
    };
    
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_ARKUIMIXEDREFRESH_H

    相关实现类说明:

    #include "ArkUIMixedRefresh.h"
    #include <hilog/log.h>
    
    namespace NativeModule {
    namespace {
    napi_env g_env;
    napi_ref g_createRefresh;
    napi_ref g_updateRefresh;
    } // namespace
    
    // 使用Napi接口创建与ArkTS侧交互的数据结构,用于Refresh组件的创建和更新。
    napi_value ArkUIMixedRefresh::CreateRefreshAttribute(const NativeRefreshAttribute &attribute, void *userData) {
        napi_property_descriptor desc[] = {
            {"width", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"height", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"backgroundColor", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"pullToRefresh", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"isRefreshing", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"refreshOffset", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"onRefreshing", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
            {"onOffsetChange", nullptr, nullptr, nullptr, nullptr, nullptr, napi_default, userData},
        };
        if (attribute.width) {
            napi_value width;
            napi_create_double(g_env, attribute.width.value(), &width);
            desc[0].value = width;
        }
        if (attribute.height) {
            napi_value height;
            napi_create_double(g_env, attribute.height.value(), &height);
            desc[1].value = height;
        }
        if (attribute.backgroundColor) {
            napi_value backgroundColor;
            napi_create_uint32(g_env, attribute.backgroundColor.value(), &backgroundColor);
            desc[2].value = backgroundColor;
        }
        if (attribute.pullToRefresh) {
            napi_value pullToRefresh;
            napi_create_int32(g_env, attribute.pullToRefresh.value(), &pullToRefresh);
            desc[3].value = pullToRefresh;
        }
        if (attribute.isRefreshing) {
            napi_value isRefreshing;
            napi_create_int32(g_env, attribute.isRefreshing.value(), &isRefreshing);
            desc[4].value = isRefreshing;
        }
        if (attribute.refreshOffset) {
            napi_value refreshOffset;
            napi_create_double(g_env, attribute.refreshOffset.value(), &refreshOffset);
            desc[5].value = refreshOffset;
        }
        if (attribute.onRefreshing) {
            OH_LOG_INFO(LOG_APP, "onRefreshing start");
            desc[6].method = [](napi_env env, napi_callback_info info) -> napi_value {
                OH_LOG_INFO(LOG_APP, "onRefreshing callback");
                size_t argc = 0;
                napi_value args[0];
                void *data;
                napi_get_cb_info(env, info, &argc, args, nullptr, &data);
                auto refresh = reinterpret_cast<ArkUIMixedRefresh *>(data);
                if (refresh && refresh->attribute_.onRefreshing) {
                    refresh->attribute_.onRefreshing();
                }
                return nullptr;
            };
        }
        if (attribute.onOffsetChange) {
            OH_LOG_INFO(LOG_APP, "onOffsetChange start");
            desc[7].method = [](napi_env env, napi_callback_info info) -> napi_value {
                OH_LOG_INFO(LOG_APP, "onOffsetChange callback");
                size_t argc = 1;
                napi_value args[1] = {nullptr};
                void *data;
                napi_get_cb_info(env, info, &argc, args, nullptr, &data);
                double offset = 0.0;
                napi_get_value_double(env, args[0], &offset);
                auto refresh = reinterpret_cast<ArkUIMixedRefresh *>(data);
                if (refresh && refresh->attribute_.onOffsetChange) {
                    refresh->attribute_.onOffsetChange(offset);
                }
                return nullptr;
            };
        }
        napi_value refreshAttribute = nullptr;
        auto result = napi_create_object_with_properties(g_env, &refreshAttribute, sizeof(desc) / sizeof(desc[0]), desc);
        if (result != napi_ok) {
            return nullptr;
        }
        return refreshAttribute;
    }
    
    // 创建ArkTS侧的组件并保存在Native侧的封装对象中。
    const std::shared_ptr<ArkUIMixedRefresh> ArkUIMixedRefresh::Create(const NativeRefreshAttribute &attribute) {
        napi_handle_scope scope;
        napi_open_handle_scope(g_env, &scope);
        auto refresh = std::make_shared<ArkUIMixedRefresh>();
        auto refreshAttribute = CreateRefreshAttribute(attribute, refresh.get());
        if (refreshAttribute == nullptr) {
            napi_close_handle_scope(g_env, scope);
            return nullptr;
        }
        napi_value result = nullptr;
        napi_value argv[1] = {refreshAttribute};
        napi_value createRefresh = nullptr;
        napi_get_reference_value(g_env, g_createRefresh, &createRefresh);
        // 调用ArkTS的Create函数创建ArkTS的ComponentContent。
        napi_call_function(g_env, nullptr, createRefresh, 1, argv, &result);
    
        // 获取ArkTS的Refresh组件。
        napi_value componentContent = nullptr;
        napi_get_named_property(g_env, result, "content", &componentContent);
        ArkUI_NodeHandle handle;
        OH_ArkUI_GetNodeHandleFromNapiValue(g_env, componentContent, &handle);
        assert(handle);
        // 获取ArkTS的Refresh组件的子组件插槽。
        napi_value nodeContent = nullptr;
        napi_get_named_property(g_env, result, "childSlot", &nodeContent);
        ArkUI_NodeContentHandle contentHandle;
        OH_ArkUI_GetNodeContentFromNapiValue(g_env, nodeContent, &contentHandle);
        assert(contentHandle);
        // 保存ArkTS的ComponentContent用于防止ArkTS侧对象释放以及后续的更新。
        napi_ref componentContentRef;
        napi_create_reference(g_env, componentContent, 1, &componentContentRef);
        // 保存ArkTS的NodeContent用于防止ArkTS侧对象释放以及后续的更新。
        napi_ref nodeContentRef;
        napi_create_reference(g_env, nodeContent, 1, &nodeContentRef);
        // 更新Refresh组件相关参数。
        refresh->handle_ = handle;
        refresh->env_ = g_env;
        refresh->componentContent_ = componentContentRef;
        refresh->nodeContent_ = nodeContentRef;
        refresh->contentHandle_ = contentHandle;
        refresh->attribute_ = attribute;
        return refresh;
    }
    // 更新函数实现。
    void ArkUIMixedRefresh::FlushMixedModeCmd() {
        napi_handle_scope scope;
        napi_open_handle_scope(g_env, &scope);
        // 创建调用ArkTS接口入参。
        auto refreshAttribute = CreateRefreshAttribute(attribute_, this);
        if (refreshAttribute == nullptr) {
            napi_close_handle_scope(g_env, scope);
            return;
        }
        // 获取更新接口的剩余两个接口参数。
        napi_value componentContent = nullptr;
        napi_get_reference_value(g_env, componentContent_, &componentContent);
        napi_value nodeContent = nullptr;
        napi_get_reference_value(g_env, nodeContent_, &nodeContent);
    
        napi_value argv[3] = {componentContent, nodeContent, refreshAttribute};
        napi_value updateRefresh = nullptr;
        napi_get_reference_value(g_env, g_updateRefresh, &updateRefresh);
        // 调用ArkTS的Update函数进行更新。
        napi_value result = nullptr;
        napi_call_function(g_env, nullptr, updateRefresh, 3, argv, &result);
    }
    
    napi_value ArkUIMixedRefresh::RegisterCreateRefresh(napi_env env, napi_callback_info info) {
        size_t argc = 1;
        napi_value args[1] = {nullptr};
    
        napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    
        g_env = env;
        napi_ref refer;
        napi_create_reference(env, args[0], 1, &refer);
    
        g_createRefresh = refer;
        return nullptr;
    }
    
    napi_value ArkUIMixedRefresh::RegisterUpdateRefresh(napi_env env, napi_callback_info info) {
        size_t argc = 1;
        napi_value args[1] = {nullptr};
    
        napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    
        g_env = env;
        napi_ref refer;
        napi_create_reference(env, args[0], 1, &refer);
    
        g_updateRefresh = refer;
        return nullptr;
    }
    
    } // namespace NativeModule
  6. 使用接入ArkTS页面章节的页面结构,并沿用定时器模块相关简单实现,将Refresh组件作为文本列表的父组件。

    // MixedRefreshExample.h
    // 混合模式示例代码。
    
    #ifndef MYAPPLICATION_MIXEDREFRESHEXAMPLE_H
    #define MYAPPLICATION_MIXEDREFRESHEXAMPLE_H
    
    #include "ArkUIBaseNode.h"
    #include "ArkUIMixedRefresh.h"
    #include "TextListExample.h"
    #include "UITimer.h"
    
    #include <js_native_api_types.h>
    
    namespace NativeModule {
    
    std::shared_ptr<ArkUIBaseNode> CreateMixedRefreshList(napi_env env) {
    auto list = CreateTextListExample();
    // 混合模式创建Refresh组件并挂载List组件。
    NativeRefreshAttribute nativeRefreshAttribute{
    .backgroundColor = 0xFF89CFF0, .refreshOffset = 64, .pullToRefresh = true};
    auto refresh = ArkUIMixedRefresh::Create(nativeRefreshAttribute);
    refresh->AddChild(list);
    
    // 设置混合模式下的事件。
    refresh->SetOnOffsetChange(
    [](float offset) { OH_LOG_INFO(LOG_APP, "on refresh offset changed: %{public}f", offset); });
    refresh->SetRefreshCallback([refreshPtr = refresh.get(), env]() {
    OH_LOG_INFO(LOG_APP, "on refreshing");
    // 启动定时器,模拟数据获取。
    CreateNativeTimer(env, refreshPtr, 1, [](void *userData, int32_t count) {
    // 数据获取后关闭刷新。
    auto refresh = reinterpret_cast<ArkUIMixedRefresh *>(userData);
    refresh->SetRefreshState(false);
    refresh->FlushMixedModeCmd();
    });
    });
    
    // 更新事件到ArkTS侧。
    refresh->FlushMixedModeCmd();
    return refresh;
    }
    
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_MIXEDREFRESHEXAMPLE_H

    替换入口组件创建为下拉刷新文本列表。

    #include "NativeEntry.h"
    
    #include "ArkUIMixedRefresh.h"
    #include "MixedRefreshExample.h"
    #include "TextListExample.h"
    
    #include <arkui/native_node_napi.h>
    #include <arkui/native_type.h>
    #include <js_native_api.h>
    #include <uv.h>
    
    namespace NativeModule {
    
    napi_value CreateNativeRoot(napi_env env, napi_callback_info info) {
        size_t argc = 1;
        napi_value args[1] = {nullptr};
    
        napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    
        // 获取NodeContent
        ArkUI_NodeContentHandle contentHandle;
        OH_ArkUI_GetNodeContentFromNapiValue(env, args[0], &contentHandle);
        NativeEntry::GetInstance()->SetContentHandle(contentHandle);
    
        // 创建Refresh文本列表
        auto refresh = CreateMixedRefreshList(env);
    
        // 保持Native侧对象到管理类中,维护生命周期。
        NativeEntry::GetInstance()->SetRootNode(refresh);
        return nullptr;
    }
    
    napi_value DestroyNativeRoot(napi_env env, napi_callback_info info) {
        // 从管理类中释放Native侧对象。
        NativeEntry::GetInstance()->DisposeRootNode();
        return nullptr;
    }
    
    } // namespace NativeModule

HarmonyOS Next开发学习手册——使用NDK接口构建UI(嵌入ArkTS组件) ArkUI在Native侧提供的能力作为ArkTS的子集,部分能力不会在Native侧提供,如声明式UI语法,自定义struct组件,UI高级组件。 阅读详情

相关推荐

【鸿蒙开发】鸿蒙ArkUI自定义组件如何封装一个好用的Toast/Loading/ProgressHUD组件

先上成果:xt_hud 是我基于 ArkUI 框架封装的三方组件,适配 API11,具体的 API 符合原生开发使用习惯。●Demo:●具体 API 使用介绍:好用的Toast/Loading/Progress自定义组件XTHUDHUD 这类组件,不同于 Button/Text 等常规的 ArkUI 组件,直接在对应父组件的构造函数 build() 中挂载、布局、交互即可,更多的情况是直接用在逻辑代码中。

HarmonyOS_001的博客 2395

鸿蒙HarmonyOS应用开发之在非ArkTS线程中回调ArkTS接口

ArkTS是单线程语言,通过NAPI接口对ArkTS对象的所有操作都须保证在同一个ArkTS线程上进行。本示例将介绍通过和实现在非ArkTS线程中通过NAPI接口回调ArkTS函数。

maniuT的博客 1189

HarmonyOS核心知识点:使用NDK接口构建UI(接入ArkTS页面)

ArkUI开发框架提供了一系列NDK接口,能够在应用中使用C和C++代码构建UI界面,这些接口包括UI组件创建、UI树操作、属性设置和事件监听等。面向通用UI界面开发场景,建议使用ArkTS代码和ArkUI声明式开发框架。需要使用UI组件树控制接口来动态创建和挂载UI组件,方便实现自身UI开发框架的系统桥接。进一步提升UI界面性能,细粒度控制组件的创建和属性设置,以降低延迟、处理极高UI负载。重复使用自己或其他开发者的C或C++UI库。布局布局是UI的必要元素,定义了组件在界面中的大小位置。

wuliusan5的博客 900

鸿蒙5.0开发实战案例:使用NDK接口构建UI(接入ArkTS页面)

ArkUI开发框架提供了一系列NDK接口,能够在应用中使用C和C++代码构建UI界面,这些接口包括UI组件创建、UI树操作、属性设置和事件监听等。面向通用UI界面开发场景,建议使用ArkTS代码和ArkUI声明式开发框架。需要使用UI组件树控制接口来动态创建和挂载UI组件,方便实现自身UI开发框架的系统桥接。进一步提升UI界面性能,细粒度控制组件的创建和属性设置,以降低延迟、处理极高UI负载。重复使用自己或其他开发者的C或C++UI库。布局布局是UI的必要元素,定义了组件在界面中的大小位置。

liudiaosi6的博客 1360

HarmonyOS核心知识点:使用NDK接口构建UI(嵌入ArkTS组件)

针对需要使用ArkTS侧独立能力的场景,ArkUI开发框架提供了Native侧嵌入ArkTS组件的能力,该能力依赖 ComponentContent 机制,通过ComponentContent完成对ArkTS组件的封装,然后将封装对象转递到Native侧,通过Native侧的 OH_ArkUI_GetNodeHandleFromNapiValue 接口转化为ArkUI_NodeHandle对象用于Native侧组件挂载使用。以下示例代码在 接入ArkTS页面 章节基础上引入ArkTS的Refresh组件。

wuliusan5的博客 839

【鸿蒙实战开发】ArkUI-浅谈NDK接口概述

ArkUI开发框架提供了一系列NDK接口,能够在应用中使用C和C++代码构建UI界面,这些接口包括UI组件创建、UI树操作、属性设置和事件监听等。面向通用UI界面开发场景,建议使用ArkTS代码和ArkUI声明式开发框架。然而,如果需要实现以下一个或多个目标,那么ArkUI NDK接口就能派上用场:

HarmonyOS007的博客 1200

鸿蒙5.0开发实战案例:使用NDK接口构建UI(嵌入ArkTS组件)

针对需要使用ArkTS侧独立能力的场景,ArkUI开发框架提供了Native侧嵌入ArkTS组件的能力,该能力依赖 ComponentContent 机制,通过ComponentContent完成对ArkTS组件的封装,然后将封装对象转递到Native侧,通过Native侧的 OH_ArkUI_GetNodeHandleFromNapiValue 接口转化为ArkUI_NodeHandle对象用于Native侧组件挂载使用。以下示例代码在 接入ArkTS页面 章节基础上引入ArkTS的Refresh组件。

liudiaosi6的博客 834

HarmonyOS核心知识点:使用NDK接口构建UI(使用懒加载开发长列表界面)

针对List、Grid、WaterFlow、Swiper组件,提供 NodeAdapter 对象替代ArkTS侧的LazyForEach功能,用于按需生成子组件,其中List组件的属性枚举值为NODE_LIST_NODE_ADAPTER,Grid组件的属性枚举值为NODE_GRID_NODE_ADAPTER,WaterFlow组件的属性枚举值为NODE_WATER_FLOW_NODE_ADAPTER,Swiper组件的属性枚举值为NODE_SWIPER_NODE_ADAPTER。懒加载适配器相关功能实现。

wuliusan5的博客 1054

鸿蒙5.0开发实战案例:使用NDK接口构建UI(使用动画)

组件内转场通过NODE_XX_TRANSITION属性(XX包括:OPACITY、TRANSLATE、SCALE、ROTATE、MOVE)配置转场参数,在组件插入和删除时显示过渡动效(通过NODE_TRANSFORM_CENTER属性设置NODE_SCALE_TRANSITION和NODE_ROTATE_ROTATE动效的中心点坐标)。同时,可以通过Node-API桥接ArkTS侧帧动画能力,实现Native侧的动画效果。同属性动画,布局类改变宽高的动画,内容都是直接到终点状态。

liudiaosi6的博客 641

【鸿蒙南向开发】Native API应用开发 之 使用NDK接口构建UI

【背景】 目前,OpenHarmony/HarmonyOS Next的主要UI开源三方库,如lottie,imageknife,pulltorefresh都是使用arkts自定义组件开发的。但越来越多应用除了功能对功能的要求外,现在也开始提出性能的要求。所以被迫得提前研究下使用NDK接口构建开源三方库。

HarmonyOS_666的博客 639

HarmonyOS鸿蒙开发指南:UI开发 基于ArkTS的声明式开发范式 声明式UI开发实例 页面布局与连接

新建自定义组件PageTitle,包含后退的图标和Food Detail的文本,调用路由的router.back()接口,弹出路由栈最上面的页面,即返回上一级页面。我们已经完成了FoodCategoryList页面和FoodDetail页面的跳转和回退,但是点击不同的FoodListItem/FoodGridItem,跳转的FoodDetail页面都是西红柿Tomato的详细介绍,这是因为没有构建起两个页面的数据传递,需要用到携带参数(parameter)路由。重构FoodDetail页面的组件。

斌擎科技 1877

鸿蒙5.0开发实战案例:使用NDK接口构建UI(使用懒加载开发长列表界面)

针对List、Grid、WaterFlow、Swiper组件,提供 NodeAdapter 对象替代ArkTS侧的LazyForEach功能,用于按需生成子组件,其中List组件的属性枚举值为NODE_LIST_NODE_ADAPTER,Grid组件的属性枚举值为NODE_GRID_NODE_ADAPTER,WaterFlow组件的属性枚举值为NODE_WATER_FLOW_NODE_ADAPTER,Swiper组件的属性枚举值为NODE_SWIPER_NODE_ADAPTER。懒加载适配器相关功能实现。

liudiaosi6的博客 634

IFRS 9与CECL对比解析:跨国企业财务必须掌握的两种信用损失模型

本文深度解析IFRS 9与CECL两种信用损失模型的差异,帮助跨国企业应对财务合规挑战。从基础架构、数据治理到监管策略,详细对比三阶段模型与单一阶段模型的核心区别,并提供实施双轨制的实务建议,助力企业优化资本管理和税务筹划。

3c4x5z6v7b的博客 670

HarmonyOS核心知识点:使用NDK接口构建UI(使用动画)

组件内转场通过NODE_XX_TRANSITION属性(XX包括:OPACITY、TRANSLATE、SCALE、ROTATE、MOVE)配置转场参数,在组件插入和删除时显示过渡动效(通过NODE_TRANSFORM_CENTER属性设置NODE_SCALE_TRANSITION和NODE_ROTATE_ROTATE动效的中心点坐标)。同时,可以通过Node-API桥接ArkTS侧帧动画能力,实现Native侧的动画效果。同属性动画,布局类改变宽高的动画,内容都是直接到终点状态。

wuliusan5的博客 684

基于Qwen3-14B大模型的智能UI自动化测试实践

UI自动化测试是软件工程中保障产品质量的关键环节,其核心原理是通过脚本模拟用户操作,对软件界面进行功能验证。传统方法依赖于编写和维护基于元素定位的固定规则脚本,在面对复杂交互或频繁变化的界面时,维护成本高昂。大语言模型(LLM)的出现为这一领域带来了新的技术价值,其强大的自然语言理解和代码生成能力,使得测试脚本的编写从精确编码转向了任务描述。通过将大模型作为决策大脑,结合Playwright等自动化工具作为执行器,可以构建出能够理解界面、规划操作并验证结果的智能测试系统。这种方案特别适用于处理变化频繁、逻辑

weixin_42619742的博客 304

SRAM compiler中Power Gating与Retention的实战配置指南

本文深入解析了在SRAM compiler中配置Power Gating(电源门控)与Retention(数据保持)功能的实战指南。针对低功耗芯片设计,文章详细阐述了如何根据应用场景(如移动AP、IoT设备)权衡开关类型、尺寸、唤醒时序以及保持电压,以实现静态功耗优化与数据可靠性的最佳平衡,并强调了后端实现与签核检查的关键要点。

weixin_29204121的博客 296

鸿蒙5.0开发实战案例:使用NDK接口构建UI(添加交互事件)

NDK接口针对UI组件的事件,提供了监听函数的方式。首先,可使用 addNodeEventReceiver 函数添加组件事件的监听器,该监听器会监听该组件上发生的所有事件,例如:点击事件、焦点事件。然后,可使用 registerNodeEvent 函数声明组件的哪些事件需要监听,NDK接口支持的事件范围通过 ArkUI_NodeEventType 枚举值定义。以下示例基于 接入ArkTS页面 章节,补充相关事件监听。

liudiaosi6的博客 524

Ubuntu 22.04下GNU Radio 3.10全家桶编译避坑实录:从UHD、VOLK到WiFi收发模块gr-ieee802-11

本文详细介绍了在Ubuntu 22.04系统下编译安装GNU Radio 3.10全家桶的完整流程,包括UHD驱动、VOLK优化库以及WiFi信号处理模块gr-ieee802-11的集成。通过逐步指导解决版本兼容性和依赖问题,帮助研究人员快速搭建高效的软件定义无线电开发环境,特别适合使用USRP设备进行无线通信研究的开发者。

weixin_30825199的博客 447

鸿蒙5.0开发实战案例:使用NDK接口构建UI(构建弹窗)

ArkUI_NativeDialogHandle表示指向弹窗控制器的指针,可以通过调用ArkUI_NativeDialogAPI_x 的create接口创建一个弹窗控制器,弹窗接口集合定义在结构体里,命名为ArkUI_NativeDialogAPI_x (x表示版本),这些接口围绕弹窗控制器实现各种弹窗控制。当不再需要弹窗操作时,需要主动调用dispose接口销毁弹窗控制器对象。通过弹窗控制器显示自定义弹窗,可以设置自定义弹窗的样式和内容。可创建交互页面,打开或关闭弹窗。

liudiaosi6的博客 447

【Google Play 上架】内部 / 封闭 / 开放 测试全解 — “只跑一个就能上架”?不行!

Google Play新规要求个人开发者账号在2023年11月13日后必须通过封闭测试(Closed testing)才能上架应用。封闭测试需要至少12名测试者连续14天保持参与状态,而内部测试和开放测试不能替代这一要求。三类测试轨道各有特点:内部测试用于快速内部验证,封闭测试是上架必经环节,开放测试面向更广泛用户但非必需。上架流程建议先内部测试修复问题,再启动封闭测试满足14天要求,最后申请生产发布。组织账号和早期个人账号可能不受此限制。开发者应提前规划测试人群,确保持续测试周期,并关注Play Cons

技术小甜甜:传播可落地技术,帮助个人和企业降低解决真实场景问题的成本 2802

阅文集团大数据面试题及参考答案

在 Flink 中,watermark 是一种用于处理乱序事件时间的机制。实现接口:通常需要实现 AssignerWithPeriodicWatermarks 或 AssignerWithPunctuatedWatermarks 接口。前者会周期性地生成 watermark,后者则是基于某些特定事件来生成 watermark ,比如接收到某个特定值的消息时。定义位置:可以在数据源处或者在流处理的中间操作中定义 watermark。在数据源定义时,能更精准地根据数据的产生特性设置 watermark;

大模型大数据攻城狮的专栏 1090

鸿蒙5.0开发实战案例:Native XComponent 组件解析~

Native XComponent是XComponent组件提供在Native层的实例,可作为JS层和Native层XComponent绑定的桥梁。XComponent所提供的NDK接口都依赖于该实例。接口能力包括获取Native Window实例、获取XComponent的布局/事件信息、注册XComponent的生命周期回调、注册XComponent的触摸、鼠标、按键等事件回调。利用Native XComponent提供的接口注册XComponent的生命周期和事件回调。

liudiaosi6的博客 1238

【Arduino 动手做】构建一个迷你 Las Vegas RGB LED 球体

《Arduino迷你拉斯维加斯球体项目:15岁少年的创意挑战》 15岁的Ben通过本项目展示了如何利用Arduino平台制作一个经济实惠的迷你拉斯维加斯球体夜灯。该项目涉及LED选择(采用WS2812B可编程灯带)、电子元件配置(含Arduino Nano微控制器和红外遥控)以及3D建模设计(100毫米直径球体)。项目难点包括LED布局优化、供电方案设计和3D打印外壳制作。Ben详细记录了从背景研究、电路设计到最终实现的完整过程,特别强调了分辨率与成本的平衡,以及如何通过白色扩散器改善视觉效果。这个项目不仅

雕爷学编程 1024

从零打造鸿蒙原生 Python IDE:ArkTS + N-API + PTY + CPython 全链路解析

鸿蒙原生Python IDE技术解析 项目概述 鸿蟒工坊(HongMian Workshop)是一款运行在HarmonyOS PC上的Python集成开发环境,填补了鸿蒙PC生态的开发工具空白。项目将Thonny IDE的核心功能移植到鸿蒙平台,提供代码编辑、Shell交互和完整CPython解释器支持。 技术架构 UI层:基于ArkTS/ArkUI实现编辑器界面 桥接层:使用C++/N-API实现JS与C++的通信 运行时层:嵌入CPython 3.12解释器 系统层:利用HarmonyOS内核

一键难忘的博客 3万+

国家自然基金研究方向选定后,关键词只能下拉吗?——不是的,国家自然科学基金(NSFC)的关键词并不是只能下拉选择,而是:[特殊字符] “可选 + 可填”的混合模式(但以规范词为主)

你可以手动输入关键词用于表达新兴方向或细分领域✔ 适用情况:新概念(如“电场调控纳米流体”)交叉领域(如“电流体力学传热耦合”)电场调控电流体力学可以自己填,但必须以系统标准关键词为主,自定义为辅如果你愿意,我可以帮你做一件更关键的事:👉根据你题目,反向设计“最容易中标”的关键词组合 + 学科代码搭配这个比写内容本身还更影响送审质量。你可以手动输入关键词用于表达新兴方向或细分领域✔ 适用情况:新概念(如“电场调控纳米流体”)交叉领域(如“电流体力学传热耦合”)电场调控电流体力学。

qq_15963745的博客 82

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

鸿蒙开发语言选择指南:ArkTS、Java与C++的应用场景解析

在移动应用开发领域,编程语言的选择直接影响开发效率、应用性能和生态适配。从技术原理看,不同语言在类型系统、运行时机制和内存管理上各有特点,这决定了它们在不同场景下的技术价值。TypeScript以其静态类型检查提升了代码可靠性,而Java凭借成熟的虚拟机生态在系统服务层保持优势,C/C++则在驱动开发和性能敏感场景中不可替代。在鸿蒙应用开发中,ArkTS作为TypeScript的超集,深度融合了声明式UI范式,为现代化应用开发提供了高效解决方案;Java主要服务于存量Android应用迁移和系统级开发;C/

weixin_30700977的博客 380

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

上一篇: 鸿蒙5.0开发进阶:使用NDK接口构建UI(构建自定义组件)
下一篇: 鸿蒙5.0开发进阶:ArkTS语言状态管理详解
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值