Tizen: Die Essenz der Entwicklung für Samsung Watch und Smart TV

Was ist Tizen?

Tizen ist ein quelloffenes Betriebssystem, das von Samsung und der Linux Foundation betreut wird. Die erste kommerzielle Version Tizen 1.0 wurde 2012 veröffentlicht. Das System basiert auf dem Linux-Kernel und verwendet eine eigene Framework-Architektur für verschiedene Gerätetypen: Tizen Mobile (Smartphones — Projekt 2017 eingestellt), Tizen Watch (Uhren), Tizen TV (Fernseher) und Tizen IoT (Smart Home).

Seit 2021 verwendet Samsung Tizen hauptsächlich in Wearables und Fernsehern. Alle Galaxy Watch-Smartwatches vor 2021 liefen unter Tizen (Galaxy Watch, Watch Active, Watch 3). Ab der Galaxy Watch 4 ist Samsung auf Wear OS mit One UI Watch umgestiegen, aber Tizen wird weiterhin für bestehende Geräte und Fernseher unterstützt. Laut Samsung (Tizen Ecosystem Report, 2025) ist Tizen TV auf über 180 Millionen Fernsehern weltweit installiert.

Ein Hauptmerkmal von Tizen ist die Unterstützung zweier Entwicklungsparadigmen: native Anwendungen (C/C++) mit maximaler Leistung und Webanwendungen (HTML5, CSS, JavaScript) für schnelle Entwicklung. Beide Typen haben Zugriff auf die Tizen Device API — Wrapper für Bluetooth, NFC, Wi-Fi, Sensoren, Kamera und Multimedia.

Tizen-Versionsgeschichte

Tizen 2.3 (2014) — erste stabile Version für Samsung Z-Smartphones. Tizen 3.0 (2017) — verbessertes Multitasking, Vulkan-Support, 64-Bit-Architektur. Tizen 4.0 (2018) — überarbeitete Frameworks, KI-Beschleunigung auf NPU. Tizen 5.5 (2020) — Tizen TV mit AVPlay 2.0, WebAssembly, verbessertes Rendering. Tizen 6.0 (2022) — ML-Inferenz auf dem Gerät, Matter-Protokoll für IoT.

Tizen-Architektur: Linux-Kernel und Frameworks

Die Tizen-Architektur ist modular mit einer mehrschichtigen Struktur aufgebaut. Die unterste Schicht ist der Linux-Kernel mit Patches für Energieeffizienz und Echtzeitaufgaben (RT_PREEMPT für TV und Audio). Über dem Kernel liegt die Hardware-Abstraktionsschicht (HAL), die einheitlichen Zugriff auf Kamera-, Sensor-, Bluetooth-, Wi-Fi-, NFC- und Display-Treiber (über DirectFB oder Wayland) bietet.

Core Framework Layer

Die Core Framework-Schicht umfasst Application Framework (Anwendungslebenszyklus-Verwaltung), UI Framework (EFL — Enlightenment Foundation Libraries für UI, DALi — 3D-Engine für Spiele und Animationen), Multimedia Framework (Kamera, Audio, Video über GStreamer und MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) und Security Framework (SELinux, Smack, Tizen-Berechtigungssystem).

Service Layer

Die Service Layer stellt Systemdienste bereit: Application Manager (Starten, Stoppen, Multitasking), Package Manager (Installieren/Deinstallieren von Apps, Formate .tpk und .wgt), Location Manager (GPS, Wi-Fi-Positionierung, Geofence), Sensor Manager (Beschleunigungssensor, Gyroskop, Barometer, Herzfrequenzmesser), Context Manager (Benutzeraktivitätserkennung: Gehen, Laufen, Schlafen).

Device API für Webanwendungen

Tizen bietet Device API — JavaScript-Schnittstellen für Webanwendungen, die Zugriff auf dieselben Funktionen wie native APIs bieten. Die APIs sind in Module unterteilt: 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.

Native Tizen-Anwendungen in C/C++

Native Tizen-Anwendungen werden in eine ausführbare Datei im .tpk-Format (Tizen Package Kit) kompiliert. Die Hauptsprache ist C++11/14 mit GCC- oder Clang-Compiler. Die Entwicklung erfolgt in Tizen Studio oder Visual Studio Code mit der Tizen-Erweiterung. Native Anwendungen haben direkten Zugriff auf EFL, DALi, GStreamer und alle System-APIs ohne Zwischeninstanzen, was maximale Leistung gewährleistet.

Aufbau einer nativen Anwendung

Eine native Anwendung enthält eine tizen-manifest.xml-Datei (ähnlich AndroidManifest.xml), eine oder mehrere Shared Libraries (.so) und Ressourcen (Bilder, Schriftarten, Lokalisierungen). Der Lebenszyklus wird über app_event_cb verwaltet: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. Die UI wird über EFL (Edje + Elementary) für Fensteranwendungen oder DALi für 3D-Grafiken erstellt.

