Introducing an interface to store alarms (323fccc6) · Commits · e / os / android_frameworks_base

apex/jobscheduler/service/java/com/android/server/alarm/Alarm.java

0 → 100644

+211 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2020 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.
			*/

			package com.android.server.alarm;

			import static android.app.AlarmManager.ELAPSED_REALTIME_WAKEUP;
			import static android.app.AlarmManager.RTC;
			import static android.app.AlarmManager.RTC_WAKEUP;

			import android.app.AlarmManager;
			import android.app.IAlarmListener;
			import android.app.PendingIntent;
			import android.os.WorkSource;
			import android.util.IndentingPrintWriter;
			import android.util.TimeUtils;
			import android.util.proto.ProtoOutputStream;

			import java.io.PrintWriter;
			import java.text.SimpleDateFormat;
			import java.util.Date;

			class Alarm {
			public final int type;
			public final long origWhen;
			public final boolean wakeup;
			public final PendingIntent operation;
			public final IAlarmListener listener;
			public final String listenerTag;
			public final String statsTag;
			public final WorkSource workSource;
			public final int flags;
			public final AlarmManager.AlarmClockInfo alarmClock;
			public final int uid;
			public final int creatorUid;
			public final String packageName;
			public final String sourcePackage;
			public int count;
			public long when;
			public long windowLength;
			public long whenElapsed; // 'when' in the elapsed time base
			public long maxWhenElapsed; // also in the elapsed time base
			// Expected alarm expiry time before app standby deferring is applied.
			public long expectedWhenElapsed;
			public long expectedMaxWhenElapsed;
			public long repeatInterval;
			public AlarmManagerService.PriorityClass priorityClass;

			Alarm(int _type, long _when, long _whenElapsed, long _windowLength, long _maxWhen,
			long _interval, PendingIntent _op, IAlarmListener _rec, String _listenerTag,
			WorkSource _ws, int _flags, AlarmManager.AlarmClockInfo _info,
			int _uid, String _pkgName) {
			type = _type;
			origWhen = _when;
			wakeup = _type == AlarmManager.ELAPSED_REALTIME_WAKEUP
			\|\| _type == AlarmManager.RTC_WAKEUP;
			when = _when;
			whenElapsed = _whenElapsed;
			expectedWhenElapsed = _whenElapsed;
			windowLength = _windowLength;
			maxWhenElapsed = expectedMaxWhenElapsed = AlarmManagerService.clampPositive(_maxWhen);
			repeatInterval = _interval;
			operation = _op;
			listener = _rec;
			listenerTag = _listenerTag;
			statsTag = makeTag(_op, _listenerTag, _type);
			workSource = _ws;
			flags = _flags;
			alarmClock = _info;
			uid = _uid;
			packageName = _pkgName;
			sourcePackage = (operation != null) ? operation.getCreatorPackage() : packageName;
			creatorUid = (operation != null) ? operation.getCreatorUid() : uid;
			}

			public static String makeTag(PendingIntent pi, String tag, int type) {
			final String alarmString = type == ELAPSED_REALTIME_WAKEUP \|\| type == RTC_WAKEUP
			? "walarm:" : "alarm:";
			return (pi != null) ? pi.getTag(alarmString) : (alarmString + tag);
			}

			public AlarmManagerService.WakeupEvent makeWakeupEvent(long nowRTC) {
			return new AlarmManagerService.WakeupEvent(nowRTC, creatorUid,
			(operation != null)
			? operation.getIntent().getAction()
			: ("<listener>:" + listenerTag));
			}

			// Returns true if either matches
			public boolean matches(PendingIntent pi, IAlarmListener rec) {
			return (operation != null)
			? operation.equals(pi)
			: rec != null && listener.asBinder().equals(rec.asBinder());
			}

			public boolean matches(String packageName) {
			return packageName.equals(sourcePackage);
			}

			@Override
			public String toString() {
			StringBuilder sb = new StringBuilder(128);
			sb.append("Alarm{");
			sb.append(Integer.toHexString(System.identityHashCode(this)));
			sb.append(" type ");
			sb.append(type);
			sb.append(" when ");
			sb.append(when);
			sb.append(" ");
			sb.append(" whenElapsed ");
			sb.append(whenElapsed);
			sb.append(" ");
			sb.append(sourcePackage);
			sb.append('}');
			return sb.toString();
			}

			/**
			* @deprecated Use {{@link #dump(IndentingPrintWriter, long, SimpleDateFormat)}} instead.
			*/
			@Deprecated
			public void dump(PrintWriter pw, String prefix, long nowELAPSED, SimpleDateFormat sdf) {
			final IndentingPrintWriter ipw = new IndentingPrintWriter(pw, prefix, prefix);
			dump(ipw, nowELAPSED, sdf);
			}

			public void dump(IndentingPrintWriter ipw, long nowELAPSED, SimpleDateFormat sdf) {
			final boolean isRtc = (type == RTC \|\| type == RTC_WAKEUP);
			ipw.print("tag=");
			ipw.println(statsTag);

			ipw.print("type=");
			ipw.print(type);
			ipw.print(" expectedWhenElapsed=");
			TimeUtils.formatDuration(expectedWhenElapsed, nowELAPSED, ipw);
			ipw.print(" expectedMaxWhenElapsed=");
			TimeUtils.formatDuration(expectedMaxWhenElapsed, nowELAPSED, ipw);
			ipw.print(" whenElapsed=");
			TimeUtils.formatDuration(whenElapsed, nowELAPSED, ipw);
			ipw.print(" maxWhenElapsed=");
			TimeUtils.formatDuration(maxWhenElapsed, nowELAPSED, ipw);
			ipw.print(" when=");
			if (isRtc) {
			ipw.print(sdf.format(new Date(when)));
			} else {
			TimeUtils.formatDuration(when, nowELAPSED, ipw);
			}
			ipw.println();

			ipw.print("window=");
			TimeUtils.formatDuration(windowLength, ipw);
			ipw.print(" repeatInterval=");
			ipw.print(repeatInterval);
			ipw.print(" count=");
			ipw.print(count);
			ipw.print(" flags=0x");
			ipw.println(Integer.toHexString(flags));

			if (alarmClock != null) {
			ipw.println("Alarm clock:");

			ipw.print(" triggerTime=");
			ipw.println(sdf.format(new Date(alarmClock.getTriggerTime())));

			ipw.print(" showIntent=");
			ipw.println(alarmClock.getShowIntent());
			}
			ipw.print("operation=");
			ipw.println(operation);

			if (listener != null) {
			ipw.print("listener=");
			ipw.println(listener.asBinder());
			}
			}

			public void dumpDebug(ProtoOutputStream proto, long fieldId, long nowElapsed) {
			final long token = proto.start(fieldId);

			proto.write(AlarmProto.TAG, statsTag);
			proto.write(AlarmProto.TYPE, type);
			proto.write(AlarmProto.TIME_UNTIL_WHEN_ELAPSED_MS, whenElapsed - nowElapsed);
			proto.write(AlarmProto.WINDOW_LENGTH_MS, windowLength);
			proto.write(AlarmProto.REPEAT_INTERVAL_MS, repeatInterval);
			proto.write(AlarmProto.COUNT, count);
			proto.write(AlarmProto.FLAGS, flags);
			if (alarmClock != null) {
			alarmClock.dumpDebug(proto, AlarmProto.ALARM_CLOCK);
			}
			if (operation != null) {
			operation.dumpDebug(proto, AlarmProto.OPERATION);
			}
			if (listener != null) {
			proto.write(AlarmProto.LISTENER, listener.asBinder().toString());
			}

			proto.end(token);
			}
			}

