HarmonyOS: คืออะไร สถาปัตยกรรมระบบ และการพัฒนาบน ArkUI

HarmonyOS คืออะไร?

HarmonyOS คือระบบปฏิบัติการแบบกระจายที่พัฒนาโดย Huawei และประกาศครั้งแรกในปี 2019 เพื่อตอบสนองต่อข้อจำกัดการเข้าถึงบริการ Google บนอุปกรณ์ใหม่ของบริษัท HarmonyOS สร้างขึ้นบนไมโครเคอร์เนลของตัวเอง ซึ่งแตกต่างจาก Linux และถูกออกแบบมาเพื่อการทำงานที่ราบรื่นระหว่างอุปกรณ์: สมาร์ทโฟน แท็บเล็ต นาฬิกาอัจฉริยะ โทรทัศน์ ระบบยานยนต์ และอุปกรณ์ IoT

ตามข้อมูลของ Huawei (รายงานระบบนิเวศ HarmonyOS, 2026) ระบบติดตั้งบนอุปกรณ์มากกว่า 700 ล้านเครื่อง รวมถึงสมาร์ทโฟน 300 ล้านเครื่อง ตลาดจีนคิดเป็น 95% ของการติดตั้ง ตั้งแต่ HarmonyOS 5.0 (NEXT, 2024) ระบบได้ละทิ้งความเข้ากันได้กับ Android AOSP โดยสมบูรณ์ — แอปพลิเคชันทั้งหมดต้องเขียนด้วย ArkTS หรือ C++ โดยใช้ ArkUI

คุณสมบัติหลักของ HarmonyOS คือสถาปัตยกรรมแบบกระจาย: แอปพลิเคชันสามารถทำงานบนหลายอุปกรณ์พร้อมกัน โดยย้ายอินเทอร์เฟซระหว่างหน้าจอ ตัวอย่างเช่น ผู้ใช้เริ่มนำทางบนโทรศัพท์ในขณะที่อินเทอร์เฟซแสดงบนหน้าจอรถ — โดยไม่ต้องคอมไพล์ใหม่หรือโค้ดเพิ่มเติม

ประวัติเวอร์ชัน HarmonyOS

HarmonyOS 1.0 (2019) — เวอร์ชันแรกสำหรับ Smart Screen ไม่ใช่สำหรับสมาร์ทโฟน HarmonyOS 2.0 (2021) — เปิดสำหรับสมาร์ทโฟน แท็บเล็ต และนาฬิกา รองรับแอปพลิเคชัน AOSP HarmonyOS 3.0 (2022) — สถาปัตยกรรมแบบกระจายที่ปรับปรุงแล้ว Super Device, Multiscreen Collaboration HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, ประสิทธิภาพที่ปรับปรุงแล้ว HarmonyOS NEXT (5.0, 2024) — การละทิ้ง AOSP โดยสมบูรณ์, เฉพาะแอปพลิเคชัน HarmonyOS ดั้งเดิม

สถาปัตยกรรม HarmonyOS: ไมโครเคอร์เนลแบบกระจาย

สถาปัตยกรรม HarmonyOS แตกต่างโดยพื้นฐานจาก Android และ iOS แทนที่เคอร์เนล Linux แบบเสาหิน HarmonyOS ใช้ไมโครเคอร์เนลของตัวเอง ซึ่งใช้ชุดฟังก์ชันที่มีสิทธิพิเศษน้อยที่สุด: การจัดการหน่วยความจำ การจัดตารางกระบวนการ และการสื่อสารระหว่างกระบวนการ บริการอื่น ๆ ทั้งหมดทำงานในพื้นที่ผู้ใช้

ไมโครเคอร์เนลและความปลอดภัย

ไมโครเคอร์เนลของ HarmonyOS ประกอบด้วยโค้ดประมาณ 10,000 บรรทัด (เคอร์เนล Linux มีมากกว่า 20 ล้านบรรทัด) ฐานโค้ดที่เล็กกว่าหมายถึงพื้นผิวการโจมตีที่เล็กกว่า ระบบใช้ การตรวจสอบอย่างเป็นทางการ — การพิสูจน์ทางคณิตศาสตร์ของความถูกต้องของโค้ดเคอร์เนล HarmonyOS รองรับ Trusted Execution Environment (TEE) ในระดับฮาร์ดแวร์สำหรับไบโอเมตริกซ์ การชำระเงิน และคีย์การเข้ารหัส การสื่อสารระหว่างกระบวนการดำเนินการผ่าน IPC ซึ่งมีประสิทธิภาพมากกว่า Binder ใน Android ถึง 5 เท่า

สถาปัตยกรรมสี่ชั้น