// Native Tizen-Anwendung in C++ mit EFL-UI
#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) {
    // Erstellen eines Tizen-Fensters
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Fenstertitel
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — Standard-Tizen-Container für Wearable-Geräte
    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);

    // Textbeschriftung
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Willkommen bei Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Fenster anzeigen
    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) {
    // Handler für Ressourcenerfassung der Anwendung
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Wird beim Erstellen der Anwendung aufgerufen
    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);
}

Die native Tizen Hello World-Anwendung verwendet EFL (Enlightenment Foundation Libraries) für die UI. ui_app_main ist der Tizen-Einstiegspunkt, der Lebenszyklus-Callbacks akzeptiert. efl_add erstellt UI-Objekte über die Hierarchie Win → Conformant → Label. Die EFL-Benutzeroberfläche basiert auf dem Edje-Composite-Modell — Theme-Beschreibungen werden in .edc-Dateien geschrieben und in .edj kompiliert.

Tizen-Manifest (tizen-manifest.xml)

Die tizen-manifest.xml-Datei ist die Konfiguration der nativen Anwendung. Sie gibt id (eindeutige ID im Reverse-Domain-Format), package (Paketname), version, label (angezeigter Name), author und description an. Berechtigungen (privileges) deklarieren den API-Zugriff: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Ohne Angabe einer Berechtigung führt der Aufruf der entsprechenden API zu einem SECURITY_ERR-Fehler.

Tizen-Webanwendungen in HTML5 und JavaScript

Tizen-Webanwendungen sind HTML5-Anwendungen, die im .wgt-Format (W3C Widget) verpackt sind. Die Entwicklung ist identisch mit der Erstellung einer normalen Website, jedoch mit zusätzlichem Zugriff auf die Tizen Device API über das globale tizen-Objekt. Webanwendungen laufen in einem eigenen Web Runtime (WRT)-Prozess, der auf der WebKit-Engine (Tizen 2.x-4.x) oder Chromium (Tizen 5.5+) basiert.

Aufbau einer Webanwendung

Eine Webanwendung enthält index.html (Einstiegspunkt), config.xml (W3C Widget-Konfiguration), CSS, JavaScript und Bilder. Die config.xml-Datei ähnelt manifest.webapp unter KaiOS: Pflichtfelder sind widget (id, version, height/width für Uhren), name, description und author. Berechtigungen für die Device API werden über das tizen:privilege-Element angegeben. Der CSP-Abschnitt (Content Security Policy) schränkt Skriptquellen ein.

// config.xml für Tizen Watch-Webanwendung
<?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>Pulsmesser</name>
    <description>Pulsmessung auf der 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>

Das minimale config.xml-Fragment zeigt die wichtigsten Elemente: widget mit id und Version, tizen:application mit einem Wearable-Profil für runde Uhrenbildschirme, tizen:privilege für healthinfo und sensor API, und eine Content Security Policy, die das Laden von Inhalten nur aus dem Anwendungspaket erlaubt.

// Tizen Watch-Webanwendung: Herzfrequenzüberwachung
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Überprüfung der HRM-Sensorunterstützung
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('HRM-Sensor nicht gefunden');
            }

            // Zugriff auf den Herzfrequenzsensor erhalten
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('HRM-Sensor initialisiert');
        } catch (err) {
            console.error('Initialisierungsfehler:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // Messung jede Sekunde
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Sensorfehler:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Herzfrequenzanzeige auf rundem 360x360-Bildschirm
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Runder Herzfrequenz-Indikator
        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();
    });
});

Die Anwendung HeartRateMonitor verwendet die Tizen Sensor API für den Zugriff auf den HRM-Sensor der Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') ruft den Herzfrequenzsensor ab, startSensor startet die Messungen im 1-Sekunden-Intervall. Eine 360×360-Leinwand zeichnet einen kreisförmigen Indikator — ein typisches UI-Paradigma für runde Tizen-Uhrenbildschirme.

Tizen Watch-Entwicklung: Circle UI und Rotary

Tizen Watch hat einzigartige UI-Merkmale: einen runden Bildschirm (360×360 Pixel bei der Galaxy Watch), eine physische Lünette (Rotary Bezel) zur Navigation und drei Hardware-Tasten: Home, Back und Custom. Der Entwickler muss die Oberfläche an den runden Bereich anpassen — Eckelemente können abgeschnitten werden. Circle UI ist eine Samsung-Bibliothek mit vorgefertigten Komponenten für runde Bildschirme.

Rotary Bezel

Rotary Bezel — ein physischer Ring um den Bildschirm der Galaxy Watch, der zur Navigation durch Listen, Lautstärkeregelung und Zoom dreht. In Tizen wird das Drehereignis über rotarydetector oder ein EFL-edje-Signal verarbeitet. Jede Lünettenkerbe erzeugt ein Ereignis mit einem Drehwinkel (0-360 Grad). Webanwendungen verarbeiten die Lünette über die rotarydetector-API: tizen.rotarydetector.

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

    init() {
        // Abonnieren von Lünetten-Drehereignissen
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — aktueller Winkel (0-360)
            // event.direction — 'cw' (im Uhrzeigersinn) oder 'ccw' (gegen Uhrzeigersinn)
            this.handleRotation(event);
        });

        // Aktivierung von rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // Winkeländerung
        this.currentAngle += delta;

        // Richtungs- und Bewegungsbestimmung
        if (delta > 0) {
            // Drehung im Uhrzeigersinn — nächstes Element
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Drehung gegen Uhrzeigersinn — vorheriges 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();
    }
}

