unified-video-framework 1.0.0

package/packages/PLATFORM_STATUS.md

@@ -0,0 +1,163 @@
+# Platform Implementation Status
+
+## Overview
+The Unified Video Framework is designed as a modular, extensible system where each platform has its own implementation package that conforms to the core interfaces.
+
+## Implementation Status
+
+### ✅ Fully Implemented
+
+#### 1. **Core** (`packages/core`)
+- **Status**: Complete
+- **Purpose**: Defines interfaces and factory pattern
+- **Files**: 
+  - `interfaces.ts` - TypeScript interfaces for all platforms
+  - `PlayerFactory.ts` - Factory pattern for creating platform-specific players
+  - `VideoPlayer.ts` - Base implementation
+
+#### 2. **Web** (`packages/web`)
+- **Status**: Complete
+- **Purpose**: Browser-based video playback
+- **Technology**: HTML5 Video API, HLS.js, dash.js
+- **Files**:
+  - `HTML5Player.ts` - TypeScript implementation
+  - `SimpleHTML5Player.js` - JavaScript implementation
+- **Demo**: Available at `/apps/demo/demo.html`
+
+#### 3. **Enact** (`packages/enact`)
+- **Status**: Complete (Adapter layer)
+- **Purpose**: Samsung Tizen and LG webOS Smart TVs
+- **Technology**: Enact framework
+- **Files**:
+  - `TizenAdapter.js` - TV-specific adaptations
+- **Note**: Uses web player with TV-specific enhancements
+
+### ⏳ Planned Implementations
+
+#### 4. **React Native** (`packages/react-native`)
+- **Status**: Placeholder created
+- **Purpose**: iOS and Android mobile apps
+- **Technology Stack**:
+  - React Native
+  - react-native-video library
+  - Native players (AVPlayer for iOS, ExoPlayer for Android)
+- **Why Not Implemented**: 
+  - Requires React Native development environment
+  - Needs platform-specific native code
+  - Different build toolchain
+
+#### 5. **Roku** (`packages/roku`)
+- **Status**: Placeholder created
+- **Purpose**: Roku streaming devices
+- **Technology Stack**:
+  - BrightScript programming language
+  - SceneGraph framework
+  - Roku SDK
+- **Why Not Implemented**:
+  - Completely different programming paradigm
+  - Requires Roku developer account
+  - Specific deployment process
+
+## Why This Architecture?
+
+### 1. **Separation of Concerns**
+Each platform has unique requirements:
+- **Web**: Runs in browser sandbox
+- **Mobile**: Native performance requirements
+- **TV**: Remote control navigation
+- **Roku**: BrightScript language
+
+### 2. **Maintainability**
+- Platform-specific bugs isolated
+- Teams can work independently
+- Updates don't affect other platforms
+
+### 3. **Scalability**
+Easy to add new platforms:
+```
+packages/
+  ├── apple-tv/       # Future: tvOS support
+  ├── android-tv/     # Future: Android TV native
+  ├── xbox/           # Future: Xbox apps
+  └── playstation/    # Future: PlayStation apps
+```
+
+## How to Add a New Platform
+
+1. **Create Package Directory**
+```bash
+mkdir packages/[platform-name]
+cd packages/[platform-name]
+npm init
+```
+
+2. **Implement Core Interface**
+```typescript
+import { VideoPlayerInterface } from '../core/src/interfaces';
+
+export class PlatformVideoPlayer implements VideoPlayerInterface {
+  // Implement all required methods
+}
+```
+
+3. **Register with Factory**
+```typescript
+// In core/src/PlayerFactory.ts
+import { PlatformVideoPlayer } from '../platform-name';
+
+PlayerFactory.register('platform-name', PlatformVideoPlayer);
+```
+
+4. **Create Demo App**
+```bash
+mkdir apps/platform-demo
+# Add platform-specific demo
+```
+
+## Development Priorities
+
+### Phase 1 (Complete) ✅
+- Core architecture
+- Web implementation
+- Basic TV support
+
+### Phase 2 (Current) 🚧
+- Enhanced streaming support
+- Demo applications
+- Documentation
+
+### Phase 3 (Future) 📅
+- React Native implementation
+- Roku implementation
+- Additional TV platforms
+
+### Phase 4 (Long-term) 🔮
+- Gaming consoles
+- Desktop native apps
+- WebRTC support
+
+## Required Development Environments
+
+### For React Native
+- Node.js 14+
+- React Native CLI
+- Xcode (for iOS)
+- Android Studio (for Android)
+- Physical devices or emulators
+
+### For Roku
+- Roku SDK
+- Roku developer account
+- Roku device in developer mode
+- Eclipse IDE (optional)
+
+### For Smart TVs
+- Tizen Studio (Samsung)
+- webOS SDK (LG)
+- TV emulators or physical TVs
+
+## Conclusion
+
+The empty directories represent the framework's extensibility and future growth potential. The architecture is designed to accommodate any video-capable platform while maintaining a consistent API across all implementations.
+
+Currently, the **web implementation is fully functional** and serves as the reference implementation for other platforms. The demo at `/apps/demo/demo.html` showcases the complete feature set that other platforms should implement.

