KaiOS: wat is het, systeemarchitectuur en webapplicaties

Wat is KaiOS?

KaiOS — een mobiel besturingssysteem voor telefoons met toetsenbord, ontwikkeld door KaiOS Technologies. Het systeem is gebaseerd op het opensourceproject Boot to Gecko (B2G) van Mozilla, dat oorspronkelijk was gemaakt als webalternatief voor Android op ultra-budgetapparaten. De eerste commerciële release vond plaats in 2017 op de Reliance JioPhone in India.

Volgens Counterpoint Research (Q2 2025) heeft KaiOS 2,8% van de wereldwijde markt voor mobiele besturingssystemen, achter Android (72%) en iOS (27%), maar vóór andere platforms. In India bereikt het aandeel van KaiOS 14% dankzij het JioPhone-programma. De gemiddelde prijs van een KaiOS-apparaat is 20-30 US-dollar, waardoor het systeem essentieel is voor opkomende markten.

Het belangrijkste kenmerk van KaiOS — alle apps zijn webapps. De ontwikkelaar schrijft code in HTML5, CSS en JavaScript, verpakt deze in een ZIP-archief met manifest en publiceert deze in de KaiStore. Het systeem ondersteunt geen installatie van native APK-bestanden — alleen Open Web Apps volgens de W3C Widget-specificatie.

Geschiedenis van KaiOS-versies

KaiOS 2.5 (2018) — eerste stabiele versie op de Gecko 48-kernel, geïnstalleerd op JioPhone 1. KaiOS 2.5.3 (2021) — ondersteuning voor Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, verbeterde prestaties, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimalisatie voor 256 MB RAM, nieuwe Web API Audio Channel, verbeterde beveiliging TLS 1.3.

KaiOS-architectuur: Linux-kernel en Gecko-engine

De KaiOS-architectuur bestaat uit drie belangrijke lagen: de Linux-kernel (Gonk), de web-engine Gecko en de gebruikersinterface Gaia. Gonk — de hardware-afhankelijke laag, met stuurprogramma's, HAL (Hardware Abstraction Layer), de modemstack RIL (Radio Interface Layer) en ondersteuning voor sensoren. Uit Android Open Source Project (AOSP) zijn de bootloader, stuurprogramma's en enkele bibliotheken overgenomen.

Gonk — hardwarelaag

Gonk geeft Gecko toegang tot de hardware: camera, Bluetooth, Wi-Fi, GPS, audio, vibratie, sensoren. In tegenstelling tot Android, waar apps worden geschreven voor Dalvik/ART, hebben apps in KaiOS toegang tot hardware via Web API's die door Gecko worden vertaald naar Gonk IPC. De radio-interface (RIL) zorgt voor 4G VoLTE, SMS, USSD en SIM-kaartbeheer.

Gecko — webengine

Gecko in KaiOS is niet alleen een browser-engine, maar een volledige runtime-omgeving voor apps. Alle HTML5-apps werken binnen Gecko Process Manager, die elke app isoleert in een afzonderlijk proces. Gecko implementeert de W3C Widget Packaging-specificatie en Mozilla-extensies voor hardwaretoegang. De Gecko-versie bepaalt welke Web API's beschikbaar zijn voor de ontwikkelaar.

Gaia — gebruikersinterface

Gaia — de webinterface van het besturingssysteem zelf: vergrendelscherm, startscherm (launcher), meldingenpaneel, kiesscherm, contacten, SMS-client. Alle systeem-apps zijn dezelfde Open Web Apps. De ontwikkelaar kan de standaardcamera of het toetsenbord vervangen door zijn eigen app door de juiste activity-handler in het manifest te registreren.

// KaiOS-versie en API-beschikbaarheid controleren
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 };
}

// Controleren op Google Apps (alleen KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Vibratie gebruiken met beschikbaarheidscontrole
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibratie, pauze, vibratie
    }
}

De functie checkKaiOSVersion leest de User Agent om de KaiOS-versie te bepalen en controleert de beschikbaarheid van belangrijke Web API's. In versie 2.5 zijn mozMobileConnection, mozTelephony, mozSms beschikbaar — deze ontbreken in gewone browsers en zijn uniek voor KaiOS. De functie triggerHapticFeedback gebruikt de Vibration API met achterwaartse compatibiliteit.

Een app maken voor KaiOS: structuur en manifest

