KaiOS: ano ito, arkitektura ng sistema at mga web application

Ano ang KaiOS?

KaiOS — isang mobile operating system para sa mga push-button phone, na binuo ng kumpanyang KaiOS Technologies. Ang sistema ay batay sa open-source project na Boot to Gecko (B2G) mula sa Mozilla, na orihinal na ginawa bilang web alternative sa Android para sa ultra-budget devices. Ang unang commercial release ay naganap noong 2017 sa Reliance JioPhone phone sa India.

Ayon sa Counterpoint Research (Q2 2025), ang KaiOS ay may 2.8% ng pandaigdigang mobile OS market, kasunod ng Android (72%) at iOS (27%), ngunit nauuna sa iba pang platforms. Sa India, ang bahagi ng KaiOS ay umaabot sa 14% salamat sa JioPhone program. Ang average na presyo ng isang KaiOS device ay 20-30 US dollars, na ginagawang mahalaga ang sistema para sa mga developing market.

Ang pangunahing katangian ng KaiOS — lahat ng application ay web application. Ang developer ay nagsusulat ng code sa HTML5, CSS at JavaScript, ipinapakete ito sa isang ZIP archive na may manifest at inilalathala sa KaiStore. Hindi sinusuportahan ng sistema ang pag-install ng native na APK files — tanging Open Web Apps ayon sa W3C Widget specification.

Kasaysayan ng mga bersyon ng KaiOS

KaiOS 2.5 (2018) — unang stable na bersyon sa Gecko 48 kernel, naka-install sa JioPhone 1. KaiOS 2.5.3 (2021) — suporta para sa Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, pinahusay na performance, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — pag-optimize para sa 256 MB RAM, bagong Web API Audio Channel, pinahusay na seguridad TLS 1.3.

Arkitektura ng KaiOS: Linux kernel at Gecko engine

Ang arkitektura ng KaiOS ay binubuo ng tatlong pangunahing layer: Linux kernel (Gonk), web engine na Gecko at user interface na Gaia. Gonk — ang hardware-dependent layer, kasama ang mga driver, HAL (Hardware Abstraction Layer), RIL (Radio Interface Layer) modem stack at suporta sa mga sensor. Mula sa Android Open Source Project (AOSP) ay kinuha ang bootloader, mga driver at ilang library.

Gonk — hardware layer

Ang Gonk ay nagbibigay ng access sa Gecko sa hardware: camera, Bluetooth, Wi-Fi, GPS, audio, vibration, sensors. Hindi tulad ng Android, kung saan ang mga application ay isinusulat para sa Dalvik/ART, sa KaiOS ang mga application ay pumupunta sa hardware sa pamamagitan ng Web API na isinasalin ng Gecko sa Gonk IPC. Ang radio interface (RIL) ay nagbibigay ng 4G VoLTE, SMS, USSD at pamamahala ng SIM card.

Gecko — web engine

Gecko sa KaiOS ay hindi lamang isang browser engine, kundi isang buong application runtime environment. Lahat ng HTML5 application ay gumagana sa loob ng Gecko Process Manager, na naghihiwalay sa bawat application sa magkakahiwalay na proseso. Ang Gecko ay nagpapatupad ng W3C Widget Packaging specification at Mozilla extensions para sa hardware access. Ang bersyon ng Gecko ay nagtatakda kung aling Web API ang available sa developer.

Gaia — user interface

Gaia — ang web interface ng OS mismo: lock screen, home screen (launcher), notification panel, dialer screen, contacts, SMS client. Lahat ng system application ay parehong Open Web Apps. Maaaring palitan ng developer ang standard camera o keyboard ng sarili nitong application, sa pamamagitan ng pagrehistro ng kaukulang activity handler sa manifest.

// Sinusuri ang bersyon ng KaiOS at availability ng 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 };
}

// Sinusuri ang pagkakaroon ng Google Apps (KaiOS 2.5.3+ lang)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Paggamit ng vibration na may availability check
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibration, pause, vibration
    }
}

Ang function na checkKaiOSVersion ay nagbabasa ng User Agent upang matukoy ang bersyon ng KaiOS at sinusuri ang availability ng mga pangunahing Web API. Sa bersyon 2.5, available ang mozMobileConnection, mozTelephony, mozSms — wala ang mga ito sa ordinaryong browser at natatangi sa KaiOS. Ang function na triggerHapticFeedback ay gumagamit ng Vibration API na may backward compatibility.

Paglikha ng application para sa KaiOS: istraktura at manifest

Application ng KaiOS — isang ZIP archive (format .zip, hindi .apk) na naglalaman ng HTML files, CSS, JavaScript, mga larawan at manifest. Ang istraktura ng minimal na application ay kinabibilangan ng manifest.webapp (paglalarawan ng application), index.html (entry point), style.css at icon.png (square icon na 90×90 pixels). Ang manifest ay sumusunod sa W3C Manifest for Web Apps specification.

