Initial OMA DRM forward lock contribution

#

# Copyright (C) 2010 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.

#

include $(call all-subdir-makefiles)

#

# Copyright (C) 2010 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.

#

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES := \

    src/MimeTypeUtil.cpp

LOCAL_MODULE := libdrmutility

LOCAL_SHARED_LIBRARIES :=  \

    libutils \

    libdl \

    libdvm \

    libandroid_runtime \

    libnativehelper \

    liblog

base := frameworks/base

LOCAL_C_INCLUDES += \

    $(JNI_H_INCLUDE) \

    $(base)/include \

    $(base)/include/drm \

    $(base)/include/drm/plugins \

    $(LOCAL_PATH)/include

ifneq ($(TARGET_BUILD_VARIANT),user)

LOCAL_C_INCLUDES += \

    $(LOCAL_PATH)/tools

endif

LOCAL_MODULE_TAGS := optional

include $(BUILD_STATIC_LIBRARY)

/*

 * Copyright (C) 2010 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 __MIMETYPEUTIL_H__

#define __MIMETYPEUTIL_H__

#include <utils/String8.h>

namespace android {

class MimeTypeUtil {

public:

    MimeTypeUtil() {}

    virtual ~MimeTypeUtil() {}

/**

 * May convert the mimetype if there is a well known

 * replacement mimetype otherwise the original mimetype

 * is returned.

 *

 * @param mimeType - mimetype in lower case to convert.

 *

 * @return mimetype or null.

 */

static String8 convertMimeType(String8& mimeType);

};

};

#endif /* __MIMETYPEUTIL_H__ */

/*

 * Copyright (C) 2010 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 __SESSIONMAP_H__

#define __SESSIONMAP_H__

#include <utils/KeyedVector.h>

namespace android {

/**

 * A wrapper template class for handling DRM Engine sessions.

 */

template <typename NODE>

class SessionMap {

public:

    KeyedVector<int, NODE> map;

    SessionMap() {}

    virtual ~SessionMap() {

        destroyMap();

    }

/**

 * Adds a new value in the session map table. It expects memory to be allocated already

 * for the session object

 *

 * @param key - key or Session ID

 * @param value - session object to add

 *

 * @return boolean result of adding value. returns false if key is already exist.

 */

bool addValue(int key, NODE value) {

    bool result = false;

    if (!isCreated(key)) {

        map.add(key, value);

        result = true;

    }

    return result;

}

/**

 * returns the session object by the key

 *

 * @param key - key or Session ID

 *

 * @return session object as per the key

 */

NODE getValue(int key) {

    NODE value = NULL;

    if (isCreated(key)) {

        value = (NODE) map.valueFor(key);

    }

    return value;

}

/**

 * returns the number of objects in the session map table

 *

 * @return count of number of session objects.

 */

int getSize() {

    return map.size();

}

/**

 * returns the session object by the index in the session map table

 *

 * @param index - index of the value required

 *

 * @return session object as per the index

 */

NODE getValueAt(unsigned int index) {

    NODE value = NULL;

    if (map.size() > index) {

      value = map.valueAt(index);

    }

    return value;

}

/**

 * deletes the object from session map. It also frees up memory for the session object.

 *

 * @param key - key of the value to be deleted

 *

 */

void removeValue(int key) {

    deleteValue(getValue(key));

    map.removeItem(key);

}

/**

 * decides if session is already created.

 *

 * @param key - key of the value for the session

 *

 * @return boolean result of whether session is created

 */

bool isCreated(int key) {

    return (0 <= map.indexOfKey(key));

}

/**

 * empty the entire session table. It releases all the memory for session objects.

 */

void destroyMap() {

    int size = map.size();

    int i = 0;

    for (i = 0; i < size; i++) {

        deleteValue(map.valueAt(i));

    }

    map.clear();

}

/**

 * free up the memory for the session object.

 * Make sure if any reference to the session object anywhere, otherwise it will be a

 * dangle pointer after this call.

 *

 * @param value - session object to free

 *

 */

void deleteValue(NODE value) {

    delete value;

}

};

};

#endif /* __SESSIONMAP_H__ */

/*

 * Copyright (C) 2010 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.

 */

#include <MimeTypeUtil.h>

#include <utils/Log.h>

namespace android {

#undef LOG_TAG

#define LOG_TAG "MimeTypeUtil"

enum {

    MIMETYPE_AUDIO       = 0,

    MIMETYPE_APPLICATION = 1,

    MIMETYPE_IMAGE       = 2,

    MIMETYPE_VIDEO       = 3,

    MIMETYPE_LAST        = -1,

};

struct MimeGroup{

    int         type;     // Audio, video,.. use the enum values

    const char* pGroup;   // "audio/", "video/",.. should contain the last "/"

    int         size;     // Number of bytes. e.g. "audio/" = 6 bytes

};

struct MimeTypeList{

    int         type;

    const char* pMimeExt;  // Everything after the '/' e.g. audio/x-mpeg -> "x-mpeg"

    int         size;      // Number of bytes. e.g. "x-mpeg" = 6 bytes

