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

Archived

Application Development Overview

Building the First ArkTS Application in Stage Model

Development Fundamentals

Application Package Fundamentals

Application Package Overview

Application Package Structure

Application Package Structure in Stage Model

Application Package Structure in FA Model

Application Package Development and Usage

Application Installation, Uninstall, and Update

Application Configuration Files in Stage Model

Overview of Application Configuration Files in Stage Model

app.json5 Configuration File

module.json5 Configuration File

Application Configuration Files in FA Model

Overview of Application Configuration Files in FA Model

Internal Structure of the app Tag

Structure of the deviceConfig Tag

Structure of the module Tag

Typical Scenarios Development

Converting HAR to HSP

Converting HSP to HAR

Creating a Static Shortcut of the Application

Creating an Application Clone

Creating an Application Multi-Instance

Configuring Layered Icons

Resource Categories and Access

Getting Started with ArkTS

Introduction to ArkTS

ArkTS Coding Style Guide

TypeScript to ArkTS Migration Guide

ArkTS Migration Background

TypeScript to ArkTS Cookbook

Adaptation Cases

ArkTS Performant Programming Practices

Basic Syntax of UI Paradigms

Basic Syntax Overview

Declarative UI Description

Custom Components

Creating a Custom Component

Page and Custom Component Lifecycle

Custom Component Layout

Constraints on Access Modifiers of Custom Component Member Variables

@Builder Decorator: Custom Builder Function

@LocalBuilder Decorator: Maintaining the Parent-Child Relationship Between Component and State Management

@BuilderParam Decorator: @Builder Function Reference

wrapBuilder: Encapsulating Global @Builder

@Styles Decorator: Definition of Reusable Styles

@Extend Decorator: Extension of Built-in Components

stateStyles: Polymorphic Style

@AnimatableExtend Decorator: Definition of Animatable Attributes

@Require Decorator: Validating Constructor Input Parameters

@Reusable Decorator: Reusing Components

State Management

State Management Overview

State Management (V1)

Component State Management

@State Decorator: State Owned by Component

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

@Link Decorator: 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

Application State Management

Application State Management Overview

LocalStorage: Storing UI State

AppStorage: Storing Application-wide UI State

PersistentStorage: Persisting Application State

Environment: Device Environment Query

Other State Management Features

Overview of Other State Management Features

@Watch Decorator: Getting Notified of State Variable Changes

$$ Syntax: Two-Way Synchronization of Built-in Components

@Track Decorator: Class Object Property-level Update

Freezing a Custom Component

Best Practices for State Management

Proper Use of State Management

State Management (V2)

V2 Exclusive Decorators

@ObservedV2 and @Trace Decorators: Observing Class Property Changes

@ComponentV2 Decorator: Custom Component

@Local Decorator: Representing the Internal State of Components

@Param Decorator: Inputting External Parameters to Components

@Once: Implementing Initialization Once

@Event Decorator: Component Output

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

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

@Computed Decorator: Computed Property

@Type Decorator: Marking the Types of the Class Property

Other State Management Features

AppStorageV2: Storing Application-wide UI State

PersistenceV2: Persisting Application State

!! Syntax: Two-Way Binding

Freezing a Custom Component

Repeat: Reusing Child Components

getTarget API: Obtaining Original Objects

makeObserved API: Changing Unobservable Data to Observable Data

Mixed Use and Migration Guide for V1 and V2

Mixing Use of Custom Components

Migrating Applications from V1 to V2

Rendering Control

Rendering Control Overview

if/else: Conditional Rendering

ForEach: Rendering Repeated Content

LazyForEach: Lazy Data Loading

ContentSlot: Representing a Placeholder in Hybrid Development

Development

Application Framework

Archived

Introduction to Ability Kit

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 in the Same Application

ExtensionAbility Component

EmbeddedUIExtensionAbility

AbilityStage Component Container

Context (Stage Model)

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)

Subscribing to System Environment Variable Changes

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 App-to-App 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 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)

FA Model Development

FA Model Development Overview

FA Model Application Components

Application- or Component-Level Configuration (FA Model)

PageAbility Component Development

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 Component Development

ServiceAbility Overview

ServiceAbility Configuration

ServiceAbility Lifecycle

Creating a ServiceAbility

Starting a ServiceAbility

Connecting to a ServiceAbility

DataAbility Component Development

DataAbility Overview

DataAbility 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 (C/C++)

Accessibility Kit

Introduction to Accessibility Kit

Adapting Your App to Screen Reader

Introduction to ArkData

Unified Data Definition

Unified Data Definition Overview

Uniform Data Structs

Application Data Persistence

Application Data Persistence Overview

Persisting Preferences Data

Persisting KV Store Data

Persisting RDB Store Data

Distributed Application Data Sync

Distributed Application Data Sync Overview

Cross-Device Sync of KV Stores

Cross-Device Sync of RDB Stores

Cross-Device Sync of Distributed Data Objects

Data Reliability and Security

Data Reliability and Security Overview

Database Backup and Restore

Database Encryption

Access Control by Device and Data Level

Using an EL5 Database

Cross-Application Data Sharing

Cross-Application Data Sharing

Many-to-Many Data Sharing

Sharing Data via Unified Data Channels

RelationalStore Development (C/C++)

UDMF Development (C/C++)

Persisting User Preference Data (C/C++)

Introduction to ArkTS

ArkTS Common Library

Overview of the ArkTS Common Library

XML Generation, Parsing, and Conversion

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

ArrayBuffer Object

SharedArrayBuffer Object

Transferable Object (NativeBinding Object)

Sendable Object

Overview of Sendable Objects

Usage Rules and Constraints for Sendable

Asynchronous Lock

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

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

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

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

ArkGuard for Code Obfuscation

Configuring arkOptions in build-profile.json5

Introduction to ArkUI

UI Development (ArkTS-based Declarative Development Paradigm)

UI Development (ArkTS-based Declarative Development Paradigm) Overview

Layout Development

Layout Overview

Building a Layout

Linear Layout (Row/Column)

Stack Layout (Stack)

Flex Layout (Flex)

Relative Layout (RelativeContainer)

Responsive Grid Layout (GridRow/GridCol)

Media Query (@ohos.mediaquery)

Creating a List (List)

Creating a Grid (Grid/GridItem)

Creating a Swiper (Swiper)

Using Tabs (Tabs)

Immersive Effect Development

Adding a Component

Radio Button (Radio)

Progress Indicator (Progress)

