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

Commit ffc38cc9 authored by Rahul Sabnis's avatar Rahul Sabnis
Browse files

setConnectionPolicy now calls connect or disconnect based on the passed 

in connectionPolicy, clean up connection logic in AdapterService to no
longer call both connect and setConnection policy as well as
remove references to PRIORITY_AUTO_CONNECT.

Bug: 146805667
Test: Manual
Change-Id: I2be3dcb2894450cc716d8f753a496cd81a6819f4
parent f3bbe2b4

android/app/src/com/android/bluetooth/a2dp/A2dpService.java

+12 −4
Original line number Diff line number Diff line
@@ -617,7 +617,9 @@ public class A2dpService extends ProfileService { 
    }



    /**

     * Set connection policy of the profile

     * Set connection policy of the profile and connects it if connectionPolicy is

     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED} or disconnects if connectionPolicy is

     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN}

     *

     * <p> The device should already be paired.

     * Connection policy can be one of:
@@ -628,16 +630,22 @@ public class A2dpService extends ProfileService { 
     * @param device Paired bluetooth device

     * @param connectionPolicy is the connection policy to set to for this profile

     * @return true if connectionPolicy is set, false on error

     * @hide

     */

    public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {

        enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");

        if (DBG) {

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

        }

        mAdapterService.getDatabase()

        boolean setSuccessfully;

        setSuccessfully = mAdapterService.getDatabase()

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

        return true;

        if (setSuccessfully && connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

            connect(device);

        } else if (setSuccessfully

                && connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            disconnect(device);

        }

        return setSuccessfully;

    }



    /**

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

+17 −4
Original line number Diff line number Diff line
@@ -313,11 +313,19 @@ public class A2dpSinkService extends ProfileService { 
    }



    /**

     * Set the connectionPolicy of the  profile.

     * Set connection policy of the profile and connects it if connectionPolicy is

     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED} or disconnects if connectionPolicy is

     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN}

     *

     * @param device   the remote device

     * @param connectionPolicy the connectionPolicy of the profile

     * @return true on success, otherwise false

     * <p> The device should already be paired.

     * Connection policy can be one of:

     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED},

     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN},

     * {@link BluetoothProfile#CONNECTION_POLICY_UNKNOWN}

     *

     * @param device Paired bluetooth device

     * @param connectionPolicy is the connection policy to set to for this profile

     * @return true if connectionPolicy is set, false on error

     */

    public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {

        enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
@@ -326,6 +334,11 @@ public class A2dpSinkService extends ProfileService { 
        }

        AdapterService.getAdapterService().getDatabase()

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

        if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

            connect(device);

        } else if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            disconnect(device);

        }

        return true;

    }

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

+17 −70
Original line number Diff line number Diff line
@@ -899,7 +899,7 @@ public class AdapterService extends Service { 
                > BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            return true;

        }

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

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

                > BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            return true;

        }
@@ -965,7 +965,7 @@ public class AdapterService extends Service { 
            mHidHostService.connect(device);

        }

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

                BluetoothProfile.PAN, device) && mPanService.getPriority(device)

                BluetoothProfile.PAN, device) && mPanService.getConnectionPolicy(device)

                > BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            Log.i(TAG, "connectEnabledProfiles: Connecting Pan Profile");

            mPanService.connect(device);