สถาปัตยกรรม HarmonyOS ประกอบด้วยสี่ชั้น: Kernel Subsystem (ไมโครเคอร์เนล + ไดรเวอร์), System Service Layer (บริการระบบ: ข้อมูลแบบกระจาย, ระบบไฟล์, ความปลอดภัย), Framework Layer (ArkUI, มัลติมีเดีย, โทรศัพท์, บริการ AI), Application Layer (แอปพลิเคชันผู้ใช้) แต่ละชั้นถูกแยกจากชั้นด้านล่างผ่าน IPC

ระบบไฟล์แบบกระจาย

HarmonyOS จัดให้มี ระบบไฟล์แบบกระจาย (DFS) ที่รวมพื้นที่เก็บข้อมูลของอุปกรณ์ผู้ใช้ทั้งหมดเป็นพื้นที่เสมือนเดียว แอปพลิเคชันเข้าถึงไฟล์โดย URI โดยไม่ต้องระบุอุปกรณ์ — ระบบจะกำหนดเส้นทางคำขอไปยังอุปกรณ์ที่จัดเก็บไฟล์จริง DFS รองรับการเข้ารหัสแบบครบวงจรและการจำลองข้อมูลที่ใช้บ่อยโดยอัตโนมัติ

// การทำงานกับระบบไฟล์แบบกระจายของ HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// การรับ URI ไฟล์บนอุปกรณ์แบบกระจาย
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;  // พบไฟล์บนอุปกรณ์ใดอุปกรณ์หนึ่ง
        }
    }
    return Uri::Empty();
}

// การอ่านข้อมูลจากอุปกรณ์ระยะไกล
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);
}

ในตัวอย่าง DistributedFileManager ค้นหาไฟล์บนอุปกรณ์ออนไลน์ทั้งหมดของผู้ใช้และส่งคืน URI แบบกระจาย DistributedFile เปิดไฟล์จริงบนอุปกรณ์ระยะไกลผ่าน IPC อย่างโปร่งใสสำหรับแอปพลิเคชัน นักพัฒนาไม่จำเป็นต้องรู้ว่าข้อมูลถูกเก็บไว้ที่ไหน — ระบบจะกำหนดเส้นทางคำขอโดยอัตโนมัติ

ArkUI และ ArkTS: การพัฒนาอินเทอร์เฟซ

ArkUI คือเฟรมเวิร์ก UI แบบประกาศของ HarmonyOS ที่พัฒนาโดย Huawei อินเทอร์เฟซถูกอธิบายเป็นลำดับชั้นของส่วนประกอบที่มีการผูกข้อมูลแบบตอบสนอง คล้ายกับ SwiftUI (iOS) หรือ Jetpack Compose (Android) ArkTS คือภาษาการพัฒนาบนพื้นฐาน TypeScript พร้อมการพิมพ์แบบสแตติกเพิ่มเติมและการรวมกับ ArkUI ผ่านดีคอเรเตอร์ @Component, @State, @Prop, @Link

แนวคิดหลักของ ArkTS

ArkTS ขยาย TypeScript ด้วยการประสานกับเฟรมเวิร์ก UI: @Component — ดีคอเรเตอร์สำหรับประกาศส่วนประกอบ UI, build() — เมธอดที่จำเป็นซึ่งส่งคืนแผนภูมิขององค์ประกอบ UI, @State — ตัวแปรแบบตอบสนองที่การเปลี่ยนแปลงจะวาดส่วนประกอบใหม่โดยอัตโนมัติ, @Prop — คุณสมบัติอินพุตจากพาเรนต์, @Link — การผูกสองทาง ส่วนประกอบ ArkUI ทั้งหมดใช้ไวยากรณ์แบบลูกโซ่กับตัวปรับแต่ง (.width, .height, .backgroundColor)

