-
-
Notifications
You must be signed in to change notification settings - Fork 230
/
AccessibilityNodeInfoDumper.java
390 lines (357 loc) · 16.1 KB
/
AccessibilityNodeInfoDumper.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
/*
* Copyright (C) 2012 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 io.appium.uiautomator2.core;
import android.graphics.Point;
import android.os.SystemClock;
import android.util.SparseArray;
import android.util.Xml;
import android.view.Display;
import android.view.View;
import android.view.accessibility.AccessibilityNodeInfo;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import org.apache.xerces.jaxp.DocumentBuilderFactoryImpl;
import org.eclipse.wst.xml.xpath2.api.Item;
import org.eclipse.wst.xml.xpath2.api.ResultSequence;
import org.eclipse.wst.xml.xpath2.api.XPath2Expression;
import org.eclipse.wst.xml.xpath2.processor.Engine;
import org.eclipse.wst.xml.xpath2.processor.XPathParserException;
import org.eclipse.wst.xml.xpath2.processor.util.DynamicContextBuilder;
import org.eclipse.wst.xml.xpath2.processor.util.StaticContextBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.xmlpull.v1.XmlSerializer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.Semaphore;
import io.appium.uiautomator2.common.exceptions.InvalidSelectorException;
import io.appium.uiautomator2.common.exceptions.UiAutomator2Exception;
import io.appium.uiautomator2.model.NotificationListener;
import io.appium.uiautomator2.model.UiElement;
import io.appium.uiautomator2.model.UiElementSnapshot;
import io.appium.uiautomator2.model.settings.EnforceXpath1;
import io.appium.uiautomator2.model.settings.LimitXpathContextScope;
import io.appium.uiautomator2.model.settings.NormalizeTagNames;
import io.appium.uiautomator2.model.settings.Settings;
import io.appium.uiautomator2.utils.Attribute;
import io.appium.uiautomator2.utils.Logger;
import io.appium.uiautomator2.utils.NodeInfoList;
import io.appium.uiautomator2.utils.StringHelpers;
import static io.appium.uiautomator2.utils.AXWindowHelpers.getCachedWindowRoots;
import static io.appium.uiautomator2.utils.XMLHelpers.toNodeName;
import static io.appium.uiautomator2.utils.XMLHelpers.toSafeString;
import static net.gcardone.junidecode.Junidecode.unidecode;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
public class AccessibilityNodeInfoDumper {
private static final String UI_ELEMENT_INDEX = "uiElementIndex";
private static final String NON_XML_CHAR_REPLACEMENT = "?";
private static final String NAMESPACE = "";
private static final String DEFAULT_VIEW_CLASS_NAME = View.class.getName();
private static final String XML_ENCODING = "UTF-8";
private final Semaphore RESOURCES_GUARD = new Semaphore(1);
private static final XPathFactory XPATH_FACTORY = XPathFactory.newInstance();
@Nullable
private final AccessibilityNodeInfo root;
private final SparseArray<UiElement<?, ?>> uiElementsMapping = new SparseArray<>();
private final Set<Attribute> includedAttributes;
private boolean shouldAddDisplayInfo;
private XmlSerializer serializer;
public AccessibilityNodeInfoDumper(@Nullable AccessibilityNodeInfo root,
Set<Attribute> includedAttributes) {
this.root = root;
this.includedAttributes = includedAttributes;
}
private int matchRootElementIndex() {
if (root == null) {
throw new RuntimeException(
"Root node search query cannot be built if the root is unset"
);
}
for (int i = 0; i < uiElementsMapping.size(); ++i) {
if (Objects.equals(uiElementsMapping.valueAt(i).getNode(), root)) {
return uiElementsMapping.keyAt(i);
}
}
throw new RuntimeException("Cannot match the index of the root node");
}
@Nullable
private static Node matchRootElement(Node root, final int elementIndex) {
if (root instanceof Element
&& ((Element) root).hasAttribute(UI_ELEMENT_INDEX)
&& Integer.parseInt(((Element) root).getAttribute(UI_ELEMENT_INDEX)) == elementIndex
) {
return root;
}
if (!root.hasChildNodes()) {
return null;
}
NodeList childNodes = root.getChildNodes();
for (int i = 0; i < childNodes.getLength(); ++i) {
Node result = matchRootElement(childNodes.item(i), elementIndex);
if (result != null) {
return result;
}
}
return null;
}
@NonNull
private Node fetchContext(InputStream xml) {
Document doc = loadDocument(xml);
return root == null || Settings.get(LimitXpathContextScope.class).getValue()
? doc
: Objects.requireNonNull(
matchRootElement(doc.getDocumentElement(), matchRootElementIndex()),
"Cannot match the root element for the context-based XPath lookup"
);
}
private void addDisplayInfo() throws IOException {
Display display = UiAutomatorBridge.getInstance().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
serializer.attribute(NAMESPACE, "rotation", Integer.toString(display.getRotation()));
serializer.attribute(NAMESPACE, "width", Integer.toString(size.x));
serializer.attribute(NAMESPACE, "height", Integer.toString(size.y));
}
private static String toXmlNodeName(@Nullable String className) {
if (StringHelpers.isBlank(className)) {
return DEFAULT_VIEW_CLASS_NAME;
}
String fixedName = className
.replaceAll("[$@#&]", ".")
.replaceAll("\\.+", ".")
.replaceAll("(^\\.|\\.$)", "");
if (Settings.get(NormalizeTagNames.class).getValue()) {
// A workaround for the Apache Harmony bug described in https://github.com/appium/appium/issues/11854
// The buggy implementation: https://android.googlesource.com/platform/dalvik/+/21d27c095fee51fd6eac6a68d50b79df4dc97d85/libcore/xml/src/main/java/org/apache/harmony/xml/dom/DocumentImpl.java#84
fixedName = unidecode(fixedName).replaceAll("[^A-Za-z0-9\\-._]", "_");
}
fixedName = toNodeName(fixedName);
if (StringHelpers.isBlank(fixedName)) {
fixedName = DEFAULT_VIEW_CLASS_NAME;
}
if (!fixedName.equals(className)) {
Logger.info(String.format("Rewrote class name '%s' to XML node name '%s'", className, fixedName));
}
return fixedName;
}
private void serializeUiElement(UiElement<?, ?> uiElement, boolean isIndexed) throws IOException {
final String className = uiElement.getClassName();
final String nodeName = toXmlNodeName(className);
serializer.startTag(NAMESPACE, nodeName);
for (Attribute attr : uiElement.attributeKeys()) {
if (!attr.isExposableToXml()) {
continue;
}
Object value = uiElement.get(attr);
if (value == null) {
continue;
}
serializer.attribute(NAMESPACE, attr.getName(), toSafeString(String.valueOf(value), NON_XML_CHAR_REPLACEMENT));
}
if (shouldAddDisplayInfo) {
addDisplayInfo();
// Display info is only added once to the root node
shouldAddDisplayInfo = false;
}
final int uiElementIndex = uiElementsMapping.size();
uiElementsMapping.put(uiElementIndex, uiElement);
if (isIndexed) {
serializer.attribute(NAMESPACE, UI_ELEMENT_INDEX, Integer.toString(uiElementIndex));
}
for (UiElement<?, ?> child : uiElement.getChildren()) {
serializeUiElement(child, isIndexed);
}
serializer.endTag(NAMESPACE, nodeName);
}
private InputStream toStream(boolean isIndexed) throws IOException {
final long startTime = SystemClock.uptimeMillis();
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
serializer = Xml.newSerializer();
shouldAddDisplayInfo = root == null;
serializer.setOutput(outputStream, XML_ENCODING);
serializer.startDocument(XML_ENCODING, true);
serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
UiElement<?, ?> uiRootElement = root != null && Settings.get(LimitXpathContextScope.class).getValue()
? UiElementSnapshot.take(root, includedAttributes)
: UiElementSnapshot.take(
getCachedWindowRoots(), NotificationListener.getInstance().getToastMessage(),
includedAttributes
);
serializeUiElement(uiRootElement, isIndexed);
serializer.endDocument();
Logger.debug(String.format("The source XML tree (%s bytes) has been fetched in %sms",
outputStream.size(), SystemClock.uptimeMillis() - startTime));
return new ByteArrayInputStream(outputStream.toByteArray());
}
}
public String dumpToXml() {
try {
RESOURCES_GUARD.acquire();
} catch (InterruptedException e) {
throw new UiAutomator2Exception(e);
}
try (InputStream xmlStream = toStream(false)) {
return StringHelpers.inputStreamToString(xmlStream, Charset.forName(XML_ENCODING));
} catch (IOException e) {
throw new UiAutomator2Exception(e);
} finally {
uiElementsMapping.clear();
RESOURCES_GUARD.release();
}
}
private static Document loadDocument(InputStream in) {
DocumentBuilderFactory factory = new DocumentBuilderFactoryImpl();
factory.setNamespaceAware(true);
factory.setValidating(false);
try {
return factory.newDocumentBuilder().parse(in);
} catch (SAXException | ParserConfigurationException | IOException e) {
throw new RuntimeException(e);
}
}
private NodeInfoList findNodesUsingXpath1(String xpath1Selector, boolean multiple) {
final XPathExpression expression;
try {
expression = XPATH_FACTORY.newXPath().compile(xpath1Selector);
} catch (XPathExpressionException e) {
throw new InvalidSelectorException(e);
}
try {
RESOURCES_GUARD.acquire();
} catch (InterruptedException e) {
throw new UiAutomator2Exception(e);
}
try (InputStream xmlStream = toStream(true)) {
NodeList elements = (NodeList) expression.evaluate(
fetchContext(xmlStream), XPathConstants.NODESET
);
final NodeInfoList matchedNodes = new NodeInfoList();
final long timeStarted = SystemClock.uptimeMillis();
for (int i = 0; i < elements.getLength(); ++i) {
if (!(elements.item(i) instanceof Element)) {
continue;
}
Element item = (Element) elements.item(i);
if (!item.hasAttribute(UI_ELEMENT_INDEX)) {
continue;
}
UiElement<?, ?> uiElement = uiElementsMapping.get(
Integer.parseInt(item.getAttribute(UI_ELEMENT_INDEX))
);
if (uiElement == null || uiElement.getNode() == null) {
continue;
}
matchedNodes.add(uiElement.getNode());
if (!multiple) {
break;
}
}
Logger.info(String.format("Took %sms to retrieve %s matches for '%s' XPath1 query",
SystemClock.uptimeMillis() - timeStarted, matchedNodes.size(), xpath1Selector));
return matchedNodes;
} catch (XPathExpressionException | IllegalArgumentException e) {
throw new UiAutomator2Exception(
String.format("%s. Try changing the '%s' driver setting to 'true' in order " +
"to workaround the problem.", e.getMessage(),
Settings.NORMALIZE_TAG_NAMES.getSetting().getName()), e);
} catch (Exception e) {
e.printStackTrace();
throw new UiAutomator2Exception(e);
} finally {
uiElementsMapping.clear();
RESOURCES_GUARD.release();
}
}
private NodeInfoList findNodesUsingXpath2(String xpath2Selector, boolean multiple) {
StaticContextBuilder scb = new StaticContextBuilder();
final XPath2Expression expr;
try {
expr = new Engine().parseExpression(xpath2Selector, scb);
} catch (XPathParserException e) {
throw new InvalidSelectorException(e);
}
try {
RESOURCES_GUARD.acquire();
} catch (InterruptedException e) {
throw new UiAutomator2Exception(e);
}
try (InputStream xmlStream = toStream(true)) {
ResultSequence rs = expr.evaluate(
new DynamicContextBuilder(scb), new Object[]{fetchContext(xmlStream)}
);
NodeInfoList matchedNodes = new NodeInfoList();
Iterator<Item> iterator = rs.iterator();
final long timeStarted = SystemClock.uptimeMillis();
while (iterator.hasNext()) {
Item item = iterator.next();
if (!(item.getNativeValue() instanceof Node)) {
continue;
}
Node node = (Node) item.getNativeValue();
if (node.getNodeType() != Node.ELEMENT_NODE) {
continue;
}
NamedNodeMap attributes = node.getAttributes();
Node uiElementIndexAttr = attributes.getNamedItem(UI_ELEMENT_INDEX);
if (uiElementIndexAttr == null) {
continue;
}
UiElement<?, ?> uiElement = uiElementsMapping.get(
Integer.parseInt(uiElementIndexAttr.getNodeValue())
);
if (uiElement == null || uiElement.getNode() == null) {
continue;
}
matchedNodes.add(uiElement.getNode());
if (!multiple) {
break;
}
}
Logger.info(String.format("Took %sms to retrieve %s matches for '%s' XPath2 query",
SystemClock.uptimeMillis() - timeStarted, matchedNodes.size(), xpath2Selector));
return matchedNodes;
} catch (Exception e) {
e.printStackTrace();
throw new UiAutomator2Exception(
String.format("%s. Try changing the '%s' driver setting to 'true' in order " +
"to workaround the problem.", e.getMessage(),
Settings.ENFORCE_XPATH1.getSetting().getName()), e);
} finally {
uiElementsMapping.clear();
RESOURCES_GUARD.release();
}
}
public NodeInfoList findNodes(String xpathSelector, boolean multiple) {
return Settings.get(EnforceXpath1.class).getValue()
? findNodesUsingXpath1(xpathSelector, multiple)
: findNodesUsingXpath2(xpathSelector, multiple);
}
}