unified-video-framework 1.0.0

package/packages/android/src/main/java/com/unifiedvideo/player/UnifiedVideoPlayer.kt

@@ -0,0 +1,707 @@
+/**
+ * UnifiedVideoPlayer.kt
+ * Unified Video Framework - Android Native SDK
+ */
+
+package com.unifiedvideo.player
+
+import android.content.Context
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.Surface
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.google.android.exoplayer2.*
+import com.google.android.exoplayer2.analytics.AnalyticsListener
+import com.google.android.exoplayer2.drm.*
+import com.google.android.exoplayer2.source.MediaSource
+import com.google.android.exoplayer2.source.ProgressiveMediaSource
+import com.google.android.exoplayer2.source.dash.DashMediaSource
+import com.google.android.exoplayer2.source.hls.HlsMediaSource
+import com.google.android.exoplayer2.source.smoothstreaming.SsMediaSource
+import com.google.android.exoplayer2.trackselection.DefaultTrackSelector
+import com.google.android.exoplayer2.ui.PlayerView
+import com.google.android.exoplayer2.ui.StyledPlayerView
+import com.google.android.exoplayer2.upstream.DefaultDataSource
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
+import com.google.android.exoplayer2.util.MimeTypes
+import com.google.android.exoplayer2.util.Util
+import com.google.android.exoplayer2.video.VideoSize
+import java.util.UUID
+
+// Player Configuration
+data class PlayerConfiguration(
+    val autoPlay: Boolean = false,
+    val controls: Boolean = true,
+    val muted: Boolean = false,
+    val loop: Boolean = false,
+    val preload: String = "auto",
+    val startTime: Long = 0,
+    val playbackSpeed: Float = 1.0f,
+    val volume: Float = 1.0f,
+    val debug: Boolean = false,
+    val useStyledControls: Boolean = true,
+    val allowBackgroundPlayback: Boolean = false
+) {
+    class Builder {
+        private var autoPlay: Boolean = false
+        private var controls: Boolean = true
+        private var muted: Boolean = false
+        private var loop: Boolean = false
+        private var preload: String = "auto"
+        private var startTime: Long = 0
+        private var playbackSpeed: Float = 1.0f
+        private var volume: Float = 1.0f
+        private var debug: Boolean = false
+        private var useStyledControls: Boolean = true
+        private var allowBackgroundPlayback: Boolean = false
+
+        fun setAutoPlay(autoPlay: Boolean) = apply { this.autoPlay = autoPlay }
+        fun setControls(controls: Boolean) = apply { this.controls = controls }
+        fun setMuted(muted: Boolean) = apply { this.muted = muted }
+        fun setLoop(loop: Boolean) = apply { this.loop = loop }
+        fun setPreload(preload: String) = apply { this.preload = preload }
+        fun setStartTime(startTime: Long) = apply { this.startTime = startTime }
+        fun setPlaybackSpeed(speed: Float) = apply { this.playbackSpeed = speed }
+        fun setVolume(volume: Float) = apply { this.volume = volume }
+        fun setDebug(debug: Boolean) = apply { this.debug = debug }
+        fun setUseStyledControls(styled: Boolean) = apply { this.useStyledControls = styled }
+        fun setAllowBackgroundPlayback(allow: Boolean) = apply { this.allowBackgroundPlayback = allow }
+
+        fun build() = PlayerConfiguration(
+            autoPlay, controls, muted, loop, preload, startTime,
+            playbackSpeed, volume, debug, useStyledControls, allowBackgroundPlayback
+        )
+    }
+}
+
+// Media Source
+data class MediaSource(
+    val url: String,
+    val type: String? = null,
+    val drm: DRMConfiguration? = null,
+    val metadata: Map<String, Any>? = null,
+    val subtitles: List<SubtitleTrack>? = null
+) {
+    companion object {
+        fun detectType(url: String): String {
+            return when {
+                url.contains(".m3u8") -> "hls"
+                url.contains(".mpd") -> "dash"
+                url.contains(".ism") -> "smoothstreaming"
+                url.contains(".mp4") -> "mp4"
+                url.contains(".webm") -> "webm"
+                url.contains(".mkv") -> "mkv"
+                else -> "mp4"
+            }
+        }
+    }
+}
+
+// DRM Configuration
+data class DRMConfiguration(
+    val type: String, // widevine, playready, clearkey
+    val licenseUrl: String,
+    val headers: Map<String, String>? = null,
+    val multiSession: Boolean = false,
+    val forceDefaultLicenseUri: Boolean = false
+)
+
+// Subtitle Track
+data class SubtitleTrack(
+    val url: String,
+    val language: String,
+    val label: String,
+    val kind: String = "subtitles", // subtitles, captions
+    val mimeType: String = MimeTypes.TEXT_VTT
+)
+
+// Player State
+enum class PlayerState {
+    IDLE,
+    LOADING,
+    READY,
+    PLAYING,
+    PAUSED,
+    BUFFERING,
+    SEEKING,
+    ENDED,
+    ERROR
+}
+
+// Main Player Class
+class UnifiedVideoPlayer(private val context: Context) {
+
+    companion object {
+        private const val TAG = "UnifiedVideoPlayer"
+    }
+
+    // Properties
+    private var exoPlayer: ExoPlayer? = null
+    private var playerView: View? = null
+    private var container: ViewGroup? = null
+    private var configuration: PlayerConfiguration? = null
+    private var currentSource: MediaSource? = null
+    private var trackSelector: DefaultTrackSelector? = null
+    
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var updateProgressHandler: Runnable? = null
+    
+    // State properties
+    var state: PlayerState = PlayerState.IDLE
+        private set
+    
+    var isPlaying: Boolean = false
+        private set
+    
+    var duration: Long = 0
+        private set
+    
+    var currentPosition: Long = 0
+        private set
+    
+    var bufferedPosition: Long = 0
+        private set
+    
+    var volume: Float = 1.0f
+        private set
+    
+    // Event callbacks
+    var onReady: (() -> Unit)? = null
+    var onPlay: (() -> Unit)? = null
+    var onPause: (() -> Unit)? = null
+    var onTimeUpdate: ((Long) -> Unit)? = null
+    var onBuffering: ((Boolean) -> Unit)? = null
+    var onSeek: ((Long) -> Unit)? = null
+    var onEnded: (() -> Unit)? = null
+    var onError: ((Exception) -> Unit)? = null
+    var onLoadedMetadata: ((Map<String, Any>) -> Unit)? = null
+    var onVolumeChange: ((Float) -> Unit)? = null
+    var onStateChange: ((PlayerState) -> Unit)? = null
+    var onProgress: ((Long) -> Unit)? = null
+    var onVideoSizeChanged: ((Int, Int) -> Unit)? = null
+    
+    // Initialization
+    fun initialize(
+        container: ViewGroup,
+        configuration: PlayerConfiguration? = null
+    ) {
+        this.container = container
+        this.configuration = configuration ?: PlayerConfiguration()
+        
+        setupPlayer()
+        applyConfiguration()
+    }
+    
+    private fun setupPlayer() {
+        // Create track selector for adaptive streaming
+        trackSelector = DefaultTrackSelector(context).apply {
+            setParameters(buildUponParameters().setMaxVideoSizeSd())
+        }
+        
+        // Create player
+        exoPlayer = ExoPlayer.Builder(context)
+            .setTrackSelector(trackSelector!!)
+            .build()
+            .apply {
+                addListener(playerEventListener)
+                addAnalyticsListener(analyticsListener)
+            }
+        
+        // Create player view
+        playerView = if (configuration?.useStyledControls == true) {
+            StyledPlayerView(context).apply {
+                player = exoPlayer
+                useController = configuration?.controls ?: true
+                controllerShowTimeoutMs = 3000
+                controllerHideOnTouch = true
+                setShowBuffering(StyledPlayerView.SHOW_BUFFERING_WHEN_PLAYING)
+            }
+        } else {
+            PlayerView(context).apply {
+                player = exoPlayer
+                useController = configuration?.controls ?: true
+                controllerShowTimeoutMs = 3000
+                controllerHideOnTouch = true
+            }
+        }
+        
+        // Add to container
+        playerView?.layoutParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT
+        )
+        container?.addView(playerView)
+        
+        // Start progress updates
+        startProgressUpdates()
+        
+        updateState(PlayerState.IDLE)
+    }
+    
+    private fun applyConfiguration() {
+        val config = configuration ?: return
+        
+        exoPlayer?.apply {
+            setVolume(config.volume)
+            playbackParameters = PlaybackParameters(config.playbackSpeed)
+            repeatMode = if (config.loop) Player.REPEAT_MODE_ALL else Player.REPEAT_MODE_OFF
+            
+            if (config.muted) {
+                setVolume(0f)
+            }
+        }
+        
+        if (config.debug) {
+            enableDebugLogging()
+        }
+    }
+    
+    // Loading Content
+    fun load(source: MediaSource) {
+        currentSource = source
+        updateState(PlayerState.LOADING)
+        
+        val uri = Uri.parse(source.url)
+        val mediaSource = createMediaSource(uri, source)
+        
+        exoPlayer?.apply {
+            setMediaSource(mediaSource)
+            prepare()
+            
+            // Apply start time if configured
+            configuration?.startTime?.let { startTime ->
+                if (startTime > 0) {
+                    seekTo(startTime)
+                }
+            }
+            
+            // Auto-play if configured
+            if (configuration?.autoPlay == true) {
+                play()
+            }
+        }
+        
+        // Load subtitles if provided
+        source.subtitles?.let { loadSubtitles(it) }
+    }
+    
+    fun load(url: String) {
+        val source = MediaSource(
+            url = url,
+            type = MediaSource.detectType(url)
+        )
+        load(source)
+    }
+    
+    private fun createMediaSource(uri: Uri, source: MediaSource): com.google.android.exoplayer2.source.MediaSource {
+        val dataSourceFactory = DefaultDataSource.Factory(context)
+        
+        // Configure DRM if needed
+        val drmSessionManagerProvider = source.drm?.let { drm ->
+            createDrmSessionManagerProvider(drm)
+        }
+        
+        val mediaItem = MediaItem.Builder()
+            .setUri(uri)
+            .apply {
+                source.drm?.let { drm ->
+                    setDrmConfiguration(
+                        MediaItem.DrmConfiguration.Builder(getDrmUuid(drm.type))
+                            .setLicenseUri(drm.licenseUrl)
+                            .setMultiSession(drm.multiSession)
+                            .setForceDefaultLicenseUri(drm.forceDefaultLicenseUri)
+                            .apply {
+                                drm.headers?.let { headers ->
+                                    setLicenseRequestHeaders(headers)
+                                }
+                            }
+                            .build()
+                    )
+                }
+            }
+            .build()
+        
+        // Create appropriate media source based on type
+        val type = source.type ?: MediaSource.detectType(source.url)
+        
+        return when (type) {
+            "hls" -> HlsMediaSource.Factory(dataSourceFactory)
+                .setDrmSessionManagerProvider(drmSessionManagerProvider)
+                .createMediaSource(mediaItem)
+            
+            "dash" -> DashMediaSource.Factory(dataSourceFactory)
+                .setDrmSessionManagerProvider(drmSessionManagerProvider)
+                .createMediaSource(mediaItem)
+            
+            "smoothstreaming" -> SsMediaSource.Factory(dataSourceFactory)
+                .setDrmSessionManagerProvider(drmSessionManagerProvider)
+                .createMediaSource(mediaItem)
+            
+            else -> ProgressiveMediaSource.Factory(dataSourceFactory)
+                .setDrmSessionManagerProvider(drmSessionManagerProvider)
+                .createMediaSource(mediaItem)
+        }
+    }
+    
+    private fun createDrmSessionManagerProvider(drm: DRMConfiguration): DrmSessionManagerProvider {
+        val drmCallback = HttpMediaDrmCallback(
+            drm.licenseUrl,
+            DefaultHttpDataSource.Factory()
+        ).apply {
+            drm.headers?.forEach { (key, value) ->
+                setKeyRequestProperty(key, value)
+            }
+        }
+        
+        return DrmSessionManagerProvider { mediaItem ->
+            val drmSessionManager = DefaultDrmSessionManager.Builder()
+                .setUuidAndExoMediaDrmProvider(
+                    getDrmUuid(drm.type),
+                    FrameworkMediaDrm.DEFAULT_PROVIDER
+                )
+                .build(drmCallback)
+            
+            drmSessionManager.setMode(DefaultDrmSessionManager.MODE_PLAYBACK, emptyByteArray())
+            drmSessionManager
+        }
+    }
+    
+    private fun getDrmUuid(drmType: String): UUID {
+        return when (drmType.lowercase()) {
+            "widevine" -> C.WIDEVINE_UUID
+            "playready" -> C.PLAYREADY_UUID
+            "clearkey" -> C.CLEARKEY_UUID
+            else -> C.WIDEVINE_UUID
+        }
+    }
+    
+    private fun loadSubtitles(subtitles: List<SubtitleTrack>) {
+        // ExoPlayer handles subtitles through MediaItem configuration
+        // This would be implemented with side-loaded subtitle tracks
+        subtitles.forEach { subtitle ->
+            Log.d(TAG, "Loading subtitle: ${subtitle.label} (${subtitle.language})")
+            // Implementation would add subtitle tracks to the media source
+        }
+    }
+    
+    // Playback Control
+    fun play() {
+        exoPlayer?.play()
+        isPlaying = true
+        updateState(PlayerState.PLAYING)
+        onPlay?.invoke()
+    }
+    
+    fun pause() {
+        exoPlayer?.pause()
+        isPlaying = false
+        updateState(PlayerState.PAUSED)
+        onPause?.invoke()
+    }
+    
+    fun stop() {
+        exoPlayer?.apply {
+            stop()
+            seekTo(0)
+        }
+        isPlaying = false
+        updateState(PlayerState.IDLE)
+    }
+    
+    fun togglePlayPause() {
+        if (isPlaying) {
+            pause()
+        } else {
+            play()
+        }
+    }
+    
+    fun seekTo(position: Long) {
+        updateState(PlayerState.SEEKING)
+        exoPlayer?.seekTo(position)
+        onSeek?.invoke(position)
+    }
+    
+    fun seekForward(seconds: Int = 10) {
+        val newPosition = currentPosition + (seconds * 1000)
+        seekTo(minOf(newPosition, duration))
+    }
+    
+    fun seekBackward(seconds: Int = 10) {
+        val newPosition = currentPosition - (seconds * 1000)
+        seekTo(maxOf(newPosition, 0))
+    }
+    
+    // Volume Control
+    fun setVolume(volume: Float) {
+        val clampedVolume = volume.coerceIn(0f, 1f)
+        this.volume = clampedVolume
+        exoPlayer?.volume = clampedVolume
+        onVolumeChange?.invoke(clampedVolume)
+    }
+    
+    fun mute() {
+        exoPlayer?.volume = 0f
+    }
+    
+    fun unmute() {
+        exoPlayer?.volume = volume
+    }
+    
+    fun toggleMute() {
+        exoPlayer?.let {
+            if (it.volume == 0f) {
+                unmute()
+            } else {
+                mute()
+            }
+        }
+    }
+    
+    // Playback Speed
+    fun setPlaybackSpeed(speed: Float) {
+        exoPlayer?.setPlaybackSpeed(speed)
+    }
+    
+    fun getPlaybackSpeed(): Float {
+        return exoPlayer?.playbackParameters?.speed ?: 1.0f
+    }
+    
+    // Quality Selection
+    fun setVideoQuality(quality: String) {
+        when (quality) {
+            "auto" -> trackSelector?.setParameters(
+                trackSelector!!.buildUponParameters().clearVideoSizeConstraints()
+            )
+            "hd" -> trackSelector?.setParameters(
+                trackSelector!!.buildUponParameters()
+                    .setMaxVideoSize(1920, 1080)
+                    .setMinVideoSize(1280, 720)
+            )
+            "sd" -> trackSelector?.setParameters(
+                trackSelector!!.buildUponParameters().setMaxVideoSizeSd()
+            )
+            "low" -> trackSelector?.setParameters(
+                trackSelector!!.buildUponParameters()
+                    .setMaxVideoSize(854, 480)
+            )
+        }
+    }
+    
+    // State Management
+    private fun updateState(newState: PlayerState) {
+        state = newState
+        onStateChange?.invoke(newState)
+        
+        if (configuration?.debug == true) {
+            Log.d(TAG, "State changed to: $newState")
+        }
+    }
+    
+    // Progress Updates
+    private fun startProgressUpdates() {
+        updateProgressHandler = object : Runnable {
+            override fun run() {
+                exoPlayer?.let {
+                    currentPosition = it.currentPosition
+                    bufferedPosition = it.bufferedPosition
+                    duration = it.duration
+                    
+                    onTimeUpdate?.invoke(currentPosition)
+                    onProgress?.invoke(bufferedPosition)
+                }
+                mainHandler.postDelayed(this, 100)
+            }
+        }
+        updateProgressHandler?.let { mainHandler.post(it) }
+    }
+    
+    private fun stopProgressUpdates() {
+        updateProgressHandler?.let { mainHandler.removeCallbacks(it) }
+    }
+    
+    // Player Event Listener
+    private val playerEventListener = object : Player.Listener {
+        
+        override fun onPlaybackStateChanged(playbackState: Int) {
+            when (playbackState) {
+                Player.STATE_IDLE -> updateState(PlayerState.IDLE)
+                Player.STATE_BUFFERING -> {
+                    updateState(PlayerState.BUFFERING)
+                    onBuffering?.invoke(true)
+                }
+                Player.STATE_READY -> {
+                    if (state == PlayerState.LOADING || state == PlayerState.BUFFERING) {
+                        updateState(PlayerState.READY)
+                        onReady?.invoke()
+                        emitLoadedMetadata()
+                    }
+                    if (state == PlayerState.BUFFERING) {
+                        onBuffering?.invoke(false)
+                    }
+                    if (exoPlayer?.isPlaying == true) {
+                        updateState(PlayerState.PLAYING)
+                    }
+                }
+                Player.STATE_ENDED -> {
+                    updateState(PlayerState.ENDED)
+                    onEnded?.invoke()
+                    
+                    if (configuration?.loop == true) {
+                        seekTo(0)
+                        play()
+                    }
+                }
+            }
+        }
+        
+        override fun onIsPlayingChanged(isPlaying: Boolean) {
+            this@UnifiedVideoPlayer.isPlaying = isPlaying
+            if (isPlaying) {
+                updateState(PlayerState.PLAYING)
+            } else if (state == PlayerState.PLAYING) {
+                updateState(PlayerState.PAUSED)
+            }
+        }
+        
+        override fun onPlayerError(error: PlaybackException) {
+            updateState(PlayerState.ERROR)
+            onError?.invoke(error)
+            
+            if (configuration?.debug == true) {
+                Log.e(TAG, "Player error: ${error.message}", error)
+            }
+        }
+        
+        override fun onVideoSizeChanged(videoSize: VideoSize) {
+            onVideoSizeChanged?.invoke(videoSize.width, videoSize.height)
+        }
+        
+        override fun onRenderedFirstFrame() {
+            Log.d(TAG, "First frame rendered")
+        }
+    }
+    
+    // Analytics Listener
+    private val analyticsListener = object : AnalyticsListener {
+        override fun onLoadCompleted(
+            eventTime: AnalyticsListener.EventTime,
+            loadEventInfo: LoadEventInfo,
+            mediaLoadData: MediaLoadData
+        ) {
+            Log.d(TAG, "Load completed: ${loadEventInfo.dataSpec.uri}")
+        }
+        
+        override fun onBandwidthEstimate(
+            eventTime: AnalyticsListener.EventTime,
+            totalLoadTimeMs: Int,
+            totalBytesLoaded: Long,
+            bitrateEstimate: Long
+        ) {
+            if (configuration?.debug == true) {
+                Log.d(TAG, "Bandwidth estimate: $bitrateEstimate bps")
+            }
+        }
+    }
+    
+    private fun emitLoadedMetadata() {
+        val metadata = mutableMapOf<String, Any>()
+        
+        exoPlayer?.let { player ->
+            metadata["duration"] = player.duration
+            
+            player.videoFormat?.let { format ->
+                metadata["width"] = format.width
+                metadata["height"] = format.height
+                metadata["frameRate"] = format.frameRate
+                metadata["bitrate"] = format.bitrate
+                metadata["codec"] = format.codecs ?: ""
+            }
+            
+            player.audioFormat?.let { format ->
+                metadata["audioChannels"] = format.channelCount
+                metadata["audioSampleRate"] = format.sampleRate
+                metadata["audioCodec"] = format.codecs ?: ""
+            }
+        }
+        
+        onLoadedMetadata?.invoke(metadata)
+    }
+    
+    // Surface Control (for advanced use cases)
+    fun setVideoSurface(surface: Surface?) {
+        exoPlayer?.setVideoSurface(surface)
+    }
+    
+    fun clearVideoSurface() {
+        exoPlayer?.clearVideoSurface()
+    }
+    
+    // Picture-in-Picture Support
+    fun enterPictureInPicture(): Boolean {
+        // Implementation depends on Activity context
+        // This would trigger PiP mode if supported
+        return false
+    }
+    
+    // Debug
+    private fun enableDebugLogging() {
+        Log.d(TAG, "Debug mode enabled")
+        Log.d(TAG, "Configuration: $configuration")
+    }
+    
+    // Lifecycle Management
+    fun onResume() {
+        exoPlayer?.let {
+            if (state == PlayerState.PLAYING) {
+                it.play()
+            }
+        }
+    }
+    
+    fun onPause() {
+        if (configuration?.allowBackgroundPlayback == false) {
+            exoPlayer?.pause()
+        }
+    }
+    
+    fun onStop() {
+        if (configuration?.allowBackgroundPlayback == false) {
+            exoPlayer?.stop()
+        }
+    }
+    
+    // Cleanup
+    fun release() {
+        stopProgressUpdates()
+        
+        exoPlayer?.apply {
+            removeListener(playerEventListener)
+            removeAnalyticsListener(analyticsListener)
+            release()
+        }
+        
+        playerView?.let {
+            container?.removeView(it)
+        }
+        
+        exoPlayer = null
+        playerView = null
+        container = null
+        
+        updateState(PlayerState.IDLE)
+    }
+}
+
+// Extension functions for easier use
+fun ExoPlayer.isBuffering(): Boolean {
+    return playbackState == Player.STATE_BUFFERING
+}
+
+fun ExoPlayer.hasEnded(): Boolean {
+    return playbackState == Player.STATE_ENDED
+}

package/packages/android/src/main/java/com/unifiedvideo/player/analytics/AnalyticsProvider.java

@@ -0,0 +1,9 @@
+package com.unifiedvideo.player.analytics;
+
+import java.util.Map;
+
+public interface AnalyticsProvider {
+    String getName();
+    void track(String event, Map<String, Object> data);
+}
+