Bumble Java Android Headtracker Test cases

/*

 * Copyright (C) 2024 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 android.bluetooth.hid;

import static android.bluetooth.BluetoothDevice.TRANSPORT_LE;

import static android.bluetooth.BluetoothProfile.STATE_CONNECTED;

import static android.bluetooth.BluetoothProfile.STATE_CONNECTING;

import static android.bluetooth.BluetoothProfile.STATE_DISCONNECTED;

import static android.bluetooth.BluetoothProfile.STATE_DISCONNECTING;

import static androidx.test.espresso.intent.matcher.IntentMatchers.hasAction;

import static androidx.test.espresso.intent.matcher.IntentMatchers.hasExtra;

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

import static org.hamcrest.Matchers.equalTo;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.any;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.inOrder;

import static org.mockito.Mockito.timeout;

import static org.mockito.Mockito.verify;

import android.annotation.SuppressLint;

import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHeadset;

import android.bluetooth.BluetoothHidHost;

import android.bluetooth.BluetoothManager;

import android.bluetooth.BluetoothProfile;

import android.bluetooth.BluetoothStatusCodes;

import android.bluetooth.Host;

import android.bluetooth.PandoraDevice;

import android.bluetooth.test_utils.EnableBluetoothRule;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.os.ParcelUuid;

import android.platform.test.annotations.RequiresFlagsEnabled;

import android.platform.test.flag.junit.CheckFlagsRule;

import android.platform.test.flag.junit.DeviceFlagsValueProvider;

import android.util.Log;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import androidx.test.platform.app.InstrumentationRegistry;

import com.android.bluetooth.flags.Flags;

import com.android.compatibility.common.util.AdoptShellPermissionsRule;

import org.hamcrest.Matcher;

import org.hamcrest.Matchers;

import org.hamcrest.core.AllOf;

import org.junit.After;

import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.InOrder;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.mockito.hamcrest.MockitoHamcrest;

import pandora.GattProto;

import pandora.HostProto.AdvertiseRequest;

import pandora.HostProto.DiscoverabilityMode;

import pandora.HostProto.OwnAddressType;

import pandora.HostProto.SetDiscoverabilityModeRequest;

import java.time.Duration;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.TimeUnit;

@RunWith(AndroidJUnit4.class)

public class HidHeadTrackerTest {

    private static final String TAG = HidHeadTrackerTest.class.getSimpleName();

    private static final String BUMBLE_DEVICE_NAME = "Bumble";

    private static final Duration BOND_INTENT_TIMEOUT = Duration.ofSeconds(10);

    private static final Duration INTENT_TIMEOUT = Duration.ofSeconds(10);

    private static final int DISCOVERY_TIMEOUT = 2000; // 2 seconds

    private CompletableFuture<BluetoothDevice> mDeviceFound;

    private static final ParcelUuid HEADTRACKER_UUID =

            ParcelUuid.fromString("109b862f-50e3-45cc-8ea1-ac62de4846d1");

    private static final Context sTargetContext =

            InstrumentationRegistry.getInstrumentation().getTargetContext();

    private static final BluetoothAdapter sAdapter =

            sTargetContext.getSystemService(BluetoothManager.class).getAdapter();

    @Rule(order = 0)

    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();

    @Rule(order = 1)

    public final AdoptShellPermissionsRule mPermissionRule = new AdoptShellPermissionsRule();

    @Rule(order = 2)

    public final PandoraDevice mBumble = new PandoraDevice();

    @Rule(order = 3)

    public final EnableBluetoothRule mEnableBluetoothRule =

            new EnableBluetoothRule(false /* enableTestMode */, true /* toggleBluetooth */);

    @Mock private BroadcastReceiver mReceiver;

    @Mock private BluetoothProfile.ServiceListener mProfileServiceListener;

    private final Map<String, Integer> mActionRegistrationCounts = new HashMap<>();

    private InOrder mInOrder = null;

    private BluetoothDevice mBumbleDevice;

    private Host mHost;

    private BluetoothHidHost mHidService;

    private BluetoothHeadset mHfpService;

    private BluetoothA2dp mA2dpService;

    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        doAnswer(

                        inv -> {

                            Log.d(

                                    TAG,

                                    "onReceive(): intent=" + Arrays.toString(inv.getArguments()));

                            Intent intent = inv.getArgument(1);

                            String action = intent.getAction();

                            if (BluetoothDevice.ACTION_UUID.equals(action)) {

                                ParcelUuid[] uuids =

                                        intent.getParcelableArrayExtra(

                                                BluetoothDevice.EXTRA_UUID, ParcelUuid.class);

                                Log.d(TAG, "onReceive(): UUID=" + Arrays.toString(uuids));

                            } else if (BluetoothDevice.ACTION_FOUND.equals(intent.getAction())) {

                                BluetoothDevice device =

                                        intent.getParcelableExtra(

                                                BluetoothDevice.EXTRA_DEVICE,

                                                BluetoothDevice.class);

                                String deviceName =

                                        String.valueOf(

                                                intent.getStringExtra(BluetoothDevice.EXTRA_NAME));

                                Log.i(

                                        TAG,

                                        "Discovered device: "

                                                + device

                                                + " with name: "

                                                + deviceName);

                                if (deviceName != null && BUMBLE_DEVICE_NAME.equals(deviceName)) {

                                    mDeviceFound.complete(device);

                                }

                            } else if (BluetoothDevice.ACTION_ACL_CONNECTED.equals(

                                    intent.getAction())) {

                                BluetoothDevice device =

                                        intent.getParcelableExtra(

                                                BluetoothDevice.EXTRA_DEVICE,

                                                BluetoothDevice.class);

                                int transport =

                                        intent.getIntExtra(

                                                BluetoothDevice.EXTRA_TRANSPORT,

                                                BluetoothDevice.TRANSPORT_AUTO);

                                Log.i(

                                        TAG,

                                        "ACL connected for device="

                                                + device

                                                + " with transport: "

                                                + transport);

                            } else if (BluetoothDevice.ACTION_ACL_DISCONNECTED.equals(

                                    intent.getAction())) {

                                BluetoothDevice device =

                                        intent.getParcelableExtra(

                                                BluetoothDevice.EXTRA_DEVICE,

                                                BluetoothDevice.class);

                                int transport =

                                        intent.getIntExtra(

                                                BluetoothDevice.EXTRA_TRANSPORT,

                                                BluetoothDevice.TRANSPORT_AUTO);

                                Log.i(

                                        TAG,

                                        "ACL Disconnected for device="

                                                + device

                                                + " with transport: "

                                                + transport);

                            } else if (BluetoothHidHost.ACTION_CONNECTION_STATE_CHANGED.equals(

                                    intent.getAction())) {

                                BluetoothDevice device =

                                        intent.getParcelableExtra(

                                                BluetoothDevice.EXTRA_DEVICE,

                                                BluetoothDevice.class);

                                int state =

                                        intent.getIntExtra(

                                                BluetoothProfile.EXTRA_STATE,

                                                BluetoothAdapter.ERROR);

                                int transport =

                                        intent.getIntExtra(

                                                BluetoothDevice.EXTRA_TRANSPORT,

                                                BluetoothDevice.TRANSPORT_AUTO);

                                Log.i(

                                        TAG,

                                        "Connection state change: device="

                                                + device

                                                + " "

                                                + BluetoothProfile.getConnectionStateName(state)

                                                + "("

                                                + state

                                                + "), transport: "

                                                + transport);

                            }

                            return null;

                        })

                .when(mReceiver)

                .onReceive(any(), any());

        mInOrder = inOrder(mReceiver);

        mHost = new Host(sTargetContext);

        // Get profile proxies

        sAdapter.getProfileProxy(

                sTargetContext, mProfileServiceListener, BluetoothProfile.HID_HOST);

        mHidService = (BluetoothHidHost) verifyProfileServiceConnected(BluetoothProfile.HID_HOST);

        sAdapter.getProfileProxy(sTargetContext, mProfileServiceListener, BluetoothProfile.A2DP);

        mA2dpService = (BluetoothA2dp) verifyProfileServiceConnected(BluetoothProfile.A2DP);

        sAdapter.getProfileProxy(sTargetContext, mProfileServiceListener, BluetoothProfile.HEADSET);

        mHfpService = (BluetoothHeadset) verifyProfileServiceConnected(BluetoothProfile.HEADSET);

    }

    @After

    public void tearDown() throws Exception {

        if (mBumbleDevice.getBondState() == BluetoothDevice.BOND_BONDED) {

            mHost.removeBondAndVerify(mBumbleDevice);

        }

        mHost.close();

        mBumbleDevice = null;

        if (getTotalActionRegistrationCounts() > 0) {

            sTargetContext.unregisterReceiver(mReceiver);

            mActionRegistrationCounts.clear();

        }

    }

    /**

     * Ensure that successful HID connection over LE Transport.

     *

     * <p>Prerequisites:

     *

     * <ol>

     *   <li>Bumble has Android Headtracker Service

     *   <li>Bumble does not support HID and HOGP

     *   <li>Bummble is connectable over LE

     * </ol>

     *

     * <p>Steps:

     *

     * <ol>

     *   <li>Android pairs with Bumble

     *   <li>Android Bluetooth reports HID host connection

     *   <li>Disconnect and reconnect

     *   <li>Android Bluetooth reports HID host connection

     * </ol>

     *

     * Expectation: successful HID connection over LE Transport

     */

    @SuppressLint("MissingPermission")

    @Test

    @RequiresFlagsEnabled({

        Flags.FLAG_ALLOW_SWITCHING_HID_AND_HOGP,

        Flags.FLAG_SAVE_INITIAL_HID_CONNECTION_POLICY

    })

    public void connectWithoutHidServiceTest() {

        registerIntentActions(

                BluetoothDevice.ACTION_ACL_CONNECTED,

                BluetoothDevice.ACTION_ACL_DISCONNECTED,

                BluetoothDevice.ACTION_UUID,

                BluetoothHidHost.ACTION_CONNECTION_STATE_CHANGED,

                BluetoothDevice.ACTION_FOUND);

        pairAndConnect();

        // Verify  ACL connection on classic transport first and then LE transport

        verifyIntentReceived(

                hasAction(BluetoothDevice.ACTION_ACL_CONNECTED),

                hasExtra(BluetoothDevice.EXTRA_TRANSPORT, BluetoothDevice.TRANSPORT_BREDR));

        verifyIntentReceived(

                hasAction(BluetoothDevice.ACTION_ACL_CONNECTED),

                hasExtra(BluetoothDevice.EXTRA_TRANSPORT, BluetoothDevice.TRANSPORT_LE));

        verifyIntentReceived(

                hasAction(BluetoothDevice.ACTION_UUID),

                hasExtra(BluetoothDevice.EXTRA_UUID, Matchers.hasItemInArray(HEADTRACKER_UUID)));

        verifyConnectionState(mBumbleDevice, equalTo(TRANSPORT_LE), equalTo(STATE_CONNECTING));

        verifyConnectionState(mBumbleDevice, equalTo(TRANSPORT_LE), equalTo(STATE_CONNECTED));

        // Disable a2dp and HFP connetcion policy

        if (mA2dpService.getConnectionPolicy(mBumbleDevice)

                == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

            assertThat(

                            mA2dpService.setConnectionPolicy(

                                    mBumbleDevice, BluetoothProfile.CONNECTION_POLICY_FORBIDDEN))

                    .isTrue();

        }

        if (mHfpService.getConnectionPolicy(mBumbleDevice)

                == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

            assertThat(

                            mHfpService.setConnectionPolicy(

                                    mBumbleDevice, BluetoothProfile.CONNECTION_POLICY_FORBIDDEN))

                    .isTrue();

        }

        // Disconnect  and Reconnect

        assertThat(mBumbleDevice.disconnect()).isEqualTo(BluetoothStatusCodes.SUCCESS);

        verifyConnectionState(mBumbleDevice, equalTo(TRANSPORT_LE), equalTo(STATE_DISCONNECTING));

        verifyConnectionState(mBumbleDevice, equalTo(TRANSPORT_LE), equalTo(STATE_DISCONNECTED));

        // Wait for ACL to get disconnected

        verifyIntentReceived(

                hasAction(BluetoothDevice.ACTION_ACL_DISCONNECTED),

                hasExtra(BluetoothDevice.EXTRA_TRANSPORT, BluetoothDevice.TRANSPORT_LE),

                hasExtra(BluetoothDevice.EXTRA_DEVICE, mBumbleDevice));

        assertThat(mBumbleDevice.connect()).isEqualTo(BluetoothStatusCodes.SUCCESS);

        verifyConnectionState(mBumbleDevice, equalTo(TRANSPORT_LE), equalTo(STATE_CONNECTING));

        verifyIntentReceived(

                hasAction(BluetoothDevice.ACTION_ACL_CONNECTED),

                hasExtra(BluetoothDevice.EXTRA_TRANSPORT, BluetoothDevice.TRANSPORT_LE),

                hasExtra(BluetoothDevice.EXTRA_DEVICE, mBumbleDevice));

        verifyConnectionState(mBumbleDevice, equalTo(TRANSPORT_LE), equalTo(STATE_CONNECTED));

        unregisterIntentActions(

                BluetoothDevice.ACTION_UUID,

                BluetoothDevice.ACTION_ACL_CONNECTED,

                BluetoothDevice.ACTION_ACL_DISCONNECTED,

                BluetoothDevice.ACTION_FOUND);

    }

    private void pairAndConnect() {

        // Register Head tracker services on Bumble

        mBumble.gattBlocking()

                .registerService(

                        GattProto.RegisterServiceRequest.newBuilder()

                                .setService(

                                        GattProto.GattServiceParams.newBuilder()

                                                .setUuid(HEADTRACKER_UUID.toString())

                                                .build())

                                .build());

        // Make Bumble connectable

        mBumble.hostBlocking()

                .advertise(

                        AdvertiseRequest.newBuilder()

                                .setLegacy(true)

                                .setConnectable(true)

                                .setOwnAddressType(OwnAddressType.RANDOM)

                                .build());

        // Make Bumble discoverable over BR/EDR

        mBumble.hostBlocking()

                .setDiscoverabilityMode(

                        SetDiscoverabilityModeRequest.newBuilder()

                                .setMode(DiscoverabilityMode.DISCOVERABLE_GENERAL)

                                .build());

        // Start Discovery

        mDeviceFound = new CompletableFuture<>();

        assertThat(sAdapter.startDiscovery()).isTrue();

        mBumbleDevice =

                mDeviceFound

                        .completeOnTimeout(null, DISCOVERY_TIMEOUT, TimeUnit.MILLISECONDS)

                        .join();

        assertThat(sAdapter.cancelDiscovery()).isTrue();

        // Create Bond

        mHost.createBondAndVerify(mBumbleDevice);

    }

    @SafeVarargs

    private void verifyIntentReceived(Matcher<Intent>... matchers) {

        mInOrder.verify(mReceiver, timeout(BOND_INTENT_TIMEOUT.toMillis()))

                .onReceive(any(Context.class), MockitoHamcrest.argThat(AllOf.allOf(matchers)));

    }

    private void verifyConnectionState(

            BluetoothDevice device, Matcher<Integer> transport, Matcher<Integer> state) {

        verifyIntentReceived(

                hasAction(BluetoothHidHost.ACTION_CONNECTION_STATE_CHANGED),

                hasExtra(BluetoothDevice.EXTRA_DEVICE, device),

                hasExtra(BluetoothDevice.EXTRA_TRANSPORT, transport),

                hasExtra(BluetoothProfile.EXTRA_STATE, state));

    }

    /**

     * Helper function to add reference count to registered intent actions

     *

     * @param actions new intent actions to add. If the array is empty, it is a no-op.

     */

    private void registerIntentActions(String... actions) {

        if (actions.length == 0) {

            return;

        }

        if (getTotalActionRegistrationCounts() > 0) {

            Log.d(TAG, "registerIntentActions(): unregister ALL intents");

            sTargetContext.unregisterReceiver(mReceiver);

        }

        for (String action : actions) {

            mActionRegistrationCounts.merge(action, 1, Integer::sum);

        }

        IntentFilter filter = new IntentFilter();

        mActionRegistrationCounts.entrySet().stream()

                .filter(entry -> entry.getValue() > 0)

                .forEach(

                        entry -> {

                            Log.d(

                                    TAG,

                                    "registerIntentActions(): Registering action = "

                                            + entry.getKey());

                            filter.addAction(entry.getKey());

                        });

        sTargetContext.registerReceiver(mReceiver, filter);

    }

    /**

     * Helper function to reduce reference count to registered intent actions If total reference

     * count is zero after removal, no broadcast receiver will be registered.

     *

     * @param actions intent actions to be removed. If some action is not registered, it is no-op

     *     for that action. If the actions array is empty, it is also a no-op.

     */

    private void unregisterIntentActions(String... actions) {

        if (actions.length == 0) {

            return;

        }

        if (getTotalActionRegistrationCounts() <= 0) {

            return;

        }

        Log.d(TAG, "unregisterIntentActions(): unregister ALL intents");

        sTargetContext.unregisterReceiver(mReceiver);

        for (String action : actions) {

            if (!mActionRegistrationCounts.containsKey(action)) {

                continue;

            }

            mActionRegistrationCounts.put(action, mActionRegistrationCounts.get(action) - 1);

            if (mActionRegistrationCounts.get(action) <= 0) {

                mActionRegistrationCounts.remove(action);

            }

        }

        if (getTotalActionRegistrationCounts() > 0) {

            IntentFilter filter = new IntentFilter();

            mActionRegistrationCounts.entrySet().stream()

                    .filter(entry -> entry.getValue() > 0)

                    .forEach(

                            entry -> {

                                Log.d(

                                        TAG,

                                        "unregisterIntentActions(): Registering action = "

                                                + entry.getKey());

                                filter.addAction(entry.getKey());

                            });

            sTargetContext.registerReceiver(mReceiver, filter);

        }

    }

    /**

     * Get sum of reference count from all registered actions

     *

     * @return sum of reference count from all registered actions

     */

    private int getTotalActionRegistrationCounts() {

        return mActionRegistrationCounts.values().stream().reduce(0, Integer::sum);

    }

    private BluetoothProfile verifyProfileServiceConnected(int profile) {

        ArgumentCaptor<BluetoothProfile> proxyCaptor =

                ArgumentCaptor.forClass(BluetoothProfile.class);

        verify(mProfileServiceListener, timeout(INTENT_TIMEOUT.toMillis()))

                .onServiceConnected(eq(profile), proxyCaptor.capture());

        return proxyCaptor.getValue();

    }

}