Merge "Mediametrics: Add max/min volume and duration in AudioPowerUsageData" (aac5c586) · Commits · e / os / android_frameworks_av

media/libmediametrics/include/MediaMetricsConstants.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -25,6 +25,9 @@
		* 2) Consistent behavior and documentation.
		*/

		#define AMEDIAMETRICS_INITIAL_MAX_VOLUME (0.f)
		#define AMEDIAMETRICS_INITIAL_MIN_VOLUME (1.f)

		/*
		* Taxonomy of audio keys
		*
		@@ -116,6 +119,11 @@
		#define AMEDIAMETRICS_PROP_DEVICETIMENS "deviceTimeNs" // int64_t playback/record time
		#define AMEDIAMETRICS_PROP_DEVICEVOLUME "deviceVolume" // double - average device volume

		#define AMEDIAMETRICS_PROP_DEVICEMAXVOLUMEDURATIONNS "deviceMaxVolumeDurationNs" // int64_t
		#define AMEDIAMETRICS_PROP_DEVICEMAXVOLUME "deviceMaxVolume" // double - maximum device volume
		#define AMEDIAMETRICS_PROP_DEVICEMINVOLUMEDURATIONNS "deviceMinVolumeDurationNs" // int64_t
		#define AMEDIAMETRICS_PROP_DEVICEMINVOLUME "deviceMinVolume" // double - minimum device volume

		#define AMEDIAMETRICS_PROP_DIRECTION "direction" // string AAudio input or output
		#define AMEDIAMETRICS_PROP_DURATIONNS "durationNs" // int64 duration time span
		#define AMEDIAMETRICS_PROP_ENCODING "encoding" // string value of format

services/audioflinger/TrackMetrics.h

+34 −2

Original line number	Diff line number	Diff line
		@@ -116,6 +116,21 @@ public:
		mDeviceStartupMs.add(startupMs);
		}

		void updateMinMaxVolume(int64_t durationNs, double deviceVolume) {
		if (deviceVolume > mMaxVolume) {
		mMaxVolume = deviceVolume;
		mMaxVolumeDurationNs = durationNs;
		} else if (deviceVolume == mMaxVolume) {
		mMaxVolumeDurationNs += durationNs;
		}
		if (deviceVolume < mMinVolume) {
		mMinVolume = deviceVolume;
		mMinVolumeDurationNs = durationNs;
		} else if (deviceVolume == mMinVolume) {
		mMinVolumeDurationNs += durationNs;
		}
		}

		// may be called multiple times during an interval
		void logVolume(float volume) {
		const int64_t timeNs = systemTime();
		@@ -123,10 +138,13 @@ public:
		if (mStartVolumeTimeNs == 0) {
		mDeviceVolume = mVolume = volume;
		mLastVolumeChangeTimeNs = mStartVolumeTimeNs = timeNs;
		updateMinMaxVolume(0, mVolume);
		return;
		}
		const int64_t durationNs = timeNs - mLastVolumeChangeTimeNs;
		updateMinMaxVolume(durationNs, mVolume);
		mDeviceVolume = (mDeviceVolume * (mLastVolumeChangeTimeNs - mStartVolumeTimeNs) +
		mVolume * (timeNs - mLastVolumeChangeTimeNs)) / (timeNs - mStartVolumeTimeNs);
		mVolume * durationNs) / (timeNs - mStartVolumeTimeNs);
		mVolume = volume;
		mLastVolumeChangeTimeNs = timeNs;
		}
		@@ -157,7 +175,11 @@ private:
		.set(AMEDIAMETRICS_PROP_EVENT, eventName)
		.set(AMEDIAMETRICS_PROP_INTERVALCOUNT, (int32_t)mIntervalCount);
		if (mIsOut) {
		item.set(AMEDIAMETRICS_PROP_DEVICEVOLUME, mDeviceVolume);
		item.set(AMEDIAMETRICS_PROP_DEVICEVOLUME, mDeviceVolume)
		.set(AMEDIAMETRICS_PROP_DEVICEMAXVOLUMEDURATIONNS, mMaxVolumeDurationNs)
		.set(AMEDIAMETRICS_PROP_DEVICEMAXVOLUME, mMaxVolume)
		.set(AMEDIAMETRICS_PROP_DEVICEMINVOLUMEDURATIONNS, mMinVolumeDurationNs)
		.set(AMEDIAMETRICS_PROP_DEVICEMINVOLUME, mMinVolume);
		}
		if (mDeviceLatencyMs.getN() > 0) {
		item.set(AMEDIAMETRICS_PROP_DEVICELATENCYMS, mDeviceLatencyMs.getMean())
		@@ -185,6 +207,10 @@ private:
		mDeviceVolume = 0.f;
		mStartVolumeTimeNs = 0;
		mLastVolumeChangeTimeNs = 0;
		mMinVolume = AMEDIAMETRICS_INITIAL_MIN_VOLUME;
		mMaxVolume = AMEDIAMETRICS_INITIAL_MAX_VOLUME;
		mMinVolumeDurationNs = 0;
		mMaxVolumeDurationNs = 0;

		mDeviceLatencyMs.reset();
		mDeviceStartupMs.reset();
		@@ -214,6 +240,12 @@ private:
		int64_t mStartVolumeTimeNs GUARDED_BY(mLock) = 0;
		int64_t mLastVolumeChangeTimeNs GUARDED_BY(mLock) = 0;

		// Min/Max volume
		double mMinVolume GUARDED_BY(mLock) = AMEDIAMETRICS_INITIAL_MIN_VOLUME;
		double mMaxVolume GUARDED_BY(mLock) = AMEDIAMETRICS_INITIAL_MAX_VOLUME;
		int64_t mMinVolumeDurationNs GUARDED_BY(mLock) = 0;
		int64_t mMaxVolumeDurationNs GUARDED_BY(mLock) = 0;

		// latency and startup for each interval.
		audio_utils::Statistics<double> mDeviceLatencyMs GUARDED_BY(mLock);
		audio_utils::Statistics<double> mDeviceStartupMs GUARDED_BY(mLock);

services/mediametrics/AudioPowerUsage.cpp

+146 −18

Original line number	Diff line number	Diff line
		@@ -45,6 +45,10 @@
		#define AUDIO_POWER_USAGE_PROP_DURATION_NS "durationNs" // int64
		#define AUDIO_POWER_USAGE_PROP_TYPE "type" // int32
		#define AUDIO_POWER_USAGE_PROP_VOLUME "volume" // double
		#define AUDIO_POWER_USAGE_PROP_MIN_VOLUME_DURATION_NS "minVolumeDurationNs" // int64
		#define AUDIO_POWER_USAGE_PROP_MIN_VOLUME "minVolume" // double
		#define AUDIO_POWER_USAGE_PROP_MAX_VOLUME_DURATION_NS "maxVolumeDurationNs" // int64
		#define AUDIO_POWER_USAGE_PROP_MAX_VOLUME "maxVolume" // double

		namespace android::mediametrics {

		@@ -141,13 +145,34 @@ void AudioPowerUsage::sendItem(const std::shared_ptr<const mediametrics::Item>&
		double volume;
		if (!item->getDouble(AUDIO_POWER_USAGE_PROP_VOLUME, &volume)) return;

		int64_t min_volume_duration_ns;
		if (!item->getInt64(AUDIO_POWER_USAGE_PROP_MIN_VOLUME_DURATION_NS, &min_volume_duration_ns)) {
		return;
		}

		double min_volume;
		if (!item->getDouble(AUDIO_POWER_USAGE_PROP_MIN_VOLUME, &min_volume)) return;

		int64_t max_volume_duration_ns;
		if (!item->getInt64(AUDIO_POWER_USAGE_PROP_MAX_VOLUME_DURATION_NS, &max_volume_duration_ns)) {
		return;
		}

		double max_volume;
		if (!item->getDouble(AUDIO_POWER_USAGE_PROP_MAX_VOLUME, &max_volume)) return;

		const int32_t duration_secs = (int32_t)(duration_ns / NANOS_PER_SECOND);
		const float average_volume = (float)volume;
		const int32_t min_volume_duration_secs = (int32_t)(min_volume_duration_ns / NANOS_PER_SECOND);
		const int32_t max_volume_duration_secs = (int32_t)(max_volume_duration_ns / NANOS_PER_SECOND);
		const int result = android::util::stats_write(android::util::AUDIO_POWER_USAGE_DATA_REPORTED,
		audio_device,
		duration_secs,
		average_volume,
		type);
		(float)volume,
		type,
		min_volume_duration_secs,
		(float)min_volume,
		max_volume_duration_secs,
		(float)max_volume);

		std::stringstream log;
		log << "result:" << result << " {"
		@@ -155,14 +180,40 @@ void AudioPowerUsage::sendItem(const std::shared_ptr<const mediametrics::Item>&
		<< android::util::AUDIO_POWER_USAGE_DATA_REPORTED
		<< " audio_device:" << audio_device
		<< " duration_secs:" << duration_secs
		<< " average_volume:" << average_volume
		<< " average_volume:" << (float)volume
		<< " type:" << type
		<< " min_volume_duration_secs:" << min_volume_duration_secs
		<< " min_volume:" << (float)min_volume
		<< " max_volume_duration_secs:" << max_volume_duration_secs
		<< " max_volume:" << (float)max_volume
		<< " }";
		mStatsdLog->log(android::util::AUDIO_POWER_USAGE_DATA_REPORTED, log.str());
		}

		void AudioPowerUsage::updateMinMaxVolumeAndDuration(
		const int64_t cur_max_volume_duration_ns, const double cur_max_volume,
		const int64_t cur_min_volume_duration_ns, const double cur_min_volume,
		int64_t& f_max_volume_duration_ns, double& f_max_volume,
		int64_t& f_min_volume_duration_ns, double& f_min_volume)
		{
		if (f_min_volume > cur_min_volume) {
		f_min_volume = cur_min_volume;
		f_min_volume_duration_ns = cur_min_volume_duration_ns;
		} else if (f_min_volume == cur_min_volume) {
		f_min_volume_duration_ns += cur_min_volume_duration_ns;
		}
		if (f_max_volume < cur_max_volume) {
		f_max_volume = cur_max_volume;
		f_max_volume_duration_ns = cur_max_volume_duration_ns;
		} else if (f_max_volume == cur_max_volume) {
		f_max_volume_duration_ns += cur_max_volume_duration_ns;
		}
		}

		bool AudioPowerUsage::saveAsItem_l(
		int32_t device, int64_t duration_ns, int32_t type, double average_vol)
		int32_t device, int64_t duration_ns, int32_t type, double average_vol,
		int64_t max_volume_duration_ns, double max_volume,
		int64_t min_volume_duration_ns, double min_volume)
		{
		ALOGV("%s: (%#x, %d, %lld, %f)", __func__, device, type,
		(long long)duration_ns, average_vol);
		@@ -193,10 +244,36 @@ bool AudioPowerUsage::saveAsItem_l(
		item->setDouble(AUDIO_POWER_USAGE_PROP_VOLUME, final_volume);
		item->setTimestamp(systemTime(SYSTEM_TIME_REALTIME));

		ALOGV("%s: update (%#x, %d, %lld, %f) --> (%lld, %f)", __func__,
		// Update the max/min volume and duration
		int64_t final_min_volume_duration_ns;
		int64_t final_max_volume_duration_ns;
		double final_min_volume;
		double final_max_volume;

		item->getInt64(AUDIO_POWER_USAGE_PROP_MIN_VOLUME_DURATION_NS,
		&final_min_volume_duration_ns);
		item->getDouble(AUDIO_POWER_USAGE_PROP_MIN_VOLUME, &final_min_volume);
		item->getInt64(AUDIO_POWER_USAGE_PROP_MAX_VOLUME_DURATION_NS,
		&final_max_volume_duration_ns);
		item->getDouble(AUDIO_POWER_USAGE_PROP_MAX_VOLUME, &final_max_volume);
		updateMinMaxVolumeAndDuration(max_volume_duration_ns, max_volume,
		min_volume_duration_ns, min_volume,
		final_max_volume_duration_ns, final_max_volume,
		final_min_volume_duration_ns, final_min_volume);
		item->setInt64(AUDIO_POWER_USAGE_PROP_MIN_VOLUME_DURATION_NS,
		final_min_volume_duration_ns);
		item->setDouble(AUDIO_POWER_USAGE_PROP_MIN_VOLUME, final_min_volume);
		item->setInt64(AUDIO_POWER_USAGE_PROP_MAX_VOLUME_DURATION_NS,
		final_max_volume_duration_ns);
		item->setDouble(AUDIO_POWER_USAGE_PROP_MAX_VOLUME, final_max_volume);

		ALOGV("%s: update (%#x, %d, %lld, %f) --> (%lld, %f) min(%lld, %f) max(%lld, %f)",
		__func__,
		device, type,
		(long long)item_duration_ns, item_volume,
		(long long)final_duration_ns, final_volume);
		(long long)final_duration_ns, final_volume,
		(long long)final_min_volume_duration_ns, final_min_volume,
		(long long)final_max_volume_duration_ns, final_max_volume);

		return true;
		}
		@@ -208,12 +285,18 @@ bool AudioPowerUsage::saveAsItem_l(
		sitem->setInt64(AUDIO_POWER_USAGE_PROP_DURATION_NS, duration_ns);
		sitem->setInt32(AUDIO_POWER_USAGE_PROP_TYPE, type);
		sitem->setDouble(AUDIO_POWER_USAGE_PROP_VOLUME, average_vol);
		sitem->setInt64(AUDIO_POWER_USAGE_PROP_MIN_VOLUME_DURATION_NS, min_volume_duration_ns);
		sitem->setDouble(AUDIO_POWER_USAGE_PROP_MIN_VOLUME, min_volume);
		sitem->setInt64(AUDIO_POWER_USAGE_PROP_MAX_VOLUME_DURATION_NS, max_volume_duration_ns);
		sitem->setDouble(AUDIO_POWER_USAGE_PROP_MAX_VOLUME, max_volume);
		mItems.emplace_back(sitem);
		return true;
		}

		bool AudioPowerUsage::saveAsItems_l(
		int32_t device, int64_t duration_ns, int32_t type, double average_vol)
		int32_t device, int64_t duration_ns, int32_t type, double average_vol,
		int64_t max_volume_duration, double max_volume,
		int64_t min_volume_duration, double min_volume)
		{
		ALOGV("%s: (%#x, %d, %lld, %f)", __func__, device, type,
		(long long)duration_ns, average_vol );
		@@ -232,7 +315,9 @@ bool AudioPowerUsage::saveAsItems_l(
		int32_t tmp_device = device_bits & -device_bits; // get lowest bit
		device_bits ^= tmp_device; // clear lowest bit
		tmp_device \|= input_bit; // restore input bit
		ret = saveAsItem_l(tmp_device, duration_ns, type, average_vol);
		ret = saveAsItem_l(tmp_device, duration_ns, type, average_vol,
		max_volume_duration, max_volume,
		min_volume_duration, min_volume);

		ALOGV("%s: device %#x recorded, remaining device_bits = %#x", __func__,
		tmp_device, device_bits);
		@@ -250,9 +335,28 @@ void AudioPowerUsage::checkTrackRecord(
		return;
		}
		double deviceVolume = 1.;
		if (isTrack && !item->getDouble(AMEDIAMETRICS_PROP_DEVICEVOLUME, &deviceVolume)) {
		int64_t maxVolumeDurationNs = 0;
		double maxVolume = AMEDIAMETRICS_INITIAL_MAX_VOLUME;
		int64_t minVolumeDurationNs = 0;
		double minVolume = AMEDIAMETRICS_INITIAL_MIN_VOLUME;
		if (isTrack) {
		if (!item->getDouble(AMEDIAMETRICS_PROP_DEVICEVOLUME, &deviceVolume)) {
		return;
		}
		if (!item->getInt64(AMEDIAMETRICS_PROP_DEVICEMAXVOLUMEDURATIONNS, &maxVolumeDurationNs)) {
		return;
		}
		if (!item->getDouble(AMEDIAMETRICS_PROP_DEVICEMAXVOLUME, &maxVolume)) {
		return;
		}
		if (!item->getInt64(AMEDIAMETRICS_PROP_DEVICEMINVOLUMEDURATIONNS, &minVolumeDurationNs)) {
		return;
		}
		if (!item->getDouble(AMEDIAMETRICS_PROP_DEVICEMINVOLUME, &minVolume)) {
		return;
		}
		}

		int32_t type = 0;
		std::string type_string;
		if ((isTrack && mAudioAnalytics->mAnalyticsState->timeMachine().get(
		@@ -285,7 +389,8 @@ void AudioPowerUsage::checkTrackRecord(
		ALOGV("device = %s => %d", device_strings.c_str(), device);
		}
		std::lock_guard l(mLock);
		saveAsItems_l(device, deviceTimeNs, type, deviceVolume);
		saveAsItems_l(device, deviceTimeNs, type, deviceVolume,
		maxVolumeDurationNs, maxVolume, minVolumeDurationNs, minVolume);
		}

		void AudioPowerUsage::checkMode(const std::shared_ptr<const mediametrics::Item>& item)
		@@ -299,10 +404,17 @@ void AudioPowerUsage::checkMode(const std::shared_ptr<const mediametrics::Item>&
		if (mMode == "AUDIO_MODE_IN_CALL") { // leaving call mode
		const int64_t endCallNs = item->getTimestamp();
		const int64_t durationNs = endCallNs - mDeviceTimeNs;
		const int64_t volumeDurationNs = endCallNs - mVolumeTimeNs;
		if (durationNs > 0) {
		mDeviceVolume = (mDeviceVolume * double(mVolumeTimeNs - mDeviceTimeNs) +
		mVoiceVolume * double(endCallNs - mVolumeTimeNs)) / (double)durationNs;
		saveAsItems_l(mPrimaryDevice, durationNs, VOICE_CALL_TYPE, mDeviceVolume);
		mVoiceVolume * double(volumeDurationNs)) / (double)durationNs;
		updateMinMaxVolumeAndDuration(volumeDurationNs, mVoiceVolume,
		volumeDurationNs, mVoiceVolume,
		mMaxVoiceVolumeDurationNs, mMaxVoiceVolume,
		mMinVoiceVolumeDurationNs, mMinVoiceVolume);
		saveAsItems_l(mPrimaryDevice, durationNs, VOICE_CALL_TYPE, mDeviceVolume,
		mMaxVoiceVolumeDurationNs, mMaxVoiceVolume,
		mMinVoiceVolumeDurationNs, mMinVoiceVolume);
		}
		} else if (mode == "AUDIO_MODE_IN_CALL") { // entering call mode
		mStartCallNs = item->getTimestamp(); // advisory only
		@@ -327,10 +439,15 @@ void AudioPowerUsage::checkVoiceVolume(const std::shared_ptr<const mediametrics:
		if (mMode == "AUDIO_MODE_IN_CALL") {
		const int64_t timeNs = item->getTimestamp();
		const int64_t durationNs = timeNs - mDeviceTimeNs;
		const int64_t volumeDurationNs = timeNs - mVolumeTimeNs;
		if (durationNs > 0) {
		mDeviceVolume = (mDeviceVolume * double(mVolumeTimeNs - mDeviceTimeNs) +
		mVoiceVolume * double(timeNs - mVolumeTimeNs)) / (double)durationNs;
		mVoiceVolume * double(volumeDurationNs)) / (double)durationNs;
		mVolumeTimeNs = timeNs;
		updateMinMaxVolumeAndDuration(volumeDurationNs, mVoiceVolume,
		volumeDurationNs, mVoiceVolume,
		mMaxVoiceVolumeDurationNs, mMaxVoiceVolume,
		mMinVoiceVolumeDurationNs, mMinVoiceVolume);
		}
		}
		ALOGV("%s: new voice volume:%lf old voice volume:%lf", __func__, voiceVolume, mVoiceVolume);
		@@ -358,15 +475,26 @@ void AudioPowerUsage::checkCreatePatch(const std::shared_ptr<const mediametrics:
		// Save statistics
		const int64_t endDeviceNs = item->getTimestamp();
		const int64_t durationNs = endDeviceNs - mDeviceTimeNs;
		const int64_t volumeDurationNs = endDeviceNs - mVolumeTimeNs;
		if (durationNs > 0) {
		mDeviceVolume = (mDeviceVolume * double(mVolumeTimeNs - mDeviceTimeNs) +
		mVoiceVolume * double(endDeviceNs - mVolumeTimeNs)) / (double)durationNs;
		saveAsItems_l(mPrimaryDevice, durationNs, VOICE_CALL_TYPE, mDeviceVolume);
		mVoiceVolume * double(volumeDurationNs)) / (double)durationNs;
		updateMinMaxVolumeAndDuration(volumeDurationNs, mVoiceVolume,
		volumeDurationNs, mVoiceVolume,
		mMaxVoiceVolumeDurationNs, mMaxVoiceVolume,
		mMinVoiceVolumeDurationNs, mMinVoiceVolume);
		saveAsItems_l(mPrimaryDevice, durationNs, VOICE_CALL_TYPE, mDeviceVolume,
		mMaxVoiceVolumeDurationNs, mMaxVoiceVolume,
		mMinVoiceVolumeDurationNs, mMinVoiceVolume);
		}
		// reset statistics
		mDeviceVolume = 0;
		mDeviceTimeNs = endDeviceNs;
		mVolumeTimeNs = endDeviceNs;
		mMaxVoiceVolume = AMEDIAMETRICS_INITIAL_MAX_VOLUME;
		mMinVoiceVolume = AMEDIAMETRICS_INITIAL_MIN_VOLUME;
		mMaxVoiceVolumeDurationNs = 0;
		mMinVoiceVolumeDurationNs = 0;
		}
		ALOGV("%s: new primary device:%#x old primary device:%#x", __func__, device, mPrimaryDevice);
		mPrimaryDevice = device;

services/mediametrics/AudioPowerUsage.h

+18 −5

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@

		namespace android::mediametrics {


		class AudioAnalytics;

		class AudioPowerUsage {
		@@ -83,13 +84,21 @@ public:
		static bool deviceFromString(const std::string& device_string, int32_t& device);
		static int32_t deviceFromStringPairs(const std::string& device_strings);
		private:
		bool saveAsItem_l(int32_t device, int64_t duration, int32_t type, double average_vol)
		bool saveAsItem_l(int32_t device, int64_t duration, int32_t type, double average_vol,
		int64_t max_volume_duration, double max_volume,
		int64_t min_volume_duration, double min_volume)
		REQUIRES(mLock);
		void sendItem(const std::shared_ptr<const mediametrics::Item>& item) const;
		void collect();
		bool saveAsItems_l(int32_t device, int64_t duration, int32_t type, double average_vol)
		bool saveAsItems_l(int32_t device, int64_t duration, int32_t type, double average_vol,
		int64_t max_volume_duration, double max_volume,
		int64_t min_volume_duration, double min_volume)
		REQUIRES(mLock);

		void updateMinMaxVolumeAndDuration(
		const int64_t cur_max_volume_duration_ns, const double cur_max_volume,
		const int64_t cur_min_volume_duration_ns, const double cur_min_volume,
		int64_t& f_max_volume_duration_ns, double& f_max_volume,
		int64_t& f_min_volume_duration_ns, double& f_min_volume);
		AudioAnalytics * const mAudioAnalytics;
		const std::shared_ptr<StatsdLog> mStatsdLog; // mStatsdLog is internally locked
		const bool mDisabled;
		@@ -100,6 +109,10 @@ private:

		double mVoiceVolume GUARDED_BY(mLock) = 0.;
		double mDeviceVolume GUARDED_BY(mLock) = 0.;
		double mMaxVoiceVolume GUARDED_BY(mLock) = AMEDIAMETRICS_INITIAL_MAX_VOLUME;
		double mMinVoiceVolume GUARDED_BY(mLock) = AMEDIAMETRICS_INITIAL_MIN_VOLUME;
		int64_t mMaxVoiceVolumeDurationNs GUARDED_BY(mLock) = 0;
		int64_t mMinVoiceVolumeDurationNs GUARDED_BY(mLock) = 0;
		int64_t mStartCallNs GUARDED_BY(mLock) = 0; // advisory only
		int64_t mVolumeTimeNs GUARDED_BY(mLock) = 0;
		int64_t mDeviceTimeNs GUARDED_BY(mLock) = 0;