| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.ide.eclipse.adt.internal.sdk; |
| |
| import com.android.ide.eclipse.adt.internal.resources.configurations.CountryCodeQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.FolderConfiguration; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.KeyboardStateQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.NavigationMethodQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.NetworkCodeQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.PixelDensityQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.ScreenDimensionQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.ScreenOrientationQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.ScreenRatioQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.ScreenSizeQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.TextInputMethodQualifier; |
| import com.android.ide.eclipse.adt.internal.resources.configurations.TouchScreenQualifier; |
| |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| /** |
| * Class representing a layout device. |
| * |
| * A Layout device is a collection of {@link FolderConfiguration} that can be used to render Android |
| * layout files. |
| * |
| * It also contains a single xdpi/ydpi that is independent of the {@link FolderConfiguration}. |
| * |
| * If the device is meant to represent a true device, then most of the FolderConfigurations' content |
| * should be identical, with only a few qualifiers (orientation, keyboard state) that would differ. |
| * However it is simpler to reuse the FolderConfiguration class (with the non changing qualifiers |
| * duplicated in each configuration) as it's what's being used by the rendering library. |
| * |
| * To create, edit and delete LayoutDevice objects, see {@link LayoutDeviceManager}. |
| * The class is not technically immutable but behaves as such outside of its package. |
| */ |
| public class LayoutDevice { |
| |
| private final String mName; |
| |
| /** editable map of the config */ |
| private Map<String, FolderConfiguration> mEditMap = new HashMap<String, FolderConfiguration>(); |
| /** unmodifiable map returned by {@link #getConfigs()}. */ |
| private Map<String, FolderConfiguration> mMap; |
| private float mXDpi = Float.NaN; |
| private float mYDpi = Float.NaN; |
| |
| LayoutDevice(String name) { |
| mName = name; |
| } |
| |
| /** |
| * Saves the Layout Device into a document under a given node |
| * @param doc the document. |
| * @param parentNode the parent node. |
| */ |
| void saveTo(Document doc, Element parentNode) { |
| // create the device node |
| Element deviceNode = createNode(doc, parentNode, LayoutDevicesXsd.NODE_DEVICE); |
| |
| // create the name attribute (no namespace on this one). |
| deviceNode.setAttribute(LayoutDevicesXsd.ATTR_NAME, mName); |
| |
| // create a default with the x/y dpi |
| Element defaultNode = createNode(doc, deviceNode, LayoutDevicesXsd.NODE_DEFAULT); |
| if (Float.isNaN(mXDpi) == false) { |
| Element xdpiNode = createNode(doc, defaultNode, LayoutDevicesXsd.NODE_XDPI); |
| xdpiNode.setTextContent(Float.toString(mXDpi)); |
| } |
| if (Float.isNaN(mYDpi) == false) { |
| Element xdpiNode = createNode(doc, defaultNode, LayoutDevicesXsd.NODE_YDPI); |
| xdpiNode.setTextContent(Float.toString(mYDpi)); |
| } |
| |
| // then save all the configs. |
| for (Entry<String, FolderConfiguration> entry : mEditMap.entrySet()) { |
| saveConfigTo(doc, deviceNode, entry.getKey(), entry.getValue()); |
| } |
| } |
| |
| /** |
| * Creates and returns a new NS-enabled node. |
| * @param doc the {@link Document} |
| * @param parentNode the parent node. The new node is appended to this one as a child. |
| * @param name the name of the node. |
| * @return the newly created node. |
| */ |
| private Element createNode(Document doc, Element parentNode, String name) { |
| Element newNode = doc.createElementNS( |
| LayoutDevicesXsd.NS_LAYOUT_DEVICE_XSD, name); |
| newNode.setPrefix(doc.lookupPrefix(LayoutDevicesXsd.NS_LAYOUT_DEVICE_XSD)); |
| parentNode.appendChild(newNode); |
| |
| return newNode; |
| } |
| |
| /** |
| * Saves a {@link FolderConfiguration} in a {@link Document}. |
| * @param doc the Document in which to save |
| * @param parent the parent node |
| * @param configName the name of the config |
| * @param config the config to save |
| */ |
| private void saveConfigTo(Document doc, Element parent, String configName, |
| FolderConfiguration config) { |
| Element configNode = createNode(doc, parent, LayoutDevicesXsd.NODE_CONFIG); |
| |
| // create the name attribute (no namespace on this one). |
| configNode.setAttribute(LayoutDevicesXsd.ATTR_NAME, configName); |
| |
| // now do the qualifiers |
| CountryCodeQualifier ccq = config.getCountryCodeQualifier(); |
| if (ccq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_COUNTRY_CODE); |
| node.setTextContent(Integer.toString(ccq.getCode())); |
| } |
| |
| NetworkCodeQualifier ncq = config.getNetworkCodeQualifier(); |
| if (ncq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_NETWORK_CODE); |
| node.setTextContent(Integer.toString(ncq.getCode())); |
| } |
| |
| ScreenSizeQualifier ssq = config.getScreenSizeQualifier(); |
| if (ssq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_SCREEN_SIZE); |
| node.setTextContent(ssq.getFolderSegment(null)); |
| } |
| |
| ScreenRatioQualifier srq = config.getScreenRatioQualifier(); |
| if (srq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_SCREEN_RATIO); |
| node.setTextContent(srq.getFolderSegment(null)); |
| } |
| |
| ScreenOrientationQualifier soq = config.getScreenOrientationQualifier(); |
| if (soq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_SCREEN_ORIENTATION); |
| node.setTextContent(soq.getFolderSegment(null)); |
| } |
| |
| PixelDensityQualifier pdq = config.getPixelDensityQualifier(); |
| if (pdq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_PIXEL_DENSITY); |
| node.setTextContent(pdq.getFolderSegment(null)); |
| } |
| |
| TouchScreenQualifier ttq = config.getTouchTypeQualifier(); |
| if (ttq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_TOUCH_TYPE); |
| node.setTextContent(ttq.getFolderSegment(null)); |
| } |
| |
| KeyboardStateQualifier ksq = config.getKeyboardStateQualifier(); |
| if (ksq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_KEYBOARD_STATE); |
| node.setTextContent(ksq.getFolderSegment(null)); |
| } |
| |
| TextInputMethodQualifier timq = config.getTextInputMethodQualifier(); |
| if (timq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_TEXT_INPUT_METHOD); |
| node.setTextContent(timq.getFolderSegment(null)); |
| } |
| |
| NavigationMethodQualifier nmq = config.getNavigationMethodQualifier(); |
| if (nmq != null) { |
| Element node = createNode(doc, configNode, LayoutDevicesXsd.NODE_NAV_METHOD); |
| node.setTextContent(nmq.getFolderSegment(null)); |
| } |
| |
| ScreenDimensionQualifier sdq = config.getScreenDimensionQualifier(); |
| if (sdq != null) { |
| Element sizeNode = createNode(doc, configNode, LayoutDevicesXsd.NODE_SCREEN_DIMENSION); |
| |
| Element node = createNode(doc, sizeNode, LayoutDevicesXsd.NODE_SIZE); |
| node.setTextContent(Integer.toString(sdq.getValue1())); |
| |
| node = createNode(doc, sizeNode, LayoutDevicesXsd.NODE_SIZE); |
| node.setTextContent(Integer.toString(sdq.getValue2())); |
| } |
| } |
| |
| void addConfig(String name, FolderConfiguration config) { |
| mEditMap.put(name, config); |
| _seal(); |
| } |
| |
| void addConfigs(Map<String, FolderConfiguration> configs) { |
| mEditMap.putAll(configs); |
| _seal(); |
| } |
| |
| void removeConfig(String name) { |
| mEditMap.remove(name); |
| _seal(); |
| } |
| |
| /** |
| * Adds config to the LayoutDevice. This is to be used to add plenty of configurations. |
| * It must be followed by {@link #_seal()}. |
| * @param name the name of the config |
| * @param config the config. |
| */ |
| void _addConfig(String name, FolderConfiguration config) { |
| mEditMap.put(name, config); |
| } |
| |
| void _seal() { |
| mMap = Collections.unmodifiableMap(mEditMap); |
| } |
| |
| void setXDpi(float xdpi) { |
| mXDpi = xdpi; |
| } |
| |
| void setYDpi(float ydpi) { |
| mYDpi = ydpi; |
| } |
| |
| public String getName() { |
| return mName; |
| } |
| |
| public Map<String, FolderConfiguration> getConfigs() { |
| return mMap; |
| } |
| |
| /** |
| * Returns the dpi of the Device screen in X. |
| * @return the dpi of screen or {@link Float#NaN} if it's not set. |
| */ |
| public float getXDpi() { |
| return mXDpi; |
| } |
| |
| /** |
| * Returns the dpi of the Device screen in Y. |
| * @return the dpi of screen or {@link Float#NaN} if it's not set. |
| */ |
| public float getYDpi() { |
| return mYDpi; |
| } |
| } |
