HarmonyOS: wat het is, systeemarchitectuur en ontwikkeling op ArkUI

Wat is HarmonyOS?

HarmonyOS is een gedistribueerd besturingssysteem ontwikkeld door Huawei en voor het eerst aangekondigd in 2019 als reactie op de beperking van toegang tot Google-diensten op nieuwe apparaten van het bedrijf. HarmonyOS is gebouwd op een eigen microkernel, anders dan Linux, en is ontworpen voor naadloze werking tussen apparaten: smartphones, tablets, smartwatches, televisies, autosystemen en IoT-apparaten.

Volgens Huawei (HarmonyOS Ecosystem Report, 2026) is het systeem geïnstalleerd op meer dan 700 miljoen apparaten, waaronder 300 miljoen smartphones. De Chinese markt is goed voor 95% van de installaties. Vanaf HarmonyOS 5.0 (NEXT, 2024) heeft het systeem de compatibiliteit met Android AOSP volledig opgegeven — alle applicaties moeten worden geschreven in ArkTS of C++ met ArkUI.

Het belangrijkste kenmerk van HarmonyOS is de gedistribueerde architectuur: een applicatie kan tegelijkertijd op meerdere apparaten worden uitgevoerd en de interface tussen schermen verplaatsen. Een gebruiker start bijvoorbeeld navigatie op een telefoon terwijl de interface wordt weergegeven op het autoscherm — zonder hercompilatie of extra code.

Versiegeschiedenis van HarmonyOS

HarmonyOS 1.0 (2019) — eerste versie voor Smart Screen, niet voor smartphones. HarmonyOS 2.0 (2021) — geopend voor smartphones, tablets en horloges, ondersteuning voor AOSP-applicaties. HarmonyOS 3.0 (2022) — verbeterde gedistribueerde architectuur, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, verbeterde prestaties. HarmonyOS NEXT (5.0, 2024) — volledig verlaten van AOSP, alleen native HarmonyOS-applicaties.

HarmonyOS-architectuur: gedistribueerde microkernel

De HarmonyOS-architectuur verschilt fundamenteel van Android en iOS. In plaats van de monolithische Linux-kernel gebruikt HarmonyOS een eigen microkernel die een minimale set bevoorrechte functies implementeert: geheugenbeheer, procesplanning en interprocescommunicatie. Alle andere services draaien in de gebruikersruimte.

Microkernel en beveiliging

De HarmonyOS-microkernel omvat ongeveer 10.000 regels code (de Linux-kernel heeft meer dan 20 miljoen). Een kleinere codebasis betekent een kleiner aanvalsoppervlak. Het systeem gebruikt formele verificatie — wiskundig bewijs van de juistheid van de kernelcode. HarmonyOS ondersteunt Trusted Execution Environment (TEE) op hardwareniveau voor biometrie, betalingen en coderingssleutels. Interprocescommunicatie wordt geïmplementeerd via IPC, 5 keer beter presterend dan Binder in Android.

Vier architectuurlagen

De HarmonyOS-architectuur bestaat uit vier lagen: Kernel Subsystem (microkernel + stuurprogramma's), System Service Layer (systeemdiensten: gedistribueerde gegevens, bestandssysteem, beveiliging), Framework Layer (ArkUI, multimedia, telefonie, AI-diensten) en Application Layer (gebruikerstoepassingen). Elke laag is via IPC geïsoleerd van de onderliggende laag.

Gedistribueerd bestandssysteem

HarmonyOS biedt een gedistribueerd bestandssysteem (DFS) dat de opslag van alle gebruikersapparaten verenigt in één virtuele ruimte. Een applicatie heeft toegang tot bestanden via URI zonder een apparaat op te geven — het systeem routeert de aanvraag naar het apparaat waar het bestand fysiek is opgeslagen. DFS ondersteunt end-to-end-codering en automatische replicatie van veelgebruikte gegevens.

// Werken met het gedistribueerde bestandssysteem van HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Een bestands-URI ophalen op een gedistribueerd apparaat
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;  // Bestand gevonden op een van de apparaten
        }
    }
    return Uri::Empty();
}

// Gegevens lezen van een extern apparaat
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);
}

