Refactor Chromoting JNI code to use jni/Client (Java changes only).

remoting/android/java/src/org/chromium/chromoting/DesktopView.java

 // 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.
 
 package org.chromium.chromoting;
 
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Point;
 import android.graphics.RadialGradient;
 import android.graphics.Rect;
 import android.graphics.Shader;
 import android.os.Looper;
 import android.os.SystemClock;
 import android.text.InputType;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputConnection;
 import android.view.inputmethod.InputMethodManager;
 
 import org.chromium.base.Log;
-import org.chromium.chromoting.jni.JniInterface;
+import org.chromium.chromoting.jni.Client;
 
 /**
  * The user interface for viewing and interacting with a specific remote host.
  * It provides a canvas onto which the video feed is rendered, handles
  * multitouch pan and zoom gestures, and collects and forwards input events.
  */
 /** GUI element that holds the drawing canvas. */
 public class DesktopView extends SurfaceView implements DesktopViewInterface,
         SurfaceHolder.Callback {
     /** Used to define the animation feedback shown when a user touches the screen. */
     public enum InputFeedbackType { NONE, SMALL_ANIMATION, LARGE_ANIMATION }
 
     private static final String TAG = "Chromoting";
 
     private final RenderData mRenderData;
     private final TouchInputHandlerInterface mInputHandler;
 
     /** The parent Desktop activity. */
     private Desktop mDesktop;
 
+    /** The Client connection, used to inject input and fetch the video frames. */
+    private Client mClient;
+
+
     // Flag to prevent multiple repaint requests from being backed up. Requests for repainting will
     // be dropped if this is already set to true. This is used by the main thread and the painting
     // thread, so the access should be synchronized on |mRenderData|.
     private boolean mRepaintPending;
 
     // Flag used to ensure that the SurfaceView is only painted between calls to surfaceCreated()
     // and surfaceDestroyed(). Accessed on main thread and display thread, so this should be
     // synchronized on |mRenderData|.
     private boolean mSurfaceCreated = false;
 
@@ skipping 113 matching lines @@
 
         mRepaintPending = false;
 
         getHolder().addCallback(this);
     }
 
     public void setDesktop(Desktop desktop) {
         mDesktop = desktop;
     }
 
+    public void setClient(Client client) {
+        mClient = client;
+    }
+
     /** See {@link TouchInputHandler#onSoftInputMethodVisibilityChanged} for API details. */
     public void onSoftInputMethodVisibilityChanged(boolean inputMethodVisible, Rect bounds) {
         mInputHandler.onSoftInputMethodVisibilityChanged(inputMethodVisible, bounds);
     }
 
     /** Request repainting of the desktop view. */
     void requestRepaint() {
         synchronized (mRenderData) {
             if (mRepaintPending) {
                 return;
             }
             mRepaintPending = true;
         }
-        JniInterface.redrawGraphics();
+        mClient.redrawGraphics();
     }
 
     /**
      * Redraws the canvas. This should be done on a non-UI thread or it could
      * cause the UI to lag. Specifically, it is currently invoked on the native
      * graphics thread using a JNI.
      */
     public void paint() {
         long startTimeMs = SystemClock.uptimeMillis();
 
         if (Looper.myLooper() == Looper.getMainLooper()) {
             Log.w(TAG, "Canvas being redrawn on UI thread");
         }
 
-        Bitmap image = JniInterface.getVideoFrame();
+        Bitmap image = mClient.getVideoFrame();
         if (image == null) {
             // This can happen if the client is connected, but a complete video frame has not yet
             // been decoded.
             return;
         }
 
         int width = image.getWidth();
         int height = image.getHeight();
         boolean sizeChanged = false;
         synchronized (mRenderData) {
             if (mRenderData.imageWidth != width || mRenderData.imageHeight != height) {
                 // TODO(lambroslambrou): Move this code into a sizeChanged() callback, to be
-                // triggered from JniInterface (on the display thread) when the remote screen size
+                // triggered from native code (on the display thread) when the remote screen size
                 // changes.
                 mRenderData.imageWidth = width;
                 mRenderData.imageHeight = height;
                 sizeChanged = true;
             }
         }
         if (sizeChanged) {
             mInputHandler.onHostSizeChanged(width, height);
         }
 
@@ skipping 25 matching lines @@
         boolean feedbackAnimationRunning = mFeedbackAnimator.isAnimationRunning();
         if (feedbackAnimationRunning) {
             float scaleFactor;
             synchronized (mRenderData) {
                 scaleFactor = mRenderData.transform.mapRadius(1);
             }
             mFeedbackAnimator.render(canvas, cursorPosition.x, cursorPosition.y, scaleFactor);
         }
 
         if (drawCursor) {
-            Bitmap cursorBitmap = JniInterface.getCursorBitmap();
+            Bitmap cursorBitmap = mClient.getCursorBitmap();
             if (cursorBitmap != null) {
-                Point hotspot = JniInterface.getCursorHotspot();
+                Point hotspot = mClient.getCursorHotspot();
                 canvas.drawBitmap(cursorBitmap, cursorPosition.x - hotspot.x,
                         cursorPosition.y - hotspot.y, new Paint());
             }
         }
 
         getHolder().unlockCanvasAndPost(canvas);
 
         synchronized (mAnimationLock) {
             if (mInputAnimationRunning || feedbackAnimationRunning) {
                 getHandler().postAtTime(new Runnable() {
@@ skipping 30 matching lines @@
             mRenderData.screenWidth = width;
             mRenderData.screenHeight = height;
         }
 
         attachRedrawCallback();
         mInputHandler.onClientSizeChanged(width, height);
         requestRepaint();
     }
 
     public void attachRedrawCallback() {
-        JniInterface.provideRedrawCallback(new Runnable() {
+        mClient.provideRedrawCallback(new Runnable() {
             @Override
             public void run() {
                 paint();
             }
         });
     }
 
     /** Called when the canvas is first created. */
     @Override
     public void surfaceCreated(SurfaceHolder holder) {
@@ skipping 75 matching lines @@
     /** Updates the current InputStrategy used by the TouchInputHandler. */
     public void changeInputMode(
             Desktop.InputMode inputMode, CapabilityManager.HostCapability hostTouchCapability) {
         // We need both input mode and host input capabilities to select the input strategy.
         if (!inputMode.isSet() || !hostTouchCapability.isSet()) {
             return;
         }
 
         switch (inputMode) {
             case TRACKPAD:
-                mInputHandler.setInputStrategy(new TrackpadInputStrategy(mRenderData));
+                mInputHandler.setInputStrategy(new TrackpadInputStrategy(mRenderData, mClient));
                 break;
 
             case TOUCH:
                 if (hostTouchCapability.isSupported()) {
-                    mInputHandler.setInputStrategy(new TouchInputStrategy(mRenderData));
+                    mInputHandler.setInputStrategy(new TouchInputStrategy(mRenderData, mClient));
                 } else {
                     mInputHandler.setInputStrategy(
-                            new SimulatedTouchInputStrategy(mRenderData, getContext()));
+                            new SimulatedTouchInputStrategy(mRenderData, mClient, getContext()));
                 }
                 break;
 
             default:
                 // Unreachable, but required by Google Java style and findbugs.
                 assert false : "Unreached";
         }
 
         // Ensure the cursor state is updated appropriately.
         requestRepaint();
     }
 }