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

Commit a13d5ea7 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "HFP: Reset battery level on HFP disconnect"

parents f2e7cb40 02f24e80

src/com/android/bluetooth/btservice/RemoteDevices.java

+42 −9
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ import android.bluetooth.BluetoothAssignedNumbers; 
import android.bluetooth.BluetoothClass;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHeadset;

import android.bluetooth.BluetoothProfile;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;
@@ -60,7 +61,6 @@ final class RemoteDevices { 
    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {

        @Override

        public void onReceive(Context context, Intent intent) {

            Log.d(TAG, "Received intent: " + intent);

            String action = intent.getAction();

            switch (action) {

                case BluetoothHeadset.ACTION_HF_INDICATORS_VALUE_CHANGED:
@@ -69,6 +69,9 @@ final class RemoteDevices { 
                case BluetoothHeadset.ACTION_VENDOR_SPECIFIC_HEADSET_EVENT:

                    onVendorSpecificHeadsetEvent(intent);

                    break;

                case BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED:

                    onHeadsetConnectionStateChanged(intent);

                    break;

                default:

                    Log.w(TAG, "Unhandled intent: " + intent);

                    break;
@@ -95,6 +98,7 @@ final class RemoteDevices { 
                + BluetoothAssignedNumbers.PLANTRONICS);

        filter.addCategory(BluetoothHeadset.VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY + "."

                + BluetoothAssignedNumbers.APPLE);

        filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);

        mAdapterService.registerReceiver(mReceiver, filter);

    }
@@ -382,13 +386,8 @@ final class RemoteDevices { 
            }

            deviceProperties.setBatteryLevel(batteryLevel);

        }

        Intent intent = new Intent(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED);

        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);

        intent.putExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, batteryLevel);

        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

        mAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_PERM);

        Log.d(TAG, "Updated device " + device + " battery level to " + String.valueOf(batteryLevel)

                        + "%");

        sendBatteryLevelChangedBroadcast(device, batteryLevel);

        Log.d(TAG, "Updated device " + device + " battery level to " + batteryLevel + "%");

    }



    /**
@@ -405,8 +404,24 @@ final class RemoteDevices { 
        if (deviceProperties == null) {

            return;

        }

        synchronized (mObject) {

            if (deviceProperties.getBatteryLevel() == BluetoothDevice.BATTERY_LEVEL_UNKNOWN) {

                debugLog("Battery level was never set or is already reset, device=" + device);

                return;

            }

            deviceProperties.setBatteryLevel(BluetoothDevice.BATTERY_LEVEL_UNKNOWN);

        }

        sendBatteryLevelChangedBroadcast(device, BluetoothDevice.BATTERY_LEVEL_UNKNOWN);

        Log.d(TAG, "Reset battery level, device=" + device);

    }



    private void sendBatteryLevelChangedBroadcast(BluetoothDevice device, int batteryLevel) {

        Intent intent = new Intent(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED);

        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);

        intent.putExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, batteryLevel);

        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

        mAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_PERM);

    }



    void devicePropertyChangedCallback(byte[] address, int[] types, byte[][] values) {

        Intent intent;
@@ -571,6 +586,24 @@ final class RemoteDevices { 
        mHandler.sendMessage(message);

    }



    /**

     * Handles headset connection state change event

     * @param intent must be {@link BluetoothHeadset#ACTION_CONNECTION_STATE_CHANGED} intent

     */

    @VisibleForTesting

    void onHeadsetConnectionStateChanged(Intent intent) {

        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

        if (device == null) {

            Log.e(TAG, "onHeadsetConnectionStateChanged() remote device is null");

            return;

        }

        if (intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothProfile.STATE_DISCONNECTED)

                == BluetoothProfile.STATE_DISCONNECTED) {

            // TODO: Rework this when non-HFP sources of battery level indication is added

            resetBatteryLevel(device);

        }

    }



    @VisibleForTesting

    void onHfIndicatorValueChanged(Intent intent) {

        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

tests/src/com/android/bluetooth/btservice/RemoteDevicesTest.java

+96 −19
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ import android.bluetooth.BluetoothAdapter; 
import android.bluetooth.BluetoothAssignedNumbers;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothHeadset;

import android.bluetooth.BluetoothProfile;

import android.content.Intent;

import android.os.Looper;

import android.support.test.runner.AndroidJUnit4;
@@ -68,7 +69,7 @@ public class RemoteDevicesTest { 
        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        // Verify that user can get battery level after the update
@@ -86,7 +87,7 @@ public class RemoteDevicesTest { 
        verify(mAdapterService, times(2))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);



        // Verify that user can get battery level after the update

        Assert.assertEquals(
@@ -151,7 +152,7 @@ public class RemoteDevicesTest { 
        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        // Verify that user can get battery level after the update
@@ -162,15 +163,70 @@ public class RemoteDevicesTest { 
        // Verify that resetting battery level changes it back to BluetoothDevice

        // .BATTERY_LEVEL_UNKNOWN

        mRemoteDevices.resetBatteryLevel(mDevice1);

        // Verify BATTERY_LEVEL_CHANGED intent is sent after first reset

        verify(mAdapterService, times(2))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verifyBatteryLevelChangedIntent(

                mDevice1, BluetoothDevice.BATTERY_LEVEL_UNKNOWN, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

        // Verify value is reset in properties

        Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));

        Assert.assertEquals(mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(),

                BluetoothDevice.BATTERY_LEVEL_UNKNOWN);



        // Verify no intent is sent after second reset

        mRemoteDevices.resetBatteryLevel(mDevice1);

        verify(mAdapterService, times(2)).sendBroadcast(any(), anyString());



        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService, times(3))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        verifyNoMoreInteractions(mAdapterService);

    }



    @Test

    public void testResetBatteryLevelOnHeadsetStateChange() {

        int batteryLevel = 10;



        // Verify that device property is null initially

        Assert.assertNull(mRemoteDevices.getDeviceProperties(mDevice1));



        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        // Verify that user can get battery level after the update

        Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));

        Assert.assertEquals(

                mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(), batteryLevel);



        // Verify that resetting battery level changes it back to BluetoothDevice

        // .BATTERY_LEVEL_UNKNOWN

        mRemoteDevices.onHeadsetConnectionStateChanged(

                getHeadsetConnectionStateChangedIntent(mDevice1,

                        BluetoothProfile.STATE_DISCONNECTING, BluetoothProfile.STATE_DISCONNECTED));

        // Verify BATTERY_LEVEL_CHANGED intent is sent after first reset

        verify(mAdapterService, times(2))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(

                mDevice1, BluetoothDevice.BATTERY_LEVEL_UNKNOWN, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

        // Verify value is reset in properties

        Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));

        Assert.assertEquals(mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(),

                BluetoothDevice.BATTERY_LEVEL_UNKNOWN);



        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService, times(3))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        verifyNoMoreInteractions(mAdapterService);