// Initialisierung beim Laden der Anwendung
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

Die Klasse RotaryNavigation abonniert rotarydetector-Ereignisse über tizen.rotarydetector.addEventListener. Beim Drehen der Lünette werden die Richtung (cw/ccw) und das Winkeldelta berechnet. Der aktuelle Abschnitt wird mit der Klasse active hervorgehoben. rotarydetector.start() ist obligatorisch — ohne werden keine Ereignisse erzeugt. destroy() kündigt das Abonnement und stoppt den Detektor, um Speicherlecks zu vermeiden.

UI-Funktionen für Uhren

Die Tizen Watch-Oberfläche verwendet Komponenten: RotarySelector (kreisförmige Liste, gesteuert über die Lünette), CircularList (Liste mit kreisförmigem Scrollen), RadialMenu (radiales Menü mit kreisförmig angeordneten Symbolen), EdgePanel (vom Bildschirmrand hereinschiebendes Panel) und CircleProgressBar (kreisförmige Fortschrittsanzeige). Alle Komponenten sind für 360×360-Auflösung optimiert und berücksichtigen das Fehlen von Bildschirmecken. Die Mindestgröße für Touch-Ziele beträgt 48 Pixel.

Tizen TV-Entwicklung: Apps für Smart TV

Tizen TV — eine Plattform für Samsung Smart TV mit eigenem SDK und Emulator. TV-Anwendungen werden in zwei Typen unterteilt: Webanwendungen (HTML5/JS) und native Anwendungen (C/C++). Webanwendungen für TV sind schneller und einfacher zu entwickeln, aber native bieten eine bessere Leistung für Video und Spiele. Tizen TV verwendet eine Fernbedienung mit D-Pad zur Navigation.

AVPlay API für Video

AVPlay API — die wichtigste Tizen TV-API für die Videowiedergabe. Unterstützt die Formate H.264, H.265 (HEVC), VP9, AV1. Auflösung bis zu 8K auf TVs ab 2024. AVPlay API bietet Hardware-Dekodierung, HDR10+, Dolby Atmos, Untertitel und mehrere Audiospuren. Steuerung über play(), pause(), stop(), seekTo(position), setDisplayRect(). Der Stream kann eine lokale Datei oder eine HLS/DASH-URL sein.

// Videoplayer für Tizen TV mit AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Prüfung der AVPlay-Verfügbarkeit
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API nicht verfügbar');
            }

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

            // Bildschirmeinstellung auf Vollbild-TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Audio-Konfiguration (Dolby Atmos, falls unterstützt)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Video zur Wiedergabe bereit');
                },
                (error) => {
                    console.error('Vorbereitungsfehler:', error);
                }
            );
        } catch (err) {
            console.error('Initialisierungsfehler:', 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'
        }));
    }
}

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

Die Klasse TizenVideoPlayer demonstriert die Arbeit mit der AVPlay API. webapis.avplay.open() öffnet einen Medienstream (lokal oder HLS/DASH). setDisplayRect legt den Rendering-Bereich fest — beim TV typischerweise Vollbild mit 3840×2160. prepareAsync ist eine asynchrone Vorbereitung mit Callbacks. AVPlay unterstützt adaptive Bitrate über ADAPTIVE_INFO und Untertitel über die SUBTITLE-Eigenschaft.

Galaxy Store und Veröffentlichung von Anwendungen

Samsung Galaxy Store — der offizielle App-Store für Tizen (Uhren, TVs, IoT). Die Entwicklerregistrierung ist über das Samsung Developers-Programm kostenlos. Entwickler laden Anwendungen im .tpk- (nativ) oder .wgt-Format (Web) hoch, die mit einem Samsung-Zertifikat signiert sind. Die Moderation dauert 2-5 Werktage. Galaxy Store ist in 190 Ländern verfügbar.

Anwendungssignatur

Tizen erfordert eine digitale Signatur für Anwendungen mit einem Samsung-Zertifikat. Prozess: Generierung eines Author-Zertifikats über den Samsung Certificate Manager, Erstellung eines Distributor-Zertifikats für den Store, Signieren des Pakets über Tizen Studio (Build Signed Package). Das Zertifikat ist mit dem Entwicklerkonto verknüpft. Ohne Signatur kann die Anwendung nur auf Entwicklungsgeräten mit aktiviertem Entwicklermodus installiert werden.

Monetarisierungsmodell

Galaxy Store unterstützt kostenpflichtige Anwendungen (30% Provision auf die ersten $10.000, danach 25%), Abonnements (25%), Werbung über Samsung Ads und In-App-Käufe über Samsung IAP. Für TV-Anwendungen steht das Modell Smart TV Premium Channels zur Verfügung. Der Mindestpreis beträgt $0,99. Auszahlungen erfolgen monatlich ab einer Schwelle von $100.