test_vendor_lib: Use EPOLLOUT

#

#

#  Copyright (C) 2015 Google, Inc.

#

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

// controller object) instead of registering its methods as callbacks?

class BREDRController {

 public:

  // Registers command callbacks with the HciHandler instance so that they are

  // fired when the corresponding opcode is received from the HCI. For now, each

  // command must be individually registered. This allows for some flexibility

  // in which commands are made available by which controller.

  void RegisterHandlerCallbacks();

  // Functions that operate on the global controller instance. Initialize()

  // is called by the vendor library's Init() function to create the global

  // controller and must be called before Get() and CleanUp().

  // CleanUp() method that destructs the global controller.

  ~BREDRController() = default;

  // Registers command callbacks with the HciHandler instance so that they are

  // fired when the corresponding opcode is received from the HCI. For now, each

  // command must be individually registered. This allows for some flexibility

  // in which commands are made available by which controller.

  void RegisterHandlerCallbacks();

  // Maintains the commands to be registered and used in the HciHandler object.

  // Keys are command opcodes and values are the callbacks to handle each

  // command.

// object and called when commands and data are sent by the host.

class HciHandler {

 public:

  // Sets the command and data callbacks for when packets are received from the

  // HCI.

  void RegisterTransportCallbacks();

  // Functions that operate on the global handler instance. Initialize()

  // is called by the vendor library's Init() function to create the global

  // handler and must be called before Get() and CleanUp().

  // CleanUp() method that destructs the global handler.

  ~HciHandler() = default;

  // Sets the command and data callbacks for when packets are received from the

  // HCI.

  void RegisterTransportCallbacks();

  // Disallow any copies of the singleton to be made.

  DISALLOW_COPY_AND_ASSIGN(HciHandler);

//

// 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,

// 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.

#include <functional>

#include <memory>

#include <queue>

#include <base/macros.h>

  void RegisterCommandCallback(

      std::function<void(std::unique_ptr<CommandPacket>)> callback);

  // TODO(dennischeng): Determine correct management of event object, what if

  // write doesn't finish before destruction?

  void SendEvent(const EventPacket& event);

  // Posts the event onto |outgoing_events_| to be written whenever the HCI file

  // descriptor is ready for writing.

  void SendEvent(std::unique_ptr<EventPacket> event);

 private:

  // Loops through the epoll event buffer and receives packets if they are

  // ready. Fires the corresponding handler callback for each received packet.

  bool ReceiveReadyPackets(const epoll_event& event_buffer,

                          int num_ready);

  bool CheckReadyEpollEvents(const epoll_event& event_buffer, int num_ready);

  // Receives a packet from the HCI whenever the event loop signals that there

  // is data to be received.

  bool ReceiveReadyPacket() const;

  // Reads in a command packet and calls the handler's command ready callback,

  // passing owernship of the command packet to the handler.

  void ReceiveReadyCommand();

  void ReceiveReadyCommand() const;

  // Sends the event at the front of |outgoing_events_| to the HCI.

  bool SendReadyEvent();

  // There will only be one global instance of the HCI transport used by

  // bt_vendor.cc and accessed via the static GetInstance() function.

  // TODO(dennischeng): import base/ and use a MessageLoopForIO for event loop.

  bool ConfigEpoll();

  // Disallow any copies of the singleton to be made.

  DISALLOW_COPY_AND_ASSIGN(HciTransport);

  // Write queue for sending events to the HCI. Event packets are removed from

  // the queue and written when write-readiness is signalled.

  std::queue<std::unique_ptr<EventPacket>> outgoing_events_;

  // Callback executed in Listen() for command packets.

  std::function<void(std::unique_ptr<CommandPacket>)> command_callback_;

  // |socketpair_fds_[0]| is the listener end and is closed in the PacketStream

  // object. |socketpair_fds_[1]| is the HCI end and is closed in bt_vendor.cc.

  int socketpair_fds_[2];

  // Disallow any copies of the singleton to be made.

  DISALLOW_COPY_AND_ASSIGN(HciTransport);

};

}  // namespace test_vendor_lib

  // Reads a command packet and returns the packet back to the caller, along

  // with the responsibility of managing the packet's memory.

  std::unique_ptr<CommandPacket> ReceiveCommand();

  std::unique_ptr<CommandPacket> ReceiveCommand() const;

  // Reads and interprets a single octet as a packet type octet. Validates the

  // type octet for correctness.

  serial_data_type_t ReceivePacketType();

  serial_data_type_t ReceivePacketType() const;

  // Sends an event to the HCI. The memory management and ownership of the event

  // is left with the caller.

  void SendEvent(const EventPacket& event);

  bool SendEvent(const EventPacket& event) const;

  // Sets the file descriptor used in reading and writing. The PacketStream

  // takes ownership of the descriptor at |fd| and closes it during destruction.

  // DATA_TYPE_SCO.

  bool ValidateTypeOctet(serial_data_type_t type) const;

  // Attempts to receive |num_octets_to_receive| into |buffer|, returning

  // Attempts to receive |num_octets_to_receive| into |destination|, returning

  // false if an error occurs.

  bool ReceiveData(std::vector<std::uint8_t>& buffer,

                  size_t num_octets_to_receive);

  bool ReceiveAll(std::vector<std::uint8_t>& destination,

                  size_t num_octets_to_receive) const;

  // Attempts to send |num_octets_to_send| from |source|, returning false if an

  // error occurs.

  bool SendData(const std::vector<std::uint8_t>& source,

               size_t num_octets_to_send);

  bool SendAll(const std::vector<std::uint8_t>& source,

               size_t num_octets_to_send) const;

  // File descriptor to read from and write to. This is the descriptor given to

  // the HCI from the HciTransport.