Image Display (Image)

Video Playback (Video)

Custom Rendering (XComponent)

Setting Component Navigation and Page Routing

Component Navigation and Page Routing Overview

Component Navigation (Navigation) (Recommended)

Navigation Transition

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

Transition from Router to Navigation

Introduction to Text

Text Display (Text/Span)

Text Input (TextInput/TextArea)

Rich Text (RichEditor)

Symbol Glyph (SymbolGlyph/SymbolSpan)

Styled String (StyledString/MutableStyledString)

Using Dialog Box

Popup Window Overview

Using Dialog Boxes (Dialog)

Dialog Box Overview

Global Custom Dialog Box Independent of UI Components (Recommended)

Custom Dialog Box (CustomDialog)

Fixed Style Dialog Box

Binding a Modal Page

Modal Page Overview

Binding a Semi-Modal Page (bindSheet)

Binding a Full-Modal Page (bindContentCover)

Using Toasts (Toast)

Managing Overlays (OverlayManager)

Drawing Geometric Shapes (Shape)

Drawing Custom Graphics Using the Canvas (Canvas)

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

Screen Rotation Animation Enhancement

Page Transition Animation (Not Recommended)

Particle Animation

Component Animation

Animation Curve

Animation Curve Overview

Traditional Curve

Animation Smoothing

Animation Effects

Frame Animation

Using Interaction Events

Interaction Event Overview

Universal Events

Event Distribution

Touchscreen Event

Keyboard and Mouse Event

Gesture Binding

Combined Gestures

Multi-level Gesture Events

Gesture Judgment

Using Customization Capabilities

Customization Capability Overview

Using Custom Nodes

Custom Node Overview

Custom Placeholder Node

Custom Extension Capability

Custom Extension Capability Overview

AttributeModifier

AttributeUpdater

Using the Mirroring Capability

Supporting Aging-Friendly Design

Dark and Light Mode Adaptation of the Application

Configuring In-Application Theme Skinning

Using the UI Context API for UI Operations (UIContext)

Using NDK APIs to Build UIs

NDK API Overview

Integrating with ArkTS Pages

Using Interaction Events

Listening for Component Events

Binding Gesture Events

Using Animations

Developing a Long List with Lazy Loading

Building a Dialog Box

Building Custom Components

Embedding ArkTS Components

Integrating Accessibility Through XComponent

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

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

Adding a Container

Adding Interactions

Developing Animations

Defining Gesture Events

Defining Page Routes

Common Component Development Guidelines

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

<canvas> Development

CanvasRenderingContext2D

OffscreenCanvasRenderingContext2D

SVG Development

Animation Development Guidelines

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

Window Overview

Application Window Development (Stage Model)

Application Window Development (FA Model)

Using NativeWindowEventFilter to Filter Multimodal Input Events (C/C++)

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)

Introduction to ArkWeb

Lifecycle of the Web Component

Setting Basic Attributes and Events

Setting UserAgent

Managing Cookies and Data Storage

Setting the 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

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

Managing Cyber Security and Privacy for the Web Component

Resolving Cross-Origin Resource Access

Intelligent Tracking Prevention

Enabling Ads Blocking

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 Back-forward Cache

Migrating Web Components Between Different Windows

Managing Web Page File Upload and Download

Uploading Files

Downloading Files

Using Web Multimedia

Holding a Video Conference with WebRTC

Taking Over the Media Playback on Web Pages

Processing Web Page Content

Printing Frontend Pages

Previewing PDF Files

Calculating and Adjusting Safe Area Insets

Using Same-Layer Rendering

Debugging Frontend Pages by Using DevTools

Using Crashpad to Collect Web Component Crash Information

Background Tasks Kit

Introduction to Background Tasks Kit

Transient Task (ArkTS)

Transient Task (C/C++)

Continuous Task (ArkTS)

Deferred Task (ArkTS)

Agent-powered Reminder (ArkTS)

Introduction to Core File Kit

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

Application Data Backup and Restore

Application Data Backup and Restore Overview

Accessing Backup and Restore

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 (ArkTS)

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

Accessing Files Across Devices

Copying Files Across Devices

Introduction to Form Kit

Service Widget Development in Stage Model

Developing an ArkTS Widget

ArkTS Widget Working Principles

ArkTS Widget Related Modules

ArkTS Widget Development

Creating an ArkTS Widget

Configuring Widget Configuration Files

Widget Lifecycle Management

Widget Page Development

Widget Page Capability Overview

Using Animations in the Widget

Applying Custom Drawing in the Widget

Widget Event Development

Widget Event Capability Overview

Launching the UIAbility of the Widget Provider Through the router Event

Launching the UIAbility of the Widget Provider in the Background Through the call Event

Updating Widget Content Through the message Event

Updating Widget Content Through the router or call Event

Widget Data Interaction

Updating Widget Content

Interval-based Widget Updates

Time-specific Widget Updates

Updating Local and Online Images in the Widget

Updating Widget Content by State

Developing a JS Widget

Service Widget Development in FA Model

Introduction to IME Kit

Implementing an Input Method Application

Using the Input Method in a Custom Edit Box

Switching Between Input Methods

Setting Input Method Subtypes

Custom Edit Box Development Guide (C/C++)

Introduction to IPC Kit

IPC and RPC Development

Subscribing to State Changes of a Remote Object

IPC Development (C/C++)

Localization Kit

Introduction to Localization Kit

Application Internationalization

UI Design for Internationalization

Locale and Cultural Habit Division

Language and User Preference Setting

System Language and Region Setting

Preferred Language Setting

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

Time Zone Name Localization

Application Localization

Multilingual Resource Provisioning

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

Adapting App Icons to the HarmonyOS Design Style

(Recommended) Layered Icon Processing

Single-Layer Icon Processing

How Do I Obtain the layeredDrawableDescriptor Object Information?

System

Archived

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

Requesting Restricted Permissions

Application Permissions

Permissions for All Applications

Restricted Permissions

Permissions for MDM Applications

Application Permission Groups

Using System Pickers

Using Security Components

Security Component Overview

Using PasteButton

Using SaveButton

Using LocationButton

Application Encryption

Password Autofill Service

Overview of the Password Autofill Service

Accessing Password Vault

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 Customized Layouts

Adaptable Scenarios

Adding Password Vault for Web Pages

Sharing Account Data Between Applications and Web Pages

Asset Store Kit

Introduction to 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)

Asset Store Kit Development (C/C++)

