We use essential cookies for the website to function, as well as analytics cookies for analyzing and creating statistics of the website performance. To agree to the use of analytics cookies, click "Accept All". You can manage your preferences at any time by clicking "Cookie Settings" on the footer. More Information.

Cookie Settings

Only Essential Cookies

Accept All

English

Products
Solutions
Events
Programs
Community
Training
Support

More

Search

Materials Console

Start

Getting Started

Application Development Overview

Preparations for Development

Building Your First HarmonyOS Application (ArkTS)

Development Fundamentals

Application Package Fundamentals

Application Package Overview

Application Package Structure

Application Package Development and Usage

Application Management

Application Installation, Uninstall, and Update

Consistency Verification for Application Installation and Update

Application Configuration Files

Application Configuration Files

app.json5 Configuration File

module.json5 Configuration File

Typical Scenarios Development

Creating a Static Shortcut of the Application

Creating an Application Clone

Creating an Application Multi-Instance

Configuring an Application Icon and Label

Converting HAR to HSP

Converting HSP to HAR

Converting HAP to HAR

Integrating bin Files into Application Packages (PC/2-in-1 Device)

Calling APIs Across HAR/HSP Modules on the Native Side

FAQs About Application Packages

Application Package Glossary

Resource Categories and Access

Getting Started with ArkTS

Introduction to ArkTS

ArkTS Coding Style Guide

Migration from TypeScript to ArkTS

ArkTS Migration Background

TypeScript to ArkTS Cookbook

Adaptation Cases

ArkTS Performant Programming Practices

Migration from Other Languages to ArkTS

Migrating from Java to ArkTS

Migrating from Swift to ArkTS

HarmonyOS Glossary

Development

Getting Prepared

Application Development Preparations

Application Framework

Application Models

Stage Model Development

Stage Model Development Overview

Stage Model Application Components

Application- or Component-Level Configuration (Stage Model)

UIAbility Component

UIAbility Overview

UIAbility Lifecycle

UIAbility Launch Type

UIAbility Usage

Data Synchronization Between UIAbility and UI Page

Starting UIAbility Within the Same Application

Cross-Device Migration Through Call Invocation

UIAbility Backup and Restore

ExtensionAbility Component

EmbeddedUIExtensionAbility

Using AppServiceExtensionAbility for Background Services

AbilityStage Component Manager

Matching Rules of Explicit Want and Implicit Want

Using Explicit Want to Start an Application Component

Common action and entities Values (Not Recommended)

Component Startup Rules (Stage Model)

Application Preloading

Obtaining Reasons for Abnormal Application Exits

Obtaining/Setting Environment Variables

Inter-Application Redirection

Overview of Application Redirection

Starting a Specified Application

Overview of Starting a Specified Application

(Optional) Using canOpenLink to Check Application Accessibility

Using Deep Linking for Application Redirection

Using App Linking for Application Redirection

Switching from Explicit Want Redirection to Linking Redirection

Application Link Description

Starting an Application of the Specified Type

Overview of Starting an Application of the Specified Type

Using startAbilityByType to Start a Navigation Application

Using startAbilityByType to Start an Email Application

Using mailto to Start an Email Application

Using startAbilityByType to Start a Financial Application

Using startAbilityByType to Start a Flight Application

Using startAbilityByType to Start an Express Delivery Application

Using startAbilityByType to Start an Image Editing Application

Using startAbility to Start a File Application

Starting a System Application

Process Model (Stage Model)

Thread Model (Stage Model)

Application Configuration File (Stage Model)

InsightIntent Framework Development

InsightIntent Framework Overview

Intent Development

Intent Development Overview

Developing Intents Using Configuration Files

Developing Intents Using Decorators

Appendix: Standard Intent Access Specifications

Debugging Intents

FA Model Development

FA Model Development Overview

Application- or Component-Level Configuration (FA Model)

PageAbility Overview

PageAbility Configuration

PageAbility Lifecycle

PageAbility Launch Type

Creating a PageAbility

Starting a Local PageAbility

Stopping a PageAbility

Starting a Specified Page

Window Properties

Requesting Permissions

Redirection Rules

ServiceAbility Overview

ServiceAbility Configuration

ServiceAbility Lifecycle

Creating a ServiceAbility

Starting a ServiceAbility

Connecting to a ServiceAbility

DataAbility Overview

DataAbility Component Configuration

DataAbility Lifecycle

Creating a DataAbility

Starting a DataAbility

Accessing a DataAbility

DataAbility Permission Control

Context (FA Model)

Want (FA Model)

Component Startup Rules (FA Model)

Process Model (FA Model)

Thread Model (FA Model)

Application Configuration File (FA Model)

Native Child Process Development

Creating/Terminating Native Child Processes (C/C++)

Obtaining Exit Information of Native Child Processes

Ability Kit Terminology

Accessibility Kit

Improving Accessibility Experience of Applications

Improving User Experience of Screen Reader

Screen Reading Scenarios with Content Specified

Scenarios Where the Screen Reading Focus Is Disabled

Multi-dimensional Nesting Scenarios

Multi-Component Scenarios

Button-annotated Scenarios

Screen Reading Scenarios of Illustrations/Videos/Animations

Scenarios Involving Dynamically Changed Content

Scenarios Involving Component Status Changes

Operating Error Scenarios

Multilingual Scenarios

Scenarios Involving Component Relocation

Scenarios Where a New Focus Position Is Set

Testing Accessibility Features of Applications

Testing Screen Reader

Unified Data Definition

Unified Data Definition Overview

Uniform Data Structs (ArkTS)

Uniform Data Structs (C/C++)

Content Cards Based on Uniform Data Structs (ArkTS)

Application Data Persistence

Application Data Persistence Overview

Persisting User Preferences (ArkTS)

Persisting User Preferences (C/C++)

Persisting KV Store Data (ArkTS)

Persisting RDB Store Data (ArkTS)

Persisting RDB Store Data (C/C++)

Persisting Vector Store Data (ArkTS)

Persisting Vector Store Data (C/C++)

Distributed Application Data Sync

Overview of Cross-Device Application Data Sync

Cross-Device Sync of KV Stores (ArkTS)

Cross-Device Sync of RDB Stores (ArkTS)

Cross-Device Sync of Distributed Data Objects (ArkTS)

Same-App Data Synchronization (Distributed)

Overview of Device-Cloud Data Sync for the Same App

Deploying the Cloud Environment for Device-Cloud Data Sync

Developing RDB Store for Device-Cloud Data Synchronization (ArkTS)

Data Reliability and Security

Data Reliability and Security Overview

Database Backup and Restore (ArkTS)

Database Backup and Restore (C/C++)

Database Encryption (ArkTS)

Database Encryption (C/C++)

Access Control by Device and Data Level (ArkTS)

Access Control by Device and Data Level (C/C++)

Using an EL5 Database (ArkTS)

Cross-Application Data Sharing

Overview of Cross-Application Data Sharing

One-to-Many Data Sharing

Sharing Configurations Between Applications (ArkTS)

Many-to-Many Data Sharing

Sharing Data via Unified Data Channels (ArkTS)

Sharing Data via Unified Data Channels (C/C++)

Application Data Vectorization (ArkTS)

ArkData Debugging Tool

Preferences Database Debugging Tool Guide

vector-store Database Debugging Tool Guide

SQLite Debugging Tool

ArkData Glossary

ArkTS Common Library

Overview of the ArkTS Common Library

XML Generation, Parsing, and Conversion

Buffer and FastBuffer

JSON Extension Library

ArkTS Container Library

Overview of the ArkTS Container Library

Linear Containers

Nonlinear Containers

ArkTS Concurrency

Overview of Concurrency

Asynchronous Concurrency (Promise and Async/Await)

Multithreaded Concurrency

Overview of Multithreaded Concurrency

Comparison Between TaskPool and Worker

Inter-Thread Communication

Overview of ArkTS Inter-Thread Communication

Inter-Thread Communication Objects

Overview of Inter-Thread Communication Objects

Container Object

ArrayBuffer Object

SharedArrayBuffer Object

Transferable Object (NativeBinding Object)

Sendable Object

Overview of Sendable Objects

Usage Rules and Constraints for Sendable

Asynchronous Lock

Asynchronous Waiting

ASON Parsing and Generation

Shared Container

Freezing Sendable Objects

Use Scenarios of Sendable

Communication Between Threads

Using TaskPool for Independent Time-consuming Tasks

Using TaskPool for Multiple Time-consuming Tasks

Communication Between the TaskPool Task and Host Thread

Real-Time Communication Between the Worker Thread and Host Thread

Synchronous Calls to Host Thread Interfaces from Worker

High-Performance Communication Between Multi-Level Workers

Multithreaded Development

Overview of Multithreaded Development

Concurrency in Time-Consuming Tasks

Overview of Concurrency in Time-Consuming Tasks

CPU Intensive Task Development (TaskPool and Worker)

I/O Intensive Task Development (TaskPool)

Synchronous Task Development (TaskPool and Worker)

Concurrency in Continuous Tasks

Overview of Concurrency in Continuous Tasks

Continuous Task Development (TaskPool)

Concurrency in Resident Tasks

Overview of Concurrency in Resident Tasks

Resident Task Development (Worker)

Multithreaded Development Practice Cases

Batch Database Operations

Concurrent Loading of Service Modules

Global Configuration

ArkUI Data Updates

C++ Inter-Thread Data Sharing

Specifying Task Concurrency with TaskPool

ArkUI Waterfall Rendering

Obtaining the Recently Accessed List

Canceling Tasks in Multithreading with TaskPool

Multithreaded Operations with Custom Native Transferable Objects

Multithreaded Operations with Custom Native Sendable Objects

Persistent Worker Threads Handling Concurrent Tasks via TaskPool

Common Concurrency Issues

ArkTS Cross-Language Interaction

Overview of ArkTS Runtime

ArkTS Modularization

Overview of Modular Operation

Dynamically Loading Native Modules in Synchronous Mode

Statically Loading Native Modules

Loading Modules Using Node-API

Side Effects and Optimization of Module Loading

Modularization Debugging Tools

ArkTS Runtime FAQs

ArkTS Compilation Toolchain

Overview of the ArkTS Compilation Toolchain

Overview of Ark Bytecode

Ark Bytecode File Format

Ark Bytecode Fundamentals

Naming Conventions for Ark Bytecode Functions

Customizing Ark Bytecode During Compilation

Ark Bytecode Generation FAQs

ArkGuard for Source Code Obfuscation

Overview of ArkGuard for Source Code Obfuscation

ArkGuard Principles and Capabilities for Source Code Obfuscation

Using ArkGuard for Source Code Obfuscation

Package-specific Source Code Obfuscation Recommendations

Common Issues with ArkGuard in Source Code Obfuscation

ArkGuard for Bytecode Obfuscation

Overview of ArkGuard for Bytecode Obfuscation

ArkGuard Principles and Capabilities for Bytecode Obfuscation

Using ArkGuard for Bytecode Obfuscation

Package-specific Bytecode Obfuscation Recommendations

Common Issues with ArkGuard in Bytecode Obfuscation

Configuring arkOptions in build-profile.json5

UI Development (ArkTS-based Declarative Development Paradigm)

UI Development (ArkTS-based Declarative Development Paradigm) Overview

Basic Syntax of UI Paradigms

Basic Syntax Overview

UI Decorator Overview

Declarative UI Description

Custom Components

Creating a Custom Component

Custom Component Lifecycle

Lifecycle of a Custom Component (Recommended)

Custom Component Layout

Constraints on Access Modifiers of Custom Component Member Variables

Custom Component Reuse

@Reusable Decorator: Reusing V1 Components

@ReusableV2 Decorator: Reusing V2 Components

Global Reuse: Centralized Component Recycling and Reuse

Development Practices of Custom Component Reuse

Diagnosis and Analysis of Component Reuse Issues

Custom Component Freezing

Freezing a Custom Component (V1)

Freezing a Custom Component (V2)

Component Encapsulation

Component Extension

Component Extension Overview

@Builder Decorator: Custom Builder Function

@LocalBuilder Decorator: Maintaining Component Relationships

@BuilderParam Decorator: Referencing the @Builder Function

wrapBuilder: Encapsulating Global @Builder

mutableBuilder: Implementing Dynamic Update of Global @Builder

@Styles Decorator: Defining Reusable Component Styles

@Extend Decorator: Defining Extended Component Styles

stateStyles: Applying Polymorphic Styles

@AnimatableExtend Decorator: Defining Animatable Properties

@Require Decorator: Validating Constructor Input Parameters

UI Paradigm State Management

State Management Overview

State Management Principles

Differences Between State Management V1 and V2 Update Mechanisms

State Management V1

Component State Management

@State Decorator: State Owned by Component

@Prop Decorator: Implementing One-Way Synchronization from Parent to Child Components

@Link Decorator: Implementing Two-Way Synchronization Between Parent and Child Components

@Provide and @Consume Decorators: Two-Way Synchronization with Descendant Components

@Observed and @ObjectLink Decorators: Observing Property Changes in Nested Class Objects

@Watch Decorator: Getting Notified of State Variable Changes

Data Object State Management

@Track Decorator: Implementing Class Object Property-Level Updates

Application State Management

Application State Management Overview

LocalStorage: Storing Page-Level UI State

AppStorage: Storing Application-wide UI State

PersistentStorage: Persisting UI State

Environment: Querying the Device Environment

State Management V2

Component State Management

@Local Decorator: Representing the Internal State of Components

@Param Decorator: Inputting External Parameters to Components

@Once: Implementing Initialization Once

@Event Decorator: Standardizing Component Output

@Provider and @Consumer Decorators: Synchronizing Across Component Levels in a Two-Way Manner

Data Object State Management

@ObservedV2 and @Trace Decorators: Observing Property Changes in Classes

@Monitor Decorator: Listening for Value Changes of the State Variables

@SyncMonitor Decorator: Synchronous Listening for Value Changes of the State Variables

@Computed Decorator: Declaring Computed Properties

@Type Decorator: Marking the Types of the Class Property

Application State Management

AppStorageV2: Storing Application-wide UI State

PersistenceV2: Persisting UI States

getTarget API: Obtaining Original Objects

makeObserved API: Changing Unobservable Data to Observable Data

canBeObserved API: Determining Whether an Object Can Be Observed

addMonitor and clearMonitor APIs: Dynamically Adding and Removing Listeners

applySync/flushUpdates/flushUIUpdates APIs: Synchronous Update

$$ Syntax: Implementing Two-Way Synchronization for Built-in Components

!! Syntax: Enabling Two-Way Binding

State Management V1 to V2 Migration Guide

V1 to V2 Migration Overview

State Management V1 to V2 Migration

Migration for Component State Variables

Migration for Data Object State Variables

Migration for In-Application State Variables

Migration for Component Reuse

Migration for Repeated Content Rendering

Migration for Built-in Objects

Widget State Variable Migration

Migration for AnimateTo Usage

Mixed Use of State Management V1 and V2

Guidelines for Mixed Use of State Management V1 and V2 (Before API Version 19)

Mixed Use of State Management V1 and V2 (API Version 19 and Later)

State Management Development

In-Component State Management FAQs

Data Object State Management FAQs

In-App State Management and Other FAQs

Common Methods for Locating the Problem That Component Refresh Is Not Triggered When State Variables Change

State Management Terms

UI Paradigm Rendering Control

Rendering Control Overview

if/else: Conditional Rendering

ForEach: Rendering Repeated Content

LazyForEach: Lazy Data Loading

Repeat: Reusing Components for Repeated Content Rendering

ContentSlot: Enabling Hybrid Development

Learning Responsive Environment Variables

@Env: Environment Variable

@CustomEnv: Custom Environment Variable

Setting Component Navigation and Page Routing

Component Navigation and Page Routing Overview

Component Navigation (Navigation) (Recommended)

Navigation Architecture

Transition Animation

Cross-Package Routing

Split-View Layout

Page Routing (@ohos.router) (Not Recommended)

Transition from Router to Navigation

Component Layouts

Layout Overview

Building a Layout

Linear Layout (Row/Column)

Stack Layout (Stack)

Flex Layout (Flex)

Relative Layout (RelativeContainer)

Responsive Grid Layout (GridRow/GridCol)

Dynamic Layout (DynamicLayout)

Container Breakpoint (ContainerReader)

Using Tabs (Tabs)

Immersive Effect Development

Layout Optimization

Lists and Grids

List and Grid Overview

Creating a List (List)

Creating an Arc List (ArcList) (Recommended for Circular Screens)

Creating a Grid (Grid/GridItem)

Grid Item Drag-and-Drop

Creating a Waterfall Flow (WaterFlow)

Common Waterfall Operations

Creating Lazy Layouts (LazyColumnLayout/LazyVGridLayout/LazyVWaterFlowLayout)

Creating a Lazy Custom Layout (LazyDynamicLayout)

Common List Views

Introduction to Text

Text Display (Text/Span)

Text Input (TextInput/TextArea/Search)

Rich Text Editing (RichEditor)

Symbol Glyph (SymbolGlyph/SymbolSpan)

Styled String (StyledString/MutableStyledString)

Text and Image Layout

Soft Keyboard Management

Selection and Development of Rich Text Display

Text Expansion and Collapse

Custom Keyboard

Image Display (Image)

Video Playback (Video)

Creating a Swiper (Swiper)

Creating an Arc Carousel Component (ArcSwiper) (Recommended for Circular Screens)

colorFilter-based Image Filter Effect

Image Resizing with the resizable Attribute

Buttons and Selections

Button and Selection Component Overview

Arc Button (ArcButton) (Recommended for Circular Screens)

Radio Button (Radio)

Adding a Component

Custom Rendering (XComponent)

Progress Indicator (Progress)

Using Popup Windows

Popup Window Overview

Dialog Boxes (Dialog)

Dialog Overview

Global Custom Dialog Box Independent of UI Components (openCustomDialog)

Basic Custom Dialog (CustomDialog)

Fixed-Style Dialog Box

Page-Level Dialog Box

Dialog Box Layer Management

Dialog Controller

Dialog Box Focus Policy

Dialog Mask Control

Menu Control (Menu)

Global Menu Independent of UI Components (openMenu)

Global Popup Independent of UI Components (openPopup)

Binding Modal Pages

Modal Page Overview

Binding a Semi-Modal Sheet (bindSheet)

Binding a Full-Modal Page (bindContentCover)

Using Toasts (Toast)

Managing Overlays (OverlayManager)

Custom Dialog Selection and Development

Immersive Light Sense

Geometric Shapes

Geometric Shape Drawing Overview

Drawing Geometric Shapes (Shape)

Clipping Shapes (clipShape)

Implementing Interaction Responses

Interaction Response Overview

Interaction Mechanism Overview

Input Devices and Events

Handling Touchscreen Input Events

Handling Mouse Input Events

Handling Touchpad Input Events

Handling Keyboard Input Events

Handling Gamepad Input Events

Handling Crown Events

Supporting Smart Gesture Input Events

Implementing Gesture Responses

Gesture Binding

Combined Gestures

Multi-level Gesture Events

Gesture Conflict Handling

Implementing Unified Drag and Drop

Implementing Focus Support

Using Animation

Animation Overview

Property Animation

Property Animation Overview

Implementing Property Animation

Custom Property Animation

Transition Animation

Transition Animation Overview

Enter/Exit Transition

Modal Transition

Shared Element Transition

Rotation Transition Animation

Page Transition Animation (Not Recommended)

Particle Animation

Component Animation

Animation Curve

Animation Curve Overview

Traditional Curve

Animation Smoothing

Animation Effects

Comparison Between Dynamic Blur and Static Blur

Efficient Use of Blur

Frame Freezing and Blurring Troubleshooting

Frame Animation (ohos.animator)

Optimizing Animation Performance

Using Customization Capabilities

Customization Capability Overview

Custom Composition

Custom Node Overview

Custom Placeholder Nodes

Custom Component Node (FrameNode)

Custom Render Node (RenderNode)

Custom Declarative Node (BuilderNode)

Setting Custom Node Cross-Language Attributes

Dynamic Component Creation

Drawing Custom Shapes on Canvas (Canvas)

Custom Drawing Modifier (DrawModifier)

Custom Extension Capability Overview

Content Modifier (ContentModifier)

Attribute Modifier (AttributeModifier)

Attribute Updater (AttributeUpdater)

Implementing UI Internationalization

Implementing Accessibility and Aging-Friendly Design

Accessibility Development

Supporting Aging-Friendly Design

Setting the Theme

Implementing Dark and Light Mode Adaptation

Configuring In-Application Theme Skinning

