HarmonyOS: mi ez, rendszerarchitektúra és fejlesztés ArkUI-n

Mi az a HarmonyOS?

HarmonyOS egy elosztott operációs rendszer, amelyet a Huawei fejlesztett ki, és először 2019-ben jelentették be válaszul a Google-szolgáltatásokhoz való hozzáférés korlátozására a vállalat új eszközein. A HarmonyOS a saját magfüggelékére épül, amely különbözik a Linux-tól, és az eszközök közötti zökkenőmentes működésre tervezték: okostelefonok, táblagépek, okosórák, televíziók, autóipari rendszerek és IoT-eszközök.

A Huawei (HarmonyOS Ökoszisztéma Jelentés, 2026) szerint a rendszer több mint 700 millió eszközre van telepítve, beleértve 300 millió okostelefont. A kínai piac a telepítések 95%-át teszi ki. A HarmonyOS 5.0-tól (NEXT, 2024) kezdve a rendszer teljesen felhagyott az Android AOSP kompatibilitással — minden alkalmazást ArkTS-ben vagy C++-ban kell megírni az ArkUI használatával.

A HarmonyOS kulcsjellemzője az elosztott architektúra: egy alkalmazás egyszerre több eszközön futhat, áthelyezve a felületet a képernyők között. Például a felhasználó elindítja a navigációt a telefonján, miközben a felület az autó képernyőjén jelenik meg — újrafordítás vagy további kód nélkül.

A HarmonyOS verziótörténete

HarmonyOS 1.0 (2019) — első verzió Smart Screen-hez, nem okostelefonokhoz. HarmonyOS 2.0 (2021) — megnyitva okostelefonokhoz, táblagépekhez és órákhoz, AOSP alkalmazások támogatása. HarmonyOS 3.0 (2022) — továbbfejlesztett elosztott architektúra, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, javított teljesítmény. HarmonyOS NEXT (5.0, 2024) — az AOSP teljes elhagyása, csak natív HarmonyOS alkalmazások.

A HarmonyOS architektúrája: elosztott magfüggelék

A HarmonyOS architektúrája alapvetően különbözik az Androidtól és az iOS-től. A monolitikus Linux kernel helyett a HarmonyOS a saját magfüggelékét használja, amely a minimális kiváltságos funkciókat valósítja meg: memóriakezelés, folyamatütemezés és folyamatok közötti kommunikáció. Az összes többi szolgáltatás a felhasználói térben fut.

Magfüggelék és biztonság

A HarmonyOS magfüggeléke körülbelül 10 000 sornyi kódot tartalmaz (a Linux kernel több mint 20 milliót). A kisebb kódbázis kisebb támadási felületet jelent. A rendszer formális verifikációt használ — a kernelkód helyességének matematikai bizonyítását. A HarmonyOS támogatja a Trusted Execution Environment (TEE) hardverszintű használatát biometriához, fizetésekhez és titkosítási kulcsokhoz. A folyamatok közötti kommunikáció IPC-n keresztül valósul meg, amely 5-ször hatékonyabb, mint az Android Binder.

Négy architekturális réteg

A HarmonyOS architektúra négy rétegből áll: Kernel Subsystem (magfüggelék + illesztőprogramok), System Service Layer (rendszerszolgáltatások: elosztott adatok, fájlrendszer, biztonság), Framework Layer (ArkUI, multimédia, telefónia, AI szolgáltatások) és Application Layer (felhasználói alkalmazások). Minden réteg IPC-n keresztül van elkülönítve az alatta lévő rétegtől.

Elosztott fájlrendszer

A HarmonyOS egy elosztott fájlrendszert (DFS) biztosít, amely egyetlen virtuális térré egyesíti a felhasználó összes eszközének tárhelyét. Egy alkalmazás URI-n keresztül fér hozzá a fájlokhoz anélkül, hogy megadná az eszközt — a rendszer a kérést arra az eszközre irányítja, ahol a fájl fizikailag található. A DFS támogatja a végpontok közötti titkosítást és a gyakran használt adatok automatikus replikációját.

// Munka a HarmonyOS elosztott fájlrendszerével
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Fájl URI lekérése elosztott eszközön
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;  // Fájl megtalálva az egyik eszközön
        }
    }
    return Uri::Empty();
}

// Adatok olvasása távoli eszközről
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);
}

A példában a DistributedFileManager megkeresi a fájlt a felhasználó összes online eszközén, és visszaad egy elosztott URI-t. A DistributedFile fizikailag megnyitja a fájlt a távoli eszközön IPC-n keresztül, átláthatóan az alkalmazás számára. A fejlesztőnek nem kell tudnia, hol tárolódnak az adatok — a rendszer automatikusan irányítja a kérést.

