UI Automator के लेगसी एपीआई का इस्तेमाल करना

UI Automator, यूज़र इंटरफ़ेस (यूआई) की टेस्टिंग का एक फ़्रेमवर्क है. यह सिस्टम और इंस्टॉल किए गए ऐप्लिकेशन में, क्रॉस-ऐप्लिकेशन फ़ंक्शनल यूज़र इंटरफ़ेस (यूआई) की टेस्टिंग के लिए सही है. UI Automator के एपीआई की मदद से, डिवाइस पर दिखने वाले एलिमेंट के साथ इंटरैक्ट किया जा सकता है. भले ही, फ़ोकस में कोई भी Activity हो. इसलिए, टेस्ट डिवाइस में सेटिंग मेन्यू या ऐप्लिकेशन लॉन्चर खोलने जैसी कार्रवाइयां की जा सकती हैं. आपका टेस्ट, यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को ढूंढ सकता है. इसके लिए, उस कॉम्पोनेंट में दिखने वाले टेक्स्ट या उसके कॉन्टेंट की जानकारी जैसे डिस्क्रिप्टर का इस्तेमाल किया जा सकता है.

UI Automator का टेस्टिंग फ़्रेमवर्क, इंस्ट्रूमेंटेशन पर आधारित एपीआई है. यह AndroidJUnitRunner टेस्ट रनर के साथ काम करता है. यह ओपेक बॉक्स-स्टाइल के ऑटोमेटेड टेस्ट लिखने के लिए सही है. इसमें टेस्ट कोड, टारगेट ऐप्लिकेशन की इंटरनल जानकारी पर निर्भर नहीं करता.

UI Automator के टेस्टिंग फ़्रेमवर्क की मुख्य सुविधाएं ये हैं:

• टारगेट डिवाइस की स्थिति की जानकारी पाने और उस पर कार्रवाइयां करने के लिए एपीआई. ज़्यादा जानकारी के लिए, डिवाइस की स्थिति की जानकारी ऐक्सेस करना लेख पढ़ें.
• क्रॉस-ऐप्लिकेशन यूज़र इंटरफ़ेस (यूआई) की टेस्टिंग के लिए एपीआई. ज़्यादा जानकारी के लिए, UI Automator के एपीआई लेख पढ़ें.

डिवाइस की स्थिति की जानकारी ऐक्सेस करना

UI Automator का टेस्टिंग फ़्रेमवर्क, UiDevice क्लास उपलब्ध कराता है. इसकी मदद से, टारगेट ऐप्लिकेशन चलाने वाले डिवाइस की स्थिति की जानकारी ऐक्सेस की जा सकती है और उस पर कार्रवाइयां की जा सकती हैं. डिवाइस की प्रॉपर्टी ऐक्सेस करने के लिए, इसके तरीकों को कॉल किया जा सकता है. जैसे, मौजूदा ओरिएंटेशन या डिसप्ले का साइज़. UiDevice क्लास की मदद से, ये कार्रवाइयां भी की जा सकती हैं:

1. डिवाइस का रोटेशन बदलना.
2. हार्डवेयर बटन दबाना. जैसे, "आवाज़ बढ़ाएं".
3. वापस जाएं, होम या मेन्यू बटन दबाना.
4. नोटिफ़िकेशन शेड खोलना.
5. मौजूदा विंडो का स्क्रीनशॉट लेना.

उदाहरण के लिए, होम बटन दबाने की प्रोसेस को सिम्युलेट करने के लिए, UiDevice.pressHome() मैथड को कॉल करें.

UI Automator के एपीआई

UI Automator के एपीआई की मदद से, मज़बूत टेस्ट लिखे जा सकते हैं. इसके लिए, टारगेट किए जा रहे ऐप्लिकेशन की जानकारी जानने की ज़रूरत नहीं होती. इन एपीआई का इस्तेमाल करके, कई ऐप्लिकेशन में यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट कैप्चर और उनमें बदलाव किए जा सकते हैं:

