KaiOS : qu'est-ce que c'est, architecture du système et applications web

Qu'est-ce que KaiOS ?

KaiOS est un système d'exploitation mobile pour téléphones à clavier développé par KaiOS Technologies. Le système est basé sur le projet open source Boot to Gecko (B2G) de Mozilla, qui a été initialement créé comme un remplacement web d'Android pour les appareils ultra-bon marché. La première version commerciale a eu lieu en 2017 sur le téléphone Reliance JioPhone en Inde.

Selon Counterpoint Research (T2 2025), KaiOS détient 2,8 % du marché mondial des OS mobiles, derrière Android (72 %) et iOS (27 %), mais devant les autres plateformes. En Inde, la part de KaiOS atteint 14 % grâce au programme JioPhone. Le prix moyen d'un appareil KaiOS est de 20 à 30 dollars, ce qui le rend essentiel pour les marchés émergents.

La caractéristique clé de KaiOS est que toutes les applications sont des applications web. Le développeur écrit du code en HTML5, CSS et JavaScript, le package dans une archive ZIP avec un manifeste et le publie sur KaiStore. Le système ne prend pas en charge l'installation de fichiers APK natifs — seulement les Open Web Apps selon la spécification W3C Widget.

Historique des versions de KaiOS

KaiOS 2.5 (2018) — première version stable sur noyau Gecko 48, livrée sur JioPhone 1. KaiOS 2.5.3 (2021) — prise en charge de Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, performances améliorées, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimisation pour 256 Mo de RAM, nouvelle Web API Audio Channel, sécurité TLS 1.3 améliorée.

Architecture de KaiOS : noyau Linux et moteur Gecko

L'architecture de KaiOS se compose de trois couches principales : le noyau Linux (Gonk), le moteur web Gecko et l'interface utilisateur Gaia. Gonk est la couche dépendante du matériel, comprenant les pilotes, la HAL (Hardware Abstraction Layer), la pile modem RIL (Radio Interface Layer) et la prise en charge des capteurs. Le chargeur d'amorçage, les pilotes et certaines bibliothèques sont tirés de l'Android Open Source Project (AOSP).

Gonk — couche matérielle

Gonk fournit à Gecko l'accès au matériel : appareil photo, Bluetooth, Wi-Fi, GPS, audio, vibration, capteurs. Contrairement à Android, où les applications sont écrites pour Dalvik/ART, dans KaiOS les applications accèdent au matériel via des Web API traduites par Gecko en Gonk IPC. L'interface radio (RIL) fournit la 4G VoLTE, les SMS, l'USSD et la gestion des cartes SIM.

Gecko — moteur web

Gecko dans KaiOS n'est pas seulement un moteur de navigateur mais un environnement d'exécution complet pour les applications. Toutes les applications HTML5 s'exécutent dans le Gecko Process Manager, qui isole chaque application dans un processus séparé. Gecko implémente la spécification W3C Widget Packaging et les extensions Mozilla pour l'accès au matériel. La version de Gecko détermine quelles Web API sont disponibles pour le développeur.

Gaia — interface utilisateur

Gaia est l'interface web de l'OS lui-même : écran de verrouillage, écran d'accueil (lanceur), panneau de notifications, composeur, contacts, client SMS. Toutes les applications système sont les mêmes Open Web Apps. Un développeur peut remplacer l'appareil photo ou le clavier standard par sa propre application en enregistrant le gestionnaire d'activité correspondant dans le manifeste.

// Vérification de la version KaiOS et disponibilité des 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 };
}

// Vérification de disponibilité de Google Apps (KaiOS 2.5.3+ uniquement)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Utilisation de la vibration avec vérification de disponibilité
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibration, pause, vibration
    }
}

La fonction checkKaiOSVersion lit le User Agent pour déterminer la version de KaiOS et vérifie la disponibilité des Web API clés. Dans la version 2.5, mozMobileConnection, mozTelephony, mozSms sont disponibles — ils sont absents dans les navigateurs normaux et propres à KaiOS. La fonction triggerHapticFeedback utilise l'API Vibration avec rétrocompatibilité.

Création d'une application pour KaiOS : structure et manifeste

