Thumbnail support

data/src/main/java/org/cryptomator/data/cloud/crypto/CryptoCloudContentRepository.kt

@@ -13,6 +13,7 @@ import org.cryptomator.domain.repository.CloudContentRepository
 import org.cryptomator.domain.usecases.ProgressAware
 import org.cryptomator.domain.usecases.cloud.DataSource
 import org.cryptomator.domain.usecases.cloud.DownloadState
+import org.cryptomator.domain.usecases.cloud.FileTransferState
 import org.cryptomator.domain.usecases.cloud.UploadState
 import java.io.File
 import java.io.OutputStream
@@ -95,6 +96,11 @@ internal class CryptoCloudContentRepository(context: Context, cloudContentReposi
 		cryptoImpl.read(file, data, progressAware)
 	}
 
+	@Throws(BackendException::class)
+	override fun associateThumbnails(list: List<CryptoNode>, progressAware: ProgressAware<FileTransferState>) {
+		cryptoImpl.associateThumbnails(list, progressAware)
+	}
+
 	@Throws(BackendException::class)
 	override fun delete(node: CryptoNode) {
 		cryptoImpl.delete(node)

data/src/main/java/org/cryptomator/data/cloud/crypto/CryptoFile.kt

@@ -2,6 +2,7 @@ package org.cryptomator.data.cloud.crypto
 
 import org.cryptomator.domain.Cloud
 import org.cryptomator.domain.CloudFile
+import java.io.File
 import java.util.Date
 
 class CryptoFile(
@@ -12,6 +13,8 @@ class CryptoFile(
 	val cloudFile: CloudFile
 ) : CloudFile, CryptoNode {
 
+	var thumbnail : File? = null
+
 	override val cloud: Cloud?
 		get() = parent.cloud
 

data/src/main/java/org/cryptomator/data/cloud/crypto/CryptoImplDecorator.kt

@@ -1,6 +1,11 @@
 package org.cryptomator.data.cloud.crypto
 
 import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.ThumbnailUtils
+import com.google.common.util.concurrent.ThreadFactoryBuilder
+import com.tomclaw.cache.DiskLruCache
 import org.cryptomator.cryptolib.api.Cryptor
 import org.cryptomator.cryptolib.common.DecryptingReadableByteChannel
 import org.cryptomator.cryptolib.common.EncryptingWritableByteChannel
@@ -9,6 +14,7 @@ import org.cryptomator.domain.Cloud
 import org.cryptomator.domain.CloudFile
 import org.cryptomator.domain.CloudFolder
 import org.cryptomator.domain.CloudNode
+import org.cryptomator.domain.CloudType
 import org.cryptomator.domain.exception.BackendException
 import org.cryptomator.domain.exception.CloudNodeAlreadyExistsException
 import org.cryptomator.domain.exception.EmptyDirFileException
@@ -22,20 +28,36 @@ import org.cryptomator.domain.usecases.UploadFileReplacingProgressAware
 import org.cryptomator.domain.usecases.cloud.DataSource
 import org.cryptomator.domain.usecases.cloud.DownloadState
 import org.cryptomator.domain.usecases.cloud.FileBasedDataSource.Companion.from
+import org.cryptomator.domain.usecases.cloud.FileTransferState
 import org.cryptomator.domain.usecases.cloud.Progress
 import org.cryptomator.domain.usecases.cloud.UploadState
+import org.cryptomator.util.SharedPreferencesHandler
+import org.cryptomator.util.ThumbnailsOption
+import org.cryptomator.util.file.LruFileCacheUtil
+import org.cryptomator.util.file.MimeType
+import org.cryptomator.util.file.MimeTypeMap
+import org.cryptomator.util.file.MimeTypes
 import java.io.ByteArrayOutputStream
+import java.io.Closeable
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.io.IOException
 import java.io.OutputStream
+import java.io.PipedInputStream
+import java.io.PipedOutputStream
 import java.nio.ByteBuffer
 import java.nio.channels.Channels
 import java.util.LinkedList
 import java.util.Queue
 import java.util.UUID
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
 import java.util.function.Supplier
+import kotlin.system.measureTimeMillis
+import timber.log.Timber
 
 
 abstract class CryptoImplDecorator(
@@ -50,6 +72,59 @@ abstract class CryptoImplDecorator(
 	@Volatile
 	private var root: RootCryptoFolder? = null
 
+	private val sharedPreferencesHandler = SharedPreferencesHandler(context)
+
+	private var diskLruCache: MutableMap<LruFileCacheUtil.Cache, DiskLruCache?> = mutableMapOf()
+
+	private val mimeTypes = MimeTypes(MimeTypeMap())
+
+	private val thumbnailExecutorService: ExecutorService by lazy {
+		val threadFactory = ThreadFactoryBuilder().setNameFormat("thumbnail-generation-thread-%d").build()
+		Executors.newCachedThreadPool(threadFactory)
+	}
+
+	protected fun getLruCacheFor(type: CloudType): DiskLruCache? {
+		return getOrCreateLruCache(getCacheTypeFromCloudType(type), sharedPreferencesHandler.lruCacheSize())
+	}
+
+	private fun getOrCreateLruCache(cache: LruFileCacheUtil.Cache, cacheSize: Int): DiskLruCache? {
+		return diskLruCache.computeIfAbsent(cache) {
+			val cacheFile = LruFileCacheUtil(context).resolve(it)
+			try {
+				DiskLruCache.create(cacheFile, cacheSize.toLong())
+			} catch (e: IOException) {
+				Timber.tag("CryptoImplDecorator").e(e, "Failed to setup LRU cache for $cacheFile.name")
+				null
+			}
+		}
+	}
+
+	protected fun renameFileInCache(source: CryptoFile, target: CryptoFile) {
+		val oldCacheKey = generateCacheKey(source)
+		val newCacheKey = generateCacheKey(target)
+		source.cloudFile.cloud?.type()?.let { cloudType ->
+			getLruCacheFor(cloudType)?.let { diskCache ->
+				if (diskCache[oldCacheKey] != null) {
+					target.thumbnail = diskCache.put(newCacheKey, diskCache[oldCacheKey])
+					diskCache.delete(oldCacheKey)
+				}
+			}
+		}
+	}
+
+	private fun getCacheTypeFromCloudType(type: CloudType): LruFileCacheUtil.Cache {
+		return when (type) {
+			CloudType.DROPBOX -> LruFileCacheUtil.Cache.DROPBOX
+			CloudType.GOOGLE_DRIVE -> LruFileCacheUtil.Cache.GOOGLE_DRIVE
+			CloudType.ONEDRIVE -> LruFileCacheUtil.Cache.ONEDRIVE
+			CloudType.PCLOUD -> LruFileCacheUtil.Cache.PCLOUD
+			CloudType.WEBDAV -> LruFileCacheUtil.Cache.WEBDAV
+			CloudType.S3 -> LruFileCacheUtil.Cache.S3
+			CloudType.LOCAL -> LruFileCacheUtil.Cache.LOCAL
+			else -> throw IllegalStateException("Unexpected CloudType: $type")
+		}
+	}
+
 	@Throws(BackendException::class)
 	abstract fun folder(cryptoParent: CryptoFolder, cleartextName: String): CryptoFolder
 
@@ -309,8 +384,22 @@ abstract class CryptoImplDecorator(
 	@Throws(BackendException::class)
 	fun read(cryptoFile: CryptoFile, data: OutputStream, progressAware: ProgressAware<DownloadState>) {
 		val ciphertextFile = cryptoFile.cloudFile
+
+		val diskCache = cryptoFile.cloudFile.cloud?.type()?.let { getLruCacheFor(it) }
+		val cacheKey = generateCacheKey(cryptoFile)
+		val genThumbnail = isThumbnailGenerationAvailable(diskCache, cryptoFile.name)
+		var futureThumbnail: Future<*> = CompletableFuture.completedFuture(null)
+
+		val thumbnailWriter = PipedOutputStream()
+		val thumbnailReader = PipedInputStream(thumbnailWriter)
+
 		try {
 			val encryptedTmpFile = readToTmpFile(cryptoFile, ciphertextFile, progressAware)
+
+			if (genThumbnail) {
+				futureThumbnail = startThumbnailGeneratorThread(cryptoFile, diskCache!!, cacheKey, thumbnailReader)
+			}
+
 			progressAware.onProgress(Progress.started(DownloadState.decryption(cryptoFile)))
 			try {
 				Channels.newChannel(FileInputStream(encryptedTmpFile)).use { readableByteChannel ->
@@ -322,7 +411,12 @@ abstract class CryptoImplDecorator(
 						while (decryptingReadableByteChannel.read(buff).also { read = it } > 0) {
 							buff.flip()
 							data.write(buff.array(), 0, buff.remaining())
+							if (genThumbnail) {
+								thumbnailWriter.write(buff.array(), 0, buff.remaining())
+							}
+
 							decrypted += read.toLong()
+
 							progressAware
 								.onProgress(
 									Progress.progress(DownloadState.decryption(cryptoFile)) //
@@ -332,16 +426,178 @@ abstract class CryptoImplDecorator(
 								)
 						}
 					}
+					thumbnailWriter.flush()
 				}
 			} finally {
 				encryptedTmpFile.delete()
 				progressAware.onProgress(Progress.completed(DownloadState.decryption(cryptoFile)))
 			}
+
+			// Close thumbnail writer first, then wait for thumbnail generation to complete
+			if (genThumbnail) {
+				closeQuietly(thumbnailWriter)
+				try {
+					futureThumbnail.get(5, java.util.concurrent.TimeUnit.SECONDS) // Add timeout to prevent hanging
+				} catch (e: java.util.concurrent.TimeoutException) {
+					Timber.w("Thumbnail generation timed out for ${cryptoFile.name}")
+					futureThumbnail.cancel(true)
+				} catch (e: Exception) {
+					Timber.w(e, "Error waiting for thumbnail generation for ${cryptoFile.name}")
+				}
+			}
+			closeQuietly(thumbnailReader)
 		} catch (e: IOException) {
+			// Don't treat thumbnail-related pipe closed errors as fatal
+			if (e.message?.contains("Pipe closed") == true && genThumbnail) {
+				Timber.d("Pipe closed during thumbnail generation (expected): ${cryptoFile.name}")
+				// The file was successfully decrypted, just the thumbnail failed
+				return
+			}
 			throw FatalBackendException(e)
 		}
 	}
 
+	private fun closeQuietly(closeable: Closeable) {
+		try {
+			closeable.close();
+		} catch (e: IOException) {
+			// ignore
+		}
+	}
+
+	private fun startThumbnailGeneratorThread(cryptoFile: CryptoFile, diskCache: DiskLruCache, cacheKey: String, thumbnailReader: PipedInputStream): Future<*> {
+		return thumbnailExecutorService.submit {
+			try {
+				val options = BitmapFactory.Options()
+				val thumbnailBitmap: Bitmap?
+
+				// Use aggressive sampling for memory efficiency with large images
+				// Estimate file size and adjust sample size accordingly
+				val fileSize = cryptoFile.size ?: 0L
+				val fileSizeMB = fileSize / (1024 * 1024)
+
+				// Calculate sample size based on file size to prevent OOM
+				var sampleSize = when {
+					fileSizeMB > 50 -> 16  // 1/256 of original size for very large files
+					fileSizeMB > 30 -> 12  // 1/144 of original size for large files
+					fileSizeMB > 20 -> 8   // 1/64 of original size for medium-large files
+					fileSizeMB > 10 -> 6   // 1/36 of original size for medium files
+					else -> 4              // 1/16 of original size for smaller files
+				}
+
+				options.inSampleSize = sampleSize
+				options.inPreferredConfig = Bitmap.Config.RGB_565 // Use less memory than ARGB_8888
+				options.inDither = false
+				options.inPurgeable = true // Allow system to purge bitmap from memory if needed
+				options.inInputShareable = true
+
+				Timber.d("Generating thumbnail for ${cryptoFile.name} (${fileSizeMB}MB) with sampleSize: $sampleSize")
+
+				val bitmap = BitmapFactory.decodeStream(thumbnailReader, null, options)
+				if (bitmap == null) {
+					closeQuietly(thumbnailReader)
+					Timber.w("Failed to decode bitmap for thumbnail generation: ${cryptoFile.name}")
+					return@submit
+				}
+
+				val thumbnailWidth = 100
+				val thumbnailHeight = 100
+				thumbnailBitmap = ThumbnailUtils.extractThumbnail(bitmap, thumbnailWidth, thumbnailHeight)
+
+				// Clean up the original bitmap to free memory immediately
+				if (bitmap != thumbnailBitmap) {
+					bitmap.recycle()
+				}
+
+				if (thumbnailBitmap != null) {
+					storeThumbnail(diskCache, cacheKey, thumbnailBitmap)
+					thumbnailBitmap.recycle() // Clean up thumbnail bitmap after storing
+				}
+				closeQuietly(thumbnailReader)
+
+				cryptoFile.thumbnail = diskCache[cacheKey]
+				Timber.d("Successfully generated thumbnail for ${cryptoFile.name}")
+			} catch (e: OutOfMemoryError) {
+				closeQuietly(thumbnailReader)
+				Timber.e(e, "OutOfMemoryError during thumbnail generation for large image: ${cryptoFile.name} (${(cryptoFile.size ?: 0L) / (1024 * 1024)}MB)")
+				// Try to recover by forcing garbage collection
+				System.gc()
+			} catch (e: java.io.IOException) {
+				closeQuietly(thumbnailReader)
+				if (e.message?.contains("Pipe closed") == true) {
+					Timber.d("Thumbnail generation stream closed (expected for large files): ${cryptoFile.name}")
+				} else {
+					Timber.w(e, "IOException during thumbnail generation for file: ${cryptoFile.name}")
+				}
+			} catch (e: Exception) {
+				closeQuietly(thumbnailReader)
+				Timber.e(e, "Bitmap generation crashed for file: ${cryptoFile.name}")
+			}
+		}
+	}
+
+	protected fun generateCacheKey(cryptoFile: CryptoFile): String {
+		return String.format("%s-%d", cryptoFile.cloudFile.cloud?.id() ?: "common", cryptoFile.path.hashCode())
+	}
+
+	private fun isThumbnailGenerationAvailable(cache: DiskLruCache?, fileName: String): Boolean {
+		return isGenerateThumbnailsEnabled() && sharedPreferencesHandler.generateThumbnails() != ThumbnailsOption.READONLY && cache != null && isImageMediaType(fileName)
+	}
+
+	fun associateThumbnails(list: List<CryptoNode>, progressAware: ProgressAware<FileTransferState>) {
+		if (!isGenerateThumbnailsEnabled()) {
+			return
+		}
+		val cryptoFileList = list.filterIsInstance<CryptoFile>()
+		if (cryptoFileList.isEmpty()) {
+			return
+		}
+		val firstCryptoFile = cryptoFileList[0]
+		val cloudType = (firstCryptoFile).cloudFile.cloud?.type() ?: return
+		val diskCache = getLruCacheFor(cloudType) ?: return
+		val toProcess = cryptoFileList.filter { cryptoFile ->
+			(isImageMediaType(cryptoFile.name) && cryptoFile.thumbnail == null)
+		}
+		var associated = 0
+		val elapsed = measureTimeMillis {
+			toProcess.forEach { cryptoFile ->
+				val cacheKey = generateCacheKey(cryptoFile)
+				val cacheFile = diskCache[cacheKey]
+				if (cacheFile != null && cryptoFile.thumbnail == null) {
+					cryptoFile.thumbnail = cacheFile
+					associated++
+					val state = FileTransferState { cryptoFile }
+					val progress = Progress.progress(state).thatIsCompleted()
+					progressAware.onProgress(progress)
+				}
+			}
+		}
+		Timber.tag("THUMBNAIL").i("[AssociateThumbnails] associated:${associated} files, elapsed:${elapsed}ms")
+	}
+
+	private fun isGenerateThumbnailsEnabled(): Boolean {
+		return sharedPreferencesHandler.useLruCache() && sharedPreferencesHandler.generateThumbnails() != ThumbnailsOption.NEVER
+	}
+
+	private fun storeThumbnail(cache: DiskLruCache?, cacheKey: String, thumbnailBitmap: Bitmap) {
+		val thumbnailFile: File = File.createTempFile(UUID.randomUUID().toString(), ".thumbnail", internalCache)
+		thumbnailBitmap.compress(Bitmap.CompressFormat.JPEG, 100, thumbnailFile.outputStream())
+
+		try {
+			cache?.let {
+				LruFileCacheUtil.storeToLruCache(it, cacheKey, thumbnailFile)
+			} ?: Timber.tag("CryptoImplDecorator").e("Failed to store item in LRU cache")
+		} catch (e: IOException) {
+			Timber.tag("CryptoImplDecorator").e(e, "Failed to write the thumbnail in DiskLruCache")
+		}
+
+		thumbnailFile.delete()
+	}
+
+	private fun isImageMediaType(filename: String): Boolean {
+		return (mimeTypes.fromFilename(filename) ?: MimeType.WILDCARD_MIME_TYPE).mediatype == "image"
+	}
+
 	@Throws(BackendException::class, IOException::class)
 	private fun readToTmpFile(cryptoFile: CryptoFile, file: CloudFile, progressAware: ProgressAware<DownloadState>): File {
 		val encryptedTmpFile = File.createTempFile(UUID.randomUUID().toString(), ".crypto", internalCache)