• UiObject2: डिवाइस पर दिखने वाले यूज़र इंटरफ़ेस (यूआई) एलिमेंट को दिखाता है.
• BySelector: यूज़र इंटरफ़ेस (यूआई) एलिमेंट को मैच करने के लिए, शर्तें तय करता है.
• By: BySelector को कम शब्दों में बनाता है.
• Configurator: UI Automator के टेस्ट चलाने के लिए, मुख्य पैरामीटर सेट करने की अनुमति देता है.

उदाहरण के लिए, यहां दिए गए कोड में बताया गया है कि डिवाइस में Gmail ऐप्लिकेशन खोलने के लिए, टेस्ट स्क्रिप्ट कैसे लिखी जा सकती है:

device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.pressHome()

val gmail: UiObject2 = device.findObject(By.text("Gmail"))
// Perform a click and wait until the app is opened.
val opened: Boolean = gmail.clickAndWait(Until.newWindow(), 3000)
assertThat(opened).isTrue()

device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.pressHome();

UiObject2 gmail = device.findObject(By.text("Gmail"));
// Perform a click and wait until the app is opened.
Boolean opened = gmail.clickAndWait(Until.newWindow(), 3000);
assertTrue(opened);

UI Automator सेट अप करना

UI Automator की मदद से, यूज़र इंटरफ़ेस (यूआई) का टेस्ट बनाने से पहले, पक्का करें कि आपने टेस्ट सोर्स कोड की जगह और प्रोजेक्ट डिपेंडेंसी कॉन्फ़िगर कर ली हों. इसके लिए, AndroidX Test के लिए प्रोजेक्ट सेट अप करना लेख पढ़ें.

अपने Android ऐप्लिकेशन मॉड्यूल की build.gradle फ़ाइल में, आपको UI Automator लाइब्रेरी के लिए डिपेंडेंसी रेफ़रंस सेट करना होगा:

UI Automator की टेस्टिंग को ऑप्टिमाइज़ करने के लिए, आपको सबसे पहले टारगेट ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट की जांच करनी चाहिए. साथ ही, यह पक्का करना चाहिए कि उन्हें ऐक्सेस किया जा सके. ऑप्टिमाइज़ेशन के इन सुझावों के बारे में, अगले दो सेक्शन में बताया गया है.

डिवाइस पर यूज़र इंटरफ़ेस (यूआई) की जांच करना

टेस्ट डिज़ाइन करने से पहले, डिवाइस पर दिखने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट की जांच करें. यह पक्का करने के लिए कि UI Automator के टेस्ट, इन कॉम्पोनेंट को ऐक्सेस कर सकें, देखें कि इन कॉम्पोनेंट में दिखने वाले टेक्स्ट लेबल, android:contentDescription वैल्यू या दोनों मौजूद हों.

uiautomatorviewer टूल, लेआउट हैरारकी की जांच करने और डिवाइस के फ़ोरग्राउंड पर दिखने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट की प्रॉपर्टी देखने के लिए, एक सुविधाजनक विज़ुअल इंटरफ़ेस उपलब्ध कराता है. इस जानकारी की मदद से, UI Automator का इस्तेमाल करके ज़्यादा सटीक टेस्ट बनाए जा सकते हैं. उदाहरण के लिए, ऐसा यूज़र इंटरफ़ेस (यूआई) सिलेक्टर बनाया जा सकता है जो दिखने वाली किसी खास प्रॉपर्टी से मैच करता हो.

uiautomatorviewer टूल लॉन्च करने के लिए:

1. टारगेट ऐप्लिकेशन को किसी फ़िज़िकल डिवाइस पर लॉन्च करें.
2. डिवाइस को अपने डेवलपमेंट मशीन से कनेक्ट करें.
3. टर्मिनल विंडो खोलें और <android-sdk>/tools/ डायरेक्ट्री पर जाएं.
4. इस निर्देश की मदद से, टूल चलाएं:

 $ uiautomatorviewer

