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

Commit 3473846f authored by Takeshi Aimi's avatar Takeshi Aimi
Browse files

Update of DRM Framework. 

-Access permission handling
  Introduce an internal function which allows the desired process to
  access decryption flow. This new function is just for reference and
  each OEM manufacturer should implement/replace with their solutions.
-New API, getMetadata()
  This API is for retrieving media metadata from container-based DRM,
  such as OMA forward-lock content. This API asks DRM agent to retrieve
  media metadata hiddein inside of DRM special container.
-New API, acquireRights()
  This API wraps acquireDrmInfo() and processDrmInfo().
  If DRM agent has valid implementation of both APIs,
  Application can acquire DrmRights only by calling this API.
-Bug fix in event loop of OnInfoListener.
  Separate OnInfo event loop from mail thread loop so as to avoid
  the issue that message is not dispatched when mail thread is busy.

Changes are made by SEMC and Sony.

Change-Id: I04ee3e0988152a71e221f2256d83253749a29da0
parent cf6a8d23

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