Tizen: podstata vývoje pro Samsung Watch a Smart TV

Co je Tizen?

Tizen je open-source operační systém spravovaný společnostmi Samsung a Linux Foundation. První komerční vydání Tizen 1.0 proběhlo v roce 2012. Systém je založen na jádře Linux a používá vlastní architekturu frameworků pro různé typy zařízení: Tizen Mobile (smartphony — projekt uzavřen v roce 2017), Tizen Watch (hodinky), Tizen TV (televizory) a Tizen IoT (inteligentní domácnost).

Od roku 2021 používá Samsung Tizen převážně v nositelných zařízeních a televizorech. Všechny chytré hodinky Galaxy Watch před rokem 2021 běžely na Tizen (Galaxy Watch, Watch Active, Watch 3). Počínaje Galaxy Watch 4 přešel Samsung na Wear OS s One UI Watch, ale Tizen je nadále podporován pro stávající zařízení a televizory. Podle Samsungu (Tizen Ecosystem Report, 2025) má Tizen TV nainstalováno více než 180 milionů televizorů po celém světě.

Klíčovou vlastností Tizen je podpora dvou vývojových paradigmat: nativní aplikace (C/C++) s maximálním výkonem a webové aplikace (HTML5, CSS, JavaScript) pro rychlý vývoj. Oba typy mají přístup k Tizen Device API — obálkám pro práci s Bluetooth, NFC, Wi-Fi, senzory, kamerou a multimédii.

Historie verzí Tizen

Tizen 2.3 (2014) — první stabilní verze pro smartphony Samsung Z. Tizen 3.0 (2017) — vylepšený multitasking, podpora Vulkan, 64bitová architektura. Tizen 4.0 (2018) — přepracované frameworky, podpora AI akcelerace na NPU. Tizen 5.5 (2020) — Tizen TV s AVPlay 2.0, WebAssembly, vylepšené vykreslování. Tizen 6.0 (2022) — podpora ML inference na zařízení, protokol Matter pro IoT.

Architektura Tizen: jádro Linux a frameworky

Architektura Tizen je postavena na modulárním principu s vícevrstvou strukturou. Nejnižší vrstvou je jádro Linux se záplatami pro energetickou účinnost a úlohy v reálném čase (RT_PREEMPT pro TV a audio). Nad jádrem je hardwarová abstrakční vrstva (HAL), která poskytuje jednotný přístup k ovladačům kamery, senzorů, Bluetooth, Wi-Fi, NFC a displeje (přes DirectFB nebo Wayland).

Vrstva Core Framework

Vrstva Core Framework zahrnuje Application Framework (správa životního cyklu aplikací), UI Framework (EFL — Enlightenment Foundation Libraries pro UI, DALi — 3D engine pro hry a animace), Multimedia Framework (kamera, audio, video přes GStreamer a MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) a Security Framework (SELinux, Smack, Systém oprávnění Tizen).

Vrstva služeb

Vrstva služeb poskytuje systémové služby: Application Manager (spouštění, zastavování, multitasking), Package Manager (instalace/odinstalace aplikací, formáty .tpk a .wgt), Location Manager (GPS, Wi-Fi polohování, Geofence), Sensor Manager (akcelerometr, gyroskop, barometr, monitor srdečního tepu), Context Manager (rozpoznávání aktivity uživatele: chůze, běh, spánek).

Device API pro webové aplikace

Tizen poskytuje Device API — JavaScriptová rozhraní pro webové aplikace, která poskytují přístup ke stejným funkcím jako nativní API. API jsou rozdělena do modulů: Application API, Bluetooth API, Calendar API, Call History API, Contact API, Content API, Data Control API, Download API, Gallery API, Media Controller API, Message API, NFC API, Notification API, Power API, Push API, System Info API, Time API, Web Setting API.

Nativní aplikace Tizen v C/C++

Nativní aplikace Tizen jsou kompilovány do spustitelného souboru ve formátu .tpk (Tizen Package Kit). Hlavním jazykem je C++11/14 s kompilátorem GCC nebo Clang. Vývoj probíhá v Tizen Studio nebo Visual Studio Code s rozšířením Tizen. Nativní aplikace mají přímý přístup k EFL, DALi, GStreamer a všem systémovým API bez zprostředkovatelů, což zajišťuje maximální výkon.

Struktura nativní aplikace