अपने ऐप्लिकेशन के लिए, यूज़र इंटरफ़ेस (यूआई) की प्रॉपर्टी देखने के लिए:

1. uiautomatorviewer इंटरफ़ेस में, डिवाइस का स्क्रीनशॉट बटन पर क्लिक करें.
2. बाईं ओर मौजूद पैनल में, स्नैपशॉट पर कर्सर घुमाएं. इससे, uiautomatorviewer टूल से पहचाने गए यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट दिखेंगे. प्रॉपर्टी, दाएं पैनल में नीचे की ओर और लेआउट हैरारकी, दाएं पैनल में ऊपर की ओर दिखती हैं.
3. ज़रूरी नहीं है, लेकिन एनएएफ़ नोड टॉगल करें बटन पर क्लिक करके, वे यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट देखे जा सकते हैं जिन्हें UI Automator ऐक्सेस नहीं कर सकता. इन कॉम्पोनेंट के लिए, सीमित जानकारी ही उपलब्ध हो सकती है.

Android में उपलब्ध, यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट के सामान्य टाइप के बारे में जानने के लिए, यूज़र इंटरफ़ेस लेख पढ़ें.

पक्का करें कि आपकी गतिविधि को ऐक्सेस किया जा सके

UI Automator का टेस्ट फ़्रेमवर्क, Android की सुलभता सुविधाओं को लागू करने वाले ऐप्लिकेशन पर बेहतर तरीके से काम करता है. जब View टाइप के यूज़र इंटरफ़ेस (यूआई) एलिमेंट या एसडीके से View की सबक्लास का इस्तेमाल किया जाता है, तो सुलभता की सुविधा लागू करने की ज़रूरत नहीं होती. ऐसा इसलिए, क्योंकि ये क्लास पहले ही ऐसा कर चुकी होती हैं.

हालांकि, कुछ ऐप्लिकेशन, बेहतर उपयोगकर्ता अनुभव देने के लिए, कस्टम यूज़र इंटरफ़ेस (यूआई) एलिमेंट का इस्तेमाल करते हैं. ऐसे एलिमेंट में, सुलभता की सुविधा अपने-आप उपलब्ध नहीं होती. अगर आपके ऐप्लिकेशन में View की ऐसी सबक्लास के इंस्टेंस शामिल हैं जो एसडीके से नहीं है, तो पक्का करें कि आपने इन एलिमेंट में सुलभता की सुविधाएं जोड़ी हों. इसके लिए, यह तरीका अपनाएं:

1. ExploreByTouchHelper को बढ़ाने वाली एक कॉंक्रीट क्लास बनाएं.
2. setAccessibilityDelegate() को कॉल करके, अपनी नई क्लास के इंस्टेंस को किसी खास कस्टम यूज़र इंटरफ़ेस (यूआई) एलिमेंट से जोड़ें.

कस्टम व्यू एलिमेंट में सुलभता की सुविधाएं जोड़ने के बारे में ज़्यादा जानने के लिए, सुलभता की सुविधा वाले कस्टम व्यू बनाना लेख पढ़ें. Android पर सुलभता के लिए, सामान्य सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, ऐप्लिकेशन को ज़्यादा सुलभ बनाना लेख पढ़ें.

UI Automator की टेस्ट क्लास बनाना

UI Automator की टेस्ट क्लास, JUnit 4 की टेस्ट क्लास की तरह ही लिखी जानी चाहिए. JUnit 4 की टेस्ट क्लास बनाने और JUnit 4 के दावे और एनोटेशन इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, इंस्ट्रूमेंटेड यूनिट टेस्ट क्लास बनाना लेख पढ़ें.

अपनी टेस्ट क्लास की परिभाषा की शुरुआत में, @RunWith(AndroidJUnit4.class) एनोटेशन जोड़ें. आपको AndroidJUnitRunner क्लास को, AndroidX Test में उपलब्ध, डिफ़ॉल्ट टेस्ट रनर के तौर पर भी तय करना होगा. इस चरण के बारे में ज़्यादा जानकारी के लिए, किसी डिवाइस या एम्युलेटर पर UI Automator के टेस्ट चलाना लेख पढ़ें.