Une application KaiOS est une archive ZIP (format .zip, pas .apk) contenant des fichiers HTML, CSS, JavaScript, des images et un manifeste. La structure minimale de l'application comprend manifest.webapp (description de l'application), index.html (point d'entrée), style.css et icon.png (icône carrée 90×90 pixels). Le manifeste suit la spécification W3C Manifest for Web Apps.

Manifeste manifest.webapp

Le fichier manifest.webapp est le fichier de configuration racine d'une application KaiOS. Champs obligatoires : name (nom), description (description jusqu'à 140 caractères), launch_path (chemin vers index.html), icons (tailles d'icône 30×30, 60×60, 90×90, 120×120). Le champ type : 'certified' (applications système), 'privileged' (accès aux Web API), 'web' (sans permissions spéciales). Les permissions pour les applications privileged sont spécifiées dans le tableau permissions.

// manifest.webapp — configuration d'application KaiOS
{
    "name": "Lampe torche",
    "description": "Allume et éteint le flash de l'appareil photo",
    "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": "Nécessaire pour activer le flash"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Le manifeste spécifie que l'application est de type privileged — cela donne accès à l'API de l'appareil photo via les permissions. Les tailles d'icône sont strictement 30×30, 60×60, 90×90 et 120×120 pixels. Le champ orientation restreint le mode portrait — les téléphones à clavier n'ont généralement pas d'accéléromètre pour la rotation d'écran. fullscreen : true masque la barre d'état.

Structure de la page HTML

Une page HTML5 dans KaiOS utilise des balises standard en tenant compte de l'écran limité (généralement 240×320 pixels). La balise meta viewport est obligatoire : <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS ne prend pas en charge les événements tactiles (pas d'écran tactile sur les téléphones à clavier) ; toute la navigation se fait via les touches : ArrowUp, ArrowDown pour se déplacer, Enter pour sélectionner, Back pour revenir.

// index.html — application lampe torche simple pour KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Lampe de poche</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Éteint</div>
        <div id="hint">Appuyez sur Entrée pour allumer</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('Caméra indisponible : ' + 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 ? 'Allumé' : 'Éteint';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Erreur : ' + e.message);
            }
        }

        // Gestion du bouton Enter physique
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

L'application Lampe torche utilise l'API MozCamera pour contrôler le flash de l'appareil photo. L'utilisateur appuie sur le bouton Enter physique — le gestionnaire keydown se déclenche, basculant flashMode entre on et off. Le statut est affiché dans un bloc de texte avec les classes status-on/status-off pour l'indication visuelle. L'API MozCamera est disponible uniquement pour les applications privileged avec permission d'appareil photo dans le manifeste.

Web API de KaiOS : travailler avec le téléphone et le matériel

KaiOS Web API est un ensemble d'interfaces JavaScript fournissant un accès aux capacités matérielles du téléphone. La plupart des API sont des extensions propriétaires de Mozilla (préfixe moz) et ne sont pas disponibles dans les navigateurs normaux. Pour utiliser l'API, l'application doit être de type privileged ou certified dans le manifeste.

Web API principales

MozMobileConnection — informations réseau : opérateur, puissance du signal, type de réseau (4G/3G/2G), IMEI, état d'itinérance. MozTelephony — gestion des appels : composition, acceptation, fin, conférence, état d'appel. MozSms — envoi et réception de SMS, MMS, gestion des messages SIM. MozContacts — lecture et écriture du répertoire téléphonique. MozBluetooth — gestion Bluetooth : découverte d'appareils, appairage, transfert de fichiers. Push API — réception de notifications push du serveur.

// Travailler avec les contacts et les appels via les Web API KaiOS
const TelephonyManager = {
    // Passer un appel par numéro
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('API Telephony indisponible');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Appel établi');
        call.ondisconnected = () => console.log('Appel terminé');
        return call;
    },

    // Obtenir la liste des contacts du répertoire
    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);
            };
        });
    },

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

// Exemple d'utilisation
TelephonyManager.getContacts()
    .then(contacts => console.log('Contacts trouvés :', contacts.length))
    .catch(err => console.error(err));

L'objet TelephonyManager combine trois API clés de KaiOS : mozTelephony pour les appels, mozContacts pour le répertoire et mozSms pour les messages. getAll() avec un curseur est un modèle pour la lecture asynchrone de grands volumes de données (typique pour les contacts de 1000+ entrées). Toutes les API retournent un DOMRequest avec des gestionnaires onsuccess et onerror.

