unified-video-framework 1.0.0

package/packages/core/src/BasePlayer.ts

@@ -0,0 +1,250 @@
+/**
+ * Abstract base player class that provides common functionality
+ */
+
+import { 
+  IVideoPlayer, 
+  VideoSource, 
+  PlayerConfig, 
+  PlayerState, 
+  PlayerEvents, 
+  PlayerError,
+  Quality,
+  SubtitleTrack 
+} from './interfaces/IVideoPlayer';
+import { EventEmitter } from './utils/EventEmitter';
+
+export abstract class BasePlayer implements IVideoPlayer {
+  protected container: HTMLElement | null = null;
+  protected config: PlayerConfig;
+  protected events: EventEmitter;
+  protected state: PlayerState;
+  protected source: VideoSource | null = null;
+  protected subtitles: SubtitleTrack[] = [];
+  protected currentSubtitleIndex: number = -1;
+
+  constructor() {
+    this.config = this.getDefaultConfig();
+    this.events = new EventEmitter();
+    this.state = this.getDefaultState();
+  }
+
+  protected getDefaultConfig(): PlayerConfig {
+    return {
+      autoPlay: false,
+      muted: false,
+      volume: 1.0,
+      controls: true,
+      loop: false,
+      preload: 'metadata',
+      playsInline: true,
+      enableAdaptiveBitrate: true,
+      debug: false,
+      freeDuration: 0
+    };
+  }
+
+  protected getDefaultState(): PlayerState {
+    return {
+      isPlaying: false,
+      isPaused: true,
+      isBuffering: false,
+      isEnded: false,
+      isError: false,
+      currentTime: 0,
+      duration: 0,
+      bufferedPercentage: 0,
+      volume: 1.0,
+      isMuted: false,
+      playbackRate: 1.0,
+      availableQualities: []
+    };
+  }
+
+  async initialize(container: HTMLElement | string, config?: PlayerConfig): Promise<void> {
+    if (typeof container === 'string') {
+      const element = document.querySelector(container) as HTMLElement;
+      if (!element) {
+        throw new Error(`Container element not found: ${container}`);
+      }
+      this.container = element;
+    } else {
+      this.container = container;
+    }
+
+    this.config = { ...this.getDefaultConfig(), ...config };
+    this.state.volume = this.config.volume || 1.0;
+    this.state.isMuted = this.config.muted || false;
+
+    await this.setupPlayer();
+  }
+
+  protected abstract setupPlayer(): Promise<void>;
+
+  abstract destroy(): Promise<void>;
+
+  abstract load(source: VideoSource): Promise<void>;
+
+  async play(): Promise<void> {
+    this.state.isPlaying = true;
+    this.state.isPaused = false;
+    this.emit('onPlay');
+  }
+
+  pause(): void {
+    this.state.isPlaying = false;
+    this.state.isPaused = true;
+    this.emit('onPause');
+  }
+
+  stop(): void {
+    this.pause();
+    this.seek(0);
+    this.state.isEnded = true;
+  }
+
+  abstract seek(time: number): void;
+
+  setVolume(level: number): void {
+    const volume = Math.max(0, Math.min(1, level));
+    this.state.volume = volume;
+    this.emit('onVolumeChanged', volume);
+  }
+
+  mute(): void {
+    this.state.isMuted = true;
+    this.emit('onVolumeChanged', 0);
+  }
+
+  unmute(): void {
+    this.state.isMuted = false;
+    this.emit('onVolumeChanged', this.state.volume);
+  }
+
+  toggleMute(): void {
+    if (this.state.isMuted) {
+      this.unmute();
+    } else {
+      this.mute();
+    }
+  }
+
+  abstract getQualities(): Quality[];
+  abstract getCurrentQuality(): Quality | null;
+  abstract setQuality(index: number): void;
+  abstract setAutoQuality(enabled: boolean): void;
+
+  setPlaybackRate(rate: number): void {
+    this.state.playbackRate = rate;
+  }
+
+  getPlaybackRate(): number {
+    return this.state.playbackRate;
+  }
+
+  getCurrentTime(): number {
+    return this.state.currentTime;
+  }
+
+  getDuration(): number {
+    return this.state.duration;
+  }
+
+  getBufferedPercentage(): number {
+    return this.state.bufferedPercentage;
+  }
+
+  getState(): PlayerState {
+    return { ...this.state };
+  }
+
+  isPlaying(): boolean {
+    return this.state.isPlaying;
+  }
+
+  isPaused(): boolean {
+    return this.state.isPaused;
+  }
+
+  isEnded(): boolean {
+    return this.state.isEnded;
+  }
+
+  abstract enterFullscreen(): Promise<void>;
+  abstract exitFullscreen(): Promise<void>;
+
+  async toggleFullscreen(): Promise<void> {
+    if (document.fullscreenElement) {
+      await this.exitFullscreen();
+    } else {
+      await this.enterFullscreen();
+    }
+  }
+
+  abstract enterPictureInPicture(): Promise<void>;
+  abstract exitPictureInPicture(): Promise<void>;
+
+  on(event: keyof PlayerEvents, handler: Function): void {
+    this.events.on(event, handler as any);
+  }
+
+  off(event: keyof PlayerEvents, handler?: Function): void {
+    this.events.off(event, handler as any);
+  }
+
+  once(event: keyof PlayerEvents, handler: Function): void {
+    this.events.once(event, handler as any);
+  }
+
+  protected emit(event: keyof PlayerEvents, ...args: any[]): void {
+    this.events.emit(event, ...args);
+  }
+
+  // Optional runtime free preview controls (no-op base; platform implementations may override)
+  setFreeDuration?(seconds: number): void;
+  resetFreePreviewGate?(): void;
+
+  getSubtitles(): SubtitleTrack[] {
+    return this.subtitles;
+  }
+
+  setSubtitleTrack(index: number): void {
+    if (index >= 0 && index < this.subtitles.length) {
+      this.currentSubtitleIndex = index;
+      this.applySubtitleTrack(this.subtitles[index]);
+    }
+  }
+
+  disableSubtitles(): void {
+    this.currentSubtitleIndex = -1;
+    this.removeSubtitles();
+  }
+
+  protected abstract applySubtitleTrack(track: SubtitleTrack): void;
+  protected abstract removeSubtitles(): void;
+
+  protected handleError(error: PlayerError): void {
+    this.state.isError = true;
+    this.state.isPlaying = false;
+    this.emit('onError', error);
+    
+    if (this.config.debug) {
+      console.error('[VideoPlayer Error]', error);
+    }
+  }
+
+  protected updateTime(time: number): void {
+    this.state.currentTime = time;
+    this.emit('onTimeUpdate', time);
+  }
+
+  protected updateBuffered(percentage: number): void {
+    this.state.bufferedPercentage = percentage;
+    this.emit('onProgress', percentage);
+  }
+
+  protected setBuffering(isBuffering: boolean): void {
+    this.state.isBuffering = isBuffering;
+    this.emit('onBuffering', isBuffering);
+  }
+}

