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

Commit c1571d86 authored by William Escande's avatar William Escande
Browse files

VolumeControl: rm impossible null handler 

Use final & injected dependency
Update test to TestLooper & truth
Split test to actionable smaller test
Apply up to date java recommendation

Bug: 368527278
Bug: 367133232
Test: atest BluetoothInstrumentationTests:VolumeControlServiceTest
Test: atest BluetoothInstrumentationTests:VolumeControlStateMachineTest
Flag: Exempt refactor no-op
Change-Id: I15a9122a10abbd4ed598a1af5b8a8902967b9135
parent a0556794

android/app/src/com/android/bluetooth/vc/VolumeControlService.java

+100 −138
Original line number Diff line number Diff line
@@ -19,6 +19,14 @@ package com.android.bluetooth.vc; 


import static android.Manifest.permission.BLUETOOTH_CONNECT;

import static android.Manifest.permission.BLUETOOTH_PRIVILEGED;

import static android.bluetooth.BluetoothDevice.BOND_BONDED;

import static android.bluetooth.BluetoothDevice.BOND_NONE;

import static android.bluetooth.BluetoothProfile.CONNECTION_POLICY_ALLOWED;

import static android.bluetooth.BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;

import static android.bluetooth.BluetoothProfile.CONNECTION_POLICY_UNKNOWN;

import static android.bluetooth.BluetoothProfile.STATE_CONNECTED;

import static android.bluetooth.BluetoothProfile.STATE_CONNECTING;

import static android.bluetooth.BluetoothProfile.STATE_DISCONNECTED;



import static java.util.Objects.requireNonNull;
@@ -31,7 +39,6 @@ import android.bluetooth.IBluetoothLeAudio; 
import android.bluetooth.IBluetoothVolumeControl;

import android.bluetooth.IBluetoothVolumeControlCallback;

import android.content.AttributionSource;

import android.content.Context;

import android.media.AudioManager;

import android.os.Handler;

import android.os.HandlerThread;
@@ -70,27 +77,28 @@ import java.util.concurrent.TimeUnit; 
import java.util.concurrent.TimeoutException;



public class VolumeControlService extends ProfileService {

    private static final String TAG = "VolumeControlService";

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



    // Timeout for state machine thread join, to prevent potential ANR.

    private static final int SM_THREAD_JOIN_TIMEOUT_MS = 1000;



    private static final int LE_AUDIO_MAX_VOL = 255;

    /* As defined by Volume Control Service 1.0.1, 3.3.1. Volume Flags behavior.

     * User Set Volume Setting means that remote keeps volume in its cache. */

    @VisibleForTesting static final int VOLUME_FLAGS_PERSISTED_USER_SET_VOLUME_MASK = 0x01;



    private static VolumeControlService sVolumeControlService;



    private AdapterService mAdapterService;

    private DatabaseManager mDatabaseManager;

    private HandlerThread mStateMachinesThread;

    private Handler mHandler = null;



    @VisibleForTesting

    @GuardedBy("mCallbacks")

    final RemoteCallbackList<IBluetoothVolumeControlCallback> mCallbacks =

            new RemoteCallbackList<>();



    VolumeControlNativeInterface mVolumeControlNativeInterface;

    @VisibleForTesting AudioManager mAudioManager;

    private final AdapterService mAdapterService;

    private final AudioManager mAudioManager;

    private final DatabaseManager mDatabaseManager;

    private final Handler mHandler;

    private final HandlerThread mStateMachinesThread;

    private final Looper mStateMachinesLooper;

    private final VolumeControlNativeInterface mNativeInterface;



    private final Map<BluetoothDevice, VolumeControlStateMachine> mStateMachines = new HashMap<>();

