KaiOS: o que é, arquitetura do sistema e aplicações web

O que é o KaiOS?

KaiOS é um sistema operativo móvel para telemóveis com teclado desenvolvido pela KaiOS Technologies. O sistema baseia-se no projeto de código aberto Boot to Gecko (B2G) da Mozilla, que foi originalmente criado como um substituto web para Android em dispositivos ultraeconómicos. O primeiro lançamento comercial foi em 2017 no telemóvel Reliance JioPhone na Índia.

De acordo com a Counterpoint Research (Q2 2025), o KaiOS detém 2,8% do mercado global de SO móveis, atrás do Android (72%) e iOS (27%), mas à frente de outras plataformas. Na Índia, a quota do KaiOS atinge os 14% graças ao programa JioPhone. O preço médio de um dispositivo KaiOS é de 20 a 30 dólares, tornando-o fundamental para mercados emergentes.

A principal característica do KaiOS é que todas as aplicações são aplicações web. O programador escreve código em HTML5, CSS e JavaScript, empacota-o num arquivo ZIP com um manifesto e publica-o no KaiStore. O sistema não suporta a instalação de ficheiros APK nativos — apenas Open Web Apps segundo a especificação W3C Widget.

Histórico de versões do KaiOS

KaiOS 2.5 (2018) — primeira versão estável com kernel Gecko 48, incluída no JioPhone 1. KaiOS 2.5.3 (2021) — suporte para Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, desempenho melhorado, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — otimização para 256 MB de RAM, nova Web API Audio Channel, segurança TLS 1.3 melhorada.

Arquitetura do KaiOS: kernel Linux e motor Gecko

A arquitetura do KaiOS é composta por três camadas principais: kernel Linux (Gonk), motor web Gecko e interface de utilizador Gaia. Gonk é a camada dependente de hardware, incluindo controladores, HAL (Hardware Abstraction Layer), pilha de modem RIL (Radio Interface Layer) e suporte de sensores. O bootloader, controladores e algumas bibliotecas são retirados do Android Open Source Project (AOSP).

Gonk — camada de hardware

Gonk fornece ao Gecko acesso ao hardware: câmara, Bluetooth, Wi-Fi, GPS, áudio, vibração, sensores. Ao contrário do Android, onde as aplicações são escritas para Dalvik/ART, no KaiOS as aplicações acedem ao hardware através de Web APIs traduzidas pelo Gecko para Gonk IPC. A interface de rádio (RIL) fornece 4G VoLTE, SMS, USSD e gestão de cartões SIM.

Gecko — motor web

O Gecko no KaiOS não é apenas um motor de navegador, mas um ambiente de execução completo para aplicações. Todas as aplicações HTML5 são executadas dentro do Gecko Process Manager, que isola cada aplicação num processo separado. O Gecko implementa a especificação W3C Widget Packaging e as extensões da Mozilla para acesso ao hardware. A versão do Gecko determina quais Web APIs estão disponíveis para o programador.

Gaia — interface de utilizador

Gaia é a interface web do próprio SO: ecrã de bloqueio, ecrã inicial (lançador), painel de notificações, marcador, contactos, cliente SMS. Todas as aplicações do sistema são as mesmas Open Web Apps. Um programador pode substituir a câmara ou o teclado padrão pela sua própria aplicação registando o manipulador de atividade correspondente no manifesto.

// Verificação de versão do KaiOS e disponibilidade de API
function checkKaiOSVersion() {
    const ua = navigator.userAgent;
    let version = 'unknown';

    if (ua.includes('KAIOS/2.5')) {
        version = '2.5';
    } else if (ua.includes('KAIOS/3')) {
        version = '3.0';
    }

    const features = {
        geolocation: 'geolocation' in navigator,
        vibration: 'vibrate' in navigator,
        mozMobileConnection: 'mozMobileConnection' in navigator,
        mozTelephony: 'mozTelephony' in navigator,
        mozSms: 'mozSms' in navigator,
        bluetooth: 'bluetooth' in navigator
    };

    return { version, features };
}

