Tizen: esența dezvoltării pentru Samsung Watch și Smart TV

Ce este Tizen?

Tizen este un sistem de operare open source supravegheat de Samsung și Linux Foundation. Prima lansare comercială, Tizen 1.0, a avut loc în 2012. Sistemul se bazează pe nucleul Linux și utilizează propria arhitectură de framework-uri pentru diferite tipuri de dispozitive: Tizen Mobile (smartphone-uri — proiect închis în 2017), Tizen Watch (ceasuri), Tizen TV (televizoare) și Tizen IoT (casă inteligentă).

Din 2021, Samsung utilizează Tizen în principal în dispozitive purtabile și televizoare. Toate smartwatch-urile Galaxy Watch dinainte de 2021 rulau pe Tizen (Galaxy Watch, Watch Active, Watch 3). Începând cu Galaxy Watch 4, Samsung a trecut la Wear OS cu One UI Watch, dar Tizen continuă să fie acceptat pentru dispozitivele existente și TV. Conform Samsung (Raportul Ecosistemului Tizen, 2025), peste 180 de milioane de televizoare din întreaga lume au Tizen TV instalat.

O caracteristică cheie a Tizen este suportul pentru două paradigme de dezvoltare: aplicații native (C/C++) cu performanță maximă și aplicații web (HTML5, CSS, JavaScript) pentru dezvoltare rapidă. Ambele tipuri au acces la Tizen Device API — învelișuri pentru lucrul cu Bluetooth, NFC, Wi-Fi, senzori, cameră și multimedia.

Istoricul versiunilor Tizen

Tizen 2.3 (2014) — prima versiune stabilă pentru smartphone-urile Samsung Z. Tizen 3.0 (2017) — multitasking îmbunătățit, suport Vulkan, arhitectură pe 64 de biți. Tizen 4.0 (2018) — framework-uri reproiectate, suport pentru accelerare AI pe NPU. Tizen 5.5 (2020) — Tizen TV cu AVPlay 2.0, WebAssembly, randare îmbunătățită. Tizen 6.0 (2022) — suport pentru inferență ML pe dispozitiv, Protocolul Matter pentru IoT.

Arhitectura Tizen: nucleul Linux și framework-uri

Arhitectura Tizen este construită pe un principiu modular cu o structură pe mai multe niveluri. Nivelul inferior este nucleul Linux cu patch-uri pentru eficiență energetică și sarcini în timp real (RT_PREEMPT pentru TV și audio). Deasupra nucleului se află Stratul de Abstractizare Hardware (HAL), care oferă acces unificat la driverele de cameră, senzori, Bluetooth, Wi-Fi, NFC și afișaj (prin DirectFB sau Wayland).

Stratul Core Framework

Stratul Core Framework include Application Framework(gestionarea ciclului de viață al aplicațiilor), UI Framework(EFL — Enlightenment Foundation Libraries pentru UI, DALi — motor 3D pentru jocuri și animații), Multimedia Framework(cameră, audio, video prin GStreamer și MediaCodec), Network Framework(Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) și Security Framework(SELinux, Smack, Sistemul de Privilegii Tizen).

Stratul de Servicii

Stratul de servicii oferă servicii de sistem: Application Manager(pornire, oprire, multitasking), Package Manager(instalare/dezinstalare aplicații, formate .tpk și .wgt), Location Manager(GPS, poziționare Wi-Fi, Geofence), Sensor Manager(accelerometru, giroscop, barometru, monitor de frecvență cardiacă), Context Manager(recunoașterea activității utilizatorului: mers, alergare, somn).

Device API pentru aplicații web

Tizen oferă Device API — interfețe JavaScript pentru aplicații web care oferă acces la aceleași funcții ca API-urile native. API-urile sunt împărțite pe module: 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.

Aplicații native Tizen în C/C++

Aplicațiile native Tizen sunt compilate într-un fișier executabil în format .tpk (Tizen Package Kit). Limbajul principal este C++11/14 cu compilatorul GCC sau Clang. Dezvoltarea se face în Tizen Studio sau Visual Studio Code cu extensia Tizen. Aplicațiile native au acces direct la EFL, DALi, GStreamer și toate API-urile de sistem fără intermediari, asigurând performanță maximă.

Structura unei aplicații native

O aplicație nativă include un fișier tizen-manifest.xml (similar cu AndroidManifest.xml), una sau mai multe biblioteci partajate (.so) și resurse (imagini, fonturi, localizări). Ciclul de viață este gestionat prin app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. UI este construit prin EFL (Edje + Elementary) pentru aplicații cu ferestre sau DALi pentru grafică 3D.

