and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.filesystem;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.amaze.filemanager.fileoperations.filesystem.OpenMode;
+
+import android.os.Parcel;
+
+/** Created by Rustam Khadipash on 29/3/2018. */
+public class HybridFileParcelableTest {
+ private HybridFileParcelable filePath;
+ private HybridFileParcelable directory;
+ private HybridFileParcelable file;
+
+ @Before
+ public void setUp() {
+ filePath = new HybridFileParcelable("/storage/sdcard0/Test1/Test1.txt");
+
+ directory = new HybridFileParcelable("/storage/sdcard0/Test2", "rw", 123456, 654321, true);
+
+ file =
+ new HybridFileParcelable("/storage/sdcard0/Test3/Test3.txt", "rw", 123456, 654321, false);
+ }
+
+ /** Purpose: Get name of a file / directory Input: no Expected: return file / directory's name */
+ @Test
+ public void getName() {
+ assertEquals("Test1.txt", filePath.getName());
+ assertEquals("Test2", directory.getName());
+ assertEquals("Test3.txt", file.getName());
+ }
+
+ /**
+ * Purpose: Change name of a file / directory Input: setName newName Expected: File / directory's
+ * name is changed
+ */
+ @Test
+ public void setName() {
+ filePath.setName("Tset1.txt");
+ assertEquals("Tset1.txt", filePath.getName());
+ directory.setName("Tset2");
+ assertEquals("Tset2", directory.getName());
+ file.setName("Tset3.txt");
+ assertEquals("Tset3.txt", file.getName());
+ }
+
+ /**
+ * Purpose: Get open mode of a file / directory Input: no Expected: return OpenMode.FILE
+ *
+ * All files and directories in this class have open mode set as OpenMode.FILE
+ */
+ @Test
+ public void getMode() {
+ assertEquals(OpenMode.FILE, filePath.getMode());
+ assertEquals(OpenMode.FILE, directory.getMode());
+ assertEquals(OpenMode.FILE, file.getMode());
+ }
+
+ /** Purpose: Get link to a file / directory Input: no Expected: return empty string */
+ @Test
+ public void getLink() {
+ assertEquals("", filePath.getLink());
+ assertEquals("", directory.getLink());
+ assertEquals("", file.getLink());
+ }
+
+ /**
+ * Purpose: Set link to a file / directory Input: setLink newLink Expected: File / directory's
+ * link is changed
+ */
+ @Test
+ public void setLink() {
+ filePath.setLink("abc");
+ assertEquals("abc", filePath.getLink());
+ directory.setLink("def");
+ assertEquals("def", directory.getLink());
+ file.setLink("ghi");
+ assertEquals("ghi", file.getLink());
+ }
+
+ /** Purpose: Get creation date of a file / directory Input: no Expected: return date */
+ @Test
+ public void getDate() {
+ assertEquals(0, filePath.getDate());
+ assertEquals(123456, directory.getDate());
+ assertEquals(123456, file.getDate());
+ }
+
+ /**
+ * Purpose: Change creation date of a file / directory Input: setDate newDate Expected: File /
+ * directory's creation date is changed
+ */
+ @Test
+ public void setDate() {
+ filePath.setDate(746352);
+ assertEquals(746352, filePath.getDate());
+ directory.setDate(474587);
+ assertEquals(474587, directory.getDate());
+ file.setDate(3573335);
+ assertEquals(3573335, file.getDate());
+ }
+
+ /** Purpose: Get size of a file / directory Input: no Expected: return size */
+ @Test
+ public void getSize() {
+ assertEquals(0, filePath.getSize());
+ assertEquals(654321, directory.getSize());
+ assertEquals(654321, file.getSize());
+ }
+
+ /**
+ * Purpose: Change size of a file / directory Input: setSize newSize Expected: File / directory's
+ * size is changed
+ */
+ @Test
+ public void setSize() {
+ filePath.setSize(3534546);
+ assertEquals(3534546, filePath.getSize());
+ directory.setSize(1745534);
+ assertEquals(1745534, directory.getSize());
+ file.setSize(7546543);
+ assertEquals(7546543, file.getSize());
+ }
+
+ /** Purpose: Check whether it is a file or directory Input: no Expected: return directory */
+ @Test
+ public void isDirectory() {
+ assertEquals(false, filePath.isDirectory());
+ assertEquals(true, directory.isDirectory());
+ assertEquals(false, file.isDirectory());
+ }
+
+ /**
+ * Purpose: Change type to file / directory Input: setDirectory isDirectory Expected: File /
+ * directory's type is changed
+ */
+ @Test
+ public void setDirectory() {
+ filePath.setDirectory(true);
+ assertEquals(true, filePath.isDirectory());
+ directory.setDirectory(false);
+ assertEquals(false, directory.isDirectory());
+ file.setDirectory(true);
+ assertEquals(true, file.isDirectory());
+ }
+
+ /** Purpose: Get path to a file / directory Input: no Expected: return path */
+ @Test
+ public void getPath() {
+ assertEquals("/storage/sdcard0/Test1/Test1.txt", filePath.getPath());
+ assertEquals("/storage/sdcard0/Test2", directory.getPath());
+ assertEquals("/storage/sdcard0/Test3/Test3.txt", file.getPath());
+ }
+
+ /** Purpose: Get file / directory's permissions Input: no Expected: return permissions */
+ @Test
+ public void getPermission() {
+ assertEquals(null, filePath.getPermission());
+ assertEquals("rw", directory.getPermission());
+ assertEquals("rw", file.getPermission());
+ }
+
+ /**
+ * Purpose: Change permissions of a file / directory Input: setPermission newPermission Expected:
+ * File / directory's permissions are changed
+ */
+ @Test
+ public void setPermission() {
+ filePath.setPermission("rwx");
+ assertEquals("rwx", filePath.getPermission());
+ directory.setPermission("rwx");
+ assertEquals("rwx", directory.getPermission());
+ file.setPermission("rwx");
+ assertEquals("rwx", file.getPermission());
+ }
+
+ /**
+ * Purpose: Write an object into a parcel, send it through an intent and read the object from the
+ * parcel Input: writeToParcel parcel object Expected: The parcel can be sent and the object can
+ * be extracted from the parcel
+ */
+ @Test
+ public void writeToParcel() {
+ Parcel parcel = Parcel.obtain();
+ file.writeToParcel(parcel, file.describeContents());
+ parcel.setDataPosition(0);
+
+ HybridFileParcelable createdFromParcel = HybridFileParcelable.CREATOR.createFromParcel(parcel);
+ assertEquals(file.getDate(), createdFromParcel.getDate());
+ assertEquals(file.getLink(), createdFromParcel.getLink());
+ assertEquals(file.getMode(), createdFromParcel.getMode());
+ assertEquals(file.getName(), createdFromParcel.getName());
+ assertEquals(file.getPath(), createdFromParcel.getPath());
+ assertEquals(file.getPermission(), createdFromParcel.getPermission());
+ assertEquals(file.getSize(), createdFromParcel.getSize());
+ assertEquals(file.isDirectory(), createdFromParcel.isDirectory());
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/filesystem/files/CryptUtilTest.java b/app/src/androidTest/java/com/amaze/filemanager/filesystem/files/CryptUtilTest.java
new file mode 100644
index 0000000..7b7728b
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/filesystem/files/CryptUtilTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.filesystem.files;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.amaze.filemanager.BuildConfig;
+import com.amaze.filemanager.utils.PasswordUtil;
+
+import android.content.Context;
+import android.util.Base64;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+@RunWith(AndroidJUnit4.class)
+public class CryptUtilTest {
+
+ private Context context;
+
+ @Before
+ public void setUp() {
+ context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+ }
+
+ @Test
+ public void testIvValueIsCorrect() {
+ assertEquals("LxbHiJhhUXcj", BuildConfig.CRYPTO_IV);
+ }
+
+ @Test
+ public void testEncryptDecrypt() throws Exception {
+ String password = "hackme";
+ String encrypted = PasswordUtil.INSTANCE.encryptPassword(context, password, Base64.URL_SAFE);
+ assertEquals(
+ password, PasswordUtil.INSTANCE.decryptPassword(context, encrypted, Base64.URL_SAFE));
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/filesystem/files/GenericCopyUtilEspressoTest.java b/app/src/androidTest/java/com/amaze/filemanager/filesystem/files/GenericCopyUtilEspressoTest.java
new file mode 100644
index 0000000..5ff4562
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/filesystem/files/GenericCopyUtilEspressoTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.filesystem.files;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.channels.Channels;
+import java.security.DigestInputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.amaze.filemanager.asynchronous.management.ServiceWatcherUtil;
+import com.amaze.filemanager.test.DummyFileGenerator;
+import com.amaze.filemanager.utils.ProgressHandler;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+@RunWith(AndroidJUnit4.class)
+public class GenericCopyUtilEspressoTest {
+
+ private GenericCopyUtil copyUtil;
+
+ private File file1, file2;
+
+ @Before
+ public void setUp() throws IOException {
+ copyUtil =
+ new GenericCopyUtil(
+ InstrumentationRegistry.getInstrumentation().getTargetContext(), new ProgressHandler());
+ file1 = File.createTempFile("test", "bin");
+ file2 = File.createTempFile("test", "bin");
+ file1.deleteOnExit();
+ file2.deleteOnExit();
+ }
+
+ @Test
+ public void testCopyFile1() throws IOException, NoSuchAlgorithmException {
+ doTestCopyFile1(512);
+ doTestCopyFile1(10 * 1024 * 1024);
+ }
+
+ @Test
+ public void testCopyFile2() throws IOException, NoSuchAlgorithmException {
+ doTestCopyFile2(512);
+ doTestCopyFile2(10 * 1024 * 1024);
+ }
+
+ @Test
+ public void testCopyFile3() throws IOException, NoSuchAlgorithmException {
+ doTestCopyFile3(512);
+ doTestCopyFile3(10 * 1024 * 1024);
+ }
+
+ // doCopy(ReadableByteChannel in, WritableByteChannel out)
+ private void doTestCopyFile1(int size) throws IOException, NoSuchAlgorithmException {
+ byte[] checksum = DummyFileGenerator.createFile(file1, size);
+ copyUtil.doCopy(
+ new FileInputStream(file1).getChannel(),
+ Channels.newChannel(new FileOutputStream(file2)),
+ ServiceWatcherUtil.UPDATE_POSITION);
+ assertEquals(file1.length(), file2.length());
+ assertSha1Equals(checksum, file2);
+ }
+
+ // copy(FileChannel in, FileChannel out)
+ private void doTestCopyFile2(int size) throws IOException, NoSuchAlgorithmException {
+ byte[] checksum = DummyFileGenerator.createFile(file1, size);
+ copyUtil.copyFile(
+ new FileInputStream(file1).getChannel(),
+ new FileOutputStream(file2).getChannel(),
+ ServiceWatcherUtil.UPDATE_POSITION);
+ assertEquals(file1.length(), file2.length());
+ assertSha1Equals(checksum, file2);
+ }
+
+ // copy(BufferedInputStream in, BufferedOutputStream out)
+ private void doTestCopyFile3(int size) throws IOException, NoSuchAlgorithmException {
+ byte[] checksum = DummyFileGenerator.createFile(file1, size);
+ copyUtil.copyFile(
+ new BufferedInputStream(new FileInputStream(file1)),
+ new BufferedOutputStream(new FileOutputStream(file2)),
+ ServiceWatcherUtil.UPDATE_POSITION);
+ assertEquals(file1.length(), file2.length());
+ assertSha1Equals(checksum, file2);
+ }
+
+ private void assertSha1Equals(byte[] expected, File file)
+ throws NoSuchAlgorithmException, IOException {
+ MessageDigest md = MessageDigest.getInstance("SHA-1");
+ DigestInputStream in = new DigestInputStream(new FileInputStream(file), md);
+ byte[] buffer = new byte[GenericCopyUtil.DEFAULT_BUFFER_SIZE];
+ while (in.read(buffer) > -1) {}
+ in.close();
+ assertArrayEquals(expected, md.digest());
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/ssh/SshClientUtilTest.java b/app/src/androidTest/java/com/amaze/filemanager/ssh/SshClientUtilTest.java
new file mode 100644
index 0000000..42774f9
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/ssh/SshClientUtilTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.ssh;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.amaze.filemanager.filesystem.ftp.NetCopyClientUtils;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+@RunWith(AndroidJUnit4.class)
+public class SshClientUtilTest {
+
+ @Test
+ public void testEncryptDecryptUriWithNoPassword() {
+ String uri = "ssh://testuser@127.0.0.1:22";
+ assertEquals(uri, NetCopyClientUtils.INSTANCE.encryptFtpPathAsNecessary(uri));
+ assertEquals(uri, NetCopyClientUtils.INSTANCE.encryptFtpPathAsNecessary(uri));
+ }
+
+ @Test
+ public void testEncryptDecryptPasswordWithMinusSign1() {
+ String uri = "ssh://testuser:abcd-efgh@127.0.0.1:22";
+ String result = NetCopyClientUtils.INSTANCE.encryptFtpPathAsNecessary(uri);
+ assertTrue(result.contains("ssh://testuser:"));
+ assertTrue(result.contains("@127.0.0.1:22"));
+ String verify = NetCopyClientUtils.INSTANCE.decryptFtpPathAsNecessary(result);
+ assertEquals(uri, verify);
+ }
+
+ @Test
+ public void testEncryptDecryptPasswordWithMinusSign2() {
+ String uri = "ssh://testuser:---------------@127.0.0.1:22";
+ String result = NetCopyClientUtils.INSTANCE.encryptFtpPathAsNecessary(uri);
+ assertTrue(result.contains("ssh://testuser:"));
+ assertTrue(result.contains("@127.0.0.1:22"));
+ String verify = NetCopyClientUtils.INSTANCE.decryptFtpPathAsNecessary(result);
+ assertEquals(uri, verify);
+ }
+
+ @Test
+ public void testEncryptDecryptPasswordWithMinusSign3() {
+ String uri = "ssh://testuser:--agdiuhdpost15@127.0.0.1:22";
+ String result = NetCopyClientUtils.INSTANCE.encryptFtpPathAsNecessary(uri);
+ assertTrue(result.contains("ssh://testuser:"));
+ assertTrue(result.contains("@127.0.0.1:22"));
+ String verify = NetCopyClientUtils.INSTANCE.decryptFtpPathAsNecessary(result);
+ assertEquals(uri, verify);
+ }
+
+ @Test
+ public void testEncryptDecryptPasswordWithMinusSign4() {
+ String uri = "ssh://testuser:t-h-i-s-i-s-p-a-s-s-w-o-r-d-@127.0.0.1:22";
+ String result = NetCopyClientUtils.INSTANCE.encryptFtpPathAsNecessary(uri);
+ assertTrue(result.contains("ssh://testuser:"));
+ assertTrue(result.contains("@127.0.0.1:22"));
+ String verify = NetCopyClientUtils.INSTANCE.decryptFtpPathAsNecessary(result);
+ assertEquals(uri, verify);
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/test/DummyFileGenerator.java b/app/src/androidTest/java/com/amaze/filemanager/test/DummyFileGenerator.java
new file mode 100644
index 0000000..43f6591
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/test/DummyFileGenerator.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.test;
+
+import static com.amaze.filemanager.filesystem.files.GenericCopyUtil.DEFAULT_BUFFER_SIZE;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.security.DigestOutputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Random;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+
+/**
+ * Generate file of specified size using randomly generated bytes.
+ *
+ * Because of the need that both Espresso and Robolectric tests depends on it, it needs to be
+ * placed at the main source tree, and hide it using {@link VisibleForTesting}.
+ */
+@VisibleForTesting(otherwise = VisibleForTesting.NONE)
+@RestrictTo(RestrictTo.Scope.TESTS)
+public abstract class DummyFileGenerator {
+
+ /**
+ * @param destFile File to be generated with random bytes
+ * @param size file size
+ * @return SHA1 checksum of the generated file, as byte array
+ * @throws IOException in case any I/O error occurred
+ */
+ @VisibleForTesting(otherwise = VisibleForTesting.NONE)
+ @RestrictTo(RestrictTo.Scope.TESTS)
+ public static byte[] createFile(@NonNull File destFile, int size) throws IOException {
+ Random rand = new SecureRandom();
+ MessageDigest md = null;
+ try {
+ md = MessageDigest.getInstance("SHA-1");
+ } catch (NoSuchAlgorithmException shouldNeverHappen) {
+ throw new IOException("SHA-1 implementation not found");
+ }
+
+ FileOutputStream out = new FileOutputStream(destFile);
+ DigestOutputStream dout = new DigestOutputStream(out, md);
+ int count = 0;
+ for (int i = size; i >= 0; i -= DEFAULT_BUFFER_SIZE, count += DEFAULT_BUFFER_SIZE) {
+ byte[] bytes = new byte[i > DEFAULT_BUFFER_SIZE ? DEFAULT_BUFFER_SIZE : i];
+ rand.nextBytes(bytes);
+ dout.write(bytes);
+ }
+ dout.flush();
+ dout.close();
+
+ return md.digest();
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/test/StoragePermissionHelper.kt b/app/src/androidTest/java/com/amaze/filemanager/test/StoragePermissionHelper.kt
new file mode 100644
index 0000000..c71d892
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/test/StoragePermissionHelper.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2014-2022 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.test
+
+// import android.content.Intent
+// import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+// import android.net.Uri
+// import android.os.Build
+// import android.os.Build.VERSION.SDK_INT
+// import android.os.Environment
+// import android.provider.Settings
+// import android.widget.Switch
+// import androidx.test.platform.app.InstrumentationRegistry
+// import androidx.test.uiautomator.UiDevice
+// import androidx.test.uiautomator.UiSelector
+// import org.junit.Assert.assertTrue
+
+object StoragePermissionHelper {
+ /**
+ * This method is intended for Android R or above devices to obtain MANAGE_EXTERNAL_STORAGE
+ * permission via UI Automator framework when running relevant Espresso tests.
+ *
+ * This method is flat commented out because UI Automator requires Android SDK 18, while
+ * currently we still want to support SDK 14.
+ */
+ @JvmStatic
+ fun obtainManageAppAllFileAccessPermissionAutomatically() {
+// if (!Environment.isExternalStorageManager() && SDK_INT > Build.VERSION_CODES.R) {
+// InstrumentationRegistry.getInstrumentation().run {
+// val device = androidx.test.uiautomator.UiDevice.getInstance(this)
+// val context = this.targetContext
+// device.pressHome()
+// val intent = Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
+// .setData(Uri.parse("package:${context.packageName}"))
+// .addFlags(FLAG_ACTIVITY_NEW_TASK)
+// context.startActivity(intent)
+// val switch = device.findObject(
+// androidx.test.uiautomator.UiSelector()
+// .packageName("com.android.settings")
+// .className(Switch::class.java.name)
+// .resourceId("android:id/switch_widget")
+// )
+// switch.click()
+// assertTrue(switch.isChecked)
+// device.pressHome()
+// }
+// }
+// assertTrue(Environment.isExternalStorageManager())
+ return // Try to get codacy happy if they ever check me... pretend I am doing something
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/ui/activities/TextEditorActivityEspressoTest.java b/app/src/androidTest/java/com/amaze/filemanager/ui/activities/TextEditorActivityEspressoTest.java
new file mode 100644
index 0000000..e88eab8
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/ui/activities/TextEditorActivityEspressoTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.ui.activities;
+
+import static org.junit.Assert.assertNotEquals;
+
+import java.io.File;
+import java.util.concurrent.CountDownLatch;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.amaze.filemanager.ui.activities.texteditor.TextEditorActivity;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.SmallTest;
+import androidx.test.filters.Suppress;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.rule.ActivityTestRule;
+
+@SmallTest
+@RunWith(AndroidJUnit4.class)
+@Suppress
+// Have to rewrite to cope with Android 11 storage access model
+public class TextEditorActivityEspressoTest {
+
+ @Rule
+ public ActivityTestRule activityRule =
+ new ActivityTestRule<>(TextEditorActivity.class, true, false);
+
+ private Context context;
+
+ private Uri uri;
+
+ @Before
+ public void setUp() {
+ context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+ File file = new File("/default.prop");
+ uri = Uri.fromFile(file);
+ }
+
+ @Test
+ public void testOpenFile() throws Exception {
+ Intent intent =
+ new Intent(context, TextEditorActivity.class)
+ .setAction(Intent.ACTION_VIEW)
+ .addCategory(Intent.CATEGORY_DEFAULT)
+ .setType("text/plain")
+ .setData(uri);
+ activityRule.launchActivity(intent);
+ CountDownLatch waiter = new CountDownLatch(1);
+ while ("".equals(activityRule.getActivity().mainTextView.getText().toString())) {
+ waiter.await();
+ }
+ waiter.countDown();
+ assertNotEquals("", activityRule.getActivity().mainTextView.getText());
+ assertNotEquals("foobar", activityRule.getActivity().mainTextView.getText());
+ // Add extra time for you to see the Activity did load, and text is actually there
+ // Thread.sleep(1000);
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/ui/fragments/BackupPrefsFragmentTest.kt b/app/src/androidTest/java/com/amaze/filemanager/ui/fragments/BackupPrefsFragmentTest.kt
new file mode 100644
index 0000000..027f5c5
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/ui/fragments/BackupPrefsFragmentTest.kt
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2014-2022 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.ui.fragments
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.SharedPreferences
+import android.net.Uri
+import androidx.lifecycle.Lifecycle
+import androidx.preference.PreferenceManager
+import androidx.test.core.app.ActivityScenario
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.amaze.filemanager.R
+import com.amaze.filemanager.ui.activities.PreferencesActivity
+import com.amaze.filemanager.ui.fragments.preferencefragments.BackupPrefsFragment
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class BackupPrefsFragmentTest {
+ var storagePath = "/storage/emulated/0"
+ var fileName = "amaze_backup.json"
+
+ /** Test exporting */
+ @Test
+ fun testExport() {
+ val backupPrefsFragment = BackupPrefsFragment()
+
+ val activityScenario = ActivityScenario.launch(PreferencesActivity::class.java)
+
+ activityScenario.moveToState(Lifecycle.State.STARTED)
+
+ val exportFile =
+ File(
+ storagePath +
+ File.separator +
+ fileName,
+ )
+
+ exportFile.delete() // delete if already exists
+
+ activityScenario.onActivity {
+ it.supportFragmentManager.beginTransaction()
+ .add(backupPrefsFragment, null)
+ .commitNow()
+
+ backupPrefsFragment.exportPrefs()
+ }
+
+ val tempFile =
+ File(
+ ApplicationProvider.getApplicationContext().cacheDir.absolutePath +
+ File.separator +
+ fileName,
+ )
+
+ Assert.assertTrue(tempFile.exists())
+
+ // terrible hack :cringe:
+ onView(withId(R.id.home)).perform(ViewActions.click())
+ Thread.sleep(500)
+
+ onView(withText(R.string.save)).perform(ViewActions.click())
+ Thread.sleep(500)
+
+ Assert.assertTrue(exportFile.exists())
+ }
+
+ /** Test whether the exported file contains the expected preference values */
+ @Test
+ fun verifyExportFile() {
+ val backupPrefsFragment = BackupPrefsFragment()
+
+ val activityScenario = ActivityScenario.launch(PreferencesActivity::class.java)
+
+ activityScenario.moveToState(Lifecycle.State.STARTED)
+
+ val file =
+ File(
+ storagePath +
+ File.separator +
+ fileName,
+ )
+
+ activityScenario.onActivity { preferencesActivity ->
+ preferencesActivity.supportFragmentManager.beginTransaction()
+ .add(backupPrefsFragment, null)
+ .commitNow()
+
+ val preferences =
+ PreferenceManager
+ .getDefaultSharedPreferences(preferencesActivity)
+
+ val preferenceMap: Map = preferences.all
+
+ val inputString =
+ file
+ .inputStream()
+ .bufferedReader()
+ .use {
+ it.readText()
+ }
+
+ val type = object : TypeToken>() {}.type
+
+ val importMap: Map =
+ GsonBuilder()
+ .create()
+ .fromJson(
+ inputString,
+ type,
+ )
+
+ for ((key, value) in preferenceMap) {
+ var mapValue = importMap[key]
+
+ if (mapValue!!::class.simpleName.equals("Double")) {
+ mapValue = (mapValue as Double).toInt() // since Gson parses Integer as Double
+ }
+
+ Assert.assertEquals(value, mapValue)
+ }
+ }
+ }
+
+ /** Test import */
+ @Test
+ fun testImport() {
+ val backupPrefsFragment = BackupPrefsFragment()
+
+ val activityScenario = ActivityScenario.launch(PreferencesActivity::class.java)
+
+ activityScenario.moveToState(Lifecycle.State.STARTED)
+
+ val exportFile =
+ File(
+ storagePath +
+ File.separator +
+ fileName,
+ )
+
+ exportFile.delete() // delete if already exists
+
+ activityScenario.onActivity { preferencesActivity ->
+ preferencesActivity.supportFragmentManager.beginTransaction()
+ .add(backupPrefsFragment, null)
+ .commitNow()
+
+ javaClass.getResourceAsStream("/$fileName")?.copyTo(exportFile.outputStream())
+
+ backupPrefsFragment.onActivityResult(
+ BackupPrefsFragment.IMPORT_BACKUP_FILE,
+ Activity.RESULT_OK,
+ Intent().setData(
+ Uri.fromFile(exportFile),
+ ),
+ )
+
+ val inputString =
+ exportFile
+ .inputStream()
+ .bufferedReader()
+ .use {
+ it.readText()
+ }
+
+ val type = object : TypeToken>() {}.type
+
+ val importMap: Map =
+ GsonBuilder()
+ .create()
+ .fromJson(
+ inputString,
+ type,
+ )
+
+ val preferences =
+ PreferenceManager
+ .getDefaultSharedPreferences(preferencesActivity)
+
+ val preferenceMap: Map = preferences.all
+
+ for ((key, value) in preferenceMap) {
+ Assert.assertTrue(checkPrefEqual(preferences, importMap, key, value))
+ }
+ }
+ }
+
+ private fun checkPrefEqual(
+ preferences: SharedPreferences,
+ importMap: Map,
+ key: String?,
+ value: Any?,
+ ): Boolean {
+ when (value!!::class.simpleName) {
+ "Boolean" -> return importMap[key] as Boolean ==
+ preferences.getBoolean(key, false)
+ "Float" ->
+ importMap[key] as Float ==
+ preferences.getFloat(key, 0f)
+ "Int" -> {
+ // since Gson parses Integer as Double
+ val toInt = (importMap[key] as Double).toInt()
+
+ return toInt == preferences.getInt(key, 0)
+ }
+ "Long" -> return importMap[key] as Long ==
+ preferences.getLong(key, 0L)
+ "String" -> return importMap[key] as String ==
+ preferences.getString(key, null)
+ "Set<*>" -> return importMap[key] as Set<*> ==
+ preferences.getStringSet(key, null)
+ }
+ return false
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/utils/CryptUtilEspressoTest.kt b/app/src/androidTest/java/com/amaze/filemanager/utils/CryptUtilEspressoTest.kt
new file mode 100644
index 0000000..d6bba34
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/utils/CryptUtilEspressoTest.kt
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2014-2022 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.utils
+
+import android.os.Build.VERSION.SDK_INT
+import android.os.Build.VERSION_CODES.JELLY_BEAN_MR2
+import android.os.Environment
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.SmallTest
+import androidx.test.rule.GrantPermissionRule
+import com.amaze.filemanager.application.AppConfig
+import com.amaze.filemanager.filesystem.HybridFileParcelable
+import com.amaze.filemanager.filesystem.files.CryptUtil
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.ByteArrayInputStream
+import java.io.File
+import java.io.FileOutputStream
+import kotlin.random.Random
+
+/**
+ * Test for [CryptUtil] against real devices.
+ *
+ */
+@SmallTest
+@RunWith(AndroidJUnit4::class)
+@Suppress("StringLiteralDuplication")
+class CryptUtilEspressoTest {
+ @Rule @JvmField
+ val storagePermissionRule: GrantPermissionRule =
+ GrantPermissionRule
+ .grant(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
+
+ /**
+ * Sanity test of CryptUtil legacy method, to ensure refactoring won't break
+ * on physical devices
+ */
+ @Test
+ fun testEncryptDecryptLegacyMethod() {
+ val source = Random(System.currentTimeMillis()).nextBytes(117)
+ val sourceFile = File(Environment.getExternalStorageDirectory(), "test.bin")
+ ByteArrayInputStream(source).copyTo(FileOutputStream(sourceFile))
+ CryptUtil(
+ AppConfig.getInstance(),
+ HybridFileParcelable(sourceFile.absolutePath),
+ ProgressHandler(),
+ ArrayList(),
+ "test.bin${CryptUtil.CRYPT_EXTENSION}",
+ false,
+ null,
+ )
+ val targetFile =
+ File(
+ Environment.getExternalStorageDirectory(),
+ "test.bin${CryptUtil.CRYPT_EXTENSION}",
+ )
+ assertTrue(targetFile.exists())
+ if (SDK_INT < JELLY_BEAN_MR2) {
+ // Quirks for SDK < 18. File is not encrypted at all.
+ assertTrue(
+ "Source and target file size should be the same = ${source.size}",
+ source.size.toLong() == targetFile.length(),
+ )
+ } else {
+ assertTrue(
+ "Source size = ${source.size} target file size = ${targetFile.length()}",
+ targetFile.length() > source.size,
+ )
+ }
+ sourceFile.delete()
+ CryptUtil(
+ AppConfig.getInstance(),
+ HybridFileParcelable(targetFile.absolutePath).also {
+ it.setSize(targetFile.length())
+ },
+ Environment.getExternalStorageDirectory().absolutePath,
+ ProgressHandler(),
+ ArrayList(),
+ null,
+ )
+ File(Environment.getExternalStorageDirectory(), "test.bin").run {
+ assertTrue(this.exists())
+ assertArrayEquals(source, this.readBytes())
+ }
+ }
+
+ /**
+ * Test encrypt and decrypt routine with AESCrypt format.
+ */
+ @Test
+ fun testEncryptDecryptAescrypt() {
+ val source = Random(System.currentTimeMillis()).nextBytes(117)
+ val sourceFile = File(Environment.getExternalStorageDirectory(), "test.bin")
+ ByteArrayInputStream(source).copyTo(FileOutputStream(sourceFile))
+ CryptUtil(
+ AppConfig.getInstance(),
+ HybridFileParcelable(sourceFile.absolutePath),
+ ProgressHandler(),
+ ArrayList(),
+ "test.bin${CryptUtil.AESCRYPT_EXTENSION}",
+ true,
+ "12345678",
+ )
+ val targetFile =
+ File(
+ Environment.getExternalStorageDirectory(),
+ "test.bin${CryptUtil.AESCRYPT_EXTENSION}",
+ )
+ assertTrue(targetFile.exists())
+ assertTrue(
+ "Source size = ${source.size} target file size = ${targetFile.length()}",
+ targetFile.length() > source.size,
+ )
+ sourceFile.delete()
+ CryptUtil(
+ AppConfig.getInstance(),
+ HybridFileParcelable(targetFile.absolutePath).also {
+ it.setSize(targetFile.length())
+ },
+ Environment.getExternalStorageDirectory().absolutePath,
+ ProgressHandler(),
+ ArrayList(),
+ "12345678",
+ )
+ File(Environment.getExternalStorageDirectory(), "test.bin").run {
+ assertTrue(this.exists())
+ assertArrayEquals(source, this.readBytes())
+ }
+ }
+}
diff --git a/app/src/androidTest/java/com/amaze/filemanager/utils/security/SecretKeygenEspressoTest.kt b/app/src/androidTest/java/com/amaze/filemanager/utils/security/SecretKeygenEspressoTest.kt
new file mode 100644
index 0000000..507bd8f
--- /dev/null
+++ b/app/src/androidTest/java/com/amaze/filemanager/utils/security/SecretKeygenEspressoTest.kt
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2014-2022 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.utils.security
+
+import android.os.Build.VERSION.SDK_INT
+import android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.SmallTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.fail
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Test [SecretKeygen] runs on real device. Necessary since Robolectric doesn't have shadows for
+ * AndroidKeyStore.
+ */
+@SmallTest
+@RunWith(AndroidJUnit4::class)
+class SecretKeygenEspressoTest {
+ /**
+ * Test [SecretKeygen.getSecretKey].
+ *
+ * Officially our lowest supported SDK is 14, hence we will throw exception
+ * if the device is so.
+ */
+ @Test
+ fun testGetSecretKey() {
+ SecretKeygen.getSecretKey()?.run {
+ assertNotNull(this)
+ assertEquals("aes", this.algorithm.lowercase())
+ } ?: if (SDK_INT < ICE_CREAM_SANDWICH) {
+ fail("Android version not supported")
+ } else {
+ // Do nothing but let it pass
+ }
+ }
+}
diff --git a/app/src/androidTest/resources/amaze_backup.json b/app/src/androidTest/resources/amaze_backup.json
new file mode 100644
index 0000000..b3b3ddc
--- /dev/null
+++ b/app/src/androidTest/resources/amaze_backup.json
@@ -0,0 +1,33 @@
+{
+ "": 1,
+ "showThumbs": true,
+ "showHidden": true,
+ "documents": true,
+ "image/jpeg_LAST": "com.oppo.gallery3d.app.ViewGallery com.coloros.gallery3d",
+ "video": true,
+ "typeablepaths": false,
+ "showPermissions": false,
+ "texteditor_newstack": false,
+ "legacyListing": false,
+ "sidebar_quickaccess_enable": false,
+ "fastaccess": true,
+ "books_added": true,
+ "application/pdf_LAST": "com.google.android.apps.viewer.PdfViewerActivity com.google.android.apps.docs",
+ "showLastModified": true,
+ "acra.legacyAlreadyConvertedTo4.8.0": true,
+ "audio/mpeg_LAST": "phone.vishnu.dialogmusicplayer.MainActivity phone.vishnu.dialogmusicplayer",
+ "acra.legacyAlreadyConvertedToJson": true,
+ "showFileSize": true,
+ "sidebar_bookmarks_enable": false,
+ "audio": true,
+ "needtosethome": false,
+ "rootmode": false,
+ "recent": true,
+ "image": true,
+ "savepaths": false,
+ "delete_confirmation": true,
+ "apks": true,
+ "audio/mpeg_DEFAULT": "phone.vishnu.dialogmusicplayer.MainActivity phone.vishnu.dialogmusicplayer",
+ "acra.lastVersionNr": 117,
+ "goBack_checkbox": false
+}
\ No newline at end of file
diff --git a/app/src/debug/res/values/strings.xml b/app/src/debug/res/values/strings.xml
new file mode 100644
index 0000000..c8aa7c6
--- /dev/null
+++ b/app/src/debug/res/values/strings.xml
@@ -0,0 +1,4 @@
+
+
+ Amaze Debug
+
diff --git a/app/src/debug/res/xml-v25/shortcuts.xml b/app/src/debug/res/xml-v25/shortcuts.xml
new file mode 100644
index 0000000..4e990dd
--- /dev/null
+++ b/app/src/debug/res/xml-v25/shortcuts.xml
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/fdroid/java/com/amaze/filemanager/asynchronous/asynctasks/CloudLoaderAsyncTask.java b/app/src/fdroid/java/com/amaze/filemanager/asynchronous/asynctasks/CloudLoaderAsyncTask.java
new file mode 100644
index 0000000..e176ef4
--- /dev/null
+++ b/app/src/fdroid/java/com/amaze/filemanager/asynchronous/asynctasks/CloudLoaderAsyncTask.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.asynchronous.asynctasks;
+
+import java.lang.ref.WeakReference;
+
+import com.amaze.filemanager.database.CloudHandler;
+import com.amaze.filemanager.ui.activities.MainActivity;
+
+import android.database.Cursor;
+import android.os.AsyncTask;
+
+import androidx.annotation.NonNull;
+
+public class CloudLoaderAsyncTask extends AsyncTask {
+
+ private final WeakReference mainActivity;
+
+ public CloudLoaderAsyncTask(MainActivity mainActivity, CloudHandler unused1, Cursor unused2) {
+ this.mainActivity = new WeakReference<>(mainActivity);
+ }
+
+ @Override
+ @NonNull
+ public Boolean doInBackground(Void... voids) {
+ return false;
+ }
+
+ @Override
+ protected void onCancelled() {
+ super.onCancelled();
+ final MainActivity mainActivity = this.mainActivity.get();
+ if (mainActivity != null) {
+ mainActivity
+ .getSupportLoaderManager()
+ .destroyLoader(MainActivity.REQUEST_CODE_CLOUD_LIST_KEY);
+ mainActivity
+ .getSupportLoaderManager()
+ .destroyLoader(MainActivity.REQUEST_CODE_CLOUD_LIST_KEYS);
+ }
+ }
+
+ @Override
+ public void onPostExecute(@NonNull Boolean result) {
+ if (result) {
+ final MainActivity mainActivity = this.mainActivity.get();
+ if (mainActivity != null) {
+ mainActivity.getDrawer().refreshDrawer();
+ mainActivity.invalidateFragmentAndBundle(null, true);
+ }
+ }
+ }
+}
diff --git a/app/src/fdroid/java/com/amaze/filemanager/filesystem/compressed/extractcontents/helpers/RarExtractor.kt b/app/src/fdroid/java/com/amaze/filemanager/filesystem/compressed/extractcontents/helpers/RarExtractor.kt
new file mode 100644
index 0000000..c01fa18
--- /dev/null
+++ b/app/src/fdroid/java/com/amaze/filemanager/filesystem/compressed/extractcontents/helpers/RarExtractor.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2014-2021 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.filesystem.compressed.extractcontents.helpers
+
+import android.content.Context
+import com.amaze.filemanager.fileoperations.utils.UpdatePosition
+import com.amaze.filemanager.filesystem.compressed.extractcontents.Extractor
+
+class RarExtractor(
+ context: Context,
+ filePath: String,
+ outputPath: String,
+ listener: OnUpdate,
+ updatePosition: UpdatePosition,
+) : Extractor(context, filePath, outputPath, listener, updatePosition) {
+ override fun extractWithFilter(filter: Filter) {
+ // no-op
+ }
+}
diff --git a/app/src/fdroid/java/com/amaze/filemanager/filesystem/compressed/showcontents/helpers/RarDecompressor.kt b/app/src/fdroid/java/com/amaze/filemanager/filesystem/compressed/showcontents/helpers/RarDecompressor.kt
new file mode 100644
index 0000000..e28f965
--- /dev/null
+++ b/app/src/fdroid/java/com/amaze/filemanager/filesystem/compressed/showcontents/helpers/RarDecompressor.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014-2021 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.filesystem.compressed.showcontents.helpers
+
+import android.content.Context
+import com.amaze.filemanager.asynchronous.asynctasks.compress.UnknownCompressedFileHelperCallable
+import com.amaze.filemanager.filesystem.compressed.showcontents.Decompressor
+
+class RarDecompressor(context: Context) : Decompressor(context) {
+ override fun changePath(
+ path: String,
+ addGoBackItem: Boolean,
+ ) = UnknownCompressedFileHelperCallable(filePath, addGoBackItem)
+
+ override fun realRelativeDirectory(dir: String): String {
+ return ""
+ }
+}
diff --git a/app/src/fdroid/java/com/amaze/filemanager/utils/Billing.java b/app/src/fdroid/java/com/amaze/filemanager/utils/Billing.java
new file mode 100644
index 0000000..0093eef
--- /dev/null
+++ b/app/src/fdroid/java/com/amaze/filemanager/utils/Billing.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.utils;
+
+import com.amaze.filemanager.ui.activities.superclasses.BasicActivity;
+
+public class Billing {
+
+ private static final String URL_AUTHOR_2_PAYPAL = "https://www.paypal.me/vishalnehra";
+
+ public Billing(BasicActivity activity) {
+ Utils.openURL(URL_AUTHOR_2_PAYPAL, activity);
+ }
+
+ public void destroyBillingInstance() {
+ // do nothing
+ }
+}
diff --git a/app/src/fdroid/java/com/amaze/filemanager/utils/PackageInstallValidation.kt b/app/src/fdroid/java/com/amaze/filemanager/utils/PackageInstallValidation.kt
new file mode 100644
index 0000000..a45e25f
--- /dev/null
+++ b/app/src/fdroid/java/com/amaze/filemanager/utils/PackageInstallValidation.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2014-2022 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.utils
+
+import java.io.File
+
+/**
+ * For non Google Play variant, this class does nothing. Just a stub.
+ */
+object PackageInstallValidation {
+ /**
+ * Do nothing.
+ */
+ @JvmStatic
+ @Throws(PackageCannotBeInstalledException::class, IllegalStateException::class)
+ fun validatePackageInstallability(f: File) = Unit
+
+ /**
+ * Exception indicating specified package cannot be installed
+ */
+ class PackageCannotBeInstalledException : Exception {
+ constructor(reason: Throwable) : super(reason)
+ constructor(reason: String) : super(reason)
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/CloudRail.java b/app/src/fdroid/java/com/cloudrail/si/CloudRail.java
new file mode 100644
index 0000000..4deb918
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/CloudRail.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si;
+
+import android.content.Intent;
+
+public class CloudRail {
+ public static void setAuthenticationResponse(Intent i) {}
+
+ public static void setAppKey(String id) {}
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/interfaces/CloudStorage.java b/app/src/fdroid/java/com/cloudrail/si/interfaces/CloudStorage.java
new file mode 100644
index 0000000..853aacb
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/interfaces/CloudStorage.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.interfaces;
+
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
+
+import com.cloudrail.si.types.CloudMetaData;
+import com.cloudrail.si.types.SpaceAllocation;
+
+public class CloudStorage {
+
+ public List getChildren(String str) {
+ return Collections.emptyList();
+ }
+
+ public void logout() {}
+
+ public void delete(String path) {}
+
+ public void move(String path1, String path2) {}
+
+ public void copy(String path1, String path2) {}
+
+ public boolean exists(String path) {
+ return false;
+ }
+
+ public void loadAsString(String str) {}
+
+ public SpaceAllocation getAllocation() {
+ return new SpaceAllocation();
+ }
+
+ public void login() {}
+
+ public String saveAsString() {
+ return "";
+ }
+
+ public String getUserLogin() {
+ return "";
+ }
+
+ public void useAdvancedAuthentication() {}
+
+ public void createFolder(String extSyncFolder) {}
+
+ public InputStream download(String path) {
+ return null;
+ }
+
+ public InputStream getThumbnail(String path) {
+ return null;
+ }
+
+ public void upload(String extSyncFile, InputStream outStream, long length, boolean b) {}
+
+ public CloudMetaData getMetadata(String str) {
+ return null;
+ }
+
+ public String createShareLink(String str) {
+ return "";
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/services/Box.java b/app/src/fdroid/java/com/cloudrail/si/services/Box.java
new file mode 100644
index 0000000..e103144
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/services/Box.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.services;
+
+import com.cloudrail.si.interfaces.CloudStorage;
+
+import android.content.Context;
+
+public class Box extends CloudStorage {
+ public Box(Context unused1, String unused2, String unused3) {
+ super();
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/services/Dropbox.java b/app/src/fdroid/java/com/cloudrail/si/services/Dropbox.java
new file mode 100644
index 0000000..76d55c7
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/services/Dropbox.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.services;
+
+import com.cloudrail.si.interfaces.CloudStorage;
+
+import android.content.Context;
+
+public class Dropbox extends CloudStorage {
+
+ public Dropbox(Context unused1, String unused2, String unused3, String unused4, String unused5) {
+ super();
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/services/GoogleDrive.java b/app/src/fdroid/java/com/cloudrail/si/services/GoogleDrive.java
new file mode 100644
index 0000000..2af7867
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/services/GoogleDrive.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.services;
+
+import com.cloudrail.si.interfaces.CloudStorage;
+
+import android.content.Context;
+
+public class GoogleDrive extends CloudStorage {
+ public GoogleDrive(
+ Context unused1, String unused2, String unused3, String unused4, String unused5) {
+ super();
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/services/OneDrive.java b/app/src/fdroid/java/com/cloudrail/si/services/OneDrive.java
new file mode 100644
index 0000000..b94d8e8
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/services/OneDrive.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.services;
+
+import com.cloudrail.si.interfaces.CloudStorage;
+
+import android.content.Context;
+
+public class OneDrive extends CloudStorage {
+ public OneDrive(Context unused1, String unused2, String unused3, String unused4, String unused5) {
+ super();
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/types/CloudMetaData.java b/app/src/fdroid/java/com/cloudrail/si/types/CloudMetaData.java
new file mode 100644
index 0000000..4fa5b4e
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/types/CloudMetaData.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.types;
+
+public class CloudMetaData {
+ public String getPath() {
+ return "";
+ }
+
+ public String getName() {
+ return "";
+ }
+
+ public Long getModifiedAt() {
+ return 0L;
+ }
+
+ public long getSize() {
+ return 0;
+ }
+
+ public boolean getFolder() {
+ return false;
+ }
+
+ public String getImageMetaData() {
+ return "";
+ }
+}
diff --git a/app/src/fdroid/java/com/cloudrail/si/types/SpaceAllocation.java b/app/src/fdroid/java/com/cloudrail/si/types/SpaceAllocation.java
new file mode 100644
index 0000000..54e3b78
--- /dev/null
+++ b/app/src/fdroid/java/com/cloudrail/si/types/SpaceAllocation.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.cloudrail.si.types;
+
+public class SpaceAllocation {
+ public long getUsed() {
+ return 0;
+ }
+
+ public long getTotal() {
+ return 0;
+ }
+}
diff --git a/app/src/fdroid/java/com/github/junrar/exception/UnsupportedRarV5Exception.java b/app/src/fdroid/java/com/github/junrar/exception/UnsupportedRarV5Exception.java
new file mode 100644
index 0000000..4ed70a9
--- /dev/null
+++ b/app/src/fdroid/java/com/github/junrar/exception/UnsupportedRarV5Exception.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.github.junrar.exception;
+
+public class UnsupportedRarV5Exception extends Exception {
+ public UnsupportedRarV5Exception(Throwable cause) {
+ super(cause);
+ }
+
+ public UnsupportedRarV5Exception() {}
+}
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..4735783
--- /dev/null
+++ b/app/src/main/AndroidManifest.xml
@@ -0,0 +1,329 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/app/src/main/assets/logback.xml b/app/src/main/assets/logback.xml
new file mode 100644
index 0000000..7f3cd78
--- /dev/null
+++ b/app/src/main/assets/logback.xml
@@ -0,0 +1,32 @@
+
+
+
+
+
+ /data/data/${PACKAGE_NAME}/cache/logs.txt
+
+ %d{HH:mm:ss.SSS} [%thread] %-5level %logger{35} - %msg%n
+
+
+
+
+
+
+
+ %logger{12}
+
+
+ [%-20thread] %msg
+
+
+
+
+
+
+
+
+
diff --git a/app/src/main/java/com/amaze/filemanager/AmazeFileManagerModule.java b/app/src/main/java/com/amaze/filemanager/AmazeFileManagerModule.java
new file mode 100644
index 0000000..1250db1
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/AmazeFileManagerModule.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager;
+
+import com.amaze.filemanager.adapters.glide.apkimage.ApkImageModelLoaderFactory;
+import com.amaze.filemanager.adapters.glide.cloudicon.CloudIconModelFactory;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.module.AppGlideModule;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+
+/** Ensures that Glide's generated API is created for the Gallery sample. */
+@GlideModule
+public class AmazeFileManagerModule extends AppGlideModule {
+ @Override
+ public void registerComponents(Context context, Glide glide, Registry registry) {
+ registry.prepend(String.class, Drawable.class, new ApkImageModelLoaderFactory(context));
+ registry.prepend(String.class, Bitmap.class, new CloudIconModelFactory(context));
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/LogHelper.java b/app/src/main/java/com/amaze/filemanager/LogHelper.java
new file mode 100644
index 0000000..38df523
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/LogHelper.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class LogHelper {
+ private static final Logger LOG = LoggerFactory.getLogger(LogHelper.class);
+
+ private LogHelper() {}
+
+ public static final void logOnProductionOrCrash(String message) {
+ if (BuildConfig.DEBUG) {
+ throw new IllegalStateException(message);
+ } else {
+ LOG.error(message);
+ }
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/TagsHelper.java b/app/src/main/java/com/amaze/filemanager/TagsHelper.java
new file mode 100644
index 0000000..30d9b9e
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/TagsHelper.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager;
+
+public final class TagsHelper {
+ private TagsHelper() {}
+
+ public static String getTag(Class clazz) {
+ String className = clazz.getSimpleName();
+ return className.substring(0, Math.min(23, className.length()));
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/AppsRecyclerAdapter.kt b/app/src/main/java/com/amaze/filemanager/adapters/AppsRecyclerAdapter.kt
new file mode 100644
index 0000000..d3bf5ae
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/AppsRecyclerAdapter.kt
@@ -0,0 +1,561 @@
+/*
+ * Copyright (C) 2014-2021 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.graphics.Color
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.Settings
+import android.text.TextUtils
+import android.util.SparseBooleanArray
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.PopupMenu
+import android.widget.Toast
+import androidx.annotation.IntDef
+import androidx.appcompat.view.ContextThemeWrapper
+import androidx.fragment.app.Fragment
+import androidx.recyclerview.widget.RecyclerView
+import com.afollestad.materialdialogs.DialogAction
+import com.afollestad.materialdialogs.MaterialDialog
+import com.amaze.filemanager.R
+import com.amaze.filemanager.adapters.data.AppDataParcelable
+import com.amaze.filemanager.adapters.glide.AppsAdapterPreloadModel
+import com.amaze.filemanager.adapters.holders.AppHolder
+import com.amaze.filemanager.adapters.holders.EmptyViewHolder
+import com.amaze.filemanager.adapters.holders.SpecialViewHolder
+import com.amaze.filemanager.asynchronous.asynctasks.DeleteTask
+import com.amaze.filemanager.asynchronous.management.ServiceWatcherUtil
+import com.amaze.filemanager.asynchronous.services.CopyService
+import com.amaze.filemanager.fileoperations.filesystem.OpenMode
+import com.amaze.filemanager.filesystem.HybridFileParcelable
+import com.amaze.filemanager.filesystem.RootHelper
+import com.amaze.filemanager.filesystem.files.FileUtils
+import com.amaze.filemanager.ui.activities.MainActivity
+import com.amaze.filemanager.ui.activities.superclasses.PreferenceActivity
+import com.amaze.filemanager.ui.activities.superclasses.ThemedActivity
+import com.amaze.filemanager.ui.dialogs.OpenFileDialogFragment.Companion.buildIntent
+import com.amaze.filemanager.ui.dialogs.OpenFileDialogFragment.Companion.setLastOpenedApp
+import com.amaze.filemanager.ui.fragments.AdjustListViewForTv
+import com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants
+import com.amaze.filemanager.ui.startActivityCatchingSecurityException
+import com.amaze.filemanager.ui.theme.AppTheme
+import com.amaze.filemanager.utils.AnimUtils.marqueeAfterDelay
+import com.amaze.filemanager.utils.Utils
+import com.amaze.filemanager.utils.safeLet
+import java.io.File
+import kotlin.math.roundToInt
+
+class AppsRecyclerAdapter(
+ private val fragment: Fragment,
+ private val modelProvider: AppsAdapterPreloadModel,
+ private val isBottomSheet: Boolean,
+ private val adjustListViewCallback: AdjustListViewForTv,
+ private val appDataParcelableList: MutableList,
+) : RecyclerView.Adapter() {
+ private val myChecked = SparseBooleanArray()
+ private var appDataListItem: MutableList = mutableListOf()
+ set(value) {
+ value.clear()
+ val headerFlags = BooleanArray(2)
+ appDataParcelableList.forEach {
+ if (!isBottomSheet && it.isSystemApp && !headerFlags[0]) {
+ value.add(ListItem(TYPE_HEADER_SYSTEM))
+ modelProvider.addItem("")
+ headerFlags[0] = true
+ } else if (!isBottomSheet && !it.isSystemApp && !headerFlags[1]) {
+ value.add(ListItem(TYPE_HEADER_THIRD_PARTY))
+ modelProvider.addItem("")
+ headerFlags[1] = true
+ }
+ modelProvider.addItem(it.path)
+ value.add(ListItem(it))
+ }
+ if (!isBottomSheet) {
+ modelProvider.addItem("")
+ value.add(ListItem(EMPTY_LAST_ITEM))
+ }
+ field = value
+ }
+
+ init {
+ appDataListItem = mutableListOf()
+ }
+
+ private val mInflater: LayoutInflater get() =
+ fragment.requireActivity()
+ .getSystemService(Activity.LAYOUT_INFLATER_SERVICE) as LayoutInflater
+
+ companion object {
+ const val TYPE_ITEM = 0
+ const val TYPE_HEADER_SYSTEM = 1
+ const val TYPE_HEADER_THIRD_PARTY = 2
+ const val EMPTY_LAST_ITEM = 3
+ }
+
+ override fun onCreateViewHolder(
+ parent: ViewGroup,
+ viewType: Int,
+ ): RecyclerView.ViewHolder {
+ var view = View(fragment.requireContext())
+ when (viewType) {
+ TYPE_ITEM -> {
+ view = mInflater.inflate(R.layout.rowlayout, parent, false)
+ return AppHolder(view)
+ }
+ TYPE_HEADER_SYSTEM, TYPE_HEADER_THIRD_PARTY -> {
+ view = mInflater.inflate(R.layout.list_header, parent, false)
+ return SpecialViewHolder(
+ fragment.requireContext(),
+ view,
+ (fragment.requireActivity() as MainActivity).utilsProvider,
+ if (viewType == TYPE_HEADER_SYSTEM) {
+ SpecialViewHolder.HEADER_SYSTEM_APP
+ } else {
+ SpecialViewHolder.HEADER_USER_APP
+ },
+ )
+ }
+ EMPTY_LAST_ITEM -> {
+ view.minimumHeight =
+ (
+ fragment.requireActivity().resources.getDimension(R.dimen.fab_height) +
+ fragment.requireContext().resources
+ .getDimension(R.dimen.fab_margin)
+ ).roundToInt()
+ return EmptyViewHolder(view)
+ }
+ else -> {
+ throw IllegalStateException("Illegal $viewType in apps adapter")
+ }
+ }
+ }
+
+ override fun getItemViewType(position: Int): Int {
+ return appDataListItem[position].listItemType
+ }
+
+ override fun onBindViewHolder(
+ holder: RecyclerView.ViewHolder,
+ position: Int,
+ ) {
+ if (holder is AppHolder) {
+ appDataListItem[position].appDataParcelable?.let { rowItem ->
+ if (isBottomSheet) {
+ holder.about.visibility = View.GONE
+ holder.txtDesc.text = rowItem.openFileParcelable?.className
+ holder.txtDesc.isSingleLine = true
+ holder.txtDesc.ellipsize = TextUtils.TruncateAt.MIDDLE
+ modelProvider.loadApkImage(rowItem.packageName, holder.apkIcon)
+ } else {
+ modelProvider.loadApkImage(rowItem.path, holder.apkIcon)
+ }
+ if (holder.about != null && !isBottomSheet) {
+ if ((fragment.requireActivity() as MainActivity).appTheme == AppTheme.LIGHT) {
+ holder.about.setColorFilter(
+ Color.parseColor("#ff666666"),
+ )
+ }
+ showPopup(holder.about, rowItem)
+ }
+ holder.rl.setOnFocusChangeListener { _, _ ->
+ adjustListViewCallback.adjustListViewForTv(
+ holder,
+ fragment.requireActivity() as MainActivity,
+ )
+ }
+ holder.txtTitle.text = rowItem.label
+ holder.packageName.text = rowItem.packageName
+ holder.packageName.isSelected = true // for marquee
+ val enableMarqueeFilename =
+ (fragment.requireActivity() as MainActivity)
+ .getBoolean(PreferencesConstants.PREFERENCE_ENABLE_MARQUEE_FILENAME)
+ if (enableMarqueeFilename) {
+ holder.txtTitle.ellipsize =
+ if (enableMarqueeFilename) {
+ TextUtils.TruncateAt.MARQUEE
+ } else {
+ TextUtils.TruncateAt.MIDDLE
+ }
+ marqueeAfterDelay(2000, holder.txtTitle)
+ }
+ if (!isBottomSheet) {
+ holder.txtDesc.text = rowItem.fileSize + " |"
+ }
+ holder.rl.isClickable = true
+ holder.rl.nextFocusRightId = holder.about.id
+ holder.rl.setOnClickListener {
+ startActivityForRowItem(rowItem)
+ }
+ }
+ if (myChecked[position]) {
+ holder.rl.setBackgroundColor(
+ Utils.getColor(fragment.context, R.color.appsadapter_background),
+ )
+ } else {
+ if ((fragment.requireActivity() as MainActivity).appTheme == AppTheme.LIGHT) {
+ holder.rl.setBackgroundResource(R.drawable.safr_ripple_white)
+ } else {
+ holder.rl.setBackgroundResource(R.drawable.safr_ripple_black)
+ }
+ }
+ }
+ }
+
+ override fun getItemCount(): Int {
+ return appDataListItem.size
+ }
+
+ /**
+ * Set list elements
+ * @param showSystemApps whether to filter system apps or not
+ */
+ fun setData(
+ data: List,
+ showSystemApps: Boolean,
+ ) {
+ appDataParcelableList.run {
+ clear()
+ val list = if (!showSystemApps) data.filter { !it.isSystemApp } else data
+ addAll(list)
+ appDataListItem = mutableListOf()
+ notifyDataSetChanged()
+ }
+ }
+
+ private fun startActivityForRowItem(rowItem: AppDataParcelable?) {
+ rowItem?.run {
+ if (isBottomSheet) {
+ val openFileParcelable = rowItem.openFileParcelable
+ openFileParcelable?.let {
+ safeLet(
+ openFileParcelable.uri,
+ openFileParcelable.mimeType,
+ openFileParcelable.useNewStack,
+ ) {
+ uri, mimeType, useNewStack ->
+ val intent =
+ buildIntent(
+ fragment.requireContext(),
+ uri,
+ mimeType,
+ useNewStack,
+ openFileParcelable.className,
+ openFileParcelable.packageName,
+ )
+ setLastOpenedApp(
+ rowItem,
+ fragment.requireActivity() as PreferenceActivity,
+ )
+ fragment.requireContext().startActivityCatchingSecurityException(intent)
+ }
+ }
+ } else {
+ val i1 =
+ fragment.requireContext().packageManager.getLaunchIntentForPackage(
+ rowItem.packageName,
+ )
+ if (i1 != null) {
+ fragment.startActivity(i1)
+ } else {
+ Toast.makeText(
+ fragment.context,
+ fragment.getString(R.string.not_allowed),
+ Toast.LENGTH_LONG,
+ )
+ .show()
+ // TODO: Implement this method
+ }
+ }
+ }
+ }
+
+ private fun showPopup(
+ v: View,
+ rowItem: AppDataParcelable?,
+ ) {
+ v.setOnClickListener { view: View? ->
+ var context = fragment.context
+ if ((
+ fragment.requireActivity()
+ as MainActivity
+ ).appTheme == AppTheme.BLACK
+ ) {
+ context = ContextThemeWrapper(context, R.style.overflow_black)
+ }
+ val popupMenu = PopupMenu(context, view)
+ popupMenu.setOnMenuItemClickListener { item: MenuItem ->
+ val themedActivity: MainActivity = fragment.requireActivity() as MainActivity
+ val colorAccent = themedActivity.accent
+ when (item.itemId) {
+ R.id.open -> {
+ rowItem?.let {
+ popupOpen(it)
+ }
+ return@setOnMenuItemClickListener true
+ }
+ R.id.share -> {
+ rowItem?.let {
+ popupShare(it, themedActivity, colorAccent)
+ }
+ return@setOnMenuItemClickListener true
+ }
+ R.id.unins -> {
+ rowItem?.let {
+ popupUninstall(it, themedActivity, colorAccent)
+ }
+ return@setOnMenuItemClickListener true
+ }
+ R.id.play -> {
+ rowItem?.let {
+ popupPlay(it)
+ }
+ return@setOnMenuItemClickListener true
+ }
+ R.id.properties -> {
+ fragment.startActivity(
+ Intent(
+ Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+ Uri.parse(
+ String.format("package:%s", rowItem!!.packageName),
+ ),
+ ),
+ )
+ return@setOnMenuItemClickListener true
+ }
+ R.id.backup -> {
+ rowItem?.let {
+ popupBackup(it)
+ }
+ return@setOnMenuItemClickListener true
+ }
+ }
+ false
+ }
+ popupMenu.inflate(R.menu.app_options)
+ popupMenu.show()
+ }
+ }
+
+ private fun popupOpen(appDataParcelable: AppDataParcelable) {
+ val i1 =
+ fragment
+ .context
+ ?.packageManager
+ ?.getLaunchIntentForPackage(appDataParcelable.packageName)
+ if (i1 != null) {
+ fragment.startActivity(i1)
+ } else {
+ Toast.makeText(
+ fragment.context,
+ fragment.getString(R.string.not_allowed),
+ Toast.LENGTH_LONG,
+ ).show()
+ }
+ }
+
+ private fun popupShare(
+ appDataParcelable: AppDataParcelable,
+ themedActivity: ThemedActivity,
+ colorAccent: Int,
+ ) {
+ val arrayList2 =
+ ArrayList()
+ arrayList2.add(File(appDataParcelable.path))
+ themedActivity.colorPreference
+ FileUtils.shareFiles(
+ arrayList2,
+ fragment.activity,
+ themedActivity.utilsProvider.appTheme,
+ colorAccent,
+ )
+ }
+
+ private fun popupUninstall(
+ appDataParcelable: AppDataParcelable,
+ themedActivity: ThemedActivity,
+ colorAccent: Int,
+ ) {
+ val f1 = HybridFileParcelable(appDataParcelable.path)
+ f1.mode = OpenMode.ROOT
+ if (appDataParcelable.isSystemApp) {
+ // system package
+ if ((fragment.requireActivity() as MainActivity).getBoolean(
+ PreferencesConstants.PREFERENCE_ROOTMODE,
+ )
+ ) {
+ showDeleteSystemAppDialog(themedActivity, colorAccent, f1)
+ } else {
+ Toast.makeText(
+ fragment.context,
+ fragment.getString(R.string.enablerootmde),
+ Toast.LENGTH_SHORT,
+ )
+ .show()
+ }
+ } else {
+ FileUtils.uninstallPackage(
+ appDataParcelable.packageName,
+ fragment.context,
+ )
+ }
+ }
+
+ private fun popupPlay(appDataParcelable: AppDataParcelable) {
+ val intent1 =
+ Intent(Intent.ACTION_VIEW)
+ try {
+ intent1.data =
+ Uri.parse(
+ String.format(
+ "market://details?id=%s",
+ appDataParcelable.packageName,
+ ),
+ )
+ fragment.startActivity(intent1)
+ } catch (ifPlayStoreNotInstalled: ActivityNotFoundException) {
+ intent1.data =
+ Uri.parse(
+ String.format(
+ "https://play.google.com/store/apps/details?id=%s",
+ appDataParcelable.packageName,
+ ),
+ )
+ fragment.startActivity(intent1)
+ }
+ }
+
+ private fun popupBackup(appDataParcelable: AppDataParcelable) {
+ val baseApkFile = File(appDataParcelable.path)
+ val filesToCopyList = ArrayList()
+ val dst =
+ File(
+ Environment.getExternalStorageDirectory()
+ .path + "/app_backup",
+ )
+ if (!dst.exists() || !dst.isDirectory) dst.mkdirs()
+ val intent =
+ Intent(
+ fragment.context,
+ CopyService::class.java,
+ )
+ val mainApkFile = RootHelper.generateBaseFile(baseApkFile, true)
+ val startIndex = appDataParcelable.packageName.indexOf("_")
+ val subString = appDataParcelable.packageName.substring(startIndex + 1)
+ val fileBaseName = appDataParcelable.label + "_$subString"
+ mainApkFile.name = "$fileBaseName.apk"
+ filesToCopyList.add(mainApkFile)
+ val splitPathList = appDataParcelable.splitPathList
+ if (splitPathList != null) {
+ for (splitApkPath: String in splitPathList) {
+ val splitApkFile = File(splitApkPath)
+ val splitParcelableFile = RootHelper.generateBaseFile(splitApkFile, true)
+ var name = splitApkFile.name.lowercase()
+ if (name.endsWith(".apk")) {
+ name = name.substring(0, name.length - 4)
+ }
+ val dotIdx = name.lastIndexOf('.')
+ name = name.substring(dotIdx + 1)
+ name = "${fileBaseName}_$name.apk"
+ splitParcelableFile.name = name
+ filesToCopyList.add(splitParcelableFile)
+ }
+ }
+ intent.putParcelableArrayListExtra(CopyService.TAG_COPY_SOURCES, filesToCopyList)
+ intent.putExtra(CopyService.TAG_COPY_TARGET, dst.path)
+ intent.putExtra(CopyService.TAG_COPY_OPEN_MODE, 0)
+
+ Toast.makeText(
+ fragment.context,
+ fragment.getString(R.string.copyingapks, filesToCopyList.size, dst.path),
+ Toast.LENGTH_LONG,
+ )
+ .show()
+
+ ServiceWatcherUtil.runService(fragment.context, intent)
+ }
+
+ private fun showDeleteSystemAppDialog(
+ themedActivity: ThemedActivity,
+ colorAccent: Int,
+ f1: HybridFileParcelable,
+ ) {
+ val builder1 =
+ MaterialDialog.Builder(fragment.requireContext())
+ builder1
+ .theme(
+ themedActivity.appTheme.getMaterialDialogTheme(),
+ )
+ .content(fragment.getString(R.string.unin_system_apk))
+ .title(fragment.getString(R.string.warning))
+ .negativeColor(colorAccent)
+ .positiveColor(colorAccent)
+ .negativeText(fragment.getString(R.string.no))
+ .positiveText(fragment.getString(R.string.yes))
+ .onNegative { dialog: MaterialDialog, _: DialogAction? -> dialog.cancel() }
+ .onPositive { _: MaterialDialog?, _: DialogAction? ->
+ val files =
+ ArrayList()
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ val parent =
+ f1.getParent(fragment.context)
+ if (parent != "app" && parent != "priv-app") {
+ val baseFile =
+ HybridFileParcelable(
+ f1.getParent(fragment.context),
+ )
+ baseFile.mode =
+ OpenMode.ROOT
+ files.add(baseFile)
+ } else {
+ files.add(f1)
+ }
+ } else {
+ files.add(f1)
+ }
+ DeleteTask(fragment.requireContext(), false).execute(files)
+ }
+ .build()
+ .show()
+ }
+
+ @Target(AnnotationTarget.TYPE)
+ @IntDef(
+ TYPE_ITEM,
+ TYPE_HEADER_SYSTEM,
+ TYPE_HEADER_THIRD_PARTY,
+ EMPTY_LAST_ITEM,
+ )
+ annotation class ListItemType
+
+ data class ListItem(
+ var appDataParcelable: AppDataParcelable?,
+ var listItemType: @ListItemType Int = TYPE_ITEM,
+ ) {
+ constructor(listItemType: @ListItemType Int) : this(null, listItemType)
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/ColorAdapter.java b/app/src/main/java/com/amaze/filemanager/adapters/ColorAdapter.java
new file mode 100644
index 0000000..0c8c67f
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/ColorAdapter.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters;
+
+import com.amaze.filemanager.R;
+import com.amaze.filemanager.ui.views.CheckableCircleView;
+import com.amaze.filemanager.utils.Utils;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.NonNull;
+
+public class ColorAdapter extends ArrayAdapter implements AdapterView.OnItemClickListener {
+
+ private LayoutInflater inflater;
+ private @ColorInt int selectedColor;
+ private OnColorSelected onColorSelected;
+
+ /**
+ * Constructor for adapter that handles the view creation of color chooser dialog in preferences
+ *
+ * @param context the context
+ * @param colors array list of color hex values in form of string; for the views
+ * @param selectedColor currently selected color
+ * @param l OnColorSelected listener for when a color is selected
+ */
+ public ColorAdapter(
+ Context context, Integer[] colors, @ColorInt int selectedColor, OnColorSelected l) {
+ super(context, R.layout.rowlayout, colors);
+ this.selectedColor = selectedColor;
+ this.onColorSelected = l;
+
+ inflater = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ }
+
+ @ColorRes
+ private int getColorResAt(int position) {
+ return getItem(position);
+ }
+
+ @NonNull
+ @Override
+ public View getView(final int position, View convertView, @NonNull ViewGroup parent) {
+ CheckableCircleView colorView;
+ if (convertView != null && convertView instanceof CheckableCircleView) {
+ colorView = (CheckableCircleView) convertView;
+ } else {
+ colorView = (CheckableCircleView) inflater.inflate(R.layout.dialog_grid_item, parent, false);
+ }
+
+ @ColorInt int color = Utils.getColor(getContext(), getColorResAt(position));
+
+ colorView.setChecked(color == selectedColor);
+ colorView.setColor(color);
+
+ return colorView;
+ }
+
+ @Override
+ public void onItemClick(AdapterView parent, View view, int position, long id) {
+ this.selectedColor = Utils.getColor(getContext(), getColorResAt(position));
+ ((CheckableCircleView) view).setChecked(true);
+ onColorSelected.onColorSelected(this.selectedColor);
+ }
+
+ public interface OnColorSelected {
+ void onColorSelected(@ColorInt int color);
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/CompressedExplorerAdapter.java b/app/src/main/java/com/amaze/filemanager/adapters/CompressedExplorerAdapter.java
new file mode 100644
index 0000000..eab01ab
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/CompressedExplorerAdapter.java
@@ -0,0 +1,379 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.amaze.filemanager.R;
+import com.amaze.filemanager.adapters.data.CompressedObjectParcelable;
+import com.amaze.filemanager.adapters.holders.CompressedItemViewHolder;
+import com.amaze.filemanager.fileoperations.filesystem.OpenMode;
+import com.amaze.filemanager.filesystem.HybridFileParcelable;
+import com.amaze.filemanager.filesystem.compressed.CompressedHelper;
+import com.amaze.filemanager.filesystem.compressed.showcontents.Decompressor;
+import com.amaze.filemanager.ui.colors.ColorUtils;
+import com.amaze.filemanager.ui.fragments.CompressedExplorerFragment;
+import com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants;
+import com.amaze.filemanager.ui.provider.UtilitiesProvider;
+import com.amaze.filemanager.ui.theme.AppTheme;
+import com.amaze.filemanager.ui.views.CircleGradientDrawable;
+import com.amaze.filemanager.utils.AnimUtils;
+import com.amaze.filemanager.utils.Utils;
+import com.bumptech.glide.Glide;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.GradientDrawable;
+import android.os.Build;
+import android.text.TextUtils;
+import android.text.format.Formatter;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.Toast;
+
+import androidx.appcompat.widget.AppCompatImageButton;
+import androidx.appcompat.widget.AppCompatImageView;
+import androidx.recyclerview.widget.RecyclerView;
+
+/** Created by Arpit on 25-01-2015 edited by Emmanuel Messulam */
+public class CompressedExplorerAdapter extends RecyclerView.Adapter {
+
+ private static final int TYPE_HEADER = 0, TYPE_ITEM = 1;
+
+ public boolean stoppedAnimation = false;
+
+ private Context context;
+ private UtilitiesProvider utilsProvider;
+ private Drawable folder;
+ private List items;
+ private CompressedExplorerFragment compressedExplorerFragment;
+ private Decompressor decompressor;
+ private LayoutInflater mInflater;
+ private boolean[] itemsChecked;
+ private int offset = 0;
+ private SharedPreferences sharedPrefs;
+
+ public CompressedExplorerAdapter(
+ Context c,
+ UtilitiesProvider utilsProvider,
+ List items,
+ CompressedExplorerFragment compressedExplorerFragment,
+ Decompressor decompressor,
+ SharedPreferences sharedPrefs) {
+ setHasStableIds(true);
+
+ this.utilsProvider = utilsProvider;
+ this.items = items;
+ this.decompressor = decompressor;
+
+ itemsChecked = new boolean[items.size()];
+
+ context = c;
+ if (c == null) return;
+ folder = c.getResources().getDrawable(R.drawable.ic_grid_folder_new);
+ this.compressedExplorerFragment = compressedExplorerFragment;
+ mInflater = (LayoutInflater) c.getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
+ this.sharedPrefs = sharedPrefs;
+ }
+
+ public void toggleChecked(boolean check) {
+ int k = 0;
+
+ for (int i = k; i < items.size(); i++) {
+ itemsChecked[i] = check;
+ notifyItemChanged(i);
+ }
+ }
+
+ public ArrayList getCheckedItemPositions() {
+ ArrayList checkedItemPositions = new ArrayList<>();
+
+ for (int i = 0; i < itemsChecked.length; i++) {
+ if (itemsChecked[i]) {
+ (checkedItemPositions).add(i);
+ }
+ }
+
+ return checkedItemPositions;
+ }
+
+ /**
+ * called as to toggle selection of any item in adapter
+ *
+ * @param position the position of the item
+ * @param imageView the circular {@link CircleGradientDrawable} that is to be animated
+ */
+ private void toggleChecked(int position, AppCompatImageView imageView) {
+ compressedExplorerFragment.stopAnim();
+ stoppedAnimation = true;
+
+ Animation animation;
+ if (itemsChecked[position]) {
+ animation = AnimationUtils.loadAnimation(context, R.anim.check_out);
+ } else {
+ animation = AnimationUtils.loadAnimation(context, R.anim.check_in);
+ }
+
+ if (imageView != null) {
+ imageView.setAnimation(animation);
+ } else {
+ // TODO: we don't have the check icon object probably because of config change
+ }
+
+ itemsChecked[position] = !itemsChecked[position];
+
+ notifyDataSetChanged();
+ if (!compressedExplorerFragment.selection || compressedExplorerFragment.mActionMode == null) {
+ compressedExplorerFragment.selection = true;
+ /*compressedExplorerFragment.mActionMode = compressedExplorerFragment.getActivity().startActionMode(
+ compressedExplorerFragment.mActionModeCallback);*/
+ compressedExplorerFragment.mActionMode =
+ compressedExplorerFragment
+ .requireMainActivity()
+ .getAppbar()
+ .getToolbar()
+ .startActionMode(compressedExplorerFragment.mActionModeCallback);
+ }
+ compressedExplorerFragment.mActionMode.invalidate();
+ if (getCheckedItemPositions().size() == 0) {
+ compressedExplorerFragment.selection = false;
+ compressedExplorerFragment.mActionMode.finish();
+ compressedExplorerFragment.mActionMode = null;
+ }
+ }
+
+ private void animate(CompressedItemViewHolder holder) {
+ holder.rl.clearAnimation();
+ Animation localAnimation =
+ AnimationUtils.loadAnimation(compressedExplorerFragment.getActivity(), R.anim.fade_in_top);
+ localAnimation.setStartOffset(this.offset);
+ holder.rl.startAnimation(localAnimation);
+ this.offset = (30 + this.offset);
+ }
+
+ public void generateZip(List arrayList) {
+ offset = 0;
+ stoppedAnimation = false;
+ items = arrayList;
+ notifyDataSetChanged();
+ itemsChecked = new boolean[items.size()];
+ }
+
+ @Override
+ public long getItemId(int position) {
+ return position;
+ }
+
+ @Override
+ public int getItemViewType(int position) {
+ if (isPositionHeader(position)) return TYPE_HEADER;
+
+ return TYPE_ITEM;
+ }
+
+ @Override
+ public CompressedItemViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+ if (viewType == TYPE_HEADER) {
+ View v = mInflater.inflate(R.layout.rowlayout, parent, false);
+ v.findViewById(R.id.picture_icon).setVisibility(View.INVISIBLE);
+ return new CompressedItemViewHolder(v);
+ } else if (viewType == TYPE_ITEM) {
+ View v = mInflater.inflate(R.layout.rowlayout, parent, false);
+ CompressedItemViewHolder vh = new CompressedItemViewHolder(v);
+ AppCompatImageButton about = v.findViewById(R.id.properties);
+ about.setVisibility(View.INVISIBLE);
+ return vh;
+ } else {
+ throw new IllegalStateException();
+ }
+ }
+
+ @Override
+ public void onBindViewHolder(final CompressedItemViewHolder holder, int position) {
+ if (!stoppedAnimation) {
+ animate(holder);
+ }
+
+ boolean enableMarquee =
+ sharedPrefs.getBoolean(PreferencesConstants.PREFERENCE_ENABLE_MARQUEE_FILENAME, true);
+ holder.txtTitle.setEllipsize(
+ enableMarquee ? TextUtils.TruncateAt.MARQUEE : TextUtils.TruncateAt.MIDDLE);
+
+ final CompressedObjectParcelable rowItem = items.get(position);
+ GradientDrawable gradientDrawable = (GradientDrawable) holder.genericIcon.getBackground();
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+ holder.checkImageView.setBackground(
+ new CircleGradientDrawable(
+ compressedExplorerFragment.accentColor,
+ utilsProvider.getAppTheme(),
+ compressedExplorerFragment.getResources().getDisplayMetrics()));
+ } else
+ holder.checkImageView.setBackgroundDrawable(
+ new CircleGradientDrawable(
+ compressedExplorerFragment.accentColor,
+ utilsProvider.getAppTheme(),
+ compressedExplorerFragment.getResources().getDisplayMetrics()));
+
+ if (rowItem.type == CompressedObjectParcelable.TYPE_GOBACK) {
+ Glide.with(compressedExplorerFragment)
+ .load(R.drawable.ic_arrow_left_white_24dp)
+ .into(holder.genericIcon);
+ gradientDrawable.setColor(Utils.getColor(context, R.color.goback_item));
+ holder.txtTitle.setText("..");
+ holder.txtDesc.setText("");
+ holder.date.setText(R.string.goback);
+ } else {
+ Glide.with(compressedExplorerFragment).load(rowItem.iconData.image).into(holder.genericIcon);
+
+ if (compressedExplorerFragment.showLastModified)
+ holder.date.setText(Utils.getDate(context, rowItem.date));
+ if (rowItem.directory) {
+ holder.genericIcon.setImageDrawable(folder);
+ gradientDrawable.setColor(compressedExplorerFragment.iconskin);
+ holder.txtTitle.setText(rowItem.name);
+ } else {
+ if (compressedExplorerFragment.showSize)
+ holder.txtDesc.setText(Formatter.formatFileSize(context, rowItem.size));
+ holder.txtTitle.setText(rowItem.path.substring(rowItem.path.lastIndexOf("/") + 1));
+ if (compressedExplorerFragment.coloriseIcons) {
+ ColorUtils.colorizeIcons(
+ context, rowItem.filetype, gradientDrawable, compressedExplorerFragment.iconskin);
+ } else gradientDrawable.setColor(compressedExplorerFragment.iconskin);
+ }
+ }
+
+ holder.rl.setOnLongClickListener(
+ view -> {
+ if (rowItem.type != CompressedObjectParcelable.TYPE_GOBACK) {
+ toggleChecked(position, holder.checkImageView);
+ }
+ return true;
+ });
+ holder.genericIcon.setOnClickListener(
+ view -> {
+ if (rowItem.type != CompressedObjectParcelable.TYPE_GOBACK) {
+ toggleChecked(position, holder.checkImageView);
+ } else {
+ compressedExplorerFragment.goBack();
+ }
+ });
+ if (utilsProvider.getAppTheme().equals(AppTheme.LIGHT)) {
+ holder.rl.setBackgroundResource(R.drawable.safr_ripple_white);
+ } else {
+ holder.rl.setBackgroundResource(R.drawable.safr_ripple_black);
+ }
+ holder.rl.setSelected(false);
+ if (itemsChecked[position]) {
+ // holder.genericIcon.setImageDrawable(compressedExplorerFragment.getResources().getDrawable(R.drawable.abc_ic_cab_done_holo_dark));
+ holder.checkImageView.setVisibility(View.VISIBLE);
+ gradientDrawable.setColor(Utils.getColor(context, R.color.goback_item));
+ holder.rl.setSelected(true);
+ } else holder.checkImageView.setVisibility(View.INVISIBLE);
+
+ holder.rl.setOnClickListener(
+ p1 -> {
+ if (rowItem.type == CompressedObjectParcelable.TYPE_GOBACK)
+ compressedExplorerFragment.goBack();
+ else {
+ if (compressedExplorerFragment.selection) {
+ toggleChecked(position, holder.checkImageView);
+ } else {
+ if (rowItem.directory) {
+ String newPath =
+ (rowItem.path.endsWith("/"))
+ ? rowItem.path.substring(0, rowItem.path.length() - 1)
+ : rowItem.path;
+ compressedExplorerFragment.changePath(newPath);
+ } else {
+
+ String fileName =
+ CompressedHelper.getFileName(
+ compressedExplorerFragment.compressedFile.getName());
+ String archiveCacheDirPath =
+ compressedExplorerFragment.getActivity().getExternalCacheDir().getPath()
+ + CompressedHelper.SEPARATOR
+ + fileName;
+
+ HybridFileParcelable file =
+ new HybridFileParcelable(
+ archiveCacheDirPath
+ + CompressedHelper.SEPARATOR
+ + rowItem.path.replaceAll("\\\\", CompressedHelper.SEPARATOR));
+ file.setMode(OpenMode.FILE);
+ // this file will be opened once service finishes up it's extraction
+ compressedExplorerFragment.files.add(file);
+ // setting flag for binder to know
+ compressedExplorerFragment.isOpen = true;
+
+ Toast.makeText(
+ compressedExplorerFragment.getContext(),
+ compressedExplorerFragment.getContext().getString(R.string.please_wait),
+ Toast.LENGTH_SHORT)
+ .show();
+ decompressor.decompress(
+ compressedExplorerFragment.getActivity().getExternalCacheDir().getPath(),
+ new String[] {rowItem.path});
+ }
+ }
+ }
+ });
+ }
+
+ @Override
+ public int getItemCount() {
+ return items.size();
+ }
+
+ @Override
+ public void onViewDetachedFromWindow(CompressedItemViewHolder holder) {
+ super.onViewAttachedToWindow(holder);
+ holder.rl.clearAnimation();
+ holder.txtTitle.setSelected(false);
+ }
+
+ @Override
+ public void onViewAttachedToWindow(CompressedItemViewHolder holder) {
+ super.onViewAttachedToWindow(holder);
+ boolean enableMarqueeFilename =
+ sharedPrefs.getBoolean(PreferencesConstants.PREFERENCE_ENABLE_MARQUEE_FILENAME, true);
+ if (enableMarqueeFilename) {
+ AnimUtils.marqueeAfterDelay(2000, holder.txtTitle);
+ }
+ }
+
+ @Override
+ public boolean onFailedToRecycleView(CompressedItemViewHolder holder) {
+ holder.rl.clearAnimation();
+ holder.txtTitle.setSelected(false);
+ return super.onFailedToRecycleView(holder);
+ }
+
+ private boolean isPositionHeader(int position) {
+ return false; // TODO:
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/HiddenAdapter.kt b/app/src/main/java/com/amaze/filemanager/adapters/HiddenAdapter.kt
new file mode 100644
index 0000000..e0dd9db
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/HiddenAdapter.kt
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2014-2020 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters
+
+import android.app.Activity
+import android.content.Context
+import android.content.SharedPreferences
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.afollestad.materialdialogs.MaterialDialog
+import com.amaze.filemanager.R
+import com.amaze.filemanager.adapters.holders.HiddenViewHolder
+import com.amaze.filemanager.asynchronous.asynctasks.DeleteTask
+import com.amaze.filemanager.fileoperations.filesystem.OpenMode
+import com.amaze.filemanager.filesystem.HybridFile
+import com.amaze.filemanager.filesystem.HybridFileParcelable
+import com.amaze.filemanager.filesystem.files.FileUtils
+import com.amaze.filemanager.ui.activities.MainActivity
+import com.amaze.filemanager.ui.fragments.MainFragment
+import com.amaze.filemanager.utils.DataUtils
+import java.io.File
+import kotlin.concurrent.thread
+
+/**
+ * This Adapter contains all logic related to showing the list of hidden files.
+ *
+ * @see com.amaze.filemanager.adapters.holders.HiddenViewHolder
+ */
+class HiddenAdapter(
+ private val context: Context,
+ private val mainFragment: MainFragment,
+ private val sharedPrefs: SharedPreferences,
+ hiddenFiles: List,
+ var materialDialog: MaterialDialog?,
+ private val hide: Boolean,
+) : RecyclerView.Adapter() {
+ companion object {
+ private const val TAG = "HiddenAdapter"
+ }
+
+ private val hiddenFiles = hiddenFiles.toMutableList()
+
+ override fun onCreateViewHolder(
+ parent: ViewGroup,
+ viewType: Int,
+ ): HiddenViewHolder {
+ val mInflater = context.getSystemService(Activity.LAYOUT_INFLATER_SERVICE) as LayoutInflater
+ val view = mInflater.inflate(R.layout.bookmarkrow, parent, false)
+ return HiddenViewHolder(view)
+ }
+
+ override fun onBindViewHolder(
+ holder: HiddenViewHolder,
+ position: Int,
+ ) {
+ val file = hiddenFiles[position]
+ holder.textTitle.text = file.getName(context)
+ holder.textDescription.text = file.getReadablePath(file.path)
+ if (hide) {
+ holder.deleteButton.visibility = View.GONE
+ }
+ holder.deleteButton.setOnClickListener {
+ // if the user taps on the delete button, un-hide the file.
+ // TODO: the "hide files" feature just hide files from view in Amaze and not create
+ // .nomedia
+ if (!file.isSmb && file.isDirectory(context)) {
+ val nomediaFile =
+ HybridFileParcelable(
+ hiddenFiles[position].path + "/" + FileUtils.NOMEDIA_FILE,
+ )
+ nomediaFile.mode = OpenMode.FILE
+ val filesToDelete = ArrayList()
+ filesToDelete.add(nomediaFile)
+ val task = DeleteTask(context, false)
+ task.execute(filesToDelete)
+ }
+ DataUtils.getInstance().removeHiddenFile(hiddenFiles[position].path)
+ hiddenFiles.remove(hiddenFiles[position])
+ notifyItemRemoved(position)
+ }
+ holder.row.setOnClickListener {
+ // if the user taps on the hidden file, take the user there.
+ materialDialog?.dismiss()
+
+ thread {
+ val fragmentActivity = mainFragment.requireActivity()
+ if (file.isDirectory(context)) {
+ fragmentActivity.runOnUiThread {
+ mainFragment.hideFab = false
+ mainFragment.requireMainActivity().showFab()
+ mainFragment.loadlist(
+ file.path,
+ false,
+ OpenMode.UNKNOWN,
+ false,
+ )
+ }
+ } else if (!file.isSmb) {
+ fragmentActivity.runOnUiThread {
+ FileUtils.openFile(
+ File(file.path),
+ (fragmentActivity as MainActivity),
+ sharedPrefs,
+ )
+ }
+ }
+ }
+ }
+ }
+
+ override fun getItemId(position: Int): Long {
+ return position.toLong()
+ }
+
+ override fun getItemCount(): Int = hiddenFiles.size
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/RecyclerAdapter.java b/app/src/main/java/com/amaze/filemanager/adapters/RecyclerAdapter.java
new file mode 100644
index 0000000..ace6284
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/RecyclerAdapter.java
@@ -0,0 +1,1609 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters;
+
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtension7zip;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionApk;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionApks;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionBzip2;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionBzip2TarLong;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionBzip2TarShort;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionGz;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionGzipTarLong;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionGzipTarShort;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionJar;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionLzma;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionRar;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionTar;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionTarLzma;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionTarXz;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionXz;
+import static com.amaze.filemanager.filesystem.compressed.CompressedHelper.fileExtensionZip;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_COLORIZE_ICONS;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_SHOW_FILE_SIZE;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_SHOW_GOBACK_BUTTON;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_SHOW_HEADERS;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_SHOW_LAST_MODIFIED;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_SHOW_PERMISSIONS;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_SHOW_THUMB;
+import static com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants.PREFERENCE_USE_CIRCULAR_IMAGES;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.amaze.filemanager.R;
+import com.amaze.filemanager.adapters.data.IconDataParcelable;
+import com.amaze.filemanager.adapters.data.LayoutElementParcelable;
+import com.amaze.filemanager.adapters.glide.RecyclerPreloadModelProvider;
+import com.amaze.filemanager.adapters.glide.RecyclerPreloadSizeProvider;
+import com.amaze.filemanager.adapters.holders.EmptyViewHolder;
+import com.amaze.filemanager.adapters.holders.ItemViewHolder;
+import com.amaze.filemanager.adapters.holders.SpecialViewHolder;
+import com.amaze.filemanager.application.AppConfig;
+import com.amaze.filemanager.fileoperations.filesystem.OpenMode;
+import com.amaze.filemanager.filesystem.PasteHelper;
+import com.amaze.filemanager.filesystem.files.CryptUtil;
+import com.amaze.filemanager.filesystem.files.sort.DirSortBy;
+import com.amaze.filemanager.ui.ItemPopupMenu;
+import com.amaze.filemanager.ui.activities.MainActivity;
+import com.amaze.filemanager.ui.activities.superclasses.PreferenceActivity;
+import com.amaze.filemanager.ui.colors.ColorUtils;
+import com.amaze.filemanager.ui.drag.RecyclerAdapterDragListener;
+import com.amaze.filemanager.ui.fragments.MainFragment;
+import com.amaze.filemanager.ui.fragments.preferencefragments.PreferencesConstants;
+import com.amaze.filemanager.ui.icons.Icons;
+import com.amaze.filemanager.ui.icons.MimeTypes;
+import com.amaze.filemanager.ui.provider.UtilitiesProvider;
+import com.amaze.filemanager.ui.selection.SelectionPopupMenu;
+import com.amaze.filemanager.ui.theme.AppTheme;
+import com.amaze.filemanager.ui.views.CircleGradientDrawable;
+import com.amaze.filemanager.utils.AnimUtils;
+import com.amaze.filemanager.utils.GlideConstants;
+import com.amaze.filemanager.utils.MainActivityActionMode;
+import com.amaze.filemanager.utils.Utils;
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.integration.recyclerview.RecyclerViewPreloader;
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.target.Target;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.graphics.Color;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.GradientDrawable;
+import android.os.Build;
+import android.os.Handler;
+import android.text.TextUtils;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.PopupMenu;
+import android.widget.Toast;
+
+import androidx.annotation.IntDef;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.view.ActionMode;
+import androidx.appcompat.view.ContextThemeWrapper;
+import androidx.appcompat.widget.AppCompatImageView;
+import androidx.appcompat.widget.AppCompatTextView;
+import androidx.recyclerview.widget.RecyclerView;
+
+/**
+ * This class is the information that serves to load the files into a "list" (a RecyclerView). There
+ * are 3 types of item TYPE_ITEM, TYPE_HEADER_FOLDERS and TYPE_HEADER_FILES, EMPTY_LAST_ITEM and
+ * TYPE_BACK represeted by ItemViewHolder, SpecialViewHolder and EmptyViewHolder respectively. The
+ * showPopup shows the file's popup menu. The 'go to parent' aka '..' button (go to settings to
+ * activate it) is just a folder.
+ *
+ * Created by Arpit on 11-04-2015 edited by Emmanuel Messulam edited
+ * by Jens Klingenberg
+ */
+public class RecyclerAdapter extends RecyclerView.Adapter
+ implements RecyclerPreloadSizeProvider.RecyclerPreloadSizeProviderCallback {
+
+ public static final int TYPE_ITEM = 0,
+ TYPE_HEADER_FOLDERS = 1,
+ TYPE_HEADER_FILES = 2,
+ EMPTY_LAST_ITEM = 3,
+ TYPE_BACK = 4;
+ private final Logger LOG = LoggerFactory.getLogger(RecyclerAdapter.class);
+
+ private static final int VIEW_GENERIC = 0, VIEW_PICTURE = 1, VIEW_APK = 2, VIEW_THUMB = 3;
+
+ public boolean stoppedAnimation = false;
+
+ @NonNull private final PreferenceActivity preferenceActivity;
+ @NonNull private final UtilitiesProvider utilsProvider;
+ @NonNull private final MainFragment mainFragment;
+ @NonNull private final SharedPreferences sharedPrefs;
+ private RecyclerViewPreloader preloader;
+ private RecyclerPreloadSizeProvider sizeProvider;
+ private RecyclerPreloadModelProvider modelProvider;
+ @NonNull private final Context context;
+ private final LayoutInflater mInflater;
+ private final float minRowHeight;
+ private final int grey_color;
+ private final int accentColor;
+ private final int iconSkinColor;
+ private final int goBackColor;
+ private final int videoColor;
+ private final int audioColor;
+ private final int pdfColor;
+ private final int codeColor;
+ private final int textColor;
+ private final int archiveColor;
+ private final int genericColor;
+ private final int apkColor;
+ private int offset = 0;
+ private final boolean enableMarquee;
+ private final int dragAndDropPreference;
+ private final boolean isGrid;
+
+ @IntDef({VIEW_GENERIC, VIEW_PICTURE, VIEW_APK, VIEW_THUMB})
+ public @interface ViewType {}
+
+ @IntDef({TYPE_ITEM, TYPE_HEADER_FOLDERS, TYPE_HEADER_FILES, EMPTY_LAST_ITEM, TYPE_BACK})
+ public @interface ListElemType {}
+
+ public RecyclerAdapter(
+ @NonNull PreferenceActivity preferenceActivity,
+ @NonNull MainFragment mainFragment,
+ @NonNull UtilitiesProvider utilsProvider,
+ @NonNull SharedPreferences sharedPrefs,
+ @NonNull RecyclerView recyclerView,
+ @NonNull List itemsRaw,
+ @NonNull Context context,
+ boolean isGrid) {
+ setHasStableIds(true);
+
+ this.preferenceActivity = preferenceActivity;
+ this.mainFragment = mainFragment;
+ this.utilsProvider = utilsProvider;
+ this.context = context;
+ this.sharedPrefs = sharedPrefs;
+ this.enableMarquee =
+ sharedPrefs.getBoolean(PreferencesConstants.PREFERENCE_ENABLE_MARQUEE_FILENAME, true);
+ this.dragAndDropPreference =
+ sharedPrefs.getInt(
+ PreferencesConstants.PREFERENCE_DRAG_AND_DROP_PREFERENCE,
+ PreferencesConstants.PREFERENCE_DRAG_DEFAULT);
+ this.isGrid = isGrid;
+
+ mInflater = (LayoutInflater) context.getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
+ accentColor = mainFragment.getMainActivity().getAccent();
+ iconSkinColor = mainFragment.getMainActivity().getCurrentColorPreference().getIconSkin();
+ goBackColor = Utils.getColor(context, R.color.goback_item);
+ videoColor = Utils.getColor(context, R.color.video_item);
+ audioColor = Utils.getColor(context, R.color.audio_item);
+ pdfColor = Utils.getColor(context, R.color.pdf_item);
+ codeColor = Utils.getColor(context, R.color.code_item);
+ textColor = Utils.getColor(context, R.color.text_item);
+ archiveColor = Utils.getColor(context, R.color.archive_item);
+ genericColor = Utils.getColor(context, R.color.generic_item);
+ minRowHeight = context.getResources().getDimension(R.dimen.minimal_row_height);
+ grey_color = Utils.getColor(context, R.color.grey);
+ apkColor = Utils.getColor(context, R.color.apk_item);
+
+ setItems(recyclerView, itemsRaw, false);
+ }
+
+ /**
+ * called as to toggle selection of any item in adapter
+ *
+ * @param position the position of the item
+ * @param imageView the check {@link CircleGradientDrawable} that is to be animated
+ */
+ public void toggleChecked(int position, AppCompatImageView imageView) {
+ if (getItemsDigested().size() <= position || position < 0) {
+ AppConfig.toast(context, R.string.operation_not_supported);
+ return;
+ }
+
+ if (getItemsDigested().get(position).getChecked() == ListItem.UNCHECKABLE) {
+ throw new IllegalArgumentException("You have checked a header");
+ }
+
+ if (!stoppedAnimation) {
+ mainFragment.stopAnimation();
+ }
+
+ if (getItemsDigested().get(position).getChecked() == ListItem.CHECKED) {
+ // if the view at position is checked, un-check it
+ LOG.debug("the view at position {} is checked, un-check it", position);
+ getItemsDigested().get(position).setChecked(false);
+
+ Animation iconAnimation = AnimationUtils.loadAnimation(context, R.anim.check_out);
+ if (imageView != null) {
+ imageView.clearAnimation();
+ imageView.startAnimation(iconAnimation);
+ } else {
+ // TODO: we don't have the check icon object probably because of config change
+ }
+ } else {
+ // if view is un-checked, check it
+ LOG.debug("the view at position {} is unchecked, check it", position);
+ getItemsDigested().get(position).setChecked(true);
+
+ Animation iconAnimation = AnimationUtils.loadAnimation(context, R.anim.check_in);
+ if (imageView != null) {
+ imageView.clearAnimation();
+ imageView.startAnimation(iconAnimation);
+ } else {
+ // TODO: we don't have the check icon object probably because of config change
+ }
+ }
+
+ invalidateSelection();
+ notifyItemChanged(position);
+ }
+
+ private void invalidateSelection() {
+ if (mainFragment.getMainFragmentViewModel() != null) {
+ mainFragment
+ .getMainActivity()
+ .setListItemSelected(
+ mainFragment.getMainFragmentViewModel().getCheckedItems().size() != 0);
+ }
+ }
+
+ public void invalidateActionMode() {
+ if (mainFragment.getMainFragmentViewModel() != null) {
+ // we have the actionmode visible, invalidate it's views
+ if (mainFragment.getMainActivity().getListItemSelected()) {
+ if (mainFragment.getMainActivity().getActionModeHelper().getActionMode() == null) {
+ ActionMode.Callback mActionModeCallback =
+ mainFragment.getMainActivity().getActionModeHelper();
+ mainFragment
+ .getMainActivity()
+ .getActionModeHelper()
+ .setActionMode(
+ mainFragment.getMainActivity().startSupportActionMode(mActionModeCallback));
+ } else {
+ mainFragment.getMainActivity().getActionModeHelper().getActionMode().invalidate();
+ }
+ } else {
+ if (mainFragment.getMainActivity().getActionModeHelper().getActionMode() != null) {
+ mainFragment.getMainActivity().getActionModeHelper().getActionMode().finish();
+ mainFragment.getMainActivity().getActionModeHelper().setActionMode(null);
+ }
+ }
+ }
+ }
+
+ public void toggleChecked(boolean selectAll, String path) {
+ int i = path.equals("/") || !getBoolean(PREFERENCE_SHOW_GOBACK_BUTTON) ? 0 : 1;
+ for (; i < getItemsDigested().size(); i++) {
+ ListItem item = getItemsDigested().get(i);
+ if (selectAll && item.getChecked() != ListItem.CHECKED) {
+ item.setChecked(true);
+ notifyItemChanged(i);
+ } else if (!selectAll && item.getChecked() == ListItem.CHECKED) {
+ item.setChecked(false);
+ notifyItemChanged(i);
+ }
+ }
+ invalidateSelection();
+ invalidateActionMode();
+ }
+
+ public void toggleInverse(String path) {
+ int i = path.equals("/") || !getBoolean(PREFERENCE_SHOW_GOBACK_BUTTON) ? 0 : 1;
+
+ for (; i < getItemsDigested().size(); i++) {
+ ListItem item = getItemsDigested().get(i);
+ if (item.getChecked() != ListItem.CHECKED) {
+ item.setChecked(true);
+ notifyItemChanged(i);
+ } else if (item.getChecked() == ListItem.CHECKED) {
+ item.setChecked(false);
+ notifyItemChanged(i);
+ }
+ }
+ }
+
+ public void toggleSameTypes() {
+ ArrayList checkedItemsIndexes = getCheckedItemsIndex();
+ for (int i = 0; i < checkedItemsIndexes.size(); i++) {
+ ListItem selectedItem = getItemsDigested().get(checkedItemsIndexes.get(i));
+
+ if (!selectedItem.specialTypeHasFile()) {
+ continue;
+ }
+
+ LayoutElementParcelable selectedElement = selectedItem.requireLayoutElementParcelable();
+ for (int z = 0; z < getItemsDigested().size(); z++) {
+ ListItem currentItem = getItemsDigested().get(z);
+ if (!currentItem.specialTypeHasFile()) {
+ // header type list item ('Files' / 'Folders')
+ continue;
+ }
+
+ LayoutElementParcelable currentElement = currentItem.requireLayoutElementParcelable();
+ if (selectedElement.isDirectory || currentElement.isDirectory) {
+ if (selectedElement.isDirectory && currentElement.isDirectory) {
+ if (currentItem.getChecked() != ListItem.CHECKED) {
+ currentItem.setChecked(true);
+ notifyItemChanged(z);
+ }
+ }
+ } else {
+ String mimeTypeCurrentItem = MimeTypes.getExtension(currentElement.desc);
+ String mimeTypeSelectedElement = MimeTypes.getExtension(selectedElement.desc);
+ if (mimeTypeCurrentItem.equalsIgnoreCase(mimeTypeSelectedElement)
+ && currentItem.getChecked() != ListItem.CHECKED) {
+ currentItem.setChecked(true);
+ notifyItemChanged(z);
+ }
+ }
+ }
+ }
+ }
+
+ public void toggleSameDates() {
+ ArrayList checkedItemsIndexes = getCheckedItemsIndex();
+ for (int i = 0; i < checkedItemsIndexes.size(); i++) {
+ ListItem selectedItem = getItemsDigested().get(checkedItemsIndexes.get(i));
+
+ if (!selectedItem.specialTypeHasFile()) {
+ continue;
+ }
+
+ LayoutElementParcelable selectedElement = selectedItem.requireLayoutElementParcelable();
+ for (int y = 0; y < getItemsDigested().size(); y++) {
+ ListItem currentItem = getItemsDigested().get(y);
+ if (!currentItem.specialTypeHasFile()) {
+ // header type list item ('Files' / 'Folders')
+ continue;
+ }
+ String dateModifiedCurrentItem =
+ currentItem.requireLayoutElementParcelable().dateModification.split("\\|")[0];
+ String dateModifiedSelectedElement = selectedElement.dateModification.split("\\|")[0];
+ if (dateModifiedCurrentItem.trim().equalsIgnoreCase(dateModifiedSelectedElement.trim())
+ && currentItem.getChecked() != ListItem.CHECKED) {
+ currentItem.setChecked(true);
+ notifyItemChanged(y);
+ }
+ }
+ }
+ }
+
+ public void toggleFill() {
+ ArrayList checkedItemsIndexes = getCheckedItemsIndex();
+ Collections.sort(checkedItemsIndexes);
+ if (checkedItemsIndexes.size() >= 2) {
+ for (int i = checkedItemsIndexes.get(0);
+ i < checkedItemsIndexes.get(checkedItemsIndexes.size() - 1);
+ i++) {
+ Objects.requireNonNull(getItemsDigested()).get(i).setChecked(true);
+ notifyItemChanged(i);
+ }
+ }
+ }
+
+ public void toggleSimilarNames() {
+ ArrayList checkedItemsIndexes = getCheckedItemsIndex();
+ for (int i = 0; i < checkedItemsIndexes.size(); i++) {
+ ListItem selectedItem = getItemsDigested().get(checkedItemsIndexes.get(i));
+
+ if (!selectedItem.specialTypeHasFile()) {
+ continue;
+ }
+
+ LayoutElementParcelable selectedElement = selectedItem.requireLayoutElementParcelable();
+ int fuzzinessFactor = selectedElement.title.length() / SelectionPopupMenu.FUZZYNESS_FACTOR;
+ if (fuzzinessFactor >= 1) {
+ for (int z = 0; z < getItemsDigested().size(); z++) {
+ ListItem currentItem = getItemsDigested().get(z);
+ if (!currentItem.specialTypeHasFile()) {
+ // header type list item ('Files' / 'Folders')
+ continue;
+ }
+ int remainingFuzzyness = fuzzinessFactor;
+
+ char[] currentItemName = currentItem.requireLayoutElementParcelable().title.toCharArray();
+ char[] selectedElementName = selectedElement.title.toCharArray();
+ boolean isSimilar = true;
+ for (int j = 0; j < Math.min(currentItemName.length, selectedElementName.length); j++) {
+ if (currentItemName[j] != selectedElementName[j] && remainingFuzzyness-- < 0) {
+ isSimilar = false;
+ break;
+ }
+ }
+ if (isSimilar
+ && Math.abs(currentItemName.length - selectedElementName.length)
+ <= remainingFuzzyness) {
+ if (currentItem.getChecked() != ListItem.CHECKED) {
+ currentItem.setChecked(true);
+ notifyItemChanged(z);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * called when we would want to toggle check for all items in the adapter
+ *
+ * @param b if to toggle true or false
+ */
+ public void toggleChecked(boolean b) {
+ for (int i = 0; i < getItemsDigested().size(); i++) {
+ ListItem item = getItemsDigested().get(i);
+ if (b && item.getChecked() != ListItem.CHECKED) {
+ item.setChecked(true);
+ notifyItemChanged(i);
+ } else if (!b && item.getChecked() == ListItem.CHECKED) {
+ item.setChecked(false);
+ notifyItemChanged(i);
+ }
+ }
+ invalidateSelection();
+ invalidateActionMode();
+ }
+
+ @NonNull
+ public ArrayList getCheckedItems() {
+ return mainFragment.getMainFragmentViewModel().getCheckedItems();
+ }
+
+ @Nullable
+ public ArrayList getItemsDigested() {
+ return mainFragment.getMainFragmentViewModel() != null
+ ? mainFragment.getMainFragmentViewModel().getAdapterListItems()
+ : null;
+ }
+
+ public boolean isItemsDigestedNullOrEmpty() {
+ return getItemsDigested() == null || getItemsDigested().isEmpty();
+ }
+
+ public boolean areAllChecked(String path) {
+ int i = (path.equals("/") || !getBoolean(PREFERENCE_SHOW_GOBACK_BUTTON)) ? 0 : 1;
+
+ for (; i < getItemsDigested().size(); i++) {
+ if (getItemsDigested().get(i).getChecked() == ListItem.NOT_CHECKED) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public ArrayList getCheckedItemsIndex() {
+ ArrayList checked = new ArrayList<>();
+
+ for (int i = 0; i < getItemsDigested().size(); i++) {
+ if (getItemsDigested().get(i).getChecked() == ListItem.CHECKED) {
+ checked.add(i);
+ }
+ }
+
+ return checked;
+ }
+
+ @Override
+ public void onViewDetachedFromWindow(@NonNull RecyclerView.ViewHolder holder) {
+ if (holder instanceof ItemViewHolder) {
+ ((ItemViewHolder) holder).baseItemView.clearAnimation();
+ ((ItemViewHolder) holder).txtTitle.setSelected(false);
+ if (dragAndDropPreference != PreferencesConstants.PREFERENCE_DRAG_DEFAULT) {
+ ((ItemViewHolder) holder).baseItemView.setOnDragListener(null);
+ }
+ }
+ super.onViewDetachedFromWindow(holder);
+ }
+
+ @Override
+ public void onViewAttachedToWindow(@NonNull RecyclerView.ViewHolder holder) {
+ super.onViewAttachedToWindow(holder);
+ boolean enableMarqueeFilename =
+ sharedPrefs.getBoolean(PreferencesConstants.PREFERENCE_ENABLE_MARQUEE_FILENAME, true);
+ if (enableMarqueeFilename && holder instanceof ItemViewHolder) {
+ AnimUtils.marqueeAfterDelay(2000, ((ItemViewHolder) holder).txtTitle);
+ }
+ super.onViewAttachedToWindow(holder);
+ }
+
+ @Override
+ public boolean onFailedToRecycleView(@NonNull RecyclerView.ViewHolder holder) {
+ ((ItemViewHolder) holder).baseItemView.clearAnimation();
+ ((ItemViewHolder) holder).txtTitle.setSelected(false);
+ return super.onFailedToRecycleView(holder);
+ }
+
+ private void animate(ItemViewHolder holder) {
+ holder.baseItemView.clearAnimation();
+ Animation localAnimation = AnimationUtils.loadAnimation(context, R.anim.fade_in_top);
+ localAnimation.setStartOffset(this.offset);
+ holder.baseItemView.startAnimation(localAnimation);
+ this.offset += 30;
+ }
+
+ /**
+ * Adds item to the end of the list, don't use this unless you are dynamically loading the
+ * adapter, after you are finished you must call createHeaders
+ */
+ public void addItem(@NonNull LayoutElementParcelable element) {
+ // TODO: simplify if condition
+ if (mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().isList()
+ && getItemsDigested().size() > 0) {
+ getItemsDigested().add(getItemsDigested().size() - 1, new ListItem(element));
+ } else if (mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().isList()) {
+ getItemsDigested().add(new ListItem(element));
+ getItemsDigested().add(new ListItem(EMPTY_LAST_ITEM));
+ } else {
+ getItemsDigested().add(new ListItem(element));
+ }
+
+ notifyItemInserted(getItemCount());
+ }
+
+ public void setItems(
+ @NonNull RecyclerView recyclerView, @NonNull List elements) {
+ setItems(recyclerView, elements, true);
+ }
+
+ private void setItems(
+ @NonNull RecyclerView recyclerView,
+ @NonNull List elements,
+ boolean invalidate) {
+ if (preloader != null) {
+ recyclerView.removeOnScrollListener(preloader);
+ preloader = null;
+ }
+
+ if (getItemsDigested() != null && invalidate) {
+ getItemsDigested().clear();
+ if (mainFragment.getMainFragmentViewModel().getIconList() != null) {
+ mainFragment.getMainFragmentViewModel().getIconList().clear();
+ }
+ }
+
+ offset = 0;
+ stoppedAnimation = false;
+
+ ArrayList uris = new ArrayList<>();
+ ArrayList listItems = new ArrayList<>();
+
+ for (LayoutElementParcelable e : elements) {
+ if (invalidate || isItemsDigestedNullOrEmpty()) {
+ if (e != null) {
+ listItems.add(new ListItem(e.isBack, e));
+ }
+ uris.add(e != null ? e.iconData : null);
+ }
+ }
+
+ if (mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().isList()
+ && listItems.size() > 0
+ && (invalidate || isItemsDigestedNullOrEmpty())) {
+ listItems.add(new ListItem(EMPTY_LAST_ITEM));
+ uris.add(null);
+ }
+
+ if (invalidate || isItemsDigestedNullOrEmpty()) {
+ mainFragment.getMainFragmentViewModel().setAdapterListItems(listItems);
+ mainFragment.getMainFragmentViewModel().setIconList(uris);
+
+ if (getBoolean(PREFERENCE_SHOW_HEADERS)) {
+ createHeaders(invalidate, mainFragment.getMainFragmentViewModel().getIconList());
+ }
+ }
+
+ boolean isItemCircular = !isGrid;
+
+ sizeProvider = new RecyclerPreloadSizeProvider(this);
+ modelProvider =
+ new RecyclerPreloadModelProvider(
+ mainFragment, mainFragment.getMainFragmentViewModel().getIconList(), isItemCircular);
+
+ preloader =
+ new RecyclerViewPreloader<>(
+ Glide.with(mainFragment),
+ modelProvider,
+ sizeProvider,
+ GlideConstants.MAX_PRELOAD_FILES);
+
+ recyclerView.addOnScrollListener(preloader);
+ }
+
+ public void createHeaders(boolean invalidate, List uris) {
+ if ((mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().getDsort() == DirSortBy.NONE_ON_TOP)
+ || getItemsDigested() == null
+ || getItemsDigested().isEmpty()) {
+ return;
+ } else {
+ boolean[] headers = new boolean[] {false, false};
+
+ for (int i = 0; i < getItemsDigested().size(); i++) {
+
+ if (getItemsDigested().get(i).layoutElementParcelable != null) {
+ LayoutElementParcelable nextItem = getItemsDigested().get(i).layoutElementParcelable;
+
+ if (nextItem != null) {
+ if (!headers[0] && nextItem.isDirectory) {
+ headers[0] = true;
+ getItemsDigested().add(i, new ListItem(TYPE_HEADER_FOLDERS));
+ uris.add(i, null);
+ continue;
+ }
+
+ if (!headers[1]
+ && !nextItem.isDirectory
+ && !nextItem.title.equals(".")
+ && !nextItem.title.equals("..")) {
+ headers[1] = true;
+ getItemsDigested().add(i, new ListItem(TYPE_HEADER_FILES));
+ uris.add(i, null);
+ continue; // leave this continue for symmetry
+ }
+ }
+ }
+ }
+
+ if (invalidate) {
+ notifyDataSetChanged();
+ }
+ }
+ }
+
+ @Override
+ public int getItemCount() {
+ return getItemsDigested().size();
+ }
+
+ @Override
+ public long getItemId(int position) {
+ return position;
+ }
+
+ @Override
+ public int getItemViewType(int position) {
+ if (getItemsDigested().get(position).specialType != -1) {
+ return getItemsDigested().get(position).specialType;
+ } else {
+ return TYPE_ITEM;
+ }
+ }
+
+ @NonNull
+ @Override
+ public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ View view;
+
+ switch (viewType) {
+ case TYPE_HEADER_FOLDERS:
+ case TYPE_HEADER_FILES:
+ if (mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().isList()) {
+
+ view = mInflater.inflate(R.layout.list_header, parent, false);
+ } else {
+
+ view = mInflater.inflate(R.layout.grid_header, parent, false);
+ }
+
+ int type =
+ viewType == TYPE_HEADER_FOLDERS
+ ? SpecialViewHolder.HEADER_FOLDERS
+ : SpecialViewHolder.HEADER_FILES;
+ return new SpecialViewHolder(context, view, utilsProvider, type);
+ case TYPE_ITEM:
+ case TYPE_BACK:
+ if (mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().isList()) {
+ view = mInflater.inflate(R.layout.rowlayout, parent, false);
+ sizeProvider.addView(VIEW_GENERIC, view.findViewById(R.id.generic_icon));
+ sizeProvider.addView(VIEW_PICTURE, view.findViewById(R.id.picture_icon));
+ sizeProvider.addView(VIEW_APK, view.findViewById(R.id.apk_icon));
+ } else {
+ view = mInflater.inflate(R.layout.griditem, parent, false);
+ sizeProvider.addView(VIEW_GENERIC, view.findViewById(R.id.generic_icon));
+ sizeProvider.addView(VIEW_THUMB, view.findViewById(R.id.icon_thumb));
+ }
+ sizeProvider.closeOffAddition();
+
+ return new ItemViewHolder(view);
+ case EMPTY_LAST_ITEM:
+ int totalFabHeight = (int) context.getResources().getDimension(R.dimen.fab_height),
+ marginFab = (int) context.getResources().getDimension(R.dimen.fab_margin);
+ view = new View(context);
+ view.setMinimumHeight(totalFabHeight + marginFab);
+ return new EmptyViewHolder(view);
+ default:
+ throw new IllegalArgumentException("Illegal: " + viewType);
+ }
+ }
+
+ @Override
+ public void onBindViewHolder(@NonNull final RecyclerView.ViewHolder vholder, int position) {
+ if (!(vholder instanceof ItemViewHolder)) {
+ return;
+ }
+
+ @NonNull final ItemViewHolder holder = (ItemViewHolder) vholder;
+
+ holder.baseItemView.setOnFocusChangeListener(
+ (v, hasFocus) -> {
+ if (hasFocus) {
+ mainFragment.adjustListViewForTv(holder, mainFragment.getMainActivity());
+ }
+ });
+ holder.txtTitle.setEllipsize(
+ enableMarquee ? TextUtils.TruncateAt.MARQUEE : TextUtils.TruncateAt.MIDDLE);
+
+ final boolean isBackButton = getItemsDigested().get(position).specialType == TYPE_BACK;
+ if (isBackButton) {
+ holder.about.setVisibility(View.GONE);
+ }
+
+ if (!this.stoppedAnimation && !getItemsDigested().get(position).getAnimating()) {
+ animate(holder);
+ getItemsDigested().get(position).setAnimate(true);
+ }
+
+ if (dragAndDropPreference != PreferencesConstants.PREFERENCE_DRAG_DEFAULT) {
+ holder.baseItemView.setOnDragListener(
+ new RecyclerAdapterDragListener(this, holder, dragAndDropPreference, mainFragment));
+ }
+
+ if (mainFragment.getMainFragmentViewModel().isList()) {
+ bindViewHolderList(holder, position);
+ } else {
+ bindViewHolderGrid(holder, position);
+ }
+
+ invalidateActionMode();
+ }
+
+ private void bindViewHolderList(@NonNull final ItemViewHolder holder, int position) {
+ final boolean isBackButton = getItemsDigested().get(position).specialType == TYPE_BACK;
+ @Nullable
+ final LayoutElementParcelable rowItem =
+ getItemsDigested().get(position).layoutElementParcelable;
+
+ if (mainFragment.getMainFragmentViewModel() != null && position == getItemCount() - 1) {
+ holder.baseItemView.setMinimumHeight((int) minRowHeight);
+ if (getItemsDigested().size() == (getBoolean(PREFERENCE_SHOW_GOBACK_BUTTON) ? 1 : 0))
+ holder.txtTitle.setText(R.string.no_files);
+ else {
+ holder.txtTitle.setText("");
+ }
+ return;
+ }
+
+ holder.baseItemView.setOnLongClickListener(
+ p1 -> {
+ if (hasPendingPasteOperation()) return false;
+ if (!isBackButton) {
+ if (dragAndDropPreference == PreferencesConstants.PREFERENCE_DRAG_DEFAULT
+ || (dragAndDropPreference == PreferencesConstants.PREFERENCE_DRAG_TO_MOVE_COPY
+ && getItemsDigested().get(holder.getAdapterPosition()).getChecked()
+ != ListItem.CHECKED)) {
+ mainFragment.registerListItemChecked(
+ holder.getAdapterPosition(), holder.checkImageView);
+ }
+ initDragListener(position, p1, holder);
+ }
+ return true;
+ });
+
+ // clear previously cached icon
+ Glide.with(mainFragment).clear(holder.genericIcon);
+ Glide.with(mainFragment).clear(holder.pictureIcon);
+ Glide.with(mainFragment).clear(holder.apkIcon);
+ Glide.with(mainFragment).clear(holder.baseItemView);
+
+ holder.baseItemView.setOnClickListener(
+ v -> {
+ mainFragment.onListItemClicked(
+ isBackButton, holder.getAdapterPosition(), rowItem, holder.checkImageView);
+ });
+
+ holder.about.setOnKeyListener(
+ (v, keyCode, event) -> {
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ if (event.getKeyCode() == KeyEvent.KEYCODE_DPAD_RIGHT) {
+ mainFragment.getMainActivity().getFAB().requestFocus();
+ } else if (event.getKeyCode() == KeyEvent.KEYCODE_DPAD_CENTER) {
+ showPopup(v, rowItem);
+ } else if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
+ mainFragment.getMainActivity().onBackPressed();
+ } else {
+ return false;
+ }
+ }
+ return true;
+ });
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+ holder.checkImageView.setBackground(
+ new CircleGradientDrawable(
+ accentColor,
+ utilsProvider.getAppTheme(),
+ mainFragment.getResources().getDisplayMetrics()));
+ } else {
+ holder.checkImageView.setBackgroundDrawable(
+ new CircleGradientDrawable(
+ accentColor,
+ utilsProvider.getAppTheme(),
+ mainFragment.getResources().getDisplayMetrics()));
+ }
+ holder.txtTitle.setText(rowItem.title);
+ holder.genericText.setText("");
+
+ if (utilsProvider.getAppTheme().equals(AppTheme.LIGHT)) {
+ holder.about.setColorFilter(grey_color);
+ }
+ holder.about.setOnClickListener(v -> showPopup(v, rowItem));
+ holder.genericIcon.setOnClickListener(
+ v -> {
+ int id = v.getId();
+ if (id == R.id.generic_icon || id == R.id.picture_icon || id == R.id.apk_icon) {
+ // TODO: transform icon on press to the properties dialog with animation
+ if (!isBackButton) {
+ toggleChecked(holder.getAdapterPosition(), holder.checkImageView);
+ } else mainFragment.goBack();
+ }
+ });
+
+ holder.pictureIcon.setOnClickListener(
+ view -> {
+ if (!isBackButton) {
+ toggleChecked(holder.getAdapterPosition(), holder.checkImageView);
+ } else mainFragment.goBack();
+ });
+
+ holder.apkIcon.setOnClickListener(
+ view -> {
+ if (!isBackButton) {
+ toggleChecked(holder.getAdapterPosition(), holder.checkImageView);
+ } else mainFragment.goBack();
+ });
+
+ // resetting icons visibility
+ holder.genericIcon.setVisibility(View.VISIBLE);
+ holder.pictureIcon.setVisibility(View.INVISIBLE);
+ holder.apkIcon.setVisibility(View.INVISIBLE);
+ holder.checkImageView.setVisibility(View.INVISIBLE);
+
+ // setting icons for various cases
+ // apkIcon holder refers to square/non-circular drawable
+ // pictureIcon is circular drawable
+ switch (rowItem.filetype) {
+ case Icons.IMAGE:
+ case Icons.VIDEO:
+ if (getBoolean(PREFERENCE_SHOW_THUMB) && rowItem.getMode() != OpenMode.FTP) {
+ if (getBoolean(PREFERENCE_USE_CIRCULAR_IMAGES)) {
+ showThumbnailWithBackground(
+ holder, rowItem.iconData, holder.pictureIcon, rowItem.iconData::setImageBroken);
+ } else {
+ showThumbnailWithBackground(
+ holder, rowItem.iconData, holder.apkIcon, rowItem.iconData::setImageBroken);
+ }
+ } else {
+ holder.genericIcon.setImageResource(
+ rowItem.filetype == Icons.IMAGE
+ ? R.drawable.ic_doc_image
+ : R.drawable.ic_doc_video_am);
+ }
+ break;
+ case Icons.APK:
+ if (getBoolean(PREFERENCE_SHOW_THUMB)) {
+ showThumbnailWithBackground(
+ holder, rowItem.iconData, holder.apkIcon, rowItem.iconData::setImageBroken);
+ } else {
+ holder.genericIcon.setImageResource(R.drawable.ic_doc_apk_white);
+ }
+ break;
+ case Icons.NOT_KNOWN:
+ holder.genericIcon.setVisibility(View.VISIBLE);
+ // if the file type is any unknown variable
+ String ext = !rowItem.isDirectory ? MimeTypes.getExtension(rowItem.title) : null;
+ if (ext != null && ext.trim().length() != 0) {
+ holder.genericText.setText(ext);
+ holder.genericIcon.setImageDrawable(null);
+ holder.genericIcon.setVisibility(View.INVISIBLE);
+ } else {
+ // we could not find the extension, set a generic file type icon probably a directory
+ modelProvider.getPreloadRequestBuilder(rowItem.iconData).into(holder.genericIcon);
+ }
+ break;
+ case Icons.ENCRYPTED:
+ default:
+ holder.genericIcon.setVisibility(View.VISIBLE);
+ modelProvider.getPreloadRequestBuilder(rowItem.iconData).into(holder.genericIcon);
+ break;
+ }
+
+ if (utilsProvider.getAppTheme().equals(AppTheme.LIGHT)) {
+ holder.baseItemView.setBackgroundResource(R.drawable.safr_ripple_white);
+ } else {
+ holder.baseItemView.setBackgroundResource(R.drawable.safr_ripple_black);
+ }
+ holder.baseItemView.setSelected(false);
+ if (getItemsDigested().get(position).getChecked() == ListItem.CHECKED) {
+
+ if (holder.checkImageView.getVisibility() == View.INVISIBLE)
+ holder.checkImageView.setVisibility(View.VISIBLE);
+ // making sure the generic icon background color filter doesn't get changed
+ // to grey on picture/video/apk/generic text icons when checked
+ // so that user can still look at the thumbs even after selection
+ if ((rowItem.filetype != Icons.IMAGE
+ && rowItem.filetype != Icons.APK
+ && rowItem.filetype != Icons.VIDEO)
+ || !getBoolean(PREFERENCE_SHOW_THUMB)) {
+ holder.apkIcon.setVisibility(View.GONE);
+ holder.pictureIcon.setVisibility(View.GONE);
+ holder.genericIcon.setVisibility(View.VISIBLE);
+ GradientDrawable gradientDrawable = (GradientDrawable) holder.genericIcon.getBackground();
+ gradientDrawable.setColor(goBackColor);
+ }
+ holder.baseItemView.setSelected(true);
+ // holder.genericText.setText("");
+ } else {
+ holder.checkImageView.setVisibility(View.INVISIBLE);
+ if (!((rowItem.filetype == Icons.APK
+ || rowItem.filetype == Icons.IMAGE
+ || rowItem.filetype == Icons.VIDEO)
+ && getBoolean(PREFERENCE_SHOW_THUMB))) {
+ holder.genericIcon.setVisibility(View.VISIBLE);
+ GradientDrawable gradientDrawable = (GradientDrawable) holder.genericIcon.getBackground();
+
+ if (getBoolean(PREFERENCE_COLORIZE_ICONS)) {
+ if (rowItem.isDirectory) {
+ gradientDrawable.setColor(iconSkinColor);
+ } else {
+ ColorUtils.colorizeIcons(context, rowItem.filetype, gradientDrawable, iconSkinColor);
+ }
+ } else {
+ gradientDrawable.setColor(iconSkinColor);
+ }
+
+ if (isBackButton) {
+ gradientDrawable.setColor(goBackColor);
+ }
+ }
+ }
+ if (getBoolean(PREFERENCE_SHOW_PERMISSIONS)) {
+ holder.perm.setText(rowItem.permissions);
+ }
+ if (getBoolean(PREFERENCE_SHOW_LAST_MODIFIED)) {
+ holder.date.setText(rowItem.dateModification);
+ } else {
+ holder.date.setVisibility(View.GONE);
+ }
+ if (isBackButton) {
+ holder.date.setText(rowItem.size);
+ holder.txtDesc.setText("");
+ } else if (getBoolean(PREFERENCE_SHOW_FILE_SIZE)) {
+ holder.txtDesc.setText(rowItem.size);
+ }
+ }
+
+ private void bindViewHolderGrid(@NonNull final ItemViewHolder holder, int position) {
+ final boolean isBackButton = getItemsDigested().get(position).specialType == TYPE_BACK;
+ @Nullable
+ final LayoutElementParcelable rowItem =
+ getItemsDigested().get(position).layoutElementParcelable;
+
+ holder.baseItemView.setOnLongClickListener(
+ p1 -> {
+ if (hasPendingPasteOperation()) return false;
+ if (!isBackButton) {
+ if (dragAndDropPreference == PreferencesConstants.PREFERENCE_DRAG_DEFAULT
+ || (dragAndDropPreference == PreferencesConstants.PREFERENCE_DRAG_TO_MOVE_COPY
+ && getItemsDigested().get(holder.getAdapterPosition()).getChecked()
+ != ListItem.CHECKED)) {
+ mainFragment.registerListItemChecked(
+ holder.getAdapterPosition(), holder.checkImageViewGrid);
+ }
+ initDragListener(position, p1, holder);
+ }
+ return true;
+ });
+
+ // view is a grid view
+ // clear previously cached icon
+ Glide.with(mainFragment).clear(holder.genericIcon);
+ Glide.with(mainFragment).clear(holder.iconLayout);
+ Glide.with(mainFragment).clear(holder.imageView1);
+ Glide.with(mainFragment).clear(holder.baseItemView);
+
+ holder.checkImageViewGrid.setColorFilter(accentColor);
+ holder.baseItemView.setOnClickListener(
+ v -> {
+ mainFragment.onListItemClicked(
+ isBackButton, holder.getAdapterPosition(), rowItem, holder.checkImageViewGrid);
+ });
+ holder.txtTitle.setText(rowItem.title);
+ holder.imageView1.setVisibility(View.INVISIBLE);
+ holder.genericIcon.setVisibility(View.VISIBLE);
+ holder.checkImageViewGrid.setVisibility(View.INVISIBLE);
+
+ if (rowItem.filetype == Icons.IMAGE || rowItem.filetype == Icons.VIDEO) {
+ if (getBoolean(PREFERENCE_SHOW_THUMB) && rowItem.getMode() != OpenMode.FTP) {
+ holder.imageView1.setVisibility(View.VISIBLE);
+ holder.imageView1.setImageDrawable(null);
+ if (utilsProvider.getAppTheme().equals(AppTheme.DARK)
+ || utilsProvider.getAppTheme().equals(AppTheme.BLACK))
+ holder.imageView1.setBackgroundColor(Color.BLACK);
+ showRoundedThumbnail(
+ holder, rowItem.iconData, holder.imageView1, rowItem.iconData::setImageBroken);
+ } else {
+ if (rowItem.filetype == Icons.IMAGE)
+ holder.genericIcon.setImageResource(R.drawable.ic_doc_image);
+ else holder.genericIcon.setImageResource(R.drawable.ic_doc_video_am);
+ }
+ } else if (rowItem.filetype == Icons.APK) {
+ if (getBoolean(PREFERENCE_SHOW_THUMB))
+ showRoundedThumbnail(
+ holder, rowItem.iconData, holder.genericIcon, rowItem.iconData::setImageBroken);
+ else {
+ holder.genericIcon.setImageResource(R.drawable.ic_doc_apk_white);
+ }
+ } else {
+ Glide.with(mainFragment).load(rowItem.iconData.image).into(holder.genericIcon);
+ }
+
+ if (holder.genericIcon.getVisibility() == View.VISIBLE) {
+ View iconBackground =
+ getBoolean(PREFERENCE_USE_CIRCULAR_IMAGES) ? holder.genericIcon : holder.iconLayout;
+ if (rowItem.isDirectory) {
+ iconBackground.setBackgroundColor(iconSkinColor);
+ } else {
+ switch (rowItem.filetype) {
+ case Icons.VIDEO:
+ if (!getBoolean(PREFERENCE_SHOW_THUMB)) iconBackground.setBackgroundColor(videoColor);
+ break;
+ case Icons.AUDIO:
+ iconBackground.setBackgroundColor(audioColor);
+ break;
+ case Icons.PDF:
+ iconBackground.setBackgroundColor(pdfColor);
+ break;
+ case Icons.CODE:
+ iconBackground.setBackgroundColor(codeColor);
+ break;
+ case Icons.TEXT:
+ iconBackground.setBackgroundColor(textColor);
+ break;
+ case Icons.COMPRESSED:
+ iconBackground.setBackgroundColor(archiveColor);
+ break;
+ case Icons.NOT_KNOWN:
+ iconBackground.setBackgroundColor(genericColor);
+ break;
+ case Icons.APK:
+ if (!getBoolean(PREFERENCE_SHOW_THUMB)) iconBackground.setBackgroundColor(apkColor);
+ break;
+ case Icons.IMAGE:
+ if (!getBoolean(PREFERENCE_SHOW_THUMB)) iconBackground.setBackgroundColor(videoColor);
+ break;
+ default:
+ iconBackground.setBackgroundColor(iconSkinColor);
+ break;
+ }
+ }
+
+ if (isBackButton) {
+ iconBackground.setBackgroundColor(goBackColor);
+ }
+ }
+
+ if (getItemsDigested().get(position).getChecked() == ListItem.CHECKED) {
+ if (holder.genericIcon.getVisibility() == View.VISIBLE) {
+
+ if ((rowItem.filetype != Icons.IMAGE
+ && rowItem.filetype != Icons.APK
+ && rowItem.filetype != Icons.VIDEO)
+ || !getBoolean(PREFERENCE_SHOW_THUMB)) {
+ View iconBackground =
+ getBoolean(PREFERENCE_USE_CIRCULAR_IMAGES) ? holder.genericIcon : holder.iconLayout;
+ iconBackground.setBackgroundColor(goBackColor);
+ }
+ }
+
+ holder.checkImageViewGrid.setVisibility(View.VISIBLE);
+ holder.baseItemView.setBackgroundColor(Utils.getColor(context, R.color.item_background));
+ } else {
+ holder.checkImageViewGrid.setVisibility(View.INVISIBLE);
+ if (utilsProvider.getAppTheme().equals(AppTheme.LIGHT)) {
+ holder.baseItemView.setBackgroundResource(R.drawable.item_doc_grid);
+ } else {
+ holder.baseItemView.setBackgroundResource(R.drawable.ic_grid_card_background_dark);
+ holder
+ .baseItemView
+ .findViewById(R.id.icon_frame_grid)
+ .setBackgroundColor(Utils.getColor(context, R.color.icon_background_dark));
+ }
+ }
+
+ if (utilsProvider.getAppTheme().equals(AppTheme.LIGHT)) {
+ holder.about.setColorFilter(grey_color);
+ }
+ holder.about.setOnClickListener(v -> showPopup(v, rowItem));
+
+ if (getBoolean(PREFERENCE_SHOW_LAST_MODIFIED)) {
+ holder.date.setText(rowItem.dateModification);
+ }
+ if (isBackButton) {
+ holder.date.setText(rowItem.size);
+ holder.txtDesc.setText("");
+ }
+ if (getBoolean(PREFERENCE_SHOW_PERMISSIONS)) {
+ holder.perm.setText(rowItem.permissions);
+ }
+ }
+
+ @Override
+ @ViewType
+ public int getCorrectView(IconDataParcelable item, int adapterPosition) {
+ int specialType = getItemsDigested().get(adapterPosition).specialType;
+
+ if (specialType != TYPE_ITEM && specialType != TYPE_BACK) { // These have no icons
+ throw new IllegalStateException("Setting view type to wrong item");
+ }
+
+ if (mainFragment.getMainFragmentViewModel() != null
+ && mainFragment.getMainFragmentViewModel().isList()) {
+ if (getBoolean(PREFERENCE_SHOW_THUMB)) {
+ int filetype =
+ getItemsDigested().get(adapterPosition).requireLayoutElementParcelable().filetype;
+
+ if (filetype == Icons.VIDEO || filetype == Icons.IMAGE) {
+ if (getBoolean(PREFERENCE_USE_CIRCULAR_IMAGES)) {
+ return VIEW_PICTURE;
+ } else {
+ return VIEW_APK;
+ }
+ } else if (filetype == Icons.APK) {
+ return VIEW_APK;
+ }
+ }
+
+ return VIEW_GENERIC;
+ } else {
+ if (item.type == IconDataParcelable.IMAGE_FROMFILE) {
+ return VIEW_THUMB;
+ } else {
+ return VIEW_GENERIC;
+ }
+ }
+ }
+
+ private void initDragListener(int position, View view, ItemViewHolder itemViewHolder) {
+ if (dragAndDropPreference != PreferencesConstants.PREFERENCE_DRAG_DEFAULT
+ && (getItemsDigested().get(position).getChecked() == ListItem.CHECKED
+ || dragAndDropPreference == PreferencesConstants.PREFERENCE_DRAG_TO_SELECT)) {
+ // toggle drag flag to true for list item due to the fact
+ // that we might have set it false in a previous drag event
+ if (!getItemsDigested().get(position).shouldToggleDragChecked) {
+ getItemsDigested().get(position).toggleShouldToggleDragChecked();
+ }
+
+ View shadowView =
+ dragAndDropPreference == PreferencesConstants.PREFERENCE_DRAG_TO_SELECT
+ ? itemViewHolder.dummyView
+ : getDragShadow(getCheckedItems().size());
+ View.DragShadowBuilder dragShadowBuilder = new View.DragShadowBuilder(shadowView);
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+ view.startDragAndDrop(null, dragShadowBuilder, null, 0);
+ } else {
+ view.startDrag(null, dragShadowBuilder, null, 0);
+ }
+ mainFragment
+ .getMainActivity()
+ .initCornersDragListener(
+ false, dragAndDropPreference != PreferencesConstants.PREFERENCE_DRAG_TO_SELECT);
+ }
+ }
+
+ private View getDragShadow(int selectionCount) {
+ mainFragment
+ .getMainActivity()
+ .getTabFragment()
+ .getDragPlaceholder()
+ .setVisibility(View.VISIBLE);
+ String rememberMovePreference =
+ sharedPrefs.getString(PreferencesConstants.PREFERENCE_DRAG_AND_DROP_REMEMBERED, "");
+ AppCompatImageView icon =
+ mainFragment
+ .getMainActivity()
+ .getTabFragment()
+ .getDragPlaceholder()
+ .findViewById(R.id.icon);
+ View filesCountParent =
+ mainFragment
+ .getMainActivity()
+ .getTabFragment()
+ .getDragPlaceholder()
+ .findViewById(R.id.files_count_parent);
+ AppCompatTextView filesCount =
+ mainFragment
+ .getMainActivity()
+ .getTabFragment()
+ .getDragPlaceholder()
+ .findViewById(R.id.files_count);
+ icon.setImageDrawable(
+ context.getResources().getDrawable(getDragIconReference(rememberMovePreference)));
+ GradientDrawable gradientDrawable = (GradientDrawable) icon.getBackground();
+ gradientDrawable.setColor(grey_color);
+ filesCount.setText(String.valueOf(selectionCount));
+ filesCountParent.setBackgroundDrawable(
+ new CircleGradientDrawable(
+ accentColor,
+ utilsProvider.getAppTheme(),
+ mainFragment.getResources().getDisplayMetrics()));
+ return mainFragment.getMainActivity().getTabFragment().getDragPlaceholder();
+ }
+
+ private int getDragIconReference(String rememberMovePreference) {
+ int iconRef = R.drawable.ic_add_white_24dp;
+ if (rememberMovePreference.equalsIgnoreCase(
+ PreferencesConstants.PREFERENCE_DRAG_REMEMBER_MOVE)) {
+ iconRef = R.drawable.ic_content_cut_white_36dp;
+ } else if (rememberMovePreference.equalsIgnoreCase(
+ PreferencesConstants.PREFERENCE_DRAG_REMEMBER_COPY)) {
+ iconRef = R.drawable.ic_content_copy_white_24dp;
+ }
+ return iconRef;
+ }
+
+ private void showThumbnailWithBackground(
+ ItemViewHolder viewHolder,
+ IconDataParcelable iconData,
+ AppCompatImageView view,
+ OnImageProcessed errorListener) {
+ if (iconData.isImageBroken()) {
+ viewHolder.genericIcon.setVisibility(View.VISIBLE);
+ Glide.with(mainFragment)
+ .load(R.drawable.ic_broken_image_white_24dp)
+ .into(viewHolder.genericIcon);
+ GradientDrawable gradientDrawable = (GradientDrawable) viewHolder.genericIcon.getBackground();
+ gradientDrawable.setColor(grey_color);
+
+ errorListener.onImageProcessed(true);
+ return;
+ }
+
+ viewHolder.genericIcon.setVisibility(View.VISIBLE);
+ Glide.with(mainFragment).load(iconData.loadingImage).into(viewHolder.genericIcon);
+ GradientDrawable gradientDrawable = (GradientDrawable) viewHolder.genericIcon.getBackground();
+
+ RequestListener requestListener =
+ new RequestListener() {
+
+ @Override
+ public boolean onLoadFailed(
+ @Nullable GlideException e, Object model, Target target, boolean isFirstResource) {
+ new Handler(
+ msg -> {
+ viewHolder.genericIcon.setVisibility(View.VISIBLE);
+ Glide.with(mainFragment)
+ .load(R.drawable.ic_broken_image_white_24dp)
+ .into(viewHolder.genericIcon);
+ return false;
+ })
+ .obtainMessage()
+ .sendToTarget();
+ gradientDrawable.setColor(grey_color);
+
+ errorListener.onImageProcessed(true);
+ return true;
+ }
+
+ @Override
+ public boolean onResourceReady(
+ Drawable resource,
+ Object model,
+ Target target,
+ DataSource dataSource,
+ boolean isFirstResource) {
+ viewHolder.genericIcon.setImageDrawable(null);
+ viewHolder.genericIcon.setVisibility(View.GONE);
+ gradientDrawable.setColor(
+ mainFragment.getResources().getColor(android.R.color.transparent));
+ view.setVisibility(View.VISIBLE);
+
+ errorListener.onImageProcessed(false);
+ return false;
+ }
+ };
+ modelProvider.getPreloadRequestBuilder(iconData).listener(requestListener).into(view);
+ }
+
+ private void showRoundedThumbnail(
+ ItemViewHolder viewHolder,
+ IconDataParcelable iconData,
+ AppCompatImageView view,
+ OnImageProcessed errorListener) {
+ if (iconData.isImageBroken()) {
+ View iconBackground =
+ getBoolean(PREFERENCE_USE_CIRCULAR_IMAGES)
+ ? viewHolder.genericIcon
+ : viewHolder.iconLayout;
+
+ viewHolder.genericIcon.setVisibility(View.VISIBLE);
+ iconBackground.setBackgroundColor(grey_color);
+ Glide.with(mainFragment)
+ .load(R.drawable.ic_broken_image_white_24dp)
+ .into(viewHolder.genericIcon);
+ view.setVisibility(View.INVISIBLE);
+
+ errorListener.onImageProcessed(true);
+ return;
+ }
+
+ View iconBackground =
+ getBoolean(PREFERENCE_USE_CIRCULAR_IMAGES) ? viewHolder.genericIcon : viewHolder.iconLayout;
+
+ viewHolder.genericIcon.setVisibility(View.VISIBLE);
+ Glide.with(mainFragment).load(iconData.loadingImage).into(viewHolder.genericIcon);
+ view.setVisibility(View.INVISIBLE);
+
+ RequestListener requestListener =
+ new RequestListener() {
+ @Override
+ public boolean onLoadFailed(
+ @Nullable GlideException e, Object model, Target target, boolean isFirstResource) {
+ iconBackground.setBackgroundColor(grey_color);
+ new Handler(
+ msg -> {
+ Glide.with(mainFragment)
+ .load(R.drawable.ic_broken_image_white_24dp)
+ .into(viewHolder.genericIcon);
+ return false;
+ })
+ .obtainMessage()
+ .sendToTarget();
+ errorListener.onImageProcessed(true);
+ return true;
+ }
+
+ @Override
+ public boolean onResourceReady(
+ Drawable resource,
+ Object model,
+ Target target,
+ DataSource dataSource,
+ boolean isFirstResource) {
+ viewHolder.genericIcon.setImageDrawable(null);
+ viewHolder.genericIcon.setVisibility(View.GONE);
+ view.setVisibility(View.VISIBLE);
+ iconBackground.setBackgroundColor(
+ mainFragment.getResources().getColor(android.R.color.transparent));
+ errorListener.onImageProcessed(false);
+ return false;
+ }
+ };
+ modelProvider.getPreloadRequestBuilder(iconData).listener(requestListener).into(view);
+ }
+
+ private void showPopup(@NonNull View view, @NonNull final LayoutElementParcelable rowItem) {
+ if (hasPendingPasteOperation()) return;
+ Context currentContext = this.context;
+ if (mainFragment.getMainActivity().getAppTheme() == AppTheme.BLACK) {
+ currentContext = new ContextThemeWrapper(context, R.style.overflow_black);
+ }
+ PopupMenu popupMenu =
+ new ItemPopupMenu(
+ currentContext,
+ mainFragment.requireMainActivity(),
+ utilsProvider,
+ mainFragment,
+ rowItem,
+ view,
+ sharedPrefs);
+ popupMenu.inflate(R.menu.item_extras);
+ String description = rowItem.desc.toLowerCase();
+
+ if (rowItem.isDirectory) {
+ popupMenu.getMenu().findItem(R.id.open_with).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.share).setVisible(false);
+
+ if (mainFragment.getMainActivity().mReturnIntent) {
+ popupMenu.getMenu().findItem(R.id.return_select).setVisible(true);
+ }
+ } else {
+ popupMenu.getMenu().findItem(R.id.book).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.compress).setVisible(true);
+
+ if (description.endsWith(fileExtensionZip)
+ || description.endsWith(fileExtensionJar)
+ || description.endsWith(fileExtensionApk)
+ || description.endsWith(fileExtensionApks)
+ || description.endsWith(fileExtensionRar)
+ || description.endsWith(fileExtensionTar)
+ || description.endsWith(fileExtensionGzipTarLong)
+ || description.endsWith(fileExtensionGzipTarShort)
+ || description.endsWith(fileExtensionBzip2TarLong)
+ || description.endsWith(fileExtensionBzip2TarShort)
+ || description.endsWith(fileExtensionTarXz)
+ || description.endsWith(fileExtensionTarLzma)
+ || description.endsWith(fileExtension7zip)
+ || description.endsWith(fileExtensionGz)
+ || description.endsWith(fileExtensionBzip2)
+ || description.endsWith(fileExtensionLzma)
+ || description.endsWith(fileExtensionXz)) {
+ popupMenu.getMenu().findItem(R.id.ex).setVisible(true);
+ popupMenu.getMenu().findItem(R.id.compress).setVisible(false);
+ }
+ }
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
+ if (description.endsWith(CryptUtil.CRYPT_EXTENSION)
+ || description.endsWith(CryptUtil.AESCRYPT_EXTENSION)) {
+ popupMenu.getMenu().findItem(R.id.decrypt).setVisible(true);
+ } else {
+ popupMenu.getMenu().findItem(R.id.encrypt).setVisible(true);
+ }
+ }
+ if (rowItem.getMode() == OpenMode.TRASH_BIN) {
+ popupMenu.getMenu().findItem(R.id.return_select).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.cut).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.cpy).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.rename).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.encrypt).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.decrypt).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.about).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.compress).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.share).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.ex).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.book).setVisible(false);
+ popupMenu.getMenu().findItem(R.id.restore).setVisible(true);
+ popupMenu.getMenu().findItem(R.id.delete).setVisible(true);
+ }
+
+ popupMenu.show();
+ }
+
+ /**
+ * Helps in deciding whether to allow file modification or not, depending on the state of the
+ * copy/paste operation.
+ *
+ * @return true if there is an unfinished copy/paste operation, false otherwise.
+ */
+ private boolean hasPendingPasteOperation() {
+ MainActivity mainActivity = mainFragment.getMainActivity();
+ if (mainActivity == null) return false;
+ MainActivityActionMode mainActivityActionMode = mainActivity.mainActivityActionMode;
+ PasteHelper pasteHelper = mainActivityActionMode.getPasteHelper();
+
+ if (pasteHelper != null
+ && pasteHelper.getSnackbar() != null
+ && pasteHelper.getSnackbar().isShown()) {
+ Toast.makeText(
+ mainFragment.requireContext(),
+ mainFragment.getString(R.string.complete_paste_warning),
+ Toast.LENGTH_LONG)
+ .show();
+ return true;
+ }
+ return false;
+ }
+
+ private boolean getBoolean(String key) {
+ return preferenceActivity.getBoolean(key);
+ }
+
+ public static class ListItem {
+ public static final int CHECKED = 0, NOT_CHECKED = 1, UNCHECKABLE = 2;
+
+ /** Not null if {@link ListItem#specialTypeHasFile()} returns true */
+ @Nullable private final LayoutElementParcelable layoutElementParcelable;
+
+ private final @ListElemType int specialType;
+ private boolean checked;
+ private boolean animate;
+ private boolean shouldToggleDragChecked = true;
+
+ ListItem(@NonNull LayoutElementParcelable layoutElementParcelable) {
+ this(false, layoutElementParcelable);
+ }
+
+ ListItem(boolean isBack, @NonNull LayoutElementParcelable layoutElementParcelable) {
+ this.layoutElementParcelable = layoutElementParcelable;
+ specialType = isBack ? TYPE_BACK : TYPE_ITEM;
+ }
+
+ ListItem(@ListElemType int specialType) {
+ this.specialType = specialType;
+ this.layoutElementParcelable = null;
+ }
+
+ public void setChecked(boolean checked) {
+ if (specialType == TYPE_ITEM) this.checked = checked;
+ }
+
+ public int getChecked() {
+ if (checked) return CHECKED;
+ else if (specialType == TYPE_ITEM) return NOT_CHECKED;
+ else return UNCHECKABLE;
+ }
+
+ @Nullable
+ public LayoutElementParcelable getLayoutElementParcelable() {
+ return layoutElementParcelable;
+ }
+
+ /**
+ * Check that {@link ListItem#specialTypeHasFile()} returns true, if it does this method doesn't
+ * return null.
+ */
+ @NonNull
+ public LayoutElementParcelable requireLayoutElementParcelable() {
+ if (!specialTypeHasFile()) {
+ throw new IllegalStateException(
+ "Type of item " + specialType + " has no LayoutElementParcelable!");
+ }
+ return layoutElementParcelable;
+ }
+
+ public int getSpecialType() {
+ return this.specialType;
+ }
+
+ /**
+ * This method effectively has a contract that allows {@link
+ * ListItem#requireLayoutElementParcelable} afterwards without crashing.
+ */
+ public boolean specialTypeHasFile() {
+ return specialType == TYPE_ITEM || specialType == TYPE_BACK;
+ }
+
+ public boolean getShouldToggleDragChecked() {
+ return !checked && this.shouldToggleDragChecked;
+ }
+
+ public void toggleShouldToggleDragChecked() {
+ this.shouldToggleDragChecked = !this.shouldToggleDragChecked;
+ }
+
+ public void setAnimate(boolean animating) {
+ if (specialType == -1) this.animate = animating;
+ }
+
+ public boolean getAnimating() {
+ return animate;
+ }
+ }
+
+ public interface OnImageProcessed {
+ void onImageProcessed(boolean isImageBroken);
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/SearchRecyclerViewAdapter.kt b/app/src/main/java/com/amaze/filemanager/adapters/SearchRecyclerViewAdapter.kt
new file mode 100644
index 0000000..5c6afc3
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/SearchRecyclerViewAdapter.kt
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2014-2023 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters
+
+import android.content.Context
+import android.text.Spannable
+import android.text.SpannableString
+import android.text.style.ForegroundColorSpan
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.widget.AppCompatTextView
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import com.amaze.filemanager.R
+import com.amaze.filemanager.application.AppConfig
+import com.amaze.filemanager.asynchronous.asynctasks.searchfilesystem.SearchResult
+import com.amaze.filemanager.ui.activities.MainActivity
+import com.amaze.filemanager.ui.colors.ColorPreference
+import java.util.Random
+
+class SearchRecyclerViewAdapter :
+ ListAdapter(
+ object : DiffUtil.ItemCallback() {
+ override fun areItemsTheSame(
+ oldItem: SearchResult,
+ newItem: SearchResult,
+ ): Boolean {
+ return oldItem.file.path == newItem.file.path &&
+ oldItem.file.name == newItem.file.name
+ }
+
+ override fun areContentsTheSame(
+ oldItem: SearchResult,
+ newItem: SearchResult,
+ ): Boolean {
+ return oldItem.file.path == newItem.file.path &&
+ oldItem.file.name == newItem.file.name &&
+ oldItem.matchRange == newItem.matchRange
+ }
+ },
+ ) {
+ override fun onCreateViewHolder(
+ parent: ViewGroup,
+ type: Int,
+ ): ViewHolder {
+ val v: View =
+ LayoutInflater.from(parent.context)
+ .inflate(R.layout.search_row_item, parent, false)
+ return ViewHolder(v)
+ }
+
+ override fun onBindViewHolder(
+ holder: SearchRecyclerViewAdapter.ViewHolder,
+ position: Int,
+ ) {
+ val (file, matchResult) = getItem(position)
+
+ val colorPreference =
+ (AppConfig.getInstance().mainActivityContext as MainActivity).currentColorPreference
+
+ val fileName = SpannableString(file.name)
+ fileName.setSpan(
+ ForegroundColorSpan(colorPreference.accent),
+ matchResult.first,
+ matchResult.last + 1,
+ Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+ )
+
+ holder.fileNameTV.text = fileName
+ holder.filePathTV.text = file.path.substring(0, file.path.lastIndexOf("/"))
+
+ holder.colorView.setBackgroundColor(getRandomColor(holder.colorView.context))
+
+ if (file.isDirectory) {
+ holder.colorView.setBackgroundColor(colorPreference.primaryFirstTab)
+ } else {
+ holder.colorView.setBackgroundColor(colorPreference.accent)
+ }
+ }
+
+ inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
+ val fileNameTV: AppCompatTextView
+ val filePathTV: AppCompatTextView
+ val colorView: View
+
+ init {
+
+ fileNameTV = view.findViewById(R.id.searchItemFileNameTV)
+ filePathTV = view.findViewById(R.id.searchItemFilePathTV)
+ colorView = view.findViewById(R.id.searchItemSampleColorView)
+
+ view.setOnClickListener {
+
+ val (file, _) = getItem(adapterPosition)
+
+ if (!file.isDirectory) {
+ file.openFile(
+ AppConfig.getInstance().mainActivityContext as MainActivity?,
+ false,
+ )
+ } else {
+ (AppConfig.getInstance().mainActivityContext as MainActivity?)
+ ?.goToMain(file.path)
+ }
+
+ (AppConfig.getInstance().mainActivityContext as MainActivity?)
+ ?.appbar?.searchView?.hideSearchView()
+ }
+ }
+ }
+
+ private fun getRandomColor(context: Context): Int {
+ return ContextCompat.getColor(
+ context,
+ ColorPreference.availableColors[
+ Random().nextInt(
+ ColorPreference.availableColors.size - 1,
+ ),
+ ],
+ )
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/data/AppDataParcelable.kt b/app/src/main/java/com/amaze/filemanager/adapters/data/AppDataParcelable.kt
new file mode 100644
index 0000000..2ea826f
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/data/AppDataParcelable.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014-2021 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters.data
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+@Suppress("LongParameterList")
+class AppDataParcelable(
+ var label: String,
+ var path: String,
+ var splitPathList: List?,
+ var packageName: String,
+ var data: String,
+ var fileSize: String,
+ var size: Long,
+ var lastModification: Long,
+ var isSystemApp: Boolean,
+ var openFileParcelable: OpenFileParcelable?,
+) : Parcelable
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/data/AppDataSorter.kt b/app/src/main/java/com/amaze/filemanager/adapters/data/AppDataSorter.kt
new file mode 100644
index 0000000..93a8219
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/data/AppDataSorter.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2014-2021 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters.data
+
+import com.amaze.filemanager.utils.safeLet
+
+class AppDataSorter(var sort: Int, isAscending: Boolean) :
+ Comparator {
+ private val asc: Int = if (isAscending) 1 else -1
+
+ /**
+ * Compares two elements and return negative, zero and positive integer if first argument is
+ * less than, equal to or greater than second
+ */
+ override fun compare(
+ file1: AppDataParcelable?,
+ file2: AppDataParcelable?,
+ ): Int {
+ safeLet(file1, file2) {
+ f1, f2 ->
+ if (f1.isSystemApp != f2.isSystemApp) {
+ return if (f1.isSystemApp) -1 else 1
+ }
+
+ when (sort) {
+ SORT_NAME -> {
+ // sort by name
+ return asc * f1.label.compareTo(f2.label, ignoreCase = true)
+ }
+ SORT_MODIF -> {
+ // sort by last modified
+ return asc *
+ java.lang.Long.valueOf(f1.lastModification)
+ .compareTo(f2.lastModification)
+ }
+ SORT_SIZE -> {
+ // sort by size
+ return asc * java.lang.Long.valueOf(f1.size).compareTo(f2.size)
+ }
+ else -> return 0
+ }
+ }
+ return 0
+ }
+
+ companion object {
+ const val SORT_NAME = 0
+ const val SORT_MODIF = 1
+ const val SORT_SIZE = 2
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/data/CompressedObjectParcelable.java b/app/src/main/java/com/amaze/filemanager/adapters/data/CompressedObjectParcelable.java
new file mode 100644
index 0000000..c9332c1
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/data/CompressedObjectParcelable.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters.data;
+
+import java.util.Comparator;
+
+import com.amaze.filemanager.ui.icons.Icons;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * @author Emmanuel Messulam on 20/11/2017, at 15:26.
+ */
+public class CompressedObjectParcelable implements Parcelable {
+ public static final int TYPE_GOBACK = -1, TYPE_NORMAL = 0;
+
+ public final boolean directory;
+ public final int type;
+ public final String path;
+ public final String name;
+ public final long date, size;
+ public final int filetype;
+ public final IconDataParcelable iconData;
+
+ public CompressedObjectParcelable(String path, long date, long size, boolean directory) {
+ this.directory = directory;
+ this.type = TYPE_NORMAL;
+ this.path = path;
+ this.name = getNameForPath(path);
+ this.date = date;
+ this.size = size;
+ this.filetype = Icons.getTypeOfFile(path, directory);
+ this.iconData =
+ new IconDataParcelable(IconDataParcelable.IMAGE_RES, Icons.loadMimeIcon(path, directory));
+ }
+
+ /** TYPE_GOBACK instance */
+ public CompressedObjectParcelable() {
+ this.directory = true;
+ this.type = TYPE_GOBACK;
+ this.path = null;
+ this.name = null;
+ this.date = 0;
+ this.size = 0;
+ this.filetype = -1;
+ this.iconData = null;
+ }
+
+ @Override
+ public int describeContents() {
+ return 0;
+ }
+
+ public void writeToParcel(Parcel p1, int p2) {
+ p1.writeInt(type);
+ if (type != TYPE_GOBACK) {
+ p1.writeInt(directory ? 1 : 0);
+ p1.writeString(path);
+ p1.writeString(name);
+ p1.writeLong(size);
+ p1.writeLong(date);
+ p1.writeInt(filetype);
+ p1.writeParcelable(iconData, 0);
+ }
+ }
+
+ public static final Parcelable.Creator CREATOR =
+ new Parcelable.Creator() {
+ public CompressedObjectParcelable createFromParcel(Parcel in) {
+ return new CompressedObjectParcelable(in);
+ }
+
+ public CompressedObjectParcelable[] newArray(int size) {
+ return new CompressedObjectParcelable[size];
+ }
+ };
+
+ private CompressedObjectParcelable(Parcel im) {
+ type = im.readInt();
+ if (type == TYPE_GOBACK) {
+ directory = true;
+ path = null;
+ name = null;
+ date = 0;
+ size = 0;
+ filetype = -1;
+ iconData = null;
+ } else {
+ directory = im.readInt() == 1;
+ path = im.readString();
+ name = im.readString();
+ size = im.readLong();
+ date = im.readLong();
+ filetype = im.readInt();
+ iconData = im.readParcelable(IconDataParcelable.class.getClassLoader());
+ }
+ }
+
+ public static class Sorter implements Comparator {
+ @Override
+ public int compare(CompressedObjectParcelable file1, CompressedObjectParcelable file2) {
+ if (file1.type == CompressedObjectParcelable.TYPE_GOBACK) return -1;
+ else if (file2.type == CompressedObjectParcelable.TYPE_GOBACK) return 1;
+ else if (file1.directory && !file2.directory) {
+ return -1;
+ } else if (file2.directory && !(file1).directory) {
+ return 1;
+ } else return file1.path.compareToIgnoreCase(file2.path);
+ }
+ }
+
+ private String getNameForPath(String path) {
+ if (path.isEmpty()) return "";
+
+ final StringBuilder stringBuilder = new StringBuilder(path);
+ if (stringBuilder.charAt(path.length() - 1) == '/')
+ stringBuilder.deleteCharAt(path.length() - 1);
+
+ try {
+ return stringBuilder.substring(stringBuilder.lastIndexOf("/") + 1);
+ } catch (StringIndexOutOfBoundsException e) {
+ return path.substring(0, path.lastIndexOf("/"));
+ }
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof CompressedObjectParcelable) {
+ CompressedObjectParcelable otherObj = (CompressedObjectParcelable) obj;
+ return name.equals(otherObj.name)
+ && type == otherObj.type
+ && directory == otherObj.directory
+ && size == otherObj.size;
+ } else return false;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = (directory ? 1 : 0);
+ result = 31 * result + type;
+ result = 31 * result + name.hashCode();
+ result = 31 * result + (int) (size ^ (size >>> 32));
+ return result;
+ }
+}
diff --git a/app/src/main/java/com/amaze/filemanager/adapters/data/IconDataParcelable.java b/app/src/main/java/com/amaze/filemanager/adapters/data/IconDataParcelable.java
new file mode 100644
index 0000000..4a34d93
--- /dev/null
+++ b/app/src/main/java/com/amaze/filemanager/adapters/data/IconDataParcelable.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2014-2024 Arpit Khurana , Vishal Nehra ,
+ * Emmanuel Messulam, Raymond Lai and Contributors.
+ *
+ * This file is part of Amaze File Manager.
+ *
+ * Amaze File Manager is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+
+package com.amaze.filemanager.adapters.data;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import androidx.annotation.DrawableRes;
+
+/**
+ * Saves data on what should be loaded as an icon for LayoutElementParcelable
+ *
+ * @author Emmanuel Messulam on 6/12/2017, at 17:52.
+ */
+public class IconDataParcelable implements Parcelable {
+
+ public static final int IMAGE_RES = 0, IMAGE_FROMFILE = 1, IMAGE_FROMCLOUD = 2;
+
+ public final int type;
+ public final String path;
+ public final @DrawableRes int image;
+ public final @DrawableRes int loadingImage;
+ private boolean isImageBroken = false;
+
+ public IconDataParcelable(int type, @DrawableRes int img) {
+ if (type == IMAGE_FROMFILE) throw new IllegalArgumentException();
+ this.type = type;
+ this.image = img;
+ this.loadingImage = -1;
+ this.path = null;
+ }
+
+ public IconDataParcelable(int type, String path, @DrawableRes int loadingImages) {
+ if (type == IMAGE_RES) throw new IllegalArgumentException();
+ this.type = type;
+ this.path = path;
+ this.loadingImage = loadingImages;
+ this.image = -1;
+ }
+
+ public boolean isImageBroken() {
+ return isImageBroken;
+ }
+
+ public void setImageBroken(boolean imageBroken) {
+ isImageBroken = imageBroken;
+ }
+
+ @Override
+ public int describeContents() {
+ return 0;
+ }
+
+ @Override
+ public void writeToParcel(Parcel parcel, int i) {
+ parcel.writeInt(type);
+ parcel.writeString(path);
+ parcel.writeInt(image);
+ parcel.writeInt(loadingImage);
+ parcel.writeInt(isImageBroken ? 1 : 0);
+ }
+
+ public IconDataParcelable(Parcel im) {
+ type = im.readInt();
+ path = im.readString();
+ image = im.readInt();
+ loadingImage = im.readInt();
+ isImageBroken = im.readInt() == 1;
+ }
+
+ public static final Parcelable.Creator CREATOR =
+ new Parcelable.Creator
+
+
](https://play.google.com/store/apps/details?id=com.amaze.filemanager)
+[
](https://f-droid.org/packages/com.amaze.filemanager/)
+[
](https://apt.izzysoft.de/fdroid/index/apk/com.amaze.filemanager)
+[
](https://github.com/TeamAmaze/AmazeFileManager/releases/latest)
+[
](https://www.androidfilehost.com/?w=files&flid=73967)
+
+Contribute
+---
+You can contribute via one of the following ways:
+- Help us with the translations of either [Amaze File Manager](https://www.transifex.com/amaze/amaze-file-manager/) or [Amaze Utilities](https://crowdin.com/project/amaze-file-utilities)
+- [Contribute](https://github.com/TeamAmaze/AmazeFileManager/blob/release/4.0/CONTRIBUTING.md) directly to the code, help us in fixing the bugs / implement new features.
+
+_If we feel your contribution is a significant help to us, we'll award you a bounty with any of your preferred mode of payment._
+
+Support
+---
+
+
+
+Or buy the [Cloud Plugin](https://play.google.com/store/apps/details?id=com.filemanager.amazecloud) supports Google Drive™, Dropbox, OneDrive and Box accounts.
+Try our app - [Amaze File Utilities](https://play.google.com/store/apps/details?id=com.amaze.fileutilities) ([Fdroid](https://f-droid.org/en/packages/com.amaze.fileutilities/))
+1. List videos / images / music documents in your device in a interactive UI where you're able to group / sort and quickly jump to any headers.
+2. Open videos / images / music / documents (pdf / docx / epub) with inbuilt player.
+3. Share / delete / cast on your tv
+4. Analyse internal storage for junk files, duplicate files, large videos / old downloads / screenshots or recordings.
+5. Analyse and group images between memes, low light / blurry / selfies / group pics.
+7. Transfer files directly between two mobile devices on same wifi network using high speed peer to peer network
+8. Gesture support in image / video player, play in background, picture in picture mode, download subtitles within the player.
+
+Warning
+---
+
+Basic r/w operations might not work on external memory on Kitkat devices. Don't use cut/paste from or to external SD Card. You might lose your files.
+
+***Under the license we are not responsible for damages.***
+
+See our [Privacy Policy](https://github.com/TeamAmaze/AmazeFileManager/wiki/Privacy-Policy)
+
+Vendors/Developers
+----
+The device vendors/ROM developers are free to include Amaze apk pre-installed in system. There is no fee required; *but you must comply with the license* (for more information read the [GNU GPL v3](https://www.gnu.org/licenses/gpl-3.0.en.html) or newer).
+
+We strongly recommend using apk signed by us (either Play Store version or from AFH link above) so that users would be able to update directly from Play Store after distribution. Furthermore, a change in digital signature will break plug-ins.
+
+### License:
+
+ Copyright (C) 2014-2018 Arpit Khurana