目录

Application Development Overview
Preparations
Building the First ArkTS Application in Stage Model
Application Package Overview
Application Package Structure in Stage Model
Application Package Structure in FA Model
HAP
HAR
HSP
Application Installation, Uninstall, and Update
Overview of Application Configuration Files in Stage Model
app.json5 Configuration File
module.json5 Configuration File
Overview of Application Configuration Files in FA Model
Internal Structure of the app Tag
Structure of the deviceConfig Tag
Structure of the module Tag
Integrated HSP
Converting HAR to HSP
Converting HSP to HAR
Creating a Static Shortcut of the Application
Creating an Application Clone
Creating an Application Multi-Instance
Configuring Layered Icons
Resource Categories and Access
Getting Started with ArkTS
Introduction to ArkTS
ArkTS Coding Style Guide
ArkTS Migration Background
TypeScript to ArkTS Cookbook
Adaptation Cases
ArkTS Performant Programming Practices
Basic Syntax Overview
Declarative UI Description
Creating a Custom Component
Page and Custom Component Lifecycle
Custom Component Layout
Constraints on Access Modifiers of Custom Component Member Variables
@Builder Decorator: Custom Builder Function
@LocalBuilder Decorator: Maintaining the Parent-Child Relationship Between Component and State Management
@BuilderParam Decorator: @Builder Function Reference
wrapBuilder: Encapsulating Global @Builder
@Styles Decorator: Definition of Reusable Styles
@Extend Decorator: Extension of Built-in Components
stateStyles: Polymorphic Style
@AnimatableExtend Decorator: Definition of Animatable Attributes
@Require Decorator: Validating Constructor Input Parameters
@Reusable Decorator: Reusing Components
State Management Overview
@State Decorator: State Owned by Component
@Prop Decorator: One-Way Synchronization from the Parent Component to Child Components
@Link Decorator: Two-Way Synchronization Between Parent and Child Components
@Provide and @Consume Decorators: Two-Way Synchronization with Descendant Components
@Observed and @ObjectLink Decorators: Observing Property Changes in Nested Class Objects
Application State Management Overview
LocalStorage: Storing UI State
AppStorage: Storing Application-wide UI State
PersistentStorage: Persisting Application State
Environment: Device Environment Query
Overview of Other State Management Features
@Watch Decorator: Getting Notified of State Variable Changes
$$ Syntax: Creating a Two-Way Synchronization with Built-in Components
@Track Decorator: Class Object Property-level Update
Freezing a Custom Component
MVVM
Best Practices for State Management
Proper Use of State Management
@ObservedV2 and @Trace Decorators: Observing Class Property Changes
@ComponentV2 Decorator: Custom Component
@Local Decorator: Representing the Internal State of Components
@Param Decorator: Inputting External Parameters to Components
@Once: Implementing Initialization Once
@Event Decorator: Component Output
@Provider and @Consumer Decorators: Synchronizing Across Component Levels in a Two-Way Manner
@Monitor Decorator: Listening for Value Changes of the State Variables
@Computed Decorator: Computed Property
@Type Decorator: Marking the Types of the Class Property
AppStorageV2: Storing Application-wide UI State
PersistenceV2: Persisting Application State
!! Syntax: Two-Way Binding
Freezing a Custom Component
Repeat: Reusing Child Components
getTarget API: Obtaining Original Objects
makeObserved API: Changing Unobservable Data to Observable Data
MVVM (V2)
Mixing Use of Custom Components
Migrating Applications from V1 to V2
Rendering Control Overview
if/else: Conditional Rendering
ForEach: Rendering Repeated Content
LazyForEach: Lazy Data Loading
ContentSlot: Representing a Placeholder in Hybrid Development
Glossary
Application Development Overview
Introduction to Ability Kit
Application Models
Stage Model Development Overview
Application- or Component-Level Configuration (Stage Model)
UIAbility Overview
UIAbility Lifecycle
UIAbility Launch Type
UIAbility Usage
Data Synchronization Between UIAbility and UI Page
Starting UIAbility in the Same Application
EmbeddedUIExtensionAbility
AbilityStage Component Container
Context (Stage Model)
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
Subscribing to System Environment Variable Changes
Overview of Application Redirection
Overview of Starting a Specified Application
(Optional) Using canOpenLink to Check Application Accessibility
Using Deep Linking for Application Redirection
Using App Linking for App-to-App Redirection
Switching from Explicit Want Redirection to Linking Redirection
Application Link Description
Overview of Starting an Application of the Specified Type
Using startAbilityByType to Start a Navigation Application
Using startAbilityByType to Start an Email Application
Using mailto to Start an Email Application
Using startAbilityByType to Start a Financial Application
Using startAbilityByType to Start an Image Editing Application
Using startAbility to Start a File Application
Starting a System Application
Process Model (Stage Model)
Thread Model (Stage Model)
Application Configuration File (Stage Model)
FA Model Development Overview
Application- or Component-Level Configuration (FA Model)
PageAbility Overview
PageAbility Configuration
PageAbility Lifecycle
PageAbility Launch Type
Creating a PageAbility
Starting a Local PageAbility
Stopping a PageAbility
Starting a Specified Page
Window Properties
Requesting Permissions
Redirection Rules
ServiceAbility Overview
ServiceAbility Configuration
ServiceAbility Lifecycle
Creating a ServiceAbility
Starting a ServiceAbility
Connecting to a ServiceAbility
DataAbility Overview
DataAbility Configuration
DataAbility Lifecycle
Creating a DataAbility
Starting a DataAbility
Accessing a DataAbility
DataAbility Permission Control
Context (FA Model)
Want (FA Model)
Component Startup Rules (FA Model)
Process Model (FA Model)
Thread Model (FA Model)
Application Configuration File (FA Model)
Native Child Process Development (C/C++)
Introduction to Accessibility Kit
Adapting Your App to Screen Reader
Introduction to ArkData
Unified Data Definition Overview
UTDs
Uniform Data Structs
Prebuilt UTDs
Application Data Persistence Overview
Persisting Preferences Data
Persisting KV Store Data
Persisting RDB Store Data
Distributed Application Data Sync Overview
Cross-Device Sync of KV Stores
Cross-Device Sync of RDB Stores
Cross-Device Sync of Distributed Data Objects
Data Reliability and Security Overview
Database Backup and Restore
Database Encryption
Access Control by Device and Data Level
Using an EL5 Database
Cross-Application Data Sharing
Sharing Data via Unified Data Channels
RelationalStore Development (C/C++)
UDMF Development (C/C++)
Introduction to ArkTS
Overview of the ArkTS Common Library
XML Overview
XML Generation
XML Parsing
XML Conversion
Buffer
Overview of the ArkTS Container Library
Linear Containers
Nonlinear Containers
Overview of Concurrency
Asynchronous Concurrency (Promise and Async/Await)
Overview of Multithreaded Concurrency
TaskPool
Worker
Comparison Between TaskPool and Worker
Overview of ArkTS Inter-Thread Communication
Regular Object
ArrayBuffer Object
SharedArrayBuffer Object
Transferable Object (NativeBinding Object)
Overview of Sendable Objects
Usage Rules and Constraints for Sendable
Asynchronous Lock
ASON Parsing and Generation
Shared Container
Shared Module
Freezing Sendable Objects
Use Scenarios of Sendable
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
Overview of Multithreaded Development
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)
Overview of Concurrency in Continuous Tasks
Continuous Task Development (TaskPool)
Overview of Concurrency in Resident Tasks
Resident Task Development (Worker)
Batch Database Operations
Concurrent Loading of Service Modules
Global Configuration
ArkUI Data Updates
C++ Inter-Thread Data Sharing
ArkUI Waterfall Rendering
ArkTS Cross-Language Interaction
Overview of ArkTS Runtime
GC
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
Overview of the ArkTS Compilation Toolchain
Overview of Ark Bytecode
Ark Bytecode File Format
Ark Bytecode Fundamentals
Naming Conventions for Ark Bytecode Functions
Customizing Ark Bytecode During Compilation
Disassembler
ArkGuard for Code Obfuscation
Configuring arkOptions in build-profile.json5
Introduction to ArkUI
UI Development (ArkTS-based Declarative Development Paradigm) Overview
Layout Overview
Linear Layout (Row/Column)
Stack Layout (Stack)
Flex Layout (Flex)
Relative Layout (RelativeContainer)
Responsive Grid Layout (GridRow/GridCol)
Media Query (@ohos.mediaquery)
Creating a List (List)
Creating a Grid (Grid/GridItem)
Creating a Swiper (Swiper)
Tabs
Immersive Effect Development
Button
Radio Button (Radio)
Toggle
Progress Indicator (Progress)
Image Display (Image)
Video Playback (Video)
Custom Rendering (XComponent)
Component Navigation and Page Routing Overview
Component Navigation (Navigation) (Recommended)
Navigation Transition
Page Routing (@ohos.router) (Not Recommended)
Transition from Router to Navigation
Introduction to Text
Text Display (Text/Span)
Text Input (TextInput/TextArea)
Rich Text (RichEditor)
Symbol Glyph (SymbolGlyph/SymbolSpan)
Styled String (StyledString/MutableStyledString)
Popup Window Overview
Dialog Box Overview
Global Custom Dialog Box Independent of UI Components (Recommended)
Custom Dialog Box (CustomDialog)
Fixed Style Dialog Box
Menu
Popup
Modal Page Overview
Binding a Semi-Modal Page (bindSheet)
Binding a Full-Modal Page (bindContentCover)
Using Toasts (Toast)
Managing Overlays (OverlayManager)
Drawing Geometric Shapes (Shape)
Drawing Custom Graphics Using the Canvas (Canvas)
Animation Overview
Property Animation Overview
Implementing Property Animation
Custom Property Animation
Transition Animation Overview
Enter/Exit Transition
Modal Transition
Shared Element Transition
Screen Rotation Animation Enhancement
Page Transition Animation (Not Recommended)
Particle Animation
Component Animation
Animation Curve Overview
Traditional Curve
Spring Curve
Animation Smoothing
Blur Effect
Shadow Effect
Color Effect
Frame Animation
Interaction Event Overview
Event Distribution
Touchscreen Event
Keyboard and Mouse Event
Focus Event
Drag Event
Gesture Binding
Single Gesture
Combined Gestures
Multi-level Gesture Events
Gesture Judgment
Customization Capability Overview
Custom Node Overview
Custom Placeholder Node
FrameNode
RenderNode
BuilderNode
Custom Extension Capability Overview
AttributeModifier
AttributeUpdater
Using the Mirroring Capability
Supporting Aging-Friendly Design
Dark and Light Mode Adaptation of the Application
Configuring In-Application Theme Skinning
Using the UI Context API for UI Operations (UIContext)
NDK API Overview
Integrating with ArkTS Pages
Listening for Component Events
Binding Gesture Events
Using Animations
Developing a Long List with Lazy Loading
Building a Dialog Box
Building Custom Components
Embedding ArkTS Components
Overview
File Organization
"js" Tag
app.js
HML
CSS
JavaScript
Lifecycle
Resource Limitations and Access
Multi-Language Capability
Component Overview
Layout Description
Adding Title and Paragraph Text
Adding an Image
Adding a Comment
Adding a Container
Adding Interactions
Developing Animations
Defining Gesture Events
Defining Page Routes
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
Development
CanvasRenderingContext2D
Path2D
OffscreenCanvasRenderingContext2D
Grid Layout
Basics
Graph Drawing
Path Drawing
Text Drawing
Defining Attribute Style Animations
Defining Animations with the transform Attribute
Defining Animations with the background-position Attribute
Defining Animations for SVG Components
Component Animation
Animation Effect
Animation Frame
Custom Components
Using WebGL to Draw Graphics
Window Overview
Application Window Development (Stage Model)
Application Window Development (FA Model)
Using NativeWindowEventFilter to Filter Multimodal Input Events (C/C++)
PiP Development Overview
Using XComponent to Develop PiP
Using typeNode to Develop PiP
Introduction to Multi-Window
Declaring the Support for Multi-Window
Adapting the App Layout to Multi-Window
Implementing the Avoid Area for the Window-top Control Bar
Display Management Overview
Using OH_DisplayManager to Obtain Basic Display Information and Listen for Status Changes (C/C++)
Using Display to Obtain Display Properties and Listen for Status Changes (ArkTS)
Introduction to ArkWeb
ArkWeb Process
Lifecycle of the Web Component
Setting UserAgent
Managing Cookies and Data Storage
Setting the Dark Mode
Opening Pages in a New Window
Managing Location Permissions
Using Incognito Mode
Using Motion and Orientation Sensors
Rendering Modes of the Web Component
Fitting In the Page Content Layout
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++)
Implementing Nested Scrolling
Docking to the Soft Keyboard
Managing Focus
Resolving Cross-Origin Resource Access
Intelligent Tracking Prevention
Enabling Ads Blocking
Using Secure Shield Mode
Loading Web Pages
Managing Page Redirection and Browsing History Navigation
Intercepting Network Requests Initiated by the Web component
Customizing Page Request Responses
Accelerating Web Page Access
Setting Back-forward Cache
Migrating Web Components Between Different Windows
Uploading Files
Downloading Files
Holding a Video Conference with WebRTC
Taking Over the Media Playback on Web Pages
Printing Frontend Pages
Previewing PDF Files
Calculating and Adjusting Safe Area Insets
Using Same-Layer Rendering
Using Offline Web Components
Debugging Frontend Pages by Using DevTools
Using Crashpad to Collect Web Component Crash Information
Introduction to Background Tasks Kit
Transient Task
Continuous Task
Deferred Task
Agent-powered Reminder
Introduction to Core File Kit
Application File Overview
Application Sandbox
Accessing Application Files (ArkTS)
Accessing Application Files (C/C++)
Obtaining Application and File System Space Statistics
Sharing an Application File
Application Data Backup and Restore Overview
Accessing Backup and Restore
User File Overview
User File URI
FileUri Development (C/C++)
Obtaining the User Directory Environment (C/C++)
Selecting User Files
Saving User Files
Persisting Temporary Permissions (ArkTS)
Persisting Temporary Permissions (C/C++)
Obtaining and Accessing a User Directory
Distributed File System Overview
Setting the Security Level of a Distributed File
Accessing Files Across Devices
Copying Files Across Devices
Introduction to Form Kit
ArkTS Widget Working Principles
ArkTS Widget Related Modules
Creating an ArkTS Widget
Configuring Widget Configuration Files
Widget Lifecycle Management
Widget Page Capability Overview
Using Animations in the Widget
Applying Custom Drawing in the Widget
Widget Event Capability Overview
Launching the UIAbility of the Widget Provider Through the router Event
Launching the UIAbility of the Widget Provider in the Background Through the call Event
Updating Widget Content Through the message Event
Updating Widget Content Through the router or call Event
Updating Widget Content
Interval-based Widget Updates
Time-specific Widget Updates
Updating Local and Online Images in the Widget
Updating Widget Content by State
Developing a JS Widget
Service Widget Development in FA Model
Introduction to IME Kit
Implementing an Input Method Application
Using the Input Method in a Custom Edit Box
Switching Between Input Methods
Setting Input Method Subtypes
Custom Edit Box Development Guide (C/C++)
Introduction to IPC Kit
IPC and RPC Development
Subscribing to State Changes of a Remote Object
IPC Development (C/C++)
Introduction to Localization Kit
UI Design for Internationalization
Locale and Cultural Habit Division
System Language and Region Setting
Preferred Language Setting
Date and Time Formatting
Number and Unit of Measurement Formatting
Phone Number Formatting
Calendar Setting
Time Zone Setting
DST Transition
Overview of Multilingual Sorting
Sorting by Local Habits
Sorting by Indexes
Character Processing
Language and Locale Name Localization
Time Zone Name Localization
Multilingual Resource Provisioning
Hard Coding and Concatenation Prevention
Scene and Context Clarification for Translation
Singular/Plural Form Selection
Overview of Pseudo-Localization Testing
Pseudo-Localization Testing for Translation
Pseudo-Localization Testing for UI Mirroring
Linguistic Testing
About This Kit
(Recommended) Layered Icon Processing
Single-Layer Icon Processing
How Do I Obtain the layeredDrawableDescriptor Object Information?
Access Control Overview
Application Permission Management Overview
Workflow for Requesting Permissions
Declaring Permissions
Requesting User Authorization
Requesting User Authorization for the Second Time
Requesting One-Time User Authorization
Requesting Restricted Permissions
Permissions for All Applications
Restricted Permissions
Permissions for MDM Applications
Application Permission Groups
Using System Pickers
Security Component Overview
Using PasteButton
Using SaveButton
Using LocationButton
Application Encryption
Overview of the Password Autofill Service
Quick Adaptation
Autosave of Accounts and Passwords
Updates of Accounts and Passwords
Autofill of Accounts and Passwords
Autofill of Strong Passwords
Suggestions on Automatically Generating Strong Passwords for Applications
Adaptation Suggestions for Customized Layouts
Adaptable Scenarios
Adding Password Vault for Web Pages
Introduction to Asset Store Kit
Protecting Asset Data
Protecting Asset Data with User Authentication
Adding an Asset (ArkTS)
Removing Assets (ArkTS)
Updating an Asset (ArkTS)
Querying Assets (ArkTS)
Querying an Asset with User Authentication (ArkTS)
Adding an Asset (C/C++)
Removing Assets (C/C++)
Update an Asset (C/C++)
Querying Assets (C/C++)
Introduction to Crypto Architecture Kit
Key Generation and Conversion Overview
Symmetric Key Generation and Conversion Specifications
Asymmetric Key Generation and Conversion Specifications
Randomly Generating a Symmetric Key (ArkTS)
Randomly Generating a Symmetric Key (C/C++)
Converting Binary Data into a Symmetric Key (ArkTS)
Converting Binary Data into a Symmetric Key Pair (C/C++)
Randomly Generating an Asymmetric Key Pair (ArkTS)
Randomly Generating an Asymmetric Key Pair (C/C++)
Converting Binary Data into an Asymmetric Key Pair (ArkTS)
Converting Binary Data into an Asymmetric Key Pair (C/C++)
Generating an Asymmetric Key Pair Based on Key Parameters (ArkTS)
Converting a Compressed or Uncompressed ECC Public Key (ArkTS)
Converting a Compressed or Uncompressed ECC Public Key (C/C++)
Converting Compressed or Uncompressed ECC Point Data (ArkTS)
Converting a PEM String into an Asymmetric Key Pair (ArkTS)
Converting a PEM String into an Asymmetric Key Pair (C/C++)
Encryption and Decryption Overview
Symmetric Key Encryption and Decryption Algorithm Specifications
Asymmetric Key Encryption and Decryption Algorithm Specifications
Encryption and Decryption by Segment
Encryption and Decryption with an AES Symmetric Key (GCM Mode) (ArkTS)
Encryption and Decryption with an AES Symmetric Key (GCM Mode) (C/C++)
Encryption and Decryption with an AES Symmetric Key (CCM Mode) (ArkTS)
Encryption and Decryption with an AES Symmetric Key (CCM Mode) (C/C++)
Encryption and Decryption with an AES Symmetric Key (CBC Mode) (ArkTS)
Encryption and Decryption with an AES Symmetric Key (CBC Mode) (C/C++)
Encryption and Decryption with an AES Symmetric Key (ECB Mode) (ArkTS)
Encryption and Decryption with an AES Symmetric Key (ECB Mode) (C/C++)
Encryption and Decryption by Segment with an AES Symmetric Key (GCM Mode) (ArkTS)
Encryption and Decryption by Segment with an AES Symmetric Key (GCM Mode) (C/C++)
Encryption and Decryption with a 3DES Symmetric Key (ECB Mode) (ArkTS)
Encryption and Decryption with a 3DES Symmetric Key (ECB Mode) (C/C++)
Encryption and Decryption with an SM4 Symmetric Key (ECB Mode) (ArkTS)
Encryption and Decryption with an SM4 Symmetric Key (ECB Mode) (C/C++)
Encryption and Decryption with an SM4 Symmetric Key (CBC Mode) (ArkTS)
Encryption and Decryption with an SM4 Symmetric Key (CBC Mode) (C/C++)
Encryption and Decryption with an SM4 Symmetric Key (GCM Mode) (ArkTS)
Encryption and Decryption with an SM4 Symmetric Key (GCM Mode) (C/C++)
Encryption and Decryption by Segment with an SM4 Symmetric Key (GCM Mode) (ArkTS)
Encryption and Decryption by Segment with an SM4 Symmetric Key (GCM Mode) (C/C++)
Encryption and Decryption with an RSA Asymmetric Key Pair (PKCS1)
Encryption and Decryption by Segment with an RSA Asymmetric Key Pair
Encryption and Decryption with an RSA Asymmetric Key Pair (PKCS1_OAEP)
Encryption and Decryption with an SM2 Asymmetric Key Pair
Converting SM2 Ciphertext
Signing and Signature Verification Overview and Algorithm Specifications
Signing and Signature Verification with an RSA Key Pair (PKCS1 Mode) (ArkTS)
Signature Verification with an RSA Key Pair (PKCS1 Mode) (C/C++)
Signing and Signature Recovery Using an RSA Key Pair (PKCS1 Mode) (ArkTS)
Signature Recovery Using an RSA Key Pair (PKCS1 Mode) (C/C++)
Signing and Signature Verification by Segment with an RSA Key Pair (PKCS1 Mode) (ArkTS)
Signing and Signature Verification by Segment with an RSA Key Pair (PKCS1 Mode) (C/C++)
Signing and Signature Verification with an RSA Key Pair (PSS Mode) (ArkTS)
Signature Verification with an RSA Key Pair (PSS Mode) (C/C++)
Signing and Signature Verification with an ECDSA Key Pair (ArkTS)
Signing and Signature Verification with an ECDSA Key Pair (C/C++)
Signing and Signature Verification with an SM2 Key Pair (ArkTS)
Signature Verification with an SM2 Key Pair (C/C++)
Key Agreement Overview and Algorithm Specifications
Key Agreement Using ECDH
Key Agreement Using X25519
Key Agreement Using DH
MD Overview and Algorithm Specifications
MD Operation (ArkTS)
MD Operations (C/C++)
MAC Operations
Secure Random Number Generation
Key Derivation Overview and Algorithm Specifications
Key Derivation Using PBKDF2
Key Derivation Using HKDF
Introduction to the DLP Service
DLP Service Development
Introduction to Device Certificate Kit
Certificate Framework Overview
Certificate Development
Certificate Extension Development
CRL Development
Creating a TrustAnchor Object Array from a .p12 File
Certificate Chain Validator Development
Certificate and CRL Collection Development
Certificate Chain Development
Certificate Management Overview
Certificate Management Development
Device Attestation Overview
Application Development
Server Development
About This Kit
Service Quota
Enabling Device Security Kit
Generating an Access Token Based on a Service Account
DeviceVerify
System Integrity Check
URL Check
Image Security Verification
Location Security Verification
Verifying the Anonymous Certificate Chain
Verifying the Signature
SecurityAudit
Fraud Detection
Personal Data Processing Information
About This Kit
Preparations
Starting a File Scanning Task for a Common Directory
Opening a File
Setting Tags for a File
Obtaining the Tags of a File
Obtaining the URI of a File
Deleting Files in a Specified Directory
Updating a Security Control Policy
Setting the KIA File List
No Enterprise Data Guard Kit Permission
About This Kit
Getting Started
FIDO Password-Free Identity Verification
IFAA Password-Free Identity Verification
SOTER Password-Free Identity Verification
Website Link Disclaimer
Introduction to Universal Keystore Kit
Basic Concepts of HUKS
Key Generation Overview and Algorithm Specifications
Generating a Key (ArkTS)
Generating a Key (C/C++)
Key Import Overview and Algorithm Specifications
Importing a Key in Plaintext (ArkTS)
Importing a Key in Plaintext (C/C++)
Importing a Key in Ciphertext (ArkTS)
Importing a Key in Ciphertext (C/C++)
General Process of Using a Key
Encryption and Decryption Overview and Algorithm Specifications
Encryption and Decryption (ArkTS)
Encryption and Decryption (C/C++)
Signing and Signature Verification Overview and Algorithm Specifications
Signing and Signature Verification (ArkTS)
Signing and Signature Verification (C/C++)
Key Agreement Overview and Algorithm Specifications
Key Agreement (ArkTS)
Key Agreement (C/C++)
Key Derivation Overview and Algorithm Specifications
Key Derivation (ArkTS)
Key Derivation (C/C++)
HUKS Access Control Overview
HUKS Access Control Development
Refined Key Access Control Development
HMAC Overview and Algorithm Specifications
HMAC (ArkTS)
HMAC (C/C++)
Deleting a Key (ArkTS)
Deleting a Key (C/C++)
Key Attestation Overview and Algorithm Specifications
Anonymous Key Attestation (ArkTS)
Anonymous Key Attestation (C/C++)
Checking a Key (ArkTS)
Checking a Key (C/C++)
Obtaining Key Properties (ArkTS)
Obtaining Key Properties (C/C++)
Exporting a Key (ArkTS)
Exporting a Key (C/C++)
Querying Key Aliases
Querying Key Aliases (C/C++)
Introduction to User Authentication Kit
Before You Start
Obtaining Supported Authentication Capabilities
Initiating User Authentication
Canceling User Authentication
Applying Custom Authentication
Obtaining Enrolled Credential Information
Using Embedded User Identity Authentication Icons
Connectivity Kit
Bluetooth Overview
Bluetooth Setting Development
BLE Development
GATT Development
SPP Development
NFC Tag Read/Write Development
HCE Development
SE Access Development
WLAN Service Development Overview
P2P Mode Development Guide
Introduction to Distributed Service Kit
Distributed Device Management Development
Introduction to Network Kit
HTTP Data Request
WebSocket Connection
Socket Connection
MDNS Management
Network Connection Management
NetConnection Development
Traffic Management
About This Kit
Getting Started
Network Quality Assessment
Network Scenario Identification
App Data Transmission Quality Feedback
Weak Network Signal Awareness and Judgment
Network Handover Notification
Handover Mode Setting
About This Kit
Getting Started
Sending a Network Request Using fetch
Sending a Network Request Using GET
Sending a Network Request Using POST
Sending a Network Request Using PUT
Sending a Network Request Using HEAD
Sending a Network Request Using DELETE
Canceling a Network Request Using cancel
Closing a Session Using close
Sending a Synchronous Network Request Using fetchsync (C/C++)
Sending an Asynchronous Network Request Using fetch (C/C++)
Sending a Network Request Using GET (C/C++)
Sending a Network Request Using POST (C/C++)
Sending a Network Request Using PUT (C/C++)
Sending a Network Request Using HEAD (C/C++)
Sending a Network Request Using DELETE (C/C++)
Canceling a Network Request Using cancel (C/C++)
Closing a Session Using close (C/C++)
Obtaining Server Resources
Sending Data to the Server
Resumable Transfer
Bidirectional Certificate Verification
Interceptor
Verifying a Certificate Based on Needs
Uploading and Downloading a File
Setting the TLS Protocol Version and Cipher Suite
Obtaining Server Resources (C/C++)
Sending Data to the Server (C/C++)
Resumable Transfer (C/C++)
Bidirectional Certificate Verification (C/C++)
Interceptor (C/C++)
Pinning a Certificate
Verifying a Response
Setting the Read/Write Timeout Interval
Suspending and Resuming Requests
Reading and Writing Streaming Data Synchronously
About This Kit
Introduction to Device Interconnectivity
Device Interconnectivity Development Guide
Overview of Device Interconnectivity NDKs
Device Interconnectivity NDK Development Guide
Device Interconnectivity (RichEditor Control)
After the Device Interconnectivity Control Is Connected, No Devices Are Available for Selection
Introduction to Telephony Kit
Call Service Development
SMS Service Development
Introduction to Basic Services Kit
Introduction to Common Events
Subscribing to Common Events in Dynamic Mode
Unsubscribing from Common Events in Dynamic Mode
Publishing Common Events
Using Emitter for Inter-Thread Communication
Managing Application Accounts
USB Service Development Overview
USB Service Development
FAQs
Requesting Permissions to Access the Pasteboard
Using the Pasteboard to Copy and Paste
Using the Delayed Copy and Paste Function of the Pasteboard
Uploading and Downloading Application Files
Introduction to Function Flow Runtime Kit
Function Flow Runtime Development
Introduction to Input Kit
Input Device Development
Mouse Pointer Development
Event Listening Development (C/C++)
Event Interception Development (C/C++)
Introduction to MDM Kit
MDM Kit Development
EnterpriseAdminExtensionAbility Development
About the Kit
Adding App Icons to Status Bar
About This Kit
Getting Started
Setting the System Navigation Status
Setting System Navigation Data
Registering a Listener for System Navigation Information and Commands
Unregistering a Listener for System Navigation Information and Commands
Registering a Mobility Service Event Listener
Unregistering a Mobility Service Event Listener
Obtaining Mobility Service Event Information
Registering a Smart Mobility Connection Status Listener
Unregistering a Smart Mobility Connection Status Listener
Obtaining the Smart Mobility Connection Status
Introduction to Driver Development Kit
Peripheral Driver Client Development
Peripheral Driver Development
FAQs
Introduction to Multimodal Awareness Kit
Stationary Development
About This Kit
Integrating the Handwriting Suite
Integrating Point Prediction
Integrating Instant Shape
Integrating Color Picker
Does the handwriting suite of Pen Kit support customized brushes?
Does the handwriting suite of Pen Kit support customized pen width levels?
Does the handwriting suite of Pen Kit support customized colors?
Can the toolbar of the handwriting suite of Pen Kit be provided on a separate basis?
Do I need to integrate the point prediction feature of Pen Kit after the handwriting suite has been integrated?
Do I need to integrate the Instant Shape feature of Pen Kit after the handwriting suite has been integrated?
Can I adjust the prediction degree of the point prediction feature of Pen Kit?
Why does the Instant Shape feature fail to recognize a shape?
Introduction to Sensor Service Kit
Introduction to Sensor Service Kit
Sensor Development (ArkTS)
Sensor Development (C/C++)
Vibrator Overview
Vibrator Development (ArkTS)
Vibrator Development (C/C++)
About the Service
Use Cases
Applying for Integrating Wear Engine
Configuring the Client ID
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
Debugging and Verification
If the project already has an app ID, do I need to apply for a new one?
How do I obtain my app's identifiers when using AppInfo?
The user authorization screen does not display
"App has not applied for the Wear Engine service" error message is reported after API calling
No data is reported immediately after the heart rate (HR) sensor is enabled
0 or 255 is reported by the HR sensor
Result code 206 is displayed when the phone is communicating with the lite wearable device
Error code 1008500011 is reported when I send a file from my phone app to my wearable app
More: Submit a ticket online if you cannot find the answer to your question
Personal Data Processing Information
Introduction to Performance Analysis Kit
Using HiLog (ArkTS)
Using HiLog (C/C++)
Introduction to HiAppEvent
Subscribing to Application Events (ArkTS)
Subscribing to Application Events (C/C++)
Crash Event Overview
Subscribing to Crash Events (ArkTS)
Subscribing to Crash Events (C/C++)
Freeze Event Overview
Subscribing to Freeze Events (ArkTS)
Subscribing to Freeze Events (C/C++)
Resource Leak Event Overview
Subscribing to Resource Leak Events (ArkTS)
Subscribing to Resource Leak Events (C/C++)
Address Sanitizer Event Overview
Subscribing to Address Sanitizer Events (ArkTS)
Subscribing to Address Sanitizer Events (C/C++)
Main Thread Jank Event Overview
Subscribing to Main Thread Jank Events (ArkTS)
Subscribing to Main Thread Jank Events (C/C++)
Using hiTraceMeter (ArkTS/JS)
Using HiTraceMeter (C/C++)
Viewing HiTraceMeter Logs
Using HiTraceChain (ArkTS/JS)
Using hiTraceChain (C/C++)
Using HiChecker (ArkTS)
Using HiDebug (ArkTS)
Using HiDebug (C/C++)
Using HiCollie (C/C++)
Development of Error Manager
Development of Application Recovery
Analyzing JS Crash
Analyzing Cpp Crash
Analyzing App Freeze
hdc
hilog
HiDumper
hitrace
hiperf
arkXtest User Guide
SmartPerf User Guide
wukong User Guide
Ability Assistant
Bundle Manager
Packing Tool
Unpacking Tool
App Check Tool
Common Event Manager
Advanced Notification Manager
EDM
restool
param
power-shell
Access Token Manager
Toybox
mediatool
Introduction to Audio Kit
Selecting an Appropriate Audio Stream Type
Introduction to Audio Focus and Audio Session
Using AudioSession to Manage Audio Focus (ArkTS)
Using AudioSession to Manage Audio Focus (C/C++)
Audio Playback Development
Using AudioRenderer for Audio Playback
Responding to Audio Output Device Changes
Using OHAudio for Audio Playback (C/C++)
Using AudioHaptic for Audio-Haptic Playback
Volume Management
Audio Effect Management
Audio Playback Stream Management
Managing Global Audio Output Devices
Audio Recording Development
Using AudioCapturer for Audio Recording
Using OHAudio for Audio Recording (C/C++)
Microphone Management
Audio Recording Stream Management
Managing Global Audio Input Devices
Audio Call Overview
Developing Audio Call
Switching from OpenSL ES to OHAudio (C/C++)
Using OpenSL ES for Audio Playback (C/C++)
Using OpenSL ES for Audio Recording (C/C++)
Introduction to AVCodec Kit
AVCodec Supported Formats
Obtaining Supported Codecs
Audio Encoding
Audio Decoding
Video Encoding
Temporally Scalable Video Coding
Video Decoding
Concurrently Creating a Video Decoder and Initializing NativeWindow
Introduction to Audio Vivid Capabilities
Audio Vivid Demuxing
Audio Vivid Decoding
Audio Vivid Playback
HDR Vivid Video Playback
HDR Vivid Video Recording
Converting HDR Vivid to SDR Videos
Media Data Multiplexing
Media Data Demultiplexing
Introduction to AVSession Kit
Local AVSession Overview
AVSession Provider
Accessing AVSession
Introduction to Playback Control
AVCastPicker Development
Extended Screen Projection Development
Use Cases
Using the Call Device Switching Component
Introduction to Camera Kit
Camera Development Preparations
Camera Device Management (ArkTS)
Device Input Management (ArkTS)
Camera Session Management (ArkTS)
Preview (ArkTS)
Photo Capture (ArkTS)
Video Recording (ArkTS)
Camera Metadata (ArkTS)
Using the Flashlight (ArkTS)
Adapting to Camera Changes in Different Folding States (ArkTS)
Deferred Photo Delivery (ArkTS)
Moving Photos (ArkTS)
Basic Camera Animation (ArkTS)
Using the Camera in the Worker Thread (ArkTS)
Using the Camera Picker (ArkTS)
Photo Capture Sample (ArkTS)
Video Recording Sample (ArkTS)
Dual-Channel Preview (ArkTS)
Deferred Photo Delivery Sample (ArkTS)
Sample for Camera Recovery from the Background (ArkTS)
Camera Device Management (C/C++)
Device Input Management (C/C++)
Camera Session Management (C/C++)
Preview (C/C++)
Secondary Processing of Preview Streams (C/C++)
Photo Capture (C/C++)
Deferred Photo Delivery (C/C++)
Video Recording (C/C++)
Camera Metadata (C/C++)
Using the Flashlight (C++)
Photo Capture Sample (C/C++)
Video Recording Sample (C/C++)
Sample of Secondary Processing of Video Streams (C/C++)
Introduction to DRM Kit
DRM Media Key System Management (ArkTS)
DRM Media Key Session Management (ArkTS)
DRM Media Key System Management (C/C++)
DRM Media Key Session Management (C/C++)
Introduction to Image Kit
Using ImageSource to Decode Images
Using PixelMap to Transform Images
Using PixelMap for PixelMap Operations
Using ImagePacker to Encode Images
Editing EXIF Data
Introduction to the Image_NativeModule Structs
Using Image_NativeModule to Decode Images
Using Image_NativeModule to Receive Images
Using Image_NativeModule for PixelMap Operations
Using Image_NativeModule to Process Image Information
Using Image_NativeModule to Encode Images
Using ImageEffect to Edit Images
Using Image to Decode Images
Using Image to Receive Images
Using Image to Transform Images
Using Image to Process PixelMap Data
Using Image to Encode Images
Introduction to Media Kit
Using AVPlayer to Play Audio (ArkTS)
Using AVPlayer to Play Videos (ArkTS)
Using AVPlayer to Set Playback URLs (ArkTS)
Using AVPlayer to Play Streaming Media (ArkTS)
Using AVPlayer to Add External Subtitles to Videos (ArkTS)
Using SoundPool to Play Short Sounds (ArkTS)
Using AVRecorder to Record Audio (ArkTS)
Using AVRecorder to Record Videos (ArkTS)
Using AVScreenCaptureRecorder to Record Screens and Save Them to Files (ArkTS)
Using AVMetadataExtractor to Extract Audio and Video Metadata (ArkTS)
Using AVImageGenerator to Extract Video Images at a Specified Time (ArkTS)
Using AVTranscoder to Transcode Videos (ArkTS)
Using AVPlayer to Play Audio (C/C++)
Using AVPlayer to Play Video (C/C++)
Using AVScreenCapture to Capture Screens and Obtain Streams (C/C++)
Using AVScreenCapture to Capture Screens and Write Them to Files (C/C++)
Introduction to Media Library Kit
Selecting Media Assets Using Picker
Saving Media Assets
Accessing and Managing Moving Photos
Playing Moving Photos with MovingPhotoView
Before You Start
Managing Media Assets
Managing User Albums
Managing System Albums
Observing Media Assets
Requesting Media Assets Using MediaAssetManager (C/C++)
About This Kit
Setting a Ringtone
About This Kit
Getting Started
Scan-to-Access Capability
Barcode Scanning by Default UI
Barcode Scanning by Custom UI
Scanning Barcodes in a Saved Image
Recognizing Barcodes in Image Data
Generating a Barcode Image from Text
Generating a Barcode Image from a Byte Array
How Do I Add a Quick Entry for the Scan-to-Access Service?
Failed to Open the Target Page Through Scan-to-Access
Scan Kit Cannot Recognize Multiple Barcodes at a Time
Device Types in Uploaded App Package Inconsistent with Declared Device Types During Package Upload
Multi-Barcode Scanning Failed During Gallery-based Barcode Scanning
1D Code Recognition Failure
Recognized Coordinate Information of a 1D Code Is Empty
Scanning Preview Image on Custom UI Stretched
Black Screen Occurred on the Custom Scanning UI
How Do I Scan Barcodes Continuously on the Custom Scanning UI (customScan.rescan)?
Failure to Recognize a Barcode Image Generated from a Byte Array
How Do I Determine Whether Scanning is Canceled on the Default Scanning UI?
How Do I Integrate Scan Kit for HTML5
How Do I Implement Zoom Ratio Change Through Gestures?
How Do I Implement the Barcode Scanning Box on a Custom UI?
Experience Design Problem on the Default/Custom Barcode Scanning UI
Personal Data Processing Information
About AR Engine
Getting Started
Managing AR Sessions
Obtaining the Device Pose
Detecting Planes in the Environment
Recognizing Plane Semantics
Recognizing the Target Shape
Placing AR Objects
Error Message "plane is nullptr!" Is Reported with the Error Code 401 When I Attempt to Obtain the 2D Vertex Coordinate Array of the Detected Plane
When the Camera Is Blocked for a Period of Time and Then Uncovered, the Output Pose Changes Dramatically
Unable to Recognize Planes In Scenarios with Reflections, Dim Lights, or Weak Textures (Where There Is Little Color Variation in the Input Images)
The Plane Drifts or Post Data Changes Abruptly in Certain Special Scenarios (Such as When a Strong Magnetic Field Is Nearby, the Phone Is Overheated, or When Duplicate Textures Are Scanned)
Introduction to ArkGraphics 2D
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
Overview of Graphics Drawing and Display
Obtaining a Canvas and Displaying Drawing Results (ArkTS)
Obtaining a Canvas and Displaying Drawing Results (C/C++)
Canvas Operations and State Processing (ArkTS)
Canvas Operations and State Processing (C/C++)
Overview of Drawing Effects
Basic Drawing Effects (ArkTS)
Complex Drawing Effects (ArkTS)
Basic Drawing Effects (C/C++)
Complex Drawing Effects (C/C++)
Overview of Primitive Drawing
Drawing Geometric Shapes (ArkTS)
Drawing Images (ArkTS)
Drawing TextBlobs (ArkTS)
Drawing Geometric Shapes (C/C++)
Drawing Images (C/C++)
Drawing TextBlobs (C/C++)
Using the Text Module for Text Display
Native Buffer Development (C/C++)
Native Image Development (C/C++)
Native VSync Development (C/C++)
Native Window Development (C/C++)
Graphics Development Terms
Introduction to ArkGraphics 3D
Building and Managing ArkGraphics 3D Scenes
Creating and Using ArkGraphics 3D Resources
Controlling and Managing ArkGraphics 3D Scene Animations
About This Kit
Overview
OpenGL ES
Vulkan
Overview
OpenGL ES
Vulkan
Vertex Marking
Developing the ABR Capability
Developing the OpenGTX Capability
What Are the Graphics APIs Supported by the Frame Generation and ABR Capabilities?
What types of devices does Graphics Accelerate Kit support?
What Are the Possible Causes of Serious Blurring Artifacts on the Edges of Moving Objects After the Extrapolation Mode of Frame Generation Is Enabled?
What Kinds of Buffers Are Suitable for the ABR Capability?
What Can I Do if the Rendering Effect of Other Passes Becomes Abnormal After the Buffer Resolution Is Adapted by the ABR Capability?
What Can I Do if the Native Texture Content Obtained from the Game Engine Is Empty After the ABR Capability Is Integrated?
About This Kit
Getting Started
GPU Spatial Upscaling
AI Temporal Upscaling
AI Spatial Upscaling
Adaptive VRS
Subpass Shading
What Can I Do If an Extension Instance Fails to Be Created?
Can I Use Upscaling and Adaptive VRS Features at the Same Time?
Adaptive VRS Depth Attachment Instructions
Do I Have to Create the Output Color Attachment by calling OH_NativeBuffer When Using the AI Spatial Upscaling Feature?
About This Kit
Management Rules for Using the Sign-in Capability of Account Kit
Configuring the Client ID
Configuring Scopes
Overview
Signing In with HUAWEI ID Through Just One Tap (Obtaining the Mobile Number, 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
Overview
Obtaining the Avatar and Nickname
Overview
Quick Verification
Obtaining the Shipping Address
Obtaining the Invoice Title
Overview
(Recommended) Following the Youth Mode Status on the Device
Enabling or Disabling the Youth Mode in an App
Subscribing to and Processing User Information Changes
What are the length limits of OpenID and UnionID?
What are the validity periods of access token and refresh token?
What are the length limits of access token and refresh token?
Is there a limit on the number and frequency of calls to the API for obtaining an app-level access token?
What can I do if the mobile number fails to be obtained or the obtained mobile number is empty?
When and how can I use the ID token?
What can I do if USB debugging is unavailable after the youth mode is enabled?
How to exchange user data between HarmonyOS APK apps and HarmonyOS apps in the one-tap sign-in scenario?
Is the UnionID or OpenID of a HUAWEI ID user or the mobile number as their unique identifier during one-tap sign-in with HUAWEI ID? After the mobile number bound to a HUAWEI ID is changed, does the user have one or two accounts when signing in to an app?
Personal Data Processing Information
About This Kit
Overview
Banner Ads
Native Ads
Rewarded Ads
Interstitial Ads
Splash Ads
Roll Ads
Why Is a White Screen Displayed When an Ad Is Displayed?
Why Is Only One Ad Displayed When an Ad Array Is Passed During Native Ad Display?
Restrictions on Petal Publisher Console
Identifier Service
Personal Data Processing Information
Introduction to Calendar Kit
Calendar Management
Event Management
Contacts Kit Development
Introduction to Location Kit
Applying for Location Permissions
Obtaining Device Location Information
Geocoding and Reverse Geocoding
Geofencing
Introduction to Notification Kit
Requesting Notification Authorization
Managing the Notification Badge
Managing Notification Slots
Publishing a Text Notification
Publishing a Progress Notification
Adding a WantAgent Object to a Notification
Canceling a Notification
About This Kit
Preparations
Subscribing to or Unsubscribing from voipCallUiEvent
Notifying the System of Incoming Calls
Notifying the System of Outgoing Calls
Reporting Call Mute and Speaker Events
Notifying the System of Call Status Changes
Notifying the System of Call Status Changes and Specifying the Call Type
Notifying the System of Call Connection Failures
Why Is the Notification Banner Not Displayed?
Why Is the Profile Picture Not Displayed in the Notification Banner?
About This Kit
Enabling Cloud Functions
Enabling Cloud DB
Enabling Cloud Storage
Node.js
Creating and Configuring a Function
Testing a Function
Calling a Function
Adding an Object Type
Adding a Cloud DB Zone
Importing an Object Type File
Initializing Database Access
Writing Data
Querying Data
Deleting Data
Setting Configuration Items of Cloud Storage
Initializing a Storage Instance
Uploading a Specified File to the Cloud
Downloading a File from the Cloud to a Local Path
Obtaining the Download URL of a Cloud File
Deleting a Cloud File
Obtaining the Cloud File List
Obtaining Metadata of a Cloud File
Setting Metadata of a Cloud File
Why Is "404:Product does not exist" Displayed When a File Fails to Be Uploaded Using Cloud Storage?
Why Does the App Log Display ""state":65" and the Upload Process Log Display "403 Forbidden" When a File Fails to Be Uploaded Using Cloud Storage?
Personal Data Processing Information
About This Kit
Preparations
Overview
Integration Process
Importing Modules
Performing Initialization
Registering an Event Listener
Multi-provider Sign-In
Associating with an Official Game Account (Association Scene)
Addiction Prevention for Minors
Submitting Player Role Information
(Optional) Game Scene Perception Function Development
Personal Data Processing Information
Pre-release Check
Game Release
How Can Game Data Be Synchronized Between HarmonyOS/EMUI and HarmonyOS NEXT? Does It Require Adaptation on the Game Side?
Must the API for Saving the Player's Role Information Be Called?
Can Other Service APIs Be Called Only After the Game Is Successfully Initialized?
Must a Package Name End with .huawei?
Are Identity Verification and Game Addiction Prevention Implemented by Huawei or Game?
How Does the Game Obtain Information About a User's HUAWEI ID, Including the Avatar and Nickname?
About This Kit
Integration Process
Qualifications Requirements for Developers
Data Openness
Applying for Health Service Kit
Configuring the Client ID
Managing User Authorization
Managing Data Sources
Managing Fitness and Health Sampling Data
Managing Workout Records
Managing Health Records
Reading Real-time Activity Rings Data
Overview
Scope Description
Daily Activities
Heart Rate
SpO2
Stress
Body Temperature
Blood Pressure
Weight
Height
Overview
Running
Walking
Cycling
Rope Jumping
Expedition
Basketball
Skiing
Apnea Testing in Diving
Apnea Training in Diving
Diving
Elliptical Machine
Golf
Mountain Climbing
Swimming
Rowing Machine
Others
Sleep
Applying for Formal Scopes
Personal Data Processing Information
The daily activity statistics returned are inconsistent with those in the Huawei Health app
No scope for a data type after obtaining the authorization
Error 1001502003 is reported during authorization
Error 1001502014 is reported during authorization
How to guide users to open the Huawei Health app if they have not agreed to the user privacy statement
Getting Help
Specifications for Using Logos
About This Kit
Configuring App Information in AppGallery Connect
Configuring an App
Configuring Products
Implementing the Purchase Process
(Mandatory) Delivering an Order
About Subscriptions
Implementing the Subscription Process
(Mandatory) Delivering an Order
Sandbox Testing
Can I set multiple addresses for receiving key events in AppGallery Connect?
What is the maximum length of the IAP public key obtained in AppGallery Connect? Is there a recommended length?
I try adding a product on the product management page in AppGallery Connect, and see a default price when setting my product price. What's the default price used for?
If the price of an in-app product in a country/region is changed in AppGallery Connect, will the price be affected when the exchange rate changes later?
Has AppGallery Connect made any numerical adjustments to the price display on the product management page? For example, have they adjusted the second decimal place to 6 or 9?
Is the SHA-256 certificate mandatory for signature verification?
Can signature verification be performed entirely on the server side?
Is there only one payment UI? Any other payment UIs available?
Can the ID of a deleted product be used again for a new product?
Certificates Supported by the Huawei IAP Server
Cipher Suites Supported by the Huawei IAP Server
How do I fix the error of an incomplete certificate chain?
Pre-release Check
About This Kit
Live View Design Specifications
Preparations
Precautions
Creating a Local Live View
Updating a Live View Through Push Kit
FAQs
About This Kit
Preparations
Displaying a Map
Changing the Map Type
Showing My Location
Displaying a Custom Map
Control Interaction
Gesture Interaction
Event Interaction
Map Location Change
Map Screenshot
Marker
MapPolyline
MapArc
MapPolygon
MapCircle
PointAnnotation
Bubble
ClusterOverlay
ImageOverlay
BuildingOverlay
TraceOverlay
Setting the Overlay Order of Map Elements
POI Search
Geocoding
Travel Route Planning
Batch Route Computation
Trajectory-based Road Snapping
Static Map
Place Details Display
Location Selection
Administrative Division Selection
Navigation and Other Capabilities Provided by Petal Maps
Coordinate Conversion
Distance Calculation
Map Not Displayed
Icon Parsing Exception
How to Obtain siteId?
Gestures Freeze or Do Not Work
Personal Data Processing Information
Map Review Number
Map Data Copyright Statement
Supported Languages
Supported Countries/Regions
About This Kit
Opening a PDF Document
Converting the File Format
Adding a Header or Footer
Adding a Watermark
Adding a Background
Adding an Annotation
Adding a Bookmark
Opening a PDF Document
Saving a PDF Document
Setting the PDF Document Preview Mode
Converting a PDF Document to an Image
Highlighting a PDF Document
Searching for a Specific Keyword in a PDF Document
Previewing a PDF Document Using the PdfView Component
Can I remove the header, footer, watermark, and background from a specific page using PDF Kit?
About This Kit
File Preview
Failed to open a file preview via the openPreview API
About This Kit
Integration Specifications
Enabling Push Kit
Applying for Scenario-Specific Message Permissions
Obtaining a Push Token
Sending a Notification Message
Recalling a Notification Message
Pushing an Authorized Subscription Message
Pushing a Widget Update Message
Sending an Extended Notification Message
Recalling an Extended Notification Message
Pushing a Background Message
Pushing a Live View Message
Pushing an In-App Call Message
Overview
Generating a JWT Based on a Service Account
Pushing Scenario-Specific Messages
(Optional) Developing the Message Receipt
Obtaining the AAID
Message Successfully Pushed from the Cloud Side but Failed to Be Displayed at the Device Side
Incorrect Classification or Categorization
Push Message Upper Limit Reached
Message Frequency Control Problems
In-App Call Message Status Error Upon First Screen Lock After the Device Is Restarted
Incoming Call Answering and Banner Error of an In-App Call Message
Personal Data Processing Information
Notification Content Management Rules
Push Notification Violation Penalty Criteria
About This Kit
Preparations
Mobile Number Quick Verification Button
Avatar Selection Button
Authorization Setting Page Launch Button
App Launch Button
Shipping Address Selection Button
Invoice Title Selection Button
Map Location Selection Button
Scenario-specific APIs
Introduction to SmartFill
Typical Scenarios
Changing the Value of ContentType Dynamically
Auto-filling Address Information in a Form
Data Sources and Logic of Suggestions
ContentType Scenarios
Supporting SmartFill for HTML5
Supporting SmartFill for HTML5 Within React Native
Supporting SmartFill for HTML5 Within Flutter
Supporting SmartFill for HTML5 Within Taro
Supporting SmartFill for HTML5 Within Weex
Supporting SmartFill for HTML5 Within mPaas
Mapping Between HTML5/Third-Party Framework Configuration Items and HarmonyOS Configuration Items
Sheet Cannot Be Opened When the Quick Mobile Number Verification Button Is Tapped
Failure to Launch a Third-Party App
Clipboard Paste Box Blocked SmartFill Selection Box
Personal Data Processing Information
About This Kit
Initiating Content Sharing in a Mobile App
Initiating Content Sharing in a 2-in-1 Device App
Configuring the Operation Area in the Host App
Obtaining the Precise UTD Type
Sharing Links
Sharing Images
Sharing Videos
Sharing Text
Processing the Shared Content Inside a Target App
Processing the Shared Content on the Level-2 Panel
Closing the Sharing Panel from the Level-2 Panel
Target App Design Specifications
Failed to Start the System Sharing Panel
About This Kit
Overview
Integration Process
Enabling Relevant Services and Setting Parameters
Configuring an App
About Digital Products
Configuring Digital Products in AppGallery Connect
Configuring Digital Products Through the Server API
Displaying Digital Products
Purchasing Digital Products
Delivering Digital Products
Testing the Digital Product Service
Recommendation on AppGallery
On-Demand Feature Distribution
Ecosystem Query Service
Update on AppGallery
Development Overview
Registering an Enterprise Account
Registering an Attribution Role
Standard Conversion Events
Custom Conversion Events
Registering Attribution Sources and Conversion Events
Posting Back the Attribution Result
Performing Debugging
Privacy Agreement Management Service
Can I Set Multiple Addresses for Receiving Key Subscription Events in AppGallery Connect?
What Is the Maximum Length of the IAP Public Key Obtained in AppGallery Connect? Is There a Recommended Length?
I Try Adding a Product on the Product Management Page in AppGallery Connect, and See a Default Price When Setting My Product Price. What Is the Default Price Used for?
If the Price of an In-App Product in a Country/Region Is Changed in AppGallery Connect, Will the Price Fluctuate with Future Exchange Rate Changes?
Has AppGallery Connect Made Any Numerical Adjustments to the Price Displayed on the Product Management Page, for Example, Changing the Second Decimal Place of a Price to 6 or 9 According to Relevant Rules?
Is the SHA-256 Certificate Mandatory for Signature Verification?
Can Signature Verification Be Performed Entirely on the Server Side?
Is There Only One Payment UI? Any Other Payment UIs Available?
How Long Is the Validity Period of purchaseToken?
Can the ID of a Deleted Product Be Used Again for a New Product?
How Many Certificates Are Supported by the Digital Product Server?
What Cipher Suites Are Supported by the Digital Product Server?
How Do I Fix the Error of an Incomplete Certificate Chain?
What Order Statuses Are Supported by the Digital Product Service?
What Are the Rules for Renewal Periods of a Subscription?
Does a One-Month Subscription Renewal Period Refer to 30 Days, 31 Days, or a Calendar Month? Similarly, How Many Days Are Included in Two Months and Three Months?
Does February Have 28 or 29 Days When Calculated by the Calendar Month?
Why Does an Atomic Service Widget Fail to Be Displayed on AppGallery?
Why Do the Dynamic Modules Fail to Be Loaded in the On-Demand Loading Scenario?
How Can I Quickly Debug the On-Demand Feature Distribution Function in My App When It Has Not Been Released on AppGallery?
Why Is the Scene Value Obtained Through the Ecosystem Query Service Empty?
Why Does the Update on AppGallery Function Throw an Exception Indicating that the App Is Not Running in the Foreground?
Can I Customize the Content in the App Update Pop-up Displayed to Users?
Why Does an Identity Verification Error Occur When I Call the Attribution Source Registration API of the App Attribution Service?
How Do I Obtain Logs of the App Attribution Service Through Filtering?
Appendix
About This Kit
Applying for Wallet Kit
Overview
Preparations on the HUAWEI Wallet Server
Enabling a Car Key
Car Control
Overview
Preparations on Your Server
Activating a Transportation Card
Topping Up a Transportation Card
Updating a Transportation Card
Deleting a Transportation Card
In which countries/regions can Wallet Kit be used?
Do I have to integrate Account Kit into my app in order to use Wallet Kit?
What will happen if a user attempts to add a pass to HUAWEI Wallet without signing in using a HUAWEI ID?
Which is the most commonly used access method?
What operations are performed by my server when a pass is added?
How can I view an added pass?
Why is only one pass displayed in HUAWEI Wallet after a user claims multiple passes from the same merchant?
Which information will be deleted when a user deletes a pass?
About This Kit
Getting Started
Obtaining Weather Data
How to Obtain the Weather Data of a Specified City
Do Weather Service Kit APIs Support the Positioning Function
No Data Returned After Minute-Level Precipitation Forecast/Weather Alert/Tide Data Is Requested
About This Kit
Text-to-Speech
Speech Recognition
About This Kit
OCR
Face Detection
Face Verification
Subject Segmentation
Multi-object Detection
Skeleton Detection
Introduction to HiAI Foundation Kit
Getting Started
Model Zoo
Overview
Non-training Quantization
Plugin-based Quantization
NAS Training
Model Size Reduction Example
FAQs on Model Size Reduction
Model Benefits
OMG Parameters
Preparing for Model Conversion
Model Conversion Example
Overview
AIPP Parameters
AIPP Configuration File Used for Model Conversion
Variable data_type
Deployment Process
Model Inference
AIPP Deployment
Heterogeneity
Zero Memory Copy
In-depth Fusion
Creating a Project
Configuring NAPI for Your Project
Model Integration
Single-Operator Application
How can I determine whether a model can run on mobile phones?
How do I select the sync or async API?
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 HiAI Foundation during model design?
How to Obtain the Version
Supported Operators
Visualization Tool
About This Kit
Intents Kit Integration Process
Overview
Use Cases
Integration Solution
Testing Solution
Overview
Use Cases
Integration Solution
Testing Solution
Overview
Use Cases
Integration Solution
Overview
Use Cases
Integration Solution
Appendix A: How to Obtain the UID of a HUAWEI ID
Introduction to MindSpore Lite Kit
Using MindSpore Lite for Model Conversion
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++)
About This Kit
Word Segmentation
Entity Extraction
Introduction to Neural Network Runtime Kit
Connecting NNRt to an AI Inference Framework
About This Kit
TextReader
AICaption
About This Kit
Face Liveness Detection
Card Recognition
Document Scanning
AI Image Recognition
Hopping Overview
Application Continuation Overview
Application Continuation Development
Cross-Device Drag and Drop Overview
Cross-Device Drag and Drop Development
Cross-Device Clipboard Overview
Cross-Device Clipboard Development
Getting Started with the NDK
Creating an NDK Project
NDK Project Building Overview
Building an NDK Project with the DevEco Studio Template
Building an NDK Project with CMake
Building an NDK Project with Prebuilt Libraries
BiSheng Compiler
Development Overview
C/C++ Library Mechanisms
Using fdsan
Node-API Overview
Node-API Data Types and APIs
Node-API Development Specifications
Node-API Development Process
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
Working with 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 Tide Their Lifecycle Using Node-API
Working with Functions Using Node-API
Performing Lifecycle Management Using Node-API
Working with Objects Using Node-API
Working with Other Node-API Utilities
Working with Primitives Using Node-API
Implementing Asynchronous Operations Using Node-API
Working with Properties Using Node-API
Working with String Using Node-API
Customizing Asynchronous Operations Using Node-API
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
Calling an ArkTS Method with Return Value of a Promise Using Node-API
Node-API FAQs
JSVM-API Overview
JSVM-API Data Types and APIs
JSVM-API Development Process
JSVM-API Development Specifications
JSVM-API FAQs
Working with Tasks Using JSVM-API
Working with VM Snapshots Using JSVM-API
Working with Wasm Using JSVM-API
Creating and Calling JS Functions Using JSVM-API
Performing JSON Operations Using JSVM-API
Working with Arrays Using JSVM-API
Working with ArrayBuffer Using JSVM-API
Working with BigInt Using JSVM-API
Working with Class Using JSVM-API
Working with Date Using JSVM-API
Working with Objects Using JSVM-API
Working with Primitives Using JSVM-API
Implementing Asynchronous Operations Using JSVM-API
Setting JS Object Properties Using JSVM-API
Obtaining the JSVM-API Version Using JSVM-API
Error Handling Using JSVM-API
Debugging and Profiling JS Code Using JSVM-API
Performing Lifecycle Management Using JSVM-API
Performing Memory Management Using JSVM-API
Comparing JS Values Using JSVM-API
Creating Basic Data Types Using JSVM-API
JSVM-API Debugging
Creating and Destroying JSVMs Using JSVM-API
Accelerating Compilation Using a Code Cache
JSVM Tuning Practices
OpenMP Overview
Building and Running Applications Using OpenMP
Raw File Development
QoS Development
Purgeable Memory Development
USB DDK Development
HID DDK Development
Native Bundle Development
Debugging and Profiling Overview
Debugging in DevEco Studio
LLDB Debugger
C/C++ Memory Error Detection
Introduction to Hardware Compatibility
HarmonyOS ABIs
CPU Features
Using Neon Instructions
Introduction
Downloading Software
Installing DevEco Studio
Creating and Running a Hello World Project
Setting Up the Proxy
Setting Up the Development Environment Without Internet Access
Project Overview
Project Directory Structure
Introduction to Project Templates
Creating a Project
Creating a Lite Project
Migrating a Project
Adapting to ohpm
Adding or Deleting a Module
Adding an Ability to a Module
Creating a Service Widget
Adding a Page
Creating an Insight Intent
Editor Basics
Code Generation/Completion
Real-time Code Check and Quick Fix
Code Linter Check
Code Refactoring
ArkTSDoc Generation
Cross-language Code Editing
Introduction
PreviewChecker Inspection Rules
Previewing an ArkTS/JS App/Atomic Service
Previewing an ArkUI Page or Component
Using Preview Profile Manager
Previewing Your App/Atomic Service on Multiple Devices
Inspector Bidirectional Preview
Mocking Preview Data
List of Previewer-Capable APIs
Developing a Static Shared Package
Developing a Dynamic Shared Package
Publishing a Shared Package
Referencing a Shared Package
Converting a Shared Package from the .tgz Format to the .har Format
Generating an App Icon
Build System Lifecycle
hvigor-config.json5
build-profile.json5
Understanding Build Tasks
Build Products
Managing Modules
Adding Dependencies
Introduction
Examples
Configuring for C++ Builds
Building a HAR
Implementing Multi-Project Builds
Logic for Checking HAP Uniqueness
Customizing the .hvigor Directory Path
Introduction
Examples
Introduction
Examples
Introduction
Examples
Analyzing Build Performance
Optimizing the hvigor Build Performance
Using the hvigor Daemon Process
Conducting an Incremental Build
Using Modular Compilation
Enabling the AOT Compilation Mode
Quick Link to a Pre-built Library
Developing a hvigor Task
Plug-in Development
Basic Build Capability
Project Model
Plug-in Context
API Usage Examples
Code Obfuscation
Logging
Compilation and Building FAQs
Signing Your App/Atomic Service
Running Your App/Atomic Service on a Local Real Device
Debugging Overview
Setting Running/Debugging Configuration
Starting and Debugging an App/Atomic Service
Debugging an App/Atomic Service in Running
Debugging an App at Startup
Using Breakpoints
Checking Variables
Using the Debugger
Reverse Debugging
Extension Debugging
Worker/TaskPool Debugging
Evaluate and Log
Smart Step Into
Starting Debugging
Using Breakpoints
Checking Variables
Debugging Assembly Code
Viewing Memory Information
Using LLDB Debugging Commands
Reverse Debugging
Viewing Stack Information
Viewing .so Information
Setting Execution Points
Using Smart Step Into
Cross-Language Debugging
Third-Party Code Debugging
Incremental Debugging
Multi-Process Debugging
Hot Reload
Developer Options
Log Analysis
Fault Log
Stack Trace Analysis
Exception Stack Trace Analysis
ASan
TSan
ArkCompiler Runtime Detection
Layout Analysis
Device File Access
Capturing Screenshots
Screen Recording
Overview of Performance Profiling
Overall UI Layout and Concepts
Session Area
Data Area
Performance Profiling Procedure
Real-Time Monitoring for Problem Demarcating
In-depth Capture for Problem Locating
Basic Time Analysis: Time
Memory Analysis and Optimization
Filtering Analysis Data
Analyzing the Startup Memory
Basic Operations with Memory Snapshot Analysis
ArkTS Memory Leak Analysis
CPU Activity Analysis: CPU
Frame Analysis
ArkUI Analysis
Cold Start Analysis: Launch
Parallelism and Concurrency Analysis: Concurrency
Loading and Frame Loss Analysis: ArkWeb
Network Diagnosis: Network
Shortcut Keys
Instrument Test
Local Test
Mock
Black-box Test with Coverage
AppAnalyzer
Releasing Your App/Atomic Service
Rule Changes
@typescript-eslint/adjacent-overload-signatures
@typescript-eslint/await-thenable
@typescript-eslint/array-type
@typescript-eslint/ban-ts-comment
@typescript-eslint/ban-tslint-comment
@typescript-eslint/ban-types
@typescript-eslint/brace-style
@typescript-eslint/class-literal-property-style
@typescript-eslint/comma-dangle
@typescript-eslint/comma-spacing
@typescript-eslint/consistent-indexed-object-style
@typescript-eslint/consistent-type-assertions
@typescript-eslint/consistent-type-definitions
@typescript-eslint/consistent-type-imports
@typescript-eslint/default-param-last
@typescript-eslint/dot-notation
@typescript-eslint/explicit-function-return-type
@typescript-eslint/explicit-member-accessibility
@typescript-eslint/explicit-module-boundary-types
@typescript-eslint/func-call-spacing
@typescript-eslint/init-declarations
@typescript-eslint/keyword-spacing
@typescript-eslint/lines-between-class-members
@typescript-eslint/member-delimiter-style
@typescript-eslint/member-ordering
@typescript-eslint/method-signature-style
@typescript-eslint/naming-convention
@typescript-eslint/no-array-constructor
@typescript-eslint/no-base-to-string
@typescript-eslint/no-confusing-non-null-assertion
@typescript-eslint/no-confusing-void-expression
@typescript-eslint/no-dupe-class-members
@typescript-eslint/no-duplicate-imports
@typescript-eslint/no-dynamic-delete
@typescript-eslint/no-empty-function
@typescript-eslint/no-empty-interface
@typescript-eslint/no-explicit-any
@typescript-eslint/no-extraneous-class
@typescript-eslint/no-extra-non-null-assertion
@typescript-eslint/no-extra-parens
@typescript-eslint/no-extra-semi
@typescript-eslint/no-floating-promises
@typescript-eslint/no-for-in-array
@typescript-eslint/no-implicit-any-catch
@typescript-eslint/no-implied-eval
@typescript-eslint/no-inferrable-types
@typescript-eslint/no-invalid-this
@typescript-eslint/no-invalid-void-type
@typescript-eslint/no-loop-func
@typescript-eslint/no-loss-of-precision
@typescript-eslint/no-magic-numbers
@typescript-eslint/no-misused-new
@typescript-eslint/no-misused-promises
@typescript-eslint/no-namespace
@typescript-eslint/no-non-null-asserted-optional-chain
@typescript-eslint/no-non-null-assertion
@typescript-eslint/no-parameter-properties
@typescript-eslint/no-redeclare
@typescript-eslint/no-require-imports
@typescript-eslint/no-restricted-syntax
@typescript-eslint/no-shadow
@typescript-eslint/no-this-alias
@typescript-eslint/no-throw-literal
@typescript-eslint/no-type-alias
@typescript-eslint/no-unnecessary-boolean-literal-compare
@typescript-eslint/no-unnecessary-condition
@typescript-eslint/no-unnecessary-qualifier
@typescript-eslint/no-unnecessary-type-arguments
@typescript-eslint/no-unnecessary-type-assertion
@typescript-eslint/no-unnecessary-type-constraint
@typescript-eslint/no-unsafe-argument
@typescript-eslint/no-unsafe-assignment
@typescript-eslint/no-unsafe-call
@typescript-eslint/no-unsafe-member-access
@typescript-eslint/no-unsafe-return
@typescript-eslint/no-unused-expressions
@typescript-eslint/no-unused-vars
@typescript-eslint/no-use-before-define
@typescript-eslint/no-useless-constructor
@typescript-eslint/prefer-as-const
@typescript-eslint/prefer-enum-initializers
@typescript-eslint/prefer-for-of
@typescript-eslint/prefer-function-type
@typescript-eslint/prefer-includes
@typescript-eslint/prefer-literal-enum-member
@typescript-eslint/prefer-namespace-keyword
@typescript-eslint/prefer-nullish-coalescing
@typescript-eslint/prefer-optional-chain
@typescript-eslint/prefer-readonly
@typescript-eslint/prefer-readonly-parameter-types
@typescript-eslint/prefer-reduce-type-parameter
@typescript-eslint/prefer-regexp-exec
@typescript-eslint/prefer-string-starts-ends-with
@typescript-eslint/prefer-ts-expect-error
@typescript-eslint/promise-function-async
@typescript-eslint/quotes
@typescript-eslint/require-array-sort-compare
@typescript-eslint/require-await
@typescript-eslint/restrict-plus-operands
@typescript-eslint/restrict-template-expressions
@typescript-eslint/return-await
@typescript-eslint/semi
@typescript-eslint/space-before-function-paren
@typescript-eslint/space-infix-ops
@typescript-eslint/strict-boolean-expressions
@typescript-eslint/switch-exhaustiveness-check
@typescript-eslint/triple-slash-reference
@typescript-eslint/type-annotation-spacing
@typescript-eslint/typedef
@typescript-eslint/unbound-method
@typescript-eslint/unified-signatures
prefer-const
eqeqeq
@security/no-commented-code
@security/no-cycle
@security/no-unsafe-aes
@security/no-unsafe-dh
@security/no-unsafe-dh-key
@security/no-unsafe-dsa
@security/no-unsafe-dsa-key
@security/no-unsafe-ecdsa
@security/no-unsafe-hash
@security/no-unsafe-mac
@security/no-unsafe-rsa-encrypt
@security/no-unsafe-rsa-key
@security/no-unsafe-rsa-sign
@security/specified-interface-call-chain-check
@performance/high-frequency-log-check
@performance/hp-arkts-no-use-any-export-current
@performance/hp-arkts-no-use-any-export-other
@performance/hp-arkui-avoid-empty-callback
@performance/hp-arkui-avoid-update-auto-state-var-in-aboutToReuse
@performance/hp-arkui-combine-same-arg-animateto
@performance/hp-arkui-image-async-load
@performance/hp-arkui-limit-refresh-scope (Deprecated)
@performance/hp-arkui-load-on-demand
@performance/hp-arkui-no-func-as-arg-for-reusable-component
@performance/hp-arkui-no-high-freq-log (Deprecated)
@performance/hp-arkui-no-state-var-access-in-loop
@performance/hp-arkui-no-stringify-in-lazyforeach-key-generator
@performance/hp-arkui-reduce-pan-gesture-distance
@performance/hp-arkui-remove-container-without-property
@performance/hp-arkui-remove-redundant-nest-container
@performance/hp-arkui-remove-redundant-state-var
@performance/hp-arkui-remove-unchanged-state-var
@performance/hp-arkui-replace-nested-reusable-component-by-builder
@performance/hp-arkui-set-cache-count-for-lazyforeach-grid
@performance/hp-arkui-suggest-cache-avplayer
@performance/hp-arkui-suggest-reuseid-for-if-else-reusable-component
@performance/hp-arkui-suggest-use-effectkit-blur
@performance/hp-arkui-suggest-use-get-anonymousid-async
@performance/hp-arkui-use-attributeUpdater-control-refresh-scope
@performance/hp-arkui-use-grid-layout-options
@performance/hp-arkui-use-id-in-get-resource-sync-api
@performance/hp-arkui-use-local-var-to-replace-state-var
@performance/hp-arkui-use-object-link-to-replace-prop
@performance/hp-arkui-use-onAnimationStart-for-swiper-preload
@performance/hp-arkui-use-reusable-component
@performance/hp-arkui-use-row-column-to-replace-flex
@performance/hp-arkui-use-scale-to-replace-attr-animateto
@performance/hp-arkui-use-taskpool-for-web-request
@performance/hp-arkui-use-transition-to-replace-animateto
@performance/hp-arkui-use-word-break-to-replace-zero-width-space
@performance/hp-arkui-wrap-waterflow-if-else-footer (Deprecated)
@performance/hp-performance-no-closures
@performance/hp-performance-no-dynamic-cls-func
@performance/lazyforeach-args-check (Deprecated)
@performance/lottie-animation-destroy-check
@performance/no-high-loaded-frame-rate-range
@performance/number-init-check
@performance/object-creation-check (Deprecated)
@performance/sparse-array-check
@performance/start-window-icon-check
@performance/timezone-interface-check
@performance/typed-array-check
@performance/waterflow-data-preload-check
@performance/multiple-associations-state-var-check
@performance/constant-property-referencing-check-in-loops
@performance/foreach-args-check
@previewer/mandatory-default-value-for-local-initialization
@previewer/no-page-method-on-preview-component
@previewer/no-unallowed-decorator-on-root-component
@cross-device-app-dev/color-value
@cross-device-app-dev/font-size-unit
@cross-device-app-dev/font-size
@cross-device-app-dev/grid-columns-span
@cross-device-app-dev/grid-span-value
@cross-device-app-dev/size-unit
@cross-device-app-dev/touch-target-size
@cross-device-app-dev/sidebar-navigation
@cross-device-app-dev/color-contrast
@hw-stylistic/array-bracket-spacing
@hw-stylistic/brace-style
@hw-stylistic/comma-spacing
@hw-stylistic/curly
@hw-stylistic/file-naming-convention
@hw-stylistic/indent
@hw-stylistic/keyword-spacing
@hw-stylistic/max-len
@hw-stylistic/no-multi-spaces
@hw-stylistic/no-tabs
@hw-stylistic/object-property-newline
@hw-stylistic/one-var-declaration-per-line
@hw-stylistic/operator-linebreak
@hw-stylistic/quotes
@hw-stylistic/semi-spacing
@hw-stylistic/space-before-blocks
@hw-stylistic/space-before-function-paren
@hw-stylistic/space-infix-ops
Maintenance Services
Rule Overview
In-App Touch Response Speed
In-App Touch Operation Completion Speed
In-App Swipe Operation Response Speed
In-App Swiping Smoothness
In-App Transition Smoothness
Dynamic Peak Memory Usage
Foreground Peak Memory Usage
Background Peak CPU Usage
Graphics Rendering Service Node Count Limit
DevEco Studio Parameters
Disabling Data Collecting
Obtaining Command Line Tools
codelinter
hstack
hvigorw
System Platform Requirements
ohpmrc
oh-package.json5
ohpm config
ohpm help
ohpm info
ohpm init
ohpm install
ohpm list
ohpm publish
ohpm uninstall
ohpm prepublish
ohpm unpublish
ohpm update
ohpm root
ohpm version
ohpm cache clean
ohpm run
ohpm --version
ohpm ping
ohpm clean
ohpm dist-tags
ohpm convert
Creating a Pipeline
Overview
Getting Started
Setting the Configuration File
Logs
ohpm-repo help
ohpm-repo install
ohpm-repo start
ohpm-repo restart
ohpm-repo stop
ohpm-repo --version
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
ohpm-repo export_pkginfo
ohpm-repo batch_download
ohpm-repo batch_publish
ohpm-repo export_userinfo
ohpm-repo import_userinfo
Single-Node Deployment
Multi-Instance Deployment
Frontend page
Personal Center Home Page
User Management
Repository Management
Authentication Management
Organization Management
Operation Log
System Settings
FAQs
Overview
Getting Started
Configuration File
Logs
ohpm-repo help
start 1.0.1
start 1.1.0
restart 1.0.1
restart 1.1.0
ohpm-repo stop
ohpm-repo --version
ohpm-repo encrypt_password
ohpm-repo pack
ohpm-repo restore
ohpm-repo deploy
ohpm-repo check_storage
ohpm-repo mirror_storage
Single-Node Deployment
Multi-Instance Deployment
Data Migration
Version Upgrade from 1.0.1 to 1.1.0
Version Upgrade from 1.0.1 to 2.X.X or 5.X.X
Version Upgrade from 1.1.0 to 2.X.X or 5.X.X
Version Upgrade from 2.X.X to 5.X.X
Storage Plug-in Configuration
Template File
Authentication Plug-in 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

Enabling Cloud Functions
Before you start development, make necessary preparations. When configuring the signing information, use the manual signing mode.

You need to enable Cloud Functions before using it. If you have enabled it, skip this step.
1. Sign in to AppGallery Connect and click My projects.
2. Click the project for which you need to enable Cloud Functions.
3. Go to Serverless > Cloud Functions. On the Cloud Functions page that is displayed, click Enable Now.
  
  If you have not set a data processing location, set it as prompted. Currently, you can enable multiple data processing locations for Cloud Functions.
4. If you have enabled multiple data processing locations, you can switch among these locations to facilitate management.