unified-video-framework 1.0.0

package/examples/ios/SampleApp/ViewController.swift

@@ -0,0 +1,337 @@
+//
+//  ViewController.swift
+//  UnifiedVideoPlayer Sample App
+//
+//  Example of integrating UnifiedVideoPlayer into an existing iOS app
+//
+
+import UIKit
+import UnifiedVideoPlayer
+
+class ViewController: UIViewController {
+    
+    // MARK: - IBOutlets
+    @IBOutlet weak var playerContainer: UIView!
+    @IBOutlet weak var playPauseButton: UIButton!
+    @IBOutlet weak var progressSlider: UISlider!
+    @IBOutlet weak var currentTimeLabel: UILabel!
+    @IBOutlet weak var durationLabel: UILabel!
+    @IBOutlet weak var volumeSlider: UISlider!
+    @IBOutlet weak var loadingIndicator: UIActivityIndicatorView!
+    @IBOutlet weak var errorLabel: UILabel!
+    
+    // MARK: - Properties
+    private var videoPlayer: UnifiedVideoPlayer!
+    private var isSliderTracking = false
+    
+    // Sample video URLs
+    private let sampleVideos = [
+        "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4",
+        "https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_fmp4/master.m3u8",
+        "https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8"
+    ]
+    
+    // MARK: - Lifecycle
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupUI()
+        setupVideoPlayer()
+        loadSampleVideo()
+    }
+    
+    override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        videoPlayer?.pause()
+    }
+    
+    deinit {
+        videoPlayer?.destroy()
+    }
+    
+    // MARK: - Setup
+    private func setupUI() {
+        errorLabel.isHidden = true
+        loadingIndicator.hidesWhenStopped = true
+        
+        // Configure sliders
+        progressSlider.value = 0
+        volumeSlider.value = 1.0
+        
+        // Style the player container
+        playerContainer.backgroundColor = .black
+        playerContainer.layer.cornerRadius = 8
+        playerContainer.clipsToBounds = true
+    }
+    
+    private func setupVideoPlayer() {
+        // Initialize the player
+        videoPlayer = UnifiedVideoPlayer()
+        
+        // Configure player
+        let config = PlayerConfiguration(dictionary: [
+            "autoPlay": false,
+            "controls": false, // Using custom controls
+            "muted": false,
+            "debug": true
+        ])
+        
+        // Initialize with container
+        videoPlayer.initialize(container: playerContainer, configuration: config)
+        
+        // Set up event listeners
+        setupPlayerEventListeners()
+    }
+    
+    private func setupPlayerEventListeners() {
+        // Ready event
+        videoPlayer.onReady = { [weak self] in
+            self?.handlePlayerReady()
+        }
+        
+        // Play/Pause events
+        videoPlayer.onPlay = { [weak self] in
+            self?.updatePlayPauseButton(isPlaying: true)
+        }
+        
+        videoPlayer.onPause = { [weak self] in
+            self?.updatePlayPauseButton(isPlaying: false)
+        }
+        
+        // Time updates
+        videoPlayer.onTimeUpdate = { [weak self] currentTime in
+            self?.updateProgress(currentTime: currentTime)
+        }
+        
+        // Buffering
+        videoPlayer.onBuffering = { [weak self] isBuffering in
+            self?.handleBuffering(isBuffering)
+        }
+        
+        // Metadata loaded
+        videoPlayer.onLoadedMetadata = { [weak self] metadata in
+            self?.handleMetadataLoaded(metadata)
+        }
+        
+        // Error handling
+        videoPlayer.onError = { [weak self] error in
+            self?.handleError(error)
+        }
+        
+        // State changes
+        videoPlayer.onStateChange = { [weak self] state in
+            self?.handleStateChange(state)
+        }
+        
+        // Video ended
+        videoPlayer.onEnded = { [weak self] in
+            self?.handleVideoEnded()
+        }
+    }
+    
+    // MARK: - Loading Content
+    private func loadSampleVideo() {
+        // Load the first sample video
+        let videoUrl = sampleVideos[0]
+        
+        let source = MediaSource(url: videoUrl)
+        videoPlayer.load(source: source)
+    }
+    
+    // MARK: - Event Handlers
+    private func handlePlayerReady() {
+        DispatchQueue.main.async { [weak self] in
+            self?.loadingIndicator.stopAnimating()
+            self?.playPauseButton.isEnabled = true
+        }
+    }
+    
+    private func handleBuffering(_ isBuffering: Bool) {
+        DispatchQueue.main.async { [weak self] in
+            if isBuffering {
+                self?.loadingIndicator.startAnimating()
+            } else {
+                self?.loadingIndicator.stopAnimating()
+            }
+        }
+    }
+    
+    private func handleMetadataLoaded(_ metadata: [String: Any]) {
+        print("Video metadata loaded: \(metadata)")
+        
+        DispatchQueue.main.async { [weak self] in
+            if let duration = metadata["duration"] as? Double {
+                self?.progressSlider.maximumValue = Float(duration)
+                self?.durationLabel.text = self?.formatTime(duration) ?? "00:00"
+            }
+            
+            if let width = metadata["width"] as? CGFloat,
+               let height = metadata["height"] as? CGFloat {
+                print("Video resolution: \(width)x\(height)")
+            }
+        }
+    }
+    
+    private func handleError(_ error: Error) {
+        DispatchQueue.main.async { [weak self] in
+            self?.loadingIndicator.stopAnimating()
+            self?.errorLabel.isHidden = false
+            self?.errorLabel.text = "Error: \(error.localizedDescription)"
+            self?.playPauseButton.isEnabled = false
+        }
+    }
+    
+    private func handleStateChange(_ state: PlayerState) {
+        print("Player state changed: \(state)")
+    }
+    
+    private func handleVideoEnded() {
+        DispatchQueue.main.async { [weak self] in
+            self?.updatePlayPauseButton(isPlaying: false)
+            self?.progressSlider.value = 0
+            self?.currentTimeLabel.text = "00:00"
+        }
+    }
+    
+    // MARK: - UI Updates
+    private func updatePlayPauseButton(isPlaying: Bool) {
+        DispatchQueue.main.async { [weak self] in
+            let title = isPlaying ? "Pause" : "Play"
+            self?.playPauseButton.setTitle(title, for: .normal)
+        }
+    }
+    
+    private func updateProgress(currentTime: Double) {
+        guard !isSliderTracking else { return }
+        
+        DispatchQueue.main.async { [weak self] in
+            self?.progressSlider.value = Float(currentTime)
+            self?.currentTimeLabel.text = self?.formatTime(currentTime) ?? "00:00"
+        }
+    }
+    
+    private func formatTime(_ seconds: Double) -> String {
+        let mins = Int(seconds) / 60
+        let secs = Int(seconds) % 60
+        return String(format: "%02d:%02d", mins, secs)
+    }
+    
+    // MARK: - IBActions
+    @IBAction func playPauseButtonTapped(_ sender: UIButton) {
+        videoPlayer.togglePlayPause()
+    }
+    
+    @IBAction func progressSliderValueChanged(_ sender: UISlider) {
+        videoPlayer.seek(to: Double(sender.value))
+    }
+    
+    @IBAction func progressSliderTouchDown(_ sender: UISlider) {
+        isSliderTracking = true
+    }
+    
+    @IBAction func progressSliderTouchUp(_ sender: UISlider) {
+        isSliderTracking = false
+    }
+    
+    @IBAction func volumeSliderValueChanged(_ sender: UISlider) {
+        videoPlayer.setVolume(sender.value)
+    }
+    
+    @IBAction func muteButtonTapped(_ sender: UIButton) {
+        videoPlayer.toggleMute()
+        sender.setTitle(sender.title(for: .normal) == "Mute" ? "Unmute" : "Mute", for: .normal)
+    }
+    
+    @IBAction func skipBackwardButtonTapped(_ sender: UIButton) {
+        videoPlayer.seekBackward(seconds: 10)
+    }
+    
+    @IBAction func skipForwardButtonTapped(_ sender: UIButton) {
+        videoPlayer.seekForward(seconds: 10)
+    }
+    
+    @IBAction func loadVideoButtonTapped(_ sender: UIButton) {
+        // Show action sheet with video options
+        let actionSheet = UIAlertController(title: "Select Video", message: nil, preferredStyle: .actionSheet)
+        
+        actionSheet.addAction(UIAlertAction(title: "MP4 Video", style: .default) { [weak self] _ in
+            self?.videoPlayer.load(url: self?.sampleVideos[0] ?? "")
+        })
+        
+        actionSheet.addAction(UIAlertAction(title: "HLS Stream", style: .default) { [weak self] _ in
+            self?.videoPlayer.load(url: self?.sampleVideos[1] ?? "")
+        })
+        
+        actionSheet.addAction(UIAlertAction(title: "Test Stream", style: .default) { [weak self] _ in
+            self?.videoPlayer.load(url: self?.sampleVideos[2] ?? "")
+        })
+        
+        actionSheet.addAction(UIAlertAction(title: "Custom URL", style: .default) { [weak self] _ in
+            self?.showCustomURLDialog()
+        })
+        
+        actionSheet.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+        
+        // iPad compatibility
+        if let popover = actionSheet.popoverPresentationController {
+            popover.sourceView = sender
+            popover.sourceRect = sender.bounds
+        }
+        
+        present(actionSheet, animated: true)
+    }
+    
+    @IBAction func fullscreenButtonTapped(_ sender: UIButton) {
+        // Present player in fullscreen
+        videoPlayer.initializeWithViewController(viewController: self, configuration: nil)
+    }
+    
+    // MARK: - Helper Methods
+    private func showCustomURLDialog() {
+        let alert = UIAlertController(title: "Enter Video URL", message: nil, preferredStyle: .alert)
+        
+        alert.addTextField { textField in
+            textField.placeholder = "https://example.com/video.mp4"
+            textField.keyboardType = .URL
+        }
+        
+        alert.addAction(UIAlertAction(title: "Load", style: .default) { [weak self] _ in
+            if let url = alert.textFields?.first?.text, !url.isEmpty {
+                self?.videoPlayer.load(url: url)
+            }
+        })
+        
+        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+        
+        present(alert, animated: true)
+    }
+}
+
+// MARK: - Extension for DRM Content (Advanced Usage)
+extension ViewController {
+    
+    func loadDRMProtectedContent() {
+        let drm = DRMConfiguration(
+            type: "fairplay",
+            licenseUrl: "https://license.server.com/fairplay"
+        )
+        drm.certificateUrl = "https://certificate.server.com/cert"
+        
+        let source = MediaSource(url: "https://example.com/protected-content.m3u8")
+        source.drm = drm
+        
+        videoPlayer.load(source: source)
+    }
+    
+    func loadVideoWithSubtitles() {
+        let subtitle = SubtitleTrack(
+            url: "https://example.com/subtitles-en.vtt",
+            language: "en",
+            label: "English"
+        )
+        
+        let source = MediaSource(url: "https://example.com/video.mp4")
+        source.subtitles = [subtitle]
+        
+        videoPlayer.load(source: source)
+    }
+}

