HarmonyOS: ce este, arhitectura sistemului și dezvoltare pe ArkUI

Ce este HarmonyOS?

HarmonyOS este un sistem de operare distribuit dezvoltat de Huawei și anunțat pentru prima dată în 2019 ca răspuns la restricționarea accesului la serviciile Google pe noile dispozitive ale companiei. HarmonyOS este construit pe propriul microkernel, diferit de Linux, și este conceput pentru funcționare fără întreruperi între dispozitive: smartphone-uri, tablete, ceasuri inteligente, televizoare, sisteme auto și dispozitive IoT.

Potrivit Huawei (Raportul Ecosistemului HarmonyOS, 2026), sistemul este instalat pe peste 700 de milioane de dispozitive, inclusiv 300 de milioane de smartphone-uri. Piața chineză reprezintă 95% din instalații. Începând cu HarmonyOS 5.0 (NEXT, 2024), sistemul a abandonat complet compatibilitatea cu Android AOSP — toate aplicațiile trebuie scrise în ArkTS sau C++ cu ArkUI.

Caracteristica cheie a HarmonyOS este arhitectura sa distribuită: o aplicație poate rula pe mai multe dispozitive simultan, mutând interfața între ecrane. De exemplu, un utilizator pornește navigația pe telefon în timp ce interfața se afișează pe ecranul mașinii — fără recompilare sau cod suplimentar.

Istoricul versiunilor HarmonyOS

HarmonyOS 1.0 (2019) — prima versiune pentru Smart Screen, nu pentru smartphone-uri. HarmonyOS 2.0 (2021) — deschis pentru smartphone-uri, tablete și ceasuri, suport pentru aplicații AOSP. HarmonyOS 3.0 (2022) — arhitectură distribuită îmbunătățită, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, performanță îmbunătățită. HarmonyOS NEXT (5.0, 2024) — abandonarea completă a AOSP, doar aplicații native HarmonyOS.

Arhitectura HarmonyOS: microkernel distribuit

Arhitectura HarmonyOS este fundamental diferită de Android și iOS. În locul kernel-ului monolitic Linux, HarmonyOS folosește propriul microkernel, implementând un set minim de funcții privilegiate: gestionarea memoriei, planificarea proceselor și comunicarea inter-proces. Toate celelalte servicii rulează în spațiul utilizatorului.

Microkernel și securitate

Microkernel-ul HarmonyOS cuprinde aproximativ 10.000 de linii de cod (kernel-ul Linux are peste 20 de milioane). O bază de cod mai mică înseamnă o suprafață de atac mai mică. Sistemul folosește verificarea formală — demonstrația matematică a corectitudinii codului kernel-ului. HarmonyOS suportă Trusted Execution Environment (TEE) la nivel hardware pentru biometrie, plăți și chei de criptare. Comunicarea inter-proces este implementată prin IPC, de 5 ori mai performant decât Binder în Android.

Patru straturi arhitecturale

Arhitectura HarmonyOS constă din patru straturi: Kernel Subsystem (microkernel + drivere), System Service Layer (servicii de sistem: date distribuite, sistem de fișiere, securitate), Framework Layer (ArkUI, multimedia, telefonie, servicii AI) și Application Layer (aplicații utilizator). Fiecare strat este izolat de stratul inferior prin IPC.

Sistem de fișiere distribuit

HarmonyOS oferă un Sistem de Fișiere Distribuit (DFS) care unifică stocarea tuturor dispozitivelor utilizatorului într-un singur spațiu virtual. O aplicație accesează fișierele prin URI fără a specifica un dispozitiv — sistemul direcționează cererea către dispozitivul unde fișierul este stocat fizic. DFS suportă criptarea end-to-end și replicarea automată a datelor frecvent utilizate.

// Lucrul cu sistemul de fișiere distribuit HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Obținerea URI-ului fișierului pe un dispozitiv distribuit
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;  // Fișier găsit pe unul dintre dispozitive
        }
    }
    return Uri::Empty();
}

// Citirea datelor de pe un dispozitiv remote
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);
}

