Android testing, how to simulate multitouch (zoom in/out) using instruments?

Android Testing: Simulating Multitouch (Zoom In/Out) with Instruments

Introduction

Instruments is a powerful tool for testing Android applications. It allows you to interact with your application in various ways, including simulating user input. This article explores how to simulate multitouch gestures, specifically zoom in and out, using Instruments.

Setting Up Your Test

Before you begin, make sure you have the following set up:

• Android Studio or Eclipse IDE
• An Android emulator or a physical device connected to your computer
• Your Android application project

Using Instruments

Here’s how to simulate multitouch gestures with Instruments:

1. Open Instruments: Open your project in Android Studio or Eclipse. From the menu, navigate to “Run -> Instrument”.
2. Select Your Target: In the Instrument window, select the process of your Android app under the “Target” tab.
3. Add a Multitouch Event:
• Click on the “Add” button at the bottom of the window.
• Choose the “Multitouch” event from the list.
• Configure the event:
• Event Type: Select “Pinch” for zoom in/out gestures.
• Touch Count: Set the number of fingers to 2.
• Start Point: Specify the initial coordinates (x, y) for the first finger.
• End Point: Specify the final coordinates (x, y) for the first finger.
• Duration: Set the duration (in milliseconds) for the pinch gesture.
4. Adjust Coordinates: Adjust the start and end points to achieve the desired zoom effect. For a zoom-in, the fingers should move closer, while for a zoom-out, they should move further apart.
5. Record the Gesture: Click the “Record” button in Instruments to record the multitouch event.
6. Run Your Test: Run your application, and Instruments will simulate the zoom in/out gesture at the specified coordinates and duration. Observe your application’s response.

Example Code:

This example assumes you have an image view named “imageView” in your layout:

UIATarget *target = [UIATarget localTarget];
UIAApplication *app = [target frontMostApp];
UIAWindow *window = [app mainWindow];
UIATableView *tableView = [window elementMatchingClass:@"UIATableView"];
UIAElement *imageView = [tableView elementMatchingClass:@"UIImageView"];
UIAElement *element = [window elementMatchingClass:@"UIATableView"];
if ([element isKindOfClass:[UIATableView class]]) {
	[[target tapWithOptions:@{@"tapOffset": @{-220,-12}} atPoint:CGPointMake(300, 50)] waitForUIEvent:@"tap"];
}

In this example, we’re:

• Fetching the target, application, and window.
• Targeting a UIATableView and getting the UIImageView.
• Simulating a tap on the table view.

Code for Multitouch:

// Example multitouch gesture code using Instruments
UIATarget *target = [UIATarget localTarget];
UIAApplication *app = [target frontMostApp];
UIAWindow *window = [app mainWindow];
UIATableView *tableView = [window elementMatchingClass:@"UIATableView"];
UIAElement *imageView = [tableView elementMatchingClass:@"UIImageView"];
UIATouch *touch1 = [target touchAtPoint:CGPointMake(100, 100)]; // Finger 1 start
UIATouch *touch2 = [target touchAtPoint:CGPointMake(200, 200)]; // Finger 2 start

[touch1 tap]; // Simulate touch down
[touch2 tap];
[target waitForUIEvent:@"tap"]; 

// Simulate a pinch (zoom) gesture
[touch1 moveTo:CGPointMake(110, 110)]; // Move finger 1 slightly inward
[touch2 moveTo:CGPointMake(190, 190)]; // Move finger 2 slightly inward

// ... add additional moves for further pinching (zoom in)

// Release touches to end the pinch
[touch1 release];
[touch2 release];

Notes:

• The specific code for multitouch gestures can vary depending on your application and its UI elements. Adjust the code accordingly.
• You can use Instruments’ recording feature to capture the multitouch gestures and then replay them during testing.
• Experiment with different touch coordinates and durations to achieve the desired zoom effects.

Conclusion

Simulating multitouch gestures with Instruments empowers you to thoroughly test your Android application’s responsiveness and user experience. By leveraging this technique, you can ensure your application handles zoom in/out gestures flawlessly across various devices and screen sizes.