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

HarmonyOS Next开发学习手册——使用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。 阅读详情

往期鸿蒙全套实战文章必看:


使用懒加载开发长列表界面

针对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。

虽然都用于按需生成组件,但不同于ArkTS的LazyForEach,NodeAdapter对象的规格如下:

  • 设置了NodeAdapter属性的节点,不再支持addChild等直接添加子组件的接口。子组件完全由NodeAdapter管理,使用属性方法设置NodeAdapter时,会判断父组件是否已经存在子节点,如果父组件已经存在子节点,则设置NodeAdapter操作失败,返回错误码。

  • NodeApdater通过相关事件通知开发者按需生成组件,类似组件事件机制,开发者使用NodeAdapter时要注册事件监听器,在监听器事件中处理逻辑,相关事件通过ArkUI_NodeAdapterEventType定义。另外NodeAdapter不会主动释放不在屏幕内显示的组件对象,开发者需要在NODE_ADAPTER_EVENT_ON_REMOVE_NODE_FROM_ADAPTER事件中进行组件对象的释放,或者进行缓存复用。下图展示了典型列表滑动场景下的事件触发机制:

以下示例代码针对接入ArkTS页面章节代码进行优化,引入懒加载机制实现文本列表:

  1. 接入ArkTS。

  2. 懒加载适配器相关功能实现。

    // ArkUIListItemAdapter
    // 用于文本列表懒加载功能代码。
    
    #ifndef MYAPPLICATION_ARKUILISTITEMADAPTER_H
    #define MYAPPLICATION_ARKUILISTITEMADAPTER_H
    
    #include <arkui/native_node.h>
    #include <stack>
    #include <string>
    #include <unordered_set>
    
    #include "ArkUIListItemNode.h"
    #include "ArkUITextNode.h"
    #include "nativeModule.h"
    
    namespace NativeModule {
    
    class ArkUIListItemAdapter {
    public:
        ArkUIListItemAdapter()
            : module_(NativeModuleInstance::GetInstance()->GetNativeNodeAPI()), handle_(OH_ArkUI_NodeAdapter_Create()) { // 使用NodeAdapter创建函数。
            // 初始化懒加载数据。
            for (int32_t i = 0; i < 1000; i++) {
                data_.emplace_back(std::to_string(i));
            }
            // 设置懒加载数据。
            OH_ArkUI_NodeAdapter_SetTotalNodeCount(handle_, data_.size());
            // 设置懒加载回调事件。
            OH_ArkUI_NodeAdapter_RegisterEventReceiver(handle_, this, OnStaticAdapterEvent);
        }
    
        ~ArkUIListItemAdapter() {
            // 释放创建的组件。
            while (!cachedItems_.empty()) {
                cachedItems_.pop();
            }
            items_.clear();
            // 释放Adapter相关资源。
            OH_ArkUI_NodeAdapter_UnregisterEventReceiver(handle_);
            OH_ArkUI_NodeAdapter_Dispose(handle_);
        }
    
        ArkUI_NodeAdapterHandle GetHandle() const { return handle_; }
    
        void RemoveItem(int32_t index) {
            // 删除第index个数据。
            data_.erase(data_.begin() + index);
            // 如果index会导致可视区域元素发生可见性变化,则会回调NODE_ADAPTER_EVENT_ON_REMOVE_NODE_FROM_ADAPTER事件删除元素,
            // 根据是否有新增元素回调NODE_ADAPTER_EVENT_ON_GET_NODE_ID和NODE_ADAPTER_EVENT_ON_ADD_NODE_TO_ADAPTER事件。
            OH_ArkUI_NodeAdapter_RemoveItem(handle_, index, 1);
            // 更新新的数量。
            OH_ArkUI_NodeAdapter_SetTotalNodeCount(handle_, data_.size());
        }
    
        void InsertItem(int32_t index, const std::string &value) {
            data_.insert(data_.begin() + index, value);
            // 如果index会导致可视区域元素发生可见性变化,则会回调NODE_ADAPTER_EVENT_ON_GET_NODE_ID和NODE_ADAPTER_EVENT_ON_ADD_NODE_TO_ADAPTER事件,
            // 根据是否有删除元素回调NODE_ADAPTER_EVENT_ON_REMOVE_NODE_FROM_ADAPTER事件。
            OH_ArkUI_NodeAdapter_InsertItem(handle_, index, 1);
            // 更新新的数量。
            OH_ArkUI_NodeAdapter_SetTotalNodeCount(handle_, data_.size());
        }
    
        void MoveItem(int32_t oldIndex, int32_t newIndex) {
            auto temp = data_[oldIndex];
            data_.insert(data_.begin() + newIndex, temp);
            data_.erase(data_.begin() + oldIndex);
            // 移到位置如果未发生可视区域内元素的可见性变化,则不回调事件,反之根据新增和删除场景回调对应的事件。
            OH_ArkUI_NodeAdapter_MoveItem(handle_, oldIndex, newIndex);
        }
    
        void ReloadItem(int32_t index, const std::string &value) {
            data_[index] = value;
            // 如果index位于可视区域内,先回调NODE_ADAPTER_EVENT_ON_REMOVE_NODE_FROM_ADAPTER删除老元素,
            // 再回调NODE_ADAPTER_EVENT_ON_GET_NODE_ID和NODE_ADAPTER_EVENT_ON_ADD_NODE_TO_ADAPTER事件。
            OH_ArkUI_NodeAdapter_ReloadItem(handle_, index, 1);
        }
    
        void ReloadAllItem() {
            std::reverse(data_.begin(), data_.end());
            // 全部重新加载场景下,会回调NODE_ADAPTER_EVENT_ON_GET_NODE_ID接口获取新的组件ID,
            // 根据新的组件ID进行对比,ID不发生变化的进行复用,
            // 针对新增ID的元素,调用NODE_ADAPTER_EVENT_ON_ADD_NODE_TO_ADAPTER事件创建新的组件,
            // 然后判断老数据中遗留的未使用ID,调用NODE_ADAPTER_EVENT_ON_REMOVE_NODE_FROM_ADAPTER删除老元素。
            OH_ArkUI_NodeAdapter_ReloadAllItems(handle_);
        }
    
    private:
        static void OnStaticAdapterEvent(ArkUI_NodeAdapterEvent *event) {
            // 获取实例对象,回调实例事件。
            auto itemAdapter = reinterpret_cast<ArkUIListItemAdapter *>(OH_ArkUI_NodeAdapterEvent_GetUserData(event));
            itemAdapter->OnAdapterEvent(event);
        }
    
        void OnAdapterEvent(ArkUI_NodeAdapterEvent *event) {
            auto type = OH_ArkUI_NodeAdapterEvent_GetType(event);
            switch (type) {
            case NODE_ADAPTER_EVENT_ON_GET_NODE_ID:
                OnNewItemIdCreated(event);
                break;
            case NODE_ADAPTER_EVENT_ON_ADD_NODE_TO_ADAPTER:
                OnNewItemAttached(event);
                break;
            case NODE_ADAPTER_EVENT_ON_REMOVE_NODE_FROM_ADAPTER:
                OnItemDetached(event);
                break;
            default:
                break;
            }
        }
    
        // 分配ID给需要显示的Item,用于ReloadAllItems场景的元素diff。
        void OnNewItemIdCreated(ArkUI_NodeAdapterEvent *event) {
            auto index = OH_ArkUI_NodeAdapterEvent_GetItemIndex(event);
            static std::hash<std::string> hashId = std::hash<std::string>();
            auto id = hashId(data_[index]);
            OH_ArkUI_NodeAdapterEvent_SetNodeId(event, id);
        }
    
        // 需要新的Item显示在可见区域。
        void OnNewItemAttached(ArkUI_NodeAdapterEvent *event) {
            auto index = OH_ArkUI_NodeAdapterEvent_GetItemIndex(event);
            ArkUI_NodeHandle handle = nullptr;
            if (!cachedItems_.empty()) {
                // 使用并更新回收复用的缓存。
                auto recycledItem = cachedItems_.top();
                auto textItem = std::dynamic_pointer_cast<ArkUITextNode>(recycledItem->GetChildren().back());
                textItem->SetTextContent(data_[index]);
                handle = recycledItem->GetHandle();
                // 释放缓存池的引用。
                cachedItems_.pop();
            } else {
                // 创建新的元素。
                auto listItem = std::make_shared<ArkUIListItemNode>();
                auto textNode = std::make_shared<ArkUITextNode>();
                textNode->SetTextContent(data_[index]);
                textNode->SetFontSize(16);
                textNode->SetPercentWidth(1);
                textNode->SetHeight(100);
                textNode->SetBackgroundColor(0xFFfffacd);
                textNode->SetTextAlign(ARKUI_TEXT_ALIGNMENT_CENTER);
                listItem->AddChild(textNode);
                listItem->RegisterOnClick([index]() { OH_LOG_INFO(LOG_APP, "on %{public}d list item click", index); });
                handle = listItem->GetHandle();
                // 保持文本列表项的引用。
                items_.emplace(handle, listItem);
            }
            // 设置需要展示的元素。
            OH_ArkUI_NodeAdapterEvent_SetItem(event, handle);
        }
    
        // Item从可见区域移除。
        void OnItemDetached(ArkUI_NodeAdapterEvent *event) {
            auto item = OH_ArkUI_NodeAdapterEvent_GetRemovedNode(event);
            // 放置到缓存池中进行回收复用。
            cachedItems_.emplace(items_[item]);
        }
    
    
    
        std::vector<std::string> data_;
        ArkUI_NativeNodeAPI_1 *module_ = nullptr;
        ArkUI_NodeAdapterHandle handle_ = nullptr;
    
        // 管理NodeAdapter生成的元素。
        std::unordered_map<ArkUI_NodeHandle, std::shared_ptr<ArkUIListItemNode>> items_;
    
        // 管理回收复用组件池。
        std::stack<std::shared_ptr<ArkUIListItemNode>> cachedItems_;
    };
    
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_ARKUILISTITEMADAPTER_H
  3. 针对接入ArkTS页面章节使用的列表封装类对象,添加额外懒加载能力。

    // ArkUIListNode.h
    // 列表封装对象。
    
    #ifndef MYAPPLICATION_ARKUILISTNODE_H
    #define MYAPPLICATION_ARKUILISTNODE_H
    
    #include "ArkUIListItemAdapter.h"
    #include "ArkUINode.h"
    #include <hilog/log.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);
            if (adapter_) {
                // 析构的时候卸载adapter下的UI组件。
                nativeModule_->resetAttribute(handle_, NODE_LIST_NODE_ADAPTER);
                adapter_.reset();
            }
        }
    
        void SetScrollBarState(bool isShow) {
            assert(handle_);
            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) {
            assert(handle_);
            onScrollIndex_ = onScrollIndex;
            nativeModule_->registerNodeEvent(handle_, NODE_LIST_ON_SCROLL_INDEX, 0, nullptr);
        }
        // 引入懒加载模块。
        void SetLazyAdapter(const std::shared_ptr<ArkUIListItemAdapter> &adapter) {
            assert(handle_);
            ArkUI_AttributeItem item{nullptr, 0, nullptr, adapter->GetHandle()};
            nativeModule_->setAttribute(handle_, NODE_LIST_NODE_ADAPTER, &item);
            adapter_ = adapter;
        }
    
    protected:
        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_;
    
        std::shared_ptr<ArkUIListItemAdapter> adapter_;
    };
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_ARKUILISTNODE_H
  4. 创建列表懒加载的示例代码。

    // ArkUILazyTextListExample
    // 懒加载列表示例代码。
    
    #ifndef MYAPPLICATION_LAZYTEXTLISTEXAMPLE_H
    #define MYAPPLICATION_LAZYTEXTLISTEXAMPLE_H
    
    #include "ArkUIBaseNode.h"
    #include "ArkUIListNode.h"
    #include "UITimer.h"
    #include <thread>
    #include <uv.h>
    
    namespace NativeModule {
    
    std::shared_ptr<ArkUIBaseNode> CreateLazyTextListExample(napi_env env) {
        // 创建组件并挂载
        // 1:创建List组件。
        auto list = std::make_shared<ArkUIListNode>();
        list->SetPercentWidth(1);
        list->SetPercentHeight(1);
        // 2:创建ListItem懒加载组件并挂载到List上。
        auto adapter = std::make_shared<ArkUIListItemAdapter>();
        list->SetLazyAdapter(adapter);
    
        // 3:模拟相关懒加载操作。
        CreateNativeTimer(env, adapter.get(), 4, [](void *userdata, int32_t count) {
            auto adapter = reinterpret_cast<ArkUIListItemAdapter *>(userdata);
            switch (count) {
            case 0: {
                // 删除第0个元素。
                adapter->RemoveItem(0);
                break;
            }
            case 1: {
                // 插入第0个元素。
                adapter->InsertItem(0, "0");
                break;
            }
            case 2: {
                // 移到元素位置。
                adapter->MoveItem(0, 2);
                break;
            }
            case 3: {
                // 重载元素。
                adapter->ReloadItem(0, "1112");
                break;
            }
            case 4: {
                // 全量重载。
                adapter->ReloadAllItem();
                break;
            }
            default: {
            }
            }
        });
    
        // 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"); });
        // 4: 注册卸载事件。
        list->RegisterOnDisappear([]() { OH_LOG_INFO(LOG_APP, "on list unmount from tree"); });
        return list;
    }
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_LAZYTEXTLISTEXAMPLE_H
  5. 定时器模块相关简单实现。

    // UITimer.h
    // 定时器模块。
    
    #ifndef MYAPPLICATION_UITIMER_H
    #define MYAPPLICATION_UITIMER_H
    
    #include <hilog/log.h>
    #include <js_native_api.h>
    #include <js_native_api_types.h>
    #include <node_api.h>
    #include <node_api_types.h>
    #include <string>
    #include <thread>
    #include <uv.h>
    
    namespace NativeModule {
    
    struct UIData {
        void *userData = nullptr;
        int32_t count = 0;
        int32_t totalCount = 0;
        void (*func)(void *userData, int32_t count) = nullptr;
    };
    
    napi_threadsafe_function threadSafeFunction = nullptr;
    
    void CreateNativeTimer(napi_env env, void *userData, int32_t totalCount, void (*func)(void *userData, int32_t count)) {
        napi_value name;
        std::string str = "UICallback";
        napi_create_string_utf8(env, str.c_str(), str.size(), &name);
        // UI主线程回调函数。
        napi_create_threadsafe_function(
            env, nullptr, nullptr, name, 0, 1, nullptr, nullptr, nullptr,
            [](napi_env env, napi_value value, void *context, void *data) {
                auto userdata = reinterpret_cast<UIData *>(data);
                userdata->func(userdata->userData, userdata->count);
                delete userdata;
            },
            &threadSafeFunction);
        // 启动定时器,模拟数据变化。
        std::thread timerThread([data = userData, totalCount, func]() {
            uv_loop_t *loop = uv_loop_new();
            uv_timer_t *timer = new uv_timer_t();
            uv_timer_init(loop, timer);
            timer->data = new UIData{data, 0, totalCount, func};
            uv_timer_start(
                timer,
                [](uv_timer_t *handle) {
                    OH_LOG_INFO(LOG_APP, "on timeout");
                    napi_acquire_threadsafe_function(threadSafeFunction);
                    auto *customData = reinterpret_cast<UIData *>(handle->data);
                    // 创建回调数据。
                    auto *callbackData =
                        new UIData{customData->userData, customData->count, customData->totalCount, customData->func};
                    napi_call_threadsafe_function(threadSafeFunction, callbackData, napi_tsfn_blocking);
                    customData->count++;
                    if (customData->count > customData->totalCount) {
                        uv_timer_stop(handle);
                        delete handle;
                        delete customData;
                    }
                },
                4000, 4000);
            uv_run(loop, UV_RUN_DEFAULT);
            uv_loop_delete(loop);
        });
        timerThread.detach();
    }
    } // namespace NativeModule
    
    #endif // MYAPPLICATION_UITIMER_H
  6. 按照接入ArkTS页面章节将懒加载相关示例代码挂载到ContentSlot上显示。

    // NDK接口入口挂载文件。
    
    #include "NativeEntry.h"
    
    #include "ArkUIMixedRefresh.h"
    #include "LazyTextListExample.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 {
    namespace {
    napi_env g_env;
    }
    
    napi_env GetNapiEnv() { return g_env; }
    
    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);
    
        // 创建懒加载文本列表
        auto node = CreateLazyTextListExample(env);
    
        // 保持Native侧对象到管理类中,维护生命周期。
        NativeEntry::GetInstance()->SetRootNode(node);
        g_env = env;
        return nullptr;
    }
    
    napi_value DestroyNativeRoot(napi_env env, napi_callback_info info) {
        // 从管理类中释放Native侧对象。
        NativeEntry::GetInstance()->DisposeRootNode();
        return nullptr;
    }
    
    } // namespace NativeModule

