HarmonyOS : qu'est-ce que c'est, architecture du système et développement sur ArkUI

Qu'est-ce que HarmonyOS ?

HarmonyOS est un système d'exploitation distribué développé par Huawei et annoncé pour la première fois en 2019 en réponse à la restriction d'accès aux services Google sur les nouveaux appareils de l'entreprise. HarmonyOS est construit sur son propre micro-noyau, différent de Linux, et est conçu pour un fonctionnement transparent entre les appareils : smartphones, tablettes, montres connectées, téléviseurs, systèmes automobiles et appareils IoT.

Selon Huawei (Rapport sur l'écosystème HarmonyOS, 2026), le système est installé sur plus de 700 millions d'appareils, dont 300 millions de smartphones. Le marché chinois représente 95 % des installations. À partir de HarmonyOS 5.0 (NEXT, 2024), le système a complètement abandonné la compatibilité avec Android AOSP — toutes les applications doivent être écrites en ArkTS ou C++ avec ArkUI.

La caractéristique clé de HarmonyOS est son architecture distribuée : une application peut s'exécuter sur plusieurs appareils simultanément, déplaçant l'interface entre les écrans. Par exemple, un utilisateur lance la navigation sur un téléphone tandis que l'interface s'affiche sur l'écran de la voiture — sans recompilation ni code supplémentaire.

Historique des versions de HarmonyOS

HarmonyOS 1.0 (2019) — première version pour Smart Screen, pas pour les smartphones. HarmonyOS 2.0 (2021) — ouvert aux smartphones, tablettes et montres, prise en charge des applications AOSP. HarmonyOS 3.0 (2022) — architecture distribuée améliorée, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, performances améliorées. HarmonyOS NEXT (5.0, 2024) — abandon complet d'AOSP, applications natives HarmonyOS uniquement.

Architecture de HarmonyOS : micro-noyau distribué

L'architecture de HarmonyOS est fondamentalement différente d'Android et iOS. Au lieu du noyau monolithique Linux, HarmonyOS utilise son propre micro-noyau, implémentant un ensemble minimal de fonctions privilégiées : gestion de la mémoire, ordonnancement des processus et communication interprocessus. Tous les autres services s'exécutent dans l'espace utilisateur.

Micro-noyau et sécurité

Le micro-noyau de HarmonyOS comprend environ 10 000 lignes de code (le noyau Linux en compte plus de 20 millions). Une base de code plus petite signifie une surface d'attaque plus réduite. Le système utilise la vérification formelle — preuve mathématique de la correction du code du noyau. HarmonyOS prend en charge l'environnement d'exécution de confiance (TEE) au niveau matériel pour la biométrie, les paiements et les clés de chiffrement. La communication interprocessus est implémentée via IPC, 5 fois plus performant que Binder dans Android.

Quatre couches d'architecture

L'architecture de HarmonyOS se compose de quatre couches : Kernel Subsystem (micro-noyau + pilotes), System Service Layer (services système : données distribuées, système de fichiers, sécurité), Framework Layer (ArkUI, multimédia, téléphonie, services IA) et Application Layer (applications utilisateur). Chaque couche est isolée de la couche inférieure via IPC.

Système de fichiers distribué

HarmonyOS fournit un système de fichiers distribué (DFS) qui unifie le stockage de tous les appareils de l'utilisateur dans un seul espace virtuel. Une application accède aux fichiers par URI sans spécifier d'appareil — le système achemine la requête vers l'appareil où le fichier est physiquement stocké. DFS prend en charge le chiffrement de bout en bout et la réplication automatique des données fréquemment utilisées.

// Travail avec le système de fichiers distribué de HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Obtention d'un URI de fichier sur un appareil distribué
Uri GetDistributedFileUri(const std::string& localPath) {
    DistributedFileManager manager;
    auto deviceList = manager.GetOnlineDevices();

    for (const auto& device : deviceList) {
        Uri uri = manager.GetFileUri(device.deviceId, localPath);
        if (uri.IsValid()) {
            return uri;  // Fichier trouvé sur l'un des appareils
        }
    }
    return Uri::Empty();
}

// Lecture de données depuis un appareil distant
std::string ReadDistributedFile(const Uri& uri) {
    DistributedFile file(uri);
    if (!file.Open(OpenMode::READ_ONLY)) {
        return "";
    }

    char buffer[4096];
    size_t bytesRead = file.Read(buffer, sizeof(buffer));
    file.Close();

    return std::string(buffer, bytesRead);
}

Dans l'exemple, DistributedFileManager recherche un fichier sur tous les appareils en ligne de l'utilisateur et retourne un URI distribué. DistributedFile ouvre physiquement le fichier sur l'appareil distant via IPC, de manière transparente pour l'application. Le développeur n'a pas besoin de savoir où les données sont stockées — le système achemine la requête automatiquement.

ArkUI et ArkTS : développement d'interfaces

ArkUI est le framework UI déclaratif de HarmonyOS développé par Huawei. L'interface est décrite comme une hiérarchie de composants avec liaison de données réactive, similaire à SwiftUI (iOS) ou Jetpack Compose (Android). ArkTS est un langage de développement basé sur TypeScript avec typage statique supplémentaire et intégration avec ArkUI via les décorateurs @Component, @State, @Prop, @Link.

Concepts fondamentaux d'ArkTS

ArkTS étend TypeScript avec une harmonisation du framework UI : @Component — décorateur pour déclarer un composant UI, build() — méthode obligatoire retournant un arbre d'éléments UI, @State — variable réactive dont les changements redessinent automatiquement le composant, @Prop — propriété d'entrée du parent, @Link — liaison bidirectionnelle. Tous les composants ArkUI utilisent une syntaxe chaînée avec des modificateurs (.width, .height, .backgroundColor).

// ArkTS — écran de profil utilisateur sur ArkUI
@Component
struct ProfileScreen {
    @State userName: string = "Anna Petrova";
    @State avatarUrl: Resource = $r("media.avatar_default");
    @State isLoading: boolean = false;
    @Prop onEditClick: () => void;

    aboutToAppear(): void {
        this.loadUserData();
    }

    async loadUserData(): Promise<void> {
        this.isLoading = true;
        try {
            const data = await UserService.getProfile();
            this.userName = data.name;
            this.avatarUrl = data.avatarUrl;
        } catch (error) {
            console.error("Erreur de chargement", error);
        } finally {
            this.isLoading = false;
        }
    }

    build(): void {
        Column() {
            if (this.isLoading) {
                LoadingProgress()
                    .width('50%')
                    .height('50%');
            } else {
                Stack({ alignContent: Alignment.Center }) {
                    Image(this.avatarUrl)
                        .width('100%')
                        .height('100%')
                        .objectFit(ImageFit.Cover);

                    Column() {
                        Text(this.userName)
                            .fontSize('24fp')
                            .fontWeight(FontWeight.Bold)
                            .fontColor(Color.White);

                        Button("Modifier", {
                            type: ButtonType.Capsule,
                            stateEffect: true
                        })
                            .onClick(() => {
                                this.onEditClick();
                            })
                            .margin({ top: '12vp' });
                    }
                    .alignItems(HorizontalAlign.Center)
                    .width('100%');
                }
                .width('100%')
                .height('300vp');
            }
        }
        .padding('16vp')
        .width('100%')
        .height('100%');
    }
}

// Point d'entrée de l'application
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Ouvrir l'éditeur de profil");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

Le composant ProfileScreen en ArkTS démontre : @State pour les variables réactives, @Prop pour le callback d'entrée, Column/Stack/Text/Image/Button comme composants UI de base, chargement asynchrone de données via async/await. LoadingProgress s'affiche pendant le chargement. Toutes les tailles sont spécifiées en vp (pixels virtuels) — unités adaptatives similaires aux pt dans iOS ou dp dans Android.

Adaptation pour différents appareils

ArkUI prend en charge le design responsive via un système de points d'arrêt (xs, sm, md, lg, xl) correspondant à la largeur de l'écran. Les composants se réorganisent automatiquement lors du passage du téléphone à la tablette ou à la montre. GridRow et GridCol sont des conteneurs adaptatifs qui changent le nombre de colonnes en fonction du point d'arrêt. Unités de taille : vp (pixels virtuels), fp (pixels de police — s'adaptent aux réglages de police), lpx (pixels logiques pour les montres).

