Przewodnik po skryptach Robo

Ten dokument zawiera informacje referencyjne na temat skryptów Robo, w tym ich strukturę, możliwości, użycie, nagrywanie i działania. Skrypty robota to testy, które automatyzują ręczne zadania kontroli jakości aplikacji mobilnych, a także umożliwiają ciągłą integrację (CI) i strategię testowania przed publikacją. Skrypt Roboscript to plik JSON opisujący sekwencję interfejsu użytkownika (UI) i innych działań.

Skrypt Robo możesz utworzyć na te sposoby:

  • Użyj funkcji nagrywania skryptu Robo. (tylko w Androidzie)

  • Ręcznie utwórz skrypt Robo. (Android i iOS+)

  • Nagraj skrypt Robo i edytuj go ręcznie. (tylko w Androidzie)

Więcej informacji o korzystaniu ze skryptów Robo znajdziesz w artykule Uruchamianie skryptu Robo.

Wprowadzenie

Skrypt Robo jest udostępniany testowi Robo wraz z innymi danymi wejściowymi, takimi jak testowany pakiet aplikacji na Androida (APK).

Poniżej znajduje się przykładowy skrypt Robo, który loguje użytkownika w aplikacji i aktywowany przy uruchamianiu testu aplikacji:

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

Jeśli w pliku znajduje się pojedynczy skrypt Robo i ma on domyślny warunek aktywacji app_under_test_shown, jak w przykładzie powyżej, możesz określić skrypt Robo w pliku, używając prostszego formatu – jako sekwencję działań:

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

Obsługa skryptów Robo w iOS+

Robo na iOS+ (wersja beta) ma ograniczoną obsługę skryptów Robo. Składnia skryptu Robo na iOS+ jest identyczna jak na Androida, a obsługiwane funkcje iOS+ działają podobnie jak na Androidzie.

W iOS+ obsługiwane są te działania:

  • Asercja
  • Kliknij
  • Długie kliknięcie
  • Przesuwanie palcem
  • Ignoruj wszystkie elementy
  • Czekaj
  • Zrobić zrzut ekranu
  • Zakończ skanowanie

W iOS+ są obsługiwane te atrybuty identyfikujące w opisie elementu:

  • Nazwa zajęć
  • Nazwa klasy nadrzędnej
  • Opis treści (i wyrażenie regularne)
  • Tekst (i wyrażenie regularne)

Na iOS+ obsługiwane są te warunki wyzwalania w opisach kontekstu:

  • Wyświetlono aplikację w trakcie testowania
  • Element obecny
  • Wykonano działanie innego skryptu niż Robo

Struktura

Skrypt Robo ma kilka atrybutów, które opisują sposób jego wykonywania przez Robo. Większość z tych atrybutów jest opcjonalna i ma zdefiniowane wartości domyślne:

Atrybut Opis
id Liczba całkowita, która pomaga śledzić ten skrypt Robo w wynikach indeksowania. Robo ma wbudowane skrypty Robo z własnymi id. Chociaż ta sama id w różnych skryptach Robo nie wpływa na ich działanie, rozróżnianie działań w wynikach indeksowania może być trudne. Aby uniknąć konfliktów, zalecamy przypisanie do skryptów Robo unikalnej wartości id o wartości 1000 lub większej.
description Podobne do id, ale bardziej opisowe.
crawlStage Etap indeksowania, na którym Robo stosuje ten skrypt. Domyślnie jest to główny etap indeksowania.
priority Priorytet tego skryptu robota w porównaniu z innymi skryptami robota. Domyślnie wszystkie skrypty robota mają priorytet 1.
maxNumberOfRuns Określa, ile razy robot może wykonać ten skrypt podczas indeksowania. Domyślnie Robo może wykonać skrypt Robo tylko raz.
contextDescriptor Opisuje kontekst lub warunek, który wyzwala ten skrypt Robo. Jeśli warunek jest pominięty, przyjmuje się, że warunek roboskryptu jest zawsze spełniony. Innymi słowy, skrypt roboczy jest bezwarunkowy.
actions Wszystkie działania tego skryptu Robo.

Pojedynczy plik zawiera kolekcję co najmniej 1 skryptu Robo.

Oto przykład pliku z 2 bezwarunkowymi skryptami Robo, z których każdy zawiera pojedyncze działanie wykonywane raz na początku indeksowania:

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

Deskryptor kontekstu

Deskryptor kontekstu określa kontekst lub warunek, który uruchamia Roboscripta, za pomocą jednego atrybutu lub kombinacji kilku atrybutów:

