HarmonyOS: co to je, architektura systému a vývoj na ArkUI

Co je HarmonyOS?

HarmonyOS je distribuovaný operační systém vyvinutý společností Huawei a poprvé oznámený v roce 2019 jako reakce na omezení přístupu ke službám Google na nových zařízeních společnosti. HarmonyOS je postaven na vlastním mikrojádře, odlišném od Linuxu, a je navržen pro bezproblémový provoz mezi zařízeními: chytré telefony, tablety, chytré hodinky, televize, automobilové systémy a zařízení IoT.

Podle Huawei (Zpráva o ekosystému HarmonyOS, 2026) je systém nainstalován na více než 700 milionech zařízení, včetně 300 milionů chytrých telefonů. Čínský trh tvoří 95% instalací. Počínaje HarmonyOS 5.0 (NEXT, 2024) systém zcela opustil kompatibilitu s Android AOSP — všechny aplikace musí být napsány v ArkTS nebo C++ s použitím ArkUI.

Klíčovou vlastností HarmonyOS je jeho distribuovaná architektura: aplikace může běžet na více zařízeních současně a přesouvat rozhraní mezi obrazovkami. Například uživatel spustí navigaci na telefonu, zatímco rozhraní se zobrazí na obrazovce auta — bez překompilování nebo dodatečného kódu.

Historie verzí HarmonyOS

HarmonyOS 1.0 (2019) — první verze pro Smart Screen, ne pro chytré telefony. HarmonyOS 2.0 (2021) — otevřena pro chytré telefony, tablety a hodinky, podpora aplikací AOSP. HarmonyOS 3.0 (2022) — vylepšená distribuovaná architektura, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, vylepšený výkon. HarmonyOS NEXT (5.0, 2024) — úplné opuštění AOSP, pouze nativní aplikace HarmonyOS.

Architektura HarmonyOS: distribuované mikrojádro

Architektura HarmonyOS se zásadně liší od Androidu a iOS. Místo monolitického jádra Linux používá HarmonyOS vlastní mikrojádro, které implementuje minimální sadu privilegovaných funkcí: správu paměti, plánování procesů a meziprocesovou komunikaci. Všechny ostatní služby běží v uživatelském prostoru.

Mikrojádro a bezpečnost

Mikrojádro HarmonyOS čítá přibližně 10 000 řádků kódu (jádro Linux má více než 20 milionů). Menší kódová základna znamená menší útoknou plochu. Systém používá formální verifikaci — matematický důkaz správnosti kódu jádra. HarmonyOS podporuje Trusted Execution Environment (TEE) na hardwarové úrovni pro biometrii, platby a šifrovací klíče. Meziprocesová komunikace je implementována pomocí IPC, 5krát výkonnějšího než Binder v Androidu.

Čtyři vrstvy architektury

Architektura HarmonyOS se skládá ze čtyř vrstev: Kernel Subsystem (mikrojádro + ovladače), System Service Layer (systémové služby: distribuovaná data, souborový systém, bezpečnost), Framework Layer (ArkUI, multimédia, telefonie, AI služby) a Application Layer (uživatelské aplikace). Každá vrstva je izolována od podkladové vrstvy pomocí IPC.

Distribuovaný souborový systém

HarmonyOS poskytuje distribuovaný souborový systém (DFS), který sjednocuje úložiště všech zařízení uživatele do jediného virtuálního prostoru. Aplikace přistupuje k souborům pomocí URI bez určení zařízení — systém směruje požadavek na zařízení, kde je soubor fyzicky uložen. DFS podporuje šifrování end-to-end a automatickou replikaci často používaných dat.

// Práce s distribuovaným souborovým systémem HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Získání URI souboru na distribuovaném zařízení
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;  // Soubor nalezen na jednom ze zařízení
        }
    }
    return Uri::Empty();
}

// Čtení dat ze vzdáleného zařízení
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);
}

