You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
744 lines
22 KiB
744 lines
22 KiB
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package com.arialyy.aria.util;
|
|
|
|
import android.app.ActivityManager;
|
|
import android.content.Context;
|
|
import android.os.Build;
|
|
import android.os.Environment;
|
|
import android.os.StatFs;
|
|
import android.os.storage.StorageManager;
|
|
import android.os.storage.StorageVolume;
|
|
import android.text.TextUtils;
|
|
import com.arialyy.aria.core.AriaManager;
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.FileReader;
|
|
import java.io.FileWriter;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.SequenceInputStream;
|
|
import java.io.Serializable;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.channels.Channels;
|
|
import java.nio.channels.FileChannel;
|
|
import java.nio.channels.ReadableByteChannel;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Enumeration;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Properties;
|
|
import java.util.Scanner;
|
|
import java.util.regex.Pattern;
|
|
|
|
/**
|
|
* 文件操作工具类
|
|
*/
|
|
public class FileUtil {
|
|
private static final String TAG = "FileUtil";
|
|
private static final Pattern DIR_SEPORATOR = Pattern.compile("/");
|
|
private static final String EXTERNAL_STORAGE_PATH =
|
|
Environment.getExternalStorageDirectory().getPath();
|
|
|
|
/**
|
|
* 创建目录 当目录不存在的时候创建文件,否则返回false
|
|
*/
|
|
public static boolean createDir(String path) {
|
|
File file = new File(path);
|
|
if (!file.exists()) {
|
|
if (!file.mkdirs()) {
|
|
ALog.d(TAG, "创建失败,请检查路径和是否配置文件权限!");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 创建文件 当文件不存在的时候就创建一个文件。 如果文件存在,先删除原文件,然后重新创建一个新文件
|
|
*
|
|
* @return {@code true} 创建成功、{@code false} 创建失败
|
|
*/
|
|
public static boolean createFile(String path) {
|
|
if (TextUtils.isEmpty(path)) {
|
|
ALog.e(TAG, "文件路径不能为null");
|
|
return false;
|
|
}
|
|
File file = new File(path);
|
|
if (file.getParentFile() == null || !file.getParentFile().exists()) {
|
|
ALog.d(TAG, "目标文件所在路径不存在,准备创建……");
|
|
if (!createDir(file.getParent())) {
|
|
ALog.d(TAG, "创建目录文件所在的目录失败!文件路径【" + path + "】");
|
|
}
|
|
}
|
|
// 创建目标文件
|
|
if (file.exists()) {
|
|
final File to = new File(file.getAbsolutePath() + System.currentTimeMillis());
|
|
if (file.renameTo(to)) {
|
|
to.delete();
|
|
} else {
|
|
file.delete();
|
|
}
|
|
}
|
|
try {
|
|
if (file.createNewFile()) {
|
|
//ALog.d(TAG, "创建文件成功:" + file.getAbsolutePath());
|
|
return true;
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 创建文件名,如果url链接有后缀名,则使用url中的后缀名
|
|
*
|
|
* @return url 的 hashKey
|
|
*/
|
|
public static String createFileName(String url) {
|
|
int end = url.indexOf("?");
|
|
String tempUrl, fileName = "";
|
|
if (end > 0) {
|
|
tempUrl = url.substring(0, end);
|
|
int tempEnd = tempUrl.lastIndexOf("/");
|
|
if (tempEnd > 0) {
|
|
fileName = tempUrl.substring(tempEnd + 1);
|
|
}
|
|
} else {
|
|
int tempEnd = url.lastIndexOf("/");
|
|
if (tempEnd > 0) {
|
|
fileName = url.substring(tempEnd + 1);
|
|
}
|
|
}
|
|
if (TextUtils.isEmpty(fileName)) {
|
|
fileName = CommonUtil.keyToHashKey(url);
|
|
}
|
|
return fileName;
|
|
}
|
|
|
|
/**
|
|
* 删除文件
|
|
*
|
|
* @param path 文件路径
|
|
* @return {@code true}删除成功、{@code false}删除失败
|
|
*/
|
|
public static boolean deleteFile(String path) {
|
|
if (TextUtils.isEmpty(path)) {
|
|
ALog.e(TAG, "删除文件失败,路径为空");
|
|
return false;
|
|
}
|
|
return deleteFile(new File(path));
|
|
}
|
|
|
|
/**
|
|
* 删除文件
|
|
*
|
|
* @param file 文件路径
|
|
* @return {@code true}删除成功、{@code false}删除失败
|
|
*/
|
|
public static boolean deleteFile(File file) {
|
|
if (file.exists()) {
|
|
final File to = new File(file.getAbsolutePath() + System.currentTimeMillis());
|
|
if (file.renameTo(to)) {
|
|
return to.delete();
|
|
} else {
|
|
return file.delete();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 将对象写入文件
|
|
*
|
|
* @param filePath 文件路径
|
|
* @param data data数据必须实现{@link Serializable}接口
|
|
*/
|
|
public static void writeObjToFile(String filePath, Object data) {
|
|
if (!(data instanceof Serializable)) {
|
|
ALog.e(TAG, "对象写入文件失败,data数据必须实现Serializable接口");
|
|
return;
|
|
}
|
|
FileOutputStream ops = null;
|
|
try {
|
|
if (!createFile(filePath)) {
|
|
return;
|
|
}
|
|
ops = new FileOutputStream(filePath);
|
|
ObjectOutputStream oops = new ObjectOutputStream(ops);
|
|
oops.writeObject(data);
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
if (ops != null) {
|
|
try {
|
|
ops.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 从文件中读取对象
|
|
*
|
|
* @param filePath 文件路径
|
|
* @return 如果读取成功,返回相应的Obj对象,读取失败,返回null
|
|
*/
|
|
public static Object readObjFromFile(String filePath) {
|
|
if (TextUtils.isEmpty(filePath)) {
|
|
ALog.e(TAG, "文件路径为空");
|
|
return null;
|
|
}
|
|
File file = new File(filePath);
|
|
if (!file.exists()) {
|
|
ALog.e(TAG, String.format("文件【%s】不存在", filePath));
|
|
return null;
|
|
}
|
|
FileInputStream fis = null;
|
|
try {
|
|
fis = new FileInputStream(filePath);
|
|
ObjectInputStream oois = new ObjectInputStream(fis);
|
|
return oois.readObject();
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} catch (ClassNotFoundException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
if (fis != null) {
|
|
try {
|
|
fis.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 合并文件
|
|
*
|
|
* @param targetPath 目标文件
|
|
* @param subPaths 碎片文件路径
|
|
* @return {@code true} 合并成功,{@code false}合并失败
|
|
*/
|
|
public static boolean mergeFile(String targetPath, List<String> subPaths) {
|
|
File file = new File(targetPath);
|
|
FileOutputStream fos = null;
|
|
FileChannel foc = null;
|
|
try {
|
|
if (!file.exists()) {
|
|
file.createNewFile();
|
|
}
|
|
fos = new FileOutputStream(targetPath);
|
|
foc = fos.getChannel();
|
|
List<FileInputStream> streams = new LinkedList<>();
|
|
for (String subPath : subPaths) {
|
|
File f = new File(subPath);
|
|
if (!f.exists()) {
|
|
ALog.d(TAG, String.format("合并文件失败,文件【%s】不存在", subPath));
|
|
for (FileInputStream fis : streams) {
|
|
fis.close();
|
|
}
|
|
streams.clear();
|
|
|
|
return false;
|
|
}
|
|
streams.add(new FileInputStream(subPath));
|
|
}
|
|
Enumeration<FileInputStream> en = Collections.enumeration(streams);
|
|
SequenceInputStream sis = new SequenceInputStream(en);
|
|
ReadableByteChannel fic = Channels.newChannel(sis);
|
|
ByteBuffer bf = ByteBuffer.allocate(8196);
|
|
while (fic.read(bf) != -1) {
|
|
bf.flip();
|
|
foc.write(bf);
|
|
bf.compact();
|
|
}
|
|
fic.close();
|
|
sis.close();
|
|
return true;
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
try {
|
|
if (foc != null) {
|
|
foc.close();
|
|
}
|
|
if (fos != null) {
|
|
fos.close();
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 分割文件
|
|
*
|
|
* @param filePath 被分割的文件路径
|
|
* @param num 分割的块数
|
|
*/
|
|
public static void splitFile(String filePath, int num) {
|
|
try {
|
|
final File file = new File(filePath);
|
|
long size = file.length();
|
|
FileInputStream fis = new FileInputStream(file);
|
|
FileChannel fic = fis.getChannel();
|
|
long j = 0;
|
|
long block = size / num;
|
|
for (int i = 0; i < num; i++) {
|
|
if (i == num - 1) {
|
|
block = size - block * (num - 1);
|
|
}
|
|
String subPath = file.getPath() + "." + i + ".part";
|
|
ALog.d(TAG, String.format("block = %s", block));
|
|
File subFile = new File(subPath);
|
|
if (!subFile.exists()) {
|
|
subFile.createNewFile();
|
|
}
|
|
FileOutputStream fos = new FileOutputStream(subFile);
|
|
FileChannel sfoc = fos.getChannel();
|
|
ByteBuffer bf = ByteBuffer.allocate(8196);
|
|
int len;
|
|
//fis.skip(block * i);
|
|
while ((len = fic.read(bf)) != -1) {
|
|
bf.flip();
|
|
sfoc.write(bf);
|
|
bf.compact();
|
|
j += len;
|
|
if (j >= block * (i + 1)) {
|
|
break;
|
|
}
|
|
}
|
|
ALog.d(TAG, String.format("len = %s", subFile.length()));
|
|
fos.close();
|
|
sfoc.close();
|
|
}
|
|
fis.close();
|
|
fic.close();
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 检查SD内存空间是否充足
|
|
*
|
|
* @param filePath 文件保存路径
|
|
* @param fileSize 文件大小
|
|
* @return {@code false} 内存空间不足,{@code true}内存空间足够
|
|
*/
|
|
public static boolean checkSDMemorySpace(String filePath, long fileSize) {
|
|
List<String> dirs = FileUtil.getSDPathList(AriaManager.getInstance().getAPP());
|
|
if (dirs == null || dirs.isEmpty()) {
|
|
return true;
|
|
}
|
|
for (String path : dirs) {
|
|
if (filePath.contains(path)) {
|
|
if (fileSize > 0 && fileSize > getAvailableExternalMemorySize(path)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* sdcard 可用大小
|
|
*
|
|
* @param sdcardPath sdcard 根路径
|
|
* @return 单位为:byte
|
|
*/
|
|
public static long getAvailableExternalMemorySize(String sdcardPath) {
|
|
StatFs stat = new StatFs(sdcardPath);
|
|
long blockSize = stat.getBlockSize();
|
|
long availableBlocks = stat.getAvailableBlocks();
|
|
return availableBlocks * blockSize;
|
|
}
|
|
|
|
/**
|
|
* sdcard 总大小
|
|
*
|
|
* @param sdcardPath sdcard 根路径
|
|
* @return 单位为:byte
|
|
*/
|
|
public static long getTotalExternalMemorySize(String sdcardPath) {
|
|
StatFs stat = new StatFs(sdcardPath);
|
|
long blockSize = stat.getBlockSize();
|
|
long totalBlocks = stat.getBlockCount();
|
|
return totalBlocks * blockSize;
|
|
}
|
|
|
|
/**
|
|
* 获取SD卡目录列表
|
|
*/
|
|
public static List<String> getSDPathList(Context context) {
|
|
List<String> paths;
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
|
|
paths = getVolumeList(context);
|
|
} else {
|
|
List<String> mounts = readMountsFile();
|
|
List<String> volds = readVoldFile();
|
|
paths = compareMountsWithVold(mounts, volds);
|
|
}
|
|
return paths;
|
|
}
|
|
|
|
/**
|
|
* 读取下载配置文件
|
|
*/
|
|
public static Properties loadConfig(File file) {
|
|
Properties properties = new Properties();
|
|
FileInputStream fis = null;
|
|
if (!file.exists()) {
|
|
createFile(file.getPath());
|
|
}
|
|
try {
|
|
fis = new FileInputStream(file);
|
|
properties.load(fis);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
try {
|
|
if (fis != null) {
|
|
fis.close();
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return properties;
|
|
}
|
|
|
|
/**
|
|
* 保存配置文件
|
|
*/
|
|
public static void saveConfig(File file, Properties properties) {
|
|
FileOutputStream fos = null;
|
|
try {
|
|
fos = new FileOutputStream(file, false);
|
|
properties.store(fos, null);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
try {
|
|
if (fos != null) {
|
|
fos.flush();
|
|
fos.close();
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getSDPathList
|
|
*/
|
|
private static List<String> getVolumeList(final Context context) {
|
|
List<String> pathList = new ArrayList<>();
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
|
StorageManager manager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
|
|
List<StorageVolume> volumes = manager.getStorageVolumes();
|
|
for (StorageVolume volume : volumes) {
|
|
String state = volume.getState();
|
|
if (state.equals(Environment.MEDIA_MOUNTED)) {
|
|
pathList.add(volume.toString());
|
|
}
|
|
}
|
|
} else {
|
|
pathList.addAll(getStorageDirectories());
|
|
}
|
|
|
|
if (pathList.isEmpty()) {
|
|
pathList = new ArrayList<>();
|
|
pathList.add(EXTERNAL_STORAGE_PATH);
|
|
}
|
|
LinkedHashMap<Integer, String> paths = new LinkedHashMap<>();
|
|
for (String path : pathList) {
|
|
File root = new File(path);
|
|
if (!root.exists() || !root.isDirectory() || !canWrite(path)) {
|
|
continue;
|
|
}
|
|
//去除mount的相同目录
|
|
int key = (root.getTotalSpace() + "-" + root.getUsableSpace()).hashCode();
|
|
String prevPath = paths.get(key);
|
|
if (!TextUtils.isEmpty(prevPath) && prevPath.length() < path.length()) {
|
|
continue;
|
|
}
|
|
paths.put(key, path);
|
|
}
|
|
List<String> list = new ArrayList<>();
|
|
for (Integer key : paths.keySet()) {
|
|
list.add(paths.get(key));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
private static boolean canWrite(String dirPath) {
|
|
File dir = new File(dirPath);
|
|
if (dir.canWrite()) {
|
|
return true;
|
|
}
|
|
boolean canWrite;
|
|
File testWriteFile = null;
|
|
try {
|
|
testWriteFile = new File(dirPath, "tw.txt");
|
|
if (testWriteFile.exists()) {
|
|
testWriteFile.delete();
|
|
}
|
|
testWriteFile.createNewFile();
|
|
FileWriter writer = new FileWriter(testWriteFile);
|
|
writer.write(1);
|
|
writer.close();
|
|
canWrite = true;
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
canWrite = false;
|
|
} finally {
|
|
try {
|
|
if (testWriteFile != null && testWriteFile.exists()) {
|
|
testWriteFile.delete();
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return canWrite;
|
|
}
|
|
|
|
/**
|
|
* Raturns all available SD-Cards in the system (include emulated) Warning: Hack! Based on Android
|
|
* source code of version 4.3
|
|
* (API 18) Because there is no standard way to get it. TODO: Test on future Android versions
|
|
* 4.2+
|
|
*
|
|
* @return paths to all available SD-Cards in the system (include emulated)
|
|
*/
|
|
public static List<String> getStorageDirectories() {
|
|
// Final set of paths
|
|
final List<String> rv = new ArrayList<>();
|
|
// Primary physical SD-CARD (not emulated)
|
|
final String rawExternalStorage = System.getenv("EXTERNAL_STORAGE");
|
|
// All Secondary SD-CARDs (all exclude primary) separated by ":"
|
|
final String rawSecondaryStoragesStr = System.getenv("SECONDARY_STORAGE");
|
|
// Primary emulated SD-CARD
|
|
final String rawEmulatedStorageTarget = System.getenv("EMULATED_STORAGE_TARGET");
|
|
if (TextUtils.isEmpty(rawEmulatedStorageTarget)) {
|
|
// Device has physical external storage; use plain paths.
|
|
if (TextUtils.isEmpty(rawExternalStorage)) {
|
|
// EXTERNAL_STORAGE undefined; falling back to default.
|
|
rv.add("/storage/sdcard0");
|
|
} else {
|
|
rv.add(rawExternalStorage);
|
|
}
|
|
} else {
|
|
// Device has emulated storage; external storage paths should have
|
|
// userId burned into them.
|
|
final String rawUserId;
|
|
|
|
//if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
|
|
final String path = Environment.getExternalStorageDirectory().getAbsolutePath();
|
|
final String[] folders = DIR_SEPORATOR.split(path);
|
|
final String lastFolder = folders[folders.length - 1];
|
|
boolean isDigit = false;
|
|
if (!TextUtils.isEmpty(lastFolder) && TextUtils.isDigitsOnly(lastFolder)) {
|
|
isDigit = true;
|
|
}
|
|
rawUserId = isDigit ? lastFolder : "";
|
|
//} else {
|
|
// rawUserId = "";
|
|
//}
|
|
// /storage/emulated/0[1,2,...]
|
|
if (TextUtils.isEmpty(rawUserId)) {
|
|
rv.add(rawExternalStorage);
|
|
} else {
|
|
rv.add(rawEmulatedStorageTarget + File.separator + rawUserId);
|
|
}
|
|
}
|
|
// Add all secondary storages
|
|
if (!TextUtils.isEmpty(rawSecondaryStoragesStr)) {
|
|
// All Secondary SD-CARDs splited into array
|
|
final String[] rawSecondaryStorages = rawSecondaryStoragesStr.split(File.pathSeparator);
|
|
Collections.addAll(rv, rawSecondaryStorages);
|
|
}
|
|
// checkout SD-CARDs writable
|
|
for (int i = rv.size() - 1; i >= 0; i--) {
|
|
String path = rv.get(i);
|
|
File root = new File(path);
|
|
if (!root.exists() || !root.isDirectory() || !canWrite(path)) {
|
|
rv.remove(i);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* Scan the /proc/mounts file and look for lines like this: /dev/block/vold/179:1 /mnt/sdcard
|
|
* vfat
|
|
* rw,dirsync,nosuid,nodev,noexec ,relatime,uid=1000,gid=1015,fmask=0602,dmask=0602,allow_utime=0020,
|
|
* codepage=cp437,iocharset= iso8859-1,shortname=mixed,utf8,errors=remount-ro 0 0 When one is
|
|
* found, split it into its
|
|
* elements and then pull out the path to the that mount point and add it to the arraylist
|
|
*/
|
|
private static List<String> readMountsFile() {
|
|
// some mount files don't list the default
|
|
// path first, so we add it here to
|
|
// ensure that it is first in our list
|
|
List<String> mounts = new ArrayList<>();
|
|
mounts.add(EXTERNAL_STORAGE_PATH);
|
|
try {
|
|
Scanner scanner = new Scanner(new File("/proc/mounts"));
|
|
while (scanner.hasNext()) {
|
|
String line = scanner.nextLine();
|
|
if (line.startsWith("/dev/block/vold/") || line.startsWith("/dev/block//vold/")) {//
|
|
String[] lineElements = line.split(" ");
|
|
// String partition = lineElements[0];
|
|
String element = lineElements[1];
|
|
// don't add the default mount path
|
|
// it's already in the list.
|
|
if (!element.equals(EXTERNAL_STORAGE_PATH)) {
|
|
mounts.add(element);
|
|
}
|
|
}
|
|
}
|
|
scanner.close();
|
|
} catch (Exception e) {
|
|
// e.printStackTrace();
|
|
}
|
|
return mounts;
|
|
}
|
|
|
|
private static List<String> readVoldFile() {
|
|
// read /etc/vold.conf or /etc/vold.fstab (it depends on version what
|
|
// clientConfig file is present)
|
|
List<String> vold = null;
|
|
Scanner scanner = null;
|
|
try {
|
|
try {
|
|
scanner = new Scanner(new File("/system/etc/vold.fstab"));
|
|
} catch (FileNotFoundException e1) {
|
|
// e1.printStackTrace();
|
|
scanner = new Scanner(new File("/system/etc/vold.conf"));
|
|
}
|
|
vold = new ArrayList<String>();
|
|
vold.add(EXTERNAL_STORAGE_PATH);
|
|
while (scanner.hasNext()) {
|
|
String line = scanner.nextLine();
|
|
if (TextUtils.isEmpty(line)) {
|
|
continue;
|
|
}
|
|
line = line.trim();
|
|
if (line.startsWith("dev_mount")) {
|
|
String[] lineElements = line.split(" ");
|
|
if (lineElements.length < 3) {
|
|
continue;
|
|
}
|
|
String element = lineElements[2];
|
|
if (element.contains(":")) {
|
|
element = element.substring(0, element.indexOf(":"));
|
|
}
|
|
// ignore default path
|
|
if (!element.equals(EXTERNAL_STORAGE_PATH)) {
|
|
vold.add(element);
|
|
}
|
|
} else if (line.startsWith("mount_point")) {
|
|
String element = line.replaceAll("mount_point", "").trim();
|
|
if (!element.equals(EXTERNAL_STORAGE_PATH)) {
|
|
vold.add(element);
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
// e.printStackTrace();
|
|
}
|
|
return vold;
|
|
}
|
|
|
|
private static List<String> compareMountsWithVold(List<String> mounts, List<String> volds) {
|
|
/*
|
|
* 有时候这两个list中的数据并不相同,我们只需要取两个list的交集部分。
|
|
*/
|
|
for (int i = mounts.size() - 1; i >= 0; i--) {
|
|
String mount = mounts.get(i);
|
|
File root = new File(mount);
|
|
// 判断目录是否存在并且可读
|
|
if (!root.exists() || !root.isDirectory() || !root.canWrite()) {
|
|
mounts.remove(i);
|
|
continue;
|
|
}
|
|
if (volds != null && !volds.contains(mount)) {
|
|
mounts.remove(i);
|
|
}
|
|
}
|
|
// 清除无用数据
|
|
if (volds != null) {
|
|
volds.clear();
|
|
}
|
|
return mounts;
|
|
}
|
|
|
|
public static long getTotalMemory() {
|
|
String file_path = "/proc/meminfo";// 系统内存信息文件
|
|
String ram_info;
|
|
String[] arrayOfRam;
|
|
long initial_memory = 0L;
|
|
try {
|
|
FileReader fr = new FileReader(file_path);
|
|
BufferedReader localBufferedReader = new BufferedReader(fr, 8192);
|
|
// 读取meminfo第一行,系统总内存大小
|
|
ram_info = localBufferedReader.readLine();
|
|
arrayOfRam = ram_info.split("\\s+");// 实现多个空格切割的效果
|
|
initial_memory =
|
|
Integer.valueOf(arrayOfRam[1]) * 1024;// 获得系统总内存,单位是KB,乘以1024转换为Byte
|
|
localBufferedReader.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return initial_memory;
|
|
}
|
|
|
|
public static long getAvailMemory(Context context) {
|
|
ActivityManager activityManager =
|
|
(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
|
|
ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
|
|
activityManager.getMemoryInfo(memoryInfo);
|
|
return memoryInfo.availMem;
|
|
}
|
|
}
|
|
|