HarmonyOS: ano ito, arkitektura ng sistema at pagpapaunlad sa ArkUI

Ano ang HarmonyOS?

HarmonyOS ay isang ipinamahaging operating system na binuo ng Huawei at unang inanunsyo noong 2019 bilang tugon sa paghihigpit ng pag-access sa mga serbisyo ng Google sa mga bagong device ng kumpanya. Ang HarmonyOS ay binuo sa sarili nitong microkernel, naiiba sa Linux, at dinisenyo para sa walang putol na operasyon sa pagitan ng mga device: smartphone, tablet, smartwatch, telebisyon, automotive system, at IoT device.

Ayon sa Huawei (HarmonyOS Ecosystem Report, 2026), ang sistema ay naka-install sa higit sa 700 milyong mga device, kabilang ang 300 milyong smartphone. Ang merkado ng Tsina ay bumubuo ng 95% ng mga pag-install. Simula sa HarmonyOS 5.0 (NEXT, 2024), ang sistema ay ganap na tinalikuran ang compatibility sa Android AOSP — lahat ng aplikasyon ay dapat isulat sa ArkTS o C++ gamit ang ArkUI.

Ang pangunahing tampok ng HarmonyOS ay ang ipinamahaging arkitektura nito: isang aplikasyon ay maaaring tumakbo sa maraming device nang sabay-sabay, inililipat ang interface sa pagitan ng mga screen. Halimbawa, ang isang user ay magsisimula ng nabigasyon sa telepono habang ang interface ay ipinapakita sa screen ng kotse — walang recompilation o karagdagang code.

Kasaysayan ng bersyon ng HarmonyOS

HarmonyOS 1.0 (2019) — unang bersyon para sa Smart Screen, hindi para sa smartphone. HarmonyOS 2.0 (2021) — binuksan para sa smartphone, tablet at relo, suporta para sa AOSP applications. HarmonyOS 3.0 (2022) — pinahusay na ipinamahaging arkitektura, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, pinahusay na performance. HarmonyOS NEXT (5.0, 2024) — ganap na pagtalikod sa AOSP, native HarmonyOS applications lamang.

Arkitektura ng HarmonyOS: ipinamahaging microkernel

Ang arkitektura ng HarmonyOS ay pangunahing naiiba sa Android at iOS. Sa halip na monolitikong Linux kernel, gumagamit ang HarmonyOS ng sarili nitong microkernel, na nagpapatupad ng minimal na hanay ng mga may pribilehiyong function: pamamahala ng memorya, pag-iiskedyul ng proseso, at inter-process communication. Lahat ng iba pang serbisyo ay tumatakbo sa user space.

Microkernel at seguridad

Ang HarmonyOS microkernel ay binubuo ng humigit-kumulang 10,000 linya ng code (ang Linux kernel ay may higit sa 20 milyon). Ang mas maliit na codebase ay nangangahulugan ng mas maliit na surface ng pag-atake. Ginagamit ng sistema ang pormal na beripikasyon — matematikal na patunay ng kawastuhan ng kernel code. Sinusuportahan ng HarmonyOS ang Trusted Execution Environment (TEE) sa antas ng hardware para sa biometrics, pagbabayad, at encryption key. Ang inter-process communication ay ipinatupad sa pamamagitan ng IPC, 5 beses na mas mahusay kaysa sa Binder sa Android.

Apat na layer ng arkitektura

Ang arkitektura ng HarmonyOS ay binubuo ng apat na layer: Kernel Subsystem (microkernel + driver), System Service Layer (mga serbisyo ng sistema: ipinamahaging data, file system, seguridad), Framework Layer (ArkUI, multimedia, teleponiya, AI services), at Application Layer (mga aplikasyon ng user). Ang bawat layer ay nakahiwalay mula sa ilalim na layer sa pamamagitan ng IPC.

Ipinamahaging file system

Ang HarmonyOS ay nagbibigay ng Ipinamahaging File System (DFS) na pinag-iisa ang storage ng lahat ng device ng user sa iisang virtual na espasyo. Ang isang aplikasyon ay umaakses sa mga file sa pamamagitan ng URI nang hindi tinutukoy ang device — iruruta ng sistema ang kahilingan sa device kung saan ang file ay pisikal na naka-imbak. Sinusuportahan ng DFS ang end-to-end encryption at awtomatikong replikasyon ng madalas gamitin na data.

// Pagtatrabaho sa ipinamahaging file system ng HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Pagkuha ng file URI sa isang ipinamahaging device
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;  // Natagpuan ang file sa isa sa mga device
        }
    }
    return Uri::Empty();
}

// Pagbabasa ng data mula sa malayong device
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);
}