Atrybut Opis
"condition": "always" Zawsze uruchamia skrypt Robo.
"condition": "element_present" Sprawdza, czy na ekranie jest widoczny widżet interfejsu użytkownika, który pasuje do elementDescriptors lub tekstu określonego przez visionText.
"condition": "element_disabled" Sprawdza, czy na ekranie jest widżet interfejsu użytkownika zgodny z elementDescriptors, z którym nie można wchodzić w interakcję.
"condition": "element_checked" Sprawdza, czy na ekranie jest widoczny element interfejsu odpowiadający parametrowi elementDescriptors i czy jest zaznaczony.
"condition": "app_under_test_shown" Sprawdzanie, czy testowana aplikacja jest uruchomiona na pierwszym planie.
"condition": "default_launcher_shown" Sprawdzanie, czy wyświetlany jest ekran główny urządzenia, co oznacza, że żadne aplikacje nie są uruchomione na pierwszym planie.
"condition": "non_roboscript_action_performed" Sprawdza, czy ostatnie nonRoboscriptActionCount kolejne działania wykonane przez test Robo nie są działaniami skryptu Robo.
negateCondition Jeśli ma wartość true, neguje condition. Za pomocą tego atrybutu możesz sprawdzić, czy na ekranie NIE ma widżetu interfejsu lub czy testowana aplikacja NIE działa na pierwszym planie.
elementDescriptors Co najmniej 1 element opisu, który identyfikuje widżet interfejsu na ekranie. Jest używany w połączeniu z warunkami element_present, element_disabled i element_checked. Wzajemnie wyklucza się z: visionText. Więcej informacji znajdziesz w opisie atrybutów elementu.
visionText Tekst na ekranie jest wykrywany za pomocą interfejsu API optycznego rozpoznawania znaków (OCR). visionText jest używany w połączeniu z warunkiem element_present. Wzajemnie się wykluczają z opcją elementDescriptors.
nonRoboscriptActionCount Liczba kolejnych działań skryptu, które nie są działaniami roboczymi, wykonanych wcześniej. Jest on używany w połączeniu z warunkiem non_roboscript_action_performed do uruchamiania skryptu Robo po każdym działaniu nonRoboscriptActionCount Robo. Domyślnie jest to 1.

Poniżej znajdziesz przykład skryptu Robo, który jest uruchamiany przez element interfejsu użytkownika z identyfikatorem zasobu "my.app.package:id/page_header" widocznym na ekranie:

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

Poniżej znajduje się przykład skryptu Robo, który jest aktywowany przez metodę "Privacy Policy" wykrytą przez optyczne rozpoznawanie znaków (OCR):

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

Oto przykład skryptu Robo, który czeka 5 sekund po każdym działaniu Robo, które nie jest skryptem:

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

Działania

Każde działanie w skrypcie Robo jest reprezentowane przez pakiet co najmniej 1 pary atrybut-wartość, które zostało opisane w tej tabeli:

Atrybut Opis
eventType Określa typ działania, np. kliknięcie, zmiana tekstu itp. Wymagane w przypadku każdego działania.
elementDescriptors Deskryptory identyfikujące widżet interfejsu użytkownika. Wymagane w przypadku wszystkich działań, które mają docelowy widżet interfejsu, takich jak kliknięcie konkretnego przycisku.
optional Jeśli ma wartość true, to działanie jest pomijane, gdy nie można go wykonać. Na przykład to działanie jest pomijane, gdy nie można znaleźć docelowego widżetu interfejsu na ekranie, ale nie powoduje to błędu w skrypcie Robo. Domyślna wartość to false.
replacementText Tekst do wpisania w docelowym elemencie interfejsu. Wymagane przy edycji tekstu.
swipeDirection Określa kierunek przesunięcia. Wymagane w przypadku działań przesuwania.
delayTime Określa czas oczekiwania w milisekundach. Wymagany w przypadku działań typu „wait” (zaczekaj).
pointTapXCoordinate i pointTapYCoordinate Współrzędne X i Y klikniętego punktu w pikselach. Wzajemnie wyklucza się z pointTapXPercent i pointTapYPercent. Wymagane w przypadku działań wykonywanych za pomocą dotknięcia punktowego.
pointTapXPercent i pointTapYPercent Współrzędne X i Y w procentach dotkniętego punktu. Wzajemnie wyklucza się z opcjami pointTapXCoordinate i pointTapYCoordinate. Wymagane w przypadku działań dotyczących kliknięcia punktu.

Poniżej znajduje się przykład skryptu Robo z 2 działaniami bez docelowych widżetów interfejsu. Oznacza to, że te działania nie działają w konkretnym widżecie interfejsu:

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

Deskryptory elementów

Descriptor elementu identyfikuje element interfejsu za pomocą co najmniej jednego z tych atrybutów:

Atrybut Opis
className –
ancestorClassName Nazwa klasy elementu nadrzędnego hierarchii elementu. Przodek to dowolny z węzłów nadrzędnych w hierarchii interfejsu elementu, w tym sam element.
resourceId –
resourceIdRegex Wyrażenie regularne Java pasujące do resourceId.
contentDescription –
contentDescriptionRegex Wyrażenie regularne Java pasujące do contentDescription.
text (pojawia się na ekranie) –
textRegex Wyrażenie regularne Java pasujące do text.
groupViewChildPosition, recyclerViewChildPosition lub adapterViewChildPosition Reprezentuje pozycję podrzędną widżetu interfejsu w zależności od rodzaju jego widżetu nadrzędnego.

Często te atrybuty są nieokreślone – na przykład przycisk może nie mieć tekstu i opisu treści. Nawet jeśli niektóre wartości atrybutów są obecne, mogą nie być unikalne na danym ekranie aplikacji (w tym resourceId).

