Tagged articles
ArkTS
98 articles · Page 1 of 1
This tutorial walks through creating a HarmonyOS 6 service card called PocketNote, covering configuration, data binding, form provider lifecycle, card UI with button actions, and the app entry point for adding the card to the system desktop, with debugging tips and a live demo on API 24 simulator.
API 24ArkTSFormKit
0 likes · 25 min read

This tutorial demonstrates how to implement real-time speech recognition in HarmonyOS using Core Speech Kit, covering engine creation, permission handling, result callbacks, and a complete voice note app example with code snippets.
ArkTSCore Speech KitHarmonyOS
0 likes · 11 min read

The article demonstrates building a "storage memory box" app using HarmonyOS 7.0's text-to-image search (Core Vision Kit) to retrieve photos of stored items and their logged locations, covering data modeling, implementation flow, candidate resolution, UI state management, and validation methodology.
ArkTSCore Vision KitHarmonyOS 7.0
0 likes · 16 min read

The article demonstrates implementing a Retrieval-Augmented Generation (RAG) pipeline on HarmonyOS 7 for enterprise private knowledge base Q&A, covering document chunking with sliding window overlap, deterministic vectorization for offline testing, cosine similarity search, orchestrated index/retrieve/generate phases, system prompt constraints to prevent hallucination, UI citation display, and 27 offline unit tests.
Agent DevelopmentArkTSEnterprise Knowledge Base
0 likes · 16 min read

The article demonstrates creating a dramatic 3D spotlight effect on HarmonyOS 6 by setting up a near-dark environment, adding a configurable spotlight with adjustable intensity, cone angle, and color temperature, and providing complete ArkTS code for real-time interactive lighting control on a MatePad Edge device.
3D graphicsArkGraphics3DArkTS
0 likes · 21 min read

The final day of the HarmonyOS Meta Service 7-Day Tour explores a Code Lab meta service that visualizes sorting algorithms, data structures, and design patterns with synchronized step-by-step playback, pause, rewind, and code highlighting driven by a shared playback model.
Algorithm VisualizationArkTSEducational Tool
0 likes · 9 min read

Huawei details its dual-engine AI coding strategy for HarmonyOS — DevEco Code with a three-loop Harness (syntax, compile, UI intent) and DevEco CLI with atomic commands, a 20M-token knowledge base, 70+ Skills, and a four-level Skill router — plus a four-layer verification stack achieving 80%+ crash-fix rates.
AI agent workflowAI codingArkTS
0 likes · 16 min read

This article introduces the compact utility from the arktoolbox library for HarmonyOS, which removes falsy values (null, undefined, 0, false, empty string, NaN) from arrays, explains its implementation, compares it with filter(Boolean), highlights edge cases like 0 being valid data, and demonstrates practical usage in forms, API aggregation, and caching.
ArkTSHarmonyOSarktoolbox
0 likes · 16 min read

This article demonstrates how to build responsive HarmonyOS 7 floating tab layouts that adapt to foldable phones, tablets, and split-screen windows by reading actual container width via ContainerReader, using breakpoints at 440/600/840 vp to switch column counts, preserving business state during layout changes, and avoiding device-type branching.
ArkTSContainerReaderHarmonyOS 7
0 likes · 26 min read

This tutorial walks through building a full-featured HarmonyOS news module with category tabs, list rendering, custom pull-to-refresh and load-more logic using touch events and offset animations, network request encapsulation with Promise-based error handling, and a layered architecture separating view, viewmodel, and common utilities.
ArkTSHarmonyOSList Component
0 likes · 33 min read

This guide explains how to enable ArkTS's built-in ArkGuard obfuscation with just two configuration files and a release build, detailing its bytecode-level operation, automatic semantic-aware rules for ArkUI and system APIs, multi-module rule management, mapping files for debugging, and step-by-step rollout with practical demos for property, filename, and dynamic access keep rules.
ArkGuardArkTSDevEco Studio
0 likes · 19 min read

This guide details HarmonyOS 7's Core Vision Kit ImageSR API for on-device 4x AI super-resolution, covering API usage, ArkTS demo code, permissions, constraints (2048x2048 input, RGBA_8888 format), common pitfalls (emulator unsupported, model download, resource leaks), and suitable use cases like e-commerce and social images where perceptual quality matters more than pixel-perfect accuracy.
API 26ArkTSCore Vision Kit
0 likes · 21 min read

