Tizen : l'essence du développement pour Samsung Watch et Smart TV

Qu'est-ce que Tizen ?

Tizen est un système d'exploitation open source supervisé par Samsung et la Linux Foundation. La première version commerciale, Tizen 1.0, a été lancée en 2012. Le système est basé sur le noyau Linux et utilise sa propre architecture de frameworks pour différents types d'appareils : Tizen Mobile (smartphones — projet fermé en 2017), Tizen Watch (montres), Tizen TV (téléviseurs) et Tizen IoT (maison intelligente).

Depuis 2021, Samsung utilise Tizen principalement dans les appareils portables et les téléviseurs. Toutes les montres connectées Galaxy Watch avant 2021 fonctionnaient sous Tizen (Galaxy Watch, Watch Active, Watch 3). À partir de la Galaxy Watch 4, Samsung est passé à Wear OS avec One UI Watch, mais Tizen continue d'être pris en charge pour les appareils existants et les TV. Selon Samsung (Tizen Ecosystem Report, 2025), plus de 180 millions de téléviseurs dans le monde ont Tizen TV installé.

Une caractéristique clé de Tizen est la prise en charge de deux paradigmes de développement : les applications natives (C/C++) avec des performances maximales et les applications web (HTML5, CSS, JavaScript) pour un développement rapide. Les deux types ont accès à Tizen Device API — des wrappers pour travailler avec Bluetooth, NFC, Wi-Fi, capteurs, caméra et multimédia.

Historique des versions de Tizen

Tizen 2.3 (2014) — première version stable pour les smartphones Samsung Z. Tizen 3.0 (2017) — multitâche amélioré, prise en charge de Vulkan, architecture 64 bits. Tizen 4.0 (2018) — frameworks repensés, prise en charge de l'accélération IA sur NPU. Tizen 5.5 (2020) — Tizen TV avec AVPlay 2.0, WebAssembly, rendu amélioré. Tizen 6.0 (2022) — prise en charge de l'inférence ML sur l'appareil, protocole Matter pour IoT.

Architecture Tizen : noyau Linux et frameworks

L'architecture Tizen est construite selon un principe modulaire avec une structure multicouche. La couche inférieure est le noyau Linux avec des correctifs pour l'efficacité énergétique et les tâches en temps réel (RT_PREEMPT pour TV et audio). Au-dessus du noyau se trouve la couche d'abstraction matérielle (HAL), qui fournit un accès unifié aux pilotes de caméra, capteurs, Bluetooth, Wi-Fi, NFC et écran (via DirectFB ou Wayland).

Couche Core Framework