鸿蒙开发渲染控制【LazyForEach:数据懒加载】 LazyForEach从提供的数据源中按需迭代数据,并在每次迭代过程中创建相应的组件。当在滚动容器中使用了LazyForEach,框架会根据滚动容器可视区域按需创建组件,当组件滑出可视区域外时,框架会进行组件销毁回收以降低内存占用。 阅读详情

相关推荐

鸿蒙HarmonyOS NEXT开发:ArkUI高性能开发-(使用懒加载优化性能)

懒加载LazyForEach是一种延迟加载的技术,它是在需要的时候才加载数据或资源,并在每次迭代过程中创建相应的组件,而不是一次性将所有内容都加载出来。

diongdingQAQ的博客 1405

(五)鸿蒙HarmonyOS主力开发语言ArkTS-数据懒加载(LazyForEach)

系列文章目录 (一)鸿蒙HarmonyOS开发基础 (二)鸿蒙HarmonyOS主力开发语言ArkTS-基本语法 (三)鸿蒙HarmonyOS主力开发语言ArkTS-状态管理 (四)鸿蒙HarmonyOS主力开发语言ArkTS-渲染控制 文章目录系列文章目录LazyForEach:数据懒加载接口描述IDataSource类型说明DataChangeListener类型说明使用限制键值生成规则组件创建规则首次渲染 LazyForEach:数据懒加载 LazyForEach从提供的数据源中按需迭代数据,并在