Adding an Asset (C/C++)

Removing Assets (C/C++)

Update an Asset (C/C++)

Querying Assets (C/C++)

Crypto Architecture Kit

Introduction to 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)

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 a PEM String into an Asymmetric Key Pair (ArkTS)

Converting a PEM String into an Asymmetric Key Pair (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 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 by Segment with an AES Symmetric Key (GCM Mode) (C/C++)

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

Encryption and Decryption with a 3DES Symmetric Key (ECB Mode) (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 an RSA Asymmetric Key Pair (PKCS1)

Encryption and Decryption by Segment with an RSA Asymmetric Key Pair

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

Encryption and Decryption with an SM2 Asymmetric Key Pair

Converting SM2 Ciphertext

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)

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

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)

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

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 SM2 Key Pair (ArkTS)

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

Key Agreement Overview and Algorithm Specifications

Key Agreement Development

Key Agreement Using ECDH

Key Agreement Using X25519

Key Agreement Using DH

MD Overview and Algorithm Specifications

MD Generation Development

MD Operation (ArkTS)

MD Operation (C/C++)

Secure Random Number Generation

Key Derivation Overview and Algorithm Specifications

Key Derivation Using PBKDF2

Key Derivation Using HKDF

Data Protection Kit

Introduction to the DLP Service

DLP Service Development

Device Certificate Kit

Introduction to Device Certificate Kit

Certificate Framework

Certificate Framework Overview

Certificate Development

Certificate Extension Development

CRL Development

Creating a TrustAnchor Object Array from a .p12 File

Certificate Chain Validator Development

Certificate and CRL Collection Development

Certificate Chain Development

Certificate Management

Certificate Management Overview

Certificate Management Development

Certificate Management Dialog Box Development

Device Attestation

Device Attestation Overview

Device Attestation Development

Application Development

Server Development

Device Security Kit

Enabling Device Security Kit

Generating an Access Token Based on a Service Account

System Integrity Check

TrustedAppService

Image Security Verification

Location Security Verification

Signature Verification

Verifying the Anonymous Certificate Chain

Verifying the Signature

BusinessRiskIntelligentDetection

Fraud Detection

Personal Data Processing Information

Enterprise Data Guard Kit

Starting a File Scanning Task for a Common Directory

Setting Tags for a File

Obtaining the Tags of a File

Obtaining the URI of a File

Deleting Files in a Specified Directory

Updating a Security Control Policy

Setting the KIA File List

No Enterprise Data Guard Kit Permission

Online Authentication Kit

Getting Started

FIDO Password-Free Identity Verification

IFAA Password-Free Identity Verification

SOTER Password-Free Identity Verification

Website Link Disclaimer

Universal Keystore Kit

Introduction to Universal Keystore Kit

Basic Concepts of HUKS

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 Ciphertext (ArkTS)

Importing a Key in Ciphertext (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 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

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++)

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

Querying Key Aliases (C/C++)

User Authentication Kit

Introduction to User Authentication Kit

User Authentication Development

Before You Start

Obtaining Supported Authentication Capabilities

Initiating User Authentication

Canceling User Authentication

Applying Custom Authentication

Obtaining Enrolled Credential Information

Using userAuthIcon

Connectivity Kit

Connectivity Kit

Bluetooth Overview

Bluetooth Setting Development

BLE Development

GATT Development

SPP Development

NFC Tag Read/Write Development

HCE Development

SE Access Development

WLAN Service Development Overview

P2P Mode Development Guide

Distributed Service Kit

Introduction to Distributed Service Kit

Distributed Device Management Development

Before You Start

Querying NearLink Status

Sending NearLink Advertising Packets

Initiating NearLink Scanning

SSAP (SparkLink Service Access Protocol) Connection and Data Transmission

Introduction to Network Kit

Data Transmission Capabilities of Network Kit

HTTP Data Request

WebSocket Connection

Socket Connection

MDNS Management

Network Management Capabilities of Network Kit

Network Connection Management

Network Connection Development

Traffic Management

Network Boost Kit

Getting Started

Network Quality

Network Quality Assessment

Network Scenario Identification

App Data Transmission Quality Feedback

Weak Network Signal Awareness and Judgment

Network Handover

Network Handover Notification

Handover Mode Setting

Remote Communication Kit

Getting Started

Basic Capabilities

Sending a Network Request Using fetch

Sending a Network Request Using GET

Sending a Network Request Using POST

Sending a Network Request Using PUT

Sending a Network Request Using HEAD

Sending a Network Request Using DELETE

Canceling a Network Request Using cancel

Closing a Session Using close

Sending a Synchronous Network Request Using fetchsync (C/C++)

Sending an Asynchronous Network Request Using fetch (C/C++)

Sending a Network Request Using GET (C/C++)

Sending a Network Request Using POST (C/C++)

Sending a Network Request Using PUT (C/C++)

Sending a Network Request Using HEAD (C/C++)

Sending a Network Request Using DELETE (C/C++)

Canceling a Network Request Using cancel (C/C++)

Closing a Session Using close (C/C++)

Remote Communication Scenarios

Obtaining Server Resources

Sending Data to the Server

Resumable Transfer

Bidirectional Certificate Verification

Verifying a Certificate Based on Needs

Uploading and Downloading a File

Setting the TLS Protocol Version and Cipher Suite

Obtaining Server Resources (C/C++)

Sending Data to the Server (C/C++)

Resumable Transfer (C/C++)

Bidirectional Certificate Verification (C/C++)

Interceptor (C/C++)

Pinning a Certificate

Verifying a Response

Setting the Read/Write Timeout Interval

Suspending and Resuming Requests

Reading and Writing Streaming Data Synchronously

Service Collaboration Kit

Device Interconnectivity (ArkTS)

Introduction to Device Interconnectivity

Device Interconnectivity Development Guide

Device Interconnectivity NDKs (C)

Overview of Device Interconnectivity NDKs

Device Interconnectivity NDK Development Guide

Device Interconnectivity (RichEditor Control)

FAQs About Service Collaboration Kit

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

Introduction to Telephony Kit

Call Service Development

SMS Service Development

Basic Functions

Basic Services Kit

Introduction to 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

Using Emitter for Inter-Thread Communication

Account Management

Managing Application Accounts

USB Service Development Overview

USB Service 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 Function of the Pasteboard

Upload and Download

Uploading and Downloading Application Files

Function Flow Runtime Kit

Introduction to Function Flow Runtime Kit

