unified-video-framework 1.0.0

package/packages/ios/Sources/UnifiedVideoPlayer/UnifiedVideoPlayerView.swift

@@ -0,0 +1,640 @@
+//
+//  UnifiedVideoPlayerView.swift
+//  UnifiedVideoPlayer
+//
+//  SwiftUI implementation of the Unified Video Framework
+//
+
+import SwiftUI
+import AVKit
+import AVFoundation
+import Combine
+import UIKit
+
+// MARK: - SwiftUI Video Player View
+@available(iOS 14.0, *)
+public struct UnifiedVideoPlayerView: UIViewControllerRepresentable {
+    @Binding var player: UnifiedVideoPlayerModel
+    var showsControls: Bool = true
+    
+    public init(player: Binding<UnifiedVideoPlayerModel>, showsControls: Bool = true) {
+        self._player = player
+        self.showsControls = showsControls
+    }
+    
+    public func makeUIViewController(context: Context) -> AVPlayerViewController {
+        let controller = AVPlayerViewController()
+        controller.player = player.avPlayer
+        controller.showsPlaybackControls = showsControls
+        return controller
+    }
+    
+    public func updateUIViewController(_ uiViewController: AVPlayerViewController, context: Context) {
+        uiViewController.player = player.avPlayer
+        uiViewController.showsPlaybackControls = showsControls
+    }
+}
+
+// MARK: - Custom SwiftUI Video Player with Controls
+@available(iOS 14.0, *)
+public struct CustomUnifiedVideoPlayer: View {
+    @StateObject private var playerModel: UnifiedVideoPlayerModel
+    @State private var showControls: Bool = true
+    @State private var hideControlsTimer: Timer?
+    @State private var pipController: AVPictureInPictureController? = nil
+    
+    // Configuration
+    private let configuration: PlayerConfiguration
+    private var accent: Color { Color(hex: configuration.themeColorHex ?? "") ?? .white }
+    private var uiAccent: UIColor { UIColor(hex: configuration.themeColorHex ?? "") ?? .white }
+    
+    public init(url: String, configuration: PlayerConfiguration = PlayerConfiguration()) {
+        self.configuration = configuration
+        self._playerModel = StateObject(wrappedValue: UnifiedVideoPlayerModel(url: url, configuration: configuration))
+    }
+    
+    public init(source: MediaSource, configuration: PlayerConfiguration = PlayerConfiguration()) {
+        self.configuration = configuration
+        self._playerModel = StateObject(wrappedValue: UnifiedVideoPlayerModel(source: source, configuration: configuration))
+    }
+    
+    public var body: some View {
+        ZStack {
+// Video Player Layer
+            VideoPlayerLayer(player: playerModel.avPlayer, pipController: $pipController)
+                .onTapGesture {
+                    withAnimation(.easeInOut(duration: 0.3)) {
+                        showControls.toggle()
+                        resetHideControlsTimer()
+                    }
+                }
+            
+            // Custom Controls Overlay
+if showControls && configuration.controls {
+                VideoControlsOverlay(
+                    playerModel: playerModel,
+                    accent: accent,
+                    uiAccent: uiAccent,
+                    pipController: pipController,
+                    onTogglePiP: {
+                        if let c = pipController {
+                            if c.isPictureInPictureActive { c.stopPictureInPicture() }
+                            else { c.startPictureInPicture() }
+                        }
+                    }
+                )
+                .transition(.opacity)
+            }
+            
+            // Loading Indicator
+            if playerModel.isBuffering {
+                ProgressView()
+                    .progressViewStyle(CircularProgressViewStyle(tint: .white))
+                    .scaleEffect(1.5)
+            }
+            
+            // Error Message
+            if let error = playerModel.error {
+                VStack {
+                    Image(systemName: "exclamationmark.triangle")
+                        .font(.largeTitle)
+                        .foregroundColor(.white)
+                    Text(error.localizedDescription)
+                        .foregroundColor(.white)
+                        .padding()
+                }
+                .background(Color.black.opacity(0.7))
+                .cornerRadius(10)
+            }
+        }
+        .background(Color.black)
+        .onAppear {
+            playerModel.initialize()
+            resetHideControlsTimer()
+        }
+        .onDisappear {
+            playerModel.cleanup()
+        }
+    }
+    
+    private func resetHideControlsTimer() {
+        hideControlsTimer?.invalidate()
+        hideControlsTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: false) { _ in
+            withAnimation {
+                showControls = false
+            }
+        }
+    }
+}
+
+// MARK: - Video Player Layer
+@available(iOS 14.0, *)
+struct VideoPlayerLayer: UIViewRepresentable {
+    let player: AVPlayer?
+    @Binding var pipController: AVPictureInPictureController?
+    
+    func makeUIView(context: Context) -> PlayerUIView {
+        let view = PlayerUIView(player: player)
+        if AVPictureInPictureController.isPictureInPictureSupported(), pipController == nil, let layer = view.playerLayer {
+            pipController = AVPictureInPictureController(playerLayer: layer)
+        }
+        return view
+    }
+    
+    func updateUIView(_ uiView: PlayerUIView, context: Context) {
+        uiView.updatePlayer(player)
+        if AVPictureInPictureController.isPictureInPictureSupported(), pipController == nil, let layer = uiView.playerLayer {
+            pipController = AVPictureInPictureController(playerLayer: layer)
+        }
+    }
+    
+    class PlayerUIView: UIView {
+        var playerLayer: AVPlayerLayer?
+        
+        init(player: AVPlayer?) {
+            super.init(frame: .zero)
+            setupPlayerLayer(with: player)
+        }
+        
+        required init?(coder: NSCoder) {
+            super.init(coder: coder)
+        }
+        
+        override func layoutSubviews() {
+            super.layoutSubviews()
+            playerLayer?.frame = bounds
+        }
+        
+        func setupPlayerLayer(with player: AVPlayer?) {
+            playerLayer?.removeFromSuperlayer()
+            
+            guard let player = player else { return }
+            
+            let newPlayerLayer = AVPlayerLayer(player: player)
+            newPlayerLayer.videoGravity = .resizeAspect
+            newPlayerLayer.frame = bounds
+            layer.addSublayer(newPlayerLayer)
+            playerLayer = newPlayerLayer
+        }
+        
+        func updatePlayer(_ player: AVPlayer?) {
+            playerLayer?.player = player
+        }
+    }
+}
+
+// MARK: - AirPlay Route Picker (SwiftUI wrapper)
+@available(iOS 13.0, *)
+struct AirPlayRoutePicker: UIViewRepresentable {
+    let tint: UIColor
+    func makeUIView(context: Context) -> AVRoutePickerView {
+        let v = AVRoutePickerView(frame: .zero)
+        v.tintColor = tint
+        if #available(iOS 13.0, *) { v.activeTintColor = tint }
+        return v
+    }
+    func updateUIView(_ uiView: AVRoutePickerView, context: Context) {
+        uiView.tintColor = tint
+        if #available(iOS 13.0, *) { uiView.activeTintColor = tint }
+    }
+}
+
+// MARK: - Video Controls Overlay
+@available(iOS 14.0, *)
+struct VideoControlsOverlay: View {
+    @ObservedObject var playerModel: UnifiedVideoPlayerModel
+    let accent: Color
+    let uiAccent: UIColor
+    let pipController: AVPictureInPictureController?
+    let onTogglePiP: () -> Void
+    @State private var isDraggingSlider: Bool = false
+    
+    var body: some View {
+        VStack {
+            // Top Bar
+            HStack {
+                if let title = playerModel.title {
+                    Text(title)
+                        .font(.headline)
+                        .foregroundColor(.white)
+                }
+                Spacer()
+                
+// AirPlay + PiP
+                HStack(spacing: 16) {
+                    if #available(iOS 13.0, *) {
+                        AirPlayRoutePicker(tint: uiAccent)
+                            .frame(width: 28, height: 28)
+                    }
+                    if AVPictureInPictureController.isPictureInPictureSupported() && pipController != nil {
+                        Button(action: onTogglePiP) {
+                            if #available(iOS 15.0, *) {
+                                Image(systemName: (pipController?.isPictureInPictureActive ?? false) ? "pip.exit" : "pip.enter")
+                                    .foregroundColor(accent)
+                                    .font(.title2)
+                            } else {
+                                Image(systemName: "rectangle")
+                                    .foregroundColor(accent)
+                                    .font(.title2)
+                            }
+                        }
+                    }
+                }
+                
+                // Settings Menu
+                Menu {
+                    // Quality Selection
+                    Menu("Quality") {
+                        ForEach(["Auto", "1080p", "720p", "480p", "360p"], id: \.self) { quality in
+                            Button(quality) {
+                                playerModel.setVideoQuality(quality)
+                            }
+                        }
+                    }
+                    
+                    // Playback Speed
+                    Menu("Speed") {
+                        ForEach([0.5, 0.75, 1.0, 1.25, 1.5, 2.0], id: \.self) { speed in
+                            Button("\(speed)x") {
+                                playerModel.setPlaybackRate(Float(speed))
+                            }
+                        }
+                    }
+                    
+                    // Subtitles
+                    if !playerModel.availableSubtitles.isEmpty {
+                        Menu("Subtitles") {
+                            Button("Off") {
+                                playerModel.selectSubtitle(nil)
+                            }
+                            ForEach(playerModel.availableSubtitles, id: \.language) { subtitle in
+                                Button(subtitle.label) {
+                                    playerModel.selectSubtitle(subtitle)
+                                }
+                            }
+                        }
+                    }
+                } label: {
+Image(systemName: "ellipsis")
+                        .foregroundColor(accent)
+                        .font(.title2)
+                }
+            }
+            .padding()
+            .background(LinearGradient(
+                gradient: Gradient(colors: [Color.black.opacity(0.7), Color.clear]),
+                startPoint: .top,
+                endPoint: .bottom
+            ))
+            
+            Spacer()
+            
+            // Center Play/Pause Button
+            if !playerModel.isPlaying {
+                Button(action: {
+                    playerModel.play()
+                }) {
+Image(systemName: "play.circle.fill")
+                        .font(.system(size: 70))
+                        .foregroundColor(accent.opacity(0.9))
+                }
+            }
+            
+            Spacer()
+            
+            // Bottom Controls
+            VStack(spacing: 10) {
+                // Progress Bar
+                HStack {
+                    Text(formatTime(playerModel.currentTime))
+                        .font(.caption)
+                        .foregroundColor(.white)
+                    
+Slider(
+                        value: Binding(
+                            get: { isDraggingSlider ? playerModel.seekTime : playerModel.currentTime },
+                            set: { playerModel.seekTime = $0 }
+                        ),
+                        in: 0...max(playerModel.duration, 1),
+                        onEditingChanged: { editing in
+                            isDraggingSlider = editing
+                            if !editing {
+                                playerModel.seek(to: playerModel.seekTime)
+                            }
+                        }
+                    )
+                    .accentColor(accent)
+                    
+                    Text(formatTime(playerModel.duration))
+                        .font(.caption)
+                        .foregroundColor(.white)
+                }
+                .padding(.horizontal)
+                
+                // Control Buttons
+                HStack(spacing: 30) {
+                    // Play/Pause
+                    Button(action: {
+                        playerModel.togglePlayPause()
+                    }) {
+Image(systemName: playerModel.isPlaying ? "pause.fill" : "play.fill")
+                            .font(.title)
+                            .foregroundColor(accent)
+                    }
+                    
+                    // Skip Backward
+                    Button(action: {
+                        playerModel.seekBackward()
+                    }) {
+Image(systemName: "gobackward.10")
+                            .font(.title2)
+                            .foregroundColor(accent)
+                    }
+                    
+                    // Skip Forward
+                    Button(action: {
+                        playerModel.seekForward()
+                    }) {
+Image(systemName: "goforward.10")
+                            .font(.title2)
+                            .foregroundColor(accent)
+                    }
+                    
+                    Spacer()
+                    
+                    // Volume
+                    HStack {
+Image(systemName: playerModel.isMuted ? "speaker.slash.fill" : "speaker.wave.2.fill")
+                            .foregroundColor(accent)
+                            .onTapGesture {
+                                playerModel.toggleMute()
+                            }
+                        
+Slider(value: $playerModel.volume, in: 0...1)
+                            .frame(width: 80)
+                            .accentColor(accent)
+                    }
+                    
+                    // Fullscreen
+                    Button(action: {
+                        playerModel.toggleFullscreen()
+                    }) {
+Image(systemName: playerModel.isFullscreen ? "arrow.down.right.and.arrow.up.left" : "arrow.up.left.and.arrow.down.right")
+                            .font(.title2)
+                            .foregroundColor(accent)
+                    }
+                }
+                .padding(.horizontal)
+            }
+            .padding(.vertical)
+            .background(LinearGradient(
+                gradient: Gradient(colors: [Color.clear, Color.black.opacity(0.7)]),
+                startPoint: .top,
+                endPoint: .bottom
+            ))
+        }
+    }
+    
+    private func formatTime(_ time: Double) -> String {
+        let minutes = Int(time) / 60
+        let seconds = Int(time) % 60
+        return String(format: "%02d:%02d", minutes, seconds)
+    }
+}
+
+// MARK: - Player Model (ObservableObject)
+@available(iOS 14.0, *)
+public class UnifiedVideoPlayerModel: ObservableObject {
+    // Published Properties
+    @Published public var isPlaying: Bool = false
+    @Published public var isBuffering: Bool = false
+    @Published public var currentTime: Double = 0
+    @Published public var duration: Double = 0
+    @Published public var seekTime: Double = 0
+    @Published public var volume: Float = 1.0 {
+        didSet { avPlayer?.volume = volume }
+    }
+    @Published public var isMuted: Bool = false {
+        didSet { avPlayer?.isMuted = isMuted }
+    }
+    @Published public var error: Error?
+    @Published public var isFullscreen: Bool = false
+    @Published public var title: String?
+    @Published public var availableSubtitles: [SubtitleTrack] = []
+    @Published public var currentVideoQuality: String = "Auto"
+    
+    // Player properties
+    public private(set) var avPlayer: AVPlayer?
+    private var playerObserver: Any?
+    private var timeObserver: Any?
+    private var cancellables = Set<AnyCancellable>()
+    private let configuration: PlayerConfiguration
+    private var mediaSource: MediaSource?
+    
+    // Events
+    public var onReady: (() -> Void)?
+    public var onEnded: (() -> Void)?
+    public var onError: ((Error) -> Void)?
+    
+    // MARK: - Initialization
+    
+    public init(url: String, configuration: PlayerConfiguration = PlayerConfiguration()) {
+        self.configuration = configuration
+        self.mediaSource = MediaSource(url: url)
+        setupPlayer()
+    }
+    
+    public init(source: MediaSource, configuration: PlayerConfiguration = PlayerConfiguration()) {
+        self.configuration = configuration
+        self.mediaSource = source
+        setupPlayer()
+    }
+    
+    // MARK: - Player Setup
+    
+    private func setupPlayer() {
+        guard let source = mediaSource,
+              let url = URL(string: source.url) else { return }
+        
+        let playerItem = AVPlayerItem(url: url)
+        avPlayer = AVPlayer(playerItem: playerItem)
+        
+        // Apply configuration
+        avPlayer?.volume = configuration.volume
+        avPlayer?.isMuted = configuration.muted
+        
+        // Setup observers
+        setupObservers()
+        
+        // Load metadata
+        if let metadata = source.metadata {
+            title = metadata["title"] as? String
+        }
+        
+        // Load subtitles if available
+        if let subtitles = source.subtitles {
+            availableSubtitles = subtitles
+        }
+    }
+    
+    public func initialize() {
+        if configuration.autoPlay {
+            play()
+        }
+    }
+    
+    // MARK: - Playback Control
+    
+    public func play() {
+        avPlayer?.play()
+        isPlaying = true
+    }
+    
+    public func pause() {
+        avPlayer?.pause()
+        isPlaying = false
+    }
+    
+    public func togglePlayPause() {
+        if isPlaying {
+            pause()
+        } else {
+            play()
+        }
+    }
+    
+    public func stop() {
+        avPlayer?.pause()
+        avPlayer?.seek(to: .zero)
+        isPlaying = false
+        currentTime = 0
+    }
+    
+    public func seek(to time: Double) {
+        let cmTime = CMTime(seconds: time, preferredTimescale: 1000)
+        avPlayer?.seek(to: cmTime)
+    }
+    
+    public func seekForward(seconds: Double = 10) {
+        let newTime = currentTime + seconds
+        seek(to: min(newTime, duration))
+    }
+    
+    public func seekBackward(seconds: Double = 10) {
+        let newTime = currentTime - seconds
+        seek(to: max(newTime, 0))
+    }
+    
+    // MARK: - Configuration
+    
+    public func setPlaybackRate(_ rate: Float) {
+        avPlayer?.rate = rate
+    }
+    
+    public func setVideoQuality(_ quality: String) {
+        currentVideoQuality = quality
+        // Implementation would handle quality switching
+    }
+    
+    public func selectSubtitle(_ subtitle: SubtitleTrack?) {
+        // Implementation would handle subtitle selection
+    }
+    
+    public func toggleMute() {
+        isMuted.toggle()
+    }
+    
+    public func toggleFullscreen() {
+        isFullscreen.toggle()
+    }
+    
+    // MARK: - Observers
+    
+    private func setupObservers() {
+        // Time observer
+        let interval = CMTime(seconds: 0.1, preferredTimescale: 1000)
+        timeObserver = avPlayer?.addPeriodicTimeObserver(forInterval: interval, queue: .main) { [weak self] time in
+            self?.currentTime = time.seconds
+        }
+        
+        // Status observer
+        avPlayer?.publisher(for: \.status)
+            .sink { [weak self] status in
+                if status == .readyToPlay {
+                    self?.updateDuration()
+                    self?.onReady?()
+                }
+            }
+            .store(in: &cancellables)
+        
+        // Rate observer
+        avPlayer?.publisher(for: \.rate)
+            .sink { [weak self] rate in
+                self?.isPlaying = rate > 0
+            }
+            .store(in: &cancellables)
+        
+        // Buffering observer
+        avPlayer?.currentItem?.publisher(for: \.isPlaybackBufferEmpty)
+            .sink { [weak self] isEmpty in
+                self?.isBuffering = isEmpty
+            }
+            .store(in: &cancellables)
+        
+        // End observer
+        NotificationCenter.default.publisher(for: .AVPlayerItemDidPlayToEndTime)
+            .sink { [weak self] _ in
+                self?.handlePlaybackEnded()
+            }
+            .store(in: &cancellables)
+        
+        // Error observer
+        avPlayer?.currentItem?.publisher(for: \.error)
+            .compactMap { $0 }
+            .sink { [weak self] error in
+                self?.error = error
+                self?.onError?(error)
+            }
+            .store(in: &cancellables)
+    }
+    
+    private func updateDuration() {
+        if let duration = avPlayer?.currentItem?.duration {
+            self.duration = duration.seconds
+        }
+    }
+    
+    private func handlePlaybackEnded() {
+        if configuration.loop {
+            seek(to: 0)
+            play()
+        } else {
+            isPlaying = false
+            onEnded?()
+        }
+    }
+    
+    // MARK: - Cleanup
+    
+    public func cleanup() {
+        avPlayer?.pause()
+        if let observer = timeObserver {
+            avPlayer?.removeTimeObserver(observer)
+        }
+        cancellables.removeAll()
+    }
+    
+    deinit {
+        cleanup()
+    }
+}
+
+// MARK: - SwiftUI Preview Provider
+@available(iOS 14.0, *)
+struct UnifiedVideoPlayerView_Previews: PreviewProvider {
+    static var previews: some View {
+        CustomUnifiedVideoPlayer(
+            url: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"
+        )
+    }
+}

