Implement async event callout from drm plugin to Java app (c0d5f1f8) · Commits · e / os / android_frameworks_av

drm/mediadrm/plugins/mock/MockDrmCryptoPlugin.cpp

+25 −1

Original line number	Original line	Diff line number	Diff line
	@@ -343,7 +343,31 @@ namespace android {
	Mutex::Autolock lock(mLock);		Mutex::Autolock lock(mLock);
	ALOGD("MockDrmPlugin::setPropertyString(name=%s, value=%s)",		ALOGD("MockDrmPlugin::setPropertyString(name=%s, value=%s)",
	name.string(), value.string());		name.string(), value.string());

			if (name == "mock-send-event") {
			unsigned code, extra;
			sscanf(value.string(), "%d %d", &code, &extra);
			DrmPlugin::EventType eventType = (DrmPlugin::EventType)code;

			Vector<uint8_t> const *pSessionId = NULL;
			ssize_t index = mByteArrayProperties.indexOfKey(String8("mock-event-session-id"));
			if (index >= 0) {
			pSessionId = &mByteArrayProperties[index];
			}

			Vector<uint8_t> const *pData = NULL;
			index = mByteArrayProperties.indexOfKey(String8("mock-event-data"));
			if (index >= 0) {
			pData = &mByteArrayProperties[index];
			}
			ALOGD("sending event from mock drm plugin: %d %d %s %s",
			(int)code, extra, pSessionId ? vectorToString(*pSessionId) : "{}",
			pData ? vectorToString(*pData) : "{}");

			sendEvent(eventType, extra, pSessionId, pData);
			} else {
	mStringProperties.add(name, value);		mStringProperties.add(name, value);
			}
	return OK;		return OK;
	}		}

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	#include <binder/IInterface.h>		#include <binder/IInterface.h>
	#include <media/stagefright/foundation/ABase.h>		#include <media/stagefright/foundation/ABase.h>
	#include <media/drm/DrmAPI.h>		#include <media/drm/DrmAPI.h>
			#include <media/IDrmClient.h>

	#ifndef ANDROID_IDRM_H_		#ifndef ANDROID_IDRM_H_

	@@ -106,6 +107,8 @@ struct IDrm : public IInterface {
	Vector<uint8_t> const &signature,		Vector<uint8_t> const &signature,
	bool &match) = 0;		bool &match) = 0;

			virtual status_t setListener(const sp<IDrmClient>& listener) = 0;

	private:		private:
	DISALLOW_EVIL_CONSTRUCTORS(IDrm);		DISALLOW_EVIL_CONSTRUCTORS(IDrm);
	};		};

0 → 100644

+48 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2013 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.
			*/

			#ifndef ANDROID_IDRMCLIENT_H
			#define ANDROID_IDRMCLIENT_H

			#include <utils/RefBase.h>
			#include <binder/IInterface.h>
			#include <binder/Parcel.h>
			#include <media/drm/DrmAPI.h>

			namespace android {

			class IDrmClient: public IInterface
			{
			public:
			DECLARE_META_INTERFACE(DrmClient);

			virtual void notify(DrmPlugin::EventType eventType, int extra, const Parcel *obj) = 0;
			};

			// ----------------------------------------------------------------------------

			class BnDrmClient: public BnInterface<IDrmClient>
			{
			public:
			virtual status_t onTransact(uint32_t code,
			const Parcel& data,
			Parcel* reply,
			uint32_t flags = 0);
			};

			}; // namespace android

			#endif // ANDROID_IDRMCLIENT_H

+1 −0

+18 −1

Original line number	Original line	Diff line number	Diff line
	@@ -51,7 +51,8 @@ enum {
	ENCRYPT,		ENCRYPT,
	DECRYPT,		DECRYPT,
	SIGN,		SIGN,
	VERIFY		VERIFY,
			SET_LISTENER
	};		};

	struct BpDrm : public BpInterface<IDrm> {		struct BpDrm : public BpInterface<IDrm> {
	@@ -384,6 +385,14 @@ struct BpDrm : public BpInterface<IDrm> {
	return reply.readInt32();		return reply.readInt32();
	}		}

			virtual status_t setListener(const sp<IDrmClient>& listener) {
			Parcel data, reply;
			data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
			data.writeStrongBinder(listener->asBinder());
			remote()->transact(SET_LISTENER, data, &reply);
			return reply.readInt32();
			}

	private:		private:
	void readVector(Parcel &reply, Vector<uint8_t> &vector) const {		void readVector(Parcel &reply, Vector<uint8_t> &vector) const {
	uint32_t size = reply.readInt32();		uint32_t size = reply.readInt32();
	@@ -712,6 +721,14 @@ status_t BnDrm::onTransact(
	return OK;		return OK;
	}		}

			case SET_LISTENER: {
			CHECK_INTERFACE(IDrm, data, reply);
			sp<IDrmClient> listener =
			interface_cast<IDrmClient>(data.readStrongBinder());
			reply->writeInt32(setListener(listener));
			return NO_ERROR;
			} break;

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