This tutorial walks through upgrading a HarmonyOS health app from local-only storage to an end-cloud integrated architecture using AppGallery Connect, covering architecture design, data synchronization strategies, CloudDB modeling, SDK initialization, and development environment setup with DevEco Studio and Node.js cloud functions.
AppGallery ConnectArkTSCloudDB
0 likes · 14 min read

ArkTS introduces the `import lazy` syntax to defer module execution until first use, reducing cold-start latency by ~15% through compiler-runtime collaboration and integrated profiling tools that detect, mark, verify, and quantify redundant loads without rewriting call sites.
ArkTSDevEco ProfilerHSP
0 likes · 10 min read

This guide teaches HarmonyOS developers to troubleshoot ArkTS compilation errors using log levels (ERROR/WARN/INFO/DEBUG), error code navigation via official documentation, common error patterns (syntax, imports, memory), and advanced techniques like debug-mode configuration, cache cleaning, and vendor version checks.
ArkTSHarmonyOSHvigor
0 likes · 8 min read

This tutorial walks through creating a high-performance HSV-based color wheel component for HarmonyOS PC using ArkTS and ArkUI, covering mathematical foundations, bidirectional RGB/HSV/Hex synchronization, mouse interaction handling, and on-device verification with DevEco Studio and HDC commands.
ArkTSArkUIDevEco Studio
0 likes · 12 min read

This tutorial walks through building a HarmonyOS interactive desktop widget using FormKit, covering configuration, UI with @LocalStorageProp, FormExtensionAbility lifecycle, event handling via postCardAction, state machine design, and real-world pitfalls like formId extraction and background execution limits.
ArkTSFormKitHarmonyOS
0 likes · 47 min read

This guide teaches HarmonyOS developers how to debug ArkTS closures using DevEco Studio, covering breakpoint setup, variable inspection via Closure nodes, watch expressions, value modification, and common pitfalls like missing closure nodes and deep nesting.
ArkTSDevEco StudioHarmonyOS
0 likes · 9 min read

A developer couple created 'Love Bean AI Blueprint,' a HarmonyOS app that generates bead art patterns from photos using AI, built with a Cangjie/ArkTS/C++ architecture and AI-assisted migration tools, earning a spot at HDC 2026 Star Avenue.
AI-assisted developmentARArkTS
0 likes · 12 min read

This article details three clustering rules — shortest reference chain, name-plus-reference chain, and property-plus-reference chain — for analyzing ArkTS memory snapshots, enabling developers to automatically group 100,000+ objects and identify leak sources by retained size and allocation site.
ArkTSHarmonyOSJSNativePointer
0 likes · 7 min read

This guide introduces the LocalHandle leak detection tool for HarmonyOS ArkTS, which uses smart instrumentation to identify memory leaks at creation time by checking for active handle scopes, reducing debugging from days to minutes with 100% accuracy and direct code-line navigation in DevEco Studio.
ArkTSDebugging ToolsDevEco Studio
0 likes · 15 min read

This guide demonstrates the complete six-step workflow for developing and publishing HarmonyOS third-party libraries to the OpenHarmony central repository using DevEcoCli and DevEcoCode, covering account setup, RSA key configuration, HAR module creation, oh-package.json5 requirements, release-mode building, and ohpm publishing with troubleshooting tips.
ArkTSDevEcoCliHarmonyOS
0 likes · 20 min read

Huawei releases DevEco Code 0.1.3 and DevEco CLI 1.2.0 with enhanced ArkTS code generation, new static analysis tools, Goal mode improvements, and comprehensive CLI commands for HarmonyOS app development including build, run, emulator management, and MCP services.
AI-assisted developmentArkTSCLI tools
0 likes · 10 min read

This tutorial demonstrates a full video transcoding workflow on HarmonyOS using the AVTranscoder API, covering instance creation, progress tracking, pause/resume/cancel controls, and playback of the transcoded output, with complete ArkTS code examples.
AVTranscoderArkTSHarmonyOS
0 likes · 12 min read

