| /* |
| * Copyright (C) 2011 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 an |
| * limitations under the License. |
| */ |
| |
| package com.android.server.usb; |
| |
| import android.app.Notification; |
| import android.app.NotificationChannel; |
| import android.app.NotificationManager; |
| import android.app.PendingIntent; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.content.res.Resources; |
| import android.database.ContentObserver; |
| import android.hardware.usb.UsbAccessory; |
| import android.hardware.usb.UsbManager; |
| import android.hardware.usb.UsbPort; |
| import android.hardware.usb.UsbPortStatus; |
| import android.os.BatteryManager; |
| import android.os.FileUtils; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.ParcelFileDescriptor; |
| import android.os.SystemClock; |
| import android.os.SystemProperties; |
| import android.os.UEventObserver; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.os.storage.StorageManager; |
| import android.os.storage.StorageVolume; |
| import android.provider.Settings; |
| import android.util.Pair; |
| import android.util.Slog; |
| |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.messages.nano.SystemMessageProto.SystemMessage; |
| import com.android.internal.notification.SystemNotificationChannels; |
| import com.android.internal.os.SomeArgs; |
| import com.android.internal.util.IndentingPrintWriter; |
| import com.android.server.FgThread; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.util.HashMap; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Scanner; |
| import java.util.Set; |
| |
| /** |
| * UsbDeviceManager manages USB state in device mode. |
| */ |
| public class UsbDeviceManager { |
| |
| private static final String TAG = "UsbDeviceManager"; |
| private static final boolean DEBUG = false; |
| |
| /** |
| * The persistent property which stores whether adb is enabled or not. |
| * May also contain vendor-specific default functions for testing purposes. |
| */ |
| private static final String USB_PERSISTENT_CONFIG_PROPERTY = "persist.sys.usb.config"; |
| |
| /** |
| * The non-persistent property which stores the current USB settings. |
| */ |
| private static final String USB_CONFIG_PROPERTY = "sys.usb.config"; |
| |
| /** |
| * The property which stores the current build type (user/userdebug/eng). |
| */ |
| private static final String BUILD_TYPE_PROPERTY = "ro.build.type"; |
| |
| private static final String BUILD_TYPE_USERDEBUG = "userdebug"; |
| private static final String BUILD_TYPE_ENG = "eng"; |
| |
| /** |
| * The non-persistent property which stores the current USB actual state. |
| */ |
| private static final String USB_STATE_PROPERTY = "sys.usb.state"; |
| |
| /** |
| * ro.bootmode value when phone boots into usual Android. |
| */ |
| private static final String NORMAL_BOOT = "normal"; |
| |
| private static final String USB_STATE_MATCH = |
| "DEVPATH=/devices/virtual/android_usb/android0"; |
| private static final String ACCESSORY_START_MATCH = |
| "DEVPATH=/devices/virtual/misc/usb_accessory"; |
| private static final String FUNCTIONS_PATH = |
| "/sys/class/android_usb/android0/functions"; |
| private static final String STATE_PATH = |
| "/sys/class/android_usb/android0/state"; |
| private static final String RNDIS_ETH_ADDR_PATH = |
| "/sys/class/android_usb/android0/f_rndis/ethaddr"; |
| private static final String AUDIO_SOURCE_PCM_PATH = |
| "/sys/class/android_usb/android0/f_audio_source/pcm"; |
| private static final String MIDI_ALSA_PATH = |
| "/sys/class/android_usb/android0/f_midi/alsa"; |
| |
| private static final int MSG_UPDATE_STATE = 0; |
| private static final int MSG_ENABLE_ADB = 1; |
| private static final int MSG_SET_CURRENT_FUNCTIONS = 2; |
| private static final int MSG_SYSTEM_READY = 3; |
| private static final int MSG_BOOT_COMPLETED = 4; |
| private static final int MSG_USER_SWITCHED = 5; |
| private static final int MSG_UPDATE_USER_RESTRICTIONS = 6; |
| private static final int MSG_UPDATE_HOST_STATE = 7; |
| private static final int MSG_ACCESSORY_MODE_ENTER_TIMEOUT = 8; |
| private static final int MSG_UPDATE_CHARGING_STATE = 9; |
| |
| private static final int AUDIO_MODE_SOURCE = 1; |
| |
| // Delay for debouncing USB disconnects. |
| // We often get rapid connect/disconnect events when enabling USB functions, |
| // which need debouncing. |
| private static final int UPDATE_DELAY = 1000; |
| |
| // Timeout for entering USB request mode. |
| // Request is cancelled if host does not configure device within 10 seconds. |
| private static final int ACCESSORY_REQUEST_TIMEOUT = 10 * 1000; |
| |
| private static final String BOOT_MODE_PROPERTY = "ro.bootmode"; |
| |
| private static final String ADB_NOTIFICATION_CHANNEL_ID_TV = "usbdevicemanager.adb.tv"; |
| |
| private UsbHandler mHandler; |
| private boolean mBootCompleted; |
| |
| private final Object mLock = new Object(); |
| |
| private final Context mContext; |
| private final ContentResolver mContentResolver; |
| @GuardedBy("mLock") |
| private UsbProfileGroupSettingsManager mCurrentSettings; |
| private NotificationManager mNotificationManager; |
| private final boolean mHasUsbAccessory; |
| private boolean mUseUsbNotification; |
| private boolean mAdbEnabled; |
| private boolean mAudioSourceEnabled; |
| private boolean mMidiEnabled; |
| private int mMidiCard; |
| private int mMidiDevice; |
| private HashMap<String, HashMap<String, Pair<String, String>>> mOemModeMap; |
| private String[] mAccessoryStrings; |
| private UsbDebuggingManager mDebuggingManager; |
| private final UsbAlsaManager mUsbAlsaManager; |
| private final UsbSettingsManager mSettingsManager; |
| private Intent mBroadcastedIntent; |
| private boolean mPendingBootBroadcast; |
| |
| private class AdbSettingsObserver extends ContentObserver { |
| public AdbSettingsObserver() { |
| super(null); |
| } |
| |
| @Override |
| public void onChange(boolean selfChange) { |
| boolean enable = (Settings.Global.getInt(mContentResolver, |
| Settings.Global.ADB_ENABLED, 0) > 0); |
| mHandler.sendMessage(MSG_ENABLE_ADB, enable); |
| } |
| } |
| |
| /* |
| * Listens for uevent messages from the kernel to monitor the USB state |
| */ |
| private final UEventObserver mUEventObserver = new UEventObserver() { |
| @Override |
| public void onUEvent(UEventObserver.UEvent event) { |
| if (DEBUG) Slog.v(TAG, "USB UEVENT: " + event.toString()); |
| |
| String state = event.get("USB_STATE"); |
| String accessory = event.get("ACCESSORY"); |
| if (state != null) { |
| mHandler.updateState(state); |
| } else if ("START".equals(accessory)) { |
| if (DEBUG) Slog.d(TAG, "got accessory start"); |
| startAccessoryMode(); |
| } |
| } |
| }; |
| |
| private final BroadcastReceiver mHostReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| UsbPort port = intent.getParcelableExtra(UsbManager.EXTRA_PORT); |
| UsbPortStatus status = intent.getParcelableExtra(UsbManager.EXTRA_PORT_STATUS); |
| mHandler.updateHostState(port, status); |
| } |
| }; |
| |
| private final BroadcastReceiver mChargingReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| int chargePlug = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1); |
| boolean usbCharging = chargePlug == BatteryManager.BATTERY_PLUGGED_USB; |
| mHandler.sendMessage(MSG_UPDATE_CHARGING_STATE, usbCharging); |
| } |
| }; |
| |
| public UsbDeviceManager(Context context, UsbAlsaManager alsaManager, |
| UsbSettingsManager settingsManager) { |
| mContext = context; |
| mUsbAlsaManager = alsaManager; |
| mSettingsManager = settingsManager; |
| mContentResolver = context.getContentResolver(); |
| PackageManager pm = mContext.getPackageManager(); |
| mHasUsbAccessory = pm.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY); |
| initRndisAddress(); |
| |
| readOemUsbOverrideConfig(); |
| |
| mHandler = new UsbHandler(FgThread.get().getLooper()); |
| |
| if (nativeIsStartRequested()) { |
| if (DEBUG) Slog.d(TAG, "accessory attached at boot"); |
| startAccessoryMode(); |
| } |
| |
| boolean secureAdbEnabled = SystemProperties.getBoolean("ro.adb.secure", false); |
| boolean dataEncrypted = "1".equals(SystemProperties.get("vold.decrypt")); |
| if (secureAdbEnabled && !dataEncrypted) { |
| mDebuggingManager = new UsbDebuggingManager(context); |
| } |
| mContext.registerReceiver(mHostReceiver, |
| new IntentFilter(UsbManager.ACTION_USB_PORT_CHANGED)); |
| mContext.registerReceiver(mChargingReceiver, |
| new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); |
| } |
| |
| private UsbProfileGroupSettingsManager getCurrentSettings() { |
| synchronized (mLock) { |
| return mCurrentSettings; |
| } |
| } |
| |
| public void systemReady() { |
| if (DEBUG) Slog.d(TAG, "systemReady"); |
| |
| mNotificationManager = (NotificationManager) |
| mContext.getSystemService(Context.NOTIFICATION_SERVICE); |
| |
| // Ensure that the notification channels are set up |
| if (isTv()) { |
| // TV-specific notification channel |
| mNotificationManager.createNotificationChannel( |
| new NotificationChannel(ADB_NOTIFICATION_CHANNEL_ID_TV, |
| mContext.getString( |
| com.android.internal.R.string |
| .adb_debugging_notification_channel_tv), |
| NotificationManager.IMPORTANCE_HIGH)); |
| } |
| |
| // We do not show the USB notification if the primary volume supports mass storage. |
| // The legacy mass storage UI will be used instead. |
| boolean massStorageSupported = false; |
| final StorageManager storageManager = StorageManager.from(mContext); |
| final StorageVolume primary = storageManager.getPrimaryVolume(); |
| massStorageSupported = primary != null && primary.allowMassStorage(); |
| mUseUsbNotification = !massStorageSupported && mContext.getResources().getBoolean( |
| com.android.internal.R.bool.config_usbChargingMessage); |
| |
| // make sure the ADB_ENABLED setting value matches the current state |
| try { |
| Settings.Global.putInt(mContentResolver, |
| Settings.Global.ADB_ENABLED, mAdbEnabled ? 1 : 0); |
| } catch (SecurityException e) { |
| // If UserManager.DISALLOW_DEBUGGING_FEATURES is on, that this setting can't be changed. |
| Slog.d(TAG, "ADB_ENABLED is restricted."); |
| } |
| mHandler.sendEmptyMessage(MSG_SYSTEM_READY); |
| } |
| |
| public void bootCompleted() { |
| if (DEBUG) Slog.d(TAG, "boot completed"); |
| mHandler.sendEmptyMessage(MSG_BOOT_COMPLETED); |
| } |
| |
| public void setCurrentUser(int newCurrentUserId, UsbProfileGroupSettingsManager settings) { |
| synchronized (mLock) { |
| mCurrentSettings = settings; |
| mHandler.obtainMessage(MSG_USER_SWITCHED, newCurrentUserId, 0).sendToTarget(); |
| } |
| } |
| |
| public void updateUserRestrictions() { |
| mHandler.sendEmptyMessage(MSG_UPDATE_USER_RESTRICTIONS); |
| } |
| |
| private void startAccessoryMode() { |
| if (!mHasUsbAccessory) return; |
| |
| mAccessoryStrings = nativeGetAccessoryStrings(); |
| boolean enableAudio = (nativeGetAudioMode() == AUDIO_MODE_SOURCE); |
| // don't start accessory mode if our mandatory strings have not been set |
| boolean enableAccessory = (mAccessoryStrings != null && |
| mAccessoryStrings[UsbAccessory.MANUFACTURER_STRING] != null && |
| mAccessoryStrings[UsbAccessory.MODEL_STRING] != null); |
| String functions = null; |
| |
| if (enableAccessory && enableAudio) { |
| functions = UsbManager.USB_FUNCTION_ACCESSORY + "," |
| + UsbManager.USB_FUNCTION_AUDIO_SOURCE; |
| } else if (enableAccessory) { |
| functions = UsbManager.USB_FUNCTION_ACCESSORY; |
| } else if (enableAudio) { |
| functions = UsbManager.USB_FUNCTION_AUDIO_SOURCE; |
| } |
| |
| if (functions != null) { |
| mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_ACCESSORY_MODE_ENTER_TIMEOUT), |
| ACCESSORY_REQUEST_TIMEOUT); |
| setCurrentFunctions(functions, false); |
| } |
| } |
| |
| private static void initRndisAddress() { |
| // configure RNDIS ethernet address based on our serial number using the same algorithm |
| // we had been previously using in kernel board files |
| final int ETH_ALEN = 6; |
| int address[] = new int[ETH_ALEN]; |
| // first byte is 0x02 to signify a locally administered address |
| address[0] = 0x02; |
| |
| String serial = SystemProperties.get("ro.serialno", "1234567890ABCDEF"); |
| int serialLength = serial.length(); |
| // XOR the USB serial across the remaining 5 bytes |
| for (int i = 0; i < serialLength; i++) { |
| address[i % (ETH_ALEN - 1) + 1] ^= (int) serial.charAt(i); |
| } |
| String addrString = String.format(Locale.US, "%02X:%02X:%02X:%02X:%02X:%02X", |
| address[0], address[1], address[2], address[3], address[4], address[5]); |
| try { |
| FileUtils.stringToFile(RNDIS_ETH_ADDR_PATH, addrString); |
| } catch (IOException e) { |
| Slog.e(TAG, "failed to write to " + RNDIS_ETH_ADDR_PATH); |
| } |
| } |
| |
| private boolean isTv() { |
| return mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_LEANBACK); |
| } |
| |
| private final class UsbHandler extends Handler { |
| |
| // current USB state |
| private boolean mConnected; |
| private boolean mHostConnected; |
| private boolean mSourcePower; |
| private boolean mSinkPower; |
| private boolean mConfigured; |
| private boolean mUsbDataUnlocked; |
| private String mCurrentFunctions; |
| private boolean mCurrentFunctionsApplied; |
| private UsbAccessory mCurrentAccessory; |
| private int mUsbNotificationId; |
| private boolean mAdbNotificationShown; |
| private int mCurrentUser = UserHandle.USER_NULL; |
| private boolean mUsbCharging; |
| private String mCurrentOemFunctions; |
| |
| public UsbHandler(Looper looper) { |
| super(looper); |
| try { |
| // Restore default functions. |
| |
| if (isNormalBoot()) { |
| mCurrentFunctions = SystemProperties.get(USB_CONFIG_PROPERTY, |
| UsbManager.USB_FUNCTION_NONE); |
| mCurrentFunctionsApplied = mCurrentFunctions.equals( |
| SystemProperties.get(USB_STATE_PROPERTY)); |
| } else { |
| mCurrentFunctions = SystemProperties.get(getPersistProp(true), |
| UsbManager.USB_FUNCTION_NONE); |
| mCurrentFunctionsApplied = SystemProperties.get(USB_CONFIG_PROPERTY, |
| UsbManager.USB_FUNCTION_NONE).equals( |
| SystemProperties.get(USB_STATE_PROPERTY)); |
| } |
| |
| /** |
| * Use the normal bootmode persistent prop to maintain state of adb across |
| * all boot modes. |
| */ |
| mAdbEnabled = UsbManager.containsFunction( |
| SystemProperties.get(USB_PERSISTENT_CONFIG_PROPERTY), |
| UsbManager.USB_FUNCTION_ADB); |
| |
| /** |
| * Remove MTP from persistent config, to bring usb to a good state |
| * after fixes to b/31814300. This block can be removed after the update |
| */ |
| String persisted = SystemProperties.get(USB_PERSISTENT_CONFIG_PROPERTY); |
| if (UsbManager.containsFunction(persisted, UsbManager.USB_FUNCTION_MTP)) { |
| SystemProperties.set(USB_PERSISTENT_CONFIG_PROPERTY, |
| UsbManager.removeFunction(persisted, UsbManager.USB_FUNCTION_MTP)); |
| } |
| |
| String state = FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim(); |
| updateState(state); |
| |
| // register observer to listen for settings changes |
| mContentResolver.registerContentObserver( |
| Settings.Global.getUriFor(Settings.Global.ADB_ENABLED), |
| false, new AdbSettingsObserver()); |
| |
| // Watch for USB configuration changes |
| mUEventObserver.startObserving(USB_STATE_MATCH); |
| mUEventObserver.startObserving(ACCESSORY_START_MATCH); |
| } catch (Exception e) { |
| Slog.e(TAG, "Error initializing UsbHandler", e); |
| } |
| } |
| |
| public void sendMessage(int what, boolean arg) { |
| removeMessages(what); |
| Message m = Message.obtain(this, what); |
| m.arg1 = (arg ? 1 : 0); |
| sendMessage(m); |
| } |
| |
| public void sendMessage(int what, Object arg) { |
| removeMessages(what); |
| Message m = Message.obtain(this, what); |
| m.obj = arg; |
| sendMessage(m); |
| } |
| |
| public void sendMessage(int what, Object arg, boolean arg1) { |
| removeMessages(what); |
| Message m = Message.obtain(this, what); |
| m.obj = arg; |
| m.arg1 = (arg1 ? 1 : 0); |
| sendMessage(m); |
| } |
| |
| public void updateState(String state) { |
| int connected, configured; |
| |
| if ("DISCONNECTED".equals(state)) { |
| connected = 0; |
| configured = 0; |
| } else if ("CONNECTED".equals(state)) { |
| connected = 1; |
| configured = 0; |
| } else if ("CONFIGURED".equals(state)) { |
| connected = 1; |
| configured = 1; |
| } else { |
| Slog.e(TAG, "unknown state " + state); |
| return; |
| } |
| removeMessages(MSG_UPDATE_STATE); |
| Message msg = Message.obtain(this, MSG_UPDATE_STATE); |
| msg.arg1 = connected; |
| msg.arg2 = configured; |
| // debounce disconnects to avoid problems bringing up USB tethering |
| sendMessageDelayed(msg, (connected == 0) ? UPDATE_DELAY : 0); |
| } |
| |
| public void updateHostState(UsbPort port, UsbPortStatus status) { |
| boolean hostConnected = status.getCurrentDataRole() == UsbPort.DATA_ROLE_HOST; |
| boolean sourcePower = status.getCurrentPowerRole() == UsbPort.POWER_ROLE_SOURCE; |
| boolean sinkPower = status.getCurrentPowerRole() == UsbPort.POWER_ROLE_SINK; |
| |
| if (DEBUG) { |
| Slog.i(TAG, "updateHostState " + port + " status=" + status); |
| } |
| |
| SomeArgs args = SomeArgs.obtain(); |
| args.argi1 = hostConnected ? 1 : 0; |
| args.argi2 = sourcePower ? 1 : 0; |
| args.argi3 = sinkPower ? 1 : 0; |
| |
| removeMessages(MSG_UPDATE_HOST_STATE); |
| Message msg = obtainMessage(MSG_UPDATE_HOST_STATE, args); |
| // debounce rapid transitions of connect/disconnect on type-c ports |
| sendMessageDelayed(msg, UPDATE_DELAY); |
| } |
| |
| private boolean waitForState(String state) { |
| // wait for the transition to complete. |
| // give up after 1 second. |
| String value = null; |
| for (int i = 0; i < 20; i++) { |
| // State transition is done when sys.usb.state is set to the new configuration |
| value = SystemProperties.get(USB_STATE_PROPERTY); |
| if (state.equals(value)) return true; |
| SystemClock.sleep(50); |
| } |
| Slog.e(TAG, "waitForState(" + state + ") FAILED: got " + value); |
| return false; |
| } |
| |
| private void setUsbConfig(String config) { |
| if (DEBUG) Slog.d(TAG, "setUsbConfig(" + config + ")"); |
| // set the new configuration |
| // we always set it due to b/23631400, where adbd was getting killed |
| // and not restarted due to property timeouts on some devices |
| SystemProperties.set(USB_CONFIG_PROPERTY, config); |
| } |
| |
| private void setAdbEnabled(boolean enable) { |
| if (DEBUG) Slog.d(TAG, "setAdbEnabled: " + enable); |
| if (enable != mAdbEnabled) { |
| mAdbEnabled = enable; |
| String oldFunctions = mCurrentFunctions; |
| |
| // Persist the adb setting |
| String newFunction = applyAdbFunction(SystemProperties.get( |
| USB_PERSISTENT_CONFIG_PROPERTY, UsbManager.USB_FUNCTION_NONE)); |
| SystemProperties.set(USB_PERSISTENT_CONFIG_PROPERTY, newFunction); |
| |
| // Remove mtp from the config if file transfer is not enabled |
| if (oldFunctions.equals(UsbManager.USB_FUNCTION_MTP) && |
| !mUsbDataUnlocked && enable) { |
| oldFunctions = UsbManager.USB_FUNCTION_NONE; |
| } |
| |
| setEnabledFunctions(oldFunctions, true, mUsbDataUnlocked); |
| updateAdbNotification(); |
| } |
| |
| if (mDebuggingManager != null) { |
| mDebuggingManager.setAdbEnabled(mAdbEnabled); |
| } |
| } |
| |
| /** |
| * Evaluates USB function policies and applies the change accordingly. |
| */ |
| private void setEnabledFunctions(String functions, boolean forceRestart, |
| boolean usbDataUnlocked) { |
| if (DEBUG) { |
| Slog.d(TAG, "setEnabledFunctions functions=" + functions + ", " |
| + "forceRestart=" + forceRestart + ", usbDataUnlocked=" + usbDataUnlocked); |
| } |
| |
| if (usbDataUnlocked != mUsbDataUnlocked) { |
| mUsbDataUnlocked = usbDataUnlocked; |
| updateUsbNotification(); |
| forceRestart = true; |
| } |
| |
| // Try to set the enabled functions. |
| final String oldFunctions = mCurrentFunctions; |
| final boolean oldFunctionsApplied = mCurrentFunctionsApplied; |
| if (trySetEnabledFunctions(functions, forceRestart)) { |
| return; |
| } |
| |
| // Didn't work. Try to revert changes. |
| // We always reapply the policy in case certain constraints changed such as |
| // user restrictions independently of any other new functions we were |
| // trying to activate. |
| if (oldFunctionsApplied && !oldFunctions.equals(functions)) { |
| Slog.e(TAG, "Failsafe 1: Restoring previous USB functions."); |
| if (trySetEnabledFunctions(oldFunctions, false)) { |
| return; |
| } |
| } |
| |
| // Still didn't work. Try to restore the default functions. |
| Slog.e(TAG, "Failsafe 2: Restoring default USB functions."); |
| if (trySetEnabledFunctions(null, false)) { |
| return; |
| } |
| |
| // Now we're desperate. Ignore the default functions. |
| // Try to get ADB working if enabled. |
| Slog.e(TAG, "Failsafe 3: Restoring empty function list (with ADB if enabled)."); |
| if (trySetEnabledFunctions(UsbManager.USB_FUNCTION_NONE, false)) { |
| return; |
| } |
| |
| // Ouch. |
| Slog.e(TAG, "Unable to set any USB functions!"); |
| } |
| |
| private boolean isNormalBoot() { |
| String bootMode = SystemProperties.get(BOOT_MODE_PROPERTY, "unknown"); |
| if (bootMode.equals(NORMAL_BOOT) || bootMode.equals("unknown")) { |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean trySetEnabledFunctions(String functions, boolean forceRestart) { |
| if (functions == null || applyAdbFunction(functions) |
| .equals(UsbManager.USB_FUNCTION_NONE)) { |
| functions = getDefaultFunctions(); |
| } |
| functions = applyAdbFunction(functions); |
| |
| String oemFunctions = applyOemOverrideFunction(functions); |
| |
| if (!isNormalBoot() && !mCurrentFunctions.equals(functions)) { |
| SystemProperties.set(getPersistProp(true), functions); |
| } |
| |
| if ((!functions.equals(oemFunctions) && |
| (mCurrentOemFunctions == null || |
| !mCurrentOemFunctions.equals(oemFunctions))) |
| || !mCurrentFunctions.equals(functions) |
| || !mCurrentFunctionsApplied |
| || forceRestart) { |
| Slog.i(TAG, "Setting USB config to " + functions); |
| mCurrentFunctions = functions; |
| mCurrentOemFunctions = oemFunctions; |
| mCurrentFunctionsApplied = false; |
| |
| // Kick the USB stack to close existing connections. |
| setUsbConfig(UsbManager.USB_FUNCTION_NONE); |
| |
| if (!waitForState(UsbManager.USB_FUNCTION_NONE)) { |
| Slog.e(TAG, "Failed to kick USB config"); |
| return false; |
| } |
| |
| // Set the new USB configuration. |
| setUsbConfig(oemFunctions); |
| |
| if (UsbManager.containsFunction(functions, UsbManager.USB_FUNCTION_MTP) |
| || UsbManager.containsFunction(functions, UsbManager.USB_FUNCTION_PTP)) { |
| // Start up dependent services. |
| updateUsbStateBroadcastIfNeeded(true); |
| } |
| |
| if (!waitForState(oemFunctions)) { |
| Slog.e(TAG, "Failed to switch USB config to " + functions); |
| return false; |
| } |
| |
| mCurrentFunctionsApplied = true; |
| } |
| return true; |
| } |
| |
| private String applyAdbFunction(String functions) { |
| // Do not pass null pointer to the UsbManager. |
| // There isnt a check there. |
| if (functions == null) { |
| functions = ""; |
| } |
| if (mAdbEnabled) { |
| functions = UsbManager.addFunction(functions, UsbManager.USB_FUNCTION_ADB); |
| } else { |
| functions = UsbManager.removeFunction(functions, UsbManager.USB_FUNCTION_ADB); |
| } |
| return functions; |
| } |
| |
| private boolean isUsbTransferAllowed() { |
| UserManager userManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE); |
| return !userManager.hasUserRestriction(UserManager.DISALLOW_USB_FILE_TRANSFER); |
| } |
| |
| private void updateCurrentAccessory() { |
| // We are entering accessory mode if we have received a request from the host |
| // and the request has not timed out yet. |
| boolean enteringAccessoryMode = hasMessages(MSG_ACCESSORY_MODE_ENTER_TIMEOUT); |
| |
| if (mConfigured && enteringAccessoryMode) { |
| // successfully entered accessory mode |
| if (mAccessoryStrings != null) { |
| mCurrentAccessory = new UsbAccessory(mAccessoryStrings); |
| Slog.d(TAG, "entering USB accessory mode: " + mCurrentAccessory); |
| // defer accessoryAttached if system is not ready |
| if (mBootCompleted) { |
| getCurrentSettings().accessoryAttached(mCurrentAccessory); |
| } // else handle in boot completed |
| } else { |
| Slog.e(TAG, "nativeGetAccessoryStrings failed"); |
| } |
| } else { |
| if (!enteringAccessoryMode) { |
| notifyAccessoryModeExit(); |
| } else if (DEBUG) { |
| Slog.v(TAG, "Debouncing accessory mode exit"); |
| } |
| } |
| } |
| |
| private void notifyAccessoryModeExit() { |
| // make sure accessory mode is off |
| // and restore default functions |
| Slog.d(TAG, "exited USB accessory mode"); |
| setEnabledFunctions(null, false, false); |
| |
| if (mCurrentAccessory != null) { |
| if (mBootCompleted) { |
| mSettingsManager.usbAccessoryRemoved(mCurrentAccessory); |
| } |
| mCurrentAccessory = null; |
| mAccessoryStrings = null; |
| } |
| } |
| |
| private boolean isUsbStateChanged(Intent intent) { |
| final Set<String> keySet = intent.getExtras().keySet(); |
| if (mBroadcastedIntent == null) { |
| for (String key : keySet) { |
| if (intent.getBooleanExtra(key, false)) { |
| return true; |
| } |
| } |
| } else { |
| if (!keySet.equals(mBroadcastedIntent.getExtras().keySet())) { |
| return true; |
| } |
| for (String key : keySet) { |
| if (intent.getBooleanExtra(key, false) != |
| mBroadcastedIntent.getBooleanExtra(key, false)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private void updateUsbStateBroadcastIfNeeded(boolean configChanged) { |
| // send a sticky broadcast containing current USB state |
| Intent intent = new Intent(UsbManager.ACTION_USB_STATE); |
| intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING |
| | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND |
| | Intent.FLAG_RECEIVER_FOREGROUND); |
| intent.putExtra(UsbManager.USB_CONNECTED, mConnected); |
| intent.putExtra(UsbManager.USB_HOST_CONNECTED, mHostConnected); |
| intent.putExtra(UsbManager.USB_CONFIGURED, mConfigured); |
| intent.putExtra(UsbManager.USB_DATA_UNLOCKED, |
| isUsbTransferAllowed() && mUsbDataUnlocked); |
| intent.putExtra(UsbManager.USB_CONFIG_CHANGED, configChanged); |
| |
| if (mCurrentFunctions != null) { |
| String[] functions = mCurrentFunctions.split(","); |
| for (int i = 0; i < functions.length; i++) { |
| final String function = functions[i]; |
| if (UsbManager.USB_FUNCTION_NONE.equals(function)) { |
| continue; |
| } |
| intent.putExtra(function, true); |
| } |
| } |
| |
| // send broadcast intent only if the USB state has changed |
| if (!isUsbStateChanged(intent)) { |
| if (DEBUG) { |
| Slog.d(TAG, "skip broadcasting " + intent + " extras: " + intent.getExtras()); |
| } |
| return; |
| } |
| |
| if (DEBUG) Slog.d(TAG, "broadcasting " + intent + " extras: " + intent.getExtras()); |
| mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL); |
| mBroadcastedIntent = intent; |
| } |
| |
| private void updateUsbFunctions() { |
| updateAudioSourceFunction(); |
| updateMidiFunction(); |
| } |
| |
| private void updateAudioSourceFunction() { |
| boolean enabled = UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_AUDIO_SOURCE); |
| if (enabled != mAudioSourceEnabled) { |
| int card = -1; |
| int device = -1; |
| |
| if (enabled) { |
| Scanner scanner = null; |
| try { |
| scanner = new Scanner(new File(AUDIO_SOURCE_PCM_PATH)); |
| card = scanner.nextInt(); |
| device = scanner.nextInt(); |
| } catch (FileNotFoundException e) { |
| Slog.e(TAG, "could not open audio source PCM file", e); |
| } finally { |
| if (scanner != null) { |
| scanner.close(); |
| } |
| } |
| } |
| mUsbAlsaManager.setAccessoryAudioState(enabled, card, device); |
| mAudioSourceEnabled = enabled; |
| } |
| } |
| |
| private void updateMidiFunction() { |
| boolean enabled = UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_MIDI); |
| if (enabled != mMidiEnabled) { |
| if (enabled) { |
| Scanner scanner = null; |
| try { |
| scanner = new Scanner(new File(MIDI_ALSA_PATH)); |
| mMidiCard = scanner.nextInt(); |
| mMidiDevice = scanner.nextInt(); |
| } catch (FileNotFoundException e) { |
| Slog.e(TAG, "could not open MIDI file", e); |
| enabled = false; |
| } finally { |
| if (scanner != null) { |
| scanner.close(); |
| } |
| } |
| } |
| mMidiEnabled = enabled; |
| } |
| mUsbAlsaManager.setPeripheralMidiState( |
| mMidiEnabled && mConfigured, mMidiCard, mMidiDevice); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_UPDATE_STATE: |
| mConnected = (msg.arg1 == 1); |
| mConfigured = (msg.arg2 == 1); |
| |
| updateUsbNotification(); |
| updateAdbNotification(); |
| if (mBootCompleted) { |
| updateUsbStateBroadcastIfNeeded(false); |
| } |
| if (UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_ACCESSORY)) { |
| updateCurrentAccessory(); |
| } |
| if (mBootCompleted) { |
| if (!mConnected) { |
| // restore defaults when USB is disconnected |
| setEnabledFunctions(null, !mAdbEnabled, false); |
| } |
| updateUsbFunctions(); |
| } else { |
| mPendingBootBroadcast = true; |
| } |
| break; |
| case MSG_UPDATE_HOST_STATE: |
| SomeArgs args = (SomeArgs) msg.obj; |
| boolean prevHostConnected = mHostConnected; |
| mHostConnected = (args.argi1 == 1); |
| mSourcePower = (args.argi2 == 1); |
| mSinkPower = (args.argi3 == 1); |
| args.recycle(); |
| updateUsbNotification(); |
| if (mBootCompleted) { |
| if (mHostConnected || prevHostConnected) { |
| updateUsbStateBroadcastIfNeeded(false); |
| } |
| } else { |
| mPendingBootBroadcast = true; |
| } |
| break; |
| case MSG_UPDATE_CHARGING_STATE: |
| mUsbCharging = (msg.arg1 == 1); |
| updateUsbNotification(); |
| break; |
| case MSG_ENABLE_ADB: |
| setAdbEnabled(msg.arg1 == 1); |
| break; |
| case MSG_SET_CURRENT_FUNCTIONS: |
| String functions = (String) msg.obj; |
| setEnabledFunctions(functions, false, msg.arg1 == 1); |
| break; |
| case MSG_UPDATE_USER_RESTRICTIONS: |
| // Restart the USB stack if USB transfer is enabled but no longer allowed. |
| final boolean forceRestart = mUsbDataUnlocked |
| && isUsbDataTransferActive() |
| && !isUsbTransferAllowed(); |
| setEnabledFunctions( |
| mCurrentFunctions, forceRestart, mUsbDataUnlocked && !forceRestart); |
| break; |
| case MSG_SYSTEM_READY: |
| updateUsbNotification(); |
| updateAdbNotification(); |
| updateUsbFunctions(); |
| break; |
| case MSG_BOOT_COMPLETED: |
| mBootCompleted = true; |
| if (mPendingBootBroadcast) { |
| updateUsbStateBroadcastIfNeeded(false); |
| mPendingBootBroadcast = false; |
| } |
| setEnabledFunctions(null, false, false); |
| if (mCurrentAccessory != null) { |
| getCurrentSettings().accessoryAttached(mCurrentAccessory); |
| } |
| if (mDebuggingManager != null) { |
| mDebuggingManager.setAdbEnabled(mAdbEnabled); |
| } |
| break; |
| case MSG_USER_SWITCHED: { |
| if (mCurrentUser != msg.arg1) { |
| // Restart the USB stack and re-apply user restrictions for MTP or PTP. |
| if (mUsbDataUnlocked |
| && isUsbDataTransferActive() |
| && mCurrentUser != UserHandle.USER_NULL) { |
| Slog.v(TAG, "Current user switched to " + msg.arg1 |
| + "; resetting USB host stack for MTP or PTP"); |
| // avoid leaking sensitive data from previous user |
| setEnabledFunctions(mCurrentFunctions, true, false); |
| } |
| mCurrentUser = msg.arg1; |
| } |
| break; |
| } |
| case MSG_ACCESSORY_MODE_ENTER_TIMEOUT: { |
| if (DEBUG) { |
| Slog.v(TAG, "Accessory mode enter timeout: " + mConnected); |
| } |
| if (!mConnected) { |
| notifyAccessoryModeExit(); |
| } |
| break; |
| } |
| } |
| } |
| |
| private boolean isUsbDataTransferActive() { |
| return UsbManager.containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_MTP) |
| || UsbManager.containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_PTP); |
| } |
| |
| public UsbAccessory getCurrentAccessory() { |
| return mCurrentAccessory; |
| } |
| |
| private void updateUsbNotification() { |
| if (mNotificationManager == null || !mUseUsbNotification |
| || ("0".equals(SystemProperties.get("persist.charging.notify")))) { |
| return; |
| } |
| int id = 0; |
| int titleRes = 0; |
| Resources r = mContext.getResources(); |
| if (mConnected) { |
| if (!mUsbDataUnlocked) { |
| if (mSourcePower) { |
| titleRes = com.android.internal.R.string.usb_supplying_notification_title; |
| id = SystemMessage.NOTE_USB_SUPPLYING; |
| } else { |
| titleRes = com.android.internal.R.string.usb_charging_notification_title; |
| id = SystemMessage.NOTE_USB_CHARGING; |
| } |
| } else if (UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_MTP)) { |
| titleRes = com.android.internal.R.string.usb_mtp_notification_title; |
| id = SystemMessage.NOTE_USB_MTP; |
| } else if (UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_PTP)) { |
| titleRes = com.android.internal.R.string.usb_ptp_notification_title; |
| id = SystemMessage.NOTE_USB_PTP; |
| } else if (UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_MIDI)) { |
| titleRes = com.android.internal.R.string.usb_midi_notification_title; |
| id = SystemMessage.NOTE_USB_MIDI; |
| } else if (UsbManager.containsFunction(mCurrentFunctions, |
| UsbManager.USB_FUNCTION_ACCESSORY)) { |
| titleRes = com.android.internal.R.string.usb_accessory_notification_title; |
| id = SystemMessage.NOTE_USB_ACCESSORY; |
| } else if (mSourcePower) { |
| titleRes = com.android.internal.R.string.usb_supplying_notification_title; |
| id = SystemMessage.NOTE_USB_SUPPLYING; |
| } else { |
| titleRes = com.android.internal.R.string.usb_charging_notification_title; |
| id = SystemMessage.NOTE_USB_CHARGING; |
| } |
| } else if (mSourcePower) { |
| titleRes = com.android.internal.R.string.usb_supplying_notification_title; |
| id = SystemMessage.NOTE_USB_SUPPLYING; |
| } else if (mHostConnected && mSinkPower && mUsbCharging) { |
| titleRes = com.android.internal.R.string.usb_charging_notification_title; |
| id = SystemMessage.NOTE_USB_CHARGING; |
| } |
| if (id != mUsbNotificationId) { |
| // clear notification if title needs changing |
| if (mUsbNotificationId != 0) { |
| mNotificationManager.cancelAsUser(null, mUsbNotificationId, |
| UserHandle.ALL); |
| mUsbNotificationId = 0; |
| } |
| if (id != 0) { |
| CharSequence message = r.getText( |
| com.android.internal.R.string.usb_notification_message); |
| CharSequence title = r.getText(titleRes); |
| |
| Intent intent = Intent.makeRestartActivityTask( |
| new ComponentName("com.android.settings", |
| "com.android.settings.deviceinfo.UsbModeChooserActivity")); |
| PendingIntent pi = PendingIntent.getActivityAsUser(mContext, 0, |
| intent, 0, null, UserHandle.CURRENT); |
| |
| Notification notification = |
| new Notification.Builder(mContext, SystemNotificationChannels.USB) |
| .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb) |
| .setWhen(0) |
| .setOngoing(true) |
| .setTicker(title) |
| .setDefaults(0) // please be quiet |
| .setColor(mContext.getColor( |
| com.android.internal.R.color |
| .system_notification_accent_color)) |
| .setContentTitle(title) |
| .setContentText(message) |
| .setContentIntent(pi) |
| .setVisibility(Notification.VISIBILITY_PUBLIC) |
| .build(); |
| mNotificationManager.notifyAsUser(null, id, notification, |
| UserHandle.ALL); |
| mUsbNotificationId = id; |
| } |
| } |
| } |
| |
| private void updateAdbNotification() { |
| if (mNotificationManager == null) return; |
| final int id = SystemMessage.NOTE_ADB_ACTIVE; |
| final int titleRes = com.android.internal.R.string.adb_active_notification_title; |
| if (mAdbEnabled && mConnected) { |
| if ("0".equals(SystemProperties.get("persist.adb.notify"))) return; |
| |
| if (!mAdbNotificationShown) { |
| Resources r = mContext.getResources(); |
| CharSequence title = r.getText(titleRes); |
| CharSequence message = r.getText( |
| com.android.internal.R.string.adb_active_notification_message); |
| |
| Intent intent = new Intent(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
| | Intent.FLAG_ACTIVITY_CLEAR_TASK); |
| PendingIntent pi = PendingIntent.getActivityAsUser(mContext, 0, |
| intent, 0, null, UserHandle.CURRENT); |
| |
| Notification notification = |
| new Notification.Builder(mContext, SystemNotificationChannels.DEVELOPER) |
| .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb) |
| .setWhen(0) |
| .setOngoing(true) |
| .setTicker(title) |
| .setDefaults(0) // please be quiet |
| .setColor(mContext.getColor( |
| com.android.internal.R.color |
| .system_notification_accent_color)) |
| .setContentTitle(title) |
| .setContentText(message) |
| .setContentIntent(pi) |
| .setVisibility(Notification.VISIBILITY_PUBLIC) |
| .extend(new Notification.TvExtender() |
| .setChannelId(ADB_NOTIFICATION_CHANNEL_ID_TV)) |
| .build(); |
| mAdbNotificationShown = true; |
| mNotificationManager.notifyAsUser(null, id, notification, |
| UserHandle.ALL); |
| } |
| } else if (mAdbNotificationShown) { |
| mAdbNotificationShown = false; |
| mNotificationManager.cancelAsUser(null, id, UserHandle.ALL); |
| } |
| } |
| |
| private String getDefaultFunctions() { |
| String func = SystemProperties.get(getPersistProp(true), |
| UsbManager.USB_FUNCTION_NONE); |
| if (UsbManager.USB_FUNCTION_NONE.equals(func)) { |
| func = UsbManager.USB_FUNCTION_MTP; |
| } |
| return func; |
| } |
| |
| public void dump(IndentingPrintWriter pw) { |
| pw.println("USB Device State:"); |
| pw.println(" mCurrentFunctions: " + mCurrentFunctions); |
| pw.println(" mCurrentOemFunctions: " + mCurrentOemFunctions); |
| pw.println(" mCurrentFunctionsApplied: " + mCurrentFunctionsApplied); |
| pw.println(" mConnected: " + mConnected); |
| pw.println(" mConfigured: " + mConfigured); |
| pw.println(" mUsbDataUnlocked: " + mUsbDataUnlocked); |
| pw.println(" mCurrentAccessory: " + mCurrentAccessory); |
| pw.println(" mHostConnected: " + mHostConnected); |
| pw.println(" mSourcePower: " + mSourcePower); |
| pw.println(" mSinkPower: " + mSinkPower); |
| pw.println(" mUsbCharging: " + mUsbCharging); |
| try { |
| pw.println(" Kernel state: " |
| + FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim()); |
| pw.println(" Kernel function list: " |
| + FileUtils.readTextFile(new File(FUNCTIONS_PATH), 0, null).trim()); |
| } catch (IOException e) { |
| pw.println("IOException: " + e); |
| } |
| } |
| } |
| |
| /* returns the currently attached USB accessory */ |
| public UsbAccessory getCurrentAccessory() { |
| return mHandler.getCurrentAccessory(); |
| } |
| |
| /* opens the currently attached USB accessory */ |
| public ParcelFileDescriptor openAccessory(UsbAccessory accessory, |
| UsbUserSettingsManager settings) { |
| UsbAccessory currentAccessory = mHandler.getCurrentAccessory(); |
| if (currentAccessory == null) { |
| throw new IllegalArgumentException("no accessory attached"); |
| } |
| if (!currentAccessory.equals(accessory)) { |
| String error = accessory.toString() |
| + " does not match current accessory " |
| + currentAccessory; |
| throw new IllegalArgumentException(error); |
| } |
| settings.checkPermission(accessory); |
| return nativeOpenAccessory(); |
| } |
| |
| public boolean isFunctionEnabled(String function) { |
| return UsbManager.containsFunction(SystemProperties.get(USB_CONFIG_PROPERTY), function); |
| } |
| |
| public void setCurrentFunctions(String functions, boolean usbDataUnlocked) { |
| if (DEBUG) { |
| Slog.d(TAG, "setCurrentFunctions(" + functions + ", " + |
| usbDataUnlocked + ")"); |
| } |
| mHandler.sendMessage(MSG_SET_CURRENT_FUNCTIONS, functions, usbDataUnlocked); |
| } |
| |
| private void readOemUsbOverrideConfig() { |
| String[] configList = mContext.getResources().getStringArray( |
| com.android.internal.R.array.config_oemUsbModeOverride); |
| |
| if (configList != null) { |
| for (String config : configList) { |
| String[] items = config.split(":"); |
| if (items.length == 3 || items.length == 4) { |
| if (mOemModeMap == null) { |
| mOemModeMap = new HashMap<String, HashMap<String, |
| Pair<String, String>>>(); |
| } |
| HashMap<String, Pair<String, String>> overrideMap |
| = mOemModeMap.get(items[0]); |
| if (overrideMap == null) { |
| overrideMap = new HashMap<String, |
| Pair<String, String>>(); |
| mOemModeMap.put(items[0], overrideMap); |
| } |
| |
| // Favoring the first combination if duplicate exists |
| if (!overrideMap.containsKey(items[1])) { |
| if (items.length == 3) { |
| overrideMap.put(items[1], |
| new Pair<String, String>(items[2], "")); |
| } else { |
| overrideMap.put(items[1], |
| new Pair<String, String>(items[2], items[3])); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private String applyOemOverrideFunction(String usbFunctions) { |
| if ((usbFunctions == null) || (mOemModeMap == null)) { |
| return usbFunctions; |
| } |
| |
| String bootMode = SystemProperties.get(BOOT_MODE_PROPERTY, "unknown"); |
| Slog.d(TAG, "applyOemOverride usbfunctions=" + usbFunctions + " bootmode=" + bootMode); |
| |
| Map<String, Pair<String, String>> overridesMap = |
| mOemModeMap.get(bootMode); |
| // Check to ensure that the oem is not overriding in the normal |
| // boot mode |
| if (overridesMap != null && !(bootMode.equals(NORMAL_BOOT) || |
| bootMode.equals("unknown"))) { |
| Pair<String, String> overrideFunctions = |
| overridesMap.get(usbFunctions); |
| if (overrideFunctions != null) { |
| Slog.d(TAG, "OEM USB override: " + usbFunctions |
| + " ==> " + overrideFunctions.first |
| + " persist across reboot " |
| + overrideFunctions.second); |
| if (!overrideFunctions.second.equals("")) { |
| String newFunction; |
| if (mAdbEnabled) { |
| newFunction = UsbManager.addFunction(overrideFunctions.second, |
| UsbManager.USB_FUNCTION_ADB); |
| } else { |
| newFunction = UsbManager.addFunction(UsbManager.USB_FUNCTION_NONE, |
| UsbManager.USB_FUNCTION_ADB); |
| } |
| Slog.d(TAG, "OEM USB override persisting: " + newFunction + "in prop: " |
| + UsbDeviceManager.getPersistProp(false)); |
| SystemProperties.set(UsbDeviceManager.getPersistProp(false), |
| newFunction); |
| } |
| return overrideFunctions.first; |
| } else if (mAdbEnabled) { |
| String newFunction = UsbManager.addFunction(UsbManager.USB_FUNCTION_NONE, |
| UsbManager.USB_FUNCTION_ADB); |
| SystemProperties.set(UsbDeviceManager.getPersistProp(false), |
| newFunction); |
| } else { |
| SystemProperties.set(UsbDeviceManager.getPersistProp(false), |
| UsbManager.USB_FUNCTION_NONE); |
| } |
| } |
| // return passed in functions as is. |
| return usbFunctions; |
| } |
| |
| public static String getPersistProp(boolean functions) { |
| String bootMode = SystemProperties.get(BOOT_MODE_PROPERTY, "unknown"); |
| String persistProp = USB_PERSISTENT_CONFIG_PROPERTY; |
| if (!(bootMode.equals(NORMAL_BOOT) || bootMode.equals("unknown"))) { |
| if (functions == true) { |
| persistProp = "persist.sys.usb." + bootMode + ".func"; |
| } else { |
| persistProp = "persist.sys.usb." + bootMode + ".config"; |
| } |
| } |
| |
| return persistProp; |
| } |
| |
| |
| public void allowUsbDebugging(boolean alwaysAllow, String publicKey) { |
| if (mDebuggingManager != null) { |
| mDebuggingManager.allowUsbDebugging(alwaysAllow, publicKey); |
| } |
| } |
| |
| public void denyUsbDebugging() { |
| if (mDebuggingManager != null) { |
| mDebuggingManager.denyUsbDebugging(); |
| } |
| } |
| |
| public void clearUsbDebuggingKeys() { |
| if (mDebuggingManager != null) { |
| mDebuggingManager.clearUsbDebuggingKeys(); |
| } else { |
| throw new RuntimeException("Cannot clear Usb Debugging keys, " |
| + "UsbDebuggingManager not enabled"); |
| } |
| } |
| |
| public void dump(IndentingPrintWriter pw) { |
| if (mHandler != null) { |
| mHandler.dump(pw); |
| } |
| if (mDebuggingManager != null) { |
| mDebuggingManager.dump(pw); |
| } |
| } |
| |
| private native String[] nativeGetAccessoryStrings(); |
| |
| private native ParcelFileDescriptor nativeOpenAccessory(); |
| |
| private native boolean nativeIsStartRequested(); |
| |
| private native int nativeGetAudioMode(); |
| } |
