Merge "MediaMetricsService: Deliver Spatialization atoms to statsd" into tm-qpr-dev (72cb1621) · Commits · e / os / android_frameworks_av

media/libmediametrics/include/MediaMetricsConstants.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -111,6 +111,7 @@
		// of suppressed in the Time Machine.
		#define AMEDIAMETRICS_PROP_SUFFIX_CHAR_DUPLICATES_ALLOWED '#'

		#define AMEDIAMETRICS_PROP_ADDRESS "address" // string, for example MAC address
		#define AMEDIAMETRICS_PROP_ALLOWUID "_allowUid" // int32_t, allow client uid to post
		#define AMEDIAMETRICS_PROP_AUDIOMODE "audioMode" // string (audio.flinger)
		#define AMEDIAMETRICS_PROP_AUXEFFECTID "auxEffectId" // int32 (AudioTrack)
		@@ -120,6 +121,8 @@
		#define AMEDIAMETRICS_PROP_CALLERNAME "callerName" // string, eg. "aaudio"
		#define AMEDIAMETRICS_PROP_CHANNELCOUNT "channelCount" // int32
		#define AMEDIAMETRICS_PROP_CHANNELMASK "channelMask" // int32
		#define AMEDIAMETRICS_PROP_CHANNELMASKS "channelMasks" // string with channelMask values
		// separated by \|.
		#define AMEDIAMETRICS_PROP_CONTENTTYPE "contentType" // string attributes (AudioTrack)
		#define AMEDIAMETRICS_PROP_CUMULATIVETIMENS "cumulativeTimeNs" // int64_t playback/record time
		// since start

services/audiopolicy/service/Spatializer.cpp

+11 −1

Original line number	Diff line number	Diff line
		@@ -274,6 +274,16 @@ Spatializer::~Spatializer() {
		mHandler.clear();
		}

		static std::string channelMaskVectorToString(
		const std::vector<audio_channel_mask_t>& masks) {
		std::stringstream ss;
		for (const auto &mask : masks) {
		if (ss.tellp() != 0) ss << "\|";
		ss << mask;
		}
		return ss.str();
		}

		status_t Spatializer::loadEngineConfiguration(sp<EffectHalInterface> effect) {
		ALOGV("%s", __func__);

		@@ -363,7 +373,7 @@ status_t Spatializer::loadEngineConfiguration(sp<EffectHalInterface> effect) {
		}
		mediametrics::LogItem(mMetricsId)
		.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CREATE)
		.set(AMEDIAMETRICS_PROP_CHANNELMASK, (int32_t)getMaxChannelMask(mChannelMasks))
		.set(AMEDIAMETRICS_PROP_CHANNELMASKS, channelMaskVectorToString(mChannelMasks))
		.set(AMEDIAMETRICS_PROP_LEVELS, aidl_utils::enumsToString(mLevels))
		.set(AMEDIAMETRICS_PROP_MODES, aidl_utils::enumsToString(mSpatializationModes))
		.set(AMEDIAMETRICS_PROP_HEADTRACKINGMODES, aidl_utils::enumsToString(mHeadTrackingModes))

services/mediametrics/AudioAnalytics.cpp

+108 −15

