Fuck off the buffer

app/src/main/java/com/hippo/ehviewer/gallery/ArchiveGalleryProvider.java

@@ -204,7 +204,7 @@ public class ArchiveGalleryProvider extends GalleryProvider2 {
                     continue;
                 }
 
-                Pipe pipe = new Pipe(4096 * 16);
+                Pipe pipe = new Pipe();
 
                 synchronized (streams) {
                     if (streams.get(index) != null) {
@@ -214,7 +214,8 @@ public class ArchiveGalleryProvider extends GalleryProvider2 {
                     streams.notify();
                 }
 
-                archiveAccessor.extractTargetIndexToOutputStream(index, pipe.getOutputStream());
+                archiveAccessor.extracttoOutputStream(index, pipe.getOutputFd());
+                pipe.closeOutputFd();
             }
         }
     }

app/src/main/java/com/hippo/ehviewer/gallery/Pipe.java

@@ -16,141 +16,37 @@
 
 package com.hippo.ehviewer.gallery;
 
-import androidx.annotation.NonNull;
+import android.os.ParcelFileDescriptor;
 
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStream;
 
 class Pipe {
-
-    private final int capacity;
-    private final byte[] buffer;
-
-    private int head = 0;
-    private int tail = 0;
-    private boolean full = false;
-
-    private boolean inClosed = false;
-    private boolean outClosed = false;
-
-    private final InputStream inputStream = new InputStream() {
-        @Override
-        public int read() throws IOException {
-            synchronized (Pipe.this) {
-                byte[] bytes = new byte[1];
-                if (read(bytes, 0, 1) != -1) {
-                    return bytes[0];
-                } else {
-                    return -1;
-                }
-            }
+    private ParcelFileDescriptor[] fd;
+    {
+        try {
+            fd = ParcelFileDescriptor.createPipe();
+        } catch (IOException e) {
+            e.printStackTrace();
         }
-
-        @Override
-        public int read(@NonNull byte[] b, int off, int len) throws IOException {
-            synchronized (Pipe.this) {
-                for (; ; ) {
-                    if (inClosed) {
-                        throw new IOException("The InputStream is closed");
-                    }
-                    if (len == 0) {
-                        return 0;
-                    }
-
-                    if (head == tail && !full) {
-                        if (outClosed) {
-                            // No bytes available and the OutputStream is closed. So it's the end.
-                            return -1;
-                        } else {
-                            // Wait for OutputStream write bytes
-                            try {
-                                Pipe.this.wait();
-                            } catch (InterruptedException e) {
-                                throw new IOException("The thread interrupted", e);
-                            }
-                        }
-                    } else {
-                        int read = Math.min(len, (head < tail ? tail : capacity) - head);
-                        System.arraycopy(buffer, head, b, off, read);
-                        head += read;
-                        if (head == capacity) {
-                            head = 0;
-                        }
-                        full = false;
-                        Pipe.this.notifyAll();
-                        return read;
-                    }
-                }
-            }
-        }
-
-        @Override
-        public void close() {
-            synchronized (Pipe.this) {
-                inClosed = true;
-                Pipe.this.notifyAll();
-            }
-        }
-    };
-
-    private final OutputStream outputStream = new OutputStream() {
-        @Override
-        public void write(int b) throws IOException {
-            synchronized (Pipe.this) {
-                byte[] bytes = new byte[]{(byte) b};
-                write(bytes, 0, 1);
-            }
-        }
-
-        @Override
-        public void write(@NonNull byte[] b, int off, int len) throws IOException {
-            synchronized (Pipe.this) {
-                while (len != 0) {
-                    if (head == tail && full) {
-                        // The buffer is full, wait for InputStream read bytes
-                        try {
-                            Pipe.this.wait();
-                        } catch (InterruptedException e) {
-                            throw new IOException("The thread interrupted", e);
-                        }
-                    } else {
-                        int write = Math.min(len, (head <= tail ? capacity : head) - tail);
-                        System.arraycopy(b, off, buffer, tail, write);
-                        off += write;
-                        len -= write;
-                        tail += write;
-                        if (tail == capacity) {
-                            tail = 0;
-                        }
-                        if (head == tail) {
-                            full = true;
-                        }
-                        Pipe.this.notifyAll();
-                    }
-                }
-            }
-        }
-
-        @Override
-        public void close() {
-            synchronized (Pipe.this) {
-                outClosed = true;
-                Pipe.this.notifyAll();
-            }
-        }
-    };
-
-    Pipe(int capacity) {
-        this.capacity = capacity;
-        this.buffer = new byte[capacity];
     }
 
+    private final InputStream inputStream = new FileInputStream(fd[0].getFileDescriptor());
+
     InputStream getInputStream() {
         return inputStream;
     }
 
-    OutputStream getOutputStream() {
-        return outputStream;
+    int getOutputFd() {
+        return fd[1].getFd();
+    }
+
+    void closeOutputFd() {
+        try {
+            fd[1].close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 }