Na przykład rozróżnianie elementów listy jest zwykle możliwe tylko przez wykorzystanie różnych pozycji podrzędnych w widżecie nadrzędnym. Oznacza to, że użycie tylko jednego opisu elementu do identyfikacji elementu interfejsu jest zwykle niewystarczające. Dlatego atrybut elementDescriptors działania zawiera sekwencję opisów elementów uporządkowanych w taki sposób, że pierwszy odpowiada docelowym widżetom interfejsu, drugi – ich nadrzędnym widżetom itd. Docelowy widget interfejsu użytkownika akcji jest dopasowywany, gdy wszystkie jego opisy elementów pasują do odpowiedniej podhierarchii widgetu interfejsu użytkownika.

Poniżej przedstawiamy przykład skryptu Robo z działaniami zmiany tekstu i kliknięcia, które wymagają zidentyfikowania docelowego elementu interfejsu użytkownika za pomocą podanych deskryptorów elementów:

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

Opcje wykonania

Opcjonalnie możesz poprzedzić listę działań w skrypcie Robo obiektem JSON określającym opcje wykonania tego skryptu Robo. Nagłówek konfiguracji zaczyna się od słowa kluczowego roboscript, po którym następuje reprezentacja w formacie JSON żądanych opcji wykonania.

Skrypty robota obsługują te opcje wykonania:

  • executionMode – opcje wykonania stosowane podczas wykonywania skryptu Robo:
    • strict – jeśli ustawisz wartość true, skrypt Robo nie będzie używać częściowego dopasowania, pomijania bieżącego działania ani zawieszania. Oznacza to, że skrypt Robo jest wykonywany jako zwykły test instrumentacji i kończy się niepowodzeniem, gdy nie można wykonać żadnego z jego działań. Domyślnie jest to false.
    • dismiss_popups – jeśli ustawisz tę opcję na true, test Robo pominie wszystkie nieoczekiwane dialogi podczas wykonywania skryptu Robo, nawet w trybie strict. Ta opcja nie ma żadnego wpływu, gdy nie jest używany tryb strict. Domyślnie jest to false.
    • notify – jeśli ma wartość false, skrypt Robo nie wyświetla na ekranie powiadomień na początku ani na końcu jego wykonania. Domyślnie jest to true.
  • postscript – opcje wykonania stosowane po zakończeniu skryptu Robo:
    • terminate – jeśli ta opcja jest ustawiona na true, test Robo przestaje indeksować po zakończeniu wykonywania skryptu Robo. Domyślnie jest to false.

Poniżej znajdziesz przykład skryptu Robo wykonywanego w trybie strict bez powiadomień na ekranie, który czeka przez 3 sekundy, po czym przeszukiwanie się zatrzymuje:

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

Parametry szablonu

Parametr szablonu to symbol zastępczy w skrypcie Robo, który jest zastępowany rzeczywistą wartością, gdy test Robo wczytuje skrypt Robo do wykonania. Parametry szablonu są poprzedzone podwójnym podkreśleniem, po którym następuje znak procentu, i są osadzone znakiem procenta, po którym następuje podwójne podkreślenie.

Skrypty robocze obsługują te parametry szablonu:

  • __%APP_PACKAGE_NAME%__ – nazwa pakietu testowanej aplikacji.

Oto przykład skryptu Robo, który zatrzymuje proces testowania aplikacji:

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

Komentarze

Skrypt Robo może zawierać wiersze komentarza, które zaczynają się od # lub //.

Oto przykład skryptu Robo z kilkoma komentarzami:

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

Możliwości

Domyślnie skrypt Robo pozostaje aktywny, dopóki nie zostaną wykonane wszystkie jego działania (lub przynajmniej podjęta próba ich wykonania). Test Robo próbuje dopasować działanie skryptu Robo, gdy wybiera działanie do wykonania. Aby zwiększyć odporność, skrypt Robo stosuje te techniki:

Technika Opis
Dopasowanie częściowe Jeśli bieżące działanie skryptu Robo nie może zostać w pełni dopasowane, kryteria dopasowania są łagodzone i ponowne próby dopasowania są podejmowane. Częściowe dopasowanie nie uwzględnia najbardziej zewnętrznego deskryptora elementu podczas dopasowywania docelowego widżetu interfejsu dla działania skryptu Robo.

Jeśli dopasowanie częściowe się powiedzie, odpowiednie działanie skryptu Robo zostanie wykonane w zwykły sposób. Ta metoda umożliwia obsługę scenariuszy, w których struktura aplikacji ulega zmianie, na przykład między wersjami aplikacji, gdy elementy ekranu są przestawiane.

Pomiń bieżące działanie Jeśli bieżącego działania skryptu Robo nie można w pełni lub częściowo dopasować, Robo próbuje dopasować następne działanie skryptu Robo. Jeśli następna akcja w pełni lub częściowo pasuje, test Robo pomija (i nigdy nie wraca do) bieżącej czynności w skrypcie Robo i wykonuje następną.