package/packages/core/src/VideoPlayer.ts

@@ -0,0 +1,237 @@
+import { EventEmitter } from 'events';
+import {
+  VideoPlayerConfig,
+  VideoSource,
+  PlayerState,
+  PlayerEvent,
+  EventHandler,
+  Quality,
+  SubtitleTrack,
+  AudioTrack,
+  PlayerMetrics,
+  PlayerError,
+  DRMConfig
+} from './interfaces';
+
+export abstract class VideoPlayer {
+  protected config: VideoPlayerConfig;
+  protected eventEmitter: EventEmitter;
+  protected state: PlayerState;
+  protected currentSource?: VideoSource;
+  protected metrics: PlayerMetrics;
+  protected errors: PlayerError[] = [];
+
+  constructor(config: VideoPlayerConfig = {}) {
+    this.config = {
+      autoPlay: false,
+      muted: false,
+      controls: true,
+      loop: false,
+      preload: 'metadata',
+      playsInline: true,
+      ...config
+    };
+    
+    this.eventEmitter = new EventEmitter();
+    this.state = PlayerState.IDLE;
+    this.metrics = this.initializeMetrics();
+  }
+
+  // Core playback methods
+  abstract load(source: VideoSource): Promise<void>;
+  abstract play(): Promise<void>;
+  abstract pause(): void;
+  abstract stop(): void;
+  abstract seek(position: number): void;
+  abstract setVolume(volume: number): void;
+  abstract setPlaybackRate(rate: number): void;
+  abstract getCurrentTime(): number;
+  abstract getDuration(): number;
+  abstract getVolume(): number;
+  abstract getPlaybackRate(): number;
+  abstract isMuted(): boolean;
+  abstract setMuted(muted: boolean): void;
+
+  // Quality management
+  abstract getAvailableQualities(): Quality[];
+  abstract getCurrentQuality(): Quality | null;
+  abstract setQuality(quality: Quality): void;
+  abstract enableAutoQuality(enabled: boolean): void;
+
+  // Subtitle/Audio tracks
+  abstract getSubtitleTracks(): SubtitleTrack[];
+  abstract getCurrentSubtitleTrack(): SubtitleTrack | null;
+  abstract setSubtitleTrack(track: SubtitleTrack | null): void;
+  abstract getAudioTracks(): AudioTrack[];
+  abstract getCurrentAudioTrack(): AudioTrack | null;
+  abstract setAudioTrack(track: AudioTrack): void;
+
+  // Platform-specific features
+  abstract enterFullscreen(): void;
+  abstract exitFullscreen(): void;
+  abstract isFullscreen(): boolean;
+  abstract enterPictureInPicture(): void;
+  abstract exitPictureInPicture(): void;
+  abstract isPictureInPicture(): boolean;
+
+  // Events
+  on(event: PlayerEvent, handler: EventHandler): void {
+    this.eventEmitter.on(event, handler);
+  }
+
+  off(event: PlayerEvent, handler: EventHandler): void {
+    this.eventEmitter.off(event, handler);
+  }
+
+  once(event: PlayerEvent, handler: EventHandler): void {
+    this.eventEmitter.once(event, handler);
+  }
+
+  removeAllListeners(event?: PlayerEvent): void {
+    if (event) {
+      this.eventEmitter.removeAllListeners(event);
+    } else {
+      this.eventEmitter.removeAllListeners();
+    }
+  }
+
+  protected emit(event: PlayerEvent, data?: any): void {
+    this.eventEmitter.emit(event, data);
+    
+    // Track analytics events
+    if (this.config.analytics?.enabled) {
+      this.trackAnalytics(event, data);
+    }
+  }
+
+  // State management
+  getState(): PlayerState {
+    return this.state;
+  }
+
+  protected setState(newState: PlayerState): void {
+    const oldState = this.state;
+    this.state = newState;
+    
+    if (oldState !== newState) {
+      this.emit('statechange' as PlayerEvent, { oldState, newState });
+    }
+  }
+
+  // Configuration
+  getConfig(): VideoPlayerConfig {
+    return { ...this.config };
+  }
+
+  updateConfig(config: Partial<VideoPlayerConfig>): void {
+    this.config = { ...this.config, ...config };
+    this.applyConfig();
+  }
+
+  protected abstract applyConfig(): void;
+
+  // Metrics
+  getMetrics(): PlayerMetrics {
+    return {
+      ...this.metrics,
+      errors: [...this.errors]
+    };
+  }
+
+  protected initializeMetrics(): PlayerMetrics {
+    return {
+      sessionId: this.generateSessionId(),
+      totalPlayTime: 0,
+      bufferingCount: 0,
+      bufferingDuration: 0,
+      averageBitrate: 0,
+      qualityChanges: 0,
+      errors: []
+    };
+  }
+
+  protected generateSessionId(): string {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  // Error handling
+  protected handleError(error: PlayerError): void {
+    this.errors.push(error);
+    this.emit('error', error);
+    
+    if (error.fatal) {
+      this.setState(PlayerState.ERROR);
+    }
+  }
+
+  // Analytics
+  protected trackAnalytics(event: string, data?: any): void {
+    if (!this.config.analytics?.providers) return;
+    
+    const analyticsData = {
+      event,
+      timestamp: Date.now(),
+      sessionId: this.metrics.sessionId,
+      currentTime: this.getCurrentTime(),
+      duration: this.getDuration(),
+      state: this.state,
+      ...data
+    };
+
+    this.config.analytics.providers.forEach(provider => {
+      try {
+        provider.track(event, analyticsData);
+      } catch (error) {
+        console.error(`Analytics provider ${provider.name} failed:`, error);
+      }
+    });
+  }
+
+  // DRM
+  protected abstract configureDRM(drmConfig: DRMConfig): Promise<void>;
+
+  // Cleanup
+  abstract destroy(): void;
+
+  protected cleanup(): void {
+    this.removeAllListeners();
+    this.state = PlayerState.IDLE;
+    this.currentSource = undefined;
+  }
+
+  // Utility methods
+  protected formatTime(seconds: number): string {
+    if (!isFinite(seconds)) return '00:00';
+    
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    
+    if (hours > 0) {
+      return `${hours}:${this.pad(minutes)}:${this.pad(secs)}`;
+    }
+    return `${minutes}:${this.pad(secs)}`;
+  }
+
+  private pad(num: number): string {
+    return num.toString().padStart(2, '0');
+  }
+
+  // Buffer management
+  abstract getBufferedRanges(): TimeRanges;
+  abstract getSeekableRanges(): TimeRanges;
+  
+  protected isBuffering(): boolean {
+    return this.state === PlayerState.BUFFERING;
+  }
+
+  // Network
+  abstract getBandwidth(): number;
+  abstract getNetworkState(): number;
+  
+  // Video properties
+  abstract getVideoWidth(): number;
+  abstract getVideoHeight(): number;
+  abstract getDroppedFrames(): number;
+  abstract getDecodedFrames(): number;
+}

package/packages/core/src/VideoPlayerFactory.ts

@@ -0,0 +1,145 @@
+/**
+ * Factory for creating video player instances based on platform
+ */
+
+import { IVideoPlayer, PlayerConfig } from './interfaces/IVideoPlayer';
+
+export type Platform = 
+  | 'web'
+  | 'ios' 
+  | 'android'
+  | 'tizen'
+  | 'webos'
+  | 'roku'
+  | 'androidtv'
+  | 'appletv'
+  | 'windows';
+
+export class VideoPlayerFactory {
+  /**
+   * Create a video player instance for the specified platform
+   */
+  static async create(
+    platform: Platform,
+    container: HTMLElement | string | any,
+    config?: PlayerConfig
+  ): Promise<IVideoPlayer> {
+    // Dynamic imports will be resolved at runtime
+    // This allows the factory to work even if not all platform packages are installed
+    
+    switch (platform) {
+      case 'web':
+        // Dynamic imports will be resolved at runtime when the package is available
+        try {
+          const WebModule = await (eval('import("@unified-video/web")') as Promise<any>);
+          if (WebModule?.WebPlayer) {
+            const player = new WebModule.WebPlayer();
+            await player.initialize(container, config);
+            return player;
+          }
+        } catch (e) {
+          // Package not installed or not available
+        }
+        break;
+        
+      case 'ios':
+      case 'android':
+        try {
+          const RNModule = await (eval('import("@unified-video/react-native")') as Promise<any>);
+          if (RNModule?.ReactNativePlayer) {
+            // React Native player is a component, handle differently
+            return RNModule.ReactNativePlayer;
+          }
+        } catch (e) {
+          // Package not installed or not available
+        }
+        break;
+        
+      case 'tizen':
+      case 'webos':
+        try {
+          const EnactModule = await (eval('import("@unified-video/enact")') as Promise<any>);
+          if (EnactModule?.EnactPlayer) {
+            const player = new EnactModule.EnactPlayer();
+            await player.initialize(container, config);
+            return player;
+          }
+        } catch (e) {
+          // Package not installed or not available
+        }
+        break;
+        
+      case 'roku':
+        try {
+          const RokuModule = await (eval('import("@unified-video/roku")') as Promise<any>);
+          if (RokuModule?.RokuPlayer) {
+            const player = new RokuModule.RokuPlayer();
+            await player.initialize(container, config);
+            return player;
+          }
+        } catch (e) {
+          // Package not installed or not available
+        }
+        break;
+        
+      default:
+        throw new Error(`Platform '${platform}' is not supported`);
+    }
+    
+    throw new Error(`Failed to load player for platform '${platform}'`);
+  }
+  
+  /**
+   * Detect the current platform
+   */
+  static detectPlatform(): Platform {
+    // Check if running in React Native
+    if (typeof global !== 'undefined' && (global as any).nativeCallSyncHook) {
+      // React Native environment
+      const { Platform } = require('react-native');
+      return Platform.OS as Platform;
+    }
+    
+    // Check if running in browser
+    if (typeof window !== 'undefined') {
+      const userAgent = window.navigator.userAgent.toLowerCase();
+      
+      // Check for Smart TV platforms
+      if (userAgent.includes('tizen')) return 'tizen';
+      if (userAgent.includes('webos')) return 'webos';
+      if (userAgent.includes('roku')) return 'roku';
+      
+      // Check for mobile browsers (might be Android TV)
+      if (userAgent.includes('android') && userAgent.includes('tv')) {
+        return 'androidtv';
+      }
+      
+      // Check for Apple TV
+      if (userAgent.includes('appletv')) return 'appletv';
+      
+      // Check for Windows
+      if (userAgent.includes('windows')) return 'windows';
+      
+      // Default to web
+      return 'web';
+    }
+    
+    // Check if running in Node.js (server-side)
+    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+      return 'web'; // Default to web for SSR
+    }
+    
+    throw new Error('Unable to detect platform');
+  }
+  
+  /**
+   * Create a video player for the current platform
+   */
+  static async createForCurrentPlatform(
+    container: HTMLElement | string | any,
+    config?: PlayerConfig
+  ): Promise<IVideoPlayer> {
+    const platform = this.detectPlatform();
+    return this.create(platform, container, config);
+  }
+}

package/packages/core/src/index.ts

@@ -0,0 +1,20 @@
+/**
+ * @unified-video/core
+ * Core interfaces and implementations for the Unified Video Framework
+ */
+
+// Export all interfaces
+export * from './interfaces/IVideoPlayer';
+
+// Export base classes
+export { BasePlayer } from './BasePlayer';
+
+// Export factory
+export { VideoPlayerFactory } from './VideoPlayerFactory';
+export type { Platform } from './VideoPlayerFactory';
+
+// Export utilities
+export { EventEmitter } from './utils/EventEmitter';
+
+// Export version
+export const VERSION = '1.0.0';