Tizen: essensen av utveckling för Samsung Watch och Smart TV

Vad är Tizen?

Tizen är ett operativsystem med öppen källkod som övervakas av Samsung och Linux Foundation. Den första kommersiella utgåvan, Tizen 1.0, släpptes 2012. Systemet är baserat på Linux-kärnan och använder en egen ramverksarkitektur för olika enhetstyper: Tizen Mobile (smartphones — projektet stängdes 2017), Tizen Watch (klockor), Tizen TV (televisionsapparater) och Tizen IoT (smarta hem).

Sedan 2021 använder Samsung Tizen främst i bärbara enheter och televisionsapparater. Alla Galaxy Watch-smartklockor före 2021 körde Tizen (Galaxy Watch, Watch Active, Watch 3). Från och med Galaxy Watch 4 bytte Samsung till Wear OS med One UI Watch, men Tizen fortsätter att stödjas för befintliga enheter och TV-apparater. Enligt Samsung (Tizen Ecosystem Report, 2025) har över 180 miljoner TV-apparater världen över Tizen TV installerat.

En viktig egenskap hos Tizen är stödet för två utvecklingsparadigm: inbyggda applikationer (C/C++) med maximal prestanda och webbapplikationer (HTML5, CSS, JavaScript) för snabb utveckling. Båda typerna har tillgång till Tizen Device API — omslag för att arbeta med Bluetooth, NFC, Wi-Fi, sensorer, kamera och multimedia.

Tizen-versionshistorik

Tizen 2.3 (2014) — första stabila versionen för Samsung Z-smartphones. Tizen 3.0 (2017) — förbättrad multitasking, Vulkan-stöd, 64-bitarsarkitektur. Tizen 4.0 (2018) — omdesignade ramverk, stöd för AI-acceleration på NPU. Tizen 5.5 (2020) — Tizen TV med AVPlay 2.0, WebAssembly, förbättrad rendering. Tizen 6.0 (2022) — stöd för ML-inferens på enheten, Matter-protokoll för IoT.

Tizen-arkitektur: Linux-kärna och ramverk

Tizen-arkitekturen är byggd på en modulär princip med en flerskiktad struktur. Det lägsta skiktet är Linux-kärnan med patchningar för energieffektivitet och realtidsuppgifter (RT_PREEMPT för TV och ljud). Ovanför kärnan finns Hardware Abstraction Layer (HAL), som ger enhetlig åtkomst till drivrutiner för kamera, sensorer, Bluetooth, Wi-Fi, NFC och display (via DirectFB eller Wayland).

Core Framework-skiktet

Core Framework-skiktet omfattar Application Framework (hantering av applikationslivscykler), UI Framework (EFL — Enlightenment Foundation Libraries för gränssnitt, DALi — 3D-motor för spel och animationer), Multimedia Framework (kamera, ljud, video via GStreamer och MediaCodec), Network Framework (Bluetooth, Wi-Fi, NFC, HTTP, WebSocket) och Security Framework (SELinux, Smack, Tizen-behörighetssystem).

Service-skiktet

Service-skiktet tillhandahåller systemtjänster: Application Manager (start, stopp, multitasking), Package Manager (installation/avinstallation av appar, format .tpk och .wgt), Location Manager (GPS, Wi-Fi-positionering, Geofence), Sensor Manager (accelerometer, gyroskop, barometer, pulsmätare), Context Manager (igenkänning av användaraktivitet: gång, löpning, sömn).

Device API för webbapplikationer

Tizen tillhandahåller Device API — JavaScript-gränssnitt för webbapplikationer som ger tillgång till samma funktioner som inbyggda API:er. API:erna är uppdelade i moduler: 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.

Inbyggda Tizen-applikationer i C/C++

Inbyggda Tizen-applikationer kompileras till en körbar fil i formatet .tpk (Tizen Package Kit). Huvudspråket är C++11/14 med GCC- eller Clang-kompilatorn. Utveckling sker i Tizen Studio eller Visual Studio Code med Tizen-tillägget. Inbyggda applikationer har direkt åtkomst till EFL, DALi, GStreamer och alla system-API:er utan mellanhänder, vilket garanterar maximal prestanda.

Struktur för en inbyggd applikation

En inbyggd applikation innehåller en fil tizen-manifest.xml (liknande AndroidManifest.xml), ett eller flera delade bibliotek (.so) och resurser (bilder, typsnitt, lokaliseringar). Livscykeln hanteras via app_event_cb: APP_EVENT_CREATE, APP_EVENT_RESUME, APP_EVENT_PAUSE, APP_EVENT_DESTROY. Gränssnittet byggs via EFL (Edje + Elementary) för fönsterapplikationer eller DALi för 3D-grafik.

