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

Commit 89b232b5 authored by Robert Shih's avatar Robert Shih
Browse files

Populate drm error details from aidl HAL 

Bug: 249941041
Test: MediaDrmParameterizedTests#testLicenseErrorCodes
Change-Id: Ib83a6302a34567d955c087bf387ba3ea3ffbed73
parent 9304228e

drm/libmediadrm/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -74,6 +74,7 @@ cc_library { 
    static_libs: [

        "resourcemanager_aidl_interface-ndk",

        "libaidlcommonsupport",

        "libjsoncpp",

    ],



    export_shared_lib_headers: [

drm/libmediadrm/DrmUtils.cpp

+160 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
#include <android/hardware/drm/1.4/IDrmFactory.h>

#include <android/hidl/manager/1.2/IServiceManager.h>

#include <hidl/HidlSupport.h>

#include <json/json.h>



#include <cutils/properties.h>

#include <utils/Errors.h>
@@ -410,6 +411,165 @@ Vector<::V1_4::LogMessage> LogBuffer::getLogs() { 
    return logs;

}



DrmStatus statusAidlToDrmStatus(::ndk::ScopedAStatus& statusAidl) {

    if (statusAidl.isOk()) return OK;

    if (statusAidl.getExceptionCode() != EX_SERVICE_SPECIFIC) return DEAD_OBJECT;

    auto astatus = static_cast<StatusAidl>(statusAidl.getServiceSpecificError());

    status_t status{};

    switch (astatus) {

    case StatusAidl::OK:

        status = OK;

        break;

    case StatusAidl::BAD_VALUE:

        status = BAD_VALUE;

        break;

    case StatusAidl::ERROR_DRM_CANNOT_HANDLE:

        status = ERROR_DRM_CANNOT_HANDLE;

        break;

    case StatusAidl::ERROR_DRM_DECRYPT:

        status = ERROR_DRM_DECRYPT;

        break;

    case StatusAidl::ERROR_DRM_DEVICE_REVOKED:

        status = ERROR_DRM_DEVICE_REVOKED;

        break;

    case StatusAidl::ERROR_DRM_FRAME_TOO_LARGE:

        status = ERROR_DRM_FRAME_TOO_LARGE;

        break;

    case StatusAidl::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:

        status = ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION;

        break;

    case StatusAidl::ERROR_DRM_INSUFFICIENT_SECURITY:

        status = ERROR_DRM_INSUFFICIENT_SECURITY;

        break;

    case StatusAidl::ERROR_DRM_INVALID_STATE:

        status = ERROR_DRM_INVALID_STATE;

        break;

    case StatusAidl::ERROR_DRM_LICENSE_EXPIRED:

        status = ERROR_DRM_LICENSE_EXPIRED;

        break;

    case StatusAidl::ERROR_DRM_NO_LICENSE:

        status = ERROR_DRM_NO_LICENSE;

        break;

    case StatusAidl::ERROR_DRM_NOT_PROVISIONED:

        status = ERROR_DRM_NOT_PROVISIONED;

        break;

    case StatusAidl::ERROR_DRM_RESOURCE_BUSY:

        status = ERROR_DRM_RESOURCE_BUSY;

        break;

    case StatusAidl::ERROR_DRM_RESOURCE_CONTENTION:

        status = ERROR_DRM_RESOURCE_CONTENTION;

        break;

    case StatusAidl::ERROR_DRM_SESSION_LOST_STATE:

        status = ERROR_DRM_SESSION_LOST_STATE;

        break;

    case StatusAidl::ERROR_DRM_SESSION_NOT_OPENED:

        status = ERROR_DRM_SESSION_NOT_OPENED;

        break;



    // New in S / drm@1.4:

    case StatusAidl::CANNOT_DECRYPT_ZERO_SUBSAMPLES:

        status = ERROR_DRM_ZERO_SUBSAMPLES;

        break;

    case StatusAidl::CRYPTO_LIBRARY_ERROR:

        status = ERROR_DRM_CRYPTO_LIBRARY;

        break;

    case StatusAidl::GENERAL_OEM_ERROR:

        status = ERROR_DRM_GENERIC_OEM;

        break;

    case StatusAidl::GENERAL_PLUGIN_ERROR:

        status = ERROR_DRM_GENERIC_PLUGIN;

        break;

    case StatusAidl::INIT_DATA_INVALID:

        status = ERROR_DRM_INIT_DATA;

        break;

    case StatusAidl::KEY_NOT_LOADED:

        status = ERROR_DRM_KEY_NOT_LOADED;

        break;

    case StatusAidl::LICENSE_PARSE_ERROR:

        status = ERROR_DRM_LICENSE_PARSE;

        break;

    case StatusAidl::LICENSE_POLICY_ERROR:

        status = ERROR_DRM_LICENSE_POLICY;

        break;

    case StatusAidl::LICENSE_RELEASE_ERROR:

        status = ERROR_DRM_LICENSE_RELEASE;

        break;

    case StatusAidl::LICENSE_REQUEST_REJECTED:

        status = ERROR_DRM_LICENSE_REQUEST_REJECTED;

        break;

    case StatusAidl::LICENSE_RESTORE_ERROR:

        status = ERROR_DRM_LICENSE_RESTORE;

        break;

    case StatusAidl::LICENSE_STATE_ERROR:

        status = ERROR_DRM_LICENSE_STATE;

        break;

    case StatusAidl::MALFORMED_CERTIFICATE:

        status = ERROR_DRM_CERTIFICATE_MALFORMED;

        break;

    case StatusAidl::MEDIA_FRAMEWORK_ERROR:

        status = ERROR_DRM_MEDIA_FRAMEWORK;

        break;

    case StatusAidl::MISSING_CERTIFICATE:

        status = ERROR_DRM_CERTIFICATE_MISSING;

        break;

    case StatusAidl::PROVISIONING_CERTIFICATE_ERROR:

        status = ERROR_DRM_PROVISIONING_CERTIFICATE;

        break;

    case StatusAidl::PROVISIONING_CONFIGURATION_ERROR:

        status = ERROR_DRM_PROVISIONING_CONFIG;

        break;

    case StatusAidl::PROVISIONING_PARSE_ERROR:

        status = ERROR_DRM_PROVISIONING_PARSE;

        break;

    case StatusAidl::PROVISIONING_REQUEST_REJECTED:

        status = ERROR_DRM_PROVISIONING_REQUEST_REJECTED;

        break;

    case StatusAidl::RETRYABLE_PROVISIONING_ERROR:

        status = ERROR_DRM_PROVISIONING_RETRY;

        break;

    case StatusAidl::SECURE_STOP_RELEASE_ERROR:

        status = ERROR_DRM_SECURE_STOP_RELEASE;

        break;

    case StatusAidl::STORAGE_READ_FAILURE:

        status = ERROR_DRM_STORAGE_READ;

        break;

    case StatusAidl::STORAGE_WRITE_FAILURE:

        status = ERROR_DRM_STORAGE_WRITE;

        break;



    case StatusAidl::ERROR_DRM_UNKNOWN:

    default:

        status = ERROR_DRM_UNKNOWN;

        break;

    }



    Json::Value errorDetails;

    Json::Reader reader;

    if (!reader.parse(statusAidl.getMessage(), errorDetails)) {

        return status;

    }



    int32_t cdmErr{}, oemErr{}, ctx{};

    std::string errMsg;

    auto val = errorDetails["cdmError"];

    if (!val.isNull()) {

        cdmErr = val.asInt();

    }

    val = errorDetails["oemError"];

    if (!val.isNull()) {

        oemErr = val.asInt();

    }

    val = errorDetails["context"];

    if (!val.isNull()) {

        ctx = val.asInt();

    }

    val = errorDetails["errorMessage"];

    if (!val.isNull()) {

        errMsg = val.asString();

    }

    return DrmStatus(status, cdmErr, oemErr, ctx, errMsg);

}



LogBuffer gLogBuf;

}  // namespace DrmUtils

}  // namespace android