Function Flow Runtime Development

Introduction to Input Kit

Input Device Development

Mouse Pointer Development

Event Listening Development (C/C++)

Event Interception Development (C/C++)

Introduction to MDM Kit

MDM Kit Development

EnterpriseAdminExtensionAbility Development

Status Bar Extension Kit

Adding App Icons to Status Bar

Getting Started

Setting the System Navigation Status

Setting System Navigation Data

Registering a Listener for System Navigation Information and Commands

Unregistering a Listener for System Navigation Information and Commands

Registering a Mobility Service Event Listener

Unregistering a Mobility Service Event Listener

Obtaining Mobility Service Event Information

Registering a Smart Mobility Connection Status Listener

Unregistering a Smart Mobility Connection Status Listener

Obtaining the Smart Mobility Connection Status

Driver Development Kit

Introduction to Driver Development Kit

Peripheral Driver Client Development

Peripheral Driver Development

Multimodal Awareness Kit

Introduction to Multimodal Awareness Kit

Stationary Development

Handwriting Function Development

Integrating the Handwriting Suite

Integrating Point Prediction

Integrating Instant Shape

Integrating Color Picker

Does the handwriting suite of Pen Kit support customized brushes?

Does the handwriting suite of Pen Kit support customized pen width levels?

Does the handwriting suite of Pen Kit support customized colors?

Can the toolbar of the handwriting suite of Pen Kit be provided on a separate basis?

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

Introduction to Sensor Service Kit

Sensor Overview

Sensor Development (ArkTS)

Sensor Development (C/C++)

Vibrator Overview

Vibrator Development (ArkTS)

Vibrator Development (C/C++)

Wear Engine Kit

About Wear Engine

About the Service

Getting Started

Applying for Integrating Wear Engine

Configuring the Client ID

Phone App Development

Querying Connected Wearable Devices

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 Wearable Devices

Obtaining Wearable Device Sensor Data

Managing the Connection Status Between Your App and Wear Engine

Watch App Development

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 identifiers when using AppInfo?

The user authorization screen does not display

"App has not applied for the Wear Engine service" error message is reported after API calling

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

0 or 255 is reported by the HR sensor

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

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

More: Submit a ticket online if you cannot find the answer to your question

Personal Data Processing Information

Debugging Tools

Performance Analysis Kit

Introduction to Performance Analysis Kit

Using HiLog (ArkTS)

Using HiLog (C/C++)

HiAppEvent Usage

Introduction to HiAppEvent

Event Subscription

Application Events

Subscribing to Application Events (ArkTS)

Subscribing to Application Events (C/C++)

Crash Event Overview

Subscribing to Crash Events (ArkTS)

Subscribing to Crash Events (C/C++)

Freeze Event Overview

Subscribing to Freeze Events (ArkTS)

Subscribing to Freeze 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++)

Using hiTraceMeter (ArkTS/JS)

Using HiTraceMeter (C/C++)

Viewing HiTraceMeter Logs

Using HiTraceChain (ArkTS/JS)

Using hiTraceChain (C/C++)

Using HiChecker (ArkTS)

Using HiDebug (ArkTS)

Using HiDebug (C/C++)

Using HiCollie (C/C++)

Error Management

Development of Error Manager

Development of Application Recovery

Analyzing JS Crash

Analyzing Cpp Crash

Analyzing App Freeze

Command Line Tools

arkXtest User Guide

SmartPerf User Guide

wukong User Guide

Debugging Commands

Ability Assistant

Packing and Unpacking Tools

Common Event Manager

Advanced Notification Manager

Access Token Manager

Command Line Utilities

Media

Archived

Introduction to Audio Kit

Selecting an Appropriate Audio Stream Type

Introduction to Audio Focus and Audio Session

Audio Focus Management

Using AudioSession to Manage Audio Focus (ArkTS)

Using AudioSession to Manage Audio Focus (C/C++)

Audio Playback Development

Using AudioRenderer for Audio Playback

Responding to Audio Output Device Changes

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

Using AudioHaptic for Audio-Haptic Playback

Volume Management

Audio Effect Management

Audio Playback Stream Management

Managing Global Audio Output Devices

Audio Recording

Audio Recording Development

Using AudioCapturer for Audio Recording

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

Microphone Management

Audio Recording Stream Management

Managing Global Audio Input Devices

Audio Call Overview

Developing Audio Call

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++)

Introduction to AVCodec Kit

AVCodec Supported Formats

Audio and Video Codecs

Obtaining Supported Codecs

Temporally Scalable Video Coding

Audio Vivid Capabilities

Introduction to Audio Vivid Capabilities

Audio Vivid Demuxing

Audio Vivid Decoding

Audio Vivid Playback

HDR Vivid Capabilities

HDR Vivid Video Playback

HDR Vivid Video Recording

Converting HDR Vivid to SDR Videos

Media Data Muxing and Demuxing

Media Data Multiplexing

Media Data Demultiplexing

Introduction to AVSession Kit

Local AVSession

Local AVSession Overview

AVSession Provider

AVSession Provider (C/C++)

Accessing AVSession

Distributed AVSession

Using the Call Device Switching Component

Using AVCastPicker

Introduction to Playback Control

AVCastPicker Development

Extended Screen Projection Development

Introduction to Camera Kit

Camera Development Preparations

Camera Development (ArkTS)

Camera Device Management (ArkTS)

Device Input Management (ArkTS)

Camera Session Management (ArkTS)

Preview (ArkTS)

Photo Capture (ArkTS)

Video Recording (ArkTS)

Camera Metadata (ArkTS)

Using the Flashlight (ArkTS)

Adapting to Camera Changes in Different Folding States (ArkTS)

Deferred Photo Delivery (ArkTS)

Moving Photos (ArkTS)

Basic Camera Animation (ArkTS)

Camera Best Practices (ArkTS)

Using the Camera Picker (ArkTS)

Photo Capture Sample (ArkTS)

Video Recording Sample (ArkTS)

Dual-Channel Preview (ArkTS)

Deferred Photo Delivery Sample (ArkTS)

Camera Development (C/C++)

Camera Device Management (C/C++)

Device Input Management (C/C++)

Camera Session Management (C/C++)

Preview (C/C++)

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

Photo Capture (C/C++)

Deferred Photo Delivery (C/C++)

Video Recording (C/C++)

Camera Metadata (C/C++)

Using the Flashlight (C++)

Camera Best Practices (C/C++)

Photo Capture Sample (C/C++)

