Tizen: de essentie van ontwikkeling voor Samsung Watch en Smart TV

Wat is Tizen?

Tizen is een open-source besturingssysteem dat wordt beheerd door Samsung en de Linux Foundation. De eerste commerciële release, Tizen 1.0, vond plaats in 2012. Het systeem is gebaseerd op de Linux-kernel en gebruikt een eigen framework-architectuur voor verschillende apparaattypen: Tizen Mobile (smartphones — project gesloten in 2017), Tizen Watch (horloges), Tizen TV (televisies) en Tizen IoT (slim huis).

Sinds 2021 gebruikt Samsung Tizen voornamelijk in wearables en televisies. Alle Galaxy Watch-smartwatches vóór 2021 draaiden op Tizen (Galaxy Watch, Watch Active, Watch 3). Vanaf Galaxy Watch 4 is Samsung overgestapt op Wear OS met One UI Watch, maar Tizen wordt nog steeds ondersteund voor bestaande apparaten en tv's. Volgens Samsung (Tizen Ecosystem Report, 2025) is Tizen TV geïnstalleerd op meer dan 180 miljoen tv's wereldwijd.

Een belangrijk kenmerk van Tizen is de ondersteuning van twee ontwikkelingsparadigma's: native applicaties (C/C++) met maximale prestaties en webapplicaties (HTML5, CSS, JavaScript) voor snelle ontwikkeling. Beide typen hebben toegang tot de Tizen Device API — wrappers voor het werken met Bluetooth, NFC, Wi-Fi, sensoren, camera en multimedia.

Tizen-versiegeschiedenis

Tizen 2.3 (2014) — eerste stabiele versie voor Samsung Z-smartphones. Tizen 3.0 (2017) — verbeterde multitasking, Vulkan-ondersteuning, 64-bits architectuur. Tizen 4.0 (2018) — herziene frameworks, AI-versnelling op NPU. Tizen 5.5 (2020) — Tizen TV met AVPlay 2.0, WebAssembly, verbeterde rendering. Tizen 6.0 (2022) — ML-inferentie op het apparaat, Matter-protocol voor IoT.

Tizen-architectuur: Linux-kernel en frameworks

De Tizen-architectuur is modulair opgebouwd met een gelaagde structuur. De onderste laag is de Linux-kernel met patches voor energie-efficiëntie en real-time taken (RT_PREEMPT voor tv en audio). Boven de kernel bevindt zich de Hardware Abstraction Layer (HAL), die uniforme toegang biedt tot stuurprogramma's voor camera, sensoren, Bluetooth, Wi-Fi, NFC en display (via DirectFB of Wayland).

Core Framework Laag

De Core Framework-laag omvat Application Framework(beheer van de levenscyclus van applicaties), UI Framework(EFL — Enlightenment Foundation Libraries voor UI, DALi — 3D-engine voor games en animaties), Multimedia Framework(camera, audio, video via GStreamer en MediaCodec), Network Framework(Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) en Security Framework(SELinux, Smack, Tizen-privilegesysteem).

Service Laag

De Service-laag biedt systeemdiensten: Application Manager(starten, stoppen, multitasking), Package Manager(installeren/verwijderen van apps, .tpk- en .wgt-formaten), Location Manager(GPS, Wi-Fi-positionering, Geofence), Sensor Manager(versnellingsmeter, gyroscoop, barometer, hartslagmeter), Context Manager(herkenning van gebruikersactiviteit: lopen, rennen, slapen).

Device API voor webapplicaties

Tizen biedt Device API — JavaScript-interfaces voor webapplicaties die toegang geven tot dezelfde functies als native API's. De API's zijn verdeeld in modules: 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-applicaties in C/C++

Native Tizen-applicaties worden gecompileerd naar een uitvoerbaar bestand in .tpk-formaat (Tizen Package Kit). De primaire taal is C++11/14 met GCC- of Clang-compiler. Ontwikkeling vindt plaats in Tizen Studio of Visual Studio Code met de Tizen-extensie. Native applicaties hebben directe toegang tot EFL, DALi, GStreamer en alle systeem-API's zonder tussenpersonen, wat maximale prestaties garandeert.

Structuur van een native applicatie

Een native applicatie bevat een tizen-manifest.xml-bestand (vergelijkbaar met AndroidManifest.xml), een of meer gedeelde bibliotheken (.so) en bronnen (afbeeldingen, lettertypen, lokalisaties). De levenscyclus wordt beheerd via app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. De UI wordt gebouwd via EFL (Edje + Elementary) voor vensterapplicaties of DALi voor 3D-graphics.

