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

Commit 9c55ab85 authored by William Escande's avatar William Escande
Browse files

remove AudioManager.setParameters from bluetooth 

All the AudioManager.setParameters are an hack that we have to remove.

Bug: 196440888
Fix: 196440888
Tag: #refactor
Test: Build
Change-Id: Iac2206b49d63d6190e229ebcbb048134ec83fcbc
parent b8b29039

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

+3 −3
Original line number Diff line number Diff line
@@ -1645,7 +1645,7 @@ public class HeadsetService extends ProfileService { 
            // Suspend A2DP when call about is about to become active

            if (mActiveDevice != null && callState != HeadsetHalConstants.CALL_STATE_DISCONNECTED

                    && !mSystemInterface.isCallIdle() && isCallIdleBefore) {

                mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");

                mSystemInterface.getAudioManager().setA2dpSuspended(true);

            }

        });

        doForEachConnectedStateMachine(
@@ -1655,7 +1655,7 @@ public class HeadsetService extends ProfileService { 
            if (callState == HeadsetHalConstants.CALL_STATE_IDLE

                    && mSystemInterface.isCallIdle() && !isAudioOn()) {

                // Resume A2DP when call ended and SCO is not connected

                mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");

                mSystemInterface.getAudioManager().setA2dpSuspended(false);

            }

        });
@@ -1813,7 +1813,7 @@ public class HeadsetService extends ProfileService { 
                }

                // Unsuspend A2DP when SCO connection is gone and call state is idle

                if (mSystemInterface.isCallIdle()) {

                    mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");

                    mSystemInterface.getAudioManager().setA2dpSuspended(false);

                }

            }

        }

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

