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

Commit 8f3744e2 authored by Angela Wang's avatar Angela Wang
Browse files

Integrates Bluetooth HAP service client into SettingsLib (1/3) 

Implements the interface LocalBluetoothProfile for HAP service client and get the remote proxy object BluetoothHapClient from Bluetooth framework for controlling the HAP service client via IPC.

Bug: 249235823
Test: make RunSettingsLibRoboTests ROBOTEST_FILTER=HapClientProfileTest
Change-Id: I8c1bb4578c0b04ffb0ea7f1298c9aa054ac4ef3c
parent 0eee4af3

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

0 → 100644
+162 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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 android.bluetooth.BluetoothProfile.CONNECTION_POLICY_ALLOWED;

import static android.bluetooth.BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;



import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothClass;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHapClient;

import android.bluetooth.BluetoothManager;

import android.bluetooth.BluetoothProfile;

import android.content.Context;



import com.android.settingslib.R;



/**

 * HapClientProfile handles the Bluetooth HAP service client role.

 */

public class HapClientProfile implements LocalBluetoothProfile {

    private static final String TAG = "HapClientProfile";



    // Order of this profile in device profiles list

    private static final int ORDINAL = 1;



    private final BluetoothAdapter mBluetoothAdapter;

    private BluetoothHapClient mService;

    private boolean mIsProfileReady;



    // These callbacks run on the main thread.

    private final class HapClientServiceListener implements BluetoothProfile.ServiceListener {



        @Override

        public void onServiceConnected(int profile, BluetoothProfile proxy) {

            mService = (BluetoothHapClient) proxy;

            mIsProfileReady = true;

        }



        @Override

        public void onServiceDisconnected(int profile) {

            mIsProfileReady = false;

        }

    }



    HapClientProfile(Context context, CachedBluetoothDeviceManager deviceManager,

            LocalBluetoothProfileManager profileManager) {

        BluetoothManager bluetoothManager = context.getSystemService(BluetoothManager.class);

        if (bluetoothManager != null) {

            mBluetoothAdapter = bluetoothManager.getAdapter();

            mBluetoothAdapter.getProfileProxy(context, new HapClientServiceListener(),

                    BluetoothProfile.HAP_CLIENT);

        } else {

            mBluetoothAdapter = null;

        }

    }



    @Override

    public boolean accessProfileEnabled() {

        return false;

    }



    @Override

    public boolean isAutoConnectable() {

        return true;

    }



    @Override

    public int getConnectionStatus(BluetoothDevice device) {

        if (mService == null) {

            return BluetoothProfile.STATE_DISCONNECTED;

        }

        return mService.getConnectionState(device);

    }



    @Override

    public boolean isEnabled(BluetoothDevice device) {

        if (mService == null || device == null) {

            return false;

        }

        return mService.getConnectionPolicy(device) > CONNECTION_POLICY_FORBIDDEN;

    }



    @Override

    public int getConnectionPolicy(BluetoothDevice device) {

        if (mService == null || device == null) {

            return CONNECTION_POLICY_FORBIDDEN;

        }

        return mService.getConnectionPolicy(device);

    }



    @Override

    public boolean setEnabled(BluetoothDevice device, boolean enabled) {

        boolean isEnabled = false;

        if (mService == null || device == null) {

            return false;

        }

        if (enabled) {

            if (mService.getConnectionPolicy(device) < CONNECTION_POLICY_ALLOWED) {

                isEnabled = mService.setConnectionPolicy(device, CONNECTION_POLICY_ALLOWED);

            }

        } else {

            isEnabled = mService.setConnectionPolicy(device, CONNECTION_POLICY_FORBIDDEN);

        }



        return isEnabled;

    }



    @Override

    public boolean isProfileReady() {

        return mIsProfileReady;

    }



    @Override

    public int getProfileId() {

        return BluetoothProfile.HAP_CLIENT;

    }



    @Override

    public int getOrdinal() {

        return ORDINAL;

    }



    @Override

    public int getNameResource(BluetoothDevice device) {

        return R.string.bluetooth_profile_hearing_aid;

    }



    @Override

    public int getSummaryResourceForDevice(BluetoothDevice device) {

        int state = getConnectionStatus(device);

        switch (state) {

            case BluetoothProfile.STATE_DISCONNECTED:

                return R.string.bluetooth_hearing_aid_profile_summary_use_for;



            case BluetoothProfile.STATE_CONNECTED:

                return R.string.bluetooth_hearing_aid_profile_summary_connected;



            default:

                return BluetoothUtils.getConnectionStateSummary(state);

        }

    }



    @Override

    public int getDrawableResource(BluetoothClass btClass) {

        return com.android.internal.R.drawable.ic_bt_hearing_aid;

    }

}

packages/SettingsLib/tests/robotests/src/com/android/settingslib/bluetooth/HapClientProfileTest.java

0 → 100644
+167 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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 android.bluetooth.BluetoothProfile.CONNECTION_POLICY_ALLOWED;

import static android.bluetooth.BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.Mockito.when;



