-
Android 13 网络 Adb相关流程深入分析研究
Android 13 网络 Adb 分析研究
一、前言
通过代码分析发现Android13 上对 网络adb 进行了限制！
Android13原生代码要求：必现连接上某个wifi，才能进行adb ，并且切换wifi或者关闭wifi都是会停止adb。
并且Android13 上 wifi adb 端口号每次是变化的，这个也是很不方便的！如果要做成Android11 或者之前一样，设备连接WiFi/有线网络后电脑可以直接进行adb连接，就要对系统代码进行适配修改。
之前以为设置端口号和persist.adb.tls_server.enable 属性就ok了，但是还是有些小bug，还是要完全研究一遍具体流程。
之前已经发过 adb默认端口号设置：
https://blog.csdn.net/wenzhi20102321/article/details/131056174默认adb实现简单分析：
https://blog.csdn.net/wenzhi20102321/article/details/131774893
默认adb开启分析：
https://blog.csdn.net/wenzhi20102321/article/details/132382549后面两个文章都是有进行了简单研究和参考价值，当时整个流程还是可以更深入了解一些，所以特意再写一篇。
这个也是全网第一个比较全面分析 Android12以上的wifi adb 代码的文章了，需要的可以点赞收藏。
下面几个分析到的Android13 的adb相关源码文件：
https://download.csdn.net/download/wenzhi20102321/88306366
二、默认adb 代码实现
关键：
1、mk 设置系统属性：persist.adb.tls_server.enable=1 2、写死端口号 5555 3、注释若干判断Wifi情况停止adb的代码- 1
- 2
- 3
- 4
1、修改的目录：
packages\modules\adb\daemon\adb_wifi.cpp framework\base\services\core\java\com\android\server\adb\AdbDebuggingManager.java //修改前面两个文件就可以实现adb了，后面的文件试辅助分析的。 //虽然 SettingsProvider 也有加载 Settings属性 Settings.Global.ADB_WIFI_ENABLED ， //但是 prop那个属性更优先，所以可以不用考虑这里默认情况 framework\base\packages\SettingsProvider\src\com\android\providers\settings\SettingsProvider.java //增加分析定位文件，系统服务启动后会判断 属性persist.adb.tls_server.enable 进行相关操作 //如果属性设置不生效，可以在这里添加打印日志查看过程 framework\base\services\core\java\com\android\server\adb\AdbService.java- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
2、具体修改：
（1）在XXX_device.mk 添加属性
persist.adb.tls_server.enable = 1- 1
- 2
手动添加，也是会记忆的！
//设置 setprop persist.adb.tls_server.enable 1 //查询 getprop persist.adb.tls_server.enable //可以查看其他adb相关属性 getprop | grep adb- 1
- 2
- 3
- 4
- 5
- 6
（2）设置固定端口号
+++ b/release/packages/modules/adb/daemon/adb_wifi.cpp @@ -160,7 +160,8 @@ static void enable_wifi_debugging() { if (sTlsServer != nullptr) { delete sTlsServer; } - sTlsServer = new TlsServer(0); + // default port 0 means random,change to 5555 ,by liwenzhi + sTlsServer = new TlsServer(5555); if (!sTlsServer->Start()) { LOG(ERROR) << "Failed to start TlsServer"; delete sTlsServer;- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
固定端口号，必须是这里设置，使用service.adb.tls.port属性设置其实是没用的！
（3）去除判断网络后，设置 ADB_WIFI_ENABLED 为 0 的代码
去吃wifi网络判断，是能有线网adb和wifi 修改后还是正常adb 的关键。
一个是初始化的时候判断，另外一个是监听网络变化的时候判断，都去掉就行。+++ b/release/frameworks/base/services/core/java/com/android/server/adb/AdbDebuggingManager.java public class AdbDebuggingManager { case MSG_ADBDWIFI_ENABLE: { if (mAdbWifiEnabled) { break; } //not to check network state ,change by liwenzhi //（1）去除下面一大段判断网络和监听网络的代码 /** AdbConnectionInfo currentInfo = getCurrentWifiApInfo(); if (currentInfo == null) { Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); //关闭 adb wifi break; } if (!verifyWifiNetwork(currentInfo.getBSSID(), currentInfo.getSSID())) { // This means that the network is not in the list of trusted networks. // We'll give user a prompt on whether to allow wireless debugging on // the current wifi network. Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); break; } setAdbConnectionInfo(currentInfo); **/ //no listener network change for disable adb_wifi,by liwenzhi /** IntentFilter intentFilter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION); intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); mContext.registerReceiver(mBroadcastReceiver, intentFilter); **/ SystemProperties.set(WIFI_PERSISTENT_CONFIG_PROPERTY, "1"); case MSG_ADBDWIFI_DISABLE: if (!mAdbWifiEnabled) { break; } mAdbWifiEnabled = false; setAdbConnectionInfo(null); //no need unregisterReceiver, because no listener network,chenge by liwenzhi，//（2）监听已经注释，不需要再注销监听 //mContext.unregisterReceiver(mBroadcastReceiver); case MSG_ADBWIFI_ALLOW: if (mAdbWifiEnabled) { break; } String bssid = (String) msg.obj; boolean alwaysAllow = msg.arg1 == 1; if (alwaysAllow) { mAdbKeyStore.addTrustedNetwork(bssid); } // Let's check again to make sure we didn't switch networks while verifying // the wifi bssid. //no to check network ,change by liwenzhi //（3）不需要判断网络 /** AdbConnectionInfo newInfo = getCurrentWifiApInfo(); if (newInfo == null || !bssid.equals(newInfo.getBSSID())) { break; } setAdbConnectionInfo(newInfo); **/ Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 1); //no listener network change for disable adb_wifi,by liwenzhi //（4）不需要要监听网络变化 /** IntentFilter intentFilter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION); intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); mContext.registerReceiver(mBroadcastReceiver, intentFilter); **/ SystemProperties.set(WIFI_PERSISTENT_CONFIG_PROPERTY, "1");- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
从上面代码看到未连接wifi的情况，getCurrentWifiApInfo 获取为null，会执行关闭wifi adb！
并且还有很多网络开关变化和网络状态变化的判断。三、日志分析查看
日志分析查看主要是：AdbService.java、AdbDebuggingManager.java、adb_wifi.cpp
AdbService 的日志默认是关闭模式的，需要设置成true，并且如果要看里面数据具体值，相关属性的日志需要自己添加打印出来。
AdbDebuggingManager 是有相关异常过程日志的
adb_wifi 该文件的打印，TAG 是adbd, 不管有没有打开adb，整个系统是一直有这个 adbd 的相关打印的，每秒大概有十几行日志！这里查看打印相关日志多个关键字的信息命令：
可能每个系统的日志都不一样，这里因供参考：
logcat | grep -E "lwz|AdbService|changed to|adb wifi|AdbDebuggingManager"- 1
- 2
- 3
lwz 是我自己加的关键字。
通过日志查看，正常开启的情况大概日志过程是：
01-01 08:00:22.756 496 511 I adbd : Waiting for persist.adb.tls_server.enable=1 08-16 15:13:50.123 762 762 D SystemServerTiming: StartAdbService 08-16 15:13:51.528 762 762 D AdbService: systemReady //修改 DEBUG = true 才看到的日志 08-16 15:13:51.528 762 762 D AdbService: lwz systemReady= persist.adb.tls_server.enable = 1 //自己加的日志打印 08-16 15:13:51.528 762 762 D AdbService: lwz systemReady mIsAdbWifiEnabled= true //自己加的日志打印，确认查看服务启动是否打开 adb 08-16 15:13:58.993 762 799 D AdbService: setAdbEnabled(true), mIsAdbUsbEnabled=true, mIsAdbWifiEnabled=true, transportType=0 08-16 15:13:58.994 762 762 D AdbService: lwz onChange shouldEnable = true 08-16 15:13:58.995 762 799 D AdbService: setAdbEnabled(true), mIsAdbUsbEnabled=true, mIsAdbWifiEnabled=true, transportType=1 08-16 15:13:59.015 762 802 D ActivityManagerTiming: OnBootPhase_1000_com.android.server.adb.AdbService$Lifecycle 08-16 15:13:59.016 762 802 V ActivityManagerTiming: OnBootPhase_1000_com.android.server.adb.AdbService$Lifecycle took to complete: 1ms 08-16 15:13:59.016 762 799 D AdbService: boot completed 08-16 15:13:59.033 496 511 I adbd : persist.adb.tls_server.enable changed to 1 //正常开启adb的日志 08-16 15:13:59.056 496 511 I adbd : adb wifi started on port 5555 08-16 15:13:59.058 496 511 I adbd : Waiting for persist.adb.tls_server.enable=0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
如果未屏蔽网络判断，添加打印日志查看过程:
08-18 16:51:20.104 762 762 D SystemServerTiming: OnBootPhase_550_com.android.server.adb.AdbService$Lifecycle 08-18 16:51:20.104 762 762 D AdbService: systemReady 08-18 16:51:20.105 762 762 D AdbService: lwz systemReady mIsAdbWifiEnabled= true //这里说明，prop 属性已经设置了 08-18 16:51:26.248 762 798 I AdbDebuggingManager: Not connected to any wireless network. Not enabling adbwifi. //这里提示没网络，会执行关闭adb 08-18 16:51:26.586 762 762 D AdbService: lwz onChange shouldEnable = false 08-18 16:51:27.411 762 762 D AdbService: lwz onChange shouldEnable = false 08-18 16:51:27.971 762 798 D AdbService: setAdbEnabled(true), mIsAdbUsbEnabled=true, mIsAdbWifiEnabled=true, transportType=0 08-18 16:51:27.972 762 798 D AdbService: setAdbEnabled(false), mIsAdbUsbEnabled=true, mIsAdbWifiEnabled=true, transportType=1 //关闭adb 08-18 16:51:27.973 510 517 I adbd : persist.adb.tls_server.enable changed to 0 //到这里 persist.adb.tls_server.enable 属性又变成了 0 08-18 16:51:27.973 510 517 I adbd : adb wifi stopped 08-18 16:51:27.981 762 798 D AdbService: Broadcasting enable = false, type = 1- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
这个也是为啥配置了那个 persist.adb.tls_server.enable =1 属性后，系统启动发现获取属性还是0 ，并且wifi adb未打开。
如果打开日志开关，并且没添加自定义日志，是不会有上面这么多日志显示的。
如果代码和属性都适配了，但是还是没有默认adb ，那么就是要好好梳理代码或者多添加日志分析查看了。
四、代码流程
其实就是看 AdbService.java、AdbDebuggingManager.java、adb_wifi.cpp 这三个类之间的流程就差不多了。
adb_wifi.cpp 这类是Androi11以及之前的版本是没有的，其他的Java类是一直有的。
packages\modules\adb 这个目录也是Android12才开始有的1、adb_wifi 底层启动
里面的日志是跑在比较前面的，比SystemServer 更早。
也是为啥设置了 persist.adb.tls_server.enable=1 能够直接使能网络adb的原因。
正常开启和关闭adb 是有相关日志的。
具体启动adb 还是靠上层调用了接口到底层才会进行开启的。这里看一段最重要的代码
const char kWifiPortProp[] = "service.adb.tls.port"; //（1）adb 端口号属性 const char kWifiEnabledProp[] = "persist.adb.tls_server.enable"; //（2）adb prop 开关属性 //（3）底层开启adb 具体实现 static void enable_wifi_debugging() { start_mdnsd(); if (sTlsServer != nullptr) { delete sTlsServer; } sTlsServer = new TlsServer(5555); //（4）写死端口号，不写死会随机生成 if (!sTlsServer->Start()) { LOG(ERROR) << "Failed to start TlsServer"; delete sTlsServer; sTlsServer = nullptr; return; } // Start mdns connect service for discovery register_adb_secure_connect_service(sTlsServer->port()); //（5）开启 adb 后，这里是会有打印的，并且对端口号属性进行了赋值 //所以代码中设置端口号的prop 数值是没啥意义的 LOG(INFO) << "lwz adb wifi started on port " << sTlsServer->port(); SetProperty(kWifiPortProp, std::to_string(sTlsServer->port())); } //（6）底层关闭adb 具体实现 static void disable_wifi_debugging() { if (sTlsServer != nullptr) { delete sTlsServer; sTlsServer = nullptr; } if (is_adb_secure_connect_service_registered()) { unregister_adb_secure_connect_service(); } kick_all_tcp_tls_transports(); //（7）关闭 adb 后，这里是会有打印的，并且对端口号属性进行了赋值 //所以代码中设置端口号的prop 数值是没啥意义的 LOG(INFO) << "adb wifi stopped"; SetProperty(kWifiPortProp, ""); } //（8）关键：这个逻辑不难，刚开始看懵了！！ // Watches for the #kWifiEnabledProp property to toggle the TlsServer static void start_wifi_enabled_observer() { std::thread([]() { bool wifi_enabled = false; while (true) { // （9）这里不会阻塞，WaitForProperty 会等待属性设置，否则一直等待状态 std::string toggled_val = wifi_enabled ? "0" : "1"; LOG(INFO) << "lwz Waiting for " << kWifiEnabledProp << "=" << toggled_val; //（10）正常开机会打印这个,等待进入1，即等待开启状态 if (WaitForProperty(kWifiEnabledProp, toggled_val)) { //底层的等待状态，等待某个属性变成某个值 wifi_enabled = !wifi_enabled; // （11）prop 属性变化，这里会有打印 //上面是while true,这里修改后，马上又进入了 “Waiting for”下一次属性变化的监听 LOG(INFO) << kWifiEnabledProp << " changed to " << toggled_val; if (wifi_enabled) { enable_wifi_debugging(); //（12）开启adb } else { disable_wifi_debugging(); //（13）关闭adb } } } }).detach(); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
上面13 个主要的点就是，adb cpp里面的重要流程。
其他更具体和底层的这里不进行研究分析。参考别人写的adb 的底层线程逻辑：
https://blog.csdn.net/qq_35970872/article/details/78912611
Android13 上也有相关的底层逻辑，代码路径：
packages\modules\adb\transport.cpp- 1
- 2
里面有线程一直在读取数据，具体逻辑我也看不懂，就不分析研究了！
2、adb 上层启动
AdbService 是SystemServer 执行 startOtherServices 里面启动的服务。
AdbService extends IAdbManager.Stub //具体暴露接口可以看 IAdbManager
AdbDebuggingManager 是一个管理adbDebug的类，在 AdbService 里面实例化，其实就是分化了一下具体执行的代码。
很多无法进入adb wifi 的情况都是在AdbDebuggingManager 拒绝的，并且重新设置了 Global属性 和 Prop 属性为0
（1）SystemServce.java 启动AdbServices代码
framework\base\services\java\com\android\server\SystemServer.java
/** * Entry point to {@code system_server}. */ public final class SystemServer implements Dumpable { private static final String ADB_SERVICE_CLASS = "com.android.server.adb.AdbService$Lifecycle"; /** * The main entry point from zygote. */ public static void main(String[] args) { //（1）java 入口方法 new SystemServer().run(); } private void run() { //（2）启动上层系统相关服务 t.traceBegin("StartServices"); startBootstrapServices(t); //启动核心服务，电源管理、AMS、WMS、PMS等服务 startCoreServices(t); //启动关键服务，电池状态信息等服务 startOtherServices(t); //（3）启动其他服务（最多），蓝牙，wifi，通知，adb等服务 startApexServices(t); //启动app相关服务 } private void startOtherServices(@NonNull TimingsTraceAndSlog t) { //（4）启动其他服务 t.traceBegin("startOtherServices"); // Start ADB Debugging Service t.traceBegin("StartAdbService"); try { mSystemServiceManager.startService(ADB_SERVICE_CLASS); //启动蓝牙相关服务 } catch (Throwable e) { Slog.e(TAG, "Failure starting AdbService"); } t.traceEnd(); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
（2）AdbServices.java 服务启动后关键代码
这个AdbService 不是具体的服务（不是四大组件里面的Service），而是通过AIDL绑定的服务，
别的类可以通过这个服务的接口对象IXXX/Manager调用里面的实现。有个特殊的是这里有 继承了 SystemService 能监听系统启动完成。
framework\base\services\core\java\com\android\server\adb\AdbService.java
public class AdbService extends IAdbManager.Stub { //（1）不是普通Service private static final boolean DEBUG = true; //打印默认为false，可以修改true 打开她 private static final String USB_PERSISTENT_CONFIG_PROPERTY = "persist.sys.usb.config"; private static final String WIFI_PERSISTENT_CONFIG_PROPERTY = "persist.adb.tls_server.enable"; private AdbService(Context context) { mContext = context; mContentResolver = context.getContentResolver(); mDebuggingManager = new AdbDebuggingManager(context); //（2）从这里看就知道 AdbDebuggingManager 不是 AdbServices 的暴露Manager registerContentObservers(); //（3）监听 Settings.Global.ADB_WIFI_ENABLED 属性变化 LocalServices.addService(AdbManagerInternal.class, new AdbManagerInternalImpl()); } /** * Manages the service lifecycle for {@code AdbService} in {@code SystemServer}. */ public static class Lifecycle extends SystemService { //（4）监听系统启动 private AdbService mAdbService; public Lifecycle(Context context) { super(context); } @Override public void onStart() { mAdbService = new AdbService(getContext()); //（5）系统启动，创建对象 publishBinderService(Context.ADB_SERVICE, mAdbService); } @Override public void onBootPhase(int phase) { if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) { //这个消息其实是SystemServer在启动OtherServie中间代码发出的。 mAdbService.systemReady(); //（6）系统关键服务启动完成，调用。这里比开机广播早。 } else if (phase == SystemService.PHASE_BOOT_COMPLETED) { // 里面的 bootCompleted 方法也是重新调用了开关Wifi adb，不过不一定会跑这里。我这系统代码没看到跑这里。 FgThread.getHandler().sendMessage(obtainMessage( AdbService::bootCompleted, mAdbService)); } } } /** * Called in response to {@code SystemService.PHASE_ACTIVITY_MANAGER_READY} from {@code * SystemServer}. */ public void systemReady() { //（7）系统关键服务启动完成 if (DEBUG) Slog.d(TAG, "systemReady"); /* * Use the normal bootmode persistent prop to maintain state of adb across * all boot modes. */ //（8）判断Usb调试 是否打开 mIsAdbUsbEnabled = containsFunction( SystemProperties.get(USB_PERSISTENT_CONFIG_PROPERTY, ""), //USB_PERSISTENT_CONFIG_PROPERTY=sys.usb.config UsbManager.USB_FUNCTION_ADB); // USB_FUNCTION_ADB=adb boolean shouldEnableAdbUsb = mIsAdbUsbEnabled || SystemProperties.getBoolean( TestHarnessModeService.TEST_HARNESS_MODE_PROPERTY, false); //属性： persist.sys.test_harness // 可以添加打印查看prop属性， Slog.d(TAG, "lwz systemReady= " + WIFI_PERSISTENT_CONFIG_PROPERTY + " = " + SystemProperties.get(WIFI_PERSISTENT_CONFIG_PROPERTY, "0")); // （9）判断Wifi adb 是否打开，persist.adb.tls_server.enable 属性是否为1 mIsAdbWifiEnabled = "1".equals(SystemProperties.get(WIFI_PERSISTENT_CONFIG_PROPERTY, "0")); // 可以添加打印查看是否是打开wifiadb状态， Slog.d(TAG, "lwz systemReady mIsAdbWifiEnabled= " + mIsAdbWifiEnabled); // make sure the ADB_ENABLED setting value matches the current state try { //（10）保存Settings 属性后会有重新调用 setAdbEnabled，因为这里进行了监听 Settings.Global.putInt(mContentResolver, Settings.Global.ADB_ENABLED, shouldEnableAdbUsb ? 1 : 0); Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, mIsAdbWifiEnabled ? 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."); } } /** * Called in response to {@code SystemService.PHASE_BOOT_COMPLETED} from {@code SystemServer}. */ public void bootCompleted() { //开机完成后，调用设置方法，这边不一定调用到！ if (DEBUG) Slog.d(TAG, "boot completed + mIsAdbWifiEnabled" + mIsAdbWifiEnabled); if (mDebuggingManager != null) { mDebuggingManager.setAdbEnabled(mIsAdbUsbEnabled, AdbTransportType.USB); mDebuggingManager.setAdbEnabled(mIsAdbWifiEnabled, AdbTransportType.WIFI); } } } // （11）监听Settings属性变化 private void registerContentObservers() { try { // register observer to listen for settings changes mObserver = new AdbSettingsObserver(); //（12）注册监听usb开关和wifi adb开关 mContentResolver.registerContentObserver( Settings.Global.getUriFor(Settings.Global.ADB_ENABLED), false, mObserver); mContentResolver.registerContentObserver( Settings.Global.getUriFor(Settings.Global.ADB_WIFI_ENABLED), false, mObserver); } catch (Exception e) { Slog.e(TAG, "Error in registerContentObservers", e); } } // （13）Settings属性 内部监听类，这里说明代码中修改 ADB_WIFI_ENABLED 属性或者adb shell中动态修改属性，这里也是能收到的 private class AdbSettingsObserver extends ContentObserver { private final Uri mAdbUsbUri = Settings.Global.getUriFor(Settings.Global.ADB_ENABLED); private final Uri mAdbWifiUri = Settings.Global.getUriFor(Settings.Global.ADB_WIFI_ENABLED); AdbSettingsObserver() { super(null); } @Override 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)); } else if (mAdbWifiUri.equals(uri)) { // （14）ADB_WIFI_ENABLED 属性监听回调 boolean shouldEnable = (Settings.Global.getInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0) > 0); // （15）自己添加的打印，打印一下开关状态值 Slog.d(TAG, "lwz onChange shouldEnable = " + shouldEnable); // （16）系统属性值变化后，执行 AdbService.setAdbEnabled 方法 FgThread.getHandler().sendMessage(obtainMessage( AdbService::setAdbEnabled, AdbService.this, shouldEnable, AdbTransportType.WIFI)); } } } //（17） 执行usb 开关和adb开关的方法 private void setAdbEnabled(boolean enable, byte transportType) { //transportType ,usb =1,wifi = 1 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; if (mIsAdbWifiEnabled) { if (!AdbProperties.secure().orElse(false) && mDebuggingManager == null) { // Start adbd. If this is secure adb, then we defer enabling adb over WiFi. SystemProperties.set(WIFI_PERSISTENT_CONFIG_PROPERTY, "1"); mConnectionPortPoller = new AdbDebuggingManager.AdbConnectionPortPoller(mPortListener); mConnectionPortPoller.start(); // （18） AdbConnectionPortPoller 是一个线程对象，不清楚为啥要启动这个线程，底层也有线程！里面没看到做非常重要的事情。 } } else { // Stop adb over WiFi. SystemProperties.set(WIFI_PERSISTENT_CONFIG_PROPERTY, "0"); if (mConnectionPortPoller != null) { mConnectionPortPoller.cancelAndWait(); //停止线程 mConnectionPortPoller = null; } } } else { // No change return; } if (enable) { startAdbd(); //这里的start 和 stop 无关紧要，不用关注 } else { stopAdbd(); } 。。。。 // （19）其实这里调用 DebuggingManager 方法才是最关键的，其他都是kalife if (mDebuggingManager != null) { mDebuggingManager.setAdbEnabled(enable, transportType); } } //这个的startAdbd 只设置了一个属性，没看到上层有判断使用，可能底层有读取这个属性 private void startAdbd() { SystemProperties.set(CTL_START, ADBD); } //这个的stopAdbd 只设置了一个属性， private void stopAdbd() { if (!mIsAdbUsbEnabled && !mIsAdbWifiEnabled) { SystemProperties.set(CTL_STOP, ADBD); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
下面就是关键代码，AdbDebuggingManager 的分析
framework\base\services\core\java\com\android\server\adb\AdbDebuggingManager.java
private static final String TAG = "AdbDebuggingManager"; private static final boolean DEBUG = false; //打印默认为false，调试可以修改为true，查看相关日志 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) { mHandler.sendEmptyMessage(enabled ? AdbDebuggingHandler.MSG_ADBDWIFI_ENABLE : AdbDebuggingHandler.MSG_ADBDWIFI_DISABLE); } } public void handleMessage(Message msg) { initKeyStore(); switch (msg.what) { case MESSAGE_ADB_ENABLED: ... case MESSAGE_ADB_DISABLED: ... case MSG_ADBDWIFI_ENABLE: { //（1）收到打开wifiadb 消息 if (mAdbWifiEnabled) { //(2) 已经打开的情况不用继续打开 break; } //not to check network state ,change by liwenzhi // （3） 注释未打开wifi和未连接wifi情况下，调用关闭adb wifi 的代码 /** AdbConnectionInfo currentInfo = getCurrentWifiApInfo(); //这里是校验当前网络是否连接wifi if (currentInfo == null) { Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); //（4）未连接wifi，关闭wifi adb的情况 break; } if (!verifyWifiNetwork(currentInfo.getBSSID(), currentInfo.getSSID())) { //这里是校验，当前连接的网络是否是上次连接的那个网络 // This means that the network is not in the list of trusted networks. // We'll give user a prompt on whether to allow wireless debugging on // the current wifi network. Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); //（5）切换到其他网络，关闭wifi adb的情况 break; } //这个是保存当前连接的wifi，就是为了区分下次连接的wifi是否和上次一致 setAdbConnectionInfo(currentInfo); **/ //no listener network change for disable adb_wifi,by liwenzhi // （6） 注释网络变化的监听，只要网络变化都会导致关闭wifi adb /** IntentFilter intentFilter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION); intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); mContext.registerReceiver(mBroadcastReceiver, intentFilter); **/ SystemProperties.set(WIFI_PERSISTENT_CONFIG_PROPERTY, "1"); mConnectionPortPoller = new AdbDebuggingManager.AdbConnectionPortPoller(mPortListener); mConnectionPortPoller.start(); startAdbDebuggingThread(); //这线程主要是为了一直监听获取outputStream和inputStream数据，这里好像会记录每一个连接的adb设备， mAdbWifiEnabled = true; if (DEBUG) Slog.i(TAG, "adb start wireless adb"); break; case MSG_ADBDWIFI_DISABLE: //关闭wifi adb if (!mAdbWifiEnabled) { //已经关闭的情况不用管 break; } mAdbWifiEnabled = false; setAdbConnectionInfo(null); //设置保存的连接wifi信息为null mContext.unregisterReceiver(mBroadcastReceiver); //如果上面监听注释了，这里也要注释 if (mThread != null) { mThread.sendResponse(MSG_DISABLE_ADBDWIFI); } onAdbdWifiServerDisconnected(-1); //这里主要是发送通知和发送广播 stopAdbDebuggingThread(); //停止相关线程 break; } } // （7）自定义handler内部类，内部包含接收网络变化自定义广播接收器 class AdbDebuggingHandler extends Handler { private NotificationManager mNotificationManager; private boolean mAdbNotificationShown; private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); // We only care about when wifi is disabled, and when there is a wifi network // change. if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)) { // （8）监听wifi开关变化 int state = intent.getIntExtra( WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_DISABLED); if (state == WifiManager.WIFI_STATE_DISABLED) { // （9）wifi关闭的情况，关闭wifi adb Slog.i(TAG, "Wifi disabled. Disabling adbwifi."); Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); } } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) { // （10）监听wifi连接情况变化 // We only care about wifi type connections NetworkInfo networkInfo = (NetworkInfo) intent.getParcelableExtra( WifiManager.EXTRA_NETWORK_INFO); if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) { // Check for network disconnect if (!networkInfo.isConnected()) { // （10）发生连接变化后，如果不是连接状态，就关闭wifi adb Slog.i(TAG, "Network disconnected. Disabling adbwifi."); Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); return; } WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE); WifiInfo wifiInfo = wifiManager.getConnectionInfo(); if (wifiInfo == null || wifiInfo.getNetworkId() == -1) { // （11）发生连接变化后，如果信息状态不对，就关闭wifi adb Slog.i(TAG, "Not connected to any wireless network." + " Not enabling adbwifi."); Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); } // Check for network change String bssid = wifiInfo.getBSSID(); if (bssid == null || bssid.isEmpty()) { // （12）发生连接变化后，如果信息ssid不对，就关闭wifi adb Slog.e(TAG, "Unable to get the wifi ap's BSSID. Disabling adbwifi."); Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); } synchronized (mAdbConnectionInfo) { if (!bssid.equals(mAdbConnectionInfo.getBSSID())) { // （12）发生连接变化后，如果和上次连接的wifi不同，就关闭wifi adb Slog.i(TAG, "Detected wifi network change. Disabling adbwifi."); Settings.Global.putInt(mContentResolver, Settings.Global.ADB_WIFI_ENABLED, 0); } } } } } };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
从上面代码可以看到 很多情况都有设置了ADB_WIFI_ENABLED 关闭的行为。
如果没有强制的安全要求，是可以把这些关闭的，目前测试还未发现啥问题。这里设置了 Settings.Global.ADB_WIFI_ENABLED 属性代码，那么哪里会处理？
再往上看一下发现 AdbService 里面是有监听这个属性变化的，
然后调用 setAdbEnabled 方法，里面有设置prop属性哦，
接着调用了 AdbDebuggingManager.setAdbEnabled ，进行很相关线程启动，属性判断，网络判断等操作！3、上层adb 相关流程
系统prop属性：persist.adb.tls_server.enable 0/1
Settings.GLOBAL属性：adb_wifi_enabled 0/1（1）系统刚启动的情况
1、adb_wifi.cpp 优先启动，start_wifi_enabled_observer方法进入等待 prop 属性改变状态 2、SystemServer 启动 AdbService 3、AdbService.systemReady方法判断prop属性，执行是否开启adb，设置Settings.GLOBAL值 4、因为 AdbService 已经监听了 Settings.GLOBAL值的变化，所以会调用监听到变化，先设置prop方法，再执行setAdbEnabled 方法 5、接着调用 AdbDebuggingManager.setAdbEnabled ，进行很相关线程启动，属性判断，网络判断等操作！ 6、如果网络未开启或者未连接等情况，AdbDebuggingManager 会设置 Settings.GLOBAL.ADB_WIFI_ENABLED 为0 7、AdbService 监听监听到Settings属性变化，又调用了 setAdbEnabled 关闭wifi adb- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
所以未屏蔽 AdbDebuggingManager 判断网络情况的代码就会出现：
设置属性 persist.adb.tls_server.enable = 1，系统启动后，发现还是为0； 设置属性 Settings.GLOBAL.ADB_WIFI_ENABLED =1 ，系统启动后，发现还是为0； adb或者代码中，手动设置 ADB_WIFI_ENABLED =1 属性后，等下看，属性还是 0 ；- 1
- 2
- 3
- 4
（2）直接设置Settings属性的情况
1、AdbService 监听监听到Settings属性变化，设置prop属性值，调用了 setAdbEnabled 方法 2、接着调用 AdbDebuggingManager.setAdbEnabled ，进行很相关线程启动，属性判断，网络判断等操作！ 3、未屏蔽网络变化的情况，可能会导致 设置 Settings.GLOBAL.ADB_WIFI_ENABLED 为0 AdbService 监听监听到Settings属性变化，重新设置prop属性值- 1
- 2
- 3
- 4
注意这里即使未屏蔽网络判断的代码，设置Settings.GLOBAL.ADB_WIFI_ENABLED = 1，
系统是会先调用开启adb，但是又马上关闭adb的，这个在 adb_wifi.cpp 是可以看到相关日志的。（3）直接设置prop属性的情况
1、adb_wifi.cpp 的 start_wifi_enabled_observer 方法接收到prop属性变化 2、如果是开启就创建对应Server，随机生成端口号，设置端口号prop属性 service.adb.tls.port 3、如果关闭就删除Server，并且端口号属性设置空字符串- 1
- 2
- 3
- 4
可以看到设置prop 属性是不经过java代码的；
如果未屏蔽网络相关判断，设置prop开启wifi adb，那么重启设备或者网络变化都是会导致wifi adb关闭的。
端口号是在开启adb的时候设置在系统的，只修改prop端口号属性是没有效果的。默认流程所有有可能是：
1、系统默认启动，未设置prop属性,未屏蔽网络判断 SystemServer --> AdbService.systemReady --> 读取prop --> 设置GLOBAL值 --> onChange --> setAdbEnabled -- > 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(false) 2、系统启动：只设置prop属性,未屏蔽网络判断 SystemServer --> AdbService.systemReady --> 读取prop --> 设置GLOBAL值 --> onChange --> setAdbEnabled -- > 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(true) -- > 判断到网络未连接 --> 设置GLOBAL值 --> onChange --> setAdbEnabled -- > 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(false) 3、系统启动：设置prop属性,并且屏蔽网络判断 SystemServer --> AdbService.systemReady --> 读取prop --> 设置GLOBAL值 --> onChange --> setAdbEnabled -- >设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(true) 4、后期设置 Settings.GLOBAL.ADB_WIFI_ENABLED =1 属性值,未屏蔽网络判断 Settings.GLOBAL.ADB_WIFI_ENABLED = 1 --> AdbService.onChange --> setAdbEnabled -- > 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(true) -- > 判断到网络未连接 --> 设置GLOBAL值 --> onChange --> setAdbEnabled -- > 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(false) 5、后期设置 Settings.GLOBAL.ADB_WIFI_ENABLED =1 属性值,屏蔽网络判断 Settings.GLOBAL.ADB_WIFI_ENABLED = 1 --> AdbService.onChange --> setAdbEnabled -- >设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(true) 6、后期设置 persist.adb.tls_server.enable =1 属性值, 不管屏不屏蔽网络变化，都是一样的 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） --> 启动adb ，设置端口号 但是最后一种情况，如果没有屏蔽网络变化，就会很不稳定，因为网络变化，就会关闭 wifi adb。 7、未屏蔽网络判断，网络改变情况 AdbDebuggingManager 广播接收到网络变化 --> 设置GLOBAL值 --> AdbService.onChange --> setAdbEnabled -- > 设置prop属性（ -->adb_wifi.cpp 会收到属性变化） 并且调用 AdbDebuggingManager.setAdbEnabled(false)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
这里也有个简单结论：
设置默认 Settings.GLOBAL.ADB_WIFI_ENABLED 的值是没用的，系统流程会给他重新设置 0 如果未屏蔽网络变化的代码，即使设置了prop属性和GLOBAL属性也是没有意义的，系统流程也是会给它设置成 0- 1
- 2
- 3
五、如果修改后依然无法网络adb连接分析
（1）查看adb默认值
getprop persist.adb.tls_server.enable //查看prop属性 settings get global adb_wifi_enabled //查看Settings 属性 setprop persist.adb.tls_server.enable 1 //设置prop属性 settings put global adb_wifi_enabled 1 //设置Settings 属性- 1
- 2
- 3
- 4
- 5
- 6
如果设置 adb_wifi_enabled 1 ，等下查询马上又变成0 ，那么就是未去除网络变化的监听和判断。
（2）查看是否去除了限制adb的网络判断代码
这个就要看 AdbDebuggingManager 里面的代码了。
1、查看是否去除了网络变化的监听 WifiManager.WIFI_STATE_CHANGED_ACTION WifiManager.NETWORK_STATE_CHANGED_ACTION 2、查看是否对 getCurrentWifiApInfo() 的判断进行了屏蔽 3、查看是否去除了执行：Settings.Global.putInt(mContentResolver,Settings.Global.ADB_WIFI_ENABLED, 0);- 1
- 2
- 3
- 4
- 5
- 6
（3）查看是否打印了底层具体执行adb_wifi.cpp adb 开关的处理
//开启wifi 的日志 LOG(INFO) << "adb wifi started on port " << sTlsServer->port(); //停止wifi adb的日志 LOG(INFO) << "adb wifi stopped";- 1
- 2
- 3
- 4
- 5
所以查看关键字"adb wifi"可以看到日志。
logcat | grep "adb wifi"- 1
- 2
日志如下：
console:/ # logcat | grep "adb wifi" 09-05 21:09:31.755 668 712 I adbd : adb wifi stopped //关闭日志 09-05 21:09:48.326 668 712 I adbd : adb wifi started on port 5555 //开启日志，并且会打印 端口号- 1
- 2
- 3
- 4
（4）还是有问题，只能在代码流程上添加日志了
1、打开 AdbService 和 AdbDebuggingManager 的日志开关 2、AdbService.systemReady()添加打印默认属性 Slog.d(TAG, "lwz systemReady= " + WIFI_PERSISTENT_CONFIG_PROPERTY + " = " + SystemProperties.get(WIFI_PERSISTENT_CONFIG_PROPERTY, "0")); Slog.d(TAG, "lwz systemReady mIsAdbWifiEnabled= " + mIsAdbWifiEnabled); 3、AdbSettingsObserver.onChange 打印Settings属性变化后的值 Slog.d(TAG, "lwz onChange shouldEnable = " + shouldEnable);- 1
- 2
- 3
- 4
- 5
- 6
AdbDebuggingManager 也可以看情况添加一下日志，但是里面关闭 wifi adb的情况基本是有打印的。
这是通过命令logcat 打印多个关键字，就能看到问题原因了。
logcat | grep -E "AdbService|AdbDebuggingManager|adb wifi|XXX" //XXX 是自己定义的- 1
- 2
- 3
- 4
（5）device offline
连接之后提示设备离线，那么可能是电脑的adb 版本和 Android设备不匹配，一般换成adb 高的版本就行，也有可能需要换成adb 低的版本。
六、其他
1、adb 相关属性
（1） prop属性：persist.adb.tls_server.enable
系统启动后，AdbService 会判断该属性决定后续是否执行开启adb。
（2）prop属性：service.adb.tls.port
该属性是 adb_wifi.cpp 使能adb的时候设置的. 后续让你知道它的端口号。
所以设置这个属性值是没有意义的。
在 adb_wifi.cpp，初始化 TlsServer 设置固定端口 5555，那么这个属性一直就是 5555. 如果未设置就是随机的5位数。（3）Settings属性：Settings.Global.ADB_WIFI_ENABLED 具体名称是 “adb_wifi_enabled”
同时在 AdbService 是有监听 这个Global 属性的变化，关联上 AdbDebuggingManager ，设置 adb 使能。
查询和设置命令：
//查询属性； setttings get global adb_wifi_enabled //设置属性 0/1： setttings put global adb_wifi_enabled 1- 1
- 2
- 3
- 4
- 5
- 6
该属性是系统上层设置的一个值，原本主要用来记录adb wifi 的开关状态。
因为Android13 会判断当前wifi是否是信任的，切换wifi后设置这个属性是无效的。但是如果修改了上面去除网络限制对策后，直接设置Global属性，是会正常开关adb的。
如果未去除网络限制对策，你会发现 adb_wifi_enabled 无法设置成1，
因为 AdbDebuggingManager 在开启的是会还会判断网络情况，如果没有网络会设置为 0 .2、AdbService.java、AdbDebuggingManager.java、adb_wifi.cpp 的关系
（1） adb_wifi 是底层init/cpp 启动的服务
里面的日志是跑在比较前面的，比SystemServer 更早。
正常开启和关闭adb 是有相关日志的。（2）AdbService启动时机
AdbService 是SystemServer 执行 startOtherServices 里面启动的服务。
AdbService extends IAdbManager.Stub //具体暴露接口可以看 IAdbManager
（3）AdbDebuggingManager 是一个管理adbDebug的类，
该类在 AdbService 里面实例化，其实就是分化了一下具体执行的代码。
很多无法进入adb wifi 的情况都是在AdbDebuggingManager 拒绝的，并且重新设置了 Global属性 和 Prop 属性为0
AdbDebuggingManager 并不是普通的暴露给其他类使用的SDK类，只是一个普通类，并且里面监听了网络变化广播，是可以收到网络变化的。
适配了去除网络限制上面代码后，就应用而言，使用 Settings.Global.ADB_WIFI_ENABLED 控制和或者当前 网络adb状态最合适的。
虽然使用prop 属性也能生效，但是系统应用Settings判断的是Settings.Global.ADB_WIFI_ENABLED的值是否为1，
会出现adb状态显示不同步的情况。别人分析的user版本不能使用adb问题（版本不是最新的，写的比较复杂）：
https://blog.csdn.net/kc58236582/article/details/53502177/ -
相关阅读:
048-第三代软件开发-数据回放
Android 集成FCM(Google 推送)导致上架失败，提前获取设备信息ANDROID ID
unity脚本出现了这个问题
Lifecyle的原理
独立站卖家如何设置Facebook的重定向广告
中文核心期刊有哪些？
突破从0到1后，鲜花电商2.0时代怎么走？
css3动画库及四方体
java 选择排序
优化 CSS 代码的小技巧
- 原文地址：https://blog.csdn.net/wenzhi20102321/article/details/132735323
