unified-video-framework 1.0.0

package/packages/enact/src/index.js

@@ -0,0 +1,82 @@
+/**
+ * @unified-video/enact
+ * Enact TV implementation for Samsung Tizen and LG webOS
+ */
+
+// Export main video player
+export { default as VideoPlayer } from './VideoPlayer';
+
+// Export TV-specific adapters
+export { default as TizenAdapter } from './adapters/TizenAdapter';
+
+// Export TV utilities
+export const TVUtils = {
+  /**
+   * Check if running on Samsung Tizen TV
+   */
+  isTizen: () => {
+    return typeof window !== 'undefined' && window.tizen !== undefined;
+  },
+
+  /**
+   * Check if running on LG webOS TV
+   */
+  isWebOS: () => {
+    return typeof window !== 'undefined' && window.webOS !== undefined;
+  },
+
+  /**
+   * Get TV platform info
+   */
+  getPlatformInfo: () => {
+    if (TVUtils.isTizen()) {
+      return {
+        platform: 'tizen',
+        version: window.tizen?.systeminfo?.getCapability('http://tizen.org/feature/platform.version')
+      };
+    }
+    if (TVUtils.isWebOS()) {
+      return {
+        platform: 'webos',
+        version: window.webOS?.platform?.tv?.version
+      };
+    }
+    return {
+      platform: 'unknown',
+      version: null
+    };
+  },
+
+  /**
+   * Register TV remote key handlers
+   */
+  registerRemoteKeys: () => {
+    if (TVUtils.isTizen()) {
+      // Register Tizen remote control keys
+      if (window.tizen && window.tizen.tvinputdevice) {
+        const keys = [
+          'MediaPlayPause',
+          'MediaPlay',
+          'MediaPause',
+          'MediaStop',
+          'MediaFastForward',
+          'MediaRewind'
+        ];
+        keys.forEach(key => {
+          try {
+            window.tizen.tvinputdevice.registerKey(key);
+          } catch (e) {
+            console.warn(`Failed to register key: ${key}`);
+          }
+        });
+      }
+    }
+    // webOS handles keys automatically
+  }
+};
+
+// Export version
+export const VERSION = '1.0.0';
+
+// Export platform identifier
+export const PLATFORM = 'tv';

package/packages/ios/BUILD_INSTRUCTIONS.md

