Tizen: l'essenza dello sviluppo per Samsung Watch e Smart TV

Cos'è Tizen?

Tizen è un sistema operativo open source supervisionato da Samsung e Linux Foundation. La prima versione commerciale, Tizen 1.0, è stata lanciata nel 2012. Il sistema si basa sul kernel Linux e utilizza una propria architettura di framework per diversi tipi di dispositivi: Tizen Mobile (smartphone — progetto chiuso nel 2017), Tizen Watch (orologi), Tizen TV (televisori) e Tizen IoT (casa intelligente).

Dal 2021, Samsung utilizza Tizen principalmente in dispositivi indossabili e televisori. Tutti gli smartwatch Galaxy Watch precedenti al 2021 funzionavano con Tizen (Galaxy Watch, Watch Active, Watch 3). A partire da Galaxy Watch 4, Samsung è passata a Wear OS con One UI Watch, ma Tizen continua a essere supportato per dispositivi esistenti e TV. Secondo Samsung (Tizen Ecosystem Report, 2025), oltre 180 milioni di TV in tutto il mondo hanno Tizen TV installato.

Una caratteristica chiave di Tizen è il supporto di due paradigmi di sviluppo: applicazioni native (C/C++) con prestazioni massime e applicazioni web (HTML5, CSS, JavaScript) per sviluppo rapido. Entrambi i tipi hanno accesso a Tizen Device API — wrapper per lavorare con Bluetooth, NFC, Wi-Fi, sensori, fotocamera e contenuti multimediali.

Storia delle versioni di Tizen

Tizen 2.3 (2014) — prima versione stabile per smartphone Samsung Z. Tizen 3.0 (2017) — multitasking migliorato, supporto Vulkan, architettura a 64 bit. Tizen 4.0 (2018) — framework ridisegnati, supporto accelerazione AI su NPU. Tizen 5.5 (2020) — Tizen TV con AVPlay 2.0, WebAssembly, rendering migliorato. Tizen 6.0 (2022) — supporto inferenza ML sul dispositivo, protocollo Matter per IoT.

Architettura Tizen: kernel Linux e framework

L'architettura Tizen è costruita su un principio modulare con una struttura a più livelli. Lo strato inferiore è il kernel Linux con patch per l'efficienza energetica e attività in tempo reale (RT_PREEMPT per TV e audio). Sopra il kernel si trova il livello di astrazione hardware (HAL), che fornisce accesso unificato ai driver di fotocamera, sensori, Bluetooth, Wi-Fi, NFC e display (tramite DirectFB o Wayland).

Core Framework Layer

Il Core Framework Layer include Application Framework (gestione del ciclo di vita delle applicazioni), UI Framework (EFL — Enlightenment Foundation Libraries per l'interfaccia utente, DALi — motore 3D per giochi e animazioni), Multimedia Framework (fotocamera, audio, video tramite GStreamer e MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) e Security Framework (SELinux, Smack, Sistema di privilegi Tizen).

Service Layer

Il Service Layer fornisce servizi di sistema: Application Manager (avvio, arresto, multitasking), Package Manager (installazione/disinstallazione applicazioni, formati .tpk e .wgt), Location Manager (GPS, posizionamento Wi-Fi, Geofence), Sensor Manager (accelerometro, giroscopio, barometro, cardiofrequenzimetro), Context Manager (riconoscimento attività utente: camminare, correre, dormire).

Device API per applicazioni web

Tizen fornisce Device API — interfacce JavaScript per applicazioni web che danno accesso alle stesse funzionalità delle API native. Le API sono divise in moduli: 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.

Applicazioni native Tizen in C/C++

Le applicazioni native Tizen vengono compilate in un file eseguibile in formato .tpk (Tizen Package Kit). Il linguaggio principale è C++11/14 con compilatore GCC o Clang. Lo sviluppo avviene in Tizen Studio o Visual Studio Code con estensione Tizen. Le applicazioni native hanno accesso diretto a EFL, DALi, GStreamer e tutte le API di sistema senza intermediari, garantendo prestazioni massime.

Struttura di un'applicazione nativa

Un'applicazione nativa include un file tizen-manifest.xml (simile ad AndroidManifest.xml), una o più librerie condivise (.so) e risorse (immagini, caratteri, localizzazioni). Il ciclo di vita è gestito tramite app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. L'interfaccia utente viene costruita tramite EFL (Edje + Elementary) per applicazioni a finestra o DALi per grafica 3D.

// Applicazione nativa Tizen in C++ con interfaccia 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) {
    // Creazione di una finestra Tizen
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

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

    // Conformant — contenitore standard Tizen per dispositivi indossabili
    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);

    // Etichetta di testo
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Benvenuti in Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Visualizzazione della finestra
    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) {
    // Gestore di acquisizione risorse dell'applicazione
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Chiamato alla creazione dell'applicazione
    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);
}

