Upload native_features.py

native_features.py

@@ -1091,13 +1091,30 @@ _NATIVE_BRIDGE_JS = r"""// capacitor-native-bridge.js — Auto-injected by APK C
   //     Starts progress UI immediately and streams network chunks in real time!
   // ═══════════════════════════════════════════════
   var origFetch = window.fetch;
+  // Bridge-internal bypass: saveDownloadToDevice / nativeEntryToFile must use
+  // origFetch directly so their network reads never re-enter this wrapper
+  // (prevents double DownloadUI cards). Exposed for the onCapReady closure.
+  window.__nativeOrigFetch = origFetch;
   window.fetch = async function(resource, init) {
+    // 0.3.0 INTERNAL BYPASS — never treat the bridge's own reads as downloads.
+    if (init && init.__nativeBridgeInternal) {
+      var cleanInit = {};
+      for (var _k in init) {
+        if (Object.prototype.hasOwnProperty.call(init, _k) && _k !== '__nativeBridgeInternal') cleanInit[_k] = init[_k];
+      }
+      return origFetch.call(this, resource, cleanInit);
+    }
     var url = '';
     if (typeof resource === 'string') {
       url = resource;
     } else if (resource && resource.url) {
       url = resource.url;
     }
+    // Internal Capacitor cache reads are never user downloads — skip wrapper entirely.
+    // (convertFileSrc() URLs look like http://localhost/_capacitor_file_/...)
+    if (url && (url.indexOf('/_capacitor_file_') !== -1 || url.indexOf('capacitor://') === 0)) {
+      return origFetch.apply(this, arguments);
+    }
 
     var isDownloadCandidate = false;
     var now = Date.now();
@@ -1252,7 +1269,9 @@ _NATIVE_BRIDGE_JS = r"""// capacitor-native-bridge.js — Auto-injected by APK C
       if (!blob && tf.localPath && window.Capacitor && window.Capacitor.convertFileSrc) {
         try {
           var webUrl = window.Capacitor.convertFileSrc(tf.localPath);
-          var resp = await fetch(webUrl);
+          // Bridge-internal read: bypass download-detection wrapper (no spurious DownloadUI).
+          var _of = window.__nativeOrigFetch || origFetch || window.fetch;
+          var resp = await _of.call(window, webUrl);
           if (resp.ok) {
             blob = await resp.blob();
           }
@@ -1520,9 +1539,23 @@ _NATIVE_BRIDGE_JS = r"""// capacitor-native-bridge.js — Auto-injected by APK C
     // ═══════════════════════════════════════════════
     // 2. ROBUST CHUNKED DOWNLOAD & SAVE TO DEVICE
     //    Intercepts <a download> and blob:/data: URLs.
-    //    Streams in 512KB chunks to MediaStore.Downloads.
-    //    Zero-OOM, auto-renames duplicates, and shows real-time progress UI!
+    //    PUMP-AND-FORWARD: network bytes stream straight to native in
+    //    512KB stages (never materialize a full Blob for http(s)).
+    //    Binder limit 1MB: 512KB raw -> ~683KB base64 + JSON < 800KB, safe.
+    //    Chunks are awaited sequentially (Java has no seq num, appends in
+    //    arrival order — parallel sends would corrupt file order).
+    //    Auto-renames duplicates, real-time progress UI, single card per download.
     // ═══════════════════════════════════════════════
+    // Binder-safe Uint8Array -> base64 without Blob/FileReader.
+    // Chunked fromCharCode avoids arg-stack overflow on 512KB arrays.
+    function uint8ToBase64(u8) {
+      var s = '';
+      var CH = 0x8000;
+      for (var i = 0; i < u8.length; i += CH) {
+        s += String.fromCharCode.apply(null, u8.subarray(i, i + CH));
+      }
+      return btoa(s);
+    }
     async function saveDownloadToDevice(url, suggestedFilename) {
       console.log('[NativeBridge] Intercepted download:', suggestedFilename, (url || '').slice(0, 50));
       var filename = (suggestedFilename || '').trim();
@@ -1549,28 +1582,110 @@ _NATIVE_BRIDGE_JS = r"""// capacitor-native-bridge.js — Auto-injected by APK C
 
       try {
         // 2. Fetch if not in blobStore (handles data: or remote http/https)
+        // PUMP-AND-FORWARD: http(s) bytes go network -> native directly in
+        // 512KB stages. Max JS accumulation = 512KB (plus one net read,
+        // typically 16-64KB). Never builds a full Blob for remote URLs,
+        // so a 30/100MB file peaks <1MB in JS instead of 2x file size.
         if (!blob) {
-          var resp = await fetch(url);
+          // Bridge-internal fetch: bypasses the window.fetch download wrapper
+          // above, so this read creates NO second DownloadUI card.
+          var _of2 = window.__nativeOrigFetch || origFetch || window.fetch;
+          var resp = await _of2.call(window, url);
           if (!resp.ok) throw new Error('Fetch failed with status ' + resp.status);
           var totalBytes = parseInt(resp.headers.get('content-length') || '0', 10);
-          var mimeType = resp.headers.get('content-type') || 'application/octet-stream';
+          var streamMime = resp.headers.get('content-type') || 'application/octet-stream';
           ui.update(0, totalBytes);
 
           if (resp.body && typeof resp.body.getReader === 'function') {
-            var reader = resp.body.getReader();
-            var netChunks = [];
-            var netLoaded = 0;
-            while (true) {
-              var nr = await reader.read();
-              if (nr.done) break;
-              if (nr.value) {
-                netChunks.push(nr.value);
-                netLoaded += nr.value.length;
-                ui.update(netLoaded, totalBytes || netLoaded);
+            // Fail-fast on permission before pulling bytes over the network.
+            if (window.Capacitor && window.Capacitor.isNativePlatform && window.Capacitor.isNativePlatform()) {
+              try {
+                var _perm = await callNative('NativeFolderHelper', 'checkStoragePermission', {});
+                if (_perm && _perm.granted === false) {
+                  ui.error({ message: 'File was not saved: Storage permission denied' });
+                  return null;
+                }
+              } catch (_pe) {}
+            }
+            var streamDownloadId = 'dl_' + Date.now() + '_' + Math.random().toString(36).slice(2, 7);
+            var STAGE_MAX = 512 * 1024; // 512KB raw -> ~683KB b64, well under 1MB binder
+            var staging = [];
+            var stagedLen = 0;
+            var streamedTotal = 0;
+            var streamFirst = true;
+            var streamLastRes = null;
+            var netReader = resp.body.getReader();
+
+            async function flushStage(isLast) {
+              if (stagedLen === 0) {
+                if (!isLast || !streamFirst) return;
+                // Empty file: still create the MediaStore entry.
+                streamLastRes = await callNative('NativeFolderHelper', 'saveFileChunk', {
+                  downloadId: streamDownloadId,
+                  filename: filename,
+                  mimeType: streamMime,
+                  chunk: '',
+                  isFirst: true,
+                  isLast: true,
+                  totalSize: totalBytes || 0
+                });
+                streamFirst = false;
+                return;
+              }
+              var combined = new Uint8Array(stagedLen);
+              var _pos = 0;
+              for (var _si = 0; _si < staging.length; _si++) {
+                combined.set(staging[_si], _pos);
+                _pos += staging[_si].length;
               }
+              staging = [];
+              stagedLen = 0;
+              var b64 = uint8ToBase64(combined);
+              // `combined`/ staging refs dropped here so GC can reclaim before next await.
+              streamLastRes = await callNative('NativeFolderHelper', 'saveFileChunk', {
+                downloadId: streamDownloadId,
+                filename: filename,
+                mimeType: streamMime,
+                chunk: b64,
+                isFirst: streamFirst,
+                isLast: !!isLast,
+                totalSize: totalBytes || 0
+              });
+              streamFirst = false;
             }
-            blob = new Blob(netChunks, { type: mimeType });
+
+            try {
+              while (true) {
+                var nr = await netReader.read();
+                if (nr.done) break;
+                if (nr.value) {
+                  staging.push(nr.value);
+                  stagedLen += nr.value.length;
+                  streamedTotal += nr.value.length;
+                  ui.update(streamedTotal, totalBytes || streamedTotal);
+                  // Flush as soon as we hit 512KB — data passes through immediately,
+                  // accumulation never exceeds STAGE_MAX + one net read.
+                  if (stagedLen >= STAGE_MAX) {
+                    await flushStage(false);
+                  }
+                }
+              }
+              await flushStage(true);
+            } catch (streamErr) {
+              // Partial MediaStore entry (IS_PENDING=1) may remain open in Java;
+              // there is currently no abortDownload() to delete it (see Part B).
+              try { if (netReader && netReader.cancel) await netReader.cancel(); } catch (_c) {}
+              throw streamErr;
+            }
+
+            var _sUri = (streamLastRes && streamLastRes.uri) || '';
+            var _sName = (streamLastRes && streamLastRes.filename) || filename;
+            var _sFolder = (streamLastRes && streamLastRes.folder) || 'Downloads';
+            ui.success(_sName, _sFolder, _sUri);
+            return streamLastRes;
           } else {
+            // No ReadableStream (blob:/data: in old WebViews): must materialize.
+            // Uses bypassed fetch's raw .blob() so no second DownloadUI card.
             blob = await resp.blob();
             ui.update(blob.size, blob.size);
           }