@quicktvui/web-renderer 1.0.0

package/src/modules/ESDeviceInfoModule.js

@@ -0,0 +1,450 @@
+// ESDeviceInfoModule - Web adapter for device information
+// Provides device info for web browser environment
+
+import { resolveAddon, createModuleInit } from '../core/moduleUtils'
+
+/**
+ * Get browser and device info from navigator and screen APIs
+ */
+function getBrowserDeviceInfo() {
+  const ua = navigator.userAgent
+  const platform = navigator.platform
+
+  // Detect browser
+  let browser = 'unknown'
+  let browserVersion = ''
+  if (/Chrome\/(\d+\.?\d*)/i.test(ua) && !/Edge|Edg/i.test(ua)) {
+    browser = 'Chrome'
+    browserVersion = RegExp.$1
+  } else if (/Safari\/(\d+\.?\d*)/i.test(ua) && !/Chrome/i.test(ua)) {
+    browser = 'Safari'
+    browserVersion = RegExp.$1
+  } else if (/Firefox\/(\d+\.?\d*)/i.test(ua)) {
+    browser = 'Firefox'
+    browserVersion = RegExp.$1
+  } else if (/Edge?\/(\d+\.?\d*)/i.test(ua)) {
+    browser = 'Edge'
+    browserVersion = RegExp.$1
+  }
+
+  // Detect OS
+  let os = 'unknown'
+  let osVersion = ''
+  if (/Windows NT (\d+\.?\d*)/i.test(ua)) {
+    os = 'Windows'
+    osVersion = RegExp.$1
+  } else if (/Mac OS X (\d+[._]\d+[._]?\d*)/i.test(ua)) {
+    os = 'macOS'
+    osVersion = RegExp.$1.replace(/_/g, '.')
+  } else if (/Android (\d+\.?\d*\.?\d*)/i.test(ua)) {
+    os = 'Android'
+    osVersion = RegExp.$1
+  } else if (/iOS|iPhone OS|iPad/i.test(ua)) {
+    os = 'iOS'
+    const match = ua.match(/OS (\d+_\d+_?\d*)/i)
+    if (match) osVersion = match[1].replace(/_/g, '.')
+  } else if (/Linux/i.test(ua)) {
+    os = 'Linux'
+  }
+
+  // Screen info
+  const screenWidth = window.screen.width || 0
+  const screenHeight = window.screen.height || 0
+  const devicePixelRatio = window.devicePixelRatio || 1
+  const colorDepth = window.screen.colorDepth || 24
+
+  // Hardware concurrency (CPU cores)
+  const cpuCores = navigator.hardwareConcurrency || 4
+
+  // Memory (if available - Chrome only)
+  const memory = navigator.deviceMemory || 4
+
+  return {
+    browser,
+    browserVersion,
+    os,
+    osVersion,
+    platform,
+    screenWidth,
+    screenHeight,
+    devicePixelRatio,
+    colorDepth,
+    cpuCores,
+    memory,
+    ua,
+  }
+}
+
+/**
+ * Get network info from navigator.connection API
+ */
+function getNetworkInfo() {
+  const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection
+  if (connection) {
+    return {
+      effectiveType: connection.effectiveType || 'unknown', // '4g', '3g', '2g', 'slow-2g'
+      type: connection.type || 'unknown',
+      downlink: connection.downlink || 0, // Mbps
+      rtt: connection.rtt || 0, // ms
+      saveData: connection.saveData || false,
+    }
+  }
+  return {
+    effectiveType: 'unknown',
+    type: 'unknown',
+    downlink: 0,
+    rtt: 0,
+    saveData: false,
+  }
+}
+
+// Cache device info
+let cachedDeviceInfo = null
+
+function getDeviceInfo() {
+  if (!cachedDeviceInfo) {
+    cachedDeviceInfo = getBrowserDeviceInfo()
+  }
+  return cachedDeviceInfo
+}
+
+export class ESDeviceInfoModule {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+  }
+
+  // Device Brand
+  async getDeviceBrand(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, 'Web')
+  }
+
+  // Device Model
+  async getDeviceModel(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, info.browser || 'Browser')
+  }
+
+  // CPU Info
+  async getDeviceCpu(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, `${info.cpuCores} cores`)
+  }
+
+  // CPU Cores
+  async getDeviceCpuCores(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, info.cpuCores)
+  }
+
+  // Device Memory (GB)
+  async getDeviceMemory(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, info.memory)
+  }
+
+  // Device Storage (not available in web)
+  async getDeviceStorage(...args) {
+    // Try to estimate storage using Storage API
+    if (navigator.storage && navigator.storage.estimate) {
+      try {
+        const estimate = await navigator.storage.estimate()
+        return resolveAddon(args, estimate.quota || 0)
+      } catch (e) {
+        // Ignore errors
+      }
+    }
+    return resolveAddon(args, 0)
+  }
+
+  // Device Resolution
+  async getDeviceResolution(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, `${info.screenWidth}x${info.screenHeight}`)
+  }
+
+  // 5G Support
+  async getDevice5G(...args) {
+    const netInfo = getNetworkInfo()
+    // Check if connection is 5g (not well supported in browsers)
+    return resolveAddon(args, false)
+  }
+
+  // Link Speed
+  async getDeviceLinkSpeed(...args) {
+    const netInfo = getNetworkInfo()
+    return resolveAddon(args, netInfo.downlink)
+  }
+
+  // Device Manufacturer
+  async getDeviceManufacture(...args) {
+    return resolveAddon(args, 'Web')
+  }
+
+  // Device Board
+  async getDeviceBoard(...args) {
+    return resolveAddon(args, 'Web')
+  }
+
+  // Device Platform
+  async getDevicePlatform(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, info.platform || 'Web')
+  }
+
+  // Device Hardware
+  async getDeviceHard(...args) {
+    return resolveAddon(args, 'Web')
+  }
+
+  // Device Architecture
+  async getDeviceArchitecture(...args) {
+    // Try to get architecture from ua or platform
+    const info = getDeviceInfo()
+    if (/arm|aarch64/i.test(info.ua)) return resolveAddon(args, 'arm64')
+    if (/x86_64|amd64/i.test(info.ua)) return resolveAddon(args, 'x86_64')
+    return resolveAddon(args, 'unknown')
+  }
+
+  // Clock Speed
+  async getDeviceClockSpeed(...args) {
+    return resolveAddon(args, 0)
+  }
+
+  // Android Version
+  async getDeviceAndroidVersion(...args) {
+    const info = getDeviceInfo()
+    if (info.os === 'Android') {
+      return resolveAddon(args, info.osVersion)
+    }
+    return resolveAddon(args, '')
+  }
+
+  // API Version
+  async getDeviceApiVersion(...args) {
+    return resolveAddon(args, 0)
+  }
+
+  // Android ID
+  async getDeviceAndroidId(...args) {
+    // Not available in web
+    return resolveAddon(args, '')
+  }
+
+  // Build ID
+  async getDeviceBuildId(...args) {
+    return resolveAddon(args, 'web')
+  }
+
+  // Root Status
+  async getDeviceRoot(...args) {
+    return resolveAddon(args, false)
+  }
+
+  // Free Storage
+  async getDeviceFreeStore(...args) {
+    if (navigator.storage && navigator.storage.estimate) {
+      try {
+        const estimate = await navigator.storage.estimate()
+        return resolveAddon(args, (estimate.quota || 0) - (estimate.usage || 0))
+      } catch (e) {
+        // Ignore errors
+      }
+    }
+    return resolveAddon(args, 0)
+  }
+
+  // Network State
+  async getNetworkState(...args) {
+    const netInfo = getNetworkInfo()
+    return resolveAddon(args, {
+      connected: navigator.onLine,
+      type: netInfo.effectiveType,
+    })
+  }
+
+  // Network Type
+  async getNetworkType(...args) {
+    const netInfo = getNetworkInfo()
+    return resolveAddon(args, netInfo.effectiveType)
+  }
+
+  // SSID (not available in web)
+  async getSSID(...args) {
+    return resolveAddon(args, '')
+  }
+
+  // MAC Address (not available in web)
+  async getMac(...args) {
+    return resolveAddon(args, '')
+  }
+
+  // IP Address (not directly available in web)
+  async getIp(...args) {
+    return resolveAddon(args, '')
+  }
+
+  // DNS (not available in web)
+  async getDeviceDns(...args) {
+    return resolveAddon(args, '')
+  }
+
+  // WiFi Version
+  async getWifiVersion(...args) {
+    return resolveAddon(args, '')
+  }
+
+  // Display Information
+  async getDisplayInformation(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, {
+      width: info.screenWidth,
+      height: info.screenHeight,
+      density: info.devicePixelRatio,
+      colorDepth: info.colorDepth,
+    })
+  }
+
+  // GPU Info (limited info available via WebGL)
+  async getGpuInfo(...args) {
+    try {
+      const canvas = document.createElement('canvas')
+      const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl')
+      if (gl) {
+        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info')
+        if (debugInfo) {
+          return resolveAddon(args, {
+            vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL),
+            renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL),
+          })
+        }
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+    return resolveAddon(args, { vendor: 'unknown', renderer: 'unknown' })
+  }
+
+  // Base Info - comprehensive device info
+  async getBaseInfo(...args) {
+    const info = getDeviceInfo()
+    const netInfo = getNetworkInfo()
+    return resolveAddon(args, {
+      brand: 'Web',
+      model: info.browser,
+      os: info.os,
+      osVersion: info.osVersion,
+      platform: info.platform,
+      screenWidth: info.screenWidth,
+      screenHeight: info.screenHeight,
+      density: info.devicePixelRatio,
+      cpuCores: info.cpuCores,
+      memory: info.memory,
+      networkType: netInfo.effectiveType,
+    })
+  }
+
+  // System Info
+  async getSystemInfo(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, {
+      os: info.os,
+      osVersion: info.osVersion,
+      browser: info.browser,
+      browserVersion: info.browserVersion,
+      platform: info.platform,
+      language: navigator.language,
+      userAgent: info.ua,
+    })
+  }
+
+  // CPU Info
+  async getCpuInfo(...args) {
+    const info = getDeviceInfo()
+    return resolveAddon(args, {
+      cores: info.cpuCores,
+      memory: info.memory,
+    })
+  }
+
+  // Android Info
+  async getAndroidInfo(...args) {
+    return resolveAddon(args, null)
+  }
+
+  // Store Info
+  async getStoreInfo(...args) {
+    if (navigator.storage && navigator.storage.estimate) {
+      try {
+        const estimate = await navigator.storage.estimate()
+        return resolveAddon(args, {
+          total: estimate.quota || 0,
+          used: estimate.usage || 0,
+          free: (estimate.quota || 0) - (estimate.usage || 0),
+        })
+      } catch (e) {
+        // Ignore errors
+      }
+    }
+    return resolveAddon(args, { total: 0, used: 0, free: 0 })
+  }
+
+  // Net Info
+  async getNetInfo(...args) {
+    const netInfo = getNetworkInfo()
+    return resolveAddon(args, {
+      online: navigator.onLine,
+      type: netInfo.effectiveType,
+      downlink: netInfo.downlink,
+      rtt: netInfo.rtt,
+      saveData: netInfo.saveData,
+    })
+  }
+
+  // Out IP (not available directly)
+  async getOutIp(...args) {
+    return resolveAddon(args, '')
+  }
+
+  // USB Info
+  async getUsbInfo(...args) {
+    return resolveAddon(args, [])
+  }
+
+  // Bluetooth Info
+  async getBluetoothInfo(...args) {
+    // Check if Web Bluetooth is available
+    const hasBluetooth = 'bluetooth' in navigator
+    return resolveAddon(args, {
+      available: hasBluetooth,
+      devices: [],
+    })
+  }
+
+  // Permission Handler
+  async permissionHandler(...args) {
+    return resolveAddon(args, { granted: true })
+  }
+
+  // Network Protocol
+  async getNetworkProtocol(...args) {
+    return resolveAddon(args, location.protocol === 'https:' ? 'https' : 'http')
+  }
+
+  // Network Speed
+  async getNetworkSpeed(...args) {
+    const netInfo = getNetworkInfo()
+    return resolveAddon(args, netInfo.downlink)
+  }
+
+  async init(...args) {
+    return createModuleInit(args)
+  }
+
+  destroy() {}
+}
+
+// Export singleton instance
+export const esDeviceInfoModuleInstance = new ESDeviceInfoModule()

