KaiOS: vad är det, systemarkitektur och webbapplikationer

Vad är KaiOS?

KaiOS — ett mobilt operativsystem för knapptelefoner utvecklat av KaiOS Technologies. Systemet är baserat på det öppna källkodsprojektet Boot to Gecko (B2G) från Mozilla, som ursprungligen skapades som ett webbalternativ till Android för ultrabilliga enheter. Den första kommersiella lanseringen ägde rum 2017 på telefonen Reliance JioPhone i Indien.

Enligt Counterpoint Research (Q2 2025) har KaiOS 2,8 % av den globala marknaden för mobila operativsystem, efter Android (72 %) och iOS (27 %), men före andra plattformar. I Indien når KaiOS andel 14 % tack vare JioPhone-programmet. Genomsnittspriset för en KaiOS-enhet är 20-30 US-dollar, vilket gör systemet nyckeln för tillväxtmarknader.

Nyckelfunktionen hos KaiOS — alla appar är webbappar. Utvecklaren skriver kod i HTML5, CSS och JavaScript, paketerar den i ett ZIP-arkiv med manifest och publicerar den i KaiStore. Systemet stöder inte installation av inhemska APK-filer — endast Open Web Apps enligt W3C Widget-specifikationen.

KaiOS versionshistorik

KaiOS 2.5 (2018) — första stabila versionen på Gecko 48-kärnan, installerad på JioPhone 1. KaiOS 2.5.3 (2021) — stöd för Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, förbättrad prestanda, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimering för 256 MB RAM, nytt Web API Audio Channel, förbättrad säkerhet TLS 1.3.

KaiOS arkitektur: Linux-kärna och Gecko-motor

KaiOS arkitektur består av tre nyckellager: Linux-kärnan (Gonk), webbmotorn Gecko och användargränssnittet Gaia. Gonk — det hårdvaruberoende lagret, som inkluderar drivrutiner, HAL (Hardware Abstraction Layer), RIL (Radio Interface Layer) modemstack och sensorstöd. Från Android Open Source Project (AOSP) är bootloader, drivrutiner och några bibliotek hämtade.

Gonk — hårdvarulager

Gonk ger Gecko åtkomst till hårdvara: kamera, Bluetooth, Wi-Fi, GPS, ljud, vibration, sensorer. Till skillnad från Android, där appar skrivs för Dalvik/ART, får appar i KaiOS åtkomst till hårdvara via Web API som översätts av Gecko till Gonk IPC. Radiogränssnittet (RIL) tillhandahåller 4G VoLTE, SMS, USSD och SIM-kortshantering.

Gecko — webbmotor

Gecko i KaiOS är inte bara en webbläsarmotor, utan en fullständig applikationskörningsmiljö. Alla HTML5-appar fungerar inuti Gecko Process Manager, som isolerar varje app i en separat process. Gecko implementerar W3C Widget Packaging-specifikationen och Mozilla-tillägg för hårdvaruåtkomst. Gecko-versionen avgör vilka Web API som är tillgängliga för utvecklaren.

Gaia — användargränssnitt

Gaia — webbgränssnittet för själva operativsystemet: låsskärm, hemskärm (launcher), meddelandepanel, knappsats, kontakter, SMS-klient. Alla systemappar är samma Open Web Apps. Utvecklaren kan ersätta standardkameran eller tangentbordet med sin egen app genom att registrera lämplig activity-handler i manifestet.

// Kontrollera KaiOS-version och API-tillgänglighet
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 };
}

// Kontrollera om Google Apps finns (endast KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Använda vibration med tillgänglighetskontroll
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibration, paus, vibration
    }
}

Funktionen checkKaiOSVersion läser User Agent för att bestämma KaiOS-versionen och kontrollerar tillgängligheten av viktiga Web API. I version 2.5 finns mozMobileConnection, mozTelephony, mozSms — dessa saknas i vanliga webbläsare och är unika för KaiOS. Funktionen triggerHapticFeedback använder Vibration API med bakåtkompatibilitet.

Skapa en app för KaiOS: struktur och manifest