Nativní aplikace obsahuje soubor tizen-manifest.xml (podobný AndroidManifest.xml), jednu nebo více sdílených knihoven (.so) a zdroje (obrázky, písma, lokalizace). Životní cyklus je řízen pomocí app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. UI je vytvářeno pomocí EFL (Edje + Elementary) pro okenní aplikace nebo DALi pro 3D grafiku.

// Nativní aplikace Tizen v C++ s UI EFL
#include <app.h>
#include <efl_extension.h>
#include <dlog.h>

typedef struct appdata {
    Evas_Object *win;
    Evas_Object *conform;
    Evas_Object *label;
} appdata_s;

static void
win_delete_cb(void *data, Evas_Object *obj, void *event_info) {
    ui_app_exit();
}

static void
create_base_gui(appdata_s *ad) {
    // Vytvoření okna Tizen
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Název okna
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — standardní kontejner Tizen pro nositelná zařízení
    ad->conform = efl_add(EFL_UI_CONFORMANT_CLASS, ad->win);
    efl_content_set(ad->win, ad->conform);
    efl_gfx_size_hint_weight_set(ad->conform, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);

    // Textový štítek
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Vítejte v Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Zobrazení okna
    efl_gfx_size_hint_weight_set(ad->label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
    efl_gfx_size_hint_align_set(ad->label, EVAS_HINT_FILL, EVAS_HINT_FILL);
}

static void
app_get_resource_cb(void *data) {
    // Obsluha získávání zdrojů aplikace
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Voláno při vytvoření aplikace
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
    return true;
}

int
main(int argc, char *argv[]) {
    appdata_s ad = {0,};
    ui_app_lifecycle_callback_s event_callback = {0,};

    event_callback.create = app_create_cb;
    return ui_app_main(argc, argv, &event_callback, &ad);
}

Nativní aplikace Tizen Hello World používá EFL (Enlightenment Foundation Libraries) pro uživatelské rozhraní. ui_app_main je vstupní bod Tizen, který přijímá zpětná volání životního cyklu. efl_add vytváří objekty UI prostřednictvím hierarchie Win → Conformant → Label. EFL UI je založeno na kompozitním modelu Edje — popisy motivů jsou psány v souborech .edc a kompilovány do .edj.

Manifest Tizen (tizen-manifest.xml)

Soubor tizen-manifest.xml je konfigurací nativní aplikace. Určuje id (jedinečný identifikátor ve formátu reverzní domény), package (název balíčku), version, label (zobrazený název), author a description. Oprávnění deklarují přístup k API: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Bez uvedení oprávnění způsobí volání odpovídajícího API chybu SECURITY_ERR.

Webové aplikace Tizen v HTML5 a JavaScript

Webové aplikace Tizen jsou aplikace HTML5 zabalené ve formátu .wgt (Widget W3C). Vývoj je totožný s vytvářením běžného webu, ale s dodatečným přístupem k Tizen Device API prostřednictvím globálního objektu tizen. Webové aplikace běží ve vlastním procesu Web Runtime (WRT), založeném na enginu WebKit (Tizen 2.x-4.x) nebo Chromium (Tizen 5.5+).

Struktura webové aplikace

Webová aplikace obsahuje index.html (vstupní bod), config.xml (konfigurace widgetu W3C), CSS, JavaScript a obrázky. Soubor config.xml je podobný manifest.webapp v KaiOS: povinná pole zahrnují widget (id, version, height/width pro hodinky), name, description a author. Oprávnění pro Device API jsou specifikována prostřednictvím prvku tizen:privilege. Sekce CSP (Content Security Policy) omezuje zdroje skriptů.

// config.xml pro webovou aplikaci Tizen Watch
<?xml version="1.0" encoding="UTF-8"?>
<widget xmlns="http://www.w3.org/ns/widgets"
        xmlns:tizen="http://tizen.org/ns/widgets"
        id="com.example.heartrate"
        version="1.0.0"
        height="360" width="360">
    <tizen:application id="com.example.heartrate"
                       package="com.example.heartrate"
                       required_version="4.0"/>
    <name>Měřič tepu</name>
    <description>Měření tepu na Galaxy Watch</description>
    <author>Developer</author>
    <tizen:privilege name="http://tizen.org/privilege/healthinfo"/>
    <tizen:privilege name="http://tizen.org/privilege/sensor"/>
    <tizen:profile name="wearable"/>
    <tizen:content-security-policy>
        default-src 'self'; script-src 'self'; style-src 'self'
    </tizen:content-security-policy>
</widget>

Minimální fragment config.xml ukazuje klíčové prvky: widget s id a verzí, tizen:application s profilem wearable pro kulaté obrazovky hodinek, tizen:privilege pro healthinfo a sensor API a Zásady zabezpečení obsahu omezující načítání obsahu pouze z balíčku aplikace.

// Webová aplikace Tizen Watch: monitorování srdečního tepu
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Kontrola podpory senzoru HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Senzor HRM nebyl nalezen');
            }

            // Získání přístupu k senzoru srdečního tepu
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Senzor HRM inicializován');
        } catch (err) {
            console.error('Chyba inicializace:', err.message);
        }
    },

    startMonitoring() {
        if (!this.hrSensor) return;

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // měření každou sekundu
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Chyba senzoru:', err.message);
                }
            }
        });
    },

    stopMonitoring() {
        if (this.hrSensor && this.isMonitoring) {
            this.hrSensor.stopSensor();
            this.isMonitoring = false;
        }
    },

    updateDisplay(heartRate) {
        // Vizualizace srdečního tepu na kulaté obrazovce 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Kruhový indikátor srdečního tepu
        ctx.beginPath();
        ctx.arc(180, 180, 120, 0, 2 * Math.PI);
        ctx.strokeStyle = '#ff4444';
        ctx.lineWidth = 8;
        ctx.stroke();
    }
};