Original line number	Diff line number	Diff line
		@@ -240,6 +240,35 @@ static constexpr const char * const AAudioStreamFields[] {
		"sharing_requested",
		};

		static constexpr const char * HeadTrackerDeviceEnabledFields[] {
		"mediametrics_headtrackerdeviceenabled_reported",
		"type",
		"event",
		"enabled",
		};

		static constexpr const char * HeadTrackerDeviceSupportedFields[] {
		"mediametrics_headtrackerdevicesupported_reported",
		"type",
		"event",
		"supported",
		};

		static constexpr const char * SpatializerCapabilitiesFields[] {
		"mediametrics_spatializer_reported",
		"head_tracking_modes",
		"spatializer_levels",
		"spatializer_modes",
		"channel_masks",
		};

		static constexpr const char * SpatializerDeviceEnabledFields[] {
		"mediametrics_spatializerdeviceenabled_reported",
		"type",
		"event",
		"enabled",
		};

		/**
		* printFields is a helper method that prints the fields and corresponding values
		* in a human readable style.
		@@ -1534,6 +1563,17 @@ std::pair<std::string, int32_t> AudioAnalytics::Health::dump(
		return { s, n };
		}

		// Classifies the setting event for statsd (use generated statsd enums.proto constants).
		static int32_t classifySettingEvent(bool isSetAlready, bool withinBoot) {
		if (isSetAlready) {
		return util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__EVENT__SPATIALIZER_SETTING_EVENT_NORMAL;
		}
		if (withinBoot) {
		return util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__EVENT__SPATIALIZER_SETTING_EVENT_BOOT;
		}
		return util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__EVENT__SPATIALIZER_SETTING_EVENT_FIRST;
		}

		void AudioAnalytics::Spatializer::onEvent(
		const std::shared_ptr<const android::mediametrics::Item> &item)
		{
		@@ -1560,14 +1600,14 @@ void AudioAnalytics::Spatializer::onEvent(
		std::string modes;
		(void)item->get(AMEDIAMETRICS_PROP_MODES, &modes);

		int32_t channelMask = 0;
		(void)item->get(AMEDIAMETRICS_PROP_CHANNELMASK, &channelMask);
		std::string channelMasks;
		(void)item->get(AMEDIAMETRICS_PROP_CHANNELMASKS, &channelMasks);

		LOG(LOG_LEVEL) << "key:" << key
		<< " headTrackingModes:" << headTrackingModes
		<< " levels:" << levels
		<< " modes:" << modes
		<< " channelMask:" << channelMask
		<< " channelMasks:" << channelMasks
		;

		const std::vector<int32_t> headTrackingModesVector =
		@@ -1576,18 +1616,39 @@ void AudioAnalytics::Spatializer::onEvent(
		types::vectorFromMap(levels, types::getSpatializerLevelMap());
		const std::vector<int32_t> modesVector =
		types::vectorFromMap(modes, types::getSpatializerModeMap());
		const std::vector<int64_t> channelMasksVector =
		types::channelMaskVectorFromString(channelMasks);

		const auto [ result, str ] = sendToStatsd(SpatializerCapabilitiesFields,
		CONDITION(android::util::MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED)
		, headTrackingModesVector
		, levelsVector
		, modesVector
		, channelMasksVector
		);

		// TODO: send to statsd
		mAudioAnalytics.mStatsdLog->log(
		android::util::MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED, str);

		std::lock_guard lg(mLock);
		if (mFirstCreateTimeNs == 0) {
		// Only update the create time once to prevent audioserver restart
		// from looking like a boot.
		mFirstCreateTimeNs = item->getTimestamp();
		}
		mSimpleLog.log("%s suffix: %s item: %s",
		__func__, suffix.c_str(), item->toString().c_str());
		} else {
		std::string subtype = suffix.substr(0, delim);
		if (subtype != "device") return; // not a device.

		std::string deviceType = suffix.substr(std::size("device.") - 1);
		const std::string deviceType = suffix.substr(std::size("device.") - 1);

		const int32_t deviceTypeStatsd =
		types::lookup<types::AUDIO_DEVICE_INFO_TYPE, int32_t>(deviceType);

		std::string address;
		(void)item->get(AMEDIAMETRICS_PROP_ADDRESS, &address);
		std::string enabled;
		(void)item->get(AMEDIAMETRICS_PROP_ENABLED, &enabled);
		std::string hasHeadTracker;
		@@ -1598,35 +1659,67 @@ void AudioAnalytics::Spatializer::onEvent(
		std::lock_guard lg(mLock);

		// Validate from our cached state
		DeviceState& deviceState = mDeviceStateMap[deviceType];

		// Our deviceKey takes the device type and appends the address if any.
		// This distinguishes different wireless devices for the purposes of tracking.
		std::string deviceKey(deviceType);
		deviceKey.append("_").append(address);
		DeviceState& deviceState = mDeviceStateMap[deviceKey];

		// check whether the settings event is within a certain time of spatializer creation.
		const bool withinBoot =
		item->getTimestamp() - mFirstCreateTimeNs < kBootDurationThreshold;

		if (!enabled.empty()) {
		if (enabled != deviceState.enabled) {
		const int32_t settingEventStatsd =
		classifySettingEvent(!deviceState.enabled.empty(), withinBoot);
		deviceState.enabled = enabled;
		const bool enabledStatsd = enabled == "true";
		// TODO: send to statsd
		(void)mAudioAnalytics;
		(void)enabledStatsd;
		const auto [ result, str ] = sendToStatsd(SpatializerDeviceEnabledFields,
		CONDITION(android::util::MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED)
		, deviceTypeStatsd
		, settingEventStatsd
		, enabledStatsd
		);
		mAudioAnalytics.mStatsdLog->log(
		android::util::MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED, str);
		}
		}
		if (!hasHeadTracker.empty()) {
		if (hasHeadTracker != deviceState.hasHeadTracker) {
		const int32_t settingEventStatsd =
		classifySettingEvent(!deviceState.hasHeadTracker.empty(), withinBoot);
		deviceState.hasHeadTracker = hasHeadTracker;
		const bool supportedStatsd = hasHeadTracker == "true";
		// TODO: send to statsd
		(void)supportedStatsd;
		const auto [ result, str ] = sendToStatsd(HeadTrackerDeviceSupportedFields,
		CONDITION(android::util::MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED)
		, deviceTypeStatsd
		, settingEventStatsd
		, supportedStatsd
		);
		mAudioAnalytics.mStatsdLog->log(
		android::util::MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED, str);
		}
		}
		if (!headTrackerEnabled.empty()) {
		if (headTrackerEnabled != deviceState.headTrackerEnabled) {
		const int32_t settingEventStatsd =
		classifySettingEvent(!deviceState.headTrackerEnabled.empty(), withinBoot);
		deviceState.headTrackerEnabled = headTrackerEnabled;
		const bool enabledStatsd = headTrackerEnabled == "true";
		// TODO: send to statsd
		(void)enabledStatsd;
		const auto [ result, str ] = sendToStatsd(HeadTrackerDeviceEnabledFields,
		CONDITION(android::util::MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED)
		, deviceTypeStatsd
		, settingEventStatsd
		, enabledStatsd
		);
		mAudioAnalytics.mStatsdLog->log(
		android::util::MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED, str);
		}
		}
		mSimpleLog.log("%s deviceType: %s item: %s",
		__func__, deviceType.c_str(), item->toString().c_str());
		mSimpleLog.log("%s deviceKey: %s item: %s",
		__func__, deviceKey.c_str(), item->toString().c_str());
		}
		}

services/mediametrics/AudioTypes.cpp

+68 −0

Original line number	Diff line number	Diff line
		@@ -179,6 +179,50 @@ const std::unordered_map<std::string, int32_t>& getAudioDeviceOutCompactMap() {
		return map;
		}

		// A map for the Java AudioDeviceInfo types.
		// This uses generated statsd enums.proto constants.
		const std::unordered_map<std::string, int32_t>& getAudioDeviceInfoTypeMap() {
		// DO NOT MODIFY VALUES (OK to add new ones).
		static std::unordered_map<std::string, int32_t> map{
		{"unknown", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_UNKNOWN},
		{"earpiece", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUILTIN_EARPIECE},
		{"speaker", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUILTIN_SPEAKER},
		{"headset", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_WIRED_HEADSET},
		{"headphone", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_WIRED_HEADPHONES}, // sic
		{"bt_sco", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_SCO},
		{"bt_sco_hs", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_SCO},
		{"bt_sco_carkit", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_SCO},
		{"bt_a2dp", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_A2DP},
		{"bt_a2dp_hp", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_A2DP},
		{"bt_a2dp_spk", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLUETOOTH_A2DP},
		{"aux_digital", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI},
		{"hdmi", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI},
		{"analog_dock", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_DOCK},
		{"digital_dock", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_DOCK},
		{"usb_accessory", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_USB_ACCESSORY},
		{"usb_device", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_USB_DEVICE},
		{"usb_headset", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_USB_HEADSET},
		{"remote_submix", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_REMOTE_SUBMIX},
		{"telephony_tx", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_TELEPHONY},
		{"line", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_LINE_ANALOG},
		{"hdmi_arc", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI_ARC},
		{"hdmi_earc", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HDMI_EARC},
		{"spdif", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_LINE_DIGITAL},
		{"fm_transmitter", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_FM},
		{"aux_line", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_AUX_LINE},
		{"speaker_safe", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUILTIN_SPEAKER_SAFE},
		{"ip", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_IP},
		{"bus", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BUS},
		{"proxy", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_UNKNOWN /* AUDIO_DEVICE_INFO_TYPE_PROXY */},
		{"hearing_aid_out", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_HEARING_AID},
		{"echo_canceller", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_ECHO_REFERENCE}, // sic
		{"ble_headset", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLE_HEADSET},
		{"ble_speaker", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLE_SPEAKER},
		{"ble_broadcast", util::MEDIAMETRICS_SPATIALIZER_DEVICE_ENABLED_REPORTED__TYPE__AUDIO_DEVICE_INFO_TYPE_BLE_BROADCAST},
		};
		return map;
		}

		const std::unordered_map<std::string, int32_t>& getAudioThreadTypeMap() {
		// DO NOT MODIFY VALUES (OK to add new ones).
		// This may be found in frameworks/av/services/audioflinger/Threads.h
		@@ -381,6 +425,19 @@ std::vector<int32_t> vectorFromMap(
		return v;
		}

		std::vector<int64_t> channelMaskVectorFromString(const std::string &s)
		{
		std::vector<int64_t> v;

		const auto result = stringutils::split(s, "\|");
		for (const auto &mask : result) {
		// 0 if undetected or if actually 0.
		int64_t int64Mask = strtoll(mask.c_str(), nullptr, 0);
		v.push_back(int64Mask);
		}
		return v;
		}

		template <>
		int32_t lookup<CONTENT_TYPE>(const std::string &contentType)
		{
		@@ -535,6 +592,17 @@ std::string lookup<OUTPUT_DEVICE>(const std::string &outputDevice)
		return stringFromFlags<OutputDeviceTraits>(outputDevice, sizeof("AUDIO_DEVICE_OUT"));
		}

		template <>
		int32_t lookup<AUDIO_DEVICE_INFO_TYPE>(const std::string& audioDeviceInfoType)
		{
		auto& map = getAudioDeviceInfoTypeMap();
		auto it = map.find(audioDeviceInfoType);
		if (it == map.end()) {
		return 0;
		}
		return it->second;
		}

		template <>
		int32_t lookup<CALLER_NAME>(const std::string &callerName)
		{

services/mediametrics/include/mediametricsservice/AudioAnalytics.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -349,8 +349,9 @@ private:
		};

		AudioAnalytics& mAudioAnalytics;

		static constexpr int64_t kBootDurationThreshold = 120 /* seconds / 1e9;
		mutable std::mutex mLock;
		int64_t mFirstCreateTimeNs GUARDED_BY(mLock) = 0;
		std::map<std::string, DeviceState> mDeviceStateMap GUARDED_BY(mLock);
		SimpleLog mSimpleLog GUARDED_BY(mLock) {64};
		} mSpatializer{*this};