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

Commit 99dbfa82 authored by Jeff Tinker's avatar Jeff Tinker
Browse files

Add securityLevel to MediaDrm isCryptoSchemeSupported API 

bug:110701831
test: cts media test cases, widevine integration tests

Change-Id: Ia4308a27a11a279db1fb127c51d752ecaa86dfcb
parent 701768e8

drm/libmediadrm/DrmHal.cpp

+53 −28
Original line number Diff line number Diff line
@@ -145,6 +145,23 @@ static DrmPlugin::SecurityLevel toSecurityLevel(SecurityLevel level) { 
    }

}



static SecurityLevel toHidlSecurityLevel(DrmPlugin::SecurityLevel level) {

    switch(level) {

    case DrmPlugin::kSecurityLevelSwSecureCrypto:

        return SecurityLevel::SW_SECURE_CRYPTO;

    case DrmPlugin::kSecurityLevelSwSecureDecode:

        return SecurityLevel::SW_SECURE_DECODE;

    case DrmPlugin::kSecurityLevelHwSecureCrypto:

        return SecurityLevel::HW_SECURE_CRYPTO;

    case DrmPlugin::kSecurityLevelHwSecureDecode:

        return SecurityLevel::HW_SECURE_DECODE;

    case DrmPlugin::kSecurityLevelHwSecureAll:

        return SecurityLevel::HW_SECURE_ALL;

    default:

        return SecurityLevel::UNKNOWN;

    }

}