UI Scene-based Capabilities

Using the UI Context API for UI Operations (UIContext)

Using Component Snapshot (ComponentSnapshot)

Long Screenshot

Detecting Component Visibility

Inspecting Page Layouts

Media Query (@ohos.mediaquery)

Using Embedded Components

Atomic Service Full Screen Launch Component (FullScreenLaunchComponent)

In-Application Embedded Component (EmbeddedComponent)

Using NDK APIs to Build UIs

NDK-Based UI Development Overview

NDK Interconnection with ArkTS

Embedding ArkTS Components

Integrating with ArkTS Pages

Building a Layout

Using Layout Components

Setting Common Layout Attributes

Using Navigation Components

Implementing a List Layout

Implementing a Waterfall Flow Layout

Using the Text Component

Using Styled Strings

Adding a Text Event Listener for a Text Box

Image Display (Image)

Using the Swiper Container

Building Form Components

Building a Dialog Box

Using Animation

Animation Overview

Animation Development

Using Selection Components

Using the Sliding Selector (Picker)

Adding Event Responses

Adding an Event Listener

Binding Basic Input Events

Binding Gesture Events

Binding Drag Events

Using Customization Capabilities

Building Custom Components

Integrating Accessibility Through Custom Drawing

Launching EmbeddedUIExtensionAbility with EmbeddedComponent

Querying and Operating Custom Nodes

Ensuring Multi-Instance Functionality in the NDK

Parallelizing UI Page Building Using Multi-threaded NDK APIs

Building a Rendering Node

UI Development (JavaScript-compatible Web-like Development Paradigm)

UI Development (JavaScript-compatible Web-like Development Paradigm) Overview

Framework Overview

File Organization

Resource Limitations and Access

Multi-Language Capability

Building the UI

Component Overview

Building a Layout

Layout Description

Adding Title and Paragraph Text

Adding an Image

Adding a Comment Area

Adding a Container

Adding Interactions

Developing Animations

Defining Gesture Events

Defining Page Routes

Common Component Development

Container Component Development

list Development

dialog Development

form Development

stepper Development

tabs Development

swiper Development

Basic Component Development

text Development

input Development

button Development

picker Development

image Development

image-animator Development

rating Development

slider Development

chart Development

switch Development

toolbar Development

menu Development

marquee Development

qrcode Development

search Development

Canvas Development

CanvasRenderingContext2D

OffscreenCanvasRenderingContext2D

SVG Development

Animation Development

Attribute Style Animation

Animation with the transform Attribute

Animation with the background-position Attribute

Animation for SVG Components

JavaScript Animation

Component Animation

Interpolator Animation

Animation Effect

Animation Frame

Custom Components

Using WebGL to Draw Graphics

UI Debugging and Optimization

UI Stability Issue Debugging

UI Stability Issue Analysis Overview

Common UI-Related Application Crash Issues

Common UI Application Freezing Issues

Debugging UI Display Exceptions

UI Context Debugging

High-Performance UI Development

UI Development FAQs

FAQs About Navigation Animation

FAQs About Custom Nodes

FAQs About Buttons and Selection Components

Popup Component FAQs

FAQs About Text Components

FAQs About Dynamic Attribute Setting

FAQs About Imperative Nodes

FAQs About UI Parallelization

Common Gesture Event Conflicts

FAQs About Immersive Light Sense

Window Overview

Window Type Development Overview

Subwindow Development

Dialog Window Development

Global Floating Window Development

Using PiP in Applications

PiP Development Overview

Using XComponent to Develop PiP (ArkTS)

Using typeNode to Develop PiP (ArkTS)

Using NDK APIs to Develop PiP (C/C++)

Global Floating Ball Development

Adapting Your App to Multi-Window

Introduction to Multi-Window

Adaptation to Multi-Window

Declaring the Support for Multi-Window

Adapting the Application Layout to Multi-Window

Implementing the Avoid Area for the Window-top Control Bar

Window Mode Overview

Freeform Window

Freeform Window Overview

App Adaptation for Freeform Windows

Basic Window Capabilities

Window Lifecycle

Window Rotation and Practical Cases

Window Rotation

Window Rotation Practical Cases

Immersive Window

Other Development Scenarios

Screenshot and Privacy Mode (ArkTS)

Controlling Brightness and Always-On (ArkTS)

Setting Window Animation Effects (ArkTS)

Controlling Window Appearance (ArkTS)

Using WindowManager to Manage Multimodal Input Events (C/C++)

Configuring and Using the Application Starting Window

Application Starting Window Overview

Configuring the Application Starting Window

Configuring Starting Window Resources

Window Metadata Configuration

Window Development FAQs

Common Log Issues and Troubleshooting in Window Development

Display Management

Display Management Overview

Using OH_DisplayManager to Obtain Basic Display Information and Listen for Status Changes (C/C++)

Using Display to Obtain Display Properties and Listen for Status Changes (ArkTS)

Display Development FAQs

Lifecycle of the Web Component

Setting Basic Attributes and Events

Developing User-Agent

Managing Cookies and Data Storage

Setting Dark Mode

Opening Pages in a New Window

Managing Location Permissions

Using Incognito Mode

Using Motion and Orientation Sensors

Web Rendering and Layout

Rendering Modes of the Web Component

Fitting In the Page Content Layout

Optimizing the Page Flash During the Redirection

Obtaining the Web Page Content Height

Using Frontend Page JavaScript Code on the Application

Invoking Frontend Page Functions on the Application

Invoking Application Functions on the Frontend Page

Establishing a Data Channel Between the Application and the Frontend Page

Mutual Invoking Between the Application and the Frontend Page (C/C++)

Establishing a Data Channel Between the Application and the Frontend Page (C/C++)

Managing Web Page Interactions

Implementing Nested Scrolling

Implementing Content Scrolling

Docking to the Soft Keyboard

Interacting with Applications Using Gestures

Zooming Web Pages

Displaying Web Page Dialog Boxes

Interacting with Web Pages Using the Drag-and-Drop Feature of the Web Component

Managing Cyber Security and Privacy for the Web Component

Resolving Cross-Origin Resource Access

Intelligent Tracking Prevention

Using the Ad Blocking Feature

Using Secure Shield Mode

Managing Web Page Loading and Browsing Records

Loading Web Pages

Managing Page Redirection and Browsing History Navigation

Intercepting Network Requests Initiated by the Web Component

Customizing Page Request Responses

Accelerating Web Page Access

Setting the Backward-Forward Cache

Migrating Web Components Between Different Windows

Managing Web Page File Upload and Download

Uploading Files

Downloading Files

Using Web Multimedia

Starting a Camera and Microphone

Taking Over the Media Playback on Web Pages

Enabling Picture-in-Picture

Enabling Immersive Full-Screen Video Playback

Processing Web Page Content

Printing Frontend Pages

Saving a Frontend Page as a PDF File

Previewing PDF Files

Calculating and Adjusting Safe Area Insets

Using Web Component Menus to Process Web Content

Processing Web Page Content by Interacting with the System Clipboard

Using Smart Text Data Detector

Same-Layer Rendering

Using Same-Layer Rendering

Using Offline Web Components

Using WebNativeMessagingExtensionAbility to Implement Communication Between Browser Extensions and Applications

Debugging Frontend Pages by Using DevTools

Using Crashpad to Collect Web Component Crash Information

Troubleshooting White Screen Issues on Web Pages

Locating Web Page Loading Issues

Background Tasks Kit

Transient Task (ArkTS)

Transient Task (C/C++)

Continuous Task (ArkTS)

Deferred Task (ArkTS)

Agent-powered Reminder (ArkTS)

Background Tasks Kit Integration Specifications

Content Embed Kit

Client-Server Interaction Process

Server Application Development

Client Application Development

Content Embed Kit FAQs

Content Embed Kit Terminology

Application Files

Application File Overview

Application Sandbox

Application File Access and Management

Accessing Application Files (ArkTS)

Accessing Application Files (C/C++)

Obtaining Application and File System Space Statistics

Sharing an Application File

Configuring the Application Shared Directory

Application Data Backup and Restore

Application Data Backup and Restore Overview

Accessing Backup and Restore

Verification Guide for App Data Backup and Restore

Adaptation Guide for Application Clone

Adaptation Guide for Data Migration During Device Upgrade

Introduction to Application Data Migration

Adaptation Process

Application Data Migration and Adaptation

Verifying the Application Data Migration

Developer Self-Verification

E2E Verification

Precautions for Code Development During Application Upgrade

User File Overview

FileUri Development (C/C++)

Obtaining the User Directory Environment (C/C++)

Selecting and Saving User Files

Selecting User Files

Saving User Files

Persisting Temporary Permissions

Persisting Temporary Permissions (C/C++)

Obtaining and Accessing a User Directory

Distributed File System

Distributed File System Overview

Setting the Security Level of a Distributed File

Sharing and Accessing Files Across Devices

Copying Files Across Devices

Device-Cloud File Sync

Device-Cloud File Sync Overview

Device-Cloud File Sync Integration

File Compression and Decompression

Compression and Decompression Overview

Archive File Compression and Decompression (C/C++)

Streaming Compression and Decompression (C/C++)

Buffer Compression and Decompression (C/C++)

Basic File Service Development

Accessing Files on the Native Side

Data Augmentation Kit

Knowledge Processing

RAG Configuration

Configuring a Prompt Template

Configuring Hyperparameters

Configuring a Thought Template

Complete Sample Code

Intelligent Data Retrieval

Intelligent Data Retrieval (C/C++)

On-Device Q&A Model

Data Augmentation Kit Glossary

On-Device Q&A Model Glossary

ArkTS Widget Development (Recommended)

ArkTS Widget Overview

Creating an ArkTS Widget

Configuring ArkTS Widget Configuration Files

Managing ArkTS Widget Lifecycle

ArkTS Widget Process Model

ArkTS Widget Provider Development

ArkTS Widget UI Development

Overview of ArkTS Widget UI Development

Using Animations in ArkTS Widgets

Using Canvas in ArkTS Widgets

Using Custom Fonts in ArkTS Widgets

ArkTS Widget Update

Overview of ArkTS Widget Update

Active Update of ArkTS Widgets

Passive Update of ArkTS Widgets

Push Updates for ArkTS Widgets

Updating Local and Online Images in the Widget

Updating Widget Content by State

ArkTS Widget Page Interaction

Overview of ArkTS Widget Page Interaction

Redirecting to an Application Page (router Event)

Launching UIAbility to the Background (call Event)

Transferring Messages to an Application (message Event)

Updating Widget Content Through the router or call Event

Editing ArkTS Widgets

Adding ArkTS Widgets to the Home Screen from Within an App

ArkTS Lock Screen Widget

ArkTS Transparent Widget

Standby Screen Widgets

Interactive Widget Development

Overview of Interactive Widgets

Developing a Fun-based Widget

Developing a Scene-based Widget

ArkTS Widget Best Practices

Widget Updates and Data Interaction

ArkTS Widget Adaptation FAQs

JS Widget Development

JS Widget Overview

Developing a JS Widget (Stage Model)

Developing a JS Widget (FA Model)

Implementing an Input Method Application

Using the Input Method in a Custom Edit Box

Switching Between Input Methods

Setting Input Method Subtypes

Security Mode of the Input Method

Using the Input Method in a Custom Edit Box (C/C++)

Immersive Mode of the Input Method Application

Input Box and Input Method Interaction in Non-Focusable Windows

IPC and RPC Development (ArkTS)

IPC and RPC Development (C/C++)

Subscribing to State Changes of a Remote Object

Localization Kit

Application Internationalization

UI Design for Internationalization

Locale ID and Cultural Habit Division

Language and User Preferences

System Language and Region

Preferred Language

User Preferences

Date and Time Formatting

Number and Unit of Measurement Formatting

Phone Number Formatting

Calendar Setting

Time Zone and DST Setting

Time Zone Setting

Multilingual Sorting

Overview of Multilingual Sorting

Sorting by Local Habits

Sorting by Indexes

Character Processing

Name Localization

Language and Locale Name Localization

Application Localization

Multilingual Adaptation

Application Translation

Hard Coding and Concatenation Prevention

Scene and Context Clarification for Translation

Singular/Plural Form Selection

Localization Testing

Pseudo-Localization Testing

Overview of Pseudo-Localization Testing

Pseudo-Localization Testing for Translation

Pseudo-Localization Testing for UI Mirroring

Linguistic Testing

Icon Processing

(Recommended) Layered Icon Processing

Single-Layer Icon Processing

Component Navigation

Setting the Dynamic Blur Style

Setting the Message Reminder

Configuring the Custom Area

Dynamically Displaying and Hiding the Title Bar

Configuring the Sheet Style

Setting the Icon Type

Configuring In-App Multi-Window

Development Example

Configuring the Sidebar in Overlay Mode

Configuring the Sidebar in Embed Mode

Sidebar Menu Style

Setting Tab Bar Dividers

Setting the Tab Bar Blur Style

Configuring the Tab Icon Bleed Style

Configuring the Sidebar Half-Screen-based Center-Aligned Style

Setting the Tab Bar Floating Style

Immediate Operation

Configuring a Persistent Notification Pop-up

Configuring a Scheduled Notification Pop-up

Key Operation Bar

Configuring a Component with a Primary Button

Configuring a Component Without a Primary Button

Configuring the List Style with Horizontal Swipe Animation

Configuring the List Card Style

Loading a Custom Symbol for an App

Point-Light Effect

Shadow Effect upon a Press

Dual-Edge Flowing Light Effect

Background Flowing Light Effect

Dual-Edge Flowing Light with a Background

In-App Multi-Window

Immersive Light

Color Selection and Favorites Management

How Do I Obtain the layeredDrawableDescriptor Object Information?

What Are the Possible Causes and Solutions for 401 Parameter Check Failure?

System

Application Access Control

Access Control Overview

Application Permission Management

Application Permission Management Overview

Requesting Application Permissions

Workflow for Requesting Permissions

Declaring Permissions

Requesting User Authorization

Requesting User Authorization for the Second Time

Requesting One-Time User Authorization

Manual Authorization

Requesting Restricted Permissions

Application Permissions

Open system_grant Permissions

Open user_grant Permissions

Restricted Permissions

Permissions for Enterprise Applications

Permissions for MDM Applications

Application Permission Groups

FAQs About Application Access Control

Removing Requested Permissions

FAQs About Packet Capture/Debugging Permission

Using Security Components

Security Component Overview

Using PasteButton

Using SaveButton

Using System Pickers

Password Vault Service

Overview of the Password Autofill Service

Accessing Password Vault for an Application

Quick Adaptation

Autosave of Accounts and Passwords

Updates of Accounts and Passwords

Autofill of Accounts and Passwords

Autofill of Strong Passwords

Suggestions on Automatically Generating Strong Passwords for Applications

Adaptation Suggestions for Custom Layouts

Adaptable Scenarios

Adding Password Vault for Web Pages

Sharing Account Data Between Applications and Web Pages

Application Encryption

Asset Store Kit

Protecting Asset Data

Protecting Asset Data with User Authentication

Asset Store Kit Development (ArkTS)

Adding an Asset (ArkTS)

Removing Assets (ArkTS)

Updating an Asset (ArkTS)

Querying Assets (ArkTS)

Querying an Asset with User Authentication (ArkTS)

Adding Assets in Batches (ArkTS)

Removing Assets in Batches (ArkTS)

Updating Assets in Batches (ArkTS)

Managing Assets in a Group (ArkTS)

Syncing Assets (Backup and Restore) (ArkTS)

Asset Store Kit Development (C/C++)

Adding an Asset (C/C++)

Removing Assets (C/C++)

Update an Asset (C/C++)

Querying Assets (C/C++)

Managing Assets in a Group (C/C++)

Syncing Assets (Backup and Restore) (C/C++)

Confidential Space Kit

Running a Data App to Process Data

Crypto Architecture Kit

Key Generation and Conversion

Key Generation and Conversion Overview

Key Generation and Conversion Specifications

Symmetric Key Generation and Conversion Specifications

Asymmetric Key Generation and Conversion Specifications

Key Generation and Conversion Development

Randomly Generating a Symmetric Key (ArkTS)

Randomly Generating a Symmetric Key (C/C++)

Converting Binary Data into a Symmetric Key (ArkTS)

Converting Binary Data into a Symmetric Key Pair (C/C++)

Randomly Generating an Asymmetric Key Pair (ArkTS)

Randomly Generating an Asymmetric Key Pair (C/C++)

Converting Binary Data into an Asymmetric Key Pair (ArkTS)

Converting Binary Data into an Asymmetric Key Pair (C/C++)

Generating an Asymmetric Key Pair Based on Key Parameters (ArkTS)

Generating an Asymmetric Key Pair Based on Key Parameters (C/C++)

Converting a Compressed or Uncompressed ECC Public Key (ArkTS)

Converting a Compressed or Uncompressed ECC Public Key (C/C++)

Converting Compressed or Uncompressed ECC Point Data (ArkTS)

Converting Compressed or Uncompressed ECC Point Data (C/C++)

Converting a PEM String into an Asymmetric Key Pair (ArkTS)

Converting a PEM String into an Asymmetric Key Pair (C/C++)

Encoding and Decoding with an RSA Private Key (ArkTS)

Encoding and Decoding with an RSA Private Key (C/C++)

Obtaining a Public Key from a Private Key (ArkTS)

Obtaining a Public Key from a Private Key (C/C++)

Encryption and Decryption

Encryption and Decryption Overview

Encryption and Decryption Algorithm Specifications

Symmetric Key Encryption and Decryption Algorithm Specifications

Asymmetric Key Encryption and Decryption Algorithm Specifications

Encryption and Decryption by Segment

Encryption and Decryption Development

Encryption and Decryption with an AES Symmetric Key (GCM Mode) (ArkTS)

Encryption and Decryption with an AES Symmetric Key (GCM Mode) (C/C++)

Encryption and Decryption with an AES Symmetric Key (CCM Mode) (ArkTS)

Encryption and Decryption with an AES Symmetric Key (CCM Mode) (C/C++)

Encryption and Decryption Using an AES Symmetric Key (CCM Mode) with AeadParamsSpec (ArkTS)

Encryption and Decryption with an AES Symmetric Key (CBC Mode) (ArkTS)

Encryption and Decryption with an AES Symmetric Key (CBC Mode) (C/C++)

Encryption and Decryption with an AES Symmetric Key (ECB Mode) (ArkTS)

Encryption and Decryption with an AES Symmetric Key (ECB Mode) (C/C++)

Encryption and Decryption by Segment with an AES Symmetric Key (GCM Mode) (ArkTS)

Encryption and Decryption with an AES Symmetric Key (XTS Mode) (ArkTS)

Encryption and Decryption by Segment with an AES Symmetric Key (GCM Mode) (C/C++)

Encryption and Decryption with a DES Symmetric Key (ECB Mode) (ArkTS)

Encryption and Decryption with a DES Symmetric Key (ECB Mode) (C/C++)

Encryption and Decryption with a 3DES Symmetric Key Pair (ArkTS)

Encryption and Decryption with a 3DES Symmetric Key Pair (C/C++)

Encryption and Decryption with an SM4 Symmetric Key (ECB Mode) (ArkTS)

Encryption and Decryption with an SM4 Symmetric Key (ECB Mode) (C/C++)

Encryption and Decryption with an SM4 Symmetric Key (CBC Mode) (ArkTS)

Encryption and Decryption with an SM4 Symmetric Key (CBC Mode) (C/C++)

Encryption and Decryption with an SM4 Symmetric Key (GCM Mode) (ArkTS)

Encryption and Decryption with an SM4 Symmetric Key (GCM Mode) (C/C++)

Encryption and Decryption by Segment with an SM4 Symmetric Key (GCM Mode) (ArkTS)

Encryption and Decryption by Segment with an SM4 Symmetric Key (GCM Mode) (C/C++)

Encryption and Decryption with a ChaCha20 Symmetric Key Pair (ArkTS)

Encryption and Decryption with a ChaCha20 Symmetric Key Pair (C/C++)

Encryption and Decryption with a ChaCha20 Symmetric Key Pair (Poly1305) (ArkTS)

Encryption and Decryption with a ChaCha20 Symmetric Key Pair (Poly1305) (C/C++)

Encryption and Decryption with an RSA Asymmetric Key Pair (PKCS1) (ArkTS)

Encryption and Decryption with an RSA Asymmetric Key Pair (PKCS1) (C/C++)

Encryption and Decryption by Segment with an RSA Asymmetric Key Pair (ArkTS)

