@quicktvui/web-renderer 1.0.0

package/src/modules/ESIJKAudioPlayerModule.js

@@ -0,0 +1,477 @@
+// ESIJKAudioPlayerModule - Web adapter for ES IJK Audio Player
+// Uses HTML5 Audio API to implement audio playback
+
+import { resolveAddon, createModuleInit } from '../core/moduleUtils'
+
+// Player states (matching native ESPlayerState)
+const ESPlayerState = {
+  ES_PLAYER_STATE_IDLE: 0,
+  ES_PLAYER_STATE_PREPARING: 1,
+  ES_PLAYER_STATE_PREPARED: 2,
+  ES_PLAYER_STATE_BUFFER_START: 3,
+  ES_PLAYER_STATE_BUFFER_END: 4,
+  ES_PLAYER_STATE_PLAYING: 5,
+  ES_PLAYER_STATE_SEEK_START: 6,
+  ES_PLAYER_STATE_SEEK_COMPLETED: 7,
+  ES_PLAYER_STATE_PAUSED: 8,
+  ES_PLAYER_STATE_RESUMED: 9,
+  ES_PLAYER_STATE_BEFORE_STOP: 10,
+  ES_PLAYER_STATE_STOP: 11,
+  ES_PLAYER_STATE_PLAYBACK_COMPLETED: 12,
+  ES_PLAYER_STATE_ERROR: 13,
+  ES_PLAYER_STATE_VIDEO_SIZE_CHANGED: 14,
+  ES_PLAYER_STATE_PLAYER_VIEW_CHANGED: 15,
+  ES_PLAYER_STATE_AD_START: 16,
+  ES_PLAYER_STATE_AD_END: 17,
+  ES_PLAYER_STATE_AD_SKIP: 18,
+  ES_PLAYER_STATE_AD_PAUSED: 19,
+  ES_PLAYER_STATE_AUTHORIZED: 20,
+  ES_PLAYER_STATE_SET_PLAY_RATE_SUCCESS: 21,
+  ES_PLAYER_STATE_SET_PLAY_RATE_ERROR: 22,
+  ES_PLAYER_STATE_AD_RESUMED: 23,
+  ES_PLAYER_STATE_AD_LOADED: 24,
+  ES_PLAYER_STATE_AD_TIME: 25,
+  ES_PLAYER_STATE_PLAYER_INITIALIZED: 26,
+  ES_PLAYER_STATE_TIMED_TEXT_CHANGED: 27,
+  ES_PLAYER_STATE_PLAYER_CLICKABLE: 28,
+  ES_PLAYER_STATE_INITIALIZE_SUCCESS: 29,
+  ES_PLAYER_STATE_INITIALIZE_ERROR: 30,
+}
+
+// Get EventBus lazily
+let _eventBus = null
+function getEventBus() {
+  if (!_eventBus) {
+    try {
+      const esVue = require('@extscreen/es3-vue')
+      if (esVue && esVue.EventBus) {
+        _eventBus = esVue.EventBus
+      }
+    } catch (e) {
+      console.warn('[ESIJKAudioPlayerModule] EventBus not available:', e.message)
+    }
+  }
+  return _eventBus
+}
+
+// Dispatch event to EventBus
+function dispatchEvent(eventName, data) {
+  const eventBus = getEventBus()
+  if (eventBus && eventBus.$emit) {
+    eventBus.$emit(eventName, data)
+  }
+  // Also dispatch custom event for global listeners
+  if (typeof window !== 'undefined') {
+    window.dispatchEvent(new CustomEvent(eventName, { detail: data }))
+  }
+}
+
+// Audio instance manager
+class AudioPlayerManager {
+  constructor() {
+    this.instances = new Map()
+    this.defaultPlayRate = 1.0
+    this.defaultVolume = 1.0
+  }
+
+  // Get or create audio instance with event binding
+  getInstance(id) {
+    if (!this.instances.has(id)) {
+      const audio = new Audio()
+      audio.defaultPlaybackRate = this.defaultPlayRate
+      audio.volume = this.defaultVolume
+      this._bindAudioEvents(audio, id)
+      this.instances.set(id, audio)
+    }
+    return this.instances.get(id)
+  }
+
+  _bindAudioEvents(audio, id) {
+    // Track if we've sent PREPARED for current source
+    let hasPrepared = false
+    let currentState = ESPlayerState.ES_PLAYER_STATE_IDLE
+
+    // Play event
+    audio.addEventListener('play', () => {
+      if (currentState !== ESPlayerState.ES_PLAYER_STATE_PLAYING) {
+        currentState = ESPlayerState.ES_PLAYER_STATE_PLAYING
+        dispatchEvent('onESAudioPlayerStatusChanged', {
+          playerStatus: ESPlayerState.ES_PLAYER_STATE_PLAYING,
+          playerState: ESPlayerState.ES_PLAYER_STATE_PLAYING,
+        })
+      }
+    })
+
+    // Playing event (after buffering) - don't send PREPARED again!
+    audio.addEventListener('playing', () => {
+      if (currentState !== ESPlayerState.ES_PLAYER_STATE_PLAYING) {
+        currentState = ESPlayerState.ES_PLAYER_STATE_PLAYING
+        dispatchEvent('onESAudioPlayerStatusChanged', {
+          playerStatus: ESPlayerState.ES_PLAYER_STATE_PLAYING,
+          playerState: ESPlayerState.ES_PLAYER_STATE_PLAYING,
+        })
+      }
+    })
+
+    // Pause event
+    audio.addEventListener('pause', () => {
+      currentState = ESPlayerState.ES_PLAYER_STATE_PAUSED
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_PAUSED,
+        playerState: ESPlayerState.ES_PLAYER_STATE_PAUSED,
+      })
+    })
+
+    // Ended event
+    audio.addEventListener('ended', () => {
+      currentState = ESPlayerState.ES_PLAYER_STATE_PLAYBACK_COMPLETED
+      hasPrepared = true // Prevent canplay from sending PREPARED again
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_PLAYBACK_COMPLETED,
+        playerState: ESPlayerState.ES_PLAYER_STATE_PLAYBACK_COMPLETED,
+      })
+    })
+
+    // Error event
+    audio.addEventListener('error', (e) => {
+      currentState = ESPlayerState.ES_PLAYER_STATE_ERROR
+      dispatchEvent('onESAudioPlayerError', {
+        errorCode: e.target.error?.code || -1,
+        errorMessage: e.target.error?.message || 'Audio error',
+      })
+    })
+
+    // Load start (preparing)
+    audio.addEventListener('loadstart', () => {
+      hasPrepared = false
+      currentState = ESPlayerState.ES_PLAYER_STATE_PREPARING
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_PREPARING,
+        playerState: ESPlayerState.ES_PLAYER_STATE_PREPARING,
+      })
+    })
+
+    // Can play (prepared) - only send once per source
+    audio.addEventListener('canplay', () => {
+      if (!hasPrepared) {
+        hasPrepared = true
+        currentState = ESPlayerState.ES_PLAYER_STATE_PREPARED
+        dispatchEvent('onESAudioPlayerStatusChanged', {
+          playerStatus: ESPlayerState.ES_PLAYER_STATE_PREPARED,
+          playerState: ESPlayerState.ES_PLAYER_STATE_PREPARED,
+        })
+      }
+    })
+
+    // Waiting (buffering)
+    audio.addEventListener('waiting', () => {
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_BUFFER_START,
+        playerState: ESPlayerState.ES_PLAYER_STATE_BUFFER_START,
+      })
+    })
+
+    // Can play through (buffer end)
+    audio.addEventListener('canplaythrough', () => {
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_BUFFER_END,
+        playerState: ESPlayerState.ES_PLAYER_STATE_BUFFER_END,
+      })
+    })
+
+    // Duration change
+    audio.addEventListener('durationchange', () => {
+      if (audio.duration && !isNaN(audio.duration)) {
+        dispatchEvent('onESAudioPlayerInfo', {
+          what: 1, // MEDIA_INFO_DURATION
+          extra: Math.floor(audio.duration * 1000),
+        })
+      }
+    })
+
+    // Rate change
+    audio.addEventListener('ratechange', () => {
+      dispatchEvent('onESAudioPlayRateChanged', {
+        playRate: audio.playbackRate,
+      })
+    })
+
+    // Seeking
+    audio.addEventListener('seeking', () => {
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_SEEK_START,
+        playerState: ESPlayerState.ES_PLAYER_STATE_SEEK_START,
+      })
+    })
+
+    // Seeked
+    audio.addEventListener('seeked', () => {
+      dispatchEvent('onESAudioPlayerStatusChanged', {
+        playerStatus: ESPlayerState.ES_PLAYER_STATE_SEEK_COMPLETED,
+        playerState: ESPlayerState.ES_PLAYER_STATE_SEEK_COMPLETED,
+      })
+    })
+
+    // Volume change
+    audio.addEventListener('volumechange', () => {
+      dispatchEvent('onESAudioPlayerInfo', {
+        what: 2, // MEDIA_INFO_VOLUME_CHANGED
+        extra: Math.floor(audio.volume * 100),
+      })
+    })
+  }
+
+  // Remove audio instance
+  removeInstance(id) {
+    const audio = this.instances.get(id)
+    if (audio) {
+      audio.pause()
+      audio.src = ''
+      this.instances.delete(id)
+    }
+  }
+
+  // Clear all instances
+  clearAll() {
+    this.instances.forEach((audio, id) => {
+      audio.pause()
+      audio.src = ''
+    })
+    this.instances.clear()
+  }
+}
+
+const audioManager = new AudioPlayerManager()
+
+export class ESIJKAudioPlayerModule {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+  }
+
+  async init(...args) {
+    // Send initialized event
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_PLAYER_INITIALIZED,
+      playerState: ESPlayerState.ES_PLAYER_STATE_PLAYER_INITIALIZED,
+    })
+    // Send init success
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_INITIALIZE_SUCCESS,
+      playerState: ESPlayerState.ES_PLAYER_STATE_INITIALIZE_SUCCESS,
+    })
+    return createModuleInit(args)
+  }
+
+  initMediaPlayer(...args) {
+    // Send initialized event
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_PLAYER_INITIALIZED,
+      playerState: ESPlayerState.ES_PLAYER_STATE_PLAYER_INITIALIZED,
+    })
+    // Send init success
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_INITIALIZE_SUCCESS,
+      playerState: ESPlayerState.ES_PLAYER_STATE_INITIALIZE_SUCCESS,
+    })
+    return resolveAddon(args, null)
+  }
+
+  play(id, ...params) {
+    console.log('[ESIJKAudioPlayerModule] play called with id:', id, 'params:', params)
+    const audio = audioManager.getInstance(id)
+    const args = params || []
+
+    // Parse play parameters
+    // Can be:
+    // 1. URL string: play(-1, 'https://...')
+    // 2. URL in array: play(-1, ['https://...'])
+    // 3. Object: play(-1, { url: '...', uri: '...' })
+    let url = ''
+    let autoplay = true
+
+    if (args.length > 0) {
+      const firstArg = args[0]
+
+      // Check if it's a string (direct URL)
+      if (typeof firstArg === 'string') {
+        url = firstArg
+      }
+      // Check if it's an array with URL string
+      else if (Array.isArray(firstArg) && typeof firstArg[0] === 'string') {
+        url = firstArg[0]
+      }
+      // Check if it's an object with url/src/uri
+      else if (typeof firstArg === 'object' && firstArg !== null && !Array.isArray(firstArg)) {
+        url = firstArg.url || firstArg.src || firstArg.uri || ''
+        autoplay = firstArg.autoplay !== false
+      }
+    }
+
+    console.log('[ESIJKAudioPlayerModule] parsed url:', url, 'autoplay:', autoplay)
+
+    if (url) {
+      audio.src = url
+      audio.load()
+    }
+
+    if (autoplay && audio.src) {
+      audio.play().catch((e) => {
+        console.warn('[ESIJKAudioPlayerModule] play error:', e)
+        dispatchEvent('onESAudioPlayerError', {
+          errorCode: -1,
+          errorMessage: e.message || 'Play error',
+        })
+      })
+    }
+    return resolveAddon(args, null)
+  }
+
+  start(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    if (audio.src) {
+      audio.play().catch((e) => {
+        console.warn('[ESIJKAudioPlayerModule] start error:', e)
+      })
+    }
+    return resolveAddon(args, null)
+  }
+
+  pause(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    audio.pause()
+    return resolveAddon(args, null)
+  }
+
+  resume(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    audio.play().catch((e) => {
+      console.warn('[ESIJKAudioPlayerModule] resume error:', e)
+    })
+    // Send resumed event
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_RESUMED,
+      playerState: ESPlayerState.ES_PLAYER_STATE_RESUMED,
+    })
+    return resolveAddon(args, null)
+  }
+
+  seekTo(id, progress, ...args) {
+    const audio = audioManager.getInstance(id)
+    if (audio.duration && progress >= 0) {
+      audio.currentTime = Math.min(progress / 1000, audio.duration) // progress is in ms
+    }
+    return resolveAddon(args, null)
+  }
+
+  stop(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    // Send before stop event
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_BEFORE_STOP,
+      playerState: ESPlayerState.ES_PLAYER_STATE_BEFORE_STOP,
+    })
+    audio.pause()
+    audio.currentTime = 0
+    // Send stopped event
+    dispatchEvent('onESAudioPlayerStatusChanged', {
+      playerStatus: ESPlayerState.ES_PLAYER_STATE_STOP,
+      playerState: ESPlayerState.ES_PLAYER_STATE_STOP,
+    })
+    return resolveAddon(args, null)
+  }
+
+  setPlayRate(id, speed, ...args) {
+    const audio = audioManager.getInstance(id)
+    audio.playbackRate = Number(speed) || 1.0
+    dispatchEvent('onESAudioPlayRateChanged', {
+      playRate: audio.playbackRate,
+    })
+    return resolveAddon(args, null)
+  }
+
+  setVolume(id, volume, ...args) {
+    const audio = audioManager.getInstance(id)
+    audio.volume = Math.max(0, Math.min(1, Number(volume) || 0))
+    return resolveAddon(args, null)
+  }
+
+  setLeftRightVolume(id, leftVolume, rightVolume, ...args) {
+    const audio = audioManager.getInstance(id)
+    // HTML5 Audio doesn't support stereo balance, use average
+    const avgVolume = (Number(leftVolume) + Number(rightVolume)) / 2
+    audio.volume = Math.max(0, Math.min(1, avgVolume || 0))
+    return resolveAddon(args, null)
+  }
+
+  reset(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    audio.pause()
+    audio.currentTime = 0
+    audio.src = ''
+    return resolveAddon(args, null)
+  }
+
+  release(id, ...args) {
+    audioManager.removeInstance(id)
+    return resolveAddon(args, null)
+  }
+
+  async isPlaying(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    const result = !audio.paused && audio.currentTime > 0
+    return resolveAddon(args, result)
+  }
+
+  async isPaused(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    const result = audio.paused
+    return resolveAddon(args, result)
+  }
+
+  async getDuration(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    // Return duration in milliseconds
+    const duration = audio.duration && !isNaN(audio.duration) ? audio.duration * 1000 : -1
+    return resolveAddon(args, duration)
+  }
+
+  async getCurrentPosition(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    // Return position in milliseconds
+    const position = audio.currentTime && !isNaN(audio.currentTime) ? audio.currentTime * 1000 : 0
+    return resolveAddon(args, position)
+  }
+
+  async getBufferPercentage(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    if (audio.buffered.length > 0 && audio.duration > 0) {
+      const bufferedEnd = audio.buffered.end(audio.buffered.length - 1)
+      const percentage = Math.round((bufferedEnd / audio.duration) * 100)
+      return resolveAddon(args, percentage)
+    }
+    return resolveAddon(args, 0)
+  }
+
+  async getCurrentPlayRate(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    return resolveAddon(args, audio.playbackRate || 1.0)
+  }
+
+  async getLeftVolume(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    // HTML5 Audio doesn't support stereo, return same as volume
+    return resolveAddon(args, audio.volume)
+  }
+
+  async getRightVolume(id, ...args) {
+    const audio = audioManager.getInstance(id)
+    // HTML5 Audio doesn't support stereo, return same as volume
+    return resolveAddon(args, audio.volume)
+  }
+
+  destroy() {
+    audioManager.clearAll()
+  }
+}

