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

Commit 9a33bb2b authored by Jeff Tinker's avatar Jeff Tinker
Browse files

Revert "Enable loading of treble-based plugins" 

bug:35329920

Tests: Verfied playback on Ryu with Play Movies in combination with
ag/1907708, ag/1909159

This reverts commit fbf36503.

Change-Id: I4a35a329b24e4cd9efcff4fe84e9d8901c714d57
parent 7ddf7abf

drm/1.0/default/CryptoFactory.cpp

+32 −51
Original line number Diff line number Diff line
@@ -15,11 +15,10 @@ 
 */

#define LOG_TAG "android.hardware.drm@1.0-impl"



#include <utils/Log.h>



#include "CryptoFactory.h"

#include "CryptoPlugin.h"

#include "TypeConvert.h"

#include <utils/Log.h>



namespace android {

namespace hardware {
@@ -28,58 +27,40 @@ namespace V1_0 { 
namespace implementation {



    CryptoFactory::CryptoFactory() :

    trebleLoader("/vendor/lib/hw", "createCryptoFactory"),

    legacyLoader("/vendor/lib/mediadrm", "createCryptoFactory") {

        loader("/vendor/lib/mediadrm", "createCryptoFactory") {

    }



    // Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.

    Return<bool> CryptoFactory::isCryptoSchemeSupported(

            const hidl_array<uint8_t, 16>& uuid) {

    return isCryptoSchemeSupported(trebleLoader, uuid) ||

            isCryptoSchemeSupported(legacyLoader, uuid);

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {

                return true;

            }

        }

        return false;

    }



    Return<void> CryptoFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,

            const hidl_vec<uint8_t>& initData, createPlugin_cb _hidl_cb) {

    sp<ICryptoPlugin> plugin = createTreblePlugin(uuid, initData);

    if (plugin == nullptr) {

        plugin = createLegacyPlugin(uuid, initData);

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {

                android::CryptoPlugin *legacyPlugin = NULL;

                status_t status = loader.getFactory(i)->createPlugin(uuid.data(),

                        initData.data(), initData.size(), &legacyPlugin);

                CryptoPlugin *newPlugin = NULL;

                if (legacyPlugin == NULL) {

                    ALOGE("Crypto legacy HAL: failed to create crypto plugin");

                } else {

                    newPlugin = new CryptoPlugin(legacyPlugin);

                }

    _hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);

                _hidl_cb(toStatus(status), newPlugin);

                return Void();

            }



sp<ICryptoPlugin> CryptoFactory::createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,

        const hidl_vec<uint8_t>& initData) {

    sp<ICryptoPlugin> plugin;

    for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {

        Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid, initData,

                [&](Status status, const sp<ICryptoPlugin>& hPlugin) {

                    if (status == Status::OK) {

                        plugin = hPlugin;

                    }

                }

            );

        if (plugin != nullptr) {

            return plugin;

        }

        _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);

        return Void();

    }

    return nullptr;

}



sp<ICryptoPlugin> CryptoFactory::createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid,

        const hidl_vec<uint8_t>& initData) {

    android::CryptoPlugin *legacyPlugin = nullptr;

    for (size_t i = 0; i < legacyLoader.factoryCount(); i++) {

        legacyLoader.getFactory(i)->createPlugin(uuid.data(),

                initData.data(), initData.size(), &legacyPlugin);

        if (legacyPlugin) {

            return new CryptoPlugin(legacyPlugin);

        }

    }

    return nullptr;

}





    ICryptoFactory* HIDL_FETCH_ICryptoFactory(const char* /* name */) {

        return new CryptoFactory();

drm/1.0/default/CryptoFactory.h

+3 −22
Original line number Diff line number Diff line
@@ -41,7 +41,8 @@ struct CryptoFactory : public ICryptoFactory { 
    CryptoFactory();

    virtual ~CryptoFactory() {}



    // Methods from ::android::hardware::drmn::V1_0::ICryptoFactory follow.

    // Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.



    Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)

            override;
@@ -50,27 +51,7 @@ struct CryptoFactory : public ICryptoFactory { 
            override;



private:

    template <typename L> Return<bool> isCryptoSchemeSupported(

            const L& loader, const hidl_array<uint8_t, 16>& uuid) {

        for (size_t i = 0; i < loader.factoryCount(); i++) {

           if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {

                return true;

            }

        }

        return false;

    }



    sp<ICryptoPlugin> createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,

                    const hidl_vec<uint8_t>& initData);



    sp<ICryptoPlugin> createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid,

                    const hidl_vec<uint8_t>& initData);



    typedef android::PluginLoader<ICryptoFactory> PluginLoader;

    PluginLoader trebleLoader;



    typedef android::PluginLoader<android::CryptoFactory> LegacyLoader;

    LegacyLoader legacyLoader;

    android::PluginLoader<android::CryptoFactory> loader;



    CryptoFactory(const CryptoFactory &) = delete;

    void operator=(const CryptoFactory &) = delete;