En KaiOS-app — ett ZIP-arkiv (format .zip, inte .apk) som innehåller HTML-filer, CSS, JavaScript, bilder och manifest. Strukturen för en minimal app inkluderar manifest.webapp (appbeskrivning), index.html (startpunkt), style.css och icon.png (kvadratisk ikon 90×90 pixlar). Manifestet följer W3C Manifest for Web Apps-specifikationen.

Manifestet manifest.webapp

Filen manifest.webapp — den viktigaste konfigurationsfilen för KaiOS-appen. Obligatoriska fält: name (namn), description (beskrivning upp till 140 tecken), launch_path (sökväg till index.html), icons (ikoner i storlekarna 30×30, 60×60, 90×90, 120×120 pixlar). Fältet type: 'certified' (systemappar), 'privileged' (åtkomst till Web API), 'web' (utan särskilda rättigheter). Behörigheter för privilegierade appar anges i arrayen permissions.

// manifest.webapp — konfiguration av KaiOS-app
{
    "name": "Ficklampa",
    "description": "Slår på och av kamerans blixt",
    "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": "Behövs för att slå på blixten"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Manifestet anger att appen har typen privileged — detta ger åtkomst till camera API via permissions. Ikonstorlekarna är strikt 30×30, 60×60, 90×90 och 120×120 pixlar. Fältet orientation begränsar porträttorientering — på knapptelefoner finns det vanligtvis ingen accelerometer för att vrida skärmen. fullscreen: true döljer statusfältet.

HTML-sidans struktur

En HTML5-sida i KaiOS använder standardtaggar med hänsyn till den begränsade skärmen (vanligtvis 240×320 pixlar). Meta-taggen viewport är obligatorisk: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS stöder inte pekhändelser (ingen pekskärm på knapptelefoner), all navigering sker via tangenter: ArrowUp, ArrowDown för rörelse, Enter för val, Back för att återvända.

// index.html — enkel ficklampa-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>Ficklampa</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Av</div>
        <div id="hint">Tryck på Enter för att slå på</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('Kameran är inte tillgänglig: ' + 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 ? 'På' : 'Av';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Fel: ' + e.message);
            }
        }

        // Hantering av hårdvaruknappen Enter
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

Appen Ficklampa använder MozCamera API för att styra kamerans blixt. Användaren trycker på hårdvarutangenten Enter — keydown-handler utlöses och växlar flashMode mellan on och off. Status visas i ett textblock med klassen status-on/status-off för visuell indikation. MozCamera API är endast tillgängligt för privilegierade appar med kamera-behörighet i manifestet.

KaiOS Web API: arbete med telefon och hårdvara

KaiOS Web API — en uppsättning JavaScript-gränssnitt som ger åtkomst till telefonens hårdvarufunktioner. De flesta API är proprietära Mozilla-tillägg (med moz-prefix) och är inte tillgängliga i vanliga webbläsare. För att använda API måste appen ha typen privileged eller certified i manifestet.

Viktigaste Web API

MozMobileConnection — nätverksinformation: operatör, signalstyrka, nätverkstyp (4G/3G/2G), IMEI, roamingstatus. MozTelephony — samtalshantering: ringa nummer, svara, avsluta, konferens, samtalsstatus. MozSms — skicka och ta emot SMS, MMS, hantera meddelanden på SIM. MozContacts — läsa och skriva telefonbok. MozBluetooth — Bluetooth-hantering: upptäcka enheter, ihopparning, filöverföring. Push API — ta emot push-meddelanden från servern.

// Arbeta med kontakter och samtal via KaiOS Web API
const TelephonyManager = {
    // Ringa ett samtal till ett nummer
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API är inte tillgängligt');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Samtalet är uppkopplat');
        call.ondisconnected = () => console.log('Samtalet är avslutat');
        return call;
    },

    // Hämta kontaktlista från telefonboken
    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);
            };
        });
    },

    // Skicka SMS
    async sendSms(phoneNumber, message) {
        if (!navigator.mozSms) {
            throw new Error('SMS API är inte tillgängligt');
        }
        const request = navigator.mozSms.send(phoneNumber, message);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
};

// Användningsexempel
TelephonyManager.getContacts()
    .then(contacts => console.log('Hittade kontakter:', contacts.length))
    .catch(err => console.error(err));

