com/android/server/people/data/EventHistoryImpl.java - platform/prebuilts/fullsdk/sources/android-31 - Git at Google

 /*
  * 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.people.data;

 import android.annotation.MainThread;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.WorkerThread;
 import android.net.Uri;
 import android.os.FileUtils;
 import android.text.format.DateUtils;
 import android.util.ArrayMap;
 import android.util.Slog;
 import android.util.SparseArray;
 import android.util.proto.ProtoInputStream;

 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.server.people.PeopleEventIndexesProto;
 import com.android.server.people.PeopleEventsProto;
 import com.android.server.people.TypedPeopleEventIndexProto;

 import com.google.android.collect.Lists;

 import java.io.File;
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ScheduledExecutorService;


 class EventHistoryImpl implements EventHistory {

     private static final long MAX_EVENTS_AGE = 4L * DateUtils.HOUR_IN_MILLIS;
     private static final long PRUNE_OLD_EVENTS_DELAY = 15L * DateUtils.MINUTE_IN_MILLIS;

     private static final String EVENTS_DIR = "events";
     private static final String INDEXES_DIR = "indexes";

     private final Injector mInjector;
     private final ScheduledExecutorService mScheduledExecutorService;
     private final EventsProtoDiskReadWriter mEventsProtoDiskReadWriter;
     private final EventIndexesProtoDiskReadWriter mEventIndexesProtoDiskReadWriter;
     private final File mRootDir;

     // Event Type -> Event Index
     @GuardedBy("this")
     private final SparseArray<EventIndex> mEventIndexArray = new SparseArray<>();

     @GuardedBy("this")
     private final EventList mRecentEvents = new EventList();

     private long mLastPruneTime;

     EventHistoryImpl(@NonNull File rootDir,
             @NonNull ScheduledExecutorService scheduledExecutorService) {
         this(new Injector(), rootDir, scheduledExecutorService);
     }

     @VisibleForTesting
     EventHistoryImpl(@NonNull Injector injector, @NonNull File rootDir,
             @NonNull ScheduledExecutorService scheduledExecutorService) {
         mInjector = injector;
         mScheduledExecutorService = scheduledExecutorService;
         mLastPruneTime = injector.currentTimeMillis();

         mRootDir = rootDir;
         File eventsDir = new File(mRootDir, EVENTS_DIR);
         mEventsProtoDiskReadWriter = new EventsProtoDiskReadWriter(eventsDir,
                 mScheduledExecutorService);
         File indexesDir = new File(mRootDir, INDEXES_DIR);
         mEventIndexesProtoDiskReadWriter = new EventIndexesProtoDiskReadWriter(indexesDir,
                 scheduledExecutorService);
     }

     @WorkerThread
     @NonNull
     static Map<String, EventHistoryImpl> eventHistoriesImplFromDisk(File categoryDir,
             ScheduledExecutorService scheduledExecutorService) {
         return eventHistoriesImplFromDisk(new Injector(), categoryDir, scheduledExecutorService);
     }

     @VisibleForTesting
     @NonNull
     static Map<String, EventHistoryImpl> eventHistoriesImplFromDisk(Injector injector,
             File categoryDir, ScheduledExecutorService scheduledExecutorService) {
         Map<String, EventHistoryImpl> results = new ArrayMap<>();
         File[] keyDirs = categoryDir.listFiles(File::isDirectory);
         if (keyDirs == null) {
             return results;
         }
         for (File keyDir : keyDirs) {
             File[] dirContents = keyDir.listFiles(
                     (dir, name) -> EVENTS_DIR.equals(name) || INDEXES_DIR.equals(name));
             if (dirContents != null && dirContents.length == 2) {
                 EventHistoryImpl eventHistory = new EventHistoryImpl(injector, keyDir,
                         scheduledExecutorService);
                 eventHistory.loadFromDisk();
                 results.put(Uri.decode(keyDir.getName()), eventHistory);
             }
         }
         return results;
     }

     /**
      * Loads recent events and indexes from disk to memory in a background thread. This should be
      * called after the device powers on and the user has been unlocked.
      */
     @VisibleForTesting
     @MainThread
     synchronized void loadFromDisk() {
         mScheduledExecutorService.execute(() -> {
             synchronized (this) {
                 EventList diskEvents = mEventsProtoDiskReadWriter.loadRecentEventsFromDisk();
                 if (diskEvents != null) {
                     diskEvents.removeOldEvents(mInjector.currentTimeMillis() - MAX_EVENTS_AGE);
                     mRecentEvents.addAll(diskEvents.getAllEvents());
                 }

                 SparseArray<EventIndex> diskIndexes =
                         mEventIndexesProtoDiskReadWriter.loadIndexesFromDisk();
                 if (diskIndexes != null) {
                     for (int i = 0; i < diskIndexes.size(); i++) {
                         mEventIndexArray.put(diskIndexes.keyAt(i), diskIndexes.valueAt(i));
                     }
                 }
             }
         });
     }

     /**
      * Flushes events and indexes immediately. This should be called when device is powering off.
      */
     @MainThread
     synchronized void saveToDisk() {
         mEventsProtoDiskReadWriter.saveEventsImmediately(mRecentEvents);
         mEventIndexesProtoDiskReadWriter.saveIndexesImmediately(mEventIndexArray);
     }

     @Override
     @NonNull
     public synchronized EventIndex getEventIndex(@Event.EventType int eventType) {
         EventIndex eventIndex = mEventIndexArray.get(eventType);
         return eventIndex != null ? new EventIndex(eventIndex) : mInjector.createEventIndex();
     }

     @Override
     @NonNull
     public synchronized EventIndex getEventIndex(Set<Integer> eventTypes) {
         EventIndex combined = mInjector.createEventIndex();
         for (@Event.EventType int eventType : eventTypes) {
             EventIndex eventIndex = mEventIndexArray.get(eventType);
             if (eventIndex != null) {
                 combined = EventIndex.combine(combined, eventIndex);
             }
         }
         return combined;
     }

     @Override
     @NonNull
     public synchronized List<Event> queryEvents(Set<Integer> eventTypes, long startTime,
             long endTime) {
         return mRecentEvents.queryEvents(eventTypes, startTime, endTime);
     }

     synchronized void addEvent(Event event) {
         pruneOldEvents();
         addEventInMemory(event);
         mEventsProtoDiskReadWriter.scheduleEventsSave(mRecentEvents);
         mEventIndexesProtoDiskReadWriter.scheduleIndexesSave(mEventIndexArray);
     }

     synchronized void onDestroy() {
         mEventIndexArray.clear();
         mRecentEvents.clear();
         mEventsProtoDiskReadWriter.deleteRecentEventsFile();
         mEventIndexesProtoDiskReadWriter.deleteIndexesFile();
         FileUtils.deleteContentsAndDir(mRootDir);
     }

     /** Deletes the events data that exceeds the retention period. */
     synchronized void pruneOldEvents() {
         long currentTime = mInjector.currentTimeMillis();
         if (currentTime - mLastPruneTime > PRUNE_OLD_EVENTS_DELAY) {
             mRecentEvents.removeOldEvents(currentTime - MAX_EVENTS_AGE);
             mLastPruneTime = currentTime;
         }
     }

     private synchronized void addEventInMemory(Event event) {
         EventIndex eventIndex = mEventIndexArray.get(event.getType());
         if (eventIndex == null) {
             eventIndex = mInjector.createEventIndex();
             mEventIndexArray.put(event.getType(), eventIndex);
         }
         eventIndex.addEvent(event.getTimestamp());
         mRecentEvents.add(event);
     }

     @VisibleForTesting
     static class Injector {

         EventIndex createEventIndex() {
             return new EventIndex();
         }

         long currentTimeMillis() {
             return System.currentTimeMillis();
         }
     }

     /** Reads and writes {@link Event}s on disk. */
     private static class EventsProtoDiskReadWriter extends AbstractProtoDiskReadWriter<EventList> {

         private static final String TAG = EventsProtoDiskReadWriter.class.getSimpleName();

         private static final String RECENT_FILE = "recent";


         EventsProtoDiskReadWriter(@NonNull File rootDir,
                 @NonNull ScheduledExecutorService scheduledExecutorService) {
             super(rootDir, scheduledExecutorService);
             rootDir.mkdirs();
         }

         @Override
         ProtoStreamWriter<EventList> protoStreamWriter() {
             return (protoOutputStream, data) -> {
                 for (Event event : data.getAllEvents()) {
                     long token = protoOutputStream.start(PeopleEventsProto.EVENTS);
                     event.writeToProto(protoOutputStream);
                     protoOutputStream.end(token);
                 }
             };
         }

         @Override
         ProtoStreamReader<EventList> protoStreamReader() {
             return protoInputStream -> {
                 List<Event> results = Lists.newArrayList();
                 try {
                     while (protoInputStream.nextField() != ProtoInputStream.NO_MORE_FIELDS) {
                         if (protoInputStream.getFieldNumber() != (int) PeopleEventsProto.EVENTS) {
                             continue;
                         }
                         long token = protoInputStream.start(PeopleEventsProto.EVENTS);
                         Event event = Event.readFromProto(protoInputStream);
                         protoInputStream.end(token);
                         results.add(event);
                     }
                 } catch (IOException e) {
                     Slog.e(TAG, "Failed to read protobuf input stream.", e);
                 }
                 EventList eventList = new EventList();
                 eventList.addAll(results);
                 return eventList;
             };
         }

         @MainThread
         void scheduleEventsSave(EventList recentEvents) {
             scheduleSave(RECENT_FILE, recentEvents);
         }

         @MainThread
         void saveEventsImmediately(EventList recentEvents) {
             saveImmediately(RECENT_FILE, recentEvents);
         }

         /**
          * Loads recent events from disk. This should be called when device is powered on.
          */
         @WorkerThread
         @Nullable
         EventList loadRecentEventsFromDisk() {
             return read(RECENT_FILE);
         }

         @WorkerThread
         void deleteRecentEventsFile() {
             delete(RECENT_FILE);
         }
     }

     /** Reads and writes {@link EventIndex}s on disk. */
     private static class EventIndexesProtoDiskReadWriter extends
             AbstractProtoDiskReadWriter<SparseArray<EventIndex>> {

         private static final String TAG = EventIndexesProtoDiskReadWriter.class.getSimpleName();

         private static final String INDEXES_FILE = "index";

         EventIndexesProtoDiskReadWriter(@NonNull File rootDir,
                 @NonNull ScheduledExecutorService scheduledExecutorService) {
             super(rootDir, scheduledExecutorService);
             rootDir.mkdirs();
         }

         @Override
         ProtoStreamWriter<SparseArray<EventIndex>> protoStreamWriter() {
             return (protoOutputStream, data) -> {
                 for (int i = 0; i < data.size(); i++) {
                     @Event.EventType int eventType = data.keyAt(i);
                     EventIndex index = data.valueAt(i);
                     long token = protoOutputStream.start(PeopleEventIndexesProto.TYPED_INDEXES);
                     protoOutputStream.write(TypedPeopleEventIndexProto.EVENT_TYPE, eventType);
                     long indexToken = protoOutputStream.start(TypedPeopleEventIndexProto.INDEX);
                     index.writeToProto(protoOutputStream);
                     protoOutputStream.end(indexToken);
                     protoOutputStream.end(token);
                 }
             };
         }

         @Override
         ProtoStreamReader<SparseArray<EventIndex>> protoStreamReader() {
             return protoInputStream -> {
                 SparseArray<EventIndex> results = new SparseArray<>();
                 try {
                     while (protoInputStream.nextField() != ProtoInputStream.NO_MORE_FIELDS) {
                         if (protoInputStream.getFieldNumber()
                                 != (int) PeopleEventIndexesProto.TYPED_INDEXES) {
                             continue;
                         }
                         long token = protoInputStream.start(PeopleEventIndexesProto.TYPED_INDEXES);
                         @Event.EventType int eventType = 0;
                         EventIndex index = EventIndex.EMPTY;
                         while (protoInputStream.nextField() != ProtoInputStream.NO_MORE_FIELDS) {
                             switch (protoInputStream.getFieldNumber()) {
                                 case (int) TypedPeopleEventIndexProto.EVENT_TYPE:
                                     eventType = protoInputStream.readInt(
                                             TypedPeopleEventIndexProto.EVENT_TYPE);
                                     break;
                                 case (int) TypedPeopleEventIndexProto.INDEX:
                                     long indexToken = protoInputStream.start(
                                             TypedPeopleEventIndexProto.INDEX);
                                     index = EventIndex.readFromProto(protoInputStream);
                                     protoInputStream.end(indexToken);
                                     break;
                                 default:
                                     Slog.w(TAG, "Could not read undefined field: "
                                             + protoInputStream.getFieldNumber());
                             }
                         }
                         results.append(eventType, index);
                         protoInputStream.end(token);
                     }
                 } catch (IOException e) {
                     Slog.e(TAG, "Failed to read protobuf input stream.", e);
                 }
                 return results;
             };
         }

         @MainThread
         void scheduleIndexesSave(SparseArray<EventIndex> indexes) {
             scheduleSave(INDEXES_FILE, indexes);
         }

         @MainThread
         void saveIndexesImmediately(SparseArray<EventIndex> indexes) {
             saveImmediately(INDEXES_FILE, indexes);
         }

         @WorkerThread
         @Nullable
         SparseArray<EventIndex> loadIndexesFromDisk() {
             return read(INDEXES_FILE);
         }

         @WorkerThread
         void deleteIndexesFile() {
             delete(INDEXES_FILE);
         }
     }
 }
	/*
	* 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.people.data;

	import android.annotation.MainThread;
	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.annotation.WorkerThread;
	import android.net.Uri;
	import android.os.FileUtils;
	import android.text.format.DateUtils;
	import android.util.ArrayMap;
	import android.util.Slog;
	import android.util.SparseArray;
	import android.util.proto.ProtoInputStream;

	import com.android.internal.annotations.GuardedBy;
	import com.android.internal.annotations.VisibleForTesting;
	import com.android.server.people.PeopleEventIndexesProto;
	import com.android.server.people.PeopleEventsProto;
	import com.android.server.people.TypedPeopleEventIndexProto;

	import com.google.android.collect.Lists;

	import java.io.File;
	import java.io.IOException;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.ScheduledExecutorService;


	class EventHistoryImpl implements EventHistory {

	private static final long MAX_EVENTS_AGE = 4L * DateUtils.HOUR_IN_MILLIS;
	private static final long PRUNE_OLD_EVENTS_DELAY = 15L * DateUtils.MINUTE_IN_MILLIS;

	private static final String EVENTS_DIR = "events";
	private static final String INDEXES_DIR = "indexes";

	private final Injector mInjector;
	private final ScheduledExecutorService mScheduledExecutorService;
	private final EventsProtoDiskReadWriter mEventsProtoDiskReadWriter;
	private final EventIndexesProtoDiskReadWriter mEventIndexesProtoDiskReadWriter;
	private final File mRootDir;

	// Event Type -> Event Index
	@GuardedBy("this")
	private final SparseArray<EventIndex> mEventIndexArray = new SparseArray<>();

	@GuardedBy("this")
	private final EventList mRecentEvents = new EventList();

	private long mLastPruneTime;

	EventHistoryImpl(@NonNull File rootDir,
	@NonNull ScheduledExecutorService scheduledExecutorService) {
	this(new Injector(), rootDir, scheduledExecutorService);
	}

	@VisibleForTesting
	EventHistoryImpl(@NonNull Injector injector, @NonNull File rootDir,
	@NonNull ScheduledExecutorService scheduledExecutorService) {
	mInjector = injector;
	mScheduledExecutorService = scheduledExecutorService;
	mLastPruneTime = injector.currentTimeMillis();

	mRootDir = rootDir;
	File eventsDir = new File(mRootDir, EVENTS_DIR);
	mEventsProtoDiskReadWriter = new EventsProtoDiskReadWriter(eventsDir,
	mScheduledExecutorService);
	File indexesDir = new File(mRootDir, INDEXES_DIR);
	mEventIndexesProtoDiskReadWriter = new EventIndexesProtoDiskReadWriter(indexesDir,
	scheduledExecutorService);
	}

	@WorkerThread
	@NonNull
	static Map<String, EventHistoryImpl> eventHistoriesImplFromDisk(File categoryDir,
	ScheduledExecutorService scheduledExecutorService) {
	return eventHistoriesImplFromDisk(new Injector(), categoryDir, scheduledExecutorService);
	}

	@VisibleForTesting
	@NonNull
	static Map<String, EventHistoryImpl> eventHistoriesImplFromDisk(Injector injector,
	File categoryDir, ScheduledExecutorService scheduledExecutorService) {
	Map<String, EventHistoryImpl> results = new ArrayMap<>();
	File[] keyDirs = categoryDir.listFiles(File::isDirectory);
	if (keyDirs == null) {
	return results;
	}
	for (File keyDir : keyDirs) {
	File[] dirContents = keyDir.listFiles(
	(dir, name) -> EVENTS_DIR.equals(name) \|\| INDEXES_DIR.equals(name));
	if (dirContents != null && dirContents.length == 2) {
	EventHistoryImpl eventHistory = new EventHistoryImpl(injector, keyDir,
	scheduledExecutorService);
	eventHistory.loadFromDisk();
	results.put(Uri.decode(keyDir.getName()), eventHistory);
	}
	}
	return results;
	}

	/**
	* Loads recent events and indexes from disk to memory in a background thread. This should be
	* called after the device powers on and the user has been unlocked.
	*/
	@VisibleForTesting
	@MainThread
	synchronized void loadFromDisk() {
	mScheduledExecutorService.execute(() -> {
	synchronized (this) {
	EventList diskEvents = mEventsProtoDiskReadWriter.loadRecentEventsFromDisk();
	if (diskEvents != null) {
	diskEvents.removeOldEvents(mInjector.currentTimeMillis() - MAX_EVENTS_AGE);
	mRecentEvents.addAll(diskEvents.getAllEvents());
	}

	SparseArray<EventIndex> diskIndexes =
	mEventIndexesProtoDiskReadWriter.loadIndexesFromDisk();
	if (diskIndexes != null) {
	for (int i = 0; i < diskIndexes.size(); i++) {
	mEventIndexArray.put(diskIndexes.keyAt(i), diskIndexes.valueAt(i));
	}
	}
	}
	});
	}

	/**
	* Flushes events and indexes immediately. This should be called when device is powering off.
	*/
	@MainThread
	synchronized void saveToDisk() {
	mEventsProtoDiskReadWriter.saveEventsImmediately(mRecentEvents);
	mEventIndexesProtoDiskReadWriter.saveIndexesImmediately(mEventIndexArray);
	}

	@Override
	@NonNull
	public synchronized EventIndex getEventIndex(@Event.EventType int eventType) {
	EventIndex eventIndex = mEventIndexArray.get(eventType);
	return eventIndex != null ? new EventIndex(eventIndex) : mInjector.createEventIndex();
	}

	@Override
	@NonNull
	public synchronized EventIndex getEventIndex(Set<Integer> eventTypes) {
	EventIndex combined = mInjector.createEventIndex();
	for (@Event.EventType int eventType : eventTypes) {
	EventIndex eventIndex = mEventIndexArray.get(eventType);
	if (eventIndex != null) {
	combined = EventIndex.combine(combined, eventIndex);
	}
	}
	return combined;
	}

	@Override
	@NonNull
	public synchronized List<Event> queryEvents(Set<Integer> eventTypes, long startTime,
	long endTime) {
	return mRecentEvents.queryEvents(eventTypes, startTime, endTime);
	}

	synchronized void addEvent(Event event) {
	pruneOldEvents();
	addEventInMemory(event);
	mEventsProtoDiskReadWriter.scheduleEventsSave(mRecentEvents);
	mEventIndexesProtoDiskReadWriter.scheduleIndexesSave(mEventIndexArray);
	}

	synchronized void onDestroy() {
	mEventIndexArray.clear();
	mRecentEvents.clear();
	mEventsProtoDiskReadWriter.deleteRecentEventsFile();
	mEventIndexesProtoDiskReadWriter.deleteIndexesFile();
	FileUtils.deleteContentsAndDir(mRootDir);
	}

	/** Deletes the events data that exceeds the retention period. */
	synchronized void pruneOldEvents() {
	long currentTime = mInjector.currentTimeMillis();
	if (currentTime - mLastPruneTime > PRUNE_OLD_EVENTS_DELAY) {
	mRecentEvents.removeOldEvents(currentTime - MAX_EVENTS_AGE);
	mLastPruneTime = currentTime;
	}
	}

	private synchronized void addEventInMemory(Event event) {
	EventIndex eventIndex = mEventIndexArray.get(event.getType());
	if (eventIndex == null) {
	eventIndex = mInjector.createEventIndex();
	mEventIndexArray.put(event.getType(), eventIndex);
	}
	eventIndex.addEvent(event.getTimestamp());
	mRecentEvents.add(event);
	}

	@VisibleForTesting
	static class Injector {

	EventIndex createEventIndex() {
	return new EventIndex();
	}

	long currentTimeMillis() {
	return System.currentTimeMillis();
	}
	}

	/** Reads and writes {@link Event}s on disk. */
	private static class EventsProtoDiskReadWriter extends AbstractProtoDiskReadWriter<EventList> {

	private static final String TAG = EventsProtoDiskReadWriter.class.getSimpleName();

	private static final String RECENT_FILE = "recent";


	EventsProtoDiskReadWriter(@NonNull File rootDir,
	@NonNull ScheduledExecutorService scheduledExecutorService) {
	super(rootDir, scheduledExecutorService);
	rootDir.mkdirs();
	}

	@Override
	ProtoStreamWriter<EventList> protoStreamWriter() {
	return (protoOutputStream, data) -> {
	for (Event event : data.getAllEvents()) {
	long token = protoOutputStream.start(PeopleEventsProto.EVENTS);
	event.writeToProto(protoOutputStream);
	protoOutputStream.end(token);
	}
	};
	}

	@Override
	ProtoStreamReader<EventList> protoStreamReader() {
	return protoInputStream -> {
	List<Event> results = Lists.newArrayList();
	try {
	while (protoInputStream.nextField() != ProtoInputStream.NO_MORE_FIELDS) {
	if (protoInputStream.getFieldNumber() != (int) PeopleEventsProto.EVENTS) {
	continue;
	}
	long token = protoInputStream.start(PeopleEventsProto.EVENTS);
	Event event = Event.readFromProto(protoInputStream);
	protoInputStream.end(token);
	results.add(event);
	}
	} catch (IOException e) {
	Slog.e(TAG, "Failed to read protobuf input stream.", e);
	}
	EventList eventList = new EventList();
	eventList.addAll(results);
	return eventList;
	};
	}

	@MainThread
	void scheduleEventsSave(EventList recentEvents) {
	scheduleSave(RECENT_FILE, recentEvents);
	}

	@MainThread
	void saveEventsImmediately(EventList recentEvents) {
	saveImmediately(RECENT_FILE, recentEvents);
	}

	/**
	* Loads recent events from disk. This should be called when device is powered on.
	*/
	@WorkerThread
	@Nullable
	EventList loadRecentEventsFromDisk() {
	return read(RECENT_FILE);
	}

	@WorkerThread
	void deleteRecentEventsFile() {
	delete(RECENT_FILE);
	}
	}

	/** Reads and writes {@link EventIndex}s on disk. */
	private static class EventIndexesProtoDiskReadWriter extends
	AbstractProtoDiskReadWriter<SparseArray<EventIndex>> {

	private static final String TAG = EventIndexesProtoDiskReadWriter.class.getSimpleName();

	private static final String INDEXES_FILE = "index";

	EventIndexesProtoDiskReadWriter(@NonNull File rootDir,
	@NonNull ScheduledExecutorService scheduledExecutorService) {
	super(rootDir, scheduledExecutorService);
	rootDir.mkdirs();
	}

	@Override
	ProtoStreamWriter<SparseArray<EventIndex>> protoStreamWriter() {
	return (protoOutputStream, data) -> {
	for (int i = 0; i < data.size(); i++) {
	@Event.EventType int eventType = data.keyAt(i);
	EventIndex index = data.valueAt(i);
	long token = protoOutputStream.start(PeopleEventIndexesProto.TYPED_INDEXES);
	protoOutputStream.write(TypedPeopleEventIndexProto.EVENT_TYPE, eventType);
	long indexToken = protoOutputStream.start(TypedPeopleEventIndexProto.INDEX);
	index.writeToProto(protoOutputStream);
	protoOutputStream.end(indexToken);
	protoOutputStream.end(token);
	}
	};
	}

	@Override
	ProtoStreamReader<SparseArray<EventIndex>> protoStreamReader() {
	return protoInputStream -> {
	SparseArray<EventIndex> results = new SparseArray<>();
	try {
	while (protoInputStream.nextField() != ProtoInputStream.NO_MORE_FIELDS) {
	if (protoInputStream.getFieldNumber()
	!= (int) PeopleEventIndexesProto.TYPED_INDEXES) {
	continue;
	}
	long token = protoInputStream.start(PeopleEventIndexesProto.TYPED_INDEXES);
	@Event.EventType int eventType = 0;
	EventIndex index = EventIndex.EMPTY;
	while (protoInputStream.nextField() != ProtoInputStream.NO_MORE_FIELDS) {
	switch (protoInputStream.getFieldNumber()) {
	case (int) TypedPeopleEventIndexProto.EVENT_TYPE:
	eventType = protoInputStream.readInt(
	TypedPeopleEventIndexProto.EVENT_TYPE);
	break;
	case (int) TypedPeopleEventIndexProto.INDEX:
	long indexToken = protoInputStream.start(
	TypedPeopleEventIndexProto.INDEX);
	index = EventIndex.readFromProto(protoInputStream);
	protoInputStream.end(indexToken);
	break;
	default:
	Slog.w(TAG, "Could not read undefined field: "
	+ protoInputStream.getFieldNumber());
	}
	}
	results.append(eventType, index);
	protoInputStream.end(token);
	}
	} catch (IOException e) {
	Slog.e(TAG, "Failed to read protobuf input stream.", e);
	}
	return results;
	};
	}

	@MainThread
	void scheduleIndexesSave(SparseArray<EventIndex> indexes) {
	scheduleSave(INDEXES_FILE, indexes);
	}

	@MainThread
	void saveIndexesImmediately(SparseArray<EventIndex> indexes) {
	saveImmediately(INDEXES_FILE, indexes);
	}

	@WorkerThread
	@Nullable
	SparseArray<EventIndex> loadIndexesFromDisk() {
	return read(INDEXES_FILE);
	}

	@WorkerThread
	void deleteIndexesFile() {
	delete(INDEXES_FILE);
	}
	}
	}