KaiOS: ce este, arhitectura sistemului și aplicații web

Ce este KaiOS?

KaiOS — un sistem de operare mobil pentru telefoane cu tastatură, dezvoltat de compania KaiOS Technologies. Sistemul se bazează pe proiectul open-source Boot to Gecko (B2G) de la Mozilla, creat inițial ca o alternativă web pentru Android pe dispozitive ultra-bugetare. Prima lansare comercială a avut loc în 2017 pe telefonul Reliance JioPhone din India.

Potrivit Counterpoint Research (Q2 2025), KaiOS deține 2,8% din piața globală a sistemelor de operare mobile, fiind depășit de Android (72%) și iOS (27%), dar în fața celorlalte platforme. În India, cota KaiOS atinge 14% datorită programului JioPhone. Prețul mediu al unui dispozitiv pe KaiOS este de 20-30 de dolari SUA, ceea ce face sistemul esențial pentru piețele emergente.

Caracteristica cheie a KaiOS — toate aplicațiile sunt aplicații web. Dezvoltatorul scrie cod în HTML5, CSS și JavaScript, îl împachetează într-o arhivă ZIP cu manifest și îl publică în KaiStore. Sistemul nu suportă instalarea fișierelor APK native — doar Open Web Apps conform specificației W3C Widget.

Istoricul versiunilor KaiOS

KaiOS 2.5 (2018) — prima versiune stabilă pe nucleul Gecko 48, instalată pe JioPhone 1. KaiOS 2.5.3 (2021) — suport pentru Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, performanță îmbunătățită, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimizare pentru 256 MB RAM, nou Web API Audio Channel, securitate îmbunătățită TLS 1.3.

Arhitectura KaiOS: nucleul Linux și motorul Gecko

Arhitectura KaiOS constă din trei straturi cheie: nucleul Linux (Gonk), motorul web Gecko și interfața utilizator Gaia. Gonk — stratul dependent de hardware, incluzând drivere, HAL (Hardware Abstraction Layer), stiva modem RIL (Radio Interface Layer) și suport pentru senzori. Din Android Open Source Project (AOSP) sunt preluate bootloader-ul, driverele și unele biblioteci.

Gonk — stratul hardware

Gonk oferă Gecko-ului acces la hardware: cameră, Bluetooth, Wi-Fi, GPS, audio, vibrații, senzori. Spre deosebire de Android, unde aplicațiile sunt scrise pentru Dalvik/ART, în KaiOS aplicațiile accesează hardware-ul prin Web API traduse de Gecko în Gonk IPC. Interfața radio (RIL) asigură 4G VoLTE, SMS, USSD și gestionarea cartelelor SIM.

Gecko — motorul web

Gecko în KaiOS nu este doar un motor de browser, ci un mediu de execuție complet pentru aplicații. Toate aplicațiile HTML5 funcționează în interiorul Gecko Process Manager, care izolează fiecare aplicație într-un proces separat. Gecko implementează specificația W3C Widget Packaging și extensiile Mozilla pentru acces la hardware. Versiunea Gecko determină ce Web API sunt disponibile dezvoltatorului.

Gaia — interfața utilizator

Gaia — interfața web a sistemului însuși: ecran de blocare, ecran de pornire (launcher), panou de notificări, ecran de apelare, contacte, client SMS. Toate aplicațiile de sistem sunt aceleași Open Web Apps. Dezvoltatorul poate înlocui camera sau tastatura standard cu propria aplicație, înregistrând handler-ul de activitate corespunzător în manifest.

// Verificarea versiunii KaiOS și a disponibilității 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 };
}

// Verificarea prezenței Google Apps (doar KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Utilizarea vibrației cu verificarea disponibilității
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibrație, pauză, vibrație
    }
}

Funcția checkKaiOSVersion citește User Agent pentru a determina versiunea KaiOS și verifică disponibilitatea Web API-urilor cheie. În versiunea 2.5 sunt disponibile mozMobileConnection, mozTelephony, mozSms — acestea lipsesc în browserele obișnuite și sunt unice pentru KaiOS. Funcția triggerHapticFeedback folosește Vibration API cu compatibilitate inversă.

Crearea unei aplicații pentru KaiOS: structură și manifest

