Merge "Update of DRM Framework." (14db41b8) · Commits · e / os / android_frameworks_av

drm/common/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@ include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		DrmConstraints.cpp \
		DrmMetadata.cpp \
		DrmConvertedStatus.cpp \
		DrmEngineBase.cpp \
		DrmInfo.cpp \

drm/common/DrmEngineBase.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,10 @@ DrmConstraints* DrmEngineBase::getConstraints(
		return onGetConstraints(uniqueId, path, action);
		}

		DrmMetadata* DrmEngineBase::getMetadata(int uniqueId, const String8* path) {
		return onGetMetadata(uniqueId, path);
		}

		status_t DrmEngineBase::initialize(int uniqueId) {
		return onInitialize(uniqueId);
		}

drm/common/DrmMetadata.cpp

0 → 100644

+117 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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 <drm/DrmMetadata.h>

		using namespace android;

		int DrmMetadata::getCount(void) const {
		return mMetadataMap.size();
		}

		status_t DrmMetadata::put(const String8* key,
		const char* value) {
		if((value != NULL) && (key != NULL)) {
		int length = strlen(value);
		char* charValue = new char[length + 1];

		memcpy(charValue, value, length);
		charValue[length] = '\0';
		mMetadataMap.add(*key, charValue);
		}
		return NO_ERROR;
		}

		String8 DrmMetadata::get(const String8& key) const {
		if (NULL != getValue(&key)) {
		return String8(getValue(&key));
		}
		else {
		return String8("");
		}
		}

		const char* DrmMetadata::getValue(const String8* key) const {
		if(key != NULL) {
		if (NAME_NOT_FOUND != mMetadataMap.indexOfKey(*key)) {
		return mMetadataMap.valueFor(*key);
		}
		else {
		return NULL;
		}
		} else {
		return NULL;
		}
		}

		const char* DrmMetadata::getAsByteArray(const String8* key) const {
		return getValue(key);
		}

		bool DrmMetadata::KeyIterator::hasNext() {
		return mIndex < mDrmMetadata->mMetadataMap.size();
		}

		const String8& DrmMetadata::KeyIterator::next() {
		const String8& key = mDrmMetadata->mMetadataMap.keyAt(mIndex);
		mIndex++;
		return key;
		}

		DrmMetadata::KeyIterator DrmMetadata::keyIterator() {
		return KeyIterator(this);
		}

		DrmMetadata::KeyIterator::KeyIterator(const DrmMetadata::KeyIterator& keyIterator) :
		mDrmMetadata(keyIterator.mDrmMetadata),
		mIndex(keyIterator.mIndex) {
		LOGV("DrmMetadata::KeyIterator::KeyIterator");
		}

		DrmMetadata::KeyIterator& DrmMetadata::KeyIterator::operator=(const DrmMetadata::KeyIterator& keyIterator) {
		LOGV("DrmMetadata::KeyIterator::operator=");
		mDrmMetadata = keyIterator.mDrmMetadata;
		mIndex = keyIterator.mIndex;
		return *this;
		}


		DrmMetadata::Iterator DrmMetadata::iterator() {
		return Iterator(this);
		}

		DrmMetadata::Iterator::Iterator(const DrmMetadata::Iterator& iterator) :
		mDrmMetadata(iterator.mDrmMetadata),
		mIndex(iterator.mIndex) {
		LOGV("DrmMetadata::Iterator::Iterator");
		}

		DrmMetadata::Iterator& DrmMetadata::Iterator::operator=(const DrmMetadata::Iterator& iterator) {
		LOGV("DrmMetadata::Iterator::operator=");
		mDrmMetadata = iterator.mDrmMetadata;
		mIndex = iterator.mIndex;
		return *this;
		}

		bool DrmMetadata::Iterator::hasNext() {
		return mIndex < mDrmMetadata->mMetadataMap.size();
		}

		String8 DrmMetadata::Iterator::next() {
		String8 value = String8(mDrmMetadata->mMetadataMap.editValueAt(mIndex));
		mIndex++;
		return value;
		}

