Tizen: la esencia del desarrollo para Samsung Watch y Smart TV

¿Qué es Tizen?

Tizen es un sistema operativo de código abierto supervisado por Samsung y la Linux Foundation. El primer lanzamiento comercial, Tizen 1.0, se produjo en 2012. El sistema se basa en el kernel Linux y utiliza su propia arquitectura de frameworks para diferentes tipos de dispositivos: Tizen Mobile (teléfonos inteligentes — proyecto cerrado en 2017), Tizen Watch (relojes), Tizen TV (televisores) y Tizen IoT (hogar inteligente).

Desde 2021, Samsung utiliza Tizen principalmente en dispositivos portátiles y televisores. Todos los relojes inteligentes Galaxy Watch anteriores a 2021 funcionaban con Tizen (Galaxy Watch, Watch Active, Watch 3). A partir de Galaxy Watch 4, Samsung cambió a Wear OS con One UI Watch, pero Tizen continúa siendo compatible con dispositivos existentes y TVs. Según Samsung (Tizen Ecosystem Report, 2025), más de 180 millones de televisores en todo el mundo tienen Tizen TV instalado.

Una característica clave de Tizen es el soporte de dos paradigmas de desarrollo: aplicaciones nativas (C/C++) con máximo rendimiento y aplicaciones web (HTML5, CSS, JavaScript) para desarrollo rápido. Ambos tipos tienen acceso a Tizen Device API — envoltorios para trabajar con Bluetooth, NFC, Wi-Fi, sensores, cámara y multimedia.

Historial de versiones de Tizen

Tizen 2.3 (2014) — primera versión estable para teléfonos inteligentes Samsung Z. Tizen 3.0 (2017) — multitarea mejorada, soporte de Vulkan, arquitectura de 64 bits. Tizen 4.0 (2018) — frameworks rediseñados, soporte de aceleración AI en NPU. Tizen 5.5 (2020) — Tizen TV con AVPlay 2.0, WebAssembly, renderizado mejorado. Tizen 6.0 (2022) — soporte de inferencia ML en el dispositivo, Protocolo Matter para IoT.

Arquitectura de Tizen: kernel Linux y frameworks

La arquitectura de Tizen se basa en un principio modular con una estructura de múltiples capas. La capa inferior es el kernel Linux con parches para eficiencia energética y tareas en tiempo real (RT_PREEMPT para TV y audio). Sobre el kernel se encuentra la capa de abstracción de hardware (HAL), que proporciona acceso unificado a los controladores de cámara, sensores, Bluetooth, Wi-Fi, NFC y pantalla (a través de DirectFB o Wayland).

Capa Core Framework

La capa Core Framework incluye Application Framework (gestión del ciclo de vida de las aplicaciones), UI Framework (EFL — Enlightenment Foundation Libraries para UI, DALi — motor 3D para juegos y animaciones), Multimedia Framework (cámara, audio, video a través de GStreamer y MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) y Security Framework (SELinux, Smack, Sistema de Privilegios de Tizen).

Capa de Servicios

La capa de servicios proporciona servicios del sistema: Application Manager (inicio, detención, multitarea), Package Manager (instalación/desinstalación de aplicaciones, formatos .tpk y .wgt), Location Manager (GPS, posicionamiento Wi-Fi, Geocerca), Sensor Manager (acelerómetro, giroscopio, barómetro, monitor de frecuencia cardíaca), Context Manager (reconocimiento de actividad del usuario: caminar, correr, dormir).

Device API para aplicaciones web

Tizen proporciona Device API — interfaces de JavaScript para aplicaciones web que brindan acceso a las mismas funciones que las API nativas. Las API se dividen en módulos: 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.

Aplicaciones nativas de Tizen en C/C++

Las aplicaciones nativas de Tizen se compilan en un archivo ejecutable en formato .tpk (Tizen Package Kit). El lenguaje principal es C++11/14 con el compilador GCC o Clang. El desarrollo se realiza en Tizen Studio o Visual Studio Code con la extensión Tizen. Las aplicaciones nativas tienen acceso directo a EFL, DALi, GStreamer y todas las API del sistema sin intermediarios, lo que garantiza el máximo rendimiento.

Estructura de una aplicación nativa

Una aplicación nativa incluye un archivo tizen-manifest.xml (similar a AndroidManifest.xml), una o varias bibliotecas compartidas (.so) y recursos (imágenes, fuentes, localizaciones). El ciclo de vida se gestiona a través de app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. La interfaz de usuario se construye con EFL (Edje + Elementary) para aplicaciones con ventanas o DALi para gráficos 3D.

