Android_应用层_File封装读写存储

开篇介绍：

   其实这边文章是之前SP，SQlite存储的最后一篇，也就是Android的3种存储方式（当然不包括内存啦），File文件存储，对于缓存历史信息和用户一些可公开信息，例如网上的缩略图，小视频等等，SDCard存储还是很有必要的，这篇完成，应用层存储的也就结束了。

废话不多说，直接上代码，大家可以参考指正

package com.huawei.genexcloud.base.framework.utils;

import android.content.Context;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.os.Environment;
import android.os.StatFs;

import com.huawei.genexcloud.base.framework.log.GCLogger;
import com.huawei.genexcloud.base.framework.log.Module;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.text.DecimalFormat;
import java.text.Normalizer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
/**
*@author zhanglong
****2016-3-20
***/

public class FileUtil {
public static final int MIN_AVAILABLE_SIZE = 100;
private static final int ONE_KILO_BYTES = 1024;
private static final int ONE_MEGA_BYTES = 1024 * 1024;

/**
* 判断SDcard是否可用, 已经挂载并且拥有可读可写权限 true 可用
*/
public static boolean ifSDcardMounted() {
String path = "/HWUserData";
File file = new File(path);
if (file.exists()) {
if (!file.canWrite()) {
return false;
}
StatFs sf = new StatFs(file.getPath());
long availCount = sf.getAvailableBlocks();
return availCount > 0;
} else {
return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
}
}

/**
* 创建文件夹
*
* @throws IOException
*/
public static boolean createDirector(String directorFilePath) {
if (null == directorFilePath) {
return false;
}

String[] dirStructure = parseDirStructure(directorFilePath);
File file;
boolean isSucceed = true;
for (int i = 0; i < dirStructure.length; i++) {
file = new File(dirStructure[i]);
if (!file.exists()) {
isSucceed = (isSucceed && file.mkdir());
if (i == dirStructure.length - 1) {
return isSucceed;
}
}
}
return false;
}

/**
* 移动资源配置文件至制定路径
*/
public static void writeResToPhone(Context context, String fileName, int res) {
InputStream inputStream = null;
FileOutputStream outputStream = null;
try {
if (isFileExist(fileName)) {
return;
}
createFile(fileName);

inputStream = context.getResources().openRawResource(res);
outputStream = new FileOutputStream(fileName);
write(inputStream, outputStream);
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeResToPhone(res) Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeResToPhone(res) IOException");
} finally {
IOUtil.closeInputStream(inputStream);
IOUtil.closeOutputStream(outputStream);
}
}

/**
* 移动Assets目录下的文件
*/
public static boolean writeAssetToPhone(Context context, String assetPath, String dir) {

File file = new File(dir);

if (!file.exists()) {
file.mkdir();
}

String[] fileList = getAllFiles(dir);
if (null != fileList) {
if (fileList.length != 0) {
return true;
}
}

AssetManager assetManager = context.getAssets();
if (!dir.endsWith("/")) {
dir += File.separator;
}
String[] files;
try {
files = assetManager.list(assetPath);
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]writeAssetToPhone(dir) IOException");
return false;
}

return writeFiles(assetPath, dir, assetManager, files);
}

public static String read(String assetsPath, Context context) {

BufferedReader reader = null;
InputStream in = null;
StringBuffer bufferContent = new StringBuffer();
String lineContent;
try {
in = context.getAssets().open(assetsPath);
reader = new BufferedReader(new InputStreamReader(in));
while ((lineContent = reader.readLine()) != null) {
bufferContent.append(lineContent);
}
return bufferContent.toString();
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]readFileByLine() IOException");
} finally {

10b86
IOUtil.closeInputStream(in);
IOUtil.closeReader(reader);
}
return "";
}

