services/mediaanalytics/MediaAnalyticsService.cpp - third_party/android/platform/frameworks/av - Git at Google

 /*
  * 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 <pthread.h>
 #include <unistd.h>

 #include <string.h>
 #include <pwd.h>

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

 #include <utils/misc.h>

 #include <android/content/pm/IPackageManagerNative.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/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"

 namespace android {

 // individual records kept in memory: age or count
 // age: <= 28 hours (1 1/6 days)
 // count: hard limit of # records
 // (0 for either of these disables that threshold)
 //
 static constexpr nsecs_t kMaxRecordAgeNs =  28 * 3600 * (1000*1000*1000ll);
 // 2019/6: average daily per device is currently 375-ish;
 // setting this to 2000 is large enough to catch most devices
 // we'll lose some data on very very media-active devices, but only for
 // the gms collection; statsd will have already covered those for us.
 // This also retains enough information to help with bugreports
 static constexpr int kMaxRecords    = 2000;

 // max we expire in a single call, to constrain how long we hold the
 // mutex, which also constrains how long a client might wait.
 static constexpr int kMaxExpiredAtOnce = 50;

 // TODO: need to look at tuning kMaxRecords and friends for low-memory devices

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

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

 MediaAnalyticsService::MediaAnalyticsService()
         : mMaxRecords(kMaxRecords),
           mMaxRecordAgeNs(kMaxRecordAgeNs),
           mMaxRecordsExpiredAtOnce(kMaxExpiredAtOnce),
           mDumpProto(MediaAnalyticsItem::PROTO_V1),
           mDumpProtoDefault(MediaAnalyticsItem::PROTO_V1) {

     ALOGD("MediaAnalyticsService created");

     mItemsSubmitted = 0;
     mItemsFinalized = 0;
     mItemsDiscarded = 0;
     mItemsDiscardedExpire = 0;
     mItemsDiscardedCount = 0;

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

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

     while (mItems.size() > 0) {
         MediaAnalyticsItem * oitem = *(mItems.begin());
         mItems.erase(mItems.begin());
         delete oitem;
         mItemsDiscarded++;
         mItemsDiscardedCount++;
     }
 }


 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)
 {
     UNUSED(forcenew);

     // fill in a sessionID if we do not yet have one
     if (item->getSessionID() <= MediaAnalyticsItem::SessionIDNone) {
         item->setSessionID(generateUniqueSessionID());
     }

     // we control these, generally not trusting user input
     nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
     // round nsecs to seconds
     now = ((now + 500000000) / 1000000000) * 1000000000;
     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 some trusted client uids
     bool isTrusted = false;

     ALOGV("caller has uid=%d, embedded uid=%d", uid, uid_given);

     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;
     }

     // Overwrite package name and version if the caller was untrusted.
     if (!isTrusted) {
       setPkgInfo(item, item->getUid(), true, true);
     } else if (item->getPkgName().empty()) {
       // empty, so fill out both parts
       setPkgInfo(item, item->getUid(), true, true);
     } else {
       // trusted, provided a package, do nothing
     }

     ALOGV("given uid %d; sanitized uid: %d sanitized pkg: %s "
           "sanitized pkg version: %"  PRId64,
           uid_given, item->getUid(),
           item->getPkgName().c_str(),
           item->getPkgVersionCode());

     mItemsSubmitted++;

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

     // XXX: if we have a sessionid in the new record, look to make
     // sure it doesn't appear in the finalized list.

     if (item->count() == 0) {
         ALOGV("dropping empty record...");
         delete item;
         item = NULL;
         return MediaAnalyticsItem::SessionIDInvalid;
     }

     // save the new record
     //
     // send a copy to statsd
     dump2Statsd(item);

     // and keep our copy for dumpsys
     MediaAnalyticsItem::SessionID_t id = item->getSessionID();
     saveItem(item);
     mItemsFinalized++;

     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
     String16 protoOption("-proto");
     int chosenProto = mDumpProtoDefault;
     String16 clearOption("-clear");
     bool clear = false;
     String16 sinceOption("-since");
     nsecs_t ts_since = 0;
     String16 helpOption("-help");
     String16 onlyOption("-only");
     std::string only;
     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] == protoOption) {
             i++;
             if (i < n) {
                 String8 value(args[i]);
                 int proto = MediaAnalyticsItem::PROTO_V0;
                 char *endp;
                 const char *p = value.string();
                 proto = strtol(p, &endp, 10);
                 if (endp != p || *endp == '\0') {
                     if (proto < MediaAnalyticsItem::PROTO_FIRST) {
                         proto = MediaAnalyticsItem::PROTO_FIRST;
                     } else if (proto > MediaAnalyticsItem::PROTO_LAST) {
                         proto = MediaAnalyticsItem::PROTO_LAST;
                     }
                     chosenProto = proto;
                 } else {
                     result.append("unable to parse value for -proto\n\n");
                 }
             } else {
                 result.append("missing value for -proto\n\n");
             }
         } 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]);
                 only = value.string();
             }
         } else if (args[i] == helpOption) {
             result.append("Recognized parameters:\n");
             result.append("-help        this help message\n");
             result.append("-proto #     dump using protocol #");
             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);
     // mutex between insertion and dumping the contents

     mDumpProto = chosenProto;

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

     dumpHeaders(result, ts_since);

     dumpRecent(result, ts_since, only.c_str());


     if (clear) {
         // remove everything from the finalized queue
         while (mItems.size() > 0) {
             MediaAnalyticsItem * oitem = *(mItems.begin());
             mItems.erase(mItems.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];

     snprintf(buffer, SIZE, "Protocol Version: %d\n", mDumpProto);
     result.append(buffer);

     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: %8" PRId64
             " Accepted: %8" PRId64 "\n",
         mItemsSubmitted, mItemsFinalized);
     result.append(buffer);
     snprintf(buffer, SIZE,
         "Records Discarded: %8" PRId64
             " (by Count: %" PRId64 " by Expiration: %" PRId64 ")\n",
          mItemsDiscarded, mItemsDiscardedCount, mItemsDiscardedExpire);
     result.append(buffer);
     if (ts_since != 0) {
         snprintf(buffer, SIZE,
             "Emitting Queue entries more recent than: %" PRId64 "\n",
             (int64_t) ts_since);
         result.append(buffer);
     }
 }

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

     if (only != NULL && *only == '\0') {
         only = NULL;
     }

     // show the recently recorded records
     snprintf(buffer, sizeof(buffer), "\nFinalized Metrics (oldest first):\n");
     result.append(buffer);
     result.append(this->dumpQueue(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() {
     return dumpQueue((nsecs_t) 0, NULL);
 }

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

     if (mItems.empty()) {
             result.append("empty\n");
     } else {
         List<MediaAnalyticsItem *>::iterator it = mItems.begin();
         for (; it != mItems.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;
             }
             std::string entry = (*it)->toString(mDumpProto);
             result.appendFormat("%5d: %s\n", slot, entry.c_str());
             slot++;
         }
     }

     return result;
 }

 //
 // Our Cheap in-core, non-persistent records management.


 // we hold mLock when we get here
 // if item != NULL, it's the item we just inserted
 // true == more items eligible to be recovered
 bool MediaAnalyticsService::expirations_l(MediaAnalyticsItem *item)
 {
     bool more = false;
     int handled = 0;

     // keep removing old records the front until we're in-bounds (count)
     // since we invoke this with each insertion, it should be 0/1 iterations.
     if (mMaxRecords > 0) {
         while (mItems.size() > (size_t) mMaxRecords) {
             MediaAnalyticsItem * oitem = *(mItems.begin());
             if (oitem == item) {
                 break;
             }
             if (handled >= mMaxRecordsExpiredAtOnce) {
                 // unlikely in this loop
                 more = true;
                 break;
             }
             handled++;
             mItems.erase(mItems.begin());
             delete oitem;
             mItemsDiscarded++;
             mItemsDiscardedCount++;
         }
     }

     // keep removing old records the front until we're in-bounds (age)
     // limited to mMaxRecordsExpiredAtOnce items per invocation.
     if (mMaxRecordAgeNs > 0) {
         nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
         while (mItems.size() > 0) {
             MediaAnalyticsItem * oitem = *(mItems.begin());
             nsecs_t when = oitem->getTimestamp();
             if (oitem == item) {
                 break;
             }
             // careful about timejumps too
             if ((now > when) && (now-when) <= mMaxRecordAgeNs) {
                 // this (and the rest) are recent enough to keep
                 break;
             }
             if (handled >= mMaxRecordsExpiredAtOnce) {
                 // this represents "one too many"; tell caller there are
                 // more to be reclaimed.
                 more = true;
                 break;
             }
             handled++;
             mItems.erase(mItems.begin());
             delete oitem;
             mItemsDiscarded++;
             mItemsDiscardedExpire++;
         }
     }

     // we only indicate whether there's more to clean;
     // caller chooses whether to schedule further cleanup.
     return more;
 }

 // process expirations in bite sized chunks, allowing new insertions through
 // runs in a pthread specifically started for this (which then exits)
 bool MediaAnalyticsService::processExpirations()
 {
     bool more;
     do {
         sleep(1);
         {
             Mutex::Autolock _l(mLock);
             more = expirations_l(NULL);
             if (!more) {
                 break;
             }
         }
     } while (more);
     return true;        // value is for std::future thread synchronization
 }

 // insert appropriately into queue
 void MediaAnalyticsService::saveItem(MediaAnalyticsItem * item)
 {

     Mutex::Autolock _l(mLock);
     // mutex between insertion and dumping the contents

     // we want to dump 'in FIFO order', so insert at the end
     mItems.push_back(item);

     // clean old stuff from the queue
     bool more = expirations_l(item);

     // consider scheduling some asynchronous cleaning, if not running
     if (more) {
         if (!mExpireFuture.valid()
             || mExpireFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {

             mExpireFuture = std::async(std::launch::async, [this]()
                                        {return this->processExpirations();});
         }
     }
 }

 static std::string allowedKeys[] =
 {
     "audiopolicy",
     "audiorecord",
     "audiothread",
     "audiotrack",
     "codec",
     "extractor",
     "nuplayer",
 };

 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
         std::string 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;
 }

 // how long we hold package info before we re-fetch it
 #define PKG_EXPIRATION_NS (30*60*1000000000ll)   // 30 minutes, in nsecs

 // give me the package name, perhaps going to find it
 // manages its own mutex operations internally
 void MediaAnalyticsService::setPkgInfo(MediaAnalyticsItem *item, uid_t uid, bool setName, bool setVersion)
 {
     ALOGV("asking for packagename to go with uid=%d", uid);

     if (!setName && !setVersion) {
         // setting nothing? strange
         return;
     }

     nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
     struct UidToPkgMap mapping;
     mapping.uid = (uid_t)(-1);

     {
         Mutex::Autolock _l(mLock_mappings);
         int i = mPkgMappings.indexOfKey(uid);
         if (i >= 0) {
             mapping = mPkgMappings.valueAt(i);
             ALOGV("Expiration? uid %d expiration %" PRId64 " now %" PRId64,
                   uid, mapping.expiration, now);
             if (mapping.expiration <= now) {
                 // purge the stale entry and fall into re-fetching
                 ALOGV("entry for uid %d expired, now= %" PRId64 "", uid, now);
                 mPkgMappings.removeItemsAt(i);
                 mapping.uid = (uid_t)(-1);
             }
         }
     }

     // if we did not find it
     if (mapping.uid == (uid_t)(-1)) {
         std::string pkg;
         std::string installer = "";
         int64_t versionCode = 0;

         struct passwd *pw = getpwuid(uid);
         if (pw) {
             pkg = pw->pw_name;
         }

         // find the proper value

         sp<IBinder> binder = NULL;
         sp<IServiceManager> sm = defaultServiceManager();
         if (sm == NULL) {
             ALOGE("defaultServiceManager failed");
         } else {
             binder = sm->getService(String16("package_native"));
             if (binder == NULL) {
                 ALOGE("getService package_native failed");
             }
         }

         if (binder != NULL) {
             sp<content::pm::IPackageManagerNative> package_mgr =
                             interface_cast<content::pm::IPackageManagerNative>(binder);
             binder::Status status;

             std::vector<int> uids;
             std::vector<std::string> names;

             uids.push_back(uid);

             status = package_mgr->getNamesForUids(uids, &names);
             if (!status.isOk()) {
                 ALOGE("package_native::getNamesForUids failed: %s",
                       status.exceptionMessage().c_str());
             } else {
                 if (!names[0].empty()) {
                     pkg = names[0].c_str();
                 }
             }

             // strip any leading "shared:" strings that came back
             if (pkg.compare(0, 7, "shared:") == 0) {
                 pkg.erase(0, 7);
             }

             // determine how pkg was installed and the versionCode
             //
             if (pkg.empty()) {
                 // no name for us to manage
             } else if (strchr(pkg.c_str(), '.') == NULL) {
                 // not of form 'com.whatever...'; assume internal and ok
             } else if (strncmp(pkg.c_str(), "android.", 8) == 0) {
                 // android.* packages are assumed fine
             } else {
                 String16 pkgName16(pkg.c_str());
                 status = package_mgr->getInstallerForPackage(pkgName16, &installer);
                 if (!status.isOk()) {
                     ALOGE("package_native::getInstallerForPackage failed: %s",
                           status.exceptionMessage().c_str());
                 }

                 // skip if we didn't get an installer
                 if (status.isOk()) {
                     status = package_mgr->getVersionCodeForPackage(pkgName16, &versionCode);
                     if (!status.isOk()) {
                         ALOGE("package_native::getVersionCodeForPackage failed: %s",
                           status.exceptionMessage().c_str());
                     }
                 }


                 ALOGV("package '%s' installed by '%s' versioncode %"  PRId64 " / %" PRIx64,
                       pkg.c_str(), installer.c_str(), versionCode, versionCode);

                 if (strncmp(installer.c_str(), "com.android.", 12) == 0) {
                         // from play store, we keep info
                 } else if (strncmp(installer.c_str(), "com.google.", 11) == 0) {
                         // some google source, we keep info
                 } else if (strcmp(installer.c_str(), "preload") == 0) {
                         // preloads, we keep the info
                 } else if (installer.c_str()[0] == '\0') {
                         // sideload (no installer); do not report
                         pkg = "";
                         versionCode = 0;
                 } else {
                         // unknown installer; do not report
                         pkg = "";
                         versionCode = 0;
                 }
             }
         }

         // add it to the map, to save a subsequent lookup
         if (!pkg.empty()) {
             Mutex::Autolock _l(mLock_mappings);
             ALOGV("Adding uid %d pkg '%s'", uid, pkg.c_str());
             ssize_t i = mPkgMappings.indexOfKey(uid);
             if (i < 0) {
                 mapping.uid = uid;
                 mapping.pkg = pkg;
                 mapping.installer = installer.c_str();
                 mapping.versionCode = versionCode;
                 mapping.expiration = now + PKG_EXPIRATION_NS;
                 ALOGV("expiration for uid %d set to %" PRId64 "", uid, mapping.expiration);

                 mPkgMappings.add(uid, mapping);
             }
         }
     }

     if (mapping.uid != (uid_t)(-1)) {
         if (setName) {
             item->setPkgName(mapping.pkg);
         }
         if (setVersion) {
             item->setPkgVersionCode(mapping.versionCode);
         }
     }
 }

 } // 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 <pthread.h>
	#include <unistd.h>

	#include <string.h>
	#include <pwd.h>

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

	#include <utils/misc.h>

	#include <android/content/pm/IPackageManagerNative.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/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"

	namespace android {

	// individual records kept in memory: age or count
	// age: <= 28 hours (1 1/6 days)
	// count: hard limit of # records
	// (0 for either of these disables that threshold)
	//
	static constexpr nsecs_t kMaxRecordAgeNs = 28 * 3600 * (100010001000ll);
	// 2019/6: average daily per device is currently 375-ish;
	// setting this to 2000 is large enough to catch most devices
	// we'll lose some data on very very media-active devices, but only for
	// the gms collection; statsd will have already covered those for us.
	// This also retains enough information to help with bugreports
	static constexpr int kMaxRecords = 2000;

	// max we expire in a single call, to constrain how long we hold the
	// mutex, which also constrains how long a client might wait.
	static constexpr int kMaxExpiredAtOnce = 50;

	// TODO: need to look at tuning kMaxRecords and friends for low-memory devices

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

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

	MediaAnalyticsService::MediaAnalyticsService()
	: mMaxRecords(kMaxRecords),
	mMaxRecordAgeNs(kMaxRecordAgeNs),
	mMaxRecordsExpiredAtOnce(kMaxExpiredAtOnce),
	mDumpProto(MediaAnalyticsItem::PROTO_V1),
	mDumpProtoDefault(MediaAnalyticsItem::PROTO_V1) {

	ALOGD("MediaAnalyticsService created");

	mItemsSubmitted = 0;
	mItemsFinalized = 0;
	mItemsDiscarded = 0;
	mItemsDiscardedExpire = 0;
	mItemsDiscardedCount = 0;

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

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

	while (mItems.size() > 0) {
	MediaAnalyticsItem * oitem = *(mItems.begin());
	mItems.erase(mItems.begin());
	delete oitem;
	mItemsDiscarded++;
	mItemsDiscardedCount++;
	}
	}


	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)
	{
	UNUSED(forcenew);

	// fill in a sessionID if we do not yet have one
	if (item->getSessionID() <= MediaAnalyticsItem::SessionIDNone) {
	item->setSessionID(generateUniqueSessionID());
	}

	// we control these, generally not trusting user input
	nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
	// round nsecs to seconds
	now = ((now + 500000000) / 1000000000) * 1000000000;
	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 some trusted client uids
	bool isTrusted = false;

	ALOGV("caller has uid=%d, embedded uid=%d", uid, uid_given);

	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;
	}

	// Overwrite package name and version if the caller was untrusted.
	if (!isTrusted) {
	setPkgInfo(item, item->getUid(), true, true);
	} else if (item->getPkgName().empty()) {
	// empty, so fill out both parts
	setPkgInfo(item, item->getUid(), true, true);
	} else {
	// trusted, provided a package, do nothing
	}

	ALOGV("given uid %d; sanitized uid: %d sanitized pkg: %s "
	"sanitized pkg version: %" PRId64,
	uid_given, item->getUid(),
	item->getPkgName().c_str(),
	item->getPkgVersionCode());

	mItemsSubmitted++;

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

	// XXX: if we have a sessionid in the new record, look to make
	// sure it doesn't appear in the finalized list.

	if (item->count() == 0) {
	ALOGV("dropping empty record...");
	delete item;
	item = NULL;
	return MediaAnalyticsItem::SessionIDInvalid;
	}

	// save the new record
	//
	// send a copy to statsd
	dump2Statsd(item);

	// and keep our copy for dumpsys
	MediaAnalyticsItem::SessionID_t id = item->getSessionID();
	saveItem(item);
	mItemsFinalized++;

	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
	String16 protoOption("-proto");
	int chosenProto = mDumpProtoDefault;
	String16 clearOption("-clear");
	bool clear = false;
	String16 sinceOption("-since");
	nsecs_t ts_since = 0;
	String16 helpOption("-help");
	String16 onlyOption("-only");
	std::string only;
	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] == protoOption) {
	i++;
	if (i < n) {
	String8 value(args[i]);
	int proto = MediaAnalyticsItem::PROTO_V0;
	char *endp;
	const char *p = value.string();
	proto = strtol(p, &endp, 10);
	if (endp != p \|\| *endp == '\0') {
	if (proto < MediaAnalyticsItem::PROTO_FIRST) {
	proto = MediaAnalyticsItem::PROTO_FIRST;
	} else if (proto > MediaAnalyticsItem::PROTO_LAST) {
	proto = MediaAnalyticsItem::PROTO_LAST;
	}
	chosenProto = proto;
	} else {
	result.append("unable to parse value for -proto\n\n");
	}
	} else {
	result.append("missing value for -proto\n\n");
	}
	} 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]);
	only = value.string();
	}
	} else if (args[i] == helpOption) {
	result.append("Recognized parameters:\n");
	result.append("-help this help message\n");
	result.append("-proto # dump using protocol #");
	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);
	// mutex between insertion and dumping the contents

	mDumpProto = chosenProto;

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

	dumpHeaders(result, ts_since);

	dumpRecent(result, ts_since, only.c_str());


	if (clear) {
	// remove everything from the finalized queue
	while (mItems.size() > 0) {
	MediaAnalyticsItem * oitem = *(mItems.begin());
	mItems.erase(mItems.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];

	snprintf(buffer, SIZE, "Protocol Version: %d\n", mDumpProto);
	result.append(buffer);

	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: %8" PRId64
	" Accepted: %8" PRId64 "\n",
	mItemsSubmitted, mItemsFinalized);
	result.append(buffer);
	snprintf(buffer, SIZE,
	"Records Discarded: %8" PRId64
	" (by Count: %" PRId64 " by Expiration: %" PRId64 ")\n",
	mItemsDiscarded, mItemsDiscardedCount, mItemsDiscardedExpire);
	result.append(buffer);
	if (ts_since != 0) {
	snprintf(buffer, SIZE,
	"Emitting Queue entries more recent than: %" PRId64 "\n",
	(int64_t) ts_since);
	result.append(buffer);
	}
	}

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

	if (only != NULL && *only == '\0') {
	only = NULL;
	}

	// show the recently recorded records
	snprintf(buffer, sizeof(buffer), "\nFinalized Metrics (oldest first):\n");
	result.append(buffer);
	result.append(this->dumpQueue(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() {
	return dumpQueue((nsecs_t) 0, NULL);
	}

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

	if (mItems.empty()) {
	result.append("empty\n");
	} else {
	List<MediaAnalyticsItem *>::iterator it = mItems.begin();
	for (; it != mItems.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;
	}
	std::string entry = (*it)->toString(mDumpProto);
	result.appendFormat("%5d: %s\n", slot, entry.c_str());
	slot++;
	}
	}

	return result;
	}

	//
	// Our Cheap in-core, non-persistent records management.


	// we hold mLock when we get here
	// if item != NULL, it's the item we just inserted
	// true == more items eligible to be recovered
	bool MediaAnalyticsService::expirations_l(MediaAnalyticsItem *item)
	{
	bool more = false;
	int handled = 0;

	// keep removing old records the front until we're in-bounds (count)
	// since we invoke this with each insertion, it should be 0/1 iterations.
	if (mMaxRecords > 0) {
	while (mItems.size() > (size_t) mMaxRecords) {
	MediaAnalyticsItem * oitem = *(mItems.begin());
	if (oitem == item) {
	break;
	}
	if (handled >= mMaxRecordsExpiredAtOnce) {
	// unlikely in this loop
	more = true;
	break;
	}
	handled++;
	mItems.erase(mItems.begin());
	delete oitem;
	mItemsDiscarded++;
	mItemsDiscardedCount++;
	}
	}

	// keep removing old records the front until we're in-bounds (age)
	// limited to mMaxRecordsExpiredAtOnce items per invocation.
	if (mMaxRecordAgeNs > 0) {
	nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
	while (mItems.size() > 0) {
	MediaAnalyticsItem * oitem = *(mItems.begin());
	nsecs_t when = oitem->getTimestamp();
	if (oitem == item) {
	break;
	}
	// careful about timejumps too
	if ((now > when) && (now-when) <= mMaxRecordAgeNs) {
	// this (and the rest) are recent enough to keep
	break;
	}
	if (handled >= mMaxRecordsExpiredAtOnce) {
	// this represents "one too many"; tell caller there are
	// more to be reclaimed.
	more = true;
	break;
	}
	handled++;
	mItems.erase(mItems.begin());
	delete oitem;
	mItemsDiscarded++;
	mItemsDiscardedExpire++;
	}
	}

	// we only indicate whether there's more to clean;
	// caller chooses whether to schedule further cleanup.
	return more;
	}

	// process expirations in bite sized chunks, allowing new insertions through
	// runs in a pthread specifically started for this (which then exits)
	bool MediaAnalyticsService::processExpirations()
	{
	bool more;
	do {
	sleep(1);
	{
	Mutex::Autolock _l(mLock);
	more = expirations_l(NULL);
	if (!more) {
	break;
	}
	}
	} while (more);
	return true; // value is for std::future thread synchronization
	}

	// insert appropriately into queue
	void MediaAnalyticsService::saveItem(MediaAnalyticsItem * item)
	{

	Mutex::Autolock _l(mLock);
	// mutex between insertion and dumping the contents

	// we want to dump 'in FIFO order', so insert at the end
	mItems.push_back(item);

	// clean old stuff from the queue
	bool more = expirations_l(item);

	// consider scheduling some asynchronous cleaning, if not running
	if (more) {
	if (!mExpireFuture.valid()
	\|\| mExpireFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {

	mExpireFuture = std::async(std::launch::async, [this]()
	{return this->processExpirations();});
	}
	}
	}

	static std::string allowedKeys[] =
	{
	"audiopolicy",
	"audiorecord",
	"audiothread",
	"audiotrack",
	"codec",
	"extractor",
	"nuplayer",
	};

	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
	std::string 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;
	}

	// how long we hold package info before we re-fetch it
	#define PKG_EXPIRATION_NS (30601000000000ll) // 30 minutes, in nsecs

	// give me the package name, perhaps going to find it
	// manages its own mutex operations internally
	void MediaAnalyticsService::setPkgInfo(MediaAnalyticsItem *item, uid_t uid, bool setName, bool setVersion)
	{
	ALOGV("asking for packagename to go with uid=%d", uid);

	if (!setName && !setVersion) {
	// setting nothing? strange
	return;
	}

	nsecs_t now = systemTime(SYSTEM_TIME_REALTIME);
	struct UidToPkgMap mapping;
	mapping.uid = (uid_t)(-1);

	{
	Mutex::Autolock _l(mLock_mappings);
	int i = mPkgMappings.indexOfKey(uid);
	if (i >= 0) {
	mapping = mPkgMappings.valueAt(i);
	ALOGV("Expiration? uid %d expiration %" PRId64 " now %" PRId64,
	uid, mapping.expiration, now);
	if (mapping.expiration <= now) {
	// purge the stale entry and fall into re-fetching
	ALOGV("entry for uid %d expired, now= %" PRId64 "", uid, now);
	mPkgMappings.removeItemsAt(i);
	mapping.uid = (uid_t)(-1);
	}
	}
	}

	// if we did not find it
	if (mapping.uid == (uid_t)(-1)) {
	std::string pkg;
	std::string installer = "";
	int64_t versionCode = 0;

	struct passwd *pw = getpwuid(uid);
	if (pw) {
	pkg = pw->pw_name;
	}

	// find the proper value

	sp<IBinder> binder = NULL;
	sp<IServiceManager> sm = defaultServiceManager();
	if (sm == NULL) {
	ALOGE("defaultServiceManager failed");
	} else {
	binder = sm->getService(String16("package_native"));
	if (binder == NULL) {
	ALOGE("getService package_native failed");
	}
	}

	if (binder != NULL) {
	sp<content::pm::IPackageManagerNative> package_mgr =
	interface_cast<content::pm::IPackageManagerNative>(binder);
	binder::Status status;

	std::vector<int> uids;
	std::vector<std::string> names;

	uids.push_back(uid);

	status = package_mgr->getNamesForUids(uids, &names);
	if (!status.isOk()) {
	ALOGE("package_native::getNamesForUids failed: %s",
	status.exceptionMessage().c_str());
	} else {
	if (!names[0].empty()) {
	pkg = names[0].c_str();
	}
	}

	// strip any leading "shared:" strings that came back
	if (pkg.compare(0, 7, "shared:") == 0) {
	pkg.erase(0, 7);
	}

	// determine how pkg was installed and the versionCode
	//
	if (pkg.empty()) {
	// no name for us to manage
	} else if (strchr(pkg.c_str(), '.') == NULL) {
	// not of form 'com.whatever...'; assume internal and ok
	} else if (strncmp(pkg.c_str(), "android.", 8) == 0) {
	// android.* packages are assumed fine
	} else {
	String16 pkgName16(pkg.c_str());
	status = package_mgr->getInstallerForPackage(pkgName16, &installer);
	if (!status.isOk()) {
	ALOGE("package_native::getInstallerForPackage failed: %s",
	status.exceptionMessage().c_str());
	}

	// skip if we didn't get an installer
	if (status.isOk()) {
	status = package_mgr->getVersionCodeForPackage(pkgName16, &versionCode);
	if (!status.isOk()) {
	ALOGE("package_native::getVersionCodeForPackage failed: %s",
	status.exceptionMessage().c_str());
	}
	}


	ALOGV("package '%s' installed by '%s' versioncode %" PRId64 " / %" PRIx64,
	pkg.c_str(), installer.c_str(), versionCode, versionCode);

	if (strncmp(installer.c_str(), "com.android.", 12) == 0) {
	// from play store, we keep info
	} else if (strncmp(installer.c_str(), "com.google.", 11) == 0) {
	// some google source, we keep info
	} else if (strcmp(installer.c_str(), "preload") == 0) {
	// preloads, we keep the info
	} else if (installer.c_str()[0] == '\0') {
	// sideload (no installer); do not report
	pkg = "";
	versionCode = 0;
	} else {
	// unknown installer; do not report
	pkg = "";
	versionCode = 0;
	}
	}
	}

	// add it to the map, to save a subsequent lookup
	if (!pkg.empty()) {
	Mutex::Autolock _l(mLock_mappings);
	ALOGV("Adding uid %d pkg '%s'", uid, pkg.c_str());
	ssize_t i = mPkgMappings.indexOfKey(uid);
	if (i < 0) {
	mapping.uid = uid;
	mapping.pkg = pkg;
	mapping.installer = installer.c_str();
	mapping.versionCode = versionCode;
	mapping.expiration = now + PKG_EXPIRATION_NS;
	ALOGV("expiration for uid %d set to %" PRId64 "", uid, mapping.expiration);

	mPkgMappings.add(uid, mapping);
	}
	}
	}

	if (mapping.uid != (uid_t)(-1)) {
	if (setName) {
	item->setPkgName(mapping.pkg);
	}
	if (setVersion) {
	item->setPkgVersionCode(mapping.versionCode);
	}
	}
	}

	} // namespace android