Aplicația KaiOS — o arhivă ZIP (format .zip, nu .apk) care conține fișiere HTML, CSS, JavaScript, imagini și manifest. Structura unei aplicații minime include manifest.webapp (descrierea aplicației), index.html (punct de intrare), style.css și icon.png (icoană pătrată de 90×90 pixeli). Manifestul respectă specificația W3C Manifest for Web Apps.

Manifestul manifest.webapp

Fișierul manifest.webapp — fișierul de configurare principal al aplicației KaiOS. Câmpuri obligatorii: name (nume), description (descriere de până la 140 de caractere), launch_path (calea către index.html), icons (icoane de dimensiuni 30×30, 60×60, 90×90, 120×120 pixeli). Câmpul type: 'certified' (aplicații de sistem), 'privileged' (acces la Web API), 'web' (fără drepturi speciale). Permisiunile pentru aplicațiile privileged sunt specificate în tabloul permissions.

// manifest.webapp — configurarea aplicației KaiOS
{
    "name": "Lanternă",
    "description": "Pornește și oprește blițul camerei",
    "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": "Necesar pentru pornirea blițului"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Manifestul specifică faptul că aplicația are tipul privileged — acest lucru oferă acces la camera API prin permissions. Dimensiunile icoanelor sunt strict 30×30, 60×60, 90×90 și 120×120 pixeli. Câmpul orientation limitează orientarea portret — pe telefoanele cu tastatură de obicei nu există accelerator pentru rotirea ecranului. fullscreen: true ascunde bara de stare.

Structura paginii HTML

Pagina HTML5 în KaiOS folosește tag-uri standard ținând cont de ecranul limitat (de obicei 240×320 pixeli). Meta-tag-ul viewport este obligatoriu: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS nu suportă evenimente tactile (nu există ecran tactil pe telefoanele cu tastatură), toată navigarea se face prin taste: ArrowUp, ArrowDown pentru mișcare, Enter pentru selecție, Back pentru revenire.

// index.html — aplicație lanternă simplă pentru KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Lanternă</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Oprit</div>
        <div id="hint">Apăsați Enter pentru a porni</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 indisponibilă: ' + 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 ? 'Pornit' : 'Oprit';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Eroare: ' + e.message);
            }
        }

        // Gestionarea butonului hardware Enter
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

Aplicația Lanternă folosește MozCamera API pentru a controla blițul camerei. Utilizatorul apasă butonul hardware Enter — se declanșează handler-ul keydown care comută flashMode între on și off. Statusul este afișat într-un bloc de text cu clasa status-on/status-off pentru indicare vizuală. MozCamera API este disponibil doar pentru aplicațiile privileged cu permisiunea camera în manifest.

Web API KaiOS: lucrul cu telefonul și echipamentele

KaiOS Web API — un set de interfețe JavaScript care oferă acces la capacitățile hardware ale telefonului. Majoritatea API-urilor sunt extensii proprietare Mozilla (cu prefixul moz) și nu sunt disponibile în browserele obișnuite. Pentru a utiliza API-urile, aplicația trebuie să aibă tipul privileged sau certified în manifest.

Principalele Web API

MozMobileConnection — informații despre rețea: operator, nivel semnal, tip rețea (4G/3G/2G), IMEI, status roaming. MozTelephony — gestionarea apelurilor: formare număr, preluare, încheiere, conferință, status apel. MozSms — trimitere și primire SMS, MMS, gestionarea mesajelor pe SIM. MozContacts — citirea și scrierea agendei telefonice. MozBluetooth — gestionarea Bluetooth: detectare dispozitive, împerechere, transfer fișiere. Push API — primirea notificărilor push de la server.

// Lucrul cu contacte și apeluri prin Web API KaiOS
const TelephonyManager = {
    // Efectuarea unui apel către un număr
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API indisponibil');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Apel stabilit');
        call.ondisconnected = () => console.log('Apel încheiat');
        return call;
    },

    // Obținerea listei de contacte din agenda telefonică
    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);
            };
        });
    },

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

// Exemplu de utilizare
TelephonyManager.getContacts()
    .then(contacts => console.log('Contacte găsite:', contacts.length))
    .catch(err => console.error(err));

Obiectul TelephonyManager combină trei API-uri cheie KaiOS: mozTelephony pentru apeluri, mozContacts pentru agenda telefonică și mozSms pentru mesaje. getAll() cu cursor — model pentru citirea asincronă a volumelor mari de date (tipic pentru contacte cu peste 1000 de înregistrări). Toate API-urile returnează DOMRequest cu handler-e onsuccess și onerror.

