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

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

Merge "Updated metrics logging IDrm implementation" am: bcd5d085 

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



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

drm/libmediadrm/DrmMetricsLogger.cpp

+95 −49
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#define LOG_TAG "DrmMetricsLogger"



#include <media/MediaMetrics.h>

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

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

#include <mediadrm/DrmHal.h>

#include <mediadrm/DrmMetricsLogger.h>

#include <mediadrm/DrmUtils.h>
@@ -34,7 +36,7 @@ std::vector<uint8_t> toStdVec(Vector<uint8_t> const& sessionId) { 
}  // namespace



DrmMetricsLogger::DrmMetricsLogger(IDrmFrontend frontend)

    : mImpl(sp<DrmHal>::make()), mUuid(), mObjNonceMsb(0), mObjNonceLsb(0), mFrontend(frontend) {}

    : mImpl(sp<DrmHal>::make()), mUuid(), mObjNonce(), mFrontend(frontend) {}



DrmMetricsLogger::~DrmMetricsLogger() {}
@@ -57,9 +59,15 @@ DrmStatus DrmMetricsLogger::isCryptoSchemeSupported(const uint8_t uuid[16], cons 
}



DrmStatus DrmMetricsLogger::createPlugin(const uint8_t uuid[16], const String8& appPackageName) {

    std::memcpy(mUuid, uuid, sizeof(mUuid));

    if (checkGetRandom(&mObjNonceMsb, __func__) == OK &&

        checkGetRandom(&mObjNonceLsb, __func__) == OK) {

    std::memcpy(mUuid.data(), uuid, mUuid.size());

    if (kUuidSchemeMap.count(mUuid)) {

        mScheme = kUuidSchemeMap.at(mUuid);

    } else {

        mScheme = "Other";

    }

    if (generateNonce(&mObjNonce, kNonceSize, __func__) != OK) {

        return ERROR_DRM_RESOURCE_BUSY;

    }

    DrmStatus status = mImpl->createPlugin(uuid, appPackageName);

    if (status == OK) {

        reportMediaDrmCreated();
@@ -68,8 +76,6 @@ DrmStatus DrmMetricsLogger::createPlugin(const uint8_t uuid[16], const String8& 
    }

    return status;

}

    return ERROR_DRM_RESOURCE_BUSY;

}



DrmStatus DrmMetricsLogger::destroyPlugin() {

    DrmStatus status = mImpl->destroyPlugin();
@@ -82,8 +88,9 @@ DrmStatus DrmMetricsLogger::destroyPlugin() { 
DrmStatus DrmMetricsLogger::openSession(DrmPlugin::SecurityLevel securityLevel,

                                        Vector<uint8_t>& sessionId) {

    SessionContext ctx{};

    if (checkGetRandom(&ctx.mNonceMsb, __func__) == OK &&

        checkGetRandom(&ctx.mNonceLsb, __func__) == OK) {

    if (generateNonce(&ctx.mNonce, kNonceSize, __func__) != OK) {

        return ERROR_DRM_RESOURCE_BUSY;

    }

    DrmStatus status = mImpl->openSession(securityLevel, sessionId);

    if (status == OK) {

        std::vector<uint8_t> sessionKey = toStdVec(sessionId);
@@ -101,8 +108,6 @@ DrmStatus DrmMetricsLogger::openSession(DrmPlugin::SecurityLevel securityLevel, 
    }

    return status;

}

    return ERROR_DRM_RESOURCE_BUSY;

}



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

    std::vector<uint8_t> sid = toStdVec(sessionId);
@@ -419,7 +424,7 @@ DrmStatus DrmMetricsLogger::requiresSecureDecoder(const char* mime, 
                                                  bool* required) const {

    DrmStatus status = mImpl->requiresSecureDecoder(mime, securityLevel, required);

    if (status != OK) {

        reportMediaDrmErrored(status, __func__);

        reportMediaDrmErrored(status, "requiresSecureDecoderLevel");

    }

    return status;

}
@@ -451,26 +456,29 @@ DrmStatus DrmMetricsLogger::getSupportedSchemes(std::vector<uint8_t>& schemes) c 


void DrmMetricsLogger::reportMediaDrmCreated() const {

    mediametrics_handle_t handle(mediametrics_create("mediadrm.created"));

    mediametrics_setCString(handle, "scheme", mScheme.c_str());

    mediametrics_setInt64(handle, "uuid_msb", be64toh(mUuid[0]));

    mediametrics_setInt64(handle, "uuid_lsb", be64toh(mUuid[1]));

    mediametrics_setInt32(handle, "frontend", mFrontend);

    mediametrics_setCString(handle, "object_nonce", mObjNonce.c_str());

    mediametrics_selfRecord(handle);

    mediametrics_delete(handle);

}



void DrmMetricsLogger::reportMediaDrmSessionOpened(const std::vector<uint8_t>& sessionId) const {

    mediametrics_handle_t handle(mediametrics_create("mediadrm.session_opened"));

    mediametrics_setInt64(handle, "obj_nonce_msb", mObjNonceMsb);

    mediametrics_setInt64(handle, "obj_nonce_lsb", mObjNonceLsb);

    mediametrics_setCString(handle, "scheme", mScheme.c_str());

    mediametrics_setInt64(handle, "uuid_msb", be64toh(mUuid[0]));

    mediametrics_setInt64(handle, "uuid_lsb", be64toh(mUuid[1]));

    mediametrics_setInt32(handle, "frontend", mFrontend);

    mediametrics_setCString(handle, "object_nonce", mObjNonce.c_str());

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

    auto it = mSessionMap.find(sessionId);

    if (it != mSessionMap.end()) {

        mediametrics_setInt64(handle, "session_nonce_msb", it->second.mNonceMsb);

        mediametrics_setInt64(handle, "session_nonce_lsb", it->second.mNonceLsb);

        mediametrics_setInt64(handle, "target_seucrity_level", it->second.mTargetSecurityLevel);

        mediametrics_setInt64(handle, "actual_seucrity_level", it->second.mActualSecurityLevel);

        mediametrics_setCString(handle, "session_nonce", it->second.mNonce.c_str());

        mediametrics_setInt64(handle, "requested_seucrity_level", it->second.mTargetSecurityLevel);

        mediametrics_setInt64(handle, "opened_seucrity_level", it->second.mActualSecurityLevel);

    }

    mediametrics_setInt32(handle, "frontend", mFrontend);

    mediametrics_selfRecord(handle);

    mediametrics_delete(handle);

}
@@ -478,36 +486,74 @@ void DrmMetricsLogger::reportMediaDrmSessionOpened(const std::vector<uint8_t>& s 
void DrmMetricsLogger::reportMediaDrmErrored(const DrmStatus& error_code, const char* api,

                                             const std::vector<uint8_t>& sessionId) const {

    mediametrics_handle_t handle(mediametrics_create("mediadrm.errored"));

    mediametrics_setInt64(handle, "obj_nonce_msb", mObjNonceMsb);

    mediametrics_setInt64(handle, "obj_nonce_lsb", mObjNonceLsb);

    mediametrics_setCString(handle, "scheme", mScheme.c_str());

    mediametrics_setInt64(handle, "uuid_msb", be64toh(mUuid[0]));

    mediametrics_setInt64(handle, "uuid_lsb", be64toh(mUuid[1]));

    mediametrics_setInt32(handle, "frontend", mFrontend);

    mediametrics_setCString(handle, "object_nonce", mObjNonce.c_str());

    if (!sessionId.empty()) {

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

        auto it = mSessionMap.find(sessionId);

        if (it != mSessionMap.end()) {

            mediametrics_setInt64(handle, "session_nonce_msb", it->second.mNonceMsb);

            mediametrics_setInt64(handle, "session_nonce_lsb", it->second.mNonceLsb);

            mediametrics_setCString(handle, "session_nonce", it->second.mNonce.c_str());

            mediametrics_setInt64(handle, "seucrity_level", it->second.mActualSecurityLevel);

        }

    }

    mediametrics_setInt64(handle, "uuid_msb", be64toh(mUuid[0]));

    mediametrics_setInt64(handle, "uuid_lsb", be64toh(mUuid[1]));

    mediametrics_setCString(handle, "api", api);

    mediametrics_setInt32(handle, "error_code", 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());

    mediametrics_setCString(handle, "api", api);

    mediametrics_setInt32(handle, "frontend", mFrontend);

    mediametrics_selfRecord(handle);

    mediametrics_delete(handle);

}



DrmStatus DrmMetricsLogger::checkGetRandom(int64_t* nonce, const char* api) {

    ssize_t bytes = getrandom(nonce, sizeof(int64_t), GRND_NONBLOCK);

    if (bytes < sizeof(int64_t)) {

DrmStatus DrmMetricsLogger::generateNonce(std::string* out, size_t size, const char* api) {

    std::vector<uint8_t> buf(size);

    ssize_t bytes = getrandom(buf.data(), size, GRND_NONBLOCK);

    if (bytes < size) {

        ALOGE("getrandom failed: %d", errno);

        reportMediaDrmErrored(ERROR_DRM_RESOURCE_BUSY, api);

        return ERROR_DRM_RESOURCE_BUSY;

    }

    android::AString tmp;

    encodeBase64(buf.data(), size, &tmp);

    out->assign(tmp.c_str());

    return OK;

}



const std::map<std::array<int64_t, 2>, std::string> DrmMetricsLogger::kUuidSchemeMap {

        {{(int64_t)0x6DD8B3C345F44A68, (int64_t)0xBF3A64168D01A4A6}, "ABV DRM (MoDRM)"},

        {{(int64_t)0xF239E769EFA34850, (int64_t)0x9C16A903C6932EFB},

         "Adobe Primetime DRM version 4"},

        {{(int64_t)0x616C746963617374, (int64_t)0x2D50726F74656374}, "Alticast"},

        {{(int64_t)0x94CE86FB07FF4F43, (int64_t)0xADB893D2FA968CA2}, "Apple FairPlay"},

        {{(int64_t)0x279FE473512C48FE, (int64_t)0xADE8D176FEE6B40F}, "Arris Titanium"},

        {{(int64_t)0x3D5E6D359B9A41E8, (int64_t)0xB843DD3C6E72C42C}, "ChinaDRM"},

        {{(int64_t)0x3EA8778F77424BF9, (int64_t)0xB18BE834B2ACBD47}, "Clear Key AES-128"},

        {{(int64_t)0xBE58615B19C44684, (int64_t)0x88B3C8C57E99E957}, "Clear Key SAMPLE-AES"},

        {{(int64_t)0xE2719D58A985B3C9, (int64_t)0x781AB030AF78D30E}, "Clear Key DASH-IF"},

        {{(int64_t)0x644FE7B5260F4FAD, (int64_t)0x949A0762FFB054B4}, "CMLA (OMA DRM)"},

        {{(int64_t)0x37C332587B994C7E, (int64_t)0xB15D19AF74482154}, "Commscope Titanium V3"},

        {{(int64_t)0x45D481CB8FE049C0, (int64_t)0xADA9AB2D2455B2F2}, "CoreCrypt"},

        {{(int64_t)0xDCF4E3E362F15818, (int64_t)0x7BA60A6FE33FF3DD}, "DigiCAP SmartXess"},

        {{(int64_t)0x35BF197B530E42D7, (int64_t)0x8B651B4BF415070F}, "DivX DRM Series 5"},

        {{(int64_t)0x80A6BE7E14484C37, (int64_t)0x9E70D5AEBE04C8D2}, "Irdeto Content Protection"},

        {{(int64_t)0x5E629AF538DA4063, (int64_t)0x897797FFBD9902D4},

         "Marlin Adaptive Streaming Simple Profile V1.0"},

        {{(int64_t)0x9A04F07998404286, (int64_t)0xAB92E65BE0885F95}, "Microsoft PlayReady"},

        {{(int64_t)0x6A99532D869F5922, (int64_t)0x9A91113AB7B1E2F3}, "MobiTV DRM"},

        {{(int64_t)0xADB41C242DBF4A6D, (int64_t)0x958B4457C0D27B95}, "Nagra MediaAccess PRM 3.0"},

        {{(int64_t)0x1F83E1E86EE94F0D, (int64_t)0xBA2F5EC4E3ED1A66}, "SecureMedia"},

        {{(int64_t)0x992C46E6C4374899, (int64_t)0xB6A050FA91AD0E39}, "SecureMedia SteelKnot"},

        {{(int64_t)0xA68129D3575B4F1A, (int64_t)0x9CBA3223846CF7C3},

         "Synamedia/Cisco/NDS VideoGuard DRM"},

        {{(int64_t)0xAA11967FCC014A4A, (int64_t)0x8E99C5D3DDDFEA2D}, "Unitend DRM (UDRM)"},

        {{(int64_t)0x9A27DD82FDE24725, (int64_t)0x8CBC4234AA06EC09}, "Verimatrix VCAS"},

        {{(int64_t)0xB4413586C58CFFB0, (int64_t)0x94A5D4896C1AF6C3}, "Viaccess-Orca DRM (VODRM)"},

        {{(int64_t)0x793B79569F944946, (int64_t)0xA94223E7EF7E44B4}, "VisionCrypt"},

        {{(int64_t)0x1077EFECC0B24D02, (int64_t)0xACE33C1E52E2FB4B}, "W3C Common PSSH box"},

        {{(int64_t)0xEDEF8BA979D64ACE, (int64_t)0xA3C827DCD51D21ED}, "Widevine Content Protection"},

};



}  // namespace android
 
 No newline at end of file

drm/libmediadrm/include/mediadrm/DrmMetricsLogger.h

+7 −5
Original line number Diff line number Diff line
@@ -26,8 +26,7 @@ 
namespace android {



struct SessionContext {

    int64_t mNonceMsb;

    int64_t mNonceLsb;

    std::string mNonce;

    int64_t mTargetSecurityLevel;

    DrmPlugin::SecurityLevel mActualSecurityLevel;

};
@@ -150,12 +149,15 @@ class DrmMetricsLogger : public IDrm { 
            const DrmStatus& error_code, const char* api,

            const std::vector<uint8_t>& sessionId = std::vector<uint8_t>()) const;



    DrmStatus checkGetRandom(int64_t* nonce, const char* api);

    DrmStatus generateNonce(std::string* out, size_t size, const char* api);



  private:

    static const size_t kNonceSize = 16;

    static const std::map<std::array<int64_t, 2>, std::string> kUuidSchemeMap;

    sp<IDrm> mImpl;

    int64_t mUuid[2] = {};

    int64_t mObjNonceMsb, mObjNonceLsb;

    std::array<int64_t, 2> mUuid;

    std::string mObjNonce;

    std::string mScheme;

    std::map<std::vector<uint8_t>, SessionContext> mSessionMap;

    mutable std::mutex mSessionMapMutex;

    IDrmFrontend mFrontend;