Merge "libmediadrm: refactor bundle dependency" (0564f530) · Commits · e / os / android_frameworks_av

drm/libmediadrm/Android.bp

+22 −4

Original line number	Diff line number	Diff line
		@@ -95,8 +95,6 @@ cc_library_shared {
		"android.hardware.drm@1.0",
		"android.hardware.drm@1.1",
		"android.hardware.drm@1.2",
		"libbinder",
		"libhidlbase",
		"liblog",
		"libmediametrics",
		"libprotobuf-cpp-lite",
		@@ -134,8 +132,6 @@ cc_library_shared {
		"android.hardware.drm@1.1",
		"android.hardware.drm@1.2",
		"libbase",
		"libbinder",
		"libhidlbase",
		"liblog",
		"libmediametrics",
		"libprotobuf-cpp-full",
		@@ -149,3 +145,25 @@ cc_library_shared {
		],
		}

		cc_library_shared {
		name: "libmediadrmmetrics_consumer",
		srcs: [
		"DrmMetricsConsumer.cpp",
		],

		include_dirs: [
		"frameworks/av/media/libmedia/include"
		],

		shared_libs: [
		"android.hardware.drm@1.0",
		"android.hardware.drm@1.1",
		"android.hardware.drm@1.2",
		"libbinder",
		"libhidlbase",
		"liblog",
		"libmediadrm",
		"libmediadrmmetrics_full",
		"libutils",
		],
		}

drm/libmediadrm/DrmHal.cpp

+5 −8

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@
		#include <mediadrm/DrmHal.h>
		#include <mediadrm/DrmSessionClientInterface.h>
		#include <mediadrm/DrmSessionManager.h>
		#include <mediadrm/IDrmMetricsConsumer.h>

		#include <vector>

		@@ -1362,11 +1363,11 @@ status_t DrmHal::setPropertyByteArray(String8 const &name,
		return status.isOk() ? toStatusT(status) : DEAD_OBJECT;
		}

		status_t DrmHal::getMetrics(PersistableBundle* metrics) {
		if (metrics == nullptr) {
		status_t DrmHal::getMetrics(const sp<IDrmMetricsConsumer> &consumer) {
		if (consumer == nullptr) {
		return UNEXPECTED_NULL;
		}
		mMetrics.Export(metrics);
		consumer->consumeFrameworkMetrics(mMetrics);

		// Append vendor metrics if they are supported.
		if (mPluginV1_1 != NULL) {
		@@ -1393,11 +1394,7 @@ status_t DrmHal::getMetrics(PersistableBundle* metrics) {
		if (status != Status::OK) {
		ALOGV("Error getting plugin metrics: %d", status);
		} else {
		PersistableBundle pluginBundle;
		if (MediaDrmMetrics::HidlMetricsToBundle(
		pluginMetrics, &pluginBundle) == OK) {
		metrics->putPersistableBundle(String16(vendor), pluginBundle);
		}
		consumer->consumeHidlMetrics(vendor, pluginMetrics);
		}
		err = toStatusT(status);
		});

drm/libmediadrm/DrmMetrics.cpp

+4 −225

Original line number	Diff line number	Diff line
		@@ -29,143 +29,12 @@
		using ::android::String16;
		using ::android::String8;
		using ::android::drm_metrics::DrmFrameworkMetrics;
		using ::android::hardware::hidl_string;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::drm::V1_0::EventType;
		using ::android::hardware::drm::V1_2::KeyStatusType;
		using ::android::hardware::drm::V1_1::DrmMetricGroup;
		using ::android::os::PersistableBundle;

		namespace {

		template <typename T> std::string GetAttributeName(T type);

		template <> std::string GetAttributeName<KeyStatusType>(KeyStatusType type) {
		static const char *type_names[] = {"USABLE", "EXPIRED",
		"OUTPUT_NOT_ALLOWED", "STATUS_PENDING",
		"INTERNAL_ERROR"};
		if (((size_t)type) > arraysize(type_names)) {
		return "UNKNOWN_TYPE";
		}
		return type_names[(size_t)type];
		}

		template <> std::string GetAttributeName<EventType>(EventType type) {
		static const char *type_names[] = {"PROVISION_REQUIRED", "KEY_NEEDED",
		"KEY_EXPIRED", "VENDOR_DEFINED",
		"SESSION_RECLAIMED"};
		if (((size_t)type) > arraysize(type_names)) {
		return "UNKNOWN_TYPE";
		}
		return type_names[(size_t)type];
		}

		template <typename T>
		void ExportCounterMetric(const android::CounterMetric<T> &counter,
		PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		std::string success_count_name = counter.metric_name() + ".ok.count";
		std::string error_count_name = counter.metric_name() + ".error.count";
		std::vector<int64_t> status_values;
		counter.ExportValues(
		[&](const android::status_t status, const int64_t value) {
		if (status == android::OK) {
		metrics->putLong(android::String16(success_count_name.c_str()),
		value);
		} else {
		int64_t total_errors(0);
		metrics->getLong(android::String16(error_count_name.c_str()),
		&total_errors);
		metrics->putLong(android::String16(error_count_name.c_str()),
		total_errors + value);
		status_values.push_back(status);
		}
		});
		if (!status_values.empty()) {
		std::string error_list_name = counter.metric_name() + ".error.list";
		metrics->putLongVector(android::String16(error_list_name.c_str()),
		status_values);
		}
		}

		template <typename T>
		void ExportCounterMetricWithAttributeNames(
		const android::CounterMetric<T> &counter, PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		counter.ExportValues([&](const T &attribute, const int64_t value) {
		std::string name = counter.metric_name() + "." +
		GetAttributeName(attribute) + ".count";
		metrics->putLong(android::String16(name.c_str()), value);
		});
		}

		template <typename T>
		void ExportEventMetric(const android::EventMetric<T> &event,
		PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		std::string success_count_name = event.metric_name() + ".ok.count";
		std::string error_count_name = event.metric_name() + ".error.count";
		std::string timing_name = event.metric_name() + ".ok.average_time_micros";
		std::vector<int64_t> status_values;
		event.ExportValues([&](const android::status_t &status,
		const android::EventStatistics &value) {
		if (status == android::OK) {
		metrics->putLong(android::String16(success_count_name.c_str()),
		value.count);
		metrics->putLong(android::String16(timing_name.c_str()),
		value.mean);
		} else {
		int64_t total_errors(0);
		metrics->getLong(android::String16(error_count_name.c_str()),
		&total_errors);
		metrics->putLong(android::String16(error_count_name.c_str()),
		total_errors + value.count);
		status_values.push_back(status);
		}
		});
		if (!status_values.empty()) {
		std::string error_list_name = event.metric_name() + ".error.list";
		metrics->putLongVector(android::String16(error_list_name.c_str()),
		status_values);
		}
		}

		void ExportSessionLifespans(
		const std::map<std::string, std::pair<int64_t, int64_t>> &mSessionLifespans,
		PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}

		if (mSessionLifespans.empty()) {
		return;
		}

		PersistableBundle startTimesBundle;
		PersistableBundle endTimesBundle;
		for (auto it = mSessionLifespans.begin(); it != mSessionLifespans.end();
		it++) {
		String16 key(it->first.c_str(), it->first.size());
		startTimesBundle.putLong(key, it->second.first);
		endTimesBundle.putLong(key, it->second.second);
		}
		metrics->putPersistableBundle(
		android::String16("drm.mediadrm.session_start_times_ms"),
		startTimesBundle);
		metrics->putPersistableBundle(
		android::String16("drm.mediadrm.session_end_times_ms"), endTimesBundle);
		}

		std::string ToHexString(const android::Vector<uint8_t> &sessionId) {
		std::ostringstream out;
		out << std::hex << std::setfill('0');
		@@ -175,31 +44,6 @@ std::string ToHexString(const android::Vector<uint8_t> &sessionId) {
		return out.str();
		}

		template <typename CT>
		void SetValue(const String16 &name, DrmMetricGroup::ValueType type,
		const CT &value, PersistableBundle *bundle) {
		switch (type) {
		case DrmMetricGroup::ValueType::INT64_TYPE:
		bundle->putLong(name, value.int64Value);
		break;
		case DrmMetricGroup::ValueType::DOUBLE_TYPE:
		bundle->putDouble(name, value.doubleValue);
		break;
		case DrmMetricGroup::ValueType::STRING_TYPE:
		bundle->putString(name, String16(value.stringValue.c_str()));
		break;
		default:
		ALOGE("Unexpected value type: %hhu", type);
		}
		}

		inline String16 MakeIndexString(unsigned int index) {
		std::string str("[");
		str.append(std::to_string(index));
		str.append("]");
		return String16(str.c_str());
		}

		} // namespace

		namespace android {
		@@ -237,23 +81,6 @@ void MediaDrmMetrics::SetSessionEnd(const android::Vector<uint8_t> &sessionId) {
		}
		}

		void MediaDrmMetrics::Export(PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		ExportCounterMetric(mOpenSessionCounter, metrics);
		ExportCounterMetric(mCloseSessionCounter, metrics);
		ExportEventMetric(mGetKeyRequestTimeUs, metrics);
		ExportEventMetric(mProvideKeyResponseTimeUs, metrics);
		ExportCounterMetric(mGetProvisionRequestCounter, metrics);
		ExportCounterMetric(mProvideProvisionResponseCounter, metrics);
		ExportCounterMetricWithAttributeNames(mKeyStatusChangeCounter, metrics);
		ExportCounterMetricWithAttributeNames(mEventCounter, metrics);
		ExportCounterMetric(mGetDeviceUniqueIdCounter, metrics);
		ExportSessionLifespans(mSessionLifespans, metrics);
		}

		status_t MediaDrmMetrics::GetSerializedMetrics(std::string *serializedMetrics) {

		if (!serializedMetrics) {
		@@ -361,62 +188,14 @@ status_t MediaDrmMetrics::GetSerializedMetrics(std::string *serializedMetrics) {
		return OK;
		}

		std::map<std::string, std::pair<int64_t, int64_t>> MediaDrmMetrics::GetSessionLifespans() const {
		return mSessionLifespans;
		}

		int64_t MediaDrmMetrics::GetCurrentTimeMs() {
		struct timeval tv;
		gettimeofday(&tv, NULL);
		return ((int64_t)tv.tv_sec * 1000) + ((int64_t)tv.tv_usec / 1000);
		}

		status_t MediaDrmMetrics::HidlMetricsToBundle(
		const hidl_vec<DrmMetricGroup> &hidlMetricGroups,
		PersistableBundle *bundleMetricGroups) {
		if (bundleMetricGroups == nullptr) {
		return UNEXPECTED_NULL;
		}
		if (hidlMetricGroups.size() == 0) {
		return OK;
		}

		int groupIndex = 0;
		std::map<String16, int> indexMap;
		for (const auto &hidlMetricGroup : hidlMetricGroups) {
		PersistableBundle bundleMetricGroup;
		for (const auto &hidlMetric : hidlMetricGroup.metrics) {
		String16 metricName(hidlMetric.name.c_str());
		PersistableBundle bundleMetric;
		// Add metric component values.
		for (const auto &value : hidlMetric.values) {
		SetValue(String16(value.componentName.c_str()), value.type,
		value, &bundleMetric);
		}
		// Set metric attributes.
		PersistableBundle bundleMetricAttributes;
		for (const auto &attribute : hidlMetric.attributes) {
		SetValue(String16(attribute.name.c_str()), attribute.type,
		attribute, &bundleMetricAttributes);
		}
		// Add attributes to the bundle metric.
		bundleMetric.putPersistableBundle(String16("attributes"),
		bundleMetricAttributes);
		// Add one layer of indirection, allowing for repeated metric names.
		PersistableBundle repeatedMetrics;
		bundleMetricGroup.getPersistableBundle(metricName,
		&repeatedMetrics);
		int index = indexMap[metricName];
		repeatedMetrics.putPersistableBundle(MakeIndexString(index),
		bundleMetric);
		indexMap[metricName] = ++index;

		// Add the bundle metric to the group of metrics.
		bundleMetricGroup.putPersistableBundle(metricName,
		repeatedMetrics);
		}
		// Add the bundle metric group to the collection of groups.
		bundleMetricGroups->putPersistableBundle(MakeIndexString(groupIndex++),
		bundleMetricGroup);
		}

		return OK;
		}

		} // namespace android

drm/libmediadrm/DrmMetricsConsumer.cpp

0 → 100644

+270 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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_TAG "DrmMetricsConsumer"

		#include <android-base/macros.h>
		#include <mediadrm/DrmMetricsConsumer.h>
		#include <mediadrm/DrmMetrics.h>
		#include <utils/String8.h>
		#include <utils/String16.h>

		using ::android::String16;
		using ::android::String8;
		using ::android::hardware::hidl_string;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::drm::V1_0::EventType;
		using ::android::hardware::drm::V1_2::KeyStatusType;
		using ::android::hardware::drm::V1_1::DrmMetricGroup;
		using ::android::os::PersistableBundle;

		namespace {

		template <typename T> std::string GetAttributeName(T type);

		template <> std::string GetAttributeName<KeyStatusType>(KeyStatusType type) {
		static const char *type_names[] = {"USABLE", "EXPIRED",
		"OUTPUT_NOT_ALLOWED", "STATUS_PENDING",
		"INTERNAL_ERROR"};
		if (((size_t)type) > arraysize(type_names)) {
		return "UNKNOWN_TYPE";
		}
		return type_names[(size_t)type];
		}

		template <> std::string GetAttributeName<EventType>(EventType type) {
		static const char *type_names[] = {"PROVISION_REQUIRED", "KEY_NEEDED",
		"KEY_EXPIRED", "VENDOR_DEFINED",
		"SESSION_RECLAIMED"};
		if (((size_t)type) > arraysize(type_names)) {
		return "UNKNOWN_TYPE";
		}
		return type_names[(size_t)type];
		}

		template <typename T>
		void ExportCounterMetric(const android::CounterMetric<T> &counter,
		PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		std::string success_count_name = counter.metric_name() + ".ok.count";
		std::string error_count_name = counter.metric_name() + ".error.count";
		std::vector<int64_t> status_values;
		counter.ExportValues(
		[&](const android::status_t status, const int64_t value) {
		if (status == android::OK) {
		metrics->putLong(android::String16(success_count_name.c_str()),
		value);
		} else {
		int64_t total_errors(0);
		metrics->getLong(android::String16(error_count_name.c_str()),
		&total_errors);
		metrics->putLong(android::String16(error_count_name.c_str()),
		total_errors + value);
		status_values.push_back(status);
		}
		});
		if (!status_values.empty()) {
		std::string error_list_name = counter.metric_name() + ".error.list";
		metrics->putLongVector(android::String16(error_list_name.c_str()),
		status_values);
		}
		}

		template <typename T>
		void ExportCounterMetricWithAttributeNames(
		const android::CounterMetric<T> &counter, PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		counter.ExportValues([&](const T &attribute, const int64_t value) {
		std::string name = counter.metric_name() + "." +
		GetAttributeName(attribute) + ".count";
		metrics->putLong(android::String16(name.c_str()), value);
		});
		}

		template <typename T>
		void ExportEventMetric(const android::EventMetric<T> &event,
		PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}
		std::string success_count_name = event.metric_name() + ".ok.count";
		std::string error_count_name = event.metric_name() + ".error.count";
		std::string timing_name = event.metric_name() + ".ok.average_time_micros";
		std::vector<int64_t> status_values;
		event.ExportValues([&](const android::status_t &status,
		const android::EventStatistics &value) {
		if (status == android::OK) {
		metrics->putLong(android::String16(success_count_name.c_str()),
		value.count);
		metrics->putLong(android::String16(timing_name.c_str()),
		value.mean);
		} else {
		int64_t total_errors(0);
		metrics->getLong(android::String16(error_count_name.c_str()),
		&total_errors);
		metrics->putLong(android::String16(error_count_name.c_str()),
		total_errors + value.count);
		status_values.push_back(status);
		}
		});
		if (!status_values.empty()) {
		std::string error_list_name = event.metric_name() + ".error.list";
		metrics->putLongVector(android::String16(error_list_name.c_str()),
		status_values);
		}
		}

		void ExportSessionLifespans(
		const std::map<std::string, std::pair<int64_t, int64_t>> &sessionLifespans,
		PersistableBundle *metrics) {
		if (!metrics) {
		ALOGE("metrics was unexpectedly null.");
		return;
		}

		if (sessionLifespans.empty()) {
		return;
		}

		PersistableBundle startTimesBundle;
		PersistableBundle endTimesBundle;
		for (auto it = sessionLifespans.begin(); it != sessionLifespans.end();
		it++) {
		String16 key(it->first.c_str(), it->first.size());
		startTimesBundle.putLong(key, it->second.first);
		endTimesBundle.putLong(key, it->second.second);
		}
		metrics->putPersistableBundle(
		android::String16("drm.mediadrm.session_start_times_ms"),
		startTimesBundle);
		metrics->putPersistableBundle(
		android::String16("drm.mediadrm.session_end_times_ms"), endTimesBundle);
		}

		template <typename CT>
		void SetValue(const String16 &name, DrmMetricGroup::ValueType type,
		const CT &value, PersistableBundle *bundle) {
		switch (type) {
		case DrmMetricGroup::ValueType::INT64_TYPE:
		bundle->putLong(name, value.int64Value);
		break;
		case DrmMetricGroup::ValueType::DOUBLE_TYPE:
		bundle->putDouble(name, value.doubleValue);
		break;
		case DrmMetricGroup::ValueType::STRING_TYPE:
		bundle->putString(name, String16(value.stringValue.c_str()));
		break;
		default:
		ALOGE("Unexpected value type: %hhu", type);
		}
		}

		inline String16 MakeIndexString(unsigned int index) {
		std::string str("[");
		str.append(std::to_string(index));
		str.append("]");
		return String16(str.c_str());
		}

		} // namespace

		namespace android {

		status_t DrmMetricsConsumer::consumeFrameworkMetrics(const MediaDrmMetrics &metrics) {
		ExportCounterMetric(metrics.mOpenSessionCounter, mBundle);
		ExportCounterMetric(metrics.mCloseSessionCounter, mBundle);
		ExportEventMetric(metrics.mGetKeyRequestTimeUs, mBundle);
		ExportEventMetric(metrics.mProvideKeyResponseTimeUs, mBundle);
		ExportCounterMetric(metrics.mGetProvisionRequestCounter, mBundle);
		ExportCounterMetric(metrics.mProvideProvisionResponseCounter, mBundle);
		ExportCounterMetricWithAttributeNames(metrics.mKeyStatusChangeCounter, mBundle);
		ExportCounterMetricWithAttributeNames(metrics.mEventCounter, mBundle);
		ExportCounterMetric(metrics.mGetDeviceUniqueIdCounter, mBundle);
		ExportSessionLifespans(metrics.GetSessionLifespans(), mBundle);
		return android::OK;
		}

		status_t DrmMetricsConsumer::consumeHidlMetrics(
		const String8 &vendor,
		const hidl_vec<DrmMetricGroup> &pluginMetrics) {
		PersistableBundle pluginBundle;
		if (DrmMetricsConsumer::HidlMetricsToBundle(
		pluginMetrics, &pluginBundle) == OK) {
		mBundle->putPersistableBundle(String16(vendor), pluginBundle);
		}
		return android::OK;
		}

		status_t DrmMetricsConsumer::HidlMetricsToBundle(
		const hidl_vec<DrmMetricGroup> &hidlMetricGroups,
		PersistableBundle *bundleMetricGroups) {
		if (bundleMetricGroups == nullptr) {
		return UNEXPECTED_NULL;
		}
		if (hidlMetricGroups.size() == 0) {
		return OK;
		}

		int groupIndex = 0;
		std::map<String16, int> indexMap;
		for (const auto &hidlMetricGroup : hidlMetricGroups) {
		PersistableBundle bundleMetricGroup;
		for (const auto &hidlMetric : hidlMetricGroup.metrics) {
		String16 metricName(hidlMetric.name.c_str());
		PersistableBundle bundleMetric;
		// Add metric component values.
		for (const auto &value : hidlMetric.values) {
		SetValue(String16(value.componentName.c_str()), value.type,
		value, &bundleMetric);
		}
		// Set metric attributes.
		PersistableBundle bundleMetricAttributes;
		for (const auto &attribute : hidlMetric.attributes) {
		SetValue(String16(attribute.name.c_str()), attribute.type,
		attribute, &bundleMetricAttributes);
		}
		// Add attributes to the bundle metric.
		bundleMetric.putPersistableBundle(String16("attributes"),
		bundleMetricAttributes);
		// Add one layer of indirection, allowing for repeated metric names.
		PersistableBundle repeatedMetrics;
		bundleMetricGroup.getPersistableBundle(metricName,
		&repeatedMetrics);
		int index = indexMap[metricName];
		repeatedMetrics.putPersistableBundle(MakeIndexString(index),
		bundleMetric);
		indexMap[metricName] = ++index;

		// Add the bundle metric to the group of metrics.
		bundleMetricGroup.putPersistableBundle(metricName,
		repeatedMetrics);
		}
		// Add the bundle metric group to the collection of groups.
		bundleMetricGroups->putPersistableBundle(MakeIndexString(groupIndex++),
		bundleMetricGroup);
		}

		return OK;
		}

		} // namespace android

drm/libmediadrm/include/mediadrm/DrmHal.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#include <mediadrm/DrmSessionManager.h>
		#include <mediadrm/IDrm.h>
		#include <mediadrm/IDrmClient.h>
		#include <mediadrm/IDrmMetricsConsumer.h>
		#include <utils/threads.h>

		namespace drm = ::android::hardware::drm;
		@@ -136,7 +137,7 @@ struct DrmHal : public IDrm,
		virtual status_t setPropertyString(String8 const &name, String8 const &value ) const;
		virtual status_t setPropertyByteArray(String8 const &name,
		Vector<uint8_t> const &value ) const;
		virtual status_t getMetrics(os::PersistableBundle *metrics);
		virtual status_t getMetrics(const sp<IDrmMetricsConsumer> &consumer);

		virtual status_t setCipherAlgorithm(Vector<uint8_t> const &sessionId,
		String8 const &algorithm);