Merge "Implement new MediaDrm methods" (c42670b8) · Commits · e / os / android_frameworks_av

drm/libmediadrm/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -36,6 +36,7 @@ cc_library {
		"libstagefright_foundation",
		"libutils",
		"android.hardware.drm@1.0",
		"android.hardware.drm@1.1",
		"libhidlallocatorutils",
		"libhidlbase",
		"libhidltransport",

drm/libmediadrm/DrmHal.cpp

+196 −110

Original line number	Diff line number	Diff line
		@@ -37,17 +37,15 @@
		#include <media/stagefright/foundation/hexdump.h>
		#include <media/stagefright/MediaErrors.h>

		using ::android::hardware::drm::V1_0::EventType;
		using ::android::hardware::drm::V1_0::IDrmFactory;
		using ::android::hardware::drm::V1_0::IDrmPlugin;
		using ::android::hardware::drm::V1_0::KeyedVector;
		using ::android::hardware::drm::V1_0::KeyRequestType;
		using ::android::hardware::drm::V1_0::KeyStatus;
		using ::android::hardware::drm::V1_0::KeyStatusType;
		using ::android::hardware::drm::V1_0::KeyType;
		using ::android::hardware::drm::V1_0::KeyValue;
		using ::android::hardware::drm::V1_0::SecureStop;
		using ::android::hardware::drm::V1_0::Status;
		using drm::V1_0::KeyedVector;
		using drm::V1_0::KeyRequestType;
		using drm::V1_0::KeyStatusType;
		using drm::V1_0::KeyType;
		using drm::V1_0::KeyValue;
		using drm::V1_1::HdcpLevel;;
		using drm::V1_0::SecureStop;
		using drm::V1_1::SecurityLevel;
		using drm::V1_0::Status;
		using ::android::hardware::hidl_array;
		using ::android::hardware::hidl_string;
		using ::android::hardware::hidl_vec;
		@@ -58,6 +56,8 @@ using ::android::sp;

		namespace android {

		#define INIT_CHECK() {if (mInitCheck != OK) return mInitCheck;}

		static inline int getCallingPid() {
		return IPCThreadState::self()->getCallingPid();
		}
		@@ -89,6 +89,42 @@ static hidl_string toHidlString(const String8& string) {
		return hidl_string(string.string());
		}

		static DrmPlugin::SecurityLevel toSecurityLevel(SecurityLevel level) {
		switch(level) {
		case SecurityLevel::SW_SECURE_CRYPTO:
		return DrmPlugin::kSecurityLevelSwSecureCrypto;
		case SecurityLevel::SW_SECURE_DECODE:
		return DrmPlugin::kSecurityLevelSwSecureDecode;
		case SecurityLevel::HW_SECURE_CRYPTO:
		return DrmPlugin::kSecurityLevelHwSecureCrypto;
		case SecurityLevel::HW_SECURE_DECODE:
		return DrmPlugin::kSecurityLevelHwSecureDecode;
		case SecurityLevel::HW_SECURE_ALL:
		return DrmPlugin::kSecurityLevelHwSecureAll;
		default:
		return DrmPlugin::kSecurityLevelUnknown;
		}
		}

		static DrmPlugin::HdcpLevel toHdcpLevel(HdcpLevel level) {
		switch(level) {
		case HdcpLevel::HDCP_NONE:
		return DrmPlugin::kHdcpNone;
		case HdcpLevel::HDCP_V1:
		return DrmPlugin::kHdcpV1;
		case HdcpLevel::HDCP_V2:
		return DrmPlugin::kHdcpV2;
		case HdcpLevel::HDCP_V2_1:
		return DrmPlugin::kHdcpV2_1;
		case HdcpLevel::HDCP_V2_2:
		return DrmPlugin::kHdcpV2_2;
		case HdcpLevel::HDCP_NO_OUTPUT:
		return DrmPlugin::kHdcpNoOutput;
		default:
		return DrmPlugin::kHdcpLevelUnknown;
		}
		}


		static ::KeyedVector toHidlKeyedVector(const KeyedVector<String8, String8>&
		keyedVector) {
		@@ -407,6 +443,7 @@ status_t DrmHal::createPlugin(const uint8_t uuid[16],
		for (size_t i = 0; i < mFactories.size(); i++) {
		if (mFactories[i]->isCryptoSchemeSupported(uuid)) {
		mPlugin = makeDrmPlugin(mFactories[i], uuid, appPackageName);
		mPluginV1_1 = drm::V1_1::IDrmPlugin::castFrom(mPlugin);
		}
		}

		@@ -425,9 +462,7 @@ status_t DrmHal::createPlugin(const uint8_t uuid[16],

		status_t DrmHal::destroyPlugin() {
		Mutex::Autolock autoLock(mLock);
		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		closeOpenSessions();
		reportMetrics();
		@@ -445,10 +480,7 @@ status_t DrmHal::destroyPlugin() {

		status_t DrmHal::openSession(Vector<uint8_t> &sessionId) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -491,10 +523,7 @@ status_t DrmHal::openSession(Vector<uint8_t> &sessionId) {

		status_t DrmHal::closeSession(Vector<uint8_t> const &sessionId) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		Return<Status> status = mPlugin->closeSession(toHidlVec(sessionId));
		if (status.isOk()) {
		@@ -519,10 +548,7 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId,
		String8> const &optionalParameters, Vector<uint8_t> &request,
		String8 &defaultUrl, DrmPlugin::KeyRequestType *keyRequestType) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -574,10 +600,7 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const &sessionId,
		status_t DrmHal::provideKeyResponse(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &response, Vector<uint8_t> &keySetId) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -598,10 +621,7 @@ status_t DrmHal::provideKeyResponse(Vector<uint8_t> const &sessionId,

		status_t DrmHal::removeKeys(Vector<uint8_t> const &keySetId) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		return toStatusT(mPlugin->removeKeys(toHidlVec(keySetId)));
		}
		@@ -609,10 +629,7 @@ status_t DrmHal::removeKeys(Vector<uint8_t> const &keySetId) {
		status_t DrmHal::restoreKeys(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keySetId) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -623,10 +640,7 @@ status_t DrmHal::restoreKeys(Vector<uint8_t> const &sessionId,
		status_t DrmHal::queryKeyStatus(Vector<uint8_t> const &sessionId,
		KeyedVector<String8, String8> &infoMap) const {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -650,10 +664,7 @@ status_t DrmHal::getProvisionRequest(String8 const &certType,
		String8 const &certAuthority, Vector<uint8_t> &request,
		String8 &defaultUrl) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -675,10 +686,7 @@ status_t DrmHal::getProvisionRequest(String8 const &certType,
		status_t DrmHal::provideProvisionResponse(Vector<uint8_t> const &response,
		Vector<uint8_t> &certificate, Vector<uint8_t> &wrappedKey) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -698,10 +706,7 @@ status_t DrmHal::provideProvisionResponse(Vector<uint8_t> const &response,

		status_t DrmHal::getSecureStops(List<Vector<uint8_t>> &secureStops) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -720,10 +725,7 @@ status_t DrmHal::getSecureStops(List<Vector<uint8_t>> &secureStops) {

		status_t DrmHal::getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -741,22 +743,139 @@ status_t DrmHal::getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &sec

		status_t DrmHal::releaseSecureStops(Vector<uint8_t> const &ssRelease) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		return toStatusT(mPlugin->releaseSecureStop(toHidlVec(ssRelease)));
		}

		status_t DrmHal::releaseAllSecureStops() {
		Mutex::Autolock autoLock(mLock);
		INIT_CHECK();

		if (mInitCheck != OK) {
		return mInitCheck;
		return toStatusT(mPlugin->releaseAllSecureStops());
		}

		return toStatusT(mPlugin->releaseAllSecureStops());
		status_t DrmHal::getHdcpLevels(DrmPlugin::HdcpLevel *connected,
		DrmPlugin::HdcpLevel *max) const {
		Mutex::Autolock autoLock(mLock);
		INIT_CHECK();

		if (connected == NULL \|\| max == NULL) {
		return BAD_VALUE;
		}
		status_t err = UNKNOWN_ERROR;

		if (mPluginV1_1 == NULL) {
		return ERROR_DRM_CANNOT_HANDLE;
		}

		*connected = DrmPlugin::kHdcpLevelUnknown;
		*max = DrmPlugin::kHdcpLevelUnknown;

		Return<void> hResult = mPluginV1_1->getHdcpLevels(
		[&](Status status, const HdcpLevel& hConnected, const HdcpLevel& hMax) {
		if (status == Status::OK) {
		*connected = toHdcpLevel(hConnected);
		*max = toHdcpLevel(hMax);
		}
		err = toStatusT(status);
		}
		);

		return hResult.isOk() ? err : DEAD_OBJECT;
		}

		status_t DrmHal::getNumberOfSessions(uint32_t open, uint32_t max) const {
		Mutex::Autolock autoLock(mLock);
		INIT_CHECK();

		if (open == NULL \|\| max == NULL) {
		return BAD_VALUE;
		}
		status_t err = UNKNOWN_ERROR;

		*open = 0;
		*max = 0;

		if (mPluginV1_1 == NULL) {
		return ERROR_DRM_CANNOT_HANDLE;
		}

		Return<void> hResult = mPluginV1_1->getNumberOfSessions(
		[&](Status status, uint32_t hOpen, uint32_t hMax) {
		if (status == Status::OK) {
		*open = hOpen;
		*max = hMax;
		}
		err = toStatusT(status);
		}
		);

		return hResult.isOk() ? err : DEAD_OBJECT;
		}

		status_t DrmHal::getSecurityLevel(Vector<uint8_t> const &sessionId,
		DrmPlugin::SecurityLevel *level) const {
		Mutex::Autolock autoLock(mLock);
		INIT_CHECK();

		if (level == NULL) {
		return BAD_VALUE;
		}
		status_t err = UNKNOWN_ERROR;

		if (mPluginV1_1 == NULL) {
		return ERROR_DRM_CANNOT_HANDLE;
		}

		*level = DrmPlugin::kSecurityLevelUnknown;

		Return<void> hResult = mPluginV1_1->getSecurityLevel(toHidlVec(sessionId),
		[&](Status status, SecurityLevel hLevel) {
		if (status == Status::OK) {
		*level = toSecurityLevel(hLevel);
		}
		err = toStatusT(status);
		}
		);

		return hResult.isOk() ? err : DEAD_OBJECT;
		}

		status_t DrmHal::setSecurityLevel(Vector<uint8_t> const &sessionId,
		const DrmPlugin::SecurityLevel& level) {
		Mutex::Autolock autoLock(mLock);
		INIT_CHECK();

		if (mPluginV1_1 == NULL) {
		return ERROR_DRM_CANNOT_HANDLE;
		}

		SecurityLevel hSecurityLevel;

		switch(level) {
		case DrmPlugin::kSecurityLevelSwSecureCrypto:
		hSecurityLevel = SecurityLevel::SW_SECURE_CRYPTO;
		break;
		case DrmPlugin::kSecurityLevelSwSecureDecode:
		hSecurityLevel = SecurityLevel::SW_SECURE_DECODE;
		break;
		case DrmPlugin::kSecurityLevelHwSecureCrypto:
		hSecurityLevel = SecurityLevel::HW_SECURE_CRYPTO;
		break;
		case DrmPlugin::kSecurityLevelHwSecureDecode:
		hSecurityLevel = SecurityLevel::HW_SECURE_DECODE;
		break;
		case DrmPlugin::kSecurityLevelHwSecureAll:
		hSecurityLevel = SecurityLevel::HW_SECURE_ALL;
		break;
		default:
		return ERROR_DRM_CANNOT_HANDLE;
		}

		Status status = mPluginV1_1->setSecurityLevel(toHidlVec(sessionId),
		hSecurityLevel);
		return toStatusT(status);
		}

		status_t DrmHal::getPropertyString(String8 const &name, String8 &value ) const {
		@@ -767,10 +886,7 @@ status_t DrmHal::getPropertyString(String8 const &name, String8 &value ) const {
		status_t DrmHal::getPropertyStringInternal(String8 const &name, String8 &value) const {
		// This function is internal to the class and should only be called while
		// mLock is already held.

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -794,10 +910,7 @@ status_t DrmHal::getPropertyByteArray(String8 const &name, Vector<uint8_t> &valu
		status_t DrmHal::getPropertyByteArrayInternal(String8 const &name, Vector<uint8_t> &value ) const {
		// This function is internal to the class and should only be called while
		// mLock is already held.

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		status_t err = UNKNOWN_ERROR;

		@@ -815,10 +928,7 @@ status_t DrmHal::getPropertyByteArrayInternal(String8 const &name, Vector<uint8_

		status_t DrmHal::setPropertyString(String8 const &name, String8 const &value ) const {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		Status status = mPlugin->setPropertyString(toHidlString(name),
		toHidlString(value));
		@@ -828,10 +938,7 @@ status_t DrmHal::setPropertyString(String8 const &name, String8 const &value ) c
		status_t DrmHal::setPropertyByteArray(String8 const &name,
		Vector<uint8_t> const &value ) const {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		Status status = mPlugin->setPropertyByteArray(toHidlString(name),
		toHidlVec(value));
		@@ -847,10 +954,7 @@ status_t DrmHal::getMetrics(MediaAnalyticsItem* metrics) {
		status_t DrmHal::setCipherAlgorithm(Vector<uint8_t> const &sessionId,
		String8 const &algorithm) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -862,10 +966,7 @@ status_t DrmHal::setCipherAlgorithm(Vector<uint8_t> const &sessionId,
		status_t DrmHal::setMacAlgorithm(Vector<uint8_t> const &sessionId,
		String8 const &algorithm) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -878,10 +979,7 @@ status_t DrmHal::encrypt(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keyId, Vector<uint8_t> const &input,
		Vector<uint8_t> const &iv, Vector<uint8_t> &output) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -904,10 +1002,7 @@ status_t DrmHal::decrypt(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keyId, Vector<uint8_t> const &input,
		Vector<uint8_t> const &iv, Vector<uint8_t> &output) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -930,10 +1025,7 @@ status_t DrmHal::sign(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keyId, Vector<uint8_t> const &message,
		Vector<uint8_t> &signature) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -956,10 +1048,7 @@ status_t DrmHal::verify(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keyId, Vector<uint8_t> const &message,
		Vector<uint8_t> const &signature, bool &match) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		DrmSessionManager::Instance()->useSession(sessionId);

		@@ -984,10 +1073,7 @@ status_t DrmHal::signRSA(Vector<uint8_t> const &sessionId,
		String8 const &algorithm, Vector<uint8_t> const &message,
		Vector<uint8_t> const &wrappedKey, Vector<uint8_t> &signature) {
		Mutex::Autolock autoLock(mLock);

		if (mInitCheck != OK) {
		return mInitCheck;
		}
		INIT_CHECK();

		if (!checkPermission("android.permission.ACCESS_DRM_CERTIFICATES")) {
		return -EPERM;

drm/libmediadrm/IDrm.cpp

+128 −1

Original line number	Diff line number	Diff line
		@@ -56,7 +56,11 @@ enum {
		VERIFY,
		SET_LISTENER,
		GET_SECURE_STOP,
		RELEASE_ALL_SECURE_STOPS
		RELEASE_ALL_SECURE_STOPS,
		GET_HDCP_LEVELS,
		GET_NUMBER_OF_SESSIONS,
		GET_SECURITY_LEVEL,
		SET_SECURITY_LEVEL,
		};

		struct BpDrm : public BpInterface<IDrm> {
		@@ -351,6 +355,82 @@ struct BpDrm : public BpInterface<IDrm> {
		return reply.readInt32();
		}

		virtual status_t getHdcpLevels(DrmPlugin::HdcpLevel *connected,
		DrmPlugin::HdcpLevel *max) const {
		Parcel data, reply;

		if (connected == NULL \|\| max == NULL) {
		return BAD_VALUE;
		}

		data.writeInterfaceToken(IDrm::getInterfaceDescriptor());

		status_t status = remote()->transact(GET_HDCP_LEVELS, data, &reply);
		if (status != OK) {
		return status;
		}

		*connected = static_cast<DrmPlugin::HdcpLevel>(reply.readInt32());
		*max = static_cast<DrmPlugin::HdcpLevel>(reply.readInt32());
		return reply.readInt32();
		}

		virtual status_t getNumberOfSessions(uint32_t open, uint32_t max) const {
		Parcel data, reply;

		if (open == NULL \|\| max == NULL) {
		return BAD_VALUE;
		}

		data.writeInterfaceToken(IDrm::getInterfaceDescriptor());

		status_t status = remote()->transact(GET_NUMBER_OF_SESSIONS, data, &reply);
		if (status != OK) {
		return status;
		}

		*open = reply.readInt32();
		*max = reply.readInt32();
		return reply.readInt32();
		}

		virtual status_t getSecurityLevel(Vector<uint8_t> const &sessionId,
		DrmPlugin::SecurityLevel *level) const {
		Parcel data, reply;

		if (level == NULL) {
		return BAD_VALUE;
		}

		data.writeInterfaceToken(IDrm::getInterfaceDescriptor());

		writeVector(data, sessionId);
		status_t status = remote()->transact(GET_SECURITY_LEVEL, data, &reply);
		if (status != OK) {
		return status;
		}

		*level = static_cast<DrmPlugin::SecurityLevel>(reply.readInt32());
		return reply.readInt32();
		}

		virtual status_t setSecurityLevel(Vector<uint8_t> const &sessionId,
		const DrmPlugin::SecurityLevel& level) {
		Parcel data, reply;

		data.writeInterfaceToken(IDrm::getInterfaceDescriptor());

		writeVector(data, sessionId);
		data.writeInt32(static_cast<uint32_t>(level));

		status_t status = remote()->transact(SET_SECURITY_LEVEL, data, &reply);
		if (status != OK) {
		return status;
		}

		return reply.readInt32();
		}

		virtual status_t getPropertyByteArray(String8 const &name, Vector<uint8_t> &value) const {
		Parcel data, reply;
		data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
		@@ -801,6 +881,53 @@ status_t BnDrm::onTransact(
		return OK;
		}

		case GET_HDCP_LEVELS:
		{
		CHECK_INTERFACE(IDrm, data, reply);
		DrmPlugin::HdcpLevel connected = DrmPlugin::kHdcpLevelUnknown;
		DrmPlugin::HdcpLevel max = DrmPlugin::kHdcpLevelUnknown;
		status_t result = getHdcpLevels(&connected, &max);
		reply->writeInt32(connected);
		reply->writeInt32(max);
		reply->writeInt32(result);
		return OK;
		}

		case GET_NUMBER_OF_SESSIONS:
		{
		CHECK_INTERFACE(IDrm, data, reply);
		uint32_t open = 0, max = 0;
		status_t result = getNumberOfSessions(&open, &max);
		reply->writeInt32(open);
		reply->writeInt32(max);
		reply->writeInt32(result);
		return OK;
		}

		case GET_SECURITY_LEVEL:
		{
		CHECK_INTERFACE(IDrm, data, reply);
		Vector<uint8_t> sessionId;
		readVector(data, sessionId);
		DrmPlugin::SecurityLevel level = DrmPlugin::kSecurityLevelUnknown;
		status_t result = getSecurityLevel(sessionId, &level);
		reply->writeInt32(level);
		reply->writeInt32(result);
		return OK;
		}

		case SET_SECURITY_LEVEL:
		{
		CHECK_INTERFACE(IDrm, data, reply);
		Vector<uint8_t> sessionId;
		readVector(data, sessionId);
		DrmPlugin::SecurityLevel level =
		static_cast<DrmPlugin::SecurityLevel>(data.readInt32());
		status_t result = setSecurityLevel(sessionId, level);
		reply->writeInt32(result);
		return OK;
		}

		case GET_PROPERTY_STRING:
		{
		CHECK_INTERFACE(IDrm, data, reply);

drm/mediadrm/plugins/clearkey/DrmPlugin.h

+29 −0

Original line number	Diff line number	Diff line
		@@ -133,6 +133,35 @@ public:
		return android::ERROR_DRM_CANNOT_HANDLE;
		}

		virtual status_t getHdcpLevels(HdcpLevel *connectedLevel,
		HdcpLevel *maxLevel) const {
		UNUSED(connectedLevel);
		UNUSED(maxLevel);
		return android::ERROR_DRM_CANNOT_HANDLE;
		}


		virtual status_t getNumberOfSessions(uint32_t *currentSessions,
		uint32_t *maxSessions) const {
		UNUSED(currentSessions);
		UNUSED(maxSessions);
		return android::ERROR_DRM_CANNOT_HANDLE;
		}

		virtual status_t getSecurityLevel(Vector<uint8_t> const &sessionId,
		SecurityLevel *level) const {
		UNUSED(sessionId);
		UNUSED(level);
		return android::ERROR_DRM_CANNOT_HANDLE;
		}

		virtual status_t setSecurityLevel(Vector<uint8_t> const &sessionId,
		const SecurityLevel& level) {
		UNUSED(sessionId);
		UNUSED(level);
		return android::ERROR_DRM_CANNOT_HANDLE;
		}

		virtual status_t getPropertyString(
		const String8& name, String8& value) const;

media/libmedia/include/media/DrmHal.h

+17 −5

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@
		#define DRM_HAL_H_

		#include <android/hardware/drm/1.0/IDrmPlugin.h>
		#include <android/hardware/drm/1.1/IDrmPlugin.h>
		#include <android/hardware/drm/1.0/IDrmPluginListener.h>
		#include <android/hardware/drm/1.0/IDrmFactory.h>

		@@ -27,11 +28,12 @@
		#include <media/MediaAnalyticsItem.h>
		#include <utils/threads.h>

		using ::android::hardware::drm::V1_0::EventType;
		using ::android::hardware::drm::V1_0::IDrmFactory;
		using ::android::hardware::drm::V1_0::IDrmPlugin;
		using ::android::hardware::drm::V1_0::IDrmPluginListener;
		using ::android::hardware::drm::V1_0::KeyStatus;
		namespace drm = ::android::hardware::drm;
		using drm::V1_0::EventType;
		using drm::V1_0::IDrmFactory;
		using drm::V1_0::IDrmPlugin;
		using drm::V1_0::IDrmPluginListener;
		using drm::V1_0::KeyStatus;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		@@ -99,6 +101,15 @@ struct DrmHal : public BnDrm,
		virtual status_t releaseSecureStops(Vector<uint8_t> const &ssRelease);
		virtual status_t releaseAllSecureStops();

		virtual status_t getHdcpLevels(DrmPlugin::HdcpLevel *connectedLevel,
		DrmPlugin::HdcpLevel *maxLevel) const;
		virtual status_t getNumberOfSessions(uint32_t *currentSessions,
		uint32_t *maxSessions) const;
		virtual status_t getSecurityLevel(Vector<uint8_t> const &sessionId,
		DrmPlugin::SecurityLevel *level) const;
		virtual status_t setSecurityLevel(Vector<uint8_t> const &sessionId,
		const DrmPlugin::SecurityLevel& level);

		virtual status_t getPropertyString(String8 const &name, String8 &value ) const;
		virtual status_t getPropertyByteArray(String8 const &name,
		Vector<uint8_t> &value ) const;
		@@ -167,6 +178,7 @@ private:

		const Vector<sp<IDrmFactory>> mFactories;
		sp<IDrmPlugin> mPlugin;
		sp<drm::V1_1::IDrmPlugin> mPluginV1_1;

		Vector<Vector<uint8_t>> mOpenSessions;
		void closeOpenSessions();