Added DeviceConfig application

Change-Id: Ibed1430fca56506bcc07dfc07c9494fdbf304e06

2 files changed, 768 insertions, 0 deletions

diff --git a/apps/DeviceConfig/src/com/example/android/deviceconfig/ConfigGenerator.java b/apps/DeviceConfig/src/com/example/android/deviceconfig/ConfigGenerator.java
new file mode 100644
index 0000000..b2b08c6
--- /dev/null
+++ b/apps/DeviceConfig/src/com/example/android/deviceconfig/ConfigGenerator.java
@@ -0,0 +1,635 @@
+/*
+ * 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.example.android.deviceconfig;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.List;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Text;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.hardware.Camera;
+import android.hardware.Camera.CameraInfo;
+import android.os.Environment;
+import android.os.StatFs;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.widget.Toast;
+
+public class ConfigGenerator {
+    private Context mCtx;
+
+    public static final String NS_DEVICES_XSD = "http://schemas.android.com/sdk/devices/1";
+
+    /**
+     * The "devices" element is the root element of this schema.
+     *
+     * It must contain one or more "device" elements that each define the
+     * hardware, software, and states for a given device.
+     */
+    public static final String NODE_DEVICES = "devices";
+
+    /**
+     * A "device" element contains a "hardware" element, a "software" element
+     * for each API version it supports, and a "state" element for each possible
+     * state the device could be in.
+     */
+    public static final String NODE_DEVICE = "device";
+
+    /**
+     * The "hardware" element contains all of the hardware information for a
+     * given device.
+     */
+    public static final String NODE_HARDWARE = "hardware";
+
+    /**
+     * The "software" element contains all of the software information for an
+     * API version of the given device.
+     */
+    public static final String NODE_SOFTWARE = "software";
+
+    /**
+     * The "state" element contains all of the parameters for a given state of
+     * the device. It's also capable of redefining hardware configurations if
+     * they change based on state.
+     */
+
+    public static final String NODE_STATE = "state";
+
+    public static final String NODE_KEYBOARD = "keyboard";
+    public static final String NODE_TOUCH = "touch";
+    public static final String NODE_GL_EXTENSIONS = "gl-extensions";
+    public static final String NODE_GL_VERSION = "gl-version";
+    public static final String NODE_NETWORKING = "networking";
+    public static final String NODE_REMOVABLE_STORAGE = "removable-storage";
+    public static final String NODE_FLASH = "flash";
+    public static final String NODE_LIVE_WALLPAPER_SUPPORT = "live-wallpaper-support";
+    public static final String NODE_BUTTONS = "buttons";
+    public static final String NODE_CAMERA = "camera";
+    public static final String NODE_LOCATION = "location";
+    public static final String NODE_GPU = "gpu";
+    public static final String NODE_DOCK = "dock";
+    public static final String NODE_YDPI = "ydpi";
+    public static final String NODE_PLUGGED_IN = "plugged-in";
+    public static final String NODE_Y_DIMENSION = "y-dimension";
+    public static final String NODE_SCREEN_RATIO = "screen-ratio";
+    public static final String NODE_NAV_STATE = "nav-state";
+    public static final String NODE_MIC = "mic";
+    public static final String NODE_RAM = "ram";
+    public static final String NODE_XDPI = "xdpi";
+    public static final String NODE_DIMENSIONS = "dimensions";
+    public static final String NODE_ABI = "abi";
+    public static final String NODE_MECHANISM = "mechanism";
+    public static final String NODE_MULTITOUCH = "multitouch";
+    public static final String NODE_NAV = "nav";
+    public static final String NODE_PIXEL_DENSITY = "pixel-density";
+    public static final String NODE_SCREEN_ORIENTATION = "screen-orientation";
+    public static final String NODE_AUTOFOCUS = "autofocus";
+    public static final String NODE_SCREEN_SIZE = "screen-size";
+    public static final String NODE_DESCRIPTION = "description";
+    public static final String NODE_BLUETOOTH_PROFILES = "bluetooth-profiles";
+    public static final String NODE_SCREEN = "screen";
+    public static final String NODE_SENSORS = "sensors";
+    public static final String NODE_DIAGONAL_LENGTH = "diagonal-length";
+    public static final String NODE_SCREEN_TYPE = "screen-type";
+    public static final String NODE_KEYBOARD_STATE = "keyboard-state";
+    public static final String NODE_X_DIMENSION = "x-dimension";
+    public static final String NODE_CPU = "cpu";
+    public static final String NODE_INTERNAL_STORAGE = "internal-storage";
+    public static final String NODE_NAME = "name";
+    public static final String NODE_MANUFACTURER = "manufacturer";
+    public static final String NODE_API_LEVEL = "api-level";
+    public static final String ATTR_DEFAULT = "default";
+    public static final String ATTR_UNIT = "unit";
+    public static final String UNIT_BYTES = "B";
+    public static final String UNIT_KIBIBYTES = "KiB";
+    public static final String UNIT_MEBIBYTES = "MiB";
+    public static final String UNIT_GIBIBYTES = "GiB";
+    public static final String UNIT_TEBIBYTES = "TiB";
+    public static final String LOCAL_NS = "d";
+    public static final String PREFIX = LOCAL_NS + ":";
+
+    private static final String TAG = "ConfigGenerator";
+
+    public ConfigGenerator(Context ctx) {
+        mCtx = ctx;
+    }
+
+    @SuppressLint("WorldReadableFiles")
+    public String generateConfig() {
+        Resources resources = mCtx.getResources();
+        PackageManager packageMgr = mCtx.getPackageManager();
+        DisplayMetrics metrics = resources.getDisplayMetrics();
+        Configuration config = resources.getConfiguration();
+
+        try {
+            Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+
+            Element devices = doc.createElement(PREFIX + NODE_DEVICES);
+            devices.setAttribute(XMLConstants.XMLNS_ATTRIBUTE + ":xsi",
+                    XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI);
+            devices.setAttribute(XMLConstants.XMLNS_ATTRIBUTE + ":" + LOCAL_NS, NS_DEVICES_XSD);
+            doc.appendChild(devices);
+
+            Element device = doc.createElement(PREFIX + NODE_DEVICE);
+            devices.appendChild(device);
+
+            Element name = doc.createElement(PREFIX + NODE_NAME);
+            device.appendChild(name);
+            name.appendChild(doc.createTextNode(android.os.Build.MODEL));
+            Element manufacturer = doc.createElement(PREFIX + NODE_MANUFACTURER);
+            device.appendChild(manufacturer);
+            manufacturer.appendChild(doc.createTextNode(android.os.Build.MANUFACTURER));
+
+            Element hardware = doc.createElement(PREFIX + NODE_HARDWARE);
+            device.appendChild(hardware);
+
+            Element screen = doc.createElement(PREFIX + NODE_SCREEN);
+            hardware.appendChild(screen);
+
+            Element screenSize = doc.createElement(PREFIX + NODE_SCREEN_SIZE);
+            screen.appendChild(screenSize);
+            Text screenSizeText;
+            switch (config.screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) {
+            case Configuration.SCREENLAYOUT_SIZE_SMALL:
+                screenSizeText = doc.createTextNode("small");
+                break;
+            case Configuration.SCREENLAYOUT_SIZE_NORMAL:
+                screenSizeText = doc.createTextNode("normal");
+                break;
+            case Configuration.SCREENLAYOUT_SIZE_LARGE:
+                screenSizeText = doc.createTextNode("large");
+                break;
+            case Configuration.SCREENLAYOUT_SIZE_XLARGE:
+                screenSizeText = doc.createTextNode("xlarge");
+                break;
+            default:
+                screenSizeText = doc.createTextNode(" ");
+                break;
+            }
+            screenSize.appendChild(screenSizeText);
+
+            Element diagonalLength = doc.createElement(PREFIX + NODE_DIAGONAL_LENGTH);
+            screen.appendChild(diagonalLength);
+            double xin = metrics.widthPixels / metrics.xdpi;
+            double yin = metrics.heightPixels / metrics.ydpi;
+            double diag = Math.sqrt(Math.pow(xin, 2) + Math.pow(yin, 2));
+            diagonalLength.appendChild(doc.createTextNode(String.format("%1$.2f", diag)));
+
+            Element pixelDensity = doc.createElement(PREFIX + NODE_PIXEL_DENSITY);
+            screen.appendChild(pixelDensity);
+            Text pixelDensityText;
+            switch (metrics.densityDpi) {
+            case DisplayMetrics.DENSITY_LOW:
+                pixelDensityText = doc.createTextNode("ldpi");
+                break;
+            case DisplayMetrics.DENSITY_MEDIUM:
+                pixelDensityText = doc.createTextNode("mdpi");
+                break;
+            case DisplayMetrics.DENSITY_TV:
+                pixelDensityText = doc.createTextNode("tvdpi");
+                break;
+            case DisplayMetrics.DENSITY_HIGH:
+                pixelDensityText = doc.createTextNode("hdpi");
+                break;
+            case DisplayMetrics.DENSITY_XHIGH:
+                pixelDensityText = doc.createTextNode("xhdpi");
+                break;
+            default:
+                pixelDensityText = doc.createTextNode(" ");
+            }
+            pixelDensity.appendChild(pixelDensityText);
+
+            Element screenRatio = doc.createElement(PREFIX + NODE_SCREEN_RATIO);
+            screen.appendChild(screenRatio);
+            Text screenRatioText;
+            switch (config.screenLayout & Configuration.SCREENLAYOUT_LONG_MASK) {
+            case Configuration.SCREENLAYOUT_LONG_YES:
+                screenRatioText = doc.createTextNode("long");
+                break;
+            case Configuration.SCREENLAYOUT_LONG_NO:
+                screenRatioText = doc.createTextNode("notlong");
+                break;
+            default:
+                screenRatioText = doc.createTextNode(" ");
+                break;
+            }
+            screenRatio.appendChild(screenRatioText);
+
+            Element dimensions = doc.createElement(PREFIX + NODE_DIMENSIONS);
+            screen.appendChild(dimensions);
+
+            Element xDimension = doc.createElement(PREFIX + NODE_X_DIMENSION);
+            dimensions.appendChild(xDimension);
+            xDimension.appendChild(doc.createTextNode(Integer.toString(metrics.widthPixels)));
+
+            Element yDimension = doc.createElement(PREFIX + NODE_Y_DIMENSION);
+            dimensions.appendChild(yDimension);
+            yDimension.appendChild(doc.createTextNode(Integer.toString(metrics.heightPixels)));
+
+            Element xdpi = doc.createElement(PREFIX + NODE_XDPI);
+            screen.appendChild(xdpi);
+            xdpi.appendChild(doc.createTextNode(Double.toString(metrics.xdpi)));
+
+            Element ydpi = doc.createElement(PREFIX + NODE_YDPI);
+            screen.appendChild(ydpi);
+            ydpi.appendChild(doc.createTextNode(Double.toString(metrics.ydpi)));
+
+            Element touch = doc.createElement(PREFIX + NODE_TOUCH);
+            screen.appendChild(touch);
+
+            Element multitouch = doc.createElement(PREFIX + NODE_MULTITOUCH);
+            touch.appendChild(multitouch);
+            Text multitouchText;
+            if (packageMgr
+                    .hasSystemFeature(PackageManager.FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND)) {
+                multitouchText = doc.createTextNode("jazz-hands");
+            } else if (packageMgr
+                    .hasSystemFeature(PackageManager.FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT)) {
+                multitouchText = doc.createTextNode("distinct");
+            } else if (packageMgr.hasSystemFeature(PackageManager.FEATURE_TOUCHSCREEN_MULTITOUCH)) {
+                multitouchText = doc.createTextNode("basic");
+            } else {
+                multitouchText = doc.createTextNode("none");
+            }
+            multitouch.appendChild(multitouchText);
+
+            Element mechanism = doc.createElement(PREFIX + NODE_MECHANISM);
+            touch.appendChild(mechanism);
+            Text mechanismText;
+            switch (config.touchscreen) {
+            case Configuration.TOUCHSCREEN_STYLUS:
+                mechanismText = doc.createTextNode("stylus");
+            case Configuration.TOUCHSCREEN_FINGER:
+                mechanismText = doc.createTextNode("finger");
+            case Configuration.TOUCHSCREEN_NOTOUCH:
+                mechanismText = doc.createTextNode("notouch");
+            default:
+                mechanismText = doc.createTextNode(" ");
+            }
+            mechanism.appendChild(mechanismText);
+
+            // Create an empty place holder node for screen-type since we can't
+            // actually determine it
+
+            Element screenType = doc.createElement(PREFIX + NODE_SCREEN_TYPE);
+            touch.appendChild(screenType);
+            screenType.appendChild(doc.createTextNode(" "));
+
+            Element networking = doc.createElement(PREFIX + NODE_NETWORKING);
+            hardware.appendChild(networking);
+            Text networkingText = doc.createTextNode("");
+            networking.appendChild(networkingText);
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_WIFI)) {
+                networkingText.appendData("\nWifi");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)) {
+                networkingText.appendData("\nBluetooth");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_NFC)) {
+                networkingText.appendData("\nNFC");
+            }
+
+            Element sensors = doc.createElement(PREFIX + NODE_SENSORS);
+            hardware.appendChild(sensors);
+            Text sensorsText = doc.createTextNode("");
+            sensors.appendChild(sensorsText);
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_SENSOR_ACCELEROMETER)) {
+                sensorsText.appendData("\nAccelerometer");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_SENSOR_BAROMETER)) {
+                sensorsText.appendData("\nBarometer");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_SENSOR_COMPASS)) {
+                sensorsText.appendData("\nCompass");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS)) {
+                sensorsText.appendData("\nGPS");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_SENSOR_GYROSCOPE)) {
+                sensorsText.appendData("\nGyroscope");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_SENSOR_LIGHT)) {
+                sensorsText.appendData("\nLightSensor");
+            }
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_SENSOR_PROXIMITY)) {
+                sensorsText.appendData("\nProximitySensor");
+            }
+
+            Element mic = doc.createElement(PREFIX + NODE_MIC);
+            hardware.appendChild(mic);
+            Text micText;
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_MICROPHONE)) {
+                micText = doc.createTextNode("true");
+            } else {
+                micText = doc.createTextNode("false");
+            }
+            mic.appendChild(micText);
+
+            if (android.os.Build.VERSION.SDK_INT >= 9){
+                List<Element> cameras = getCameraElements(doc);
+                for (Element cam : cameras){
+                    hardware.appendChild(cam);
+                }
+            } else {
+                Camera c = Camera.open();
+                Element camera = doc.createElement(PREFIX + NODE_CAMERA);
+                hardware.appendChild(camera);
+                Element location = doc.createElement(PREFIX + NODE_LOCATION);
+                camera.appendChild(location);
+                // All camera's before API 9 were on the back
+                location.appendChild(doc.createTextNode("back"));
+                Camera.Parameters cParams = c.getParameters();
+                Element autofocus = doc.createElement(PREFIX + NODE_AUTOFOCUS);
+                camera.appendChild(autofocus);
+                List<String> foci = cParams.getSupportedFocusModes();
+                if (foci == null) {
+                    autofocus.appendChild(doc.createTextNode(" "));
+                } else if (foci.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
+                    autofocus.appendChild(doc.createTextNode("true"));
+                } else {
+                    autofocus.appendChild(doc.createTextNode("false"));
+                }
+
+                Element flash = doc.createElement(PREFIX + NODE_FLASH);
+                camera.appendChild(flash);
+                List<String> flashes = cParams.getSupportedFlashModes();
+                if (flashes == null || !flashes.contains(Camera.Parameters.FLASH_MODE_ON)) {
+                    flash.appendChild(doc.createTextNode("false"));
+                } else {
+                    flash.appendChild(doc.createTextNode("true"));
+                }
+                c.release();
+            }
+
+
+            Element keyboard = doc.createElement(PREFIX + NODE_KEYBOARD);
+            hardware.appendChild(keyboard);
+            Text keyboardText;
+            switch (config.keyboard) {
+            case Configuration.KEYBOARD_NOKEYS:
+                keyboardText = doc.createTextNode("nokeys");
+                break;
+            case Configuration.KEYBOARD_12KEY:
+                keyboardText = doc.createTextNode("12key");
+                break;
+            case Configuration.KEYBOARD_QWERTY:
+                keyboardText = doc.createTextNode("qwerty");
+                break;
+            default:
+                keyboardText = doc.createTextNode(" ");
+            }
+            keyboard.appendChild(keyboardText);
+
+            Element nav = doc.createElement(PREFIX + NODE_NAV);
+            hardware.appendChild(nav);
+            Text navText;
+            switch (config.navigation) {
+            case Configuration.NAVIGATION_DPAD:
+                navText = doc.createTextNode("dpad");
+            case Configuration.NAVIGATION_TRACKBALL:
+                navText = doc.createTextNode("trackball");
+            case Configuration.NAVIGATION_WHEEL:
+                navText = doc.createTextNode("wheel");
+            case Configuration.NAVIGATION_NONAV:
+                navText = doc.createTextNode("nonav");
+            default:
+                navText = doc.createTextNode(" ");
+            }
+            nav.appendChild(navText);
+
+            Element ram = doc.createElement(PREFIX + NODE_RAM);
+            hardware.appendChild(ram);
+            // totalMemory given in bytes, divide by 1048576 to get RAM in MiB
+            String line;
+            long ramAmount = 0;
+            String unit = UNIT_BYTES;
+            try {
+                BufferedReader meminfo = new BufferedReader(new FileReader("/proc/meminfo"));
+                while ((line = meminfo.readLine()) != null) {
+                    String[] vals = line.split("[\\s]+");
+                    if (vals[0].equals("MemTotal:")) {
+                        try {
+                            /*
+                             * We're going to want it as a string eventually,
+                             * but parsing it lets us validate it's actually a
+                             * number and something strange isn't going on
+                             */
+                            ramAmount = Long.parseLong(vals[1]);
+                            unit = vals[2];
+                            break;
+                        } catch (NumberFormatException e) {
+                            // Ignore
+                        }
+                    }
+                }
+                meminfo.close();
+            } catch (FileNotFoundException e) {
+                // Ignore
+            }
+            if (ramAmount > 0) {
+                if (unit.equals("B")) {
+                    unit = UNIT_BYTES;
+                } else if (unit.equals("kB")) {
+                    unit = UNIT_KIBIBYTES;
+                } else if (unit.equals("MB")) {
+                    unit = UNIT_MEBIBYTES;
+                } else if (unit.equals("GB")) {
+                    unit = UNIT_GIBIBYTES;
+                } else {
+                    unit = " ";
+                }
+            }
+            ram.setAttribute(ATTR_UNIT, unit);
+            ram.appendChild(doc.createTextNode(Long.toString(ramAmount)));
+
+            // Can't actually get whether we're using software buttons
+            Element buttons = doc.createElement(PREFIX + NODE_BUTTONS);
+            hardware.appendChild(buttons);
+            buttons.appendChild(doc.createTextNode(" "));
+
+            Element internalStorage = doc.createElement(PREFIX + NODE_INTERNAL_STORAGE);
+            hardware.appendChild(internalStorage);
+            StatFs rootStat = new StatFs(Environment.getRootDirectory().getAbsolutePath());
+            long bytesAvailable = rootStat.getBlockSize() * rootStat.getBlockCount();
+            long internalStorageSize = bytesAvailable / (1024 * 1024);
+            internalStorage.appendChild(doc.createTextNode(Long.toString(internalStorageSize)));
+            internalStorage.setAttribute(ATTR_UNIT, UNIT_MEBIBYTES);
+
+            Element externalStorage = doc.createElement(PREFIX + NODE_REMOVABLE_STORAGE);
+            hardware.appendChild(externalStorage);
+            externalStorage.appendChild(doc.createTextNode(" "));
+
+
+            // Don't know CPU, GPU types
+            Element cpu = doc.createElement(PREFIX + NODE_CPU);
+            hardware.appendChild(cpu);
+            cpu.appendChild(doc.createTextNode(" "));
+            Element gpu = doc.createElement(PREFIX + NODE_GPU);
+            hardware.appendChild(gpu);
+            gpu.appendChild(doc.createTextNode(" "));
+
+            Element abi = doc.createElement(PREFIX + NODE_ABI);
+            hardware.appendChild(abi);
+            Text abiText = doc.createTextNode("");
+            abi.appendChild(abiText);
+            abiText.appendData("\n" + android.os.Build.CPU_ABI);
+            abiText.appendData("\n" + android.os.Build.CPU_ABI2);
+
+            // Don't know about either the dock or plugged-in element
+            Element dock = doc.createElement(PREFIX + NODE_DOCK);
+            hardware.appendChild(dock);
+            dock.appendChild(doc.createTextNode(" "));
+
+            Element pluggedIn = doc.createElement(PREFIX + NODE_PLUGGED_IN);
+            hardware.appendChild(pluggedIn);
+            pluggedIn.appendChild(doc.createTextNode(" "));
+
+            Element software = doc.createElement(PREFIX + NODE_SOFTWARE);
+            device.appendChild(software);
+
+            Element apiLevel = doc.createElement(PREFIX + NODE_API_LEVEL);
+            software.appendChild(apiLevel);
+            apiLevel.appendChild(doc.createTextNode(Integer
+                    .toString(android.os.Build.VERSION.SDK_INT)));
+
+            Element liveWallpaperSupport = doc.createElement(PREFIX + NODE_LIVE_WALLPAPER_SUPPORT);
+            software.appendChild(liveWallpaperSupport);
+            if (packageMgr.hasSystemFeature(PackageManager.FEATURE_LIVE_WALLPAPER)) {
+                liveWallpaperSupport.appendChild(doc.createTextNode("true"));
+            } else {
+                liveWallpaperSupport.appendChild(doc.createTextNode("flase"));
+            }
+
+            Element bluetoothProfiles = doc.createElement(PREFIX + NODE_BLUETOOTH_PROFILES);
+            software.appendChild(bluetoothProfiles);
+            bluetoothProfiles.appendChild(doc.createTextNode(" "));
+
+            Element glVersion = doc.createElement(PREFIX + NODE_GL_VERSION);
+            software.appendChild(glVersion);
+            glVersion.appendChild(doc.createTextNode(" "));
+
+            Element glExtensions = doc.createElement(PREFIX + NODE_GL_EXTENSIONS);
+            software.appendChild(glExtensions);
+            glExtensions.appendChild(doc.createTextNode(" "));
+
+            Transformer tf = TransformerFactory.newInstance().newTransformer();
+            tf.setOutputProperty(OutputKeys.INDENT, "yes");
+            DOMSource source = new DOMSource(doc);
+            String filename = String.format("devices_%1$tm_%1$td_%1$ty.xml", Calendar.getInstance()
+                    .getTime());
+            File dir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
+            File outFile = new File(dir, filename);
+            FileOutputStream out = new FileOutputStream(new File(dir, filename));
+            StreamResult result = new StreamResult(out);
+            tf.transform(source, result);
+            out.flush();
+            out.close();
+            return outFile.getAbsolutePath();
+        } catch (ParserConfigurationException e) {
+            error("Parser config exception", e);
+        } catch (TransformerConfigurationException e) {
+            error("Transformer config exception", e);
+        } catch (TransformerFactoryConfigurationError e) {
+            error("TransformerFactory config exception", e);
+        } catch (TransformerException e) {
+            error("Error transforming", e);
+        } catch (IOException e) {
+            error("I/O Error", e);
+        }
+        return null;
+    }
+
+    @TargetApi(9)
+    private List<Element> getCameraElements(Document doc) {
+        List<Element> cList = new ArrayList<Element>();
+        for (int i = 0; i < Camera.getNumberOfCameras(); i++) {
+            Element camera = doc.createElement(PREFIX + NODE_CAMERA);
+            cList.add(camera);
+            Element location = doc.createElement(PREFIX + NODE_LOCATION);
+            camera.appendChild(location);
+            Text locationText;
+            Camera.CameraInfo cInfo = new Camera.CameraInfo();
+            Camera.getCameraInfo(i, cInfo);
+            if (cInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
+                locationText = doc.createTextNode("front");
+            } else if (cInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
+                locationText = doc.createTextNode("back");
+            } else {
+                locationText = doc.createTextNode(" ");
+            }
+            location.appendChild(locationText);
+
+            Camera c = Camera.open(i);
+            Camera.Parameters cParams = c.getParameters();
+
+            Element autofocus = doc.createElement(PREFIX + NODE_AUTOFOCUS);
+            camera.appendChild(autofocus);
+            List<String> foci = cParams.getSupportedFocusModes();
+            if (foci == null) {
+                autofocus.appendChild(doc.createTextNode(" "));
+            } else if (foci.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
+                autofocus.appendChild(doc.createTextNode("true"));
+            } else {
+                autofocus.appendChild(doc.createTextNode("false"));
+            }
+
+            Element flash = doc.createElement(PREFIX + NODE_FLASH);
+            camera.appendChild(flash);
+            List<String> flashes = cParams.getSupportedFlashModes();
+            if (flashes == null || !flashes.contains(Camera.Parameters.FLASH_MODE_ON)) {
+                flash.appendChild(doc.createTextNode("false"));
+            } else {
+                flash.appendChild(doc.createTextNode("true"));
+            }
+            c.release();
+        }
+        return cList;
+    }
+
+    private void error(String err, Throwable e) {
+        Toast.makeText(mCtx, "Error Generating Configuration", Toast.LENGTH_SHORT).show();
+        Log.e(TAG, err);
+        Log.e(TAG, e.getLocalizedMessage());
+    }
+}
diff --git a/apps/DeviceConfig/src/com/example/android/deviceconfig/MyActivity.java b/apps/DeviceConfig/src/com/example/android/deviceconfig/MyActivity.java
new file mode 100644
index 0000000..837d072
--- /dev/null
+++ b/apps/DeviceConfig/src/com/example/android/deviceconfig/MyActivity.java
@@ -0,0 +1,133 @@
+/*
+ * 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.example.android.deviceconfig;
+
+import java.io.File;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.net.Uri;
+import android.os.Bundle;
+import android.util.DisplayMetrics;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+import com.example.android.deviceconfig.R;
+
+public class MyActivity extends Activity implements OnClickListener {
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.main);
+
+        Button btn = (Button) findViewById(R.id.generateConfigButton);
+        btn.setOnClickListener(this);
+        Configuration config = getResources().getConfiguration();
+
+        TextView tv = (TextView) findViewById(R.id.keyboard_state_api);
+        if (tv != null) {
+            String separator = config.orientation == Configuration.ORIENTATION_PORTRAIT ? "\n" : "";
+            String foo = "keyboardHidden=" + separator;
+            if (config.keyboardHidden == Configuration.KEYBOARDHIDDEN_NO) {
+                foo += "EXPOSED";
+            } else if (config.keyboardHidden == Configuration.KEYBOARDHIDDEN_YES) {
+                foo += "HIDDEN";
+            } else if (config.keyboardHidden == Configuration.KEYBOARDHIDDEN_UNDEFINED) {
+                foo += "UNDEFINED";
+            } else {
+                foo += "?";
+            }
+            foo += "\nhardKeyboardHidden=" + separator;
+            if (config.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO) {
+                foo = foo + "EXPOSED";
+            } else if (config.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES) {
+                foo = foo + "HIDDEN";
+            } else if (config.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_UNDEFINED) {
+                foo = foo + "UNDEFINED";
+            } else {
+                foo = "?";
+            }
+
+            tv.setText(foo);
+        }
+
+        tv = (TextView) findViewById(R.id.nav_state_api);
+        if (tv != null) {
+            if (config.navigationHidden == Configuration.NAVIGATIONHIDDEN_NO) {
+                tv.setText("EXPOSED");
+            } else if (config.navigationHidden == Configuration.NAVIGATIONHIDDEN_YES) {
+                tv.setText("HIDDEN");
+            } else if (config.navigationHidden == Configuration.NAVIGATIONHIDDEN_UNDEFINED) {
+                tv.setText("UNDEFINED");
+            } else {
+                tv.setText("??");
+            }
+        }
+
+        DisplayMetrics metrics = getResources().getDisplayMetrics();
+
+
+        tv = (TextView) findViewById(R.id.size_api);
+        if (tv != null) {
+            int a = metrics.heightPixels;
+            int b = metrics.widthPixels;
+            tv.setText(b + "x" + a);
+        }
+
+        tv = (TextView) findViewById(R.id.xdpi);
+        if (tv != null) {
+            tv.setText(String.format("%f", metrics.xdpi));
+        }
+        tv = (TextView) findViewById(R.id.ydpi);
+        if (tv != null) {
+            tv.setText(String.format("%f", metrics.ydpi));
+        }
+
+        tv = (TextView) findViewById(R.id.scaled_density);
+        if (tv != null) {
+            tv.setText(String.format("%f", metrics.scaledDensity));
+        }
+
+        tv = (TextView) findViewById(R.id.font_scale);
+        if (tv != null) {
+            tv.setText(String.format("%f", config.fontScale));
+        }
+
+    }
+
+    public void onClick(View v) {
+        ConfigGenerator configGen = new ConfigGenerator(this);
+        final String filename = configGen.generateConfig();
+        if (filename != null) {
+            Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
+            emailIntent.setType("text/xml");
+            File devicesXml = new File(filename);
+            emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Device XML: " + devicesXml.getName());
+            emailIntent.putExtra(Intent.EXTRA_TEXT, "Note: This is intended to generate a base "
+                    + "XML description. After running this, you should double check the generated "
+                    + "information and add all of the missing fields.");
+            emailIntent.putExtra(Intent.EXTRA_STREAM,
+                    Uri.parse("file://" + devicesXml.getAbsolutePath()));
+            startActivity(emailIntent);
+        }
+    }
+
+}