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: 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 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 75 Conductor::~Conductor() { 76 ASSERT(peer_connection_.get() == NULL); 77 } 78 79 bool Conductor::connection_active() const { 80 return peer_connection_.get() != NULL; 81 } 82 83 void Conductor::Close() { 84 client_->SignOut(); 85 DeletePeerConnection(); 86 } 87 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 NULL, 109 this); 110 if (!peer_connection_.get()) { 111 main_wnd_->MessageBox("Error", 112 "CreatePeerConnection failed", true); 113 DeletePeerConnection(); 114 } 115 AddStreams(); 116 return peer_connection_.get() != NULL; 117 } 118 119 void Conductor::DeletePeerConnection() { 120 peer_connection_ = NULL; 121 active_streams_.clear(); 122 main_wnd_->StopLocalRenderer(); 123 main_wnd_->StopRemoteRenderer(); 124 peer_connection_factory_ = NULL; 125 peer_id_ = -1; 126 } 127 128 void Conductor::EnsureStreamingUI() { 129 ASSERT(peer_connection_.get() != NULL); 130 if (main_wnd_->IsWindow()) { 131 if (main_wnd_->current_ui() != MainWindow::STREAMING) 132 main_wnd_->SwitchToStreamingUI(); 133 } 134 } 135 136 // 137 // PeerConnectionObserver implementation. 138 // 139 140 void Conductor::OnError() { 141 LOG(LS_ERROR) << __FUNCTION__; 142 main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_ERROR, NULL); 143 } 144 145 // Called when a remote stream is added 146 void Conductor::OnAddStream(webrtc::MediaStreamInterface* stream) { 147 LOG(INFO) << __FUNCTION__ << " " << stream->label(); 148 149 stream->AddRef(); 150 main_wnd_->QueueUIThreadCallback(NEW_STREAM_ADDED, 151 stream); 152 } 153 154 void Conductor::OnRemoveStream(webrtc::MediaStreamInterface* stream) { 155 LOG(INFO) << __FUNCTION__ << " " << stream->label(); 156 stream->AddRef(); 157 main_wnd_->QueueUIThreadCallback(STREAM_REMOVED, 158 stream); 159 } 160 161 void Conductor::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) { 162 LOG(INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index(); 163 Json::StyledWriter writer; 164 Json::Value jmessage; 165 166 jmessage[kCandidateSdpMidName] = candidate->sdp_mid(); 167 jmessage[kCandidateSdpMlineIndexName] = candidate->sdp_mline_index(); 168 std::string sdp; 169 if (!candidate->ToString(&sdp)) { 170 LOG(LS_ERROR) << "Failed to serialize candidate"; 171 return; 172 } 173 jmessage[kCandidateSdpName] = sdp; 174 SendMessage(writer.write(jmessage)); 175 } 176 177 // 178 // PeerConnectionClientObserver implementation. 179 // 180 181 void Conductor::OnSignedIn() { 182 LOG(INFO) << __FUNCTION__; 183 main_wnd_->SwitchToPeerList(client_->peers()); 184 } 185 186 void Conductor::OnDisconnected() { 187 LOG(INFO) << __FUNCTION__; 188 189 DeletePeerConnection(); 190 191 if (main_wnd_->IsWindow()) 192 main_wnd_->SwitchToConnectUI(); 193 } 194 195 void Conductor::OnPeerConnected(int id, const std::string& name) { 196 LOG(INFO) << __FUNCTION__; 197 // Refresh the list if we're showing it. 198 if (main_wnd_->current_ui() == MainWindow::LIST_PEERS) 199 main_wnd_->SwitchToPeerList(client_->peers()); 200 } 201 202 void Conductor::OnPeerDisconnected(int id) { 203 LOG(INFO) << __FUNCTION__; 204 if (id == peer_id_) { 205 LOG(INFO) << "Our peer disconnected"; 206 main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_CLOSED, NULL); 207 } else { 208 // Refresh the list if we're showing it. 209 if (main_wnd_->current_ui() == MainWindow::LIST_PEERS) 210 main_wnd_->SwitchToPeerList(client_->peers()); 211 } 212 } 213 214 void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) { 215 ASSERT(peer_id_ == peer_id || peer_id_ == -1); 216 ASSERT(!message.empty()); 217 218 if (!peer_connection_.get()) { 219 ASSERT(peer_id_ == -1); 220 peer_id_ = peer_id; 221 222 if (!InitializePeerConnection()) { 223 LOG(LS_ERROR) << "Failed to initialize our PeerConnection instance"; 224 client_->SignOut(); 225 return; 226 } 227 } else if (peer_id != peer_id_) { 228 ASSERT(peer_id_ != -1); 229 LOG(WARNING) << "Received a message from unknown peer while already in a " 230 "conversation with a different peer."; 231 return; 232 } 233 234 Json::Reader reader; 235 Json::Value jmessage; 236 if (!reader.parse(message, jmessage)) { 237 LOG(WARNING) << "Received unknown message. " << message; 238 return; 239 } 240 std::string type; 241 std::string json_object; 242 243 GetStringFromJsonObject(jmessage, kSessionDescriptionTypeName, &type); 244 if (!type.empty()) { 245 std::string sdp; 246 if (!GetStringFromJsonObject(jmessage, kSessionDescriptionSdpName, &sdp)) { 247 LOG(WARNING) << "Can't parse received session description message."; 248 return; 249 } 250 webrtc::SessionDescriptionInterface* session_description( 251 webrtc::CreateSessionDescription(type, sdp)); 252 if (!session_description) { 253 LOG(WARNING) << "Can't parse received session description message."; 254 return; 255 } 256 LOG(INFO) << " Received session description :" << message; 257 peer_connection_->SetRemoteDescription( 258 DummySetSessionDescriptionObserver::Create(), session_description); 259 if (session_description->type() == 260 webrtc::SessionDescriptionInterface::kOffer) { 261 peer_connection_->CreateAnswer(this, NULL); 262 } 263 return; 264 } else { 265 std::string sdp_mid; 266 int sdp_mlineindex = 0; 267 std::string sdp; 268 if (!GetStringFromJsonObject(jmessage, kCandidateSdpMidName, &sdp_mid) || 269 !GetIntFromJsonObject(jmessage, kCandidateSdpMlineIndexName, 270 &sdp_mlineindex) || 271 !GetStringFromJsonObject(jmessage, kCandidateSdpName, &sdp)) { 272 LOG(WARNING) << "Can't parse received message."; 273 return; 274 } 275 talk_base::scoped_ptr<webrtc::IceCandidateInterface> candidate( 276 webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, sdp)); 277 if (!candidate.get()) { 278 LOG(WARNING) << "Can't parse received candidate message."; 279 return; 280 } 281 if (!peer_connection_->AddIceCandidate(candidate.get())) { 282 LOG(WARNING) << "Failed to apply the received candidate"; 283 return; 284 } 285 LOG(INFO) << " Received candidate :" << message; 286 return; 287 } 288 } 289 290 void Conductor::OnMessageSent(int err) { 291 // Process the next pending message if any. 292 main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, NULL); 293 } 294 295 void Conductor::OnServerConnectionFailure() { 296 main_wnd_->MessageBox("Error", ("Failed to connect to " + server_).c_str(), 297 true); 298 } 299 300 // 301 // MainWndCallback implementation. 302 // 303 304 void Conductor::StartLogin(const std::string& server, int port) { 305 if (client_->is_connected()) 306 return; 307 server_ = server; 308 client_->Connect(server, port, GetPeerName()); 309 } 310 311 void Conductor::DisconnectFromServer() { 312 if (client_->is_connected()) 313 client_->SignOut(); 314 } 315 316 void Conductor::ConnectToPeer(int peer_id) { 317 ASSERT(peer_id_ == -1); 318 ASSERT(peer_id != -1); 319 320 if (peer_connection_.get()) { 321 main_wnd_->MessageBox("Error", 322 "We only support connecting to one peer at a time", true); 323 return; 324 } 325 326 if (InitializePeerConnection()) { 327 peer_id_ = peer_id; 328 peer_connection_->CreateOffer(this, NULL); 329 } else { 330 main_wnd_->MessageBox("Error", "Failed to initialize PeerConnection", true); 331 } 332 } 333 334 cricket::VideoCapturer* Conductor::OpenVideoCaptureDevice() { 335 talk_base::scoped_ptr<cricket::DeviceManagerInterface> dev_manager( 336 cricket::DeviceManagerFactory::Create()); 337 if (!dev_manager->Init()) { 338 LOG(LS_ERROR) << "Can't create device manager"; 339 return NULL; 340 } 341 std::vector<cricket::Device> devs; 342 if (!dev_manager->GetVideoCaptureDevices(&devs)) { 343 LOG(LS_ERROR) << "Can't enumerate video devices"; 344 return NULL; 345 } 346 std::vector<cricket::Device>::iterator dev_it = devs.begin(); 347 cricket::VideoCapturer* capturer = NULL; 348 for (; dev_it != devs.end(); ++dev_it) { 349 capturer = dev_manager->CreateVideoCapturer(*dev_it); 350 if (capturer != NULL) 351 break; 352 } 353 return capturer; 354 } 355 356 void Conductor::AddStreams() { 357 if (active_streams_.find(kStreamLabel) != active_streams_.end()) 358 return; // Already added. 359 360 talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track( 361 peer_connection_factory_->CreateAudioTrack( 362 kAudioLabel, peer_connection_factory_->CreateAudioSource(NULL))); 363 364 talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track( 365 peer_connection_factory_->CreateVideoTrack( 366 kVideoLabel, 367 peer_connection_factory_->CreateVideoSource(OpenVideoCaptureDevice(), 368 NULL))); 369 main_wnd_->StartLocalRenderer(video_track); 370 371 talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream = 372 peer_connection_factory_->CreateLocalMediaStream(kStreamLabel); 373 374 stream->AddTrack(audio_track); 375 stream->AddTrack(video_track); 376 if (!peer_connection_->AddStream(stream, NULL)) { 377 LOG(LS_ERROR) << "Adding stream to PeerConnection failed"; 378 } 379 typedef std::pair<std::string, 380 talk_base::scoped_refptr<webrtc::MediaStreamInterface> > 381 MediaStreamPair; 382 active_streams_.insert(MediaStreamPair(stream->label(), stream)); 383 main_wnd_->SwitchToStreamingUI(); 384 } 385 386 void Conductor::DisconnectFromCurrentPeer() { 387 LOG(INFO) << __FUNCTION__; 388 if (peer_connection_.get()) { 389 client_->SendHangUp(peer_id_); 390 DeletePeerConnection(); 391 } 392 393 if (main_wnd_->IsWindow()) 394 main_wnd_->SwitchToPeerList(client_->peers()); 395 } 396 397 void Conductor::UIThreadCallback(int msg_id, void* data) { 398 switch (msg_id) { 399 case PEER_CONNECTION_CLOSED: 400 LOG(INFO) << "PEER_CONNECTION_CLOSED"; 401 DeletePeerConnection(); 402 403 ASSERT(active_streams_.empty()); 404 405 if (main_wnd_->IsWindow()) { 406 if (client_->is_connected()) { 407 main_wnd_->SwitchToPeerList(client_->peers()); 408 } else { 409 main_wnd_->SwitchToConnectUI(); 410 } 411 } else { 412 DisconnectFromServer(); 413 } 414 break; 415 416 case SEND_MESSAGE_TO_PEER: { 417 LOG(INFO) << "SEND_MESSAGE_TO_PEER"; 418 std::string* msg = reinterpret_cast<std::string*>(data); 419 if (msg) { 420 // For convenience, we always run the message through the queue. 421 // This way we can be sure that messages are sent to the server 422 // in the same order they were signaled without much hassle. 423 pending_messages_.push_back(msg); 424 } 425 426 if (!pending_messages_.empty() && !client_->IsSendingMessage()) { 427 msg = pending_messages_.front(); 428 pending_messages_.pop_front(); 429 430 if (!client_->SendToPeer(peer_id_, *msg) && peer_id_ != -1) { 431 LOG(LS_ERROR) << "SendToPeer failed"; 432 DisconnectFromServer(); 433 } 434 delete msg; 435 } 436 437 if (!peer_connection_.get()) 438 peer_id_ = -1; 439 440 break; 441 } 442 443 case PEER_CONNECTION_ERROR: 444 main_wnd_->MessageBox("Error", "an unknown error occurred", true); 445 break; 446 447 case NEW_STREAM_ADDED: { 448 webrtc::MediaStreamInterface* stream = 449 reinterpret_cast<webrtc::MediaStreamInterface*>( 450 data); 451 webrtc::VideoTrackVector tracks = stream->GetVideoTracks(); 452 // Only render the first track. 453 if (!tracks.empty()) { 454 webrtc::VideoTrackInterface* track = tracks[0]; 455 main_wnd_->StartRemoteRenderer(track); 456 } 457 stream->Release(); 458 break; 459 } 460 461 case STREAM_REMOVED: { 462 // Remote peer stopped sending a stream. 463 webrtc::MediaStreamInterface* stream = 464 reinterpret_cast<webrtc::MediaStreamInterface*>( 465 data); 466 stream->Release(); 467 break; 468 } 469 470 default: 471 ASSERT(false); 472 break; 473 } 474 } 475 476 void Conductor::OnSuccess(webrtc::SessionDescriptionInterface* desc) { 477 peer_connection_->SetLocalDescription( 478 DummySetSessionDescriptionObserver::Create(), desc); 479 Json::StyledWriter writer; 480 Json::Value jmessage; 481 jmessage[kSessionDescriptionTypeName] = desc->type(); 482 std::string sdp; 483 desc->ToString(&sdp); 484 jmessage[kSessionDescriptionSdpName] = sdp; 485 SendMessage(writer.write(jmessage)); 486 } 487 488 void Conductor::OnFailure(const std::string& error) { 489 LOG(LERROR) << error; 490 } 491 492 void Conductor::SendMessage(const std::string& json_object) { 493 std::string* msg = new std::string(json_object); 494 main_wnd_->QueueUIThreadCallback(SEND_MESSAGE_TO_PEER, msg); 495 } 496