package/src/modules/ESLocalStorageModule.js

@@ -0,0 +1,100 @@
+import { resolveAddon, createModuleInit } from '../core/moduleUtils'
+
+function getRawStorage() {
+  const g = globalThis
+  return (g && g.__localStorage) || (g && g.localStorage) || null
+}
+
+async function readStorage(key) {
+  const s = getRawStorage()
+  if (!s || !s.getItem) return null
+  const v = s.getItem(key)
+  return v && typeof v.then === 'function' ? await v : v
+}
+
+async function writeStorage(key, value) {
+  const s = getRawStorage()
+  if (!s || !s.setItem) return false
+  const r = s.setItem(key, value)
+  if (r && typeof r.then === 'function') await r
+  return true
+}
+
+export class ESLocalStorageModule {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+    this._name = ''
+  }
+
+  _key(key) {
+    if (!this._name) return key
+    return `${this._name}:${key}`
+  }
+
+  async initSharedPreferences(name, ...args) {
+    this._name = String(name ?? '')
+    return resolveAddon(args, true)
+  }
+
+  async initESSharedPreferences(name, ...args) {
+    this._name = String(name ?? '')
+    return resolveAddon(args, true)
+  }
+
+  async getBoolean(key, defValue, ...args) {
+    const v = await readStorage(this._key(String(key)))
+    if (v === null || v === undefined) return resolveAddon(args, !!defValue)
+    if (v === 'true') return resolveAddon(args, true)
+    if (v === 'false') return resolveAddon(args, false)
+    if (v === '1') return resolveAddon(args, true)
+    if (v === '0') return resolveAddon(args, false)
+    return resolveAddon(args, !!defValue)
+  }
+
+  async putBoolean(key, value, ...args) {
+    const ok = await writeStorage(this._key(String(key)), value ? 'true' : 'false')
+    return resolveAddon(args, ok)
+  }
+
+  async getInt(key, defValue, ...args) {
+    const v = await readStorage(this._key(String(key)))
+    if (v === null || v === undefined || v === '') return resolveAddon(args, Number(defValue) || 0)
+    const n = Number.parseInt(String(v), 10)
+    return resolveAddon(args, Number.isFinite(n) ? n : Number(defValue) || 0)
+  }
+
+  async putInt(key, value, ...args) {
+    const ok = await writeStorage(this._key(String(key)), String(Number(value) | 0))
+    return resolveAddon(args, ok)
+  }
+
+  async getLong(key, defValue, ...args) {
+    const v = await readStorage(this._key(String(key)))
+    if (v === null || v === undefined || v === '') return resolveAddon(args, Number(defValue) || 0)
+    const n = Number.parseInt(String(v), 10)
+    return resolveAddon(args, Number.isFinite(n) ? n : Number(defValue) || 0)
+  }
+
+  async putLong(key, value, ...args) {
+    const ok = await writeStorage(this._key(String(key)), String(Math.trunc(Number(value))))
+    return resolveAddon(args, ok)
+  }
+
+  async getString(key, defValue, ...args) {
+    const v = await readStorage(this._key(String(key)))
+    return resolveAddon(args, v === null || v === undefined ? String(defValue ?? '') : String(v))
+  }
+
+  async putString(key, value, ...args) {
+    const ok = await writeStorage(this._key(String(key)), String(value ?? ''))
+    return resolveAddon(args, ok)
+  }
+
+  async init(...args) {
+    return createModuleInit(args)
+  }
+
+  destroy() {}
+}

