package com.hwc.oklib.util;
import android.annotation.SuppressLint;
import android.content.ContentResolver;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Environment;
import android.os.StatFs;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;
import java.io.BufferedOutputStream;
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.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* @author 黄伟才
* @ClassName: FileUtil
* @Description: 操作文件工具类
* @date 2015-10-19 下午6:28:40
*/
public class FileUtil {
private static final String TAG = "BitmapCommonUtils";
private static final long POLY64REV = 0x95AC9329AC4BC9B5L;
private static final long INITIALCRC = 0xFFFFFFFFFFFFFFFFL;
private static long[] sCrcTable = new long[256];
public enum PathStatus {SUCCESS, EXITS, ERROR}
/**
* 删除文件夹
*
* @param folderPath 文件夹完整绝对路径
*/
public static void delFolder(String folderPath) {
try {
delAllFile(folderPath); // 删除完里面所有内容
String filePath = folderPath;
filePath = filePath.toString();
File myFilePath = new File(filePath);
myFilePath.delete(); // 删除空文件夹
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 删除所有文件
*
* @param path 文件夹的路径
* @return
*/
public static boolean delAllFile(String path) {
boolean flag = false;
File file = new File(path);
if (!file.exists()) {
return flag;
}
if (!file.isDirectory()) {
return flag;
}
String[] tempList = file.list();
File temp = null;
for (int i = 0; i < tempList.length; i++) {
if (path.endsWith(File.separator)) {
temp = new File(path + tempList[i]);
} else {
temp = new File(path + File.separator + tempList[i]);
}
if (temp.isFile()) {
temp.delete();
}
if (temp.isDirectory()) {
delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
delFolder(path + "/" + tempList[i]);// 再删除空文件夹
flag = true;
}
}
return flag;
}
/**
* 写文本文件 在Android系统中，文件保存在 /data/data/PACKAGE_NAME/files 目录下，，，测试不通过
*
* @param context
* @param fileName
* @param content
*/
public static void write(Context context, String fileName, String content) {
if (content == null)
content = "";
try {
FileOutputStream fos = context.openFileOutput(fileName,
Context.MODE_PRIVATE);
fos.write(content.getBytes());
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取文本文件，，，测试不通过
*
* @param context
* @param fileName
* @return
*/
public static String read(Context context, String fileName) {
try {
FileInputStream in = context.openFileInput(fileName);
return readInStream(in);
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
/**
* 获取字符串
*
* @param inStream
* @return
*/
private static String readInStream(FileInputStream inStream) {
try {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
byte[] buffer = new byte[512];
int length = -1;
while ((length = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, length);
}
outStream.close();
inStream.close();
return outStream.toString();
} catch (IOException e) {
Log.i("FileTest", e.getMessage());
}
return null;
}
/**
* 创建文件
*
* @param folderPath
* @param fileName
* @return
*/
public static File createFile(String folderPath, String fileName) {
File destDir = new File(folderPath);
if (!destDir.exists()) {
destDir.mkdirs();
}
return new File(folderPath, fileName);
}
/**
* 向手机写图片
*
* @param buffer
* @param folder
* @param fileName
* @return
*/
public static boolean writeFile(byte[] buffer, String folder,
String fileName) {
boolean writeSucc = false;
boolean sdCardExist = Environment.getExternalStorageState().equals(
Environment.MEDIA_MOUNTED);
String folderPath = "";
if (sdCardExist) {
folderPath = Environment.getExternalStorageDirectory()
+ File.separator + folder + File.separator;
} else {
writeSucc = false;
}
File fileDir = new File(folderPath);
if (!fileDir.exists()) {
fileDir.mkdirs();
}
File file = new File(folderPath + fileName);
FileOutputStream out = null;
try {
out = new FileOutputStream(file);
out.write(buffer);
writeSucc = true;
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return writeSucc;
}
/**
* 把bitmap保存到本地
*
* @param mBitmap
* @param path
*/
public static void saveBitmapToFile(Bitmap mBitmap, String path) {
File f = new File(path);
if (f.exists()) {
f.delete();
}
FileOutputStream fOut = null;
try {
fOut = new FileOutputStream(f);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
mBitmap.compress(Bitmap.CompressFormat.PNG, 100, fOut);
try {
fOut.flush();
} catch (IOException e) {
e.printStackTrace();
}
try {
fOut.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 根据文件的绝对路径获取文件名但不包含扩展名
*
* @param filePath
* @return
*/
public static String getFileNameNoFormat(String filePath) {
if (TextUtils.isEmpty(filePath)) {
return "";
}
int point = filePath.lastIndexOf('.');
return filePath.substring(filePath.lastIndexOf(File.separator) + 1,
point);
}
/**
* 获取文件扩展名
*
* @param fileName
* @return
*/
public static String getFileFormat(String fileName) {
if (TextUtils.isEmpty(fileName))
return "";
int point = fileName.lastIndexOf('.');
return fileName.substring(point + 1);
}
/**
* 获取文件大小
*
* @param filePath
* @return
*/
public static long getFileSize(String filePath) {
long size = 0;
File file = new File(filePath);
if (file != null && file.exists()) {
size = file.length();
}
return size;
}
/**
* 在Android 编程中经常会用到uri转化为文件路径
* 下面是4.4后通过Uri获取路径以及文件名一种方法
*
* @param context
* @param uri
* @return
*/
public static String getRealFilePath(final Context context, final Uri uri) {
if (null == uri) return null;
final String scheme = uri.getScheme();
String data = null;
if (scheme == null)
data = uri.getPath();
else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
data = uri.getPath();
} else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
Cursor cursor = context.getContentResolver().query(uri, new String[]{MediaStore.Images.ImageColumns.DATA}, null, null, null);
if (null != cursor) {
if (cursor.moveToFirst()) {
int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
if (index > -1) {
data = cursor.getString(index);
}
}
cursor.close();
}
}
return data;
}
/**
* 获取文件大小
*
* @param size 字节
* @return
*/
public static String getFileSize(long size) {
if (size <= 0)
return "0K";
java.text.DecimalFormat df = new java.text.DecimalFormat("##.##");
float temp = (float) size / 1024;
if (temp >= 1024) {
return df.format(temp / 1024) + "M";
} else {
return df.format(temp) + "K";
}
}
/**
* 转换文件大小
*
* @param fileS
* @return B/KB/MB/GB
*/
public static String formatFileSize(long fileS) {
java.text.DecimalFormat df = new java.text.DecimalFormat("#.00");
String fileSizeString = "";
if (fileS < 1024) {
fileSizeString = df.format((double) fileS) + "B";
} else if (fileS < 1048576) {
fileSizeString = df.format((double) fileS / 1024) + "KB";
} else if (fileS < 1073741824) {
fileSizeString = df.format((double) fileS / 1048576) + "MB";
} else {
fileSizeString = df.format((double) fileS / 1073741824) + "G";
}
return fileSizeString;
}
/**
* 直接获取路径下对应文件的大小
*
* @param filePath
* @return
*/
public static String getFormatFileSize(String filePath) {
return formatFileSize(getFileSize(filePath));
}
/**
* 获取目录文件大小
*
* @param dir
* @return
*/
public static long getDirSize(File dir) {
if (dir == null) {
return 0;
}
if (!dir.isDirectory()) {
return 0;
}
long dirSize = 0;
File[] files = dir.listFiles();
for (File file : files) {
if (file.isFile()) {
dirSize += file.length();
} else if (file.isDirectory()) {
dirSize += file.length();
dirSize += getDirSize(file); // 递归调用继续统计
}
}
return dirSize;
}
/**
* 获取目录文件个数
*
* @param dir
* @return
*/
public long getFileList(File dir) {
long count = 0;
File[] files = dir.listFiles();
count = files.length;
for (File file : files) {
if (file.isDirectory()) {
count = count + getFileList(file);// 递归
count--;
}
}
return count;
}
/**
* 流转字节
*
* @param in
* @return
* @throws IOException
*/
public static byte[] toBytes(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
int ch;
while ((ch = in.read()) != -1) {
out.write(ch);
}
byte buffer[] = out.toByteArray();
out.close();
return buffer;
}
/**
* 获得指定文件的byte数组
*/
public static byte[] getBytesFromFile(String filePath) {
byte[] buffer = null;
try {
File file = new File(filePath);
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
bos.close();
buffer = bos.toByteArray();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
/**
* 根据byte数组，生成文件
*/
public static String bypeToFile(byte[] bfile, String filePath, String fileName) {
BufferedOutputStream bos = null;
FileOutputStream fos = null;
String outFilePath = filePath + fileName;
File file = null;
try {
File dir = new File(filePath);
if (!dir.exists() && dir.isDirectory()) {//判断文件目录是否存在
dir.mkdirs();
}
file = new File(outFilePath);
fos = new FileOutputStream(file);
bos = new BufferedOutputStream(fos);
bos.write(bfile);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
return outFilePath;
}
/**
* 检查文件是否存在
*
* @param name
* @return
*/
public static boolean checkFileExists(String name) {
boolean status;
if (!name.equals("")) {
File path = Environment.getExternalStorageDirectory();
File newPath = new File(path.toString() + name);
status = newPath.exists();
} else {
status = false;
}
return status;
}
/**
* 检查路径是否存在
*
* @param path
* @return
*/
public static boolean checkFilePathExists(String path) {
return new File(path).exists();
}
/**
* 计算SD卡的剩余空间
*
* @return 返回-1，说明没有安装sd卡
*/
public static long getFreeDiskSpace() {
String status = Environment.getExternalStorageState();
long freeSpace = 0;
if (status.equals(Environment.MEDIA_MOUNTED)) {
try {
File path = Environment.getExternalStorageDirectory();
StatFs stat = new StatFs(path.getPath());
long blockSize = stat.getBlockSize();
long availableBlocks = stat.getAvailableBlocks();
freeSpace = availableBlocks * blockSize / 1024;
} catch (Exception e) {
e.printStackTrace();
}
} else {
return -1;
}
return (freeSpace);
}
/**
* 新建目录
*
* @param directoryName
* @return
*/
public static boolean createDirectory(String directoryName) {
boolean status;
if (!directoryName.equals("")) {
File path = Environment.getExternalStorageDirectory();
File newPath = new File(path.toString() + directoryName);
status = newPath.mkdir();
status = true;
} else
status = false;
return status;
}
/**
* 检查是否安装SD卡
*
* @return
*/
public static boolean checkSaveLocationExists() {
String sDCardStatus = Environment.getExternalStorageState();
boolean status;
if (sDCardStatus.equals(Environment.MEDIA_MOUNTED)) {
status = true;
} else
status = false;
return status;
}
/**
* 检查是否安装外置的SD卡
*
* @return
*/
public static boolean checkExternalSDExists() {
Map evn = System.getenv();
return evn.containsKey("SECONDARY_STORAGE");
}
/**
* 删除目录(包括：目录里的所有文件)
*
* @param fileName
* @return
*/
public static boolean deleteDirectory(String fileName) {
boolean status;
SecurityManager checker = new SecurityManager();
if (!fileName.equals("")) {
File path = Environment.getExternalStorageDirectory();
File newPath = new File(path.toString() + fileName);
checker.checkDelete(newPath.toString());
if (newPath.isDirectory()) {
String[] listfile = newPath.list();
// delete all files within the specified directory and then
// delete the directory
try {
for (int i = 0; i < listfile.length; i++) {
File deletedFile = new File(newPath.toString() + "/"
+ listfile[i].toString());
deletedFile.delete();
}
newPath.delete();
//L.e("cache", "DirectoryManager deleteDirectory" + fileName);
status = true;
} catch (Exception e) {
e.printStackTrace();
status = false;
}
} else
status = false;
} else
status = false;
return status;
}
/**
* 删除文件
*
* @param fileName
* @return
*/
public static boolean deleteFile(String fileName) {
boolean status;
SecurityManager checker = new SecurityManager();
if (!fileName.equals("")) {
File path = Environment.getExternalStorageDirectory();
File newPath = new File(path.toString() + fileName);
checker.checkDelete(newPath.toString());
if (newPath.isFile()) {
try {
//L.e("cache", "DirectoryManager deleteFile" + fileName);
newPath.delete();
status = true;
} catch (SecurityException se) {
se.printStackTrace();
status = false;
}
} else
status = false;
} else
status = false;
return status;
}
/**
* 删除空目录
*
* 返回 0代表成功 ,1 代表没有删除权限, 2代表不是空目录,3 代表未知错误
*
* @return
*/
public static int deleteBlankPath(String path) {
File f = new File(path);
if (!f.canWrite()) {
return 1;
}
if (f.list() != null && f.list().length > 0) {
return 2;
}
if (f.delete()) {
return 0;
}
return 3;
}
/**
* 重命名
*
* @param oldName
* @param newName
* @return
*/
public static boolean reNamePath(String oldName, String newName) {
File f = new File(oldName);
return f.renameTo(new File(newName));
}
/**
* 删除文件
*
* @param filePath
*/
public static boolean deleteFileWithPath(String filePath) {
SecurityManager checker = new SecurityManager();
File f = new File(filePath);
checker.checkDelete(filePath);
if (f.isFile()) {
//L.e("cache", "DirectoryManager deleteFile" + filePath);
f.delete();
return true;
}
return false;
}
/**
* 清空一个文件夹
*
* @param filePath
*/
public static void clearFileWithPath(String filePath) {
List files = FileUtil.listPathFiles(filePath);
if (files.isEmpty()) {
return;
}
for (File f : files) {
if (f.isDirectory()) {
clearFileWithPath(f.getAbsolutePath());
} else {
f.delete();
}
}
}
/**
* 获取一个文件夹下的所有文件
*
* @param root
* @return
*/
public static List listPathFiles(String root) {
List allDir = new ArrayList();
SecurityManager checker = new SecurityManager();
File path = new File(root);
checker.checkRead(root);
File[] files = path.listFiles();
for (File f : files) {
if (f.isFile())
allDir.add(f);
else
listPath(f.getAbsolutePath());
}
return allDir;
}
/**
* 获取SD卡的根目录，末尾带\
*
* @return
*/
public static String getSDRoot() {
return Environment.getExternalStorageDirectory().getAbsolutePath()
+ File.separator;
}
/**
* 获取手机外置SD卡的根目录
*
* @return
*/
public static String getExternalSDRoot() {
Map evn = System.getenv();
return evn.get("SECONDARY_STORAGE");
}
/**
* 列出root目录下所有子目录
*
* @param root
* @return 绝对路径
*/
public static List listPath(String root) {
List allDir = new ArrayList();
SecurityManager checker = new SecurityManager();
File path = new File(root);
checker.checkRead(root);
// 过滤掉以.开始的文件夹
if (path.isDirectory()) {
for (File f : path.listFiles()) {
if (f.isDirectory()) {
allDir.add(f.getAbsolutePath());
}
}
}
return allDir;
}
/**
* 创建目录
*
* @param newPath
*/
public static PathStatus createPath(String newPath) {
File path = new File(newPath);
if (path.exists()) {
return PathStatus.EXITS;
}
if (path.mkdir()) {
return PathStatus.SUCCESS;
} else {
return PathStatus.ERROR;
}
}
/**
* 截取路径名
*
* @return
*/
public static String getPathName(String absolutePath) {
int start = absolutePath.lastIndexOf(File.separator) + 1;
int end = absolutePath.length();
return absolutePath.substring(start, end);
}
/**
* 压缩图片
* @param filePathStr
* @param width
* @param height
* @param maxSize
* @return 压缩后的文件路径
*/
public static String getSmallPicture(String filePathStr, int width,
int height, int maxSize) {
try {
Bitmap bitmap = copressImage(filePathStr, width, height);
// Bitmap bitmap = BitmapFactory.decodeFile(filePathStr);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int options = 100;// 个人喜欢从100开始,
bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);
while (baos.toByteArray().length / 1024 > maxSize) { // 压缩到小于maxSize k
baos.reset();
options -= 10;
bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);
}
FileOutputStream fos = new FileOutputStream(filePathStr);
fos.write(baos.toByteArray());
fos.flush();
fos.close();
} catch (Exception e) {
return filePathStr;
}
return filePathStr;
}
@SuppressWarnings("unused")
public static Bitmap copressImage(String imgPath, int imagew, int imageh) {
File picture = new File(imgPath);
BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options();
// 下面这个设置是将图片边界不可调节变为可调节
bitmapFactoryOptions.inJustDecodeBounds = true;
bitmapFactoryOptions.inSampleSize = 2;
int outWidth = bitmapFactoryOptions.outWidth;
int outHeight = bitmapFactoryOptions.outHeight;
Bitmap bmap = BitmapFactory.decodeFile(picture.getAbsolutePath(),
bitmapFactoryOptions);
int yRatio = (int) Math.ceil(bitmapFactoryOptions.outHeight / imageh);
int xRatio = (int) Math.ceil(bitmapFactoryOptions.outWidth / imagew);
if (yRatio > 1 || xRatio > 1) {
if (yRatio > xRatio) {
bitmapFactoryOptions.inSampleSize = yRatio;
} else {
bitmapFactoryOptions.inSampleSize = xRatio;
}
}
bitmapFactoryOptions.inJustDecodeBounds = false;
bmap = BitmapFactory.decodeFile(picture.getAbsolutePath(),
bitmapFactoryOptions);
if (bmap != null) {
return bmap;
}
return null;
}
public static InputStream getInputStream(FileInputStream fileInput) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024 * 4];
int n = -1;
InputStream inputStream = null;
try {
while ((n = fileInput.read(buffer)) != -1) {
baos.write(buffer, 0, n);
}
byte[] byteArray = baos.toByteArray();
inputStream = new ByteArrayInputStream(byteArray);
return inputStream;
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
} catch (IOException e) {
e.printStackTrace();
return null;
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/**
* 获取GUID（UUID）
*
* @return
*/
public static String getGUID() {
UUID uuid = UUID.randomUUID();
String s = UUID.randomUUID().toString();
return s;
}
/**
* 创建目录
*/
public static void createFolder(String path) {
File file = new File(path);
if (!file.exists()) {
file.mkdirs();
} else {
}
}
/**
* 复制文件
*
* @param filePath
* @param targetPath
* @return
*/
public static boolean copy(String filePath, String targetPath) {
try {
InputStream fosfrom = new FileInputStream(filePath);
OutputStream fosto = new FileOutputStream(targetPath);
byte bt[] = new byte[1024];
int c;
while ((c = fosfrom.read(bt)) > 0) {
fosto.write(bt, 0, c);
}
fosfrom.close();
fosto.close();
return true;
} catch (Exception ex) {
return false;
}
}
/**
* 删除文件
*
* @param filePath
* @return
*/
public static boolean delete(String filePath) {
File file = new File(filePath);
if (file.exists()) { // 判断文件是否存在
if (file.isFile()) { // 判断是否是文件
file.delete(); // delete()方法 你应该知道 是删除的意思;
} else if (file.isDirectory()) { // 否则如果它是一个目录
String filePaths[] = file.list(); // 声明目录下所有的文件;
if (filePaths != null) {
for (int i = 0; i < filePaths.length; i++) { // 遍历目录下所有的文件
delete(filePaths[i]); // 把每个文件 用这个方法进行迭代
}
}
}
boolean isSuccess = file.delete();
if (!isSuccess) {
return false;
}
}
return true;
}
/**
* 剪切文件
*
* @param filePath
* @param targetPath
* @return
*/
public static boolean cut(String filePath, String targetPath) {
//L.e("cache", "cut targetPath:" + targetPath);
//L.e("cache", "cut filePath:" + filePath);
if (copy(filePath, targetPath) && delete(filePath)) {
return true;
}
return false;
}
/**
* 获取bitmap的字节大小
*
* @param bitmap
* @return
*/
public static int getBitmapSize(Bitmap bitmap) {
return bitmap.getRowBytes() * bitmap.getHeight();
}
public static String saveFileByBinary(String source, String path, String fileName) {
createFolder(path);
fileName = path + fileName;
delete(fileName);
File file = new File(fileName);
byte[] byteFile = Base64.decode(source, 0);
try {
InputStream is = new ByteArrayInputStream(byteFile);
FileOutputStream os = new FileOutputStream(file);
byte[] b = new byte[1024];
int len = 0;
//开始读取
while ((len = is.read(b)) != -1) {
os.write(b, 0, len);
}
//完毕关闭所有连接
is.close();
os.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return fileName;
}
public static byte[] getBytes(String in) {
byte[] result = new byte[in.length() * 2];
int output = 0;
for (char ch : in.toCharArray()) {
result[output++] = (byte) (ch & 0xFF);
result[output++] = (byte) (ch >> 8);
}
return result;
}
/**
* 获取md5
*
* @param s
* @return
*/
public static String getMD5(String s) {
char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
try {
byte[] btInput = s.getBytes();
// 获得MD5摘要算法的 MessageDigest 对象
MessageDigest mdInst = MessageDigest.getInstance("MD5");
// 使用指定的字节更新摘要
mdInst.update(btInput);
// 获得密文
byte[] md = mdInst.digest();
// 把密文转换成十六进制的字符串形式
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static boolean isSameKey(byte[] key, byte[] buffer) {
int n = key.length;
if (buffer.length < n) {
return false;
}
for (int i = 0; i < n; ++i) {
if (key[i] != buffer[i]) {
return false;
}
}
return true;
}
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
byte[] copy = new byte[newLength];
System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength));
return copy;
}
static {
//参考 http://bioinf.cs.ucl.ac.uk/downloads/crc64/crc64.c
long part;
for (int i = 0; i < 256; i++) {
part = i;
for (int j = 0; j < 8; j++) {
long x = ((int) part & 1) != 0 ? POLY64REV : 0;
part = (part >> 1) ^ x;
}
sCrcTable[i] = part;
}
}
public static byte[] makeKey(String httpUrl) {
return getBytes(httpUrl);
}
/**
* A function thats returns a 64-bit crc for string
*
* @param in input string
* @return a 64-bit crc value
*/
public static final long crc64Long(String in) {
if (in == null || in.length() == 0) {
return 0;
}
return crc64Long(getBytes(in));
}
public static final long crc64Long(byte[] buffer) {
long crc = INITIALCRC;
for (int k = 0, n = buffer.length; k < n; ++k) {
crc = sCrcTable[(((int) crc) ^ buffer[k]) & 0xff] ^ (crc >> 8);
}
return crc;
}
/**
* 获取文件的二进制文件
*
* @param path 文件路径
*/
@SuppressLint({"InlinedApi", "NewApi"})
public static String getBase64Str(String path) {
String uploadBuffer = "";
try {
FileInputStream fis = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int count = 0;
while ((count = fis.read(buffer)) >= 0) {
baos.write(buffer, 0, count);
}
uploadBuffer = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT)); //进行Base64
} catch (Exception e) {
e.printStackTrace();
}
return uploadBuffer;
}
/**
* 检查文件是否大于所输入的大小限制
*
* @param path
* @param size
* @return
*/
public static boolean checkFileSize(String path, double size) {
try {
FileInputStream fis = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int count = 0;
while ((count = fis.read(buffer)) >= 0) {
baos.write(buffer, 0, count);
}
if ((baos.toByteArray().length / 1024) > size) {
return false;
} else {
return true;
}
} catch (Exception e) {
return false;
}
}
}
