KaiOS: qué es, arquitectura del sistema y aplicaciones web

¿Qué es KaiOS?

KaiOS es un sistema operativo móvil para teléfonos con teclado desarrollado por KaiOS Technologies. El sistema se basa en el proyecto de código abierto Boot to Gecko (B2G) de Mozilla, que originalmente fue creado como un reemplazo web para Android en dispositivos ultraeconómicos. El primer lanzamiento comercial fue en 2017 en el teléfono Reliance JioPhone en India.

Según Counterpoint Research (Q2 2025), KaiOS posee el 2,8% del mercado mundial de SO móviles, por detrás de Android (72%) e iOS (27%), pero por delante de otras plataformas. En India, la cuota de KaiOS alcanza el 14% gracias al programa JioPhone. El precio medio de un dispositivo KaiOS es de 20 a 30 dólares, lo que lo hace clave para los mercados emergentes.

La característica clave de KaiOS es que todas las aplicaciones son aplicaciones web. El desarrollador escribe código en HTML5, CSS y JavaScript, lo empaqueta en un archivo ZIP con un manifiesto y lo publica en KaiStore. El sistema no admite la instalación de archivos APK nativos, solo Open Web Apps según la especificación W3C Widget.

Historial de versiones de KaiOS

KaiOS 2.5 (2018) — primera versión estable con núcleo Gecko 48, incluida en JioPhone 1. KaiOS 2.5.3 (2021) — soporte para Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, rendimiento mejorado, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimización para 256 MB de RAM, nueva Web API Audio Channel, mejora de seguridad TLS 1.3.

Arquitectura de KaiOS: núcleo Linux y motor Gecko

La arquitectura de KaiOS consta de tres capas clave: núcleo Linux (Gonk), motor web Gecko e interfaz de usuario Gaia. Gonk es la capa dependiente del hardware, que incluye controladores, HAL (Hardware Abstraction Layer), la pila de módem RIL (Radio Interface Layer) y soporte de sensores. El gestor de arranque, los controladores y algunas bibliotecas se toman de Android Open Source Project (AOSP).

Gonk — capa de hardware

Gonk proporciona a Gecko acceso al hardware: cámara, Bluetooth, Wi-Fi, GPS, audio, vibración, sensores. A diferencia de Android, donde las aplicaciones se escriben para Dalvik/ART, en KaiOS las aplicaciones acceden al hardware a través de Web API traducidas por Gecko a Gonk IPC. La interfaz de radio (RIL) proporciona 4G VoLTE, SMS, USSD y gestión de tarjetas SIM.

Gecko — motor web

Gecko en KaiOS no es solo un motor de navegador, sino un entorno de ejecución completo para aplicaciones. Todas las aplicaciones HTML5 se ejecutan dentro del Gecko Process Manager, que aísla cada aplicación en un proceso separado. Gecko implementa la especificación W3C Widget Packaging y las extensiones de Mozilla para acceso al hardware. La versión de Gecko determina qué Web API están disponibles para el desarrollador.

Gaia — interfaz de usuario

Gaia es la interfaz web del propio SO: pantalla de bloqueo, pantalla de inicio (lanzador), panel de notificaciones, marcador, contactos, cliente SMS. Todas las aplicaciones del sistema son las mismas Open Web Apps. Un desarrollador puede reemplazar la cámara o el teclado estándar con su propia aplicación registrando el manejador de actividad correspondiente en el manifiesto.

// Comprobación de versión de KaiOS y disponibilidad 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 };
}

// Comprobación de disponibilidad de Google Apps (solo 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 vibración con verificación de disponibilidad
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibración, pausa, vibración
    }
}

La función checkKaiOSVersion lee el User Agent para determinar la versión de KaiOS y verifica la disponibilidad de las Web API clave. En la versión 2.5, están disponibles mozMobileConnection, mozTelephony, mozSms — ausentes en navegadores normales y exclusivos de KaiOS. La función triggerHapticFeedback usa la Vibration API con compatibilidad hacia atrás.

Creación de una aplicación para KaiOS: estructura y manifiesto

