> list) {
63 | File file = new File(getAbsolutePath(context), name) {
64 | @Override
65 | public boolean isDirectory() {
66 | return true;
67 | }
68 |
69 | @Override
70 | public boolean exists() {
71 | return false;
72 | }
73 | };
74 |
75 | if (PermissionUtils.needToGetPermission(context, file)) {
76 | list.add(0, FileInterface.fromFile(file));
77 | } else {
78 | list.add(0, FileInterface.fromDocumentFile(DocumentFile.fromTreeUri(context, PermissionUtils.getAndroidFolderUri(id, true))));
79 | }
80 | }
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/adapter/CacheManager.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.adapter;
2 |
3 | import android.net.Uri;
4 | import android.os.Parcelable;
5 |
6 | import java.util.List;
7 | import java.util.WeakHashMap;
8 |
9 | /**
10 | * 1. Cache loaded folder files
11 | * for a better performance on second load.
12 | *
13 | * 2. Cache RecyclerView's LayoutManager state
14 | * for showing the previous position when {@link Adapter#backFolder()} called.
15 | */
16 | final class CacheManager {
17 |
18 | private static final WeakHashMap>> cached = new WeakHashMap<>();
19 |
20 | public static List> get(Uri uri) {
21 | return cached.get(uri);
22 | }
23 |
24 | public static void put(Uri uri, List> files) {
25 | cached.put(uri, files);
26 | }
27 |
28 | public static List> remove(Uri uri) {
29 | return cached.remove(uri);
30 | }
31 |
32 | public static boolean contains(Uri uri) {
33 | return cached.containsKey(uri);
34 | }
35 |
36 | // ****
37 |
38 | private static final WeakHashMap cachedStates = new WeakHashMap<>();
39 |
40 | public static Parcelable getState(Uri uri) {
41 | return cachedStates.get(uri);
42 | }
43 |
44 | public static void saveState(Uri uri, Parcelable state) {
45 | cachedStates.put(uri, state);
46 | }
47 |
48 | public static Parcelable removeState(Uri uri) {
49 | return cachedStates.remove(uri);
50 | }
51 |
52 | public static boolean containsState(Uri uri) {
53 | return cachedStates.containsKey(uri);
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/adapter/FileInterface.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.adapter;
2 |
3 | import android.content.Context;
4 | import android.net.Uri;
5 |
6 | import androidx.annotation.NonNull;
7 | import androidx.documentfile.provider.DocumentFile;
8 |
9 | import com.aghajari.app.androidr.utils.FileUtil;
10 |
11 | import java.io.File;
12 | import java.util.ArrayList;
13 | import java.util.List;
14 |
15 | /**
16 | * a File interface to read File/DocumentFile easier.
17 | * Use DocumentFile on Android 11 (R) or newer.
18 | * Use File (normal) for older versions of android.
19 | */
20 | public class FileInterface {
21 | @NonNull
22 | protected final T file;
23 |
24 | private boolean isDirectory;
25 | private String cachedName;
26 | private long cachedLastModify;
27 | private int cacheListFilesCount = -1;
28 | private Uri cachedUri = null;
29 |
30 | FileInterface(@NonNull T file) {
31 | this.file = file;
32 |
33 | internalIsDirectory(); // do not comment this one
34 | // cache data
35 | internalName();
36 | getListFilesCount();
37 | lastModified();
38 | }
39 |
40 | public static FileInterface fromDocumentFile(@NonNull DocumentFile documentFile) {
41 | return new FileInterface<>(documentFile);
42 | }
43 |
44 | public static FileInterface fromFile(@NonNull File file) {
45 | return new FileInterface<>(file);
46 | }
47 |
48 | DocumentFile asDocumentFile() {
49 | return (DocumentFile) file;
50 | }
51 |
52 | File asFile() {
53 | return (File) file;
54 | }
55 |
56 | public boolean canRead() {
57 | if (file instanceof DocumentFile)
58 | return asDocumentFile().canRead();
59 | else
60 | return asFile().canRead();
61 | }
62 |
63 | public boolean canWrite() {
64 | if (file instanceof DocumentFile)
65 | return asDocumentFile().canWrite();
66 | else
67 | return asFile().canWrite();
68 | }
69 |
70 | public boolean isFile() {
71 | if (file instanceof DocumentFile)
72 | return asDocumentFile().isFile();
73 | else
74 | return asFile().isFile();
75 | }
76 |
77 | protected void internalUri() {
78 | if (cachedUri == null)
79 | return;
80 | Uri uri;
81 | if (file instanceof DocumentFile)
82 | uri = asDocumentFile().getUri();
83 | else
84 | uri = Uri.fromFile(asFile());
85 | if (!uri.equals(cachedUri)) {
86 | if (CacheManager.contains(cachedUri)) {
87 | CacheManager.put(uri, CacheManager.remove(cachedUri));
88 | }
89 | if (CacheManager.containsState(cachedUri)) {
90 | CacheManager.saveState(uri, CacheManager.removeState(cachedUri));
91 | }
92 | }
93 | cachedUri = uri;
94 | }
95 |
96 | public Uri getUri() {
97 | if (cachedUri != null)
98 | return cachedUri;
99 |
100 | if (file instanceof DocumentFile)
101 | return cachedUri = asDocumentFile().getUri();
102 | else
103 | return cachedUri = Uri.fromFile(asFile());
104 | }
105 |
106 | public boolean delete() {
107 | if (file instanceof DocumentFile)
108 | return asDocumentFile().delete();
109 | else
110 | return asFile().delete();
111 | }
112 |
113 | public boolean renameTo(String displayName) {
114 | boolean res;
115 | if (file instanceof DocumentFile)
116 | res = asDocumentFile().renameTo(displayName);
117 | else
118 | res = asFile().renameTo(new File(asFile().getParent(), displayName));
119 | cachedName = internalName();
120 | cachedLastModify = lastModified();
121 | internalUri(); //update caches
122 | return res;
123 | }
124 |
125 | protected void internalIsDirectory() {
126 | if (file instanceof DocumentFile) {
127 | isDirectory = asDocumentFile().isDirectory();
128 | } else {
129 | isDirectory = asFile().isDirectory();
130 | }
131 | }
132 |
133 | public boolean isDirectory() {
134 | return isDirectory;
135 | }
136 |
137 | public String getAbsolutePath(Context context) {
138 | if (file instanceof DocumentFile)
139 | return FileUtil.getPath(context, asDocumentFile().getUri());
140 | else
141 | return asFile().getAbsolutePath();
142 | }
143 |
144 | public boolean exists() {
145 | if (file instanceof DocumentFile)
146 | return asDocumentFile().exists();
147 | else
148 | return asFile().exists();
149 | }
150 |
151 | protected String internalName() {
152 | if (file instanceof DocumentFile)
153 | return cachedName = asDocumentFile().getName();
154 | else
155 | return cachedName = asFile().getName();
156 | }
157 |
158 | public String getName() {
159 | if (cachedName == null)
160 | return internalName();
161 | return cachedName;
162 | }
163 |
164 | public long length() {
165 | if (file instanceof DocumentFile)
166 | return asDocumentFile().length();
167 | else
168 | return asFile().length();
169 | }
170 |
171 | public long lastModified() {
172 | if (cachedLastModify >= 0)
173 | return cachedLastModify;
174 |
175 | if (file instanceof DocumentFile)
176 | return cachedLastModify = asDocumentFile().lastModified();
177 | else
178 | return cachedLastModify = asFile().lastModified();
179 | }
180 |
181 | protected List> internalListFiles(Context context) {
182 | Uri uri = getUri();
183 | if (CacheManager.get(uri) != null) {
184 | return CacheManager.get(uri);
185 | }
186 |
187 | List> list = new ArrayList<>();
188 | if (file instanceof DocumentFile) {
189 | if (asDocumentFile().listFiles() == null)
190 | return null;
191 |
192 | for (DocumentFile f : asDocumentFile().listFiles()) {
193 | if (!Adapter.SHOW_HIDDEN_FILES && f.getName().startsWith("."))
194 | continue;
195 | list.add(FileInterface.fromDocumentFile(f));
196 | }
197 | } else {
198 | if (asFile().listFiles() == null)
199 | return null;
200 |
201 | for (File f : asFile().listFiles()) {
202 | if (!Adapter.SHOW_HIDDEN_FILES && f.getName().startsWith("."))
203 | continue;
204 | list.add(FileInterface.fromFile(f));
205 | }
206 | }
207 | CacheManager.put(uri, list);
208 | return list;
209 | }
210 |
211 | public FileInterface[] listFiles(Context context) {
212 | return internalListFiles(context).toArray(new FileInterface[0]);
213 | }
214 |
215 | public int getListFilesCount() {
216 | if (cacheListFilesCount >= 0)
217 | return cacheListFilesCount;
218 |
219 | if (file instanceof DocumentFile) {
220 | if (asDocumentFile().listFiles() == null)
221 | return cacheListFilesCount = 0;
222 |
223 | if (Adapter.SHOW_HIDDEN_FILES) {
224 | return cacheListFilesCount = asDocumentFile().listFiles().length;
225 | } else {
226 | cacheListFilesCount = 0;
227 | for (DocumentFile f : asDocumentFile().listFiles()) {
228 | if (!Adapter.SHOW_HIDDEN_FILES && f.getName().startsWith(".")) continue;
229 | cacheListFilesCount++;
230 | }
231 | return cacheListFilesCount;
232 | }
233 | } else {
234 | if (asFile().listFiles() == null)
235 | return cacheListFilesCount = 0;
236 |
237 | if (Adapter.SHOW_HIDDEN_FILES) {
238 | return cacheListFilesCount = asFile().listFiles().length;
239 | } else {
240 | cacheListFilesCount = 0;
241 | for (File f : asFile().listFiles()) {
242 | if (!Adapter.SHOW_HIDDEN_FILES && f.getName().startsWith(".")) continue;
243 | cacheListFilesCount++;
244 | }
245 | return cacheListFilesCount;
246 | }
247 | }
248 | }
249 |
250 | public FileInterface getParentFile() {
251 | if (file instanceof DocumentFile) {
252 | if (asDocumentFile().getParentFile() == null) return null;
253 | return FileInterface.fromDocumentFile(asDocumentFile().getParentFile());
254 | } else {
255 | if (asFile().getParentFile() == null) return null;
256 | return FileInterface.fromFile(asFile().getParentFile());
257 | }
258 | }
259 |
260 | @Override
261 | public boolean equals(Object o) {
262 | if (this == o) return true;
263 | if (o == null || getClass() != o.getClass()) return false;
264 |
265 | FileInterface that = (FileInterface) o;
266 | return file.equals(that.file);
267 | }
268 |
269 | @Override
270 | public int hashCode() {
271 | return file.hashCode();
272 | }
273 | }
274 |
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/adapter/OpenFolderTask.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.adapter;
2 |
3 | import android.net.Uri;
4 | import android.os.AsyncTask;
5 | import android.os.Handler;
6 | import android.view.View;
7 |
8 | import androidx.documentfile.provider.DocumentFile;
9 |
10 | import java.io.File;
11 | import java.util.ArrayList;
12 | import java.util.List;
13 |
14 | /**
15 | * Task to load a folder files with progress.
16 | */
17 | final class OpenFolderTask extends AsyncTask, Integer, List>> {
18 | final Adapter adapter;
19 | boolean loading = true;
20 |
21 | OpenFolderTask(Adapter adapter) {
22 | super();
23 | this.adapter = adapter;
24 | }
25 |
26 | @Override
27 | protected List> doInBackground(FileInterface... file) {
28 | Uri uri = file[0].getUri();
29 | if (CacheManager.get(uri) != null) {
30 | return CacheManager.get(uri);
31 | }
32 |
33 | List> list = new ArrayList<>();
34 | int max;
35 |
36 | if (file[0].file instanceof DocumentFile) {
37 | if (file[0].asDocumentFile().listFiles() == null)
38 | return null;
39 |
40 | DocumentFile[] files = file[0].asDocumentFile().listFiles();
41 | max = files.length;
42 | for (int i = 1; i <= max; i++) {
43 | if (isCancelled())
44 | return null;
45 | if (!Adapter.SHOW_HIDDEN_FILES && files[i - 1].getName().startsWith("."))
46 | continue;
47 |
48 | publishProgress(i, max);
49 | list.add(FileInterface.fromDocumentFile(files[i - 1]));
50 | }
51 | } else {
52 | if (file[0].asFile().listFiles() == null)
53 | return null;
54 |
55 | File[] files = file[0].asFile().listFiles();
56 | max = files.length;
57 | for (int i = 1; i <= max; i++) {
58 | if (isCancelled())
59 | return null;
60 | if (!Adapter.SHOW_HIDDEN_FILES && files[i - 1].getName().startsWith("."))
61 | continue;
62 |
63 | publishProgress(i, max);
64 | list.add(FileInterface.fromFile(files[i - 1]));
65 | }
66 | }
67 | CacheManager.put(uri, list);
68 |
69 | if (file[0] instanceof AndroidFolderInterface) {
70 | ((AndroidFolderInterface) file[0]).checkDataAndObb(adapter.context, list);
71 | }
72 | return list;
73 | }
74 |
75 | private final static Handler handler = new Handler();
76 |
77 | @Override
78 | protected void onPreExecute() {
79 | super.onPreExecute();
80 | handler.postDelayed(new Runnable() {
81 | @Override
82 | public void run() {
83 | if (loading)
84 | adapter.loading.setVisibility(View.VISIBLE);
85 | }
86 | }, 100);
87 | }
88 |
89 | @Override
90 | protected void onPostExecute(List> files) {
91 | super.onPostExecute(files);
92 | loading = false;
93 | if (!isCancelled() && files != null) {
94 | adapter.list.addAll(files);
95 | adapter.loading.setVisibility(View.GONE);
96 | adapter.notifyDataSetChanged();
97 | adapter.loaded();
98 | }
99 | }
100 |
101 | @Override
102 | protected void onProgressUpdate(Integer... values) {
103 | super.onProgressUpdate(values);
104 | if (!isCancelled()) {
105 | adapter.loading_progress.setText(values[0] + "/" + values[1]);
106 | }
107 | }
108 |
109 | @Override
110 | protected void onCancelled() {
111 | super.onCancelled();
112 | loading = false;
113 | adapter.loading.setVisibility(View.GONE);
114 | adapter.notifyDataSetChanged();
115 | }
116 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/utils/DividerItemDecoration.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.utils;
2 |
3 | import android.content.Context;
4 | import android.content.res.TypedArray;
5 | import android.graphics.Canvas;
6 | import android.graphics.Rect;
7 | import android.graphics.drawable.Drawable;
8 | import android.view.View;
9 | import android.widget.LinearLayout;
10 |
11 | import androidx.annotation.NonNull;
12 | import androidx.core.view.ViewCompat;
13 | import androidx.recyclerview.widget.RecyclerView;
14 |
15 | /**
16 | * DividerItemDecoration is a {@link RecyclerView.ItemDecoration} that can be used as a divider
17 | * between items of a {@link androidx.recyclerview.widget.LinearLayoutManager}. It supports both {@link #HORIZONTAL} and
18 | * {@link #VERTICAL} orientations.
19 | *
20 | *
21 | * mDividerItemDecoration = new DividerItemDecoration(recyclerView.getContext(),
22 | * mLayoutManager.getOrientation());
23 | * recyclerView.addItemDecoration(mDividerItemDecoration);
24 | *
25 | */
26 | public class DividerItemDecoration extends RecyclerView.ItemDecoration {
27 | public static final int HORIZONTAL = LinearLayout.HORIZONTAL;
28 | public static final int VERTICAL = LinearLayout.VERTICAL;
29 | private static final int[] ATTRS = new int[]{android.R.attr.listDivider};
30 | private Drawable mDivider;
31 |
32 | private final int[] padding;
33 |
34 | /**
35 | * Current orientation. Either {@link #HORIZONTAL} or {@link #VERTICAL}.
36 | */
37 | private int mOrientation;
38 | private final Rect mBounds = new Rect();
39 |
40 | /**
41 | * Creates a divider {@link RecyclerView.ItemDecoration} that can be used with a
42 | * {@link androidx.recyclerview.widget.LinearLayoutManager}.
43 | *
44 | * @param context Current context, it will be used to access resources.
45 | * @param orientation Divider orientation. Should be {@link #HORIZONTAL} or {@link #VERTICAL}.
46 | */
47 | public DividerItemDecoration(Context context, int orientation, int[] padding) {
48 | final TypedArray a = context.obtainStyledAttributes(ATTRS);
49 | mDivider = a.getDrawable(0);
50 | a.recycle();
51 | setOrientation(orientation);
52 | this.padding = padding;
53 | }
54 |
55 | /**
56 | * Sets the orientation for this divider. This should be called if
57 | * {@link RecyclerView.LayoutManager} changes orientation.
58 | *
59 | * @param orientation {@link #HORIZONTAL} or {@link #VERTICAL}
60 | */
61 | public void setOrientation(int orientation) {
62 | if (orientation != HORIZONTAL && orientation != VERTICAL) {
63 | throw new IllegalArgumentException(
64 | "Invalid orientation. It should be either HORIZONTAL or VERTICAL");
65 | }
66 | mOrientation = orientation;
67 | }
68 |
69 | /**
70 | * Sets the {@link Drawable} for this divider.
71 | *
72 | * @param drawable Drawable that should be used as a divider.
73 | */
74 | public void setDrawable(@NonNull Drawable drawable) {
75 | if (drawable == null) {
76 | throw new IllegalArgumentException("Drawable cannot be null.");
77 | }
78 | mDivider = drawable;
79 | }
80 |
81 | @Override
82 | public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
83 | if (parent.getLayoutManager() == null) {
84 | return;
85 | }
86 | if (mOrientation == VERTICAL) {
87 | drawVertical(c, parent);
88 | } else {
89 | drawHorizontal(c, parent);
90 | }
91 | }
92 |
93 | private void drawVertical(Canvas canvas, RecyclerView parent) {
94 | canvas.save();
95 | final int left;
96 | final int right;
97 | if (parent.getClipToPadding()) {
98 | left = parent.getPaddingLeft() + padding[0];
99 | right = parent.getWidth() - parent.getPaddingRight() - padding[1];
100 | canvas.clipRect(left, parent.getPaddingTop(), right,
101 | parent.getHeight() - parent.getPaddingBottom());
102 | } else {
103 | left = padding[0];
104 | right = parent.getWidth() - padding[1];
105 | }
106 | final int childCount = parent.getChildCount();
107 | for (int i = 0; i < childCount; i++) {
108 | final View child = parent.getChildAt(i);
109 |
110 | //skip last item
111 | if (parent.getChildViewHolder(child).getAdapterPosition() == parent.getAdapter().getItemCount() - 1)
112 | continue;
113 |
114 | parent.getDecoratedBoundsWithMargins(child, mBounds);
115 | final int bottom = mBounds.bottom + Math.round(ViewCompat.getTranslationY(child));
116 | final int top = bottom - mDivider.getIntrinsicHeight();
117 | mDivider.setBounds(left, top, right, bottom);
118 | mDivider.draw(canvas);
119 | }
120 | canvas.restore();
121 | }
122 |
123 | private void drawHorizontal(Canvas canvas, RecyclerView parent) {
124 | canvas.save();
125 | final int top;
126 | final int bottom;
127 | if (parent.getClipToPadding()) {
128 | top = parent.getPaddingTop() + padding[0];
129 | bottom = parent.getHeight() - parent.getPaddingBottom() - padding[1];
130 | canvas.clipRect(parent.getPaddingLeft(), top,
131 | parent.getWidth() - parent.getPaddingRight(), bottom);
132 | } else {
133 | top = padding[0];
134 | bottom = parent.getHeight() - padding[1];
135 | }
136 | final int childCount = parent.getChildCount();
137 | for (int i = 0; i < childCount; i++) {
138 | final View child = parent.getChildAt(i);
139 |
140 | //skip last item
141 | if (parent.getChildViewHolder(child).getAdapterPosition() == parent.getAdapter().getItemCount() - 1)
142 | continue;
143 |
144 | parent.getLayoutManager().getDecoratedBoundsWithMargins(child, mBounds);
145 | final int right = mBounds.right + Math.round(ViewCompat.getTranslationX(child));
146 | final int left = right - mDivider.getIntrinsicWidth();
147 | mDivider.setBounds(left, top, right, bottom);
148 | mDivider.draw(canvas);
149 | }
150 | canvas.restore();
151 | }
152 |
153 | @Override
154 | public void getItemOffsets(Rect outRect, View view, RecyclerView parent,
155 | RecyclerView.State state) {
156 | if (mOrientation == VERTICAL) {
157 | outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
158 | } else {
159 | outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
160 | }
161 | }
162 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/utils/EmptyItemDecoration.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.utils;
2 |
3 | import android.app.Activity;
4 | import android.graphics.Canvas;
5 | import android.graphics.Paint;
6 | import android.graphics.Rect;
7 |
8 | import androidx.recyclerview.widget.RecyclerView;
9 |
10 | import com.aghajari.app.androidr.adapter.Adapter;
11 |
12 | public class EmptyItemDecoration extends RecyclerView.ItemDecoration {
13 | Paint paint;
14 |
15 | public EmptyItemDecoration(int size) {
16 | paint = new Paint();
17 | //paint.setColor(Color.LTGRAY);
18 | //paint.setTypeface(Typeface.DEFAULT_BOLD);
19 | paint.setTextSize(size);
20 | }
21 |
22 | @Override
23 | public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
24 | if (parent.getLayoutManager() == null)
25 | return;
26 |
27 | if (parent.getAdapter().getItemCount() == 0
28 | && !PermissionUtils.hasAllPermissions((Activity) parent.getContext()))
29 | drawCenter(c,paint,"Permissions Needed!");
30 |
31 | else if (((Adapter) parent.getAdapter()).isEmpty())
32 | drawCenter(c, paint, "No files");
33 | }
34 |
35 | private final Rect r = new Rect();
36 |
37 | private void drawCenter(Canvas canvas, Paint paint, String text) {
38 | canvas.getClipBounds(r);
39 | int cHeight = r.height();
40 | int cWidth = r.width();
41 | paint.setTextAlign(Paint.Align.LEFT);
42 | paint.getTextBounds(text, 0, text.length(), r);
43 | float x = cWidth / 2f - r.width() / 2f - r.left;
44 | float y = cHeight / 2f + r.height() / 2f - r.bottom;
45 | canvas.drawText(text, x, y, paint);
46 | }
47 |
48 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/utils/FileUtil.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.utils;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.annotation.TargetApi;
5 | import android.content.ContentUris;
6 | import android.content.Context;
7 | import android.database.Cursor;
8 | import android.net.Uri;
9 | import android.os.Build;
10 | import android.os.Environment;
11 | import android.os.storage.StorageManager;
12 | import android.os.storage.StorageVolume;
13 | import android.provider.DocumentsContract;
14 | import android.provider.MediaStore;
15 |
16 | import androidx.annotation.Nullable;
17 |
18 | import java.io.File;
19 | import java.lang.reflect.Array;
20 | import java.lang.reflect.Method;
21 | import java.text.CharacterIterator;
22 | import java.text.StringCharacterIterator;
23 | import java.util.List;
24 |
25 | /**
26 | * Sources :
27 | * https://stackoverflow.com/a/36162691
28 | * https://stackoverflow.com/a/41520090
29 | */
30 | public final class FileUtil {
31 |
32 | private static final String PRIMARY_VOLUME_NAME = "primary";
33 |
34 | @Nullable
35 | public static String getFullPathFromTreeUri(@Nullable final Uri treeUri, Context con) {
36 | if (treeUri == null) return null;
37 | String volumePath = getVolumePath(getVolumeIdFromTreeUri(treeUri), con);
38 | if (volumePath == null) return File.separator;
39 | if (volumePath.endsWith(File.separator))
40 | volumePath = volumePath.substring(0, volumePath.length() - 1);
41 |
42 | String documentPath = getDocumentPathFromTreeUri(treeUri);
43 | if (documentPath.endsWith(File.separator))
44 | documentPath = documentPath.substring(0, documentPath.length() - 1);
45 |
46 | if (documentPath.length() > 0) {
47 | if (documentPath.startsWith(File.separator))
48 | return volumePath + documentPath;
49 | else
50 | return volumePath + File.separator + documentPath;
51 | } else return volumePath;
52 | }
53 |
54 |
55 | private static String getVolumePath(final String volumeId, Context context) {
56 | if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
57 | return null;
58 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
59 | return getVolumePathForAndroid11AndAbove(volumeId, context);
60 | else
61 | return getVolumePathBeforeAndroid11(volumeId, context);
62 | }
63 |
64 |
65 | private static String getVolumePathBeforeAndroid11(final String volumeId, Context context) {
66 | try {
67 | StorageManager mStorageManager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
68 | Class storageVolumeClazz = Class.forName("android.os.storage.StorageVolume");
69 | Method getVolumeList = mStorageManager.getClass().getMethod("getVolumeList");
70 | Method getUuid = storageVolumeClazz.getMethod("getUuid");
71 | Method getPath = storageVolumeClazz.getMethod("getPath");
72 | Method isPrimary = storageVolumeClazz.getMethod("isPrimary");
73 | Object result = getVolumeList.invoke(mStorageManager);
74 |
75 | final int length = Array.getLength(result);
76 | for (int i = 0; i < length; i++) {
77 | Object storageVolumeElement = Array.get(result, i);
78 | String uuid = (String) getUuid.invoke(storageVolumeElement);
79 | Boolean primary = (Boolean) isPrimary.invoke(storageVolumeElement);
80 |
81 | if (primary && PRIMARY_VOLUME_NAME.equals(volumeId)) // primary volume?
82 | return (String) getPath.invoke(storageVolumeElement);
83 |
84 | if (uuid != null && uuid.equals(volumeId)) // other volumes?
85 | return (String) getPath.invoke(storageVolumeElement);
86 | }
87 | // not found.
88 | return null;
89 | } catch (Exception ex) {
90 | return null;
91 | }
92 | }
93 |
94 | @TargetApi(Build.VERSION_CODES.R)
95 | private static String getVolumePathForAndroid11AndAbove(final String volumeId, Context context) {
96 | try {
97 | StorageManager mStorageManager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
98 | List storageVolumes = mStorageManager.getStorageVolumes();
99 | for (StorageVolume storageVolume : storageVolumes) {
100 | // primary volume?
101 | if (storageVolume.isPrimary() && PRIMARY_VOLUME_NAME.equals(volumeId))
102 | return storageVolume.getDirectory().getPath();
103 |
104 | // other volumes?
105 | String uuid = storageVolume.getUuid();
106 | if (uuid != null && uuid.equals(volumeId))
107 | return storageVolume.getDirectory().getPath();
108 |
109 | }
110 | // not found.
111 | return null;
112 | } catch (Exception ex) {
113 | return null;
114 | }
115 | }
116 |
117 | @TargetApi(Build.VERSION_CODES.LOLLIPOP)
118 | private static String getVolumeIdFromTreeUri(final Uri treeUri) {
119 | final String docId = DocumentsContract.getTreeDocumentId(treeUri);
120 | final String[] split = docId.split(":");
121 | if (split.length > 0) return split[0];
122 | else return null;
123 | }
124 |
125 |
126 | @TargetApi(Build.VERSION_CODES.LOLLIPOP)
127 | private static String getDocumentPathFromTreeUri(final Uri treeUri) {
128 | final String docId = DocumentsContract.getTreeDocumentId(treeUri);
129 | final String[] split = docId.split(":");
130 | if ((split.length >= 2) && (split[1] != null)) return split[1];
131 | else return File.separator;
132 | }
133 |
134 | /*
135 | * Gets the file path of the given Uri.
136 | */
137 | @SuppressLint("NewApi")
138 | public static String getPath(Context context, Uri uri) {
139 | final boolean needToCheckUri = Build.VERSION.SDK_INT >= 19;
140 | String selection = null;
141 | String[] selectionArgs = null;
142 | // Uri is different in versions after KITKAT (Android 4.4), we need to
143 | // deal with different Uris.
144 | if (needToCheckUri && DocumentsContract.isDocumentUri(context.getApplicationContext(), uri)) {
145 | if (isExternalStorageDocument(uri)) {
146 | final String docId = DocumentsContract.getDocumentId(uri);
147 | final String[] split = docId.split(":");
148 | return Environment.getExternalStorageDirectory() + "/" + split[1];
149 | } else if (isDownloadsDocument(uri)) {
150 | final String id = DocumentsContract.getDocumentId(uri);
151 | uri = ContentUris.withAppendedId(
152 | Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
153 | } else if (isMediaDocument(uri)) {
154 | final String docId = DocumentsContract.getDocumentId(uri);
155 | final String[] split = docId.split(":");
156 | final String type = split[0];
157 | if ("image".equals(type)) {
158 | uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
159 | } else if ("video".equals(type)) {
160 | uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
161 | } else if ("audio".equals(type)) {
162 | uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
163 | }
164 | selection = "_id=?";
165 | selectionArgs = new String[]{split[1]};
166 | }
167 | }
168 | if ("content".equalsIgnoreCase(uri.getScheme())) {
169 | String[] projection = {MediaStore.Images.Media.DATA};
170 | Cursor cursor = null;
171 | try {
172 | cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
173 | int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
174 | if (cursor.moveToFirst()) {
175 | return cursor.getString(column_index);
176 | }
177 | } catch (Exception e) {
178 | }
179 | } else if ("file".equalsIgnoreCase(uri.getScheme())) {
180 | return uri.getPath();
181 | }
182 | return null;
183 | }
184 |
185 |
186 | /**
187 | * @param uri The Uri to check.
188 | * @return Whether the Uri authority is ExternalStorageProvider.
189 | */
190 | private static boolean isExternalStorageDocument(Uri uri) {
191 | return "com.android.externalstorage.documents".equals(uri.getAuthority());
192 | }
193 |
194 | /**
195 | * @param uri The Uri to check.
196 | * @return Whether the Uri authority is DownloadsProvider.
197 | */
198 | private static boolean isDownloadsDocument(Uri uri) {
199 | return "com.android.providers.downloads.documents".equals(uri.getAuthority());
200 | }
201 |
202 | /**
203 | * @param uri The Uri to check.
204 | * @return Whether the Uri authority is MediaProvider.
205 | */
206 | private static boolean isMediaDocument(Uri uri) {
207 | return "com.android.providers.media.documents".equals(uri.getAuthority());
208 | }
209 |
210 | public static String humanReadableByteCountSI(long bytes) {
211 | if (-1000 < bytes && bytes < 1000) {
212 | return bytes + " B";
213 | }
214 | CharacterIterator ci = new StringCharacterIterator("kMGTPE");
215 | while (bytes <= -999_950 || bytes >= 999_950) {
216 | bytes /= 1000;
217 | ci.next();
218 | }
219 | return String.format("%.1f %cB", bytes / 1000.0, ci.current());
220 | }
221 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/aghajari/app/androidr/utils/PermissionUtils.java:
--------------------------------------------------------------------------------
1 | package com.aghajari.app.androidr.utils;
2 |
3 | import android.app.Activity;
4 | import android.content.Context;
5 | import android.content.Intent;
6 | import android.content.UriPermission;
7 | import android.content.pm.PackageManager;
8 | import android.net.Uri;
9 | import android.os.Build;
10 | import android.os.Environment;
11 | import android.provider.DocumentsContract;
12 | import android.provider.Settings;
13 |
14 | import androidx.core.app.ActivityCompat;
15 | import androidx.core.content.ContextCompat;
16 |
17 | import com.aghajari.app.androidr.adapter.FileInterface;
18 |
19 | import java.io.File;
20 |
21 | import static android.Manifest.permission.READ_EXTERNAL_STORAGE;
22 | import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE;
23 | import static android.os.Build.VERSION.SDK_INT;
24 |
25 | /**
26 | * A helper class to check and request read/write/manage storage permissions.
27 | * Supports all version of androids.
28 | */
29 | public final class PermissionUtils {
30 |
31 | public static final String ANDROID = "primary:Android";
32 | public static final String ANDROID_DATA = "primary:Android/data";
33 | public static final String ANDROID_OBB = "primary:Android/obb";
34 |
35 | /**
36 | * @return true if you have the permissions.
37 | */
38 | public static boolean checkAndRequestPermissions(Activity context, int requestCodeFolder, int requestCodePermission) {
39 | if (!PermissionUtils.checkPermissions(context)) {
40 | PermissionUtils.requestPermissions(context, requestCodePermission);
41 | return false;
42 | } else if (!PermissionUtils.checkAndroidFolderPermission(context, PermissionUtils.ANDROID)) {
43 | PermissionUtils.requestAndroidFolderPermission(context, requestCodeFolder, PermissionUtils.ANDROID);
44 | return false;
45 | }
46 | return true;
47 | }
48 |
49 | /**
50 | * @return true if you have all of the permissions to manage storage.
51 | */
52 | public static boolean hasAllPermissions(Activity context) {
53 | return PermissionUtils.checkAndroidFolderPermission(context, PermissionUtils.ANDROID)
54 | && PermissionUtils.checkPermissions(context);
55 | }
56 |
57 | /**
58 | * @return true if Android version is higher or equals 30
59 | */
60 | public static boolean needToUseDocumentFile() {
61 | return Build.VERSION.SDK_INT >= Build.VERSION_CODES.R;
62 | }
63 |
64 | /**
65 | * @return true if you have access to write/read/manage storage.
66 | */
67 | public static boolean checkPermissions(Context context) {
68 | if (SDK_INT >= Build.VERSION_CODES.R) {
69 | return Environment.isExternalStorageManager();
70 | } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
71 | int result = ContextCompat.checkSelfPermission(context, READ_EXTERNAL_STORAGE);
72 | int result1 = ContextCompat.checkSelfPermission(context, WRITE_EXTERNAL_STORAGE);
73 | return result == PackageManager.PERMISSION_GRANTED && result1 == PackageManager.PERMISSION_GRANTED;
74 | }
75 | return true;
76 | }
77 |
78 | /**
79 | * request permissions for write/read/manage storage.
80 | */
81 | public static void requestPermissions(Activity context, int requestCode) {
82 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
83 | Intent i = new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION);
84 | i.setData(Uri.parse("package:" + context.getPackageName()));
85 | context.startActivityForResult(i, requestCode);
86 |
87 | } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
88 |
89 | ActivityCompat.requestPermissions(context, new String[]{
90 | READ_EXTERNAL_STORAGE,
91 | WRITE_EXTERNAL_STORAGE}
92 | , requestCode);
93 | }
94 | }
95 |
96 | /**
97 | * {@link #ANDROID} = /storage/emulated/0/Android
98 | * {@link #ANDROID_DATA} = /storage/emulated/0/Android/data
99 | * {@link #ANDROID_OBB} = /storage/emulated/0/Android/obb
100 | *
101 | * @return android folder uri.
102 | */
103 | public static Uri getAndroidFolderUri(String id, boolean tree) {
104 | if (tree)
105 | return DocumentsContract.buildTreeDocumentUri("com.android.externalstorage.documents", id);
106 | else
107 | return DocumentsContract.buildDocumentUri("com.android.externalstorage.documents", id);
108 | }
109 |
110 | /**
111 | * @return true if you have access to manage Android folders.
112 | */
113 | public static boolean checkAndroidFolderPermission(Context context, String id) {
114 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
115 | Uri android_tree_uri = getAndroidFolderUri(id, true);
116 |
117 | for (UriPermission uriPermission : context.getContentResolver().getPersistedUriPermissions()) {
118 | if (uriPermission.getUri().equals(android_tree_uri) && uriPermission.isReadPermission())
119 | return true;
120 | }
121 | return false;
122 | } else {
123 | return true;
124 | }
125 | }
126 |
127 | /**
128 | * request permission to manage Android folders.
129 | */
130 | public static void requestAndroidFolderPermission(Activity context, int requestCode, String id) {
131 | Intent i = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE)
132 | .putExtra("android.provider.extra.SHOW_ADVANCED", true)
133 | .putExtra("android.content.extra.SHOW_ADVANCED", true)
134 | .putExtra(DocumentsContract.EXTRA_INITIAL_URI, getAndroidFolderUri(id, false));
135 | context.startActivityForResult(i, requestCode);
136 | }
137 |
138 | /**
139 | * Check if needs to get permission for an Android folder (data/obb)
140 | */
141 | public static boolean needToGetPermission(Context context, FileInterface file) {
142 | return (file.getName().equalsIgnoreCase("obb")
143 | && !checkAndroidFolderPermission(context, ANDROID_OBB))
144 | || (file.getName().equalsIgnoreCase("data")
145 | && !checkAndroidFolderPermission(context, ANDROID_DATA));
146 | }
147 |
148 | /**
149 | * Check if needs to get permission for an Android folder (data/obb)
150 | */
151 | public static boolean needToGetPermission(Context context, File file) {
152 | return (file.getName().equalsIgnoreCase("obb")
153 | && !checkAndroidFolderPermission(context, ANDROID_OBB))
154 | || (file.getName().equalsIgnoreCase("data")
155 | && !checkAndroidFolderPermission(context, ANDROID_DATA));
156 | }
157 |
158 | /**
159 | * request permission to manage Android/data or Android/obb
160 | */
161 | public static void requestAndroidFolderPermission(Activity context, int requestCode, FileInterface file) {
162 | if (file.getName().equalsIgnoreCase("obb")) {
163 | requestAndroidFolderPermission(context, requestCode, ANDROID_OBB);
164 | } else if (file.getName().equalsIgnoreCase("data")) {
165 | requestAndroidFolderPermission(context, requestCode, ANDROID_DATA);
166 | }
167 | }
168 |
169 | public static void grantUriPermission(Context context, Uri uri) {
170 | int flags = Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION;
171 | context.getContentResolver().takePersistableUriPermission(uri, flags);
172 | context.grantUriPermission(context.getPackageName(), uri, flags);
173 | }
174 |
175 | }
176 |
--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
8 |
9 |
15 |
35 | 
3 |
4 | Simple project to get Android/{data,obb} directory access for Android >= 11 without root. (Supports all versions of Android)
5 |
6 | - [x] Doesn't need root.
7 | - [x] Useful for File Managers on Android >= 11.
8 | - [x] Tested on Android 11 & 10 & 7.
9 | - [x] Android/data directory access
10 | - [x] Android/obb directory access
11 |
12 | ## Author
13 | - **Amir Hossein Aghajari**
14 |
15 | License
16 | =======
17 |
18 | Copyright 2021 Amir Hossein Aghajari
19 | Licensed under the Apache License, Version 2.0 (the "License");
20 | you may not use this file except in compliance with the License.
21 | You may obtain a copy of the License at
22 |
23 | http://www.apache.org/licenses/LICENSE-2.0
24 |
25 | Unless required by applicable law or agreed to in writing, software
26 | distributed under the License is distributed on an "AS IS" BASIS,
27 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
28 | See the License for the specific language governing permissions and
29 | limitations under the License.
30 |
31 |
32 |