In het voorbeeld zoekt DistributedFileManager een bestand op alle online apparaten van de gebruiker en retourneert een gedistribueerde URI. DistributedFile opent het bestand fysiek op het externe apparaat via IPC, transparant voor de applicatie. De ontwikkelaar hoeft niet te weten waar de gegevens zijn opgeslagen — het systeem routeert de aanvraag automatisch.

ArkUI en ArkTS: interface-ontwikkeling

ArkUI is het declaratieve UI-framework van HarmonyOS ontwikkeld door Huawei. De interface wordt beschreven als een hiërarchie van componenten met reactieve gegevensbinding, vergelijkbaar met SwiftUI (iOS) of Jetpack Compose (Android). ArkTS is een ontwikkeltaal op basis van TypeScript met extra statische typering en integratie met ArkUI via de decorateurs @Component, @State, @Prop, @Link.

Concepten van ArkTS

ArkTS breidt TypeScript uit door harmonisatie met het UI-framework: @Component — een decorateur voor het declareren van een UI-component, build() — een verplichte methode die een boom van UI-elementen retourneert, @State — een reactieve variabele waarvan wijzigingen de component automatisch opnieuw tekenen, @Prop — een invoereigenschap van de ouder, @Link — bidirectionele binding. Alle ArkUI-componenten gebruiken een ketensyntaxis met modifiers (.width, .height, .backgroundColor).

// ArkTS — gebruikersprofielscherm op 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("Laadfout", 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("Bewerken", {
                            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%');
    }
}

// Toepassingsingangspunt
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Profieleditor openen");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

De ProfileScreen-component in ArkTS demonstreert: @State voor reactieve variabelen, @Prop voor invoer-callback, Column/Stack/Text/Image/Button als basis UI-componenten, asynchroon laden van gegevens via async/await. LoadingProgress wordt weergegeven tijdens het laden. Alle afmetingen worden opgegeven in vp (virtuele pixels) — adaptieve eenheden vergelijkbaar met pt in iOS of dp in Android.

Aanpassing voor verschillende apparaten

ArkUI ondersteunt responsief ontwerp via een systeem van Breakpoints (xs, sm, md, lg, xl) die overeenkomen met de schermbreedte. Componenten worden automatisch herschikt bij overschakeling van telefoon naar tablet of horloge. GridRow en GridCol zijn adaptieve containers die het aantal kolommen wijzigen op basis van het breakpoint. Maateenheden: vp (virtuele pixels), fp (lettertypepixels — schalen met lettertype-instellingen), lpx (logische pixels voor horloges).

DevEco Studio en ontwikkelingstools

DevEco Studio is de officiële geïntegreerde ontwikkelomgeving (IDE) voor HarmonyOS, gebaseerd op IntelliJ IDEA Community Edition. Het bevat een code-editor met ondersteuning voor ArkTS en C++, een visuele ArkUI-editor (drag-and-drop), een HarmonyOS-apparaatemulator, Preview voor directe UI-weergave en Profiler voor prestatieanalyse.

HarmonyOS-emulator

DevEco Studio bevat een emulator op basis van QEMU, die smartphones (verschillende schermformaten), tablets, horloges en televisies ondersteunt. De emulator simuleert een gedistribueerde omgeving: u kunt meerdere virtuele apparaten uitvoeren en cross-device-interactie testen. De emulator vereist virtualisatie (Hyper-V op Windows, KVM op Linux).

Preview en Live Preview

ArkUI Preview is een functie voor directe UI-weergave zonder bouwen of starten van de emulator. Codewijzigingen verschijnen binnen 1-2 seconden in Preview. Alle standaardcomponenten en animaties worden ondersteund. Preview werkt met verschillende breakpoints om de aanpasbaarheid te testen. Live Preview maakt via USB of Wi-Fi verbinding met een echt apparaat voor testen op hardware.

HarmonyOS SDK en API

De HarmonyOS SDK bevat: ArkUI (UI-componenten), Multimedia Kit (audio/video-opname en -weergave), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolocatie), Sensor Kit (sensoren), AI Kit (ML Kit met on-device inferentie op Huawei NPU). API-versies: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Camera initialiseren op 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 {
            // Cameravergunning aanvragen
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Camera verkrijgen (0 — achter, 1 — voor)
            const camera = await this.cameraManager.getCamera(0);

            // Camera-ingang maken
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Preview starten op Surface (ArkUI XComponent)
            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;
    }
}