private static boolean writeFiles(String assetPath, String dir, AssetManager assetManager, String[] files) {
boolean isSuccess = false;

for (String strSvy : files) {
String filePath = assetPath + File.separator + strSvy;
InputStream inputStream = null;
FileOutputStream outputStream = null;
try {
inputStream = assetManager.open(filePath);
outputStream = new FileOutputStream(dir + strSvy);
isSuccess = write(inputStream, outputStream);
} catch (FileNotFoundException e) {
GCLogger.error(Module.FILE_MANAGER, "[FileUtil] writeAssetToPhone(dir) for{} Exception");
isSuccess = false;
} catch (IOException e) {
GCLogger.error(Module.FILE_MANAGER, "[FileUtil]writeAssetToPhone(dir) for{} IOException");
isSuccess = false;
} finally {
IOUtil.closeInputStream(inputStream);
IOUtil.closeOutputStream(outputStream);
}
}
return isSuccess;
}

private static boolean write(InputStream inputStream, OutputStream outputStream) throws IOException {
int count;
byte[] buffer = new byte[1024];
while ((count = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, count);
}
outputStream.flush();

return true;
}

public static void writeContinueContent(String path, String conent) {
BufferedWriter out = null;
try {
out = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(path, true)));
out.write(conent);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

public static void closeRandomAccessFile(RandomAccessFile randomAccessFile) {
if (null != randomAccessFile) {
try {
randomAccessFile.close();
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] closeRandomAccessFile() IOException");
}
}
}

/**
* 创建文件,fileName为文件全路径加文件名
*/
public static boolean createFile(String fileName) {
String[] dirStructure = parseDirStructure(fileName);
File file;
for (int i = 0; i < dirStructure.length; i++) {
file = new File(dirStructure[i]);
if (i == dirStructure.length - 1) {
if (!file.isFile()) {
return createNewFile(file);
}
} else {
makeFileDirectory(file);
}
}
return false;
}

/**
* 通过提供的文件名在默认路径下生成文件
*
* @param fileName 文件的名称
* @return 生成的文件
*/
public static File createFileByName(String fileName) {
File file = new File(fileName);
if (!isFileExist(file)) {
try {
file.createNewFile();
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]" + e.toString());
}
}
return file;
}

/**
* 是否存在此文件
*
* @param file 判断是否存在的文件
* @return 存在返回true，否则返回false
*/
public static boolean isFileExist(final File file) {
// 在无SD卡时file会为空
if (file == null) {
return false;
}
if (file.exists()) {
return true;
} else {
return false;
}
}

private static void makeFileDirectory(File file) {
if (!file.exists()) {
boolean isCreateFileDirectorySuccess = file.mkdir();
if (!isCreateFileDirectorySuccess) {
GCLogger.error(Module.UTILITIES, new StringBuffer("[FileUtil] : makeFileDirectory(File file), ")
.append("Make directory failed!").toString());
}
}
}

/**
* 删除标准文件
*/
public static boolean deleteFile(String fileName) {
return isFileExist(fileName) && (new File(fileName).delete());
}

private static boolean deleteFile(File file) {
return file.exists() && file.delete();
}

/**
* 删除某个目录下的所有文件，但不删除该目录
*/
public static boolean deleteFiles(File dir) {
if (null == dir) {
return false;
}
if (!dir.isDirectory()) {
return deleteFile(dir);
}

boolean isSucceed = true;
File[] files = dir.listFiles();
if (null != files) {
for (File file : files) {
isSucceed &= deleteFiles(file);
}
}
return isSucceed;
}

public static boolean deleteDir(File dir) {
if (!dir.isDirectory()) {
return deleteFile(dir);
}

boolean isSucceed = true;

File[] files = dir.listFiles();
if (null != files) {
for (File file : files) {
isSucceed &= deleteDir(file);
}
}

isSucceed &= dir.delete();
return isSucceed;
}

/**
* @param context
* @param srcName The name of the file to open; can not contain path separators.
* @param dest
*/
public static void copyFile(Context context, String srcName, String dest) {
InputStream inputStream = null;
OutputStream outputStream = null;
try {
inputStream = context.openFileInput(srcName);
File file = new File(dest);
if (!file.exists()) {
file.createNewFile();
}
outputStream = new FileOutputStream(dest);
write(inputStream, outputStream);
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] copyFile(src)Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] copyFile(src)IOException");
} finally {
IOUtil.closeInputStream(inputStream);
IOUtil.closeOutputStream(outputStream);
}
}

