Tizen: The Essence of Development for Samsung Watch and Smart TV

What is Tizen?

Tizen is an open-source operating system overseen by Samsung and the Linux Foundation. The first commercial release, Tizen 1.0, was launched in 2012. The system is based on the Linux kernel and uses its own framework architecture for different device types: Tizen Mobile (smartphones — project closed in 2017), Tizen Watch (watches), Tizen TV (televisions), and Tizen IoT (smart home).

Since 2021, Samsung has used Tizen primarily in wearable devices and televisions. All Galaxy Watch smartwatches before 2021 ran on Tizen (Galaxy Watch, Watch Active, Watch 3). Starting with Galaxy Watch 4, Samsung switched to Wear OS with One UI Watch, but Tizen continues to be supported for existing devices and TVs. According to Samsung (Tizen Ecosystem Report, 2025), over 180 million TVs worldwide have Tizen TV installed.

A key feature of Tizen is support for two development paradigms: native applications (C/C++) with maximum performance and web applications (HTML5, CSS, JavaScript) for rapid development. Both types have access to the Tizen Device API — wrappers for working with Bluetooth, NFC, Wi-Fi, sensors, camera, and multimedia.

Tizen Version History

Tizen 2.3 (2014) — first stable version for Samsung Z smartphones. Tizen 3.0 (2017) — improved multitasking, Vulkan support, 64-bit architecture. Tizen 4.0 (2018) — redesigned frameworks, AI acceleration support on NPU. Tizen 5.5 (2020) — Tizen TV with AVPlay 2.0, WebAssembly, improved rendering. Tizen 6.0 (2022) — on-device ML inference support, Matter Protocol for IoT.

Tizen Architecture: Linux Kernel and Frameworks

Tizen Architecture is built on a modular principle with a multi-layered structure. The bottom layer is the Linux kernel with patches for energy efficiency and real-time tasks (RT_PREEMPT for TV and audio). Above the kernel is the Hardware Abstraction Layer (HAL), which provides unified access to camera, sensor, Bluetooth, Wi-Fi, NFC, and display drivers (via DirectFB or Wayland).

Core Framework Layer

The Core Framework layer includes Application Framework (application lifecycle management), UI Framework (EFL — Enlightenment Foundation Libraries for UI, DALi — 3D engine for games and animations), Multimedia Framework (camera, audio, video via GStreamer and MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket), and Security Framework (SELinux, Smack, Tizen Privilege System).

Service Layer

The Service Layer provides system services: Application Manager (launch, stop, multitasking), Package Manager (install/uninstall applications, .tpk and .wgt formats), Location Manager (GPS, Wi-Fi positioning, Geofence), Sensor Manager (accelerometer, gyroscope, barometer, heart rate monitor), Context Manager (user activity recognition: walking, running, sleeping).

Device API for Web Applications

Tizen provides Device API — JavaScript interfaces for web applications that give access to the same features as native APIs. The APIs are divided into 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 Applications in C/C++

Native Tizen applications are compiled into an executable file in the .tpk format (Tizen Package Kit). The primary language is C++11/14 with the GCC or Clang compiler. Development is done in Tizen Studio or Visual Studio Code with the Tizen extension. Native applications have direct access to EFL, DALi, GStreamer, and all system APIs without intermediaries, ensuring maximum performance.

Native Application Structure

A native application includes a tizen-manifest.xml file (similar to AndroidManifest.xml), one or more shared libraries (.so), and resources (images, fonts, localizations). The lifecycle is managed through app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. The UI is built using EFL (Edje + Elementary) for windowed applications or DALi for 3D graphics.

// Native Tizen application in C++ with 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) {
    // Creating a Tizen window
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Window title
    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 for wearable devices
    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);

    // Text label
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Welcome to Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Displaying the window
    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) {
    // Application resource acquisition handler
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Called when the application is created
    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);
}

The native Tizen Hello World application uses EFL (Enlightenment Foundation Libraries) for the UI. ui_app_main is the Tizen entry point that accepts lifecycle callbacks. efl_add creates UI objects through the Win → Conformant → Label hierarchy. EFL UI is based on the Edje composite model — theme descriptions are written in .edc files and compiled into .edj.

Tizen Manifest (tizen-manifest.xml)

The tizen-manifest.xml file is the native application configuration. It specifies id (unique identifier in reverse domain format), package (package name), version, label (display name), author, and description. Privileges declare API access: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Without specifying a privilege, calling the corresponding API will result in a SECURITY_ERR error.

Tizen Web Applications in HTML5 and JavaScript

Tizen Web applications are HTML5 applications packaged in .wgt format (W3C Widget). Development is identical to creating a regular website, but with additional access to the Tizen Device API through the global tizen object. Web applications run in their own Web Runtime (WRT) process, based on the WebKit engine (Tizen 2.x-4.x) or Chromium (Tizen 5.5+).

Web Application Structure

A web application contains index.html (entry point), config.xml (W3C Widget Configuration), CSS, JavaScript, and images. The config.xml file is similar to manifest.webapp in KaiOS: mandatory fields include widget (id, version, height/width for watches), name, description, and author. Permissions for Device API are specified through the tizen:privilege element. The CSP (Content Security Policy) section restricts script sources.

// config.xml for Tizen Watch web application
<?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>Heart rate monitor</name>
    <description>Heart rate measurement on 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>

