HarmonyOS: qué es, arquitectura del sistema y desarrollo en ArkUI

¿Qué es HarmonyOS?

HarmonyOS es un sistema operativo distribuido desarrollado por Huawei y anunciado por primera vez en 2019 como respuesta a la restricción de acceso a los servicios de Google en los nuevos dispositivos de la compañía. HarmonyOS está construido sobre su propio micronúcleo, diferente de Linux, y está diseñado para un funcionamiento fluido entre dispositivos: smartphones, tabletas, relojes inteligentes, televisores, sistemas automotrices y dispositivos IoT.

Según Huawei (HarmonyOS Ecosystem Report, 2026), el sistema está instalado en más de 700 millones de dispositivos, incluidos 300 millones de smartphones. El mercado chino representa el 95% de las instalaciones. A partir de HarmonyOS 5.0 (NEXT, 2024), el sistema ha abandonado por completo la compatibilidad con Android AOSP: todas las aplicaciones deben escribirse en ArkTS o C++ con ArkUI.

La característica clave de HarmonyOS es su arquitectura distribuida: una aplicación puede ejecutarse en múltiples dispositivos simultáneamente, moviendo la interfaz entre pantallas. Por ejemplo, un usuario inicia la navegación en un teléfono mientras la interfaz se muestra en la pantalla del coche, sin recompilación ni código adicional.

Historial de versiones de HarmonyOS

HarmonyOS 1.0 (2019) — primera versión para Smart Screen, no para smartphones. HarmonyOS 2.0 (2021) — abierta para smartphones, tabletas y relojes, soporte para aplicaciones AOSP. HarmonyOS 3.0 (2022) — arquitectura distribuida mejorada, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, rendimiento mejorado. HarmonyOS NEXT (5.0, 2024) — abandono completo de AOSP, solo aplicaciones nativas de HarmonyOS.

Arquitectura de HarmonyOS: micronúcleo distribuido

La arquitectura de HarmonyOS es fundamentalmente diferente de Android e iOS. En lugar del núcleo monolítico Linux, HarmonyOS utiliza su propio micronúcleo que implementa un conjunto mínimo de funciones privilegiadas: gestión de memoria, planificación de procesos y comunicación entre procesos. Todos los demás servicios se ejecutan en el espacio de usuario.

Micronúcleo y seguridad

El micronúcleo de HarmonyOS comprende alrededor de 10 000 líneas de código (el núcleo Linux tiene más de 20 millones). Una base de código más pequeña significa una superficie de ataque más reducida. El sistema utiliza verificación formal — demostración matemática de la corrección del código del núcleo. HarmonyOS admite Trusted Execution Environment (TEE) a nivel de hardware para biometría, pagos y claves de cifrado. La comunicación entre procesos se implementa mediante IPC, 5 veces más eficiente que Binder en Android.

Cuatro capas de arquitectura

La arquitectura de HarmonyOS consta de cuatro capas: Kernel Subsystem (micronúcleo + controladores), System Service Layer (servicios del sistema: datos distribuidos, sistema de archivos, seguridad), Framework Layer (ArkUI, multimedia, telefonía, servicios de IA) y Application Layer (aplicaciones de usuario). Cada capa está aislada de la capa inferior mediante IPC.

Sistema de archivos distribuido

HarmonyOS proporciona un Distributed File System (DFS) que unifica el almacenamiento de todos los dispositivos del usuario en un único espacio virtual. Una aplicación accede a los archivos por URI sin especificar un dispositivo: el sistema enruta la solicitud al dispositivo donde el archivo está almacenado físicamente. DFS admite cifrado de extremo a extremo y replicación automática de datos de uso frecuente.

// Trabajo con el sistema de archivos distribuido de HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Obtención de URI de archivo en un dispositivo distribuido
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;  // Archivo encontrado en uno de los dispositivos
        }
    }
    return Uri::Empty();
}

// Lectura de datos desde 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);
}

