Merge pull request #136 from solrudev/develop

0.15.1

Author: solrudev

README.md

@@ -35,7 +35,7 @@ Ackpine depends on Jetpack libraries, so it's also necessary to add the `google(
 
 ```toml
 [versions]
-ackpine = "0.15.0"
+ackpine = "0.15.1"
 
 [libraries]
 ackpine-core = { module = "ru.solrudev.ackpine:ackpine-core", version.ref = "ackpine" }
@@ -76,7 +76,7 @@ ackpine = [
 
 ```kotlin
 dependencies {
-    val ackpineVersion = "0.15.0"
+    val ackpineVersion = "0.15.1"
     implementation("ru.solrudev.ackpine:ackpine-core:$ackpineVersion")
 
     // optional - Kotlin extensions and Coroutines support

ackpine-api/api-main/src/main/kotlin/ru/solrudev/ackpine/SdkIntWrapper.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2025 Ilya Fomichev
+ *
+ * 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
+ *
+ *     http://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 ru.solrudev.ackpine
+
+internal object SdkIntWrapper {
+	@JvmSynthetic
+	fun get() = try {
+		SdkInt.get()
+	} catch (_: NoClassDefFoundError) {
+		throw NoClassDefFoundError(
+			"Class ru.solrudev.ackpine.SdkInt was not found. " +
+					"Make sure you have configured a dependency on ackpine-core module."
+		)
+	}
+}

ackpine-api/api-main/src/main/kotlin/ru/solrudev/ackpine/exceptions/Exceptions.kt

@@ -16,11 +16,11 @@
 
 package ru.solrudev.ackpine.exceptions
 
-import android.os.Build
+import ru.solrudev.ackpine.SdkIntWrapper
 
 /**
  * Thrown if installation of split packages is not supported when creating session with split package is attempted.
  */
 public class SplitPackagesNotSupportedException : IllegalArgumentException(
-	"Split packages are not supported on current Android API level: ${Build.VERSION.SDK_INT}"
+	"Split packages are not supported on current Android API level: ${SdkIntWrapper.get()}"
 )

ackpine-api/api-stubs/src/main/kotlin/ru/solrudev/ackpine/SdkInt.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2025 Ilya Fomichev
+ *
+ * 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
+ *
+ *     http://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 ru.solrudev.ackpine
+
+/**
+ * A replaceable stub for getting current SDK version.
+ */
+public object SdkInt {
+	public fun get(): Int {
+		throw NotImplementedError()
+	}
+}

ackpine-core/src/main/kotlin/ru/solrudev/ackpine/SdkInt.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2025 Ilya Fomichev
+ *
+ * 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
+ *
+ *     http://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 ru.solrudev.ackpine
+
+import android.os.Build
+
+@Suppress("Unused")
+internal object SdkInt {
+	@JvmSynthetic
+	@JvmName("get")
+	internal fun get() = Build.VERSION.SDK_INT
+}

ackpine-core/src/main/kotlin/ru/solrudev/ackpine/impl/activity/SessionCommitActivity.kt

@@ -141,7 +141,7 @@ internal abstract class SessionCommitActivity<F : Failure> protected constructor
 	}
 
 	protected fun withCompletableSession(block: (CompletableSession<F>?) -> Unit) {
-		ackpineSessionFuture.handleResult(block)
+		ackpineSessionFuture.handleResult(block = block)
 	}
 
 	private fun notifySessionCommitted() {

ackpine-core/src/main/kotlin/ru/solrudev/ackpine/impl/installer/session/IntentBasedInstallSession.kt

@@ -147,7 +147,7 @@ internal class IntentBasedInstallSession internal constructor(
 		apkFile.parentFile?.mkdirs()
 		apkFile.createNewFile()
 		val afd = context.openAssetFileDescriptor(apk, cancellationSignal)
-			?: error("AssetFileDescriptor was null: $apk")
+			?: throw NullPointerException("AssetFileDescriptor was null: $apk")
 		afd.createInputStream().buffered().use { apkStream ->
 			val outputStream = apkFile.outputStream()
 			outputStream.buffered().use { bufferedOutputStream ->

ackpine-core/src/main/kotlin/ru/solrudev/ackpine/impl/installer/session/SessionBasedInstallSession.kt

@@ -33,15 +33,19 @@ import android.graphics.BitmapFactory
 import android.icu.util.ULocale
 import android.net.Uri
 import android.os.Build
+import android.os.CancellationSignal
 import android.os.Handler
 import android.os.OperationCanceledException
 import android.util.Log
 import androidx.annotation.ChecksSdkIntAtLeast
 import androidx.annotation.RequiresApi
 import androidx.annotation.RestrictTo
 import androidx.concurrent.futures.CallbackToFutureAdapter
+import ru.solrudev.ackpine.helpers.closeAllWithException
 import ru.solrudev.ackpine.helpers.closeWithException
 import ru.solrudev.ackpine.helpers.concurrent.handleResult
+import ru.solrudev.ackpine.helpers.getOrElse
+import ru.solrudev.ackpine.helpers.mapCatchingFirst
 import ru.solrudev.ackpine.helpers.use
 import ru.solrudev.ackpine.impl.database.dao.InstallConstraintsDao
 import ru.solrudev.ackpine.impl.database.dao.InstallPreapprovalDao
@@ -75,6 +79,7 @@ import ru.solrudev.ackpine.session.Session.State.Failed
 import ru.solrudev.ackpine.session.parameters.Confirmation
 import ru.solrudev.ackpine.session.parameters.NotificationData
 import java.util.UUID
+import java.util.concurrent.CancellationException
 import java.util.concurrent.Executor
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.random.Random
@@ -235,9 +240,9 @@ internal class SessionBasedInstallSession internal constructor(
 	}
 
 	override fun doCleanup() {
-		executor.execute(::abandonSession) // may be long if storage is under load
-		clearPackageInstallerSessionCallback()
 		isPreapprovalActive = false
+		clearPackageInstallerSessionCallback()
+		executor.execute(::abandonSession) // may be long if storage is under load
 	}
 
 	@ChecksSdkIntAtLeast(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
@@ -403,7 +408,7 @@ internal class SessionBasedInstallSession internal constructor(
 
 	private fun writeApksToSession(sessionId: Int) {
 		val session = packageInstaller.openSession(sessionId)
-		session.writeApks().handleResult(
+		session.writeApksAsync().handleResult(
 			block = {
 				try {
 					session.close()
@@ -414,47 +419,75 @@ internal class SessionBasedInstallSession internal constructor(
 			},
 			onException = { exception ->
 				session.closeWithException(exception)
-				if (exception is OperationCanceledException) {
+				if (exception is CancellationException) {
 					cancel()
 				} else {
 					completeExceptionally(exception)
 				}
 			})
 	}
 
-	private fun PackageInstallerService.Session.writeApks() = CallbackToFutureAdapter.getFuture { completer ->
+	private fun PackageInstallerService.Session.writeApksAsync() = CallbackToFutureAdapter.getFuture { completer ->
+		writeApks(completer)
+	}
+
+	private fun PackageInstallerService.Session.writeApks(
+		completer: CallbackToFutureAdapter.Completer<Unit>
+	): String {
+		val tag = "SessionBasedInstallSession.writeApks"
+		val assetFileDescriptors = apks
+			.mapCatchingFirst { uri ->
+				context.openAssetFileDescriptor(uri, cancellationSignal)
+					?: throw NullPointerException("AssetFileDescriptor was null: $uri")
+			}
+			.getOrElse { failure ->
+				closeAllWithException(failure.partialResult, failure.exception)
+				if (failure.exception is OperationCanceledException) {
+					completer.setCancelled()
+				} else {
+					completer.setException(failure.exception)
+				}
+				return tag
+			}
 		val countdown = AtomicInteger(apks.size)
 		val currentProgress = AtomicInteger(0)
 		val progressMax = apks.size * PROGRESS_MAX
-		apks.forEachIndexed { index, uri ->
-			val afd = context.openAssetFileDescriptor(uri, cancellationSignal)
-				?: error("AssetFileDescriptor was null: $uri")
+		val sharedCancelSignal = CancellationSignal()
+		cancellationSignal.setOnCancelListener {
+			sharedCancelSignal.cancel()
+			completer.setCancelled()
+		}
+		assetFileDescriptors.forEachIndexed { index, afd ->
 			try {
 				executor.execute {
 					try {
 						afd.use {
-							writeApk(afd, index, currentProgress, progressMax)
+							writeApk(afd, index, currentProgress, progressMax, sharedCancelSignal)
 							if (countdown.decrementAndGet() == 0) {
 								completer.set(Unit)
 							}
 						}
+					} catch (_: OperationCanceledException) { // no-op
 					} catch (throwable: Throwable) {
+						sharedCancelSignal.cancel()
 						completer.setException(throwable)
 					}
 				}
 			} catch (exception: Exception) {
 				afd.closeWithException(exception)
+				sharedCancelSignal.cancel()
 				completer.setException(exception)
 			}
 		}
-		"SessionBasedInstallSession.writeApks"
+		return tag
 	}
 
 	private fun PackageInstallerService.Session.writeApk(
 		afd: AssetFileDescriptor,
 		index: Int,
 		currentProgress: AtomicInteger,
-		progressMax: Int
+		progressMax: Int,
+		cancellationSignal: CancellationSignal
 	) = afd.createInputStream().use { apkStream ->
 		requireNotNull(apkStream) { "APK $index InputStream was null." }
 		val length = afd.declaredLength

ackpine-core/src/main/kotlin/ru/solrudev/ackpine/impl/session/AbstractSession.kt

@@ -258,6 +258,7 @@ internal abstract class AbstractSession<F : Failure> protected constructor(
 	}
 
 	private fun cleanup() {
+		cancellationSignal.setOnCancelListener(null)
 		doCleanup()
 		context.getSystemService<NotificationManager>()?.cancel(id.toString(), notificationId)
 	}

ackpine-runtime/src/main/kotlin/ru/solrudev/ackpine/helpers/CloseableHelpers.kt

@@ -44,4 +44,37 @@ public fun AutoCloseable.closeWithException(cause: Throwable) {
 	} catch (closeException: Throwable) {
 		cause.addSuppressed(closeException)
 	}
-}
+}
+
+/**
+ * Guarantees closing all [resources] and delivery of every failure through thrown exception.
+ */
+@RequiresApi(Build.VERSION_CODES.KITKAT)
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+@JvmSynthetic
+public fun closeAll(resources: Iterable<AutoCloseable>) {
+	resources
+		.mapCatching { it.close() }
+		.getOrThrow()
+}
+
+/**
+ * Guarantees closing all [resources] and delivery of every failure through the [cause] via its suppressed exceptions.
+ */
+@RequiresApi(Build.VERSION_CODES.KITKAT)
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+@JvmSynthetic
+public fun closeAllWithException(resources: Iterable<AutoCloseable>, cause: Throwable) {
+	resources
+		.mapCatching { it.close() }
+		.failureOrNull()
+		?.let { failure -> cause.addSuppressed(failure.exception) }
+}
+
+/**
+ * Guarantees closing all [resources] and delivery of every failure through thrown exception.
+ */
+@RequiresApi(Build.VERSION_CODES.KITKAT)
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+@JvmSynthetic
+public fun closeAll(vararg resources: AutoCloseable): Unit = closeAll(resources.asIterable())