Een KaiOS-app — een ZIP-archief (formaat .zip, niet .apk) met HTML-bestanden, CSS, JavaScript, afbeeldingen en een manifest. De structuur van een minimale app omvat manifest.webapp (app-beschrijving), index.html (ingangspunt), style.css en icon.png (vierkant pictogram van 90×90 pixels). Het manifest voldoet aan de W3C Manifest for Web Apps-specificatie.

Het manifest manifest.webapp

Het bestand manifest.webapp — het belangrijkste configuratiebestand van de KaiOS-app. Verplichte velden: name (naam), description (beschrijving tot 140 tekens), launch_path (pad naar index.html), icons (pictogrammen van 30×30, 60×60, 90×90, 120×120 pixels). Het veld type: 'certified' (systeem-apps), 'privileged' (toegang tot Web API's), 'web' (zonder speciale rechten). Permissions voor privileged-apps worden opgegeven in de array permissions.

// manifest.webapp — configuratie van KaiOS-app
{
    "name": "Zaklamp",
    "description": "Schakelt de cameraflitser in en uit",
    "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": "Nodig om de flitser in te schakelen"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Het manifest geeft aan dat de app het type privileged heeft — dit geeft toegang tot de camera-API via permissions. De pictogramafmetingen zijn strikt 30×30, 60×60, 90×90 en 120×120 pixels. Het veld orientation beperkt de portretoriëntatie — op telefoons met toetsenbord is er meestal geen versnellingsmeter om het scherm te draaien. fullscreen: true verbergt de statusbalk.

HTML-pagina structuur

Een HTML5-pagina in KaiOS gebruikt standaard tags, rekening houdend met het beperkte scherm (meestal 240×320 pixels). De meta-tag viewport is verplicht: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS ondersteunt geen aanraakgebeurtenissen (geen aanraakscherm op telefoons met toetsenbord), alle navigatie gaat via toetsen: ArrowUp, ArrowDown voor beweging, Enter voor selectie, Back om terug te keren.

// index.html — eenvoudige zaklamp-app voor KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Zaklamp</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Uit</div>
        <div id="hint">Druk op Enter om in te schakelen</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('Camera niet beschikbaar: ' + 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 ? 'Ingeschakeld' : 'Uitgeschakeld';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Fout: ' + e.message);
            }
        }

        // Afhandeling van hardware Enter-toets
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

De app Zaklamp gebruikt de MozCamera API om de cameraflitser te bedienen. De gebruiker drukt op de hardware Enter-toets — de keydown-handler wordt geactiveerd en schakelt flashMode tussen on en off. De status wordt weergegeven in een tekstblok met de klasse status-on/status-off voor visuele indicatie. MozCamera API is alleen beschikbaar voor privileged-apps met camera-toestemming in het manifest.

KaiOS Web API: werken met telefoon en hardware

KaiOS Web API — een reeks JavaScript-interfaces die toegang bieden tot de hardwaremogelijkheden van de telefoon. De meeste API's zijn eigen Mozilla-extensies (met moz-voorvoegsel) en niet beschikbaar in gewone browsers. Om API's te gebruiken, moet de app het type privileged of certified hebben in het manifest.

Belangrijkste Web API's

MozMobileConnection — netwerkinformatie: operator, signaalniveau, netwerktype (4G/3G/2G), IMEI, roamingstatus. MozTelephony — gespreksbeheer: nummer kiezen, beantwoorden, beëindigen, conferentie, gespreksstatus. MozSms — SMS en MMS verzenden en ontvangen, berichten op SIM beheren. MozContacts — telefoonboek lezen en schrijven. MozBluetooth — Bluetooth-beheer: apparaten detecteren, koppelen, bestanden overzetten. Push API — pushmeldingen van de server ontvangen.

// Werken met contacten en gesprekken via KaiOS Web API
const TelephonyManager = {
    // Een gesprek voeren naar een nummer
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API niet beschikbaar');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Gesprek tot stand gebracht');
        call.ondisconnected = () => console.log('Gesprek beëindigd');
        return call;
    },

    // Contactenlijst ophalen uit het telefoonboek
    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);
            };
        });
    },

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

// Voorbeeld van gebruik
TelephonyManager.getContacts()
    .then(contacts => console.log('Contacten gevonden:', contacts.length))
    .catch(err => console.error(err));

Het object TelephonyManager combineert drie belangrijke KaiOS API's: mozTelephony voor gesprekken, mozContacts voor het telefoonboek en mozSms voor berichten. getAll() met cursor — patroon voor asynchroon lezen van grote hoeveelheden gegevens (typisch voor contacten met meer dan 1000 vermeldingen). Alle API's retourneren DOMRequest met onsuccess- en onerror-handlers.