L'applicazione nativa Tizen Hello World utilizza EFL (Enlightenment Foundation Libraries) per l'interfaccia utente. ui_app_main è il punto di ingresso di Tizen che accetta callback del ciclo di vita. efl_add crea oggetti dell'interfaccia utente tramite la gerarchia Win → Conformant → Label. L'interfaccia utente EFL si basa sul modello composito Edje — le descrizioni dei temi sono scritte in file .edc e compilate in .edj.

Manifest Tizen (tizen-manifest.xml)

Il file tizen-manifest.xml è la configurazione dell'applicazione nativa. Specifica id (identificatore univoco in formato dominio inverso), package (nome del pacchetto), version, label (nome visualizzato), author e description. I privilegi dichiarano l'accesso alle API: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Senza specificare un privilegio, la chiamata all'API corrispondente restituirà un errore SECURITY_ERR.

Applicazioni web Tizen in HTML5 e JavaScript

Le applicazioni web Tizen sono applicazioni HTML5 impacchettate in formato .wgt (Widget W3C). Lo sviluppo è identico alla creazione di un sito web normale, ma con accesso aggiuntivo a Tizen Device API tramite l'oggetto globale tizen. Le applicazioni web vengono eseguite in un processo Web Runtime (WRT) separato, basato sul motore WebKit (Tizen 2.x-4.x) o Chromium (Tizen 5.5+).

Struttura di un'applicazione web

Un'applicazione web contiene index.html (punto di ingresso), config.xml (Configurazione Widget W3C), CSS, JavaScript e immagini. Il file config.xml è simile a manifest.webapp in KaiOS: i campi obbligatori includono widget (id, version, height/width per orologi), name, description e author. Le autorizzazioni per Device API sono specificate tramite l'elemento tizen:privilege. La sezione CSP (Content Security Policy) limita le origini degli script.

// config.xml per applicazione 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>Pulsometro</name>
    <description>Misurazione del polso su 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>

Il frammento minimo di config.xml mostra gli elementi chiave: widget con id e versione, tizen:application con profilo wearable per schermi rotondi di orologi, tizen:privilege per healthinfo e sensor API, e una Content Security Policy che limita il caricamento dei contenuti al solo pacchetto dell'applicazione.

// Applicazione web Tizen Watch: monitoraggio frequenza cardiaca
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Verifica supporto sensore HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Sensore HRM non trovato');
            }

            // Accesso al sensore di frequenza cardiaca
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Sensore HRM inizializzato');
        } catch (err) {
            console.error('Errore di inizializzazione:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // misura ogni secondo
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Errore del sensore:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Visualizzazione frequenza cardiaca su schermo rotondo 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Indicatore circolare frequenza cardiaca
        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();
    });
});

L'applicazione HeartRateMonitor utilizza Tizen Sensor API per accedere al sensore HRM di Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') ottiene il sensore di frequenza cardiaca, startSensor avvia le misurazioni con intervallo di 1 secondo. Un canvas 360×360 disegna un indicatore circolare — un tipico paradigma UI per schermi rotondi di orologi Tizen.

Sviluppo per Tizen Watch: Circle UI e Rotary

Tizen Watch ha caratteristiche UI uniche: uno schermo rotondo (360×360 pixel su Galaxy Watch), una lunetta fisica (rotary bezel) per la navigazione e tre pulsanti hardware: Home, Back e Custom. Lo sviluppatore deve adattare l'interfaccia a un'area rotonda — gli elementi d'angolo potrebbero essere tagliati. Circle UI è una libreria Samsung con componenti pronti per schermi rotondi.

Rotary Bezel

Rotary Bezel — un anello fisico attorno allo schermo di Galaxy Watch che ruota per navigare tra gli elenchi, regolare il volume e lo zoom. In Tizen, l'evento di rotazione viene gestito tramite rotarydetector o un segnale edje EFL. Ogni tacca della lunetta genera un evento con un angolo di rotazione (0-360 gradi). Le applicazioni web gestiscono la lunetta tramite l'API rotarydetector: tizen.rotarydetector.

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

    init() {
        // Iscrizione agli eventi di rotazione della lunetta
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — angolo corrente (0-360)
            // event.direction — 'cw' (orario) o 'ccw' (antiorario)
            this.handleRotation(event);
        });

        // Attivazione rotarydetector
        detector.start();
    }

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

        // Determinazione direzione e movimento
        if (delta > 0) {
            // Rotazione oraria — elemento successivo
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Rotazione antioraria — elemento precedente
            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();
    }
}