package/examples/ios/SwiftUISampleApp/ContentView.swift

@@ -0,0 +1,304 @@
+//
+//  ContentView.swift
+//  UnifiedVideoPlayer SwiftUI Sample App
+//
+//  Example of using UnifiedVideoPlayer with SwiftUI
+//
+
+import SwiftUI
+import UnifiedVideoPlayer
+
+struct ContentView: View {
+    @StateObject private var playerModel = UnifiedVideoPlayerModel(
+        url: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"
+    )
+    
+    @State private var selectedVideoIndex = 0
+    @State private var showVideoSelection = false
+    @State private var customURL = ""
+    @State private var showCustomURLAlert = false
+    
+    let sampleVideos = [
+        ("Big Buck Bunny", "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"),
+        ("HLS Stream", "https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_fmp4/master.m3u8"),
+        ("Test Stream", "https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8")
+    ]
+    
+    var body: some View {
+        NavigationView {
+            VStack(spacing: 0) {
+                // Video Player
+                CustomUnifiedVideoPlayer(
+                    url: sampleVideos[selectedVideoIndex].1,
+                    configuration: PlayerConfiguration(dictionary: [
+                        "autoPlay": false,
+                        "controls": true,
+                        "debug": true
+                    ])
+                )
+                .aspectRatio(16/9, contentMode: .fit)
+                .background(Color.black)
+                
+                // Controls Section
+                ScrollView {
+                    VStack(spacing: 20) {
+                        // Video Selection
+                        VStack(alignment: .leading, spacing: 10) {
+                            Text("Select Video")
+                                .font(.headline)
+                            
+                            ForEach(0..<sampleVideos.count, id: \.self) { index in
+                                Button(action: {
+                                    selectedVideoIndex = index
+                                    loadVideo(url: sampleVideos[index].1)
+                                }) {
+                                    HStack {
+                                        Image(systemName: selectedVideoIndex == index ? "checkmark.circle.fill" : "circle")
+                                        Text(sampleVideos[index].0)
+                                        Spacer()
+                                    }
+                                    .foregroundColor(selectedVideoIndex == index ? .blue : .primary)
+                                }
+                                .buttonStyle(PlainButtonStyle())
+                            }
+                            
+                            Button("Load Custom URL") {
+                                showCustomURLAlert = true
+                            }
+                            .foregroundColor(.blue)
+                        }
+                        .padding()
+                        .background(Color.gray.opacity(0.1))
+                        .cornerRadius(10)
+                        
+                        // Player Info
+                        VStack(alignment: .leading, spacing: 10) {
+                            Text("Player Information")
+                                .font(.headline)
+                            
+                            InfoRow(label: "State", value: playerStateText)
+                            InfoRow(label: "Duration", value: formatTime(playerModel.duration))
+                            InfoRow(label: "Current Time", value: formatTime(playerModel.currentTime))
+                            InfoRow(label: "Volume", value: String(format: "%.0f%%", playerModel.volume * 100))
+                            InfoRow(label: "Quality", value: playerModel.currentVideoQuality)
+                            
+                            if let error = playerModel.error {
+                                InfoRow(label: "Error", value: error.localizedDescription)
+                                    .foregroundColor(.red)
+                            }
+                        }
+                        .padding()
+                        .background(Color.gray.opacity(0.1))
+                        .cornerRadius(10)
+                        
+                        // Advanced Features
+                        VStack(alignment: .leading, spacing: 10) {
+                            Text("Advanced Features")
+                                .font(.headline)
+                            
+                            Button("Load DRM Content") {
+                                loadDRMContent()
+                            }
+                            
+                            Button("Load with Subtitles") {
+                                loadVideoWithSubtitles()
+                            }
+                        }
+                        .padding()
+                        .background(Color.gray.opacity(0.1))
+                        .cornerRadius(10)
+                    }
+                    .padding()
+                }
+            }
+            .navigationTitle("SwiftUI Video Player")
+            .navigationBarTitleDisplayMode(.inline)
+        }
+        .alert("Enter Video URL", isPresented: $showCustomURLAlert) {
+            TextField("https://example.com/video.mp4", text: $customURL)
+            Button("Cancel", role: .cancel) { }
+            Button("Load") {
+                if !customURL.isEmpty {
+                    loadVideo(url: customURL)
+                }
+            }
+        }
+    }
+    
+    private var playerStateText: String {
+        if playerModel.isPlaying {
+            return "Playing"
+        } else if playerModel.isBuffering {
+            return "Buffering..."
+        } else {
+            return "Paused"
+        }
+    }
+    
+    private func loadVideo(url: String) {
+        let source = MediaSource(url: url)
+        // Note: In a real implementation, you'd reinitialize the player with the new source
+        // This is simplified for demonstration
+    }
+    
+    private func loadDRMContent() {
+        let drm = DRMConfiguration(
+            type: "fairplay",
+            licenseUrl: "https://license.server.com/fairplay"
+        )
+        drm.certificateUrl = "https://certificate.server.com/cert"
+        
+        let source = MediaSource(url: "https://example.com/protected-content.m3u8")
+        source.drm = drm
+        
+        // Load the DRM protected content
+        // playerModel would need to be reinitialized with this source
+    }
+    
+    private func loadVideoWithSubtitles() {
+        let subtitle = SubtitleTrack(
+            url: "https://example.com/subtitles-en.vtt",
+            language: "en",
+            label: "English"
+        )
+        
+        let source = MediaSource(url: "https://example.com/video.mp4")
+        source.subtitles = [subtitle]
+        
+        // Load video with subtitles
+        // playerModel would need to be reinitialized with this source
+    }
+    
+    private func formatTime(_ time: Double) -> String {
+        guard !time.isNaN && !time.isInfinite else { return "00:00" }
+        let minutes = Int(time) / 60
+        let seconds = Int(time) % 60
+        return String(format: "%02d:%02d", minutes, seconds)
+    }
+}
+
+struct InfoRow: View {
+    let label: String
+    let value: String
+    
+    var body: some View {
+        HStack {
+            Text(label + ":")
+                .fontWeight(.medium)
+            Spacer()
+            Text(value)
+                .foregroundColor(.secondary)
+        }
+    }
+}
+
+// MARK: - Alternative Full-Screen Player View
+struct FullScreenPlayerView: View {
+    @Environment(\.presentationMode) var presentationMode
+    let videoURL: String
+    
+    var body: some View {
+        ZStack {
+            Color.black.edgesIgnoringSafeArea(.all)
+            
+            CustomUnifiedVideoPlayer(
+                url: videoURL,
+                configuration: PlayerConfiguration(dictionary: [
+                    "autoPlay": true,
+                    "controls": true
+                ])
+            )
+            
+            // Close button
+            VStack {
+                HStack {
+                    Spacer()
+                    Button(action: {
+                        presentationMode.wrappedValue.dismiss()
+                    }) {
+                        Image(systemName: "xmark.circle.fill")
+                            .font(.title)
+                            .foregroundColor(.white)
+                            .background(Color.black.opacity(0.5))
+                            .clipShape(Circle())
+                    }
+                    .padding()
+                }
+                Spacer()
+            }
+        }
+    }
+}
+
+// MARK: - List View with Multiple Videos
+struct VideoListView: View {
+    let videos = [
+        VideoItem(title: "Big Buck Bunny", url: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4", thumbnail: "thumbnail1"),
+        VideoItem(title: "Elephant Dream", url: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4", thumbnail: "thumbnail2"),
+        VideoItem(title: "For Bigger Blazes", url: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ForBiggerBlazes.mp4", thumbnail: "thumbnail3")
+    ]
+    
+    @State private var selectedVideo: VideoItem?
+    
+    var body: some View {
+        NavigationView {
+            List(videos) { video in
+                VideoRow(video: video) {
+                    selectedVideo = video
+                }
+            }
+            .navigationTitle("Video Library")
+            .sheet(item: $selectedVideo) { video in
+                FullScreenPlayerView(videoURL: video.url)
+            }
+        }
+    }
+}
+
+struct VideoItem: Identifiable {
+    let id = UUID()
+    let title: String
+    let url: String
+    let thumbnail: String
+}
+
+struct VideoRow: View {
+    let video: VideoItem
+    let action: () -> Void
+    
+    var body: some View {
+        Button(action: action) {
+            HStack {
+                // Thumbnail placeholder
+                RoundedRectangle(cornerRadius: 8)
+                    .fill(Color.gray.opacity(0.3))
+                    .frame(width: 120, height: 67.5)
+                    .overlay(
+                        Image(systemName: "play.circle.fill")
+                            .font(.title)
+                            .foregroundColor(.white)
+                    )
+                
+                VStack(alignment: .leading, spacing: 4) {
+                    Text(video.title)
+                        .font(.headline)
+                        .foregroundColor(.primary)
+                    Text("Tap to play")
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                }
+                
+                Spacer()
+            }
+            .padding(.vertical, 8)
+        }
+        .buttonStyle(PlainButtonStyle())
+    }
+}
+
+// MARK: - Preview
+struct ContentView_Previews: PreviewProvider {
+    static var previews: some View {
+        ContentView()
+    }
+}