Limitations des Web API

Les Web API de KaiOS ont des limitations : les API d'appels et SMS sont disponibles uniquement sur les téléphones (pas sur les tablettes), l'appareil photo — seulement si un appareil photo physique est présent, Bluetooth — profil HSP/HFP limité. La Push API nécessite la prise en charge du serveur Google Firebase (FCM) ou un serveur personnalisé. L'API de géolocalisation utilise A-GPS ou Cell ID selon la prise en charge matérielle.

UI et navigation : T9, boutons et écran 240×320

L'interface utilisateur de KaiOS est conçue pour le contrôle par clavier T9 et boutons physiques. La résolution d'écran standard est de 240×320 pixels (QVGA) sur la plupart des téléphones à clavier. L'absence d'écran tactile signifie que toute la navigation est implémentée via des événements keydown/keyup : ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (ou Escape).

Gestion du focus

KaiOS ne prend pas en charge CSS :focus de la manière habituelle — le focus est géré via tabindex et JavaScript. Le développeur doit suivre manuellement l'élément actuellement sélectionné et déplacer le focus lors des pressions sur les touches. L'utilisation de data-index sur les éléments de liste est recommandée pour simplifier la navigation. L'élément sélectionné est généralement surligné avec une classe .selected avec un background-color CSS contrastant.

// Navigation par focus dans une liste pour 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();
    }
}

// Initialisation de la navigation pour une liste de menu
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Élément sélectionné :', e.detail.index);
});

La classe ListNavigation implémente la navigation par focus complète pour KaiOS. ArrowUp/ArrowDown déplacent le focus cycliquement à travers les éléments avec data-index. Enter déclenche un événement personnalisé itemselected. Backspace/Escape retourne à l'écran précédent. scrollIntoView avec block : nearest fait défiler automatiquement l'écran lorsqu'on sort de la zone visible.

CSS pour KaiOS

KaiOS 2.5 prend en charge CSS 2.1 + partiellement CSS3 (border-radius, box-shadow, gradients). Flexbox est partiellement pris en charge dans KaiOS 2.5, complètement pris en charge y compris CSS Grid dans KaiOS 3.0. Il est recommandé d'utiliser une mise en page basée sur float avec largeur fixe pour la compatibilité. La police par défaut est TizenSans ou Noto Sans CJK pour les marchés asiatiques. La taille du texte est de 14-16 pixels pour le contenu principal, 18-20 pour les titres.

KaiStore et publication d'applications

KaiStore est la boutique officielle d'applications pour KaiOS, préinstallée sur tous les appareils. Les développeurs s'inscrivent sur le KaiOS Developer Portal (developer.kaiostech.com), téléchargent un paquet ZIP signé et remplissent la description. La modération vérifie la sécurité, la stabilité et la conformité à la politique de contenu. Le délai de révision moyen est de 3 à 5 jours ouvrables.

Signature d'application

KaiOS nécessite la signature numérique de l'application via un KaiOS Certificate. Le développeur génère une paire de clés (privée + publique) à l'aide de l'utilitaire kaios-sign, envoie la clé publique au KaiOS Developer Portal et reçoit un certificat. Le fichier .zip signé contient la signature dans le dossier META-INF. Sans signature, l'application ne peut être installée que sur des appareils de développement.

Modèle de distribution et monétisation

KaiStore prend en charge les applications gratuites, la publicité via le KaiOS Ads SDK et les achats intégrés via la facturation opérateur (Direct Carrier Billing). La commission de KaiStore est de 30 % des revenus. Un canal alternatif est la préinstallation via les fabricants OEM (Jio, Nokia, Alcatel, Doro). La préinstallation nécessite un contrat direct avec le fabricant de l'appareil.

Limitations de KaiStore

KaiStore ne prend pas en charge les applications payantes dans certains pays (paiement uniquement par facturation opérateur). La taille de l'application est limitée à 10 Mo pour le téléchargement via les réseaux 2G/3G. L'application ne doit pas utiliser plus de 50 Mo de RAM. L'accès à l'API mozMobileConnection est interdit sans déclaration explicite dans le manifeste. Les violations de politique entraînent la suspension du compte développeur.