// ArkTS — หน้าจอโปรไฟล์ผู้ใช้บน ArkUI
@Component
struct ProfileScreen {
    @State userName: string = "อันนา เปโตรวา";
    @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);
        } 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("แก้ไข", {
                            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
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("เปิดตัวแก้ไขโปรไฟล์");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

ส่วนประกอบ ProfileScreen ใน ArkTS แสดงให้เห็น: @State สำหรับตัวแปรแบบตอบสนอง, @Prop สำหรับ callback อินพุต, Column/Stack/Text/Image/Button เป็นส่วนประกอบ UI พื้นฐาน, การโหลดข้อมูลแบบอะซิงโครนัสผ่าน async/await LoadingProgress จะแสดงระหว่างการโหลด ขนาดทั้งหมดระบุเป็น vp (พิกเซลเสมือน) — หน่วยปรับตัวคล้าย pt ใน iOS หรือ dp ใน Android

การปรับให้เข้ากับอุปกรณ์ต่าง ๆ

ArkUI รองรับการออกแบบที่ตอบสนองผ่านระบบ จุดแบ่ง (xs, sm, md, lg, xl) ที่สอดคล้องกับความกว้างหน้าจอ ส่วนประกอบจะจัดเรียงใหม่โดยอัตโนมัติเมื่อเปลี่ยนจากโทรศัพท์เป็นแท็บเล็ตหรือนาฬิกา GridRow และ GridCol เป็นคอนเทนเนอร์ปรับตัวที่เปลี่ยนจำนวนคอลัมน์ตามจุดแบ่ง หน่วยขนาด: vp (พิกเซลเสมือน), fp (พิกเซลฟอนต์ — ปรับตามการตั้งค่าฟอนต์), lpx (พิกเซลเชิงตรรกะสำหรับนาฬิกา)

DevEco Studio และเครื่องมือพัฒนา

DevEco Studio คือสภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) อย่างเป็นทางการสำหรับ HarmonyOS บนพื้นฐาน IntelliJ IDEA Community Edition ประกอบด้วยตัวแก้ไขโค้ดที่รองรับ ArkTS และ C++, ตัวแก้ไข ArkUI แบบภาพ (ลากและวาง), อีมูเลเตอร์อุปกรณ์ HarmonyOS, Preview สำหรับการดู UI ทันที และ Profiler สำหรับการวิเคราะห์ประสิทธิภาพ

อีมูเลเตอร์ HarmonyOS

DevEco Studio มีอีมูเลเตอร์บนพื้นฐาน QEMU รองรับสมาร์ทโฟน (ขนาดหน้าจอต่าง ๆ), แท็บเล็ต, นาฬิกา และโทรทัศน์ อีมูเลเตอร์จำลองสภาพแวดล้อมแบบกระจาย: คุณสามารถเรียกใช้อุปกรณ์เสมือนหลายเครื่องและทดสอบการโต้ตอบข้ามอุปกรณ์ อีมูเลเตอร์ต้องการการจำลองเสมือน (Hyper-V บน Windows, KVM บน Linux)

Preview และ Live Preview

ArkUI Preview คือคุณสมบัติการดู UI ทันทีโดยไม่ต้องสร้างหรือเริ่มอีมูเลเตอร์ การเปลี่ยนแปลงโค้ดปรากฏใน Preview ภายใน 1-2 วินาที ส่วนประกอบและแอนิเมชันมาตรฐานทั้งหมดรองรับ Preview ทำงานกับจุดแบ่งต่าง ๆ เพื่อทดสอบการปรับตัว Live Preview เชื่อมต่อกับอุปกรณ์จริงผ่าน USB หรือ Wi-Fi เพื่อทดสอบบนฮาร์ดแวร์จริง

HarmonyOS SDK และ API

HarmonyOS SDK ประกอบด้วย: ArkUI (ส่วนประกอบ UI), Multimedia Kit (การจับและเล่นเสียง/วิดีโอ), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (ตำแหน่งทางภูมิศาสตร์), Sensor Kit (เซนเซอร์), AI Kit (ML Kit พร้อมการอนุมานบนอุปกรณ์บน NPU ของ Huawei) เวอร์ชัน API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT)

// การเริ่มต้นกล้องบน HarmonyOS ผ่าน 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 {
            // การขอสิทธิ์กล้อง
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // การรับกล้อง (0 — หลัง, 1 — หน้า)
            const camera = await this.cameraManager.getCamera(0);

            // การสร้างอินพุตกล้อง
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // การเริ่มพรีวิวบน 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;
    }
}

ส่วนประกอบ CameraView แสดงการทำงานกับ Multimedia Kit: การขอสิทธิ์ผ่าน Permissions.request, การรับกล้องผ่าน CameraManager, การสร้าง CameraInput และ PreviewOutput ArkUI Surface (ผ่าน XComponent) แสดงสตรีมวิดีโอ การดำเนินการทั้งหมดเป็นแบบอะซิงโครนัสพร้อมการจัดการข้อผิดพลาดผ่าน try/catch

แอปพลิเคชันแบบกระจายและข้ามอุปกรณ์

สถาปัตยกรรมแบบกระจาย ของ HarmonyOS คือความแตกต่างหลักจากคู่แข่ง แอปพลิเคชันสามารถประกอบด้วยบริการอะตอมมิกหลายรายการ (Atomic Services) ซึ่งแต่ละรายการทำงานบนอุปกรณ์ที่เหมาะสมที่สุด ผู้ใช้เริ่มงานบนอุปกรณ์หนึ่งและดำเนินการต่อบนอีกอุปกรณ์หนึ่งโดยไม่สูญเสียบริบท

Atomic Services และ Ability