+22 −33
Original line number Diff line number Diff line
@@ -80,12 +80,6 @@ public class HeadsetStateMachine extends StateMachine { 
    private static final String TAG = "HeadsetStateMachine";

    private static final boolean DBG = false;



    private static final String HEADSET_NAME = "bt_headset_name";

    private static final String HEADSET_NREC = "bt_headset_nrec";

    private static final String HEADSET_WBS = "bt_wbs";

    private static final String HEADSET_AUDIO_FEATURE_ON = "on";

    private static final String HEADSET_AUDIO_FEATURE_OFF = "off";



    static final int CONNECT = 1;

    static final int DISCONNECT = 2;

    static final int CONNECT_AUDIO = 3;
@@ -143,8 +137,9 @@ public class HeadsetStateMachine extends StateMachine { 
    private HeadsetAgIndicatorEnableState mAgIndicatorEnableState;

    // The timestamp when the device entered connecting/connected state

    private long mConnectingTimestampMs = Long.MIN_VALUE;

    // Audio Parameters like NREC

    private final HashMap<String, String> mAudioParams = new HashMap<>();

    // Audio Parameters

    private boolean mHasNrecEnabled = false;

    private boolean mHasWbsEnabled = false;

    // AT Phone book keeps a group of states used by AT+CPBR commands

    private final AtPhonebook mPhonebook;

    // HSP specific
@@ -221,7 +216,8 @@ public class HeadsetStateMachine extends StateMachine { 
        if (mPhonebook != null) {

            mPhonebook.cleanup();

        }

        mAudioParams.clear();

        mHasWbsEnabled = false;

        mHasNrecEnabled = false;

    }



    public void dump(StringBuilder sb) {
@@ -316,8 +312,7 @@ public class HeadsetStateMachine extends StateMachine { 
            BluetoothStatsLog.write(BluetoothStatsLog.BLUETOOTH_SCO_CONNECTION_STATE_CHANGED,

                    mAdapterService.obfuscateAddress(device),

                    getConnectionStateFromAudioState(toState),

                    TextUtils.equals(mAudioParams.get(HEADSET_WBS), HEADSET_AUDIO_FEATURE_ON)

                            ? BluetoothHfpProtoEnums.SCO_CODEC_MSBC

                    mHasWbsEnabled ? BluetoothHfpProtoEnums.SCO_CODEC_MSBC

                            : BluetoothHfpProtoEnums.SCO_CODEC_CVSD,

                    mAdapterService.getMetricId(device));

            mHeadsetService.onAudioStateChangedFromStateMachine(device, fromState, toState);
@@ -450,7 +445,8 @@ public class HeadsetStateMachine extends StateMachine { 
            mPhonebook.resetAtState();

            updateAgIndicatorEnableState(null);

            mNeedDialingOutReply = false;

            mAudioParams.clear();

            mHasWbsEnabled = false;

            mHasNrecEnabled = false;

            broadcastStateTransitions();

            // Remove the state machine for unbonded devices

            if (mPrevState != null
@@ -1073,9 +1069,9 @@ public class HeadsetStateMachine extends StateMachine { 
                break;

                case CONNECT_AUDIO:

                    stateLogD("CONNECT_AUDIO, device=" + mDevice);

                    mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");

                    mSystemInterface.getAudioManager().setA2dpSuspended(true);

                    if (!mNativeInterface.connectAudio(mDevice)) {

                        mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");

                        mSystemInterface.getAudioManager().setA2dpSuspended(false);

                        stateLogE("Failed to connect SCO audio for " + mDevice);

                        // No state change involved, fire broadcast immediately

                        broadcastAudioState(mDevice, BluetoothHeadset.STATE_AUDIO_DISCONNECTED,
@@ -1508,15 +1504,12 @@ public class HeadsetStateMachine extends StateMachine { 
    }



    private void setAudioParameters() {

        String keyValuePairs = String.join(";", new String[]{

                HEADSET_NAME + "=" + getCurrentDeviceName(),

                HEADSET_NREC + "=" + mAudioParams.getOrDefault(HEADSET_NREC,

                        HEADSET_AUDIO_FEATURE_OFF),

                HEADSET_WBS + "=" + mAudioParams.getOrDefault(HEADSET_WBS,

                        HEADSET_AUDIO_FEATURE_OFF)

        });

        Log.i(TAG, "setAudioParameters for " + mDevice + ": " + keyValuePairs);

        mSystemInterface.getAudioManager().setParameters(keyValuePairs);

        AudioManager am = mSystemInterface.getAudioManager();

        Log.i(TAG, "setAudioParameters for " + mDevice + ":"

                + " Name=" + getCurrentDeviceName()

                + " hasNrecEnabled=" + mHasNrecEnabled

                + " hasWbsEnabled=" + mHasWbsEnabled);

        am.setBluetoothHeadsetProperties(getCurrentDeviceName(), mHasNrecEnabled, mHasWbsEnabled);

    }



    private String parseUnknownAt(String atString) {
@@ -1645,32 +1638,28 @@ public class HeadsetStateMachine extends StateMachine { 
    }



    private void processNoiseReductionEvent(boolean enable) {

        String prevNrec = mAudioParams.getOrDefault(HEADSET_NREC, HEADSET_AUDIO_FEATURE_OFF);

        String newNrec = enable ? HEADSET_AUDIO_FEATURE_ON : HEADSET_AUDIO_FEATURE_OFF;

        mAudioParams.put(HEADSET_NREC, newNrec);

        log("processNoiseReductionEvent: " + HEADSET_NREC + " change " + prevNrec + " -> "

                + newNrec);

        log("processNoiseReductionEvent: " + mHasNrecEnabled + " -> " + enable);

        mHasNrecEnabled = enable;

        if (getAudioState() == BluetoothHeadset.STATE_AUDIO_CONNECTED) {

            setAudioParameters();

        }

    }



    private void processWBSEvent(int wbsConfig) {

        String prevWbs = mAudioParams.getOrDefault(HEADSET_WBS, HEADSET_AUDIO_FEATURE_OFF);

        boolean prevWbs = mHasWbsEnabled;

        switch (wbsConfig) {

            case HeadsetHalConstants.BTHF_WBS_YES:

                mAudioParams.put(HEADSET_WBS, HEADSET_AUDIO_FEATURE_ON);

                mHasWbsEnabled = true;

                break;

            case HeadsetHalConstants.BTHF_WBS_NO:

            case HeadsetHalConstants.BTHF_WBS_NONE:

                mAudioParams.put(HEADSET_WBS, HEADSET_AUDIO_FEATURE_OFF);

                mHasWbsEnabled = false;

                break;

            default:

                Log.e(TAG, "processWBSEvent: unknown wbsConfig " + wbsConfig);

                return;

        }

        log("processWBSEvent: " + HEADSET_NREC + " change " + prevWbs + " -> " + mAudioParams.get(

                HEADSET_WBS));

        log("processWBSEvent: " + prevWbs + " -> " + mHasWbsEnabled);

    }



    @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)

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

+2 −2
Original line number Diff line number Diff line
@@ -111,7 +111,7 @@ public class HeadsetClientService extends ProfileService { 
                Log.e(TAG, "AudioManager service doesn't exist?");

            } else {

                // start AudioManager in a known state

                mAudioManager.setParameters("hfp_enable=false");

                mAudioManager.setHfpEnabled(false);

            }



            mSmFactory = new HeadsetClientStateMachineFactory();
@@ -200,7 +200,7 @@ public class HeadsetClientService extends ProfileService { 
                                "Setting volume to audio manager: " + streamValue + " hands free: "

                                        + hfVol);

                    }

                    mAudioManager.setParameters("hfp_volume=" + hfVol);

                    mAudioManager.setHfpVolume(hfVol);

                    synchronized (mStateMachineMap) {

                        for (HeadsetClientStateMachine sm : mStateMachineMap.values()) {

                            if (sm != null) {

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

+6 −6
Original line number Diff line number Diff line
@@ -813,9 +813,9 @@ public class HeadsetClientStateMachine extends StateMachine { 
        }

        logD("hfp_enable=" + enable);

        if (enable && !sAudioIsRouted) {

            mAudioManager.setParameters("hfp_enable=true");

            mAudioManager.setHfpEnabled(true);

        } else if (!enable) {

            mAudioManager.setParameters("hfp_enable=false");

            mAudioManager.setHfpEnabled(false);

        }

        sAudioIsRouted = enable;

    }
@@ -1583,7 +1583,7 @@ public class HeadsetClientStateMachine extends StateMachine { 
                    // routing is handled by the bluetooth stack itself. The only reason to do so is

                    // because Bluetooth SCO connection from the HF role is not entirely supported

                    // for routing and volume purposes.

                    // NOTE: All calls here are routed via the setParameters which changes the

                    // NOTE: All calls here are routed via AudioManager methods which changes the

                    // routing at the Audio HAL level.



                    if (mService.isScoRouted()) {
@@ -1605,15 +1605,15 @@ public class HeadsetClientStateMachine extends StateMachine { 
                    logD("hfp_enable=true mAudioWbs is " + mAudioWbs);

                    if (mAudioWbs) {

                        logD("Setting sampling rate as 16000");

                        mAudioManager.setParameters("hfp_set_sampling_rate=16000");

                        mAudioManager.setHfpSamplingRate(16000);

                    } else {

                        logD("Setting sampling rate as 8000");

                        mAudioManager.setParameters("hfp_set_sampling_rate=8000");

                        mAudioManager.setHfpSamplingRate(8000);

                    }

                    logD("hf_volume " + hfVol);

                    routeHfpAudio(true);

                    mAudioFocusRequest = requestAudioFocus();

                    mAudioManager.setParameters("hfp_volume=" + hfVol);

                    mAudioManager.setHfpVolume(hfVol);

                    transitionTo(mAudioOn);

                    break;

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

+5 −10
Original line number Diff line number Diff line
@@ -954,8 +954,7 @@ public class HeadsetServiceAndStateMachineTest { 
        mHeadsetService.startVoiceRecognition(deviceA);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).atResponseCode(deviceA,

                HeadsetHalConstants.AT_RESPONSE_OK, 0);

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS))

                .setParameters("A2dpSuspended=true");

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).setA2dpSuspended(true);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).connectAudio(deviceA);

        verifyNoMoreInteractions(mNativeInterface);

    }
@@ -1008,8 +1007,7 @@ public class HeadsetServiceAndStateMachineTest { 
        // We still continue on the initiating HF

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).atResponseCode(deviceA,

                HeadsetHalConstants.AT_RESPONSE_OK, 0);

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS))

                .setParameters("A2dpSuspended=true");

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).setA2dpSuspended(true);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).connectAudio(deviceA);

        verifyNoMoreInteractions(mNativeInterface);

    }
@@ -1084,8 +1082,7 @@ public class HeadsetServiceAndStateMachineTest { 
        verify(mNativeInterface).setActiveDevice(deviceA);

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

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).startVoiceRecognition(deviceA);

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS))

                .setParameters("A2dpSuspended=true");

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).setA2dpSuspended(true);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).connectAudio(deviceA);

        waitAndVerifyAudioStateIntent(ASYNC_CALL_TIMEOUT_MILLIS, deviceA,

                BluetoothHeadset.STATE_AUDIO_CONNECTING, BluetoothHeadset.STATE_AUDIO_DISCONNECTED);
