Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0cc3da84 authored by Sohail Nagaraj's avatar Sohail Nagaraj
Browse files

New IDrm API return type 

Bug: 260065906

Test: gts-tradefed run gts --abi arm64-v8a -m GtsMediaTestCases
Test: atest CtsMediaDrmFrameworkTestCases

Change-Id: Iaa017050e28f6412f62bd9d4a16e62fcea253e32
parent bd526c26

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;