@@ -0,0 +1,108 @@
+# iOS Build Instructions - Fixing Architecture Issues
+
+## Problem
+The error "UnifiedVideoPlayer.swiftmodule is not built for arm64" occurs when the framework isn't compiled for the correct architecture.
+
+## Solution
+
+### Option 1: Using Swift Package Manager (Recommended)
+
+1. In Xcode, go to **File > Add Package Dependencies**
+2. Click "Add Local..." and navigate to `/packages/ios/`
+3. Select the package and add it to your target
+4. Swift Package Manager will automatically build for the correct architecture
+
+### Option 2: Build Universal Framework
+
+1. Open Terminal and navigate to `/packages/ios/`
+2. Run the build script:
+   ```bash
+   chmod +x build_framework.sh
+   ./build_framework.sh
+   ```
+3. This will create a universal XCFramework in `Output/UnifiedVideoPlayer.xcframework`
+4. Drag the `.xcframework` into your Xcode project
+
+### Option 3: Direct Xcode Project Build
+
+1. Open `/packages/ios/UnifiedVideoPlayer.xcodeproj` in Xcode
+2. Select your target device/simulator from the scheme selector
+3. Go to **Product > Build** (⌘B)
+4. The framework will be built for the selected architecture
+
+### Option 4: Manual Architecture Configuration
+
+If you're still experiencing issues:
+
+1. In your app's Xcode project, select your target
+2. Go to **Build Settings**
+3. Search for "Architectures"
+4. Ensure these settings:
+   - **Architectures**: Standard Architectures (arm64, arm64e)
+   - **Valid Architectures**: arm64 arm64e x86_64
+   - **Build Active Architecture Only**: 
+     - Debug: Yes (for faster builds)
+     - Release: No (for distribution)
+   - **Excluded Architectures**: Leave empty or remove any entries
+
+### Architecture Reference
+
+- **arm64**: Physical iOS devices (iPhone 6s and later)
+- **arm64e**: Newer iOS devices (iPhone XS and later)
+- **x86_64**: Intel-based Mac simulators
+- **arm64** (simulator): Apple Silicon Mac simulators
+
+### Troubleshooting
+
+1. **Clean Build Folder**: Product > Clean Build Folder (⇧⌘K)
+2. **Delete Derived Data**: 
+   - Xcode > Settings > Locations
+   - Click arrow next to Derived Data path
+   - Delete the folder for your project
+3. **Reset Package Caches**: File > Packages > Reset Package Caches
+4. **Check Deployment Target**: Ensure iOS deployment target is 13.0 or higher
+
+### Using in Your Project
+
+```swift
+import UnifiedVideoPlayer
+
+struct ContentView: View {
+    var body: some View {
+        UnifiedVideoPlayerView(url: URL(string: "https://example.com/video.mp4")!)
+    }
+}
+```
+
+## Build from Command Line
+
+For CI/CD or command-line builds:
+
+```bash
+# Build for simulator
+xcodebuild -scheme UnifiedVideoPlayer \
+  -sdk iphonesimulator \
+  -configuration Release \
+  -arch x86_64 \
+  -arch arm64 \
+  build
+
+# Build for device
+xcodebuild -scheme UnifiedVideoPlayer \
+  -sdk iphoneos \
+  -configuration Release \
+  -arch arm64 \
+  build
+
+# Create XCFramework (universal)
+xcodebuild -create-xcframework \
+  -framework path/to/device.framework \
+  -framework path/to/simulator.framework \
+  -output UnifiedVideoPlayer.xcframework
+```
+
+## Notes
+
+- Always use `.xcframework` for distributing binary frameworks as it supports multiple architectures
+- When archiving for App Store, ensure "Build Active Architecture Only" is set to NO
+- For development, you can use "Build Active Architecture Only = YES" for faster builds

package/packages/ios/FIX_EMBED_ISSUE.md

