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

Commit e1cef22d authored by Aritra Sen's avatar Aritra Sen Committed by Gerrit Code Review
Browse files

Merge "Handle Bond state changes through the adapter service instead of...

Merge "Handle Bond state changes through the adapter service instead of relying on broadcast receivers." into main
parents 070ce385 4f663ea6
Loading
Loading
Loading
Loading
+8 −32
Original line number Diff line number Diff line
@@ -40,10 +40,8 @@ import android.bluetooth.BufferConstraints;
import android.bluetooth.IBluetoothA2dp;
import android.companion.CompanionDeviceManager;
import android.content.AttributionSource;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioDeviceCallback;
import android.media.AudioDeviceInfo;
import android.media.AudioManager;
@@ -124,7 +122,6 @@ public class A2dpService extends ProfileService {
    // A2DP Offload Enabled in platform
    boolean mA2dpOffloadEnabled = false;

    private BroadcastReceiver mBondStateChangedReceiver;
    private final AudioManagerAudioDeviceCallback mAudioManagerAudioDeviceCallback =
            new AudioManagerAudioDeviceCallback();

@@ -202,20 +199,13 @@ public class A2dpService extends ProfileService {
            Log.d(TAG, "A2DP offload flag set to " + mA2dpOffloadEnabled);
        }

        // Step 7: Setup broadcast receivers
        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        mBondStateChangedReceiver = new BondStateChangedReceiver();
        registerReceiver(mBondStateChangedReceiver, filter);

        // Step 8: Register Audio Device callback
        // Step 7: Register Audio Device callback
        mAudioManager.registerAudioDeviceCallback(mAudioManagerAudioDeviceCallback, mHandler);

        // Step 9: Mark service as started
        // Step 8: Mark service as started
        setA2dpService(this);

        // Step 10: Clear active device
        // Step 9: Clear active device
        removeActiveDevice(false);

        return true;
@@ -229,19 +219,15 @@ public class A2dpService extends ProfileService {
            return true;
        }

        // Step 10: Clear active device and stop playing audio
        // Step 9: Clear active device and stop playing audio
        removeActiveDevice(true);

        // Step 9: Mark service as stopped
        // Step 8: Mark service as stopped
        setA2dpService(null);

        // Step 8: Unregister Audio Device Callback
        // Step 7: Unregister Audio Device Callback
        mAudioManager.unregisterAudioDeviceCallback(mAudioManagerAudioDeviceCallback);

        // Step 7: Unregister broadcast receivers
        unregisterReceiver(mBondStateChangedReceiver);
        mBondStateChangedReceiver = null;

        // Step 6: Cleanup native interface
        mNativeInterface.cleanup();

@@ -1184,18 +1170,8 @@ public class A2dpService extends ProfileService {
                Utils.getTempAllowlistBroadcastOptions());
    }

    private class BondStateChangedReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (!BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction())) {
                return;
            }
            int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
                                           BluetoothDevice.ERROR);
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            requireNonNull(device, "ACTION_BOND_STATE_CHANGED with no EXTRA_DEVICE");
            bondStateChanged(device, state);
        }
    public void handleBondStateChanged(BluetoothDevice device, int fromState, int toState) {
        mHandler.post(() -> bondStateChanged(device, toState));
    }

    /**
+18 −36
Original line number Diff line number Diff line
@@ -26,11 +26,9 @@ import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothUuid;
import android.bluetooth.IBluetoothBattery;
import android.content.AttributionSource;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.HandlerThread;
import android.os.Handler;
import android.os.Looper;
import android.os.ParcelUuid;
import android.sysprop.BluetoothProperties;
import android.util.Log;
@@ -64,10 +62,9 @@ public class BatteryService extends ProfileService {
    private AdapterService mAdapterService;
    private DatabaseManager mDatabaseManager;
    private HandlerThread mStateMachinesThread;
    private Handler mHandler;
    private final Map<BluetoothDevice, BatteryStateMachine> mStateMachines = new HashMap<>();

    private BroadcastReceiver mBondStateChangedReceiver;

    public static boolean isEnabled() {
        return BluetoothProperties.isProfileBasClientEnabled().orElse(false);
    }
@@ -98,17 +95,11 @@ public class BatteryService extends ProfileService {
        mDatabaseManager = Objects.requireNonNull(mAdapterService.getDatabase(),
                "DatabaseManager cannot be null when BatteryService starts");

        mHandler = new Handler(Looper.getMainLooper());
        mStateMachines.clear();
        mStateMachinesThread = new HandlerThread("BatteryService.StateMachines");
        mStateMachinesThread.start();

        // Setup broadcast receivers
        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        mBondStateChangedReceiver = new BondStateChangedReceiver();
        registerReceiver(mBondStateChangedReceiver, filter);

        setBatteryService(this);

        return true;
@@ -125,9 +116,6 @@ public class BatteryService extends ProfileService {
        }

        setBatteryService(null);
        // Unregister broadcast receivers
        unregisterReceiver(mBondStateChangedReceiver);
        mBondStateChangedReceiver = null;

        // Destroy state machines and stop handler thread
        synchronized (mStateMachines) {
@@ -149,6 +137,12 @@ public class BatteryService extends ProfileService {
            }
        }

        // Unregister Handler and stop all queued messages.
        if (mHandler != null) {
            mHandler.removeCallbacksAndMessages(null);
            mHandler = null;
        }

        mAdapterService = null;

        return true;
@@ -470,33 +464,21 @@ public class BatteryService extends ProfileService {
        }
    }

    // Remove state machine if the bonding for a device is removed
    private class BondStateChangedReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (!BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction())) {
                return;
            }
            int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
                    BluetoothDevice.ERROR);
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            Objects.requireNonNull(device, "ACTION_BOND_STATE_CHANGED with no EXTRA_DEVICE");
            handleBondStateChanged(device, state);
        }
    /** Process a change in the bonding state for a device */
    public void handleBondStateChanged(BluetoothDevice device, int fromState, int toState) {
        mHandler.post(() -> bondStateChanged(device, toState));
    }

    /**
     * Process a change in the bonding state for a device.
     * Remove state machine if the bonding for a device is removed
     *
     * @param device the device whose bonding state has changed
     * @param bondState the new bond state for the device. Possible values are:
     * {@link BluetoothDevice#BOND_NONE},
     * {@link BluetoothDevice#BOND_BONDING},
     * {@link BluetoothDevice#BOND_BONDED},
     * {@link BluetoothDevice#ERROR}.
     * @param bondState the new bond state for the device. Possible values are: {@link
     *     BluetoothDevice#BOND_NONE}, {@link BluetoothDevice#BOND_BONDING}, {@link
     *     BluetoothDevice#BOND_BONDED}, {@link BluetoothDevice#ERROR}.
     */
    @VisibleForTesting
    void handleBondStateChanged(BluetoothDevice device, int bondState) {
    void bondStateChanged(BluetoothDevice device, int bondState) {
        if (DBG) {
            Log.d(TAG, "Bond state changed for device: " + device + " state: " + bondState);
        }
+4 −30
Original line number Diff line number Diff line
@@ -34,10 +34,8 @@ import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanRecord;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanSettings;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
@@ -115,7 +113,6 @@ public class BassClientService extends ProfileService {
            mPeriodicAdvertisementResultMap;
    private ScanCallback mSearchScanCallback;
    private Callbacks mCallbacks;
    private BroadcastReceiver mIntentReceiver;

    private static final int LOG_NB_EVENTS = 100;
    private static final BluetoothEventLogger sEventLogger =
@@ -371,28 +368,6 @@ public class BassClientService extends ProfileService {
        mCallbackHandlerThread.start();
        mCallbacks = new Callbacks(mCallbackHandlerThread.getLooper());

        IntentFilter filter = new IntentFilter();
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        mIntentReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();

                if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
                    int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
                            BluetoothDevice.ERROR);
                    BluetoothDevice device =
                            intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    Objects.requireNonNull(device,
                            "ACTION_BOND_STATE_CHANGED with no EXTRA_DEVICE");
                    bondStateChanged(device, state);

                }
            }
        };
        registerReceiver(mIntentReceiver, filter, Context.RECEIVER_EXPORTED);

        setBassClientService(this);
        // Saving PSync stuff for future addition
        mSyncHandleToDeviceMap = new HashMap<Integer, BluetoothDevice>();