Ta metoda jest przydatna w sytuacjach, gdy zachowanie aplikacji zmienia się między wersjami lub jest niestabilne, np. gdy podczas nagrywania lub odtwarzania skryptu Robo jest wyświetlany inny dialog.

Zawieś Jeśli ani bieżące, ani kolejne działania skryptu Robo nie mogą być dopasowane w pełni lub częściowo, skrypt Robo jest tymczasowo zawieszony, a test Robo wybiera działanie do wykonania, korzystając z innych strategii. Po zakończeniu tej czynności test Robo wznawia wykonywanie skryptu Robo.

Dopóki nie uda się dopasować bieżących lub kolejnych działań skryptu Robo, skrypt Robo pozostanie zawieszony dla dowolnej liczby działań. Dlatego skrypty Robo nie muszą być wstępem do testu Robo, a działania w skrypcie Robo możesz przeplatać ze standardowymi działaniami testu Robo. Ta technika sprawdza się w sytuacjach, gdy zachowanie aplikacji jest niestabilne lub gdy zmiany między wersjami aplikacji są na tyle duże, że test Robo musi „uzupełnić luki” za pomocą standardowych działań.

Priorytety

Jeśli skrypt Robo osiągnie wartość maxNumberOfRuns, nie będzie już mógł zostać aktywowany podczas danego indeksowania. Jeśli w obecnym kontekście może zostać uruchomiony więcej niż 1 skrypt Robo, priorytet jest przyznawany przez wybór skryptu Robo w tej kolejności:

  1. Ma atrybut contextDescriptor.
  2. Ma najwyższą wartość priority (domyślnie wszystkie skrypty Robo mają tę samą wartość priority atrybutu 1).
  3. Pojawia się na początku listy skryptów robota, jeśli ich priorytety są takie same.

Poniżej znajduje się przykład pliku z 3 skryptami Robo, które wykonują to samo działanie i są wywoływane przez ten sam warunek – testowana aplikacja jest na pierwszym planie:

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

Gdy testowana aplikacja jest na pierwszym planie, Robo uruchamia te czynności w takiej kolejności:

  1. "Robo script 2", ponieważ ma najwyższy priorytet.
  2. "Robo script 1", ponieważ pojawia się wcześniej wśród pozostałych kwalifikujących się skryptów Robo o tym samym priorytecie.
  3. "Robo script 3" jako ostatni odpowiedni skrypt Robo.

Powtarzane uruchomienia

Domyślnie Robo uruchamia skrypt Robo najwyżej raz podczas indeksowania. Możesz to zmienić za pomocą atrybutu maxNumberOfRuns.

Poniżej znajdziesz przykład skryptu Robo, który przenosi testowaną aplikację do tła maksymalnie 10 razy:

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

Etap indeksowania

Skrypty Robo mają zastosowanie na różnych etapach danego indeksowania Robo:

Etap indeksowania Opis
pre_crawl Zanim Robo uruchomi i zacznie indeksować testowaną aplikację.
post_crawl Gdy Robo zakończy indeksowanie aplikacji w trakcie testowania. post_crawlSkrypt robota nie może trwać dłużej niż 15 sekund, w przeciwnym razie indeksowanie może zostać przerwane z powodu przekroczenia limitu czasu.
crawl Główny etap indeksowania, gdy Robo indeksuje testowaną aplikację.
close_screen Gdy robot próbuje wrócić (cofać się) z danego ekranu, po zbadaniu wszystkich możliwych działań na tym ekranie. Domyślnie Robo naciska przycisk Wstecz, co w niektórych sytuacjach jest niepożądane.

Jeśli atrybut crawlStage skryptu Robo nie jest określony, sugeruje się, że jest to crawl.

Oto przykład skryptu Robo, który czyści dane użytkownika testowanej aplikacji, zanim Robo zacznie indeksować aplikację:

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

Poniżej znajdziesz przykładowy skrypt Robo, który nakazuje Robo kliknięcie "Cancel" przy każdej próbie powrotu (cofnięcia) w oknie potwierdzenia:

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

Działania warunkowe

Skrypt Robo może zawierać działania warunkowe. Działania warunkowe mają 3 dodatkowe atrybuty, które opisują sposób ich wykonywania przez Robo:

Atrybut Opis
priority Priorytet tego działania warunkowego w porównaniu z innymi działaniami warunkowymi w zawierającym go skrypcie Robo. Domyślnie wszystkie akcje warunkowe mają priorytet 1.
maxNumberOfRuns Ile razy ta czynność warunkowa może zostać wykonana podczas jednego wykonania skryptu Robo, który ją zawiera. Domyślnie wszystkie działania warunkowe mogą być wykonywane maksymalnie raz w ramach pojedynczego wykonania skryptu Robo, który je zawiera.
contextDescriptor Kontekst lub warunek, który powoduje to działanie warunkowe. Ma tę samą strukturę i oferuje podobne możliwości jak contextDescriptor w skrypcie Robo.

