gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "DrmSessionManager: use ndk resourcemanager"

Browse Source
gugelfrei
Robert Shih 5 years ago committed by Android (Google) Code Review
parent 68db3a07ae 0f3a8a0d98
commit 369b4e0cd1
5 changed files with 83 additions and 74 deletions
Show Stats Download Patch File Download Diff File

6
drm/libmediadrm/Android.bp
Unescape View File

@ -39,6 +39,7 @@ cc_library_shared {
shared_libs: [ shared_libs: [
"libbinder", "libbinder",
"libbinder_ndk",
"libcutils", "libcutils",
"libdl", "libdl",
"liblog", "liblog",
@ -46,7 +47,6 @@ cc_library_shared {
"libmediadrmmetrics_lite", "libmediadrmmetrics_lite",
"libmediametrics", "libmediametrics",
"libmediautils", "libmediautils",
"libresourcemanagerservice",
"libstagefright_foundation", "libstagefright_foundation",
"libutils", "libutils",
"android.hardware.drm@1.0", "android.hardware.drm@1.0",
@ -56,6 +56,10 @@ cc_library_shared {
"libhidlbase", "libhidlbase",
], ],
static_libs: [
"resourcemanager_aidl_interface-ndk_platform",
],
export_shared_lib_headers: [ export_shared_lib_headers: [
"android.hardware.drm@1.0", "android.hardware.drm@1.0",
"android.hardware.drm@1.1", "android.hardware.drm@1.1",

39
drm/libmediadrm/DrmHal.cpp
Unescape View File

@ -23,9 +23,9 @@
#include <binder/IPCThreadState.h> #include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h> #include <binder/IServiceManager.h>
#include <aidl/android/media/BnResourceManagerClient.h>
#include <android/hardware/drm/1.2/types.h> #include <android/hardware/drm/1.2/types.h>
#include <android/hidl/manager/1.2/IServiceManager.h> #include <android/hidl/manager/1.2/IServiceManager.h>
#include <android/media/BnResourceManagerClient.h>
#include <hidl/ServiceManagement.h> #include <hidl/ServiceManagement.h>
#include <media/EventMetric.h> #include <media/EventMetric.h>
#include <media/PluginMetricsReporting.h> #include <media/PluginMetricsReporting.h>
@ -298,17 +298,16 @@ static status_t toStatusT_1_2(Status_V1_2 status) {
Mutex DrmHal::mLock; 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) explicit DrmSessionClient(DrmHal* drm, const Vector<uint8_t>& sessionId)
: mSessionId(sessionId), : mSessionId(sessionId),
mDrm(drm) {} mDrm(drm) {}
::android::binder::Status reclaimResource(bool* _aidl_return) override; ::ndk::ScopedAStatus reclaimResource(bool* _aidl_return) override;
::android::binder::Status getName(::std::string* _aidl_return) override; ::ndk::ScopedAStatus getName(::std::string* _aidl_return) override;
const Vector<uint8_t> mSessionId; const Vector<uint8_t> mSessionId;
protected:
virtual ~DrmSessionClient(); virtual ~DrmSessionClient();
private: private:
@ -317,24 +316,25 @@ private:
DISALLOW_EVIL_CONSTRUCTORS(DrmSessionClient); 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(); sp<DrmHal> drm = mDrm.promote();
if (drm == NULL) { if (drm == NULL) {
*_aidl_return = true; *_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) { if (err != OK) {
*_aidl_return = false; *_aidl_return = false;
return ::android::binder::Status::ok(); return ::ndk::ScopedAStatus::ok();
} }
drm->sendEvent(EventType::SESSION_RECLAIMED, drm->sendEvent(EventType::SESSION_RECLAIMED,
toHidlVec(mSessionId), hidl_vec<uint8_t>()); toHidlVec(sessionId), hidl_vec<uint8_t>());
*_aidl_return = true; *_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; String8 name;
sp<DrmHal> drm = mDrm.promote(); sp<DrmHal> drm = mDrm.promote();
if (drm == NULL) { if (drm == NULL) {
@ -349,7 +349,7 @@ private:
} }
name.append("]"); name.append("]");
*_aidl_return = name; *_aidl_return = name;
return ::android::binder::Status::ok(); return ::ndk::ScopedAStatus::ok();
} }
DrmHal::DrmSessionClient::~DrmSessionClient() { DrmHal::DrmSessionClient::~DrmSessionClient() {
@ -757,9 +757,10 @@ status_t DrmHal::openSession(DrmPlugin::SecurityLevel level,
} while (retry); } while (retry);
if (err == OK) { if (err == OK) {
sp<DrmSessionClient> client(new DrmSessionClient(this, sessionId)); std::shared_ptr<DrmSessionClient> client(new DrmSessionClient(this, sessionId));
DrmSessionManager::Instance()->addSession(getCallingPid(), client, sessionId); DrmSessionManager::Instance()->addSession(getCallingPid(),
mOpenSessions.push(client); std::static_pointer_cast<IResourceManagerClient>(client), sessionId);
mOpenSessions.push_back(client);
mMetrics.SetSessionStart(sessionId); mMetrics.SetSessionStart(sessionId);
} }
@ -775,9 +776,9 @@ status_t DrmHal::closeSession(Vector<uint8_t> const &sessionId) {
if (status.isOk()) { if (status.isOk()) {
if (status == Status::OK) { if (status == Status::OK) {
DrmSessionManager::Instance()->removeSession(sessionId); DrmSessionManager::Instance()->removeSession(sessionId);
for (size_t i = 0; i < mOpenSessions.size(); i++) { for (auto i = mOpenSessions.begin(); i != mOpenSessions.end(); i++) {
if (isEqualSessionId(mOpenSessions[i]->mSessionId, sessionId)) { if (isEqualSessionId((*i)->mSessionId, sessionId)) {
mOpenSessions.removeAt(i); mOpenSessions.erase(i);
break; break;
} }
} }

84
drm/libmediadrm/DrmSessionManager.cpp
Unescape View File

@ -18,13 +18,12 @@
#define LOG_TAG "DrmSessionManager" #define LOG_TAG "DrmSessionManager"
#include <utils/Log.h> #include <utils/Log.h>
#include <android/media/IResourceManagerClient.h> #include <aidl/android/media/IResourceManagerClient.h>
#include <android/media/IResourceManagerService.h> #include <aidl/android/media/IResourceManagerService.h>
#include <binder/IPCThreadState.h> #include <aidl/android/media/MediaResourceParcel.h>
#include <binder/IProcessInfoService.h> #include <android/binder_ibinder.h>
#include <binder/IServiceManager.h> #include <android/binder_manager.h>
#include <cutils/properties.h> #include <cutils/properties.h>
#include <media/MediaResource.h>
#include <mediadrm/DrmUtils.h> #include <mediadrm/DrmUtils.h>
#include <mediadrm/DrmSessionManager.h> #include <mediadrm/DrmSessionManager.h>
#include <unistd.h> #include <unistd.h>
@ -32,10 +31,18 @@
#include <vector> #include <vector>
#include "ResourceManagerService.h"
namespace android { 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) { static String8 GetSessionIdString(const Vector<uint8_t> &sessionId) {
String8 sessionIdStr; String8 sessionIdStr;
@ -45,34 +52,28 @@ static String8 GetSessionIdString(const Vector<uint8_t> &sessionId) {
return sessionIdStr; return sessionIdStr;
} }
static std::vector<uint8_t> toStdVec(const Vector<uint8_t> &vector) { template <typename Byte = uint8_t>
const uint8_t *v = vector.array(); static std::vector<Byte> toStdVec(const Vector<uint8_t> &vector) {
std::vector<uint8_t> vec(v, v + vector.size()); auto v = reinterpret_cast<const Byte *>(vector.array());
std::vector<Byte> vec(v, v + vector.size());
return vec; return vec;
} }
static uint64_t toClientId(const sp<IResourceManagerClient>& drm) {
return reinterpret_cast<int64_t>(drm.get());
}
static std::vector<MediaResourceParcel> toResourceVec( static std::vector<MediaResourceParcel> toResourceVec(
const Vector<uint8_t> &sessionId, int64_t value) { const Vector<uint8_t> &sessionId, int64_t value) {
using Type = aidl::android::media::MediaResourceType;
using SubType = aidl::android::media::MediaResourceSubType;
std::vector<MediaResourceParcel> resources; 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; return resources;
} }
static sp<IResourceManagerService> getResourceManagerService() { static std::shared_ptr<IResourceManagerService> getResourceManagerService() {
if (DrmUtils::UseDrmService()) { ::ndk::SpAIBinder binder(AServiceManager_getService("media.resource_manager"));
// Create ResourceManagerService object in mediadrmserver process return IResourceManagerService::fromBinder(binder);
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);
} }
bool isEqualSessionId(const Vector<uint8_t> &sessionId1, const Vector<uint8_t> &sessionId2) { 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() { sp<DrmSessionManager> DrmSessionManager::Instance() {
static sp<DrmSessionManager> drmSessionManager = new DrmSessionManager(); auto drmSessionManager = new DrmSessionManager();
drmSessionManager->init(); drmSessionManager->init();
return drmSessionManager; return drmSessionManager;
} }
@ -97,9 +98,10 @@ DrmSessionManager::DrmSessionManager()
: DrmSessionManager(getResourceManagerService()) { : DrmSessionManager(getResourceManagerService()) {
} }
DrmSessionManager::DrmSessionManager(const sp<IResourceManagerService> &service) DrmSessionManager::DrmSessionManager(const std::shared_ptr<IResourceManagerService> &service)
: mService(service), : mService(service),
mInitialized(false) { mInitialized(false),
mDeathRecipient(AIBinder_DeathRecipient_new(ResourceManagerServiceDied)) {
if (mService == NULL) { if (mService == NULL) {
ALOGE("Failed to init ResourceManagerService"); ALOGE("Failed to init ResourceManagerService");
} }
@ -107,7 +109,7 @@ DrmSessionManager::DrmSessionManager(const sp<IResourceManagerService> &service)
DrmSessionManager::~DrmSessionManager() { DrmSessionManager::~DrmSessionManager() {
if (mService != NULL) { 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; mInitialized = true;
if (mService != NULL) { if (mService != NULL) {
IInterface::asBinder(mService)->linkToDeath(this); AIBinder_linkToDeath(mService->asBinder().get(), mDeathRecipient.get(), this);
} }
} }
void DrmSessionManager::addSession(int pid, void DrmSessionManager::addSession(int pid,
const sp<IResourceManagerClient>& drm, const Vector<uint8_t> &sessionId) { const std::shared_ptr<IResourceManagerClient>& drm, const Vector<uint8_t> &sessionId) {
uid_t uid = IPCThreadState::self()->getCallingUid(); uid_t uid = AIBinder_getCallingUid();
ALOGV("addSession(pid %d, uid %d, drm %p, sessionId %s)", pid, uid, drm.get(), ALOGV("addSession(pid %d, uid %d, drm %p, sessionId %s)", pid, uid, drm.get(),
GetSessionIdString(sessionId).string()); GetSessionIdString(sessionId).string());
@ -133,9 +135,9 @@ void DrmSessionManager::addSession(int pid,
return; return;
} }
int64_t clientId = toClientId(drm); static int64_t clientId = 0;
mSessionMap[toStdVec(sessionId)] = (SessionInfo){pid, uid, clientId}; 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) { 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 // unlock early because reclaimResource might callback into removeSession
mLock.lock(); mLock.lock();
sp<IResourceManagerService> service(mService); std::shared_ptr<IResourceManagerService> service(mService);
mLock.unlock(); mLock.unlock();
if (service == NULL) { if (service == NULL) {
@ -181,7 +183,7 @@ bool DrmSessionManager::reclaimSession(int callingPid) {
// we rely on IResourceManagerClient to removeSession in reclaimResource // we rely on IResourceManagerClient to removeSession in reclaimResource
Vector<uint8_t> dummy; Vector<uint8_t> dummy;
bool success; 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; return status.isOk() && success;
} }
@ -195,10 +197,10 @@ bool DrmSessionManager::containsSession(const Vector<uint8_t>& sessionId) const
return mSessionMap.count(toStdVec(sessionId)); return mSessionMap.count(toStdVec(sessionId));
} }
void DrmSessionManager::binderDied(const wp<IBinder>& /*who*/) { void DrmSessionManager::binderDied() {
ALOGW("ResourceManagerService died."); ALOGW("ResourceManagerService died.");
Mutex::Autolock lock(mLock); Mutex::Autolock lock(mLock);
mService.clear(); mService.reset();
} }
} // namespace android } // namespace android

2
drm/libmediadrm/include/mediadrm/DrmHal.h
Unescape View File

@ -207,7 +207,7 @@ private:
// Mutable to allow modification within GetPropertyByteArray. // Mutable to allow modification within GetPropertyByteArray.
mutable MediaDrmMetrics mMetrics; mutable MediaDrmMetrics mMetrics;
Vector<sp<DrmSessionClient>> mOpenSessions; std::vector<std::shared_ptr<DrmSessionClient>> mOpenSessions;
void closeOpenSessions(); void closeOpenSessions();
void cleanup(); void cleanup();

26
drm/libmediadrm/include/mediadrm/DrmSessionManager.h
Unescape View File

@ -18,7 +18,9 @@
#define DRM_SESSION_MANAGER_H_ #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 <media/stagefright/foundation/ABase.h>
#include <utils/RefBase.h> #include <utils/RefBase.h>
#include <utils/KeyedVector.h> #include <utils/KeyedVector.h>
@ -26,6 +28,7 @@
#include <utils/Vector.h> #include <utils/Vector.h>
#include <map> #include <map>
#include <memory>
#include <utility> #include <utility>
#include <vector> #include <vector>
@ -33,12 +36,8 @@ namespace android {
class DrmSessionManagerTest; class DrmSessionManagerTest;
namespace media { using aidl::android::media::IResourceManagerClient;
class IResourceManagerClient; using aidl::android::media::IResourceManagerService;
class IResourceManagerService;
}
using android::media::IResourceManagerClient;
using android::media::IResourceManagerService;
bool isEqualSessionId(const Vector<uint8_t> &sessionId1, const Vector<uint8_t> &sessionId2); 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; typedef std::map<std::vector<uint8_t>, SessionInfo> SessionInfoMap;
struct DrmSessionManager : public IBinder::DeathRecipient { struct DrmSessionManager : public RefBase {
static sp<DrmSessionManager> Instance(); static sp<DrmSessionManager> Instance();
DrmSessionManager(); 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 useSession(const Vector<uint8_t>& sessionId);
void removeSession(const Vector<uint8_t>& sessionId); void removeSession(const Vector<uint8_t>& sessionId);
bool reclaimSession(int callingPid); bool reclaimSession(int callingPid);
@ -66,7 +67,7 @@ struct DrmSessionManager : public IBinder::DeathRecipient {
bool containsSession(const Vector<uint8_t>& sessionId) const; bool containsSession(const Vector<uint8_t>& sessionId) const;
// implements DeathRecipient // implements DeathRecipient
virtual void binderDied(const wp<IBinder>& /*who*/); void binderDied();
protected: protected:
virtual ~DrmSessionManager(); virtual ~DrmSessionManager();
@ -74,10 +75,11 @@ protected:
private: private:
void init(); void init();
sp<IResourceManagerService> mService; std::shared_ptr<IResourceManagerService> mService;
mutable Mutex mLock; mutable Mutex mLock;
SessionInfoMap mSessionMap; SessionInfoMap mSessionMap;
bool mInitialized; bool mInitialized;
::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
DISALLOW_EVIL_CONSTRUCTORS(DrmSessionManager); DISALLOW_EVIL_CONSTRUCTORS(DrmSessionManager);
}; };

Write Preview
Loading…
Cancel
Save