The minimal config.xml snippet demonstrates key elements: widget with id and version, tizen:application with a wearable profile for round watch screens, tizen:privilege for healthinfo and sensor API, and a Content Security Policy that limits content loading to the application package only.

// Tizen Watch web application: heart rate monitoring
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Checking HRM sensor support
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('HRM sensor not found');
            }

            // Getting access to the heart rate sensor
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('HRM sensor initialized');
        } catch (err) {
            console.error('Initialization error:', err.message);
        }
    },

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

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

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

    updateDisplay(heartRate) {
        // Visualizing heart rate on a 360x360 round screen
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Circular heart rate indicator
        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();
    });
});

The HeartRateMonitor application uses the Tizen Sensor API to access the Galaxy Watch HRM sensor. tizen.sensorservice.getDefaultSensor('HRM') gets the heart rate sensor, startSensor starts measurements with a 1-second interval. A 360×360 canvas draws a circular indicator — a typical UI paradigm for round Tizen watch screens.

Tizen Watch Development: Circle UI and Rotary

Tizen Watch has unique UI features: a round screen (360×360 pixels on Galaxy Watch), a physical bezel (rotary bezel) for navigation, and three hardware buttons: Home, Back, and Custom. Developers must adapt the interface for a round area — corner elements may be cut off. Circle UI is a Samsung library with ready-made components for round screens.

Rotary Bezel

Rotary Bezel — a physical ring around the Galaxy Watch screen that rotates for navigation through lists, volume control, and zooming. In Tizen, the rotation event is handled through rotarydetector or an EFL edje signal. Each bezel notch generates an event with a rotation angle (0-360 degrees). Web applications handle the bezel through the rotarydetector API: tizen.rotarydetector.

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

    init() {
        // Subscribing to bezel rotation events
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — current angle (0-360)
            // event.direction — 'cw' (clockwise) or 'ccw' (counterclockwise)
            this.handleRotation(event);
        });

        // Activating rotarydetector
        detector.start();
    }

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

        // Determining direction and movement
        if (delta > 0) {
            // Clockwise rotation — next element
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Counterclockwise rotation — previous 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();
    }
}

// Initialization on application load
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

The RotaryNavigation class subscribes to rotarydetector events via tizen.rotarydetector.addEventListener. When the bezel is rotated, the direction (cw/ccw) and angle delta are calculated. The current section is highlighted with the active class. rotarydetector.start() is mandatory — without it, events are not generated. destroy() unsubscribes and stops the detector to prevent memory leaks.

UI Features for Watches

The Tizen Watch interface uses components: RotarySelector (circular list controlled by the bezel), CircularList (list with circular scrolling), RadialMenu (radial menu with icons arranged in a circle), EdgePanel (panel sliding in from the screen edge), and CircleProgressBar (circular progress indicator). All components are optimized for 360×360 resolution and account for the absence of screen corners. Minimum touch target size is 48 pixels.

Tizen TV Development: Apps for Smart TV

Tizen TV — a platform for Samsung Smart TV with its own SDK and emulator. TV applications are divided into two types: web applications (HTML5/JS) and native applications (C/C++). Web applications for TV are faster and easier to develop, but native ones offer better performance for video and games. Tizen TV uses a remote control with D-pad for navigation.

AVPlay API for Video

AVPlay API — the key Tizen TV API for video playback. Supports H.264, H.265 (HEVC), VP9, AV1 formats. Resolution up to 8K on 2024+ TVs. AVPlay API provides hardware decoding, HDR10+, Dolby Atmos, subtitles, and multiple audio tracks. Controlled via play(), pause(), stop(), seekTo(position), setDisplayRect(). The stream can be a local file or an HLS/DASH URL.

// Video player for Tizen TV with AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Checking AVPlay availability
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API unavailable');
            }

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

            // Setting display to full screen TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Configuring audio (Dolby Atmos, if supported)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Video ready to play');
                },
                (error) => {
                    console.error('Preparation error:', error);
                }
            );
        } catch (err) {
            console.error('Initialization error:', 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'
        }));
    }
}

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

The TizenVideoPlayer class demonstrates working with the AVPlay API. webapis.avplay.open() opens a media stream (local or HLS/DASH). setDisplayRect sets the rendering area — on TV this is typically fullscreen at 3840×2160. prepareAsync is asynchronous preparation with callbacks. AVPlay supports adaptive bitrate via ADAPTIVE_INFO and subtitles via the SUBTITLE property.

Galaxy Store and Publishing Applications

Samsung Galaxy Store — the official app store for Tizen (watches, TVs, IoT). Developer registration is $0 (free) through the Samsung Developers program. Developers upload applications in .tpk (native) or .wgt (web) format, signed with a Samsung certificate. Moderation takes 2-5 business days. Galaxy Store is available in 190 countries.

Application Signing

Tizen requires a digital signature for applications using a Samsung certificate. Process: generate an Author Certificate through Samsung Certificate Manager, create a Distributor Certificate for the store, sign the package via Tizen Studio (Build Signed Package). The certificate is linked to the developer account. Without a signature, the application can only be installed on dev devices with Developer Mode enabled.

Monetization Model

Galaxy Store supports paid applications (30% commission on the first $10,000, then 25%), subscriptions (25%), advertising via Samsung Ads, and in-app purchases through Samsung IAP. For TV applications, the Smart TV Premium Channels model is available. Minimum price is $0.99. Payouts are made monthly upon reaching the $100 threshold.