import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHapClient;

import android.bluetooth.BluetoothManager;

import android.bluetooth.BluetoothProfile;

import android.content.Context;



import androidx.test.core.app.ApplicationProvider;



import com.android.settingslib.testutils.shadow.ShadowBluetoothAdapter;



import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.junit.MockitoJUnit;

import org.mockito.junit.MockitoRule;

import org.robolectric.RobolectricTestRunner;

import org.robolectric.annotation.Config;

import org.robolectric.shadow.api.Shadow;



@RunWith(RobolectricTestRunner.class)

@Config(shadows = {ShadowBluetoothAdapter.class})

public class HapClientProfileTest {



    @Rule

    public final MockitoRule mockito = MockitoJUnit.rule();



    @Mock

    private CachedBluetoothDeviceManager mDeviceManager;

    @Mock

    private LocalBluetoothProfileManager mProfileManager;

    @Mock

    private BluetoothDevice mBluetoothDevice;

    @Mock

    private BluetoothHapClient mService;



    private final Context mContext = ApplicationProvider.getApplicationContext();

    private BluetoothProfile.ServiceListener mServiceListener;

    private HapClientProfile mProfile;



    @Before

    public void setUp() {

        mProfile = new HapClientProfile(mContext, mDeviceManager, mProfileManager);

        final BluetoothManager bluetoothManager = mContext.getSystemService(BluetoothManager.class);

        final ShadowBluetoothAdapter shadowBluetoothAdapter =

                Shadow.extract(bluetoothManager.getAdapter());

        mServiceListener = shadowBluetoothAdapter.getServiceListener();

    }



    @Test

    public void onServiceConnected_isProfileReady() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);



        assertThat(mProfile.isProfileReady()).isTrue();

    }



    @Test

    public void onServiceDisconnected_isProfileNotReady() {

        mServiceListener.onServiceDisconnected(BluetoothProfile.HAP_CLIENT);



        assertThat(mProfile.isProfileReady()).isFalse();

    }



    @Test

    public void getConnectionStatus_returnCorrectConnectionState() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionState(mBluetoothDevice))

                .thenReturn(BluetoothProfile.STATE_CONNECTED);



        assertThat(mProfile.getConnectionStatus(mBluetoothDevice))

                .isEqualTo(BluetoothProfile.STATE_CONNECTED);

    }



    @Test

    public void isEnabled_connectionPolicyAllowed_returnTrue() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice)).thenReturn(CONNECTION_POLICY_ALLOWED);



        assertThat(mProfile.isEnabled(mBluetoothDevice)).isTrue();

    }



    @Test

    public void isEnabled_connectionPolicyForbidden_returnFalse() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice))

                .thenReturn(CONNECTION_POLICY_FORBIDDEN);



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

    }



    @Test

    public void getConnectionPolicy_returnCorrectConnectionPolicy() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice)).thenReturn(CONNECTION_POLICY_ALLOWED);



        assertThat(mProfile.getConnectionPolicy(mBluetoothDevice))

                .isEqualTo(CONNECTION_POLICY_ALLOWED);

    }



    @Test

    public void setEnabled_connectionPolicyAllowed_setConnectionPolicyAllowed_returnFalse() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice)).thenReturn(CONNECTION_POLICY_ALLOWED);

        when(mService.setConnectionPolicy(mBluetoothDevice, CONNECTION_POLICY_ALLOWED))

                .thenReturn(true);



        assertThat(mProfile.setEnabled(mBluetoothDevice, true)).isFalse();

    }



    @Test

    public void setEnabled_connectionPolicyForbidden_setConnectionPolicyAllowed_returnTrue() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice))

                .thenReturn(CONNECTION_POLICY_FORBIDDEN);

        when(mService.setConnectionPolicy(mBluetoothDevice, CONNECTION_POLICY_ALLOWED))

                .thenReturn(true);



        assertThat(mProfile.setEnabled(mBluetoothDevice, true)).isTrue();

    }



    @Test

    public void setEnabled_connectionPolicyAllowed_setConnectionPolicyForbidden_returnTrue() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice)).thenReturn(CONNECTION_POLICY_ALLOWED);

        when(mService.setConnectionPolicy(mBluetoothDevice, CONNECTION_POLICY_FORBIDDEN))

                .thenReturn(true);



        assertThat(mProfile.setEnabled(mBluetoothDevice, false)).isTrue();

    }



    @Test

    public void setEnabled_connectionPolicyForbidden_setConnectionPolicyForbidden_returnTrue() {

        mServiceListener.onServiceConnected(BluetoothProfile.HAP_CLIENT, mService);

        when(mService.getConnectionPolicy(mBluetoothDevice))

                .thenReturn(CONNECTION_POLICY_FORBIDDEN);

        when(mService.setConnectionPolicy(mBluetoothDevice, CONNECTION_POLICY_FORBIDDEN))

                .thenReturn(true);



        assertThat(mProfile.setEnabled(mBluetoothDevice, false)).isTrue();

    }

}