Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 55ffa01e authored by Fabien Sanglard's avatar Fabien Sanglard
Browse files

Extract PairingThread out of AdbDebuggingManager 

AdbDebuggingManager is a huge, 2k+ lines which is difficult to
understand. By making PairingThread a regular class, we gain in clarity.

Test: NA
Bug: NA
Flag: EXEMPT(refactor)
Change-Id: Ie8873e605d1ccc6250cc612a059ee9cb3c64cff1
parent 598d5900

services/core/java/com/android/server/adb/AdbDebuggingManager.java

+13 −126
Original line number Diff line number Diff line
@@ -48,8 +48,6 @@ import android.net.LocalSocket; 
import android.net.LocalSocketAddress;

import android.net.NetworkInfo;

import android.net.Uri;

import android.net.nsd.NsdManager;

import android.net.nsd.NsdServiceInfo;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiInfo;

import android.net.wifi.WifiManager;
@@ -60,7 +58,6 @@ import android.os.Handler; 
import android.os.Looper;

import android.os.Message;

import android.os.SystemClock;

import android.os.SystemProperties;

import android.os.SystemService;

import android.os.UserHandle;

import android.os.UserManager;
@@ -153,14 +150,14 @@ public class AdbDebuggingManager { 
    @Nullable private final File mUserKeyFile;

    @Nullable private final File mTempKeysFile;



    private static final String WIFI_PERSISTENT_GUID =

            "persist.adb.wifi.guid";

    static final String WIFI_PERSISTENT_GUID = "persist.adb.wifi.guid";

    private static final int PAIRING_CODE_LENGTH = 6;

    /**

     * The maximum time to wait for the adbd service to change state when toggling.

     */

    private static final long ADBD_STATE_CHANGE_TIMEOUT = DEFAULT_DISPATCHING_TIMEOUT_MILLIS;

    private PairingThread mPairingThread = null;



    private AdbPairingThread mAdbPairingThread = null;

    // A list of keys connected via wifi

    private final Set<String> mWifiConnectedKeys = new HashSet<>();

    // The current info of the adbwifi connection.
@@ -230,117 +227,7 @@ public class AdbDebuggingManager { 
        mConnectionPortPoller = null;

    }



    class PairingThread extends Thread implements NsdManager.RegistrationListener {

        private NsdManager mNsdManager;

        private String mPairingCode;

        private String mGuid;

        private String mServiceName;

        // From RFC6763 (https://tools.ietf.org/html/rfc6763#section-7.2),

        // The rules for Service Names [RFC6335] state that they may be no more

        // than fifteen characters long (not counting the mandatory underscore),

        // consisting of only letters, digits, and hyphens, must begin and end

        // with a letter or digit, must not contain consecutive hyphens, and

        // must contain at least one letter.

        @VisibleForTesting static final String SERVICE_PROTOCOL = "adb-tls-pairing";

        private final String mServiceType = String.format("_%s._tcp.", SERVICE_PROTOCOL);

        private int mPort;



        private native int native_pairing_start(String guid, String password);

        private native void native_pairing_cancel();



        private native String native_pairing_wait();



        PairingThread(String pairingCode, String serviceName) {

            super(TAG);

            mPairingCode = pairingCode;

            mGuid = SystemProperties.get(WIFI_PERSISTENT_GUID);

            mServiceName = serviceName;

            if (serviceName == null || serviceName.isEmpty()) {

                mServiceName = mGuid;

            }

            mPort = -1;

            mNsdManager = (NsdManager) mContext.getSystemService(Context.NSD_SERVICE);

        }



        @Override

        public void run() {

            // Register the mdns service

            NsdServiceInfo serviceInfo = new NsdServiceInfo();

            serviceInfo.setServiceName(mServiceName);

            serviceInfo.setServiceType(mServiceType);

            serviceInfo.setPort(mPort);

            mNsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, this);



            // Send pairing port to UI

            Message msg = mHandler.obtainMessage(

                    AdbDebuggingHandler.MSG_RESPONSE_PAIRING_PORT);

            msg.obj = mPort;

            mHandler.sendMessage(msg);



            String publicKey = native_pairing_wait();

            if (publicKey != null) {

                Slog.i(TAG, "Pairing succeeded key=" + publicKey);

            } else {

                Slog.i(TAG, "Pairing failed");

            }



            mNsdManager.unregisterService(this);



            Message message = Message.obtain(mHandler,

                                             AdbDebuggingHandler.MSG_RESPONSE_PAIRING_RESULT,

                                             publicKey);

            mHandler.sendMessage(message);

        }



        @Override

        public void start() {

            /*

             * If a user is fast enough to click cancel, native_pairing_cancel can be invoked

             * while native_pairing_start is running which run the destruction of the object

             * while it is being constructed. Here we start the pairing server on foreground

             * Thread so native_pairing_cancel can never be called concurrently. Then we let

             * the pairing server run on a background Thread.

             */

            if (mGuid.isEmpty()) {

                Slog.e(TAG, "adbwifi guid was not set");

                return;

            }

            mPort = native_pairing_start(mGuid, mPairingCode);

            if (mPort <= 0) {

                Slog.e(TAG, "Unable to start pairing server");

                return;

            }



            super.start();

        }



        public void cancelPairing() {

            native_pairing_cancel();

        }



        @Override

        public void onServiceRegistered(NsdServiceInfo serviceInfo) {

            Slog.i(TAG, "Registered pairing service: " + serviceInfo);

        }



        @Override

        public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

            Slog.e(TAG, "Failed to register pairing service(err=" + errorCode

                    + "): " + serviceInfo);

            cancelPairing();

        }



        @Override

        public void onServiceUnregistered(NsdServiceInfo serviceInfo) {

            Slog.i(TAG, "Unregistered pairing service: " + serviceInfo);

        }



        @Override

        public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

            Slog.w(TAG, "Failed to unregister pairing service(err=" + errorCode

                    + "): " + serviceInfo);

        }

    }



    @VisibleForTesting

    static class AdbDebuggingThread extends Thread {
@@ -1178,28 +1065,29 @@ public class AdbDebuggingManager { 
                case MSG_PAIR_PAIRING_CODE: {

                    String pairingCode = createPairingCode(PAIRING_CODE_LENGTH);

                    updateUIPairCode(pairingCode);

                    mPairingThread = new PairingThread(pairingCode, null);

                    mPairingThread.start();

                        mAdbPairingThread = new AdbPairingThread(pairingCode, null, mContext, this);

                        mAdbPairingThread.start();

                    break;

                }

                case MSG_PAIR_QR_CODE: {

                    Bundle bundle = (Bundle) msg.obj;

                    String serviceName = bundle.getString("serviceName");

                    String password = bundle.getString("password");

                    mPairingThread = new PairingThread(password, serviceName);

                    mPairingThread.start();

                        mAdbPairingThread =

                                new AdbPairingThread(password, serviceName, mContext, this);

                        mAdbPairingThread.start();

                    break;

                }

                case MSG_PAIRING_CANCEL:

                    if (mPairingThread != null) {

                        mPairingThread.cancelPairing();

                    if (mAdbPairingThread != null) {

                        mAdbPairingThread.cancelPairing();

                        try {

                            mPairingThread.join();

                            mAdbPairingThread.join();

                        } catch (InterruptedException e) {

                            Slog.w(TAG, "Error while waiting for pairing thread to quit.");

                            e.printStackTrace();

                        }

                        mPairingThread = null;

                        mAdbPairingThread = null;

                    }

                    break;

                case MSG_WIFI_DEVICE_CONNECTED: {
@@ -1278,7 +1166,6 @@ public class AdbDebuggingManager { 
                    authWindow, state, alwaysAllow);

        }





        /**

         * Schedules a job to update the connection time of the currently connected key and filter

         * out any keys that are beyond their expiration time.

services/core/java/com/android/server/adb/AdbPairingThread.java

0 → 100644
+145 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2025 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.server.adb;



import android.content.Context;

import android.net.nsd.NsdManager;

import android.net.nsd.NsdServiceInfo;

import android.os.Handler;

import android.os.Message;

import android.os.SystemProperties;

import android.util.Slog;



import com.android.internal.annotations.VisibleForTesting;

import com.android.server.adb.AdbDebuggingManager.AdbDebuggingHandler;



class AdbPairingThread extends Thread implements NsdManager.RegistrationListener {

    private static final String TAG = AdbPairingThread.class.getSimpleName();

    private final NsdManager mNsdManager;

    private final Context mContext;

    private final String mPairingCode;

    private final String mGuid;

    private String mServiceName;



    // From RFC6763 (https://tools.ietf.org/html/rfc6763#section-7.2),

    // The rules for Service Names [RFC6335] state that they may be no more

    // than fifteen characters long (not counting the mandatory underscore),

    // consisting of only letters, digits, and hyphens, must begin and end

    // with a letter or digit, must not contain consecutive hyphens, and

    // must contain at least one letter.

    @VisibleForTesting static final String SERVICE_PROTOCOL = "adb-tls-pairing";

    private final String mServiceType = String.format("_%s._tcp.", SERVICE_PROTOCOL);

    private int mPort;



    private final Handler mHandler;



    AdbPairingThread(String pairingCode, String serviceName, Context context, Handler handler) {

        super(TAG);

        mPairingCode = pairingCode;

        mGuid = SystemProperties.get(AdbDebuggingManager.WIFI_PERSISTENT_GUID);

        mServiceName = serviceName;

        if (serviceName == null || serviceName.isEmpty()) {

            mServiceName = mGuid;

        }

        mPort = -1;

        mContext = context;

        mNsdManager = (NsdManager) mContext.getSystemService(Context.NSD_SERVICE);

        mHandler = handler;

    }



    @Override

    public void run() {

        // Register the mdns service

        NsdServiceInfo serviceInfo = new NsdServiceInfo();

        serviceInfo.setServiceName(mServiceName);

        serviceInfo.setServiceType(mServiceType);

        serviceInfo.setPort(mPort);

        mNsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, this);



        // Send pairing port to UI

        Message msg = mHandler.obtainMessage(AdbDebuggingHandler.MSG_RESPONSE_PAIRING_PORT);

        msg.obj = mPort;

        mHandler.sendMessage(msg);



        String publicKey = native_pairing_wait();

        if (publicKey != null) {

            Slog.i(TAG, "Pairing succeeded key=" + publicKey);

        } else {

            Slog.i(TAG, "Pairing failed");

        }



        mNsdManager.unregisterService(this);



        Message message =

                Message.obtain(

                        mHandler, AdbDebuggingHandler.MSG_RESPONSE_PAIRING_RESULT, publicKey);

        mHandler.sendMessage(message);

    }



    @Override

    public void start() {

        /*

         * If a user is fast enough to click cancel, native_pairing_cancel can be invoked

         * while native_pairing_start is running which run the destruction of the object

         * while it is being constructed. Here we start the pairing server on foreground

         * Thread so native_pairing_cancel can never be called concurrently. Then we let

         * the pairing server run on a background Thread.

         */

        if (mGuid.isEmpty()) {

            Slog.e(TAG, "adbwifi guid was not set");

            return;

        }

        mPort = native_pairing_start(mGuid, mPairingCode);

        if (mPort <= 0) {

            Slog.e(TAG, "Unable to start pairing server");

            return;

        }



        super.start();

    }



    public void cancelPairing() {

        native_pairing_cancel();

    }



    @Override

    public void onServiceRegistered(NsdServiceInfo serviceInfo) {

        Slog.i(TAG, "Registered pairing service: " + serviceInfo);

    }



    @Override

    public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

        Slog.e(TAG, "Failed to register pairing service(err=" + errorCode + "): " + serviceInfo);

        cancelPairing();

    }



    @Override

    public void onServiceUnregistered(NsdServiceInfo serviceInfo) {

        Slog.i(TAG, "Unregistered pairing service: " + serviceInfo);

    }



    @Override

    public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

        Slog.w(TAG, "Failed to unregister pairing service(err=" + errorCode + "): " + serviceInfo);

    }



    private native int native_pairing_start(String guid, String password);



    private native void native_pairing_cancel();



    private native String native_pairing_wait();

}

services/core/jni/com_android_server_adb_AdbDebuggingManager.cpp

+1 −2
Original line number Diff line number Diff line
@@ -116,8 +116,7 @@ static const JNINativeMethod gPairingThreadMethods[] = { 
};



int register_android_server_AdbDebuggingManager(JNIEnv* env) {

    return jniRegisterNativeMethods(env,

                                    "com/android/server/adb/AdbDebuggingManager$PairingThread",

    return jniRegisterNativeMethods(env, "com/android/server/adb/AdbPairingThread",

                                    gPairingThreadMethods, NELEM(gPairingThreadMethods));

}

services/tests/servicestests/src/com/android/server/adb/AdbDebuggingManagerTest.java

+1 −1
Original line number Diff line number Diff line
@@ -873,7 +873,7 @@ public final class AdbDebuggingManagerTest { 


    @Test

    public void testPairingThread_MdnsServiceName_RFC6335() {

        assertTrue(isValidMdnsServiceName(AdbDebuggingManager.PairingThread.SERVICE_PROTOCOL));

        assertTrue(isValidMdnsServiceName(AdbPairingThread.SERVICE_PROTOCOL));

    }



    private boolean isValidMdnsServiceName(String name) {