// Verificação de disponibilidade do Google Apps (apenas KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Uso de vibração com verificação de disponibilidade
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibração, pausa, vibração
    }
}

A função checkKaiOSVersion lê o User Agent para determinar a versão do KaiOS e verifica a disponibilidade das Web APIs principais. Na versão 2.5, estão disponíveis mozMobileConnection, mozTelephony, mozSms — ausentes em navegadores normais e exclusivos do KaiOS. A função triggerHapticFeedback usa a Vibration API com retrocompatibilidade.

Criação de uma aplicação para KaiOS: estrutura e manifesto

Uma aplicação KaiOS é um arquivo ZIP (formato .zip, não .apk) contendo ficheiros HTML, CSS, JavaScript, imagens e um manifesto. A estrutura mínima da aplicação inclui manifest.webapp (descrição da aplicação), index.html (ponto de entrada), style.css e icon.png (ícone quadrado de 90×90 píxeis). O manifesto segue a especificação W3C Manifest for Web Apps.

Manifesto manifest.webapp

O ficheiro manifest.webapp é o ficheiro de configuração raiz de uma aplicação KaiOS. Campos obrigatórios: name (nome), description (descrição até 140 caracteres), launch_path (caminho para index.html), icons (tamanhos de ícone 30×30, 60×60, 90×90, 120×120). O campo type: 'certified' (aplicações de sistema), 'privileged' (acesso a Web API), 'web' (sem permissões especiais). As permissões para aplicações privileged são especificadas no array permissions.

