Tizen: a essência do desenvolvimento para Samsung Watch e Smart TV

O que é Tizen?

Tizen é um sistema operacional de código aberto supervisionado pela Samsung e pela Linux Foundation. O primeiro lançamento comercial, Tizen 1.0, ocorreu em 2012. O sistema é baseado no kernel Linux e usa sua própria arquitetura de frameworks para diferentes tipos de dispositivos: Tizen Mobile (smartphones — projeto encerrado em 2017), Tizen Watch (relógios), Tizen TV (televisores) e Tizen IoT (casa inteligente).

Desde 2021, a Samsung usa o Tizen principalmente em dispositivos vestíveis e televisores. Todos os smartwatches Galaxy Watch anteriores a 2021 rodavam Tizen (Galaxy Watch, Watch Active, Watch 3). A partir do Galaxy Watch 4, a Samsung migrou para o Wear OS com One UI Watch, mas o Tizen continua sendo suportado para dispositivos existentes e TVs. De acordo com a Samsung (Tizen Ecosystem Report, 2025), mais de 180 milhões de TVs em todo o mundo têm o Tizen TV instalado.

Uma característica chave do Tizen é o suporte a dois paradigmas de desenvolvimento: aplicativos nativos (C/C++) com máximo desempenho e aplicativos web (HTML5, CSS, JavaScript) para desenvolvimento rápido. Ambos os tipos têm acesso ao Tizen Device API — wrappers para trabalhar com Bluetooth, NFC, Wi-Fi, sensores, câmera e multimídia.

Histórico de versões do Tizen

Tizen 2.3 (2014) — primeira versão estável para smartphones Samsung Z. Tizen 3.0 (2017) — multitarefa melhorada, suporte a Vulkan, arquitetura de 64 bits. Tizen 4.0 (2018) — frameworks reformulados, suporte a aceleração de IA em NPU. Tizen 5.5 (2020) — Tizen TV com AVPlay 2.0, WebAssembly, renderização melhorada. Tizen 6.0 (2022) — suporte a inferência ML no dispositivo, Protocolo Matter para IoT.

Arquitetura Tizen: kernel Linux e frameworks

A arquitetura Tizen é construída em um princípio modular com uma estrutura de múltiplas camadas. A camada inferior é o kernel Linux com patches para eficiência energética e tarefas em tempo real (RT_PREEMPT para TV e áudio). Acima do kernel está a Camada de Abstração de Hardware (HAL), que fornece acesso unificado aos drivers de câmera, sensores, Bluetooth, Wi-Fi, NFC e display (via DirectFB ou Wayland).

Camada Core Framework

A camada Core Framework inclui Application Framework (gerenciamento do ciclo de vida do aplicativo), UI Framework (EFL — Enlightenment Foundation Libraries para UI, DALi — mecanismo 3D para jogos e animações), Multimedia Framework (câmera, áudio, vídeo via GStreamer e MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) e Security Framework (SELinux, Smack, Sistema de Privilégios Tizen).

Camada de Serviços

A camada de serviços fornece serviços do sistema: Application Manager (inicialização, parada, multitarefa), Package Manager (instalação/desinstalação de aplicativos, formatos .tpk e .wgt), Location Manager (GPS, posicionamento Wi-Fi, Geofence), Sensor Manager (acelerômetro, giroscópio, barômetro, monitor de frequência cardíaca), Context Manager (reconhecimento de atividade do usuário: caminhar, correr, dormir).

Device API para aplicativos web

Tizen fornece Device API — interfaces JavaScript para aplicativos web que dão acesso aos mesmos recursos que as APIs nativas. As APIs são divididas em 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.

Aplicativos nativos Tizen em C/C++

Aplicativos nativos Tizen são compilados em um arquivo executável no formato .tpk (Tizen Package Kit). A linguagem principal é C++11/14 com o compilador GCC ou Clang. O desenvolvimento é feito no Tizen Studio ou Visual Studio Code com a extensão Tizen. Aplicativos nativos têm acesso direto a EFL, DALi, GStreamer e todas as APIs do sistema sem intermediários, garantindo máximo desempenho.

Estrutura do aplicativo nativo

Um aplicativo nativo inclui um arquivo tizen-manifest.xml (semelhante ao AndroidManifest.xml), uma ou mais bibliotecas compartilhadas (.so) e recursos (imagens, fontes, localizações). O ciclo de vida é gerenciado através de app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. A UI é construída usando EFL (Edje + Elementary) para aplicativos com janelas ou DALi para gráficos 3D.

