#796 Improved the screen recorder for creating more than 3 minutes long videos

core/src/main/kotlin/com/malinskiy/marathon/extension/StringExtensions.kt

@@ -24,3 +24,5 @@ fun String.escape(): String {
 }
 
 val escapeRegex = "[^a-zA-Z0-9\\.\\#]".toRegex()
+
+fun String.addFileNumberForVideo(fileNumber: String) = "${this.split(".mp4")[0]}$fileNumber.mp4"

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/RemoteFileManager.kt

@@ -44,7 +44,7 @@ class RemoteFileManager(private val device: AndroidDevice) {
     }
 
     companion object {
-        const val MAX_FILENAME = 255
+        const val MAX_FILENAME = 254 //we need 1 more char for fileNumber in case of using video attachment > 180 && apiLevel < 34
         const val TMP_PATH = "/data/local/tmp"
     }
 }

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/adam/AdamAndroidDevice.kt

@@ -54,6 +54,7 @@ import com.malinskiy.marathon.device.NetworkState
 import com.malinskiy.marathon.device.file.measureFileTransfer
 import com.malinskiy.marathon.exceptions.DeviceLostException
 import com.malinskiy.marathon.execution.TestBatchResults
+import com.malinskiy.marathon.extension.addFileNumberForVideo
 import com.malinskiy.marathon.extension.escape
 import com.malinskiy.marathon.extension.withTimeout
 import com.malinskiy.marathon.extension.withTimeoutOrNull
@@ -74,6 +75,7 @@ import java.awt.image.BufferedImage
 import java.io.File
 import java.time.Duration
 import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.TimeUnit
 import kotlin.coroutines.CoroutineContext
 import com.malinskiy.marathon.android.model.ShellCommandResult as MarathonShellCommandResult
 
