Naming consistency: MediaAnalytics to MediaMetrics
Bug: 145780674
Test: build, boot, dumpsys media.metrics
Test: atest mediametrics_tests CtsNativeMediaMetricsTestCases
Change-Id: Icbfa98da9e61702aee9a1d807b5e126b4b9c6458
diff --git a/media/libmediametrics/Android.bp b/media/libmediametrics/Android.bp
index f599190..7fd5408 100644
--- a/media/libmediametrics/Android.bp
+++ b/media/libmediametrics/Android.bp
@@ -2,8 +2,8 @@
name: "libmediametrics",
srcs: [
- "IMediaAnalyticsService.cpp",
- "MediaAnalyticsItem.cpp",
+ "IMediaMetricsService.cpp",
+ "MediaMetricsItem.cpp",
"MediaMetrics.cpp",
],
diff --git a/media/libmediametrics/IMediaAnalyticsService.cpp b/media/libmediametrics/IMediaMetricsService.cpp
similarity index 80%
rename from media/libmediametrics/IMediaAnalyticsService.cpp
rename to media/libmediametrics/IMediaMetricsService.cpp
index 534aece..b5675e6 100644
--- a/media/libmediametrics/IMediaAnalyticsService.cpp
+++ b/media/libmediametrics/IMediaMetricsService.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#define LOG_TAG "MediaAnalytics"
+#define LOG_TAG "MediaMetrics"
#include <stdint.h>
#include <inttypes.h>
@@ -29,8 +29,8 @@
#include <utils/Log.h>
#include <utils/String8.h>
-#include <media/MediaAnalyticsItem.h>
-#include <media/IMediaAnalyticsService.h>
+#include <media/MediaMetricsItem.h>
+#include <media/IMediaMetricsService.h>
namespace android {
@@ -41,15 +41,15 @@
SUBMIT_BUFFER,
};
-class BpMediaAnalyticsService: public BpInterface<IMediaAnalyticsService>
+class BpMediaMetricsService: public BpInterface<IMediaMetricsService>
{
public:
- explicit BpMediaAnalyticsService(const sp<IBinder>& impl)
- : BpInterface<IMediaAnalyticsService>(impl)
+ explicit BpMediaMetricsService(const sp<IBinder>& impl)
+ : BpInterface<IMediaMetricsService>(impl)
{
}
- status_t submit(MediaAnalyticsItem *item) override
+ status_t submit(mediametrics::Item *item) override
{
if (item == nullptr) {
return BAD_VALUE;
@@ -57,7 +57,7 @@
ALOGV("%s: (ONEWAY) item=%s", __func__, item->toString().c_str());
Parcel data;
- data.writeInterfaceToken(IMediaAnalyticsService::getInterfaceDescriptor());
+ data.writeInterfaceToken(IMediaMetricsService::getInterfaceDescriptor());
status_t status = item->writeToParcel(&data);
if (status != NO_ERROR) { // assume failure logged in item
@@ -79,7 +79,7 @@
ALOGV("%s: (ONEWAY) length:%zu", __func__, length);
Parcel data;
- data.writeInterfaceToken(IMediaAnalyticsService::getInterfaceDescriptor());
+ data.writeInterfaceToken(IMediaMetricsService::getInterfaceDescriptor());
status_t status = data.writeInt32(length)
?: data.write((uint8_t*)buffer, length);
@@ -95,18 +95,18 @@
}
};
-IMPLEMENT_META_INTERFACE(MediaAnalyticsService, "android.media.IMediaAnalyticsService");
+IMPLEMENT_META_INTERFACE(MediaMetricsService, "android.media.IMediaMetricsService");
// ----------------------------------------------------------------------
-status_t BnMediaAnalyticsService::onTransact(
+status_t BnMediaMetricsService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case SUBMIT_ITEM: {
- CHECK_INTERFACE(IMediaAnalyticsService, data, reply);
+ CHECK_INTERFACE(IMediaMetricsService, data, reply);
- MediaAnalyticsItem * const item = MediaAnalyticsItem::create();
+ mediametrics::Item * const item = mediametrics::Item::create();
status_t status = item->readFromParcel(data);
if (status != NO_ERROR) { // assume failure logged in item
return status;
@@ -116,7 +116,7 @@
return NO_ERROR;
}
case SUBMIT_BUFFER: {
- CHECK_INTERFACE(IMediaAnalyticsService, data, reply);
+ CHECK_INTERFACE(IMediaMetricsService, data, reply);
int32_t length;
status_t status = data.readInt32(&length);
if (status != NO_ERROR || length <= 0) {
diff --git a/media/libmediametrics/MediaMetrics.cpp b/media/libmediametrics/MediaMetrics.cpp
index cf268e0..4aceac5 100644
--- a/media/libmediametrics/MediaMetrics.cpp
+++ b/media/libmediametrics/MediaMetrics.cpp
@@ -21,7 +21,7 @@
#include <string.h>
#include <sys/types.h>
-#include <media/MediaAnalyticsItem.h>
+#include <media/MediaMetricsItem.h>
#include <media/MediaMetrics.h>
//
@@ -34,25 +34,25 @@
// manage the overall record
mediametrics_handle_t mediametrics_create(mediametricskey_t key) {
- android::MediaAnalyticsItem *item = android::MediaAnalyticsItem::create(key);
+ android::mediametrics::Item *item = android::mediametrics::Item::create(key);
return (mediametrics_handle_t) item;
}
void mediametrics_delete(mediametrics_handle_t handle) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return;
delete item;
}
mediametricskey_t mediametrics_getKey(mediametrics_handle_t handle) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return NULL;
return strdup(item->getKey().c_str());
}
// nuplayer, et al use it when acting as proxies
void mediametrics_setUid(mediametrics_handle_t handle, uid_t uid) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->setUid(uid);
}
@@ -61,31 +61,31 @@
void mediametrics_setInt32(mediametrics_handle_t handle, attr_t attr,
int32_t value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->setInt32(attr, value);
}
void mediametrics_setInt64(mediametrics_handle_t handle, attr_t attr,
int64_t value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->setInt64(attr, value);
}
void mediametrics_setDouble(mediametrics_handle_t handle, attr_t attr,
double value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->setDouble(attr, value);
}
void mediametrics_setRate(mediametrics_handle_t handle, attr_t attr,
int64_t count, int64_t duration) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->setRate(attr, count, duration);
}
void mediametrics_setCString(mediametrics_handle_t handle, attr_t attr,
const char *value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->setCString(attr, value);
}
@@ -94,25 +94,25 @@
void mediametrics_addInt32(mediametrics_handle_t handle, attr_t attr,
int32_t value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->addInt32(attr, value);
}
void mediametrics_addInt64(mediametrics_handle_t handle, attr_t attr,
int64_t value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->addInt64(attr, value);
}
void mediametrics_addDouble(mediametrics_handle_t handle, attr_t attr,
double value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->addDouble(attr, value);
}
void mediametrics_addRate(mediametrics_handle_t handle, attr_t attr,
int64_t count, int64_t duration) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item != NULL) item->addRate(attr, count, duration);
}
@@ -123,28 +123,28 @@
bool mediametrics_getInt32(mediametrics_handle_t handle, attr_t attr,
int32_t * value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->getInt32(attr, value);
}
bool mediametrics_getInt64(mediametrics_handle_t handle, attr_t attr,
int64_t * value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->getInt64(attr, value);
}
bool mediametrics_getDouble(mediametrics_handle_t handle, attr_t attr,
double *value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->getDouble(attr, value);
}
bool mediametrics_getRate(mediametrics_handle_t handle, attr_t attr,
int64_t * count, int64_t * duration, double *rate) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->getRate(attr, count, duration, rate);
}
@@ -152,7 +152,7 @@
// NB: caller owns the string that comes back, is responsible for freeing it
bool mediametrics_getCString(mediametrics_handle_t handle, attr_t attr,
char **value) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->getCString(attr, value);
@@ -164,36 +164,36 @@
}
bool mediametrics_selfRecord(mediametrics_handle_t handle) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->selfrecord();
}
mediametrics_handle_t mediametrics_dup(mediametrics_handle_t handle) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
- if (item == NULL) return android::MediaAnalyticsItem::convert(item);
- return android::MediaAnalyticsItem::convert(item->dup());
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
+ if (item == NULL) return android::mediametrics::Item::convert(item);
+ return android::mediametrics::Item::convert(item->dup());
}
const char *mediametrics_readable(mediametrics_handle_t handle) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return "";
return item->toCString();
}
int32_t mediametrics_count(mediametrics_handle_t handle) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return 0;
return item->count();
}
bool mediametrics_isEnabled() {
// static, so doesn't need an instance
- return android::MediaAnalyticsItem::isEnabled();
+ return android::mediametrics::Item::isEnabled();
}
bool mediametrics_getAttributes(mediametrics_handle_t handle, char **buffer, size_t *length) {
- android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+ android::mediametrics::Item *item = (android::mediametrics::Item *) handle;
if (item == NULL) return false;
return item->writeToByteString(buffer, length) == android::NO_ERROR;
diff --git a/media/libmediametrics/MediaAnalyticsItem.cpp b/media/libmediametrics/MediaMetricsItem.cpp
similarity index 87%
rename from media/libmediametrics/MediaAnalyticsItem.cpp
rename to media/libmediametrics/MediaMetricsItem.cpp
index 8025e49..98158d2 100644
--- a/media/libmediametrics/MediaAnalyticsItem.cpp
+++ b/media/libmediametrics/MediaMetricsItem.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#define LOG_TAG "MediaAnalyticsItem"
+#define LOG_TAG "mediametrics::Item"
#include <inttypes.h>
#include <stdlib.h>
@@ -31,15 +31,15 @@
#include <utils/threads.h>
#include <binder/IServiceManager.h>
-#include <media/IMediaAnalyticsService.h>
-#include <media/MediaAnalyticsItem.h>
+#include <media/IMediaMetricsService.h>
+#include <media/MediaMetricsItem.h>
#include <private/android_filesystem_config.h>
// Max per-property string size before truncation in toString().
// Do not make too large, as this is used for dumpsys purposes.
static constexpr size_t kMaxPropertyStringSize = 4096;
-namespace android {
+namespace android::mediametrics {
#define DEBUG_SERVICEACCESS 0
#define DEBUG_API 0
@@ -49,24 +49,24 @@
// the service is off.
#define SVC_TRIES 2
-MediaAnalyticsItem* MediaAnalyticsItem::convert(mediametrics_handle_t handle) {
- MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
+mediametrics::Item* mediametrics::Item::convert(mediametrics_handle_t handle) {
+ mediametrics::Item *item = (android::mediametrics::Item *) handle;
return item;
}
-mediametrics_handle_t MediaAnalyticsItem::convert(MediaAnalyticsItem *item ) {
+mediametrics_handle_t mediametrics::Item::convert(mediametrics::Item *item ) {
mediametrics_handle_t handle = (mediametrics_handle_t) item;
return handle;
}
-MediaAnalyticsItem::~MediaAnalyticsItem() {
+mediametrics::Item::~Item() {
if (DEBUG_ALLOCATIONS) {
- ALOGD("Destroy MediaAnalyticsItem @ %p", this);
+ ALOGD("Destroy mediametrics::Item @ %p", this);
}
clear();
}
-void MediaAnalyticsItem::clear() {
+void mediametrics::Item::clear() {
// clean allocated storage from key
mKey.clear();
@@ -88,8 +88,8 @@
}
// make a deep copy of myself
-MediaAnalyticsItem *MediaAnalyticsItem::dup() {
- MediaAnalyticsItem *dst = new MediaAnalyticsItem(this->mKey);
+mediametrics::Item *mediametrics::Item::dup() {
+ mediametrics::Item *dst = new mediametrics::Item(this->mKey);
if (dst != NULL) {
// key as part of constructor
@@ -110,50 +110,50 @@
return dst;
}
-MediaAnalyticsItem &MediaAnalyticsItem::setTimestamp(nsecs_t ts) {
+mediametrics::Item &mediametrics::Item::setTimestamp(nsecs_t ts) {
mTimestamp = ts;
return *this;
}
-nsecs_t MediaAnalyticsItem::getTimestamp() const {
+nsecs_t mediametrics::Item::getTimestamp() const {
return mTimestamp;
}
-MediaAnalyticsItem &MediaAnalyticsItem::setPid(pid_t pid) {
+mediametrics::Item &mediametrics::Item::setPid(pid_t pid) {
mPid = pid;
return *this;
}
-pid_t MediaAnalyticsItem::getPid() const {
+pid_t mediametrics::Item::getPid() const {
return mPid;
}
-MediaAnalyticsItem &MediaAnalyticsItem::setUid(uid_t uid) {
+mediametrics::Item &mediametrics::Item::setUid(uid_t uid) {
mUid = uid;
return *this;
}
-uid_t MediaAnalyticsItem::getUid() const {
+uid_t mediametrics::Item::getUid() const {
return mUid;
}
-MediaAnalyticsItem &MediaAnalyticsItem::setPkgName(const std::string &pkgName) {
+mediametrics::Item &mediametrics::Item::setPkgName(const std::string &pkgName) {
mPkgName = pkgName;
return *this;
}
-MediaAnalyticsItem &MediaAnalyticsItem::setPkgVersionCode(int64_t pkgVersionCode) {
+mediametrics::Item &mediametrics::Item::setPkgVersionCode(int64_t pkgVersionCode) {
mPkgVersionCode = pkgVersionCode;
return *this;
}
-int64_t MediaAnalyticsItem::getPkgVersionCode() const {
+int64_t mediametrics::Item::getPkgVersionCode() const {
return mPkgVersionCode;
}
// find the proper entry in the list
-size_t MediaAnalyticsItem::findPropIndex(const char *name) const
+size_t mediametrics::Item::findPropIndex(const char *name) const
{
size_t i = 0;
for (; i < mPropCount; i++) {
@@ -162,7 +162,7 @@
return i;
}
-MediaAnalyticsItem::Prop *MediaAnalyticsItem::findProp(const char *name) const {
+mediametrics::Item::Prop *mediametrics::Item::findProp(const char *name) const {
const size_t i = findPropIndex(name);
if (i < mPropCount) {
return &mProps[i];
@@ -172,7 +172,7 @@
// consider this "find-or-allocate".
// caller validates type and uses clearPropValue() accordingly
-MediaAnalyticsItem::Prop *MediaAnalyticsItem::allocateProp(const char *name) {
+mediametrics::Item::Prop *mediametrics::Item::allocateProp(const char *name) {
const size_t i = findPropIndex(name);
if (i < mPropCount) {
return &mProps[i]; // already have it, return
@@ -184,7 +184,7 @@
return prop;
}
-MediaAnalyticsItem::Prop *MediaAnalyticsItem::allocateProp() {
+mediametrics::Item::Prop *mediametrics::Item::allocateProp() {
if (mPropCount == mPropSize && growProps() == false) {
ALOGE("%s: failed allocation for new properties", __func__);
return nullptr;
@@ -193,7 +193,7 @@
}
// used within the summarizers; return whether property existed
-bool MediaAnalyticsItem::removeProp(const char *name) {
+bool mediametrics::Item::removeProp(const char *name) {
const size_t i = findPropIndex(name);
if (i < mPropCount) {
mProps[i].clear();
@@ -209,7 +209,7 @@
// remove indicated keys and their values
// return value is # keys removed
-size_t MediaAnalyticsItem::filter(size_t n, const char *attrs[]) {
+size_t mediametrics::Item::filter(size_t n, const char *attrs[]) {
size_t zapped = 0;
for (size_t i = 0; i < n; ++i) {
const char *name = attrs[i];
@@ -235,7 +235,7 @@
// remove any keys NOT in the provided list
// return value is # keys removed
-size_t MediaAnalyticsItem::filterNot(size_t n, const char *attrs[]) {
+size_t mediametrics::Item::filterNot(size_t n, const char *attrs[]) {
std::set<std::string> check(attrs, attrs + n);
size_t zapped = 0;
for (size_t j = 0; j < mPropCount;) {
@@ -260,7 +260,7 @@
return zapped;
}
-bool MediaAnalyticsItem::growProps(int increment)
+bool mediametrics::Item::growProps(int increment)
{
if (increment <= 0) {
increment = kGrowProps;
@@ -276,7 +276,7 @@
mPropSize = nsize;
return true;
} else {
- ALOGW("MediaAnalyticsItem::growProps fails");
+ ALOGW("mediametrics::Item::growProps fails");
return false;
}
}
@@ -284,7 +284,7 @@
// Parcel / serialize things for binder calls
//
-status_t MediaAnalyticsItem::readFromParcel(const Parcel& data) {
+status_t mediametrics::Item::readFromParcel(const Parcel& data) {
int32_t version;
status_t status = data.readInt32(&version);
if (status != NO_ERROR) return status;
@@ -298,7 +298,7 @@
}
}
-status_t MediaAnalyticsItem::readFromParcel0(const Parcel& data) {
+status_t mediametrics::Item::readFromParcel0(const Parcel& data) {
const char *s = data.readCString();
mKey = s == nullptr ? "" : s;
int32_t pid, uid;
@@ -323,7 +323,7 @@
return NO_ERROR;
}
-status_t MediaAnalyticsItem::writeToParcel(Parcel *data) const {
+status_t mediametrics::Item::writeToParcel(Parcel *data) const {
if (data == nullptr) return BAD_VALUE;
const int32_t version = 0;
@@ -339,7 +339,7 @@
}
}
-status_t MediaAnalyticsItem::writeToParcel0(Parcel *data) const {
+status_t mediametrics::Item::writeToParcel0(Parcel *data) const {
status_t status =
data->writeCString(mKey.c_str())
?: data->writeInt32(mPid)
@@ -357,20 +357,20 @@
return NO_ERROR;
}
-const char *MediaAnalyticsItem::toCString() {
+const char *mediametrics::Item::toCString() {
return toCString(PROTO_LAST);
}
-const char * MediaAnalyticsItem::toCString(int version) {
+const char * mediametrics::Item::toCString(int version) {
std::string val = toString(version);
return strdup(val.c_str());
}
-std::string MediaAnalyticsItem::toString() const {
+std::string mediametrics::Item::toString() const {
return toString(PROTO_LAST);
}
-std::string MediaAnalyticsItem::toString(int version) const {
+std::string mediametrics::Item::toString(int version) const {
std::string result;
char buffer[kMaxPropertyStringSize];
@@ -388,9 +388,9 @@
// for the lazy, we offer methods that finds the service and
// calls the appropriate daemon
-bool MediaAnalyticsItem::selfrecord() {
+bool mediametrics::Item::selfrecord() {
ALOGD_IF(DEBUG_API, "%s: delivering %s", __func__, this->toString().c_str());
- sp<IMediaAnalyticsService> svc = getInstance();
+ sp<IMediaMetricsService> svc = getInstance();
if (svc != NULL) {
status_t status = svc->submit(this);
if (status != NO_ERROR) {
@@ -403,7 +403,6 @@
}
}
-namespace mediametrics {
//static
bool BaseItem::isEnabled() {
// completely skip logging from certain UIDs. We do this here
@@ -420,12 +419,12 @@
return false;
}
- int enabled = property_get_int32(MediaAnalyticsItem::EnabledProperty, -1);
+ int enabled = property_get_int32(Item::EnabledProperty, -1);
if (enabled == -1) {
- enabled = property_get_int32(MediaAnalyticsItem::EnabledPropertyPersist, -1);
+ enabled = property_get_int32(Item::EnabledPropertyPersist, -1);
}
if (enabled == -1) {
- enabled = MediaAnalyticsItem::EnabledProperty_default;
+ enabled = Item::EnabledProperty_default;
}
return enabled > 0;
}
@@ -440,7 +439,7 @@
static sp<MediaMetricsDeathNotifier> sNotifier;
// static
-sp<IMediaAnalyticsService> BaseItem::sAnalyticsService;
+sp<IMediaMetricsService> BaseItem::sMediaMetricsService;
static std::mutex sServiceMutex;
static int sRemainingBindAttempts = SVC_TRIES;
@@ -448,20 +447,20 @@
void BaseItem::dropInstance() {
std::lock_guard _l(sServiceMutex);
sRemainingBindAttempts = SVC_TRIES;
- sAnalyticsService = nullptr;
+ sMediaMetricsService = nullptr;
}
// static
bool BaseItem::submitBuffer(const char *buffer, size_t size) {
/*
- MediaAnalyticsItem item;
+ mediametrics::Item item;
status_t status = item.readFromByteString(buffer, size);
ALOGD("%s: status:%d, size:%zu, item:%s", __func__, status, size, item.toString().c_str());
return item.selfrecord();
*/
ALOGD_IF(DEBUG_API, "%s: delivering %zu bytes", __func__, size);
- sp<IMediaAnalyticsService> svc = getInstance();
+ sp<IMediaMetricsService> svc = getInstance();
if (svc != nullptr) {
const status_t status = svc->submitBuffer(buffer, size);
if (status != NO_ERROR) {
@@ -474,7 +473,7 @@
}
//static
-sp<IMediaAnalyticsService> BaseItem::getInstance() {
+sp<IMediaMetricsService> BaseItem::getInstance() {
static const char *servicename = "media.metrics";
static const bool enabled = isEnabled(); // singleton initialized
@@ -486,13 +485,13 @@
// think of remainingBindAttempts as telling us whether service == nullptr because
// (1) we haven't tried to initialize it yet
// (2) we've tried to initialize it, but failed.
- if (sAnalyticsService == nullptr && sRemainingBindAttempts > 0) {
+ if (sMediaMetricsService == nullptr && sRemainingBindAttempts > 0) {
const char *badness = "";
sp<IServiceManager> sm = defaultServiceManager();
if (sm != nullptr) {
sp<IBinder> binder = sm->getService(String16(servicename));
if (binder != nullptr) {
- sAnalyticsService = interface_cast<IMediaAnalyticsService>(binder);
+ sMediaMetricsService = interface_cast<IMediaMetricsService>(binder);
sNotifier = new MediaMetricsDeathNotifier();
binder->linkToDeath(sNotifier);
} else {
@@ -501,7 +500,7 @@
} else {
badness = "No Service Manager access";
}
- if (sAnalyticsService == nullptr) {
+ if (sMediaMetricsService == nullptr) {
if (sRemainingBindAttempts > 0) {
sRemainingBindAttempts--;
}
@@ -509,14 +508,13 @@
__func__, servicename, badness);
}
}
- return sAnalyticsService;
+ return sMediaMetricsService;
}
-} // namespace mediametrics
// merge the info from 'incoming' into this record.
// we finish with a union of this+incoming and special handling for collisions
-bool MediaAnalyticsItem::merge(MediaAnalyticsItem *incoming) {
+bool mediametrics::Item::merge(mediametrics::Item *incoming) {
// if I don't have key or session id, take them from incoming
// 'this' should never be missing both of them...
@@ -623,7 +621,7 @@
} // namespace
-status_t MediaAnalyticsItem::writeToByteString(char **pbuffer, size_t *plength) const
+status_t mediametrics::Item::writeToByteString(char **pbuffer, size_t *plength) const
{
if (pbuffer == nullptr || plength == nullptr)
return BAD_VALUE;
@@ -701,7 +699,7 @@
return NO_ERROR;
}
-status_t MediaAnalyticsItem::readFromByteString(const char *bufferptr, size_t length)
+status_t mediametrics::Item::readFromByteString(const char *bufferptr, size_t length)
{
if (bufferptr == nullptr) return BAD_VALUE;
@@ -761,7 +759,7 @@
return NO_ERROR;
}
-status_t MediaAnalyticsItem::Prop::writeToParcel(Parcel *data) const
+status_t mediametrics::Item::Prop::writeToParcel(Parcel *data) const
{
switch (mType) {
case kTypeInt32:
@@ -791,7 +789,7 @@
}
}
-status_t MediaAnalyticsItem::Prop::readFromParcel(const Parcel& data)
+status_t mediametrics::Item::Prop::readFromParcel(const Parcel& data)
{
const char *key = data.readCString();
if (key == nullptr) return BAD_VALUE;
@@ -834,23 +832,23 @@
return status;
}
-void MediaAnalyticsItem::Prop::toString(char *buffer, size_t length) const
+void mediametrics::Item::Prop::toString(char *buffer, size_t length) const
{
switch (mType) {
case kTypeInt32:
snprintf(buffer, length, "%s=%d:", mName, u.int32Value);
break;
- case MediaAnalyticsItem::kTypeInt64:
+ case mediametrics::Item::kTypeInt64:
snprintf(buffer, length, "%s=%lld:", mName, (long long)u.int64Value);
break;
- case MediaAnalyticsItem::kTypeDouble:
+ case mediametrics::Item::kTypeDouble:
snprintf(buffer, length, "%s=%e:", mName, u.doubleValue);
break;
- case MediaAnalyticsItem::kTypeRate:
+ case mediametrics::Item::kTypeRate:
snprintf(buffer, length, "%s=%lld/%lld:",
mName, (long long)u.rate.first, (long long)u.rate.second);
break;
- case MediaAnalyticsItem::kTypeCString:
+ case mediametrics::Item::kTypeCString:
// TODO sanitize string for ':' '='
snprintf(buffer, length, "%s=%s:", mName, u.CStringValue);
break;
@@ -861,7 +859,7 @@
}
}
-size_t MediaAnalyticsItem::Prop::getByteStringSize() const
+size_t mediametrics::Item::Prop::getByteStringSize() const
{
const size_t header =
sizeof(uint16_t) // length
@@ -869,19 +867,19 @@
+ strlen(mName) + 1; // mName + 0 termination
size_t payload = 0;
switch (mType) {
- case MediaAnalyticsItem::kTypeInt32:
+ case mediametrics::Item::kTypeInt32:
payload = sizeof(u.int32Value);
break;
- case MediaAnalyticsItem::kTypeInt64:
+ case mediametrics::Item::kTypeInt64:
payload = sizeof(u.int64Value);
break;
- case MediaAnalyticsItem::kTypeDouble:
+ case mediametrics::Item::kTypeDouble:
payload = sizeof(u.doubleValue);
break;
- case MediaAnalyticsItem::kTypeRate:
+ case mediametrics::Item::kTypeRate:
payload = sizeof(u.rate.first) + sizeof(u.rate.second);
break;
- case MediaAnalyticsItem::kTypeCString:
+ case mediametrics::Item::kTypeCString:
payload = strlen(u.CStringValue) + 1;
break;
default:
@@ -892,7 +890,6 @@
return header + payload;
}
-namespace mediametrics {
// TODO: fold into a template later.
status_t BaseItem::writeToByteString(
@@ -968,9 +965,8 @@
?: insert(name, bufferpptr, bufferptrmax);
}
-} // namespace mediametrics
-status_t MediaAnalyticsItem::Prop::writeToByteString(
+status_t mediametrics::Item::Prop::writeToByteString(
char **bufferpptr, char *bufferptrmax) const
{
switch (mType) {
@@ -993,7 +989,7 @@
}
}
-status_t MediaAnalyticsItem::Prop::readFromByteString(
+status_t mediametrics::Item::Prop::readFromByteString(
const char **bufferpptr, const char *bufferptrmax)
{
uint16_t len;
@@ -1036,4 +1032,4 @@
}
}
-} // namespace android
+} // namespace android::mediametrics
diff --git a/media/libmediametrics/include/IMediaAnalyticsService.h b/media/libmediametrics/include/IMediaMetricsService.h
similarity index 83%
rename from media/libmediametrics/include/IMediaAnalyticsService.h
rename to media/libmediametrics/include/IMediaMetricsService.h
index 30c63e7..d6871ec 100644
--- a/media/libmediametrics/include/IMediaAnalyticsService.h
+++ b/media/libmediametrics/include/IMediaMetricsService.h
@@ -29,15 +29,14 @@
#include <binder/IServiceManager.h>
-#include <media/MediaAnalyticsItem.h>
-// nope...#include <media/MediaAnalytics.h>
+#include <media/MediaMetricsItem.h>
namespace android {
-class IMediaAnalyticsService: public IInterface
+class IMediaMetricsService: public IInterface
{
public:
- DECLARE_META_INTERFACE(MediaAnalyticsService);
+ DECLARE_META_INTERFACE(MediaMetricsService);
/**
* Submits the indicated record to the mediaanalytics service, where
@@ -48,14 +47,14 @@
* \return status which is negative if an error is detected (some errors
may be silent and return 0 - success).
*/
- virtual status_t submit(MediaAnalyticsItem *item) = 0;
+ virtual status_t submit(mediametrics::Item *item) = 0;
virtual status_t submitBuffer(const char *buffer, size_t length) = 0;
};
// ----------------------------------------------------------------------------
-class BnMediaAnalyticsService: public BnInterface<IMediaAnalyticsService>
+class BnMediaMetricsService: public BnInterface<IMediaMetricsService>
{
public:
status_t onTransact(uint32_t code,
@@ -66,7 +65,7 @@
protected:
// Internal call where release is true if the service is to delete the item.
virtual status_t submitInternal(
- MediaAnalyticsItem *item, bool release) = 0;
+ mediametrics::Item *item, bool release) = 0;
};
}; // namespace android
diff --git a/media/libmediametrics/include/MediaAnalyticsItem.h b/media/libmediametrics/include/MediaMetricsItem.h
similarity index 90%
rename from media/libmediametrics/include/MediaAnalyticsItem.h
rename to media/libmediametrics/include/MediaMetricsItem.h
index bff7c9b..5f33650 100644
--- a/media/libmediametrics/include/MediaAnalyticsItem.h
+++ b/media/libmediametrics/include/MediaMetricsItem.h
@@ -32,7 +32,7 @@
namespace android {
-class IMediaAnalyticsService;
+class IMediaMetricsService;
class Parcel;
/*
@@ -115,8 +115,8 @@
static const int EnabledProperty_default = 1;
// let's reuse a binder connection
- static sp<IMediaAnalyticsService> sAnalyticsService;
- static sp<IMediaAnalyticsService> getInstance();
+ static sp<IMediaMetricsService> sMediaMetricsService;
+ static sp<IMediaMetricsService> getInstance();
static void dropInstance();
static bool submitBuffer(const char *buffer, size_t len);
@@ -329,26 +329,26 @@
};
/**
- * MediaMetrics Item is a stack allocated media analytics item used for
+ * MediaMetrics LogItem is a stack allocated media analytics item used for
* fast logging. It falls over to a malloc if needed.
*
* This is templated with a buffer size to allocate on the stack.
*/
template <size_t N = 4096>
-class Item : public BufferedItem {
+class LogItem : public BufferedItem {
public:
- explicit Item(const std::string key) : Item(key.c_str()) { }
+ explicit LogItem(const std::string key) : LogItem(key.c_str()) { }
// Since this class will not be defined before the base class, we initialize variables
// in our own order.
- explicit Item(const char *key) {
+ explicit LogItem(const char *key) {
mBegin = mBuffer;
mEnd = mBuffer + N;
mBaseRealloc = &mReallocPtr;
init(key);
}
- ~Item() override {
+ ~LogItem() override {
if (mReallocPtr != nullptr) { // do the check before calling free to avoid overhead.
free(mReallocPtr);
}
@@ -359,18 +359,17 @@
char mBuffer[N];
};
-} // mediametrics
/**
- * Media Metrics MediaAnalyticsItem
+ * Media Metrics Item
*
* A mutable item representing an event or record that will be
* logged with the Media Metrics service. For client logging, one should
* use the mediametrics::Item.
*
- * The MediaAnalyticsItem is designed for the service as it has getters.
+ * The Item is designed for the service as it has getters.
*/
-class MediaAnalyticsItem : public mediametrics::BaseItem {
+class Item : public mediametrics::BaseItem {
friend class MediaMetricsJNI; // TODO: remove this access
public:
@@ -397,14 +396,14 @@
// T must be convertible to mKey
template <typename T>
- explicit MediaAnalyticsItem(T key)
+ explicit Item(T key)
: mKey(key) { }
- MediaAnalyticsItem() = default;
+ Item() = default;
- MediaAnalyticsItem(const MediaAnalyticsItem&) = delete;
- MediaAnalyticsItem &operator=(const MediaAnalyticsItem&) = delete;
+ Item(const Item&) = delete;
+ Item &operator=(const Item&) = delete;
- bool operator==(const MediaAnalyticsItem& other) const {
+ bool operator==(const Item& other) const {
if (mPropCount != other.mPropCount
|| mPid != other.mPid
|| mUid != other.mUid
@@ -418,29 +417,29 @@
}
return true;
}
- bool operator!=(const MediaAnalyticsItem& other) const {
+ bool operator!=(const Item& other) const {
return !(*this == other);
}
template <typename T>
- static MediaAnalyticsItem* create(T key) {
- return new MediaAnalyticsItem(key);
+ static Item* create(T key) {
+ return new Item(key);
}
- static MediaAnalyticsItem* create() {
- return new MediaAnalyticsItem();
+ static Item* create() {
+ return new Item();
}
- static MediaAnalyticsItem* convert(mediametrics_handle_t);
- static mediametrics_handle_t convert(MediaAnalyticsItem *);
+ static Item* convert(mediametrics_handle_t);
+ static mediametrics_handle_t convert(Item *);
// access functions for the class
- ~MediaAnalyticsItem();
+ ~Item();
// reset all contents, discarding any extra data
void clear();
- MediaAnalyticsItem *dup();
+ Item *dup();
- MediaAnalyticsItem &setKey(const char *key) {
+ Item &setKey(const char *key) {
mKey = key;
return *this;
}
@@ -450,46 +449,46 @@
size_t count() const { return mPropCount; }
template<typename S, typename T>
- MediaAnalyticsItem &set(S key, T value) {
+ Item &set(S key, T value) {
allocateProp(key)->set(value);
return *this;
}
// set values appropriately
- MediaAnalyticsItem &setInt32(const char *key, int32_t value) {
+ Item &setInt32(const char *key, int32_t value) {
return set(key, value);
}
- MediaAnalyticsItem &setInt64(const char *key, int64_t value) {
+ Item &setInt64(const char *key, int64_t value) {
return set(key, value);
}
- MediaAnalyticsItem &setDouble(const char *key, double value) {
+ Item &setDouble(const char *key, double value) {
return set(key, value);
}
- MediaAnalyticsItem &setRate(const char *key, int64_t count, int64_t duration) {
+ Item &setRate(const char *key, int64_t count, int64_t duration) {
return set(key, std::make_pair(count, duration));
}
- MediaAnalyticsItem &setCString(const char *key, const char *value) {
+ Item &setCString(const char *key, const char *value) {
return set(key, value);
}
// fused get/add/set; if attr wasn't there, it's a simple set.
// type-mismatch counts as "wasn't there".
template<typename S, typename T>
- MediaAnalyticsItem &add(S key, T value) {
+ Item &add(S key, T value) {
allocateProp(key)->add(value);
return *this;
}
- MediaAnalyticsItem &addInt32(const char *key, int32_t value) {
+ Item &addInt32(const char *key, int32_t value) {
return add(key, value);
}
- MediaAnalyticsItem &addInt64(const char *key, int64_t value) {
+ Item &addInt64(const char *key, int64_t value) {
return add(key, value);
}
- MediaAnalyticsItem &addDouble(const char *key, double value) {
+ Item &addDouble(const char *key, double value) {
return add(key, value);
}
- MediaAnalyticsItem &addRate(const char *key, int64_t count, int64_t duration) {
+ Item &addRate(const char *key, int64_t count, int64_t duration) {
return add(key, std::make_pair(count, duration));
}
@@ -555,19 +554,19 @@
// timestamp, pid, and uid only used on server side
// timestamp is in 'nanoseconds, unix time'
- MediaAnalyticsItem &setTimestamp(nsecs_t);
+ Item &setTimestamp(nsecs_t);
nsecs_t getTimestamp() const;
- MediaAnalyticsItem &setPid(pid_t);
+ Item &setPid(pid_t);
pid_t getPid() const;
- MediaAnalyticsItem &setUid(uid_t);
+ Item &setUid(uid_t);
uid_t getUid() const;
- MediaAnalyticsItem &setPkgName(const std::string &pkgName);
+ Item &setPkgName(const std::string &pkgName);
std::string getPkgName() const { return mPkgName; }
- MediaAnalyticsItem &setPkgVersionCode(int64_t);
+ Item &setPkgVersionCode(int64_t);
int64_t getPkgVersionCode() const;
// our serialization code for binder calls
@@ -589,7 +588,7 @@
// with rules for first/last/add, etc
// XXX: document semantics and how they are indicated
// caller continues to own 'incoming'
- bool merge(MediaAnalyticsItem *incoming);
+ bool merge(Item *incoming);
private:
// handle Parcel version 0
@@ -712,19 +711,19 @@
template <typename T> void visit(T f) const {
switch (mType) {
- case MediaAnalyticsItem::kTypeInt32:
+ case Item::kTypeInt32:
f(u.int32Value);
return;
- case MediaAnalyticsItem::kTypeInt64:
+ case Item::kTypeInt64:
f(u.int64Value);
return;
- case MediaAnalyticsItem::kTypeDouble:
+ case Item::kTypeDouble:
f(u.doubleValue);
return;
- case MediaAnalyticsItem::kTypeRate:
+ case Item::kTypeRate:
f(u.rate);
return;
- case MediaAnalyticsItem::kTypeCString:
+ case Item::kTypeCString:
f(u.CStringValue);
return;
default:
@@ -885,7 +884,7 @@
class iterator {
public:
- iterator(size_t pos, const MediaAnalyticsItem &_item)
+ iterator(size_t pos, const Item &_item)
: i(std::min(pos, _item.count()))
, item(_item) { }
iterator &operator++() {
@@ -901,7 +900,7 @@
private:
size_t i;
- const MediaAnalyticsItem &item;
+ const Item &item;
};
iterator begin() const {
@@ -938,6 +937,7 @@
nsecs_t mTimestamp = 0;
};
+} // namespace mediametrics
} // namespace android
#endif