@@ -2357,69 +2357,62 @@ public class AdapterService extends Service { 
        // All profile toggles disabled, so connects all supported profiles

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

                BluetoothProfile.A2DP, device)) {

            mA2dpService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting A2dp");

            mA2dpService.connect(device);

            // Set connection policy also connects the profile with CONNECTION_POLICY_ALLOWED

            mA2dpService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            numProfilesConnected++;

        }

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

                BluetoothProfile.A2DP_SINK, device)) {

            Log.i(TAG, "connectAllEnabledProfiles: Connecting A2dp Sink");

            mA2dpSinkService.setConnectionPolicy(device,

                    BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting A2dp Sink");

            mA2dpSinkService.connect(device);

            numProfilesConnected++;

        }

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

                BluetoothProfile.HEADSET, device)) {

            mHeadsetService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting Headset Profile");

            mHeadsetService.connect(device);

            mHeadsetService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            numProfilesConnected++;

        }

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

                BluetoothProfile.HEADSET_CLIENT, device)) {

            Log.i(TAG, "connectAllEnabledProfiles: Connecting HFP");

            mHeadsetClientService.setConnectionPolicy(device,

                    BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting HFP");

            mHeadsetClientService.connect(device);

            numProfilesConnected++;

        }

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

                BluetoothProfile.MAP_CLIENT, device)) {

            Log.i(TAG, "connectAllEnabledProfiles: Connecting MAP");

            mMapClientService.setConnectionPolicy(device,

                    BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting MAP");

            mMapClientService.connect(device);

            numProfilesConnected++;

        }

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

                BluetoothProfile.HID_HOST, device)) {

            Log.i(TAG, "connectAllEnabledProfiles: Connecting Hid Host Profile");

            mHidHostService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG,

                    "connectAllEnabledProfiles: Connecting Hid Host Profile");

            mHidHostService.connect(device);

            numProfilesConnected++;

        }

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

                BluetoothProfile.PAN, device)) {

            Log.i(TAG, "connectAllEnabledProfiles: Connecting Pan Profile");

            mPanService.connect(device);

            mPanService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            numProfilesConnected++;

        }

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

                BluetoothProfile.PBAP_CLIENT, device)) {

            Log.i(TAG, "connectAllEnabledProfiles: Connecting Pbap");

            mPbapClientService.setConnectionPolicy(device,

                    BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting Pbap");

            mPbapClientService.connect(device);

            numProfilesConnected++;

        }

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

                BluetoothProfile.HEARING_AID, device)) {

            Log.i(TAG,

                    "connectAllEnabledProfiles: Connecting Hearing Aid Profile");

            mHearingAidService.connect(device);

            Log.i(TAG, "connectAllEnabledProfiles: Connecting Hearing Aid Profile");

            mHearingAidService.setConnectionPolicy(device,

                    BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            numProfilesConnected++;

        }
@@ -2446,77 +2439,38 @@ public class AdapterService extends Service { 


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

                BluetoothProfile.A2DP, device)) {

            if (mA2dpService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mA2dpService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



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

            mA2dpService.disconnect(device);

        }

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

                BluetoothProfile.A2DP_SINK, device)) {

            if (mA2dpSinkService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mA2dpSinkService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



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

            mA2dpSinkService.disconnect(device);

        }

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

                BluetoothProfile.HEADSET, device)) {

            if (mHeadsetService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mHeadsetService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



            Log.i(TAG,

                    "disconnectAllEnabledProfiles: Disconnecting Headset Profile");

            mHeadsetService.disconnect(device);

        }

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

                BluetoothProfile.HEADSET_CLIENT, device)) {

            if (mHeadsetClientService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mHeadsetClientService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



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

            mHeadsetClientService.disconnect(device);

        }

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

                BluetoothProfile.MAP_CLIENT, device)) {

            if (mMapClientService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mMapClientService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



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

            mMapClientService.disconnect(device);

        }

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

                BluetoothProfile.HID_DEVICE, device)) {

            Log.i(TAG,

                    "disconnectAllEnabledProfiles: Disconnecting Hid Device "

                            + "Profile");

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

            mHidDeviceService.disconnect(device);

        }

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

                BluetoothProfile.HID_HOST, device)) {

            if (mHidHostService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mHidHostService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



            Log.i(TAG,

                    "disconnectAllEnabledProfiles: Disconnecting Hid Host Profile");

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

            mHidHostService.disconnect(device);

        }

        if (mPanService != null && isSupported(localDeviceUuids, remoteDeviceUuids,
@@ -2526,19 +2480,12 @@ public class AdapterService extends Service { 
        }

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

                BluetoothProfile.PBAP_CLIENT, device)) {

            if (mPbapClientService.getConnectionPolicy(device)

                    > BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

                mPbapClientService.setConnectionPolicy(device,

                        BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            }



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

            mPbapClientService.disconnect(device);

        }

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

                BluetoothProfile.HEARING_AID, device)) {

            Log.i(TAG,

                    "disconnectAllEnabledProfiles: Disconnecting Hearing Aid Profile");

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

            mHearingAidService.disconnect(device);

        }

android/app/src/com/android/bluetooth/btservice/PhonePolicy.java

+4 −3
Original line number Diff line number Diff line
@@ -258,10 +258,11 @@ class PhonePolicy { 
        }



        if ((panService != null) && (ArrayUtils.contains(uuids, BluetoothUuid.PANU) && (

                panService.getPriority(device) == BluetoothProfile.CONNECTION_POLICY_UNKNOWN)

                panService.getConnectionPolicy(device)

                        == BluetoothProfile.CONNECTION_POLICY_UNKNOWN)

                && mAdapterService.getResources()

                .getBoolean(R.bool.config_bluetooth_pan_enable_autoconnect))) {

            panService.setPriority(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

            panService.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        }



        if ((hearingAidService != null) && ArrayUtils.contains(uuids,
@@ -490,7 +491,7 @@ class PhonePolicy { 
            List<BluetoothDevice> panConnDevList = panService.getConnectedDevices();

            // TODO: the panConnDevList.isEmpty() check below should be removed once

            // Multi-PAN is supported.

            if (panConnDevList.isEmpty() && (panService.getPriority(device)

            if (panConnDevList.isEmpty() && (panService.getConnectionPolicy(device)

                    >= BluetoothProfile.CONNECTION_POLICY_ALLOWED)

                    && (panService.getConnectionState(device)

                    == BluetoothProfile.STATE_DISCONNECTED)) {

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

+17 −4
Original line number Diff line number Diff line
@@ -454,11 +454,19 @@ public class HearingAidService extends ProfileService { 
    }



    /**

     * Set the connectionPolicy of the Hearing Aid profile.

     * Set connection policy of the profile and connects it if connectionPolicy is

     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED} or disconnects if connectionPolicy is

     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN}

     *

     * @param device the remote device

     * @param connectionPolicy the connection policy of the profile

     * @return true on success, otherwise false

     * <p> The device should already be paired.

     * Connection policy can be one of:

     * {@link BluetoothProfile#CONNECTION_POLICY_ALLOWED},

     * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN},

     * {@link BluetoothProfile#CONNECTION_POLICY_UNKNOWN}

     *

     * @param device Paired bluetooth device

     * @param connectionPolicy is the connection policy to set to for this profile

     * @return true if connectionPolicy is set, false on error

     */

    public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {

        enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
@@ -467,6 +475,11 @@ public class HearingAidService extends ProfileService { 
        }

        mAdapterService.getDatabase()

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

        if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

            connect(device);

        } else if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

            disconnect(device);

        }

        return true;

    }