Merge "L2CAP: Store channel configuration state in a separate class"
am: f2e2339fd6
Change-Id: Ib6c4377d60848cb655fc748997d9b33975071679
diff --git a/gd/l2cap/classic/internal/channel_configuration_state.h b/gd/l2cap/classic/internal/channel_configuration_state.h
new file mode 100644
index 0000000..b0dead5
--- /dev/null
+++ b/gd/l2cap/classic/internal/channel_configuration_state.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2019 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 "l2cap/l2cap_packets.h"
+#include "l2cap/mtu.h"
+
+namespace bluetooth {
+namespace l2cap {
+namespace classic {
+namespace internal {
+
+struct ChannelConfigurationState {
+ public:
+ enum State {
+ /**
+ * for the initiator path, a request has been sent but a positive response has not yet been received, and for the
+ * acceptor path, a request with acceptable options has not yet been received.
+ */
+ WAIT_CONFIG_REQ_RSP,
+ /**
+ * the acceptor path is complete after having responded to acceptable options, but for the initiator path, a
+ * positive response on the recent request has not yet been received.
+ */
+ WAIT_CONFIG_RSP,
+ /**
+ * the initiator path is complete after having received a positive response, but for the acceptor path, a request
+ * with acceptable options has not yet been received.
+ */
+ WAIT_CONFIG_REQ,
+ /**
+ * Configuration is complete
+ */
+ CONFIGURED,
+ };
+ State state_ = State::WAIT_CONFIG_REQ_RSP;
+
+ Mtu incoming_mtu_ = kDefaultClassicMtu;
+ Mtu outgoing_mtu_ = kDefaultClassicMtu;
+ RetransmissionAndFlowControlModeOption retransmission_and_flow_control_mode_;
+ RetransmissionAndFlowControlConfigurationOption local_retransmission_and_flow_control_;
+ RetransmissionAndFlowControlConfigurationOption remote_retransmission_and_flow_control_;
+ FcsType fcs_type_ = FcsType::DEFAULT;
+};
+} // namespace internal
+} // namespace classic
+} // namespace l2cap
+} // namespace bluetooth
diff --git a/gd/l2cap/classic/internal/dynamic_channel_impl.cc b/gd/l2cap/classic/internal/dynamic_channel_impl.cc
index c0614f9..e916011 100644
--- a/gd/l2cap/classic/internal/dynamic_channel_impl.cc
+++ b/gd/l2cap/classic/internal/dynamic_channel_impl.cc
@@ -82,39 +82,6 @@
return ss.str();
}
-DynamicChannelImpl::ConfigurationStatus DynamicChannelImpl::GetOutgoingConfigurationStatus() const {
- return outgoing_configuration_status_;
-}
-
-void DynamicChannelImpl::SetOutgoingConfigurationStatus(ConfigurationStatus status) {
- outgoing_configuration_status_ = status;
-}
-
-DynamicChannelImpl::ConfigurationStatus DynamicChannelImpl::GetIncomingConfigurationStatus() const {
- return incoming_configuration_status_;
-}
-
-void DynamicChannelImpl::SetIncomingConfigurationStatus(ConfigurationStatus status) {
- incoming_configuration_status_ = status;
-}
-
-void DynamicChannelImpl::SetSender(l2cap::internal::Sender* sender) {
- sender_ = sender;
-}
-
-void DynamicChannelImpl::SetIncomingMtu(Mtu mtu) {
- sender_->SetIncomingMtu(mtu);
-}
-
-void DynamicChannelImpl::SetRetransmissionFlowControlConfig(
- const RetransmissionAndFlowControlConfigurationOption& option) {
- sender_->SetChannelRetransmissionFlowControlMode(option);
-}
-
-void DynamicChannelImpl::SetFcsType(FcsType fcs_type) {
- sender_->SetFcsType(fcs_type);
-}
-
} // namespace internal
} // namespace classic
} // namespace l2cap
diff --git a/gd/l2cap/classic/internal/dynamic_channel_impl.h b/gd/l2cap/classic/internal/dynamic_channel_impl.h
index 95be5c7..10f487b 100644
--- a/gd/l2cap/classic/internal/dynamic_channel_impl.h
+++ b/gd/l2cap/classic/internal/dynamic_channel_impl.h
@@ -68,26 +68,6 @@
return psm_;
}
- enum class ConfigurationStatus { NOT_CONFIGURED, CONFIGURED };
-
- virtual ConfigurationStatus GetOutgoingConfigurationStatus() const;
- virtual void SetOutgoingConfigurationStatus(ConfigurationStatus status);
-
- virtual ConfigurationStatus GetIncomingConfigurationStatus() const;
- virtual void SetIncomingConfigurationStatus(ConfigurationStatus status);
-
- /**
- * Callback from the Scheduler to notify the Sender for this channel. On config update, channel might notify the
- * configuration to Sender
- */
- void SetSender(l2cap::internal::Sender* sender) override;
-
- virtual void SetIncomingMtu(Mtu mtu);
-
- virtual void SetRetransmissionFlowControlConfig(const RetransmissionAndFlowControlConfigurationOption& mode);
-
- virtual void SetFcsType(FcsType fcs_type);
-
// TODO(cmanton) Do something a little bit better than this
bool local_initiated_{false};
@@ -109,10 +89,6 @@
static constexpr size_t kChannelQueueSize = 10;
common::BidiQueue<packet::PacketView<packet::kLittleEndian>, packet::BasePacketBuilder> channel_queue_{
kChannelQueueSize};
- ConfigurationStatus outgoing_configuration_status_ = ConfigurationStatus::NOT_CONFIGURED;
- ConfigurationStatus incoming_configuration_status_ = ConfigurationStatus::NOT_CONFIGURED;
-
- l2cap::internal::Sender* sender_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(DynamicChannelImpl);
};
diff --git a/gd/l2cap/classic/internal/fixed_channel_impl.cc b/gd/l2cap/classic/internal/fixed_channel_impl.cc
index 8ac6c94..9bfaef8 100644
--- a/gd/l2cap/classic/internal/fixed_channel_impl.cc
+++ b/gd/l2cap/classic/internal/fixed_channel_impl.cc
@@ -94,8 +94,6 @@
link_->RefreshRefCount();
}
-void FixedChannelImpl::SetSender(l2cap::internal::Sender* sender) {}
-
} // namespace internal
} // namespace classic
} // namespace l2cap
diff --git a/gd/l2cap/classic/internal/fixed_channel_impl.h b/gd/l2cap/classic/internal/fixed_channel_impl.h
index 6fde5c6..e425d9c 100644
--- a/gd/l2cap/classic/internal/fixed_channel_impl.h
+++ b/gd/l2cap/classic/internal/fixed_channel_impl.h
@@ -74,7 +74,6 @@
Cid GetRemoteCid() const {
return cid_;
}
- void SetSender(l2cap::internal::Sender* sender) override;
private:
// Constructor states
diff --git a/gd/l2cap/classic/internal/link.cc b/gd/l2cap/classic/internal/link.cc
index 63f5f71..8d6e3e6 100644
--- a/gd/l2cap/classic/internal/link.cc
+++ b/gd/l2cap/classic/internal/link.cc
@@ -36,8 +36,8 @@
: l2cap_handler_(l2cap_handler), acl_connection_(std::move(acl_connection)),
data_pipeline_manager_(l2cap_handler, acl_connection_->GetAclQueueEnd()), parameter_provider_(parameter_provider),
dynamic_service_manager_(dynamic_service_manager), fixed_service_manager_(fixed_service_manager),
- signalling_manager_(l2cap_handler_, this, dynamic_service_manager_, &dynamic_channel_allocator_,
- fixed_service_manager_) {
+ signalling_manager_(l2cap_handler_, this, &data_pipeline_manager_, dynamic_service_manager_,
+ &dynamic_channel_allocator_, fixed_service_manager_) {
ASSERT(l2cap_handler_ != nullptr);
ASSERT(acl_connection_ != nullptr);
ASSERT(parameter_provider_ != nullptr);
diff --git a/gd/l2cap/classic/internal/signalling_manager.cc b/gd/l2cap/classic/internal/signalling_manager.cc
index 7398c17..894de32 100644
--- a/gd/l2cap/classic/internal/signalling_manager.cc
+++ b/gd/l2cap/classic/internal/signalling_manager.cc
@@ -19,7 +19,9 @@
#include <chrono>
#include "common/bind.h"
+#include "l2cap/classic/internal/channel_configuration_state.h"
#include "l2cap/classic/internal/link.h"
+#include "l2cap/internal/data_pipeline_manager.h"
#include "l2cap/l2cap_packets.h"
#include "os/log.h"
#include "packet/raw_builder.h"
@@ -31,11 +33,13 @@
static constexpr auto kTimeout = std::chrono::seconds(3);
ClassicSignallingManager::ClassicSignallingManager(os::Handler* handler, Link* link,
+ l2cap::internal::DataPipelineManager* data_pipeline_manager,
DynamicChannelServiceManagerImpl* dynamic_service_manager,
DynamicChannelAllocator* channel_allocator,
FixedChannelServiceManagerImpl* fixed_service_manager)
- : handler_(handler), link_(link), dynamic_service_manager_(dynamic_service_manager),
- channel_allocator_(channel_allocator), fixed_service_manager_(fixed_service_manager), alarm_(handler) {
+ : handler_(handler), link_(link), data_pipeline_manager_(data_pipeline_manager),
+ dynamic_service_manager_(dynamic_service_manager), channel_allocator_(channel_allocator),
+ fixed_service_manager_(fixed_service_manager), alarm_(handler) {
ASSERT(handler_ != nullptr);
ASSERT(link_ != nullptr);
signalling_channel_ = link_->AllocateFixedChannel(kClassicSignallingCid, {});
@@ -147,23 +151,35 @@
}
send_connection_response(signal_id, remote_cid, new_channel->GetCid(), ConnectionResponseResult::SUCCESS,
ConnectionResponseStatus::NO_FURTHER_INFORMATION_AVAILABLE);
+ auto& configuration_state = channel_configuration_[new_channel->GetCid()];
auto* service = dynamic_service_manager_->GetService(psm);
auto initial_config = service->GetConfigOption();
+
+ auto mtu_configuration = std::make_unique<MtuConfigurationOption>();
+ mtu_configuration->mtu_ = initial_config.incoming_mtu;
+ configuration_state.incoming_mtu_ = initial_config.incoming_mtu;
+
+ auto fcs_option = std::make_unique<FrameCheckSequenceOption>();
+ fcs_option->fcs_type_ = FcsType::DEFAULT;
+ if (!link_->GetRemoteSupportsFcs()) {
+ fcs_option->fcs_type_ = FcsType::NO_FCS;
+ configuration_state.fcs_type_ = FcsType::NO_FCS;
+ }
+
+ auto retransmission_flow_control_configuration = std::make_unique<RetransmissionAndFlowControlConfigurationOption>();
if (!link_->GetRemoteSupportsErtm()) {
initial_config.channel_mode = DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::L2CAP_BASIC;
}
- auto mtu_configuration = std::make_unique<MtuConfigurationOption>();
- mtu_configuration->mtu_ = initial_config.incoming_mtu;
- auto fcs_option = std::make_unique<FrameCheckSequenceOption>();
- fcs_option->fcs_type_ = FcsType::NO_FCS;
- auto retransmission_flow_control_configuration = std::make_unique<RetransmissionAndFlowControlConfigurationOption>();
switch (initial_config.channel_mode) {
case DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::L2CAP_BASIC:
retransmission_flow_control_configuration->mode_ = RetransmissionAndFlowControlModeOption::L2CAP_BASIC;
+ configuration_state.retransmission_and_flow_control_mode_ = RetransmissionAndFlowControlModeOption::L2CAP_BASIC;
break;
case DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::ENHANCED_RETRANSMISSION:
retransmission_flow_control_configuration->mode_ =
RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION;
+ configuration_state.retransmission_and_flow_control_mode_ =
+ RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION;
// TODO: Decide where to put initial values
retransmission_flow_control_configuration->tx_window_size_ = 10;
retransmission_flow_control_configuration->max_transmit_ = 20;
@@ -172,9 +188,8 @@
retransmission_flow_control_configuration->maximum_pdu_size_ = 1010;
break;
}
+ configuration_state.local_retransmission_and_flow_control_ = *retransmission_flow_control_configuration;
- new_channel->SetRetransmissionFlowControlConfig(*retransmission_flow_control_configuration);
- new_channel->SetIncomingMtu(initial_config.incoming_mtu);
std::vector<std::unique_ptr<ConfigurationOption>> config;
config.emplace_back(std::move(mtu_configuration));
config.emplace_back(std::move(retransmission_flow_control_configuration));
@@ -211,20 +226,35 @@
return;
}
alarm_.Cancel();
+
+ auto& configuration_state = channel_configuration_[new_channel->GetCid()];
auto initial_config = link_->GetConfigurationForInitialConfiguration(new_channel->GetCid());
+
+ auto mtu_configuration = std::make_unique<MtuConfigurationOption>();
+ mtu_configuration->mtu_ = initial_config.incoming_mtu;
+ configuration_state.incoming_mtu_ = initial_config.incoming_mtu;
+
+ auto fcs_option = std::make_unique<FrameCheckSequenceOption>();
+ fcs_option->fcs_type_ = FcsType::DEFAULT;
+ if (!link_->GetRemoteSupportsFcs()) {
+ fcs_option->fcs_type_ = FcsType::NO_FCS;
+ configuration_state.fcs_type_ = FcsType::NO_FCS;
+ }
+
+ auto retransmission_flow_control_configuration = std::make_unique<RetransmissionAndFlowControlConfigurationOption>();
if (!link_->GetRemoteSupportsErtm()) {
initial_config.channel_mode = DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::L2CAP_BASIC;
}
- auto mtu_configuration = std::make_unique<MtuConfigurationOption>();
- mtu_configuration->mtu_ = initial_config.incoming_mtu;
- auto retransmission_flow_control_configuration = std::make_unique<RetransmissionAndFlowControlConfigurationOption>();
switch (initial_config.channel_mode) {
case DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::L2CAP_BASIC:
retransmission_flow_control_configuration->mode_ = RetransmissionAndFlowControlModeOption::L2CAP_BASIC;
+ configuration_state.retransmission_and_flow_control_mode_ = RetransmissionAndFlowControlModeOption::L2CAP_BASIC;
break;
case DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::ENHANCED_RETRANSMISSION:
retransmission_flow_control_configuration->mode_ =
RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION;
+ configuration_state.retransmission_and_flow_control_mode_ =
+ RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION;
// TODO: Decide where to put initial values
retransmission_flow_control_configuration->tx_window_size_ = 10;
retransmission_flow_control_configuration->max_transmit_ = 20;
@@ -233,11 +263,12 @@
retransmission_flow_control_configuration->maximum_pdu_size_ = 1010;
break;
}
+ configuration_state.local_retransmission_and_flow_control_ = *retransmission_flow_control_configuration;
+
std::vector<std::unique_ptr<ConfigurationOption>> config;
config.emplace_back(std::move(mtu_configuration));
- if (initial_config.channel_mode != DynamicChannelConfigurationOption::RetransmissionAndFlowControlMode::L2CAP_BASIC) {
- config.emplace_back(std::move(retransmission_flow_control_configuration));
- }
+ config.emplace_back(std::move(retransmission_flow_control_configuration));
+ config.emplace_back(std::move(fcs_option));
SendConfigurationRequest(remote_cid, {});
}
@@ -249,10 +280,13 @@
return;
}
+ auto& configuration_state = channel_configuration_[cid];
+
for (auto& option : options) {
switch (option->type_) {
case ConfigurationOptionType::MTU: {
- channel->SetIncomingMtu(MtuConfigurationOption::Specialize(option.get())->mtu_);
+ configuration_state.outgoing_mtu_ = MtuConfigurationOption::Specialize(option.get())->mtu_;
+ // TODO: If less than minimum (required by spec), reject
break;
}
case ConfigurationOptionType::FLUSH_TIMEOUT: {
@@ -261,11 +295,11 @@
}
case ConfigurationOptionType::RETRANSMISSION_AND_FLOW_CONTROL: {
auto config = RetransmissionAndFlowControlConfigurationOption::Specialize(option.get());
- channel->SetRetransmissionFlowControlConfig(*config);
+ configuration_state.remote_retransmission_and_flow_control_ = *config;
break;
}
case ConfigurationOptionType::FRAME_CHECK_SEQUENCE: {
- channel->SetFcsType(FrameCheckSequenceOption::Specialize(option.get())->fcs_type_);
+ configuration_state.fcs_type_ = FrameCheckSequenceOption::Specialize(option.get())->fcs_type_;
break;
}
default:
@@ -278,18 +312,22 @@
}
}
- auto response = ConfigurationResponseBuilder::Create(signal_id.Value(), channel->GetRemoteCid(), is_continuation,
- ConfigurationResponseResult::SUCCESS, {});
- enqueue_buffer_->Enqueue(std::move(response), handler_);
- channel->SetIncomingConfigurationStatus(DynamicChannelImpl::ConfigurationStatus::CONFIGURED);
- if (channel->GetOutgoingConfigurationStatus() == DynamicChannelImpl::ConfigurationStatus::CONFIGURED) {
+ if (configuration_state.state_ == ChannelConfigurationState::State::WAIT_CONFIG_REQ) {
std::unique_ptr<DynamicChannel> user_channel = std::make_unique<DynamicChannel>(channel, handler_);
if (channel->local_initiated_) {
link_->NotifyChannelCreation(cid, std::move(user_channel));
} else {
dynamic_service_manager_->GetService(channel->GetPsm())->NotifyChannelCreation(std::move(user_channel));
}
+ configuration_state.state_ = ChannelConfigurationState::State::CONFIGURED;
+ data_pipeline_manager_->UpdateClassicConfiguration(cid, configuration_state);
+ } else if (configuration_state.state_ == ChannelConfigurationState::State::WAIT_CONFIG_REQ_RSP) {
+ configuration_state.state_ = ChannelConfigurationState::State::WAIT_CONFIG_RSP;
}
+
+ auto response = ConfigurationResponseBuilder::Create(signal_id.Value(), channel->GetRemoteCid(), is_continuation,
+ ConfigurationResponseResult::SUCCESS, {});
+ enqueue_buffer_->Enqueue(std::move(response), handler_);
}
void ClassicSignallingManager::OnConfigurationResponse(SignalId signal_id, Cid cid, Continuation is_continuation,
@@ -310,15 +348,50 @@
return;
}
- channel->SetOutgoingConfigurationStatus(DynamicChannelImpl::ConfigurationStatus::CONFIGURED);
- if (channel->GetIncomingConfigurationStatus() == DynamicChannelImpl::ConfigurationStatus::CONFIGURED) {
+ // TODO: Handle status not SUCCESS
+
+ auto& configuration_state = channel_configuration_[channel->GetCid()];
+
+ for (auto& option : options) {
+ switch (option->type_) {
+ case ConfigurationOptionType::MTU: {
+ auto config = MtuConfigurationOption::Specialize(option.get());
+ configuration_state.incoming_mtu_ = config->mtu_;
+ break;
+ }
+ case ConfigurationOptionType::FLUSH_TIMEOUT: {
+ // TODO: Handle this configuration option
+ break;
+ }
+ case ConfigurationOptionType::RETRANSMISSION_AND_FLOW_CONTROL: {
+ auto config = RetransmissionAndFlowControlConfigurationOption::Specialize(option.get());
+ configuration_state.retransmission_and_flow_control_mode_ = config->mode_;
+ configuration_state.local_retransmission_and_flow_control_ = *config;
+ break;
+ }
+ case ConfigurationOptionType::FRAME_CHECK_SEQUENCE: {
+ configuration_state.fcs_type_ = FrameCheckSequenceOption::Specialize(option.get())->fcs_type_;
+ break;
+ }
+ default:
+ LOG_WARN("Received some unsupported configuration option: %d", static_cast<int>(option->type_));
+ return;
+ }
+ }
+
+ if (configuration_state.state_ == ChannelConfigurationState::State::WAIT_CONFIG_RSP) {
std::unique_ptr<DynamicChannel> user_channel = std::make_unique<DynamicChannel>(channel, handler_);
if (channel->local_initiated_) {
link_->NotifyChannelCreation(cid, std::move(user_channel));
} else {
dynamic_service_manager_->GetService(channel->GetPsm())->NotifyChannelCreation(std::move(user_channel));
}
+ configuration_state.state_ = ChannelConfigurationState::State::CONFIGURED;
+ data_pipeline_manager_->UpdateClassicConfiguration(cid, configuration_state);
+ } else if (configuration_state.state_ == ChannelConfigurationState::State::WAIT_CONFIG_REQ_RSP) {
+ configuration_state.state_ = ChannelConfigurationState::State::WAIT_CONFIG_REQ;
}
+
alarm_.Cancel();
handle_send_next_command();
}
diff --git a/gd/l2cap/classic/internal/signalling_manager.h b/gd/l2cap/classic/internal/signalling_manager.h
index 0e17ec7..651da42 100644
--- a/gd/l2cap/classic/internal/signalling_manager.h
+++ b/gd/l2cap/classic/internal/signalling_manager.h
@@ -21,10 +21,12 @@
#include <vector>
#include "l2cap/cid.h"
+#include "l2cap/classic/internal/channel_configuration_state.h"
#include "l2cap/classic/internal/dynamic_channel_allocator.h"
#include "l2cap/classic/internal/dynamic_channel_service_manager_impl.h"
#include "l2cap/classic/internal/fixed_channel_impl.h"
#include "l2cap/classic/internal/fixed_channel_service_manager_impl.h"
+#include "l2cap/internal/data_pipeline_manager.h"
#include "l2cap/l2cap_packets.h"
#include "l2cap/psm.h"
#include "l2cap/signal_id.h"
@@ -53,6 +55,7 @@
class ClassicSignallingManager {
public:
ClassicSignallingManager(os::Handler* handler, Link* link,
+ l2cap::internal::DataPipelineManager* data_pipeline_manager,
classic::internal::DynamicChannelServiceManagerImpl* dynamic_service_manager,
classic::internal::DynamicChannelAllocator* channel_allocator,
classic::internal::FixedChannelServiceManagerImpl* fixed_service_manager);
@@ -103,6 +106,7 @@
os::Handler* handler_;
Link* link_;
+ [[maybe_unused]] l2cap::internal::DataPipelineManager* data_pipeline_manager_;
std::shared_ptr<classic::internal::FixedChannelImpl> signalling_channel_;
DynamicChannelServiceManagerImpl* dynamic_service_manager_;
DynamicChannelAllocator* channel_allocator_;
@@ -112,6 +116,7 @@
std::queue<PendingCommand> pending_commands_;
os::Alarm alarm_;
SignalId next_signal_id_ = kInitialSignalId;
+ std::unordered_map<Cid, ChannelConfigurationState> channel_configuration_;
};
} // namespace internal
diff --git a/gd/l2cap/internal/channel_impl.h b/gd/l2cap/internal/channel_impl.h
index ae17660..427a15f 100644
--- a/gd/l2cap/internal/channel_impl.h
+++ b/gd/l2cap/internal/channel_impl.h
@@ -47,13 +47,6 @@
virtual Cid GetCid() const = 0;
virtual Cid GetRemoteCid() const = 0;
-
- /**
- * Callback from the Scheduler to notify the Sender for this channel. On config update, channel might notify the
- * configuration change to Sender.
- * Fixed channel doesn't need to implement it, as it doesn't need to send config update to Sender.
- */
- virtual void SetSender(l2cap::internal::Sender* sender) = 0;
};
} // namespace internal
diff --git a/gd/l2cap/internal/channel_impl_mock.h b/gd/l2cap/internal/channel_impl_mock.h
index 710e69a..4430487 100644
--- a/gd/l2cap/internal/channel_impl_mock.h
+++ b/gd/l2cap/internal/channel_impl_mock.h
@@ -34,7 +34,6 @@
GetQueueDownEnd, (), (override));
MOCK_METHOD(Cid, GetCid, (), (const, override));
MOCK_METHOD(Cid, GetRemoteCid, (), (const, override));
- MOCK_METHOD(void, SetSender, (l2cap::internal::Sender*), (override));
};
} // namespace testing
diff --git a/gd/l2cap/internal/data_pipeline_manager.cc b/gd/l2cap/internal/data_pipeline_manager.cc
index d0023c0..1c8d973 100644
--- a/gd/l2cap/internal/data_pipeline_manager.cc
+++ b/gd/l2cap/internal/data_pipeline_manager.cc
@@ -30,9 +30,6 @@
ASSERT(sender_map_.find(cid) == sender_map_.end());
sender_map_.emplace(std::piecewise_construct, std::forward_as_tuple(cid),
std::forward_as_tuple(handler_, scheduler_.get(), channel));
- if (channel->GetCid() >= kFirstDynamicChannel) {
- channel->SetSender(&sender_map_.find(cid)->second);
- }
}
void DataPipelineManager::DetachChannel(Cid cid) {
@@ -50,6 +47,11 @@
sender_map_.find(cid)->second.OnPacketSent();
}
+void DataPipelineManager::UpdateClassicConfiguration(Cid cid, classic::internal::ChannelConfigurationState config) {
+ ASSERT(sender_map_.find(cid) != sender_map_.end());
+ sender_map_.find(cid)->second.UpdateClassicConfiguration(config);
+}
+
} // namespace internal
} // namespace l2cap
} // namespace bluetooth
diff --git a/gd/l2cap/internal/data_pipeline_manager.h b/gd/l2cap/internal/data_pipeline_manager.h
index f801297..fffbfc7 100644
--- a/gd/l2cap/internal/data_pipeline_manager.h
+++ b/gd/l2cap/internal/data_pipeline_manager.h
@@ -23,6 +23,7 @@
#include "common/bind.h"
#include "data_controller.h"
#include "l2cap/cid.h"
+#include "l2cap/classic/internal/channel_configuration_state.h"
#include "l2cap/internal/channel_impl.h"
#include "l2cap/internal/receiver.h"
#include "l2cap/internal/scheduler.h"
@@ -61,6 +62,7 @@
virtual void DetachChannel(Cid cid);
virtual DataController* GetDataController(Cid cid);
virtual void OnPacketSent(Cid cid);
+ virtual void UpdateClassicConfiguration(Cid cid, classic::internal::ChannelConfigurationState config);
virtual ~DataPipelineManager() = default;
private:
diff --git a/gd/l2cap/internal/sender.cc b/gd/l2cap/internal/sender.cc
index 7fe1dd7..1c146cf 100644
--- a/gd/l2cap/internal/sender.cc
+++ b/gd/l2cap/internal/sender.cc
@@ -14,20 +14,15 @@
* limitations under the License.
*/
-#include <string>
#include <unordered_map>
#include "common/bind.h"
-#include "l2cap/cid.h"
-#include "l2cap/classic/internal/dynamic_channel_impl.h"
#include "l2cap/internal/basic_mode_channel_data_controller.h"
#include "l2cap/internal/enhanced_retransmission_mode_channel_data_controller.h"
#include "l2cap/internal/scheduler.h"
#include "l2cap/internal/sender.h"
#include "os/handler.h"
#include "os/log.h"
-#include "os/queue.h"
-#include "packet/base_packet_builder.h"
namespace bluetooth {
namespace l2cap {
@@ -55,32 +50,6 @@
return data_controller_->GetNextPacket();
}
-void Sender::SetChannelRetransmissionFlowControlMode(const RetransmissionAndFlowControlConfigurationOption& option) {
- if (mode_ == option.mode_) {
- return;
- }
- if (option.mode_ == RetransmissionAndFlowControlModeOption::L2CAP_BASIC) {
- data_controller_ =
- std::make_unique<BasicModeDataController>(channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
- return;
- }
- if (option.mode_ == RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION) {
- data_controller_ =
- std::make_unique<ErtmController>(channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
- data_controller_->SetRetransmissionAndFlowControlOptions(option);
- return;
- }
-}
-
-void Sender::SetFcsType(FcsType fcs_type) {
- // TODO: FCS is enabled when "not both side explicitly disable it".
- data_controller_->EnableFcs(fcs_type == FcsType::DEFAULT);
-}
-
-void Sender::SetIncomingMtu(Mtu mtu) {
- // TODO: Enforce MTU
-}
-
DataController* Sender::GetDataController() {
return data_controller_.get();
}
@@ -101,6 +70,25 @@
is_dequeue_registered_ = false;
}
+void Sender::UpdateClassicConfiguration(classic::internal::ChannelConfigurationState config) {
+ auto mode = config.retransmission_and_flow_control_mode_;
+ if (mode == mode_) {
+ return;
+ }
+ if (mode == RetransmissionAndFlowControlModeOption::L2CAP_BASIC) {
+ data_controller_ =
+ std::make_unique<BasicModeDataController>(channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
+ return;
+ }
+ if (mode == RetransmissionAndFlowControlModeOption::ENHANCED_RETRANSMISSION) {
+ data_controller_ =
+ std::make_unique<ErtmController>(channel_id_, remote_channel_id_, queue_end_, handler_, scheduler_);
+ data_controller_->SetRetransmissionAndFlowControlOptions(config.local_retransmission_and_flow_control_);
+ data_controller_->EnableFcs(config.fcs_type_ == FcsType::DEFAULT);
+ return;
+ }
+}
+
} // namespace internal
} // namespace l2cap
} // namespace bluetooth
diff --git a/gd/l2cap/internal/sender.h b/gd/l2cap/internal/sender.h
index 850a88d..46e0006 100644
--- a/gd/l2cap/internal/sender.h
+++ b/gd/l2cap/internal/sender.h
@@ -23,6 +23,7 @@
#include "common/bind.h"
#include "data_controller.h"
#include "l2cap/cid.h"
+#include "l2cap/classic/internal/channel_configuration_state.h"
#include "l2cap/internal/channel_impl.h"
#include "l2cap/internal/data_controller.h"
#include "l2cap/l2cap_packets.h"
@@ -61,10 +62,7 @@
*/
std::unique_ptr<UpperDequeue> GetNextPacket();
- void SetChannelRetransmissionFlowControlMode(const RetransmissionAndFlowControlConfigurationOption& option);
- void SetFcsType(FcsType fcs_type);
- void SetIncomingMtu(Mtu mtu);
-
+ void UpdateClassicConfiguration(classic::internal::ChannelConfigurationState config);
DataController* GetDataController();
private:
diff --git a/gd/l2cap/le/internal/fixed_channel_impl.cc b/gd/l2cap/le/internal/fixed_channel_impl.cc
index 9ae4e1f..e09b80d 100644
--- a/gd/l2cap/le/internal/fixed_channel_impl.cc
+++ b/gd/l2cap/le/internal/fixed_channel_impl.cc
@@ -107,10 +107,6 @@
return cid_;
}
-void FixedChannelImpl::SetSender(l2cap::internal::Sender* sender) {
- ASSERT_LOG(false, "Should not set sender for fixed channel");
-}
-
} // namespace internal
} // namespace le
} // namespace l2cap
diff --git a/gd/l2cap/le/internal/fixed_channel_impl.h b/gd/l2cap/le/internal/fixed_channel_impl.h
index 82a4125..5d6a11d 100644
--- a/gd/l2cap/le/internal/fixed_channel_impl.h
+++ b/gd/l2cap/le/internal/fixed_channel_impl.h
@@ -55,7 +55,6 @@
Cid GetCid() const override;
Cid GetRemoteCid() const override;
- void SetSender(l2cap::internal::Sender* sender) override;
virtual void OnClosed(hci::ErrorCode status);
virtual std::string ToString() {