Po wywołaniu skrypt Robo wykonuje działania bezwarunkowe po kolei w kolejności ich występowania. Jeśli skrypt Robo zawiera działania warunkowe, są one brane pod uwagę za każdym razem przed wybraniem działania bezwarunkowego do wykonania. Jeśli jakiekolwiek działanie warunkowe zostanie wywołane i wybrane na podstawie swojego priorytetu oraz pozostałej liczby uruchomień, skrypt Robo wykona to działanie warunkowe. W przeciwnym razie skrypt wykona to działanie bezwarunkowe. Aby był ważny, skrypt Robo musi zawierać co najmniej 1 działanie bezwarunkowe.

Poniżej znajduje się przykład bezwarunkowego skryptu Robo z działaniem warunkowym, które zamyka wyskakujące okna, jeśli pojawią się w jakimkolwiek momencie podczas wykonywania skryptu 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
    }
}

Ignorowanie działań

Skrypt Robo może zawierać instrukcje, aby Robo zignorował określone widżety interfejsu użytkownika lub wszystkie widżety interfejsu użytkownika na określonym ekranie. Te instrukcje są reprezentowane jako ignorowanie „działań” z wartością eventType ELEMENT_IGNORED i ALL_ELEMENTS_IGNORED.

Gdy atrybut contextDescriptor skryptu Robo zawierającego działania ignorowania pasuje do danego ekranu, Robo nie wchodzi w interakcję z żadnymi widżetami interfejsu docelowymi dla tych działań ignorowania (chyba że jakieś inne działanie skryptu Robo spowoduje, że Robo wykona działanie na jednym z ignorowanych widżetów interfejsu).

Skrypt robota może zawierać różne działania ignorowania, warunkowe i bezwarunkowe. W odróżnieniu od innych działań skryptu Robo działania ignorowania są stosowane, o ile ich zawierający skrypt Robo contextDescriptor pasuje do ekranu podczas indeksowania przez Robo, niezależnie od wartości atrybutów priority i maxNumberOfRuns.

Poniżej znajdziesz przykład pliku z 2 skryptami Robo. Pierwszy skrypt Robo sprawia, że Robo ignoruje wszystkie widżety interfejsu na ekranie zawierającym widżet interfejsu o identyfikatorze zasobu "my.app.package:id/ignored_screen". Drugi skrypt Robo sprawia, że Robo ignoruje widżety interfejsu użytkownika, których identyfikatory zasobów pasują do wyrażenia regularnego Java ".*:id/done" na ekranie zawierającym widżet interfejsu użytkownika z identyfikatorem zasobu "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"
          }
        ]
      }
    ]
  }
]

Obsługa RecyclerView i AdapterView

Elementy podrzędne widżetów RecyclerView i AdapterView są ładowane dynamicznie i mogą być wyświetlane po wielu przesunięciach od bieżącego ekranu. Ponieważ rozmiar ekranu i liczba przesunięć wymaganych do dotarcia do dziecka różnią się w zależności od formatu urządzenia, znacznie bardziej niezawodne jest korzystanie z pozycji danych dziecka, która jest bezwzględna. Nie jest to jednak tak niezawodne rozwiązanie, jak określenie liczby przesunięć, które są wymagane, aby dziecko pojawiło się na ekranie, a następnie określenie jego położenia na ekranie.

Dlatego skrypt Robo przechwytuje bezwzględne pozycje danych obiektu podrzędnego RecyclerView, które są celami działań skryptu Robo, jako recyclerViewChildPosition. Skrypt Robo rejestruje też bezwzględne pozycje danych elementów podrzędnych AdapterView, które są celami działań skryptu Robo, jako adapterViewChildPosition.

Działania na elementach potomnych RecyclerView i AdapterView są wykonywane w tych krokach:

  1. Test robota sprawdza, czy odpowiedni element podrzędny jest wyświetlany na ekranie, poprzez działanie pozycjonujące na RecyclerView lub AdapterView.

  2. Test Robo wykonuje zarejestrowane działanie bezpośrednio na elemencie podrzędnym, ponieważ jest on już widoczny na ekranie.

Poniżej znajdziesz przykład działania kliknięcia na potomku 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
    }
  ]
}

Poniżej znajdziesz przykład działania kliknięcia w podrzędnym elemencie 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
    }
  ]
}

Nagraj skrypt Robo w Android Studio i uruchom go w narzędziu Test Lab

W Android Studio możesz utworzyć skrypt Robo, który zostanie zapisany jako plik JSON. Następnie możesz przesłać plik JSON do usługi Firebase Test Lab za pomocą aplikacji i odpowiednio uruchomić test.

Gdy przeprowadzasz test Robo z dołączonym skryptem, robot najpierw wykonuje czynności oskryptowane przez Ciebie, a potem analizuje aplikację według normalnego schematu.

Aby utworzyć plik JSON skryptu Robo w Android Studio, wykonaj czynności opisane w sekcji Nagrywanie skryptu Robo za pomocą Test Lab w Android Studio.

Działania skryptu Robo

Do wszystkich działań stosuje się ten wspólny atrybut opcjonalny:

  • description – pomaga śledzić wykonanie tej czynności w skrypcie Robo w wynikach testu Robo.

Asercja

Jeśli zadeklarowany warunek jest spełniony, skrypt Robo przechodzi do następnego działania, którym może być kolejne założenie. W przeciwnym razie wykonanie skryptu Robo zostanie wstrzymane z powodu nieudanego potwierdzenia.

