Start

Getting Started

Development

Getting Prepared

Application Development Preparations

Application Framework

Ability Kit

About This 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 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

Context (Stage Model)

Want

Want Overview

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)

AppStartup

Application Preloading

Application Restart

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

Obtaining the URL of the Target Application

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

Agent Development Guidelines Based on AgentExtensionAbility

Using AgentExtensionAbility for Agent Services

AgentExtensionAbility Configuration File Description

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

About This 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

ArkData

About This Kit

Unified Data Definition

Unified Data Definition Overview

UTDs (ArkTS)

UTDs (C/C++)

Uniform Data Structs (ArkTS)

Uniform Data Structs (C/C++)

Content Cards Based on Uniform Data Structs (ArkTS)

Prebuilt UTDs

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)

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 Database Debugging Tool

Preferences Database Debugging Tool Guide

vector-store Database Debugging Tool Guide

SQLite Debugging Tool

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

Overview of Concurrency

Asynchronous Concurrency (Promise and Async/Await)

Multithreaded Concurrency

Overview of Multithreaded Concurrency

TaskPool

Worker

Comparison Between TaskPool and Worker

Inter-Thread Communication

Overview of ArkTS Inter-Thread Communication

Inter-Thread Communication Objects

Overview of Inter-Thread Communication Objects

Regular Object

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

Shared Module

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

ArkTS Runtime

Overview of ArkTS Runtime

ArkTS Modularization

Overview of Modular Operation

Dynamic Import

Lazy Import

Dynamically Loading Native Modules in Synchronous Mode

Statically Loading Native Modules

Loading Modules Using Node-API

Side Effects and Optimization of Module Loading

ArkTS Runtime FAQs

ArkTS Compilation Toolchain

Overview of the ArkTS Compilation Toolchain

Ark Bytecode

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

Disassembler

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

ArkUI

About This Kit

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

@Reusable V2 Decorator: Reusing V2 Components

Custom Component Freezing

Freezing a Custom Component (V1)

Freezing a Custom Component (V2)

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 Terms

State Management Principles

Differences Between State Management V1 and V2 Update Mechanisms

MVVM (V1)

MVVM (V2)

State Management V1

Component State Management

@State Decorator: State Owned by Component

@Prop: Implementing One-Way Synchronization from Parent 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

@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 Class Property Changes

@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

Auxiliary APIs

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 Sugar

$$ 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

Migration for AnimateTo Usage

Mixed Use of State Management V1 and V2

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

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

Setting Component Navigation and Page Routing

Component Navigation and Page Routing Overview

Component Navigation (Navigation) (Recommended)

Navigation Architecture

Subpage

Page Routing

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)

Using Tabs (Tabs)

Immersive Effect Development

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)

Creating a Waterfall Flow (WaterFlow)

Using Text

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

Media Display

Image Display (Image)

Video Playback (Video)

Creating a Swiper (Swiper)

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

Buttons and Selections

Button and Selection Component Overview

Button

Arc Button (ArcButton) (Recommended for Circular Screens)

Radio Button (Radio)

Toggle

Adding a Component

Custom Rendering (XComponent)

Progress Indicator (Progress)

Using Popup Windows

Popup Window Overview

Dialog Boxes (Dialog)

Dialog Box Overview

Global Custom Dialog Box Independent of UI Components (openCustomDialog)

Basic Custom Dialog Box (CustomDialog)

Fixed-Style Dialog Box

Page-Level Dialog Box

Dialog Box Layer Management

Dialog Controller

Dialog Box Focus Policy

Global Menu Independent of UI Components (openMenu)

Using Popups

Popup Overview

Popup

Global Popup Independent of UI Components (openPopup)

Binding Modal Pages

Modal Page Overview

Binding a Modal Sheet (bindSheet)

Binding a Full-Modal Page (bindContentCover)

Using Toasts (Toast)

Managing Overlays (OverlayManager)

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

Implementing Gesture Responses

Gesture Binding

Single Gesture

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

Frame Animation (ohos.animator)

Using Customization Capabilities

Customization Capability Overview

Custom Composition

Custom Nodes

Custom Node Overview

Custom Placeholder Nodes

Custom Component Node (FrameNode)

Custom Render Node (RenderNode)

Custom Declarative Node (BuilderNode)

Setting Custom Node Cross-Language Attributes

Custom Drawing

Drawing Custom Graphics Using the Canvas (Canvas)

Custom Drawing Modifier (DrawModifier)

Modifier

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

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

Integrating with ArkTS Pages

Adding Event Responses

Adding an Event Listener

Binding Basic Input Events

Binding Gesture Events

Binding Drag Events

Using Animations

Building a Layout

Using Layout Components

Setting the Common Layout Attributes

List and Grid

Implementing a List Layout

Implementing a Waterfall Flow Layout

Using Grids

Using Text

Using the Text Component

Drawing and Displaying Text in Text Components

Adding a Text Event Listener for a Text Box

Building a Dialog Box

Building Form Components

Media Display

Using the Swiper Component

Using Navigation Components

Building Custom Components

Embedding ArkTS Components

Building a Rendering Node

Integrating Accessibility Through Custom Drawing

Custom Drawing

Querying and Operating Custom Nodes

Launching EmbeddedUIExtensionAbility with EmbeddedComponent

Ensuring Multi-Instance Functionality in the NDK

Parallelizing UI Page Building Using Multi-threaded NDK APIs

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

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

Resource Limitations and Access

Multi-Language Capability

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

Basic Component Development

image-animator Development

CanvasRenderingContext2D

Path2D

OffscreenCanvasRenderingContext2D

Animation Development

CSS Animation

Attribute Style Animation

Animation with the transform Attribute

Animation with the background-position Attribute

Animation for SVG Components

JavaScript Animation

Component Animation

Interpolator Animation

Using WebGL to Draw Graphics

UI Debugging and Optimization

UI Stability Issue Debugging

UI Stability Issue Analysis Overview

Common UI Application Freezing Issues

