Tizen: istota tworzenia aplikacji dla Samsung Watch i Smart TV

Czym jest Tizen?

Tizen to otwarty system operacyjny nadzorowany przez Samsung i Linux Foundation. Pierwsze komercyjne wydanie Tizen 1.0 miało miejsce w 2012 roku. System opiera się na jądrze Linux i wykorzystuje własną architekturę frameworków dla różnych typów urządzeń: Tizen Mobile (smartfony — projekt zamknięty w 2017), Tizen Watch (zegarki), Tizen TV (telewizory) i Tizen IoT (inteligentny dom).

Od 2021 roku Samsung używa Tizen głównie w urządzeniach noszonych i telewizorach. Wszystkie smartwatche Galaxy Watch przed 2021 rokiem działały na Tizen (Galaxy Watch, Watch Active, Watch 3). Począwszy od Galaxy Watch 4, Samsung przeszedł na Wear OS z One UI Watch, ale Tizen nadal jest wspierany dla istniejących urządzeń i telewizorów. Według Samsung (Tizen Ecosystem Report, 2025), na ponad 180 milionach telewizorów na całym świecie zainstalowano Tizen TV.

Kluczową cechą Tizen jest obsługa dwóch paradygmatów tworzenia aplikacji: aplikacje natywne (C/C++) z maksymalną wydajnością i aplikacje webowe (HTML5, CSS, JavaScript) do szybkiego tworzenia. Oba typy mają dostęp do Tizen Device API — nakładek do pracy z Bluetooth, NFC, Wi-Fi, czujnikami, kamerą i multimediami.

Historia wersji Tizen

Tizen 2.3 (2014) — pierwsza stabilna wersja dla smartfonów Samsung Z. Tizen 3.0 (2017) — ulepszona wielozadaniowość, obsługa Vulkan, architektura 64-bitowa. Tizen 4.0 (2018) — przeprojektowane frameworki, obsługa akceleracji AI na NPU. Tizen 5.5 (2020) — Tizen TV z AVPlay 2.0, WebAssembly, ulepszone renderowanie. Tizen 6.0 (2022) — obsługa wnioskowania ML na urządzeniu, protokół Matter dla IoT.

Architektura Tizen: jądro Linux i frameworki

Architektura Tizen jest zbudowana na zasadzie modułowej z wielowarstwową strukturą. Najniższa warstwa to jądro Linux z łatkami do efektywności energetycznej i zadań czasu rzeczywistego (RT_PREEMPT dla TV i audio). Nad jądrem znajduje się warstwa abstrakcji sprzętowej (HAL), zapewniająca ujednolicony dostęp do sterowników kamery, czujników, Bluetooth, Wi-Fi, NFC i wyświetlacza (przez DirectFB lub Wayland).

Warstwa Core Framework

Warstwa Core Framework obejmuje Application Framework (zarządzanie cyklem życia aplikacji), UI Framework (EFL — Enlightenment Foundation Libraries dla UI, DALi — silnik 3D dla gier i animacji), Multimedia Framework (kamera, audio, wideo przez GStreamer i MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) i Security Framework (SELinux, Smack, System uprawnień Tizen).

Warstwa usług

Warstwa usług zapewnia usługi systemowe: Application Manager (uruchamianie, zatrzymywanie, wielozadaniowość), Package Manager (instalacja/deinstalacja aplikacji, formaty .tpk i .wgt), Location Manager (GPS, pozycjonowanie Wi-Fi, Geofence), Sensor Manager (akcelerometr, żyroskop, barometr, monitor tętna), Context Manager (rozpoznawanie aktywności użytkownika: chodzenie, bieganie, spanie).

Device API dla aplikacji webowych

Tizen udostępnia Device API — interfejsy JavaScript dla aplikacji webowych, które dają dostęp do tych samych funkcji co natywne API. API są podzielone na moduły: 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.

Natywne aplikacje Tizen w C/C++

Natywne aplikacje Tizen są kompilowane do pliku wykonywalnego w formacie .tpk (Tizen Package Kit). Głównym językiem jest C++11/14 z kompilatorem GCC lub Clang. Tworzenie odbywa się w Tizen Studio lub Visual Studio Code z rozszerzeniem Tizen. Aplikacje natywne mają bezpośredni dostęp do EFL, DALi, GStreamer i wszystkich API systemowych bez pośredników, co zapewnia maksymalną wydajność.

Struktura aplikacji natywnej

Aplikacja natywna zawiera plik tizen-manifest.xml (odpowiednik AndroidManifest.xml), jedną lub więcej bibliotek współdzielonych (.so) i zasoby (obrazy, czcionki, lokalizacje). Cykl życia jest zarządzany przez app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. Interfejs użytkownika jest budowany przez EFL (Edje + Elementary) dla aplikacji okienkowych lub DALi dla grafiki 3D.

