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

Commit 0abd8868 authored by Łukasz Rymanowski's avatar Łukasz Rymanowski
Browse files

vc: Add handling DATABASE_OUT_OF_SYNC 

Bug: 262309077
Tag: #feature
Test: atest BluetoothInstrumentationTests
Change-Id: I177268b2cbc14c14332f54962479dc24ba3cba1c
parent 1922df20

system/bta/vc/device.cc

+17 −16
Original line number Diff line number Diff line
@@ -29,17 +29,12 @@ 


using namespace bluetooth::vc::internal;



void VolumeControlDevice::Disconnect(tGATT_IF gatt_if) {

  LOG(INFO) << __func__ << ": " << ADDRESS_TO_LOGGABLE_STR(address);



  if (IsConnected()) {

void VolumeControlDevice::DeregisterNotifications(tGATT_IF gatt_if) {

  if (volume_state_handle != 0)

      BTA_GATTC_DeregisterForNotifications(gatt_if, address,

                                           volume_state_handle);

    BTA_GATTC_DeregisterForNotifications(gatt_if, address, volume_state_handle);



  if (volume_flags_handle != 0)

      BTA_GATTC_DeregisterForNotifications(gatt_if, address,

                                           volume_flags_handle);

    BTA_GATTC_DeregisterForNotifications(gatt_if, address, volume_flags_handle);



  for (const VolumeOffset& of : audio_offsets.volume_offsets) {

    BTA_GATTC_DeregisterForNotifications(gatt_if, address,
@@ -48,7 +43,13 @@ void VolumeControlDevice::Disconnect(tGATT_IF gatt_if) { 
                                         of.audio_location_handle);

    BTA_GATTC_DeregisterForNotifications(gatt_if, address, of.state_handle);

  }

}



void VolumeControlDevice::Disconnect(tGATT_IF gatt_if) {

  LOG(INFO) << __func__ << ": " << ADDRESS_TO_LOGGABLE_STR(address);



  if (IsConnected()) {

    DeregisterNotifications(gatt_if);

    BtaGattQueue::Clean(connection_id);

    BTA_GATTC_Close(connection_id);

    connection_id = GATT_INVALID_CONN_ID;

system/bta/vc/devices.h

+2 −0
Original line number Diff line number Diff line
@@ -120,6 +120,8 @@ class VolumeControlDevice : public bluetooth::common::IRedactableLoggable { 


  void Disconnect(tGATT_IF gatt_if);



  void DeregisterNotifications(tGATT_IF gatt_if);



  bool UpdateHandles(void);



  void ResetHandles(void);

system/bta/vc/vc.cc

+46 −10
Original line number Diff line number Diff line
@@ -185,6 +185,29 @@ class VolumeControlImpl : public VolumeControl { 
    }

  }



  void ClearDeviceInformationAndStartSearch(VolumeControlDevice* device) {

    if (!device) {

      LOG_ERROR("Device is null");

      return;

    }



    LOG_INFO(": address=%s", ADDRESS_TO_LOGGABLE_CSTR(device->address));

    if (device->service_changed_rcvd) {

      LOG_INFO("Device already is waiting for new services");

      return;

    }



    std::vector<RawAddress> devices = {device->address};

    device->DeregisterNotifications(gatt_if_);



    RemovePendingVolumeControlOperations(devices,

                                         bluetooth::groups::kGroupUnknown);

    device->first_connection = true;

    device->service_changed_rcvd = true;

    BtaGattQueue::Clean(device->connection_id);

    BTA_GATTC_ServiceSearchRequest(device->connection_id, &kVolumeControlUuid);

  }



  void OnServiceChangeEvent(const RawAddress& address) {

    VolumeControlDevice* device =

        volume_control_devices_.FindByAddress(address);
@@ -193,11 +216,8 @@ class VolumeControlImpl : public VolumeControl { 
                 << ADDRESS_TO_LOGGABLE_STR(address);

      return;

    }

    LOG(INFO) << __func__ << ": address="

              << ADDRESS_TO_LOGGABLE_STR(address);

    device->first_connection = true;

    device->service_changed_rcvd = true;

    BtaGattQueue::Clean(device->connection_id);



    ClearDeviceInformationAndStartSearch(device);

  }



  void OnServiceDiscDoneEvent(const RawAddress& address) {
@@ -255,7 +275,12 @@ class VolumeControlImpl : public VolumeControl { 
    }



    if (status != GATT_SUCCESS) {

      LOG(INFO) << __func__ << ": status=" << static_cast<int>(status);

      LOG_INFO(": status=0x%02x", static_cast<int>(status));

      if (status == GATT_DATABASE_OUT_OF_SYNC) {

        LOG_INFO("Database out of sync for %s",

                 ADDRESS_TO_LOGGABLE_CSTR(device->address));

        ClearDeviceInformationAndStartSearch(device);

      }

      return;

    }
@@ -555,10 +580,15 @@ class VolumeControlImpl : public VolumeControl { 
    }



    if (status != GATT_SUCCESS) {

      LOG(ERROR) << __func__

                 << "Failed to register for notification: " << loghex(handle)

                 << " status: " << status;

      if (status == GATT_DATABASE_OUT_OF_SYNC) {

        LOG_INFO("Database out of sync for %s, conn_id: 0x%04x",

                 ADDRESS_TO_LOGGABLE_CSTR(device->address), connection_id);

        ClearDeviceInformationAndStartSearch(device);

      } else {

        LOG_ERROR("Failed to register for notification: 0x%04x, status 0x%02x",

                  handle, status);

        device_cleanup_helper(device, true);

      }

      return;

    }
@@ -693,6 +723,12 @@ class VolumeControlImpl : public VolumeControl { 


    /* In case of error, remove device from the tracking operation list */

    RemoveDeviceFromOperationList(device->address, PTR_TO_INT(data));



    if (status == GATT_DATABASE_OUT_OF_SYNC) {

      LOG_INFO("Database out of sync for %s",

               ADDRESS_TO_LOGGABLE_CSTR(device->address));

      ClearDeviceInformationAndStartSearch(device);

    }

  }



  static void operation_callback(void* data) {

system/bta/vc/vc_test.cc

+40 −0
Original line number Diff line number Diff line
@@ -754,6 +754,46 @@ TEST_F(VolumeControlTest, test_discovery_vocs_broken) { 
  TestAppUnregister();

}



TEST_F(VolumeControlTest, test_read_vcs_database_out_of_sync) {

  const RawAddress test_address = GetTestAddress(0);

  EXPECT_CALL(*callbacks, OnVolumeStateChanged(test_address, _, _, false));

  std::vector<uint16_t> handles({0x0021});

  uint16_t conn_id = 1;



  SetSampleDatabase(conn_id);

  TestAppRegister();

  TestConnect(test_address);

  GetConnectedEvent(test_address, conn_id);



  EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, _, _, _))

      .WillRepeatedly(DoDefault());

  for (auto const& handle : handles) {

    EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, handle, _, _))

        .WillOnce(DoDefault());

  }

  GetSearchCompleteEvent(conn_id);



  /* Simulate database change on the remote side. */

  ON_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _))

      .WillByDefault(

          Invoke([this](uint16_t conn_id, uint16_t handle,

                        std::vector<uint8_t> value, tGATT_WRITE_TYPE write_type,

                        GATT_WRITE_OP_CB cb, void* cb_data) {

            auto* svc = gatt::FindService(services_map[conn_id], handle);

            if (svc == nullptr) return;



            tGATT_STATUS status = GATT_DATABASE_OUT_OF_SYNC;

            if (cb)

              cb(conn_id, status, handle, value.size(), value.data(), cb_data);

          }));



  ON_CALL(gatt_interface, ServiceSearchRequest(_, _)).WillByDefault(Return());

  EXPECT_CALL(gatt_interface, ServiceSearchRequest(_, _));

  VolumeControl::Get()->SetVolume(test_address, 15);

  Mock::VerifyAndClearExpectations(&gatt_interface);

  TestAppUnregister();

}



class VolumeControlCallbackTest : public VolumeControlTest {

 protected:

  const RawAddress test_address = GetTestAddress(0);