Feature/supporting new compression formats

app/build.gradle.kts

@@ -97,6 +97,8 @@ dependencies {
     implementation(libs.androidx.documentfile)
     implementation(libs.androidx.swiperefreshlayout)
     implementation(libs.androidpdfviewer)
+    implementation(libs.apache.commons.compress)
+    implementation(libs.tukaanixz)
     implementation(libs.roottools)
     implementation(libs.rootshell)
     implementation(libs.gestureviews)

app/proguard-rules.pro

@@ -2,3 +2,4 @@
 -dontnote org.apache.http.**
 -keep class com.simplemobiletools.** { *; }
 -dontwarn com.simplemobiletools.**
+-dontwarn com.github.luben.zstd.ZstdOutputStream

app/src/main/kotlin/com/simplemobiletools/filemanager/pro/adapters/ItemsAdapter.kt

@@ -46,12 +46,8 @@ import com.simplemobiletools.filemanager.pro.models.ListItem
 import com.stericson.RootTools.RootTools
 import net.lingala.zip4j.exception.ZipException
 import net.lingala.zip4j.io.inputstream.ZipInputStream
-import net.lingala.zip4j.io.outputstream.ZipOutputStream
 import net.lingala.zip4j.model.LocalFileHeader
-import net.lingala.zip4j.model.ZipParameters
-import net.lingala.zip4j.model.enums.EncryptionMethod
 import java.io.BufferedInputStream
-import java.io.Closeable
 import java.io.File
 import java.util.*
 
@@ -476,7 +472,7 @@ class ItemsAdapter(
             return
         }
 
-        CompressAsDialog(activity, firstPath) { destination, password ->
+        CompressAsDialog(activity, firstPath) { destination, compressionFormat, password ->
             activity.handleAndroidSAFDialog(firstPath) { granted ->
                 if (!granted) {
                     return@handleAndroidSAFDialog
@@ -489,7 +485,7 @@ class ItemsAdapter(
                     activity.toast(R.string.compressing)
                     val paths = getSelectedFileDirItems().map { it.path }
                     ensureBackgroundThread {
-                        if (compressPaths(paths, destination, password)) {
+                        if (CompressionHelper.compress(activity, paths, destination, compressionFormat, password)) {
                             activity.runOnUiThread {
                                 activity.toast(R.string.compression_successful)
                                 listener?.refreshFragment()
@@ -638,89 +634,6 @@ class ItemsAdapter(
         }
     }
 
-    @SuppressLint("NewApi")
-    private fun compressPaths(sourcePaths: List<String>, targetPath: String, password: String? = null): Boolean {
-        val queue = LinkedList<String>()
-        val fos = activity.getFileOutputStreamSync(targetPath, "application/zip") ?: return false
-
-        val zout = password?.let { ZipOutputStream(fos, password.toCharArray()) } ?: ZipOutputStream(fos)
-        var res: Closeable = fos
-
-        fun zipEntry(name: String) = ZipParameters().also {
-            it.fileNameInZip = name
-            if (password != null) {
-                it.isEncryptFiles = true
-                it.encryptionMethod = EncryptionMethod.AES
-            }
-        }
-
-        try {
-            sourcePaths.forEach { currentPath ->
-                var name: String
-                var mainFilePath = currentPath
-                val base = "${mainFilePath.getParentPath()}/"
-                res = zout
-                queue.push(mainFilePath)
-                if (activity.getIsPathDirectory(mainFilePath)) {
-                    name = "${mainFilePath.getFilenameFromPath()}/"
-                    zout.putNextEntry(
-                        ZipParameters().also {
-                            it.fileNameInZip = name
-                        }
-                    )
-                }
-
-                while (!queue.isEmpty()) {
-                    mainFilePath = queue.pop()
-                    if (activity.getIsPathDirectory(mainFilePath)) {
-                        if (activity.isRestrictedSAFOnlyRoot(mainFilePath)) {
-                            activity.getAndroidSAFFileItems(mainFilePath, true) { files ->
-                                for (file in files) {
-                                    name = file.path.relativizeWith(base)
-                                    if (activity.getIsPathDirectory(file.path)) {
-                                        queue.push(file.path)
-                                        name = "${name.trimEnd('/')}/"
-                                        zout.putNextEntry(zipEntry(name))
-                                    } else {
-                                        zout.putNextEntry(zipEntry(name))
-                                        activity.getFileInputStreamSync(file.path)!!.copyTo(zout)
-                                        zout.closeEntry()
-                                    }
-                                }
-                            }
-                        } else {
-                            val mainFile = File(mainFilePath)
-                            for (file in mainFile.listFiles()) {
-                                name = file.path.relativizeWith(base)
-                                if (activity.getIsPathDirectory(file.absolutePath)) {
-                                    queue.push(file.absolutePath)
-                                    name = "${name.trimEnd('/')}/"
-                                    zout.putNextEntry(zipEntry(name))
-                                } else {
-                                    zout.putNextEntry(zipEntry(name))
-                                    activity.getFileInputStreamSync(file.path)!!.copyTo(zout)
-                                    zout.closeEntry()
-                                }
-                            }
-                        }
-
-                    } else {
-                        name = if (base == currentPath) currentPath.getFilenameFromPath() else mainFilePath.relativizeWith(base)
-                        zout.putNextEntry(zipEntry(name))
-                        activity.getFileInputStreamSync(mainFilePath)!!.copyTo(zout)
-                        zout.closeEntry()
-                    }
-                }
-            }
-        } catch (exception: Exception) {
-            activity.showErrorToast(exception)
-            return false
-        } finally {
-            res.close()
-        }
-        return true
-    }
-
     private fun askConfirmDelete() {
         activity.handleDeletePasswordProtection {
             val itemsCnt = selectedKeys.size

app/src/main/kotlin/com/simplemobiletools/filemanager/pro/dialogs/CompressAsDialog.kt

@@ -1,15 +1,21 @@
 package com.simplemobiletools.filemanager.pro.dialogs
 
 import android.view.View
+import android.widget.ArrayAdapter
 import androidx.appcompat.app.AlertDialog
 import com.simplemobiletools.commons.activities.BaseSimpleActivity
 import com.simplemobiletools.commons.dialogs.FilePickerDialog
 import com.simplemobiletools.commons.extensions.*
 import com.simplemobiletools.filemanager.pro.R
 import com.simplemobiletools.filemanager.pro.databinding.DialogCompressAsBinding
 import com.simplemobiletools.filemanager.pro.extensions.config
+import com.simplemobiletools.filemanager.pro.helpers.CompressionFormat
 
-class CompressAsDialog(val activity: BaseSimpleActivity, val path: String, val callback: (destination: String, password: String?) -> Unit) {
+class CompressAsDialog(
+    val activity: BaseSimpleActivity,
+    val path: String,
+    val callback: (destination: String, compressionFormat: CompressionFormat, password: String?) -> Unit
+) {
     private val binding = DialogCompressAsBinding.inflate(activity.layoutInflater)
 
     init {
@@ -29,6 +35,24 @@ class CompressAsDialog(val activity: BaseSimpleActivity, val path: String, val c
                 }
             }
 
+            compressionFormatValue.apply {
+                setOnClickListener {
+                    activity.hideKeyboard(filenameValue)
+                }
+                val adapter = ArrayAdapter(
+                    activity,
+                    android.R.layout.simple_dropdown_item_1line,
+                    CompressionFormat.entries.take(CompressionFormat.entries.size - 1).map { it.extension })
+                setAdapter(adapter)
+                setText(adapter.getItem(0), false)
+
+                setOnItemClickListener { _, _, i, _ ->
+                    val compressionFormat = CompressionFormat.entries[i]
+                    filenameHint.hint = String.format(activity.getString(R.string.filename_without_extension), compressionFormat.extension)
+                    passwordProtect.beVisibleIf(compressionFormat.canCreateEncryptedArchive)
+                    enterPasswordHint.beVisibleIf(compressionFormat.canCreateEncryptedArchive && passwordProtect.isChecked)
+                }
+            }
             passwordProtect.setOnCheckedChangeListener { _, _ ->
                 enterPasswordHint.beVisibleIf(passwordProtect.isChecked)
             }
@@ -53,14 +77,14 @@ class CompressAsDialog(val activity: BaseSimpleActivity, val path: String, val c
                         when {
                             name.isEmpty() -> activity.toast(R.string.empty_name)
                             name.isAValidFilename() -> {
-                                val newPath = "$realPath/$name.zip"
+                                val newPath = "$realPath/$name${getSelectedCompressionFormat().extension}"
                                 if (activity.getDoesFilePathExist(newPath)) {
                                     activity.toast(R.string.name_taken)
                                     return@OnClickListener
                                 }
 
                                 alertDialog.dismiss()
-                                callback(newPath, password)
+                                callback(newPath, getSelectedCompressionFormat(), password)
                             }
 
                             else -> activity.toast(R.string.invalid_name)
@@ -69,4 +93,6 @@ class CompressAsDialog(val activity: BaseSimpleActivity, val path: String, val c
                 }
             }
     }
+
+    private fun getSelectedCompressionFormat() = CompressionFormat.fromExtension(binding.compressionFormatValue.text.toString())
 }

app/src/main/kotlin/com/simplemobiletools/filemanager/pro/helpers/CompressionFormat.kt

@@ -0,0 +1,35 @@
+package com.simplemobiletools.filemanager.pro.helpers
+
+import org.apache.commons.compress.compressors.CompressorStreamFactory
+
+enum class CompressionFormat(
+    val extension: String,
+    val mimeType: String,
+    val compressorStreamFactory: String,
+    val canReadEncryptedArchive: Boolean,
+    val canCreateEncryptedArchive: Boolean
+) {
+    ZIP(".zip", "application/zip", "", true, true),
+    SEVEN_ZIP(".7z", "application/x-7z-compressed", "", true, false),
+    TAR_GZ(".tar.gz", "application/gzip", CompressorStreamFactory.GZIP, false, false),
+    TAR_XZ(".tar.xz", "application/x-xz", CompressorStreamFactory.XZ, false, false),
+    UNKNOWN("", "", "", false, false);
+
+    companion object {
+        fun fromExtension(extension: String): CompressionFormat {
+            val normalizedExtension = if (extension.startsWith(".")) {
+                extension
+            } else {
+                ".$extension"
+            }
+
+            return when (normalizedExtension.lowercase()) {
+                ZIP.extension -> ZIP
+                SEVEN_ZIP.extension -> SEVEN_ZIP
+                TAR_GZ.extension -> TAR_GZ
+                TAR_XZ.extension -> TAR_XZ
+                else -> UNKNOWN
+            }
+        }
+    }
+}