calabash-android 0.5.1 → 0.5.2.pre1

data/lib/calabash-android/removed_actions.txt

@@ -50,3 +50,7 @@ wait_for_tab
 set_text
 scroll_down
 scroll_up
+set_date_with_description
+set_date_with_index
+set_time_with_description
+set_time_with_index

data/lib/calabash-android/steps/date_picker_steps.rb

@@ -1,8 +1,8 @@
 
-Given /^I set the date to "(\d\d-\d\d-\d\d\d\d)" on DatePicker with index "([^\"]*)"$/ do |date, index|
-  perform_action('set_date_with_index', date, index)
+Given /^I set the date to "(\d\d-\d\d-\d\d\d\d)" on DatePicker with index ([^\"]*)$/ do |date, index|
+  set_date("android.widget.DatePicker index:#{index.to_i-1}", date)
 end
 
 Given /^I set the "([^\"]*)" date to "(\d\d-\d\d-\d\d\d\d)"$/ do |content_description, date|
-  perform_action('set_date_with_description', content_description, date)
-end
+  set_date("android.widget.DatePicker {contentDescription LIKE[c] '#{content_description}'}", date)
+end

data/lib/calabash-android/steps/time_picker_steps.rb

@@ -1,8 +1,8 @@
 
-Given /^I set the time to "(\d\d:\d\d)" on TimePicker with index "([^\"]*)"$/ do |time, index|
-  perform_action('set_time_with_index', time, index)
+Given /^I set the time to "(\d\d:\d\d)" on TimePicker with index ([^\"]*)$/ do |time, index|
+  set_time("android.widget.TimePicker index:#{index.to_i-1}", time)
 end
 
 Given /^I set the "([^\"]*)" time to "(\d\d:\d\d)"$/ do |content_description, time|
-  perform_action('set_time_with_description', content_description, time)
+  set_time("android.widget.TimePicker {contentDescription LIKE[c] '#{content_description}'}", time)
 end

data/lib/calabash-android/touch_helpers.rb

@@ -1,34 +1,120 @@
 module Calabash
   module Android
     module TouchHelpers
+      include ::Calabash::Android::Gestures
+
+      def execute_gesture(multi_touch_gesture)
+        result = JSON.parse(http("/gesture", JSON.parse(multi_touch_gesture.to_json), read_timeout: multi_touch_gesture.timeout+10))
+
+        if result['outcome'] != 'SUCCESS'
+          raise "Failed to perform gesture. #{result['reason']}"
+        end
+      end
+
       def tap(mark, *args)
+        puts "Warning: The method tap is deprecated. Use tap_mark instead. In later Calabash versions we will change the semantics of `tap` to take a general query."
+
+        tap_mark(mark, *args)
+      end
+
+      def tap_mark(mark, *args)
         touch("* marked:'#{mark}'", *args)
       end
 
-      def double_tap(uiquery, options = {})
-        center_x, center_y = find_coordinate(uiquery, options)
+      def touch(query_string, options={})
+        if query_result?(query_string)
+          center_x, center_y = find_coordinate(query_string, options)
+
+          perform_action("touch_coordinate", center_x, center_y)
+        else
+          execute_gesture(Gesture.with_parameters(Gesture.tap(options), {query_string: query_string}.merge(options)))
+        end
+      end
+
+      def double_tap(query_string, options={})
+        if query_result?(query_string)
+          center_x, center_y = find_coordinate(query_string, options)
 
-        perform_action("double_tap_coordinate", center_x, center_y)
+          perform_action("double_tap_coordinate", center_x, center_y)
+        else
+          execute_gesture(Gesture.with_parameters(Gesture.double_tap(options), {query_string: query_string}.merge(options)))
+        end
       end
 
-      # Performs a "long press" operation on a selected view
-      # Params:
-      # +uiquery+: a uiquery identifying one view
-      # +options[:length]+: the length of the long press in milliseconds (optional)
-      #
-      # Examples:
-      #   - long_press("* id:'my_id'")
-      #   - long_press("* id:'my_id'", {:length=>5000})
-      def long_press(uiquery, options = {})
-        center_x, center_y = find_coordinate(uiquery, options)
-        length = options[:length]
-        perform_action("long_press_coordinate", center_x, center_y, *(length unless length.nil?))
+      def long_press(query_string, options={})
+        if query_result?(query_string)
+          center_x, center_y = find_coordinate(query_string, options)
+          length = options[:length]
+
+          perform_action("long_press_coordinate", center_x, center_y, *(length unless length.nil?))
+        else
+          length = options[:length]
+
+          if length
+            puts "Using the length key is deprecated. Use 'time' (in seconds) instead."
+            options[:time] = length/1000.0
+          end
+
+          options[:time] ||= 1
+
+          touch(query_string, options)
+        end
+      end
+
+      def drag(*args)
+        pan(*args)
       end
 
-      def touch(uiquery, options = {})
-        center_x, center_y = find_coordinate(uiquery, options)
+      def pan_left(options={})
+        pan("DecorView", :left, options)
+      end
+
+      def pan_right(options={})
+        pan("DecorView", :right, options)
+      end
 
-        perform_action("touch_coordinate", center_x, center_y)
+      def pan_up(options={})
+        pan("* id:'content'", :up, options)
+      end
+
+      def pan_down(options={})
+        pan("* id:'content'", :down, options)
+      end
+
+      def pan(query_string, direction, options={})
+        execute_gesture(Gesture.with_parameters(Gesture.swipe(direction, options), {query_string: query_string}.merge(options)))
+      end
+
+      def flick_left(options={})
+        flick("DecorView", :left, options)
+      end
+
+      def flick_right(options={})
+        flick("DecorView", :right, options)
+      end
+
+      def flick_up(options={})
+        flick("* id:'content'", :up, options)
+      end
+
+      def flick_down(options={})
+        flick("* id:'content'", :down, options)
+      end
+
+      def flick(query_string, direction, options={})
+        execute_gesture(Gesture.with_parameters(Gesture.swipe(direction, {flick: true}.merge(options)), {query_string: query_string}.merge(options)))
+      end
+
+      def pinch_out(options={})
+        pinch("* id:'content'", :out, options)
+      end
+
+      def pinch_in(options={})
+        pinch("* id:'content'", :in, options)
+      end
+
+      def pinch(query_string, direction, options={})
+        execute_gesture(Gesture.with_parameters(Gesture.pinch(direction, options), {query_string: query_string}.merge(options)))
       end
 
       def find_coordinate(uiquery, options={})
@@ -68,6 +154,16 @@ module Calabash
           when_element_exists(query_string, options)
         end
       end
+
+      def query_result?(uiquery)
+        element = if uiquery.is_a?(Array)
+          uiquery.first
+        else
+          uiquery
+        end
+
+        element.is_a?(Hash) && element.has_key?('rect') && element['rect'].has_key?('center_x') && element['rect'].has_key?('center_y')
+      end
     end
   end
 end

data/lib/calabash-android/version.rb

@@ -1,5 +1,5 @@
 module Calabash
   module Android
-    VERSION = "0.5.1"
+    VERSION = "0.5.2.pre1"
   end
 end

data/test-server/calabash-js/src/calabash.js

@@ -98,8 +98,40 @@
         return res;
     }
 
+    function applyMethods(object, arguments) {
+        var length = arguments.length;
+
+        for(var i = 0; i < length; i++) {
+            var argument = arguments[i];
+
+            if (typeof argument === 'string') {
+                argument = {method_name: argument, arguments: []}
+            }
+
+            var methodName = argument.method_name;
+            var methodArguments = argument.arguments;
+
+            if (typeof object[methodName] === 'undefined') {
+                var type = Object.prototype.toString.call(object);
+
+                object =
+                    {
+                        error: "No such method '" + methodName + "'",
+                        methodName: methodName,
+                        receiverString: object.constructor.name,
+                        receiverClass: type
+                    };
+
+                break;
+            } else {
+                object = object[methodName].apply(object, methodArguments);
+            }
+        }
+    }
+
     var exp = '%@'/* dynamic */,
-        queryType = '%@',
+        queryType = '%@' /* dynamic */,
+        arguments = '%@' /* dynamic */,
         nodes = null,
         res = [],
         i,N;
@@ -122,5 +154,14 @@
     {
        return JSON.stringify({error:'Exception while running query: '+exp, details:e.toString()})
     }
+
+    if (arguments !== '%@') {
+        var length = res.length;
+
+        for (var i = 0; i < length; i++) {
+            res[i] = applyMethods(res[i], arguments);
+        }
+    }
+
     return JSON.stringify(toJSON(res));
 })();

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/HttpServer.java

@@ -9,6 +9,7 @@ import java.io.StringWriter;
 import java.lang.InterruptedException;
 import java.lang.Override;
 import java.lang.Runnable;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.Map;
@@ -23,10 +24,14 @@ import sh.calaba.instrumentationbackend.FranklyResult;
 import sh.calaba.instrumentationbackend.InstrumentationBackend;
 import sh.calaba.instrumentationbackend.Result;
 import sh.calaba.instrumentationbackend.json.JSONUtils;
+import sh.calaba.instrumentationbackend.query.InvocationOperation;
+import sh.calaba.instrumentationbackend.query.Operation;
 import sh.calaba.instrumentationbackend.query.Query;
 import sh.calaba.instrumentationbackend.query.QueryResult;
 import sh.calaba.org.codehaus.jackson.map.ObjectMapper;
 
+import android.app.Application;
+import android.content.Context;
 import android.graphics.Bitmap;
 import android.util.Log;
 import android.view.View;
@@ -123,7 +128,48 @@ public class HttpServer extends NanoHTTPD {
                 errorResult = FranklyResult.fromThrowable(e);
             }
             return new NanoHTTPD.Response(HTTP_INTERNALERROR, "application/json;charset=utf-8", errorResult.asJson());
-		} 
+		}
+        else if (uri.endsWith("/backdoor")) {
+            try {
+                String json = params.getProperty("json");
+                ObjectMapper mapper = new ObjectMapper();
+                Map backdoorMethod = mapper.readValue(json, Map.class);
+
+                String methodName = (String) backdoorMethod.get("method_name");
+                List arguments = (List) backdoorMethod.get("arguments");
+                Operation operation = new InvocationOperation(methodName, arguments);
+
+                Application application = InstrumentationBackend.solo.getCurrentActivity().getApplication();
+                Object invocationResult;
+
+                invocationResult = operation.apply(application);
+
+                if (invocationResult instanceof Map && ((Map) invocationResult).containsKey("error")) {
+                    Context context = getRootView().getContext();
+                    invocationResult = operation.apply(context);
+                }
+
+                Map<String, String> result = new HashMap<String, String>();
+
+                if (invocationResult instanceof Map && ((Map) invocationResult).containsKey("error")) {
+                    result.put("outcome", "ERROR");
+                    result.put("result", (String) ((Map) invocationResult).get("error"));
+                    result.put("details", invocationResult.toString());
+                } else {
+                    result.put("outcome", "SUCCESS");
+                    result.put("result", String.valueOf(invocationResult));
+                }
+
+                ObjectMapper resultMapper = new ObjectMapper();
+
+                return new NanoHTTPD.Response(HTTP_OK, "application/json;charset=utf-8", resultMapper.writeValueAsString(result));
+            } catch (Exception e) {
+                e.printStackTrace();
+                Exception ex = new Exception("Could not invoke method", e);
+
+                return new NanoHTTPD.Response(HTTP_OK, "application/json;charset=utf-8", FranklyResult.fromThrowable(ex).asJson());
+            }
+        }
 		else if (uri.endsWith("/map")) {
 			FranklyResult errorResult = null;
 			try {
@@ -189,7 +235,26 @@ public class HttpServer extends NanoHTTPD {
 		} else if (uri.endsWith("/query")) {
 			return new Response(HTTP_BADREQUEST, MIME_PLAINTEXT,
 					"/query endpoint is discontinued - use /map with operation query");
-		} else if (uri.endsWith("/kill")) {
+        } else if (uri.endsWith("/gesture")) {
+            FranklyResult errorResult;
+
+            try {
+                String json = params.getProperty("json");
+                ObjectMapper mapper = new ObjectMapper();
+                Map gesture = mapper.readValue(json, Map.class);
+
+                (new MultiTouchGesture(gesture)).perform();
+
+                return new NanoHTTPD.Response(HTTP_OK, "application/json;charset=utf-8",
+                        FranklyResult.successResult(new QueryResult(Collections.emptyList())).asJson());
+
+            } catch (Exception e ) {
+                e.printStackTrace();
+                errorResult = FranklyResult.fromThrowable(e);
+            }
+
+            return new NanoHTTPD.Response(HTTP_OK, "application/json;charset=utf-8", errorResult.asJson());
+        } else if (uri.endsWith("/kill")) {
 			lock.lock();
 			try {
 				running = false;

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/MultiTouchGesture.java

@@ -0,0 +1,749 @@
+package sh.calaba.instrumentationbackend.actions;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+import android.app.KeyguardManager;
+import android.content.Context;
+import android.os.Build;
+import android.os.SystemClock;
+import android.util.Pair;
+import android.view.MotionEvent;
+
+import java.lang.reflect.Method;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.query.Query;
+import sh.calaba.instrumentationbackend.query.QueryResult;
+
+public class MultiTouchGesture {
+    Map<String, Object> multiTouchGestureMap;
+    Instrumentation instrumentation;
+    List<Gesture> pressedGestures;
+    List<Gesture> gesturesToPerform;
+    boolean hasPressedFirstGesture;
+
+    public MultiTouchGesture(Map<String, Object> multiTouchGesture) {
+        this.multiTouchGestureMap = multiTouchGesture;
+        instrumentation = InstrumentationBackend.instrumentation;
+        gesturesToPerform = new ArrayList<Gesture>();
+        hasPressedFirstGesture = false;
+    }
+
+    public void parseGesture() {
+        List<Map<String, Object>> sentGestures = (ArrayList<Map<String, Object>>) multiTouchGestureMap.get("gestures");
+        List<String> queryStrings = new ArrayList<String>();
+
+        // We query before generating the gestures. TODO: Implement new class with temporary information
+        for (Map<String, Object> gestureMap : sentGestures) {
+            String queryString = (String) gestureMap.get("query_string");
+
+            if (queryString != null) {
+                queryStrings.add(queryString);
+            }
+
+            ArrayList<Map<String, Object>> sentTouches = (ArrayList<Map<String, Object>>) gestureMap.get("touches");
+
+            for (Map<String,Object> sentTouch : sentTouches) {
+                if (sentTouch.containsKey("query_string")) {
+                    queryString = (String) sentTouch.get("query_string");
+
+                    if (queryString != null) {
+                        queryStrings.add(queryString);
+                    }
+                }
+            }
+        }
+
+        long timeout = (long) ((Double) multiTouchGestureMap.get("query_timeout") * 1000);
+        Map<String, Map<String, Integer>> evaluatedQueries = evaluateQueries(queryStrings, timeout);
+
+        for (Map<String, Object> gestureMap : sentGestures) {
+            String queryString = (String) gestureMap.get("query_string");
+            Map<String,Integer> rect = evaluatedQueries.get(queryString);
+
+            ArrayList<Map<String, Object>> sentTouches = (ArrayList<Map<String, Object>>) gestureMap.get("touches");
+
+            Gesture gesture = new Gesture();
+            int length = sentTouches.size();
+
+            for (int i = 0; i < length; i++) {
+                Map<String, Object> touch = sentTouches.get(i);
+                Map<String,Integer> specificRect = rect;
+
+                if (touch.containsKey("query_string")) {
+                    String specificQueryString = (String) touch.get("query_string");
+
+                    if (specificQueryString != null) {
+                        specificRect = evaluatedQueries.get(specificQueryString);
+                    }
+                }
+
+                int resultX = 0, resultY = 0, resultWidth = 0, resultHeight = 0;
+
+                if (specificRect != null) {
+                    resultX = specificRect.get("x");
+                    resultY = specificRect.get("y");
+                    resultWidth = specificRect.get("width");
+                    resultHeight = specificRect.get("height");
+                }
+
+                int offsetX = (Integer) touch.get("offset_x");
+                int offsetY = (Integer) touch.get("offset_y");
+                int x, y;
+
+                if (specificRect == null) {
+                    x = offsetX;
+                    y = offsetY;
+                } else {
+                    x = ((((Integer) touch.get("x")) * resultWidth)/100 + offsetX + resultX);
+                    y = ((((Integer) touch.get("y")) * resultHeight)/100 + offsetY + resultY);
+                }
+
+                long time = (long) ((Double) touch.get("time") * 1000);
+                long wait = (long) ((Double) touch.get("wait") * 1000);
+                boolean release = (Boolean) touch.get("release");
+
+                if (i == length - 1) {
+                    release = true;
+                }
+
+                if (!gesture.hasEvents()) {
+                    gesture.addEvent(new Event(new Coordinate(x, y), wait));
+                } else {
+                    gesture.addEvent(new Event(new Coordinate(x, y), 0l));
+
+                    if (wait != 0l) {
+                        gesture.addEvent(new Event(new Coordinate(x, y), wait), false);
+                    } else {
+                        gesture.setFling(true);
+                    }
+                }
+
+                gesture.addTimeOffset(time);
+
+                if (release) {
+                    gesture.addEvent(new Event(gesture.upEvent().getCoordinate(), 0l), true);
+                    long endTime = gesture.upEvent().getTime();
+                    gesturesToPerform.add(gesture);
+                    gesture = new Gesture(endTime);
+                }
+            }
+        }
+    }
+
+    public void perform() {
+        parseGesture();
+
+        // Sometimes the keyguard window or a service pops up very briefly.
+        // We handle it by waiting a fixed time
+        tryWaitForKeyguard(2);
+
+        long time;
+        long startTime = SystemClock.uptimeMillis();
+        long endTime = findEndTime();
+        pressedGestures = new ArrayList<Gesture>();
+
+        while ((time = SystemClock.uptimeMillis() - startTime) <= endTime) {
+            releaseGestures(time);
+
+            if (hasPressedFirstGesture) {
+                pressGestures(time);
+
+                // Instead of reassigning the time variable we only move gestures when we no longer offset the time
+                moveGestures(time);
+            } else {
+                // We catch the security exception thrown when the keyguard is visible briefly and retry if it's the first press
+                // Offset the startTime by the needed extra time if needed
+                long currentTime = SystemClock.uptimeMillis();
+                pressGestures(time);
+                long timeTaken =  SystemClock.uptimeMillis() - currentTime;
+
+                // Offset the start time (this changing the future values of time). This is done to keep relative timings consistent
+                if (hasPressedFirstGesture) { // We just pressed our first gesture
+                    startTime += timeTaken;
+                }
+            }
+        }
+
+        releaseGestures(endTime);
+    }
+
+    private Map<String, Map<String, Integer>> evaluateQueries(List<String> queryStrings, long timeout) {
+        List<String> distinctQueryStrings = new ArrayList<String>();
+
+        for (String queryString : queryStrings) {
+            if (!distinctQueryStrings.contains(queryString)) {
+                distinctQueryStrings.add(queryString);
+            }
+        }
+
+        Map<String, Map<String, Integer>> evaluatedQueries = new HashMap<String, Map<String, Integer>>();
+
+        long endTime  = SystemClock.uptimeMillis() + timeout;
+
+        do {
+            evaluatedQueries.clear();
+
+            for (String queryString : distinctQueryStrings) {
+                QueryResult queryResult = new Query(queryString, java.util.Collections.emptyList()).executeQuery();
+                // For now we calculate the views location and save it. In an implementation in the future, we should save the actual views and use their coordinates later on.
+                List<Object> results = queryResult.asList();
+
+                if (results.size() == 0) {
+                    break;
+                } else {
+                    Map<Object,Object> firstItem = (Map<Object, Object>) results.get(0);
+                    Map<String,Integer> rect = (Map<String, Integer>) firstItem.get("rect");
+                    evaluatedQueries.put(queryString, rect);
+                }
+            }
+
+            if (evaluatedQueries.size() == distinctQueryStrings.size()) {
+                // All the queries have been evaluated
+                return evaluatedQueries;
+            }
+
+            // Avoid affecting the UI Thread and device performance too much
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        } while (SystemClock.uptimeMillis() <= endTime);
+
+        throw new RuntimeException("Could not find views '" + distinctQueryStrings.toString() + "'");
+    }
+
+    private void sendPointerSync(MotionEvent motionEvent) {
+        instrumentation.sendPointerSync(motionEvent);
+    }
+
+    private void pressGestures(long currentTime) {
+        int i = 0;
+
+        while (i < gesturesToPerform.size()) {
+            Gesture gesture = gesturesToPerform.get(i);
+
+            // Sometimes the keyguard window or a service pops up very briefly.
+            // We handle it by retrying - but only if no gestures are currently down to avoid mistiming gestures.
+            int retries = hasPressedFirstGesture ? 1 : 10;
+            SecurityException ex = null;
+
+            for (int j = 0; j < retries; j++) {
+                try {
+                    if (gesture.shouldPress(currentTime)) {
+                        sendPointerSync(gesture.generateDownEvent(pressedGestures));
+                        hasPressedFirstGesture = true;
+                        pressedGestures.add(gesture);
+                        gesturesToPerform.remove(i);
+                    } else {
+                        i++;
+                    }
+
+                    ex = null;
+                    break;
+                } catch (SecurityException e) {
+                    ex = e;
+
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException interruptedException) {
+                        throw new RuntimeException(interruptedException);
+                    }
+                }
+            }
+
+            if (ex != null) {
+                throw new SecurityException(ex);
+            }
+        }
+    }
+
+    private void releaseGestures(long currentTime) {
+        int i = 0;
+
+        while (i < pressedGestures.size()) {
+            Gesture gesture = pressedGestures.get(i);
+
+            if (gesture.shouldRelease(currentTime)) {
+                // Ensure that the gesture will always move to its end-coordinate
+                long uptimeMillis = SystemClock.uptimeMillis();
+                moveGestures(currentTime, uptimeMillis);
+
+                sendPointerSync(gesture.generateUpEvent(pressedGestures, uptimeMillis+1));
+                pressedGestures.remove(i);
+            } else {
+                i++;
+            }
+        }
+    }
+
+    private void moveGestures(long currentTime) {
+        moveGestures(currentTime, null);
+    }
+
+    private void moveGestures(long currentTime, Long systemClockUptimeMillis) {
+        List<Gesture> gesturesToMove = new ArrayList<Gesture>();
+
+        for (Gesture gesture : pressedGestures) {
+            // Flinging gestures should never move to their last coordinate before releasing the touch.
+            if (gesture.shouldMove(currentTime)) {
+                gesturesToMove.add(gesture);
+            }
+        }
+
+        int gestureLength = gesturesToMove.size();
+
+        if (gestureLength > 0) {
+            MotionEvent motionEvent = obtainMotionEvent(gesturesToMove, MotionEvent.ACTION_MOVE, currentTime, findAbsoluteStartTime(), systemClockUptimeMillis);
+            sendPointerSync(motionEvent);
+        }
+    }
+
+    private long findAbsoluteStartTime() {
+        long startTime = SystemClock.uptimeMillis();
+
+        for (Gesture gesture : pressedGestures) {
+            if (gesture.getAbsoluteDownTime() != null) {
+                startTime = Math.min(gesture.getAbsoluteDownTime(), startTime);
+            }
+        }
+
+        return startTime;
+    }
+
+    private long findEndTime() {
+        long endTime = 0;
+
+        for (Gesture gesture : gesturesToPerform) {
+            endTime = Math.max(gesture.upEvent().getTime(), endTime);
+        }
+
+        return endTime;
+    }
+
+    public static void tryWaitForKeyguard(int timeoutSeconds) {
+        Activity activity = InstrumentationBackend.solo.getCurrentActivity();
+        KeyguardManager keyguardManager = (KeyguardManager) activity.getSystemService(Context.KEYGUARD_SERVICE);
+
+        if (!keyguardManager.inKeyguardRestrictedInputMode()) {
+            return;
+        }
+
+        long startTime = SystemClock.uptimeMillis();
+
+        while (SystemClock.uptimeMillis() - startTime <= timeoutSeconds * 1000) {
+            if (!keyguardManager.inKeyguardRestrictedInputMode()) {
+                break;
+            }
+        }
+
+        // For now, if the keyguard has shown up once, we sleep a bit more.
+        // TODO: Improve the implementation to detect focus of the activity to replace stopping when the keyguard is gone
+
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static MotionEvent obtainMotionEvent(List<Gesture> pressedGestures, int motionEventAction, long currentTime, Long absoluteDownTime) {
+        return obtainMotionEvent(pressedGestures, motionEventAction, currentTime, absoluteDownTime, null);
+    }
+
+    public static MotionEvent obtainMotionEvent(List<Gesture> pressedGestures, int motionEventAction, long currentTime, Long absoluteDownTime, Long systemClockUptimeMillis) {
+        int gestureLength = pressedGestures.size();
+
+        Coordinate[] coordinates = new Coordinate[gestureLength];
+        int[] pointerIds = new int[gestureLength];
+
+        for (int i = 0; i < gestureLength; i++) {
+            Gesture gesture = pressedGestures.get(i);
+            coordinates[i] = gesture.getPosition(currentTime);
+            pointerIds[i] = gesture.getId();
+        }
+
+        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.FROYO) {
+            MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[gestureLength];
+
+            for (int i = 0; i < gestureLength; i++) {
+                MotionEvent.PointerCoords pointerCoord = new MotionEvent.PointerCoords();
+                pointerCoord.x = coordinates[i].getX();
+                pointerCoord.y = coordinates[i].getY();
+                pointerCoord.pressure = 1;
+                pointerCoord.size = 1;
+                pointerCoords[i] = pointerCoord;
+            }
+
+            if (systemClockUptimeMillis == null) {
+                systemClockUptimeMillis = SystemClock.uptimeMillis();
+            }
+
+            if (absoluteDownTime == null) {
+                absoluteDownTime = systemClockUptimeMillis;
+            }
+
+            return MotionEvent.obtain(absoluteDownTime, systemClockUptimeMillis, motionEventAction, gestureLength, pointerIds, pointerCoords, 0, 1, 1, 0, 0, 0, 0);
+        } else {
+            try {
+                Method method = MotionEvent.class.getMethod("obtainNano", long.class, long.class, long.class, int.class, int.class, int[].class, float[].class, int.class, float.class, float.class, int.class, int.class);
+                float[] inData = new float[4*(gestureLength)];
+
+                for (int i = 0; i < gestureLength; i++) {
+                    inData[i*4] = coordinates[i].getX();
+                    inData[i*4+1] = coordinates[i].getY();
+                    inData[i*4+2] = 1.0f;
+                    inData[i*4+3] = 1.0f;
+                }
+
+                if (systemClockUptimeMillis == null) {
+                    systemClockUptimeMillis = SystemClock.uptimeMillis();
+                }
+
+                if (absoluteDownTime == null) {
+                    absoluteDownTime = systemClockUptimeMillis;
+                }
+
+                return (MotionEvent)method.invoke(null, absoluteDownTime, systemClockUptimeMillis, systemClockUptimeMillis * 1000000, motionEventAction, gestureLength, pointerIds, inData, 0, 1, 1, 0, 0);
+            } catch (Exception e) {
+                e.printStackTrace();
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private class Gesture {
+        List<Event> events;
+        Integer id;
+        Long absoluteDownTime;
+        long timeOffset;
+        boolean fling;
+
+        public Gesture() {
+            this(0);
+        }
+
+        public Gesture(long timeOffset) {
+            events = new ArrayList<Event>();
+            id = null;
+            absoluteDownTime = null;
+            this.timeOffset = timeOffset;
+            setFling(false);
+        }
+
+        public void addTimeOffset(long timeOffset) {
+            this.timeOffset += timeOffset;
+        }
+
+        public long getTimeOffset() {
+            return timeOffset;
+        }
+
+        public Integer getId() {
+            return id;
+        }
+
+        public boolean getFling() {
+            return fling;
+        }
+
+        public Long getAbsoluteDownTime() {
+            return absoluteDownTime;
+        }
+
+        public void setFling(boolean fling) {
+            this.fling = fling;
+        }
+
+        public void addEvent(Event event) {
+            addEvent(event, true);
+        }
+
+        public void addEvent(Event event, boolean useOffset) {
+            if (upEvent() != null) {
+                event.setTime(event.getTime() + upEvent().getTime());
+            }
+
+            if (useOffset) {
+                event.setTime(event.getTime() + timeOffset);
+            }
+
+            events.add(event);
+            timeOffset = 0;
+        }
+
+        public boolean hasEvents() {
+            return (events != null && events.size() != 0);
+        }
+
+        public Event downEvent() {
+            if (!hasEvents()) {
+                return null;
+            } else {
+                return events.get(0);
+            }
+        }
+
+        public Event upEvent() {
+            if (!hasEvents()) {
+                return null;
+            } else {
+                return events.get(events.size() - 1);
+            }
+        }
+
+        public Pair<Event,Event> getEventPair(long time) {
+            if (downEvent().getTime() == time) {
+                return new Pair<Event,Event>(downEvent(), events.get(1));
+            }
+
+            int i;
+
+            for (i = 0; i < events.size(); i++) {
+                if (events.get(i).getTime() > time) {
+                    break;
+                }
+            }
+
+            if (i == 0) {
+                return null;
+            }
+
+            return new Pair<Event,Event>(events.get(i-1), events.get(i));
+        }
+
+        public boolean shouldPress(long time) {
+            return (getEventPair(time) != null);
+        }
+
+        public boolean shouldRelease(long time) {
+            return (time >= upEvent().getTime());
+        }
+
+        public boolean shouldMove(long time) {
+            if (!getFling() || time >= upEvent().getTime()) {
+                return true;
+            }
+
+            Coordinate position = getPosition(time);
+            Coordinate upCoordinate = upEvent().getCoordinate();
+            double fullDistance = getEventPair(time).first.getCoordinate().distance(upCoordinate);
+            double distance = position.distance(upCoordinate);
+
+            return (distance / fullDistance > 0.05);
+        }
+
+        public Coordinate getPosition(long time) {
+            if (time >= upEvent().getTime()) {
+                return upEvent().getCoordinate();
+            }
+
+            Pair<Event,Event> eventPair = getEventPair(time);
+
+            long startTime = eventPair.first.getTime();
+            long endTime = eventPair.second.getTime();
+            Coordinate from = eventPair.first.getCoordinate();
+            Coordinate to = eventPair.second.getCoordinate();
+
+            if (endTime == startTime) {
+                return to;
+            }
+
+            float fraction = (float) (time - startTime)/(endTime - startTime);
+
+            if (fraction == 0.0f) {
+                return from;
+            } else {
+                return from.between(to, fraction);
+            }
+        }
+
+        public MotionEvent.PointerProperties getPointerProperty() {
+            MotionEvent.PointerProperties pointerProperties = new MotionEvent.PointerProperties();
+            pointerProperties.id = id;
+            pointerProperties.toolType = MotionEvent.TOOL_TYPE_FINGER;
+
+            return pointerProperties;
+        }
+
+        public MotionEvent.PointerCoords getPointerCoord(long time) {
+            Coordinate position = getPosition(time);
+            MotionEvent.PointerCoords pointerCoords = new MotionEvent.PointerCoords();
+            pointerCoords.x = position.getX();
+            pointerCoords.y = position.getY();
+            pointerCoords.pressure = 1.0f;
+            pointerCoords.size = 1.0f;
+
+            return pointerCoords;
+        }
+
+        public void setId(List<Gesture> pressedGestures) {
+            // The id of the pointer is 0-based. The id should always be as low as possible
+            int id = 0;
+            boolean idSet = false;
+
+            while (!idSet) {
+                idSet = true;
+
+                for (Gesture gesture : pressedGestures) {
+                    if (gesture.getId() == id) {
+                        idSet = false;
+                        id++;
+                    }
+                }
+            }
+
+            this.id = id;
+        }
+
+        public MotionEvent generateDownEvent(List<Gesture> pressedGestures) {
+            int gestureLength = pressedGestures.size();
+            setId(pressedGestures);
+            int motionEventAction;
+
+            // The down action is based on the amount of gestures currently down, not its own id/timing.
+            if (gestureLength > 0) {
+                motionEventAction = (gestureLength << MotionEvent.ACTION_POINTER_INDEX_SHIFT) + MotionEvent.ACTION_POINTER_DOWN;
+            } else {
+                motionEventAction = MotionEvent.ACTION_DOWN;
+            }
+
+            long time = downEvent().getTime();
+
+             // Because this gesture is not yet down, it is not included in the list of gestures passed as the first parameter
+            List<Gesture> allPressedGestures = new ArrayList<Gesture>(pressedGestures);
+            allPressedGestures.add(this);
+
+            absoluteDownTime = SystemClock.uptimeMillis();
+
+            return obtainMotionEvent(allPressedGestures, motionEventAction, time, absoluteDownTime);
+        }
+
+        public MotionEvent generateUpEvent(List<Gesture> pressedGestures) {
+            return generateUpEvent(pressedGestures, null);
+        }
+
+        public MotionEvent generateUpEvent(List<Gesture> pressedGestures, Long systemClockUptimeMillis) {
+            int gestureLength = pressedGestures.size();
+            int motionEventAction;
+            int indexInPressedGestures = pressedGestures.indexOf(this);
+
+            // The up action is based on the amount of gestures currently down, not its own id/timing.
+            if (gestureLength > 1) {
+                motionEventAction = (indexInPressedGestures << MotionEvent.ACTION_POINTER_INDEX_SHIFT) + MotionEvent.ACTION_POINTER_UP;
+            } else {
+                motionEventAction = MotionEvent.ACTION_UP;
+            }
+
+            long time = upEvent().getTime();
+
+            return obtainMotionEvent(pressedGestures, motionEventAction, time, getAbsoluteDownTime(), systemClockUptimeMillis);
+        }
+
+        public String toString() {
+            return "Gesture {Events: "+events.toString()+"}";
+        }
+    }
+
+    private class Event {
+        private Coordinate coordinate;
+        private Long time;
+
+        public Event() {
+            this(null, null);
+        }
+
+        public Event(Coordinate coordinate, Long time) {
+            setCoordinate(coordinate);
+            setTime(time);
+        }
+
+        public Event copy() {
+            return new Event(coordinate.copy(), getTime());
+        }
+
+        public Coordinate getCoordinate() {
+            return coordinate;
+        }
+
+        public void setCoordinate(Coordinate coordinate) {
+            this.coordinate = coordinate;
+        }
+
+        public long getTime() {
+            return time;
+        }
+
+        public void setTime(Long time) {
+            this.time = time;
+        }
+
+        public String toString() {
+            return "Event {time: "+getTime()+", coordinate: "+getCoordinate()+"}";
+        }
+    }
+
+    private class Coordinate {
+        private int x;
+        private int y;
+
+        public Coordinate(int x, int y) {
+            setX(x);
+            setY(y);
+        }
+
+        public Coordinate copy() {
+            return new Coordinate(getX(), getY());
+        }
+
+        public int getX() {
+            return x;
+        }
+
+        public int getY() {
+            return y;
+        }
+
+        public void setX(int x) {
+            this.x = x;
+        }
+
+        public void setY(int y) {
+            this.y = y;
+        }
+
+        public Coordinate between(Coordinate to, float fraction) {
+            int x = (int) ((to.getX() - getX()) * fraction + getX());
+            int y = (int) ((to.getY() - getY()) * fraction + getY());
+
+            return new Coordinate(x, y);
+        }
+
+        public double distance(Coordinate to) {
+            float xDistance = getX() - to.getX();
+            float yDistance = getY() - to.getY();
+
+            return Math.sqrt(Math.pow(xDistance, 2) + Math.pow(yDistance, 2));
+        }
+
+        public String toString() {
+            return "Coordinate {x: "+getX()+", y: "+getY()+"}";
+        }
+
+        public boolean equals(Object object, double precision) {
+            if (!(object instanceof Coordinate)) {
+                return false;
+            }
+
+            Coordinate coordinate = (Coordinate)object;
+
+            return (distance(coordinate) <= precision);
+        }
+    }
+}