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

Commit 10b4f7b0 authored by Rahul Sabnis's avatar Rahul Sabnis
Browse files

Use getConnectionState to determine which profiles to disconnect in 

AdapterService#disconnectAllEnabledProfiles()

Bug: 146073640
Test: Manual
Change-Id: If31e8ddae445daa7fe760ee0450d4188389cf502
parent ad040d9d

src/com/android/bluetooth/a2dpsink/A2dpSinkService.java

+10 −1
Original line number Diff line number Diff line
@@ -306,7 +306,16 @@ public class A2dpSinkService extends ProfileService { 
        return deviceList;

    }



    synchronized int getConnectionState(BluetoothDevice device) {

    /**

     * Get the current connection state of the profile

     *

     * @param device is the remote bluetooth device

     * @return {@link BluetoothProfile#STATE_DISCONNECTED} if this profile is disconnected,

     * {@link BluetoothProfile#STATE_CONNECTING} if this profile is being connected,

     * {@link BluetoothProfile#STATE_CONNECTED} if this profile is connected, or

     * {@link BluetoothProfile#STATE_DISCONNECTING} if this profile is being disconnected

     */

    public synchronized int getConnectionState(BluetoothDevice device) {

        A2dpSinkStateMachine stateMachine = mDeviceStateMap.get(device);

        return (stateMachine == null) ? BluetoothProfile.STATE_DISCONNECTED

                : stateMachine.getState();

src/com/android/bluetooth/btservice/AdapterService.java

+24 −27
Original line number Diff line number Diff line
@@ -2463,67 +2463,64 @@ public class AdapterService extends Service { 
            return false;

        }



        ParcelUuid[] remoteDeviceUuids = getRemoteUuids(device);

        ParcelUuid[] localDeviceUuids = mAdapterProperties.getUuids();



        if (mA2dpService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.A2DP, device)) {

        if (mA2dpService != null && mA2dpService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting A2dp");

            mA2dpService.disconnect(device);

        }

        if (mA2dpSinkService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.A2DP_SINK, device)) {

        if (mA2dpSinkService != null && mA2dpSinkService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting A2dp Sink");

            mA2dpSinkService.disconnect(device);

        }

        if (mHeadsetService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.HEADSET, device)) {

        if (mHeadsetService != null && mHeadsetService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG,

                    "disconnectAllEnabledProfiles: Disconnecting Headset Profile");

            mHeadsetService.disconnect(device);

        }

        if (mHeadsetClientService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.HEADSET_CLIENT, device)) {

        if (mHeadsetClientService != null && mHeadsetClientService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting HFP");

            mHeadsetClientService.disconnect(device);

        }

        if (mMapClientService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.MAP_CLIENT, device)) {

        if (mMapClientService != null && mMapClientService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting MAP Client");

            mMapClientService.disconnect(device);

        }

        if (mMapService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.MAP, device)) {

        if (mMapService != null && mMapService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting MAP");

            mMapService.disconnect(device);

        }

        if (mHidDeviceService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.HID_DEVICE, device)) {

        if (mHidDeviceService != null && mHidDeviceService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting Hid Device Profile");

            mHidDeviceService.disconnect(device);

        }

        if (mHidHostService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.HID_HOST, device)) {

        if (mHidHostService != null && mHidHostService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting Hid Host Profile");

            mHidHostService.disconnect(device);

        }

        if (mPanService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.PAN, device)) {

        if (mPanService != null && mPanService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting Pan Profile");

            mPanService.disconnect(device);

        }

        if (mPbapClientService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.PBAP_CLIENT, device)) {

        if (mPbapClientService != null && mPbapClientService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting Pbap Client");

            mPbapClientService.disconnect(device);

        }

        if (mPbapService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.PBAP, device)) {

        if (mPbapService != null && mPbapService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting Pbap Server");

            mPbapService.disconnect(device);

        }

        if (mHearingAidService != null && isSupported(localDeviceUuids, remoteDeviceUuids,

                BluetoothProfile.HEARING_AID, device)) {

        if (mHearingAidService != null && mHearingAidService.getConnectionState(device)

                == BluetoothProfile.STATE_CONNECTED) {

            Log.i(TAG, "disconnectAllEnabledProfiles: Disconnecting Hearing Aid Profile");

            mHearingAidService.disconnect(device);

        }

src/com/android/bluetooth/hearingaid/HearingAidService.java

+10 −1
Original line number Diff line number Diff line
@@ -442,7 +442,16 @@ public class HearingAidService extends ProfileService { 
        return mDeviceHiSyncIdMap;

    }



    int getConnectionState(BluetoothDevice device) {

    /**

     * Get the current connection state of the profile

     *

     * @param device is the remote bluetooth device

     * @return {@link BluetoothProfile#STATE_DISCONNECTED} if this profile is disconnected,

     * {@link BluetoothProfile#STATE_CONNECTING} if this profile is being connected,

     * {@link BluetoothProfile#STATE_CONNECTED} if this profile is connected, or

     * {@link BluetoothProfile#STATE_DISCONNECTING} if this profile is being disconnected

     */

    public int getConnectionState(BluetoothDevice device) {

        enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");

        synchronized (mStateMachines) {

            HearingAidStateMachine sm = mStateMachines.get(device);

src/com/android/bluetooth/hfpclient/HeadsetClientService.java

+10 −1
Original line number Diff line number Diff line
@@ -543,7 +543,16 @@ public class HeadsetClientService extends ProfileService { 
        return devices;

    }



    private synchronized int getConnectionState(BluetoothDevice device) {

    /**

     * Get the current connection state of the profile

     *

     * @param device is the remote bluetooth device

     * @return {@link BluetoothProfile#STATE_DISCONNECTED} if this profile is disconnected,

     * {@link BluetoothProfile#STATE_CONNECTING} if this profile is being connected,

     * {@link BluetoothProfile#STATE_CONNECTED} if this profile is connected, or

     * {@link BluetoothProfile#STATE_DISCONNECTING} if this profile is being disconnected

     */

    public synchronized int getConnectionState(BluetoothDevice device) {

        enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");

        HeadsetClientStateMachine sm = mStateMachineMap.get(device);

        if (sm != null) {

src/com/android/bluetooth/hid/HidDeviceService.java

+26 −2
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ import android.util.Log; 


import com.android.bluetooth.BluetoothMetricsProto;

import com.android.bluetooth.Utils;

import com.android.bluetooth.btservice.AdapterService;

import com.android.bluetooth.btservice.MetricsLogger;

import com.android.bluetooth.btservice.ProfileService;

import com.android.internal.annotations.VisibleForTesting;
@@ -661,9 +662,10 @@ public class HidDeviceService extends ProfileService { 
        enforceCallingOrSelfPermission(

                BLUETOOTH_PRIVILEGED, "Need BLUETOOTH_PRIVILEGED permission");

        if (DBG) {

            Log.d(TAG, "setConnectionPolicy: device " + device

                    + " and connectionPolicy " + connectionPolicy);

            Log.d(TAG, "Saved connectionPolicy " + device + " = " + connectionPolicy);

        }

        AdapterService.getAdapterService().getDatabase()

                .setProfileConnectionPolicy(device, BluetoothProfile.HID_DEVICE, connectionPolicy);

        if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            disconnect(device);

            return true;
@@ -671,6 +673,28 @@ public class HidDeviceService extends ProfileService { 
        return false;

    }



    /**

     * Get the connection policy of the profile.

     *

     * <p> The connection policy can be any of:

     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED},

     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN},

     * {@link BluetoothProfile#CONNECTION_POLICY_UNKNOWN}

     *

     * @param device Bluetooth device

     * @return connection policy of the device

     * @hide

     */

    public int getConnectionPolicy(BluetoothDevice device) {

        if (device == null) {

            throw new IllegalArgumentException("Null device");

        }

        enforceCallingOrSelfPermission(

                BLUETOOTH_PRIVILEGED, "Need BLUETOOTH_PRIVILEGED permission");

        return AdapterService.getAdapterService().getDatabase()

                .getProfileConnectionPolicy(device, BluetoothProfile.HID_DEVICE);

    }



    synchronized boolean reportError(BluetoothDevice device, byte error) {

        enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission");

        if (DBG) {