apex/jobscheduler/service/java/com/android/server/alarm/AlarmManagerService.java

+515 −1065

File changed.

Preview size limit exceeded, changes collapsed.

apex/jobscheduler/service/java/com/android/server/alarm/AlarmStore.java

0 → 100644

+127 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2020 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.
			*/

			package com.android.server.alarm;

			import android.os.SystemClock;
			import android.util.IndentingPrintWriter;
			import android.util.proto.ProtoOutputStream;

			import java.io.FileDescriptor;
			import java.text.SimpleDateFormat;
			import java.util.ArrayList;
			import java.util.function.Predicate;

			/**
			* Used by {@link AlarmManagerService} to store alarms.
			* Besides basic add and remove operations, supports querying the next upcoming alarm times,
			* and all the alarms that are due at a given time.
			*/
			public interface AlarmStore {

			/**
			* Adds the given alarm.
			*
			* @param a The alarm to add.
			*/
			void add(Alarm a);

			/**
			* Removes alarms that pass the given predicate.
			*
			* @param whichAlarms The predicate describing the alarms to remove.
			* @return a list containing alarms that were removed.
			*/
			ArrayList<Alarm> remove(Predicate<Alarm> whichAlarms);

			/**
			* Returns the total number of alarms in this store.
			*/
			int size();

			/**
			* Get the next wakeup delivery time of all alarms in this store.
			*
			* @return a long timestamp in the {@link SystemClock#elapsedRealtime() elapsed}
			* timebase.
			*/
			long getNextWakeupDeliveryTime();

			/**
			* Get the next delivery time of all alarms in this store.
			*
			* @return a long timestamp in the {@link SystemClock#elapsedRealtime() elapsed}
			* timebase. May or may not be the same as {{@link #getNextWakeupDeliveryTime()}}.
			*/
			long getNextDeliveryTime();

			/**
			* Removes all alarms that are pending delivery at the given time.
			*
			* @param nowElapsed The time at which delivery eligibility is evaluated.
			* @return The list of alarms pending at the given time.
			*/
			ArrayList<Alarm> removePendingAlarms(long nowElapsed);

			/**
			* Adjusts alarm deliveries for all alarms according to the passed
			* {@link AlarmDeliveryCalculator}
			*
			* @return {@code true} if any of the alarm deliveries changed due to this call.
			*/
			boolean recalculateAlarmDeliveries(AlarmDeliveryCalculator deliveryCalculator);

			/**
			* Returns all the alarms in the form of a list.
			*/
			ArrayList<Alarm> asList();

			/**
			* Dumps the state of this alarm store into the passed print writer. Also accepts the current
			* timestamp and a {@link SimpleDateFormat} to format the timestamps as human readable delta
			* from the current time.
			*
			* Primary useful for debugging. Can be called from the
			* {@link android.os.Binder#dump(FileDescriptor PrintWriter, String[]) dump} method of the
			* caller.
			* @param ipw The {@link IndentingPrintWriter} to write to.
			* @param nowElapsed the time when the dump is requested in the
			* {@link SystemClock#elapsedRealtime()
			* elapsed} timebase.
			* @param sdf the date format to print timestamps in.
			*/
			void dump(IndentingPrintWriter ipw, long nowElapsed, SimpleDateFormat sdf);

			/**
			* Dump the state of this alarm store as a proto buffer to the given stream.
			*/
			void dumpProto(ProtoOutputStream pos, long nowElapsed);

			/**
			* A functional interface used to update the alarm. Used to describe the update in
			* {@link #recalculateAlarmDeliveries(AlarmDeliveryCalculator)}
			*/
			@FunctionalInterface
			interface AlarmDeliveryCalculator {
			/**
			* Updates the given alarm's delivery time.
			*
			* @param a the alarm to update.
			* @return {@code true} if any change was made, {@code false} otherwise.
			*/
			boolean updateAlarmDelivery(Alarm a);
			}
			}

