Ce document fournit des informations de référence sur les scripts Robo, y compris la structure, les fonctionnalités, l'utilisation, l'enregistrement et les actions. Les scripts robotisés sont des tests qui automatisent les tâches de contrôle qualité manuelles pour les applications mobiles, et permettent l'intégration continue (CI) et les stratégies de test avant lancement. Un script Robo est un fichier JSON qui décrit une séquence d'interface utilisateur (UI) et d'autres actions.
Vous pouvez créer un script Robo de différentes manières:
Utilisez la fonctionnalité d'enregistrement de scripts Robo. (Android uniquement)
Créez le script Robo manuellement. (Android et iOS+)
Enregistrez le script Robo, puis modifiez-le manuellement. (Android uniquement)
Pour en savoir plus sur l'utilisation des scripts Robo, consultez Exécuter un script Robo.
Introduction
Le script Robo est fourni au test Robo avec d'autres entrées telles que le package d'application Android (APK) app-under-test.
Voici un exemple de script Robo qui connecte un utilisateur à une application, qui se déclenche lorsque l'application en cours de test est lancée:
[
{
"crawlStage": "crawl",
"contextDescriptor": {
"condition": "app_under_test_shown"
},
"actions": [
{
"eventType": "VIEW_TEXT_CHANGED",
"replacementText": "user123",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/username"
}
]
},
{
"eventType": "VIEW_TEXT_CHANGED",
"replacementText": "12345",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/password"
}
]
},
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/login"
}
]
}
]
}
]
Si un seul script Robo se trouve dans un fichier et qu'il comporte la condition de déclenchement app_under_test_shown
par défaut, comme dans l'exemple ci-dessus, vous pouvez spécifier le script Robo dans un fichier à l'aide d'un format plus simple, comme une séquence de ses actions:
[
{
"eventType": "VIEW_TEXT_CHANGED",
"replacementText": "user123",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/username"
}
]
},
{
"eventType": "VIEW_TEXT_CHANGED",
"replacementText": "12345",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/password"
}
]
},
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/login"
}
]
}
]
Compatibilité avec les scripts Robo sur iOS et versions ultérieures
Les scripts Robo sont compatibles de manière limitée avec Robo pour iOS+ (bêta). La syntaxe du script Robo pour iOS et versions ultérieures est identique à celle d'Android, et les fonctionnalités iOS et versions ultérieures compatibles se comportent de manière similaire à leurs homologues Android.
Les actions suivantes sont compatibles avec iOS+:
- Assertion
- Cliquez sur
- Clic long
- Glissé
- Ignorer tous les éléments
- Attente
- Prendre une capture d'écran
- Arrêter l'exploration
Les attributs d'identification suivants dans les descripteurs d'éléments sont compatibles avec iOS +:
- Nom de la classe
- Nom de la classe ascendante
- Description du contenu (et expression régulière)
- Texte (et expression régulière)
Les conditions de déclenchement dans les descripteurs de contexte suivantes sont compatibles avec iOS+:
- Application en cours de test affichée
- Élément présent
- Action de script non Robo effectuée
Structure
Un script Robo comporte plusieurs attributs qui décrivent la façon dont Robo l'exécute. La plupart de ces attributs sont facultatifs et disposent de valeurs par défaut prédéfinies:
Attribut | Description |
id
|
Nombre entier qui permet de suivre ce script Robo dans les résultats d'exploration.
Robo dispose de scripts Robo intégrés avec leurs propres id . Bien que la même id dans différents scripts Robo n'affecte pas leur comportement, il peut être difficile de distinguer les actions de ces scripts Robo dans les sorties d'exploration. Nous vous recommandons d'attribuer un id unique de 1000 ou plus à vos scripts Robo pour éviter tout conflit.
|
description
|
Semblable à id , mais plus descriptif.
|
crawlStage
|
Étape de l'exploration à laquelle Robo applique ce script Robo. Par défaut, il s'agit de l'étape d'exploration principale. |
priority
|
Priorité de ce script Robo par rapport aux autres scripts Robo.
Par défaut, tous les scripts Robo ont une priorité de 1 .
|
maxNumberOfRuns
|
Indique le nombre de fois où Robo peut exécuter ce script Robo au cours d'une exploration. Par défaut, Robo peut exécuter un script Robo une seule fois. |
contextDescriptor
|
Décrit le contexte ou la condition qui déclenche ce script Robo. Si cette valeur est omise, la condition de déclenchement de ce script Robo est considérée comme toujours remplie. En d'autres termes, le script Robo est inconditionnel. |
actions
|
Toutes les actions de ce script Robo. |
Un seul fichier contient une collection d'un ou de plusieurs scripts Robo.
Voici un exemple de fichier contenant deux scripts Robo inconditionnels, chacun avec une seule action exécutée une seule fois au début d'une exploration:
[
{
"id": 1000,
"description": "My first Robo script",
"actions": [
{
"eventType": "DISABLE_KEYBOARD"
}
]
},
{
"id": 1001,
"description": "My second Robo script",
"actions": [
{
"eventType": "PRESSED_BACK"
}
]
}
]
Descripteur de contexte
Un descripteur de contexte définit le contexte ou la condition qui déclenche un script Robo à l'aide d'un ou d'une combinaison de plusieurs attributs:
Attribut | Description |
---|---|
"condition": "always"
|
Déclenche toujours un script Robo. |
"condition": "element_present"
|
Vérifie qu'un widget d'UI correspondant à elementDescriptors ou au texte spécifié par visionText est présent à l'écran.
|
"condition": "element_disabled"
|
Vérifie qu'un widget d'interface utilisateur correspondant à elementDescriptors est présent à l'écran et qu'il ne peut pas être utilisé.
|
"condition": "element_checked"
|
Vérifie qu'un widget d'interface utilisateur correspondant à elementDescriptors est présent à l'écran et coché.
|
"condition": "app_under_test_shown"
|
Vérifie que l'application en cours de test s'exécute au premier plan. |
"condition": "default_launcher_shown"
|
Vérifie que l'écran d'accueil d'un appareil s'affiche, ce qui signifie qu'aucune application ne s'exécute au premier plan. |
"condition": "non_roboscript_action_performed"
|
Vérifie que les dernières nonRoboscriptActionCount actions consécutives effectuées par le test Robo ne sont pas des actions de script Robo.
|
negateCondition
|
Si la valeur est true , annule condition . Par exemple, vous pouvez utiliser cet attribut pour vérifier si un widget d'UI n'est PAS présent à l'écran ou si l'application app-under-test n'est PAS exécutée au premier plan.
|
elementDescriptors
|
Un ou plusieurs descripteurs d'éléments qui identifient un widget d'UI à l'écran.
Il est utilisé en combinaison avec les conditions element_present , element_disabled et element_checked . S'exclut mutuellement avec visionText . Pour en savoir plus, consultez la section Descripteurs d'éléments.
|
visionText
|
Le texte à l'écran est détecté à l'aide de l'API de reconnaissance optique des caractères (OCR). visionText est utilisé avec la condition element_present . S'exclut mutuellement avec elementDescriptors .
|
nonRoboscriptActionCount
|
Nombre d'actions de script non Robo consécutives effectuées précédemment. Il est utilisé en combinaison avec la condition non_roboscript_action_performed pour déclencher un script Robo après chaque action Robo nonRoboscriptActionCount . La valeur par défaut est 1 .
|
Voici un exemple de script Robo déclenché par un widget d'interface utilisateur avec un ID de ressource "my.app.package:id/page_header"
présent à l'écran:
{
"id": 1000,
"contextDescriptor": {
"condition": "element_present",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/page_header"
}
]
},
"actions": [
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"text": "Settings"
}
]
}
]
}
Voici un exemple de script Robo déclenché par "Privacy Policy"
détecté par la reconnaissance optique des caractères (OCR):
{
"id": 1000,
"description": "Vision text Robo script",
"contextDescriptor": {
"condition": "element_present",
"visionText": "Privacy Policy"
},
"actions": [
{
"eventType": "VIEW_CLICKED",
"visionText": "Privacy Policy"
}
]
}
Voici un exemple de script Robo qui attend cinq secondes après chaque action Robo non scriptée:
{
"contextDescriptor": {
"condition": "non_roboscript_action_performed"
},
"maxNumberOfRuns" : 1000,
"actions" : [
{
"eventType" : "DELAYED_MESSAGE_POSTED",
"delayTime" : 5000
}]
}
Actions
Chaque action d'un script Robo est représentée par un ensemble d'une ou plusieurs paires attribut-valeur, décrites dans le tableau suivant:
Attribut | Description |
eventType
|
Spécifie le type d'action (par exemple, clic, modification de texte, etc.). Obligatoire pour toutes les actions. |
elementDescriptors
|
Descripteurs qui identifient un widget d'interface utilisateur. Obligatoire pour toutes les actions qui ont un widget d'interface utilisateur cible, comme cliquer sur un bouton particulier. |
optional
|
Si défini sur true , cette action est ignorée lorsqu'elle ne peut pas être effectuée. Par exemple, cette action est ignorée lorsqu'elle ne trouve pas son widget d'UI cible sur un écran, sans que le script Robo associé ne échoue. La valeur par défaut est false .
|
replacementText
|
Texte à saisir dans le widget d'interface utilisateur cible. Obligatoire pour les actions de modification de texte. |
swipeDirection
|
Indique le sens du balayage. Obligatoire pour les actions de balayage. |
delayTime
|
Indique la durée d'attente, en millisecondes. Obligatoire pour les actions d'attente. |
pointTapXCoordinate et pointTapYCoordinate
|
Coordonnées X et Y du point sélectionné en pixels. S'exclut mutuellement avec pointTapXPercent et pointTapYPercent .
Obligatoire pour les actions de pression sur un point.
|
pointTapXPercent et pointTapYPercent
|
Pourcentage des coordonnées X et Y du point sélectionné. S'exclut mutuellement avec pointTapXCoordinate et pointTapYCoordinate . Obligatoire pour les actions de pression sur un point.
|
Voici un exemple de script Robo avec deux actions sans widgets d'interface utilisateur cibles, ce qui signifie que ces actions ne fonctionnent pas sur un widget d'interface utilisateur spécifique:
[
{
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 3000
},
{
"eventType": "PRESSED_BACK"
}
]
Descripteurs d'éléments
Un descripteur d'élément identifie un widget d'interface utilisateur à l'aide d'un ou de plusieurs des attributs d'identification suivants:
Attribut | Description |
className
|
– |
ancestorClassName
|
Nom de classe de l'ancêtre de la hiérarchie d'interface utilisateur de l'élément. Un ancêtre est l'un des nœuds parents de la hiérarchie de l'UI de l'élément, y compris l'élément lui-même. |
resourceId
|
– |
resourceIdRegex
|
Expression régulière Java correspondant à resourceId .
|
contentDescription
|
– |
contentDescriptionRegex
|
Expression régulière Java correspondant à contentDescription .
|
text (qui s'affiche à l'écran)
|
– |
textRegex
|
Expression régulière Java correspondant à text .
|
groupViewChildPosition , recyclerViewChildPosition ou adapterViewChildPosition
|
Représente la position enfant d'un widget d'interface utilisateur en fonction du type de son widget parent. |
Ces attributs ne sont souvent pas définis. Par exemple, un bouton peut ne pas comporter de texte ni de description de contenu. Même si certaines valeurs d'attribut sont présentes, elles ne sont pas nécessairement uniques sur un écran d'application donné (y compris resourceId
).
Par exemple, il n'est généralement possible de différencier les éléments d'une liste que par leurs différentes positions d'enfants dans leur widget parent. Cela signifie qu'il est généralement insuffisant d'utiliser un seul descripteur d'élément pour identifier un widget d'interface utilisateur. Par conséquent, l'attribut elementDescriptors
d'une action contient une séquence de descripteurs d'éléments ordonnés de sorte que le premier corresponde au widget d'interface utilisateur cible, le deuxième au widget parent du widget d'interface utilisateur cible, et ainsi de suite. Le widget d'UI cible d'une action est mis en correspondance lorsque tous ses descripteurs d'éléments correspondent à la sous-hiérarchie du widget d'UI correspondant.
Voici un exemple de script Robo avec une modification de texte et des actions de clic, qui nécessitent toutes deux d'identifier le widget d'interface utilisateur cible à l'aide des descripteurs d'élément fournis:
[
{
"eventType": "VIEW_TEXT_CHANGED",
"replacementText": "John",
"elementDescriptors": [
{
"className": "android.support.v7.widget.AppCompatEditText",
"groupViewChildPosition": 0,
"resourceId": "com.google.samples.apps.topeka:id/first_name"
},
{
"className": "android.widget.FrameLayout",
"groupViewChildPosition": 0
},
{
"className": "android.support.design.widget.TextInputLayout",
"groupViewChildPosition": 1
}
]
},
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"className": "android.support.design.widget.FloatingActionButton",
"groupViewChildPosition": 1,
"resourceId": "com.google.samples.apps.topeka:id/done"
},
{
"className": "android.widget.FrameLayout",
"groupViewChildPosition": 1,
"resourceId": "com.google.samples.apps.topeka:id/content"
},
{
"className": "android.widget.FrameLayout",
"groupViewChildPosition": 0,
"resourceId": "com.google.samples.apps.topeka:id/sign_in_content"
}
]
}
]
Options d'exécution
Vous pouvez éventuellement préfixer la liste des actions d'un script Robo avec un objet JSON qui spécifie les options d'exécution de ce script Robo. Cet en-tête de configuration commence par le mot clé roboscript
, suivi d'une représentation JSON des options d'exécution souhaitées.
Les scripts Robo sont compatibles avec les options d'exécution suivantes:
executionMode
: options d'exécution appliquées lorsqu'un script Robo est en cours d'exécution :strict
: si la valeur esttrue
, le script Robo n'utilise pas la correspondance partielle, l'omission de l'action en cours et la suspension. Autrement dit, le script Robo est exécuté comme un test d'instrumentation standard et échoue dès qu'une de ses actions ne peut pas être effectuée. Par défaut, il s'agit defalse
.dismiss_popups
: si la valeur esttrue
, le test Robo ignore toutes les boîtes de dialogue inattendues lors de l'exécution du script Robo, même en modestrict
. Cette option n'a aucun effet en dehors du modestrict
. Par défaut, il s'agit defalse
.notify
: si la valeur estfalse
, le script Robo n'affiche pas de notifications à l'écran au début et à la fin de son exécution. Par défaut, il s'agit detrue
.
postscript
: options d'exécution appliquées une fois qu'un script Robo est terminé :terminate
: si la valeur esttrue
, le test Robo arrête l'exploration une fois le script Robo terminé. Par défaut, il s'agit defalse
.
Voici un exemple de script Robo exécuté en mode strict
sans notification à l'écran qui passe en veille pendant trois secondes, après quoi l'exploration s'arrête:
"roboscript": {
"executionMode": {
"strict": true,
"notify": false
},
"postscript": {
"terminate": true
}
}
[
{
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 3000
}
]
Paramètres de modèle
Un paramètre de modèle est un espace réservé dans un script Robo qui est remplacé par la valeur réelle lorsque le test Robo charge ce script Robo pour l'exécuter. Les paramètres du modèle sont précédés d'un double trait de soulignement suivi d'un signe de pourcentage, puis sont postfixés par un signe de pourcentage suivi d'un double trait de soulignement.
Les scripts Robo acceptent le paramètre de modèle suivant:
__%APP_PACKAGE_NAME%__
: nom du package de l'application testée.
Voici un exemple de script Robo qui arrête le processus de l'application testée:
[
{
"eventType": "ADB_SHELL_COMMAND",
"command": "am force-stop __%APP_PACKAGE_NAME%__"
}
]
Commentaires
Un script Robo peut contenir des lignes de commentaire, qui sont des lignes commençant par #
ou //
.
Voici un exemple de script Robo avec quelques commentaires:
# Confirm a user account.
[
{
// Click the DONE button.
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"resourceId": "com.google.samples.apps.topeka:id/done"
}
]
}
]
Fonctionnalités
Par défaut, le script Robo reste actif jusqu'à ce que toutes les actions d'un script Robo soient terminées (ou au moins tentées). Le test Robo continue d'essayer de faire correspondre une action de script Robo chaque fois qu'il choisit une action à effectuer. Le script Robo utilise les techniques suivantes pour améliorer la robustesse:
Technique | Description |
Correspondance partielle | Si l'action du script Robo actuelle ne peut pas être entièrement mise en correspondance, les critères de mise en correspondance sont assouplis et la mise en correspondance est réessayée. La correspondance partielle ne tient pas compte du descripteur d'élément le plus externe lors de la mise en correspondance du widget d'interface utilisateur cible d'une action de script Robo.
Si la correspondance partielle réussit, l'action du script Robo correspondante est effectuée comme d'habitude. Cette technique est compatible avec les scénarios dans lesquels la structure de l'application change, par exemple entre les versions de l'application, lorsque les éléments de l'écran sont réorganisés. |
Ignorer l'action en cours | Si l'action du script Robo actuel ne peut pas être entièrement ou partiellement mise en correspondance, Robo tente de mettre en correspondance l'action du script Robo suivante. Si l'action suivante correspond entièrement ou partiellement, le test Robo ignore (et ne revient jamais) l'action du script Robo en cours et effectue l'action suivante.
Cette technique est compatible avec les scénarios dans lesquels le comportement de l'application change entre les versions ou est irrégulier, par exemple, lorsqu'une boîte de dialogue intermittente peut apparaître sur différents écrans lors de l'enregistrement ou de la relecture d'un script Robo. |
Suspendre | Si aucune action du script Robo actuelle ni ultérieure ne peut être mise en correspondance totale ou partielle, le script Robo est temporairement suspendu et le test Robo choisit une action à effectuer à l'aide de ses autres stratégies. Une fois cette action terminée, le test Robo reprend l'exécution du script Robo.
Tant que les actions actuelles ou ultérieures du script Robo ne peuvent pas être mises en correspondance, le script Robo reste suspendu pour un nombre illimité d'actions. Ainsi, les scripts Robo n'ont pas nécessairement besoin d'être un prologue pour un test Robo, et vous pouvez intercaler des actions de script Robo avec des actions de test Robo standards. Cette technique est adaptée aux scénarios où le comportement de l'application est instable ou lorsque les modifications entre les versions de l'application sont suffisamment importantes pour que le test Robo doive "combler les lacunes" avec ses actions standards. |
Priorités
Si un script Robo atteint son maxNumberOfRuns
, il ne peut plus être déclenché dans une exploration donnée. Si plusieurs scripts Robo peuvent être déclenchés par le contexte actuel, la priorité est donnée en choisissant, dans l'ordre suivant, le script Robo:
- Comporte un attribut
contextDescriptor
. - Possède le
priority
le plus élevé (par défaut, tous les scripts Robo ont le mêmepriority
d'exécution de1
). - Apparaît en premier dans la liste des scripts Robo, si les priorités de ces scripts sont identiques.
Voici un exemple de fichier contenant trois scripts Robo qui effectuent la même action et sont déclenchés par la même condition (l'application testée est au premier plan) :
[
{
"id": 1000,
"description": "Robo script 1",
"contextDescriptor": {
"condition": "app_under_test_shown"
},
"actions": [
{
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 3000
}
]
},
{
"id": 1001,
"description": "Robo script 2",
"priority": "2",
"contextDescriptor": {
"condition": "app_under_test_shown"
},
"actions": [
{
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 3000
}
]
},
{
"id": 1002,
"description": "Robo script 3",
"contextDescriptor": {
"condition": "app_under_test_shown"
},
"actions": [
{
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 3000
}
]
}
]
Lorsque l'application en cours de test est au premier plan, Robo déclenche les éléments suivants, dans l'ordre:
"Robo script 2"
, car il a la priorité la plus élevée."Robo script 1"
, car il apparaît plus tôt parmi les autres scripts Robo applicables ayant la même priorité."Robo script 3"
en tant que dernier script Robo applicable.
Exécutions répétées
Par défaut, Robo ne déclenche un script Robo qu'une seule fois au cours d'une exploration. Vous pouvez ajuster cela via l'attribut maxNumberOfRuns
.
Voici un exemple de script Robo qui met l'application testée en arrière-plan jusqu'à 10 fois:
{
"id": 1000,
"maxNumberOfRuns": 10,
"contextDescriptor": {
"condition": "app_under_test_shown"
},
"actions": [
{
"eventType": "GO_HOME"
}
]
}
Étape d'exploration
Les scripts Robo sont applicables à différentes étapes d'une exploration Robo donnée:
Étape d'exploration | Description |
pre_crawl
|
Avant le lancement de Robo et le début de l'exploration de l'application en cours de test. |
post_crawl
|
Une fois que Robo a terminé d'explorer l'application en cours de test. La durée d'un script Robo post_crawl ne doit pas dépasser 15 secondes, sinon l'exploration peut se terminer par un délai avant expiration.
|
crawl
|
Étape d'exploration principale, lorsque Robo explore l'application en cours de test. |
close_screen
|
Lorsque Robo tente de revenir en arrière (revenir en arrière) à partir d'un écran donné, toutes les actions possibles sur cet écran sont explorées. Par défaut, Robo appuie sur "Retour", ce qui n'est pas souhaitable dans certains cas. |
Si l'attribut crawlStage
d'un script Robo n'est pas spécifié, il est implicitement crawl
.
Voici un exemple de script Robo qui efface les données utilisateur de l'application en cours de test avant que Robo ne commence à l'explorer:
{
"id": 1000,
"crawlStage": "pre_crawl",
"actions": [
{
"eventType": "ADB_SHELL_COMMAND",
"command": "pm clear __%APP_PACKAGE_NAME%__"
}
]
}
Voici un exemple de script Robo qui demande à Robo de cliquer sur "Cancel"
chaque fois qu'il tente de revenir en arrière à partir d'une boîte de dialogue de confirmation:
{
"id": 1000,
"crawlStage": "close_screen",
"maxNumberOfRuns": 999,
"contextDescriptor": {
"condition": "element_present",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/confirmation_dialog"
}
]
},
"actions": [
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"text": "Cancel"
}
]
}
]
}
Actions conditionnelles
Un script Robo peut contenir des actions conditionnelles. Les actions conditionnelles comportent trois attributs supplémentaires qui décrivent la façon dont Robo les exécute:
Attribut | Description |
priority
|
Priorité de cette action conditionnelle par rapport aux autres actions conditionnelles dans le script Robo qui la contient. Par défaut, toutes les actions conditionnelles ont une priorité de 1 .
|
maxNumberOfRuns
|
Nombre de fois où cette action conditionnelle peut être effectuée lors d'une exécution du script Robo qui la contient. Par défaut, toutes les actions conditionnelles ne peuvent être effectuées qu'une seule fois lors d'une seule exécution du script Robo qui les contient. |
contextDescriptor
|
Contexte/Condition qui déclenche cette action conditionnelle. Il possède la même structure et offre des fonctionnalités similaires à celles du contextDescriptor du script Robo. |
Lorsqu'il est déclenché, un script Robo exécute ses actions non conditionnelles une par une dans l'ordre d'apparition. Si un script Robo contient des actions conditionnelles, elles sont prises en compte chaque fois avant de choisir une action non conditionnelle à effectuer. Si une action conditionnelle est déclenchée et sélectionnée en fonction de sa priorité et du nombre d'exécutions restantes, le script Robo exécute cette action conditionnelle. Sinon, le script Robo effectue l'action non conditionnelle suivante. Pour être valide, un script Robo doit contenir au moins une action non conditionnelle.
Voici un exemple de script Robo inconditionnel avec une action conditionnelle qui ferme les boîtes de dialogue pop-up si elles s'affichent à tout moment pendant l'exécution du script Robo:
{
"id": 1000,
"actions": [
{
"description": "Dismiss popup",
"maxNumberOfRuns": 100,
"contextDescriptor": {
"condition": "default_launcher_shown",
"negateCondition": true
},
"eventType": "GO_HOME"
},
{
"description": "Screen off",
"eventType": "ADB_SHELL_COMMAND",
"command": "input keyevent 26"
},
{
"description": "Wait for 10 seconds",
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 10000
},
{
"description": "Screen on",
"eventType": "ADB_SHELL_COMMAND",
"command": "input keyevent 82"
},
{
"description": "Wait for 10 seconds",
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 10000
}
}
Ignorer des actions
Un script Robo peut contenir des instructions pour que Robo ignore des widgets d'interface utilisateur spécifiques ou tous les widgets d'interface utilisateur d'un écran donné. Ces instructions sont représentées comme ignorant les "actions" avec eventType
ELEMENT_IGNORED
et ALL_ELEMENTS_IGNORED
respectivement.
Chaque fois que l'attribut contextDescriptor
d'un script Robo contenant des actions d'ignorement correspond à un écran donné, Robo n'interagit avec aucun widget d'interface utilisateur ciblé par ses actions d'ignorement (sauf si une autre action de script Robo lui fait effectuer une action sur l'un des widgets d'interface utilisateur ignorés).
Un script Robo peut contenir un mélange d'actions ignorées, conditionnelles et non conditionnelles. Contrairement aux autres actions de script Robo, les actions d'ignorer sont appliquées tant que le contextDescriptor
du script Robo qui les contient correspond à un écran lors d'une exploration Robo, quelles que soient les valeurs des attributs priority
et maxNumberOfRuns
.
Voici un exemple de fichier contenant deux scripts Robo. Le premier script Robo oblige Robo à ignorer tous les widgets d'interface utilisateur sur un écran contenant un widget d'interface utilisateur ayant l'ID de ressource "my.app.package:id/ignored_screen"
. Le deuxième script Robo fait en sorte que Robo ignore les widgets d'interface utilisateur dont les ID de ressource correspondent à la regex Java ".*:id/done"
sur un écran contenant un widget d'interface utilisateur avec un ID de ressource "my.app.package:id/main_screen"
:
[
{
"id": 1000,
"contextDescriptor": {
"condition": "element_present",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/ignored_screen"
}
]
},
"actions": [
{
"eventType": "ALL_ELEMENTS_IGNORED"
}
]
},
{
"id": 1001,
"contextDescriptor": {
"condition": "element_present",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/main_screen"
}
]
},
"actions": [
{
"eventType": "ELEMENT_IGNORED",
"elementDescriptors": [
{
"resourceIdRegex": ".*:id/done"
}
]
}
]
}
]
Compatibilité avec RecyclerView et AdapterView
Les enfants des widgets RecyclerView et AdapterView sont chargés de manière dynamique et peuvent être affichés à de nombreux balayages de l'écran actuel. Étant donné que la taille d'un écran et le nombre de balayages requis pour accéder à cet enfant varient selon les facteurs de forme d'appareil, il est beaucoup plus robuste de s'appuyer sur la position absolue des données de l'enfant. Il s'agit d'une approche moins robuste que de s'appuyer sur le nombre de balayages requis pour afficher cet enfant à l'écran, puis d'utiliser sa position à l'écran.
Par conséquent, le script Robo capture les positions de données absolues des enfants RecyclerView qui sont des cibles d'actions de script Robo en tant que recyclerViewChildPosition
. Le script Robo capture également les positions de données absolues des enfants AdapterView qui sont des cibles d'actions du script Robo en tant que adapterViewChildPosition
.
Les actions sur les enfants RecyclerView et AdapterView sont effectuées dans les étapes suivantes:
Le test Robo s'assure que l'enfant correspondant s'affiche à l'écran via une action de positionnement sur son RecyclerView ou AdapterView contenant.
Le test Robo effectue l'action enregistrée directement sur l'élément enfant, car il est déjà affiché à l'écran.
Voici un exemple d'action de clic sur un enfant AdapterView (android.widget.GridView
) :
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"className": "com.google.samples.apps.topeka.widget.AvatarView",
"adapterViewChildPosition": 5,
"resourceId": "com.google.samples.apps.topeka:id/avatar",
"contentDescription": "Avatar 6"
},
{
"className": "android.widget.GridView",
"groupViewChildPosition": 1,
"resourceId": "com.google.samples.apps.topeka:id/avatars"
},
{
"className": "android.widget.LinearLayout",
"groupViewChildPosition": 1
},
{
"className": "android.widget.LinearLayout",
"groupViewChildPosition": 0
}
]
}
Voici un exemple d'action de clic sur un enfant RecyclerView (android.support.v7.widget.RecyclerView
) :
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"className": "android.support.v7.widget.AppCompatTextView",
"groupViewChildPosition": 1,
"resourceId": "com.google.samples.apps.topeka:id/category_title"
},
{
"className": "android.widget.FrameLayout",
"recyclerViewChildPosition": 8,
"resourceId": "com.google.samples.apps.topeka:id/category_item"
},
{
"className": "android.support.v7.widget.RecyclerView",
"groupViewChildPosition": 1,
"resourceId": "com.google.samples.apps.topeka:id/categories"
},
{
"className": "android.widget.FrameLayout",
"groupViewChildPosition": 1,
"resourceId": "com.google.samples.apps.topeka:id/category_container"
},
{
"className": "android.widget.LinearLayout",
"groupViewChildPosition": 0
}
]
}
Enregistrer un script Robo dans Android Studio et l'exécuter dans Test Lab
Vous pouvez créer un script Robo dans Android Studio, qui l'enregistre en tant que fichier JSON. Vous pouvez ensuite importer le fichier JSON dans Firebase Test Lab avec l'application et exécuter le test en conséquence.
Lorsque vous exécutez un test Robo avec un script associé, le test Robo effectue d'abord les actions décrites dans le script, puis explore l'application comme d'habitude.
Pour créer un fichier JSON de script Robo dans Android Studio, suivez les étapes de la section Enregistrer un script Robo à l'aide de Test Lab dans Android Studio.
Actions du script Robo
L'attribut facultatif commun suivant s'applique à toutes les actions:
description
: permet de suivre l'exécution de cette action de script Robo dans les sorties de test Robo.
Assertion
Si la condition affirmée est vraie, le script Robo passe à l'action suivante, qui peut être une autre assertion. Sinon, l'exécution du script Robo est interrompue en raison d'un échec d'assertion.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "ASSERTION"
|
-- |
contextDescriptor
|
Décrit le contexte ou la condition déclarée. Il a la même structure et offre des fonctionnalités similaires à celles du contextDescriptor du script Robo. |
Voici un exemple d'assertion de script Robo qui vérifie que l'application testée est au premier plan:
{
"eventType": "ASSERTION",
"contextDescriptor": {
"condition": "app_under_test_shown"
}
}
Voici un exemple d'assertion de script Robo qui vérifie qu'un widget d'interface utilisateur avec l'ID de ressource "com.google.samples.apps.topeka:id/done"
est présent sur un écran:
{
"eventType": "ASSERTION",
"contextDescriptor": {
"condition": "element_present",
"elementDescriptors": [
{
"resourceId": "com.google.samples.apps.topeka:id/done"
}
]
}
}
Voici un exemple d'assertion de script Robo qui vérifie que "Settings"
n'est PAS détecté sur un écran à l'aide de la technologie OCR:
{
"eventType": "ASSERTION",
"contextDescriptor": {
"condition": "element_present",
"negateCondition": true,
"visionText": "Settings"
}
}
Cliquez sur
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
eventType
|
Spécifie le type d'action du script Robo. |
"eventType": "VIEW_CLICKED"
|
Cliquez sur l'élément cible de l'application en cours de test. |
"eventType": "SOFT_KEYBOARD_CLICK"
|
Cliquez sur l'élément cible du clavier virtuel. |
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK"
|
Clique sur des éléments aléatoires du clavier virtuel jusqu'à maxNumberOfRuns fois.
|
"eventType": "LIST_ITEM_CLICKED"
|
Utilisé par l'enregistreur de script Robo dans Android Studio pour cliquer sur les éléments de liste. |
elementDescriptors
|
Identifie le widget d'interface utilisateur sur lequel l'utilisateur a cliqué à l'aide de la hiérarchie de l'interface utilisateur Android.
S'exclut mutuellement avec visionText .
|
visionText
|
Identifie l'élément sur lequel l'utilisateur a cliqué à l'aide de la technologie OCR. Exclusion mutuelle avec elementDescriptors .
|
matchIndex
|
Spécifie l'indice de l'occurrence de l'élément cible correspondant, lorsque l'élément cible est identifié à l'aide de visionText . S'il s'agit de 0 , l'action du script Robo sélectionne le premier élément correspondant. S'il s'agit de 1 , l'action du script Robo sélectionne le deuxième élément correspondant, et ainsi de suite. L'ordre est déterminé de gauche à droite, de haut en bas. La valeur par défaut est 0 (le premier élément correspondant est sélectionné).
|
maxNumberOfRuns
|
Spécifie le nombre de clics sur un élément aléatoire du clavier virtuel lorsque eventType est défini sur SOFT_KEYBOARD_RANDOM_CLICK .
La valeur par défaut est 1 .
|
Voici un exemple d'action de script Robo qui clique sur un bouton avec l'ID de ressource "com.google.samples.apps.topeka:id/done"
:
{
"eventType": "VIEW_CLICKED",
"elementDescriptors": [
{
"resourceId": "com.google.samples.apps.topeka:id/done"
}
]
}
Voici un exemple d'action de script Robo qui clique sur la deuxième occurrence du mot "Search"
détecté sur un écran à l'aide de la technologie OCR:
{
"eventType": "VIEW_CLICKED",
"visionText": "Search",
"matchIndex": 1
}
Voici un exemple d'action de script Robo qui clique sur un élément de clavier virtuel avec une description de contenu "Emoji button"
:
{
"eventType": "SOFT_KEYBOARD_CLICK",
"elementDescriptors": [
{
"contentDescription": "Emoji button"
}
]
}
Voici un exemple d'action de script Robo qui clique sur des éléments du clavier virtuel aléatoires jusqu'à cinq fois:
{
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK",
"maxNumberOfRuns": 5
}
Désactiver le clavier virtuel
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "DISABLE_KEYBOARD"
|
-- |
Voici un exemple d'action de script Robo qui désactive le clavier virtuel:
{
"eventType": "DISABLE_KEYBOARD"
}
Exécuter une commande shell adb
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "ADB_SHELL_COMMAND"
|
-- |
command
|
Commande shell Android Debug Bridge (adb) à exécuter. |
L'attribut suivant est facultatif:
expectedOutputRegex
: résultat attendu de la commande sous forme d'expression régulière Java. Si le résultat ne correspond pas, l'action du script Robo échoue. Par défaut, il s'agit d'une chaîne vide, ce qui signifie que la sortie n'est pas vérifiée.
Voici un exemple d'action de script Robo qui efface les données utilisateur de l'application testée:
{
"eventType": "ADB_SHELL_COMMAND",
"command": "pm clear __%APP_PACKAGE_NAME%__"
}
Octroyer des autorisations
Cette action est enregistrée par l'enregistreur de script Robo dans Android Studio pour assurer la rétrocompatibilité avec Espresso Test Recorder. Le test Robo accorde toutes les autorisations à l'application testée au début de chaque exploration. Par conséquent, cette action est une opération sans effet. N'utilisez PAS cette action dans vos scripts Robo.
Le tableau suivant répertorie les attributs obligatoires:
Attribut | Description |
"eventType": "PERMISSIONS_REQUEST"
|
-- |
Ignorer tous les éléments d'un écran
Cette action permet à Robo d'ignorer tous les éléments de n'importe quel écran qui déclenche le script Robo contenant.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "ALL_ELEMENTS_IGNORED"
|
-- |
Voici un exemple d'action de script Robo qui fait en sorte que Robo ignore tous les éléments d'un écran:
{
"eventType": "ALL_ELEMENTS_IGNORED"
}
Ignorer un élément
Cette action permet à Robo d'ignorer un ou plusieurs éléments correspondant à l'elementDescriptors
spécifié.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "ELEMENT_IGNORED"
|
-- |
elementDescriptors
|
Identifie le ou les widgets d'interface utilisateur ignorés à l'aide de la hiérarchie de l'interface utilisateur Android. |
L'attribut suivant est facultatif:
ignoreChildren
: si la valeur esttrue
, Robo ignore également tous les descendants du ou des widgets d'interface utilisateur ignorés. Par défaut, il s'agit defalse
.
Voici un exemple d'action de script Robo qui fait en sorte que Robo ignore tous les éléments dont les descriptions de contenu commencent par "Avatar"
:
{
"eventType": "ELEMENT_IGNORED",
"elementDescriptors": [
{
"contentDescriptionRegex": "Avatar.*"
}
]
}
Texte d'entrée
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
eventType
|
Indique le type d'action du script Robo. |
"eventType": "VIEW_TEXT_CHANGED"
|
Saisit le texte donné dans le widget d'UI cible. |
"eventType": "ENTER_TEXT"
|
saisit le texte donné dans le widget d'UI cible, puis envoie un événement KEYCODE_ENTER à ce widget d'UI.
|
elementDescriptors
|
Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android. |
replacementText
|
Texte à saisir dans le widget d'interface utilisateur cible. |
Voici un exemple d'action de script Robo qui saisit "John"
dans un widget d'interface utilisateur avec l'ID de ressource "com.google.samples.apps.topeka:id/first_name"
:
{
"eventType": "VIEW_TEXT_CHANGED",
"replacementText": "John",
"elementDescriptors": [
{
"resourceId": "com.google.samples.apps.topeka:id/first_name"
}
]
}
Clic long
Le tableau suivant répertorie les attributs obligatoires:
Attribut | Description |
"eventType": "VIEW_LONG_CLICKED"
|
-- |
elementDescriptors
|
Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android. Exclusion mutuelle avec visionText .
|
visionText
|
Identifie l'élément sur lequel l'utilisateur a cliqué de manière prolongée à l'aide de la reconnaissance optique des caractères. Exclusion mutuelle avec elementDescriptors .
|
matchIndex
|
Spécifie l'indice de l'occurrence de l'élément cible correspondant, lorsque l'élément cible est identifié à l'aide de visionText . S'il s'agit de 0 , l'action du script Robo sélectionne le premier élément correspondant. S'il s'agit de 1 , l'action du script Robo sélectionne le deuxième élément correspondant, et ainsi de suite. L'ordre est déterminé de gauche à droite, de haut en bas. La valeur par défaut est 0 (le premier élément correspondant est sélectionné).
|
L'attribut suivant est facultatif:
delayTime
: spécifie la durée de la pression sur un clic long, en millisecondes.
Voici un exemple d'action de script Robo qui effectue un clic de cinq secondes sur un widget d'interface utilisateur avec la description de contenu "Avatar 8"
:
{
"eventType": "VIEW_LONG_CLICKED",
"elementDescriptors": [
{
"contentDescription": "Avatar 8"
}
],
"delayTime": 5000
}
Effectuer un geste à un point
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
"eventType": "ONE_POINT_GESTURE"
|
-- |
coordinates
|
Deux coordonnées pour un geste à un point, au format "(x1,y1)->(x2,y2)" en pourcentages ou en pixels. |
L'attribut suivant est facultatif:
dragAndDrop
: si défini surtrue
, le geste à un point effectue une action de glisser-déposer. La valeur par défaut estfalse
.
Voici un exemple d'action de geste à un point de script Robo qui effectue un balayage vers le bas:
{
"eventType": "ONE_POINT_GESTURE",
"coordinates": "(50%,25%)->(50%,75%)"
}
Effectuer un geste à deux points
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
"eventType": "TWO_POINT_GESTURE"
|
-- |
coordinates
|
Quatre coordonnées pour un geste à deux points, au format "(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)" en pourcentages ou en pixels. |
Voici un exemple d'action de script Robo qui effectue un geste de pincement pour zoomer:
{
"eventType": "TWO_POINT_GESTURE",
"coordinates": "(50%,50%)->(25%,50%),(50%,50%)->(75%,50%)"
}
Effectuer une action IME
Cette action appuie sur le bouton d'action actuel (par exemple, "Suivant", "OK" et "Rechercher") dans l'éditeur de mode de saisie (IME) du widget d'interface utilisateur cible spécifié.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
"eventType": "PRESSED_EDITOR_ACTION"
|
-- |
elementDescriptors
|
Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android. |
Voici un exemple d'action de script Robo qui effectue une action IME sur un widget d'UI avec l'ID de ressource "com.google.samples.apps.topeka:id/first_name"
:
{
"eventType": "PRESSED_EDITOR_ACTION",
"elementDescriptors": [
{
"resourceId": "com.google.samples.apps.topeka:id/first_name"
}
]
}
Appuyer sur la touche Retour
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
eventType
|
Indique le type d'action du script Robo. |
"eventType": "PRESSED_BACK"
|
Envoie un événement KEYCODE_BACK à l'appareil.
|
"eventType": "PRESSED_BACK_EMULATOR_28"
|
Utilisé par l'enregistreur de script Robo dans Android Studio pour appuyer sur le bouton Retour sur les émulateurs de l'API 28. |
Voici un exemple d'action de script Robo qui appuie sur Retour:
{
"eventType": "PRESSED_BACK"
}
Appuyez sur "Accueil"
Cette action envoie un événement KEYCODE_HOME
à l'appareil.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "GO_HOME"
|
-- |
Voici un exemple d'action de script Robo qui appuie sur la touche Accueil:
{
"eventType": "GO_HOME"
}
Faire défiler un élément pour l'afficher
Cette action permet au test Robo de faire défiler le widget d'UI correspondant au elementDescriptors
spécifié jusqu'à ce que le widget d'UI correspondant au childElementDescriptors
spécifié soit présent à l'écran, que le widget à faire défiler ne puisse plus être défilé ou que le nombre maximal de 50 défilements soit atteint.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "ELEMENT_SCROLL_INTO_VIEW"
|
-- |
elementDescriptors
|
Identifie le widget d'UI défilé à l'aide de la hiérarchie de l'UI Android. |
childElementDescriptors
|
Identifie le widget d'interface utilisateur vers lequel faire défiler l'écran à l'aide de la hiérarchie de l'interface utilisateur Android. |
Voici un exemple d'action de script Robo qui fait défiler le widget d'interface utilisateur avec l'ID de ressource "my.app.package:id/scrollable_card_container"
jusqu'à ce que le widget d'interface utilisateur avec le texte "Orange"
soit présent à l'écran (ou qu'aucun autre défilement ne puisse être effectué ou que le nombre maximal de 50 défilements soit atteint):
{
"eventType": "ELEMENT_SCROLL_INTO_VIEW",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/scrollable_card_container"
}
],
"childElementDescriptors": [
{
"text": "Orange"
}
]
}
Glissé
Le tableau suivant répertorie les attributs obligatoires:
Attribut | Description |
---|---|
"eventType": "VIEW_SWIPED"
|
-- |
swipeDirection
|
Indique le sens du balayage :
|
elementDescriptors
|
Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android. |
Voici un exemple d'action de script Robo qui balaie vers le haut un widget d'interface utilisateur avec l'ID de ressource "my.app.package:id/custom_content"
:
{
"eventType": "VIEW_SWIPED",
"swipeDirection": "Up",
"elementDescriptors": [
{
"resourceId": "my.app.package:id/custom_content"
}
]
}
Prendre une capture d'écran
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "TAKE_SCREENSHOT"
|
-- |
screenshotName
|
Indique le nom du fichier de capture d'écran. |
Voici un exemple d'action de script Robo qui prend une capture d'écran:
{
"eventType": "TAKE_SCREENSHOT",
"screenshotName": "my_screenshot"
}
Appuyer sur un point de l'écran
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
"eventType": "POINT_TAP"
|
-- |
pointTapXCoordinate
|
Coordonnée X en pixels du point sur lequel l'utilisateur a appuyé. S'exclut mutuellement avec pointTapXPercent et pointTapYPercent .
|
pointTapYCoordinate
|
Coordonnée Y en pixels du point sélectionné. Exclusion mutuelle avec pointTapXPercent et pointTapYPercent .
|
pointTapXPercent
|
Coordonnée X en pourcentage du point sélectionné. S'exclut mutuellement avec pointTapXCoordinate et pointTapYCoordinate .
|
pointTapYPercent
|
Coordonnée Y en pourcentage du point sélectionné. S'exclut mutuellement avec pointTapXCoordinate et pointTapYCoordinate .
|
Voici un exemple d'action de script Robo qui appuie au milieu d'un écran:
{
"eventType": "POINT_TAP",
"pointTapXPercent": 50,
"pointTapYPercent": 50
}
Appuyer sur un point dans un élément
Le tableau suivant répertorie les attributs obligatoires:
Attribut | Description |
"eventType": "POINT_TAP_ELEMENT"
|
-- |
pointTapXPercent
|
Coordonnée X en pourcentage dans l'élément cible. |
pointTapYPercent
|
Coordonnée du pourcentage Y dans l'élément cible. |
elementDescriptors
|
Identifie le widget d'interface utilisateur cible à l'aide de la hiérarchie de l'interface utilisateur Android. |
Voici un exemple d'action de script Robo qui déplace le curseur d'une barre de défilement vers la droite:
{
"eventType": "POINT_TAP_ELEMENT",
"pointTapXPercent": 80,
"pointTapYPercent": 50,
"elementDescriptors": [
{
"resourceId": "my.app.package:id/my_seekbar"
}
]
}
Arrêter l'exploration
Cette action arrête le test Robo.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
---|---|
"eventType": "TERMINATE_CRAWL"
|
-- |
Voici un exemple d'action de script Robo qui arrête un test Robo:
{
"eventType": "TERMINATE_CRAWL"
}
Attente
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "DELAYED_MESSAGE_POSTED"
|
-- |
delayTime
|
Indique la durée d'attente, en millisecondes. |
Voici un exemple d'action de script Robo qui attend trois secondes:
{
"eventType": "DELAYED_MESSAGE_POSTED",
"delayTime": 3000
}
Attendre un élément
Cette action fait attendre le test Robo jusqu'à ce qu'un élément apparaisse à l'écran, jusqu'à l'expiration du délai spécifié.
Le tableau suivant liste les attributs obligatoires:
Attribut | Description |
"eventType": "WAIT_FOR_ELEMENT"
|
-- |
delayTime
|
Indique le délai avant expiration de l'attente, en millisecondes. |
elementDescriptors
|
Identifie le widget d'interface utilisateur attendu à l'aide de la hiérarchie de l'interface utilisateur Android. |
Voici un exemple d'action de script Robo qui attend jusqu'à 30 secondes qu'un widget d'interface utilisateur avec l'ID de ressource "my.app.package:id/confirmation_button"
s'affiche à l'écran:
{
"eventType": "WAIT_FOR_ELEMENT",
"delayTime": 30000,
"elementDescriptors": [
{
"resourceId": "my.app.package:id/confirmation_button"
}
]
}