How to use build method of io.appium.java_client.ios.IOSStartScreenRecordingOptions class

1package com.daxiang.core.ios;
2
3import com.daxiang.App;
4import com.daxiang.core.MobileDevice;
5import com.daxiang.core.appium.AppiumServer;
6import com.daxiang.core.appium.IosDriverBuilder;
7import com.daxiang.core.appium.IosPageSourceHandler;
8import com.daxiang.model.Device;
9import com.daxiang.utils.Terminal;
10import com.daxiang.utils.UUIDUtil;
11import io.appium.java_client.AppiumDriver;
12import io.appium.java_client.ios.IOSDriver;
13import io.appium.java_client.ios.IOSStartScreenRecordingOptions;
14import lombok.extern.slf4j.Slf4j;
15import org.apache.commons.exec.ExecuteWatchdog;
16import org.apache.commons.io.FileUtils;
17import org.dom4j.DocumentException;
18import org.springframework.util.StringUtils;
19import org.springframework.web.client.RestTemplate;
20
21import java.io.File;
22import java.io.IOException;
23import java.time.Duration;
24import java.util.Base64;
25
26/**
27 * Created by jiangyitao.
28 */
29@Slf4j
30public class IosDevice extends MobileDevice {
31
32    /**
33     * iproxy localPort remotePort deviceId
34     */
35    private static final String IPROXY = "iproxy %d %d %s";
36    private ExecuteWatchdog mjpegServerIproxyWatchdog;
37
38    public IosDevice(Device device, AppiumServer appiumServer) {
39        super(device, appiumServer);
40    }
41
42    @Override
43    public AppiumDriver newAppiumDriver() {
44        return new IosDriverBuilder().build(this, false);
45    }
46
47    @Override
48    public AppiumDriver initAppiumDriver() {
49        return new IosDriverBuilder().build(this, true);
50    }
51
52    @Override
53    public File screenshot() throws Exception {
54        return IosUtil.screenshotByIdeviceScreenshot(getId());
55    }
56
57    @Override
58    public void installApp(File app) throws IOException {
59        IosUtil.installIpa(app.getAbsolutePath(), getId());
60    }
61
62    @Override
63    public String dump() throws IOException, DocumentException {
64        return new IosPageSourceHandler(getAppiumDriver()).getPageSource();
65    }
66
67    @Override
68    public void startRecordingScreen() {
69        IOSStartScreenRecordingOptions iosOptions = new IOSStartScreenRecordingOptions();
70        // The maximum value is 30 minutes.
71        iosOptions.withTimeLimit(Duration.ofMinutes(30));
72        iosOptions.withFps(10); // default 10
73        iosOptions.withVideoQuality(IOSStartScreenRecordingOptions.VideoQuality.LOW);
74        iosOptions.withVideoType("libx264");
75        ((IOSDriver) getAppiumDriver()).startRecordingScreen(iosOptions);
76    }
77
78    @Override
79    public File stopRecordingScreen() throws IOException {
80        File videoFile = new File(UUIDUtil.getUUID() + ".mp4");
81        String base64Video = ((IOSDriver) getAppiumDriver()).stopRecordingScreen();
82        FileUtils.writeByteArrayToFile(videoFile, Base64.getDecoder().decode(base64Video), false);
83        return videoFile;
84    }
85
86    @Override
87    public void installApp(String appDownloadUrl) throws Exception {
88        if (StringUtils.isEmpty(appDownloadUrl)) {
89            throw new RuntimeException("appDownloadUrl cannot be empty");
90        }
91
92        // download ipa
93        RestTemplate restTemplate = App.getBean(RestTemplate.class);
94        byte[] ipaBytes = restTemplate.getForObject(appDownloadUrl, byte[].class);
95
96        File ipa = new File(UUIDUtil.getUUID() + ".ipa");
97        try {
98            FileUtils.writeByteArrayToFile(ipa, ipaBytes, false);
99            // install
100            IosUtil.installIpa(ipa.getAbsolutePath(), getId());
101        } finally {
102            // delete ipa
103            FileUtils.deleteQuietly(ipa);
104        }
105    }
106
107    public int getMjpegServerPort() {
108        Object mjpegServerPort = getAppiumDriver().getCapabilities().asMap().get("mjpegServerPort");
109        return (int) ((long) mjpegServerPort);
110    }
111
112    public void startMjpegServerIproxy() throws IOException {
113        int mjpegServerPort = getMjpegServerPort();
114        String cmd = String.format(IPROXY, mjpegServerPort, mjpegServerPort, getId());
115        log.info("[ios][{}]mjpegServer: {}", getId(), cmd);
116        mjpegServerIproxyWatchdog = Terminal.executeAsyncAndGetWatchdog(cmd);
117    }
118
119    public void stopMjpegServerIproxy() {
120        if (mjpegServerIproxyWatchdog != null) {
121            log.info("[ios][{}]mjpegServer iproxy stop", getId());
122            mjpegServerIproxyWatchdog.destroyProcess();
123        }
124    }
125}
126