This guide covers HarmonyOS wearable app development from fundamentals to distribution, including cross-device continuation, rotating crown and gesture interactions, ArkTS/ArkUI frameworks, JS-like paradigm for lightweight wearables, design guidelines, best practices for architecture and security, debugging, performance tuning, and AppGallery Connect publishing.
App DistributionArkTSArkUI
0 likes · 14 min read

Kuaishou contributes to the KMP&CMP community, expanding cross-language syntax support to 78% coverage with complex generics, function expressions, abstract classes, and typealias, while introducing KSP-powered compile-time type solidification to solve runtime generic erasure in ArkTS-Kotlin interop.
ArkTSGenericsHarmonyOS
0 likes · 6 min read

Taihe is a HarmonyOS cross-language tool that replaces 200+ lines of manual NAPI binding code with a 4-line IDL definition, generating type-safe C++, ArkTS, and NAPI bindings through a compiler pipeline with stable ABI and language projections.
ArkTSC++HarmonyOS
0 likes · 18 min read

This article explores ArkTS's annotation system, showing how its compiler-driven inference reduces annotation boilerplate by one-third compared to Java, enables compile-time default value injection and type checking, separates annotations from decorators, provides built-in @Available and @SuppressWarnings, supports modular imports, and details current limitations like target restrictions and limited attribute types.
@Available@SuppressWarningsAnnotations
0 likes · 12 min read

This article demonstrates how to integrate HarmonyOS Media Library Kit's Moving Photo capability into a real app, covering selection, import, sandbox storage, data modeling, and playback with MovingPhotoView using the Time Travel Journal app as a case study.
AVPlayerArkTSDynamic Photo
0 likes · 27 min read

Log4a, an open-source HarmonyOS logging library from One Day Accounting, uses a three-layer architecture with background Worker threads to prevent main-thread blocking, supports encrypted log storage, rolling logs, and server upload, and has been validated across apps with over one million users and ten million downloads.
ArkTSHarmonyOSLog4a
0 likes · 6 min read

HarmonyOS 7 introduces DevEco Code, an AI agent that plans and generates code, and DevEco CLI, which executes build, deploy, and test commands, together enabling a goal-oriented development loop with knowledge bases and reusable Skills for verified app delivery.
AI AgentAI codingArkTS
0 likes · 8 min read

HarmonyOS has open-sourced its first batch of Agent Skills on GitCode, providing AI-assisted coding support for ArkTS syntax checking, ArkUI development, multi-device adaptation, and application stability diagnosis, with demonstrated efficiency gains in foldable device adaptation and freeze analysis.
AI-assisted developmentArkTSArkUI
0 likes · 6 min read

HarmonyOS 7.0 Developer Beta1 introduces on-device A2A for secure agent integration, 3D Gaussian Splatting spatial reconstruction and rendering, ArkUI immersive light-sense components, ArkTS compilation and debugging enhancements, OHAudioSuite spatial audio pipeline, and a kernel-level fast startup technology that trades storage I/O for memory savings to achieve instant app launches.
3D Gaussian splattingAbility KitArkTS
0 likes · 12 min read

This article details a HarmonyOS network request library encapsulation featuring global configuration, chainable API, request/response interceptors, and support for JSON, form, binary, and multipart file uploads, with complete implementation code, usage examples, and pitfalls like ArkTS type constraints and large-file memory limits.
ArkTSChainable APIFile Upload
0 likes · 16 min read

This tutorial demonstrates building a skateboard trick tracking app on HarmonyOS, covering trick library design, practice session storage using the Preferences API, combo management, statistical analytics, and key implementation pitfalls like data migration and async handling.
ArkTSData ModelingHarmonyOS
0 likes · 21 min read

This guide demonstrates seven bytecode instrumentation scenarios using HarmonyOS AbcKitTS, including lifecycle tracking, function timing, privacy API monitoring, method replacement, attribute modification, click tracking, and parameter validation, with code examples and Hvigor plugin integration.
AbcKitTSArkTSHarmonyOS
0 likes · 18 min read

This article details building a dynamic HarmonyOS service card that shows real-time cooking progress on the desktop, using FormExtensionAbility in API 23 with a main-process push architecture and Preferences-based cross-process data bridge to overcome process isolation.
API 23ArkTSFormExtensionAbility
0 likes · 23 min read