În exemplu, DistributedFileManager caută un fișier pe toate dispozitivele online ale utilizatorului și returnează un URI distribuit. DistributedFile deschide fizic fișierul pe dispozitivul remot prin IPC, transparent pentru aplicație. Dezvoltatorul nu trebuie să știe unde sunt stocate datele — sistemul direcționează cererea automat.

ArkUI și ArkTS: dezvoltarea interfețelor

ArkUI este framework-ul UI declarativ al HarmonyOS dezvoltat de Huawei. Interfața este descrisă ca o ierarhie de componente cu legare reactivă a datelor, similară cu SwiftUI (iOS) sau Jetpack Compose (Android). ArkTS este un limbaj de dezvoltare bazat pe TypeScript cu tipizare statică suplimentară și integrare cu ArkUI prin decoratorii @Component, @State, @Prop, @Link.

Concepte fundamentale ArkTS

ArkTS extinde TypeScript prin armonizarea cu framework-ul UI: @Component — decorator pentru declararea unui component UI, build() — metodă obligatorie care returnează un arbore de elemente UI, @State — variabilă reactivă ale cărei schimbări redesenează automat componentul, @Prop — proprietate de intrare de la părinte, @Link — legare bidirecțională. Toate componentele ArkUI folosesc sintaxă înlănțuită cu modificatori (.width, .height, .backgroundColor).

// ArkTS — ecranul profilului utilizatorului pe 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("Eroare de încărcare", 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("Editare", {
                            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%');
    }
}

// Punctul de intrare al aplicației
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Deschide editorul de profil");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

Componentul ProfileScreen în ArkTS demonstrează: @State pentru variabile reactive, @Prop pentru callback de intrare, Column/Stack/Text/Image/Button ca componente UI de bază, încărcarea asincronă a datelor prin async/await. LoadingProgress este afișat în timpul încărcării. Toate dimensiunile sunt specificate în vp (pixeli virtuali) — unități adaptive similare cu pt în iOS sau dp în Android.

Adaptare pentru diferite dispozitive

ArkUI suportă design responsive printr-un sistem de Breakpoint-uri (xs, sm, md, lg, xl) corespunzătoare lățimii ecranului. Componentele se reorganizează automat la trecerea de pe telefon pe tabletă sau ceas. GridRow și GridCol sunt containere adaptive care schimbă numărul de coloane în funcție de breakpoint. Unități de dimensiune: vp (pixeli virtuali), fp (pixeli de font — se scalează cu setările fontului), lpx (pixeli logici pentru ceasuri).

DevEco Studio și instrumente de dezvoltare

DevEco Studio este mediul de dezvoltare integrat (IDE) oficial pentru HarmonyOS, bazat pe IntelliJ IDEA Community Edition. Include un editor de cod cu suport pentru ArkTS și C++, un editor vizual ArkUI (drag-and-drop), un emulator de dispozitive HarmonyOS, Preview pentru vizualizarea instantanee a UI și Profiler pentru analiza performanței.

Emulator HarmonyOS

DevEco Studio include un emulator bazat pe QEMU, care suportă smartphone-uri (diferite dimensiuni de ecran), tablete, ceasuri și televizoare. Emulatorul simulează un mediu distribuit: puteți rula mai multe dispozitive virtuale și testa interacțiunea cross-dispozitiv. Emulatorul necesită virtualizare (Hyper-V pe Windows, KVM pe Linux).

Preview și Live Preview

ArkUI Preview este o funcție de vizualizare instantanee a UI fără compilare sau pornire a emulatorului. Modificările de cod apar în Preview în 1-2 secunde. Toate componentele și animațiile standard sunt suportate. Preview funcționează cu diferite breakpoint-uri pentru testarea adaptabilității. Live Preview se conectează la un dispozitiv real prin USB sau Wi-Fi pentru testare pe hardware real.

HarmonyOS SDK și API

SDK-ul HarmonyOS include: ArkUI (componente UI), Multimedia Kit (captură și redare audio/video), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolocalizare), Sensor Kit (senzori), AI Kit (ML Kit cu inferență pe dispozitiv pe NPU Huawei). Versiuni API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Inițializarea camerei pe HarmonyOS prin 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 {
            // Solicitarea permisiunii camerei
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Obținerea camerei (0 — spate, 1 — față)
            const camera = await this.cameraManager.getCamera(0);

            // Crearea intrării camerei
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Pornirea previzualizării pe 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;
    }
}

