services/core/java/com/android/server/sensorprivacy/PersistedState.java - platform/frameworks/base - Git at Google

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

 import android.hardware.SensorPrivacyManager;
 import android.os.Environment;
 import android.os.UserHandle;
 import android.service.SensorPrivacyIndividualEnabledSensorProto;
 import android.service.SensorPrivacySensorProto;
 import android.service.SensorPrivacyServiceDumpProto;
 import android.service.SensorPrivacyUserProto;
 import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Log;
 import android.util.Pair;
 import android.util.SparseArray;
 import android.util.Xml;

 import com.android.internal.util.XmlUtils;
 import com.android.internal.util.dump.DualDumpOutputStream;
 import com.android.internal.util.function.QuadConsumer;
 import com.android.internal.util.function.pooled.PooledLambda;
 import com.android.modules.utils.TypedXmlPullParser;
 import com.android.modules.utils.TypedXmlSerializer;
 import com.android.server.IoThread;
 import com.android.server.LocalServices;
 import com.android.server.pm.UserManagerInternal;

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

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 /**
  * Class for managing persisted state. Synchronization must be handled by the caller.
  */
 class PersistedState {

     private static final String LOG_TAG = PersistedState.class.getSimpleName();

     /** Version number indicating compatibility parsing the persisted file */
     private static final int CURRENT_PERSISTENCE_VERSION = 2;
     /** Version number indicating the persisted data needs upgraded to match new internal data
      *  structures and features */
     private static final int CURRENT_VERSION = 2;

     private static final String XML_TAG_SENSOR_PRIVACY = "sensor-privacy";
     private static final String XML_TAG_SENSOR_STATE = "sensor-state";
     private static final String XML_ATTRIBUTE_PERSISTENCE_VERSION = "persistence-version";
     private static final String XML_ATTRIBUTE_VERSION = "version";
     private static final String XML_ATTRIBUTE_TOGGLE_TYPE = "toggle-type";
     private static final String XML_ATTRIBUTE_USER_ID = "user-id";
     private static final String XML_ATTRIBUTE_SENSOR = "sensor";
     private static final String XML_ATTRIBUTE_STATE_TYPE = "state-type";
     private static final String XML_ATTRIBUTE_LAST_CHANGE = "last-change";

     private final AtomicFile mAtomicFile;

     private ArrayMap<TypeUserSensor, SensorState> mStates = new ArrayMap<>();

     static PersistedState fromFile(String fileName) {
         return new PersistedState(fileName);
     }

     private PersistedState(String fileName) {
         mAtomicFile = new AtomicFile(new File(Environment.getDataSystemDirectory(), fileName));
         readState();
     }

     private void readState() {
         AtomicFile file = mAtomicFile;
         if (!file.exists()) {
             AtomicFile fileToMigrateFrom =
                     new AtomicFile(new File(Environment.getDataSystemDirectory(),
                             "sensor_privacy.xml"));

             if (fileToMigrateFrom.exists()) {
                 // Sample the start tag to determine if migration is needed
                 try (FileInputStream inputStream = fileToMigrateFrom.openRead()) {
                     TypedXmlPullParser parser = Xml.resolvePullParser(inputStream);
                     XmlUtils.beginDocument(parser, XML_TAG_SENSOR_PRIVACY);
                     file = fileToMigrateFrom;
                 } catch (IOException e) {
                     Log.e(LOG_TAG, "Caught an exception reading the state from storage: ", e);
                     // Delete the file to prevent the same error on subsequent calls and assume
                     // sensor privacy is not enabled.
                     fileToMigrateFrom.delete();
                 } catch (XmlPullParserException e) {
                     // No migration needed
                 }
             }
         }

         Object nonupgradedState = null;
         if (file.exists()) {
             try (FileInputStream inputStream = file.openRead()) {
                 TypedXmlPullParser parser = Xml.resolvePullParser(inputStream);
                 XmlUtils.beginDocument(parser, XML_TAG_SENSOR_PRIVACY);
                 final int persistenceVersion = parser.getAttributeInt(null,
                         XML_ATTRIBUTE_PERSISTENCE_VERSION, 0);

                 // Use inline string literals for xml tags/attrs when parsing old versions since
                 // these should never be changed even with refactorings.
                 if (persistenceVersion == 0) {
                     int version = 0;
                     PVersion0 version0 = new PVersion0(version);
                     nonupgradedState = version0;
                     readPVersion0(parser, version0);
                 } else if (persistenceVersion == 1) {
                     int version = parser.getAttributeInt(null,
                             "version", 1);
                     PVersion1 version1 = new PVersion1(version);
                     nonupgradedState = version1;

                     readPVersion1(parser, version1);
                 } else if (persistenceVersion == CURRENT_PERSISTENCE_VERSION) {
                     int version = parser.getAttributeInt(null,
                             XML_ATTRIBUTE_VERSION, 2);
                     PVersion2 version2 = new PVersion2(version);
                     nonupgradedState = version2;

                     readPVersion2(parser, version2);
                 } else {
                     Log.e(LOG_TAG, "Unknown persistence version: " + persistenceVersion
                                     + ". Deleting.",
                             new RuntimeException());
                     file.delete();
                     nonupgradedState = null;
                 }

             } catch (IOException | XmlPullParserException | RuntimeException e) {
                 Log.e(LOG_TAG, "Caught an exception reading the state from storage: ", e);
                 // Delete the file to prevent the same error on subsequent calls and assume
                 // sensor privacy is not enabled.
                 file.delete();
                 nonupgradedState = null;
             }
         }

         if (nonupgradedState == null) {
             // New file, default state for current version goes here.
             nonupgradedState = new PVersion2(2);
         }

         if (nonupgradedState instanceof PVersion0) {
             nonupgradedState = PVersion1.fromPVersion0((PVersion0) nonupgradedState);
         }
         if (nonupgradedState instanceof PVersion1) {
             nonupgradedState = PVersion2.fromPVersion1((PVersion1) nonupgradedState);
         }
         if (nonupgradedState instanceof PVersion2) {
             PVersion2 upgradedState = (PVersion2) nonupgradedState;
             mStates = upgradedState.mStates;
         } else {
             Log.e(LOG_TAG, "State not successfully upgraded.");
             mStates = new ArrayMap<>();
         }
     }

     private static void readPVersion0(TypedXmlPullParser parser, PVersion0 version0)
             throws XmlPullParserException, IOException {

         XmlUtils.nextElement(parser);
         while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
             if ("individual-sensor-privacy".equals(parser.getName())) {
                 int sensor = XmlUtils.readIntAttribute(parser, "sensor");
                 boolean indEnabled = XmlUtils.readBooleanAttribute(parser,
                         "enabled");
                 version0.addState(sensor, indEnabled);
                 XmlUtils.skipCurrentTag(parser);
             } else {
                 XmlUtils.nextElement(parser);
             }
         }
     }

     private static void readPVersion1(TypedXmlPullParser parser, PVersion1 version1)
             throws XmlPullParserException, IOException {
         while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
             XmlUtils.nextElement(parser);

             if ("user".equals(parser.getName())) {
                 int currentUserId = parser.getAttributeInt(null, "id");
                 int depth = parser.getDepth();
                 while (XmlUtils.nextElementWithin(parser, depth)) {
                     if ("individual-sensor-privacy".equals(parser.getName())) {
                         int sensor = parser.getAttributeInt(null, "sensor");
                         boolean isEnabled = parser.getAttributeBoolean(null,
                                 "enabled");
                         version1.addState(currentUserId, sensor, isEnabled);
                     }
                 }
             }
         }
     }

     private static void readPVersion2(TypedXmlPullParser parser, PVersion2 version2)
             throws XmlPullParserException, IOException {

         while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
             XmlUtils.nextElement(parser);

             if (XML_TAG_SENSOR_STATE.equals(parser.getName())) {
                 int toggleType = parser.getAttributeInt(null, XML_ATTRIBUTE_TOGGLE_TYPE);
                 int userId = parser.getAttributeInt(null, XML_ATTRIBUTE_USER_ID);
                 int sensor = parser.getAttributeInt(null, XML_ATTRIBUTE_SENSOR);
                 int state = parser.getAttributeInt(null, XML_ATTRIBUTE_STATE_TYPE);
                 long lastChange = parser.getAttributeLong(null, XML_ATTRIBUTE_LAST_CHANGE);

                 version2.addState(toggleType, userId, sensor, state, lastChange);
             } else {
                 XmlUtils.skipCurrentTag(parser);
             }
         }
     }

     public SensorState getState(int toggleType, int userId, int sensor) {
         return mStates.get(new TypeUserSensor(toggleType, userId, sensor));
     }

     public SensorState setState(int toggleType, int userId, int sensor, SensorState sensorState) {
         return mStates.put(new TypeUserSensor(toggleType, userId, sensor), sensorState);
     }

     private static class TypeUserSensor {

         int mType;
         int mUserId;
         int mSensor;

         TypeUserSensor(int type, int userId, int sensor) {
             mType = type;
             mUserId = userId;
             mSensor = sensor;
         }

         TypeUserSensor(TypeUserSensor typeUserSensor) {
             this(typeUserSensor.mType, typeUserSensor.mUserId, typeUserSensor.mSensor);
         }

         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (!(o instanceof TypeUserSensor)) return false;
             TypeUserSensor that = (TypeUserSensor) o;
             return mType == that.mType && mUserId == that.mUserId && mSensor == that.mSensor;
         }

         @Override
         public int hashCode() {
             return 31 * (31 * mType + mUserId) + mSensor;
         }
     }

     void schedulePersist() {
         int numStates = mStates.size();

         ArrayMap<TypeUserSensor, SensorState> statesCopy = new ArrayMap<>();
         for (int i = 0; i < numStates; i++) {
             statesCopy.put(new TypeUserSensor(mStates.keyAt(i)),
                     new SensorState(mStates.valueAt(i)));
         }
         IoThread.getHandler().sendMessage(
                 PooledLambda.obtainMessage(PersistedState::persist, this, statesCopy));
     }

     private void persist(ArrayMap<TypeUserSensor, SensorState> states) {
         FileOutputStream outputStream = null;
         try {
             outputStream = mAtomicFile.startWrite();
             TypedXmlSerializer serializer = Xml.resolveSerializer(outputStream);
             serializer.startDocument(null, true);
             serializer.startTag(null, XML_TAG_SENSOR_PRIVACY);
             serializer.attributeInt(null, XML_ATTRIBUTE_PERSISTENCE_VERSION,
                     CURRENT_PERSISTENCE_VERSION);
             serializer.attributeInt(null, XML_ATTRIBUTE_VERSION, CURRENT_VERSION);
             for (int i = 0; i < states.size(); i++) {
                 TypeUserSensor userSensor = states.keyAt(i);
                 SensorState sensorState = states.valueAt(i);

                 // Do not persist hardware toggle states. Will be restored on reboot
                 if (userSensor.mType != SensorPrivacyManager.TOGGLE_TYPE_SOFTWARE) {
                     continue;
                 }

                 serializer.startTag(null, XML_TAG_SENSOR_STATE);
                 serializer.attributeInt(null, XML_ATTRIBUTE_TOGGLE_TYPE,
                         userSensor.mType);
                 serializer.attributeInt(null, XML_ATTRIBUTE_USER_ID,
                         userSensor.mUserId);
                 serializer.attributeInt(null, XML_ATTRIBUTE_SENSOR,
                         userSensor.mSensor);
                 serializer.attributeInt(null, XML_ATTRIBUTE_STATE_TYPE,
                         sensorState.getState());
                 serializer.attributeLong(null, XML_ATTRIBUTE_LAST_CHANGE,
                         sensorState.getLastChange());
                 serializer.endTag(null, XML_TAG_SENSOR_STATE);
             }

             serializer.endTag(null, XML_TAG_SENSOR_PRIVACY);
             serializer.endDocument();
             mAtomicFile.finishWrite(outputStream);
         } catch (IOException e) {
             Log.e(LOG_TAG, "Caught an exception persisting the sensor privacy state: ", e);
             mAtomicFile.failWrite(outputStream);
         }
     }

     void dump(DualDumpOutputStream dumpStream) {
         // Collect per user, then per sensor. <toggle type, state>
         SparseArray<SparseArray<Pair<Integer, SensorState>>> statesMatrix = new SparseArray<>();
         int numStates = mStates.size();
         for (int i = 0; i < numStates; i++) {
             int toggleType = mStates.keyAt(i).mType;
             int userId = mStates.keyAt(i).mUserId;
             int sensor = mStates.keyAt(i).mSensor;

             SparseArray<Pair<Integer, SensorState>> userStates = statesMatrix.get(userId);
             if (userStates == null) {
                 userStates = new SparseArray<>();
                 statesMatrix.put(userId, userStates);
             }
             userStates.put(sensor, new Pair<>(toggleType, mStates.valueAt(i)));
         }

         dumpStream.write("storage_implementation",
                 SensorPrivacyServiceDumpProto.STORAGE_IMPLEMENTATION,
                 SensorPrivacyStateControllerImpl.class.getName());

         int numUsers = statesMatrix.size();
         for (int i = 0; i < numUsers; i++) {
             int userId = statesMatrix.keyAt(i);
             long userToken = dumpStream.start("users", SensorPrivacyServiceDumpProto.USER);
             dumpStream.write("user_id", SensorPrivacyUserProto.USER_ID, userId);
             SparseArray<Pair<Integer, SensorState>> userStates = statesMatrix.valueAt(i);
             int numSensors = userStates.size();
             for (int j = 0; j < numSensors; j++) {
                 int sensor = userStates.keyAt(j);
                 int toggleType = userStates.valueAt(j).first;
                 SensorState sensorState = userStates.valueAt(j).second;
                 long sensorToken = dumpStream.start("sensors", SensorPrivacyUserProto.SENSORS);
                 dumpStream.write("sensor", SensorPrivacySensorProto.SENSOR, sensor);
                 long toggleToken = dumpStream.start("toggles", SensorPrivacySensorProto.TOGGLES);
                 dumpStream.write("toggle_type",
                         SensorPrivacyIndividualEnabledSensorProto.TOGGLE_TYPE,
                         toggleType);
                 dumpStream.write("state_type",
                         SensorPrivacyIndividualEnabledSensorProto.STATE_TYPE,
                         sensorState.getState());
                 dumpStream.write("last_change",
                         SensorPrivacyIndividualEnabledSensorProto.LAST_CHANGE,
                         sensorState.getLastChange());
                 dumpStream.end(toggleToken);
                 dumpStream.end(sensorToken);
             }
             dumpStream.end(userToken);
         }
     }

     void forEachKnownState(QuadConsumer<Integer, Integer, Integer, SensorState> consumer) {
         int numStates = mStates.size();
         for (int i = 0; i < numStates; i++) {
             TypeUserSensor tus = mStates.keyAt(i);
             SensorState sensorState = mStates.valueAt(i);
             consumer.accept(tus.mType, tus.mUserId, tus.mSensor, sensorState);
         }
     }

     // Structure for persistence version 0
     private static class PVersion0 {
         private SparseArray<SensorState> mIndividualEnabled = new SparseArray<>();

         private PVersion0(int version) {
             if (version != 0) {
                 throw new RuntimeException("Only version 0 supported");
             }
         }

         private void addState(int sensor, boolean enabled) {
             mIndividualEnabled.put(sensor, new SensorState(enabled));
         }

         private void upgrade() {
             // No op, only version 0 is supported
         }
     }

     // Structure for persistence version 1
     private static class PVersion1 {
         private SparseArray<SparseArray<SensorState>> mIndividualEnabled = new SparseArray<>();

         private PVersion1(int version) {
             if (version != 1) {
                 throw new RuntimeException("Only version 1 supported");
             }
         }

         private static PVersion1 fromPVersion0(PVersion0 version0) {
             version0.upgrade();

             PVersion1 result = new PVersion1(1);

             int[] users = {UserHandle.USER_SYSTEM};
             try {
                 users = LocalServices.getService(UserManagerInternal.class).getUserIds();
             } catch (Exception e) {
                 Log.e(LOG_TAG, "Unable to get users.", e);
             }

             // Copy global state to each user
             for (int i = 0; i < users.length; i++) {
                 int userId = users[i];

                 for (int j = 0; j < version0.mIndividualEnabled.size(); j++) {
                     final int sensor = version0.mIndividualEnabled.keyAt(j);
                     final SensorState sensorState = version0.mIndividualEnabled.valueAt(j);

                     result.addState(userId, sensor, sensorState.isEnabled());
                 }
             }

             return result;
         }

         private void addState(int userId, int sensor, boolean enabled) {
             SparseArray<SensorState> userIndividualSensorEnabled =
                     mIndividualEnabled.get(userId, new SparseArray<>());
             mIndividualEnabled.put(userId, userIndividualSensorEnabled);

             userIndividualSensorEnabled
                     .put(sensor, new SensorState(enabled));
         }

         private void upgrade() {
             // No op, only version 1 is supported
         }
     }

     // Structure for persistence version 2
     private static class PVersion2 {
         private ArrayMap<TypeUserSensor, SensorState> mStates = new ArrayMap<>();

         private PVersion2(int version) {
             if (version != 2) {
                 throw new RuntimeException("Only version 2 supported");
             }
         }

         private static PVersion2 fromPVersion1(PVersion1 version1) {
             version1.upgrade();

             PVersion2 result = new PVersion2(2);

             SparseArray<SparseArray<SensorState>> individualEnabled =
                     version1.mIndividualEnabled;
             int numUsers = individualEnabled.size();
             for (int i = 0; i < numUsers; i++) {
                 int userId = individualEnabled.keyAt(i);
                 SparseArray<SensorState> userIndividualEnabled = individualEnabled.valueAt(i);
                 int numSensors = userIndividualEnabled.size();
                 for (int j = 0; j < numSensors; j++) {
                     int sensor = userIndividualEnabled.keyAt(j);
                     SensorState sensorState = userIndividualEnabled.valueAt(j);
                     result.addState(SensorPrivacyManager.TOGGLE_TYPE_SOFTWARE,
                             userId, sensor, sensorState.getState(), sensorState.getLastChange());
                 }
             }

             return result;
         }

         private void addState(int toggleType, int userId, int sensor, int state,
                 long lastChange) {
             mStates.put(new TypeUserSensor(toggleType, userId, sensor),
                     new SensorState(state, lastChange));
         }
     }

     public void resetForTesting() {
         mStates = new ArrayMap<>();
     }
 }
	/*
	* Copyright (C) 2021 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.sensorprivacy;

	import android.hardware.SensorPrivacyManager;
	import android.os.Environment;
	import android.os.UserHandle;
	import android.service.SensorPrivacyIndividualEnabledSensorProto;
	import android.service.SensorPrivacySensorProto;
	import android.service.SensorPrivacyServiceDumpProto;
	import android.service.SensorPrivacyUserProto;
	import android.util.ArrayMap;
	import android.util.AtomicFile;
	import android.util.Log;
	import android.util.Pair;
	import android.util.SparseArray;
	import android.util.Xml;

	import com.android.internal.util.XmlUtils;
	import com.android.internal.util.dump.DualDumpOutputStream;
	import com.android.internal.util.function.QuadConsumer;
	import com.android.internal.util.function.pooled.PooledLambda;
	import com.android.modules.utils.TypedXmlPullParser;
	import com.android.modules.utils.TypedXmlSerializer;
	import com.android.server.IoThread;
	import com.android.server.LocalServices;
	import com.android.server.pm.UserManagerInternal;

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

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;

	/**
	* Class for managing persisted state. Synchronization must be handled by the caller.
	*/
	class PersistedState {

	private static final String LOG_TAG = PersistedState.class.getSimpleName();

	/** Version number indicating compatibility parsing the persisted file */
	private static final int CURRENT_PERSISTENCE_VERSION = 2;
	/** Version number indicating the persisted data needs upgraded to match new internal data
	* structures and features */
	private static final int CURRENT_VERSION = 2;

	private static final String XML_TAG_SENSOR_PRIVACY = "sensor-privacy";
	private static final String XML_TAG_SENSOR_STATE = "sensor-state";
	private static final String XML_ATTRIBUTE_PERSISTENCE_VERSION = "persistence-version";
	private static final String XML_ATTRIBUTE_VERSION = "version";
	private static final String XML_ATTRIBUTE_TOGGLE_TYPE = "toggle-type";
	private static final String XML_ATTRIBUTE_USER_ID = "user-id";
	private static final String XML_ATTRIBUTE_SENSOR = "sensor";
	private static final String XML_ATTRIBUTE_STATE_TYPE = "state-type";
	private static final String XML_ATTRIBUTE_LAST_CHANGE = "last-change";

	private final AtomicFile mAtomicFile;

	private ArrayMap<TypeUserSensor, SensorState> mStates = new ArrayMap<>();

	static PersistedState fromFile(String fileName) {
	return new PersistedState(fileName);
	}

	private PersistedState(String fileName) {
	mAtomicFile = new AtomicFile(new File(Environment.getDataSystemDirectory(), fileName));
	readState();
	}

	private void readState() {
	AtomicFile file = mAtomicFile;
	if (!file.exists()) {
	AtomicFile fileToMigrateFrom =
	new AtomicFile(new File(Environment.getDataSystemDirectory(),
	"sensor_privacy.xml"));

	if (fileToMigrateFrom.exists()) {
	// Sample the start tag to determine if migration is needed
	try (FileInputStream inputStream = fileToMigrateFrom.openRead()) {
	TypedXmlPullParser parser = Xml.resolvePullParser(inputStream);
	XmlUtils.beginDocument(parser, XML_TAG_SENSOR_PRIVACY);
	file = fileToMigrateFrom;
	} catch (IOException e) {
	Log.e(LOG_TAG, "Caught an exception reading the state from storage: ", e);
	// Delete the file to prevent the same error on subsequent calls and assume
	// sensor privacy is not enabled.
	fileToMigrateFrom.delete();
	} catch (XmlPullParserException e) {
	// No migration needed
	}
	}
	}

	Object nonupgradedState = null;
	if (file.exists()) {
	try (FileInputStream inputStream = file.openRead()) {
	TypedXmlPullParser parser = Xml.resolvePullParser(inputStream);
	XmlUtils.beginDocument(parser, XML_TAG_SENSOR_PRIVACY);
	final int persistenceVersion = parser.getAttributeInt(null,
	XML_ATTRIBUTE_PERSISTENCE_VERSION, 0);

	// Use inline string literals for xml tags/attrs when parsing old versions since
	// these should never be changed even with refactorings.
	if (persistenceVersion == 0) {
	int version = 0;
	PVersion0 version0 = new PVersion0(version);
	nonupgradedState = version0;
	readPVersion0(parser, version0);
	} else if (persistenceVersion == 1) {
	int version = parser.getAttributeInt(null,
	"version", 1);
	PVersion1 version1 = new PVersion1(version);
	nonupgradedState = version1;

	readPVersion1(parser, version1);
	} else if (persistenceVersion == CURRENT_PERSISTENCE_VERSION) {
	int version = parser.getAttributeInt(null,
	XML_ATTRIBUTE_VERSION, 2);
	PVersion2 version2 = new PVersion2(version);
	nonupgradedState = version2;

	readPVersion2(parser, version2);
	} else {
	Log.e(LOG_TAG, "Unknown persistence version: " + persistenceVersion
	+ ". Deleting.",
	new RuntimeException());
	file.delete();
	nonupgradedState = null;
	}

	} catch (IOException \| XmlPullParserException \| RuntimeException e) {
	Log.e(LOG_TAG, "Caught an exception reading the state from storage: ", e);
	// Delete the file to prevent the same error on subsequent calls and assume
	// sensor privacy is not enabled.
	file.delete();
	nonupgradedState = null;
	}
	}

	if (nonupgradedState == null) {
	// New file, default state for current version goes here.
	nonupgradedState = new PVersion2(2);
	}

	if (nonupgradedState instanceof PVersion0) {
	nonupgradedState = PVersion1.fromPVersion0((PVersion0) nonupgradedState);
	}
	if (nonupgradedState instanceof PVersion1) {
	nonupgradedState = PVersion2.fromPVersion1((PVersion1) nonupgradedState);
	}
	if (nonupgradedState instanceof PVersion2) {
	PVersion2 upgradedState = (PVersion2) nonupgradedState;
	mStates = upgradedState.mStates;
	} else {
	Log.e(LOG_TAG, "State not successfully upgraded.");
	mStates = new ArrayMap<>();
	}
	}

	private static void readPVersion0(TypedXmlPullParser parser, PVersion0 version0)
	throws XmlPullParserException, IOException {

	XmlUtils.nextElement(parser);
	while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
	if ("individual-sensor-privacy".equals(parser.getName())) {
	int sensor = XmlUtils.readIntAttribute(parser, "sensor");
	boolean indEnabled = XmlUtils.readBooleanAttribute(parser,
	"enabled");
	version0.addState(sensor, indEnabled);
	XmlUtils.skipCurrentTag(parser);
	} else {
	XmlUtils.nextElement(parser);
	}
	}
	}

	private static void readPVersion1(TypedXmlPullParser parser, PVersion1 version1)
	throws XmlPullParserException, IOException {
	while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
	XmlUtils.nextElement(parser);

	if ("user".equals(parser.getName())) {
	int currentUserId = parser.getAttributeInt(null, "id");
	int depth = parser.getDepth();
	while (XmlUtils.nextElementWithin(parser, depth)) {
	if ("individual-sensor-privacy".equals(parser.getName())) {
	int sensor = parser.getAttributeInt(null, "sensor");
	boolean isEnabled = parser.getAttributeBoolean(null,
	"enabled");
	version1.addState(currentUserId, sensor, isEnabled);
	}
	}
	}
	}
	}

	private static void readPVersion2(TypedXmlPullParser parser, PVersion2 version2)
	throws XmlPullParserException, IOException {

	while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
	XmlUtils.nextElement(parser);

	if (XML_TAG_SENSOR_STATE.equals(parser.getName())) {
	int toggleType = parser.getAttributeInt(null, XML_ATTRIBUTE_TOGGLE_TYPE);
	int userId = parser.getAttributeInt(null, XML_ATTRIBUTE_USER_ID);
	int sensor = parser.getAttributeInt(null, XML_ATTRIBUTE_SENSOR);
	int state = parser.getAttributeInt(null, XML_ATTRIBUTE_STATE_TYPE);
	long lastChange = parser.getAttributeLong(null, XML_ATTRIBUTE_LAST_CHANGE);

	version2.addState(toggleType, userId, sensor, state, lastChange);
	} else {
	XmlUtils.skipCurrentTag(parser);
	}
	}
	}

	public SensorState getState(int toggleType, int userId, int sensor) {
	return mStates.get(new TypeUserSensor(toggleType, userId, sensor));
	}

	public SensorState setState(int toggleType, int userId, int sensor, SensorState sensorState) {
	return mStates.put(new TypeUserSensor(toggleType, userId, sensor), sensorState);
	}

	private static class TypeUserSensor {

	int mType;
	int mUserId;
	int mSensor;

	TypeUserSensor(int type, int userId, int sensor) {
	mType = type;
	mUserId = userId;
	mSensor = sensor;
	}

	TypeUserSensor(TypeUserSensor typeUserSensor) {
	this(typeUserSensor.mType, typeUserSensor.mUserId, typeUserSensor.mSensor);
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) return true;
	if (!(o instanceof TypeUserSensor)) return false;
	TypeUserSensor that = (TypeUserSensor) o;
	return mType == that.mType && mUserId == that.mUserId && mSensor == that.mSensor;
	}

	@Override
	public int hashCode() {
	return 31 * (31 * mType + mUserId) + mSensor;
	}
	}

	void schedulePersist() {
	int numStates = mStates.size();

	ArrayMap<TypeUserSensor, SensorState> statesCopy = new ArrayMap<>();
	for (int i = 0; i < numStates; i++) {
	statesCopy.put(new TypeUserSensor(mStates.keyAt(i)),
	new SensorState(mStates.valueAt(i)));
	}
	IoThread.getHandler().sendMessage(
	PooledLambda.obtainMessage(PersistedState::persist, this, statesCopy));
	}

	private void persist(ArrayMap<TypeUserSensor, SensorState> states) {
	FileOutputStream outputStream = null;
	try {
	outputStream = mAtomicFile.startWrite();
	TypedXmlSerializer serializer = Xml.resolveSerializer(outputStream);
	serializer.startDocument(null, true);
	serializer.startTag(null, XML_TAG_SENSOR_PRIVACY);
	serializer.attributeInt(null, XML_ATTRIBUTE_PERSISTENCE_VERSION,
	CURRENT_PERSISTENCE_VERSION);
	serializer.attributeInt(null, XML_ATTRIBUTE_VERSION, CURRENT_VERSION);
	for (int i = 0; i < states.size(); i++) {
	TypeUserSensor userSensor = states.keyAt(i);
	SensorState sensorState = states.valueAt(i);

	// Do not persist hardware toggle states. Will be restored on reboot
	if (userSensor.mType != SensorPrivacyManager.TOGGLE_TYPE_SOFTWARE) {
	continue;
	}

	serializer.startTag(null, XML_TAG_SENSOR_STATE);
	serializer.attributeInt(null, XML_ATTRIBUTE_TOGGLE_TYPE,
	userSensor.mType);
	serializer.attributeInt(null, XML_ATTRIBUTE_USER_ID,
	userSensor.mUserId);
	serializer.attributeInt(null, XML_ATTRIBUTE_SENSOR,
	userSensor.mSensor);
	serializer.attributeInt(null, XML_ATTRIBUTE_STATE_TYPE,
	sensorState.getState());
	serializer.attributeLong(null, XML_ATTRIBUTE_LAST_CHANGE,
	sensorState.getLastChange());
	serializer.endTag(null, XML_TAG_SENSOR_STATE);
	}

	serializer.endTag(null, XML_TAG_SENSOR_PRIVACY);
	serializer.endDocument();
	mAtomicFile.finishWrite(outputStream);
	} catch (IOException e) {
	Log.e(LOG_TAG, "Caught an exception persisting the sensor privacy state: ", e);
	mAtomicFile.failWrite(outputStream);
	}
	}

	void dump(DualDumpOutputStream dumpStream) {
	// Collect per user, then per sensor. <toggle type, state>
	SparseArray<SparseArray<Pair<Integer, SensorState>>> statesMatrix = new SparseArray<>();
	int numStates = mStates.size();
	for (int i = 0; i < numStates; i++) {
	int toggleType = mStates.keyAt(i).mType;
	int userId = mStates.keyAt(i).mUserId;
	int sensor = mStates.keyAt(i).mSensor;

	SparseArray<Pair<Integer, SensorState>> userStates = statesMatrix.get(userId);
	if (userStates == null) {
	userStates = new SparseArray<>();
	statesMatrix.put(userId, userStates);
	}
	userStates.put(sensor, new Pair<>(toggleType, mStates.valueAt(i)));
	}

	dumpStream.write("storage_implementation",
	SensorPrivacyServiceDumpProto.STORAGE_IMPLEMENTATION,
	SensorPrivacyStateControllerImpl.class.getName());

	int numUsers = statesMatrix.size();
	for (int i = 0; i < numUsers; i++) {
	int userId = statesMatrix.keyAt(i);
	long userToken = dumpStream.start("users", SensorPrivacyServiceDumpProto.USER);
	dumpStream.write("user_id", SensorPrivacyUserProto.USER_ID, userId);
	SparseArray<Pair<Integer, SensorState>> userStates = statesMatrix.valueAt(i);
	int numSensors = userStates.size();
	for (int j = 0; j < numSensors; j++) {
	int sensor = userStates.keyAt(j);
	int toggleType = userStates.valueAt(j).first;
	SensorState sensorState = userStates.valueAt(j).second;
	long sensorToken = dumpStream.start("sensors", SensorPrivacyUserProto.SENSORS);
	dumpStream.write("sensor", SensorPrivacySensorProto.SENSOR, sensor);
	long toggleToken = dumpStream.start("toggles", SensorPrivacySensorProto.TOGGLES);
	dumpStream.write("toggle_type",
	SensorPrivacyIndividualEnabledSensorProto.TOGGLE_TYPE,
	toggleType);
	dumpStream.write("state_type",
	SensorPrivacyIndividualEnabledSensorProto.STATE_TYPE,
	sensorState.getState());
	dumpStream.write("last_change",
	SensorPrivacyIndividualEnabledSensorProto.LAST_CHANGE,
	sensorState.getLastChange());
	dumpStream.end(toggleToken);
	dumpStream.end(sensorToken);
	}
	dumpStream.end(userToken);
	}
	}

	void forEachKnownState(QuadConsumer<Integer, Integer, Integer, SensorState> consumer) {
	int numStates = mStates.size();
	for (int i = 0; i < numStates; i++) {
	TypeUserSensor tus = mStates.keyAt(i);
	SensorState sensorState = mStates.valueAt(i);
	consumer.accept(tus.mType, tus.mUserId, tus.mSensor, sensorState);
	}
	}

	// Structure for persistence version 0
	private static class PVersion0 {
	private SparseArray<SensorState> mIndividualEnabled = new SparseArray<>();

	private PVersion0(int version) {
	if (version != 0) {
	throw new RuntimeException("Only version 0 supported");
	}
	}

	private void addState(int sensor, boolean enabled) {
	mIndividualEnabled.put(sensor, new SensorState(enabled));
	}

	private void upgrade() {
	// No op, only version 0 is supported
	}
	}

	// Structure for persistence version 1
	private static class PVersion1 {
	private SparseArray<SparseArray<SensorState>> mIndividualEnabled = new SparseArray<>();

	private PVersion1(int version) {
	if (version != 1) {
	throw new RuntimeException("Only version 1 supported");
	}
	}

	private static PVersion1 fromPVersion0(PVersion0 version0) {
	version0.upgrade();

	PVersion1 result = new PVersion1(1);

	int[] users = {UserHandle.USER_SYSTEM};
	try {
	users = LocalServices.getService(UserManagerInternal.class).getUserIds();
	} catch (Exception e) {
	Log.e(LOG_TAG, "Unable to get users.", e);
	}

	// Copy global state to each user
	for (int i = 0; i < users.length; i++) {
	int userId = users[i];

	for (int j = 0; j < version0.mIndividualEnabled.size(); j++) {
	final int sensor = version0.mIndividualEnabled.keyAt(j);
	final SensorState sensorState = version0.mIndividualEnabled.valueAt(j);

	result.addState(userId, sensor, sensorState.isEnabled());
	}
	}

	return result;
	}

	private void addState(int userId, int sensor, boolean enabled) {
	SparseArray<SensorState> userIndividualSensorEnabled =
	mIndividualEnabled.get(userId, new SparseArray<>());
	mIndividualEnabled.put(userId, userIndividualSensorEnabled);

	userIndividualSensorEnabled
	.put(sensor, new SensorState(enabled));
	}

	private void upgrade() {
	// No op, only version 1 is supported
	}
	}

	// Structure for persistence version 2
	private static class PVersion2 {
	private ArrayMap<TypeUserSensor, SensorState> mStates = new ArrayMap<>();

	private PVersion2(int version) {
	if (version != 2) {
	throw new RuntimeException("Only version 2 supported");
	}
	}

	private static PVersion2 fromPVersion1(PVersion1 version1) {
	version1.upgrade();

	PVersion2 result = new PVersion2(2);

	SparseArray<SparseArray<SensorState>> individualEnabled =
	version1.mIndividualEnabled;
	int numUsers = individualEnabled.size();
	for (int i = 0; i < numUsers; i++) {
	int userId = individualEnabled.keyAt(i);
	SparseArray<SensorState> userIndividualEnabled = individualEnabled.valueAt(i);
	int numSensors = userIndividualEnabled.size();
	for (int j = 0; j < numSensors; j++) {
	int sensor = userIndividualEnabled.keyAt(j);
	SensorState sensorState = userIndividualEnabled.valueAt(j);
	result.addState(SensorPrivacyManager.TOGGLE_TYPE_SOFTWARE,
	userId, sensor, sensorState.getState(), sensorState.getLastChange());
	}
	}

	return result;
	}

	private void addState(int toggleType, int userId, int sensor, int state,
	long lastChange) {
	mStates.put(new TypeUserSensor(toggleType, userId, sensor),
	new SensorState(state, lastChange));
	}
	}

	public void resetForTesting() {
	mStates = new ArrayMap<>();
	}
	}