Add cancellation to binary uploading

app/src/main/java/com/kunzisoft/keepass/activities/EntryActivity.kt

@@ -221,7 +221,9 @@ class EntryActivity : LockingActivity() {
             registerProgressTask()
             onActionTaskListener = object : AttachmentFileNotificationService.ActionTaskListener {
                 override fun onAttachmentAction(fileUri: Uri, entryAttachmentState: EntryAttachmentState) {
-                    entryContentsView?.putAttachment(entryAttachmentState)
+                    if (entryAttachmentState.streamDirection != StreamDirection.UPLOAD) {
+                        entryContentsView?.putAttachment(entryAttachmentState)
+                    }
                 }
             }
         }

app/src/main/java/com/kunzisoft/keepass/activities/EntryEditActivity.kt

@@ -372,6 +372,9 @@ class EntryEditActivity : LockingActivity(),
                                 }
                             }
                         }
+                        AttachmentState.CANCELED -> {
+                            entryEditFragment?.removeAttachment(entryAttachmentState)
+                        }
                         AttachmentState.ERROR -> {
                             entryEditFragment?.removeAttachment(entryAttachmentState)
                             coordinatorLayout?.let {
@@ -525,6 +528,7 @@ class EntryEditActivity : LockingActivity(),
      * Saves the new entry or update an existing entry in the database
      */
     private fun saveEntry() {
+        mAttachmentFileBinderManager?.stopUploadAllAttachments()
         // Get the temp entry
         entryEditFragment?.getEntryInfo()?.let { newEntryInfo ->
 
@@ -542,6 +546,7 @@ class EntryEditActivity : LockingActivity(),
                         when (attachmentState.downloadState) {
                             AttachmentState.START,
                             AttachmentState.IN_PROGRESS,
+                            AttachmentState.CANCELED,
                             AttachmentState.ERROR -> {
                                 // Remove attachment not finished from info
                                 newEntryInfo.attachments = newEntryInfo.attachments.toMutableList().apply {
@@ -785,6 +790,7 @@ class EntryEditActivity : LockingActivity(),
                     .setMessage(R.string.discard_changes)
                     .setNegativeButton(android.R.string.cancel, null)
                     .setPositiveButton(R.string.discard) { _, _ ->
+                        mAttachmentFileBinderManager?.stopUploadAllAttachments()
                         backPressedAlreadyApproved = true
                         approved.invoke()
                     }.create().show()

app/src/main/java/com/kunzisoft/keepass/adapters/EntryAttachmentsItemsAdapter.kt

@@ -142,6 +142,7 @@ class EntryAttachmentsItemsAdapter(context: Context)
                     }
                     AttachmentState.NULL,
                     AttachmentState.ERROR,
+                    AttachmentState.CANCELED,
                     AttachmentState.COMPLETE -> {
                         holder.binaryFileProgressContainer.visibility = View.GONE
                         holder.binaryFileProgress.visibility = View.GONE
@@ -159,8 +160,13 @@ class EntryAttachmentsItemsAdapter(context: Context)
                 holder.binaryFileDeleteButton.visibility = View.GONE
                 holder.binaryFileProgress.apply {
                     visibility = when (entryAttachmentState.downloadState) {
-                        AttachmentState.NULL, AttachmentState.COMPLETE, AttachmentState.ERROR -> View.GONE
+                        AttachmentState.NULL,
-                        AttachmentState.START, AttachmentState.IN_PROGRESS -> View.VISIBLE
+                        AttachmentState.COMPLETE,
+                        AttachmentState.CANCELED,
+                        AttachmentState.ERROR -> View.GONE
+
+                        AttachmentState.START,
+                        AttachmentState.IN_PROGRESS -> View.VISIBLE
                     }
                     progress = entryAttachmentState.downloadProgression
                 }

app/src/main/java/com/kunzisoft/keepass/model/EntryAttachmentState.kt

@@ -76,5 +76,5 @@ data class EntryAttachmentState(var attachment: Attachment,
 }
 
 enum class AttachmentState {
-    NULL, START, IN_PROGRESS, COMPLETE, ERROR
+    NULL, START, IN_PROGRESS, COMPLETE, CANCELED, ERROR
 }

app/src/main/java/com/kunzisoft/keepass/services/AttachmentFileNotificationService.kt

@@ -35,10 +35,8 @@ import com.kunzisoft.keepass.model.AttachmentState
 import com.kunzisoft.keepass.model.EntryAttachmentState
 import com.kunzisoft.keepass.model.StreamDirection
 import com.kunzisoft.keepass.stream.readAllBytes
-import com.kunzisoft.keepass.timeout.TimeoutHelper
 import com.kunzisoft.keepass.utils.UriUtil
 import kotlinx.coroutines.*
-import java.io.BufferedInputStream
 import java.util.*
 import java.util.concurrent.CopyOnWriteArrayList
 
@@ -101,12 +99,15 @@ class AttachmentFileNotificationService: LockNotificationService() {
 
         when(intent?.action) {
             ACTION_ATTACHMENT_FILE_START_UPLOAD -> {
-                actionUploadOrDownload(downloadFileUri,
+                actionStartUploadOrDownload(downloadFileUri,
                         intent,
                         StreamDirection.UPLOAD)
             }
+            ACTION_ATTACHMENT_FILE_STOP_UPLOAD -> {
+                actionStopUpload()
+            }
             ACTION_ATTACHMENT_FILE_START_DOWNLOAD -> {
-                actionUploadOrDownload(downloadFileUri,
+                actionStartUploadOrDownload(downloadFileUri,
                         intent,
                         StreamDirection.DOWNLOAD)
             }
@@ -216,15 +217,22 @@ class AttachmentFileNotificationService: LockNotificationService() {
                     setDeleteIntent(pendingDeleteIntent)
                     setOngoing(false)
                 }
+                AttachmentState.CANCELED -> {
+                    setContentText(getString(R.string.download_canceled))
+                    setDeleteIntent(pendingDeleteIntent)
+                    setOngoing(false)
+                }
                 AttachmentState.ERROR -> {
                     setContentText(getString(R.string.error_file_not_create))
+                    setDeleteIntent(pendingDeleteIntent)
                     setOngoing(false)
                 }
             }
         }
         when (attachmentNotification.entryAttachmentState.downloadState) {
-            AttachmentState.ERROR,
+            AttachmentState.COMPLETE,
-            AttachmentState.COMPLETE -> {
+            AttachmentState.CANCELED,
+            AttachmentState.ERROR -> {
                 stopForeground(false)
                 notificationManager?.notify(attachmentNotification.notificationId, builder.build())
             } else -> {
@@ -235,6 +243,7 @@ class AttachmentFileNotificationService: LockNotificationService() {
 
     override fun onDestroy() {
         attachmentNotificationList.forEach { attachmentNotification ->
+            attachmentNotification.attachmentFileAction?.cancel()
             attachmentNotification.attachmentFileAction?.listener = null
             notificationManager?.cancel(attachmentNotification.notificationId)
         }
@@ -263,10 +272,10 @@ class AttachmentFileNotificationService: LockNotificationService() {
         }
     }
 
-    private fun actionUploadOrDownload(downloadFileUri: Uri?,
+    private fun actionStartUploadOrDownload(fileUri: Uri?,
-                                       intent: Intent,
+                                            intent: Intent,
-                                       streamDirection: StreamDirection) {
+                                            streamDirection: StreamDirection) {
-        if (downloadFileUri != null
+        if (fileUri != null
                 && intent.hasExtra(ATTACHMENT_KEY)) {
             try {
                 intent.getParcelableExtra<Attachment>(ATTACHMENT_KEY)?.let { entryAttachment ->
@@ -274,7 +283,7 @@ class AttachmentFileNotificationService: LockNotificationService() {
                     val nextNotificationId = (attachmentNotificationList.maxByOrNull { it.notificationId }
                             ?.notificationId ?: notificationId) + 1
                     val entryAttachmentState = EntryAttachmentState(entryAttachment, streamDirection)
-                    val attachmentNotification = AttachmentNotification(downloadFileUri, nextNotificationId, entryAttachmentState)
+                    val attachmentNotification = AttachmentNotification(fileUri, nextNotificationId, entryAttachmentState)
 
                     // Add action to the list on start
                     attachmentNotificationList.add(attachmentNotification)
@@ -287,11 +296,24 @@ class AttachmentFileNotificationService: LockNotificationService() {
                     }
                 }
             } catch (e: Exception) {
-                Log.e(TAG, "Unable to upload/download $downloadFileUri", e)
+                Log.e(TAG, "Unable to upload/download $fileUri", e)
             }
         }
     }
 
+    private fun actionStopUpload() {
+        try {
+            // Stop each upload
+            attachmentNotificationList.filter {
+                it.entryAttachmentState.streamDirection == StreamDirection.UPLOAD
+            }.forEach {
+                it.attachmentFileAction?.cancel()
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Unable to stop upload", e)
+        }
+    }
+
     private class AttachmentFileAction(
             private val attachmentNotification: AttachmentNotification,
             private val contentResolver: ContentResolver) {
@@ -308,8 +330,6 @@ class AttachmentFileNotificationService: LockNotificationService() {
 
             // on pre execute
             CoroutineScope(Dispatchers.Main).launch {
-                TimeoutHelper.temporarilyDisableTimeout()
-
                 attachmentNotification.attachmentFileAction = this@AttachmentFileAction
                 attachmentNotification.entryAttachmentState.apply {
                     downloadState = AttachmentState.START
@@ -320,53 +340,62 @@ class AttachmentFileNotificationService: LockNotificationService() {
 
             withContext(Dispatchers.IO) {
                 // on Progress with thread
-                val asyncResult: Deferred<Boolean> = async {
+                val asyncAction = launch {
-                    var progressResult = true
+                    attachmentNotification.entryAttachmentState.apply {
-                    try {
+                        try {
-                        attachmentNotification.entryAttachmentState.apply {
+                                downloadState = AttachmentState.IN_PROGRESS
-                            downloadState = AttachmentState.IN_PROGRESS
 
-                            when (streamDirection) {
+                                when (streamDirection) {
-                                StreamDirection.UPLOAD -> {
+                                    StreamDirection.UPLOAD -> {
-                                    uploadToDatabase(
+                                        uploadToDatabase(
-                                            attachmentNotification.uri,
+                                                attachmentNotification.uri,
-                                            attachment.binaryAttachment,
+                                                attachment.binaryAttachment,
-                                            contentResolver, 1024) { percent ->
+                                                contentResolver, 1024,
-                                        publishProgress(percent)
+                                                { // Cancellation
+                                                    downloadState == AttachmentState.CANCELED
+                                                }
+                                        ) { percent ->
+                                            publishProgress(percent)
+                                        }
+                                    }
+                                    StreamDirection.DOWNLOAD -> {
+                                        downloadFromDatabase(
+                                                attachmentNotification.uri,
+                                                attachment.binaryAttachment,
+                                                contentResolver, 1024) { percent ->
+                                            publishProgress(percent)
+                                        }
                                     }
                                 }
-                                StreamDirection.DOWNLOAD -> {
+                        } catch (e: Exception) {
-                                    downloadFromDatabase(
+                            e.printStackTrace()
-                                            attachmentNotification.uri,
+                            downloadState = AttachmentState.ERROR
-                                            attachment.binaryAttachment,
-                                            contentResolver, 1024) { percent ->
-                                        publishProgress(percent)
-                                    }
-                                }
-                            }
                         }
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                        progressResult = false
                     }
-                    progressResult
+                    attachmentNotification.entryAttachmentState.downloadState
                 }
 
                 // on post execute
                 withContext(Dispatchers.Main) {
-                    val result = asyncResult.await()
+                    asyncAction.join()
-                    attachmentNotification.attachmentFileAction = null
                     attachmentNotification.entryAttachmentState.apply {
-                        downloadState = if (result) AttachmentState.COMPLETE else AttachmentState.ERROR
+                        if (downloadState != AttachmentState.CANCELED
-                        downloadProgression = 100
+                                && downloadState != AttachmentState.ERROR) {
+                            downloadState = AttachmentState.COMPLETE
+                            downloadProgression = 100
+                        }
                     }
+                    attachmentNotification.attachmentFileAction = null
                     listener?.onUpdate(attachmentNotification)
-                    TimeoutHelper.releaseTemporarilyDisableTimeout()
                 }
 
             }
         }
 
+        fun cancel() {
+            attachmentNotification.entryAttachmentState.downloadState = AttachmentState.CANCELED
+        }
+
         fun downloadFromDatabase(attachmentToUploadUri: Uri,
                                  binaryAttachment: BinaryAttachment,
                                  contentResolver: ContentResolver,
@@ -396,13 +425,14 @@ class AttachmentFileNotificationService: LockNotificationService() {
                              binaryAttachment: BinaryAttachment,
                              contentResolver: ContentResolver,
                              bufferSize: Int = DEFAULT_BUFFER_SIZE,
+                             canceled: ()-> Boolean = { false },
                              update: ((percent: Int)->Unit)? = null) {
             var dataUploaded = 0L
             val fileSize = contentResolver.openFileDescriptor(attachmentFromDownloadUri, "r")?.statSize ?: 0
             UriUtil.getUriInputStream(contentResolver, attachmentFromDownloadUri)?.use { inputStream ->
                 Database.getInstance().loadedCipherKey?.let { binaryCipherKey ->
                     binaryAttachment.getGzipOutputDataStream(binaryCipherKey).use { outputStream ->
-                        inputStream.readAllBytes(bufferSize) { buffer ->
+                        inputStream.readAllBytes(bufferSize, canceled) { buffer ->
                             outputStream.write(buffer)
                             dataUploaded += buffer.size
                             try {
@@ -422,7 +452,9 @@ class AttachmentFileNotificationService: LockNotificationService() {
             val currentTime = System.currentTimeMillis()
             if (previousSaveTime + updateMinFrequency < currentTime) {
                 attachmentNotification.entryAttachmentState.apply {
-                    downloadState = AttachmentState.IN_PROGRESS
+                    if (downloadState != AttachmentState.CANCELED) {
+                        downloadState = AttachmentState.IN_PROGRESS
+                    }
                     downloadProgression = percent
                 }
                 CoroutineScope(Dispatchers.Main).launch {
@@ -444,6 +476,7 @@ class AttachmentFileNotificationService: LockNotificationService() {
         private const val CHANNEL_ATTACHMENT_ID = "com.kunzisoft.keepass.notification.channel.attachment"
 
         const val ACTION_ATTACHMENT_FILE_START_UPLOAD = "ACTION_ATTACHMENT_FILE_START_UPLOAD"
+        const val ACTION_ATTACHMENT_FILE_STOP_UPLOAD = "ACTION_ATTACHMENT_FILE_STOP_UPLOAD"
         const val ACTION_ATTACHMENT_FILE_START_DOWNLOAD = "ACTION_ATTACHMENT_FILE_START_DOWNLOAD"
         const val ACTION_ATTACHMENT_REMOVE = "ACTION_ATTACHMENT_REMOVE"
 

app/src/main/java/com/kunzisoft/keepass/stream/StreamBytesUtils.kt

@@ -31,10 +31,11 @@ import java.util.*
  */
 @Throws(IOException::class)
 fun InputStream.readAllBytes(bufferSize: Int = DEFAULT_BUFFER_SIZE,
+                             cancelCondition: ()-> Boolean = { false },
                              readBytes: (bytesRead: ByteArray) -> Unit) {
     val buffer = ByteArray(bufferSize)
     var read = 0
-    while (read != -1) {
+    while (read != -1 && !cancelCondition()) {
         read = this.read(buffer, 0, buffer.size)
         if (read != -1) {
             val optimizedBuffer: ByteArray = if (buffer.size == read) {

app/src/main/java/com/kunzisoft/keepass/tasks/AttachmentFileBinderManager.kt

@@ -34,6 +34,7 @@ import com.kunzisoft.keepass.model.EntryAttachmentState
 import com.kunzisoft.keepass.services.AttachmentFileNotificationService
 import com.kunzisoft.keepass.services.AttachmentFileNotificationService.Companion.ACTION_ATTACHMENT_FILE_START_DOWNLOAD
 import com.kunzisoft.keepass.services.AttachmentFileNotificationService.Companion.ACTION_ATTACHMENT_FILE_START_UPLOAD
+import com.kunzisoft.keepass.services.AttachmentFileNotificationService.Companion.ACTION_ATTACHMENT_FILE_STOP_UPLOAD
 import com.kunzisoft.keepass.services.AttachmentFileNotificationService.Companion.ACTION_ATTACHMENT_REMOVE
 
 class AttachmentFileBinderManager(private val activity: FragmentActivity) {
@@ -120,6 +121,10 @@ class AttachmentFileBinderManager(private val activity: FragmentActivity) {
         }, ACTION_ATTACHMENT_FILE_START_UPLOAD)
     }
 
+    fun stopUploadAllAttachments() {
+        start(null, ACTION_ATTACHMENT_FILE_STOP_UPLOAD)
+    }
+
     fun startDownloadAttachment(downloadFileUri: Uri,
                                 attachment: Attachment) {
         start(Bundle().apply {

app/src/main/res/values/strings.xml

@@ -514,6 +514,7 @@
     <string name="download_progression">In progress: %1$d%%</string>
     <string name="download_finalization">Finalizing…</string>
     <string name="download_complete">Complete!</string>
+    <string name="download_canceled">Canceled!</string>
     <string name="encryption_rijndael">Rijndael (AES)</string>
     <string name="encryption_twofish">Twofish</string>
     <string name="encryption_chacha20">ChaCha20</string>