Encryption and Decryption by Segment with an RSA Asymmetric Key Pair (C/C++)

Encryption and Decryption with an RSA Asymmetric Key Pair (PKCS1_OAEP)

Encryption and Decryption with an SM2 Asymmetric Key Pair (ArkTS)

Encryption and Decryption with an SM2 Asymmetric Key Pair (C/C++)

Encryption and Decryption of Symmetric Keys with AES-WRAP (ArkTS)

Encryption and Decryption of Symmetric Keys with AES-WRAP (C/C++)

Converting SM2 Ciphertext (ArkTS)

Converting SM2 Ciphertext (C/C++)

Encryption and Decryption with an RC2 Symmetric Key (CBC Mode) (ArkTS)

Encryption and Decryption with an RC4 Symmetric Key (ArkTS)

Encryption and Decryption Using ECIES (ArkTS)

Encryption and Decryption Using ECIES (C/C++)

Signing and Signature Verification

Signing and Signature Verification Overview and Algorithm Specifications

Signing and Signature Verification Development

Signing and Signature Verification with an RSA Key Pair (PKCS1 Mode) (ArkTS)

Signing and Signature Verification with an RSA Key Pair (PKCS1 Mode) (C/C++)

Signing and Signature Verification with an RSA Key Pair (PKCS1 Mode) (OnlySign and OnlyVerify Modes) (ArkTS)

Signing and Signature Recovery Using an RSA Key Pair (PKCS1 Mode) (ArkTS)

Signature Recovery Using an RSA Key Pair (PKCS1 Mode) (C/C++)

Signing and Signature Verification by Segment with an RSA Key Pair (PKCS1 Mode) (ArkTS)

Signing and Signature Verification by Segment with an RSA Key Pair (PKCS1 Mode) (C/C++)

Signing and Signature Verification with an RSA Key Pair (PSS Mode) (ArkTS)

Signing and Signature Verification with an RSA Key Pair (PSS Mode) (C/C++)

Signing and Signature Verification with an RSA Key Pair (OnlySign and OnlyVerify Modes) (ArkTS)

Signing and Signature Verification with an ECDSA Key Pair (ArkTS)

Signing and Signature Verification with an ECDSA Key Pair (C/C++)

Signing and Signature Verification with an ECC Key Pair (OnlySign and OnlyVerify Modes) (ArkTS)

Signing and Signature Verification with an SM2 Key Pair (ArkTS)

Signing and Signature Verification with an SM2 Key Pair (C/C++)

Converting SM2 Signature Formats (ArkTS)

Converting SM2 Signature Formats (C/C++)

Signing and Signature Verification Using ML-DSA Key Pairs (ArkTS)

Key Agreement Overview and Algorithm Specifications

Key Agreement Development

Key Agreement Using ECDH (ArkTS)

Key Agreement Using ECDH (C/C++)

Key Agreement Using X25519 (ArkTS)

Key Agreement Using X25519 (C/C++)

Key Agreement Using DH (ArkTS)

Key Agreement Using DH (C/C++)

Key Encapsulation and Decapsulation

Key Encapsulation and Decapsulation Using KEM (ArkTS)

MD Overview and Algorithm Specifications

Generating an MD Using SHA-256 (ArkTS)

Generating an MD Using SHA-256 (C/C++)

Generating an MD Using MD5 (ArkTS)

Generating an MD Using MD5 (C/C++)

Generating an MD Using SHA-3 (ArkTS)

Generating an MD Using SHA3-256 (C/C++)

MAC Overview and Algorithm Specifications

Generating an HMAC (ArkTS)

Generating an HMAC (C/C++)

Generating a CMAC (ArkTS)

Generating a CMAC (C/C++)

Generating Secure Random Numbers (ArkTS)

Generating Secure Random Numbers (C/C++)

Generating Secure Random Numbers with Hardware Entropy Sources (ArkTS)

Generating Secure Random Numbers with Hardware Entropy Sources (C/C++)

Key Derivation Overview and Algorithm Specifications

Key Derivation Using PBKDF2 (ArkTS)

Key Derivation Using PBKDF2 (C/C++)

Key Derivation Using HKDF (ArkTS)

Key Derivation Using HKDF (C/C++)

Key Derivation Using Scrypt (ArkTS)

Key Derivation Using Scrypt (C/C++)

Key Derivation Using X963KDF (ArkTS)

Key Derivation Using X963KDF (C/C++)

Cross-Platform Data Compatibility

Crypto Architecture Kit FAQs

AES Decryption Failure Returning Error Code 17630001

Data Protection Kit

DLP Service Development (ArkTS)

DLP Service Development (C/C++)

Adapting to Encrypted Share

Data Protection Kit Glossary

Device Certificate Kit

Certificate Framework

Certificate Framework Overview

Certificate Development

Certificate Extension Development

CRL Development

Creating a TrustAnchor Object Array from a PKCS #12 File

Certificate Chain Validator Development

Certificate and CRL Collection Development

Certificate Chain Development

Using the Prebuilt CA Certificate to Validate a Certificate Chain

Certificate Signing with CMS

Certificate Encapsulation with CMS

Certificate Signature Verification with CMS

Certificate Decapsulation with CMS

Creating and Parsing a Certificate with PKCS #12

Online Validation of Certificate Revocation Status of a Certificate Chain

Downloading the Missing Intermediate CA Certificate During Certificate Chain Validation

Building and Verifying a Certificate Chain

Certificate Management Service

Certificate Manager Overview

CA Certificate Development

Application Certificate Development

User Certificate Credential Development

System Certificate Credential Development

Device Certificate Kit Glossary

Device Security Kit

Development Preparations

Enabling Device Security Kit

Generating a JWT Based on a Service Account

Safety Detection

Enhanced System Integrity Check

System Integrity Check

Local System Integrity Check

Unified Risk Control Credential

TrustedAppService

Image Security Verification

Location Security Verification

Secure Image Compression and Cropping

Signature Verification

Verifying the Anonymous Certificate Chain

Verifying the Signature

TrustedAppService Glossary

Digital Shield Service

Digital Shield Password Management Service

Setting the Digital Shield Password

Changing the Digital Shield Password

Disabling the Digital Shield Service

Password-based Transaction Authentication

Biometric Binding, Authentication, and Unbinding

Enabling Biometric Authentication

Performing Biometric Transaction Authentication

Disabling the Authentication Capability of a Specified Biometric Feature

Digital Shield Signature Key Backup and Restoration

Digital Shield Access in Web Page Scenarios (FIDO2)

TrustedAuthentication Glossary

Single-Client Subscription

Multi-Client Subscription

Subscribing to Notification Events

Subscribing to Authentication Events

Process Information Query

Code Signature Information Query

Querying Notification Client Information

Querying Authentication Client Information

Multi-Client Subscription (C/C++)

Subscribing to Notification Events

Subscribing to Authentication Events

Process Information Query (C/C++)

Code Signature Information Query (C/C++)

Querying Notification Client Information (C/C++)

Querying Authentication Client Information (C/C++)

Service Risk Detection

Fraud Detection

Simulated Click Detection

Enhanced Simulated Click Detection

Terms of BusinessRiskIntelligentDetection

RiskControlEngine

Device Security Mode Query (C/C++)

Anti-Fraud Picker

Obtaining Fraudulent Messages

Obtaining Fraudulent Call Logs

Obtaining Fraudulent Apps

VirusProtectionServiceManager (C/C++)

Super privacy mode

Querying the Super Privacy Mode Status

Querying the Super Privacy Policy Status

Subscribes to Super Privacy mode change events.

Subscribing to Super Privacy Mode and Policy Change Events

Personal Data Processing Information

Supported Countries/Regions

Enterprise Data Guard Kit

Enterprise Threat Protection Kit

Virus Detection And Handling

App Directory Scanning

Isolated File Restoration

Deletion of Isolated Files

Isolation Query

Threat Process Termination

Enterprise Threat Protection Kit FAQs

Online Authentication Kit

Passwordless Authentication

Development Preparations

FIDO Passwordless Authentication

IFAA Passwordless Authentication

SOTER Passwordless Authentication

Authentication Using Passkeys (ArkTS)

Authentication Using Passkeys (C/C++)

DID Digital Identity

Personal Data Processing Information

Website Link Disclaimer

Universal Keystore Kit

Local Key Management

Basic Concepts of Local Key Management

Key Generation and Import

Key Generation Overview and Algorithm Specifications

Generating a Key (ArkTS)

Generating a Key (C/C++)

Key Import Overview and Algorithm Specifications

Importing a Key in Plaintext (ArkTS)

Importing a Key in Plaintext (C/C++)

Importing a Key in Secure Mode (ArkTS)

Importing a Key in Secure Mode (C/C++)

Importing a Key Using a Digital Envelope (ArkTS)

Importing a Key Using a Digital Envelope (C/C++)

General Process of Using a Key

Encryption and Decryption

Encryption and Decryption Overview and Algorithm Specifications

Encryption and Decryption (ArkTS)

Encryption and Decryption (C/C++)

Signing and Signature Verification

Signing and Signature Verification Overview and Algorithm Specifications

Signing and Signature Verification (ArkTS)

Signing and Signature Verification (C/C++)

Key Agreement Overview and Algorithm Specifications

Key Agreement (ArkTS)

Key Agreement (C/C++)

Key Encapsulation

Key Encapsulation Mechanism and Algorithm Specifications

Encapsulating a Key (ArkTS)

Key Derivation Overview and Algorithm Specifications

Key Derivation (ArkTS)

Key Derivation (C/C++)

HUKS Access Control Overview

HUKS Access Control Development

Refined Key Access Control Development

HMAC Overview and Algorithm Specifications

Deleting a Key (ArkTS)

Deleting a Key (C/C++)

Key Attestation

Key Attestation Overview and Algorithm Specifications

Anonymous Key Attestation (ArkTS)

Anonymous Key Attestation (C/C++)

Offline Anonymous Key Attestation (ArkTS)

Application Attestation

About Application Attestation

Creating a Key to Establish a Trusted Certificate

Application Development

Server Development

Identifying Real Requests Through Signature Verification

Application Development

Server Development

Integration Design Practice for Verifying the Authenticity of Application Requests

Other Operations

Checking Key Existence

Checking a Key (ArkTS)

Checking a Key (C/C++)

Obtaining Key Properties

Obtaining Key Properties (ArkTS)

Obtaining Key Properties (C/C++)

Exporting a Key

Exporting a Key (ArkTS)

Exporting a Key (C/C++)

Querying Key Aliases

Querying Key Aliases (ArkTS)

Querying Key Aliases (C/C++)

Exporting and Importing a Key in Ciphertext

About Exporting and Importing a Key in Ciphertext

Exporting and Importing a Key in Ciphertext (ArkTS)

Exporting and Importing a Key in Ciphertext (C/C++)

Group Key Overview

Group Key (ArkTS)

Group Key (C/C++)

External Key Management Extension

External Key Management Extension Overview

Provider Management

Provider Management Overview and Specifications

Registering and Unregistering a Provider (ArkTS)

Registering and Unregistering a Provider (C/C++)

Resource Management

Resource Management Overview and Specifications

Obtaining a Resource ID (ArkTS)

Opening/Closing a Resource (ArkTS)

Opening and Closing Resources (C/C++)

Key Generation, Import, and Export

Generating a Key (ArkTS)

Importing a Key (ArkTS)

Exporting a Public Key (ArkTS)

UKey PIN Authentication Management

UKey PIN Authentication Overview and Specifications

Authentication Status Query (ArkTS)

Authentication Status Query (C/C++)

Clearing the UKey PIN Authentication Status (ArkTS)

Signing and Signature Verification

Signing and Signature Verification Overview and Algorithm Specifications

Signing and Signature Verification (ArkTS)

Signing and Signature Verification (C/C++)

General Operations

General Query Overview and Specifications

General Query (ArkTS)

General Query (C/C++)

Setting Properties (ArkTS)

Obtaining Error Information (ArkTS)

UKey Process Example

Driver HAP ExtensionAbility Adaptation Guide

CryptoExtensionAbility Extension Capability Overview

CryptoExtensionAbility Adaptation Development

Personal Data Processing Information

User Authentication Kit

Before You Start

Obtaining Supported Authentication Capabilities

Initiating User Authentication

Canceling User Authentication

Perceiving and Adjusting the Authentication Process

Applying Custom Authentication

Obtaining Enrolled Credential Status

Using userAuthIcon

Obtaining the Locking Status of a Specified Authentication Type

User Authentication Kit FAQs

How to Detect Changes in Device Fingerprints for Fingerprint Login

How to Detect Authentication Failure During Fingerprint Login

Accessory Integration

An Exception Occurs During API Calls, and the Expected Operation Cannot Be Completed

Connectivity Kit

Bluetooth Overview

Bluetooth Setting

Bluetooth Classic

Device Discovery

SPP-based Connection and Data Transmission

Bluetooth Low Energy

BLE Scanning and Advertising

GATT-based Connection and Data Transmission

2900099 Bluetooth API Call Error

401 Invalid Parameter Reported When an Optional Property Is Explicitly Set to undefined

Bluetooth Glossary

NFC Development

NFC Tag Read/Write Development

HCE Development

SE Access Development

WLAN Service Development Overview

P2P Connection Development

STA Development

Wi-Fi Scan Development

Converged Short-Range

Converged Short-Range Service Development

Interconnection Between Partner Devices and HarmonyOS Devices

Converged Short-Range Glossary

Distributed Service Kit

Distributed Device Management Development

Distributed Ability Connection Management

Cross-Device UIAbility Connection Development

Enhanced Connection Development

Checking Whether NearLink Is Supported

Querying NearLink Status

Sending NearLink Advertising Packets

Initiating NearLink Scanning

SSAP Connection and Data Transfer

Transferring Data Using NearLink

Obtaining NearLink Cooperative Device Set Information

NearLink Kit Terms

Using HTTP for Network Access

Using WebSocket for Network Access

Using WebSocket for Network Access (C/C++)

Using Socket for Network Access

Using MDNS for LAN Access

Using DNS for Domain Name Resolution

Using HTTP Global Interceptor (C/C++)

Network Connection

Network Connection Management

Network Connection Management (C/C++)

Network Connection Development Practices

Application Network Reconnection

Network Information Query and Connection Management

Network Connection Security Configuration

Network Management

Collecting Network Statistics

Using the Network Firewall

Extensible Authentication

Network Boost Kit

Network Quality

Network Quality Assessment

Network Scenario Identification

App Data Transmission Quality Feedback

Weak Network Signal Awareness and Judgment

Network Handover (Between Multiple Networks)

Network Handover Notification

Handover Mode Setting

Network Handover (Multi-Network Concurrency)

Setting the Service Scenario

Listening to the Multi-Network Concurrency Status

Listening to Multi-Network Concurrency Suggestions

Querying Multi-Network Concurrency Quota Information

Initiating and Releasing Multi-Network Concurrency

Network Acceleration Based on Multi-Network Concurrency

Network Quality (C/C++)

Network Quality Assessment (C/C++)

Network Scenario Identification (C/C++)

App Data Transmission Quality Feedback (C/C++)

Weak Network Signal Awareness and Judgment (C/C++)

Network Handover (Between Multiple Networks) (C/C++)

Network Handover Notification (C/C++)

Handover Mode Setting (C/C++)

Network Handover (Multi-Network Concurrency) (C/C++)

Setting the Service Scenario (C/C++)

Listening to the Multi-Network Concurrency Status (C/C++)

Listening to Multi-Network Concurrency Suggestions (C/C++)

Querying Multi-Network Concurrency Quota Information (C/C++)

Initiating and Releasing Multi-Network Concurrency (C/C++)

How Do I Determine Whether the Current Network Is a Wi-Fi or Cellular Network During Multi-Network Concurrent Transmission?

What Will Happen If the Quota of Multi-Network Concurrency Is Used Up?

Remote Communication Kit

Network Communication Using HTTP

Initiating an HTTP Request and Obtaining a Response

Sending a Network Request (ArkTS)

Canceling a Network Request (ArkTS)

Closing a Session (ArkTS)

Sending a Network Request (C++)

Canceling a Network Request (C++)

Closing a Session (C++)

HTTP Request Customization

Configuration: Efficient Function Customization

DnsConfiguration: DNS Customization

TransferConfiguration: Data Transmission Customization

ProxyConfiguration: Proxy Customization

SecurityConfiguration: Secure Transmission Customization

ProcessingConfiguration: Processing Customization

Interceptor: Richer and Higher-Level Customization Capabilities

File Upload/Download

Implementing Upload and Download Quickly

Implementing the Function of Suspending/Resuming Requests and Resuming Transfer

Implementing Streaming Requests

HTTP Transmission Performance Improvement

Performance Maintenance and Test Based on TracingConfiguration

Transmission Performance Optimization Based on Configuration

Improving Resource Obtaining Performance with HTTP Caching

Basic HTTP Caching Function

Cache Sharing Between Sessions

Customizing a Cache Interceptor

Boosting HTTP Transmission Performance Through Pre-connection

Network Communication Using QUIC

Receiving Push Messages over a QUIC Long-Lived Connection

Calling a Remote Program Using URPC

Service Collaboration Kit

Device Interconnectivity (ArkTS)

Introduction to Device Interconnectivity

Development Guide for Device Interconnectivity

Device Interconnectivity in NDK (C)

Overview of Device Interconnectivity in NDK

Development Guide for Device Interconnectivity in NDK

Device Interconnectivity (RichEditor Control)

OneHop for Device Interaction

After the Device Interconnectivity Control Is Connected, No Devices Are Available for Selection

Call Service Development

SMS Service Development

Network Debugging and Optimization

Getting Started with Network Navigator

Capturing Packets with tcpdump Using Network Packet Analysis

Basic Functions

Basic Services Kit

Process and Thread Communication

Using Common Events for IPC

Introduction to Common Events

Subscribing to Common Events in Dynamic Mode

Unsubscribing from Common Events in Dynamic Mode

Publishing Common Events

Subscribing to Common Events in C

Unsubscribing from Common Events in C

Publishing Common Events in C

Using Emitter for Inter-Thread Communication

Account Management

Application Accounts

Managing Application Accounts

Developing USB Services

USB Service Development Overview

USB Host Development

USB Device Management

USB Control Transfer

USB Interrupt Transfer

USB Bulk Transfer

USB Isochronous Transfer

Developing USB Serial Communication Services

USB Serial Communication Development Overview

USB Serial Configuration Management

USB Serial Communication Management

USB Service Glossary

Sample Server Development Overview

Sample Server Development

Pasteboard Service

Requesting Permissions to Access the Pasteboard

Using the Pasteboard to Copy and Paste

Using the Pasteboard to Copy and Paste (C/C++)

Using the Delayed Copy and Paste Feature of the Pasteboard

Upload and Download

Uploading and Downloading Application Files

Compression and Decompression

Compressing and Decompressing Files

Word Selection Service

Overview of the Word Selection Service

Developing a Word Selection Extension Ability

Power Management

Running Lock Usage Guide

Preventing the Idle System from Entering Sleep Mode

Printing Files (C/C++)

PrintExtensionAbility

Using Segment Map to Query and Maintain Range Information

Using RectPartition to Solve the Rectangular Partition Problem

Using PolyRoot to Solve Polynomial Roots

Using ConcurrentHashMap to Query and Maintain Key-Value Information in a Multithreaded Environment

Using DSP for Vector Computation

Using DSP for Second-Order IIR Filtering

Using DSP for FFT

Using HashMap to Manage Key-Value Data

Using Sort for Generic and Natural Language Sorting

Using mathPrediction for Mathematical Prediction

perfHint System Performance Optimization

Using perfHint for System Performance Optimization (ArkTS)

Using perfHint for System Performance Optimization (C/C++)

Function Flow Runtime Kit

Function Flow Runtime Paradigms

Function Flow Runtime Development Samples (C)

Function Flow Runtime Serial Queue (C)

Function Flow Runtime Concurrent Queue (C)

Function Flow Runtime Task Graph (C)

Function Flow Runtime Development Samples (C++)

Function Flow Runtime Serial Queue (C++)

Function Flow Runtime Concurrent Queue (C++)

Function Flow Runtime Task Graph (C++)

Function Flow Runtime Job Partner (C++)

Function Flow Runtime Development

Function Flow Runtime C APIs

Input Device Development

Preferential Response of System Function Keys

Mouse Pointer Development

Event Listening Development (C/C++)

Event Interception Development (C/C++)

MDM Kit Development

Multi-App Management

EnterpriseAdminExtensionAbility Development

Personal Data Processing Information

Kernel Enhance Kit

QoS Development

