Use jni_generator in Chromoting Android client

remoting/android/java/src/org/chromium/chromoting/jni/JniInterface.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.jni;
 
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.SharedPreferences;
 import android.graphics.Bitmap;
 import android.graphics.Point;
 import android.os.Looper;
 import android.text.InputType;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.inputmethod.EditorInfo;
 import android.widget.CheckBox;
 import android.widget.TextView;
 import android.widget.Toast;
 
+import org.chromium.base.CalledByNative;
+import org.chromium.base.JNINamespace;
 import org.chromium.chromoting.R;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 /**
  * Initializes the Chromium remoting library, and provides JNI calls into it.
  * All interaction with the native code is centralized in this class.
  */
+@JNINamespace("remoting")
 public class JniInterface {
     /** The status code indicating successful connection. */
     private static final int SUCCESSFUL_CONNECTION = 3;
 
     /** The application context. */
     private static Activity sContext = null;
 
     /*
      * Library-loading state machine.
      */
     /** Whether we've already loaded the library. */
     private static boolean sLoaded = false;
 
     /**
      * To be called once from the main Activity. Any subsequent calls will update the application
      * context, but not reload the library. This is useful e.g. when the activity is closed and the
      * user later wants to return to the application.
      */
     public static void loadLibrary(Activity context) {
         sContext = context;
 
         synchronized(JniInterface.class) {
             if (sLoaded) return;
         }
 
         System.loadLibrary("remoting_client_jni");
+
+        Log.e("jni", "*** 1");
+
         loadNative(context);
         sLoaded = true;
     }
 
     /** Performs the native portion of the initialization. */
     private static native void loadNative(Context context);

[digit1, 2013/10/19 09:50:04]

Hint: You must call this function "nativeLoadNative()" for the JNI generator to
process it and generate a stub for it. The auot-generated
"jni/JniInteface_jni.h" will contain the following:

- A function named "RegisterNativesImpl(JNIEnv*)" which you must call explicitly
at JNI_OnLoad() time.
- An auto-generated stub that will call a function named "LoadNative()" that
must be defined in the source code that includes the header.

This patch is currently crashing because you never register a native method hook
for this 'loadNative()' in the current implementation.

Don't worry if you didn't get it on the first try, it means we must better
document this whole process, that's all :)

[Lambros, 2013/10/23 17:35:23]

Done.

 
     /*
      * API/OAuth2 keys access.
      */
     public static native String getApiKey();
     public static native String getClientId();
     public static native String getClientSecret();
 
     /*
      * Connection-initiating state machine.
@@ skipping 71 matching lines @@
     /** Lock to protect the frame bitmap reference. */
     private static final Object sFrameLock = new Object();
 
     /** Position of cursor hot-spot. */
     private static Point sCursorHotspot = new Point();
 
     /** Bitmap holding the cursor shape. */
     private static Bitmap sCursorBitmap = null;
 
     /** Reports whenever the connection status changes. */
+    @CalledByNative
     private static void reportConnectionStatus(int state, int error) {
         if (state < SUCCESSFUL_CONNECTION && error == 0) {
             // The connection is still being established, so we'll report the current progress.
             synchronized (JniInterface.class) {
                 if (sProgressIndicator == null) {
                     sProgressIndicator = ProgressDialog.show(sContext, sContext.
                             getString(R.string.progress_title), sContext.getResources().
                             getStringArray(R.array.protoc_states)[state], true, true,
                             new DialogInterface.OnCancelListener() {
                                 @Override
@@ skipping 27 matching lines @@
             } else {
                 Toast.makeText(sContext, sContext.getResources().getStringArray(
                         R.array.protoc_states)[state] + (error == 0 ? "" : ": " +
                         sContext.getResources().getStringArray(R.array.protoc_errors)[error]),
                         Toast.LENGTH_LONG).show();
             }
         }
     }
 
     /** Prompts the user to enter a PIN. */
+    @CalledByNative
     private static void displayAuthenticationPrompt(boolean pairingSupported) {
         AlertDialog.Builder pinPrompt = new AlertDialog.Builder(sContext);
         pinPrompt.setTitle(sContext.getString(R.string.pin_entry_title));
         pinPrompt.setMessage(sContext.getString(R.string.pin_entry_message));
         pinPrompt.setIcon(android.R.drawable.ic_lock_lock);
 
         final View pinEntry = sContext.getLayoutInflater().inflate(R.layout.pin_dialog, null);
         pinPrompt.setView(pinEntry);
 
         final TextView pinTextView = (TextView)pinEntry.findViewById(R.id.pin_dialog_text);
@@ skipping 45 matching lines @@
                     public void onCancel(DialogInterface dialog) {
                         // The user backed out of the dialog (equivalent to the cancel button).
                         pinDialog.getButton(AlertDialog.BUTTON_NEGATIVE).performClick();
                     }
                 });
 
         pinDialog.show();
     }
 
     /** Saves newly-received pairing credentials to permanent storage. */
+    @CalledByNative
     private static void commitPairingCredentials(String host, byte[] id, byte[] secret) {
         synchronized (sContext) {
             sContext.getPreferences(Activity.MODE_PRIVATE).edit().
                     putString(host + "_id", new String(id)).
                     putString(host + "_secret", new String(secret)).
                     apply();
         }
     }
 
     /**
      * Sets the redraw callback to the provided functor. Provide a value of null whenever the
      * window is no longer visible so that we don't continue to draw onto it.
      */
     public static void provideRedrawCallback(Runnable redrawCallback) {
         sRedrawCallback = redrawCallback;
     }
 
     /** Forces the native graphics thread to redraw to the canvas. */
     public static boolean redrawGraphics() {
         synchronized(JniInterface.class) {
             if (!sConnected || sRedrawCallback == null) return false;
         }
 
         scheduleRedrawNative();
         return true;
     }
 
     /** Performs the redrawing callback. This is a no-op if the window isn't visible. */
+    @CalledByNative
     private static void redrawGraphicsInternal() {
-        if (sRedrawCallback != null)
+        if (sRedrawCallback != null) {
             sRedrawCallback.run();
+        }
     }
 
     /**
      * Returns a bitmap of the latest video frame. Called on the native graphics thread when
      * DesktopView is repainted.
      */
     public static Bitmap getVideoFrame() {
         if (Looper.myLooper() == Looper.getMainLooper()) {
             Log.w("jniiface", "Canvas being redrawn on UI thread");
         }
 
         if (!sConnected) {
             return null;
         }
 
         synchronized (sFrameLock) {
             return sFrameBitmap;
         }
     }
 
     /**
-     * Sets a new video frame. Called from native code on the native graphics thread when a new
-     * frame is allocated.
+     * Sets a new video frame. Called on the native graphics thread when a new frame is allocated.
      */
+    @CalledByNative
     private static void setVideoFrame(Bitmap bitmap) {
         if (Looper.myLooper() == Looper.getMainLooper()) {
             Log.w("jniiface", "Video frame updated on UI thread");
         }
 
         synchronized (sFrameLock) {
             sFrameBitmap = bitmap;
         }
     }
 
     /**
      * Creates a new Bitmap to hold video frame pixels. Called by native code which stores a global
      * reference to the Bitmap and writes the decoded frame pixels to it.
      */
+    @CalledByNative
     private static Bitmap newBitmap(int width, int height) {
         return Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
     }
 
     /**
-     * Updates the cursor shape. This is called from native code on the graphics thread when
-     * receiving a new cursor shape from the host.
+     * Updates the cursor shape. This is called on the graphics thread when receiving a new cursor
+     * shape from the host.
      */
+    @CalledByNative
     public static void updateCursorShape(int width, int height, int hotspotX, int hotspotY,
                                          ByteBuffer buffer) {
         sCursorHotspot = new Point(hotspotX, hotspotY);
 
         int[] data = new int[width * height];
         buffer.order(ByteOrder.LITTLE_ENDIAN);
         buffer.asIntBuffer().get(data, 0, data.length);
         sCursorBitmap = Bitmap.createBitmap(data, width, height, Bitmap.Config.ARGB_8888);
     }
 
@@ skipping 20 matching lines @@
 
     /** Schedules a redraw on the native graphics thread. */
     private static native void scheduleRedrawNative();
 
     /** Passes mouse information to the native handling code. */
     private static native void mouseActionNative(int x, int y, int whichButton, boolean buttonDown);
 
     /** Passes key press information to the native handling code. */
     private static native void keyboardActionNative(int keyCode, boolean keyDown);
 }