UI Automator की टेस्ट क्लास में, यह प्रोग्रामिंग मॉडल लागू करें:

1. टेस्ट किए जाने वाले डिवाइस को ऐक्सेस करने के लिए, UiDevice ऑब्जेक्ट पाएं. इसके लिए, getInstance() मैथड को कॉल करें और इसे Instrumentation ऑब्जेक्ट को आर्ग्युमेंट के तौर पर पास करें.
2. डिवाइस पर दिखने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट (उदाहरण के लिए, फ़ोरग्राउंड में मौजूद मौजूदा व्यू) को ऐक्सेस करने के लिए, UiObject2 ऑब्जेक्ट पाएं. इसके लिए, findObject() मैथड को कॉल करें.
3. उस यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट पर उपयोगकर्ता के किसी खास इंटरैक्शन को सिम्युलेट करने के लिए, UiObject2 मैथड को कॉल करें. उदाहरण के लिए, स्क्रोल करने के लिए scrollUntil() और टेक्स्ट फ़ील्ड में बदलाव करने के लिए, setText() को कॉल करें. एक से ज़्यादा यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट या उपयोगकर्ता की कार्रवाइयों के क्रम वाले ज़्यादा जटिल उपयोगकर्ता इंटरैक्शन की जांच करने के लिए, ज़रूरत के हिसाब से चरण 2 और 3 में एपीआई को बार-बार कॉल किया जा सकता है.
4. पक्का करें कि इन उपयोगकर्ता इंटरैक्शन के बाद, यूज़र इंटरफ़ेस (यूआई) में उम्मीद के मुताबिक स्थिति या व्यवहार दिखे.

इन चरणों के बारे में ज़्यादा जानकारी, नीचे दिए गए सेक्शन में दी गई है.

यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट ऐक्सेस करना

The UiDevice ऑब्जेक्ट, डिवाइस की स्थिति को ऐक्सेस और उसमें बदलाव करने का मुख्य तरीका है. अपने टेस्ट में, UiDevice के तरीकों को कॉल करके, अलग-अलग प्रॉपर्टी की स्थिति की जांच की जा सकती है. जैसे, मौजूदा ओरिएंटेशन या डिसप्ले का साइज़. आपका टेस्ट, UiDevice ऑब्जेक्ट का इस्तेमाल करके, डिवाइस-लेवल की कार्रवाइयां कर सकता है. जैसे, डिवाइस को किसी खास रोटेशन में फ़ोर्स करना, डी-पैड के हार्डवेयर बटन दबाना, और होम और मेन्यू बटन दबाना.

डिवाइस की होम स्क्रीन से टेस्ट शुरू करना एक अच्छा तरीका है. होम स्क्रीन (या डिवाइस में चुनी गई किसी अन्य शुरुआती जगह) से, UI Automator के एपीआई में दिए गए तरीकों को कॉल करके, यूज़र इंटरफ़ेस (यूआई) के खास एलिमेंट चुने जा सकते हैं और उनके साथ इंटरैक्ट किया जा सकता है.

यहां दिए गए कोड स्निपेट में बताया गया है कि आपका टेस्ट, UiDevice का इंस्टेंस कैसे पा सकता है और होम बटन दबाने की प्रोसेस को सिम्युलेट कैसे कर सकता है:

import org.junit.Before
import androidx.test.runner.AndroidJUnit4
import androidx.test.uiautomator.UiDevice
import androidx.test.uiautomator.By
import androidx.test.uiautomator.Until
...

private const val BASIC_SAMPLE_PACKAGE = "com.example.android.testing.uiautomator.BasicSample"
private const val LAUNCH_TIMEOUT = 5000L
private const val STRING_TO_BE_TYPED = "UiAutomator"