Debugging UI Display Exceptions

UI Context Debugging

UI Preview

UI Profiling

High-Performance UI Development

UI Development FAQs

FAQs About Navigation Animation

FAQs About Custom Nodes

FAQs About Buttons and Selection Components

FAQs About Popup Component

FAQs About Text Components

FAQs About Dynamic Attribute Setting

FAQs About Imperative Nodes

FAQs About UI Parallelization

Window Manager

Window Overview

Application Window Development (Stage Model)

Application Window Development (FA Model)

Window Rotation

Window Metadata Configuration

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

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

PiP FAQs

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

Configuring and Using the Application Starting Window

Introduction to the Application Starting Window

Configuring the Application Starting Window

Configuring Starting Window Resources

Window Development Terminology

Window Development FAQs

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 Management Development Terminology

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

Managing Focus

Interacting with Applications Using Gestures

Zooming Web Pages

Displaying Web Page Dialog Boxes

Using Drag and Drop in Web Component to Interact with Web Pages

Simulated Click Detection for Web Applications

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

Using Same-Layer Rendering

Using Offline Web Components

Using WebNativeMessagingExtensionAbility to Implement Communication Between Browser Extensions and Applications

Web Debugging

Debugging Frontend Pages by Using DevTools

Using Crashpad to Collect Web Component Crash Information

Troubleshooting White Screen Issues on Web Pages

Using Hypium to Implement ArkWeb Automated Testing

ArkWeb Glossary

Background Tasks Kit

About This 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

About This Kit

Client-Server Interaction Process

Server Application Development

Client Application Development

Content Embed Kit FAQs

Content Embed Kit Terminology

Core File Kit

About This 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

Configuring the Application Shared Directory

Application Data Backup and Restore

Application Data Backup and Restore Overview

Accessing Backup and Restore

User Files

User File Overview

User File URI

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

Sharing and Accessing Files Across Devices

Copying Files Across Devices

Data Augmentation Kit

Configuring a Prompt Template

Configuring Hyperparameters

Configuring a Thought Template

Complete Sample Code

Intelligent Data Retrieval-ArkTS

Intelligent Data Retrieval-C++

On-Device Q&A Model

Form Kit

About This Kit

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

Dark and Light Mode Adaptation for ArkTS Widget UI

Using Custom Fonts in ArkTS Widgets

ArkTS Widget Update

Overview of ArkTS Widget Update

Active Update of ArkTS Widgets

Passive Update of 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

ArkTS Widget Editing

Overview of ArkTS Widget Editing

Widget Editing Development

Widget Addition to Home Screen

Adding Widgets to the Home Screen

Interactive Widget Development

Overview of Interactive Widgets

Developing a Fun-based Widget

Scene-based Widget

Overview of Scene-based Widgets

Developing a Scene-based Widget

ArkTS Widget Adaptation FAQs

JS Widget Development

JS Widget Overview

Developing a JS Widget (Stage Model)

Developing a JS Widget (FA Model)

IME Kit

About This Kit

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

Managing the Input Method Using hdc Commands

Input Box and Input Method Interaction in Non-Focusable Windows

IME Kit Glossary

IPC Kit

About This Kit

IPC and RPC Development (ArkTS)

IPC and RPC Development (C/C++)

Subscribing to State Changes of a Remote Object

Localization Kit

About This 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

DST Transition

Multilingual Sorting

Overview of Multilingual Sorting

Sorting by Local Habits

Language and Locale 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

UI Design Kit

About This Kit

Adapting App Icons to the HarmonyOS Design Style

(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

Sidebar Style

Configuring the Sidebar in Overlay Mode

Configuring the Sidebar in Embed Mode

Sidebar Menu Style

Bottom Tab Bar

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

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

List Style

Configuring the List Style with Horizontal Swipe Animation

Configuring the List Card Style

Loading a Custom Symbol for an App

Registering Resources

Visual Effects

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

FAQs

How Do I Obtain the layeredDrawableDescriptor Object Information?

System

Security

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

Open system_grant Permissions

Open user_grant Permissions

Restricted Permissions

Permissions for Enterprise Applications

Permissions for MDM Applications

Application Permission Groups

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

Autosave of Accounts and Passwords

Updates of Accounts and Passwords

Autofill

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

About This Kit

Scenarios

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)

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

Updating an Asset (C/C++)

Querying Assets (C/C++)

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

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

Crypto Architecture Kit

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

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

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

Converting SM2 Signature Formats (ArkTS)

Converting SM2 Signature Formats (C/C++)

Key Agreement

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

MD Overview and Algorithm Specifications

MD Development

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

MAC Overview and Algorithm Specifications

Generating an HMAC (ArkTS)

Generating an HMAC (C/C++)

Generating a CMAC (ArkTS)

Generating a CMAC (C/C++)

Random Numbers

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

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 17630001

Data Protection Kit

DLP Service

About This Kit

DLP Service Development (ArkTS)

DLP Service Development (C/C++)

Adapting to Encrypted Share

Device Certificate Kit

About This 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

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

Certificate Management

Certificate Management Overview

Application Certificate Development

CA Certificate Development

Certificate Management Dialog Box Development

Device Security Kit

About This Kit

Service Quota

Development Preparations

Enabling Device Security Kit

Generating a JWT Based on a Service Account

DeviceVerify

Safety Detection

Enhanced System Integrity Check

System Integrity Check

URL Check

Local System Integrity Check

TrustedAppService

Image Security Verification

Location Security Verification

Secure Image Compression and Cropping

Signature Verification

Verifying the Anonymous Certificate Chain

Verifying the Signature

Digital Shield Service

Overview

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

Security Audit

Single-Client Subscription

Multi-Client Subscription

Subscribing to Notification Events

Subscribing to Authentication Events

Process Information Query

Code Signature Information Query

Multi-Client Subscription (C/C++)

Subscribing to Notification Events

Subscribing to Authentication Events

Process Information Query (C/C++)

