@nativescript/core 9.0.0-next-09-24-2025-17985801416 → 9.0.0-next-10-06-2025-18277360121

package/platforms/android/java/org/nativescript/widgets/FileHelper.java

@@ -0,0 +1,815 @@
+package org.nativescript.widgets;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.Looper;
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+import android.webkit.MimeTypeMap;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.documentfile.provider.DocumentFile;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.lang.ref.WeakReference;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class FileHelper {
+	static final String TAG = "FileHelper";
+	private Uri uri;
+	private final ExecutorService executor = Executors.newSingleThreadExecutor();
+	private final Handler handler;
+
+
+	private DocumentFile documentFile;
+
+	private WeakReference<Context> context;
+
+	public interface Callback {
+		void onError(Exception exception);
+
+		void onSuccess(@Nullable Object result);
+	}
+
+	FileHelper(Context context, Uri uri) {
+		handler = new Handler(Looper.myLooper());
+		this.context = new WeakReference<>(context);
+		this.uri = uri;
+		if (DocumentFile.isDocumentUri(context, uri)) {
+			documentFile = DocumentFile.fromSingleUri(context, uri);
+		}
+	}
+
+	private static boolean isExternalStorageDocument(Uri uri) {
+		return "com.android.externalstorage.documents".equals(uri
+			.getAuthority());
+	}
+
+	private static @Nullable
+	Cursor getCursor(Context context, Uri uri) {
+		return getCursor(context, uri, new String[]{
+			MediaStore.MediaColumns.DISPLAY_NAME,
+			MediaStore.MediaColumns.DATE_MODIFIED,
+			MediaStore.MediaColumns.SIZE
+		});
+	}
+
+	private static @Nullable
+	Cursor getCursor(Context context, Uri uri, String[] projections) {
+		Cursor cursor = null;
+		try {
+			if (Build.VERSION.SDK_INT >= 19) {
+				if (DocumentsContract.isDocumentUri(context, uri)) {
+					if (Build.VERSION.SDK_INT >= 29) {
+						if (!uri.toString().startsWith("content://com.android.providers.downloads.documents")) {
+							cursor = context.getContentResolver().query(
+								MediaStore.getMediaUri(context, uri), projections, null, null, null, null
+							);
+						}
+					}
+				}
+			}
+			if (cursor == null) {
+				cursor = context.getContentResolver().query(uri, projections, null, null, null);
+			}
+		} catch (Exception ignored) {
+		}
+
+		return cursor;
+
+	}
+
+	public static boolean exists(Context context, String string) {
+		try {
+			return exists(context, Uri.parse(string));
+		} catch (Exception ignored) {
+			return false;
+		}
+	}
+
+	static File getDocumentFile(Context context, Uri uri) {
+		if (Build.VERSION.SDK_INT >= 19 && DocumentsContract.isDocumentUri(context, uri)) {
+			return getFile(context, uri);
+		}
+		return null;
+	}
+
+	public static boolean exists(Context context, Uri uri) {
+		if (Build.VERSION.SDK_INT >= 19) {
+			if (DocumentsContract.isDocumentUri(context, uri)) {
+				DocumentFile file = DocumentFile.fromSingleUri(context, uri);
+				if (file != null) {
+					return file.exists();
+				}
+			}
+			File file = getDocumentFile(context, uri);
+			if (file != null) {
+				return file.exists();
+			}
+			return false;
+		}
+		Cursor cursor = getCursor(context, uri);
+		if (cursor == null) {
+			return false;
+		}
+		boolean exists = cursor.moveToFirst();
+		cursor.close();
+		return exists;
+	}
+
+	public static @Nullable
+	FileHelper fromString(Context context, String string) {
+		return fromUri(context, Uri.parse(string));
+	}
+
+	@SuppressWarnings("deprecation")
+	private static @Nullable
+	File getFile(Context context, Uri uri) {
+		if (Build.VERSION.SDK_INT >= 19) {
+			if (isExternalStorageDocument(uri)) {
+				String docId = DocumentsContract.getDocumentId(uri);
+				String[] split = docId.split(":");
+				String type = split[0];
+				String path = split[1];
+
+				if ("primary".equals(type)) {
+					int nameIndex = path.lastIndexOf("/");
+					String seg = path.substring(0, nameIndex);
+					String[] parts = Uri.decode(uri.toString()).split(":" + seg);
+					String file = Environment.getExternalStorageDirectory() + "/" + path + "/" + parts[1];
+					return new File(file);
+				} else {
+					File[] cacheDirs = context.getExternalCacheDirs();
+					String storageDir = null;
+					for (File cacheDir : cacheDirs) {
+						final String cachePath = cacheDir.getPath();
+						int index = cachePath.indexOf(type);
+						if (index >= 0) {
+							storageDir = cachePath.substring(0, index + type.length());
+						}
+					}
+
+					if (storageDir != null) {
+						return new File(storageDir + "/" + path);
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+	public static @Nullable
+	FileHelper fromUri(Context context, Uri contentUri) {
+		return new FileHelper(context, contentUri);
+	}
+
+	private long getFileSize() {
+		if (documentFile != null) {
+			return documentFile.length();
+		}
+		Context context = this.context.get();
+		if (context == null) {
+			return 0;
+		}
+		if (Build.VERSION.SDK_INT >= 19 && DocumentsContract.isDocumentUri(context, uri)) {
+			File file = getDocumentFile(context, uri);
+			if (file == null) {
+				return 0;
+			}
+			return file.length();
+		}
+
+		Cursor cursor = getCursor(context, uri, null);
+
+		if (cursor == null) {
+			return 0;
+		}
+
+		long size = 0;
+
+		boolean moved = cursor.moveToFirst();
+		if (moved) {
+			int sizeIndex = cursor.getColumnIndex(
+				MediaStore.MediaColumns.SIZE
+			);
+
+			size = cursor.getLong(sizeIndex);
+
+		}
+		cursor.close();
+
+		return size;
+	}
+
+	private void updateInternal(Context context) {
+		updateInternal(context, true);
+	}
+
+
+	private void updateValue(Context context, Uri uri, ContentValues values) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+			context.getContentResolver().update(uri, values, null);
+		} else {
+			context.getContentResolver().update(uri, values, null, null);
+		}
+	}
+
+	private void updateInternal(Context context, boolean force) {
+
+		if (force) {
+			// trigger db update
+			ContentValues values = new ContentValues();
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+				if (isExternalStorageDocument(uri)) {
+					return;
+				}
+				if (DocumentsContract.isDocumentUri(context, uri)) {
+					DocumentFile file = DocumentFile.fromSingleUri(context, uri);
+					if (file != null) {
+						updateValue(context, file.getUri(), values);
+					}
+				} else {
+					updateValue(context, uri, values);
+				}
+			} else {
+				updateValue(context, uri, values);
+			}
+		}
+	}
+
+	public long getSize() {
+		return getFileSize();
+	}
+
+	public String getName() {
+		if (documentFile != null) {
+			return documentFile.getName();
+		}
+
+		String name = null;
+
+		Context context = this.context.get();
+		if (context != null) {
+			if (DocumentFile.isDocumentUri(context, uri)) {
+				File file = getDocumentFile(context, uri);
+				if (file != null) {
+					name = file.getName();
+				}
+			} else {
+
+				Cursor cursor = getCursor(context, uri, null);
+
+				if (cursor == null) {
+					return null;
+				}
+
+				boolean moved = cursor.moveToFirst();
+				if (moved) {
+					int nameIndex = cursor.getColumnIndex(
+						MediaStore.MediaColumns.DISPLAY_NAME
+					);
+
+					name = cursor.getString(nameIndex);
+
+				}
+				cursor.close();
+
+				return name;
+			}
+		}
+
+		return name;
+	}
+
+	public String getMime() {
+		String mime = null;
+
+		Context context = this.context.get();
+		if (context != null) {
+			mime = context.getContentResolver().getType(uri);
+		}
+
+		if (mime == null) {
+			return "application/octet-stream";
+		}
+		return mime;
+	}
+
+	public String getExtension() {
+		String mime = getMime();
+		if (mime == null) {
+			return "";
+		}
+		return MimeTypeMap.getSingleton().getExtensionFromMimeType(mime);
+	}
+
+	public long getLastModified() {
+		long lastModified = 0;
+		if (documentFile != null) {
+			return documentFile.lastModified();
+		}
+		Context context = this.context.get();
+		if (context != null) {
+			if (DocumentFile.isDocumentUri(context, uri)) {
+				File file = getDocumentFile(context, uri);
+				if (file != null) {
+					lastModified = file.lastModified() / 1000;
+				}
+			} else {
+				Cursor cursor = getCursor(context, uri, null);
+
+				if (cursor == null) {
+					return 0;
+				}
+
+				boolean moved = cursor.moveToFirst();
+				if (moved) {
+					int sizeIndex = cursor.getColumnIndex(
+						MediaStore.MediaColumns.DATE_MODIFIED
+					);
+
+					lastModified = cursor.getLong(sizeIndex);
+
+				}
+				cursor.close();
+			}
+		}
+
+		return lastModified;
+	}
+
+	private InputStream getInputStream(Context context, Uri uri) throws Exception {
+		if (Build.VERSION.SDK_INT >= 19) {
+			if (DocumentsContract.isDocumentUri(context, uri)) {
+				return context.getContentResolver().openInputStream(DocumentFile.fromSingleUri(context, uri).getUri());
+			}
+			if (isExternalStorageDocument(uri)) {
+				File file = getFile(context, uri);
+				return new FileInputStream(file);
+			}
+		}
+		return context.getContentResolver().openInputStream(uri);
+	}
+
+	private OutputStream getOutputStream(Context context, Uri uri) throws Exception {
+		return getOutputStream(context, uri, false);
+	}
+
+	private OutputStream getOutputStream(Context context, Uri uri, boolean append) throws Exception {
+		if (Build.VERSION.SDK_INT >= 19) {
+			if (DocumentsContract.isDocumentUri(context, uri)) {
+				return context.getContentResolver().openOutputStream(DocumentFile.fromSingleUri(context, uri).getUri(), append ? "wa" : "w");
+			}
+			if (isExternalStorageDocument(uri)) {
+				File file = getFile(context, uri);
+				return new FileOutputStream(file, append);
+			}
+		}
+		return context.getContentResolver().openOutputStream(uri, append ? "wa" : "w");
+	}
+
+	public void appendSync(Context context, byte[] content, @Nullable Callback callback) {
+		try {
+			writeSyncInternal(context, content, true);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void append(Context context, byte[] content, Callback callback) {
+		executor.execute(() -> {
+			try {
+				writeSyncInternal(context, content, true);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	public void appendBufferSync(Context context, ByteBuffer content, @Nullable Callback callback) {
+		try {
+			writeBufferSyncInternal(context, content, true);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void appendBuffer(Context context, ByteBuffer content, Callback callback) {
+		executor.execute(() -> {
+			try {
+				writeBufferSyncInternal(context, content, true);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	public void appendTextSync(Context context, String content, @Nullable String encoding, @Nullable Callback callback) {
+		try {
+			writeTextSyncInternal(context, content, encoding, true);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void appendText(Context context, String content, @Nullable String encoding, Callback callback) {
+		executor.execute(() -> {
+			try {
+				writeTextSyncInternal(context, content, encoding, true);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	private byte[] readSyncInternal(Context context) throws Exception {
+		InputStream is = getInputStream(context, uri);
+
+		Async.Http.RequestResult.ByteArrayOutputStream2 ret = new Async.Http.RequestResult.ByteArrayOutputStream2();
+
+		byte[] buff = new byte[4096];
+		int read;
+		while ((read = is.read(buff, 0, buff.length)) != -1) {
+			ret.write(buff, 0, read);
+		}
+
+		is.close();
+		return ret.buf();
+	}
+
+	private ByteBuffer readBufferSyncInternal(Context context) throws Exception {
+		InputStream is = getInputStream(context, uri);
+
+		ReadableByteChannel channel = Channels.newChannel(is);
+		ByteBuffer buffer = ByteBuffer.allocateDirect(is.available());
+		channel.read(buffer);
+
+		return buffer;
+	}
+
+	public @Nullable
+	byte[] readSync(Context context, @Nullable Callback callback) {
+		try {
+			return readSyncInternal(context);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+		return null;
+	}
+
+	public void read(Context context, Callback callback) {
+		executor.execute(() -> {
+			try {
+				byte[] result = readSyncInternal(context);
+				handler.post(() -> callback.onSuccess(result));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	public @Nullable
+	ByteBuffer readBufferSync(Context context, @Nullable Callback callback) {
+		try {
+			return readBufferSyncInternal(context);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+		return null;
+	}
+
+	public void readBuffer(Context context, Callback callback) {
+		executor.execute(() -> {
+			try {
+				ByteBuffer result = readBufferSyncInternal(context);
+				handler.post(() -> callback.onSuccess(result));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	private String readTextSyncInternal(Context context, @Nullable String encoding) throws Exception {
+		String characterSet = encoding;
+		if (characterSet == null) {
+			characterSet = "UTF-8";
+		}
+
+		InputStream is = getInputStream(context, uri);
+		InputStreamReader isr = new InputStreamReader(is, characterSet);
+		BufferedReader reader = new BufferedReader(isr);
+		char[] buf = new char[is.available()];
+		reader.read(buf);
+		reader.close();
+		return new String(buf);
+	}
+
+	public String readTextSync(Context context, @Nullable String encoding, @Nullable Callback callback) {
+		try {
+			return readTextSyncInternal(context, encoding);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+		return null;
+	}
+
+	public void readText(Context context, @Nullable String encoding, Callback callback) {
+		executor.execute(() -> {
+			try {
+				String result = readTextSyncInternal(context, encoding);
+				handler.post(() -> callback.onSuccess(result));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	private void writeSyncInternal(Context context, byte[] content) throws Exception {
+		writeSyncInternal(context, content, false);
+	}
+
+	private void writeSyncInternal(Context context, byte[] content, boolean append) throws Exception {
+		OutputStream os = getOutputStream(context, uri, append);
+		os.write(content, 0, content.length);
+		os.flush();
+		os.close();
+		try {
+			updateInternal(context);
+		} catch (Exception exception){
+			Log.e(TAG, "Failed to updateValue: " + exception.getMessage());
+		}
+	}
+
+	private void writeBufferSyncInternal(Context context, ByteBuffer content) throws Exception {
+		writeBufferSyncInternal(context, content, false);
+	}
+
+	private void writeBufferSyncInternal(Context context, ByteBuffer content, boolean append) throws Exception {
+		OutputStream os = getOutputStream(context, uri, append);
+		WritableByteChannel channel = Channels.newChannel(os);
+		channel.write(content);
+		os.flush();
+		os.close();
+		try {
+			updateInternal(context);
+		} catch (Exception exception){
+			Log.e(TAG, "Failed to updateValue: " + exception.getMessage());
+		}
+	}
+
+	public void writeSync(Context context, byte[] content, @Nullable Callback callback) {
+		try {
+			writeSyncInternal(context, content);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void write(Context context, byte[] content, Callback callback) {
+		executor.execute(() -> {
+			try {
+				writeSyncInternal(context, content);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	public void writeBufferSync(Context context, ByteBuffer content, @Nullable Callback callback) {
+		try {
+			writeBufferSyncInternal(context, content);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void writeBuffer(Context context, ByteBuffer content, Callback callback) {
+		executor.execute(() -> {
+			try {
+				writeBufferSyncInternal(context, content);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	private void writeTextSyncInternal(Context context, String content, @Nullable String encoding) throws Exception {
+		writeTextSyncInternal(context, content, encoding, false);
+	}
+
+	private void writeTextSyncInternal(Context context, String content, @Nullable String encoding, boolean append) throws Exception {
+		OutputStream os = getOutputStream(context, uri, append);
+		String characterSet = encoding;
+		if (characterSet == null) {
+			characterSet = "UTF-8";
+		}
+		OutputStreamWriter osw = new OutputStreamWriter(os, characterSet);
+		osw.write(content);
+		osw.flush();
+		osw.close();
+		try {
+			updateInternal(context);
+		} catch (Exception exception){
+			Log.e(TAG, "Failed to updateValue: " + exception.getMessage());
+		}
+	}
+
+	public void writeTextSync(Context context, String content, @Nullable String encoding, @Nullable Callback callback) {
+		try {
+			writeTextSyncInternal(context, content, encoding);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void writeText(Context context, String content, @Nullable String encoding, Callback callback) {
+		executor.execute(() -> {
+			try {
+				writeTextSyncInternal(context, content, encoding);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	private void copyToFileInternal(InputStream is, OutputStream os) throws Exception {
+		int read;
+		byte[] buf = new byte[1024];
+		while ((read = is.read(buf)) != -1) {
+			os.write(buf, 0, read);
+		}
+		is.close();
+		os.flush();
+		os.close();
+	}
+
+	private void copyToFileInternal(Context context, File file) throws Exception {
+		InputStream is = getInputStream(context, uri);
+		FileOutputStream os = new FileOutputStream(file);
+		copyToFileInternal(is, os);
+	}
+
+	public boolean copyToFileSync(Context context, File file, @Nullable Callback callback) {
+		boolean completed = false;
+		try {
+			copyToFileInternal(context, file);
+			completed = true;
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+		return completed;
+	}
+
+	public void copyToFile(Context context, File file, Callback callback) {
+		executor.execute(() -> {
+			try {
+				copyToFileInternal(context, file);
+				handler.post(() -> callback.onSuccess(true));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+	public boolean delete(Context context) {
+		try {
+			if (Build.VERSION.SDK_INT >= 19) {
+				if (isExternalStorageDocument(uri)) {
+					File file = getFile(context, uri);
+					if (file != null) {
+						return file.delete();
+					}
+					return false;
+				} else {
+					if (DocumentsContract.isDocumentUri(context, uri)) {
+						if (Build.VERSION.SDK_INT >= 29) {
+							if (!uri.toString().startsWith("content://com.android.providers.downloads.documents")) {
+								return context.getContentResolver().delete(
+									MediaStore.getMediaUri(context, uri), null, null
+								) > 0;
+							}
+
+						} else {
+							return DocumentsContract.deleteDocument(context.getContentResolver(), uri);
+						}
+					}
+				}
+			}
+			return context.getContentResolver().delete(uri, null, null) > 0;
+		} catch (SecurityException | FileNotFoundException e) {
+			return false;
+		}
+	}
+
+
+	private void renameInternal(Context context, String newName) throws Exception {
+		ContentValues values = new ContentValues();
+		values.put(MediaStore.MediaColumns.DISPLAY_NAME, newName);
+
+		if (Build.VERSION.SDK_INT >= 19) {
+			if (isExternalStorageDocument(uri)) {
+				File file = getFile(context, uri);
+				if (file != null) {
+					file.renameTo(new File(file.getParentFile(), newName));
+					return;
+				}
+				return;
+			}
+
+			if (DocumentsContract.isDocumentUri(context, uri)) {
+				if (Build.VERSION.SDK_INT >= 29) {
+					if (!uri.toString().startsWith("content://com.android.providers.downloads.documents")) {
+						context.getContentResolver().update(
+							uri, values, null, null
+						);
+						return;
+					}
+					DocumentsContract.renameDocument(context.getContentResolver(), uri, newName);
+				} else if (Build.VERSION.SDK_INT >= 21) {
+					DocumentsContract.renameDocument(context.getContentResolver(), uri, newName);
+					return;
+				}
+			}
+
+		}
+		try {
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+				context.getContentResolver().update(uri, values, null);
+			} else {
+				context.getContentResolver().update(uri, values, null, null);
+			}
+			updateInternal(context, false);
+		} catch (Exception exception){
+			Log.e(TAG, "Failed to updateValue: " + exception.getMessage());
+		}
+		
+	}
+
+	public void renameSync(Context context, String newName, @Nullable Callback callback) {
+		try {
+			renameInternal(context, newName);
+		} catch (Exception e) {
+			if (callback != null) {
+				callback.onError(e);
+			}
+		}
+	}
+
+	public void rename(Context context, String newName, Callback callback) {
+		executor.execute(() -> {
+			try {
+				renameInternal(context, newName);
+				handler.post(() -> callback.onSuccess(null));
+			} catch (Exception e) {
+				handler.post(() -> callback.onError(e));
+			}
+		});
+	}
+
+}