KaiOS: cos'è, architettura del sistema e applicazioni web

Cos'è KaiOS?

KaiOS è un sistema operativo mobile per telefoni con tastiera sviluppato da KaiOS Technologies. Il sistema si basa sul progetto open source Boot to Gecko (B2G) di Mozilla, che è stato originariamente creato come sostituto web di Android per dispositivi ultra-economici. La prima versione commerciale è stata rilasciata nel 2017 sul telefono Reliance JioPhone in India.

Secondo Counterpoint Research (Q2 2025), KaiOS detiene il 2,8% del mercato globale degli OS mobili, dietro Android (72%) e iOS (27%), ma davanti ad altre piattaforme. In India, la quota di KaiOS raggiunge il 14% grazie al programma JioPhone. Il prezzo medio di un dispositivo KaiOS è di 20-30 dollari USA, rendendolo fondamentale per i mercati emergenti.

La caratteristica principale di KaiOS è che tutte le applicazioni sono applicazioni web. Lo sviluppatore scrive codice in HTML5, CSS e JavaScript, lo impacchetta in un archivio ZIP con un manifest e lo pubblica su KaiStore. Il sistema non supporta l'installazione di file APK nativi — solo Open Web Apps secondo la specifica W3C Widget.

Storia delle versioni di KaiOS

KaiOS 2.5 (2018) — prima versione stabile su kernel Gecko 48, distribuita su JioPhone 1. KaiOS 2.5.3 (2021) — supporto per Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, prestazioni migliorate, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — ottimizzazione per 256 MB di RAM, nuova Web API Audio Channel, sicurezza TLS 1.3 migliorata.

Architettura di KaiOS: kernel Linux e motore Gecko

L'architettura di KaiOS è composta da tre strati principali: kernel Linux (Gonk), motore web Gecko e interfaccia utente Gaia. Gonk è lo strato dipendente dall'hardware, che include driver, HAL (Hardware Abstraction Layer), stack modem RIL (Radio Interface Layer) e supporto sensori. Il bootloader, i driver e alcune librerie provengono da Android Open Source Project (AOSP).

Gonk — strato hardware

Gonk fornisce a Gecko l'accesso all'hardware: fotocamera, Bluetooth, Wi-Fi, GPS, audio, vibrazione, sensori. A differenza di Android, dove le app sono scritte per Dalvik/ART, in KaiOS le app accedono all'hardware tramite Web API tradotte da Gecko in Gonk IPC. L'interfaccia radio (RIL) fornisce 4G VoLTE, SMS, USSD e gestione delle schede SIM.

Gecko — motore web

Gecko in KaiOS non è solo un motore browser ma un ambiente di esecuzione completo per le applicazioni. Tutte le applicazioni HTML5 vengono eseguite all'interno di Gecko Process Manager, che isola ogni applicazione in un processo separato. Gecko implementa la specifica W3C Widget Packaging e le estensioni Mozilla per l'accesso all'hardware. La versione di Gecko determina quali Web API sono disponibili per lo sviluppatore.

Gaia — interfaccia utente

Gaia è l'interfaccia web dell'OS stesso: schermata di blocco, schermata home (launcher), pannello notifiche, compositore, contatti, client SMS. Tutte le applicazioni di sistema sono le stesse Open Web Apps. Uno sviluppatore può sostituire la fotocamera o la tastiera standard con la propria app registrando il corrispondente gestore di attività nel manifest.

// Verifica versione KaiOS e disponibilità 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 disponibilità 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));

// Utilizzo vibrazione con verifica disponibilità
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibrazione, pausa, vibrazione
    }
}

La funzione checkKaiOSVersion legge lo User Agent per determinare la versione di KaiOS e verifica la disponibilità delle Web API chiave. Nella versione 2.5, sono disponibili mozMobileConnection, mozTelephony, mozSms — assenti nei browser normali e unici per KaiOS. La funzione triggerHapticFeedback utilizza l'API Vibration con retrocompatibilità.

Creazione di un'app per KaiOS: struttura e manifest