// Aplicativo nativo Tizen em C++ com 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) {
    // Criando uma janela 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 da janela
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — contêiner padrão Tizen para dispositivos vestíveis
    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);

    // Rótulo de texto
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Bem-vindo ao Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Exibindo a janela
    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) {
    // Manipulador de aquisição de recursos do aplicativo
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Chamado quando o aplicativo é criado
    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);
}

O aplicativo nativo Tizen Hello World usa EFL (Enlightenment Foundation Libraries) para a UI. ui_app_main é o ponto de entrada do Tizen que aceita callbacks do ciclo de vida. efl_add cria objetos de UI através da hierarquia Win → Conformant → Label. A UI do EFL é baseada no modelo composto Edje — as descrições de temas são escritas em arquivos .edc e compiladas em .edj.

Manifesto Tizen (tizen-manifest.xml)

O arquivo tizen-manifest.xml é a configuração do aplicativo nativo. Ele especifica id (identificador único no formato de domínio reverso), package (nome do pacote), version, label (nome exibido), author e description. Privilégios declaram acesso à API: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Sem especificar um privilégio, chamar a API correspondente resultará em um erro SECURITY_ERR.

Aplicativos web Tizen em HTML5 e JavaScript

Aplicativos web Tizen são aplicativos HTML5 empacotados no formato .wgt (Widget W3C). O desenvolvimento é idêntico à criação de um site comum, mas com acesso adicional ao Tizen Device API através do objeto global tizen. Os aplicativos web são executados em seu próprio processo Web Runtime (WRT), baseado no mecanismo WebKit (Tizen 2.x-4.x) ou Chromium (Tizen 5.5+).

Estrutura do aplicativo web

Um aplicativo web contém index.html (ponto de entrada), config.xml (Configuração de Widget W3C), CSS, JavaScript e imagens. O arquivo config.xml é semelhante ao manifest.webapp no KaiOS: campos obrigatórios incluem widget (id, version, height/width para relógios), name, description e author. Permissões para Device API são especificadas através do elemento tizen:privilege. A seção CSP (Política de Segurança de Conteúdo) restringe fontes de scripts.

// config.xml para aplicativo 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>Monitor de pulso</name>
    <description>Medição do pulso no 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>

O trecho mínimo de config.xml demonstra elementos-chave: widget com id e versão, tizen:application com perfil wearable para telas redondas de relógio, tizen:privilege para healthinfo e sensor API, e uma Política de Segurança de Conteúdo que limita o carregamento de conteúdo apenas ao pacote do aplicativo.

// Aplicativo web Tizen Watch: monitoramento de frequência cardíaca
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Verificação de suporte do sensor HRM
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('Sensor HRM não encontrado');
            }

            // Obtendo acesso ao sensor de frequência cardíaca
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('Sensor HRM inicializado');
        } catch (err) {
            console.error('Erro de inicialização:', err.message);
        }
    },

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

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

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

    updateDisplay(heartRate) {
        // Visualização da frequência cardíaca em tela redonda 360x360
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Indicador circular de frequência 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();
    });
});

O aplicativo HeartRateMonitor usa a Tizen Sensor API para acessar o sensor HRM do Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') obtém o sensor de frequência cardíaca, startSensor inicia as medições com intervalo de 1 segundo. Um canvas de 360×360 desenha um indicador circular — um paradigma típico de UI para telas redondas de relógio Tizen.

Desenvolvimento para Tizen Watch: Circle UI e Rotary

Tizen Watch tem características únicas de UI: uma tela redonda (360×360 pixels no Galaxy Watch), um bisel físico (rotary bezel) para navegação e três botões físicos: Home, Back e Custom. O desenvolvedor deve adaptar a interface para uma área redonda — elementos nos cantos podem ser cortados. Circle UI é uma biblioteca da Samsung com componentes prontos para telas redondas.

Rotary Bezel

Rotary Bezel — um anel físico ao redor da tela do Galaxy Watch que gira para navegar por listas, ajustar volume e aplicar zoom. No Tizen, o evento de rotação é tratado através de rotarydetector ou um sinal edje do EFL. Cada entalhe do bisel gera um evento com um ângulo de rotação (0-360 graus). Aplicativos web tratam o bisel através da API rotarydetector: tizen.rotarydetector.

// Manipulação do Rotary Bezel no Tizen Watch
class RotaryNavigation {
    constructor() {
        this.currentAngle = 0;
        this.sections = document.querySelectorAll('.rotary-section');
        this.currentSection = 0;
        this.init();
    }

