src/third_party/libjingle/source/talk/examples/call/callclient.cc

   1 /*
   2  * libjingle
   3  * Copyright 2004--2005, 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/call/callclient.h"
  29
  30 #include <string>
  31
  32 #include "talk/examples/call/console.h"
  33 #include "talk/examples/call/friendinvitesendtask.h"
  34 #include "talk/examples/call/muc.h"
  35 #include "talk/examples/call/mucinviterecvtask.h"
  36 #include "talk/examples/call/mucinvitesendtask.h"
  37 #include "talk/examples/call/presencepushtask.h"
  38 #include "talk/media/base/mediacommon.h"
  39 #include "talk/media/base/mediaengine.h"
  40 #include "talk/media/base/rtpdataengine.h"
  41 #include "talk/media/base/screencastid.h"
  42 #include "webrtc/base/helpers.h"
  43 #include "webrtc/base/logging.h"
  44 #include "webrtc/base/network.h"
  45 #include "webrtc/base/socketaddress.h"
  46 #include "webrtc/base/stringencode.h"
  47 #include "webrtc/base/stringutils.h"
  48 #include "webrtc/base/thread.h"
  49 #include "webrtc/base/windowpickerfactory.h"
  50 #ifdef HAVE_SCTP
  51 #include "talk/media/sctp/sctpdataengine.h"
  52 #endif
  53 #include "talk/media/base/videorenderer.h"
  54 #include "talk/media/devices/devicemanager.h"
  55 #include "talk/media/devices/videorendererfactory.h"
  56 #include "talk/p2p/base/sessionmanager.h"
  57 #include "talk/p2p/client/basicportallocator.h"
  58 #include "talk/p2p/client/sessionmanagertask.h"
  59 #include "talk/session/media/mediamessages.h"
  60 #include "talk/session/media/mediasessionclient.h"
  61 #include "talk/xmpp/constants.h"
  62 #include "talk/xmpp/hangoutpubsubclient.h"
  63 #include "talk/xmpp/mucroomconfigtask.h"
  64 #include "talk/xmpp/mucroomlookuptask.h"
  65 #include "talk/xmpp/pingtask.h"
  66 #include "talk/xmpp/presenceouttask.h"
  67
  68 namespace {
  69
  70 // Must be period >= timeout.
  71 const uint32 kPingPeriodMillis = 10000;
  72 const uint32 kPingTimeoutMillis = 10000;
  73
  74 const char* DescribeStatus(buzz::PresenceStatus::Show show,
  75                            const std::string& desc) {
  76   switch (show) {
  77   case buzz::PresenceStatus::SHOW_XA:      return desc.c_str();
  78   case buzz::PresenceStatus::SHOW_ONLINE:  return "online";
  79   case buzz::PresenceStatus::SHOW_AWAY:    return "away";
  80   case buzz::PresenceStatus::SHOW_DND:     return "do not disturb";
  81   case buzz::PresenceStatus::SHOW_CHAT:    return "ready to chat";
  82   default:                                 return "offline";
  83   }
  84 }
  85
  86 std::string GetWord(const std::vector<std::string>& words,
  87                     size_t index, const std::string& def) {
  88   if (words.size() > index) {
  89     return words[index];
  90   } else {
  91     return def;
  92   }
  93 }
  94
  95 int GetInt(const std::vector<std::string>& words, size_t index, int def) {
  96   int val;
  97   if (words.size() > index && rtc::FromString(words[index], &val)) {
  98     return val;
  99   } else {
 100     return def;
 101   }
 102 }
 103
 104 }  // namespace
 105
 106 const char* CALL_COMMANDS =
 107 "Available commands:\n"
 108 "\n"
 109 "  hangup            Ends the call.\n"
 110 "  hold              Puts the current call on hold\n"
 111 "  calls             Lists the current calls and their sessions\n"
 112 "  switch [call_id]  Switch to the specified call\n"
 113 "  addsession [jid]  Add a new session to the current call.\n"
 114 "  rmsession [sid]   Remove specified session.\n"
 115 "  mute              Stops sending voice.\n"
 116 "  unmute            Re-starts sending voice.\n"
 117 "  vmute             Stops sending video.\n"
 118 "  vunmute           Re-starts sending video.\n"
 119 "  dtmf              Sends a DTMF tone.\n"
 120 "  stats             Print voice stats for the current call.\n"
 121 "  quit              Quits the application.\n"
 122 "";
 123
 124 // TODO: Make present and record really work.
 125 const char* HANGOUT_COMMANDS =
 126 "Available MUC commands:\n"
 127 "\n"
 128 "  present    Starts presenting (just signalling; not actually presenting.)\n"
 129 "  unpresent  Stops presenting (just signalling; not actually presenting.)\n"
 130 "  record     Starts recording (just signalling; not actually recording.)\n"
 131 "  unrecord   Stops recording (just signalling; not actually recording.)\n"
 132 "  rmute [nick] Remote mute another participant.\n"
 133 "  block [nick] Block another participant.\n"
 134 "  screencast [fps] Starts screencast. \n"
 135 "  unscreencast Stops screencast. \n"
 136 "  quit       Quits the application.\n"
 137 "";
 138
 139 const char* RECEIVE_COMMANDS =
 140 "Available commands:\n"
 141 "\n"
 142 "  accept [bw] Accepts the incoming call and switches to it.\n"
 143 "  reject  Rejects the incoming call and stays with the current call.\n"
 144 "  quit    Quits the application.\n"
 145 "";
 146
 147 const char* CONSOLE_COMMANDS =
 148 "Available commands:\n"
 149 "\n"
 150 "  roster              Prints the online friends from your roster.\n"
 151 "  friend user         Request to add a user to your roster.\n"
 152 "  call [jid] [bw]     Initiates a call to the user[/room] with the\n"
 153 "                      given JID and with optional bandwidth.\n"
 154 "  vcall [jid] [bw]    Initiates a video call to the user[/room] with\n"
 155 "                      the given JID and with optional bandwidth.\n"
 156 "  calls               Lists the current calls\n"
 157 "  switch [call_id]    Switch to the specified call\n"
 158 "  join [room_jid]     Joins a multi-user-chat with room JID.\n"
 159 "  ljoin [room_name]   Joins a MUC by looking up JID from room name.\n"
 160 "  invite user [room]  Invites a friend to a multi-user-chat.\n"
 161 "  leave [room]        Leaves a multi-user-chat.\n"
 162 "  nick [nick]         Sets the nick.\n"
 163 "  priority [int]      Sets the priority.\n"
 164 "  getdevs             Prints the available media devices.\n"
 165 "  quit                Quits the application.\n"
 166 "";
 167
 168 void CallClient::ParseLine(const std::string& line) {
 169   std::vector<std::string> words;
 170   int start = -1;
 171   int state = 0;
 172   for (int index = 0; index <= static_cast<int>(line.size()); ++index) {
 173     if (state == 0) {
 174       if (!isspace(line[index])) {
 175         start = index;
 176         state = 1;
 177       }
 178     } else {
 179       ASSERT(state == 1);
 180       ASSERT(start >= 0);
 181       if (isspace(line[index])) {
 182         std::string word(line, start, index - start);
 183         words.push_back(word);
 184         start = -1;
 185         state = 0;
 186       }
 187     }
 188   }
 189
 190   // Global commands
 191   const std::string& command = GetWord(words, 0, "");
 192   if (command == "quit") {
 193     Quit();
 194   } else if (call_ && incoming_call_) {
 195     if (command == "accept") {
 196       cricket::CallOptions options;
 197       options.video_bandwidth = GetInt(words, 1, cricket::kAutoBandwidth);
 198       options.has_video = true;
 199       options.data_channel_type = data_channel_type_;
 200       Accept(options);
 201     } else if (command == "reject") {
 202       Reject();
 203     } else {
 204       console_->PrintLine(RECEIVE_COMMANDS);
 205     }
 206   } else if (call_) {
 207     if (command == "hangup") {
 208       call_->Terminate();
 209     } else if (command == "hold") {
 210       media_client_->SetFocus(NULL);
 211       call_ = NULL;
 212     } else if (command == "addsession") {
 213       std::string to = GetWord(words, 1, "");
 214       cricket::CallOptions options;
 215       options.has_video = call_->has_video();
 216       options.video_bandwidth = cricket::kAutoBandwidth;
 217       options.data_channel_type = data_channel_type_;
 218       options.AddStream(cricket::MEDIA_TYPE_VIDEO, "", "");
 219       if (!InitiateAdditionalSession(to, options)) {
 220         console_->PrintLine("Failed to initiate additional session.");
 221       }
 222     } else if (command == "rmsession") {
 223       std::string id = GetWord(words, 1, "");
 224       TerminateAndRemoveSession(call_, id);
 225     } else if (command == "calls") {
 226       PrintCalls();
 227     } else if ((words.size() == 2) && (command == "switch")) {
 228       SwitchToCall(GetInt(words, 1, -1));
 229     } else if (command == "mute") {
 230       call_->Mute(true);
 231       if (InMuc()) {
 232         hangout_pubsub_client_->PublishAudioMuteState(true);
 233       }
 234     } else if (command == "unmute") {
 235       call_->Mute(false);
 236       if (InMuc()) {
 237         hangout_pubsub_client_->PublishAudioMuteState(false);
 238       }
 239     } else if (command == "vmute") {
 240       call_->MuteVideo(true);
 241       if (InMuc()) {
 242         hangout_pubsub_client_->PublishVideoMuteState(true);
 243       }
 244     } else if (command == "vunmute") {
 245       call_->MuteVideo(false);
 246       if (InMuc()) {
 247         hangout_pubsub_client_->PublishVideoMuteState(false);
 248       }
 249     } else if (command == "screencast") {
 250       if (screencast_ssrc_ != 0) {
 251         console_->PrintLine("Can't screencast twice.  Unscreencast first.");
 252       } else {
 253         std::string streamid = "screencast";
 254         screencast_ssrc_ = rtc::CreateRandomId();
 255         int fps = GetInt(words, 1, 5);  // Default to 5 fps.
 256
 257         cricket::ScreencastId screencastid;
 258         cricket::Session* session = GetFirstSession();
 259         if (session && SelectFirstDesktopScreencastId(&screencastid)) {
 260           call_->StartScreencast(
 261               session, streamid, screencast_ssrc_, screencastid, fps);
 262         }
 263       }
 264     } else if (command == "unscreencast") {
 265       // TODO: Use a random ssrc
 266       std::string streamid = "screencast";
 267
 268       cricket::Session* session = GetFirstSession();
 269       if (session) {
 270         call_->StopScreencast(session, streamid, screencast_ssrc_);
 271         screencast_ssrc_ = 0;
 272       }
 273     } else if (command == "present") {
 274       if (InMuc()) {
 275         hangout_pubsub_client_->PublishPresenterState(true);
 276       }
 277     } else if (command == "unpresent") {
 278       if (InMuc()) {
 279         hangout_pubsub_client_->PublishPresenterState(false);
 280       }
 281     } else if (command == "record") {
 282       if (InMuc()) {
 283         hangout_pubsub_client_->PublishRecordingState(true);
 284       }
 285     } else if (command == "unrecord") {
 286       if (InMuc()) {
 287         hangout_pubsub_client_->PublishRecordingState(false);
 288       }
 289     } else if ((command == "rmute") && (words.size() == 2)) {
 290       if (InMuc()) {
 291         const std::string& nick = words[1];
 292         hangout_pubsub_client_->RemoteMute(nick);
 293       }
 294     } else if ((command == "block") && (words.size() == 2)) {
 295       if (InMuc()) {
 296         const std::string& nick = words[1];
 297         hangout_pubsub_client_->BlockMedia(nick);
 298       }
 299     } else if (command == "senddata") {
 300       // "" is the default streamid.
 301       SendData("", words[1]);
 302     } else if ((command == "dtmf") && (words.size() == 2)) {
 303       int ev = std::string("0123456789*#").find(words[1][0]);
 304       call_->PressDTMF(ev);
 305     } else if (command == "stats") {
 306       PrintStats();
 307     } else {
 308       console_->PrintLine(CALL_COMMANDS);
 309       if (InMuc()) {
 310         console_->PrintLine(HANGOUT_COMMANDS);
 311       }
 312     }
 313   } else {
 314     if (command == "roster") {
 315       PrintRoster();
 316     } else if (command == "send") {
 317       buzz::Jid jid(words[1]);
 318       if (jid.IsValid()) {
 319         last_sent_to_ = words[1];
 320         SendChat(words[1], words[2]);
 321       } else if (!last_sent_to_.empty()) {
 322         SendChat(last_sent_to_, words[1]);
 323       } else {
 324         console_->PrintLine(
 325             "Invalid JID. JIDs should be in the form user@domain");
 326       }
 327     } else if ((words.size() == 2) && (command == "friend")) {
 328       InviteFriend(words[1]);
 329     } else if (command == "call") {
 330       std::string to = GetWord(words, 1, "");
 331       cricket::CallOptions options;
 332       options.data_channel_type = data_channel_type_;
 333       if (!PlaceCall(to, options)) {
 334         console_->PrintLine("Failed to initiate call.");
 335       }
 336     } else if (command == "vcall") {
 337       std::string to = GetWord(words, 1, "");
 338       int bandwidth = GetInt(words, 2, cricket::kAutoBandwidth);
 339       cricket::CallOptions options;
 340       options.has_video = true;
 341       options.video_bandwidth = bandwidth;
 342       options.data_channel_type = data_channel_type_;
 343       if (!PlaceCall(to, options)) {
 344         console_->PrintLine("Failed to initiate call.");
 345       }
 346     } else if (command == "calls") {
 347       PrintCalls();
 348     } else if ((words.size() == 2) && (command == "switch")) {
 349       SwitchToCall(GetInt(words, 1, -1));
 350     } else if (command == "join") {
 351       JoinMuc(GetWord(words, 1, ""));
 352     } else if (command == "ljoin") {
 353       LookupAndJoinMuc(GetWord(words, 1, ""));
 354     } else if ((words.size() >= 2) && (command == "invite")) {
 355       InviteToMuc(words[1], GetWord(words, 2, ""));
 356     } else if (command == "leave") {
 357       LeaveMuc(GetWord(words, 1, ""));
 358     } else if (command == "nick") {
 359       SetNick(GetWord(words, 1, ""));
 360     } else if (command == "priority") {
 361       int priority = GetInt(words, 1, 0);
 362       SetPriority(priority);
 363       SendStatus();
 364     } else if (command == "getdevs") {
 365       GetDevices();
 366     } else if ((words.size() == 2) && (command == "setvol")) {
 367       SetVolume(words[1]);
 368     } else {
 369       console_->PrintLine(CONSOLE_COMMANDS);
 370     }
 371   }
 372 }
 373
 374 CallClient::CallClient(buzz::XmppClient* xmpp_client,
 375                        const std::string& caps_node, const std::string& version)
 376     : xmpp_client_(xmpp_client),
 377       worker_thread_(NULL),
 378       media_engine_(NULL),
 379       data_engine_(NULL),
 380       media_client_(NULL),
 381       call_(NULL),
 382       hangout_pubsub_client_(NULL),
 383       incoming_call_(false),
 384       auto_accept_(false),
 385       pmuc_domain_("groupchat.google.com"),
 386       render_(true),
 387       data_channel_type_(cricket::DCT_NONE),
 388       multisession_enabled_(false),
 389       local_renderer_(NULL),
 390       static_views_accumulated_count_(0),
 391       screencast_ssrc_(0),
 392       roster_(new RosterMap),
 393       portallocator_flags_(0),
 394       allow_local_ips_(false),
 395       signaling_protocol_(cricket::PROTOCOL_HYBRID),
 396       transport_protocol_(cricket::ICEPROTO_HYBRID),
 397       sdes_policy_(cricket::SEC_DISABLED),
 398       dtls_policy_(cricket::SEC_DISABLED),
 399       ssl_identity_(),
 400       show_roster_messages_(false) {
 401   xmpp_client_->SignalStateChange.connect(this, &CallClient::OnStateChange);
 402   my_status_.set_caps_node(caps_node);
 403   my_status_.set_version(version);
 404 }
 405
 406 CallClient::~CallClient() {
 407   delete media_client_;
 408   delete roster_;
 409   delete worker_thread_;
 410 }
 411
 412 const std::string CallClient::strerror(buzz::XmppEngine::Error err) {
 413   switch (err) {
 414     case buzz::XmppEngine::ERROR_NONE:
 415       return "";
 416     case buzz::XmppEngine::ERROR_XML:
 417       return "Malformed XML or encoding error";
 418     case buzz::XmppEngine::ERROR_STREAM:
 419       return "XMPP stream error";
 420     case buzz::XmppEngine::ERROR_VERSION:
 421       return "XMPP version error";
 422     case buzz::XmppEngine::ERROR_UNAUTHORIZED:
 423       return "User is not authorized (Check your username and password)";
 424     case buzz::XmppEngine::ERROR_TLS:
 425       return "TLS could not be negotiated";
 426     case buzz::XmppEngine::ERROR_AUTH:
 427       return "Authentication could not be negotiated";
 428     case buzz::XmppEngine::ERROR_BIND:
 429       return "Resource or session binding could not be negotiated";
 430     case buzz::XmppEngine::ERROR_CONNECTION_CLOSED:
 431       return "Connection closed by output handler.";
 432     case buzz::XmppEngine::ERROR_DOCUMENT_CLOSED:
 433       return "Closed by </stream:stream>";
 434     case buzz::XmppEngine::ERROR_SOCKET:
 435       return "Socket error";
 436     default:
 437       return "Unknown error";
 438   }
 439 }
 440
 441 void CallClient::OnCallDestroy(cricket::Call* call) {
 442   RemoveCallsStaticRenderedViews(call);
 443   if (call == call_) {
 444     if (local_renderer_) {
 445       delete local_renderer_;
 446       local_renderer_ = NULL;
 447     }
 448     console_->PrintLine("call destroyed");
 449     call_ = NULL;
 450     delete hangout_pubsub_client_;
 451     hangout_pubsub_client_ = NULL;
 452   }
 453 }
 454
 455 void CallClient::OnStateChange(buzz::XmppEngine::State state) {
 456   switch (state) {
 457     case buzz::XmppEngine::STATE_START:
 458       console_->PrintLine("connecting...");
 459       break;
 460     case buzz::XmppEngine::STATE_OPENING:
 461       console_->PrintLine("logging in...");
 462       break;
 463     case buzz::XmppEngine::STATE_OPEN:
 464       console_->PrintLine("logged in...");
 465       InitMedia();
 466       InitPresence();
 467       break;
 468     case buzz::XmppEngine::STATE_CLOSED:
 469       {
 470         buzz::XmppEngine::Error error = xmpp_client_->GetError(NULL);
 471         console_->PrintLine("logged out... %s", strerror(error).c_str());
 472         Quit();
 473       }
 474       break;
 475     default:
 476       break;
 477   }
 478 }
 479
 480 void CallClient::InitMedia() {
 481   worker_thread_ = new rtc::Thread();
 482   // The worker thread must be started here since initialization of
 483   // the ChannelManager will generate messages that need to be
 484   // dispatched by it.
 485   worker_thread_->Start();
 486
 487   // TODO: It looks like we are leaking many objects. E.g.
 488   // |network_manager_| is never deleted.
 489   network_manager_ = new rtc::BasicNetworkManager();
 490
 491   // TODO: Decide if the relay address should be specified here.
 492   rtc::SocketAddress stun_addr("stun.l.google.com", 19302);
 493   cricket::ServerAddresses stun_servers;
 494   stun_servers.insert(stun_addr);
 495   port_allocator_ =  new cricket::BasicPortAllocator(
 496       network_manager_, stun_servers, rtc::SocketAddress(),
 497       rtc::SocketAddress(), rtc::SocketAddress());
 498
 499   if (portallocator_flags_ != 0) {
 500     port_allocator_->set_flags(portallocator_flags_);
 501   }
 502   session_manager_ = new cricket::SessionManager(
 503       port_allocator_, worker_thread_);
 504   session_manager_->set_secure(dtls_policy_);
 505   session_manager_->set_identity(ssl_identity_.get());
 506   session_manager_->set_transport_protocol(transport_protocol_);
 507   session_manager_->SignalRequestSignaling.connect(
 508       this, &CallClient::OnRequestSignaling);
 509   session_manager_->SignalSessionCreate.connect(
 510       this, &CallClient::OnSessionCreate);
 511   session_manager_->OnSignalingReady();
 512
 513   session_manager_task_ =
 514       new cricket::SessionManagerTask(xmpp_client_, session_manager_);
 515   session_manager_task_->EnableOutgoingMessages();
 516   session_manager_task_->Start();
 517
 518   if (!media_engine_) {
 519     media_engine_ = cricket::MediaEngineFactory::Create();
 520   }
 521
 522   if (!data_engine_) {
 523     if (data_channel_type_ == cricket::DCT_SCTP) {
 524 #ifdef HAVE_SCTP
 525       data_engine_ = new cricket::SctpDataEngine();
 526 #else
 527       LOG(LS_WARNING) << "SCTP Data Engine not supported.";
 528       data_channel_type_ = cricket::DCT_NONE;
 529       data_engine_ = new cricket::RtpDataEngine();
 530 #endif
 531     } else {
 532       // Even if we have DCT_NONE, we still have a data engine, just
 533       // to make sure it isn't NULL.
 534       data_engine_ = new cricket::RtpDataEngine();
 535     }
 536   }
 537
 538   media_client_ = new cricket::MediaSessionClient(
 539       xmpp_client_->jid(),
 540       session_manager_,
 541       media_engine_,
 542       data_engine_,
 543       cricket::DeviceManagerFactory::Create());
 544   media_client_->SignalCallCreate.connect(this, &CallClient::OnCallCreate);
 545   media_client_->SignalCallDestroy.connect(this, &CallClient::OnCallDestroy);
 546   media_client_->SignalDevicesChange.connect(this,
 547                                              &CallClient::OnDevicesChange);
 548   media_client_->set_secure(sdes_policy_);
 549   media_client_->set_multisession_enabled(multisession_enabled_);
 550 }
 551
 552 void CallClient::OnRequestSignaling() {
 553   session_manager_->OnSignalingReady();
 554 }
 555
 556 void CallClient::OnSessionCreate(cricket::Session* session, bool initiate) {
 557   session->set_current_protocol(signaling_protocol_);
 558 }
 559
 560 void CallClient::OnCallCreate(cricket::Call* call) {
 561   call->SignalSessionState.connect(this, &CallClient::OnSessionState);
 562   call->SignalMediaStreamsUpdate.connect(
 563       this, &CallClient::OnMediaStreamsUpdate);
 564 }
 565
 566 void CallClient::OnSessionState(cricket::Call* call,
 567                                 cricket::Session* session,
 568                                 cricket::Session::State state) {
 569   if (state == cricket::Session::STATE_RECEIVEDINITIATE) {
 570     buzz::Jid jid(session->remote_name());
 571     if (call_ == call && multisession_enabled_) {
 572       // We've received an initiate for an existing call. This is actually a
 573       // new session for that call.
 574       console_->PrintLine("Incoming session from '%s'", jid.Str().c_str());
 575       AddSession(session);
 576
 577       cricket::CallOptions options;
 578       options.has_video = call_->has_video();
 579       options.data_channel_type = data_channel_type_;
 580       call_->AcceptSession(session, options);
 581
 582       if (call_->has_video() && render_) {
 583         RenderAllStreams(call, session, true);
 584       }
 585     } else {
 586       console_->PrintLine("Incoming call from '%s'", jid.Str().c_str());
 587       call_ = call;
 588       AddSession(session);
 589       incoming_call_ = true;
 590       if (call->has_video() && render_) {
 591         local_renderer_ =
 592             cricket::VideoRendererFactory::CreateGuiVideoRenderer(160, 100);
 593       }
 594       if (auto_accept_) {
 595         cricket::CallOptions options;
 596         options.has_video = true;
 597         options.data_channel_type = data_channel_type_;
 598         Accept(options);
 599       }
 600     }
 601   } else if (state == cricket::Session::STATE_SENTINITIATE) {
 602     if (call->has_video() && render_) {
 603       local_renderer_ =
 604           cricket::VideoRendererFactory::CreateGuiVideoRenderer(160, 100);
 605     }
 606     console_->PrintLine("calling...");
 607   } else if (state == cricket::Session::STATE_RECEIVEDACCEPT) {
 608     console_->PrintLine("call answered");
 609     SetupAcceptedCall();
 610   } else if (state == cricket::Session::STATE_RECEIVEDREJECT) {
 611     console_->PrintLine("call not answered");
 612   } else if (state == cricket::Session::STATE_INPROGRESS) {
 613     console_->PrintLine("call in progress");
 614     call->SignalSpeakerMonitor.connect(this, &CallClient::OnSpeakerChanged);
 615     call->StartSpeakerMonitor(session);
 616   } else if (state == cricket::Session::STATE_RECEIVEDTERMINATE) {
 617     console_->PrintLine("other side terminated");
 618     TerminateAndRemoveSession(call, session->id());
 619   }
 620 }
 621
 622 void CallClient::OnSpeakerChanged(cricket::Call* call,
 623                                   cricket::Session* session,
 624                                   const cricket::StreamParams& speaker) {
 625   if (!speaker.has_ssrcs()) {
 626     console_->PrintLine("Session %s has no current speaker.",
 627                         session->id().c_str());
 628   } else if (speaker.id.empty()) {
 629     console_->PrintLine("Session %s speaker change to unknown (%u).",
 630                         session->id().c_str(), speaker.first_ssrc());
 631   } else {
 632     console_->PrintLine("Session %s speaker changed to %s (%u).",
 633                         session->id().c_str(), speaker.id.c_str(),
 634                         speaker.first_ssrc());
 635   }
 636 }
 637
 638 void SetMediaCaps(int media_caps, buzz::PresenceStatus* status) {
 639   status->set_voice_capability((media_caps & cricket::AUDIO_RECV) != 0);
 640   status->set_video_capability((media_caps & cricket::VIDEO_RECV) != 0);
 641   status->set_camera_capability((media_caps & cricket::VIDEO_SEND) != 0);
 642 }
 643
 644 void SetCaps(int media_caps, buzz::PresenceStatus* status) {
 645   status->set_know_capabilities(true);
 646   status->set_pmuc_capability(true);
 647   SetMediaCaps(media_caps, status);
 648 }
 649
 650 void SetAvailable(const buzz::Jid& jid, buzz::PresenceStatus* status) {
 651   status->set_jid(jid);
 652   status->set_available(true);
 653   status->set_show(buzz::PresenceStatus::SHOW_ONLINE);
 654 }
 655
 656 void CallClient::InitPresence() {
 657   presence_push_ = new buzz::PresencePushTask(xmpp_client_, this);
 658   presence_push_->SignalStatusUpdate.connect(
 659     this, &CallClient::OnStatusUpdate);
 660   presence_push_->SignalMucJoined.connect(this, &CallClient::OnMucJoined);
 661   presence_push_->SignalMucLeft.connect(this, &CallClient::OnMucLeft);
 662   presence_push_->SignalMucStatusUpdate.connect(
 663     this, &CallClient::OnMucStatusUpdate);
 664   presence_push_->Start();
 665
 666   presence_out_ = new buzz::PresenceOutTask(xmpp_client_);
 667   SetAvailable(xmpp_client_->jid(), &my_status_);
 668   SetCaps(media_client_->GetCapabilities(), &my_status_);
 669   SendStatus(my_status_);
 670   presence_out_->Start();
 671
 672   muc_invite_recv_ = new buzz::MucInviteRecvTask(xmpp_client_);
 673   muc_invite_recv_->SignalInviteReceived.connect(this,
 674       &CallClient::OnMucInviteReceived);
 675   muc_invite_recv_->Start();
 676
 677   muc_invite_send_ = new buzz::MucInviteSendTask(xmpp_client_);
 678   muc_invite_send_->Start();
 679
 680   friend_invite_send_ = new buzz::FriendInviteSendTask(xmpp_client_);
 681   friend_invite_send_->Start();
 682
 683   StartXmppPing();
 684 }
 685
 686 void CallClient::StartXmppPing() {
 687   buzz::PingTask* ping = new buzz::PingTask(
 688       xmpp_client_, rtc::Thread::Current(),
 689       kPingPeriodMillis, kPingTimeoutMillis);
 690   ping->SignalTimeout.connect(this, &CallClient::OnPingTimeout);
 691   ping->Start();
 692 }
 693
 694 void CallClient::OnPingTimeout() {
 695   LOG(LS_WARNING) << "XMPP Ping timeout. Will keep trying...";
 696   StartXmppPing();
 697
 698   // Or should we do this instead?
 699   // Quit();
 700 }
 701
 702 void CallClient::SendStatus(const buzz::PresenceStatus& status) {
 703   presence_out_->Send(status);
 704 }
 705
 706 void CallClient::OnStatusUpdate(const buzz::PresenceStatus& status) {
 707   RosterItem item;
 708   item.jid = status.jid();
 709   item.show = status.show();
 710   item.status = status.status();
 711
 712   std::string key = item.jid.Str();
 713
 714   if (status.available() && status.voice_capability()) {
 715     if (show_roster_messages_) {
 716       console_->PrintLine("Adding to roster: %s", key.c_str());
 717     }
 718     (*roster_)[key] = item;
 719     // TODO: Make some of these constants.
 720   } else {
 721     if (show_roster_messages_) {
 722       console_->PrintLine("Removing from roster: %s", key.c_str());
 723     }
 724     RosterMap::iterator iter = roster_->find(key);
 725     if (iter != roster_->end())
 726       roster_->erase(iter);
 727   }
 728 }
 729
 730 void CallClient::PrintRoster() {
 731   console_->PrintLine("Roster contains %d callable", roster_->size());
 732   RosterMap::iterator iter = roster_->begin();
 733   while (iter != roster_->end()) {
 734     console_->PrintLine("%s - %s",
 735                         iter->second.jid.BareJid().Str().c_str(),
 736                         DescribeStatus(iter->second.show, iter->second.status));
 737     iter++;
 738   }
 739 }
 740
 741 void CallClient::SendChat(const std::string& to, const std::string msg) {
 742   buzz::XmlElement* stanza = new buzz::XmlElement(buzz::QN_MESSAGE);
 743   stanza->AddAttr(buzz::QN_TO, to);
 744   stanza->AddAttr(buzz::QN_ID, rtc::CreateRandomString(16));
 745   stanza->AddAttr(buzz::QN_TYPE, "chat");
 746   buzz::XmlElement* body = new buzz::XmlElement(buzz::QN_BODY);
 747   body->SetBodyText(msg);
 748   stanza->AddElement(body);
 749
 750   xmpp_client_->SendStanza(stanza);
 751   delete stanza;
 752 }
 753
 754 void CallClient::SendData(const std::string& streamid,
 755                           const std::string& text) {
 756   // TODO(mylesj): Support sending data over sessions other than the first.
 757   cricket::Session* session = GetFirstSession();
 758   if (!call_ || !session) {
 759     console_->PrintLine("Must be in a call to send data.");
 760     return;
 761   }
 762   if (!call_->has_data()) {
 763     console_->PrintLine("This call doesn't have a data channel.");
 764     return;
 765   }
 766
 767   const cricket::DataContentDescription* data =
 768       cricket::GetFirstDataContentDescription(session->local_description());
 769   if (!data) {
 770     console_->PrintLine("This call doesn't have a data content.");
 771     return;
 772   }
 773
 774   cricket::StreamParams stream;
 775   if (!cricket::GetStreamByIds(
 776           data->streams(), "", streamid, &stream)) {
 777     LOG(LS_WARNING) << "Could not send data: no such stream: "
 778                     << streamid << ".";
 779     return;
 780   }
 781
 782   cricket::SendDataParams params;
 783   params.ssrc = stream.first_ssrc();
 784   rtc::Buffer payload(text.data(), text.length());
 785   cricket::SendDataResult result;
 786   bool sent = call_->SendData(session, params, payload, &result);
 787   if (!sent) {
 788     if (result == cricket::SDR_BLOCK) {
 789       LOG(LS_WARNING) << "Could not send data because it would block.";
 790     } else {
 791       LOG(LS_WARNING) << "Could not send data for unknown reason.";
 792     }
 793   }
 794 }
 795
 796 void CallClient::InviteFriend(const std::string& name) {
 797   buzz::Jid jid(name);
 798   if (!jid.IsValid() || jid.node() == "") {
 799     console_->PrintLine("Invalid JID. JIDs should be in the form user@domain.");
 800     return;
 801   }
 802   // Note: for some reason the Buzz backend does not forward our presence
 803   // subscription requests to the end user when that user is another call
 804   // client as opposed to a Smurf user. Thus, in that scenario, you must
 805   // run the friend command as the other user too to create the linkage
 806   // (and you won't be notified to do so).
 807   friend_invite_send_->Send(jid);
 808   console_->PrintLine("Requesting to befriend %s.", name.c_str());
 809 }
 810
 811 bool CallClient::FindJid(const std::string& name, buzz::Jid* found_jid,
 812                          cricket::CallOptions* options) {
 813   bool found = false;
 814   options->is_muc = false;
 815   buzz::Jid callto_jid(name);
 816   if (name.length() == 0 && mucs_.size() > 0) {
 817     // if no name, and in a MUC, establish audio with the MUC
 818     *found_jid = mucs_.begin()->first;
 819     found = true;
 820     options->is_muc = true;
 821   } else if (name[0] == '+') {
 822     // if the first character is a +, assume it's a phone number
 823     *found_jid = callto_jid;
 824     found = true;
 825   } else {
 826     // otherwise, it's a friend
 827     for (RosterMap::iterator iter = roster_->begin();
 828          iter != roster_->end(); ++iter) {
 829       if (iter->second.jid.BareEquals(callto_jid)) {
 830         found = true;
 831         *found_jid = iter->second.jid;
 832         break;
 833       }
 834     }
 835
 836     if (!found) {
 837       if (mucs_.count(callto_jid) == 1 &&
 838           mucs_[callto_jid]->state() == buzz::Muc::MUC_JOINED) {
 839         found = true;
 840         *found_jid = callto_jid;
 841         options->is_muc = true;
 842       }
 843     }
 844   }
 845
 846   if (found) {
 847     console_->PrintLine("Found %s '%s'",
 848                         options->is_muc ? "room" : "online friend",
 849                         found_jid->Str().c_str());
 850   } else {
 851     console_->PrintLine("Could not find online friend '%s'", name.c_str());
 852   }
 853
 854   return found;
 855 }
 856
 857 void CallClient::OnDataReceived(cricket::Call*,
 858                                 const cricket::ReceiveDataParams& params,
 859                                 const rtc::Buffer& payload) {
 860   // TODO(mylesj): Support receiving data on sessions other than the first.
 861   cricket::Session* session = GetFirstSession();
 862   if (!session)
 863     return;
 864
 865   cricket::StreamParams stream;
 866   const std::vector<cricket::StreamParams>* data_streams =
 867       call_->GetDataRecvStreams(session);
 868   std::string text(payload.data(), payload.length());
 869   if (data_streams && GetStreamBySsrc(*data_streams, params.ssrc, &stream)) {
 870     console_->PrintLine(
 871         "Received data from '%s' on stream '%s' (ssrc=%u): %s",
 872         stream.groupid.c_str(), stream.id.c_str(),
 873         params.ssrc, text.c_str());
 874   } else {
 875     console_->PrintLine(
 876         "Received data (ssrc=%u): %s",
 877         params.ssrc, text.c_str());
 878   }
 879 }
 880
 881 bool CallClient::PlaceCall(const std::string& name,
 882                            cricket::CallOptions options) {
 883   buzz::Jid jid;
 884   if (!FindJid(name, &jid, &options))
 885     return false;
 886
 887   if (!call_) {
 888     call_ = media_client_->CreateCall();
 889     AddSession(call_->InitiateSession(jid, media_client_->jid(), options));
 890   }
 891   media_client_->SetFocus(call_);
 892   if (call_->has_video() && render_ && !options.is_muc) {
 893     // TODO(pthatcher): Hookup local_render_ to the local capturer.
 894   }
 895   if (options.is_muc) {
 896     const std::string& nick = mucs_[jid]->local_jid().resource();
 897     hangout_pubsub_client_ =
 898         new buzz::HangoutPubSubClient(xmpp_client_, jid, nick);
 899     hangout_pubsub_client_->SignalPresenterStateChange.connect(
 900         this, &CallClient::OnPresenterStateChange);
 901     hangout_pubsub_client_->SignalAudioMuteStateChange.connect(
 902         this, &CallClient::OnAudioMuteStateChange);
 903     hangout_pubsub_client_->SignalRecordingStateChange.connect(
 904         this, &CallClient::OnRecordingStateChange);
 905     hangout_pubsub_client_->SignalRemoteMute.connect(
 906         this, &CallClient::OnRemoteMuted);
 907     hangout_pubsub_client_->SignalMediaBlock.connect(
 908         this, &CallClient::OnMediaBlocked);
 909     hangout_pubsub_client_->SignalRequestError.connect(
 910         this, &CallClient::OnHangoutRequestError);
 911     hangout_pubsub_client_->SignalPublishAudioMuteError.connect(
 912         this, &CallClient::OnHangoutPublishAudioMuteError);
 913     hangout_pubsub_client_->SignalPublishPresenterError.connect(
 914         this, &CallClient::OnHangoutPublishPresenterError);
 915     hangout_pubsub_client_->SignalPublishRecordingError.connect(
 916         this, &CallClient::OnHangoutPublishRecordingError);
 917     hangout_pubsub_client_->SignalRemoteMuteError.connect(
 918         this, &CallClient::OnHangoutRemoteMuteError);
 919     hangout_pubsub_client_->RequestAll();
 920   }
 921
 922   return true;
 923 }
 924
 925 bool CallClient::InitiateAdditionalSession(const std::string& name,
 926                                            cricket::CallOptions options) {
 927   // Can't add a session if there is no call yet.
 928   if (!call_)
 929     return false;
 930
 931   buzz::Jid jid;
 932   if (!FindJid(name, &jid, &options))
 933     return false;
 934
 935   std::vector<cricket::Session*>& call_sessions = sessions_[call_->id()];
 936   call_sessions.push_back(
 937       call_->InitiateSession(jid,
 938                              buzz::Jid(call_sessions[0]->remote_name()),
 939                              options));
 940
 941   return true;
 942 }
 943
 944 void CallClient::TerminateAndRemoveSession(cricket::Call* call,
 945                                            const std::string& id) {
 946   std::vector<cricket::Session*>& call_sessions = sessions_[call->id()];
 947   for (std::vector<cricket::Session*>::iterator iter = call_sessions.begin();
 948        iter != call_sessions.end(); ++iter) {
 949     if ((*iter)->id() == id) {
 950       RenderAllStreams(call, *iter, false);
 951       call_->TerminateSession(*iter);
 952       call_sessions.erase(iter);
 953       break;
 954     }
 955   }
 956 }
 957
 958 void CallClient::PrintCalls() {
 959   const std::map<uint32, cricket::Call*>& calls = media_client_->calls();
 960   for (std::map<uint32, cricket::Call*>::const_iterator i = calls.begin();
 961        i != calls.end(); ++i) {
 962     console_->PrintLine("Call (id:%d), is %s",
 963                         i->first,
 964                         i->second == call_ ? "active" : "on hold");
 965     std::vector<cricket::Session *>& sessions = sessions_[call_->id()];
 966     for (std::vector<cricket::Session *>::const_iterator j = sessions.begin();
 967          j != sessions.end(); ++j) {
 968       console_->PrintLine("|--Session (id:%s), to %s", (*j)->id().c_str(),
 969                           (*j)->remote_name().c_str());
 970
 971       std::vector<cricket::StreamParams>::const_iterator k;
 972       const std::vector<cricket::StreamParams>* streams =
 973           i->second->GetAudioRecvStreams(*j);
 974       if (streams)
 975         for (k = streams->begin(); k != streams->end(); ++k) {
 976           console_->PrintLine("|----Audio Stream: %s", k->ToString().c_str());
 977         }
 978       streams = i->second->GetVideoRecvStreams(*j);
 979       if (streams)
 980         for (k = streams->begin(); k != streams->end(); ++k) {
 981           console_->PrintLine("|----Video Stream: %s", k->ToString().c_str());
 982         }
 983       streams = i->second->GetDataRecvStreams(*j);
 984       if (streams)
 985         for (k = streams->begin(); k != streams->end(); ++k) {
 986           console_->PrintLine("|----Data Stream: %s", k->ToString().c_str());
 987         }
 988     }
 989   }
 990 }
 991
 992 void CallClient::SwitchToCall(uint32 call_id) {
 993   const std::map<uint32, cricket::Call*>& calls = media_client_->calls();
 994   std::map<uint32, cricket::Call*>::const_iterator call_iter =
 995       calls.find(call_id);
 996   if (call_iter != calls.end()) {
 997     media_client_->SetFocus(call_iter->second);
 998     call_ = call_iter->second;
 999   } else {
1000     console_->PrintLine("Unable to find call: %d", call_id);
1001   }
1002 }
1003
1004 void CallClient::OnPresenterStateChange(
1005     const std::string& nick, bool was_presenting, bool is_presenting) {
1006   if (!was_presenting && is_presenting) {
1007     console_->PrintLine("%s now presenting.", nick.c_str());
1008   } else if (was_presenting && !is_presenting) {
1009     console_->PrintLine("%s no longer presenting.", nick.c_str());
1010   } else if (was_presenting && is_presenting) {
1011     console_->PrintLine("%s still presenting.", nick.c_str());
1012   } else if (!was_presenting && !is_presenting) {
1013     console_->PrintLine("%s still not presenting.", nick.c_str());
1014   }
1015 }
1016
1017 void CallClient::OnAudioMuteStateChange(
1018     const std::string& nick, bool was_muted, bool is_muted) {
1019   if (!was_muted && is_muted) {
1020     console_->PrintLine("%s now muted.", nick.c_str());
1021   } else if (was_muted && !is_muted) {
1022     console_->PrintLine("%s no longer muted.", nick.c_str());
1023   }
1024 }
1025
1026 void CallClient::OnRecordingStateChange(
1027     const std::string& nick, bool was_recording, bool is_recording) {
1028   if (!was_recording && is_recording) {
1029     console_->PrintLine("%s now recording.", nick.c_str());
1030   } else if (was_recording && !is_recording) {
1031     console_->PrintLine("%s no longer recording.", nick.c_str());
1032   }
1033 }
1034
1035 void CallClient::OnRemoteMuted(const std::string& mutee_nick,
1036                                const std::string& muter_nick,
1037                                bool should_mute_locally) {
1038   if (should_mute_locally) {
1039     call_->Mute(true);
1040     console_->PrintLine("Remote muted by %s.", muter_nick.c_str());
1041   } else {
1042     console_->PrintLine("%s remote muted by %s.",
1043                         mutee_nick.c_str(), muter_nick.c_str());
1044   }
1045 }
1046
1047 void CallClient::OnMediaBlocked(const std::string& blockee_nick,
1048                                 const std::string& blocker_nick) {
1049   console_->PrintLine("%s blocked by %s.",
1050                       blockee_nick.c_str(), blocker_nick.c_str());
1051 }
1052
1053 void CallClient::OnHangoutRequestError(const std::string& node,
1054                                        const buzz::XmlElement* stanza) {
1055   console_->PrintLine("Failed request pub sub items for node %s.",
1056                       node.c_str());
1057 }
1058
1059 void CallClient::OnHangoutPublishAudioMuteError(
1060     const std::string& task_id, const buzz::XmlElement* stanza) {
1061   console_->PrintLine("Failed to publish audio mute state.");
1062 }
1063
1064 void CallClient::OnHangoutPublishPresenterError(
1065     const std::string& task_id, const buzz::XmlElement* stanza) {
1066   console_->PrintLine("Failed to publish presenting state.");
1067 }
1068
1069 void CallClient::OnHangoutPublishRecordingError(
1070     const std::string& task_id, const buzz::XmlElement* stanza) {
1071   console_->PrintLine("Failed to publish recording state.");
1072 }
1073
1074 void CallClient::OnHangoutRemoteMuteError(const std::string& task_id,
1075                                           const std::string& mutee_nick,
1076                                           const buzz::XmlElement* stanza) {
1077   console_->PrintLine("Failed to remote mute.");
1078 }
1079
1080 void CallClient::Accept(const cricket::CallOptions& options) {
1081   ASSERT(call_ && incoming_call_);
1082   ASSERT(sessions_[call_->id()].size() == 1);
1083   cricket::Session* session = GetFirstSession();
1084   call_->AcceptSession(session, options);
1085   media_client_->SetFocus(call_);
1086   if (call_->has_video() && render_) {
1087     // TODO(pthatcher): Hookup local_render_ to the local capturer.
1088     RenderAllStreams(call_, session, true);
1089   }
1090   SetupAcceptedCall();
1091   incoming_call_ = false;
1092 }
1093
1094 void CallClient::SetupAcceptedCall() {
1095   if (call_->has_data()) {
1096     call_->SignalDataReceived.connect(this, &CallClient::OnDataReceived);
1097   }
1098 }
1099
1100 void CallClient::Reject() {
1101   ASSERT(call_ && incoming_call_);
1102   call_->RejectSession(call_->sessions()[0]);
1103   incoming_call_ = false;
1104 }
1105
1106 void CallClient::Quit() {
1107   rtc::Thread::Current()->Quit();
1108 }
1109
1110 void CallClient::SetNick(const std::string& muc_nick) {
1111   my_status_.set_nick(muc_nick);
1112
1113   // TODO: We might want to re-send presence, but right
1114   // now, it appears to be ignored by the MUC.
1115   //
1116   // presence_out_->Send(my_status_); for (MucMap::const_iterator itr
1117   // = mucs_.begin(); itr != mucs_.end(); ++itr) {
1118   // presence_out_->SendDirected(itr->second->local_jid(),
1119   // my_status_); }
1120
1121   console_->PrintLine("Nick set to '%s'.", muc_nick.c_str());
1122 }
1123
1124 void CallClient::LookupAndJoinMuc(const std::string& room_name) {
1125   // The room_name can't be empty for lookup task.
1126   if (room_name.empty()) {
1127     console_->PrintLine("Please provide a room name or room jid.");
1128     return;
1129   }
1130
1131   std::string room = room_name;
1132   std::string domain = xmpp_client_->jid().domain();
1133   if (room_name.find("@") != std::string::npos) {
1134     // Assume the room_name is a fully qualified room name.
1135     // We'll find the room name string and domain name string from it.
1136     room = room_name.substr(0, room_name.find("@"));
1137     domain = room_name.substr(room_name.find("@") + 1);
1138   }
1139
1140   buzz::MucRoomLookupTask* lookup_query_task =
1141       buzz::MucRoomLookupTask::CreateLookupTaskForRoomName(
1142           xmpp_client_, buzz::Jid(buzz::STR_GOOGLE_MUC_LOOKUP_JID), room,
1143           domain);
1144   lookup_query_task->SignalResult.connect(this,
1145       &CallClient::OnRoomLookupResponse);
1146   lookup_query_task->SignalError.connect(this,
1147       &CallClient::OnRoomLookupError);
1148   lookup_query_task->Start();
1149 }
1150
1151 void CallClient::JoinMuc(const std::string& room_jid_str) {
1152   if (room_jid_str.empty()) {
1153     buzz::Jid room_jid = GenerateRandomMucJid();
1154     console_->PrintLine("Generated a random room jid: %s",
1155                         room_jid.Str().c_str());
1156     JoinMuc(room_jid);
1157   } else {
1158     JoinMuc(buzz::Jid(room_jid_str));
1159   }
1160 }
1161
1162 void CallClient::JoinMuc(const buzz::Jid& room_jid) {
1163   if (!room_jid.IsValid()) {
1164     console_->PrintLine("Unable to make valid muc endpoint for %s",
1165                         room_jid.Str().c_str());
1166     return;
1167   }
1168
1169   std::string room_nick = room_jid.resource();
1170   if (room_nick.empty()) {
1171     room_nick = (xmpp_client_->jid().node()
1172                  + "_" + xmpp_client_->jid().resource());
1173   }
1174
1175   MucMap::iterator elem = mucs_.find(room_jid);
1176   if (elem != mucs_.end()) {
1177     console_->PrintLine("This MUC already exists.");
1178     return;
1179   }
1180
1181   buzz::Muc* muc = new buzz::Muc(room_jid.BareJid(), room_nick);
1182   mucs_[muc->jid()] = muc;
1183   presence_out_->SendDirected(muc->local_jid(), my_status_);
1184 }
1185
1186 void CallClient::OnRoomLookupResponse(buzz::MucRoomLookupTask* task,
1187                                       const buzz::MucRoomInfo& room) {
1188   // The server requires the room be "configured" before being used.
1189   // We only need to configure it if we create it, but rooms are
1190   // auto-created at lookup, so there's currently no way to know if we
1191   // created it.  So, we configure it every time, just in case.
1192   // Luckily, it appears to be safe to configure a room that's already
1193   // configured.  Our current flow is:
1194   // 1. Lookup/auto-create
1195   // 2. Configure
1196   // 3. Join
1197   // TODO: In the future, once the server supports it, we
1198   // should:
1199   // 1. Lookup
1200   // 2. Create and Configure if necessary
1201   // 3. Join
1202   std::vector<std::string> room_features;
1203   room_features.push_back(buzz::STR_MUC_ROOM_FEATURE_ENTERPRISE);
1204   buzz::MucRoomConfigTask* room_config_task = new buzz::MucRoomConfigTask(
1205       xmpp_client_, room.jid, room.full_name(), room_features);
1206   room_config_task->SignalResult.connect(this,
1207       &CallClient::OnRoomConfigResult);
1208   room_config_task->SignalError.connect(this,
1209       &CallClient::OnRoomConfigError);
1210   room_config_task->Start();
1211 }
1212
1213 void CallClient::OnRoomLookupError(buzz::IqTask* task,
1214                                    const buzz::XmlElement* stanza) {
1215   if (stanza == NULL) {
1216     console_->PrintLine("Room lookup failed.");
1217   } else {
1218     console_->PrintLine("Room lookup error: ", stanza->Str().c_str());
1219   }
1220 }
1221
1222 void CallClient::OnRoomConfigResult(buzz::MucRoomConfigTask* task) {
1223   JoinMuc(task->room_jid());
1224 }
1225
1226 void CallClient::OnRoomConfigError(buzz::IqTask* task,
1227                                    const buzz::XmlElement* stanza) {
1228   console_->PrintLine("Room config failed.");
1229   // We join the muc anyway, because if the room is already
1230   // configured, the configure will fail, but we still want to join.
1231   // Idealy, we'd know why the room config failed and only do this on
1232   // "already configured" errors.  But right now all we get back is
1233   // "not-allowed".
1234   buzz::MucRoomConfigTask* config_task =
1235       static_cast<buzz::MucRoomConfigTask*>(task);
1236   JoinMuc(config_task->room_jid());
1237 }
1238
1239 void CallClient::OnMucInviteReceived(const buzz::Jid& inviter,
1240     const buzz::Jid& room,
1241     const std::vector<buzz::AvailableMediaEntry>& avail) {
1242
1243   console_->PrintLine("Invited to join %s by %s.", room.Str().c_str(),
1244       inviter.Str().c_str());
1245   console_->PrintLine("Available media:");
1246   if (avail.size() > 0) {
1247     for (std::vector<buzz::AvailableMediaEntry>::const_iterator i =
1248             avail.begin();
1249         i != avail.end();
1250         ++i) {
1251       console_->PrintLine("  %s, %s",
1252                           buzz::AvailableMediaEntry::TypeAsString(i->type),
1253                           buzz::AvailableMediaEntry::StatusAsString(i->status));
1254     }
1255   } else {
1256     console_->PrintLine("  None");
1257   }
1258   // We automatically join the room.
1259   JoinMuc(room);
1260 }
1261
1262 void CallClient::OnMucJoined(const buzz::Jid& endpoint) {
1263   MucMap::iterator elem = mucs_.find(endpoint);
1264   ASSERT(elem != mucs_.end() &&
1265          elem->second->state() == buzz::Muc::MUC_JOINING);
1266
1267   buzz::Muc* muc = elem->second;
1268   muc->set_state(buzz::Muc::MUC_JOINED);
1269   console_->PrintLine("Joined \"%s\"", muc->jid().Str().c_str());
1270 }
1271
1272 void CallClient::OnMucStatusUpdate(const buzz::Jid& jid,
1273     const buzz::MucPresenceStatus& status) {
1274
1275   // Look up this muc.
1276   MucMap::iterator elem = mucs_.find(jid);
1277   ASSERT(elem != mucs_.end());
1278
1279   buzz::Muc* muc = elem->second;
1280
1281   if (status.jid().IsBare() || status.jid() == muc->local_jid()) {
1282     // We are only interested in status about other users.
1283     return;
1284   }
1285
1286   if (status.available()) {
1287     muc->members()[status.jid().resource()] = status;
1288   } else {
1289     muc->members().erase(status.jid().resource());
1290   }
1291 }
1292
1293 bool CallClient::InMuc() {
1294   const buzz::Jid* muc_jid = FirstMucJid();
1295   if (!muc_jid) return false;
1296   return muc_jid->IsValid();
1297 }
1298
1299 const buzz::Jid* CallClient::FirstMucJid() {
1300   if (mucs_.empty()) return NULL;
1301   return &(mucs_.begin()->first);
1302 }
1303
1304 void CallClient::LeaveMuc(const std::string& room) {
1305   buzz::Jid room_jid;
1306   const buzz::Jid* muc_jid = FirstMucJid();
1307   if (room.length() > 0) {
1308     room_jid = buzz::Jid(room);
1309   } else if (mucs_.size() > 0) {
1310     // leave the first MUC if no JID specified
1311     if (muc_jid) {
1312       room_jid = *(muc_jid);
1313     }
1314   }
1315
1316   if (!room_jid.IsValid()) {
1317     console_->PrintLine("Invalid MUC JID.");
1318     return;
1319   }
1320
1321   MucMap::iterator elem = mucs_.find(room_jid);
1322   if (elem == mucs_.end()) {
1323     console_->PrintLine("No such MUC.");
1324     return;
1325   }
1326
1327   buzz::Muc* muc = elem->second;
1328   muc->set_state(buzz::Muc::MUC_LEAVING);
1329
1330   buzz::PresenceStatus status;
1331   status.set_jid(my_status_.jid());
1332   status.set_available(false);
1333   status.set_priority(0);
1334   presence_out_->SendDirected(muc->local_jid(), status);
1335 }
1336
1337 void CallClient::OnMucLeft(const buzz::Jid& endpoint, int error) {
1338   // We could be kicked from a room from any state.  We would hope this
1339   // happens While in the MUC_LEAVING state
1340   MucMap::iterator elem = mucs_.find(endpoint);
1341   if (elem == mucs_.end())
1342     return;
1343
1344   buzz::Muc* muc = elem->second;
1345   if (muc->state() == buzz::Muc::MUC_JOINING) {
1346     console_->PrintLine("Failed to join \"%s\", code=%d",
1347                         muc->jid().Str().c_str(), error);
1348   } else if (muc->state() == buzz::Muc::MUC_JOINED) {
1349     console_->PrintLine("Kicked from \"%s\"",
1350                         muc->jid().Str().c_str());
1351   }
1352
1353   delete muc;
1354   mucs_.erase(elem);
1355 }
1356
1357 void CallClient::InviteToMuc(const std::string& given_user,
1358                              const std::string& room) {
1359   std::string user = given_user;
1360
1361   // First find the room.
1362   const buzz::Muc* found_muc;
1363   if (room.length() == 0) {
1364     if (mucs_.size() == 0) {
1365       console_->PrintLine("Not in a room yet; can't invite.");
1366       return;
1367     }
1368     // Invite to the first muc
1369     found_muc = mucs_.begin()->second;
1370   } else {
1371     MucMap::iterator elem = mucs_.find(buzz::Jid(room));
1372     if (elem == mucs_.end()) {
1373       console_->PrintLine("Not in room %s.", room.c_str());
1374       return;
1375     }
1376     found_muc = elem->second;
1377   }
1378
1379   buzz::Jid invite_to = found_muc->jid();
1380
1381   // Now find the user. We invite all of their resources.
1382   bool found_user = false;
1383   buzz::Jid user_jid(user);
1384   for (RosterMap::iterator iter = roster_->begin();
1385        iter != roster_->end(); ++iter) {
1386     if (iter->second.jid.BareEquals(user_jid)) {
1387       buzz::Jid invitee = iter->second.jid;
1388       muc_invite_send_->Send(invite_to, invitee);
1389       found_user = true;
1390     }
1391   }
1392   if (!found_user) {
1393     buzz::Jid invitee = user_jid;
1394     muc_invite_send_->Send(invite_to, invitee);
1395   }
1396 }
1397
1398 void CallClient::GetDevices() {
1399   std::vector<std::string> names;
1400   media_client_->GetAudioInputDevices(&names);
1401   console_->PrintLine("Audio input devices:");
1402   PrintDevices(names);
1403   media_client_->GetAudioOutputDevices(&names);
1404   console_->PrintLine("Audio output devices:");
1405   PrintDevices(names);
1406   media_client_->GetVideoCaptureDevices(&names);
1407   console_->PrintLine("Video capture devices:");
1408   PrintDevices(names);
1409 }
1410
1411 void CallClient::PrintDevices(const std::vector<std::string>& names) {
1412   for (size_t i = 0; i < names.size(); ++i) {
1413     console_->PrintLine("%d: %s", static_cast<int>(i), names[i].c_str());
1414   }
1415 }
1416
1417 void CallClient::OnDevicesChange() {
1418   console_->PrintLine("Devices changed.");
1419   SetMediaCaps(media_client_->GetCapabilities(), &my_status_);
1420   SendStatus(my_status_);
1421 }
1422
1423 void CallClient::SetVolume(const std::string& level) {
1424   media_client_->SetOutputVolume(strtol(level.c_str(), NULL, 10));
1425 }
1426
1427 void CallClient::OnMediaStreamsUpdate(cricket::Call* call,
1428                                       cricket::Session* session,
1429                                       const cricket::MediaStreams& added,
1430                                       const cricket::MediaStreams& removed) {
1431   if (call && call->has_video()) {
1432     for (std::vector<cricket::StreamParams>::const_iterator
1433          it = removed.video().begin(); it != removed.video().end(); ++it) {
1434       RemoveStaticRenderedView(it->first_ssrc());
1435     }
1436
1437     if (render_) {
1438       RenderStreams(call, session, added.video(), true);
1439     }
1440     SendViewRequest(call, session);
1441   }
1442 }
1443
1444 void CallClient::RenderAllStreams(cricket::Call* call,
1445                                   cricket::Session* session,
1446                                   bool enable) {
1447   const std::vector<cricket::StreamParams>* video_streams =
1448       call->GetVideoRecvStreams(session);
1449   if (video_streams) {
1450     RenderStreams(call, session, *video_streams, enable);
1451   }
1452 }
1453
1454 void CallClient::RenderStreams(
1455     cricket::Call* call,
1456     cricket::Session* session,
1457     const std::vector<cricket::StreamParams>& video_streams,
1458     bool enable) {
1459   std::vector<cricket::StreamParams>::const_iterator stream;
1460   for (stream = video_streams.begin(); stream != video_streams.end();
1461        ++stream) {
1462     RenderStream(call, session, *stream, enable);
1463   }
1464 }
1465
1466 void CallClient::RenderStream(cricket::Call* call,
1467                               cricket::Session* session,
1468                               const cricket::StreamParams& stream,
1469                               bool enable) {
1470   if (!stream.has_ssrcs()) {
1471     // Nothing to see here; move along.
1472     return;
1473   }
1474
1475   uint32 ssrc = stream.first_ssrc();
1476   StaticRenderedViews::iterator iter =
1477       static_rendered_views_.find(std::make_pair(session, ssrc));
1478   if (enable) {
1479     if (iter == static_rendered_views_.end()) {
1480       // TODO(pthatcher): Make dimensions and positions more configurable.
1481       int offset = (50 * static_views_accumulated_count_) % 300;
1482       AddStaticRenderedView(session, ssrc, 640, 400, 30,
1483                             offset, offset);
1484       // Should have it now.
1485       iter = static_rendered_views_.find(std::make_pair(session, ssrc));
1486     }
1487     call->SetVideoRenderer(session, ssrc, iter->second.renderer);
1488   } else {
1489     if (iter != static_rendered_views_.end()) {
1490       call->SetVideoRenderer(session, ssrc, NULL);
1491       RemoveStaticRenderedView(ssrc);
1492     }
1493   }
1494 }
1495
1496 // TODO: Would these methods to add and remove views make
1497 // more sense in call.cc?  Would other clients use them?
1498 void CallClient::AddStaticRenderedView(
1499     cricket::Session* session,
1500     uint32 ssrc, int width, int height, int framerate,
1501     int x_offset, int y_offset) {
1502   StaticRenderedView rendered_view(
1503       cricket::StaticVideoView(
1504           cricket::StreamSelector(ssrc), width, height, framerate),
1505       cricket::VideoRendererFactory::CreateGuiVideoRenderer(
1506           x_offset, y_offset));
1507   rendered_view.renderer->SetSize(width, height, 0);
1508   static_rendered_views_.insert(std::make_pair(std::make_pair(session, ssrc),
1509                                                rendered_view));
1510   ++static_views_accumulated_count_;
1511   console_->PrintLine("Added renderer for ssrc %d", ssrc);
1512 }
1513
1514 bool CallClient::RemoveStaticRenderedView(uint32 ssrc) {
1515   for (StaticRenderedViews::iterator it = static_rendered_views_.begin();
1516        it != static_rendered_views_.end(); ++it) {
1517     if (it->second.view.selector.ssrc == ssrc) {
1518       delete it->second.renderer;
1519       static_rendered_views_.erase(it);
1520       console_->PrintLine("Removed renderer for ssrc %d", ssrc);
1521       return true;
1522     }
1523   }
1524   return false;
1525 }
1526
1527 void CallClient::RemoveCallsStaticRenderedViews(cricket::Call* call) {
1528   std::vector<cricket::Session*>& sessions = sessions_[call->id()];
1529   std::set<cricket::Session*> call_sessions(sessions.begin(), sessions.end());
1530   for (StaticRenderedViews::iterator it = static_rendered_views_.begin();
1531        it != static_rendered_views_.end(); ) {
1532     if (call_sessions.find(it->first.first) != call_sessions.end()) {
1533       delete it->second.renderer;
1534       static_rendered_views_.erase(it++);
1535     } else {
1536       ++it;
1537     }
1538   }
1539 }
1540
1541 void CallClient::SendViewRequest(cricket::Call* call,
1542                                  cricket::Session* session) {
1543   cricket::ViewRequest request;
1544   for (StaticRenderedViews::iterator it = static_rendered_views_.begin();
1545        it != static_rendered_views_.end(); ++it) {
1546     if (it->first.first == session) {
1547       request.static_video_views.push_back(it->second.view);
1548     }
1549   }
1550   call->SendViewRequest(session, request);
1551 }
1552
1553 buzz::Jid CallClient::GenerateRandomMucJid() {
1554   // Generate a GUID of the form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX,
1555   // for an eventual JID of private-chat-<GUID>@groupchat.google.com.
1556   char guid[37], guid_room[256];
1557   for (size_t i = 0; i < ARRAY_SIZE(guid) - 1;) {
1558     if (i == 8 || i == 13 || i == 18 || i == 23) {
1559       guid[i++] = '-';
1560     } else {
1561       sprintf(guid + i, "%04x", rand());
1562       i += 4;
1563     }
1564   }
1565
1566   rtc::sprintfn(guid_room,
1567                       ARRAY_SIZE(guid_room),
1568                       "private-chat-%s@%s",
1569                       guid,
1570                       pmuc_domain_.c_str());
1571   return buzz::Jid(guid_room);
1572 }
1573
1574 bool CallClient::SelectFirstDesktopScreencastId(
1575     cricket::ScreencastId* screencastid) {
1576   if (!rtc::WindowPickerFactory::IsSupported()) {
1577     LOG(LS_WARNING) << "Window picker not suported on this OS.";
1578     return false;
1579   }
1580
1581   rtc::WindowPicker* picker =
1582       rtc::WindowPickerFactory::CreateWindowPicker();
1583   if (!picker) {
1584     LOG(LS_WARNING) << "Could not create a window picker.";
1585     return false;
1586   }
1587
1588   rtc::DesktopDescriptionList desktops;
1589   if (!picker->GetDesktopList(&desktops) || desktops.empty()) {
1590     LOG(LS_WARNING) << "Could not get a list of desktops.";
1591     return false;
1592   }
1593
1594   *screencastid = cricket::ScreencastId(desktops[0].id());
1595   return true;
1596 }
1597
1598 void CallClient::PrintStats() const {
1599   const cricket::VoiceMediaInfo& vmi = call_->last_voice_media_info();
1600
1601   for (std::vector<cricket::VoiceSenderInfo>::const_iterator it =
1602        vmi.senders.begin(); it != vmi.senders.end(); ++it) {
1603     console_->PrintLine("Sender: ssrc=%u codec='%s' bytes=%d packets=%d "
1604                         "rtt=%d jitter=%d",
1605                         it->ssrc(), it->codec_name.c_str(), it->bytes_sent,
1606                         it->packets_sent, it->rtt_ms, it->jitter_ms);
1607   }
1608
1609   for (std::vector<cricket::VoiceReceiverInfo>::const_iterator it =
1610        vmi.receivers.begin(); it != vmi.receivers.end(); ++it) {
1611     console_->PrintLine("Receiver: ssrc=%u bytes=%d packets=%d "
1612                         "jitter=%d loss=%.2f",
1613                         it->ssrc(), it->bytes_rcvd, it->packets_rcvd,
1614                         it->jitter_ms, it->fraction_lost);
1615   }
1616 }