Modular DRM for MediaPlayer
Bug: 34559906
Test: Manual through the test app
Change-Id: I752c3e2bbc2fac9c75f7ddc986014c4b8ce75d84
diff --git a/include/media/IMediaPlayer.h b/include/media/IMediaPlayer.h
index f642373..ca865a8 100644
--- a/include/media/IMediaPlayer.h
+++ b/include/media/IMediaPlayer.h
@@ -24,6 +24,7 @@
#include <system/audio.h>
#include <media/IMediaSource.h>
+#include <media/drm/DrmAPI.h> // for DrmPlugin::* enum
// Fwd decl to make sure everyone agrees that the scope of struct sockaddr_in is
// global, and not in android::
@@ -89,6 +90,22 @@
virtual status_t setRetransmitEndpoint(const struct sockaddr_in* endpoint) = 0;
virtual status_t getRetransmitEndpoint(struct sockaddr_in* endpoint) = 0;
virtual status_t setNextPlayer(const sp<IMediaPlayer>& next) = 0;
+ // ModDrm
+ virtual status_t prepareDrm(const uint8_t uuid[16], const int mode) = 0;
+ virtual status_t releaseDrm() = 0;
+ virtual status_t getKeyRequest(Vector<uint8_t> const& scope,
+ String8 const &mimeType,
+ DrmPlugin::KeyType keyType,
+ KeyedVector<String8, String8>& optionalParameters,
+ Vector<uint8_t>& request,
+ String8& defaultUrl,
+ DrmPlugin::KeyRequestType& keyRequestType) = 0;
+ virtual status_t provideKeyResponse(Vector<uint8_t>& releaseKeySetId,
+ Vector<uint8_t>& response,
+ Vector<uint8_t>& keySetId) = 0;
+ virtual status_t restoreKeys(Vector<uint8_t> const& keySetId) = 0;
+ virtual status_t getDrmPropertyString(String8 const& name, String8& value) = 0;
+ virtual status_t setDrmPropertyString(String8 const& name, String8 const& value) = 0;
// Invoke a generic method on the player by using opaque parcels
// for the request and reply.
diff --git a/include/media/MediaPlayerInterface.h b/include/media/MediaPlayerInterface.h
index 0e815cb..4e18f1f 100644
--- a/include/media/MediaPlayerInterface.h
+++ b/include/media/MediaPlayerInterface.h
@@ -280,6 +280,34 @@
return INVALID_OPERATION;
}
+ // ModDrm
+ virtual status_t prepareDrm(const uint8_t uuid[16], const int mode) {
+ return INVALID_OPERATION;
+ }
+ virtual status_t releaseDrm() {
+ return INVALID_OPERATION;
+ }
+ virtual status_t getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,
+ DrmPlugin::KeyType keyType,
+ KeyedVector<String8, String8>& optionalParameters,
+ Vector<uint8_t>& request, String8& defaultUrl,
+ DrmPlugin::KeyRequestType& keyRequestType) {
+ return INVALID_OPERATION;
+ }
+ virtual status_t provideKeyResponse(Vector<uint8_t>& releaseKeySetId,
+ Vector<uint8_t>& response, Vector<uint8_t>& keySetId) {
+ return INVALID_OPERATION;
+ }
+ virtual status_t restoreKeys(Vector<uint8_t> const& keySetId) {
+ return INVALID_OPERATION;
+ }
+ virtual status_t getDrmPropertyString(String8 const& name, String8& value) {
+ return INVALID_OPERATION;
+ }
+ virtual status_t setDrmPropertyString(String8 const& name, String8 const& value) {
+ return INVALID_OPERATION;
+ }
+
private:
friend class MediaPlayerService;
diff --git a/include/media/mediaplayer.h b/include/media/mediaplayer.h
index 5d7c25a..2c5ff1f 100644
--- a/include/media/mediaplayer.h
+++ b/include/media/mediaplayer.h
@@ -55,6 +55,7 @@
MEDIA_INFO = 200,
MEDIA_SUBTITLE_DATA = 201,
MEDIA_META_DATA = 202,
+ MEDIA_DRM_INFO = 210,
};
// Generic error codes for the media player framework. Errors are fatal, the
@@ -260,6 +261,19 @@
status_t getParameter(int key, Parcel* reply);
status_t setRetransmitEndpoint(const char* addrString, uint16_t port);
status_t setNextMediaPlayer(const sp<MediaPlayer>& player);
+ // ModDrm
+ status_t prepareDrm(const uint8_t uuid[16], const int mode);
+ status_t releaseDrm();
+ status_t getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,
+ DrmPlugin::KeyType keyType,
+ KeyedVector<String8, String8>& optionalParameters,
+ Vector<uint8_t>& request, String8& defaultUrl,
+ DrmPlugin::KeyRequestType& keyRequestType);
+ status_t provideKeyResponse(Vector<uint8_t>& releaseKeySetId,
+ Vector<uint8_t>& response, Vector<uint8_t>& keySetId);
+ status_t restoreKeys(Vector<uint8_t> const& keySetId);
+ status_t getDrmPropertyString(String8 const& name, String8& value);
+ status_t setDrmPropertyString(String8 const& name, String8 const& value);
private:
void clear_l();
diff --git a/media/libmedia/IMediaPlayer.cpp b/media/libmedia/IMediaPlayer.cpp
index 9ffde4e..966267a 100644
--- a/media/libmedia/IMediaPlayer.cpp
+++ b/media/libmedia/IMediaPlayer.cpp
@@ -70,8 +70,28 @@
SET_RETRANSMIT_ENDPOINT,
GET_RETRANSMIT_ENDPOINT,
SET_NEXT_PLAYER,
+ // ModDrm
+ PREPARE_DRM,
+ RELEASE_DRM,
+ GET_KEY_REQUEST,
+ PROVIDE_KEY_RESPONSE,
+ RESTORE_KEYS,
+ GET_DRM_PROPERTY_STRING,
+ SET_DRM_PROPERTY_STRING,
};
+// ModDrm helpers
+static void readVector(const Parcel& reply, Vector<uint8_t>& vector) {
+ uint32_t size = reply.readUint32();
+ vector.insertAt((size_t)0, size);
+ reply.read(vector.editArray(), size);
+}
+
+static void writeVector(Parcel& data, Vector<uint8_t> const& vector) {
+ data.writeUint32(vector.size());
+ data.write(vector.array(), vector.size());
+}
+
class BpMediaPlayer: public BpInterface<IMediaPlayer>
{
public:
@@ -447,6 +467,137 @@
return err;
}
+
+ // ModDrm
+ status_t prepareDrm(const uint8_t uuid[16], const int mode)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ data.write(uuid, 16);
+ data.writeInt32(mode);
+
+ status_t status = remote()->transact(PREPARE_DRM, data, &reply);
+ if (status != OK) {
+ ALOGE("prepareDrm: binder call failed: %d", status);
+ return status;
+ }
+
+ return reply.readInt32();
+ }
+
+ status_t releaseDrm()
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ status_t status = remote()->transact(RELEASE_DRM, data, &reply);
+ if (status != OK) {
+ ALOGE("releaseDrm: binder call failed: %d", status);
+ return status;
+ }
+
+ return reply.readInt32();
+ }
+
+ status_t getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,
+ DrmPlugin::KeyType keyType, KeyedVector<String8, String8>& optionalParameters,
+ Vector<uint8_t>& request, String8& defaultUrl,
+ DrmPlugin::KeyRequestType& keyRequestType)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ writeVector(data, scope);
+ data.writeString8(mimeType);
+ data.writeInt32((int32_t)keyType);
+
+ data.writeUint32(optionalParameters.size());
+ for (size_t i = 0; i < optionalParameters.size(); ++i) {
+ data.writeString8(optionalParameters.keyAt(i));
+ data.writeString8(optionalParameters.valueAt(i));
+ }
+
+ status_t status = remote()->transact(GET_KEY_REQUEST, data, &reply);
+ if (status != OK) {
+ ALOGE("getKeyRequest: binder call failed: %d", status);
+ return status;
+ }
+
+ readVector(reply, request);
+ defaultUrl = reply.readString8();
+ keyRequestType = (DrmPlugin::KeyRequestType)reply.readInt32();
+
+ return reply.readInt32();
+ }
+
+ status_t provideKeyResponse(Vector<uint8_t>& releaseKeySetId, Vector<uint8_t>& response,
+ Vector<uint8_t> &keySetId)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ writeVector(data, releaseKeySetId);
+ writeVector(data, response);
+
+ status_t status = remote()->transact(PROVIDE_KEY_RESPONSE, data, &reply);
+ if (status != OK) {
+ ALOGE("provideKeyResponse: binder call failed: %d", status);
+ return status;
+ }
+
+ readVector(reply, keySetId);
+
+ return reply.readInt32();
+ }
+
+ status_t restoreKeys(Vector<uint8_t> const& keySetId)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ writeVector(data, keySetId);
+
+ status_t status = remote()->transact(RESTORE_KEYS, data, &reply);
+ if (status != OK) {
+ ALOGE("restoreKeys: binder call failed: %d", status);
+ return status;
+ }
+
+ return reply.readInt32();
+ }
+
+ status_t getDrmPropertyString(String8 const& name, String8& value)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ data.writeString8(name);
+ status_t status = remote()->transact(GET_DRM_PROPERTY_STRING, data, &reply);
+ if (status != OK) {
+ ALOGE("getDrmPropertyString: binder call failed: %d", status);
+ return status;
+ }
+
+ value = reply.readString8();
+ return reply.readInt32();
+ }
+
+ status_t setDrmPropertyString(String8 const& name, String8 const& value)
+ {
+ Parcel data, reply;
+ data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
+
+ data.writeString8(name);
+ data.writeString8(value);
+ status_t status = remote()->transact(SET_DRM_PROPERTY_STRING, data, &reply);
+ if (status != OK) {
+ ALOGE("setDrmPropertyString: binder call failed: %d", status);
+ return status;
+ }
+
+ return reply.readInt32();
+ }
};
IMPLEMENT_META_INTERFACE(MediaPlayer, "android.media.IMediaPlayer");
@@ -741,6 +892,93 @@
return NO_ERROR;
} break;
+
+ // ModDrm
+ case PREPARE_DRM: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+ uint8_t uuid[16];
+ data.read(uuid, sizeof(uuid));
+
+ int mode = data.readInt32();
+
+ uint32_t result = prepareDrm(uuid, mode);
+ reply->writeInt32(result);
+ return OK;
+ }
+ case RELEASE_DRM: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+
+ uint32_t result = releaseDrm();
+ reply->writeInt32(result);
+ return OK;
+ }
+ case GET_KEY_REQUEST: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+
+ Vector<uint8_t> scope;
+ readVector(data, scope);
+ String8 mimeType = data.readString8();
+ DrmPlugin::KeyType keyType = (DrmPlugin::KeyType)data.readInt32();
+
+ KeyedVector<String8, String8> optionalParameters;
+ uint32_t count = data.readUint32();
+ for (size_t i = 0; i < count; ++i) {
+ String8 key, value;
+ key = data.readString8();
+ value = data.readString8();
+ optionalParameters.add(key, value);
+ }
+
+ Vector<uint8_t> request;
+ String8 defaultUrl;
+ DrmPlugin::KeyRequestType keyRequestType = DrmPlugin::kKeyRequestType_Unknown;
+
+ status_t result = getKeyRequest(scope, mimeType, keyType, optionalParameters,
+ request, defaultUrl, keyRequestType);
+
+ writeVector(*reply, request);
+ reply->writeString8(defaultUrl);
+ reply->writeInt32(keyRequestType);
+ reply->writeInt32(result);
+ return OK;
+ }
+ case PROVIDE_KEY_RESPONSE: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+ Vector<uint8_t> releaseKeySetId, response, keySetId;
+ readVector(data, releaseKeySetId);
+ readVector(data, response);
+ uint32_t result = provideKeyResponse(releaseKeySetId, response, keySetId);
+ writeVector(*reply, keySetId);
+ reply->writeInt32(result);
+ return OK;
+ }
+ case RESTORE_KEYS: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+
+ Vector<uint8_t> keySetId;
+ readVector(data, keySetId);
+ uint32_t result = restoreKeys(keySetId);
+ reply->writeInt32(result);
+ return OK;
+ }
+ case GET_DRM_PROPERTY_STRING: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+ String8 name, value;
+ name = data.readString8();
+ uint32_t result = getDrmPropertyString(name, value);
+ reply->writeString8(value);
+ reply->writeInt32(result);
+ return OK;
+ }
+ case SET_DRM_PROPERTY_STRING: {
+ CHECK_INTERFACE(IMediaPlayer, data, reply);
+ String8 name, value;
+ name = data.readString8();
+ value = data.readString8();
+ uint32_t result = setDrmPropertyString(name, value);
+ reply->writeInt32(result);
+ return OK;
+ }
default:
return BBinder::onTransact(code, data, reply, flags);
}
diff --git a/media/libmedia/mediaplayer.cpp b/media/libmedia/mediaplayer.cpp
index 40af8de..e7369fb 100644
--- a/media/libmedia/mediaplayer.cpp
+++ b/media/libmedia/mediaplayer.cpp
@@ -874,7 +874,7 @@
case MEDIA_NOP: // interface test message
break;
case MEDIA_PREPARED:
- ALOGV("prepared");
+ ALOGV("MediaPlayer::notify() prepared");
mCurrentState = MEDIA_PLAYER_PREPARED;
if (mPrepareSync) {
ALOGV("signal application thread");
@@ -883,6 +883,9 @@
mSignal.signal();
}
break;
+ case MEDIA_DRM_INFO:
+ ALOGV("MediaPlayer::notify() MEDIA_DRM_INFO(%d, %d, %d, %p)", msg, ext1, ext2, obj);
+ break;
case MEDIA_PLAYBACK_COMPLETE:
ALOGV("playback complete");
if (mCurrentState == MEDIA_PLAYER_IDLE) {
@@ -983,4 +986,123 @@
return mPlayer->setNextPlayer(next == NULL ? NULL : next->mPlayer);
}
+// ModDrm
+status_t MediaPlayer::prepareDrm(const uint8_t uuid[16], const int mode)
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Only allowing it in player's prepared state
+ if (!(mCurrentState & MEDIA_PLAYER_PREPARED)) {
+ ALOGE("prepareDrm must only be called in the prepared state.");
+ return INVALID_OPERATION;
+ }
+
+ status_t ret = mPlayer->prepareDrm(uuid, mode);
+ ALOGV("prepareDrm: ret=%d", ret);
+
+ return ret;
+}
+
+status_t MediaPlayer::releaseDrm()
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Not allowing releaseDrm in an active state
+ if (mCurrentState & (MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PAUSED)) {
+ ALOGE("releaseDrm can not be called in the started/paused state.");
+ return INVALID_OPERATION;
+ }
+
+ status_t ret = mPlayer->releaseDrm();
+ ALOGV("releaseDrm: ret=%d", ret);
+
+ return ret;
+}
+
+status_t MediaPlayer::getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,
+ DrmPlugin::KeyType keyType,
+ KeyedVector<String8, String8>& optionalParameters,
+ Vector<uint8_t>& request, String8& defaultUrl,
+ DrmPlugin::KeyRequestType& keyRequestType)
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Not enforcing a particular state beyond the checks enforced by the Java layer
+ // Key exchange can happen after the start.
+ status_t ret = mPlayer->getKeyRequest(scope, mimeType, keyType, optionalParameters,
+ request, defaultUrl, keyRequestType);
+ ALOGV("getKeyRequest ret=%d %d %s %d ", ret,
+ (int)request.size(), defaultUrl.string(), (int)keyRequestType);
+
+ return ret;
+}
+
+status_t MediaPlayer::provideKeyResponse(Vector<uint8_t>& releaseKeySetId,
+ Vector<uint8_t>& response, Vector<uint8_t>& keySetId)
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Not enforcing a particular state beyond the checks enforced by the Java layer
+ // Key exchange can happen after the start.
+ status_t ret = mPlayer->provideKeyResponse(releaseKeySetId, response, keySetId);
+ ALOGV("provideKeyResponse: ret=%d", ret);
+
+ return ret;
+}
+
+status_t MediaPlayer::restoreKeys(Vector<uint8_t> const& keySetId)
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Not enforcing a particular state beyond the checks enforced by the Java layer
+ // Key exchange can happen after the start.
+ status_t ret = mPlayer->restoreKeys(keySetId);
+ ALOGV("restoreKeys: ret=%d", ret);
+
+ return ret;
+}
+
+status_t MediaPlayer::getDrmPropertyString(String8 const& name, String8& value)
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Not enforcing a particular state beyond the checks enforced by the Java layer
+ status_t ret = mPlayer->getDrmPropertyString(name, value);
+ ALOGV("getDrmPropertyString: ret=%d", ret);
+
+ return ret;
+}
+
+status_t MediaPlayer::setDrmPropertyString(String8 const& name, String8 const& value)
+{
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ return NO_INIT;
+ }
+
+ // Not enforcing a particular state beyond the checks enforced by the Java layer
+ status_t ret = mPlayer->setDrmPropertyString(name, value);
+ ALOGV("setDrmPropertyString: ret=%d", ret);
+
+ return ret;
+}
+
} // namespace android
diff --git a/media/libmediaplayerservice/MediaPlayerService.h b/media/libmediaplayerservice/MediaPlayerService.h
index db182b2..819973e 100644
--- a/media/libmediaplayerservice/MediaPlayerService.h
+++ b/media/libmediaplayerservice/MediaPlayerService.h
@@ -347,6 +347,32 @@
virtual status_t dump(int fd, const Vector<String16>& args);
audio_session_t getAudioSessionId() { return mAudioSessionId; }
+ // ModDrm
+ virtual status_t prepareDrm(const uint8_t /*uuid*/[16], const int /*mode*/)
+ { return INVALID_OPERATION; }
+ virtual status_t releaseDrm()
+ { return INVALID_OPERATION; }
+ virtual status_t getKeyRequest(Vector<uint8_t> const& /*scope*/,
+ String8 const& /*mimeType*/,
+ DrmPlugin::KeyType /*keyType*/,
+ KeyedVector<String8, String8>& /*optionalParameters*/,
+ Vector<uint8_t>& /*request*/,
+ String8& /*defaultUrl*/,
+ DrmPlugin::KeyRequestType& /*keyRequestType*/)
+ { return INVALID_OPERATION; }
+ virtual status_t provideKeyResponse(Vector<uint8_t>& /*releaseKeySetId*/,
+ Vector<uint8_t>& /*response*/,
+ Vector<uint8_t>& /*keySetId*/)
+ { return INVALID_OPERATION; }
+ virtual status_t restoreKeys(Vector<uint8_t> const& /*keySetId*/)
+ { return INVALID_OPERATION; }
+ virtual status_t getDrmPropertyString(String8 const& /*name*/,
+ String8& /*value*/)
+ { return INVALID_OPERATION; }
+ virtual status_t setDrmPropertyString(String8 const& /*name*/,
+ String8 const& /*value*/)
+ { return INVALID_OPERATION; }
+
private:
class ServiceDeathNotifier: public IBinder::DeathRecipient