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

Commit 632cac52 authored by Josh Wu's avatar Josh Wu Committed by William Escande
Browse files

[HFP] Broadcast inband ringing status to HF 

Cherry-picked from Wear os

Bug: 263323082
Bug: 237054503
Test: atest BluetoothInstrumentationTests
Change-Id: I40b76a358d3fd13a32b7154f2e3966a9b0ff6603
(cherry picked from commit 713924f39f1f6c4f7b3d80ea4b95951e155e47de)
parent 1643edea

android/app/src/com/android/bluetooth/hfp/HeadsetService.java

+45 −21
Original line number Diff line number Diff line
@@ -1967,31 +1967,55 @@ public class HeadsetService extends ProfileService { 
    @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)

    public void onConnectionStateChangedFromStateMachine(BluetoothDevice device, int fromState,

            int toState) {

        synchronized (mStateMachines) {

            List<BluetoothDevice> audioConnectableDevices = getConnectedDevices();

        if (fromState != BluetoothProfile.STATE_CONNECTED

                && toState == BluetoothProfile.STATE_CONNECTED) {

                if (audioConnectableDevices.size() > 1) {

                    mInbandRingingRuntimeDisable = true;

                    doForEachConnectedStateMachine(

                            stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.SEND_BSIR,

                                    0));

                }

            updateInbandRinging(device, true);

            MetricsLogger.logProfileConnectionEvent(BluetoothMetricsProto.ProfileId.HEADSET);

        }

        if (fromState != BluetoothProfile.STATE_DISCONNECTED

                && toState == BluetoothProfile.STATE_DISCONNECTED) {

                if (audioConnectableDevices.size() <= 1) {

                    mInbandRingingRuntimeDisable = false;

                    doForEachConnectedStateMachine(

                            stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.SEND_BSIR,

                                    1));

                }

            updateInbandRinging(device, false);

            if (device.equals(mActiveDevice)) {

                setActiveDevice(null);

            }

        }

    }



    /**

     * Called from {@link HeadsetClientStateMachine} to update inband ringing status.

     */

    public void updateInbandRinging(BluetoothDevice device, boolean connected) {

        synchronized (mStateMachines) {

            List<BluetoothDevice> audioConnectableDevices = getConnectedDevices();

            final int enabled;

            final boolean inbandRingingRuntimeDisable = mInbandRingingRuntimeDisable;



            if (audioConnectableDevices.size() > 1 || isHeadsetClientConnected()) {

                mInbandRingingRuntimeDisable = true;

                enabled = 0;

            } else {

                mInbandRingingRuntimeDisable = false;

                enabled = 1;

            }



            final boolean updateAll = inbandRingingRuntimeDisable != mInbandRingingRuntimeDisable;



            Log.i(TAG, "updateInbandRinging():"

                    + " Device=" + device

                    + " enabled=" + enabled

                    + " connected=" + connected

                    + " Update all=" + updateAll);



            StateMachineTask sendBsirTask = stateMachine -> stateMachine

                            .sendMessage(HeadsetStateMachine.SEND_BSIR, enabled);



            if (updateAll) {

                doForEachConnectedStateMachine(sendBsirTask);

            } else if (connected) {

                // Same Inband ringing status, send +BSIR only to the new connected device

                doForStateMachine(device, sendBsirTask);

            }

        }

    }



    /**

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

+16 −6
Original line number Diff line number Diff line
@@ -64,6 +64,7 @@ import com.android.bluetooth.Utils; 
import com.android.bluetooth.btservice.AdapterService;

import com.android.bluetooth.btservice.MetricsLogger;

import com.android.bluetooth.btservice.ProfileService;

import com.android.bluetooth.hfp.HeadsetService;

import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.util.IState;

import com.android.internal.util.State;
@@ -148,6 +149,7 @@ public class HeadsetClientStateMachine extends StateMachine { 
    private long mClccTimer = 0;



    private final HeadsetClientService mService;

    private final HeadsetService mHeadsetService;



    // Set of calls that represent the accurate state of calls that exists on AG and the calls that

    // are currently in process of being notified to the AG from HF.
@@ -860,12 +862,13 @@ public class HeadsetClientStateMachine extends StateMachine { 
        return (bitfield & mask) == mask;

    }



    HeadsetClientStateMachine(HeadsetClientService context, Looper looper,

                              NativeInterface nativeInterface) {

    HeadsetClientStateMachine(HeadsetClientService context, HeadsetService headsetService,

                              Looper looper, NativeInterface nativeInterface) {

        super(TAG, looper);

        mService = context;

        mNativeInterface = nativeInterface;

        mAudioManager = mService.getAudioManager();

        mHeadsetService = headsetService;



        mVendorProcessor = new VendorCommandResponseProcessor(mService, mNativeInterface);
@@ -909,11 +912,12 @@ public class HeadsetClientStateMachine extends StateMachine { 
        setInitialState(mDisconnected);

    }



    static HeadsetClientStateMachine make(HeadsetClientService context, Looper looper,

                                          NativeInterface nativeInterface) {

    static HeadsetClientStateMachine make(HeadsetClientService context,

                                          HeadsetService headsetService,

                                          Looper looper, NativeInterface nativeInterface) {

        logD("make");

        HeadsetClientStateMachine hfcsm = new HeadsetClientStateMachine(context, looper,

                                                                        nativeInterface);

        HeadsetClientStateMachine hfcsm = new HeadsetClientStateMachine(context, headsetService,

                                                                        looper, nativeInterface);

        hfcsm.start();

        return hfcsm;

    }
@@ -1022,6 +1026,9 @@ public class HeadsetClientStateMachine extends StateMachine { 
                Log.e(TAG, "Disconnected: Illegal state transition from " + mPrevState.getName()

                        + " to Disconnected, mCurrentDevice=" + mCurrentDevice);

            }

            if (mHeadsetService != null && mCurrentDevice != null) {

                mHeadsetService.updateInbandRinging(mCurrentDevice, false);

            }

            mCurrentDevice = null;

        }
@@ -1309,6 +1316,9 @@ public class HeadsetClientStateMachine extends StateMachine { 
            if (mPrevState == mConnecting) {

                broadcastConnectionState(mCurrentDevice, BluetoothProfile.STATE_CONNECTED,

                        BluetoothProfile.STATE_CONNECTING);

                if (mHeadsetService != null) {

                    mHeadsetService.updateInbandRinging(mCurrentDevice, true);

                }

                MetricsLogger.logProfileConnectionEvent(

                        BluetoothMetricsProto.ProfileId.HEADSET_CLIENT);

            } else if (mPrevState != mAudioOn) {

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

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


import android.os.HandlerThread;



import com.android.bluetooth.hfp.HeadsetService;



// Factory so that StateMachine objected can be mocked

public class HeadsetClientStateMachineFactory {

    /**
@@ -26,6 +28,7 @@ public class HeadsetClientStateMachineFactory { 
     */

    public HeadsetClientStateMachine make(HeadsetClientService context, HandlerThread t,

            NativeInterface nativeInterface) {

        return HeadsetClientStateMachine.make(context, t.getLooper(), nativeInterface);

        return HeadsetClientStateMachine.make(context, HeadsetService.getHeadsetService(),

                t.getLooper(), nativeInterface);

    }

}

