1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef REMOTING_CLIENT_CHROMOTING_JNI_INSTANCE_H_ 6 #define REMOTING_CLIENT_CHROMOTING_JNI_INSTANCE_H_ 7 8 #include <string> 9 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/message_loop/message_loop.h" 14 #include "remoting/client/chromoting_client.h" 15 #include "remoting/client/client_config.h" 16 #include "remoting/client/client_context.h" 17 #include "remoting/client/client_user_interface.h" 18 #include "remoting/client/frame_consumer_proxy.h" 19 #include "remoting/client/jni/jni_frame_consumer.h" 20 #include "remoting/jingle_glue/xmpp_signal_strategy.h" 21 #include "remoting/protocol/clipboard_stub.h" 22 #include "remoting/protocol/connection_to_host.h" 23 #include "remoting/protocol/cursor_shape_stub.h" 24 25 namespace remoting { 26 27 namespace protocol { 28 class ClipboardEvent; 29 class CursorShapeInfo; 30 } // namespace protocol 31 32 // ClientUserInterface that indirectly makes and receives JNI calls. 33 class ChromotingJniInstance 34 : public ClientUserInterface, 35 public protocol::ClipboardStub, 36 public protocol::CursorShapeStub, 37 public base::RefCountedThreadSafe<ChromotingJniInstance> { 38 public: 39 // Initiates a connection with the specified host. Call from the UI thread. 40 // The instance does not take ownership of |jni_runtime|. To connect with an 41 // unpaired host, pass in |pairing_id| and |pairing_secret| as empty strings. 42 ChromotingJniInstance(ChromotingJniRuntime* jni_runtime, 43 const char* username, 44 const char* auth_token, 45 const char* host_jid, 46 const char* host_id, 47 const char* host_pubkey, 48 const char* pairing_id, 49 const char* pairing_secret); 50 51 // Terminates the current connection (if it hasn't already failed) and cleans 52 // up. Must be called before destruction. 53 void Cleanup(); 54 55 // Provides the user's PIN and resumes the host authentication attempt. Call 56 // on the UI thread once the user has finished entering this PIN into the UI, 57 // but only after the UI has been asked to provide a PIN (via FetchSecret()). 58 void ProvideSecret(const std::string& pin, bool create_pair); 59 60 // Schedules a redraw on the display thread. May be called from any thread. 61 void RedrawDesktop(); 62 63 // Moves the host's cursor to the specified coordinates, optionally with some 64 // mouse button depressed. If |button| is BUTTON_UNDEFINED, no click is made. 65 void PerformMouseAction(int x, int y, 66 protocol::MouseEvent_MouseButton button, 67 bool button_down); 68 69 void PerformMouseWheelDeltaAction(int delta_x, int delta_y); 70 71 // Sends the provided keyboard scan code to the host. 72 void PerformKeyboardAction(int key_code, bool key_down); 73 74 // Records paint time for statistics logging, if enabled. May be called from 75 // any thread. 76 void RecordPaintTime(int64 paint_time_ms); 77 78 // ClientUserInterface implementation. 79 virtual void OnConnectionState( 80 protocol::ConnectionToHost::State state, 81 protocol::ErrorCode error) OVERRIDE; 82 virtual void OnConnectionReady(bool ready) OVERRIDE; 83 virtual void SetCapabilities(const std::string& capabilities) OVERRIDE; 84 virtual void SetPairingResponse( 85 const protocol::PairingResponse& response) OVERRIDE; 86 virtual void DeliverHostMessage( 87 const protocol::ExtensionMessage& message) OVERRIDE; 88 virtual protocol::ClipboardStub* GetClipboardStub() OVERRIDE; 89 virtual protocol::CursorShapeStub* GetCursorShapeStub() OVERRIDE; 90 virtual scoped_ptr<protocol::ThirdPartyClientAuthenticator::TokenFetcher> 91 GetTokenFetcher(const std::string& host_public_key) OVERRIDE; 92 93 // CursorShapeStub implementation. 94 virtual void InjectClipboardEvent( 95 const protocol::ClipboardEvent& event) OVERRIDE; 96 97 // ClipboardStub implementation. 98 virtual void SetCursorShape(const protocol::CursorShapeInfo& shape) OVERRIDE; 99 100 private: 101 // This object is ref-counted, so it cleans itself up. 102 virtual ~ChromotingJniInstance(); 103 104 void ConnectToHostOnDisplayThread(); 105 void ConnectToHostOnNetworkThread(); 106 void DisconnectFromHostOnNetworkThread(); 107 108 // Notifies the user interface that the user needs to enter a PIN. The 109 // current authentication attempt is put on hold until |callback| is invoked. 110 // May be called on any thread. 111 void FetchSecret(bool pairable, 112 const protocol::SecretFetchedCallback& callback); 113 114 // Enables or disables periodic logging of performance statistics. Called on 115 // the network thread. 116 void EnableStatsLogging(bool enabled); 117 118 // If logging is enabled, logs the current connection statistics, and 119 // triggers another call to this function after the logging time interval. 120 // Called on the network thread. 121 void LogPerfStats(); 122 123 // Used to obtain task runner references and make calls to Java methods. 124 ChromotingJniRuntime* jni_runtime_; 125 126 // ID of the host we are connecting to. 127 std::string host_id_; 128 129 // This group of variables is to be used on the display thread. 130 scoped_refptr<FrameConsumerProxy> frame_consumer_; 131 scoped_ptr<JniFrameConsumer> view_; 132 scoped_ptr<base::WeakPtrFactory<JniFrameConsumer> > view_weak_factory_; 133 134 // This group of variables is to be used on the network thread. 135 ClientConfig client_config_; 136 scoped_ptr<ClientContext> client_context_; 137 scoped_ptr<protocol::ConnectionToHost> connection_; 138 scoped_ptr<ChromotingClient> client_; 139 XmppSignalStrategy::XmppServerConfig xmpp_config_; 140 scoped_ptr<XmppSignalStrategy> signaling_; // Must outlive client_ 141 142 // Pass this the user's PIN once we have it. To be assigned and accessed on 143 // the UI thread, but must be posted to the network thread to call it. 144 protocol::SecretFetchedCallback pin_callback_; 145 146 // Indicates whether to establish a new pairing with this host. This is 147 // modified in ProvideSecret(), but thereafter to be used only from the 148 // network thread. (This is safe because ProvideSecret() is invoked at most 149 // once per run, and always before any reference to this flag.) 150 bool create_pairing_; 151 152 // If this is true, performance statistics will be periodically written to 153 // the Android log. Used on the network thread. 154 bool stats_logging_enabled_; 155 156 friend class base::RefCountedThreadSafe<ChromotingJniInstance>; 157 158 DISALLOW_COPY_AND_ASSIGN(ChromotingJniInstance); 159 }; 160 161 } // namespace remoting 162 163 #endif 164