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

Commit cefac142 authored by Hassan Shojania's avatar Hassan Shojania
Browse files

Modular DRM for MediaPlayer 

Bug:  34559906
Test: Manual through the test app

Change-Id: I286f9ff199c34563b7b8643de725f8d1534ea06c
parent 2f77a222

include/media/IMediaPlayer.h

+3 −16
Original line number Diff line number Diff line
@@ -24,7 +24,6 @@ 
#include <system/audio.h>



#include <media/IMediaSource.h>

#include <media/drm/DrmAPI.h>   // for DrmPlugin::* enum

#include <media/VolumeShaper.h>



// Fwd decl to make sure everyone agrees that the scope of struct sockaddr_in is
@@ -97,22 +96,10 @@ public: 
                                    const sp<VolumeShaper::Operation>& operation) = 0;

    virtual sp<VolumeShaper::State> getVolumeShaperState(int id) = 0;



    // ModDrm

    virtual status_t        prepareDrm(const uint8_t uuid[16], const int mode) = 0;

    // Modular DRM

    virtual status_t        prepareDrm(const uint8_t uuid[16],

                                    const Vector<uint8_t>& drmSessionId) = 0;

    virtual status_t        releaseDrm() = 0;

    virtual status_t        getKeyRequest(Vector<uint8_t> const& scope,

                                    String8 const &mimeType,

                                    DrmPlugin::KeyType keyType,

                                    KeyedVector<String8, String8>& optionalParameters,

                                    Vector<uint8_t>& request,

                                    String8& defaultUrl,

                                    DrmPlugin::KeyRequestType& keyRequestType) = 0;

    virtual status_t        provideKeyResponse(Vector<uint8_t>& releaseKeySetId,

                                    Vector<uint8_t>& response,

                                    Vector<uint8_t>& keySetId) = 0;

    virtual status_t        restoreKeys(Vector<uint8_t> const& keySetId) = 0;

    virtual status_t        getDrmPropertyString(String8 const& name, String8& value) = 0;

    virtual status_t        setDrmPropertyString(String8 const& name, String8 const& value) = 0;



    // Invoke a generic method on the player by using opaque parcels

    // for the request and reply.

include/media/MediaPlayerInterface.h

+2 −22
Original line number Diff line number Diff line
@@ -285,33 +285,13 @@ public: 
        return INVALID_OPERATION;

    }



    // ModDrm

    virtual status_t prepareDrm(const uint8_t uuid[16], const int mode) {

    // Modular DRM

    virtual status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId) {

        return INVALID_OPERATION;

    }

    virtual status_t releaseDrm() {

        return INVALID_OPERATION;

    }

    virtual status_t getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,

                             DrmPlugin::KeyType keyType,

                             KeyedVector<String8, String8>& optionalParameters,

                             Vector<uint8_t>& request, String8& defaultUrl,

                             DrmPlugin::KeyRequestType& keyRequestType) {

        return INVALID_OPERATION;

    }

    virtual status_t provideKeyResponse(Vector<uint8_t>& releaseKeySetId,

                             Vector<uint8_t>& response, Vector<uint8_t>& keySetId) {

        return INVALID_OPERATION;

    }

    virtual status_t restoreKeys(Vector<uint8_t> const& keySetId) {

        return INVALID_OPERATION;

    }

    virtual status_t getDrmPropertyString(String8 const& name, String8& value) {

        return INVALID_OPERATION;

    }

    virtual status_t setDrmPropertyString(String8 const& name, String8 const& value) {

        return INVALID_OPERATION;

    }



private:

    friend class MediaPlayerService;

include/media/mediaplayer.h

