413 lines
12 KiB
Java
413 lines
12 KiB
Java
package com.mogo.utils;
|
|
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.net.Uri;
|
|
import android.text.TextUtils;
|
|
import android.util.Base64;
|
|
import android.util.Log;
|
|
|
|
import androidx.annotation.IntRange;
|
|
import androidx.core.content.FileProvider;
|
|
|
|
import java.io.BufferedInputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.FileWriter;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStreamWriter;
|
|
|
|
/**
|
|
* 文件工具类
|
|
*/
|
|
public class FileUtils {
|
|
public static boolean createFileDir(String fileDir) {
|
|
if (TextUtils.isEmpty(fileDir)) {
|
|
return false;
|
|
}
|
|
try {
|
|
File dir = new File(fileDir);
|
|
if(!dir.exists()){
|
|
return dir.mkdirs();
|
|
}
|
|
return dir.exists();
|
|
} catch (Exception e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static boolean createFileDir(File dir) {
|
|
if (dir == null) {
|
|
return false;
|
|
}
|
|
try {
|
|
return dir.exists() || dir.mkdir();
|
|
} catch (Exception e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static void writeToFile(String fileDir, String fileName, String content) {
|
|
if (fileDir == null || fileName == null || content == null) {
|
|
return;
|
|
}
|
|
if (!createFileDir(fileDir)) {
|
|
return;
|
|
}
|
|
FileOutputStream fos = null;
|
|
OutputStreamWriter osw = null;
|
|
try {
|
|
fos = new FileOutputStream(fileDir + fileName, true);
|
|
osw = new OutputStreamWriter(fos);
|
|
osw.write(content);
|
|
osw.flush();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
IOUtils.closeSilently(fos);
|
|
IOUtils.closeSilently(osw);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read a text file into a String, optionally limiting the length.
|
|
*/
|
|
public static String readTextFile(File file) {
|
|
InputStream is = null;
|
|
BufferedInputStream bis = null;
|
|
ByteArrayOutputStream bos = null;
|
|
String text = null;
|
|
try {
|
|
is = new FileInputStream(file);
|
|
bis = new BufferedInputStream(is);
|
|
bos = new ByteArrayOutputStream();
|
|
int len;
|
|
byte[] data = new byte[1024];
|
|
do {
|
|
len = bis.read(data);
|
|
if (len > 0) bos.write(data, 0, len);
|
|
} while (len == data.length);
|
|
text = bos.toString();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
IOUtils.closeSilently(is);
|
|
IOUtils.closeSilently(bis);
|
|
IOUtils.closeSilently(bos);
|
|
}
|
|
return text;
|
|
}
|
|
|
|
public static String fileToBase64(File file) {
|
|
String base64 = null;
|
|
InputStream in = null;
|
|
try {
|
|
in = new FileInputStream(file);
|
|
byte[] bytes = new byte[in.available()];
|
|
int length = in.read(bytes);
|
|
base64 = Base64.encodeToString(bytes, 0, length, Base64.DEFAULT);
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
IOUtils.closeSilently(in);
|
|
}
|
|
return base64;
|
|
}
|
|
|
|
/**
|
|
* Writes string to file. Basically same as "echo -n $string > $filename"
|
|
*/
|
|
public static void stringToFile(String filename, String string) {
|
|
FileWriter out = null;
|
|
try {
|
|
out = new FileWriter(filename);
|
|
out.write(string);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
IOUtils.closeSilently(out);
|
|
}
|
|
}
|
|
|
|
public static InputStream stringToStream(String content) {
|
|
InputStream inputStream = null;
|
|
try {
|
|
inputStream = new ByteArrayInputStream(content.getBytes());
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return inputStream;
|
|
}
|
|
|
|
public static String streamToString(InputStream is) throws IOException {
|
|
String content = null;
|
|
try {
|
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
|
int i = -1;
|
|
while ((i = is.read()) != -1) {
|
|
bos.write(i);
|
|
}
|
|
content = bos.toString();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return content;
|
|
}
|
|
|
|
public static String getStringFromFile(Context context, String fileName) {
|
|
FileInputStream fis = null;
|
|
ByteArrayOutputStream os = null;
|
|
String content = null;
|
|
try {
|
|
fis = context.openFileInput(fileName);
|
|
os = new ByteArrayOutputStream();
|
|
byte[] buffer = new byte[1024];
|
|
int length = -1;
|
|
while ((length = fis.read(buffer)) != -1) {
|
|
os.write(buffer, 0, length);
|
|
}
|
|
content = os.toString();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
IOUtils.closeSilently(fis);
|
|
IOUtils.closeSilently(os);
|
|
}
|
|
return content;
|
|
}
|
|
|
|
public static InputStream getStreamFromFile(Context context, String fileName) {
|
|
FileInputStream fis = null;
|
|
try {
|
|
fis = context.openFileInput(fileName);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return fis;
|
|
}
|
|
|
|
public static void saveStringToFile(Context context, String content, String fileName) {
|
|
try {
|
|
FileOutputStream fos = context.openFileOutput(fileName, Context.MODE_PRIVATE);
|
|
fos.write(content.getBytes());
|
|
IOUtils.closeSilently(fos);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 将scheme为file的uri转成FileProvider 提供的content uri
|
|
*/
|
|
public static Uri convertFileUriToFileProviderUri(Context context, Uri uri) {
|
|
if (uri == null) return null;
|
|
if (ContentResolver.SCHEME_FILE.equals(uri.getScheme())) {
|
|
return getUriForFile(context, new File(uri.getPath()));
|
|
}
|
|
return uri;
|
|
|
|
}
|
|
|
|
/**
|
|
* 创建一个用于拍照图片输出路径的Uri (FileProvider)
|
|
*/
|
|
public static Uri getUriForFile(Context context, File file) {
|
|
return FileProvider.getUriForFile(context, getFileProviderName(context), file);
|
|
}
|
|
|
|
public static String getFileProviderName(Context context) {
|
|
return context.getPackageName() + ".fileprovider";
|
|
}
|
|
|
|
/**
|
|
* 把Uri 解析出文件绝对路径
|
|
*/
|
|
public static String parseOwnUri(Context context, Uri uri) {
|
|
if (uri == null) return null;
|
|
String path;
|
|
if (TextUtils.equals(uri.getAuthority(), getFileProviderName(context))) {
|
|
path = new File(uri.getPath()).getAbsolutePath();
|
|
} else {
|
|
path = uri.getPath();
|
|
}
|
|
return path;
|
|
}
|
|
|
|
public static String getFileStreamPath(Context context, String name) {
|
|
String absFileName = null;
|
|
try {
|
|
File file = context.getFileStreamPath(name);
|
|
if (file != null && file.exists()) {
|
|
absFileName = file.getAbsolutePath();
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return absFileName;
|
|
}
|
|
|
|
|
|
/**
|
|
* 拷贝文件数据到指定目录
|
|
*
|
|
* @param is
|
|
* @param to
|
|
* @param listener
|
|
*/
|
|
public static void copy(final InputStream is, final String to, final FileCopyListener listener) {
|
|
new Thread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
Log.w("FileUtils", "======copy======");
|
|
|
|
if (listener != null) {
|
|
listener.onStart();
|
|
}
|
|
|
|
try {
|
|
|
|
long fileSize = is.available();
|
|
long process = 0;
|
|
|
|
byte[] buff = new byte[1024];
|
|
int rc = 0;
|
|
|
|
File toFile = new File(to);
|
|
if (!toFile.getParentFile().exists()) {
|
|
toFile.getParentFile().mkdirs();
|
|
}
|
|
|
|
FileOutputStream fos = new FileOutputStream(toFile);
|
|
|
|
while ((rc = is.read(buff, 0, 1024)) > 0) {
|
|
process += rc;
|
|
fos.write(buff, 0, rc);
|
|
if (listener != null) {
|
|
listener.onProcess(((int) (((float) process) * 100 / fileSize)));
|
|
}
|
|
}
|
|
|
|
fos.flush();
|
|
fos.close();
|
|
is.close();
|
|
|
|
} catch (Exception e) {
|
|
if (listener != null) {
|
|
listener.onFail(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (listener != null) {
|
|
listener.onFinish(to);
|
|
}
|
|
}
|
|
}).start();
|
|
}
|
|
|
|
/**
|
|
* 拷贝文件到制定目录
|
|
*
|
|
* @param from
|
|
* @param to
|
|
* @param listener
|
|
*/
|
|
public static void copy(final String from, final String to, final FileCopyListener listener) {
|
|
new Thread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
File file = null;
|
|
try {
|
|
file = new File(from);
|
|
} catch (Exception e) {
|
|
if (listener != null) {
|
|
listener.onFail(e);
|
|
}
|
|
return;
|
|
}
|
|
if (!file.isFile()) {
|
|
if (listener != null) {
|
|
listener.onFail(new Exception(String.format("%s is not a file", from)));
|
|
return;
|
|
}
|
|
}
|
|
if (!file.exists()) {
|
|
if (listener != null) {
|
|
listener.onFail(new FileNotFoundException(String.format("%s is not exists.", from)));
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (listener != null) {
|
|
listener.onStart();
|
|
}
|
|
|
|
long fileSize = file.length();
|
|
long process = 0;
|
|
|
|
try {
|
|
FileInputStream fis = new FileInputStream(file);
|
|
|
|
byte[] buff = new byte[1024];
|
|
int rc = 0;
|
|
|
|
File toFile = new File(to);
|
|
if (!toFile.getParentFile().exists()) {
|
|
toFile.getParentFile().mkdirs();
|
|
}
|
|
|
|
FileOutputStream fos = new FileOutputStream(toFile);
|
|
|
|
while ((rc = fis.read(buff, 0, 1024)) > 0) {
|
|
process += rc;
|
|
fos.write(buff, 0, rc);
|
|
if (listener != null) {
|
|
listener.onProcess(((int) (((float) process) * 100 / fileSize)));
|
|
}
|
|
}
|
|
|
|
fos.flush();
|
|
fos.close();
|
|
fis.close();
|
|
|
|
} catch (Exception e) {
|
|
if (listener != null) {
|
|
listener.onFail(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (listener != null) {
|
|
listener.onFinish(to);
|
|
}
|
|
}
|
|
}).start();
|
|
}
|
|
|
|
|
|
/**
|
|
* 文件拷贝监听
|
|
*/
|
|
public interface FileCopyListener {
|
|
// 开始
|
|
void onStart();
|
|
|
|
// 失败
|
|
void onFail(Exception e);
|
|
|
|
// 进度
|
|
void onProcess(@IntRange(from = 0, to = 100) int process);
|
|
|
|
// 结束成功
|
|
void onFinish(String toPath);
|
|
}
|
|
|
|
}
|