KaiOS: mi ez, rendszerarchitektúra és webalkalmazások

Mi az a KaiOS?

KaiOS — egy mobil operációs rendszer nyomógombos telefonokhoz, amelyet a KaiOS Technologies fejlesztett ki. A rendszer a Mozilla nyílt forráskódú Boot to Gecko (B2G) projektjén alapul, amelyet eredetileg webes Android-alternatívának hoztak létre ultraelosztott eszközökhöz. Az első kereskedelmi kiadás 2017-ben történt a Reliance JioPhone telefonon Indiában.

A Counterpoint Research (Q2 2025) szerint a KaiOS a mobil operációs rendszerek globális piacának 2,8%-át birtokolja, lemaradva az Android (72%) és iOS (27%) mögött, de megelőzve a többi platformot. Indiában a KaiOS részesedése eléri a 14%-ot a JioPhone programnak köszönhetően. Egy KaiOS-eszköz átlagos ára 20-30 amerikai dollár, ami a rendszert kulcsfontosságúvá teszi a fejlődő piacok számára.

A KaiOS legfontosabb jellemzője — minden alkalmazás webalkalmazás. A fejlesztő HTML5, CSS és JavaScript kódot ír, ZIP-archívumba csomagolja manifesttel, és közzéteszi a KaiStore-ban. A rendszer nem támogatja natív APK-fájlok telepítését — csak Open Web Apps a W3C Widget specifikáció szerint.

A KaiOS verziótörténete

KaiOS 2.5 (2018) — az első stabil verzió a Gecko 48 kernelen, a JioPhone 1-re telepítve. KaiOS 2.5.3 (2021) — Google Assistant, Google Maps Go, YouTube Go támogatás. KaiOS 3.0 (2022) — Gecko 84, jobb teljesítmény, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimalizálás 256 MB RAM-ra, új Web API Audio Channel, továbbfejlesztett TLS 1.3 biztonság.

KaiOS architektúra: Linux kernel és Gecko motor

A KaiOS architektúrája három kulcsrétegből áll: Linux kernel (Gonk), Gecko webmotor és Gaia felhasználói felület. Gonk — a hardverfüggő réteg, amely illesztőprogramokat, HAL-t (Hardware Abstraction Layer), RIL (Radio Interface Layer) modem vermet és érzékelő-támogatást tartalmaz. Az Android Open Source Project (AOSP)-ből a bootloader, illesztőprogramok és néhány könyvtár származik.

Gonk — hardverréteg

A Gonk biztosítja a Gecko számára a hardver elérését: kamera, Bluetooth, Wi-Fi, GPS, audio, rezgés, érzékelők. Ellentétben az Androiddal, ahol az alkalmazásokat Dalvik/ART-ra írják, a KaiOS-ben az alkalmazások a Gecko által Gonk IPC-re lefordított Web API-kon keresztül érik el a hardvert. A rádióinterface (RIL) biztosítja a 4G VoLTE-t, SMS-t, USSD-t és a SIM-kártyák kezelését.

Gecko — webmotor

Gecko a KaiOS-ben nem csak böngészőmotor, hanem teljes alkalmazás-futtatókörnyezet. Az összes HTML5-alkalmazás a Gecko Process Manager-en belül működik, amely minden alkalmazást külön folyamatba izolál. A Gecko megvalósítja a W3C Widget Packaging specifikációt és a Mozilla-bővítményeket a hardver eléréséhez. A Gecko verziója határozza meg, hogy mely Web API-k érhetők el a fejlesztő számára.

Gaia — felhasználói felület

Gaia — az operációs rendszer webes felülete: zárolási képernyő, kezdőképernyő (launcher), értesítési panel, tárcsázó képernyő, névjegyzék, SMS-kliens. Az összes rendszeralkalmazás ugyanazok az Open Web Apps. A fejlesztő lecserélheti a szabványos kamerát vagy billentyűzetet saját alkalmazására, ha regisztrálja a megfelelő activity handlert a manifestben.

// KaiOS verziójának és API elérhetőségének ellenőrzése
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 };
}

// Google Apps jelenlétének ellenőrzése (csak KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Rezgés használata elérhetőségi ellenőrzéssel
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // rezgés, szünet, rezgés
    }
}

A checkKaiOSVersion függvény beolvassa a User Agentet a KaiOS verziójának meghatározásához, és ellenőrzi a kulcsfontosságú Web API-k elérhetőségét. A 2.5-ös verzióban elérhető a mozMobileConnection, mozTelephony, mozSms — ezek hiányoznak a szokásos böngészőkből, és egyediek a KaiOS számára. A triggerHapticFeedback függvény a Vibration API-t használja visszafelé kompatibilitással.

Alkalmazás létrehozása KaiOS-re: struktúra és manifest