public static void copyFile(String src, String dest) {
InputStream inputStream = null;
OutputStream outputStream = null;
try {
inputStream = new BufferedInputStream(new FileInputStream(src));
File file = new File(dest);
if (!file.exists()) {
file.createNewFile();
}
outputStream = new FileOutputStream(dest);
write(inputStream, outputStream);
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] copyFile()Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] copyFile()IOException");
} finally {
IOUtil.closeInputStream(inputStream);
IOUtil.closeOutputStream(outputStream);
}
}

public static boolean isFileExist(String filePath) {
if (null == filePath) {
return false;
}

File file = new File(filePath);
return file.isFile();
}

private static boolean createNewFile(File file) {
try {
return file.createNewFile();
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] createNewFile()IOException");
return false;
}
}

public static boolean isNoSpaceLeft(String root) {
return getAvailableFileSize(root) < MIN_AVAILABLE_SIZE;
}

/**
* 判断空间是否足够 >100M
*/
public static boolean isEnoughSpaceLeft(String root, int fileSize) {
long spaceLeft = getAvailableFileSize(root);
return spaceLeft * ONE_KILO_BYTES > (long) fileSize * ONE_MEGA_BYTES;
}

public static long getAvailableFileSize(String root) {
try {
StatFs statFs = new StatFs(root);
long blockSize = statFs.getBlockSize();
long availableBlocks = statFs.getAvailableBlocks();
return blockSize * availableBlocks / 1024;
} catch (IllegalArgumentException e) {
GCLogger.error(Module.UTILITIES, new StringBuffer("[FileUtil] getAvailableFileSize()Exception").toString());
return Long.MAX_VALUE;
}
}

public static ArrayList<String> searchFileToString(String path, String postfix) {
path = Normalizer.normalize(path, Normalizer.Form.NFKC);
if (!path.endsWith("/")) {
path = path + "/";
}

ArrayList<String> fileToString = new ArrayList<String>();
File file = new File(path);
if (!file.exists() || !file.isDirectory()) {
return fileToString;
}
File[] files = file.listFiles();
if (null != files) {
addFileNameToList(path, postfix, fileToString, files);
}
return fileToString;
}

private static void addFileNameToList(String path, String postfix, ArrayList<String> fileToString, File[] files) {
for (File file1 : files) {
if (file1.isFile()) {
String name = file1.getName();
if (name.endsWith(postfix)) {
fileToString.add(path + file1.getName());
}
}
}
}

private static String[] parseDirStructure(String remotePathName) {
ArrayList<String> dirList = new ArrayList<String>();
String path = remotePathName;
int index = 0;
for (int i = 0; i < path.length(); i++) {
if (path.charAt(i) == '/' && i > 0) {
dirList.add(path.substring(0, i));
index = i;
}
}
if (index < path.length()) {
dirList.add(path.substring(0, path.length()));
}
String[] retStr = new String[dirList.size()];
return dirList.toArray(retStr);
}

public static String formatFilePath(String filePath) {
if (!filePath.endsWith("/")) {
filePath += File.separator;
}
return filePath;
}

public static String[] getAllFiles(String remotePathName) {
File file = new File(remotePathName);
if (!file.isDirectory()) {
return new String[0];
}
return file.list();
}

public static File[] getFiles(File dir, FilenameFilter filenameFilter) {
if (!dir.isDirectory()) {
return new File[0];
}
return dir.listFiles(filenameFilter);
}

public static File getFile(String path) {
File file = new File(path);
if (!file.isDirectory()) {
return file;
}
return null;
}

/**
* 检查记录文件的大小
*/
public static int getFileCurrentSize(File file) {
return (int) ((file.length() + 1024) / 1024);// kb
}

/**
* 获取执行路径下的所有文件列表，按最后修改时间排序
*/
public static List<String> getAllFilesByLastModifyTime(String remotePathName) {
List<String> allFilesName = new ArrayList<String>();
File file = new File(remotePathName);
if (!file.isDirectory()) {
return new ArrayList<String>();
}
File[] fileList = file.listFiles();
if (null != fileList) {
// 按照文件最后修改时间排序
sortFiles(fileList);

for (File f : fileList) {
if (f.getAbsoluteFile().isFile()) {
allFilesName.add(f.getName());
}
}
}
return allFilesName;
}