Una aplicación KaiOS es un archivo ZIP (formato .zip, no .apk) que contiene archivos HTML, CSS, JavaScript, imágenes y un manifiesto. La estructura mínima de la aplicación incluye manifest.webapp (descripción de la aplicación), index.html (punto de entrada), style.css e icon.png (icono cuadrado de 90×90 píxeles). El manifiesto sigue la especificación W3C Manifest for Web Apps.

Manifiesto manifest.webapp

El archivo manifest.webapp es el archivo de configuración raíz de una aplicación KaiOS. Campos obligatorios: name (nombre), description (descripción hasta 140 caracteres), launch_path (ruta a index.html), icons (tamaños de icono 30×30, 60×60, 90×90, 120×120). El campo type: 'certified' (aplicaciones del sistema), 'privileged' (acceso a Web API), 'web' (sin permisos especiales). Los permisos para aplicaciones privileged se especifican en el array permissions.

// manifest.webapp — configuración de aplicación KaiOS
{
    "name": "Linterna",
    "description": "Enciende y apaga el flash de la 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": "Necesario para activar el flash"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

El manifiesto especifica que la aplicación es de tipo privileged — esto otorga acceso a la API de la cámara a través de permisos. Los tamaños de icono son estrictamente 30×30, 60×60, 90×90 y 120×120 píxeles. El campo orientation restringe el modo retrato — los teléfonos con teclado normalmente no tienen acelerómetro para rotación de pantalla. fullscreen: true oculta la barra de estado.

Estructura de la página HTML

Una página HTML5 en KaiOS usa etiquetas estándar teniendo en cuenta la pantalla limitada (normalmente 240×320 píxeles). La metaetiqueta viewport es obligatoria: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS no admite eventos táctiles (no hay pantalla táctil en teléfonos con teclado); toda la navegación se realiza mediante teclas: ArrowUp, ArrowDown para moverse, Enter para seleccionar, Back para volver.

// index.html — aplicación linterna simple para KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Linterna</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Apagado</div>
        <div id="hint">Presiona Enter para encender</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ámara no disponible: ' + 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 ? 'Encendido' : 'Apagado';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Error: ' + e.message);
            }
        }

        // Manejo del botón Enter físico
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

La aplicación Linterna usa la API MozCamera para controlar el flash de la cámara. El usuario presiona el botón Enter físico — se activa el manejador keydown, cambiando flashMode entre on y off. El estado se muestra en un bloque de texto con clases status-on/status-off para indicación visual. La API MozCamera solo está disponible para aplicaciones privileged con permiso de cámara en el manifiesto.

Web API de KaiOS: trabajo con el teléfono y hardware

KaiOS Web API es un conjunto de interfaces JavaScript que proporcionan acceso a las capacidades hardware del teléfono. La mayoría de las API son extensiones propietarias de Mozilla (con prefijo moz) y no están disponibles en navegadores normales. Para usar la API, la aplicación debe tener tipo privileged o certified en el manifiesto.

Web API principales

MozMobileConnection — información de red: operador, intensidad de señal, tipo de red (4G/3G/2G), IMEI, estado de roaming. MozTelephony — gestión de llamadas: marcar, aceptar, finalizar, conferencia, estado de llamada. MozSms — envío y recepción de SMS, MMS, gestión de mensajes en SIM. MozContacts — lectura y escritura de la agenda telefónica. MozBluetooth — gestión de Bluetooth: descubrimiento de dispositivos, emparejamiento, transferencia de archivos. Push API — recepción de notificaciones push del servidor.

// Trabajo con contactos y llamadas mediante Web API de KaiOS
const TelephonyManager = {
    // Realizar llamada por número
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API no disponible');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Llamada establecida');
        call.ondisconnected = () => console.log('Llamada finalizada');
        return call;
    },

    // Obtener lista de contactos de la 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('SMS API no disponible');
        }
        const request = navigator.mozSms.send(phoneNumber, message);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
};

// Ejemplo de uso
TelephonyManager.getContacts()
    .then(contacts => console.log('Contactos encontrados:', contacts.length))
    .catch(err => console.error(err));

