/*
* 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.sdklib.devices;
import static com.android.SdkConstants.VALUE_FALSE;
import static com.android.SdkConstants.VALUE_TRUE;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.dvlib.DeviceSchema;
import com.android.resources.Density;
import com.android.resources.Keyboard;
import com.android.resources.KeyboardState;
import com.android.resources.Navigation;
import com.android.resources.NavigationState;
import com.android.resources.ScreenOrientation;
import com.android.resources.ScreenRatio;
import com.android.resources.ScreenRound;
import com.android.resources.ScreenSize;
import com.android.resources.TouchScreen;
import com.android.resources.UiMode;
import com.google.common.base.Splitter;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.DefaultHandler;
import java.awt.Point;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.validation.Schema;
public class DeviceParser {
private static class DeviceHandler extends DefaultHandler {
private static final Splitter sSpaceSplitter = Splitter.on(' ').omitEmptyStrings();
private static final String ROUND_BOOT_PROP = "ro.emulator.circular";
private static final String CHIN_BOOT_PROP = "ro.emu.win_outset_bottom_px";
private final Table<String, String, Device> mDevices = HashBasedTable.create();
private final StringBuilder mStringAccumulator = new StringBuilder();
private final File mParentFolder;
private Meta mMeta;
private Hardware mHardware;
private Software mSoftware;
private State mState;
private Device.Builder mBuilder;
private Camera mCamera;
private Storage.Unit mUnit;
private String[] mBootProp;
public DeviceHandler(@Nullable File parentFolder) {
mParentFolder = parentFolder;
}
@NonNull
public Table<String, String, Device> getDevices() {
return mDevices;
}
@Override
public void startElement(String uri, String localName, String name, Attributes attributes)
throws SAXException {
if (DeviceSchema.NODE_DEVICE.equals(localName)) {
// Reset everything
mMeta = null;
mHardware = null;
mSoftware = null;
mState = null;
mCamera = null;
mBuilder = new Device.Builder();
} else if (DeviceSchema.NODE_META.equals(localName)) {
mMeta = new Meta();
} else if (DeviceSchema.NODE_HARDWARE.equals(localName)) {
mHardware = new Hardware();
} else if (DeviceSchema.NODE_SOFTWARE.equals(localName)) {
mSoftware = new Software();
} else if (DeviceSchema.NODE_STATE.equals(localName)) {
mState = new State();
// mState can embed a Hardware instance
mHardware = mHardware.deepCopy();
String defaultState = attributes.getValue(DeviceSchema.ATTR_DEFAULT);
if ("true".equals(defaultState) || "1".equals(defaultState)) {
mState.setDefaultState(true);
}
mState.setName(attributes.getValue(DeviceSchema.ATTR_NAME).trim());
} else if (DeviceSchema.NODE_CAMERA.equals(localName)) {
mCamera = new Camera();
} else if (DeviceSchema.NODE_RAM.equals(localName)
|| DeviceSchema.NODE_INTERNAL_STORAGE.equals(localName)
|| DeviceSchema.NODE_REMOVABLE_STORAGE.equals(localName)) {
mUnit = Storage.Unit.getEnum(attributes.getValue(DeviceSchema.ATTR_UNIT));
} else if (DeviceSchema.NODE_FRAME.equals(localName)) {
mMeta.setFrameOffsetLandscape(new Point());
mMeta.setFrameOffsetPortrait(new Point());
} else if (DeviceSchema.NODE_SCREEN.equals(localName)) {
mHardware.setScreen(new Screen());
} else if (DeviceSchema.NODE_BOOT_PROP.equals(localName)) {
mBootProp = new String[2];
}
mStringAccumulator.setLength(0);
}
@Override
public void characters(char[] ch, int start, int length) {
mStringAccumulator.append(ch, start, length);
}
@Override
public void endElement(String uri, String localName, String name) throws SAXException {
if (DeviceSchema.NODE_DEVICE.equals(localName)) {
Device device = mBuilder.build();
mDevices.put(device.getId(), device.getManufacturer(), device);
} else if (DeviceSchema.NODE_NAME.equals(localName)) {
mBuilder.setName(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_ID.equals(localName)) {
mBuilder.setId(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_MANUFACTURER.equals(localName)) {
mBuilder.setManufacturer(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_META.equals(localName)) {
mBuilder.setMeta(mMeta);
} else if (DeviceSchema.NODE_SOFTWARE.equals(localName)) {
mBuilder.addSoftware(mSoftware);
} else if (DeviceSchema.NODE_STATE.equals(localName)) {
mState.setHardware(mHardware);
mBuilder.addState(mState);
} else if (DeviceSchema.NODE_SIXTY_FOUR.equals(localName)) {
mMeta.setIconSixtyFour(new File(mParentFolder, getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_SIXTEEN.equals(localName)) {
mMeta.setIconSixteen(new File(mParentFolder, getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_PATH.equals(localName)) {
mMeta.setFrame(new File(mParentFolder, mStringAccumulator.toString().trim()));
} else if (DeviceSchema.NODE_PORTRAIT_X_OFFSET.equals(localName)) {
mMeta.getFrameOffsetPortrait().x = getInteger(mStringAccumulator);
} else if (DeviceSchema.NODE_PORTRAIT_Y_OFFSET.equals(localName)) {
mMeta.getFrameOffsetPortrait().y = getInteger(mStringAccumulator);
} else if (DeviceSchema.NODE_LANDSCAPE_X_OFFSET.equals(localName)) {
mMeta.getFrameOffsetLandscape().x = getInteger(mStringAccumulator);
} else if (DeviceSchema.NODE_LANDSCAPE_Y_OFFSET.equals(localName)) {
mMeta.getFrameOffsetLandscape().y = getInteger(mStringAccumulator);
} else if (DeviceSchema.NODE_SCREEN_SIZE.equals(localName)) {
mHardware.getScreen().setSize(ScreenSize.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_DIAGONAL_LENGTH.equals(localName)) {
mHardware.getScreen().setDiagonalLength(getDouble(mStringAccumulator));
} else if (DeviceSchema.NODE_PIXEL_DENSITY.equals(localName)) {
mHardware.getScreen().setPixelDensity(
Density.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_SCREEN_RATIO.equals(localName)) {
mHardware.getScreen().setRatio(
ScreenRatio.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_X_DIMENSION.equals(localName)) {
mHardware.getScreen().setXDimension(getInteger(mStringAccumulator));
} else if (DeviceSchema.NODE_Y_DIMENSION.equals(localName)) {
mHardware.getScreen().setYDimension(getInteger(mStringAccumulator));
} else if (DeviceSchema.NODE_XDPI.equals(localName)) {
mHardware.getScreen().setXdpi(getDouble(mStringAccumulator));
} else if (DeviceSchema.NODE_YDPI.equals(localName)) {
mHardware.getScreen().setYdpi(getDouble(mStringAccumulator));
} else if (DeviceSchema.NODE_MULTITOUCH.equals(localName)) {
mHardware.getScreen().setMultitouch(
Multitouch.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_MECHANISM.equals(localName)) {
mHardware.getScreen().setMechanism(
TouchScreen.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_SCREEN_TYPE.equals(localName)) {
mHardware.getScreen().setScreenType(
ScreenType.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_NETWORKING.equals(localName)) {
for (String n : getStringList(mStringAccumulator)) {
Network net = Network.getEnum(n);
if (net != null) {
mHardware.addNetwork(net);
}
}
} else if (DeviceSchema.NODE_SENSORS.equals(localName)) {
for (String s : getStringList(mStringAccumulator)) {
Sensor sens = Sensor.getEnum(s);
if (sens != null) {
mHardware.addSensor(sens);
}
}
} else if (DeviceSchema.NODE_MIC.equals(localName)) {
mHardware.setHasMic(getBool(mStringAccumulator));
} else if (DeviceSchema.NODE_CAMERA.equals(localName)) {
mHardware.addCamera(mCamera);
mCamera = null;
} else if (DeviceSchema.NODE_LOCATION.equals(localName)) {
CameraLocation location = CameraLocation.getEnum(getString(mStringAccumulator));
if (location != null) {
mCamera.setLocation(location);
}
} else if (DeviceSchema.NODE_AUTOFOCUS.equals(localName)) {
mCamera.setFlash(getBool(mStringAccumulator));
} else if (DeviceSchema.NODE_FLASH.equals(localName)) {
mCamera.setFlash(getBool(mStringAccumulator));
} else if (DeviceSchema.NODE_KEYBOARD.equals(localName)) {
mHardware.setKeyboard(Keyboard.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_NAV.equals(localName)) {
mHardware.setNav(Navigation.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_RAM.equals(localName)) {
int val = getInteger(mStringAccumulator);
mHardware.setRam(new Storage(val, mUnit));
} else if (DeviceSchema.NODE_BUTTONS.equals(localName)) {
ButtonType buttonType = ButtonType.getEnum(getString(mStringAccumulator));
if (buttonType != null) {
mHardware.setButtonType(buttonType);
}
} else if (DeviceSchema.NODE_INTERNAL_STORAGE.equals(localName)) {
for (String s : getStringList(mStringAccumulator)) {
int val = Integer.parseInt(s);
mHardware.addInternalStorage(new Storage(val, mUnit));
}
} else if (DeviceSchema.NODE_REMOVABLE_STORAGE.equals(localName)) {
for (String s : getStringList(mStringAccumulator)) {
if (s != null && !s.isEmpty()) {
int val = Integer.parseInt(s);
mHardware.addRemovableStorage(new Storage(val, mUnit));
}
}
} else if (DeviceSchema.NODE_CPU.equals(localName)) {
mHardware.setCpu(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_GPU.equals(localName)) {
mHardware.setGpu(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_ABI.equals(localName)) {
for (String s : getStringList(mStringAccumulator)) {
Abi abi = Abi.getEnum(s);
if (abi != null) {
mHardware.addSupportedAbi(abi);
}
}
} else if (DeviceSchema.NODE_DOCK.equals(localName)) {
for (String s : getStringList(mStringAccumulator)) {
UiMode d = UiMode.getEnum(s);
if (d != null) {
mHardware.addSupportedUiMode(d);
}
}
} else if (DeviceSchema.NODE_POWER_TYPE.equals(localName)) {
PowerType type = PowerType.getEnum(getString(mStringAccumulator));
if (type != null) {
mHardware.setChargeType(type);
}
} else if (DeviceSchema.NODE_API_LEVEL.equals(localName)) {
String val = getString(mStringAccumulator);
// Can be one of 5 forms:
// 1
// 1-2
// 1-
// -2
// -
int index;
if (val.charAt(0) == '-') {
if (val.length() == 1) { // -
mSoftware.setMinSdkLevel(0);
mSoftware.setMaxSdkLevel(Integer.MAX_VALUE);
} else { // -2
// Remove the front dash and any whitespace between it
// and the upper bound.
val = val.substring(1).trim();
mSoftware.setMinSdkLevel(0);
mSoftware.setMaxSdkLevel(Integer.parseInt(val));
}
} else if ((index = val.indexOf('-')) > 0) {
if (index == val.length() - 1) { // 1-
// Strip the last dash and any whitespace between it and
// the lower bound.
val = val.substring(0, val.length() - 1).trim();
mSoftware.setMinSdkLevel(Integer.parseInt(val));
mSoftware.setMaxSdkLevel(Integer.MAX_VALUE);
} else { // 1-2
String min = val.substring(0, index).trim();
String max = val.substring(index + 1);
mSoftware.setMinSdkLevel(Integer.parseInt(min));
mSoftware.setMaxSdkLevel(Integer.parseInt(max));
}
} else { // 1
int apiLevel = Integer.parseInt(val);
mSoftware.setMinSdkLevel(apiLevel);
mSoftware.setMaxSdkLevel(apiLevel);
}
} else if (DeviceSchema.NODE_LIVE_WALLPAPER_SUPPORT.equals(localName)) {
mSoftware.setLiveWallpaperSupport(getBool(mStringAccumulator));
} else if (DeviceSchema.NODE_BLUETOOTH_PROFILES.equals(localName)) {
for (String s : getStringList(mStringAccumulator)) {
BluetoothProfile profile = BluetoothProfile.getEnum(s);
if (profile != null) {
mSoftware.addBluetoothProfile(profile);
}
}
} else if (DeviceSchema.NODE_GL_VERSION.equals(localName)) {
// Guaranteed to be in the form [\d]\.[\d]
mSoftware.setGlVersion(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_GL_EXTENSIONS.equals(localName)) {
mSoftware.addAllGlExtensions(getStringList(mStringAccumulator));
} else if (DeviceSchema.NODE_DESCRIPTION.equals(localName)) {
mState.setDescription(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_SCREEN_ORIENTATION.equals(localName)) {
mState.setOrientation(ScreenOrientation.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_KEYBOARD_STATE.equals(localName)) {
mState.setKeyState(KeyboardState.getEnum(getString(mStringAccumulator)));
} else if (DeviceSchema.NODE_NAV_STATE.equals(localName)) {
// We have an extra state in our XML for nonav that
// NavigationState doesn't contain
String navState = getString(mStringAccumulator);
if (navState.equals("nonav")) {
mState.setNavState(NavigationState.HIDDEN);
} else {
mState.setNavState(NavigationState.getEnum(getString(mStringAccumulator)));
}
} else if (DeviceSchema.NODE_STATUS_BAR.equals(localName)) {
mSoftware.setStatusBar(getBool(mStringAccumulator));
} else if (DeviceSchema.NODE_TAG_ID.equals(localName)) {
mBuilder.setTagId(getString(mStringAccumulator));
} else if (DeviceSchema.NODE_PROP_NAME.equals(localName)) {
assert mBootProp != null && mBootProp.length == 2;
mBootProp[0] = getString(mStringAccumulator);
} else if (DeviceSchema.NODE_PROP_VALUE.equals(localName)) {
assert mBootProp != null && mBootProp.length == 2;
mBootProp[1] = mStringAccumulator.toString();
} else if (DeviceSchema.NODE_BOOT_PROP.equals(localName)) {
assert mBootProp != null && mBootProp.length == 2 &&
mBootProp[0] != null && mBootProp[1] != null;
mBuilder.addBootProp(mBootProp[0], mBootProp[1]);
checkAndSetIfRound(mBootProp[0], mBootProp[1]);
mBootProp = null;
} else if (DeviceSchema.NODE_SKIN.equals(localName)) {
String path = getString(mStringAccumulator).replace('/', File.separatorChar);
mHardware.setSkinFile(new File(path));
}
}
@Override
public void error(SAXParseException e) throws SAXParseException {
throw e;
}
private void checkAndSetIfRound(String bootPropKey, String bootPropValue) {
// This is a ugly hack. To keep the existing devices.xmls working, the roundness of the
// screen is stored in a boot property.
ScreenRound roundness = null;
if (ROUND_BOOT_PROP.equals(bootPropKey)) {
if (VALUE_TRUE.equals(bootPropValue)) {
roundness = ScreenRound.ROUND;
} else if (VALUE_FALSE.equals(bootPropValue)) {
roundness = ScreenRound.NOTROUND;
}
for (State state : mBuilder.getAllStates()) {
state.getHardware().getScreen().setScreenRound(roundness);
}
}
if (CHIN_BOOT_PROP.equals(bootPropKey)) {
int chin = Integer.parseInt(bootPropValue);
for (State state : mBuilder.getAllStates()) {
state.getHardware().getScreen().setChin(chin);
}
}
}
private static List<String> getStringList(StringBuilder stringAccumulator) {
List<String> filteredStrings = new ArrayList<String>();
for (String s : sSpaceSplitter.split(stringAccumulator)) {
if (s != null && !s.isEmpty()) {
filteredStrings.add(s.trim());
}
}
return filteredStrings;
}
private static Boolean getBool(StringBuilder s) {
return equals(s, "true") || equals(s, "1");
}
private static double getDouble(StringBuilder stringAccumulator) {
return Double.parseDouble(getString(stringAccumulator));
}
private static String getString(StringBuilder s) {
return s.toString().trim();
}
private static boolean equals(StringBuilder s, String t) {
int start = 0;
int length = s.length();
while (start < length && Character.isWhitespace(s.charAt(start))) {
start++;
}
if (start == length) {
return t.isEmpty();
}
int end = length;
while (end > start && Character.isWhitespace(s.charAt(end - 1))) {
end--;
}
if (t.length() != (end - start)) {
return false;
}
for (int i = 0, n = t.length(), j = start; i < n; i++, j++) {
if (Character.toLowerCase(s.charAt(j)) != Character.toLowerCase(t.charAt(i))) {
return false;
}
}
return true;
}
private static int getInteger(StringBuilder stringAccumulator) {
return Integer.parseInt(getString(stringAccumulator));
}
}
private static final SAXParserFactory sParserFactory;
static {
sParserFactory = SAXParserFactory.newInstance();
sParserFactory.setNamespaceAware(true);
}
@NonNull
public static Table<String, String, Device> parse(@NonNull File devicesFile)
throws SAXException, ParserConfigurationException, IOException {
// stream closed by parseImpl.
@SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
InputStream stream = new FileInputStream(devicesFile);
return parseImpl(stream, devicesFile.getAbsoluteFile().getParentFile());
}
/**
* This method closes the stream.
*/
@NonNull
public static Table<String, String, Device> parse(@NonNull InputStream devices)
throws SAXException, IOException, ParserConfigurationException {
return parseImpl(devices, null);
}
/**
* After parsing, this method closes the stream.
*/
@NonNull
private static Table<String, String, Device> parseImpl(@NonNull InputStream devices, @Nullable File parentDir)
throws SAXException, IOException, ParserConfigurationException {
try {
if (!devices.markSupported()) {
//noinspection IOResourceOpenedButNotSafelyClosed
devices = new BufferedInputStream(devices); // closed in the finally block.
}
devices.mark(500000);
int version = DeviceSchema.getXmlSchemaVersion(devices);
SAXParser parser = getParser(version);
DeviceHandler dHandler = new DeviceHandler(parentDir);
devices.reset();
parser.parse(devices, dHandler);
return dHandler.getDevices();
}
finally {
// It's better to close the stream here since we may have created it above.
devices.close();
}
}
@NonNull
private static SAXParser getParser(int version) throws ParserConfigurationException, SAXException {
Schema schema = DeviceSchema.getSchema(version);
if (schema != null) {
sParserFactory.setSchema(schema);
}
return sParserFactory.newSAXParser();
}
}