Add a new UEventObserver subclass to broadcast an Intent whe USB state changes. (57c798ad) · Commits · e / os / android_frameworks_base

core/java/android/hardware/Usb.java

0 → 100644

+78 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -80,6 +80,9 @@
	<protected-broadcast android:name="android.bluetooth.device.action.PAIRING_REQUEST" />		<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.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 -->		<!-- Permissions for things that cost money -->
	<!-- ====================================== -->		<!-- ====================================== -->

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

+12 −1

Original line number	Original line	Diff line number	Diff line
	@@ -93,6 +93,7 @@ class ServerThread extends Thread {
	BluetoothA2dpService bluetoothA2dp = null;		BluetoothA2dpService bluetoothA2dp = null;
	HeadsetObserver headset = null;		HeadsetObserver headset = null;
	DockObserver dock = null;		DockObserver dock = null;
			UsbObserver usb = null;
	UiModeManagerService uiMode = null;		UiModeManagerService uiMode = null;
	RecognitionManagerService recognition = null;		RecognitionManagerService recognition = null;
	ThrottleService throttle = null;		ThrottleService throttle = null;
	@@ -364,9 +365,17 @@ class ServerThread extends Thread {
	Slog.e(TAG, "Failure starting DockObserver", e);		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 {		try {
	Slog.i(TAG, "UI Mode Manager Service");		Slog.i(TAG, "UI Mode Manager Service");
	// Listen for dock station changes		// Listen for UI mode changes
	uiMode = new UiModeManagerService(context);		uiMode = new UiModeManagerService(context);
	} catch (Throwable e) {		} catch (Throwable e) {
	Slog.e(TAG, "Failure starting UiModeManagerService", e);		Slog.e(TAG, "Failure starting UiModeManagerService", e);
	@@ -465,6 +474,7 @@ class ServerThread extends Thread {
	final BatteryService batteryF = battery;		final BatteryService batteryF = battery;
	final ConnectivityService connectivityF = connectivity;		final ConnectivityService connectivityF = connectivity;
	final DockObserver dockF = dock;		final DockObserver dockF = dock;
			final UsbObserver usbF = usb;
	final ThrottleService throttleF = throttle;		final ThrottleService throttleF = throttle;
	final UiModeManagerService uiModeF = uiMode;		final UiModeManagerService uiModeF = uiMode;
	final AppWidgetService appWidgetF = appWidget;		final AppWidgetService appWidgetF = appWidget;
	@@ -487,6 +497,7 @@ class ServerThread extends Thread {
	if (batteryF != null) batteryF.systemReady();		if (batteryF != null) batteryF.systemReady();
	if (connectivityF != null) connectivityF.systemReady();		if (connectivityF != null) connectivityF.systemReady();
	if (dockF != null) dockF.systemReady();		if (dockF != null) dockF.systemReady();
			if (usbF != null) usbF.systemReady();
	if (uiModeF != null) uiModeF.systemReady();		if (uiModeF != null) uiModeF.systemReady();
	if (recognitionF != null) recognitionF.systemReady();		if (recognitionF != null) recognitionF.systemReady();
	Watchdog.getInstance().start();		Watchdog.getInstance().start();

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

0 → 100644

+197 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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;
			}
			}
			};
			}