This article details a three-tier information architecture (full, compact, minimal) for adapting HarmonyOS native apps to floating windows on foldable devices like the Pura X Max, showing how to preserve only essential UI elements — title, status, and primary action — in minimal mode while progressively restoring context as window width increases.
ArkTSHarmonyOSUI adaptation
0 likes · 23 min read

This article analyzes the HarmonyOS ClickUtil library from @pura/harmony-utils V1.4.0, explaining throttle and debounce implementations with source code, interactive demos, and scenario-based selection guidance for preventing duplicate button clicks in mobile applications.
ArkTSClickUtilHarmonyOS
0 likes · 13 min read

Everything Claude Code now provides comprehensive HarmonyOS development support with a dedicated agent, ArkTS syntax rules, automated hooks, and project templates that enforce V2 state management, Navigation routing, and security best practices for AI-assisted coding.
AI codingArkTSClaude Code
0 likes · 14 min read

This tutorial demonstrates building a mental health app statistics page in HarmonyOS, covering a custom tab switcher, a Grid-based mood calendar with mock data, and a smooth mood trend curve drawn on Canvas using cubic Bézier interpolation.
ArkTSBezier CurveCanvas
0 likes · 11 min read

This tutorial walks through building a HarmonyOS NEXT app that uses ArkTS and the reminderAgentManager API to deliver daily 7:30 AM weather-based umbrella notifications, covering permissions, network requests, decision logic, and UI design.
ArkTSDevEco StudioHarmonyOS
0 likes · 17 min read

This guide details the RcText component from the rchoui library for HarmonyOS 6, covering basic text display, theme colors, sizing, custom styling, alignment, decoration, truncation modes, special formats for price and phone numbers, link handling, prefix/suffix icons, interaction events, and layout control with practical code examples.
ArkTSHarmonyOSRcText
0 likes · 25 min read

This article details practical HarmonyOS compilation optimizations — unified lockfiles, boosted extraction, disabled JS intermediate output, and skipped lib compression — that reduced full builds from 24 to 14 minutes and incremental builds from 4 to 2.5 minutes on a 3-million-line ArkTS codebase.
ArkTSDevEco StudioHarmonyOS
0 likes · 7 min read

This tutorial demonstrates how to implement face detection in HarmonyOS apps using Core Vision Kit, covering face position, landmarks, orientation, confidence scores, with complete ArkTS code examples, constraints, error handling, and privacy considerations for offline on-device processing.
ArkTSComputer VisionCore Vision Kit
0 likes · 16 min read

The article demonstrates how CodeGenie uses MCP to connect external knowledge bases and Rules to enforce ArkTS standards, enabling AI to detect deprecated APIs, retrieve official docs, and generate compliant HarmonyOS code through a four-step workflow.
AI-assisted developmentArkTSCodeGenie
0 likes · 8 min read

This tutorial walks through creating a WeChat-like interface on HarmonyOS 6, covering four main pages — Chat, Contacts, Discovery, and Me — using Tabs for bottom navigation, Swiper for swipe gestures, and reusable ArkTS components for lists, dividers, and tab bar styling.
ArkTSCustom ComponentsHarmonyOS 6
0 likes · 12 min read

This guide walks you through the complete HarmonyOS mobile development workflow—from understanding the platform’s layered architecture and core ArkTS/ArkUI concepts, to setting up DevEco Studio, creating a Hello World app, managing UI, state, routing, data, and finally packaging and publishing the app.
ArkTSArkUIDevEco Studio
0 likes · 12 min read

This article details implementing a high-performance line art extraction feature in HarmonyOS using ArkTS, covering grayscale conversion, differential edge detection, efficient pixel buffer access, sketch and comic style rendering, and time-sliced chunk processing to prevent UI freezes on large images.
ArkTSEdge DetectionHarmonyOS
0 likes · 12 min read

This article explains ArkTS's strict type restrictions, its use of ESObject for unknown JS types, special limits on interfaces, classes, and decorators, as well as its memory model, closure rules, and the differences between Record and Map containers, highlighting how these design choices improve compilation and runtime efficiency.
AOTArkTSConcurrency
0 likes · 7 min read

