gecko/build/mobile/robocop/FennecNativeActions.java.in

#filter substitution
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Firefox Mobile Test Framework.
 *
 * The Initial Developer of the Original Code is Mozilla.
 * Portions created by the Initial Developer are Copyright (C) 2011
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 * Trevor Fairey <tnfairey@gmail.com>
 * David Burns <dburns@mozilla.com>
 * Joel Maher <joel.maher@gmail.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

package @ANDROID_PACKAGE_NAME@;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.List;

import java.lang.Class;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.Long;

import android.app.Activity;
import android.app.Instrumentation;
import android.util.Log;
import android.view.View;
import android.view.KeyEvent;

import java.util.concurrent.SynchronousQueue;

import org.json.*;

import com.jayway.android.robotium.solo.Solo;

public class FennecNativeActions implements Actions {
  // Map of IDs to element names.
  private Solo solo;
  private Instrumentation instr;

  // Objects for reflexive access of fennec classes.
  private ClassLoader classLoader;
  private Class gel;
  private Class ge;
  private Class gas;
  private Method registerGEL;
  private Method unregisterGEL;
  private Method sendGE;


  // If waiting for an event.
  private SynchronousQueue waitqueue = new SynchronousQueue<Boolean>();

  public FennecNativeActions(Activity activity, Solo robocop, Instrumentation instrumentation){
    this.solo = robocop;
    this.instr = instrumentation;
    // Set up reflexive access of java classes and methods.
    try {
      classLoader = activity.getClassLoader();
      gel = classLoader.loadClass("org.mozilla.gecko.GeckoEventListener");
      ge = classLoader.loadClass("org.mozilla.gecko.GeckoEvent");
      gas = classLoader.loadClass("org.mozilla.gecko.GeckoAppShell");
      Class [] parameters = new Class[2];
      parameters[0] = String.class;
      parameters[1] = gel;
      registerGEL = gas.getMethod("registerGeckoEventListener", parameters);
      unregisterGEL = gas.getMethod("unregisterGeckoEventListener", parameters);
      parameters = new Class[1];
      parameters[0] = ge;
      sendGE = gas.getMethod("sendEventToGecko", parameters);
     } catch (ClassNotFoundException e) {
       e.printStackTrace();
     } catch (SecurityException e) {
       e.printStackTrace();
     } catch (NoSuchMethodException e) {
       e.printStackTrace();
     } catch (IllegalArgumentException e) {
       e.printStackTrace();
     }
  }

  class wakeInvocationHandler implements InvocationHandler {
    public wakeInvocationHandler(){};
    public Object invoke(Object proxy, Method method, Object[] args) {
      String methodName = method.getName();
      //Depending on the method, return a completely different type.
      if(methodName.equals("toString")) {
        return "wakeInvocationHandler";
      }
      if(methodName.equals("equals")) {
        return this == args[0];
      }
      if(methodName.equals("clone")) {
        return this;
      }
      if(methodName.equals("hashCode")) {
        return 314;
      }
      Log.i("Robocop", "Waking up on "+methodName);
      waitqueue.offer(new Boolean(true));
      return null;
    }
  }
  
  public void waitForGeckoEvent(String geckoEvent) {
    Log.i("Robocop", "waiting for "+geckoEvent);
    try {
      Class [] interfaces = new Class[1];
      interfaces[0] = gel;
      Object[] finalParams = new Object[2];
      finalParams[0] = geckoEvent;
     
      wakeInvocationHandler wIH = new wakeInvocationHandler();
      Object proxy = Proxy.newProxyInstance(classLoader, interfaces, wIH);
      finalParams[1] = proxy;
      registerGEL.invoke(null, finalParams);
      
      waitqueue.take();
      unregisterGEL.invoke(null, finalParams);
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    } catch (InvocationTargetException e) {
      e.printStackTrace();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    Log.i("Robocop", "wait ends for: "+geckoEvent);
  }

  public void sendSpecialKey(SpecialKey button) {
    switch( button) {
      case DOWN:
        instr.sendCharacterSync(KeyEvent.KEYCODE_DPAD_DOWN);
        break;
      case UP:
        instr.sendCharacterSync(KeyEvent.KEYCODE_DPAD_UP);
        break;
      case LEFT:
        instr.sendCharacterSync(KeyEvent.KEYCODE_DPAD_LEFT);
        break;
      case RIGHT:
        instr.sendCharacterSync(KeyEvent.KEYCODE_DPAD_RIGHT);
        break;
      case ENTER:
        instr.sendCharacterSync(KeyEvent.KEYCODE_ENTER);
        break;
      default:
        break;
    }
  }

  @Override
  public void sendKeys(String input) {
    instr.sendStringSync(input);
  }


  public void drag(int startingX, int endingX, int startingY, int endingY) {
    solo.drag(startingX, endingX, startingY, endingY, 10);
  }
}