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

remoting/android/java/src/org/chromium/chromoting/cardboard/Cursor.java

 // Copyright 2015 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.cardboard;
 
 import static org.chromium.chromoting.cardboard.CardboardUtil.makeFloatBuffer;
 import static org.chromium.chromoting.cardboard.CardboardUtil.makeRectangularTextureBuffer;
 
 import android.graphics.Bitmap;
 import android.graphics.Point;
 import android.graphics.PointF;
 import android.opengl.GLES20;
 
 import org.chromium.chromoting.TouchInputHandler;
-import org.chromium.chromoting.jni.JniInterface;
+import org.chromium.chromoting.jni.Client;
 
 import java.nio.FloatBuffer;
 
 /**
  * Cardboard activity desktop cursor that is used to render the image of the mouse
  * cursor onto the desktop.
  */
 public class Cursor {
     private static final String VERTEX_SHADER =
             "uniform mat4 u_CombinedMatrix;"
@@ skipping 18 matching lines @@
 
     private static final int POSITION_COORDINATE_DATA_SIZE = 3;
     private static final int TEXTURE_COORDINATE_DATA_SIZE = 2;
 
     // Number of vertices passed to glDrawArrays().
     private static final int VERTICES_NUMBER = 6;
 
     // Threshold to determine whether to send the mouse move event.
     private static final float CURSOR_MOVE_THRESHOLD = 1.0f;
 
+    private final Client mClient;
+
     private FloatBuffer mPositionCoordinates;
 
     private int mVertexShaderHandle;
     private int mFragmentShaderHandle;
     private int mProgramHandle;
     private int mCombinedMatrixHandle;
     private int mTextureUniformHandle;
     private int mPositionHandle;
     private int mTextureDataHandle;
     private int mTextureCoordinateHandle;
 
     // Flag to indicate whether to reload the desktop texture.
     private boolean mReloadTexture;
 
     // Lock to allow multithreaded access to mReloadTexture.
     private final Object mReloadTextureLock = new Object();
 
     private Bitmap mCursorBitmap;
 
     // Half width and half height of the cursor.
     private PointF mHalfFrameSize;
 
     private PointF mCursorPosition;
 
-    public Cursor() {
+    public Cursor(Client client) {
+        mClient = client;
         mHalfFrameSize = new PointF(0.0f, 0.0f);
         mCursorPosition = new PointF(0.0f, 0.0f);
 
         mVertexShaderHandle =
                 ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, VERTEX_SHADER);
         mFragmentShaderHandle =
                 ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, FRAGMENT_SHADER);
         mProgramHandle = ShaderHelper.createAndLinkProgram(mVertexShaderHandle,
                 mFragmentShaderHandle, new String[] {"a_Position", "a_TexCoordinate",
                     "u_CombinedMatrix", "u_Texture"});
@@ skipping 23 matching lines @@
     private boolean moveCursor(PointF position) {
         return Math.abs(mCursorPosition.x - position.x) > CURSOR_MOVE_THRESHOLD
                 || Math.abs(mCursorPosition.y - position.y) > CURSOR_MOVE_THRESHOLD;
     }
 
     /**
      * Send the mouse move event to host when {@link moveCursor} returns true.
      */
     public void moveTo(PointF position) {
         if (moveCursor(position)) {
-            JniInterface.sendMouseEvent((int) position.x, (int) position.y,
+            mClient.sendMouseEvent((int) position.x, (int) position.y,
                     TouchInputHandler.BUTTON_UNDEFINED, false);
         }
         mCursorPosition = position;
     }
 
     /**
      * Link the texture data for cursor if {@link mReloadTexture} is true.
      * Invoked from {@link com.google.vrtoolkit.cardboard.CardboardView.StereoRenderer.onNewFrame}
      */
     public void maybeLoadTexture(Desktop desktop) {
         synchronized (mReloadTextureLock) {
             if (!mReloadTexture || !desktop.hasVideoFrame()) {
                 return;
             }
         }
 
-        Bitmap cursorBitmap = JniInterface.getCursorBitmap();
+        Bitmap cursorBitmap = mClient.getCursorBitmap();
 
         if (cursorBitmap == mCursorBitmap) {
             // Case when cursor image has not changed.
             synchronized (mReloadTextureLock) {
                 mReloadTexture = false;
             }
             return;
         }
 
         mCursorBitmap = cursorBitmap;
-        updatePosition(desktop, mCursorBitmap, JniInterface.getCursorHotspot());
+        updatePosition(desktop, mCursorBitmap, mClient.getCursorHotspot());
 
         TextureHelper.linkTexture(mTextureDataHandle, cursorBitmap);
 
         synchronized (mReloadTextureLock) {
             mReloadTexture = false;
         }
     }
 
     public boolean hasImageFrame() {
         return mCursorBitmap != null;
@@ skipping 71 matching lines @@
 
     /*
      * Clean cursor related opengl data.
      */
     public void cleanup() {
         GLES20.glDeleteShader(mVertexShaderHandle);
         GLES20.glDeleteShader(mFragmentShaderHandle);
         GLES20.glDeleteTextures(1, new int[] {mTextureDataHandle}, 0);
     }
 }