package/packages/android/build.gradle

@@ -0,0 +1,135 @@
+buildscript {
+    ext.kotlin_version = '1.9.24'
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+group = project.findProperty('GROUP') ?: System.getenv('GROUP') ?: 'com.github.Webnexs'
+version = project.findProperty('VERSION') ?: System.getenv('VERSION') ?: '1.0.0'
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+android {
+    compileSdk 34
+    
+    defaultConfig {
+        minSdk 21
+        targetSdk 34
+        versionCode 1
+        versionName "1.0.0"
+        
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles "consumer-rules.pro"
+    }
+    
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+    
+    buildFeatures {
+        viewBinding true
+    }
+    
+    namespace 'com.unifiedvideo.player'
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    // ExoPlayer
+    implementation 'com.google.android.exoplayer:exoplayer:2.19.1'
+    implementation 'com.google.android.exoplayer:exoplayer-hls:2.19.1'
+    implementation 'com.google.android.exoplayer:exoplayer-dash:2.19.1'
+    implementation 'com.google.android.exoplayer:exoplayer-smoothstreaming:2.19.1'
+    implementation 'com.google.android.exoplayer:extension-okhttp:2.19.1'
+    
+    // UI Components
+    implementation 'com.google.android.exoplayer:exoplayer-ui:2.19.1'
+    
+    // DRM Support
+    implementation 'com.google.android.exoplayer:extension-drm:2.19.1'
+
+    // Google Cast (sender)
+    implementation 'com.google.android.gms:play-services-cast-framework:21.4.0'
+    
+    // Kotlin
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    
+    // AndroidX
+    implementation 'androidx.core:core-ktx:1.12.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'com.google.android.material:material:1.11.0'
+    implementation 'androidx.mediarouter:mediarouter:1.6.0'
+    implementation 'androidx.media:media:1.6.0'
+    
+    // Testing
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
+}
+
+// Maven Publishing
+afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                from components.release
+
+                groupId = project.group
+                artifactId = 'unifiedvideo-player'
+                version = project.version
+
+                pom {
+                    name = 'Unified Video Player'
+                    description = 'Unified video player SDK for Android'
+                    url = 'https://github.com/Webnexs/unified-video-framework'
+                    licenses {
+                        license {
+                            name = 'MIT License'
+                            url = 'https://opensource.org/licenses/MIT'
+                        }
+                    }
+                }
+            }
+        }
+        // Optional: Only publish to GitHub Packages if credentials are provided (prevents JitPack failures)
+        if (project.hasProperty('github.user') && project.hasProperty('github.token')) {
+            repositories {
+                maven {
+                    name = "GitHubPackages"
+                    url = uri("https://maven.pkg.github.com/yourcompany/unified-video-android")
+                    credentials {
+                        username = project.findProperty("github.user")
+                        password = project.findProperty("github.token")
+                    }
+                }
+            }
+        }
+    }
+}
+
+tasks.register('install') { dependsOn('publishToMavenLocal') }

