From b401e0a8bbde930d54bd8dee5dda0a76090d79a3 Mon Sep 17 00:00:00 2001 From: Joshua Duong Date: Thu, 2 Jan 2020 13:19:54 -0800 Subject: [PATCH] Add AdbTransportType.aidl. Add AdbWifi internal API stubs. Since wireless debugging can be enabled without usb debugging enabled, we'll need to differentiate between which transport is enabled. Also added the internal AdbManager stubs for wireless debugging. Adding implementation in separate CL to get around merge conflict with a SysUI CL in the stack. BUG: b/111434128 Test: make Exempt-From-Owner-Approval: already approved Change-Id: I4e1ae6398f291f321e61e7eb119564ebd5e54c2e --- core/java/android/debug/AdbManager.java | 108 ++++++++++ .../android/debug/AdbManagerInternal.java | 2 +- core/java/android/debug/AdbTransportType.aidl | 25 +++ core/java/android/debug/IAdbManager.aidl | 56 +++++ core/java/android/debug/IAdbTransport.aidl | 4 +- core/java/android/debug/PairDevice.java | 112 ++++++++++ core/res/AndroidManifest.xml | 3 + .../server/adb/AdbDebuggingManager.java | 21 +- .../com/android/server/adb/AdbService.java | 202 +++++++++++------- .../android/server/usb/UsbDeviceManager.java | 10 +- 10 files changed, 458 insertions(+), 85 deletions(-) create mode 100644 core/java/android/debug/AdbTransportType.aidl create mode 100644 core/java/android/debug/PairDevice.java diff --git a/core/java/android/debug/AdbManager.java b/core/java/android/debug/AdbManager.java index 0a76bedcd66ee..7714dd80f9100 100644 --- a/core/java/android/debug/AdbManager.java +++ b/core/java/android/debug/AdbManager.java @@ -31,6 +31,114 @@ import android.os.RemoteException; public class AdbManager { private static final String TAG = "AdbManager"; + /** + * Action indicating the state change of wireless debugging. Can be either + * STATUS_CONNECTED + * STATUS_DISCONNECTED + * + * @hide + */ + public static final String WIRELESS_DEBUG_STATE_CHANGED_ACTION = + "com.android.server.adb.WIRELESS_DEBUG_STATUS"; + + /** + * Contains the list of paired devices. + * + * @hide + */ + public static final String WIRELESS_DEBUG_PAIRED_DEVICES_ACTION = + "com.android.server.adb.WIRELESS_DEBUG_PAIRED_DEVICES"; + + /** + * Action indicating the status of a pairing. Can be either + * WIRELESS_STATUS_FAIL + * WIRELESS_STATUS_SUCCESS + * WIRELESS_STATUS_CANCELLED + * WIRELESS_STATUS_PAIRING_CODE + * WIRELESS_STATUS_CONNECTED + * + * @hide + */ + public static final String WIRELESS_DEBUG_PAIRING_RESULT_ACTION = + "com.android.server.adb.WIRELESS_DEBUG_PAIRING_RESULT"; + + /** + * Extra containing the PairDevice map of paired/pairing devices. + * + * @hide + */ + public static final String WIRELESS_DEVICES_EXTRA = "devices_map"; + + /** + * The status of the pairing/unpairing. + * + * @hide + */ + public static final String WIRELESS_STATUS_EXTRA = "status"; + + /** + * The PairDevice. + * + * @hide + */ + public static final String WIRELESS_PAIR_DEVICE_EXTRA = "pair_device"; + + /** + * The six-digit pairing code. + * + * @hide + */ + public static final String WIRELESS_PAIRING_CODE_EXTRA = "pairing_code"; + + /** + * The adb connection/pairing port that was opened. + * + * @hide + */ + public static final String WIRELESS_DEBUG_PORT_EXTRA = "adb_port"; + + /** + * Status indicating the pairing/unpairing failed. + * + * @hide + */ + public static final int WIRELESS_STATUS_FAIL = 0; + + /** + * Status indicating the pairing/unpairing succeeded. + * + * @hide + */ + public static final int WIRELESS_STATUS_SUCCESS = 1; + + /** + * Status indicating the pairing/unpairing was cancelled. + * + * @hide + */ + public static final int WIRELESS_STATUS_CANCELLED = 2; + + /** + * Status indicating the pairing code for pairing. + * + * @hide + */ + public static final int WIRELESS_STATUS_PAIRING_CODE = 3; + + /** + * Status indicating wireless debugging is connected. + * + * @hide + */ + public static final int WIRELESS_STATUS_CONNECTED = 4; + + /** + * Status indicating wireless debugging is disconnected. + * + * @hide + */ + public static final int WIRELESS_STATUS_DISCONNECTED = 5; + private final Context mContext; private final IAdbManager mService; diff --git a/core/java/android/debug/AdbManagerInternal.java b/core/java/android/debug/AdbManagerInternal.java index 51eb7fc2d8048..0bd9f19f91fe6 100644 --- a/core/java/android/debug/AdbManagerInternal.java +++ b/core/java/android/debug/AdbManagerInternal.java @@ -42,7 +42,7 @@ public abstract class AdbManagerInternal { /** * Returns {@code true} if ADB debugging is enabled. */ - public abstract boolean isAdbEnabled(); + public abstract boolean isAdbEnabled(byte transportType); /** * Returns the file that contains all of the ADB keys used by the device. diff --git a/core/java/android/debug/AdbTransportType.aidl b/core/java/android/debug/AdbTransportType.aidl new file mode 100644 index 0000000000000..69046150d0ee6 --- /dev/null +++ b/core/java/android/debug/AdbTransportType.aidl @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2019 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.debug; + +/** @hide */ +@Backing(type="byte") +enum AdbTransportType { + USB, + WIFI, +} + diff --git a/core/java/android/debug/IAdbManager.aidl b/core/java/android/debug/IAdbManager.aidl index c48fc07791c0c..aea7633d91dcf 100644 --- a/core/java/android/debug/IAdbManager.aidl +++ b/core/java/android/debug/IAdbManager.aidl @@ -42,6 +42,62 @@ interface IAdbManager { */ void clearDebuggingKeys(); + /** + * Allow ADB wireless debugging on the connected network. If {@code alwaysAllow} + * is {@code true}, add {@code bssid} to list of networks that the user has + * approved. + * + * @param alwaysAllow if true, add permanently to list of allowed networks + * @param bssid BSSID of the network + */ + void allowWirelessDebugging(boolean alwaysAllow, String bssid); + + /** + * Deny ADB wireless debugging on the connected network. + */ + void denyWirelessDebugging(); + + /** + * Returns a Map with the key fingerprint mapped to the device information. + */ + Map getPairedDevices(); + + /** + * Unpair the device identified by the key fingerprint it uses. + * + * @param fingerprint fingerprint of the key the device is using. + */ + void unpairDevice(String fingerprint); + + /** + * Enables pairing by pairing code. The result of the enable will be sent via intent action + * {@link android.debug.AdbManager#WIRELESS_DEBUG_ENABLE_DISCOVER_ACTION}. Furthermore, the + * pairing code will also be sent in the intent as an extra + * @{link android.debug.AdbManager#WIRELESS_PAIRING_CODE_EXTRA}. Note that only one + * pairing method can be enabled at a time, either by pairing code, or by QR code. + */ + void enablePairingByPairingCode(); + + /** + * Enables pairing by QR code. The result of the enable will be sent via intent action + * {@link android.debug.AdbManager#WIRELESS_DEBUG_ENABLE_DISCOVER_ACTION}. Note that only one + * pairing method can be enabled at a time, either by pairing code, or by QR code. + * + * @param serviceName The MDNS service name parsed from the QR code. + * @param password The password parsed from the QR code. + */ + void enablePairingByQrCode(String serviceName, String password); + + /** + * Returns the network port that adb wireless server is running on. + */ + int getAdbWirelessPort(); + + /** + * Disables pairing. + */ + void disablePairing(); + /** * Returns true if device supports secure Adb over Wi-Fi. */ diff --git a/core/java/android/debug/IAdbTransport.aidl b/core/java/android/debug/IAdbTransport.aidl index 77211fc936937..f018813408c48 100644 --- a/core/java/android/debug/IAdbTransport.aidl +++ b/core/java/android/debug/IAdbTransport.aidl @@ -16,7 +16,9 @@ package android.debug; +import android.debug.AdbTransportType; + /** @hide */ interface IAdbTransport { - void onAdbEnabled(boolean enabled); + void onAdbEnabled(boolean enabled, in AdbTransportType type); } diff --git a/core/java/android/debug/PairDevice.java b/core/java/android/debug/PairDevice.java new file mode 100644 index 0000000000000..2d5b446b4f8fa --- /dev/null +++ b/core/java/android/debug/PairDevice.java @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2020 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.debug; + +import android.annotation.NonNull; +import android.os.Parcel; +import android.os.Parcelable; + +import com.android.internal.annotations.Immutable; +import com.android.internal.util.Preconditions; + +/** + * Contains information about the client in an ADB connection. + * @hide + */ +@Immutable +public class PairDevice implements Parcelable { + /** + * The human-readable name of the device. + */ + @NonNull private final String mName; + + /** + * The device's guid. + */ + @NonNull private final String mGuid; + + /** + * Indicates whether the device is currently connected to adbd. + */ + private final boolean mConnected; + + public PairDevice(@NonNull String name, @NonNull String guid, boolean connected) { + Preconditions.checkStringNotEmpty(name); + Preconditions.checkStringNotEmpty(guid); + mName = name; + mGuid = guid; + mConnected = connected; + } + + /** + * @return the device name. + */ + @NonNull + public String getDeviceName() { + return mName; + } + + /** + * @return the device GUID. + */ + @NonNull + public String getGuid() { + return mGuid; + } + + /** + * @return the adb connection state of the device. + */ + public boolean isConnected() { + return mConnected; + } + + @Override + public void writeToParcel(@NonNull Parcel dest, int flags) { + dest.writeString(mName); + dest.writeString(mGuid); + dest.writeBoolean(mConnected); + } + + /** + * @return Human-readable info about the object. + */ + @Override + public String toString() { + return "\n" + mName + "\n" + mGuid + "\n" + mConnected; + } + + @Override + public int describeContents() { + return 0; + } + + @NonNull + public static final Parcelable.Creator CREATOR = + new Creator() { + @Override + public PairDevice createFromParcel(Parcel source) { + return new PairDevice(source.readString(), source.readString(), + source.readBoolean()); + } + + @Override + public PairDevice[] newArray(int size) { + return new PairDevice[size]; + } + }; +} diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml index 0a2c59f765f39..a5f6564b73a61 100644 --- a/core/res/AndroidManifest.xml +++ b/core/res/AndroidManifest.xml @@ -391,6 +391,9 @@ + + + diff --git a/services/core/java/com/android/server/adb/AdbDebuggingManager.java b/services/core/java/com/android/server/adb/AdbDebuggingManager.java index 4b48ef917744b..da93998c83ba6 100644 --- a/services/core/java/com/android/server/adb/AdbDebuggingManager.java +++ b/services/core/java/com/android/server/adb/AdbDebuggingManager.java @@ -29,6 +29,7 @@ import android.content.pm.UserInfo; import android.content.res.Resources; import android.database.ContentObserver; import android.debug.AdbProtoEnums; +import android.debug.AdbTransportType; import android.net.LocalSocket; import android.net.LocalSocketAddress; import android.net.Uri; @@ -717,13 +718,21 @@ public class AdbDebuggingManager { } /** - * When {@code enabled} is {@code true}, this allows ADB debugging and starts the ADB hanler - * thread. When {@code enabled} is {@code false}, this disallows ADB debugging and shuts - * down the handler thread. + * When {@code enabled} is {@code true}, this allows ADB debugging and starts the ADB handler + * thread. When {@code enabled} is {@code false}, this disallows ADB debugging for the given + * @{code transportType}. See {@link IAdbTransport} for all available transport types. + * If all transport types are disabled, the ADB handler thread will shut down. */ - public void setAdbEnabled(boolean enabled) { - mHandler.sendEmptyMessage(enabled ? AdbDebuggingHandler.MESSAGE_ADB_ENABLED - : AdbDebuggingHandler.MESSAGE_ADB_DISABLED); + public void setAdbEnabled(boolean enabled, byte transportType) { + if (transportType == AdbTransportType.USB) { + mHandler.sendEmptyMessage(enabled ? AdbDebuggingHandler.MESSAGE_ADB_ENABLED + : AdbDebuggingHandler.MESSAGE_ADB_DISABLED); + } else if (transportType == AdbTransportType.WIFI) { + // TODO(joshuaduong): Not implemented + } else { + throw new IllegalArgumentException( + "setAdbEnabled called with unimplemented transport type=" + transportType); + } } /** diff --git a/services/core/java/com/android/server/adb/AdbService.java b/services/core/java/com/android/server/adb/AdbService.java index c125b1baf8605..f2a8615dca889 100644 --- a/services/core/java/com/android/server/adb/AdbService.java +++ b/services/core/java/com/android/server/adb/AdbService.java @@ -15,19 +15,23 @@ */ package com.android.server.adb; +import static com.android.internal.util.function.pooled.PooledLambda.obtainMessage; + +import android.annotation.NonNull; +import android.annotation.UserIdInt; import android.content.ContentResolver; import android.content.Context; import android.content.pm.PackageManager; import android.database.ContentObserver; import android.debug.AdbManagerInternal; +import android.debug.AdbTransportType; import android.debug.IAdbManager; import android.debug.IAdbTransport; +import android.debug.PairDevice; import android.hardware.usb.UsbManager; +import android.net.Uri; import android.os.Binder; -import android.os.Handler; import android.os.IBinder; -import android.os.Looper; -import android.os.Message; import android.os.RemoteException; import android.os.SystemProperties; import android.provider.Settings; @@ -38,7 +42,6 @@ import android.util.ArraySet; import android.util.Slog; import android.util.proto.ProtoOutputStream; - import com.android.internal.util.DumpUtils; import com.android.internal.util.IndentingPrintWriter; import com.android.internal.util.dump.DualDumpOutputStream; @@ -50,6 +53,7 @@ import java.io.File; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.Collections; +import java.util.Map; /** * The Android Debug Bridge (ADB) service. This controls the availability of ADB and authorization @@ -77,7 +81,8 @@ public class AdbService extends IAdbManager.Stub { if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) { mAdbService.systemReady(); } else if (phase == SystemService.PHASE_BOOT_COMPLETED) { - mAdbService.bootCompleted(); + FgThread.getHandler().sendMessage(obtainMessage( + AdbService::bootCompleted, mAdbService)); } } } @@ -94,8 +99,14 @@ public class AdbService extends IAdbManager.Stub { } @Override - public boolean isAdbEnabled() { - return mAdbEnabled; + public boolean isAdbEnabled(byte transportType) { + if (transportType == AdbTransportType.USB) { + return mIsAdbUsbEnabled; + } else if (transportType == AdbTransportType.WIFI) { + return mIsAdbWifiEnabled; + } + throw new IllegalArgumentException( + "isAdbEnabled called with unimplemented transport type=" + transportType); } @Override @@ -109,77 +120,60 @@ public class AdbService extends IAdbManager.Stub { } } - private final class AdbHandler extends Handler { - AdbHandler(Looper looper) { - super(looper); - try { - /* - * Use the normal bootmode persistent prop to maintain state of adb across - * all boot modes. - */ - mAdbEnabled = containsFunction( - SystemProperties.get(USB_PERSISTENT_CONFIG_PROPERTY, ""), - UsbManager.USB_FUNCTION_ADB); + private void initAdbState() { + try { + /* + * Use the normal bootmode persistent prop to maintain state of adb across + * all boot modes. + */ + mIsAdbUsbEnabled = containsFunction( + SystemProperties.get(USB_PERSISTENT_CONFIG_PROPERTY, ""), + UsbManager.USB_FUNCTION_ADB); + // TODO(joshuaduong): Read the adb wifi state from a persistent system + // property (persist.sys.adb.wifi). + mIsAdbWifiEnabled = false; - // register observer to listen for settings changes - mContentResolver.registerContentObserver( - Settings.Global.getUriFor(Settings.Global.ADB_ENABLED), - false, new AdbSettingsObserver()); - } catch (Exception e) { - Slog.e(TAG, "Error initializing AdbHandler", e); - } - } - - private boolean containsFunction(String functions, String function) { - int index = functions.indexOf(function); - if (index < 0) return false; - if (index > 0 && functions.charAt(index - 1) != ',') return false; - int charAfter = index + function.length(); - if (charAfter < functions.length() && functions.charAt(charAfter) != ',') return false; - return true; - } - - public void sendMessage(int what, boolean arg) { - removeMessages(what); - Message m = Message.obtain(this, what); - m.arg1 = (arg ? 1 : 0); - sendMessage(m); - } - - @Override - public void handleMessage(Message msg) { - switch (msg.what) { - case MSG_ENABLE_ADB: - setAdbEnabled(msg.arg1 == 1); - break; - case MSG_BOOT_COMPLETED: - if (mDebuggingManager != null) { - mDebuggingManager.setAdbEnabled(mAdbEnabled); - } - break; - } + // register observer to listen for settings changes + mContentResolver.registerContentObserver( + Settings.Global.getUriFor(Settings.Global.ADB_ENABLED), + false, new AdbSettingsObserver()); + } catch (Exception e) { + Slog.e(TAG, "Error in initAdbState", e); } } + private static boolean containsFunction(String functions, String function) { + int index = functions.indexOf(function); + if (index < 0) return false; + if (index > 0 && functions.charAt(index - 1) != ',') return false; + int charAfter = index + function.length(); + if (charAfter < functions.length() && functions.charAt(charAfter) != ',') return false; + return true; + } + private class AdbSettingsObserver extends ContentObserver { + private final Uri mAdbUsbUri = Settings.Global.getUriFor(Settings.Global.ADB_ENABLED); + 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); + public void onChange(boolean selfChange, @NonNull Uri uri, @UserIdInt int userId) { + if (mAdbUsbUri.equals(uri)) { + boolean shouldEnable = (Settings.Global.getInt(mContentResolver, + Settings.Global.ADB_ENABLED, 0) > 0); + FgThread.getHandler().sendMessage(obtainMessage( + AdbService::setAdbEnabled, AdbService.this, shouldEnable, + AdbTransportType.USB)); + } + // TODO(joshuaduong): Add condition for WIFI transport } } private static final String TAG = "AdbService"; private static final boolean DEBUG = false; - private static final int MSG_ENABLE_ADB = 1; - private static final int MSG_BOOT_COMPLETED = 2; - /** * The persistent property which stores whether adb is enabled or not. * May also contain vendor-specific default functions for testing purposes. @@ -188,10 +182,10 @@ public class AdbService extends IAdbManager.Stub { private final Context mContext; private final ContentResolver mContentResolver; - private final AdbService.AdbHandler mHandler; private final ArrayMap mTransports = new ArrayMap<>(); - private boolean mAdbEnabled; + private boolean mIsAdbUsbEnabled; + private boolean mIsAdbWifiEnabled; private AdbDebuggingManager mDebuggingManager; private AdbService(Context context) { @@ -204,8 +198,7 @@ public class AdbService extends IAdbManager.Stub { mDebuggingManager = new AdbDebuggingManager(context); } - mHandler = new AdbHandler(FgThread.get().getLooper()); - + initAdbState(); LocalServices.addService(AdbManagerInternal.class, new AdbManagerInternalImpl()); } @@ -219,7 +212,7 @@ public class AdbService extends IAdbManager.Stub { // make sure the ADB_ENABLED setting value matches the current state try { Settings.Global.putInt(mContentResolver, - Settings.Global.ADB_ENABLED, mAdbEnabled ? 1 : 0); + Settings.Global.ADB_ENABLED, mIsAdbUsbEnabled ? 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."); @@ -231,7 +224,10 @@ public class AdbService extends IAdbManager.Stub { */ public void bootCompleted() { if (DEBUG) Slog.d(TAG, "boot completed"); - mHandler.sendEmptyMessage(MSG_BOOT_COMPLETED); + if (mDebuggingManager != null) { + mDebuggingManager.setAdbEnabled(mIsAdbUsbEnabled, AdbTransportType.USB); + mDebuggingManager.setAdbEnabled(mIsAdbWifiEnabled, AdbTransportType.WIFI); + } } @Override @@ -285,24 +281,82 @@ public class AdbService extends IAdbManager.Stub { PackageManager.FEATURE_CAMERA_ANY); } - private void setAdbEnabled(boolean enable) { - if (DEBUG) Slog.d(TAG, "setAdbEnabled(" + enable + "), mAdbEnabled=" + mAdbEnabled); + @Override + public void allowWirelessDebugging(boolean alwaysAllow, String bssid) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + } - if (enable == mAdbEnabled) { + @Override + public void denyWirelessDebugging() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + } + + @Override + public Map getPairedDevices() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + return null; + } + + @Override + public void unpairDevice(String fingerprint) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + } + + @Override + public void enablePairingByPairingCode() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + } + + @Override + public void enablePairingByQrCode(String serviceName, String password) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + } + + @Override + public void disablePairing() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + } + + @Override + public int getAdbWirelessPort() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_DEBUGGING, null); + // TODO(joshuaduong): NOT IMPLEMENTED + return 0; + } + + private void setAdbEnabled(boolean enable, byte transportType) { + if (DEBUG) { + Slog.d(TAG, "setAdbEnabled(" + enable + "), mIsAdbUsbEnabled=" + mIsAdbUsbEnabled + + ", mIsAdbWifiEnabled=" + mIsAdbWifiEnabled + ", transportType=" + + transportType); + } + + if (transportType == AdbTransportType.USB && enable != mIsAdbUsbEnabled) { + mIsAdbUsbEnabled = enable; + } else if (transportType == AdbTransportType.WIFI && enable != mIsAdbWifiEnabled) { + mIsAdbWifiEnabled = enable; + } else { + // No change return; } - mAdbEnabled = enable; for (IAdbTransport transport : mTransports.values()) { try { - transport.onAdbEnabled(enable); + transport.onAdbEnabled(enable, transportType); } catch (RemoteException e) { Slog.w(TAG, "Unable to send onAdbEnabled to transport " + transport.toString()); } } if (mDebuggingManager != null) { - mDebuggingManager.setAdbEnabled(enable); + mDebuggingManager.setAdbEnabled(enable, transportType); } } diff --git a/services/usb/java/com/android/server/usb/UsbDeviceManager.java b/services/usb/java/com/android/server/usb/UsbDeviceManager.java index 45b840ca976a0..5bb75c92fd30f 100644 --- a/services/usb/java/com/android/server/usb/UsbDeviceManager.java +++ b/services/usb/java/com/android/server/usb/UsbDeviceManager.java @@ -41,6 +41,7 @@ import android.content.SharedPreferences; import android.content.pm.PackageManager; import android.content.res.Resources; import android.debug.AdbManagerInternal; +import android.debug.AdbTransportType; import android.debug.IAdbTransport; import android.hardware.usb.ParcelableUsbPort; import android.hardware.usb.UsbAccessory; @@ -774,8 +775,10 @@ public class UsbDeviceManager implements ActivityTaskManagerInternal.ScreenObser } @Override - public void onAdbEnabled(boolean enabled) { - mHandler.sendMessage(MSG_ENABLE_ADB, enabled); + public void onAdbEnabled(boolean enabled, byte transportType) { + if (transportType == AdbTransportType.USB) { + mHandler.sendMessage(MSG_ENABLE_ADB, enabled); + } } } @@ -1169,7 +1172,8 @@ public class UsbDeviceManager implements ActivityTaskManagerInternal.ScreenObser } protected boolean isAdbEnabled() { - return LocalServices.getService(AdbManagerInternal.class).isAdbEnabled(); + return LocalServices.getService(AdbManagerInternal.class) + .isAdbEnabled(AdbTransportType.USB); } protected void updateAdbNotification(boolean force) {