@RunWith(AndroidJUnit4::class)
@SdkSuppress(minSdkVersion = 18)
class ChangeTextBehaviorTest2 {

private lateinit var device: UiDevice

@Before
fun startMainActivityFromHomeScreen() {
  // Initialize UiDevice instance
  device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())

  // Start from the home screen
  device.pressHome()

  // Wait for launcher
  val launcherPackage: String = device.launcherPackageName
  assertThat(launcherPackage, notNullValue())
  device.wait(
    Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT
  )

  // Launch the app
  val context = ApplicationProvider.getApplicationContext<Context>()
  val intent = context.packageManager.getLaunchIntentForPackage(
  BASIC_SAMPLE_PACKAGE).apply {
    // Clear out any previous instances
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  context.startActivity(intent)

  // Wait for the app to appear
  device.wait(
    Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT
    )
  }
}

import org.junit.Before;
import androidx.test.runner.AndroidJUnit4;
import androidx.test.uiautomator.UiDevice;
import androidx.test.uiautomator.By;
import androidx.test.uiautomator.Until;
...

@RunWith(AndroidJUnit4.class)
@SdkSuppress(minSdkVersion = 18)
public class ChangeTextBehaviorTest {

  private static final String BASIC_SAMPLE_PACKAGE
  = "com.example.android.testing.uiautomator.BasicSample";
  private static final int LAUNCH_TIMEOUT = 5000;
  private static final String STRING_TO_BE_TYPED = "UiAutomator";
  private UiDevice device;

  @Before
  public void startMainActivityFromHomeScreen() {
    // Initialize UiDevice instance
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());

    // Start from the home screen
    device.pressHome();

    // Wait for launcher
    final String launcherPackage = device.getLauncherPackageName();
    assertThat(launcherPackage, notNullValue());
    device.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT);

    // Launch the app
    Context context = ApplicationProvider.getApplicationContext();
    final Intent intent = context.getPackageManager()
    .getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
    // Clear out any previous instances
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
    context.startActivity(intent);

    // Wait for the app to appear
    device.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT);
    }
}

उदाहरण में, @SdkSuppress(minSdkVersion = 18) स्टेटमेंट से यह पक्का करने में मदद मिलती है कि टेस्ट सिर्फ़ Android 4.3 (एपीआई लेवल 18) या इसके बाद के वर्शन वाले डिवाइसों पर ही चलेंगे. यह UI Automator फ़्रेमवर्क के लिए ज़रूरी है.

findObject() मैथड का इस्तेमाल करके, UiObject2 को वापस पाएं. यह किसी दिए गए सिलेक्टर की शर्तों से मैच करने वाले व्यू को दिखाता है. ज़रूरत के हिसाब से, अपने ऐप्लिकेशन की टेस्टिंग के अन्य हिस्सों में, बनाए गए UiObject2 इंस्टेंस का फिर से इस्तेमाल किया जा सकता है. ध्यान दें कि UI Automator का टेस्ट फ़्रेमवर्क, मौजूदा डिसप्ले में मैच ढूंढता है. ऐसा तब होता है, जब आपका टेस्ट, यूज़र इंटरफ़ेस (यूआई) एलिमेंट पर क्लिक करने या किसी प्रॉपर्टी के बारे में क्वेरी करने के लिए, UiObject2 इंस्टेंस का इस्तेमाल करता है.

यहां दिए गए स्निपेट में बताया गया है कि आपका टेस्ट, ऐप्लिकेशन में 'रद्द करें' बटन और 'ठीक है' बटन को दिखाने वाले UiObject2 इंस्टेंस कैसे बना सकता है.

val okButton: UiObject2 = device.findObject(
    By.text("OK").clazz("android.widget.Button")
)

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click()
}

UiObject2 okButton = device.findObject(
    By.text("OK").clazz("android.widget.Button")
);

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click();
}

कोई सिलेक्टर तय करना