// Native Tizen-applicatie in C++ met 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) {
    // Een Tizen-venster maken
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

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

    // Conformant — standaard Tizen-container voor wearables
    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);

    // Tekstlabel
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Welkom bij Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Venster weergeven
    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 voor het verkrijgen van applicatiebronnen
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Aangeroepen bij het maken van de applicatie
    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);
}

De native Tizen Hello World-applicatie gebruikt EFL (Enlightenment Foundation Libraries) voor de UI. ui_app_main is het Tizen-ingangspunt dat levenscyclus-callbacks accepteert. efl_add maakt UI-objecten via de hiërarchie Win → Conformant → Label. EFL UI is gebaseerd op het Edje-composietmodel — themabeschrijvingen worden geschreven in .edc-bestanden en gecompileerd naar .edj.

Tizen-manifest (tizen-manifest.xml)

Het tizen-manifest.xml-bestand is de configuratie van de native applicatie. Het specificeert id (unieke identificatie in omgekeerd domeinformaat), package (pakketnaam), version, label (weergavenaam), author en description. Privileges verklaren API-toegang: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Zonder het specificeren van een privilege resulteert het aanroepen van de corresponderende API in een SECURITY_ERR-fout.

Tizen-webapplicaties in HTML5 en JavaScript

Tizen-webapplicaties zijn HTML5-applicaties verpakt in .wgt-formaat (W3C Widget). Ontwikkeling is identiek aan het maken van een gewone website, maar met extra toegang tot de Tizen Device API via het globale tizen-object. Webapplicaties worden uitgevoerd in een eigen Web Runtime (WRT)-proces, gebaseerd op de WebKit-engine (Tizen 2.x-4.x) of Chromium (Tizen 5.5+).

Structuur van een webapplicatie

Een webapplicatie bevat index.html (ingangspunt), config.xml (W3C Widget-configuratie), CSS, JavaScript en afbeeldingen. Het config.xml-bestand is vergelijkbaar met manifest.webapp in KaiOS: verplichte velden zijn widget (id, version, height/width voor horloges), name, description en author. Machtigingen voor Device API worden gespecificeerd via het tizen:privilege-element. De CSP-sectie (Content Security Policy) beperkt scriptbronnen.

// config.xml voor Tizen Watch-webapplicatie
<?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>Hartslagmeter</name>
    <description>Hartslagmeting op 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>

Het minimale config.xml-fragment toont de belangrijkste elementen: widget met id en versie, tizen:application met een wearable-profiel voor ronde horlogeschermen, tizen:privilege voor healthinfo en sensor API, en een Content Security Policy die het laden van inhoud alleen vanuit het applicatiepakket beperkt.

// Tizen Watch-webapplicatie: hartslagmeting
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Controleren van HRM-sensorondersteuning
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('HRM-sensor niet gevonden');
            }

            // Toegang krijgen tot de hartslagsensor
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('HRM-sensor geïnitialiseerd');
        } catch (err) {
            console.error('Initialisatiefout:', err.message);
        }
    },

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

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

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

    updateDisplay(heartRate) {
        // Hartslagvisualisatie op rond 360x360-scherm
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Ronde hartslagindicator
        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();
    });
});

De HeartRateMonitor-applicatie gebruikt de Tizen Sensor API voor toegang tot de HRM-sensor van de Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') haalt de hartslagsensor op, startSensor start metingen met een interval van 1 seconde. Een 360×360-canvas tekent een cirkelvormige indicator — een typisch UI-paradigma voor ronde Tizen-horlogeschermen.

Tizen Watch-ontwikkeling: Circle UI en Rotary

Tizen Watch heeft unieke UI-kenmerken: een rond scherm (360×360 pixels op Galaxy Watch), een fysieke ring (rotary bezel) voor navigatie en drie hardwareknoppen: Home, Back en Custom. De ontwikkelaar moet de interface aanpassen aan een rond gebied — hoekelementen kunnen worden afgesneden. Circle UI is een Samsung-bibliotheek met kant-en-klare componenten voor ronde schermen.

Rotary Bezel

Rotary Bezel — een fysieke ring rond het scherm van de Galaxy Watch die draait voor navigatie door lijsten, volumeregeling en zoom. In Tizen wordt de rotatiegebeurtenis afgehandeld via rotarydetector of een EFL-edje-signaal. Elke inkeping van de ring genereert een gebeurtenis met een rotatiehoek (0-360 graden). Webapplicaties verwerken de ring via de rotarydetector API: tizen.rotarydetector.

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

    init() {
        // Abonneren op ringrotatiegebeurtenissen
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — huidige hoek (0-360)
            // event.direction — 'cw' (met de klok mee) of 'ccw' (tegen de klok in)
            this.handleRotation(event);
        });

        // Activeren van rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // hoekverandering
        this.currentAngle += delta;

        // Bepalen van richting en beweging
        if (delta > 0) {
            // Met de klok mee draaien — volgend element
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Tegen de klok in draaien — vorig 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();
    }
}