// manifest.webapp — configuração de aplicação KaiOS
{
    "name": "Lanterna",
    "description": "Liga e desliga o flash da câmara",
    "launch_path": "/index.html",
    "icons": {
        "30": "/icons/icon-30.png",
        "60": "/icons/icon-60.png",
        "90": "/icons/icon-90.png",
        "120": "/icons/icon-120.png"
    },
    "type": "privileged",
    "permissions": {
        "camera": {
            "description": "Necessário para ativar o flash"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

O manifesto especifica que a aplicação é do tipo privileged — isto concede acesso à API da câmara através de permissões. Os tamanhos dos ícones são estritamente 30×30, 60×60, 90×90 e 120×120 píxeis. O campo orientation restringe o modo retrato — os telemóveis com teclado normalmente não têm acelerómetro para rotação do ecrã. fullscreen: true oculta a barra de estado.

Estrutura da página HTML

Uma página HTML5 no KaiOS utiliza tags padrão considerando o ecrã limitado (normalmente 240×320 píxeis). A metatag viewport é obrigatória: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. O KaiOS não suporta eventos táteis (não há ecrã tátil em telemóveis com teclado); toda a navegação é feita através de teclas: ArrowUp, ArrowDown para mover, Enter para selecionar, Back para voltar.

// index.html — aplicação lanterna simples para KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Lanterna</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Desligado</div>
        <div id="hint">Pressione Enter para ligar</div>
    </div>

    <script>
        const statusEl = document.getElementById('status');
        const hintEl = document.getElementById('hint');
        let isFlashOn = false;
        let camera = null;

        async function initCamera() {
            try {
                camera = navigator.mozCameras.getListOfCameras()[0];
                const cameraControl = await
                    navigator.mozCameras.getCamera(camera, { mode: 'picture' });
                return cameraControl;
            } catch (e) {
                showError('Câmera indisponível: ' + e.message);
            }
        }

        async function toggleFlash() {
            const cam = await initCamera();
            if (!cam) return;

            isFlashOn = !isFlashOn;
            try {
                await cam.setConfiguration({
                    mode: 'picture',
                    flashMode: isFlashOn ? 'on' : 'off'
                });
                statusEl.textContent = isFlashOn ? 'Ligado' : 'Desligado';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Erro: ' + e.message);
            }
        }

        // Manipulação do botão Enter físico
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

        initCamera();
    </script>
</body>
</html>

A aplicação Lanterna utiliza a MozCamera API para controlar o flash da câmara. O utilizador pressiona o botão Enter físico — o manipulador keydown é acionado, alternando flashMode entre on e off. O estado é exibido num bloco de texto com classes status-on/status-off para indicação visual. A MozCamera API está disponível apenas para aplicações privileged com permissão de câmara no manifesto.

Web API do KaiOS: trabalhar com o telemóvel e hardware

KaiOS Web API é um conjunto de interfaces JavaScript que fornecem acesso às capacidades de hardware do telemóvel. A maioria das APIs são extensões proprietárias da Mozilla (com prefixo moz) e não estão disponíveis em navegadores normais. Para utilizar a API, a aplicação deve ter o tipo privileged ou certified no manifesto.

Web APIs principais

MozMobileConnection — informações de rede: operador, intensidade de sinal, tipo de rede (4G/3G/2G), IMEI, estado de roaming. MozTelephony — gestão de chamadas: marcar, aceitar, terminar, conferência, estado da chamada. MozSms — envio e receção de SMS, MMS, gestão de mensagens SIM. MozContacts — leitura e escrita da agenda telefónica. MozBluetooth — gestão de Bluetooth: descoberta de dispositivos, emparelhamento, transferência de ficheiros. Push API — receção de notificações push do servidor.

// Trabalhar com contactos e chamadas através da Web API do KaiOS
const TelephonyManager = {
    // Fazer chamada por número
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('API Telephony indisponível');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Chamada estabelecida');
        call.ondisconnected = () => console.log('Chamada encerrada');
        return call;
    },

    // Obter lista de contactos da agenda
    async getContacts() {
        const cursor = navigator.mozContacts.getAll({
            sortBy: 'familyName',
            sortOrder: 'ascending'
        });

        const contacts = [];
        return new Promise((resolve, reject) => {
            cursor.onsuccess = function() {
                if (this.result) {
                    contacts.push(this.result);
                    this.continue();
                } else {
                    resolve(contacts);
                }
            };
            cursor.onerror = function() {
                reject(this.error);
            };
        });
    },

    // Enviar SMS
    async sendSms(phoneNumber, message) {
        if (!navigator.mozSms) {
            throw new Error('API SMS indisponível');
        }
        const request = navigator.mozSms.send(phoneNumber, message);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
};

// Exemplo de utilização
TelephonyManager.getContacts()
    .then(contacts => console.log('Contatos encontrados:', contacts.length))
    .catch(err => console.error(err));

O objeto TelephonyManager combina três APIs principais do KaiOS: mozTelephony para chamadas, mozContacts para a agenda e mozSms para mensagens. getAll() com cursor é um padrão para leitura assíncrona de grandes volumes de dados (típico para contactos com 1000+ entradas). Todas as APIs retornam um DOMRequest com manipuladores onsuccess e onerror.

Limitações das Web APIs

As Web APIs do KaiOS têm limitações: as APIs de chamadas e SMS estão disponíveis apenas em telemóveis (não em tablets), câmara — apenas se houver câmara física, Bluetooth — perfil HSP/HFP limitado. A Push API requer suporte do servidor Google Firebase (FCM) ou um servidor personalizado. A API de geolocalização usa A-GPS ou Cell ID dependendo do suporte de hardware.

UI e navegação: T9, botões e ecrã 240×320

A interface de utilizador do KaiOS é projetada para controlo por teclado T9 e botões físicos. A resolução de ecrã padrão é de 240×320 píxeis (QVGA) na maioria dos telemóveis com teclado. A ausência de ecrã tátil significa que toda a navegação é implementada através de eventos keydown/keyup: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (ou Escape).

Gestão de foco

O KaiOS não suporta CSS :focus da forma habitual — o foco é gerido através de tabindex e JavaScript. O programador deve monitorizar manualmente o elemento atualmente selecionado e mover o foco ao pressionar teclas. Recomenda-se a utilização de data-index nos elementos de lista para simplificar a navegação. O elemento selecionado é normalmente realçado com uma classe .selected com um background-color CSS contrastante.

// Navegação por foco em lista para KaiOS
class ListNavigation {
    constructor(containerSelector) {
        this.container = document.querySelector(containerSelector);
        this.items = this.container.querySelectorAll('[data-index]');
        this.currentIndex = 0;
        this.init();
    }

    init() {
        this.updateFocus();

        document.addEventListener('keydown', (e) => {
            switch (e.key) {
                case 'ArrowUp':
                    e.preventDefault();
                    this.moveFocus(-1);
                    break;
                case 'ArrowDown':
                    e.preventDefault();
                    this.moveFocus(1);
                    break;
                case 'Enter':
                    e.preventDefault();
                    this.selectItem();
                    break;
                case 'Backspace':
                case 'Escape':
                    e.preventDefault();
                    this.goBack();
                    break;
            }
        });
    }

    moveFocus(direction) {
        this.items[this.currentIndex].classList.remove('selected');
        this.currentIndex = (this.currentIndex + direction + this.items.length) % this.items.length;
        this.updateFocus();
    }

    updateFocus() {
        const el = this.items[this.currentIndex];
        el.classList.add('selected');
        el.scrollIntoView({ block: 'nearest' });
    }

    selectItem() {
        const el = this.items[this.currentIndex];
        const event = new CustomEvent('itemselected', {
            detail: { index: this.currentIndex, element: el }
        });
        this.container.dispatchEvent(event);
    }

    goBack() {
        history.back();
    }
}

// Inicialização de navegação para uma lista de menu
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Elemento selecionado:', e.detail.index);
});

A classe ListNavigation implementa a navegação por foco completa para KaiOS. ArrowUp/ArrowDown movem o foco ciclicamente pelos elementos com data-index. Enter aciona um evento personalizado itemselected. Backspace/Escape retorna ao ecrã anterior. scrollIntoView com block: nearest desloca automaticamente o ecrã ao sair da área visível.

CSS para KaiOS

O KaiOS 2.5 suporta CSS 2.1 + parcialmente CSS3 (border-radius, box-shadow, gradients). O Flexbox é parcialmente suportado no KaiOS 2.5, totalmente suportado incluindo CSS Grid no KaiOS 3.0. Recomenda-se a utilização de layout baseado em float com largura fixa para compatibilidade. O tipo de letra padrão é TizenSans ou Noto Sans CJK para mercados asiáticos. O tamanho do texto é de 14-16 píxeis para conteúdo principal, 18-20 para títulos.

KaiStore e publicação de aplicações

KaiStore é a loja oficial de aplicações para KaiOS, pré-instalada em todos os dispositivos. Os programadores registam-se no KaiOS Developer Portal (developer.kaiostech.com), carregam um pacote ZIP assinado e preenchem a descrição. A moderação verifica segurança, estabilidade e conformidade com a política de conteúdo. O tempo médio de revisão é de 3 a 5 dias úteis.

Assinatura de aplicações

O KaiOS requer a assinatura digital da aplicação através de um KaiOS Certificate. O programador gera um par de chaves (privada + pública) usando o utilitário kaios-sign, envia a chave pública para o KaiOS Developer Portal e recebe um certificado. O ficheiro .zip assinado contém a assinatura na pasta META-INF. Sem assinatura, a aplicação só pode ser instalada em dispositivos de desenvolvimento.

Modelo de distribuição e monetização

O KaiStore suporta aplicações gratuitas, publicidade através do KaiOS Ads SDK e compras na aplicação através de faturação do operador (Direct Carrier Billing). A comissão do KaiStore é de 30% da receita. Um canal alternativo é a pré-instalação através de fabricantes OEM (Jio, Nokia, Alcatel, Doro). A pré-instalação requer um contrato direto com o fabricante do dispositivo.

Limitações do KaiStore

O KaiStore não suporta aplicações pagas em alguns países (pagamento apenas através de faturação do operador). O tamanho da aplicação está limitado a 10 MB para download através de redes 2G/3G. A aplicação não deve usar mais de 50 MB de RAM. O acesso à API mozMobileConnection é proibido sem declaração explícita no manifesto. As violações de políticas resultam na suspensão da conta do programador.