Home | History | Annotate | Download | only in jni 
      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