KaiOS-alkalmazás — egy ZIP-archívum (.zip formátumban, nem .apk), amely HTML-fájlokat, CSS-t, JavaScriptet, képeket és manifestet tartalmaz. A minimális alkalmazás struktúrája magában foglalja a manifest.webapp-ot (alkalmazás leírása), index.html-t (belépési pont), style.css-t és icon.png-t (90×90 pixeles négyzet alakú ikon). A manifest megfelel a W3C Manifest for Web Apps specifikációnak.

A manifest.webapp fájl

A manifest.webapp fájl — a KaiOS-alkalmazás fő konfigurációs fájlja. Kötelező mezők: name (név), description (leírás legfeljebb 140 karakter), launch_path (útvonal az index.html-hez), icons (30×30, 60×60, 90×90, 120×120 pixeles ikonok). A type mező: 'certified' (rendszeralkalmazások), 'privileged' (hozzáférés a Web API-khoz), 'web' (különleges jogosultságok nélkül). A privileged alkalmazások engedélyei a permissions tömbben vannak megadva.

// manifest.webapp — KaiOS alkalmazás konfigurációja
{
    "name": "Zseblámpa",
    "description": "Bekapcsolja és kikapcsolja a kamera vakut",
    "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": "Szükséges a vaku bekapcsolásához"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

A manifest jelzi, hogy az alkalmazás privileged típusú — ez engedélyezi a hozzáférést a camera API-hoz a permissions segítségével. Az ikonméretek szigorúan 30×30, 60×60, 90×90 és 120×120 pixel. Az orientation mező korlátozza az álló tájolást — a nyomógombos telefonokban általában nincs gyorsulásmérő a képernyő elforgatásához. A fullscreen: true elrejti az állapotsort.

A HTML-oldal struktúrája

A KaiOS HTML5-oldala szabványos címkéket használ, figyelembe véve a korlátozott képernyőt (általában 240×320 pixel). A viewport meta-címke kötelező: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. A KaiOS nem támogatja az érintési eseményeket (nincs érintőképernyő a nyomógombos telefonokon), a navigáció billentyűkkel történik: ArrowUp, ArrowDown a mozgáshoz, Enter a kiválasztáshoz, Back a visszatéréshez.

// index.html — egyszerű zseblámpa alkalmazás KaiOS-hez
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Zseblámpa</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Kikapcsolva</div>
        <div id="hint">A bekapcsoláshoz nyomja meg az Entert</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('A kamera nem elérhető: ' + 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 ? 'Bekapcsolva' : 'Kikapcsolva';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Hiba: ' + e.message);
            }
        }

        // Hardveres Enter gomb kezelése
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

A Zseblámpa alkalmazás a MozCamera API-t használja a kamera vaku vezérléséhez. A felhasználó megnyomja a hardveres Enter gombot — a keydown kezelő elindul, amely a flashMode-ot on és off között kapcsolja. Az állapot egy szöveges blokkban jelenik meg a status-on/status-off osztállyal vizuális jelzés céljából. A MozCamera API csak a manifestben camera engedéllyel rendelkező privileged alkalmazások számára érhető el.

KaiOS Web API: munka a telefonnal és hardverrel

KaiOS Web API — JavaScript-interfészek gyűjteménye, amelyek hozzáférést biztosítanak a telefon hardveres képességeihez. A legtöbb API a Mozilla saját bővítménye (moz előtaggal), és nem érhető el a szokásos böngészőkben. Az API-k használatához az alkalmazásnak privileged vagy certified típusúnak kell lennie a manifestben.

Fő Web API-k

MozMobileConnection — hálózati információk: szolgáltató, jelerősség, hálózat típusa (4G/3G/2G), IMEI, roaming állapot. MozTelephony — hívások kezelése: szám tárcsázása, fogadás, befejezés, konferencia, hívás állapota. MozSms — SMS, MMS küldése és fogadása, üzenetek kezelése a SIM-en. MozContacts — telefónkönyv olvasása és írása. MozBluetooth — Bluetooth kezelése: eszközök észlelése, párosítás, fájlátvitel. Push API — push értesítések fogadása a szerverről.

// Kapcsolatok és hívások kezelése a KaiOS Web API-n keresztül
const TelephonyManager = {
    // Hívás kezdeményezése egy számra
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('A Telephony API nem elérhető');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('A hívás létrejött');
        call.ondisconnected = () => console.log('A hívás befejeződött');
        return call;
    },

    // Kapcsolatok listájának lekérése a telefónkönyvből
    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 küldése
    async sendSms(phoneNumber, message) {
        if (!navigator.mozSms) {
            throw new Error('Az SMS API nem elérhető');
        }
        const request = navigator.mozSms.send(phoneNumber, message);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
};

// Használati példa
TelephonyManager.getContacts()
    .then(contacts => console.log('Talált névjegyek száma:', contacts.length))
    .catch(err => console.error(err));

A TelephonyManager objektum három kulcsfontosságú KaiOS API-t egyesít: mozTelephony a hívásokhoz, mozContacts a telefónkönyvhöz és mozSms az üzenetekhez. A getAll() kurzorral — minta nagy mennyiségű adat aszinkron olvasásához (jellemző a 1000+ bejegyzéssel rendelkező névjegyzékekre). Az összes API DOMRequest-et ad vissza onsuccess és onerror kezelőkkel.