Code Signature Information Query (C/C++)

Service Risk Detection

Fraud Detection

Simulated Click Detection

Enhanced Simulated Click Detection

Device Security Mode Query (C/C++)

Anti-Fraud Picker

Obtaining Fraudulent Messages

Obtaining Fraudulent Call Logs

Obtaining Fraudulent Apps

Screen Privacy

VirusProtectionServiceManager (C/C++)

Super privacy mode

Querying the Super Privacy Status

Subscribing to Status Change Events

Personal Data Processing Information

Appendix

Supported Countries/Regions

Enterprise Data Guard Kit

About This Kit

Development Preparations

Hierarchical File Management

Starting a File Scanning Task

Opening a File

Setting Tags for a File

Obtaining the Tags of a File

Obtaining the URI of a File

Deleting a File at a Specified Path

Updating a Security Control Policy

Setting the KIA File List

Subscribing to and Unsubscribing from KIA File Copy, Rename, and Compress Events

Setting a Watermark Image for KIA Files

Adding, Deleting, and Obtaining an App Trustlist

Setting HDC Authentication Keys

Subscribing to or Unsubscribing from Printing Service Startup Events

Enterprise Recovery Key

Obtaining the Enterprise Recovery Key for Decrypting Hard Drive Data

Obtaining the Enterprise Recovery Key for Resetting the Lock Screen Password

Obtaining a Challenge

Signing a Challenge

Updating the Enterprise Public Key Certificate

Deleting an Enterprise Recovery Key

FAQs

Failure to Obtain the Enterprise Data Guard Kit Permission

Enterprise Threat Protection Kit

About This Kit

Preparations

File access and handling

App Directory Scanning

File Opening

File Isolation

Isolated File Restoration

Deletion of Isolated Files

Isolation Query

FAQs

Online Authentication Kit

About This Kit

Preparations

FIDO Passwordless Identity Authentication

IFAA Passwordless Identity Authentication

SOTER Passwordless Identity Authentication

Passkeys

Overview

Authentication Using Passkeys (ArkTS)

Authentication Using Passkeys (C/C++)

Website Link Disclaimer

Universal Keystore Kit

About This Kit

Local Key Management

Basic Concepts of Local Key Management

Key Generation and Import

Key Generation

Key Generation Overview and Algorithm Specifications

Generating a Key (ArkTS)

Generating a Key (C/C++)

Key Import

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

Key Import Using Digital Envelope (ArkTS)

Key Import Using Digital Envelope (C/C++)

Key Use

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

Key Agreement Overview and Algorithm Specifications

Key Agreement (ArkTS)

Key Agreement (C/C++)

Key Derivation

Key Derivation Overview and Algorithm Specifications

Key Derivation (ArkTS)

Key Derivation (C/C++)

Access Control

HUKS Access Control Overview

HUKS Access Control Development

Refined Key Access Control Development

HMAC

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

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

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

Opening and Closing Resources (C/C++)

Ukey PIN Authentication Management

Ukey PIN Authentication Overview and Specifications

Authentication Status Query (ArkTS)

Authentication Status Query (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++)

General Operations

General Query Overview and Specifications

General Query (ArkTS)

General Query (C/C++)

Driver HAP ExtensionAbility Adaptation Guide

CryptoExtensionAbility Extension Capability Overview

CryptoExtensionAbility Adaptation Development Guide

Personal Data Processing Information

User Authentication Kit

About This Kit

User Authentication Development

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

SPP-based Connection and Data Transmission

Bluetooth Low Energy

BLE Scanning and Advertising

GATT-based Connection and Data Transmission

Bluetooth FAQs

2900099 Bluetooth API Call Error

NFC

NFC Service Development Overview

NFC Tag Read/Write Development

HCE Development

SE Access Development

WLAN

WLAN Service Development Overview

P2P Connection Development

STA Development

Wi-Fi Scan Development

Converged Short-Range

Converged Short-Range Service Development Overview

Interconnection Between Partner Devices and HarmonyOS Devices

Connectivity Kit Terminology

Distributed Service Kit

About This 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

SSAP Server

SSAP Client

Transferring Data Using NearLink

Obtaining NearLink Cooperative Device Set Information

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

VPN Management

Network Management

Collecting Network Statistics

Using the Network Firewall

Extensible Authentication

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)

Overview

Setting the Service Scenario

Listening to the Multi-Network Concurrency Status

Listening to the Multi-Network Concurrency Suggestions

Querying Multi-Network Concurrency Quota Information

Initiating and Releasing Multi-Network Concurrency