Gewu Service Development

Purgeable Memory Development

Setting Thread Priorities in High-Load Scenarios

Enabling Hotspot Accelerate

Service Support Kit

Device Hardware Consistency Check

Development Preparations

Implementing Navigation Hop Functions

Navigation Hop to Head Unit

Address Hop to Head Unit

Hop to Walking Navigation upon Vehicle Exit

Obtaining HiCar Connection Status

Proactively Obtaining HiCar Connection Status

Listening to HiCar Connection Status

Connecting an App on Super Home Screen to the Distributed Camera

Driver Development Kit

Setting Up the Environment

Basic Peripheral Driver Development

UI-free Driver Development

UI-based Driver Development

Dedicated Peripheral Driver Development

USB DDK Development

HID DDK Development

USB Serial DDK Development

SCSI Peripheral DDK Development

Multimodal Awareness Kit

Stationary Development

Motion Awareness Development

Device Status Awareness Development

Metadata Binding Development

Handwriting Feature Development

Integrating the Handwriting Suite

Integrating Point Prediction

Integrating Instant Shape

Integrating the Global Color Picker

Integrating Stylus Interaction

Connecting to Stylus Frame Boost

Handwriting Feature Development (C/C++)

Integrating the Global Color Picker

Integrating Point Prediction

Connecting to Stylus Frame Boost

Does the Handwriting Suite of Pen Kit Support Custom Brushes?

Does the Handwriting Suite of Pen Kit Support Custom Brush Widths?

Does the Handwriting Suite of Pen Kit Support Custom Colors?

Can the Toolbar of the Handwriting Suite of Pen Kit Be Provided Separately?

Do I Need to Integrate the Point Prediction Feature of Pen Kit After the Handwriting Suite Has Been Integrated?

Do I Need to Integrate the Instant Shape Feature of Pen Kit After the Handwriting Suite Has Been Integrated?

Can I Adjust the Prediction Degree of the Point Prediction Feature of Pen Kit?

Why Does the Instant Shape Feature Fail to Recognize a Shape?

Sensor Service Kit

Sensor Overview

Sensor Development (ArkTS)

Sensor Development (C/C++)

Vibrator Overview

Vibrator Development (ArkTS)

Vibrator Development (C/C++)

Object Tracking Photography Development

Wear Engine Kit

About the Service

Phone-Side App Development

Getting Started

Applying for Integrating Wear Engine

Configuring the Client ID

App Development

Querying Connected Wearables

Requesting User Authorization

Querying Wearable Device Information

Selecting a Target Device

App-to-App Message Communications

Querying and Subscribing to Status

Template-based Notifications on Wearables

Obtaining Wearable Device Sensor Data

Managing the Connection Status Between Your App and Wear Engine Kit

Wearable-Side App Development

Querying Connected Peer Devices

App-to-App Message Communications

Debugging and Verification

FAQs About Wear Engine

If the Project Already Has an App ID, Do I Need to Apply for a New One?

How do I obtain my app's identifier when using AppInfo?

The user authorization screen does not display

What Can I Do If Error Message "App has not applied for the Wear Engine service" is Reported During an API Call?

No data is reported immediately after the heart rate (HR) sensor is enabled

Why Is 0 or 255 Reported by the HR Sensor?

Result code 206 is displayed when the phone is communicating with a lite wearable device

Error code 1008500011 is reported when I send a file from my phone app to my wearable app

Submitting a Ticket Online If You Cannot Find the Answer to Your Question

Personal Data Processing Information

AOD Navigation Kit

Integrating AOD Navigation

Debugging Tools

Performance Analysis Kit

Fault Detection

Crash Detection

JS Crash (Process Crash) Detection

C++ Crash (Process Crash) Detection

Address Sanitizer Detection

Application Freeze Detection

Resource Leak Detection

Task Timeout Detection

Application Killed Detection

Page Switch Logs

Power Detection

Performance Detection

Using HiLog (ArkTS)

Using HiLog (C/C++)

Event Subscription

Introduction to HiAppEvent

Using HiAppEvent to Subscribe to Events

Event Subscription Overview

Event Subscription (ArkTS)

Event Subscription (C/C++)

Crash Event Overview

Subscribing to Crash Events (ArkTS)

Subscribing to Crash Events (C/C++)

Application Freeze Events

Application Freeze Event Overview

Subscribing to Application Freeze Events (ArkTS)

Subscribing to Application Freeze Events (C/C++)

App Freeze Warning Events

App Freeze Warning Event Overview

Subscribing to App Freeze Warning Events (ArkTS)

Subscribing to App Freeze Warning Events (C/C++)

Resource Leak Events

Resource Leak Event Overview

Subscribing to Resource Leak Events (ArkTS)

Subscribing to Resource Leak Events (C/C++)

Address Sanitizer Events

Address Sanitizer Event Overview

Subscribing to Address Sanitizer Events (ArkTS)

Subscribing to Address Sanitizer Events (C/C++)

Main Thread Jank Events

Main Thread Jank Event Overview

Subscribing to Main Thread Jank Events (ArkTS)

Subscribing to Main Thread Jank Events (C/C++)

Task Execution Timeout Events

Task Execution Timeout Event Overview

Subscribing to Task Execution Timeout Events (ArkTS)

Subscribing to Task Execution Timeout Events (C/C++)

Application Killed Events

Application Killed Event Overview

Subscribing to Application Killed Events (ArkTS)

Subscribing to Application Killed Events (C/C++)

ArkWeb Fling Jank Events

ArkWeb Fling Jank Event Overview

Subscribing to ArkWeb Fling Jank Events (ArkTS)

Time-Consuming Launch Event

Introduction to Time-Consuming Launch Events

Subscribing to Time-Consuming Launch Events (ArkTS)

Subscribing to Time-Consuming Launch Events (C/C++)

Scrolling Frame Loss Event

Introduction to Scrolling Frame Loss Events

Subscribing to Scrolling Frame Loss Events (ArkTS)

Subscribing to Scrolling Frame Loss Events (C/C++)

High CPU Load Event

Introduction to High CPU Load Events

Subscribing to High CPU Load Events (ArkTS)

Battery Usage Statistics Event

Introduction to Battery Usage Statistics Events

Subscribing to Battery Usage Statistics Events (ArkTS)

Audio Jank Event

Introduction to Audio Jank Events

Subscribing to Audio Jank Events (ArkTS)

Subscribing to Audio Jank Events (C/C++)

HiAppEvent FAQs

Using FaultLogExtensionAbility to Subscribe to Events

Performance Tracing

Introduction to HiTraceMeter

Using HiTraceMeter (ArkTS)

Using HiTraceMeter (C/C++)

Viewing HiTraceMeter Logs

Distributed Call Chain Tracing

Introduction to HiTraceChain

Using HiTraceChain (ArkTS)

Using HiTraceChain (C/C++)

Using HiChecker (ArkTS)

Obtaining System Debugging Information

Introduction to HiDebug

Using HiDebug APIs (ArkTS)

Using HiDebug APIs (C/C++)

Service Thread Timeout Detection

Using HiCollie to Detect Service Thread Stuck and Jank Events (C/C++)

Using HiCollie to Detect Function Execution Timeout Events (C/C++)

Error Manager and Application Recovery

Development of Error Manager

Development of Application Recovery

App Gray-scale Collection

App Gray-scale Data Collection Overview

Using HiRetrieval for App Gray-Scale Data Collection (ArkTS)

Personal Data Processing Statement

Automated Test Framework User Guides

JsUnit User Guide

UITest User Guide

PerfTest User Guide

SmartPerf Device User Guide

wukong User Guide

Debugging Commands

Ability Assistant

Packing and Unpacking Tools

Common Event Manager

Advanced Notification Manager

Enterprise Device Manager

Access Token Manager

PrivacyManagerService

Command Line Utilities

rawheap-translator

js-rawheap-translator

Getting to Know Network Navigator

Binary Sign Tool

Media

Media Development at a Glance

Using HDR Vivid in Media Applications

Audio Focus and Audio Session Management

Audio Focus and Audio Session Overview

Introduction to Audio Focus

Audio Session Management (ArkTS)

Using OHAudio for Audio Session (C/C++)

Audio Playback Development

Choosing the Right Playback Stream Type

(Recommended) Using OHAudio for Audio Playback (C/C++)

Using AudioRenderer for Audio Playback (ArkTS)

Low-Latency Audio Playback (C/C++)

Low-Power Audio Playback

Using AudioHaptic for Audio-Haptic Playback (ArkTS)

Using SoundPlayer for System Sound Effect Playback

Volume Management

Spatial Audio Capability Query and Status Subscription

Audio Playback Stream Management

Audio Recording

Audio Recording Development

Microphone Recording (External Recording) Features

Choosing the Right Recording Stream Type

(Recommended) Using OHAudio for Audio Recording (C/C++)

Using AudioCapturer for Audio Recording (ArkTS)

Low-Latency Audio Recording (C/C++)

Implementing Background Recording

System Audio Recording (Internal Recording) Features

System Audio Recording Overview and API Selection

Implementing System Audio Recording

Managing Microphone Mute State

Querying and Listening for the Recording Status of Other Applications

Recording Concurrency Strategy Description

Implementing Custom Audio Monitoring

Implementing Low-Latency Audio Monitoring

Audio Device Routing Management

Querying and Listening for Audio Input Devices

Querying and Listening for Audio Output Devices

Switching Audio Input Devices

Switching Audio Output Devices

Handling Output Device Changes Gracefully

Audio Call Overview

Developing Audio Call

Audio Performance Optimization

Enhancing Audio Performance Experience

Audio Workgroup Management

Audio Creation Overview (C/C++)

Offline Editing (C/C++)

Real-Time Preview (C/C++)

Audio Format Conversion (C/C++)

Spatial Rendering (C/C++)

Audio Effects (C/C++)

MIDI Device Communication

OH_MIDI Overview (C/C++)

Using OH_MIDI for MIDI Development (C/C++)

OpenSL ES Development (Not Recommended)

Switching from OpenSL ES to OHAudio (C/C++)

Using OpenSL ES for Audio Playback (C/C++)

Using OpenSL ES for Audio Recording (C/C++)

Using Audio Snapshots for Troubleshooting

Troubleshooting Silent Playback Issues

Troubleshooting Audio Playback Stuttering and Noise Issues

Troubleshooting Silent Recording Issues

AVCodec Supported Formats

Audio and Video Codecs

Obtaining Supported Codecs

Synchronous Audio Encoding

Synchronous Audio Decoding

Synchronous Video Encoding

Temporally Scalable Video Coding

B-Frame Video Encoding

Video Encoding Configurations for Typical Scenarios

ROI Video Encoding

Encoding with One Input and Dual Outputs

Encoding with Preprocessing

Synchronous Video Decoding

Intelligent Smooth High-Speed Playback Decoding

Video Variable Frame Rate

Audio Vivid Capabilities

Introduction to Audio Vivid Capabilities

Audio Vivid Demultiplexing

Audio Vivid Decoding

Audio Vivid Encoding

Audio Vivid Playback

HDR Vivid Capabilities

HDR Vivid Video Playback

HDR Vivid Video Recording

Converting HDR Vivid to SDR Videos

Media Data Multiplexing and Demultiplexing

Media Data Multiplexing

Media Data Demultiplexing

Audio and Video Codec Development Practices

Decoded Video Playback Control in Surface Mode

A/V Synchronization

Rendering Video Frames

HDR Vivid Video Playback and Recording

HDR Vivid-to-SDR Video Transcoding

Video Transcoding in Buffer Mode

Video Encoding in Surface Mode

AVCodec Kit FAQs

Concurrently Creating a Video Decoder and Initializing NativeWindow

Video Codec Width, Height, Stride, and Crop Information

Local AVSession

Local AVSession Overview

AVSession Provider (ArkTS)

AVSession Provider (C/C++)

Accessing AVSession

Background Playback

Integrating the Lyrics Component

AVSession Controller

Distributed AVSession

Switching Call Devices Using Components

Using AVCastPicker

Introduction to Playback Control

AVCastPicker Development

Extended Screen Casting Development

Accessing Playback Control Self-Check

Checklist for Playback Control Access

Checklist for Accessing Playback Control

Basic Playback Controls

Audio/Video Casting

Audio Recommendations

Customizing the Display Layout of Control Buttons in the Media Controller

Using the Audio Template

AVSession Kit FAQs

Local Media Session FAQs

Common FAQs About Distributed Media Sessions

FAQs About Using AVCastPicker

FAQs About Using AVCastPickerHelper APIs

Requesting Camera Development Permissions

Mandatory Capabilities for Camera Application Development (ArkTS)

Camera Device Management (ArkTS)

Device Input Management (ArkTS)

Camera Session Management (ArkTS)

Fundamental Capabilities for Camera Application Development (ArkTS)

Using the System Camera to Take Photos and Record Videos (CameraPicker)

Preview (ArkTS)

Dual-Channel Preview (ArkTS)

Photo Capture (ArkTS)

Photo Capture Practices (ArkTS)

Video Recording (ArkTS)

Video Recording Practices (ArkTS)

Metadata (ArkTS)

Using the Flashlight (ArkTS)

Adapting Camera Changes in Different Fold States (ArkTS)

Deferred Photo Delivery (ArkTS)

Deferred Photo Delivery Practices (ArkTS)

Moving Photos (ArkTS)

Basic Camera Animation (ArkTS)

Using the Camera in the Worker Thread (ArkTS)

Practices for Camera Recovery from the Background (ArkTS)

Practices for Automatic Camera Switching (ArkTS)

White Balance Settings (ArkTS)

Pressure Management (ArkTS)

Camera Controller (ArkTS)

Macro Photography Settings (ArkTS)

Multi-Camera Concurrent Mode (ArkTS)

YUV Photo Capture (ArkTS)

Camera Rotation

Adjusting Camera Rotation Angles (ArkTS)

Understanding Camera Rotation Terminology

Secure Mode Camera (ArkTS)

Dynamically Adjusting the Preview Frame Rate (ArkTS)

Using Camera Preconfiguration (ArkTS)

HDR Vivid Photo Capture (ArkTS)

HDR Vivid Camera Recording (ArkTS)

Solution to Screen Artifacts During Camera Preview

Mandatory Capabilities for Camera Application Development (C/C++)

Camera Device Management (C/C++)

Device Input Management (C/C++)

Camera Session Management (C/C++)

Fundamental Capabilities for Camera Application Development (C/C++)

Preview (C/C++)

Secondary Processing of Preview Streams (C/C++)

Photo Capture (C/C++)

Photo Capture Practices (C/C++)

Deferred Photo Delivery (C/C++)

Video Recording (C/C++)

Video Recording Practices (C/C++)

Camera Metadata (C/C++)

Using the Flashlight (C++)

Pressure Management (C/C++)

Macro Photography Settings (C/C++)

Multi-Camera Concurrent Mode (C/C++)

YUV Photo Capture (C/C++)

Camera Rotation

Adjusting Camera Rotation Angles (C/C++)

Understanding Camera Rotation Terminology

Dynamically Adjusting the Preview Frame Rate (C/C++)

Using Camera Preconfiguration (C/C++)

Camera Kit FAQs

Camera Fails to Start

Camera API Call Sequence Issues

Camera Preview Stream Startup Issues

Session Configuration Issues

Camera Preview Rotation Issues

White Balance Issues

Color Space Configuration Issues

DRM Development (ArkTS)

DRM Development (C/C++)

DRM Playback with AVPlayer (ArkTS)

DRM Playback with AVCodec (C/C++)

Image Development (ArkTS)

Using ImageSource to Decode Images

Using ImageSource to Decode Pictures

Image Decoding Memory Optimization (ArkTS)

Image Region Decoding and Downsampling (ArkTS)

Using ImageSource to Obtain RAW Data

Using ImagePacker to Encode Images

Using ImagePacker to Encode Pictures

Image Editing and Processing

Using PixelMap to Transform Images

Using PixelMap for PixelMap Operations

Using VideoProcessingEngine to Upscale Images

Image Metadata Processing

Reading and Editing Image Exif Data

Reading and Editing Image XMP Metadata

Using ImageSource to Obtain Specific Metadata

Image Receiving

Using ImageReceiver to Receive Images

Image Development (C/C++)

Using Image_NativeModule to Decode Images

Using Image_NativeModule to Decode Pictures

Image Decoding Memory Optimization (C/C++)

Image Region Decoding and Downsampling (C/C++)

Using Image_NativeModule to Decode Animated Images

Using Image_NativeModule to Decode HDR Images

Using Image_NativeModule to Encode Images

Using Image_NativeModule to Encode Pictures

Image Editing and Processing

Using Image_NativeModule for PixelMap Operations

Using ImageEffect to Edit Images

Using ImageProcessing to Process Images

Dynamic Metadata Generation for Images

Color Space Conversion for Images

Converting HDR Images from Single-Layer to Dual-Layer

Converting HDR Images from Dual-Layer to Single-Layer

Using Image_NativeModule to Read and Edit Image Exif Data

Image Receiving

Using Image_NativeModule to Receive Images

FAQs About Image Kit

Handling HEIF Images

Obtaining the Rotation Angle of an Image

Image Kit Exception Handling

Common Crash and Error Issues

Image Development (Dependent on JS Objects) (Not Recommended)

Image Transformation

PixelMap Operation

Image Receiving

Media Development (ArkTS)

Using AVPlayer to Play Audio (ArkTS)

Using AVPlayer to Play Videos (ArkTS)

Using AVPlayer to Set Playback URLs (ArkTS)

Using AVPlayer to Play Streaming Media (ArkTS)

Using AVPlayer to Add External Subtitles to Videos (ArkTS)

Using SoundPool to Play Short Sounds (ArkTS)

Using AVRecorder to Record Audio (ArkTS)

Using AVRecorder to Record Videos (ArkTS)

Using AVScreenCaptureRecorder to Record Screens and Write Them to Files (ArkTS)

Media Information Query

Using AVMetadataExtractor to Extract Audio and Video Metadata (ArkTS)

Using AVImageGenerator to Extract Video Images at a Specified Time (ArkTS)

Video Transcoding

Using AVTranscoder to Transcode Videos (ArkTS)

Creating an Asynchronous Thread for AVTranscoder Video Transcoding (ArkTS)

Transcoding FAQs

Media Development Practices

Long-Form Video Playback with AVPlayer

Short-Form Video Playback with AVPlayer

Embedded Short-Form Video Playback with AVPlayer

Online Video Playback with AVPlayer

Minimizing Stuttering in Online Video Playback

Obtaining Video Thumbnails Using System Capabilities

Screen Recording Based on AVScreenCapture (ArkTS)

Media Development (C/C++)

Using AVPlayer to Play Audio (C/C++)

Using AVPlayer to Play Videos (C/C++)

Using AVPlayer to Play Streaming Media (C/C++)

Using LPP to Play Videos (C/C++)

Using AVRecorder to Record Audio (C/C++)

Using AVRecorder to Record Videos (C/C++)

Using AVScreenCapture to Capture Screens and Obtain Streams (C/C++)

Using AVScreenCapture in Basic Scenarios

Using AVScreenCapture in Custom Scenarios

Screen Capture FAQs

Using AVScreenCapture to Capture Screens and Write Them to Files (C/C++)

Using AVScreenCapture to Capture Window-Level Screen (C/C++)

Capturing the Specified Area on a Screen

Media Information Query

Using AVMetadataExtractor to Obtain Metadata (C/C++)

Using AVImageGenerator to Obtain Video Frames (C/C++)

Video Transcoding

Using AVTranscoder to Transcode Videos (C/C++)

Video Processing

Video Dynamic Metadata Generation

Video Color Space Conversion

Screen Recording Based on AVScreenCapture (C/C++)

Media Library Kit

Selecting Media Assets Using Picker

Saving Media Assets

Accessing Images/Videos Using PhotoPickerComponent

Accessing Albums Using AlbumPickerComponent

Obtaining the Latest Image/Video Using RecentPhotoComponent

Using PickerController to Replace Original Images with Edited Images

Recommending Images Using the Photo Picker

Accessing and Managing Moving Photos

Playing Moving Photos with MovingPhotoView

Inheriting Media File Access Permissions After Device Upgrade

Restricted Open Capabilities

Before You Start

Managing Media Assets

Managing User Albums

Managing System Albums

Observing Media Assets

Requesting Media Assets Using MediaAssetManager (C/C++)

Obtaining and Storing Images

Media Library Kit FAQs

How to Properly Manage Media Assets

How to Correctly Identify Media Asset Types

Geolocation Information Is Missing from Images

