KaiOS: Was es ist, Systemarchitektur und Webanwendungen

Was ist KaiOS?

KaiOS ist ein mobiles Betriebssystem für Tastenhandys, entwickelt von KaiOS Technologies. Das System basiert auf dem Open-Source-Projekt Boot to Gecko (B2G) von Mozilla, das ursprünglich als webbasierter Android-Ersatz für Ultra-Budget-Geräte entwickelt wurde. Die erste kommerzielle Veröffentlichung erfolgte 2017 auf dem Reliance JioPhone in Indien.

Laut Counterpoint Research (Q2 2025) hält KaiOS 2,8% des weltweiten Marktes für mobile Betriebssysteme, hinter Android (72%) und iOS (27%), aber vor anderen Plattformen. In Indien erreicht KaiOS dank des JioPhone-Programms einen Anteil von 14%. Der Durchschnittspreis eines KaiOS-Geräts liegt bei 20-30 US-Dollar, was es für Schwellenmärkte besonders wichtig macht.

Das Hauptmerkmal von KaiOS ist, dass alle Anwendungen Webanwendungen sind. Der Entwickler schreibt Code in HTML5, CSS und JavaScript, verpackt ihn in einem ZIP-Archiv mit Manifest und veröffentlicht ihn im KaiStore. Das System unterstützt keine nativen APK-Dateien — nur Open Web Apps gemäß der W3C Widget-Spezifikation.

KaiOS-Versionsgeschichte

KaiOS 2.5 (2018) — erste stabile Version auf Gecko 48 Kernel, ausgeliefert auf dem JioPhone 1. KaiOS 2.5.3 (2021) — Unterstützung für Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, verbesserte Leistung, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — Optimierung für 256 MB RAM, neue Audio Channel Web API, verbesserte TLS 1.3-Sicherheit.

KaiOS-Architektur: Linux-Kernel und Gecko-Engine

Die KaiOS-Architektur besteht aus drei Hauptschichten: Linux-Kernel (Gonk), Gecko-Web-Engine und Gaia-Benutzeroberfläche. Gonk ist die hardwareabhängige Schicht, die Treiber, HAL (Hardware Abstraction Layer), RIL (Radio Interface Layer) Modem-Stack und Sensorunterstützung umfasst. Der Bootloader, Treiber und einige Bibliotheken stammen aus dem Android Open Source Project (AOSP).

Gonk — Hardwareschicht

Gonk bietet Gecko Zugriff auf die Hardware: Kamera, Bluetooth, Wi-Fi, GPS, Audio, Vibration, Sensoren. Im Gegensatz zu Android, wo Apps für Dalvik/ART geschrieben werden, greifen Apps in KaiOS über Web-APIs auf die Hardware zu, die von Gecko in Gonk IPC übersetzt werden. Die Funkschnittstelle (RIL) bietet 4G VoLTE, SMS, USSD und SIM-Kartenverwaltung.

Gecko — Web-Engine

Gecko in KaiOS ist nicht nur eine Browser-Engine, sondern eine vollständige Anwendungslaufzeitumgebung. Alle HTML5-Anwendungen laufen innerhalb des Gecko Process Manager, der jede Anwendung in einen separaten Prozess isoliert. Gecko implementiert die W3C Widget Packaging-Spezifikation und Mozilla-Erweiterungen für den Hardwarezugriff. Die Gecko-Version bestimmt, welche Web-APIs dem Entwickler zur Verfügung stehen.

Gaia — Benutzeroberfläche

Gaia ist die Weboberfläche des OS selbst: Sperrbildschirm, Startbildschirm (Launcher), Benachrichtigungsfeld, Wählhilfe, Kontakte, SMS-Client. Alle Systemanwendungen sind dieselben Open Web Apps. Ein Entwickler kann die Standardkamera oder -tastatur durch seine eigene App ersetzen, indem er den entsprechenden Activity-Handler im Manifest registriert.

// Überprüfung der KaiOS-Version und API-Verfügbarkeit
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 };
}

// Überprüfung der Google Apps-Verfügbarkeit (nur KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Verwendung von Vibration mit Verfügbarkeitsprüfung
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // Vibration, Pause, Vibration
    }
}

Die Funktion checkKaiOSVersion liest den User Agent, um die KaiOS-Version zu bestimmen, und prüft die Verfügbarkeit wichtiger Web-APIs. In Version 2.5 sind mozMobileConnection, mozTelephony, mozSms verfügbar — sie fehlen in normalen Browsern und sind einzigartig für KaiOS. Die Funktion triggerHapticFeedback verwendet die Vibration API mit Abwärtskompatibilität.

Erstellen einer App für KaiOS: Struktur und Manifest

Eine KaiOS-App ist ein ZIP-Archiv (Format .zip, nicht .apk), das HTML-Dateien, CSS, JavaScript, Bilder und ein Manifest enthält. Die minimale App-Struktur umfasst manifest.webapp (App-Beschreibung), index.html (Einstiegspunkt), style.css und icon.png (quadratisches Symbol 90×90 Pixel). Das Manifest folgt der W3C Manifest for Web Apps-Spezifikation.