private static void sortFiles(File[] fileList) {
Arrays.sort(fileList, new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
if (o1.lastModified() < o2.lastModified()) {
return 1;
} else if (o1.lastModified() == o2.lastModified()) {
return 0;
} else {
return -1;
}
}
});
}

public static String getDefaultFileName(String mIMEI) {
String strFileName = mIMEI + "_" + getCurrentTime();
return strFileName;
}

public static String getCurrentTime() {
DecimalFormat df = new DecimalFormat("00");
Calendar c = Calendar.getInstance();
String currentTime = c.get(Calendar.YEAR) + df.format((c.get(Calendar.MONTH) + 1))
+ df.format(c.get(Calendar.DAY_OF_MONTH)) + df.format(c.get(Calendar.HOUR_OF_DAY))
+ df.format(c.get(Calendar.MINUTE)) + df.format(c.get(Calendar.SECOND));
return currentTime;
}

public static long getDirTotalSize(String rootDir) {
File dir = new File(rootDir);

File[] files = dir.listFiles();
if (null == files) {
return 0;
}
long chrFileLen = 0;
for (File file : files) {
chrFileLen += file.length();
}

return chrFileLen;
}

public static String getFileName(String filePath) {
if (null == filePath) {
return null;
}
filePath = pathFilter(filePath);
int end = filePath.lastIndexOf(".");
int start = filePath.lastIndexOf("/");
return filePath.substring(start + 1, end);
}

public static String getFileFullName(String filePath) {
if (null == filePath) {
return null;
}
filePath = pathFilter(filePath);
int start = filePath.lastIndexOf("/");
return filePath.substring(start + 1);
}

public static String pathFilter(String path) {
path = path.replace(" ", "");
path = path.replace("\\", "/");
while (path.indexOf("//") != -1) {
path = path.replace("//", "/");
}
return path;
}

public static void renameFile(String oldname, String newname) {
if (!oldname.equals(newname)) {
File oldfile = new File(oldname);
File newfile = new File(newname);
renameFile(oldfile, newfile);
}
}

public static void renameFile(String path, String oldname, String newname) {
if (!oldname.equals(newname)) {
File oldfile = new File(oldname);
File newfile = new File(newname);
renameFile(oldfile, newfile);
}
}

private static boolean renameFile(File oldfile, File newfile) {
// 若在该目录下已经有一个文件和新文件名相同，则不允许重命名
return !newfile.exists() && oldfile.renameTo(newfile);
}

public static byte[] readFile(File file) {
if (null == file || !file.isFile()) {
return null;
}

ByteArrayOutputStream outputStream = null;
InputStream inputStream = null;
try {
inputStream = new BufferedInputStream(new FileInputStream(file));
outputStream = new ByteArrayOutputStream(1024);

write(inputStream, outputStream);
byte[] bytes = outputStream.toByteArray();
return bytes;
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] readFile(byte)Exception");
return null;
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] readFile(byte)IOException");
return null;
} finally {
IOUtil.closeOutputStream(outputStream);
IOUtil.closeInputStream(inputStream);
}
}

public static boolean writeFile(byte[] value, File file) {
if (null == value) {
return false;
}
BufferedOutputStream out = null;
try {
out = new BufferedOutputStream(new FileOutputStream(file));
out.write(value);
return true;
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeFile(boolean)Exception");
FileUtil.deleteDir(file);
return false;
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeFile(boolean)IOException");
FileUtil.deleteDir(file);
return false;
} finally {
IOUtil.closeOutputStream(out);
}
}

public static boolean writeToAndroid(String srcFilePath, String destFileName, Context context) {
InputStream inputStream = null;
FileOutputStream outputStream = null;
try {
inputStream = new FileInputStream(srcFilePath);
outputStream = context.openFileOutput(destFileName, Context.MODE_PRIVATE);
write(inputStream, outputStream);
return true;
} catch (FileNotFoundException fe) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeToAndroid()Exception Exception");
return false;
} catch (IOException ie) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeToAndroid()IOException");
return false;
} finally {
IOUtil.closeInputStream(inputStream);
IOUtil.closeOutputStream(outputStream);
}
}

public static boolean isDirectoryExist(String path) {
File file = new File(path);
return file.isDirectory();
}

