HarmonyOS: o que é, arquitetura do sistema e desenvolvimento no ArkUI

O que é HarmonyOS?

HarmonyOS é um sistema operacional distribuído desenvolvido pela Huawei e anunciado pela primeira vez em 2019 como resposta à restrição de acesso aos serviços do Google em novos dispositivos da empresa. O HarmonyOS é construído em seu próprio micronúcleo, diferente do Linux, e é projetado para operação perfeita entre dispositivos: smartphones, tablets, smartwatches, televisores, sistemas automotivos e dispositivos IoT.

De acordo com a Huawei (Relatório do Ecossistema HarmonyOS, 2026), o sistema está instalado em mais de 700 milhões de dispositivos, incluindo 300 milhões de smartphones. O mercado chinês representa 95% das instalações. A partir do HarmonyOS 5.0 (NEXT, 2024), o sistema abandonou completamente a compatibilidade com Android AOSP — todas as aplicações devem ser escritas em ArkTS ou C++ usando ArkUI.

A principal característica do HarmonyOS é sua arquitetura distribuída: uma aplicação pode ser executada em vários dispositivos simultaneamente, movendo a interface entre telas. Por exemplo, um usuário inicia a navegação no telefone enquanto a interface é exibida na tela do carro — sem recompilação ou código adicional.

Histórico de versões do HarmonyOS

HarmonyOS 1.0 (2019) — primeira versão para Smart Screen, não para smartphones. HarmonyOS 2.0 (2021) — aberto para smartphones, tablets e relógios, suporte a aplicações AOSP. HarmonyOS 3.0 (2022) — arquitetura distribuída melhorada, Super Device, Multiscreen Collaboration. HarmonyOS 4.0 (2023) — ArkUI 3.0, Live View, desempenho melhorado. HarmonyOS NEXT (5.0, 2024) — abandono completo do AOSP, apenas aplicações nativas do HarmonyOS.

Arquitetura do HarmonyOS: micronúcleo distribuído

A arquitetura do HarmonyOS é fundamentalmente diferente do Android e iOS. Em vez do núcleo monolítico Linux, o HarmonyOS usa seu próprio micronúcleo, implementando um conjunto mínimo de funções privilegiadas: gerenciamento de memória, agendamento de processos e comunicação entre processos. Todos os outros serviços são executados no espaço do usuário.

Micronúcleo e segurança

O micronúcleo do HarmonyOS compreende cerca de 10.000 linhas de código (o núcleo Linux tem mais de 20 milhões). Uma base de código menor significa uma superfície de ataque menor. O sistema usa verificação formal — prova matemática da correção do código do núcleo. O HarmonyOS suporta Trusted Execution Environment (TEE) em nível de hardware para biometria, pagamentos e chaves de criptografia. A comunicação entre processos é implementada via IPC, 5 vezes mais performático que o Binder no Android.

Quatro camadas de arquitetura

A arquitetura do HarmonyOS consiste em quatro camadas: Kernel Subsystem (micronúcleo + drivers), System Service Layer (serviços do sistema: dados distribuídos, sistema de arquivos, segurança), Framework Layer (ArkUI, multimídia, telefonia, serviços de IA) e Application Layer (aplicações do usuário). Cada camada é isolada da camada inferior via IPC.

Sistema de arquivos distribuído

O HarmonyOS fornece um Sistema de Arquivos Distribuído (DFS) que unifica o armazenamento de todos os dispositivos do usuário em um único espaço virtual. Uma aplicação acessa arquivos por URI sem especificar um dispositivo — o sistema roteia a solicitação para o dispositivo onde o arquivo está fisicamente armazenado. O DFS suporta criptografia de ponta a ponta e replicação automática de dados usados com frequência.

// Trabalhando com o sistema de arquivos distribuído do HarmonyOS
#include <dfs/storage_manager.h>
#include <uri/uri_helper.h>

using namespace OHOS::Storage;

// Obtendo URI de arquivo em um dispositivo distribuído
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;  // Arquivo encontrado em um dos dispositivos
        }
    }
    return Uri::Empty();
}

// Lendo dados de um 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);
}

