/*
|
* 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
|