La couche Core Framework comprend Application Framework (gestion du cycle de vie des applications), UI Framework (EFL — Enlightenment Foundation Libraries pour l'UI, DALi — moteur 3D pour jeux et animations), Multimedia Framework (caméra, audio, vidéo via GStreamer et MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) et Security Framework (SELinux, Smack, Système de Privilèges Tizen).

Couche de services

La couche de services fournit des services système : Application Manager (lancement, arrêt, multitâche), Package Manager (installation/désinstallation d'applications, formats .tpk et .wgt), Location Manager (GPS, géolocalisation Wi-Fi, Géofence), Sensor Manager (accéléromètre, gyroscope, baromètre, moniteur de fréquence cardiaque), Context Manager (reconnaissance d'activité utilisateur : marche, course, sommeil).

Device API pour applications web

Tizen fournit Device API — des interfaces JavaScript pour applications web qui donnent accès aux mêmes fonctionnalités que les API natives. Les API sont divisées en 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.

Applications natives Tizen en C/C++

Les applications natives Tizen sont compilées en un fichier exécutable au format .tpk (Tizen Package Kit). Le langage principal est C++11/14 avec le compilateur GCC ou Clang. Le développement se fait dans Tizen Studio ou Visual Studio Code avec l'extension Tizen. Les applications natives ont un accès direct à EFL, DALi, GStreamer et toutes les API système sans intermédiaires, garantissant des performances maximales.

Structure d'une application native

Une application native comprend un fichier tizen-manifest.xml (similaire à AndroidManifest.xml), une ou plusieurs bibliothèques partagées (.so) et des ressources (images, polices, localisations). Le cycle de vie est géré via app_event_cb : APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. L'interface utilisateur est construite via EFL (Edje + Elementary) pour les applications fenêtrées ou DALi pour les graphiques 3D.

// Application native Tizen en C++ avec interface 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) {
    // Création d'une fenêtre Tizen
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Titre de la fenêtre
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — conteneur standard Tizen pour appareils portables
    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);

    // Étiquette de texte
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Bienvenue dans Tizen !");
    efl_content_set(ad->conform, ad->label);

    // Affichage de la fenêtre
    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) {
    // Gestionnaire d'acquisition de ressources de l'application
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Appelé lors de la création de l'application
    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'application native Tizen Hello World utilise EFL (Enlightenment Foundation Libraries) pour l'interface utilisateur. ui_app_main est le point d'entrée Tizen qui accepte les callbacks du cycle de vie. efl_add crée des objets d'interface utilisateur via la hiérarchie Win → Conformant → Label. L'interface utilisateur EFL est basée sur le modèle composite Edje — les descriptions de thèmes sont écrites dans des fichiers .edc et compilées en .edj.

Manifeste Tizen (tizen-manifest.xml)

Le fichier tizen-manifest.xml est la configuration de l'application native. Il spécifie id (identifiant unique au format de domaine inversé), package (nom du paquet), version, label (nom affiché), author et description. Les privilèges déclarent l'accès aux API : http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Sans spécifier de privilège, l'appel de l'API correspondante entraînera une erreur SECURITY_ERR.

Applications web Tizen en HTML5 et JavaScript

Les applications web Tizen sont des applications HTML5 conditionnées au format .wgt (Widget W3C). Le développement est identique à la création d'un site web classique, mais avec un accès supplémentaire à Tizen Device API via l'objet global tizen. Les applications web s'exécutent dans leur propre processus Web Runtime (WRT), basé sur le moteur WebKit (Tizen 2.x-4.x) ou Chromium (Tizen 5.5+).

Structure d'une application web

Une application web contient index.html (point d'entrée), config.xml (Configuration de Widget W3C), CSS, JavaScript et images. Le fichier config.xml est similaire à manifest.webapp dans KaiOS : les champs obligatoires incluent widget (id, version, height/width pour les montres), name, description et author. Les permissions pour Device API sont spécifiées via l'élément tizen:privilege. La section CSP (Content Security Policy) restreint les sources de scripts.

// config.xml pour application 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>Cardiofréquencemètre</name>
    <description>Mesure du pouls sur 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>

L'extrait minimal de config.xml montre les éléments clés : widget avec id et version, tizen:application avec un profil wearable pour les écrans ronds de montre, tizen:privilege pour healthinfo et sensor API, et une Content Security Policy qui limite le chargement du contenu au seul paquet de l'application.

// Application web Tizen Watch : surveillance de la fréquence cardiaque
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Vérification de la prise en charge du capteur HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Capteur HRM introuvable');
            }

            // Obtention de l'accès au capteur de fréquence cardiaque
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Capteur HRM initialisé');
        } catch (err) {
            console.error('Erreur d'initialisation :', err.message);
        }
    },

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

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

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

    updateDisplay(heartRate) {
        // Visualisation de la fréquence cardiaque sur écran rond 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Indicateur circulaire de fréquence cardiaque
        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'application HeartRateMonitor utilise Tizen Sensor API pour accéder au capteur HRM de la Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') obtient le capteur de fréquence cardiaque, startSensor lance les mesures avec un intervalle de 1 seconde. Un canvas 360×360 dessine un indicateur circulaire — un paradigme d'interface utilisateur typique pour les écrans ronds de montre Tizen.

Développement Tizen Watch : Circle UI et Rotary

Tizen Watch a des caractéristiques d'interface uniques : un écran rond (360×360 pixels sur la Galaxy Watch), une lunette physique (rotary bezel) pour la navigation et trois boutons matériels : Home, Back et Custom. Le développeur doit adapter l'interface à une zone ronde — les éléments d'angle peuvent être coupés. Circle UI est une bibliothèque Samsung avec des composants prêts pour les écrans ronds.

Rotary Bezel

Rotary Bezel — un anneau physique autour de l'écran de la Galaxy Watch qui tourne pour naviguer dans les listes, régler le volume et zoomer. Dans Tizen, l'événement de rotation est traité via rotarydetector ou un signal edge EFL. Chaque cran de la lunette génère un événement avec un angle de rotation (0-360 degrés). Les applications web traitent la lunette via l'API rotarydetector : tizen.rotarydetector.

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

    init() {
        // Abonnement aux événements de rotation de la lunette
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — angle actuel (0-360)
            // event.direction — 'cw' (horaire) ou 'ccw' (antihoraire)
            this.handleRotation(event);
        });

        // Activation de rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // changement d'angle
        this.currentAngle += delta;

        // Détermination de la direction et du mouvement
        if (delta > 0) {
            // Rotation horaire — élément suivant
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Rotation antihoraire — élément précédent
            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();
    }
}