apex/jobscheduler/service/java/com/android/server/alarm/BatchingAlarmStore.java

0 → 100644

+379 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2020 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.
			*/

			package com.android.server.alarm;

			import static com.android.server.alarm.AlarmManagerService.DEBUG_BATCH;
			import static com.android.server.alarm.AlarmManagerService.TAG;
			import static com.android.server.alarm.AlarmManagerService.clampPositive;
			import static com.android.server.alarm.AlarmManagerService.dumpAlarmList;
			import static com.android.server.alarm.AlarmManagerService.isTimeTickAlarm;

			import android.app.AlarmManager;
			import android.util.IndentingPrintWriter;
			import android.util.Slog;
			import android.util.proto.ProtoOutputStream;

			import com.android.internal.util.StatLogger;

			import java.text.SimpleDateFormat;
			import java.util.ArrayList;
			import java.util.Collections;
			import java.util.Comparator;
			import java.util.function.Predicate;

			/**
			* Batching implementation of an Alarm Store.
			* This keeps the alarms in batches, which are sorted on the start time of their delivery window.
			*/
			public class BatchingAlarmStore implements AlarmStore {

			private ArrayList<Batch> mAlarmBatches = new ArrayList<>();
			private int mSize;
			private AlarmClockRemovalListener mAlarmClockRemovalListener;

			interface Stats {
			int REBATCH_ALL_ALARMS = 1;
			}

			final StatLogger mStatLogger = new StatLogger("Alarm store stats", new String[]{
			"REBATCH_ALL_ALARMS",
			});

			private static final Comparator<Batch> sBatchOrder = (b1, b2) -> {
			long when1 = b1.mStart;
			long when2 = b2.mStart;
			if (when1 > when2) {
			return 1;
			}
			if (when1 < when2) {
			return -1;
			}
			return 0;
			};

			private static final Comparator<Alarm> sIncreasingTimeOrder = (a1, a2) -> {
			long when1 = a1.whenElapsed;
			long when2 = a2.whenElapsed;
			if (when1 > when2) {
			return 1;
			}
			if (when1 < when2) {
			return -1;
			}
			return 0;
			};

			BatchingAlarmStore(AlarmClockRemovalListener listener) {
			mAlarmClockRemovalListener = listener;
			}

			@Override
			public void add(Alarm a) {
			insertAndBatchAlarm(a);
			mSize++;
			}

			@Override
			public ArrayList<Alarm> remove(Predicate<Alarm> whichAlarms) {
			final ArrayList<Alarm> removed = new ArrayList<>();
			for (int i = mAlarmBatches.size() - 1; i >= 0; i--) {
			final Batch b = mAlarmBatches.get(i);
			removed.addAll(b.remove(whichAlarms));
			if (b.size() == 0) {
			mAlarmBatches.remove(i);
			}
			}
			if (!removed.isEmpty()) {
			mSize -= removed.size();
			rebatchAllAlarms();
			}
			return removed;
			}

			private void rebatchAllAlarms() {
			final long start = mStatLogger.getTime();
			final ArrayList<Batch> oldBatches = (ArrayList<Batch>) mAlarmBatches.clone();
			mAlarmBatches.clear();
			for (final Batch batch : oldBatches) {
			for (int i = 0; i < batch.size(); i++) {
			insertAndBatchAlarm(batch.get(i));
			}
			}
			mStatLogger.logDurationStat(Stats.REBATCH_ALL_ALARMS, start);
			}

			@Override
			public int size() {
			return mSize;
			}

			@Override
			public long getNextWakeupDeliveryTime() {
			for (Batch b : mAlarmBatches) {
			if (b.hasWakeups()) {
			return b.mStart;
			}
			}
			return 0;
			}

			@Override
			public long getNextDeliveryTime() {
			if (mAlarmBatches.size() > 0) {
			return mAlarmBatches.get(0).mStart;
			}
			return 0;
			}

			@Override
			public ArrayList<Alarm> removePendingAlarms(long nowElapsed) {
			final ArrayList<Alarm> removedAlarms = new ArrayList<>();
			while (mAlarmBatches.size() > 0) {
			final Batch batch = mAlarmBatches.get(0);
			if (batch.mStart > nowElapsed) {
			break;
			}
			mAlarmBatches.remove(0);
			for (int i = 0; i < batch.size(); i++) {
			removedAlarms.add(batch.get(i));
			}
			}
			mSize -= removedAlarms.size();
			return removedAlarms;
			}

			@Override
			public boolean recalculateAlarmDeliveries(AlarmDeliveryCalculator deliveryCalculator) {
			boolean changed = false;
			for (final Batch b : mAlarmBatches) {
			for (int i = 0; i < b.size(); i++) {
			changed \|= deliveryCalculator.updateAlarmDelivery(b.get(i));
			}
			}
			if (changed) {
			rebatchAllAlarms();
			}
			return changed;
			}

			@Override
			public ArrayList<Alarm> asList() {
			final ArrayList<Alarm> allAlarms = new ArrayList<>();
			for (final Batch batch : mAlarmBatches) {
			for (int i = 0; i < batch.size(); i++) {
			allAlarms.add(batch.get(i));
			}
			}
			return allAlarms;
			}

			@Override
			public void dump(IndentingPrintWriter ipw, long nowElapsed, SimpleDateFormat sdf) {
			ipw.print("Pending alarm batches: ");
			ipw.println(mAlarmBatches.size());
			for (Batch b : mAlarmBatches) {
			ipw.print(b);
			ipw.println(':');
			ipw.increaseIndent();
			dumpAlarmList(ipw, b.mAlarms, nowElapsed, sdf);
			ipw.decreaseIndent();
			}
			mStatLogger.dump(ipw);
			}

			@Override
			public void dumpProto(ProtoOutputStream pos, long nowElapsed) {
			for (Batch b : mAlarmBatches) {
			b.dumpDebug(pos, AlarmManagerServiceDumpProto.PENDING_ALARM_BATCHES, nowElapsed);
			}
			}

			private void insertAndBatchAlarm(Alarm alarm) {
			final int whichBatch = ((alarm.flags & AlarmManager.FLAG_STANDALONE) != 0) ? -1
			: attemptCoalesce(alarm.whenElapsed, alarm.maxWhenElapsed);

			if (whichBatch < 0) {
			addBatch(mAlarmBatches, new Batch(alarm));
			} else {
			final Batch batch = mAlarmBatches.get(whichBatch);
			if (batch.add(alarm)) {
			// The start time of this batch advanced, so batch ordering may
			// have just been broken. Move it to where it now belongs.
			mAlarmBatches.remove(whichBatch);
			addBatch(mAlarmBatches, batch);
			}
			}
			}

			static void addBatch(ArrayList<Batch> list, Batch newBatch) {
			int index = Collections.binarySearch(list, newBatch, sBatchOrder);
			if (index < 0) {
			index = 0 - index - 1;
			}
			list.add(index, newBatch);
			}

			// Return the index of the matching batch, or -1 if none found.
			private int attemptCoalesce(long whenElapsed, long maxWhen) {
			final int n = mAlarmBatches.size();
			for (int i = 0; i < n; i++) {
			Batch b = mAlarmBatches.get(i);
			if ((b.mFlags & AlarmManager.FLAG_STANDALONE) == 0 && b.canHold(whenElapsed, maxWhen)) {
			return i;
			}
			}
			return -1;
			}

			final class Batch {
			long mStart; // These endpoints are always in ELAPSED
			long mEnd;
			int mFlags; // Flags for alarms, such as FLAG_STANDALONE.

			final ArrayList<Alarm> mAlarms = new ArrayList<>();

			Batch(Alarm seed) {
			mStart = seed.whenElapsed;
			mEnd = clampPositive(seed.maxWhenElapsed);
			mFlags = seed.flags;
			mAlarms.add(seed);
			}

			int size() {
			return mAlarms.size();
			}

			Alarm get(int index) {
			return mAlarms.get(index);
			}

			boolean canHold(long whenElapsed, long maxWhen) {
			return (mEnd >= whenElapsed) && (mStart <= maxWhen);
			}

			boolean add(Alarm alarm) {
			boolean newStart = false;
			// narrows the batch if necessary; presumes that canHold(alarm) is true
			int index = Collections.binarySearch(mAlarms, alarm, sIncreasingTimeOrder);
			if (index < 0) {
			index = 0 - index - 1;
			}
			mAlarms.add(index, alarm);
			if (DEBUG_BATCH) {
			Slog.v(TAG, "Adding " + alarm + " to " + this);
			}
			if (alarm.whenElapsed > mStart) {
			mStart = alarm.whenElapsed;
			newStart = true;
			}
			if (alarm.maxWhenElapsed < mEnd) {
			mEnd = alarm.maxWhenElapsed;
			}
			mFlags \|= alarm.flags;

			if (DEBUG_BATCH) {
			Slog.v(TAG, " => now " + this);
			}
			return newStart;
			}

			ArrayList<Alarm> remove(Predicate<Alarm> predicate) {
			final ArrayList<Alarm> removed = new ArrayList<>();
			long newStart = 0; // recalculate endpoints as we go
			long newEnd = Long.MAX_VALUE;
			int newFlags = 0;
			for (int i = 0; i < mAlarms.size(); ) {
			Alarm alarm = mAlarms.get(i);
			if (predicate.test(alarm)) {
			removed.add(mAlarms.remove(i));
			if (alarm.alarmClock != null && mAlarmClockRemovalListener != null) {
			mAlarmClockRemovalListener.onRemoved();
			}
			if (isTimeTickAlarm(alarm)) {
			// This code path is not invoked when delivering alarms, only when removing
			// alarms due to the caller cancelling it or getting uninstalled, etc.
			Slog.wtf(TAG, "Removed TIME_TICK alarm");
			}
			} else {
			if (alarm.whenElapsed > newStart) {
			newStart = alarm.whenElapsed;
			}
			if (alarm.maxWhenElapsed < newEnd) {
			newEnd = alarm.maxWhenElapsed;
			}
			newFlags \|= alarm.flags;
			i++;
			}
			}
			if (!removed.isEmpty()) {
			// commit the new batch bounds
			mStart = newStart;
			mEnd = newEnd;
			mFlags = newFlags;
			}
			return removed;
			}

			boolean hasWakeups() {
			final int n = mAlarms.size();
			for (int i = 0; i < n; i++) {
			Alarm a = mAlarms.get(i);
			if (a.wakeup) {
			return true;
			}
			}
			return false;
			}

			@Override
			public String toString() {
			StringBuilder b = new StringBuilder(40);
			b.append("Batch{");
			b.append(Integer.toHexString(this.hashCode()));
			b.append(" num=");
			b.append(size());
			b.append(" start=");
			b.append(mStart);
			b.append(" end=");
			b.append(mEnd);
			if (mFlags != 0) {
			b.append(" flgs=0x");
			b.append(Integer.toHexString(mFlags));
			}
			b.append('}');
			return b.toString();
			}

			public void dumpDebug(ProtoOutputStream proto, long fieldId, long nowElapsed) {
			final long token = proto.start(fieldId);

			proto.write(BatchProto.START_REALTIME, mStart);
			proto.write(BatchProto.END_REALTIME, mEnd);
			proto.write(BatchProto.FLAGS, mFlags);
			for (Alarm a : mAlarms) {
			a.dumpDebug(proto, BatchProto.ALARMS, nowElapsed);
			}

			proto.end(token);
			}
			}

			@FunctionalInterface
			interface AlarmClockRemovalListener {
			void onRemoved();
			}
			}

