Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes I11495d03,If5816721 into gingerbread

Browse Source 
* changes:
  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
This commit is contained in:
Mike Lockwood
2010-06-24 09:26:55 -07:00
committed by Android (Google) Code Review
parent a2549bb644 2423607a32
commit 477def1d42
5 changed files with 303 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
core/java/android/hardware/Usb.java Normal file
View File

@@ -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";
}

11
core/res/AndroidManifest.xml
View File

@@ -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"

5
core/res/res/values/strings.xml
View File

@@ -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. -->

13
services/java/com/android/server/SystemServer.java
View File

@@ -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();

197
services/java/com/android/server/UsbObserver.java Normal file
View File

@@ -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;
}
}
};
}