// Inbyggd Tizen-applikation i C++ med EFL-gränssnitt
#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) {
    // Skapa ett Tizen-fönster
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // Fönstrets titel
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — standard Tizen-behållare för bärbara enheter
    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);

    // Textetikett
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Välkommen till Tizen!");
    efl_content_set(ad->conform, ad->label);

    // Visa fönster
    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) {
    // Hanterare för applikationsresursanskaffning
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // Anropas när applikationen skapas
    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);
}

Den inbyggda Tizen Hello World-applikationen använder EFL (Enlightenment Foundation Libraries) för gränssnittet. ui_app_main är Tizens startpunkt som accepterar livscykelåteranrop. efl_add skapar gränssnittsobjekt genom hierarkin Win → Conformant → Label. EFL-gränssnittet är baserat på Edje-kompositmodellen — temabeskrivningar skrivs i .edc-filer och kompileras till .edj.

Tizen-manifest (tizen-manifest.xml)

Filen tizen-manifest.xml är konfigurationen för den inbyggda applikationen. Den anger id (unik identifierare i omvänt domänformat), package (paketnamn), version, label (visningsnamn), author och description. Behörigheter deklarerar API-åtkomst: http://tizen.org/privilege/bluetooth, http://tizen.org/privilege/location, http://tizen.org/privilege/camera. Utan att ange en behörighet kommer anrop till motsvarande API att resultera i ett SECURITY_ERR-fel.

Tizen-webbapplikationer i HTML5 och JavaScript

Tizen-webbapplikationer är HTML5-applikationer paketerade i formatet .wgt (W3C Widget). Utvecklingen är identisk med att skapa en vanlig webbplats, men med ytterligare åtkomst till Tizen Device API via det globala tizen-objektet. Webbapplikationer körs i en egen Web Runtime (WRT)-process, baserad på WebKit-motorn (Tizen 2.x-4.x) eller Chromium (Tizen 5.5+).

Struktur för en webbapplikation

En webbapplikation innehåller index.html (startpunkt), config.xml (W3C Widget-konfiguration), CSS, JavaScript och bilder. Filen config.xml liknar manifest.webapp i KaiOS: obligatoriska fält inkluderar widget (id, version, height/width för klockor), name, description och author. Behörigheter för Device API anges via elementet tizen:privilege. CSP-sektionen (Content Security Policy) begränsar skriptkällor.

// config.xml för Tizen Watch-webbapplikation
<?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>Pulsmätare</name>
    <description>Pulsmätning på 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>

Det minimala config.xml-utdraget visar nyckelelement: widget med id och version, tizen:application med en wearable-profil för runda klockskärmar, tizen:privilege för healthinfo och sensor API, och en Content Security Policy som begränsar inläsning av innehåll till endast applikationspaketet.

// Tizen Watch-webbapplikation: pulsmätning
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // Kontroll av HRM-sensorstöd
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('HRM-sensorn hittades inte');
            }

            // Få åtkomst till pulssensorn
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('HRM-sensorn är initierad');
        } catch (err) {
            console.error('Initieringsfel:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // mätning varje sekund
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('Sensorfel:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // Visualisering av puls på rund 360x360-skärm
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // Cirkulär pulsindikator
        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();
    });
});

Applikationen HeartRateMonitor använder Tizen Sensor API för åtkomst till HRM-sensorn i Galaxy Watch. tizen.sensorservice.getDefaultSensor('HRM') hämtar pulssensorn, startSensor startar mätningar med 1 sekunds intervall. En 360×360-canvas ritar en cirkulär indikator — ett typiskt gränssnittsparadigm för runda Tizen-klockskärmar.

Tizen Watch-utveckling: Circle UI och Rotary

Tizen Watch har unika gränssnittsegenskaper: en rund skärm (360×360 pixlar på Galaxy Watch), en fysisk ring (rotary bezel) för navigering och tre hårdvaruknappar: Home, Back och Custom. Utvecklaren måste anpassa gränssnittet till ett runt område — hörnelement kan kapas. Circle UI är ett Samsung-bibliotek med färdiga komponenter för runda skärmar.

Rotary Bezel