Limitări ale Web API

Web API-urile KaiOS au limitări: API-urile de apeluri și SMS sunt disponibile doar pe telefoane (nu pe tablete), camera — doar cu cameră fizică, Bluetooth — profil limitat HSP/HFP. Push API necesită suportul serverului Google Firebase (FCM) sau al unui server propriu. API-ul de geolocație folosește A-GPS sau Cell ID în funcție de suportul hardware.

UI și navigare: T9, butoane și ecran 240×320

Interfața utilizator KaiOS este orientată spre controlul cu tastatura T9 și butoanele hardware. Rezoluția standard a ecranului — 240×320 pixeli (QVGA) la majoritatea telefoanelor cu tastatură. Absența ecranului tactil înseamnă că toată navigarea se realizează prin evenimente keydown/keyup: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (sau Escape).

Gestionarea focusului

KaiOS nu suportă CSS :focus în mod obișnuit — focusul este gestionat prin tabindex și JavaScript. Dezvoltatorul trebuie să urmărească manual elementul selectat curent și să mute focusul la apăsarea tastelor. Se recomandă utilizarea data-index pe elementele de listă pentru a simplifica navigarea. Elementul selectat este de obicei evidențiat prin clasa .selected cu proprietatea CSS background-color de culoare contrastantă.

// Navigarea prin focus pe listă pentru 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();
    }
}

// Inițializarea navigării pentru lista de meniu
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Element selectat:', e.detail.index);
});

Clasa ListNavigation implementează navigarea completă prin focus pentru KaiOS. ArrowUp/ArrowDown mută focusul ciclic pe elementele cu data-index. Enter declanșează evenimentul personalizat itemselected. Backspace/Escape revin la ecranul anterior. scrollIntoView cu block: nearest derulează automat ecranul când elementul iese din zona vizibilă.

CSS pentru KaiOS

KaiOS 2.5 suportă CSS 2.1 + parțial CSS3 (border-radius, box-shadow, gradients). Flexbox este suportat parțial în KaiOS 2.5, complet în KaiOS 3.0, inclusiv CSS Grid. Se recomandă utilizarea layout-ului float cu lățime fixă pentru compatibilitate. Fontul implicit — TizenSans sau Noto Sans CJK pentru piețele asiatice. Dimensiunea textului — 14-16 pixeli pentru conținut principal, 18-20 pentru titluri.

KaiStore și publicarea aplicațiilor

KaiStore — magazinul oficial de aplicații pentru KaiOS, preinstalat pe toate dispozitivele. Dezvoltatorul se înregistrează pe KaiOS Developer Portal (developer.kaiostech.com), încarcă pachetul ZIP semnat și completează descrierea. Moderarea verifică securitatea, stabilitatea și conformitatea cu politica de conținut. Timpul mediu de verificare — 3-5 zile lucrătoare.

Semnarea aplicației

KaiOS necesită semnarea digitală a aplicației prin KaiOS Certificate. Dezvoltatorul generează o pereche de chei (privată + publică) prin utilitarul kaios-sign, trimite cheia publică pe KaiOS Developer Portal și primește un certificat. Fișierul .zip semnat conține semnătura în folderul META-INF. Fără semnătură, aplicația se instalează doar pe dispozitive de dezvoltare.

Model de distribuție și monetizare

KaiStore suportă aplicații gratuite, publicitate prin KaiOS Ads SDK și achiziții in-app prin facturarea operatorului (Direct Carrier Billing). Comisionul KaiStore — 30% din venit. Canal alternativ — preinstalare prin producătorii OEM (Jio, Nokia, Alcatel, Doro). Pentru preinstalare este necesar un contract direct cu producătorul de dispozitive.

Limitări ale KaiStore

KaiStore nu suportă aplicații plătite în unele țări (plată doar prin facturarea operatorului). Dimensiunea aplicației este limitată la 10 MB pentru încărcare prin rețele 2G/3G. Aplicația nu trebuie să utilizeze mai mult de 50 MB de RAM. Accesul la API mozMobileConnection fără specificare explicită în manifest este interzis. Încălcarea politicilor duce la blocarea contului dezvoltatorului.