unified-video-framework 1.0.0

package/iOS_IMPLEMENTATION_OPTIONS.md

@@ -0,0 +1,470 @@
+# 📱 iOS Implementation Options for Unified Video Framework
+
+You have **5 different ways** to implement the video player on iOS, depending on your project requirements:
+
+## 1. ✅ Native iOS (Pure Swift/Objective-C)
+**Best for:** Native iOS apps, maximum performance, full platform control
+
+### Swift Implementation
+```swift
+// VideoPlayerViewController.swift
+import UIKit
+import AVFoundation
+import AVKit
+
+class VideoPlayerViewController: UIViewController {
+    private var player: AVPlayer?
+    private var playerLayer: AVPlayerLayer?
+    private var playerViewController: AVPlayerViewController?
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupPlayer()
+    }
+    
+    private func setupPlayer() {
+        // Initialize player with URL
+        guard let url = URL(string: "https://example.com/video.m3u8") else { return }
+        
+        player = AVPlayer(url: url)
+        
+        // Option 1: Custom player view
+        playerLayer = AVPlayerLayer(player: player)
+        playerLayer?.frame = view.bounds
+        playerLayer?.videoGravity = .resizeAspect
+        view.layer.addSublayer(playerLayer!)
+        
+        // Option 2: Using AVPlayerViewController
+        // playerViewController = AVPlayerViewController()
+        // playerViewController?.player = player
+        // present(playerViewController!, animated: true) {
+        //     self.player?.play()
+        // }
+        
+        // Add controls
+        addCustomControls()
+        
+        // Start playback
+        player?.play()
+    }
+    
+    private func addCustomControls() {
+        // Add play/pause button
+        let playButton = UIButton(frame: CGRect(x: 20, y: view.bounds.height - 100, width: 60, height: 60))
+        playButton.setTitle("▶️", for: .normal)
+        playButton.addTarget(self, action: #selector(togglePlayPause), for: .touchUpInside)
+        view.addSubview(playButton)
+        
+        // Add progress slider
+        let slider = UISlider(frame: CGRect(x: 100, y: view.bounds.height - 80, width: view.bounds.width - 120, height: 40))
+        slider.addTarget(self, action: #selector(sliderValueChanged(_:)), for: .valueChanged)
+        view.addSubview(slider)
+    }
+    
+    @objc private func togglePlayPause() {
+        if player?.rate == 0 {
+            player?.play()
+        } else {
+            player?.pause()
+        }
+    }
+    
+    @objc private func sliderValueChanged(_ slider: UISlider) {
+        let seconds = Double(slider.value) * (player?.currentItem?.duration.seconds ?? 0)
+        let time = CMTime(seconds: seconds, preferredTimescale: 1000)
+        player?.seek(to: time)
+    }
+}
+```
+
+### Objective-C Implementation
+```objc
+// VideoPlayerViewController.m
+#import <AVFoundation/AVFoundation.h>
+#import <AVKit/AVKit.h>
+
+@interface VideoPlayerViewController ()
+@property (nonatomic, strong) AVPlayer *player;
+@property (nonatomic, strong) AVPlayerLayer *playerLayer;
+@end
+
+@implementation VideoPlayerViewController
+
+- (void)viewDidLoad {
+    [super viewDidLoad];
+    [self setupPlayer];
+}
+
+- (void)setupPlayer {
+    NSURL *videoURL = [NSURL URLWithString:@"https://example.com/video.m3u8"];
+    self.player = [AVPlayer playerWithURL:videoURL];
+    
+    self.playerLayer = [AVPlayerLayer playerLayerWithPlayer:self.player];
+    self.playerLayer.frame = self.view.bounds;
+    self.playerLayer.videoGravity = AVLayerVideoGravityResizeAspect;
+    [self.view.layer addSublayer:self.playerLayer];
+    
+    [self.player play];
+}
+
+@end
+```
+
+### Installation Steps:
+```bash
+# No additional dependencies needed - uses native iOS frameworks
+# Simply add to your Xcode project
+```
+
+---
+
+## 2. 🌐 WebView Implementation
+**Best for:** Web-based content, existing web player, hybrid apps
+
+```swift
+// WebViewPlayerViewController.swift
+import UIKit
+import WebKit
+
+class WebViewPlayerViewController: UIViewController, WKNavigationDelegate {
+    private var webView: WKWebView!
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupWebView()
+        loadVideoPlayer()
+    }
+    
+    private func setupWebView() {
+        let configuration = WKWebViewConfiguration()
+        configuration.allowsInlineMediaPlayback = true
+        configuration.mediaTypesRequiringUserActionForPlayback = []
+        
+        webView = WKWebView(frame: view.bounds, configuration: configuration)
+        webView.navigationDelegate = self
+        view.addSubview(webView)
+    }
+    
+    private func loadVideoPlayer() {
+        // Option 1: Load remote player
+        if let url = URL(string: "https://yoursite.com/player.html") {
+            webView.load(URLRequest(url: url))
+        }
+        
+        // Option 2: Load local HTML
+        let html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <style>
+                body { margin: 0; padding: 0; }
+                video { width: 100%; height: 100vh; }
+            </style>
+        </head>
+        <body>
+            <video controls autoplay>
+                <source src="https://example.com/video.mp4" type="video/mp4">
+            </video>
+            <script src="unified-video-web.js"></script>
+            <script>
+                const player = new UnifiedVideoPlayer();
+                player.initialize('video');
+            </script>
+        </body>
+        </html>
+        """
+        webView.loadHTMLString(html, baseURL: nil)
+    }
+}
+```
+
+---
+
+## 3. 🎭 React Native Implementation
+**Best for:** Cross-platform apps, JavaScript developers, code reuse
+
+```jsx
+// Already covered in your example
+// This is useful when you want to share code between iOS and Android
+```
+
+---
+
+## 4. 🔥 Flutter Implementation
+**Best for:** Cross-platform with Dart, Material Design, high performance
+
+```dart
+// VideoPlayerScreen.dart
+import 'package:flutter/material.dart';
+import 'package:video_player/video_player.dart';
+import 'package:chewie/chewie.dart';
+
+class VideoPlayerScreen extends StatefulWidget {
+  @override
+  _VideoPlayerScreenState createState() => _VideoPlayerScreenState();
+}
+
+class _VideoPlayerScreenState extends State<VideoPlayerScreen> {
+  VideoPlayerController? _videoPlayerController;
+  ChewieController? _chewieController;
+
+  @override
+  void initState() {
+    super.initState();
+    initializePlayer();
+  }
+
+  Future<void> initializePlayer() async {
+    _videoPlayerController = VideoPlayerController.network(
+      'https://example.com/video.m3u8',
+    );
+
+    await _videoPlayerController!.initialize();
+
+    _chewieController = ChewieController(
+      videoPlayerController: _videoPlayerController!,
+      autoPlay: true,
+      looping: false,
+      showControls: true,
+      materialProgressColors: ChewieProgressColors(
+        playedColor: Colors.red,
+        handleColor: Colors.blue,
+        backgroundColor: Colors.grey,
+        bufferedColor: Colors.lightGreen,
+      ),
+    );
+
+    setState(() {});
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text('Video Player')),
+      body: Center(
+        child: _chewieController != null
+            ? Chewie(controller: _chewieController!)
+            : CircularProgressIndicator(),
+      ),
+    );
+  }
+
+  @override
+  void dispose() {
+    _videoPlayerController?.dispose();
+    _chewieController?.dispose();
+    super.dispose();
+  }
+}
+```
+
+### Installation:
+```yaml
+# pubspec.yaml
+dependencies:
+  video_player: ^2.7.0
+  chewie: ^1.7.0
+```
+
+---
+
+## 5. 🏗️ Unity Implementation
+**Best for:** Games, 3D apps, AR/VR experiences
+
+```csharp
+// VideoPlayerController.cs
+using UnityEngine;
+using UnityEngine.Video;
+
+public class VideoPlayerController : MonoBehaviour
+{
+    private VideoPlayer videoPlayer;
+    private RenderTexture renderTexture;
+
+    void Start()
+    {
+        // Create VideoPlayer component
+        videoPlayer = gameObject.AddComponent<VideoPlayer>();
+        
+        // Set video URL
+        videoPlayer.url = "https://example.com/video.mp4";
+        
+        // Configure player
+        videoPlayer.playOnAwake = false;
+        videoPlayer.renderMode = VideoRenderMode.RenderTexture;
+        
+        // Create render texture
+        renderTexture = new RenderTexture(1920, 1080, 16);
+        videoPlayer.targetTexture = renderTexture;
+        
+        // Apply to UI or 3D object
+        GetComponent<Renderer>().material.mainTexture = renderTexture;
+        
+        // Play video
+        videoPlayer.Play();
+    }
+
+    public void PlayPause()
+    {
+        if (videoPlayer.isPlaying)
+            videoPlayer.Pause();
+        else
+            videoPlayer.Play();
+    }
+}
+```
+
+---
+
+## 📊 Comparison Matrix
+
+| Feature | Native iOS | WebView | React Native | Flutter | Unity |
+|---------|-----------|---------|--------------|---------|--------|
+| **Performance** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ |
+| **Development Speed** | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
+| **Cross-Platform** | ❌ | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
+| **Native Features** | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
+| **Custom UI** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
+| **DRM Support** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
+| **Learning Curve** | Medium | Easy | Medium | Medium | Hard |
+| **App Size** | Small | Small | Large | Medium | Large |
+
+---
+
+## 🎯 When to Use Each Approach
+
+### Choose **Native iOS** if:
+- ✅ Building iOS-only app
+- ✅ Need maximum performance
+- ✅ Require deep iOS integration
+- ✅ Want smallest app size
+- ✅ Need advanced DRM (FairPlay)
+
+### Choose **WebView** if:
+- ✅ Already have web player
+- ✅ Want quick implementation
+- ✅ Need to maintain single codebase
+- ✅ Content is web-based
+
+### Choose **React Native** if:
+- ✅ Building for iOS and Android
+- ✅ Team knows JavaScript/React
+- ✅ Want to share code between platforms
+- ✅ Need hot reload for development
+
+### Choose **Flutter** if:
+- ✅ Want beautiful UI out of the box
+- ✅ Building for multiple platforms
+- ✅ Team knows Dart
+- ✅ Need high performance cross-platform
+
+### Choose **Unity** if:
+- ✅ Building game or 3D app
+- ✅ Need AR/VR features
+- ✅ Want 360° video support
+- ✅ Already using Unity
+
+---
+
+## 🚀 Quick Start Commands
+
+### Native iOS (Swift)
+```bash
+# Create new Xcode project
+# File > New > Project > iOS App
+# Add VideoPlayerViewController.swift to project
+```
+
+### WebView
+```bash
+# Add to existing iOS project
+# No additional setup needed
+```
+
+### React Native
+```bash
+npx react-native init VideoApp
+cd VideoApp
+npm install react-native-video
+cd ios && pod install
+npx react-native run-ios
+```
+
+### Flutter
+```bash
+flutter create video_app
+cd video_app
+flutter pub add video_player chewie
+flutter run
+```
+
+### Unity
+```bash
+# Download Unity Hub
+# Create new 3D project
+# Import Video Player package
+```
+
+---
+
+## 📦 Framework Integration
+
+To integrate the Unified Video Framework with any of these approaches:
+
+### 1. Native iOS Integration
+```swift
+// UnifiedVideoPlayer.swift
+import UnifiedVideoCore
+
+class UnifiedVideoPlayer {
+    private let corePlayer = UnifiedCore.Player()
+    
+    func initialize(view: UIView) {
+        corePlayer.attachToView(view)
+    }
+    
+    func load(url: String) {
+        corePlayer.load(MediaSource(url: url))
+    }
+}
+```
+
+### 2. Bridge Pattern for Cross-Platform
+```swift
+// UnifiedVideoBridge.swift
+@objc(UnifiedVideoBridge)
+class UnifiedVideoBridge: NSObject {
+    @objc func initialize(_ config: [String: Any]) {
+        // Initialize core player
+    }
+    
+    @objc func load(_ source: [String: Any]) {
+        // Load video source
+    }
+}
+```
+
+---
+
+## 💡 Best Practices
+
+1. **For Enterprise Apps**: Use Native iOS for best control
+2. **For Startups**: Use React Native or Flutter for faster time-to-market
+3. **For Media Companies**: Native iOS with custom controls
+4. **For Education/Training**: WebView for easy content updates
+5. **For Gaming**: Unity with video textures
+
+---
+
+## 📚 Additional Resources
+
+- [AVFoundation Documentation](https://developer.apple.com/av-foundation/)
+- [React Native Video](https://github.com/react-native-video/react-native-video)
+- [Flutter Video Player](https://pub.dev/packages/video_player)
+- [Unity Video Player](https://docs.unity3d.com/Manual/VideoPlayer.html)
+- [WKWebView Guide](https://developer.apple.com/documentation/webkit/wkwebview)
+
+---
+
+Choose the approach that best fits your project requirements, team expertise, and timeline!

package/ios/UnifiedVideoPlayer/UnifiedVideoPlayer.podspec

@@ -0,0 +1,33 @@
+Pod::Spec.new do |s|
+  s.name             = 'UnifiedVideoPlayer'
+  s.version          = '0.1.0'
+  s.summary          = 'Unified video player SDK for iOS (HLS, FairPlay DRM, PiP, AirPlay, Remote Command Center).'
+  s.description      = <<-DESC
+A unified, embeddable iOS video player SDK powered by AVPlayer.
+Features:
+- HLS playback with robust event API
+- Subtitles/audio track selection
+- Picture-in-Picture and AirPlay support
+- FairPlay DRM (SPC/CKC) integration hooks
+- Remote Command Center & Now Playing
+- Background audio
+DESC
+  s.homepage         = 'https://github.com/your-org/unified-video-framework'
+  s.license          = { :type => 'MIT' }
+  s.author           = { 'Your Company' => 'support@example.com' }
+  s.source           = { :git => 'https://github.com/your-org/unified-video-framework-ios.git', :tag => s.version.to_s }
+  s.platform         = :ios, '12.0'
+  s.swift_version    = '5.8'
+
+  # This podspec lives next to the Sources directory
+  s.source_files = 'Sources/**/*.{swift,h,m}'
+
+  s.frameworks = 'AVFoundation', 'AVKit', 'MediaPlayer'
+  s.requires_arc = true
+
+  s.pod_target_xcconfig = {
+    'OTHER_SWIFT_FLAGS' => '$(inherited) -DUNIFIED_VIDEO_PLAYER',
+    'SWIFT_OPTIMIZATION_LEVEL' => '$(inherited)'
+  }
+end
+

package/jest.config.js

@@ -0,0 +1,33 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'jsdom',
+  roots: ['<rootDir>/packages'],
+  testMatch: [
+    '**/__tests__/**/*.+(ts|tsx|js)',
+    '**/?(*.)+(spec|test).+(ts|tsx|js)'
+  ],
+  transform: {
+    '^.+\\.(ts|tsx)$': 'ts-jest'
+  },
+  collectCoverageFrom: [
+    'packages/*/src/**/*.{ts,tsx}',
+    '!packages/*/src/**/*.d.ts',
+    '!packages/*/src/**/index.ts',
+    '!packages/*/src/**/*.stories.tsx'
+  ],
+  moduleNameMapper: {
+    '@unified-video/core': '<rootDir>/packages/core/src',
+    '@unified-video/web': '<rootDir>/packages/web/src',
+    '@unified-video/react-native': '<rootDir>/packages/react-native/src',
+    '@unified-video/enact': '<rootDir>/packages/enact/src',
+    '@unified-video/roku': '<rootDir>/packages/roku/src'
+  },
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 70,
+      lines: 70,
+      statements: 70
+    }
+  }
+};

package/jitpack.yml

@@ -0,0 +1,5 @@
+jdk:
+  - openjdk17
+install:
+  - gradle -p packages/android clean publishToMavenLocal
+

package/lerna.json

@@ -0,0 +1,35 @@
+{
+  "version": "1.0.0",
+  "npmClient": "npm",
+  "packages": [
+    "packages/*",
+    "apps/*"
+  ],
+  "command": {
+    "bootstrap": {
+      "hoist": true,
+      "noCi": false,
+      "npmClientArgs": ["--no-package-lock"]
+    },
+    "publish": {
+      "conventionalCommits": true,
+      "message": "chore(release): publish %v",
+      "registry": "https://registry.npmjs.org",
+      "allowBranch": ["main", "master"]
+    },
+    "version": {
+      "allowBranch": ["main", "master"],
+      "conventionalCommits": true,
+      "createRelease": "github",
+      "exact": false,
+      "message": "chore(release): version %v"
+    }
+  },
+  "ignoreChanges": [
+    "**/dist/**",
+    "**/node_modules/**",
+    "**/test/**",
+    "**/*.md",
+    "**/package-lock.json"
+  ]
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "unified-video-framework",
+  "version": "1.0.0",
+  "description": "Cross-platform video player framework supporting iOS, Android, Web, Smart TVs (Samsung/LG), Roku, and more",
+  "private": false,
+  "workspaces": [
+    "packages/*",
+    "apps/*",
+    "tools/*"
+  ],
+  "scripts": {
+    "postinstall": "npm run build:core",
+    "bootstrap": "lerna bootstrap --legacy-peer-deps",
+    "build": "npm run build:core && npm run build:web && npm run build:rental-api",
+    "build:core": "cd packages/core && npm run build",
+    "build:web": "cd packages/web && npm run build",
+    "build:rental-api": "cd apps/rental-api && npm run build",
+    "start:rental-api": "cd apps/rental-api && npm start",
+    "dev:rental-api": "cd apps/rental-api && npm run dev",
+    "build:react-native": "cd packages/react-native && npm run build",
+    "build:enact": "cd packages/enact && npm run build",
+    "build:all": "lerna run build --stream",
+    "clean": "lerna clean",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "lint": "eslint . --ext .ts,.tsx,.js,.jsx",
+    "type-check": "tsc --noEmit",
+    "publish": "lerna publish",
+    "dev": "lerna run dev --parallel",
+    "serve:demo": "node server.js",
+    "docs": "typedoc --out docs packages/core/src"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.70.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.0.0",
+    "lerna": "^6.0.0",
+    "prettier": "^2.8.0",
+    "typescript": "^4.9.0",
+    "typedoc": "^0.23.0",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/your-org/unified-video-framework.git"
+  },
+  "keywords": [
+    "video",
+    "player",
+    "streaming",
+    "cross-platform",
+    "react-native",
+    "enact",
+    "smart-tv",
+    "tizen",
+    "webos",
+    "roku",
+    "drm",
+    "hls",
+    "dash"
+  ],
+  "author": "Your Company",
+  "license": "MIT"
+}