A Web API-k korlátai

A KaiOS Web API-k korlátozásokkal rendelkeznek: a hívás- és SMS API-k csak telefonokon érhetők el (nem tableteken), kamera — csak fizikai kamerával, Bluetooth — korlátozott HSP/HFP profil. A Push API Google Firebase (FCM) szerver vagy saját szerver támogatását igényli. A helymeghatározási API A-GPS-t vagy Cell ID-t használ a hardver támogatásától függően.

UI és navigáció: T9, gombok és 240×320-as kijelző

A KaiOS felhasználói felülete T9 billentyűzettel és hardveres gombokkal történő vezérlésre orientált. A szabványos képernyőfelbontás — 240×320 pixel (QVGA) a legtöbb nyomógombos telefonban. Az érintőképernyő hiánya azt jelenti, hogy a navigáció keydown/keyup eseményeken keresztül történik: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (vagy Escape).

Fókuszkezelés

A KaiOS nem támogatja a CSS :focus-t a megszokott módon — a fókuszt tabindex és JavaScript segítségével kezelik. A fejlesztőnek manuálisan kell nyomon követnie az aktuálisan kiválasztott elemet és mozgatnia a fókuszt billentyűlenyomáskor. Javasolt a data-index használata a lista elemeken a navigáció egyszerűsítéséhez. A kiválasztott elem általában a .selected osztályon keresztül van kiemelve, kontrasztos background-color CSS tulajdonsággal.

// Fókusznavigáció listában KaiOS-hez
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();
    }
}

// Navigáció inicializálása menülistához
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Kiválasztott elem:', e.detail.index);
});

A ListNavigation osztály teljes fókusznavigációt valósít meg KaiOS-hez. Az ArrowUp/ArrowDown ciklikusan mozgatja a fókuszt a data-index-szel rendelkező elemeken. Az Enter elindítja az itemselected egyéni eseményt. A Backspace/Escape visszatér az előző képernyőre. A scrollIntoView a block: nearest paraméterrel automatikusan görgeti a képernyőt, amikor az elem elhagyja a látható területet.

CSS KaiOS-hez

A KaiOS 2.5 támogatja a CSS 2.1 + részleges CSS3-at (border-radius, box-shadow, gradients). A Flexbox részben támogatott KaiOS 2.5-ben, teljesen KaiOS 3.0-ban, beleértve a CSS Grid-et. Kompatibilitás érdekében javasolt a fix szélességű float elrendezés használata. Az alapértelmezett betűtípus — TizenSans vagy Noto Sans CJK az ázsiai piacokon. A szöveg mérete — 14-16 pixel a fő tartalomhoz, 18-20 a címekhez.

KaiStore és alkalmazások publikálása

KaiStore — a KaiOS hivatalos alkalmazásboltja, amely minden eszközön előre telepítve van. A fejlesztő regisztrál a KaiOS Developer Portalon (developer.kaiostech.com), feltölti az aláírt ZIP-csomagot és kitölti a leírást. A moderáció ellenőrzi a biztonságot, stabilitást és a tartalmi irányelveknek való megfelelést. Az átlagos ellenőrzési idő — 3-5 munkanap.

Alkalmazás aláírása

A KaiOS digitális aláírást követel meg az alkalmazáshoz egy KaiOS Certificate segítségével. A fejlesztő kulcspárt generál (privát + nyilvános) a kaios-sign segédprogrammal, elküldi a nyilvános kulcsot a KaiOS Developer Portalra, és tanúsítványt kap. Az aláírt .zip fájl az aláírást a META-INF mappában tartalmazza. Aláírás nélkül az alkalmazás csak fejlesztői eszközökre telepíthető.

Terjesztési modell és monetizáció

A KaiStore támogatja az ingyenes alkalmazásokat, a hirdetéseket a KaiOS Ads SDK segítségével és az in-app vásárlásokat szolgáltatói számlázáson keresztül (Direct Carrier Billing). A KaiStore jutaléka — a bevétel 30%-a. Alternatív csatorna — előtelepítés OEM-gyártókon keresztül (Jio, Nokia, Alcatel, Doro). Az előtelepítéshez közvetlen szerződés szükséges az eszközgyártóval.

A KaiStore korlátai

A KaiStore néhány országban nem támogatja a fizetős alkalmazásokat (fizetés csak szolgáltatói számlázáson keresztül). Az alkalmazás mérete 10 MB-ra korlátozott 2G/3G hálózatokon keresztüli letöltés esetén. Az alkalmazás nem használhat 50 MB-nál több RAM-ot. A mozMobileConnection API-hoz való hozzáférés kifejezett manifestbeli megjelölés nélkül tilos. Az irányelvek megsértése a fejlesztői fiók letiltásához vezet.