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

Commit 6d998b67 authored by Jeff Tinker's avatar Jeff Tinker Committed by Rahul Frias
Browse files

Implement new MediaDrm methods 

Methods for querying HDCP, security levels and
number of sessions

bug:64001680
bug:33657579

Test: cts: MediaDrmMockTest, ClearKeySystemTest
gts: GtsMediaTestCases

Change-Id: I7c84df02ec33d305b6bd5ac7479922f87aa64863
parent e1883526

drm/libmediadrm/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ cc_library_shared { 
        "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));
@@ -842,10 +949,7 @@ status_t DrmHal::setPropertyByteArray(String8 const &name, 
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);
@@ -857,10 +961,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);
@@ -873,10 +974,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);
@@ -899,10 +997,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);
@@ -925,10 +1020,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);
@@ -951,10 +1043,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);
@@ -979,10 +1068,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
@@ -55,7 +55,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> {
@@ -350,6 +354,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());
@@ -788,6 +868,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>
@@ -26,11 +27,12 @@ 
#include <media/IDrmClient.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;
@@ -98,6 +100,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;
@@ -165,6 +176,7 @@ private: 


    const Vector<sp<IDrmFactory>> mFactories;

    sp<IDrmPlugin> mPlugin;

    sp<drm::V1_1::IDrmPlugin> mPluginV1_1;



    Vector<Vector<uint8_t>> mOpenSessions;

    void closeOpenSessions();