package/packages/android/src/main/AndroidManifest.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.unifiedvideo.player">
+    
+    <!-- Permissions -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    
+    <!-- Optional permissions for background playback -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    
+    <application>
+        <!-- Background playback service (optional) -->
+        <service 
+            android:name=".services.PlaybackService"
+            android:exported="false"
+            android:foregroundServiceType="mediaPlayback" />
+
+        <!-- PiP Action Receiver -->
+        <receiver
+            android:name=".pip.PipActionReceiver"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.unifiedvideo.player.ACTION_PLAY" />
+                <action android:name="com.unifiedvideo.player.ACTION_PAUSE" />
+            </intent-filter>
+        </receiver>
+
+        <!-- Google Cast Framework options provider (sender SDK) -->
+        <meta-data
+            android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+            android:value="com.unifiedvideo.player.cast.CastOptionsProvider" />
+    </application>
+    
+</manifest>

package/packages/android/src/main/java/com/unifiedvideo/player/PlayerConfiguration.java

@@ -0,0 +1,221 @@
+/**
+ * PlayerConfiguration.java
+ * Player configuration for UnifiedVideoPlayer
+ */
+
+package com.unifiedvideo.player;
+
+/**
+ * Player configuration class
+ */
+public class PlayerConfiguration {
+    public final boolean autoPlay;
+    public final boolean controls;
+    public final boolean muted;
+    public final boolean loop;
+    public final String preload;
+    public final long startTime;
+    public final float playbackSpeed;
+    public final float volume;
+    public final boolean debug;
+    public final boolean useStyledControls;
+    public final boolean allowBackgroundPlayback;
+
+    private PlayerConfiguration(Builder builder) {
+        this.autoPlay = builder.autoPlay;
+        this.controls = builder.controls;
+        this.muted = builder.muted;
+        this.loop = builder.loop;
+        this.preload = builder.preload;
+        this.startTime = builder.startTime;
+        this.playbackSpeed = builder.playbackSpeed;
+        this.volume = builder.volume;
+        this.debug = builder.debug;
+        this.useStyledControls = builder.useStyledControls;
+        this.allowBackgroundPlayback = builder.allowBackgroundPlayback;
+    }
+
+    /**
+     * Builder class for PlayerConfiguration
+     */
+    public static class Builder {
+        private boolean autoPlay = false;
+        private boolean controls = true;
+        private boolean muted = false;
+        private boolean loop = false;
+        private String preload = "auto";
+        private long startTime = 0;
+        private float playbackSpeed = 1.0f;
+        private float volume = 1.0f;
+        private boolean debug = false;
+        private boolean useStyledControls = true;
+        private boolean allowBackgroundPlayback = false;
+
+        public Builder() {
+        }
+
+        public Builder setAutoPlay(boolean autoPlay) {
+            this.autoPlay = autoPlay;
+            return this;
+        }
+
+        public Builder setControls(boolean controls) {
+            this.controls = controls;
+            return this;
+        }
+
+        public Builder setMuted(boolean muted) {
+            this.muted = muted;
+            return this;
+        }
+
+        public Builder setLoop(boolean loop) {
+            this.loop = loop;
+            return this;
+        }
+
+        public Builder setPreload(String preload) {
+            this.preload = preload;
+            return this;
+        }
+
+        public Builder setStartTime(long startTime) {
+            this.startTime = startTime;
+            return this;
+        }
+
+        public Builder setPlaybackSpeed(float speed) {
+            this.playbackSpeed = speed;
+            return this;
+        }
+
+        public Builder setVolume(float volume) {
+            this.volume = volume;
+            return this;
+        }
+
+        public Builder setDebug(boolean debug) {
+            this.debug = debug;
+            return this;
+        }
+
+        public Builder setUseStyledControls(boolean styled) {
+            this.useStyledControls = styled;
+            return this;
+        }
+
+        public Builder setAllowBackgroundPlayback(boolean allow) {
+            this.allowBackgroundPlayback = allow;
+            return this;
+        }
+
+        public PlayerConfiguration build() {
+            return new PlayerConfiguration(this);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "PlayerConfiguration{" +
+                "autoPlay=" + autoPlay +
+                ", controls=" + controls +
+                ", muted=" + muted +
+                ", loop=" + loop +
+                ", preload='" + preload + '\'' +
+                ", startTime=" + startTime +
+                ", playbackSpeed=" + playbackSpeed +
+                ", volume=" + volume +
+                ", debug=" + debug +
+                ", useStyledControls=" + useStyledControls +
+                ", allowBackgroundPlayback=" + allowBackgroundPlayback +
+                '}';
+    }
+}
+
+/**
+ * Media source information class
+ */
+class MediaSourceInfo {
+    public final String url;
+    public final String type;
+    public final DRMConfiguration drm;
+    public final java.util.Map<String, Object> metadata;
+    public final java.util.List<SubtitleTrack> subtitles;
+
+    public MediaSourceInfo(String url) {
+        this(url, detectType(url), null, null, null);
+    }
+
+    public MediaSourceInfo(String url, String type) {
+        this(url, type, null, null, null);
+    }
+
+    public MediaSourceInfo(String url, String type, DRMConfiguration drm, 
+                          java.util.Map<String, Object> metadata, 
+                          java.util.List<SubtitleTrack> subtitles) {
+        this.url = url;
+        this.type = type;
+        this.drm = drm;
+        this.metadata = metadata;
+        this.subtitles = subtitles;
+    }
+
+    public static String detectType(String url) {
+        if (url.contains(".m3u8")) return "hls";
+        if (url.contains(".mpd")) return "dash";
+        if (url.contains(".ism")) return "smoothstreaming";
+        if (url.contains(".mp4")) return "mp4";
+        if (url.contains(".webm")) return "webm";
+        if (url.contains(".mkv")) return "mkv";
+        return "mp4";
+    }
+}
+
+/**
+ * DRM configuration class
+ */
+class DRMConfiguration {
+    public final String type; // widevine, playready, clearkey
+    public final String licenseUrl;
+    public final java.util.Map<String, String> headers;
+    public final boolean multiSession;
+    public final boolean forceDefaultLicenseUri;
+
+    public DRMConfiguration(String type, String licenseUrl) {
+        this(type, licenseUrl, null, false, false);
+    }
+
+    public DRMConfiguration(String type, String licenseUrl, 
+                           java.util.Map<String, String> headers,
+                           boolean multiSession, 
+                           boolean forceDefaultLicenseUri) {
+        this.type = type;
+        this.licenseUrl = licenseUrl;
+        this.headers = headers;
+        this.multiSession = multiSession;
+        this.forceDefaultLicenseUri = forceDefaultLicenseUri;
+    }
+}
+
+/**
+ * Subtitle track class
+ */
+class SubtitleTrack {
+    public final String url;
+    public final String language;
+    public final String label;
+    public final String kind; // subtitles, captions
+    public final String mimeType;
+
+    public SubtitleTrack(String url, String language, String label) {
+        this(url, language, label, "subtitles", "text/vtt");
+    }
+
+    public SubtitleTrack(String url, String language, String label, String kind, String mimeType) {
+        this.url = url;
+        this.language = language;
+        this.label = label;
+        this.kind = kind;
+        this.mimeType = mimeType;
+    }
+}