// Aplicație nativă Tizen în C++ cu 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) {
    // Crearea unei ferestre Tizen
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

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

    // Conformant — container standard Tizen pentru dispozitive purtabile
    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);

    // Etichetă text
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Bine ați venit în Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Afișarea ferestrei
    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 de achiziție a resurselor aplicației
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Apelat la crearea aplicației
    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);
}

Aplicația nativă Tizen Hello World folosește EFL (Enlightenment Foundation Libraries) pentru UI. ui_app_main este punctul de intrare Tizen care acceptă callback-uri ale ciclului de viață. efl_add creează obiecte UI prin ierarhia Win → Conformant → Label. UI-ul EFL se bazează pe modelul compozit Edje — descrierile de teme sunt scrise în fișiere .edc și compilate în .edj.

Manifestul Tizen (tizen-manifest.xml)

Fișierul tizen-manifest.xml este configurația aplicației native. Specifică id (identificator unic în format de domeniu invers), package (numele pachetului), version, label (numele afișat), author și description. Privilegiile declară accesul la API: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Fără specificarea unui privilegiu, apelarea API-ului corespunzător va rezulta într-o eroare SECURITY_ERR.

Aplicații web Tizen în HTML5 și JavaScript

Aplicațiile web Tizen sunt aplicații HTML5 ambalate în format .wgt (Widget W3C). Dezvoltarea este identică cu crearea unui site web obișnuit, dar cu acces suplimentar la Tizen Device API prin obiectul global tizen. Aplicațiile web rulează în propriul proces Web Runtime (WRT), bazat pe motorul WebKit (Tizen 2.x-4.x) sau Chromium (Tizen 5.5+).

Structura unei aplicații web

O aplicație web conține index.html (punct de intrare), config.xml (Configurare Widget W3C), CSS, JavaScript și imagini. Fișierul config.xml este similar cu manifest.webapp din KaiOS: câmpurile obligatorii includ widget (id, version, height/width pentru ceasuri), name, description și author. Permisiunile pentru Device API sunt specificate prin elementul tizen:privilege. Secțiunea CSP (Content Security Policy) restricționează sursele de scripturi.

// config.xml pentru aplicația web 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>Pulsometru</name>
    <description>Măsurarea pulsului pe 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>

Fragmentul minim de config.xml demonstrează elementele cheie: widget cu id și versiune, tizen:application cu profil wearable pentru ecrane rotunde de ceas, tizen:privilege pentru healthinfo și sensor API și o Politică de Securitate a Conținutului care limitează încărcarea conținutului doar din pachetul aplicației.

// Aplicație web Tizen Watch: monitorizarea frecvenței cardiace
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Verificarea suportului senzorului HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Senzor HRM nu a fost găsit');
            }

            // Obținerea accesului la senzorul de frecvență cardiacă
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Senzor HRM inițializat');
        } catch (err) {
            console.error('Eroare de inițializare:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // măsurare în fiecare secundă
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Eroare senzor:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Vizualizarea frecvenței cardiace pe ecran rotund 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Indicator circular al frecvenței cardiace
        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();
    });
});

Aplicația HeartRateMonitor utilizează Tizen Sensor API pentru a accesa senzorul HRM al Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') obține senzorul de frecvență cardiacă, startSensor începe măsurătorile cu un interval de 1 secundă. Un canvas de 360×360 desenează un indicator circular — un paradigma UI tipică pentru ecranele rotunde ale ceasurilor Tizen.

Dezvoltare pentru Tizen Watch: Circle UI și Rotary

Tizen Watch are caracteristici UI unice: un ecran rotund (360×360 pixeli pe Galaxy Watch), o ramă fizică (rotary bezel) pentru navigare și trei butoane hardware: Home, Back și Custom. Dezvoltatorul trebuie să adapteze interfața pentru o zonă rotundă — elementele de colț pot fi tăiate. Circle UI este o bibliotecă Samsung cu componente gata făcute pentru ecrane rotunde.

Rotary Bezel

Rotary Bezel — un inel fizic în jurul ecranului Galaxy Watch care se rotește pentru navigarea prin liste, reglarea volumului și zoom. În Tizen, evenimentul de rotație este gestionat prin rotarydetector sau un semnal edje EFL. Fiecare crestătură a ramei generează un eveniment cu un unghi de rotație (0-360 de grade). Aplicațiile web gestionează rama prin API-ul rotarydetector: tizen.rotarydetector.

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

    init() {
        // Abonarea la evenimente de rotație a ramei
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — unghiul curent (0-360)
            // event.direction — 'cw' (sens orar) sau 'ccw' (sens antiorar)
            this.handleRotation(event);
        });

        // Activarea rotarydetector
        detector.start();
    }

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

        // Determinarea direcției și mișcării
        if (delta > 0) {
            // Rotire în sens orar — elementul următor
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Rotire în sens antiorar — elementul anterior
            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();
    }
}