En el ejemplo, DistributedFileManager busca un archivo en todos los dispositivos en línea del usuario y devuelve un URI distribuido. DistributedFile abre físicamente el archivo en el dispositivo remoto a través de IPC, de forma transparente para la aplicación. El desarrollador no necesita saber dónde se almacenan los datos: el sistema enruta la solicitud automáticamente.

ArkUI y ArkTS: desarrollo de interfaces

ArkUI es el framework UI declarativo de HarmonyOS desarrollado por Huawei. La interfaz se describe como una jerarquía de componentes con vinculación de datos reactiva, similar a SwiftUI (iOS) o Jetpack Compose (Android). ArkTS es un lenguaje de desarrollo basado en TypeScript con tipado estático adicional e integración con ArkUI mediante decoradores @Component, @State, @Prop, @Link.

Conceptos básicos de ArkTS

ArkTS extiende TypeScript con armonización del framework UI: @Component — decorador para declarar un componente UI, build() — método obligatorio que devuelve un árbol de elementos UI, @State — variable reactiva cuyos cambios redibujan automáticamente el componente, @Prop — propiedad de entrada del padre, @Link — enlace bidireccional. Todos los componentes de ArkUI usan sintaxis encadenada con modificadores (.width, .height, .backgroundColor).

// ArkTS — pantalla de perfil de usuario en 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 de carga", 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("Editar", {
                            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 de entrada de la aplicación
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Abrir editor de perfil");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

El componente ProfileScreen en ArkTS demuestra: @State para variables reactivas, @Prop para callback de entrada, Column/Stack/Text/Image/Button como componentes UI básicos, carga asíncrona de datos mediante async/await. LoadingProgress se muestra durante la carga. Todos los tamaños se especifican en vp (píxeles virtuales), unidades adaptativas similares a pt en iOS o dp en Android.

Adaptación para diferentes dispositivos

ArkUI admite diseño responsivo mediante un sistema de Breakpoints (xs, sm, md, lg, xl) correspondientes al ancho de pantalla. Los componentes se reorganizan automáticamente al cambiar de teléfono a tableta o reloj. GridRow y GridCol son contenedores adaptativos que cambian el número de columnas según el breakpoint. Unidades de tamaño: vp (píxeles virtuales), fp (píxeles de fuente — se escalan con la configuración de fuente), lpx (píxeles lógicos para relojes).

DevEco Studio y herramientas de desarrollo

DevEco Studio es el entorno de desarrollo integrado (IDE) oficial para HarmonyOS, basado en IntelliJ IDEA Community Edition. Incluye un editor de código con soporte para ArkTS y C++, un editor visual de ArkUI (drag-and-drop), un emulador de dispositivos HarmonyOS, Preview para visualización instantánea de la UI y Profiler para análisis de rendimiento.

Emulador de HarmonyOS

DevEco Studio incluye un emulador basado en QEMU que admite smartphones (varios tamaños de pantalla), tabletas, relojes y televisores. El emulador simula un entorno distribuido: puede ejecutar múltiples dispositivos virtuales y probar la interacción entre dispositivos. El emulador requiere virtualización (Hyper-V en Windows, KVM en Linux).

Preview y Live Preview

ArkUI Preview es una función de visualización instantánea de la UI sin necesidad de compilar ni iniciar el emulador. Los cambios en el código aparecen en Preview en 1-2 segundos. Todos los componentes y animaciones estándar son compatibles. Preview funciona con diferentes breakpoints para probar la adaptabilidad. Live Preview se conecta a un dispositivo real mediante USB o Wi-Fi para pruebas en hardware real.

HarmonyOS SDK y API

El SDK de HarmonyOS incluye: ArkUI (componentes UI), Multimedia Kit (captura y reproducción de audio/vídeo), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolocalización), Sensor Kit (sensores), AI Kit (ML Kit con inferencia en dispositivo en NPU de Huawei). Versiones de API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Inicialización de cámara en HarmonyOS mediante 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 {
            // Solicitud de permiso de cámara
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Obtención de cámara (0 — trasera, 1 — frontal)
            const camera = await this.cameraManager.getCamera(0);

            // Creación de entrada de cámara
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Inicio de vista previa en 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;
    }
}

