add support of mobitru screen recording feature

docs/modules/plugins/pages/plugin-mobitru.adoc

@@ -127,6 +127,12 @@ a|`true` +
 |`false`
 |Inject special code into application to allow emulation of "touch id" action and QR code scan.
 
+|`mobitru.enable-recording`
+a|`true` +
+`false`
+|`false`
+|Enable the video recording for entire appium session. The output recording will be attached to an allure report
+
 |`mobitru.device-wait-timeout`
 |The duration in {durations-format-link} format.
 |`PT5M`

vividus-plugin-mobitru/build.gradle

@@ -6,6 +6,7 @@ dependencies {
     implementation project(':vividus-http-client')
     implementation project(':vividus-extension-selenium')
     implementation project(':vividus-plugin-mobile-app')
+    implementation project(':vividus-reporter')
 
     implementation platform(group: 'org.slf4j', name: 'slf4j-bom', version: '2.0.16')
     implementation(group: 'org.slf4j', name: 'slf4j-api')

vividus-plugin-mobitru/src/main/java/org/vividus/mobitru/client/MobitruClient.java

@@ -79,6 +79,29 @@ public void returnDevice(String deviceId) throws MobitruOperationException
         executeRequest(DEVICE_PATH + "/" + deviceId, HttpMethod.DELETE, UnaryOperator.identity(), HttpStatus.SC_OK);
     }
 
