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 #ifndef TALK_EXAMPLES_CALL_CALLCLIENT_H_ 29 #define TALK_EXAMPLES_CALL_CALLCLIENT_H_ 30 31 #include <map> 32 #include <string> 33 #include <vector> 34 35 #include "talk/examples/call/console.h" 36 #include "talk/media/base/mediachannel.h" 37 #include "talk/p2p/base/session.h" 38 #include "talk/session/media/mediamessages.h" 39 #include "talk/session/media/mediasessionclient.h" 40 #include "talk/xmpp/hangoutpubsubclient.h" 41 #include "talk/xmpp/presencestatus.h" 42 #include "talk/xmpp/xmppclient.h" 43 #include "webrtc/base/scoped_ptr.h" 44 #include "webrtc/base/sslidentity.h" 45 46 namespace buzz { 47 class PresencePushTask; 48 class PresenceOutTask; 49 class MucInviteRecvTask; 50 class MucInviteSendTask; 51 class FriendInviteSendTask; 52 class DiscoInfoQueryTask; 53 class Muc; 54 class PresenceStatus; 55 class IqTask; 56 class MucRoomConfigTask; 57 class MucRoomLookupTask; 58 class MucPresenceStatus; 59 class XmlElement; 60 class HangoutPubSubClient; 61 struct AvailableMediaEntry; 62 struct MucRoomInfo; 63 } // namespace buzz 64 65 namespace rtc { 66 class Thread; 67 class NetworkManager; 68 } // namespace rtc 69 70 namespace cricket { 71 class PortAllocator; 72 class MediaEngineInterface; 73 class MediaSessionClient; 74 class Call; 75 class SessionManagerTask; 76 struct CallOptions; 77 struct MediaStreams; 78 struct StreamParams; 79 } // namespace cricket 80 81 struct RosterItem { 82 buzz::Jid jid; 83 buzz::PresenceStatus::Show show; 84 std::string status; 85 }; 86 87 struct StaticRenderedView { StaticRenderedViewStaticRenderedView88 StaticRenderedView(const cricket::StaticVideoView& view, 89 cricket::VideoRenderer* renderer) : 90 view(view), 91 renderer(renderer) { 92 } 93 94 cricket::StaticVideoView view; 95 cricket::VideoRenderer* renderer; 96 }; 97 98 // Maintain a mapping of (session, ssrc) to rendered view. 99 typedef std::map<std::pair<cricket::Session*, uint32>, 100 StaticRenderedView> StaticRenderedViews; 101 102 class CallClient: public sigslot::has_slots<> { 103 public: 104 CallClient(buzz::XmppClient* xmpp_client, 105 const std::string& caps_node, 106 const std::string& version); 107 ~CallClient(); 108 media_client()109 cricket::MediaSessionClient* media_client() const { return media_client_; } SetMediaEngine(cricket::MediaEngineInterface * media_engine)110 void SetMediaEngine(cricket::MediaEngineInterface* media_engine) { 111 media_engine_ = media_engine; 112 } SetAutoAccept(bool auto_accept)113 void SetAutoAccept(bool auto_accept) { 114 auto_accept_ = auto_accept; 115 } SetPmucDomain(const std::string & pmuc_domain)116 void SetPmucDomain(const std::string &pmuc_domain) { 117 pmuc_domain_ = pmuc_domain; 118 } SetRender(bool render)119 void SetRender(bool render) { 120 render_ = render; 121 } SetDataChannelType(cricket::DataChannelType data_channel_type)122 void SetDataChannelType(cricket::DataChannelType data_channel_type) { 123 data_channel_type_ = data_channel_type; 124 } SetMultiSessionEnabled(bool multisession_enabled)125 void SetMultiSessionEnabled(bool multisession_enabled) { 126 multisession_enabled_ = multisession_enabled; 127 } SetConsole(Console * console)128 void SetConsole(Console *console) { 129 console_ = console; 130 } SetPriority(int priority)131 void SetPriority(int priority) { 132 my_status_.set_priority(priority); 133 } SendStatus()134 void SendStatus() { 135 SendStatus(my_status_); 136 } 137 void SendStatus(const buzz::PresenceStatus& status); 138 139 void ParseLine(const std::string &str); 140 141 void SendChat(const std::string& to, const std::string msg); 142 void SendData(const std::string& stream_name, 143 const std::string& text); 144 void InviteFriend(const std::string& user); 145 void JoinMuc(const buzz::Jid& room_jid); 146 void JoinMuc(const std::string& room_jid_str); 147 void LookupAndJoinMuc(const std::string& room_name); 148 void InviteToMuc(const std::string& user, const std::string& room); 149 bool InMuc(); 150 const buzz::Jid* FirstMucJid(); 151 void LeaveMuc(const std::string& room); 152 void SetNick(const std::string& muc_nick); SetPortAllocatorFlags(uint32 flags)153 void SetPortAllocatorFlags(uint32 flags) { portallocator_flags_ = flags; } SetAllowLocalIps(bool allow_local_ips)154 void SetAllowLocalIps(bool allow_local_ips) { 155 allow_local_ips_ = allow_local_ips; 156 } 157 SetSignalingProtocol(cricket::SignalingProtocol protocol)158 void SetSignalingProtocol(cricket::SignalingProtocol protocol) { 159 signaling_protocol_ = protocol; 160 } SetTransportProtocol(cricket::TransportProtocol protocol)161 void SetTransportProtocol(cricket::TransportProtocol protocol) { 162 transport_protocol_ = protocol; 163 } SetSecurePolicy(cricket::SecurePolicy sdes_policy,cricket::SecurePolicy dtls_policy)164 void SetSecurePolicy(cricket::SecurePolicy sdes_policy, 165 cricket::SecurePolicy dtls_policy) { 166 sdes_policy_ = sdes_policy; 167 dtls_policy_ = dtls_policy; 168 } SetSslIdentity(rtc::SSLIdentity * identity)169 void SetSslIdentity(rtc::SSLIdentity* identity) { 170 ssl_identity_.reset(identity); 171 } 172 173 typedef std::map<buzz::Jid, buzz::Muc*> MucMap; 174 mucs()175 const MucMap& mucs() const { 176 return mucs_; 177 } 178 SetShowRosterMessages(bool show_roster_messages)179 void SetShowRosterMessages(bool show_roster_messages) { 180 show_roster_messages_ = show_roster_messages; 181 } 182 183 private: 184 void AddStream(uint32 audio_src_id, uint32 video_src_id); 185 void RemoveStream(uint32 audio_src_id, uint32 video_src_id); 186 void OnStateChange(buzz::XmppEngine::State state); 187 188 void InitMedia(); 189 void InitPresence(); 190 void StartXmppPing(); 191 void OnPingTimeout(); 192 void OnRequestSignaling(); 193 void OnSessionCreate(cricket::Session* session, bool initiate); 194 void OnCallCreate(cricket::Call* call); 195 void OnCallDestroy(cricket::Call* call); 196 void OnSessionState(cricket::Call* call, 197 cricket::Session* session, 198 cricket::Session::State state); 199 void OnStatusUpdate(const buzz::PresenceStatus& status); 200 void OnMucInviteReceived(const buzz::Jid& inviter, const buzz::Jid& room, 201 const std::vector<buzz::AvailableMediaEntry>& avail); 202 void OnMucJoined(const buzz::Jid& endpoint); 203 void OnMucStatusUpdate(const buzz::Jid& jid, 204 const buzz::MucPresenceStatus& status); 205 void OnMucLeft(const buzz::Jid& endpoint, int error); 206 void OnPresenterStateChange(const std::string& nick, 207 bool was_presenting, bool is_presenting); 208 void OnAudioMuteStateChange(const std::string& nick, 209 bool was_muted, bool is_muted); 210 void OnRecordingStateChange(const std::string& nick, 211 bool was_recording, bool is_recording); 212 void OnRemoteMuted(const std::string& mutee_nick, 213 const std::string& muter_nick, 214 bool should_mute_locally); 215 void OnMediaBlocked(const std::string& blockee_nick, 216 const std::string& blocker_nick); 217 void OnHangoutRequestError(const std::string& node, 218 const buzz::XmlElement* stanza); 219 void OnHangoutPublishAudioMuteError(const std::string& task_id, 220 const buzz::XmlElement* stanza); 221 void OnHangoutPublishPresenterError(const std::string& task_id, 222 const buzz::XmlElement* stanza); 223 void OnHangoutPublishRecordingError(const std::string& task_id, 224 const buzz::XmlElement* stanza); 225 void OnHangoutRemoteMuteError(const std::string& task_id, 226 const std::string& mutee_nick, 227 const buzz::XmlElement* stanza); 228 void OnDevicesChange(); 229 void OnMediaStreamsUpdate(cricket::Call* call, 230 cricket::Session* session, 231 const cricket::MediaStreams& added, 232 const cricket::MediaStreams& removed); 233 void OnSpeakerChanged(cricket::Call* call, 234 cricket::Session* session, 235 const cricket::StreamParams& speaker_stream); 236 void OnRoomLookupResponse(buzz::MucRoomLookupTask* task, 237 const buzz::MucRoomInfo& room_info); 238 void OnRoomLookupError(buzz::IqTask* task, 239 const buzz::XmlElement* stanza); 240 void OnRoomConfigResult(buzz::MucRoomConfigTask* task); 241 void OnRoomConfigError(buzz::IqTask* task, 242 const buzz::XmlElement* stanza); 243 void OnDataReceived(cricket::Call*, 244 const cricket::ReceiveDataParams& params, 245 const rtc::Buffer& payload); 246 buzz::Jid GenerateRandomMucJid(); 247 248 // Depending on |enable|, render (or don't) all the streams in |session|. 249 void RenderAllStreams(cricket::Call* call, 250 cricket::Session* session, 251 bool enable); 252 253 // Depending on |enable|, render (or don't) the streams in |video_streams|. 254 void RenderStreams(cricket::Call* call, 255 cricket::Session* session, 256 const std::vector<cricket::StreamParams>& video_streams, 257 bool enable); 258 259 // Depending on |enable|, render (or don't) the supplied |stream|. 260 void RenderStream(cricket::Call* call, 261 cricket::Session* session, 262 const cricket::StreamParams& stream, 263 bool enable); 264 void AddStaticRenderedView( 265 cricket::Session* session, 266 uint32 ssrc, int width, int height, int framerate, 267 int x_offset, int y_offset); 268 bool RemoveStaticRenderedView(uint32 ssrc); 269 void RemoveCallsStaticRenderedViews(cricket::Call* call); 270 void SendViewRequest(cricket::Call* call, cricket::Session* session); 271 bool SelectFirstDesktopScreencastId(cricket::ScreencastId* screencastid); 272 273 static const std::string strerror(buzz::XmppEngine::Error err); 274 275 void PrintRoster(); 276 bool FindJid(const std::string& name, 277 buzz::Jid* found_jid, 278 cricket::CallOptions* options); 279 bool PlaceCall(const std::string& name, cricket::CallOptions options); 280 bool InitiateAdditionalSession(const std::string& name, 281 cricket::CallOptions options); 282 void TerminateAndRemoveSession(cricket::Call* call, const std::string& id); 283 void PrintCalls(); 284 void SwitchToCall(uint32 call_id); 285 void Accept(const cricket::CallOptions& options); 286 void Reject(); 287 void Quit(); 288 289 void GetDevices(); 290 void PrintDevices(const std::vector<std::string>& names); 291 292 void SetVolume(const std::string& level); 293 GetFirstSession()294 cricket::Session* GetFirstSession() { return sessions_[call_->id()][0]; } AddSession(cricket::Session * session)295 void AddSession(cricket::Session* session) { 296 sessions_[call_->id()].push_back(session); 297 } 298 299 void PrintStats() const; 300 void SetupAcceptedCall(); 301 302 typedef std::map<std::string, RosterItem> RosterMap; 303 304 Console *console_; 305 buzz::XmppClient* xmpp_client_; 306 rtc::Thread* worker_thread_; 307 rtc::NetworkManager* network_manager_; 308 cricket::PortAllocator* port_allocator_; 309 cricket::SessionManager* session_manager_; 310 cricket::SessionManagerTask* session_manager_task_; 311 cricket::MediaEngineInterface* media_engine_; 312 cricket::DataEngineInterface* data_engine_; 313 cricket::MediaSessionClient* media_client_; 314 MucMap mucs_; 315 316 cricket::Call* call_; 317 typedef std::map<uint32, std::vector<cricket::Session *> > SessionMap; 318 SessionMap sessions_; 319 320 buzz::HangoutPubSubClient* hangout_pubsub_client_; 321 bool incoming_call_; 322 bool auto_accept_; 323 std::string pmuc_domain_; 324 bool render_; 325 cricket::DataChannelType data_channel_type_; 326 bool multisession_enabled_; 327 cricket::VideoRenderer* local_renderer_; 328 StaticRenderedViews static_rendered_views_; 329 uint32 static_views_accumulated_count_; 330 uint32 screencast_ssrc_; 331 332 buzz::PresenceStatus my_status_; 333 buzz::PresencePushTask* presence_push_; 334 buzz::PresenceOutTask* presence_out_; 335 buzz::MucInviteRecvTask* muc_invite_recv_; 336 buzz::MucInviteSendTask* muc_invite_send_; 337 buzz::FriendInviteSendTask* friend_invite_send_; 338 RosterMap* roster_; 339 uint32 portallocator_flags_; 340 341 bool allow_local_ips_; 342 cricket::SignalingProtocol signaling_protocol_; 343 cricket::TransportProtocol transport_protocol_; 344 cricket::SecurePolicy sdes_policy_; 345 cricket::SecurePolicy dtls_policy_; 346 rtc::scoped_ptr<rtc::SSLIdentity> ssl_identity_; 347 std::string last_sent_to_; 348 349 bool show_roster_messages_; 350 }; 351 352 #endif // TALK_EXAMPLES_CALL_CALLCLIENT_H_ 353