package/packages/ios/Sources/UnifiedVideoPlayer/Utilities/Color+Hex.swift

@@ -0,0 +1,36 @@
+import UIKit
+import SwiftUI
+
+public extension UIColor {
+    // Supports #RRGGBB and #AARRGGBB (with or without #)
+    convenience init?(hex: String) {
+        var cleaned = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+        if cleaned.hasPrefix("#") { cleaned.removeFirst() }
+        guard cleaned.count == 6 || cleaned.count == 8 else { return nil }
+
+        var rgba: UInt64 = 0
+        guard Scanner(string: cleaned).scanHexInt64(&rgba) else { return nil }
+
+        let a, r, g, b: CGFloat
+        if cleaned.count == 8 {
+            a = CGFloat((rgba & 0xFF000000) >> 24) / 255.0
+            r = CGFloat((rgba & 0x00FF0000) >> 16) / 255.0
+            g = CGFloat((rgba & 0x0000FF00) >> 8) / 255.0
+            b = CGFloat(rgba & 0x000000FF) / 255.0
+        } else {
+            a = 1.0
+            r = CGFloat((rgba & 0xFF0000) >> 16) / 255.0
+            g = CGFloat((rgba & 0x00FF00) >> 8) / 255.0
+            b = CGFloat(rgba & 0x0000FF) / 255.0
+        }
+        self.init(red: r, green: g, blue: b, alpha: a)
+    }
+}
+
+public extension Color {
+    init?(hex: String) {
+        guard let ui = UIColor(hex: hex) else { return nil }
+        self = Color(ui)
+    }
+}
+