android/app/tests/unit/src/com/android/bluetooth/hfp/HeadsetServiceAndStateMachineTest.java

+23 −8
Original line number Diff line number Diff line
@@ -67,6 +67,7 @@ import org.mockito.ArgumentCaptor; 
import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.mockito.Spy;

import org.mockito.InOrder;



import java.lang.reflect.Method;

import java.util.Collections;
@@ -664,6 +665,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.setActiveDevice(device));

        verify(mNativeInterface).setActiveDevice(device);

        Assert.assertEquals(device, mHeadsetService.getActiveDevice());

        verify(mNativeInterface).sendBsir(eq(device), eq(true));

        // Start voice recognition

        startVoiceRecognitionFromHf(device);

    }
@@ -687,6 +689,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.setActiveDevice(device));

        verify(mNativeInterface).setActiveDevice(device);

        Assert.assertEquals(device, mHeadsetService.getActiveDevice());

        verify(mNativeInterface).sendBsir(eq(device), eq(true));

        // Start voice recognition

        startVoiceRecognitionFromHf(device);

        // Stop voice recognition
@@ -721,6 +724,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.setActiveDevice(device));

        verify(mNativeInterface).setActiveDevice(device);

        Assert.assertEquals(device, mHeadsetService.getActiveDevice());

        verify(mNativeInterface).sendBsir(eq(device), eq(true));

        // Start voice recognition

        HeadsetStackEvent startVrEvent =

                new HeadsetStackEvent(HeadsetStackEvent.EVENT_TYPE_VR_STATE_CHANGED,
@@ -753,6 +757,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.setActiveDevice(device));

        verify(mNativeInterface).setActiveDevice(device);

        Assert.assertEquals(device, mHeadsetService.getActiveDevice());

        verify(mNativeInterface).sendBsir(eq(device), eq(true));

        // Start voice recognition

        HeadsetStackEvent startVrEvent =

                new HeadsetStackEvent(HeadsetStackEvent.EVENT_TYPE_VR_STATE_CHANGED,
@@ -785,6 +790,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.setActiveDevice(device));

        verify(mNativeInterface).setActiveDevice(device);

        Assert.assertEquals(device, mHeadsetService.getActiveDevice());

        verify(mNativeInterface).sendBsir(eq(device), eq(true));

        // Start voice recognition

        startVoiceRecognitionFromAg();

    }
