/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package com.android.server.inputmethod;
|
|
import android.annotation.NonNull;
|
import android.annotation.UserIdInt;
|
import android.os.Environment;
|
import android.os.FileUtils;
|
import android.os.UserHandle;
|
import android.text.TextUtils;
|
import android.util.ArrayMap;
|
import android.util.AtomicFile;
|
import android.util.Slog;
|
import android.util.Xml;
|
import android.view.inputmethod.InputMethodInfo;
|
import android.view.inputmethod.InputMethodSubtype;
|
|
import com.android.internal.util.FastXmlSerializer;
|
|
import org.xmlpull.v1.XmlPullParser;
|
import org.xmlpull.v1.XmlPullParserException;
|
import org.xmlpull.v1.XmlSerializer;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* Utility class to read/write subtype.xml.
|
*/
|
final class AdditionalSubtypeUtils {
|
private static final String TAG = "AdditionalSubtypeUtils";
|
|
private static final String SYSTEM_PATH = "system";
|
private static final String INPUT_METHOD_PATH = "inputmethod";
|
private static final String ADDITIONAL_SUBTYPES_FILE_NAME = "subtypes.xml";
|
private static final String NODE_SUBTYPES = "subtypes";
|
private static final String NODE_SUBTYPE = "subtype";
|
private static final String NODE_IMI = "imi";
|
private static final String ATTR_ID = "id";
|
private static final String ATTR_LABEL = "label";
|
private static final String ATTR_ICON = "icon";
|
private static final String ATTR_IME_SUBTYPE_ID = "subtypeId";
|
private static final String ATTR_IME_SUBTYPE_LOCALE = "imeSubtypeLocale";
|
private static final String ATTR_IME_SUBTYPE_LANGUAGE_TAG = "languageTag";
|
private static final String ATTR_IME_SUBTYPE_MODE = "imeSubtypeMode";
|
private static final String ATTR_IME_SUBTYPE_EXTRA_VALUE = "imeSubtypeExtraValue";
|
private static final String ATTR_IS_AUXILIARY = "isAuxiliary";
|
private static final String ATTR_IS_ASCII_CAPABLE = "isAsciiCapable";
|
|
private AdditionalSubtypeUtils() {
|
}
|
|
/**
|
* Returns a {@link File} that represents the directory at which subtype.xml will be placed.
|
*
|
* @param userId User ID with with subtype.xml path should be determined.
|
* @return {@link File} that represents the directory.
|
*/
|
@NonNull
|
private static File getInputMethodDir(@UserIdInt int userId) {
|
final File systemDir = userId == UserHandle.USER_SYSTEM
|
? new File(Environment.getDataDirectory(), SYSTEM_PATH)
|
: Environment.getUserSystemDirectory(userId);
|
return new File(systemDir, INPUT_METHOD_PATH);
|
}
|
|
/**
|
* Returns an {@link AtomicFile} to read/write additional subtype for the given user id.
|
*
|
* @param inputMethodDir Directory at which subtype.xml will be placed
|
* @return {@link AtomicFile} to be used to read/write additional subtype
|
*/
|
@NonNull
|
private static AtomicFile getAdditionalSubtypeFile(File inputMethodDir) {
|
final File subtypeFile = new File(inputMethodDir, ADDITIONAL_SUBTYPES_FILE_NAME);
|
return new AtomicFile(subtypeFile, "input-subtypes");
|
}
|
|
/**
|
* Write additional subtypes into "subtype.xml".
|
*
|
* <p>This method does not confer any data/file locking semantics. Caller must make sure that
|
* multiple threads are not calling this method at the same time for the same {@code userId}.
|
* </p>
|
*
|
* @param allSubtypes {@link ArrayMap} from IME ID to additional subtype list. Passing an empty
|
* map deletes the file.
|
* @param methodMap {@link ArrayMap} from IME ID to {@link InputMethodInfo}.
|
* @param userId The user ID to be associated with.
|
*/
|
static void save(ArrayMap<String, List<InputMethodSubtype>> allSubtypes,
|
ArrayMap<String, InputMethodInfo> methodMap, @UserIdInt int userId) {
|
final File inputMethodDir = getInputMethodDir(userId);
|
|
if (allSubtypes.isEmpty()) {
|
if (!inputMethodDir.exists()) {
|
// Even the parent directory doesn't exist. There is nothing to clean up.
|
return;
|
}
|
final AtomicFile subtypesFile = getAdditionalSubtypeFile(inputMethodDir);
|
if (subtypesFile.exists()) {
|
subtypesFile.delete();
|
}
|
if (FileUtils.listFilesOrEmpty(inputMethodDir).length == 0) {
|
if (!inputMethodDir.delete()) {
|
Slog.e(TAG, "Failed to delete the empty parent directory " + inputMethodDir);
|
}
|
}
|
return;
|
}
|
|
if (!inputMethodDir.exists() && !inputMethodDir.mkdirs()) {
|
Slog.e(TAG, "Failed to create a parent directory " + inputMethodDir);
|
return;
|
}
|
|
// Safety net for the case that this function is called before methodMap is set.
|
final boolean isSetMethodMap = methodMap != null && methodMap.size() > 0;
|
FileOutputStream fos = null;
|
final AtomicFile subtypesFile = getAdditionalSubtypeFile(inputMethodDir);
|
try {
|
fos = subtypesFile.startWrite();
|
final XmlSerializer out = new FastXmlSerializer();
|
out.setOutput(fos, StandardCharsets.UTF_8.name());
|
out.startDocument(null, true);
|
out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
|
out.startTag(null, NODE_SUBTYPES);
|
for (String imiId : allSubtypes.keySet()) {
|
if (isSetMethodMap && !methodMap.containsKey(imiId)) {
|
Slog.w(TAG, "IME uninstalled or not valid.: " + imiId);
|
continue;
|
}
|
out.startTag(null, NODE_IMI);
|
out.attribute(null, ATTR_ID, imiId);
|
final List<InputMethodSubtype> subtypesList = allSubtypes.get(imiId);
|
final int numSubtypes = subtypesList.size();
|
for (int i = 0; i < numSubtypes; ++i) {
|
final InputMethodSubtype subtype = subtypesList.get(i);
|
out.startTag(null, NODE_SUBTYPE);
|
if (subtype.hasSubtypeId()) {
|
out.attribute(null, ATTR_IME_SUBTYPE_ID,
|
String.valueOf(subtype.getSubtypeId()));
|
}
|
out.attribute(null, ATTR_ICON, String.valueOf(subtype.getIconResId()));
|
out.attribute(null, ATTR_LABEL, String.valueOf(subtype.getNameResId()));
|
out.attribute(null, ATTR_IME_SUBTYPE_LOCALE, subtype.getLocale());
|
out.attribute(null, ATTR_IME_SUBTYPE_LANGUAGE_TAG,
|
subtype.getLanguageTag());
|
out.attribute(null, ATTR_IME_SUBTYPE_MODE, subtype.getMode());
|
out.attribute(null, ATTR_IME_SUBTYPE_EXTRA_VALUE, subtype.getExtraValue());
|
out.attribute(null, ATTR_IS_AUXILIARY,
|
String.valueOf(subtype.isAuxiliary() ? 1 : 0));
|
out.attribute(null, ATTR_IS_ASCII_CAPABLE,
|
String.valueOf(subtype.isAsciiCapable() ? 1 : 0));
|
out.endTag(null, NODE_SUBTYPE);
|
}
|
out.endTag(null, NODE_IMI);
|
}
|
out.endTag(null, NODE_SUBTYPES);
|
out.endDocument();
|
subtypesFile.finishWrite(fos);
|
} catch (java.io.IOException e) {
|
Slog.w(TAG, "Error writing subtypes", e);
|
if (fos != null) {
|
subtypesFile.failWrite(fos);
|
}
|
}
|
}
|
|
/**
|
* Read additional subtypes from "subtype.xml".
|
*
|
* <p>This method does not confer any data/file locking semantics. Caller must make sure that
|
* multiple threads are not calling this method at the same time for the same {@code userId}.
|
* </p>
|
*
|
* @param allSubtypes {@link ArrayMap} from IME ID to additional subtype list. This parameter
|
* will be used to return the result.
|
* @param userId The user ID to be associated with.
|
*/
|
static void load(@NonNull ArrayMap<String, List<InputMethodSubtype>> allSubtypes,
|
@UserIdInt int userId) {
|
allSubtypes.clear();
|
|
final AtomicFile subtypesFile = getAdditionalSubtypeFile(getInputMethodDir(userId));
|
if (!subtypesFile.exists()) {
|
// Not having the file means there is no additional subtype.
|
return;
|
}
|
try (FileInputStream fis = subtypesFile.openRead()) {
|
final XmlPullParser parser = Xml.newPullParser();
|
parser.setInput(fis, StandardCharsets.UTF_8.name());
|
int type = parser.getEventType();
|
// Skip parsing until START_TAG
|
while (true) {
|
type = parser.next();
|
if (type == XmlPullParser.START_TAG || type == XmlPullParser.END_DOCUMENT) {
|
break;
|
}
|
}
|
String firstNodeName = parser.getName();
|
if (!NODE_SUBTYPES.equals(firstNodeName)) {
|
throw new XmlPullParserException("Xml doesn't start with subtypes");
|
}
|
final int depth = parser.getDepth();
|
String currentImiId = null;
|
ArrayList<InputMethodSubtype> tempSubtypesArray = null;
|
while (((type = parser.next()) != XmlPullParser.END_TAG
|
|| parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
|
if (type != XmlPullParser.START_TAG) {
|
continue;
|
}
|
final String nodeName = parser.getName();
|
if (NODE_IMI.equals(nodeName)) {
|
currentImiId = parser.getAttributeValue(null, ATTR_ID);
|
if (TextUtils.isEmpty(currentImiId)) {
|
Slog.w(TAG, "Invalid imi id found in subtypes.xml");
|
continue;
|
}
|
tempSubtypesArray = new ArrayList<>();
|
allSubtypes.put(currentImiId, tempSubtypesArray);
|
} else if (NODE_SUBTYPE.equals(nodeName)) {
|
if (TextUtils.isEmpty(currentImiId) || tempSubtypesArray == null) {
|
Slog.w(TAG, "IME uninstalled or not valid.: " + currentImiId);
|
continue;
|
}
|
final int icon = Integer.parseInt(
|
parser.getAttributeValue(null, ATTR_ICON));
|
final int label = Integer.parseInt(
|
parser.getAttributeValue(null, ATTR_LABEL));
|
final String imeSubtypeLocale =
|
parser.getAttributeValue(null, ATTR_IME_SUBTYPE_LOCALE);
|
final String languageTag =
|
parser.getAttributeValue(null, ATTR_IME_SUBTYPE_LANGUAGE_TAG);
|
final String imeSubtypeMode =
|
parser.getAttributeValue(null, ATTR_IME_SUBTYPE_MODE);
|
final String imeSubtypeExtraValue =
|
parser.getAttributeValue(null, ATTR_IME_SUBTYPE_EXTRA_VALUE);
|
final boolean isAuxiliary = "1".equals(String.valueOf(
|
parser.getAttributeValue(null, ATTR_IS_AUXILIARY)));
|
final boolean isAsciiCapable = "1".equals(String.valueOf(
|
parser.getAttributeValue(null, ATTR_IS_ASCII_CAPABLE)));
|
final InputMethodSubtype.InputMethodSubtypeBuilder
|
builder = new InputMethodSubtype.InputMethodSubtypeBuilder()
|
.setSubtypeNameResId(label)
|
.setSubtypeIconResId(icon)
|
.setSubtypeLocale(imeSubtypeLocale)
|
.setLanguageTag(languageTag)
|
.setSubtypeMode(imeSubtypeMode)
|
.setSubtypeExtraValue(imeSubtypeExtraValue)
|
.setIsAuxiliary(isAuxiliary)
|
.setIsAsciiCapable(isAsciiCapable);
|
final String subtypeIdString =
|
parser.getAttributeValue(null, ATTR_IME_SUBTYPE_ID);
|
if (subtypeIdString != null) {
|
builder.setSubtypeId(Integer.parseInt(subtypeIdString));
|
}
|
tempSubtypesArray.add(builder.build());
|
}
|
}
|
} catch (XmlPullParserException | IOException | NumberFormatException e) {
|
Slog.w(TAG, "Error reading subtypes", e);
|
}
|
}
|
}
|
