HarmonyOS: vad det är, systemarkitektur och utveckling på ArkUI

Vad är HarmonyOS?

HarmonyOS är ett distribuerat operativsystem utvecklat av Huawei och först tillkännagivet 2019 som svar på begränsad tillgång till Google-tjänster på företagets nya enheter. HarmonyOS är byggt på en egen mikrokärna, skild från Linux, och är utformat för sömlös drift mellan enheter: smartphones, surfplattor, smartklockor, tv-apparater, fordonssystem och IoT-enheter.

Enligt Huawei (HarmonyOS Ecosystem Report, 2026) är systemet installerat på över 700 miljoner enheter, inklusive 300 miljoner smartphones. Den kinesiska marknaden står för 95% av installationerna. Från och med HarmonyOS 5.0 (NEXT, 2024) har systemet helt övergett Android AOSP-kompatibilitet — alla applikationer måste skrivas i ArkTS eller C++ med ArkUI.

Nyckelfunktionen i HarmonyOS är dess distribuerade arkitektur: en applikation kan köras på flera enheter samtidigt och flytta gränssnittet mellan skärmar. Till exempel startar en användare navigering på en telefon medan gränssnittet visas på bilens skärm — utan omkompilering eller extra kod.

HarmonyOS versionshistorik

HarmonyOS 1.0 (2019) — första versionen för Smart Screen, inte för smartphones. HarmonyOS 2.0 (2021) — öppnad för smartphones, surfplattor och klockor, stöd för AOSP-applikationer. HarmonyOS 3.0 (2022) — förbättrad distribuerad arkitektur, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, förbättrad prestanda. HarmonyOS NEXT (5.0, 2024) — fullständigt övergivande av AOSP, endast inbyggda HarmonyOS-applikationer.

HarmonyOS-arkitektur: distribuerad mikrokärna

HarmonyOS arkitektur skiljer sig fundamentalt från Android och iOS. Istället för den monolitiska Linux-kärnan använder HarmonyOS en egen mikrokärna som implementerar en minimal uppsättning privilegierade funktioner: minneshantering, processplanering och interprocesskommunikation. Alla andra tjänster körs i användarutrymmet.

Mikrokärna och säkerhet

HarmonyOS-mikrokärnan omfattar cirka 10 000 rader kod (Linux-kärnan har över 20 miljoner). En mindre kodbas innebär en mindre attackyta. Systemet använder formell verifiering — matematiskt bevis på korrektheten av kärnkoden. HarmonyOS stöder Trusted Execution Environment (TEE) på hårdvarunivå för biometri, betalningar och krypteringsnycklar. Interprocesskommunikation implementeras via IPC, 5 gånger mer prestanda än Binder i Android.

Fyra arkitekturlager

HarmonyOS-arkitekturen består av fyra lager: Kernel Subsystem (mikrokärna + drivrutiner), System Service Layer (systemtjänster: distribuerad data, filsystem, säkerhet), Framework Layer (ArkUI, multimedia, telefoni, AI-tjänster) och Application Layer (användarapplikationer). Varje lager är isolerat från underliggande lager via IPC.

Distribuerat filsystem

HarmonyOS tillhandahåller ett distribuerat filsystem (DFS) som förenar lagringen av alla användarens enheter i ett enda virtuellt utrymme. En applikation får åtkomst till filer via URI utan att ange en enhet — systemet dirigerar begäran till enheten där filen fysiskt lagras. DFS stöder end-to-end-kryptering och automatisk replikering av ofta använda data.

// Arbeta med HarmonyOS distribuerade filsystem
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Hämta en fil-URI på en distribuerad enhet
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;  // Fil hittades på en av enheterna
        }
    }
    return Uri::Empty();
}

// Läsa data från en fjärrenhet
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);
}

I exemplet söker DistributedFileManager efter en fil på alla användarens online-enheter och returnerar en distribuerad URI. DistributedFile öppnar filen fysiskt på fjärrenheten via IPC, transparent för applikationen. Utvecklaren behöver inte veta var data lagras — systemet dirigerar begäran automatiskt.

ArkUI och ArkTS: gränssnittsutveckling

ArkUI är HarmonyOS deklarativa UI-ramverk utvecklat av Huawei. Gränssnittet beskrivs som en hierarki av komponenter med reaktiv databindning, liknande SwiftUI (iOS) eller Jetpack Compose (Android). ArkTS är ett utvecklingsspråk baserat på TypeScript med ytterligare statisk typning och integration med ArkUI via dekoratörerna @Component, @State, @Prop, @Link.

Grundläggande ArkTS-koncept

ArkTS utökar TypeScript genom harmonisering med UI-ramverket: @Component — en dekoratör för att deklarera en UI-komponent, build() — en obligatorisk metod som returnerar ett träd av UI-element, @State — en reaktiv variabel vars förändringar automatiskt ritar om komponenten, @Prop — en ingångsegenskap från föräldern, @Link — tvåvägsbindning. Alla ArkUI-komponenter använder kedjesyntax med modifierare (.width, .height, .backgroundColor).

// ArkTS — användarprofilskärm på 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("Laddningsfel", 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("Redigera", {
                            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%');
    }
}

// Applikationsingångspunkt
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Öppna profileditor");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

ProfileScreen-komponenten i ArkTS demonstrerar: @State för reaktiva variabler, @Prop för ingångs-callback, Column/Stack/Text/Image/Button som grundläggande UI-komponenter, asynkron dataladdning via async/await. LoadingProgress visas under laddning. Alla storlekar anges i vp (virtuella pixlar) — adaptiva enheter liknande pt i iOS eller dp i Android.

Anpassning för olika enheter

