Add new secure stop methods (1bfb3d21) · Commits · e / os / android_frameworks_base

api/current.txt

+4 −1

Original line number	Diff line number	Diff line
		@@ -23255,6 +23255,7 @@ package android.media {
		method public java.lang.String getPropertyString(java.lang.String);
		method public android.media.MediaDrm.ProvisionRequest getProvisionRequest();
		method public byte[] getSecureStop(byte[]);
		method public java.util.List<byte[]> getSecureStopIds();
		method public java.util.List<byte[]> getSecureStops();
		method public int getSecurityLevel(byte[]);
		method public static final boolean isCryptoSchemeSupported(java.util.UUID);
		@@ -23264,9 +23265,11 @@ package android.media {
		method public void provideProvisionResponse(byte[]) throws android.media.DeniedByServerException;
		method public java.util.HashMap<java.lang.String, java.lang.String> queryKeyStatus(byte[]);
		method public deprecated void release();
		method public void releaseAllSecureStops();
		method public deprecated void releaseAllSecureStops();
		method public void releaseSecureStops(byte[]);
		method public void removeAllSecureStops();
		method public void removeKeys(byte[]);
		method public void removeSecureStop(byte[]);
		method public void restoreKeys(byte[], byte[]);
		method public void setOnEventListener(android.media.MediaDrm.OnEventListener);
		method public void setOnExpirationUpdateListener(android.media.MediaDrm.OnExpirationUpdateListener, android.os.Handler);

media/java/android/media/MediaDrm.java

+52 −17

Original line number	Diff line number	Diff line
		@@ -942,43 +942,78 @@ public final class MediaDrm implements AutoCloseable {
		throws DeniedByServerException;

		/**
		* A means of enforcing limits on the number of concurrent streams per subscriber
		* across devices is provided via SecureStop. This is achieved by securely
		* monitoring the lifetime of sessions.
		* Secure stops are a way to enforce limits on the number of concurrent
		* streams per subscriber across devices. They provide secure monitoring of
		* the lifetime of content decryption keys in MediaDrm sessions.
		* <p>
		* Information from the server related to the current playback session is written
		* to persistent storage on the device when each MediaCrypto object is created.
		* A secure stop is written to secure persistent memory when keys are loaded
		* into a MediaDrm session. The secure stop state indicates that the keys
		* are available for use. When playback completes and the keys are removed
		* or the session is destroyed, the secure stop state is updated to indicate
		* that keys are no longer usable.
		* <p>
		* In the normal case, playback will be completed, the session destroyed and the
		* Secure Stops will be queried. The app queries secure stops and forwards the
		* secure stop message to the server which verifies the signature and notifies the
		* server side database that the session destruction has been confirmed. The persisted
		* record on the client is only removed after positive confirmation that the server
		* received the message using releaseSecureStops().
		* After playback, the app can query the secure stop and send it in a
		* message to the license server confirming that the keys are no longer
		* active. The license server returns a secure stop release response
		* message to the app which then deletes the secure stop from persistent
		* memory using {@link #releaseSecureStops}.
		* @return a list of all secure stops from secure persistent memory
		*/
		@NonNull
		public native List<byte[]> getSecureStops();

		/**
		* Access secure stop by secure stop ID.
		* Return a list of all secure stop IDs currently in persistent memory.
		*
		* @param ssid - The secure stop ID provided by the license server.
		* @return a list of secure stop IDs
		*/
		@NonNull
		public native List<byte[]> getSecureStopIds();

		/**
		* Access a specific secure stop given its secure stop ID.
		*
		* @param ssid the ID of the secure stop to return
		* @return the secure stop identified by ssid
		*/
		@NonNull
		public native byte[] getSecureStop(@NonNull byte[] ssid);

		/**
		* Process the SecureStop server response message ssRelease. After authenticating
		* the message, remove the SecureStops identified in the response.
		* Process the secure stop server response message ssRelease. After
		* authenticating the message, remove the secure stops identified in the
		* response.
		*
		* @param ssRelease the server response indicating which secure stops to release
		*/
		public native void releaseSecureStops(@NonNull byte[] ssRelease);

		/**
		* Remove all secure stops without requiring interaction with the server.
		* Remove a specific secure stop without requiring a secure stop release message
		* from the license server.
		* @param ssid the ID of the secure stop to remove
		*/
		public native void removeSecureStop(@NonNull byte[] ssid);

		/**
		* Remove all secure stops without requiring a secure stop release message from
		* the license server.
		*
		* This method was added in API 28. In API versions 18 through 27,
		* {@link #releaseAllSecureStops} should be called instead. There is no need to
		* do anything for API versions prior to 18.
		*/
		public native void releaseAllSecureStops();
		public native void removeAllSecureStops();

		/**
		* Remove all secure stops without requiring a secure stop release message from
		* the license server.
		*
		* @deprecated Remove all secure stops using {@link #removeAllSecureStops} instead.
		*/
		public void releaseAllSecureStops() {
		removeAllSecureStops();;
		}

		@Retention(RetentionPolicy.SOURCE)
		@IntDef({HDCP_LEVEL_UNKNOWN, HDCP_NONE, HDCP_V1, HDCP_V2,

media/jni/android_media_MediaDrm.cpp

+47 −5

Original line number	Diff line number	Diff line
		@@ -1134,6 +1134,27 @@ static jobject android_media_MediaDrm_getSecureStops(
		return ListOfVectorsToArrayListOfByteArray(env, secureStops);
		}

		static jobject android_media_MediaDrm_getSecureStopIds(
		JNIEnv *env, jobject thiz) {
		sp<IDrm> drm = GetDrm(env, thiz);

		if (drm == NULL) {
		jniThrowException(env, "java/lang/IllegalStateException",
		"MediaDrm obj is null");
		return NULL;
		}

		List<Vector<uint8_t> > secureStopIds;

		status_t err = drm->getSecureStopIds(secureStopIds);

		if (throwExceptionAsNecessary(env, err, "Failed to get secure stop Ids")) {
		return NULL;
		}

		return ListOfVectorsToArrayListOfByteArray(env, secureStopIds);
		}

		static jbyteArray android_media_MediaDrm_getSecureStop(
		JNIEnv *env, jobject thiz, jbyteArray ssid) {
		sp<IDrm> drm = GetDrm(env, thiz);
		@@ -1168,7 +1189,22 @@ static void android_media_MediaDrm_releaseSecureStops(
		throwExceptionAsNecessary(env, err, "Failed to release secure stops");
		}

		static void android_media_MediaDrm_releaseAllSecureStops(
		static void android_media_MediaDrm_removeSecureStop(
		JNIEnv *env, jobject thiz, jbyteArray ssid) {
		sp<IDrm> drm = GetDrm(env, thiz);

		if (drm == NULL) {
		jniThrowException(env, "java/lang/IllegalStateException",
		"MediaDrm obj is null");
		return;
		}

		status_t err = drm->removeSecureStop(JByteArrayToVector(env, ssid));

		throwExceptionAsNecessary(env, err, "Failed to remove secure stop");
		}

		static void android_media_MediaDrm_removeAllSecureStops(
		JNIEnv *env, jobject thiz) {
		sp<IDrm> drm = GetDrm(env, thiz);

		@@ -1176,9 +1212,9 @@ static void android_media_MediaDrm_releaseAllSecureStops(
		return;
		}

		status_t err = drm->releaseAllSecureStops();
		status_t err = drm->removeAllSecureStops();

		throwExceptionAsNecessary(env, err, "Failed to release all secure stops");
		throwExceptionAsNecessary(env, err, "Failed to remove all secure stops");
		}


		@@ -1719,14 +1755,20 @@ static const JNINativeMethod gMethods[] = {
		{ "getSecureStops", "()Ljava/util/List;",
		(void *)android_media_MediaDrm_getSecureStops },

		{ "getSecureStopIds", "()Ljava/util/List;",
		(void *)android_media_MediaDrm_getSecureStopIds },

		{ "getSecureStop", "([B)[B",
		(void *)android_media_MediaDrm_getSecureStop },

		{ "releaseSecureStops", "([B)V",
		(void *)android_media_MediaDrm_releaseSecureStops },

		{ "releaseAllSecureStops", "()V",
		(void *)android_media_MediaDrm_releaseAllSecureStops },
		{ "removeSecureStop", "([B)V",
		(void *)android_media_MediaDrm_removeSecureStop },

		{ "removeAllSecureStops", "()V",
		(void *)android_media_MediaDrm_removeAllSecureStops },

		{ "getConnectedHdcpLevel", "()I",
		(void *)android_media_MediaDrm_getConnectedHdcpLevel },