static DrmPlugin::OfflineLicenseState toOfflineLicenseState(

        OfflineLicenseState licenseState) {

    switch(licenseState) {
@@ -569,16 +586,39 @@ Return<void> DrmHal::sendSessionLostState( 
    return Void();

}



bool DrmHal::isCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType) {

    Mutex::Autolock autoLock(mLock);



    for (size_t i = 0; i < mFactories.size(); i++) {

        if (mFactories[i]->isCryptoSchemeSupported(uuid)) {

            if (mimeType != "") {

                if (mFactories[i]->isContentTypeSupported(mimeType.string())) {

bool DrmHal::matchMimeTypeAndSecurityLevel(sp<IDrmFactory> &factory,

                                           const uint8_t uuid[16],

                                           const String8 &mimeType,

                                           DrmPlugin::SecurityLevel level) {

    if (mimeType == "") {

        return true;

    } else if (!factory->isContentTypeSupported(mimeType.string())) {

        return false;

    }



    if (level == DrmPlugin::kSecurityLevelUnknown) {

        return true;

    } else {

        sp<drm::V1_2::IDrmFactory> factoryV1_2 = drm::V1_2::IDrmFactory::castFrom(factory);

        if (factoryV1_2 == NULL) {

            return true;

        } else if (factoryV1_2->isCryptoSchemeSupported_1_2(uuid,

                        mimeType.string(), toHidlSecurityLevel(level))) {

            return true;

        }

    }

    return false;

}



bool DrmHal::isCryptoSchemeSupported(const uint8_t uuid[16],

                                     const String8 &mimeType,

                                     DrmPlugin::SecurityLevel level) {

    Mutex::Autolock autoLock(mLock);



    for (size_t i = 0; i < mFactories.size(); i++) {

        sp<IDrmFactory> factory = mFactories[i];

        if (factory->isCryptoSchemeSupported(uuid)) {

            if (matchMimeTypeAndSecurityLevel(factory, uuid, mimeType, level)) {

                return true;

            }

        }
@@ -634,31 +674,16 @@ status_t DrmHal::openSession(DrmPlugin::SecurityLevel level, 
    Mutex::Autolock autoLock(mLock);

    INIT_CHECK();



    SecurityLevel hSecurityLevel;

    SecurityLevel hSecurityLevel = toHidlSecurityLevel(level);

    bool setSecurityLevel = true;



    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;

    case DrmPlugin::kSecurityLevelMax:

    if (level == DrmPlugin::kSecurityLevelMax) {

        setSecurityLevel = false;

        break;

    default:

    } else {

        if (hSecurityLevel == SecurityLevel::UNKNOWN) {

            return ERROR_DRM_CANNOT_HANDLE;

        }

    }



    status_t  err = UNKNOWN_ERROR;

    bool retry = true;

drm/libmediadrm/IDrm.cpp

+9 −4
Original line number Diff line number Diff line
@@ -83,11 +83,14 @@ struct BpDrm : public BpInterface<IDrm> { 
        return reply.readInt32();

    }



    virtual bool isCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType) {

    virtual bool isCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType,

            DrmPlugin::SecurityLevel level) {

        Parcel data, reply;

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

        data.write(uuid, 16);

        data.writeString8(mimeType);

        data.writeInt32(level);



        status_t status = remote()->transact(IS_CRYPTO_SUPPORTED, data, &reply);

        if (status != OK) {

            ALOGE("isCryptoSchemeSupported: binder call failed: %d", status);
@@ -123,11 +126,11 @@ struct BpDrm : public BpInterface<IDrm> { 
        return reply.readInt32();

    }



    virtual status_t openSession(DrmPlugin::SecurityLevel securityLevel,

    virtual status_t openSession(DrmPlugin::SecurityLevel level,

            Vector<uint8_t> &sessionId) {

        Parcel data, reply;

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

        data.writeInt32(securityLevel);

        data.writeInt32(level);



        status_t status = remote()->transact(OPEN_SESSION, data, &reply);

        if (status != OK) {
@@ -768,7 +771,9 @@ status_t BnDrm::onTransact( 
            uint8_t uuid[16];

            data.read(uuid, sizeof(uuid));

            String8 mimeType = data.readString8();

            reply->writeInt32(isCryptoSchemeSupported(uuid, mimeType));

            DrmPlugin::SecurityLevel level =

                    static_cast<DrmPlugin::SecurityLevel>(data.readInt32());

            reply->writeInt32(isCryptoSchemeSupported(uuid, mimeType, level));

            return OK;

        }

drm/mediadrm/plugins/clearkey/hidl/DrmFactory.cpp

+8 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ namespace V1_2 { 
namespace clearkey {



using ::android::hardware::drm::V1_0::Status;

using ::android::hardware::drm::V1_1::SecurityLevel;

using ::android::hardware::Void;



Return<bool> DrmFactory::isCryptoSchemeSupported(
@@ -41,6 +42,13 @@ Return<bool> DrmFactory::isCryptoSchemeSupported( 
    return clearkeydrm::isClearKeyUUID(uuid.data());

}



Return<bool> DrmFactory::isCryptoSchemeSupported_1_2(const hidl_array<uint8_t, 16>& uuid,

                                                     const hidl_string &mimeType,

                                                     SecurityLevel level) {

    return isCryptoSchemeSupported(uuid) && isContentTypeSupported(mimeType) &&

            level == SecurityLevel::SW_SECURE_CRYPTO;

}



Return<bool> DrmFactory::isContentTypeSupported(const hidl_string &mimeType) {

    // This should match the mimeTypes handed by InitDataParser.

    return mimeType == kIsoBmffVideoMimeType ||

drm/mediadrm/plugins/clearkey/hidl/include/ClearKeyTypes.h

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ namespace V1_2 { 
namespace clearkey {



using ::android::hardware::drm::V1_0::KeyValue;

using ::android::hardware::drm::V1_1::SecurityLevel;

using ::android::hardware::hidl_vec;



const uint8_t kBlockSize = 16; //AES_BLOCK_SIZE;

drm/mediadrm/plugins/clearkey/hidl/include/DrmFactory.h

+4 −0
Original line number Diff line number Diff line
@@ -39,6 +39,10 @@ struct DrmFactory : public IDrmFactory { 
    Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)

            override;



    Return<bool> isCryptoSchemeSupported_1_2(const hidl_array<uint8_t, 16>& uuid,

                                             const hidl_string& mimeType,

                                             SecurityLevel level) override;



    Return<bool> isContentTypeSupported(const hidl_string &mimeType)

            override;