public static void delAllExpiredFile(String path, int validPeriod) {
File file = new File(path);
File[] files = file.listFiles(new NoDirFileFilter());
if (null != files) {
for (File file1 : files) {
if (isFileExpired(file1, validPeriod)) {
deleteFile(file1);
}
}
}
}

private static boolean isFileExpired(File file, int validPeriod) {
if (!file.isFile()) {
return false;
}
return TimeUtil.isExpired(file.lastModified(), System.currentTimeMillis(), validPeriod);
}

static class NoDirFileFilter implements FileFilter {
@Override
public boolean accept(File file) {
return file.isFile();
}

}

public static LinkedList<File> convertFileArrayToList(File[] files) {
LinkedList<File> fileList = new LinkedList<File>();
if (files.length > 0) {
for (File file : files) {
fileList.add(file);
}
}
return fileList;
}

public static String readFileOnlyOneLine(File file) {
BufferedReader reader = null;
String lineContent = null;
if (validateFile(file)) {
try {
reader = new BufferedReader(new FileReader(file));
lineContent = reader.readLine();
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]readFileOnlyOneLine() Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] readFileOnlyOneLine() IOException");
} finally {
IOUtil.closeReader(reader);
}
}
return lineContent;
}

public static String readFileByLine(File file) {
StringBuffer bufferContent = new StringBuffer();

if (validateFile(file)) {
BufferedReader reader = null;
String lineContent;

try {
reader = new BufferedReader(new FileReader(file));
while ((lineContent = reader.readLine()) != null) {
bufferContent.append(lineContent + "\n");
}
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]readFileByLine() Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]readFileByLine() IOException");
} finally {
IOUtil.closeReader(reader);
}
}
return bufferContent.toString();
}

/**
* 读取assets文本
*
* @param assetsName
* @return
*/
public static String readAssetsString(Context context, String assetsName) {
StringBuilder stringBuilder = new StringBuilder();
try {
BufferedReader bf = new BufferedReader(
new InputStreamReader(context.getAssets().open(assetsName), "UTF-8"));
String line;
while ((line = bf.readLine()) != null) {
stringBuilder.append(line);
}
} catch (IOException e) {
e.printStackTrace();
}
return stringBuilder.toString();
}

public static String readFileWithoutLine(String path) {
File file = new File(path);
StringBuffer bufferContent = new StringBuffer();

if (validateFile(file)) {
BufferedReader reader = null;
String lineContent;

try {
reader = new BufferedReader(new FileReader(file));
while ((lineContent = reader.readLine()) != null) {
bufferContent.append(lineContent);
}
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]readFileByLine() Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]readFileByLine() IOException");
} finally {
IOUtil.closeReader(reader);
}
}
return bufferContent.toString();
}

public static void writeFile(File file, String content) {
BufferedWriter writer = null;

try {
writer = new BufferedWriter(new FileWriter(file));
writer.write(content);
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeFile()IOException");
} finally {
IOUtil.closeWriter(writer);
}
}

public static void writeFileContinue(File file, String content) {
BufferedWriter bufferedWriter = null;
FileWriter fileWriter = null;

try {
fileWriter = new FileWriter(file, true);
bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write(content);
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeFileContinue()IOException");
} catch (OutOfMemoryError e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeFileContinue()Error");
} finally {
IOUtil.closeWriter(bufferedWriter);
IOUtil.closeWriter(fileWriter);
}
}

public static void writeContent(BufferedWriter writer, String content) {
if (null == writer) {
return;
}

try {
writer.write(content);
writer.newLine();
writer.flush();
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil] writeContent()IOException");
}
}

public static void createFileWithConstContent(String fileName, int fileSize) {
if (fileSize <= 0) {
return;
}
createFile(fileName);
BufferedOutputStream outputStream = null;
try {
outputStream = new BufferedOutputStream(new FileOutputStream(new File(fileName)));
byte[] oneKBytes = new byte[ONE_KILO_BYTES];
for (int i = 0; i < fileSize; i++) {
outputStream.write(oneKBytes);
outputStream.flush();
}
} catch (FileNotFoundException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]createFileWithConstContent() Exception");
} catch (IOException e) {
GCLogger.error(Module.UTILITIES, "[FileUtil]createFileWithConstContent() IOException");
} finally {
IOUtil.closeOutputStream(outputStream);
}
}

