Tizen: a Samsung Watch és Smart TV fejlesztés lényege

Mi az a Tizen?

Tizen egy nyílt forráskódú operációs rendszer, amelyet a Samsung és a Linux Foundation felügyel. Az első kereskedelmi kiadás, a Tizen 1.0, 2012-ben jelent meg. A rendszer a Linux kernelre épül, és saját keretrendszer-architektúrát használ a különböző eszköztípusokhoz: Tizen Mobile (okostelefonok — a projekt 2017-ben bezárt), Tizen Watch (órák), Tizen TV (televíziók) és Tizen IoT (okos otthon).

2021 óta a Samsung a Tizent főként viselhető eszközökben és televíziókban használja. A 2021 előtti összes Galaxy Watch okosóra Tizenen futott (Galaxy Watch, Watch Active, Watch 3). A Galaxy Watch 4-től kezdve a Samsung áttért a Wear OS-re One UI Watch-csal, de a Tizen továbbra is támogatott a meglévő eszközökön és TV-ken. A Samsung (Tizen Ecosystem Report, 2025) szerint világszerte több mint 180 millió TV-re van telepítve Tizen TV.

A Tizen egyik legfontosabb jellemzője a két fejlesztési paradigma támogatása: natív alkalmazások (C/C++) maximális teljesítménnyel és webalkalmazások (HTML5, CSS, JavaScript) gyors fejlesztéshez. Mindkét típus hozzáfér a Tizen Device API-hoz — Bluetooth, NFC, Wi-Fi, érzékelők, kamera és multimédia használatához szükséges burkolófelületekhez.

Tizen verziótörténet

Tizen 2.3 (2014) — az első stabil verzió Samsung Z okostelefonokhoz. Tizen 3.0 (2017) — továbbfejlesztett multitasking, Vulkan-támogatás, 64 bites architektúra. Tizen 4.0 (2018) — újratervezett keretrendszerek, AI-gyorsítás támogatása NPU-n. Tizen 5.5 (2020) — Tizen TV AVPlay 2.0-val, WebAssembly-vel, javított rendereléssel. Tizen 6.0 (2022) — ML következtetés támogatása az eszközön, Matter protokoll IoT-hez.

Tizen architektúra: Linux kernel és keretrendszerek

A Tizen architektúra moduláris elven épül fel többrétegű struktúrával. A legalsó réteg a Linux kernel energiahatékonysági és valós idejű feladatokhoz (RT_PREEMPT TV-hez és audiohoz) szükséges javításokkal. A kernel felett található a hardverabsztrakciós réteg (HAL), amely egységes hozzáférést biztosít a kamera-, érzékelő-, Bluetooth-, Wi-Fi-, NFC- és kijelző-illesztőprogramokhoz (DirectFB-n vagy Waylanden keresztül).

Core Framework réteg

A Core Framework réteg tartalmazza az Application Framework-et (alkalmazás-életciklus-kezelés), UI Framework-et (EFL — Enlightenment Foundation Libraries a felhasználói felülethez, DALi — 3D motor játékokhoz és animációkhoz), Multimedia Framework-et (kamera, audio, video GStreameren és MediaCodecon keresztül), Network Framework-et (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) és Security Framework-et (SELinux, Smack, Tizen jogosultsági rendszer).

Service réteg

A Service réteg rendszerszolgáltatásokat nyújt: Application Manager (indítás, leállítás, multitasking), Package Manager (alkalmazások telepítése/eltávolítása, .tpk és .wgt formátumok), Location Manager (GPS, Wi-Fi helymeghatározás, Geokerítés), Sensor Manager (gyorsulásmérő, giroszkóp, barométer, pulzusmérő), Context Manager (felhasználói tevékenység felismerése: gyaloglás, futás, alvás).

Device API webalkalmazásokhoz

A Tizen Device API-t biztosít — JavaScript interfészeket webalkalmazásokhoz, amelyek hozzáférést adnak ugyanazokhoz a funkciókhoz, mint a natív API-k. Az API-k modulokra vannak osztva: 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.