+2 −12
Original line number Diff line number Diff line
@@ -266,19 +266,9 @@ public: 
                                    const sp<VolumeShaper::Configuration>& configuration,

                                    const sp<VolumeShaper::Operation>& operation);

            sp<VolumeShaper::State> getVolumeShaperState(int id);

            // ModDrm

            status_t        prepareDrm(const uint8_t uuid[16], const int mode);

            // Modular DRM

            status_t        prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId);

            status_t        releaseDrm();

            status_t        getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,

                                    DrmPlugin::KeyType keyType,

                                    KeyedVector<String8, String8>& optionalParameters,

                                    Vector<uint8_t>& request, String8& defaultUrl,

                                    DrmPlugin::KeyRequestType& keyRequestType);

            status_t        provideKeyResponse(Vector<uint8_t>& releaseKeySetId,

                                    Vector<uint8_t>& response, Vector<uint8_t>& keySetId);

            status_t        restoreKeys(Vector<uint8_t> const& keySetId);

            status_t        getDrmPropertyString(String8 const& name, String8& value);

            status_t        setDrmPropertyString(String8 const& name, String8 const& value);



private:

            void            clear_l();

include/media/stagefright/MediaCodec.h

+5 −0
Original line number Diff line number Diff line
@@ -91,6 +91,8 @@ struct MediaCodec : public AHandler { 
            const sp<ICrypto> &crypto,

            uint32_t flags);



    status_t releaseCrypto();



    status_t setCallback(const sp<AMessage> &callback);



    status_t setOnFrameRenderedNotification(const sp<AMessage> &notify);
@@ -239,6 +241,7 @@ private: 
        kWhatSetParameters                  = 'setP',

        kWhatSetCallback                    = 'setC',

        kWhatSetNotification                = 'setN',

        kWhatDrmReleaseCrypto               = 'rDrm',

    };



    enum {
@@ -416,6 +419,8 @@ private: 
        mStickyError = err;

    }



    void onReleaseCrypto(const sp<AMessage>& msg);



    DISALLOW_EVIL_CONSTRUCTORS(MediaCodec);

};

media/libmedia/IMediaPlayer.cpp

+9 −179
Original line number Diff line number Diff line
@@ -72,14 +72,9 @@ enum { 
    SET_NEXT_PLAYER,

    APPLY_VOLUME_SHAPER,

    GET_VOLUME_SHAPER_STATE,

    // ModDrm

    // Modular DRM

    PREPARE_DRM,

    RELEASE_DRM,

    GET_KEY_REQUEST,

    PROVIDE_KEY_RESPONSE,

    RESTORE_KEYS,

    GET_DRM_PROPERTY_STRING,

    SET_DRM_PROPERTY_STRING,

};



// ModDrm helpers
@@ -521,14 +516,14 @@ public: 
        return state;

    }



    // ModDrm

    status_t prepareDrm(const uint8_t uuid[16], const int mode)

    // Modular DRM

    status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());



        data.write(uuid, 16);

        data.writeInt32(mode);

        writeVector(data, drmSessionId);



        status_t status = remote()->transact(PREPARE_DRM, data, &reply);

        if (status != OK) {
@@ -552,105 +547,6 @@ public: 


        return reply.readInt32();

    }



    status_t getKeyRequest(Vector<uint8_t> const& scope, String8 const& mimeType,

            DrmPlugin::KeyType keyType, KeyedVector<String8, String8>& optionalParameters,

            Vector<uint8_t>& request, String8& defaultUrl,

            DrmPlugin::KeyRequestType& keyRequestType)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());



        writeVector(data, scope);

        data.writeString8(mimeType);

        data.writeInt32((int32_t)keyType);



        data.writeUint32(optionalParameters.size());

        for (size_t i = 0; i < optionalParameters.size(); ++i) {

            data.writeString8(optionalParameters.keyAt(i));

            data.writeString8(optionalParameters.valueAt(i));

        }



        status_t status = remote()->transact(GET_KEY_REQUEST, data, &reply);

        if (status != OK) {

            ALOGE("getKeyRequest: binder call failed: %d", status);

            return status;

        }



        readVector(reply, request);

        defaultUrl = reply.readString8();

        keyRequestType = (DrmPlugin::KeyRequestType)reply.readInt32();



        return reply.readInt32();

    }



    status_t provideKeyResponse(Vector<uint8_t>& releaseKeySetId, Vector<uint8_t>& response,

            Vector<uint8_t> &keySetId)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());



        writeVector(data, releaseKeySetId);

        writeVector(data, response);



        status_t status = remote()->transact(PROVIDE_KEY_RESPONSE, data, &reply);

        if (status != OK) {

            ALOGE("provideKeyResponse: binder call failed: %d", status);

            return status;

        }



        readVector(reply, keySetId);



        return reply.readInt32();

    }



    status_t restoreKeys(Vector<uint8_t> const& keySetId)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());



        writeVector(data, keySetId);



        status_t status = remote()->transact(RESTORE_KEYS, data, &reply);

        if (status != OK) {

            ALOGE("restoreKeys: binder call failed: %d", status);

            return status;

        }



        return reply.readInt32();

    }



    status_t getDrmPropertyString(String8 const& name, String8& value)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());



        data.writeString8(name);

        status_t status = remote()->transact(GET_DRM_PROPERTY_STRING, data, &reply);

        if (status != OK) {

            ALOGE("getDrmPropertyString: binder call failed: %d", status);

            return status;

        }



        value = reply.readString8();

        return reply.readInt32();

    }



    status_t setDrmPropertyString(String8 const& name, String8 const& value)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());



        data.writeString8(name);

        data.writeString8(value);

        status_t status = remote()->transact(SET_DRM_PROPERTY_STRING, data, &reply);

        if (status != OK) {

            ALOGE("setDrmPropertyString: binder call failed: %d", status);

            return status;

        }



        return reply.readInt32();

    }

};