De CameraView-component demonstreert werken met Multimedia Kit: toestemming aanvragen via Permissions.request, camera verkrijgen via CameraManager, CameraInput en PreviewOutput maken. ArkUI Surface (via XComponent) geeft de videostream weer. Alle bewerkingen zijn asynchroon met foutafhandeling via try/catch.

Gedistribueerde applicaties en cross-device

De gedistribueerde architectuur van HarmonyOS is het belangrijkste verschil met concurrenten. Een applicatie kan bestaan uit meerdere atomaire services (Atomic Services), die elk op het optimale apparaat worden uitgevoerd. De gebruiker begint een taak op het ene apparaat en gaat verder op een ander zonder contextverlies.

Atomic Services en Ability

Atomic Service is de minimale implementatie-eenheid op HarmonyOS. Elke service implementeert een of meer Ability (analoog aan Activity in Android). Page Ability — een scherm met UI, Service Ability — een achtergrondtaak, Data Ability — gegevenstoegang. Een applicatie kan een Ability aan een ander apparaat delegeren: bijvoorbeeld de UI wordt op de tablet weergegeven terwijl AI-verwerking op een telefoon met NPU wordt uitgevoerd.

Gedistribueerd Gegevensbeheer

Het systeem voor gedistribueerd gegevensbeheer (DDM) synchroniseert de applicatiestatus tussen apparaten. DDM gebruikt gedistribueerde gegevensobjecten — reactieve objecten die automatisch worden gerepliceerd naar alle gebruikersapparaten. Gegevenswijzigingen op het ene apparaat worden onmiddellijk weerspiegeld op alle andere. DDM ondersteunt codering en houdt rekening met de netwerkverbinding (Bluetooth, Wi-Fi, mobiele gegevens).

Super Device

Super Device — een HarmonyOS-functie waarmee u tot 7 Huawei-apparaten kunt verenigen in één computeromgeving. De gebruiker sleept apparaatpictogrammen in de Super Device-interface: luidsprekers worden audio-uitvoer, de tablet wordt een tweede scherm, het horloge wordt een hartslagmeter voor een fitness-app op de telefoon. Alle apparaten synchroniseren via een gedistribueerde bus (Distributed Bus) met een latentie van minder dan 5 ms.

AppGallery en applicatiepublicatie

Huawei AppGallery is de officiële appstore van HarmonyOS, de derde grootste ter wereld na Google Play en App Store. Volgens Huawei (2026) heeft AppGallery meer dan 580 miljoen maandelijkse actieve gebruikers. Ontwikkelaarsregistratie is gratis voor particulieren (in tegenstelling tot de $99 van Apple).

Publicatieproces

De ontwikkelaar bouwt de applicatie in DevEco Studio (.hap-formaat — HarmonyOS Ability Package). Publicatie via AppGallery Connect: HAP-bestand uploaden, beschrijving invullen (naam, pictogram, schermafbeeldingen), prijsmodel configureren. De gemiddelde moderatietijd is 1-3 werkdagen. Huawei controleert beveiliging (statische analyse), API-compatibiliteit en naleving van het beleid.

Monetisering

AppGallery ondersteunt: betaalde applicaties (Huawei-commissie 15-30%), abonnementen (15% commissie), advertenties via Huawei Ads Kit en in-app aankopen via IAP Kit. Huawei Pay is een betalingsgateway voor de Chinese markt die Alipay en WeChat Pay ondersteunt. Internationale ontwikkelaars ontvangen betalingen via PayPal of bankoverschrijving.

Huawei Mobile Services (HMS)

HMS Core is een set services die Google Play Services vervangen op Huawei-apparaten zonder Google. Bevat: Push Kit (pushmeldingen), Map Kit (kaarten met navigatie), Location Kit (geolocatie), Ads Kit (reclame), Analytics Kit (analyse), Account Kit (autorisatie via Huawei ID). HMS Core is beschikbaar op apparaten met HarmonyOS en op Huawei Android-apparaten (via AppGallery).