// Aplicación nativa de Tizen en C++ con 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) {
    // Creación de una ventana de Tizen
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Título de la ventana
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — contenedor estándar de Tizen para dispositivos portátiles
    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);

    // Etiqueta de texto
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "¡Bienvenido a Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Visualización de la ventana
    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) {
    // Manejador de adquisición de recursos de la aplicación
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Se llama cuando se crea la aplicación
    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);
}

La aplicación nativa Tizen Hello World utiliza EFL (Enlightenment Foundation Libraries) para la interfaz de usuario. ui_app_main es el punto de entrada de Tizen que acepta callbacks del ciclo de vida. efl_add crea objetos de UI a través de la jerarquía Win → Conformant → Label. La interfaz de EFL se basa en el modelo compuesto Edje: las descripciones de temas se escriben en archivos .edc y se compilan en .edj.

Manifiesto de Tizen (tizen-manifest.xml)

El archivo tizen-manifest.xml es la configuración de la aplicación nativa. Especifica id (identificador único en formato de dominio inverso), package (nombre del paquete), version, label (nombre mostrado), author y description. Los privilegios declaran el acceso a API: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Sin especificar un privilegio, llamar a la API correspondiente resultará en un error SECURITY_ERR.

Aplicaciones web de Tizen en HTML5 y JavaScript

Las aplicaciones web de Tizen son aplicaciones HTML5 empaquetadas en formato .wgt (Widget W3C). El desarrollo es idéntico a la creación de un sitio web normal, pero con acceso adicional a Tizen Device API a través del objeto global tizen. Las aplicaciones web se ejecutan en su propio proceso Web Runtime (WRT), basado en el motor WebKit (Tizen 2.x-4.x) o Chromium (Tizen 5.5+).

Estructura de una aplicación web

Una aplicación web contiene index.html (punto de entrada), config.xml (Configuración de Widget W3C), CSS, JavaScript e imágenes. El archivo config.xml es similar a manifest.webapp en KaiOS: los campos obligatorios incluyen widget (id, version, height/width para relojes), name, description y author. Los permisos para Device API se especifican mediante el elemento tizen:privilege. La sección CSP (Política de Seguridad de Contenido) restringe las fuentes de scripts.

// config.xml para aplicación web de 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>Pulsómetro</name>
    <description>Medición del pulso en 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>

El fragmento mínimo de config.xml demuestra elementos clave: widget con id y versión, tizen:application con perfil wearable para pantallas redondas de reloj, tizen:privilege para healthinfo y sensor API, y una Política de Seguridad de Contenido que limita la carga de contenido solo al paquete de la aplicación.

// Aplicación web de Tizen Watch: monitoreo de frecuencia cardíaca
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Verificación de soporte del sensor HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Sensor HRM no encontrado');
            }

            // Obtención de acceso al sensor de frecuencia cardíaca
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Sensor HRM inicializado');
        } catch (err) {
            console.error('Error de inicialización:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // midiendo cada segundo
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Error del sensor:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Visualización de la frecuencia cardíaca en una pantalla redonda de 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Indicador circular de frecuencia cardíaca
        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();
    });
});

La aplicación HeartRateMonitor utiliza Tizen Sensor API para acceder al sensor HRM de Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') obtiene el sensor de frecuencia cardíaca, startSensor inicia las mediciones con un intervalo de 1 segundo. Un canvas de 360×360 dibuja un indicador circular — una paradigma típico de UI para pantallas redondas de reloj Tizen.

Desarrollo para Tizen Watch: Circle UI y Rotary

Tizen Watch tiene características de UI únicas: una pantalla redonda (360×360 píxeles en Galaxy Watch), un bisel físico (rotary bezel) para navegación y tres botones físicos: Home, Back y Custom. El desarrollador debe adaptar la interfaz a un área redonda: los elementos en las esquinas pueden cortarse. Circle UI es una biblioteca de Samsung con componentes listos para pantallas redondas.

Rotary Bezel

Rotary Bezel — un anillo físico alrededor de la pantalla de Galaxy Watch que gira para navegar por listas, ajustar el volumen y hacer zoom. En Tizen, el evento de rotación se maneja a través de rotarydetector o una señal edje de EFL. Cada muesca del bisel genera un evento con un ángulo de rotación (0-360 grados). Las aplicaciones web manejan el bisel a través de la API rotarydetector: tizen.rotarydetector.

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

    init() {
        // Suscripción a eventos de rotación del bisel
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — ángulo actual (0-360)
            // event.direction — 'cw' (horario) o 'ccw' (antihorario)
            this.handleRotation(event);
        });

        // Activación de rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // cambio de ángulo
        this.currentAngle += delta;

        // Determinación de dirección y movimiento
        if (delta > 0) {
            // Rotación horaria — siguiente elemento
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Rotación antihoraria — elemento 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();
    }
}