अगर आपको किसी ऐप्लिकेशन में, यूज़र इंटरफ़ेस (यूआई) के किसी खास कॉम्पोनेंट को ऐक्सेस करना है, तो By क्लास का इस्तेमाल करके, BySelector इंस्टेंस बनाएं. BySelector , दिखाए गए यूज़र इंटरफ़ेस (यूआई) में मौजूद खास एलिमेंट के लिए क्वेरी दिखाता है.

अगर एक से ज़्यादा मैचिंग एलिमेंट मिलते हैं, तो लेआउट हैरारकी में मैच होने वाला पहला एलिमेंट, टारगेट UiObject2 के तौर पर वापस मिलता है. BySelector बनाते समय, अपनी खोज को बेहतर बनाने के लिए, एक साथ कई प्रॉपर्टी को चेन किया जा सकता है. अगर यूज़र इंटरफ़ेस (यूआई) का कोई मैचिंग एलिमेंट नहीं मिलता है, तो null वापस मिलता है.

कई BySelector इंस्टेंस को नेस्ट करने के लिए, आप hasChild() या hasDescendant() मैथड का इस्तेमाल कर सकते हैं. उदाहरण के लिए, यहां दिए गए कोड में बताया गया है कि आपका टेस्ट, टेक्स्ट प्रॉपर्टी वाले चाइल्ड यूज़र इंटरफ़ेस (यूआई) एलिमेंट वाले पहले ListView को ढूंढने के लिए, खोज कैसे तय कर सकता है.

val listView: UiObject2 = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
)

UiObject2 listView = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
);

सिलेक्टर की शर्तों में, ऑब्जेक्ट की स्थिति तय करना काम का हो सकता है. उदाहरण के लिए, अगर आपको चुने गए सभी एलिमेंट की सूची चुननी है, ताकि उन्हें साफ़ किया जा सके, तो आर्ग्युमेंट को 'सही' पर सेट करके, checked() मैथड को कॉल करें.

कार्रवाइयां करना

जब आपके टेस्ट को UiObject2 ऑब्जेक्ट मिल जाता है, तो उस ऑब्जेक्ट से दिखाए गए यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट पर उपयोगकर्ता के इंटरैक्शन करने के लिए, UiObject2 क्लास में मौजूद तरीकों को कॉल किया जा सकता है. इन कार्रवाइयों को तय किया जा सकता है:

• click() : यूज़र इंटरफ़ेस (यूआई) एलिमेंट की दिखने वाली सीमाओं के बीच में क्लिक करता है.
• drag() : इस ऑब्जेक्ट को किसी भी कोऑर्डिनेट पर खींचता है.
• setText() : फ़ील्ड के कॉन्टेंट को साफ़ करने के बाद, बदलाव किए जा सकने वाले फ़ील्ड में टेक्स्ट सेट करता है. इसके उलट, clear() मैथड, बदलाव किए जा सकने वाले फ़ील्ड में मौजूद टेक्स्ट को साफ़ करता है.
• swipe() : तय की गई दिशा में स्वाइप करने की कार्रवाई करता है.
• scrollUntil(): तय की गई दिशा में स्क्रोल करने की कार्रवाई करता है जब तक Condition या EventCondition पूरी नहीं हो जाती.

UI Automator का टेस्ट फ़्रेमवर्क, शेल कमांड का इस्तेमाल किए बिना, Intent भेज सकता है या Activity लॉन्च कर सकता है. इसके लिए, Context ऑब्जेक्ट getContext() की मदद से पाया जाता है.

यहां दिए गए स्निपेट में बताया गया है कि आपका टेस्ट, एक Intent का इस्तेमाल करके, टेस्ट किए जा रहे ऐप्लिकेशन को कैसे लॉन्च कर सकता है. यह तरीका तब काम का होता है, जब आपको सिर्फ़ कैलकुलेटर ऐप्लिकेशन की टेस्टिंग करनी हो और लॉन्चर से कोई मतलब न हो.

fun setUp() {
...

  // Launch a simple calculator app
  val context = getInstrumentation().context
  val intent = context.packageManager.getLaunchIntentForPackage(CALC_PACKAGE).apply {
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  // Clear out any previous instances
  context.startActivity(intent)
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT)
}