qq_44160056的博客 2900

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

鸿蒙next标签栏无法自动更新,解决懒加载问题

在开发鸿蒙时,我们会遇到这样一个局面,在@Entry组件修饰下的根组件跳转至其他@Component修饰的组件时只能在组件初始的时候加载一次,其余情况默认原先的加载状况以至于用户无法实时获取正确的信息。4.解决方案:将生命周期作为函数,实例化该对象并且再次加载生命周期。

m0_56315670的博客 1290

鸿蒙开发基础 —— 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。懒加载适配器相关功能实现。

guangxishaoji的博客 806

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

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

HarmonyOS007的博客 1200

鸿蒙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页面)

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(使用懒加载开发长列表界面)

针对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

【鸿蒙基于API 13实战开发】—— 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。懒加载适配器相关功能实现。

shangkangba的博客 407

ArkUI-X 1.0 跨平台实战:3步将HarmonyOS应用转换为Android/iOS原生项目

本文详细介绍了如何使用ArkUI-X 1.0将HarmonyOS应用快速转换为Android/iOS原生项目。通过3个核心步骤:环境准备与工具链配置、跨平台迁移核心步骤、高级功能与性能优化,开发者可以轻松实现多平台适配。文章特别强调了ArkUI-X框架的跨平台优势,并提供了实用的代码示例和性能优化建议,帮助开发者高效完成应用迁移。