How to Properly Handle High-Resolution Images

Setting a Ringtone

Getting Started

Scan-to-Access Capability

Barcode Scan by Default UI

Barcode Scanning by Custom UI

Recognizing Barcodes in an Image

Scanning Barcodes in a Saved Image

Recognizing Barcodes in Image Data

Barcode Image Generation

Generating a Barcode Image from Text

Generating a Barcode Image from a Byte Array

How Do I Add a Quick Entry for the Scan-to-Access Service?

Failed to Open the Target Page Through Scan-to-Access

Scan Kit Cannot Recognize Multiple Barcodes at a Time

Device Types in Uploaded Package Inconsistent with Declared Device Types During Package Upload

Multi-Barcode Scanning Failed During Gallery-based Barcode Scanning by Default UI

1D Code Recognition Failure

Recognized Coordinate Information of a 1D Code Is Empty

Scanning Preview Image on Custom UI Stretched

Black Screen Occurred on the Custom Scanning UI

How Do I Scan Barcodes Continuously on the Custom Scanning UI?

Failure to Recognize a Barcode Image Generated from a Byte Array

How Do I Determine Whether Scanning is Canceled on the Default Scanning UI?

How Do I Integrate Scan Kit for HTML5

How Do I Implement Zoom Ratio Change Through Gestures?

How Do I Implement the Barcode Scanning Box on a Custom UI?

Experience Design Problem on the Default/Custom Barcode Scanning UI

How Do I Implement the Retry Mechanism for Barcode Scanning by Custom UI?

App Occasionally Exits When a User Attempts to Recognize a Barcode from a Saved Image on the Custom Barcode Scanning UI

How Do I Set the Background Color of a Barcode Image to Transparent?

Personal Data Processing Information

Graphics

AR Session Management

Managing AR Sessions (ArkTS)

Managing AR Sessions (C/C++)

Motion Tracking

Obtaining the Device Pose (ArkTS)

Obtaining the Device Pose (C/C++)

Plane Detection

Detecting Planes in the Environment (ArkTS)

Detecting Planes in the Environment (C/C++)

Placing Objects (ArkTS)

Placing Objects (C/C++)

Plane Semantics

Recognizing Plane Semantics (ArkTS)

Recognizing Plane Semantics (C/C++)

Object Semantics

Recognizing the Target Shape (C/C++)

Environment Mesh Recognition

Obtaining Mesh Scanning Information (ArkTS)

Obtaining Mesh Scanning Information (C/C++)

Depth Estimation

Obtaining Depth Estimation Information (ArkTS)

Obtaining the Depth Image (C/C++)

High-Precision Geometric Reconstruction

High-Precision Geometric Reconstruction (ArkTS)

High-Precision Geometric Reconstruction (C/C++)

Human Body Skeleton Keypoint Recognition and Tracking

Human Body Tracking and Skeleton Keypoint Recognition (ArkTS)

Human Body Tracking and Skeleton Keypoint Recognition (C/C++)

Facial Recognition and Tracking

Face Tracking (ArkTS)

Face Tracking (C/C++)

Image Tracking (ArkTS)

Image Tracking (C/C++)

FAQs About AR Engine

Error Message "plane is nullptr!" Is Reported with the Error Code 401 When I Attempt to Obtain the 2D Vertex Coordinate Array of the Detected Plane

When the Camera Is Blocked for a Period of Time and Then Uncovered, the Output Pose Changes Dramatically

Unable to Recognize Planes in Scenarios with Reflections, Dim Lights, or Weak Textures (Where There Is Little Color Variation in the Input Images)

The Plane Drifts or Pose Data Changes Abruptly in Certain Special Scenarios (Such as When a Strong Magnetic Field Is Nearby, the Phone Is Overheated, or When Duplicate Textures Are Scanned)

Data Type Conversion

Personal Data Processing Information

Using Variable Frame Rates

Introduction to Variable Frame Rates

Requesting Frame Rates for Animations

Requesting Frame Rates for UI Components

Requesting Frame Rates for Custom Content

Native DisplaySoloist Development (C/C++)

Overdraw Debugging

Graphics Drawing and Display

Overview of Graphics Drawing and Display

Canvas Acquisition and Display of Drawing Results

Obtaining a Canvas and Displaying Drawing Results (ArkTS)

Obtaining a Canvas and Displaying Drawing Results (C/C++)

Canvas Operations and State Processing

Canvas Operations and State Processing (ArkTS)

Canvas Operations and State Processing (C/C++)

Drawing Effects

Overview of Drawing Effects

Basic Drawing Effects (ArkTS)

Complex Drawing Effects (ArkTS)

Basic Drawing Effects (C/C++)

Complex Drawing Effects (C/C++)

Primitive Drawing

Drawing Primitives

Drawing Geometric Shapes (ArkTS)

Drawing Images (ArkTS)

Drawing TextBlobs (ArkTS)

Drawing Geometric Shapes (C/C++)

Drawing Images (C/C++)

Drawing TextBlobs (C/C++)

Introduction to Text Development

Font Management

Using Theme Fonts (ArkTS)

Registering and Using Custom Fonts (ArkTS)

Obtaining and Using System Fonts (ArkTS)

Using Theme Fonts (C/C++)

Registering and Using Custom Fonts (C/C++)

Obtaining and Using System Fonts (C/C++)

Text Measurement

Text Measurement (ArkTS)

Text Measurement (C/C++)

Text Drawing and Display

Drawing and Displaying Simple Text (ArkTS)

Drawing and Displaying Complex Text (ArkTS)

Drawing and Displaying Custom Text (ArkTS)

Drawing and Displaying Simple Text (C/C++)

Drawing and Displaying Complex Text (C/C++)

Drawing and Displaying Custom Text (C/C++)

Text Development FAQs

Offline Image Processing

Adding Image Effects (C/C++)

NativeVSync Development (C/C++)

Graphics Buffer

NativeBuffer Development (C/C++)

NativeImage Development (C/C++)

NativeWindow Development (C/C++)

GPU/CPU Memory Access Sync (C/C++)

Common Stability Issues with Graphics Buffers (C/C++)

Building and Managing ArkGraphics 3D Scenes

Creating and Using ArkGraphics 3D Resources

Creating and Using Material Resources

Creating and Using Image Resources

Creating and Using Environment Resources

Requirements on the .shader File Format

Controlling and Managing ArkGraphics 3D Scene Animations

Downloading and Installing the ArkGraphics Editor Plugin and Editor

Graphics Accelerate Kit

Game Rendering Acceleration Service

Developing the Frame Generation Capability

Interpolation Mode

Extrapolation Mode

System Display Mode

AI-based Frame Generation Mode

Developing the ABR Capability

Developing the OpenGTX Capability

Game Asset Acceleration Service

Background Download of Assets

Development Preparations

Asset Download in the System Background

Extension-Initiated System-Managed Download

Extension-Initiated Coordinated Download

Asset Download in the App Foreground

Asset Download Switching from the System Background to the App Foreground

Releasing an Asset Download Task

Viewing Asset Distribution Data

Game Launch Acceleration Service

Development Preparations

Second-Level Game Launch

Second-level Launch

Game Pre-launch

Implementing Game Pre-launch

Game Buddy Service

Development Preparations

Implementing the Game Buddy Service

Game Rendering Acceleration Service

What Are the Graphics APIs Supported by the Frame Generation and ABR Capabilities?

What Types of Devices Does This Kit Support?

What Are the Possible Causes of Serious Blurring Artifacts on the Edges of Moving Objects After the Extrapolation Mode of Frame Generation Is Enabled?

What Kinds of Buffers Are Suitable for the ABR Capability?

What Can I Do if the Rendering Effect of Other Passes Becomes Abnormal After the Buffer Resolution Is Adapted by the ABR Capability?

What Can I Do if the Native Texture Content Obtained from the Game Engine Is Empty After the ABR Capability Is Integrated?

Game Asset Acceleration Service

What Types of Asset Formats Are Supported for Upload to Huawei CDNs?

What Can I Do If the Download Functions Do Not Take Effect Because the Component Type Is Not Configured for the Integrated Game Asset Acceleration ExtensionAbility?

What Can I Do If the Download Functions Do Not Take Effect Because the Network Permission Is Not Configured for the Integrated Game Asset Acceleration ExtensionAbility?

Why Do the Static Variables Used in Asset Acceleration ExtensionAbility Methods Not Take Effect?

How Do I Parse XML Files Corresponding to manifestUrl in the Huawei CDN Scenario?

Can I Only Access the Download ExtensionAbility Without Rewriting the Download Logic or Middleware in the Game Engine?

How Do I Use a Specified Test Device for Local Testing After Integrating the Asset Background Download Functions?

Is It Possible to Stop a Released Download Task, for Example, When I Encounter Issues with Assets?

Can I Apply for a Continuous Task for Seamless Game Running and Asset Download After the App Switches from the Foreground to the Background?

How Do I Integrate the Asset Background Download Functions If I Use Unity Addressables in My Game?

Game Launch Acceleration Service

How Do I Avoid Full-Screen Incoming Call Notification for My Game Launched by Loading a Memory Snapshot?

What Can I Do If Vibration Occurs During Scene Switching After a User Swipes Up to Exit the Game?

What Can I Do If Third-Party SDK Functions Are Abnormal in a Game Launched from a Memory Snapshot?

What Can I Do If a Black Screen Is Displayed When the Game Calls UnityEngine.Application.Quit to Exit Through a Side Swipe?

What Can I Do If the Error Message "BusinessError: The Worker instance is not running, maybe worker is terminated when PostMessage" Is Frequently Recorded in Logs?

What Can I Do to Avoid Game Freezing upon Next Fast Launch if the Game Freezes Previously?

What Can I Do If an Error Similar to "UIContent is nullptr" Occurs After Second-Level Game Launch, Causing Sign-in and Other Exceptions?

What Can I Do If My Game Is Rejected for Failing to Implement Anti-addiction Reminders?

What Can I Do If the Splash Screen and the Resumed Game Audio Are Out of Sync During Second-Level Game Launch?

What Can I Do If My Game Cannot Perform Hot Updates After Second-Level Game Launch Is Enabled?

What Should I Do If an Exception Occurs When the Game Launch Acceleration API Is Called on a Tablet Running Tuanjie Engine 1.8.1 to 1.9.0?

Game Buddy Service

What Should I Do If the Game Screenshot Callback Does Not Return a File Descriptor?

Spatial Recon Kit

Loading a 3DGS Model

Adding a Filter Effect

Reconstructing a 3D Scene (C/C++)

Managing Spatial Recon Kit Sessions

GPU Spatial Upscaling

AI Temporal Upscaling

AI Spatial Upscaling

Subpass Shading

Ray-Traced Reflections

Ray-Traced Shadow and Ambient Occlusion

Ray-Traced Global Illumination

Control-Display Separation

High-Performance GPU Sorting

What Can I Do If an Extension Instance Fails to Be Created?

Can I Use Upscaling and Adaptive VRS Features at the Same Time?

Adaptive VRS Depth Attachment Instructions

Application Services

Management Rules for Using the Sign-in Capability of Account Kit

Getting Started

Requesting Scopes

Configuring Signing Information and Adding a Fingerprint

Configuring the Client ID

Signing In with HUAWEI ID Through Just One Tap (Obtaining the Mobile Number, UnionID, and OpenID)

Signing In with HUAWEI ID (Obtaining the UnionID and OpenID)

Lite Import Title

Signing In with a Custom Button

Silently Signing In

Signing In After Authorization by QR Code Scanning

Access to User Information of a HUAWEI ID

Obtaining the Avatar and Nickname

Obtaining the Mobile Number

Obtaining the Shipping Address

Obtaining the Invoice Title

Obtaining the Risk Level

Obtaining a User's Risk Level Through One-Tap HUAWEI ID Sign-in

Obtaining a User's Risk Level Through Other Ways for HUAWEI ID Sign-in

Obtaining the Real-Name Age Group

Synchronization of the Device's Youth Mode Status to an App

Following the Device's Youth Mode Status

Enabling the Youth Mode Within an App

Disabling the Youth Mode Within an App

(Recommended) Disabling the App's Youth Mode

Disabling the Device's Youth Mode

Adjusting Youth Mode Settings

Account Kit Notification Events

1001500001 Fingerprint Certificate Verification Failure

1001502014 Necessary Scopes Not Requested

What Should I Do If the Anonymous Mobile Number Cannot Be Obtained in the One-Tap Sign-In Scenario?

What Should I Do If the Plaintext Mobile Number Cannot Be Obtained in the One-Tap Sign-In Scenario?

In the One-Tap Sign-In Scenario Where the App Displays the One-Tap Sign-In Screen, What Should the App Proceed If the User Signs Out of the HUAWEI ID or Switches to Another HUAWEI ID on the Device?

Is the UnionID/OpenID of a HUAWEI ID User or the Mobile Number Used as Their Unique Identifier During One-Tap Sign-In with a HUAWEI ID?

How to Exchange User Data Between HarmonyOS APK Apps and HarmonyOS NEXT Apps in the One-Tap Sign-In Scenario?

What Should I Do If the Avatar and Nickname Cannot Be Obtained?

Formats of OpenID and UnionID

What Are the Validity Periods of Access Token and Refresh Token?

What Are the Length Limits of Access Token and Refresh Token?

When and How Can I Use the ID Token?

What Can I Do If USB Debugging Is Unavailable After the Youth Mode Is Enabled?

Upon Receiving a Notification That the Device's Youth Mode Is Enabled, What Actions Should the App Take?

Integrating One-Tap HUAWEI ID Sign-In Using a Third-Party Development Framework

401 Parameter Check Failure

60180007 What Should I Do If the Server Cannot Obtain the One-tap Sign-in Mobile Number of a HUAWEI ID Through the Authorization Code?

1001502003 Invalid Input Parameter Value

Personal Data Processing Information

Supported Countries/Regions

Petal Ads Publisher Service

Interstitial Ads

Real-Time Bidding

FAQs About Petal Ads Publisher Service

Why Is a White Screen Displayed When an Ad Is Displayed?

What Are the Restrictions on Petal Publisher Center?

Why Is Error Code 801 Returned When a PC Requests or Displays an Ad?

Personal Data Processing Information

Digital Product Service

Integration Process

Enabling the Digital Product Service

Enabling Relevant Services and Setting Parameters

Configuring an App

Configuring Digital Products

About Digital Products

Configuring Digital Products in AppGallery Connect

Configuring Digital Products Through the Server API

Distributing Digital Products in Your App

Displaying Digital Products

Purchasing Digital Products

Delivering Digital Products

Testing the Digital Product Service

Recommendation on AppGallery

Adding an Atomic Service Widget to the Home Screen

Displaying the App Details Page

Adding a Shortcut to the Home Screen

Querying an App Shortcut

Deleting an App Shortcut

On-Demand Feature Distribution

On-Demand Feature Distribution (ArkTS)

On-Demand Feature Distribution (C/C++)

Ecosystem Query Service

Update on AppGallery

App Attribution Service

Development Overview

Registering an Enterprise Account

Managing Attribution Roles

Managing Conversion Events

Standard Conversion Events

Custom Conversion Events

Managing Attribution Policies

Registering Attribution Sources and Conversion Events

Posting Back the Attribution Result

Performing Debugging

Privacy Agreement Management Service

Icon Management Service

Dynamically Managing App Icons Through AppGallery Connect

Dynamically Switching App Icons

App Review Service

FAQs About AppGallery Kit

Can I Configure Multiple Callback URLs for Key Subscription Events in AppGallery Connect?

What Is the Maximum Length of the IAP Public Key Obtained in AppGallery Connect? Is There a Recommended Length?

I Try Adding a Product on the Product Management Page in AppGallery Connect, and See a Default Price When Setting My Product Price. What Is the Default Price Used for?

If I Manually Change an In-App Product's Price for a Specific Country/Region in AppGallery Connect, Will It Still Adjust with Future Exchange Rate Changes?

Has AppGallery Connect Made Any Numerical Adjustments to the Price Displayed on the Product Management Page, for Example, Changing the Second Decimal Place of a Price to 6 or 9 According to Relevant Rules?

Is the SHA-256 Certificate Mandatory for Signature Verification?

Can Signature Verification Be Performed Entirely on the Server Side?

Is There Only One UI Design for the Payment Screen?

Can the ID of a Deleted Product Be Used Again for a New Product?

How Many Certificates Are Supported by the Digital Product Server?

What Cipher Suites Are Supported by the Digital Product Server?

What Order Statuses Are Supported by the Digital Product Service?

What Are the Rules for Renewal Periods of a Subscription?

Does a One-Month Subscription Renewal Period Refer to 30 Days, 31 Days, or a Calendar Month? Similarly, How Many Days Are Included in Two Months and Three Months?

Does February Have 28 or 29 Days When the Subscription Period Is Calculated by Calendar Month?

Why Does an Atomic Service Widget Fail to Be Displayed on AppGallery?

Why Do the Dynamic Modules Fail to Be Loaded in the On-Demand Loading Scenario?

Can the Module Loaded on Demand Be Released or Updated on AppGallery Separately?

If the App Restarts After a Module Is Loaded, Does the Module Remain Loaded? Is It Necessary to Re-initiate an On-Demand Loading Request?

In the On-Demand Loading Scenario, Can a User Uninstall a Specified Module That Has Been Loaded and Initiate a Request Again?

Is Synchronous Loading of Dependencies Supported in On-Demand Loading Scenarios?

Does the On-Demand Loading Scenario Support Multiple Tasks at the Same Time?

If an App Is Updated on AppGallery After On-Demand Loading Succeeds, Does On-Demand Loading Need to Be Triggered Again?

Why Does Redirection to a Dynamic Module Page Fail After On-Demand Loading Succeeds?

How Can I Quickly Debug the On-Demand Feature Distribution Function in My App When It Has Not Been Released on AppGallery?

Why Is the Scene Value Obtained Through the Ecosystem Query Service Empty?

Why Does the Update on AppGallery Feature Throw an Exception Indicating that the App Is Not Running in the Foreground?

Can I Customize the Content in the App Update Pop-up Displayed to Users?

Why Does an Identity Verification Error Occur When I Call the Attribution Source Registration API of the App Attribution Service?

How Do I Obtain Logs of the App Attribution Service Through Filtering?

How Do I Filter Logs Recording the Addition of App Shortcuts to the Home Screen?

What Can I Do If Error Code 401 Is Returned When an App Shortcut Is Added to the Home Screen?

Standard Conversion Events and App Attribution Signatures

Supported Countries/Regions

App Linking Kit

Getting Started

Making Preparations

Enabling App Linking

Starting an App Using the App Link Capability of App Linking

Redirecting to an App Download Page Through Direct Access to AppGallery

Redirecting to an App Details Page Using the Deferred Link Capability

Redirecting to an App in a Specified Way Using the Cross-Platform Link Capability

Calendar Management

Event Management

Registering and Managing One-Tap Services for Calendar Events

Calendar Service Best Practices

Call Service Kit

Displaying Enterprise Contact Information on the Incoming or Outgoing Call Screen

Displaying Enterprise Service Information on the Incoming or Outgoing Call Screen

Redirecting to the Unknown Number and Information Identification Page

Why Is the Notification Banner Not Displayed?

Why Is the Profile Picture Not Displayed in the Notification Banner?

Cloud Foundation Kit

Getting Started

Making Preparations

Enabling Cloud Functions

Enabling Cloud DB

Enabling Cloud Storage

Cloud Functions

Developing a Cloud Function

Developing a Function

Creating a Function

Testing a Function

Calling a Function

Adding an Object Type

Adding a Cloud DB Zone

Importing an Object Type File

Initializing Database Access

Setting Configuration Items of Cloud Storage

Initializing the Global App Context

Initializing a Storage Instance

Uploading a Specified File to the Cloud

Downloading a File from the Cloud to a Local Path

Obtaining the Download URL of a Cloud File

Deleting a Cloud File

Obtaining the Cloud File List

Obtaining Metadata of a Cloud File

Setting Metadata of a Cloud File

Debugging on the Emulator

Cloud Foundation Kit FAQs

Why Is "404:Product does not exist" Displayed When a File Fails to Be Uploaded Using Cloud Storage?

Why Does the App Log Display ""state":65" and the Upload Process Log Display "403 Forbidden" When a File Fails to Be Uploaded Using Cloud Storage?

What Can I Do If an API of Cloud Storage Fails to Be Called, the App Log Displays ""state":65", and the Upload Process Log Displays "404 Not Found"?

Personal Data Processing Information

Supported Countries/Regions

Using the Picker for Contact Management