+    public void startDeviceScreenRecording(String deviceId) throws MobitruOperationException
+    {
+        performDeviceRecordingRequest(deviceId, HttpMethod.POST, HttpStatus.SC_CREATED);
+    }
+
+    public byte[] stopDeviceScreenRecording(String deviceId) throws MobitruOperationException
+    {
+        return performDeviceRecordingRequest(deviceId, HttpMethod.DELETE, HttpStatus.SC_OK);
+    }
+
+    private byte[] performDeviceRecordingRequest(String deviceId, HttpMethod httpMethod, int status)
+            throws MobitruOperationException
+    {
+        String url = String.format("%s/%s/recording", DEVICE_PATH, deviceId);
+        return executeRequest(url, httpMethod, UnaryOperator.identity(), status);
+    }
+
+    public byte[] downloadDeviceScreenRecording(String recordingId) throws MobitruOperationException
+    {
+        return executeRequest("/recording/" + recordingId, HttpMethod.GET,
+                UnaryOperator.identity(), HttpStatus.SC_OK);
+    }
+
     public void installApp(String deviceId, String appId, InstallApplicationOptions options)
             throws MobitruOperationException
     {

vividus-plugin-mobitru/src/main/java/org/vividus/mobitru/client/MobitruFacade.java

@@ -31,6 +31,32 @@ public interface MobitruFacade
      */
     String takeDevice(DesiredCapabilities desiredCapabilities) throws MobitruOperationException;
 
+    /**
+     * Start the screen recording on the device with specified UDID.
+     *
+     * @param deviceId The UDID of the device
+     * @throws MobitruOperationException In case of any issues during start the recording.
+     */
+    void startDeviceScreenRecording(String deviceId) throws MobitruOperationException;
+
+    /**
+     * Stop the screen recording on the device with specified UDID.
+     *
+     * @param deviceId The UDID of the device
+     * @return The ID of the recording artifact.
+     * @throws MobitruOperationException In case of any issues during start the recording.
+     */
+    String stopDeviceScreenRecording(String deviceId) throws MobitruOperationException;
+
+    /**
+     * Stop the screen recording on the device with specified UDID.
+     *
+     * @param recordingId The ID of the recording artifact
+     * @return Binary content of the recording artifact.
+     * @throws MobitruOperationException In case of any issues during start the recording.
+     */
+    byte[] downloadDeviceScreenRecording(String recordingId) throws MobitruOperationException;
+
     /**
      * Installs the desired application on the device with specified UDID
      *

vividus-plugin-mobitru/src/main/java/org/vividus/mobitru/client/MobitruFacadeImpl.java

@@ -21,7 +21,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
@@ -35,12 +34,14 @@
 import org.openqa.selenium.remote.DesiredCapabilities;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.slf4j.spi.LoggingEventBuilder;
 import org.vividus.mobitru.client.exception.MobitruDeviceSearchException;
 import org.vividus.mobitru.client.exception.MobitruDeviceTakeException;
 import org.vividus.mobitru.client.exception.MobitruOperationException;
 import org.vividus.mobitru.client.model.Application;
 import org.vividus.mobitru.client.model.Device;
 import org.vividus.mobitru.client.model.DeviceSearchParameters;
+import org.vividus.mobitru.client.model.ScreenRecording;
 import org.vividus.util.wait.DurationBasedWaiter;
 import org.vividus.util.wait.RetryTimesBasedWaiter;
 import org.vividus.util.wait.WaitMode;
@@ -57,6 +58,8 @@
         .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
 
     private static final int RETRY_TIMES = 20;
+    private static final Duration DOWNLOAD_RECORDING_POOLING_TIMEOUT = Duration.ofSeconds(5);
+    private static final int DOWNLOAD_RECORDING_RETRY_COUNT = 10;
 
     private final MobitruClient mobitruClient;
     private Duration waitForDeviceTimeout;
@@ -109,6 +112,33 @@
         mobitruClient.returnDevice(deviceId);
     }
 
+    @Override
+    public void startDeviceScreenRecording(String deviceId) throws MobitruOperationException
+    {
+        mobitruClient.startDeviceScreenRecording(deviceId);
+    }
+
+    @Override
+    public String stopDeviceScreenRecording(String deviceId) throws MobitruOperationException
+    {
+        byte[] receivedRecordingInfo = mobitruClient.stopDeviceScreenRecording(deviceId);
+        ScreenRecording screenRecordingInfo = performMapperOperation(mapper ->
+                mapper.readValue(receivedRecordingInfo, ScreenRecording.class));
+        return screenRecordingInfo.getRecordingId();
+    }
+
+    @Override
+    public byte[] downloadDeviceScreenRecording(String recordingId) throws MobitruOperationException
+    {
+        Waiter waiter = new RetryTimesBasedWaiter(DOWNLOAD_RECORDING_POOLING_TIMEOUT,
+                DOWNLOAD_RECORDING_RETRY_COUNT);
+        Optional<byte[]> receivedRecording = performWaiterOperation(waiter,
+                () -> mobitruClient.downloadDeviceScreenRecording(recordingId),
+                LOGGER.atDebug(), "download device screen recording");
+        return receivedRecording.orElseThrow(() -> new MobitruOperationException(
+                String.format("Unable to download recording with id %s", recordingId)));
+    }
+
     private String takeDevice(Device device, Waiter deviceWaiter) throws MobitruOperationException
     {
         LOGGER.info("Trying to take device with configuration {}", device);
@@ -120,22 +150,13 @@
     private String takeDevice(FailableSupplier<byte[], MobitruOperationException> takeDeviceActions,
             Supplier<String> unableToTakeDeviceErrorMessage, Waiter deviceWaiter) throws MobitruOperationException
     {
-        byte[] receivedDevice = deviceWaiter.wait(() -> {
-            try
-            {
-                return takeDeviceActions.get();
-            }
-            catch (MobitruDeviceTakeException e)
-            {
-                LOGGER.warn("Unable to take device, retrying attempt.", e);
-                return null;
-            }
-        }, Objects::nonNull);
-        if (null == receivedDevice)
+        Optional<byte[]> receivedDevice = performWaiterOperation(deviceWaiter, takeDeviceActions,
+                LOGGER.atWarn(), "take device");
+        if (receivedDevice.isEmpty())
         {
             throw new MobitruDeviceTakeException(unableToTakeDeviceErrorMessage.get());
         }
-        Device takenDevice = performMapperOperation(mapper -> mapper.readValue(receivedDevice, Device.class));
+        Device takenDevice = performMapperOperation(mapper -> mapper.readValue(receivedDevice.get(), Device.class));
         LOGGER.info("Device with configuration {} is taken", takenDevice);
         return (String) takenDevice.getDesiredCapabilities().get(UDID);
     }
@@ -213,6 +234,25 @@
         }
     }
 
+    private Optional<byte[]> performWaiterOperation(Waiter waiter,
+                                                    FailableSupplier<byte[], MobitruOperationException> operation,
+                                                    LoggingEventBuilder operationLoggerBuilder, String operationTitle)
+    {
+        return waiter.wait(() -> {
+            try
+            {
+                return Optional.of(operation.get());
+            }
+            catch (MobitruOperationException e)
+            {
+                operationLoggerBuilder
+                        .setCause(e)
+                        .log("Unable to {}, retrying attempt", operationTitle);
+                return Optional.empty();
+            }
+        }, Optional::isPresent);
+    }
+
     private boolean isSearchForDevice(DesiredCapabilities desiredCapabilities)
     {
         Map<String, Object> capabilities = desiredCapabilities.asMap();

vividus-plugin-mobitru/src/main/java/org/vividus/mobitru/client/model/ScreenRecording.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2019-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.vividus.mobitru.client.model;
+
+public class ScreenRecording
+{
+    private String recordingId;
+
+    public String getRecordingId()
+    {
+        return recordingId;
+    }
+
+    public void setRecordingId(String recordingId)
+    {
+        this.recordingId = recordingId;
+    }
+
+    @Override
+    public String toString()
+    {
+        return "ScreenRecording{id='" + recordingId + '}';
+    }
+}

vividus-plugin-mobitru/src/main/java/org/vividus/mobitru/recording/MobitruRecordingListener.java

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2019-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.vividus.mobitru.recording;
+
+import com.google.common.eventbus.Subscribe;
+
+import org.jbehave.core.annotations.AfterScenario;
+import org.jbehave.core.annotations.BeforeScenario;
+import org.jbehave.core.annotations.ScenarioType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.vividus.mobitru.client.MobitruFacade;
+import org.vividus.mobitru.client.exception.MobitruOperationException;
+import org.vividus.reporter.event.IAttachmentPublisher;
+import org.vividus.selenium.IWebDriverProvider;
+import org.vividus.selenium.event.BeforeWebDriverQuitEvent;
+import org.vividus.selenium.event.WebDriverCreateEvent;
+import org.vividus.testcontext.TestContext;
+
+public class MobitruRecordingListener
+{
+    private static final String KEY = "mobitruDeviceId";
+    private static final Logger LOGGER = LoggerFactory.getLogger(MobitruRecordingListener.class);
+
+    private final MobitruFacade mobitruFacade;
+    private final IAttachmentPublisher attachmentPublisher;
+    private final IWebDriverProvider webDriverProvider;
+    private boolean enableRecording;
+    private final TestContext testContext;
+
+    public MobitruRecordingListener(MobitruFacade mobitruFacade, IAttachmentPublisher attachmentPublisher,
+                                    TestContext testContext, IWebDriverProvider webDriverProvider)
+    {
+        this.mobitruFacade = mobitruFacade;
+        this.attachmentPublisher = attachmentPublisher;
+        this.testContext = testContext;
+        this.webDriverProvider = webDriverProvider;
+    }
+
+    @BeforeScenario(uponType = ScenarioType.ANY)
+    public void startRecordingBeforeScenario()
+    {
+        //perform start recording if a web driver session is already exist,
+        //which means onSessionStart will be not executed
+        if (webDriverProvider.isWebDriverInitialized())
+        {
+            startRecordingIfEnabled();
+        }
+    }
+
+    @Subscribe
+    public void onSessionStart(WebDriverCreateEvent event)
+    {
+        startRecordingIfEnabled();
+    }
+
+    @Subscribe
+    public void onSessionStop(BeforeWebDriverQuitEvent event)
+    {
+        publishRecordingIfEnabled();
+    }
+
+    @AfterScenario(uponType = ScenarioType.ANY)
+    public void publishRecordingAfterScenario()
+    {
+        //perform publish if a web driver session is still exist,
+        //which means onSessionStop method was not executed
+        if (webDriverProvider.isWebDriverInitialized())
+        {
+            publishRecordingIfEnabled();
+        }
+    }
+
+    private void startRecordingIfEnabled()
+    {
+        if (enableRecording)
+        {
+            String deviceId = getDeviceId();
+            try
+            {
+                mobitruFacade.startDeviceScreenRecording(deviceId);
+            }
+            catch (MobitruOperationException e)
+            {
+                LOGGER.atWarn()
+                        .addArgument(deviceId)
+                        .setCause(e)
+                        .log("Unable to start recording on device with UUID {}");
+            }
+        }
+    }
+
+    private void publishRecordingIfEnabled()
+    {
+        if (enableRecording)
+        {
+            String deviceId = getDeviceId();
+            try
+            {
+                String recordingId = mobitruFacade.stopDeviceScreenRecording(deviceId);
+                byte[] recording = mobitruFacade.downloadDeviceScreenRecording(recordingId);
+                String attachmentName = String.format("mobitru_session_recording_%s.mp4", recordingId);
+                attachmentPublisher.publishAttachment(recording, attachmentName);
+            }
+            catch (MobitruOperationException e)
+            {
+                LOGGER.atWarn()
+                        .addArgument(deviceId)
+                        .setCause(e)
+                        .log("Unable to stop or download recording on device with UUID {}");
+            }
+        }
+    }
+
+    public void setEnableRecording(boolean enableRecording)
+    {
+        this.enableRecording = enableRecording;
+    }
+
+    private String getDeviceId()
+    {
+        return testContext.get(KEY);
+    }
+}