Tizen: Samsung Watch 및 Smart TV 개발의 본질

// EFL UI를 사용한 C++ Tizen 네이티브 애플리케이션
#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) {
    // Tizen 창 만들기
    ad->win = efl_add(EFL_UI_WIN_CLASS, nullptr,
                      efl_ui_win_typename_set(efl_add(EFL_UI_WIN_CLASS, nullptr), "tizen-hello"));

    // 창 제목
    efl_text_set(ad->win, "Hello Tizen");
    efl_event_callback_add(ad->win, EFL_UI_WIN_EVENT_DELETE_REQUEST, win_delete_cb, ad);

    // Conformant — 웨어러블 기기용 표준 Tizen 컨테이너
    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);

    // 텍스트 레이블
    ad->label = efl_add(EFL_UI_LABEL_CLASS, ad->conform);
    efl_text_set(ad->label, "Tizen에 오신 것을 환영합니다!");
    efl_content_set(ad->conform, ad->label);

    // 창 표시
    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) {
    // 애플리케이션 리소스 획득 핸들러
    appdata_s *ad = (appdata_s *)data;
    create_base_gui(ad);
}

static bool
app_create_cb(void *data) {
    // 애플리케이션 생성 시 호출됨
    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);
}

// Tizen Watch 웹 애플리케이션용 config.xml
<?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>심박수 측정기</name>
    <description>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>

// Tizen Watch 웹 애플리케이션: 심박수 모니터링
const HeartRateMonitor = {
    hrSensor: null,
    isMonitoring: false,

    async init() {
        try {
            // HRM 센서 지원 확인
            const sensors = tizen.sensorservice.getAvailableSensors();
            if (!sensors.includes('HRM')) {
                throw new Error('HRM 센서를 찾을 수 없습니다');
            }

            // 심박수 센서 액세스 권한 얻기
            this.hrSensor = tizen.sensorservice.getDefaultSensor('HRM');
            console.log('HRM 센서가 초기화되었습니다');
        } catch (err) {
            console.error('초기화 오류:', err.message);
        }
    },

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

        this.isMonitoring = true;
        this.hrSensor.startSensor({
            interval: 1000,  // 매초 측정
            callback: {
                onsuccess: (data) => {
                    const heartRate = data.heartRate;
                    document.getElementById('hr-value').textContent = heartRate;
                    this.updateDisplay(heartRate);
                },
                onerror: (err) => {
                    console.error('센서 오류:', err.message);
                }
            }
        });
    },

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

    updateDisplay(heartRate) {
        // 360x360 원형 화면에 심박수 시각화
        const canvas = document.getElementById('hr-canvas');
        const ctx = canvas.getContext('2d');
        ctx.clearRect(0, 0, 360, 360);

        // 원형 심박수 표시기
        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();
    });
});

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

    init() {
        // 베젤 회전 이벤트 구독
        const detector = tizen.rotarydetector;

        detector.addEventListener('rotarydetector', (event) => {
            // event.angle — 현재 각도(0-360)
            // event.direction — 'cw'(시계 방향) 또는 'ccw'(반시계 방향)
            this.handleRotation(event);
        });

        // rotarydetector 활성화
        detector.start();
    }

    handleRotation(event) {
        const delta = event.delta;  // 각도 변경
        this.currentAngle += delta;

        // 방향 및 이동 결정
        if (delta > 0) {
            // 시계 방향 회전 — 다음 요소
            this.currentSection = Math.min(this.currentSection + 1, this.sections.length - 1);
        } else {
            // 반시계 방향 회전 — 이전 요소
            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();
    }
}

// 애플리케이션 로드 시 초기화
document.addEventListener('tizen-rotary-ready', () => {
    const nav = new RotaryNavigation();
});

// AVPlay API를 사용한 Tizen TV용 비디오 플레이어
class TizenVideoPlayer {
    constructor(videoElementId) {
        this.videoElement = document.getElementById(videoElementId);
        this.avplay = null;
        this.isReady = false;
    }

    async init(url) {
        try {
            // AVPlay 가용성 확인
            if (typeof webapis === 'undefined' ||
                !webapis.avplay) {
                throw new Error('AVPlay API를 사용할 수 없습니다');
            }

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

            // TV 전체 화면으로 표시 설정
            this.avplay.setDisplayRect(0, 0, 3840, 2160);
            this.avplay.setDisplayMethod(webapis.avplay.AVPLAY_DISPLAY_METHOD_PLAYER);

            // 오디오 구성(Dolby Atmos, 지원되는 경우)
            this.avplay.setStreamingProperty('ADAPTIVE_INFO', JSON.stringify({
                width: 3840,
                height: 2160,
                bitrate: 25000000
            }));

            this.avplay.prepareAsync(
                () => {
                    this.isReady = true;
                    console.log('영상 재생 준비 완료');
                },
                (error) => {
                    console.error('준비 오류:', error);
                }
            );
        } catch (err) {
            console.error('초기화 오류:', 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'
        }));
    }
}

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