    private final Map<BluetoothDevice, VolumeControlOffsetDescriptor> mAudioOffsets =
@@ -100,15 +108,34 @@ public class VolumeControlService extends ProfileService { 
    private final Map<Integer, Boolean> mGroupMuteCache = new HashMap<>();

    private final Map<BluetoothDevice, Integer> mDeviceVolumeCache = new HashMap<>();



    /* As defined by Volume Control Service 1.0.1, 3.3.1. Volume Flags behavior.

     * User Set Volume Setting means that remote keeps volume in its cache.

     */

    @VisibleForTesting static final int VOLUME_FLAGS_PERSISTED_USER_SET_VOLUME_MASK = 0x01;



    @VisibleForTesting ServiceFactory mFactory = new ServiceFactory();



    public VolumeControlService(Context ctx) {

        super(ctx);

    public VolumeControlService(AdapterService adapterService) {

        this(adapterService, null, VolumeControlNativeInterface.getInstance());

    }



    @VisibleForTesting

    VolumeControlService(

            AdapterService adapterService,

            Looper looper,

            VolumeControlNativeInterface nativeInterface) {

        super(requireNonNull(adapterService));

        mAdapterService = adapterService;

        mDatabaseManager = requireNonNull(mAdapterService.getDatabase());

        mNativeInterface = requireNonNull(nativeInterface);

        mAudioManager = requireNonNull(getSystemService(AudioManager.class));

        if (looper == null) {

            mHandler = new Handler(requireNonNull(Looper.getMainLooper()));

            mStateMachinesThread = new HandlerThread("VolumeControlService.StateMachines");

            mStateMachinesThread.start();

            mStateMachinesLooper = mStateMachinesThread.getLooper();

        } else {

            mHandler = new Handler(looper);

            mStateMachinesThread = null;

            mStateMachinesLooper = looper;

        }

        setVolumeControlService(this);

        mNativeInterface.init();

    }



    public static boolean isEnabled() {
@@ -120,45 +147,9 @@ public class VolumeControlService extends ProfileService { 
        return new BluetoothVolumeControlBinder(this);

    }



    @Override

    public void start() {

        Log.d(TAG, "start()");

        if (sVolumeControlService != null) {

            throw new IllegalStateException("start() called twice");

        }



        // Get AdapterService, VolumeControlNativeInterface, DatabaseManager, AudioManager.

        // None of them can be null.

        mAdapterService = requireNonNull(AdapterService.getAdapterService());

        mDatabaseManager = requireNonNull(mAdapterService.getDatabase());

        mVolumeControlNativeInterface = requireNonNull(VolumeControlNativeInterface.getInstance());

        mAudioManager = requireNonNull(getSystemService(AudioManager.class));



        // Start handler thread for state machines

        mHandler = new Handler(Looper.getMainLooper());

        mStateMachines.clear();

        mStateMachinesThread = new HandlerThread("VolumeControlService.StateMachines");

        mStateMachinesThread.start();



        mAudioOffsets.clear();

        mGroupVolumeCache.clear();

        mGroupMuteCache.clear();

        mDeviceVolumeCache.clear();



        // Mark service as started

        setVolumeControlService(this);



        // Initialize native interface

        mVolumeControlNativeInterface.init();

    }



    @Override

    public void stop() {

        Log.d(TAG, "stop()");

        if (sVolumeControlService == null) {

            Log.w(TAG, "stop() called before start()");

            return;

        }



        // Mark service as stopped

        setVolumeControlService(null);
@@ -167,7 +158,6 @@ public class VolumeControlService extends ProfileService { 
        synchronized (mStateMachines) {

            for (VolumeControlStateMachine sm : mStateMachines.values()) {

                sm.doQuit();

                sm.cleanup();

            }

            mStateMachines.clear();

        }
@@ -176,43 +166,25 @@ public class VolumeControlService extends ProfileService { 
            try {

                mStateMachinesThread.quitSafely();

                mStateMachinesThread.join(SM_THREAD_JOIN_TIMEOUT_MS);

                mStateMachinesThread = null;

            } catch (InterruptedException e) {

                // Do not rethrow as we are shutting down anyway

            }

        }



        // Unregister handler and remove all queued messages.

        if (mHandler != null) {

        mHandler.removeCallbacksAndMessages(null);

            mHandler = null;

        }



        // Cleanup native interface

        mVolumeControlNativeInterface.cleanup();

        mVolumeControlNativeInterface = null;

        mNativeInterface.cleanup();



        mAudioOffsets.clear();

        mGroupVolumeCache.clear();

        mGroupMuteCache.clear();

        mDeviceVolumeCache.clear();



        // Clear AdapterService, VolumeControlNativeInterface

        mAudioManager = null;

        mVolumeControlNativeInterface = null;

        mAdapterService = null;



        synchronized (mCallbacks) {

            if (mCallbacks != null) {

            mCallbacks.kill();

        }

    }

    }



    @Override

    public void cleanup() {

        Log.d(TAG, "cleanup()");

    }



    /**

     * Get the VolumeControlService instance
@@ -244,7 +216,7 @@ public class VolumeControlService extends ProfileService { 
            return false;

        }



        if (getConnectionPolicy(device) == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

        if (getConnectionPolicy(device) == CONNECTION_POLICY_FORBIDDEN) {

            return false;

        }

        final ParcelUuid[] featureUuids = mAdapterService.getRemoteUuids(device);
@@ -260,7 +232,7 @@ public class VolumeControlService extends ProfileService { 
            if (smConnect == null) {

                Log.e(TAG, "Cannot connect to " + device + " : no state machine");

            }

            smConnect.sendMessage(VolumeControlStateMachine.CONNECT);

            smConnect.sendMessage(VolumeControlStateMachine.MESSAGE_CONNECT);

        }



        return true;
@@ -274,7 +246,7 @@ public class VolumeControlService extends ProfileService { 
        synchronized (mStateMachines) {

            VolumeControlStateMachine sm = getOrCreateStateMachine(device);

            if (sm != null) {

                sm.sendMessage(VolumeControlStateMachine.DISCONNECT);

                sm.sendMessage(VolumeControlStateMachine.MESSAGE_DISCONNECT);

            }

        }
@@ -317,11 +289,11 @@ public class VolumeControlService extends ProfileService { 
        int bondState = mAdapterService.getBondState(device);

        // Allow this connection only if the device is bonded. Any attempt to connect while

        // bonding would potentially lead to an unauthorized connection.

        if (bondState != BluetoothDevice.BOND_BONDED) {

        if (bondState != BOND_BONDED) {

            Log.w(TAG, "okToConnect: return false, bondState=" + bondState);

            return false;

        } else if (connectionPolicy != BluetoothProfile.CONNECTION_POLICY_UNKNOWN

                && connectionPolicy != BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

        } else if (connectionPolicy != CONNECTION_POLICY_UNKNOWN

                && connectionPolicy != CONNECTION_POLICY_ALLOWED) {

            // Otherwise, reject the connection if connectionPolicy is not valid.

            Log.w(TAG, "okToConnect: return false, connectionPolicy=" + connectionPolicy);

            return false;
@@ -344,7 +316,7 @@ public class VolumeControlService extends ProfileService { 
                if (!Utils.arrayContains(featureUuids, BluetoothUuid.VOLUME_CONTROL)) {

                    continue;

                }

                int connectionState = BluetoothProfile.STATE_DISCONNECTED;

                int connectionState = STATE_DISCONNECTED;

                VolumeControlStateMachine sm = mStateMachines.get(device);

                if (sm != null) {

                    connectionState = sm.getConnectionState();
@@ -380,7 +352,7 @@ public class VolumeControlService extends ProfileService { 
        synchronized (mStateMachines) {

            VolumeControlStateMachine sm = mStateMachines.get(device);

            if (sm == null) {

                return BluetoothProfile.STATE_DISCONNECTED;

                return STATE_DISCONNECTED;

            }

            return sm.getConnectionState();

        }
@@ -404,9 +376,9 @@ public class VolumeControlService extends ProfileService { 
        Log.d(TAG, "Saved connectionPolicy " + device + " = " + connectionPolicy);

        mDatabaseManager.setProfileConnectionPolicy(

                device, BluetoothProfile.VOLUME_CONTROL, connectionPolicy);

        if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED) {

        if (connectionPolicy == CONNECTION_POLICY_ALLOWED) {

            connect(device);

        } else if (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {

        } else if (connectionPolicy == CONNECTION_POLICY_FORBIDDEN) {

            disconnect(device);

        }

        return true;
@@ -465,7 +437,7 @@ public class VolumeControlService extends ProfileService { 
            return;

        }



        mVolumeControlNativeInterface.setExtAudioOutVolumeOffset(device, instanceId, volumeOffset);

        mNativeInterface.setExtAudioOutVolumeOffset(device, instanceId, volumeOffset);

    }



    void setDeviceVolume(BluetoothDevice device, int volume, boolean isGroupOp) {
@@ -489,7 +461,7 @@ public class VolumeControlService extends ProfileService { 
        } else {

            Log.i(TAG, "Setting individual device volume");

            mDeviceVolumeCache.put(device, volume);

            mVolumeControlNativeInterface.setVolume(device, volume);

            mNativeInterface.setVolume(device, volume);

        }

    }
@@ -500,7 +472,7 @@ public class VolumeControlService extends ProfileService { 
        }



        mGroupVolumeCache.put(groupId, volume);

        mVolumeControlNativeInterface.setGroupVolume(groupId, volume);

        mNativeInterface.setGroupVolume(groupId, volume);



        // We only receive the volume change and mute state needs to be acquired manually

        Boolean isGroupMute = mGroupMuteCache.getOrDefault(groupId, false);
@@ -508,7 +480,7 @@ public class VolumeControlService extends ProfileService { 


        /* Note: AudioService keeps volume levels for each stream and for each device type,

         * however it stores the mute state only for the stream type but not for each individual

         * device type. When active device changes, it's volume level gets aplied, but mute state

         * device type. When active device changes, it's volume level gets applied, but mute state

         * is not, but can be either derived from the volume level or just unmuted like for A2DP.

         * Also setting volume level > 0 to audio system will implicitly unmute the stream.

         * However LeAudio devices can keep their volume level high, while keeping it mute so we
@@ -580,21 +552,21 @@ public class VolumeControlService extends ProfileService { 
    }



    public void mute(BluetoothDevice device) {

        mVolumeControlNativeInterface.mute(device);

        mNativeInterface.mute(device);

    }



    public void muteGroup(int groupId) {

        mGroupMuteCache.put(groupId, true);

        mVolumeControlNativeInterface.muteGroup(groupId);

        mNativeInterface.muteGroup(groupId);

    }



    public void unmute(BluetoothDevice device) {

        mVolumeControlNativeInterface.unmute(device);

        mNativeInterface.unmute(device);

    }



    public void unmuteGroup(int groupId) {

        mGroupMuteCache.put(groupId, false);

        mVolumeControlNativeInterface.unmuteGroup(groupId);

        mNativeInterface.unmuteGroup(groupId);

    }



    void notifyNewCallbackOfKnownVolumeInfo(IBluetoothVolumeControlCallback callback) {
@@ -670,7 +642,7 @@ public class VolumeControlService extends ProfileService { 
            if (sm == null) {

                return;

            }

            if (sm.getConnectionState() != BluetoothProfile.STATE_CONNECTED) {

            if (sm.getConnectionState() != STATE_CONNECTED) {

                return;

            }

        }
@@ -680,7 +652,7 @@ public class VolumeControlService extends ProfileService { 
        synchronized (mStateMachines) {

            VolumeControlStateMachine sm = mStateMachines.get(device);

            if (sm != null) {

                can_change_volume = (sm.getConnectionState() == BluetoothProfile.STATE_CONNECTED);

                can_change_volume = (sm.getConnectionState() == STATE_CONNECTED);

            }

        }
@@ -691,15 +663,15 @@ public class VolumeControlService extends ProfileService { 
                            groupId, IBluetoothVolumeControl.VOLUME_CONTROL_UNKNOWN_VOLUME);

            if (groupVolume != IBluetoothVolumeControl.VOLUME_CONTROL_UNKNOWN_VOLUME) {

                Log.i(TAG, "Setting value:" + groupVolume + " to " + device);

                mVolumeControlNativeInterface.setVolume(device, groupVolume);

                mNativeInterface.setVolume(device, groupVolume);

            }



            Boolean isGroupMuted = mGroupMuteCache.getOrDefault(groupId, false);

            Log.i(TAG, "Setting mute:" + isGroupMuted + " to " + device);

            if (isGroupMuted) {

                mVolumeControlNativeInterface.mute(device);

                mNativeInterface.mute(device);

            } else {

                mVolumeControlNativeInterface.unmute(device);

                mNativeInterface.unmute(device);

            }

        }

    }
@@ -865,21 +837,20 @@ public class VolumeControlService extends ProfileService { 
                synchronized (mStateMachines) {

                    VolumeControlStateMachine sm = mStateMachines.get(device);

                    if (sm != null) {

                        can_change_volume =

                                (sm.getConnectionState() == BluetoothProfile.STATE_CONNECTED);

                        can_change_volume = (sm.getConnectionState() == STATE_CONNECTED);

                    }

                }



                if (can_change_volume && (groupVolume != volume)) {

                    Log.i(TAG, "Setting value:" + groupVolume + " to " + device);

                    mVolumeControlNativeInterface.setVolume(device, groupVolume);

                    mNativeInterface.setVolume(device, groupVolume);

                }

                if (can_change_volume && (groupMute != mute)) {

                    Log.i(TAG, "Setting mute:" + groupMute + " to " + device);

                    if (groupMute) {

                        mVolumeControlNativeInterface.mute(device);

                        mNativeInterface.mute(device);

                    } else {

                        mVolumeControlNativeInterface.unmute(device);

                        mNativeInterface.unmute(device);

                    }

                }

            } else {
@@ -925,19 +896,16 @@ public class VolumeControlService extends ProfileService { 


        Log.d(TAG, "Volume mode: " + mode + "0: normal, 1: ring, 2,3: call");



        switch (mode) {

            case AudioManager.MODE_IN_COMMUNICATION:

            case AudioManager.MODE_IN_CALL:

                return AudioManager.STREAM_VOICE_CALL;

            case AudioManager.MODE_RINGTONE:

        return switch (mode) {

            case AudioManager.MODE_IN_CALL, AudioManager.MODE_IN_COMMUNICATION -> {

                yield AudioManager.STREAM_VOICE_CALL;

            }

            case AudioManager.MODE_RINGTONE -> {

                Log.d(TAG, " Update during ringtone applied to voice call");

                return AudioManager.STREAM_VOICE_CALL;

            case AudioManager.MODE_NORMAL:

            default:

                // other conditions will influence the stream type choice, read on...

                break;

                yield AudioManager.STREAM_VOICE_CALL;

            }

        return AudioManager.STREAM_MUSIC;

            default -> AudioManager.STREAM_MUSIC;

        };

    }



    void handleExternalOutputs(BluetoothDevice device, int numberOfExternalOutputs) {
@@ -1277,12 +1245,9 @@ public class VolumeControlService extends ProfileService { 
                if (stackEvent.type

                        == VolumeControlStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED) {

                    switch (stackEvent.valueInt1) {

                        case VolumeControlStackEvent.CONNECTION_STATE_CONNECTED:

                        case VolumeControlStackEvent.CONNECTION_STATE_CONNECTING:

                        case STATE_CONNECTED, STATE_CONNECTING -> {

                            sm = getOrCreateStateMachine(device);

                            break;

                        default:

                            break;

                        }

                    }

                }

            }
@@ -1290,7 +1255,7 @@ public class VolumeControlService extends ProfileService { 
                Log.e(TAG, "Cannot process stack event: no state machine: " + stackEvent);

                return;

            }

            sm.sendMessage(VolumeControlStateMachine.STACK_EVENT, stackEvent);

            sm.sendMessage(VolumeControlStateMachine.MESSAGE_STACK_EVENT, stackEvent);

        }

    }
@@ -1307,11 +1272,9 @@ public class VolumeControlService extends ProfileService { 


            Log.d(TAG, "Creating a new state machine for " + device);

            sm =

                    VolumeControlStateMachine.make(

                            device,

                            this,

                            mVolumeControlNativeInterface,

                            mStateMachinesThread.getLooper());

                    new VolumeControlStateMachine(

                            this, device, mNativeInterface, mStateMachinesLooper);

            sm.start();

            mStateMachines.put(device, sm);

            return sm;

        }
@@ -1392,7 +1355,7 @@ public class VolumeControlService extends ProfileService { 
    void bondStateChanged(BluetoothDevice device, int bondState) {

        Log.d(TAG, "Bond state changed for device: " + device + " state: " + bondState);

        // Remove state machine if the bonding for a device is removed

        if (bondState != BluetoothDevice.BOND_NONE) {

        if (bondState != BOND_NONE) {

            return;

        }
@@ -1401,7 +1364,7 @@ public class VolumeControlService extends ProfileService { 
            if (sm == null) {

                return;

            }

            if (sm.getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) {

            if (sm.getConnectionState() != STATE_DISCONNECTED) {

                Log.i(TAG, "Disconnecting device because it was unbonded.");

                disconnect(device);

                return;
@@ -1421,7 +1384,6 @@ public class VolumeControlService extends ProfileService { 
            }

            Log.i(TAG, "removeStateMachine: removing state machine for device: " + device);

            sm.doQuit();

            sm.cleanup();

            mStateMachines.remove(device);

        }

    }
@@ -1450,13 +1412,13 @@ public class VolumeControlService extends ProfileService { 
        }



        // Check if the device is disconnected - if unbond, remove the state machine

        if (toState == BluetoothProfile.STATE_DISCONNECTED) {

        if (toState == STATE_DISCONNECTED) {

            int bondState = mAdapterService.getBondState(device);

            if (bondState == BluetoothDevice.BOND_NONE) {

            if (bondState == BOND_NONE) {

                Log.d(TAG, device + " is unbond. Remove state machine");

                removeStateMachine(device);

            }

        } else if (toState == BluetoothProfile.STATE_CONNECTED) {

        } else if (toState == STATE_CONNECTED) {

            // Restore the group volume if it was changed while the device was not yet connected.

            CsipSetCoordinatorService csipClient = mFactory.getCsipSetCoordinatorService();

            if (csipClient != null) {
@@ -1466,14 +1428,14 @@ public class VolumeControlService extends ProfileService { 
                            mGroupVolumeCache.getOrDefault(

                                    groupId, IBluetoothVolumeControl.VOLUME_CONTROL_UNKNOWN_VOLUME);

                    if (groupVolume != IBluetoothVolumeControl.VOLUME_CONTROL_UNKNOWN_VOLUME) {

                        mVolumeControlNativeInterface.setVolume(device, groupVolume);

                        mNativeInterface.setVolume(device, groupVolume);

                    }



                    Boolean groupMute = mGroupMuteCache.getOrDefault(groupId, false);

                    if (groupMute) {

                        mVolumeControlNativeInterface.mute(device);

                        mNativeInterface.mute(device);

                    } else {

                        mVolumeControlNativeInterface.unmute(device);

                        mNativeInterface.unmute(device);

                    }

                }

            } else {
@@ -1554,7 +1516,7 @@ public class VolumeControlService extends ProfileService { 


            VolumeControlService service = getService(source);

            if (service == null) {

                return BluetoothProfile.STATE_DISCONNECTED;

                return STATE_DISCONNECTED;

            }



            return service.getConnectionState(device);
@@ -1580,7 +1542,7 @@ public class VolumeControlService extends ProfileService { 


            VolumeControlService service = getService(source);

            if (service == null) {

                return BluetoothProfile.CONNECTION_POLICY_UNKNOWN;

                return CONNECTION_POLICY_UNKNOWN;

            }



            service.enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED, null);

android/app/src/com/android/bluetooth/vc/VolumeControlStackEvent.java

+3 −31
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
package com.android.bluetooth.vc;



import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothProfile;



public class VolumeControlStackEvent {

    // Event types for STACK_EVENT message (coming from native)
@@ -34,13 +35,6 @@ public class VolumeControlStackEvent { 
    public static final int EVENT_TYPE_EXT_AUDIO_IN_DESCR_CHANGED = 10;

    public static final int EVENT_TYPE_EXT_AUDIO_IN_GAIN_PROPS_CHANGED = 11;



    // Do not modify without updating the HAL bt_vc_aid.h files.

    // Match up with enum class ConnectionState of bt_vc_aid.h.

    static final int CONNECTION_STATE_DISCONNECTED = 0;

    static final int CONNECTION_STATE_CONNECTING = 1;

    static final int CONNECTION_STATE_CONNECTED = 2;

    static final int CONNECTION_STATE_DISCONNECTING = 3;



    public int type;

    public BluetoothDevice device;

    public int valueInt1;
@@ -108,18 +102,7 @@ public class VolumeControlStackEvent { 
    private static String eventTypeValue1ToString(int type, int value) {

        switch (type) {

            case EVENT_TYPE_CONNECTION_STATE_CHANGED:

                switch (value) {

                    case CONNECTION_STATE_DISCONNECTED:

                        return "CONNECTION_STATE_DISCONNECTED";

                    case CONNECTION_STATE_CONNECTING:

                        return "CONNECTION_STATE_CONNECTING";

                    case CONNECTION_STATE_CONNECTED:

                        return "CONNECTION_STATE_CONNECTED";

                    case CONNECTION_STATE_DISCONNECTING:

                        return "CONNECTION_STATE_DISCONNECTING";

                    default:

                        return "UNKNOWN";

                }

                return BluetoothProfile.getConnectionStateName(value);

            case EVENT_TYPE_VOLUME_STATE_CHANGED:

                return "{group_id:" + value + "}";

            case EVENT_TYPE_DEVICE_AVAILABLE:
@@ -143,18 +126,7 @@ public class VolumeControlStackEvent { 
    private static String eventTypeValue2ToString(int type, int value) {

        switch (type) {

            case EVENT_TYPE_CONNECTION_STATE_CHANGED:

                switch (value) {

                    case CONNECTION_STATE_DISCONNECTED:

                        return "CONNECTION_STATE_DISCONNECTED";

                    case CONNECTION_STATE_CONNECTING:

                        return "CONNECTION_STATE_CONNECTING";

                    case CONNECTION_STATE_CONNECTED:

                        return "CONNECTION_STATE_CONNECTED";

                    case CONNECTION_STATE_DISCONNECTING:

                        return "CONNECTION_STATE_DISCONNECTING";

                    default:

                        return "UNKNOWN";

                }

                return BluetoothProfile.getConnectionStateName(value);

            case EVENT_TYPE_VOLUME_STATE_CHANGED:

                return "{volume:" + value + "}";

            case EVENT_TYPE_DEVICE_AVAILABLE:

android/app/src/com/android/bluetooth/vc/VolumeControlStateMachine.java

+130 −210

File changed.

Preview size limit exceeded, changes collapsed.

android/app/tests/unit/src/com/android/bluetooth/vc/VolumeControlNativeInterfaceTest.java

+3 −1
Original line number Diff line number Diff line
@@ -21,6 +21,8 @@ import static com.google.common.truth.Truth.assertThat; 
import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.bluetooth.BluetoothProfile;



import androidx.test.runner.AndroidJUnit4;



import org.junit.After;
@@ -55,7 +57,7 @@ public class VolumeControlNativeInterfaceTest { 


    @Test

    public void onConnectionStateChanged() {

        int state = VolumeControlStackEvent.CONNECTION_STATE_CONNECTED;

        int state = BluetoothProfile.STATE_CONNECTED;

        byte[] address = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};



        mNativeInterface.onConnectionStateChanged(state, address);

android/app/tests/unit/src/com/android/bluetooth/vc/VolumeControlServiceTest.java

+410 −748

File changed.

Preview size limit exceeded, changes collapsed.