ArkUI és ArkTS: felületek fejlesztése

ArkUI a HarmonyOS deklaratív UI keretrendszere, amelyet a Huawei fejlesztett ki. A felület komponensek hierarchiájaként írható le reaktív adatkötéssel, hasonlóan a SwiftUI-hoz (iOS) vagy a Jetpack Compose-hoz (Android). ArkTS egy TypeScript alapú fejlesztői nyelv további statikus típusossággal és integrációval az ArkUI-hoz a @Component, @State, @Prop, @Link dekorátorokon keresztül.

ArkTS alapfogalmak

Az ArkTS kibővíti a TypeScript-et az UI keretrendszerrel való harmonizációval: @Component — dekorátor egy UI komponens deklarálásához, build() — kötelező metódus, amely visszaadja az UI elemek fáját, @State — reaktív változó, amelynek változásai automatikusan újrarajzolják a komponenst, @Prop — bemeneti tulajdonság a szülőtől, @Link — kétirányú kötés. Az összes ArkUI komponens láncolt szintaxist használ módosítókkal (.width, .height, .backgroundColor).

// ArkTS — felhasználói profil képernyő ArkUI-n
@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("Betöltési hiba", 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("Szerkesztés", {
                            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%');
    }
}

// Alkalmazás belépési pont
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Profilszerkesztő megnyitása");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

A ProfileScreen komponens ArkTS-ben bemutatja: @State reaktív változókhoz, @Prop bemeneti callbackhez, Column/Stack/Text/Image/Button alap UI komponensekként, aszinkron adatbetöltés async/await segítségével. A LoadingProgress a betöltés alatt jelenik meg. Minden méret vp-ben (virtuális pixelekben) van megadva — adaptív egységek, hasonlóan az iOS pt vagy Android dp mértékegységeihez.

Adaptáció különböző eszközökhöz

Az ArkUI támogatja a reszponzív tervezést egy töréspont rendszeren (xs, sm, md, lg, xl) keresztül, amely a képernyő szélességének felel meg. A komponensek automatikusan átrendeződnek, amikor telefonról táblagépre vagy órára váltunk. A GridRow és GridCol adaptív konténerek, amelyek a törésponttól függően változtatják az oszlopok számát. Mértékegységek: vp (virtuális pixelek), fp (betűtípus pixelek — a betűtípus-beállításokkal skálázódnak), lpx (logikai pixelek órákhoz).

DevEco Studio és fejlesztői eszközök

DevEco Studio a hivatalos integrált fejlesztői környezet (IDE) a HarmonyOS számára, amely az IntelliJ IDEA Community Edition-en alapul. Tartalmaz egy kódszerkesztőt ArkTS és C++ támogatással, egy vizuális ArkUI szerkesztőt (fogd és vidd), egy HarmonyOS eszköz emulátort, Preview-t az azonnali UI megtekintéshez és Profiler-t a teljesítményelemzéshez.

HarmonyOS emulátor

A DevEco Studio tartalmaz egy QEMU-alapú emulátort, amely támogatja az okostelefonokat (különböző képernyőméretek), táblagépeket, órákat és televíziókat. Az emulátor szimulál egy elosztott környezetet: több virtuális eszközt futtathat, és tesztelheti az eszközök közötti interakciót. Az emulátor virtualizációt igényel (Hyper-V Windows-on, KVM Linux-on).

Preview és Live Preview

ArkUI Preview egy funkció az UI azonnali megtekintéséhez build vagy emulátor indítása nélkül. A kódváltozások 1-2 másodpercen belül megjelennek a Preview-ban. Az összes szabványos komponens és animáció támogatott. A Preview különböző töréspontokkal működik az alkalmazkodóképesség teszteléséhez. A Live Preview USB-n vagy Wi-Fi-n keresztül csatlakozik egy valós eszközhöz a hardveres teszteléshez.

HarmonyOS SDK és API

A HarmonyOS SDK a következőket tartalmazza: ArkUI (UI komponensek), Multimedia Kit (audio/video rögzítés és lejátszás), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (helymeghatározás), Sensor Kit (érzékelők), AI Kit (ML Kit on-device inferenciával Huawei NPU-n). API verziók: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Kamera inicializálása HarmonyOS-on Multimedia Kiten keresztül
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 {
            // Kamera engedély kérése
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Kamera lekérése (0 — hátsó, 1 — elülső)
            const camera = await this.cameraManager.getCamera(0);

            // Kamera bemenet létrehozása
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Előnézet indítása Surface-en (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;
    }
}

A CameraView komponens bemutatja a Multimedia Kittel való munkát: engedély kérése a Permissions.request segítségével, kamera lekérése a CameraManager-en keresztül, CameraInput és PreviewOutput létrehozása. Az ArkUI Surface (XComponent-en keresztül) megjeleníti a videó streamet. Minden művelet aszinkron, hiba kezeléssel try/catch segítségével.

Elosztott alkalmazások és eszközök közötti

A HarmonyOS elosztott architektúrája a fő különbség a versenytársakhoz képest. Egy alkalmazás több atomi szolgáltatásból (Atomic Services) állhat, amelyek mindegyike az optimális eszközön fut. A felhasználó elindít egy feladatot az egyik eszközön, és egy másikon folytatja a kontextus elvesztése nélkül.

Atomic Services és Ability

Az Atomic Service a minimális telepítési egység a HarmonyOS-ban. Minden szolgáltatás egy vagy több Ability-t valósít meg (analóg az Android Activity-jével). Page Ability — egy képernyő UI-val, Service Ability — egy háttérfeladat, Data Ability — adatelérés. Egy alkalmazás delegálhat egy Ability-t egy másik eszközre: például az UI a táblagépen jelenik meg, miközben az AI feldolgozás egy NPU-val rendelkező telefonon fut.

Elosztott Adatkezelés

Az Elosztott Adatkezelő (DDM) rendszer szinkronizálja az alkalmazás állapotát az eszközök között. A DDM elosztott adatobjektumokat használ — reaktív objektumokat, amelyek automatikusan replikálódnak a felhasználó összes eszközére. Az adatok változása az egyik eszközön azonnal tükröződik az összes többin. A DDM támogatja a titkosítást és figyelembe veszi a hálózati kapcsolatot (Bluetooth, Wi-Fi, mobil adat).

Super Device

Super Device — egy HarmonyOS funkció, amely lehetővé teszi akár 7 Huawei eszköz egyetlen számítási környezetbe történő egyesítését. A felhasználó eszközikonokat húz a Super Device felületén: a hangszórók audio kimenetté válnak, a táblagép második képernyővé, az óra pulzusmérővé a telefon fitnesz alkalmazásához. Az összes eszköz egy elosztott buszon (Distributed Bus) keresztül szinkronizálódik, 5 ms-nál kisebb késleltetéssel.

AppGallery és alkalmazások közzététele

Huawei AppGallery a HarmonyOS hivatalos alkalmazásboltja, a harmadik legnagyobb a világon a Google Play és az App Store után. A Huawei (2026) szerint az AppGallery-nek több mint 580 millió havi aktív felhasználója van. A fejlesztői regisztráció magánszemélyek számára ingyenes (ellentétben az Apple 99 dollárjával).

Közzétételi folyamat

A fejlesztő a DevEco Studio-ban (.hap formátum — HarmonyOS Ability Package) építi fel az alkalmazást. Közzététel az AppGallery Connecten keresztül: HAP fájl feltöltése, leírás kitöltése (név, ikon, képernyőképek), árképzési modell beállítása. Az átlagos moderációs idő 1-3 munkanap. A Huawei ellenőrzi a biztonságot (statikus elemzés), az API kompatibilitást és a szabályzatoknak való megfelelést.

Monetizáció

Az AppGallery támogatja: fizetős alkalmazások (Huawei jutalék 15-30%), előfizetések (15% jutalék), reklámozás a Huawei Ads Kiten keresztül és alkalmazáson belüli vásárlások az IAP Kiten keresztül. A Huawei Pay egy fizetési átjáró a kínai piac számára, amely támogatja az Alipay-t és a WeChat Pay-t. A nemzetközi fejlesztők PayPalon vagy banki átutalással kapják meg a kifizetéseket.

Huawei Mobile Services (HMS)

A HMS Core egy szolgáltatáskészlet, amely a Google Play Services-t helyettesíti a Google nélküli Huawei eszközökön. Tartalmazza: Push Kit (push értesítések), Map Kit (térképek navigációval), Location Kit (helymeghatározás), Ads Kit (hirdetés), Analytics Kit (analitika), Account Kit (hitelesítés Huawei ID-n keresztül). A HMS Core elérhető HarmonyOS-szal rendelkező eszközökön és Huawei Android eszközökön (az AppGallery-n keresztül).