HarmonyOS: cos'è, architettura del sistema e sviluppo su ArkUI

Cos'è HarmonyOS?

HarmonyOS è un sistema operativo distribuito sviluppato da Huawei e annunciato per la prima volta nel 2019 in risposta alla restrizione dell'accesso ai servizi Google sui nuovi dispositivi dell'azienda. HarmonyOS è costruito sul proprio microkernel, diverso da Linux, ed è progettato per un funzionamento senza soluzione di continuità tra dispositivi: smartphone, tablet, smartwatch, televisori, sistemi automobilistici e dispositivi IoT.

Secondo Huawei (Rapporto sull'Ecosistema HarmonyOS, 2026), il sistema è installato su oltre 700 milioni di dispositivi, inclusi 300 milioni di smartphone. Il mercato cinese rappresenta il 95% delle installazioni. A partire da HarmonyOS 5.0 (NEXT, 2024), il sistema ha completamente abbandonato la compatibilità con Android AOSP — tutte le applicazioni devono essere scritte in ArkTS o C++ con ArkUI.

La caratteristica principale di HarmonyOS è la sua architettura distribuita: un'applicazione può essere eseguita su più dispositivi contemporaneamente, spostando l'interfaccia tra gli schermi. Ad esempio, un utente avvia la navigazione sul telefono mentre l'interfaccia viene visualizzata sullo schermo dell'auto — senza ricompilazione o codice aggiuntivo.

Storia delle versioni di HarmonyOS

HarmonyOS 1.0 (2019) — prima versione per Smart Screen, non per smartphone. HarmonyOS 2.0 (2021) — aperto a smartphone, tablet e orologi, supporto per applicazioni AOSP. HarmonyOS 3.0 (2022) — architettura distribuita migliorata, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, prestazioni migliorate. HarmonyOS NEXT (5.0, 2024) — abbandono completo di AOSP, solo applicazioni native HarmonyOS.

Architettura di HarmonyOS: microkernel distribuito

L'architettura di HarmonyOS è fondamentalmente diversa da Android e iOS. Invece del kernel monolitico Linux, HarmonyOS utilizza il proprio microkernel, implementando un insieme minimo di funzioni privilegiate: gestione della memoria, scheduling dei processi e comunicazione interprocesso. Tutti gli altri servizi vengono eseguiti nello spazio utente.

Microkernel e sicurezza

Il microkernel di HarmonyOS comprende circa 10.000 righe di codice (il kernel Linux ne ha oltre 20 milioni). Un codebase più piccolo significa una superficie d'attacco più ridotta. Il sistema utilizza la verifica formale — dimostrazione matematica della correttezza del codice del kernel. HarmonyOS supporta Trusted Execution Environment (TEE) a livello hardware per biometria, pagamenti e chiavi di crittografia. La comunicazione interprocesso è implementata tramite IPC, 5 volte più performante di Binder in Android.

Quattro livelli architetturali

L'architettura di HarmonyOS è composta da quattro livelli: Kernel Subsystem (microkernel + driver), System Service Layer (servizi di sistema: dati distribuiti, file system, sicurezza), Framework Layer (ArkUI, multimedialità, telefonia, servizi AI) e Application Layer (applicazioni utente). Ogni livello è isolato dal livello sottostante tramite IPC.

File system distribuito

HarmonyOS fornisce un File System Distribuito (DFS) che unifica l'archiviazione di tutti i dispositivi dell'utente in un unico spazio virtuale. Un'applicazione accede ai file tramite URI senza specificare un dispositivo — il sistema instrada la richiesta al dispositivo in cui il file è fisicamente memorizzato. DFS supporta la crittografia end-to-end e la replica automatica dei dati utilizzati di frequente.

// Lavorare con il file system distribuito di HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Ottenere un URI di file su un dispositivo distribuito
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;  // File trovato su uno dei dispositivi
        }
    }
    return Uri::Empty();
}

// Leggere dati da un dispositivo remoto
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);
}

