renun/legado
1
0
Fork 0
mirror of https://github.com/gedoor/legado.git synced 2025-08-10 00:52:30 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

实现epub的懒加载(未经广泛测试)

Browse Source
This commit is contained in:
ag2s20150909
2022-04-07 20:48:52 +08:00
parent dd9917ff0a
commit f621fc72d1
4 changed files with 570 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
epublib/src/main/java/me/ag2s/epublib/util/Android11CloseGuard.java Normal file
View File

@@ -0,0 +1,33 @@
package me.ag2s.epublib.util;
import android.os.Build;
import android.util.CloseGuard;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
@RequiresApi(api = Build.VERSION_CODES.R)
final class Android11CloseGuard implements AndroidCloseGuard {
@NonNull
private final CloseGuard mImpl;
public Android11CloseGuard() {
mImpl = new CloseGuard();
}
@Override
public void open(@NonNull String closeMethodName) {
mImpl.open(closeMethodName);
}
@Override
public void close() {
mImpl.close();
}
@Override
public void warnIfOpen() {
mImpl.warnIfOpen();
}
}

38
epublib/src/main/java/me/ag2s/epublib/util/AndroidCloseGuard.java Normal file
View File

@@ -0,0 +1,38 @@
package me.ag2s.epublib.util;
import android.os.Build;
import androidx.annotation.NonNull;
public interface AndroidCloseGuard {
public static AndroidCloseGuard getInstance() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
return new Android11CloseGuard();
} else {
return new AndroidRefCloseGuard();
}
}
/**
* Initializes the instance with a warning that the caller should have explicitly called the
* {@code closeMethodName} method instead of relying on finalization.
*
* @param closeMethodName non-null name of explicit termination method. Printed by warnIfOpen.
* @throws NullPointerException if closeMethodName is null.
*/
void open(@NonNull String closeMethodName);
/**
* Marks this CloseGuard instance as closed to avoid warnings on finalization.
*/
void close();
/**
* Logs a warning if the caller did not properly cleanup by calling an explicit close method
* before finalization.
*/
void warnIfOpen();
}

83
epublib/src/main/java/me/ag2s/epublib/util/AndroidRefCloseGuard.java Normal file
View File

@@ -0,0 +1,83 @@
package me.ag2s.epublib.util;
import androidx.annotation.NonNull;
import java.lang.reflect.Method;
final class AndroidRefCloseGuard implements AndroidCloseGuard {
private static Object closeGuardInstance;
private static Method getMethod;
private static Method closeMethod;
private static Method openMethod;
private static Method warnIfOpenMethod;
public AndroidRefCloseGuard() {
if (getMethod == null || closeMethod == null || openMethod == null || warnIfOpenMethod == null) {
try {
Class<?> closeGuardClass = Class.forName("dalvik.system.CloseGuard");
getMethod = closeGuardClass.getMethod("get");
closeMethod = closeGuardClass.getMethod("close");
openMethod = closeGuardClass.getMethod("open", String.class);
warnIfOpenMethod = closeGuardClass.getMethod("warnIfOpen");
} catch (Exception ignored) {
getMethod = null;
openMethod = null;
warnIfOpenMethod = null;
}
}
}
Object createAndOpen(String closer) {
if (getMethod != null) {
try {
if (closeGuardInstance == null) {
closeGuardInstance = getMethod.invoke(null);
}
openMethod.invoke(closeGuardInstance, closer);
return closeGuardInstance;
} catch (Exception ignored) {
}
}
return null;
}
boolean warnIfOpen(Object closeGuardInstance) {
boolean reported = false;
if (closeGuardInstance != null) {
try {
warnIfOpenMethod.invoke(closeGuardInstance);
reported = true;
} catch (Exception ignored) {
}
}
return reported;
}
@Override
public void open(@NonNull String closeMethodName) {
closeGuardInstance = createAndOpen(closeMethodName);
}
@Override
public void close() {
if (closeGuardInstance != null) {
try {
closeMethod.invoke(closeMethod);
} catch (Exception ignored) {
}
}
}
@Override
public void warnIfOpen() {
warnIfOpen(closeGuardInstance);
}
}

522
epublib/src/main/java/me/ag2s/epublib/zip/AndroidRandomReadableFile.java
View File