    init() {
        // Inscrição em eventos de rotação do bisel
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — ângulo atual (0-360)
            // event.direction — 'cw' (horário) ou 'ccw' (anti-horário)
            this.handleRotation(event);
        });

        // Ativação do rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // mudança de ângulo
        this.currentAngle += delta;

        // Determinação de direção e movimento
        if (delta > 0) {
            // Rotação horária — próximo elemento
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Rotação anti-horária — 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();
    }
}

// Inicialização ao carregar o aplicativo
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

A classe RotaryNavigation se inscreve em eventos rotarydetector através de tizen.rotarydetector.addEventListener. Quando o bisel é girado, a direção (cw/ccw) e o delta do ângulo são calculados. A seção atual é destacada com a classe active. rotarydetector.start() é obrigatório — sem ele, eventos não são gerados. destroy() cancela a inscrição e para o detector para evitar vazamentos de memória.

Recursos de UI para relógios

A interface do Tizen Watch usa componentes: RotarySelector (lista circular controlada pelo bisel), CircularList (lista com rolagem circular), RadialMenu (menu radial com ícones dispostos em círculo), EdgePanel (painel que desliza da borda da tela) e CircleProgressBar (indicador de progresso circular). Todos os componentes são otimizados para resolução 360×360 e consideram a ausência de cantos na tela. O tamanho mínimo dos alvos de toque é de 48 pixels.

Desenvolvimento para Tizen TV: aplicativos para Smart TV

Tizen TV — uma plataforma para Samsung Smart TV com seu próprio SDK e emulador. Os aplicativos de TV são divididos em dois tipos: aplicativos web (HTML5/JS) e aplicativos nativos (C/C++). Aplicativos web para TV são mais rápidos e fáceis de desenvolver, mas os nativos oferecem melhor desempenho para vídeo e jogos. O Tizen TV usa um controle remoto com D-pad para navegação.

AVPlay API para vídeo

AVPlay API — a API chave do Tizen TV para reprodução de vídeo. Suporta os formatos H.264, H.265 (HEVC), VP9, AV1. Resolução de até 8K em TVs de 2024+. A AVPlay API fornece decodificação por hardware, HDR10+, Dolby Atmos, legendas e múltiplas faixas de áudio. Controle através de play(), pause(), stop(), seekTo(position), setDisplayRect(). O fluxo pode ser um arquivo local ou uma URL HLS/DASH.

// Player de vídeo para Tizen TV com AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Verificação de disponibilidade do AVPlay
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('API AVPlay indisponível');
            }

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

            // Configuração de exibição em tela cheia na TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Configuração de áudio (Dolby Atmos, se compatível)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Vídeo pronto para reprodução');
                },
                (error) => {
                    console.error('Erro de preparação:', error);
                }
            );
        } catch (err) {
            console.error('Erro de inicialização:', 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');

A classe TizenVideoPlayer demonstra o trabalho com a AVPlay API. webapis.avplay.open() abre um fluxo de mídia (local ou HLS/DASH). setDisplayRect define a área de renderização — na TV geralmente é tela cheia em 3840×2160. prepareAsync é uma preparação assíncrona com callbacks. AVPlay suporta taxa de bits adaptativa via ADAPTIVE_INFO e legendas via propriedade SUBTITLE.

Galaxy Store e publicação de aplicativos

Samsung Galaxy Store — a loja oficial de aplicativos para Tizen (relógios, TVs, IoT). O registro de desenvolvedor é gratuito através do programa Samsung Developers. Os desenvolvedores enviam aplicativos no formato .tpk (nativo) ou .wgt (web), assinados com um certificado Samsung. A moderação leva de 2 a 5 dias úteis. O Galaxy Store está disponível em 190 países.

Assinatura de aplicativos

O Tizen exige uma assinatura digital para aplicativos usando um certificado Samsung. Processo: gerar um Certificado de Autor através do Samsung Certificate Manager, criar um Certificado de Distribuidor para a loja, assinar o pacote via Tizen Studio (Build Signed Package). O certificado está vinculado à conta do desenvolvedor. Sem assinatura, o aplicativo só pode ser instalado em dispositivos de desenvolvimento com o Modo Desenvolvedor ativado.

Modelo de monetização

O Galaxy Store suporta aplicativos pagos (comissão de 30% nos primeiros $10.000, depois 25%), assinaturas (25%), publicidade através do Samsung Ads e compras no aplicativo através do Samsung IAP. Para aplicativos de TV, o modelo Smart TV Premium Channels está disponível. O preço mínimo é $0,99. Os pagamentos são feitos mensalmente ao atingir o limite de $100.