Nell'esempio, DistributedFileManager cerca un file su tutti i dispositivi online dell'utente e restituisce un URI distribuito. DistributedFile apre fisicamente il file sul dispositivo remoto tramite IPC, in modo trasparente per l'applicazione. Lo sviluppatore non ha bisogno di sapere dove sono memorizzati i dati — il sistema instrada automaticamente la richiesta.

ArkUI e ArkTS: sviluppo di interfacce

ArkUI è il framework UI dichiarativo di HarmonyOS sviluppato da Huawei. L'interfaccia è descritta come una gerarchia di componenti con data binding reattivo, simile a SwiftUI (iOS) o Jetpack Compose (Android). ArkTS è un linguaggio di sviluppo basato su TypeScript con tipizzazione statica aggiuntiva e integrazione con ArkUI tramite i decorator @Component, @State, @Prop, @Link.

Concetti fondamentali di ArkTS

ArkTS estende TypeScript con l'armonizzazione del framework UI: @Component — decorator per dichiarare un componente UI, build() — metodo obbligatorio che restituisce un albero di elementi UI, @State — variabile reattiva i cui cambiamenti ridisegnano automaticamente il componente, @Prop — proprietà di input dal genitore, @Link — binding bidirezionale. Tutti i componenti ArkUI utilizzano una sintassi a catena con modificatori (.width, .height, .backgroundColor).

// ArkTS — schermata del profilo utente su 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("Errore di caricamento", 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("Modifica", {
                            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%');
    }
}

// Punto di ingresso dell'applicazione
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Apri editor del profilo");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

Il componente ProfileScreen in ArkTS dimostra: @State per variabili reattive, @Prop per callback di input, Column/Stack/Text/Image/Button come componenti UI di base, caricamento asincrono dei dati tramite async/await. LoadingProgress viene visualizzato durante il caricamento. Tutte le dimensioni sono specificate in vp (pixel virtuali) — unità adattive simili a pt in iOS o dp in Android.

Adattamento per diversi dispositivi

ArkUI supporta il design responsive tramite un sistema di Breakpoint (xs, sm, md, lg, xl) corrispondenti alla larghezza dello schermo. I componenti si riorganizzano automaticamente quando si passa dal telefono al tablet o all'orologio. GridRow e GridCol sono contenitori adattivi che cambiano il numero di colonne in base al breakpoint. Unità di dimensione: vp (pixel virtuali), fp (pixel di carattere — si adattano alle impostazioni del carattere), lpx (pixel logici per orologi).

DevEco Studio e strumenti di sviluppo

DevEco Studio è l'ambiente di sviluppo integrato (IDE) ufficiale per HarmonyOS, basato su IntelliJ IDEA Community Edition. Include un editor di codice con supporto per ArkTS e C++, un editor visivo ArkUI (drag-and-drop), un emulatore di dispositivi HarmonyOS, Preview per la visualizzazione istantanea dell'UI e Profiler per l'analisi delle prestazioni.

Emulatore HarmonyOS

DevEco Studio include un emulatore basato su QEMU, che supporta smartphone (varie dimensioni dello schermo), tablet, orologi e televisori. L'emulatore simula un ambiente distribuito: è possibile eseguire più dispositivi virtuali e testare l'interazione cross-dispositivo. L'emulatore richiede virtualizzazione (Hyper-V su Windows, KVM su Linux).

Preview e Live Preview

ArkUI Preview è una funzione di visualizzazione istantanea dell'UI senza compilazione o avvio dell'emulatore. Le modifiche al codice appaiono in Preview entro 1-2 secondi. Tutti i componenti e le animazioni standard sono supportati. Preview funziona con diversi breakpoint per testare l'adattabilità. Live Preview si connette a un dispositivo reale tramite USB o Wi-Fi per test su hardware reale.

HarmonyOS SDK e API

L'SDK di HarmonyOS include: ArkUI (componenti UI), Multimedia Kit (acquisizione e riproduzione audio/video), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolocalizzazione), Sensor Kit (sensori), AI Kit (ML Kit con inferenza su dispositivo su NPU Huawei). Versioni API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Inizializzazione della fotocamera su HarmonyOS tramite 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 {
            // Richiesta autorizzazione fotocamera
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Ottenimento fotocamera (0 — posteriore, 1 — anteriore)
            const camera = await this.cameraManager.getCamera(0);

            // Creazione input fotocamera
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Avvio anteprima su 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;
    }
}