document.addEventListener('DOMContentLoaded', () => {
    HeartRateMonitor.init().then(() => {
        HeartRateMonitor.startMonitoring();
    });
});

Aplikace HeartRateMonitor používá Tizen Sensor API pro přístup k senzoru HRM hodinek Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') získá senzor srdečního tepu, startSensor spustí měření s intervalem 1 sekundy. Plátno 360×360 vykresluje kruhový indikátor — typické UI paradigma pro kulaté obrazovky hodinek Tizen.

Vývoj pro Tizen Watch: Circle UI a Rotary

Tizen Watch má jedinečné funkce uživatelského rozhraní: kulatý displej (360×360 pixelů na Galaxy Watch), fyzický rámeček (rotary bezel) pro navigaci a tři hardwarová tlačítka: Home, Back a Custom. Vývojář musí přizpůsobit rozhraní kulaté oblasti — rohové prvky mohou být oříznuty. Circle UI je knihovna Samsung s hotovými komponentami pro kulaté obrazovky.

Rotary Bezel

Rotary Bezel — fyzický kroužek kolem obrazovky Galaxy Watch, který se otáčí pro navigaci v seznamech, nastavení hlasitosti a zoom. V Tizen je událost otáčení zpracována prostřednictvím rotarydetector nebo signálu edge EFL. Každý zářez rámečku generuje událost s úhlem otočení (0-360 stupňů). Webové aplikace zpracovávají rámeček prostřednictvím API rotarydetector: tizen.rotarydetector.

// Zpracování Rotary Bezel v Tizen Watch
class RotaryNavigation {
    constructor() {
        this.currentAngle = 0;
        this.sections = document.querySelectorAll('.rotary-section');
        this.currentSection = 0;
        this.init();
    }

    init() {
        // Přihlášení k odběru událostí otáčení rámečku
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — aktuální úhel (0-360)
            // event.direction — 'cw' (po směru hod.) nebo 'ccw' (proti směru hod.)
            this.handleRotation(event);
        });

        // Aktivace rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // změna úhlu
        this.currentAngle += delta;

        // Určení směru a pohybu
        if (delta > 0) {
            // Otáčení po směru hodin — další prvek
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Otáčení proti směru hodin — předchozí prvek
            this.currentSection = Math.max(this.currentSection - 1, 0);
        }

        this.updateUI();
    }

    updateUI() {
        this.sections.forEach((el, i) => {
            el.classList.toggle('active', i === this.currentSection);
            el.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
        });
    }

    destroy() {
        tizen.rotarydetector.removeEventListener('rotarydetector');
        tizen.rotarydetector.stop();
    }
}

// Inicializace při načtení aplikace
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

Třída RotaryNavigation se přihlásí k odběru událostí rotarydetector prostřednictvím tizen.rotarydetector.addEventListener. Při otočení rámečku se vypočítá směr (cw/ccw) a delta úhlu. Aktuální sekce je zvýrazněna třídou active. rotarydetector.start() je povinný — bez něj se události negenerují. destroy() se odhlásí a zastaví detektor, aby se zabránilo únikům paměti.

Funkce uživatelského rozhraní pro hodinky