Wymagane atrybuty:

Atrybut Opis
"eventType": "ASSERTION" --
contextDescriptor Opisuje zadeklarowany kontekst lub warunek. Ma tę samą strukturę i oferuje podobne funkcje co deskryptor kontekstu skryptu Robo.

Oto przykład stwierdzenia w skrypcie Robo, które sprawdza, czy testowana aplikacja jest na pierwszym planie:

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

Poniżej znajdziesz przykład potwierdzenia skryptu Robo, który sprawdza, czy widżet UI o identyfikatorze zasobu "com.google.samples.apps.topeka:id/done" jest widoczny na ekranie:

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

Poniżej znajdziesz przykład potwierdzenia skryptu Robo, który sprawdza, czy za pomocą OCR na ekranie nie została wykryta strona "Settings":

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

Kliknij

Wymagane atrybuty:

Atrybut Opis
eventType Określa typ działania skryptu Robo.
"eventType": "VIEW_CLICKED" Klika element docelowy w testowanej aplikacji.
"eventType": "SOFT_KEYBOARD_CLICK" Klika element docelowy na wirtualnej klawiaturze.
"eventType": "SOFT_KEYBOARD_RANDOM_CLICK" Klika losowe elementy klawiatury ekranowej do maxNumberOfRuns razy.
"eventType": "LIST_ITEM_CLICKED" Służy do klikania elementów listy przez rejestrator skryptu Robo w Android Studio.
elementDescriptors Identyfikuje kliknięty element interfejsu użytkownika, korzystając z hierarchii interfejsu Androida. Wzajemnie wyklucza się z opcją visionText.
visionText Wykorzystując OCR, rozpoznaje element, na który użytkownik kliknął. Wzajemnie wyklucza się z: elementDescriptors.
matchIndex Określa indeks wystąpienia dopasowanego elementu docelowego, gdy element docelowy jest identyfikowany za pomocą visionText. Jeśli to 0, działanie skryptu Robo wybiera pierwszy pasujący element, jeśli to 1, działanie skryptu Robo wybiera drugi pasujący element itd. Kolejność jest określana od lewej do prawej i od góry do dołu. Wartością domyślną jest 0 (wybierany jest pierwszy pasujący element).
maxNumberOfRuns Określa, ile razy kliknąć losowy element klawiatury ekranowej, gdy eventType = SOFT_KEYBOARD_RANDOM_CLICK. Wartością domyślną jest 1.

Oto przykład działania skryptu Robo, które polega na kliknięciu przycisku o identyfikatorze zasobu "com.google.samples.apps.topeka:id/done":

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

Oto przykład działania skryptu Robo, które klika drugie wystąpienie słowa "Search" wykryte na ekranie za pomocą rozpoznawania tekstu:

{
  "eventType": "VIEW_CLICKED",
  "visionText": "Search",
  "matchIndex": 1
}

Oto przykład działania skryptu Robo, które polega na kliknięciu elementu klawiatury ekranowej z opisem treści "Emoji button":

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

Poniżej znajdziesz przykład działania skryptu Robo, które klika losowe elementy klawiatury ekranowej maksymalnie 5 razy:

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

Wyłączanie klawiatury ekranowej

Wymagane atrybuty:

Atrybut Opis
"eventType": "DISABLE_KEYBOARD" --

Oto przykład działania skryptu Robo, które wyłącza klawiaturę ekranową:

{
  "eventType": "DISABLE_KEYBOARD"
}

Wykonaj polecenie powłoki adb

Wymagane atrybuty:

Atrybut Opis
"eventType": "ADB_SHELL_COMMAND" --
command Polecenie w powłoce Android Debug Bridge (adb), które ma zostać wykonane.

Ten atrybut jest opcjonalny:

  • expectedOutputRegex – oczekiwane dane wyjściowe polecenia jako wyrażenie regularne w Javie. Jeśli dane wyjściowe nie pasują, działanie skryptu Robo się nie powiedzie. Domyślnie jest to pusty ciąg znaków, co oznacza, że dane wyjściowe nie są sprawdzane.

Oto przykład działania skryptu Robo, które usuwa dane użytkownika aplikacji testowanej:

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

Przyznaj uprawnienia

To działanie jest rejestrowane przez rejestrator skryptów Robo w Android Studio w celu zapewnienia zgodności wstecznej z nagrywarką testów Espresso. Test Robo przyznaje wszystkie uprawnienia aplikacji w trakcie testowania na początku każdego indeksowania i dlatego nie jest to działanie. NIE używaj tego działania w skryptach Robo.

Wymagane atrybuty:

Atrybut Opis
"eventType": "PERMISSIONS_REQUEST" --

Ignorowanie wszystkich elementów na ekranie

To działanie powoduje, że Robo ignoruje wszystkie elementy na dowolnym ekranie, który uruchamia skrypt Robo.

Wymagane atrybuty:

Atrybut Opis
"eventType": "ALL_ELEMENTS_IGNORED" --

