Merge "DrmSessionManager: use ndk resourcemanager" (369b4e0c) · Commits · e / os / android_frameworks_av

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