1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*
* Copyright 2011 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 EXAMPLES_PEERCONNECTION_CLIENT_PEER_CONNECTION_CLIENT_H_
#define EXAMPLES_PEERCONNECTION_CLIENT_PEER_CONNECTION_CLIENT_H_
#include <map>
#include <memory>
#include <string>
#include "api/async_dns_resolver.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "rtc_base/net_helpers.h"
#include "rtc_base/physical_socket_server.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
typedef std::map<int, std::string> Peers;
struct PeerConnectionClientObserver {
virtual void OnSignedIn() = 0; // Called when we're logged on.
virtual void OnDisconnected() = 0;
virtual void OnPeerConnected(int id, const std::string& name) = 0;
virtual void OnPeerDisconnected(int peer_id) = 0;
virtual void OnMessageFromPeer(int peer_id, const std::string& message) = 0;
virtual void OnMessageSent(int err) = 0;
virtual void OnServerConnectionFailure() = 0;
protected:
virtual ~PeerConnectionClientObserver() {}
};
class PeerConnectionClient : public sigslot::has_slots<> {
public:
enum State {
NOT_CONNECTED,
RESOLVING,
SIGNING_IN,
CONNECTED,
SIGNING_OUT_WAITING,
SIGNING_OUT,
};
PeerConnectionClient();
~PeerConnectionClient();
int id() const;
bool is_connected() const;
const Peers& peers() const;
void RegisterObserver(PeerConnectionClientObserver* callback);
void Connect(const std::string& server,
int port,
const std::string& client_name);
bool SendToPeer(int peer_id, const std::string& message);
bool SendHangUp(int peer_id);
bool IsSendingMessage();
bool SignOut();
protected:
void DoConnect();
void Close();
void InitSocketSignals();
bool ConnectControlSocket();
void OnConnect(rtc::Socket* socket);
void OnHangingGetConnect(rtc::Socket* socket);
void OnMessageFromPeer(int peer_id, const std::string& message);
// Quick and dirty support for parsing HTTP header values.
bool GetHeaderValue(const std::string& data,
size_t eoh,
const char* header_pattern,
size_t* value);
bool GetHeaderValue(const std::string& data,
size_t eoh,
const char* header_pattern,
std::string* value);
// Returns true if the whole response has been read.
bool ReadIntoBuffer(rtc::Socket* socket,
std::string* data,
size_t* content_length);
void OnRead(rtc::Socket* socket);
void OnHangingGetRead(rtc::Socket* socket);
// Parses a single line entry in the form "<name>,<id>,<connected>"
bool ParseEntry(const std::string& entry,
std::string* name,
int* id,
bool* connected);
int GetResponseStatus(const std::string& response);
bool ParseServerResponse(const std::string& response,
size_t content_length,
size_t* peer_id,
size_t* eoh);
void OnClose(rtc::Socket* socket, int err);
void OnResolveResult(const webrtc::AsyncDnsResolverResult& result);
PeerConnectionClientObserver* callback_;
rtc::SocketAddress server_address_;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver_;
std::unique_ptr<rtc::Socket> control_socket_;
std::unique_ptr<rtc::Socket> hanging_get_;
std::string onconnect_data_;
std::string control_data_;
std::string notification_data_;
std::string client_name_;
Peers peers_;
State state_;
int my_id_;
webrtc::ScopedTaskSafety safety_;
};
#endif // EXAMPLES_PEERCONNECTION_CLIENT_PEER_CONNECTION_CLIENT_H_
|