Hisense Aijia's smart home app migrated to HarmonyOS using ArkTS, integrating Scan Kit for robust QR scanning, Cast Engine for low-latency screen casting, responsive layouts for foldable devices, and Account Kit for simplified OAuth login, cutting launch time to 2 seconds with HarmonyOS team support.
Account KitArkTSCast Engine
0 likes · 12 min read

This article shares the complete development journey of PromptTuner, a HarmonyOS 6 native app for prompt discovery, optimization, and management, covering architecture, ArkUI declarative UI patterns, state management, API abstraction, local analytics, privacy compliance, and performance optimization techniques with concrete code examples and metrics.
ArkTSArkUIDeclarative UI
0 likes · 43 min read

This tutorial walks through the complete lifecycle of a HarmonyOS atomic service — from UI implementation with Navigation, Grid, LazyForEach, and @Builder, to AI-powered text-to-speech, and finally manual code signing, packaging, and release via AppGallery Connect.
AppGallery ConnectArkTSAtomic Service
0 likes · 13 min read

A HarmonyOS developer shares the full technical practice of building a children's flag-learning app, covering technology selection (Core Speech Kit, ArkTS, Stage model), core feature implementation (offline voice synthesis/recognition, canvas drawing, puzzle game), global state management with AppStorage, performance optimizations for 200+ flags, and future plans for multi-device collaboration and AI integration.
ArkTSCore Speech KitDevEco Studio
0 likes · 26 min read

Learn to implement scroll-responsive navigation bars in HarmonyOS 6.0 using HdsNavigation's dynamicHideTitleBar API, with step-by-step configuration, hide modes (SCROLL_UP_TO), offset tuning, blur effect combination, conditional enabling, and debugging techniques for smooth immersive UIs.
API 6.0ArkTSHarmonyOS
0 likes · 11 min read

The article shares the development of 'Hongtu Zhidao', a travel app built on HarmonyOS 6, detailing its architecture, challenges like multi-tab navigation and AI content persistence, and solutions using ArkTS/ArkUI declarative UI, ArkData local storage, AppStorageV2 for global state, real-time AI itinerary planning, and DevEco Studio's hot reload and multi-device preview.
AppStorageV2ArkDataArkTS
0 likes · 18 min read

This technical case study details the end-to-end development of PromptTuner, a HarmonyOS 6 native app for prompt discovery, optimization, and management, covering three-layer architecture, ArkUI declarative UI patterns, state management, API abstraction, local analytics, privacy compliance, and measurable performance gains.
API abstractionArkTSArkUI
0 likes · 35 min read

A HarmonyOS developer shares the technical journey of building 'Shengqu Guoqitong', a children's flag learning app, detailing why HarmonyOS was chosen over Android, Flutter, and React Native, and how Core Speech Kit's offline TTS/ASR and ArkTS declarative UI enabled efficient development of voice-driven, interactive educational features.
ArkTSChildren EducationCore Speech Kit
0 likes · 29 min read

A junior developer shares the full lifecycle of creating "Gege Check-in," a HarmonyOS habit-tracking app that won Huawei's 2025 developer incentive, detailing architecture, AI-assisted coding, DevEco Studio workflows, calendar component integration, privacy-first local storage, and the monthly active user targets required to claim the reward.
AI-assisted codingArkTSDevEco Studio
0 likes · 9 min read

This article explores HarmonyOS 6's four core development capabilities: the 'one-to-many' multi-device adaptation framework, AI agent integration via Xiaoyi platform, UI Design Kit for native-grade interfaces, and Live View Kit for real-time system-level notifications, with code examples and implementation guides.
AI AgentArkTSHarmonyOS 6
0 likes · 36 min read

This article details the integration and optimization of Amap Flutter plugins (amap_flutter_map, amap_flutter_location) in an OpenHarmony project, covering Clean Architecture layering, tile caching, memory management, cross-platform adaptations for Android/iOS, error handling, and a complete HarmonyOS bridge/adapter implementation in ArkTS.
AmapArkTSFlutter
0 likes · 19 min read