V příkladu DistributedFileManager vyhledá soubor na všech online zařízeních uživatele a vrátí distribuovaný URI. DistributedFile fyzicky otevře soubor na vzdáleném zařízení přes IPC, transparentně pro aplikaci. Vývojář nepotřebuje vědět, kde jsou data uložena — systém automaticky směruje požadavek.

ArkUI a ArkTS: vývoj rozhraní

ArkUI je deklarativní UI framework HarmonyOS vyvinutý společností Huawei. Rozhraní je popsáno jako hierarchie komponent s reaktivním propojováním dat, podobně jako SwiftUI (iOS) nebo Jetpack Compose (Android). ArkTS je vývojový jazyk založený na TypeScript s dodatečným statickým typováním a integrací s ArkUI pomocí dekorátorů @Component, @State, @Prop, @Link.

Základní koncepty ArkTS

ArkTS rozšiřuje TypeScript harmonizací s UI frameworkem: @Component — dekorátor pro deklarování UI komponenty, build() — povinná metoda vracející strom UI prvků, @State — reaktivní proměnná, jejíž změny automaticky překreslí komponentu, @Prop — vstupní vlastnost od rodiče, @Link — obousměrné propojení. Všechny komponenty ArkUI používají řetězovou syntaxi s modifikátory (.width, .height, .backgroundColor).

// ArkTS — obrazovka profilu uživatele na 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("Chyba načítání", 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("Upravit", {
                            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%');
    }
}

// Vstupní bod aplikace
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Otevřít editor profilu");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

Komponenta ProfileScreen v ArkTS demonstruje: @State pro reaktivní proměnné, @Prop pro vstupní callback, Column/Stack/Text/Image/Button jako základní UI komponenty, asynchronní načítání dat pomocí async/await. LoadingProgress se zobrazí během načítání. Všechny velikosti jsou zadány ve vp (virtuálních pixelech) — adaptivních jednotkách podobných pt v iOS nebo dp v Androidu.

Adaptace pro různá zařízení

ArkUI podporuje responzivní design prostřednictvím systému Breakpointů (xs, sm, md, lg, xl) odpovídajících šířce obrazovky. Komponenty se automaticky přeskupí při přechodu z telefonu na tablet nebo hodinky. GridRow a GridCol jsou adaptivní kontejnery, které mění počet sloupců v závislosti na breakpointu. Jednotky velikosti: vp (virtuální pixely), fp (pixely písma — škálují se s nastavením písma), lpx (logické pixely pro hodinky).

DevEco Studio a vývojové nástroje

DevEco Studio je oficiální integrované vývojové prostředí (IDE) pro HarmonyOS, založené na IntelliJ IDEA Community Edition. Zahrnuje editor kódu s podporou ArkTS a C++, vizuální editor ArkUI (drag-and-drop), emulátor zařízení HarmonyOS, Preview pro okamžité zobrazení UI a Profiler pro analýzu výkonu.

Emulátor HarmonyOS

DevEco Studio obsahuje emulátor založený na QEMU, podporující chytré telefony (různé velikosti obrazovky), tablety, hodinky a televize. Emulátor simuluje distribuované prostředí: můžete spustit více virtuálních zařízení a testovat interakci napříč zařízeními. Emulátor vyžaduje virtualizaci (Hyper-V na Windows, KVM na Linuxu).

Preview a Live Preview

ArkUI Preview je funkce okamžitého zobrazení UI bez sestavení nebo spuštění emulátoru. Změny kódu se zobrazí v Preview během 1-2 sekund. Všechny standardní komponenty a animace jsou podporovány. Preview pracuje s různými breakpointy pro testování přizpůsobivosti. Live Preview se připojí k reálnému zařízení přes USB nebo Wi-Fi pro testování na hardwaru.

HarmonyOS SDK a API

HarmonyOS SDK zahrnuje: ArkUI (UI komponenty), Multimedia Kit (zachycení a přehrávání audio/videa), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolokace), Sensor Kit (senzory), AI Kit (ML Kit s inferencí na zařízení na NPU Huawei). Verze API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Inicializace kamery na HarmonyOS přes 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 {
            // Žádost o povolení kamery
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Získání kamery (0 — zadní, 1 — přední)
            const camera = await this.cameraManager.getCamera(0);

            // Vytvoření vstupu kamery
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Spuštění náhledu na 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;
    }
}