Video Recording Sample (C/C++)

Introduction to DRM Kit

DRM Development (ArkTS)

DRM Media Key System Management (ArkTS)

DRM Media Key Session Management (ArkTS)

DRM Development (C/C++)

DRM Media Key System Management (C/C++)

DRM Media Key Session Management (C/C++)

Introduction to Image Kit

Image Development (ArkTS)

Using ImageSource to Decode Images

Using ImageSource to Decode Pictures

Using PixelMap to Transform Images

Using PixelMap for PixelMap Operations

Using ImagePacker to Encode Images

Using ImagePacker to Encode Pictures

Editing EXIF Data

Image Development (C/C++)

Introduction to the Image_NativeModule Structs

Using Image_NativeModule to Decode Images

Using Image_NativeModule to Decode Pictures

Using Image_NativeModule to Receive Images

Using Image_NativeModule for PixelMap Operations

Using Image_NativeModule to Process Image Information

Using Image_NativeModule to Encode Images

Using Image_NativeModule to Encode Pictures

Using ImageEffect to Edit Images

Image Development (Dependent on JS Objects) (C/C++)

Using Image to Decode Images

Using Image to Receive Images

Using Image to Transform Images

Using Image to Process PixelMap Data

Using Image to Encode Images

Introduction to Media Kit

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 Save 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)

Media Development (C/C++)

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

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

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

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

Media Library Kit

Introduction to 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

Accessing and Managing Moving Photos

Playing Moving Photos with MovingPhotoView

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++)

Setting a Ringtone

Getting Started

Scan-to-Access Capability

Barcode Scanning 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 App Package Inconsistent with Declared Device Types During Package Upload

Multi-Barcode Scanning Failed During Gallery-based Barcode Scanning

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 (customScan.rescan)?

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?

Personal Data Processing Information

Graphics

Archived

About AR Engine

Getting Started

Managing AR Sessions

Obtaining the Device Pose

Detecting Planes in the Environment

Recognizing Plane Semantics

Recognizing the Target Shape

Placing AR Objects

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 Post 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)

Introduction to ArkGraphics 2D

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

Overview of Primitive Drawing

Drawing Geometric Shapes (ArkTS)

Drawing Images (ArkTS)

Drawing TextBlobs (ArkTS)

Drawing Geometric Shapes (C/C++)

Drawing Images (C/C++)

Drawing TextBlobs (C/C++)

Using the Text Module for Text Display

Native Buffer Development (C/C++)

Native Image Development (C/C++)

Native VSync Development (C/C++)

Native Window Development (C/C++)

Graphics Development Terms

Introduction to ArkGraphics 3D

Building and Managing ArkGraphics 3D Scenes

Creating and Using ArkGraphics 3D Resources

Controlling and Managing ArkGraphics 3D Scene Animations

Graphics Accelerate Kit

Developing the Frame Generation Capability

Interpolation Mode

Extrapolation Mode

Developing the ABR Capability

Developing the OpenGTX Capability

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

What types of devices does Graphics Accelerate 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?

Getting Started

GPU Spatial Upscaling

AI Temporal Upscaling

AI Spatial Upscaling

Subpass Shading

FAQs About XEngine Kit

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

Do I Have to Create the Output Color Attachment by calling OH_NativeBuffer When Using the AI Spatial Upscaling Feature?

Application Services

Archived

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

Getting Started

Configuring the Client ID

Configuring Scopes

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)

Signing In with the HUAWEI ID Sign-In Button

Signing In with a Custom Button

Silently Signing In

Subscribing to HUAWEI ID Sign-in/Sign-out Events

Access to User Information of a HUAWEI ID

Obtaining the Avatar and Nickname

Obtaining the Mobile Number

Quick Verification

Obtaining the Shipping Address

Obtaining the Invoice Title

(Recommended) Following the Youth Mode Status on the Device

Enabling or Disabling the Youth Mode in an App

Subscribing to and Processing User Information Changes

What are the length limits 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?

Is there a limit on the number and frequency of calls to the API for obtaining an app-level access token?

What can I do if the mobile number fails to be obtained or the obtained mobile number is empty?

When and how can I use the ID token?

What can I do if USB debugging is unavailable after the youth mode is enabled?

How to exchange user data between HarmonyOS APK apps and HarmonyOS NEXT apps in the one-tap sign-in scenario?

Is the UnionID or OpenID of a HUAWEI ID user or the mobile number as their unique identifier during one-tap sign-in with HUAWEI ID?

Personal Data Processing Information

Petal Ads Publisher Service

Interstitial Ads

FAQs About Petal Ads Publisher Service

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

Why Is Only One Ad Displayed When an Ad Array Is Passed During Native Ad Display?

Restrictions on Petal Publisher Console

Identifier Service

Personal Data Processing Information

Introduction to Calendar Kit

Calendar Management

Event Management

Contacts Kit Development

Introduction to Location Kit

Applying for Location Permissions

Obtaining Device Location Information

Geocoding and Reverse Geocoding

Notification Kit

Introduction to 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 WantAgent Object to a Notification

Subscribing to or Unsubscribing from voipCallUiEvent

Notifying the System of Incoming Calls

Notifying the System of Outgoing Calls

Reporting Call Mute and Speaker Events

Notifying the System of Call Status Changes

Notifying the System of Call Status Changes and Specifying the Call Type

Notifying the System of Call Connection Failures

Why Is the Notification Banner Not Displayed?

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

Cloud Foundation Kit

Getting Started

Enabling Cloud Functions

Enabling Cloud DB

Enabling Cloud Storage

Cloud Functions

Developing a Function

Creating and Configuring 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 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

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?

Personal Data Processing Information

Game Service Kit

(Mandatory) Basic Game Function Development

Integration Process

Integration Procedure

Importing Modules

Performing Initialization

Registering an Event Listener

Multi-provider Sign-In

Associating with Official Game Account

Addiction Prevention for Minors

Submitting Role Information

Switching Account

(Optional) Game Scene Perception Function Development

Integration Process

Integration Procedure

Personal Data Processing Information

Releasing a Game

Pre-release Check

Release Application

FAQs About Game Service Kit

How Can Game Data Be Synchronized Between HarmonyOS/EMUI and HarmonyOS NEXT? Does It Require Adaptation on the Game Side?

Must the API for Saving Role Information Be Called?

Can Other Service APIs Be Called Only After the Game Is Successfully Initialized?

Must a Package Name End with .huawei?