// Initialisatie bij het laden van de applicatie
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

De klasse RotaryNavigation abonneert zich op rotarydetector-gebeurtenissen via tizen.rotarydetector.addEventListener. Wanneer de ring wordt gedraaid, worden de richting (cw/ccw) en de hoekdelta berekend. De huidige sectie wordt gemarkeerd met de klasse active. rotarydetector.start() is verplicht — zonder worden er geen gebeurtenissen gegenereerd. destroy() meldt zich af en stopt de detector om geheugenlekken te voorkomen.

UI-functies voor horloges

De Tizen Watch-interface gebruikt componenten: RotarySelector(cirkelvormige lijst bediend met de ring), CircularList(lijst met cirkelvormig scrollen), RadialMenu(radiaal menu met pictogrammen in een cirkel), EdgePanel(paneel dat van de rand van het scherm schuift) en CircleProgressBar(cirkelvormige voortgangsindicator). Alle componenten zijn geoptimaliseerd voor 360×360-resolutie en houden rekening met het ontbreken van schermhoeken. Minimale aanraakdoelgrootte is 48 pixels.

Tizen TV-ontwikkeling: apps voor Smart TV

Tizen TV — een platform voor Samsung Smart TV met eigen SDK en emulator. TV-applicaties zijn onderverdeeld in twee typen: webapplicaties (HTML5/JS) en native applicaties (C/C++). Webapplicaties voor tv zijn sneller en gemakkelijker te ontwikkelen, maar native bieden betere prestaties voor video en games. Tizen TV gebruikt een afstandsbediening met D-pad voor navigatie.

AVPlay API voor video

AVPlay API — de belangrijkste Tizen TV-API voor videoweergave. Ondersteunt de formaten H.264, H.265 (HEVC), VP9, AV1. Resolutie tot 8K op tv's van 2024+. AVPlay API biedt hardwarematige decodering, HDR10+, Dolby Atmos, ondertiteling en meerdere audiotracks. Bediening via play(), pause(), stop(), seekTo(position), setDisplayRect(). De stream kan een lokaal bestand of een HLS/DASH-URL zijn.

// Videospeler voor Tizen TV met AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Controleren van AVPlay-beschikbaarheid
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API niet beschikbaar');
            }

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

            // Weergave instellen op volledig scherm tv
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Audio configureren (Dolby Atmos, indien ondersteund)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Video is klaar om af te spelen');
                },
                (error) => {
                    console.error('Voorbereidingsfout:', error);
                }
            );
        } catch (err) {
            console.error('Initialisatiefout:', 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'
        }));
    }
}

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

De klasse TizenVideoPlayer demonstreert het werken met de AVPlay API. webapis.avplay.open() opent een mediastream (lokaal of HLS/DASH). setDisplayRect stelt het weergavegebied in — op tv is dit meestal volledig scherm op 3840×2160. prepareAsync is asynchrone voorbereiding met callbacks. AVPlay ondersteunt adaptieve bitsnelheid via ADAPTIVE_INFO en ondertiteling via de SUBTITLE-eigenschap.

Galaxy Store en het publiceren van applicaties

Samsung Galaxy Store — de officiële app-winkel voor Tizen (horloges, tv's, IoT). Ontwikkelaarsregistratie is gratis via het Samsung Developers-programma. Ontwikkelaars uploaden applicaties in .tpk- (native) of .wgt-formaat (web), ondertekend met een Samsung-certificaat. Moderatie duurt 2-5 werkdagen. Galaxy Store is beschikbaar in 190 landen.

Applicatie ondertekenen

Tizen vereist een digitale handtekening voor applicaties met een Samsung-certificaat. Proces: genereer een auteurscertificaat via Samsung Certificate Manager, maak een distributeurscertificaat voor de winkel, onderteken het pakket via Tizen Studio (Build Signed Package). Het certificaat is gekoppeld aan het ontwikkelaarsaccount. Zonder handtekening kan de applicatie alleen worden geïnstalleerd op ontwikkelapparaten met de ontwikkelaarsmodus ingeschakeld.

Monetiseringsmodel

Galaxy Store ondersteunt betaalde applicaties (30% commissie over de eerste $10.000, daarna 25%), abonnementen (25%), advertenties via Samsung Ads en in-app aankopen via Samsung IAP. Voor tv-applicaties is het Smart TV Premium Channels-model beschikbaar. De minimumprijs is $0,99. Uitbetalingen worden maandelijks gedaan bij het bereiken van de drempel van $100.