@@ -372,7 +374,27 @@ class AdamAndroidDevice(
         remoteFilePath: String,
         options: VideoConfiguration
     ) {
-        val screenRecorderCommand = options.toScreenRecorderCommand(remoteFilePath)
+        var secondsRemaining = TimeUnit.SECONDS.convert(options.timeLimit, options.timeLimitUnits)
+        if(secondsRemaining <= 180 || apiLevel >= 34) {
+            startScreenRecorder(remoteFilePath, options)
+        } else {
+            var recordsCount = 0
+            while(recordsCount == 0 || secondsRemaining>=180) {
+                startScreenRecorder(remoteFilePath, options, recordsCount.toString()) {
+                    secondsRemaining -= 180
+                    recordsCount++
+                }
+            }
+        }
+    }
+
+    private suspend fun startScreenRecorder(
+        remoteFilePath: String,
+        options: VideoConfiguration,
+        fileNumber: String = "",
+        finallyBlock: (() -> Unit)? = null
+    ) {
+        val screenRecorderCommand = options.toScreenRecorderCommand(remoteFilePath.addFileNumberForVideo(fileNumber), this)
         try {
             withTimeoutOrNull(androidConfiguration.timeoutConfiguration.screenrecorder) {
                 val result = client.execute(ShellCommandRequest(screenRecorderCommand), serial = adbSerial)
@@ -388,6 +410,8 @@ class AdamAndroidDevice(
             logger.warn(e) { "screenrecord start was interrupted" }
         } catch (e: Exception) {
             logger.error("Unable to start screenrecord", e)
+        } finally {
+            finallyBlock?.invoke()
         }
     }
 

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/executor/listeners/video/ScreenRecorderTestBatchListener.kt

@@ -10,6 +10,7 @@ import com.malinskiy.marathon.device.DevicePoolId
 import com.malinskiy.marathon.device.toDeviceInfo
 import com.malinskiy.marathon.execution.Attachment
 import com.malinskiy.marathon.execution.AttachmentType
+import com.malinskiy.marathon.extension.addFileNumberForVideo
 import com.malinskiy.marathon.extension.withTimeoutOrNull
 import com.malinskiy.marathon.io.FileManager
 import com.malinskiy.marathon.io.FileType
@@ -22,6 +23,7 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.async
 import kotlinx.coroutines.cancelAndJoin
+import java.io.File
 import java.time.Duration
 import kotlin.system.measureTimeMillis
 
@@ -122,29 +124,56 @@ class ScreenRecorderTestBatchListener(
     }
 
     private suspend fun pullTestVideo(test: Test) {
-        val localVideoFile = fileManager.createFile(FileType.VIDEO, pool, device.toDeviceInfo(), test, testBatchId)
+        val localVideoFiles = mutableListOf<File>()
         val remoteFilePath = device.fileManager.remoteVideoForTest(test, testBatchId)
         val millis = measureTimeMillis {
-            device.safePullFile(remoteFilePath, localVideoFile.toString())
+            if(device.apiLevel >= 34 || videoConfiguration.timeLimit <= 180) {
+                val localVideoFile = fileManager.createFile(FileType.VIDEO, pool, device.toDeviceInfo(), test, testBatchId)
+                device.safePullFile(remoteFilePath, localVideoFile.toString())
+                localVideoFiles.add(localVideoFile)
+            } else {
+                for (i in 0 .. (videoConfiguration.timeLimit / 180)) {
+                    val localVideoFile = fileManager.createFile(FileType.VIDEO, pool, device.toDeviceInfo(), test, testBatchId, i.toString())
+                    device.safePullFile(remoteFilePath.addFileNumberForVideo(i.toString()), localVideoFile.toString())
+                    localVideoFiles.add(localVideoFile)
+                }
+            }
         }
         logger.trace { "Pulling finished in ${millis}ms $remoteFilePath " }
-        attachmentListeners.forEach { it.onAttachment(test, Attachment(localVideoFile, AttachmentType.VIDEO)) }
+        attachmentListeners.forEach {
+            localVideoFiles.forEach { localVideoFile ->
+                it.onAttachment(test, Attachment(localVideoFile, AttachmentType.VIDEO))
+            }
+        }
     }
 
     /**
      * This can be called both when test times out and device unavailable
      */
     private suspend fun pullLastBatchVideo(remoteFilePath: String) {
-        val localVideoFile = fileManager.createFile(FileType.VIDEO, pool, device.toDeviceInfo(), testBatchId = testBatchId)
         val millis = measureTimeMillis {
-            device.safePullFile(remoteFilePath, localVideoFile.toString())
+            if(device.apiLevel >= 34 || videoConfiguration.timeLimit <= 180) {
+                val localVideoFile = fileManager.createFile(FileType.VIDEO, pool, device.toDeviceInfo(), testBatchId = testBatchId)
+                device.safePullFile(remoteFilePath, localVideoFile.toString())
+            } else {
+                for (i in 0 .. (videoConfiguration.timeLimit / 180)) {
+                    val localVideoFile = fileManager.createFile(FileType.VIDEO, pool, device.toDeviceInfo(), testBatchId = testBatchId, id = i.toString())
+                    device.safePullFile(remoteFilePath.addFileNumberForVideo(i.toString()), localVideoFile.toString())
+                }
+            }
         }
         logger.trace { "Pulling finished in ${millis}ms $remoteFilePath " }
     }
 
     private suspend fun removeRemoteVideo(remoteFilePath: String) {
         val millis = measureTimeMillis {
-            device.fileManager.removeRemotePath(remoteFilePath)
+            if(device.apiLevel >= 34 || videoConfiguration.timeLimit <= 180) {
+                device.fileManager.removeRemotePath(remoteFilePath)
+            } else {
+                for (i in 0 .. (videoConfiguration.timeLimit / 180)) {
+                    device.fileManager.removeRemotePath(remoteFilePath.addFileNumberForVideo(i.toString()))
+                }
+            }
         }
         logger.trace { "Removed file in ${millis}ms $remoteFilePath" }
     }

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/extension/ConfigurationExtensions.kt

@@ -1,12 +1,13 @@
 package com.malinskiy.marathon.android.extension
 
+import com.malinskiy.marathon.android.AndroidDevice
 import com.malinskiy.marathon.android.model.AndroidTestBundle
 import com.malinskiy.marathon.config.vendor.VendorConfiguration
 import com.malinskiy.marathon.config.vendor.android.AndroidTestBundleConfiguration
 import com.malinskiy.marathon.config.vendor.android.VideoConfiguration
 import java.util.concurrent.TimeUnit
 
-fun VideoConfiguration.toScreenRecorderCommand(remoteFilePath: String): String {
+fun VideoConfiguration.toScreenRecorderCommand(remoteFilePath: String, device: AndroidDevice? = null): String {
     val sb = StringBuilder()
 
     sb.append("screenrecord")
@@ -36,7 +37,7 @@ fun VideoConfiguration.toScreenRecorderCommand(remoteFilePath: String): String {
     if (timeLimit > 0) {
         sb.append("--time-limit ")
         var seconds = TimeUnit.SECONDS.convert(timeLimit, timeLimitUnits)
-        if (seconds > 180) {
+        if (seconds > 180 && ((device?.apiLevel ?: 0) < 34)) {
             seconds = 180
         }
         sb.append(seconds)

vendor/vendor-android/src/test/kotlin/com/malinskiy/marathon/android/RemoteFileManagerTest.kt

@@ -176,7 +176,7 @@ class RemoteFileManagerTest {
                     emptyList()
                 ), "batch-id"
             )
-            assertThat(actual).isEqualTo("/sdcard/pkg.clazz-testWithAVeryLongNameThatExceeds255CharactersqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmQWERT-batch-id.mp4")
+            assertThat(actual).isEqualTo("/sdcard/pkg.clazz-testWithAVeryLongNameThatExceeds255CharactersqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmQWER-batch-id.mp4")
         }
     }
 }

vendor/vendor-android/src/test/kotlin/com/malinskiy/marathon/android/VideoConfigurationTest.kt

@@ -2,11 +2,34 @@ package com.malinskiy.marathon.android
 
 import assertk.assertThat
 import assertk.assertions.isEqualTo
+import com.malinskiy.adam.AndroidDebugBridgeClient
+import com.malinskiy.adam.server.junit5.AdbClient
+import com.malinskiy.adam.server.junit5.AdbServer
+import com.malinskiy.adam.server.junit5.AdbTest
+import com.malinskiy.adam.server.stub.AndroidDebugBridgeServer
+import com.malinskiy.marathon.android.adam.TestConfigurationFactory
+import com.malinskiy.marathon.android.adam.TestDeviceFactory
+import com.malinskiy.marathon.android.adam.boot
+import com.malinskiy.marathon.android.adam.features
 import com.malinskiy.marathon.android.extension.toScreenRecorderCommand
+import com.malinskiy.marathon.config.vendor.android.FileSyncConfiguration
+import com.malinskiy.marathon.config.vendor.android.FileSyncEntry
 import com.malinskiy.marathon.config.vendor.android.VideoConfiguration
+import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+import org.mockito.kotlin.mock
 
+@AdbTest
 class VideoConfigurationTest {
+    @AdbClient
+    lateinit var client: AndroidDebugBridgeClient
+
+    @AdbServer
+    lateinit var server: AndroidDebugBridgeServer
+
     @Test
     fun testDefaults() {
         assertThat(VideoConfiguration().toScreenRecorderCommand("/sdcard/video.mp4"))
@@ -18,4 +41,39 @@ class VideoConfigurationTest {
         assertThat(VideoConfiguration(timeLimit = 200).toScreenRecorderCommand("/sdcard/video.mp4"))
             .isEqualTo("screenrecord --size 720x1280 --bit-rate 1000000 --time-limit 180 /sdcard/video.mp4")
     }
+
+    @ParameterizedTest
+    @MethodSource("apiLevels")
+    fun testLongVideoDependsOnApiLevel(sdkLevel: Int, expectedTimeLimit: Int) {
+        val configuration = TestConfigurationFactory.create(
+            fileSyncConfiguration = FileSyncConfiguration(
+                mutableSetOf(
+                    FileSyncEntry(
+                        "screenshots"
+                    )
+                )
+            )
+        )
+        val device = TestDeviceFactory.create(client, configuration, mock())
+        runBlocking {
+            server.multipleSessions {
+                serial("emulator-5554") {
+                    boot(sdk = sdkLevel)
+                }
+                features("emulator-5554")
+            }
+
+            device.setup()
+        }
+        assertThat(VideoConfiguration(timeLimit = 200).toScreenRecorderCommand("/sdcard/video.mp4", device))
+            .isEqualTo("screenrecord --size 720x1280 --bit-rate 1000000 --time-limit $expectedTimeLimit /sdcard/video.mp4")
+    }
+
+    companion object {
+        @JvmStatic
+        fun apiLevels() = listOf(
+            Arguments.of(33, 180),
+            Arguments.of(34, 200)
+        )
+    }
 }