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

Commit 649aaaf7 authored by Sal Savage's avatar Sal Savage Committed by Gerrit Code Review
Browse files

Merge "Make BluetoothHeadsetClient and associated functions @SystemApi"

parents 427883e9 d22925c5

android/app/src/com/android/bluetooth/hfpclient/HeadsetClientStateMachine.java

+4 −1
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
package com.android.bluetooth.hfpclient;



import static android.Manifest.permission.BLUETOOTH_CONNECT;

import static android.Manifest.permission.BLUETOOTH_PRIVILEGED;



import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;
@@ -1930,7 +1931,9 @@ public class HeadsetClientStateMachine extends StateMachine { 
                intent.putExtra(BluetoothHeadsetClient.EXTRA_AG_FEATURE_MERGE_AND_DETACH, true);

            }

        }

        mService.sendBroadcast(intent, BLUETOOTH_CONNECT,



        mService.sendBroadcastMultiplePermissions(intent,

                new String[] {BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED},

                Utils.getTempAllowlistBroadcastOptions());



        HfpClientConnectionService.onConnectionStateChanged(device, newState, prevState);

android/app/tests/unit/src/com/android/bluetooth/hfpclient/HeadsetClientStateMachineTest.java

+53 −31
Original line number Diff line number Diff line
@@ -139,14 +139,15 @@ public class HeadsetClientStateMachineTest { 
        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, connStCh);



        // Verify that only DISCONNECTED -> DISCONNECTED broadcast is fired

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS)).sendBroadcast(MockitoHamcrest

                .argThat(

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS))

                .sendBroadcastMultiplePermissions(MockitoHamcrest.argThat(

                AllOf.allOf(IntentMatchers.hasAction(

                        BluetoothHeadsetClient.ACTION_CONNECTION_STATE_CHANGED),

                        IntentMatchers.hasExtra(BluetoothProfile.EXTRA_STATE,

                                BluetoothProfile.STATE_DISCONNECTED),

                        IntentMatchers.hasExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE,

                                BluetoothProfile.STATE_DISCONNECTED))), anyString(),

                                BluetoothProfile.STATE_DISCONNECTED))),

                any(String[].class),

                any(Bundle.class));

        // Check we are in disconnected state still.

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),
@@ -171,9 +172,9 @@ public class HeadsetClientStateMachineTest { 


        // Verify that one connection state broadcast is executed

        ArgumentCaptor<Intent> intentArgument1 = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS)).sendBroadcast(intentArgument1

                .capture(),

                anyString(), any(Bundle.class));

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS))

                .sendBroadcastMultiplePermissions(intentArgument1.capture(),

                any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_CONNECTING,

                intentArgument1.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));
@@ -190,8 +191,9 @@ public class HeadsetClientStateMachineTest { 


        // Verify that one connection state broadcast is executed

        ArgumentCaptor<Intent> intentArgument2 = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(2)).sendBroadcast(

                intentArgument2.capture(), anyString(), any(Bundle.class));

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(2))

                .sendBroadcastMultiplePermissions(intentArgument2.capture(),

                any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_CONNECTED,

                intentArgument2.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));

        // Check we are in connecting state now.
@@ -217,9 +219,9 @@ public class HeadsetClientStateMachineTest { 


        // Verify that one connection state broadcast is executed

        ArgumentCaptor<Intent> intentArgument1 = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS)).sendBroadcast(intentArgument1

                .capture(),

                anyString(), any(Bundle.class));

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS))

                .sendBroadcastMultiplePermissions(intentArgument1.capture(),

                any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_CONNECTING,

                intentArgument1.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));
@@ -230,9 +232,9 @@ public class HeadsetClientStateMachineTest { 
        // Verify that one connection state broadcast is executed

        ArgumentCaptor<Intent> intentArgument2 = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService,

                timeout(HeadsetClientStateMachine.CONNECTING_TIMEOUT_MS * 2).times(

                        2)).sendBroadcast(intentArgument2.capture(), anyString(),

                any(Bundle.class));

                timeout(HeadsetClientStateMachine.CONNECTING_TIMEOUT_MS * 2).times(2))

                .sendBroadcastMultiplePermissions(intentArgument2.capture(),

                any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_DISCONNECTED,

                intentArgument2.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));
@@ -260,11 +262,15 @@ public class HeadsetClientStateMachineTest { 
        connStCh.device = mTestDevice;

        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, connStCh);



        int expectedBroadcastIndex = 1;

        int expectedBroadcastMultiplePermissionsIndex = 1;



        // Verify that one connection state broadcast is executed

        ArgumentCaptor<Intent> intentArgument = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS)).sendBroadcast(intentArgument

                .capture(),

                anyString(), any(Bundle.class));

        verify(mHeadsetClientService,

                timeout(STANDARD_WAIT_MILLIS).times(expectedBroadcastMultiplePermissionsIndex++))

                .sendBroadcastMultiplePermissions(intentArgument.capture(),

                any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_CONNECTING,

                intentArgument.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));
@@ -275,9 +281,10 @@ public class HeadsetClientStateMachineTest { 
        slcEvent.device = mTestDevice;

        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, slcEvent);



        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(2)).sendBroadcast(

                intentArgument.capture(),

                anyString(), any(Bundle.class));

        verify(mHeadsetClientService,

                timeout(STANDARD_WAIT_MILLIS).times(expectedBroadcastMultiplePermissionsIndex++))

                .sendBroadcastMultiplePermissions(intentArgument.capture(),

                any(String[].class), any(Bundle.class));



        Assert.assertEquals(BluetoothProfile.STATE_CONNECTED,

                intentArgument.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));