No exemplo, o DistributedFileManager procura um arquivo em todos os dispositivos online do usuário e retorna um URI distribuído. O DistributedFile abre fisicamente o arquivo no dispositivo remoto via IPC, de forma transparente para a aplicação. O desenvolvedor não precisa saber onde os dados estão armazenados — o sistema roteia a solicitação automaticamente.

ArkUI e ArkTS: desenvolvimento de interfaces

ArkUI é o framework UI declarativo do HarmonyOS desenvolvido pela Huawei. A interface é descrita como uma hierarquia de componentes com vinculação de dados reativa, semelhante ao SwiftUI (iOS) ou Jetpack Compose (Android). ArkTS é uma linguagem de desenvolvimento baseada em TypeScript com tipagem estática adicional e integração com ArkUI através dos decoradores @Component, @State, @Prop, @Link.

Conceitos principais do ArkTS

O ArkTS estende o TypeScript com harmonização do framework UI: @Component — decorador para declarar um componente UI, build() — método obrigatório que retorna uma árvore de elementos UI, @State — variável reativa cujas alterações redesenham automaticamente o componente, @Prop — propriedade de entrada do pai, @Link — vinculação bidirecional. Todos os componentes ArkUI usam sintaxe encadeada com modificadores (.width, .height, .backgroundColor).

// ArkTS — tela de perfil do usuário no 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("Erro de carregamento", 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%');
    }
}

// Ponto de entrada da aplicação
@Entry
@Component
struct MainApp {
    build(): void {
        Column() {
            ProfileScreen({
                onEditClick: () => {
                    console.info("Abrir editor de perfil");
                }
            });
        }
        .width('100%')
        .height('100%');
    }
}

O componente ProfileScreen em ArkTS demonstra: @State para variáveis reativas, @Prop para callback de entrada, Column/Stack/Text/Image/Button como componentes UI básicos, carregamento assíncrono de dados via async/await. O LoadingProgress é exibido durante o carregamento. Todos os tamanhos são especificados em vp (pixels virtuais) — unidades adaptativas semelhantes a pt no iOS ou dp no Android.

Adaptação para diferentes dispositivos

O ArkUI suporta design responsivo através de um sistema de Breakpoints (xs, sm, md, lg, xl) correspondentes à largura da tela. Os componentes são reorganizados automaticamente ao mudar do telefone para tablet ou relógio. GridRow e GridCol são contêineres adaptativos que alteram o número de colunas dependendo do breakpoint. Unidades de tamanho: vp (pixels virtuais), fp (pixels de fonte — escalam com as configurações de fonte), lpx (pixels lógicos para relógios).

DevEco Studio e ferramentas de desenvolvimento

DevEco Studio é o ambiente de desenvolvimento integrado (IDE) oficial para HarmonyOS, baseado no IntelliJ IDEA Community Edition. Inclui um editor de código com suporte a ArkTS e C++, um editor visual ArkUI (drag-and-drop), um emulador de dispositivos HarmonyOS, Preview para visualização instantânea da UI e Profiler para análise de desempenho.

Emulador do HarmonyOS

O DevEco Studio inclui um emulador baseado em QEMU, suportando smartphones (vários tamanhos de tela), tablets, relógios e televisores. O emulador simula um ambiente distribuído: você pode executar vários dispositivos virtuais e testar a interação entre dispositivos. O emulador requer virtualização (Hyper-V no Windows, KVM no Linux).

Preview e Live Preview

ArkUI Preview é um recurso de visualização instantânea da UI sem construir ou iniciar o emulador. As alterações no código aparecem no Preview em 1-2 segundos. Todos os componentes e animações padrão são suportados. O Preview funciona com diferentes breakpoints para testar a adaptabilidade. O Live Preview conecta-se a um dispositivo real via USB ou Wi-Fi para teste em hardware real.

HarmonyOS SDK e API

O SDK do HarmonyOS inclui: ArkUI (componentes UI), Multimedia Kit (captura e reprodução de áudio/vídeo), Connectivity Kit (Bluetooth, Wi-Fi, NFC), Location Kit (geolocalização), Sensor Kit (sensores), AI Kit (ML Kit com inferência no dispositivo na NPU da Huawei). Versões de API: API 9 (HarmonyOS 3.x), API 10 (4.x), API 11 (NEXT).