Un'app KaiOS è un archivio ZIP (formato .zip, non .apk) contenente file HTML, CSS, JavaScript, immagini e un manifest. La struttura minima dell'app include manifest.webapp (descrizione dell'app), index.html (punto di ingresso), style.css e icon.png (icona quadrata 90×90 pixel). Il manifest segue la specifica W3C Manifest for Web Apps.

Manifest manifest.webapp

Il file manifest.webapp è il file di configurazione principale di un'app KaiOS. Campi obbligatori: name (nome), description (descrizione fino a 140 caratteri), launch_path (percorso per index.html), icons (dimensioni icona 30×30, 60×60, 90×90, 120×120). Il campo type: 'certified' (app di sistema), 'privileged' (accesso alle Web API), 'web' (nessun permesso speciale). I permessi per le app privileged sono specificati nell'array permissions.

// manifest.webapp — configurazione applicazione KaiOS
{
    "name": "Torcia",
    "description": "Accende e spegne il flash della fotocamera",
    "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": "Necessario per attivare il flash"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Il manifest specifica che l'app è di tipo privileged — questo concede l'accesso all'API della fotocamera tramite i permessi. Le dimensioni delle icone sono rigorosamente 30×30, 60×60, 90×90 e 120×120 pixel. Il campo orientation limita la modalità ritratto — i telefoni con tastiera di solito non hanno un accelerometro per la rotazione dello schermo. fullscreen: true nasconde la barra di stato.

Struttura della pagina HTML

Una pagina HTML5 in KaiOS utilizza tag standard considerando lo schermo limitato (solitamente 240×320 pixel). Il meta tag viewport è obbligatorio: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS non supporta eventi tattili (nessun touchscreen sui telefoni con tastiera); tutta la navigazione avviene tramite tasti: ArrowUp, ArrowDown per muoversi, Enter per selezionare, Back per tornare indietro.

// index.html — semplice app torcia per KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Torcia</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Spento</div>
        <div id="hint">Premi Invio per accendere</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('Telecamera non disponibile: ' + 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 ? 'Acceso' : 'Spento';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Errore: ' + e.message);
            }
        }

        // Gestione del pulsante Enter hardware
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

L'app Torcia utilizza l'API MozCamera per controllare il flash della fotocamera. L'utente preme il pulsante Enter hardware — il gestore keydown si attiva, commutando flashMode tra on e off. Lo stato viene visualizzato in un blocco di testo con classi status-on/status-off per indicazione visiva. L'API MozCamera è disponibile solo per le app privileged con permesso fotocamera nel manifest.

KaiOS Web API: lavorare con telefono e hardware

KaiOS Web API è un insieme di interfacce JavaScript che forniscono accesso alle capacità hardware del telefono. La maggior parte delle API sono estensioni proprietarie di Mozilla (con prefisso moz) e non sono disponibili nei browser normali. Per utilizzare l'API, l'app deve avere tipo privileged o certified nel manifest.

Web API principali

MozMobileConnection — informazioni di rete: operatore, intensità del segnale, tipo di rete (4G/3G/2G), IMEI, stato roaming. MozTelephony — gestione chiamate: composizione, accettazione, termine, conferenza, stato chiamata. MozSms — invio e ricezione di SMS, MMS, gestione messaggi SIM. MozContacts — lettura e scrittura della rubrica telefonica. MozBluetooth — gestione Bluetooth: scoperta dispositivi, accoppiamento, trasferimento file. Push API — ricezione di notifiche push dal server.

// Lavorare con contatti e chiamate tramite Web API KaiOS
const TelephonyManager = {
    // Effettuare una chiamata per numero
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API non disponibile');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Chiamata stabilita');
        call.ondisconnected = () => console.log('Chiamata terminata');
        return call;
    },

    // Ottenere l'elenco dei contatti dalla rubrica
    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);
            };
        });
    },

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

// Esempio di utilizzo
TelephonyManager.getContacts()
    .then(contacts => console.log('Contatti trovati:', contacts.length))
    .catch(err => console.error(err));

L'oggetto TelephonyManager combina tre API chiave di KaiOS: mozTelephony per le chiamate, mozContacts per la rubrica e mozSms per i messaggi. getAll() con un cursore è un pattern per la lettura asincrona di grandi volumi di dati (tipico per contatti con 1000+ voci). Tutte le API restituiscono un DOMRequest con gestori onsuccess e onerror.

