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

Commit 0abc5c74 authored by Robert Shih's avatar Robert Shih Committed by Automerger Merge Worker
Browse files

Merge "drm: fix error atom plumbing" am: c835b448 am: 26919473 am: b6c7c1b2 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/2510143



Change-Id: Ibee38a0fe82ed3035364f4548cdcea5ebaa281a5
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents ed2a0bee b6c7c1b2

drm/libmediadrm/DrmMetricsLogger.cpp

+53 −43
Original line number Diff line number Diff line
@@ -41,49 +41,59 @@ DrmMetricsLogger::DrmMetricsLogger(IDrmFrontend frontend) 


DrmMetricsLogger::~DrmMetricsLogger() {}



int MediaErrorToJavaError(status_t err) {

int MediaErrorToEnum(status_t err) {

#define ERROR_BAD_VALUE (BAD_VALUE)

#define ERROR_DEAD_OBJECT (DEAD_OBJECT)

#define STATUS_CASE(status) \

    case status: \

        return J##status

    case ERROR_##status: \

        return ENUM_##status



    switch (err) {

        STATUS_CASE(ERROR_DRM_UNKNOWN);

        STATUS_CASE(ERROR_DRM_NO_LICENSE);

        STATUS_CASE(ERROR_DRM_LICENSE_EXPIRED);

        STATUS_CASE(ERROR_DRM_RESOURCE_BUSY);

        STATUS_CASE(ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION);

        STATUS_CASE(ERROR_DRM_SESSION_NOT_OPENED);

        STATUS_CASE(ERROR_DRM_CANNOT_HANDLE);

        STATUS_CASE(ERROR_DRM_INSUFFICIENT_SECURITY);

        STATUS_CASE(ERROR_DRM_FRAME_TOO_LARGE);

        STATUS_CASE(ERROR_DRM_SESSION_LOST_STATE);

        STATUS_CASE(ERROR_DRM_CERTIFICATE_MALFORMED);

        STATUS_CASE(ERROR_DRM_CERTIFICATE_MISSING);

        STATUS_CASE(ERROR_DRM_CRYPTO_LIBRARY);

        STATUS_CASE(ERROR_DRM_GENERIC_OEM);

        STATUS_CASE(ERROR_DRM_GENERIC_PLUGIN);

        STATUS_CASE(ERROR_DRM_INIT_DATA);

        STATUS_CASE(ERROR_DRM_KEY_NOT_LOADED);

        STATUS_CASE(ERROR_DRM_LICENSE_PARSE);

        STATUS_CASE(ERROR_DRM_LICENSE_POLICY);

        STATUS_CASE(ERROR_DRM_LICENSE_RELEASE);

        STATUS_CASE(ERROR_DRM_LICENSE_REQUEST_REJECTED);

        STATUS_CASE(ERROR_DRM_LICENSE_RESTORE);

        STATUS_CASE(ERROR_DRM_LICENSE_STATE);

        STATUS_CASE(ERROR_DRM_MEDIA_FRAMEWORK);

        STATUS_CASE(ERROR_DRM_PROVISIONING_CERTIFICATE);

        STATUS_CASE(ERROR_DRM_PROVISIONING_CONFIG);

        STATUS_CASE(ERROR_DRM_PROVISIONING_PARSE);

        STATUS_CASE(ERROR_DRM_PROVISIONING_REQUEST_REJECTED);

        STATUS_CASE(ERROR_DRM_PROVISIONING_RETRY);

        STATUS_CASE(ERROR_DRM_RESOURCE_CONTENTION);

        STATUS_CASE(ERROR_DRM_SECURE_STOP_RELEASE);

        STATUS_CASE(ERROR_DRM_STORAGE_READ);

        STATUS_CASE(ERROR_DRM_STORAGE_WRITE);

        STATUS_CASE(ERROR_DRM_ZERO_SUBSAMPLES);

        STATUS_CASE(DRM_UNKNOWN);

        STATUS_CASE(DRM_NO_LICENSE);

        STATUS_CASE(DRM_LICENSE_EXPIRED);

        STATUS_CASE(DRM_RESOURCE_BUSY);

        STATUS_CASE(DRM_INSUFFICIENT_OUTPUT_PROTECTION);

        STATUS_CASE(DRM_SESSION_NOT_OPENED);

        STATUS_CASE(DRM_CANNOT_HANDLE);

        STATUS_CASE(DRM_INSUFFICIENT_SECURITY);

        STATUS_CASE(DRM_FRAME_TOO_LARGE);

        STATUS_CASE(DRM_SESSION_LOST_STATE);

        STATUS_CASE(DRM_CERTIFICATE_MALFORMED);

        STATUS_CASE(DRM_CERTIFICATE_MISSING);

        STATUS_CASE(DRM_CRYPTO_LIBRARY);

        STATUS_CASE(DRM_GENERIC_OEM);

        STATUS_CASE(DRM_GENERIC_PLUGIN);

        STATUS_CASE(DRM_INIT_DATA);

        STATUS_CASE(DRM_KEY_NOT_LOADED);

        STATUS_CASE(DRM_LICENSE_PARSE);

        STATUS_CASE(DRM_LICENSE_POLICY);

        STATUS_CASE(DRM_LICENSE_RELEASE);

        STATUS_CASE(DRM_LICENSE_REQUEST_REJECTED);

        STATUS_CASE(DRM_LICENSE_RESTORE);

        STATUS_CASE(DRM_LICENSE_STATE);

        STATUS_CASE(DRM_MEDIA_FRAMEWORK);

        STATUS_CASE(DRM_PROVISIONING_CERTIFICATE);

        STATUS_CASE(DRM_PROVISIONING_CONFIG);

        STATUS_CASE(DRM_PROVISIONING_PARSE);

        STATUS_CASE(DRM_PROVISIONING_REQUEST_REJECTED);

        STATUS_CASE(DRM_PROVISIONING_RETRY);

        STATUS_CASE(DRM_RESOURCE_CONTENTION);

        STATUS_CASE(DRM_SECURE_STOP_RELEASE);

        STATUS_CASE(DRM_STORAGE_READ);

        STATUS_CASE(DRM_STORAGE_WRITE);

        STATUS_CASE(DRM_ZERO_SUBSAMPLES);

        STATUS_CASE(DRM_INVALID_STATE);

        STATUS_CASE(BAD_VALUE);

        STATUS_CASE(DRM_NOT_PROVISIONED);

        STATUS_CASE(DRM_DEVICE_REVOKED);

        STATUS_CASE(DRM_DECRYPT);

        STATUS_CASE(DEAD_OBJECT);

#undef ERROR_BAD_VALUE

#undef ERROR_DEAD_OBJECT

#undef STATUS_CASE

    }

    return static_cast<int>(err);

    return ENUM_DRM_UNKNOWN;

}



int DrmPluginSecurityLevelToJavaSecurityLevel(DrmPlugin::SecurityLevel securityLevel) {
@@ -187,12 +197,12 @@ DrmStatus DrmMetricsLogger::openSession(DrmPlugin::SecurityLevel securityLevel, 


DrmStatus DrmMetricsLogger::closeSession(Vector<uint8_t> const& sessionId) {

    std::vector<uint8_t> sid = toStdVec(sessionId);

    {

    DrmStatus status = mImpl->closeSession(sessionId);

    if (status == OK) {

        const std::lock_guard<std::mutex> lock(mSessionMapMutex);

        mSessionMap.erase(sid);

    }

    DrmStatus status = mImpl->closeSession(sessionId);

    if (status != OK) {

    } else {

        // TODO(b/275729711): reclaim sessions that failed to close

        reportMediaDrmErrored(status, __func__, sid);

    }

    return status;
@@ -582,7 +592,7 @@ void DrmMetricsLogger::reportMediaDrmErrored(const DrmStatus& error_code, const 
        }

    }

    mediametrics_setCString(handle, "api", api);

    mediametrics_setInt32(handle, "error_code", MediaErrorToJavaError(error_code));

    mediametrics_setInt32(handle, "error_code", MediaErrorToEnum(error_code));

    mediametrics_setInt32(handle, "cdm_err", error_code.getCdmErr());

    mediametrics_setInt32(handle, "oem_err", error_code.getOemErr());

    mediametrics_setInt32(handle, "error_context", error_code.getContext());

drm/libmediadrm/include/mediadrm/DrmMetricsLogger.h

+42 −34
Original line number Diff line number Diff line
@@ -25,41 +25,49 @@ 


namespace android {



// Keep enums in sync with frameworks/proto_logging/stats/enums/media/drm/enums.proto



enum {

    JERROR_DRM_UNKNOWN = 0,

    JERROR_DRM_NO_LICENSE = 1,

    JERROR_DRM_LICENSE_EXPIRED = 2,

    JERROR_DRM_RESOURCE_BUSY = 3,

    JERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION = 4,

    JERROR_DRM_SESSION_NOT_OPENED = 5,

    JERROR_DRM_CANNOT_HANDLE = 6,

    JERROR_DRM_INSUFFICIENT_SECURITY = 7,

    JERROR_DRM_FRAME_TOO_LARGE = 8,

    JERROR_DRM_SESSION_LOST_STATE = 9,

    JERROR_DRM_CERTIFICATE_MALFORMED = 10,

    JERROR_DRM_CERTIFICATE_MISSING = 11,

    JERROR_DRM_CRYPTO_LIBRARY = 12,

    JERROR_DRM_GENERIC_OEM = 13,

    JERROR_DRM_GENERIC_PLUGIN = 14,

    JERROR_DRM_INIT_DATA = 15,

    JERROR_DRM_KEY_NOT_LOADED = 16,

    JERROR_DRM_LICENSE_PARSE = 17,

    JERROR_DRM_LICENSE_POLICY = 18,

    JERROR_DRM_LICENSE_RELEASE = 19,

    JERROR_DRM_LICENSE_REQUEST_REJECTED = 20,

    JERROR_DRM_LICENSE_RESTORE = 21,

    JERROR_DRM_LICENSE_STATE = 22,

    JERROR_DRM_MEDIA_FRAMEWORK = 23,

    JERROR_DRM_PROVISIONING_CERTIFICATE = 24,

    JERROR_DRM_PROVISIONING_CONFIG = 25,

    JERROR_DRM_PROVISIONING_PARSE = 26,

    JERROR_DRM_PROVISIONING_REQUEST_REJECTED = 27,

    JERROR_DRM_PROVISIONING_RETRY = 28,

    JERROR_DRM_RESOURCE_CONTENTION = 29,

    JERROR_DRM_SECURE_STOP_RELEASE = 30,

    JERROR_DRM_STORAGE_READ = 31,

    JERROR_DRM_STORAGE_WRITE = 32,

    JERROR_DRM_ZERO_SUBSAMPLES = 33,

    ENUM_DRM_UNKNOWN = 0,

    ENUM_DRM_NO_LICENSE = 1,

    ENUM_DRM_LICENSE_EXPIRED = 2,

    ENUM_DRM_RESOURCE_BUSY = 3,

    ENUM_DRM_INSUFFICIENT_OUTPUT_PROTECTION = 4,

    ENUM_DRM_SESSION_NOT_OPENED = 5,

    ENUM_DRM_CANNOT_HANDLE = 6,

    ENUM_DRM_INSUFFICIENT_SECURITY = 7,

    ENUM_DRM_FRAME_TOO_LARGE = 8,

    ENUM_DRM_SESSION_LOST_STATE = 9,

    ENUM_DRM_CERTIFICATE_MALFORMED = 10,

    ENUM_DRM_CERTIFICATE_MISSING = 11,

    ENUM_DRM_CRYPTO_LIBRARY = 12,

    ENUM_DRM_GENERIC_OEM = 13,

    ENUM_DRM_GENERIC_PLUGIN = 14,

    ENUM_DRM_INIT_DATA = 15,

    ENUM_DRM_KEY_NOT_LOADED = 16,

    ENUM_DRM_LICENSE_PARSE = 17,

    ENUM_DRM_LICENSE_POLICY = 18,

    ENUM_DRM_LICENSE_RELEASE = 19,

    ENUM_DRM_LICENSE_REQUEST_REJECTED = 20,

    ENUM_DRM_LICENSE_RESTORE = 21,

    ENUM_DRM_LICENSE_STATE = 22,

    ENUM_DRM_MEDIA_FRAMEWORK = 23,

    ENUM_DRM_PROVISIONING_CERTIFICATE = 24,

    ENUM_DRM_PROVISIONING_CONFIG = 25,

    ENUM_DRM_PROVISIONING_PARSE = 26,

    ENUM_DRM_PROVISIONING_REQUEST_REJECTED = 27,

    ENUM_DRM_PROVISIONING_RETRY = 28,

    ENUM_DRM_RESOURCE_CONTENTION = 29,

    ENUM_DRM_SECURE_STOP_RELEASE = 30,

    ENUM_DRM_STORAGE_READ = 31,

    ENUM_DRM_STORAGE_WRITE = 32,

    ENUM_DRM_ZERO_SUBSAMPLES = 33,

    ENUM_DRM_INVALID_STATE = 34,

    ENUM_BAD_VALUE = 35,

    ENUM_DRM_NOT_PROVISIONED = 36,

    ENUM_DRM_DEVICE_REVOKED = 37,

    ENUM_DRM_DECRYPT = 38,

    ENUM_DEAD_OBJECT = 39,

};



enum {

services/mediametrics/statsd_drm.cpp

+6 −6
Original line number Diff line number Diff line
@@ -281,9 +281,9 @@ bool statsd_mediadrm_session_opened(const std::shared_ptr<const mediametrics::It 
    const int32_t uid = IPCThreadState::self()->getCallingUid();

    int32_t frontend = 0;

    if (!item->getInt32("frontend", &frontend)) return false;

    int32_t requested_security_level = -1;

    int32_t requested_security_level = 0;

    if (!item->getInt32("requested_security_level", &requested_security_level)) return false;

    int32_t opened_security_level = -1;

    int32_t opened_security_level = 0;

    if (!item->getInt32("opened_security_level", &opened_security_level)) return false;



    // Optional to be included
@@ -325,12 +325,10 @@ bool statsd_mediadrm_errored(const std::shared_ptr<const mediametrics::Item>& it 
    if (!item->getInt32("frontend", &frontend)) return false;

    std::string object_nonce = "";

    if (!item->getString("object_nonce", &object_nonce)) return false;

    int32_t security_level = -1;

    if (!item->getInt32("security_level", &security_level)) return false;

    std::string api_str = "";

    if (!item->getString("api", &api_str)) return false;

    const int32_t api = MediaDrmStatsdHelper::findDrmApi(api_str);

    int32_t error_code = -1;

    int32_t error_code = 0;

    if (!item->getInt32("error_code", &error_code)) return false;



    // Optional to be included
@@ -338,12 +336,14 @@ bool statsd_mediadrm_errored(const std::shared_ptr<const mediametrics::Item>& it 
    item->getString("version", &version);

    std::string session_nonce = "";

    item->getString("session_nonce", &session_nonce);

    int32_t security_level = 0;

    item->getInt32("security_level", &security_level);



    int32_t cdm_err = 0;

    item->getInt32("cdm_err", &cdm_err);

    int32_t oem_err = 0;

    item->getInt32("oem_err", &oem_err);

    int32_t error_context = -1;

    int32_t error_context = 0;

    item->getInt32("error_context", &error_context);



    const int result = stats_write(stats::media_metrics::MEDIA_DRM_ERRORED, scheme, uuid_lsb,