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

Commit f6c7ae61 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Use aggressive initial connection params" into main am: c55eb6ca 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3328187



Change-Id: Iee59319b519426fe3893bb5f07bf9affb2749e30
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 5834a669 c55eb6ca

framework/tests/bumble/src/android/bluetooth/GattClientTest.java

+31 −0
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ import static org.mockito.Mockito.verify; 


import android.bluetooth.test_utils.EnableBluetoothRule;

import android.content.Context;

import android.os.SystemProperties;

import android.platform.test.annotations.RequiresFlagsEnabled;

import android.platform.test.flag.junit.CheckFlagsRule;

import android.platform.test.flag.junit.DeviceFlagsValueProvider;
@@ -93,6 +94,11 @@ public class GattClientTest { 
    private static final UUID TEST_CHARACTERISTIC_UUID =

            UUID.fromString("00010001-0000-0000-0000-000000000000");



    private static final int MIN_CONN_INTERVAL_RELAXED =

            SystemProperties.getInt("bluetooth.core.le.min_connection_interval_relaxed", 0x0018);

    private static final int MAX_CONN_INTERVAL_RELAXED =

            SystemProperties.getInt("bluetooth.core.le.max_connection_interval_relaxed", 0x0028);



    @Rule(order = 0)

    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
@@ -172,6 +178,31 @@ public class GattClientTest { 
        disconnectAndWaitDisconnection(gatt, gattCallback);

    }



    @RequiresFlagsEnabled(Flags.FLAG_INITIAL_CONN_PARAMS_P1)

    @Test

    public void onConnectionUpdatedIsCalledOnlyOnceForRelaxingConnectionParameters_noGattCache() {

        BluetoothGattCallback gattCallback = mock(BluetoothGattCallback.class);

        ArgumentCaptor<Integer> connectionIntervalCaptor = ArgumentCaptor.forClass(Integer.class);



        BluetoothGatt gatt = connectGattAndWaitConnection(gattCallback, false);



        // Wait until service discovery is done and parameters are relaxed.

        verify(gattCallback, timeout(10_000).times(1))

                .onConnectionUpdated(

                        any(), connectionIntervalCaptor.capture(), anyInt(), anyInt(), anyInt());



        List<Integer> capturedConnectionIntervals = connectionIntervalCaptor.getAllValues();

        assertThat(capturedConnectionIntervals).hasSize(1);



        // Since aggressive parameters are used in the initial connection,

        // there should be only one connection parameters update event for relaxing them.

        int relaxedConnIntervalAfterServiceDiscovery = capturedConnectionIntervals.get(0);

        assertThat(relaxedConnIntervalAfterServiceDiscovery).isAtLeast(MIN_CONN_INTERVAL_RELAXED);

        assertThat(relaxedConnIntervalAfterServiceDiscovery).isAtMost(MAX_CONN_INTERVAL_RELAXED);



        disconnectAndWaitDisconnection(gatt, gattCallback);

    }



    @Test

    public void reconnectExistingClient() throws Exception {

        advertiseWithBumble();

system/common/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ cc_library_static { 
    ],

    srcs: [

        "address_obfuscator.cc",

        "le_conn_params.cc",

        "message_loop_thread.cc",

        "metric_id_allocator.cc",

        "os_utils.cc",

system/common/BUILD.gn

+1 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
static_library("common") {

  sources = [

    "address_obfuscator.cc",

    "le_conn_params.cc",

    "message_loop_thread.cc",

    "metric_id_allocator.cc",

    "metrics_linux.cc",

system/common/le_conn_params.cc

0 → 100644
+142 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2024 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "le_conn_params"



#include "common/le_conn_params.h"



#include <bluetooth/log.h>



#include <cstdint>



#include "os/system_properties.h"

#include "stack/include/btm_ble_api_types.h"



using namespace bluetooth;



const std::string LeConnectionParameters::kPropertyAggressiveConnThreshold =

        "bluetooth.core.le.aggressive_connection_threshold";

const std::string LeConnectionParameters::kPropertyMinConnIntervalAggressive =

        "bluetooth.core.le.min_connection_interval_aggressive";

const std::string LeConnectionParameters::kPropertyMaxConnIntervalAggressive =

        "bluetooth.core.le.max_connection_interval_aggressive";

const std::string LeConnectionParameters::kPropertyMinConnIntervalRelaxed =

        "bluetooth.core.le.min_connection_interval_relaxed";

const std::string LeConnectionParameters::kPropertyMaxConnIntervalRelaxed =

        "bluetooth.core.le.max_connection_interval_relaxed";



bool LeConnectionParameters::initialized = false;

uint32_t LeConnectionParameters::aggressive_conn_threshold = kAggressiveConnThreshold;

uint32_t LeConnectionParameters::min_conn_interval_aggressive = kMinConnIntervalAggressive;

uint32_t LeConnectionParameters::max_conn_interval_aggressive = kMaxConnIntervalAggressive;

uint32_t LeConnectionParameters::min_conn_interval_relaxed = kMinConnIntervalRelaxed;

uint32_t LeConnectionParameters::max_conn_interval_relaxed = kMaxConnIntervalRelaxed;



void LeConnectionParameters::InitConnParamsWithSystemProperties() {

  aggressive_conn_threshold =

          os::GetSystemPropertyUint32(kPropertyAggressiveConnThreshold, kAggressiveConnThreshold);

  min_conn_interval_aggressive = os::GetSystemPropertyUint32(kPropertyMinConnIntervalAggressive,

                                                             kMinConnIntervalAggressive);

  max_conn_interval_aggressive = os::GetSystemPropertyUint32(kPropertyMaxConnIntervalAggressive,

                                                             kMaxConnIntervalAggressive);

  min_conn_interval_relaxed =

          os::GetSystemPropertyUint32(kPropertyMinConnIntervalRelaxed, kMinConnIntervalRelaxed);

  max_conn_interval_relaxed =

          os::GetSystemPropertyUint32(kPropertyMaxConnIntervalRelaxed, kMaxConnIntervalRelaxed);



  log::debug("Before checking validity: threshold={}, aggressive={}/{}, relaxed={}/{}",

             aggressive_conn_threshold, min_conn_interval_aggressive, max_conn_interval_aggressive,

             min_conn_interval_relaxed, max_conn_interval_relaxed);



  // Check validity of each values

  if (aggressive_conn_threshold < 0) {

    log::warn("Invalid aggressive connection threshold. Using default value.",

              aggressive_conn_threshold);

    aggressive_conn_threshold = kAggressiveConnThreshold;

  }



  if (min_conn_interval_aggressive < BTM_BLE_CONN_INT_MIN ||

      min_conn_interval_aggressive > BTM_BLE_CONN_INT_MAX ||

      max_conn_interval_aggressive < BTM_BLE_CONN_INT_MIN ||

      max_conn_interval_aggressive > BTM_BLE_CONN_INT_MAX ||

      max_conn_interval_aggressive < min_conn_interval_aggressive) {

    log::warn("Invalid aggressive connection intervals. Using default values.");

    min_conn_interval_aggressive = kMinConnIntervalAggressive;

    max_conn_interval_aggressive = kMaxConnIntervalAggressive;

  }



  if (min_conn_interval_relaxed < BTM_BLE_CONN_INT_MIN ||

      min_conn_interval_relaxed > BTM_BLE_CONN_INT_MAX ||

      max_conn_interval_relaxed < BTM_BLE_CONN_INT_MIN ||

      max_conn_interval_relaxed > BTM_BLE_CONN_INT_MAX ||

      max_conn_interval_relaxed < min_conn_interval_relaxed) {

    log::warn("Invalid relaxed connection intervals. Using default values.");

    min_conn_interval_relaxed = kMinConnIntervalRelaxed;

    max_conn_interval_relaxed = kMaxConnIntervalRelaxed;

  }



  if ((min_conn_interval_aggressive > min_conn_interval_relaxed) &&

      (max_conn_interval_aggressive > max_conn_interval_relaxed)) {

    log::warn(

            "Relaxed connection intervals are more aggressive than aggressive ones."

            " Setting all intervals to default values.");

    min_conn_interval_aggressive = kMinConnIntervalAggressive;

    max_conn_interval_aggressive = kMaxConnIntervalAggressive;

    min_conn_interval_relaxed = kMinConnIntervalRelaxed;

    max_conn_interval_relaxed = kMaxConnIntervalRelaxed;

  }



  log::debug("After checking validity: threshold={}, aggressive={}/{}, relaxed={}/{}",

             aggressive_conn_threshold, min_conn_interval_aggressive, max_conn_interval_aggressive,

             min_conn_interval_relaxed, max_conn_interval_relaxed);



  initialized = true;

}



uint32_t LeConnectionParameters::GetAggressiveConnThreshold() {

  if (!initialized) {

    InitConnParamsWithSystemProperties();

  }

  return aggressive_conn_threshold;

}



uint32_t LeConnectionParameters::GetMinConnIntervalAggressive() {

  if (!initialized) {

    InitConnParamsWithSystemProperties();

  }

  return min_conn_interval_aggressive;

}



uint32_t LeConnectionParameters::GetMaxConnIntervalAggressive() {

  if (!initialized) {

    InitConnParamsWithSystemProperties();

  }

  return max_conn_interval_aggressive;

}



uint32_t LeConnectionParameters::GetMinConnIntervalRelaxed() {

  if (!initialized) {

    InitConnParamsWithSystemProperties();

  }

  return min_conn_interval_relaxed;

}



uint32_t LeConnectionParameters::GetMaxConnIntervalRelaxed() {

  if (!initialized) {

    InitConnParamsWithSystemProperties();

  }

  return max_conn_interval_relaxed;

}

system/common/le_conn_params.h

0 → 100644
+51 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2024 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <bluetooth/log.h>



#include <cstdint>



class LeConnectionParameters {

public:

  static constexpr uint16_t kAggressiveConnThreshold = 2;

  static constexpr uint16_t kMinConnIntervalAggressive = 0x0008;  // 8, *1.25 becomes 10ms

  static constexpr uint16_t kMaxConnIntervalAggressive = 0x0010;  // 16, *1.25 becomes 20ms

  static constexpr uint16_t kMinConnIntervalRelaxed = 0x0018;     // 24, *1.25 becomes 30ms

  static constexpr uint16_t kMaxConnIntervalRelaxed = 0x0028;     // 40, *1.25 becomes 50ms



  static const std::string kPropertyAggressiveConnThreshold;

  static const std::string kPropertyMinConnIntervalAggressive;

  static const std::string kPropertyMaxConnIntervalAggressive;

  static const std::string kPropertyMinConnIntervalRelaxed;

  static const std::string kPropertyMaxConnIntervalRelaxed;



  static void InitConnParamsWithSystemProperties();

  static uint32_t GetAggressiveConnThreshold();

  static uint32_t GetMinConnIntervalAggressive();

  static uint32_t GetMaxConnIntervalAggressive();

  static uint32_t GetMinConnIntervalRelaxed();

  static uint32_t GetMaxConnIntervalRelaxed();



private:

  static bool initialized;

  static uint32_t aggressive_conn_threshold;

  static uint32_t min_conn_interval_aggressive;

  static uint32_t max_conn_interval_aggressive;

  static uint32_t min_conn_interval_relaxed;

  static uint32_t max_conn_interval_relaxed;

};