@vizbeetv/sdk-qa 7.8.36 → 7.8.38

package/types/vtvsdk/src/core/session/bicast/VizbeeBicastSession.d.ts

@@ -0,0 +1,25 @@
+import { VizbeeMessagingClient } from '../base/VizbeeMessagingClient.js';
+import { VizbeePresenceClient } from '../base/VizbeePresenceClient.js';
+/**
+ * Manages the messaging session for Vizbee bicast communications.
+ * This class implements the Singleton pattern for the messaging client,
+ * ensuring only one instance exists throughout the application lifecycle.
+ */
+declare class VizbeeBicastSession {
+    /**
+     * Instance of the messaging client. Initialized lazily upon first request.
+     * @private
+     */
+    private _messagingClient;
+    private _presenceClient;
+    constructor();
+    /**
+     * Returns the messaging client instance, creating it if it doesn't exist.
+     * Implements lazy initialization pattern for the messaging client.
+     *
+     * @returns {VizbeeMessagingClient} The singleton instance of the messaging client
+     */
+    getMessagingClient(): VizbeeMessagingClient;
+    getPresenceClient(): VizbeePresenceClient;
+}
+export { VizbeeBicastSession };

package/types/vtvsdk/src/core/session/bicast/VizbeeBicastSessionManager.d.ts

@@ -0,0 +1,63 @@
+import { VizbeeBicastSession } from './VizbeeBicastSession.js';
+import { SessionState } from '../SessionState.js';
+import { SessionStateListener } from '../SessionStateListener.js';
+/**
+ * Manages the lifecycle and state of Vizbee bicast sessions.
+ * This class handles session initialization, state management, and listener notifications.
+ * It interfaces with the VZB SDK's syncController to maintain session state synchronization.
+ */
+declare class VizbeeBicastSessionManager {
+    /** Singleton instance */
+    private static instance;
+    /** Current active session instance */
+    private session;
+    /** Current state of the session, defaults to NOT_CONNECTED */
+    private sessionState;
+    /** Array of listeners to be notified of session state changes */
+    private sessionStateListeners;
+    /** Reference to the VZB SDK's sync controller */
+    private syncController;
+    constructor();
+    /**
+     * Initializes the session manager by connecting to the VZB SDK's sync controller
+     * and setting up initial state and listeners.
+     */
+    init(): void;
+    private listenForSyncControllerAvailability;
+    private listenForSyncControllerSessionState;
+    /**
+     * Registers a new listener for session state changes.
+     * @param listener - The listener object implementing SessionStateListener interface
+     */
+    addSessionStateListener(listener: SessionStateListener | ((newState: SessionState) => void)): void;
+    /**
+     * Removes a previously registered session state listener.
+     * @param listener - The listener object to remove
+     */
+    removeSessionStateListener(listener: SessionStateListener): void;
+    /**
+     * Returns the current active session instance.
+     * @returns The current VizbeeBicastSession or null if no active session
+     */
+    getSession(): VizbeeBicastSession | null;
+    /**
+     * Checks if the session is currently in connecting state.
+     * @returns True if the session is connecting, false otherwise
+     */
+    isConnecting(): boolean;
+    /**
+     * Checks if the session is currently connected.
+     * @returns True if the session is connected, false otherwise
+     */
+    isConnected(): boolean;
+    /**
+     * Handles session state change events from the sync controller.
+     * Creates or destroys session instances based on the new state
+     * and notifies all registered listeners.
+     *
+     * @param state - The new session state
+     * @private
+     */
+    private onSessionStateChanged;
+}
+export { VizbeeBicastSessionManager };

package/types/vtvsdk/src/core/session/bicast/VizbeePresenceManager.d.ts

@@ -0,0 +1,24 @@
+import { PresenceEventResult } from '../models/presence/PresenceEventResult.js';
+import { VizbeeDevice } from '../models/VizbeeDevice.js';
+/**
+ * Manages the lifecycle and state of Vizbee bicast sessions.
+ * This class handles session initialization, state management, and listener notifications.
+ * It interfaces with the VZB SDK's syncController to maintain session state synchronization.
+ */
+declare class VizbeePresenceManager {
+    /** Singleton instance */
+    private static instance;
+    private vizbeePresenceClient;
+    private presenceCallbacks;
+    private vizbeeSession;
+    constructor();
+    /**
+     * Initializes the session manager by connecting to the VZB SDK's sync controller
+     * and setting up initial state and listeners.
+     */
+    private init;
+    subscribe(onPresenceChanged: (result: PresenceEventResult) => void): void;
+    unsubscribe(onPresenceChanged: (result: PresenceEventResult) => void): void;
+    getMembers(): VizbeeDevice[];
+}
+export { VizbeePresenceManager };