Are Identity Verification and Game Addiction Prevention Implemented by Huawei or Game?

How to Obtain Information About a Player's HUAWEI ID, Including the Avatar and Nickname?

What Does Game Need to Do to Transfer Game Progress Data from HarmonyOS/EMUI to HarmonyOS NEXT?

Can Game Data Under the Same Game Account Be Synchronized Between Mobile Phones Running HarmonyOS/EMUI and Those Running HarmonyOS NEXT?

To Improve Player Experience, Can Players Be Prompted to Go to HUAWEI GameCenter to Perform Transfer or Rollback?

Can Games Be Notified of Data Association After Role Transfer/Rollback?

openId Is Used to Sign in to HarmonyOS Games. When the Progress of HarmonyOS Games Is Transferred to HarmonyOS NEXT Games, the Player ID Saved in the HarmonyOS NEXT Games is gamePlayerId. How to Associate the Two?

If the Game Does Not Have a Historical Channel Package or Involve Transfer, or the Transfer Function Is Not Configured, Can the Transfer Process Be Skipped?

If the Player Chooses Association-based Sign-In, Is the Transfer Function of HUAWEI GameCenter Available?

In an Association Scene, How Do You Obtain Required Information to Associate a HUAWEI ID with an Official Account When a Player Does Not Authorize You to Obtain Their Mobile Number?

Is the Mobile Number that a Player Authorizes You to Obtain the Mobile Number Associated with the HUAWEI ID or a Security Phone Number?

When a Player Switches to Another Game Account or Performs Other Operations, How Do Your Game Forcibly Display the Multi-provider Sign-in Panel?

Can the Multi-provider Sign-in Panel Be Customized by Games?

What Can a Player Do If They Choose a Wrong Method for Signing in to a Game?

If a Player's HUAWEI ID Does Not Have Any Record of Signing in to HarmonyOS/EMUI Games, Can They only Choose the Association-based Sign-in Method?

Is It Allowed for Games Not to Provide the Function of Disassociating from Game Account?

Is It Necessary to Submit Role Information?

How Do You Disable Sign-In With Official Game Account for a Game?

What Is the Player Experience of Signing in to a Game After Transfer Rollback?

Health Service Kit

Integration Process

Qualifications Requirements for Developers

Getting Started

Applying for Health Service Kit

Configuring the Client ID

Developing the App

Launching Huawei Health for Users to Agree to Privacy Statement

Managing User Authorization

Managing Data Sources

Managing Health and Fitness Data

Health and Fitness Sampling Data

Workout Records

Real-time Activity Rings Data

Scope Description

Daily Activities

Body Temperature

Workout Record Data

Apnea Testing in Diving

Apnea Training in Diving

Elliptical Machine

Mountain Climbing

Health Record Data

Applying for Formal Scopes

Personal Data Processing Information

FAQs About Health Service Kit

The daily activity statistics returned are inconsistent with those in the Huawei Health app

No scope for a data type after obtaining the authorization

Error 1001502003 is reported during authorization

Error 1001502014 is reported during authorization

How to guide users to open the Huawei Health app if they have not agreed to the user privacy statement

Specifications for Using Logos

Requirements and Restrictions on IAP Integration

Getting Started

Enabling Merchant Service

Enabling and Activating IAP Kit

(Optional) Setting Necessary Parameters

Configuring App Identity Information

Configuring Products

Product Purchase

Consumable or Non-consumable Purchase

Implementing the Purchase Process

Delivering an Order

Auto-renewable Subscription Purchase

About Subscriptions

Implementing the Subscription Process

Delivering a Service

Sandbox Testing

Benefit Analysis and Reports

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, have they 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?

Certificates Supported by the Huawei IAP Server

Cipher Suites Supported by the Huawei IAP Server

How do I fix the error of an incomplete certificate chain?

Live View Design Specifications

App Development

Creating a Local Live View

Updating a Live View Through Push Kit

Frequency Control on Live View Update

Third-Party Development Framework Access

Live View Lifecycle

Live View Template Use

Restrictions on the Number of Live Views

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 Overlay Order of Map Elements

Travel Route Planning

Batch Route Computation

Trajectory-based Road Snapping

Place Details Display

Location Selection

Administrative Division Selection

Navigation and Other Capabilities Provided by Petal Maps

Map Calculation Tools

Coordinate Conversion

Distance Calculation

Map Not Displayed

Icon Parsing Exception

How to Obtain siteId?

Gestures Freeze or Do Not Work

Personal Data Processing Information

Map Review Number

Map Data Copyright Statement

Supported Languages

Supported Countries/Regions

Implemented by pdfService

Opening a PDF Document

Converting the File Format

Adding a Header or Footer

Adding a Watermark

Adding a Background

Adding an Annotation

Adding a Bookmark

Implemented by PdfView

Opening a PDF Document

Saving a PDF Document

Setting the PDF Document Preview Mode

Converting a PDF Document to an Image

Highlighting a PDF Document

Searching for a Specific Keyword in a PDF Document

Previewing a PDF Document Using the PdfView Component

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

Failed to open a file preview via the openPreview API

Failed to open a file preview when the URI obtained by DocumentViewPicker is opened via 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 an Authorized Subscription Message

Pushing a Widget Update Message

Pushing an Extended Notification Message

Sending an Extended Notification Message

Recalling an Extended Notification 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

Obtaining the AAID

Message Successfully Pushed from the Cloud Side but Failed to Be Displayed at the Device Side

Incorrect Classification or Categorization

Push Message Upper Limit Reached

Message Frequency Control Problems

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

Incoming Call Answering and Banner Error of an In-App Call Message

Personal Data Processing Information

Notification Content Management Rules

Push Notification Violation Penalty Criteria

Scenario Fusion Kit

Scenario-Specific Buttons

Mobile Number Quick Verification Button

Avatar Selection Button

Authorization Setting Page Launch Button

App Launch Button

Shipping Address Selection Button

Invoice Title Selection Button

Map Location Selection Button

Scenario-specific APIs

Introduction to SmartFill

Typical Scenarios

Changing the Value of ContentType Dynamically

Auto-filling Address Information in a Form

Data Sources and Logic of Suggestions

ContentType Scenarios

Integrating SmartFill to Third-Party Frameworks/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

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

Failure to Launch a Third-Party App

Clipboard Paste Box Blocked SmartFill Selection Box

Personal Data Processing Information

Content Sharing Initiation by a Host App

Integration Modes for Host Apps