Rozhraní Tizen Watch používá komponenty: RotarySelector(kruhový seznam ovládaný rámečkem), CircularList(seznam s kruhovým posouváním), RadialMenu(radiální menu s ikonami uspořádanými do kruhu), EdgePanel(panel vysouvající se z okraje obrazovky) a CircleProgressBar(kruhový indikátor průběhu). Všechny komponenty jsou optimalizovány pro rozlišení 360×360 a berou v úvahu absenci rohů obrazovky. Minimální velikost dotykových cílů je 48 pixelů.

Vývoj pro Tizen TV: aplikace pro Smart TV

Tizen TV — platforma pro Samsung Smart TV s vlastním SDK a emulátorem. Aplikace pro TV se dělí na dva typy: webové aplikace (HTML5/JS) a nativní aplikace (C/C++). Webové aplikace pro TV jsou rychlejší a snadněji se vyvíjejí, ale nativní poskytují lepší výkon pro video a hry. Tizen TV používá dálkový ovladač s D-padem pro navigaci.

AVPlay API pro video

AVPlay API — klíčové API Tizen TV pro přehrávání videa. Podporuje formáty H.264, H.265 (HEVC), VP9, AV1. Rozlišení až 8K na TV 2024+. AVPlay API poskytuje hardwarové dekódování, HDR10+, Dolby Atmos, titulky a více zvukových stop. Ovládání pomocí play(), pause(), stop(), seekTo(position), setDisplayRect(). Stream může být lokální soubor nebo URL HLS/DASH.

// Video přehrávač pro Tizen TV s AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Kontrola dostupnosti AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API je nedostupné');
            }

            this.avplay = webapis.avplay;
            this.avplay.open(url);

            // Nastavení zobrazení na celou obrazovku TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Konfigurace zvuku (Dolby Atmos, pokud je podporován)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Video je připraveno k přehrávání');
                },
                (error) => {
                    console.error('Chyba přípravy:', error);
                }
            );
        } catch (err) {
            console.error('Chyba inicializace:', err);
        }
    }

    play() {
        if (this.isReady) this.avplay.play();
    }

    pause() {
        this.avplay.pause();
    }

    seekTo(positionMs) {
        this.avplay.seekTo(positionMs);
    }

    setSubtitle(url, encoding) {
        this.avplay.setStreamingProperty('SUBTITLE', JSON.stringify({
            url: url,
            encoding: encoding || 'UTF-8'
        }));
    }
}

// Použití
const player = new TizenVideoPlayer('video-area');
player.init('https://example.com/stream.m3u8');
player.setSubtitle('https://example.com/subs.vtt', 'UTF-8');

Třída TizenVideoPlayer demonstruje práci s AVPlay API. webapis.avplay.open() otevře mediální stream (lokální nebo HLS/DASH). setDisplayRect nastaví oblast vykreslování — na TV je to obvykle celá obrazovka při 3840×2160. prepareAsync je asynchronní příprava se zpětnými voláními. AVPlay podporuje adaptivní přenosovou rychlost přes ADAPTIVE_INFO a titulky přes vlastnost SUBTITLE.

Galaxy Store a publikování aplikací

Samsung Galaxy Store — oficiální obchod s aplikacemi pro Tizen (hodinky, TV, IoT). Registrace vývojáře je zdarma prostřednictvím programu Samsung Developers. Vývojáři nahrávají aplikace ve formátu .tpk (nativní) nebo .wgt (webové), podepsané certifikátem Samsung. Moderace trvá 2-5 pracovních dní. Galaxy Store je k dispozici ve 190 zemích.

Podepisování aplikací

Tizen vyžaduje digitální podpis aplikací certifikátem Samsung. Proces: vygenerování autorského certifikátu prostřednictvím Samsung Certificate Manager, vytvoření distribučního certifikátu pro obchod, podepsání balíčku prostřednictvím Tizen Studio (Build Signed Package). Certifikát je propojen s účtem vývojáře. Bez podpisu lze aplikaci nainstalovat pouze na vývojářská zařízení s zapnutým vývojářským režimem.

Model zpeněžení

Galaxy Store podporuje placené aplikace (30% provize z prvních 10 000 $, poté 25%), předplatné (25%), reklamu prostřednictvím Samsung Ads a nákupy v aplikaci prostřednictvím Samsung IAP. Pro TV aplikace je k dispozici model Smart TV Premium Channels. Minimální cena je 0,99 $. Výplaty probíhají měsíčně po dosažení hranice 100 $.