Enable Android support for Chromoting PINless (paired) authentication

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.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.EditText;
+import android.widget.CheckBox;
 import android.widget.TextView;
 import android.widget.Toast;
 
 import org.chromium.chromoting.R;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 /**
  * Initializes the Chromium remoting library, and provides JNI calls into it.
@@ skipping 56 matching lines @@
             String hostJid, String hostId, String hostPubkey, Runnable successCallback) {
         synchronized(JniInterface.class) {
             if (!sLoaded) return;
 
             if (sConnected) {
                 disconnectFromHost();
             }
         }
 
         sSuccessCallback = successCallback;
-        connectNative(username, authToken, hostJid, hostId, hostPubkey);
+        SharedPreferences prefs = sContext.getPreferences(Activity.MODE_PRIVATE);
+        connectNative(username, authToken, hostJid, hostId, hostPubkey,
+                prefs.getString(hostId + "_id", ""), prefs.getString(hostId + "_secret", ""));
         sConnected = true;
     }
 
     /** Severs the connection and cleans up. */
     public static void disconnectFromHost() {
         synchronized(JniInterface.class) {
             if (!sLoaded || !sConnected) return;
 
             if (sProgressIndicator != null) {
                 sProgressIndicator.dismiss();
                 sProgressIndicator = null;
             }
         }
 
         disconnectNative();
         sSuccessCallback = null;
         sConnected = false;
     }
 
     /** Performs the native portion of the connection. */
-    private static native void connectNative(
-            String username, String authToken, String hostJid, String hostId, String hostPubkey);
+    private static native void connectNative(String username, String authToken, String hostJid,
+            String hostId, String hostPubkey, String pairId, String pairSecret);
 
     /** Performs the native portion of the cleanup. */
     private static native void disconnectNative();
 
     /*
      * Entry points *from* the native code.
      */
     /** Callback to signal whenever we need to redraw. */
     private static Runnable sRedrawCallback = null;
 
@@ skipping 53 matching lines @@
         }
     }
 
     /** Prompts the user to enter a PIN. */
     private static void displayAuthenticationPrompt() {
         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 EditText pinEntry = new EditText(sContext);
-        pinEntry.setInputType(
-                InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_PASSWORD);
-        pinEntry.setImeOptions(EditorInfo.IME_ACTION_DONE);
+        final View pinEntry = sContext.getLayoutInflater().inflate(R.layout.pin_dialog, null);
         pinPrompt.setView(pinEntry);
 
         pinPrompt.setPositiveButton(
                 R.string.pin_entry_connect, new DialogInterface.OnClickListener() {
                     @Override
                     public void onClick(DialogInterface dialog, int which) {
                         Log.i("jniiface", "User provided a PIN code");
-                        authenticationResponse(String.valueOf(pinEntry.getText()));
+                        authenticationResponse(String.valueOf(
+                                ((TextView)
+                                        pinEntry.findViewById(R.id.pin_dialog_text)).getText()),
+                                ((CheckBox)
+                                        pinEntry.findViewById(R.id.pin_dialog_check)).isChecked());
                     }
                 });
 
         pinPrompt.setNegativeButton(
                 R.string.pin_entry_cancel, new DialogInterface.OnClickListener() {
                     @Override
                     public void onClick(DialogInterface dialog, int which) {
                         Log.i("jniiface", "User canceled pin entry prompt");
                         Toast.makeText(sContext,
                                 sContext.getString(R.string.msg_pin_canceled),
                                 Toast.LENGTH_LONG).show();
                         disconnectFromHost();
                     }
                 });
 
         final AlertDialog pinDialog = pinPrompt.create();
 
-        pinEntry.setOnEditorActionListener(
+        ((TextView)pinEntry.findViewById(R.id.pin_dialog_text)).setOnEditorActionListener(
                 new TextView.OnEditorActionListener() {
                     @Override
                     public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
                         // The user pressed enter on the keypad (equivalent to the connect button).
                         pinDialog.getButton(AlertDialog.BUTTON_POSITIVE).performClick();
                         pinDialog.dismiss();
                         return true;
                     }
                 });
 
         pinDialog.setOnCancelListener(
                 new DialogInterface.OnCancelListener() {
                     @Override
                     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. */
+    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() {
@@ skipping 44 matching lines @@
     /** Presses and releases the specified (nonnegative) key. */
     public static void keyboardAction(int keyCode, boolean keyDown) {
         if (!sConnected) {
             return;
         }
 
         keyboardActionNative(keyCode, keyDown);
     }
 
     /** Performs the native response to the user's PIN. */
-    private static native void authenticationResponse(String pin);
+    private static native void authenticationResponse(String pin, boolean createPair);
 
     /** 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);
 }