Initiating Content Sharing Through System Share in a Mobile App

Initiating Content Sharing Through System Share in a 2-in-1 Device App

Initiating Content Sharing Through Huawei Share in a Mobile App

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

Configuring the Operation Area in the Host App

Obtaining the Precise UTD Type

Common Sharing Scenarios

Shared Content Processing by a Target App

Processing the Shared Content Inside a Target App

Processing the Shared Content on the Level-2 Panel

Closing the Sharing Panel from the Level-2 Panel

Sharing Contact Information to the Recommendation Area

Target App Design Specifications

Failed to Start the System Sharing Panel

Unsupported Shared Data Type

No Permission to Obtain URI Data

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

On-Demand Feature Distribution

Ecosystem Query Service

Update on AppGallery

App Attribution Service

Development Overview

Registering an Enterprise Account

Registering an Attribution Role

Managing Conversion Events

Standard Conversion Events

Custom Conversion Events

Registering Attribution Sources and Conversion Events

Posting Back the Attribution Result

Performing Debugging

Privacy Agreement Management Service

FAQs About Store Kit

Can I Set Multiple Addresses for Receiving 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 the Price of an In-App Product in a Country/Region Is Changed in AppGallery Connect, Will the Price Fluctuate 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 Payment UI? Any Other Payment UIs Available?

How Long Is the Validity Period of purchaseToken?

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?

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

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 Calculated by the 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?

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 Function 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?

Applying for Wallet Kit

Digital Car Key

Preparations on the HUAWEI Wallet Server

Enabling a Car Key

Transportation Card

Preparations on Your Server

Activating a Transportation Card

Topping Up a Transportation Card

Updating a Transportation Card

Deleting a Transportation Card

In which countries/regions can Wallet Kit be used?

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

AI

Archived

Core Speech Kit

Speech Recognition

Core Vision Kit

Face Verification

Subject Segmentation

HiAI Foundation Kit

Introduction to HiAI Foundation Kit

Getting Started

Model Optimization

Model Size Reduction

Non-training Quantization

Plugin-based Quantization

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

Zero Memory Copy

In-depth Fusion

App Integration

Creating a Project

Configuring NAPI for Your Project

Model Integration

Single-Operator Application

HiAI Foundation Kit FAQs

How to Obtain the Version

Supported Operators

Visualization Tool

Intents Kit Integration Process

Habit-based Recommendation Solution

Integration Solution

Testing Solution

Event-based Notification Solution

Integration Solution

Testing Solution

Skill Call Solution

Integration Solution

Local Search Solution

Integration Solution

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

MindSpore Lite Kit

Introduction to 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++)

Natural Language Kit

Word Segmentation

Entity Extraction

Neural Network Runtime Kit

Introduction to Neural Network Runtime Kit

Connecting NNRt to an AI Inference Framework

Face Liveness Detection

Card Recognition

Document Scanning

AI Image Recognition

Hopping

Archived

Hopping Overview

Application Continuation

Application Continuation Overview

Application Continuation Development

Cross-Device Drag and Drop

Cross-Device Drag and Drop Overview

Cross-Device Drag and Drop Development

Cross-Device Clipboard

Cross-Device Clipboard Overview

Cross-Device Clipboard Development

NDK Development

Archived

Getting Started with the NDK

Creating an NDK Project

Building an NDK Project

NDK Project Building Overview

Building an NDK Project with the DevEco Studio Template

Building an NDK Project with CMake

Building an NDK Project with Prebuilt Libraries

BiSheng Compiler

Code Development

Development Overview

C/C++ Standard Library

C/C++ Mechanisms

Node-API Overview

Node-API Data Types and APIs

Node-API Development Specifications

Node-API Development Process

Node-API Usage Guide

Using Node-API Extension APIs

Working with Array Using Node-API

Working with ArrayBuffer Using Node-API

Working with BigInt Using Node-API

Working with Buffer Using Node-API

Working with Basic Data Types Using Node-API

Working with Classes 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 Tide 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

Working with Property Using Node-API

Working with String Using Node-API

Customizing Asynchronous Operations Using Node-API

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

JSVM-API Overview

JSVM-API Data Types and APIs

JSVM-API Development Process

JSVM-API Development Specifications

JSVM-API Development Specifications

JSVM-API Usage Guide

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

Working with BigInt Using JSVM-API

Working with Class Using JSVM-API

Working with Date 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

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

Creating Basic Data Types Using JSVM-API

JSVM-API Use Cases

JSVM-API Debugging

JSVM-API Tuning and Performant Coding Cases

Creating and Destroying JSVMs Using JSVM-API

Accelerating Compilation Using a Code Cache

JSVM Tuning Practices

Resource Management

Raw File Development

Thread Scheduling

QoS Development

Memory Management

Purgeable Memory Development

Device Management

USB DDK Development

HID DDK Development

Bundle Management

Native Bundle Development

Debugging and Profiling

Debugging and Profiling Overview

Debugging in DevEco Studio

C/C++ Memory Error Detection

Hardware Compatibility

Introduction to Hardware Compatibility

Using Neon Instructions

Tools

DevEco Studio

Archived

Getting Started

Downloading Software

Installing DevEco Studio

Creating and Running a Hello World Project

Setting Up the Proxy

Setting Up the Development Environment Without Internet Access

Project Management

Project Overview

Project Directory Structure

Introduction to Project Templates

Creating a Project

Creating a Lite Project

Converting or Migrating a Project

Integrated Project Migration

Adapting to ohpm

Managing Modules

Adding or Deleting a Module

Adding an Ability to a Module

Creating a Service Widget

Creating an Insight Intent

Code Generation/Completion

Real-time Code Check and Quick Fix

Code Linter Check

Code Refactoring

ArkTSDoc Generation

Cross-language Code Editing

Previewing the UI

PreviewChecker Inspection Rules

Previewing an ArkTS/JS App/Atomic Service

Previewing an ArkUI Page or Component

Profile Manager

Previewing Your App/Atomic Service on Multiple Devices

Inspector Bidirectional Preview

Mocking Preview Data

List of Previewer-Capable APIs

Developing Your App/Atomic Service

Developing and Referencing Shared Packages

Developing a Static Shared Package

Developing a Dynamic Shared Package

Publishing a Shared Package

Referencing a Shared Package

Converting a Shared Package from the .tgz Format to the .har Format

Generating an App Icon

Building Your App/Service

Build System Lifecycle

Configuration Files