IMPLEMENT_META_INTERFACE(MediaPlayer, "android.media.IMediaPlayer");
@@ -983,15 +879,16 @@ status_t BnMediaPlayer::onTransact( 
            return NO_ERROR;

        } break;



        // ModDrm

        // Modular DRM

        case PREPARE_DRM: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);



            uint8_t uuid[16];

            data.read(uuid, sizeof(uuid));

            Vector<uint8_t> drmSessionId;

            readVector(data, drmSessionId);



            int mode = data.readInt32();



            uint32_t result = prepareDrm(uuid, mode);

            uint32_t result = prepareDrm(uuid, drmSessionId);

            reply->writeInt32(result);

            return OK;

        }
@@ -1002,73 +899,6 @@ status_t BnMediaPlayer::onTransact( 
            reply->writeInt32(result);

            return OK;

        }

        case GET_KEY_REQUEST: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);



            Vector<uint8_t> scope;

            readVector(data, scope);

            String8 mimeType = data.readString8();

            DrmPlugin::KeyType keyType = (DrmPlugin::KeyType)data.readInt32();



            KeyedVector<String8, String8> optionalParameters;

            uint32_t count = data.readUint32();

            for (size_t i = 0; i < count; ++i) {

                String8 key, value;

                key = data.readString8();

                value = data.readString8();

                optionalParameters.add(key, value);

            }



            Vector<uint8_t> request;

            String8 defaultUrl;

            DrmPlugin::KeyRequestType keyRequestType = DrmPlugin::kKeyRequestType_Unknown;



            status_t result = getKeyRequest(scope, mimeType, keyType, optionalParameters,

                                      request, defaultUrl, keyRequestType);



            writeVector(*reply, request);

            reply->writeString8(defaultUrl);

            reply->writeInt32(keyRequestType);

            reply->writeInt32(result);

            return OK;

        }

        case PROVIDE_KEY_RESPONSE: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);

            Vector<uint8_t> releaseKeySetId, response, keySetId;

            readVector(data, releaseKeySetId);

            readVector(data, response);

            uint32_t result = provideKeyResponse(releaseKeySetId, response, keySetId);

            writeVector(*reply, keySetId);

            reply->writeInt32(result);

            return OK;

        }

        case RESTORE_KEYS: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);



            Vector<uint8_t> keySetId;

            readVector(data, keySetId);

            uint32_t result = restoreKeys(keySetId);

            reply->writeInt32(result);

            return OK;

        }

        case GET_DRM_PROPERTY_STRING: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);

            String8 name, value;

            name = data.readString8();

            uint32_t result = getDrmPropertyString(name, value);

            reply->writeString8(value);

            reply->writeInt32(result);

            return OK;

        }

        case SET_DRM_PROPERTY_STRING: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);

            String8 name, value;

            name = data.readString8();

            value = data.readString8();

            uint32_t result = setDrmPropertyString(name, value);

            reply->writeInt32(result);

            return OK;

        }

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }