Diese Seite wurde von der Cloud Translation API übersetzt.

Referenzhandbuch für Robo-Skripte

Dieses Dokument enthält Referenzinformationen zu Robo-Skripts, einschließlich Struktur, Funktionen, Verwendung, Aufzeichnung und Aktionen. Robo-Skripte sind Tests, die manuelle Qualitätssicherungsaufgaben (QA) für mobile Apps automatisieren und kontinuierliche Integrations- (CI) und Pre-Launch-Teststrategien ermöglichen. Ein Robo-Skript ist eine JSON-Datei, die eine Abfolge von Benutzeroberflächen (UI) und anderen Aktionen beschreibt.

Sie können ein Robo-Skript auf folgende Weise erstellen:

Verwenden Sie die Robo-Skript-Aufzeichnungsfunktion.
Erstellen Sie das Robo-Skript manuell.
Zeichnen Sie das Robo-Skript auf und bearbeiten Sie es dann manuell.

Weitere Informationen zur Verwendung von Robo-Skripts finden Sie unter Ausführen eines Robo-Skripts .

Robo-Skript wird Robo-Test zusammen mit anderen Eingaben wie dem App-under-Test-Android-Anwendungspaket (APK) bereitgestellt.

Das Folgende ist ein Beispiel für ein Robo-Skript, das einen Benutzer bei einer App anmeldet, was ausgelöst wird, wenn die zu testende App gestartet wird:

[
  {
    "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"
          }
        ]
      }
    ]
  }
]

Wenn es ein einzelnes Robo-Skript in einer Datei gibt und es die standardmäßige auslösende Bedingung app_under_test_shown hat, wie im obigen Beispiel, dann können Sie das Robo-Skript in einer Datei mit einem einfacheren Format angeben – einfach als Folge seiner Aktionen:

[
  {
    "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"
      }
    ]
  }
]

Struktur

Ein Robo-Skript hat mehrere Attribute, die beschreiben, wie Robo es ausführt. Die meisten dieser Attribute sind optional mit vordefinierten Standardwerten:

Attribut	Beschreibung
`id`	Eine ganze Zahl, die hilft, dieses Robo-Skript in Crawl-Ausgaben zu verfolgen.
`description`	Ähnlich wie `id` , aber aussagekräftiger.
`crawlStage`	Das Stadium eines Crawl-Robo wendet dieses Robo-Skript an. Standardmäßig ist dies die Haupt-Crawling-Phase.
`priority`	Die Priorität dieses Robo-Skripts im Vergleich zu anderen Robo-Skripts. Standardmäßig haben alle Robo-Skripte eine Priorität von `1` .
`maxNumberOfRuns`	Gibt an, wie oft während eines Crawls Robo dieses Robo-Skript ausführen kann. Standardmäßig kann Robo ein Robo-Skript einmal ausführen.
`contextDescriptor`	Beschreibt den Kontext/die Bedingung, die dieses Robo-Skript auslöst. Wenn es weggelassen wird, gilt die Auslösebedingung dieses Robo-Skripts als immer erfüllt; Mit anderen Worten, das Robo-Skript ist bedingungslos.
`actions`	Alle Aktionen dieses Robo-Skripts.

Eine einzelne Datei enthält eine Sammlung von einem oder mehreren Robo-Skripts.

Das Folgende ist ein Beispiel für eine Datei mit zwei unbedingten Robo-Skripts, jedes mit einer einzigen Aktion, die einmal zu Beginn eines Crawls ausgeführt wird:

[
  {
    "id": 1000,
    "description": "My first Robo script",
    "actions": [
      {
        "eventType": "DISABLE_KEYBOARD"
      }
    ]
  },
  {
    "id": 1001,
    "description": "My second Robo script",
    "actions": [
      {
        "eventType": "PRESSED_BACK"
      }
    ]
  }
]

Kontextdeskriptor

Ein Kontextdeskriptor definiert den Kontext/die Bedingung, die ein Robo-Skript auslöst, indem er ein oder eine Kombination mehrerer Attribute verwendet:

Attribut	Beschreibung
`"condition": "element_present"`	Überprüft, ob ein UI-Widget, das `elementDescriptors` oder dem von `visionText` angegebenen Text übereinstimmt, auf dem Bildschirm vorhanden ist.
`"condition": "element_disabled"`	Überprüft, ob ein UI-Widget, das mit `elementDescriptors` übereinstimmt, auf dem Bildschirm vorhanden ist und nicht damit interagiert werden kann.
`"condition": "element_checked"`	Überprüft, ob ein UI-Widget, das mit `elementDescriptors` übereinstimmt, auf dem Bildschirm vorhanden und aktiviert ist.
`"condition": "app_under_test_shown"`	Überprüft, ob die zu testende App im Vordergrund ausgeführt wird.
`"condition": "default_launcher_shown"`	Überprüft, ob der Startbildschirm eines Geräts angezeigt wird, was bedeutet, dass keine Apps im Vordergrund ausgeführt werden.
`"condition": "non_roboscript_action_performed"`	Überprüft, ob die letzte vom Robo-Test ausgeführte Aktion keine Robo-Skriptaktion ist.
`negateCondition`	Wenn auf `true` gesetzt, wird die `condition` negiert. Sie können dieses Attribut beispielsweise verwenden, um zu überprüfen, ob ein UI-Widget NICHT auf dem Bildschirm vorhanden ist oder ob die zu testende App NICHT im Vordergrund ausgeführt wird.
`elementDescriptors`	Ein oder mehrere Elementdeskriptoren, die ein UI-Widget auf dem Bildschirm identifizieren. Sie wird in Kombination mit den Bedingungen `element_present` , `element_disabled` und `element_checked` verwendet. Schließt sich gegenseitig mit `visionText` aus. Weitere Informationen finden Sie unter Elementdeskriptoren .
`visionText`	Text auf dem Bildschirm wird mithilfe der OCR-API (Optical Character Recognition) erkannt. `visionText` wird in Kombination mit der Bedingung `element_present` verwendet. Schließt sich gegenseitig mit `elementDescriptors` aus.

