KaiOS: co to jest, architektura systemu i aplikacje webowe

Co to jest KaiOS?

KaiOS — mobilny system operacyjny dla telefonów z klawiaturą, opracowany przez firmę KaiOS Technologies. System bazuje na otwartym projekcie Boot to Gecko (B2G) od Mozilla, który początkowo powstał jako internetowa alternatywa dla Androida w ultra-budżetowych urządzeniach. Pierwsza komercyjna wersja ukazała się w 2017 roku na telefonie Reliance JioPhone w Indiach.

Według Counterpoint Research (Q2 2025), KaiOS zajmuje 2,8% światowego rynku mobilnych systemów operacyjnych, ustępując Androidowi (72%) i iOS (27%), ale wyprzedzając pozostałe platformy. W Indiach udział KaiOS sięga 14% dzięki programowi JioPhone. Średnia cena urządzenia na KaiOS wynosi 20-30 dolarów amerykańskich, co czyni ten system kluczowym dla rynków rozwijających się.

Kluczowa cecha KaiOS — wszystkie aplikacje są aplikacjami internetowymi. Programista pisze kod w HTML5, CSS i JavaScript, pakuje do archiwum ZIP z manifestem i publikuje w KaiStore. System nie obsługuje instalacji natywnych plików APK — tylko Open Web Apps zgodnie ze specyfikacją W3C Widget.

Historia wersji KaiOS

KaiOS 2.5 (2018) — pierwsza stabilna wersja na jądrze Gecko 48, zainstalowana na JioPhone 1. KaiOS 2.5.3 (2021) — obsługa Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, ulepszona wydajność, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optymalizacja pod 256 MB RAM, nowy Web API Audio Channel, ulepszone bezpieczeństwo TLS 1.3.

Architektura KaiOS: jądro Linux i silnik Gecko

Architektura KaiOS składa się z trzech kluczowych warstw: jądra Linux (Gonk), silnika internetowego Gecko i interfejsu użytkownika Gaia. Gonk — warstwa sprzętozależna, obejmująca sterowniki, HAL (Hardware Abstraction Layer), stos modemu RIL (Radio Interface Layer) i obsługę czujników. Z Android Open Source Project (AOSP) zaczerpnięto bootloader, sterowniki i niektóre biblioteki.

Gonk — warstwa sprzętowa

Gonk zapewnia Gecko dostęp do sprzętu: aparatu, Bluetooth, Wi-Fi, GPS, audio, wibracji, czujników. W przeciwieństwie do Androida, gdzie aplikacje pisze się na Dalvik/ART, w KaiOS aplikacje uzyskują dostęp do sprzętu przez Web API tłumaczone przez Gecko na Gonk IPC. Interfejs radiowy (RIL) zapewnia 4G VoLTE, SMS, USSD i zarządzanie kartami SIM.

Gecko — silnik internetowy

Gecko w KaiOS to nie tylko silnik przeglądarki, ale pełnoprawne środowisko uruchomieniowe aplikacji. Wszystkie aplikacje HTML5 działają wewnątrz Gecko Process Manager, który izoluje każdą aplikację w osobnym procesie. Gecko implementuje specyfikację W3C Widget Packaging oraz rozszerzenia Mozilla do dostępu do sprzętu. Wersja Gecko określa, które Web API są dostępne dla programisty.

Gaia — interfejs użytkownika

Gaia — to interfejs internetowy samego systemu: ekran blokady, ekran główny (launcher), panel powiadomień, ekran wybierania numeru, kontakty, klient SMS. Wszystkie aplikacje systemowe to te same Open Web Apps. Programista może zastąpić standardowy aparat lub klawiaturę własną aplikacją, rejestrując odpowiednie activity handler w manifeście.

// Sprawdzanie wersji KaiOS i dostępności 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 };
}

// Sprawdzanie obecności Google Apps (tylko KaiOS 2.5.3+)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Użycie wibracji z sprawdzeniem dostępności
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // wibracja, pauza, wibracja
    }
}

Funkcja checkKaiOSVersion odczytuje User Agent w celu określenia wersji KaiOS i sprawdza dostępność kluczowych Web API. W wersji 2.5 dostępne są mozMobileConnection, mozTelephony, mozSms — są one niedostępne w zwykłych przeglądarkach i unikalne dla KaiOS. Funkcja triggerHapticFeedback używa Vibration API z wsteczną kompatybilnością.

Tworzenie aplikacji dla KaiOS: struktura i manifest