Poniżej przedstawiamy przykład działania skryptu Robo, które powoduje, że Robo ignoruje wszystkie elementy na ekranie:

{
  "eventType": "ALL_ELEMENTS_IGNORED"
}

Ignorowanie elementu

To działanie powoduje, że Robo ignoruje element (lub elementy) pasujące do określonego wyrażenia.elementDescriptors

Wymagane atrybuty:

Atrybut Opis
"eventType": "ELEMENT_IGNORED" --
elementDescriptors Identyfikuje pomijane widżety interfejsu za pomocą hierarchii interfejsu Androida.

Ten atrybut jest opcjonalny:

  • ignoreChildren – jeśli jest ustawiona na true, Robo ignoruje również wszystkie elementy podrzędne ignorowanych widżetów interfejsu. Domyślnie jest to false.

Poniżej przedstawiamy przykład działania skryptu Robo, które powoduje, że Robo ignoruje wszystkie elementy, których opisy zaczynają się od "Avatar":

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

Wprowadzany tekst

Wymagane atrybuty:

Atrybut Opis
eventType Określa typ działania skryptu Robo.
"eventType": "VIEW_TEXT_CHANGED" Wpisuje podany tekst w docelowym elemencie interfejsu.
"eventType": "ENTER_TEXT" wstawia podany tekst w docelowym elemencie interfejsu użytkownika, a potem wysyła do niego zdarzenie KEYCODE_ENTER.
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida.
replacementText Tekst do wpisania w docelowym widżecie interfejsu.

Oto przykład działania skryptu Robo, które przekazuje dane "John" do widżetu interfejsu użytkownika o identyfikatorze zasobu "com.google.samples.apps.topeka:id/first_name":

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

Kliknięcie i przytrzymanie

Wymagane atrybuty:

Atrybut Opis
"eventType": "VIEW_LONG_CLICKED" --
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida. Wzajemnie wykluczające się z visionText.
visionText Wykorzystując OCR, rozpoznaje element, na którym użytkownik kliknął i przytrzymał. Wzajemnie się wykluczają z opcją elementDescriptors.
matchIndex Określa indeks wystąpienia dopasowanego elementu docelowego, gdy element docelowy jest identyfikowany za pomocą visionText. Jeśli to 0, działanie skryptu Robo wybiera pierwszy pasujący element, jeśli to 1, działanie skryptu Robo wybiera drugi pasujący element itd. Kolejność jest ustalana od lewej do prawej lub od góry do dołu. Wartością domyślną jest 0 (wybierany jest pierwszy pasujący element).

Ten atrybut jest opcjonalny:

  • delayTime – określa czas przytrzymania długiego kliknięcia w milisekundach.

Poniżej przedstawiamy przykład działania skryptu Robo, które polega na kliknięciu przez 5 sekund elementu interfejsu użytkownika z opisem treści "Avatar 8":

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

Wykonywanie gestów jednopunktowych

Wymagane atrybuty:

Atrybut Opis
"eventType": "ONE_POINT_GESTURE" --
coordinates Dwie współrzędne dla gestu jednopunktowego, sformatowane jako „(x1,y1)->(x2,y2)” w procentach lub pikselach.

Ten atrybut jest opcjonalny:

  • dragAndDrop – jeśli ustawisz wartość true, gest jednopunktowy spowoduje przeciągnięcie i upuszczenie. Domyślnie jest to false.

Oto przykład działania gestu jednopunktowego w skrypcie Robo, który wykonuje gest przesunięcia w dół:

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

Wykonaj gest dwupunktowy

Wymagane atrybuty:

Atrybut Opis
"eventType": "TWO_POINT_GESTURE" --
coordinates 4 współrzędne gestu dwupunktowego w formacie „(x1,y1)->(x2,y2),(x3,y3)->(x4,y4)” w procentach lub pikselach.

Oto przykład działania akcji skryptu Robo, która wykonuje gest rozsunięcia palców:

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

Wykonaj działanie IME

To działanie naciska bieżący przycisk działania, np. „Dalej”, „Gotowe” lub „Szukaj”, w Edytorze metody wprowadzania (IME) dla określonego docelowego elementu interfejsu.

Wymagane atrybuty:

Atrybut Opis
"eventType": "PRESSED_EDITOR_ACTION" --
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida.

Oto przykład działania skryptu Robo, które wykonuje działanie IME na widżecie interfejsu użytkownika o identyfikatorze zasobu "com.google.samples.apps.topeka:id/first_name":

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

Naciśnij Wstecz

Wymagane atrybuty:

Atrybut Opis
eventType Określa typ działania skryptu Robo.
"eventType": "PRESSED_BACK" Wysyła na urządzenie zdarzenie KEYCODE_BACK.
"eventType": "PRESSED_BACK_EMULATOR_28" Służy do obsługi przycisku Wstecz w rejestratorze skryptu Robo w Android Studio na emulatorach z interfejsem API 28.

Oto przykład działania skryptu Robo, które wraca:

{
  "eventType": "PRESSED_BACK"
}

Naciśnij przycisk ekranu głównego

To działanie powoduje wysłanie zdarzenia KEYCODE_HOME do urządzenia.