Komponenta CameraView demonstruje práci s Multimedia Kit: žádost o povolení přes Permissions.request, získání kamery přes CameraManager, vytvoření CameraInput a PreviewOutput. ArkUI Surface (přes XComponent) zobrazuje video stream. Všechny operace jsou asynchronní s ošetřením chyb pomocí try/catch.

Distribuované aplikace a napříč zařízeními

Distribuovaná architektura HarmonyOS je hlavní rozdíl oproti konkurentům. Aplikace může sestávat z několika atomických služeb (Atomic Services), z nichž každá běží na optimálním zařízení. Uživatel zahájí úkol na jednom zařízení a pokračuje na jiném bez ztráty kontextu.

Atomic Services a Ability

Atomic Service je minimální jednotka nasazení na HarmonyOS. Každá služba implementuje jednu nebo více Ability (analogie Activity v Androidu). Page Ability — obrazovka s UI, Service Ability — úloha na pozadí, Data Ability — přístup k datům. Aplikace může delegovat Ability na jiné zařízení: například UI se zobrazí na tabletu, zatímco AI zpracování běží na telefonu s NPU.

Správa distribuovaných dat

Systém správy distribuovaných dat (DDM) synchronizuje stav aplikace mezi zařízeními. DDM používá distribuované datové objekty — reaktivní objekty, které se automaticky replikují na všechna zařízení uživatele. Změna dat na jednom zařízení se okamžitě projeví na všech ostatních. DDM podporuje šifrování a zohledňuje síťové připojení (Bluetooth, Wi-Fi, mobilní data).

Super Device

Super Device — funkce HarmonyOS, která umožňuje sjednotit až 7 zařízení Huawei do jediného výpočetního prostředí. Uživatel přetahuje ikony zařízení v rozhraní Super Device: reproduktory se stanou audio výstupem, tablet druhým displejem, hodinky měřičem tepu pro fitness aplikaci na telefonu. Všechna zařízení se synchronizují prostřednictvím distribuované sběrnice (Distributed Bus) s latencí menší než 5 ms.

AppGallery a publikování aplikací

Huawei AppGallery je oficiální obchod s aplikacemi HarmonyOS, třetí největší na světě po Google Play a App Store. Podle Huawei (2026) má AppGallery více než 580 milionů měsíčně aktivních uživatelů. Registrace vývojáře je pro fyzické osoby zdarma (na rozdíl od 99 $ od Apple).

Proces publikování

Vývojář sestaví aplikaci v DevEco Studio (formát .hap — HarmonyOS Ability Package). Publikování přes AppGallery Connect: nahrání HAP souboru, vyplnění popisu (název, ikona, snímky obrazovky), nastavení cenového modelu. Průměrná doba moderace je 1-3 pracovní dny. Huawei kontroluje bezpečnost (statická analýza), kompatibilitu API a soulad s politikami.

Monetizace

AppGallery podporuje: placené aplikace (provize Huawei 15-30%), předplatné (15% provize), reklamu prostřednictvím Huawei Ads Kit a nákupy v aplikaci prostřednictvím IAP Kit. Huawei Pay je platební brána pro čínský trh podporující Alipay a WeChat Pay. Mezinárodní vývojáři dostávají platby přes PayPal nebo bankovní převod.

Huawei Mobile Services (HMS)

HMS Core je sada služeb nahrazujících Google Play Services na zařízeních Huawei bez Google. Zahrnuje: Push Kit (push oznámení), Map Kit (mapy s navigací), Location Kit (geolokace), Ads Kit (reklama), Analytics Kit (analytika), Account Kit (autorizace přes Huawei ID). HMS Core je k dispozici na zařízeních s HarmonyOS a na zařízeních Android Huawei (přes AppGallery).