Aplikacja KaiOS — to archiwum ZIP (format .zip, nie .apk), zawierające pliki HTML, CSS, JavaScript, obrazy i manifest. Struktura minimalnej aplikacji obejmuje manifest.webapp (opis aplikacji), index.html (punkt wejścia), style.css i icon.png (kwadratowa ikona 90×90 pikseli). Manifest jest zgodny ze specyfikacją W3C Manifest for Web Apps.

Manifest manifest.webapp

Plik manifest.webapp — główny plik konfiguracyjny aplikacji KaiOS. Wymagane pola: name (nazwa), description (opis do 140 znaków), launch_path (ścieżka do index.html), icons (ikony o rozmiarach 30×30, 60×60, 90×90, 120×120). Pole type: 'certified' (aplikacje systemowe), 'privileged' (dostęp do Web API), 'web' (bez specjalnych uprawnień). Permissions dla aplikacji privileged są określane w tablicy permissions.

// manifest.webapp — konfiguracja aplikacji KaiOS
{
    "name": "Latarka",
    "description": "Włącza i wyłącza lampę błyskową aparatu",
    "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": "Potrzebny do włączenia lampy błyskowej"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

Manifest określa, że aplikacja ma typ privileged — daje to dostęp do camera API przez permissions. Rozmiary ikon to ściśle 30×30, 60×60, 90×90 i 120×120 pikseli. Pole orientation ogranicza orientację pionową — w telefonach z klawiaturą zwykle nie ma akcelerometru do obracania ekranu. fullscreen: true ukrywa pasek stanu.

Struktura strony HTML

Strona HTML5 w KaiOS używa standardowych znaczników z uwzględnieniem ograniczonego ekranu (zwykle 240×320 pikseli). Meta-tag viewport jest obowiązkowy: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS nie obsługuje zdarzeń dotykowych (brak ekranu dotykowego w telefonach z klawiaturą), cała nawigacja odbywa się przez klawisze: ArrowUp, ArrowDown do poruszania się, Enter do wyboru, Back do powrotu.

// index.html — prosta aplikacja latarki dla KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Latarka</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Wyłączony</div>
        <div id="hint">Naciśnij Enter, aby włączyć</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 niedostępna: ' + 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 ? 'Włączony' : 'Wyłączony';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Błąd: ' + e.message);
            }
        }

        // Obsługa przycisku sprzętowego Enter
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

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

Aplikacja Latarka używa MozCamera API do sterowania lampą błyskową aparatu. Użytkownik naciska sprzętowy przycisk Enter — uruchamia się procedura keydown, przełączająca flashMode między on i off. Status jest wyświetlany w bloku tekstowym z klasą status-on/status-off do wizualnej informacji. MozCamera API jest dostępne tylko dla aplikacji privileged z uprawnieniem camera w manifeście.

Web API KaiOS: praca z telefonem i sprzętem

KaiOS Web API — zestaw interfejsów JavaScript zapewniających dostęp do sprzętowych możliwości telefonu. Większość API to zastrzeżone rozszerzenia Mozilla (z prefiksem moz) i są niedostępne w zwykłych przeglądarkach. Aby używać API, aplikacja musi mieć typ privileged lub certified w manifeście.

Główne Web API

MozMobileConnection — informacje o sieci: operator, poziom sygnału, typ sieci (4G/3G/2G), IMEI, status roamingu. MozTelephony — zarządzanie połączeniami: wybieranie numeru, odbieranie, kończenie, połączenia konferencyjne, status połączenia. MozSms — wysyłanie i odbieranie SMS, MMS, zarządzanie wiadomościami w karcie SIM. MozContacts — odczyt i zapis książki telefonicznej. MozBluetooth — zarządzanie Bluetooth: wykrywanie urządzeń, parowanie, przesyłanie plików. Push API — odbieranie powiadomień push z serwera.

// Praca z kontaktami i połączeniami przez Web API KaiOS
const TelephonyManager = {
    // Wykonywanie połączenia na numer
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API niedostępny');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Połączenie nawiązane');
        call.ondisconnected = () => console.log('Połączenie zakończone');
        return call;
    },

    // Pobieranie listy kontaktów z książki telefonicznej
    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);
            };
        });
    },

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

// Przykład użycia
TelephonyManager.getContacts()
    .then(contacts => console.log('Znaleziono kontaktów:', contacts.length))
    .catch(err => console.error(err));

Obiekt TelephonyManager łączy trzy kluczowe API KaiOS: mozTelephony do połączeń, mozContacts do książki telefonicznej i mozSms do wiadomości. getAll() z kursorem — wzorzec do asynchronicznego odczytu dużych ilości danych (typowe dla kontaktów powyżej 1000 wpisów). Wszystkie API zwracają DOMRequest z procedurami onsuccess i onerror.