drm/1.0/default/DrmFactory.cpp

+40 −51
Original line number Diff line number Diff line
@@ -15,11 +15,10 @@ 
 */

#define LOG_TAG "android.hardware.drm@1.0-impl"



#include <utils/Log.h>



#include "DrmFactory.h"

#include "DrmPlugin.h"

#include "TypeConvert.h"

#include <utils/Log.h>



namespace android {

namespace hardware {
@@ -28,60 +27,50 @@ namespace V1_0 { 
namespace implementation {



    DrmFactory::DrmFactory() :

    trebleLoader("/vendor/lib/hw", "createDrmFactory"),

    legacyLoader("/vendor/lib/mediadrm", "createDrmFactory") {

        loader("/vendor/lib/mediadrm", "createDrmFactory") {

    }



    // Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.

    Return<bool> DrmFactory::isCryptoSchemeSupported (

            const hidl_array<uint8_t, 16>& uuid) {

    return isCryptoSchemeSupported(trebleLoader, uuid) ||

            isCryptoSchemeSupported(legacyLoader, uuid);

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {

                return true;

            }

        }

        return false;

    }



    Return<bool> DrmFactory::isContentTypeSupported (

            const hidl_string& mimeType) {

    return isContentTypeSupported<PluginLoader, hidl_string>(trebleLoader, mimeType) ||

            isContentTypeSupported<LegacyLoader, String8>(legacyLoader, mimeType);

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isContentTypeSupported(String8(mimeType.c_str()))) {

                return true;

            }

        }

        return false;

    }



    Return<void> DrmFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,

            const hidl_string& appPackageName, createPlugin_cb _hidl_cb) {

        sp<IDrmPlugin> plugin = createTreblePlugin(uuid, appPackageName);

    if (plugin == nullptr) {

        plugin = createLegacyPlugin(uuid);

    }

    _hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);

    return Void();

}



sp<IDrmPlugin> DrmFactory::createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,

        const hidl_string& appPackageName) {

    sp<IDrmPlugin> plugin;

    for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {

        Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid,

                appPackageName, [&](Status status, const sp<IDrmPlugin>& hPlugin) {

                    if (status == Status::OK) {

                        plugin = hPlugin;

                    }

                }

            );

        if (plugin != nullptr) {

            return plugin;

        }

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {

                android::DrmPlugin *legacyPlugin = NULL;

                status_t status = loader.getFactory(i)->createDrmPlugin(

                        uuid.data(), &legacyPlugin);

                DrmPlugin *newPlugin = NULL;

                if (legacyPlugin == NULL) {

                    ALOGE("Drm legacy HAL: failed to create drm plugin");

                } else {

                    newPlugin = new DrmPlugin(legacyPlugin);

                }

    return nullptr;

}



sp<IDrmPlugin> DrmFactory::createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid) {

    android::DrmPlugin *legacyPlugin = nullptr;

    for (size_t i = 0; i < legacyLoader.factoryCount(); i++) {

        legacyLoader.getFactory(i)->createDrmPlugin(uuid.data(), &legacyPlugin);

        if (legacyPlugin) {

            return new DrmPlugin(legacyPlugin);

                _hidl_cb(toStatus(status), newPlugin);

                return Void();

            }

        }

    return nullptr;

        _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);

        return Void();

    }



    IDrmFactory* HIDL_FETCH_IDrmFactory(const char* /* name */) {

drm/1.0/default/DrmFactory.h

+3 −30
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ struct DrmFactory : public IDrmFactory { 
    virtual ~DrmFactory() {}



    // Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.



    Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)

            override;
@@ -52,35 +53,7 @@ struct DrmFactory : public IDrmFactory { 
            const hidl_string& appPackageName, createPlugin_cb _hidl_cb) override;



private:

    template <typename L> Return<bool> isCryptoSchemeSupported(

            const L& loader, const hidl_array<uint8_t, 16>& uuid) {

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isCryptoSchemeSupported(uuid.data())) {

                return true;

            }

        }

        return false;

    }



    template <typename L, typename S> Return<bool> isContentTypeSupported(

            const L& loader, const hidl_string& mimeType) {

        for (size_t i = 0; i < loader.factoryCount(); i++) {

            if (loader.getFactory(i)->isContentTypeSupported(S(mimeType))) {

                return true;

            }

        }

        return false;

    }



    sp<IDrmPlugin> createTreblePlugin(const hidl_array<uint8_t, 16>& uuid,

        const hidl_string& appPackageName);

    sp<IDrmPlugin> createLegacyPlugin(const hidl_array<uint8_t, 16>& uuid);



    typedef android::PluginLoader<IDrmFactory> PluginLoader;

    PluginLoader trebleLoader;



    typedef android::PluginLoader<android::DrmFactory> LegacyLoader;

    LegacyLoader legacyLoader;

    android::PluginLoader<android::DrmFactory> loader;



    DrmFactory(const DrmFactory &) = delete;

    void operator=(const DrmFactory &) = delete;