services/core/java/com/android/server/input/PersistentDataStore.java - platform/frameworks/base - Git at Google

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

 import com.android.internal.util.ArrayUtils;
 import com.android.internal.util.FastXmlSerializer;
 import com.android.internal.util.XmlUtils;

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

 import android.view.Surface;
 import android.hardware.input.TouchCalibration;
 import android.util.AtomicFile;
 import android.util.Slog;
 import android.util.Xml;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;

 import libcore.io.IoUtils;
 import libcore.util.Objects;

 /**
  * Manages persistent state recorded by the input manager service as an XML file.
  * Caller must acquire lock on the data store before accessing it.
  *
  * File format:
  * <code>
  * &lt;input-mananger-state>
  *   &lt;input-devices>
  *     &lt;input-device descriptor="xxxxx" keyboard-layout="yyyyy" />
  *   &gt;input-devices>
  * &gt;/input-manager-state>
  * </code>
  */
 final class PersistentDataStore {
     static final String TAG = "InputManager";

     // Input device state by descriptor.
     private final HashMap<String, InputDeviceState> mInputDevices =
             new HashMap<String, InputDeviceState>();
     private final AtomicFile mAtomicFile;

     // True if the data has been loaded.
     private boolean mLoaded;

     // True if there are changes to be saved.
     private boolean mDirty;

     public PersistentDataStore() {
         mAtomicFile = new AtomicFile(new File("/data/system/input-manager-state.xml"));
     }

     public void saveIfNeeded() {
         if (mDirty) {
             save();
             mDirty = false;
         }
     }

     public TouchCalibration getTouchCalibration(String inputDeviceDescriptor, int surfaceRotation) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
         if (state == null) {
             return TouchCalibration.IDENTITY;
         }

         TouchCalibration cal = state.getTouchCalibration(surfaceRotation);
         if (cal == null) {
             return TouchCalibration.IDENTITY;
         }
         return cal;
     }

     public boolean setTouchCalibration(String inputDeviceDescriptor, int surfaceRotation, TouchCalibration calibration) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);

         if (state.setTouchCalibration(surfaceRotation, calibration)) {
             setDirty();
             return true;
         }

         return false;
     }

     public String getCurrentKeyboardLayout(String inputDeviceDescriptor) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
         return state != null ? state.getCurrentKeyboardLayout() : null;
     }

     public boolean setCurrentKeyboardLayout(String inputDeviceDescriptor,
             String keyboardLayoutDescriptor) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);
         if (state.setCurrentKeyboardLayout(keyboardLayoutDescriptor)) {
             setDirty();
             return true;
         }
         return false;
     }

     public String[] getKeyboardLayouts(String inputDeviceDescriptor) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
         if (state == null) {
             return (String[])ArrayUtils.emptyArray(String.class);
         }
         return state.getKeyboardLayouts();
     }

     public boolean addKeyboardLayout(String inputDeviceDescriptor,
             String keyboardLayoutDescriptor) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);
         if (state.addKeyboardLayout(keyboardLayoutDescriptor)) {
             setDirty();
             return true;
         }
         return false;
     }

     public boolean removeKeyboardLayout(String inputDeviceDescriptor,
             String keyboardLayoutDescriptor) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);
         if (state.removeKeyboardLayout(keyboardLayoutDescriptor)) {
             setDirty();
             return true;
         }
         return false;
     }

     public boolean switchKeyboardLayout(String inputDeviceDescriptor, int direction) {
         InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
         if (state != null && state.switchKeyboardLayout(direction)) {
             setDirty();
             return true;
         }
         return false;
     }

     public boolean removeUninstalledKeyboardLayouts(Set<String> availableKeyboardLayouts) {
         boolean changed = false;
         for (InputDeviceState state : mInputDevices.values()) {
             if (state.removeUninstalledKeyboardLayouts(availableKeyboardLayouts)) {
                 changed = true;
             }
         }
         if (changed) {
             setDirty();
             return true;
         }
         return false;
     }

     private InputDeviceState getInputDeviceState(String inputDeviceDescriptor,
             boolean createIfAbsent) {
         loadIfNeeded();
         InputDeviceState state = mInputDevices.get(inputDeviceDescriptor);
         if (state == null && createIfAbsent) {
             state = new InputDeviceState();
             mInputDevices.put(inputDeviceDescriptor, state);
             setDirty();
         }
         return state;
     }

     private void loadIfNeeded() {
         if (!mLoaded) {
             load();
             mLoaded = true;
         }
     }

     private void setDirty() {
         mDirty = true;
     }

     private void clearState() {
         mInputDevices.clear();
     }

     private void load() {
         clearState();

         final InputStream is;
         try {
             is = mAtomicFile.openRead();
         } catch (FileNotFoundException ex) {
             return;
         }

         XmlPullParser parser;
         try {
             parser = Xml.newPullParser();
             parser.setInput(new BufferedInputStream(is), null);
             loadFromXml(parser);
         } catch (IOException ex) {
             Slog.w(InputManagerService.TAG, "Failed to load input manager persistent store data.", ex);
             clearState();
         } catch (XmlPullParserException ex) {
             Slog.w(InputManagerService.TAG, "Failed to load input manager persistent store data.", ex);
             clearState();
         } finally {
             IoUtils.closeQuietly(is);
         }
     }

     private void save() {
         final FileOutputStream os;
         try {
             os = mAtomicFile.startWrite();
             boolean success = false;
             try {
                 XmlSerializer serializer = new FastXmlSerializer();
                 serializer.setOutput(new BufferedOutputStream(os), "utf-8");
                 saveToXml(serializer);
                 serializer.flush();
                 success = true;
             } finally {
                 if (success) {
                     mAtomicFile.finishWrite(os);
                 } else {
                     mAtomicFile.failWrite(os);
                 }
             }
         } catch (IOException ex) {
             Slog.w(InputManagerService.TAG, "Failed to save input manager persistent store data.", ex);
         }
     }

     private void loadFromXml(XmlPullParser parser)
             throws IOException, XmlPullParserException {
         XmlUtils.beginDocument(parser, "input-manager-state");
         final int outerDepth = parser.getDepth();
         while (XmlUtils.nextElementWithin(parser, outerDepth)) {
             if (parser.getName().equals("input-devices")) {
                 loadInputDevicesFromXml(parser);
             }
         }
     }

     private void loadInputDevicesFromXml(XmlPullParser parser)
             throws IOException, XmlPullParserException {
         final int outerDepth = parser.getDepth();
         while (XmlUtils.nextElementWithin(parser, outerDepth)) {
             if (parser.getName().equals("input-device")) {
                 String descriptor = parser.getAttributeValue(null, "descriptor");
                 if (descriptor == null) {
                     throw new XmlPullParserException(
                             "Missing descriptor attribute on input-device.");
                 }
                 if (mInputDevices.containsKey(descriptor)) {
                     throw new XmlPullParserException("Found duplicate input device.");
                 }

                 InputDeviceState state = new InputDeviceState();
                 state.loadFromXml(parser);
                 mInputDevices.put(descriptor, state);
             }
         }
     }

     private void saveToXml(XmlSerializer serializer) throws IOException {
         serializer.startDocument(null, true);
         serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
         serializer.startTag(null, "input-manager-state");
         serializer.startTag(null, "input-devices");
         for (Map.Entry<String, InputDeviceState> entry : mInputDevices.entrySet()) {
             final String descriptor = entry.getKey();
             final InputDeviceState state = entry.getValue();
             serializer.startTag(null, "input-device");
             serializer.attribute(null, "descriptor", descriptor);
             state.saveToXml(serializer);
             serializer.endTag(null, "input-device");
         }
         serializer.endTag(null, "input-devices");
         serializer.endTag(null, "input-manager-state");
         serializer.endDocument();
     }

     private static final class InputDeviceState {
         private static final String[] CALIBRATION_NAME = { "x_scale",
                 "x_ymix", "x_offset", "y_xmix", "y_scale", "y_offset" };

         private TouchCalibration[] mTouchCalibration = new TouchCalibration[4];
         private String mCurrentKeyboardLayout;
         private ArrayList<String> mKeyboardLayouts = new ArrayList<String>();

         public TouchCalibration getTouchCalibration(int surfaceRotation) {
             try {
                 return mTouchCalibration[surfaceRotation];
             } catch (ArrayIndexOutOfBoundsException ex) {
                 Slog.w(InputManagerService.TAG, "Cannot get touch calibration.", ex);
                 return null;
             }
         }

         public boolean setTouchCalibration(int surfaceRotation, TouchCalibration calibration) {
             try {
                 if (!calibration.equals(mTouchCalibration[surfaceRotation])) {
                     mTouchCalibration[surfaceRotation] = calibration;
                     return true;
                 }
                 return false;
             } catch (ArrayIndexOutOfBoundsException ex) {
                 Slog.w(InputManagerService.TAG, "Cannot set touch calibration.", ex);
                 return false;
             }
         }

         public String getCurrentKeyboardLayout() {
             return mCurrentKeyboardLayout;
         }

         public boolean setCurrentKeyboardLayout(String keyboardLayout) {
             if (Objects.equal(mCurrentKeyboardLayout, keyboardLayout)) {
                 return false;
             }
             addKeyboardLayout(keyboardLayout);
             mCurrentKeyboardLayout = keyboardLayout;
             return true;
         }

         public String[] getKeyboardLayouts() {
             if (mKeyboardLayouts.isEmpty()) {
                 return (String[])ArrayUtils.emptyArray(String.class);
             }
             return mKeyboardLayouts.toArray(new String[mKeyboardLayouts.size()]);
         }

         public boolean addKeyboardLayout(String keyboardLayout) {
             int index = Collections.binarySearch(mKeyboardLayouts, keyboardLayout);
             if (index >= 0) {
                 return false;
             }
             mKeyboardLayouts.add(-index - 1, keyboardLayout);
             if (mCurrentKeyboardLayout == null) {
                 mCurrentKeyboardLayout = keyboardLayout;
             }
             return true;
         }

         public boolean removeKeyboardLayout(String keyboardLayout) {
             int index = Collections.binarySearch(mKeyboardLayouts, keyboardLayout);
             if (index < 0) {
                 return false;
             }
             mKeyboardLayouts.remove(index);
             updateCurrentKeyboardLayoutIfRemoved(keyboardLayout, index);
             return true;
         }

         private void updateCurrentKeyboardLayoutIfRemoved(
                 String removedKeyboardLayout, int removedIndex) {
             if (Objects.equal(mCurrentKeyboardLayout, removedKeyboardLayout)) {
                 if (!mKeyboardLayouts.isEmpty()) {
                     int index = removedIndex;
                     if (index == mKeyboardLayouts.size()) {
                         index = 0;
                     }
                     mCurrentKeyboardLayout = mKeyboardLayouts.get(index);
                 } else {
                     mCurrentKeyboardLayout = null;
                 }
             }
         }

         public boolean switchKeyboardLayout(int direction) {
             final int size = mKeyboardLayouts.size();
             if (size < 2) {
                 return false;
             }
             int index = Collections.binarySearch(mKeyboardLayouts, mCurrentKeyboardLayout);
             assert index >= 0;
             if (direction > 0) {
                 index = (index + 1) % size;
             } else {
                 index = (index + size - 1) % size;
             }
             mCurrentKeyboardLayout = mKeyboardLayouts.get(index);
             return true;
         }

         public boolean removeUninstalledKeyboardLayouts(Set<String> availableKeyboardLayouts) {
             boolean changed = false;
             for (int i = mKeyboardLayouts.size(); i-- > 0; ) {
                 String keyboardLayout = mKeyboardLayouts.get(i);
                 if (!availableKeyboardLayouts.contains(keyboardLayout)) {
                     Slog.i(TAG, "Removing uninstalled keyboard layout " + keyboardLayout);
                     mKeyboardLayouts.remove(i);
                     updateCurrentKeyboardLayoutIfRemoved(keyboardLayout, i);
                     changed = true;
                 }
             }
             return changed;
         }

         public void loadFromXml(XmlPullParser parser)
                 throws IOException, XmlPullParserException {
             final int outerDepth = parser.getDepth();
             while (XmlUtils.nextElementWithin(parser, outerDepth)) {
                 if (parser.getName().equals("keyboard-layout")) {
                     String descriptor = parser.getAttributeValue(null, "descriptor");
                     if (descriptor == null) {
                         throw new XmlPullParserException(
                                 "Missing descriptor attribute on keyboard-layout.");
                     }
                     String current = parser.getAttributeValue(null, "current");
                     if (mKeyboardLayouts.contains(descriptor)) {
                         throw new XmlPullParserException(
                                 "Found duplicate keyboard layout.");
                     }

                     mKeyboardLayouts.add(descriptor);
                     if (current != null && current.equals("true")) {
                         if (mCurrentKeyboardLayout != null) {
                             throw new XmlPullParserException(
                                     "Found multiple current keyboard layouts.");
                         }
                         mCurrentKeyboardLayout = descriptor;
                     }
                 } else if (parser.getName().equals("calibration")) {
                     String format = parser.getAttributeValue(null, "format");
                     String rotation = parser.getAttributeValue(null, "rotation");
                     int r = -1;

                     if (format == null) {
                         throw new XmlPullParserException(
                                 "Missing format attribute on calibration.");
                     }
                     if (!format.equals("affine")) {
                         throw new XmlPullParserException(
                                 "Unsupported format for calibration.");
                     }
                     if (rotation != null) {
                         try {
                             r = stringToSurfaceRotation(rotation);
                         } catch (IllegalArgumentException e) {
                             throw new XmlPullParserException(
                                     "Unsupported rotation for calibration.");
                         }
                     }

                     float[] matrix = TouchCalibration.IDENTITY.getAffineTransform();
                     int depth = parser.getDepth();
                     while (XmlUtils.nextElementWithin(parser, depth)) {
                         String tag = parser.getName().toLowerCase();
                         String value = parser.nextText();

                         for (int i = 0; i < matrix.length && i < CALIBRATION_NAME.length; i++) {
                             if (tag.equals(CALIBRATION_NAME[i])) {
                                 matrix[i] = Float.parseFloat(value);
                                 break;
                             }
                         }
                     }

                     if (r == -1) {
                         // Assume calibration applies to all rotations
                         for (r = 0; r < mTouchCalibration.length; r++) {
                             mTouchCalibration[r] = new TouchCalibration(matrix[0],
                                 matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
                         }
                     } else {
                         mTouchCalibration[r] = new TouchCalibration(matrix[0],
                             matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
                     }
                 }
             }

             // Maintain invariant that layouts are sorted.
             Collections.sort(mKeyboardLayouts);

             // Maintain invariant that there is always a current keyboard layout unless
             // there are none installed.
             if (mCurrentKeyboardLayout == null && !mKeyboardLayouts.isEmpty()) {
                 mCurrentKeyboardLayout = mKeyboardLayouts.get(0);
             }
         }

         public void saveToXml(XmlSerializer serializer) throws IOException {
             for (String layout : mKeyboardLayouts) {
                 serializer.startTag(null, "keyboard-layout");
                 serializer.attribute(null, "descriptor", layout);
                 if (layout.equals(mCurrentKeyboardLayout)) {
                     serializer.attribute(null, "current", "true");
                 }
                 serializer.endTag(null, "keyboard-layout");
             }

             for (int i = 0; i < mTouchCalibration.length; i++) {
                 if (mTouchCalibration[i] != null) {
                     String rotation = surfaceRotationToString(i);
                     float[] transform = mTouchCalibration[i].getAffineTransform();

                     serializer.startTag(null, "calibration");
                     serializer.attribute(null, "format", "affine");
                     serializer.attribute(null, "rotation", rotation);
                     for (int j = 0; j < transform.length && j < CALIBRATION_NAME.length; j++) {
                         serializer.startTag(null, CALIBRATION_NAME[j]);
                         serializer.text(Float.toString(transform[j]));
                         serializer.endTag(null, CALIBRATION_NAME[j]);
                     }
                     serializer.endTag(null, "calibration");
                 }
             }
         }

         private static String surfaceRotationToString(int surfaceRotation) {
             switch (surfaceRotation) {
                 case Surface.ROTATION_0:   return "0";
                 case Surface.ROTATION_90:  return "90";
                 case Surface.ROTATION_180: return "180";
                 case Surface.ROTATION_270: return "270";
             }
             throw new IllegalArgumentException("Unsupported surface rotation value" + surfaceRotation);
         }

         private static int stringToSurfaceRotation(String s) {
             if ("0".equals(s)) {
                 return Surface.ROTATION_0;
             }
             if ("90".equals(s)) {
                 return Surface.ROTATION_90;
             }
             if ("180".equals(s)) {
                 return Surface.ROTATION_180;
             }
             if ("270".equals(s)) {
                 return Surface.ROTATION_270;
             }
             throw new IllegalArgumentException("Unsupported surface rotation string '" + s + "'");
         }
     }
 }
	/*
	* Copyright (C) 2012 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.input;

	import com.android.internal.util.ArrayUtils;
	import com.android.internal.util.FastXmlSerializer;
	import com.android.internal.util.XmlUtils;

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

	import android.view.Surface;
	import android.hardware.input.TouchCalibration;
	import android.util.AtomicFile;
	import android.util.Slog;
	import android.util.Xml;

	import java.io.BufferedInputStream;
	import java.io.BufferedOutputStream;
	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.Set;

	import libcore.io.IoUtils;
	import libcore.util.Objects;

	/**
	* Manages persistent state recorded by the input manager service as an XML file.
	* Caller must acquire lock on the data store before accessing it.
	*
	* File format:
	* <code>
	* <input-mananger-state>
	* <input-devices>
	* <input-device descriptor="xxxxx" keyboard-layout="yyyyy" />
	* >input-devices>
	* >/input-manager-state>
	* </code>
	*/
	final class PersistentDataStore {
	static final String TAG = "InputManager";

	// Input device state by descriptor.
	private final HashMap<String, InputDeviceState> mInputDevices =
	new HashMap<String, InputDeviceState>();
	private final AtomicFile mAtomicFile;

	// True if the data has been loaded.
	private boolean mLoaded;

	// True if there are changes to be saved.
	private boolean mDirty;

	public PersistentDataStore() {
	mAtomicFile = new AtomicFile(new File("/data/system/input-manager-state.xml"));
	}

	public void saveIfNeeded() {
	if (mDirty) {
	save();
	mDirty = false;
	}
	}

	public TouchCalibration getTouchCalibration(String inputDeviceDescriptor, int surfaceRotation) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
	if (state == null) {
	return TouchCalibration.IDENTITY;
	}

	TouchCalibration cal = state.getTouchCalibration(surfaceRotation);
	if (cal == null) {
	return TouchCalibration.IDENTITY;
	}
	return cal;
	}

	public boolean setTouchCalibration(String inputDeviceDescriptor, int surfaceRotation, TouchCalibration calibration) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);

	if (state.setTouchCalibration(surfaceRotation, calibration)) {
	setDirty();
	return true;
	}

	return false;
	}

	public String getCurrentKeyboardLayout(String inputDeviceDescriptor) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
	return state != null ? state.getCurrentKeyboardLayout() : null;
	}

	public boolean setCurrentKeyboardLayout(String inputDeviceDescriptor,
	String keyboardLayoutDescriptor) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);
	if (state.setCurrentKeyboardLayout(keyboardLayoutDescriptor)) {
	setDirty();
	return true;
	}
	return false;
	}

	public String[] getKeyboardLayouts(String inputDeviceDescriptor) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
	if (state == null) {
	return (String[])ArrayUtils.emptyArray(String.class);
	}
	return state.getKeyboardLayouts();
	}

	public boolean addKeyboardLayout(String inputDeviceDescriptor,
	String keyboardLayoutDescriptor) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);
	if (state.addKeyboardLayout(keyboardLayoutDescriptor)) {
	setDirty();
	return true;
	}
	return false;
	}

	public boolean removeKeyboardLayout(String inputDeviceDescriptor,
	String keyboardLayoutDescriptor) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, true);
	if (state.removeKeyboardLayout(keyboardLayoutDescriptor)) {
	setDirty();
	return true;
	}
	return false;
	}

	public boolean switchKeyboardLayout(String inputDeviceDescriptor, int direction) {
	InputDeviceState state = getInputDeviceState(inputDeviceDescriptor, false);
	if (state != null && state.switchKeyboardLayout(direction)) {
	setDirty();
	return true;
	}
	return false;
	}

	public boolean removeUninstalledKeyboardLayouts(Set<String> availableKeyboardLayouts) {
	boolean changed = false;
	for (InputDeviceState state : mInputDevices.values()) {
	if (state.removeUninstalledKeyboardLayouts(availableKeyboardLayouts)) {
	changed = true;
	}
	}
	if (changed) {
	setDirty();
	return true;
	}
	return false;
	}

	private InputDeviceState getInputDeviceState(String inputDeviceDescriptor,
	boolean createIfAbsent) {
	loadIfNeeded();
	InputDeviceState state = mInputDevices.get(inputDeviceDescriptor);
	if (state == null && createIfAbsent) {
	state = new InputDeviceState();
	mInputDevices.put(inputDeviceDescriptor, state);
	setDirty();
	}
	return state;
	}

	private void loadIfNeeded() {
	if (!mLoaded) {
	load();
	mLoaded = true;
	}
	}

	private void setDirty() {
	mDirty = true;
	}

	private void clearState() {
	mInputDevices.clear();
	}

	private void load() {
	clearState();

	final InputStream is;
	try {
	is = mAtomicFile.openRead();
	} catch (FileNotFoundException ex) {
	return;
	}

	XmlPullParser parser;
	try {
	parser = Xml.newPullParser();
	parser.setInput(new BufferedInputStream(is), null);
	loadFromXml(parser);
	} catch (IOException ex) {
	Slog.w(InputManagerService.TAG, "Failed to load input manager persistent store data.", ex);
	clearState();
	} catch (XmlPullParserException ex) {
	Slog.w(InputManagerService.TAG, "Failed to load input manager persistent store data.", ex);
	clearState();
	} finally {
	IoUtils.closeQuietly(is);
	}
	}

	private void save() {
	final FileOutputStream os;
	try {
	os = mAtomicFile.startWrite();
	boolean success = false;
	try {
	XmlSerializer serializer = new FastXmlSerializer();
	serializer.setOutput(new BufferedOutputStream(os), "utf-8");
	saveToXml(serializer);
	serializer.flush();
	success = true;
	} finally {
	if (success) {
	mAtomicFile.finishWrite(os);
	} else {
	mAtomicFile.failWrite(os);
	}
	}
	} catch (IOException ex) {
	Slog.w(InputManagerService.TAG, "Failed to save input manager persistent store data.", ex);
	}
	}

	private void loadFromXml(XmlPullParser parser)
	throws IOException, XmlPullParserException {
	XmlUtils.beginDocument(parser, "input-manager-state");
	final int outerDepth = parser.getDepth();
	while (XmlUtils.nextElementWithin(parser, outerDepth)) {
	if (parser.getName().equals("input-devices")) {
	loadInputDevicesFromXml(parser);
	}
	}
	}

	private void loadInputDevicesFromXml(XmlPullParser parser)
	throws IOException, XmlPullParserException {
	final int outerDepth = parser.getDepth();
	while (XmlUtils.nextElementWithin(parser, outerDepth)) {
	if (parser.getName().equals("input-device")) {
	String descriptor = parser.getAttributeValue(null, "descriptor");
	if (descriptor == null) {
	throw new XmlPullParserException(
	"Missing descriptor attribute on input-device.");
	}
	if (mInputDevices.containsKey(descriptor)) {
	throw new XmlPullParserException("Found duplicate input device.");
	}

	InputDeviceState state = new InputDeviceState();
	state.loadFromXml(parser);
	mInputDevices.put(descriptor, state);
	}
	}
	}

	private void saveToXml(XmlSerializer serializer) throws IOException {
	serializer.startDocument(null, true);
	serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
	serializer.startTag(null, "input-manager-state");
	serializer.startTag(null, "input-devices");
	for (Map.Entry<String, InputDeviceState> entry : mInputDevices.entrySet()) {
	final String descriptor = entry.getKey();
	final InputDeviceState state = entry.getValue();
	serializer.startTag(null, "input-device");
	serializer.attribute(null, "descriptor", descriptor);
	state.saveToXml(serializer);
	serializer.endTag(null, "input-device");
	}
	serializer.endTag(null, "input-devices");
	serializer.endTag(null, "input-manager-state");
	serializer.endDocument();
	}

	private static final class InputDeviceState {
	private static final String[] CALIBRATION_NAME = { "x_scale",
	"x_ymix", "x_offset", "y_xmix", "y_scale", "y_offset" };

	private TouchCalibration[] mTouchCalibration = new TouchCalibration[4];
	private String mCurrentKeyboardLayout;
	private ArrayList<String> mKeyboardLayouts = new ArrayList<String>();

	public TouchCalibration getTouchCalibration(int surfaceRotation) {
	try {
	return mTouchCalibration[surfaceRotation];
	} catch (ArrayIndexOutOfBoundsException ex) {
	Slog.w(InputManagerService.TAG, "Cannot get touch calibration.", ex);
	return null;
	}
	}

	public boolean setTouchCalibration(int surfaceRotation, TouchCalibration calibration) {
	try {
	if (!calibration.equals(mTouchCalibration[surfaceRotation])) {
	mTouchCalibration[surfaceRotation] = calibration;
	return true;
	}
	return false;
	} catch (ArrayIndexOutOfBoundsException ex) {
	Slog.w(InputManagerService.TAG, "Cannot set touch calibration.", ex);
	return false;
	}
	}

	public String getCurrentKeyboardLayout() {
	return mCurrentKeyboardLayout;
	}

	public boolean setCurrentKeyboardLayout(String keyboardLayout) {
	if (Objects.equal(mCurrentKeyboardLayout, keyboardLayout)) {
	return false;
	}
	addKeyboardLayout(keyboardLayout);
	mCurrentKeyboardLayout = keyboardLayout;
	return true;
	}

	public String[] getKeyboardLayouts() {
	if (mKeyboardLayouts.isEmpty()) {
	return (String[])ArrayUtils.emptyArray(String.class);
	}
	return mKeyboardLayouts.toArray(new String[mKeyboardLayouts.size()]);
	}

	public boolean addKeyboardLayout(String keyboardLayout) {
	int index = Collections.binarySearch(mKeyboardLayouts, keyboardLayout);
	if (index >= 0) {
	return false;
	}
	mKeyboardLayouts.add(-index - 1, keyboardLayout);
	if (mCurrentKeyboardLayout == null) {
	mCurrentKeyboardLayout = keyboardLayout;
	}
	return true;
	}

	public boolean removeKeyboardLayout(String keyboardLayout) {
	int index = Collections.binarySearch(mKeyboardLayouts, keyboardLayout);
	if (index < 0) {
	return false;
	}
	mKeyboardLayouts.remove(index);
	updateCurrentKeyboardLayoutIfRemoved(keyboardLayout, index);
	return true;
	}

	private void updateCurrentKeyboardLayoutIfRemoved(
	String removedKeyboardLayout, int removedIndex) {
	if (Objects.equal(mCurrentKeyboardLayout, removedKeyboardLayout)) {
	if (!mKeyboardLayouts.isEmpty()) {
	int index = removedIndex;
	if (index == mKeyboardLayouts.size()) {
	index = 0;
	}
	mCurrentKeyboardLayout = mKeyboardLayouts.get(index);
	} else {
	mCurrentKeyboardLayout = null;
	}
	}
	}

	public boolean switchKeyboardLayout(int direction) {
	final int size = mKeyboardLayouts.size();
	if (size < 2) {
	return false;
	}
	int index = Collections.binarySearch(mKeyboardLayouts, mCurrentKeyboardLayout);
	assert index >= 0;
	if (direction > 0) {
	index = (index + 1) % size;
	} else {
	index = (index + size - 1) % size;
	}
	mCurrentKeyboardLayout = mKeyboardLayouts.get(index);
	return true;
	}

	public boolean removeUninstalledKeyboardLayouts(Set<String> availableKeyboardLayouts) {
	boolean changed = false;
	for (int i = mKeyboardLayouts.size(); i-- > 0; ) {
	String keyboardLayout = mKeyboardLayouts.get(i);
	if (!availableKeyboardLayouts.contains(keyboardLayout)) {
	Slog.i(TAG, "Removing uninstalled keyboard layout " + keyboardLayout);
	mKeyboardLayouts.remove(i);
	updateCurrentKeyboardLayoutIfRemoved(keyboardLayout, i);
	changed = true;
	}
	}
	return changed;
	}

	public void loadFromXml(XmlPullParser parser)
	throws IOException, XmlPullParserException {
	final int outerDepth = parser.getDepth();
	while (XmlUtils.nextElementWithin(parser, outerDepth)) {
	if (parser.getName().equals("keyboard-layout")) {
	String descriptor = parser.getAttributeValue(null, "descriptor");
	if (descriptor == null) {
	throw new XmlPullParserException(
	"Missing descriptor attribute on keyboard-layout.");
	}
	String current = parser.getAttributeValue(null, "current");
	if (mKeyboardLayouts.contains(descriptor)) {
	throw new XmlPullParserException(
	"Found duplicate keyboard layout.");
	}

	mKeyboardLayouts.add(descriptor);
	if (current != null && current.equals("true")) {
	if (mCurrentKeyboardLayout != null) {
	throw new XmlPullParserException(
	"Found multiple current keyboard layouts.");
	}
	mCurrentKeyboardLayout = descriptor;
	}
	} else if (parser.getName().equals("calibration")) {
	String format = parser.getAttributeValue(null, "format");
	String rotation = parser.getAttributeValue(null, "rotation");
	int r = -1;

	if (format == null) {
	throw new XmlPullParserException(
	"Missing format attribute on calibration.");
	}
	if (!format.equals("affine")) {
	throw new XmlPullParserException(
	"Unsupported format for calibration.");
	}
	if (rotation != null) {
	try {
	r = stringToSurfaceRotation(rotation);
	} catch (IllegalArgumentException e) {
	throw new XmlPullParserException(
	"Unsupported rotation for calibration.");
	}
	}

	float[] matrix = TouchCalibration.IDENTITY.getAffineTransform();
	int depth = parser.getDepth();
	while (XmlUtils.nextElementWithin(parser, depth)) {
	String tag = parser.getName().toLowerCase();
	String value = parser.nextText();

	for (int i = 0; i < matrix.length && i < CALIBRATION_NAME.length; i++) {
	if (tag.equals(CALIBRATION_NAME[i])) {
	matrix[i] = Float.parseFloat(value);
	break;
	}
	}
	}

	if (r == -1) {
	// Assume calibration applies to all rotations
	for (r = 0; r < mTouchCalibration.length; r++) {
	mTouchCalibration[r] = new TouchCalibration(matrix[0],
	matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
	}
	} else {
	mTouchCalibration[r] = new TouchCalibration(matrix[0],
	matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
	}
	}
	}

	// Maintain invariant that layouts are sorted.
	Collections.sort(mKeyboardLayouts);

	// Maintain invariant that there is always a current keyboard layout unless
	// there are none installed.
	if (mCurrentKeyboardLayout == null && !mKeyboardLayouts.isEmpty()) {
	mCurrentKeyboardLayout = mKeyboardLayouts.get(0);
	}
	}

	public void saveToXml(XmlSerializer serializer) throws IOException {
	for (String layout : mKeyboardLayouts) {
	serializer.startTag(null, "keyboard-layout");
	serializer.attribute(null, "descriptor", layout);
	if (layout.equals(mCurrentKeyboardLayout)) {
	serializer.attribute(null, "current", "true");
	}
	serializer.endTag(null, "keyboard-layout");
	}

	for (int i = 0; i < mTouchCalibration.length; i++) {
	if (mTouchCalibration[i] != null) {
	String rotation = surfaceRotationToString(i);
	float[] transform = mTouchCalibration[i].getAffineTransform();

	serializer.startTag(null, "calibration");
	serializer.attribute(null, "format", "affine");
	serializer.attribute(null, "rotation", rotation);
	for (int j = 0; j < transform.length && j < CALIBRATION_NAME.length; j++) {
	serializer.startTag(null, CALIBRATION_NAME[j]);
	serializer.text(Float.toString(transform[j]));
	serializer.endTag(null, CALIBRATION_NAME[j]);
	}
	serializer.endTag(null, "calibration");
	}
	}
	}

	private static String surfaceRotationToString(int surfaceRotation) {
	switch (surfaceRotation) {
	case Surface.ROTATION_0: return "0";
	case Surface.ROTATION_90: return "90";
	case Surface.ROTATION_180: return "180";
	case Surface.ROTATION_270: return "270";
	}
	throw new IllegalArgumentException("Unsupported surface rotation value" + surfaceRotation);
	}

	private static int stringToSurfaceRotation(String s) {
	if ("0".equals(s)) {
	return Surface.ROTATION_0;
	}
	if ("90".equals(s)) {
	return Surface.ROTATION_90;
	}
	if ("180".equals(s)) {
	return Surface.ROTATION_180;
	}
	if ("270".equals(s)) {
	return Surface.ROTATION_270;
	}
	throw new IllegalArgumentException("Unsupported surface rotation string '" + s + "'");
	}
	}
	}