// Inicialización al cargar la aplicación
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

La clase RotaryNavigation se suscribe a eventos rotarydetector a través de tizen.rotarydetector.addEventListener. Cuando se gira el bisel, se calcula la dirección (cw/ccw) y el delta del ángulo. La sección actual se resalta con la clase active. rotarydetector.start() es obligatorio — sin él, no se generan eventos. destroy() cancela la suscripción y detiene el detector para evitar fugas de memoria.

Características de UI para relojes

La interfaz de Tizen Watch utiliza componentes: RotarySelector (lista circular controlada por el bisel), CircularList (lista con desplazamiento circular), RadialMenu (menú radial con iconos dispuestos en círculo), EdgePanel (panel que se desliza desde el borde de la pantalla) y CircleProgressBar (indicador de progreso circular). Todos los componentes están optimizados para resolución 360×360 y tienen en cuenta la ausencia de esquinas en la pantalla. El tamaño mínimo de los objetivos táctiles es de 48 píxeles.

Desarrollo para Tizen TV: aplicaciones para Smart TV

Tizen TV — una plataforma para Samsung Smart TV con su propio SDK y emulador. Las aplicaciones para TV se dividen en dos tipos: aplicaciones web (HTML5/JS) y aplicaciones nativas (C/C++). Las aplicaciones web para TV se desarrollan más rápido y son más sencillas, pero las nativas ofrecen un mejor rendimiento para video y juegos. Tizen TV utiliza un control remoto con D-pad para la navegación.

API AVPlay para video

AVPlay API — la API clave de Tizen TV para reproducción de video. Compatible con formatos H.264, H.265 (HEVC), VP9, AV1. Resolución de hasta 8K en TVs de 2024+. AVPlay API proporciona decodificación por hardware, HDR10+, Dolby Atmos, subtítulos y múltiples pistas de audio. Control mediante play(), pause(), stop(), seekTo(position), setDisplayRect(). El flujo puede ser un archivo local o una URL HLS/DASH.

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

    async init(url) {
        try {
            // Verificación de disponibilidad de AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API no disponible');
            }

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

            // Configuración de visualización a pantalla completa en TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Configuración de audio (Dolby Atmos, si es compatible)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Vídeo listo para reproducir');
                },
                (error) => {
                    console.error('Error de preparación:', error);
                }
            );
        } catch (err) {
            console.error('Error de inicialización:', 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'
        }));
    }
}

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

La clase TizenVideoPlayer demuestra el trabajo con AVPlay API. webapis.avplay.open() abre un flujo de medios (local o HLS/DASH). setDisplayRect establece el área de renderizado — en TV suele ser pantalla completa a 3840×2160. prepareAsync es una preparación asíncrona con callbacks. AVPlay admite tasa de bits adaptativa mediante ADAPTIVE_INFO y subtítulos mediante la propiedad SUBTITLE.

Galaxy Store y publicación de aplicaciones

Samsung Galaxy Store — la tienda oficial de aplicaciones para Tizen (relojes, TVs, IoT). El registro de desarrollador es gratuito a través del programa Samsung Developers. Los desarrolladores suben aplicaciones en formato .tpk (nativas) o .wgt (web), firmadas con un certificado de Samsung. La moderación toma de 2 a 5 días hábiles. Galaxy Store está disponible en 190 países.

Firma de aplicaciones

Tizen requiere una firma digital para las aplicaciones mediante un certificado de Samsung. Proceso: generar un Certificado de Autor a través de Samsung Certificate Manager, crear un Certificado de Distribuidor para la tienda, firmar el paquete mediante Tizen Studio (Build Signed Package). El certificado está vinculado a la cuenta del desarrollador. Sin firma, la aplicación solo se puede instalar en dispositivos de desarrollo con el Modo Desarrollador activado.

Modelo de monetización

Galaxy Store admite aplicaciones de pago (comisión del 30% sobre los primeros $10,000, luego 25%), suscripciones (25%), publicidad a través de Samsung Ads y compras dentro de la aplicación mediante Samsung IAP. Para aplicaciones de TV, está disponible el modelo Smart TV Premium Channels. El precio mínimo es de $0.99. Los pagos se realizan mensualmente al alcanzar el umbral de $100.