Initial Contribution

1 files changed, 464 insertions, 0 deletions

diff --git a/media/java/android/drm/mobile1/DrmRawContent.java b/media/java/android/drm/mobile1/DrmRawContent.java
new file mode 100644
index 0000000..046b84a
--- /dev/null
+++ b/media/java/android/drm/mobile1/DrmRawContent.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2007 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.
+ */
+
+package android.drm.mobile1;
+
+import java.io.*;
+
+/**
+ * This class provides interfaces to access the DRM raw content.
+ */
+public class DrmRawContent {
+    /**
+     * The "application/vnd.oma.drm.message" mime type.
+     */
+    public static final String DRM_MIMETYPE_MESSAGE_STRING = "application/vnd.oma.drm.message";
+
+    /**
+     * The "application/vnd.oma.drm.content" mime type.
+     */
+    public static final String DRM_MIMETYPE_CONTENT_STRING = "application/vnd.oma.drm.content";
+
+    /**
+     * The DRM delivery type: Forward-Lock
+     */
+    public static final int DRM_FORWARD_LOCK = 1;
+
+    /**
+     * The DRM delivery type: Combined Delivery
+     */
+    public static final int DRM_COMBINED_DELIVERY = 2;
+
+    /**
+     * The DRM delivery type: Separate Delivery
+     */
+    public static final int DRM_SEPARATE_DELIVERY = 3;
+
+    /**
+     * The DRM delivery type: Separate Delivery in DRM message
+     */
+    public static final int DRM_SEPARATE_DELIVERY_DM = 4;
+
+    /**
+     * The DRM media content length is unknown currently
+     */
+    public static final int DRM_UNKNOWN_DATA_LEN = -1;
+
+
+    /**
+     * The id of "application/vnd.oma.drm.message" mime type.
+     */
+    private static final int DRM_MIMETYPE_MESSAGE = 1;
+
+    /**
+     * The id of "application/vnd.oma.drm.content" mime type.
+     */
+    private static final int DRM_MIMETYPE_CONTENT = 2;
+
+    /**
+     * Successful operation.
+     */
+    private static final int JNI_DRM_SUCCESS = 0;
+
+    /**
+     * General failure.
+     */
+    private static final int JNI_DRM_FAILURE = -1;
+
+    /**
+     * Indicates the end of the DRM content is reached.
+     */
+    private static final int JNI_DRM_EOF = -2;
+
+    /**
+     * The media content length is unknown from native method
+     */
+    private static final int JNI_DRM_UNKNOWN_DATA_LEN = -3;
+
+    /**
+     * The member to save the original InputStream data.
+     */
+    private BufferedInputStream inData;
+
+    /**
+     * The member to save the original InputStream data length.
+     */
+    private int inDataLen;
+
+    /**
+     * The unique id to this DRM content. It will be initialized
+     * in constructor by native method. And it will not be changed
+     * after initialization.
+     */
+    private int id;
+
+    /**
+     * The rights issuer address of this DRM object.
+     */
+    private String rightsIssuer;
+
+    /**
+     * The media content type of this DRM object.
+     */
+    private String mediaType;
+
+    /**
+     * The delivery method type of this DRM object.
+     */
+    private int rawType;
+
+
+    /**
+     * Construct a DrmRawContent object.
+     *
+     * @param inRawdata     object of DRM raw data stream.
+     * @param len           the length of raw data can be read.
+     * @param mimeTypeStr   the mime type of the DRM content.
+     */
+    public DrmRawContent(InputStream inRawdata, int len, String mimeTypeStr) throws DrmException, IOException {
+        int mimeType;
+
+        id = -1;
+        inData = new BufferedInputStream(inRawdata, 1024);
+        inDataLen = len;
+
+        if (DRM_MIMETYPE_MESSAGE_STRING.equals(mimeTypeStr))
+            mimeType = DRM_MIMETYPE_MESSAGE;
+        else if (DRM_MIMETYPE_CONTENT_STRING.equals(mimeTypeStr))
+            mimeType = DRM_MIMETYPE_CONTENT;
+        else
+            throw new IllegalArgumentException("mimeType must be DRM_MIMETYPE_MESSAGE or DRM_MIMETYPE_CONTENT");
+
+        if (len <= 0)
+            throw new IllegalArgumentException("len must be > 0");
+
+        /* call native method to initialize this DRM content */
+        id = nativeConstructDrmContent(inData, inDataLen, mimeType);
+
+        if (JNI_DRM_FAILURE == id)
+            throw new DrmException("nativeConstructDrmContent() returned JNI_DRM_FAILURE");
+
+        /* init the rights issuer field. */
+        rightsIssuer = nativeGetRightsAddress();
+
+        /* init the raw content type. */
+        rawType = nativeGetDeliveryMethod();
+        if (JNI_DRM_FAILURE == rawType)
+            throw new DrmException("nativeGetDeliveryMethod() returned JNI_DRM_FAILURE");
+
+        /* init the media content type. */
+        mediaType = nativeGetContentType();
+        if (null == mediaType)
+            throw new DrmException("nativeGetContentType() returned null");
+    }
+
+    /**
+     * Get rights address from raw Seperate Delivery content.
+     *
+     * @return the string of the rights issuer address,
+     *         or null if no rights issuer.
+     */
+    public String getRightsAddress() {
+        return rightsIssuer;
+    }
+
+    /**
+     * Get the type of the raw DRM content.
+     *
+     * @return one of the following delivery type of this DRM content:
+     *              #DRM_FORWARD_LOCK
+     *              #DRM_COMBINED_DELIVERY
+     *              #DRM_SEPARATE_DELIVERY
+     *              #DRM_SEPARATE_DELIVERY_DM
+     */
+    public int getRawType() {
+        return rawType;
+    }
+
+    /**
+     * Get one InputStream object to read decrypted content.
+     *
+     * @param rights        the rights object contain decrypted key.
+     *
+     * @return the InputStream object of decrypted media content.
+     */
+    public InputStream getContentInputStream(DrmRights rights) {
+        if (null == rights)
+            throw new NullPointerException();
+
+        return new DrmInputStream(rights);
+    }
+
+    /**
+     * Get the type of the decrypted media content.
+     *
+     * @return the decrypted media content type of this DRM content.
+     */
+    public String getContentType() {
+        return mediaType;
+    }
+
+    /**
+     * Get the length of the decrypted media content.
+     *
+     * @param rights        the rights object contain decrypted key.
+     *
+     * @return the length of the decrypted media content.
+     *         #DRM_UNKNOWN_DATA_LEN if the length is unknown currently.
+     */
+    public int getContentLength(DrmRights rights) throws DrmException {
+        /**
+         * Because currently the media object associate with rights object
+         * has been handled in native logic, so here it is not need to deal
+         * the rights. But for the apps, it is mandatory for user to get
+         * the rights object before get the media content length.
+         */
+        if (null == rights)
+            throw new NullPointerException();
+
+        int mediaLen = nativeGetContentLength();
+
+        if (JNI_DRM_FAILURE == mediaLen)
+            throw new DrmException("nativeGetContentLength() returned JNI_DRM_FAILURE");
+
+        if (JNI_DRM_UNKNOWN_DATA_LEN == mediaLen)
+            return DRM_UNKNOWN_DATA_LEN;
+
+        return mediaLen;
+    }
+
+    /**
+     * This class provide a InputStream to the DRM media content.
+     */
+    class DrmInputStream extends InputStream
+    {
+        /**
+         * The flag to indicate whether this stream is closed or not.
+         */
+        private boolean isClosed;
+
+        /**
+         * The offset of this DRM content to be reset.
+         */
+        private int offset;
+
+        /**
+         * A byte of data to be readed.
+         */
+        private byte[] b;
+
+        /**
+         * Construct a DrmInputStream instance.
+         */
+        public DrmInputStream(DrmRights rights) {
+            /**
+             * Because currently the media object associate with rights object
+             * has been handled in native logic, so here it is not need to deal
+             * the rights. But for the apps, it is mandatory for user to get
+             * the rights object before get the media content data.
+             */
+
+            isClosed = false;
+            offset = 0;
+            b = new byte[1];
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#available()
+         */
+        public int available() throws IOException {
+            /* call native method to get this DRM decrypted media content length */
+            int len = nativeGetContentLength();
+
+            if (JNI_DRM_FAILURE == len)
+                throw new IOException();
+
+            /* if the length is unknown, just return 0 for available value */
+            if (JNI_DRM_UNKNOWN_DATA_LEN == len)
+                return 0;
+
+            int availableLen = len - offset;
+            if (availableLen < 0)
+                throw new IOException();
+
+            return availableLen;
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#read()
+         */
+        public int read() throws IOException {
+            int res;
+
+            res = read(b, 0, 1);
+
+            if (-1 == res)
+                return -1;
+
+            return b[0] & 0xff;
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#read(byte)
+         */
+        public int read(byte[] b) throws IOException {
+            return read(b, 0, b.length);
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#read(byte, int, int)
+         */
+        public int read(byte[] b, int off, int len) throws IOException {
+            if (null == b)
+                throw new NullPointerException();
+            if (off < 0 || len < 0 || off + len > b.length)
+                throw new IndexOutOfBoundsException();
+            if (true == isClosed)
+                throw new IOException();
+
+            if (0 == len)
+                return 0;
+
+            len = nativeReadContent(b, off, len, offset);
+
+            if (JNI_DRM_FAILURE == len)
+                throw new IOException();
+            else if (JNI_DRM_EOF == len)
+                return -1;
+
+            offset += len;
+
+            return len;
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#markSupported()
+         */
+        public boolean markSupported() {
+            return false;
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#mark(int)
+         */
+        public void mark(int readlimit) {
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#reset()
+         */
+        public void reset() throws IOException {
+            throw new IOException();
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#skip()
+         */
+        public long skip(long n) throws IOException {
+            return 0;
+        }
+
+        /* Non-javadoc
+         * @see java.io.InputStream#close()
+         */
+        public void close() {
+            isClosed = true;
+        }
+    }
+
+    /**
+     * native method: construct a DRM content according the mime type.
+     *
+     * @param data      input DRM content data to be parsed.
+     * @param len       the length of the data.
+     * @param mimeType  the mime type of this DRM content. the value of this field includes:
+     *                      #DRM_MIMETYPE_MESSAGE
+     *                      #DRM_MIMETYPE_CONTENT
+     *
+     * @return #the id of the DRM content if succeed.
+     *         #JNI_DRM_FAILURE if fail.
+     */
+    private native int nativeConstructDrmContent(InputStream data, int len, int mimeType);
+
+    /**
+     * native method: get this DRM content rights issuer.
+     *
+     * @return the address of rights issuer if in case of separate delivery.
+     *         null if not separete delivery, or otherwise.
+     */
+    private native String nativeGetRightsAddress();
+
+    /**
+     * native method: get this DRM content delivery type.
+     *
+     * @return the delivery method, the value may be one of the following:
+     *              #DRM_FORWARD_LOCK
+     *              #DRM_COMBINED_DELIVERY
+     *              #DRM_SEPARATE_DELIVERY
+     *              #DRM_SEPARATE_DELIVERY_DM
+     *         #JNI_DRM_FAILURE if fail.
+     */
+    private native int nativeGetDeliveryMethod();
+
+    /**
+     * native method: get a piece of media content data.
+     *
+     * @param buf       the buffer to save DRM media content data.
+     * @param bufOff    the offset of the buffer to start to save data.
+     * @param len       the number of byte to read.
+     * @param mediaOff  the offset of the media content data to start to read.
+     *
+     * @return the length of the media content data has been read.
+     *         #JNI_DRM_EOF if reach to end of the media content.
+     *         #JNI_DRM_FAILURE if fail.
+     */
+    private native int nativeReadContent(byte[] buf, int bufOff, int len, int mediaOff);
+
+    /**
+     * native method: get this DRM content type.
+     *
+     * @return the decrypted media content type.
+     *         null if fail.
+     */
+    private native String nativeGetContentType();
+
+    /**
+     * native method: get this DRM decrypted media content length.
+     *
+     * @return the length of decrypted media content.
+     *         #JNI_DRM_FAILURE if fail.
+     *         #JNI_DRM_UNKNOWN_DATA_LEN if the length is unknown currently.
+     */
+    private native int nativeGetContentLength();
+
+    /**
+     * The finalizer of the DRMRawContent. Do some cleanup.
+     */
+    protected native void finalize();
+
+
+    /**
+     * Load the shared library to link the native methods.
+     */
+    static {
+        try {
+            System.loadLibrary("drm1_jni");
+        }
+        catch (UnsatisfiedLinkError ule) {
+            System.err.println("WARNING: Could not load libdrm1_jni.so");
+        }
+    }
+}