El objeto TelephonyManager combina tres API clave de KaiOS: mozTelephony para llamadas, mozContacts para la agenda y mozSms para mensajes. getAll() con cursor es un patrón para lectura asíncrona de grandes volúmenes de datos (típico para contactos de 1000+ entradas). Todas las API devuelven un DOMRequest con manejadores onsuccess y onerror.

Limitaciones de Web API

Las Web API de KaiOS tienen limitaciones: las API de llamadas y SMS solo están disponibles en teléfonos (no en tablets), la cámara solo si hay cámara física, Bluetooth con perfil HSP/HFP limitado. Push API requiere soporte del servidor Google Firebase (FCM) o un servidor propio. La API de geolocalización usa A-GPS o Cell ID según el soporte hardware.

UI y navegación: T9, botones y pantalla 240×320

La interfaz de usuario de KaiOS está diseñada para el control mediante teclado T9 y botones físicos. La resolución de pantalla estándar es de 240×320 píxeles (QVGA) en la mayoría de los teléfonos con teclado. La ausencia de pantalla táctil implica que toda la navegación se implementa mediante eventos keydown/keyup: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (o Escape).

Gestión del foco

KaiOS no admite CSS :focus de la forma habitual — el foco se gestiona mediante tabindex y JavaScript. El desarrollador debe rastrear manualmente el elemento seleccionado actualmente y mover el foco al presionar teclas. Se recomienda usar data-index en los elementos de lista para simplificar la navegación. El elemento seleccionado normalmente se resalta con una clase .selected con un background-color CSS contrastante.

// Navegación por foco en 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();
    }
}

// Inicialización de navegación para una lista de menú
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Elemento seleccionado:', e.detail.index);
});

La clase ListNavigation implementa la navegación por foco completa para KaiOS. ArrowUp/ArrowDown mueven el foco cíclicamente por los elementos con data-index. Enter activa un evento personalizado itemselected. Backspace/Escape vuelven a la pantalla anterior. scrollIntoView con block: nearest desplaza automáticamente la pantalla al salir del área visible.

CSS para KaiOS

KaiOS 2.5 admite CSS 2.1 + parcialmente CSS3 (border-radius, box-shadow, gradients). Flexbox se admite parcialmente en KaiOS 2.5, completamente incluyendo CSS Grid en KaiOS 3.0. Se recomienda usar maquetación con float y ancho fijo para compatibilidad. La fuente predeterminada es TizenSans o Noto Sans CJK para mercados asiáticos. El tamaño de texto es de 14-16 píxeles para contenido principal, 18-20 para títulos.

KaiStore y publicación de aplicaciones

KaiStore es la tienda oficial de aplicaciones para KaiOS, preinstalada en todos los dispositivos. Los desarrolladores se registran en KaiOS Developer Portal (developer.kaiostech.com), suben un paquete ZIP firmado y completan la descripción. La moderación verifica seguridad, estabilidad y cumplimiento de la política de contenido. El tiempo medio de revisión es de 3 a 5 días hábiles.

Firma de aplicaciones

KaiOS requiere la firma digital de la aplicación mediante un KaiOS Certificate. El desarrollador genera un par de claves (privada + pública) usando la utilidad kaios-sign, envía la clave pública al KaiOS Developer Portal y recibe un certificado. El archivo .zip firmado contiene la firma en la carpeta META-INF. Sin firma, la aplicación solo se puede instalar en dispositivos de desarrollo.

Modelo de distribución y monetización

KaiStore admite aplicaciones gratuitas, publicidad mediante el KaiOS Ads SDK y compras integradas a través de facturación del operador (Direct Carrier Billing). La comisión de KaiStore es del 30% de los ingresos. Un canal alternativo es la preinstalación a través de fabricantes OEM (Jio, Nokia, Alcatel, Doro). La preinstalación requiere un contrato directo con el fabricante del dispositivo.

Limitaciones de KaiStore

KaiStore no admite aplicaciones de pago en algunos países (pago solo mediante facturación del operador). El tamaño de la aplicación está limitado a 10 MB para descarga a través de redes 2G/3G. La aplicación no debe usar más de 50 MB de RAM. El acceso a la API mozMobileConnection está prohibido sin declaración explícita en el manifiesto. Las violaciones de políticas resultan en la suspensión de la cuenta del desarrollador.