services/core/java/com/android/server/display/AmbientBrightnessStatsTracker.java

/*
 * 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();
        }
    }
}