@@ -0,0 +1,142 @@
+# Fix for "Library not loaded" Runtime Error
+
+## Problem
+The error `Library not loaded: @rpath/UnifiedVideoPlayer.framework/UnifiedVideoPlayer` occurs when the framework is linked but not embedded in the app bundle.
+
+## Solution Steps
+
+### Step 1: Check Framework Embedding in Xcode
+
+1. **Select your app target** in Xcode
+2. Go to **General** tab
+3. Scroll to **Frameworks, Libraries, and Embedded Content**
+4. Find `UnifiedVideoPlayer` in the list
+5. **IMPORTANT**: Change the "Embed" setting from "Do Not Embed" to **"Embed & Sign"**
+
+![Embed Setting](https://developer.apple.com/library/archive/technotes/tn2435/Art/tn2435_embed.png)
+
+### Step 2: Verify Build Phases
+
+1. Select your app target
+2. Go to **Build Phases** tab
+3. Expand **Embed Frameworks** section (create if it doesn't exist)
+4. Ensure `UnifiedVideoPlayer.framework` is listed
+5. Check "Code Sign On Copy" checkbox
+
+If the framework is missing from Embed Frameworks:
+- Click the "+" button
+- Add `UnifiedVideoPlayer.framework`
+- Enable "Code Sign On Copy"
+
+### Step 3: Clean and Rebuild
+
+```bash
+# In Xcode
+1. Product > Clean Build Folder (⇧⌘K)
+2. Close Xcode
+3. Delete DerivedData:
+   rm -rf ~/Library/Developer/Xcode/DerivedData/Flicknexs-*
+4. Reopen Xcode
+5. Product > Build (⌘B)
+```
+
+### Step 4: Alternative - Manual Framework Setup
+
+If Swift Package Manager continues to have issues, use the pre-built framework:
+
+1. Remove the Swift Package:
+   - Select your project in navigator
+   - Select project (not target) in editor
+   - Go to "Package Dependencies" tab
+   - Select UnifiedVideoPlayer and click "-" to remove
+
+2. Build the framework manually:
+   ```bash
+   cd packages/ios
+   xcodebuild -scheme UnifiedVideoPlayer \
+     -configuration Release \
+     -derivedDataPath build \
+     -arch arm64 \
+     -sdk iphoneos \
+     BUILD_LIBRARY_FOR_DISTRIBUTION=YES
+   ```
+
+3. Add the built framework:
+   - Drag `build/Build/Products/Release-iphoneos/UnifiedVideoPlayer.framework` to your project
+   - Select "Copy items if needed"
+   - Add to your app target
+   - **Set to "Embed & Sign"**
+
+### Step 5: Verify Runtime Search Paths
+
+1. Select your app target
+2. Go to **Build Settings**
+3. Search for "Runpath Search Paths"
+4. Ensure it includes:
+   ```
+   @executable_path/Frameworks
+   @loader_path/Frameworks
+   ```
+
+### Step 6: Check Code Signing
+
+1. Select your app target
+2. Go to **Signing & Capabilities**
+3. Ensure "Automatically manage signing" is enabled
+4. Or manually select your development team and provisioning profile
+
+## Quick Checklist
+
+- [ ] Framework is set to "Embed & Sign" in General > Frameworks, Libraries, and Embedded Content
+- [ ] Framework appears in Build Phases > Embed Frameworks
+- [ ] "Code Sign On Copy" is checked
+- [ ] Runtime Search Paths includes @executable_path/Frameworks
+- [ ] Clean Build Folder performed
+- [ ] DerivedData deleted
+- [ ] Code signing configured properly
+
+## If Still Not Working
+
+Try creating a simple test to verify the framework loads:
+
+```swift
+// In AppDelegate.swift or App.swift
+import UnifiedVideoPlayer
+
+func testFrameworkLoad() {
+    print("UnifiedVideoPlayer loaded successfully")
+    let player = UnifiedVideoPlayer()
+    print("Player created: \(player)")
+}
+
+// Call this in application:didFinishLaunchingWithOptions
+testFrameworkLoad()
+```
+
+## Common Causes
+
+1. **Wrong Embed Setting**: Most common - framework not set to "Embed & Sign"
+2. **Missing from Embed Frameworks**: Framework linked but not copied to app bundle
+3. **Architecture Mismatch**: Framework not built for device architecture
+4. **Code Signing Issues**: Framework not properly signed
+5. **Corrupt DerivedData**: Old build artifacts causing issues
+
+## Terminal Commands for Debugging
+
+```bash
+# Check if framework is in the app bundle (after building)
+ls -la ~/Library/Developer/Xcode/DerivedData/Flicknexs-*/Build/Products/Debug-iphoneos/Flicknexs.app/Frameworks/
+
+# Check framework architectures
+lipo -info ~/Library/Developer/Xcode/DerivedData/Flicknexs-*/Build/Products/Debug-iphoneos/PackageFrameworks/UnifiedVideoPlayer.framework/UnifiedVideoPlayer
+
+# Verify code signing
+codesign -dv ~/Library/Developer/Xcode/DerivedData/Flicknexs-*/Build/Products/Debug-iphoneos/Flicknexs.app/Frameworks/UnifiedVideoPlayer.framework
+```
+
+## Contact Support
+
+If none of these solutions work, the issue might be specific to your project configuration. Check:
+- Your minimum deployment target (should be iOS 13.0+)
+- Any custom build scripts that might interfere
+- Other third-party frameworks that might conflict

package/packages/ios/GETTING_STARTED.md

@@ -0,0 +1,100 @@
+# Getting Started with UnifiedVideoPlayer (iOS)
+
+This guide shows how to install, configure dynamic theme color, and play a video using the iOS SDK under `packages/ios`.
+
+## 1) Install the SDK
+
+- CocoaPods (public repo suggested)
+  - Ensure `UnifiedVideoPlayer.podspec` points to your Git repo + tag.
+  - Podfile:
+    ```ruby
+    platform :ios, '13.0'
+    use_frameworks!
+
+    target 'YourApp' do
+      pod 'UnifiedVideoPlayer', :git => 'https://github.com/yourcompany/unified-video-ios.git', :tag => '1.0.0'
+    end
+    ```
+  - Run `pod install`
+
+- Swift Package Manager
+  - In Xcode: File > Add Packages… > Add Local… and choose `packages/ios` or use the hosted repo URL.
+
+## 2) Enable Capabilities (recommended)
+- Background Modes: enable "Audio, AirPlay, and Picture in Picture"
+- If your DRM or CDN endpoints require it, configure ATS exceptions in your app's Info.plist.
+
+## 3) Configure Dynamic Color and Video URL
+
+Dynamic color is set via `PlayerConfiguration.themeColorHex` (supports `#RRGGBB` or `#AARRGGBB`).
+The video URL is set on `MediaSource(url:)` or by using the SwiftUI helper with a URL.
+
+### UIKit example
+```swift
+import UnifiedVideoPlayer
+
+let player = UnifiedVideoPlayer()
+let config = PlayerConfiguration()
+config.autoPlay = true
+config.themeColorHex = "#FF5722" // dynamic brand color
+
+player.initialize(container: playerContainerView, configuration: config)
+
+let source = MediaSource(url: "https://example.com/stream.m3u8")
+source.metadata = ["title": "My Demo Video"]
+// Optional DRM
+// let drm = DRMConfiguration(type: "fairplay", licenseUrl: "https://license.example.com/fps")
+// drm.certificateUrl = "https://license.example.com/cert"
+// drm.headers = ["X-Tenant-ID": "default"]
+// source.drm = drm
+
+player.load(source: source)
+```
+
+### SwiftUI example
+```swift
+import UnifiedVideoPlayer
+
+let cfg = PlayerConfiguration()
+cfg.autoPlay = true
+cfg.themeColorHex = "#4CAF50"
+
+// In your View body:
+CustomUnifiedVideoPlayer(
+  url: "https://example.com/stream.m3u8",
+  configuration: cfg
+)
+```
+
+What does the theme color affect?
+- UIKit: tint color of the default play/pause control the SDK overlays on top of the video.
+- SwiftUI: tint/accent color for control icons and sliders.
+
+## 4) Subtitles, AirPlay, PiP (optional)
+- Subtitles: provide `source.subtitles = [SubtitleTrack(...)]` (full parsing depends on your format).
+- AirPlay: use `let airPlayView = player.makeAirPlayPickerView()` and add to your UI.
+- PiP: call `player.startPictureInPicture()` and `player.stopPictureInPicture()`.
+
+## 5) FairPlay DRM (optional)
+```swift
+let drm = DRMConfiguration(type: "fairplay", licenseUrl: "https://license.example.com/fps")
+drm.certificateUrl = "https://license.example.com/cert"
+drm.headers = ["X-Tenant-ID": "default"]
+source.drm = drm
+player.load(source: source)
+```
+
+## 6) Lock Screen Controls & Background Audio
+- Enabled automatically; SDK configures AVAudioSession and Remote Command Center.
+- Provide `source.metadata["title"]` to display track title on the lock screen.
+
+## 7) Troubleshooting
+- If you see "not built for arm64": follow `BUILD_INSTRUCTIONS.md` in `packages/ios`.
+- If you get "Library not loaded": follow `FIX_EMBED_ISSUE.md` in `packages/ios`.
+
+## 8) Publishing to CocoaPods
+- Ensure `UnifiedVideoPlayer.podspec`:
+  - `s.source` points to a public Git repo URL
+  - `s.version` matches your Git tag
+- Run `pod lib lint` and `pod trunk push` as appropriate.
+

package/packages/ios/Package.swift

@@ -0,0 +1,35 @@
+// swift-tools-version:5.5
+import PackageDescription
+
+let package = Package(
+    name: "UnifiedVideoPlayer",
+    platforms: [
+        .iOS(.v13),
+        .tvOS(.v13),
+        .macCatalyst(.v13)
+    ],
+    products: [
+        .library(
+            name: "UnifiedVideoPlayer",
+            type: .dynamic,
+            targets: ["UnifiedVideoPlayer"]
+        )
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "UnifiedVideoPlayer",
+            dependencies: [],
+            path: "Sources/UnifiedVideoPlayer",
+            swiftSettings: [
+                .unsafeFlags(["-enable-library-evolution"])
+            ]
+        ),
+        .testTarget(
+            name: "UnifiedVideoPlayerTests",
+            dependencies: ["UnifiedVideoPlayer"],
+            path: "Tests/UnifiedVideoPlayerTests"
+        )
+    ],
+    swiftLanguageVersions: [.v5]
+)

package/packages/ios/README.md

@@ -0,0 +1,84 @@
+# UnifiedVideoPlayer (iOS SDK)
+
+A unified iOS video player SDK with:
+- HLS playback (AVPlayer)
+- FairPlay DRM (SPC/CKC)
+- Subtitles/audio track selection (AVMediaSelection)
+- Picture-in-Picture (AVPictureInPictureController)
+- AirPlay (AVRoutePickerView)
+- Remote Command Center + Now Playing (lock screen controls)
+- Background audio (AVAudioSession)
+
+## Installation
+
+### CocoaPods
+1) Ensure this SDK is in a public Git repository. Update the podspec `s.source` to point at that repo and tag.
+2) In your Podfile:
+```ruby
+platform :ios, '13.0'
+use_frameworks!
+
+target 'YourApp' do
+  pod 'UnifiedVideoPlayer', :git => 'https://github.com/yourcompany/unified-video-ios.git', :tag => '1.0.0'
+end
+```
+3) Run:
+```bash
+pod install
+```
+
+### Swift Package Manager
+Add the package at the repository URL or use Add Local Package pointing to `packages/ios`.
+
+## Quick Start
+```swift
+import UnifiedVideoPlayer
+
+let containerView = UIView(frame: .zero)
+let player = UnifiedVideoPlayer()
+let config = PlayerConfiguration()
+config.autoPlay = true
+
+player.initialize(container: containerView, configuration: config)
+
+let source = MediaSource(url: "https://example.com/stream.m3u8")
+source.metadata = ["title": "Demo Stream"]
+player.onReady = { print("ready") }
+player.onQualityChange = { br in print("bitrate: \(br)") }
+
+player.load(source: source)
+```
+
+### FairPlay DRM
+```swift
+let drm = DRMConfiguration(type: "fairplay", licenseUrl: "https://license.example.com/fps")
+drm.certificateUrl = "https://license.example.com/cert"
+drm.headers = ["X-Tenant-ID": "default"]
+
+let source = MediaSource(url: "https://cdn.example.com/protected/playlist.m3u8")
+source.drm = drm
+player.load(source: source)
+```
+
+### Tracks
+```swift
+let audios = player.audioTracks()      // [String]
+let subs = player.subtitleTracks()     // [String]
+player.selectAudioTrack(index: 0)
+player.selectSubtitleTrack(index: -1)  // off
+```
+
+### PiP & AirPlay
+```swift
+player.startPictureInPicture()
+player.stopPictureInPicture()
+let airPlay = player.makeAirPlayPickerView()
+```
+
+## Capabilities
+- Enable Background Modes > Audio
+- For DRM endpoints, configure ATS exceptions if necessary.
+
+## License
+MIT
+