package/src/modules/ESGroupDataModule.js

@@ -0,0 +1,195 @@
+// ESGroupDataModule - Web adapter for shared data storage
+// Provides cross-package data sharing using localStorage
+
+import { resolveAddon, createModuleInit } from '../core/moduleUtils'
+
+// Storage key prefix for group data
+const GROUP_DATA_PREFIX = 'es_group_data_'
+
+/**
+ * Build storage key for a package
+ */
+function buildStorageKey(params, key) {
+  if (!params || !params.packageName) {
+    return null
+  }
+  return `${GROUP_DATA_PREFIX}${params.packageName}_${key}`
+}
+
+/**
+ * Get data from localStorage
+ */
+function getFromStorage(params, key, defValue) {
+  const storageKey = buildStorageKey(params, key)
+  if (!storageKey) {
+    return Promise.resolve(defValue)
+  }
+
+  try {
+    const stored = localStorage.getItem(storageKey)
+    if (stored && stored !== '') {
+      const shareData = JSON.parse(stored)
+      if (shareData && shareData.data !== undefined) {
+        return Promise.resolve(shareData.data)
+      }
+    }
+  } catch (e) {
+    console.warn('[ESGroupDataModule] Error reading from storage:', e)
+  }
+
+  return Promise.resolve(defValue)
+}
+
+/**
+ * Put data to localStorage
+ */
+function putToStorage(params, key, value, mode, type) {
+  const storageKey = buildStorageKey(params, key)
+  if (!storageKey) {
+    return Promise.resolve(false)
+  }
+
+  try {
+    const shareData = {
+      mode: mode || 0,
+      type: type,
+      secretKey: params?.secretKey || '',
+      data: value,
+    }
+    localStorage.setItem(storageKey, JSON.stringify(shareData))
+    return Promise.resolve(true)
+  } catch (e) {
+    console.warn('[ESGroupDataModule] Error writing to storage:', e)
+    return Promise.resolve(false)
+  }
+}
+
+// ESSharedDataType constants
+const ESSharedDataType = {
+  ES_SHARED_DATA_TYPE_INT: 0,
+  ES_SHARED_DATA_TYPE_LONG: 1,
+  ES_SHARED_DATA_TYPE_FLOAT: 2,
+  ES_SHARED_DATA_TYPE_STRING: 3,
+  ES_SHARED_DATA_TYPE_BOOLEAN: 4,
+  ES_SHARED_DATA_TYPE_MAP: 5,
+  ES_SHARED_DATA_TYPE_ARRAY: 6,
+}
+
+export class ESGroupDataModule {
+  constructor(context) {
+    this.context = context
+    this.name = ''
+    this.mode = 'normal'
+  }
+
+  // Boolean
+  async getBoolean(params, key, defValue, ...args) {
+    const result = await getFromStorage(params, key, defValue)
+    return resolveAddon(args, result)
+  }
+
+  async putBoolean(params, key, value, mode, ...args) {
+    const result = await putToStorage(
+      params,
+      key,
+      value,
+      mode,
+      ESSharedDataType.ES_SHARED_DATA_TYPE_BOOLEAN
+    )
+    return resolveAddon(args, result)
+  }
+
+  // Int
+  async getInt(params, key, defValue, ...args) {
+    const result = await getFromStorage(params, key, defValue)
+    return resolveAddon(args, result)
+  }
+
+  async putInt(params, key, value, mode, ...args) {
+    const result = await putToStorage(
+      params,
+      key,
+      value,
+      mode,
+      ESSharedDataType.ES_SHARED_DATA_TYPE_INT
+    )
+    return resolveAddon(args, result)
+  }
+
+  // Long
+  async getLong(params, key, defValue, ...args) {
+    const result = await getFromStorage(params, key, defValue)
+    return resolveAddon(args, result)
+  }
+
+  async putLong(params, key, value, mode, ...args) {
+    const result = await putToStorage(
+      params,
+      key,
+      value,
+      mode,
+      ESSharedDataType.ES_SHARED_DATA_TYPE_LONG
+    )
+    return resolveAddon(args, result)
+  }
+
+  // String
+  async getString(params, key, defValue, ...args) {
+    const result = await getFromStorage(params, key, defValue)
+    return resolveAddon(args, result)
+  }
+
+  async putString(params, key, value, mode, ...args) {
+    const result = await putToStorage(
+      params,
+      key,
+      value,
+      mode,
+      ESSharedDataType.ES_SHARED_DATA_TYPE_STRING
+    )
+    return resolveAddon(args, result)
+  }
+
+  // Array
+  async getArray(params, key, defValue, ...args) {
+    const result = await getFromStorage(params, key, defValue)
+    return resolveAddon(args, result)
+  }
+
+  async putArray(params, key, value, mode, ...args) {
+    const result = await putToStorage(
+      params,
+      key,
+      value,
+      mode,
+      ESSharedDataType.ES_SHARED_DATA_TYPE_ARRAY
+    )
+    return resolveAddon(args, result)
+  }
+
+  // Map/Object
+  async getMap(params, key, defValue, ...args) {
+    const result = await getFromStorage(params, key, defValue)
+    return resolveAddon(args, result)
+  }
+
+  async putMap(params, key, value, mode, ...args) {
+    const result = await putToStorage(
+      params,
+      key,
+      value,
+      mode,
+      ESSharedDataType.ES_SHARED_DATA_TYPE_MAP
+    )
+    return resolveAddon(args, result)
+  }
+
+  async init(...args) {
+    return createModuleInit(args)
+  }
+
+  destroy() {}
+}
+
+// Export singleton instance
+export const esGroupDataModuleInstance = new ESGroupDataModule()