Enterprise Space Kit

Cross-Workspace Data Transfer

File Exfiltration Control

Workspace Management

Workspace Management

Workspace Configuration

Subscribing to Workspace Events

Process Access Restriction

Deep Freeze Policy

Enterprise Account Authentication

Cross-Workspace Message Notification

What Should I Do If Compilation Fails?

File Manager Service Kit

Moving a File to the Recycle Bin

Obtaining a File Icon

Parsing a File Shortcut

Game Controller Kit

Listening for Device Online/Offline Events (C/C++)

Listening for Gamepad Axis and Button Events (C/C++)

Game Service Kit

(Mandatory) Basic Game Service

Online Game Sign-In

(Mandatory) Sign-In with a HUAWEI ID

Sign-In with an Official Game Account

Standalone Game Sign-In

Pre-release Check

(Mandatory) Mini Game Sign-In

Payment in Mini Games

(Optional) Game Scene Perception

Development Procedure (ArkTS)

Development Procedure (C/C++)

(Optional) Game Nearby Transfer

Development Procedure

Transferring Resource Packages

Transferring Installation Packages

Personal Data Processing Information

FAQs About Game Service Kit

Basic Game Service

Can I Skip App ID Mapping If My Game Does Not Have a Package for HarmonyOS 4 and Earlier?

What Is the Size Limit for Official Game Account Icons?

How Do I Hide the Official Account Sign-In Option on the Game Sign-In Screen?

What Should a Player Do If They Choose an Incorrect Sign-In Account?

Game Scene Perception

Can I Integrate Game Scene Perception into Games Developed Through C# Programming?

Configuring a Callback Address

Obtaining the Game Key

Health Service Kit

Integration Process

Qualifications Requirements for Developers

Open Data Overview

Getting Started

Applying for Health Service Kit

Configuring the Client ID

Developing Phone/Tablet Apps

Launching HUAWEI Health for Users to Agree to the Privacy Statement

Managing User Authorization

Managing Data Sources

Managing Health and Fitness Data

Health and Fitness Sample Data

Workout Records

Real-Time Activity Rings Data

Manually Synchronizing Data

Developing Wearable Apps

Managing User Authorization

Managing Health and Fitness Data

Reading Health and Fitness Sample Data

Reading Workout Records

Reading Health Records

Real-Time Activity Rings Data

Developing Lite Wearable Apps

Managing User Authorization

Managing Workout Linkage

Permission Description

Daily Activities

Body Temperature

Heart Rate Variability

Workout Record Data

Apnea Testing in Diving

Apnea Training in Diving

Elliptical Machine

Mountain Hiking

Health Record Data

Menstrual Cycle

Applying for Formal Scopes

Personal Data Processing Information

FAQs About Health Service Kit

Specifications for Using Logos

Requirements and Restrictions on IAP Kit Integration

(Optional) Using the IAP Kit Integration Skill

Getting Started

Basic Preparations

Enabling Merchant Service

Creating a Project and App

Enabling and Activating IAP Kit

(Optional) Requesting the Embedded Checkout Open Capability

(Optional) Setting Necessary Parameters

Configuring Products

Configuring Signing Information

Configuring App Identity Information

Product Purchase

Consumable or Non-consumable Purchase

Implementing the Purchase Process

Delivering a Consumable/Non-consumable Product

Auto-renewable Subscription Purchase

Understanding Auto-renewable Subscriptions

Implementing the Purchase Process

Delivering an Auto-renewable Subscription Product

Non-renewable Subscription Purchase

Implementing the Purchase Process

Delivering a Non-renewable Subscription Product

Sandbox Testing

Benefit Analysis and Reports

Issuing an Invoice

Can I Set Multiple Addresses for Receiving Key Events in AppGallery Connect?

What Is the Maximum Length of the IAP Public Key Obtained in AppGallery Connect? Is There a Recommended Length?

I Try Adding a Product on the Product Management Page in AppGallery Connect, and See a Default Price When Setting My Product Price. What's the Default Price Used for?

If the Price of an In-App Product in a Country/Region Is Changed in AppGallery Connect, Will the Price Be Affected When the Exchange Rate Changes Later?

Has AppGallery Connect Made Any Numerical Adjustments to the Price Display on the Product Management Page? For Example, Has It Adjusted the Second Decimal Place to 6 or 9?

Is the SHA-256 Certificate Mandatory for Signature Verification?

Can Signature Verification Be Performed Entirely on the Server Side?

Can the ID of a Deleted Product Be Used Again for a New Product?

What Certificates Are Supported by the Huawei IAP Server?

What Cipher Suites Are Supported by the Huawei IAP Server?

How Do I Fix the Error of an Incomplete Certificate Chain?

When an App Calls createPurchase to Launch the IAP Kit's Checkout Screen from a Child Window, the Child Window Will Be Hidden. Is This Normal?

Why Am I Asked for Real Payment When Testing in the Sandbox Environment?

Can I Use the Same API Key for a HarmonyOS Atomic Service and a HarmonyOS App?

What Are the Maximum Lengths of purchaseToken and purchaseOrderId?

What Are subGroupId (Subscription Group ID), subGroupGenerationId (Subscription Group Generation ID), and subscriptionId (Subscription ID)?

How to Handle and Use developerPayload?

How to Troubleshoot JWT Signature Verification Failures After App Migration?

How to Calculate the Validity Period for New Subscriptions upon Immediate Switch of Auto-Renewable Subscriptions?

Global Coverage of IAP Kit

Live View Design Specifications

Basic Preparations

Enabling Push Kit

Setting the Data Processing Location

Enabling Live View Kit

Performing Debugging

Applying for the Formal Permission on Live View Kit

App Development

Creating a Local Live View

Updating a Live View Through Push Kit

Frequency Control for Live View Updates

Third-Party Development Framework Access

Live View Lifecycle

Live View Template Use

Restrictions on the Number of Live Views

Introduction to Location Kit

Applying for Location Permissions

Guide of Obtaining Device Location Information

Obtaining Device Location Information (ArkTS)

Obtaining Device Location Information (C/C++)

Geocoding and Reverse Geocoding

Geofence Development

Introduction to Geofencing

On-Device GNSS Geofence Development

Personal Data Processing Statement

Displaying a Map

Changing the Map Type

Showing My Location

Displaying a Custom Map

Map Interaction

Control Interaction

Gesture Interaction

Event Interaction

Map Location Change

Drawing on a Map

PointAnnotation

BuildingOverlay

Setting the Layering Order of Map Elements

FlowFieldOverlay

MassPointOverlay

Travel Route Planning

Batch Route Computation

Trajectory-based Road Snapping

Place Details Display

Location Selection

Administrative Division Selection

Navigation and Other Capabilities Provided by the Map App

Map Calculation Tools

Coordinate Rectification

Distance Calculation

Map Not Displayed

How to Obtain siteId?

Gestures Freeze or Do Not Work

Configuring the Persistent Display of the Map Logo

Effective Scope of Scenario-based Controls' language Parameter

Personal Data Processing Information

Preparations Before Release - Obtaining the Map Service Agreement and Qualification Certificate

Map Data Copyright Statement

Supported Languages

Supported Countries/Regions

Notification Kit

Requesting Notification Authorization

Managing the Notification Badge

Managing Notification Slots

Publishing a Notification

Publishing a Text Notification

Publishing a Progress Notification

Adding a Custom Ringtone to a Notification

Adding a WantAgent Object to a Notification

Updating a Notification

Canceling a Notification

Cross-Device Notification

Cross-Device Notification Overview

Clearing Repeated Notifications Across Devices

Notification Subscription Extension Capability

Introduction to NotificationSubscriberExtensionAbility

Developing the ExtensionAbility for Notification Subscription

Applying for Priority Notification Entitlement

Developing a Shortcut to In-App Notification Settings

Integration Specifications

Skill Integration Description

Checkout Screen Design Specifications

Registering a Merchant and Obtaining the Merchant ID

(Optional) Configuration in Specific Scenarios

Enabling Payment Kit

Binding a Merchant ID to an App ID

Preparing the Certificates

On-Device App Configuration

Cloud Service Preparation

(Optional) Preparing for e-CNY Payment Integration

(Optional) Preparing for Integrating the User Identity Verification Service

Basic Payment Scenario

Combined Payment for Platform Merchants

PIN-free Payment Integration

PIN-free Payment Description

Payment with Contract Signing Scenario

Contracted Auto-Debit Scenario

e-CNY Payment Scenario

Unified Checkout Integration

Service Rule Description

Mixed Payment Scenario

External Payment Scenario

Launching the Third-Party Checkout Screen

Based on URL Redirection

Based on the API

Third-Party Payment Troubleshooting

Scenario of Guiding Users to Bind Cards

User Identity Verification Service

Real-Name Information Verification/Authorization Scenario

Face-based Identity Verification Scenario

Viewing Call Records of the Identity Verification Service

Sandbox Environment Verification

Operations Tools

Merchant Coupon Scenario

Platform Coupon

Coupon Claiming Scenario

Coupon Selection Scenario

Service and Support

In Which Scenarios Are Request Parameter Signing and Result Signature Verification Used During Integration Development?

How Can I Obtain the Public/Private Key Pair for Signing of Payment Kit?

Who Is the bodySign of a GET Request Signed For?

What Should I Do If the Checkout Screen Does Not Respond or An Error Is Reported?

Why Is No Callback Received After Successful Payment?

Will Multiple Signed Contracts Be Generated If a User Signs a Contract Repeatedly?

Where Can the PIN-free Payment Contract Signed in Huawei Pay Be Terminated?

Why Is SHA256 Used for Signature Verification of the Pre-Ordering Request, But SM2 Is Used for Signature Verification of the Payment Callback? Can Only SM2 Be Used for Signature Verification?

What Should I Do If an Error Indicating Invalid Signature Is Reported in the API Response?

What Should I Do If the Checkout Screen Displays an Error Message Indicating Service Unavailability and Asking Me to Try Again Later?

What Should I Do If an Error Indicating Abnormal Transaction Order Status Is Reported for the Pre-ordering Request?

Can prepayId Be Queried Through an API If the Payment Is Made in a Period of Time After Pre-ordering?

Can the callbackUrl Parameter in Some APIs that Provide Notification Callback Be Customized? Can a Merchant Customize the Callback Notification Packet?

What Can I Do If Multiple Callback Notifications Are Received for the Same Payment Request?

Does the Callback Notification API Provided by the Merchant Need to Be Added to the Network Trustlist in the Payment Kit Production Environment? How Do I Verify That the Provided Callback URL Can Be Properly Accessed by the Payment Kit Server?

Why Does the Payment Callback Contain the Marketing Information When the Merchant Does Not Pass the Marketing Information?

Can the Same Merchant ID, Certificate, Key, and Other Input Parameters Except for appId Be Used for the App and Atomic Service APIs?

Is There an Environment for Jointly Debugging the Access of Registered Merchants?

What Is the Relationship Between callerId in the Request Header PayMercAuth and mercNo or combineMercNo in the Request Body?

Will the Signature Be Verified for API Request If the bodySign Field in the Request Header PayMercAuth Is Empty? Or, Will the Field Be Verified First?

Why Is 000000 Returned and Refund Amount Not Received When a Refund Request Is Initiated Repeatedly with the Same Merchant Order ID?

In Addition to the Refund API in the Integration Guide, Is There Any Financial Platform Available for Refund Operations in Payment Kit? Can Refund Be Requested on Such a Platform?

What Format Should Be Used to Parse the Date After a Bill File Is Downloaded?

What Should I Do If an Error Is Reported During Checkout, Indicating App Information Verification Failure and Asking Me to Contact the Merchant?

Why Is an Entity Inconsistency Message Displayed When a Merchant ID Is Bound to an App ID?

How Can I Contact the Operating Organization or Handling Service Organization to Obtain the Development Guide?

What Should I Do If I Cannot Find the Payment Kit (Non-Virtual) Menu or the App ID Association Authorization Screen?

pdfService Capabilities

Opening and Saving a PDF Document

Adding and Deleting PDF Pages

Text, Images, and Annotations on PDF Pages

Converting a PDF Document to Images

Converting a Specified Page or Area to an Image

Converting a PDF Document to Images

Checking Whether the PDF Document Is Encrypted and Removing the Security Lock

Adding and Deleting Bookmarks

Adding and Deleting Headers and Footers

Adding and Deleting Watermarks

Adding and Deleting Backgrounds

PdfView Preview Component

Previewing a PDF Document

Opening and Saving a PDF Document

Setting the PDF Document Preview Effects

Searching for Keywords

Highlighting a PDF Document

Converting a PDF Thumbnail into an Image

Optimizing the PDF Document Switching Experience

Can I remove the header, footer, watermark, and background from a specific page using PDF Kit?

Can I Preview PDF Documents Online?

File Open Boost (C/C++)

File Open Boost Status Awareness (Deprecated)

File Cache Boost (C/C++)

Failed to Open a File Preview via the openPreview API

Preview Fails When the URI Obtained by DocumentViewPicker Is Opened Through the openPreview API

Getting Started

Integration Specifications

Enabling Push Kit

Applying for Scenario-Specific Message Permissions

Obtaining a Push Token

Pushing Scenario-Specific Messages

Pushing a Notification Message

Sending a Notification Message

Recalling a Notification Message

Pushing a Badge Update Message

Pushing a Widget Update Message

Pushing a Text-to-Speech Message

Sending a Text-to-Speech Message

Recalling a Text-to-Speech Message

Pushing a Background Message

Pushing a Live View Message

Pushing an In-App Call Message

Device-Cloud Debugging

Generating a JWT Based on a Service Account

Pushing Scenario-Specific Messages

(Optional) Developing the Message Receipt

(Optional) Viewing the Push Report

Obtaining the AAID

How Do I Handle Problems When Pushing Messages?

Why Does the Target Device Fail to Receive a Push Message After the Push API Is Successfully Called on the Cloud?

Incorrect Classification or Categorization

Push Message Upper Limit Reached

Message Frequency Control Problems

In-App Call Message Service Error Upon First Screen Lock After the Device Is Restarted

Incoming Call Banner Error of an In-App Call Message

Request URL Version Problem in a Scenario-Specific Message

How Does My App Client Receive and Display Messages While Running in the Background?

What Types of Scenario-Specific Messages Should I Choose If I Want to Implement Instant Messaging?

Pricing of the Kit

How Can I Replace the Certificate of My Message Receipt Server?

Personal Data Processing Information

Notification Content Management Rules

Push Notification Violation Penalty Criteria

Supported Countries/Regions

Book Content Parsing

Obtaining Book Information

Obtaining the Catalog Item List

Book Content Typesetting

Building a Reader

Modifying Reading Settings

Customizing the Font

Customizing the Page Background

Changing the Page-Turning Mode, Font Size, and Line Height

Adapting the Dark and Light Modes

Listening to Text Scaling Factor Value Changes

Book Content Interaction

Manually Triggering Page Turning

Notifying the Reading Progress

Scenario Fusion Kit

Development Preparations

Scenario-specific Buttons

Mobile Number Quick Verification Button

Avatar Selection Button

App Launch Button

Shipping Address Selection Button

Invoice Title Selection Button

Map Location Selection Button

Permission Settings Button

Mobile Number and Risk Level Retrieval Button

Scenario-Specific Input Component

Province/City/District Selector Input Component

Scenario-specific APIs

Obtaining System Information Attributes by API Calls

Obtaining System Information Attributes by API Calls in Asynchronous Mode

Obtaining System Setting Attributes by API Calls

Displaying the Follow Component by API Calls

File Path Conversion API

Introduction to SmartFill

Typical Scenarios

Changing the Value of ContentType Dynamically

Auto-filling Address Information in a Form

License Plate Number Filling Suggestion

Data Sources and Logic of Suggestions

ContentType Use Scenarios

Integrating SmartFill to Apps Using Third-Party Frameworks and HTML5

Supporting SmartFill for HTML5

Supporting SmartFill for HTML5 Within React Native

Supporting SmartFill for HTML5 Within Flutter

Supporting SmartFill for HTML5 Within Taro

Supporting SmartFill for HTML5 Within Weex

Supporting SmartFill for HTML5 Within mPaas

Mapping Between HTML5/Third-Party Framework Configuration Items and HarmonyOS Configuration Items

Scenario Fusion Kit FAQs

Page Cannot Be Opened When the Quick Mobile Number Verification Button Is Tapped

Failure to Launch a Third-Party App

SmartFill Selection Box Blocked by the Clipboard Paste Box

Personal Data Processing Information

Supported Countries/Regions

Screen Time Guard Kit

Configuring Signing Information

Requesting a Restricted ACL Permission

User Authorization Management

Requesting User Authorization

Revoking User Authorization

Triggering Callbacks When the App Authorization Switch Is Toggled On or Off on the Authorization List Page of Digital Balance

App Selection Page

Starting the App Selection Page

Launching the Permitted App Redirect Page

Guard Strategy Management

Adding a Strategy

Updating a Strategy

Queries Strategy Configuration Data

Starting a Strategy

Stopping a Strategy

Querying Strategy Execution Data

Deleting a Strategy

App Access Restriction

Setting App Access Restrictions

Removing App Access Restrictions

Redirecting from the Intercept Page to the Screen Time Guard App

Share Kit Terms

Experience Specifications

Precise UTD Type Required for the Host App to Initiate Content Sharing

One-Step Access to Received Data on the Target Device

Content Sharing Initiation by a Host App

Integration Modes for Host Apps

Initiating Content Sharing Through the Sharing Panel

Configuring the Target App List (Available Only to Enterprise Apps)

Customizing the Operation Area

Obtaining the Sharing Result

Shared Content Processing by a Target App

Processing the Shared Content Inside a Target App

Processing the Shared Content on the Sharing Details Page

Closing the Sharing Panel from the Sharing Details Page

Checking Whether an App Is Started by System Share

Sharing Contact Information to the Recommendation Area

Target App Design Specifications

Common Sharing Scenarios

Tap to Transfer

Tap to Transfer Between Phones

Sharing Content

Inviting a User to Join a Team

Tap to Transfer Between a Phone and a PC/2-in-1 Device

Sharing Content to a Specified In-app Page

Sharing Content Between a Phone and a PC/2-in-1 Device or Tablet

Enabling Grab & Drop on a Device

Transfer Between Trusted Devices

Sharing a Link of App Linking to Go to a Specified In-app Page

Failed to Start the System Sharing Panel

Unsupported Shared Data Type

Message "The file you selected cannot be shared." Displayed During Sharing

Applying for Wallet Kit

Digital Car Key

Preparations on the HUAWEI Wallet Server

Enabling a Car Key

Controlling a Car

Transportation Card

Preparations on Your Server

Activating a Transportation Card

Topping Up a Transportation Card

Updating a Transportation Card

Deleting a Transportation Card

Do I Have to Integrate Account Kit into My App in Order to Use Wallet Kit?

What Will Happen If a User Attempts to Add a Pass to HUAWEI Wallet Without Signing in Using a HUAWEI ID?

Which Is the Most Commonly Used Access Method?

What Operations Are Performed by My Server When a Pass Is Added?

How Can I View an Added Pass?

Why Is Only One Pass Displayed in HUAWEI Wallet After a User Claims Multiple Passes from the Same Merchant?

Which Information Will Be Deleted When a User Deletes a Pass?

Weather Service Kit

Getting Started

Obtaining Weather Data

How to Obtain the Weather Data of a Specified City

Do Weather Service Kit APIs Support the Positioning Function

No Data Returned After Minute-Level Precipitation Forecast/Weather Alert/Tide Data Is Requested

Personal Data Processing Information

AI

Agent Framework Kit

Starting an Agent Through a Function Component

Implementing A2A Protocol Communication via AgentAbilityExtension

Model Optimization

Lightweight Model

Non-Training Quantization

Plugin-based Quantization

Transformer Quantization

One-Stop Quantization for LLMs

Plugin-based Quantization

LoRA Fine-Tuning on a Quantized Base Model

Model Size Reduction Example

Model Conversion

Offline Model Conversion

Preparing for Model Conversion

Model Conversion Example

AIPP Parameters

AIPP Configuration File Used for Model Conversion

Variable data_type

On-device Deployment

Deployment Process

Model Inference

AIPP Deployment

Maintenance, Testing, and Optimization

Zero Memory Copy

In-Depth Fusion

App Integration

Creating a Project

Configuring NAPI for Your Project

Model Integration

Single-Operator Application

Ascend C Operator Development

Custom Operator Development

Introduction to Ascend C

Environment Setup

Hardware Architecture

Basic Architecture