// Inițializare la încărcarea aplicației
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

Clasa RotaryNavigation se abonează la evenimente rotarydetector prin tizen.rotarydetector.addEventListener. Când rama este rotită, se calculează direcția (cw/ccw) și delta unghiului. Secțiunea curentă este evidențiată cu clasa active. rotarydetector.start() este obligatoriu — fără el, evenimentele nu sunt generate. destroy() se dezabonează și oprește detectorul pentru a preveni scurgerile de memorie.

Caracteristici UI pentru ceasuri

Interfața Tizen Watch utilizează componente: RotarySelector(listă circulară controlată de ramă), CircularList(listă cu derulare circulară), RadialMenu(meniu radial cu pictograme dispuse în cerc), EdgePanel(panoul care alunecă de pe marginea ecranului) și CircleProgressBar(indicator circular de progres). Toate componentele sunt optimizate pentru rezoluția 360×360 și țin cont de absența colțurilor ecranului. Dimensiunea minimă a țintelor tactile este de 48 de pixeli.

Dezvoltare pentru Tizen TV: aplicații pentru Smart TV

Tizen TV — o platformă pentru Samsung Smart TV cu propriul SDK și emulator. Aplicațiile TV sunt împărțite în două tipuri: aplicații web (HTML5/JS) și aplicații native (C/C++). Aplicațiile web pentru TV sunt mai rapide și mai ușor de dezvoltat, dar cele native oferă performanță mai bună pentru video și jocuri. Tizen TV utilizează o telecomandă cu D-pad pentru navigare.

API-ul AVPlay pentru video

API-ul AVPlay — API-ul cheie al Tizen TV pentru redarea video. Suportă formatele H.264, H.265 (HEVC), VP9, AV1. Rezoluție de până la 8K pe TV 2024+. API-ul AVPlay oferă decodificare hardware, HDR10+, Dolby Atmos, subtitrări și mai multe piste audio. Control prin play(), pause(), stop(), seekTo(position), setDisplayRect(). Fluxul poate fi un fișier local sau un URL HLS/DASH.

// Player video pentru Tizen TV cu AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Verificarea disponibilității AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API indisponibil');
            }

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

            // Setarea afișajului pe ecran complet TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Configurare audio (Dolby Atmos, dacă este acceptat)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Videoclipul este gata de redare');
                },
                (error) => {
                    console.error('Eroare de pregătire:', error);
                }
            );
        } catch (err) {
            console.error('Eroare de inițializare:', 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'
        }));
    }
}

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

Clasa TizenVideoPlayer demonstrează lucrul cu API-ul AVPlay. webapis.avplay.open() deschide un flux media (local sau HLS/DASH). setDisplayRect stabilește zona de randare — pe TV este de obicei ecran complet la 3840×2160. prepareAsync este o pregătire asincronă cu callback-uri. AVPlay acceptă rată de biți adaptivă prin ADAPTIVE_INFO și subtitrări prin proprietatea SUBTITLE.

Galaxy Store și publicarea aplicațiilor

Samsung Galaxy Store — magazinul oficial de aplicații pentru Tizen (ceasuri, TV, IoT). Înregistrarea dezvoltatorului este gratuită prin programul Samsung Developers. Dezvoltatorii încarcă aplicații în format .tpk (nativ) sau .wgt (web), semnate cu un certificat Samsung. Moderarea durează 2-5 zile lucrătoare. Galaxy Store este disponibil în 190 de țări.

Semnarea aplicației

Tizen necesită o semnătură digitală pentru aplicații cu un certificat Samsung. Proces: generarea unui Certificat de Autor prin Samsung Certificate Manager, crearea unui Certificat de Distribuitor pentru magazin, semnarea pachetului prin Tizen Studio (Build Signed Package). Certificatul este legat de contul dezvoltatorului. Fără semnătură, aplicația poate fi instalată doar pe dispozitive de dezvoltare cu Modul Dezvoltator activat.

Model de monetizare

Galaxy Store acceptă aplicații plătite (comision 30% pentru primii 10.000 $, apoi 25%), abonamente (25%), publicitate prin Samsung Ads și achiziții în aplicație prin Samsung IAP. Pentru aplicațiile TV, este disponibil modelul Smart TV Premium Channels. Prețul minim este de 0,99 $. Plățile se efectuează lunar la atingerea pragului de 100 $.