Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 99a5aba0 authored by Jeff Tinker's avatar Jeff Tinker
Browse files

Remove DISABLE_TREBLE_DRM 

This flag is obsolete now that the conversion
to treble is complete.

Change-Id: I7073d337939da43bddf99644bfe52db9baa2f605
related-to-bug: 32815560
parent 399565a0

drm/libmediadrm/Android.mk

+2 −12
Original line number Diff line number Diff line
@@ -25,16 +25,9 @@ LOCAL_SRC_FILES += \ 
    IDrmClient.cpp \

    IMediaDrmService.cpp \

    MediaCasDefs.cpp \

    SharedLibrary.cpp

ifneq ($(DISABLE_TREBLE_DRM), true)

LOCAL_SRC_FILES += \

    SharedLibrary.cpp \

    DrmHal.cpp \

    CryptoHal.cpp

else

LOCAL_SRC_FILES += \

    Drm.cpp \

    Crypto.cpp

endif



LOCAL_SHARED_LIBRARIES := \

    libbinder \
@@ -43,15 +36,12 @@ LOCAL_SHARED_LIBRARIES := \ 
    liblog \

    libmediautils \

    libstagefright_foundation \

    libutils

ifneq ($(DISABLE_TREBLE_DRM), true)

LOCAL_SHARED_LIBRARIES += \

    libutils \

    android.hidl.base@1.0 \

    android.hardware.drm@1.0 \

    libhidlbase \

    libhidlmemory \

    libhidltransport

endif



LOCAL_CFLAGS += -Werror -Wno-error=deprecated-declarations -Wall

drm/libmediadrm/Crypto.cpp

deleted100644 → 0
+0 −288
Original line number Diff line number Diff line 
/*

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

 */



//#define LOG_NDEBUG 0

#define LOG_TAG "Crypto"

#include <utils/Log.h>

#include <dirent.h>

#include <dlfcn.h>



#include <binder/IMemory.h>

#include <media/Crypto.h>

#include <media/DrmPluginPath.h>

#include <media/hardware/CryptoAPI.h>

#include <media/stagefright/foundation/ADebug.h>

#include <media/stagefright/foundation/AString.h>

#include <media/stagefright/foundation/hexdump.h>

#include <media/stagefright/MediaErrors.h>



namespace android {



KeyedVector<Vector<uint8_t>, String8> Crypto::mUUIDToLibraryPathMap;

KeyedVector<String8, wp<SharedLibrary> > Crypto::mLibraryPathToOpenLibraryMap;

Mutex Crypto::mMapLock;



static bool operator<(const Vector<uint8_t> &lhs, const Vector<uint8_t> &rhs) {

    if (lhs.size() < rhs.size()) {

        return true;

    } else if (lhs.size() > rhs.size()) {

        return false;

    }



    return memcmp((void *)lhs.array(), (void *)rhs.array(), rhs.size()) < 0;

}



Crypto::Crypto()

    : mInitCheck(NO_INIT),

      mFactory(NULL),