package/types/vtvsdk/src/core/session/models/MemberInfo.d.ts

@@ -0,0 +1,39 @@
+import { MemberType } from './MemberType.js';
+/**
+ * Represents detailed information about a network member device in the Vizbee ecosystem.
+ * This interface captures device identification, hardware details, and runtime state.
+ */
+export interface MemberInfo {
+    /** Unique identifier for the device */
+    deviceId: string;
+    /** Identifier for Advertisers (IDFA) - platform-specific advertising identifier */
+    idfa: string;
+    /** Identifier for Vendors (IDFV) - platform-specific vendor identifier */
+    idfv: string;
+    /** Human-readable name for the device */
+    friendlyName: string;
+    /** Device model name (e.g., "iPhone", "Pixel") */
+    modelName: string;
+    /** Specific model number or identifier */
+    modelNumber: string;
+    /** Device manufacturer name */
+    manufacturer: string;
+    /** Role/type of the member in the network */
+    memberType: MemberType;
+    /** Flag indicating if ad tracking is restricted on this device */
+    limitAdTracking: boolean;
+    /** Indicates if the application is currently in the foreground */
+    isInForeground: boolean;
+    /** Unique identifier for the current network session */
+    networkSessionId: string;
+    /** Optional key-value pairs for additional device attributes */
+    customAttributes?: Record<string, any>;
+}
+/**
+ * Creates a new MemberInfo object with default values.
+ * Used for initializing a new member info structure with empty/default values
+ * before setting actual device information.
+ *
+ * @returns {MemberInfo} A MemberInfo object with default values
+ */
+export declare function createDefaultMemberInfo(): MemberInfo;

package/types/vtvsdk/src/core/session/models/MemberType.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Represents different types of devices supported in the Vizbee ecosystem.
+ * This enum categorizes devices into mobile devices and various smart TV platforms.
+ */
+export declare enum MemberType {
+    /** Android mobile devices */
+    ANDROID_MOBILE = "Android",
+    /** iOS mobile devices (iPhone, iPad) */
+    IOS = "iOS",
+    /** Android TV platform devices */
+    ANDROID_TV = "AndroidTV",
+    /** Amazon Fire TV devices */
+    FIRE_TV = "FireTV",
+    /** Roku streaming devices and TVs */
+    ROKU = "Roku",
+    /** Samsung Smart TVs running Tizen OS */
+    SAMSUNG_TIZEN = "SamsungTizen",
+    /** LG Smart TVs running WebOS */
+    LG_WEB_OS = "LGWebOS",
+    /** Vizio SmartCast enabled TVs */
+    VIZIO_SMARTCAST = "VizioSmartCast",
+    /** Fallback for unrecognized device types */
+    UNKNOWN = "Unknown"
+}
+/**
+ * Contains additional information about a member type.
+ * Used to provide platform-specific details and capabilities.
+ */
+export interface MemberTypeInfo {
+    /** String representation of the member type */
+    value: string;
+    /** Indicates if the device is a TV/large screen device */
+    isScreen: boolean;
+}
+/**
+ * Retrieves detailed information about a specific member type.
+ *
+ * @param memberType - The member type to get information for
+ * @returns MemberTypeInfo object containing platform details
+ */
+export declare function getMemberTypeInfo(memberType: MemberType): MemberTypeInfo;
+/**
+ * Converts a string value to its corresponding MemberType.
+ * Used for parsing platform identifiers from various sources.
+ *
+ * @param value - String identifier of the platform
+ * @returns The corresponding MemberType enum value, or UNKNOWN if not recognized
+ */
+export declare function fromValue(value: string): MemberType;

package/types/vtvsdk/src/core/session/models/VizbeeDevice.d.ts