@@ -186,7 +242,7 @@ public class RemoteDevicesTest { 
        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        // Verify that user can get battery level after the update
@@ -201,16 +257,26 @@ public class RemoteDevicesTest { 
                0, Utils.getByteAddress(mDevice1), AbstractionLayer.BT_ACL_STATE_DISCONNECTED);

        verify(mAdapterService).getState();

        verify(mAdapterService).getConnectionState(mDevice1);

        verify(mAdapterService, times(2)).sendBroadcast(any(), anyString());

        // Verify ACTION_ACL_DISCONNECTED and BATTERY_LEVEL_CHANGED intent are sent

        verify(mAdapterService, times(3))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verifyBatteryLevelChangedIntent(mDevice1, BluetoothDevice.BATTERY_LEVEL_UNKNOWN,

                mIntentArgument.getAllValues().get(mIntentArgument.getAllValues().size() - 2));

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM,

                mStringArgument.getAllValues().get(mStringArgument.getAllValues().size() - 2));

        Assert.assertEquals(

                BluetoothDevice.ACTION_ACL_DISCONNECTED, mIntentArgument.getValue().getAction());

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

        // Verify value is reset in properties

        Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));

        Assert.assertEquals(BluetoothDevice.BATTERY_LEVEL_UNKNOWN,

                mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel());



        // Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again

        mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);

        verify(mAdapterService, times(3))

        verify(mAdapterService, times(4))

                .sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());



        verifyNoMoreInteractions(mAdapterService);
@@ -227,7 +293,7 @@ public class RemoteDevicesTest { 
        mRemoteDevices.onHfIndicatorValueChanged(getHfIndicatorIntent(

                mDevice1, batteryLevel, HeadsetHalConstants.HF_INDICATOR_BATTERY_LEVEL_STATUS));

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

    }
@@ -256,7 +322,7 @@ public class RemoteDevicesTest { 
                BluetoothAssignedNumbers.PLANTRONICS, BluetoothHeadset.AT_CMD_TYPE_SET,

                getXEventArray(3, 8), mDevice1));

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, 37, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, 37, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

    }
@@ -274,7 +340,7 @@ public class RemoteDevicesTest { 
                        2, 1, 3, 10},

                mDevice1));

        verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());

        verfyBatteryLevelChangedIntent(mDevice1, 60, mIntentArgument);

        verifyBatteryLevelChangedIntent(mDevice1, 60, mIntentArgument);

        Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

    }
@@ -327,16 +393,27 @@ public class RemoteDevicesTest { 
                        new Object[] {1, "WRONG", "WRONG"}));

    }



    private static void verfyBatteryLevelChangedIntent(

    private static void verifyBatteryLevelChangedIntent(

            BluetoothDevice device, int batteryLevel, ArgumentCaptor<Intent> intentArgument) {

        Assert.assertEquals(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED,

                intentArgument.getValue().getAction());

        verifyBatteryLevelChangedIntent(device, batteryLevel, intentArgument.getValue());

    }



    private static void verifyBatteryLevelChangedIntent(

            BluetoothDevice device, int batteryLevel, Intent intent) {

        Assert.assertEquals(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED, intent.getAction());

        Assert.assertEquals(device, intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));

        Assert.assertEquals(

                device, intentArgument.getValue().getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));

        Assert.assertEquals(batteryLevel,

                intentArgument.getValue().getIntExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, -15));

        Assert.assertEquals(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT,

                intentArgument.getValue().getFlags());

                batteryLevel, intent.getIntExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, -15));

        Assert.assertEquals(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT, intent.getFlags());

    }



    private static Intent getHeadsetConnectionStateChangedIntent(

            BluetoothDevice device, int oldState, int newState) {

        Intent intent = new Intent(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);

        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);

        intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, oldState);

        intent.putExtra(BluetoothProfile.EXTRA_STATE, newState);

        return intent;

    }



    private static Intent getHfIndicatorIntent(