Android Player SDK

Quickstart: Android Player

This guide will walk you through the steps to start a BlendVision One streaming playback on native Android application (mobile/tablet) using the Android player SDK.


Additionally, you can also check out the sample project for an even smoother start:


Before We Start

Before proceeding, ensure that you have prepared your BlendVision One streaming content. You can prepare your content in two ways:

Step 1: Obtain a Playback Token

  • Obtain a valid API token by following the authentication steps
  • Retrieve the resource_id and resource_type of the streaming content you would like to playback. There are two ways to obtain this information:
    • Retrieve using the API
    • Copy from your BlendVision One console
      • VOD > Publishing Tools > Player SDK > VOD ID
      • Live > Publishing Tools > Player SDK > Event ID

  • Obtain the playback token using the API: /bv/cms/v1/tokens, with the resource_id and resource_type as body parameters

    • You can also include customer_id in the body parameters if you want to track user playback with your own defined user ID

const val API_DOMAIN = ""

interface ApiService {
    suspend fun getPlaybackToken(
        @Header("Authorization") cmsToken: String, // 'Bearer ${CMS token}'
        @Body request: PlaybackTokenRequest()
    }: PlaybackTokenResponse

data class PlaybackTokenRequest(
    val resourceId: String,
    val resourceType: String,
    val customerId: String

data class PlaybackTokenResponse(
    val playbackToken: String


Step 2: Start a Playback Session

const val API_DOMAIN = ""

interface ApiService {
    suspend fun startPlaybackSession(
        @Header("Authorization") playbackToken: String,
        @Path("deviceId") deviceId: String
    ): StartSessionResponse
    suspend fun getStreamInfo(
        @Header("Authorization") playbackToken: String,
        @Path("deviceId") deviceId: String
    ): GetStreamInfoResponse

// data for start a session
data class StartSessionResponse(
    val endPoint: String

// data for get stream information
data class GetStreamInfoResponse(
    val sources: List

data class Source(
    val manifests: List,
    val thumbnailSeekingUrl: String

data class Manifest(
    val protocal: String,
    val url: String,
    val resolutions: List

data class Resolution(
    val height: String,
    val width: String


Step 3: Initialize the Player

Obtain Player License Key

Obtain a valid player license key from your BlendVision One console

Install Player SDK

  • Download from
  • Create /libs folder in the project root path

  • Add below description in the gradle

    implementation fileTree(dir: 'libs', include: ['*.aar'])
  • Add following .aar files to libs/.

    // UniPlayer
    // KKSPlayer
    // KKS-network
    • others (can be imported from public maven)
    plugins {
        id 'kotlin-kapt'
    api ('' + guava_version) {
        // Exclude dependencies that are only used by Guava at compile time
        // (but declared as runtime deps) [internal b/168188131].
        exclude group: '', module: 'jsr305'
        exclude group: 'org.checkerframework', module: 'checker-compat-qual'
        exclude group: '', module: 'error_prone_annotations'
        exclude group: '', module: 'j2objc-annotations'
        exclude group: 'org.codehaus.mojo', module: 'animal-sniffer-annotations'
    //Google IMA SDK
    implementation "$google_ima_version"
    implementation "$cast_version"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
    implementation 'com.squareup.okhttp3:okhttp:' + okhttp_version
    implementation "com.squareup.okhttp3:logging-interceptor:$okhttp_version"
    // gson
    implementation '' + gsonVersion
    // thumbnail
    implementation "com.github.bumptech.glide:glide:$glideVersion"
    kapt "com.github.bumptech.glide:compiler:$glideVersion"
  • Set


Create a Player

To play the streaming content, create a player instance with the license key and stream information in the initialization configuration:

// create the player instance
private var player: UniPlayer? = null
player = UniPlayer.Builder(
            license = "YOUR_LICENSE_KEY"
// set player view type
    defaultContentType = ContentType.STANDALONE

// bind the new created player to player view

// load stream information
        source = listOf(
                url = streamInfoResponse.sources[0].manifests.filter { it.protocol == MediaConfig.Protocol.DASH }[0].url,
                protocal = MediaConfig.Protocol.DASH,
                drm = MediaConfig.DrmInfo.Widevine(
                    licenseUrl = startSessionResponse.endPoint,
                    headers = mapOf("" to "")
        title = "",
        imageUrl = "",
        thumbnailSeekingUrl = ""

// start playback

// pause/play during playback

// release the player


Step 4: Manage the Lifecycle of a Playback Session

const val API_DOMAIN = ""

interface ApiService {

    // post this API every 10 seconds
    suspend fun Heartbeat(
        @Header("Authorization") playbackToken: String,
        @Path("deviceId") deviceId: String
    suspend fun EndPlaybackSession(
        @Header("Authorization") playbackToken: String,
        @Path("deviceId") deviceId: String


What's More