Manifest na manifest.webapp

Ang file na manifest.webapp — ang pangunahing configuration file ng KaiOS application. Mga mandatoryong field: name (pangalan), description (paglalarawan hanggang 140 character), launch_path (path papunta sa index.html), icons (mga icon na may sukat na 30×30, 60×60, 90×90, 120×120 pixels). Ang field na type: 'certified' (system applications), 'privileged' (access sa Web API), 'web' (walang espesyal na karapatan). Ang permissions para sa privileged applications ay tinutukoy sa permissions array.

// manifest.webapp — configuration ng KaiOS application
{
    "name": "Flashlight",
    "description": "Binubuksan at isinasara ang flash ng camera",
    "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": "Kailangan para buksan ang flash"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Ipinapakita ng manifest na ang application ay may uri na privileged — nagbibigay ito ng access sa camera API sa pamamagitan ng permissions. Ang laki ng icon ay mahigpit na 30×30, 60×60, 90×90 at 120×120 pixels. Ang field na orientation ay naglilimita sa portrait orientation — sa mga push-button phone ay karaniwang walang accelerometer para paikutin ang screen. Ang fullscreen: true ay nagtatago ng status bar.

Istraktura ng HTML page

Ang HTML5 page sa KaiOS ay gumagamit ng standard na mga tag na isinasaalang-alang ang limitadong screen (karaniwang 240×320 pixels). Ang meta-tag na viewport ay sapilitan: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. Hindi sinusuportahan ng KaiOS ang touch events (walang touch screen sa mga push-button phone), lahat ng nabigasyon ay sa pamamagitan ng mga key: ArrowUp, ArrowDown para sa paggalaw, Enter para sa pagpili, Back para sa pagbabalik.

// index.html — simpleng flashlight application para sa KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Flashlight</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Naka-off</div>
        <div id="hint">Pindutin ang Enter para i-on</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('Hindi available ang camera: ' + 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 ? 'Naka-on' : 'Naka-off';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Error: ' + e.message);
            }
        }

        // Pag-handle ng hardware Enter button
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

Ang application na Flashlight ay gumagamit ng MozCamera API para kontrolin ang flash ng camera. Pinindot ng user ang hardware Enter button — na-trigger ang keydown handler na nagpapalipat-lipat ng flashMode sa pagitan ng on at off. Ang status ay ipinapakita sa text block na may class na status-on/status-off para sa visual indication. Ang MozCamera API ay available lamang para sa privileged applications na may camera permission sa manifest.

Web API ng KaiOS: pagtatrabaho sa telepono at hardware

KaiOS Web API — isang set ng JavaScript interfaces na nagbibigay ng access sa hardware capabilities ng telepono. Karamihan sa mga API ay proprietary Mozilla extensions (may moz prefix) at hindi available sa ordinaryong browser. Para magamit ang API, ang application ay dapat may uri na privileged o certified sa manifest.

Mga pangunahing Web API

MozMobileConnection — impormasyon ng network: operator, signal level, uri ng network (4G/3G/2G), IMEI, status ng roaming. MozTelephony — pamamahala ng tawag: pag-dial ng numero, pagsagot, pagtatapos, conference, status ng tawag. MozSms — pagpapadala at pagtanggap ng SMS, MMS, pamamahala ng mensahe sa SIM. MozContacts — pagbabasa at pagsusulat ng phonebook. MozBluetooth — pamamahala ng Bluetooth: pagtuklas ng device, pagpapares, paglilipat ng file. Push API — pagtanggap ng push notification mula sa server.

// Pagtatrabaho sa mga contact at tawag sa pamamagitan ng Web API ng KaiOS
const TelephonyManager = {
    // Pagtawag sa numero
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Hindi available ang Telephony API');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Naitatag ang tawag');
        call.ondisconnected = () => console.log('Natapos ang tawag');
        return call;
    },

    // Pagkuha ng listahan ng contact mula sa phonebook
    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);
            };
        });
    },

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

// Halimbawa ng paggamit
TelephonyManager.getContacts()
    .then(contacts => console.log('Nahanap na mga contact:', contacts.length))
    .catch(err => console.error(err));

Ang object na TelephonyManager ay pinagsasama ang tatlong pangunahing KaiOS API: mozTelephony para sa mga tawag, mozContacts para sa phonebook at mozSms para sa mga mensahe. Ang getAll() na may cursor — pattern para sa asynchronous na pagbabasa ng malaking halaga ng data (karaniwan para sa mga contact na may higit sa 1000 entries). Lahat ng API ay nagbabalik ng DOMRequest na may mga handler na onsuccess at onerror.

Mga limitasyon ng Web API

