@volley/vwr-loader 1.0.0-alpha.1

package/src/getDeviceId.test.ts

@@ -0,0 +1,237 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import { getDeviceId } from "./getDeviceId"
+
+describe("getDeviceId", () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+        // Clean up window properties
+        delete (window as any).DeviceInfo
+        delete (window as any).NativeBridge
+        delete (window as any).webapis
+        delete (window as any).webOSDev
+        delete (window as any).webOS
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+        delete (window as any).DeviceInfo
+        delete (window as any).NativeBridge
+        delete (window as any).webapis
+        delete (window as any).webOSDev
+        delete (window as any).webOS
+    })
+
+    describe("FIRE_TV platform", () => {
+        it("returns device ID from DeviceInfo.getAndroidId when available", async () => {
+            const mockAndroidId = "firetv-android-id-123"
+            Object.defineProperty(window, "DeviceInfo", {
+                value: {
+                    getAndroidId: vi
+                        .fn()
+                        .mockResolvedValue({ androidId: mockAndroidId }),
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("FIRE_TV")
+            expect(result).toBe(mockAndroidId)
+        })
+
+        it("returns null when DeviceInfo throws error", async () => {
+            Object.defineProperty(window, "DeviceInfo", {
+                value: {
+                    getAndroidId: vi
+                        .fn()
+                        .mockRejectedValue(new Error("DeviceInfo error")),
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("FIRE_TV")
+            expect(result).toBeNull()
+        })
+
+        it("returns null when DeviceInfo returns empty", async () => {
+            Object.defineProperty(window, "DeviceInfo", {
+                value: {
+                    getAndroidId: vi.fn().mockResolvedValue({ androidId: "" }),
+                },
+                writable: true,
+                configurable: true,
+            })
+            const result = await getDeviceId("FIRE_TV")
+            expect(result).toBeNull()
+        })
+    })
+
+    describe("SAMSUNG_TV platform", () => {
+        it("returns device ID from Samsung webapis when available", async () => {
+            const mockDeviceId = "samsung-duid-123"
+            Object.defineProperty(window, "webapis", {
+                value: {
+                    productinfo: {
+                        getDuid: vi.fn().mockReturnValue(mockDeviceId),
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("SAMSUNG_TV")
+            expect(result).toBe(mockDeviceId)
+        })
+
+        it("returns null when webapis throws error", async () => {
+            Object.defineProperty(window, "webapis", {
+                value: {
+                    productinfo: {
+                        getDuid: vi.fn().mockImplementation(() => {
+                            throw new Error("Samsung API error")
+                        }),
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("SAMSUNG_TV")
+            expect(result).toBeNull()
+        })
+    })
+
+    describe("LG_TV platform", () => {
+        it("returns device ID from LG webOS.service.request when available", async () => {
+            const mockDeviceId = "lg-udid-123"
+            const mockRequest = vi.fn().mockImplementation((_uri, options) => {
+                options.onSuccess?.({
+                    idList: [{ idValue: mockDeviceId }],
+                })
+                return { cancel: vi.fn() }
+            })
+
+            Object.defineProperty(window, "webOS", {
+                value: {
+                    service: {
+                        request: mockRequest,
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("LG_TV")
+            expect(result).toBe(mockDeviceId)
+        })
+
+        it("returns null when webOS.service.request fails", async () => {
+            const mockRequest = vi.fn().mockImplementation((_uri, options) => {
+                options.onFailure?.({ errorText: "LG API error" })
+                return { cancel: vi.fn() }
+            })
+
+            Object.defineProperty(window, "webOS", {
+                value: {
+                    service: {
+                        request: mockRequest,
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("LG_TV")
+            expect(result).toBeNull()
+        })
+    })
+
+    describe("MOBILE platform", () => {
+        it("returns device ID from NativeBridge when available", async () => {
+            const mockDeviceId = "native-device-123"
+            Object.defineProperty(window, "NativeBridge", {
+                value: {
+                    getDeviceId: vi.fn().mockResolvedValue(mockDeviceId),
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("MOBILE")
+            expect(result).toBe(mockDeviceId)
+        })
+
+        it("returns null when NativeBridge throws error", async () => {
+            Object.defineProperty(window, "NativeBridge", {
+                value: {
+                    getDeviceId: vi
+                        .fn()
+                        .mockRejectedValue(new Error("Native error")),
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("MOBILE")
+            expect(result).toBeNull()
+        })
+    })
+
+    describe("WEB platform", () => {
+        beforeEach(() => {
+            localStorage.clear()
+        })
+
+        it("generates and stores new device ID when none exists", async () => {
+            const mockUUID = "web-uuid-123"
+            Object.defineProperty(window.crypto, "randomUUID", {
+                value: vi.fn().mockReturnValue(mockUUID),
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getDeviceId("WEB")
+
+            expect(result).toBe(mockUUID)
+            expect(localStorage.getItem("volley_device_id")).toBe(mockUUID)
+        })
+
+        it("retrieves existing device ID from localStorage", async () => {
+            const existingId = "existing-web-id"
+            localStorage.setItem("volley_device_id", existingId)
+
+            const result = await getDeviceId("WEB")
+
+            expect(result).toBe(existingId)
+        })
+    })
+
+    describe("Unknown platform", () => {
+        it("returns null for unknown platform", async () => {
+            const result = await getDeviceId("UNKNOWN_PLATFORM")
+            expect(result).toBeNull()
+        })
+    })
+
+    describe("Case insensitivity", () => {
+        it("is case-insensitive for platform parameter", async () => {
+            const mockSamsungId = "samsung-case-test"
+            Object.defineProperty(window, "webapis", {
+                value: {
+                    productinfo: {
+                        getDuid: vi.fn().mockReturnValue(mockSamsungId),
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result1 = await getDeviceId("samsung_tv")
+            const result2 = await getDeviceId("SAMSUNG_TV")
+
+            expect(result1).toBe(mockSamsungId)
+            expect(result2).toBe(mockSamsungId)
+        })
+    })
+})

package/src/getDeviceId.ts

@@ -0,0 +1,243 @@
+import { defaultLogger, type Logger } from "./logger"
+
+/**
+ * Get a unique device identifier for the current platform.
+ *
+ * This function attempts to retrieve a device ID from platform-specific APIs.
+ *
+ * Platform handling:
+ * - FireTV: DeviceInfo (Capacitor plugin)
+ * - Android/iOS: NativeBridge
+ * - Samsung TV: webapis
+ * - LG TV: webOS Luna service
+ * - Web: localStorage (with generated UUID fallback)
+ *
+ * @param platform - Platform identifier ('FIRE_TV', 'SAMSUNG_TV', 'LG_TV', 'ANDROID_MOBILE', 'IOS_MOBILE', 'WEB')
+ * @param logger - Optional logger for error reporting. Defaults to defaultLogger.
+ * @returns A promise that resolves to a unique device identifier string, or null if retrieval fails
+ *
+ * @example
+ * ```typescript
+ * const deviceId = await getDeviceId('SAMSUNG_TV', logger)
+ * if (!deviceId) {
+ *   // Handle error
+ * }
+ * ```
+ */
+export async function getDeviceId(
+    platform: string,
+    logger: Logger = defaultLogger
+): Promise<string | null> {
+    const normalizedPlatform = platform.toUpperCase()
+    switch (normalizedPlatform) {
+        case "FIRE_TV":
+            return await getFireTVDeviceId(logger)
+        case "SAMSUNG_TV":
+            return await getSamsungDeviceId(logger)
+        case "LG_TV":
+            return await getLGDeviceId(logger)
+        case "ANDROID_MOBILE":
+        case "IOS_MOBILE":
+        case "MOBILE": // Legacy/Generic
+            return await getMobileDeviceId(logger)
+        case "WEB":
+            return getLocalStorageDeviceId()
+        default:
+            const message = `[getDeviceId] Unknown platform: ${platform}`
+            logger.error(message)
+            return null
+    }
+}
+
+/**
+ * Get or create device ID from localStorage (for Web platform)
+ */
+function getLocalStorageDeviceId(): string {
+    let deviceId = localStorage.getItem("volley_device_id")
+    if (!deviceId) {
+        deviceId = crypto.randomUUID()
+        localStorage.setItem("volley_device_id", deviceId)
+    }
+    return deviceId
+}
+
+/**
+ * Attempt to get device ID from Capacitor DeviceInfo plugin (FireTV)
+ */
+async function getFireTVDeviceId(logger: Logger): Promise<string | null> {
+    try {
+        if (!window.DeviceInfo?.getAndroidId) {
+            return null
+        }
+
+        const result = await window.DeviceInfo.getAndroidId()
+        if (result?.androidId && result.androidId.trim()) {
+            return result.androidId
+        } else {
+            logger.error("DeviceInfo.getAndroidId returned empty")
+        }
+    } catch (error) {
+        const message = "DeviceInfo.getAndroidId failed:"
+        logger.error(message, { error })
+    }
+    return null
+}
+
+/**
+ * Attempt to get device ID from Native Bridge (Android/iOS)
+ */
+async function getMobileDeviceId(logger: Logger): Promise<string | null> {
+    try {
+        if (!window.NativeBridge?.getDeviceId) {
+            return null
+        }
+
+        const id = await window.NativeBridge.getDeviceId()
+        if (id && id.trim()) {
+            return id
+        } else {
+            logger.error("NativeBridge.getDeviceId returned empty")
+        }
+    } catch (error) {
+        const message = "NativeBridge.getDeviceId failed:"
+        logger.error(message, { error })
+    }
+    return null
+}
+
+/**
+ * Attempt to get device ID from Samsung TV webapis
+ */
+async function getSamsungDeviceId(logger: Logger): Promise<string | null> {
+    try {
+        if (!window.webapis?.productinfo?.getDuid) {
+            return null
+        }
+
+        const id = window.webapis.productinfo.getDuid()
+        if (id && id.trim()) {
+            return id
+        } else {
+            logger.error("Samsung webapis.getDuid returned empty")
+        }
+    } catch (error) {
+        const message = "Samsung webapis.getDuid failed:"
+        logger.error(message, { error })
+    }
+    return null
+}
+
+/**
+ * Attempt to get device ID from LG TV using Luna Service.
+ *
+ * This implementation is copied from PSDK's LGTVDeviceInfo to ensure
+ * the shell and SDK return the exact same device ID.
+ *
+ * TODO: In the future, PSDK should import this function from vwr-loader
+ * to maintain a single source of truth for LG device ID retrieval.
+ */
+const LG_LUNA_SERVICE_TIMEOUT = 5000
+
+async function getLGDeviceId(logger: Logger): Promise<string | null> {
+    if (!window.webOS?.service?.request) {
+        const message = "LG webOS service request not available"
+        logger.error(message)
+        return null
+    }
+
+    return new Promise((resolve) => {
+        let timeoutId: ReturnType<typeof setTimeout> | undefined
+        let request: { cancel: () => void } | undefined
+        let resolved = false
+
+        const cleanup = () => {
+            if (timeoutId) {
+                clearTimeout(timeoutId)
+                timeoutId = undefined
+            }
+            request?.cancel()
+        }
+
+        const finish = (value: string | null) => {
+            if (resolved) return
+            resolved = true
+            cleanup()
+            resolve(value)
+        }
+
+        timeoutId = setTimeout(() => {
+            const message = "LG Luna service timed out"
+            logger.error(message)
+            finish(null)
+        }, LG_LUNA_SERVICE_TIMEOUT)
+
+        try {
+            request = window.webOS?.service?.request(
+                "luna://com.webos.service.sm",
+                {
+                    method: "deviceid/getIDs",
+                    parameters: { idType: ["LGUDID"] },
+                    onSuccess: (response: LGDeviceIdResponse) => {
+                        const deviceId = response.idList?.[0]?.idValue
+                        if (!deviceId) {
+                            const message =
+                                "LG Luna service returned no device ID"
+                            logger.error(message)
+                        }
+                        finish(deviceId || null)
+                    },
+                    onFailure: (error) => {
+                        const message = "LG Luna service failed:"
+                        logger.error(message, { error })
+                        finish(null)
+                    },
+                    subscribe: false,
+                }
+            )
+        } catch (error) {
+            const message = "LG Luna service request threw error:"
+            logger.error(message, { error })
+            finish(null)
+        }
+    })
+}
+
+// Type definitions for LG Luna service response
+interface LGDeviceIdResponse {
+    idList?: Array<{
+        idValue?: string
+    }>
+}
+
+// Type augmentation for platform-specific APIs
+declare global {
+    interface Window {
+        DeviceInfo?: {
+            getAndroidId: () => Promise<{ androidId: string }>
+        }
+        NativeBridge?: {
+            getDeviceId: () => Promise<string>
+        }
+        webapis?: {
+            productinfo?: {
+                getDuid: () => string
+            }
+        }
+        webOS?: {
+            service?: {
+                request: (
+                    uri: string,
+                    options: {
+                        method?: string
+                        parameters?: Record<string, unknown>
+                        onSuccess?: (response: LGDeviceIdResponse) => void
+                        onFailure?: (error: { errorText?: string }) => void
+                        subscribe?: boolean
+                    }
+                ) => {
+                    cancel: () => void
+                }
+            }
+        }
+    }
+}