Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/talk/examples/peerconnection/client/conductor.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 15.2 KB
Line 
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.
40const char kCandidateSdpMidName[] = "sdpMid";
41const char kCandidateSdpMlineIndexName[] = "sdpMLineIndex";
42const char kCandidateSdpName[] = "candidate";
43
44// Names used for a SessionDescription JSON object.
45const char kSessionDescriptionTypeName[] = "type";
46const char kSessionDescriptionSdpName[] = "sdp";
47
48class DummySetSessionDescriptionObserver
49    : public webrtc::SetSessionDescriptionObserver {
50 public:
51  static DummySetSessionDescriptionObserver* Create() {
52    return
53        new talk_base::RefCountedObject<DummySetSessionDescriptionObserver>();
54  }
55  virtual void OnSuccess() {
56    LOG(INFO) << __FUNCTION__;
57  }
58  virtual void OnFailure(const std::string& error) {
59    LOG(INFO) << __FUNCTION__ << " " << error;
60  }
61
62 protected:
63  DummySetSessionDescriptionObserver() {}
64  ~DummySetSessionDescriptionObserver() {}
65};
66
67Conductor::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
75Conductor::~Conductor() {
76  ASSERT(peer_connection_.get() == NULL);
77}
78
79bool Conductor::connection_active() const {
80  return peer_connection_.get() != NULL;
81}
82
83void Conductor::Close() {
84  client_->SignOut();
85  DeletePeerConnection();
86}
87
88bool 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
118void 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
127void 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
139void 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
145void 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
153void Conductor::OnRemoveStream(webrtc::MediaStreamInterface* stream) {
154  LOG(INFO) << __FUNCTION__ << " " << stream->label();
155  stream->AddRef();
156  main_wnd_->QueueUIThreadCallback(STREAM_REMOVED,
157                                   stream);
158}
159
160void 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
180void Conductor::OnSignedIn() {
181  LOG(INFO) << __FUNCTION__;
182  main_wnd_->SwitchToPeerList(client_->peers());
183}
184
185void Conductor::OnDisconnected() {
186  LOG(INFO) << __FUNCTION__;
187
188  DeletePeerConnection();
189
190  if (main_wnd_->IsWindow())
191    main_wnd_->SwitchToConnectUI();
192}
193
194void 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
201void 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
213void 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
289void Conductor::OnMessageSent(int err) {
290  // Process the next pending message if any.
291  main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, NULL);
292}
293
294void Conductor::OnServerConnectionFailure() {
295    main_wnd_->MessageBox("Error", ("Failed to connect to " + server_).c_str(),
296                          true);
297}
298
299//
300// MainWndCallback implementation.
301//
302
303void 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
310void Conductor::DisconnectFromServer() {
311  if (client_->is_connected())
312    client_->SignOut();
313}
314
315void 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
333cricket::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
355void 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
385void 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
396void 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
475void 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
487void Conductor::OnFailure(const std::string& error) {
488    LOG(LERROR) << error;
489}
490
491void 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}
Note: See TracBrowser for help on using the repository browser.