Componentul CameraView demonstrează lucrul cu Multimedia Kit: solicitarea permisiunii prin Permissions.request, obținerea camerei prin CameraManager, crearea CameraInput și PreviewOutput. ArkUI Surface (prin XComponent) afișează fluxul video. Toate operațiile sunt asincrone cu gestionarea erorilor prin try/catch.

Aplicații distribuite și cross-dispozitiv

Arhitectura distribuită a HarmonyOS este principala diferență față de concurenți. O aplicație poate consta din mai multe servicii atomice (Atomic Services), fiecare rulând pe dispozitivul optim. Utilizatorul începe o sarcină pe un dispozitiv și continuă pe altul fără a pierde contextul.

Atomic Services și Ability

Atomic Service este unitatea minimă de implementare pe HarmonyOS. Fiecare serviciu implementează una sau mai multe Ability (analog cu Activity în Android). Page Ability — un ecran cu UI, Service Ability — o sarcină în fundal, Data Ability — acces la date. O aplicație poate delega o Ability altui dispozitiv: de exemplu, UI se afișează pe tabletă în timp ce procesarea AI rulează pe un telefon cu NPU.

Gestionarea Datelor Distribuite

Sistemul de Gestionare a Datelor Distribuite (DDM) sincronizează starea aplicației între dispozitive. DDM folosește Obiecte de Date Distribuite — obiecte reactive care se replică automat pe toate dispozitivele utilizatorului. Modificările de date pe un dispozitiv sunt reflectate instantaneu pe toate celelalte. DDM suportă criptarea și ia în considerare conexiunea de rețea (Bluetooth, Wi-Fi, date celulare).

Super Device

Super Device — o funcție HarmonyOS care permite unirea a până la 7 dispozitive Huawei într-un singur mediu de calcul. Utilizatorul trage pictogramele dispozitivelor în interfața Super Device: difuzoarele devin ieșire audio, tableta devine un al doilea ecran, ceasul devine un monitor de ritm cardiac pentru o aplicație de fitness pe telefon. Toate dispozitivele se sincronizează printr-un bus distribuit (Distributed Bus) cu o latență sub 5 ms.

AppGallery și publicarea aplicațiilor

Huawei AppGallery este magazinul oficial de aplicații HarmonyOS, al treilea ca mărime din lume după Google Play și App Store. Potrivit Huawei (2026), AppGallery are peste 580 de milioane de utilizatori activi lunar. Înregistrarea dezvoltatorului este gratuită pentru persoane fizice (spre deosebire de cei 99 $ ai Apple).

Procesul de publicare

Dezvoltatorul construiește aplicația în DevEco Studio (format .hap — HarmonyOS Ability Package). Publicarea prin AppGallery Connect: încărcarea fișierului HAP, completarea descrierii (nume, pictogramă, capturi de ecran), configurarea modelului de preț. Timpul mediu de moderare este de 1-3 zile lucrătoare. Huawei verifică securitatea (analiză statică), compatibilitatea API și conformitatea cu politicile.

Monetizare

AppGallery suportă: aplicații plătite (comision Huawei 15-30%), abonamente (comision 15%), publicitate prin Huawei Ads Kit și achiziții în aplicație prin IAP Kit. Huawei Pay este o poartă de plată pentru piața chineză care suportă Alipay și WeChat Pay. Dezvoltatorii internaționali primesc plăți prin PayPal sau transfer bancar.

Huawei Mobile Services (HMS)

HMS Core este un set de servicii care înlocuiesc Google Play Services pe dispozitivele Huawei fără Google. Include: Push Kit (notificări push), Map Kit (hărți cu navigație), Location Kit (geolocalizare), Ads Kit (publicitate), Analytics Kit (analitică), Account Kit (autorizare prin Huawei ID). HMS Core este disponibil pe dispozitivele cu HarmonyOS și pe dispozitivele Android Huawei (prin AppGallery).