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

Commit e400e210 authored by Robert Shih's avatar Robert Shih Committed by Gerrit Code Review
Browse files

Merge "Populate drm error details from aidl HAL"

parents 8df134ee 89b232b5

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) {