xref: /packages/apps/Phone/src/com/android/phone/BluetoothHeadsetService.java

/*
 * Copyright (C) 2006 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.phone;

import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothAudioGateway;
import android.bluetooth.BluetoothAudioGateway.IncomingConnectionInfo;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothHeadset;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothUuid;
import android.bluetooth.HeadsetBase;
import android.bluetooth.IBluetooth;
import android.bluetooth.IBluetoothHeadset;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.ParcelUuid;
import android.os.PowerManager;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.provider.Settings;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Provides Bluetooth Headset and Handsfree profile, as a service in
 * the Phone application.
 * @hide
 */
public class BluetoothHeadsetService extends Service {
    private static final String TAG = "Bluetooth HSHFP";
    private static final boolean DBG = true;

    private static final String PREF_NAME = BluetoothHeadsetService.class.getSimpleName();
    private static final String PREF_LAST_HEADSET = "lastHeadsetAddress";

    private static final int PHONE_STATE_CHANGED = 1;

    private static final String BLUETOOTH_ADMIN_PERM = android.Manifest.permission.BLUETOOTH_ADMIN;
    private static final String BLUETOOTH_PERM = android.Manifest.permission.BLUETOOTH;

    private static boolean sHasStarted = false;

    private BluetoothDevice mDeviceSdpQuery;
    private BluetoothAdapter mAdapter;
    private IBluetooth mBluetoothService;
    private PowerManager mPowerManager;
    private BluetoothAudioGateway mAg;
    private BluetoothHandsfree mBtHandsfree;
    private ConcurrentHashMap<BluetoothDevice, BluetoothRemoteHeadset> mRemoteHeadsets;
    private BluetoothDevice mAudioConnectedDevice;

    @Override
    public void onCreate() {
        super.onCreate();
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mPowerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
        mBtHandsfree = PhoneApp.getInstance().getBluetoothHandsfree();
        mAg = new BluetoothAudioGateway(mAdapter);
        IntentFilter filter = new IntentFilter(
                BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED);
        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        filter.addAction(AudioManager.VOLUME_CHANGED_ACTION);
        filter.addAction(BluetoothDevice.ACTION_UUID);
        registerReceiver(mBluetoothReceiver, filter);

        IBinder b = ServiceManager.getService(BluetoothAdapter.BLUETOOTH_SERVICE);
        if (b == null) {
            throw new RuntimeException("Bluetooth service not available");
        }
        mBluetoothService = IBluetooth.Stub.asInterface(b);
        mRemoteHeadsets = new ConcurrentHashMap<BluetoothDevice, BluetoothRemoteHeadset>();
   }

   private class BluetoothRemoteHeadset {
       private int mState;
       private int mAudioState;
       private int mHeadsetType;
       private HeadsetBase mHeadset;
       private IncomingConnectionInfo mIncomingInfo;

       BluetoothRemoteHeadset() {
           mState = BluetoothProfile.STATE_DISCONNECTED;
           mHeadsetType = BluetoothHandsfree.TYPE_UNKNOWN;
           mHeadset = null;
           mIncomingInfo = null;
           mAudioState = BluetoothHeadset.STATE_AUDIO_DISCONNECTED;
       }

       BluetoothRemoteHeadset(int headsetType, IncomingConnectionInfo incomingInfo) {
           mState = BluetoothProfile.STATE_DISCONNECTED;
           mHeadsetType = headsetType;
           mHeadset = null;
           mIncomingInfo = incomingInfo;
           mAudioState = BluetoothHeadset.STATE_AUDIO_DISCONNECTED;
       }
   }

   synchronized private BluetoothDevice getCurrentDevice() {
       for (BluetoothDevice device : mRemoteHeadsets.keySet()) {
           int state = mRemoteHeadsets.get(device).mState;
           if (state == BluetoothProfile.STATE_CONNECTING ||
               state == BluetoothProfile.STATE_CONNECTED) {
               return device;
           }
       }
       return null;
   }

    @Override
    public void onStart(Intent intent, int startId) {
         if (mAdapter == null) {
            Log.w(TAG, "Stopping BluetoothHeadsetService: device does not have BT");
            stopSelf();
        } else {
            if (!sHasStarted) {
                if (DBG) log("Starting BluetoothHeadsetService");
                if (mAdapter.isEnabled()) {
                    mAg.start(mIncomingConnectionHandler);
                    mBtHandsfree.onBluetoothEnabled();
                }
                sHasStarted = true;
            }
        }
    }

    private final Handler mIncomingConnectionHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            synchronized(BluetoothHeadsetService.this) {
                IncomingConnectionInfo info = (IncomingConnectionInfo)msg.obj;
                int type = BluetoothHandsfree.TYPE_UNKNOWN;
                switch(msg.what) {
                case BluetoothAudioGateway.MSG_INCOMING_HEADSET_CONNECTION:
                    type = BluetoothHandsfree.TYPE_HEADSET;
                    break;
                case BluetoothAudioGateway.MSG_INCOMING_HANDSFREE_CONNECTION:
                    type = BluetoothHandsfree.TYPE_HANDSFREE;
                    break;
                }

                Log.i(TAG, "Incoming rfcomm (" + BluetoothHandsfree.typeToString(type) +
                      ") connection from " + info.mRemoteDevice + "on channel " +
                      info.mRfcommChan);

                int priority = BluetoothProfile.PRIORITY_OFF;
                HeadsetBase headset;
                priority = getPriority(info.mRemoteDevice);
                if (priority <= BluetoothProfile.PRIORITY_OFF) {
                    Log.i(TAG, "Rejecting incoming connection because priority = " + priority);

                    headset = new HeadsetBase(mPowerManager, mAdapter,
                                              info.mRemoteDevice,
                                              info.mSocketFd, info.mRfcommChan,
                                              null);
                    headset.disconnect();
                    try {
                        mBluetoothService.notifyIncomingConnection(info.mRemoteDevice.getAddress(),
                                                                   true);
                    } catch (RemoteException e) {
                        Log.e(TAG, "notifyIncomingConnection", e);
                    }
                    return;
                }

                BluetoothRemoteHeadset remoteHeadset;
                BluetoothDevice device = getCurrentDevice();

                int state = BluetoothProfile.STATE_DISCONNECTED;
                if (device != null) {
                    state = mRemoteHeadsets.get(device).mState;
                }

                switch (state) {
                case BluetoothProfile.STATE_DISCONNECTED:
                    // headset connecting us, lets join
                    remoteHeadset = new BluetoothRemoteHeadset(type, info);
                    mRemoteHeadsets.put(info.mRemoteDevice, remoteHeadset);

                    try {
                        mBluetoothService.notifyIncomingConnection(
                           info.mRemoteDevice.getAddress(), false);
                    } catch (RemoteException e) {
                        Log.e(TAG, "notifyIncomingConnection");
                    }
                    break;
                case BluetoothProfile.STATE_CONNECTING:
                    if (!info.mRemoteDevice.equals(device)) {
                        // different headset, ignoring
                        Log.i(TAG, "Already attempting connect to " + device +
                              ", disconnecting " + info.mRemoteDevice);

                        headset = new HeadsetBase(mPowerManager, mAdapter,
                                                  info.mRemoteDevice,
                                                  info.mSocketFd, info.mRfcommChan,
                                                  null);
                        headset.disconnect();
                        break;
                    }

                    // Incoming and Outgoing connections to the same headset.
                    // The state machine manager will cancel outgoing and accept the incoming one.
                    // Update the state
                    mRemoteHeadsets.get(info.mRemoteDevice).mHeadsetType = type;
                    mRemoteHeadsets.get(info.mRemoteDevice).mIncomingInfo = info;

                    try {
                        mBluetoothService.notifyIncomingConnection(
                            info.mRemoteDevice.getAddress(), false);
                    } catch (RemoteException e) {
                        Log.e(TAG, "notifyIncomingConnection");
                    }
                    break;
                case BluetoothProfile.STATE_CONNECTED:
                    Log.i(TAG, "Already connected to " + device + ", disconnecting " +
                            info.mRemoteDevice);
                    rejectIncomingConnection(info);
                    break;
                }
            }
        }
    };

    private void rejectIncomingConnection(IncomingConnectionInfo info) {
        HeadsetBase headset = new HeadsetBase(mPowerManager, mAdapter,
            info.mRemoteDevice, info.mSocketFd, info.mRfcommChan, null);
        headset.disconnect();
    }


    private final BroadcastReceiver mBluetoothReceiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            BluetoothDevice device =
                    intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

            BluetoothDevice currDevice = getCurrentDevice();
            int state = BluetoothProfile.STATE_DISCONNECTED;
            if (currDevice != null) {
                state = mRemoteHeadsets.get(currDevice).mState;
            }

            if ((state == BluetoothProfile.STATE_CONNECTED ||
                    state == BluetoothProfile.STATE_CONNECTING) &&
                    action.equals(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED) &&
                    device.equals(currDevice)) {
                try {
                    mBinder.disconnect(currDevice);
                } catch (RemoteException e) {}
            } else if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                switch (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
                                           BluetoothAdapter.ERROR)) {
                case BluetoothAdapter.STATE_ON:
                    mAg.start(mIncomingConnectionHandler);
                    mBtHandsfree.onBluetoothEnabled();
                    break;
                case BluetoothAdapter.STATE_TURNING_OFF:
                    mBtHandsfree.onBluetoothDisabled();
                    mAg.stop();
                    if (currDevice != null) {
                        try {
                            mBinder.disconnect(currDevice);
                        } catch (RemoteException e) {}
                    }
                    break;
                }
            } else if (action.equals(AudioManager.VOLUME_CHANGED_ACTION)) {
                int streamType = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, -1);
                if (streamType == AudioManager.STREAM_BLUETOOTH_SCO) {
                    mBtHandsfree.sendScoGainUpdate(intent.getIntExtra(
                            AudioManager.EXTRA_VOLUME_STREAM_VALUE, 0));
                }

            } else if (action.equals(BluetoothDevice.ACTION_UUID)) {
                if (device.equals(mDeviceSdpQuery) && device.equals(currDevice)) {
                    // We have got SDP records for the device we are interested in.
                    getSdpRecordsAndConnect(device);
                }
            }
        }
    };

    private static final int CONNECT_HEADSET_DELAYED = 1;
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case CONNECT_HEADSET_DELAYED:
                    BluetoothDevice device = (BluetoothDevice) msg.obj;
                    getSdpRecordsAndConnect(device);
                    break;
            }
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    // ------------------------------------------------------------------
    // Bluetooth Headset Connect
    // ------------------------------------------------------------------
    private static final int RFCOMM_CONNECTED             = 1;
    private static final int RFCOMM_ERROR                 = 2;

    private long mTimestamp;

    /**
     * Thread for RFCOMM connection
     * Messages are sent to mConnectingStatusHandler as connection progresses.
     */
    private RfcommConnectThread mConnectThread;
    private class RfcommConnectThread extends Thread {
        private BluetoothDevice device;
        private int channel;
        private int type;

        private static final int EINTERRUPT = -1000;
        private static final int ECONNREFUSED = -111;

        public RfcommConnectThread(BluetoothDevice device, int channel, int type) {
            super();
            this.device = device;
            this.channel = channel;
            this.type = type;
        }

        private int waitForConnect(HeadsetBase headset) {
            // Try to connect for 20 seconds
            int result = 0;
            for (int i=0; i < 40 && result == 0; i++) {
                // waitForAsyncConnect returns 0 on timeout, 1 on success, < 0 on error.
                result = headset.waitForAsyncConnect(500, mConnectedStatusHandler);
                if (isInterrupted()) {
                    headset.disconnect();
                    return EINTERRUPT;
                }
            }
            return result;
        }

        @Override
        public void run() {
            long timestamp;

            timestamp = System.currentTimeMillis();
            HeadsetBase headset = new HeadsetBase(mPowerManager, mAdapter,
                                                  device, channel);

            int result = waitForConnect(headset);

            if (result != EINTERRUPT && result != 1) {
                if (result == ECONNREFUSED && mDeviceSdpQuery == null) {
                    // The rfcomm channel number might have changed, do SDP
                    // query and try to connect again.
                    mDeviceSdpQuery = getCurrentDevice();
                    device.fetchUuidsWithSdp();
                    mConnectThread = null;
                    return;
                } else {
                    Log.i(TAG, "Trying to connect to rfcomm socket again after 1 sec");
                    try {
                      sleep(1000);  // 1 second
                    } catch (InterruptedException e) {
                      return;
                    }
                }
                result = waitForConnect(headset);
            }
            mDeviceSdpQuery = null;
            if (result == EINTERRUPT) return;

            if (DBG) log("RFCOMM connection attempt took " +
                  (System.currentTimeMillis() - timestamp) + " ms");
            if (isInterrupted()) {
                headset.disconnect();
                return;
            }
            if (result < 0) {
                Log.w(TAG, "headset.waitForAsyncConnect() error: " + result);
                mConnectingStatusHandler.obtainMessage(RFCOMM_ERROR).sendToTarget();
                return;
            } else if (result == 0) {
                mConnectingStatusHandler.obtainMessage(RFCOMM_ERROR).sendToTarget();
                Log.w(TAG, "mHeadset.waitForAsyncConnect() error: " + result + "(timeout)");
                return;
            } else {
                mConnectingStatusHandler.obtainMessage(RFCOMM_CONNECTED, headset).sendToTarget();
            }
        }
    }

    /**
     * Receives events from mConnectThread back in the main thread.
     */
    private final Handler mConnectingStatusHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            BluetoothDevice device = getCurrentDevice();
            if (device == null ||
                mRemoteHeadsets.get(device).mState != BluetoothProfile.STATE_CONNECTING) {
                return;  // stale events
            }

            switch (msg.what) {
            case RFCOMM_ERROR:
                if (DBG) log("Rfcomm error");
                mConnectThread = null;
                setState(device, BluetoothProfile.STATE_DISCONNECTED);
                break;
            case RFCOMM_CONNECTED:
                if (DBG) log("Rfcomm connected");
                mConnectThread = null;
                HeadsetBase headset = (HeadsetBase)msg.obj;
                setState(device, BluetoothProfile.STATE_CONNECTED);

                mRemoteHeadsets.get(device).mHeadset = headset;
                mBtHandsfree.connectHeadset(headset, mRemoteHeadsets.get(device).mHeadsetType);
                break;
            }
        }
    };

    /**
     * Receives events from a connected RFCOMM socket back in the main thread.
     */
    private final Handler mConnectedStatusHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case HeadsetBase.RFCOMM_DISCONNECTED:
                mBtHandsfree.resetAtState();
                mBtHandsfree.setVirtualCallInProgress(false);
                BluetoothDevice device = getCurrentDevice();
                if (device != null) {
                    setState(device, BluetoothProfile.STATE_DISCONNECTED);
                }
                break;
            }
        }
    };

    private synchronized void setState(BluetoothDevice device, int state) {
        int prevState = mRemoteHeadsets.get(device).mState;
        if (state != prevState) {
            if (DBG) log("Device: " + device +
                " Headset  state" + prevState + " -> " + state);
            if (prevState == BluetoothProfile.STATE_CONNECTED) {
                // Headset is disconnecting, stop the parser.
                mBtHandsfree.disconnectHeadset();
            }
            Intent intent = new Intent(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
            intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, prevState);
            intent.putExtra(BluetoothProfile.EXTRA_STATE, state);
            intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
            if (state == BluetoothProfile.STATE_DISCONNECTED) {
                mRemoteHeadsets.get(device).mHeadset = null;
                mRemoteHeadsets.get(device).mHeadsetType = BluetoothHandsfree.TYPE_UNKNOWN;
            }

            mRemoteHeadsets.get(device).mState = state;

            sendBroadcast(intent, BLUETOOTH_PERM);
            if (state == BluetoothHeadset.STATE_CONNECTED) {
                // Set the priority to AUTO_CONNECT
                setPriority(device, BluetoothHeadset.PRIORITY_AUTO_CONNECT);
                adjustOtherHeadsetPriorities(device);
            }
            try {
                mBluetoothService.sendConnectionStateChange(device, BluetoothProfile.HEADSET,
                                                            state, prevState);
            } catch (RemoteException e) {
                Log.e(TAG, "sendConnectionStateChange: exception");
            }
       }
    }

    private void adjustOtherHeadsetPriorities(BluetoothDevice connectedDevice) {
       for (BluetoothDevice device : mAdapter.getBondedDevices()) {
          if (getPriority(device) >= BluetoothHeadset.PRIORITY_AUTO_CONNECT &&
              !device.equals(connectedDevice)) {
              setPriority(device, BluetoothHeadset.PRIORITY_ON);
          }
       }
    }

    private void setPriority(BluetoothDevice device, int priority) {
        try {
            mBinder.setPriority(device, priority);
        } catch (RemoteException e) {
            Log.e(TAG, "Error while setting priority for: " + device);
        }
    }

    private int getPriority(BluetoothDevice device) {
        try {
            return mBinder.getPriority(device);
        } catch (RemoteException e) {
            Log.e(TAG, "Error while getting priority for: " + device);
        }
        return BluetoothProfile.PRIORITY_UNDEFINED;
    }

    private synchronized void getSdpRecordsAndConnect(BluetoothDevice device) {
        if (!device.equals(getCurrentDevice())) {
            // stale
            return;
        }

        // Check if incoming connection has already connected.
        if (mRemoteHeadsets.get(device).mState == BluetoothProfile.STATE_CONNECTED) {
            return;
        }

        ParcelUuid[] uuids = device.getUuids();
        ParcelUuid[] localUuids = mAdapter.getUuids();
        int type = BluetoothHandsfree.TYPE_UNKNOWN;
        if (uuids != null) {
            if (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.Handsfree) &&
                BluetoothUuid.isUuidPresent(localUuids, BluetoothUuid.Handsfree_AG)) {
                log("SDP UUID: TYPE_HANDSFREE");
                type = BluetoothHandsfree.TYPE_HANDSFREE;
                mRemoteHeadsets.get(device).mHeadsetType = type;
                int channel = device.getServiceChannel(BluetoothUuid.Handsfree);
                mConnectThread = new RfcommConnectThread(device, channel, type);
                if (mAdapter.isDiscovering()) {
                    mAdapter.cancelDiscovery();
                }
                mConnectThread.start();
                if (getPriority(device) < BluetoothHeadset.PRIORITY_AUTO_CONNECT) {
                    setPriority(device, BluetoothHeadset.PRIORITY_AUTO_CONNECT);
                }
                return;
            } else if (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.HSP) &&
                BluetoothUuid.isUuidPresent(localUuids, BluetoothUuid.HSP_AG)) {
                log("SDP UUID: TYPE_HEADSET");
                type = BluetoothHandsfree.TYPE_HEADSET;
                mRemoteHeadsets.get(device).mHeadsetType = type;
                int channel = device.getServiceChannel(BluetoothUuid.HSP);
                mConnectThread = new RfcommConnectThread(device, channel, type);
                if (mAdapter.isDiscovering()) {
                    mAdapter.cancelDiscovery();
                }
                mConnectThread.start();
                if (getPriority(device) < BluetoothHeadset.PRIORITY_AUTO_CONNECT) {
                    setPriority(device, BluetoothHeadset.PRIORITY_AUTO_CONNECT);
                }
                return;
            }
        }
        log("SDP UUID: TYPE_UNKNOWN");
        mRemoteHeadsets.get(device).mHeadsetType = type;
        setState(device, BluetoothProfile.STATE_DISCONNECTED);
        return;
    }

    /**
     * Handlers for incoming service calls
     */
    private final IBluetoothHeadset.Stub mBinder = new IBluetoothHeadset.Stub() {
        public int getConnectionState(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            BluetoothRemoteHeadset headset = mRemoteHeadsets.get(device);
            if (headset == null) {
                return BluetoothProfile.STATE_DISCONNECTED;
            }
            return headset.mState;
        }

        public List<BluetoothDevice> getConnectedDevices() {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            return getDevicesMatchingConnectionStates(
                new int[] {BluetoothProfile.STATE_CONNECTED});
        }

        public boolean connect(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
                                           "Need BLUETOOTH_ADMIN permission");
            synchronized (BluetoothHeadsetService.this) {
                BluetoothDevice currDevice = getCurrentDevice();

                if (currDevice == device ||
                    getPriority(device) == BluetoothProfile.PRIORITY_OFF) {
                    return false;
                }
                if (currDevice != null) {
                    disconnect(currDevice);
                }
                try {
                    return mBluetoothService.connectHeadset(device.getAddress());
                } catch (RemoteException e) {
                    Log.e(TAG, "connectHeadset");
                    return false;
                }
            }
        }

        public boolean disconnect(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
                                           "Need BLUETOOTH_ADMIN permission");
            synchronized (BluetoothHeadsetService.this) {
                BluetoothRemoteHeadset headset = mRemoteHeadsets.get(device);
                if (headset == null ||
                    headset.mState == BluetoothProfile.STATE_DISCONNECTED ||
                    headset.mState == BluetoothProfile.STATE_DISCONNECTING) {
                    return false;
                }
                try {
                    return mBluetoothService.disconnectHeadset(device.getAddress());
                } catch (RemoteException e) {
                    Log.e(TAG, "disconnectHeadset");
                    return false;
                }
            }
        }

        public synchronized boolean isAudioConnected(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            if (device.equals(mAudioConnectedDevice)) return true;
            return false;
        }

        public synchronized List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            List<BluetoothDevice> headsets = new ArrayList<BluetoothDevice>();
            for (BluetoothDevice device: mRemoteHeadsets.keySet()) {
                int headsetState = getConnectionState(device);
                for (int state : states) {
                    if (state == headsetState) {
                        headsets.add(device);
                        break;
                    }
                }
            }
            return headsets;
        }

        public boolean startVoiceRecognition(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            synchronized (BluetoothHeadsetService.this) {
                if (device == null ||
                    mRemoteHeadsets.get(device) == null ||
                    mRemoteHeadsets.get(device).mState != BluetoothProfile.STATE_CONNECTED) {
                    return false;
                }
                return mBtHandsfree.startVoiceRecognition();
            }
        }

        public boolean stopVoiceRecognition(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            synchronized (BluetoothHeadsetService.this) {
                if (device == null ||
                    mRemoteHeadsets.get(device) == null ||
                    mRemoteHeadsets.get(device).mState != BluetoothProfile.STATE_CONNECTED) {
                    return false;
                }

                return mBtHandsfree.stopVoiceRecognition();
            }
        }

        public int getBatteryUsageHint(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");

            return HeadsetBase.getAtInputCount();
        }

        public int getPriority(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
                "Need BLUETOOTH_ADMIN permission");
            synchronized (BluetoothHeadsetService.this) {
                int priority = Settings.Secure.getInt(getContentResolver(),
                        Settings.Secure.getBluetoothHeadsetPriorityKey(device.getAddress()),
                        BluetoothProfile.PRIORITY_UNDEFINED);
                return priority;
            }
        }

        public boolean setPriority(BluetoothDevice device, int priority) {
            enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
                "Need BLUETOOTH_ADMIN permission");
            synchronized (BluetoothHeadsetService.this) {
                Settings.Secure.putInt(getContentResolver(),
                        Settings.Secure.getBluetoothHeadsetPriorityKey(device.getAddress()),
                        priority);
                if (DBG) log("Saved priority " + device + " = " + priority);
                return true;
            }
        }

        public boolean createIncomingConnect(BluetoothDevice device) {
            synchronized (BluetoothHeadsetService.this) {
                HeadsetBase headset;
                setState(device, BluetoothProfile.STATE_CONNECTING);

                IncomingConnectionInfo info = mRemoteHeadsets.get(device).mIncomingInfo;
                headset = new HeadsetBase(mPowerManager, mAdapter,
                                          device,
                                          info.mSocketFd, info.mRfcommChan,
                                          mConnectedStatusHandler);

                mRemoteHeadsets.get(device).mHeadset = headset;

                mConnectingStatusHandler.obtainMessage(RFCOMM_CONNECTED, headset).sendToTarget();
                return true;
            }
        }

        public boolean startScoUsingVirtualVoiceCall(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            synchronized (BluetoothHeadsetService.this) {
                if (device == null ||
                    mRemoteHeadsets.get(device) == null ||
                    mRemoteHeadsets.get(device).mState != BluetoothProfile.STATE_CONNECTED ||
                    getAudioState(device) != BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
                    return false;
                }
                return mBtHandsfree.initiateScoUsingVirtualVoiceCall();
            }
        }

        public boolean stopScoUsingVirtualVoiceCall(BluetoothDevice device) {
            enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
            synchronized (BluetoothHeadsetService.this) {
                if (device == null ||
                    mRemoteHeadsets.get(device) == null ||
                    mRemoteHeadsets.get(device).mState != BluetoothProfile.STATE_CONNECTED ||
                    getAudioState(device) == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
                    return false;
                }
                return mBtHandsfree.terminateScoUsingVirtualVoiceCall();
            }
        }

        public boolean rejectIncomingConnect(BluetoothDevice device) {
            synchronized (BluetoothHeadsetService.this) {
                BluetoothRemoteHeadset headset = mRemoteHeadsets.get(device);
                if (headset != null) {
                    IncomingConnectionInfo info = headset.mIncomingInfo;
                    rejectIncomingConnection(info);
                } else {
                    Log.e(TAG, "Error no record of remote headset");
                }
                return true;
            }
        }

        public boolean acceptIncomingConnect(BluetoothDevice device) {
            synchronized (BluetoothHeadsetService.this) {
                HeadsetBase headset;
                BluetoothRemoteHeadset cachedHeadset = mRemoteHeadsets.get(device);
                if (cachedHeadset == null) {
                    Log.e(TAG, "Cached Headset is Null in acceptIncomingConnect");
                    return false;
                }
                IncomingConnectionInfo info = cachedHeadset.mIncomingInfo;
                headset = new HeadsetBase(mPowerManager, mAdapter,
                                          device,
                                          info.mSocketFd, info.mRfcommChan,
                                          mConnectedStatusHandler);

                setState(device, BluetoothProfile.STATE_CONNECTED);

                cachedHeadset.mHeadset = headset;
                mBtHandsfree.connectHeadset(headset, cachedHeadset.mHeadsetType);

                if (DBG) log("Successfully used incoming connection");
                return true;
            }
        }

        public  boolean cancelConnectThread() {
            synchronized (BluetoothHeadsetService.this) {
                if (mConnectThread != null) {
                    // cancel the connection thread
                    mConnectThread.interrupt();
                    try {
                        mConnectThread.join();
                    } catch (InterruptedException e) {
                        Log.e(TAG, "Connection cancelled twice?", e);
                    }
                    mConnectThread = null;
                }
                return true;
            }
        }

        public boolean connectHeadsetInternal(BluetoothDevice device) {
            synchronized (BluetoothHeadsetService.this) {
                BluetoothDevice currDevice = getCurrentDevice();
                if (currDevice == null) {
                    BluetoothRemoteHeadset headset = new BluetoothRemoteHeadset();
                    mRemoteHeadsets.put(device, headset);

                    setState(device, BluetoothProfile.STATE_CONNECTING);
                    if (device.getUuids() == null) {
                        // We might not have got the UUID change notification from
                        // Bluez yet, if we have just paired. Try after 1.5 secs.
                        Message msg = new Message();
                        msg.what = CONNECT_HEADSET_DELAYED;
                        msg.obj = device;
                        mHandler.sendMessageDelayed(msg, 1500);
                    } else {
                        getSdpRecordsAndConnect(device);
                    }
                    return true;
                } else {
                      Log.w(TAG, "connectHeadset(" + device + "): failed: already in state " +
                            mRemoteHeadsets.get(currDevice).mState +
                            " with headset " + currDevice);
                }
                return false;
            }
        }

        public boolean disconnectHeadsetInternal(BluetoothDevice device) {
            synchronized (BluetoothHeadsetService.this) {
                BluetoothRemoteHeadset remoteHeadset = mRemoteHeadsets.get(device);
                if (remoteHeadset == null) return false;

                if (remoteHeadset.mState == BluetoothProfile.STATE_CONNECTED) {
                    // Send a dummy battery level message to force headset
                    // out of sniff mode so that it will immediately notice
                    // the disconnection. We are currently sending it for
                    // handsfree only.
                    // TODO: Call hci_conn_enter_active_mode() from
                    // rfcomm_send_disc() in the kernel instead.
                    // See http://b/1716887
                    setState(device, BluetoothProfile.STATE_DISCONNECTING);

                    HeadsetBase headset = remoteHeadset.mHeadset;
                    if (remoteHeadset.mHeadsetType == BluetoothHandsfree.TYPE_HANDSFREE) {
                        headset.sendURC("+CIEV: 7,3");
                    }

                    if (headset != null) {
                        headset.disconnect();
                        headset = null;
                    }
                    setState(device, BluetoothProfile.STATE_DISCONNECTED);
                    return true;
                } else if (remoteHeadset.mState == BluetoothProfile.STATE_CONNECTING) {
                    // The state machine would have canceled the connect thread.
                    // Just set the state here.
                    setState(device, BluetoothProfile.STATE_DISCONNECTED);
                    return true;
                }
                return false;
            }
        }

        public boolean setAudioState(BluetoothDevice device, int state) {
            // mRemoteHeadsets handles put/get concurrency by itself
            int prevState = mRemoteHeadsets.get(device).mAudioState;
            mRemoteHeadsets.get(device).mAudioState = state;
            if (state == BluetoothHeadset.STATE_AUDIO_CONNECTED) {
                mAudioConnectedDevice = device;
            } else if (state == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
                mAudioConnectedDevice = null;
            }
            Intent intent = new Intent(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
            intent.putExtra(BluetoothHeadset.EXTRA_STATE, state);
            intent.putExtra(BluetoothHeadset.EXTRA_PREVIOUS_STATE, prevState);
            intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
            sendBroadcast(intent, android.Manifest.permission.BLUETOOTH);
            if (DBG) log("AudioStateIntent: " + device + " State: " + state
                         + " PrevState: " + prevState);
            return true;
        }

        public int getAudioState(BluetoothDevice device) {
            // mRemoteHeadsets handles put/get concurrency by itself
            BluetoothRemoteHeadset headset = mRemoteHeadsets.get(device);
            if (headset == null) return BluetoothHeadset.STATE_AUDIO_DISCONNECTED;

            return headset.mAudioState;
       }
    };

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (DBG) log("Stopping BluetoothHeadsetService");
        unregisterReceiver(mBluetoothReceiver);
        mBtHandsfree.onBluetoothDisabled();
        mAg.stop();
        sHasStarted = false;
        BluetoothDevice device = getCurrentDevice();
        if (device != null) {
            setState(device, BluetoothProfile.STATE_DISCONNECTED);
        }
    }



    private static void log(String msg) {
        Log.d(TAG, msg);
    }
}