HarmonyOS: co to jest, architektura systemu i rozwój na ArkUI

Co to jest HarmonyOS?

HarmonyOS to rozproszony system operacyjny opracowany przez Huawei i po raz pierwszy ogłoszony w 2019 roku jako odpowiedź na ograniczenie dostępu do usług Google na nowych urządzeniach firmy. HarmonyOS jest zbudowany na własnym mikrojądrze, różnym od Linuxa, i jest zaprojektowany do bezproblemowej pracy między urządzeniami: smartfonami, tabletami, smartwatchami, telewizorami, systemami samochodowymi i urządzeniami IoT.

Według Huawei (Raport ekosystemu HarmonyOS, 2026), system jest zainstalowany na ponad 700 milionach urządzeń, w tym 300 milionach smartfonów. Rynek chiński stanowi 95% instalacji. Począwszy od HarmonyOS 5.0 (NEXT, 2024), system całkowicie porzucił kompatybilność z Android AOSP — wszystkie aplikacje muszą być napisane w ArkTS lub C++ z użyciem ArkUI.

Kluczową cechą HarmonyOS jest jego rozproszona architektura: aplikacja może działać na wielu urządzeniach jednocześnie, przenosząc interfejs między ekranami. Na przykład użytkownik uruchamia nawigację na telefonie, a interfejs wyświetla się na ekranie samochodu — bez rekompilacji ani dodatkowego kodu.

Historia wersji HarmonyOS

HarmonyOS 1.0 (2019) — pierwsza wersja dla Smart Screen, nie dla smartfonów. HarmonyOS 2.0 (2021) — otwarta dla smartfonów, tabletów i zegarków, obsługa aplikacji AOSP. HarmonyOS 3.0 (2022) — ulepszona architektura rozproszona, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, ulepszona wydajność. HarmonyOS NEXT (5.0, 2024) — całkowite porzucenie AOSP, tylko natywne aplikacje HarmonyOS.

Architektura HarmonyOS: rozproszone mikrojądro

Architektura HarmonyOS zasadniczo różni się od Androida i iOS. Zamiast monolitycznego jądra Linux, HarmonyOS używa własnego mikrojądra, implementującego minimalny zestaw funkcji uprzywilejowanych: zarządzanie pamięcią, planowanie procesów i komunikację międzyprocesową. Wszystkie inne usługi działają w przestrzeni użytkownika.

Mikrojądro i bezpieczeństwo

Mikrojądro HarmonyOS liczy około 10 000 linii kodu (jądro Linux ma ponad 20 milionów). Mniejsza baza kodu oznacza mniejszą powierzchnię ataku. System wykorzystuje weryfikację formalną — matematyczny dowód poprawności kodu jądra. HarmonyOS obsługuje Trusted Execution Environment (TEE) na poziomie sprzętowym dla biometrii, płatności i kluczy szyfrowania. Komunikacja międzyprocesowa jest realizowana przez IPC, 5 razy wydajniejszy niż Binder w Androidzie.

Cztery warstwy architektury

Architektura HarmonyOS składa się z czterech warstw: Kernel Subsystem (mikrojądro + sterowniki), System Service Layer (usługi systemowe: dane rozproszone, system plików, bezpieczeństwo), Framework Layer (ArkUI, multimedia, telefonia, usługi AI) i Application Layer (aplikacje użytkownika). Każda warstwa jest izolowana od warstwy poniżej przez IPC.

Rozproszony system plików

HarmonyOS zapewnia rozproszony system plików (DFS), który łączy pamięć wszystkich urządzeń użytkownika w jedną wirtualną przestrzeń. Aplikacja uzyskuje dostęp do plików przez URI bez określania urządzenia — system kieruje żądanie do urządzenia, na którym plik jest fizycznie przechowywany. DFS obsługuje szyfrowanie end-to-end i automatyczną replikację często używanych danych.

// Praca z rozproszonym systemem plików HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Uzyskiwanie URI pliku na rozproszonym urządzeniu
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;  // Plik znaleziony na jednym z urządzeń
        }
    }
    return Uri::Empty();
}

// Odczyt danych z urządzenia zdalnego
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);
}

