cmds/input/src/com/android/commands/input/Input.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.commands.input;

 import static android.view.Display.DEFAULT_DISPLAY;
 import static android.view.Display.INVALID_DISPLAY;

 import android.hardware.input.InputManager;
 import android.os.SystemClock;
 import android.view.InputDevice;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.ViewConfiguration;

 import com.android.internal.os.BaseCommand;

 import java.io.PrintStream;
 import java.util.HashMap;
 import java.util.Map;

 /**
  * Command that sends key events to the device, either by their keycode, or by
  * desired character output.
  */

 public class Input extends BaseCommand {
     private static final String TAG = "Input";
     private static final String INVALID_ARGUMENTS = "Error: Invalid arguments for command: ";
     private static final String INVALID_DISPLAY_ARGUMENTS =
             "Error: Invalid arguments for display ID.";

     private static final float DEFAULT_PRESSURE = 1.0f;
     private static final float NO_PRESSURE = 0.0f;

     private static final Map<String, Integer> SOURCES = new HashMap<String, Integer>() {{
         put("keyboard", InputDevice.SOURCE_KEYBOARD);
         put("dpad", InputDevice.SOURCE_DPAD);
         put("gamepad", InputDevice.SOURCE_GAMEPAD);
         put("touchscreen", InputDevice.SOURCE_TOUCHSCREEN);
         put("mouse", InputDevice.SOURCE_MOUSE);
         put("stylus", InputDevice.SOURCE_STYLUS);
         put("trackball", InputDevice.SOURCE_TRACKBALL);
         put("touchpad", InputDevice.SOURCE_TOUCHPAD);
         put("touchnavigation", InputDevice.SOURCE_TOUCH_NAVIGATION);
         put("joystick", InputDevice.SOURCE_JOYSTICK);
     }};

     private static final Map<String, InputCmd> COMMANDS = new HashMap<String, InputCmd>();

     /**
      * Command-line entry point.
      *
      * @param args The command-line arguments
      */
     public static void main(String[] args) {
         (new Input()).run(args);
     }

     Input() {
         COMMANDS.put("text", new InputText());
         COMMANDS.put("keyevent", new InputKeyEvent());
         COMMANDS.put("tap", new InputTap());
         COMMANDS.put("swipe", new InputSwipe());
         COMMANDS.put("draganddrop", new InputDragAndDrop());
         COMMANDS.put("press", new InputPress());
         COMMANDS.put("roll", new InputRoll());
         COMMANDS.put("motionevent", new InputMotionEvent());
     }

     @Override
     public void onRun() throws Exception {
         String arg = nextArgRequired();
         int inputSource = InputDevice.SOURCE_UNKNOWN;

         // Get source (optional).
         if (SOURCES.containsKey(arg)) {
             inputSource = SOURCES.get(arg);
             arg = nextArgRequired();
         }

         // Get displayId (optional).
         int displayId = INVALID_DISPLAY;
         if ("-d".equals(arg)) {
             displayId = getDisplayId();
             arg = nextArgRequired();
         }

         // Get command and run.
         InputCmd cmd = COMMANDS.get(arg);
         if (cmd != null) {
             try {
                 cmd.run(inputSource, displayId);
                 return;
             } catch (NumberFormatException ex) {
                 throw new IllegalArgumentException(INVALID_ARGUMENTS + arg);
             }
         }

         throw new IllegalArgumentException("Error: Unknown command: " + arg);
     }

     private int getDisplayId() {
         String displayArg = nextArgRequired();
         if ("INVALID_DISPLAY".equalsIgnoreCase(displayArg)) {
             return INVALID_DISPLAY;
         } else if ("DEFAULT_DISPLAY".equalsIgnoreCase(displayArg)) {
             return DEFAULT_DISPLAY;
         } else {
             try {
                 final int displayId = Integer.parseInt(displayArg);
                 if (displayId == INVALID_DISPLAY) {
                     return INVALID_DISPLAY;
                 }
                 return Math.max(displayId, 0);
             } catch (NumberFormatException e) {
                 throw new IllegalArgumentException(INVALID_DISPLAY_ARGUMENTS);
             }
         }
     }

     class InputText implements InputCmd {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_KEYBOARD);
             sendText(inputSource, nextArgRequired(), displayId);
         }

         /**
          * Convert the characters of string text into key event's and send to
          * device.
          *
          * @param text is a string of characters you want to input to the device.
          */
         private void sendText(int source, final String text, int displayId) {
             final StringBuffer buff = new StringBuffer(text);
             boolean escapeFlag = false;
             for (int i = 0; i < buff.length(); i++) {
                 if (escapeFlag) {
                     escapeFlag = false;
                     if (buff.charAt(i) == 's') {
                         buff.setCharAt(i, ' ');
                         buff.deleteCharAt(--i);
                     }
                 }
                 if (buff.charAt(i) == '%') {
                     escapeFlag = true;
                 }
             }

             final char[] chars = buff.toString().toCharArray();
             final KeyCharacterMap kcm = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD);
             final KeyEvent[] events = kcm.getEvents(chars);
             for (int i = 0; i < events.length; i++) {
                 KeyEvent e = events[i];
                 if (source != e.getSource()) {
                     e.setSource(source);
                 }
                 e.setDisplayId(displayId);
                 injectKeyEvent(e);
             }
         }
     }

     class InputKeyEvent implements InputCmd {
         @Override
         public void run(int inputSource, int displayId) {
             String arg = nextArgRequired();
             final boolean longpress = "--longpress".equals(arg);
             if (longpress) {
                 arg = nextArgRequired();
             }

             do {
                 final int keycode = KeyEvent.keyCodeFromString(arg);
                 sendKeyEvent(inputSource, keycode, longpress, displayId);
             } while ((arg = nextArg()) != null);
         }

         private void sendKeyEvent(int inputSource, int keyCode, boolean longpress, int displayId) {
             final long now = SystemClock.uptimeMillis();
             int repeatCount = 0;

             KeyEvent event = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, keyCode, repeatCount,
                     0 /*metaState*/, KeyCharacterMap.VIRTUAL_KEYBOARD, 0 /*scancode*/, 0 /*flags*/,
                     inputSource);
             event.setDisplayId(displayId);

             injectKeyEvent(event);
             if (longpress) {
                 repeatCount++;
                 injectKeyEvent(KeyEvent.changeTimeRepeat(event, now, repeatCount,
                         KeyEvent.FLAG_LONG_PRESS));
             }
             injectKeyEvent(KeyEvent.changeAction(event, KeyEvent.ACTION_UP));
         }
     }

     class InputTap implements InputCmd {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
             sendTap(inputSource, Float.parseFloat(nextArgRequired()),
                     Float.parseFloat(nextArgRequired()), displayId);
         }

         void sendTap(int inputSource, float x, float y, int displayId) {
             final long now = SystemClock.uptimeMillis();
             injectMotionEvent(inputSource, MotionEvent.ACTION_DOWN, now, now, x, y, 1.0f,
                     displayId);
             injectMotionEvent(inputSource, MotionEvent.ACTION_UP, now, now, x, y, 0.0f, displayId);
         }
     }

     class InputPress extends InputTap {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_TRACKBALL);
             sendTap(inputSource, 0.0f, 0.0f, displayId);
         }
     }

     class InputSwipe implements InputCmd {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
             sendSwipe(inputSource, displayId, false);
         }

         void sendSwipe(int inputSource, int displayId, boolean isDragDrop) {
             // Parse two points and duration.
             final float x1 = Float.parseFloat(nextArgRequired());
             final float y1 = Float.parseFloat(nextArgRequired());
             final float x2 = Float.parseFloat(nextArgRequired());
             final float y2 = Float.parseFloat(nextArgRequired());
             String durationArg = nextArg();
             int duration = durationArg != null ? Integer.parseInt(durationArg) : -1;
             if (duration < 0) {
                 duration = 300;
             }

             final long down = SystemClock.uptimeMillis();
             injectMotionEvent(inputSource, MotionEvent.ACTION_DOWN, down, down, x1, y1, 1.0f,
                     displayId);
             if (isDragDrop) {
                 // long press until drag start.
                 try {
                     Thread.sleep(ViewConfiguration.getLongPressTimeout());
                 } catch (InterruptedException e) {
                     throw new RuntimeException(e);
                 }
             }
             long now = SystemClock.uptimeMillis();
             final long endTime = down + duration;
             while (now < endTime) {
                 final long elapsedTime = now - down;
                 final float alpha = (float) elapsedTime / duration;
                 injectMotionEvent(inputSource, MotionEvent.ACTION_MOVE, down, now,
                         lerp(x1, x2, alpha), lerp(y1, y2, alpha), 1.0f, displayId);
                 now = SystemClock.uptimeMillis();
             }
             injectMotionEvent(inputSource, MotionEvent.ACTION_UP, down, now, x2, y2, 0.0f,
                     displayId);
         }
     }

     class InputDragAndDrop extends InputSwipe {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
             sendSwipe(inputSource, displayId, true);
         }
     }

     class InputRoll implements InputCmd {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_TRACKBALL);
             sendMove(inputSource, Float.parseFloat(nextArgRequired()),
                     Float.parseFloat(nextArgRequired()), displayId);
         }

         /**
          * Sends a simple zero-pressure move event.
          *
          * @param inputSource the InputDevice.SOURCE_* sending the input event
          * @param dx change in x coordinate due to move
          * @param dy change in y coordinate due to move
          */
         private void sendMove(int inputSource, float dx, float dy, int displayId) {
             final long now = SystemClock.uptimeMillis();
             injectMotionEvent(inputSource, MotionEvent.ACTION_MOVE, now, now, dx, dy, 0.0f,
                     displayId);
         }
     }

     class InputMotionEvent implements InputCmd {
         @Override
         public void run(int inputSource, int displayId) {
             inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
             sendMotionEvent(inputSource, nextArgRequired(), Float.parseFloat(nextArgRequired()),
                     Float.parseFloat(nextArgRequired()), displayId);
         }

         private void sendMotionEvent(int inputSource, String motionEventType, float x, float y,
                 int displayId) {
             final int action;
             final float pressure;

             switch (motionEventType.toUpperCase()) {
                 case "DOWN":
                     action = MotionEvent.ACTION_DOWN;
                     pressure = DEFAULT_PRESSURE;
                     break;
                 case "UP":
                     action = MotionEvent.ACTION_UP;
                     pressure = NO_PRESSURE;
                     break;
                 case "MOVE":
                     action = MotionEvent.ACTION_MOVE;
                     pressure = DEFAULT_PRESSURE;
                     break;
                 default:
                     throw new IllegalArgumentException("Unknown motionevent " + motionEventType);
             }

             final long now = SystemClock.uptimeMillis();
             injectMotionEvent(inputSource, action, now, now, x, y, pressure, displayId);
         }
     }

     /**
      * Abstract class for command
      * use nextArgRequired or nextArg to check next argument if necessary.
      */
     private interface InputCmd {
         void run(int inputSource, int displayId);
     }

     private static void injectKeyEvent(KeyEvent event) {
         InputManager.getInstance().injectInputEvent(event,
                 InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH);
     }

     private static int getInputDeviceId(int inputSource) {
         final int DEFAULT_DEVICE_ID = 0;
         int[] devIds = InputDevice.getDeviceIds();
         for (int devId : devIds) {
             InputDevice inputDev = InputDevice.getDevice(devId);
             if (inputDev.supportsSource(inputSource)) {
                 return devId;
             }
         }
         return DEFAULT_DEVICE_ID;
     }

     /**
      * Builds a MotionEvent and injects it into the event stream.
      *
      * @param inputSource the InputDevice.SOURCE_* sending the input event
      * @param action the MotionEvent.ACTION_* for the event
      * @param downTime the value of the ACTION_DOWN event happened
      * @param when the value of SystemClock.uptimeMillis() at which the event happened
      * @param x x coordinate of event
      * @param y y coordinate of event
      * @param pressure pressure of event
      */
     private static void injectMotionEvent(int inputSource, int action, long downTime, long when,
             float x, float y, float pressure, int displayId) {
         final float DEFAULT_SIZE = 1.0f;
         final int DEFAULT_META_STATE = 0;
         final float DEFAULT_PRECISION_X = 1.0f;
         final float DEFAULT_PRECISION_Y = 1.0f;
         final int DEFAULT_EDGE_FLAGS = 0;
         MotionEvent event = MotionEvent.obtain(downTime, when, action, x, y, pressure, DEFAULT_SIZE,
                 DEFAULT_META_STATE, DEFAULT_PRECISION_X, DEFAULT_PRECISION_Y,
                 getInputDeviceId(inputSource), DEFAULT_EDGE_FLAGS);
         event.setSource(inputSource);
         if (displayId == INVALID_DISPLAY && (inputSource & InputDevice.SOURCE_CLASS_POINTER) != 0) {
             displayId = DEFAULT_DISPLAY;
         }
         event.setDisplayId(displayId);
         InputManager.getInstance().injectInputEvent(event,
                 InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH);
     }

     private static final float lerp(float a, float b, float alpha) {
         return (b - a) * alpha + a;
     }

     private static final int getSource(int inputSource, int defaultSource) {
         return inputSource == InputDevice.SOURCE_UNKNOWN ? defaultSource : inputSource;
     }

     @Override
     public void onShowUsage(PrintStream out) {
         out.println("Usage: input [<source>] [-d DISPLAY_ID] <command> [<arg>...]");
         out.println();
         out.println("The sources are: ");
         for (String src : SOURCES.keySet()) {
             out.println("      " + src);
         }
         out.println();
         out.printf("-d: specify the display ID.\n"
                 + "      (Default: %d for key event, %d for motion event if not specified.)",
                 INVALID_DISPLAY, DEFAULT_DISPLAY);
         out.println();
         out.println("The commands and default sources are:");
         out.println("      text <string> (Default: touchscreen)");
         out.println("      keyevent [--longpress] <key code number or name> ..."
                 + " (Default: keyboard)");
         out.println("      tap <x> <y> (Default: touchscreen)");
         out.println("      swipe <x1> <y1> <x2> <y2> [duration(ms)]"
                 + " (Default: touchscreen)");
         out.println("      draganddrop <x1> <y1> <x2> <y2> [duration(ms)]"
                 + " (Default: touchscreen)");
         out.println("      press (Default: trackball)");
         out.println("      roll <dx> <dy> (Default: trackball)");
         out.println("      motionevent <DOWN|UP|MOVE> <x> <y> (Default: touchscreen)");
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.commands.input;

	import static android.view.Display.DEFAULT_DISPLAY;
	import static android.view.Display.INVALID_DISPLAY;

	import android.hardware.input.InputManager;
	import android.os.SystemClock;
	import android.view.InputDevice;
	import android.view.KeyCharacterMap;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.ViewConfiguration;

	import com.android.internal.os.BaseCommand;

	import java.io.PrintStream;
	import java.util.HashMap;
	import java.util.Map;

	/**
	* Command that sends key events to the device, either by their keycode, or by
	* desired character output.
	*/

	public class Input extends BaseCommand {
	private static final String TAG = "Input";
	private static final String INVALID_ARGUMENTS = "Error: Invalid arguments for command: ";
	private static final String INVALID_DISPLAY_ARGUMENTS =
	"Error: Invalid arguments for display ID.";

	private static final float DEFAULT_PRESSURE = 1.0f;
	private static final float NO_PRESSURE = 0.0f;

	private static final Map<String, Integer> SOURCES = new HashMap<String, Integer>() {{
	put("keyboard", InputDevice.SOURCE_KEYBOARD);
	put("dpad", InputDevice.SOURCE_DPAD);
	put("gamepad", InputDevice.SOURCE_GAMEPAD);
	put("touchscreen", InputDevice.SOURCE_TOUCHSCREEN);
	put("mouse", InputDevice.SOURCE_MOUSE);
	put("stylus", InputDevice.SOURCE_STYLUS);
	put("trackball", InputDevice.SOURCE_TRACKBALL);
	put("touchpad", InputDevice.SOURCE_TOUCHPAD);
	put("touchnavigation", InputDevice.SOURCE_TOUCH_NAVIGATION);
	put("joystick", InputDevice.SOURCE_JOYSTICK);
	}};

	private static final Map<String, InputCmd> COMMANDS = new HashMap<String, InputCmd>();

	/**
	* Command-line entry point.
	*
	* @param args The command-line arguments
	*/
	public static void main(String[] args) {
	(new Input()).run(args);
	}

	Input() {
	COMMANDS.put("text", new InputText());
	COMMANDS.put("keyevent", new InputKeyEvent());
	COMMANDS.put("tap", new InputTap());
	COMMANDS.put("swipe", new InputSwipe());
	COMMANDS.put("draganddrop", new InputDragAndDrop());
	COMMANDS.put("press", new InputPress());
	COMMANDS.put("roll", new InputRoll());
	COMMANDS.put("motionevent", new InputMotionEvent());
	}

	@Override
	public void onRun() throws Exception {
	String arg = nextArgRequired();
	int inputSource = InputDevice.SOURCE_UNKNOWN;

	// Get source (optional).
	if (SOURCES.containsKey(arg)) {
	inputSource = SOURCES.get(arg);
	arg = nextArgRequired();
	}

	// Get displayId (optional).
	int displayId = INVALID_DISPLAY;
	if ("-d".equals(arg)) {
	displayId = getDisplayId();
	arg = nextArgRequired();
	}

	// Get command and run.
	InputCmd cmd = COMMANDS.get(arg);
	if (cmd != null) {
	try {
	cmd.run(inputSource, displayId);
	return;
	} catch (NumberFormatException ex) {
	throw new IllegalArgumentException(INVALID_ARGUMENTS + arg);
	}
	}

	throw new IllegalArgumentException("Error: Unknown command: " + arg);
	}

	private int getDisplayId() {
	String displayArg = nextArgRequired();
	if ("INVALID_DISPLAY".equalsIgnoreCase(displayArg)) {
	return INVALID_DISPLAY;
	} else if ("DEFAULT_DISPLAY".equalsIgnoreCase(displayArg)) {
	return DEFAULT_DISPLAY;
	} else {
	try {
	final int displayId = Integer.parseInt(displayArg);
	if (displayId == INVALID_DISPLAY) {
	return INVALID_DISPLAY;
	}
	return Math.max(displayId, 0);
	} catch (NumberFormatException e) {
	throw new IllegalArgumentException(INVALID_DISPLAY_ARGUMENTS);
	}
	}
	}

	class InputText implements InputCmd {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_KEYBOARD);
	sendText(inputSource, nextArgRequired(), displayId);
	}

	/**
	* Convert the characters of string text into key event's and send to
	* device.
	*
	* @param text is a string of characters you want to input to the device.
	*/
	private void sendText(int source, final String text, int displayId) {
	final StringBuffer buff = new StringBuffer(text);
	boolean escapeFlag = false;
	for (int i = 0; i < buff.length(); i++) {
	if (escapeFlag) {
	escapeFlag = false;
	if (buff.charAt(i) == 's') {
	buff.setCharAt(i, ' ');
	buff.deleteCharAt(--i);
	}
	}
	if (buff.charAt(i) == '%') {
	escapeFlag = true;
	}
	}

	final char[] chars = buff.toString().toCharArray();
	final KeyCharacterMap kcm = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD);
	final KeyEvent[] events = kcm.getEvents(chars);
	for (int i = 0; i < events.length; i++) {
	KeyEvent e = events[i];
	if (source != e.getSource()) {
	e.setSource(source);
	}
	e.setDisplayId(displayId);
	injectKeyEvent(e);
	}
	}
	}

	class InputKeyEvent implements InputCmd {
	@Override
	public void run(int inputSource, int displayId) {
	String arg = nextArgRequired();
	final boolean longpress = "--longpress".equals(arg);
	if (longpress) {
	arg = nextArgRequired();
	}

	do {
	final int keycode = KeyEvent.keyCodeFromString(arg);
	sendKeyEvent(inputSource, keycode, longpress, displayId);
	} while ((arg = nextArg()) != null);
	}

	private void sendKeyEvent(int inputSource, int keyCode, boolean longpress, int displayId) {
	final long now = SystemClock.uptimeMillis();
	int repeatCount = 0;

	KeyEvent event = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, keyCode, repeatCount,
	0 /metaState/, KeyCharacterMap.VIRTUAL_KEYBOARD, 0 /scancode/, 0 /flags/,
	inputSource);
	event.setDisplayId(displayId);

	injectKeyEvent(event);
	if (longpress) {
	repeatCount++;
	injectKeyEvent(KeyEvent.changeTimeRepeat(event, now, repeatCount,
	KeyEvent.FLAG_LONG_PRESS));
	}
	injectKeyEvent(KeyEvent.changeAction(event, KeyEvent.ACTION_UP));
	}
	}

	class InputTap implements InputCmd {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
	sendTap(inputSource, Float.parseFloat(nextArgRequired()),
	Float.parseFloat(nextArgRequired()), displayId);
	}

	void sendTap(int inputSource, float x, float y, int displayId) {
	final long now = SystemClock.uptimeMillis();
	injectMotionEvent(inputSource, MotionEvent.ACTION_DOWN, now, now, x, y, 1.0f,
	displayId);
	injectMotionEvent(inputSource, MotionEvent.ACTION_UP, now, now, x, y, 0.0f, displayId);
	}
	}

	class InputPress extends InputTap {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_TRACKBALL);
	sendTap(inputSource, 0.0f, 0.0f, displayId);
	}
	}

	class InputSwipe implements InputCmd {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
	sendSwipe(inputSource, displayId, false);
	}

	void sendSwipe(int inputSource, int displayId, boolean isDragDrop) {
	// Parse two points and duration.
	final float x1 = Float.parseFloat(nextArgRequired());
	final float y1 = Float.parseFloat(nextArgRequired());
	final float x2 = Float.parseFloat(nextArgRequired());
	final float y2 = Float.parseFloat(nextArgRequired());
	String durationArg = nextArg();
	int duration = durationArg != null ? Integer.parseInt(durationArg) : -1;
	if (duration < 0) {
	duration = 300;
	}

	final long down = SystemClock.uptimeMillis();
	injectMotionEvent(inputSource, MotionEvent.ACTION_DOWN, down, down, x1, y1, 1.0f,
	displayId);
	if (isDragDrop) {
	// long press until drag start.
	try {
	Thread.sleep(ViewConfiguration.getLongPressTimeout());
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	}
	}
	long now = SystemClock.uptimeMillis();
	final long endTime = down + duration;
	while (now < endTime) {
	final long elapsedTime = now - down;
	final float alpha = (float) elapsedTime / duration;
	injectMotionEvent(inputSource, MotionEvent.ACTION_MOVE, down, now,
	lerp(x1, x2, alpha), lerp(y1, y2, alpha), 1.0f, displayId);
	now = SystemClock.uptimeMillis();
	}
	injectMotionEvent(inputSource, MotionEvent.ACTION_UP, down, now, x2, y2, 0.0f,
	displayId);
	}
	}

	class InputDragAndDrop extends InputSwipe {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
	sendSwipe(inputSource, displayId, true);
	}
	}

	class InputRoll implements InputCmd {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_TRACKBALL);
	sendMove(inputSource, Float.parseFloat(nextArgRequired()),
	Float.parseFloat(nextArgRequired()), displayId);
	}

	/**
	* Sends a simple zero-pressure move event.
	*
	* @param inputSource the InputDevice.SOURCE_* sending the input event
	* @param dx change in x coordinate due to move
	* @param dy change in y coordinate due to move
	*/
	private void sendMove(int inputSource, float dx, float dy, int displayId) {
	final long now = SystemClock.uptimeMillis();
	injectMotionEvent(inputSource, MotionEvent.ACTION_MOVE, now, now, dx, dy, 0.0f,
	displayId);
	}
	}

	class InputMotionEvent implements InputCmd {
	@Override
	public void run(int inputSource, int displayId) {
	inputSource = getSource(inputSource, InputDevice.SOURCE_TOUCHSCREEN);
	sendMotionEvent(inputSource, nextArgRequired(), Float.parseFloat(nextArgRequired()),
	Float.parseFloat(nextArgRequired()), displayId);
	}

	private void sendMotionEvent(int inputSource, String motionEventType, float x, float y,
	int displayId) {
	final int action;
	final float pressure;

	switch (motionEventType.toUpperCase()) {
	case "DOWN":
	action = MotionEvent.ACTION_DOWN;
	pressure = DEFAULT_PRESSURE;
	break;
	case "UP":
	action = MotionEvent.ACTION_UP;
	pressure = NO_PRESSURE;
	break;
	case "MOVE":
	action = MotionEvent.ACTION_MOVE;
	pressure = DEFAULT_PRESSURE;
	break;
	default:
	throw new IllegalArgumentException("Unknown motionevent " + motionEventType);
	}

	final long now = SystemClock.uptimeMillis();
	injectMotionEvent(inputSource, action, now, now, x, y, pressure, displayId);
	}
	}

	/**
	* Abstract class for command
	* use nextArgRequired or nextArg to check next argument if necessary.
	*/
	private interface InputCmd {
	void run(int inputSource, int displayId);
	}

	private static void injectKeyEvent(KeyEvent event) {
	InputManager.getInstance().injectInputEvent(event,
	InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH);
	}

	private static int getInputDeviceId(int inputSource) {
	final int DEFAULT_DEVICE_ID = 0;
	int[] devIds = InputDevice.getDeviceIds();
	for (int devId : devIds) {
	InputDevice inputDev = InputDevice.getDevice(devId);
	if (inputDev.supportsSource(inputSource)) {
	return devId;
	}
	}
	return DEFAULT_DEVICE_ID;
	}

	/**
	* Builds a MotionEvent and injects it into the event stream.
	*
	* @param inputSource the InputDevice.SOURCE_* sending the input event
	* @param action the MotionEvent.ACTION_* for the event
	* @param downTime the value of the ACTION_DOWN event happened
	* @param when the value of SystemClock.uptimeMillis() at which the event happened
	* @param x x coordinate of event
	* @param y y coordinate of event
	* @param pressure pressure of event
	*/
	private static void injectMotionEvent(int inputSource, int action, long downTime, long when,
	float x, float y, float pressure, int displayId) {
	final float DEFAULT_SIZE = 1.0f;
	final int DEFAULT_META_STATE = 0;
	final float DEFAULT_PRECISION_X = 1.0f;
	final float DEFAULT_PRECISION_Y = 1.0f;
	final int DEFAULT_EDGE_FLAGS = 0;
	MotionEvent event = MotionEvent.obtain(downTime, when, action, x, y, pressure, DEFAULT_SIZE,
	DEFAULT_META_STATE, DEFAULT_PRECISION_X, DEFAULT_PRECISION_Y,
	getInputDeviceId(inputSource), DEFAULT_EDGE_FLAGS);
	event.setSource(inputSource);
	if (displayId == INVALID_DISPLAY && (inputSource & InputDevice.SOURCE_CLASS_POINTER) != 0) {
	displayId = DEFAULT_DISPLAY;
	}
	event.setDisplayId(displayId);
	InputManager.getInstance().injectInputEvent(event,
	InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH);
	}

	private static final float lerp(float a, float b, float alpha) {
	return (b - a) * alpha + a;
	}

	private static final int getSource(int inputSource, int defaultSource) {
	return inputSource == InputDevice.SOURCE_UNKNOWN ? defaultSource : inputSource;
	}

	@Override
	public void onShowUsage(PrintStream out) {
	out.println("Usage: input [<source>] [-d DISPLAY_ID] <command> [<arg>...]");
	out.println();
	out.println("The sources are: ");
	for (String src : SOURCES.keySet()) {
	out.println(" " + src);
	}
	out.println();
	out.printf("-d: specify the display ID.\n"
	+ " (Default: %d for key event, %d for motion event if not specified.)",
	INVALID_DISPLAY, DEFAULT_DISPLAY);
	out.println();
	out.println("The commands and default sources are:");
	out.println(" text <string> (Default: touchscreen)");
	out.println(" keyevent [--longpress] <key code number or name> ..."
	+ " (Default: keyboard)");
	out.println(" tap <x> <y> (Default: touchscreen)");
	out.println(" swipe <x1> <y1> <x2> <y2> [duration(ms)]"
	+ " (Default: touchscreen)");
	out.println(" draganddrop <x1> <y1> <x2> <y2> [duration(ms)]"
	+ " (Default: touchscreen)");
	out.println(" press (Default: trackball)");
	out.println(" roll <dx> <dy> (Default: trackball)");
	out.println(" motionevent <DOWN\|UP\|MOVE> <x> <y> (Default: touchscreen)");
	}
	}