精华内容
下载资源
问答
  • 安卓一键清理工具

    2017-07-27 11:08:19
    一键清理工具类:主要清理 1.系统的内存 2.App的缓存 3.系统的临时文件 .apk .log .tmp .temp .back package com.hitv.process; import java.io.BufferedReader; import java.io.File; import java.io....

    一键清理工具类:主要清理 1.系统的内存 2.App的缓存 3.系统的临时文件 .apk .log .tmp .temp .back

    package com.hitv.process;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileReader;
    import java.lang.reflect.Method;
    import java.text.DecimalFormat;
    import java.util.ArrayList;
    import java.util.List;
    
    import android.app.ActivityManager;
    import android.app.ActivityManager.MemoryInfo;
    import android.app.ActivityManager.RunningAppProcessInfo;
    import android.app.ActivityManager.RunningTaskInfo;
    import android.content.Context;
    import android.content.Intent;
    import android.content.pm.ActivityInfo;
    import android.content.pm.ApplicationInfo;
    import android.content.pm.IPackageDataObserver;
    
    import android.content.pm.IPackageStatsObserver;
    import android.content.pm.PackageInfo;
    import android.content.pm.PackageManager;
    import android.content.pm.PackageStats;
    import android.content.pm.PackageManager.NameNotFoundException;
    import android.graphics.drawable.Drawable;
    import android.os.RemoteException;
    import android.util.Log;
    
    /**
     * @author DongYinPing 1045612812@qq.com
     * @version 1.0 一键清理工具类:主要清理 1.系统的内存 2.App的缓存 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) cx.getSystemService(Context.ACTIVITY_SERVICE);
            pm = cx.getPackageManager();
        }
    
        // ################################ 清理进程 ###################################
    
        /**
         * 获取进程白名单
         * */
        private List<String> getFilterPackgeName() {
    
            List<String> filterPackgeNames = new ArrayList<String>(); // 过滤一些进程
    
            ActivityInfo launcherInfo = new Intent(Intent.ACTION_MAIN).addCategory(
                    Intent.CATEGORY_HOME).resolveActivityInfo(pm, 0);
    
            filterPackgeNames.add(launcherInfo.packageName); // Launcher
            filterPackgeNames.add("com.hitv.locker"); // 定时锁屏管理
            filterPackgeNames.add(cx.getPackageName()); // 自己
            filterPackgeNames.add(getCurTopPackgeName()); // 过滤正在运行的进程      
    
            return filterPackgeNames;
        }
    
        /**
         * 系统剩余的内存
         * */
        public float getSurplusMemory() {
            MemoryInfo info = new ActivityManager.MemoryInfo();
            am.getMemoryInfo(info);
            return (float) info.availMem / 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 = bufferedReader.readLine();
                arrayOfString = str2.split("\\s+");
                initial_memory = Integer.valueOf(arrayOfString[1]);
                bufferedReader.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            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<ActivityManager> clazz = ActivityManager.class;
            Method method;
            try {
                method = clazz.getDeclaredMethod("forceStopPackage", String.class);
                method.invoke(am, packageName);
                forceSucceed = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return forceSucceed;
        }
    
        /**
         * 判断是否属于系统app
         * */
        public boolean isSystemApp(ApplicationInfo info) {
            if ((info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
                return false;// 表示是系统程序,但用户更新过,也算是用户安装的程序
            } else if ((info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
                return false; // 一定是用户安装的程序
            }
            return true;
        }
    
        /**
         * 获取最顶层的app包名,若是自己,则指定为其上一个
         * */
        public String getCurTopPackgeName() {
            String curAppTaskPackgeName = null;
            String myPackageName = cx.getPackageName();
            List<RunningTaskInfo> appTask = am.getRunningTasks(Integer.MAX_VALUE);
            if (appTask.size() > 0) {
                curAppTaskPackgeName = appTask.get(0).topActivity.getPackageName();
                if (appTask.size() > 1) {
                    if (curAppTaskPackgeName.equals(myPackageName)
                            && appTask.get(1) != null) {
                        curAppTaskPackgeName = appTask.get(1).topActivity
                                .getPackageName();
                    }
                }
            }
            return curAppTaskPackgeName;
        }
    
        /**
         * 遍历所有正在运行的进程列表,将所有应用的信息传入AppInfo中
         * */
        public List<AppInfo> getRunningAppProcesses() {
            List<RunningAppProcessInfo> runningAppProcessInfos = am
                    .getRunningAppProcesses();// 正在运行的进程
            List<AppInfo> appInfos = new ArrayList<AppInfo>();
            List<String> filterPackgeName = getFilterPackgeName();
            for (RunningAppProcessInfo appProcessInfo : runningAppProcessInfos) {
                AppInfo info = new AppInfo();
                int id = appProcessInfo.pid;
                info.setId(id);
                String appProcessName = appProcessInfo.processName;
                info.setIsFilterProcess(filterPackgeName.contains(appProcessName));// 需过滤的包名
                info.setPackageName(appProcessName);// 设置进程名
                try {
                    ApplicationInfo applicationInfo = pm.getPackageInfo(
                            appProcessName, 0).applicationInfo;
                    Drawable icon = applicationInfo.loadIcon(pm);
                    info.setIcon(icon);
                    String name = applicationInfo.loadLabel(pm).toString();
                    info.setName(name);
                    info.setIsSystemProcess(isSystemApp(applicationInfo));
                    android.os.Debug.MemoryInfo[] memoryInfo = am
                            .getProcessMemoryInfo(new int[] { id });
                    int memory = memoryInfo[0].getTotalPrivateDirty();
                    info.setMemorySize(memory);
                    appInfos.add(info);
                    info = null;
                } catch (Exception e) {
                    // e.printStackTrace();
                    info.setName(appProcessName);
                    info.setIsSystemProcess(true);
                }
            }
            return appInfos;
        }
    
        /**
         * 过滤掉系统和白名单进程 获取最终要杀死的进程列表
         * */
        public ArrayList<AppInfo> getKillRunningAppProcesses() {
            ArrayList<AppInfo> killRunningAppProcesses = new ArrayList<AppInfo>();
            List<AppInfo> runningAppProcessInfos = getRunningAppProcesses();// 正在运行的进程
            for (int i = 0; i < runningAppProcessInfos.size(); i++) {
                AppInfo info = runningAppProcessInfos.get(i);
                if (!info.getIsSystemProcess() && !info.getIsFilterProcess()) {
                    killRunningAppProcesses.add(info);
                }
            }
            return killRunningAppProcesses;
        }
    
        /**
         * 遍历进程列表并杀死
         * */
        public String killProcesses(ArrayList<AppInfo> appInfos) {
            float killMemorySize = 0;
            for (AppInfo appInfo : appInfos) {
                if (forceStopPackageByPackageName(appInfo.getPackageName())) {
                    float size = appInfo.getMemorySize();
                    Log.d("1----- DYP -----1","killProcesses-->>   packageName:" + appInfo.getPackageName()+ " | size:" + size);
                    killMemorySize = killMemorySize + appInfo.getMemorySize();
                }
            }
            return numToString((float) killMemorySize / 1024);
        }
    
        // ################################ 清理文件 ###################################
        /**
         * 获取单个文件大小
         * */
    
        public float getFileSize(File file) {
            float size = 0;
            FileInputStream inputStream = null;
            try {
                inputStream = new FileInputStream(file);
                size = inputStream.available();
            } catch (Exception e) {
                Log.d("--- DYP --- getFileSize", "catch");
                // e.printStackTrace();
            } finally {
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (java.io.IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
            return (float) size / 1024;
        }
    
        /**
         * 删除文件,并返回文件大小
         * */
        public String deleteFile(List<File> files) {
            float allFileSize = 0;
            float size = 0;
            for (File file : files) {
                size = getFileSize(file);
                Log.d("3----- DYP -----3", "deleteFile-->>  filePath:" + file.getPath()+ " | size:" + size);
                if(file.delete()){
                    allFileSize = allFileSize + getFileSize(file);
                }
            }
            // list.clear();
            return numToString((float) allFileSize / 1024);
        }
    
        /**
         * 查找指定目录下的文件,
         * */
        List<File> fileList = new ArrayList<File>();
    
        public List<File> getallFiles(String sd, String[] clearType) {
    
            try {//遍历可能遇到.开头的文件
    
                File file = new File(sd);
                if (file.exists()) {
                    File[] files = file.listFiles();
                    for (int i = 0; i < files.length; i++) {
                        if (files[i].isDirectory()) {
                            getallFiles(files[i].getAbsolutePath(), clearType);// 递归查找
                        } else {
                            for (int j = 0; j < clearType.length; j++) {
                                if (files[i].getAbsolutePath().endsWith((clearType[j]))) {// 以.apk这些结尾
    //                          if (files[i].getAbsolutePath().endsWith(".apk")) {
    //                              if (isInstallApp(files[i].getAbsolutePath())) {// 安装过可以删除
    //                                  fileList.add(files[i]);
    //                              }
    //                          } else {
    //                              fileList.add(files[i]);
    //                          }
                                    fileList.add(files[i]);
                                }
                            }
                        }
                    }
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return fileList;
        }
    
        // ################################ 清理缓存 ###################################
    
        float cacheSize = 0;
    
        /**
         * 使用反射方法调用系统隐藏api: getPackageSizeInfo 获取app缓存大小
         * */
        public float getPackageSizeInfo(final String packageName) {
            cacheSize = 0;
            try {
                Method method = PackageManager.class.getMethod(
                        "getPackageSizeInfo", new Class[] { String.class,
                                IPackageStatsObserver.class });
                method.invoke(pm, new Object[] { packageName,
                        new IPackageStatsObserver.Stub() {
                            @Override
                            public void onGetStatsCompleted(PackageStats pStats,
                                    boolean succeeded) throws RemoteException {
                                cacheSize = pStats.cacheSize;
                            }
                        } });
            } catch (Exception e) {
                cacheSize = 0;
                // e.printStackTrace();
            }
            return cacheSize;
        }
    
        boolean isCleanCacheSucceed = false;
    
        /**
         * 使用反射方法调用系统隐藏api: deleteApplicationCacheFiles 返回清除是否成功
         * */
        private boolean deleteApplicationCacheFiles(String packageName) {
            isCleanCacheSucceed = false;
            try {
                Method method = PackageManager.class.getMethod(
                        "deleteApplicationCacheFiles", new Class[] { String.class,
                                IPackageDataObserver.class });
                method.invoke(pm, packageName, new IPackageDataObserver.Stub() {
                    @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) {
                // e.printStackTrace();
                Log.d("DYP", "deleteApplicationCacheFiles -->> catch ");
            }
            return isCleanCacheSucceed;
        }
    
        float allCacheSize = 0;
    
        /**
         * 清除所有安装app 返回的总缓存
         * */
        public String cleanCache(List<PackageInfo> packageInfos) {
            allCacheSize = 0;
            for (int i = 0; i < packageInfos.size(); i++) {
                String packageName = packageInfos.get(i).packageName;
                if (packageName != null) {
                    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 = cx.getPackageManager();
            try {
                pm.getPackageInfo(abPath, PackageManager.GET_ACTIVITIES);
                return true;
            } catch (NameNotFoundException e) {
                return false;
            }
        }
    
        /**
         * 获取所有已经安装的应用程序 ,包括那些卸载了的,但没有清除数据的应用程序
         * */
        public List<PackageInfo> getPackageInfos() {
            List<PackageInfo> packageInfos = pm.getInstalledPackages(PackageManager.GET_UNINSTALLED_PACKAGES);
            // List<ApplicationInfo> listAppcations = pm.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
            return packageInfos;
        }
    
        // #############################  将float转化为字符串形式返回 #########################
    
        public String numToString(float f) {
            // 小数不足2位,以0补足
            DecimalFormat decimalFormat = new DecimalFormat("0.00");
            String s = decimalFormat.format(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());
        }
    }
    展开全文
  • 本项目是一个基于安卓的开源一键清理项目源码,支持root后进行强力清理。不过项目是使用android studio开发的工程,eclipse需要自己转工程才可以导入。实现的功能有:基本功能、内存加速、缓存清理、自启管理、软件...
  • 本项目是一个基于安卓的开源一键清理项目源码,支持root后进行强力清理。不过项目是使用android studio开发的工程,eclipse需要自己转工程才可以导入。实现的功能有:基本功能、内存加速、缓存清理、自启管理、软件...
  • 在Android设备中,我们经常会看到与系统或者应用相关的清除功能有:清除数据、清除缓存一键清理,这么多清除功能对于一个程序猿就够难理解了,偏偏很多安卓设备上都有这些功能,对于用户来说就更难理解,趁着在...

    在Android设备中,我们经常会看到与系统或者应用相关的清除功能有:清除数据、清除缓存、一键清理,这么多清除功能对于一个程序猿就够难理解了,偏偏很多安卓设备上都有这些功能,对于用户来说就更难理解,趁着在把玩手机的时候想到了这一点,索引追根究底了解他们的具体区别。

    清除数据和清除缓存

    一键清理
    清除数据、清除缓存、一键清理的区别
    清除数据

      清除数据主要是清除用户配置,比如SharedPreferences、数据库等等,这些数据都是在程序运行过程中保存的用户配置信息,清除数据后,下次进入程序就和第一次进入程序时一样;
    清除缓存

      缓存是程序运行时的临时存储空间,它可以存放从网络下载的临时图片,从用户的角度出发清除缓存对用户并没有太大的影响,但是清除缓存后用户再次使用该APP时,由于本地缓存已经被清理,所有的数据需要重新从网络上获取,注意:为了在清除缓存的时候能够正常清除与应用相关的缓存,请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。比如对微信清除缓存,则聊天记录、朋友圈缓存的用户头像、图片、文字等信息都会被清除掉,清除缓存后再次进入微信时你会发现消息记录被清空了,朋友圈的图片和用户头像需要加载一会才能正常显示。
    一键清理

      一键清理是系统级别的功能,它主要是杀后台进程,以达到释放内存的目的,但杀掉哪些进程和清理时设置的重要值阈值有关,重要值越大说明进程重要程度越低,如果在清理时某个进程的重要值大于该阈值,该进程就会被杀掉。比如微信等应用在后台,一件清理后会将微信和与之相关的服务都杀掉(有的服务做了特殊处理,杀不死!!!)。
    参考资料

        What’s the difference between clear cache & clear data in android settings

        Android中系统设置中的清除数据究竟会清除哪些数据

        Android 一键清理、内存清理功能实现

        How to delete files created by the application on uninstall?

    说明

      为了让程序被卸载后不在文件系统中留下毫无关联的无用文件,建议将应用相关的配置和缓存文件存放在程序被卸载时会删掉的文件夹下面(音乐文件、视频文件、图片、电子书这种适合多个应用阅读和浏览的文件除外),具体路径有:

        /data/data/package/

        getFilesDir()

        getCacheDir()

        getExternalCacheDir()(是否能够在程序被卸载时被删除与API的等级有关)

        getExternalFilesDir()(是否能够在程序被卸载时被删除与API的等级有关)

        在Android手机里面,缓存的位置分为两类,一类是Internal Storage,即内部存储,另外一类是External Storage,即外部存储。

        比较老的手机,有一个手机内部存储,还有一个SD卡存储,就是分别对应这两种存储位置,因为以前的SD卡是可以扩展的,即可拆卸的,所以可以用是否可拆卸作为内外存储的分类标准。

        但是现在最新的设备,比如小米、锤子、华为等,都取消了可拆卸的SD卡,直接与机身焊接在一起,分为16G、32G版本,所以现在内外存储的分类不再以是否可拆卸作为标准,而是以下面的几方面作为新的标准:
        内部存储

            总是可用的

            这里的文件默认是只能被你的app所访问的。

            当用户卸载你的app的时候,系统会把internal里面的相关文件都清除干净。

            Internal是在你想确保不被用户与其他app所访问的最佳存储区域。
        外部存储

            并不总是可用的,因为用户可以选择把这部分作为USB存储模式,这样就不可以访问了。

            是大家都可以访问的,因此保存到这里的文件是失去访问控制权限的。

            当用户卸载你的app时,系统仅仅会删除external根目录(getExternalFilesDir())下的相关文件。

            External是在你不需要严格的访问权限并且你希望这些文件能够被其他app所共享或者是允许用户通过电脑访问时的最佳存储区域。
        文件位置
        内部存储

            getFileDir() 通过此方法可以获取到你的APP内部存储的文件,路径为/data/data/pacgage_name/files

            getCacheDir() 通过此方法可以获取到你的APP内部存储的文件,路径为/data/data/package_name/cache

            openFileOutput() 通过此方法,我们可以获取到一个输出流,输出流的保存路径是/data/data/package_name/files ,和getFileDir()的路径一致
        外部存储
        私有存储

            Context.getExternalCacheDir()

            Context.getExternalFilesDir()

        创建的私有文件的地址是/sdcard/Android/date/package_name下面,Android文件夹是隐藏文件夹,用户无法操作。

        如果我们想缓存图片等比较耗空间的文件,推荐放在getExternalCacheDir()所在的文件下面,这个文件和getCacheDir()很像,都可以放缓存文件,在APP被卸载的时候,都会被系统删除,而且缓存的内容对其他APP是相对私有的。
        公共存储

        你的APP产生的文件不需要隐藏,即对用户是可见的,那么你可以把文件放在外部的公共存储文件下面。这个方法不是Context的方法,而是Environment的两个方法,第一个方法获取到的其实是外部存储的根目录,而第二个方法获取到得则是外部存储的公共目录。其实在访问权限上是没有区别的,不同点是getExternalStoragePublicDirectory()在运行的时候,会需要你带有一个特定的参数来指定这些public的文件类型,以便于与其他public文件进行分类。

            Environment.getExternalStorageDirectory()

            Environment.getExternalStoragePublicDirectory()
        表现
        内部存储

        你的app的internal storage 目录是以你的app的包名作为标识存放在Android文件系统的特定目录下[data/data/com.example.xx]。 从技术上讲,如果你设置文件为可读的,那么其他app就可以读取你的internal文件。然而,其他app需要知道你的包名与文件名。若是你没有设置为可读或者可写,其他app是没有办法读写的。因此只要你使用MODE_PRIVATE ,那么这些文件就不可能被其他app所访问。

        另外记住一点,内部存储在你的APP卸载的时候,会一块被删除,因此,我们可以在cache目录里面放置我们的图片缓存,而且cache与files的差别在于,如果手机的内部存储控件不够了,会自行选择cache目录进行删除,因此,不要把重要的文件放在cache文件里面,可以放置在files里面,因为这个文件只有在APP被卸载的时候才会被删除。还有要注意的一点是,如果应用程序是更新操作,内部存储不会被删除,区别于被用户手动卸载。
        外部存储

        不管你是使用 getExternalStoragePublicDirectory() 来存储可以共享的文件,还是使用 getExternalFilesDir() 来储存那些对与你的app来说是私有的文件,有一点很重要,那就是你要使用那些类似DIRECTORY_PICTURES 的API的常量。那些目录类型参数可以确保那些文件被系统正确的对待。例如,那些以DIRECTORY_RINGTONES 类型保存的文件就会被系统的media scanner认为是ringtone而不是音乐。
        清除数据、清除缓存的区别

            清除数据主要是清除用户配置,比如SharedPreferences、数据库等等,这些数据都是在程序运行过程中保存的用户配置信息,清除数据后,下次进入程序就和第一次进入程序时一样

            缓存是程序运行时的临时存储空间,它可以存放从网络下载的临时图片,从用户的角度出发清除缓存对用户并没有太大的影响,但是清除缓存后用户再次使用该APP时,由于本地缓存已经被清理,所有的数据需要重新从网络上获取。为了在清除缓存的时候能够正常清除与应用相关的缓存,请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。
     

    展开全文
  • 前言  在Android设备中,我们经常会看到与系统或者应用相关的清除功能有:清除数据、清除缓存一键清理,这么多清除功能对于一个程序猿就够难理解了,偏偏很多安卓设备上都有这些功能,对于用户来说就更难理解,...

    前言

      在Android设备中,我们经常会看到与系统或者应用相关的清除功能有:清除数据、清除缓存、一键清理,这么多清除功能对于一个程序猿就够难理解了,偏偏很多安卓设备上都有这些功能,对于用户来说就更难理解,趁着在把玩手机的时候想到了这一点,索引追根究底了解他们的具体区别。

    清除数据和清除缓存

    一键清理

    清除数据、清除缓存、一键清理的区别

    清除数据

      清除数据主要是清除用户配置,比如SharedPreferences、数据库等等,这些数据都是在程序运行过程中保存的用户配置信息,清除数据后,下次进入程序就和第一次进入程序时一样;

    清除缓存

      缓存是程序运行时的临时存储空间,它可以存放从网络下载的临时图片,从用户的角度出发清除缓存对用户并没有太大的影响,但是清除缓存后用户再次使用该APP时,由于本地缓存已经被清理,所有的数据需要重新从网络上获取,注意:为了在清除缓存的时候能够正常清除与应用相关的缓存,请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。比如对微信清除缓存,则聊天记录、朋友圈缓存的用户头像、图片、文字等信息都会被清除掉,清除缓存后再次进入微信时你会发现消息记录被清空了,朋友圈的图片和用户头像需要加载一会才能正常显示。

    一键清理

      一键清理是系统级别的功能,它主要是杀后台进程,以达到释放内存的目的,但杀掉哪些进程和清理时设置的重要值阈值有关,重要值越大说明进程重要程度越低,如果在清理时某个进程的重要值大于该阈值,该进程就会被杀掉。比如微信等应用在后台,一件清理后会将微信和与之相关的服务都杀掉(有的服务做了特殊处理,杀不死!!!)。

    参考资料

    说明

      为了让程序被卸载后不在文件系统中留下毫无关联的无用文件,建议将应用相关的配置和缓存文件存放在程序被卸载时会删掉的文件夹下面(音乐文件、视频文件、图片、电子书这种适合多个应用阅读和浏览的文件除外),具体路径有:

    • /data/data/package/

    • getFilesDir()

    • getCacheDir()

    • getExternalCacheDir()(是否能够在程序被卸载时被删除与API的等级有关)

    • getExternalFilesDir()(是否能够在程序被卸载时被删除与API的等级有关)

    展开全文
  • android 一键清除 清理

    千次阅读 2019-05-13 10:59:53
      在Android设备中,我们经常会看到与系统或者应用相关的清除功能有:清除数据、清除缓存一键清理,这么多清除功能对于一个程序猿就够难理解了,偏偏很多安卓设备上都有这些功能,对于用户来说就更难理解,趁着...

     

     

    前言

     

      在Android设备中,我们经常会看到与系统或者应用相关的清除功能有:清除数据、清除缓存、一键清理,这么多清除功能对于一个程序猿就够难理解了,偏偏很多安卓设备上都有这些功能,对于用户来说就更难理解,趁着在把玩手机的时候想到了这一点,索引追根究底了解他们的具体区别。

    清除数据和清除缓存

    一键清理

    清除数据、清除缓存、一键清理的区别

    清除数据

      清除数据主要是清除用户配置,比如SharedPreferences、数据库等等,这些数据都是在程序运行过程中保存的用户配置信息,清除数据后,下次进入程序就和第一次进入程序时一样;

    清除缓存

      缓存是程序运行时的临时存储空间,它可以存放从网络下载的临时图片,从用户的角度出发清除缓存对用户并没有太大的影响,但是清除缓存后用户再次使用该APP时,由于本地缓存已经被清理,所有的数据需要重新从网络上获取,注意:为了在清除缓存的时候能够正常清除与应用相关的缓存,请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。比如对微信清除缓存,则聊天记录、朋友圈缓存的用户头像、图片、文字等信息都会被清除掉,清除缓存后再次进入微信时你会发现消息记录被清空了,朋友圈的图片和用户头像需要加载一会才能正常显示。

    一键清理

      一键清理是系统级别的功能,它主要是杀后台进程,以达到释放内存的目的,但杀掉哪些进程和清理时设置的重要值阈值有关,重要值越大说明进程重要程度越低,如果在清理时某个进程的重要值大于该阈值,该进程就会被杀掉。比如微信等应用在后台,一件清理后会将微信和与之相关的服务都杀掉(有的服务做了特殊处理,杀不死!!!)。

    参考资料

    说明

      为了让程序被卸载后不在文件系统中留下毫无关联的无用文件,建议将应用相关的配置和缓存文件存放在程序被卸载时会删掉的文件夹下面(音乐文件、视频文件、图片、电子书这种适合多个应用阅读和浏览的文件除外),具体路径有:

    • /data/data/package/

    • getFilesDir()

    • getCacheDir()

    • getExternalCacheDir()(是否能够在程序被卸载时被删除与API的等级有关)

    • getExternalFilesDir()(是否能够在程序被卸载时被删除与API的等级有关)

     

    --------------------------------------------------

     

     

    Android 一键清理、内存清理功能实现:

     

    360桌面、金山清理大师等都提供了一键清理、一键加速等功能,其实就是杀一些后台进程来达到释放内存的目的。

       基本思路就是列出所有运行的进程,查看其重要值(RunningAppProcessInfo.importance,值越大说明进程重要程度越低),可以设定一个阈值,

    如果该进程的重要值大于该阈值,就可以杀掉该进程。

    进程的重要值有以下几个等级:

    [java] view plain copy

    1. /** 
    2.          * Constant for {@link #importance}: this is a persistent process. 
    3.          * Only used when reporting to process observers. 
    4.          * @hide 
    5.          */  
    6.         public static final int IMPORTANCE_PERSISTENT = 50;  
    7.   
    8.         /** 
    9.          * Constant for {@link #importance}: this process is running the 
    10.          * foreground UI. 
    11.          */  
    12.         public static final int IMPORTANCE_FOREGROUND = 100;  
    13.           
    14.         /** 
    15.          * Constant for {@link #importance}: this process is running something 
    16.          * that is actively visible to the user, though not in the immediate 
    17.          * foreground. 
    18.          */  
    19.         public static final int IMPORTANCE_VISIBLE = 200;  
    20.           
    21.         /** 
    22.          * Constant for {@link #importance}: this process is running something 
    23.          * that is considered to be actively perceptible to the user.  An 
    24.          * example would be an application performing background music playback. 
    25.          */  
    26.         public static final int IMPORTANCE_PERCEPTIBLE = 130;  
    27.           
    28.         /** 
    29.          * Constant for {@link #importance}: this process is running an 
    30.          * application that can not save its state, and thus can't be killed 
    31.          * while in the background. 
    32.          * @hide 
    33.          */  
    34.         public static final int IMPORTANCE_CANT_SAVE_STATE = 170;  
    35.           
    36.         /** 
    37.          * Constant for {@link #importance}: this process is contains services 
    38.          * that should remain running. 
    39.          */  
    40.         public static final int IMPORTANCE_SERVICE = 300;  
    41.           
    42.         /** 
    43.          * Constant for {@link #importance}: this process process contains 
    44.          * background code that is expendable. 
    45.          */  
    46.         public static final int IMPORTANCE_BACKGROUND = 400;  
    47.           
    48.         /** 
    49.          * Constant for {@link #importance}: this process is empty of any 
    50.          * actively running code. 
    51.          */  
    52.         public static final int IMPORTANCE_EMPTY = 500;  


    直接上代码:

    [java] view plain copy

    1. package com.android.clearmemory;  
    2.   
    3. import android.app.Activity;  
    4. import android.app.ActivityManager;  
    5. import android.app.ActivityManager.MemoryInfo;  
    6. import android.app.ActivityManager.RunningAppProcessInfo;  
    7. import android.content.Context;  
    8. import android.os.Bundle;  
    9. import android.util.Log;  
    10. import android.view.View;  
    11. import android.widget.Button;  
    12. import android.widget.Toast;  
    13.   
    14. import java.util.List;  
    15.   
    16. public class ClearMemoryActivity extends Activity {  
    17.     private static final String TAG = "ClearMemoryActivity";  
    18.   
    19.     /** 
    20.      * Called when the activity is first created. 
    21.      */  
    22.     @Override  
    23.     public void onCreate(Bundle savedInstanceState) {  
    24.         super.onCreate(savedInstanceState);  
    25.         setContentView(R.layout.main);  
    26.   
    27.         Button clear = (Button) findViewById(R.id.clear);  
    28.         clear.setOnClickListener(new View.OnClickListener() {  
    29.             @Override  
    30.             public void onClick(View v) {  
    31.                 //To change body of implemented methods use File | Settings | File Templates.  
    32.                 ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);  
    33.                 List<RunningAppProcessInfo> infoList = am.getRunningAppProcesses();  
    34.                 List<ActivityManager.RunningServiceInfo> serviceInfos = am.getRunningServices(100);  
    35.   
    36.                 long beforeMem = getAvailMemory(ClearMemoryActivity.this);  
    37.                 Log.d(TAG, "-----------before memory info : " + beforeMem);  
    38.                 int count = 0;  
    39.                 if (infoList != null) {  
    40.                     for (int i = 0; i < infoList.size(); ++i) {  
    41.                         RunningAppProcessInfo appProcessInfo = infoList.get(i);  
    42.                         Log.d(TAG, "process name : " + appProcessInfo.processName);  
    43.                         //importance 该进程的重要程度  分为几个级别,数值越低就越重要。  
    44.                         Log.d(TAG, "importance : " + appProcessInfo.importance);  
    45.   
    46.                         // 一般数值大于RunningAppProcessInfo.IMPORTANCE_SERVICE的进程都长时间没用或者空进程了  
    47.                         // 一般数值大于RunningAppProcessInfo.IMPORTANCE_VISIBLE的进程都是非可见进程,也就是在后台运行着  
    48.                         if (appProcessInfo.importance > RunningAppProcessInfo.IMPORTANCE_VISIBLE) {  
    49.                             String[] pkgList = appProcessInfo.pkgList;  
    50.                             for (int j = 0; j < pkgList.length; ++j) {//pkgList 得到该进程下运行的包名  
    51.                                 Log.d(TAG, "It will be killed, package name : " + pkgList[j]);  
    52.                                 am.killBackgroundProcesses(pkgList[j]);  
    53.                                 count++;  
    54.                             }  
    55.                         }  
    56.   
    57.                     }  
    58.                 }  
    59.   
    60.                 long afterMem = getAvailMemory(ClearMemoryActivity.this);  
    61.                 Log.d(TAG, "----------- after memory info : " + afterMem);  
    62.                 Toast.makeText(ClearMemoryActivity.this, "clear " + count + " process, "  
    63.                             + (afterMem - beforeMem) + "M", Toast.LENGTH_LONG).show();  
    64.             }  
    65.         });  
    66.   
    67.         ClearMemoryFloatView.instance(getApplicationContext()).createView();  
    68.     }  
    69.   
    70.     //获取可用内存大小  
    71.     private long getAvailMemory(Context context) {  
    72.         // 获取android当前可用内存大小  
    73.         ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
    74.         MemoryInfo mi = new MemoryInfo();  
    75.         am.getMemoryInfo(mi);  
    76.         //mi.availMem; 当前系统的可用内存  
    77.         //return Formatter.formatFileSize(context, mi.availMem);// 将获取的内存大小规格化  
    78.         Log.d(TAG, "可用内存---->>>" + mi.availMem / (1024 * 1024));  
    79.         return mi.availMem / (1024 * 1024);  
    80.     }  
    81. }  

     

    注意:

     

    我这里选择阈值是IMPORTANCE_VISIBLE级别的,也就是非可见的后台进程和服务会被杀掉(一些系统进程肯定除外)。

    清理的效果跟金山清理大师和360桌面的一键清理效果差不多。

    如果不想杀的太凶,可以选择IMPORTANCE_SERVICE级别,杀掉那些长时间没用或者空进程了,

    这个级别的清理力度不够大,达不到金山清理大师的效果。

     

     

     

     

     

     

    展开全文
  • 安卓手机有自带的手机管家,清理内存非常方便,但是苹果手机,很多朋友都不知道该怎么清理内存。今天笔者就分享几个办法,能轻松清理出几个G缓存哦!删除Safari浏览器缓存数据我们经常会用Safari浏览器浏览一些...
  • 安卓手机有自带的手机管家,清理内存非常方便,但是苹果手机,很多朋友都不知道该怎么清理内存。 今天笔者就分享几个办法,能轻松清理出几个G缓存哦! 删除Safari浏览器缓存数据 我们经常会用Safari浏览器浏览...
  • 安卓手机有自带的手机管家,清理内存非常方便,但是苹果手机,很多朋友都不知道该怎么清理内存。今天笔者就分享几个办法,能轻松清理出几个G缓存哦!删除Safari浏览器缓存数据我们经常会用Safari浏览器浏览一些...
  • 微信清理朋友圈app一款强大的微信清理工具,当你想要重置自己的微信号并删除所有的内容之时,又觉得一条条删太麻烦了,就可以用到这款神器工具,可以帮助你一键删除掉朋友圈内的所有内容,帮助你轻松的重置微信号,十分的...
  • 删除镜像删除,或在模拟器内应用-全部应用-清除缓存信息 ... ... 猎豹清理大师 - 安卓手机清理和加速必备神器! 猎豹清理大师是全球下载量第一的清理软件,一键清理手机垃圾文件,释放超乎你想象的存储空...
  • 安卓手机安全卫士源码基于黑马的手机安全项目源码作者又对功能做出了一些增删基本的功能有手机防盗、通讯黑名单、软件管理、进程管理、流量统计、手机杀毒、缓存清理、程序锁等进程管理实现了进程的Kill,就是平时...
  • 手机管家可以帮我们一键清理掉软件运行累积下来的应用缓存,但是对于废弃的安装包、图片、文档等多媒体文件,则需要我们手动去过滤删除。 这时候很多朋友都会使用手机自带的文件管理器来删除掉多余的文件,...
  • 安卓手机安全卫士源码基于黑马的手机安全项目源码作者又对功能做出了一些增删基本的功能有手机防盗、通讯黑名单、软件管理、进程管理、流量统计、手机杀毒、缓存清理、程序锁等进程管理实现了进程的Kill,就是平时...
  • 点击‘生成’-'更新系统缓存,勾选[检测并清理错误文档]' 7、更新网站: 点击‘生成’-‘一键更新网站 ’-更新所有-开始更新,这里默认把首页也更新了,如果你只想看首页的效果直接点击‘生成’-'更新主页html'就...
  • 黑马安卓52期视频教程

    热门讨论 2015-06-24 22:15:48
    1缓存清理 2看门狗的小bug修复 3添加广告 4加密和测试 5流量统计 IntelliJ IDEA 04、自定义控件与视图(2天)------------------------------ 1.组合系统控件 10.补充点 11.滑动开关(绘制开关) 12.1滑动开关(处理...
  • 蜂助手 v3.0.0.zip

    2019-07-12 07:02:30
    蜂助手是一款由广东蜂助手网络技术有限公司开发的手机服务平台。界面操作简洁,目前公司研发了六种产品,均支持安卓、苹果手机,满足不同服务环节的...2.一键清理垃圾缓存,手机加速优化 3.修复应用安装器导致程序卡死
  • 本源码为影视双端,支持一键生成安卓和苹果客户端,界面ui优美,对接苹果cms,只需打开api开放接口即可。...10.缓存清理 11.聚合直播 12.绑定用户设备码,防止乱注册 13.设置邀请奖励,注册奖励
  • 本源码为影视双端,支持一键生成安卓和苹果客户端,界面ui优美,对接苹果cms,只需...缓存清理 11.聚合直播 12.绑定用户设备码,防止乱注册 13.设置邀请奖励,注册奖励 14.太多了,,,懒得写,自行体验
  • 6.一键进程清理 7.缓存清理 8.历史记录清理(剪贴板记录,流览器历史,穀歌电子市场历史,Gmail搜索历史,穀歌地图历史记录,穀歌地球历史记录) 9.通话记录和短信记录清理 10.SD卡垃圾档清理 11.移动程式至SD卡 12....
  • 1.支持安卓 苹果,一键打包,方便使用 2.广告功能:首页幻灯片,搜索栏广告,播放页广告,代理中心广告 3.三种运营模式选择 4.优美的ui,适应于手机端的各种提示框 5.支持代理分销 6.卡密购买充值 7.视频下载 ...
  • 知识体系:对安卓知识体系做整理 登录注册:登录、注册、Cookie持久化 我的收藏页面:依靠Cookie持久化,实现对文章的收藏和展示 项目分类:在WanAndroid上发布的项目 网址导航:展示常用的开发网站 搜索功能:输入...
  • ✅ RunAny:一劳永逸的快速启动软件,拥有三键启动、一键直达、批量搜索、全局热键、短语输出、热键映射、脚本插件等功能 - 更多介绍 2019年12月17号添加 suziwen - Github ✅ 小书匠:一款专注于写作的 ...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

安卓一键清理缓存