DevEco Studio et outils de développement

DevEco Studio est l'environnement de développement intégré (IDE) officiel pour HarmonyOS, basé sur IntelliJ IDEA Community Edition. Il comprend un éditeur de code avec prise en charge d'ArkTS et C++, un éditeur visuel ArkUI (glisser-déposer), un émulateur d'appareils HarmonyOS, Preview pour la visualisation instantanée de l'UI et Profiler pour l'analyse des performances.

Émulateur HarmonyOS

DevEco Studio inclut un émulateur basé sur QEMU, prenant en charge les smartphones (différentes tailles d'écran), tablettes, montres et téléviseurs. L'émulateur simule un environnement distribué : vous pouvez exécuter plusieurs appareils virtuels et tester l'interaction entre appareils. L'émulateur nécessite la virtualisation (Hyper-V sur Windows, KVM sur Linux).

Preview et Live Preview

ArkUI Preview est une fonction de visualisation instantanée de l'UI sans compilation ni démarrage de l'émulateur. Les modifications de code apparaissent dans Preview en 1 à 2 secondes. Tous les composants et animations standard sont pris en charge. Preview fonctionne avec différents points d'arrêt pour tester l'adaptabilité. Live Preview se connecte à un appareil réel via USB ou Wi-Fi pour des tests sur matériel réel.

HarmonyOS SDK et API

Le SDK HarmonyOS comprend : ArkUI (composants UI), Multimedia Kit (capture et lecture audio/vidéo), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (géolocalisation), Sensor Kit (capteurs), AI Kit (ML Kit avec inférence sur appareil sur NPU Huawei). Versions d'API : API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Initialisation de la caméra sur HarmonyOS via Multimedia Kit
import multimedia.CameraManager;
import multimedia.CameraInput;
import multimedia.PreviewOutput;

@Component
struct CameraView {
    @State isPreviewActive: boolean = false;
    cameraManager: CameraManager = CameraManager.getInstance();
    cameraInput?: CameraInput;
    previewOutput?: PreviewOutput;

    async startPreview(): Promise<void> {
        try {
            // Demande d'autorisation de caméra
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Obtention de la caméra (0 — arrière, 1 — avant)
            const camera = await this.cameraManager.getCamera(0);

            // Création de l'entrée caméra
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Démarrage de l'aperçu sur Surface (XComponent ArkUI)
            this.previewOutput = await this.cameraManager.createPreviewOutput({
                width: 1920,
                height: 1080
            });
            await this.previewOutput.start();
            this.isPreviewActive = true;
        } catch (error) {
            console.error("Camera error: " + error.message);
        }
    }

    async stopPreview(): Promise<void> {
        await this.previewOutput?.stop();
        await this.cameraInput?.close();
        this.isPreviewActive = false;
    }
}

Le composant CameraView démontre le travail avec Multimedia Kit : demande d'autorisation via Permissions.request, obtention de la caméra via CameraManager, création de CameraInput et PreviewOutput. ArkUI Surface (via XComponent) affiche le flux vidéo. Toutes les opérations sont asynchrones avec gestion des erreurs via try/catch.

Applications distribuées et inter-appareils

L'architecture distribuée de HarmonyOS est la principale différence par rapport aux concurrents. Une application peut être constituée de plusieurs services atomiques (Atomic Services), chacun s'exécutant sur l'appareil optimal. L'utilisateur commence une tâche sur un appareil et continue sur un autre sans perdre le contexte.

Atomic Services et Ability

Atomic Service est l'unité de déploiement minimale sur HarmonyOS. Chaque service implémente une ou plusieurs Ability (analogue à Activity dans Android). Page Ability — un écran avec UI, Service Ability — une tâche en arrière-plan, Data Ability — accès aux données. Une application peut déléguer une Ability à un autre appareil : par exemple, l'UI s'affiche sur la tablette tandis que le traitement IA s'exécute sur un téléphone avec NPU.

Gestion des données distribuées

Le système de gestion des données distribuées (DDM) synchronise l'état de l'application entre les appareils. DDM utilise des objets de données distribués — des objets réactifs qui se répliquent automatiquement sur tous les appareils de l'utilisateur. Les modifications de données sur un appareil sont instantanément répercutées sur tous les autres. DDM prend en charge le chiffrement et tient compte de la connexion réseau (Bluetooth, Wi-Fi, données cellulaires).

Super Device

Super Device — une fonctionnalité de HarmonyOS permettant d'unir jusqu'à 7 appareils Huawei dans un seul environnement informatique. L'utilisateur fait glisser les icônes d'appareils dans l'interface Super Device : les haut-parleurs deviennent une sortie audio, la tablette devient un deuxième écran, la montre devient un moniteur de fréquence cardiaque pour une application de fitness sur le téléphone. Tous les appareils se synchronisent via un bus distribué (Distributed Bus) avec une latence inférieure à 5 ms.

AppGallery et publication d'applications

Huawei AppGallery est la boutique officielle d'applications HarmonyOS, la troisième plus grande au monde après Google Play et App Store. Selon Huawei (2026), AppGallery compte plus de 580 millions d'utilisateurs actifs mensuels. L'inscription du développeur est gratuite pour les particuliers (contrairement aux 99 $ d'Apple).