@@ -431,11 +406,6 @@ public class BassClientService extends ProfileService {
            mHandler = null;
        }

        if (mIntentReceiver != null) {
            unregisterReceiver(mIntentReceiver);
            mIntentReceiver = null;
        }

        setBassClientService(null);
        if (mSyncHandleToDeviceMap != null) {
            mSyncHandleToDeviceMap.clear();
@@ -798,6 +768,10 @@ public class BassClientService extends ProfileService {
        }
    }

    public void handleBondStateChanged(BluetoothDevice device, int fromState, int toState) {
        mHandler.post(() -> bondStateChanged(device, toState));
    }

    @VisibleForTesting
    void bondStateChanged(BluetoothDevice device, int bondState) {
        log("Bond state changed for device: " + device + " state: " + bondState);
+37 −0
Original line number Diff line number Diff line
@@ -6964,6 +6964,43 @@ public class AdapterService extends Service {
        }
    }

    /** Handle Bluetooth profiles when bond state changes with a {@link BluetoothDevice} */
    public void handleBondStateChanged(BluetoothDevice device, int fromState, int toState) {
        if (mA2dpService != null && mA2dpService.isAvailable()) {
            mA2dpService.handleBondStateChanged(device, fromState, toState);
        }
        if (mHeadsetService != null && mHeadsetService.isAvailable()) {
            mHeadsetService.handleBondStateChanged(device, fromState, toState);
        }
        if (mLeAudioService != null && mLeAudioService.isAvailable()) {
            mLeAudioService.handleBondStateChanged(device, fromState, toState);
        }
        if (mHearingAidService != null && mHearingAidService.isAvailable()) {
            mHearingAidService.handleBondStateChanged(device, fromState, toState);
        }
        if (mHapClientService != null && mHapClientService.isAvailable()) {
            mHapClientService.handleBondStateChanged(device, fromState, toState);
        }
        if (mBassClientService != null && mBassClientService.isAvailable()) {
            mBassClientService.handleBondStateChanged(device, fromState, toState);
        }
        if (mBatteryService != null && mBatteryService.isAvailable()) {
            mBatteryService.handleBondStateChanged(device, fromState, toState);
        }
        if (mVolumeControlService != null && mVolumeControlService.isAvailable()) {
            mVolumeControlService.handleBondStateChanged(device, fromState, toState);
        }
        if (mPbapService != null && mPbapService.isAvailable()) {
            mPbapService.handleBondStateChanged(device, fromState, toState);
        }
        if (mCsipSetCoordinatorService != null && mCsipSetCoordinatorService.isAvailable()) {
            mCsipSetCoordinatorService.handleBondStateChanged(device, fromState, toState);
        }
        if (mDatabaseManager != null) {
            mDatabaseManager.handleBondStateChanged(device, fromState, toState);
        }
    }

    static int convertScanModeToHal(int mode) {
        switch (mode) {
            case BluetoothAdapter.SCAN_MODE_NONE:
+1 −0
Original line number Diff line number Diff line
@@ -495,6 +495,7 @@ final class BondStateMachine extends StateMachine {
            }
        }

        mAdapterService.handleBondStateChanged(device, oldState, newState);
        Intent intent = new Intent(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
        intent.putExtra(BluetoothDevice.EXTRA_BOND_STATE, newState);
Loading