PreRequisites

• Android Studio
• Gradle (5.6.4 or later)
• Target API level 24 or later
• Bitmovin Key to add in AndroidManifest.xml

Quick Start Guide

Adding MKPlayer Dependencies

    $ROOT/build.gradle:

        allprojects {
            repositories {
                maven {
                    url 'http://bitmovin.bintray.com/maven'
                }
                maven {
                    url 'https://mkplayer.jfrog.io/artifactory/mkplayer/'
                }
            }
        }

    $ROOT/app/build.gradle:

        dependencies {
            compile(group: 'com.mediakind', name: 'mkplayer', version: '0.9.0', ext: 'aar') {
               transitive =true
            }
        }

Player Initialization

    private lateinit var mkplayer: MKPlayer
    private var configuration: MKPlayerConfiguration? = null
    configuration!!.isUiEnabled = false // Pass as true if Bitmovin UI is required
    mkplayer = MKPlayer(applicationContext, rootView, configuration!!)
    mkplayer.initPlayer()

Event Registration

Register your event listeners prior to loading a source to make sure you have visibility into the video playback session:

    mkplayer.addEventListener(onMKAdEventListener)
    mkplayer.addEventListener(onMKErrorListener)
    mkplayer.addEventListener(onMKMutedListener)
    mkplayer.addEventListener(onMKPausedListener)
    mkplayer.addEventListener(onMKPlayListener)
    mkplayer.addEventListener(onMKPlaybackFinishedListener)
    mkplayer.addEventListener(onMKPlayingListener)
    mkplayer.addEventListener(onMKReadyListener)
    mkplayer.addEventListener(onMKSeekListener)
    mkplayer.addEventListener(onMKSeekedListener)
    mkplayer.addEventListener(onMKSourceLoadListener)
    mkplayer.addEventListener(onMKSourceLoadedListener)
    mkplayer.addEventListener(onMKSourceUnloadedListener)
    mkplayer.addEventListener(onMKUnmutedListener)
    mkplayer.addEventListener(onMKTimeChangedListener)

    private val onMKErrorListener = object : OnMKErrorListener {
        override fun onError(event: MKPErrorEvent) {
            Log.e(TAG,"An error occurred (" + event.getCode().toString() + "): " + event.getMessage())
        }
    }

    private val onMKPlayListener = object : OnMKPlayListener {
        override fun onPlay(eventMKP: MKPPlayEvent) {
            Log.d(TAG, "Received onMKPlay Callback " + eventMKP.getTime())
        }
    }

    private val onMKPausedListener = object : OnMKPausedListener {
        override fun onPaused(event: MKPPausedEvent) {
            Log.d(TAG, "Received onPaused Callback " + event.getTime())
        }
    }

    private val onMKMutedListener = object : OnMKMutedListener {
        override fun onMuted(event: MKPMutedEvent) {
        }
    }

    private val onMKPlaybackFinishedListener = object : OnMKPlaybackFinishedListener {
        override fun onPlaybackFinished(finishedEvent: MKPlaybackFinishedEvent) {
            Log.d(TAG, "Received onMKPlaybackFinished Callback")
        }
    }

    private val onMKPlayingListener = object : OnMKPlayingListener {
        override fun onPlaying(event: MKPPlayingEvent) {
        }
    }

    private val onMKReadyListener = object : OnMKReadyListener {
        override fun onReady(event: MKPReadyEvent) {
            Log.d(TAG, "Received onMKReady Callback")
        }
    }

    private val onMKSeekListener = object : OnMKSeekListener {
        override fun onSeek(event: MKPSeekEvent) {
            Log.d(TAG, "Received onMKSeek Callback positionMK" +
                        " ${event.getPosition()} " +
                        "target positionMK  ${event.getSeekTarget()}"
            )
        }
    }

    private val onMKSeekedListener = object : OnMKSeekedListener {
        override fun onSeeked(event: MKPSeekedEvent) {
            Log.d(TAG, "Received onMKSeeked Callback")
        }
    }

    private val onMKSourceLoadListener = object : OnMKSourceLoadListener {
        override fun onSourceLoad(event: MKPSourceLoadEvent) {
            Log.d(TAG, "Received onMKSourceLoad Callback")
        }
    }

    private val onMKSourceLoadedListener = object : OnMKSourceLoadedListener {
        override fun onSourceLoaded(event: MKPSourceLoadedEvent) {
            Log.d(TAG, "Received onMKSourceLoaded Callback")
        }
    }

    private val onMKSourceUnloadedListener = object : OnMKSourceUnloadedListener {
        override fun onSourceUnloaded(event: MKPSourceUnloadEvent) {
            Log.d(TAG, "Received onMKSourceUnLoaded Callback")
        }
    }

    private val onMKUnmutedListener = object : OnMKUnmutedListener {
        override fun onUnmute(event: MKPUnmutedEvent) {
        }
    }

    private val onMKTimeChangedListener = object : OnMKTimeChangeListener {
        override fun onTimeChanged(var1: Double) {
        }
    }

Stream Loading

    // Play clear content using Source URL
    mkplayer.load("https://bitdash-a.akamaihd.net/content/sintel/sintel.mpd")

    // Play encrypted content using a Source Configuration (see source_list.json)
    // create an object of SourceConfiguration and assign values
    sourceConfiguration?.externalSourceUrl = "https://storage.googleapis.com/wvmedia/cenc/h264/tears/tears.mpd"
    sourceConfiguration?.externalSourceLicenseUrl = "https://proxy.uat.widevine.com/proxy?provider=widevine_test"
    mkplayer.load(sourceConfiguration) 

Stream Playback

    mkplayer.play()

Application Lifecycle Events

    mkplayer.onActivityPaused()
    mkplayer.onActivityResumed()
    mkplayer.onActivityStopped()
    mkplayer.onActivityDestroyed()

Load new stream

    // To unload current URL
    mkplayer.unload()
    After unload callback please follow Stream Loading and Stream Playback sections

Player Cleanup

    // Call removeEventListener which are registered with addEventListener

    // For example
    removeEventListener(onMKErrorListener)

    // To unload current URL
    mkplayer.unload()

    // After calling destroy it is expected that no api should be called on mkplayer object and recreate mkplayer

    mkplayer.destroy()