@@ -291,7 +298,8 @@ public class HeadsetClientStateMachineTest { 
        eventInBandRing.valueInt = 1;

        eventInBandRing.device = mTestDevice;

        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, eventInBandRing);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(3)).sendBroadcast(

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(expectedBroadcastIndex++))

                .sendBroadcast(

                intentArgument.capture(),

                anyString(), any(Bundle.class));

        Assert.assertEquals(1,
@@ -304,7 +312,9 @@ public class HeadsetClientStateMachineTest { 
        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, eventCallStatusUpdated);

        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(3)).sendBroadcast(

        verify(mHeadsetClientService,

                timeout(STANDARD_WAIT_MILLIS).times(expectedBroadcastIndex - 1))

                .sendBroadcast(

                intentArgument.capture(),

                anyString(),any(Bundle.class));
@@ -318,7 +328,9 @@ public class HeadsetClientStateMachineTest { 
        eventIncomingCall.device = mTestDevice;



        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, eventIncomingCall);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(3)).sendBroadcast(

        verify(mHeadsetClientService,

                timeout(STANDARD_WAIT_MILLIS).times(expectedBroadcastIndex - 1))

                .sendBroadcast(

                intentArgument.capture(),

                anyString(), any(Bundle.class));
@@ -328,7 +340,8 @@ public class HeadsetClientStateMachineTest { 
        eventCommandStatus.valueInt = AT_OK;

        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, eventCommandStatus);

        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        verify(mHeadsetClientService, timeout(QUERY_CURRENT_CALLS_TEST_WAIT_MILLIS).times(4))

        verify(mHeadsetClientService,

                timeout(QUERY_CURRENT_CALLS_TEST_WAIT_MILLIS).times(expectedBroadcastIndex++))

                .sendBroadcast(

                intentArgument.capture(),

                anyString(), any(Bundle.class));
@@ -340,7 +353,8 @@ public class HeadsetClientStateMachineTest { 
        // Disable In Band Ring and verify state gets propagated.

        eventInBandRing.valueInt = 0;

        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, eventInBandRing);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(5)).sendBroadcast(

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(expectedBroadcastIndex++))

                .sendBroadcast(

                intentArgument.capture(),

                anyString(), any(Bundle.class));

        Assert.assertEquals(0,
@@ -359,7 +373,8 @@ public class HeadsetClientStateMachineTest { 
        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, connStCh);

        ArgumentCaptor<Intent> intentArgument = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(startBroadcastIndex))

                .sendBroadcast(intentArgument.capture(), anyString(), any(Bundle.class));

                .sendBroadcastMultiplePermissions(intentArgument.capture(),

                                                  any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_CONNECTING,

                intentArgument.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));

        startBroadcastIndex++;
@@ -377,7 +392,8 @@ public class HeadsetClientStateMachineTest { 
        mHeadsetClientStateMachine.sendMessage(StackEvent.STACK_EVENT, slcEvent);

        ArgumentCaptor<Intent> intentArgument = ArgumentCaptor.forClass(Intent.class);

        verify(mHeadsetClientService, timeout(STANDARD_WAIT_MILLIS).times(startBroadcastIndex))

                .sendBroadcast(intentArgument.capture(), anyString(), any(Bundle.class));

                .sendBroadcastMultiplePermissions(intentArgument.capture(),

                                                  any(String[].class), any(Bundle.class));

        Assert.assertEquals(BluetoothProfile.STATE_CONNECTED,

                intentArgument.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));

        startBroadcastIndex++;
@@ -478,8 +494,11 @@ public class HeadsetClientStateMachineTest { 
        when(mHeadsetClientService.getConnectionPolicy(any(BluetoothDevice.class))).thenReturn(

                BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        int expectedBroadcastIndex = 1;

        expectedBroadcastIndex = setUpHfpClientConnection(expectedBroadcastIndex);

        expectedBroadcastIndex = setUpServiceLevelConnection(expectedBroadcastIndex);

        int expectedBroadcastMultiplePermissionsIndex = 1;

        expectedBroadcastMultiplePermissionsIndex =

            setUpHfpClientConnection(expectedBroadcastMultiplePermissionsIndex);

        expectedBroadcastMultiplePermissionsIndex =

            setUpServiceLevelConnection(expectedBroadcastMultiplePermissionsIndex);



        // Simulate a known event arrive

        String vendorEvent = vendorEventCode + vendorEventArgument;
@@ -587,8 +606,11 @@ public class HeadsetClientStateMachineTest { 
        doReturn(true).when(mNativeInterface).stopVoiceRecognition(any(BluetoothDevice.class));



        int expectedBroadcastIndex = 1;

        expectedBroadcastIndex = setUpHfpClientConnection(expectedBroadcastIndex);

        expectedBroadcastIndex = setUpServiceLevelConnection(expectedBroadcastIndex);

        int expectedBroadcastMultiplePermissionsIndex = 1;

        expectedBroadcastMultiplePermissionsIndex =

            setUpHfpClientConnection(expectedBroadcastMultiplePermissionsIndex);

        expectedBroadcastMultiplePermissionsIndex =

            setUpServiceLevelConnection(expectedBroadcastMultiplePermissionsIndex);



        // Simulate a voice recognition start

        mHeadsetClientStateMachine.sendMessage(VOICE_RECOGNITION_START);

framework/java/android/bluetooth/BluetoothHeadsetClient.java

+374 −113

File changed.

Preview size limit exceeded, changes collapsed.