W przykładzie DistributedFileManager wyszukuje plik na wszystkich online'owych urządzeniach użytkownika i zwraca rozproszony URI. DistributedFile otwiera plik fizycznie na zdalnym urządzeniu przez IPC, w sposób przezroczysty dla aplikacji. Deweloper nie musi wiedzieć, gdzie przechowywane są dane — system automatycznie kieruje żądanie.

ArkUI i ArkTS: tworzenie interfejsów

ArkUI to deklaratywny framework UI HarmonyOS opracowany przez Huawei. Interfejs jest opisywany jako hierarchia komponentów z reaktywnym wiązaniem danych, podobnie jak SwiftUI (iOS) lub Jetpack Compose (Android). ArkTS to język programowania oparty na TypeScript z dodatkowym statycznym typowaniem i integracją z ArkUI przez dekoratory @Component, @State, @Prop, @Link.

Podstawowe koncepcje ArkTS

ArkTS rozszerza TypeScript poprzez harmonizację z frameworkiem UI: @Component — dekorator do deklarowania komponentu UI, build() — obowiązkowa metoda zwracająca drzewo elementów UI, @State — zmienna reaktywna, której zmiany automatycznie przerysowują komponent, @Prop — właściwość wejściowa od rodzica, @Link — wiązanie dwukierunkowe. Wszystkie komponenty ArkUI używają składni łańcuchowej z modyfikatorami (.width, .height, .backgroundColor).

// ArkTS — ekran profilu użytkownika 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("Błąd ładowania", 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("Edytuj", {
                            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%');
    }
}

// Punkt wejścia aplikacji
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Otwórz edytor profilu");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

Komponent ProfileScreen w ArkTS demonstruje: @State dla zmiennych reaktywnych, @Prop dla callbacku wejściowego, Column/Stack/Text/Image/Button jako podstawowe komponenty UI, asynchroniczne ładowanie danych przez async/await. LoadingProgress wyświetla się podczas ładowania. Wszystkie rozmiary są podawane w vp (wirtualnych pikselach) — jednostkach adaptacyjnych podobnych do pt w iOS lub dp w Androidzie.

Adaptacja do różnych urządzeń

ArkUI obsługuje responsywny design poprzez system Breakpoints (xs, sm, md, lg, xl) odpowiadających szerokości ekranu. Komponenty automatycznie przestawiają się przy przejściu z telefonu na tablet lub zegarek. GridRow i GridCol to adaptacyjne kontenery zmieniające liczbę kolumn w zależności od breakpointa. Jednostki rozmiaru: vp (wirtualne piksele), fp (piksele czcionki — skalują się z ustawieniami czcionki), lpx (logiczne piksele dla zegarków).

DevEco Studio i narzędzia programistyczne

DevEco Studio to oficjalne zintegrowane środowisko programistyczne (IDE) dla HarmonyOS, oparte na IntelliJ IDEA Community Edition. Zawiera edytor kodu z obsługą ArkTS i C++, wizualny edytor ArkUI (przeciągnij i upuść), emulator urządzeń HarmonyOS, Preview do natychmiastowego podglądu UI i Profiler do analizy wydajności.

Emulator HarmonyOS

DevEco Studio zawiera emulator oparty na QEMU, obsługujący smartfony (różne rozmiary ekranów), tablety, zegarki i telewizory. Emulator symuluje środowisko rozproszone: można uruchomić wiele wirtualnych urządzeń i testować interakcję między urządzeniami. Emulator wymaga wirtualizacji (Hyper-V w Windows, KVM w Linux).

Preview i Live Preview

ArkUI Preview to funkcja natychmiastowego podglądu UI bez budowania i uruchamiania emulatora. Zmiany w kodzie pojawiają się w Preview w ciągu 1-2 sekund. Wszystkie standardowe komponenty i animacje są obsługiwane. Preview działa z różnymi breakpointami do testowania adaptacyjności. Live Preview łączy się z rzeczywistym urządzeniem przez USB lub Wi-Fi do testowania na sprzęcie.

HarmonyOS SDK i API

HarmonyOS SDK zawiera: ArkUI (komponenty UI), Multimedia Kit (przechwytywanie i odtwarzanie audio/wideo), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolokalizacja), Sensor Kit (czujniki), AI Kit (ML Kit z wnioskowaniem na urządzeniu na NPU Huawei). Wersje API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Inicjalizacja kamery na HarmonyOS przez 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 {
            // Żądanie uprawnienia do kamery
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Uzyskanie kamery (0 — tylna, 1 — przednia)
            const camera = await this.cameraManager.getCamera(0);

            // Tworzenie wejścia kamery
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Uruchomienie podglądu 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;
    }
}

