Merge "MediaMetrics: Report last statsd atoms pushed" into sc-dev
diff --git a/services/mediametrics/AudioAnalytics.cpp b/services/mediametrics/AudioAnalytics.cpp
index ca918a9..2b797b8 100644
--- a/services/mediametrics/AudioAnalytics.cpp
+++ b/services/mediametrics/AudioAnalytics.cpp
@@ -207,8 +207,10 @@
return { result, ss.str() };
}
-AudioAnalytics::AudioAnalytics()
+AudioAnalytics::AudioAnalytics(const std::shared_ptr<StatsdLog>& statsdLog)
: mDeliverStatistics(property_get_bool(PROP_AUDIO_ANALYTICS_CLOUD_ENABLED, true))
+ , mStatsdLog(statsdLog)
+ , mAudioPowerUsage(this, statsdLog)
{
SetMinimumLogSeverity(android::base::DEBUG); // for LOG().
ALOGD("%s", __func__);
@@ -407,20 +409,6 @@
ll -= l;
}
- if (ll > 0) {
- // Print the statsd atoms we sent out.
- const std::string statsd = mStatsdLog.dumpToString(" " /* prefix */, ll - 1);
- const size_t n = std::count(statsd.begin(), statsd.end(), '\n') + 1; // we control this.
- if ((size_t)ll >= n) {
- if (n == 1) {
- ss << "Statsd atoms: empty or truncated\n";
- } else {
- ss << "Statsd atoms:\n" << statsd;
- }
- ll -= (int32_t)n;
- }
- }
-
if (ll > 0 && prefix == nullptr) {
auto [s, l] = mAudioPowerUsage.dump(ll);
ss << s;
@@ -602,7 +590,8 @@
, logSessionIdForStats.c_str()
);
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(
+ android::util::MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED, str);
}
} break;
case THREAD: {
@@ -650,7 +639,8 @@
, ENUM_EXTRACT(typeForStats)
);
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(
+ android::util::MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED, str);
}
} break;
case TRACK: {
@@ -770,7 +760,8 @@
, logSessionIdForStats.c_str()
);
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(
+ android::util::MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED, str);
}
} break;
}
@@ -846,7 +837,8 @@
, /* connection_count */ 1
);
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(
+ android::util::MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED, str);
}
}
}
@@ -899,7 +891,8 @@
, /* connection_count */ 1
);
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(
+ android::util::MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED, str);
}
return;
}
@@ -925,7 +918,8 @@
, /* connection_count */ 1
);
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(
+ android::util::MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED, str);
}
}
@@ -1065,7 +1059,7 @@
ss << " " << fieldsStr;
std::string str = ss.str();
ALOGV("%s: statsd %s", __func__, str.c_str());
- mAudioAnalytics.mStatsdLog.log("%s", str.c_str());
+ mAudioAnalytics.mStatsdLog->log(android::util::MEDIAMETRICS_AAUDIOSTREAM_REPORTED, str);
}
}
diff --git a/services/mediametrics/AudioAnalytics.h b/services/mediametrics/AudioAnalytics.h
index 07872ef..2b41a95 100644
--- a/services/mediametrics/AudioAnalytics.h
+++ b/services/mediametrics/AudioAnalytics.h
@@ -17,10 +17,10 @@
#pragma once
#include <android-base/thread_annotations.h>
-#include <audio_utils/SimpleLog.h>
#include "AnalyticsActions.h"
#include "AnalyticsState.h"
#include "AudioPowerUsage.h"
+#include "StatsdLog.h"
#include "TimedAction.h"
#include "Wrap.h"
@@ -32,7 +32,7 @@
friend AudioPowerUsage;
public:
- AudioAnalytics();
+ explicit AudioAnalytics(const std::shared_ptr<StatsdLog>& statsdLog);
~AudioAnalytics();
/**
@@ -122,8 +122,7 @@
SharedPtrWrap<AnalyticsState> mPreviousAnalyticsState;
TimedAction mTimedAction; // locked internally
-
- SimpleLog mStatsdLog{16 /* log lines */}; // locked internally
+ const std::shared_ptr<StatsdLog> mStatsdLog; // locked internally, ok for multiple threads.
// DeviceUse is a nested class which handles audio device usage accounting.
// We define this class at the end to ensure prior variables all properly constructed.
@@ -212,7 +211,7 @@
AudioAnalytics &mAudioAnalytics;
} mAAudioStreamInfo{*this};
- AudioPowerUsage mAudioPowerUsage{this};
+ AudioPowerUsage mAudioPowerUsage;
};
} // namespace android::mediametrics
diff --git a/services/mediametrics/AudioPowerUsage.cpp b/services/mediametrics/AudioPowerUsage.cpp
index e584f12..ab74c8e 100644
--- a/services/mediametrics/AudioPowerUsage.cpp
+++ b/services/mediametrics/AudioPowerUsage.cpp
@@ -127,14 +127,13 @@
return deviceMask;
}
-/* static */
-void AudioPowerUsage::sendItem(const std::shared_ptr<const mediametrics::Item>& item)
+void AudioPowerUsage::sendItem(const std::shared_ptr<const mediametrics::Item>& item) const
{
int32_t type;
if (!item->getInt32(AUDIO_POWER_USAGE_PROP_TYPE, &type)) return;
- int32_t device;
- if (!item->getInt32(AUDIO_POWER_USAGE_PROP_DEVICE, &device)) return;
+ int32_t audio_device;
+ if (!item->getInt32(AUDIO_POWER_USAGE_PROP_DEVICE, &audio_device)) return;
int64_t duration_ns;
if (!item->getInt64(AUDIO_POWER_USAGE_PROP_DURATION_NS, &duration_ns)) return;
@@ -142,11 +141,24 @@
double volume;
if (!item->getDouble(AUDIO_POWER_USAGE_PROP_VOLUME, &volume)) return;
- (void)android::util::stats_write(android::util::AUDIO_POWER_USAGE_DATA_REPORTED,
- device,
- (int32_t)(duration_ns / NANOS_PER_SECOND),
- (float)volume,
+ const int32_t duration_secs = (int32_t)(duration_ns / NANOS_PER_SECOND);
+ const float average_volume = (float)volume;
+ const int result = android::util::stats_write(android::util::AUDIO_POWER_USAGE_DATA_REPORTED,
+ audio_device,
+ duration_secs,
+ average_volume,
type);
+
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_audio_power_usage_data_reported:"
+ << android::util::AUDIO_POWER_USAGE_DATA_REPORTED
+ << " audio_device:" << audio_device
+ << " duration_secs:" << duration_secs
+ << " average_volume:" << average_volume
+ << " type:" << type
+ << " }";
+ mStatsdLog->log(android::util::AUDIO_POWER_USAGE_DATA_REPORTED, log.str());
}
bool AudioPowerUsage::saveAsItem_l(
@@ -360,8 +372,10 @@
mPrimaryDevice = device;
}
-AudioPowerUsage::AudioPowerUsage(AudioAnalytics *audioAnalytics)
+AudioPowerUsage::AudioPowerUsage(
+ AudioAnalytics *audioAnalytics, const std::shared_ptr<StatsdLog>& statsdLog)
: mAudioAnalytics(audioAnalytics)
+ , mStatsdLog(statsdLog)
, mDisabled(property_get_bool(PROP_AUDIO_METRICS_DISABLED, AUDIO_METRICS_DISABLED_DEFAULT))
, mIntervalHours(property_get_int32(PROP_AUDIO_METRICS_INTERVAL_HR, INTERVAL_HR_DEFAULT))
{
diff --git a/services/mediametrics/AudioPowerUsage.h b/services/mediametrics/AudioPowerUsage.h
index b705a6a..7021902 100644
--- a/services/mediametrics/AudioPowerUsage.h
+++ b/services/mediametrics/AudioPowerUsage.h
@@ -22,13 +22,15 @@
#include <mutex>
#include <thread>
+#include "StatsdLog.h"
+
namespace android::mediametrics {
class AudioAnalytics;
class AudioPowerUsage {
public:
- explicit AudioPowerUsage(AudioAnalytics *audioAnalytics);
+ AudioPowerUsage(AudioAnalytics *audioAnalytics, const std::shared_ptr<StatsdLog>& statsdLog);
~AudioPowerUsage();
void checkTrackRecord(const std::shared_ptr<const mediametrics::Item>& item, bool isTrack);
@@ -83,12 +85,13 @@
private:
bool saveAsItem_l(int32_t device, int64_t duration, int32_t type, double average_vol)
REQUIRES(mLock);
- static void sendItem(const std::shared_ptr<const mediametrics::Item>& item);
+ 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)
REQUIRES(mLock);
AudioAnalytics * const mAudioAnalytics;
+ const std::shared_ptr<StatsdLog> mStatsdLog; // mStatsdLog is internally locked
const bool mDisabled;
const int32_t mIntervalHours;
diff --git a/services/mediametrics/MediaMetricsService.cpp b/services/mediametrics/MediaMetricsService.cpp
index 7ee731e..8321481 100644
--- a/services/mediametrics/MediaMetricsService.cpp
+++ b/services/mediametrics/MediaMetricsService.cpp
@@ -206,7 +206,7 @@
(void)mAudioAnalytics.submit(sitem, isTrusted);
- (void)dump2Statsd(sitem); // failure should be logged in function.
+ (void)dump2Statsd(sitem, mStatsdLog); // failure should be logged in function.
saveItem(sitem);
return NO_ERROR;
}
@@ -308,6 +308,11 @@
if (lines == linesToDump) {
result << "-- some lines may be truncated --\n";
}
+
+ // Dump the statsd atoms we sent out.
+ result << "Statsd atoms:\n"
+ << mStatsdLog->dumpToString(" " /* prefix */,
+ all ? STATSD_LOG_LINES_MAX : STATSD_LOG_LINES_DUMP);
}
}
const std::string str = result.str();
diff --git a/services/mediametrics/MediaMetricsService.h b/services/mediametrics/MediaMetricsService.h
index 6234656..8d0b1cf 100644
--- a/services/mediametrics/MediaMetricsService.h
+++ b/services/mediametrics/MediaMetricsService.h
@@ -124,7 +124,14 @@
std::atomic<int64_t> mItemsSubmitted{}; // accessed outside of lock.
- mediametrics::AudioAnalytics mAudioAnalytics; // mAudioAnalytics is locked internally.
+ // mStatsdLog is locked internally (thread-safe) and shows the last atoms logged
+ static constexpr size_t STATSD_LOG_LINES_MAX = 30; // recent log lines to keep
+ static constexpr size_t STATSD_LOG_LINES_DUMP = 4; // normal amount of lines to dump
+ const std::shared_ptr<mediametrics::StatsdLog> mStatsdLog{
+ std::make_shared<mediametrics::StatsdLog>(STATSD_LOG_LINES_MAX)};
+
+ // mAudioAnalytics is locked internally.
+ mediametrics::AudioAnalytics mAudioAnalytics{mStatsdLog};
std::mutex mLock;
// statistics about our analytics
diff --git a/services/mediametrics/StatsdLog.h b/services/mediametrics/StatsdLog.h
new file mode 100644
index 0000000..e207bac
--- /dev/null
+++ b/services/mediametrics/StatsdLog.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#pragma once
+
+#include <audio_utils/SimpleLog.h>
+#include <map>
+#include <mutex>
+#include <sstream>
+
+namespace android::mediametrics {
+
+class StatsdLog {
+public:
+ explicit StatsdLog(size_t lines) : mSimpleLog(lines) {}
+
+ void log(int atom, const std::string& string) {
+ {
+ std::lock_guard lock(mLock);
+ ++mCountMap[atom];
+ }
+ mSimpleLog.log("%s", string.c_str());
+ }
+
+ std::string dumpToString(const char *prefix = "", size_t logLines = 0) const {
+ std::stringstream ss;
+
+ { // first print out the atom counts
+ std::lock_guard lock(mLock);
+
+ size_t col = 0;
+ for (const auto& count : mCountMap) {
+ if (col == 8) {
+ col = 0;
+ ss << "\n" << prefix;
+ } else {
+ ss << " ";
+ }
+ ss << "[ " << count.first << " : " << count.second << " ]";
+ ++col;
+ }
+ ss << "\n";
+ }
+
+ // then print out the log lines
+ ss << mSimpleLog.dumpToString(prefix, logLines);
+ return ss.str();
+ }
+
+private:
+ SimpleLog mSimpleLog; // internally locked
+ std::map<int /* atom */, size_t /* count */> mCountMap GUARDED_BY(mLock); // sorted
+ mutable std::mutex mLock;
+};
+
+} // namespace android::mediametrics
diff --git a/services/mediametrics/fuzzer/mediametrics_service_fuzzer.cpp b/services/mediametrics/fuzzer/mediametrics_service_fuzzer.cpp
index 0cb2594..8b0b479 100644
--- a/services/mediametrics/fuzzer/mediametrics_service_fuzzer.cpp
+++ b/services/mediametrics/fuzzer/mediametrics_service_fuzzer.cpp
@@ -320,7 +320,9 @@
void MediaMetricsServiceFuzzer::invokeAudioAnalytics(const uint8_t *data, size_t size) {
FuzzedDataProvider fdp = FuzzedDataProvider(data, size);
- android::mediametrics::AudioAnalytics audioAnalytics;
+ std::shared_ptr<android::mediametrics::StatsdLog> statsdLog =
+ std::make_shared<android::mediametrics::StatsdLog>(10);
+ android::mediametrics::AudioAnalytics audioAnalytics{statsdLog};
while (fdp.remaining_bytes()) {
auto item = std::make_shared<mediametrics::Item>(fdp.ConsumeRandomLengthString().c_str());
diff --git a/services/mediametrics/iface_statsd.cpp b/services/mediametrics/iface_statsd.cpp
index b7c5296..df42184 100644
--- a/services/mediametrics/iface_statsd.cpp
+++ b/services/mediametrics/iface_statsd.cpp
@@ -48,10 +48,7 @@
// has its own routine to handle this.
//
-bool enabled_statsd = true;
-
-using statsd_pusher = bool (*)(const mediametrics::Item *);
-using statsd_puller = bool (*)(const mediametrics::Item *, AStatsEventList *);
+static bool enabled_statsd = true;
namespace {
template<typename Handler, typename... Args>
@@ -68,15 +65,17 @@
}
if (handlers.count(key)) {
- return (handlers.at(key))(item.get(), args...);
+ return (handlers.at(key))(item, args...);
}
return false;
}
} // namespace
// give me a record, I'll look at the type and upload appropriately
-bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item) {
- static const std::map<std::string, statsd_pusher> statsd_pushers =
+bool dump2Statsd(
+ const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog) {
+ static const std::map<std::string, statsd_pusher*> statsd_pushers =
{
{ "audiopolicy", statsd_audiopolicy },
{ "audiorecord", statsd_audiorecord },
@@ -91,11 +90,11 @@
{ "nuplayer2", statsd_nuplayer },
{ "recorder", statsd_recorder },
};
- return dump2StatsdInternal(statsd_pushers, item);
+ return dump2StatsdInternal(statsd_pushers, item, statsdLog);
}
bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item, AStatsEventList* out) {
- static const std::map<std::string, statsd_puller> statsd_pullers =
+ static const std::map<std::string, statsd_puller*> statsd_pullers =
{
{ "mediadrm", statsd_mediadrm_puller },
};
diff --git a/services/mediametrics/iface_statsd.h b/services/mediametrics/iface_statsd.h
index 1b6c79a..00ca662 100644
--- a/services/mediametrics/iface_statsd.h
+++ b/services/mediametrics/iface_statsd.h
@@ -22,26 +22,29 @@
class Item;
}
-extern bool enabled_statsd;
-
+using statsd_pusher = bool (const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog);
// component specific dumpers
-extern bool statsd_audiopolicy(const mediametrics::Item *);
-extern bool statsd_audiorecord(const mediametrics::Item *);
-extern bool statsd_audiothread(const mediametrics::Item *);
-extern bool statsd_audiotrack(const mediametrics::Item *);
-extern bool statsd_codec(const mediametrics::Item *);
-extern bool statsd_extractor(const mediametrics::Item *);
-extern bool statsd_mediaparser(const mediametrics::Item *);
-extern bool statsd_nuplayer(const mediametrics::Item *);
-extern bool statsd_recorder(const mediametrics::Item *);
+extern statsd_pusher statsd_audiopolicy;
+extern statsd_pusher statsd_audiorecord;
+extern statsd_pusher statsd_audiothread;
+extern statsd_pusher statsd_audiotrack;
+extern statsd_pusher statsd_codec;
+extern statsd_pusher statsd_extractor;
+extern statsd_pusher statsd_mediaparser;
-extern bool statsd_mediadrm(const mediametrics::Item *);
-extern bool statsd_drmmanager(const mediametrics::Item *);
+extern statsd_pusher statsd_nuplayer;
+extern statsd_pusher statsd_recorder;
+extern statsd_pusher statsd_mediadrm;
+extern statsd_pusher statsd_drmmanager;
+using statsd_puller = bool (const std::shared_ptr<const mediametrics::Item>& item,
+ AStatsEventList *);
// component specific pullers
-extern bool statsd_mediadrm_puller(const mediametrics::Item *, AStatsEventList *);
+extern statsd_puller statsd_mediadrm_puller;
-bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item);
+bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog);
bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item, AStatsEventList* out);
} // namespace android
diff --git a/services/mediametrics/statsd_audiopolicy.cpp b/services/mediametrics/statsd_audiopolicy.cpp
index 6ef2f2c..f44b7c4 100644
--- a/services/mediametrics/statsd_audiopolicy.cpp
+++ b/services/mediametrics/statsd_audiopolicy.cpp
@@ -37,16 +37,16 @@
namespace android {
-bool statsd_audiopolicy(const mediametrics::Item *item)
+bool statsd_audiopolicy(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -60,35 +60,35 @@
metrics_proto.set_status(status);
}
//string char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
- std::string rqst_src;
- if (item->getString("android.media.audiopolicy.rqst.src", &rqst_src)) {
- metrics_proto.set_request_source(std::move(rqst_src));
+ std::string request_source;
+ if (item->getString("android.media.audiopolicy.rqst.src", &request_source)) {
+ metrics_proto.set_request_source(request_source);
}
//string char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
- std::string rqst_pkg;
- if (item->getString("android.media.audiopolicy.rqst.pkg", &rqst_pkg)) {
- metrics_proto.set_request_package(std::move(rqst_pkg));
+ std::string request_package;
+ if (item->getString("android.media.audiopolicy.rqst.pkg", &request_package)) {
+ metrics_proto.set_request_package(request_package);
}
//int32 char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
- int32_t rqst_session = -1;
- if (item->getInt32("android.media.audiopolicy.rqst.session", &rqst_session)) {
- metrics_proto.set_request_session(rqst_session);
+ int32_t request_session = -1;
+ if (item->getInt32("android.media.audiopolicy.rqst.session", &request_session)) {
+ metrics_proto.set_request_session(request_session);
}
//string char kAudioPolicyRqstDevice[] = "android.media.audiopolicy.rqst.device";
- std::string rqst_device;
- if (item->getString("android.media.audiopolicy.rqst.device", &rqst_device)) {
- metrics_proto.set_request_device(std::move(rqst_device));
+ std::string request_device;
+ if (item->getString("android.media.audiopolicy.rqst.device", &request_device)) {
+ metrics_proto.set_request_device(request_device);
}
//string char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
- std::string active_src;
- if (item->getString("android.media.audiopolicy.active.src", &active_src)) {
- metrics_proto.set_active_source(std::move(active_src));
+ std::string active_source;
+ if (item->getString("android.media.audiopolicy.active.src", &active_source)) {
+ metrics_proto.set_active_source(active_source);
}
//string char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
- std::string active_pkg;
- if (item->getString("android.media.audiopolicy.active.pkg", &active_pkg)) {
- metrics_proto.set_active_package(std::move(active_pkg));
+ std::string active_package;
+ if (item->getString("android.media.audiopolicy.active.pkg", &active_package)) {
+ metrics_proto.set_active_package(active_package);
}
//int32 char kAudioPolicyActiveSession[] = "android.media.audiopolicy.active.session";
int32_t active_session = -1;
@@ -98,27 +98,40 @@
//string char kAudioPolicyActiveDevice[] = "android.media.audiopolicy.active.device";
std::string active_device;
if (item->getString("android.media.audiopolicy.active.device", &active_device)) {
- metrics_proto.set_active_device(std::move(active_device));
+ metrics_proto.set_active_device(active_device);
}
-
std::string serialized;
if (!metrics_proto.SerializeToString(&serialized)) {
ALOGE("Failed to serialize audipolicy metrics");
return false;
}
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_AUDIOPOLICY_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_AUDIOPOLICY_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_audiopolicy_reported:"
+ << android::util::MEDIAMETRICS_AUDIOPOLICY_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
-
+ << " status:" << status
+ << " request_source:" << request_source
+ << " request_package:" << request_package
+ << " request_session:" << request_session
+ << " request_device:" << request_device
+ << " active_source:" << active_source
+ << " active_package:" << active_package
+ << " active_session:" << active_session
+ << " active_device:" << active_device
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_AUDIOPOLICY_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_audiorecord.cpp b/services/mediametrics/statsd_audiorecord.cpp
index db809dc..70a67ae 100644
--- a/services/mediametrics/statsd_audiorecord.cpp
+++ b/services/mediametrics/statsd_audiorecord.cpp
@@ -38,16 +38,15 @@
namespace android {
-bool statsd_audiorecord(const mediametrics::Item *item)
-{
+bool statsd_audiorecord(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog) {
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -57,12 +56,12 @@
//
std::string encoding;
if (item->getString("android.media.audiorecord.encoding", &encoding)) {
- metrics_proto.set_encoding(std::move(encoding));
+ metrics_proto.set_encoding(encoding);
}
std::string source;
if (item->getString("android.media.audiorecord.source", &source)) {
- metrics_proto.set_source(std::move(source));
+ metrics_proto.set_source(source);
}
int32_t latency = -1;
@@ -80,14 +79,14 @@
metrics_proto.set_channels(channels);
}
- int64_t createdMs = -1;
- if (item->getInt64("android.media.audiorecord.createdMs", &createdMs)) {
- metrics_proto.set_created_millis(createdMs);
+ int64_t created_millis = -1;
+ if (item->getInt64("android.media.audiorecord.createdMs", &created_millis)) {
+ metrics_proto.set_created_millis(created_millis);
}
- int64_t durationMs = -1;
- if (item->getInt64("android.media.audiorecord.durationMs", &durationMs)) {
- metrics_proto.set_duration_millis(durationMs);
+ int64_t duration_millis = -1;
+ if (item->getInt64("android.media.audiorecord.durationMs", &duration_millis)) {
+ metrics_proto.set_duration_millis(duration_millis);
}
int32_t count = -1;
@@ -95,44 +94,43 @@
metrics_proto.set_count(count);
}
- int32_t errcode = -1;
- if (item->getInt32("android.media.audiorecord.errcode", &errcode)) {
- metrics_proto.set_error_code(errcode);
- } else if (item->getInt32("android.media.audiorecord.lastError.code", &errcode)) {
- metrics_proto.set_error_code(errcode);
+ int32_t error_code = -1;
+ if (item->getInt32("android.media.audiorecord.errcode", &error_code)) {
+ metrics_proto.set_error_code(error_code);
+ } else if (item->getInt32("android.media.audiorecord.lastError.code", &error_code)) {
+ metrics_proto.set_error_code(error_code);
}
- std::string errfunc;
- if (item->getString("android.media.audiorecord.errfunc", &errfunc)) {
- metrics_proto.set_error_function(std::move(errfunc));
- } else if (item->getString("android.media.audiorecord.lastError.at", &errfunc)) {
- metrics_proto.set_error_function(std::move(errfunc));
+ std::string error_function;
+ if (item->getString("android.media.audiorecord.errfunc", &error_function)) {
+ metrics_proto.set_error_function(error_function);
+ } else if (item->getString("android.media.audiorecord.lastError.at", &error_function)) {
+ metrics_proto.set_error_function(error_function);
}
- // portId (int32)
int32_t port_id = -1;
if (item->getInt32("android.media.audiorecord.portId", &port_id)) {
metrics_proto.set_port_id(count);
}
- // frameCount (int32)
- int32_t frameCount = -1;
- if (item->getInt32("android.media.audiorecord.frameCount", &frameCount)) {
- metrics_proto.set_frame_count(frameCount);
+
+ int32_t frame_count = -1;
+ if (item->getInt32("android.media.audiorecord.frameCount", &frame_count)) {
+ metrics_proto.set_frame_count(frame_count);
}
- // attributes (string)
+
std::string attributes;
if (item->getString("android.media.audiorecord.attributes", &attributes)) {
- metrics_proto.set_attributes(std::move(attributes));
+ metrics_proto.set_attributes(attributes);
}
- // channelMask (int64)
- int64_t channelMask = -1;
- if (item->getInt64("android.media.audiorecord.channelMask", &channelMask)) {
- metrics_proto.set_channel_mask(channelMask);
+
+ int64_t channel_mask = -1;
+ if (item->getInt64("android.media.audiorecord.channelMask", &channel_mask)) {
+ metrics_proto.set_channel_mask(channel_mask);
}
- // startcount (int64)
- int64_t startcount = -1;
- if (item->getInt64("android.media.audiorecord.startcount", &startcount)) {
- metrics_proto.set_start_count(startcount);
+
+ int64_t start_count = -1;
+ if (item->getInt64("android.media.audiorecord.startcount", &start_count)) {
+ metrics_proto.set_start_count(start_count);
}
std::string serialized;
@@ -145,21 +143,44 @@
// log_session_id (string)
std::string logSessionId;
(void)item->getString("android.media.audiorecord.logSessionId", &logSessionId);
- const auto logSessionIdForStats =
+ const auto log_session_id =
mediametrics::stringutils::sanitizeLogSessionId(logSessionId);
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_AUDIORECORD_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized,
- logSessionIdForStats.c_str());
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_AUDIORECORD_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized,
+ log_session_id.c_str());
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_audiorecord_reported:"
+ << android::util::MEDIAMETRICS_AUDIORECORD_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ << " encoding:" << encoding
+ << " source:" << source
+ << " latency:" << latency
+ << " samplerate:" << samplerate
+ << " channels:" << channels
+ << " created_millis:" << created_millis
+ << " duration_millis:" << duration_millis
+ << " count:" << count
+ << " error_code:" << error_code
+ << " error_function:" << error_function
+ << " port_id:" << port_id
+ << " frame_count:" << frame_count
+ << " attributes:" << attributes
+ << " channel_mask:" << channel_mask
+ << " start_count:" << start_count
+
+ << " log_session_id:" << log_session_id
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_AUDIORECORD_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_audiothread.cpp b/services/mediametrics/statsd_audiothread.cpp
index 2ad2562..34cc923 100644
--- a/services/mediametrics/statsd_audiothread.cpp
+++ b/services/mediametrics/statsd_audiothread.cpp
@@ -37,16 +37,16 @@
namespace android {
-bool statsd_audiothread(const mediametrics::Item *item)
+bool statsd_audiothread(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -68,17 +68,17 @@
if (item->getInt32(MM_PREFIX "samplerate", &samplerate)) {
metrics_proto.set_samplerate(samplerate);
}
- std::string workhist;
- if (item->getString(MM_PREFIX "workMs.hist", &workhist)) {
- metrics_proto.set_work_millis_hist(std::move(workhist));
+ std::string work_millis_hist;
+ if (item->getString(MM_PREFIX "workMs.hist", &work_millis_hist)) {
+ metrics_proto.set_work_millis_hist(work_millis_hist);
}
- std::string latencyhist;
- if (item->getString(MM_PREFIX "latencyMs.hist", &latencyhist)) {
- metrics_proto.set_latency_millis_hist(std::move(latencyhist));
+ std::string latency_millis_hist;
+ if (item->getString(MM_PREFIX "latencyMs.hist", &latency_millis_hist)) {
+ metrics_proto.set_latency_millis_hist(latency_millis_hist);
}
- std::string warmuphist;
- if (item->getString(MM_PREFIX "warmupMs.hist", &warmuphist)) {
- metrics_proto.set_warmup_millis_hist(std::move(warmuphist));
+ std::string warmup_millis_hist;
+ if (item->getString(MM_PREFIX "warmupMs.hist", &warmup_millis_hist)) {
+ metrics_proto.set_warmup_millis_hist(warmup_millis_hist);
}
int64_t underruns = -1;
if (item->getInt64(MM_PREFIX "underruns", &underruns)) {
@@ -88,101 +88,99 @@
if (item->getInt64(MM_PREFIX "overruns", &overruns)) {
metrics_proto.set_overruns(overruns);
}
- int64_t activeMs = -1;
- if (item->getInt64(MM_PREFIX "activeMs", &activeMs)) {
- metrics_proto.set_active_millis(activeMs);
+ int64_t active_millis = -1;
+ if (item->getInt64(MM_PREFIX "activeMs", &active_millis)) {
+ metrics_proto.set_active_millis(active_millis);
}
- int64_t durationMs = -1;
- if (item->getInt64(MM_PREFIX "durationMs", &durationMs)) {
- metrics_proto.set_duration_millis(durationMs);
+ int64_t duration_millis = -1;
+ if (item->getInt64(MM_PREFIX "durationMs", &duration_millis)) {
+ metrics_proto.set_duration_millis(duration_millis);
}
- // item->setInt32(MM_PREFIX "id", (int32_t)mId); // IO handle
int32_t id = -1;
if (item->getInt32(MM_PREFIX "id", &id)) {
metrics_proto.set_id(id);
}
- // item->setInt32(MM_PREFIX "portId", (int32_t)mPortId);
+
int32_t port_id = -1;
- if (item->getInt32(MM_PREFIX "portId", &id)) {
+ if (item->getInt32(MM_PREFIX "portId", &port_id)) {
metrics_proto.set_port_id(port_id);
}
// item->setCString(MM_PREFIX "type", threadTypeToString(mType));
std::string type;
if (item->getString(MM_PREFIX "type", &type)) {
- metrics_proto.set_type(std::move(type));
+ metrics_proto.set_type(type);
}
- // item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
+
int32_t sample_rate = -1;
if (item->getInt32(MM_PREFIX "sampleRate", &sample_rate)) {
metrics_proto.set_sample_rate(sample_rate);
}
- // item->setInt64(MM_PREFIX "channelMask", (int64_t)mChannelMask);
+
int32_t channel_mask = -1;
if (item->getInt32(MM_PREFIX "channelMask", &channel_mask)) {
metrics_proto.set_channel_mask(channel_mask);
}
- // item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
+
std::string encoding;
if (item->getString(MM_PREFIX "encoding", &encoding)) {
- metrics_proto.set_encoding(std::move(encoding));
+ metrics_proto.set_encoding(encoding);
}
- // item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
+
int32_t frame_count = -1;
if (item->getInt32(MM_PREFIX "frameCount", &frame_count)) {
metrics_proto.set_frame_count(frame_count);
}
- // item->setCString(MM_PREFIX "outDevice", toString(mOutDevice).c_str());
- std::string outDevice;
- if (item->getString(MM_PREFIX "outDevice", &outDevice)) {
- metrics_proto.set_output_device(std::move(outDevice));
- }
- // item->setCString(MM_PREFIX "inDevice", toString(mInDevice).c_str());
- std::string inDevice;
- if (item->getString(MM_PREFIX "inDevice", &inDevice)) {
- metrics_proto.set_input_device(std::move(inDevice));
- }
- // item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
- double iojitters_ms_mean = -1;
- if (item->getDouble(MM_PREFIX "ioJitterMs.mean", &iojitters_ms_mean)) {
- metrics_proto.set_io_jitter_mean_millis(iojitters_ms_mean);
- }
- // item->setDouble(MM_PREFIX "ioJitterMs.std", mIoJitterMs.getStdDev());
- double iojitters_ms_std = -1;
- if (item->getDouble(MM_PREFIX "ioJitterMs.std", &iojitters_ms_std)) {
- metrics_proto.set_io_jitter_stddev_millis(iojitters_ms_std);
- }
- // item->setDouble(MM_PREFIX "processTimeMs.mean", mProcessTimeMs.getMean());
- double process_time_ms_mean = -1;
- if (item->getDouble(MM_PREFIX "processTimeMs.mean", &process_time_ms_mean)) {
- metrics_proto.set_process_time_mean_millis(process_time_ms_mean);
- }
- // item->setDouble(MM_PREFIX "processTimeMs.std", mProcessTimeMs.getStdDev());
- double process_time_ms_std = -1;
- if (item->getDouble(MM_PREFIX "processTimeMs.std", &process_time_ms_std)) {
- metrics_proto.set_process_time_stddev_millis(process_time_ms_std);
- }
- // item->setDouble(MM_PREFIX "timestampJitterMs.mean", tsjitter.getMean());
- double timestamp_jitter_ms_mean = -1;
- if (item->getDouble(MM_PREFIX "timestampJitterMs.mean", ×tamp_jitter_ms_mean)) {
- metrics_proto.set_timestamp_jitter_mean_millis(timestamp_jitter_ms_mean);
- }
- // item->setDouble(MM_PREFIX "timestampJitterMs.std", tsjitter.getStdDev());
- double timestamp_jitter_ms_stddev = -1;
- if (item->getDouble(MM_PREFIX "timestampJitterMs.std", ×tamp_jitter_ms_stddev)) {
- metrics_proto.set_timestamp_jitter_stddev_millis(timestamp_jitter_ms_stddev);
- }
- // item->setDouble(MM_PREFIX "latencyMs.mean", mLatencyMs.getMean());
- double latency_ms_mean = -1;
- if (item->getDouble(MM_PREFIX "latencyMs.mean", &latency_ms_mean)) {
- metrics_proto.set_latency_mean_millis(latency_ms_mean);
- }
- // item->setDouble(MM_PREFIX "latencyMs.std", mLatencyMs.getStdDev());
- double latency_ms_stddev = -1;
- if (item->getDouble(MM_PREFIX "latencyMs.std", &latency_ms_stddev)) {
- metrics_proto.set_latency_stddev_millis(latency_ms_stddev);
+
+ std::string output_device;
+ if (item->getString(MM_PREFIX "outDevice", &output_device)) {
+ metrics_proto.set_output_device(output_device);
}
+ std::string input_device;
+ if (item->getString(MM_PREFIX "inDevice", &input_device)) {
+ metrics_proto.set_input_device(input_device);
+ }
+
+ double io_jitter_mean_millis = -1;
+ if (item->getDouble(MM_PREFIX "ioJitterMs.mean", &io_jitter_mean_millis)) {
+ metrics_proto.set_io_jitter_mean_millis(io_jitter_mean_millis);
+ }
+
+ double io_jitter_stddev_millis = -1;
+ if (item->getDouble(MM_PREFIX "ioJitterMs.std", &io_jitter_stddev_millis)) {
+ metrics_proto.set_io_jitter_stddev_millis(io_jitter_stddev_millis);
+ }
+
+ double process_time_mean_millis = -1;
+ if (item->getDouble(MM_PREFIX "processTimeMs.mean", &process_time_mean_millis)) {
+ metrics_proto.set_process_time_mean_millis(process_time_mean_millis);
+ }
+
+ double process_time_stddev_millis = -1;
+ if (item->getDouble(MM_PREFIX "processTimeMs.std", &process_time_stddev_millis)) {
+ metrics_proto.set_process_time_stddev_millis(process_time_stddev_millis);
+ }
+
+ double timestamp_jitter_mean_millis = -1;
+ if (item->getDouble(MM_PREFIX "timestampJitterMs.mean", ×tamp_jitter_mean_millis)) {
+ metrics_proto.set_timestamp_jitter_mean_millis(timestamp_jitter_mean_millis);
+ }
+
+ double timestamp_jitter_stddev_millis = -1;
+ if (item->getDouble(MM_PREFIX "timestampJitterMs.std", ×tamp_jitter_stddev_millis)) {
+ metrics_proto.set_timestamp_jitter_stddev_millis(timestamp_jitter_stddev_millis);
+ }
+
+ double latency_mean_millis = -1;
+ if (item->getDouble(MM_PREFIX "latencyMs.mean", &latency_mean_millis)) {
+ metrics_proto.set_latency_mean_millis(latency_mean_millis);
+ }
+
+ double latency_stddev_millis = -1;
+ if (item->getDouble(MM_PREFIX "latencyMs.std", &latency_stddev_millis)) {
+ metrics_proto.set_latency_stddev_millis(latency_stddev_millis);
+ }
std::string serialized;
if (!metrics_proto.SerializeToString(&serialized)) {
@@ -190,17 +188,50 @@
return false;
}
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_AUDIOTHREAD_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_AUDIOTHREAD_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_audiothread_reported:"
+ << android::util::MEDIAMETRICS_AUDIOTHREAD_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ << " type:" << type
+ << " framecount:" << framecount
+ << " samplerate:" << samplerate
+ << " work_millis_hist:" << work_millis_hist
+ << " latency_millis_hist:" << latency_millis_hist
+ << " warmup_millis_hist:" << warmup_millis_hist
+ << " underruns:" << underruns
+ << " overruns:" << overruns
+ << " active_millis:" << active_millis
+ << " duration_millis:" << duration_millis
+ << " id:" << id
+ << " port_id:" << port_id
+ << " sample_rate:" << sample_rate
+ << " channel_mask:" << channel_mask
+ << " encoding:" << encoding
+ << " frame_count:" << frame_count
+ << " output_device:" << output_device
+ << " input_device:" << input_device
+ << " io_jitter_mean_millis:" << io_jitter_mean_millis
+ << " io_jitter_stddev_millis:" << io_jitter_stddev_millis
+
+ << " process_time_mean_millis:" << process_time_mean_millis
+ << " process_time_stddev_millis:" << process_time_stddev_millis
+ << " timestamp_jitter_mean_millis:" << timestamp_jitter_mean_millis
+ << " timestamp_jitter_stddev_millis:" << timestamp_jitter_stddev_millis
+ << " latency_mean_millis:" << latency_mean_millis
+ << " latency_stddev_millis:" << latency_stddev_millis
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_AUDIOTHREAD_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_audiotrack.cpp b/services/mediametrics/statsd_audiotrack.cpp
index fd809c8..fe269a1 100644
--- a/services/mediametrics/statsd_audiotrack.cpp
+++ b/services/mediametrics/statsd_audiotrack.cpp
@@ -38,16 +38,16 @@
namespace android {
-bool statsd_audiotrack(const mediametrics::Item *item)
+bool statsd_audiotrack(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -58,52 +58,52 @@
// static constexpr char kAudioTrackStreamType[] = "android.media.audiotrack.streamtype";
// optional string streamType;
- std::string streamtype;
- if (item->getString("android.media.audiotrack.streamtype", &streamtype)) {
- metrics_proto.set_stream_type(std::move(streamtype));
+ std::string stream_type;
+ if (item->getString("android.media.audiotrack.streamtype", &stream_type)) {
+ metrics_proto.set_stream_type(stream_type);
}
// static constexpr char kAudioTrackContentType[] = "android.media.audiotrack.type";
// optional string contentType;
- std::string contenttype;
- if (item->getString("android.media.audiotrack.type", &contenttype)) {
- metrics_proto.set_content_type(std::move(contenttype));
+ std::string content_type;
+ if (item->getString("android.media.audiotrack.type", &content_type)) {
+ metrics_proto.set_content_type(content_type);
}
// static constexpr char kAudioTrackUsage[] = "android.media.audiotrack.usage";
// optional string trackUsage;
- std::string trackusage;
- if (item->getString("android.media.audiotrack.usage", &trackusage)) {
- metrics_proto.set_track_usage(std::move(trackusage));
+ std::string track_usage;
+ if (item->getString("android.media.audiotrack.usage", &track_usage)) {
+ metrics_proto.set_track_usage(track_usage);
}
// static constexpr char kAudioTrackSampleRate[] = "android.media.audiotrack.samplerate";
// optional int32 samplerate;
- int32_t samplerate = -1;
- if (item->getInt32("android.media.audiotrack.samplerate", &samplerate)) {
- metrics_proto.set_sample_rate(samplerate);
+ int32_t sample_rate = -1;
+ if (item->getInt32("android.media.audiotrack.samplerate", &sample_rate)) {
+ metrics_proto.set_sample_rate(sample_rate);
}
// static constexpr char kAudioTrackChannelMask[] = "android.media.audiotrack.channelmask";
// optional int64 channelMask;
- int64_t channelMask = -1;
- if (item->getInt64("android.media.audiotrack.channelmask", &channelMask)) {
- metrics_proto.set_channel_mask(channelMask);
+ int64_t channel_mask = -1;
+ if (item->getInt64("android.media.audiotrack.channelmask", &channel_mask)) {
+ metrics_proto.set_channel_mask(channel_mask);
}
// NB: These are not yet exposed as public Java API constants.
// static constexpr char kAudioTrackUnderrunFrames[] = "android.media.audiotrack.underrunframes";
// optional int32 underrunframes;
- int32_t underrunframes = -1;
- if (item->getInt32("android.media.audiotrack.underrunframes", &underrunframes)) {
- metrics_proto.set_underrun_frames(underrunframes);
+ int32_t underrun_frames = -1;
+ if (item->getInt32("android.media.audiotrack.underrunframes", &underrun_frames)) {
+ metrics_proto.set_underrun_frames(underrun_frames);
}
// static constexpr char kAudioTrackStartupGlitch[] = "android.media.audiotrack.glitch.startup";
// optional int32 startupglitch;
- int32_t startupglitch = -1;
- if (item->getInt32("android.media.audiotrack.glitch.startup", &startupglitch)) {
- metrics_proto.set_startup_glitch(startupglitch);
+ int32_t startup_glitch = -1;
+ if (item->getInt32("android.media.audiotrack.glitch.startup", &startup_glitch)) {
+ metrics_proto.set_startup_glitch(startup_glitch);
}
// portId (int32)
@@ -114,7 +114,7 @@
// encoding (string)
std::string encoding;
if (item->getString("android.media.audiotrack.encoding", &encoding)) {
- metrics_proto.set_encoding(std::move(encoding));
+ metrics_proto.set_encoding(encoding);
}
// frameCount (int32)
int32_t frame_count = -1;
@@ -124,7 +124,7 @@
// attributes (string)
std::string attributes;
if (item->getString("android.media.audiotrack.attributes", &attributes)) {
- metrics_proto.set_attributes(std::move(attributes));
+ metrics_proto.set_attributes(attributes);
}
std::string serialized;
@@ -137,21 +137,40 @@
// log_session_id (string)
std::string logSessionId;
(void)item->getString("android.media.audiotrack.logSessionId", &logSessionId);
- const auto logSessionIdForStats =
+ const auto log_session_id =
mediametrics::stringutils::sanitizeLogSessionId(logSessionId);
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_AUDIOTRACK_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized,
- logSessionIdForStats.c_str());
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_AUDIOTRACK_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized,
+ log_session_id.c_str());
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_audiotrack_reported:"
+ << android::util::MEDIAMETRICS_AUDIOTRACK_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ << " stream_type:" << stream_type
+ << " content_type:" << content_type
+ << " track_usage:" << track_usage
+ << " sample_rate:" << sample_rate
+ << " channel_mask:" << channel_mask
+ << " underrun_frames:" << underrun_frames
+ << " startup_glitch:" << startup_glitch
+ << " port_id:" << port_id
+ << " encoding:" << encoding
+ << " frame_count:" << frame_count
+ << " attributes:" << attributes
+
+ << " log_session_id:" << log_session_id
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_AUDIOTRACK_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_codec.cpp b/services/mediametrics/statsd_codec.cpp
index 1c5ab77..8a2158f 100644
--- a/services/mediametrics/statsd_codec.cpp
+++ b/services/mediametrics/statsd_codec.cpp
@@ -38,16 +38,16 @@
namespace android {
-bool statsd_codec(const mediametrics::Item *item)
+bool statsd_codec(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -58,39 +58,39 @@
// android.media.mediacodec.codec string
std::string codec;
if (item->getString("android.media.mediacodec.codec", &codec)) {
- metrics_proto.set_codec(std::move(codec));
+ metrics_proto.set_codec(codec);
}
- // android.media.mediacodec.mime string
+
std::string mime;
if (item->getString("android.media.mediacodec.mime", &mime)) {
- metrics_proto.set_mime(std::move(mime));
+ metrics_proto.set_mime(mime);
}
- // android.media.mediacodec.mode string
+
std::string mode;
if ( item->getString("android.media.mediacodec.mode", &mode)) {
- metrics_proto.set_mode(std::move(mode));
+ metrics_proto.set_mode(mode);
}
- // android.media.mediacodec.encoder int32
+
int32_t encoder = -1;
if ( item->getInt32("android.media.mediacodec.encoder", &encoder)) {
metrics_proto.set_encoder(encoder);
}
- // android.media.mediacodec.secure int32
+
int32_t secure = -1;
if ( item->getInt32("android.media.mediacodec.secure", &secure)) {
metrics_proto.set_secure(secure);
}
- // android.media.mediacodec.width int32
+
int32_t width = -1;
if ( item->getInt32("android.media.mediacodec.width", &width)) {
metrics_proto.set_width(width);
}
- // android.media.mediacodec.height int32
+
int32_t height = -1;
if ( item->getInt32("android.media.mediacodec.height", &height)) {
metrics_proto.set_height(height);
}
- // android.media.mediacodec.rotation-degrees int32
+
int32_t rotation = -1;
if ( item->getInt32("android.media.mediacodec.rotation-degrees", &rotation)) {
metrics_proto.set_rotation(rotation);
@@ -100,90 +100,89 @@
if ( item->getInt32("android.media.mediacodec.crypto", &crypto)) {
metrics_proto.set_crypto(crypto);
}
- // android.media.mediacodec.profile int32
+
int32_t profile = -1;
if ( item->getInt32("android.media.mediacodec.profile", &profile)) {
metrics_proto.set_profile(profile);
}
- // android.media.mediacodec.level int32
+
int32_t level = -1;
if ( item->getInt32("android.media.mediacodec.level", &level)) {
metrics_proto.set_level(level);
}
- // android.media.mediacodec.maxwidth int32
- int32_t maxwidth = -1;
- if ( item->getInt32("android.media.mediacodec.maxwidth", &maxwidth)) {
- metrics_proto.set_max_width(maxwidth);
+
+ int32_t max_width = -1;
+ if ( item->getInt32("android.media.mediacodec.maxwidth", &max_width)) {
+ metrics_proto.set_max_width(max_width);
}
- // android.media.mediacodec.maxheight int32
- int32_t maxheight = -1;
- if ( item->getInt32("android.media.mediacodec.maxheight", &maxheight)) {
- metrics_proto.set_max_height(maxheight);
+
+ int32_t max_height = -1;
+ if ( item->getInt32("android.media.mediacodec.maxheight", &max_height)) {
+ metrics_proto.set_max_height(max_height);
}
- // android.media.mediacodec.errcode int32
- int32_t errcode = -1;
- if ( item->getInt32("android.media.mediacodec.errcode", &errcode)) {
- metrics_proto.set_error_code(errcode);
+
+ int32_t error_code = -1;
+ if ( item->getInt32("android.media.mediacodec.errcode", &error_code)) {
+ metrics_proto.set_error_code(error_code);
}
- // android.media.mediacodec.errstate string
- std::string errstate;
- if ( item->getString("android.media.mediacodec.errstate", &errstate)) {
- metrics_proto.set_error_state(std::move(errstate));
+
+ std::string error_state;
+ if ( item->getString("android.media.mediacodec.errstate", &error_state)) {
+ metrics_proto.set_error_state(error_state);
}
- // android.media.mediacodec.latency.max int64
+
int64_t latency_max = -1;
if ( item->getInt64("android.media.mediacodec.latency.max", &latency_max)) {
metrics_proto.set_latency_max(latency_max);
}
- // android.media.mediacodec.latency.min int64
+
int64_t latency_min = -1;
if ( item->getInt64("android.media.mediacodec.latency.min", &latency_min)) {
metrics_proto.set_latency_min(latency_min);
}
- // android.media.mediacodec.latency.avg int64
+
int64_t latency_avg = -1;
if ( item->getInt64("android.media.mediacodec.latency.avg", &latency_avg)) {
metrics_proto.set_latency_avg(latency_avg);
}
- // android.media.mediacodec.latency.n int64
+
int64_t latency_count = -1;
if ( item->getInt64("android.media.mediacodec.latency.n", &latency_count)) {
metrics_proto.set_latency_count(latency_count);
}
- // android.media.mediacodec.latency.unknown int64
+
int64_t latency_unknown = -1;
if ( item->getInt64("android.media.mediacodec.latency.unknown", &latency_unknown)) {
metrics_proto.set_latency_unknown(latency_unknown);
}
- // android.media.mediacodec.queueSecureInputBufferError int32
- if (int32_t queueSecureInputBufferError = -1;
- item->getInt32("android.media.mediacodec.queueSecureInputBufferError",
- &queueSecureInputBufferError)) {
- metrics_proto.set_queue_secure_input_buffer_error(queueSecureInputBufferError);
+
+ int32_t queue_secure_input_buffer_error = -1;
+ if (item->getInt32("android.media.mediacodec.queueSecureInputBufferError",
+ &queue_secure_input_buffer_error)) {
+ metrics_proto.set_queue_secure_input_buffer_error(queue_secure_input_buffer_error);
}
- // android.media.mediacodec.queueInputBufferError int32
- if (int32_t queueInputBufferError = -1;
- item->getInt32("android.media.mediacodec.queueInputBufferError",
- &queueInputBufferError)) {
- metrics_proto.set_queue_input_buffer_error(queueInputBufferError);
+
+ int32_t queue_input_buffer_error = -1;
+ if (item->getInt32("android.media.mediacodec.queueInputBufferError",
+ &queue_input_buffer_error)) {
+ metrics_proto.set_queue_input_buffer_error(queue_input_buffer_error);
}
// android.media.mediacodec.latency.hist NOT EMITTED
- // android.media.mediacodec.bitrate_mode string
std::string bitrate_mode;
if (item->getString("android.media.mediacodec.bitrate_mode", &bitrate_mode)) {
- metrics_proto.set_bitrate_mode(std::move(bitrate_mode));
+ metrics_proto.set_bitrate_mode(bitrate_mode);
}
- // android.media.mediacodec.bitrate int32
+
int32_t bitrate = -1;
if (item->getInt32("android.media.mediacodec.bitrate", &bitrate)) {
metrics_proto.set_bitrate(bitrate);
}
- // android.media.mediacodec.lifetimeMs int64
- int64_t lifetimeMs = -1;
- if ( item->getInt64("android.media.mediacodec.lifetimeMs", &lifetimeMs)) {
- lifetimeMs = mediametrics::bucket_time_minutes(lifetimeMs);
- metrics_proto.set_lifetime_millis(lifetimeMs);
+
+ int64_t lifetime_millis = -1;
+ if (item->getInt64("android.media.mediacodec.lifetimeMs", &lifetime_millis)) {
+ lifetime_millis = mediametrics::bucket_time_minutes(lifetime_millis);
+ metrics_proto.set_lifetime_millis(lifetime_millis);
}
// new for S; need to plumb through to westworld
@@ -201,18 +200,51 @@
ALOGE("Failed to serialize codec metrics");
return false;
}
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_CODEC_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_codec_reported:"
+ << android::util::MEDIAMETRICS_CODEC_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_CODEC_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
+ << " codec:" << codec
+ << " mime:" << mime
+ << " mode:" << mode
+ << " encoder:" << encoder
+ << " secure:" << secure
+ << " width:" << width
+ << " height:" << height
+ << " rotation:" << rotation
+ << " crypto:" << crypto
+ << " profile:" << profile
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ << " level:" << level
+ << " max_width:" << max_width
+ << " max_height:" << max_height
+ << " error_code:" << error_code
+ << " error_state:" << error_state
+ << " latency_max:" << latency_max
+ << " latency_min:" << latency_min
+ << " latency_avg:" << latency_avg
+ << " latency_count:" << latency_count
+ << " latency_unknown:" << latency_unknown
+ << " queue_input_buffer_error:" << queue_input_buffer_error
+ << " queue_secure_input_buffer_error:" << queue_secure_input_buffer_error
+ << " bitrate_mode:" << bitrate_mode
+ << " bitrate:" << bitrate
+ << " lifetime_millis:" << lifetime_millis
+ // TODO: add when log_session_id is merged.
+ // << " log_session_id:" << log_session_id
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_CODEC_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_drm.cpp b/services/mediametrics/statsd_drm.cpp
index 071c549..d043da5 100644
--- a/services/mediametrics/statsd_drm.cpp
+++ b/services/mediametrics/statsd_drm.cpp
@@ -43,53 +43,60 @@
namespace android {
// mediadrm
-bool statsd_mediadrm(const mediametrics::Item *item)
+bool statsd_mediadrm(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
std::string vendor;
(void) item->getString("vendor", &vendor);
std::string description;
(void) item->getString("description", &description);
- if (enabled_statsd) {
- // This field is left here for backward compatibility.
- // This field is not used anymore.
- const std::string kUnusedField("unused");
- android::util::BytesField bf_serialized(kUnusedField.c_str(), kUnusedField.size());
- android::util::stats_write(android::util::MEDIAMETRICS_MEDIADRM_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- vendor.c_str(),
- description.c_str(),
- bf_serialized);
- } else {
- ALOGV("NOT sending: mediadrm data(%s, %s)", vendor.c_str(), description.c_str());
- }
+ // This field is left here for backward compatibility.
+ // This field is not used anymore.
+ const std::string kUnusedField("unused");
+ android::util::BytesField bf_serialized(kUnusedField.c_str(), kUnusedField.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_MEDIADRM_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ vendor.c_str(),
+ description.c_str(),
+ bf_serialized);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_mediadrm_reported:"
+ << android::util::MEDIAMETRICS_MEDIADRM_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
+
+ << " vendor:" << vendor
+ << " description:" << description
+ // omitting serialized
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_MEDIADRM_REPORTED, log.str());
return true;
}
// drmmanager
-bool statsd_drmmanager(const mediametrics::Item *item)
+bool statsd_drmmanager(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
using namespace std::string_literals;
if (item == nullptr) return false;
- if (!enabled_statsd) {
- ALOGV("NOT sending: drmmanager data");
- return true;
- }
-
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
std::string plugin_id;
(void) item->getString("plugin_id", &plugin_id);
@@ -107,8 +114,9 @@
item->getInt64(("method"s + std::to_string(i)).c_str(), &methodCounts[i]);
}
- android::util::stats_write(android::util::MEDIAMETRICS_DRMMANAGER_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode, mediaApexVersion,
+ const int result = android::util::stats_write(android::util::MEDIAMETRICS_DRMMANAGER_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
plugin_id.c_str(), description.c_str(),
method_id, mime_types.c_str(),
methodCounts[0], methodCounts[1], methodCounts[2],
@@ -117,6 +125,25 @@
methodCounts[9], methodCounts[10], methodCounts[11],
methodCounts[12]);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_drmmanager_reported:"
+ << android::util::MEDIAMETRICS_DRMMANAGER_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
+
+ << " plugin_id:" << plugin_id
+ << " description:" << description
+ << " method_id:" << method_id
+ << " mime_types:" << mime_types;
+
+ for (size_t i = 0; i < methodCounts.size(); ++i) {
+ log << " method_" << i << ":" << methodCounts[i];
+ }
+ log << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_DRMMANAGER_REPORTED, log.str());
return true;
}
@@ -144,17 +171,13 @@
} // namespace
// |out| and its contents are memory-managed by statsd.
-bool statsd_mediadrm_puller(const mediametrics::Item* item, AStatsEventList* out)
+bool statsd_mediadrm_puller(
+ const std::shared_ptr<const mediametrics::Item>& item, AStatsEventList* out)
{
if (item == nullptr) {
return false;
}
- if (!enabled_statsd) {
- ALOGV("NOT pulling: mediadrm activity");
- return true;
- }
-
std::string serialized_metrics;
(void) item->getString("serialized_metrics", &serialized_metrics);
const auto framework_raw(base64DecodeNoPad(serialized_metrics));
diff --git a/services/mediametrics/statsd_extractor.cpp b/services/mediametrics/statsd_extractor.cpp
index 4180e0c..e228f07 100644
--- a/services/mediametrics/statsd_extractor.cpp
+++ b/services/mediametrics/statsd_extractor.cpp
@@ -37,16 +37,16 @@
namespace android {
-bool statsd_extractor(const mediametrics::Item *item)
+bool statsd_extractor(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -55,26 +55,25 @@
// flesh out the protobuf we'll hand off with our data
//
- // android.media.mediaextractor.fmt string
- std::string fmt;
- if (item->getString("android.media.mediaextractor.fmt", &fmt)) {
- metrics_proto.set_format(std::move(fmt));
- }
- // android.media.mediaextractor.mime string
- std::string mime;
- if (item->getString("android.media.mediaextractor.mime", &mime)) {
- metrics_proto.set_mime(std::move(mime));
- }
- // android.media.mediaextractor.ntrk int32
- int32_t ntrk = -1;
- if (item->getInt32("android.media.mediaextractor.ntrk", &ntrk)) {
- metrics_proto.set_tracks(ntrk);
+ std::string format;
+ if (item->getString("android.media.mediaextractor.fmt", &format)) {
+ metrics_proto.set_format(format);
}
- // android.media.mediaextractor.entry string
+ std::string mime;
+ if (item->getString("android.media.mediaextractor.mime", &mime)) {
+ metrics_proto.set_mime(mime);
+ }
+
+ int32_t tracks = -1;
+ if (item->getInt32("android.media.mediaextractor.ntrk", &tracks)) {
+ metrics_proto.set_tracks(tracks);
+ }
+
std::string entry_point_string;
+ stats::mediametrics::ExtractorData::EntryPoint entry_point =
+ stats::mediametrics::ExtractorData_EntryPoint_OTHER;
if (item->getString("android.media.mediaextractor.entry", &entry_point_string)) {
- stats::mediametrics::ExtractorData::EntryPoint entry_point;
if (entry_point_string == "sdk") {
entry_point = stats::mediametrics::ExtractorData_EntryPoint_SDK;
} else if (entry_point_string == "ndk-with-jvm") {
@@ -93,17 +92,30 @@
return false;
}
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_EXTRACTOR_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_EXTRACTOR_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_extractor_reported:"
+ << android::util::MEDIAMETRICS_EXTRACTOR_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ << " format:" << format
+ << " mime:" << mime
+ << " tracks:" << tracks
+ << " entry_point:" << entry_point_string << "(" << entry_point << ")"
+ // TODO: Add MediaExtractor log_session_id
+ // << " log_session_id:" << log_session_id
+
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_EXTRACTOR_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_mediaparser.cpp b/services/mediametrics/statsd_mediaparser.cpp
index 262b2ae..f543425 100644
--- a/services/mediametrics/statsd_mediaparser.cpp
+++ b/services/mediametrics/statsd_mediaparser.cpp
@@ -36,16 +36,15 @@
namespace android {
-bool statsd_mediaparser(const mediametrics::Item *item)
+bool statsd_mediaparser(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
- if (item == nullptr) {
- return false;
- }
+ static constexpr bool enabled_statsd = true; // TODO: Remove, dup with dump2StatsdInternal().
+ if (item == nullptr) return false;
- // statsd wrapper data.
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
std::string parserName;
item->getString("android.media.mediaparser.parserName", &parserName);
@@ -82,9 +81,9 @@
if (enabled_statsd) {
(void) android::util::stats_write(android::util::MEDIAMETRICS_MEDIAPARSER_REPORTED,
- timestamp,
- pkgName.c_str(),
- pkgVersionCode,
+ timestamp_nanos,
+ package_name.c_str(),
+ package_version_code,
parserName.c_str(),
createdByName,
parserPool.c_str(),
@@ -99,7 +98,29 @@
} else {
ALOGV("NOT sending MediaParser media metrics.");
}
-
+ // TODO: Cleanup after playback_id is merged.
+ std::stringstream log;
+ log << "result:" << "(result)" << " {"
+ << " mediametrics_mediaparser_reported:"
+ << android::util::MEDIAMETRICS_MEDIAPARSER_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " parser_name:" << parserName
+ << " created_by_name:" << createdByName
+ << " parser_pool:" << parserPool
+ << " last_exception:" << lastException
+ << " resource_byte_count:" << resourceByteCount
+ << " duration_millis:" << durationMillis
+ << " track_mime_types:" << trackMimeTypes
+ << " track_codecs:" << trackCodecs
+ << " altered_parameters:" << alteredParameters
+ << " video_width:" << videoWidth
+ << " video_height:" << videoHeight
+ // TODO: Add MediaParser playback_id
+ // << " playback_id:" << playbackId
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_MEDIAPARSER_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_nuplayer.cpp b/services/mediametrics/statsd_nuplayer.cpp
index a8d0f55..33da81e 100644
--- a/services/mediametrics/statsd_nuplayer.cpp
+++ b/services/mediametrics/statsd_nuplayer.cpp
@@ -41,16 +41,16 @@
* handles nuplayer AND nuplayer2
* checks for the union of what the two players generate
*/
-bool statsd_nuplayer(const mediametrics::Item *item)
+bool statsd_nuplayer(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -60,15 +60,16 @@
//
// differentiate between nuplayer and nuplayer2
- metrics_proto.set_whichplayer(item->getKey().c_str());
+ std::string whichPlayer = item->getKey();
+ metrics_proto.set_whichplayer(whichPlayer.c_str());
std::string video_mime;
if (item->getString("android.media.mediaplayer.video.mime", &video_mime)) {
- metrics_proto.set_video_mime(std::move(video_mime));
+ metrics_proto.set_video_mime(video_mime);
}
std::string video_codec;
if (item->getString("android.media.mediaplayer.video.codec", &video_codec)) {
- metrics_proto.set_video_codec(std::move(video_codec));
+ metrics_proto.set_video_codec(video_codec);
}
int32_t width = -1;
@@ -92,32 +93,32 @@
if (item->getInt64("android.media.mediaplayer.startupdropped", &frames_dropped_startup)) {
metrics_proto.set_frames_dropped_startup(frames_dropped_startup);
}
- double fps = -1.0;
- if (item->getDouble("android.media.mediaplayer.fps", &fps)) {
- metrics_proto.set_framerate(fps);
+ double framerate = -1.0;
+ if (item->getDouble("android.media.mediaplayer.fps", &framerate)) {
+ metrics_proto.set_framerate(framerate);
}
std::string audio_mime;
if (item->getString("android.media.mediaplayer.audio.mime", &audio_mime)) {
- metrics_proto.set_audio_mime(std::move(audio_mime));
+ metrics_proto.set_audio_mime(audio_mime);
}
std::string audio_codec;
if (item->getString("android.media.mediaplayer.audio.codec", &audio_codec)) {
- metrics_proto.set_audio_codec(std::move(audio_codec));
+ metrics_proto.set_audio_codec(audio_codec);
}
- int64_t duration_ms = -1;
- if (item->getInt64("android.media.mediaplayer.durationMs", &duration_ms)) {
- metrics_proto.set_duration_millis(duration_ms);
+ int64_t duration_millis = -1;
+ if (item->getInt64("android.media.mediaplayer.durationMs", &duration_millis)) {
+ metrics_proto.set_duration_millis(duration_millis);
}
- int64_t playing_ms = -1;
- if (item->getInt64("android.media.mediaplayer.playingMs", &playing_ms)) {
- metrics_proto.set_playing_millis(playing_ms);
+ int64_t playing_millis = -1;
+ if (item->getInt64("android.media.mediaplayer.playingMs", &playing_millis)) {
+ metrics_proto.set_playing_millis(playing_millis);
}
- int32_t err = -1;
- if (item->getInt32("android.media.mediaplayer.err", &err)) {
- metrics_proto.set_error(err);
+ int32_t error = -1;
+ if (item->getInt32("android.media.mediaplayer.err", &error)) {
+ metrics_proto.set_error(error);
}
int32_t error_code = -1;
if (item->getInt32("android.media.mediaplayer.errcode", &error_code)) {
@@ -125,45 +126,74 @@
}
std::string error_state;
if (item->getString("android.media.mediaplayer.errstate", &error_state)) {
- metrics_proto.set_error_state(std::move(error_state));
+ metrics_proto.set_error_state(error_state);
}
std::string data_source_type;
if (item->getString("android.media.mediaplayer.dataSource", &data_source_type)) {
- metrics_proto.set_data_source_type(std::move(data_source_type));
+ metrics_proto.set_data_source_type(data_source_type);
}
- int64_t rebufferingMs = -1;
- if (item->getInt64("android.media.mediaplayer.rebufferingMs", &rebufferingMs)) {
- metrics_proto.set_rebuffering_millis(rebufferingMs);
+ int64_t rebuffering_millis = -1;
+ if (item->getInt64("android.media.mediaplayer.rebufferingMs", &rebuffering_millis)) {
+ metrics_proto.set_rebuffering_millis(rebuffering_millis);
}
int32_t rebuffers = -1;
if (item->getInt32("android.media.mediaplayer.rebuffers", &rebuffers)) {
metrics_proto.set_rebuffers(rebuffers);
}
- int32_t rebufferExit = -1;
- if (item->getInt32("android.media.mediaplayer.rebufferExit", &rebufferExit)) {
- metrics_proto.set_rebuffer_at_exit(rebufferExit);
+ int32_t rebuffer_at_exit = -1;
+ if (item->getInt32("android.media.mediaplayer.rebufferExit", &rebuffer_at_exit)) {
+ metrics_proto.set_rebuffer_at_exit(rebuffer_at_exit);
}
-
std::string serialized;
if (!metrics_proto.SerializeToString(&serialized)) {
ALOGE("Failed to serialize nuplayer metrics");
return false;
}
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_NUPLAYER_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_NUPLAYER_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized);
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_nuplayer_reported:"
+ << android::util::MEDIAMETRICS_NUPLAYER_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
+ << " whichPlayer:" << whichPlayer
+ << " video_mime:" << video_mime
+ << " video_codec:" << video_codec
+ << " width:" << width
+ << " height:" << height
+ << " frames:" << frames
+ << " frames_dropped:" << frames_dropped
+ << " framerate:" << framerate
+ << " audio_mime:" << audio_mime
+ << " audio_codec:" << media_apex_version
+
+ << " duration_millis:" << duration_millis
+ << " playing_millis:" << playing_millis
+ << " error:" << error
+ << " error_code:" << error_code
+ << " error_state:" << error_state
+ << " data_source_type:" << data_source_type
+ << " rebuffering_millis:" << rebuffering_millis
+ << " rebuffers:" << rebuffers
+ << " rebuffer_at_exit:" << rebuffer_at_exit
+ << " frames_dropped_startup:" << frames_dropped_startup
+
+ // TODO NuPlayer - add log_session_id
+ // << " log_session_id:" << log_session_id
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_NUPLAYER_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/statsd_recorder.cpp b/services/mediametrics/statsd_recorder.cpp
index 2e5ada4..23b884f 100644
--- a/services/mediametrics/statsd_recorder.cpp
+++ b/services/mediametrics/statsd_recorder.cpp
@@ -37,16 +37,16 @@
namespace android {
-bool statsd_recorder(const mediametrics::Item *item)
+bool statsd_recorder(const std::shared_ptr<const mediametrics::Item>& item,
+ const std::shared_ptr<mediametrics::StatsdLog>& statsdLog)
{
if (item == nullptr) return false;
// these go into the statsd wrapper
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
+ const nsecs_t timestamp_nanos = MediaMetricsService::roundTime(item->getTimestamp());
+ const std::string package_name = item->getPkgName();
+ const int64_t package_version_code = item->getPkgVersionCode();
+ const int64_t media_apex_version = 0;
// the rest into our own proto
//
@@ -58,22 +58,22 @@
// string kRecorderAudioMime = "android.media.mediarecorder.audio.mime";
std::string audio_mime;
if (item->getString("android.media.mediarecorder.audio.mime", &audio_mime)) {
- metrics_proto.set_audio_mime(std::move(audio_mime));
+ metrics_proto.set_audio_mime(audio_mime);
}
// string kRecorderVideoMime = "android.media.mediarecorder.video.mime";
std::string video_mime;
if (item->getString("android.media.mediarecorder.video.mime", &video_mime)) {
- metrics_proto.set_video_mime(std::move(video_mime));
+ metrics_proto.set_video_mime(video_mime);
}
// int32 kRecorderVideoProfile = "android.media.mediarecorder.video-encoder-profile";
- int32_t videoProfile = -1;
- if (item->getInt32("android.media.mediarecorder.video-encoder-profile", &videoProfile)) {
- metrics_proto.set_video_profile(videoProfile);
+ int32_t video_profile = -1;
+ if (item->getInt32("android.media.mediarecorder.video-encoder-profile", &video_profile)) {
+ metrics_proto.set_video_profile(video_profile);
}
// int32 kRecorderVideoLevel = "android.media.mediarecorder.video-encoder-level";
- int32_t videoLevel = -1;
- if (item->getInt32("android.media.mediarecorder.video-encoder-level", &videoLevel)) {
- metrics_proto.set_video_level(videoLevel);
+ int32_t video_level = -1;
+ if (item->getInt32("android.media.mediarecorder.video-encoder-level", &video_level)) {
+ metrics_proto.set_video_level(video_level);
}
// int32 kRecorderWidth = "android.media.mediarecorder.width";
int32_t width = -1;
@@ -97,73 +97,73 @@
}
// int32 kRecorderCaptureFps = "android.media.mediarecorder.capture-fps";
- int32_t captureFps = -1;
- if (item->getInt32("android.media.mediarecorder.capture-fps", &captureFps)) {
- metrics_proto.set_capture_fps(captureFps);
+ int32_t capture_fps = -1;
+ if (item->getInt32("android.media.mediarecorder.capture-fps", &capture_fps)) {
+ metrics_proto.set_capture_fps(capture_fps);
}
// double kRecorderCaptureFpsEnable = "android.media.mediarecorder.capture-fpsenable";
- double captureFpsEnable = -1;
- if (item->getDouble("android.media.mediarecorder.capture-fpsenable", &captureFpsEnable)) {
- metrics_proto.set_capture_fps_enable(captureFpsEnable);
+ double capture_fps_enable = -1;
+ if (item->getDouble("android.media.mediarecorder.capture-fpsenable", &capture_fps_enable)) {
+ metrics_proto.set_capture_fps_enable(capture_fps_enable);
}
// int64 kRecorderDurationMs = "android.media.mediarecorder.durationMs";
- int64_t durationMs = -1;
- if (item->getInt64("android.media.mediarecorder.durationMs", &durationMs)) {
- metrics_proto.set_duration_millis(durationMs);
+ int64_t duration_millis = -1;
+ if (item->getInt64("android.media.mediarecorder.durationMs", &duration_millis)) {
+ metrics_proto.set_duration_millis(duration_millis);
}
// int64 kRecorderPaused = "android.media.mediarecorder.pausedMs";
- int64_t pausedMs = -1;
- if (item->getInt64("android.media.mediarecorder.pausedMs", &pausedMs)) {
- metrics_proto.set_paused_millis(pausedMs);
+ int64_t paused_millis = -1;
+ if (item->getInt64("android.media.mediarecorder.pausedMs", &paused_millis)) {
+ metrics_proto.set_paused_millis(paused_millis);
}
// int32 kRecorderNumPauses = "android.media.mediarecorder.NPauses";
- int32_t pausedCount = -1;
- if (item->getInt32("android.media.mediarecorder.NPauses", &pausedCount)) {
- metrics_proto.set_paused_count(pausedCount);
+ int32_t paused_count = -1;
+ if (item->getInt32("android.media.mediarecorder.NPauses", &paused_count)) {
+ metrics_proto.set_paused_count(paused_count);
}
// int32 kRecorderAudioBitrate = "android.media.mediarecorder.audio-bitrate";
- int32_t audioBitrate = -1;
- if (item->getInt32("android.media.mediarecorder.audio-bitrate", &audioBitrate)) {
- metrics_proto.set_audio_bitrate(audioBitrate);
+ int32_t audio_bitrate = -1;
+ if (item->getInt32("android.media.mediarecorder.audio-bitrate", &audio_bitrate)) {
+ metrics_proto.set_audio_bitrate(audio_bitrate);
}
// int32 kRecorderAudioChannels = "android.media.mediarecorder.audio-channels";
- int32_t audioChannels = -1;
- if (item->getInt32("android.media.mediarecorder.audio-channels", &audioChannels)) {
- metrics_proto.set_audio_channels(audioChannels);
+ int32_t audio_channels = -1;
+ if (item->getInt32("android.media.mediarecorder.audio-channels", &audio_channels)) {
+ metrics_proto.set_audio_channels(audio_channels);
}
// int32 kRecorderAudioSampleRate = "android.media.mediarecorder.audio-samplerate";
- int32_t audioSampleRate = -1;
- if (item->getInt32("android.media.mediarecorder.audio-samplerate", &audioSampleRate)) {
- metrics_proto.set_audio_samplerate(audioSampleRate);
+ int32_t audio_samplerate = -1;
+ if (item->getInt32("android.media.mediarecorder.audio-samplerate", &audio_samplerate)) {
+ metrics_proto.set_audio_samplerate(audio_samplerate);
}
// int32 kRecorderMovieTimescale = "android.media.mediarecorder.movie-timescale";
- int32_t movieTimescale = -1;
- if (item->getInt32("android.media.mediarecorder.movie-timescale", &movieTimescale)) {
- metrics_proto.set_movie_timescale(movieTimescale);
+ int32_t movie_timescale = -1;
+ if (item->getInt32("android.media.mediarecorder.movie-timescale", &movie_timescale)) {
+ metrics_proto.set_movie_timescale(movie_timescale);
}
// int32 kRecorderAudioTimescale = "android.media.mediarecorder.audio-timescale";
- int32_t audioTimescale = -1;
- if (item->getInt32("android.media.mediarecorder.audio-timescale", &audioTimescale)) {
- metrics_proto.set_audio_timescale(audioTimescale);
+ int32_t audio_timescale = -1;
+ if (item->getInt32("android.media.mediarecorder.audio-timescale", &audio_timescale)) {
+ metrics_proto.set_audio_timescale(audio_timescale);
}
// int32 kRecorderVideoTimescale = "android.media.mediarecorder.video-timescale";
- int32_t videoTimescale = -1;
- if (item->getInt32("android.media.mediarecorder.video-timescale", &videoTimescale)) {
- metrics_proto.set_video_timescale(videoTimescale);
+ int32_t video_timescale = -1;
+ if (item->getInt32("android.media.mediarecorder.video-timescale", &video_timescale)) {
+ metrics_proto.set_video_timescale(video_timescale);
}
// int32 kRecorderVideoBitrate = "android.media.mediarecorder.video-bitrate";
- int32_t videoBitRate = -1;
- if (item->getInt32("android.media.mediarecorder.video-bitrate", &videoBitRate)) {
- metrics_proto.set_video_bitrate(videoBitRate);
+ int32_t video_bitrate = -1;
+ if (item->getInt32("android.media.mediarecorder.video-bitrate", &video_bitrate)) {
+ metrics_proto.set_video_bitrate(video_bitrate);
}
// int32 kRecorderVideoIframeInterval = "android.media.mediarecorder.video-iframe-interval";
- int32_t iFrameInterval = -1;
- if (item->getInt32("android.media.mediarecorder.video-iframe-interval", &iFrameInterval)) {
- metrics_proto.set_iframe_interval(iFrameInterval);
+ int32_t iframe_interval = -1;
+ if (item->getInt32("android.media.mediarecorder.video-iframe-interval", &iframe_interval)) {
+ metrics_proto.set_iframe_interval(iframe_interval);
}
std::string serialized;
@@ -172,17 +172,47 @@
return false;
}
- if (enabled_statsd) {
- android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
- (void)android::util::stats_write(android::util::MEDIAMETRICS_RECORDER_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
+ android::util::BytesField bf_serialized( serialized.c_str(), serialized.size());
+ int result = android::util::stats_write(android::util::MEDIAMETRICS_RECORDER_REPORTED,
+ timestamp_nanos, package_name.c_str(), package_version_code,
+ media_apex_version,
+ bf_serialized);
+ std::stringstream log;
+ log << "result:" << result << " {"
+ << " mediametrics_recorder_reported:"
+ << android::util::MEDIAMETRICS_RECORDER_REPORTED
+ << " timestamp_nanos:" << timestamp_nanos
+ << " package_name:" << package_name
+ << " package_version_code:" << package_version_code
+ << " media_apex_version:" << media_apex_version
- } else {
- ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
- }
+ << " audio_mime:" << audio_mime
+ << " video_mime:" << video_mime
+ << " video_profile:" << video_profile
+ << " video_level:" << video_level
+ << " width:" << width
+ << " height:" << height
+ << " rotation:" << rotation
+ << " framerate:" << framerate
+ << " capture_fps:" << capture_fps
+ << " capture_fps_enable:" << capture_fps_enable
+ << " duration_millis:" << duration_millis
+ << " paused_millis:" << paused_millis
+ << " paused_count:" << paused_count
+ << " audio_bitrate:" << audio_bitrate
+ << " audio_channels:" << audio_channels
+ << " audio_samplerate:" << audio_samplerate
+ << " movie_timescale:" << movie_timescale
+ << " audio_timescale:" << audio_timescale
+ << " video_timescale:" << video_timescale
+ << " video_bitrate:" << video_bitrate
+
+ << " iframe_interval:" << iframe_interval
+ // TODO Recorder - add log_session_id
+ // << " log_session_id:" << log_session_id
+ << " }";
+ statsdLog->log(android::util::MEDIAMETRICS_RECORDER_REPORTED, log.str());
return true;
}
diff --git a/services/mediametrics/tests/mediametrics_tests.cpp b/services/mediametrics/tests/mediametrics_tests.cpp
index ac9c7fa..2336d6f 100644
--- a/services/mediametrics/tests/mediametrics_tests.cpp
+++ b/services/mediametrics/tests/mediametrics_tests.cpp
@@ -809,7 +809,9 @@
(*item3).set("four", (int32_t)4)
.setTimestamp(12);
- android::mediametrics::AudioAnalytics audioAnalytics;
+ std::shared_ptr<mediametrics::StatsdLog> statsdLog =
+ std::make_shared<mediametrics::StatsdLog>(10);
+ android::mediametrics::AudioAnalytics audioAnalytics{statsdLog};
// untrusted entities cannot create a new key.
ASSERT_EQ(PERMISSION_DENIED, audioAnalytics.submit(item, false /* isTrusted */));
@@ -817,7 +819,7 @@
// TODO: Verify contents of AudioAnalytics.
// Currently there is no getter API in AudioAnalytics besides dump.
- ASSERT_EQ(11, audioAnalytics.dump(1000).second /* lines */);
+ ASSERT_EQ(10, audioAnalytics.dump(1000).second /* lines */);
ASSERT_EQ(NO_ERROR, audioAnalytics.submit(item, true /* isTrusted */));
// untrusted entities can add to an existing key
@@ -845,7 +847,9 @@
(*item3).set("four", (int32_t)4)
.setTimestamp(12);
- android::mediametrics::AudioAnalytics audioAnalytics;
+ std::shared_ptr<mediametrics::StatsdLog> statsdLog =
+ std::make_shared<mediametrics::StatsdLog>(10);
+ android::mediametrics::AudioAnalytics audioAnalytics{statsdLog};
// untrusted entities cannot create a new key.
ASSERT_EQ(PERMISSION_DENIED, audioAnalytics.submit(item, false /* isTrusted */));
@@ -853,7 +857,7 @@
// TODO: Verify contents of AudioAnalytics.
// Currently there is no getter API in AudioAnalytics besides dump.
- ASSERT_EQ(11, audioAnalytics.dump(1000).second /* lines */);
+ ASSERT_EQ(10, audioAnalytics.dump(1000).second /* lines */);
ASSERT_EQ(NO_ERROR, audioAnalytics.submit(item, true /* isTrusted */));
// untrusted entities can add to an existing key
@@ -877,7 +881,9 @@
(*item3).set("four", (int32_t)4)
.setTimestamp(12);
- android::mediametrics::AudioAnalytics audioAnalytics;
+ std::shared_ptr<mediametrics::StatsdLog> statsdLog =
+ std::make_shared<mediametrics::StatsdLog>(10);
+ android::mediametrics::AudioAnalytics audioAnalytics{statsdLog};
ASSERT_EQ(NO_ERROR, audioAnalytics.submit(item, true /* isTrusted */));
// untrusted entities can add to an existing key