Limitazioni delle Web API

Le Web API di KaiOS hanno limitazioni: le API di chiamate e SMS sono disponibili solo sui telefoni (non sui tablet), fotocamera — solo se è presente una fotocamera fisica, Bluetooth — profilo HSP/HFP limitato. La Push API richiede il supporto del server Google Firebase (FCM) o un server personalizzato. L'API di geolocalizzazione utilizza A-GPS o Cell ID a seconda del supporto hardware.

UI e navigazione: T9, pulsanti e schermo 240×320

L'interfaccia utente di KaiOS è progettata per il controllo tramite tastiera T9 e pulsanti hardware. La risoluzione dello schermo standard è di 240×320 pixel (QVGA) sulla maggior parte dei telefoni con tastiera. L'assenza di touchscreen significa che tutta la navigazione è implementata tramite eventi keydown/keyup: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (o Escape).

Gestione del focus

KaiOS non supporta CSS :focus nel modo consueto — il focus è gestito tramite tabindex e JavaScript. Lo sviluppatore deve tracciare manualmente l'elemento attualmente selezionato e spostare il focus alla pressione dei tasti. Si consiglia di utilizzare data-index sugli elementi dell'elenco per semplificare la navigazione. L'elemento selezionato viene solitamente evidenziato con una classe .selected con un background-color CSS contrastante.

// Navigazione a fuoco tramite elenco per 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();
    }
}

// Inizializzazione della navigazione per un elenco di menu
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Elemento selezionato:', e.detail.index);
});

La classe ListNavigation implementa la navigazione a fuoco completa per KaiOS. ArrowUp/ArrowDown spostano il focus ciclicamente attraverso gli elementi con data-index. Enter attiva un evento personalizzato itemselected. Backspace/Escape torna alla schermata precedente. scrollIntoView con block: nearest scorre automaticamente lo schermo quando si esce dall'area visibile.

CSS per KaiOS

KaiOS 2.5 supporta CSS 2.1 + parzialmente CSS3 (border-radius, box-shadow, gradients). Flexbox è parzialmente supportato in KaiOS 2.5, completamente supportato inclusi CSS Grid in KaiOS 3.0. Si consiglia di utilizzare un layout basato su float con larghezza fissa per la compatibilità. Il carattere predefinito è TizenSans o Noto Sans CJK per i mercati asiatici. La dimensione del testo è 14-16 pixel per il contenuto principale, 18-20 per i titoli.

KaiStore e pubblicazione di app

KaiStore è il negozio ufficiale di applicazioni per KaiOS, preinstallato su tutti i dispositivi. Gli sviluppatori si registrano su KaiOS Developer Portal (developer.kaiostech.com), caricano un pacchetto ZIP firmato e compilano la descrizione. La moderazione verifica sicurezza, stabilità e conformità alle politiche sui contenuti. Il tempo medio di revisione è di 3-5 giorni lavorativi.

Firma dell'app

KaiOS richiede la firma digitale dell'app tramite un KaiOS Certificate. Lo sviluppatore genera una coppia di chiavi (privata + pubblica) utilizzando l'utilità kaios-sign, invia la chiave pubblica al KaiOS Developer Portal e riceve un certificato. Il file .zip firmato contiene la firma nella cartella META-INF. Senza firma, l'app può essere installata solo su dispositivi di sviluppo.

Modello di distribuzione e monetizzazione

KaiStore supporta app gratuite, pubblicità tramite KaiOS Ads SDK e acquisti in-app tramite fatturazione dell'operatore (Direct Carrier Billing). La commissione di KaiStore è del 30% delle entrate. Un canale alternativo è la preinstallazione tramite produttori OEM (Jio, Nokia, Alcatel, Doro). La preinstallazione richiede un contratto diretto con il produttore del dispositivo.

Limitazioni di KaiStore

KaiStore non supporta app a pagamento in alcuni paesi (pagamento solo tramite fatturazione operatore). La dimensione dell'app è limitata a 10 MB per il download su reti 2G/3G. L'app non deve utilizzare più di 50 MB di RAM. L'accesso all'API mozMobileConnection è vietato senza dichiarazione esplicita nel manifest. Le violazioni delle policy comportano la sospensione dell'account dello sviluppatore.