weixin_34248705的博客 384

鸿蒙生态深度解构:HarmonyOS 6.0与OpenHarmony 5.0全栈开发实战指南

《鸿蒙6.0全栈开发实战指南》摘要: 本文深度解析鸿蒙6.0(NEXT)技术体系,聚焦纯血鸿蒙时代的开发变革。核心内容包括:1) Stage模型架构与Ability生命周期管理;2) ArkUI状态管理三级体系(@State/@Link/@Observed)的性能优化方案;3) 响应式布局在折叠屏等多端设备上的工业级实现;4) 冷启动优化等10条大厂级性能法则。通过电商场景案例,展示了从0.78s冷启动优化到分布式硬件开发的全栈实践路径,为开发者提供从北向应用到南向驱动的完整技术解决方案。特别强调鸿蒙6.0

m0_51738372的博客 2693

ArkUI-X动态化开发在Android平台的核心优势与实践

动态化开发是现代移动应用提升迭代效率的关键技术,其核心原理在于将应用模块动态加载运行,避免传统全量更新的繁琐流程。ArkUI-X作为鸿蒙生态的跨平台解决方案,通过框架级动态化实现了UI框架的按需加载,相比传统业务逻辑动态化具有显著优势。在工程实践中,这种技术能有效缩减安装包体积40%以上,支持热更新绕过应用市场审核,并大幅降低多平台UI一致性维护成本。特别是在电商、金融等需要快速迭代的场景中,ArkUI-X的动态化能力结合HSP资源包管理和性能监控体系,为开发者提供了高效的跨平台开发方案。