Wymagane atrybuty:

Atrybut Opis
"eventType": "GO_HOME" --

Oto przykład działania skryptu Robo, które polega na naciśnięciu przycisku Wróć do strony głównej:

{
  "eventType": "GO_HOME"
}

Przewijanie elementu, aby go wyświetlić

W ramach tego działania Robo testuje przewijanie do przodu widgetu interfejsu użytkownika dopasowanego do określonego wyrażenia elementDescriptors, aż do momentu, gdy na ekranie pojawi się widget interfejsu użytkownika dopasowany do określonego wyrażenia childElementDescriptors, lub do momentu, gdy nie będzie można przewijać widgetu, lub do momentu osiągnięcia maksymalnej liczby 50 przewijań.

Wymagane atrybuty:

Atrybut Opis
"eventType": "ELEMENT_SCROLL_INTO_VIEW" --
elementDescriptors Określa element interfejsu użytkownika, który został przescrollowany, korzystając z hierarchii interfejsu użytkownika Androida.
childElementDescriptors Określa element interfejsu, do którego ma się przewinąć, korzystając z hierarchii interfejsu Androida.

Oto przykład działania skryptu Robo, które przewija widget interfejsu z identyfikatorem zasobu "my.app.package:id/scrollable_card_container", aż na ekranie pojawi się widget z tekstem "Orange" (lub do momentu, gdy nie będzie można przewinąć dalej lub nie zostanie osiągnięta maksymalna liczba 50 przewinięć):

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

Przesuwanie palcem

Wymagane atrybuty:

Atrybut Opis
"eventType": "VIEW_SWIPED" --
swipeDirection Określa kierunek przesunięcia:
  • Left
  • Right
  • Up
  • Down
  • Forward – wartość Down lub Right w zależności od tego, czy docelowy element interfejsu użytkownika można przewijać w poziomie czy w pionie.
  • Backward – Up lub Left w zależności od możliwości przewijania w pionie lub poziomie docelowego widżetu interfejsu.
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu Androida.

Oto przykład działania skryptu Robo, które przesuwa w górę element interfejsu użytkownika o identyfikator zasobu "my.app.package:id/custom_content":

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

Zrzut ekranu

Wymagane atrybuty:

Atrybut Opis
"eventType": "TAKE_SCREENSHOT" --
screenshotName Określa nazwę pliku zrzutu ekranu.

Oto przykład działania skryptu Robo, które polega na zrobieniu zrzutu ekranu:

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

Kliknij punkt na ekranie.

Wymagane atrybuty:

Atrybut Opis
"eventType": "POINT_TAP" --
pointTapXCoordinate Pikselowa współrzędna X klikniętego punktu. Współwystępuje z pointTapXPercent i pointTapYPercent.
pointTapYCoordinate Pikselowa współrzędna Y dotkniętego punktu. Współwystępuje z pointTapXPercent i pointTapYPercent.
pointTapXPercent Współrzędna X klikniętego punktu w procentach. Wzajemnie wyklucza się z tagami pointTapXCoordinate i pointTapYCoordinate.
pointTapYPercent Współrzędna procentowa Y klikniętego punktu. Wzajemnie wyklucza się z tagami pointTapXCoordinate i pointTapYCoordinate.

Oto przykład działania skryptu Robo, które polega na dotknięciu w środku ekranu:

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

Kliknij punkt w obrębie elementu

Wymagane atrybuty:

Atrybut Opis
"eventType": "POINT_TAP_ELEMENT" --
pointTapXPercent Procentowa współrzędna X w elemencie docelowym.
pointTapYPercent Współrzędna Y w procentach w elementach docelowych.
elementDescriptors Identyfikuje docelowy element interfejsu użytkownika za pomocą hierarchii interfejsu użytkownika Androida.

Oto przykład działania skryptu Robo, które przesuwa suwak paska przewijania w prawo:

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

Zakończ skanowanie

To działanie powoduje zatrzymanie testu Robo.

Wymagane atrybuty:

Atrybut Opis
"eventType": "TERMINATE_CRAWL" --

Oto przykład działania skryptu Robo, które powoduje zatrzymanie testu Robo:

{
  "eventType": "TERMINATE_CRAWL"
}

Czekaj

Wymagane atrybuty:

Atrybut Opis
"eventType": "DELAYED_MESSAGE_POSTED" --
delayTime Określa czas oczekiwania w milisekundach.

Oto przykład działania skryptu Robo, które czeka 3 sekundy:

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

Poczekaj na element

Dzięki temu test Robo będzie czekać na pojawienie się elementu na ekranie do określonego limitu czasu.

Wymagane atrybuty:

Atrybut Opis
"eventType": "WAIT_FOR_ELEMENT" --
delayTime Określa czas oczekiwania w milisekundach.
elementDescriptors Identyfikuje oczekiwany widget interfejsu użytkownika za pomocą hierarchii interfejsu użytkownika Androida.

Oto przykład działania skryptu Robo, które czeka maksymalnie 30 sekund na pojawienie się na ekranie widżetu interfejsu z identyfikatorem zasobu"my.app.package:id/confirmation_button":

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

Dalsze kroki