Learn how to monitor and analyze crashes in HarmonyOS Next by handling native C/C++ signals and ArkTS/JavaScript errors, using hiAppEvent watchers, simulating crash scenarios, and leveraging build artifacts such as source maps, debug .so files, and nameCache for precise stack trace reconstruction and improved app stability.
ArkTSCrash MonitoringHarmonyOS
0 likes · 17 min read

This tutorial demonstrates how to implement external subtitles (SRT/VTT) in HarmonyOS using AVPlayer's subtitleUpdate event, covering subtitle file loading via addSubtitleFromFd, callback registration, synchronization, and limitations like pre-playback-only subtitle setting.
AVPlayerArkTSHarmonyOS
0 likes · 6 min read

CodeGenie, HarmonyOS's AI coding assistant, now generates compilable ArkTS UI code from screenshots in ~2 minutes using a parse-then-generate architecture with VLM element detection and LLM agents, achieving 85%+ parsing accuracy, near 100% preview rate, and 40% adoption across food, travel, shopping, news, and education apps.
AI-assisted codingArkTSCodeGenie
0 likes · 14 min read

This guide covers HarmonyOS AVScreenCapture for screen recording, detailing features like hardware-accelerated H.264/H.265 encoding, dual audio tracks, full-screen and region capture, plus complete ArkTS and C++ NDK code examples with configuration parameters and development workflows.
ArkTSHarmonyOSNDK
0 likes · 6 min read

This article introduces HarmonyOS NEXT's pure, fast, and minimal design, its development base with DevEco Studio and ArkTS, the compilation artifacts (HAR, HSP, HAP), the system‑level open capability map, and the ARMS RUM SDK's architecture, session management, and three unobtrusive data‑collection schemes for performance monitoring.
ArkTSHarmonyOSPerformance Monitoring
0 likes · 11 min read


21CTOSep 29, 2025 · Frontend Development
OpenHarmony 6.0, unveiled at the 2025 OpenAtom OpenHarmony conference in Changsha, introduces major upgrades across UI components, ArkTS language, media handling, graphics, security protocols, and performance testing, while reporting over 17 million HarmonyOS devices and a rapidly growing contributor community.
ArkTSArkUIOpenHarmony
0 likes · 5 min read

CodeGenie leverages a Huawei-curated HarmonyOS corpus to provide context-aware code completion with three trigger modes, fine-grained acceptance controls, cross-module dependency resolution, and adaptive style learning, enabling developers to generate accurate ArkTS code while maintaining full control over suggestions.
AI-assisted developmentArkTSCodeGenie
0 likes · 8 min read

This article explains how to implement dialog routing in HarmonyOS using the Navigation component's Dialog mode, contrasting Standard and Dialog NavDestination modes, and provides a complete shopping cart example with ArkTS code demonstrating persistent, non-blocking dialogs with transition effects.
ArkTSArkUIDialog Routing
0 likes · 6 min read

This guide covers HarmonyOS AVRecorder's supported formats (AAC/MP3, H.264/H.265, MP4/M4A), provides step-by-step ArkTS and C++ NDK code examples for recording workflow, and outlines key development practices including state machine rules, resource cleanup, and permission handling.
AVRecorderArkTSHarmonyOS
0 likes · 6 min read

This article explains how HarmonyOS developers can reuse native C/C++ file upload code across iOS, Android, and HarmonyOS by employing Node‑API thread‑safe functions to asynchronously report upload progress, errors, and completion from native threads back to the ArkTS UI thread.
ArkTSFile UploadHarmonyOS
0 likes · 14 min read

This article walks through the ArkUI‑X cross‑platform framework, explains the relationship between ArkTS, ArkUI and ArkUI‑X, shows how to set up the development environment, create and build a demo project, and reveals the rendering pipeline and Android/iOS integration details including a clipboard example.
AndroidArkTSArkUI-X
0 likes · 17 min read

This article explains how to use Node‑API’s thread‑safe functions to asynchronously relay native file upload progress, completion, and error callbacks from native C/C++ threads to ArkTS JavaScript on HarmonyOS, covering API definitions, event‑loop integration, and practical implementation details with code examples.
ArkTSFile UploadHarmonyOS
0 likes · 13 min read