Ang Web API ng KaiOS ay may mga limitasyon: ang mga API ng tawag at SMS ay available lamang sa mga telepono (hindi sa tablets), camera — tanging may pisikal na camera, Bluetooth — limitadong HSP/HFP profile. Ang Push API ay nangangailangan ng suporta ng Google Firebase (FCM) server o sariling server. Ang Geolocation API ay gumagamit ng A-GPS o Cell ID depende sa hardware support.

UI at nabigasyon: T9, mga button at screen na 240×320

Ang user interface ng KaiOS ay nakatuon sa kontrol gamit ang T9 keyboard at hardware buttons. Ang standard na resolution ng screen — 240×320 pixels (QVGA) sa karamihan ng mga push-button phone. Ang kawalan ng touch screen ay nangangahulugan na lahat ng nabigasyon ay sa pamamagitan ng keydown/keyup events: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (o Escape).

Pamamahala ng focus

Hindi sinusuportahan ng KaiOS ang CSS :focus sa karaniwang paraan — ang focus ay pinamamahalaan sa pamamagitan ng tabindex at JavaScript. Ang developer ay dapat manu-manong subaybayan ang kasalukuyang napiling elemento at ilipat ang focus sa pagpindot ng key. Inirerekomenda ang paggamit ng data-index sa mga elemento ng listahan upang pasimplehin ang nabigasyon. Ang napiling elemento ay karaniwang naka-highlight sa pamamagitan ng class na .selected na may CSS property na background-color na contrast color.

// Focus navigation sa listahan para sa 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();
    }
}

// Initialization ng navigation para sa menu list
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Napiling elemento:', e.detail.index);
});

Ang class na ListNavigation ay nagpapatupad ng kumpletong focus navigation para sa KaiOS. Ang ArrowUp/ArrowDown ay naglilipat ng focus nang paikot sa mga elementong may data-index. Ang Enter ay nagta-trigger ng custom event na itemselected. Ang Backspace/Escape ay bumabalik sa nakaraang screen. Ang scrollIntoView na may block: nearest ay awtomatikong nag-scroll ng screen kapag ang elemento ay lumabas sa visible area.

CSS para sa KaiOS

Ang KaiOS 2.5 ay sumusuporta sa CSS 2.1 + bahagyang CSS3 (border-radius, box-shadow, gradients). Ang Flexbox ay bahagyang sinusuportahan sa KaiOS 2.5, ganap sa KaiOS 3.0 kasama ang CSS Grid. Inirerekomenda ang paggamit ng float layout na may fixed width para sa compatibility. Ang default na font — TizenSans o Noto Sans CJK para sa Asian markets. Laki ng text — 14-16 pixels para sa pangunahing nilalaman, 18-20 para sa mga heading.

KaiStore at pag-publish ng aplikasyon

KaiStore — ang opisyal na app store para sa KaiOS, naka-preinstall sa lahat ng device. Ang developer ay nagrerehistro sa KaiOS Developer Portal (developer.kaiostech.com), nag-upload ng pinirmahang ZIP package at nagpupuno ng paglalarawan. Sinusuri ng moderasyon ang seguridad, stability at pagsunod sa content policy. Ang average na oras ng pagsusuri — 3-5 araw ng trabaho.

Pagpirma ng application

Ang KaiOS ay nangangailangan ng digital signing ng application sa pamamagitan ng KaiOS Certificate. Ang developer ay gumagawa ng key pair (pribado + publiko) sa pamamagitan ng kaios-sign utility, nagpapadala ng public key sa KaiOS Developer Portal at tumatanggap ng certificate. Ang pinirmahang .zip file ay naglalaman ng signature sa META-INF folder. Kung walang pirma, ang application ay naka-install lamang sa dev devices.

Modelo ng distribusyon at monetization

Ang KaiStore ay sumusuporta sa libreng application, advertising sa pamamagitan ng KaiOS Ads SDK at in-app purchases sa pamamagitan ng carrier billing (Direct Carrier Billing). Komisyon ng KaiStore — 30% ng kita. Alternatibong channel — pre-install sa pamamagitan ng OEM manufacturers (Jio, Nokia, Alcatel, Doro). Para sa pre-install kinakailangan ang direktang kontrata sa manufacturer ng device.

Mga limitasyon ng KaiStore

Hindi sinusuportahan ng KaiStore ang bayad na application sa ilang bansa (pagbabayad lamang sa pamamagitan ng carrier billing). Ang laki ng application ay limitado sa 10 MB para sa pag-download sa pamamagitan ng 2G/3G networks. Ang application ay hindi dapat gumamit ng higit sa 50 MB ng RAM. Ipinagbabawal ang access sa mozMobileConnection API nang walang malinaw na pagtukoy sa manifest. Ang paglabag sa patakaran ay nagreresulta sa pag-block ng developer account.