Manifest manifest.webapp

Die Datei manifest.webapp ist die Stammkonfigurationsdatei einer KaiOS-App. Pflichtfelder: name (Name), description (Beschreibung bis 140 Zeichen), launch_path (Pfad zu index.html), icons (Symbolgrößen 30×30, 60×60, 90×90, 120×120). Das Feld type: 'certified' (System-Apps), 'privileged' (Web-API-Zugriff), 'web' (keine speziellen Berechtigungen). Berechtigungen für privilegierte Apps werden im Array permissions angegeben.

// manifest.webapp — KaiOS-Anwendungskonfiguration
{
    "name": "Taschenlampe",
    "description": "Schaltet den Kamerablitz ein und aus",
    "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": "Erforderlich zum Aktivieren des Blitzes"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Das Manifest gibt an, dass die App vom Typ privileged ist — dies gewährt Zugriff auf die Kamera-API über Berechtigungen. Die Symbolgrößen sind streng 30×30, 60×60, 90×90 und 120×120 Pixel. Das Feld orientation schränkt den Hochformatmodus ein — Tastenhandys haben normalerweise keinen Beschleunigungsmesser für die Bildschirmdrehung. fullscreen: true blendet die Statusleiste aus.

HTML-Seitenstruktur

Eine HTML5-Seite in KaiOS verwendet Standard-Tags unter Berücksichtigung des begrenzten Bildschirms (normalerweise 240×320 Pixel). Der Viewport-Meta-Tag ist erforderlich: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS unterstützt keine Touch-Ereignisse (kein Touchscreen bei Tastenhandys); die gesamte Navigation erfolgt über Tasten: ArrowUp, ArrowDown zum Bewegen, Enter zum Auswählen, Back zum Zurückkehren.

// index.html — einfache Taschenlampen-App für KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Taschenlampe</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Aus</div>
        <div id="hint">Drücken Sie Enter zum Einschalten</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('Kamera nicht verfügbar: ' + 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 ? 'Ein' : 'Aus';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Fehler: ' + e.message);
            }
        }

        // Behandlung der Hardware-Enter-Taste
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

Die App Taschenlampe verwendet die MozCamera API zur Steuerung des Kamerablitzes. Der Benutzer drückt die Hardware-Enter-Taste — der keydown-Handler wird ausgelöst und schaltet flashMode zwischen on und off um. Der Status wird in einem Textblock mit den Klassen status-on/status-off zur visuellen Anzeige dargestellt. Die MozCamera API ist nur für privilegierte Apps mit Kameraberechtigung im Manifest verfügbar.

KaiOS Web API: Arbeiten mit Telefon und Hardware

KaiOS Web API ist eine Sammlung von JavaScript-Schnittstellen, die Zugriff auf die Hardware-Funktionen des Telefons bieten. Die meisten APIs sind proprietäre Mozilla-Erweiterungen (moz-präfixiert) und in normalen Browsern nicht verfügbar. Um die API zu nutzen, muss die App im Manifest den Typ privileged oder certified haben.

Wichtige Web-APIs

MozMobileConnection — Netzwerkinformationen: Betreiber, Signalstärke, Netzwerktyp (4G/3G/2G), IMEI, Roaming-Status. MozTelephony — Anrufverwaltung: Wählen, Annehmen, Beenden, Konferenzschaltung, Anrufstatus. MozSms — Senden und Empfangen von SMS, MMS, Verwaltung von SIM-Nachrichten. MozContacts — Lesen und Schreiben des Telefonbuchs. MozBluetooth — Bluetooth-Verwaltung: Geräteerkennung, Pairing, Dateiübertragung. Push API — Empfang von Push-Benachrichtigungen vom Server.

// Arbeiten mit Kontakten und Anrufen über KaiOS Web API
const TelephonyManager = {
    // Anruf nach Nummer tätigen
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API nicht verfügbar');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Anruf hergestellt');
        call.ondisconnected = () => console.log('Anruf beendet');
        return call;
    },

    // Kontaktliste aus dem Telefonbuch abrufen
    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 senden
    async sendSms(phoneNumber, message) {
        if (!navigator.mozSms) {
            throw new Error('SMS API nicht verfügbar');
        }
        const request = navigator.mozSms.send(phoneNumber, message);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
};

// Anwendungsbeispiel
TelephonyManager.getContacts()
    .then(contacts => console.log('Kontakte gefunden:', contacts.length))
    .catch(err => console.error(err));

Das Objekt TelephonyManager kombiniert drei wichtige KaiOS-APIs: mozTelephony für Anrufe, mozContacts für das Telefonbuch und mozSms für Nachrichten. getAll() mit einem Cursor ist ein Muster zum asynchronen Lesen großer Datenmengen (typisch für Kontakte mit 1000+ Einträgen). Alle APIs geben ein DOMRequest mit onsuccess- und onerror-Handlern zurück.

