path: root/media/java/android/drm/mobile1/DrmRawContent.java

/*
 * 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");
        }
    }
}