weixin_32075843的博客 340

【鸿蒙开发实战篇】鸿蒙6开发中,UI相关应用崩溃常见问题与解决方案

摘要:本文针对鸿蒙应用开发中常见的UI崩溃问题,总结了4类典型错误及解决方案:JS运行时错误、应用冻结、内存泄漏和Native层崩溃。文章提供了详细的调试方法,包括日志分析、性能剖析工具使用,并给出预防性编码建议,如全局异常拦截、Worker线程优化和资源生命周期管理。这些基于HarmonyOS 4.0/Next版本的经验对鸿蒙6开发具有重要参考价值。

威哥爱编程,华为 HDE,鸿蒙极客、优快云博客专家、《鸿蒙 HarmonyOS 5/6 开发之路》系列图书第一作者 1387

Dbeaver连接TDengine时序数据库

也没啥好总结的,就一句话:Dbeaver真香,而且还是我大JAVA实现的,赞。希望能帮到大家,uping。

zwrlj527的专栏 1903

别再为GEE注册发愁了!用谷歌Cloud Project,5分钟搞定谷歌地球引擎账户(保姆级图文)

本文提供2024最新版谷歌地球引擎(GEE)账户注册的保姆级教程,通过谷歌Cloud Project快速完成注册,5分钟极速通关。详细解析注册前的准备、分步图解流程、常见误区及解决方案,帮助用户避开90%的注册陷阱,直达GEE核心功能区。