Rotary Bezel — en fysisk ring runt Galaxy Watch-skärmen som roterar för navigering i listor, volymjustering och zoom. I Tizen hanteras rotationshändelsen via rotarydetector eller en EFL-edje-signal. Varje hack på ringen genererar en händelse med en rotationsvinkel (0-360 grader). Webbapplikationer hanterar ringen via rotarydetector-API:et: tizen.rotarydetector.

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

    init() {
        // Prenumerera på ringrotationshändelser
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — aktuell vinkel (0-360)
            // event.direction — 'cw' (medurs) eller 'ccw' (moturs)
            this.handleRotation(event);
        });

        // Aktivering av rotarydetector
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // vinkeländring
        this.currentAngle += delta;

        // Bestämning av riktning och rörelse
        if (delta > 0) {
            // Medurs rotation — nästa element
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // Moturs rotation — föregående element
            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();
    }
}

// Initialisering vid applikationsladdning
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

Klassen RotaryNavigation prenumererar på rotarydetector-händelser via tizen.rotarydetector.addEventListener. När ringen vrids beräknas riktningen (cw/ccw) och vinkeldeltat. Den aktuella sektionen markeras med klassen active. rotarydetector.start() är obligatorisk — utan den genereras inga händelser. destroy() avslutar prenumerationen och stoppar detektorn för att förhindra minnesläckor.

Gränssnittsfunktioner för klockor

Tizen Watch-gränssnittet använder komponenter: RotarySelector(cirkulär lista styrd av ringen), CircularList(lista med cirkulär rullning), RadialMenu(radiell meny med ikoner arrangerade i en cirkel), EdgePanel(panel som glider in från skärmkanten) och CircleProgressBar(cirkulär förloppsindikator). Alla komponenter är optimerade för 360×360-upplösning och tar hänsyn till avsaknaden av skärmhörn. Minsta tryckmålstorlek är 48 pixlar.

Tizen TV-utveckling: appar för Smart TV

Tizen TV — en plattform för Samsung Smart TV med eget SDK och emulator. TV-applikationer delas in i två typer: webbapplikationer (HTML5/JS) och inbyggda applikationer (C/C++). Webbapplikationer för TV är snabbare och enklare att utveckla, men inbyggda ger bättre prestanda för video och spel. Tizen TV använder en fjärrkontroll med D-pad för navigering.

AVPlay API för video

AVPlay API — det viktigaste Tizen TV-API:et för videouppspelning. Stöder formaten H.264, H.265 (HEVC), VP9, AV1. Upplösning upp till 8K på TV-apparater från 2024+. AVPlay API tillhandahåller hårdvaruavkodning, HDR10+, Dolby Atmos, undertexter och flera ljudspår. Kontroll via play(), pause(), stop(), seekTo(position), setDisplayRect(). Strömmen kan vara en lokal fil eller en HLS/DASH-URL.

// Videospelare för Tizen TV med AVPlay API
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // Kontroll av AVPlay-tillgänglighet
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API är inte tillgängligt');
            }

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

            // Ställa in visning på helskärm TV
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // Ljudkonfiguration (Dolby Atmos, om det stöds)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('Videon är redo att spelas upp');
                },
                (error) => {
                    console.error('Förberedelsefel:', error);
                }
            );
        } catch (err) {
            console.error('Initieringsfel:', 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'
        }));
    }
}

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

Klassen TizenVideoPlayer demonstrerar arbete med AVPlay API. webapis.avplay.open() öppnar en mediaström (lokal eller HLS/DASH). setDisplayRect ställer in renderingsområdet — på TV är det vanligtvis helskärm vid 3840×2160. prepareAsync är asynkron förberedelse med återanrop. AVPlay stöder adaptiv bithastighet via ADAPTIVE_INFO och undertexter via egenskapen SUBTITLE.

Galaxy Store och publicering av applikationer

Samsung Galaxy Store — den officiella appbutiken för Tizen (klockor, TV-apparater, IoT). Utvecklarregistrering är gratis via Samsung Developers-programmet. Utvecklare laddar upp applikationer i formatet .tpk (inbyggd) eller .wgt (webb), signerade med ett Samsung-certifikat. Moderering tar 2-5 arbetsdagar. Galaxy Store finns i 190 länder.

Signering av applikationer

Tizen kräver en digital signatur för applikationer med ett Samsung-certifikat. Process: generera ett författarcertifikat via Samsung Certificate Manager, skapa ett distributörscertifikat för butiken, signera paketet via Tizen Studio (Build Signed Package). Certifikatet är kopplat till utvecklarkontot. Utan signatur kan applikationen endast installeras på utvecklingsenheter med utvecklarläget aktiverat.

Intäktsmodell

Galaxy Store stöder betalda applikationer (30% provision på de första 10 000 $, därefter 25%), prenumerationer (25%), annonsering via Samsung Ads och köp i appen via Samsung IAP. För TV-applikationer finns modellen Smart TV Premium Channels. Minimipriset är 0,99 $. Utbetalningar görs månadsvis när tröskeln på 100 $ uppnås.