package/packages/ios/Sources/UnifiedVideoPlayer/Analytics/AnalyticsEmitter.swift

@@ -0,0 +1,26 @@
+import Foundation
+import AVFoundation
+
+final class AnalyticsEmitter {
+    private var observer: NSObjectProtocol?
+    var onBitrate: ((Double) -> Void)?
+
+    func startObserving(item: AVPlayerItem) {
+        stopObserving()
+        observer = NotificationCenter.default.addObserver(
+            forName: .AVPlayerItemNewAccessLogEntry,
+            object: item,
+            queue: .main
+        ) { [weak self] _ in
+            guard let event = item.accessLog()?.events.last else { return }
+            let br = event.indicatedBitrate > 0 ? event.indicatedBitrate : event.observedBitrate
+            self?.onBitrate?(br)
+        }
+    }
+
+    func stopObserving() {
+        if let obs = observer { NotificationCenter.default.removeObserver(obs) }
+        observer = nil
+    }
+}
+

package/packages/ios/Sources/UnifiedVideoPlayer/DRM/FairPlayDRMManager.swift

@@ -0,0 +1,102 @@
+import Foundation
+import AVFoundation
+
+final class FairPlayDRMManager: NSObject, AVAssetResourceLoaderDelegate {
+    private let drm: DRMConfiguration
+    private var certificateData: Data?
+    private let queue = DispatchQueue(label: "uvp.fairplay")
+
+    init(drm: DRMConfiguration) {
+        self.drm = drm
+        super.init()
+    }
+
+    // MARK: AVAssetResourceLoaderDelegate
+    func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
+        queue.async { [weak self] in
+            self?.handle(loadingRequest: loadingRequest)
+        }
+        return true
+    }
+
+    func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancel loadingRequest: AVAssetResourceLoadingRequest) {
+        // No-op
+    }
+
+    private func handle(loadingRequest: AVAssetResourceLoadingRequest) {
+        guard let requestURL = loadingRequest.request.url, requestURL.scheme == "skd" else {
+            loadingRequest.finishLoading(with: NSError(domain: "UnifiedVideoPlayer.FairPlay", code: -10, userInfo: [NSLocalizedDescriptionKey: "Invalid or missing SKD URL"]))
+            return
+        }
+
+        do {
+            let cert = try fetchCertificate()
+            let contentIdData: Data
+            if let cid = requestURL.host?.data(using: .utf8) ?? requestURL.absoluteString.data(using: .utf8) {
+                contentIdData = cid
+            } else {
+                throw NSError(domain: "UnifiedVideoPlayer.FairPlay", code: -11, userInfo: [NSLocalizedDescriptionKey: "Unable to derive content ID"]) 
+            }
+
+            let spcData = try loadingRequest.streamingContentKeyRequestData(forApp: cert, contentIdentifier: contentIdData, options: nil)
+            requestCKC(spc: spcData) { [weak loadingRequest] result in
+                guard let lr = loadingRequest else { return }
+                switch result {
+                case .success(let ckc):
+                    lr.dataRequest?.respond(with: ckc)
+                    lr.finishLoading()
+                case .failure(let error):
+                    lr.finishLoading(with: error)
+                }
+            }
+        } catch {
+            loadingRequest.finishLoading(with: error)
+        }
+    }
+
+    private func fetchCertificate() throws -> Data {
+        if let cached = certificateData { return cached }
+        guard let certURLString = drm.certificateUrl, let certURL = URL(string: certURLString) else {
+            throw NSError(domain: "UnifiedVideoPlayer.FairPlay", code: -12, userInfo: [NSLocalizedDescriptionKey: "certificateUrl is missing"])
+        }
+        var request = URLRequest(url: certURL)
+        if let headers = drm.headers { headers.forEach { request.addValue($0.value, forHTTPHeaderField: $0.key) } }
+        let sem = DispatchSemaphore(value: 0)
+        var resultData: Data?
+        var resultError: Error?
+        URLSession.shared.dataTask(with: request) { data, _, error in
+            resultData = data
+            resultError = error
+            sem.signal()
+        }.resume()
+        _ = sem.wait(timeout: .now() + 30)
+        if let e = resultError { throw e }
+        guard let data = resultData else {
+            throw NSError(domain: "UnifiedVideoPlayer.FairPlay", code: -13, userInfo: [NSLocalizedDescriptionKey: "Empty certificate response"]) 
+        }
+        certificateData = data
+        return data
+    }
+
+    private func requestCKC(spc: Data, completion: @escaping (Result<Data, Error>) -> Void) {
+        guard let licenseURL = URL(string: drm.licenseUrl) else {
+            completion(.failure(NSError(domain: "UnifiedVideoPlayer.FairPlay", code: -14, userInfo: [NSLocalizedDescriptionKey: "Invalid licenseUrl"])) )
+            return
+        }
+        var request = URLRequest(url: licenseURL)
+        request.httpMethod = "POST"
+        request.addValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
+        if let headers = drm.headers { headers.forEach { request.addValue($0.value, forHTTPHeaderField: $0.key) } }
+        request.httpBody = spc
+
+        URLSession.shared.dataTask(with: request) { data, _, error in
+            if let e = error { completion(.failure(e)); return }
+            guard let data = data else {
+                completion(.failure(NSError(domain: "UnifiedVideoPlayer.FairPlay", code: -15, userInfo: [NSLocalizedDescriptionKey: "Empty CKC response"])) )
+                return
+            }
+            completion(.success(data))
+        }.resume()
+    }
+}
+