Programming Model

Kernel Function

Hardware Architecture Abstraction

Programming Paradigm

Programming APIs

High-Level APIs

Operator Implementation

Overview of Operator Implementation

Vector Programming

Matrix Programming (High-Level APIs)

Basic Knowledge

Matrix Programming Operator Implementation

Project-based Operator Development

Overview of Project-based Operator Development

Creating an Operator Project

Project-based Operator Implementation

Operator Prototype Definition and Implementation

Operator Implementation on the Kernel

Tiling Implementation on the Host

Operator Compilation and Deployment

Operator Project Build

Installing the Operator Package

Operator Debugging and Tuning

Operator Debugging Overview

Data Preparation and Configuration

Preparing Input Data and Golden Data

Obtaining the Operator JSON Configuration Template

Configuring the Operator JSON File with Fixed Input/Output Order

Configuring the Operator JSON File with Normalized params

Debugging Functions

Tiling Debugging

CPU Twin Debugging

DumpAccChkPoint

Operator Deployment

Operator Integration into a GE Graph

Overview of Operator Graph Integration

Development Process

Graph Build and Execution

AI Framework Operator Adaptation

Overview of AI Framework Operator Adaptation

Basic Tensor Concepts

Data Layout Formats

How to Use Double Buffer to Optimize Performance

How to Allocate Workspace as Temporary Memory

How to Update a Project to the Latest Version

Parameter Description for the Operator Project Creation Tool

Debugging Tool Examples and Parameter Description

Data Generation Script Adaptation Example

Examples of the Operator JSON Configuration File

Example of the Accuracy Comparison Result

In-Place Operator Debugging Example

Parameter Description for the ascendebug Debugging Tool

Operator Development FAQs

Ascend C Operator APIs

Ascend C API List

General Restrictions

Data Type Definition

UnaryRepeatParams

BinaryRepeatParams

Scalar Computation

ScalarGetCountOfValue

ScalarCountLeadingZero

CountBitsCntSameAsSignBit

ScalarGetSFFValue

Vector Computation

Monocular Instructions

Binocular Instructions

Scalar Binocular Instructions

Scalar Ternary Instructions

Precision Conversion Instructions

Data Conversion

Data Distribution and Collection

Common Data Movement

Real-Time Format Conversion

Memory Management and Synchronization Control

GetTensorCountInQue

GetTensorCountInQue

GetSysWorkSpacePtr

SetSysWorkSpace

GetUserWorkspace

Nuclear Synchronization

PipeBarrier(ISASI)

System Variable Access

DumpAccChkPoint

GET_TILING_DATA

GET_TILING_DATA_WITH_STRUCT

High-Level APIs

Matrix Multiplication

Usage Description

Matmul Template Parameters

Usage Description

TCubeTiling Structure

Activation Function

Prototype Registration and Management

Prototype Registration API (OP_ADD)

SetInferDataType

Tiling Data Structure Registration

TilingData Structure Definition

TilingData Structure Registration

Platform Information Obtaining Platform Ascend C

CalcTschBlockDim

GetLibApiWorkSpaceSize

Internal Associated APIs

Operator Debugging APIs

ICPU_SET_TILING_KEY

Basic Data Structures and APIs

Basic Data Structures and API List

AnchorInstanceInfo

GetInstanceStart

SetInstanceStart

SetInstantiationNum

CompileTimeTensorDesc

GetOriginFormat

GetStorageFormat

GetExpandDimsType

SetStorageFormat

SetOriginFormat

SetExpandDimsType

ComputeNodeInfo

GetIrOutputsNum

GetInputInstanceInfo

GetOutputInstanceInfo

GetOutputTdInfo

MutableInputInstanceInfo

MutableOutputInstanceInfo

MutableInputTdInfo

MutableOutputTdInfo

ContinuousVectorVector

GetOverHeadLength

ContinuousVector

Expand (Outputting a New Shape)

Expand (Changing the Original Shape)

ExtendedKernelContext

GetOptionalInputDesc

GetDynamicInputDesc

GetRequiredInputDesc

GetIrInputInstanceInfo

GetIrOutputInstanceInfo

GetComputeNodeInputNum

GetComputeNodeOutputNum

GetComputeNodeInfo

InferDataTypeContext

GetInputDataType

GetOptionalInputDataType

GetRequiredInputDataType

GetOutputDataType

SetOutputDataType

InferShapeContext

GetOptionalInputShape

GetRequiredInputTensor

GetRequiredInputShape

InferShapeRangeContext

GetInputShapeRange

GetInputTensorRange

GetOptionalInputTensorRange

GetDynamicInputTensorRange

GetOptionalInputShapeRange

GetDynamicInputShapeRange

GetRequiredInputShapeRange

GetRequiredInputTensorRange

GetOutputShapeRange

OpImplRegisterV2

Constructor and Destructor

InferShapeRange

InputsDataDependency

InferOutDataTypeSameWithFirstInput

GenSimplifiedKey

TilingInputsDataDependency

OutputShapeDependOnCompute

GetListListFloat

GetOriginFormat

SetOriginFormat

GetStorageFormat

SetStorageFormat

GetExpandDimsType

SetExpandDimsType

MutableExpandDimsType

GetStorageShape

MutableOriginShape

MutableStorageShape

Constructor and Destructor

TensorPlacementUtils

CreateFollowing

GetStorageShape

MutableStorageShape

MutableOriginShape

GetStorageFormat

SetStorageFormat

GetOriginFormat

SetOriginFormat

GetExpandDimsType

SetExpandDimsType

MutableTensorData

GetOptionalInputTensor

GetRequiredInputTensor

GetOptionalInputShape

GetRequiredInputShape

GetRawTilingData

GetWorkspaceSizes

GetWorkspaceNum

GetPlatformInfo

TypedContinuousVector

TensorPlacement

Internal Associated APIs

Constructor and Destructor

Constructor and Destructor

Relational Operator Overloading

Constructor and Destructor

AutoMappingSubgraphIOIndexFuncRegister

FrameworkRegistry

Constructor and Destructor

GetAutoMappingSubgraphIOIndexFunc

AddAutoMappingSubgraphIOIndexFunc

InferenceContext

Constructor and Destructor

SetInputHandleShapesAndTypes

SetOutputHandleShapesAndTypes

GetInputHandleShapesAndTypes

GetOutputHandleShapesAndTypes

GetResourceContext

SetResourceContext

RegisterReliedOnResourceKey

AddChangedResourceKey

GetReliedOnResourceKeys

GetChangedResourceKeys

ClearChangedResourceKeys

InferFormatFuncRegister

InferShapeFuncRegister

InferValueRangeFuncRegister

Constructor and Destructor

OperatorCreatorRegister

OperatorFactory

Constructor and Destructor

AddControlInput

InferShapeAndType

GetAllAttrNamesAndTypes

GetAllIrAttrNamesAndTypes

GetDynamicInputNum

GetDynamicInputDesc

GetDynamicOutputNum

GetDynamicOutputDesc

GetDynamicSubgraph

GetDynamicSubgraphBuilder

GetInferenceContext

GetInputConstData

GetSubgraphBuilder

GetSubgraphNamesCount

GetSubgraphNames

SetInferenceContext

TryGetInputDesc

UpdateInputDesc

UpdateOutputDesc

UpdateDynamicInputDesc

UpdateDynamicOutputDesc

DynamicInputRegister

DynamicInputRegisterByIndex

DynamicOutputRegister

SubgraphCountRegister

SetSubgraphBuilder

OpRegistrationData

Constructor and Destructor

REGISTER_CUSTOM_OP

ParseParamsByOperatorFn

FusionParseParamsFn

FusionParseParamsFn (Overload)

ParseSubgraphPostFn

ParseOpToGraphFn

DelInputWithCond

DelInputWithOriginalType

GetOriginOpTypeSet

GetFrameworkType

GetParseParamFn

GetParseParamByOperatorFn

GetFusionParseParamFn

GetFusionParseParamByOpFn

GetParseSubgraphPostFn

GetParseOpToGraphFn

AutoMappingByOpFn

AutoMappingFnDynamic

AutoMappingByOpFnDynamic

AutoMappingSubgraphIndex

InputReorderVector

Constructor and Destructor

Constructor and Destructor

Constructor and Destructor

GetExpandDimsRule

GetOriginFormat

SetExpandDimsRule

SetOriginFormat

SetUnknownDimNumShape

Constructor and Destructor

GetExpandDimsRule

GetOriginFormat

GetOriginShapeDim

GetOriginShapeDimNum

SetExpandDimsRule

SetOriginFormat

SetOriginShapeDim

SetOriginShapeDimNum

DataTypeToAscendString

AscendStringToDataType

FormatToAscendString

AscendStringToFormat

DataTypeToSerialString

SerialStringToDataType

FormatToSerialString

SerialStringToFormat

DataFormatToFormat

GetDataTypeLength

VerifyFuncRegister

ConvertToAscendString

ConvertToListAscendString

GetFormatFromC0

GetFormatFromSub

GetFormatFromSubAndC0

GetPrimaryFormat

GetSizeByDataType

ge::graphStatus

BROADCAST_INFER

COMMON_INFER_FUNC_REG

DECLARE_ERRORNO

ELMTWISE_INFER_SHAPEANDTYPE

IMPLEMT_COMMON_INFERFUNC

IMPLEMT_INFERFORMAT_FUNC

IMPLEMT_INFERFUNC

IMPLEMT_VERIFIER

INFER_FORMAT_FUNC_REG

Prototype Definition (REG_OP)

Prototype Definition Derivative APIs

VERIFY_FUNC_REG

Ascend C-to-Kirin Compatibility Porting Guide

Mapping Between Ascend and Kirin AI Processors of the Same Generation

Ascend 910B/Ascend 910C-to-Kirin X90/Kirin 9030 Porting Guide

Basic API Porting Guide

Atomic Operation

Synchronization Control

Matrix Computing

Resource management

System Variables

High-Level API Porting Guide

Operator Compilation Porting Guide

LLM Capability Openness

CANN LLM Model Quantization

Quantization Procedure

Environment Setup

Three-Stage Quantization Procedure

Quantization Effect Evaluation

CANN LLM Model Conversion

Exporting the Original Model as a Friendly-Structure ONNX Model

Converting an ONNX Model to a CANN Model

How Can I Determine Whether a Model Can Run on Mobile Phones?

What Are the Data Formats Supported by the Inference Function?

What Should I Do if the Type of the Output Operator Is Incorrect for the OMG Offline Model?

How can I determine which operators have better performance on CANN during model design?

How to Obtain the Version

Supported Operators

Visualization Tool

Core Speech Kit

Speech Recognition

Personal Data Processing Information

Core Vision Kit

Face Verification

Subject Segmentation

Multi-object Detection

Skeleton Detection

Image Super Resolution

Searching for Images by Text

Personal Data Processing Information

Intents Kit Integration Process

Habit-based Recommendation Solution

Integration Solution

Testing Solution

Event-based Notification Solution

Integration Solution

Testing Solution

Location-based Recommendation Solution

Integration Solution

Skill Call Solution

Integration Solution

Integration in Task Execution Scenarios via a Configuration File

Integration in Task Execution Scenarios via a Decorator

Solution Overview

Integration via a Link-based Decorator

Integration via a Page-based Decorator

Integration via a Function-based Decorator

Definition Rules for Custom Intents

One-Step Access to Functions

Local Search Solution

Integration Solution

Function Search Solution

Content Search Solution

What Should I Do If the Error Message "Intent 'xxxxxx' is not included in domain 'xxxxxx'. Select an intent from the list of suggestions." Is Displayed for intentName?

What Should I Do If the Error Message "Value should be one of: "intentName", "domain", "intentVersion", "srcEntry", "uiAbility", "serviceExtension", "uiExtension", "form"" Is Displayed for inputParams?

What Should I Do If the App Launched by Celia Exits Unexpectedly When I Use the Intents Kit Debug Assistant Agent for Joint Debugging?

Is There a Cloud-based Dynamic Slot Declaration Solution for the One-Step Function Access Scenario?

Appendix A: How to Obtain the UID of a HUAWEI ID

MindSpore Lite Kit

Using MindSpore Lite for Model Conversion

Model Deployment

Using MindSpore Lite for Model Inference (C/C++)

Using the MindSpore Lite Engine for On-Device Training (C/C++)

Using MindSpore Lite for Image Classification (ArkTS)

Using MindSpore Lite for Image Classification (C/C++)

Using MindSpore Lite for Speech Recognition (C/C++)

MindSpore Lite Kit Operator List

MindSpore Lite Kit Glossary

Natural Language Kit

Word Segmentation

Entity Extraction

Neural Network Runtime Kit

Connecting NNRt to an AI Inference Framework

Reading Control

AI Caption Control

Face Liveness Detection

Card Recognition

Document Scanning

AI Image Recognition

Personal Data Processing Information

Hopping

Free Hopping Documentation Path Adjustment

NDK Development

Creating an NDK Project

Building an NDK Project

Building an NDK Project with the DevEco Studio Template

Building NDK Projects with Command-Line CMake

Building an NDK Project with Prebuilt Libraries

BiSheng Compiler

Integrating a Third-Party Dynamic Link Library

Code Development

C/C++ Standard Library

C/C++ Library Mechanisms

Using Node-API for ArkTS/JS and C/C++ Language Interaction

Node-API Overview

Node-API Status Codes

Node-API Data Types and APIs

Node-API Development Specifications

Node-API Development Process

Node-API Guides

Using Node-API Extension APIs

Working with Arrays Using Node-API

Working with ArrayBuffer Using Node-API

Working with BigInt Using Node-API

Working with Buffer Using Node-API

Creating Basic Data Types Using Node-API

Working with Class Using Node-API

Working with Cleanup Hooks Using Node-API

Working with Date Using Node-API

Error Handling Using Node-API

Associating Data with a Running Environment to Tie Their Lifecycle Using Node-API

Working with Functions Using Node-API

Performing Lifecycle Management Using Node-API

Working with Objects Using Node-API

Working with Other Node-API Utilities

Working with Primitives Using Node-API

Implementing Asynchronous Operations Using Node-API

Setting ArkTS Object Properties Using Node-API

Working with String Using Node-API

Customizing Asynchronous Operations Using Node-API

Typical Node-API Use Cases

Asynchronous Task Development Using Node-API

Thread Safety Development Using Node-API

Wrapping a Native Object in an ArkTS Object

Wrapping a Native Object in a Sendable ArkTS Object

Creating an ArkTS Runtime Environment Using Node-API

Loading a Module in the Main Thread Using Node-API

Running or Stopping an Event Loop in an Asynchronous Thread Using Node-API Extension APIs

Loading a Module Using Node-API

Passing a Task with the Specified Priority to an ArkTS Thread from an Asynchronous Thread Using Node-API

Creating, Switching, and Destroying a Context in a Thread Using Node-API Extension APIs

Creating a Strong Reference to an ArkTS Object Using Node-API Extension APIs

Creating and Destroying a Critical Scope and Accessing String Content Using Node-API Extension APIs

Analyzing Error Logs and Crashes Triggered by Using Node-API

Calling an ArkTS Method with Return Value of a promise Using Node-API

Creating a Sendable Strong Reference to an ArkTS Object Using Node-API Extension APIs

Accelerating Property Access Using Extended Node-APIs

FAQs About Stability

FAQs About Memory Leaks

FAQs About Basic Functionalities

JSVM-API Overview

JSVM-API Data Types and APIs

JSVM-API Development Process

JSVM-API Development Specifications

JSVM-API Development Specifications

JSVM-API Guides

Working with Tasks Using JSVM-API

Working with VM Snapshots Using JSVM-API

Working with Wasm Using JSVM-API

Creating and Calling JS Functions Using JSVM-API

Performing JSON Operations Using JSVM-API

Working with Arrays Using JSVM-API

Working with ArrayBuffer Using JSVM-API

Creating an ArrayBuffer from External Memory Using JSVM-API

Working with BigInt Using JSVM-API

Working with Classes Using JSVM-API

Working with Date Using JSVM-API

Performing Debug Operations Using JSVM-API

Working with Objects Using JSVM-API

Working with Primitives Using JSVM-API

Implementing Asynchronous Operations Using JSVM-API

Setting JS Object Properties Using JSVM-API

Creating and Obtaining String Values Using JSVM-API

Obtaining the JSVM-API Version Using JSVM-API

Error Handling Using JSVM-API

Debugging and Profiling JS Code Using JSVM-API

Performing Lifecycle Management Using JSVM-API

Performing Memory Management Using JSVM-API

Comparing JS Values Using JSVM-API

Customizing Exception Handling Using JSVM-API

Triggering GC Using JSVM-API

Using JSVM-API to Obtain Heap Snapshots and Monitor Heap Memory Thresholds

Setting the private Property Using JSVM-API

Working with Latin1/UTF16 Strings Using JSVM-API

Using Proxy APIs Provided by JSVM-API

Working with Well-Known Symbols Using JSVM-API

Working with Wrapper Objects Using JSVM-API

Creating and Obtaining Values Using JSVM-API

Typical JSVM-API Use Cases

JSVM-API Debugging

Working with Trace Using JSVM-API

Requesting the JIT Profile for JSVM-API

JSVM-API Secure Shield Mode

Troubleshooting JSVM-API Memory Leaks

JSVM-API Tuning and Performant Coding Cases

Creating and Destroying JSVMs Using JSVM-API

Accelerating Compilation Using a Code Cache

JSVM Tuning Practices

JSVM Performance Debugging Guides

Using HiSmartPerf to Collect JSVM Trace

Analyzing Web Page Memory Using DevTools

Using Longque JS APIs

OpenMP Overview

Building and Running Applications Using OpenMP

Resource Management

Raw File Development

Bundle Management

Native Bundle Development

Compilation Toolchain

Using GN to Configure the HarmonyOS Build Toolchain

Using CMake to Configure the HarmonyOS Build Toolchain

Using Make to Configure the HarmonyOS Build Toolchain

Using the Configure Tool to Configure the HarmonyOS Build Toolchain

Quickly Building Third-Party Libraries Using the Lycium Cross-Compilation Framework

Passing Complex Parameters Across Languages

Implementing Communication Between Native Child Threads and the UI Main Thread

Debugging and Profiling

C/C++ Memory Error Detection

Hardware Compatibility

Using Neon Instructions

Tools

Environment Setup

Downloading and Installing DevEco Studio

Using the New UI

Creating a Project

Project Overview

Project Directory Structure

Introduction to Project Templates

Creating a Project

Managing Modules

Adding and Deleting a Module

Importing and Referencing a Module

Unloading and Loading a Module

Developing, Publishing, and Managing Shared Packages

Developing a Static Shared Package

Developing a Dynamic Shared Package

Publishing a Shared Package

Referencing and Managing a Shared Package

ohpm-repo: Private Repository Setup Tool

Getting Started

Setting the Configuration File

Related Commands

ohpm-repo install

ohpm-repo start

ohpm-repo restart

ohpm-repo --version

ohpm-repo encrypt_password

ohpm-repo deploy

ohpm-repo restore

ohpm-repo mirror_storage

ohpm-repo check_storage

ohpm-repo remove_instance

Data Migration Commands

ohpm-repo export_pkginfo

ohpm-repo batch_download

ohpm-repo batch_publish

ohpm-repo export_userinfo

ohpm-repo import_userinfo

ohpm-repo export_pkgPermission

ohpm-repo import_pkgPermission

Deployment Guide

Single-Node Deployment

Multi-Instance Deployment

Personal Center Home Page

User Management

Repository Management

Package Permission Management

Authentication Management

Organization Management

System Settings

Security Configuration

Version Upgrade

Upgrading from 1.0.1 to 2.X.X/5.X.X

Upgrading from 1.1.0 to 2.X.X/5.X.X

Upgrading 2.X.X/5.X.X to a Later Version

Storage Plug-in Customization

Storage Plugin Configuration

Authentication Plug-in Customization

Authentication Plugin Configuration

Custom Login Authentication Plugin

Custom Login Verification Plugin Configuration

Export of Metadata from the Central Repository of the OpenHarmony Third-Party Library to ohpm-repo

ohpm Repository Interface Protocol

Custom Metadata Validation Rule Plugin

Deploying the ohpm-repo Service Using a Dockerfile

Adding an Ability

Generating a Single-Layer Icon

Creating a Service Widget

Creating an Insight Intent

Setting Up the Development Environment Offline

Coding and Debugging

Code Generation/Completion

Real-time Code Check and Quick Fix

Running Code Linter

Code Linter Check Rules

Recommended Rules

