services/mediaanalytics/MediaAnalyticsService.cpp - android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2017 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.
  */

 // Proxy for media player implementations

 //#define LOG_NDEBUG 0
 #define LOG_TAG "MediaAnalyticsService"
 #include <utils/Log.h>

 #include <stdint.h>
 #include <inttypes.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <dirent.h>
 #include <unistd.h>

 #include <string.h>

 #include <cutils/atomic.h>
 #include <cutils/properties.h> // for property_get

 #include <utils/misc.h>

 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
 #include <binder/MemoryHeapBase.h>
 #include <binder/MemoryBase.h>
 #include <gui/Surface.h>
 #include <utils/Errors.h>  // for status_t
 #include <utils/List.h>
 #include <utils/String8.h>
 #include <utils/SystemClock.h>
 #include <utils/Timers.h>
 #include <utils/Vector.h>

 #include <media/AudioPolicyHelper.h>
 #include <media/IMediaHTTPService.h>
 #include <media/IRemoteDisplay.h>
 #include <media/IRemoteDisplayClient.h>
 #include <media/MediaPlayerInterface.h>
 #include <media/mediarecorder.h>
 #include <media/MediaMetadataRetrieverInterface.h>
 #include <media/Metadata.h>
 #include <media/AudioTrack.h>
 #include <media/MemoryLeakTrackUtil.h>
 #include <media/stagefright/MediaCodecList.h>
 #include <media/stagefright/MediaErrors.h>
 #include <media/stagefright/Utils.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/ALooperRoster.h>
 #include <mediautils/BatteryNotifier.h>

 //#include <memunreachable/memunreachable.h>
 #include <system/audio.h>

 #include <private/android_filesystem_config.h>

 #include "MediaAnalyticsService.h"

 #include "MetricsSummarizer.h"
 #include "MetricsSummarizerCodec.h"
 #include "MetricsSummarizerExtractor.h"
 #include "MetricsSummarizerPlayer.h"
 #include "MetricsSummarizerRecorder.h"


 namespace android {


 // summarized records
 // up to 48 sets, each covering an hour -- at least 2 days of coverage
 // (will be longer if there are hours without any media action)
 static const nsecs_t kNewSetIntervalNs = 3600*(1000*1000*1000ll);
 static const int kMaxRecordSets = 48;
 // individual records kept in memory
 static const int kMaxRecords    = 100;


 static const char *kServiceName = "media.metrics";


 //using android::status_t;
 //using android::OK;
 //using android::BAD_VALUE;
 //using android::NOT_ENOUGH_DATA;
 //using android::Parcel;


 void MediaAnalyticsService::instantiate() {
     defaultServiceManager()->addService(
             String16(kServiceName), new MediaAnalyticsService());
 }

 // handle sets of summarizers
 MediaAnalyticsService::SummarizerSet::SummarizerSet() {
     mSummarizers = new List<MetricsSummarizer *>();
 }
 MediaAnalyticsService::SummarizerSet::~SummarizerSet() {
     // empty the list
     List<MetricsSummarizer *> *l = mSummarizers;
     while (l->size() > 0) {
         MetricsSummarizer *summarizer = *(l->begin());
         l->erase(l->begin());
         delete summarizer;
     }
 }

 void MediaAnalyticsService::newSummarizerSet() {
     ALOGD("MediaAnalyticsService::newSummarizerSet");
     MediaAnalyticsService::SummarizerSet *set = new MediaAnalyticsService::SummarizerSet();
     nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
     set->setStarted(now);

     set->appendSummarizer(new MetricsSummarizerExtractor("extractor"));
     set->appendSummarizer(new MetricsSummarizerCodec("codec"));
     set->appendSummarizer(new MetricsSummarizerPlayer("nuplayer"));
     set->appendSummarizer(new MetricsSummarizerRecorder("recorder"));

     // ALWAYS at the end, since it catches everything
     set->appendSummarizer(new MetricsSummarizer(NULL));

     // inject this set at the BACK of the list.
     mSummarizerSets->push_back(set);
     mCurrentSet = set;

     // limit the # that we have
     if (mMaxRecordSets > 0) {
         List<SummarizerSet *> *l = mSummarizerSets;
         while (l->size() > (size_t) mMaxRecordSets) {
             ALOGD("Deleting oldest record set....");
             MediaAnalyticsService::SummarizerSet *oset = *(l->begin());
             l->erase(l->begin());
             delete oset;
             mSetsDiscarded++;
         }
     }
 }

 MediaAnalyticsService::MediaAnalyticsService()
         : mMaxRecords(kMaxRecords),
           mMaxRecordSets(kMaxRecordSets),
           mNewSetInterval(kNewSetIntervalNs) {

     ALOGD("MediaAnalyticsService created");
     // clear our queues
     mOpen = new List<MediaAnalyticsItem *>();
     mFinalized = new List<MediaAnalyticsItem *>();

     mSummarizerSets = new List<MediaAnalyticsService::SummarizerSet *>();
     newSummarizerSet();

     mItemsSubmitted = 0;
     mItemsFinalized = 0;
     mItemsDiscarded = 0;

     mLastSessionID = 0;
     // recover any persistency we set up
     // etc
 }

 MediaAnalyticsService::~MediaAnalyticsService() {
         ALOGD("MediaAnalyticsService destroyed");

     // clean out mOpen and mFinalized
     delete mOpen;
     mOpen = NULL;
     delete mFinalized;
     mFinalized = NULL;

     // XXX: clean out the summaries
 }


 MediaAnalyticsItem::SessionID_t MediaAnalyticsService::generateUniqueSessionID() {
     // generate a new sessionid

     Mutex::Autolock _l(mLock_ids);
     return (++mLastSessionID);
 }

 // caller surrenders ownership of 'item'
 MediaAnalyticsItem::SessionID_t MediaAnalyticsService::submit(MediaAnalyticsItem *item, bool forcenew) {

     MediaAnalyticsItem::SessionID_t id = MediaAnalyticsItem::SessionIDInvalid;

     // we control these, generally not trusting user input
     nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
     item->setTimestamp(now);
     int pid = IPCThreadState::self()->getCallingPid();
     int uid = IPCThreadState::self()->getCallingUid();

     int uid_given = item->getUid();
     int pid_given = item->getPid();

     // although we do make exceptions for particular client uids
     // that we know we trust.
     //
     bool isTrusted = false;

     switch (uid)  {
         case AID_MEDIA:
         case AID_MEDIA_CODEC:
         case AID_MEDIA_EX:
         case AID_MEDIA_DRM:
             // trusted source, only override default values
                 isTrusted = true;
             if (uid_given == (-1)) {
                 item->setUid(uid);
             }
             if (pid_given == (-1)) {
                 item->setPid(pid);
             }
             break;
         default:
             isTrusted = false;
             item->setPid(pid);
             item->setUid(uid);
             break;
     }


     mItemsSubmitted++;

     // validate the record; we discard if we don't like it
     if (contentValid(item, isTrusted) == false) {
         delete item;
         return MediaAnalyticsItem::SessionIDInvalid;
     }


     // if we have a sesisonid in the new record, look to make
     // sure it doesn't appear in the finalized list.
     // XXX: this is for security / DOS prevention.
     // may also require that we persist the unique sessionIDs
     // across boots [instead of within a single boot]


     // match this new record up against records in the open
     // list...
     // if there's a match, merge them together
     // deal with moving the old / merged record into the finalized que

     bool finalizing = item->getFinalized();

     // if finalizing, we'll remove it
     MediaAnalyticsItem *oitem = findItem(mOpen, item, finalizing | forcenew);
     if (oitem != NULL) {
         if (forcenew) {
             // old one gets finalized, then we insert the new one
             // so we'll have 2 records at the end of this.
             // but don't finalize an empty record
             if (oitem->count() == 0) {
                 // we're responsible for disposing of the dead record
                 delete oitem;
                 oitem = NULL;
             } else {
                 oitem->setFinalized(true);
                 summarize(oitem);
                 saveItem(mFinalized, oitem, 0);
             }
             // new record could itself be marked finalized...
             if (finalizing) {
                 summarize(item);
                 saveItem(mFinalized, item, 0);
                 mItemsFinalized++;
             } else {
                 saveItem(mOpen, item, 1);
             }
             id = item->getSessionID();
         } else {
             // combine the records, send it to finalized if appropriate
             oitem->merge(item);
             if (finalizing) {
                 summarize(oitem);
                 saveItem(mFinalized, oitem, 0);
                 mItemsFinalized++;
             }
             id = oitem->getSessionID();

             // we're responsible for disposing of the dead record
             delete item;
             item = NULL;
         }
     } else {
         // nothing to merge, save the new record
         id = item->getSessionID();
         if (finalizing) {
             if (item->count() == 0) {
                 // drop empty records
                 delete item;
                 item = NULL;
             } else {
                 summarize(item);
                 saveItem(mFinalized, item, 0);
                 mItemsFinalized++;
             }
         } else {
             saveItem(mOpen, item, 1);
         }
     }
     return id;
 }

 status_t MediaAnalyticsService::dump(int fd, const Vector<String16>& args)
 {
     const size_t SIZE = 512;
     char buffer[SIZE];
     String8 result;

     if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
         snprintf(buffer, SIZE, "Permission Denial: "
                 "can't dump MediaAnalyticsService from pid=%d, uid=%d\n",
                 IPCThreadState::self()->getCallingPid(),
                 IPCThreadState::self()->getCallingUid());
         result.append(buffer);
         write(fd, result.string(), result.size());
         return NO_ERROR;
     }

     // crack any parameters
     bool clear = false;
     bool summary = false;
     nsecs_t ts_since = 0;
     String16 summaryOption("-summary");
     String16 clearOption("-clear");
     String16 sinceOption("-since");
     String16 helpOption("-help");
     String16 onlyOption("-only");
     const char *only = NULL;
     int n = args.size();
     for (int i = 0; i < n; i++) {
         String8 myarg(args[i]);
         if (args[i] == clearOption) {
             clear = true;
         } else if (args[i] == summaryOption) {
             summary = true;
         } else if (args[i] == sinceOption) {
             i++;
             if (i < n) {
                 String8 value(args[i]);
                 char *endp;
                 const char *p = value.string();
                 ts_since = strtoll(p, &endp, 10);
                 if (endp == p || *endp != '\0') {
                     ts_since = 0;
                 }
             } else {
                 ts_since = 0;
             }
             // command line is milliseconds; internal units are nano-seconds
             ts_since *= 1000*1000;
         } else if (args[i] == onlyOption) {
             i++;
             if (i < n) {
                 String8 value(args[i]);
                 const char *p = value.string();
                 char *q = strdup(p);
                 if (q != NULL) {
                     if (only != NULL) {
                         free((void*)only);
                     }
                 only = q;
                 }
             }
         } else if (args[i] == helpOption) {
             result.append("Recognized parameters:\n");
             result.append("-help        this help message\n");
             result.append("-summary     show summary info\n");
             result.append("-clear       clears out saved records\n");
             result.append("-only X      process records for component X\n");
             result.append("-since X     include records since X\n");
             result.append("             (X is milliseconds since the UNIX epoch)\n");
             write(fd, result.string(), result.size());
             return NO_ERROR;
         }
     }

     Mutex::Autolock _l(mLock);

     // we ALWAYS dump this piece
     snprintf(buffer, SIZE, "Dump of the %s process:\n", kServiceName);
     result.append(buffer);

     dumpHeaders(result, ts_since);

     // only want 1, to avoid confusing folks that parse the output
     if (summary) {
         dumpSummaries(result, ts_since, only);
     } else {
         dumpRecent(result, ts_since, only);
     }
     free((void*)only);
     only=NULL;


     if (clear) {
         // remove everything from the finalized queue
         while (mFinalized->size() > 0) {
             MediaAnalyticsItem * oitem = *(mFinalized->begin());
             mFinalized->erase(mFinalized->begin());
             delete oitem;
             mItemsDiscarded++;
         }

         // shall we clear the summary data too?

     }

     write(fd, result.string(), result.size());
     return NO_ERROR;
 }

 // dump headers
 void MediaAnalyticsService::dumpHeaders(String8 &result, nsecs_t ts_since) {
     const size_t SIZE = 512;
     char buffer[SIZE];

     int enabled = MediaAnalyticsItem::isEnabled();
     if (enabled) {
         snprintf(buffer, SIZE, "Metrics gathering: enabled\n");
     } else {
         snprintf(buffer, SIZE, "Metrics gathering: DISABLED via property\n");
     }
     result.append(buffer);

     snprintf(buffer, SIZE,
         "Since Boot: Submissions: %" PRId64
             " Finalizations: %" PRId64
         " Discarded: %" PRId64 "\n",
         mItemsSubmitted, mItemsFinalized, mItemsDiscarded);
     result.append(buffer);
     snprintf(buffer, SIZE,
         "Summary Sets Discarded: %" PRId64 "\n", mSetsDiscarded);
     result.append(buffer);
     if (ts_since != 0) {
         snprintf(buffer, SIZE,
             "Dumping Queue entries more recent than: %" PRId64 "\n",
             (int64_t) ts_since);
         result.append(buffer);
     }
 }

 // dump summary info
 void MediaAnalyticsService::dumpSummaries(String8 &result, nsecs_t ts_since, const char *only) {
     const size_t SIZE = 512;
     char buffer[SIZE];
     int slot = 0;

     snprintf(buffer, SIZE, "\nSummarized Metrics:\n");
     result.append(buffer);

     // have each of the distillers dump records
     if (mSummarizerSets != NULL) {
         List<SummarizerSet *>::iterator itSet = mSummarizerSets->begin();
         for (; itSet != mSummarizerSets->end(); itSet++) {
             nsecs_t when = (*itSet)->getStarted();
             if (when < ts_since) {
                 continue;
             }
             List<MetricsSummarizer *> *list = (*itSet)->getSummarizers();
             List<MetricsSummarizer *>::iterator it = list->begin();
             for (; it != list->end(); it++) {
                 if (only != NULL && strcmp(only, (*it)->getKey()) != 0) {
                     ALOGV("Told to omit '%s'", (*it)->getKey());
                 }
                 AString distilled = (*it)->dumpSummary(slot, only);
                 result.append(distilled.c_str());
             }
         }
     }
 }

 // the recent, detailed queues
 void MediaAnalyticsService::dumpRecent(String8 &result, nsecs_t ts_since, const char * only) {
     const size_t SIZE = 512;
     char buffer[SIZE];

     // show the recently recorded records
     snprintf(buffer, sizeof(buffer), "\nFinalized Metrics (oldest first):\n");
     result.append(buffer);
     result.append(this->dumpQueue(mFinalized, ts_since, only));

     snprintf(buffer, sizeof(buffer), "\nIn-Progress Metrics (newest first):\n");
     result.append(buffer);
     result.append(this->dumpQueue(mOpen, ts_since, only));

     // show who is connected and injecting records?
     // talk about # records fed to the 'readers'
     // talk about # records we discarded, perhaps "discarded w/o reading" too
 }
 // caller has locked mLock...
 String8 MediaAnalyticsService::dumpQueue(List<MediaAnalyticsItem *> *theList) {
     return dumpQueue(theList, (nsecs_t) 0, NULL);
 }

 String8 MediaAnalyticsService::dumpQueue(List<MediaAnalyticsItem *> *theList, nsecs_t ts_since, const char * only) {
     String8 result;
     int slot = 0;

     if (theList->empty()) {
             result.append("empty\n");
     } else {
         List<MediaAnalyticsItem *>::iterator it = theList->begin();
         for (; it != theList->end(); it++) {
             nsecs_t when = (*it)->getTimestamp();
             if (when < ts_since) {
                 continue;
             }
             if (only != NULL &&
                 strcmp(only, (*it)->getKey().c_str()) != 0) {
                 ALOGV("Omit '%s', it's not '%s'", (*it)->getKey().c_str(), only);
                 continue;
             }
             AString entry = (*it)->toString();
             result.appendFormat("%5d: %s\n", slot, entry.c_str());
             slot++;
         }
     }

     return result;
 }

 //
 // Our Cheap in-core, non-persistent records management.
 // XXX: rewrite this to manage persistence, etc.

 // insert appropriately into queue
 void MediaAnalyticsService::saveItem(List<MediaAnalyticsItem *> *l, MediaAnalyticsItem * item, int front) {

     Mutex::Autolock _l(mLock);

     // adding at back of queue (fifo order)
     if (front)  {
         l->push_front(item);
     } else {
         l->push_back(item);
     }

     // keep removing old records the front until we're in-bounds
     if (mMaxRecords > 0) {
         while (l->size() > (size_t) mMaxRecords) {
             MediaAnalyticsItem * oitem = *(l->begin());
             l->erase(l->begin());
             delete oitem;
             mItemsDiscarded++;
         }
     }
 }

 // are they alike enough that nitem can be folded into oitem?
 static bool compatibleItems(MediaAnalyticsItem * oitem, MediaAnalyticsItem * nitem) {

     if (0) {
         ALOGD("Compare: o %s n %s",
               oitem->toString().c_str(), nitem->toString().c_str());
     }

     // general safety
     if (nitem->getUid() != oitem->getUid()) {
         return false;
     }
     if (nitem->getPid() != oitem->getPid()) {
         return false;
     }

     // key -- needs to match
     if (nitem->getKey() == oitem->getKey()) {
         // still in the game.
     } else {
         return false;
     }

     // session id -- empty field in new is allowed
     MediaAnalyticsItem::SessionID_t osession = oitem->getSessionID();
     MediaAnalyticsItem::SessionID_t nsession = nitem->getSessionID();
     if (nsession != osession) {
         // incoming '0' matches value in osession
         if (nsession != 0) {
             return false;
         }
     }

     return true;
 }

 // find the incomplete record that this will overlay
 MediaAnalyticsItem *MediaAnalyticsService::findItem(List<MediaAnalyticsItem*> *theList, MediaAnalyticsItem *nitem, bool removeit) {
     if (nitem == NULL) {
         return NULL;
     }

     MediaAnalyticsItem *item = NULL;

     Mutex::Autolock _l(mLock);

     for (List<MediaAnalyticsItem *>::iterator it = theList->begin();
         it != theList->end(); it++) {
         MediaAnalyticsItem *tmp = (*it);

         if (!compatibleItems(tmp, nitem)) {
             continue;
         }

         // we match! this is the one I want.
         if (removeit) {
             theList->erase(it);
         }
         item = tmp;
         break;
     }
     return item;
 }


 // delete the indicated record
 void MediaAnalyticsService::deleteItem(List<MediaAnalyticsItem *> *l, MediaAnalyticsItem *item) {

     Mutex::Autolock _l(mLock);

     for (List<MediaAnalyticsItem *>::iterator it = l->begin();
         it != l->end(); it++) {
         if ((*it)->getSessionID() != item->getSessionID())
             continue;
         delete *it;
         l->erase(it);
         break;
     }
 }

 static AString allowedKeys[] =
 {
     "codec",
     "extractor"
 };

 static const int nAllowedKeys = sizeof(allowedKeys) / sizeof(allowedKeys[0]);

 // are the contents good
 bool MediaAnalyticsService::contentValid(MediaAnalyticsItem *item, bool isTrusted) {

     // untrusted uids can only send us a limited set of keys
     if (isTrusted == false) {
         // restrict to a specific set of keys
         AString key = item->getKey();

         size_t i;
         for(i = 0; i < nAllowedKeys; i++) {
             if (key == allowedKeys[i]) {
                 break;
             }
         }
         if (i == nAllowedKeys) {
             ALOGD("Ignoring (key): %s", item->toString().c_str());
             return false;
         }
     }

     // internal consistency

     return true;
 }

 // are we rate limited, normally false
 bool MediaAnalyticsService::rateLimited(MediaAnalyticsItem *) {

     return false;
 }

 // insert into the appropriate summarizer.
 // we make our own copy to save/summarize
 void MediaAnalyticsService::summarize(MediaAnalyticsItem *item) {

     ALOGV("MediaAnalyticsService::summarize()");

     if (item == NULL) {
         return;
     }

     nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
     if (mCurrentSet == NULL
         || (mCurrentSet->getStarted() + mNewSetInterval < now)) {
         newSummarizerSet();
     }

     if (mCurrentSet == NULL) {
         return;
     }

     List<MetricsSummarizer *> *summarizers = mCurrentSet->getSummarizers();
     List<MetricsSummarizer *>::iterator it = summarizers->begin();
     for (; it != summarizers->end(); it++) {
         if ((*it)->isMine(*item)) {
             break;
         }
     }
     if (it == summarizers->end()) {
         ALOGD("no handler for type %s", item->getKey().c_str());
         return;               // no handler
     }

     // invoke the summarizer. summarizer will make whatever copies
     // it wants; the caller retains ownership of item.

     (*it)->handleRecord(item);

 }

 } // namespace android
	/*
	* Copyright (C) 2017 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.
	*/

	// Proxy for media player implementations

	//#define LOG_NDEBUG 0
	#define LOG_TAG "MediaAnalyticsService"
	#include <utils/Log.h>

	#include <stdint.h>
	#include <inttypes.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <dirent.h>
	#include <unistd.h>

	#include <string.h>

	#include <cutils/atomic.h>
	#include <cutils/properties.h> // for property_get

	#include <utils/misc.h>

	#include <binder/IPCThreadState.h>
	#include <binder/IServiceManager.h>
	#include <binder/MemoryHeapBase.h>
	#include <binder/MemoryBase.h>
	#include <gui/Surface.h>
	#include <utils/Errors.h> // for status_t
	#include <utils/List.h>
	#include <utils/String8.h>
	#include <utils/SystemClock.h>
	#include <utils/Timers.h>
	#include <utils/Vector.h>

	#include <media/AudioPolicyHelper.h>
	#include <media/IMediaHTTPService.h>
	#include <media/IRemoteDisplay.h>
	#include <media/IRemoteDisplayClient.h>
	#include <media/MediaPlayerInterface.h>
	#include <media/mediarecorder.h>
	#include <media/MediaMetadataRetrieverInterface.h>
	#include <media/Metadata.h>
	#include <media/AudioTrack.h>
	#include <media/MemoryLeakTrackUtil.h>
	#include <media/stagefright/MediaCodecList.h>
	#include <media/stagefright/MediaErrors.h>
	#include <media/stagefright/Utils.h>
	#include <media/stagefright/foundation/ADebug.h>
	#include <media/stagefright/foundation/ALooperRoster.h>
	#include <mediautils/BatteryNotifier.h>

	//#include <memunreachable/memunreachable.h>
	#include <system/audio.h>

	#include <private/android_filesystem_config.h>

	#include "MediaAnalyticsService.h"

	#include "MetricsSummarizer.h"
	#include "MetricsSummarizerCodec.h"
	#include "MetricsSummarizerExtractor.h"
	#include "MetricsSummarizerPlayer.h"
	#include "MetricsSummarizerRecorder.h"


	namespace android {



	// summarized records
	// up to 48 sets, each covering an hour -- at least 2 days of coverage
	// (will be longer if there are hours without any media action)
	static const nsecs_t kNewSetIntervalNs = 3600(10001000*1000ll);
	static const int kMaxRecordSets = 48;
	// individual records kept in memory
	static const int kMaxRecords = 100;


	static const char *kServiceName = "media.metrics";


	//using android::status_t;
	//using android::OK;
	//using android::BAD_VALUE;
	//using android::NOT_ENOUGH_DATA;
	//using android::Parcel;


	void MediaAnalyticsService::instantiate() {
	defaultServiceManager()->addService(
	String16(kServiceName), new MediaAnalyticsService());
	}

	// handle sets of summarizers
	MediaAnalyticsService::SummarizerSet::SummarizerSet() {
	mSummarizers = new List<MetricsSummarizer *>();
	}
	MediaAnalyticsService::SummarizerSet::~SummarizerSet() {
	// empty the list
	List<MetricsSummarizer > l = mSummarizers;
	while (l->size() > 0) {
	MetricsSummarizer summarizer = (l->begin());
	l->erase(l->begin());
	delete summarizer;
	}
	}

	void MediaAnalyticsService::newSummarizerSet() {
	ALOGD("MediaAnalyticsService::newSummarizerSet");
	MediaAnalyticsService::SummarizerSet *set = new MediaAnalyticsService::SummarizerSet();
	nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
	set->setStarted(now);

	set->appendSummarizer(new MetricsSummarizerExtractor("extractor"));
	set->appendSummarizer(new MetricsSummarizerCodec("codec"));
	set->appendSummarizer(new MetricsSummarizerPlayer("nuplayer"));
	set->appendSummarizer(new MetricsSummarizerRecorder("recorder"));

	// ALWAYS at the end, since it catches everything
	set->appendSummarizer(new MetricsSummarizer(NULL));

	// inject this set at the BACK of the list.
	mSummarizerSets->push_back(set);
	mCurrentSet = set;

	// limit the # that we have
	if (mMaxRecordSets > 0) {
	List<SummarizerSet > l = mSummarizerSets;
	while (l->size() > (size_t) mMaxRecordSets) {
	ALOGD("Deleting oldest record set....");
	MediaAnalyticsService::SummarizerSet oset = (l->begin());
	l->erase(l->begin());
	delete oset;
	mSetsDiscarded++;
	}
	}
	}

	MediaAnalyticsService::MediaAnalyticsService()
	: mMaxRecords(kMaxRecords),
	mMaxRecordSets(kMaxRecordSets),
	mNewSetInterval(kNewSetIntervalNs) {

	ALOGD("MediaAnalyticsService created");
	// clear our queues
	mOpen = new List<MediaAnalyticsItem *>();
	mFinalized = new List<MediaAnalyticsItem *>();

	mSummarizerSets = new List<MediaAnalyticsService::SummarizerSet *>();
	newSummarizerSet();

	mItemsSubmitted = 0;
	mItemsFinalized = 0;
	mItemsDiscarded = 0;

	mLastSessionID = 0;
	// recover any persistency we set up
	// etc
	}

	MediaAnalyticsService::~MediaAnalyticsService() {
	ALOGD("MediaAnalyticsService destroyed");

	// clean out mOpen and mFinalized
	delete mOpen;
	mOpen = NULL;
	delete mFinalized;
	mFinalized = NULL;

	// XXX: clean out the summaries
	}


	MediaAnalyticsItem::SessionID_t MediaAnalyticsService::generateUniqueSessionID() {
	// generate a new sessionid

	Mutex::Autolock _l(mLock_ids);
	return (++mLastSessionID);
	}

	// caller surrenders ownership of 'item'
	MediaAnalyticsItem::SessionID_t MediaAnalyticsService::submit(MediaAnalyticsItem *item, bool forcenew) {

	MediaAnalyticsItem::SessionID_t id = MediaAnalyticsItem::SessionIDInvalid;

	// we control these, generally not trusting user input
	nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
	item->setTimestamp(now);
	int pid = IPCThreadState::self()->getCallingPid();
	int uid = IPCThreadState::self()->getCallingUid();

	int uid_given = item->getUid();
	int pid_given = item->getPid();

	// although we do make exceptions for particular client uids
	// that we know we trust.
	//
	bool isTrusted = false;

	switch (uid) {
	case AID_MEDIA:
	case AID_MEDIA_CODEC:
	case AID_MEDIA_EX:
	case AID_MEDIA_DRM:
	// trusted source, only override default values
	isTrusted = true;
	if (uid_given == (-1)) {
	item->setUid(uid);
	}
	if (pid_given == (-1)) {
	item->setPid(pid);
	}
	break;
	default:
	isTrusted = false;
	item->setPid(pid);
	item->setUid(uid);
	break;
	}


	mItemsSubmitted++;

	// validate the record; we discard if we don't like it
	if (contentValid(item, isTrusted) == false) {
	delete item;
	return MediaAnalyticsItem::SessionIDInvalid;
	}


	// if we have a sesisonid in the new record, look to make
	// sure it doesn't appear in the finalized list.
	// XXX: this is for security / DOS prevention.
	// may also require that we persist the unique sessionIDs
	// across boots [instead of within a single boot]


	// match this new record up against records in the open
	// list...
	// if there's a match, merge them together
	// deal with moving the old / merged record into the finalized que

	bool finalizing = item->getFinalized();

	// if finalizing, we'll remove it
	MediaAnalyticsItem *oitem = findItem(mOpen, item, finalizing \| forcenew);
	if (oitem != NULL) {
	if (forcenew) {
	// old one gets finalized, then we insert the new one
	// so we'll have 2 records at the end of this.
	// but don't finalize an empty record
	if (oitem->count() == 0) {
	// we're responsible for disposing of the dead record
	delete oitem;
	oitem = NULL;
	} else {
	oitem->setFinalized(true);
	summarize(oitem);
	saveItem(mFinalized, oitem, 0);
	}
	// new record could itself be marked finalized...
	if (finalizing) {
	summarize(item);
	saveItem(mFinalized, item, 0);
	mItemsFinalized++;
	} else {
	saveItem(mOpen, item, 1);
	}
	id = item->getSessionID();
	} else {
	// combine the records, send it to finalized if appropriate
	oitem->merge(item);
	if (finalizing) {
	summarize(oitem);
	saveItem(mFinalized, oitem, 0);
	mItemsFinalized++;
	}
	id = oitem->getSessionID();

	// we're responsible for disposing of the dead record
	delete item;
	item = NULL;
	}
	} else {
	// nothing to merge, save the new record
	id = item->getSessionID();
	if (finalizing) {
	if (item->count() == 0) {
	// drop empty records
	delete item;
	item = NULL;
	} else {
	summarize(item);
	saveItem(mFinalized, item, 0);
	mItemsFinalized++;
	}
	} else {
	saveItem(mOpen, item, 1);
	}
	}
	return id;
	}

	status_t MediaAnalyticsService::dump(int fd, const Vector<String16>& args)
	{
	const size_t SIZE = 512;
	char buffer[SIZE];
	String8 result;

	if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
	snprintf(buffer, SIZE, "Permission Denial: "
	"can't dump MediaAnalyticsService from pid=%d, uid=%d\n",
	IPCThreadState::self()->getCallingPid(),
	IPCThreadState::self()->getCallingUid());
	result.append(buffer);
	write(fd, result.string(), result.size());
	return NO_ERROR;
	}

	// crack any parameters
	bool clear = false;
	bool summary = false;
	nsecs_t ts_since = 0;
	String16 summaryOption("-summary");
	String16 clearOption("-clear");
	String16 sinceOption("-since");
	String16 helpOption("-help");
	String16 onlyOption("-only");
	const char *only = NULL;
	int n = args.size();
	for (int i = 0; i < n; i++) {
	String8 myarg(args[i]);
	if (args[i] == clearOption) {
	clear = true;
	} else if (args[i] == summaryOption) {
	summary = true;
	} else if (args[i] == sinceOption) {
	i++;
	if (i < n) {
	String8 value(args[i]);
	char *endp;
	const char *p = value.string();
	ts_since = strtoll(p, &endp, 10);
	if (endp == p \|\| *endp != '\0') {
	ts_since = 0;
	}
	} else {
	ts_since = 0;
	}
	// command line is milliseconds; internal units are nano-seconds
	ts_since = 10001000;
	} else if (args[i] == onlyOption) {
	i++;
	if (i < n) {
	String8 value(args[i]);
	const char *p = value.string();
	char *q = strdup(p);
	if (q != NULL) {
	if (only != NULL) {
	free((void*)only);
	}
	only = q;
	}
	}
	} else if (args[i] == helpOption) {
	result.append("Recognized parameters:\n");
	result.append("-help this help message\n");
	result.append("-summary show summary info\n");
	result.append("-clear clears out saved records\n");
	result.append("-only X process records for component X\n");
	result.append("-since X include records since X\n");
	result.append(" (X is milliseconds since the UNIX epoch)\n");
	write(fd, result.string(), result.size());
	return NO_ERROR;
	}
	}

	Mutex::Autolock _l(mLock);

	// we ALWAYS dump this piece
	snprintf(buffer, SIZE, "Dump of the %s process:\n", kServiceName);
	result.append(buffer);

	dumpHeaders(result, ts_since);

	// only want 1, to avoid confusing folks that parse the output
	if (summary) {
	dumpSummaries(result, ts_since, only);
	} else {
	dumpRecent(result, ts_since, only);
	}
	free((void*)only);
	only=NULL;


	if (clear) {
	// remove everything from the finalized queue
	while (mFinalized->size() > 0) {
	MediaAnalyticsItem * oitem = *(mFinalized->begin());
	mFinalized->erase(mFinalized->begin());
	delete oitem;
	mItemsDiscarded++;
	}

	// shall we clear the summary data too?

	}

	write(fd, result.string(), result.size());
	return NO_ERROR;
	}

	// dump headers
	void MediaAnalyticsService::dumpHeaders(String8 &result, nsecs_t ts_since) {
	const size_t SIZE = 512;
	char buffer[SIZE];

	int enabled = MediaAnalyticsItem::isEnabled();
	if (enabled) {
	snprintf(buffer, SIZE, "Metrics gathering: enabled\n");
	} else {
	snprintf(buffer, SIZE, "Metrics gathering: DISABLED via property\n");
	}
	result.append(buffer);

	snprintf(buffer, SIZE,
	"Since Boot: Submissions: %" PRId64
	" Finalizations: %" PRId64
	" Discarded: %" PRId64 "\n",
	mItemsSubmitted, mItemsFinalized, mItemsDiscarded);
	result.append(buffer);
	snprintf(buffer, SIZE,
	"Summary Sets Discarded: %" PRId64 "\n", mSetsDiscarded);
	result.append(buffer);
	if (ts_since != 0) {
	snprintf(buffer, SIZE,
	"Dumping Queue entries more recent than: %" PRId64 "\n",
	(int64_t) ts_since);
	result.append(buffer);
	}
	}

	// dump summary info
	void MediaAnalyticsService::dumpSummaries(String8 &result, nsecs_t ts_since, const char *only) {
	const size_t SIZE = 512;
	char buffer[SIZE];
	int slot = 0;

	snprintf(buffer, SIZE, "\nSummarized Metrics:\n");
	result.append(buffer);

	// have each of the distillers dump records
	if (mSummarizerSets != NULL) {
	List<SummarizerSet *>::iterator itSet = mSummarizerSets->begin();
	for (; itSet != mSummarizerSets->end(); itSet++) {
	nsecs_t when = (*itSet)->getStarted();
	if (when < ts_since) {
	continue;
	}
	List<MetricsSummarizer > list = (*itSet)->getSummarizers();
	List<MetricsSummarizer *>::iterator it = list->begin();
	for (; it != list->end(); it++) {
	if (only != NULL && strcmp(only, (*it)->getKey()) != 0) {
	ALOGV("Told to omit '%s'", (*it)->getKey());
	}
	AString distilled = (*it)->dumpSummary(slot, only);
	result.append(distilled.c_str());
	}
	}
	}
	}

	// the recent, detailed queues
	void MediaAnalyticsService::dumpRecent(String8 &result, nsecs_t ts_since, const char * only) {
	const size_t SIZE = 512;
	char buffer[SIZE];

	// show the recently recorded records
	snprintf(buffer, sizeof(buffer), "\nFinalized Metrics (oldest first):\n");
	result.append(buffer);
	result.append(this->dumpQueue(mFinalized, ts_since, only));

	snprintf(buffer, sizeof(buffer), "\nIn-Progress Metrics (newest first):\n");
	result.append(buffer);
	result.append(this->dumpQueue(mOpen, ts_since, only));

	// show who is connected and injecting records?
	// talk about # records fed to the 'readers'
	// talk about # records we discarded, perhaps "discarded w/o reading" too
	}
	// caller has locked mLock...
	String8 MediaAnalyticsService::dumpQueue(List<MediaAnalyticsItem > theList) {
	return dumpQueue(theList, (nsecs_t) 0, NULL);
	}

	String8 MediaAnalyticsService::dumpQueue(List<MediaAnalyticsItem > theList, nsecs_t ts_since, const char * only) {
	String8 result;
	int slot = 0;

	if (theList->empty()) {
	result.append("empty\n");
	} else {
	List<MediaAnalyticsItem *>::iterator it = theList->begin();
	for (; it != theList->end(); it++) {
	nsecs_t when = (*it)->getTimestamp();
	if (when < ts_since) {
	continue;
	}
	if (only != NULL &&
	strcmp(only, (*it)->getKey().c_str()) != 0) {
	ALOGV("Omit '%s', it's not '%s'", (*it)->getKey().c_str(), only);
	continue;
	}
	AString entry = (*it)->toString();
	result.appendFormat("%5d: %s\n", slot, entry.c_str());
	slot++;
	}
	}

	return result;
	}

	//
	// Our Cheap in-core, non-persistent records management.
	// XXX: rewrite this to manage persistence, etc.

	// insert appropriately into queue
	void MediaAnalyticsService::saveItem(List<MediaAnalyticsItem > l, MediaAnalyticsItem * item, int front) {

	Mutex::Autolock _l(mLock);

	// adding at back of queue (fifo order)
	if (front) {
	l->push_front(item);
	} else {
	l->push_back(item);
	}

	// keep removing old records the front until we're in-bounds
	if (mMaxRecords > 0) {
	while (l->size() > (size_t) mMaxRecords) {
	MediaAnalyticsItem * oitem = *(l->begin());
	l->erase(l->begin());
	delete oitem;
	mItemsDiscarded++;
	}
	}
	}

	// are they alike enough that nitem can be folded into oitem?
	static bool compatibleItems(MediaAnalyticsItem * oitem, MediaAnalyticsItem * nitem) {

	if (0) {
	ALOGD("Compare: o %s n %s",
	oitem->toString().c_str(), nitem->toString().c_str());
	}

	// general safety
	if (nitem->getUid() != oitem->getUid()) {
	return false;
	}
	if (nitem->getPid() != oitem->getPid()) {
	return false;
	}

	// key -- needs to match
	if (nitem->getKey() == oitem->getKey()) {
	// still in the game.
	} else {
	return false;
	}

	// session id -- empty field in new is allowed
	MediaAnalyticsItem::SessionID_t osession = oitem->getSessionID();
	MediaAnalyticsItem::SessionID_t nsession = nitem->getSessionID();
	if (nsession != osession) {
	// incoming '0' matches value in osession
	if (nsession != 0) {
	return false;
	}
	}

	return true;
	}

	// find the incomplete record that this will overlay
	MediaAnalyticsItem MediaAnalyticsService::findItem(List<MediaAnalyticsItem> theList, MediaAnalyticsItem nitem, bool removeit) {
	if (nitem == NULL) {
	return NULL;
	}

	MediaAnalyticsItem *item = NULL;

	Mutex::Autolock _l(mLock);

	for (List<MediaAnalyticsItem *>::iterator it = theList->begin();
	it != theList->end(); it++) {
	MediaAnalyticsItem tmp = (it);

	if (!compatibleItems(tmp, nitem)) {
	continue;
	}

	// we match! this is the one I want.
	if (removeit) {
	theList->erase(it);
	}
	item = tmp;
	break;
	}
	return item;
	}


	// delete the indicated record
	void MediaAnalyticsService::deleteItem(List<MediaAnalyticsItem > l, MediaAnalyticsItem *item) {

	Mutex::Autolock _l(mLock);

	for (List<MediaAnalyticsItem *>::iterator it = l->begin();
	it != l->end(); it++) {
	if ((*it)->getSessionID() != item->getSessionID())
	continue;
	delete *it;
	l->erase(it);
	break;
	}
	}

	static AString allowedKeys[] =
	{
	"codec",
	"extractor"
	};

	static const int nAllowedKeys = sizeof(allowedKeys) / sizeof(allowedKeys[0]);

	// are the contents good
	bool MediaAnalyticsService::contentValid(MediaAnalyticsItem *item, bool isTrusted) {

	// untrusted uids can only send us a limited set of keys
	if (isTrusted == false) {
	// restrict to a specific set of keys
	AString key = item->getKey();

	size_t i;
	for(i = 0; i < nAllowedKeys; i++) {
	if (key == allowedKeys[i]) {
	break;
	}
	}
	if (i == nAllowedKeys) {
	ALOGD("Ignoring (key): %s", item->toString().c_str());
	return false;
	}
	}

	// internal consistency

	return true;
	}

	// are we rate limited, normally false
	bool MediaAnalyticsService::rateLimited(MediaAnalyticsItem *) {

	return false;
	}

	// insert into the appropriate summarizer.
	// we make our own copy to save/summarize
	void MediaAnalyticsService::summarize(MediaAnalyticsItem *item) {

	ALOGV("MediaAnalyticsService::summarize()");

	if (item == NULL) {
	return;
	}

	nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
	if (mCurrentSet == NULL
	\|\| (mCurrentSet->getStarted() + mNewSetInterval < now)) {
	newSummarizerSet();
	}

	if (mCurrentSet == NULL) {
	return;
	}

	List<MetricsSummarizer > summarizers = mCurrentSet->getSummarizers();
	List<MetricsSummarizer *>::iterator it = summarizers->begin();
	for (; it != summarizers->end(); it++) {
	if ((it)->isMine(item)) {
	break;
	}
	}
	if (it == summarizers->end()) {
	ALOGD("no handler for type %s", item->getKey().c_str());
	return; // no handler
	}

	// invoke the summarizer. summarizer will make whatever copies
	// it wants; the caller retains ownership of item.

	(*it)->handleRecord(item);

	}

	} // namespace android