drm/libmediadrm/fuzzer/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ cc_fuzz { 
        "liblog",

        "resourcemanager_aidl_interface-ndk",

        "libaidlcommonsupport",

        "libjsoncpp",

    ],

    header_libs: [

        "libmedia_headers",

drm/libmediadrm/include/mediadrm/DrmStatus.h

+13 −6
Original line number Diff line number Diff line
@@ -16,27 +16,34 @@ 


#ifndef DRM_STATUS_

#define DRM_STATUS_

#include <stdint.h>



#include <media/stagefright/foundation/ABase.h>

#include <media/stagefright/MediaErrors.h>

#include <utils/Errors.h>



#include <stdint.h>

#include <string>



namespace android {



struct DrmStatus {

  public:

    DrmStatus(status_t status, int32_t cdmerr = 0, int32_t oemerr = 0)

        : mStatus(status), mCdmErr(cdmerr), mOemErr(oemerr) {}

    DrmStatus(status_t status, int32_t cdmErr = 0, int32_t oemErr = 0,

              int32_t ctx = 0, std::string errMsg = "")

        : mStatus(status), mCdmErr(cdmErr), mOemErr(oemErr),

          mCtx(ctx), mErrMsg(errMsg) {}

    operator status_t() const { return mStatus; }

    int32_t cdmErr() const { return mCdmErr; }

    int32_t oemErr() const { return mOemErr; }

    int32_t getCdmErr() const { return mCdmErr; }

    int32_t getOemErr() const { return mOemErr; }

    int32_t getContext() const { return mCtx; }

    std::string getErrorMessage() const { return mErrMsg; }

    bool operator==(status_t other) const { return mStatus == other; }

    bool operator!=(status_t other) const { return mStatus != other; }



  private:

    status_t mStatus;

    int32_t mCdmErr{}, mOemErr{};

    int32_t mCdmErr{}, mOemErr{}, mCtx{};

    std::string mErrMsg;

};



}  // namespace android

drm/libmediadrm/interface/mediadrm/DrmUtils.h

+1 −92
Original line number Diff line number Diff line
@@ -199,98 +199,7 @@ inline status_t toStatusT(const android::hardware::Return<T> &status) { 
    return toStatusT_1_4(err);

}



inline DrmStatus statusAidlToDrmStatus(::ndk::ScopedAStatus& statusAidl) {

    if (statusAidl.isOk()) return OK;

    if (statusAidl.getExceptionCode() != EX_SERVICE_SPECIFIC) return DEAD_OBJECT;

    auto status = static_cast<StatusAidl>(statusAidl.getServiceSpecificError());

    switch (status) {

    case StatusAidl::OK:

        return OK;

    case StatusAidl::BAD_VALUE:

        return BAD_VALUE;

    case StatusAidl::ERROR_DRM_CANNOT_HANDLE:

        return ERROR_DRM_CANNOT_HANDLE;

    case StatusAidl::ERROR_DRM_DECRYPT:

        return ERROR_DRM_DECRYPT;

    case StatusAidl::ERROR_DRM_DEVICE_REVOKED:

        return ERROR_DRM_DEVICE_REVOKED;

    case StatusAidl::ERROR_DRM_FRAME_TOO_LARGE:

        return ERROR_DRM_FRAME_TOO_LARGE;

    case StatusAidl::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:

        return ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION;

    case StatusAidl::ERROR_DRM_INSUFFICIENT_SECURITY:

        return ERROR_DRM_INSUFFICIENT_SECURITY;

    case StatusAidl::ERROR_DRM_INVALID_STATE:

        return ERROR_DRM_INVALID_STATE;

    case StatusAidl::ERROR_DRM_LICENSE_EXPIRED:

        return ERROR_DRM_LICENSE_EXPIRED;

    case StatusAidl::ERROR_DRM_NO_LICENSE:

        return ERROR_DRM_NO_LICENSE;

    case StatusAidl::ERROR_DRM_NOT_PROVISIONED:

        return ERROR_DRM_NOT_PROVISIONED;

    case StatusAidl::ERROR_DRM_RESOURCE_BUSY:

        return ERROR_DRM_RESOURCE_BUSY;

    case StatusAidl::ERROR_DRM_RESOURCE_CONTENTION:

        return ERROR_DRM_RESOURCE_CONTENTION;

    case StatusAidl::ERROR_DRM_SESSION_LOST_STATE:

        return ERROR_DRM_SESSION_LOST_STATE;

    case StatusAidl::ERROR_DRM_SESSION_NOT_OPENED:

        return ERROR_DRM_SESSION_NOT_OPENED;



    // New in S / drm@1.4:

    case StatusAidl::CANNOT_DECRYPT_ZERO_SUBSAMPLES:

        return ERROR_DRM_ZERO_SUBSAMPLES;

    case StatusAidl::CRYPTO_LIBRARY_ERROR:

        return ERROR_DRM_CRYPTO_LIBRARY;

    case StatusAidl::GENERAL_OEM_ERROR:

        return ERROR_DRM_GENERIC_OEM;

    case StatusAidl::GENERAL_PLUGIN_ERROR:

        return ERROR_DRM_GENERIC_PLUGIN;

    case StatusAidl::INIT_DATA_INVALID:

        return ERROR_DRM_INIT_DATA;

    case StatusAidl::KEY_NOT_LOADED:

        return ERROR_DRM_KEY_NOT_LOADED;

    case StatusAidl::LICENSE_PARSE_ERROR:

        return ERROR_DRM_LICENSE_PARSE;

    case StatusAidl::LICENSE_POLICY_ERROR:

        return ERROR_DRM_LICENSE_POLICY;

    case StatusAidl::LICENSE_RELEASE_ERROR:

        return ERROR_DRM_LICENSE_RELEASE;

    case StatusAidl::LICENSE_REQUEST_REJECTED:

        return ERROR_DRM_LICENSE_REQUEST_REJECTED;

    case StatusAidl::LICENSE_RESTORE_ERROR:

        return ERROR_DRM_LICENSE_RESTORE;

    case StatusAidl::LICENSE_STATE_ERROR:

        return ERROR_DRM_LICENSE_STATE;

    case StatusAidl::MALFORMED_CERTIFICATE:

        return ERROR_DRM_CERTIFICATE_MALFORMED;

    case StatusAidl::MEDIA_FRAMEWORK_ERROR:

        return ERROR_DRM_MEDIA_FRAMEWORK;

    case StatusAidl::MISSING_CERTIFICATE:

        return ERROR_DRM_CERTIFICATE_MISSING;

    case StatusAidl::PROVISIONING_CERTIFICATE_ERROR:

        return ERROR_DRM_PROVISIONING_CERTIFICATE;

    case StatusAidl::PROVISIONING_CONFIGURATION_ERROR:

        return ERROR_DRM_PROVISIONING_CONFIG;

    case StatusAidl::PROVISIONING_PARSE_ERROR:

        return ERROR_DRM_PROVISIONING_PARSE;

    case StatusAidl::PROVISIONING_REQUEST_REJECTED:

        return ERROR_DRM_PROVISIONING_REQUEST_REJECTED;

    case StatusAidl::RETRYABLE_PROVISIONING_ERROR:

        return ERROR_DRM_PROVISIONING_RETRY;

    case StatusAidl::SECURE_STOP_RELEASE_ERROR:

        return ERROR_DRM_SECURE_STOP_RELEASE;

    case StatusAidl::STORAGE_READ_FAILURE:

        return ERROR_DRM_STORAGE_READ;

    case StatusAidl::STORAGE_WRITE_FAILURE:

        return ERROR_DRM_STORAGE_WRITE;



    case StatusAidl::ERROR_DRM_UNKNOWN:

    default:

        return ERROR_DRM_UNKNOWN;

    }

    return ERROR_DRM_UNKNOWN;

}

DrmStatus statusAidlToDrmStatus(::ndk::ScopedAStatus& statusAidl);



template<typename T, typename U>

status_t GetLogMessagesAidl(const std::shared_ptr<U> &obj, Vector<::V1_4::LogMessage> &logs) {