@@ -2,6 +2,7 @@ package me.ag2s.epublib.zip;
import android.content.Context;
import android.net.Uri;
import android.os.Build;
import android.os.ParcelFileDescriptor;
import android.system.ErrnoException;
import android.system.OsConstants;
@@ -16,26 +17,30 @@ import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UTFDataFormatException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import me.ag2s.epublib.util.AndroidCloseGuard;
public class AndroidRandomReadableFile implements DataInput, Closeable {
private ParcelFileDescriptor pfd;
private final ParcelFileDescriptor pfd;
private FileInputStream fis;
private DataInputStream dis;
public long pos = 0;
private long pos = 0;
private final AndroidCloseGuard guard = AndroidCloseGuard.getInstance();
public AndroidRandomReadableFile(@NonNull Context context, @NonNull Uri treeUri) throws FileNotFoundException {
try {
pfd = context.getContentResolver().openFileDescriptor(treeUri, "r");
fis = new FileInputStream(pfd.getFileDescriptor());
dis = new DataInputStream(fis);
} catch (FileNotFoundException e) {
throw e;
}
pfd = context.getContentResolver().openFileDescriptor(treeUri, "r");
fis = new FileInputStream(pfd.getFileDescriptor());
//dis = new DataInputStream(fis);
guard.open("close");
}
public final FileDescriptor getFD() {
return pfd.getFileDescriptor();
}
@@ -48,38 +53,73 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
public final FileInputStream getFileInputStream() {
if (fis == null || pos != getPos()) {
if (fis == null || this.pos != getPos()) {
this.pos = getPos();
fis = new FileInputStream(pfd.getFileDescriptor());
}
return fis;
}
/**
* Reads a byte of data from this input stream. This method blocks
* if no input is yet available.
*
* @return the next byte of data, or <code>-1</code> if the end of the
* file is reached.
* @throws IOException if an I/O error occurs.
*/
public int read() throws IOException {
byte[] b = new byte[1];
return (read(b, 0, 1) != -1) ? b[0] & 0xff : -1;
}
public int read(byte[] b) {
try {
return read(b, 0, b.length);
} catch (IOException e) {
e.printStackTrace();
return -1;
}
/**
* Reads up to <code>b.length</code> bytes of data from this input
* stream into an array of bytes. This method blocks until some input
* is available.
*
* @param b the buffer into which the data is read.
* @return the total number of bytes read into the buffer, or
* <code>-1</code> if there is no more data because the end of
* the file has been reached.
* @throws IOException if an I/O error occurs.
*/
public int read(byte[] b) throws IOException {
return read(b, 0, b.length);
}
/**
* Reads up to <code>len</code> bytes of data from this input stream
* into an array of bytes. If <code>len</code> is not zero, the method
* blocks until some input is available; otherwise, no
* bytes are read and <code>0</code> is returned.
*
* @param b the buffer into which the data is read.
* @param off the start offset in the destination array <code>b</code>
* @param len the maximum number of bytes read.
* @return the total number of bytes read into the buffer, or
* <code>-1</code> if there is no more data because the end of
* the file has been reached.
* @throws NullPointerException If <code>b</code> is <code>null</code>.
* @throws IndexOutOfBoundsException If <code>off</code> is negative,
* <code>len</code> is negative, or <code>len</code> is greater than
* <code>b.length - off</code>
* @throws IOException if an I/O error occurs.
*/
public int read(byte[] b, int off, int len) throws IOException {
try {
return android.system.Os.read(pfd.getFileDescriptor(), b, off, len);
} catch (Exception e) {
return -1;
throw new IOException(e);
}
}
private void syncInputStream() {
this.pos = getPos();
fis = new FileInputStream(pfd.getFileDescriptor());
dis = new DataInputStream(fis);
}
@@ -110,6 +150,46 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
/**
* Reads some bytes from an input
* stream and stores them into the buffer
* array {@code b}. The number of bytes
* read is equal
* to the length of {@code b}.
* <p>
* This method blocks until one of the
* following conditions occurs:
* <ul>
* <li>{@code b.length}
* bytes of input data are available, in which
* case a normal return is made.
*
* <li>End of
* file is detected, in which case an {@code EOFException}
* is thrown.
*
* <li>An I/O error occurs, in
* which case an {@code IOException} other
* than {@code EOFException} is thrown.
* </ul>
* <p>
* If {@code b} is {@code null},
* a {@code NullPointerException} is thrown.
* If {@code b.length} is zero, then
* no bytes are read. Otherwise, the first
* byte read is stored into element {@code b[0]},
* the next one into {@code b[1]}, and
* so on.
* If an exception is thrown from
* this method, then it may be that some but
* not all bytes of {@code b} have been
* updated with data from the input stream.
*
* @param b the buffer into which the data is read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public void readFully(byte[] b) throws IOException {
try {
@@ -121,6 +201,49 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
/**
* Reads {@code len}
* bytes from
* an input stream.
* <p>
* This method
* blocks until one of the following conditions
* occurs:
* <ul>
* <li>{@code len} bytes
* of input data are available, in which case
* a normal return is made.
*
* <li>End of file
* is detected, in which case an {@code EOFException}
* is thrown.
*
* <li>An I/O error occurs, in
* which case an {@code IOException} other
* than {@code EOFException} is thrown.
* </ul>
* <p>
* If {@code b} is {@code null},
* a {@code NullPointerException} is thrown.
* If {@code off} is negative, or {@code len}
* is negative, or {@code off+len} is
* greater than the length of the array {@code b},
* then an {@code IndexOutOfBoundsException}
* is thrown.
* If {@code len} is zero,
* then no bytes are read. Otherwise, the first
* byte read is stored into element {@code b[off]},
* the next one into {@code b[off+1]},
* and so on. The number of bytes read is,
* at most, equal to {@code len}.
*
* @param b the buffer into which the data is read.
* @param off an int specifying the offset into the data.
* @param len an int specifying the number of bytes to read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public void readFully(byte[] b, int off, int len) throws IOException {
try {
@@ -131,6 +254,27 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
}
/**
* Makes an attempt to skip over
* {@code n} bytes
* of data from the input
* stream, discarding the skipped bytes. However,
* it may skip
* over some smaller number of
* bytes, possibly zero. This may result from
* any of a
* number of conditions; reaching
* end of file before {@code n} bytes
* have been skipped is
* only one possibility.
* This method never throws an {@code EOFException}.
* The actual
* number of bytes skipped is returned.
*
* @param n the number of bytes to be skipped.
* @return the number of bytes actually skipped.
* @throws IOException if an I/O error occurs.
*/
@Override
public int skipBytes(int n) throws IOException {
try {
@@ -142,6 +286,19 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
/**
* Reads one input byte and returns
* {@code true} if that byte is nonzero,
* {@code false} if that byte is zero.
* This method is suitable for reading
* the byte written by the {@code writeBoolean}
* method of interface {@code DataOutput}.
*
* @return the {@code boolean} value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public boolean readBoolean() throws IOException {
int ch = this.read();
@@ -151,6 +308,20 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
/**
* Reads and returns one input byte.
* The byte is treated as a signed value in
* the range {@code -128} through {@code 127},
* inclusive.
* This method is suitable for
* reading the byte written by the {@code writeByte}
* method of interface {@code DataOutput}.
*
* @return the 8-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public byte readByte() throws IOException {
int ch = this.read();
@@ -160,6 +331,24 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
}
/**
* Reads one input byte, zero-extends
* it to type {@code int}, and returns
* the result, which is therefore in the range
* {@code 0}
* through {@code 255}.
* This method is suitable for reading
* the byte written by the {@code writeByte}
* method of interface {@code DataOutput}
* if the argument to {@code writeByte}
* was intended to be a value in the range
* {@code 0} through {@code 255}.
*
* @return the unsigned 8-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public int readUnsignedByte() throws IOException {
int ch = this.read();
@@ -170,30 +359,131 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
private final byte[] readBuffer = new byte[8];
/**
* Reads two input bytes and returns
* a {@code short} value. Let {@code a}
* be the first byte read and {@code b}
* be the second byte. The value
* returned
* is:
* <pre>{@code (short)((a << 8) | (b & 0xff))
* }</pre>
* This method
* is suitable for reading the bytes written
* by the {@code writeShort} method of
* interface {@code DataOutput}.
*
* @return the 16-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public short readShort() throws IOException {
readFully(readBuffer, 0, 2);
return ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asShortBuffer().get();
}
/**
* Reads two input bytes and returns
* an {@code int} value in the range {@code 0}
* through {@code 65535}. Let {@code a}
* be the first byte read and
* {@code b}
* be the second byte. The value returned is:
* <pre>{@code (((a & 0xff) << 8) | (b & 0xff))
* }</pre>
* This method is suitable for reading the bytes
* written by the {@code writeShort} method
* of interface {@code DataOutput} if
* the argument to {@code writeShort}
* was intended to be a value in the range
* {@code 0} through {@code 65535}.
*
* @return the unsigned 16-bit value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public int readUnsignedShort() throws IOException {
readFully(readBuffer, 0, 2);
return ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asShortBuffer().get() & 0xffff;
}
/**
* Reads two input bytes and returns a {@code char} value.
* Let {@code a}
* be the first byte read and {@code b}
* be the second byte. The value
* returned is:
* <pre>{@code (char)((a << 8) | (b & 0xff))
* }</pre>
* This method
* is suitable for reading bytes written by
* the {@code writeChar} method of interface
* {@code DataOutput}.
*
* @return the {@code char} value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public char readChar() throws IOException {
readFully(readBuffer, 0, 2);
return (char) ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asShortBuffer().get();
}
/**
* Reads four input bytes and returns an
* {@code int} value. Let {@code a-d}
* be the first through fourth bytes read. The value returned is:
* <pre>{@code
* (((a & 0xff) << 24) | ((b & 0xff) << 16) |
* ((c & 0xff) << 8) | (d & 0xff))
* }</pre>
* This method is suitable
* for reading bytes written by the {@code writeInt}
* method of interface {@code DataOutput}.
*
* @return the {@code int} value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public int readInt() throws IOException {
readFully(readBuffer, 0, 4);
return ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asIntBuffer().get();
}
/**
* Reads eight input bytes and returns
* a {@code long} value. Let {@code a-h}
* be the first through eighth bytes read.
* The value returned is:
* <pre>{@code
* (((long)(a & 0xff) << 56) |
* ((long)(b & 0xff) << 48) |
* ((long)(c & 0xff) << 40) |
* ((long)(d & 0xff) << 32) |
* ((long)(e & 0xff) << 24) |
* ((long)(f & 0xff) << 16) |
* ((long)(g & 0xff) << 8) |
* ((long)(h & 0xff)))
* }</pre>
* <p>
* This method is suitable
* for reading bytes written by the {@code writeLong}
* method of interface {@code DataOutput}.
*
* @return the {@code long} value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public long readLong() throws IOException {
readFully(readBuffer, 0, 8);
@@ -207,11 +497,47 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
((readBuffer[7] & 255) << 0));
}
/**
* Reads four input bytes and returns
* a {@code float} value. It does this
* by first constructing an {@code int}
* value in exactly the manner
* of the {@code readInt}
* method, then converting this {@code int}
* value to a {@code float} in
* exactly the manner of the method {@code Float.intBitsToFloat}.
* This method is suitable for reading
* bytes written by the {@code writeFloat}
* method of interface {@code DataOutput}.
*
* @return the {@code float} value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
}
/**
* Reads eight input bytes and returns
* a {@code double} value. It does this
* by first constructing a {@code long}
* value in exactly the manner
* of the {@code readLong}
* method, then converting this {@code long}
* value to a {@code double} in exactly
* the manner of the method {@code Double.longBitsToDouble}.
* This method is suitable for reading
* bytes written by the {@code writeDouble}
* method of interface {@code DataOutput}.
*
* @return the {@code double} value read.
* @throws EOFException if this stream reaches the end before reading
* all the bytes.
* @throws IOException if an I/O error occurs.
*/
@Override
public double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
@@ -219,6 +545,32 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
private char[] lineBuffer;
/**
* See the general contract of the <code>readLine</code>
* method of <code>DataInput</code>.
* <p>
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return the next line of text from this input stream.
* @throws IOException if an I/O error occurs.
* @see java.io.BufferedReader#readLine()
* @see java.io.FilterInputStream##in
* @deprecated This method does not properly convert bytes to characters.
* As of JDK&nbsp;1.1, the preferred way to read lines of text is via the
* <code>BufferedReader.readLine()</code> method. Programs that use the
* <code>DataInputStream</code> class to read lines can be converted to use
* the <code>BufferedReader</code> class by replacing code of the form:
* <blockquote><pre>
* DataInputStream d =&nbsp;new&nbsp;DataInputStream(in);
* </pre></blockquote>
* with:
* <blockquote><pre>
* BufferedReader d
* =&nbsp;new&nbsp;BufferedReader(new&nbsp;InputStreamReader(in));
* </pre></blockquote>
*/
@Deprecated
@Override
public String readLine() throws IOException {
@@ -260,109 +612,67 @@ public class AndroidRandomReadableFile implements DataInput, Closeable {
return String.copyValueOf(buf, 0, offset);
}
/**
* See the general contract of the <code>readUTF</code>
* method of <code>DataInput</code>.
* <p>
* Bytes
* for this operation are read from the contained
* input stream.
*
* @return a Unicode string.
* @throws EOFException if this input stream reaches the end before
* reading all the bytes.
* @throws IOException the stream has been closed and the contained
* input stream does not support reading after close, or
* another I/O error occurs.
* @throws UTFDataFormatException if the bytes do not represent a valid
* modified UTF-8 encoding of a string.
* @see java.io.DataInputStream#readUTF(java.io.DataInput)
*/
@Override
public String readUTF() throws IOException {
if (pos != getPos()) {
syncInputStream();
}
return dis.readUTF();
return DataInputStream.readUTF(this);
}
// public final static String readUTF(DataInput in) throws IOException {
// int utflen = in.readUnsignedShort();
// byte[] bytearr = null;
// char[] chararr = null;
// if (in instanceof DataInputStream) {
// DataInputStream dis = (DataInputStream)in;
// if (dis.bytearr.length < utflen){
// dis.bytearr = new byte[utflen*2];
// dis.chararr = new char[utflen*2];
// }
// chararr = dis.chararr;
// bytearr = dis.bytearr;
// } else {
// bytearr = new byte[utflen];
// chararr = new char[utflen];
// }
//
// int c, char2, char3;
// int count = 0;
// int chararr_count=0;
//
// in.readFully(bytearr, 0, utflen);
//
// while (count < utflen) {
// c = (int) bytearr[count] & 0xff;
// if (c > 127) break;
// count++;
// chararr[chararr_count++]=(char)c;
// }
//
// while (count < utflen) {
// c = (int) bytearr[count] & 0xff;
// switch (c >> 4) {
// case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
// /* 0xxxxxxx*/
// count++;
// chararr[chararr_count++]=(char)c;
// break;
// case 12: case 13:
// /* 110x xxxx 10xx xxxx*/
// count += 2;
// if (count > utflen)
// throw new UTFDataFormatException(
// "malformed input: partial character at end");
// char2 = (int) bytearr[count-1];
// if ((char2 & 0xC0) != 0x80)
// throw new UTFDataFormatException(
// "malformed input around byte " + count);
// chararr[chararr_count++]=(char)(((c & 0x1F) << 6) |
// (char2 & 0x3F));
// break;
// case 14:
// /* 1110 xxxx 10xx xxxx 10xx xxxx */
// count += 3;
// if (count > utflen)
// throw new UTFDataFormatException(
// "malformed input: partial character at end");
// char2 = (int) bytearr[count-2];
// char3 = (int) bytearr[count-1];
// if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))
// throw new UTFDataFormatException(
// "malformed input around byte " + (count-1));
// chararr[chararr_count++]=(char)(((c & 0x0F) << 12) |
// ((char2 & 0x3F) << 6) |
// ((char3 & 0x3F) << 0));
// break;
// default:
// /* 10xx xxxx, 1111 xxxx */
// throw new UTFDataFormatException(
// "malformed input around byte " + count);
// }
// }
// // The number of chars produced may be less than utflen
// return new String(chararr, 0, chararr_count);
// }
@Override
public void close() throws IOException {
try {
dis.close();
} catch (Exception e) {
e.printStackTrace();
}
guard.close();
if (Build.VERSION.SDK_INT >= 28) {
//Reference.reachabilityFence(this);
}
try {
fis.close();
if (fis != null) {
fis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
try {
pfd.close();
if (pfd != null) {
pfd.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
protected void finalize() throws Throwable {
try {
// Note that guard could be null if the constructor threw.
guard.warnIfOpen();
close();
} finally {
super.finalize();
}
}
}