Natív Tizen alkalmazások C/C++-ban

A natív Tizen alkalmazások .tpk formátumú (Tizen Package Kit) végrehajtható fájlba fordulnak. Az elsődleges nyelv a C++11/14 GCC vagy Clang fordítóval. A fejlesztés Tizen Studio-ban vagy Visual Studio Code-ban történik a Tizen kiterjesztéssel. A natív alkalmazások közvetlen hozzáféréssel rendelkeznek az EFL-hez, DALi-hoz, GStreamerhez és az összes rendszer API-hoz közvetítők nélkül, maximális teljesítményt biztosítva.

Natív alkalmazás szerkezete

Egy natív alkalmazás tartalmaz egy tizen-manifest.xml fájlt (hasonló az AndroidManifest.xml-hez), egy vagy több megosztott könyvtárat (.so) és erőforrásokat (képek, betűtípusok, lokalizációk). Az életciklust az app_event_cb kezeli: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. A felhasználói felület EFL-en (Edje + Elementary) keresztül épül fel ablakos alkalmazásokhoz, vagy DALi-n keresztül 3D grafikához.

// Natív Tizen alkalmazás C++-ban EFL UI-val
#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) {
    // Tizen ablak létrehozása
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Ablak címe
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — szabványos Tizen konténer viselhető eszközökhöz
    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);

    // Szöveges címke
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Üdvözöljük a Tizen-ben!");
    efl_content_set(ad->conform, ad->label);

    // Ablak megjelenítése
    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) {
    // Alkalmazáserőforrás-beszerzés kezelője
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Az alkalmazás létrehozásakor hívódik meg
    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);
}

A natív Tizen Hello World alkalmazás EFL-t (Enlightenment Foundation Libraries) használ a felhasználói felülethez. A ui_app_main a Tizen belépési pontja, amely életciklus-visszahívásokat fogad. Az efl_add UI objektumokat hoz létre a Win → Conformant → Label hierarchián keresztül. Az EFL UI az Edje összetett modellre épül — a témaleírások .edc fájlokba íródnak, és .edj-be fordulnak.

Tizen manifest (tizen-manifest.xml)

A tizen-manifest.xml fájl a natív alkalmazás konfigurációja. Megadja az id-t (egyedi azonosító fordított domain formátumban), package-t (csomagnév), version-t, label-t (megjelenített név), author-t és description-t. A jogosultságok deklarálják az API-hozzáférést: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Jogosultság megadása nélkül a megfelelő API meghívása SECURITY_ERR hibát eredményez.

Tizen webalkalmazások HTML5-ben és JavaScript-ben

A Tizen webalkalmazások .wgt formátumba (W3C Widget) csomagolt HTML5 alkalmazások. A fejlesztés megegyezik egy normál weboldal létrehozásával, de további hozzáféréssel a Tizen Device API-hoz a globális tizen objektumon keresztül. A webalkalmazások saját Web Runtime (WRT) folyamatban futnak, a WebKit motoron (Tizen 2.x-4.x) vagy Chromiumon (Tizen 5.5+) alapulva.

Webalkalmazás szerkezete

Egy webalkalmazás tartalmaz index.html-t (belépési pont), config.xml-t (W3C Widget konfiguráció), CSS-t, JavaScript-et és képeket. A config.xml fájl hasonló a KaiOS manifest.webapp-jához: a kötelező mezők közé tartozik a widget (id, version, height/width órákhoz), name, description és author. A Device API engedélyei a tizen:privilege elemen keresztül adhatók meg. A CSP (Content Security Policy) szakasz korlátozza a szkriptforrásokat.

// config.xml Tizen Watch webalkalmazáshoz
<?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>Pulzusmérő</name>
    <description>Pulzusmérés a Galaxy Watch készüléken</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>

A minimális config.xml részlet bemutatja a legfontosabb elemeket: widget id-val és verzióval, tizen:application wearable profillal kerek óraképernyőkhöz, tizen:privilege healthinfo és sensor API-hoz, valamint Content Security Policy, amely csak az alkalmazáscsomagból engedi a tartalom betöltését.

