mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
390 lines
12 KiB
Java
390 lines
12 KiB
Java
#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.nio.IntBuffer;
|
|
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.opengl.GLSurfaceView;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
|
|
import org.json.*;
|
|
|
|
import com.jayway.android.robotium.solo.Solo;
|
|
|
|
public class FennecNativeDriver implements Driver {
|
|
// Map of IDs to element names.
|
|
private HashMap locators = null;
|
|
private Activity activity;
|
|
private Solo solo;
|
|
|
|
// 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;
|
|
private Method _startFrameRecording;
|
|
private Method _stopFrameRecording;
|
|
private Method _startCheckerboardRecording;
|
|
private Method _stopCheckerboardRecording;
|
|
private Method _getPixels;
|
|
|
|
public FennecNativeDriver(Activity activity, Solo robocop){
|
|
this.activity = activity;
|
|
this.solo = robocop;
|
|
|
|
// Set up table of fennec_ids.
|
|
locators = convertTextToTable(getFile("/mnt/sdcard/fennec_ids.txt"));
|
|
|
|
// 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);
|
|
|
|
Class gfx = classLoader.loadClass("org.mozilla.gecko.gfx.PanningPerfAPI");
|
|
_startFrameRecording = gfx.getDeclaredMethod("startFrameTimeRecording");
|
|
_stopFrameRecording = gfx.getDeclaredMethod("stopFrameTimeRecording");
|
|
_startCheckerboardRecording = gfx.getDeclaredMethod("startCheckerboardRecording");
|
|
_stopCheckerboardRecording = gfx.getDeclaredMethod("stopCheckerboardRecording");
|
|
|
|
Class layerView = classLoader.loadClass("org.mozilla.gecko.gfx.LayerView");
|
|
_getPixels = layerView.getDeclaredMethod("getPixels");
|
|
} catch (ClassNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (SecurityException e) {
|
|
e.printStackTrace();
|
|
} catch (NoSuchMethodException e) {
|
|
e.printStackTrace();
|
|
} catch (IllegalArgumentException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
//Information on the location of the Gecko Frame.
|
|
private boolean geckoInfo = false;
|
|
private int geckoTop = 100;
|
|
private int geckoLeft = 0;
|
|
private int geckoHeight= 700;
|
|
private int geckoWidth = 1024;
|
|
|
|
private void getGeckoInfo() {
|
|
View geckoLayout = activity.findViewById(Integer.decode((String)locators.get("gecko_layout")));
|
|
if (geckoLayout != null) {
|
|
int[] pos = new int[2];
|
|
geckoLayout.getLocationOnScreen(pos);
|
|
geckoTop = pos[1];
|
|
geckoLeft = pos[0];
|
|
geckoWidth = geckoLayout.getWidth();
|
|
geckoHeight = geckoLayout.getHeight();
|
|
geckoInfo = true;
|
|
} else {
|
|
throw new RoboCopException("Unable to find view gecko_layout");
|
|
}
|
|
}
|
|
|
|
public int getGeckoTop() {
|
|
if(!geckoInfo) {
|
|
getGeckoInfo();
|
|
}
|
|
return geckoTop;
|
|
}
|
|
|
|
public int getGeckoLeft() {
|
|
if(!geckoInfo) {
|
|
getGeckoInfo();
|
|
}
|
|
return geckoLeft;
|
|
}
|
|
|
|
public int getGeckoHeight() {
|
|
if(!geckoInfo) {
|
|
getGeckoInfo();
|
|
}
|
|
return geckoHeight;
|
|
}
|
|
public int getGeckoWidth() {
|
|
if(!geckoInfo) {
|
|
getGeckoInfo();
|
|
}
|
|
return geckoWidth;
|
|
}
|
|
|
|
public Element findElement(Activity activity, String name) {
|
|
if (name == null)
|
|
throw new IllegalArgumentException("Can not findElements when passed a null");
|
|
if (locators.containsKey(name)){
|
|
return new FennecNativeElement(Integer.decode((String)locators.get(name)), activity, solo);
|
|
}
|
|
throw new RoboCopException("Element does not exist in the list");
|
|
}
|
|
|
|
public void startFrameRecording() {
|
|
try {
|
|
Object [] params = null;
|
|
_startFrameRecording.invoke(null, params);
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
} catch (InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public int stopFrameRecording() {
|
|
Class [] parameters = new Class[1];
|
|
parameters[0] = null;
|
|
List frames;
|
|
|
|
try {
|
|
Object [] params = null;
|
|
frames = (List)_stopFrameRecording.invoke(null, params);
|
|
Object [] framearray = frames.toArray();
|
|
Long last = new Long(0);
|
|
Long threshold = new Long(17);
|
|
int numDelays = 0;
|
|
for (int i=0; i < framearray.length; i++) {
|
|
Long val = (Long)framearray[i];
|
|
if ((val - last) > threshold) {
|
|
numDelays++;
|
|
}
|
|
last = val;
|
|
}
|
|
return numDelays;
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
} catch (InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public void startCheckerboardRecording() {
|
|
try {
|
|
Object [] params = null;
|
|
_startCheckerboardRecording.invoke(null, params);
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
} catch (InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public int stopCheckerboardRecording() {
|
|
Class [] parameters = new Class[1];
|
|
parameters[0] = null;
|
|
List checkerboard;
|
|
|
|
try {
|
|
Object [] params = null;
|
|
checkerboard = (List)_stopCheckerboardRecording.invoke(null, params);
|
|
Object [] amountarray = checkerboard.toArray();
|
|
int numIncompleteFrames = 0;
|
|
for (int i=0; i < amountarray.length; i++) {
|
|
Float val = (Float)amountarray[i];
|
|
if (val > 0.0f)
|
|
numIncompleteFrames++;
|
|
}
|
|
return numIncompleteFrames;
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
} catch (InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private GLSurfaceView getSurfaceView() {
|
|
for (View v : solo.getCurrentViews()) {
|
|
if (v instanceof GLSurfaceView) {
|
|
return (GLSurfaceView)v;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int[][] getPaintedSurface() {
|
|
GLSurfaceView view = getSurfaceView();
|
|
if (view == null) {
|
|
return null;
|
|
}
|
|
IntBuffer pixelBuffer;
|
|
try {
|
|
pixelBuffer = (IntBuffer)_getPixels.invoke(view);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
|
|
// now we need to (1) flip the image, because GL likes to do things up-side-down,
|
|
// and (2) rearrange the bits from AGBR-8888 to ARGB-8888.
|
|
int w = view.getWidth();
|
|
int h = view.getHeight();
|
|
pixelBuffer.position(0);
|
|
int[][] pixels = new int[h][w];
|
|
for (int y = h - 1; y >= 0; y--) {
|
|
for (int x = 0; x < w; x++) {
|
|
int agbr = pixelBuffer.get();
|
|
pixels[y][x] = (agbr & 0xFF00FF00) | ((agbr >> 16) & 0x000000FF) | ((agbr << 16) & 0x00FF0000);
|
|
}
|
|
}
|
|
return pixels;
|
|
}
|
|
|
|
class scrollHandler implements InvocationHandler {
|
|
public scrollHandler(){};
|
|
public Object invoke(Object proxy, Method method, Object[] args) {
|
|
try{
|
|
//Disect the JSON object into the appropriate variables
|
|
JSONObject jo = ((JSONObject)args[1]);
|
|
scrollHeight = jo.getInt("y");
|
|
height = jo.getInt("cheight");
|
|
//We don't want a height of 0. That means it's a bad response.
|
|
if( height > 0) {
|
|
pageHeight = jo.getInt("height");
|
|
}
|
|
|
|
} catch( Throwable e) {
|
|
Log.i("Robocop", "WARNING: ScrollReceived, but read wrong!");
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
public int getScrollHeight() {
|
|
return scrollHeight;
|
|
}
|
|
public int getPageHeight() {
|
|
return pageHeight;
|
|
}
|
|
public int getHeight() {
|
|
return height;
|
|
}
|
|
|
|
public int height=0;
|
|
public int scrollHeight=0;
|
|
public int pageHeight=10;
|
|
public void setupScrollHandling() {
|
|
//Setup scrollHandler to catch "robocop:scroll" events.
|
|
try {
|
|
Class [] interfaces = new Class[1];
|
|
interfaces[0] = gel;
|
|
Object[] finalParams = new Object[2];
|
|
finalParams[0] = "robocop:scroll";
|
|
finalParams[1] = Proxy.newProxyInstance(classLoader, interfaces, new scrollHandler());
|
|
registerGEL.invoke(null, finalParams);
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
} catch (InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
}
|
|
|
|
//Takes a filename, loads the file,
|
|
// and returns a string version of the entire file.
|
|
public static String getFile(String filename)
|
|
{
|
|
StringBuilder text = new StringBuilder();
|
|
|
|
BufferedReader br = null;
|
|
try {
|
|
br = new BufferedReader(new FileReader(filename));
|
|
String line;
|
|
|
|
while ((line = br.readLine()) != null) {
|
|
text.append(line);
|
|
text.append('\n');
|
|
}
|
|
} catch(IOException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
try {
|
|
br.close();
|
|
} catch (IOException e) {
|
|
}
|
|
}
|
|
return text.toString();
|
|
}
|
|
|
|
// Takes a string of "key=value" pairs split by \n and creates a hash table.
|
|
public static HashMap convertTextToTable(String data)
|
|
{
|
|
HashMap retVal = new HashMap();
|
|
|
|
String[] lines = data.split("\n");
|
|
for (int i = 0; i < lines.length; i++) {
|
|
String[] parts = lines[i].split("=");
|
|
retVal.put(parts[0].trim(), parts[1].trim());
|
|
}
|
|
return retVal;
|
|
}
|
|
}
|