AntTechMay 6, 2025 · Information Security
This article presents a comprehensive overview of the security challenges in HarmonyOS native ArkTS applications and describes the design and implementation of a specialized static analysis framework—including source extraction, data‑flow and inter‑function analysis, knowledge‑graph construction, and risk inference engine—while also outlining integration into development pipelines and future research directions.
ArkTScode analysisknowledge graph
0 likes · 17 min read

This article details Alibaba's security team's comprehensive approach to detecting ArkTS code vulnerabilities in HarmonyOS apps, covering architectural design, static analysis techniques, knowledge‑graph modeling, CI/CD integration, and future AI‑driven enhancements.
ArkTSHarmonyOSknowledge graph
0 likes · 17 min read

This article explores the ArkUI‑X cross‑platform framework, detailing its relationship with ArkTS and ArkUI, step‑by‑step environment setup, project creation, the compilation pipeline that generates ViewPU classes, and the intricate bridge that connects ArkTS code to Android and iOS system services such as the clipboard.
ArkTSArkUI-XClipboard Integration
0 likes · 16 min read

This article explains the HarmonyOS NEXT Background Tasks Kit, detailing its four task types—Transient, Continuous, Deferred, and Agent‑powered Reminder—along with their characteristics, typical use cases, and complete ArkTS code examples for each scenario.
ArkTSBackground TasksHarmonyOS
0 likes · 17 min read

This article explains the concept of structural typing in TypeScript, contrasts it with ArkTS's nominal typing approach, provides code examples illustrating compatibility rules, and analyzes why Huawei chose to disable structural typing in ArkTS, highlighting the trade‑offs involved.
ArkTSHarmonyOSNominal Typing
0 likes · 10 min read


JD TechNov 13, 2024 · Frontend Development
This article explains the end‑to‑end architecture, principles, and code implementation of the dynamic cross‑platform framework (Roma/Dynamic) on HarmonyOS, covering template loading, JS‑C++‑ArkTS instance creation, V‑Dom and Component tree construction, rendering pipeline, view updates, and performance optimizations.
ArkTSC++HarmonyOS
0 likes · 30 min read

The article examines how arkTS, HarmonyOS's TypeScript‑based language, forces front‑end developers to adopt stricter class‑based patterns, disallows any/unknown, and removes familiar JavaScript features like spread and destructuring, making the transition noticeably harder.
ArkTSHarmonyOSTypeScript
0 likes · 10 min read

This article introduces ArkTS, HarmonyOS’s preferred TypeScript‑based language, and demonstrates its declarative UI syntax, component creation, property and event configuration, child component nesting, state management, and rendering control through practical code examples.
ArkTSComponent ArchitectureDeclarative UI
0 likes · 6 min read


JD TechOct 19, 2024 · Mobile Development
This article explains HarmonyOS long‑list rendering techniques, comparing the one‑time ForEach approach with the on‑demand LazyForEach method, and detailing cacheCount and @Reusable component reuse strategies, migration challenges from iOS/Android, ArkTS and C‑API implementations, and performance test results.
ArkTSHarmonyOSLazyForEach
0 likes · 17 min read

This article examines the challenges of rendering long lists on HarmonyOS across iOS, Android, and Web platforms, explains the ForEach and LazyForEach mechanisms, and presents practical ArkTS and C++ solutions—including cacheCount, component reuse, and performance optimizations—to achieve smoother UI and lower memory usage.
ArkTSC++HarmonyOS
0 likes · 19 min read

This article analyzes four major performance problems of UI rendering on HarmonyOS—excessive view hierarchy, long communication pipelines, poor list rendering, and secondary layout—and presents a C‑based native component solution with code examples to improve cross‑platform UI performance.
ArkTSC interfaceHarmonyOS
0 likes · 14 min read

This article examines four major performance bottlenecks when rendering UI on HarmonyOS—excessive view hierarchy, lengthy communication pipelines, poor list rendering, and secondary layout passes—and introduces a C‑language native interface solution that streamlines component integration, reduces overhead, and aligns HarmonyOS rendering with iOS and Android.
ArkTSC interfaceHarmonyOS
0 likes · 12 min read

This guide details how Sohu News integrated HarmonyOS push notifications—covering DevEco Studio setup, certificate generation, profile configuration, client ID metadata, permission requests, token retrieval, and handling cold‑ and hot‑start push data—using the HarmonyOS NEXT SDK and AppGallery Connect services.
AppGallery ConnectArkTSDevEco Studio
0 likes · 9 min read