@@ -858,6 +864,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.setActiveDevice(device));

        verify(mNativeInterface).setActiveDevice(device);

        Assert.assertEquals(device, mHeadsetService.getActiveDevice());

        verify(mNativeInterface).sendBsir(eq(device), eq(true));

        // Start voice recognition

        startVoiceRecognitionFromAg();

        // Stop voice recognition
@@ -906,8 +913,10 @@ public class HeadsetServiceAndStateMachineTest { 
        connectTestDevice(deviceA);

        BluetoothDevice deviceB = TestUtils.getTestDevice(mAdapter, 1);

        connectTestDevice(deviceB);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceA, false);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceB, false);

        InOrder inOrder = inOrder(mNativeInterface);

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(true));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceB), eq(false));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(false));

        // Set active device to device B

        Assert.assertTrue(mHeadsetService.setActiveDevice(deviceB));

        verify(mNativeInterface).setActiveDevice(deviceB);
@@ -958,8 +967,10 @@ public class HeadsetServiceAndStateMachineTest { 
        connectTestDevice(deviceA);

        BluetoothDevice deviceB = TestUtils.getTestDevice(mAdapter, 1);

        connectTestDevice(deviceB);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceA, false);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceB, false);

        InOrder inOrder = inOrder(mNativeInterface);

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(true));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceB), eq(false));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(false));

        // Set active device to device B

        Assert.assertTrue(mHeadsetService.setActiveDevice(deviceB));

        verify(mNativeInterface).setActiveDevice(deviceB);
@@ -1010,8 +1021,10 @@ public class HeadsetServiceAndStateMachineTest { 
        connectTestDevice(deviceA);

        BluetoothDevice deviceB = TestUtils.getTestDevice(mAdapter, 1);

        connectTestDevice(deviceB);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceA, false);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceB, false);

        InOrder inOrder = inOrder(mNativeInterface);

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(true));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceB), eq(false));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(false));

        // Set active device to device B

        Assert.assertTrue(mHeadsetService.setActiveDevice(deviceB));

        verify(mNativeInterface).setActiveDevice(deviceB);
@@ -1049,8 +1062,10 @@ public class HeadsetServiceAndStateMachineTest { 
        connectTestDevice(deviceA);

        BluetoothDevice deviceB = TestUtils.getTestDevice(mAdapter, 1);

        connectTestDevice(deviceB);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceA, false);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).sendBsir(deviceB, false);

        InOrder inOrder = inOrder(mNativeInterface);

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(true));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceB), eq(false));

        inOrder.verify(mNativeInterface).sendBsir(eq(deviceA), eq(false));

        // Set active device to device B

        Assert.assertTrue(mHeadsetService.setActiveDevice(deviceB));

        verify(mNativeInterface).setActiveDevice(deviceB);

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

+20 −5
Original line number Diff line number Diff line
@@ -58,6 +58,7 @@ import com.android.bluetooth.R; 
import com.android.bluetooth.TestUtils;

import com.android.bluetooth.Utils;

import com.android.bluetooth.btservice.AdapterService;

import com.android.bluetooth.hfp.HeadsetService;

import com.android.bluetooth.hfp.HeadsetStackEvent;



