@nativescript/core 9.0.0-next-09-27-2025-18063560861 → 9.0.0-next-10-06-2025-18277360121

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

@@ -0,0 +1,1356 @@
+package org.nativescript.widgets;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Looper;
+import android.util.Base64;
+import android.util.Log;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.net.CookieHandler;
+import java.net.CookieManager;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Stack;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.zip.GZIPInputStream;
+
+public class Async {
+	static final String TAG = "Async";
+	static ThreadPoolExecutor executor = null;
+
+	static ThreadPoolExecutor threadPoolExecutor() {
+		if (executor == null) {
+			int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
+			ThreadFactory backgroundPriorityThreadFactory = new PriorityThreadFactory(android.os.Process.THREAD_PRIORITY_BACKGROUND);
+
+			executor = new ThreadPoolExecutor(
+				NUMBER_OF_CORES * 2,
+				NUMBER_OF_CORES * 2,
+				60L,
+				TimeUnit.SECONDS,
+				new LinkedBlockingQueue<Runnable>(),
+				backgroundPriorityThreadFactory
+			);
+		}
+
+		return executor;
+	}
+
+	public interface CompleteCallback {
+		void onComplete(Object result, Object tag);
+
+		void onError(String error, Object tag);
+	}
+
+	static class PriorityThreadFactory implements ThreadFactory {
+		private final int mThreadPriority;
+
+		public PriorityThreadFactory(int threadPriority) {
+			mThreadPriority = threadPriority;
+		}
+
+		@Override
+		public Thread newThread(final Runnable runnable) {
+			Runnable wrapperRunnable = new Runnable() {
+				@Override
+				public void run() {
+					try {
+						android.os.Process.setThreadPriority(mThreadPriority);
+					} catch (Throwable t) {
+
+					}
+					runnable.run();
+				}
+			};
+			return new Thread(wrapperRunnable);
+		}
+	}
+
+	public static class Image {
+		/*
+		 * The request id parameter is needed for the sake of the JavaScript implementation.
+		 * Because we want to use only one extend of the CompleteCallback interface (for the sake of better performance)
+		 * we use this id to detect the initial request, which result is currently received in the complete callback.
+		 * When the async task completes it will pass back this id to JavaScript.
+		 */
+		public static void fromResource(final String name, final Context context, final int requestId, final CompleteCallback callback) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final LoadImageFromResourceTask task = new LoadImageFromResourceTask(context, requestId, callback);
+					final Bitmap result = task.doInBackground(name);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void fromFile(final String fileName, final int requestId, final CompleteCallback callback) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final LoadImageFromFileTask task = new LoadImageFromFileTask(requestId, callback);
+					final Bitmap result = task.doInBackground(fileName);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void fromBase64(final String source, final int requestId, final CompleteCallback callback) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final LoadImageFromBase64StringTask task = new LoadImageFromBase64StringTask(requestId, callback);
+					final Bitmap result = task.doInBackground(source);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void download(final String url, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final DownloadImageTask task = new DownloadImageTask(callback, context);
+					final Bitmap result = task.doInBackground(url);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		static class DownloadImageTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public DownloadImageTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected Bitmap doInBackground(String... params) {
+				InputStream stream = null;
+				try {
+					stream = new java.net.URL(params[0]).openStream();
+					Bitmap bmp = BitmapFactory.decodeStream(stream);
+					return bmp;
+				} catch (Throwable t) {
+					Log.e(TAG, "Failed to decode stream, Throwable: " + t.getMessage());
+					return null;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final Bitmap result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.context);
+				} else {
+					this.callback.onError("DownloadImageTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class LoadImageFromResourceTask {
+			private final CompleteCallback callback;
+			private final Context context;
+			private final int requestId;
+
+			public LoadImageFromResourceTask(Context context, int requestId, CompleteCallback callback) {
+				this.callback = callback;
+				this.context = context;
+				this.requestId = requestId;
+			}
+
+			protected Bitmap doInBackground(String... params) {
+				String name = params[0];
+				Resources res = this.context.getResources();
+				int id = res.getIdentifier(name, "drawable", context.getPackageName());
+
+				if (id > 0) {
+					BitmapDrawable result = (BitmapDrawable) res.getDrawable(id);
+					return result.getBitmap();
+				}
+
+				return null;
+			}
+
+			protected void onPostExecute(final Bitmap result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.requestId);
+				} else {
+					this.callback.onError("LoadImageFromResourceTask returns no result.", this.requestId);
+				}
+			}
+		}
+
+		static class LoadImageFromFileTask {
+			private final CompleteCallback callback;
+			private final int requestId;
+
+			public LoadImageFromFileTask(int requestId, CompleteCallback callback) {
+				this.callback = callback;
+				this.requestId = requestId;
+			}
+
+			protected Bitmap doInBackground(String... params) {
+				String fileName = params[0];
+				return BitmapFactory.decodeFile(fileName);
+			}
+
+			protected void onPostExecute(final Bitmap result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.requestId);
+				} else {
+					this.callback.onError("LoadImageFromFileTask returns no result.", this.requestId);
+				}
+			}
+		}
+
+		static class LoadImageFromBase64StringTask {
+			private final CompleteCallback callback;
+			private final int requestId;
+
+			public LoadImageFromBase64StringTask(int requestId, CompleteCallback callback) {
+				this.callback = callback;
+				this.requestId = requestId;
+			}
+
+			protected Bitmap doInBackground(String... params) {
+				String source = params[0];
+				byte[] bytes = Base64.decode(source, Base64.DEFAULT);
+				return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+			}
+
+			protected void onPostExecute(final Bitmap result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.requestId);
+				} else {
+					this.callback.onError("LoadImageFromBase64StringTask returns no result.", this.requestId);
+				}
+			}
+		}
+	}
+
+	public static class Http {
+		private static final String GET_METHOD = "GET";
+		private static final String HEAD_METHOD = "HEAD";
+		private static CookieManager cookieManager;
+
+		public static void setCookieManager(CookieManager manager) {
+			if(manager == null) return;
+
+			cookieManager = manager;
+			if (CookieHandler.getDefault() == null) {
+				CookieHandler.setDefault(manager);
+			}
+    }
+		
+		public static CookieManager initializeCookieManager() {
+			if (cookieManager == null) {
+				CookieHandler defaultHandler = CookieHandler.getDefault();
+				if (defaultHandler instanceof CookieManager) {
+					cookieManager = (CookieManager) defaultHandler;
+				} else {
+					cookieManager = new CookieManager();
+					CookieHandler.setDefault(cookieManager);
+				}
+			}
+
+			return cookieManager;
+    }
+
+		public static void MakeRequest(final RequestOptions options, final CompleteCallback callback, final Object context) {
+			if (cookieManager == null) {
+				initializeCookieManager();
+			}
+
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final HttpRequestTask task = new HttpRequestTask(callback, context);
+					final RequestResult result = task.doInBackground(options);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static class KeyValuePair {
+			public String key;
+			public String value;
+
+			public KeyValuePair(String key, String value) {
+				this.key = key;
+				this.value = value;
+			}
+		}
+
+		public static class RequestOptions {
+			public String url;
+			public String method;
+			public ArrayList<KeyValuePair> headers;
+			public Object content;
+			public int timeout = -1;
+			public int screenWidth = -1;
+			public int screenHeight = -1;
+			public boolean dontFollowRedirects = false;
+
+			public void addHeaders(HttpURLConnection connection) {
+				if (this.headers == null) {
+					return;
+				}
+				boolean hasAcceptHeader = false;
+
+				for (KeyValuePair pair : this.headers) {
+					String key = pair.key;
+					connection.addRequestProperty(key, pair.value);
+					if (key.toLowerCase().contentEquals("accept-encoding")) {
+						hasAcceptHeader = true;
+					}
+				}
+
+				// If the user hasn't added an Accept-Encoding header, we add gzip as something we accept
+				if (!hasAcceptHeader) {
+					connection.addRequestProperty("Accept-Encoding", "gzip");
+				}
+			}
+
+			public void writeContent(HttpURLConnection connection, Stack<Closeable> openedStreams) throws IOException {
+				if (this.content == null) {
+					return;
+				}
+
+				OutputStream outStream = connection.getOutputStream();
+				openedStreams.push(outStream);
+
+				if (this.content instanceof String) {
+					OutputStreamWriter writer = new OutputStreamWriter(outStream);
+					openedStreams.push(writer);
+
+					writer.write((String) this.content);
+				} else {
+					outStream.write(((java.nio.ByteBuffer) this.content).array());
+				}
+			}
+		}
+
+		public static class RequestResult {
+			public ByteArrayOutputStream raw;
+			public ArrayList<KeyValuePair> headers = new ArrayList<KeyValuePair>();
+			public int statusCode;
+			public String responseAsString;
+			public Bitmap responseAsImage;
+			public Exception error;
+			public String url;
+			public String statusText;
+
+			public void getHeaders(HttpURLConnection connection) {
+				Map<String, List<String>> headers = connection.getHeaderFields();
+				if (headers == null) {
+					// no headers, this may happen if there is no internet connection currently available
+					return;
+				}
+
+				int size = headers.size();
+				if (size == 0) {
+					return;
+				}
+
+				for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
+					String key = entry.getKey();
+					for (String value : entry.getValue()) {
+						this.headers.add(new KeyValuePair(key, value));
+					}
+				}
+			}
+
+			public void readResponseStream(HttpURLConnection connection, Stack<Closeable> openedStreams, RequestOptions options) throws IOException {
+				int contentLength = connection.getContentLength();
+
+				InputStream inStream =
+					this.statusCode >= 400
+						? connection.getErrorStream()
+						: connection.getInputStream();
+
+				if (inStream == null) {
+					// inStream is null when receiving status code 401 or 407
+					// see this thread for more information http://stackoverflow.com/a/24986433
+					return;
+				}
+
+				// In the event we don't have a null stream, and we have gzip as part of the encoding
+				// then we will use gzip to decode the stream
+				// Ignore gzip encoding for 204 'No Content' status to prevent java.io.EOFException
+				String encodingHeader = connection.getHeaderField("Content-Encoding");
+				if (encodingHeader != null && encodingHeader.toLowerCase().contains("gzip") && this.statusCode != 204) {
+					inStream = new GZIPInputStream(inStream);
+				}
+
+				openedStreams.push(inStream);
+
+				BufferedInputStream buffer = new BufferedInputStream(inStream, 4096);
+				openedStreams.push(buffer);
+
+				ByteArrayOutputStream2 responseStream = contentLength != -1 ? new ByteArrayOutputStream2(contentLength) : new ByteArrayOutputStream2();
+				openedStreams.push(responseStream);
+
+				byte[] buff = new byte[4096];
+				int read = -1;
+				while ((read = buffer.read(buff, 0, buff.length)) != -1) {
+					responseStream.write(buff, 0, read);
+				}
+
+				this.raw = responseStream;
+				buff = null;
+
+				// make the byte array conversion here, not in the JavaScript
+				// world for better performance
+				// since we do not have some explicit way to determine whether
+				// the content-type is image
+				try {
+					// TODO: Generally this approach will not work for very
+					// large files
+					BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
+					bitmapOptions.inJustDecodeBounds = true;
+
+					// check the size of the bitmap first
+					BitmapFactory.decodeByteArray(responseStream.buf(), 0, responseStream.size(), bitmapOptions);
+					if (bitmapOptions.outWidth > 0 && bitmapOptions.outHeight > 0) {
+						int scale = 1;
+						final int height = bitmapOptions.outHeight;
+						final int width = bitmapOptions.outWidth;
+
+						if ((options.screenWidth > 0 && bitmapOptions.outWidth > options.screenWidth) ||
+							(options.screenHeight > 0 && bitmapOptions.outHeight > options.screenHeight)) {
+							final int halfHeight = height / 2;
+							final int halfWidth = width / 2;
+
+							// scale down the image since it is larger than the
+							// screen resolution
+							while ((halfWidth / scale) > options.screenWidth && (halfHeight / scale) > options.screenHeight) {
+								scale *= 2;
+							}
+						}
+
+						bitmapOptions.inJustDecodeBounds = false;
+						bitmapOptions.inSampleSize = scale;
+						this.responseAsImage = BitmapFactory.decodeByteArray(responseStream.buf(), 0, responseStream.size(), bitmapOptions);
+					}
+				} catch (Throwable t) {
+					Log.e(TAG, "Failed to decode byte array, Throwable: " + t.getMessage());
+				}
+
+				if (this.responseAsImage == null) {
+					// convert to string
+					this.responseAsString = responseStream.toString();
+				}
+			}
+
+			public static final class ByteArrayOutputStream2 extends ByteArrayOutputStream {
+				public ByteArrayOutputStream2() {
+					super();
+				}
+
+				public ByteArrayOutputStream2(int size) {
+					super(size);
+				}
+
+				/**
+				 * Returns the internal buffer of this ByteArrayOutputStream, without copying.
+				 */
+				public synchronized byte[] buf() {
+					return this.buf;
+				}
+			}
+		}
+
+		static class HttpRequestTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public HttpRequestTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected RequestResult doInBackground(RequestOptions... params) {
+				RequestResult result = new RequestResult();
+				Stack<Closeable> openedStreams = new Stack<Closeable>();
+
+				try {
+					RequestOptions options = params[0];
+					URL url = new URL(options.url);
+					HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+
+					// set the request method
+					String requestMethod = options.method != null ? options.method.toUpperCase(Locale.ENGLISH) : GET_METHOD;
+					connection.setRequestMethod(requestMethod);
+
+					// add the headers
+					options.addHeaders(connection);
+
+					// apply timeout
+					if (options.timeout > 0) {
+						connection.setConnectTimeout(options.timeout);
+						connection.setReadTimeout(options.timeout);
+					}
+
+					// don't follow redirect (30x) responses; by default, HttpURLConnection follows them.
+					if (options.dontFollowRedirects) {
+						connection.setInstanceFollowRedirects(false);
+					}
+
+					options.writeContent(connection, openedStreams);
+
+					// close the opened streams (saves copy-paste implementation
+					// in each method that throws IOException)
+					this.closeOpenedStreams(openedStreams);
+
+					connection.connect();
+
+					// build the result
+					result.getHeaders(connection);
+					result.url = options.url;
+					result.statusCode = connection.getResponseCode();
+					result.statusText = connection.getResponseMessage();
+					if (!requestMethod.equals(HEAD_METHOD)) {
+						result.readResponseStream(connection, openedStreams, options);
+					}
+
+					// close the opened streams (saves copy-paste implementation
+					// in each method that throws IOException)
+					this.closeOpenedStreams(openedStreams);
+
+					connection.disconnect();
+
+					return result;
+				} catch (Exception e) // TODO: Catch all exceptions?
+				{
+					result.error = e;
+
+					return result;
+				} finally {
+					try {
+						this.closeOpenedStreams(openedStreams);
+					} catch (IOException e) {
+						Log.e(TAG, "Failed to close opened streams, IOException: " + e.getMessage());
+					}
+				}
+			}
+
+			protected void onPostExecute(final RequestResult result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.context);
+				} else {
+					this.callback.onError("HttpRequestTask returns no result.", this.context);
+				}
+			}
+
+			private void closeOpenedStreams(Stack<Closeable> streams) throws IOException {
+				while (streams.size() > 0) {
+					Closeable stream = streams.pop();
+					stream.close();
+				}
+			}
+		}
+	}
+
+	public static class File {
+
+		static void updateValue(Context context, Uri uri) {
+			try {
+				ContentValues values = new ContentValues();
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+					context.getContentResolver().update(uri, values, null);
+				} else {
+					context.getContentResolver().update(uri, values, null, null);
+				}
+			} catch (Exception exception){
+				Log.e(TAG, "Failed to updateValue: " + exception.getMessage());
+			}
+			
+		}
+
+		public static void append(final String path, final byte[] content, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final AppendTask task = new AppendTask(callback, context);
+					final boolean result = task.doInBackground(path, content);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void appendBuffer(final String path, final ByteBuffer content, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final AppendBufferTask task = new AppendBufferTask(callback, context);
+					final boolean result = task.doInBackground(path, content);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void appendText(final String path, final String content, final String encoding, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final AppendTextTask task = new AppendTextTask(callback, context);
+					final boolean result = task.doInBackground(path, content, encoding);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static boolean copySync(final String src, final String dest, final Context context) throws Exception {
+			InputStream is;
+			OutputStream os;
+			boolean requiresUpdate = false;
+			if(src.startsWith("content://")){
+				is = context.getContentResolver().openInputStream(Uri.parse(src));
+			}else is = new FileInputStream(new java.io.File(src));
+
+			if(dest.startsWith("content://")){
+				os = context.getContentResolver().openOutputStream(Uri.parse(dest));
+				requiresUpdate = true;
+			}else os = new FileOutputStream(new java.io.File(dest));
+
+			boolean ret = copySync(is, os, context);
+
+			if(ret && requiresUpdate){
+				updateValue(context, Uri.parse(dest));
+			}
+
+			return ret;
+
+		}
+
+		public static boolean copySync(final InputStream src, final OutputStream dest, final Object context) throws Exception {
+			ReadableByteChannel isc = java.nio.channels.Channels.newChannel(src);
+			WritableByteChannel osc = java.nio.channels.Channels.newChannel(dest);
+
+			int size = src.available();
+
+			int written = fastChannelCopy(isc, osc);
+
+			return size == written;
+		}
+
+		public static void copy(final String src, final String dest, final CompleteCallback callback, final Context context) {
+			try {
+				InputStream is;
+				OutputStream os;
+
+				boolean requiresUpdate = false;
+
+				if(src.startsWith("content://")){
+					is = context.getContentResolver().openInputStream(Uri.parse(src));
+				}else is = new FileInputStream(new java.io.File(src));
+
+				if(dest.startsWith("content://")){
+					requiresUpdate = true;
+					os = context.getContentResolver().openOutputStream(Uri.parse(dest));
+				}else os = new FileOutputStream(new java.io.File(dest));
+
+				boolean finalRequiresUpdate = requiresUpdate;
+				copy(is, os, new CompleteCallback() {
+					@Override
+					public void onComplete(Object result, Object tag) {
+						if(finalRequiresUpdate){
+							updateValue(context, Uri.parse(dest));
+						}
+						callback.onComplete(result, tag);
+					}
+
+					@Override
+					public void onError(String error, Object tag) {
+						callback.onError(error, tag);
+					}
+				}, context);
+
+			}catch (Exception exception){
+				callback.onError(exception.getMessage(), context);
+			}
+		}
+
+		private static int fastChannelCopy(final ReadableByteChannel src,
+											final WritableByteChannel dest) throws IOException {
+			int written = 0;
+			final ByteBuffer buffer = ByteBuffer.allocateDirect(16 * 1024);
+			while (src.read(buffer) != -1) {
+				// prepare the buffer to be drained
+				buffer.flip();
+				// write to the channel, may block
+				written += dest.write(buffer);
+				// If partial transfer, shift remainder down
+				// If buffer is empty, same as doing clear()
+				buffer.compact();
+			}
+			// EOF will leave buffer in fill state
+			buffer.flip();
+			// make sure the buffer is fully drained.
+			while (buffer.hasRemaining()) {
+				written += dest.write(buffer);
+			}
+			return written;
+		}
+
+		public static void copy(final InputStream src, final OutputStream dest, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute((Runnable) () -> {
+
+				boolean done = false;
+				Exception error = null;
+				try (InputStream is = src; OutputStream os = dest){
+					ReadableByteChannel isc = java.nio.channels.Channels.newChannel(is);
+					WritableByteChannel osc = java.nio.channels.Channels.newChannel(os);
+
+					int size = src.available();
+
+					int written = fastChannelCopy(isc, osc);
+
+					done = size == written;
+
+				} catch (Exception e) {
+					error = e;
+
+				}finally {
+					if (error != null){
+						Exception finalError = error;
+						mHandler.post(() -> callback.onError(finalError.getMessage(), context));
+					}else {
+						boolean finalDone = done;
+						mHandler.post(() -> callback.onComplete(finalDone, context));
+					}
+				}
+			});
+		}
+
+		public static void readText(final String path, final String encoding, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final ReadTextTask task = new ReadTextTask(callback, context);
+					final String result = task.doInBackground(path, encoding);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void read(final String path, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final ReadTask task = new ReadTask(callback, context);
+					final byte[] result = task.doInBackground(path);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void readBuffer(final String path, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final ReadBufferTask task = new ReadBufferTask(callback, context);
+					final ByteBuffer result = task.doInBackground(path);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void writeText(final String path, final String content, final String encoding, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final WriteTextTask task = new WriteTextTask(callback, context);
+					final boolean result = task.doInBackground(path, content, encoding);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void write(final String path, final byte[] content, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final WriteTask task = new WriteTask(callback, context);
+					final boolean result = task.doInBackground(path, content);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		public static void writeBuffer(final String path, final ByteBuffer content, final CompleteCallback callback, final Object context) {
+			final android.os.Handler mHandler = new android.os.Handler(Looper.myLooper());
+			threadPoolExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					final WriteBufferTask task = new WriteBufferTask(callback, context);
+					final boolean result = task.doInBackground(path, content);
+					mHandler.post(new Runnable() {
+						@Override
+						public void run() {
+							task.onPostExecute(result);
+						}
+					});
+				}
+			});
+		}
+
+		static class ReadTextTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public ReadTextTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected String doInBackground(String... params) {
+				java.io.File javaFile = new java.io.File(params[0]);
+				FileInputStream stream = null;
+
+				try {
+					stream = new FileInputStream(javaFile);
+
+					InputStreamReader reader = new InputStreamReader(stream, params[1]);
+
+					CharBuffer buffer = CharBuffer.allocate(81920);
+					StringBuilder sb = new StringBuilder();
+
+					while (reader.read(buffer) != -1) {
+						buffer.flip();
+						sb.append(buffer);
+						buffer.clear();
+					}
+
+					reader.close();
+
+					return sb.toString();
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to read file, FileNotFoundException: " + e.getMessage());
+					return null;
+				} catch (UnsupportedEncodingException e) {
+					Log.e(TAG, "Failed to read file, UnsupportedEncodingException: " + e.getMessage());
+					return null;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to read file, IOException: " + e.getMessage());
+					return null;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final String result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.context);
+				} else {
+					this.callback.onError("ReadTextTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class ReadTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public ReadTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected byte[] doInBackground(String... params) {
+				java.io.File javaFile = new java.io.File(params[0]);
+				FileInputStream stream = null;
+
+				try {
+					stream = new FileInputStream(javaFile);
+
+					byte[] result = new byte[(int) javaFile.length()];
+
+					DataInputStream dataInputStream = new DataInputStream(stream);
+					dataInputStream.readFully(result);
+
+					return result;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to read file, FileNotFoundException: " + e.getMessage());
+					return null;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to read file, IOException: " + e.getMessage());
+					return null;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final byte[] result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.context);
+				} else {
+					this.callback.onError("ReadTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class ReadBufferTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public ReadBufferTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected ByteBuffer doInBackground(String... params) {
+				java.io.File javaFile = new java.io.File(params[0]);
+				FileInputStream stream = null;
+
+				try {
+					stream = new FileInputStream(javaFile);
+
+					ByteBuffer buffer = ByteBuffer.allocateDirect((int) javaFile.length());
+
+					FileChannel channel = stream.getChannel();
+					channel.read(buffer);
+					buffer.rewind();
+
+					return buffer;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to read file, FileNotFoundException: " + e.getMessage());
+					return null;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to read file, IOException: " + e.getMessage());
+					return null;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final ByteBuffer result) {
+				if (result != null) {
+					this.callback.onComplete(result, this.context);
+				} else {
+					this.callback.onError("ReadTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class WriteTextTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public WriteTextTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected boolean doInBackground(String... params) {
+				java.io.File javaFile = new java.io.File(params[0]);
+				FileOutputStream stream = null;
+				try {
+					stream = new FileOutputStream(javaFile);
+
+					OutputStreamWriter writer = new OutputStreamWriter(stream, params[2]);
+					writer.write(params[1]);
+					writer.close();
+
+					return true;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to write file, FileNotFoundException: " + e.getMessage());
+					return false;
+				} catch (UnsupportedEncodingException e) {
+					Log.e(TAG, "Failed to write file, UnsupportedEncodingException: " + e.getMessage());
+					return false;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to write file, IOException: " + e.getMessage());
+					return false;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final boolean result) {
+				if (result) {
+					this.callback.onComplete(null, this.context);
+				} else {
+					this.callback.onError("WriteTextTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class WriteTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public WriteTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected boolean doInBackground(Object... params) {
+				java.io.File javaFile = new java.io.File((String) params[0]);
+				FileOutputStream stream = null;
+				byte[] content = (byte[]) params[1];
+
+				try {
+					stream = new FileOutputStream(javaFile);
+					stream.write(content, 0, content.length);
+
+					return true;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to write file, FileNotFoundException: " + e.getMessage());
+					return false;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to write file, IOException: " + e.getMessage());
+					return false;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final boolean result) {
+				if (result) {
+					this.callback.onComplete(null, this.context);
+				} else {
+					this.callback.onError("WriteTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class WriteBufferTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public WriteBufferTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected boolean doInBackground(Object... params) {
+				java.io.File javaFile = new java.io.File((String) params[0]);
+				FileOutputStream stream = null;
+				ByteBuffer content = (ByteBuffer) params[1];
+
+				try {
+					stream = new FileOutputStream(javaFile);
+					FileChannel channel = stream.getChannel();
+					content.rewind();
+					channel.write(content);
+					content.rewind();
+					return true;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to write file, FileNotFoundException: " + e.getMessage());
+					return false;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to write file, IOException: " + e.getMessage());
+					return false;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final boolean result) {
+				if (result) {
+					this.callback.onComplete(null, this.context);
+				} else {
+					this.callback.onError("WriteTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class AppendTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public AppendTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected boolean doInBackground(Object... params) {
+				java.io.File javaFile = new java.io.File((String) params[0]);
+				FileOutputStream stream = null;
+				byte[] content = (byte[]) params[1];
+
+				try {
+					stream = new FileOutputStream(javaFile, true);
+					stream.write(content, 0, content.length);
+
+					return true;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to append file, FileNotFoundException: " + e.getMessage());
+					return false;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to write file, IOException: " + e.getMessage());
+					return false;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final boolean result) {
+				if (result) {
+					this.callback.onComplete(null, this.context);
+				} else {
+					this.callback.onError("AppendTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class AppendBufferTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public AppendBufferTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected boolean doInBackground(Object... params) {
+				java.io.File javaFile = new java.io.File((String) params[0]);
+				FileOutputStream stream = null;
+				ByteBuffer content = (ByteBuffer) params[1];
+
+				try {
+					stream = new FileOutputStream(javaFile, true);
+					FileChannel channel = stream.getChannel();
+					content.rewind();
+					channel.write(content);
+					content.rewind();
+					return true;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to append to file, FileNotFoundException: " + e.getMessage());
+					return false;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to append file, IOException: " + e.getMessage());
+					return false;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final boolean result) {
+				if (result) {
+					this.callback.onComplete(null, this.context);
+				} else {
+					this.callback.onError("AppendTask returns no result.", this.context);
+				}
+			}
+		}
+
+		static class AppendTextTask {
+			private final CompleteCallback callback;
+			private final Object context;
+
+			public AppendTextTask(CompleteCallback callback, Object context) {
+				this.callback = callback;
+				this.context = context;
+			}
+
+			protected boolean doInBackground(String... params) {
+				java.io.File javaFile = new java.io.File(params[0]);
+				FileOutputStream stream = null;
+				try {
+					stream = new FileOutputStream(javaFile, true);
+
+					OutputStreamWriter writer = new OutputStreamWriter(stream, params[2]);
+					writer.write(params[1]);
+					writer.close();
+
+					return true;
+				} catch (FileNotFoundException e) {
+					Log.e(TAG, "Failed to append file, FileNotFoundException: " + e.getMessage());
+					return false;
+				} catch (UnsupportedEncodingException e) {
+					Log.e(TAG, "Failed to append file, UnsupportedEncodingException: " + e.getMessage());
+					return false;
+				} catch (IOException e) {
+					Log.e(TAG, "Failed to append file, IOException: " + e.getMessage());
+					return false;
+				} finally {
+					if (stream != null) {
+						try {
+							stream.close();
+						} catch (IOException e) {
+							Log.e(TAG, "Failed to close stream, IOException: " + e.getMessage());
+						}
+					}
+				}
+			}
+
+			protected void onPostExecute(final boolean result) {
+				if (result) {
+					this.callback.onComplete(null, this.context);
+				} else {
+					this.callback.onError("AppendTextTask returns no result.", this.context);
+				}
+			}
+		}
+
+	}
+}