basic_ice_controller.h

/*

 *  Copyright 2019 The WebRTC Project Authors. All rights reserved.

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree. An additional intellectual property rights grant can be found

 *  in the file PATENTS.  All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

*/

#ifndef P2P_BASE_BASIC_ICE_CONTROLLER_H_

#define P2P_BASE_BASIC_ICE_CONTROLLER_H_

#include <algorithm>

#include <map>

#include <set>

#include <utility>

#include <vector>

#include "p2p/base/ice_controller_factory_interface.h"

#include "p2p/base/ice_controller_interface.h"

namespace cricket {

class BasicIceController : public IceControllerInterface {

 public:

  explicit BasicIceController(const IceControllerFactoryArgs& args);

  virtual ~BasicIceController();

  void SetIceConfig(const IceConfig& config) override;

  void SetSelectedConnection(const Connection* selected_connection) override;

  void AddConnection(const Connection* connection) override;

  void OnConnectionDestroyed(const Connection* connection) override;

  rtc::ArrayView<const Connection* const> GetConnections() const override {

    return connections_;

  rtc::ArrayView<const Connection*> connections() const override {

    return rtc::ArrayView<const Connection*>(

        const_cast<const Connection**>(connections_.data()),

        connections_.size());

  bool HasPingableConnection() const override;

  PingResult SelectConnectionToPing(int64_t last_ping_sent_ms) override;

  bool GetUseCandidateAttr(const Connection* conn,

                           NominationMode mode,

                           IceMode remote_ice_mode) const override;

  SwitchResult ShouldSwitchConnection(IceSwitchReason reason,

                                      const Connection* connection) override;

  SwitchResult SortAndSwitchConnection(IceSwitchReason reason) override;

  std::vector<const Connection*> PruneConnections() override;

  // These methods are only for tests.

  const Connection* FindNextPingableConnection() override;

  void MarkConnectionPinged(const Connection* conn) override;

 private:

  // A transport channel is weak if the current best connection is either

  // not receiving or not writable, or if there is no best connection at all.

  bool weak() const {

    return !selected_connection_ || selected_connection_->weak();

  int weak_ping_interval() const {

    return std::max(config_.ice_check_interval_weak_connectivity_or_default(),

                    config_.ice_check_min_interval_or_default());

  int strong_ping_interval() const {

    return std::max(config_.ice_check_interval_strong_connectivity_or_default(),

                    config_.ice_check_min_interval_or_default());

  int check_receiving_interval() const {

    return std::max(MIN_CHECK_RECEIVING_INTERVAL,

                    config_.receiving_timeout_or_default() / 10);

  const Connection* FindOldestConnectionNeedingTriggeredCheck(int64_t now);

  // Between `conn1` and `conn2`, this function returns the one which should

  // be pinged first.

  const Connection* MorePingable(const Connection* conn1,

                                 const Connection* conn2);

  // Select the connection which is Relay/Relay. If both of them are,

  // UDP relay protocol takes precedence.

  const Connection* MostLikelyToWork(const Connection* conn1,

                                     const Connection* conn2);

  // Compare the last_ping_sent time and return the one least recently pinged.

  const Connection* LeastRecentlyPinged(const Connection* conn1,

                                        const Connection* conn2);

  bool IsPingable(const Connection* conn, int64_t now) const;

  bool IsBackupConnection(const Connection* conn) const;

  // Whether a writable connection is past its ping interval and needs to be

  // pinged again.

  bool WritableConnectionPastPingInterval(const Connection* conn,

                                          int64_t now) const;

  int CalculateActiveWritablePingInterval(const Connection* conn,

                                          int64_t now) const;

  std::map<const rtc::Network*, const Connection*> GetBestConnectionByNetwork()

      const;

  std::vector<const Connection*> GetBestWritableConnectionPerNetwork() const;

  bool ReadyToSend(const Connection* connection) const;

  bool PresumedWritable(const Connection* conn) const;

  int CompareCandidatePairNetworks(

      const Connection* a,

      const Connection* b,

      std::optional<rtc::AdapterType> network_preference) const;

  // The methods below return a positive value if `a` is preferable to `b`,

  // a negative value if `b` is preferable, and 0 if they're equally preferable.

  // If `receiving_unchanged_threshold` is set, then when `b` is receiving and

  // `a` is not, returns a negative value only if `b` has been in receiving

  // state and `a` has been in not receiving state since

  // `receiving_unchanged_threshold` and sets

  // `missed_receiving_unchanged_threshold` to true otherwise.

  int CompareConnectionStates(

      const Connection* a,

      const Connection* b,

      std::optional<int64_t> receiving_unchanged_threshold,

      bool* missed_receiving_unchanged_threshold) const;

  int CompareConnectionCandidates(const Connection* a,

                                  const Connection* b) const;

  // Compares two connections based on the connection states

  // (writable/receiving/connected), nomination states, last data received time,

  // and static preferences. Does not include latency. Used by both sorting

  // and ShouldSwitchSelectedConnection().

  // Returns a positive value if `a` is better than `b`.

  int CompareConnections(const Connection* a,

                         const Connection* b,

                         std::optional<int64_t> receiving_unchanged_threshold,

                         bool* missed_receiving_unchanged_threshold) const;

  SwitchResult HandleInitialSelectDampening(IceSwitchReason reason,

                                            const Connection* new_connection);

  std::function<IceTransportState()> ice_transport_state_func_;

  std::function<IceRole()> ice_role_func_;

  std::function<bool(const Connection*)> is_connection_pruned_func_;

  IceConfig config_;

  const IceFieldTrials* field_trials_;

  // `connections_` is a sorted list with the first one always be the

  // `selected_connection_` when it's not nullptr. The combination of

  // `pinged_connections_` and `unpinged_connections_` has the same

  // connections as `connections_`. These 2 sets maintain whether a

  // connection should be pinged next or not.

  const Connection* selected_connection_ = nullptr;

  std::vector<const Connection*> connections_;

  std::set<const Connection*> pinged_connections_;

  std::set<const Connection*> unpinged_connections_;

  // Timestamp for when we got the first selectable connection.

  int64_t initial_select_timestamp_ms_ = 0;

};

}  // namespace cricket

#endif  // P2P_BASE_BASIC_ICE_CONTROLLER_H_