Atomic Service คือหน่วยการปรับใช้ขั้นต่ำบน HarmonyOS แต่ละบริการใช้หนึ่งหรือมากกว่า Ability (คล้ายกับ Activity ใน Android) Page Ability — หน้าจอพร้อม UI, Service Ability — งานพื้นหลัง, Data Ability — การเข้าถึงข้อมูล แอปพลิเคชันสามารถมอบหมาย Ability ให้กับอุปกรณ์อื่น: ตัวอย่างเช่น UI แสดงบนแท็บเล็ตในขณะที่การประมวลผล AI ทำงานบนโทรศัพท์ที่มี NPU

การจัดการข้อมูลแบบกระจาย

ระบบการจัดการข้อมูลแบบกระจาย (DDM) ซิงโครไนซ์สถานะแอปพลิเคชันระหว่างอุปกรณ์ DDM ใช้ ออบเจ็กต์ข้อมูลแบบกระจาย — ออบเจ็กต์แบบตอบสนองที่จำลองแบบโดยอัตโนมัติบนอุปกรณ์ผู้ใช้ทั้งหมด การเปลี่ยนแปลงข้อมูลบนอุปกรณ์หนึ่งจะสะท้อนทันทีบนอุปกรณ์อื่นทั้งหมด DDM รองรับการเข้ารหัสและพิจารณาการเชื่อมต่อเครือข่าย (Bluetooth, Wi-Fi, ข้อมูลเซลลูลาร์)

Super Device

Super Device — คุณสมบัติ HarmonyOS ที่อนุญาตให้รวมอุปกรณ์ Huawei สูงสุด 7 เครื่องเป็นสภาพแวดล้อมการคำนวณเดียว ผู้ใช้ลากไอคอนอุปกรณ์ในอินเทอร์เฟซ Super Device: ลำโพงกลายเป็นเอาต์พุตเสียง, แท็บเล็ตกลายเป็นหน้าจอที่สอง, นาฬิกากลายเป็นเครื่องวัดอัตราการเต้นของหัวใจสำหรับแอปฟิตเนสบนโทรศัพท์ อุปกรณ์ทั้งหมดซิงโครไนซ์ผ่าน Distributed Bus ด้วยความหน่วงน้อยกว่า 5 มิลลิวินาที

AppGallery และการเผยแพร่แอปพลิเคชัน

Huawei AppGallery คือร้านค้าแอปพลิเคชันอย่างเป็นทางการของ HarmonyOS ซึ่งใหญ่เป็นอันดับสามของโลกรองจาก Google Play และ App Store ตามข้อมูลของ Huawei (2026) AppGallery มีผู้ใช้ที่ใช้งานรายเดือนมากกว่า 580 ล้านคน การลงทะเบียนนักพัฒนาฟรีสำหรับบุคคลทั่วไป (แตกต่างจาก $99 ของ Apple)

กระบวนการเผยแพร่

นักพัฒนาสร้างแอปพลิเคชันใน DevEco Studio (รูปแบบ .hap — HarmonyOS Ability Package) การเผยแพร่ผ่าน AppGallery Connect: อัปโหลดไฟล์ HAP, กรอกคำอธิบาย (ชื่อ, ไอคอน, ภาพหน้าจอ), กำหนดค่ารูปแบบราคา เวลาการตรวจสอบโดยเฉลี่ยคือ 1-3 วันทำการ Huawei ตรวจสอบความปลอดภัย (การวิเคราะห์แบบสแตติก), ความเข้ากันได้กับ API และการปฏิบัติตามนโยบาย

การสร้างรายได้

AppGallery รองรับ: แอปพลิเคชันแบบชำระเงิน (ค่าคอมมิชชัน Huawei 15-30%), การสมัครสมาชิก (ค่าคอมมิชชัน 15%), การโฆษณาผ่าน Huawei Ads Kit และการซื้อในแอปผ่าน IAP Kit Huawei Pay คือเกตเวย์การชำระเงินสำหรับตลาดจีนที่รองรับ Alipay และ WeChat Pay นักพัฒนาต่างประเทศได้รับการชำระเงินผ่าน PayPal หรือการโอนเงินผ่านธนาคาร

Huawei Mobile Services (HMS)

HMS Core คือชุดบริการที่แทนที่ Google Play Services บนอุปกรณ์ Huawei ที่ไม่มี Google ประกอบด้วย: Push Kit (การแจ้งเตือนแบบพุช), Map Kit (แผนที่พร้อมการนำทาง), Location Kit (ตำแหน่งทางภูมิศาสตร์), Ads Kit (การโฆษณา), Analytics Kit (การวิเคราะห์), Account Kit (การอนุญาตผ่าน Huawei ID) HMS Core พร้อมใช้งานบนอุปกรณ์ที่ใช้ HarmonyOS และอุปกรณ์ Android ของ Huawei (ผ่าน AppGallery)