Sa halimbawa, ang DistributedFileManager ay naghahanap ng file sa lahat ng online device ng user at nagbabalik ng ipinamahaging URI. Binubuksan ng DistributedFile ang file nang pisikal sa malayong device sa pamamagitan ng IPC, transparent para sa aplikasyon. Hindi kailangang malaman ng developer kung saan naka-imbak ang data — awtomatikong iruruta ng sistema ang kahilingan.

ArkUI at ArkTS: pagpapaunlad ng interface

ArkUI ay ang deklaratibong UI framework ng HarmonyOS na binuo ng Huawei. Ang interface ay inilalarawan bilang isang hierarchy ng mga component na may reaktibong data binding, katulad ng SwiftUI (iOS) o Jetpack Compose (Android). ArkTS ay isang wika ng pagpapaunlad batay sa TypeScript na may karagdagang static typing at integrasyon sa ArkUI sa pamamagitan ng mga dekorador na @Component, @State, @Prop, @Link.

Mga pangunahing konsepto ng ArkTS

Pinalalawak ng ArkTS ang TypeScript sa pamamagitan ng harmonisasyon sa UI framework: @Component — dekorador para sa pagdedeklara ng UI component, build() — mandatoryong pamamaraan na nagbabalik ng puno ng mga elemento ng UI, @State — reaktibong variable na ang mga pagbabago ay awtomatikong nagre-redraw ng component, @Prop — input property mula sa magulang, @Link — dalawang-direksyong binding. Lahat ng ArkUI component ay gumagamit ng chain syntax na may mga modifier (.width, .height, .backgroundColor).

// ArkTS — screen ng profile ng user sa 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("Error sa pag-load", 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("I-edit", {
                            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%');
    }
}

// Entry point ng aplikasyon
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Buksan ang editor ng profile");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

Ang ProfileScreen component sa ArkTS ay nagpapakita: @State para sa reaktibong variable, @Prop para sa input callback, Column/Stack/Text/Image/Button bilang mga pangunahing UI component, asynchronous na pag-load ng data sa pamamagitan ng async/await. Ang LoadingProgress ay ipinapakita habang naglo-load. Lahat ng sukat ay tinutukoy sa vp (virtual pixels) — mga adaptibong unit katulad ng pt sa iOS o dp sa Android.

Adaptasyon para sa iba't ibang device

Sinusuportahan ng ArkUI ang responsive na disenyo sa pamamagitan ng sistema ng Mga Breakpoint (xs, sm, md, lg, xl) na katumbas ng lapad ng screen. Ang mga component ay awtomatikong nagre-rearrange kapag lumilipat mula sa telepono patungo sa tablet o relo. Ang GridRow at GridCol ay mga adaptibong container na nagbabago ng bilang ng column depende sa breakpoint. Mga unit ng sukat: vp (virtual pixels), fp (font pixels — nag-scale sa mga setting ng font), lpx (lohikal na pixels para sa relo).

DevEco Studio at mga tool sa pagpapaunlad

DevEco Studio ay ang opisyal na integrated development environment (IDE) para sa HarmonyOS, batay sa IntelliJ IDEA Community Edition. Kabilang dito ang code editor na may suporta sa ArkTS at C++, visual ArkUI editor (drag-and-drop), HarmonyOS device emulator, Preview para sa instant na pagtingin ng UI, at Profiler para sa pagsusuri ng performance.

HarmonyOS emulator

Ang DevEco Studio ay may kasamang emulator batay sa QEMU, sumusuporta sa smartphone (iba't ibang laki ng screen), tablet, relo, at telebisyon. Ginagaya ng emulator ang isang ipinamahaging kapaligiran: maaari kang magpatakbo ng maraming virtual device at subukan ang cross-device na interaksyon. Ang emulator ay nangangailangan ng virtualization (Hyper-V sa Windows, KVM sa Linux).

Preview at Live Preview

ArkUI Preview ay isang tampok para sa instant na pagtingin ng UI nang walang pagbuo o pagsisimula ng emulator. Ang mga pagbabago sa code ay lilitaw sa Preview sa loob ng 1-2 segundo. Lahat ng standard na component at animation ay sinusuportahan. Ang Preview ay gumagana sa iba't ibang breakpoint para sa pagsubok ng kakayahang umangkop. Ang Live Preview ay kumokonekta sa isang tunay na device sa pamamagitan ng USB o Wi-Fi para sa pagsubok sa hardware.

HarmonyOS SDK at API

Ang HarmonyOS SDK ay may kasamang: ArkUI (UI components), Multimedia Kit (pagkuha at pag-playback ng audio/video), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolokasyon), Sensor Kit (sensor), AI Kit (ML Kit na may on-device na inferens sa NPU ng Huawei). Mga bersyon ng API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Pagsisimula ng camera sa HarmonyOS sa pamamagitan ng 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 {
            // Paghiling ng pahintulot sa camera
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Pagkuha ng camera (0 — likuran, 1 — harapan)
            const camera = await this.cameraManager.getCamera(0);

            // Paglikha ng input ng camera
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Pagsisimula ng preview sa Surface (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;
    }
}