    const char* pMimeType; // Mimetype that should be returned

};

// Known mimetypes by android

static const char mime_type_audio_mpeg[]  = "audio/mpeg";

static const char mime_type_audio_3gpp[]  = "audio/3gpp";

static const char mime_type_audio_amr[]   = "audio/amr-wb";

static const char mime_type_audio_aac[]   = "audio/mp4a-latm";

static const char mime_type_audio_wav[]   = "audio/wav";

static const char mime_type_video_mpeg4[] = "video/mpeg4";

static const char mime_type_video_3gpp[]  = "video/3gpp";

// Known mimetype groups

static const char mime_group_audio[]       = "audio/";

static const char mime_group_application[] = "application/";

static const char mime_group_image[]       = "image/";

static const char mime_group_video[]       = "video/";

static struct MimeGroup mimeGroup[] = {

    {MIMETYPE_AUDIO,       mime_group_audio,        sizeof(mime_group_audio)-1},

    {MIMETYPE_APPLICATION, mime_group_application,  sizeof(mime_group_application)-1},

    {MIMETYPE_IMAGE,       mime_group_image,        sizeof(mime_group_image)-1},

    {MIMETYPE_VIDEO,       mime_group_video,        sizeof(mime_group_video)-1},

    {MIMETYPE_LAST,        NULL,                    0} // Must be last entry

};

// List of all mimetypes that should be converted.

static struct MimeTypeList mimeTypeList[] = {

    // Mp3 mime types

    {MIMETYPE_AUDIO, "mp3",          sizeof("mp3")-1,         mime_type_audio_mpeg},

    {MIMETYPE_AUDIO, "x-mpeg",       sizeof("x-mpeg")-1,      mime_type_audio_mpeg},

    {MIMETYPE_AUDIO, "x-mp3",        sizeof("x-mp3")-1,       mime_type_audio_mpeg},

    {MIMETYPE_AUDIO, "mpg",          sizeof("mpg")-1,         mime_type_audio_mpeg},

    {MIMETYPE_AUDIO, "mpg3",         sizeof("mpg")-1,         mime_type_audio_mpeg},

    {MIMETYPE_AUDIO, "x-mpg",        sizeof("x-mpg")-1,       mime_type_audio_mpeg},

    {MIMETYPE_AUDIO, "x-mpegaudio",  sizeof("x-mpegaudio")-1, mime_type_audio_mpeg},

    // 3gpp audio mime types

    {MIMETYPE_AUDIO, "3gp",          sizeof("3gp")-1,         mime_type_audio_3gpp},

    // Amr audio mime types

    {MIMETYPE_AUDIO, "amr",          sizeof("amr")-1,         mime_type_audio_amr},

    // Aac audio mime types

    {MIMETYPE_AUDIO, "aac",          sizeof("aac")-1,         mime_type_audio_aac},

    // Wav audio mime types

    {MIMETYPE_AUDIO, "x-wav",        sizeof("x-wav")-1,       mime_type_audio_wav},

    // Mpeg4 video mime types

    {MIMETYPE_VIDEO, "mpg4",         sizeof("mpg4")-1,        mime_type_video_mpeg4},

    {MIMETYPE_VIDEO, "mp4v-es",      sizeof("mp4v-es")-1,     mime_type_video_mpeg4},

    // 3gpp video mime types

    {MIMETYPE_VIDEO, "3gp",          sizeof("3gp")-1,         mime_type_video_3gpp},

    // Must be last entry

    {MIMETYPE_LAST,  NULL,           0,                       NULL}

};

/**

 * May convert the mimetype if there is a well known

 * replacement mimetype otherwise the original mimetype

 * is returned.

 *

 * @param mimeType - mimetype in lower case to convert.

 *

 * @return mimetype or null.

 */

String8 MimeTypeUtil::convertMimeType(String8& mimeType) {

    String8 result = mimeType;

    const char* pTmp;

    const char* pMimeType;

    struct MimeGroup* pGroup;

    struct MimeTypeList* pMimeItem;

    int len;

    pMimeType = mimeType.string();

    if (NULL != pMimeType) {

        /* Check which group the mimetype is */

        pGroup = mimeGroup;

        while (MIMETYPE_LAST != pGroup->type) {

            if (0 == strncmp(pMimeType, pGroup->pGroup, pGroup->size)) {

                break;

            }

            pGroup++;

        }

        /* Go through the mimetype list. Only check items of the correct group */

        if (MIMETYPE_LAST != pGroup->type) {

            pMimeItem = mimeTypeList;

            len = strlen (pMimeType+pGroup->size);

            while (MIMETYPE_LAST != pMimeItem->type) {

                if ((len == pMimeItem->size) &&

                    (0 == strcmp(pMimeType+pGroup->size, pMimeItem->pMimeExt))) {

                    result = String8(pMimeItem->pMimeType);

                    break;

                }

                pMimeItem++;

            }

        }

        LOGI("convertMimeType got mimetype %s, converted into mimetype %s",

             pMimeType, result.string());

    }

    return result;

}

};