// Natywna aplikacja Tizen w C++ z 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) {
    // Tworzenie 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"));

    // Tytuł 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 — standardowy kontener Tizen dla urządzeń noszonych
    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);

    // Etykieta tekstowa
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Witamy w Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Wyświetlanie 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) {
    // Procedura obsługi pozyskiwania zasobów aplikacji
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Wywoływane przy tworzeniu aplikacji
    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);
}

Natywna aplikacja Tizen Hello World używa EFL (Enlightenment Foundation Libraries) dla interfejsu użytkownika. ui_app_main to punkt wejścia Tizen, który przyjmuje callbacki cyklu życia. efl_add tworzy obiekty interfejsu przez hierarchię Win → Conformant → Label. Interfejs EFL opiera się na modelu kompozytowym Edje — opisy motywów są pisane w plikach .edc i kompilowane do .edj.

Manifest Tizen (tizen-manifest.xml)

Plik tizen-manifest.xml to konfiguracja aplikacji natywnej. Określa id (unikalny identyfikator w formacie odwróconej domeny), package (nazwa pakietu), version, label (wyświetlana nazwa), author i description. Uprawnienia deklarują dostęp do API: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Bez określenia uprawnienia wywołanie odpowiedniego API zakończy się błędem SECURITY_ERR.

Aplikacje webowe Tizen w HTML5 i JavaScript

Aplikacje webowe Tizen to aplikacje HTML5 spakowane w formacie .wgt (W3C Widget). Tworzenie jest identyczne jak tworzenie zwykłej strony internetowej, ale z dodatkowym dostępem do Tizen Device API przez globalny obiekt tizen. Aplikacje webowe uruchamiane są we własnym procesie Web Runtime (WRT), opartym na silniku WebKit (Tizen 2.x-4.x) lub Chromium (Tizen 5.5+).

Struktura aplikacji webowej

Aplikacja webowa zawiera index.html (punkt wejścia), config.xml (Konfiguracja Widgetu W3C), CSS, JavaScript i obrazy. Plik config.xml jest podobny do manifest.webapp w KaiOS: obowiązkowe pola to widget (id, version, height/width dla zegarków), name, description i author. Uprawnienia dla Device API są określane przez element tizen:privilege. Sekcja CSP (Content Security Policy) ogranicza źródła skryptów.

// config.xml dla aplikacji webowej 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>Pulsometr</name>
    <description>Pomiar tętna 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>

Minimalny fragment config.xml pokazuje kluczowe elementy: widget z id i wersją, tizen:application z profilem wearable dla okrągłych ekranów zegarków, tizen:privilege dla healthinfo i sensor API oraz Content Security Policy ograniczającą ładowanie treści tylko z pakietu aplikacji.

// Aplikacja webowa Tizen Watch: monitorowanie tętna
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Sprawdzanie obsługi czujnika HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Czujnik HRM nie znaleziony');
            }

            // Uzyskiwanie dostępu do czujnika tętna
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Czujnik HRM zainicjowany');
        } catch (err) {
            console.error('Błąd inicjalizacji:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // pomiar co sekundę
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Błąd czujnika:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Wizualizacja tętna na okrągłym ekranie 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Okrągły wskaźnik tętna
        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();
    });
});

Aplikacja HeartRateMonitor używa Tizen Sensor API do dostępu do czujnika HRM w Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') pobiera czujnik tętna, startSensor uruchamia pomiary z interwałem 1 sekundy. Canvas 360×360 rysuje okrągły wskaźnik — typowy paradygmat interfejsu dla okrągłych ekranów zegarków Tizen.

Tworzenie aplikacji dla Tizen Watch: Circle UI i Rotary

Tizen Watch ma unikalne cechy interfejsu: okrągły ekran (360×360 pikseli w Galaxy Watch), fizyczny pierścień (rotary bezel) do nawigacji i trzy przyciski sprzętowe: Home, Back i Custom. Deweloper musi dostosować interfejs do okrągłego obszaru — elementy narożne mogą być przycięte. Circle UI to biblioteka Samsung z gotowymi komponentami dla okrągłych ekranów.

Rotary Bezel

Rotary Bezel — fizyczny pierścień wokół ekranu Galaxy Watch, który obraca się do nawigacji po listach, regulacji głośności i zoomu. W Tizen zdarzenie obrotu jest obsługiwane przez rotarydetector lub sygnał edje EFL. Każde wcięcie pierścienia generuje zdarzenie z kątem obrotu (0-360 stopni). Aplikacje webowe obsługują pierścień przez API rotarydetector: tizen.rotarydetector.

// Obsługa Rotary Bezel w Tizen Watch
class RotaryNavigation {
    constructor() {
        this.currentAngle = 0;
        this.sections = document.querySelectorAll('.rotary-section');
        this.currentSection = 0;
        this.init();
    }