Ograniczenia Web API

Web API KaiOS mają ograniczenia: API połączeń i SMS są dostępne tylko w telefonach (nie w tabletach), aparat — tylko przy fizycznym aparacie, Bluetooth — ograniczony profil HSP/HFP. Push API wymaga obsługi serwera Google Firebase (FCM) lub własnego serwera. API geolokalizacji używa A-GPS lub Cell ID w zależności od wsparcia sprzętowego.

UI i nawigacja: T9, przyciski i ekran 240×320

Interfejs użytkownika KaiOS jest zorientowany na obsługę z klawiatury T9 i przycisków sprzętowych. Standardowa rozdzielczość ekranu — 240×320 pikseli (QVGA) w większości telefonów z klawiaturą. Brak ekranu dotykowego oznacza, że cała nawigacja jest realizowana przez zdarzenia keydown/keyup: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (lub Escape).

Zarządzanie fokusem

KaiOS nie obsługuje CSS :focus w znany sposób — fokusem zarządza się przez tabindex i JavaScript. Programista musi ręcznie śledzić aktualnie wybrany element i przenosić fokus przy naciśnięciu klawiszy. Zaleca się używanie data-index na elementach listy, aby uprościć nawigację. Wybrany element jest zwykle podświetlany przez klasę .selected z właściwością CSS background-color w kontrastowym kolorze.

// Nawigacja fokusowa po liście dla 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();
    }
}

// Inicjalizacja nawigacji dla listy menu
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Wybrano element:', e.detail.index);
});

Klasa ListNavigation implementuje pełną nawigację fokusową dla KaiOS. ArrowUp/ArrowDown przesuwają fokus cyklicznie po elementach z data-index. Enter wywołuje zdarzenie niestandardowe itemselected. Backspace/Escape wracają do poprzedniego ekranu. scrollIntoView z block: nearest automatycznie przewija ekran, gdy element wyjdzie poza widoczny obszar.

CSS dla KaiOS

KaiOS 2.5 obsługuje CSS 2.1 + częściowo CSS3 (border-radius, box-shadow, gradients). Flexbox jest obsługiwany w KaiOS 2.5 częściowo, w KaiOS 3.0 — w pełni, w tym CSS Grid. Zaleca się używanie układu float o stałej szerokości dla kompatybilności. Domyślna czcionka to TizenSans lub Noto Sans CJK dla rynków azjatyckich. Rozmiar tekstu — 14-16 pikseli dla głównej treści, 18-20 dla nagłówków.

KaiStore i publikacja aplikacji

KaiStore — oficjalny sklep z aplikacjami dla KaiOS, preinstalowany na wszystkich urządzeniach. Programista rejestruje się w KaiOS Developer Portal (developer.kaiostech.com), przesyła podpisany pakiet ZIP i wypełnia opis. Moderacja sprawdza bezpieczeństwo, stabilność i zgodność z polityką treści. Średni czas weryfikacji — 3-5 dni roboczych.

Podpisywanie aplikacji

KaiOS wymaga podpisu cyfrowego aplikacji przez KaiOS Certificate. Programista generuje parę kluczy (prywatny + publiczny) za pomocą narzędzia kaios-sign, wysyła klucz publiczny do KaiOS Developer Portal i otrzymuje certyfikat. Podpisany plik .zip zawiera podpis w folderze META-INF. Bez podpisu aplikacja jest instalowana tylko na urządzeniach deweloperskich.

Model dystrybucji i monetyzacja

KaiStore obsługuje darmowe aplikacje, reklamy przez KaiOS Ads SDK i zakupy w aplikacji przez billing operatora (Direct Carrier Billing). Prowizja KaiStore — 30% od dochodu. Alternatywny kanał — preinstalacja przez producentów OEM (Jio, Nokia, Alcatel, Doro). Do preinstalacji wymagana jest bezpośrednia umowa z producentem urządzeń.

Ograniczenia KaiStore

KaiStore nie obsługuje płatnych aplikacji w wielu krajach (płatność tylko przez billing operatora). Rozmiar aplikacji jest ograniczony do 10 MB przy pobieraniu przez sieci 2G/3G. Aplikacja nie może zużywać więcej niż 50 MB pamięci RAM. Zabroniony jest dostęp do API mozMobileConnection bez jawnego określenia w manifeście. Naruszenie polityki skutkuje blokadą konta programisty.