private static boolean validateFile(File file) {
return file.exists() && file.isFile();
}

public static String getApkAboutInformation(String path, String defaultStr) {
File buildTimeFile = new File(path);
String content = readFileOnlyOneLine(buildTimeFile);
return null == content ? defaultStr : content;
}

public static boolean moveOrRewriteFile(String src, String dest) {

if (!isFileExist(src)) {
return false;
}
if (isFileExist(dest)) {
deleteFile(dest);
}
copyFile(src, dest);
deleteFile(src);
return true;
}

public static long getFileSize(Module module, File file) {
if (file.exists()) {
return file.length();
} else { //
GCLogger.debug("module", "File is not exist!");
}
return 0;
}

public static void clearData(FileInputStream inputStream, byte[] readBuffer) {
try {
long fileSize;
do {
fileSize = inputStream.read(readBuffer);
if (fileSize <= 0) {
return;
}
} while (fileSize == readBuffer.length);
} catch (IOException e) {
GCLogger.error(Module.DIAG_MANAGER, "[FileUtil] clearData()IOException");
}
}

/**
* 检查SD卡是否存在
*
* @return 是否存在
*/
public static boolean isSdCardAvailable() {

return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}

/**
* 文件或文件夹是否存在
*/
public static boolean isFileOrPathExist(String filePath) {
if (null == filePath) {
return false;
}

File file = new File(filePath);
return file.exists();
}

/**
* 获取文件名,区分大小写
**/
public static String getFileNameIgnoreCase(String fileName, String directory) {
if (null == directory) {
return null;
}

String[] fileList = FileUtil.getAllFiles(directory);
if (null == fileList) {
return null;
}

for (int i = 0; i < fileList.length; i++) {
if (fileName.equalsIgnoreCase(fileList[i])) {
return fileList[i];
}
}
return null;
}

public static List<String> getAllFile(File root) {
List<String> fileList = new ArrayList<String>();
File files[] = root.listFiles();
if (files != null) {
for (File file : files) {
if (file.isDirectory()) {
getAllFile(file);
} else {
if (file.toString().endsWith("png") || file.toString().endsWith("PNG")) {
fileList.add(file.getName());
}

}
}
}

return fileList;
}

//得到该目录下所有后缀是.txt的文件名
public static List<String> getAllTxtFileNameForDir(File dir) {
List<String> fileList = new ArrayList<>();
File[] files = dir.listFiles();
if (null != files) {
for (File file : files) {
if (file.toString().endsWith(".txt")) {
fileList.add(file.getName());
}
}
}
return fileList;
}

/**
* 获取插件化   文件夹路径  的公用方法
*
* @return
*/
public static String getPluginGlobalDir() {
String pluginsDir = getPublicDataRootDir() + "/plugins/";
File fileDir = new File(pluginsDir);
if (!fileDir.exists()) {
boolean mkdir = fileDir.mkdirs();
}
return pluginsDir;
}

/**
* 获取插件化  文件夹temp路径   的公用方法
*
* @return
*/
public static String getPluginTempDir() {
String pluginsDir = getPublicDataRootDir() + "/plugins/temp/";
File fileDir1 = new File(pluginsDir);
if (!fileDir1.exists()) {
boolean mkdir = fileDir1.mkdirs();
}
return pluginsDir;
}

/**
* 此方法用于修改存储路径的公用接口
*
* @return
*/
public static String getPublicDataRootDir() {

return EnvironmentInfo.getDataRootDirectory();
//return EnvironmentInfo.getProductFileDirectory();
}

/**
* 获取图片本地地址
*
* @param context
* @param imageID
* @return
*/
public static String getIconAddress(Context context, int imageID) {
Resources res = context.getResources();
BitmapDrawable d = (BitmapDrawable) res.getDrawable(imageID);
Bitmap img = d.getBitmap();

String fn = imageID + ".PNG";
String path = FileUtil.getPluginTempDir() + fn;

try {
OutputStream os = new FileOutputStream(path);
//把bitmap压缩成png
img.compress(Bitmap.CompressFormat.PNG, 100, os);
os.close();
return path;
} catch (Exception e) {
return "";
}
}

}