weixin_42557830的博客 202

React Native鸿蒙跨平台开发与Linking模块实战

跨平台开发技术通过共享代码库显著提升移动应用开发效率,其中React Native框架结合JavaScript生态实现了高性能原生应用开发。深度链接(Deeplink)作为关键技术,通过统一URL路由机制打通应用内外跳转链路,在电商、社交等场景中实现无缝用户体验。本文以鸿蒙(HarmonyOS)平台为例,详细解析React Native中Linking模块的实现原理,涵盖URL Scheme注册、跨平台路由映射、原生模块集成等核心内容,并分享鸿蒙特有的分布式链接处理与性能优化方案,为多端统一开发提供实践参考

weixin_30291791的博客 388

RK3568 解决MIPI屏幕开机只显示uboot logo的问题

之前写过一篇文章介绍了RK3568驱动MIPI屏幕的方法,这次产品迭代,硬件改版,选型的新的屏幕了。所以再次开启调试屏幕的过程。本以为会和上次一样会轻车熟路,事情总是事与愿违,同样的路,遇到新的坑。

fhqlongteng的博客 5427

自定义组件封装:构建高复用性的业务组件库(24)

适用场景:当需要复用的不仅是 UI 样式,还包含特定的布局结构和业务逻辑时(例如:一个由 Image + Text 垂直排列组成的图文复合组件),应将其封装为自定义组件。实现方式使用@Component装饰器定义组件,在内部实现不变的布局结构。将可能变化的部分(如文本内容、图片资源、点击事件等)作为参数变量暴露出来。进阶复用:为了让外部使用者能够灵活定制内部子组件的样式,可以在封装组件的变量中添加类型的参数。这样,外部调用方既可以直接传入数据,也可以通过传入Modifier实例来修改内部子组件的样式。

