Changeset 1783

Timestamp:

10/08/14 10:02:37 (10 years ago)

Author:

funger

Message:

Parser for onClick events only. Using MouseClick? to simulate onClick events.

Location:

trunk/autoquest-plugin-android/src/main/java/de/ugoe/cs/autoquest/plugin/android

Files:

• AndroidLogParser.java (modified) (1 diff)
• commands (added)
• commands/CMDparseAndroid.java (added)
• commands/CMDparseDirAndroid.java (added)
• guimodel (added)
• guimodel/AndroidButton.java (added)
• guimodel/AndroidFrame.java (added)
• guimodel/AndroidGUIElement.java (added)
• guimodel/AndroidGUIElementSpec.java (added)

trunk/autoquest-plugin-android/src/main/java/de/ugoe/cs/autoquest/plugin/android/AndroidLogParser.java

@@ +1 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   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 de.ugoe.cs.autoquest.plugin.android;
 
-public class AndroidLogParser {
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
+import de.ugoe.cs.autoquest.eventcore.guimodel.GUIElementTree;
+import de.ugoe.cs.autoquest.eventcore.guimodel.GUIModel;
+import de.ugoe.cs.autoquest.eventcore.guimodel.GUIModelException;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.plugin.android.guimodel.AndroidGUIElementSpec;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ * <p>
+ * This class provides functionality to parse XML log files generated by the
+ * AndroidMonitor of autoquest. The result of parsing a file is a collection of
+ * event sequences.
+ * </p>
+ * 
+ * @author Florian Unger
+ * @version 1.0
+ */
+public class AndroidLogParser extends DefaultHandler {
+
+        /*
+         * (non-Javadoc)
+         * 
+         * int java.lang.Object.hashCode() is used in the Androidmonitor Long is
+         * used to internally handle and compare the number. e.g.
+         * currentGUIElementHash != null
+         */
+        /**
+         * <p>
+         * Internal handle to the id of the event that is currently being parsed.
+         * </p>
+         */
+        private String currentEventId;
+
+        /**
+         * <p>
+         * Internal handle to the parameters of the event currently being parsed.
+         * </p>
+         */
+        private Map<String, String> currentEventParameters;
+
+        /**
+         * <p>
+         * Internal handle to the source of the event that is currently being
+         * parsed.
+         * </p>
+         */
+        private Long currentEventSource;
+
+        /**
+         * <p>
+         * Internal handle to the timestamp of the event that is currently being
+         * parsed.
+         */
+        private Long currentEventTimestamp = -1l;
+
+        /**
+         * 
+         * <p>
+         * Internal handle to the hashcode of the GUI element, that is currently
+         * parsed.
+         * </p>
+         */
+        private Long currentGUIElementHash;
+
+        /**
+         * <p>
+         * internal handle to the parsed GUI structure, stored in a GUIElementTree
+         * </p>
+         */
+        private GUIElementTree<Long> currentGUIElementTree;
+
+        /**
+         * <p>
+         * internal handle to the specification currently parsed for a GUI element
+         * </p>
+         */
+        private AndroidGUIElementSpec currentGUIElementSpec;
+
+        /**
+         * 
+         * <p>
+         * Internal handle to the hashcode of the parent of the GUI element, that is
+         * currently parsed.
+         * </p>
+         */
+        private Long currentParentHash;
+
+        /**
+         * <p>
+         * Internal handle to the event sequence that is currently being parsed.
+         * </p>
+         */
+        private List<Event> currentSequence;
+
+        /**
+         * <p>
+         * Internal handle to the event sequence that is currently being parsed.
+         * </p>
+         */
+        // private List<Event> currentSequence;
+
+        /**
+         * <p>
+         * Map that holds events that had no registered target GUI element during
+         * parsing. Keys are the IDs of the unregistered targets.
+         * </p>
+         */
+        private Map<Long, List<Event>> eventsWithoutTargets;
+
+        /**
+         * <p>
+         * Collection of event sequences that is contained in the log file, which is
+         * parsed.
+         * </p>
+         */
+        private Collection<List<Event>> sequences;
+
+        /**
+         * <p>
+         * Constructor. Creates a new AndroidLogParser.
+         * </p>
+         */
+        public AndroidLogParser() {
+                sequences = new LinkedList<List<Event>>();
+                // currentSequence = null;
+        }
+
+        // TODO create a constructor which creates a new AndroidLogParser with a
+        // specific event filter.
+
+        /**
+         * <p>
+         * Parses a log file written by the JFCMonitor and creates a collection of
+         * event sequences.
+         * </p>
+         * 
+         * @param filename
+         *            name and path of the log file
+         */
+        public void parseFile(String filename) {
+                if (filename == null) {
+                        throw new IllegalArgumentException("filename must not be null");
+                }
+
+                parseFile(new File(filename));
+        }
+
+        /**
+         * <p>
+         * Parses a log file written by the JFCMonitor and creates a collection of
+         * event sequences.
+         * </p>
+         * 
+         * @param file
+         *            name and path of the log file
+         */
+        public void parseFile(File file) {
+                if (file == null) {
+                        throw new IllegalArgumentException("file must not be null");
+                }
+
+                SAXParserFactory spf = SAXParserFactory.newInstance();
+                // set true to validate that the file is well defined
+                spf.setValidating(true);
+
+                SAXParser saxParser = null;
+                InputSource inputSource = null;
+                try {
+                        saxParser = spf.newSAXParser();
+                        inputSource = new InputSource(new InputStreamReader(
+                                        new FileInputStream(file), "UTF-8"));
+                } catch (UnsupportedEncodingException e) {
+                        Console.printerr("Error parsing file + " + file.getName());
+                        Console.logException(e);
+                        return;
+                } catch (ParserConfigurationException e) {
+                        Console.printerr("Error parsing file + " + file.getName());
+                        Console.logException(e);
+                        return;
+                } catch (SAXException e) {
+                        Console.printerr("Error parsing file + " + file.getName());
+                        Console.logException(e);
+                        return;
+                } catch (FileNotFoundException e) {
+                        Console.printerr("Error parsing file + " + file.getName());
+                        Console.logException(e);
+                        return;
+                }
+                if (inputSource != null) {
+                        inputSource.setSystemId("file://" + file.getAbsolutePath());
+                        try {
+                                // called a second time to be sure that no error happens
+                                if (saxParser == null) {
+                                        throw new RuntimeException("SAXParser creation failed");
+                                }
+                                saxParser.parse(inputSource, this);
+                        } catch (SAXParseException e) {
+                                Console.printerrln("Failure parsing file in line "
+                                                + e.getLineNumber() + ", column " + e.getColumnNumber()
+                                                + ".");
+                                Console.logException(e);
+                                return;
+                        } catch (SAXException e) {
+                                Console.printerr("Error parsing file + " + file.getName());
+                                Console.logException(e);
+                                return;
+                        } catch (IOException e) {
+                                Console.printerr("Error parsing file + " + file.getName());
+                                Console.logException(e);
+                                return;
+                        }
+                }
+                if (!eventsWithoutTargets.isEmpty()) {
+                        Console.printerr("Some events reference GUI elements that are not part of logfile. "
+                                        + "These events have been parsed without target.");
+                }
+        }
+
+        /**
+         * <p>
+         * Returns the collection of event sequences that is obtained from parsing
+         * log files.
+         * </p>
+         * 
+         * @return collection of event sequences
+         */
+        public Collection<List<Event>> getSequences() {
+                return sequences;
+        }
+
+        /**
+         * <p>
+         * Returns the GUI model that is obtained from parsing log files.
+         * </p>
+         * 
+         * @return GUIModel
+         */
+        public GUIModel getGuiModel() {
+                return currentGUIElementTree.getGUIModel();
+        }
+
+        /*
+         * (non-Javadoc)
+         * 
+         * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String,
+         * java.lang.String, java.lang.String, org.xml.sax.Attributes)
+         */
+        public void startElement(String uri, String localName, String qName,
+                        Attributes atts) throws SAXException {
+                if (qName.equals("sessions")) {
+                        // currentSequence = new LinkedList<Event>(); Up to know it is
+                        // necessary to handle different sessions. All components are known
+                        // before an event occurs.
+                        if (currentGUIElementTree == null)
+                                currentGUIElementTree = new GUIElementTree<Long>();
+                }
+
+                if (qName.equals("component")) {
+                        currentGUIElementHash = Long.parseLong(atts.getValue("hash"));
+                        currentGUIElementSpec = new AndroidGUIElementSpec();
+                        currentGUIElementSpec.setHashCode((int) currentGUIElementHash
+                                        .longValue());
+                } else if (qName.equals("event")) {
+                        currentEventId = atts.getValue("id");
+                        currentEventParameters = new HashMap<String, String>();
+
+                } else if (qName.equals("param")) {
+                        if (currentGUIElementHash != null) {
+                                if ("class".equals(atts.getValue("name"))) {
+                                        currentGUIElementSpec.setType(atts.getValue("value"));
+                                } else if ("path".equals(atts.getValue("name"))) {
+                                        currentGUIElementSpec.setPath(atts.getValue("value"));
+                                } else if ("id".equals(atts.getValue("name"))) {
+                                        currentGUIElementSpec.setIndex(Integer.parseInt(atts
+                                                        .getValue("value")));
+                                } else if ("parent".equals(atts.getValue("name"))) {
+                                        currentParentHash = Long.parseLong(atts.getValue("value"));
+                                }
+                        } else if (currentEventId != null) {
+                                if ("source".equals(atts.getValue("name"))) {
+                                        currentEventSource = Long.parseLong(atts.getValue("value"));
+                                }
+                                if ("timestamp".equals(atts.getValue("name"))) {
+                                        currentEventTimestamp = Long.parseLong(atts
+                                                        .getValue("value"));
+                                }
+                                currentEventParameters.put(atts.getValue("name"),
+                                                atts.getValue("value"));
+                        }
+                }
+
+                // TODO add hierarchy information if available -> Up to know gathering
+                // this information leads to an out of memory exception in the
+                // androidmonitor @see: AndroidmonitorLogFile#addComponent
+        }
+
+        /*
+         * (non-Javadoc)
+         * 
+         * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String,
+         * java.lang.String, java.lang.String)
+         */
+        @Override
+        public void endElement(String uri, String localName, String qName)
+                        throws SAXException {
+                if (qName.equals("component") && currentGUIElementHash != null) {
+                        try {
+                                currentGUIElementTree.add(currentGUIElementHash,
+                                                currentParentHash, currentGUIElementSpec);
+                        } catch (GUIModelException e) {
+                                throw new SAXException(
+                                                "could not handle GUI element with hash "
+                                                                + currentGUIElementHash + ": " + e.getMessage(),
+                                                e);
+                        }
+                        currentGUIElementHash = null;
+                        currentParentHash = null;
+                } else if (currentEventId != null) {
+                        if (qName.equals("event")) {
+                                IGUIElement currentGUIElement;
+                                currentGUIElement = currentGUIElementTree
+                                                .find(currentEventSource);
+                                Event event;
+
+                                // up to now only onClick events are implemented and each
+                                // onclick event is processed as a mouse click
+                                int x = Integer.parseInt(currentEventParameters.get("X"));
+                                int y = Integer.parseInt(currentEventParameters.get("Y"));
+                                MouseButtonInteraction.Button button = null;
+                                button = MouseButtonInteraction.Button.LEFT;
+
+                                // maybe it would be necessary in the future to check weather
+                                // the GUI element exits.
+                                event = new Event(new MouseClick(button, x, y),
+                                                currentGUIElement);
+
+                                event.setTimestamp(currentEventTimestamp);
+                                currentSequence.add(event);
+
+                                currentEventParameters = null;
+                                currentEventId = null;
+                                currentEventTimestamp = -1l;
+                        }
+                } else if (qName.equals("sessions")) {
+                        if (currentSequence != null) {
+                                sequences.add(currentSequence);
+                        }
+                }
+        }
 
 }