Source: IosDevice.java

package com.daxiang.core.ios;

import com.daxiang.App;
import com.daxiang.core.MobileDevice;
import com.daxiang.core.appium.AppiumServer;
import com.daxiang.core.appium.IosDriverBuilder;
import com.daxiang.core.appium.IosPageSourceHandler;
import com.daxiang.model.Device;
import com.daxiang.utils.Terminal;
import com.daxiang.utils.UUIDUtil;
import io.appium.java_client.AppiumDriver;
import io.appium.java_client.ios.IOSDriver;
import io.appium.java_client.ios.IOSStartScreenRecordingOptions;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.io.FileUtils;
import org.dom4j.DocumentException;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;

import java.io.File;
import java.io.IOException;
import java.time.Duration;
import java.util.Base64;

/**
 * Created by jiangyitao.
 */
@Slf4j
public class IosDevice extends MobileDevice {

    /**
     * iproxy localPort remotePort deviceId
     */
    private static final String IPROXY = "iproxy %d %d %s";
    private ExecuteWatchdog mjpegServerIproxyWatchdog;

    public IosDevice(Device device, AppiumServer appiumServer) {
        super(device, appiumServer);
    }

    @Override
    public AppiumDriver newAppiumDriver() {
        return new IosDriverBuilder().build(this, false);
    }

    @Override
    public AppiumDriver initAppiumDriver() {
        return new IosDriverBuilder().build(this, true);
    }

    @Override
    public File screenshot() throws Exception {
        return IosUtil.screenshotByIdeviceScreenshot(getId());
    }

    @Override
    public void installApp(File app) throws IOException {
        IosUtil.installIpa(app.getAbsolutePath(), getId());
    }

    @Override
    public String dump() throws IOException, DocumentException {
        return new IosPageSourceHandler(getAppiumDriver()).getPageSource();
    }

    @Override
    public void startRecordingScreen() {
        IOSStartScreenRecordingOptions iosOptions = new IOSStartScreenRecordingOptions();
        // The maximum value is 30 minutes.
        iosOptions.withTimeLimit(Duration.ofMinutes(30));
        iosOptions.withFps(10); // default 10
        iosOptions.withVideoQuality(IOSStartScreenRecordingOptions.VideoQuality.LOW);
        iosOptions.withVideoType("libx264");
        ((IOSDriver) getAppiumDriver()).startRecordingScreen(iosOptions);
    }

    @Override
    public File stopRecordingScreen() throws IOException {
        File videoFile = new File(UUIDUtil.getUUID() + ".mp4");
        String base64Video = ((IOSDriver) getAppiumDriver()).stopRecordingScreen();
        FileUtils.writeByteArrayToFile(videoFile, Base64.getDecoder().decode(base64Video), false);
        return videoFile;
    }