// Inicializando câmera no HarmonyOS via 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 {
            // Solicitando permissão da câmera
            const granted = await Permissions.request("ohos.permission.CAMERA");
            if (!granted) return;

            // Obtendo câmera (0 — traseira, 1 — frontal)
            const camera = await this.cameraManager.getCamera(0);

            // Criando entrada de câmera
            this.cameraInput = await this.cameraManager.createCameraInput(camera);
            await this.cameraInput.open();

            // Iniciando visualização no 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;
    }
}

O componente CameraView demonstra o trabalho com o Multimedia Kit: solicitação de permissão via Permissions.request, obtenção da câmera via CameraManager, criação de CameraInput e PreviewOutput. O ArkUI Surface (via XComponent) exibe o fluxo de vídeo. Todas as operações são assíncronas com tratamento de erros via try/catch.

Aplicações distribuídas e entre dispositivos

A arquitetura distribuída do HarmonyOS é a principal diferença dos concorrentes. Uma aplicação pode consistir em vários serviços atômicos (Atomic Services), cada um sendo executado no dispositivo ideal. O usuário inicia uma tarefa em um dispositivo e continua em outro sem perder o contexto.

Atomic Services e Ability

Atomic Service é a unidade mínima de implantação no HarmonyOS. Cada serviço implementa uma ou mais Ability (análogo ao Activity no Android). Page Ability — uma tela com UI, Service Ability — uma tarefa em segundo plano, Data Ability — acesso a dados. Uma aplicação pode delegar uma Ability para outro dispositivo: por exemplo, a UI é exibida no tablet enquanto o processamento de IA é executado no telefone com NPU.

Gerenciamento de Dados Distribuídos

O sistema de Gerenciamento de Dados Distribuídos (DDM) sincroniza o estado da aplicação entre dispositivos. O DDM usa Objetos de Dados Distribuídos — objetos reativos que se replicam automaticamente em todos os dispositivos do usuário. As alterações de dados em um dispositivo são refletidas instantaneamente em todos os outros. O DDM suporta criptografia e leva em consideração a conexão de rede (Bluetooth, Wi-Fi, dados móveis).

Super Device

Super Device — um recurso do HarmonyOS que permite unir até 7 dispositivos Huawei em um único ambiente computacional. O usuário arrasta ícones de dispositivos na interface do Super Device: os alto-falantes se tornam saída de áudio, o tablet se torna uma segunda tela, o relógio se torna um monitor de frequência cardíaca para um aplicativo de fitness no telefone. Todos os dispositivos sincronizam via Distributed Bus com latência inferior a 5 ms.

AppGallery e publicação de aplicações

Huawei AppGallery é a loja oficial de aplicativos do HarmonyOS, a terceira maior do mundo depois da Google Play e App Store. De acordo com a Huawei (2026), a AppGallery tem mais de 580 milhões de usuários ativos mensais. O registro de desenvolvedor é gratuito para pessoas físicas (ao contrário dos $99 da Apple).

Processo de publicação

O desenvolvedor compila a aplicação no DevEco Studio (formato .hap — HarmonyOS Ability Package). Publicação via AppGallery Connect: envie o arquivo HAP, preencha a descrição (nome, ícone, capturas de tela), configure o modelo de preços. O tempo médio de moderação é de 1 a 3 dias úteis. A Huawei verifica segurança (análise estática), compatibilidade com API e conformidade com políticas.

Monetização

A AppGallery suporta: aplicações pagas (comissão Huawei 15-30%), assinaturas (15% de comissão), publicidade via Huawei Ads Kit e compras no aplicativo via IAP Kit. O Huawei Pay é um gateway de pagamento para o mercado chinês que suporta Alipay e WeChat Pay. Desenvolvedores internacionais recebem pagamentos via PayPal ou transferência bancária.

Huawei Mobile Services (HMS)

HMS Core é um conjunto de serviços que substitui o Google Play Services em dispositivos Huawei sem Google. Inclui: Push Kit (notificações push), Map Kit (mapas com navegação), Location Kit (geolocalização), Ads Kit (publicidade), Analytics Kit (análises), Account Kit (autorização via Huawei ID). O HMS Core está disponível em dispositivos com HarmonyOS e em dispositivos Android da Huawei (via AppGallery).