@@ -0,0 +1,26 @@
+import { VizbeeDeviceType } from './VizbeeDeviceType.js';
+/**
+ * Represents a device in the Vizbee ecosystem with its core identifying properties.
+ * This class provides a unified device representation that can be constructed from
+ * different source types (SenderInfo or MemberInfo).
+ */
+export declare class VizbeeDevice {
+    deviceId: string;
+    friendlyName: string;
+    modelName: string;
+    modelNumber: string | null;
+    manufacturer: string | null;
+    deviceType: VizbeeDeviceType | null;
+    /**
+     * Creates a new VizbeeDevice instance.
+     *
+     * @param deviceId - Unique identifier for the device
+     * @param friendlyName - Human-readable name of the device
+     * @param modelName - Model name or type of the device
+     * @param modelNumber - Specific model number identifier (optional)
+     * @param manufacturer - Device manufacturer name (optional)
+     * @param deviceType - Type classification of the device (optional)
+     */
+    constructor(deviceId: string, friendlyName: string, modelName: string, modelNumber: string | null, manufacturer: string | null, deviceType: VizbeeDeviceType | null);
+    toString(): string;
+}

package/types/vtvsdk/src/core/session/models/VizbeeDeviceType.d.ts

@@ -0,0 +1,10 @@
+import { DeviceType } from "../../sync/presence/DeviceType.js";
+/**
+ * DeviceType is used to specify the type of device.
+ */
+export declare enum VizbeeDeviceType {
+    ANDROID_MOBILE = "ANDROID_MOBILE",
+    IOS = "IOS",
+    UNKNOWN = "UNKNOWN"
+}
+export declare function toVizbeeDeviceType(deviceType: DeviceType): VizbeeDeviceType;

package/types/vtvsdk/src/core/session/models/presence/PresenceEventResult.d.ts

@@ -0,0 +1,11 @@
+import { VizbeeDevice } from "../VizbeeDevice.js";
+export declare class PresenceEventResult {
+    readonly event: PresenceEvent;
+    readonly device: VizbeeDevice;
+    constructor(event: PresenceEvent, device: VizbeeDevice);
+    toString(): string;
+}
+export declare enum PresenceEvent {
+    JOIN = "JOIN",
+    LEAVE = "LEAVE"
+}

package/types/vtvsdk/src/core/sync/presence/Device.d.ts

@@ -0,0 +1,34 @@
+import { DeviceType } from "./DeviceType.js";
+export interface Device {
+    readonly deviceId: string;
+    readonly idfa?: string;
+    readonly idfv?: string;
+    readonly friendlyName?: string;
+    readonly modelName?: string;
+    readonly modelNumber?: string;
+    readonly manufacturer?: string;
+    readonly deviceType: DeviceType;
+    readonly limitAdTracking?: boolean;
+    readonly isInForeground?: boolean;
+    readonly networkSessionId?: string;
+    readonly customAttributes?: Record<string, any>;
+}
+export declare class DeviceImpl implements Device {
+    readonly deviceId: string;
+    readonly deviceType: DeviceType;
+    readonly idfa?: string;
+    readonly idfv?: string;
+    readonly friendlyName?: string;
+    readonly modelName?: string;
+    readonly modelNumber?: string;
+    readonly manufacturer?: string;
+    readonly limitAdTracking: boolean;
+    readonly isInForeground: boolean;
+    readonly networkSessionId?: string;
+    readonly customAttributes?: Record<string, any>;
+    constructor(deviceId: string, deviceType: DeviceType, idfa?: string, idfv?: string, friendlyName?: string, modelName?: string, modelNumber?: string, manufacturer?: string, limitAdTracking?: boolean, isInForeground?: boolean, networkSessionId?: string, customAttributes?: Record<string, any>);
+    get displayName(): string;
+    equals(other: any): boolean;
+    hashCode(): number;
+    toString(): string;
+}

package/types/vtvsdk/src/core/sync/presence/DeviceType.d.ts

@@ -0,0 +1,6 @@
+export declare enum DeviceType {
+    ANDROID_MOBILE = "Android",
+    IOS = "iOS",
+    UNKNOWN = "Unknown"
+}
+export declare function deviceTypeFromValue(value: string): DeviceType;

package/types/vtvsdk/src/core/sync/presence/PresenceEvent.d.ts

@@ -0,0 +1,4 @@
+export declare enum PresenceEvent {
+    JOIN = "JOIN",
+    LEAVE = "LEAVE"
+}

package/types/vtvsdk/src/core/sync/presence/PresenceEventResult.d.ts

@@ -0,0 +1,8 @@
+import { Device } from "./Device.js";
+import { PresenceEvent } from "./PresenceEvent.js";
+export declare class PresenceEventResult {
+    event: PresenceEvent;
+    member: Device;
+    constructor(event: PresenceEvent, member: Device);
+    toString(): string;
+}