com/android/server/display/AmbientBrightnessStatsTracker.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright 2018 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.display;

 import android.annotation.Nullable;
 import android.annotation.UserIdInt;
 import android.hardware.display.AmbientBrightnessDayStats;
 import android.os.SystemClock;
 import android.os.UserManager;
 import android.util.Slog;
 import android.util.Xml;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.FastXmlSerializer;

 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
 import org.xmlpull.v1.XmlSerializer;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
 import java.time.LocalDate;
 import java.time.format.DateTimeParseException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.Map;

 /**
  * Class that stores stats of ambient brightness regions as histogram.
  */
 public class AmbientBrightnessStatsTracker {

     private static final String TAG = "AmbientBrightnessStatsTracker";
     private static final boolean DEBUG = false;

     @VisibleForTesting
     static final float[] BUCKET_BOUNDARIES_FOR_NEW_STATS =
             {0, 0.1f, 0.3f, 1, 3, 10, 30, 100, 300, 1000, 3000, 10000};
     @VisibleForTesting
     static final int MAX_DAYS_TO_TRACK = 7;

     private final AmbientBrightnessStats mAmbientBrightnessStats;
     private final Timer mTimer;
     private final Injector mInjector;
     private final UserManager mUserManager;
     private float mCurrentAmbientBrightness;
     private @UserIdInt int mCurrentUserId;

     public AmbientBrightnessStatsTracker(UserManager userManager, @Nullable Injector injector) {
         mUserManager = userManager;
         if (injector != null) {
             mInjector = injector;
         } else {
             mInjector = new Injector();
         }
         mAmbientBrightnessStats = new AmbientBrightnessStats();
         mTimer = new Timer(() -> mInjector.elapsedRealtimeMillis());
         mCurrentAmbientBrightness = -1;
     }

     public synchronized void start() {
         mTimer.reset();
         mTimer.start();
     }

     public synchronized void stop() {
         if (mTimer.isRunning()) {
             mAmbientBrightnessStats.log(mCurrentUserId, mInjector.getLocalDate(),
                     mCurrentAmbientBrightness, mTimer.totalDurationSec());
         }
         mTimer.reset();
         mCurrentAmbientBrightness = -1;
     }

     public synchronized void add(@UserIdInt int userId, float newAmbientBrightness) {
         if (mTimer.isRunning()) {
             if (userId == mCurrentUserId) {
                 mAmbientBrightnessStats.log(mCurrentUserId, mInjector.getLocalDate(),
                         mCurrentAmbientBrightness, mTimer.totalDurationSec());
             } else {
                 if (DEBUG) {
                     Slog.v(TAG, "User switched since last sensor event.");
                 }
                 mCurrentUserId = userId;
             }
             mTimer.reset();
             mTimer.start();
             mCurrentAmbientBrightness = newAmbientBrightness;
         } else {
             if (DEBUG) {
                 Slog.e(TAG, "Timer not running while trying to add brightness stats.");
             }
         }
     }

     public synchronized void writeStats(OutputStream stream) throws IOException {
         mAmbientBrightnessStats.writeToXML(stream);
     }

     public synchronized void readStats(InputStream stream) throws IOException {
         mAmbientBrightnessStats.readFromXML(stream);
     }

     public synchronized ArrayList<AmbientBrightnessDayStats> getUserStats(int userId) {
         return mAmbientBrightnessStats.getUserStats(userId);
     }

     public synchronized void dump(PrintWriter pw) {
         pw.println("AmbientBrightnessStats:");
         pw.print(mAmbientBrightnessStats);
     }

     /**
      * AmbientBrightnessStats tracks ambient brightness stats across users over multiple days.
      * This class is not ThreadSafe.
      */
     class AmbientBrightnessStats {

         private static final String TAG_AMBIENT_BRIGHTNESS_STATS = "ambient-brightness-stats";
         private static final String TAG_AMBIENT_BRIGHTNESS_DAY_STATS =
                 "ambient-brightness-day-stats";
         private static final String ATTR_USER = "user";
         private static final String ATTR_LOCAL_DATE = "local-date";
         private static final String ATTR_BUCKET_BOUNDARIES = "bucket-boundaries";
         private static final String ATTR_BUCKET_STATS = "bucket-stats";

         private Map<Integer, Deque<AmbientBrightnessDayStats>> mStats;

         public AmbientBrightnessStats() {
             mStats = new HashMap<>();
         }

         public void log(@UserIdInt int userId, LocalDate localDate, float ambientBrightness,
                 float durationSec) {
             Deque<AmbientBrightnessDayStats> userStats = getOrCreateUserStats(mStats, userId);
             AmbientBrightnessDayStats dayStats = getOrCreateDayStats(userStats, localDate);
             dayStats.log(ambientBrightness, durationSec);
         }

         public ArrayList<AmbientBrightnessDayStats> getUserStats(@UserIdInt int userId) {
             if (mStats.containsKey(userId)) {
                 return new ArrayList<>(mStats.get(userId));
             } else {
                 return null;
             }
         }

         public void writeToXML(OutputStream stream) throws IOException {
             XmlSerializer out = new FastXmlSerializer();
             out.setOutput(stream, StandardCharsets.UTF_8.name());
             out.startDocument(null, true);
             out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);

             final LocalDate cutOffDate = mInjector.getLocalDate().minusDays(MAX_DAYS_TO_TRACK);
             out.startTag(null, TAG_AMBIENT_BRIGHTNESS_STATS);
             for (Map.Entry<Integer, Deque<AmbientBrightnessDayStats>> entry : mStats.entrySet()) {
                 for (AmbientBrightnessDayStats userDayStats : entry.getValue()) {
                     int userSerialNumber = mInjector.getUserSerialNumber(mUserManager,
                             entry.getKey());
                     if (userSerialNumber != -1 && userDayStats.getLocalDate().isAfter(cutOffDate)) {
                         out.startTag(null, TAG_AMBIENT_BRIGHTNESS_DAY_STATS);
                         out.attribute(null, ATTR_USER, Integer.toString(userSerialNumber));
                         out.attribute(null, ATTR_LOCAL_DATE,
                                 userDayStats.getLocalDate().toString());
                         StringBuilder bucketBoundariesValues = new StringBuilder();
                         StringBuilder timeSpentValues = new StringBuilder();
                         for (int i = 0; i < userDayStats.getBucketBoundaries().length; i++) {
                             if (i > 0) {
                                 bucketBoundariesValues.append(",");
                                 timeSpentValues.append(",");
                             }
                             bucketBoundariesValues.append(userDayStats.getBucketBoundaries()[i]);
                             timeSpentValues.append(userDayStats.getStats()[i]);
                         }
                         out.attribute(null, ATTR_BUCKET_BOUNDARIES,
                                 bucketBoundariesValues.toString());
                         out.attribute(null, ATTR_BUCKET_STATS, timeSpentValues.toString());
                         out.endTag(null, TAG_AMBIENT_BRIGHTNESS_DAY_STATS);
                     }
                 }
             }
             out.endTag(null, TAG_AMBIENT_BRIGHTNESS_STATS);
             out.endDocument();
             stream.flush();
         }

         public void readFromXML(InputStream stream) throws IOException {
             try {
                 Map<Integer, Deque<AmbientBrightnessDayStats>> parsedStats = new HashMap<>();
                 XmlPullParser parser = Xml.newPullParser();
                 parser.setInput(stream, StandardCharsets.UTF_8.name());

                 int type;
                 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
                         && type != XmlPullParser.START_TAG) {
                 }
                 String tag = parser.getName();
                 if (!TAG_AMBIENT_BRIGHTNESS_STATS.equals(tag)) {
                     throw new XmlPullParserException(
                             "Ambient brightness stats not found in tracker file " + tag);
                 }

                 final LocalDate cutOffDate = mInjector.getLocalDate().minusDays(MAX_DAYS_TO_TRACK);
                 parser.next();
                 int outerDepth = parser.getDepth();
                 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
                         && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
                     if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
                         continue;
                     }
                     tag = parser.getName();
                     if (TAG_AMBIENT_BRIGHTNESS_DAY_STATS.equals(tag)) {
                         String userSerialNumber = parser.getAttributeValue(null, ATTR_USER);
                         LocalDate localDate = LocalDate.parse(
                                 parser.getAttributeValue(null, ATTR_LOCAL_DATE));
                         String[] bucketBoundaries = parser.getAttributeValue(null,
                                 ATTR_BUCKET_BOUNDARIES).split(",");
                         String[] bucketStats = parser.getAttributeValue(null,
                                 ATTR_BUCKET_STATS).split(",");
                         if (bucketBoundaries.length != bucketStats.length
                                 || bucketBoundaries.length < 1) {
                             throw new IOException("Invalid brightness stats string.");
                         }
                         float[] parsedBucketBoundaries = new float[bucketBoundaries.length];
                         float[] parsedBucketStats = new float[bucketStats.length];
                         for (int i = 0; i < bucketBoundaries.length; i++) {
                             parsedBucketBoundaries[i] = Float.parseFloat(bucketBoundaries[i]);
                             parsedBucketStats[i] = Float.parseFloat(bucketStats[i]);
                         }
                         int userId = mInjector.getUserId(mUserManager,
                                 Integer.parseInt(userSerialNumber));
                         if (userId != -1 && localDate.isAfter(cutOffDate)) {
                             Deque<AmbientBrightnessDayStats> userStats = getOrCreateUserStats(
                                     parsedStats, userId);
                             userStats.offer(
                                     new AmbientBrightnessDayStats(localDate,
                                             parsedBucketBoundaries, parsedBucketStats));
                         }
                     }
                 }
                 mStats = parsedStats;
             } catch (NullPointerException | NumberFormatException | XmlPullParserException |
                     DateTimeParseException | IOException e) {
                 throw new IOException("Failed to parse brightness stats file.", e);
             }
         }

         @Override
         public String toString() {
             StringBuilder builder = new StringBuilder();
             for (Map.Entry<Integer, Deque<AmbientBrightnessDayStats>> entry : mStats.entrySet()) {
                 for (AmbientBrightnessDayStats dayStats : entry.getValue()) {
                     builder.append("  ");
                     builder.append(entry.getKey()).append(" ");
                     builder.append(dayStats).append("\n");
                 }
             }
             return builder.toString();
         }

         private Deque<AmbientBrightnessDayStats> getOrCreateUserStats(
                 Map<Integer, Deque<AmbientBrightnessDayStats>> stats, @UserIdInt int userId) {
             if (!stats.containsKey(userId)) {
                 stats.put(userId, new ArrayDeque<>());
             }
             return stats.get(userId);
         }

         private AmbientBrightnessDayStats getOrCreateDayStats(
                 Deque<AmbientBrightnessDayStats> userStats, LocalDate localDate) {
             AmbientBrightnessDayStats lastBrightnessStats = userStats.peekLast();
             if (lastBrightnessStats != null && lastBrightnessStats.getLocalDate().equals(
                     localDate)) {
                 return lastBrightnessStats;
             } else {
                 AmbientBrightnessDayStats dayStats = new AmbientBrightnessDayStats(localDate,
                         BUCKET_BOUNDARIES_FOR_NEW_STATS);
                 if (userStats.size() == MAX_DAYS_TO_TRACK) {
                     userStats.poll();
                 }
                 userStats.offer(dayStats);
                 return dayStats;
             }
         }
     }

     @VisibleForTesting
     interface Clock {
         long elapsedTimeMillis();
     }

     @VisibleForTesting
     static class Timer {

         private final Clock clock;
         private long startTimeMillis;
         private boolean started;

         public Timer(Clock clock) {
             this.clock = clock;
         }

         public void reset() {
             started = false;
         }

         public void start() {
             if (!started) {
                 startTimeMillis = clock.elapsedTimeMillis();
                 started = true;
             }
         }

         public boolean isRunning() {
             return started;
         }

         public float totalDurationSec() {
             if (started) {
                 return (float) ((clock.elapsedTimeMillis() - startTimeMillis) / 1000.0);
             }
             return 0;
         }
     }

     @VisibleForTesting
     static class Injector {
         public long elapsedRealtimeMillis() {
             return SystemClock.elapsedRealtime();
         }

         public int getUserSerialNumber(UserManager userManager, int userId) {
             return userManager.getUserSerialNumber(userId);
         }

         public int getUserId(UserManager userManager, int userSerialNumber) {
             return userManager.getUserHandle(userSerialNumber);
         }

         public LocalDate getLocalDate() {
             return LocalDate.now();
         }
     }
 }
	/*
	* Copyright 2018 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.display;

	import android.annotation.Nullable;
	import android.annotation.UserIdInt;
	import android.hardware.display.AmbientBrightnessDayStats;
	import android.os.SystemClock;
	import android.os.UserManager;
	import android.util.Slog;
	import android.util.Xml;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.util.FastXmlSerializer;

	import org.xmlpull.v1.XmlPullParser;
	import org.xmlpull.v1.XmlPullParserException;
	import org.xmlpull.v1.XmlSerializer;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.PrintWriter;
	import java.nio.charset.StandardCharsets;
	import java.time.LocalDate;
	import java.time.format.DateTimeParseException;
	import java.util.ArrayDeque;
	import java.util.ArrayList;
	import java.util.Deque;
	import java.util.HashMap;
	import java.util.Map;

	/**
	* Class that stores stats of ambient brightness regions as histogram.
	*/
	public class AmbientBrightnessStatsTracker {

	private static final String TAG = "AmbientBrightnessStatsTracker";
	private static final boolean DEBUG = false;

	@VisibleForTesting
	static final float[] BUCKET_BOUNDARIES_FOR_NEW_STATS =
	{0, 0.1f, 0.3f, 1, 3, 10, 30, 100, 300, 1000, 3000, 10000};
	@VisibleForTesting
	static final int MAX_DAYS_TO_TRACK = 7;

	private final AmbientBrightnessStats mAmbientBrightnessStats;
	private final Timer mTimer;
	private final Injector mInjector;
	private final UserManager mUserManager;
	private float mCurrentAmbientBrightness;
	private @UserIdInt int mCurrentUserId;

	public AmbientBrightnessStatsTracker(UserManager userManager, @Nullable Injector injector) {
	mUserManager = userManager;
	if (injector != null) {
	mInjector = injector;
	} else {
	mInjector = new Injector();
	}
	mAmbientBrightnessStats = new AmbientBrightnessStats();
	mTimer = new Timer(() -> mInjector.elapsedRealtimeMillis());
	mCurrentAmbientBrightness = -1;
	}

	public synchronized void start() {
	mTimer.reset();
	mTimer.start();
	}

	public synchronized void stop() {
	if (mTimer.isRunning()) {
	mAmbientBrightnessStats.log(mCurrentUserId, mInjector.getLocalDate(),
	mCurrentAmbientBrightness, mTimer.totalDurationSec());
	}
	mTimer.reset();
	mCurrentAmbientBrightness = -1;
	}

	public synchronized void add(@UserIdInt int userId, float newAmbientBrightness) {
	if (mTimer.isRunning()) {
	if (userId == mCurrentUserId) {
	mAmbientBrightnessStats.log(mCurrentUserId, mInjector.getLocalDate(),
	mCurrentAmbientBrightness, mTimer.totalDurationSec());
	} else {
	if (DEBUG) {
	Slog.v(TAG, "User switched since last sensor event.");
	}
	mCurrentUserId = userId;
	}
	mTimer.reset();
	mTimer.start();
	mCurrentAmbientBrightness = newAmbientBrightness;
	} else {
	if (DEBUG) {
	Slog.e(TAG, "Timer not running while trying to add brightness stats.");
	}
	}
	}

	public synchronized void writeStats(OutputStream stream) throws IOException {
	mAmbientBrightnessStats.writeToXML(stream);
	}

	public synchronized void readStats(InputStream stream) throws IOException {
	mAmbientBrightnessStats.readFromXML(stream);
	}

	public synchronized ArrayList<AmbientBrightnessDayStats> getUserStats(int userId) {
	return mAmbientBrightnessStats.getUserStats(userId);
	}

	public synchronized void dump(PrintWriter pw) {
	pw.println("AmbientBrightnessStats:");
	pw.print(mAmbientBrightnessStats);
	}

	/**
	* AmbientBrightnessStats tracks ambient brightness stats across users over multiple days.
	* This class is not ThreadSafe.
	*/
	class AmbientBrightnessStats {

	private static final String TAG_AMBIENT_BRIGHTNESS_STATS = "ambient-brightness-stats";
	private static final String TAG_AMBIENT_BRIGHTNESS_DAY_STATS =
	"ambient-brightness-day-stats";
	private static final String ATTR_USER = "user";
	private static final String ATTR_LOCAL_DATE = "local-date";
	private static final String ATTR_BUCKET_BOUNDARIES = "bucket-boundaries";
	private static final String ATTR_BUCKET_STATS = "bucket-stats";

	private Map<Integer, Deque<AmbientBrightnessDayStats>> mStats;

	public AmbientBrightnessStats() {
	mStats = new HashMap<>();
	}

	public void log(@UserIdInt int userId, LocalDate localDate, float ambientBrightness,
	float durationSec) {
	Deque<AmbientBrightnessDayStats> userStats = getOrCreateUserStats(mStats, userId);
	AmbientBrightnessDayStats dayStats = getOrCreateDayStats(userStats, localDate);
	dayStats.log(ambientBrightness, durationSec);
	}

	public ArrayList<AmbientBrightnessDayStats> getUserStats(@UserIdInt int userId) {
	if (mStats.containsKey(userId)) {
	return new ArrayList<>(mStats.get(userId));
	} else {
	return null;
	}
	}

	public void writeToXML(OutputStream stream) throws IOException {
	XmlSerializer out = new FastXmlSerializer();
	out.setOutput(stream, StandardCharsets.UTF_8.name());
	out.startDocument(null, true);
	out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);

	final LocalDate cutOffDate = mInjector.getLocalDate().minusDays(MAX_DAYS_TO_TRACK);
	out.startTag(null, TAG_AMBIENT_BRIGHTNESS_STATS);
	for (Map.Entry<Integer, Deque<AmbientBrightnessDayStats>> entry : mStats.entrySet()) {
	for (AmbientBrightnessDayStats userDayStats : entry.getValue()) {
	int userSerialNumber = mInjector.getUserSerialNumber(mUserManager,
	entry.getKey());
	if (userSerialNumber != -1 && userDayStats.getLocalDate().isAfter(cutOffDate)) {
	out.startTag(null, TAG_AMBIENT_BRIGHTNESS_DAY_STATS);
	out.attribute(null, ATTR_USER, Integer.toString(userSerialNumber));
	out.attribute(null, ATTR_LOCAL_DATE,
	userDayStats.getLocalDate().toString());
	StringBuilder bucketBoundariesValues = new StringBuilder();
	StringBuilder timeSpentValues = new StringBuilder();
	for (int i = 0; i < userDayStats.getBucketBoundaries().length; i++) {
	if (i > 0) {
	bucketBoundariesValues.append(",");
	timeSpentValues.append(",");
	}
	bucketBoundariesValues.append(userDayStats.getBucketBoundaries()[i]);
	timeSpentValues.append(userDayStats.getStats()[i]);
	}
	out.attribute(null, ATTR_BUCKET_BOUNDARIES,
	bucketBoundariesValues.toString());
	out.attribute(null, ATTR_BUCKET_STATS, timeSpentValues.toString());
	out.endTag(null, TAG_AMBIENT_BRIGHTNESS_DAY_STATS);
	}
	}
	}
	out.endTag(null, TAG_AMBIENT_BRIGHTNESS_STATS);
	out.endDocument();
	stream.flush();
	}

	public void readFromXML(InputStream stream) throws IOException {
	try {
	Map<Integer, Deque<AmbientBrightnessDayStats>> parsedStats = new HashMap<>();
	XmlPullParser parser = Xml.newPullParser();
	parser.setInput(stream, StandardCharsets.UTF_8.name());

	int type;
	while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
	&& type != XmlPullParser.START_TAG) {
	}
	String tag = parser.getName();
	if (!TAG_AMBIENT_BRIGHTNESS_STATS.equals(tag)) {
	throw new XmlPullParserException(
	"Ambient brightness stats not found in tracker file " + tag);
	}

	final LocalDate cutOffDate = mInjector.getLocalDate().minusDays(MAX_DAYS_TO_TRACK);
	parser.next();
	int outerDepth = parser.getDepth();
	while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
	&& (type != XmlPullParser.END_TAG \|\| parser.getDepth() > outerDepth)) {
	if (type == XmlPullParser.END_TAG \|\| type == XmlPullParser.TEXT) {
	continue;
	}
	tag = parser.getName();
	if (TAG_AMBIENT_BRIGHTNESS_DAY_STATS.equals(tag)) {
	String userSerialNumber = parser.getAttributeValue(null, ATTR_USER);
	LocalDate localDate = LocalDate.parse(
	parser.getAttributeValue(null, ATTR_LOCAL_DATE));
	String[] bucketBoundaries = parser.getAttributeValue(null,
	ATTR_BUCKET_BOUNDARIES).split(",");
	String[] bucketStats = parser.getAttributeValue(null,
	ATTR_BUCKET_STATS).split(",");
	if (bucketBoundaries.length != bucketStats.length
	\|\| bucketBoundaries.length < 1) {
	throw new IOException("Invalid brightness stats string.");
	}
	float[] parsedBucketBoundaries = new float[bucketBoundaries.length];
	float[] parsedBucketStats = new float[bucketStats.length];
	for (int i = 0; i < bucketBoundaries.length; i++) {
	parsedBucketBoundaries[i] = Float.parseFloat(bucketBoundaries[i]);
	parsedBucketStats[i] = Float.parseFloat(bucketStats[i]);
	}
	int userId = mInjector.getUserId(mUserManager,
	Integer.parseInt(userSerialNumber));
	if (userId != -1 && localDate.isAfter(cutOffDate)) {
	Deque<AmbientBrightnessDayStats> userStats = getOrCreateUserStats(
	parsedStats, userId);
	userStats.offer(
	new AmbientBrightnessDayStats(localDate,
	parsedBucketBoundaries, parsedBucketStats));
	}
	}
	}
	mStats = parsedStats;
	} catch (NullPointerException \| NumberFormatException \| XmlPullParserException \|
	DateTimeParseException \| IOException e) {
	throw new IOException("Failed to parse brightness stats file.", e);
	}
	}

	@Override
	public String toString() {
	StringBuilder builder = new StringBuilder();
	for (Map.Entry<Integer, Deque<AmbientBrightnessDayStats>> entry : mStats.entrySet()) {
	for (AmbientBrightnessDayStats dayStats : entry.getValue()) {
	builder.append(" ");
	builder.append(entry.getKey()).append(" ");
	builder.append(dayStats).append("\n");
	}
	}
	return builder.toString();
	}

	private Deque<AmbientBrightnessDayStats> getOrCreateUserStats(
	Map<Integer, Deque<AmbientBrightnessDayStats>> stats, @UserIdInt int userId) {
	if (!stats.containsKey(userId)) {
	stats.put(userId, new ArrayDeque<>());
	}
	return stats.get(userId);
	}

	private AmbientBrightnessDayStats getOrCreateDayStats(
	Deque<AmbientBrightnessDayStats> userStats, LocalDate localDate) {
	AmbientBrightnessDayStats lastBrightnessStats = userStats.peekLast();
	if (lastBrightnessStats != null && lastBrightnessStats.getLocalDate().equals(
	localDate)) {
	return lastBrightnessStats;
	} else {
	AmbientBrightnessDayStats dayStats = new AmbientBrightnessDayStats(localDate,
	BUCKET_BOUNDARIES_FOR_NEW_STATS);
	if (userStats.size() == MAX_DAYS_TO_TRACK) {
	userStats.poll();
	}
	userStats.offer(dayStats);
	return dayStats;
	}
	}
	}

	@VisibleForTesting
	interface Clock {
	long elapsedTimeMillis();
	}

	@VisibleForTesting
	static class Timer {

	private final Clock clock;
	private long startTimeMillis;
	private boolean started;

	public Timer(Clock clock) {
	this.clock = clock;
	}

	public void reset() {
	started = false;
	}

	public void start() {
	if (!started) {
	startTimeMillis = clock.elapsedTimeMillis();
	started = true;
	}
	}

	public boolean isRunning() {
	return started;
	}

	public float totalDurationSec() {
	if (started) {
	return (float) ((clock.elapsedTimeMillis() - startTimeMillis) / 1000.0);
	}
	return 0;
	}
	}

	@VisibleForTesting
	static class Injector {
	public long elapsedRealtimeMillis() {
	return SystemClock.elapsedRealtime();
	}

	public int getUserSerialNumber(UserManager userManager, int userId) {
	return userManager.getUserSerialNumber(userId);
	}

	public int getUserId(UserManager userManager, int userSerialNumber) {
	return userManager.getUserHandle(userSerialNumber);
	}

	public LocalDate getLocalDate() {
	return LocalDate.now();
	}
	}
	}