This tutorial walks you through creating a basic HarmonyOS notepad application using the native ArkTS language and ArkUI components, covering project setup, directory structure, UI layout, routing, and implementing add‑and‑delete functionality with complete code examples.
ArkTSArkUIHarmonyOS
0 likes · 19 min read

This tutorial walks through the fundamentals of building ArkTS components for HarmonyOS, covering project setup, key decorators like @Entry and @Component, styling with @Styles and @Extend, handling events, managing properties and state, conditional rendering, functional components, and slot implementation.
ArkTSComponent DevelopmentHarmonyOS
0 likes · 18 min read

This article introduces HarmonyOS, its background, advantages, application forms, development benefits, distributed debugging, multi‑device adaptation, AI integration, the ArkTS language, ArkUI framework, Ability concept, ArkCompiler, and practical steps for setting up the DevEco Studio environment, helping developers quickly grasp the ecosystem and start building apps.
App DevelopmentArkTSDistributed OS
0 likes · 19 min read

After reviewing previous HarmonyOS articles that omitted UI, this piece explains the rationale for focusing on UI later, introduces ArkTS and the Stage model, and outlines the creation of a HarmonyOS UI scaffolding tool to streamline development across desktop and mobile platforms.
ArkTSHarmonyOSStage Model
0 likes · 7 min read


phodalFeb 26, 2024 · Mobile Development
This article explores how generative AI is integrated into the AutoDev tool to add ArkTS language support, automatically generate ArkUI pages, and migrate existing Android, iOS, and mini‑program code to HarmonyOS, while discussing technical challenges and future improvements.
ArkTSArkUIAutoDev
0 likes · 9 min read

The guide provides a complete introduction to HarmonyOS, explaining its distributed architecture and one‑time development model, detailing the DevEco toolchain, ArkTS language and ArkUI frameworks, walking through environment setup and a step‑by‑step first app, and covering advanced topics such as state management, componentization, testing, and publishing.
ArkTSArkUIDeclarative UI
0 likes · 17 min read

This guide provides a complete overview of HarmonyOS, its distributed architecture, development fundamentals, environment setup with DevEco Studio, ArkUI framework, code examples for UI, networking, data storage, permissions, state and thread management, testing, and publishing procedures for mobile developers.
ArkTSDevEco StudioHarmonyOS
0 likes · 23 min read

This article explains JD.com and Huawei's partnership to launch a HarmonyOS native JD app, details how the Taro front‑end framework adapts to HarmonyOS ArkTS and ArkUI, and provides a three‑part guide for developers to create their first HarmonyOS native application.
ArkTSCross-platform DevelopmentHarmonyOS
0 likes · 5 min read

This article thoroughly analyzes how the Taro front‑end framework is adapted to Huawei's HarmonyOS ArkTS by employing a runtime‑centric adaptation approach that maps Taro's virtual DOM to ArkTS UI components, reducing compile‑time conversion errors and improving developer experience.
ArkTSHarmonyOSTaRO
0 likes · 16 min read

By using ArkTS’s declarative UI features—@Entry, @Component, @Preview, struct‑based custom components, property chaining, Column layout, and a ForEach loop—this tutorial builds a TodoList where each ToDoItem toggles an isComplete state on click, automatically updating the view through state‑driven rendering.
ArkTSDeclarative UIFrontend Development
0 likes · 6 min read

ArkTS, Huawei’s evolution of JavaScript and TypeScript, provides a declarative UI framework with enhanced rendering, cross‑OS support, and streamlined state management through @State, @StorageLink, and AppStorage, enabling developers to build concise, high‑performance HarmonyOS applications using familiar JS/TS syntax.
ArkTSDeclarative UIFrontend Development
0 likes · 10 min read

To begin developing HarmonyOS apps with Huawei DevEco Studio, download and install the IDE and required SDKs, configure Node.js and OHPM, verify the environment, create a new Stage‑model project using the Empty Ability template, explore the generated ArkTS directory structure, compare it to Android projects, and run the app on an emulator.
ArkTSDevEco StudioHarmonyOS
0 likes · 6 min read
