// Copyright 2013 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_CLIENT_CHROMOTING_SESSION_H_ #define REMOTING_CLIENT_CHROMOTING_SESSION_H_ #include #include #include "base/memory/raw_ptr.h" #include "base/memory/ref_counted.h" #include "base/memory/weak_ptr.h" #include "remoting/client/chromoting_client.h" #include "remoting/client/client_context.h" #include "remoting/client/client_telemetry_logger.h" #include "remoting/client/client_user_interface.h" #include "remoting/client/connect_to_host_info.h" #include "remoting/client/feedback_data.h" #include "remoting/client/input/client_input_injector.h" #include "remoting/proto/control.pb.h" #include "remoting/proto/event.pb.h" #include "remoting/protocol/clipboard_stub.h" #include "remoting/protocol/cursor_shape_stub.h" #include "remoting/signaling/ftl_device_id_provider.h" #include "remoting/signaling/signal_strategy.h" namespace remoting { namespace protocol { class AudioStub; class VideoRenderer; } // namespace protocol class ChromotingClientRuntime; // ChromotingSession is scoped to the session. // Construction, destruction, and all method calls must occur on the UI Thread. // All callbacks will be posted to the UI Thread. // A ChromotingSession instance can be used for at most one connection attempt. // If you need to reconnect an ended session, you will need to create a new // session instance. class ChromotingSession : public ClientInputInjector { public: // All methods of the delegate are called on the UI thread. Callbacks should // also be invoked on the UI thread too. class Delegate { public: virtual ~Delegate() {} // Notifies the delegate of the current connection status. The delegate // should destroy the ChromotingSession instance when the connection state // is an end state. virtual void OnConnectionState(protocol::ConnectionToHost::State state, protocol::ErrorCode error) = 0; // Saves new pairing credentials to permanent storage. virtual void CommitPairingCredentials(const std::string& host, const std::string& id, const std::string& secret) = 0; // Notifies the user interface that the user needs to enter a PIN. The // current authentication attempt is put on hold until |callback| is // invoked. virtual void FetchSecret( bool pairing_supported, const protocol::SecretFetchedCallback& secret_fetched_callback) = 0; // Pops up a third party login page to fetch token required for // authentication. virtual void FetchThirdPartyToken( const std::string& token_url, const std::string& client_id, const std::string& scopes, const protocol::ThirdPartyTokenFetchedCallback& token_fetched_callback) = 0; // Pass on the set of negotiated capabilities to the client. virtual void SetCapabilities(const std::string& capabilities) = 0; // Passes on the deconstructed ExtensionMessage to the client to handle // appropriately. virtual void HandleExtensionMessage(const std::string& type, const std::string& message) = 0; }; using GetFeedbackDataCallback = base::OnceCallback)>; // Initiates a connection with the specified host. This will start the // connection immediately. ChromotingSession(base::WeakPtr delegate, std::unique_ptr cursor_stub, std::unique_ptr video_renderer, std::unique_ptr audio_player, const ConnectToHostInfo& info); ChromotingSession(const ChromotingSession&) = delete; ChromotingSession& operator=(const ChromotingSession&) = delete; ~ChromotingSession() override; // Gets the current feedback data and returns it to the callback on the // UI thread. void GetFeedbackData(GetFeedbackDataCallback callback) const; // Requests pairing between the host and client for PIN-less authentication. void RequestPairing(const std::string& device_name); // Moves the host's cursor to the specified coordinates, optionally with some // mouse button depressed. If |button| is BUTTON_UNDEFINED, no click is made. void SendMouseEvent(int x, int y, protocol::MouseEvent_MouseButton button, bool button_down); void SendMouseWheelEvent(int delta_x, int delta_y); // ClientInputInjector implementation. bool SendKeyEvent(int scan_code, int key_code, bool key_down) override; void SendTextEvent(const std::string& text) override; // Sends the provided touch event payload to the host. void SendTouchEvent(const protocol::TouchEvent& touch_event); void SendClientResolution(int dips_width, int dips_height, float scale); // Enables or disables the video channel. void EnableVideoChannel(bool enable); void SendClientMessage(const std::string& type, const std::string& data); private: class Core; template void RunCoreTaskOnNetworkThread(const base::Location& from_here, Functor&& core_functor, Args&&... args); // Used to obtain task runner references. const raw_ptr runtime_; // Created when the session is connected, then used, and destroyed on the // network thread when the instance is destroyed. std::unique_ptr core_; }; } // namespace remoting #endif // REMOTING_CLIENT_CHROMOTING_SESSION_H_