package/packages/ios/UnifiedVideoPlayer.podspec

@@ -0,0 +1,27 @@
+Pod::Spec.new do |s|
+  s.name             = 'UnifiedVideoPlayer'
+  s.version          = '1.0.0'
+  s.summary          = 'Unified Video Player SDK for iOS'
+  s.description      = <<-DESC
+    A powerful, unified video player SDK for iOS that provides a consistent API for video playback 
+    with support for HLS, DASH, DRM, subtitles, and more.
+  DESC
+
+  s.homepage         = 'https://github.com/yourcompany/unified-video-ios'
+  s.license          = { :type => 'MIT', :file => 'LICENSE' }
+  s.author           = { 'Your Company' => 'contact@yourcompany.com' }
+  s.source           = { :git => 'https://github.com/yourcompany/unified-video-ios.git', :tag => s.version.to_s }
+
+  s.ios.deployment_target = '13.0'
+  s.tvos.deployment_target = '13.0'
+  s.swift_version = '5.0'
+
+  s.source_files = 'Sources/UnifiedVideoPlayer/**/*.{swift,h,m}'
+  s.public_header_files = 'Sources/UnifiedVideoPlayer/**/*.h'
+  
+  s.frameworks = 'UIKit', 'AVFoundation', 'AVKit', 'Foundation'
+  
+  s.resource_bundles = {
+    'UnifiedVideoPlayer' => ['Sources/UnifiedVideoPlayer/Resources/**/*']
+  }
+end