// Tizen Watch webalkalmazás: pulzusfigyelés
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // HRM érzékelő támogatásának ellenőrzése
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('A HRM-érzékelő nem található');
            }

            // Hozzáférés a pulzusérzékelőhöz
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('A HRM-érzékelő inicializálva');
        } catch (err) {
            console.error('Inicializálási hiba:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // mérés másodpercenként
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Érzékelőhiba:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Pulzus megjelenítése 360x360-as kerek képernyőn
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Kör alakú pulzusjelző
        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();
    });
});

A HeartRateMonitor alkalmazás a Tizen Sensor API-t használja a Galaxy Watch HRM-érzékelőjének eléréséhez. A tizen.sensorservice.getDefaultSensor('HRM') lekéri a pulzusérzékelőt, a startSensor 1 másodperces időközzel indítja a méréseket. Egy 360×360-as vászon kör alakú jelzőt rajzol — ez a tipikus UI paradigma a kerek Tizen óraképernyőkön.

Tizen Watch fejlesztés: Circle UI és Rotary

A Tizen Watch egyedi UI jellemzőkkel rendelkezik: kerek képernyő (360×360 pixel a Galaxy Watch-on), fizikai keret (rotary bezel) navigációhoz, és három hardver gomb: Home, Back és Custom. A fejlesztőnek a kerek területhez kell igazítania a felületet — a sarokelemek levághatók. A Circle UI egy Samsung könyvtár kész komponensekkel kerek képernyőkhöz.

Rotary Bezel

Rotary Bezel — egy fizikai gyűrű a Galaxy Watch képernyője körül, amely listákban való navigációhoz, hangerőszabályzáshoz és nagyításhoz forog. Tizenben a forgatási eseményt a rotarydetector vagy egy EFL edge jel kezeli. A keret minden bevágása egy eseményt generál egy elforgatási szöggel (0-360 fok). A webalkalmazások a rotarydetector API-n keresztül kezelik a keretet: tizen.rotarydetector.

// Rotary Bezel kezelése Tizen Watch-ban
class RotaryNavigation {
    constructor() {
        this.currentAngle = 0;
        this.sections = document.querySelectorAll('.rotary-section');
        this.currentSection = 0;
        this.init();
    }

    init() {
        // Feliratkozás a keret forgatási eseményeire
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — aktuális szög (0-360)
            // event.direction — 'cw' (óramutató járásával megegyező) vagy 'ccw' (ellentétes)
            this.handleRotation(event);
        });

        // rotarydetector aktiválása
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // szögváltozás
        this.currentAngle += delta;

        // Irány és mozgás meghatározása
        if (delta > 0) {
            // Forgatás az óramutató járásával megegyezően — következő elem
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Forgatás az óramutató járásával ellentétesen — előző elem
            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();
    }
}

// Inicializálás az alkalmazás betöltésekor
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

A RotaryNavigation osztály feliratkozik a rotarydetector eseményekre a tizen.rotarydetector.addEventListener-en keresztül. Amikor a keretet elforgatják, kiszámításra kerül az irány (cw/ccw) és a szög delta. Az aktuális szakasz az active osztállyal van kiemelve. A rotarydetector.start() kötelező — nélküle nem jönnek létre események. A destroy() leiratkozik és leállítja a detektort a memóriaszivárgás megelőzése érdekében.

UI jellemzők órákhoz

A Tizen Watch felület a következő komponenseket használja: RotarySelector (keret által vezérelt kör alakú lista), CircularList (kör alakú görgetéssel rendelkező lista), RadialMenu (radális menü körbe rendezett ikonokkal), EdgePanel (a képernyő széléről becsúszó panel) és CircleProgressBar (kör alakú folyamatjelző). Minden komponens 360×360 felbontásra van optimalizálva, és figyelembe veszi a képernyősarkok hiányát. A minimális érintési célpont méret 48 pixel.