Ang CameraView component ay nagpapakita ng pagtatrabaho sa Multimedia Kit: paghiling ng pahintulot sa pamamagitan ng Permissions.request, pagkuha ng camera sa pamamagitan ng CameraManager, paglikha ng CameraInput at PreviewOutput. Ang ArkUI Surface (sa pamamagitan ng XComponent) ay nagpapakita ng video stream. Lahat ng operasyon ay asynchronous na may paghawak ng error sa pamamagitan ng try/catch.

Ipinamahaging mga aplikasyon at cross-device

Ang ipinamahaging arkitektura ng HarmonyOS ay ang pangunahing pagkakaiba mula sa mga kakumpitensya. Ang isang aplikasyon ay maaaring binubuo ng maraming atomic na serbisyo (Atomic Services), bawat isa ay tumatakbo sa pinakamainam na device. Ang user ay nagsisimula ng gawain sa isang device at nagpapatuloy sa isa pa nang hindi nawawala ang konteksto.

Atomic Services at Ability

Ang Atomic Service ay ang pinakamaliit na unit ng deployment sa HarmonyOS. Ang bawat serbisyo ay nagpapatupad ng isa o higit pang Ability (kahalintulad ng Activity sa Android). Page Ability — isang screen na may UI, Service Ability — isang background na gawain, Data Ability — access sa data. Ang isang aplikasyon ay maaaring magdelegado ng Ability sa ibang device: halimbawa, ang UI ay ipinapakita sa tablet habang ang AI processing ay tumatakbo sa telepono na may NPU.

Pamamahagi ng Ipinamahaging Data

Ang sistema ng Pamamahagi ng Ipinamahaging Data (DDM) ay nagsi-sync ng estado ng aplikasyon sa pagitan ng mga device. Gumagamit ang DDM ng Ipinamahaging Data Object — mga reaktibong object na awtomatikong nagre-replicate sa lahat ng device ng user. Ang pagbabago ng data sa isang device ay agad na nasasalamin sa lahat ng iba pa. Sinusuportahan ng DDM ang encryption at isinasaalang-alang ang koneksyon sa network (Bluetooth, Wi-Fi, cellular data).

Super Device

Super Device — isang tampok ng HarmonyOS na nagpapahintulot na pagsamahin ang hanggang 7 Huawei device sa iisang computing environment. Kinakaladkad ng user ang mga icon ng device sa interface ng Super Device: ang mga speaker ay nagiging audio output, ang tablet ay nagiging pangalawang screen, ang relo ay nagiging heart rate monitor para sa fitness app sa telepono. Lahat ng device ay nagsi-sync sa pamamagitan ng Distributed Bus na may latency na mas mababa sa 5 ms.

AppGallery at pag-publish ng aplikasyon

Huawei AppGallery ay ang opisyal na app store ng HarmonyOS, ang ikatlong pinakamalaki sa mundo pagkatapos ng Google Play at App Store. Ayon sa Huawei (2026), ang AppGallery ay may higit sa 580 milyong buwanang aktibong user. Ang pagrerehistro ng developer ay libre para sa mga indibidwal (hindi katulad ng $99 ng Apple).

Proseso ng pag-publish

Binubuo ng developer ang aplikasyon sa DevEco Studio (.hap format — HarmonyOS Ability Package). Pag-publish sa pamamagitan ng AppGallery Connect: i-upload ang HAP file, punan ang paglalarawan (pangalan, icon, screenshot), i-configure ang modelo ng pagpepresyo. Ang average na oras ng moderasyon ay 1-3 araw ng trabaho. Sinusuri ng Huawei ang seguridad (static analysis), API compatibility, at pagsunod sa patakaran.

Monetisasyon

Sinusuportahan ng AppGallery: mga bayad na aplikasyon (komisyon ng Huawei 15-30%), subscription (15% komisyon), advertising sa pamamagitan ng Huawei Ads Kit at in-app purchases sa pamamagitan ng IAP Kit. Ang Huawei Pay ay isang payment gateway para sa merkado ng Tsina na sumusuporta sa Alipay at WeChat Pay. Ang mga internasyonal na developer ay tumatanggap ng mga pagbabayad sa pamamagitan ng PayPal o bank transfer.

Huawei Mobile Services (HMS)

Ang HMS Core ay isang hanay ng mga serbisyo na pumapalit sa Google Play Services sa mga Huawei device na walang Google. Kabilang dito: Push Kit (mga push notification), Map Kit (mga mapa na may nabigasyon), Location Kit (geolokasyon), Ads Kit (advertising), Analytics Kit (analytics), Account Kit (awtorisasyon sa pamamagitan ng Huawei ID). Ang HMS Core ay magagamit sa mga device na may HarmonyOS at sa Huawei Android device (sa pamamagitan ng AppGallery).