am 477def1d: Merge changes I11495d03,If5816721 into gingerbread

Merge commit '477def1d4216f82bdfe58525131db88b384fc5a5' into gingerbread-plus-aosp

* commit '477def1d4216f82bdfe58525131db88b384fc5a5':
  Add a new UEventObserver subclass to broadcast an Intent whe USB state changes.
  DO NOT MERGE Add new permission to allow access to USB devices

core/java/android/hardware/Usb.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2010 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 android.hardware;
+
+/**
+ * Class for accessing USB state information.
+ * @hide
+ */
+public class Usb {
+   /**
+     * Broadcast Action:  A broadcast for USB connected events.
+     *
+     * The extras bundle will name/value pairs with the name of the function
+     * and a value of either {@link #USB_FUNCTION_ENABLED} or {@link #USB_FUNCTION_DISABLED}.
+     * Possible USB function names include {@link #USB_FUNCTION_MASS_STORAGE},
+     * {@link #USB_FUNCTION_ADB}, {@link #USB_FUNCTION_RNDIS} and {@link #USB_FUNCTION_MTP}.
+     */
+    public static final String ACTION_USB_CONNECTED =
+            "android.hardware.action.USB_CONNECTED";
+
+   /**
+     * Broadcast Action:  A broadcast for USB disconnected events.
+     */
+    public static final String ACTION_USB_DISCONNECTED =
+            "android.hardware.action.USB_DISCONNECTED";
+
+
+    /**
+     * Name of the USB mass storage USB function.
+     * Used in extras for the {@link #ACTION_USB_CONNECTED} broadcast
+     */
+    public static final String USB_FUNCTION_MASS_STORAGE = "mass_storage";
+
+    /**
+     * Name of the adb USB function.
+     * Used in extras for the {@link #ACTION_USB_CONNECTED} broadcast
+     */
+    public static final String USB_FUNCTION_ADB = "adb";
+
+    /**
+     * Name of the RNDIS ethernet USB function.
+     * Used in extras for the {@link #ACTION_USB_CONNECTED} broadcast
+     */
+    public static final String USB_FUNCTION_RNDIS = "rndis";
+
+    /**
+     * Name of the MTP USB function.
+     * Used in extras for the {@link #ACTION_USB_CONNECTED} broadcast
+     */
+    public static final String USB_FUNCTION_MTP = "mtp";
+
+    /**
+     * Value indicating that a USB function is enabled.
+     * Used in extras for the {@link #ACTION_USB_CONNECTED} broadcast
+     */
+    public static final String USB_FUNCTION_ENABLED = "enabled";
+
+    /**
+     * Value indicating that a USB function is disabled.
+     * Used in extras for the {@link #ACTION_USB_CONNECTED} broadcast
+     */
+    public static final String USB_FUNCTION_DISABLED = "disabled";
+}

core/res/AndroidManifest.xml

@@ -80,6 +80,9 @@
     <protected-broadcast android:name="android.bluetooth.device.action.PAIRING_REQUEST" />
     <protected-broadcast android:name="android.bluetooth.device.action.PAIRING_CANCEL" />
 
+    <protected-broadcast android:name="android.hardware.action.USB_CONNECTED" />
+    <protected-broadcast android:name="android.hardware.action.USB_DISCONNECTED" />
+
     <!-- ====================================== -->
     <!-- Permissions for things that cost money -->
     <!-- ====================================== -->
@@ -436,6 +439,14 @@
         android:label="@string/permlab_flashlight"
         android:description="@string/permdesc_flashlight" />
 
+    <!-- Allows an application to access USB devices
+         @hide -->
+    <permission android:name="android.permission.ACCESS_USB"
+        android:permissionGroup="android.permission-group.HARDWARE_CONTROLS"
+        android:protectionLevel="signatureOrSystem"
+        android:label="@string/permlab_accessUsb"
+        android:description="@string/permdesc_accessUsb" />
+
     <!-- Allows access to hardware peripherals.  Intended only for hardware testing -->
     <permission android:name="android.permission.HARDWARE_TEST"
         android:permissionGroup="android.permission-group.HARDWARE_CONTROLS"

core/res/res/values/strings.xml

@@ -938,6 +938,11 @@
     <string name="permdesc_flashlight">Allows the application to control
         the flashlight.</string>
 
