diff --git a/app/src/main/java/com/droiddeck/launcher/core/Downloader.java b/app/src/main/java/com/droiddeck/launcher/core/Downloader.java index 19cec5acbe..9bd86c5719 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/Downloader.java +++ b/app/src/main/java/com/droiddeck/launcher/core/Downloader.java @@ -58,7 +58,7 @@ public final class Downloader { private static void closeAsync(InputStream active) { CANCEL_EXECUTOR.execute(() -> { - try { active.close(); } catch (IOException ignored) { } + try { active.close(); } catch (IOException | IllegalStateException ignored) { } }); } diff --git a/app/src/main/java/com/droiddeck/launcher/files/StorageRoots.kt b/app/src/main/java/com/droiddeck/launcher/files/StorageRoots.kt index b19a2e9874..825c2e24c6 100644 --- a/app/src/main/java/com/droiddeck/launcher/files/StorageRoots.kt +++ b/app/src/main/java/com/droiddeck/launcher/files/StorageRoots.kt @@ -90,7 +90,8 @@ object StorageRoots { .filter { present(it.state) } .forEachIndexed { index, volume -> val uuid = volume.uuid?.takeIf { it.isNotBlank() } - val dirName = volume.directory?.name?.takeIf { it.isNotBlank() } + val directory = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) volume.directory else null + val dirName = directory?.name?.takeIf { it.isNotBlank() } val descSlug = volume.getDescription(context)?.trim() ?.takeIf { it.isNotBlank() && !it.equals("android", ignoreCase = true) } ?.replace(Regex("[^A-Za-z0-9._-]+"), "-") @@ -98,9 +99,7 @@ object StorageRoots { entry.removable = !volume.isPrimary && volume.isRemovable if (entry.label == null) entry.label = labelFor(context, volume, uuid ?: dirName ?: descSlug) - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { - volume.directory?.let { entry.candidates += it } - } + directory?.let { entry.candidates += it } val name = uuid ?: dirName if (name != null) { entry.candidates += File("/storage/$name") diff --git a/app/src/test/java/com/droiddeck/launcher/core/DownloaderCancelTest.kt b/app/src/test/java/com/droiddeck/launcher/core/DownloaderCancelTest.kt new file mode 100644 index 0000000000..8d49cdeb00 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/core/DownloaderCancelTest.kt @@ -0,0 +1,77 @@ +package com.droiddeck.launcher.core + +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import java.io.InputStream +import java.util.concurrent.CopyOnWriteArrayList +import java.util.concurrent.CountDownLatch +import java.util.concurrent.ExecutorService +import java.util.concurrent.ThreadPoolExecutor +import java.util.concurrent.TimeUnit + +class DownloaderCancelTest { + private val previousHandler = Thread.getDefaultUncaughtExceptionHandler() + private val uncaught = CopyOnWriteArrayList() + + @After fun tearDown() { + Thread.setDefaultUncaughtExceptionHandler(previousHandler) + } + + private val cancelExecutor: ExecutorService + get() = Downloader::class.java.getDeclaredField("CANCEL_EXECUTOR") + .apply { isAccessible = true } + .get(null) as ExecutorService + + private fun cancelWhileClosingThrows(failure: RuntimeException): Thread { + Thread.setDefaultUncaughtExceptionHandler { _, error -> uncaught += error } + val closed = CountDownLatch(1) + var closer: Thread? = null + val stream = object : InputStream() { + override fun read(): Int = -1 + override fun close() { + closer = Thread.currentThread() + closed.countDown() + throw failure + } + } + val cancellation = Downloader.Cancellation() + Downloader.Cancellation::class.java.getDeclaredMethod("attach", InputStream::class.java) + .apply { isAccessible = true } + .invoke(cancellation, stream) + + cancellation.cancel() + + assertTrue(closed.await(5, TimeUnit.SECONDS)) + return closer!! + } + + private fun survivesItsTask(closer: Thread): Boolean { + val pool = cancelExecutor as ThreadPoolExecutor + val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5) + while (System.nanoTime() < deadline) { + if (!closer.isAlive) return false + if (pool.activeCount == 0 && closer.state == Thread.State.TIMED_WAITING) return true + Thread.sleep(5) + } + error("the cancel thread neither ended nor went back to waiting for work") + } + + @Test fun unbalancedTimeoutOnCancelDoesNotCrash() { + val closer = cancelWhileClosingThrows(IllegalStateException("Unbalanced enter/exit")) + + assertTrue(survivesItsTask(closer)) + assertEquals(emptyList(), uncaught.toList()) + } + + @Test fun otherCloseFailuresStillSurface() { + val failure = UnsupportedOperationException("close") + val closer = cancelWhileClosingThrows(failure) + + closer.join(TimeUnit.SECONDS.toMillis(5)) + assertFalse(closer.isAlive) + assertEquals(listOf(failure), uncaught.toList()) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/files/StorageRootsVolumeTest.kt b/app/src/test/java/com/droiddeck/launcher/files/StorageRootsVolumeTest.kt new file mode 100644 index 0000000000..b7d9cf520c --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/files/StorageRootsVolumeTest.kt @@ -0,0 +1,55 @@ +package com.droiddeck.launcher.files + +import android.os.Environment +import android.os.Process +import android.os.storage.StorageManager +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.shadows.StorageVolumeBuilder +import java.io.File + +@RunWith(RobolectricTestRunner::class) +@Config(manifest = Config.NONE) +class StorageRootsVolumeTest { + @get:Rule val temporary = TemporaryFolder() + + private fun addUsbVolume(): File { + val mount = temporary.newFolder("usbstick") + val context = RuntimeEnvironment.getApplication() + val volume = StorageVolumeBuilder("public:8,1", mount, "USB drive", Process.myUserHandle(), Environment.MEDIA_MOUNTED) + .setIsPrimary(false) + .setIsEmulated(false) + .setIsRemovable(true) + .build() + shadowOf(context.getSystemService(StorageManager::class.java)).addStorageVolume(volume) + return mount + } + + @Config(sdk = [29]) + @Test fun volumesWithoutDirectoryApiAreListedOnAndroid10() { + addUsbVolume() + + val usb = StorageRoots.list(RuntimeEnvironment.getApplication()).single { it.label == "USB drive" } + + assertTrue(usb.removable) + } + + @Config(sdk = [30]) + @Test fun volumeDirectoryIsStillUsedOnAndroid11() { + val mount = addUsbVolume() + + val usb = StorageRoots.list(RuntimeEnvironment.getApplication()).single { it.label == "USB drive" } + + assertTrue(usb.removable) + assertTrue(usb.readable) + assertEquals(mount.absoluteFile, usb.dir.absoluteFile) + } +}