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

Commit 11a5020f authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 6022569 from 22a082cd to rvc-release 

Change-Id: Ie53fbdfa0784559e0c7757c2aebf2c27244d3d25
parents 706a0fa6 22a082cd

drm/libmediadrm/Android.bp

+6 −3
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ cc_library_shared { 
    srcs: [

        "DrmPluginPath.cpp",

        "DrmSessionManager.cpp",

        "IMediaDrmService.cpp",

        "SharedLibrary.cpp",

        "DrmHal.cpp",

        "CryptoHal.cpp",
@@ -39,14 +38,14 @@ cc_library_shared { 


    shared_libs: [

        "libbinder",

        "libbinder_ndk",

        "libcutils",

        "libdl",

        "liblog",

        "libmedia",

        "libmediadrmmetrics_lite",

        "libmediametrics",

        "libmediametrics#1",

        "libmediautils",

        "libresourcemanagerservice",

        "libstagefright_foundation",

        "libutils",

        "android.hardware.drm@1.0",
@@ -56,6 +55,10 @@ cc_library_shared { 
        "libhidlbase",

    ],



    static_libs: [

        "resourcemanager_aidl_interface-ndk_platform",

    ],



    export_shared_lib_headers: [

        "android.hardware.drm@1.0",

        "android.hardware.drm@1.1",

drm/libmediadrm/DrmHal.cpp

+30 −26
Original line number Diff line number Diff line
@@ -23,11 +23,12 @@ 
#include <binder/IPCThreadState.h>

#include <binder/IServiceManager.h>



#include <aidl/android/media/BnResourceManagerClient.h>

#include <android/hardware/drm/1.2/types.h>

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

#include <android/media/BnResourceManagerClient.h>

#include <hidl/ServiceManagement.h>

#include <media/EventMetric.h>

#include <media/MediaMetrics.h>

#include <media/PluginMetricsReporting.h>

#include <media/drm/DrmAPI.h>

#include <media/stagefright/foundation/ADebug.h>
@@ -298,17 +299,16 @@ static status_t toStatusT_1_2(Status_V1_2 status) { 


Mutex DrmHal::mLock;



struct DrmHal::DrmSessionClient : public android::media::BnResourceManagerClient {

struct DrmHal::DrmSessionClient : public aidl::android::media::BnResourceManagerClient {

    explicit DrmSessionClient(DrmHal* drm, const Vector<uint8_t>& sessionId)

      : mSessionId(sessionId),

        mDrm(drm) {}



    ::android::binder::Status reclaimResource(bool* _aidl_return) override;

    ::android::binder::Status getName(::std::string* _aidl_return) override;

    ::ndk::ScopedAStatus reclaimResource(bool* _aidl_return) override;

    ::ndk::ScopedAStatus getName(::std::string* _aidl_return) override;



    const Vector<uint8_t> mSessionId;



protected:

    virtual ~DrmSessionClient();



private:
@@ -317,24 +317,25 @@ private: 
    DISALLOW_EVIL_CONSTRUCTORS(DrmSessionClient);

};



::android::binder::Status DrmHal::DrmSessionClient::reclaimResource(bool* _aidl_return) {

::ndk::ScopedAStatus DrmHal::DrmSessionClient::reclaimResource(bool* _aidl_return) {

    auto sessionId = mSessionId;

    sp<DrmHal> drm = mDrm.promote();

    if (drm == NULL) {

        *_aidl_return = true;

        return ::android::binder::Status::ok();

        return ::ndk::ScopedAStatus::ok();

    }

    status_t err = drm->closeSession(mSessionId);

    status_t err = drm->closeSession(sessionId);

    if (err != OK) {

        *_aidl_return = false;

        return ::android::binder::Status::ok();

        return ::ndk::ScopedAStatus::ok();

    }

    drm->sendEvent(EventType::SESSION_RECLAIMED,

            toHidlVec(mSessionId), hidl_vec<uint8_t>());

            toHidlVec(sessionId), hidl_vec<uint8_t>());

    *_aidl_return = true;

    return ::android::binder::Status::ok();

    return ::ndk::ScopedAStatus::ok();

}



::android::binder::Status DrmHal::DrmSessionClient::getName(::std::string* _aidl_return) {

::ndk::ScopedAStatus DrmHal::DrmSessionClient::getName(::std::string* _aidl_return) {

    String8 name;

    sp<DrmHal> drm = mDrm.promote();

    if (drm == NULL) {
@@ -349,7 +350,7 @@ private: 
    }

    name.append("]");

    *_aidl_return = name;

    return ::android::binder::Status::ok();

    return ::ndk::ScopedAStatus::ok();

}



DrmHal::DrmSessionClient::~DrmSessionClient() {
@@ -453,6 +454,7 @@ sp<IDrmPlugin> DrmHal::makeDrmPlugin(const sp<IDrmFactory>& factory, 
        const uint8_t uuid[16], const String8& appPackageName) {

    mAppPackageName = appPackageName;

    mMetrics.SetAppPackageName(appPackageName);

    mMetrics.SetAppUid(IPCThreadState::self()->getCallingUid());



    sp<IDrmPlugin> plugin;

    Return<void> hResult = factory->createPlugin(uuid, appPackageName.string(),
@@ -757,9 +759,10 @@ status_t DrmHal::openSession(DrmPlugin::SecurityLevel level, 
    } while (retry);



    if (err == OK) {

        sp<DrmSessionClient> client(new DrmSessionClient(this, sessionId));

        DrmSessionManager::Instance()->addSession(getCallingPid(), client, sessionId);

        mOpenSessions.push(client);

        std::shared_ptr<DrmSessionClient> client(new DrmSessionClient(this, sessionId));

        DrmSessionManager::Instance()->addSession(getCallingPid(),

                std::static_pointer_cast<IResourceManagerClient>(client), sessionId);

        mOpenSessions.push_back(client);

        mMetrics.SetSessionStart(sessionId);

    }
@@ -775,9 +778,9 @@ status_t DrmHal::closeSession(Vector<uint8_t> const &sessionId) { 
    if (status.isOk()) {

        if (status == Status::OK) {

            DrmSessionManager::Instance()->removeSession(sessionId);

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

                if (isEqualSessionId(mOpenSessions[i]->mSessionId, sessionId)) {

                    mOpenSessions.removeAt(i);

            for (auto i = mOpenSessions.begin(); i != mOpenSessions.end(); i++) {

                if (isEqualSessionId((*i)->mSessionId, sessionId)) {

                    mOpenSessions.erase(i);

                    break;

                }

            }
@@ -1563,21 +1566,21 @@ status_t DrmHal::signRSA(Vector<uint8_t> const &sessionId, 


void DrmHal::reportFrameworkMetrics() const

{

    std::unique_ptr<MediaAnalyticsItem> item(MediaAnalyticsItem::create("mediadrm"));

    item->setPkgName(mMetrics.GetAppPackageName().c_str());

    mediametrics_handle_t item(mediametrics_create("mediadrm"));

    mediametrics_setUid(item, mMetrics.GetAppUid());

    String8 vendor;

    String8 description;

    status_t result = getPropertyStringInternal(String8("vendor"), vendor);

    if (result != OK) {

        ALOGE("Failed to get vendor from drm plugin: %d", result);

    } else {

        item->setCString("vendor", vendor.c_str());

        mediametrics_setCString(item, "vendor", vendor.c_str());

    }

    result = getPropertyStringInternal(String8("description"), description);

    if (result != OK) {

        ALOGE("Failed to get description from drm plugin: %d", result);

    } else {

        item->setCString("description", description.c_str());

        mediametrics_setCString(item, "description", description.c_str());

    }



    std::string serializedMetrics;
@@ -1588,11 +1591,12 @@ void DrmHal::reportFrameworkMetrics() const 
    std::string b64EncodedMetrics = toBase64StringNoPad(serializedMetrics.data(),

                                                        serializedMetrics.size());

    if (!b64EncodedMetrics.empty()) {

        item->setCString("serialized_metrics", b64EncodedMetrics.c_str());

        mediametrics_setCString(item, "serialized_metrics", b64EncodedMetrics.c_str());

    }

    if (!item->selfrecord()) {

    if (!mediametrics_selfRecord(item)) {

        ALOGE("Failed to self record framework metrics");

    }

    mediametrics_delete(item);

}



void DrmHal::reportPluginMetrics() const
@@ -1606,7 +1610,7 @@ void DrmHal::reportPluginMetrics() const 
        std::string metricsString = toBase64StringNoPad(metricsVector.array(),

                                                        metricsVector.size());

        status_t res = android::reportDrmPluginMetrics(metricsString, vendor,

                                                       description, mAppPackageName);

                                                       description, mMetrics.GetAppUid());

        if (res != OK) {

            ALOGE("Metrics were retrieved but could not be reported: %d", res);

        }

drm/libmediadrm/DrmSessionManager.cpp

+43 −41
Original line number Diff line number Diff line
@@ -18,13 +18,12 @@ 
#define LOG_TAG "DrmSessionManager"

#include <utils/Log.h>



#include <android/media/IResourceManagerClient.h>

#include <android/media/IResourceManagerService.h>

#include <binder/IPCThreadState.h>

#include <binder/IProcessInfoService.h>

#include <binder/IServiceManager.h>

#include <aidl/android/media/IResourceManagerClient.h>

#include <aidl/android/media/IResourceManagerService.h>

#include <aidl/android/media/MediaResourceParcel.h>

#include <android/binder_ibinder.h>

#include <android/binder_manager.h>

#include <cutils/properties.h>

#include <media/MediaResource.h>

#include <mediadrm/DrmUtils.h>

#include <mediadrm/DrmSessionManager.h>

#include <unistd.h>
@@ -32,10 +31,18 @@ 


#include <vector>



#include "ResourceManagerService.h"



namespace android {

using android::binder::Status;



using aidl::android::media::MediaResourceParcel;



namespace {

void ResourceManagerServiceDied(void* cookie) {

    auto thiz = static_cast<DrmSessionManager*>(cookie);

    thiz->binderDied();

}

}



using ::ndk::ScopedAStatus;



static String8 GetSessionIdString(const Vector<uint8_t> &sessionId) {

    String8 sessionIdStr;
@@ -45,34 +52,28 @@ static String8 GetSessionIdString(const Vector<uint8_t> &sessionId) { 
    return sessionIdStr;

}



static std::vector<uint8_t> toStdVec(const Vector<uint8_t> &vector) {

    const uint8_t *v = vector.array();

    std::vector<uint8_t> vec(v, v + vector.size());

template <typename Byte = uint8_t>

static std::vector<Byte> toStdVec(const Vector<uint8_t> &vector) {

    auto v = reinterpret_cast<const Byte *>(vector.array());

    std::vector<Byte> vec(v, v + vector.size());

    return vec;

}



static uint64_t toClientId(const sp<IResourceManagerClient>& drm) {

    return reinterpret_cast<int64_t>(drm.get());

}



static std::vector<MediaResourceParcel> toResourceVec(

        const Vector<uint8_t> &sessionId, int64_t value) {

    using Type = aidl::android::media::MediaResourceType;

    using SubType = aidl::android::media::MediaResourceSubType;

    std::vector<MediaResourceParcel> resources;

    resources.push_back(MediaResource::DrmSessionResource(toStdVec(sessionId), value));

    MediaResourceParcel resource{

            Type::kDrmSession, SubType::kUnspecifiedSubType,

            toStdVec<int8_t>(sessionId), value};

    resources.push_back(resource);

    return resources;

}



static sp<IResourceManagerService> getResourceManagerService() {

    if (DrmUtils::UseDrmService()) {

        // Create ResourceManagerService object in mediadrmserver process

        return new android::media::ResourceManagerService();

    }

    sp<IServiceManager> sm = defaultServiceManager();

    if (sm == NULL) {

        return NULL;

    }

    sp<IBinder> binder = sm->getService(String16("media.resource_manager"));

    return interface_cast<IResourceManagerService>(binder);

static std::shared_ptr<IResourceManagerService> getResourceManagerService() {

    ::ndk::SpAIBinder binder(AServiceManager_getService("media.resource_manager"));

    return IResourceManagerService::fromBinder(binder);

}



bool isEqualSessionId(const Vector<uint8_t> &sessionId1, const Vector<uint8_t> &sessionId2) {
@@ -88,7 +89,7 @@ bool isEqualSessionId(const Vector<uint8_t> &sessionId1, const Vector<uint8_t> & 
}



sp<DrmSessionManager> DrmSessionManager::Instance() {

    static sp<DrmSessionManager> drmSessionManager = new DrmSessionManager();

    auto drmSessionManager = new DrmSessionManager();

    drmSessionManager->init();

    return drmSessionManager;

}
@@ -97,9 +98,10 @@ DrmSessionManager::DrmSessionManager() 
    : DrmSessionManager(getResourceManagerService()) {

}



DrmSessionManager::DrmSessionManager(const sp<IResourceManagerService> &service)

DrmSessionManager::DrmSessionManager(const std::shared_ptr<IResourceManagerService> &service)

    : mService(service),

      mInitialized(false) {

      mInitialized(false),

      mDeathRecipient(AIBinder_DeathRecipient_new(ResourceManagerServiceDied)) {

    if (mService == NULL) {

        ALOGE("Failed to init ResourceManagerService");

    }
@@ -107,7 +109,7 @@ DrmSessionManager::DrmSessionManager(const sp<IResourceManagerService> &service) 


DrmSessionManager::~DrmSessionManager() {

    if (mService != NULL) {

        IInterface::asBinder(mService)->unlinkToDeath(this);

        AIBinder_unlinkToDeath(mService->asBinder().get(), mDeathRecipient.get(), this);

    }

}
@@ -118,13 +120,13 @@ void DrmSessionManager::init() { 
    }

    mInitialized = true;

    if (mService != NULL) {

        IInterface::asBinder(mService)->linkToDeath(this);

        AIBinder_linkToDeath(mService->asBinder().get(), mDeathRecipient.get(), this);

    }

}



void DrmSessionManager::addSession(int pid,

        const sp<IResourceManagerClient>& drm, const Vector<uint8_t> &sessionId) {

    uid_t uid = IPCThreadState::self()->getCallingUid();

        const std::shared_ptr<IResourceManagerClient>& drm, const Vector<uint8_t> &sessionId) {

    uid_t uid = AIBinder_getCallingUid();

    ALOGV("addSession(pid %d, uid %d, drm %p, sessionId %s)", pid, uid, drm.get(),

            GetSessionIdString(sessionId).string());
@@ -133,9 +135,9 @@ void DrmSessionManager::addSession(int pid, 
        return;

    }



    int64_t clientId = toClientId(drm);

    static int64_t clientId = 0;

    mSessionMap[toStdVec(sessionId)] = (SessionInfo){pid, uid, clientId};

    mService->addResource(pid, uid, clientId, drm, toResourceVec(sessionId, INT64_MAX));

    mService->addResource(pid, uid, clientId++, drm, toResourceVec(sessionId, INT64_MAX));

}



void DrmSessionManager::useSession(const Vector<uint8_t> &sessionId) {
@@ -170,7 +172,7 @@ bool DrmSessionManager::reclaimSession(int callingPid) { 


    // unlock early because reclaimResource might callback into removeSession

    mLock.lock();

    sp<IResourceManagerService> service(mService);

    std::shared_ptr<IResourceManagerService> service(mService);

    mLock.unlock();



    if (service == NULL) {
@@ -181,7 +183,7 @@ bool DrmSessionManager::reclaimSession(int callingPid) { 
    // we rely on IResourceManagerClient to removeSession in reclaimResource

    Vector<uint8_t> dummy;

    bool success;

    Status status = service->reclaimResource(callingPid, toResourceVec(dummy, INT64_MAX), &success);

    ScopedAStatus status = service->reclaimResource(callingPid, toResourceVec(dummy, INT64_MAX), &success);

    return status.isOk() && success;

}
@@ -195,10 +197,10 @@ bool DrmSessionManager::containsSession(const Vector<uint8_t>& sessionId) const 
    return mSessionMap.count(toStdVec(sessionId));

}



void DrmSessionManager::binderDied(const wp<IBinder>& /*who*/) {

void DrmSessionManager::binderDied() {

    ALOGW("ResourceManagerService died.");

    Mutex::Autolock lock(mLock);

    mService.clear();

    mService.reset();

}



}  // namespace android

drm/libmediadrm/IMediaDrmService.cpp

deleted100644 → 0
+0 −57
Original line number Diff line number Diff line 
/*

**

** Copyright 2015, The Android Open Source Project

**

** Licensed under the Apache License, Version 2.0 (the "License");

** you may not use this file except in compliance with the License.

** You may obtain a copy of the License at

**

**     http://www.apache.org/licenses/LICENSE-2.0

**

** Unless required by applicable law or agreed to in writing, software

** distributed under the License is distributed on an "AS IS" BASIS,

** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

** See the License for the specific language governing permissions and

** limitations under the License.

*/



#include <stdint.h>

#include <sys/types.h>



#include <binder/Parcel.h>

#include <binder/IMemory.h>

#include <mediadrm/ICrypto.h>

#include <mediadrm/IDrm.h>

#include <mediadrm/IMediaDrmService.h>



#include <utils/Errors.h>  // for status_t

#include <utils/String8.h>



namespace android {



class BpMediaDrmService: public BpInterface<IMediaDrmService>

{

public:

    explicit BpMediaDrmService(const sp<IBinder>& impl)

        : BpInterface<IMediaDrmService>(impl)

    {

    }



};



IMPLEMENT_META_INTERFACE(MediaDrmService, "android.media.IMediaDrmService");



// ----------------------------------------------------------------------



status_t BnMediaDrmService::onTransact(

    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    switch (code) {

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

}



// ----------------------------------------------------------------------------



} // namespace android

drm/libmediadrm/PluginMetricsReporting.cpp

+9 −9
Original line number Diff line number Diff line
@@ -21,7 +21,7 @@ 


#include <inttypes.h>



#include <media/MediaAnalyticsItem.h>

#include <media/MediaMetrics.h>

#include <utils/Log.h>
@@ -33,18 +33,18 @@ constexpr char kSerializedMetricsField[] = "serialized_metrics"; 


status_t reportVendorMetrics(const std::string& metrics,

                             const String8& name,

                             const String8& appPackageName) {

    std::unique_ptr<MediaAnalyticsItem> analyticsItem(MediaAnalyticsItem::create(name.c_str()));

    std::string app_package_name(appPackageName.c_str(), appPackageName.size());

    analyticsItem->setPkgName(app_package_name);

                             uid_t appUid) {

    mediametrics_handle_t analyticsItem(mediametrics_create(name.c_str()));

    mediametrics_setUid(analyticsItem, appUid);

    if (metrics.size() > 0) {

        analyticsItem->setCString(kSerializedMetricsField, metrics.c_str());

        mediametrics_setCString(analyticsItem, kSerializedMetricsField, metrics.c_str());

    }



    if (!analyticsItem->selfrecord()) {

    if (!mediametrics_selfRecord(analyticsItem)) {

      ALOGE("%s: selfrecord() returned false", __func__);

    }



    mediametrics_delete(analyticsItem);

    return OK;

}
@@ -67,13 +67,13 @@ String8 sanitize(const String8& input) { 
status_t reportDrmPluginMetrics(const std::string& b64EncodedMetrics,

                                const String8& vendor,

                                const String8& description,

                                const String8& appPackageName) {

                                uid_t appUid) {



    String8 name = String8::format("drm.vendor.%s.%s",

                                   sanitize(vendor).c_str(),

                                   sanitize(description).c_str());



    return reportVendorMetrics(b64EncodedMetrics, name, appPackageName);

    return reportVendorMetrics(b64EncodedMetrics, name, appUid);

}



}  // namespace android