+    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
+    <string name="permlab_accessUsb">access USB devices</string>
+    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
+    <string name="permdesc_accessUsb">Allows the application to access USB devices.</string>
+
     <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
     <string name="permlab_hardware_test">test hardware</string>
     <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->

services/java/com/android/server/SystemServer.java

@@ -96,6 +96,7 @@ class ServerThread extends Thread {
         BluetoothA2dpService bluetoothA2dp = null;
         HeadsetObserver headset = null;
         DockObserver dock = null;
+        UsbObserver usb = null;
         UiModeManagerService uiMode = null;
         RecognitionManagerService recognition = null;
         ThrottleService throttle = null;
@@ -372,9 +373,17 @@ class ServerThread extends Thread {
                 Slog.e(TAG, "Failure starting DockObserver", e);
             }
 
+            try {
+                Slog.i(TAG, "USB Observer");
+                // Listen for USB changes
+                usb = new UsbObserver(context);
+            } catch (Throwable e) {
+                Slog.e(TAG, "Failure starting UsbObserver", e);
+            }
+
             try {
                 Slog.i(TAG, "UI Mode Manager Service");
-                // Listen for dock station changes
+                // Listen for UI mode changes
                 uiMode = new UiModeManagerService(context);
             } catch (Throwable e) {
                 Slog.e(TAG, "Failure starting UiModeManagerService", e);
@@ -461,6 +470,7 @@ class ServerThread extends Thread {
         final BatteryService batteryF = battery;
         final ConnectivityService connectivityF = connectivity;
         final DockObserver dockF = dock;
+        final UsbObserver usbF = usb;
         final ThrottleService throttleF = throttle;
         final UiModeManagerService uiModeF = uiMode;
         final AppWidgetService appWidgetF = appWidget;
@@ -483,6 +493,7 @@ class ServerThread extends Thread {
                 if (batteryF != null) batteryF.systemReady();
                 if (connectivityF != null) connectivityF.systemReady();
                 if (dockF != null) dockF.systemReady();
+                if (usbF != null) usbF.systemReady();
                 if (uiModeF != null) uiModeF.systemReady();
                 if (recognitionF != null) recognitionF.systemReady();
                 Watchdog.getInstance().start();

services/java/com/android/server/UsbObserver.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2010 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;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.hardware.Usb;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Message;
+import android.os.UEventObserver;
+import android.provider.Settings;
+import android.util.Log;
+import android.util.Slog;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.ArrayList;
+
+/**
+ * <p>UsbObserver monitors for changes to USB state.
+ */
+class UsbObserver extends UEventObserver {
+    private static final String TAG = UsbObserver.class.getSimpleName();
+    private static final boolean LOG = false;
+
+    private static final String USB_CONFIGURATION_MATCH = "DEVPATH=/devices/virtual/switch/usb_configuration";
+    private static final String USB_FUNCTIONS_MATCH = "DEVPATH=/devices/virtual/usb_composite/";
+    private static final String USB_CONFIGURATION_PATH = "/sys/class/switch/usb_configuration/state";
+    private static final String USB_COMPOSITE_CLASS_PATH = "/sys/class/usb_composite";
+
+    private static final int MSG_UPDATE = 0;
+
+    private int mUsbConfig = 0;
+    private int mPreviousUsbConfig = 0;
+
+    // lists of enabled and disabled USB functions
+    private final ArrayList<String> mEnabledFunctions = new ArrayList<String>();
+    private final ArrayList<String> mDisabledFunctions = new ArrayList<String>();
+
+    private boolean mSystemReady;
+
+    private final Context mContext;
+
+    private PowerManagerService mPowerManager;
+
+    public UsbObserver(Context context) {
+        mContext = context;
+        init();  // set initial status
+
+        startObserving(USB_CONFIGURATION_MATCH);
+        startObserving(USB_FUNCTIONS_MATCH);
+    }
+
+    @Override
+    public void onUEvent(UEventObserver.UEvent event) {
+        if (Log.isLoggable(TAG, Log.VERBOSE)) {
+            Slog.v(TAG, "USB UEVENT: " + event.toString());
+        }
+
+        synchronized (this) {
+            String switchState = event.get("SWITCH_STATE");
+            if (switchState != null) {
+                try {
+                    int newConfig = Integer.parseInt(switchState);
+                    if (newConfig != mUsbConfig) {
+                        mPreviousUsbConfig = mUsbConfig;
+                        mUsbConfig = newConfig;
+                        // trigger an Intent broadcast
+                        if (mSystemReady) {
+                            update();
+                        }
+                    }
+                } catch (NumberFormatException e) {
+                    Slog.e(TAG, "Could not parse switch state from event " + event);
+                }
+            } else {
+                String function = event.get("FUNCTION");
+                String enabledStr = event.get("ENABLED");
+                if (function != null && enabledStr != null) {
+                    // Note: we do not broadcast a change when a function is enabled or disabled.
+                    // We just record the state change for the next broadcast.
+                    boolean enabled = "1".equals(enabledStr);
+                    if (enabled) {
+                        if (!mEnabledFunctions.contains(function)) {
+                            mEnabledFunctions.add(function);
+                        }
+                        mDisabledFunctions.remove(function);
+                    } else {
+                        if (!mDisabledFunctions.contains(function)) {
+                            mDisabledFunctions.add(function);
+                        }
+                        mEnabledFunctions.remove(function);
+                    }
+                }
+            }
+        }
+    }
+    private final void init() {
+        char[] buffer = new char[1024];
+
+        try {
+            FileReader file = new FileReader(USB_CONFIGURATION_PATH);
+            int len = file.read(buffer, 0, 1024);
+            mPreviousUsbConfig = mUsbConfig = Integer.valueOf((new String(buffer, 0, len)).trim());
+
+        } catch (FileNotFoundException e) {
+            Slog.w(TAG, "This kernel does not have USB configuration switch support");
+        } catch (Exception e) {
+            Slog.e(TAG, "" , e);
+        }
+
+        try {
+            File[] files = new File(USB_COMPOSITE_CLASS_PATH).listFiles();
+            for (int i = 0; i < files.length; i++) {
+                File file = new File(files[i], "enable");
+                FileReader reader = new FileReader(file);
+                int len = reader.read(buffer, 0, 1024);
+                int value = Integer.valueOf((new String(buffer, 0, len)).trim());
+                String functionName = files[i].getName();
+                if (value == 1) {
+                    mEnabledFunctions.add(functionName);
+                } else {
+                    mDisabledFunctions.add(functionName);
+                }
+            }
+        } catch (FileNotFoundException e) {
+            Slog.w(TAG, "This kernel does not have USB composite class support");
+        } catch (Exception e) {
+            Slog.e(TAG, "" , e);
+        }
+    }
+
+    void systemReady() {
+        synchronized (this) {
+            update();
+            mSystemReady = true;
+        }
+    }
+
+    private final void update() {
+        mHandler.sendEmptyMessage(MSG_UPDATE);
+    }
+
+    private final Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MSG_UPDATE:
+                    synchronized (this) {
+                        final ContentResolver cr = mContext.getContentResolver();
+
+                        if (Settings.Secure.getInt(cr,
+                                Settings.Secure.DEVICE_PROVISIONED, 0) == 0) {
+                            Slog.i(TAG, "Device not provisioned, skipping USB broadcast");
+                            return;
+                        }
+                        // Send an Intent containing connected/disconnected state
+                        // and the enabled/disabled state of all USB functions
+                        Intent intent;
+                        if (mUsbConfig != 0) {
+                            intent = new Intent(Usb.ACTION_USB_CONNECTED);
+
+                            // include state of all USB functions in our extras
+                            for (int i = 0; i < mEnabledFunctions.size(); i++) {
+                                intent.putExtra(mEnabledFunctions.get(i), Usb.USB_FUNCTION_ENABLED);
+                            }
+                            for (int i = 0; i < mDisabledFunctions.size(); i++) {
+                                intent.putExtra(mDisabledFunctions.get(i), Usb.USB_FUNCTION_DISABLED);
+                            }
+                        } else {
+                            intent = new Intent(Usb.ACTION_USB_DISCONNECTED);
+                        }
+
+                        mContext.sendBroadcast(intent, android.Manifest.permission.ACCESS_USB);
+                    }
+                    break;
+            }
+        }
+    };
+}