// Inizializzazione al caricamento dell'applicazione
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

La classe RotaryNavigation si iscrive agli eventi rotarydetector tramite tizen.rotarydetector.addEventListener. Quando la lunetta viene ruotata, vengono calcolati la direzione (cw/ccw) e il delta dell'angolo. La sezione corrente viene evidenziata con la classe active. rotarydetector.start() è obbligatorio — senza di esso, gli eventi non vengono generati. destroy() annulla l'iscrizione e arresta il rilevatore per prevenire perdite di memoria.

Caratteristiche UI per orologi

L'interfaccia di Tizen Watch utilizza componenti: RotarySelector (elenco circolare controllato dalla lunetta), CircularList (elenco con scorrimento circolare), RadialMenu (menu radiale con icone disposte in cerchio), EdgePanel (pannello che scorre dal bordo dello schermo) e CircleProgressBar (indicatore di progresso circolare). Tutti i componenti sono ottimizzati per la risoluzione 360×360 e tengono conto dell'assenza di angoli dello schermo. La dimensione minima dei target touch è di 48 pixel.

Sviluppo per Tizen TV: applicazioni per Smart TV

Tizen TV — una piattaforma per Samsung Smart TV con proprio SDK ed emulatore. Le applicazioni TV si dividono in due tipi: applicazioni web (HTML5/JS) e applicazioni native (C/C++). Le applicazioni web per TV sono più veloci e facili da sviluppare, ma quelle native offrono prestazioni migliori per video e giochi. Tizen TV utilizza un telecomando con D-pad per la navigazione.

AVPlay API per video

AVPlay API — l'API chiave di Tizen TV per la riproduzione video. Supporta i formati H.264, H.265 (HEVC), VP9, AV1. Risoluzione fino a 8K su TV 2024+. AVPlay API fornisce decodifica hardware, HDR10+, Dolby Atmos, sottotitoli e multiple tracce audio. Controllo tramite play(), pause(), stop(), seekTo(position), setDisplayRect(). Il flusso può essere un file locale o un URL HLS/DASH.

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

    async init(url) {
        try {
            // Verifica disponibilità AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API non disponibile');
            }

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

            // Impostazione schermo intero TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

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

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Video pronto per la riproduzione');
                },
                (error) => {
                    console.error('Errore di preparazione:', error);
                }
            );
        } catch (err) {
            console.error('Errore di inizializzazione:', 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'
        }));
    }
}

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

La classe TizenVideoPlayer dimostra il lavoro con AVPlay API. webapis.avplay.open() apre un flusso multimediale (locale o HLS/DASH). setDisplayRect imposta l'area di rendering — sul TV di solito è a schermo intero a 3840×2160. prepareAsync è una preparazione asincrona con callback. AVPlay supporta il bitrate adattivo tramite ADAPTIVE_INFO e i sottotitoli tramite la proprietà SUBTITLE.

Galaxy Store e pubblicazione di applicazioni

Samsung Galaxy Store — il negozio ufficiale di applicazioni per Tizen (orologi, TV, IoT). La registrazione dello sviluppatore è gratuita tramite il programma Samsung Developers. Gli sviluppatori caricano applicazioni in formato .tpk (nativo) o .wgt (web), firmate con un certificato Samsung. La moderazione richiede 2-5 giorni lavorativi. Galaxy Store è disponibile in 190 paesi.

Firma dell'applicazione

Tizen richiede una firma digitale per le applicazioni con un certificato Samsung. Processo: generare un Certificato Autore tramite Samsung Certificate Manager, creare un Certificato Distributore per il negozio, firmare il pacchetto tramite Tizen Studio (Build Signed Package). Il certificato è collegato all'account dello sviluppatore. Senza firma, l'applicazione può essere installata solo su dispositivi di sviluppo con Modalità Sviluppatore attivata.

Modello di monetizzazione

Galaxy Store supporta applicazioni a pagamento (commissione 30% sui primi $10.000, poi 25%), abbonamenti (25%), pubblicità tramite Samsung Ads e acquisti in-app tramite Samsung IAP. Per le applicazioni TV, è disponibile il modello Smart TV Premium Channels. Il prezzo minimo è $0,99. I pagamenti vengono effettuati mensilmente al raggiungimento della soglia di $100.