    @Override
    public void installApp(String appDownloadUrl) throws Exception {
        if (StringUtils.isEmpty(appDownloadUrl)) {
            throw new RuntimeException("appDownloadUrl cannot be empty");
        }

        // download ipa
        RestTemplate restTemplate = App.getBean(RestTemplate.class);
        byte[] ipaBytes = restTemplate.getForObject(appDownloadUrl, byte[].class);

        File ipa = new File(UUIDUtil.getUUID() + ".ipa");
        try {
            FileUtils.writeByteArrayToFile(ipa, ipaBytes, false);
            // install
            IosUtil.installIpa(ipa.getAbsolutePath(), getId());
        } finally {
            // delete ipa
            FileUtils.deleteQuietly(ipa);
        }
    }

    public int getMjpegServerPort() {
        Object mjpegServerPort = getAppiumDriver().getCapabilities().asMap().get("mjpegServerPort");
        return (int) ((long) mjpegServerPort);
    }

    public void startMjpegServerIproxy() throws IOException {
        int mjpegServerPort = getMjpegServerPort();
        String cmd = String.format(IPROXY, mjpegServerPort, mjpegServerPort, getId());
        log.info("[ios][{}]mjpegServer: {}", getId(), cmd);
        mjpegServerIproxyWatchdog = Terminal.executeAsyncAndGetWatchdog(cmd);
    }

    public void stopMjpegServerIproxy() {
        if (mjpegServerIproxyWatchdog != null) {
            log.info("[ios][{}]mjpegServer iproxy stop", getId());
            mjpegServerIproxyWatchdog.destroyProcess();
        }
    }
}

