Merge "New IDrm API return type" (dab574b8) · Commits · e / os / android_frameworks_av

drm/libmediadrm/CryptoHalAidl.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -41,7 +41,7 @@ using NativeHandleAidlCommon = ::aidl::android::hardware::common::NativeHandle;
		using ::aidl::android::hardware::drm::DecryptArgs;

		using ::android::sp;
		using ::android::DrmUtils::statusAidlToStatusT;
		using ::android::DrmUtils::statusAidlToDrmStatus;
		using ::android::hardware::hidl_array;
		using ::android::hardware::hidl_handle;
		using ::android::hardware::hidl_memory;
		@@ -268,7 +268,7 @@ status_t CryptoHalAidl::setMediaDrmSession(const Vector<uint8_t>& sessionId) {
		}

		auto err = mPlugin->setMediaDrmSession(toStdVec(sessionId));
		return statusAidlToStatusT(err);
		return statusAidlToDrmStatus(err);
		}

		ssize_t CryptoHalAidl::decrypt(const uint8_t keyId[16], const uint8_t iv[16],
		@@ -352,7 +352,7 @@ ssize_t CryptoHalAidl::decrypt(const uint8_t keyId[16], const uint8_t iv[16],
		int32_t result = 0;
		::ndk::ScopedAStatus statusAidl = mPlugin->decrypt(args, &result);

		err = statusAidlToStatusT(statusAidl);
		err = statusAidlToDrmStatus(statusAidl);
		std::string msgStr(statusAidl.getMessage());
		if (errorDetailMsg != nullptr) {
		*errorDetailMsg = toString8(msgStr);

drm/libmediadrm/DrmHal.cpp

+77 −76

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		#include <mediadrm/DrmHal.h>
		#include <mediadrm/DrmHalAidl.h>
		#include <mediadrm/DrmHalHidl.h>
		#include <mediadrm/DrmStatus.h>
		#include <mediadrm/DrmUtils.h>

		namespace android {
		@@ -31,45 +32,45 @@ DrmHal::DrmHal() {

		DrmHal::~DrmHal() {}

		status_t DrmHal::initCheck() const {
		if (mDrmHalAidl->initCheck() == OK \|\| mDrmHalHidl->initCheck() == OK) return OK;
		if (mDrmHalAidl->initCheck() == NO_INIT \|\| mDrmHalHidl->initCheck() == NO_INIT) return NO_INIT;
		DrmStatus DrmHal::initCheck() const {
		if (mDrmHalAidl->initCheck() == OK \|\| mDrmHalHidl->initCheck() == OK) return DrmStatus(OK);
		if (mDrmHalAidl->initCheck() == NO_INIT \|\| mDrmHalHidl->initCheck() == NO_INIT)
		return DrmStatus(NO_INIT);
		return mDrmHalHidl->initCheck();
		}

		status_t DrmHal::isCryptoSchemeSupported(const uint8_t uuid[16], const String8& mimeType,
		DrmStatus DrmHal::isCryptoSchemeSupported(const uint8_t uuid[16], const String8& mimeType,
		DrmPlugin::SecurityLevel securityLevel, bool* result) {
		status_t statusResult;
		statusResult = mDrmHalAidl->isCryptoSchemeSupported(uuid, mimeType, securityLevel, result);
		DrmStatus statusResult =
		mDrmHalAidl->isCryptoSchemeSupported(uuid, mimeType, securityLevel, result);
		if (*result) return statusResult;
		return mDrmHalHidl->isCryptoSchemeSupported(uuid, mimeType, securityLevel, result);
		}

		status_t DrmHal::createPlugin(const uint8_t uuid[16], const String8& appPackageName) {
		status_t statusResult;
		statusResult = mDrmHalAidl->createPlugin(uuid, appPackageName);
		if (statusResult != OK) return mDrmHalHidl->createPlugin(uuid, appPackageName);
		return statusResult;
		DrmStatus DrmHal::createPlugin(const uint8_t uuid[16], const String8& appPackageName) {
		return mDrmHalAidl->createPlugin(uuid, appPackageName) == OK
		? DrmStatus(OK)
		: mDrmHalHidl->createPlugin(uuid, appPackageName);
		}

		status_t DrmHal::destroyPlugin() {
		status_t statusResult = mDrmHalAidl->destroyPlugin();
		status_t statusResultHidl = mDrmHalHidl->destroyPlugin();
		DrmStatus DrmHal::destroyPlugin() {
		DrmStatus statusResult = mDrmHalAidl->destroyPlugin();
		DrmStatus statusResultHidl = mDrmHalHidl->destroyPlugin();
		if (statusResult != OK) return statusResult;
		return statusResultHidl;
		}

		status_t DrmHal::openSession(DrmPlugin::SecurityLevel securityLevel, Vector<uint8_t>& sessionId) {
		DrmStatus DrmHal::openSession(DrmPlugin::SecurityLevel securityLevel, Vector<uint8_t>& sessionId) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->openSession(securityLevel, sessionId);
		return mDrmHalHidl->openSession(securityLevel, sessionId);
		}

		status_t DrmHal::closeSession(Vector<uint8_t> const& sessionId) {
		DrmStatus DrmHal::closeSession(Vector<uint8_t> const& sessionId) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->closeSession(sessionId);
		return mDrmHalHidl->closeSession(sessionId);
		}

		status_t DrmHal::getKeyRequest(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& initData,
		DrmStatus DrmHal::getKeyRequest(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& initData,
		String8 const& mimeType, DrmPlugin::KeyType keyType,
		KeyedVector<String8, String8> const& optionalParameters,
		Vector<uint8_t>& request, String8& defaultUrl,
		@@ -81,37 +82,37 @@ status_t DrmHal::getKeyRequest(Vector<uint8_t> const& sessionId, Vector<uint8_t>
		request, defaultUrl, keyRequestType);
		}

		status_t DrmHal::provideKeyResponse(Vector<uint8_t> const& sessionId,
		DrmStatus DrmHal::provideKeyResponse(Vector<uint8_t> const& sessionId,
		Vector<uint8_t> const& response, Vector<uint8_t>& keySetId) {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->provideKeyResponse(sessionId, response, keySetId);
		return mDrmHalHidl->provideKeyResponse(sessionId, response, keySetId);
		}

		status_t DrmHal::removeKeys(Vector<uint8_t> const& keySetId) {
		DrmStatus DrmHal::removeKeys(Vector<uint8_t> const& keySetId) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->removeKeys(keySetId);
		return mDrmHalHidl->removeKeys(keySetId);
		}

		status_t DrmHal::restoreKeys(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keySetId) {
		DrmStatus DrmHal::restoreKeys(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keySetId) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->restoreKeys(sessionId, keySetId);
		return mDrmHalHidl->restoreKeys(sessionId, keySetId);
		}

		status_t DrmHal::queryKeyStatus(Vector<uint8_t> const& sessionId,
		DrmStatus DrmHal::queryKeyStatus(Vector<uint8_t> const& sessionId,
		KeyedVector<String8, String8>& infoMap) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->queryKeyStatus(sessionId, infoMap);
		return mDrmHalHidl->queryKeyStatus(sessionId, infoMap);
		}

		status_t DrmHal::getProvisionRequest(String8 const& certType, String8 const& certAuthority,
		DrmStatus DrmHal::getProvisionRequest(String8 const& certType, String8 const& certAuthority,
		Vector<uint8_t>& request, String8& defaultUrl) {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->getProvisionRequest(certType, certAuthority, request, defaultUrl);
		return mDrmHalHidl->getProvisionRequest(certType, certAuthority, request, defaultUrl);
		}

		status_t DrmHal::provideProvisionResponse(Vector<uint8_t> const& response,
		DrmStatus DrmHal::provideProvisionResponse(Vector<uint8_t> const& response,
		Vector<uint8_t>& certificate,
		Vector<uint8_t>& wrappedKey) {
		if (mDrmHalAidl->initCheck() == OK)
		@@ -119,108 +120,108 @@ status_t DrmHal::provideProvisionResponse(Vector<uint8_t> const& response,
		return mDrmHalHidl->provideProvisionResponse(response, certificate, wrappedKey);
		}

		status_t DrmHal::getSecureStops(List<Vector<uint8_t>>& secureStops) {
		DrmStatus DrmHal::getSecureStops(List<Vector<uint8_t>>& secureStops) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getSecureStops(secureStops);
		return mDrmHalHidl->getSecureStops(secureStops);
		}

		status_t DrmHal::getSecureStopIds(List<Vector<uint8_t>>& secureStopIds) {
		DrmStatus DrmHal::getSecureStopIds(List<Vector<uint8_t>>& secureStopIds) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getSecureStopIds(secureStopIds);
		return mDrmHalHidl->getSecureStopIds(secureStopIds);
		}

		status_t DrmHal::getSecureStop(Vector<uint8_t> const& ssid, Vector<uint8_t>& secureStop) {
		DrmStatus DrmHal::getSecureStop(Vector<uint8_t> const& ssid, Vector<uint8_t>& secureStop) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getSecureStop(ssid, secureStop);
		return mDrmHalHidl->getSecureStop(ssid, secureStop);
		}

		status_t DrmHal::releaseSecureStops(Vector<uint8_t> const& ssRelease) {
		DrmStatus DrmHal::releaseSecureStops(Vector<uint8_t> const& ssRelease) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->releaseSecureStops(ssRelease);
		return mDrmHalHidl->releaseSecureStops(ssRelease);
		}

		status_t DrmHal::removeSecureStop(Vector<uint8_t> const& ssid) {
		DrmStatus DrmHal::removeSecureStop(Vector<uint8_t> const& ssid) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->removeSecureStop(ssid);
		return mDrmHalHidl->removeSecureStop(ssid);
		}

		status_t DrmHal::removeAllSecureStops() {
		DrmStatus DrmHal::removeAllSecureStops() {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->removeAllSecureStops();
		return mDrmHalHidl->removeAllSecureStops();
		}

		status_t DrmHal::getHdcpLevels(DrmPlugin::HdcpLevel* connectedLevel,
		DrmStatus DrmHal::getHdcpLevels(DrmPlugin::HdcpLevel* connectedLevel,
		DrmPlugin::HdcpLevel* maxLevel) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getHdcpLevels(connectedLevel, maxLevel);
		return mDrmHalHidl->getHdcpLevels(connectedLevel, maxLevel);
		}

		status_t DrmHal::getNumberOfSessions(uint32_t* currentSessions, uint32_t* maxSessions) const {
		DrmStatus DrmHal::getNumberOfSessions(uint32_t* currentSessions, uint32_t* maxSessions) const {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->getNumberOfSessions(currentSessions, maxSessions);
		return mDrmHalHidl->getNumberOfSessions(currentSessions, maxSessions);
		}

		status_t DrmHal::getSecurityLevel(Vector<uint8_t> const& sessionId,
		DrmStatus DrmHal::getSecurityLevel(Vector<uint8_t> const& sessionId,
		DrmPlugin::SecurityLevel* level) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getSecurityLevel(sessionId, level);
		return mDrmHalHidl->getSecurityLevel(sessionId, level);
		}

		status_t DrmHal::getOfflineLicenseKeySetIds(List<Vector<uint8_t>>& keySetIds) const {
		DrmStatus DrmHal::getOfflineLicenseKeySetIds(List<Vector<uint8_t>>& keySetIds) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getOfflineLicenseKeySetIds(keySetIds);
		return mDrmHalHidl->getOfflineLicenseKeySetIds(keySetIds);
		}

		status_t DrmHal::removeOfflineLicense(Vector<uint8_t> const& keySetId) {
		DrmStatus DrmHal::removeOfflineLicense(Vector<uint8_t> const& keySetId) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->removeOfflineLicense(keySetId);
		return mDrmHalHidl->removeOfflineLicense(keySetId);
		}

		status_t DrmHal::getOfflineLicenseState(Vector<uint8_t> const& keySetId,
		DrmStatus DrmHal::getOfflineLicenseState(Vector<uint8_t> const& keySetId,
		DrmPlugin::OfflineLicenseState* licenseState) const {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->getOfflineLicenseState(keySetId, licenseState);
		return mDrmHalHidl->getOfflineLicenseState(keySetId, licenseState);
		}

		status_t DrmHal::getPropertyString(String8 const& name, String8& value) const {
		DrmStatus DrmHal::getPropertyString(String8 const& name, String8& value) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getPropertyString(name, value);
		return mDrmHalHidl->getPropertyString(name, value);
		}

		status_t DrmHal::getPropertyByteArray(String8 const& name, Vector<uint8_t>& value) const {
		DrmStatus DrmHal::getPropertyByteArray(String8 const& name, Vector<uint8_t>& value) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getPropertyByteArray(name, value);
		return mDrmHalHidl->getPropertyByteArray(name, value);
		}

		status_t DrmHal::setPropertyString(String8 const& name, String8 const& value) const {
		DrmStatus DrmHal::setPropertyString(String8 const& name, String8 const& value) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->setPropertyString(name, value);
		return mDrmHalHidl->setPropertyString(name, value);
		}

		status_t DrmHal::setPropertyByteArray(String8 const& name, Vector<uint8_t> const& value) const {
		DrmStatus DrmHal::setPropertyByteArray(String8 const& name, Vector<uint8_t> const& value) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->setPropertyByteArray(name, value);
		return mDrmHalHidl->setPropertyByteArray(name, value);
		}

		status_t DrmHal::getMetrics(const sp<IDrmMetricsConsumer>& consumer) {
		DrmStatus DrmHal::getMetrics(const sp<IDrmMetricsConsumer>& consumer) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getMetrics(consumer);
		return mDrmHalHidl->getMetrics(consumer);
		}

		status_t DrmHal::setCipherAlgorithm(Vector<uint8_t> const& sessionId, String8 const& algorithm) {
		DrmStatus DrmHal::setCipherAlgorithm(Vector<uint8_t> const& sessionId, String8 const& algorithm) {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->setCipherAlgorithm(sessionId, algorithm);
		return mDrmHalHidl->setCipherAlgorithm(sessionId, algorithm);
		}

		status_t DrmHal::setMacAlgorithm(Vector<uint8_t> const& sessionId, String8 const& algorithm) {
		DrmStatus DrmHal::setMacAlgorithm(Vector<uint8_t> const& sessionId, String8 const& algorithm) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->setMacAlgorithm(sessionId, algorithm);
		return mDrmHalHidl->setMacAlgorithm(sessionId, algorithm);
		}

		status_t DrmHal::encrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
		DrmStatus 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) {
		if (mDrmHalAidl->initCheck() == OK)
		@@ -228,7 +229,7 @@ status_t DrmHal::encrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const
		return mDrmHalHidl->encrypt(sessionId, keyId, input, iv, output);
		}

		status_t DrmHal::decrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
		DrmStatus 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) {
		if (mDrmHalAidl->initCheck() == OK)
		@@ -236,14 +237,14 @@ status_t DrmHal::decrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const
		return mDrmHalHidl->decrypt(sessionId, keyId, input, iv, output);
		}

		status_t DrmHal::sign(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
		DrmStatus DrmHal::sign(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
		Vector<uint8_t> const& message, Vector<uint8_t>& signature) {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->sign(sessionId, keyId, message, signature);
		return mDrmHalHidl->sign(sessionId, keyId, message, signature);
		}

		status_t DrmHal::verify(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
		DrmStatus DrmHal::verify(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
		Vector<uint8_t> const& message, Vector<uint8_t> const& signature,
		bool& match) {
		if (mDrmHalAidl->initCheck() == OK)
		@@ -251,7 +252,7 @@ status_t DrmHal::verify(Vector<uint8_t> const& sessionId, Vector<uint8_t> const&
		return mDrmHalHidl->verify(sessionId, keyId, message, signature, match);
		}

		status_t DrmHal::signRSA(Vector<uint8_t> const& sessionId, String8 const& algorithm,
		DrmStatus DrmHal::signRSA(Vector<uint8_t> const& sessionId, String8 const& algorithm,
		Vector<uint8_t> const& message, Vector<uint8_t> const& wrappedKey,
		Vector<uint8_t>& signature) {
		if (mDrmHalAidl->initCheck() == OK)
		@@ -259,34 +260,34 @@ status_t DrmHal::signRSA(Vector<uint8_t> const& sessionId, String8 const& algori
		return mDrmHalHidl->signRSA(sessionId, algorithm, message, wrappedKey, signature);
		}

		status_t DrmHal::setListener(const sp<IDrmClient>& listener) {
		DrmStatus DrmHal::setListener(const sp<IDrmClient>& listener) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->setListener(listener);
		return mDrmHalHidl->setListener(listener);
		}

		status_t DrmHal::requiresSecureDecoder(const char* mime, bool* required) const {
		DrmStatus DrmHal::requiresSecureDecoder(const char* mime, bool* required) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->requiresSecureDecoder(mime, required);
		return mDrmHalHidl->requiresSecureDecoder(mime, required);
		}

		status_t DrmHal::requiresSecureDecoder(const char* mime, DrmPlugin::SecurityLevel securityLevel,
		DrmStatus DrmHal::requiresSecureDecoder(const char* mime, DrmPlugin::SecurityLevel securityLevel,
		bool* required) const {
		if (mDrmHalAidl->initCheck() == OK)
		return mDrmHalAidl->requiresSecureDecoder(mime, securityLevel, required);
		return mDrmHalHidl->requiresSecureDecoder(mime, securityLevel, required);
		}

		status_t DrmHal::setPlaybackId(Vector<uint8_t> const& sessionId, const char* playbackId) {
		DrmStatus DrmHal::setPlaybackId(Vector<uint8_t> const& sessionId, const char* playbackId) {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->setPlaybackId(sessionId, playbackId);
		return mDrmHalHidl->setPlaybackId(sessionId, playbackId);
		}

		status_t DrmHal::getLogMessages(Vector<drm::V1_4::LogMessage>& logs) const {
		DrmStatus DrmHal::getLogMessages(Vector<drm::V1_4::LogMessage>& logs) const {
		if (mDrmHalAidl->initCheck() == OK) return mDrmHalAidl->getLogMessages(logs);
		return mDrmHalHidl->getLogMessages(logs);
		}

		status_t DrmHal::getSupportedSchemes(std::vector<uint8_t> &schemes) const {
		DrmStatus DrmHal::getSupportedSchemes(std::vector<uint8_t>& schemes) const {
		status_t statusResult;
		statusResult = mDrmHalAidl->getSupportedSchemes(schemes);
		if (statusResult == OK) return statusResult;

drm/libmediadrm/DrmHalAidl.cpp

+133 −130

File changed.

Preview size limit exceeded, changes collapsed.

drm/libmediadrm/DrmHalHidl.cpp

+161 −158

File changed.

Preview size limit exceeded, changes collapsed.

drm/libmediadrm/include/mediadrm/DrmHal.h

+79 −79

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@
		*/

		#include <mediadrm/IDrm.h>
		#include <mediadrm/DrmStatus.h>

		#ifndef DRM_HAL_H_
		#define DRM_HAL_H_
		@@ -24,100 +25,99 @@ namespace android {
		struct DrmHal : public IDrm {
		DrmHal();
		virtual ~DrmHal();
		virtual status_t initCheck() const;
		virtual status_t isCryptoSchemeSupported(const uint8_t uuid[16],
		const String8 &mimeType,
		DrmPlugin::SecurityLevel securityLevel,
		bool *result);
		virtual status_t createPlugin(const uint8_t uuid[16],
		virtual DrmStatus initCheck() const;
		virtual DrmStatus isCryptoSchemeSupported(const uint8_t uuid[16], const String8& mimeType,
		DrmPlugin::SecurityLevel securityLevel, bool* result);
		virtual DrmStatus createPlugin(const uint8_t uuid[16],
		const String8 &appPackageName);
		virtual status_t destroyPlugin();
		virtual status_t openSession(DrmPlugin::SecurityLevel securityLevel,
		virtual DrmStatus destroyPlugin();
		virtual DrmStatus openSession(DrmPlugin::SecurityLevel securityLevel,
		Vector<uint8_t> &sessionId);
		virtual status_t closeSession(Vector<uint8_t> const &sessionId);
		virtual status_t
		virtual DrmStatus closeSession(Vector<uint8_t> const &sessionId);
		virtual DrmStatus
		getKeyRequest(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &initData,
		String8 const &mimeType, DrmPlugin::KeyType keyType,
		KeyedVector<String8, String8> const &optionalParameters,
		Vector<uint8_t> &request, String8 &defaultUrl,
		DrmPlugin::KeyRequestType *keyRequestType);
		virtual status_t provideKeyResponse(Vector<uint8_t> const &sessionId,
		virtual DrmStatus provideKeyResponse(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &response,
		Vector<uint8_t> &keySetId);
		virtual status_t removeKeys(Vector<uint8_t> const &keySetId);
		virtual status_t restoreKeys(Vector<uint8_t> const &sessionId,
		virtual DrmStatus removeKeys(Vector<uint8_t> const &keySetId);
		virtual DrmStatus restoreKeys(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keySetId);
		virtual status_t queryKeyStatus(Vector<uint8_t> const &sessionId,
		virtual DrmStatus queryKeyStatus(Vector<uint8_t> const &sessionId,
		KeyedVector<String8, String8> &infoMap) const;
		virtual status_t getProvisionRequest(String8 const &certType,
		virtual DrmStatus getProvisionRequest(String8 const &certType,
		String8 const &certAuthority,
		Vector<uint8_t> &request,
		String8 &defaultUrl);
		virtual status_t provideProvisionResponse(Vector<uint8_t> const &response,
		virtual DrmStatus provideProvisionResponse(Vector<uint8_t> const &response,
		Vector<uint8_t> &certificate,
		Vector<uint8_t> &wrappedKey);
		virtual status_t getSecureStops(List<Vector<uint8_t>> &secureStops);
		virtual status_t getSecureStopIds(List<Vector<uint8_t>> &secureStopIds);
		virtual status_t getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop);
		virtual status_t releaseSecureStops(Vector<uint8_t> const &ssRelease);
		virtual status_t removeSecureStop(Vector<uint8_t> const &ssid);
		virtual status_t removeAllSecureStops();
		virtual status_t getHdcpLevels(DrmPlugin::HdcpLevel *connectedLevel,
		virtual DrmStatus getSecureStops(List<Vector<uint8_t>> &secureStops);
		virtual DrmStatus getSecureStopIds(List<Vector<uint8_t>> &secureStopIds);
		virtual DrmStatus getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop);
		virtual DrmStatus releaseSecureStops(Vector<uint8_t> const &ssRelease);
		virtual DrmStatus removeSecureStop(Vector<uint8_t> const &ssid);
		virtual DrmStatus removeAllSecureStops();
		virtual DrmStatus getHdcpLevels(DrmPlugin::HdcpLevel *connectedLevel,
		DrmPlugin::HdcpLevel *maxLevel) const;
		virtual status_t getNumberOfSessions(uint32_t *currentSessions,
		virtual DrmStatus getNumberOfSessions(uint32_t *currentSessions,
		uint32_t *maxSessions) const;
		virtual status_t getSecurityLevel(Vector<uint8_t> const &sessionId,
		virtual DrmStatus getSecurityLevel(Vector<uint8_t> const &sessionId,
		DrmPlugin::SecurityLevel *level) const;
		virtual status_t getOfflineLicenseKeySetIds(List<Vector<uint8_t>> &keySetIds) const;
		virtual status_t removeOfflineLicense(Vector<uint8_t> const &keySetId);
		virtual status_t getOfflineLicenseState(Vector<uint8_t> const &keySetId,
		virtual DrmStatus getOfflineLicenseKeySetIds(List<Vector<uint8_t>> &keySetIds) const;
		virtual DrmStatus removeOfflineLicense(Vector<uint8_t> const &keySetId);
		virtual DrmStatus getOfflineLicenseState(Vector<uint8_t> const &keySetId,
		DrmPlugin::OfflineLicenseState *licenseState) const;
		virtual status_t getPropertyString(String8 const &name, String8 &value) const;
		virtual status_t getPropertyByteArray(String8 const &name,
		virtual DrmStatus getPropertyString(String8 const &name, String8 &value) const;
		virtual DrmStatus getPropertyByteArray(String8 const &name,
		Vector<uint8_t> &value) const;
		virtual status_t setPropertyString(String8 const &name,
		virtual DrmStatus setPropertyString(String8 const &name,
		String8 const &value ) const;
		virtual status_t setPropertyByteArray(String8 const &name,
		virtual DrmStatus setPropertyByteArray(String8 const &name,
		Vector<uint8_t> const &value) const;
		virtual status_t getMetrics(const sp<IDrmMetricsConsumer> &consumer);
		virtual status_t setCipherAlgorithm(Vector<uint8_t> const &sessionId,
		virtual DrmStatus getMetrics(const sp<IDrmMetricsConsumer> &consumer);
		virtual DrmStatus setCipherAlgorithm(Vector<uint8_t> const &sessionId,
		String8 const &algorithm);
		virtual status_t setMacAlgorithm(Vector<uint8_t> const &sessionId,
		virtual DrmStatus setMacAlgorithm(Vector<uint8_t> const &sessionId,
		String8 const &algorithm);
		virtual status_t encrypt(Vector<uint8_t> const &sessionId,
		virtual DrmStatus 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);
		virtual status_t decrypt(Vector<uint8_t> const &sessionId,
		virtual DrmStatus 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);
		virtual status_t sign(Vector<uint8_t> const &sessionId,
		virtual DrmStatus sign(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keyId,
		Vector<uint8_t> const &message,
		Vector<uint8_t> &signature);
		virtual status_t verify(Vector<uint8_t> const &sessionId,
		virtual DrmStatus verify(Vector<uint8_t> const &sessionId,
		Vector<uint8_t> const &keyId,
		Vector<uint8_t> const &message,
		Vector<uint8_t> const &signature,
		bool &match);
		virtual status_t signRSA(Vector<uint8_t> const &sessionId,
		virtual DrmStatus signRSA(Vector<uint8_t> const &sessionId,
		String8 const &algorithm,
		Vector<uint8_t> const &message,
		Vector<uint8_t> const &wrappedKey,
		Vector<uint8_t> &signature);
		virtual status_t setListener(const sp<IDrmClient>& listener);
		virtual status_t requiresSecureDecoder(const char mime, bool required) const;
		virtual status_t requiresSecureDecoder(const char *mime, DrmPlugin::SecurityLevel securityLevel,
		virtual DrmStatus setListener(const sp<IDrmClient>& listener);
		virtual DrmStatus requiresSecureDecoder(const char mime, bool required) const;
		virtual DrmStatus requiresSecureDecoder(const char *mime,
		DrmPlugin::SecurityLevel securityLevel,
		bool *required) const;
		virtual status_t setPlaybackId(
		virtual DrmStatus setPlaybackId(
		Vector<uint8_t> const &sessionId,
		const char *playbackId);
		virtual status_t getLogMessages(Vector<drm::V1_4::LogMessage> &logs) const;
		virtual status_t getSupportedSchemes(std::vector<uint8_t> &schemes) const;
		virtual DrmStatus getLogMessages(Vector<drm::V1_4::LogMessage> &logs) const;
		virtual DrmStatus getSupportedSchemes(std::vector<uint8_t> &schemes) const;

		private:
		sp<IDrm> mDrmHalHidl;