core/java/com/android/internal/util/StatLogger.java

+12 −1

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	package com.android.internal.util;		package com.android.internal.util;

	import android.os.SystemClock;		import android.os.SystemClock;
			import android.text.TextUtils;
	import android.util.IndentingPrintWriter;		import android.util.IndentingPrintWriter;
	import android.util.Slog;		import android.util.Slog;
	import android.util.proto.ProtoOutputStream;		import android.util.proto.ProtoOutputStream;
	@@ -65,8 +66,14 @@ public class StatLogger {
	private long mNextTickTime = SystemClock.elapsedRealtime() + 1000;		private long mNextTickTime = SystemClock.elapsedRealtime() + 1000;

	private final String[] mLabels;		private final String[] mLabels;
			private final String mStatsTag;

	public StatLogger(String[] eventLabels) {		public StatLogger(String[] eventLabels) {
			this(null, eventLabels);
			}

			public StatLogger(String statsTag, String[] eventLabels) {
			mStatsTag = statsTag;
	SIZE = eventLabels.length;		SIZE = eventLabels.length;
	mCountStats = new int[SIZE];		mCountStats = new int[SIZE];
	mDurationStats = new long[SIZE];		mDurationStats = new long[SIZE];
	@@ -135,7 +142,11 @@ public class StatLogger {

	public void dump(IndentingPrintWriter pw) {		public void dump(IndentingPrintWriter pw) {
	synchronized (mLock) {		synchronized (mLock) {
			if (!TextUtils.isEmpty(mStatsTag)) {
			pw.println(mStatsTag + ":");
			} else {
	pw.println("Stats:");		pw.println("Stats:");
			}
	pw.increaseIndent();		pw.increaseIndent();
	for (int i = 0; i < SIZE; i++) {		for (int i = 0; i < SIZE; i++) {
	final int count = mCountStats[i];		final int count = mCountStats[i];