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

Commit 0f3a8a0d authored by Robert Shih's avatar Robert Shih
Browse files

DrmSessionManager: use ndk resourcemanager 

Bug: 134787536
Bug: 144588885
Test: DrmSessionManagerTest
Test: DrmSessionManager_test
Test: MediaDrmClearkeyTest.testGetNumberOfSessions
Test: WidevineGenericOpsTests.testL1
Change-Id: I2d0bf13d41b32fb5f17e097c0097c1c596c7ab2f
parent bb4a40fb

drm/libmediadrm/Android.bp

+5 −1
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ cc_library_shared { 


    shared_libs: [

        "libbinder",

        "libbinder_ndk",

        "libcutils",

        "libdl",

        "liblog",
@@ -46,7 +47,6 @@ cc_library_shared { 
        "libmediadrmmetrics_lite",

        "libmediametrics",

        "libmediautils",

        "libresourcemanagerservice",

        "libstagefright_foundation",

        "libutils",

        "android.hardware.drm@1.0",
@@ -56,6 +56,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

+20 −19
Original line number Diff line number Diff line
@@ -23,9 +23,9 @@ 
#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/PluginMetricsReporting.h>
@@ -298,17 +298,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 +316,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 +349,7 @@ private: 
    }

    name.append("]");

    *_aidl_return = name;

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

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

}



DrmHal::DrmSessionClient::~DrmSessionClient() {
@@ -757,9 +757,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 +776,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;

                }

            }

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/include/mediadrm/DrmHal.h

+1 −1
Original line number Diff line number Diff line
@@ -207,7 +207,7 @@ private: 
    // Mutable to allow modification within GetPropertyByteArray.

    mutable MediaDrmMetrics mMetrics;



    Vector<sp<DrmSessionClient>> mOpenSessions;

    std::vector<std::shared_ptr<DrmSessionClient>> mOpenSessions;

    void closeOpenSessions();

    void cleanup();

drm/libmediadrm/include/mediadrm/DrmSessionManager.h

+14 −12
Original line number Diff line number Diff line
@@ -18,7 +18,9 @@ 


#define DRM_SESSION_MANAGER_H_



#include <binder/IBinder.h>

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

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

#include <android/binder_auto_utils.h>

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

#include <utils/RefBase.h>

#include <utils/KeyedVector.h>
@@ -26,6 +28,7 @@ 
#include <utils/Vector.h>



#include <map>

#include <memory>

#include <utility>

#include <vector>
@@ -33,12 +36,8 @@ namespace android { 


class DrmSessionManagerTest;



namespace media {

class IResourceManagerClient;

class IResourceManagerService;

}

using android::media::IResourceManagerClient;

using android::media::IResourceManagerService;

using aidl::android::media::IResourceManagerClient;

using aidl::android::media::IResourceManagerService;



bool isEqualSessionId(const Vector<uint8_t> &sessionId1, const Vector<uint8_t> &sessionId2);
@@ -50,13 +49,15 @@ struct SessionInfo { 


typedef std::map<std::vector<uint8_t>, SessionInfo> SessionInfoMap;



struct DrmSessionManager : public IBinder::DeathRecipient {

struct DrmSessionManager : public RefBase {

    static sp<DrmSessionManager> Instance();



    DrmSessionManager();

    explicit DrmSessionManager(const sp<IResourceManagerService> &service);

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



    void addSession(int pid, const sp<IResourceManagerClient>& drm, const Vector<uint8_t>& sessionId);

    void addSession(int pid,

            const std::shared_ptr<IResourceManagerClient>& drm,

            const Vector<uint8_t>& sessionId);

    void useSession(const Vector<uint8_t>& sessionId);

    void removeSession(const Vector<uint8_t>& sessionId);

    bool reclaimSession(int callingPid);
@@ -66,7 +67,7 @@ struct DrmSessionManager : public IBinder::DeathRecipient { 
    bool containsSession(const Vector<uint8_t>& sessionId) const;



    // implements DeathRecipient

    virtual void binderDied(const wp<IBinder>& /*who*/);

    void binderDied();



protected:

    virtual ~DrmSessionManager();
@@ -74,10 +75,11 @@ protected: 
private:

    void init();



    sp<IResourceManagerService> mService;

    std::shared_ptr<IResourceManagerService> mService;

    mutable Mutex mLock;

    SessionInfoMap mSessionMap;

    bool mInitialized;

    ::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;



    DISALLOW_EVIL_CONSTRUCTORS(DrmSessionManager);

};