    init() {
        // Subskrybowanie zdarzeń obrotu pierścienia
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — bieżący kąt (0-360)
            // event.direction — 'cw' (zgodnie z ruchem wskazówek) lub 'ccw' (przeciwnie)
            this.handleRotation(event);
        });

        // Aktywacja rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // zmiana kąta
        this.currentAngle += delta;

        // Określanie kierunku i ruchu
        if (delta > 0) {
            // Obrót zgodnie z ruchem wskazówek — następny element
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Obrót przeciwnie do ruchu wskazówek — poprzedni element
            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();
    }
}

// Inicjalizacja przy ładowaniu aplikacji
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

Klasa RotaryNavigation subskrybuje zdarzenia rotarydetector przez tizen.rotarydetector.addEventListener. Podczas obracania pierścienia obliczany jest kierunek (cw/ccw) i delta kąta. Bieżąca sekcja jest podświetlana klasą active. rotarydetector.start() jest obowiązkowy — bez niego zdarzenia nie są generowane. destroy() anuluje subskrypcję i zatrzymuje detektor, aby zapobiec wyciekom pamięci.

Funkcje interfejsu dla zegarków

Interfejs Tizen Watch używa komponentów: RotarySelector (okrągła lista sterowana pierścieniem), CircularList (lista z okrągłym przewijaniem), RadialMenu (menu radialne z ikonami ułożonymi w okręgu), EdgePanel (panel wysuwany z krawędzi ekranu) i CircleProgressBar (okrągły wskaźnik postępu). Wszystkie komponenty są zoptymalizowane do rozdzielczości 360×360 i uwzględniają brak narożników ekranu. Minimalny rozmiar celów dotykowych to 48 pikseli.

Tworzenie aplikacji dla Tizen TV: aplikacje na Smart TV

Tizen TV — platforma dla Samsung Smart TV z własnym SDK i emulatorem. Aplikacje TV dzielą się na dwa typy: aplikacje webowe (HTML5/JS) i aplikacje natywne (C/C++). Aplikacje webowe na TV są szybsze i łatwiejsze w tworzeniu, ale natywne zapewniają lepszą wydajność dla wideo i gier. Tizen TV używa pilota z D-padem do nawigacji.

AVPlay API dla wideo

AVPlay API — kluczowe API Tizen TV do odtwarzania wideo. Obsługuje formaty H.264, H.265 (HEVC), VP9, AV1. Rozdzielczość do 8K na TV 2024+. AVPlay API zapewnia dekodowanie sprzętowe, HDR10+, Dolby Atmos, napisy i wiele ścieżek audio. Sterowanie przez play(), pause(), stop(), seekTo(position), setDisplayRect(). Strumień może być plikiem lokalnym lub URL HLS/DASH.

// Odtwarzacz wideo dla Tizen TV z AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Sprawdzanie dostępności AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API niedostępny');
            }

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

            // Ustawienie wyświetlania na pełny ekran TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Konfiguracja audio (Dolby Atmos, jeśli obsługiwany)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Wideo gotowe do odtworzenia');
                },
                (error) => {
                    console.error('Błąd przygotowania:', error);
                }
            );
        } catch (err) {
            console.error('Błąd inicjalizacji:', 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'
        }));
    }
}

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

Klasa TizenVideoPlayer demonstruje pracę z AVPlay API. webapis.avplay.open() otwiera strumień multimediów (lokalny lub HLS/DASH). setDisplayRect ustawia obszar renderowania — na TV zwykle pełny ekran 3840×2160. prepareAsync to asynchroniczne przygotowanie z callbackami. AVPlay obsługuje adaptacyjną przepływność przez ADAPTIVE_INFO i napisy przez właściwość SUBTITLE.

Galaxy Store i publikacja aplikacji

Samsung Galaxy Store — oficjalny sklep aplikacji dla Tizen (zegarki, TV, IoT). Rejestracja dewelopera jest bezpłatna przez program Samsung Developers. Deweloperzy przesyłają aplikacje w formacie .tpk (natywne) lub .wgt (webowe), podpisane certyfikatem Samsung. Moderacja trwa 2-5 dni roboczych. Galaxy Store jest dostępny w 190 krajach.

Podpisywanie aplikacji

Tizen wymaga podpisu cyfrowego aplikacji certyfikatem Samsung. Proces: wygenerowanie certyfikatu autora przez Samsung Certificate Manager, utworzenie certyfikatu dystrybutora dla sklepu, podpisanie pakietu przez Tizen Studio (Build Signed Package). Certyfikat jest powiązany z kontem dewelopera. Bez podpisu aplikację można zainstalować tylko na urządzeniach deweloperskich z włączonym trybem deweloperskim.

Model monetyzacji

Galaxy Store obsługuje płatne aplikacje (prowizja 30% od pierwszych 10 000 $, potem 25%), subskrypcje (25%), reklamy przez Samsung Ads i zakupy w aplikacji przez Samsung IAP. Dla aplikacji TV dostępny jest model Smart TV Premium Channels. Minimalna cena to 0,99 $. Wypłaty są dokonywane miesięcznie po osiągnięciu progu 100 $.