Question

我正在尝试为ExoPlayer 2实现脱机DRM支持，但我遇到了一些问题。

我发现了conversation。 ExoPlayer 1.x有一些实现，有些步骤如何使用ExoPlayer 2.x实现该实现。

我对OfflineDRMSessionManager whitch implements DrmSessionManager有疑问。在该示例中是从ExoPlayer 1.x导入的DrmSessionManager。如果我从ExoPlayer 2导入它，那么我有编译它的问题。我遇到了@Override方法（open（），close（），..）的问题，这些方法不在新的DrmSessionManager中，并且有一些新方法：acquireSession()，...。

Answer 1

使用ExoPlayer 2.2.0的最新版本，它在ExoPlayer中提供了此功能。 ExoPlayer有一个帮助程序类可以下载和刷新脱机许可证密钥。这应该是首选方法。

OfflineLicenseHelper.java
/**
 * Helper class to download, renew and release offline licenses. It utilizes {@link
 * DefaultDrmSessionManager}.
 */
public final class OfflineLicenseHelper<T extends ExoMediaCrypto> {

您可以访问ExoPlayer repo

中的最新代码

我创建了一个脱机播放DRM内容的示例应用程序。您可以从here

访问它

Answer 2

正如@TheJango解释的那样，在ExoPlayer 2.2.0的最新版本中，它提供了ExoPlayer内置的这个功能。但是，OfflineLicenseHelper类的设计考虑了一些VOD用例。购买电影，保存许可证（下载方法），下载电影，在DefaultDrmSessionManager中加载许可证，然后设置模式进行播放。

另一个用例可能是你想制作一个在线流媒体系统，其中不同的内容使用相同的许可证（例如电视）相当一段时间（例如24小时）更智能。因此，它永远不会下载已经拥有的许可证（假设您的DRM系统按照许可证请求向您收费，否则将会有大量相同许可证的请求），以下方法可以与ExoPlayer 2.2.0一起使用。我花了一些时间来获得一个有效的解决方案，而无需修改ExoPlayer源代码。我不太喜欢他们使用setMode()方法采用的方法，只能调用一次。以前DrmSessionManager可用于多个会话（音频，视频），现在如果许可证不同或来自不同的方法（下载，播放，...），它们将不再有效。无论如何，我引入了一个新的类CachingDefaultDrmSessionManager来替换你可能正在使用的DefaultDrmSessionManager。在内部，它委托给DefaultDrmSessionManager。

package com.google.android.exoplayer2.drm;

import android.content.Context;
import android.content.SharedPreferences;
import java.util.concurrent.atomic.AtomicBoolean;
import android.os.Handler;
import android.os.Looper;
import android.util.Base64;
import android.util.Log;

import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.extractor.mp4.PsshAtomUtil;
import com.google.android.exoplayer2.util.Util;

import java.util.Arrays;
import java.util.HashMap;
import java.util.UUID;

import static com.google.android.exoplayer2.drm.DefaultDrmSessionManager.MODE_DOWNLOAD;
import static com.google.android.exoplayer2.drm.DefaultDrmSessionManager.MODE_QUERY;

public class CachingDefaultDrmSessionManager<T extends ExoMediaCrypto> implements DrmSessionManager<T> {

    private final SharedPreferences drmkeys;
    public static final String TAG="CachingDRM";
    private final DefaultDrmSessionManager<T> delegateDefaultDrmSessionManager;
    private final UUID uuid;
    private final AtomicBoolean pending = new AtomicBoolean(false);
    private byte[] schemeInitD;

    public interface EventListener {
        void onDrmKeysLoaded();
        void onDrmSessionManagerError(Exception e);
        void onDrmKeysRestored();
        void onDrmKeysRemoved();
    }

