// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_ #define REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_ #include <set> #include <string> #include "base/callback_forward.h" #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" #include "base/threading/non_thread_safe.h" #include "remoting/jingle_glue/signal_strategy.h" #include "remoting/proto/internal.pb.h" #include "remoting/protocol/clipboard_filter.h" #include "remoting/protocol/errors.h" #include "remoting/protocol/input_filter.h" #include "remoting/protocol/message_reader.h" #include "remoting/protocol/session.h" #include "remoting/protocol/session_manager.h" namespace pp { class Instance; } // namespace pp namespace remoting { class XmppProxy; class VideoPacket; namespace protocol { class AudioReader; class AudioStub; class Authenticator; class ClientControlDispatcher; class ClientEventDispatcher; class ClientStub; class ClipboardStub; class HostStub; class InputStub; class SessionConfig; class TransportFactory; class VideoReader; class VideoStub; class ConnectionToHost : public SignalStrategy::Listener, public SessionManager::Listener, public Session::EventHandler, public base::NonThreadSafe { public: // The UI implementations maintain corresponding definitions of this // enumeration in webapp/client_session.js and // android/java/res/values/strings.xml. The Android app also includes a // constant in android/java/src/org/chromium/chromoting/jni/JniInterface.java // that tracks the numeric value of the CONNECTED state. Be sure to update // these locations to match this one if you make any changes to the ordering. enum State { INITIALIZING, CONNECTING, AUTHENTICATED, CONNECTED, FAILED, CLOSED, }; class HostEventCallback { public: virtual ~HostEventCallback() {} // Called when state of the connection changes. virtual void OnConnectionState(State state, ErrorCode error) = 0; // Called when ready state of the connection changes. When |ready| // is set to false some data sent by the peers may be // delayed. This is used to indicate in the UI when connection is // temporarily broken. virtual void OnConnectionReady(bool ready) = 0; }; ConnectionToHost(bool allow_nat_traversal); virtual ~ConnectionToHost(); // |signal_strategy| must outlive connection. |audio_stub| may be // null, in which case audio will not be requested. virtual void Connect(SignalStrategy* signal_strategy, const std::string& host_jid, const std::string& host_public_key, scoped_ptr<TransportFactory> transport_factory, scoped_ptr<Authenticator> authenticator, HostEventCallback* event_callback, ClientStub* client_stub, ClipboardStub* clipboard_stub, VideoStub* video_stub, AudioStub* audio_stub); virtual const SessionConfig& config(); // Stubs for sending data to the host. virtual ClipboardStub* clipboard_stub(); virtual HostStub* host_stub(); virtual InputStub* input_stub(); // SignalStrategy::StatusObserver interface. virtual void OnSignalStrategyStateChange( SignalStrategy::State state) OVERRIDE; virtual bool OnSignalStrategyIncomingStanza( const buzz::XmlElement* stanza) OVERRIDE; // SessionManager::Listener interface. virtual void OnSessionManagerReady() OVERRIDE; virtual void OnIncomingSession( Session* session, SessionManager::IncomingSessionResponse* response) OVERRIDE; // Session::EventHandler interface. virtual void OnSessionStateChange(Session::State state) OVERRIDE; virtual void OnSessionRouteChange(const std::string& channel_name, const TransportRoute& route) OVERRIDE; virtual void OnSessionChannelReady(const std::string& channel_name, bool ready) OVERRIDE; // Return the current state of ConnectionToHost. State state() const; private: // Callbacks for channel initialization void OnChannelInitialized(bool successful); void NotifyIfChannelsReady(); void CloseOnError(ErrorCode error); // Stops writing in the channels. void CloseChannels(); void SetState(State state, ErrorCode error); bool allow_nat_traversal_; std::string host_jid_; std::string host_public_key_; scoped_ptr<Authenticator> authenticator_; HostEventCallback* event_callback_; // Stub for incoming messages. ClientStub* client_stub_; ClipboardStub* clipboard_stub_; VideoStub* video_stub_; AudioStub* audio_stub_; SignalStrategy* signal_strategy_; scoped_ptr<SessionManager> session_manager_; scoped_ptr<Session> session_; scoped_ptr<VideoReader> video_reader_; scoped_ptr<AudioReader> audio_reader_; scoped_ptr<ClientControlDispatcher> control_dispatcher_; scoped_ptr<ClientEventDispatcher> event_dispatcher_; ClipboardFilter clipboard_forwarder_; InputFilter event_forwarder_; // Internal state of the connection. State state_; ErrorCode error_; // List of channels that are not currently ready. std::set<std::string> not_ready_channels_; private: DISALLOW_COPY_AND_ASSIGN(ConnectionToHost); }; } // namespace protocol } // namespace remoting #endif // REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_