1 #ifndef TGCALLS_NETWORK_MANAGER_H
2 #define TGCALLS_NETWORK_MANAGER_H
3 
4 #include "rtc_base/thread.h"
5 
6 #include "EncryptedConnection.h"
7 #include "Instance.h"
8 #include "Message.h"
9 #include "Stats.h"
10 
11 #include "rtc_base/copy_on_write_buffer.h"
12 #include "api/candidate.h"
13 #include "rtc_base/network_monitor_factory.h"
14 
15 #include <functional>
16 #include <memory>
17 
18 namespace rtc {
19 class BasicPacketSocketFactory;
20 class BasicNetworkManager;
21 class PacketTransportInternal;
22 struct NetworkRoute;
23 } // namespace rtc
24 
25 namespace cricket {
26 class BasicPortAllocator;
27 class P2PTransportChannel;
28 class IceTransportInternal;
29 } // namespace cricket
30 
31 namespace webrtc {
32 class BasicAsyncResolverFactory;
33 class TurnCustomizer;
34 } // namespace webrtc
35 
36 namespace tgcalls {
37 
38 struct Message;
39 
40 class NetworkManager : public sigslot::has_slots<>, public std::enable_shared_from_this<NetworkManager> {
41 public:
42 	struct State {
43 		bool isReadyToSendData = false;
44         bool isFailed = false;
45 	};
46 
47     struct InterfaceTrafficStats {
48         int64_t incoming = 0;
49         int64_t outgoing = 0;
50     };
51 
52 	NetworkManager(
53 		rtc::Thread *thread,
54 		EncryptionKey encryptionKey,
55 		bool enableP2P,
56         bool enableTCP,
57         bool enableStunMarking,
58 		std::vector<RtcServer> const &rtcServers,
59         std::unique_ptr<Proxy> proxy,
60 		std::function<void(const State &)> stateUpdated,
61 		std::function<void(DecryptedMessage &&)> transportMessageReceived,
62 		std::function<void(Message &&)> sendSignalingMessage,
63 		std::function<void(int delayMs, int cause)> sendTransportServiceAsync);
64 	~NetworkManager();
65 
66     void start();
67 	void receiveSignalingMessage(DecryptedMessage &&message);
68 	uint32_t sendMessage(const Message &message);
69 	void sendTransportService(int cause);
70     void setIsLocalNetworkLowCost(bool isLocalNetworkLowCost);
71     TrafficStats getNetworkStats();
72     void fillCallStats(CallStats &callStats);
73     void logCurrentNetworkState();
74 
75 private:
76     void checkConnectionTimeout();
77 	void candidateGathered(cricket::IceTransportInternal *transport, const cricket::Candidate &candidate);
78 	void candidateGatheringState(cricket::IceTransportInternal *transport);
79 	void transportStateChanged(cricket::IceTransportInternal *transport);
80 	void transportReadyToSend(cricket::IceTransportInternal *transport);
81 	void transportPacketReceived(rtc::PacketTransportInternal *transport, const char *bytes, size_t size, const int64_t &timestamp, int unused);
82     void transportRouteChanged(absl::optional<rtc::NetworkRoute> route);
83     void addTrafficStats(int64_t byteCount, bool isIncoming);
84 
85 	rtc::Thread *_thread = nullptr;
86     bool _enableP2P = false;
87     bool _enableTCP = false;
88     bool _enableStunMarking = false;
89     std::vector<RtcServer> _rtcServers;
90     std::unique_ptr<Proxy> _proxy;
91 	EncryptedConnection _transport;
92 	bool _isOutgoing = false;
93 	std::function<void(const NetworkManager::State &)> _stateUpdated;
94 	std::function<void(DecryptedMessage &&)> _transportMessageReceived;
95 	std::function<void(Message &&)> _sendSignalingMessage;
96 
97     std::unique_ptr<rtc::NetworkMonitorFactory> _networkMonitorFactory;
98 	std::unique_ptr<rtc::BasicPacketSocketFactory> _socketFactory;
99 	std::unique_ptr<rtc::BasicNetworkManager> _networkManager;
100     std::unique_ptr<webrtc::TurnCustomizer> _turnCustomizer;
101 	std::unique_ptr<cricket::BasicPortAllocator> _portAllocator;
102 	std::unique_ptr<webrtc::BasicAsyncResolverFactory> _asyncResolverFactory;
103 	std::unique_ptr<cricket::P2PTransportChannel> _transportChannel;
104 
105     PeerIceParameters _localIceParameters;
106     absl::optional<PeerIceParameters> _remoteIceParameters;
107 
108     bool _isLocalNetworkLowCost = false;
109     int64_t _lastNetworkActivityMs = 0;
110     InterfaceTrafficStats _trafficStatsWifi;
111     InterfaceTrafficStats _trafficStatsCellular;
112 
113     absl::optional<CallStatsConnectionEndpointType> _currentEndpointType;
114     std::vector<CallStatsNetworkRecord> _networkRecords;
115 };
116 
117 } // namespace tgcalls
118 
119 #endif
120