    public CachingDefaultDrmSessionManager(Context context, UUID uuid, ExoMediaDrm<T> mediaDrm, MediaDrmCallback callback, HashMap<String, String> optionalKeyRequestParameters, final Handler eventHandler, final EventListener eventListener) {
        this.uuid = uuid;
        DefaultDrmSessionManager.EventListener eventListenerInternal = new DefaultDrmSessionManager.EventListener() {

            @Override
            public void onDrmKeysLoaded() {
                saveDrmKeys();
                pending.set(false);
                if (eventListener!=null) eventListener.onDrmKeysLoaded();
            }

            @Override
            public void onDrmSessionManagerError(Exception e) {
                pending.set(false);
                if (eventListener!=null) eventListener.onDrmSessionManagerError(e);
            }

            @Override
            public void onDrmKeysRestored() {
                saveDrmKeys();
                pending.set(false);
                if (eventListener!=null) eventListener.onDrmKeysRestored();
            }

            @Override
            public void onDrmKeysRemoved() {
                pending.set(false);
                if (eventListener!=null) eventListener.onDrmKeysRemoved();
            }
        };
        delegateDefaultDrmSessionManager = new DefaultDrmSessionManager<T>(uuid, mediaDrm, callback, optionalKeyRequestParameters, eventHandler, eventListenerInternal);
        drmkeys = context.getSharedPreferences("drmkeys", Context.MODE_PRIVATE);
    }

    final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
    public static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for ( int j = 0; j < bytes.length; j++ ) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }

    public void saveDrmKeys() {
        byte[] offlineLicenseKeySetId = delegateDefaultDrmSessionManager.getOfflineLicenseKeySetId();
        if (offlineLicenseKeySetId==null) {
            Log.i(TAG,"Failed to download offline license key");
        } else {
            Log.i(TAG,"Storing downloaded offline license key for "+bytesToHex(schemeInitD)+": "+bytesToHex(offlineLicenseKeySetId));
            storeKeySetId(schemeInitD, offlineLicenseKeySetId);
        }
    }

    @Override
    public DrmSession<T> acquireSession(Looper playbackLooper, DrmInitData drmInitData) {
        if (pending.getAndSet(true)) {
             return delegateDefaultDrmSessionManager.acquireSession(playbackLooper, drmInitData);
        }
        // First check if we already have this license in local storage and if it's still valid.
        DrmInitData.SchemeData schemeData = drmInitData.get(uuid);
        schemeInitD = schemeData.data;
        Log.i(TAG,"Request for key for init data "+bytesToHex(schemeInitD));
        if (Util.SDK_INT < 21) {
            // Prior to L the Widevine CDM required data to be extracted from the PSSH atom.
            byte[] psshData = PsshAtomUtil.parseSchemeSpecificData(schemeInitD, C.WIDEVINE_UUID);
            if (psshData == null) {
                // Extraction failed. schemeData isn't a Widevine PSSH atom, so leave it unchanged.
            } else {
                schemeInitD = psshData;
            }
        }
        byte[] cachedKeySetId=loadKeySetId(schemeInitD);
        if (cachedKeySetId!=null) {
            //Load successful.
            Log.i(TAG,"Cached key set found "+bytesToHex(cachedKeySetId));
            if (!Arrays.equals(delegateDefaultDrmSessionManager.getOfflineLicenseKeySetId(), cachedKeySetId))
            {
                delegateDefaultDrmSessionManager.setMode(MODE_QUERY, cachedKeySetId);
            }
        } else {
            Log.i(TAG,"No cached key set found ");
            delegateDefaultDrmSessionManager.setMode(MODE_DOWNLOAD,null);
        }
        DrmSession<T> tDrmSession = delegateDefaultDrmSessionManager.acquireSession(playbackLooper, drmInitData);
        return tDrmSession;
    }

    @Override
    public void releaseSession(DrmSession<T> drmSession) {
        pending.set(false);
        delegateDefaultDrmSessionManager.releaseSession(drmSession);
    }

    public void storeKeySetId(byte[] initData, byte[] keySetId) {
        String encodedInitData = Base64.encodeToString(initData, Base64.NO_WRAP);
        String encodedKeySetId = Base64.encodeToString(keySetId, Base64.NO_WRAP);
        drmkeys.edit()
                .putString(encodedInitData, encodedKeySetId)
                .apply();
    }

    public byte[] loadKeySetId(byte[] initData) {
        String encodedInitData = Base64.encodeToString(initData, Base64.NO_WRAP);
        String encodedKeySetId = drmkeys.getString(encodedInitData, null);
        if (encodedKeySetId == null) return null;
        return Base64.decode(encodedKeySetId, 0);
    }

}

