feat(performance): removed double memory usage when reading/writing text files (Acode-Foundation#2359)

RohitKushvaha01 · web-flow · commit b5ba27c932dc · 2026-06-23T13:30:02.000+05:30
* feat: removed double memory usage when reading/writing text files

* feat: improvements

* format

* fix: regression

* format

* feat: pin utf-8 for json

* format
diff --git a/src/fileSystem/externalFs.js b/src/fileSystem/externalFs.js
@@ -1,5 +1,5 @@
 import loader from "dialogs/loader";
-import { decode, encode } from "utils/encodings";
+import { decode, encode, getEncodingName } from "utils/encodings";
 import helpers from "utils/helpers";
 import Url from "utils/Url";
 
@@ -11,12 +11,26 @@ const externalFs = {
 		});
 	},
 
+	async readAsText(url, encoding) {
+		url = await this.formatUri(url);
+		return new Promise((resolve, reject) => {
+			sdcard.readAsText(url, encoding, resolve, reject);
+		});
+	},
+
 	async writeFile(filename, data) {
 		return new Promise(async (resolve, reject) => {
 			sdcard.write(filename, data, resolve, reject);
 		});
 	},
 
+	async writeText(filename, data, encoding) {
+		filename = await this.formatUri(filename);
+		return new Promise((resolve, reject) => {
+			sdcard.writeText(filename, data, encoding, resolve, reject);
+		});
+	},
+
 	async copy(src, dest) {
 		return new Promise((resolve, reject) => {
 			sdcard.copy(src, dest, resolve, reject);
@@ -178,17 +192,23 @@ function createFs(url) {
 			return externalFs.listDir(url);
 		},
 		async readFile(encoding) {
-			let { data } = await externalFs.readFile(url, encoding);
-
 			if (encoding) {
-				data = await decode(data, encoding);
+				const isJson = encoding === "json";
+				const charset = getEncodingName(isJson ? "utf-8" : encoding);
+				const text = await externalFs.readAsText(url, charset);
+				const stripped = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+				return isJson ? JSON.parse(stripped) : stripped;
 			}
 
+			let { data } = await externalFs.readFile(url);
 			return data;
 		},
 		async writeFile(content, encoding) {
 			if (typeof content === "string" && encoding) {
-				content = await encode(content, encoding);
+				const charset = getEncodingName(
+					encoding === "json" ? "utf-8" : encoding,
+				);
+				return externalFs.writeText(url, content, charset);
 			}
 			return externalFs.writeFile(url, content);
 		},
diff --git a/src/plugins/sdcard/src/android/SDcard.java b/src/plugins/sdcard/src/android/SDcard.java
@@ -24,6 +24,9 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintWriter;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
 import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -108,6 +111,9 @@ public boolean execute(
       case "read":
         readFile(arg1, callback);
         break;
+      case "readAsText":
+        readAsText(arg1, arg2, callback);
+        break;
       case "write":
         writeFile(
           formatUri(arg1),
@@ -116,6 +122,9 @@ public boolean execute(
           callback
         );
         break;
+      case "writeText":
+        writeText(arg1, arg2, arg3, callback);
+        break;
       case "rename":
         rename(arg1, arg2, callback);
         break;
@@ -476,6 +485,102 @@ public void run() {
       );
   }
 
+  private void readAsText(final String filename, final String encoding, final CallbackContext callback) {
+    cordova
+      .getThreadPool()
+      .execute(
+        new Runnable() {
+          public void run() {
+            try {
+              String formattedUri = formatUri(filename);
+              Uri uri = Uri.parse(formattedUri);
+              
+              String charSetName = encoding;
+              if (charSetName == null || charSetName.isEmpty() || "auto".equalsIgnoreCase(charSetName)) {
+                charSetName = "UTF-8";
+              }
+              if (!Charset.isSupported(charSetName)) {
+                callback.error("Charset not supported: " + charSetName);
+                return;
+              }
+              Charset charset = Charset.forName(charSetName);
+
+              InputStream is = context
+                .getContentResolver()
+                .openInputStream(uri);
+
+              if (is == null) {
+                callback.error("File not found");
+                return;
+              }
+
+              StringBuilder sb = new StringBuilder();
+              try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, charset))) {
+                char[] buffer = new char[8192];
+                int charsRead;
+                while ((charsRead = reader.read(buffer)) != -1) {
+                  sb.append(buffer, 0, charsRead);
+                }
+              }
+              callback.success(sb.toString());
+            } catch (Exception e) {
+              callback.error(e.toString());
+            }
+          }
+        }
+      );
+  }
+
+  private void writeText(
+    final String filename,
+    final String content,
+    final String encoding,
+    final CallbackContext callback
+  ) {
+    final Context context = this.context;
+
+    cordova
+      .getThreadPool()
+      .execute(
+        new Runnable() {
+          public void run() {
+            try {
+              String formattedUri = formatUri(filename);
+              DocumentFile file = getFile(formattedUri);
+              if (file == null) {
+                callback.error("File not found.");
+                return;
+              }
+              if (canWrite(file.getUri())) {
+                String charSetName = encoding;
+                if (charSetName == null || charSetName.isEmpty() || "auto".equalsIgnoreCase(charSetName)) {
+                  charSetName = "UTF-8";
+                }
+                if (!Charset.isSupported(charSetName)) {
+                  callback.error("Charset not supported: " + charSetName);
+                  return;
+                }
+                Charset charset = Charset.forName(charSetName);
+
+                try (OutputStream op = context
+                  .getContentResolver()
+                  .openOutputStream(file.getUri(), "rwt")) {
+                  byte[] bytes = content.getBytes(charset);
+                  op.write(bytes);
+                  op.flush();
+                }
+                callback.success("OK");
+              } else {
+                callback.error("No write permission");
+              }
+            } catch (Exception e) {
+              callback.error(e.toString());
+            }
+          }
+        }
+      );
+  }
+
   private void writeFile(
     final String filename,
     final String content,
diff --git a/src/plugins/sdcard/www/plugin.js b/src/plugins/sdcard/www/plugin.js
@@ -44,10 +44,16 @@ module.exports = {
   read: function (filename, onSuccess, onFail) {
     cordova.exec(onSuccess, onFail, 'SDcard', 'read', [filename]);
   },
+  readAsText: function (filename, encoding, onSuccess, onFail) {
+    cordova.exec(onSuccess, onFail, 'SDcard', 'readAsText', [filename, encoding]);
+  },
   write: function (filename, content, onSuccess, onFail) {
     var _isBuffer = content instanceof ArrayBuffer;
     cordova.exec(onSuccess, onFail, 'SDcard', 'write', [filename, content, _isBuffer]);
   },
+  writeText: function (filename, content, encoding, onSuccess, onFail) {
+    cordova.exec(onSuccess, onFail, 'SDcard', 'writeText', [filename, content, encoding]);
+  },
   stats: function (filename, onSuccess, onFail) {
     cordova.exec(onSuccess, onFail, 'SDcard', 'stats', [filename]);
   },
diff --git a/src/utils/encodings.js b/src/utils/encodings.js
@@ -151,6 +151,21 @@ export async function detectEncoding(buffer) {
 	return def === "auto" ? "UTF-8" : def || "UTF-8";
 }
 
+/**
+ * Resolves a charset string to the canonical encoding name.
+ * @param {string} charset
+ * @returns {string}
+ */
+export function getEncodingName(charset) {
+	if (!charset) {
+		charset = settings.value.defaultFileEncoding;
+	}
+
+	if (charset === "auto") charset = "UTF-8";
+
+	return getEncoding(charset).name;
+}
+
 /**
  * Decodes arrayBuffer to String according given encoding type
  * @param {ArrayBuffer} buffer
@@ -165,13 +180,7 @@ export async function decode(buffer, charset) {
 		isJson = true;
 	}
 
-	if (!charset) {
-		charset = settings.value.defaultFileEncoding;
-	}
-
-	if (charset === "auto") charset = "UTF-8";
-
-	charset = getEncoding(charset).name;
+	charset = getEncodingName(charset);
 	const text = await execDecode(buffer, charset);
 
 	if (isJson) {
@@ -188,13 +197,7 @@ export async function decode(buffer, charset) {
  * @returns {Promise<ArrayBuffer>}
  */
 export function encode(text, charset) {
-	if (!charset) {
-		charset = settings.value.defaultFileEncoding;
-	}
-
-	if (charset === "auto") charset = "UTF-8";
-
-	charset = getEncoding(charset).name;
+	charset = getEncodingName(charset);
 	return execEncode(text, charset);
 }
 
