1 /*
2 * Copyright (c) 2007, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package org.jemmy.input;
24
25
26 import java.awt.EventQueue;
27 import java.awt.image.BufferedImage;
28 import java.io.BufferedReader;
29 import java.io.File;
30 import java.io.IOException;
31 import java.io.InputStreamReader;
32 import java.io.ObjectInputStream;
33 import java.io.ObjectOutputStream;
34 import java.io.OptionalDataException;
35 import java.io.PrintWriter;
36 import java.lang.reflect.Field;
37 import java.lang.reflect.InvocationTargetException;
38 import java.lang.reflect.Modifier;
39 import java.net.ServerSocket;
40 import java.net.Socket;
41 import java.net.UnknownHostException;
42 import java.util.Arrays;
43 import java.util.HashSet;
44 import java.util.Set;
45 import java.util.logging.Level;
46 import java.util.logging.Logger;
47 import org.jemmy.JemmyException;
48 import org.jemmy.Rectangle;
49 import org.jemmy.env.Environment;
50 import org.jemmy.env.Timeout;
51 import org.jemmy.image.AWTImage;
52 import org.jemmy.image.Image;
53 import org.jemmy.image.PNGDecoder;
54 import org.jemmy.image.PNGEncoder;
55 import org.jemmy.timing.State;
56 import org.jemmy.timing.Waiter;
57 import org.jemmy.interfaces.Keyboard.KeyboardButton;
58 import org.jemmy.interfaces.Mouse.MouseButton;
59
60 /**
61 * TODO: This code is inherently not thread safe
62 * @author КАМ
63 */
64 class RobotExecutor {
65
66 private static RobotExecutor instance;
67 private AWTMap awtMap = null;
68
69 public static RobotExecutor get() {
70 if (instance == null) {
71 instance = new RobotExecutor();
72 }
73 return instance;
74 }
75
76 /**
77 * A reference to the robot instance.
78 */
79 protected ClassReference robotReference = null;
80 protected Timeout autoDelay;
81 private boolean inited = false;
82 private boolean runInOtherJVM = false;
83 private boolean ready = false;
84 private boolean connectionEstablished = false;
85 private ObjectOutputStream outputStream;
86 private ObjectInputStream inputStream;
87 private Socket socket;
88 private int connectionPort;
89 private String connectionHost;
90 public static final int CONNECTION_TIMEOUT = Integer.parseInt(
91 (String)Environment.getEnvironment().getProperty(
92 AWTRobotInputFactory.OTHER_VM_CONNECTION_TIMEOUT_PROPERTY,
93 Integer.toString(60000 * 15))); // 15 min
94
95 public RobotExecutor() {
96 }
97
98 void setAWTMap(AWTMap awtMap) {
99 this.awtMap = awtMap;
100 }
101
102 AWTMap getAWTMap() {
103 if (awtMap == null) {
104 awtMap = new AWTMap();
105 }
106 return awtMap;
107 }
108
109 private void ensureInited() {
110 if (!inited) {
111 runInOtherJVM = Boolean.parseBoolean((String)Environment.getEnvironment()
112 .getProperty(AWTRobotInputFactory.OTHER_VM_PROPERTY,
113 Boolean.toString(runInOtherJVM)));
114 inited = true;
115 }
116 }
117
118 public Image createScreenCapture(Rectangle screenRect) {
119 Object result = makeAnOperation("createScreenCapture", new Object[] {
120 new java.awt.Rectangle(screenRect.x, screenRect.y, screenRect.width,
121 screenRect.height) },
122 new Class[] { java.awt.Rectangle.class });
123 if (result.getClass().isAssignableFrom(BufferedImage.class)) {
124 return new AWTImage(BufferedImage.class.cast(result));
125 } else {
126 throw new JemmyException("Screen capture (" + result
127 + ") is not a BufferedImage");
128 }
129 }
130
131 public Object makeAnOperation(String method, Object[] params, Class[] paramClasses) {
132 ensureInited();
133 if (runInOtherJVM) {
134 return makeAnOperationRemotely(method, params, paramClasses);
135 } else {
136 return makeAnOperationLocally(method, params, paramClasses);
137 }
138 }
139
140 public void exit() {
141 ensureInited();
142 if (runInOtherJVM) {
143 ensureConnection();
144 try {
145 outputStream.writeObject("exit");
146 connectionEstablished = false;
147 deleteProperties();
148 } catch (IOException ex) {
149 throw new JemmyException("Failed to invoke exit", ex);
150 }
151 }
152 }
153
154 private Object makeAnOperationLocally(String method, Object[] params, Class[] paramClasses) {
155 if (robotReference == null) {
156 initRobot();
157 }
158 try {
159 convert(method, params, paramClasses);
160 Object result = robotReference.invokeMethod(method, params, paramClasses);
161 synchronizeRobot();
162 return result;
163 } catch (InvocationTargetException e) {
164 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
165 } catch (IllegalStateException e) {
166 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
167 } catch (NoSuchMethodException e) {
168 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
169 } catch (IllegalAccessException e) {
170 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
171 }
172 }
173
174 private int convert(Object obj) {
175 if (MouseButton.class.isAssignableFrom(obj.getClass())) {
176 return awtMap.convert((MouseButton)obj);
177 } else if (KeyboardButton.class.isAssignableFrom(obj.getClass())) {
178 return awtMap.convert((KeyboardButton)obj);
179 } else {
180 throw new JemmyException("Unable to recognize object", obj);
181 }
182 }
183
184 private static final Set<String> convertables = new HashSet<String>(Arrays.asList(new String[] {"mousePress", "mouseRelease", "keyPress", "keyRelease"}));
185
186 private void convert(String method, Object[] params, Class[] paramClasses) {
187 if (convertables.contains(method))
188 for (int i = 0; i < params.length; i++) {
189 params[i] = new Integer(convert(params[i]));
190 paramClasses[i] = Integer.TYPE;
191 }
192 }
193
194 public static void main(String[] args) {
195 System.setProperty("apple.awt.UIElement", "true");
196 if (args.length != 0 && args.length != 1) {
197 System.err.println("Usage: java ... [-D" +
198 Environment.JEMMY_PROPERTIES_FILE_PROPERTY + "=" +
199 "<.jemmy.properties full path>]" +
200 " RobotExecutor [connectionPort]");
201 System.exit(-1);
202 }
203 if (args.length == 1) {
204 Environment.getEnvironment().setProperty(
205 AWTRobotInputFactory.OTHER_VM_PORT_PROPERTY, args[0]);
206 }
207 RobotExecutor re = new RobotExecutor();
208 try {
209 re.server();
210 } catch (Exception ex) {
211 ex.printStackTrace(System.err);
212 System.err.flush();
213 System.exit(-1);
214 }
215 }
216
217 private File props;
218
219 private void deleteProperties() {
220 if (props != null) {
221 props.delete();
222 props = null;
223 }
224 }
225
226 private void prepareProperties() {
227 deleteProperties();
228 try {
229 props = File.createTempFile(".jemmy.othervm.", ".properties");
230 props.deleteOnExit();
231 PrintWriter fw = new PrintWriter(props);
232 for(Field f : AWTRobotInputFactory.class.getDeclaredFields()) {
233 if ((f.getModifiers() & Modifier.FINAL) != 0 &&
234 (f.getModifiers() & Modifier.STATIC) != 0 &&
235 f.getType().equals(String.class) &&
236 f.getName().startsWith("OTHER_VM_") &&
237 Environment.getEnvironment().getProperty((String)f.get(null)) != null) {
238 fw.println(f.get(null) + "=" + Environment.getEnvironment().getProperty((String)f.get(null)));
239 }
240 }
241 fw.close();
242 } catch (IllegalArgumentException ex) {
243 throw new JemmyException("Failed to create temporary properties file: " + props.getAbsolutePath(), ex);
244 } catch (IllegalAccessException ex) {
245 throw new JemmyException("Failed to create temporary properties file: " + props.getAbsolutePath(), ex);
246 } catch (IOException ex) {
247 throw new JemmyException("Failed to create temporary properties file: " + props.getAbsolutePath(), ex);
248 }
249
250 }
251
252 private void startServer() {
253 try {
254 prepareProperties();
255 ProcessBuilder pb = new ProcessBuilder("java",
256 //"-Xrunjdwp:transport=dt_socket,suspend=y,server=y,address=8000",
257 "-cp", System.getProperty("java.class.path"),
258 "-D" + Environment.JEMMY_PROPERTIES_FILE_PROPERTY +
259 "=" + props.getAbsolutePath(),
260 RobotExecutor.class.getName(),
261 Integer.toString(connectionPort));
262 // TODO: Improve output
263 // System.out.println("Starting server");
264 // System.out.println("Command: " + pb.command());
265 // System.out.flush();
266 pb.redirectErrorStream(true);
267 final Process p = pb.start();
268 new Thread() {
269
270 @Override
271 public void run() {
272 BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
273 while (true) {
274 try {
275 String line = br.readLine();
276 if (line == null) {
277 break;
278 }
279 System.out.println("SERVER: " + line);
280 } catch (IOException ex) {
281 throw new JemmyException("Exception during other JVM output processing", ex);
282 }
283 }
284 }
285 }.start();
286 } catch (IOException ex) {
287 throw new JemmyException("Failed to start other JVM", ex);
288 }
289 }
290
291 public void ensureConnection() {
292 ensureInited();
293 if (runInOtherJVM && !connectionEstablished) {
294 initClientConnection();
295 }
296 }
297
298 private void initClientConnection() {
299 connectionHost = (String)Environment.getEnvironment().getProperty(
300 AWTRobotInputFactory.OTHER_VM_HOST_PROPERTY, "localhost");
301 connectionPort = Integer.parseInt((String)Environment.getEnvironment()
302 .getProperty(AWTRobotInputFactory.OTHER_VM_PORT_PROPERTY,
303 "53669"));
304 try {
305 try {
306 socket = new Socket(connectionHost, connectionPort);
307 } catch (IOException ex) {
308 if ("localhost".equalsIgnoreCase(connectionHost)
309 || "127.0.0.1".equals(connectionHost)) {
310 // TODO Improve check for localhost
311 startServer();
312 Environment.getEnvironment().getTimeout("");
313 Timeout waitTime = new Timeout("connection wait time", 5 * 60000);
314 socket = new Waiter(waitTime).ensureState(new State<Socket>() {
315 Exception ex;
316 public Socket reached() {
317 Socket socket = null;
318 try {
319 socket = new Socket(connectionHost, connectionPort);
320 } catch (UnknownHostException ex1) {
321 ex = ex1;
322 } catch (Exception ex1) {
323 ex = ex1;
324 }
325 return socket;
326 }
327
328 @Override
329 public String toString() {
330 if (ex != null) {
331 // TODO: Provide better mechanics for exception handling
332 Logger.getLogger(RobotExecutor.class.getName())
333 .log(Level.INFO, null, ex);
334 }
335 return "Waiting for connection to be established " +
336 "with other JVM (" + connectionHost
337 + ":" + connectionPort + ", exception: " + ex + ")";
338 }
339 });
340 } else {
341 throw new JemmyException("Failed to establish socket " +
342 "connection with other JVM (" + connectionHost
343 + ":" + connectionPort + ")", ex);
344 }
345 }
346 outputStream = new ObjectOutputStream(socket.getOutputStream());
347 inputStream = new ObjectInputStream(socket.getInputStream());
348
349 connectionEstablished = true;
350 ready = true;
351
352 System.out.println("Connection established!");
353 setAutoDelay(autoDelay);
354 } catch (IOException ex) {
355 throw new JemmyException("Failed to establish socket connection " +
356 "with other JVM (" + connectionHost + ":" + connectionPort
357 + ")", ex);
358 }
359 }
360
361 public synchronized Object getProperty(String name) {
362 ensureConnection();
363 try {
364 outputStream.writeObject("getProperty");
365 outputStream.writeObject(name);
366 Object result = inputStream.readObject();
367 String response = (String)(inputStream.readObject());
368 if (!"OK".equals(response)) {
369 throw new JemmyException("Remote operation didn't succeed");
370 }
371 return result;
372 } catch (ClassNotFoundException ex) {
373 throw new JemmyException("Socket communication with other JVM failed", ex);
374 } catch (OptionalDataException ex) {
375 throw new JemmyException("Socket communication with other JVM " +
376 "failed: OptionalDataException eof = " + ex.eof + ", " +
377 "length = " + ex.length, ex);
378 } catch (IOException ex) {
379 throw new JemmyException("Socket communication with other JVM failed", ex);
380 }
381 }
382
383 private synchronized Object makeAnOperationRemotely(String method, Object[] params, Class[] paramClasses) {
384 ensureConnection();
385 try {
386 outputStream.writeObject("makeAnOperation");
387 outputStream.writeObject(method);
388 outputStream.writeObject(params);
389 outputStream.writeObject(paramClasses);
390 Object result;
391 String response = (String)(inputStream.readObject());
392 if ("image".equals(response)) {
393 result = PNGDecoder.decode(inputStream, false);
394 } else {
395 if (!"OK".equals(response)) {
396 throw new JemmyException("Remote operation didn't succeed");
397 }
398 result = inputStream.readObject();
399 }
400 return result;
401 } catch (ClassNotFoundException ex) {
402 throw new JemmyException("Socket communication with other JVM failed", ex);
403 } catch (OptionalDataException ex) {
404 throw new JemmyException("Socket communication with other JVM " +
405 "failed: OptionalDataException eof = " + ex.eof + ", " +
406 "length = " + ex.length, ex);
407 } catch (IOException ex) {
408 throw new JemmyException("Socket communication with other JVM failed", ex);
409 }
410 }
411
412 private void server() {
413 System.out.println("Robot ready!");
414 System.out.flush();
415 ServerSocket sc;
416 connectionPort = Integer.parseInt((String)Environment.getEnvironment()
417 .getProperty(AWTRobotInputFactory.OTHER_VM_PORT_PROPERTY,
418 "53669"));
419 while(true) {
420 Thread watchdog = new Thread("RobotExecutor.server watchdog") {
421
422 @Override
423 public void run() {
424 try {
425 Thread.sleep(CONNECTION_TIMEOUT);
426 System.out.println("Exiting server as there is no " +
427 "connection for " + CONNECTION_TIMEOUT / 60000.0
428 + " minutes");
429 System.out.flush();
430 System.exit(0);
431 } catch (InterruptedException ex) {
432 // Ignoring exception as it is okay
433 }
434 }
435
436 };
437 watchdog.start();
438 System.out.println("Waiting for incoming connection for up to "
439 + CONNECTION_TIMEOUT / 60000.0 + " minutes");
440 try {
441 sc = new ServerSocket(connectionPort);
442 socket = sc.accept();
443 watchdog.interrupt();
444 } catch (IOException ex) {
445 throw new JemmyException("Can't establish connection with client", ex);
446 }
447 System.out.println("Connection established!");
448 try {
449 inputStream = new ObjectInputStream(socket.getInputStream());
450 outputStream = new ObjectOutputStream(socket.getOutputStream());
451 while(true) {
452 String command = (String)inputStream.readObject();
453 if ("exit".equals(command)) {
454 System.exit(0);
455 }
456 if ("getProperty".equals(command)) {
457 String property = (String)inputStream.readObject();
458 outputStream.writeObject(Environment.getEnvironment().getProperty(property));
459 outputStream.writeObject("OK");
460 }
461 if ("makeAnOperation".equals(command)) {
462 String method = (String)inputStream.readObject();
463 Object[] params = (Object[])inputStream.readObject();
464 Class[] paramClasses = (Class[])inputStream.readObject();
465 Object result = makeAnOperationLocally(method, params,
466 paramClasses);
467 if (result instanceof BufferedImage) {
468 outputStream.writeObject("image");
469 BufferedImage image = BufferedImage.class.cast(result);
470 new PNGEncoder(outputStream, PNGEncoder.COLOR_MODE)
471 .encode(image, false);
472 } else {
473 outputStream.writeObject("OK");
474 outputStream.writeObject(result);
475 }
476 }
477 }
478 } catch (ClassNotFoundException ex) {
479 throw new JemmyException("Socket communication with other " +
480 "JVM failed", ex);
481 } catch (IOException ex) {
482 Logger.getLogger(RobotExecutor.class.getName())
483 .log(Level.SEVERE, null, ex);
484 } finally {
485 if (socket != null) {
486 try {
487 socket.close();
488 } catch (IOException ex) {
489 Logger.getLogger(RobotExecutor.class.getName()).log(
490 Level.SEVERE, "Exception during socket closing", ex);
491 }
492 }
493 if (sc != null) {
494 try {
495 sc.close();
496 } catch (IOException ex) {
497 Logger.getLogger(RobotExecutor.class.getName()).log(
498 Level.SEVERE, "Exception during server socket " +
499 "closing", ex);
500 }
501 }
502 }
503 }
504 }
505
506 private void initRobot() {
507 // need to init Robot in dispatch thread because it hangs on Linux
508 // (see http://www.netbeans.org/issues/show_bug.cgi?id=37476)
509 if (EventQueue.isDispatchThread()) {
510 doInitRobot();
511 } else {
512 try {
513 EventQueue.invokeAndWait(new Runnable() {
514
515 public void run() {
516 doInitRobot();
517 }
518 });
519 } catch (InterruptedException ex) {
520 throw new JemmyException("Failed to initialize robot", ex);
521 } catch (InvocationTargetException ex) {
522 throw new JemmyException("Failed to initialize robot", ex);
523 }
524 }
525 }
526
527 private void doInitRobot() {
528 try {
529 ClassReference robotClassReverence = new ClassReference("java.awt.Robot");
530 robotReference = new ClassReference(robotClassReverence.newInstance(null, null));
531 if (awtMap == null) {
532 awtMap = new AWTMap();
533 }
534 setAutoDelay(autoDelay);
535 ready = true;
536 } catch (InvocationTargetException e) {
537 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
538 } catch (IllegalStateException e) {
539 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
540 } catch (NoSuchMethodException e) {
541 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
542 } catch (IllegalAccessException e) {
543 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
544 } catch (ClassNotFoundException e) {
545 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
546 } catch (InstantiationException e) {
547 throw (new JemmyException("Exception during java.awt.Robot accessing", e));
548 }
549 }
550
551 /**
552 * Calls <code>java.awt.Robot.waitForIdle()</code> method.
553 */
554 protected void synchronizeRobot() {
555 ensureInited();
556 if (!runInOtherJVM) {
557 // TODO: It looks like this method is rudimentary
558 if (!EventQueue.isDispatchThread()) {
559 if (robotReference == null) {
560 initRobot();
561 }
562 try {
563 robotReference.invokeMethod("waitForIdle", null, null);
564 } catch (Exception e) {
565 e.printStackTrace();
566 }
567 }
568 }
569 }
570
571 public void setAutoDelay(Timeout autoDelay) {
572 this.autoDelay = autoDelay;
573 if (ready) {
574 makeAnOperation("setAutoDelay", new Object[]{new Integer((int) ((autoDelay != null) ? autoDelay.getValue() : 0))}, new Class[]{Integer.TYPE});
575 }
576 }
577
578 public boolean isRunInOtherJVM() {
579 ensureInited();
580 return runInOtherJVM;
581 }
582
583 public void setRunInOtherJVM(boolean runInOtherJVM) {
584 if (inited && this.runInOtherJVM && this.connectionEstablished && !runInOtherJVM) {
585 shutdownConnection();
586 }
587 this.runInOtherJVM = runInOtherJVM;
588 inited = true;
589 ready = false;
590 }
591
592 private void shutdownConnection() {
593 try {
594 outputStream.writeObject("exit");
595 socket.close();
596 connectionEstablished = false;
597 } catch (IOException ex) {
598 throw new JemmyException("Failed to shutdown connection", ex);
599 }
600 }
601 }