1package jp.shiftinc.automation.trial;
2
3import io.appium.java_client.AppiumDriver;
4import io.appium.java_client.MobileElement;
5import io.appium.java_client.imagecomparison.OccurrenceMatchingOptions;
6import io.appium.java_client.imagecomparison.OccurrenceMatchingResult;
7import io.appium.java_client.ios.IOSStartScreenRecordingOptions;
8import io.appium.java_client.screenrecording.CanRecordScreen;
9import io.qameta.allure.Allure;
10import io.qameta.allure.Attachment;
11import io.qameta.allure.Feature;
12import io.qameta.allure.Step;
13import org.junit.jupiter.api.AfterEach;
14import org.junit.jupiter.api.BeforeAll;
15import org.junit.jupiter.api.TestInstance;
16import org.junit.jupiter.params.ParameterizedTest;
17import org.junit.jupiter.params.provider.Arguments;
18import org.junit.jupiter.params.provider.MethodSource;
19import org.openqa.selenium.OutputType;
20import org.openqa.selenium.WebElement;
21
22import javax.imageio.ImageIO;
23import java.awt.image.BufferedImage;
24import java.io.ByteArrayInputStream;
25import java.io.ByteArrayOutputStream;
26import java.io.File;
27import java.io.IOException;
28import java.nio.file.Files;
29import java.nio.file.Paths;
30import java.util.Base64;
31import java.util.concurrent.TimeUnit;
32import java.util.stream.Stream;
33
34import static org.junit.jupiter.api.Assertions.assertNotNull;
35import static org.junit.jupiter.params.provider.Arguments.arguments;
36
37@SuppressWarnings({"SameParameterValue", "FieldCanBeLocal"})
38@Feature("Appiumイメージセレクタテスト")
39@TestInstance(TestInstance.Lifecycle.PER_CLASS)
40class TestMobileApp {
41    private AppiumDriver driver;
42    private OSBase osInfo;
43
44    @BeforeAll
45    void setupClass() {
46    }
47
48    @Step("{osName}／イメージセレクタでログイン")
49    @ParameterizedTest
50    @MethodSource("osMartix")
51    void imageSelectorTest(String osName) throws IOException, InterruptedException {
52        setup(osName);
53
54        // イメージセレクタ
55        WebElement loginElm = driver.findElementByImage(getReferenceImageB64("racine_sut_login.png"));
56        // visualization
57        String imageResult = loginElm.getAttribute("visual");
58        // Allureにアタッチ(サービス関数経由）
59        addAttachment(Base64.getDecoder().decode(imageResult), "image-selector");
60        loginElm.click();
61
62        Thread.sleep(20000);
63        //addAttachment(driver.getScreenshotAs(OutputType.BYTES),"img1");
64        // テンプレートマッチング
65        OccurrenceMatchingResult result = templateMatch("original_template.png");
66        // Allureにアタッチ(サービス関数経由）
67        addAttachment(Base64.getDecoder().decode(result.getVisualization()), "template-matched-result");
68        assertNotNull(result.getRect());
69    }
70
71    Stream<Arguments> osMartix() {
72        return Stream.of(
73                arguments("ios"),
74                arguments("android")
75        );
76    }
77
78    @AfterEach
79    void tearDown() throws IOException {
80        if (driver != null) {
81            String base64Video = ((CanRecordScreen) driver).stopRecordingScreen();
82            String path = String.format("./build/test_%s.mp4",osInfo.osName());
83            Files.write(Paths.get(path), Base64.getDecoder().decode(base64Video));
84            attachVideo(path);
85            driver.closeApp();
86        }
87    }
88
89    private void setup(String os) {
90        osInfo =  os.equals("ios")? new IOSBase():new AndroidBase();
91        driver = osInfo.driver();
92        driver.launchApp();
93        driver.manage().timeouts().implicitlyWait(60, TimeUnit.SECONDS);
94        if (os.equals("ios")) {
95            ((IOSBase)osInfo).iosDriver.startRecordingScreen(
96                    new IOSStartScreenRecordingOptions()
97                            .withVideoType("libx264")
98                            .withVideoScale("320:640")
99                            .withVideoQuality(IOSStartScreenRecordingOptions.VideoQuality.MEDIUM)
100            );
101        } else {
102            ((AndroidBase)osInfo).androidDriver.startRecordingScreen();
103        }
104        MobileElement loginId = (MobileElement) driver.findElement(osInfo.loginId());
105        MobileElement loginPwd = (MobileElement) driver.findElement(osInfo.loginPwd());
106        loginId.sendKeys("demo");
107        loginPwd.click();
108        loginPwd.sendKeys("demo");
109    }
110
111    private String getReferenceImageB64(String imageName) throws IOException {
112        BufferedImage image = ImageIO.read(new File(osInfo.resourceDir() + imageName));
113        ByteArrayOutputStream os = new ByteArrayOutputStream();
114        ImageIO.write(image, "png", os);
115        return Base64.getEncoder().encodeToString(os.toByteArray());
116    }
117
118    private OccurrenceMatchingResult templateMatch(String template) throws IOException {
119        return driver
120                .findImageOccurrence(
121                        driver.getScreenshotAs(OutputType.FILE),
122                        new File(osInfo.resourceDir() + template),
123                        new OccurrenceMatchingOptions()
124                                .withThreshold(0.6)
125                                .withEnabledVisualization());
126    }
127
128    private static void addAttachment(byte[] byteArray, String imageName) {
129        Allure.addAttachment(imageName, "image/png", new ByteArrayInputStream(byteArray), "png");
130    }
131
132    @SuppressWarnings("UnusedReturnValue")
133    @Attachment(value = "video",type="video/mp4",fileExtension = "mp4")
134    private byte[] attachVideo(String path) throws IOException {
135        return getFile(path);
136    }
137
138    private byte[] getFile(String fileName) throws IOException {
139        File file = new File(fileName);
140        return Files.readAllBytes(Paths.get(file.getAbsolutePath()));
141    }
142}
143

Source: TestMobileApp.java

package jp.shiftinc.automation.trial;

import io.appium.java_client.AppiumDriver;
import io.appium.java_client.MobileElement;
import io.appium.java_client.imagecomparison.OccurrenceMatchingOptions;
import io.appium.java_client.imagecomparison.OccurrenceMatchingResult;
import io.appium.java_client.ios.IOSStartScreenRecordingOptions;
import io.appium.java_client.screenrecording.CanRecordScreen;
import io.qameta.allure.Allure;
import io.qameta.allure.Attachment;
import io.qameta.allure.Feature;
import io.qameta.allure.Step;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.WebElement;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.params.provider.Arguments.arguments;

