Merge "Simplify logic for getConnectionStatus in HidDeviceProfile"

import java.util.List;

/**

 * HidProfile handles Bluetooth HID profile.

 * HidDeviceProfile handles Bluetooth HID Device role

 */

public class HidDeviceProfile implements LocalBluetoothProfile {

    private static final String TAG = "HidDeviceProfile";

    private static final int ORDINAL = 18;

    // HID Device Profile is always preferred.

    private static final int PREFERRED_VALUE = -1;

    private static final boolean DEBUG = true;

    private final LocalBluetoothAdapter mLocalAdapter;

    private final CachedBluetoothDeviceManager mDeviceManager;

            implements BluetoothProfile.ServiceListener {

        public void onServiceConnected(int profile, BluetoothProfile proxy) {

            if (DEBUG) {

                Log.d(TAG,"Bluetooth service connected :-)");

            }

            Log.d(TAG, "Bluetooth service connected :-), profile:" + profile);

            mService = (BluetoothHidDevice) proxy;

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

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

        }

        public void onServiceDisconnected(int profile) {

            if (DEBUG) {

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

            }

            Log.d(TAG, "Bluetooth service disconnected, profile:" + profile);

            mIsProfileReady = false;

        }

    }

    @Override

    public boolean connect(BluetoothDevice device) {

        // Don't invoke method in service because settings is not allowed to connect this profile.

        return false;

    }

        if (mService == null) {

            return BluetoothProfile.STATE_DISCONNECTED;

        }

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

        return !deviceList.isEmpty() && deviceList.contains(device)

                ? mService.getConnectionState(device)

                : BluetoothProfile.STATE_DISCONNECTED;

        return mService.getConnectionState(device);

    }

    @Override

    }

    protected void finalize() {

        if (DEBUG) {

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

        }

        if (mService != null) {

            try {

                BluetoothAdapter.getDefaultAdapter().closeProfileProxy(BluetoothProfile.HID_DEVICE,

/*

 * Copyright (C) 2018 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 static com.google.common.truth.Truth.assertThat;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.when;

import static org.mockito.Mockito.verify;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHidDevice;

import android.bluetooth.BluetoothProfile;

import android.content.Context;

import com.android.settingslib.SettingsLibRobolectricTestRunner;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RuntimeEnvironment;

@RunWith(SettingsLibRobolectricTestRunner.class)

public class HidDeviceProfileTest {

    @Mock

    private LocalBluetoothAdapter mAdapter;

    @Mock

    private CachedBluetoothDeviceManager mDeviceManager;

    @Mock

    private LocalBluetoothProfileManager mProfileManager;

    @Mock

    private BluetoothHidDevice mService;

    @Mock

    private CachedBluetoothDevice mCachedBluetoothDevice;

    @Mock

    private BluetoothDevice mBluetoothDevice;

    private BluetoothProfile.ServiceListener mServiceListener;

    private HidDeviceProfile mProfile;

    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        doAnswer((invocation) -> {

            mServiceListener = (BluetoothProfile.ServiceListener) invocation.getArguments()[1];

            return null;

        }).when(mAdapter).getProfileProxy(any(Context.class),

                any(BluetoothProfile.ServiceListener.class), eq(BluetoothProfile.HID_DEVICE));

        mProfile = new HidDeviceProfile(RuntimeEnvironment.application, mAdapter,

                mDeviceManager, mProfileManager);

        mServiceListener.onServiceConnected(BluetoothProfile.HID_DEVICE, mService);

    }

    @Test

    public void connect_shouldReturnFalse() {

        assertThat(mProfile.connect(mBluetoothDevice)).isFalse();

    }

    @Test

    public void disconnect_shouldDisconnectBluetoothHidDevice() {

        mProfile.disconnect(mBluetoothDevice);

        verify(mService).disconnect(mBluetoothDevice);

    }

    @Test

    public void getConnectionStatus_shouldReturnConnectionState() {

        when(mService.getConnectionState(mBluetoothDevice)).

                thenReturn(BluetoothProfile.STATE_CONNECTED);

        assertThat(mProfile.getConnectionStatus(mBluetoothDevice)).

                isEqualTo(BluetoothProfile.STATE_CONNECTED);

    }

}