Investigación de análisis de Adb de red de Android 13
Directorio de artículos
- Investigación de análisis de Adb de red de Android 13
-
- I. Introducción
- 2. Implementación predeterminada del código adb
- 3. Análisis y visualización de registros.
- 4. Proceso de código
- 5. Si la conexión de red adb aún no se puede analizar después de la modificación
-
- (1) Ver el valor predeterminado de adb
- (2) Compruebe si se ha eliminado el código de juicio de red que restringe adb
- (3) Compruebe si se imprime la ejecución subyacente del procesamiento del conmutador adb_wifi.cpp.
- (4) Todavía hay un problema: solo podemos agregar registros al proceso de código.
- (5) dispositivo fuera de línea
- 6. Otros
I. Introducción
¡A través del análisis de código, se descubrió que la red adb está restringida en Android 13!
Requisitos del código nativo de Android13: debe estar conectado a una determinada wifi antes de poder usar adb, y cambiar o apagar wifi detendrá adb.
Y el número de puerto wifi adb en Android13 cambia cada vez, ¡lo cual también es muy inconveniente!
Si desea hacer Android 11 o el mismo que antes, la computadora puede conectarse directamente a adb después de que el dispositivo esté conectado a una red WiFi/cableada, y el código del sistema debe adaptarse y modificarse.
Pensé que estaría bien configurar el número de puerto y la propiedad persist.adb.tls_server.enable, pero todavía hay algunos errores pequeños y todavía necesito estudiar el proceso específico por completo.
La configuración del número de puerto predeterminado de adb se publicó anteriormente:
https://blog.csdn.net/wenzhi20102321/article/details/131056174
El adb predeterminado implementa un análisis simple:
https://blog.csdn.net/wenzhi20102321/article/details/131774893
De forma predeterminada, adb habilita el análisis:
https://blog.csdn.net/wenzhi20102321/article/details/132382549
Los dos últimos artículos son de simple investigación y valor de referencia. En ese momento, todo el proceso aún se podía entender con más profundidad, por lo que escribí otro artículo especialmente.
Este es también el primer artículo en toda la red que analiza exhaustivamente el código wifi adb para Android 12 y superior. Si lo necesita, puede darle me gusta y guardarlo.
Los siguientes son los archivos de código fuente relacionados con adb analizados de Android13:
https://download.csdn.net/download/wenzhi20102321/88306366
2. Implementación predeterminada del código adb
Lo esencial:
1、mk 设置系统属性：persist.adb.tls_server.enable=1
2、写死端口号 5555
3、注释若干判断Wifi情况停止adb的代码
1. Directorio modificado:
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
2. Modificaciones específicas:
(1) Agregar atributos en XXX_device.mk
persist.adb.tls_server.enable = 1
¡Incluso si lo agregas manualmente, será recordado!
//设置
setprop persist.adb.tls_server.enable 1
//查询
getprop persist.adb.tls_server.enable
//可以查看其他adb相关属性
getprop | grep adb
(2) Establecer un número de puerto fijo
+++ 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;
El número de puerto fijo debe configurarse aquí. ¡Configurarlo usando la propiedad service.adb.tls.port es realmente inútil!
(3) Después de eliminar el código para determinar la red, configure ADB_WIFI_ENABLED en 0
Verifique la red wifi para determinar si la red cableada adb y wifi se pueden modificar o si la clave es adb normal.
Uno se juzga durante la inicialización y el otro se juzga cuando se monitorean los cambios en la red, simplemente elimínelos.
+++ 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");
En el código anterior, podemos ver que cuando wifi no está conectado, getCurrentWifiApInfo es nulo y wifi adb se cerrará.
Y hay muchos juicios sobre los cambios de conmutador de red y los cambios de estado de la red.
3. Análisis y visualización de registros.
El análisis y la visualización de registros incluyen principalmente: AdbService.java, AdbDebuggingManager.java, adb_wifi.cpp.
Los registros de AdbService están en modo cerrado de forma predeterminada y deben configurarse en verdadero. Si desea ver los valores específicos de los datos internos, Los registros de atributos relacionados deben ser agregados e impresos por usted mismo. AdbDebuggingManager es la impresión del archivo adb_wifi con registros de procesos de excepción relacionados. La TAG es adbd. Independientemente de si adb está abierto o no, todo el sistema siempre tiene impresiones relacionadas con adbd. ¡Hay alrededor de una docena de líneas de registros por segundo
!
Estos son los comandos de información para imprimir varias palabras clave en registros relacionados:
Los registros de cada sistema pueden ser diferentes, por lo que aquí están como referencia:
logcat | grep -E "lwz|AdbService|changed to|adb wifi|AdbDebuggingManager"
lwz es una palabra clave que agregué yo mismo.
Al ver los registros, el proceso de registro aproximado para el inicio normal es el siguiente:
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
Si el juicio de la red no está bloqueado, agregue el proceso de visualización del registro de impresión:
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
Esta es también la razón por la que después de configurar el atributo persist.adb.tls_server.enable =1, el inicio del sistema encontró que el atributo obtenido todavía era 0 y wifi adb no estaba activado.
Si activa el interruptor de registro y no agrega registros personalizados, no se mostrarán tantos registros.
Si el código y los atributos están adaptados, pero todavía no hay un adb predeterminado, entonces debe ordenar el código o agregar más análisis de registros para verificar.
4. Proceso de código
De hecho, el proceso entre las tres clases de AdbService.java, AdbDebuggingManager.java y adb_wifi.cpp es casi el mismo.
Este tipo de adb_wifi.cpp no está disponible en Android 11 y versiones anteriores, pero otras clases de Java siempre están disponibles.
paquetes\modules\adb Este directorio solo está disponible desde Android 12.
1. inicio inferior de adb_wifi
Los registros internos se ejecutan antes que SystemServer.
Esta es también la razón por la que configurar persist.adb.tls_server.enable=1 puede habilitar directamente la red adb.
Hay registros relacionados para abrir y cerrar adb normalmente.
Específicamente, adb se inicia solo cuando la capa superior llama a la interfaz de la capa inferior.
A continuación se muestra el fragmento de código más importante.
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();
}
Los 13 puntos principales anteriores son los procesos importantes en adb cpp.
Otras cuestiones más específicas y subyacentes no serán estudiadas ni analizadas aquí.
Consulte la lógica del hilo subyacente de adb escrita por otros:
https://blog.csdn.net/qq_35970872/article/details/78912611
Android13 también tiene una lógica subyacente relacionada, ruta de código:
packages\modules\adb\transport.cpp
Hay hilos dentro que han estado leyendo datos. No puedo entender la lógica específica, ¡así que no la analizaré!
2. inicio de la capa superior de adb
AdbService es un servicio que se inicia cuando SystemServer ejecuta startOtherServices.
AdbService extiende IAdbManager.Stub // Para interfaces expuestas específicas, consulte IAdbManager
AdbDebuggingManager es una clase que administra adbDebug, se instancia en AdbService y en realidad divide el código de ejecución específico.
AdbDebuggingManager rechaza muchas situaciones en las que no se puede acceder a adb wifi y el atributo Global y el atributo Prop se restablecen a 0.
(1) SystemServce.java inicia el código 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();
}
}
(2) Código clave AdbServices.java después del inicio del servicio
Este AdbService no es un servicio específico (no es el Servicio entre los cuatro componentes principales), sino un servicio vinculado a través de AIDL.
Otras clases pueden llamar a la implementación a través del objeto de interfaz IXXX/Manager de este servicio.
Una cosa especial es que hereda SystemService y puede monitorear la finalización del inicio del sistema.
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);
}
}
El siguiente es el código clave, análisis de 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);
}
}
}
}
}
};
En el código anterior, puede ver que en muchos casos, ADB_WIFI_ENABLED está configurado para desactivarse.
Si no hay requisitos de seguridad obligatorios, se pueden desactivar. La prueba actual no ha encontrado ningún problema.
El código de propiedad Settings.Global.ADB_WIFI_ENABLED se establece aquí, entonces, ¿dónde se procesará?
Mirando más arriba, descubrí que AdbService monitorea los cambios en este atributo
y luego llama al método setAdbEnabled, que establece el atributo prop,
y luego llama a AdbDebuggingManager.setAdbEnabled para realizar el inicio de subprocesos relacionados, el juicio de atributos, el juicio de red y otras operaciones.
3. Procesos relacionados con adb de capa superior
Atributo de propiedad del sistema: persist.adb.tls_server.enable 0/1
Atributo Settings.GLOBAL: adb_wifi_enabled 0/1
(1) La situación cuando el sistema acaba de iniciarse
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
Por lo tanto, si AdbDebuggingManager no está bloqueado, aparecerá el código para determinar la situación de la red:
设置属性 persist.adb.tls_server.enable = 1，系统启动后，发现还是为0；
设置属性 Settings.GLOBAL.ADB_WIFI_ENABLED =1 ，系统启动后，发现还是为0；
adb或者代码中，手动设置 ADB_WIFI_ENABLED =1 属性后，等下看，属性还是 0 ；
(2) El caso de configurar directamente el atributo de Configuración
1、AdbService 监听监听到Settings属性变化，设置prop属性值，调用了 setAdbEnabled 方法
2、接着调用 AdbDebuggingManager.setAdbEnabled ，进行很相关线程启动，属性判断，网络判断等操作！
3、未屏蔽网络变化的情况，可能会导致 设置 Settings.GLOBAL.ADB_WIFI_ENABLED 为0
AdbService 监听监听到Settings属性变化，重新设置prop属性值
Tenga en cuenta que incluso si el código de juicio de red no está bloqueado aquí, si se establece Settings.GLOBAL.ADB_WIFI_ENABLED = 1,
el sistema primero llamará para habilitar adb, pero luego cerrará inmediatamente adb. Puede ver los registros relevantes en adb_wifi.cpp.
(3) El caso de establecer directamente el atributo de propiedad
1、adb_wifi.cpp 的 start_wifi_enabled_observer 方法接收到prop属性变化
2、如果是开启就创建对应Server，随机生成端口号，设置端口号prop属性 service.adb.tls.port
3、如果关闭就删除Server，并且端口号属性设置空字符串
Se puede ver que la configuración del atributo prop no pasa por el código java;
si el juicio relacionado con la red no está bloqueado y el prop está configurado para habilitar wifi adb, reiniciar el dispositivo o cambiar la red hará que wifi adb se cierre.
El número de puerto se establece en el sistema cuando se activa adb. Simplemente modificar el atributo del número de puerto de propiedad no tiene ningún efecto.
El proceso predeterminado puede ser:
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)
También hay una conclusión simple aquí:
设置默认 Settings.GLOBAL.ADB_WIFI_ENABLED 的值是没用的，系统流程会给他重新设置 0
如果未屏蔽网络变化的代码，即使设置了prop属性和GLOBAL属性也是没有意义的，系统流程也是会给它设置成 0
5. Si la conexión de red adb aún no se puede analizar después de la modificación
(1) Ver el valor predeterminado de 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 属性
Si adb_wifi_enabled se establece en 1 y la consulta cambia inmediatamente a 0, entonces no se han eliminado la supervisión y el juicio de los cambios de la red.
(2) Compruebe si se ha eliminado el código de juicio de red que restringe adb
Esto depende del código en 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);
(3) Compruebe si se imprime la ejecución subyacente del procesamiento del conmutador adb_wifi.cpp.
//开启wifi 的日志
LOG(INFO) << "adb wifi started on port " << sTlsServer->port();
//停止wifi adb的日志
LOG(INFO) << "adb wifi stopped";
Así que verifique la palabra clave "adb wifi" para ver el registro.
logcat | grep "adb wifi"
El registro es el siguiente:
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 //开启日志，并且会打印 端口号
(4) Todavía hay un problema: solo podemos agregar registros al proceso de código.
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);
AdbDebuggingManager también puede agregar registros según la situación, pero la situación de apagar wifi adb básicamente está impresa.
Al imprimir varias palabras clave con el comando logcat, puede ver la causa del problema.
logcat | grep -E "AdbService|AdbDebuggingManager|adb wifi|XXX" //XXX 是自己定义的
(5) dispositivo fuera de línea
Después de conectarse, le indica que el dispositivo está desconectado. Entonces puede ser que la versión de adb de la computadora no coincida con la del dispositivo Android. Generalmente, es suficiente cambiar a una versión superior de adb. También es posible que deba cambiar a una versión inferior de adb.
6. Otros
1. atributos relacionados con adb
(1) propiedad de prop:persist.adb.tls_server.enable
Una vez que se inicia el sistema, AdbService juzgará esta propiedad para determinar si se debe abrir adb posteriormente.
(2) atributo de propiedad: service.adb.tls.port
Esta propiedad la establece adb_wifi.cpp cuando adb está habilitado. Le permitirá saber su número de puerto más adelante.
Por lo tanto, establecer el valor de esta propiedad no tiene sentido.
En adb_wifi.cpp, inicialice TlsServer y configure el puerto fijo 5555, entonces este atributo siempre será 5555. Si no está configurado, será un número aleatorio de 5 dígitos.
(3) Atributo de configuración: Settings.Global.ADB_WIFI_ENABLED El nombre específico es "adb_wifi_enabled"
Al mismo tiempo, AdbService monitorea los cambios en el atributo Global, lo asocia con AdbDebuggingManager y configura la habilitación de adb.
Consultar y establecer comandos:
//查询属性；
setttings get global adb_wifi_enabled
//设置属性 0/1：
setttings put global adb_wifi_enabled 1
Este atributo es un valor establecido por la capa superior del sistema y originalmente se usaba principalmente para registrar el estado de encendido/apagado de adb wifi.
Debido a que Android13 determinará si el wifi actual es confiable, configurar este atributo después de cambiar de wifi no es válido.
Sin embargo, si modifica las contramedidas anteriores para eliminar las restricciones de red y establece directamente el atributo Global, adb se activará y desactivará normalmente.
Si no se elimina la contramedida de restricción de red, encontrará que adb_wifi_enabled no se puede establecer en 1,
porque AdbDebuggingManager aún determinará la condición de la red cuando esté encendido y se establecerá en 0 si no hay red.
2. La relación entre AdbService.java, AdbDebuggingManager.java y adb_wifi.cpp
(1) adb_wifi es un servicio iniciado por el init/cpp subyacente
Los registros internos se ejecutan antes que SystemServer.
Hay registros relacionados para abrir y cerrar adb normalmente.
(2) Tiempo de inicio de AdbService
AdbService es un servicio que se inicia cuando SystemServer ejecuta startOtherServices.
AdbService extiende IAdbManager.Stub // Para interfaces expuestas específicas, consulte IAdbManager
(3) AdbDebuggingManager es una clase que administra adbDebug.
Se crea una instancia de esta clase en AdbService, que en realidad separa el código de ejecución específico.
AdbDebuggingManager rechaza muchas situaciones en las que no se puede acceder a adb wifi y el atributo Global y el atributo Prop se restablecen a 0.
AdbDebuggingManager no es una clase SDK ordinaria expuesta a otras clases, es solo una clase ordinaria que escucha las transmisiones de cambios de red y puede recibir cambios de red.
Después de adaptar el código anterior para eliminar las restricciones de la red, en lo que respecta a la aplicación, lo más apropiado es usar Settings.Global.ADB_WIFI_ENABLED para controlar o el estado actual de adb de la red.
Aunque el uso del atributo prop también puede surtir efecto, el sistema usa Configuración para determinar si el valor de Settings.Global.ADB_WIFI_ENABLED es 1 y la
visualización del estado de adb no estará sincronizada.
La versión de usuario analizada por otros no puede usar adb (la versión no es la última y la escritura es más complicada):
https://blog.csdn.net/kc58236582/article/details/53502177/