Einschränkungen der Web-APIs

Die KaiOS Web-APIs haben Einschränkungen: Anruf- und SMS-APIs sind nur auf Telefonen verfügbar (nicht auf Tablets), Kamera — nur bei vorhandener physischer Kamera, Bluetooth — eingeschränktes HSP/HFP-Profil. Die Push API erfordert Serverunterstützung von Google Firebase (FCM) oder einen eigenen Server. Die Geolokalisierungs-API verwendet A-GPS oder Cell ID, abhängig von der Hardwareunterstützung.

UI und Navigation: T9, Tasten und 240×320-Bildschirm

Die KaiOS-Benutzeroberfläche ist für die Steuerung über T9-Tastatur und Hardware-Tasten ausgelegt. Die Standardbildschirmauflösung beträgt bei den meisten Tastenhandys 240×320 Pixel (QVGA). Das Fehlen eines Touchscreens bedeutet, dass die gesamte Navigation über keydown/keyup-Ereignisse erfolgt: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (oder Escape).

Fokusverwaltung

KaiOS unterstützt CSS :focus nicht in der üblichen Weise — der Fokus wird über tabindex und JavaScript verwaltet. Der Entwickler muss das aktuell ausgewählte Element manuell verfolgen und den Fokus bei Tastendruck verschieben. Die Verwendung von data-index auf Listenelementen wird empfohlen, um die Navigation zu vereinfachen. Das ausgewählte Element wird normalerweise mit einer .selected-Klasse mit einer kontrastierenden CSS-Hintergrundfarbe hervorgehoben.

// Fokusnavigation durch Liste für 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();
    }
}

// Navigation für eine Menüliste initialisieren
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Element ausgewählt:', e.detail.index);
});

Die Klasse ListNavigation implementiert die vollständige Fokusnavigation für KaiOS. ArrowUp/ArrowDown bewegen den Fokus zyklisch durch Elemente mit data-index. Enter löst ein benutzerdefiniertes itemselected-Ereignis aus. Backspace/Escape kehrt zum vorherigen Bildschirm zurück. scrollIntoView mit block: nearest scrollt automatisch den Bildschirm, wenn der sichtbare Bereich verlassen wird.

CSS für KaiOS

KaiOS 2.5 unterstützt CSS 2.1 + teilweise CSS3 (border-radius, box-shadow, gradients). Flexbox wird in KaiOS 2.5 teilweise unterstützt, in KaiOS 3.0 vollständig einschließlich CSS Grid. Für die Kompatibilität wird ein float-basiertes Layout mit fester Breite empfohlen. Die Standardschriftart ist TizenSans oder Noto Sans CJK für asiatische Märkte. Die Textgröße beträgt 14-16 Pixel für Hauptinhalte, 18-20 für Überschriften.

KaiStore und App-Veröffentlichung

KaiStore ist der offizielle App-Store für KaiOS, der auf allen Geräten vorinstalliert ist. Entwickler registrieren sich im KaiOS Developer Portal (developer.kaiostech.com), laden ein signiertes ZIP-Paket hoch und füllen die Beschreibung aus. Die Moderation überprüft Sicherheit, Stabilität und Einhaltung der Inhaltsrichtlinien. Die durchschnittliche Überprüfungszeit beträgt 3-5 Werktage.

App-Signierung

KaiOS erfordert die digitale Signierung der App durch ein KaiOS Certificate. Der Entwickler generiert ein Schlüsselpaar (privat + öffentlich) mit dem Dienstprogramm kaios-sign, sendet den öffentlichen Schlüssel an das KaiOS Developer Portal und erhält ein Zertifikat. Die signierte .zip-Datei enthält die Signatur im Ordner META-INF. Ohne Signatur kann die App nur auf Entwicklungsgeräten installiert werden.

Verteilungsmodell und Monetarisierung

KaiStore unterstützt kostenlose Apps, Werbung über das KaiOS Ads SDK und In-App-Käufe über Carrier Billing (Direct Carrier Billing). Die Provision von KaiStore beträgt 30% der Einnahmen. Ein alternativer Kanal ist die Vorinstallation über OEM-Hersteller (Jio, Nokia, Alcatel, Doro). Für die Vorinstallation ist ein direkter Vertrag mit dem Gerätehersteller erforderlich.

KaiStore-Einschränkungen

KaiStore unterstützt keine kostenpflichtigen Apps in einigen Ländern (Zahlung nur über Carrier Billing). Die App-Größe ist auf 10 MB für Downloads über 2G/3G-Netze begrenzt. Die App darf nicht mehr als 50 MB RAM verwenden. Der Zugriff auf die mozMobileConnection-API ist ohne explizite Deklaration im Manifest untersagt. Verstöße gegen die Richtlinien führen zur Sperrung des Entwicklerkontos.