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