drm/common/IDrmManagerService.cpp

+62 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@

		#include <drm/DrmInfo.h>
		#include <drm/DrmConstraints.h>
		#include <drm/DrmMetadata.h>
		#include <drm/DrmRights.h>
		#include <drm/DrmInfoStatus.h>
		#include <drm/DrmConvertedStatus.h>
		@@ -123,6 +124,35 @@ DrmConstraints* BpDrmManagerService::getConstraints(
		return drmConstraints;
		}

		DrmMetadata* BpDrmManagerService::getMetadata(int uniqueId, const String8* path) {
		LOGV("Get Metadata");
		Parcel data, reply;
		data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
		data.writeInt32(uniqueId);

		DrmMetadata* drmMetadata = NULL;
		data.writeString8(*path);
		remote()->transact(GET_METADATA_FROM_CONTENT, data, &reply);

		if (0 != reply.dataAvail()) {
		//Filling Drm Metadata
		drmMetadata = new DrmMetadata();

		const int size = reply.readInt32();
		for (int index = 0; index < size; ++index) {
		const String8 key(reply.readString8());
		const int bufferSize = reply.readInt32();
		char* data = NULL;
		if (0 < bufferSize) {
		data = new char[bufferSize];
		reply.read(data, bufferSize);
		}
		drmMetadata->put(&key, data);
		}
		}
		return drmMetadata;
		}

		bool BpDrmManagerService::canHandle(int uniqueId, const String8& path, const String8& mimeType) {
		LOGV("Can Handle");
		Parcel data, reply;
		@@ -827,6 +857,38 @@ status_t BnDrmManagerService::onTransact(
		return DRM_NO_ERROR;
		}

		case GET_METADATA_FROM_CONTENT:
		{
		LOGV("BnDrmManagerService::onTransact :GET_METADATA_FROM_CONTENT");
		CHECK_INTERFACE(IDrmManagerService, data, reply);

		const int uniqueId = data.readInt32();
		const String8 path = data.readString8();

		DrmMetadata* drmMetadata = getMetadata(uniqueId, &path);
		if (NULL != drmMetadata) {
		//Filling DRM Metadata contents
		reply->writeInt32(drmMetadata->getCount());

		DrmMetadata::KeyIterator keyIt = drmMetadata->keyIterator();
		while (keyIt.hasNext()) {
		const String8 key = keyIt.next();
		reply->writeString8(key);
		const char* value = drmMetadata->getAsByteArray(&key);
		int bufferSize = 0;
		if (NULL != value) {
		bufferSize = strlen(value);
		reply->writeInt32(bufferSize + 1);
		reply->write(value, bufferSize + 1);
		} else {
		reply->writeInt32(0);
		}
		}
		}
		delete drmMetadata; drmMetadata = NULL;
		return NO_ERROR;
		}

		case CAN_HANDLE:
		{
		LOGV("BnDrmManagerService::onTransact :CAN_HANDLE");

drm/drmserver/DrmManager.cpp

+10 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <drm/DrmInfoEvent.h>
		#include <drm/DrmRights.h>
		#include <drm/DrmConstraints.h>
		#include <drm/DrmMetadata.h>
		#include <drm/DrmInfoStatus.h>
		#include <drm/DrmInfoRequest.h>
		#include <drm/DrmSupportInfo.h>
		@@ -148,6 +149,15 @@ DrmConstraints* DrmManager::getConstraints(int uniqueId, const String8* path, co
		return NULL;
		}

		DrmMetadata* DrmManager::getMetadata(int uniqueId, const String8* path) {
		const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, *path);
		if (EMPTY_STRING != plugInId) {
		IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId);
		return rDrmEngine.getMetadata(uniqueId, path);
		}
		return NULL;
		}

		status_t DrmManager::installDrmEngine(int uniqueId, const String8& absolutePath) {
		mPlugInManager.loadPlugIn(absolutePath);