Enable loading of treble-based plugins (fbf36503) · Commits · e / os / android_hardware_interfaces

drm/1.0/default/CryptoFactory.cpp

+51 −32

Original line number	Diff line number	Diff line
		@@ -14,10 +14,11 @@
		* limitations under the License.
		*/

		#include <utils/Log.h>

		#include "CryptoFactory.h"
		#include "CryptoPlugin.h"
		#include "TypeConvert.h"
		#include <utils/Log.h>

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

		CryptoFactory::CryptoFactory() :
		loader("/vendor/lib/mediadrm", "createCryptoFactory") {
		trebleLoader("/vendor/lib/hw", "createCryptoFactory"),
		legacyLoader("/vendor/lib/mediadrm", "createCryptoFactory") {
		}

		// Methods from ::android::hardware::drm::V1_0::ICryptoFactory follow.
		Return<bool> CryptoFactory::isCryptoSchemeSupported(
		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;
		return isCryptoSchemeSupported(trebleLoader, uuid) \|\|
		isCryptoSchemeSupported(legacyLoader, uuid);
		}

		Return<void> CryptoFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
		const hidl_vec<uint8_t>& initData, createPlugin_cb _hidl_cb) {
		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);
		sp<ICryptoPlugin> plugin = createTreblePlugin(uuid, initData);
		if (plugin == nullptr) {
		plugin = createLegacyPlugin(uuid, initData);
		}
		_hidl_cb(toStatus(status), newPlugin);
		_hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);
		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;
		}
		}
		_hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
		return Void();
		);
		if (plugin != nullptr) {
		return plugin;
		}
		}
		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

+22 −3

Original line number	Diff line number	Diff line
		@@ -41,8 +41,7 @@ struct CryptoFactory : public ICryptoFactory {
		CryptoFactory();
		virtual ~CryptoFactory() {}

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

		// Methods from ::android::hardware::drmn::V1_0::ICryptoFactory follow.
		Return<bool> isCryptoSchemeSupported(const hidl_array<uint8_t, 16>& uuid)
		override;

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

		private:
		android::PluginLoader<android::CryptoFactory> loader;
		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;

		CryptoFactory(const CryptoFactory &) = delete;
		void operator=(const CryptoFactory &) = delete;

drm/1.0/default/DrmFactory.cpp

+52 −42

Original line number	Diff line number	Diff line
		@@ -14,10 +14,11 @@
		* limitations under the License.
		*/

		#include <utils/Log.h>

		#include "DrmFactory.h"
		#include "DrmPlugin.h"
		#include "TypeConvert.h"
		#include <utils/Log.h>

		namespace android {
		namespace hardware {
		@@ -26,50 +27,59 @@ namespace V1_0 {
		namespace implementation {

		DrmFactory::DrmFactory() :
		loader("/vendor/lib/mediadrm", "createDrmFactory") {
		trebleLoader("/vendor/lib/hw", "createDrmFactory"),
		legacyLoader("/vendor/lib/mediadrm", "createDrmFactory") {
		}

		// Methods from ::android::hardware::drm::V1_0::IDrmFactory follow.
		Return<bool> DrmFactory::isCryptoSchemeSupported(
		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;
		return isCryptoSchemeSupported(trebleLoader, uuid) \|\|
		isCryptoSchemeSupported(legacyLoader, uuid);
		}

		Return<bool> DrmFactory::isContentTypeSupported (
		const hidl_string& mimeType) {
		for (size_t i = 0; i < loader.factoryCount(); i++) {
		if (loader.getFactory(i)->isContentTypeSupported(String8(mimeType.c_str()))) {
		return true;
		}
		}
		return false;
		return isContentTypeSupported<PluginLoader, hidl_string>(trebleLoader, mimeType) \|\|
		isContentTypeSupported<LegacyLoader, String8>(legacyLoader, mimeType);
		}

		Return<void> DrmFactory::createPlugin(const hidl_array<uint8_t, 16>& uuid,
		createPlugin_cb _hidl_cb) {

		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);
		sp<IDrmPlugin> plugin = createTreblePlugin(uuid);
		if (plugin == nullptr) {
		plugin = createLegacyPlugin(uuid);
		}
		_hidl_cb(toStatus(status), newPlugin);
		_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) {
		sp<IDrmPlugin> plugin;
		for (size_t i = 0; i < trebleLoader.factoryCount(); i++) {
		Return<void> hResult = trebleLoader.getFactory(i)->createPlugin(uuid,
		[&](Status status, const sp<IDrmPlugin>& hPlugin) {
		if (status == Status::OK) {
		plugin = hPlugin;
		}
		_hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
		return Void();
		}
		);
		if (plugin != nullptr) {
		return plugin;
		}
		}
		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);
		}
		}
		return nullptr;
		}

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

drm/1.0/default/DrmFactory.h

+30 −5

Original line number	Diff line number	Diff line
		@@ -42,7 +42,6 @@ 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;

		@@ -51,9 +50,35 @@ struct DrmFactory : public IDrmFactory {

		Return<void> createPlugin(const hidl_array<uint8_t, 16>& uuid,
		createPlugin_cb _hidl_cb) override;

		private:
		android::PluginLoader<android::DrmFactory> loader;
		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);
		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;

		DrmFactory(const DrmFactory &) = delete;
		void operator=(const DrmFactory &) = delete;