import org.hamcrest.core.AllOf;
@@ -94,6 +95,8 @@ public class HeadsetClientStateMachineTest { 
    @Mock

    private Resources mMockHfpResources;

    @Mock

    private HeadsetService mHeadsetService;

    @Mock

    private HeadsetClientService mHeadsetClientService;

    @Mock

    private AudioManager mAudioManager;
@@ -138,7 +141,7 @@ public class HeadsetClientStateMachineTest { 
        mHandlerThread.start();

        // Manage looper execution in main test thread explicitly to guarantee timing consistency

        mHeadsetClientStateMachine = new TestHeadsetClientStateMachine(mHeadsetClientService,

                mHandlerThread.getLooper(), mNativeInterface);

                mHeadsetService, mHandlerThread.getLooper(), mNativeInterface);

        mHeadsetClientStateMachine.start();

        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

    }
@@ -149,10 +152,12 @@ public class HeadsetClientStateMachineTest { 
            return;

        }

        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        TestUtils.clearAdapterService(mAdapterService);

        mHeadsetClientStateMachine.allowConnect = null;

        mHeadsetClientStateMachine.doQuit();

        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        mHandlerThread.quit();

        TestUtils.clearAdapterService(mAdapterService);

        verifyNoMoreInteractions(mHeadsetService);

    }



    /**
@@ -245,6 +250,7 @@ public class HeadsetClientStateMachineTest { 
        // Check we are in connecting state now.

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),

                IsInstanceOf.instanceOf(HeadsetClientStateMachine.Connected.class));

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(true));

    }



    /**
@@ -287,6 +293,7 @@ public class HeadsetClientStateMachineTest { 
        // Check we are in connecting state now.

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),

                IsInstanceOf.instanceOf(HeadsetClientStateMachine.Disconnected.class));

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(false));

    }



    /**
@@ -338,6 +345,8 @@ public class HeadsetClientStateMachineTest { 
        Assert.assertEquals(BluetoothProfile.STATE_CONNECTED,

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



        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(true));



        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_IN_BAND_RINGTONE);

        event.valueInt = 0;

        event.device = mTestDevice;
@@ -455,6 +464,7 @@ public class HeadsetClientStateMachineTest { 
                intentArgument.getValue().getIntExtra(BluetoothProfile.EXTRA_STATE, -1));

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),

                IsInstanceOf.instanceOf(HeadsetClientStateMachine.Connected.class));

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(true));



        startBroadcastIndex++;

        return startBroadcastIndex;
@@ -1164,6 +1174,7 @@ public class HeadsetClientStateMachineTest { 
        sendMessageAndVerifyTransition(

                mHeadsetClientStateMachine.obtainMessage(StackEvent.STACK_EVENT, event),

                HeadsetClientStateMachine.Disconnected.class);

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(false));

    }



    @Test
@@ -1228,6 +1239,7 @@ public class HeadsetClientStateMachineTest { 
        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),

                IsInstanceOf.instanceOf(HeadsetClientStateMachine.Connected.class));

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(true));

    }



    @Test
@@ -1236,6 +1248,7 @@ public class HeadsetClientStateMachineTest { 
        Message msg = mHeadsetClientStateMachine

                .obtainMessage(HeadsetClientStateMachine.CONNECTING_TIMEOUT);

        sendMessageAndVerifyTransition(msg, HeadsetClientStateMachine.Disconnected.class);

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(false));

    }



    @Test
@@ -1324,6 +1337,7 @@ public class HeadsetClientStateMachineTest { 
        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),

                IsInstanceOf.instanceOf(HeadsetClientStateMachine.Disconnected.class));

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(false));

    }



    @Test
@@ -1369,6 +1383,7 @@ public class HeadsetClientStateMachineTest { 
        TestUtils.waitForLooperToFinishScheduledTask(mHandlerThread.getLooper());

        Assert.assertThat(mHeadsetClientStateMachine.getCurrentState(),

                IsInstanceOf.instanceOf(HeadsetClientStateMachine.Connected.class));

        verify(mHeadsetService).updateInbandRinging(eq(mTestDevice), eq(true));

    }



    private void initToAudioOnState() {
@@ -1399,9 +1414,9 @@ public class HeadsetClientStateMachineTest { 


        Boolean allowConnect = null;



        TestHeadsetClientStateMachine(HeadsetClientService context, Looper looper,

                NativeInterface nativeInterface) {

            super(context, looper, nativeInterface);

        TestHeadsetClientStateMachine(HeadsetClientService context, HeadsetService headsetService,

                Looper looper, NativeInterface nativeInterface) {

            super(context, headsetService, looper, nativeInterface);

        }



        public boolean doesSuperHaveDeferredMessages(int what) {