package/src/modules/ESLogModule.js

@@ -0,0 +1,65 @@
+// ESLogModule - Web adapter for ES Log Module
+// Uses console API for logging
+
+import { resolveAddon, createModuleInit } from '../core/moduleUtils'
+
+export class ESLogModule {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+    this.enabled = true
+  }
+
+  async init(...args) {
+    return createModuleInit(args)
+  }
+
+  destroy() {}
+
+  v(tag, ...args) {
+    if (!this.enabled) return
+    console.log(`[V][${tag}]`, ...args)
+  }
+
+  d(tag, ...args) {
+    if (!this.enabled) return
+    console.debug(`[D][${tag}]`, ...args)
+  }
+
+  i(tag, ...args) {
+    if (!this.enabled) return
+    console.info(`[I][${tag}]`, ...args)
+  }
+
+  w(tag, ...args) {
+    if (!this.enabled) return
+    console.warn(`[W][${tag}]`, ...args)
+  }
+
+  e(tag, ...args) {
+    if (!this.enabled) return
+    console.error(`[E][${tag}]`, ...args)
+  }
+
+  f(tag, ...args) {
+    if (!this.enabled) return
+    console.error(`[F][${tag}]`, ...args)
+  }
+
+  async getEsInfo(...args) {
+    const info = {
+      version: 'web',
+      platform: 'web',
+    }
+    return resolveAddon(args, info)
+  }
+
+  setEnabled(enabled) {
+    this.enabled = enabled
+  }
+
+  isEnabled() {
+    return this.enabled
+  }
+}