Tizen TV fejlesztés: alkalmazások Smart TV-hez

Tizen TV — egy platform a Samsung Smart TV-hez saját SDK-val és emulátorral. A TV-alkalmazások két típusra oszlanak: webalkalmazások (HTML5/JS) és natív alkalmazások (C/C++). A webalkalmazások TV-hez gyorsabbak és könnyebben fejleszthetők, de a natív alkalmazások jobb teljesítményt nyújtanak videóhoz és játékokhoz. A Tizen TV távirányítót használ D-paddal a navigációhoz.

AVPlay API videóhoz

AVPlay API — a Tizen TV legfontosabb API-ja videólejátszáshoz. Támogatja a H.264, H.265 (HEVC), VP9, AV1 formátumokat. Akár 8K felbontás 2024+ TV-ken. Az AVPlay API hardveres dekódolást, HDR10+, Dolby Atmos-t, feliratokat és több audio sávot biztosít. Vezérlés a play(), pause(), stop(), seekTo(position), setDisplayRect() függvényekkel. A stream lehet helyi fájl vagy HLS/DASH URL.

// Videolejátszó Tizen TV-hez AVPlay API-val
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // AVPlay elérhetőségének ellenőrzése
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('Az AVPlay API nem elérhető');
            }

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

            // Kijelző beállítása teljes képernyős TV-re
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Hang konfigurálása (Dolby Atmos, ha támogatott)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('A videó készen áll a lejátszásra');
                },
                (error) => {
                    console.error('Előkészítési hiba:', error);
                }
            );
        } catch (err) {
            console.error('Inicializálási hiba:', 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'
        }));
    }
}

// Használat
const player = new TizenVideoPlayer('video-area');
player.init('https://example.com/stream.m3u8');
player.setSubtitle('https://example.com/subs.vtt', 'UTF-8');

A TizenVideoPlayer osztály bemutatja az AVPlay API-val való munkát. A webapis.avplay.open() megnyit egy média streamet (helyi vagy HLS/DASH). A setDisplayRect beállítja a megjelenítési területet — TV-n ez általában teljes képernyő 3840×2160 felbontásban. A prepareAsync aszinkron előkészítés visszahívásokkal. Az AVPlay támogatja az adaptív bitsebességet az ADAPTIVE_INFO-n keresztül és a feliratokat a SUBTITLE tulajdonságon keresztül.

Galaxy Store és alkalmazások publikálása

Samsung Galaxy Store — a hivatalos alkalmazásbolt Tizenhez (órák, TV-k, IoT). A fejlesztői regisztráció ingyenes a Samsung Developers programon keresztül. A fejlesztők .tpk (natív) vagy .wgt (web) formátumban tölthetnek fel alkalmazásokat, Samsung tanúsítvánnyal aláírva. A moderálás 2-5 munkanapot vesz igénybe. A Galaxy Store 190 országban érhető el.

Alkalmazás aláírása

A Tizen digitális aláírást igényel az alkalmazásokhoz Samsung tanúsítvánnyal. Folyamat: Szerzői Tanúsítvány generálása a Samsung Certificate Manageren keresztül, Forgalmazói Tanúsítvány létrehozása a bolt számára, a csomag aláírása a Tizen Studio-n keresztül (Build Signed Package). A tanúsítvány a fejlesztői fiókhoz van kötve. Aláírás nélkül az alkalmazás csak fejlesztői eszközökön telepíthető bekapcsolt Fejlesztői móddal.

Bevételezési modell

A Galaxy Store támogatja a fizetős alkalmazásokat (30% jutalék az első 10.000 $-ig, aztán 25%), előfizetéseket (25%), hirdetéseket a Samsung Ads-en keresztül és alkalmazáson belüli vásárlásokat a Samsung IAP-n keresztül. TV-alkalmazásokhoz a Smart TV Premium Channels modell érhető el. A minimális ár 0,99 $. A kifizetések havonta történnek a 100 $-os küszöb elérésekor.