1 /*
2 * libjingle
3 * Copyright 2012, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "talk/examples/peerconnection/client/conductor.h"
29
30 #include <utility>
31
32 #include "talk/app/webrtc/videosourceinterface.h"
33 #include "talk/base/common.h"
34 #include "talk/base/json.h"
35 #include "talk/base/logging.h"
36 #include "talk/examples/peerconnection/client/defaults.h"
37 #include "talk/media/devices/devicemanager.h"
38
39 // Names used for a IceCandidate JSON object.
40 const char kCandidateSdpMidName[] = "sdpMid";
41 const char kCandidateSdpMlineIndexName[] = "sdpMLineIndex";
42 const char kCandidateSdpName[] = "candidate";
43
44 // Names used for a SessionDescription JSON object.
45 const char kSessionDescriptionTypeName[] = "type";
46 const char kSessionDescriptionSdpName[] = "sdp";
47
48 class DummySetSessionDescriptionObserver
49 : public webrtc::SetSessionDescriptionObserver {
50 public:
Create()51 static DummySetSessionDescriptionObserver* Create() {
52 return
53 new talk_base::RefCountedObject<DummySetSessionDescriptionObserver>();
54 }
OnSuccess()55 virtual void OnSuccess() {
56 LOG(INFO) << __FUNCTION__;
57 }
OnFailure(const std::string & error)58 virtual void OnFailure(const std::string& error) {
59 LOG(INFO) << __FUNCTION__ << " " << error;
60 }
61
62 protected:
DummySetSessionDescriptionObserver()63 DummySetSessionDescriptionObserver() {}
~DummySetSessionDescriptionObserver()64 ~DummySetSessionDescriptionObserver() {}
65 };
66
Conductor(PeerConnectionClient * client,MainWindow * main_wnd)67 Conductor::Conductor(PeerConnectionClient* client, MainWindow* main_wnd)
68 : peer_id_(-1),
69 client_(client),
70 main_wnd_(main_wnd) {
71 client_->RegisterObserver(this);
72 main_wnd->RegisterObserver(this);
73 }
74
~Conductor()75 Conductor::~Conductor() {
76 ASSERT(peer_connection_.get() == NULL);
77 }
78
connection_active() const79 bool Conductor::connection_active() const {
80 return peer_connection_.get() != NULL;
81 }
82
Close()83 void Conductor::Close() {
84 client_->SignOut();
85 DeletePeerConnection();
86 }
87
InitializePeerConnection()88 bool Conductor::InitializePeerConnection() {
89 ASSERT(peer_connection_factory_.get() == NULL);
90 ASSERT(peer_connection_.get() == NULL);
91
92 peer_connection_factory_ = webrtc::CreatePeerConnectionFactory();
93
94 if (!peer_connection_factory_.get()) {
95 main_wnd_->MessageBox("Error",
96 "Failed to initialize PeerConnectionFactory", true);
97 DeletePeerConnection();
98 return false;
99 }
100
101 webrtc::PeerConnectionInterface::IceServers servers;
102 webrtc::PeerConnectionInterface::IceServer server;
103 server.uri = GetPeerConnectionString();
104 servers.push_back(server);
105 peer_connection_ = peer_connection_factory_->CreatePeerConnection(servers,
106 NULL,
107 NULL,
108 this);
109 if (!peer_connection_.get()) {
110 main_wnd_->MessageBox("Error",
111 "CreatePeerConnection failed", true);
112 DeletePeerConnection();
113 }
114 AddStreams();
115 return peer_connection_.get() != NULL;
116 }
117
DeletePeerConnection()118 void Conductor::DeletePeerConnection() {
119 peer_connection_ = NULL;
120 active_streams_.clear();
121 main_wnd_->StopLocalRenderer();
122 main_wnd_->StopRemoteRenderer();
123 peer_connection_factory_ = NULL;
124 peer_id_ = -1;
125 }
126
EnsureStreamingUI()127 void Conductor::EnsureStreamingUI() {
128 ASSERT(peer_connection_.get() != NULL);
129 if (main_wnd_->IsWindow()) {
130 if (main_wnd_->current_ui() != MainWindow::STREAMING)
131 main_wnd_->SwitchToStreamingUI();
132 }
133 }
134
135 //
136 // PeerConnectionObserver implementation.
137 //
138
OnError()139 void Conductor::OnError() {
140 LOG(LS_ERROR) << __FUNCTION__;
141 main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_ERROR, NULL);
142 }
143
144 // Called when a remote stream is added
OnAddStream(webrtc::MediaStreamInterface * stream)145 void Conductor::OnAddStream(webrtc::MediaStreamInterface* stream) {
146 LOG(INFO) << __FUNCTION__ << " " << stream->label();
147
148 stream->AddRef();
149 main_wnd_->QueueUIThreadCallback(NEW_STREAM_ADDED,
150 stream);
151 }
152
OnRemoveStream(webrtc::MediaStreamInterface * stream)153 void Conductor::OnRemoveStream(webrtc::MediaStreamInterface* stream) {
154 LOG(INFO) << __FUNCTION__ << " " << stream->label();
155 stream->AddRef();
156 main_wnd_->QueueUIThreadCallback(STREAM_REMOVED,
157 stream);
158 }
159
OnIceCandidate(const webrtc::IceCandidateInterface * candidate)160 void Conductor::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {
161 LOG(INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index();
162 Json::StyledWriter writer;
163 Json::Value jmessage;
164
165 jmessage[kCandidateSdpMidName] = candidate->sdp_mid();
166 jmessage[kCandidateSdpMlineIndexName] = candidate->sdp_mline_index();
167 std::string sdp;
168 if (!candidate->ToString(&sdp)) {
169 LOG(LS_ERROR) << "Failed to serialize candidate";
170 return;
171 }
172 jmessage[kCandidateSdpName] = sdp;
173 SendMessage(writer.write(jmessage));
174 }
175
176 //
177 // PeerConnectionClientObserver implementation.
178 //
179
OnSignedIn()180 void Conductor::OnSignedIn() {
181 LOG(INFO) << __FUNCTION__;
182 main_wnd_->SwitchToPeerList(client_->peers());
183 }
184
OnDisconnected()185 void Conductor::OnDisconnected() {
186 LOG(INFO) << __FUNCTION__;
187
188 DeletePeerConnection();
189
190 if (main_wnd_->IsWindow())
191 main_wnd_->SwitchToConnectUI();
192 }
193
OnPeerConnected(int id,const std::string & name)194 void Conductor::OnPeerConnected(int id, const std::string& name) {
195 LOG(INFO) << __FUNCTION__;
196 // Refresh the list if we're showing it.
197 if (main_wnd_->current_ui() == MainWindow::LIST_PEERS)
198 main_wnd_->SwitchToPeerList(client_->peers());
199 }
200
OnPeerDisconnected(int id)201 void Conductor::OnPeerDisconnected(int id) {
202 LOG(INFO) << __FUNCTION__;
203 if (id == peer_id_) {
204 LOG(INFO) << "Our peer disconnected";
205 main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_CLOSED, NULL);
206 } else {
207 // Refresh the list if we're showing it.
208 if (main_wnd_->current_ui() == MainWindow::LIST_PEERS)
209 main_wnd_->SwitchToPeerList(client_->peers());
210 }
211 }
212
OnMessageFromPeer(int peer_id,const std::string & message)213 void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
214 ASSERT(peer_id_ == peer_id || peer_id_ == -1);
215 ASSERT(!message.empty());
216
217 if (!peer_connection_.get()) {
218 ASSERT(peer_id_ == -1);
219 peer_id_ = peer_id;
220
221 if (!InitializePeerConnection()) {
222 LOG(LS_ERROR) << "Failed to initialize our PeerConnection instance";
223 client_->SignOut();
224 return;
225 }
226 } else if (peer_id != peer_id_) {
227 ASSERT(peer_id_ != -1);
228 LOG(WARNING) << "Received a message from unknown peer while already in a "
229 "conversation with a different peer.";
230 return;
231 }
232
233 Json::Reader reader;
234 Json::Value jmessage;
235 if (!reader.parse(message, jmessage)) {
236 LOG(WARNING) << "Received unknown message. " << message;
237 return;
238 }
239 std::string type;
240 std::string json_object;
241
242 GetStringFromJsonObject(jmessage, kSessionDescriptionTypeName, &type);
243 if (!type.empty()) {
244 std::string sdp;
245 if (!GetStringFromJsonObject(jmessage, kSessionDescriptionSdpName, &sdp)) {
246 LOG(WARNING) << "Can't parse received session description message.";
247 return;
248 }
249 webrtc::SessionDescriptionInterface* session_description(
250 webrtc::CreateSessionDescription(type, sdp));
251 if (!session_description) {
252 LOG(WARNING) << "Can't parse received session description message.";
253 return;
254 }
255 LOG(INFO) << " Received session description :" << message;
256 peer_connection_->SetRemoteDescription(
257 DummySetSessionDescriptionObserver::Create(), session_description);
258 if (session_description->type() ==
259 webrtc::SessionDescriptionInterface::kOffer) {
260 peer_connection_->CreateAnswer(this, NULL);
261 }
262 return;
263 } else {
264 std::string sdp_mid;
265 int sdp_mlineindex = 0;
266 std::string sdp;
267 if (!GetStringFromJsonObject(jmessage, kCandidateSdpMidName, &sdp_mid) ||
268 !GetIntFromJsonObject(jmessage, kCandidateSdpMlineIndexName,
269 &sdp_mlineindex) ||
270 !GetStringFromJsonObject(jmessage, kCandidateSdpName, &sdp)) {
271 LOG(WARNING) << "Can't parse received message.";
272 return;
273 }
274 talk_base::scoped_ptr<webrtc::IceCandidateInterface> candidate(
275 webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, sdp));
276 if (!candidate.get()) {
277 LOG(WARNING) << "Can't parse received candidate message.";
278 return;
279 }
280 if (!peer_connection_->AddIceCandidate(candidate.get())) {
281 LOG(WARNING) << "Failed to apply the received candidate";
282 return;
283 }
284 LOG(INFO) << " Received candidate :" << message;
285 return;
286 }
287 }
288
OnMessageSent(int err)289 void Conductor::OnMessageSent(int err) {
290 // Process the next pending message if any.
291 main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, NULL);
292 }
293
OnServerConnectionFailure()294 void Conductor::OnServerConnectionFailure() {
295 main_wnd_->MessageBox("Error", ("Failed to connect to " + server_).c_str(),
296 true);
297 }
298
299 //
300 // MainWndCallback implementation.
301 //
302
StartLogin(const std::string & server,int port)303 void Conductor::StartLogin(const std::string& server, int port) {
304 if (client_->is_connected())
305 return;
306 server_ = server;
307 client_->Connect(server, port, GetPeerName());
308 }
309
DisconnectFromServer()310 void Conductor::DisconnectFromServer() {
311 if (client_->is_connected())
312 client_->SignOut();
313 }
314
ConnectToPeer(int peer_id)315 void Conductor::ConnectToPeer(int peer_id) {
316 ASSERT(peer_id_ == -1);
317 ASSERT(peer_id != -1);
318
319 if (peer_connection_.get()) {
320 main_wnd_->MessageBox("Error",
321 "We only support connecting to one peer at a time", true);
322 return;
323 }
324
325 if (InitializePeerConnection()) {
326 peer_id_ = peer_id;
327 peer_connection_->CreateOffer(this, NULL);
328 } else {
329 main_wnd_->MessageBox("Error", "Failed to initialize PeerConnection", true);
330 }
331 }
332
OpenVideoCaptureDevice()333 cricket::VideoCapturer* Conductor::OpenVideoCaptureDevice() {
334 talk_base::scoped_ptr<cricket::DeviceManagerInterface> dev_manager(
335 cricket::DeviceManagerFactory::Create());
336 if (!dev_manager->Init()) {
337 LOG(LS_ERROR) << "Can't create device manager";
338 return NULL;
339 }
340 std::vector<cricket::Device> devs;
341 if (!dev_manager->GetVideoCaptureDevices(&devs)) {
342 LOG(LS_ERROR) << "Can't enumerate video devices";
343 return NULL;
344 }
345 std::vector<cricket::Device>::iterator dev_it = devs.begin();
346 cricket::VideoCapturer* capturer = NULL;
347 for (; dev_it != devs.end(); ++dev_it) {
348 capturer = dev_manager->CreateVideoCapturer(*dev_it);
349 if (capturer != NULL)
350 break;
351 }
352 return capturer;
353 }
354
AddStreams()355 void Conductor::AddStreams() {
356 if (active_streams_.find(kStreamLabel) != active_streams_.end())
357 return; // Already added.
358
359 talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
360 peer_connection_factory_->CreateAudioTrack(
361 kAudioLabel, peer_connection_factory_->CreateAudioSource(NULL)));
362
363 talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track(
364 peer_connection_factory_->CreateVideoTrack(
365 kVideoLabel,
366 peer_connection_factory_->CreateVideoSource(OpenVideoCaptureDevice(),
367 NULL)));
368 main_wnd_->StartLocalRenderer(video_track);
369
370 talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream =
371 peer_connection_factory_->CreateLocalMediaStream(kStreamLabel);
372
373 stream->AddTrack(audio_track);
374 stream->AddTrack(video_track);
375 if (!peer_connection_->AddStream(stream, NULL)) {
376 LOG(LS_ERROR) << "Adding stream to PeerConnection failed";
377 }
378 typedef std::pair<std::string,
379 talk_base::scoped_refptr<webrtc::MediaStreamInterface> >
380 MediaStreamPair;
381 active_streams_.insert(MediaStreamPair(stream->label(), stream));
382 main_wnd_->SwitchToStreamingUI();
383 }
384
DisconnectFromCurrentPeer()385 void Conductor::DisconnectFromCurrentPeer() {
386 LOG(INFO) << __FUNCTION__;
387 if (peer_connection_.get()) {
388 client_->SendHangUp(peer_id_);
389 DeletePeerConnection();
390 }
391
392 if (main_wnd_->IsWindow())
393 main_wnd_->SwitchToPeerList(client_->peers());
394 }
395
UIThreadCallback(int msg_id,void * data)396 void Conductor::UIThreadCallback(int msg_id, void* data) {
397 switch (msg_id) {
398 case PEER_CONNECTION_CLOSED:
399 LOG(INFO) << "PEER_CONNECTION_CLOSED";
400 DeletePeerConnection();
401
402 ASSERT(active_streams_.empty());
403
404 if (main_wnd_->IsWindow()) {
405 if (client_->is_connected()) {
406 main_wnd_->SwitchToPeerList(client_->peers());
407 } else {
408 main_wnd_->SwitchToConnectUI();
409 }
410 } else {
411 DisconnectFromServer();
412 }
413 break;
414
415 case SEND_MESSAGE_TO_PEER: {
416 LOG(INFO) << "SEND_MESSAGE_TO_PEER";
417 std::string* msg = reinterpret_cast<std::string*>(data);
418 if (msg) {
419 // For convenience, we always run the message through the queue.
420 // This way we can be sure that messages are sent to the server
421 // in the same order they were signaled without much hassle.
422 pending_messages_.push_back(msg);
423 }
424
425 if (!pending_messages_.empty() && !client_->IsSendingMessage()) {
426 msg = pending_messages_.front();
427 pending_messages_.pop_front();
428
429 if (!client_->SendToPeer(peer_id_, *msg) && peer_id_ != -1) {
430 LOG(LS_ERROR) << "SendToPeer failed";
431 DisconnectFromServer();
432 }
433 delete msg;
434 }
435
436 if (!peer_connection_.get())
437 peer_id_ = -1;
438
439 break;
440 }
441
442 case PEER_CONNECTION_ERROR:
443 main_wnd_->MessageBox("Error", "an unknown error occurred", true);
444 break;
445
446 case NEW_STREAM_ADDED: {
447 webrtc::MediaStreamInterface* stream =
448 reinterpret_cast<webrtc::MediaStreamInterface*>(
449 data);
450 webrtc::VideoTrackVector tracks = stream->GetVideoTracks();
451 // Only render the first track.
452 if (!tracks.empty()) {
453 webrtc::VideoTrackInterface* track = tracks[0];
454 main_wnd_->StartRemoteRenderer(track);
455 }
456 stream->Release();
457 break;
458 }
459
460 case STREAM_REMOVED: {
461 // Remote peer stopped sending a stream.
462 webrtc::MediaStreamInterface* stream =
463 reinterpret_cast<webrtc::MediaStreamInterface*>(
464 data);
465 stream->Release();
466 break;
467 }
468
469 default:
470 ASSERT(false);
471 break;
472 }
473 }
474
OnSuccess(webrtc::SessionDescriptionInterface * desc)475 void Conductor::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
476 peer_connection_->SetLocalDescription(
477 DummySetSessionDescriptionObserver::Create(), desc);
478 Json::StyledWriter writer;
479 Json::Value jmessage;
480 jmessage[kSessionDescriptionTypeName] = desc->type();
481 std::string sdp;
482 desc->ToString(&sdp);
483 jmessage[kSessionDescriptionSdpName] = sdp;
484 SendMessage(writer.write(jmessage));
485 }
486
OnFailure(const std::string & error)487 void Conductor::OnFailure(const std::string& error) {
488 LOG(LERROR) << error;
489 }
490
SendMessage(const std::string & json_object)491 void Conductor::SendMessage(const std::string& json_object) {
492 std::string* msg = new std::string(json_object);
493 main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, msg);
494 }
495