此处密钥在本地存储中作为Base64编码字符串保留。因为对于典型的DASH流，音频和视频渲染器都将从DrmSessionManager请求许可，可能同时使用AtomicBoolean。如果音频和/或视频使用不同的密钥，我认为这种方法会失败。此外，我还没有检查过期密钥。看看OfflineLicenseHelper，看看如何处理这些问题。

Answer 3

@ Pepa Zapletal，继续进行以下更改，以便离线播放。

您还可以看到更新的答案here。

更改如下：

将方法private void onKeyResponse(Object response)的签名更改为private void onKeyResponse(Object response, boolean offline)
而不是发送文件清单URI将存储的文件路径发送到PlayerActivity.java.
将MediaDrm.KEY_TYPE_STREAMING更改为MediaDrm.KEY_TYPE_OFFLINE中的getKeyRequest()。
在postKeyRequest()中首先检查密钥是否已存储，如果找到密钥，则直接调用onKeyResponse(key, true)。
在onKeyResponse()中，拨打restoreKeys()而不是致电provideKeyResponse()。
其余的一切都一样，现在你的文件将会播放。

主要角色：此处provideKeyResponse()和restoreKeys()是本机方法，在获取密钥和恢复密钥方面起主要作用。

provideKeyResponse()方法将返回字节数组中的主许可证密钥当且仅当keyType为MediaDrm.KEY_TYPE_OFFLINE时，此方法将返回空字节数组我们对那个数组无能为力。

restoreKeys()方法将期望为当前会话恢复的密钥，因此将我们已经存储在本地的密钥提供给此方法，它将处理它。

注意：首先，您必须以某种方式下载许可证密钥并将其安全地存储在本地设备中。

在我的情况下，首先我在线播放文件，因此exoplayer将获取我在本地存储的密钥。从第二次开始，它将首先检查密钥是否存储，如果密钥被发现，它将跳过许可证密钥请求并播放文件。

用这些东西替换StreamingDrmSessionManager.java的方法和内部类。

private void postKeyRequest() {
    KeyRequest keyRequest;
    try {
        // check is key exist in local or not, if exist no need to
        // make a request License server for the key.
      byte[] keyFromLocal = Util.getKeyFromLocal();
      if(keyFromLocal != null) {
          onKeyResponse(keyFromLocal, true);
          return;
      }

      keyRequest = mediaDrm.getKeyRequest(sessionId, schemeData.data, schemeData.mimeType, MediaDrm.KEY_TYPE_OFFLINE, optionalKeyRequestParameters);
      postRequestHandler.obtainMessage(MSG_KEYS, keyRequest).sendToTarget();
    } catch (NotProvisionedException e) {
      onKeysError(e);
    }
  }


private void onKeyResponse(Object response, boolean offline) {
    if (state != STATE_OPENED && state != STATE_OPENED_WITH_KEYS) {
      // This event is stale.
      return;
    }

    if (response instanceof Exception) {
      onKeysError((Exception) response);
      return;
    }

    try {
        // if we have a key and we want to play offline then call 
        // 'restoreKeys()' with the key which we have already stored.
        // Here 'response' is the stored key. 
        if(offline) {
            mediaDrm.restoreKeys(sessionId, (byte[]) response);
        } else {
            // Don't have any key in local, so calling 'provideKeyResponse()' to
            // get the main License key and store the returned key in local.
            byte[] bytes = mediaDrm.provideKeyResponse(sessionId, (byte[]) response);
            Util.storeKeyInLocal(bytes);
        }
      state = STATE_OPENED_WITH_KEYS;
      if (eventHandler != null && eventListener != null) {
        eventHandler.post(new Runnable() {
          @Override
          public void run() {
            eventListener.onDrmKeysLoaded();
          }
        });
      }
    } catch (Exception e) {
      onKeysError(e);
    }
  }


@SuppressLint("HandlerLeak")
  private class PostResponseHandler extends Handler {

    public PostResponseHandler(Looper looper) {
      super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {
        case MSG_PROVISION:
          onProvisionResponse(msg.obj);
          break;
        case MSG_KEYS:
          // We don't have key in local so calling 'onKeyResponse()' with offline to 'false'.
          onKeyResponse(msg.obj, false);
          break;
      }
    }

  }

Android - ExoPlayer 2脱机播放DRM（broadvine）

3 个答案: