android/car/BluetoothDevicesInfo.java

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

import android.annotation.Nullable;
import android.bluetooth.BluetoothDevice;
import android.car.CarBluetoothManager;
import android.util.Log;

import java.util.List;
import java.util.ArrayList;

import android.bluetooth.BluetoothProfile;

import com.android.internal.annotations.VisibleForTesting;

/**
 * BluetoothDevicesInfo contains all the information pertinent to connection on a Bluetooth Profile.
 * It holds
 * 1. a list of devices {@link #mDeviceInfoList} that has previously paired and connected on this
 * profile.
 * 2. a Connection Info object {@link #mConnectionInfo} that has following book keeping information:
 * a) profile
 * b) Current Connection status
 * c) If there are any devices available for connection
 * d) Index of the Device list that a connection is being tried upon currently.
 * e) Number of devices that have been previously paired and connected on this profile.
 * f) How many retry attempts have been made
 *
 * This is used by the {@link BluetoothDeviceConnectionPolicy} to find the device to attempt
 * a connection on for a profile.  The policy also updates this object with the connection
 * results.
 */
public class BluetoothDevicesInfo {

    private static final String TAG = "CarBluetoothDevicesInfo";
    private static final boolean DBG = Utils.DBG;
    private final int DEVICE_NOT_FOUND = -1;
    private final int DEVICE_PRIORITY_UNDEFINED = -1;
    // The device list and the connection state information together have all the information
    // that is required to know which device(s) to connect to, when we need to connect/
    private List<DeviceInfo> mDeviceInfoList;
    private ConnectionInfo mConnectionInfo;

    /**
     * This class holds on to information regarding this bluetooth profile's connection state.
     */
    private class ConnectionInfo {
        // which bluetooth profile this Device Info is for
        private int mProfile;
        // are there any devices available to connect. It is false either if
        // 1. no device has been paired to connect on this profile
        // 2. all paired devices have been tried to connect to, but unsuccessful (not in range etc)
        private boolean mDeviceAvailableToConnect;
        // index of device in the mDeviceInfoList that the next connection attempt should be made
        private int mDeviceIndex;
        // Connection Retry counter
        private int mRetryAttempt;
        // Current number of active connections on this profile
        private int mNumActiveConnections;
        // number of concurrent active connections supported.
        private int mNumConnectionsSupported;

        public ConnectionInfo(int profile) {
            // Default the number of concurrent active connections supported to 1.
            this(profile, 1);
        }

        public ConnectionInfo(int profile, int numConnectionsSupported) {
            mProfile = profile;
            mNumConnectionsSupported = numConnectionsSupported;
            initConnectionInfo();
        }

        private void initConnectionInfo() {
            mDeviceAvailableToConnect = true;
            mDeviceIndex = 0;
            mRetryAttempt = 0;
            mNumActiveConnections = 0;
        }
    }

    /**
     * This class holds information about the list of devices that can connect (have connected in
     * the past) and their current connection state.
     */
    public class DeviceInfo {

        private BluetoothDevice mBluetoothDevice;
        private int mConnectionState;
        private int mDevicePriority;

        public DeviceInfo(BluetoothDevice device, int state) {
            mBluetoothDevice = device;
            mConnectionState = state;
            mDevicePriority = DEVICE_PRIORITY_UNDEFINED;
        }

        public void setConnectionState(int state) {
            mConnectionState = state;
        }

        public int getConnectionState() {
            return mConnectionState;
        }

        public BluetoothDevice getBluetoothDevice() {
            return mBluetoothDevice;
        }

        public void setBluetoothDevicePriority(int priority) {
            mDevicePriority = priority;
        }

        public int getBluetoothDevicePriority() {
            return mDevicePriority;
        }
    }

    public BluetoothDevicesInfo(int profile) {
        mDeviceInfoList = new ArrayList<>();
        mConnectionInfo = new ConnectionInfo(profile);
    }

    public BluetoothDevicesInfo(int profile, int numConnectionsSupported) {
        mDeviceInfoList = new ArrayList<>();
        mConnectionInfo = new ConnectionInfo(profile, numConnectionsSupported);
    }

    /**
     * Set the priority of the device with the given priority level
     *
     * @param deviceToTag - BluetoothDevice to set the priority for
     * @param priority    - Priority to set
     */

    public void setBluetoothDevicePriorityLocked(BluetoothDevice deviceToTag, int priority) {
        /*if (priority >= mConnectionInfo.mNumConnectionsSupported) {
            if (DBG) {
                Log.d(TAG, "Priority cannot exceed number of connections supported");
            }
            return;
        }*/
        // if there is a device already set to that priority, unseat that device
        BluetoothDevice oldDeviceWithPriority = getBluetoothDeviceForPriorityLocked(priority);
        if (oldDeviceWithPriority != null) {
            if (DBG) {
                Log.d(TAG, "Unsetting priority " + priority + " on " + oldDeviceWithPriority);
            }
            removeBluetoothDevicePriorityLocked(oldDeviceWithPriority);
        }
        // Tag the new device with the given priority
        DeviceInfo newDeviceInfoWithPriority = findDeviceInfoInListLocked(deviceToTag);
        if (newDeviceInfoWithPriority == null) {
            if (DBG) {
                Log.d(TAG, "setBluetoothDevicePriorityLocked():Unknown and unpaired device");
            }
            return;
        }
        if (DBG) {
            Log.d(TAG, "Setting priority " + priority + " to "
                    + newDeviceInfoWithPriority.mBluetoothDevice);
        }
        newDeviceInfoWithPriority.setBluetoothDevicePriority(priority);
        // Update the position of the device in the device Queue
        moveDeviceToPrioritySlotsLocked(newDeviceInfoWithPriority, priority);
    }

    /**
     * Clear the priority of the given device.
     *
     * @param deviceToUntag - BluetoothDevice to untag
     */
    public void removeBluetoothDevicePriorityLocked(BluetoothDevice deviceToUntag) {
        DeviceInfo deviceInfo = findDeviceInfoInListLocked(deviceToUntag);
        deviceInfo.setBluetoothDevicePriority(DEVICE_PRIORITY_UNDEFINED);
    }

    /**
     * Returns the number of devices that have been tagged as priority devices.
     * If there is a device that is tagged as a Secondary device, then the number of tagged devices
     * is 2, even if there is no primary device.
     *
     * @return - Number of Tagged devices Ex: Only Primary - 1, Primary and/or Secondary - 2
     */
    public int getNumberOfTaggedDevicesLocked() {
        int numberOfTaggedDevices = 0;
        if (getBluetoothDeviceForPriorityLocked(
                CarBluetoothManager.BLUETOOTH_DEVICE_CONNECTION_PRIORITY_1) != null) {
            return CarBluetoothManager.BLUETOOTH_DEVICE_CONNECTION_PRIORITY_1 + 1;
        } else if (getBluetoothDeviceForPriorityLocked(
                CarBluetoothManager.BLUETOOTH_DEVICE_CONNECTION_PRIORITY_0) != null) {
            return CarBluetoothManager.BLUETOOTH_DEVICE_CONNECTION_PRIORITY_0 + 1;
        }
        return numberOfTaggedDevices;
    }

    /**
     * Returns the device that has the passed priority
     */
    public BluetoothDevice getBluetoothDeviceForPriorityLocked(int priority) {
        BluetoothDevice device = null;
        for (DeviceInfo deviceInfo : mDeviceInfoList) {
            if (deviceInfo.mDevicePriority == priority) {
                return deviceInfo.mBluetoothDevice;
            }
        }
        return device;
    }

    /**
     * Get the position of the given device in the list of connectable devices for this profile.
     *
     * @param device - {@link BluetoothDevice}
     * @return postion in the {@link #mDeviceInfoList}, DEVICE_NOT_FOUND if the device is not in the
     * list.
     */
    private int getPositionInListLocked(BluetoothDevice device) {
        int index = DEVICE_NOT_FOUND;
        if (mDeviceInfoList != null) {
            int i = 0;
            for (DeviceInfo devInfo : mDeviceInfoList) {
                if (devInfo.mBluetoothDevice.getAddress().equals(device.getAddress())) {
                    index = i;
                    break;
                }
                i++;
            }
        }
        return index;
    }

    /**
     * Check if the given device is in the {@link #mDeviceInfoList}
     *
     * @param device - {@link BluetoothDevice} to look for
     * @return true if found, false if not found
     */
    boolean checkDeviceInListLocked(BluetoothDevice device) {
        boolean isPresent = false;
        if (device == null) {
            return isPresent;
        }
        for (DeviceInfo devInfo : mDeviceInfoList) {
            if (devInfo.mBluetoothDevice.getAddress().equals(device.getAddress())) {
                isPresent = true;
                break;
            }
        }
        return isPresent;
    }

    /**
     * Iterate through the {@link BluetoothDevicesInfo#mDeviceInfoList} and find the
     * {@link DeviceInfo} with the given {@link BluetoothDevice}
     *
     * @param device - {@link BluetoothDevice} to look for
     * @return - {@link DeviceInfo} that contains the passed {@link BluetoothDevice}
     */
    private DeviceInfo findDeviceInfoInListLocked(@Nullable BluetoothDevice device) {
        if (device == null) {
            return null;
        }
        for (DeviceInfo devInfo : mDeviceInfoList) {
            if (devInfo.mBluetoothDevice.getAddress().equals(device.getAddress())) {
                return devInfo;
            }
        }
        return null;
    }

    /**
     * Get the current list of connectable devices for this profile.
     *
     * @return Device list for this profile.
     */
    public List<BluetoothDevice> getDeviceList() {
        List<BluetoothDevice> bluetoothDeviceList = new ArrayList<>();
        for (DeviceInfo deviceInfo : mDeviceInfoList) {
            bluetoothDeviceList.add(deviceInfo.mBluetoothDevice);
        }
        return bluetoothDeviceList;
    }

    public List<DeviceInfo> getDeviceInfoList() {
        return mDeviceInfoList;
    }

    public void setNumberOfConnectionsSupported(int num) {
        mConnectionInfo.mNumConnectionsSupported = num;
    }

    public int getNumberOfConnectionsSupported() {
        return mConnectionInfo.mNumConnectionsSupported;
    }

    /**
     * Add a device to the device list.  Used during pairing.
     *
     * @param dev - device to add for further connection attempts on this profile.
     */
    public void addDeviceLocked(BluetoothDevice dev) {
        // Check if this device is already in the device list
        if (checkDeviceInListLocked(dev)) {
            if (DBG) {
                Log.d(TAG, "Device " + dev + " already in list.  Not adding");
            }
            return;
        }
        // Add new device and set the connection state to DISCONNECTED.
        if (mDeviceInfoList != null) {
            DeviceInfo deviceInfo = new DeviceInfo(dev, BluetoothProfile.STATE_DISCONNECTED);
            mDeviceInfoList.add(deviceInfo);
        } else {
            if (DBG) {
                Log.d(TAG, "Device List is null");
            }
        }
    }

    /**
     * Set the connection state for this device to the given connection state.
     *
     * @param device - Bluetooth device to update the state for
     * @param state  - the Connection state to set.
     */
    public void setConnectionStateLocked(BluetoothDevice device, int state) {
        if (device == null) {
            Log.e(TAG, "setConnectionStateLocked() device null");
            return;
        }
        for (DeviceInfo devInfo : mDeviceInfoList) {
            BluetoothDevice dev = devInfo.mBluetoothDevice;
            if (dev == null) {
                continue;
            }
            if (dev.getAddress().equals(device.getAddress())) {
                if (DBG) {
                    Log.d(TAG, "Setting " + dev + " state to " + state);
                }
                devInfo.setConnectionState(state);
                break;
            }
        }
    }

    /**
     * Returns the current connection state for the given device
     *
     * @param device - device to get the bluetooth connection state for
     * @return - Connection State.  If passed device is null, returns DEVICE_NOT_FOUND.
     */
    public int getCurrentConnectionStateLocked(BluetoothDevice device) {
        int state = DEVICE_NOT_FOUND;
        if (device == null) {
            Log.e(TAG, "getCurrentConnectionStateLocked() device null");
            return state;
        }

        for (DeviceInfo devInfo : mDeviceInfoList) {
            BluetoothDevice dev = devInfo.mBluetoothDevice;
            if (dev == null) {
                continue;
            }
            if (dev.getAddress().equals(device.getAddress())) {
                state = devInfo.getConnectionState();
                break;
            }
        }
        return state;
    }

    /**
     * Returns the device that is currently in the middle of a connection attempt.
     *
     * @return BluetoothDevice that is connecting, null if no device is connecting
     */
    public BluetoothDevice getConnectingDeviceLocked() {
        for (DeviceInfo devInfo : mDeviceInfoList) {
            if (devInfo.getConnectionState() == BluetoothProfile.STATE_CONNECTING) {
                return devInfo.getBluetoothDevice();
            }
        }
        return null;
    }

    /**
     * Returns a list of connected devices for this profile.
     *
     * @return - List of connected devices
     */
    public List<BluetoothDevice> getConnectedDevicesLocked() {
        List<BluetoothDevice> devices = new ArrayList<>();
        for (DeviceInfo devInfo : mDeviceInfoList) {
            if (devInfo.getConnectionState() == BluetoothProfile.STATE_CONNECTED) {
                devices.add(devInfo.getBluetoothDevice());
            }
        }
        if (DBG) {
            Log.d(TAG, "Active Connections: " + getNumberOfActiveConnectionsLocked());
            Log.d(TAG, "Connected devices Size: " + devices.size());
        }
        return devices;
    }

    /**
     * Remove a device from the list.  Used when a device is unpaired
     *
     * @param dev - device to remove from the list.
     */
    public void removeDeviceLocked(BluetoothDevice dev) {
        if (mDeviceInfoList != null) {
            DeviceInfo devInfo = findDeviceInfoInListLocked(dev);
            if (devInfo != null) {
                mDeviceInfoList.remove(devInfo);
                // If the device was connected when it was unpaired, we wouldn't have received the
                // Profile disconnected intents.  Hence check if the device was connected and if it
                // was, then decrement the number of active connections.
                if (devInfo.getConnectionState() == BluetoothProfile.STATE_CONNECTED) {
                    mConnectionInfo.mNumActiveConnections--;
                }
            }
        } else {
            if (DBG) {
                Log.d(TAG, "Device List is null");
            }
        }
        Log.d(TAG, "Device List size: " + mDeviceInfoList.size());
    }

    public void clearDeviceListLocked() {
        if (mDeviceInfoList != null) {
            mDeviceInfoList.clear();
        }
    }

    /**
     * Returns the next device to attempt a connection on for this profile.
     *
     * @return {@link BluetoothDevice} that is next in the Queue. null if the Queue has been
     * exhausted
     * (no known device nearby)
     */
    public BluetoothDevice getNextDeviceInQueueLocked() {
        BluetoothDevice device = null;
        int numberOfPairedDevices = getNumberOfPairedDevicesLocked();
        // iterate till we find a disconnected device
        while (mConnectionInfo.mDeviceIndex < numberOfPairedDevices &&
                mDeviceInfoList.get(mConnectionInfo.mDeviceIndex).getConnectionState()
                        != BluetoothProfile.STATE_DISCONNECTED) {
            mConnectionInfo.mDeviceIndex++;
        }

        if (mConnectionInfo.mDeviceIndex >= numberOfPairedDevices) {
            if (DBG) {
                Log.d(TAG,
                        "No device available for profile "
                                + mConnectionInfo.mProfile + " "
                                + mConnectionInfo.mDeviceIndex + "/"
                                + numberOfPairedDevices);
            }
            // mDeviceIndex is the index of the device in the mDeviceInfoList, that the next
            // connection attempt would be made on.  It is moved ahead on
            // updateConnectionStatusLocked() so it always holds the index of the next device to
            // connect to.  But here, when we get the next device to connect to, if we see that
            // the index is greater than the number of devices in the list, then we move the index
            // back to the first device in the list and don't return anything.
            // The reason why this is reset is to imply that connection attempts on this profile has
            // been exhausted and if you want to retry connecting on this profile, we will start
            // from the first device.
            // The reason to reset here rather than in updateConnectionStatusLocked() is to make
            // sure we have the latest view of the numberOfPairedDevices before we say we have
            // exhausted the list.
            mConnectionInfo.mDeviceIndex = 0;
            return null;
        }

        device = mDeviceInfoList.get(mConnectionInfo.mDeviceIndex).mBluetoothDevice;
        if (DBG) {
            Log.d(TAG, "Getting device " + mConnectionInfo.mDeviceIndex + " from list: "
                    + device);
        }
        return device;
    }

    /**
     * Update the connection Status for connection attempts made on this profile.
     * If the attempt was successful, mark it and keep track of the device that was connected.
     * If unsuccessful, check if we can retry on the same device. If no more retry attempts,
     * move to the next device in the Queue.
     *
     * @param device  - {@link BluetoothDevice} that connected.
     * @param success - connection result
     * @param retry   - If Retries are available for the same device.
     */
    public void updateConnectionStatusLocked(BluetoothDevice device, boolean success,
            boolean retry) {
        if (device == null) {
            Log.w(TAG, "Updating Status with null BluetoothDevice");
            return;
        }
        if (success) {
            if (DBG) {
                Log.d(TAG, mConnectionInfo.mProfile + " connected to " + device);
            }
            // Get the position of this device in the device list maintained for this profile.
            int positionInQ = getPositionInListLocked(device);
            if (DBG) {
                Log.d(TAG, "Position of " + device + " in Q: " + positionInQ);
            }
            // If the device that connected is not in the list, it could be because it is being
            // paired and getting added to the device list for this profile for the first time.
            if (positionInQ == DEVICE_NOT_FOUND) {
                Log.d(TAG, "Connected device not in Q: " + device);
                addDeviceLocked(device);
                positionInQ = mDeviceInfoList.size() - 1;
            } else if (positionInQ != mConnectionInfo.mDeviceIndex) {
            /*
                 This will happen if auto-connect requests to connect on a device from its list,
                 but the device that connected was different.  Maybe there was another requestor
                 and the Bluetooth services chose to honor the other request.  What we do here,
                 is to make sure we note which device connected and not assume that the device
                 that connected is the device we requested.  The ultimate goal of the policy is
                 to remember which devices connected on which profile (regardless of the origin
                 of the connection request) so it knows which device to connect the next time.
            */
                if (DBG) {
                    Log.d(TAG, "Different device connected: " + device + " CurrIndex: "
                            + mConnectionInfo.mDeviceIndex);
                }
            }

            // At this point positionInQ reflects where in the list the device that connected is,
            // i.e, its index.  Move the device to the front of the device list, since the policy is
            // to try to connect to the last connected device first.  Hence by moving the device
            // to the front of the list, the next time auto connect triggers, this will be the
            // device that the policy will try to connect on for this profile.
            if (positionInQ != 0) {
                moveDeviceToQueueFrontLocked(positionInQ);
                // reset the device Index back to the first in the Queue
                //mConnectionInfo.mDeviceIndex = 0;
            }

            if (getCurrentConnectionStateLocked(device) != BluetoothProfile.STATE_CONNECTED) {
                mConnectionInfo.mNumActiveConnections++;
                if (DBG) {
                    Log.d(TAG,
                            "Incrementing Active Connections "
                                    + mConnectionInfo.mNumActiveConnections);
                }
            }
            setConnectionStateLocked(device, BluetoothProfile.STATE_CONNECTED);
            // Reset the retry count
            mConnectionInfo.mRetryAttempt = 0;

            if (getConnectingDeviceLocked() == null) {
                mConnectionInfo.mDeviceIndex++;
            }
            if (DBG) {
                Log.d(TAG,
                        "Profile: " + mConnectionInfo.mProfile + " Number of Active Connections: "
                                + mConnectionInfo.mNumActiveConnections);
            }
        } else {
            // if no more retries, move to the next device
            if (DBG) {
                Log.d(TAG, "Connection fail or Disconnected");
            }
            // Decrement Number of Active Connections only if the device is already connected.
            if (getCurrentConnectionStateLocked(device) == BluetoothProfile.STATE_CONNECTED) {
                mConnectionInfo.mNumActiveConnections--;
                if (DBG) {
                    Log.d(TAG, "Decrementing Active Connections "
                            + mConnectionInfo.mNumActiveConnections);
                }
            }
            setConnectionStateLocked(device, BluetoothProfile.STATE_DISCONNECTED);

            // Update the mDeviceIndex only when there is no other device currently in the middle
            // of a connection attempt.  This is to safeguard against disconnect intents coming in
            // for devices other than the one that the policy is currently trying to connect.
            if (getConnectingDeviceLocked() == null) {
                if (!retry) {
                    mConnectionInfo.mDeviceIndex++;
                    if (DBG) {
                        Log.d(TAG, "Moving to device: " + mConnectionInfo.mDeviceIndex);
                    }
                    // Reset the retry count
                    mConnectionInfo.mRetryAttempt = 0;
                } else {
                    if (DBG) {
                        Log.d(TAG, "Staying with the same device - retrying: "
                                + mConnectionInfo.mDeviceIndex);
                    }
                }
            } else {
                BluetoothDevice connectingDevice = getConnectingDeviceLocked();
                if (connectingDevice != null) {
                    if (DBG) {
                        Log.d(TAG, "Not moving to next device. " + connectingDevice
                                + " still connecting");
                    }
                } else {
                    Log.e(TAG, "Unexpected. Status = connecting, but connecting device = null");
                }
            }
        }
    }

    /**
     * Move the given device to its priority slot
     *
     * @param deviceInfo - DeviceInfo to move
     * @param priority   - Priority of the device in the list
     */
    private void moveDeviceToPrioritySlotsLocked(DeviceInfo deviceInfo, int priority) {
        if (DBG) {
            Log.d(TAG, "Moving " + deviceInfo.mBluetoothDevice + " to " + priority);
        }
        mDeviceInfoList.remove(deviceInfo);
        mDeviceInfoList.add(priority, deviceInfo);
    }

    /**
     * Move the item in the given position to the front of the queue and push the rest down.
     *
     * @param position - current position of the device that it is moving from
     */
    private void moveDeviceToQueueFrontLocked(int position) {
        int topOfList = getNumberOfTaggedDevicesLocked();
        // If the device is a primary or secondary, its position is fixed.
        if (position <= topOfList) {
            return;
        }
        DeviceInfo deviceInfo = mDeviceInfoList.get(position);
        if (deviceInfo.mBluetoothDevice == null) {
            if (DBG) {
                Log.d(TAG, "Unexpected: deviceToMove is null");
            }
            return;
        }
        mDeviceInfoList.remove(position);
        // Top of the list to which a device can be moved depends on the number of tagged devices
        // If there is a dedicated Primary device, then the newly connected device can only be moved
        // to the second position, since the primary device always occupies the first position.
        // Hence the topOfList is the first position after the tagged devices.
        mDeviceInfoList.add(topOfList, deviceInfo);
    }

    /**
     * Returns the profile that this devicesInfo is for.
     */
    public Integer getProfileLocked() {
        return mConnectionInfo.mProfile;
    }

    /**
     * Get the number of devices in the {@link #mDeviceInfoList} - paired and previously connected
     * devices
     *
     * @return number of paired devices on this profile.
     */
    public int getNumberOfPairedDevicesLocked() {
        return mDeviceInfoList.size();
    }

    /**
     * Increment the retry count. Called when a connection is made on the profile.
     */
    public void incrementRetryCountLocked() {
        if (mConnectionInfo != null) {
            mConnectionInfo.mRetryAttempt++;
        }
    }

    /**
     * Get the number of times a connection attempt has been tried on a device for this profile.
     *
     * @return number of retry attempts.
     */
    public Integer getRetryCountLocked() {
        return mConnectionInfo.mRetryAttempt;
    }

    /**
     * Set the mDeviceAvailableToConnect with the passed value.
     *
     * @param deviceAvailable - true or false.
     */
    public void setDeviceAvailableToConnectLocked(boolean deviceAvailable) {
        mConnectionInfo.mDeviceAvailableToConnect = deviceAvailable;
    }

    /**
     * Returns if there are any devices available to connect on this profile.
     *
     * @return true if a device is available, false
     * 1. if number of active connections on this profile has been maxed out or
     * 2. if all devices in the list have failed to connect already.
     */
    public boolean isProfileConnectableLocked() {
        if (DBG) {
            Log.d(TAG, "Profile: " + mConnectionInfo.mProfile + " Num of connections: "
                    + mConnectionInfo.mNumActiveConnections + " Conn Supported: "
                    + mConnectionInfo.mNumConnectionsSupported
                    + ", the flag: mDeviceAvailableToConnect = "
                    + mConnectionInfo.mDeviceAvailableToConnect);
        }

        if (mConnectionInfo.mDeviceAvailableToConnect &&
                mConnectionInfo.mNumActiveConnections < mConnectionInfo.mNumConnectionsSupported) {
            return true;
        }

        if (DBG) {
            if (mConnectionInfo.mDeviceAvailableToConnect) {
                Log.d(TAG, "Connected devices for profile " + mConnectionInfo.mProfile);
                for (BluetoothDevice device : getConnectedDevicesLocked()) {
                    Log.d(TAG, device.getAddress());
                }
            }
        }
        return false;
    }

    /**
     * Return the current number of active connections on this profile.
     *
     * @return number of active connections.
     */
    public int getNumberOfActiveConnectionsLocked() {
        return mConnectionInfo.mNumActiveConnections;
    }

    public void resetDeviceIndex() {
        mConnectionInfo.mDeviceIndex = 0;
    }

    /**
     * Reset the connection related bookkeeping information.
     * Called on a BluetoothAdapter Off to clean slate
     */
    public void resetConnectionInfoLocked() {
        mConnectionInfo.mNumActiveConnections = 0;
        mConnectionInfo.mDeviceIndex = 0;
        mConnectionInfo.mRetryAttempt = 0;
        mConnectionInfo.mDeviceAvailableToConnect = true;
        for (DeviceInfo info : mDeviceInfoList) {
            setConnectionStateLocked(info.getBluetoothDevice(),
                    BluetoothProfile.STATE_DISCONNECTED);
        }
    }

    public void resetDeviceListLocked() {
        if (mDeviceInfoList != null) {
            mDeviceInfoList.clear();
        }
        resetConnectionInfoLocked();
    }

    @VisibleForTesting
    String toDebugString() {
        StringBuilder buf = new StringBuilder();
        buf.append("\tmDeviceAvailableToConnect = " + mConnectionInfo.mDeviceAvailableToConnect);
        buf.append("\n\t#Paired Devices = " + getNumberOfPairedDevicesLocked());
        buf.append(", #Active Connections = " + mConnectionInfo.mNumActiveConnections);
        buf.append(", #Connections Supported = " + mConnectionInfo.mNumConnectionsSupported);
        if (mDeviceInfoList != null) {
            int i = 1;
            for (DeviceInfo devInfo : mDeviceInfoList) {
                buf.append("\n\t\tdevice# " + i++ +
                        " = " + Utils.getDeviceDebugInfo(devInfo.getBluetoothDevice()));
                String s;
                switch (devInfo.getConnectionState()) {
                    case BluetoothProfile.STATE_CONNECTING:
                        s = "STATE_CONNECTING";
                        break;
                    case BluetoothProfile.STATE_DISCONNECTED:
                        s = "STATE_DISCONNECTED";
                        break;
                    case BluetoothProfile.STATE_CONNECTED:
                        s = "STATE_CONNECTED";
                        break;
                    default:
                        s = "state_UNKNOWN";
                }
                buf.append(", " + s);
            }
        } else {
            buf.append("\n\tno devices listed");
        }
        buf.append("\n");
        return buf.toString();
    }
}