From 9163d42a50076c2a77694ff394363264d862c7bf Mon Sep 17 00:00:00 2001 From: Mike Lockwood Date: Mon, 10 May 2010 18:26:40 -0400 Subject: [PATCH 1/2] DO NOT MERGE Add new permission to allow access to USB devices Adds permission android.permission.ACCESS_USB. This is a partial cherry pick of a change from master. It adds the permission, but not the support for associating it the AID_USB group. Change-Id: If5816721a4fc88bf444141a7b717da65ea37d5f4 Signed-off-by: Mike Lockwood --- core/res/AndroidManifest.xml | 8 ++++++++ core/res/res/values/strings.xml | 5 +++++ 2 files changed, 13 insertions(+) diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml index aff94531a16c0..a9dbaedf20d55 100644 --- a/core/res/AndroidManifest.xml +++ b/core/res/AndroidManifest.xml @@ -436,6 +436,14 @@ android:label="@string/permlab_flashlight" android:description="@string/permdesc_flashlight" /> + + + Allows the application to control the flashlight. + + access USB devices + + Allows the application to access USB devices. + test hardware From 2423607a32d63a0c646b17758ebeb4dc1d0b791f Mon Sep 17 00:00:00 2001 From: Mike Lockwood Date: Wed, 23 Jun 2010 17:36:36 -0400 Subject: [PATCH 2/2] Add a new UEventObserver subclass to broadcast an Intent whe USB state changes. We now broadcast Usb.ACTION_USB_CONNECTED and Usb.ACTION_USB_DISCONNECTED when USB is connected or disconnected. The ACTION_USB_CONNECTED extras indicate the enabled/disabled state of all USB functions. Change-Id: I11495d039429dbe22bd738067296e39ae415befa Signed-off-by: Mike Lockwood --- core/java/android/hardware/Usb.java | 78 +++++++ core/res/AndroidManifest.xml | 3 + .../java/com/android/server/SystemServer.java | 13 +- .../java/com/android/server/UsbObserver.java | 197 ++++++++++++++++++ 4 files changed, 290 insertions(+), 1 deletion(-) create mode 100644 core/java/android/hardware/Usb.java create mode 100644 services/java/com/android/server/UsbObserver.java diff --git a/core/java/android/hardware/Usb.java b/core/java/android/hardware/Usb.java new file mode 100644 index 0000000000000..e9c2cf7b61dd0 --- /dev/null +++ b/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"; +} diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml index a9dbaedf20d55..b1f81df7faf79 100644 --- a/core/res/AndroidManifest.xml +++ b/core/res/AndroidManifest.xml @@ -80,6 +80,9 @@ + + + diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java index b91bf7312db58..71306361506a0 100644 --- a/services/java/com/android/server/SystemServer.java +++ b/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(); diff --git a/services/java/com/android/server/UsbObserver.java b/services/java/com/android/server/UsbObserver.java new file mode 100644 index 0000000000000..3993a7f042410 --- /dev/null +++ b/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; + +/** + *

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 mEnabledFunctions = new ArrayList(); + private final ArrayList mDisabledFunctions = new ArrayList(); + + 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; + } + } + }; +}