Beperkingen van Web API's

KaiOS Web API's hebben beperkingen: gespreks- en SMS-API's zijn alleen beschikbaar op telefoons (niet op tablets), camera — alleen met fysieke camera, Bluetooth — beperkt HSP/HFP-profiel. Push API vereist ondersteuning van een Google Firebase (FCM)-server of een eigen server. De geolocatie-API gebruikt A-GPS of Cell ID, afhankelijk van hardware-ondersteuning.

UI en navigatie: T9, knoppen en scherm 240×320

De KaiOS-gebruikersinterface is gericht op bediening met het T9-toetsenbord en hardware-knoppen. De standaard schermresolutie — 240×320 pixels (QVGA) bij de meeste telefoons met toetsenbord. Het ontbreken van een aanraakscherm betekent dat alle navigatie plaatsvindt via keydown/keyup-gebeurtenissen: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (of Escape).

Focusbeheer

KaiOS ondersteunt CSS :focus niet op de gebruikelijke manier — focus wordt beheerd via tabindex en JavaScript. De ontwikkelaar moet handmatig het huidige geselecteerde element bijhouden en de focus verplaatsen bij toetsindrukking. Het wordt aanbevolen data-index te gebruiken op lijstelementen om navigatie te vereenvoudigen. Het geselecteerde element wordt meestal gemarkeerd via de klasse .selected met een contrasterende background-color CSS-eigenschap.

// Focusnavigatie door lijst voor 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();
    }
}

// Navigatie initialiseren voor menulijst
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Element geselecteerd:', e.detail.index);
});

De klasse ListNavigation implementeert volledige focusnavigatie voor KaiOS. ArrowUp/ArrowDown verplaatsen de focus cyclisch over elementen met data-index. Enter roept de aangepaste gebeurtenis itemselected aan. Backspace/Escape keren terug naar het vorige scherm. scrollIntoView met block: nearest scrolt automatisch het scherm wanneer het element buiten het zichtbare gebied valt.

CSS voor KaiOS

KaiOS 2.5 ondersteunt CSS 2.1 + gedeeltelijk CSS3 (border-radius, box-shadow, gradients). Flexbox wordt gedeeltelijk ondersteund in KaiOS 2.5, volledig in KaiOS 3.0, inclusief CSS Grid. Voor compatibiliteit wordt aanbevolen een float-lay-out met vaste breedte te gebruiken. Het standaardlettertype is TizenSans of Noto Sans CJK voor Aziatische markten. Tekengrootte — 14-16 pixels voor hoofdinhoud, 18-20 voor koppen.

KaiStore en publiceren van apps

KaiStore — de officiële app-store voor KaiOS, vooraf geïnstalleerd op alle apparaten. De ontwikkelaar registreert zich op het KaiOS Developer Portal (developer.kaiostech.com), uploadt het ondertekende ZIP-pakket en vult de beschrijving in. Moderatie controleert veiligheid, stabiliteit en naleving van het contentbeleid. De gemiddelde controletijd is 3-5 werkdagen.

App ondertekenen

KaiOS vereist digitale ondertekening van de app via een KaiOS Certificate. De ontwikkelaar genereert een sleutelpaar (privé + openbaar) met het hulpprogramma kaios-sign, stuurt de openbare sleutel naar het KaiOS Developer Portal en ontvangt een certificaat. Het ondertekende .zip-bestand bevat de handtekening in de map META-INF. Zonder handtekening wordt de app alleen op ontwikkelapparaten geïnstalleerd.

Distributiemodel en monetisatie

KaiStore ondersteunt gratis apps, advertenties via de KaiOS Ads SDK en in-app aankopen via operator facturering (Direct Carrier Billing). De commissie van KaiStore is 30% van de inkomsten. Een alternatief kanaal is voorinstallatie via OEM-fabrikanten (Jio, Nokia, Alcatel, Doro). Voor voorinstallatie is een direct contract met de apparaatfabrikant vereist.

Beperkingen van KaiStore

KaiStore ondersteunt geen betaalde apps in sommige landen (betaling alleen via operator facturering). De app-grootte is beperkt tot 10 MB voor download via 2G/3G-netwerken. De app mag niet meer dan 50 MB RAM gebruiken. Toegang tot de mozMobileConnection API zonder expliciete vermelding in het manifest is verboden. Schending van het beleid leidt tot blokkering van het ontwikkelaarsaccount.