El componente CameraView demuestra el trabajo con Multimedia Kit: solicitud de permiso mediante Permissions.request, obtención de la cámara mediante CameraManager, creación de CameraInput y PreviewOutput. ArkUI Surface (a través de XComponent) muestra el flujo de vídeo. Todas las operaciones son asíncronas con manejo de errores mediante try/catch.

Aplicaciones distribuidas y entre dispositivos

La arquitectura distribuida de HarmonyOS es la principal diferencia frente a la competencia. Una aplicación puede consistir en múltiples servicios atómicos (Atomic Services), cada uno ejecutándose en el dispositivo óptimo. El usuario comienza una tarea en un dispositivo y continúa en otro sin perder contexto.

Atomic Services y Ability

Atomic Service es la unidad mínima de despliegue en HarmonyOS. Cada servicio implementa uno o más Ability (análogo a Activity en Android). Page Ability — una pantalla con UI, Service Ability — una tarea en segundo plano, Data Ability — acceso a datos. Una aplicación puede delegar un Ability a otro dispositivo: por ejemplo, la UI se muestra en una tableta mientras el procesamiento de IA se ejecuta en un teléfono con NPU.

Distributed Data Management

El sistema Distributed Data Management (DDM) sincroniza el estado de la aplicación entre dispositivos. DDM utiliza Distributed Data Objects — objetos reactivos que se replican automáticamente en todos los dispositivos del usuario. Los cambios de datos en un dispositivo se reflejan instantáneamente en todos los demás. DDM admite cifrado y tiene en cuenta la conexión de red (Bluetooth, Wi-Fi, datos móviles).

Super Device

Super Device es una función de HarmonyOS que permite unir hasta 7 dispositivos Huawei en un único entorno informático. El usuario arrastra iconos de dispositivos en la interfaz de Super Device: los altavoces se convierten en salida de audio, la tableta en una segunda pantalla, el reloj en un monitor de frecuencia cardíaca para una aplicación de fitness en el teléfono. Todos los dispositivos se sincronizan mediante un bus distribuido (Distributed Bus) con una latencia inferior a 5 ms.

AppGallery y publicación de aplicaciones

Huawei AppGallery es la tienda oficial de aplicaciones de HarmonyOS, la tercera más grande del mundo después de Google Play y App Store. Según Huawei (2026), AppGallery cuenta con más de 580 millones de usuarios activos mensuales. El registro de desarrollador es gratuito para personas físicas (a diferencia de los $99 de Apple).

Proceso de publicación

El desarrollador compila la aplicación en DevEco Studio (formato .hap — HarmonyOS Ability Package). Publicación a través de AppGallery Connect: cargar el archivo HAP, completar la descripción (nombre, icono, capturas de pantalla), configurar el modelo de precios. El tiempo medio de moderación es de 1 a 3 días hábiles. Huawei verifica la seguridad (análisis estático), la compatibilidad con API y el cumplimiento de políticas.

Monetización

AppGallery admite: aplicaciones de pago (comisión de Huawei 15-30%), suscripciones (comisión del 15%), publicidad a través de Huawei Ads Kit y compras integradas mediante IAP Kit. Huawei Pay es una pasarela de pago para el mercado chino que admite Alipay y WeChat Pay. Los desarrolladores internacionales reciben pagos a través de PayPal o transferencia bancaria.

Huawei Mobile Services (HMS)

HMS Core es un conjunto de servicios que reemplazan a Google Play Services en dispositivos Huawei sin Google. Incluye: Push Kit (notificaciones push), Map Kit (mapas con navegación), Location Kit (geolocalización), Ads Kit (publicidad), Analytics Kit (analítica), Account Kit (autorización mediante Huawei ID). HMS Core está disponible en dispositivos con HarmonyOS y en dispositivos Android de Huawei (a través de AppGallery).