2023年11月26日发(作者：)
Android⼀键清理内存，缓存，⽂件代码
⼀键清理⼯具类:主要清理 1.系统的内存 的缓存 3.系统的临时⽂件 .apk .log .tmp .temp .back
package s;
import edReader;
import ;
import putStream;
import ader;
import ;
import lFormat;
import ist;
import ;
import tyManager;
import Info;
import gAppProcessInfo;
import gTaskInfo;
import t;
import ;
import tyInfo;
import ationInfo;
import geDataObserver;
import geStatsObserver;
import eInfo;
import eManager;
import eStats;
import tFoundException;
import le;
import Exception;
import ;
/**
* @author DongYinPing 1045612812@
* @version 1.0 ⼀键清理⼯具类:主要清理 1.系统的内存 的缓存 3.系统的临时⽂件 .apk .log .tmp .temp;
* */
public class CleanUtils {
private Context cx;
private ActivityManager am;
private PackageManager pm;
public CleanUtils(Context context) {
super();
cx = context;
am = (ActivityManager) temService(TY_SERVICE);
pm = kageManager();
}
(""); // 定时锁屏管理
(kageName()); // ⾃⼰
(getCurTopPackgeName()); // 过滤正在运⾏的进程
return filterPackgeNames;
}
/**
* 系统剩余的内存
* */
public float getSurplusMemory() {
MemoryInfo info = new Info();
oryInfo(info);
return (float) em / 1024 / 1024;
}
/**
* 系统总内存
* */
public float getTotalMemory() {
String str1 = "/proc/meminfo";
String str2;
String[] arrayOfString;
long initial_memory = 0;
try {
FileReader fileReader = new FileReader(str1);
BufferedReader bufferedReader = new BufferedReader(fileReader, 8192);
str2 = ne();
arrayOfString = ("s+");
initial_memory = f(arrayOfString[1]);
();
} catch (Exception e) {
tackTrace();
}
return (float) (initial_memory / 1024);
}
/**
* 系统内存:当前使⽤百分⽐/字符串格式
* */
public String usePercentNumString() {
float surplus_size = getSurplusMemory();// 剩余MB
float all_size = getTotalMemory();// 总共MB
// ⼩数不⾜2位,以0补⾜
DecimalFormat decimalFormat = new DecimalFormat("0.00");
String percentnum = decimalFormat
.format((1 - surplus_size / all_size) * 100);
return percentnum;
}
/**
* 系统内存:当前使⽤百分⽐/数字格式
* */
public float usePercentNum() {// ⽤于清理后UI更新
float surplus_size = getSurplusMemory();// 剩余MB
float all_size = getTotalMemory();// 总共MB
return (1 - surplus_size / all_size) * 100;
}
/**
* 使⽤反射⽅法调⽤系统隐藏api：forceStopPackage 通过包名杀死进程
* */
public boolean forceStopPackageByPackageName(String packageName) {
boolean forceSucceed = false;
Class
Method method;
try {
method = laredMethod("forceStopPackage", );
(am, packageName);
forceSucceed = true;
} catch (Exception e) {
tackTrace();
}
return forceSucceed;
}
/**
* 判断是否属于系统app
* */
public boolean isSystemApp(ApplicationInfo info) {
if (( & _UPDATED_SYSTEM_APP) != 0) {
return false;// 表⽰是系统程序，但⽤户更新过，也算是⽤户安装的程序
} else if (( & _SYSTEM) == 0) {
return false; // ⼀定是⽤户安装的程序
}
return true;
}
/**
* 获取最顶层的app包名,若是⾃⼰，则指定为其上⼀个
* */
public String getCurTopPackgeName() {
String curAppTaskPackgeName = null;
String myPackageName = kageName();
List
if (() > 0) {
curAppTaskPackgeName = (0).kageName();
if (() > 1) {
if ((myPackageName)
&& (1) != null) {
curAppTaskPackgeName = (1).topActivity
.getPackageName();
}
}
}
return curAppTaskPackgeName;
}
/**
* 遍历所有正在运⾏的进程列表,将所有应⽤的信息传⼊AppInfo中
* */
public List
List
.getRunningAppProcesses();// 正在运⾏的进程
List
List
for (RunningAppProcessInfo appProcessInfo : runningAppProcessInfos) {
AppInfo info = new AppInfo();
int id = ;
(id);
String appProcessName = sName;
ilterProcess(ns(appProcessName));// 需过滤的包名
kageName(appProcessName);// 设置进程名
try {
ApplicationInfo applicationInfo = kageInfo(
appProcessName, 0).applicationInfo;
Drawable icon = on(pm);
n(icon);
String name = bel(pm).toString();
e(name);
ystemProcess(isSystemApp(applicationInfo));
Info[] memoryInfo = am
.getProcessMemoryInfo(new int[] { id });
int memory = memoryInfo[0].getTotalPrivateDirty();
orySize(memory);
(info);
info = null;
} catch (Exception e) {
// tackTrace();
e(appProcessName);
ystemProcess(true);
}
}
return appInfos;
}
/**
* 过滤掉系统和⽩名单进程 获取最终要杀死的进程列表
* */
public ArrayList
ArrayList
List
for (int i = 0; i < (); i++) {
AppInfo info = (i);
if (!ystemProcess() && !ilterProcess()) {
(info);
}
}
return killRunningAppProcesses;
}
/**
* 遍历进程列表并杀死
* */
public String killProcesses(ArrayList
float killMemorySize = 0;
for (AppInfo appInfo : appInfos) {
if (forceStopPackageByPackageName(kageName())) {
float size = orySize();
Log.d("1----- DYP -----1","killProcesses-->> packageName:" + kageName()+ " | size:" + size);
killMemorySize = killMemorySize + orySize();
}
}
return numToString((float) killMemorySize / 1024);
}
// ################################ 清理⽂件 ###################################
/**
* 获取单个⽂件⼤⼩
* */
public float getFileSize(File file) {
float size = 0;
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream(file);
size = ble();
} catch (Exception e) {
Log.d("--- DYP --- getFileSize", "catch");
// tackTrace();
} finally {
if (inputStream != null) {
try {
();
} catch (ption e) {
tackTrace();
}
}
}
return (float) size / 1024;
}
/**
* 删除⽂件，并返回⽂件⼤⼩
* */
public String deleteFile(List
float allFileSize = 0;
float size = 0;
for (File file : files) {
size = getFileSize(file);
Log.d("3----- DYP -----3", "deleteFile-->> filePath:" + h()+ " | size:" + size);
if(()){
allFileSize = allFileSize + getFileSize(file);
}
}
// ();
return numToString((float) allFileSize / 1024);
}
/**
* 查找指定⽬录下的⽂件，
* */
List
public List
try {//遍历可能遇到.开头的⽂件
File file = new File(sd);
if (()) {
File[] files = les();
for (int i = 0; i < ; i++) {
if (files[i].isDirectory()) {
getallFiles(files[i].getAbsolutePath(), clearType);// 递归查找
} else {
for (int j = 0; j < ; j++) {
if (files[i].getAbsolutePath().endsWith((clearType[j]))) {// 以.apk这些结尾
// if (files[i].getAbsolutePath().endsWith(".apk")) {
// if (isInstallApp(files[i].getAbsolutePath())) {// 安装过可以删除
// (files[i]);
// }
// } else {
// (files[i]);
// }
(files[i]);
}
}
}
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
tackTrace();
}
return fileList;
}
// ################################ 清理缓存 ###################################
float cacheSize = 0;
/**
* 使⽤反射⽅法调⽤系统隐藏api： getPackageSizeInfo 获取app缓存⼤⼩
* */
public float getPackageSizeInfo(final String packageName) {
cacheSize = 0;
try {
Method method = hod(
"getPackageSizeInfo", new Class[] { ,
});
(pm, new Object[] { packageName,
new () {
@Override
public void onGetStatsCompleted(PackageStats pStats,
boolean succeeded) throws RemoteException {
cacheSize = ize;
}
} });
} catch (Exception e) {
cacheSize = 0;
// tackTrace();
}
return cacheSize;
}
boolean isCleanCacheSucceed = false;
/**
* 使⽤反射⽅法调⽤系统隐藏api： deleteApplicationCacheFiles 返回清除是否成功
* */
private boolean deleteApplicationCacheFiles(String packageName) {
isCleanCacheSucceed = false;
try {
Method method = hod(
"deleteApplicationCacheFiles", new Class[] { ,
});
(pm, packageName, new () {
@Override
public void onRemoveCompleted(String packageName,
boolean succeeded) throws RemoteException {
if(succeeded){
Log.d("DYP", "deleteApplicationCacheFiles -->> succeeded "+succeeded);
Log.d("DYP", "deleteApplicationCacheFiles -->> packageName "+packageName);
}
isCleanCacheSucceed = succeeded;
}
});
} catch (Exception e) {
// tackTrace();
Log.d("DYP", "deleteApplicationCacheFiles -->> catch ");
}
return isCleanCacheSucceed;
}
float allCacheSize = 0;
/**
* 清除所有安装app 返回的总缓存
* */
public String cleanCache(List
allCacheSize = 0;
for (int i = 0; i < (); i++) {
String packageName = (i).packageName;
if (packageName != null) {
float size = getPackageSizeInfo(packageName);
float size = getPackageSizeInfo(packageName);
//Log.d("2----- DYP -----2", "cleanCache--> packageName:" + packageName+ " | size:" + size);
if(deleteApplicationCacheFiles(packageName)){
allCacheSize = allCacheSize + size;
Log.d("2----- DYP -----2", "cleanCache--> packageName:" + packageName+ " | size:" + size);
}
}
}
return numToString((float) allCacheSize / 1024);
}
/**
* 判断app是否安装
* */
public boolean isInstallApp(String abPath) {
PackageManager pm = kageManager();
try {
kageInfo(abPath, _ACTIVITIES);
return true;
} catch (NameNotFoundException e) {
return false;
}
}
/**
* 获取所有已经安装的应⽤程序 ,包括那些卸载了的，但没有清除数据的应⽤程序
* */
public List
List
// List
return packageInfos;
}
// ############################# 将float转化为字符串形式返回 #########################
public String numToString(float f) {
// ⼩数不⾜2位,以0补⾜
DecimalFormat decimalFormat = new DecimalFormat("0.00");
String s = (f);
return s;
}
// ############################# 开始清理 并返回清理数据的⼤⼩ #########################
/** 清除指定垃圾⽂件 */
String[] clearType = { ".apk", ".log", ".tmp", ".temp", ".bak" };
String SDCARD_ROOT = "/mnt/sdcard";
public String startDeleteFile() {
return deleteFile(getallFiles(SDCARD_ROOT, clearType));
}
public String startCleanCache() {
return cleanCache(getPackageInfos());
}
public String startkillProcesses() {
return killProcesses(getKillRunningAppProcesses());
}
}
发布评论