@typescript-eslint: General Rules

@typescript-eslint/adjacent-overload-signatures

@typescript-eslint/array-type

@typescript-eslint/await-thenable

@typescript-eslint/ban-ts-comment

@typescript-eslint/ban-tslint-comment

@typescript-eslint/ban-types

@typescript-eslint/brace-style

@typescript-eslint/class-literal-property-style

@typescript-eslint/comma-dangle

@typescript-eslint/comma-spacing

@typescript-eslint/consistent-indexed-object-style

@typescript-eslint/consistent-type-assertions

@typescript-eslint/consistent-type-definitions

@typescript-eslint/consistent-type-imports

@typescript-eslint/default-param-last

@typescript-eslint/dot-notation

@typescript-eslint/explicit-function-return-type

@typescript-eslint/explicit-member-accessibility

@typescript-eslint/explicit-module-boundary-types

@typescript-eslint/func-call-spacing

@typescript-eslint/init-declarations

@typescript-eslint/keyword-spacing

@typescript-eslint/lines-between-class-members

@typescript-eslint/member-delimiter-style

@typescript-eslint/member-ordering

@typescript-eslint/method-signature-style

@typescript-eslint/naming-convention

@typescript-eslint/no-array-constructor

@typescript-eslint/no-base-to-string

@typescript-eslint/no-confusing-non-null-assertion

@typescript-eslint/no-confusing-void-expression

@typescript-eslint/no-dupe-class-members

@typescript-eslint/no-duplicate-imports

@typescript-eslint/no-dynamic-delete

@typescript-eslint/no-empty-function

@typescript-eslint/no-empty-interface

@typescript-eslint/no-explicit-any

@typescript-eslint/no-extraneous-class

@typescript-eslint/no-extra-non-null-assertion

@typescript-eslint/no-extra-parens

@typescript-eslint/no-extra-semi

@typescript-eslint/no-floating-promises

@typescript-eslint/no-for-in-array

@typescript-eslint/no-implicit-any-catch

@typescript-eslint/no-implied-eval

@typescript-eslint/no-inferrable-types

@typescript-eslint/no-invalid-this

@typescript-eslint/no-invalid-void-type

@typescript-eslint/no-loop-func

@typescript-eslint/no-loss-of-precision

@typescript-eslint/no-magic-numbers

@typescript-eslint/no-misused-new

@typescript-eslint/no-misused-promises

@typescript-eslint/no-namespace

@typescript-eslint/no-non-null-asserted-optional-chain

@typescript-eslint/no-non-null-assertion

@typescript-eslint/no-parameter-properties

@typescript-eslint/no-redeclare

@typescript-eslint/no-require-imports

@typescript-eslint/no-restricted-syntax

@typescript-eslint/no-shadow

@typescript-eslint/no-this-alias

@typescript-eslint/no-throw-literal

@typescript-eslint/no-type-alias

@typescript-eslint/no-unnecessary-boolean-literal-compare

@typescript-eslint/no-unnecessary-condition

@typescript-eslint/no-unnecessary-qualifier

@typescript-eslint/no-unnecessary-type-arguments

@typescript-eslint/no-unnecessary-type-assertion

@typescript-eslint/no-unnecessary-type-constraint

@typescript-eslint/no-unsafe-argument

@typescript-eslint/no-unsafe-assignment

@typescript-eslint/no-unsafe-call

@typescript-eslint/no-unsafe-member-access

@typescript-eslint/no-unsafe-return

@typescript-eslint/no-unused-expressions

@typescript-eslint/no-unused-vars

@typescript-eslint/no-use-before-define

@typescript-eslint/no-useless-constructor

@typescript-eslint/prefer-as-const

@typescript-eslint/prefer-enum-initializers

@typescript-eslint/prefer-for-of

@typescript-eslint/prefer-function-type

@typescript-eslint/prefer-includes

@typescript-eslint/prefer-literal-enum-member

@typescript-eslint/prefer-namespace-keyword

@typescript-eslint/prefer-nullish-coalescing

@typescript-eslint/prefer-optional-chain

@typescript-eslint/prefer-readonly

@typescript-eslint/prefer-readonly-parameter-types

@typescript-eslint/prefer-reduce-type-parameter

@typescript-eslint/prefer-regexp-exec

@typescript-eslint/prefer-string-starts-ends-with

@typescript-eslint/prefer-ts-expect-error

@typescript-eslint/promise-function-async

@typescript-eslint/quotes

@typescript-eslint/require-array-sort-compare

@typescript-eslint/require-await

@typescript-eslint/restrict-plus-operands

@typescript-eslint/restrict-template-expressions

@typescript-eslint/return-await

@typescript-eslint/semi

@typescript-eslint/space-before-function-paren

@typescript-eslint/space-infix-ops

@typescript-eslint/strict-boolean-expressions

@typescript-eslint/switch-exhaustiveness-check

@typescript-eslint/triple-slash-reference

@typescript-eslint/type-annotation-spacing

@typescript-eslint/typedef

@typescript-eslint/unbound-method

@typescript-eslint/unified-signatures

@security: Security Rules

@security/no-commented-code

@security/no-cycle

@security/no-unsafe-aes

@security/no-unsafe-dh

@security/no-unsafe-dsa

@security/no-unsafe-dh-key

@security/no-unsafe-dsa-key

@security/no-unsafe-ecdsa

@security/no-unsafe-hash

@security/no-unsafe-mac

@security/no-unsafe-rsa-encrypt

@security/no-unsafe-rsa-key

@security/no-unsafe-rsa-sign

@security/no-unsafe-3des

@security/specified-interface-call-chain-check

@security/no-unsafe-kdf

@security/no-unsafe-sm4

@security/no-unsafe-sm2-key

@security/no-unsafe-sm2-cipher

@security/no-unsafe-ecdh

@security/no-unsafe-huks

@performance: Performance Rules

@performance/avoid-overusing-custom-component-check

@performance/bad-deep-clone-check

@performance/constant-property-referencing-check-in-loops

@performance/crypto-replacement-check

@performance/custom-node-memory-leak-check

@performance/dark-color-mode-check

@performance/datashare-query-unrelease-check

@performance/foreach-args-check

@performance/foreach-index-check

@performance/gif-hardware-decoding-check

@performance/hp-arkui-avoid-update-auto-state-var-in-aboutToReuse

@performance/hp-arkui-avoid-empty-callback

@performance/hp-arkui-combine-same-arg-animateto

@performance/hp-arkui-image-async-load

@performance/hp-arkui-load-on-demand

@performance/hp-arkui-limit-refresh-scope (Deprecated)

@performance/hp-arkui-no-func-as-arg-for-reusable-component

@performance/hp-arkui-no-high-freq-log (Deprecated)

@performance/hp-arkui-no-stringify-in-lazyforeach-key-generator

@performance/hp-arkui-no-state-var-access-in-loop

@performance/hp-arkts-no-use-any-export-current

@performance/hp-arkts-no-use-any-export-other

@performance/hp-arkui-remove-container-without-property

@performance/hp-arkui-replace-nested-reusable-component-by-builder

@performance/hp-arkui-reduce-pangesture-distance

@performance/hp-arkui-remove-redundant-nest-container

@performance/hp-arkui-remove-redundant-state-var

@performance/hp-arkui-remove-unchanged-state-var

@performance/hp-arkui-set-cache-count-for-lazyforeach-grid

@performance/hp-arkui-suggest-cache-avplayer

@performance/hp-arkui-suggest-reuseid-for-if-else-reusable-component

@performance/hp-arkui-suggest-use-effectkit-blur

@performance/hp-arkui-suggest-use-get-anonymousid-async

@performance/hp-arkui-use-attributeUpdater-control-refresh-scope

@performance/hp-arkui-use-grid-layout-options

@performance/hp-arkui-use-id-in-get-resource-sync-api

@performance/hp-arkui-use-local-var-to-replace-state-var

@performance/hp-arkui-use-onAnimationStart-for-swiper-preload

@performance/hp-arkui-use-object-link-to-replace-prop

@performance/hp-arkui-use-row-column-to-replace-flex

@performance/hp-arkui-use-reusable-component

@performance/hp-arkui-use-scale-to-replace-attr-animateto

@performance/hp-arkui-use-taskpool-for-web-request

@performance/hp-arkui-use-transition-to-replace-animateto

@performance/hp-arkui-use-word-break-to-replace-zero-width-space

@performance/hp-arkui-wrap-waterflow-if-else-footer (Deprecated)

@performance/high-frequency-log-check

@performance/hp-ffrt-no-use-std

@performance/hp-performance-no-closures

@performance/hp-performance-no-dynamic-cls-func

@performance/init-list-component

@performance/js-code-cache-by-interception-check

@performance/js-code-cache-by-precompile-check

@performance/lazyforeach-args-check (Deprecated)

@performance/lottie-animation-destroy-check

@performance/multiple-associations-state-var-check

@performance/monitor-invisible-area-in-image-animation

@performance/no-use-any-import

@performance/no-high-loaded-frame-rate-range

@performance/number-init-check

@performance/nested-post-frame-callback-check

@performance/object-creation-check (Deprecated)

@performance/reasonable-audio-use-check

@performance/reasonable-gps-use-check

@performance/reuse-date-instances-check

@performance/reasonable-sensor-use-check

@performance/sparse-array-check

@performance/start-window-icon-check

@performance/state-variable-usage-in-ui-format-check

@performance/typed-array-check

@performance/timezone-interface-check

@performance/tabs-on-change-check

@performance/update-state-var-between-animatetos-check

@performance/web-cache-mode-check

@performance/web-on-active-check

@performance/waterflow-data-preload-check

@previewer: Preview Rules

@previewer/mandatory-default-value-for-local-initialization

@previewer/no-page-method-on-preview-component

@previewer/no-unallowed-decorator-on-root-component

@cross-device-app-dev: Rules Oriented to One-time Development for Multi-device Deployment

@cross-device-app-dev/color-contrast

@cross-device-app-dev/color-value

@cross-device-app-dev/font-size-unit

@cross-device-app-dev/font-size

@cross-device-app-dev/grid-columns-span

@cross-device-app-dev/grid-span-value

@cross-device-app-dev/one-multi-breakpoint-check

@cross-device-app-dev/sidebar-navigation

@cross-device-app-dev/size-unit

@cross-device-app-dev/touch-target-size

@cross-device-app-dev/window-size-change-listener-check

@cross-device-app-dev/immersive-effect-check

@hw-stylistic: ArkTS Code Style Rules

@hw-stylistic/array-bracket-spacing

@hw-stylistic/brace-style

@hw-stylistic/comma-spacing

@hw-stylistic/curly

@hw-stylistic/file-naming-convention

@hw-stylistic/indent

@hw-stylistic/keyword-spacing

@hw-stylistic/max-len

@hw-stylistic/no-multi-spaces

@hw-stylistic/no-tabs

@hw-stylistic/object-property-newline

@hw-stylistic/one-var-declaration-per-line

@hw-stylistic/operator-linebreak

@hw-stylistic/quotes

@hw-stylistic/semi-spacing

@hw-stylistic/space-before-blocks

@hw-stylistic/space-before-function-paren

@hw-stylistic/space-infix-ops

@correctness: Correctness Rules

@correctness/avsession-buttons-check

@correctness/audio-interrupt-check

@correctness/audio-pause-or-mute-check

@correctness/avsession-metadata-check

@correctness/image-pixel-format-check

@correctness/image-interpolation-check

@correctness/listen-default-network-change

@correctness/listen-multi-network-concurrent

@correctness/multimedia-use-stride-in-image-receiver

@correctness/redundant-dependency-check

@correctness/v1-nested-object-property-change-format-check

@correctness/v1-state-object-member-used-in-function-parameter-check

@correctness/accessibility-label-check

@correctness/accessibility-focus-redundancy-check

@correctness/accessibility-type-redundancy-check

@correctness/accessibility-status-missing-check

@compatibility: Compatibility Rules

@compatibility/api-compatibility-check

@compatibility/deprecate-api-check

Clang-Tidy Code Inspection

Code Refactoring

ArkTSDoc Generation

Document Generation

Quickly Inserting Scenario-based Code Snippets

Cross-language Code Editing

Code Indexing (clangd)

Previewing the UI

PreviewChecker Inspection Rules

Previewing an ArkTS/JS App/Atomic Service

Previewing an ArkUI Page or Component

Using Profile Manager

Previewing Your App/Atomic Service on Multiple Devices

Using Inspector Bidirectional Preview

Mocking Preview Data

Debugging Your App Using the Previewer

List of Previewer-Capable APIs

Configuring a Debug Signature

Signing Your App/Service Automatically

Signing Your App/Atomic Service Manually

Running Your App on a Local Real Device

Running a Lite Wearable App via the Simulator

Running Your App on the Emulator

Working Environment

Supported Devices

Differences Between the Emulator and the Real Device

Managing the Emulator

Creating an Emulator

Starting/Stopping the Emulator

Using the Emulator

Controlling the Screen

Using the Toolbar

Moving and Scaling the Emulator

Accessing the Network Using the Emulator

Installing an App Package and Uploading Files

Using Extended Features

Modifying the Emulator

Customizing the Virtual Device Screen

Using the Emulator via the CLI

Deploying an Emulator Offline

Emulator Error Codes

Debugging Your App

Debugging Overview

Running/Debugging Configuration

Debugging ArkTS Code

Debugging Scenario Description

Starting Debugging in Debug Mode

Starting Debugging in Attach Mode

Using Wait-for-Debugger Mode

Using Breakpoints

Checking Variables

Performing Reverse Debugging

Debugging Extension Abilities

Performing Multi-Process Debugging

Printing Expressions

Using Smart Step Into

Viewing Asynchronous Function Call Stacks

Native Code Debugging

Starting the Debugging Process

Using Breakpoints

Checking Variables

Debugging Assembly Code

Viewing Memory Information

Using LLDB Debugging Commands

Performing Reverse Debugging

Visualizing Call Stacks

Visualizing .so Information

Setting Execution Points

Using Smart Step Into

Speeding Up Native Debugging Startup

Debugging Native Child Processes

Using the Debugger

Performing Cross-Language Debugging

Debugging Third-Party Library Source Code

Performing Incremental Debugging

Using Hot Reload

Viewing ArkUI State Variables

Using Developer Options

Analyzing UI Layouts

Accessing Device Files

Location Simulation

Debugging Databases

Capturing Screenshots

Recording Screens

Mirroring Device Screens

Debugging Error Codes

Runtime Configuration Error Codes

Hot Reload and Incremental Debugging Error Codes

Debugging Error Codes

hdc Command Error Codes

Analyzing Logs and Faults

Viewing Cpp Crash Logs

Viewing AppFreeze Logs

Viewing App Killed Logs

Parsing App minidump/coredump Files

Analyzing Stack Traces

Analyzing Exception Stack Traces

ASan: Detecting Memory Errors

HWASan: Detecting Memory Errors

TSan: Detecting Thread Errors

UBSan: Detecting Undefined Behaviors

ArkCompiler: Detecting Runtime Issues

Conducting Self-Test

Instrument Test

Black-box coverage

Test Framework Error Codes

Instrument Test Error Codes

Local Test Error Codes

CLI Test Error Codes

Setting Up the Proxy

Terminal Environment Variables

DevEco Studio Parameters

Disabling Data Collecting

Log Collection and Diagnosis Data

ohpm Version Number Rules

pac.json5 Privacy Manifest File

Building an App

Build System Lifecycle

Configuration Files

hvigor-config.json5 File

Project-level build-profile.json5 File

Module-level build-profile.json5 File

Configuring Your Build

Managing Modules

Adding Dependencies

Configuring Multiple Targets and Products

Configuring for C++ Builds

Quick Link to a Pre-built Library

Implementing Multi-project Builds

Understanding the Logic for Checking HAP Uniqueness

Customizing the .hvigor Directory Path

Customizing Your Build

Customizing Build Options

Obtaining Customized Build Parameters

Dynamically Modifying the Build Configuration

Improving Build Efficiency

Default Features

Using the Daemon Process

Enabling Parallel Build

Conducting an Incremental Build

Conducting Modular Compilation

Analyzing the Build Process

Performance/Memory Optimization Practices: Multi-Target Build

Performance/Memory Optimization Practices: Multi-HAP/Multi-HSP Build

Performance Optimization Practices: Custom Plugins and Tasks

Performance Optimization Practices: Mixed-Language Project Synchronization

Performance Optimization Practices: Cache Plugins

Memory Optimization Practices: Remote Build

Experimental Features

Expanding Build Capabilities

Developing an Hvigor Task

Developing an Hvigor Plugin

Using APIs for Extending Your Build

Basic Build Capabilities

API Usage Examples

Task Visualization and Execution

Using Obfuscation for Code Hardening

Troubleshooting Build Errors

Compilation and Building FAQs

Build Error Codes

Dependency Error Codes

Script Error Codes

Configuration Error Codes

Resource Missing Error Codes

Syntax Error Codes

Specification Error Codes

Permission Error Codes

Operation Error Codes

ArkTS Compilation Error Codes

Performance Optimization

Introduction to Performance Optimization Tools

Introduction to DevEco Profiler

Using DevEco Profiler

Performance Profiling Procedure

Realtime Monitor for Problem Demarcating

In-depth Capture for Problem Locating

Janky Frames Analysis

Analyzing App Stuttering Issues Using the Frame Template

Cold Start Analysis: Launch

Basic Operations with Launch Analysis

Case: Analyzing the First Frame Completion Delay During Cold Start

Memory Leak Analysis: Snapshot

Basic Operations with Memory Snapshot Analysis

Analyzing the ArkTS Memory Leak

Memory Analysis: Allocation

Filtering Memory Analysis Data

Analyzing Memory at Launch

Analyzing the Native Memory Leak

UI Component Memory Analysis: ComMemory

Energy Consumption Diagnosis: Energy

Loading and Frame Loss Analysis: ArkWeb

Network Diagnosis: Network

Parallelism and Concurrency Analysis: Concurrency

GPU Activity Analysis

Basic Time Analysis: Time

CPU Activity Analysis

I/O Latency Analysis: FileSystem

DevEco Profiler Terms

App Release

Command Line Tools

Obtaining Command Line Tools

Using codelinter

Using the Emulator

System Platform Requirements

oh-package.json5

Common Commands

ohpm prepublish

ohpm cache clean

ohpm dependency-check

ohpm config Error Codes

ohpm info Error Codes

ohpm install Error Codes

ohpm list Error Codes

ohpm publish Error Codes

ohpm uninstall Error Codes

ohpm unpublish Error Codes

ohpm update Error Codes

ohpm version Error Codes

ohpm cache clean Error Codes

ohpm run Error Codes

ohpm ping Error Codes

ohpm clean Error Codes

ohpm dist-tags Error Codes

ohpm convert Error Codes

ohpm dependency-check Error Codes

Common ohpm Command Error Codes

ArkTSDoc Generator (arktsdoc)

Setting Up a Pipeline

OpenMP Overview

Last updated: 2026-09-04 06:52

Content overview

Version Description

Open Multi-Processing (OpenMP) provides a set of APIs that support multi-platform shared memory multiprocessing programming. It consists of a set of compiler directives, library routines, and environment variables that influence runtime behavior. It provides high-level abstract description of parallel algorithms, making it suitable for developing parallel applications on multi-core processor devices. Based on the pragma directives added to the application, the compiler automatically processes the application segments in parallel. Using OpenMP can reduce the complexity of parallel programming.

When to Use

OpenMP has been widely used in scientific computing, image processing, machine learning, financial computing, bioinformatics and other high-performance computing fields. It is particularly suitable for computing-intensive tasks and addressing data parallelism issues. By simplifying the development process of multi-core parallelization, OpenMP helps efficiently utilize the multi-core resources of modern processors and addresses traditional parallel programming challenges, such as complex thread management, uneven task loads, and performance bottlenecks. With the flexible scheduling mechanism and cross-platform support of OpenMP, applications can significantly enhance performance while maintaining code simplicity and portability. OpenMP is a crucial tool for improving both the development and computing efficiency.

Version Description

Currently, HarmonyOS uses the OpenMP library implemented in llvm 15.0.4. For details about the corresponding OpenMP API version, see clang-OpenMPSupport.

For details about how to use OpenMP in HarmonyOS apps, see Building and Running Applications Using OpenMP.

Building and Running Applications Using OpenMP

Send feedback

Was this page helpful?

Send feedback

Reach out to us through the community for any other questions.

Community Q&A Intelligent Assistant

Search in Guides

Search only in OpenMP SupportSearch titles only

Enter a keyword.