Komponent CameraView demonstruje pracę z Multimedia Kit: żądanie uprawnienia przez Permissions.request, uzyskanie kamery przez CameraManager, tworzenie CameraInput i PreviewOutput. ArkUI Surface (przez XComponent) wyświetla strumień wideo. Wszystkie operacje są asynchroniczne z obsługą błędów przez try/catch.

Aplikacje rozproszone i między urządzeniami

Architektura rozproszona HarmonyOS to główna różnica w stosunku do konkurencji. Aplikacja może składać się z wielu usług atomowych (Atomic Services), z których każda działa na optymalnym urządzeniu. Użytkownik rozpoczyna zadanie na jednym urządzeniu i kontynuuje na innym bez utraty kontekstu.

Atomic Services i Ability

Atomic Service to minimalna jednostka wdrażania w HarmonyOS. Każda usługa implementuje jedną lub więcej Ability (odpowiednik Activity w Androidzie). Page Ability — ekran z UI, Service Ability — zadanie w tle, Data Ability — dostęp do danych. Aplikacja może delegować Ability do innego urządzenia: na przykład UI wyświetla się na tablecie, a przetwarzanie AI odbywa się na telefonie z NPU.

Zarządzanie danymi rozproszonymi

System zarządzania danymi rozproszonymi (DDM) synchronizuje stan aplikacji między urządzeniami. DDM używa rozproszonych obiektów danych — obiektów reaktywnych, które automatycznie replikują się na wszystkich urządzeniach użytkownika. Zmiana danych na jednym urządzeniu jest natychmiast odzwierciedlana na wszystkich pozostałych. DDM obsługuje szyfrowanie i uwzględnia połączenie sieciowe (Bluetooth, Wi-Fi, dane komórkowe).

Super Device

Super Device — funkcja HarmonyOS pozwalająca połączyć do 7 urządzeń Huawei w jedno środowisko obliczeniowe. Użytkownik przeciąga ikony urządzeń w interfejsie Super Device: głośniki stają się wyjściem audio, tablet drugim ekranem, zegarek monitorem tętna dla aplikacji fitness na telefonie. Wszystkie urządzenia synchronizują się przez rozproszoną magistralę (Distributed Bus) z opóźnieniem poniżej 5 ms.

AppGallery i publikowanie aplikacji

Huawei AppGallery to oficjalny sklep z aplikacjami HarmonyOS, trzeci co do wielkości na świecie po Google Play i App Store. Według Huawei (2026), AppGallery ma ponad 580 milionów aktywnych użytkowników miesięcznie. Rejestracja programisty jest bezpłatna dla osób fizycznych (w przeciwieństwie do 99 $ Apple).

Proces publikacji

Deweloper buduje aplikację w DevEco Studio (format .hap — HarmonyOS Ability Package). Publikacja przez AppGallery Connect: przesłanie pliku HAP, wypełnienie opisu (nazwa, ikona, zrzuty ekranu), skonfigurowanie modelu cenowego. Średni czas moderacji to 1-3 dni robocze. Huawei sprawdza bezpieczeństwo (analiza statyczna), kompatybilność z API i zgodność z politykami.

Monetyzacja

AppGallery obsługuje: płatne aplikacje (prowizja Huawei 15-30%), subskrypcje (15% prowizji), reklamy przez Huawei Ads Kit i zakupy w aplikacji przez IAP Kit. Huawei Pay to bramka płatności dla rynku chińskiego obsługująca Alipay i WeChat Pay. Międzynarodowi deweloperzy otrzymują płatności przez PayPal lub przelew bankowy.

Huawei Mobile Services (HMS)

HMS Core to zestaw usług zastępujących Google Play Services na urządzeniach Huawei bez Google. Obejmuje: Push Kit (powiadomienia push), Map Kit(mapy z nawigacją), Location Kit (geolokalizacja), Ads Kit (reklamy), Analytics Kit (analityka), Account Kit (autoryzacja przez Huawei ID). HMS Core jest dostępny na urządzeniach z HarmonyOS i na urządzeniach Android Huawei (przez AppGallery).