Drm Exoplayer

MainActivity.kt

package com.example.exoplayerex

import android.net.Uri
import android.util.Base64
import android.view.ViewGroup
import android.widget.FrameLayout
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.media3.common.C
import androidx.media3.common.MediaItem
import androidx.media3.common.MimeTypes
import androidx.media3.datasource.DefaultHttpDataSource
import androidx.media3.exoplayer.ExoPlayer
import androidx.media3.exoplayer.dash.DashMediaSource
import androidx.media3.exoplayer.drm.DefaultDrmSessionManager
import androidx.media3.exoplayer.drm.FrameworkMediaDrm
import androidx.media3.exoplayer.drm.LocalMediaDrmCallback
import androidx.media3.exoplayer.source.MergingMediaSource
import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
import androidx.media3.ui.PlayerView

@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
@Composable
fun Live() {
    val context = LocalContext.current
    val trackSelector = DefaultTrackSelector(context)

    val drmKey = "b8ed4930014a0ad8f4bc2310f378edd2"
    val drmKeyId = "89413479ba07590893320faf05a6b7fd"
    val mpdUrl =
        "https://bpprod3linear.akamaized.net/bpk-tv/irdeto_com_Channel_301/output/manifest.mpd"

    val encodedDrmKey = Base64.encodeToString(drmKey.toByteArray(), Base64.URL_SAFE)
    val encodedDrmKeyId = Base64.encodeToString(drmKeyId.toByteArray(), Base64.URL_SAFE)


    val player: ExoPlayer = remember {
        ExoPlayer.Builder(context).setTrackSelector(trackSelector)
            .build()
            .apply {
                prepare()
            }
    }

    /*  //val factory = DefaultMediaSourceFactory(context)
      val defaultHttpDataSourceFactory = DefaultHttpDataSource.Factory()
          .setUserAgent(U_A)
          .setTransferListener(
              DefaultBandwidthMeter.Builder(context)
                  .setResetOnNetworkTypeChange(false)
                  .build()
          )

      val dashChunkSourceFactory: DashChunkSource.Factory = DefaultDashChunkSource.Factory(
          defaultHttpDataSourceFactory
      )

      val manifestDataSourceFactory = DefaultHttpDataSource.Factory().setUserAgent(USER_AGENT)

      val dashMediaSource =
          DashMediaSource.Factory(dashChunkSourceFactory, manifestDataSourceFactory)
              .createMediaSource(
                  MediaItem.Builder()
                      .setUri(Uri.parse(mpdUrl))
                      // DRM Configuration
                      .setDrmConfiguration(
                          MediaItem.DrmConfiguration.Builder(C.CLEARKEY_UUID)
                              .setKeySetId("{\"keys\":[{\"kty\":\"oct\",\"k\":\"${encodedDrmKey}\",\"kid\":\"${encodedDrmKeyId}\"}],\"type\":\"temporary\"}".toByteArray())
                              .build()


                      )
                      .setMimeType(MimeTypes.APPLICATION_MPD)
                      .setTag(null)
                      .build()
              )*/

    val manifestDataSourceFactory = DefaultHttpDataSource.Factory()

    val drmCallback =
        LocalMediaDrmCallback("{\"keys\":[{\"kty\":\"oct\",\"k\":\"${encodedDrmKey}\",\"kid\":\"${encodedDrmKeyId}\"}],\"type\":\"temporary\"}".toByteArray())
    val manager = DefaultDrmSessionManager.Builder()
        .setMultiSession(false)
        .setKeyRequestParameters(
            HashMap<String, String>(
                mapOf(
                    Pair("Host", "bpprod3linear.akamaized.net"),
                )
            )
        )
        .setUuidAndExoMediaDrmProvider(
            C.CLEARKEY_UUID,
            FrameworkMediaDrm.DEFAULT_PROVIDER,
        )

        .build(drmCallback)


    //DashMediaSource.Factory(manifestDataSourceFactory)
    //  .setDrmSessionManagerProvider { manager }
    //.createMediaSource(MediaItem.fromUri(mpdUrl))


    Column(
        modifier =
        Modifier
            .fillMaxWidth()
            .height(260.dp),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AndroidView(
            factory = {
                PlayerView(context).apply {
                    this.player = player
                    player.playWhenReady = true
             
                    player.prepare(
                        MergingMediaSource(
                            DashMediaSource.Factory(manifestDataSourceFactory)
                                .setDrmSessionManagerProvider { manager }
                                .createMediaSource(
                                    MediaItem.Builder()
                                        .setUri(Uri.parse(mpdUrl))
                                        .setDrmConfiguration(
                                            MediaItem.DrmConfiguration.Builder(C.WIDEVINE_UUID)
                                                .setLicenseUri("https://widevine-proxy.appspot.com/proxy")
                                                .build()


                                        )
                                        .setMimeType(MimeTypes.APPLICATION_MPD)
                                        .setTag(null)
                                        .build()
                                )

                        )
                    )


                    layoutParams = FrameLayout.LayoutParams(
                        ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT
                    )
                }
            },
            modifier = Modifier
                .fillMaxSize()
                .padding(0.dp, 0.dp, 0.dp, 0.dp)
                .background(Color.Black)
        )
    }
}