Das Folgende ist ein Beispiel für ein Robo-Skript, das von einem UI-Widget mit einer auf dem Bildschirm vorhandenen Ressourcen-ID "my.app.package:id/page_header" ausgelöst wird:

{
  "id": 1000,
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "my.app.package:id/page_header"
      }
    ]
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "elementDescriptors": [
        {
          "text": "Settings"
        }
      ]
    }
  ]
}

Das Folgende ist ein Beispiel für ein Robo-Skript, das durch "Privacy Policy" ausgelöst wird, das von Optical Character Recognition (OCR) erkannt wird:

{
  "id": 1000,
  "description": "Vision text Robo script",
  "contextDescriptor": {
    "condition": "element_present",
    "visionText": "Privacy Policy"
  },
  "actions": [
    {
      "eventType": "VIEW_CLICKED",
      "visionText": "Privacy Policy"
    }
  ]
}

Das Folgende ist ein Beispiel für ein Robo-Skript, das nach jeder Nicht-Skript-Robo-Aktion 5 Sekunden wartet:

{
  "contextDescriptor": {
    "condition": "non_roboscript_action_performed"
  },
  "maxNumberOfRuns" : 1000,
  "actions" : [
    {
      "eventType" : "DELAYED_MESSAGE_POSTED",
      "delayTime" : 5000
    }]
}

Aktionen

Jede Aktion in einem Robo-Skript wird als Bündel aus einem oder mehreren Attribut-Wert-Paaren dargestellt, die in der folgenden Tabelle beschrieben werden:

Attribut	Beschreibung
`eventType`	Gibt die Art der Aktion an, z. B. Klicken, Text bearbeiten usw. Erforderlich für jede Aktion.
`elementDescriptors`	Deskriptoren, die ein UI-Widget identifizieren. Erforderlich für alle Aktionen, die ein Ziel-UI-Widget haben, z. B. das Klicken auf eine bestimmte Schaltfläche.
`optional`	Wenn auf `true` gesetzt, wird diese Aktion übersprungen, wenn sie nicht ausgeführt werden kann. Diese Aktion wird beispielsweise übersprungen, wenn das Ziel-UI-Widget auf einem Bildschirm nicht gefunden werden kann – ohne dass das enthaltende Robo-Skript fehlschlägt. Standardmäßig ist der Wert `false` .
`replacementText`	Der Text, der in das Ziel-UI-Widget eingegeben werden soll. Erforderlich für Textbearbeitungsaktionen.
`swipeDirection`	Gibt die Richtung des Streichens an. Erforderlich für Wischaktionen.
`delayTime`	Gibt an, wie lange gewartet werden soll, in Millisekunden. Erforderlich für Warteaktionen.
`pointTapXCoordinate` und `pointTapYCoordinate`	Die X- und Y-Koordinaten des Pixels des angetippten Punkts. Schließt sich gegenseitig mit `pointTapXPercent` und `pointTapYPercent` aus. Erforderlich für Punkttipp-Aktionen.
`pointTapXPercent` und `pointTapYPercent`	Die prozentualen X- und Y-Koordinaten des angetippten Punkts. Schließt sich gegenseitig mit `pointTapXCoordinate` und `pointTapYCoordinate` aus. Erforderlich für Punkttipp-Aktionen.

Das Folgende ist ein Beispiel für ein Robo-Skript mit zwei Aktionen ohne Ziel-UI-Widgets, was bedeutet, dass diese Aktionen nicht auf einem bestimmten UI-Widget ausgeführt werden:

[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "delayTime": 3000
  },
  {
    "eventType": "PRESSED_BACK"
  }
]

Elementdeskriptoren

Ein Elementdeskriptor identifiziert ein UI-Widget mithilfe eines oder mehrerer der folgenden identifizierenden Attribute:

Attribut	Beschreibung
`className`	–
`ancestorClassName`	Klassenname des Vorfahren der UI-Hierarchie des Elements. Ein Vorfahre ist einer der übergeordneten Knoten in der UI-Hierarchie des Elements, einschließlich des Elements selbst.
`resourceId`	–
`resourceIdRegex`	Regulärer Java-Ausdruck zum Abgleichen `resourceId` .
`contentDescription`	–
`contentDescriptionRegex`	Regulärer Java-Ausdruck zum Abgleichen `contentDescription` .
`text` (der auf dem Bildschirm erscheint)	–
`textRegex`	Regulärer Java-Ausdruck zum Abgleichen `text` .
`groupViewChildPosition` , `recyclerViewChildPosition` oder `adapterViewChildPosition`	Stellt die untergeordnete Position eines UI-Widgets in Abhängigkeit von der Art seines übergeordneten Widgets dar.

Häufig sind diese Attribute undefiniert, z. B. kann eine Schaltfläche keinen Text und keine Inhaltsbeschreibung haben. Selbst wenn einige Attributwerte vorhanden sind, sind sie auf einem bestimmten App-Bildschirm möglicherweise nicht eindeutig (einschließlich resourceId ).

Beispielsweise ist die Unterscheidung zwischen Elementen einer Liste im Allgemeinen nur möglich, indem ihre unterschiedlichen untergeordneten Positionen innerhalb ihres übergeordneten Widgets verwendet werden. Dies bedeutet, dass die Verwendung von nur einem Elementdeskriptor zur Identifizierung eines UI-Widgets normalerweise nicht ausreicht. Daher enthält das Attribut elementDescriptors einer Aktion eine Folge von Elementdeskriptoren, die so angeordnet sind, dass der erste dem Ziel-UI-Widget entspricht, der zweite dem übergeordneten Widget des Ziel-UI-Widgets entspricht und so weiter. Das Ziel-UI-Widget einer Aktion wird abgeglichen, wenn alle seine Elementdeskriptoren mit der entsprechenden Unterhierarchie des UI-Widgets übereinstimmen.

Das Folgende ist ein Beispiel für ein Robo-Skript mit einer Textänderung und Klickaktionen, die beide erfordern, dass Sie das Ziel-UI-Widget mithilfe der bereitgestellten Elementdeskriptoren identifizieren:

[
  {
    "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"
      }
    ]
  }
]

Ausführungsmöglichkeiten

Optional können Sie der Liste der Aktionen in einem Robo-Skript ein JSON-Objekt voranstellen, das die Ausführungsoptionen für dieses Robo-Skript angibt. Dieser Konfigurationsheader beginnt mit dem roboscript Schlüsselwort, gefolgt von einer JSON-Darstellung der gewünschten Ausführungsoptionen.

Robo-Skripte unterstützen die folgenden Ausführungsoptionen:

executionMode - Ausführungsoptionen, die angewendet werden, wenn ein Robo-Skript ausgeführt wird:
- strict – wenn auf true gesetzt, verwendet das Robo-Skript keinen teilweisen Abgleich, überspringt die aktuelle Aktion und suspendiert nicht . Das heißt, das Robo-Skript wird als regulärer Instrumentierungstest ausgeführt und schlägt fehl, sobald eine seiner Aktionen nicht ausgeführt werden kann.
postscript - Ausführungsoptionen, die angewendet werden, nachdem ein Robo-Skript abgeschlossen ist:
- terminate - Wenn auf true gesetzt, stoppt Robo-Test das Crawlen, nachdem das Robo-Skript abgeschlossen ist.

Das Folgende ist ein Beispiel für ein Robo-Skript, das im strict Modus ausgeführt wird und drei Sekunden lang schläft, wonach das Crawlen stoppt:

"roboscript": {
  "executionMode": {
    "strict": true
  },
  "postscript": {
    "terminate": true
  }
}
[
  {
    "eventType": "DELAYED_MESSAGE_POSTED",
    "delayTime": 3000
  }
]

Vorlagenparameter

Ein Vorlagenparameter ist ein Platzhalter in einem Robo-Skript, der durch den tatsächlichen Wert ersetzt wird, wenn der Robo-Test dieses Robo-Skript zur Ausführung lädt. Vorlagenparametern wird ein doppelter Unterstrich gefolgt von einem Prozentzeichen vorangestellt und ihnen wird ein Prozentzeichen gefolgt von einem doppelten Unterstrich nachgestellt.

Robo-Skripte unterstützen die folgenden Vorlagenparameter:

__%APP_PACKAGE_NAME%__ – der Paketname der zu testenden App.

Das Folgende ist ein Beispiel für ein Robo-Skript, das den App-under-Test-Prozess stoppt:

[
  {
    "eventType": "ADB_SHELL_COMMAND",
    "command": "am force-stop __%APP_PACKAGE_NAME%__"
  }
]

Kommentare

Ein Robo-Skript kann Kommentarzeilen enthalten, die mit # oder // beginnen.

Das Folgende ist ein Beispiel für ein Robo-Skript mit einigen Kommentaren:

# Confirm a user account.
[
  {
    // Click the DONE button.
    "eventType": "VIEW_CLICKED",
    "elementDescriptors": [
      {
        "resourceId": "com.google.samples.apps.topeka:id/done"
      }
    ]
  }
]

Fähigkeiten

Standardmäßig bleibt das Robo-Skript aktiv, bis alle Aktionen eines Robo-Skripts abgeschlossen (oder zumindest versucht) sind. Der Robo-Test versucht immer wieder, eine Robo-Skriptaktion abzugleichen, wenn er eine auszuführende Aktion auswählt. Robo-Skript verwendet die folgenden Techniken, um die Robustheit zu erhöhen:

Technik	Beschreibung
Teilweise Übereinstimmung	Wenn die aktuelle Robo-Script-Aktion nicht vollständig abgeglichen werden kann, werden die Abgleichskriterien gelockert und der Abgleich wird wiederholt. Beim teilweisen Abgleich wird der äußerste Elementdeskriptor nicht berücksichtigt, während das Ziel-UI-Widget einer Robo-Skriptaktion abgeglichen wird. Wenn der teilweise Abgleich erfolgreich ist, wird die entsprechende Robo-Script-Aktion wie gewohnt ausgeführt. Diese Technik unterstützt Szenarien, in denen sich die App-Struktur ändert, z. B. zwischen App-Versionen, wenn Bildschirmelemente neu angeordnet werden.
Aktuelle Aktion überspringen	Wenn die aktuelle Robo-Skript-Aktion nicht vollständig oder teilweise zugeordnet werden kann, versucht Robo, die nachfolgende Robo-Skript-Aktion abzugleichen. Wenn die nachfolgende Aktion vollständig oder teilweise übereinstimmt, überspringt der Robo-Test die aktuelle Robo-Skript-Aktion (und kehrt nie zu ihr zurück) und führt die nachfolgende aus. Diese Technik unterstützt Szenarien, in denen sich das App-Verhalten zwischen den Versionen ändert oder fehlerhaft ist, z. B. wenn ein intermittierender Dialog während der Aufzeichnung im Vergleich zur Wiedergabe eines Robo-Skripts auf verschiedenen Bildschirmen angezeigt wird.
Aussetzen	Wenn weder aktuelle noch nachfolgende Robo-Skript-Aktionen vollständig oder teilweise abgeglichen werden können, wird Robo-Skript vorübergehend ausgesetzt und Robo-Test wählt eine Aktion aus, die unter Verwendung seiner anderen Strategien ausgeführt werden soll. Nach Abschluss dieser Aktion setzt Robo Test die Ausführung des Robo-Skripts fort. Solange aktuelle oder nachfolgende Robo-Script-Aktionen nicht zugeordnet werden können, bleibt Robo-Script für eine beliebige Anzahl von Aktionen ausgesetzt. Daher müssen Robo-Skripte nicht unbedingt ein Prolog für einen Robo-Test sein, und Sie können Robo-Skript-Aktionen mit Standard-Robo-Test-Aktionen durchsetzen. Diese Technik unterstützt Szenarien, in denen das App-Verhalten unbeständig ist oder wenn Änderungen zwischen App-Versionen so groß sind, dass der Robo-Test mit seinen Standardaktionen „die Lücken füllen“ muss.

Prioritäten

Wenn ein Robo-Skript seine maxNumberOfRuns erreicht, kann es bei einem bestimmten Crawl nicht mehr ausgelöst werden. Wenn mehr als ein Robo-Skript durch den aktuellen Kontext ausgelöst werden kann, wird Priorität gegeben, indem in der folgenden Reihenfolge das Robo-Skript ausgewählt wird, das:

Hat ein contextDescriptor Attribut.
Hat die höchste priority (standardmäßig haben alle Robo-Skripte dieselbe priority von 1 ).
Erscheint am frühesten in der Liste der Robo-Skripte, wenn die Prioritäten der Robo-Skripte gleich sind.

Das Folgende ist ein Beispiel für eine Datei mit drei Robo-Skripts, die dieselbe Aktion ausführen und durch dieselbe Bedingung ausgelöst werden – die zu testende App befindet sich im Vordergrund:

[
  {
    "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
      }
    ]
  }
]

Wenn sich die zu testende App im Vordergrund befindet, löst Robo in dieser Reihenfolge Folgendes aus:

"Robo script 2" , weil es die höchste Priorität hat.
"Robo script 1" , weil es unter den verbleibenden anwendbaren Robo-Skripts mit derselben Priorität früher erscheint.
"Robo script 3" als letztes zutreffendes Roboscript.

Wiederholte Läufe

Standardmäßig löst Robo ein Robo-Skript höchstens einmal während eines Crawls aus. Dies kann über das Attribut maxNumberOfRuns angepasst werden.

Das Folgende ist ein Beispiel für ein Robo-Skript, das die zu testende App bis zu 10 Mal in den Hintergrund bringt:

{
  "id": 1000,
  "maxNumberOfRuns": 10,
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  },
  "actions": [
    {
      "eventType": "GO_HOME"
    }
  ]
}

Crawl-Phase

Robo-Skripte sind in verschiedenen Phasen eines bestimmten Robo-Crawls anwendbar:

Crawl-Phase	Beschreibung
`pre_crawl`	Bevor Robo die zu testende App startet und mit dem Crawlen beginnt.
`post_crawl`	Nachdem Robo das Crawlen der zu testenden App abgeschlossen hat.
`crawl`	Die Haupt-Crawling-Phase, in der Robo die zu testende App durchsucht.
`close_screen`	Wenn Robo versucht, von einem bestimmten Bildschirm zurückzukehren (Backtrack), wenn alle möglichen Aktionen auf diesem Bildschirm untersucht wurden. Standardmäßig drückt Robo zurück, was in einigen Szenarien unerwünscht ist.

Wenn das crawlStage Attribut eines Robo-Skripts nicht angegeben ist, wird impliziert, dass es crawl ist.

Das Folgende ist ein Beispiel für ein Robo-Skript, das die Benutzerdaten der zu testenden App löscht, bevor Robo mit dem Crawlen beginnt:

{
  "id": 1000,
  "crawlStage": "pre_crawl",
  "actions": [
    {
      "eventType": "ADB_SHELL_COMMAND",
      "command": "pm clear __%APP_PACKAGE_NAME%__"
    }
  ]
}

Das Folgende ist ein Beispiel für ein Robo-Skript, das Robo anweist, auf "Cancel" zu klicken, wenn es versucht, von einem Bestätigungsdialog zurückzukehren (Backtrack):

{
  "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"
        }
      ]
    }
  ]
}

Bedingte Aktionen

Ein Robo-Skript kann bedingte Aktionen enthalten. Bedingte Aktionen haben drei zusätzliche Attribute, die beschreiben, wie Robo sie ausführt:

Attribut	Beschreibung
`priority`	Die Priorität dieser bedingten Aktion im Vergleich zu anderen bedingten Aktionen innerhalb des enthaltenen Robo-Skripts. Standardmäßig haben alle bedingten Aktionen eine Priorität von `1` .
`maxNumberOfRuns`	Wie oft diese bedingte Aktion während einer Ausführung des enthaltenen Robo-Skripts ausgeführt werden kann. Standardmäßig können alle bedingten Aktionen höchstens einmal in einer einzigen Ausführung des sie enthaltenden Robo-Skripts ausgeführt werden.
`contextDescriptor`	Der Kontext/die Bedingung, die diese bedingte Aktion auslöst. Es hat die gleiche Struktur und bietet ähnliche Fähigkeiten wie [der Kontextdeskriptor des Robo-Skripts](#Kontextdeskriptor).

Wenn es ausgelöst wird, führt ein Robo-Skript seine nicht bedingten Aktionen nacheinander in der Reihenfolge ihres Erscheinens aus. Wenn ein Robo-Skript bedingte Aktionen enthält, werden diese jedes Mal berücksichtigt, bevor eine nicht bedingte Aktion zur Ausführung ausgewählt wird. Wenn eine bedingte Aktion ausgelöst und basierend auf ihrer Priorität und der verbleibenden Anzahl von Ausführungen ausgewählt wird, führt das Robo-Skript diese bedingte Aktion aus. Andernfalls führt das Robo-Skript die folgende nicht bedingte Aktion aus. Um gültig zu sein, muss ein Robo-Skript mindestens eine nicht bedingte Aktion enthalten.

Das Folgende ist ein Beispiel für ein unbedingtes Robo-Skript mit einer bedingten Aktion, die Popup-Dialoge schließt, wenn sie zu irgendeinem Zeitpunkt während der Ausführung des Robo-Skripts angezeigt werden:

{
  "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
    }
}

Aktionen ignorieren

Ein Robo-Skript kann Anweisungen für Robo enthalten, bestimmte UI-Widgets oder alle UI-Widgets auf einem bestimmten Bildschirm zu ignorieren. Diese Anweisungen werden entsprechend als ignorierende "Aktionen" mit eventType ELEMENT_IGNORED und ALL_ELEMENTS_IGNORED dargestellt.

Immer wenn das contextDescriptor Attribut eines Robo-Skripts, das ignorierende Aktionen enthält, mit einem bestimmten Bildschirm übereinstimmt, interagiert Robo nicht mit UI-Widgets, auf die seine ignorierenden Aktionen abzielen (es sei denn, eine andere Robo-Skriptaktion veranlasst Robo, eine Aktion auf einem der ignorierten UI-Widgets auszuführen).

Ein Robo-Skript kann eine Mischung aus ignorierenden, bedingten und nicht bedingten Aktionen enthalten. Im Gegensatz zu anderen Robo-Script-Aktionen werden ignorierende Aktionen angewendet, solange contextDescriptor des enthaltenen Robo-Scripts während eines Robo-Crawls mit einem Bildschirm übereinstimmt, unabhängig von den Werten der Attribute „ priority “ und maxNumberOfRuns “.

Das Folgende ist ein Beispiel für eine Datei mit zwei Robo-Skripts. Das erste Robo-Skript lässt Robo alle UI-Widgets auf einem Bildschirm ignorieren, der ein UI-Widget mit einer Ressourcen-ID "my.app.package:id/ignored_screen" enthält. Das zweite Robo-Skript veranlasst Robo, UI-Widgets zu ignorieren, deren Ressourcen-IDs mit dem Java-Regex ".*:id/done" auf einem Bildschirm übereinstimmen, der ein UI-Widget mit einer Ressourcen-ID "my.app.package:id/main_screen" enthält:

[
  {
    "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"
          }
        ]
      }
    ]
  }
]

RecyclerView- und AdapterView-Unterstützung

Untergeordnete Elemente von RecyclerView- und AdapterView-Widgets werden dynamisch geladen und können viele Swipes vom aktuellen Bildschirm entfernt angezeigt werden. Da die Größe eines Bildschirms und die Anzahl der erforderlichen Wischvorgänge, um zu diesem Kind zu gelangen, für verschiedene Geräteformfaktoren unterschiedlich sind, ist es viel robuster, sich auf die Datenposition des Kindes zu verlassen, die absolut ist. Es ist ein weniger robuster Ansatz, sich auf die Anzahl der Wischbewegungen zu verlassen, die erforderlich sind, um dieses Kind auf den Bildschirm zu bringen, und dann seine Bildschirmposition zu verwenden.

Daher erfasst Robo-Skript die absoluten Datenpositionen von RecyclerView-Kindern, die Ziele von Robo-Skript-Aktionen sind, als recyclerViewChildPosition . Robo-Skript erfasst auch die absoluten Datenpositionen von AdapterView-Kindern, die Ziele von Robo-Skript-Aktionen sind, als adapterViewChildPosition .

Aktionen für untergeordnete RecyclerView- und AdapterView-Elemente werden in den folgenden Schritten ausgeführt:

Der Robo-Test stellt sicher, dass das entsprechende Kind auf dem Bildschirm durch eine Positionierungsaktion auf dem enthaltenden RecyclerView oder AdapterView angezeigt wird.
Robo Test führt die aufgezeichnete Aktion direkt auf dem untergeordneten Element aus, da es bereits auf dem Bildschirm angezeigt wird.

Das Folgende ist ein Beispiel für eine Klick-Aktion auf einem untergeordneten 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
    }
  ]
}

Das Folgende ist ein Beispiel für eine Klickaktion auf ein untergeordnetes 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
    }
  ]
}

Zeichnen Sie ein Robo-Skript in Android Studio auf und führen Sie es in Test Lab aus

Sie können ein Robo-Skript in Android Studio erstellen, das das Skript als JSON-Datei speichert. Anschließend können Sie die JSON-Datei mit der Anwendung in Firebase Test Lab hochladen und den Test entsprechend ausführen.

Wenn Sie einen Robo-Test mit einem angehängten Skript ausführen, geht Robo-Test zunächst durch Ihre vordefinierten Aktionen und untersucht dann die App wie gewohnt.

Führen Sie zum Erstellen einer Robo-Skript-JSON-Datei in Android Studio die Schritte unter Aufzeichnen eines Robo-Skripts mit Test Lab in Android Studio aus.

Robo-Script-Aktionen

Das folgende allgemeine optionale Attribut gilt für alle Aktionen:

description – Hilft, die Ausführung dieser Robo-Skriptaktion in Robo-Testausgaben zu verfolgen.

Behauptung

Wenn die behauptete Bedingung wahr ist, fährt das Robo-Skript mit der nächsten Aktion fort, die eine andere Behauptung sein könnte. Andernfalls wird die Ausführung des Robo-Skripts aufgrund einer fehlgeschlagenen Behauptung angehalten.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "ASSERTION"`	--
`contextDescriptor`	Beschreibt den bestätigten Kontext oder die Bedingung. Es hat dieselbe Struktur und bietet ähnliche Funktionen wie der contextDescriptor des Robo-Skripts .

Das Folgende ist ein Beispiel für eine Robo-Skript-Assertion, die überprüft, ob sich die zu testende App im Vordergrund befindet:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "app_under_test_shown"
  }
}

Das Folgende ist ein Beispiel für eine Robo-Skript-Assertion, die überprüft, ob ein UI-Widget mit der Ressourcen-ID "com.google.samples.apps.topeka:id/done" auf einem Bildschirm vorhanden ist:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "element_present",
    "elementDescriptors": [
      {
        "resourceId": "com.google.samples.apps.topeka:id/done"
      }
    ]
  }
}

Das Folgende ist ein Beispiel für eine Robo-Skript-Assertion, die überprüft, ob "Settings" NICHT auf einem Bildschirm mit OCR erkannt wird:

{
  "eventType": "ASSERTION",
  "contextDescriptor": {
    "condition": "element_present",
    "negateCondition": true,
    "visionText": "Settings"
  }
}

Klicken

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`eventType`	Gibt den Typ der Robo-Script-Aktion an.
`"eventType": "VIEW_CLICKED"`	Klickt auf das Zielelement der zu testenden App.
`"eventType": "SOFT_KEYBOARD_CLICK"`	Klickt auf das Zielelement der Soft-Tastatur.
`"eventType": "SOFT_KEYBOARD_RANDOM_CLICK"`	Klickt bis zu `maxNumberOfRuns` mal auf zufällige Elemente der Soft-Tastatur.
`"eventType": "LIST_ITEM_CLICKED"`	Wird vom Robo Script Recorder in Android Studio zum Klicken auf Listenelemente verwendet.
`elementDescriptors`	Identifiziert das angeklickte UI-Widget mithilfe der Android-UI-Hierarchie. Schließt sich gegenseitig mit `visionText` aus.
`visionText`	Identifiziert das angeklickte Element mittels OCR. Schließt sich gegenseitig mit `elementDescriptors` aus.
`maxNumberOfRuns`	Gibt an, wie oft auf ein zufälliges Element der virtuellen Tastatur geklickt werden soll, wenn `eventType` `SOFT_KEYBOARD_RANDOM_CLICK` ist. Der Standardwert ist `1` .

Im Folgenden sehen Sie ein Beispiel für eine Robo-Skript-Aktion, die auf eine Schaltfläche mit der Ressourcen-ID "com.google.samples.apps.topeka:id/done" klickt:

{
  "eventType": "VIEW_CLICKED",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/done"
    }
  ]
}

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die auf einem Bildschirm mit OCR erkannt wird, der auf "Privacy Policy" klickt:

{
  "eventType": "VIEW_CLICKED",
  "visionText": "Privacy Policy"
}

Das Folgende ist ein Beispiel für eine Robo-Script-Aktion, die auf ein Softkeyboard-Element mit der Inhaltsbeschreibung "Emoji button" klickt:

{
  "eventType": "SOFT_KEYBOARD_CLICK",
  "elementDescriptors": [
    {
      "contentDescription": "Emoji button"
    }
  ]
}

Das Folgende ist ein Beispiel für eine Robo-Script-Aktion, die bis zu fünf Mal auf zufällige Softkeyboard-Elemente klickt:

{
  "eventType": "SOFT_KEYBOARD_RANDOM_CLICK",
  "maxNumberOfRuns": 5
}

Deaktivieren Sie die Soft-Tastatur

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "DISABLE_KEYBOARD"`	--

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die die Soft-Tastatur deaktiviert:

{
  "eventType": "DISABLE_KEYBOARD"
}

Führen Sie den adb-Shell-Befehl aus

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "ADB_SHELL_COMMAND"`	--
`command`	Der Shell-Befehl Android Debug Bridge (adb), der ausgeführt werden soll.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die die Benutzerdaten der zu testenden App löscht:

{
  "eventType": "ADB_SHELL_COMMAND",
  "command": "pm clear __%APP_PACKAGE_NAME%__"
}

Berechtigungen erteilen

Diese Aktion wird vom Robo Script Recorder in Android Studio aufgezeichnet, um die Abwärtskompatibilität mit Espresso Test Recorder zu gewährleisten. Der Robo-Test gewährt der zu testenden App zu Beginn jedes Crawls alle Berechtigungen, und daher ist diese Aktion ein No-Op. Verwenden Sie diese Aktion NICHT in Ihren Robo-Skripten.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "PERMISSIONS_REQUEST"`	--

Alle Elemente auf einem Bildschirm ignorieren

Diese Aktion bewirkt, dass Robo alle Elemente auf jedem Bildschirm ignoriert, die das enthaltende Robo-Skript auslösen.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "ALL_ELEMENTS_IGNORED"`	--

Das Folgende ist ein Beispiel für eine Robo-Skriptaktion, die Robo dazu bringt, alle Elemente auf einem Bildschirm zu ignorieren:

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

Ignoriere ein Element

Diese Aktion bewirkt, dass Robo ein Element (oder Elemente) ignoriert, die mit den angegebenen elementDescriptors übereinstimmen.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "ELEMENT_IGNORED"`	--
`elementDescriptors`	Identifiziert das/die ignorierte(n) UI-Widget(s) mithilfe der Android-UI-Hierarchie.

Das Folgende ist ein Beispiel für eine Robo-Skriptaktion, die Robo dazu bringt, alle Elemente zu ignorieren, deren Inhaltsbeschreibungen mit "Avatar" beginnen:

{
  "eventType": "ELEMENT_IGNORED",
  "elementDescriptors": [
    {
      "contentDescriptionRegex": "Avatar.*"
    }
  ]
}

Eingabetext

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`eventType`	Gibt den Typ der Robo-Script-Aktion an.
`"eventType": "VIEW_TEXT_CHANGED"`	Fügt den angegebenen Text in das Ziel-UI-Widget ein.
`"eventType": "ENTER_TEXT"`	gibt den angegebenen Text in das Ziel-UI-Widget ein und sendet dann ein `KEYCODE_ENTER` Ereignis an dieses UI-Widget.
`elementDescriptors`	Identifiziert das Ziel-UI-Widget mithilfe der Android-UI-Hierarchie.
`replacementText`	Der Text, der in das Ziel-UI-Widget eingegeben werden soll.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die "John" in ein UI-Widget mit der Ressourcen-ID "com.google.samples.apps.topeka:id/first_name" eingibt:

{
  "eventType": "VIEW_TEXT_CHANGED",
  "replacementText": "John",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/first_name"
    }
  ]
}

Langer Klick

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "VIEW_LONG_CLICKED"`	--
`elementDescriptors`	Identifiziert das Ziel-UI-Widget mithilfe der Android-UI-Hierarchie.

Das folgende Attribut ist optional:

delayTime - gibt an, wie lange das Drücken eines langen Klicks dauert, in Millisekunden.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die einen fünf Sekunden langen Klick auf ein UI-Widget mit der Inhaltsbeschreibung "Avatar 8" ausführt:

{
  "eventType": "VIEW_LONG_CLICKED",
  "elementDescriptors": [
    {
      "contentDescription": "Avatar 8"
    }
  ],
  "delayTime": 5000
}

Führen Sie eine Ein-Punkt-Geste aus

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "ONE_POINT_GESTURE"`	--
`coordinates`	Zwei Koordinaten für eine Ein-Punkt-Geste, formatiert als „(x1,y1)->(x2,y2)“ in Prozent oder Pixel.

Das folgende Attribut ist optional:

dragAndDrop – wenn auf true gesetzt, führt die Ein-Punkt-Geste eine Drag-and-Drop-Aktion aus. Standardmäßig ist es false .

Das Folgende ist ein Beispiel für eine Robo-Skript-Einpunkt-Gestenaktion, die eine Wischbewegung nach unten ausführt:

{
  "eventType": "ONE_POINT_GESTURE",
  "coordinates": "(50%,25%)->(50%,75%)"
}

Führen Sie eine Zwei-Punkte-Geste aus

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "TWO_POINT_GESTURE"`	--
`coordinates`	Vier Koordinaten für eine Zwei-Punkt-Geste, formatiert als „(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)“ als Prozentsätze oder Pixel.

Das Folgende ist ein Beispiel für eine Robo-Skriptaktion, die eine Pinch-out-Geste ausführt:

{
  "eventType": "TWO_POINT_GESTURE",
  "coordinates": "(50%,50%)->(25%,50%),(50%,50%)->(75%,50%)"
}

Führen Sie eine IME-Aktion durch

Diese Aktion drückt die aktuelle Aktionsschaltfläche, z. B. „Weiter“, „Fertig“ und „Suchen“, im Eingabemethoden-Editor (IME) für das angegebene Ziel-UI-Widget.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "PRESSED_EDITOR_ACTION"`	--
`elementDescriptors`	Identifiziert das Ziel-UI-Widget mithilfe der Android-UI-Hierarchie.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die eine IME-Aktion auf einem UI-Widget mit der Ressourcen-ID "com.google.samples.apps.topeka:id/first_name" ausführt:

{
  "eventType": "PRESSED_EDITOR_ACTION",
  "elementDescriptors": [
    {
      "resourceId": "com.google.samples.apps.topeka:id/first_name"
    }
  ]
}

Drücken Sie zurück

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`eventType`	Gibt den Typ der Robo-Script-Aktion an.
`"eventType": "PRESSED_BACK"`	Sendet ein `KEYCODE_BACK` Ereignis an das Gerät.
`"eventType": "PRESSED_BACK_EMULATOR_28"`	Wird vom Robo-Script-Recorder in Android Studio verwendet, um die Emulator-API 28 zurückzudrängen.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die zurückdrückt:

{
  "eventType": "PRESSED_BACK"
}

Drücken Sie nach Hause

Diese Aktion sendet ein KEYCODE_HOME Ereignis an das Gerät.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "GO_HOME"`	--

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die auf Home drückt:

{
  "eventType": "GO_HOME"
}

Scrollen Sie ein Element in die Ansicht

Diese Aktion bewirkt, dass Robo test das UI-Widget vorwärts scrollt, das mit den angegebenen elementDescriptors übereinstimmt, bis das UI-Widget, das mit den angegebenen childElementDescriptors übereinstimmt, auf dem Bildschirm vorhanden ist oder das gescrollte Widget nicht mehr gescrollt werden kann oder die maximale Anzahl von 50 Bildläufen erreicht ist.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "ELEMENT_SCROLL_INTO_VIEW"`	--
`elementDescriptors`	Identifiziert das gescrollte UI-Widget mithilfe der Android-UI-Hierarchie.
`childElementDescriptors`	Identifiziert das UI-Widget, zu dem mithilfe der Android-UI-Hierarchie gescrollt werden soll.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die das UI-Widget mit der Ressourcen-ID "my.app.package:id/scrollable_card_container" scrollt, bis das UI-Widget mit dem Text "Orange" auf dem Bildschirm vorhanden ist (oder keine Scrolls mehr möglich sind). durchgeführt werden oder die maximale Anzahl von 50 Schriftrollen erreicht ist):

{
  "eventType": "ELEMENT_SCROLL_INTO_VIEW",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/scrollable_card_container"
    }
  ],
  "childElementDescriptors": [
    {
      "text": "Orange"
    }
  ]
}

Wischen

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "VIEW_SWIPED"`	--
`swipeDirection`	Gibt die Richtung des Streichens an: `Left` `Right` `Up` `Down` `Forward` – entweder `Down` oder `Right` , abhängig von der vertikalen oder horizontalen Bildlauffähigkeit des Ziel-UI-Widgets. `Backward` – entweder `Up` oder `Left` , je nach vertikaler oder horizontaler Bildlauffähigkeit des Ziel-UI-Widgets.
`elementDescriptors`	Identifiziert das Ziel-UI-Widget mithilfe der Android-UI-Hierarchie.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die ein UI-Widget mit der Ressourcen-ID "my.app.package:id/custom_content" nach oben wischt:

{
  "eventType": "VIEW_SWIPED",
  "swipeDirection": "Up",
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/custom_content"
    }
  ]
}

Einen Screenshot machen

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "TAKE_SCREENSHOT"`	--
`screenshotName`	Gibt den Dateinamen des Screenshots an.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die einen Screenshot erstellt:

{
  "eventType": "TAKE_SCREENSHOT",
  "screenshotName": "my_screenshot"
}

Tippen Sie auf einen Punkt auf dem Bildschirm

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "POINT_TAP"`	--
`pointTapXCoordinate`	Die Pixel-X-Koordinate des angetippten Punkts. Schließt sich gegenseitig mit `pointTapXPercent` und `pointTapYPercent` aus.
`pointTapYCoordinate`	Die Pixel-Y-Koordinate des angetippten Punkts. Schließt sich gegenseitig mit `pointTapXPercent` und `pointTapYPercent` aus.
`pointTapXPercent`	Die prozentuale X-Koordinate des angetippten Punkts. Schließt sich gegenseitig mit `pointTapXCoordinate` und `pointTapYCoordinate` aus.
`pointTapYPercent`	Die prozentuale Y-Koordinate des angetippten Punkts. Schließt sich gegenseitig mit `pointTapXCoordinate` und `pointTapYCoordinate` aus.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die in der Mitte eines Bildschirms tippt:

{
  "eventType": "POINT_TAP",
  "pointTapXPercent": 50,
  "pointTapYPercent": 50
}

Tippen Sie auf einen Punkt innerhalb eines Elements

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "POINT_TAP_ELEMENT"`	--
`pointTapXPercent`	Die prozentuale X-Koordinate innerhalb des Zielelements.
`pointTapYPercent`	Die prozentuale Y-Koordinate innerhalb des Zielelements.
`elementDescriptors`	Identifiziert das Ziel-UI-Widget mithilfe der Android-UI-Hierarchie.

Das Folgende ist ein Beispiel für eine Robo-Skriptaktion, die den Schieberegler einer Suchleiste nach rechts bewegt:

{
  "eventType": "POINT_TAP_ELEMENT",
  "pointTapXPercent": 80,
  "pointTapYPercent": 50,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/my_seekbar"
    }
  ]
}

Crawl beenden

Diese Aktion stoppt den Robo-Test.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "TERMINATE_CRAWL"`	--

Das Folgende ist ein Beispiel für eine Robo-Skriptaktion, die einen Robo-Test stoppt:

{
  "eventType": "TERMINATE_CRAWL"
}

Warten

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "DELAYED_MESSAGE_POSTED"`	--
`delayTime`	Gibt an, wie lange gewartet werden soll, in Millisekunden.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die drei Sekunden wartet:

{
  "eventType": "DELAYED_MESSAGE_POSTED",
  "delayTime": 3000
}

Warte auf ein Element

Diese Aktion lässt Robo-Test bis zum angegebenen Timeout warten, bis ein Element auf dem Bildschirm erscheint.

Die folgende Tabelle listet die erforderlichen Attribute auf:

Attribut	Beschreibung
`"eventType": "WAIT_FOR_ELEMENT"`	--
`delayTime`	Gibt das Wartezeitlimit in Millisekunden an.
`elementDescriptors`	Identifiziert das erwartete UI-Widget mithilfe der Android-UI-Hierarchie.

Das Folgende ist ein Beispiel für eine Robo-Skript-Aktion, die bis zu 30 Sekunden darauf wartet, dass ein UI-Widget mit der Ressourcen-ID "my.app.package:id/confirmation_button" auf dem Bildschirm erscheint:

{
  "eventType": "WAIT_FOR_ELEMENT",
  "delayTime": 30000,
  "elementDescriptors": [
    {
      "resourceId": "my.app.package:id/confirmation_button"
    }
  ]
}

Nächste Schritte

Erfahren Sie, wie Sie ein Robo-Skript ausführen .