      mPlugin(NULL) {

}



Crypto::~Crypto() {

    delete mPlugin;

    mPlugin = NULL;

    closeFactory();

}



void Crypto::closeFactory() {

    delete mFactory;

    mFactory = NULL;

    mLibrary.clear();

}



status_t Crypto::initCheck() const {

    return mInitCheck;

}



/*

 * Search the plugins directory for a plugin that supports the scheme

 * specified by uuid

 *

 * If found:

 *    mLibrary holds a strong pointer to the dlopen'd library

 *    mFactory is set to the library's factory method

 *    mInitCheck is set to OK

 *

 * If not found:

 *    mLibrary is cleared and mFactory are set to NULL

 *    mInitCheck is set to an error (!OK)

 */

void Crypto::findFactoryForScheme(const uint8_t uuid[16]) {



    closeFactory();



    // lock static maps

    Mutex::Autolock autoLock(mMapLock);



    // first check cache

    Vector<uint8_t> uuidVector;

    uuidVector.appendArray(uuid, sizeof(uuid[0]) * 16);

    ssize_t index = mUUIDToLibraryPathMap.indexOfKey(uuidVector);

    if (index >= 0) {

        if (loadLibraryForScheme(mUUIDToLibraryPathMap[index], uuid)) {

            mInitCheck = OK;

            return;

        } else {

            ALOGE("Failed to load from cached library path!");

            mInitCheck = ERROR_UNSUPPORTED;

            return;

        }

    }



    // no luck, have to search

    String8 dirPath(getDrmPluginPath());

    String8 pluginPath;



    DIR* pDir = opendir(dirPath.string());

    if (pDir) {

        struct dirent* pEntry;

        while ((pEntry = readdir(pDir))) {



            pluginPath = dirPath + "/" + pEntry->d_name;



            if (pluginPath.getPathExtension() == ".so") {



                if (loadLibraryForScheme(pluginPath, uuid)) {

                    mUUIDToLibraryPathMap.add(uuidVector, pluginPath);

                    mInitCheck = OK;

                    closedir(pDir);

                    return;

                }

            }

        }



        closedir(pDir);

    }



    // try the legacy libdrmdecrypt.so

    pluginPath = "libdrmdecrypt.so";

    if (loadLibraryForScheme(pluginPath, uuid)) {

        mUUIDToLibraryPathMap.add(uuidVector, pluginPath);

        mInitCheck = OK;

        return;

    }



    mInitCheck = ERROR_UNSUPPORTED;

}



bool Crypto::loadLibraryForScheme(const String8 &path, const uint8_t uuid[16]) {



    // get strong pointer to open shared library

    ssize_t index = mLibraryPathToOpenLibraryMap.indexOfKey(path);

    if (index >= 0) {

        mLibrary = mLibraryPathToOpenLibraryMap[index].promote();

    } else {

        index = mLibraryPathToOpenLibraryMap.add(path, NULL);

    }



    if (!mLibrary.get()) {

        mLibrary = new SharedLibrary(path);

        if (!*mLibrary) {

            ALOGE("loadLibraryForScheme failed:%s", mLibrary->lastError());

            return false;

        }



        mLibraryPathToOpenLibraryMap.replaceValueAt(index, mLibrary);

    }



    typedef CryptoFactory *(*CreateCryptoFactoryFunc)();



    CreateCryptoFactoryFunc createCryptoFactory =

        (CreateCryptoFactoryFunc)mLibrary->lookup("createCryptoFactory");



    if (createCryptoFactory == NULL ||

        (mFactory = createCryptoFactory()) == NULL ||

        !mFactory->isCryptoSchemeSupported(uuid)) {

        ALOGE("createCryptoFactory failed:%s", mLibrary->lastError());

        closeFactory();

        return false;

    }

    return true;

}



bool Crypto::isCryptoSchemeSupported(const uint8_t uuid[16]) {

    Mutex::Autolock autoLock(mLock);



    if (mFactory && mFactory->isCryptoSchemeSupported(uuid)) {

        return true;

    }



    findFactoryForScheme(uuid);

    return (mInitCheck == OK);

}



status_t Crypto::createPlugin(

        const uint8_t uuid[16], const void *data, size_t size) {

    Mutex::Autolock autoLock(mLock);



    if (mPlugin != NULL) {

        return -EINVAL;

    }



    if (!mFactory || !mFactory->isCryptoSchemeSupported(uuid)) {

        findFactoryForScheme(uuid);

    }



    if (mInitCheck != OK) {

        return mInitCheck;

    }



    return mFactory->createPlugin(uuid, data, size, &mPlugin);

}



status_t Crypto::destroyPlugin() {

    Mutex::Autolock autoLock(mLock);



    if (mInitCheck != OK) {

        return mInitCheck;

    }



    if (mPlugin == NULL) {

        return -EINVAL;

    }



    delete mPlugin;

    mPlugin = NULL;



    return OK;

}



bool Crypto::requiresSecureDecoderComponent(const char *mime) const {

    Mutex::Autolock autoLock(mLock);



    if (mInitCheck != OK) {

        return mInitCheck;

    }



    if (mPlugin == NULL) {

        return -EINVAL;

    }



    return mPlugin->requiresSecureDecoderComponent(mime);

}



ssize_t Crypto::decrypt(const uint8_t key[16], const uint8_t iv[16],

        CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,

        const sp<IMemory> &source, size_t offset,

        const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,

        const ICrypto::DestinationBuffer &destination, AString *errorDetailMsg) {



    Mutex::Autolock autoLock(mLock);



    if (mInitCheck != OK) {

        return mInitCheck;

    }



    if (mPlugin == NULL) {

        return -EINVAL;

    }



    const void *srcPtr = static_cast<uint8_t *>(source->pointer()) + offset;



    void *destPtr;

    bool secure = false;

    if (destination.mType == kDestinationTypeNativeHandle) {

        destPtr = static_cast<void *>(destination.mHandle);

        secure = true;

    } else {

        destPtr = destination.mSharedMemory->pointer();

    }



    ssize_t result = mPlugin->decrypt(secure, key, iv, mode, pattern, srcPtr, subSamples,

            numSubSamples, destPtr, errorDetailMsg);



    return result;

}



void Crypto::notifyResolution(uint32_t width, uint32_t height) {

    Mutex::Autolock autoLock(mLock);



    if (mInitCheck == OK && mPlugin != NULL) {

        mPlugin->notifyResolution(width, height);

    }

}



status_t Crypto::setMediaDrmSession(const Vector<uint8_t> &sessionId) {

    Mutex::Autolock autoLock(mLock);



    status_t result = NO_INIT;

    if (mInitCheck == OK && mPlugin != NULL) {

        result = mPlugin->setMediaDrmSession(sessionId);

    }

    return result;

}



}  // namespace android