hvigor-config.json5

build-profile.json5

Configuring Your Build

Managing Modules

Adding Dependencies

Configuring Multi-Target and Multi-Product

Configuring for C++ Builds

Implementing Multi-Project Builds

Logic for Checking HAP Uniqueness

Customizing the .hvigor Directory Path

Customizing Your Build

Customizing Build Options

Obtaining Customized Build Parameters

Dynamically Modifying the Signature and Build Configuration

Optimizing Your Build

Analyzing Build Performance

Optimizing the Build Performance

Optimizing the Hvigor Build Performance

Using the Hvigor Daemon Process

Conducting an Incremental Build

Using Modular Compilation

Enabling the AOT Compilation Mode

Quick Link to a Pre-built Library

Extending Your Build

Developing a Hvigor Task

Plug-in Development

Using APIs for Extending Your Build

Basic Build Capability

Plug-in Context

API Usage Examples

Hardening Your Build

Code Obfuscation

Troubleshooting

Compilation and Building FAQs

Signing Your App/Atomic Service

Running Your App/Atomic Service

Running Your App/Atomic Service on a Local Real Device

Debugging Your App/Atomic Service

Debugging Overview

Running/Debugging Configuration

ArkTS Code Debugging

Starting and Debugging an App/Service

Debugging an App/Atomic Service in Running

Debugging an App at Startup

Using Breakpoints

Checking Variables

Using the Debugger

Reverse Debugging

Extension Debugging

Worker/TaskPool Debugging

Evaluate and Log

Smart Step Into

Native Code Debugging

Starting Debugging

Using Breakpoints

Checking Variables

Debugging Assembly Code

Viewing Memory Information

Using LLDB Debugging Commands

Reverse Debugging

Viewing Stack Information

Viewing .so Information

Setting Execution Points

Using Smart Step Into

Cross-Language Debugging

Debugging Third-Party Code

Incremental Debugging

Multi-Process Debugging

Developer Options

Stack Trace Analysis

Exception Stack Trace Analysis

ArkCompiler Runtime Detection

Layout Analysis

Device File Access

Capturing Screenshots

Screen Recording

Performance Profiling

Overview of Performance Profiling

Introduction to DevEco Profiler

Overall UI Layout and Concepts

Using DevEco Profiler

Performance Profiling Procedure

Real-Time Monitoring for Problem Demarcating

In-depth Capture for Problem Locating

Basic Time Analysis: Time

Memory Analysis: Allocation

Memory Analysis and Optimization

Filtering Analysis Data

Analyzing the Startup Memory

Memory Leak Analysis: Snapshot

Basic Operations with Memory Snapshot Analysis

ArkTS Memory Leak Analysis

CPU Activity Analysis: CPU

Janky Frames Analysis

Cold Start Analysis: Launch

Parallelism and Concurrency Analysis: Concurrency

Loading and Frame Loss Analysis: ArkWeb

Network Diagnosis: Network

Testing Your App/Atomic Service

Instrument Test

Black-box Test with Coverage

Releasing Your App/Atomic Service

Code Linter Check Rules

@typescript-eslint: General Rules

@typescript-eslint/adjacent-overload-signatures

@typescript-eslint/await-thenable

@typescript-eslint/array-type

@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-dh-key

@security/no-unsafe-dsa

@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/specified-interface-call-chain-check

@performance: Performance Rules

@performance/high-frequency-log-check

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

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

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

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

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

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

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

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

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

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

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

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

@performance/hp-arkui-reduce-pan-gesture-distance

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

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

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

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

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

@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-object-link-to-replace-prop

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

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

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

@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/hp-performance-no-closures

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

@performance/lazyforeach-args-check (Deprecated)

@performance/lottie-animation-destroy-check

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

@performance/number-init-check

@performance/object-creation-check (Deprecated)

@performance/sparse-array-check

@performance/start-window-icon-check

@performance/timezone-interface-check

@performance/typed-array-check

@performance/waterflow-data-preload-check

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

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

@performance/foreach-args-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-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/size-unit

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

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

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

@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

Maintenance Services

App/Atomic Service Health Check Rules

In-App Touch Response Speed

In-App Touch Operation Completion Speed

In-App Swipe Operation Response Speed

In-App Swiping Smoothness

In-App Transition Smoothness

Dynamic Peak Memory Usage

Foreground Peak Memory Usage

Background Peak CPU Usage

Graphics Rendering Service Node Count Limit

DevEco Studio Parameters

Disabling Data Collecting

Command Line Tools

Archived

Obtaining Command Line Tools

System Platform Requirements

oh-package.json5

Common Commands

ohpm prepublish

ohpm cache clean

Setting Up a Pipeline

DevEco Service

Archived

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

Deployment Guide

Single-Node Deployment

Multi-Instance Deployment

Personal Center Home Page

User Management

Repository Management

Authentication Management

Organization Management

System Settings

ohpm-repo Private Repository History (1.0.1 and 1.1.0)

Getting Started

Configuration File

Related Commands

ohpm-repo start

ohpm-repo restart

ohpm-repo --version

ohpm-repo encrypt_password

ohpm-repo restore

ohpm-repo deploy

ohpm-repo check_storage

ohpm-repo mirror_storage

Deployment Guide

Single-Node Deployment

Multi-Instance Deployment

Version Upgrade

Version Upgrade from 1.0.1 to 1.1.0

Version Upgrade from 1.0.1 to 2.X.X or 5.X.X

Version Upgrade from 1.1.0 to 2.X.X or 5.X.X

Version Upgrade from 2.X.X to 5.X.X

Storage Plug-in Customization

Storage Plug-in Configuration

Authentication Plug-in Customization

Authentication Plug-in Configuration

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

ohpm Repository Interface Protocol

The documentation of HarmonyOS 5.0.1 (API 13) you're currently viewing is archived and no longer updated. You are advised to switch to the latest version.

Code Test

Last updated: 2025-02-06 09:47

DevEco Studio supports the app/atomic service test framework, with basic APIs for writing test cases and the capability to execute test cases, output test results, and provide the code coverage. It helps you develop simple and easy-to-use automatic test scripts.

Instrument test: The test cases are stored in the ohosTest directory and must be run on a device. The ArkTS and JS programming languages are supported.
Local test: The test cases are stored in the test directory and do not need to be run on a device. Local tests apply to ArkTS projects developed based on the stage model only. They do not apply to C/C++ methods and system APIs.

Instrument Test
Local Test

Instrument Test