mirror of https://github.com/TeamNewPipe/NewPipe
384 lines
12 KiB
Java
384 lines
12 KiB
Java
package us.shandian.giga.io;
|
|
|
|
import android.annotation.TargetApi;
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.provider.DocumentsContract;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.documentfile.provider.DocumentFile;
|
|
import androidx.fragment.app.Fragment;
|
|
|
|
import org.schabi.newpipe.streams.io.SharpStream;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.Serializable;
|
|
import java.net.URI;
|
|
|
|
public class StoredFileHelper implements Serializable {
|
|
private static final long serialVersionUID = 0L;
|
|
public static final String DEFAULT_MIME = "application/octet-stream";
|
|
|
|
private transient DocumentFile docFile;
|
|
private transient DocumentFile docTree;
|
|
private transient File ioFile;
|
|
private transient Context context;
|
|
|
|
protected String source;
|
|
private String sourceTree;
|
|
|
|
protected String tag;
|
|
|
|
private String srcName;
|
|
private String srcType;
|
|
|
|
public StoredFileHelper(@Nullable Uri parent, String filename, String mime, String tag) {
|
|
this.source = null;// this instance will be "invalid" see invalidate()/isInvalid() methods
|
|
|
|
this.srcName = filename;
|
|
this.srcType = mime == null ? DEFAULT_MIME : mime;
|
|
if (parent != null) this.sourceTree = parent.toString();
|
|
|
|
this.tag = tag;
|
|
}
|
|
|
|
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
|
|
StoredFileHelper(@Nullable Context context, DocumentFile tree, String filename, String mime, boolean safe) throws IOException {
|
|
this.docTree = tree;
|
|
this.context = context;
|
|
|
|
DocumentFile res;
|
|
|
|
if (safe) {
|
|
// no conflicts (the filename is not in use)
|
|
res = this.docTree.createFile(mime, filename);
|
|
if (res == null) throw new IOException("Cannot create the file");
|
|
} else {
|
|
res = createSAF(context, mime, filename);
|
|
}
|
|
|
|
this.docFile = res;
|
|
|
|
this.source = docFile.getUri().toString();
|
|
this.sourceTree = docTree.getUri().toString();
|
|
|
|
this.srcName = this.docFile.getName();
|
|
this.srcType = this.docFile.getType();
|
|
}
|
|
|
|
StoredFileHelper(File location, String filename, String mime) throws IOException {
|
|
this.ioFile = new File(location, filename);
|
|
|
|
if (this.ioFile.exists()) {
|
|
if (!this.ioFile.isFile() && !this.ioFile.delete())
|
|
throw new IOException("The filename is already in use by non-file entity and cannot overwrite it");
|
|
} else {
|
|
if (!this.ioFile.createNewFile())
|
|
throw new IOException("Cannot create the file");
|
|
}
|
|
|
|
this.source = Uri.fromFile(this.ioFile).toString();
|
|
this.sourceTree = Uri.fromFile(location).toString();
|
|
|
|
this.srcName = ioFile.getName();
|
|
this.srcType = mime;
|
|
}
|
|
|
|
@TargetApi(Build.VERSION_CODES.KITKAT)
|
|
public StoredFileHelper(Context context, @Nullable Uri parent, @NonNull Uri path, String tag) throws IOException {
|
|
this.tag = tag;
|
|
this.source = path.toString();
|
|
|
|
if (path.getScheme() == null || path.getScheme().equalsIgnoreCase(ContentResolver.SCHEME_FILE)) {
|
|
this.ioFile = new File(URI.create(this.source));
|
|
} else {
|
|
DocumentFile file = DocumentFile.fromSingleUri(context, path);
|
|
|
|
if (file == null) throw new RuntimeException("SAF not available");
|
|
|
|
this.context = context;
|
|
|
|
if (file.getName() == null) {
|
|
this.source = null;
|
|
return;
|
|
} else {
|
|
this.docFile = file;
|
|
takePermissionSAF();
|
|
}
|
|
}
|
|
|
|
if (parent != null) {
|
|
if (!ContentResolver.SCHEME_FILE.equals(parent.getScheme()))
|
|
this.docTree = DocumentFile.fromTreeUri(context, parent);
|
|
|
|
this.sourceTree = parent.toString();
|
|
}
|
|
|
|
this.srcName = getName();
|
|
this.srcType = getType();
|
|
}
|
|
|
|
|
|
public static StoredFileHelper deserialize(@NonNull StoredFileHelper storage, Context context) throws IOException {
|
|
Uri treeUri = storage.sourceTree == null ? null : Uri.parse(storage.sourceTree);
|
|
|
|
if (storage.isInvalid())
|
|
return new StoredFileHelper(treeUri, storage.srcName, storage.srcType, storage.tag);
|
|
|
|
StoredFileHelper instance = new StoredFileHelper(context, treeUri, Uri.parse(storage.source), storage.tag);
|
|
|
|
// under SAF, if the target document is deleted, conserve the filename and mime
|
|
if (instance.srcName == null) instance.srcName = storage.srcName;
|
|
if (instance.srcType == null) instance.srcType = storage.srcType;
|
|
|
|
return instance;
|
|
}
|
|
|
|
public static void requestSafWithFileCreation(@NonNull Fragment who, int requestCode, String filename, String mime) {
|
|
// SAF notes:
|
|
// ACTION_OPEN_DOCUMENT Do not let you create the file, useful for overwrite files
|
|
// ACTION_CREATE_DOCUMENT No overwrite support, useless the file provider resolve the conflict
|
|
|
|
Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT)
|
|
.addCategory(Intent.CATEGORY_OPENABLE)
|
|
.setType(mime)
|
|
.putExtra(Intent.EXTRA_TITLE, filename)
|
|
.addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION | StoredDirectoryHelper.PERMISSION_FLAGS)
|
|
.putExtra("android.content.extra.SHOW_ADVANCED", true);// hack, show all storage disks
|
|
|
|
who.startActivityForResult(intent, requestCode);
|
|
}
|
|
|
|
|
|
public SharpStream getStream() throws IOException {
|
|
invalid();
|
|
|
|
if (docFile == null)
|
|
return new FileStream(ioFile);
|
|
else
|
|
return new FileStreamSAF(context.getContentResolver(), docFile.getUri());
|
|
}
|
|
|
|
/**
|
|
* Indicates whatever if is possible access using the {@code java.io} API
|
|
*
|
|
* @return {@code true} for Java I/O API, otherwise, {@code false} for Storage Access Framework
|
|
*/
|
|
public boolean isDirect() {
|
|
invalid();
|
|
|
|
return docFile == null;
|
|
}
|
|
|
|
public boolean isInvalid() {
|
|
return source == null;
|
|
}
|
|
|
|
public Uri getUri() {
|
|
invalid();
|
|
|
|
return docFile == null ? Uri.fromFile(ioFile) : docFile.getUri();
|
|
}
|
|
|
|
public Uri getParentUri() {
|
|
invalid();
|
|
|
|
return sourceTree == null ? null : Uri.parse(sourceTree);
|
|
}
|
|
|
|
public void truncate() throws IOException {
|
|
invalid();
|
|
|
|
try (SharpStream fs = getStream()) {
|
|
fs.setLength(0);
|
|
}
|
|
}
|
|
|
|
public boolean delete() {
|
|
if (source == null) return true;
|
|
if (docFile == null) return ioFile.delete();
|
|
|
|
|
|
boolean res = docFile.delete();
|
|
|
|
try {
|
|
int flags = Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION;
|
|
context.getContentResolver().releasePersistableUriPermission(docFile.getUri(), flags);
|
|
} catch (Exception ex) {
|
|
// nothing to do
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
public long length() {
|
|
invalid();
|
|
|
|
return docFile == null ? ioFile.length() : docFile.length();
|
|
}
|
|
|
|
public boolean canWrite() {
|
|
if (source == null) return false;
|
|
return docFile == null ? ioFile.canWrite() : docFile.canWrite();
|
|
}
|
|
|
|
public String getName() {
|
|
if (source == null)
|
|
return srcName;
|
|
else if (docFile == null)
|
|
return ioFile.getName();
|
|
|
|
String name = docFile.getName();
|
|
return name == null ? srcName : name;
|
|
}
|
|
|
|
public String getType() {
|
|
if (source == null || docFile == null)
|
|
return srcType;
|
|
|
|
String type = docFile.getType();
|
|
return type == null ? srcType : type;
|
|
}
|
|
|
|
public String getTag() {
|
|
return tag;
|
|
}
|
|
|
|
public boolean existsAsFile() {
|
|
if (source == null) return false;
|
|
|
|
// WARNING: DocumentFile.exists() and DocumentFile.isFile() methods are slow
|
|
boolean exists = docFile == null ? ioFile.exists() : docFile.exists();
|
|
boolean isFile = docFile == null ? ioFile.isFile() : docFile.isFile();// ¿docFile.isVirtual() means is no-physical?
|
|
|
|
return exists && isFile;
|
|
}
|
|
|
|
public boolean create() {
|
|
invalid();
|
|
boolean result;
|
|
|
|
if (docFile == null) {
|
|
try {
|
|
result = ioFile.createNewFile();
|
|
} catch (IOException e) {
|
|
return false;
|
|
}
|
|
} else if (docTree == null) {
|
|
result = false;
|
|
} else {
|
|
if (!docTree.canRead() || !docTree.canWrite()) return false;
|
|
try {
|
|
docFile = createSAF(context, srcType, srcName);
|
|
if (docFile == null || docFile.getName() == null) return false;
|
|
result = true;
|
|
} catch (IOException e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (result) {
|
|
source = (docFile == null ? Uri.fromFile(ioFile) : docFile.getUri()).toString();
|
|
srcName = getName();
|
|
srcType = getType();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public void invalidate() {
|
|
if (source == null) return;
|
|
|
|
srcName = getName();
|
|
srcType = getType();
|
|
|
|
source = null;
|
|
|
|
docTree = null;
|
|
docFile = null;
|
|
ioFile = null;
|
|
context = null;
|
|
}
|
|
|
|
public boolean equals(StoredFileHelper storage) {
|
|
if (this == storage) return true;
|
|
|
|
// note: do not compare tags, files can have the same parent folder
|
|
//if (stringMismatch(this.tag, storage.tag)) return false;
|
|
|
|
if (stringMismatch(getLowerCase(this.sourceTree), getLowerCase(this.sourceTree)))
|
|
return false;
|
|
|
|
if (this.isInvalid() || storage.isInvalid()) {
|
|
return this.srcName.equalsIgnoreCase(storage.srcName) && this.srcType.equalsIgnoreCase(storage.srcType);
|
|
}
|
|
|
|
if (this.isDirect() != storage.isDirect()) return false;
|
|
|
|
if (this.isDirect())
|
|
return this.ioFile.getPath().equalsIgnoreCase(storage.ioFile.getPath());
|
|
|
|
return DocumentsContract.getDocumentId(
|
|
this.docFile.getUri()
|
|
).equalsIgnoreCase(DocumentsContract.getDocumentId(
|
|
storage.docFile.getUri()
|
|
));
|
|
}
|
|
|
|
@NonNull
|
|
@Override
|
|
public String toString() {
|
|
if (source == null)
|
|
return "[Invalid state] name=" + srcName + " type=" + srcType + " tag=" + tag;
|
|
else
|
|
return "sourceFile=" + source + " treeSource=" + (sourceTree == null ? "" : sourceTree) + " tag=" + tag;
|
|
}
|
|
|
|
|
|
private void invalid() {
|
|
if (source == null)
|
|
throw new IllegalStateException("In invalid state");
|
|
}
|
|
|
|
private void takePermissionSAF() throws IOException {
|
|
try {
|
|
context.getContentResolver().takePersistableUriPermission(docFile.getUri(), StoredDirectoryHelper.PERMISSION_FLAGS);
|
|
} catch (Exception e) {
|
|
if (docFile.getName() == null) throw new IOException(e);
|
|
}
|
|
}
|
|
|
|
private DocumentFile createSAF(@Nullable Context context, String mime, String filename) throws IOException {
|
|
DocumentFile res = StoredDirectoryHelper.findFileSAFHelper(context, docTree, filename);
|
|
|
|
if (res != null && res.exists() && res.isDirectory()) {
|
|
if (!res.delete())
|
|
throw new IOException("Directory with the same name found but cannot delete");
|
|
res = null;
|
|
}
|
|
|
|
if (res == null) {
|
|
res = this.docTree.createFile(srcType == null ? DEFAULT_MIME : mime, filename);
|
|
if (res == null) throw new IOException("Cannot create the file");
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
private String getLowerCase(String str) {
|
|
return str == null ? null : str.toLowerCase();
|
|
}
|
|
|
|
private boolean stringMismatch(String str1, String str2) {
|
|
if (str1 == null && str2 == null) return false;
|
|
if ((str1 == null) != (str2 == null)) return true;
|
|
|
|
return !str1.equals(str2);
|
|
}
|
|
}
|