@SuppressWarnings({"SameParameterValue", "FieldCanBeLocal"})
@Feature("Appiumイメージセレクタテスト")
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class TestMobileApp {
    private AppiumDriver driver;
    private OSBase osInfo;

    @BeforeAll
    void setupClass() {
    }

    @Step("{osName}／イメージセレクタでログイン")
    @ParameterizedTest
    @MethodSource("osMartix")
    void imageSelectorTest(String osName) throws IOException, InterruptedException {
        setup(osName);

        // イメージセレクタ
        WebElement loginElm = driver.findElementByImage(getReferenceImageB64("racine_sut_login.png"));
        // visualization
        String imageResult = loginElm.getAttribute("visual");
        // Allureにアタッチ(サービス関数経由）
        addAttachment(Base64.getDecoder().decode(imageResult), "image-selector");
        loginElm.click();

        Thread.sleep(20000);
        //addAttachment(driver.getScreenshotAs(OutputType.BYTES),"img1");
        // テンプレートマッチング
        OccurrenceMatchingResult result = templateMatch("original_template.png");
        // Allureにアタッチ(サービス関数経由）
        addAttachment(Base64.getDecoder().decode(result.getVisualization()), "template-matched-result");
        assertNotNull(result.getRect());
    }

    Stream<Arguments> osMartix() {
        return Stream.of(
                arguments("ios"),
                arguments("android")
        );
    }

    @AfterEach
    void tearDown() throws IOException {
        if (driver != null) {
            String base64Video = ((CanRecordScreen) driver).stopRecordingScreen();
            String path = String.format("./build/test_%s.mp4",osInfo.osName());
            Files.write(Paths.get(path), Base64.getDecoder().decode(base64Video));
            attachVideo(path);
            driver.closeApp();
        }
    }

    private void setup(String os) {
        osInfo =  os.equals("ios")? new IOSBase():new AndroidBase();
        driver = osInfo.driver();
        driver.launchApp();
        driver.manage().timeouts().implicitlyWait(60, TimeUnit.SECONDS);
        if (os.equals("ios")) {
            ((IOSBase)osInfo).iosDriver.startRecordingScreen(
                    new IOSStartScreenRecordingOptions()
                            .withVideoType("libx264")
                            .withVideoScale("320:640")
                            .withVideoQuality(IOSStartScreenRecordingOptions.VideoQuality.MEDIUM)
            );
        } else {
            ((AndroidBase)osInfo).androidDriver.startRecordingScreen();
        }
        MobileElement loginId = (MobileElement) driver.findElement(osInfo.loginId());
        MobileElement loginPwd = (MobileElement) driver.findElement(osInfo.loginPwd());
        loginId.sendKeys("demo");
        loginPwd.click();
        loginPwd.sendKeys("demo");
    }

    private String getReferenceImageB64(String imageName) throws IOException {
        BufferedImage image = ImageIO.read(new File(osInfo.resourceDir() + imageName));
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ImageIO.write(image, "png", os);
        return Base64.getEncoder().encodeToString(os.toByteArray());
    }

    private OccurrenceMatchingResult templateMatch(String template) throws IOException {
        return driver
                .findImageOccurrence(
                        driver.getScreenshotAs(OutputType.FILE),
                        new File(osInfo.resourceDir() + template),
                        new OccurrenceMatchingOptions()
                                .withThreshold(0.6)
                                .withEnabledVisualization());
    }

    private static void addAttachment(byte[] byteArray, String imageName) {
        Allure.addAttachment(imageName, "image/png", new ByteArrayInputStream(byteArray), "png");
    }

    @SuppressWarnings("UnusedReturnValue")
    @Attachment(value = "video",type="video/mp4",fileExtension = "mp4")
    private byte[] attachVideo(String path) throws IOException {
        return getFile(path);
    }

    private byte[] getFile(String fileName) throws IOException {
        File file = new File(fileName);
        return Files.readAllBytes(Paths.get(file.getAbsolutePath()));
    }
}