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

Commit f8a1c912 authored by Sanket Agarwal's avatar Sanket Agarwal
Browse files

Add Headset HF role to the settings menu 

- Makes the HF client a configurable item in Settings. You can
  enable/disable HF per item.
- Disconnect works cleanly since Settings now disconnects HF and hence
  tear down the ACL.

Bug: b/26808830

Change-Id: I062b64beac4c009a6075756b7f163c6455d77af2
parent a5da90c6

packages/SettingsLib/src/com/android/settingslib/bluetooth/CachedBluetoothDevice.java

+7 −6
Original line number Diff line number Diff line
@@ -835,7 +835,7 @@ public final class CachedBluetoothDevice implements Comparable<CachedBluetoothDe 
    public int getConnectionSummary() {

        boolean profileConnected = false;       // at least one profile is connected

        boolean a2dpNotConnected = false;       // A2DP is preferred but not connected

        boolean headsetNotConnected = false;    // Headset is preferred but not connected

        boolean hfpNotConnected = false;    // HFP is preferred but not connected



        for (LocalBluetoothProfile profile : getProfiles()) {

            int connectionStatus = getProfileConnectionState(profile);
@@ -854,8 +854,9 @@ public final class CachedBluetoothDevice implements Comparable<CachedBluetoothDe 
                        if ((profile instanceof A2dpProfile) ||

                            (profile instanceof A2dpSinkProfile)){

                            a2dpNotConnected = true;

                        } else if (profile instanceof HeadsetProfile) {

                            headsetNotConnected = true;

                        } else if ((profile instanceof HeadsetProfile) ||

                                   (profile instanceof HfpClientProfile)) {

                            hfpNotConnected = true;

                        }

                    }

                    break;
@@ -863,11 +864,11 @@ public final class CachedBluetoothDevice implements Comparable<CachedBluetoothDe 
        }



        if (profileConnected) {

            if (a2dpNotConnected && headsetNotConnected) {

            if (a2dpNotConnected && hfpNotConnected) {

                return R.string.bluetooth_connected_no_headset_no_a2dp;

            } else if (a2dpNotConnected) {

                return R.string.bluetooth_connected_no_a2dp;

            } else if (headsetNotConnected) {

            } else if (hfpNotConnected) {

                return R.string.bluetooth_connected_no_headset;

            } else {

                return R.string.bluetooth_connected;

packages/SettingsLib/src/com/android/settingslib/bluetooth/HfpClientProfile.java

0 → 100755
+233 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 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.settingslib.bluetooth;



import android.bluetooth.BluetoothHeadsetClient;

import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothClass;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothProfile;

import android.bluetooth.BluetoothUuid;

import android.content.Context;

import android.os.ParcelUuid;

import android.util.Log;



import com.android.settingslib.R;



import java.util.ArrayList;

import java.util.List;



/**

 * Handles the Handsfree HF role.

 */

final class HfpClientProfile implements LocalBluetoothProfile {

    private static final String TAG = "HfpClientProfile";

    private static boolean V = false;



    private BluetoothHeadsetClient mService;

    private boolean mIsProfileReady;



    private final LocalBluetoothAdapter mLocalAdapter;

    private final CachedBluetoothDeviceManager mDeviceManager;



    static final ParcelUuid[] SRC_UUIDS = {

        BluetoothUuid.HSP_AG,

        BluetoothUuid.Handsfree_AG,

    };



    static final String NAME = "HEADSET_CLIENT";

    private final LocalBluetoothProfileManager mProfileManager;



    // Order of this profile in device profiles list

    private static final int ORDINAL = 0;



    // These callbacks run on the main thread.

    private final class HfpClientServiceListener

            implements BluetoothProfile.ServiceListener {



        @Override

        public void onServiceConnected(int profile, BluetoothProfile proxy) {

            if (V) Log.d(TAG,"Bluetooth service connected");

            mService = (BluetoothHeadsetClient) proxy;

            // We just bound to the service, so refresh the UI for any connected HFP devices.

            List<BluetoothDevice> deviceList = mService.getConnectedDevices();

            while (!deviceList.isEmpty()) {

                BluetoothDevice nextDevice = deviceList.remove(0);

                CachedBluetoothDevice device = mDeviceManager.findDevice(nextDevice);

                // we may add a new device here, but generally this should not happen

                if (device == null) {

                    Log.w(TAG, "HfpClient profile found new device: " + nextDevice);

                    device = mDeviceManager.addDevice(mLocalAdapter, mProfileManager, nextDevice);

                }

                device.onProfileStateChanged(

                    HfpClientProfile.this, BluetoothProfile.STATE_CONNECTED);

                device.refresh();

            }

            mIsProfileReady=true;

        }



        @Override

        public void onServiceDisconnected(int profile) {

            if (V) Log.d(TAG,"Bluetooth service disconnected");

            mIsProfileReady=false;

        }

    }



    @Override

    public boolean isProfileReady() {

        return mIsProfileReady;

    }



    HfpClientProfile(Context context, LocalBluetoothAdapter adapter,

            CachedBluetoothDeviceManager deviceManager,

            LocalBluetoothProfileManager profileManager) {

        mLocalAdapter = adapter;

        mDeviceManager = deviceManager;

        mProfileManager = profileManager;

        mLocalAdapter.getProfileProxy(context, new HfpClientServiceListener(),

                BluetoothProfile.HEADSET_CLIENT);

    }



    @Override

    public boolean isConnectable() {

        return true;

    }



    @Override

    public boolean isAutoConnectable() {

        return true;

    }



    public List<BluetoothDevice> getConnectedDevices() {

        if (mService == null) return new ArrayList<BluetoothDevice>(0);

        return mService.getDevicesMatchingConnectionStates(

              new int[] {BluetoothProfile.STATE_CONNECTED,

                         BluetoothProfile.STATE_CONNECTING,

                         BluetoothProfile.STATE_DISCONNECTING});

    }



    @Override

    public boolean connect(BluetoothDevice device) {

        if (mService == null) return false;

        List<BluetoothDevice> srcs = getConnectedDevices();

        if (srcs != null) {

            for (BluetoothDevice src : srcs) {

                if (src.equals(device)) {

                    // Connect to same device, Ignore it

                    Log.d(TAG,"Ignoring Connect");

                    return true;

                }

            }

            // Handsfree HF only supports one source connection and hence it is OK to disconnect

            // the only connected device here.

            for (BluetoothDevice src : srcs) {

                mService.disconnect(src);

            }

        }

        return mService.connect(device);

    }



    @Override

    public boolean disconnect(BluetoothDevice device) {

        if (mService == null) return false;

        // Downgrade priority as user is disconnecting the headset.

        if (mService.getPriority(device) > BluetoothProfile.PRIORITY_ON){

            mService.setPriority(device, BluetoothProfile.PRIORITY_ON);

        }

        return mService.disconnect(device);

    }



    @Override

    public int getConnectionStatus(BluetoothDevice device) {

        if (mService == null) {

            return BluetoothProfile.STATE_DISCONNECTED;

        }

        return mService.getConnectionState(device);

    }



    @Override

    public boolean isPreferred(BluetoothDevice device) {

        if (mService == null) return false;

        return mService.getPriority(device) > BluetoothProfile.PRIORITY_OFF;

    }



    @Override

    public int getPreferred(BluetoothDevice device) {

        if (mService == null) return BluetoothProfile.PRIORITY_OFF;

        return mService.getPriority(device);

    }



    @Override

    public void setPreferred(BluetoothDevice device, boolean preferred) {

        if (mService == null) return;

        if (preferred) {

            if (mService.getPriority(device) < BluetoothProfile.PRIORITY_ON) {

                mService.setPriority(device, BluetoothProfile.PRIORITY_ON);

            }

        } else {

            mService.setPriority(device, BluetoothProfile.PRIORITY_OFF);

        }

    }



    @Override

    public String toString() {

        return NAME;

    }



    @Override

    public int getOrdinal() {

        return ORDINAL;

    }



    @Override

    public int getNameResource(BluetoothDevice device) {

        return R.string.bluetooth_profile_headset;

    }



    @Override

    public int getSummaryResourceForDevice(BluetoothDevice device) {

        int state = getConnectionStatus(device);

        switch (state) {

            case BluetoothProfile.STATE_DISCONNECTED:

                return R.string.bluetooth_headset_profile_summary_use_for;



            case BluetoothProfile.STATE_CONNECTED:

                return R.string.bluetooth_headset_profile_summary_connected;



            default:

                return Utils.getConnectionStateSummary(state);

        }

    }



    @Override

    public int getDrawableResource(BluetoothClass btClass) {

        return R.drawable.ic_bt_headset_hfp;

    }



    protected void finalize() {

        if (V) Log.d(TAG, "finalize()");

        if (mService != null) {

            try {

                BluetoothAdapter.getDefaultAdapter().closeProfileProxy(

                    BluetoothProfile.HEADSET_CLIENT, mService);

                mService = null;

            } catch (Throwable t) {

                Log.w(TAG, "Error cleaning up HfpClient proxy", t);

            }

        }

    }

}

packages/SettingsLib/src/com/android/settingslib/bluetooth/LocalBluetoothProfileManager.java

+32 −4
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ import android.bluetooth.BluetoothA2dp; 
import android.bluetooth.BluetoothA2dpSink;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHeadset;

import android.bluetooth.BluetoothHeadsetClient;

import android.bluetooth.BluetoothMap;

import android.bluetooth.BluetoothInputDevice;

import android.bluetooth.BluetoothPan;
@@ -76,6 +77,7 @@ public final class LocalBluetoothProfileManager { 
    private A2dpProfile mA2dpProfile;

    private A2dpSinkProfile mA2dpSinkProfile;

    private HeadsetProfile mHeadsetProfile;

    private HfpClientProfile mHfpClientProfile;

    private MapProfile mMapProfile;

    private final HidProfile mHidProfile;

    private OppProfile mOppProfile;
@@ -150,6 +152,7 @@ public final class LocalBluetoothProfileManager { 
            Log.w(TAG, "Warning: A2DP profile was previously added but the UUID is now missing.");

        }



        // A2DP SINK

        if (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.AudioSink)) {

            if (mA2dpSinkProfile == null) {

                if(DEBUG) Log.d(TAG, "Adding local A2DP Sink profile");
@@ -175,6 +178,22 @@ public final class LocalBluetoothProfileManager { 
            Log.w(TAG, "Warning: HEADSET profile was previously added but the UUID is now missing.");

        }



        // Headset HF

        if (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.Handsfree)) {

            if (mHfpClientProfile == null) {

                if(DEBUG) Log.d(TAG, "Adding local HfpClient profile");

                mHfpClientProfile =

                    new HfpClientProfile(mContext, mLocalAdapter, mDeviceManager, this);

                addProfile(mHfpClientProfile, HfpClientProfile.NAME,

                        BluetoothHeadsetClient.ACTION_CONNECTION_STATE_CHANGED);

            }

        } else if (mHfpClientProfile != null) {

            Log.w(TAG,

                "Warning: Hfp Client profile was previously added but the UUID is now missing.");

        } else {

            Log.d(TAG, "Handsfree Uuid not found.");

        }



        // OPP

        if (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.ObexObjectPush)) {

            if (mOppProfile == null) {
@@ -312,17 +331,26 @@ public final class LocalBluetoothProfileManager { 
        return mA2dpProfile;

    }



    A2dpSinkProfile getA2dpSinkProfile() {

        if ((mA2dpSinkProfile != null)&&(mA2dpSinkProfile.isProfileReady()))

    public A2dpSinkProfile getA2dpSinkProfile() {

        if ((mA2dpSinkProfile != null) && (mA2dpSinkProfile.isProfileReady())) {

            return mA2dpSinkProfile;

        else

        } else {

            return null;

        }

    }



    public HeadsetProfile getHeadsetProfile() {

        return mHeadsetProfile;

    }



    public HfpClientProfile getHfpClientProfile() {

        if ((mHfpClientProfile != null) && (mHfpClientProfile.isProfileReady())) {

            return mHfpClientProfile;

        } else {

          return null;

        }

    }



    public PbapServerProfile getPbapProfile(){

        return mPbapProfile;

    }