Davina_yu的博客 428

新手必看:瑞萨MCU选型时,QFP、QFN、BGA这些封装到底该怎么选?(附选型避坑指南)

本文详细解析了瑞萨MCU选型中QFP、QFN、BGA等封装的特点与适用场景,提供实战避坑指南。通过对比封装的空间占用、散热能力、焊接难度等核心维度,帮助工程师根据具体需求选择最合适的芯片封装,避免因选型不当导致的高成本与生产问题。

weixin_26965807的博客 421

CPU核心、die和package的区别:从硬件小白到高手的进阶指南

本文深入浅出地解析了CPU核心、Die与Package的核心概念与区别,是硬件爱好者从入门到精通的实用指南。文章从硅晶圆制造讲起,阐述了物理核心与逻辑线程(如超线程技术)的工作原理,并详细介绍了封装(Package)的作用与多Die模块化设计。最后,结合实际应用场景,提供了选购、性能解读与优化调优的实用建议。

pz89012345的博客 204

鸿蒙与React Native融合下的手机号输入验证优化实践

在跨平台开发领域,输入验证是保障数据安全与用户体验的基础技术。通过正则表达式等校验机制,开发者可以确保用户输入符合业务规则。随着鸿蒙系统的分布式能力与声明式UI特性发展,传统React Native方案在输入法控制、校验性能等方面获得显著提升。本文以手机号验证为典型场景,深入解析如何结合鸿蒙原生API与React Native框架,实现键盘类型自动切换、分布式设备协同等高阶功能。通过对比JS层与原生校验的性能差异(鸿蒙C++校验仅3.1ms),展示混合开发方案在金融、电商等实时性要求高的场景中的技术价值。

weixin_34405557的博客 366

(Cascade extended state observer)级联ADRC的simulink仿真和程序---送给中国研究学者的精华版

(Cascade extended state observer)级联ADRC的simulink仿真和程序---送给中国研究学者的精华版

weixin_44312889的博客 3786

OpenHarmony实战开发-Grid高性能开发指导。

在构建大型、复杂应用时,性能优化至关重要。Grid布局作为一种高效布局方式,可以提高页面的均分能力、子组件占比控制能力及自适应布局能力。本文将介绍Grid在高性能开发方面的应用,包括懒加载、cachedCount、组件复用和使用GridLayoutOptions设置GridItem大小等方法,帮助开发者优化Grid布局性能,减少加载和渲染时间,提升用户体验。

2401_82546228的博客 1489

突发E层(Es层):短波通信中的“意外惊喜”与“隐形杀手”全解析

本文深入解析了突发E层(Es层)在短波通信中的双重作用,既可能带来超远距离通信的“意外惊喜”,也可能成为通信链路的“隐形杀手”。通过分析Es层的形成机制、时空分布规律及实战应用技巧,帮助通信爱好者与专业人员更好地利用或应对这一电离层现象,提升短波通信的可靠性与效率。

weixin_30443813的博客 828

SystemVerilog新手实战指南:iverilog与VScode的完美组合

本文为SystemVerilog新手提供了一套高效入门方案,详细介绍了如何利用开源编译器iverilog与轻量编辑器VScode搭建学习环境。内容涵盖十分钟快速安装配置、首个工程从编码到查看波形的完整流程,并演示了动态数组和队列等SystemVerilog新特性的使用,旨在帮助初学者避开复杂商业工具,快速掌握数字电路设计与验证的核心技能。

f6g7h8i9j的博客 514
上一篇: 鸿蒙5.0开发进阶:使用NDK接口构建UI(使用动画)
下一篇: 鸿蒙5.0开发进阶:使用NDK接口构建UI(构建弹窗)
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值