Processus de publication

Le développeur compile l'application dans DevEco Studio (format .hap — HarmonyOS Ability Package). Publication via AppGallery Connect : télécharger le fichier HAP, remplir la description (nom, icône, captures d'écran), configurer le modèle de tarification. Le temps de modération moyen est de 1 à 3 jours ouvrables. Huawei vérifie la sécurité (analyse statique), la compatibilité API et la conformité aux politiques.

Monétisation

AppGallery prend en charge : les applications payantes (commission Huawei 15-30 %), les abonnements (commission de 15 %), la publicité via Huawei Ads Kit et les achats intégrés via IAP Kit. Huawei Pay est une passerelle de paiement pour le marché chinois prenant en charge Alipay et WeChat Pay. Les développeurs internationaux reçoivent les paiements via PayPal ou virement bancaire.

Huawei Mobile Services (HMS)

HMS Core est un ensemble de services remplaçant Google Play Services sur les appareils Huawei sans Google. Inclut : Push Kit (notifications push), Map Kit (cartes avec navigation), Location Kit (géolocalisation), Ads Kit (publicité), Analytics Kit (analyses), Account Kit (autorisation via Huawei ID). HMS Core est disponible sur les appareils avec HarmonyOS et sur les appareils Android Huawei (via AppGallery).