Il componente CameraView dimostra il lavoro con Multimedia Kit: richiesta di autorizzazione tramite Permissions.request, ottenimento della fotocamera tramite CameraManager, creazione di CameraInput e PreviewOutput. ArkUI Surface (tramite XComponent) visualizza il flusso video. Tutte le operazioni sono asincrone con gestione degli errori tramite try/catch.

Applicazioni distribuite e cross-dispositivo

L'architettura distribuita di HarmonyOS è la principale differenza rispetto ai concorrenti. Un'applicazione può essere composta da più servizi atomici (Atomic Services), ciascuno in esecuzione sul dispositivo ottimale. L'utente inizia un'attività su un dispositivo e continua su un altro senza perdere il contesto.

Atomic Services e Ability

Atomic Service è l'unità di distribuzione minima su HarmonyOS. Ogni servizio implementa una o più Ability (analogo ad Activity in Android). Page Ability — uno schermo con UI, Service Ability — un'attività in background, Data Ability — accesso ai dati. Un'applicazione può delegare un Ability a un altro dispositivo: ad esempio, l'UI viene visualizzata sul tablet mentre l'elaborazione AI viene eseguita su un telefono con NPU.

Gestione dei dati distribuiti

Il sistema di gestione dei dati distribuiti (DDM) sincronizza lo stato dell'applicazione tra i dispositivi. DDM utilizza oggetti di dati distribuiti — oggetti reattivi che si replicano automaticamente su tutti i dispositivi dell'utente. Le modifiche ai dati su un dispositivo vengono immediatamente riflesse su tutti gli altri. DDM supporta la crittografia e tiene conto della connessione di rete (Bluetooth, Wi-Fi, dati cellulari).

Super Device

Super Device — una funzionalità di HarmonyOS che consente di unire fino a 7 dispositivi Huawei in un unico ambiente di elaborazione. L'utente trascina le icone dei dispositivi nell'interfaccia Super Device: gli altoparlanti diventano uscita audio, il tablet diventa un secondo schermo, l'orologio diventa un monitor per la frequenza cardiaca per un'app fitness sul telefono. Tutti i dispositivi si sincronizzano tramite un bus distribuito (Distributed Bus) con una latenza inferiore a 5 ms.

AppGallery e pubblicazione di applicazioni

Huawei AppGallery è il negozio ufficiale di applicazioni HarmonyOS, il terzo più grande al mondo dopo Google Play e App Store. Secondo Huawei (2026), AppGallery conta oltre 580 milioni di utenti attivi mensili. La registrazione dello sviluppatore è gratuita per i privati (a differenza dei 99 $ di Apple).

Processo di pubblicazione

Lo sviluppatore compila l'applicazione in DevEco Studio (formato .hap — HarmonyOS Ability Package). Pubblicazione tramite AppGallery Connect: caricare il file HAP, compilare la descrizione (nome, icona, screenshot), configurare il modello di prezzo. Il tempo medio di moderazione è di 1-3 giorni lavorativi. Huawei verifica la sicurezza (analisi statica), la compatibilità API e la conformità alle politiche.

Monetizzazione

AppGallery supporta: applicazioni a pagamento (commissione Huawei 15-30%), abbonamenti (commissione 15%), pubblicità tramite Huawei Ads Kit e acquisti in-app tramite IAP Kit. Huawei Pay è un gateway di pagamento per il mercato cinese che supporta Alipay e WeChat Pay. Gli sviluppatori internazionali ricevono pagamenti tramite PayPal o bonifico bancario.

Huawei Mobile Services (HMS)

HMS Core è un insieme di servizi che sostituiscono Google Play Services sui dispositivi Huawei senza Google. Include: Push Kit (notifiche push), Map Kit (mappe con navigazione), Location Kit (geolocalizzazione), Ads Kit (pubblicità), Analytics Kit (analisi), Account Kit (autorizzazione tramite Huawei ID). HMS Core è disponibile su dispositivi con HarmonyOS e su dispositivi Android Huawei (tramite AppGallery).