@@ -1133,8 +1130,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertTrue(mHeadsetService.startVoiceRecognition(device));

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).atResponseCode(device,

                HeadsetHalConstants.AT_RESPONSE_OK, 0);

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS))

                .setParameters("A2dpSuspended=true");

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).setA2dpSuspended(true);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).connectAudio(device);

        waitAndVerifyAudioStateIntent(ASYNC_CALL_TIMEOUT_MILLIS, device,

                BluetoothHeadset.STATE_AUDIO_CONNECTING, BluetoothHeadset.STATE_AUDIO_DISCONNECTED);
@@ -1151,8 +1147,7 @@ public class HeadsetServiceAndStateMachineTest { 
        Assert.assertNotNull(device);

        Assert.assertTrue(mHeadsetService.startVoiceRecognition(device));

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).startVoiceRecognition(device);

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS))

                .setParameters("A2dpSuspended=true");

        verify(mAudioManager, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).setA2dpSuspended(true);

        verify(mNativeInterface, timeout(ASYNC_CALL_TIMEOUT_MILLIS)).connectAudio(device);

        waitAndVerifyAudioStateIntent(ASYNC_CALL_TIMEOUT_MILLIS, device,

                BluetoothHeadset.STATE_AUDIO_CONNECTING, BluetoothHeadset.STATE_AUDIO_DISCONNECTED);