关键字： 应用统计 Android源码 应用使用时长 应用使用次数
上篇文章讲到BinderService调用了UserUsageStatsService的相关函数接口，实现了应用使用信息的记录。本篇文章主要是根据源码UserUsageStatsService进行解析，介绍关于读取数据的详细流程。
数据的读取
之前的文章曾讲到，不论是Event还是ConfigurationChange，都是调用UserUsageStatsService.reportEvent(event)这一函数，用来记录event和config数据；使用UserUsageStatsService.queryStats()这一函数，进行数据的读取。接下来就会主要讲解关于数据读取部分的代码逻辑。
读取UsageStats
/**
* Generic query method that selects the appropriate IntervalStats for the specified time range
* and bucket, then calls the {@link com.android.server.usage.UsageStatsDatabase.StatCombiner}
* provided to select the stats to use from the IntervalStats object.
*/
private <T> List<T> queryStats(int intervalType, final long beginTime, final long endTime,
StatCombiner<T> combiner) {
//如果intervalType==INTERVAL_BEST，则自行根据所给的时间区间，获取最合适的查询类型（按天，周，月或年查询）
if (intervalType == UsageStatsManager.INTERVAL_BEST) {
intervalType = mDatabase.findBestFitBucket(beginTime, endTime);
if (intervalType < 0) {
// Nothing saved to disk yet, so every stat is just as equal (no rollover has
// occurred.
intervalType = UsageStatsManager.INTERVAL_DAILY;
}
}
//查询类型异常的话，则返回null。（查询类型只有4种，即0~3，分别按天，周，月或年查询）
if (intervalType < 0 || intervalType >= mCurrentStats.length) {
if (DEBUG) {
Slog.d(TAG, mLogPrefix + "Bad intervalType used " + intervalType);
}
return null;
}
// 获取所需查询的IntervalStats
final IntervalStats currentStats = mCurrentStats[intervalType];
if (DEBUG) {
Slog.d(TAG, mLogPrefix + "SELECT * FROM " + intervalType + " WHERE beginTime >= "
+ beginTime + " AND endTime < " + endTime);
}
//如果所查询的时间区间和currentStats记录的时间区间不存在交集，则返回null
if (beginTime >= currentStats.endTime) {
if (DEBUG) {
Slog.d(TAG, mLogPrefix + "Requesting stats after " + beginTime + " but latest is "
+ currentStats.endTime);
}
// Nothing newer available.
return null;
}
// Truncate the endTime to just before the in-memory stats. Then, we'll append the
// in-memory stats to the results (if necessary) so as to avoid writing to disk too
// often.
//截取查询时间段在currentStats的时间区间之前的那一段时间，获取查询结果，以避免过于频繁的读取文件
final long truncatedEndTime = Math.min(currentStats.beginTime, endTime);
// Get the stats from disk. 读取文件中的数据
List<T> results = mDatabase.queryUsageStats(intervalType, beginTime,
truncatedEndTime, combiner);
if (DEBUG) {
Slog.d(TAG, "Got " + (results != null ? results.size() : 0) + " results from disk");
Slog.d(TAG, "Current stats beginTime=" + currentStats.beginTime +
" endTime=" + currentStats.endTime);
}
// Now check if the in-memory stats match the range and add them if they do.
//除了当前内存中的数据读取完成之后，再加上当前内存的数据（注：当前内存的数据都是最新的，这样读取的数据就会按照时间顺序排列）
if (beginTime < currentStats.endTime && endTime > currentStats.beginTime) {
if (DEBUG) {
Slog.d(TAG, mLogPrefix + "Returning in-memory stats");
}
if (results == null) {
results = new ArrayList<>();
}
combiner.combine(currentStats, true, results);
}
if (DEBUG) {
Slog.d(TAG, mLogPrefix + "Results: " + (results != null ? results.size() : 0));
}
return results;
}
List<UsageStats> queryUsageStats(int bucketType, long beginTime, long endTime) {
return queryStats(bucketType, beginTime, endTime, sUsageStatsCombiner);
}
从上述代码可以得知，数据的读取，主要是调用mDatabase.queryUsageStats（）这一函数进行的，这一函数也是从文件读取数据的关键函数。
/**
* Find all {@link IntervalStats} for the given range and interval type.
*/
public <T> List<T> queryUsageStats(int intervalType, long beginTime, long endTime,
StatCombiner<T> combiner) {
synchronized (mLock) {
//再次检查intervalType 是否合法（额？为什么是再次？ `_`|||）
if (intervalType < 0 || intervalType >= mIntervalDirs.length) {
throw new IllegalArgumentException("Bad interval type " + intervalType);
}
//按照查询类型，获取所需查找的文件
final TimeSparseArray<AtomicFile> intervalStats = mSortedStatFiles[intervalType];
if (endTime <= beginTime) {
if (DEBUG) {
Slog.d(TAG, "endTime(" + endTime + ") <= beginTime(" + beginTime + ")");
}
return null;
}
//获取第一个所需查找的文件的文件序号，如果第一个记录的文件记录的时间就已经在查询范围中，则证明所有文件都在查询范围，则从第一个文件开始查起
int startIndex = intervalStats.closestIndexOnOrBefore(beginTime);
if (startIndex < 0) {
// All the stats available have timestamps after beginTime, which means they all
// match.
startIndex = 0;
}
//获取最后一个所需查找的文件的文件序号，如果第一个记录的文件记录的时间就已经晚于查询的最后时间，则证明所有文件都不在查询范围，则返回null
int endIndex = intervalStats.closestIndexOnOrBefore(endTime);
if (endIndex < 0) {
// All the stats start after this range ends, so nothing matches.
if (DEBUG) {
Slog.d(TAG, "No results for this range. All stats start after.");
}
return null;
}
//如果查询的endTime刚好是文件记录的开始那一时刻，则不查询最后一个文件，文件数减一
//因为最后一个文件的开始时间其实只是刚好在endTime这一临界时刻，这一文件的数据都在endTime之后，不需进行读取
if (intervalStats.keyAt(endIndex) == endTime) {
// The endTime is exclusive, so if we matched exactly take the one before.
endIndex--;
if (endIndex < 0) {
// All the stats start after this range ends, so nothing matches.
if (DEBUG) {
Slog.d(TAG, "No results for this range. All stats start after.");
}
return null;
}
}
//循环读取文件数据
try {
IntervalStats stats = new IntervalStats();
ArrayList<T> results = new ArrayList<>();
for (int i = startIndex; i <= endIndex; i++) {
final AtomicFile f = intervalStats.valueAt(i);
if (DEBUG) {
Slog.d(TAG, "Reading stat file " + f.getBaseFile().getAbsolutePath());
}
UsageStatsXml.read(f, stats);
if (beginTime < stats.endTime) {
combiner.combine(stats, false, results);
}
}
return results;
} catch (IOException e) {
Slog.e(TAG, "Failed to read usage stats file", e);
return null;
}
}
}
从上述代码可以得知，循环读取文件使用的是UsageStatsXml.read(AtomicFile file, IntervalStats statsOut)这一函数。其源码如下：
public static void read(AtomicFile file, IntervalStats statsOut) throws IOException {
try {
FileInputStream in = file.openRead();
try {
statsOut.beginTime = parseBeginTime(file);
read(in, statsOut);
statsOut.lastTimeSaved = file.getLastModifiedTime();
} finally {
try {
in.close();
} catch (IOException e) {
// Empty
}
}
} catch (FileNotFoundException e) {
Slog.e(TAG, "UsageStats Xml", e);
throw e;
}
}
private static void read(InputStream in, IntervalStats statsOut) throws IOException {
XmlPullParser parser = Xml.newPullParser();
try {
parser.setInput(in, "utf-8");
XmlUtils.beginDocument(parser, USAGESTATS_TAG);
String versionStr = parser.getAttributeValue(null, VERSION_ATTR);
try {
switch (Integer.parseInt(versionStr)) {
case 1:
UsageStatsXmlV1.read(parser, statsOut);
break;
default:
Slog.e(TAG, "Unrecognized version " + versionStr);
throw new IOException("Unrecognized version " + versionStr);
}
} catch (NumberFormatException e) {
Slog.e(TAG, "Bad version");
throw new IOException(e);
}
} catch (XmlPullParserException e) {
Slog.e(TAG, "Failed to parse Xml", e);
throw new IOException(e);
}
}
UsageStatsXml.read(AtomicFile file, IntervalStats statsOut)调用UsageStatsXml.read(InputStream in, IntervalStats statsOut)，从中可以发现其关键函数是调用UsageStatsXmlV1.read(parser, statsOut);
/**
* Reads from the {@link XmlPullParser}, assuming that it is already on the
* <code><usagestats></code> tag.
*
* @param parser The parser from which to read events.
* @param statsOut The stats object to populate with the data from the XML file.
*/
public static void read(XmlPullParser parser, IntervalStats statsOut)
throws XmlPullParserException, IOException {
//清空原有的数据
statsOut.packageStats.clear();
statsOut.configurations.clear();
statsOut.activeConfiguration = null;
if (statsOut.events != null) {
statsOut.events.clear();
}
statsOut.endTime = XmlUtils.readLongAttribute(parser, END_TIME_ATTR);
int eventCode;
int outerDepth = parser.getDepth();
// 循环读取各个节点的数据
while ((eventCode = parser.next()) != XmlPullParser.END_DOCUMENT
&& (eventCode != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
if (eventCode != XmlPullParser.START_TAG) {
continue;
}
final String tag = parser.getName();
switch (tag) {
case PACKAGE_TAG:
loadUsageStats(parser, statsOut);
break;
case CONFIG_TAG:
loadConfigStats(parser, statsOut);
break;
case EVENT_TAG:
loadEvent(parser, statsOut);
break;
}
}
}
如上，循环读取各个节点的数据的时候，根据节点的不同，分别调用loadUsageStats(parser, statsOut)，loadConfigStats(parser, statsOut)，loadEvent(parser, statsOut)，这三个函数将UsageStats，ConfigStats，以及Events分别读取写入statsOut中。
— 具体写入函数如下：
private static void loadUsageStats(XmlPullParser parser, IntervalStats statsOut)
throws XmlPullParserException, IOException {
final String pkg = parser.getAttributeValue(null, PACKAGE_ATTR);
if (pkg == null) {
throw new ProtocolException("no " + PACKAGE_ATTR + " attribute present");
}
final UsageStats stats = statsOut.getOrCreateUsageStats(pkg);
// Apply the offset to the beginTime to find the absolute time.
stats.mLastTimeUsed = statsOut.beginTime + XmlUtils.readLongAttribute(
parser, LAST_TIME_ACTIVE_ATTR);
stats.mTotalTimeInForeground = XmlUtils.readLongAttribute(parser, TOTAL_TIME_ACTIVE_ATTR);
stats.mLastEvent = XmlUtils.readIntAttribute(parser, LAST_EVENT_ATTR);
}
private static void loadConfigStats(XmlPullParser parser, IntervalStats statsOut)
throws XmlPullParserException, IOException {
final Configuration config = new Configuration();
Configuration.readXmlAttrs(parser, config);
final ConfigurationStats configStats = statsOut.getOrCreateConfigurationStats(config);
// Apply the offset to the beginTime to find the absolute time.
configStats.mLastTimeActive = statsOut.beginTime + XmlUtils.readLongAttribute(
parser, LAST_TIME_ACTIVE_ATTR);
configStats.mTotalTimeActive = XmlUtils.readLongAttribute(parser, TOTAL_TIME_ACTIVE_ATTR);
configStats.mActivationCount = XmlUtils.readIntAttribute(parser, COUNT_ATTR);
if (XmlUtils.readBooleanAttribute(parser, ACTIVE_ATTR)) {
statsOut.activeConfiguration = configStats.mConfiguration;
}
}
private static void loadEvent(XmlPullParser parser, IntervalStats statsOut)
throws XmlPullParserException, IOException {
final String packageName = XmlUtils.readStringAttribute(parser, PACKAGE_ATTR);
if (packageName == null) {
throw new ProtocolException("no " + PACKAGE_ATTR + " attribute present");
}
final String className = XmlUtils.readStringAttribute(parser, CLASS_ATTR);
final UsageEvents.Event event = statsOut.buildEvent(packageName, className);
// Apply the offset to the beginTime to find the absolute time of this event.
event.mTimeStamp = statsOut.beginTime + XmlUtils.readLongAttribute(parser, TIME_ATTR);
event.mEventType = XmlUtils.readIntAttribute(parser, TYPE_ATTR);
if (event.mEventType == UsageEvents.Event.CONFIGURATION_CHANGE) {
event.mConfiguration = new Configuration();
Configuration.readXmlAttrs(parser, event.mConfiguration);
}
if (statsOut.events == null) {
statsOut.events = new TimeSparseArray<>();
}
statsOut.events.put(event.mTimeStamp, event);
}
以上便是读取UsageStats的主要流程。
读取ConfigurationStats
List<ConfigurationStats> queryConfigurationStats(int bucketType, long beginTime, long endTime) {
return queryStats(bucketType, beginTime, endTime, sConfigStatsCombiner);
}
没什么好说的，读取ConfigurationStats采用和UsageStats一样的方式，上文已提到过了，不再一一赘述。
读取Events
UsageEvents queryEvents(final long beginTime, final long endTime) {
final ArraySet<String> names = new ArraySet<>();
List<UsageEvents.Event> results = queryStats(UsageStatsManager.INTERVAL_DAILY,
beginTime, endTime, new StatCombiner<UsageEvents.Event>() {
@Override
public void combine(IntervalStats stats, boolean mutable,
List<UsageEvents.Event> accumulatedResult) {
if (stats.events == null) {
return;
}
final int startIndex = stats.events.closestIndexOnOrAfter(beginTime);
if (startIndex < 0) {
return;
}
final int size = stats.events.size();
for (int i = startIndex; i < size; i++) {
if (stats.events.keyAt(i) >= endTime) {
return;
}
final UsageEvents.Event event = stats.events.valueAt(i);
names.add(event.mPackage);
if (event.mClass != null) {
names.add(event.mClass);
}
accumulatedResult.add(event);
}
}
});
if (results == null || results.isEmpty()) {
return null;
}
String[] table = names.toArray(new String[names.size()]);
Arrays.sort(table);
return new UsageEvents(results, table);
}
从上述源码可知，查询Events的接口，调用的乃是和查询UsageStats相同的queryStats(）函数，具体流程可参见本文上述“查询Stats”相关内容。
结语：
本文主要介绍了关于Android系统中统计各个app的使用情况的解决方案，主要是介绍了在统计数据的时候，读取将写入对应文件的数据这一具体流程，以及写入数据的详细情况。接下来的文章中将会详细阐述如何读取这些记录的数据，并且使用他们。
转载请注明出处。
github：UseTimeStatistic
参考文献：
Android 5.1相关源码目录
Android UsageStatsService：要点解析
Android5.1应用打开次数获取