// Initialisation au chargement de l'application
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

La classe RotaryNavigation s'abonne aux événements rotarydetector via tizen.rotarydetector.addEventListener. Lorsque la lunette est tournée, la direction (cw/ccw) et le delta d'angle sont calculés. La section actuelle est mise en surbrillance avec la classe active. rotarydetector.start() est obligatoire — sans lui, les événements ne sont pas générés. destroy() se désabonne et arrête le détecteur pour éviter les fuites mémoire.

Fonctionnalités d'interface pour les montres

L'interface Tizen Watch utilise des composants : RotarySelector (liste circulaire contrôlée par la lunette), CircularList (liste avec défilement circulaire), RadialMenu (menu radial avec icônes disposées en cercle), EdgePanel (panneau glissant depuis le bord de l'écran) et CircleProgressBar (indicateur de progression circulaire). Tous les composants sont optimisés pour la résolution 360×360 et tiennent compte de l'absence de coins d'écran. La taille minimale des cibles tactiles est de 48 pixels.

Développement Tizen TV : applications pour Smart TV

Tizen TV — une plateforme pour Samsung Smart TV avec son propre SDK et émulateur. Les applications TV sont divisées en deux types : applications web (HTML5/JS) et applications natives (C/C++). Les applications web pour TV sont plus rapides et faciles à développer, mais les applications natives offrent de meilleures performances pour la vidéo et les jeux. Tizen TV utilise une télécommande avec D-pad pour la navigation.

API AVPlay pour la vidéo

AVPlay API — l'API clé de Tizen TV pour la lecture vidéo. Prend en charge les formats H.264, H.265 (HEVC), VP9, AV1. Résolution jusqu'à 8K sur les TV 2024+. AVPlay API fournit le décodage matériel, HDR10+, Dolby Atmos, les sous-titres et plusieurs pistes audio. Contrôle via play(), pause(), stop(), seekTo(position), setDisplayRect(). Le flux peut être un fichier local ou une URL HLS/DASH.

// Lecteur vidéo pour Tizen TV avec AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Vérification de la disponibilité d'AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('API AVPlay indisponible');
            }

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

            // Configuration de l'affichage en plein écran TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Configuration audio (Dolby Atmos, si pris en charge)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Vidéo prête à la lecture');
                },
                (error) => {
                    console.error('Erreur de préparation :', error);
                }
            );
        } catch (err) {
            console.error('Erreur d'initialisation :', 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'
        }));
    }
}

// Utilisation
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 démontre le travail avec AVPlay API. webapis.avplay.open() ouvre un flux multimédia (local ou HLS/DASH). setDisplayRect définit la zone de rendu — sur TV, c'est généralement le plein écran en 3840×2160. prepareAsync est une préparation asynchrone avec callbacks. AVPlay prend en charge le débit adaptatif via ADAPTIVE_INFO et les sous-titres via la propriété SUBTITLE.

Galaxy Store et publication d'applications

Samsung Galaxy Store — la boutique officielle d'applications pour Tizen (montres, TV, IoT). L'inscription des développeurs est gratuite via le programme Samsung Developers. Les développeurs téléchargent des applications au format .tpk (natif) ou .wgt (web), signées avec un certificat Samsung. La modération prend 2 à 5 jours ouvrables. Galaxy Store est disponible dans 190 pays.

Signature d'application

Tizen exige une signature numérique pour les applications avec un certificat Samsung. Processus : générer un certificat d'auteur via Samsung Certificate Manager, créer un certificat de distributeur pour le magasin, signer le paquet via Tizen Studio (Build Signed Package). Le certificat est lié au compte développeur. Sans signature, l'application ne peut être installée que sur des appareils de développement avec le mode développeur activé.

Modèle de monétisation

Galaxy Store prend en charge les applications payantes (commission de 30% sur les premiers 10 000 $, puis 25%), les abonnements (25%), la publicité via Samsung Ads et les achats intégrés via Samsung IAP. Pour les applications TV, le modèle Smart TV Premium Channels est disponible. Le prix minimum est de 0,99 $. Les paiements sont effectués mensuellement à partir de 100 $.