Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:50:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "Enable loading of treble-based plugins"

Browse Source
This commit is contained in:
Jeff Tinker
2017-01-28 01:22:18 +00:00
committed by Android (Google) Code Review
parent 3935f20ce1 fbf3650370
commit d4c3cbcc38
4 changed files with 158 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
drm/1.0/default/CryptoFactory.cpp
View File

@@ -15,10 +15,11 @@
*/
#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 {
@@ -26,45 +27,63 @@ namespace drm {
namespace V1_0 {
namespace implementation {
CryptoFactory::CryptoFactory() :
loader("/vendor/lib/mediadrm", "createCryptoFactory") {
}
CryptoFactory::CryptoFactory() :
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;
}
// 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);
}
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);
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);
}
_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(toStatus(status), newPlugin);
return Void();
}
);
if (plugin != nullptr) {
return plugin;
}
_hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
return Void();
}
return nullptr;
}
ICryptoFactory* HIDL_FETCH_ICryptoFactory(const char* /* name */) {
return new CryptoFactory();
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();
}
} // namespace implementation
} // namespace V1_0

25
drm/1.0/default/CryptoFactory.h
View File

@@ -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;

98
drm/1.0/default/DrmFactory.cpp
View File

@@ -15,10 +15,11 @@
*/
#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 {
@@ -26,56 +27,65 @@ namespace drm {
namespace V1_0 {
namespace implementation {
DrmFactory::DrmFactory() :
loader("/vendor/lib/mediadrm", "createDrmFactory") {
DrmFactory::DrmFactory() :
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) {
return isCryptoSchemeSupported(trebleLoader, uuid) ||
isCryptoSchemeSupported(legacyLoader, uuid);
}
Return<bool> DrmFactory::isContentTypeSupported (
const hidl_string& mimeType) {
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) {
sp<IDrmPlugin> plugin = createTreblePlugin(uuid);
if (plugin == nullptr) {
plugin = createLegacyPlugin(uuid);
}
_hidl_cb(plugin != nullptr ? Status::OK : Status::ERROR_DRM_CANNOT_HANDLE, plugin);
return Void();
}
// 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<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<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> 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(toStatus(status), newPlugin);
return Void();
}
);
if (plugin != nullptr) {
return plugin;
}
_hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, NULL);
return Void();
}
return nullptr;
}
IDrmFactory* HIDL_FETCH_IDrmFactory(const char* /* name */) {
return new DrmFactory();
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 */) {
return new DrmFactory();
}
} // namespace implementation
} // namespace V1_0

35
drm/1.0/default/DrmFactory.h
View File

@@ -42,18 +42,43 @@ 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;
Return<bool> isContentTypeSupported(const hidl_string &mimeType)
Return<bool> isContentTypeSupported(const hidl_string& mimeType)
override;
Return<void> createPlugin(const hidl_array<uint8_t, 16>& uuid,
createPlugin_cb _hidl_cb) override;
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;