proxy_host.h

// Copyright 2024 The Pigweed Authors
//
// 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
//
//     https://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 "pw_bluetooth_proxy/gatt_notify_channel.h"
#include "pw_bluetooth_proxy/internal/acl_data_channel.h"
#include "pw_bluetooth_proxy/internal/h4_storage.h"
#include "pw_bluetooth_proxy/internal/hci_transport.h"
#include "pw_bluetooth_proxy/internal/l2cap_channel_manager.h"
#include "pw_bluetooth_proxy/l2cap_channel_common.h"
#include "pw_bluetooth_proxy/l2cap_coc.h"
#include "pw_bluetooth_proxy/l2cap_status_delegate.h"
#include "pw_bluetooth_proxy/rfcomm_channel.h"
#include "pw_status/status.h"
 
namespace pw::bluetooth::proxy {
 
class ProxyHost {
 public:
  ProxyHost(pw::Function<void(H4PacketWithHci&& packet)>&& send_to_host_fn,
            pw::Function<void(H4PacketWithH4&& packet)>&& send_to_controller_fn,
            uint16_t le_acl_credits_to_reserve,
            uint16_t br_edr_acl_credits_to_reserve);
 
  ProxyHost() = delete;
  ProxyHost(const ProxyHost&) = delete;
  ProxyHost& operator=(const ProxyHost&) = delete;
  ProxyHost(ProxyHost&&) = delete;
  ProxyHost& operator=(ProxyHost&&) = delete;
  ~ProxyHost();
 
  // ##### Container API
  // Containers are expected to call these functions (in addition to ctor).
 
  void HandleH4HciFromHost(H4PacketWithH4&& h4_packet);
 
  void HandleH4HciFromController(H4PacketWithHci&& h4_packet);
 
  void Reset();
 
  // ##### Client APIs
 
  void RegisterL2capStatusDelegate(L2capStatusDelegate& delegate);
 
  void UnregisterL2capStatusDelegate(L2capStatusDelegate& delegate);
 
  pw::Result<L2capCoc> AcquireL2capCoc(
      pw::multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      L2capCoc::CocConfig rx_config,
      L2capCoc::CocConfig tx_config,
      Function<void(multibuf::MultiBuf&& payload)>&& receive_fn,
      ChannelEventCallback&& event_fn);
 
  pw::Status SendAdditionalRxCredits(uint16_t connection_handle,
                                     uint16_t local_cid,
                                     uint16_t additional_rx_credits);
 
  pw::Result<BasicL2capChannel> AcquireBasicL2capChannel(
      multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      uint16_t local_cid,
      uint16_t remote_cid,
      AclTransportType transport,
      OptionalPayloadReceiveCallback&& payload_from_controller_fn,
      OptionalPayloadReceiveCallback&& payload_from_host_fn,
      ChannelEventCallback&& event_fn);
 
  pw::Result<GattNotifyChannel> AcquireGattNotifyChannel(
      int16_t connection_handle,
      uint16_t attribute_handle,
      ChannelEventCallback&& event_fn);
 
  // TODO: https://pwbug.dev/369709521 - Delete this once all downstreams
  // have transitioned.
  StatusWithMultiBuf SendGattNotify(uint16_t connection_handle,
                                    uint16_t attribute_handle,
                                    pw::multibuf::MultiBuf&& payload);
 
  // TODO: https://pwbug.dev/379337272 - Delete this once all downstreams
  // have transitioned.
  pw::Status SendGattNotify(uint16_t connection_handle,
                            uint16_t attribute_handle,
                            pw::span<const uint8_t> attribute_value);
 
  pw::Result<RfcommChannel> AcquireRfcommChannel(
      multibuf::MultiBufAllocator& rx_multibuf_allocator,
      uint16_t connection_handle,
      RfcommChannel::Config rx_config,
      RfcommChannel::Config tx_config,
      uint8_t channel_number,
      Function<void(multibuf::MultiBuf&& payload)>&& payload_from_controller_fn,
      ChannelEventCallback&& event_fn);
 
  bool HasSendLeAclCapability() const;
 
  bool HasSendBrEdrAclCapability() const;
 
  uint16_t GetNumFreeLeAclPackets() const;
 
  uint16_t GetNumFreeBrEdrAclPackets() const;
 
  static constexpr size_t GetNumSimultaneousAclSendsSupported() {
    return H4Storage::GetNumH4Buffs();
  }
 
  static constexpr size_t GetMaxAclSendSize() {
    return H4Storage::GetH4BuffSize() - sizeof(emboss::H4PacketType);
  }
 
  static constexpr size_t GetMaxNumAclConnections() {
    return AclDataChannel::GetMaxNumAclConnections();
  }
 
 private:
  // Handle HCI Event packet from the controller.
  void HandleEventFromController(H4PacketWithHci&& h4_packet);
 
  // Handle HCI Event packet from the host.
  void HandleEventFromHost(H4PacketWithH4&& h4_packet);
 
  // Handle HCI ACL data packet from the controller.
  void HandleAclFromController(H4PacketWithHci&& h4_packet);
 
  // Process an LE_META_EVENT
  void HandleLeMetaEvent(H4PacketWithHci&& h4_packet);
 
  // Process a Command_Complete event.
  void HandleCommandCompleteEvent(H4PacketWithHci&& h4_packet);
 
  // Handle HCI Command packet from the host.
  void HandleCommandFromHost(H4PacketWithH4&& h4_packet);
 
  // Handle HCI ACL data packet from the host.
  void HandleAclFromHost(H4PacketWithH4&& h4_packet);
 
  // For sending non-ACL data to the host and controller. ACL traffic shall be
  // sent through the `acl_data_channel_`.
  HciTransport hci_transport_;
 
  // Owns management of the LE ACL data channel.
  AclDataChannel acl_data_channel_;
 
  // Keeps track of the L2CAP-based channels managed by the proxy.
  L2capChannelManager l2cap_channel_manager_;
};
 
}  // namespace pw::bluetooth::proxy