public void setUp() {
...

  // Launch a simple calculator app
  Context context = getInstrumentation().getContext();
  Intent intent = context.getPackageManager()
  .getLaunchIntentForPackage(CALC_PACKAGE);
  intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);

  // Clear out any previous instances
  context.startActivity(intent);
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT);
}

नतीजों की पुष्टि करना

InstrumentationTestCase, TestCase को बढ़ाता है. इसलिए, ऐप्लिकेशन में मौजूद यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट, उम्मीद के मुताबिक नतीजे देते हैं या नहीं, यह टेस्ट करने के लिए, JUnit के दावे के स्टैंडर्ड तरीकों का इस्तेमाल किया जा सकता है.

यहां दिए गए स्निपेट में बताया गया है कि आपका टेस्ट, कैलकुलेटर ऐप्लिकेशन में कई बटन कैसे ढूंढ सकता है, उन पर क्रम से क्लिक कैसे कर सकता है, और फिर यह पुष्टि कैसे कर सकता है कि सही नतीजा दिख रहा है.

private const val CALC_PACKAGE = "com.myexample.calc"

fun testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click()
  device.findObject(By.res(CALC_PACKAGE, "plus")).click()
  device.findObject(By.res(CALC_PACKAGE, "three")).click()
  device.findObject(By.res(CALC_PACKAGE, "equals")).click()

  // Verify the result = 5
  val result: UiObject2 = device.findObject(By.res(CALC_PACKAGE, "result"))
  assertEquals("5", result.text)
}

private static final String CALC_PACKAGE = "com.myexample.calc";

public void testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click();
  device.findObject(By.res(CALC_PACKAGE, "plus")).click();
  device.findObject(By.res(CALC_PACKAGE, "three")).click();
  device.findObject(By.res(CALC_PACKAGE, "equals")).click();

  // Verify the result = 5
  UiObject2 result = device.findObject(By.res(CALC_PACKAGE, "result"));
  assertEquals("5", result.getText());
}

किसी डिवाइस या एम्युलेटर पर UI Automator के टेस्ट चलाना

UI Automator के टेस्ट, Android Studio या कमांड-लाइन से चलाए जा सकते हैं. पक्का करें कि आपने अपने प्रोजेक्ट में, AndroidJUnitRunner को डिफ़ॉल्ट इंस्ट्रूमेंटेशन रनर के तौर पर तय किया हो.

और उदाहरण

सिस्टम यूज़र इंटरफ़ेस (यूआई) के साथ इंटरैक्ट करना

UI Automator, स्क्रीन पर मौजूद हर चीज़ के साथ इंटरैक्ट कर सकता है. इसमें आपके ऐप्लिकेशन के बाहर मौजूद सिस्टम एलिमेंट भी शामिल हैं. इनके बारे में, यहां दिए गए कोड स्निपेट में बताया गया है:

// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.executeShellCommand("am start -a android.settings.SETTINGS")

// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.executeShellCommand("am start -a android.settings.SETTINGS");

// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openNotification()

// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openNotification();

// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openQuickSettings()

// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openQuickSettings();

// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"))
print(clock.getText())

// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"));
print(clock.getText());

ट्रांज़िशन के लिए इंतज़ार करना

स्क्रीन ट्रांज़िशन में समय लग सकता है. साथ ही, उनके समय का अनुमान लगाना मुश्किल होता है. इसलिए, कार्रवाइयां करने के बाद, UI Automator को इंतज़ार करना चाहिए. इसके लिए, UI Automator कई तरीके उपलब्ध कराता है:

• UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout): उदाहरण के लिए, किसी बटन पर क्लिक करने और नई विंडो दिखने तक इंतज़ार करने के लिए, device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout) को कॉल करें
• UiDevice.wait(Condition<Object, U> condition, long timeout): उदाहरण के लिए, डिवाइस पर कोई खास UiObject2 दिखने तक इंतज़ार करने के लिए, device.wait(Until.hasObject(By.text("my_text")), timeout); को कॉल करें
• UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): उदाहरण के लिए, चेकबॉक्स के चुने जाने तक इंतज़ार करने के लिए, checkbox.wait(Until.checked(true), timeout); को कॉल करें
• UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout): उदाहरण के लिए, किसी बटन पर क्लिक करने और नई विंडो दिखने तक इंतज़ार करने के लिए, button.clickAndWait(Until.newWindow(), timeout); को कॉल करें
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition): उदाहरण के लिए, कोई नया ऑब्जेक्ट दिखने तक नीचे स्क्रोल करने के लिए, object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj'))); को कॉल करें
• UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): उदाहरण के लिए, सबसे नीचे तक स्क्रोल करने के लिए, object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN)); को कॉल करें

यहां दिए गए कोड स्निपेट में बताया गया है कि ट्रांज़िशन के लिए इंतज़ार करने वाले performActionAndWait() मैथड का इस्तेमाल करके, सिस्टम सेटिंग में 'परेशान न करें' मोड बंद करने के लिए, UI Automator का इस्तेमाल कैसे किया जा सकता है:

@Test
@SdkSuppress(minSdkVersion = 21)
@Throws(Exception::class)
fun turnOffDoNotDisturb() {
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
    device.performActionAndWait({
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS")
        } catch (e: IOException) {
            throw RuntimeException(e)
        }
    }, Until.newWindow(), 1000)
    // Check system settings has been opened.
    Assert.assertTrue(device.hasObject(By.pkg("com.android.settings")))

    // Scroll the settings to the top and find Notifications button
    var scrollableObj: UiObject2 = device.findObject(By.scrollable(true))
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP))
    val notificationsButton = scrollableObj.findObject(By.text("Notifications"))

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait({ notificationsButton.click() }, Until.newWindow(), 1000)
    scrollableObj = device.findObject(By.scrollable(true))
    // Scroll down until it finds a Do Not Disturb button.
    val doNotDisturb = scrollableObj.scrollUntil(
        Direction.DOWN,
        Until.findObject(By.textContains("Do Not Disturb"))
    )
    device.performActionAndWait({ doNotDisturb.click() }, Until.newWindow(), 1000)
    // Turn off the Do Not Disturb.
    val turnOnDoNotDisturb = device.findObject(By.text("Turn on now"))
    turnOnDoNotDisturb?.click()
    Assert.assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000))
}

@Test
@SdkSuppress(minSdkVersion = 21)
public void turnOffDoNotDisturb() throws Exception{
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
    device.performActionAndWait(() -> {
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }, Until.newWindow(), 1000);
    // Check system settings has been opened.
    assertTrue(device.hasObject(By.pkg("com.android.settings")));

    // Scroll the settings to the top and find Notifications button
    UiObject2 scrollableObj = device.findObject(By.scrollable(true));
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP));
    UiObject2 notificationsButton = scrollableObj.findObject(By.text("Notifications"));

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait(() -> notificationsButton.click(), Until.newWindow(), 1000);
    scrollableObj = device.findObject(By.scrollable(true));
    // Scroll down until it finds a Do Not Disturb button.
    UiObject2 doNotDisturb = scrollableObj.scrollUntil(Direction.DOWN,
            Until.findObject(By.textContains("Do Not Disturb")));
    device.performActionAndWait(()-> doNotDisturb.click(), Until.newWindow(), 1000);
    // Turn off the Do Not Disturb.
    UiObject2 turnOnDoNotDisturb = device.findObject(By.text("Turn on now"));
    if(turnOnDoNotDisturb != null) {
        turnOnDoNotDisturb.click();
    }
    assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000));
}

अन्य संसाधन

Android के टेस्ट में UI Automator का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, ये संसाधन देखें.

रेफ़रंस के लिए दस्तावेज़:

• UI Automator के एपीआई का रेफ़रंस

सैंपल

• BasicSample: UI Automator का सामान्य सैंपल.