Objektet TelephonyManager kombinerar tre viktiga KaiOS-API: mozTelephony för samtal, mozContacts för telefonboken och mozSms för meddelanden. getAll() med markör — mönster för asynkron läsning av stora datamängder (typiskt för kontakter med över 1000 poster). Alla API returnerar DOMRequest med onsuccess- och onerror-hanterare.

Begränsningar för Web API

KaiOS Web API har begränsningar: samtals- och SMS-API är endast tillgängliga på telefoner (inte på surfplattor), kamera — endast med fysisk kamera, Bluetooth — begränsad HSP/HFP-profil. Push API kräver stöd från Google Firebase (FCM)-server eller egen server. Geoplats-API använder A-GPS eller Cell ID beroende på hårdvarustöd.

UI och navigering: T9, knappar och skärm 240×320

Användargränssnittet i KaiOS är inriktat på styrning med T9-tangentbord och hårdvaruknappar. Standard skärmupplösning — 240×320 pixlar (QVGA) på de flesta knapptelefoner. Avsaknaden av pekskärm innebär att all navigering sker via keydown/keyup-händelser: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (eller Escape).

Fokus hantering

KaiOS stöder inte CSS :focus på vanligt sätt — fokus hanteras via tabindex och JavaScript. Utvecklaren måste manuellt hålla reda på det aktuella valda elementet och flytta fokus vid tangenttryckning. Det rekommenderas att använda data-index på listelement för att förenkla navigering. Det valda elementet markeras vanligtvis via klassen .selected med CSS-egenskapen background-color i kontrastfärg.

// Fokusnavigering i lista 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();
    }
}

// Initiera navigering för menylista
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Valt element:', e.detail.index);
});

Klassen ListNavigation implementerar full fokusnavigering för KaiOS. ArrowUp/ArrowDown flyttar fokus cykliskt över element med data-index. Enter anropar den anpassade händelsen itemselected. Backspace/Escape återgår till föregående skärm. scrollIntoView med block: nearest rullar automatiskt skärmen när elementet lämnar det synliga området.

CSS för KaiOS

KaiOS 2.5 stöder CSS 2.1 + delvis CSS3 (border-radius, box-shadow, gradients). Flexbox stöds delvis i KaiOS 2.5, fullt ut i KaiOS 3.0 inklusive CSS Grid. För kompatibilitet rekommenderas float-layout med fast bredd. Standardtypsnitt — TizenSans eller Noto Sans CJK för asiatiska marknader. Textstorlek — 14-16 pixlar för huvudinnehåll, 18-20 för rubriker.

KaiStore och publicering av appar

KaiStore — den officiella appbutiken för KaiOS, förinstallerad på alla enheter. Utvecklaren registrerar sig på KaiOS Developer Portal (developer.kaiostech.com), laddar upp det signerade ZIP-paketet och fyller i beskrivningen. Moderering kontrollerar säkerhet, stabilitet och efterlevnad av innehållspolicy. Genomsnittlig granskningstid — 3-5 arbetsdagar.

App-signering

KaiOS kräver digital signering av appen via KaiOS Certificate. Utvecklaren genererar ett nyckelpar (privat + offentlig) med verktyget kaios-sign, skickar den offentliga nyckeln till KaiOS Developer Portal och får ett certifikat. Den signerade .zip-filen innehåller signaturen i mappen META-INF. Utan signatur installeras appen endast på utvecklingsenheter.

Distributionsmodell och intäktsgenerering

KaiStore stöder gratisappar, annonsering via KaiOS Ads SDK och köp i appen via operatörsfakturering (Direct Carrier Billing). KaiStore-provision — 30 % av intäkterna. Alternativ kanal — förinstallation via OEM-tillverkare (Jio, Nokia, Alcatel, Doro). För förinstallation krävs ett direkt avtal med enhetstillverkaren.

Begränsningar för KaiStore

KaiStore stöder inte betalappar i vissa länder (betalning endast via operatörsfakturering). Appstorleken är begränsad till 10 MB för nedladdning via 2G/3G-nätverk. Appen får inte använda mer än 50 MB RAM. Åtkomst till mozMobileConnection API utan uttryckligt angivande i manifestet är förbjudet. Brott mot policy leder till blockering av utvecklarkontot.