/**
 * Copyright (C) 2014 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.usage;

import static android.app.usage.UsageEvents.Event.ACTIVITY_PAUSED;
import static android.app.usage.UsageEvents.Event.ACTIVITY_RESUMED;
import static android.app.usage.UsageEvents.Event.ACTIVITY_STOPPED;
import static android.app.usage.UsageEvents.Event.CONFIGURATION_CHANGE;
import static android.app.usage.UsageEvents.Event.CONTINUE_PREVIOUS_DAY;
import static android.app.usage.UsageEvents.Event.CONTINUING_FOREGROUND_SERVICE;
import static android.app.usage.UsageEvents.Event.DEVICE_SHUTDOWN;
import static android.app.usage.UsageEvents.Event.END_OF_DAY;
import static android.app.usage.UsageEvents.Event.FLUSH_TO_DISK;
import static android.app.usage.UsageEvents.Event.FOREGROUND_SERVICE_START;
import static android.app.usage.UsageEvents.Event.FOREGROUND_SERVICE_STOP;
import static android.app.usage.UsageEvents.Event.KEYGUARD_HIDDEN;
import static android.app.usage.UsageEvents.Event.KEYGUARD_SHOWN;
import static android.app.usage.UsageEvents.Event.LOCUS_ID_SET;
import static android.app.usage.UsageEvents.Event.NOTIFICATION_INTERRUPTION;
import static android.app.usage.UsageEvents.Event.ROLLOVER_FOREGROUND_SERVICE;
import static android.app.usage.UsageEvents.Event.SCREEN_INTERACTIVE;
import static android.app.usage.UsageEvents.Event.SCREEN_NON_INTERACTIVE;
import static android.app.usage.UsageEvents.Event.SHORTCUT_INVOCATION;
import static android.app.usage.UsageEvents.Event.STANDBY_BUCKET_CHANGED;
import static android.app.usage.UsageEvents.Event.SYSTEM_INTERACTION;

import android.app.usage.ConfigurationStats;
import android.app.usage.EventList;
import android.app.usage.EventStats;
import android.app.usage.UsageEvents.Event;
import android.app.usage.UsageStats;
import android.content.res.Configuration;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseIntArray;
import android.util.proto.ProtoInputStream;

import com.android.internal.annotations.VisibleForTesting;

import java.io.IOException;
import java.util.List;

public class IntervalStats {
    private static final String TAG = "IntervalStats";

    public static final int CURRENT_MAJOR_VERSION = 1;
    public static final int CURRENT_MINOR_VERSION = 1;
    public int majorVersion = CURRENT_MAJOR_VERSION;
    public int minorVersion = CURRENT_MINOR_VERSION;
    public long beginTime;
    public long endTime;
    public long lastTimeSaved;
    public final EventTracker interactiveTracker = new EventTracker();
    public final EventTracker nonInteractiveTracker = new EventTracker();
    public final EventTracker keyguardShownTracker = new EventTracker();
    public final EventTracker keyguardHiddenTracker = new EventTracker();
    public final ArrayMap<String, UsageStats> packageStats = new ArrayMap<>();
    /** @hide */
    public final SparseArray<UsageStats> packageStatsObfuscated = new SparseArray<>();
    public final ArrayMap<Configuration, ConfigurationStats> configurations = new ArrayMap<>();
    public Configuration activeConfiguration;
    public final EventList events = new EventList();

    // A string cache. This is important as when we're parsing XML files, we don't want to
    // keep hundreds of strings that have the same contents. We will read the string
    // and only keep it if it's not in the cache. The GC will take care of the
    // strings that had identical copies in the cache.
    public final ArraySet<String> mStringCache = new ArraySet<>();

    public static final class EventTracker {
        public long curStartTime;
        public long lastEventTime;
        public long duration;
        public int count;

        public void commitTime(long timeStamp) {
            if (curStartTime != 0) {
                duration += timeStamp - curStartTime;
                curStartTime = 0;
            }
        }

        public void update(long timeStamp) {
            if (curStartTime == 0) {
                // If we aren't already running, time to bump the count.
                count++;
            }
            commitTime(timeStamp);
            curStartTime = timeStamp;
            lastEventTime = timeStamp;
        }

        void addToEventStats(List<EventStats> out, int event, long beginTime, long endTime) {
            if (count != 0 || duration != 0) {
                EventStats ev = new EventStats();
                ev.mEventType = event;
                ev.mCount = count;
                ev.mTotalTime = duration;
                ev.mLastEventTime = lastEventTime;
                ev.mBeginTimeStamp = beginTime;
                ev.mEndTimeStamp = endTime;
                out.add(ev);
            }
        }

    }

    public IntervalStats() {
    }

    /**
     * Gets the UsageStats object for the given package, or creates one and adds it internally.
     */
    UsageStats getOrCreateUsageStats(String packageName) {
        UsageStats usageStats = packageStats.get(packageName);
        if (usageStats == null) {
            usageStats = new UsageStats();
            usageStats.mPackageName = getCachedStringRef(packageName);
            usageStats.mBeginTimeStamp = beginTime;
            usageStats.mEndTimeStamp = endTime;
            packageStats.put(usageStats.mPackageName, usageStats);
        }
        return usageStats;
    }

    /**
     * Gets the ConfigurationStats object for the given configuration, or creates one and adds it
     * internally.
     */
    ConfigurationStats getOrCreateConfigurationStats(Configuration config) {
        ConfigurationStats configStats = configurations.get(config);
        if (configStats == null) {
            configStats = new ConfigurationStats();
            configStats.mBeginTimeStamp = beginTime;
            configStats.mEndTimeStamp = endTime;
            configStats.mConfiguration = config;
            configurations.put(config, configStats);
        }
        return configStats;
    }

    /**
     * Builds a UsageEvents.Event, but does not add it internally.
     */
    Event buildEvent(String packageName, String className) {
        Event event = new Event();
        event.mPackage = getCachedStringRef(packageName);
        if (className != null) {
            event.mClass = getCachedStringRef(className);
        }
        return event;
    }

    /**
     * Builds a UsageEvents.Event from a proto, but does not add it internally.
     * Built here to take advantage of the cached String Refs
     */
    Event buildEvent(ProtoInputStream parser, List<String> stringPool)
            throws IOException {
        final Event event = new Event();
        while (true) {
            switch (parser.nextField()) {
                case (int) IntervalStatsProto.Event.PACKAGE:
                    event.mPackage = getCachedStringRef(
                            parser.readString(IntervalStatsProto.Event.PACKAGE));
                    break;
                case (int) IntervalStatsProto.Event.PACKAGE_INDEX:
                    event.mPackage = getCachedStringRef(stringPool.get(
                            parser.readInt(IntervalStatsProto.Event.PACKAGE_INDEX) - 1));
                    break;
                case (int) IntervalStatsProto.Event.CLASS:
                    event.mClass = getCachedStringRef(
                            parser.readString(IntervalStatsProto.Event.CLASS));
                    break;
                case (int) IntervalStatsProto.Event.CLASS_INDEX:
                    event.mClass = getCachedStringRef(stringPool.get(
                            parser.readInt(IntervalStatsProto.Event.CLASS_INDEX) - 1));
                    break;
                case (int) IntervalStatsProto.Event.TIME_MS:
                    event.mTimeStamp = beginTime + parser.readLong(
                            IntervalStatsProto.Event.TIME_MS);
                    break;
                case (int) IntervalStatsProto.Event.FLAGS:
                    event.mFlags = parser.readInt(IntervalStatsProto.Event.FLAGS);
                    break;
                case (int) IntervalStatsProto.Event.TYPE:
                    event.mEventType = parser.readInt(IntervalStatsProto.Event.TYPE);
                    break;
                case (int) IntervalStatsProto.Event.CONFIG:
                    event.mConfiguration = new Configuration();
                    event.mConfiguration.readFromProto(parser, IntervalStatsProto.Event.CONFIG);
                    break;
                case (int) IntervalStatsProto.Event.SHORTCUT_ID:
                    event.mShortcutId = parser.readString(
                            IntervalStatsProto.Event.SHORTCUT_ID).intern();
                    break;
                case (int) IntervalStatsProto.Event.STANDBY_BUCKET:
                    event.mBucketAndReason = parser.readInt(
                            IntervalStatsProto.Event.STANDBY_BUCKET);
                    break;
                case (int) IntervalStatsProto.Event.NOTIFICATION_CHANNEL:
                    event.mNotificationChannelId = parser.readString(
                            IntervalStatsProto.Event.NOTIFICATION_CHANNEL);
                    break;
                case (int) IntervalStatsProto.Event.NOTIFICATION_CHANNEL_INDEX:
                    event.mNotificationChannelId = getCachedStringRef(stringPool.get(
                            parser.readInt(IntervalStatsProto.Event.NOTIFICATION_CHANNEL_INDEX)
                                    - 1));
                    break;
                case (int) IntervalStatsProto.Event.INSTANCE_ID:
                    event.mInstanceId = parser.readInt(IntervalStatsProto.Event.INSTANCE_ID);
                    break;
                case (int) IntervalStatsProto.Event.TASK_ROOT_PACKAGE_INDEX:
                    event.mTaskRootPackage = getCachedStringRef(stringPool.get(
                            parser.readInt(IntervalStatsProto.Event.TASK_ROOT_PACKAGE_INDEX) - 1));
                    break;
                case (int) IntervalStatsProto.Event.TASK_ROOT_CLASS_INDEX:
                    event.mTaskRootClass = getCachedStringRef(stringPool.get(
                            parser.readInt(IntervalStatsProto.Event.TASK_ROOT_CLASS_INDEX) - 1));
                    break;
                case (int) IntervalStatsProto.Event.LOCUS_ID_INDEX:
                    event.mLocusId = getCachedStringRef(stringPool.get(
                            parser.readInt(IntervalStatsProto.Event.LOCUS_ID_INDEX) - 1));
                    break;
                case ProtoInputStream.NO_MORE_FIELDS:
                    // Handle default values for certain events types
                    switch (event.mEventType) {
                        case CONFIGURATION_CHANGE:
                            if (event.mConfiguration == null) {
                                event.mConfiguration = new Configuration();
                            }
                            break;
                        case SHORTCUT_INVOCATION:
                            if (event.mShortcutId == null) {
                                event.mShortcutId = "";
                            }
                            break;
                        case NOTIFICATION_INTERRUPTION:
                            if (event.mNotificationChannelId == null) {
                                event.mNotificationChannelId = "";
                            }
                            break;
                        case LOCUS_ID_SET:
                            if (event.mLocusId == null) {
                                event.mLocusId = "";
                            }
                            break;
                    }
                    return event;
            }
        }
    }

    private boolean isStatefulEvent(int eventType) {
        switch (eventType) {
            case ACTIVITY_RESUMED:
            case ACTIVITY_PAUSED:
            case ACTIVITY_STOPPED:
            case FOREGROUND_SERVICE_START:
            case FOREGROUND_SERVICE_STOP:
            case END_OF_DAY:
            case ROLLOVER_FOREGROUND_SERVICE:
            case CONTINUE_PREVIOUS_DAY:
            case CONTINUING_FOREGROUND_SERVICE:
            case DEVICE_SHUTDOWN:
                return true;
        }
        return false;
    }

    /**
     * Returns whether the event type is one caused by user visible
     * interaction. Excludes those that are internally generated.
     */
    private boolean isUserVisibleEvent(int eventType) {
        return eventType != SYSTEM_INTERACTION
                && eventType != STANDBY_BUCKET_CHANGED;
    }

    /**
     * Update the IntervalStats by a activity or foreground service event.
     * @param packageName package name of this event. Is null if event targets to all packages.
     * @param className class name of a activity or foreground service, could be null to if this
     *                  is sent to all activities/services in this package.
     * @param timeStamp Epoch timestamp in milliseconds.
     * @param eventType event type as in {@link Event}
     * @param instanceId if className is an activity, the hashCode of ActivityRecord's appToken.
     *                 if className is not an activity, instanceId is not used.
     * @hide
     */
    @VisibleForTesting
    public void update(String packageName, String className, long timeStamp, int eventType,
            int instanceId) {
        if (eventType == DEVICE_SHUTDOWN
                || eventType == FLUSH_TO_DISK) {
            // DEVICE_SHUTDOWN and FLUSH_TO_DISK are sent to all packages.
            final int size = packageStats.size();
            for (int i = 0; i < size; i++) {
                UsageStats usageStats = packageStats.valueAt(i);
                usageStats.update(null, timeStamp, eventType, instanceId);
            }
        } else {
            UsageStats usageStats = getOrCreateUsageStats(packageName);
            usageStats.update(className, timeStamp, eventType, instanceId);
        }
        if (timeStamp > endTime) {
            endTime = timeStamp;
        }
    }

    /**
     * @hide
     */
    @VisibleForTesting
    public void addEvent(Event event) {
        // Cache common use strings
        event.mPackage = getCachedStringRef(event.mPackage);
        if (event.mClass != null) {
            event.mClass = getCachedStringRef(event.mClass);
        }
        if (event.mTaskRootPackage != null) {
            event.mTaskRootPackage = getCachedStringRef(event.mTaskRootPackage);
        }
        if (event.mTaskRootClass != null) {
            event.mTaskRootClass = getCachedStringRef(event.mTaskRootClass);
        }
        if (event.mEventType == NOTIFICATION_INTERRUPTION) {
            event.mNotificationChannelId = getCachedStringRef(event.mNotificationChannelId);
        }
        events.insert(event);
        if (event.mTimeStamp > endTime) {
            endTime = event.mTimeStamp;
        }
    }

    void updateChooserCounts(String packageName, String category, String action) {
        UsageStats usageStats = getOrCreateUsageStats(packageName);
        if (usageStats.mChooserCounts == null) {
            usageStats.mChooserCounts = new ArrayMap<>();
        }
        ArrayMap<String, Integer> chooserCounts;
        final int idx = usageStats.mChooserCounts.indexOfKey(action);
        if (idx < 0) {
            chooserCounts = new ArrayMap<>();
            usageStats.mChooserCounts.put(action, chooserCounts);
        } else {
            chooserCounts = usageStats.mChooserCounts.valueAt(idx);
        }
        int currentCount = chooserCounts.getOrDefault(category, 0);
        chooserCounts.put(category, currentCount + 1);
    }

    void updateConfigurationStats(Configuration config, long timeStamp) {
        if (activeConfiguration != null) {
            ConfigurationStats activeStats = configurations.get(activeConfiguration);
            activeStats.mTotalTimeActive += timeStamp - activeStats.mLastTimeActive;
            activeStats.mLastTimeActive = timeStamp - 1;
        }

        if (config != null) {
            ConfigurationStats configStats = getOrCreateConfigurationStats(config);
            configStats.mLastTimeActive = timeStamp;
            configStats.mActivationCount += 1;
            activeConfiguration = configStats.mConfiguration;
        }
        if (timeStamp > endTime) {
            endTime = timeStamp;
        }
    }

    void incrementAppLaunchCount(String packageName) {
        UsageStats usageStats = getOrCreateUsageStats(packageName);
        usageStats.mAppLaunchCount += 1;
    }

    void commitTime(long timeStamp) {
        interactiveTracker.commitTime(timeStamp);
        nonInteractiveTracker.commitTime(timeStamp);
        keyguardShownTracker.commitTime(timeStamp);
        keyguardHiddenTracker.commitTime(timeStamp);
    }

    void updateScreenInteractive(long timeStamp) {
        interactiveTracker.update(timeStamp);
        nonInteractiveTracker.commitTime(timeStamp);
    }

    void updateScreenNonInteractive(long timeStamp) {
        nonInteractiveTracker.update(timeStamp);
        interactiveTracker.commitTime(timeStamp);
    }

    void updateKeyguardShown(long timeStamp) {
        keyguardShownTracker.update(timeStamp);
        keyguardHiddenTracker.commitTime(timeStamp);
    }

    void updateKeyguardHidden(long timeStamp) {
        keyguardHiddenTracker.update(timeStamp);
        keyguardShownTracker.commitTime(timeStamp);
    }

    void addEventStatsTo(List<EventStats> out) {
        interactiveTracker.addToEventStats(out, SCREEN_INTERACTIVE,
                beginTime, endTime);
        nonInteractiveTracker.addToEventStats(out, SCREEN_NON_INTERACTIVE,
                beginTime, endTime);
        keyguardShownTracker.addToEventStats(out, KEYGUARD_SHOWN,
                beginTime, endTime);
        keyguardHiddenTracker.addToEventStats(out, KEYGUARD_HIDDEN,
                beginTime, endTime);
    }

    private String getCachedStringRef(String str) {
        final int index = mStringCache.indexOf(str);
        if (index < 0) {
            mStringCache.add(str);
            return str;
        }
        return mStringCache.valueAt(index);
    }

    /**
     * When an IntervalStats object is deserialized, if the object's version number
     * is lower than current version number, optionally perform a upgrade.
     */
    void upgradeIfNeeded() {
        // We only uprade on majorVersion change, no need to upgrade on minorVersion change.
        if (!(majorVersion < CURRENT_MAJOR_VERSION)) {
            return;
        }
        /*
          Optional upgrade code here.
        */
        majorVersion = CURRENT_MAJOR_VERSION;
    }

    /**
     * Parses all of the tokens to strings in the obfuscated usage stats data. This includes
     * deobfuscating each of the package tokens and chooser actions and categories.
     *
     * @return {@code true} if any stats were omitted while deobfuscating, {@code false} otherwise.
     */
    private boolean deobfuscateUsageStats(PackagesTokenData packagesTokenData) {
        boolean dataOmitted = false;
        final int usageStatsSize = packageStatsObfuscated.size();
        for (int statsIndex = 0; statsIndex < usageStatsSize; statsIndex++) {
            final int packageToken = packageStatsObfuscated.keyAt(statsIndex);
            final UsageStats usageStats = packageStatsObfuscated.valueAt(statsIndex);
            usageStats.mPackageName = packagesTokenData.getPackageString(packageToken);
            if (usageStats.mPackageName == null) {
                Slog.e(TAG, "Unable to parse usage stats package " + packageToken);
                dataOmitted = true;
                continue;
            }

            // Update chooser counts
            final int chooserActionsSize = usageStats.mChooserCountsObfuscated.size();
            for (int actionIndex = 0; actionIndex < chooserActionsSize; actionIndex++) {
                final ArrayMap<String, Integer> categoryCountsMap = new ArrayMap<>();
                final int actionToken = usageStats.mChooserCountsObfuscated.keyAt(actionIndex);
                final String action = packagesTokenData.getString(packageToken, actionToken);
                if (action == null) {
                    Slog.i(TAG, "Unable to parse chooser action " + actionToken
                            + " for package " + packageToken);
                    continue;
                }
                final SparseIntArray categoryCounts =
                        usageStats.mChooserCountsObfuscated.valueAt(actionIndex);
                final int categoriesSize = categoryCounts.size();
                for (int categoryIndex = 0; categoryIndex < categoriesSize; categoryIndex++) {
                    final int categoryToken = categoryCounts.keyAt(categoryIndex);
                    final String category = packagesTokenData.getString(packageToken,
                            categoryToken);
                    if (category == null) {
                        Slog.i(TAG, "Unable to parse chooser category " + categoryToken
                                + " for package " + packageToken);
                        continue;
                    }
                    categoryCountsMap.put(category, categoryCounts.valueAt(categoryIndex));
                }
                usageStats.mChooserCounts.put(action, categoryCountsMap);
            }
            packageStats.put(usageStats.mPackageName, usageStats);
        }
        return dataOmitted;
    }

    /**
     * Parses all of the tokens to strings in the obfuscated events data. This includes
     * deobfuscating the package token, along with any class, task root package/class tokens, and
     * shortcut or notification channel tokens.
     *
     * @return {@code true} if any events were omitted while deobfuscating, {@code false} otherwise.
     */
    private boolean deobfuscateEvents(PackagesTokenData packagesTokenData) {
        boolean dataOmitted = false;
        for (int i = this.events.size() - 1; i >= 0; i--) {
            final Event event = this.events.get(i);
            final int packageToken = event.mPackageToken;
            event.mPackage = packagesTokenData.getPackageString(packageToken);
            if (event.mPackage == null) {
                Slog.e(TAG, "Unable to parse event package " + packageToken);
                this.events.remove(i);
                dataOmitted = true;
                continue;
            }

            if (event.mClassToken != PackagesTokenData.UNASSIGNED_TOKEN) {
                event.mClass = packagesTokenData.getString(packageToken, event.mClassToken);
                if (event.mClass == null) {
                    Slog.i(TAG, "Unable to parse class " + event.mClassToken
                            + " for package " + packageToken);
                }
            }
            if (event.mTaskRootPackageToken != PackagesTokenData.UNASSIGNED_TOKEN) {
                event.mTaskRootPackage = packagesTokenData.getString(packageToken,
                        event.mTaskRootPackageToken);
                if (event.mTaskRootPackage == null) {
                    Slog.i(TAG, "Unable to parse task root package " + event.mTaskRootPackageToken
                            + " for package " + packageToken);
                }
            }
            if (event.mTaskRootClassToken != PackagesTokenData.UNASSIGNED_TOKEN) {
                event.mTaskRootClass = packagesTokenData.getString(packageToken,
                        event.mTaskRootClassToken);
                if (event.mTaskRootClass == null) {
                    Slog.i(TAG, "Unable to parse task root class " + event.mTaskRootClassToken
                            + " for package " + packageToken);
                }
            }
            switch (event.mEventType) {
                case CONFIGURATION_CHANGE:
                    if (event.mConfiguration == null) {
                        event.mConfiguration = new Configuration();
                    }
                    break;
                case SHORTCUT_INVOCATION:
                    event.mShortcutId = packagesTokenData.getString(packageToken,
                            event.mShortcutIdToken);
                    if (event.mShortcutId == null) {
                        Slog.e(TAG, "Unable to parse shortcut " + event.mShortcutIdToken
                                + " for package " + packageToken);
                        this.events.remove(i);
                        dataOmitted = true;
                        continue;
                    }
                    break;
                case NOTIFICATION_INTERRUPTION:
                    event.mNotificationChannelId = packagesTokenData.getString(packageToken,
                            event.mNotificationChannelIdToken);
                    if (event.mNotificationChannelId == null) {
                        Slog.e(TAG, "Unable to parse notification channel "
                                + event.mNotificationChannelIdToken + " for package "
                                + packageToken);
                        this.events.remove(i);
                        dataOmitted = true;
                        continue;
                    }
                    break;
                case LOCUS_ID_SET:
                    event.mLocusId = packagesTokenData.getString(packageToken, event.mLocusIdToken);
                    if (event.mLocusId == null) {
                        Slog.e(TAG, "Unable to parse locus " + event.mLocusIdToken
                                + " for package " + packageToken);
                        this.events.remove(i);
                        dataOmitted = true;
                        continue;
                    }
                    break;
            }
        }
        return dataOmitted;
    }

    /**
     * Parses the obfuscated tokenized data held in this interval stats object.
     *
     * @return {@code true} if any data was omitted while deobfuscating, {@code false} otherwise.
     * @hide
     */
    public boolean deobfuscateData(PackagesTokenData packagesTokenData) {
        final boolean statsOmitted = deobfuscateUsageStats(packagesTokenData);
        final boolean eventsOmitted = deobfuscateEvents(packagesTokenData);
        return statsOmitted || eventsOmitted;
    }

    /**
     * Obfuscates certain strings within each package stats such as the package name, and the
     * chooser actions and categories.
     */
    private void obfuscateUsageStatsData(PackagesTokenData packagesTokenData) {
        final int usageStatsSize = packageStats.size();
        for (int statsIndex = 0; statsIndex < usageStatsSize; statsIndex++) {
            final String packageName = packageStats.keyAt(statsIndex);
            final UsageStats usageStats = packageStats.valueAt(statsIndex);
            if (usageStats == null) {
                continue;
            }

            final int packageToken = packagesTokenData.getPackageTokenOrAdd(
                    packageName, usageStats.mEndTimeStamp);
            // don't obfuscate stats whose packages have been removed
            if (packageToken == PackagesTokenData.UNASSIGNED_TOKEN) {
                continue;
            }
            usageStats.mPackageToken = packageToken;
            // Update chooser counts.
            final int chooserActionsSize = usageStats.mChooserCounts.size();
            for (int actionIndex = 0; actionIndex < chooserActionsSize; actionIndex++) {
                final String action = usageStats.mChooserCounts.keyAt(actionIndex);
                final ArrayMap<String, Integer> categoriesMap =
                        usageStats.mChooserCounts.valueAt(actionIndex);
                if (categoriesMap == null) {
                    continue;
                }

                final SparseIntArray categoryCounts = new SparseIntArray();
                final int categoriesSize = categoriesMap.size();
                for (int categoryIndex = 0; categoryIndex < categoriesSize; categoryIndex++) {
                    String category = categoriesMap.keyAt(categoryIndex);
                    int categoryToken = packagesTokenData.getTokenOrAdd(packageToken, packageName,
                            category);
                    categoryCounts.put(categoryToken, categoriesMap.valueAt(categoryIndex));
                }
                int actionToken = packagesTokenData.getTokenOrAdd(packageToken, packageName,
                        action);
                usageStats.mChooserCountsObfuscated.put(actionToken, categoryCounts);
            }
            packageStatsObfuscated.put(packageToken, usageStats);
        }
    }

    /**
     * Obfuscates certain strings within an event such as the package name, the class name,
     * task root package and class names, and shortcut and notification channel ids.
     */
    private void obfuscateEventsData(PackagesTokenData packagesTokenData) {
        for (int i = events.size() - 1; i >= 0; i--) {
            final Event event = events.get(i);
            if (event == null) {
                continue;
            }

            final int packageToken = packagesTokenData.getPackageTokenOrAdd(
                    event.mPackage, event.mTimeStamp);
            // don't obfuscate events from packages that have been removed
            if (packageToken == PackagesTokenData.UNASSIGNED_TOKEN) {
                events.remove(i);
                continue;
            }
            event.mPackageToken = packageToken;
            if (!TextUtils.isEmpty(event.mClass)) {
                event.mClassToken = packagesTokenData.getTokenOrAdd(packageToken,
                        event.mPackage, event.mClass);
            }
            if (!TextUtils.isEmpty(event.mTaskRootPackage)) {
                event.mTaskRootPackageToken = packagesTokenData.getTokenOrAdd(packageToken,
                        event.mPackage, event.mTaskRootPackage);
            }
            if (!TextUtils.isEmpty(event.mTaskRootClass)) {
                event.mTaskRootClassToken = packagesTokenData.getTokenOrAdd(packageToken,
                        event.mPackage, event.mTaskRootClass);
            }
            switch (event.mEventType) {
                case SHORTCUT_INVOCATION:
                    if (!TextUtils.isEmpty(event.mShortcutId)) {
                        event.mShortcutIdToken = packagesTokenData.getTokenOrAdd(packageToken,
                                event.mPackage, event.mShortcutId);
                    }
                    break;
                case NOTIFICATION_INTERRUPTION:
                    if (!TextUtils.isEmpty(event.mNotificationChannelId)) {
                        event.mNotificationChannelIdToken = packagesTokenData.getTokenOrAdd(
                                packageToken, event.mPackage, event.mNotificationChannelId);
                    }
                    break;
                case LOCUS_ID_SET:
                    if (!TextUtils.isEmpty(event.mLocusId)) {
                        event.mLocusIdToken = packagesTokenData.getTokenOrAdd(packageToken,
                                event.mPackage, event.mLocusId);
                    }
                    break;
            }
        }
    }

    /**
     * Obfuscates the data in this instance of interval stats.
     *
     * @hide
     */
    public void obfuscateData(PackagesTokenData packagesTokenData) {
        obfuscateUsageStatsData(packagesTokenData);
        obfuscateEventsData(packagesTokenData);
    }
}