drm/libmediadrm/Drm.cpp

deleted100644 → 0
+0 −799

File deleted.

Preview size limit exceeded, changes collapsed.

services/mediadrm/Android.mk

+1 −7
Original line number Diff line number Diff line
@@ -25,19 +25,13 @@ LOCAL_SHARED_LIBRARIES:= \ 
    libbinder \

    liblog \

    libmediadrm \

    libutils

ifneq ($(DISABLE_TREBLE_DRM), true)

LOCAL_SHARED_LIBRARIES += \

    libutils \

    libhidlbase \

    libhidlmemory \

    android.hidl.base@1.0 \

    android.hardware.drm@1.0

endif



LOCAL_CFLAGS += -Wall -Wextra -Werror

ifeq ($(DISABLE_TREBLE_DRM), true)

LOCAL_CFLAGS += -DDISABLE_TREBLE_DRM=1

endif



LOCAL_MODULE:= mediadrmserver

services/mediadrm/MediaDrmService.cpp

+0 −13
Original line number Diff line number Diff line
@@ -24,13 +24,8 @@ 
#include <binder/IServiceManager.h>

#include <utils/Log.h>



#ifdef DISABLE_TREBLE_DRM

#include <media/Crypto.h>

#include <media/Drm.h>

#else

#include <media/CryptoHal.h>

#include <media/DrmHal.h>

#endif



namespace android {
@@ -40,19 +35,11 @@ void MediaDrmService::instantiate() { 
}



sp<ICrypto> MediaDrmService::makeCrypto() {

#ifdef DISABLE_TREBLE_DRM

    return new Crypto;

#else

    return new CryptoHal;

#endif

}



sp<IDrm> MediaDrmService::makeDrm() {

#ifdef DISABLE_TREBLE_DRM

    return new Drm;

#else

    return new DrmHal;

#endif

}



} // namespace android