ArkUI stöder responsiv design genom ett system av brytpunkter (xs, sm, md, lg, xl) som motsvarar skärmbredd. Komponenter omorganiseras automatiskt vid växling från telefon till surfplatta eller klocka. GridRow och GridCol är adaptiva containrar som ändrar antalet kolumner beroende på brytpunkt. Storleksenheter: vp (virtuella pixlar), fp (teckensnittspixlar — skalas med teckensnittsinställningar), lpx (logiska pixlar för klockor).

DevEco Studio och utvecklingsverktyg

DevEco Studio är den officiella integrerade utvecklingsmiljön (IDE) för HarmonyOS, baserad på IntelliJ IDEA Community Edition. Den innehåller en kodredigerare med stöd för ArkTS och C++, en visuell ArkUI-redigerare (drag-and-drop), en HarmonyOS-enhetsemulator, Preview för omedelbar UI-visning och Profiler för prestandaanalys.

HarmonyOS-emulator

DevEco Studio innehåller en emulator baserad på QEMU, som stöder smartphones (olika skärmstorlekar), surfplattor, klockor och TV-apparater. Emulatorn simulerar en distribuerad miljö: du kan köra flera virtuella enheter och testa interaktion mellan enheter. Emulatorn kräver virtualisering (Hyper-V på Windows, KVM på Linux).

Preview och Live Preview

ArkUI Preview är en funktion för omedelbar UI-visning utan att bygga eller starta emulatorn. Kodändringar visas i Preview inom 1-2 sekunder. Alla standardkomponenter och animationer stöds. Preview fungerar med olika brytpunkter för att testa anpassningsförmåga. Live Preview ansluter till en verklig enhet via USB eller Wi-Fi för testning på hårdvara.

HarmonyOS SDK och API

HarmonyOS SDK innehåller: ArkUI (UI-komponenter), Multimedia Kit (ljud/videoinspelning och uppspelning), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolokalisering), Sensor Kit (sensorer), AI Kit (ML Kit med inferens på enheten på Huawei NPU). API-versioner: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Initiera kamera på 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 {
            // Begär kameraåtkomst
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Hämta kamera (0 — bakre, 1 — främre)
            const camera = await this.cameraManager.getCamera(0);

            // Skapa kamerainmatning
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Starta förhandsvisning på 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;
    }
}

CameraView-komponenten demonstrerar arbete med Multimedia Kit: begära tillstånd via Permissions.request, hämta kamera via CameraManager, skapa CameraInput och PreviewOutput. ArkUI Surface (via XComponent) visar videoströmmen. Alla operationer är asynkrona med felhantering via try/catch.

Distribuerade applikationer och mellan enheter

Distribuerad arkitektur hos HarmonyOS är den största skillnaden från konkurrenterna. En applikation kan bestå av flera atomära tjänster (Atomic Services), som var och en körs på den optimala enheten. Användaren påbörjar en uppgift på en enhet och fortsätter på en annan utan att förlora kontext.

Atomic Services och Ability

Atomic Service är den minsta distributionsenheten på HarmonyOS. Varje tjänst implementerar en eller flera Ability (analogt med Activity i Android). Page Ability — en skärm med UI, Service Ability — en bakgrundsuppgift, Data Ability — dataåtkomst. En applikation kan delegera en Ability till en annan enhet: till exempel visas UI på surfplattan medan AI-bearbetning körs på en telefon med NPU.

Distribuerad Datahantering

Systemet för distribuerad datahantering (DDM) synkroniserar applikationstillståndet mellan enheter. DDM använder distribuerade dataobjekt — reaktiva objekt som automatiskt replikeras till alla användarens enheter. Dataändringar på en enhet återspeglas omedelbart på alla andra. DDM stöder kryptering och tar hänsyn till nätverksanslutning (Bluetooth, Wi-Fi, mobildata).

Super Device

Super Device — en HarmonyOS-funktion som gör det möjligt att förena upp till 7 Huawei-enheter i en enda datormiljö. Användaren drar enhetsikoner i Super Device-gränssnittet: högtalare blir ljudutgång, surfplattan blir en andra skärm, klockan blir en pulsmätare för en fitnessapp på telefonen. Alla enheter synkroniseras via en distribuerad buss (Distributed Bus) med en latens på mindre än 5 ms.

AppGallery och applikationspublicering

Huawei AppGallery är den officiella appbutiken för HarmonyOS, den tredje största i världen efter Google Play och App Store. Enligt Huawei (2026) har AppGallery över 580 miljoner månatliga aktiva användare. Utvecklarregistrering är gratis för privatpersoner (till skillnad från Apples $99).

Publiceringsprocess

Utvecklaren bygger applikationen i DevEco Studio (.hap-format — HarmonyOS Ability Package). Publicering via AppGallery Connect: ladda upp HAP-fil, fyll i beskrivning (namn, ikon, skärmbilder), konfigurera prismodell. Genomsnittlig modereringstid är 1-3 arbetsdagar. Huawei kontrollerar säkerhet (statisk analys), API-kompatibilitet och policyefterlevnad.

Monetarisering

AppGallery stöder: betalapplikationer (Huawei-provision 15-30%), prenumerationer (15% provision), annonsering via Huawei Ads Kit och köp i appen via IAP Kit. Huawei Pay är en betalningsgateway för den kinesiska marknaden som stöder Alipay och WeChat Pay. Internationella utvecklare får betalningar via PayPal eller banköverföring.

Huawei Mobile Services (HMS)

HMS Core är en uppsättning tjänster som ersätter Google Play Services på Huawei-enheter utan Google. Innehåller: Push Kit (push-meddelanden), Map Kit (kartor med navigering), Location Kit (geolokalisering), Ads Kit (annonsering), Analytics Kit (analys), Account Kit (auktorisering via Huawei ID). HMS Core finns på enheter med HarmonyOS och på Huawei Android-enheter (via AppGallery).