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: [
"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",

39
drm/libmediadrm/DrmHal.cpp
Unescape View File

@ -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;
}
}

84
drm/libmediadrm/DrmSessionManager.cpp
Unescape View File

@ -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

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

@ -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();

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

@ -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);
};

Write Preview
Loading…
Cancel
Save