Network Quality-related Capabilities (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 Capabilities (C/C++)

Network Handover Notification (C/C++)

Handover Mode Setting (C/C++)

Remote Communication Kit

About This Kit

Preparations

Network Communication Using HTTP

Initiating an HTTP Request and Obtaining a Response

Sending a Network Request (ArkTS)

Canceling Network Requests (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 Resumable Transfer

Implementing Streaming Requests

Streaming

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 Functions

Cache Sharing Between Sessions

Customizing a Cache Interceptor

Boosting HTTP Transmission Performance Through Pre-connection

URPC Scenarios

Calling a Remote Program Using URPC

Service Collaboration Kit

About This Kit

Device Interconnectivity (ArkTS)

About This Kit

Device Interconnectivity Development Guide

Device Interconnectivity NDK (C)

Overview of the Device Interconnectivity NDK Feature

Device Interconnectivity NDK Development Guide

Device Interconnectivity (RichEditor Control)

Service Collaboration Kit FAQs

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

Telephony Kit

About This Kit

Call Service Development

SMS Service Development

Network Debugging and Optimization

Getting Started with Network Navigator

Basic Functions

Basic Services Kit

About This 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

USB Service

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

FAQs

USB Service Glossary

Update Service

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

FAST Kit

About This Kit

Using SegmentMap to Query and Maintain Range Information

Using RectPartition to Solve the Rectangular Partition Problem

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

Using DSP for Vector Computation

Using DSP for Second-Order IIR Filtering

Function Flow Runtime Kit

About This 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 Kit

About This Kit

Input Device Development

Preferential Response of System Function Keys

Mouse Pointer Development

Event Listening Development (C/C++)

Event Interception Development (C/C++)

EnterpriseAdminExtensionAbility Development Guide

Purgeable Memory Management Development

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

About This 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

FAQs

Terms

Multimodal Awareness Kit

About This Kit

Stationary Development

Motion Awareness Development

Device Status Awareness Development

User Status Awareness Development

Metadata Binding Development

Pen Kit

About This Kit

Handwriting Function Development

Integrating the Handwriting Suite

Integrating Point Prediction

Integrating Instant Shape

Integrating the Global Color Picker

Integrating Stylus Interaction

Handwriting Function Development (C/C++)

Integrating the Global Color Picker

Integrating Point Prediction

FAQs

Does the handwriting suite of Pen Kit support custom 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 Development (ArkTS)

Sensor Development (C/C++)

Vibrator

Vibrator Overview

Vibrator Development (ArkTS)

Vibrator Development (C/C++)

Mechanic Kit

About This Kit

Object Tracking Photography Development

Phone App Development

Getting Started

Applying for Wear Engine Kit Integration

Configuring the Client ID

Developing Your App

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

Wearable 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

Error message "App has not applied for the Wear Engine service" 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 a 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

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

General Logs

Page Switch Logs

Power Detection

Performance Detection

Introduction to HiAppEvent

Using HiAppEvent to Subscribe to Events

Event Subscription Overview

Event Subscription (ArkTS)

Event Subscription (C/C++)

System Events

Crash Events

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

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 Events

Subscribing to Time-Consuming Launch Events (ArkTS)

Scrolling Frame Loss Events

Subscribing to Scrolling Frame Loss Events (ArkTS)

High CPU Load Events

Subscribing to High CPU Load Events (ArkTS)

Battery Usage Statistics Events

Subscribing to Battery Usage Statistics Events (ArkTS)

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

Check Mode

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

Performance Analysis Kit Terminology

Test Kit

Automated Test Framework User Guides

SmartPerf Device User Guide

Packing and Unpacking Tools

Advanced Notification Manager

Enterprise Device Manager

PrivacyManagerService

Command Line Utilities

Getting to Know Network Navigator

Binary Sign Tool

Media

Media Development at a Glance

Using HDR Vivid in Media Applications

Audio Kit

About This Kit

Selecting the Appropriate Audio Stream Types

Audio Focus and Audio Session Management

Introduction to Audio Focus and Audio Sessions

Using AudioSession to Manage Audio Focus (ArkTS)

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

Audio Playback

Audio Playback Development

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

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

Using AudioCapturer for Audio Recording (ArkTs)

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

Managing Microphone Mute Status

Querying and Listening for the Recording Status of Other Applications

Recording Concurrency Strategy Description

Audio Monitoring

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

Audio Call Overview

Developing Audio Call

Audio Performance Optimization

Enhancing Audio Performance Experience

Audio Workgroup Management

Audio Creation

Audio Creation Overview (C/C++)

Offline Editing (C/C++)

Real-Time Rendering (C/C++)

MIDI

OH_MIDI Overview (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++)

AVCodec Kit

About This Kit

AVCodec Supported Formats

Audio and Video Codecs

Obtaining Supported Codecs

Audio Encoding

Synchronous Audio Encoding

Audio Decoding

Synchronous Audio Decoding

Video Encoding

Synchronous Video Encoding

Temporally Scalable Video Coding

B-Frame Video Encoding

Video Encoding Configurations for Typical Scenarios

ROI Video Encoding

Video Decoding

Synchronous Video Decoding

Video Variable Frame Rate

Audio Vivid Ability

Introduction to Audio Vivid Capabilities

Audio Vivid Demultiplexing

Audio Vivid Decoding

Audio Vivid Playback

HDR Vivid Ability

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

AVCodec Kit FAQs

Concurrently Creating a Video Decoder and Initializing NativeWindow

Video Codec Width, Height, Stride, and Crop Information

AVSession Kit

About This Kit

Local AVSession

Local AVSession Overview

AVSession Provider

AVSession Provider (C/C++)

Accessing AVSession

Background Playback

Application Access to Lyrics Component

Distributed AVSession

Using the Call Device Switching Component

Using AVCastPicker

Introduction to Playback Control

AVCastPicker Development

Extended Screen Casting Development

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)

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

Focus (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

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

Focus (C/C++)

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

Using Camera Preconfiguration (C/C++)

DRM Kit

About This Kit

DRM Development (ArkTS)

DRM Development (C/C++)

DRM Playback with AVPlayer (ArkTS)

DRM Playback with AVCodec (C/C++)

Image Kit

About This Kit

Image Development (ArkTS)

Image Decoding

Using ImageSource to Decode Images

Using ImageSource to Decode Pictures

Allocating Memory for Image Decoding (ArkTS)

Image Region Decoding and Downsampling (ArkTS)

Using ImageSource to Obtain RAW Data

Image Encoding

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

Editing Exif Data

Image Receiving

Using ImageReceiver to Receive Images

Image Development (C/C++)

Image Decoding

Using Image_NativeModule to Decode Images

Using Image_NativeModule to Decode Pictures

Allocating Memory for Image Decoding (C/C++)

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

Image Encoding

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

Scaling 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 Edit 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 in Image Kit

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

Media Development (ArkTS)

Playback

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)

Recording

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

Playback

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

Recording

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 for Window-Level Screen Recording (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 Scaling

Video Dynamic Metadata Generation

Video Color Space Conversion

Media Library Kit

About This 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

Moving Photos

Accessing and Managing Moving Photos

Playing Moving Photos with MovingPhotoView

Device upgrade inherits the media file access permission.

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

Media Library Kit FAQs

How to Properly Manage Media Assets

How to Correctly Identify Media Asset Types

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

FAQs

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

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?

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 Engine

About This Kit

Preparations

AR Session Management

Introduction

Managing AR Sessions

Managing AR Sessions (C/C++)

Motion Tracking

Introduction

Obtaining the Device Pose (ArkTS)

Obtaining the Device Pose (C/C++)

Plane Detection

Introduction

Detecting Planes in the Environment (ArkTS)

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

Hit Testing

Introduction

Placing Objects (ArkTS)

Placing AR Objects (C/C++)

Plane Semantics

Introduction

Recognizing Plane Semantics (ArkTS)

Recognizing Plane Semantics (C/C++)

Object Semantics

Introduction

Recognizing the Target Shape

Environment Mesh Recognition

Introduction

Obtaining Mesh Scanning Information (ArkTS)

Obtaining Mesh Scanning Information (C/C++)

Depth Estimation

Introduction

Obtaining Depth Estimation Information (ArkTS)

Obtaining Depth Image

High-Precision Geometric Reconstruction

Introduction

High-Precision Geometric Reconstruction (ArkTS)

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

Human Body Skeleton Point Recognition and Tracking

Introduction

Human Body Tracking and Skeleton Keypoint Recognition (ArkTS)

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

Facial Recognition and Tracking

Introduction

Face Tracking (ArkTS)

Face Tracking (C/C++)

Image Tracking

Introduction

Image Tracking (ArkTS)

Image Tracking

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

Appendix

ArkGraphics 2D

About This Kit

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

Text

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

NativeBuffer Development (C/C++)

Graphics Buffer

NativeImage Development (C/C++)

NativeWindow Development (C/C++)

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

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

Graphics Development Terms

ArkGraphics 3D

About This Kit

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

Graphics Accelerate Kit

About This Kit

Game Rendering Acceleration Service

Overview

Developing the Frame Generation Capability

AI-based Frame Generation Mode

Overview

Vulkan

Developing the ABR Capability

Developing the OpenGTX Capability

Game Resource Acceleration Service

Resource Package Background Download

Overview

Development Preparations

Developing the Function of Resource Package Download in the System Background

Extension-Initiated System-Managed Download

Extension-Initiated Coordinated Download

Developing the Function of Resource Package Download in the App Foreground

Resource Package Download Switching from the System Background to the App Foreground

Releasing a Resource Package Download Task

Viewing Resource Package Distribution Data

Game Launch Acceleration Service

Second-Level Game Launch

Overview

Development Preparations

Implementing Game Launch Acceleration

FAQs

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 Resource Acceleration Service

What Types of Resource Package 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 Resource 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 Resource Acceleration ExtensionAbility?

Why Do the Static Variables Used in Resource 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 Resource Package Background Download Functions?

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

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

How Do I Integrate the Resource Package 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?

Adding a Filter Effect

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

Managing Spatial Recon Kit Sessions

XEngine Kit

About This Kit

Preparations

GPU Spatial Upscaling

AI Temporal Upscaling

AI Spatial Upscaling

Adaptive VRS

Subpass Shading

Ray-Traced Reflections

Ray-Traced Shadow and Ambient Occlusion

Ray-Traced Global Illumination

Maleoon API

High-Performance GPU Sorting

FAQs

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 AI Spatial Upscaling?

Application Services

Account Kit

About This Kit

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

Sign-In

Overview

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

Overview

Obtaining the Avatar and Nickname

Obtaining the Mobile Number

Overview

Quick Verification

Obtaining the Shipping Address

Obtaining the Invoice Title

Obtaining the Risk Level

Overview

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

Youth Mode

Overview

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

Disabling the Device's Youth Mode

Adjusting Youth Mode Settings

Subscribing to and Processing User Information Changes

FAQs

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

How Can User Data Be Shared Across Apps from Different Developers?

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

Appendix

Supported Countries/Regions

Petal Ads Publisher Service

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?

OAID Service

Personal Data Processing Information

AppGallery Kit

About This Kit

Digital Product Service

Overview

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

App Shortcuts

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

Preparations

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

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?

Appendixes

Standard Events and App Attribution Signatures

Supported Countries/Regions

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

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

FAQs

Why Is the Notification Banner Not Displayed?

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

Enabling Cloud Functions

Enabling Cloud DB

Enabling Cloud Storage

Cloud Functions

Developing a Cloud Function

Developing 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

Cloud Storage

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

Appendix

Supported Countries/Regions

Contacts Kit

About This Kit

Using the Picker for Contact Management

Enterprise Space Kit

About This Kit

Development Preparations

Inter-Space Data Transfer

Setting Review Information

Obtaining Review Information

Configuring a Unidirectional or Bidirectional Inter-workspace Data Transfer Policy

Workspace Management

Creating a Workspace

Enabling the Workspace Function

Querying Workspaces

Removing a Workspace

Setting Workspace Information

Setting the Workspace Profile Photo

Subscribing to a Workspace Event

Unsubscribing from a Workspace Event

Restricting System Service Processes from Accessing Background User Data

Checking Whether System Service Processes Are Restricted from Accessing Background User Data

Obtaining the List of System Service Processes Restricted from Accessing Background User Data

Adding a Restricted User Data Path List for a System Service Process

Deleting a Restricted User Data Path List for a System Service Process

Setting a Workspace Policy

Querying Workspace Policies

Setting the Deep Freeze Exemption List

Querying the Deep Freeze Exemption List

Authenticating an Enterprise Account

Obtaining an Enterprise App Access Token

Setting the Status Bar Icon of a Workspace

Setting the Local Name of a Workspace

FAQs

What Should I Do If Compilation Fails?

File Manager Service Kit

About This Kit

Moving a File to the Recycle Bin

Obtaining a File Icon

Parsing a File Shortcut

Game Controller Kit

About This Kit

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

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

Game Service Kit

About This Kit

(Mandatory) Basic Game Service

(Mandatory) Sign-in with a HUAWEI ID

Sign-in with an Official Game Account

Standalone Game Sign-in

(Mandatory) Mini Game Sign-In

Payment in Mini Games

Basic Game Service Terminology

(Optional) Game Scene Perception

Overview

Preparations

Development Procedure (ArkTS)

Development Procedure (C/C++)

(Optional) Nearby Transfer

Overview

Preparations

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 to Hide the Official Account Sign-in Option in My Game?

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

Appendix

Configuring a Callback Address

Obtaining the Game Key

Health Service Kit

About This Kit

Integration Process

Qualifications Requirements for Developers

Development

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 Privacy Statement

Managing User Authorization

Managing Data Sources

Managing Health and Fitness Data

Health and Fitness Sample Data

Workout Records

Health 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

Data Types

Overview

Permission Description

Heart Rate Variability

Apnea Testing in Diving

Apnea Training in Diving

Applying for Formal Permissions

Personal Data Processing Information

FAQs About Health Service Kit

Appendixes

Getting Help

Specifications for Using Logos

IAP Kit

About This Kit

Requirements and Restrictions on IAP Integration

(Optional) Using the IAP Kit Integration Skill

Getting Started

Preparations

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 an Order

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

Appendix

Global Coverage of IAP Kit

Live View Kit

About This Kit

Live View Design Specifications

Preparations

Basic Preparations

Enabling Push Kit

Setting the Data Processing Location

Enabling Live View Kit

Access Debugging

Applying for the Formal Permission on Live View Kit

App Development

Precautions

Creating a Local Live View

Updating a Live View Through Push Kit

FAQs

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

Location Kit

About This Kit

Preparations

Applying for Location Permissions (ArkTS)

Guide of Obtaining Device Location Information

Obtaining Device Location Information (ArkTS)

Obtaining Device Location Information (C/C++)

Geocoding and Reverse Geocoding

Changing the Map Type

Showing My Location

Displaying a Custom Map

Setting the Layering Order of Map Elements

Travel Route Planning

Batch Route Computation

Trajectory-based Road Snapping

Static Map

Map Picker

Place Details Display

Location Selection

Administrative Division Selection

Navigation and Other Capabilities Provided by the Map App

Map Calculation Tools

Coordinate Rectification

Distance Calculation

FAQs

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

Appendixes

Map Data Copyright Statement

Supported Languages

Supported Countries/Regions

Notification Kit

About This 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

ExtensionAbility for Notification Subscription

Introduction to NotificationSubscriberExtensionAbility

Developing the ExtensionAbility for Notification Subscription

Payment Kit

About This Kit

Access Specifications

Skill Integration Description

Checkout Screen Design Specifications

Preparations

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

FAQs

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?

PDF Kit

About This Kit

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

Annotations

Converting a PDF Page to an Image

Optimizing the PDF Document Switching Experience

FAQs

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

Can I preview PDF documents online?

Preview Kit

About This Kit

File Preview

File Open Boost (C/C++)

File Open Boost Status Awareness

File Cache Boost (C/C++)

FAQs

Failed to Open a File Preview via the openPreview API

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

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 Widget Update Message

Pushing Text-to-Speech Messages

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

Overview

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

FAQs

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 Status 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 Do My App Client Receive and Display Messages When It Is 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

Appendixes

Notification Content Management Rules

Push Notification Violation Penalty Criteria

Supported Countries/Regions

Reader Kit

About This Kit

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

About This Kit

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

SmartFill

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

Appendix

Supported Countries/Regions

Screen Time Guard Kit

About This Kit

Preparations

Configuring Signing Information

Requesting a Restricted ACL Permission

User Authorization Management

Overview

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

Overview

Starting the App Selection Page

Launching the Permitted App Redirect Page

Guard Strategy Management

App Access Restriction

Overview

Setting App Access Restrictions

Removing App Access Restrictions

Share Kit

About This Kit

Share Kit Terms

Share Kit Experience Specifications

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

One-Step Access to Received Data on the Target Device

System Share

Overview

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 Between Phones

Overview

Sharing Content

Inviting a User to Join a Team

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

Overview

Sharing Content to a Specified In-app Page

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

Grab & Drop

Overview

Enabling Grab & Drop on a Device

Transfer Between Trusted Devices

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

FAQs

Failed to Start the System Sharing Panel

Unsupported Shared Data Type

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

Wallet Kit

About This Kit

Applying for Wallet Kit

Digital Car Key

Overview

Preparations on the HUAWEI Wallet Server

Preparations on Your Server

Activating a Transportation Card

Topping Up a Transportation Card

Updating a Transportation Card

Deleting a Transportation Card

FAQs

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

About This Kit

Preparations

Obtaining Weather Data

Weather Service Kit FAQs

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

Agent Framework Kit

About This Kit

Starting an Agent Through a Function Component

CANN Kit

About This Kit

Development Preparations

Non-Training Quantization

Plugin-based Quantization

Transformer Quantization

One-Stop Quantization for LLMs

Plugin-based Quantization

LoRA Fine-Tuning on a Quantized Base Model

NAS Training

Model Size Reduction Example

FAQs

Model Benefits

Model Conversion

Offline Model Conversion

Preparing for Model Conversion

Model Conversion Example

AIPP Configuration File Used for Model Conversion

Maintenance, Testing, and Optimization

Configuring NAPI for Your Project

Model Integration

Single-Operator Application

Ascend C Operator Development

Custom Operator Development

Introduction to Ascend C

Environment Setup

Quick Start

Basic Concepts

Hardware Architecture

Hardware Architecture Abstraction

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

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

ONNX Framework

Appendix

Tensor Basics

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

ScalarGetCountOfValue

ScalarCountLeadingZero

ScalarCast

CountBitsCntSameAsSignBit

ScalarGetSFFValue

Vector Computation

Monocular Instructions

Binocular Instructions

Scalar Binocular Instructions

Scalar Ternary Instructions

Axpy

More Examples

Precision Conversion Instructions

Data Distribution and Collection

Data Movement

DataCopy

Common Data Movement

Real-Time Format Conversion

DataCopyPad

Memory Management and Synchronization Control

Nuclear Synchronization

PipeBarrier(ISASI)

TPosition

System Variable Access

GET_TILING_DATA_WITH_STRUCT

TILING_KEY_IS

High-Level APIs

Matrix Multiplication

Matmul

Instruction

Matmul Template Parameters

TCubeTiling Structure

Prototype Registration and Management

Prototype Registration API (OP_ADD)

Tiling Data Structure Registration

TilingData Structure Definition

TilingData Structure Registration

Platform Information Obtaining Platform Ascend C

GetLibApiWorkSpaceSize

Internal Associated APIs

Operator Debugging APIs

Basic Data Structures and APIs

Basic Data Structures and API List

CompileTimeTensorDesc

GetOutputInstanceInfo

GetInputTdInfo

GetOutputTdInfo

GetAttrs

MutableInputInstanceInfo

MutableOutputInstanceInfo

ContinuousVectorVector

Expand (Outputting a New Shape)

Expand (Changing the Original Shape)

ExtendedKernelContext

GetIrInputInstanceInfo

GetIrOutputInstanceInfo

GetComputeNodeInputNum

GetComputeNodeOutputNum

GetOptionalInputDataType

GetRequiredInputDataType

GetOptionalInputShape

GetRequiredInputTensor

GetRequiredInputShape

GetOutputShape

InferShapeRangeContext

GetInputShapeRange

GetInputTensorRange

GetOptionalInputTensorRange

GetDynamicInputTensorRange

GetOptionalInputShapeRange

GetDynamicInputShapeRange

GetRequiredInputShapeRange

GetRequiredInputTensorRange

GetOutputShapeRange

OpImplRegisterV2

Constructor and Destructor

InferOutDataTypeSameWithFirstInput

GenSimplifiedKey

OpExecuteFunc

TilingInputsDataDependency

HostInputs

OutputShapeDependOnCompute

MutableExpandDimsType

Constructor and Destructor

GetOptionalInputTensor

GetRequiredInputTensor

GetOptionalInputShape

GetRequiredInputShape

TypedContinuousVector

Internal Associated APIs

GE Namespace

Allocator

Constructor and Destructor

Constructor and Destructor

GetString

Relational Operator Overloading

Constructor and Destructor

CreateFrom

GetValue

AutoMappingSubgraphIOIndexFuncRegister

FrameworkRegistry

Constructor and Destructor

GetAutoMappingSubgraphIOIndexFunc

AddAutoMappingSubgraphIOIndexFunc

InferenceContext

Constructor and Destructor

SetInputHandleShapesAndTypes

SetOutputHandleShapesAndTypes

GetInputHandleShapesAndTypes

GetOutputHandleShapesAndTypes

RegisterReliedOnResourceKey

AddChangedResourceKey

GetReliedOnResourceKeys

GetChangedResourceKeys

ClearChangedResourceKeys

InferFormatFuncRegister

InferShapeFuncRegister

InferValueRangeFuncRegister

ListTensorType

MemBlock

Constructor and Destructor

OperatorCreatorRegister

Constructor and Destructor

GetAllAttrNamesAndTypes

GetAllIrAttrNamesAndTypes

GetDynamicSubgraphBuilder

GetSubgraphNamesCount

UpdateDynamicInputDesc

UpdateDynamicOutputDesc

VerifyAllAttr

DynamicInputRegister

DynamicInputRegisterByIndex

DynamicOutputRegister

SubgraphCountRegister

Constructor and Destructor

ParseParamsByOperatorFn

FusionParseParamsFn

FusionParseParamsFn (Overload)

DelInputWithOriginalType

GetParseParamByOperatorFn

GetFusionParseParamFn

GetFusionParseParamByOpFn

GetParseSubgraphPostFn

AutoMappingByOpFnDynamic

AutoMappingSubgraphIndex

InputReorderVector

Promote

ShapeAndType

Constructor and Destructor

Constructor and Destructor

Constructor and Destructor

SetUnknownDimNumShape

Update

TensorType

Tensor

Constructor and Destructor

DataTypeToAscendString

AscendStringToDataType

FormatToAscendString

AscendStringToFormat

DataTypeToSerialString

SerialStringToDataType

ConvertToAscendString

ConvertToListAscendString

GetFormatFromSubAndC0

COMMON_INFER_FUNC_REG

DECLARE_ERRORNO

ELMTWISE_INFER_SHAPEANDTYPE

IMPLEMT_COMMON_INFERFUNC

IMPLEMT_INFERFORMAT_FUNC

IMPLEMT_INFERFUNC

IMPLEMT_VERIFIER

INFER_FORMAT_FUNC_REG

INFER_FUNC_REG

Prototype Definition (REG_OP)

Prototype Definition Derivative APIs

VERIFY_FUNC_REG

Ascend C-to-Kirin Compatibility Porting Guide

Compatibility

Mapping Between Ascend and Kirin AI Processors of the Same Generation

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

Overview

Basic API Porting Guide

L2 Cache

Data Type

Atomic Operation

Synchronization Control

High-Level API Porting Guide

Operator Compilation Porting Guide

LLM Capability Openness

Overview

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

FAQs

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?

Appendixes

How to Obtain the Version

Personal Data Processing Information

Multi-object Detection

Skeleton Detection

Personal Data Processing Information

MindSpore Lite Kit

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

Appendix

MindSpore Lite Kit Operator List

Neural Network Runtime Kit

About This Kit

Connecting NNRt to an AI Inference Framework

Face Liveness Detection

Card Recognition

Document Scanning

AI Image Recognition

Personal Data Processing Information

Hopping

Free Hopping Documentation Path Adjustment

NDK Development

About This Kit

Creating an NDK Project

Building an NDK Project

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

Overview

C/C++ Standard Library

C/C++ Library Mechanisms

Using fdsan

Using Node-API

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

Node-API FAQs

FAQs About Stability

FAQs About Memory Leaks

FAQs About Basic Functionalities

Using JSVM-API

JSVM-API Overview

JSVM-API Data Types and APIs

JSVM-API Development Process

JSVM-API Development Specifications

JSVM-API FAQs

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

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

Setting the private Property Using JSVM-API

Working with Latin1/UTF16 Strings Using JSVM-API

Working with Proxy Using 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

Longque-JS-API

Using Longque JS APIs

OpenMP Support

OpenMP Overview

Building and Running Applications Using OpenMP

Resource Management

Raw File Development

Bundle Management

Native Bundle Development

Debugging and Profiling

Overview

C/C++ Memory Error Detection

LLDB Debugger

Hardware Compatibility

Overview

HarmonyOS ABIs

CPU Features

Using Neon Instructions

Tools

Environment Setup

Overview

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

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

Overview

Getting Started

Setting the Configuration File

ohpm-repo encrypt_password

ohpm-repo pack

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

Functions

Frontend page

Personal Center Home Page

User Management

Repository Management

Package Permission Management

Authentication Management

Organization Management

Operation Log

System Settings

Security Configuration

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

Template File

Authentication Plug-in Customization

Authentication Plugin Configuration

Template File

Data Backup

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

Configuration

Template Files

Deploying the ohpm-repo Service Using a Dockerfile

Adding an Ability

Adding a Page

Generating a Single-Layer Icon

Creating a Service Widget

Creating an Insight Intent

Setting Up the Development Environment Offline

Coding and Debugging

Writing Code

Editor Basics

Code Generation/Completion

Code Check

Real-time Code Check and Quick Fix

Running Code Linter

Code Linter Check Rules

Rule Changes

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

prefer-const

eqeqeq

@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

@compatibility: Compatibility Rules

@compatibility/api-compatibility-check

Clang-Tidy Code Inspection

Quickly Inserting Scenario-based Code Snippets

Cross-language Code Editing

Previewing the UI

Introduction

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

Running Your App on a Local Real Device

Running a Lite Wearable App via the Simulator

Running Your App on the Emulator

Overview

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

Code Debugging

ArkTS Code Debugging

Debugging Scenario Description

Starting and Debugging an App/Atomic Service

Debugging an App/Atomic Service in Running

Debugging an App at Startup

Using Breakpoints

Checking Variables

Using Reverse Debugging

Using Extension Debugging

Using Multi-Process Debugging

Printing Expressions

Using Smart Step Into

Viewing the Asynchronous Function Stack

Native Code Debugging

Starting Debugging

Using Breakpoints

Checking Variables

Debugging Assembly Code

Viewing Memory Information

Using LLDB Debugging Commands

Using Reverse Debugging

Viewing Stack Information

Viewing .so Information

Setting Execution Points

Using Smart Step Into

Using the Debugger

Cross-Language Debugging

Debugging Third-Party Library Source Code

Incremental Debugging

Hot Reload

Viewing ArkUI State Variables

Capturing Screenshots

Screen Recording

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

Log Analysis

Fault Analysis

Fault Log

Viewing Cpp Crash Logs

Viewing AppFreeze Logs

Viewing App Killed Logs

Stack Trace Analysis

Exception Stack Trace Analysis

ASan: Detecting Memory Errors

HWASan: Detecting Memory Errors

TSan: Detecting Thread Errors

UBSan: Detecting Undefined Behaviors

ArkCompiler Runtime Detection

Black-box Test with Coverage

Test Framework Error Codes

Instrument Test Error Codes

Local Test Error Codes

Appendix

Setting Up the Proxy

Terminal Environment Variables

Using Operation Analyzer

DevEco Studio Parameters

Disabling Data Collecting

Uploading Logs

ohpm Version Number Rules

pac.json5 Privacy Manifest File

Building an App

Release Notes

Overview

Build System Lifecycle

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

Introduction

Examples

Building a HAR

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

Introduction

Examples

Obtaining Customized Build Parameters

Introduction

Examples

Dynamically Modifying the Build Configuration

Introduction

Examples

Improving Build Efficiency

Analyzing the Build Process

Using the Daemon Process

Enabling Parallel Build

Conducting an Incremental Build

Enabling Performance Optimization Experimental Features

Conducting Modular Compilation

Expanding Build Capabilities

Developing an Hvigor Task

Developing an Hvigor Plugin

Using APIs for Extending Your Build

Basic Build Capabilities

Plugin Context

API Usage Examples

Task Visualization and Execution

Using Obfuscation for Code Hardening

Troubleshooting Build Errors

Logging

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

UI Layout

Session Area

Data Area

Using DevEco Profiler

Performance Profiling Procedure

Real-Time Monitoring for Problem Demarcating

In-depth Capture for Problem Locating

Janky Frames Analysis

Frame Analysis

ArkUI 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

Overview

Filtering Memory Analysis Data

Analyzing Memory at Launch

Analyzing the Native Memory Leak

UI Component Memory Analysis: ComMemory

Energy Consumption Diagnosis: Energy Analysis

Loading and Frame Loss Analysis: ArkWeb

Network Diagnosis: Network

Parallelism and Concurrency Analysis: Concurrency

GPU Activity Analysis

Basic Time Analysis: Time

CPU Activity Analysis

Appendixes

Shortcut Keys

Error Codes

DevEco Profiler Terms

App Release

Release

Command Line Tools

Obtaining Command Line Tools

System Platform Requirements

ohpm dependency-check

Error Codes

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

Setting Up a Pipeline

Format

Last updated: 2026-07-22 06:43

Content overview

Function Description

Defines the operator parameter data formats.

Function Prototype

Collapse
Word wrap
Dark theme
Copy code
OpParamDef &Format(std::vector<ge::Format> formats);

Parameters

Expand

Parameter	Input/Output	Description
formats	Input	Data format of the operator parameter. For details about ge::Format, see Format.

Return Value

OpParamDef operator definition.

Restrictions

None

Send feedback

Was this page helpful?

Send feedback

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

Community Q&A Intelligent Assistant