How to uninstall programs, clear data, and stop services on android

How to uninstall programs, clear data, and stop services on android
To uninstall programs, clear data, and stop running services, the code is summarized as follows:
The main classes used are:
PackageManager
ActivityManager
ApplicationInfo
RunningServiceInfo
Method
There are also two android. the source file in pm is used to generate a pile, IPackageStatsObserver. java and IPackageDataObserver. java, from the name, we can see that they are related to the package status and size. Find the source code of these two files on the Internet and put them in android under the src directory of the project. under the pm package, create your own package.
First, you need to obtain the installed apk in the system. The first is the system apk, and the second is the third-party apk. Therefore, you can specify a filter when obtaining the apk, see the following code:
Java code

1. // Add a filter to get all programs, system programs, and programs installed by the user
   
2. 
   
3. Private List queryFilterAppInfo (int filter ){
   
4. // Query all installed applications
   
5. List listAppcations =
   
6. Pm. getInstalledApplications (PackageManager. GET_UNINSTALLED_PACKAGES );
   
7. Collections. sort (listAppcations, new
   
8. ApplicationInfo. DisplayNameComparator (pm); // sort
   
9. List appInfos = new ArrayList (); // Save the filtered AppInfo
   
10. // Filter Based on conditions
    
11. Switch (filter ){
    
12. Case FILTER_ALL_APP: // All Applications
    
13. AppInfos. clear ();
    
14. For (ApplicationInfo app: listAppcations ){
    
15. If (app. packageName. equals ("com. android. appmanager") {// filter yourself
    
16. Continue;
    
17. }
    
18. AppInfos. add (getAppInfo (app ));
    
19. }
    
20. Return appInfos;
    
21. Case FILTER_SYSTEM_APP: // System Program
    
22. AppInfos. clear ();
    
23. For (ApplicationInfo app: listAppcations ){
    
24. If (app. flags & ApplicationInfo. FLAG_SYSTEM )! = 0 ){
    
25. If (app. packageName. equals ("com. android. appmanager" "font-family: Arial,
    
26. Helvetica, sans-serif; ">) // wifi {// filter yourself
    
27. Continue;
    
28. }
    
29. AppInfos. add (getAppInfo (app ));
    
30. }
    
31. }
    
32. Return appInfos;
    
33. Case FILTER_THIRD_APP: // third-party Application
    
34. AppInfos. clear ();
    
35. For (ApplicationInfo app: listAppcations ){
    
36. // Non-system program
    
37. If (app. flags & ApplicationInfo. FLAG_SYSTEM) <= 0 ){
    
38. If (app. packageName. equals ("com. android. appmanager "))
    
39. Continue;
    
40. }
    
41. AppInfos. add (getAppInfo (app ));
    
42. }
    
43. // It is a system program. After being manually updated by the user, the system program becomes a third-party application.
    
44. Else if (app. flags & ApplicationInfo. FLAG_UPDATED_SYSTEM_APP )! = 0)
    
45. {
    
46. If (app. packageName. equals ("geeya. android. appmanage") {// filter yourself
    
47. Continue;
    
48. }
    
49. AppInfos. add (getAppInfo (app ));
    
50. }
    
51. }
    
52. Break;
    
53. Default:
    
54. Return null;
    
55. }
    
56. Return appInfos;
    
57. } Copy the code
    AppInfo is a class defined by myself. It contains the package name, data area size, code area size, and other attributes of the application.
    Well, now let's get the data area size, cache area size, and code area size of the app package. here we need to use the reflection mechanism to get the hidden method of the PackageManager class getPackageSizeInfo (), the specific implementation of this method is implemented through the callback function. here we need to use the pile generated by the IPackageStatsObserver class.
    Java code
    
    
    1. // Bindler mechanism service class formed by aidl File
       
    2. 
       
    3. Public class PkgSizeObserver extends IPackageStatsObserver. Stub {
       
    4. /***
       
    5. * Callback function,
       
    6. *
       
    7. * @ Param pStatus
       
    8. * The returned data is encapsulated in the PackageStats object.
       
    9. * @ Param succeeded
       
    10. * Indicates that the callback is successful.
        
    11. */
        
    12. @ Override
        
    13. Public void onGetStatsCompleted (PackageStats pStats, boolean succeeded)
        
    14. Throws RemoteException {
        
    15. Long cachesize; // cache size
        
    16. Long datasize; // data size
        
    17. Long codesize; // application size
        
    18. Long totalsize; // The total size.
        
    19. // System. out. println ("data start init! ");
        
    20. Synchronized (Integer. class ){
        
    21. Cachesize = pStats. cacheSize; // cache size
        
    22. Datasize = pStats. dataSize; // data size
        
    23. Codesize = pStats. codeSize; // application size
        
    24. Totalsize = cachesize + datasize + codesize;
        
    25. Message msg = mHandler. obtainMessage ();
        
    26. Msg. what = MSG_SIZE_CHANGE;
        
    27. Bundle bundle = new Bundle ();
        
    28. Bundle. putLong ("cachesize", cachesize );
        
    29. Bundle. putLong ("datasize", datasize );
        
    30. Bundle. putLong ("codesize", codesize );
        
    31. Bundle. putLong ("totalsize", totalsize );
        
    32. Bundle. putString ("packageName", pStats. packageName );
        
    33. Msg. obj = bundle;
        
    34. MHandler. sendMessage (msg );
        
    35. }
        
    36. }
        
    37. }
        
    38. // Obtain the size information of each apk, including the data zone, code zone, and cache zone.
        
    39. // Query the package size information
        
    40. Public void queryPacakgeSize (String pkgName) throws Exception {
        
    41. If (pkgName! = Null ){
        
    42. // Use the radiation mechanism to obtain the hidden function getPackageSizeInfo of the PackageManager class
        
    43. PackageManager pm = getPackageManager (); // get the pm object
        
    44. Try {
        
    45. // Obtain the hidden function through the reflection mechanism
        
    46. Method getPackageSizeInfo =
        
    47. Pm. getClass (). getDeclaredMethod ("getPackageSizeInfo", String. class,
        
    48. IPackageStatsObserver. class );
        
    49. GetPackageSizeInfo. invoke (pm, pkgName, new PkgSizeObserver ());
        
    50. } Catch (Exception ex ){
        
    51. // Log. e (TAG, "NoSuchMethodException ");
        
    52. Ex. printStackTrace ();
        
    53. Throw ex; // throw an exception
        
    54. }
        
    55. }
        
    56. } Copy the code
        This is the best way to encapsulate the app size data into messages for sending !!
        This section also describes how to convert long data into a file size format.
        Java code
        
        
        1. // System function, String Conversion long-String (kb)
           
        2. 
           
        3. Private String formateFileSize (long size ){
           
        4. Return Formatter. formatFileSize (MainActivity. this, size );
           
        5. } Copy the code
           Well, now let's clear user data. Here we need to use the previously downloaded file IPackageDataObserver, which is the same as getting the app size and implemented through callback.
           Java code
           
           
           1. // CLEAR user data
              
           2. 
              
           3. Class ClearUserDataObserver extends IPackageDataObserver. Stub {
              
           4. Public void onRemoveCompleted (final String packageName, final boolean
              
           5. Succeeded ){
              
           6. Final Message msg = mHandler. obtainMessage ();
              
           7. If (succeeded ){
              
           8. Msg. what = CLEAR_USER_DATA;
              
           9. } Else {
              
           10. Msg. what = NOT_CLEAR_USER_DATA;
               
           11. }
               
           12. MHandler2.sendMessage (msg );
               
           13. }
               
           14. }
               
           15. // Clear apk data
               
           16. Public void clearAppUserData (String pkgname ){
               
           17. // After testing, this method cannot be obtained through reflection. I have to write it like this and can only compile it in the source code.
               
           18. Pm. clearApplicationUserData (pkgname, new ClearUserDataObserver ());
               
           19. } Copy the code
               Okay. Now it's time to uninstall the program. Check the code.
               Java code
               
               
               1. // Uninstall apk
                  
               2. 
                  
               3. Ublic void unInstallApp (String pkgname ){
                  
               4. Log. e ("unInstallApp (String pkgname)", "pkgname is" + pkgname );
                  
               5. Intent intent = new Intent ();
                  
               6. // This action is defined by myself on the android framework layer. DELETE. HIDE indicates that the action is uninstalled directly. Without going through the native dialog of the system.
                  
               7. Intent. setAction ("android. intent. action. DELETE. HIDE ");//
                  
               8. The DELETE. HIDE action does not need to be confirmed by the system. Unmount directly!
                  
               9. Uri packageURI = Uri. parse ("package:" + pkgname );
                  
               10. Intent. setData (packageURI );
                   
               11. StartActivity (intent); copy the code
                   The apk management is almost the same. Now let's take a look at the management of running services.
                   First, obtain the running service:
                   Here, my RunningInfo is a class defined by myself. It mainly serves some attributes, such as the package name, uid, pid, and so on.
                   Java code
                   
                   
                   1. // Get the Running Service
                      
                   2. 
                      
                   3. Public List getRunningService (){
                      
                   4. List runServiceList = am. getRunningServices (30 );
                      
                   5. List Services_List = new ArrayList ();//
                      
                   6. Save the AppInfo
                      
                   7. Log. e ("getRunningService. size = ",
                      
                   8. New Integer (runServiceList. size (). toString ());
                      
                   9. String pkgname = "";
                      
                   10. ApplicationInfo appByPkgName = null;
                       
                   11. For (RunningServiceInfo info: runServiceList ){
                       
                   12. Pkgname = info. service. getPackageName ();
                       
                   13. // System. out. println ("service package is:" + pkgname +
                       
                   14. // "Pid =" + info. pid); // the ID of the program
                       
                   15. // Filter out the services of these systems. Only the services installed by the user are displayed.
                       
                   16. If (pkgname. equals ("com. android. appmanager") {// filter yourself
                       
                   17. Continue;
                       
                   18. }
                       
                   19. Try {
                       
                   20. AppByPkgName = pm. getApplicationInfo (pkgname,
                       
                   21. PackageManager. GET_UNINSTALLED_PACKAGES); // The last parameter is generally 0.
                       
                   22. .
                       
                   23. } Catch (NameNotFoundException e ){
                       
                   24. // Log. e ("MainActivity 841 line", "appByPkgName =
                       
                   25. Pm. getApplicationInfo (pkgname, PackageManager. GET_UNINSTALLED_PACKAGES)
                       
                   26. Exception! ");
                       
                   27. E. printStackTrace ();
                       
                   28. }
                       
                   29. Services_List.add (getRunningInfo (appByPkgName ));//
                       
                   30. Services that contain the same package. Here, we only need to display one.
                       
                   31. }
                       
                   32. // Put it in the set file to filter out those with the same package name. Here, I have rewritten the compareTo method of RunningInfo. Your rule is:
                       
                   33. PkgName is equal. Two objects are equal!
                       
                   34. Set set = new HashSet ();
                       
                   35. For (RunningInfo x: Services_List ){
                       
                   36. Set. add (x );
                       
                   37. }
                       
                   38. For (RunningInfo y: set ){
                       
                   39. Services_List.add (y );
                       
                   40. }
                       
                   41. Return Services_List;
                       
                   42. } Copy the code
                       After obtaining the running service, you can stop the service at will. The code for stopping the service is:
                       Java code
                       
                       
                       1. // Forcibly stop an app
                          
                       2. 
                          
                       3. Ublic boolean stopApp (String pkgname ){
                          
                       4. Boolean flag = false;
                          
                       5. ActivityManager am = (ActivityManager)
                          
                       6. MContext. getSystemService (Context. ACTIVITY_SERVICE );
                          
                       7. Try {
                          
                       8. Method forceStopPackage;
                          
                       9. ForceStopPackage = am. getClass (). getDeclaredMethod ("forceStopPackage ",
                          
                       10. String. class); // reflection to obtain the hidden method (hide)
                           
                       11. ForceStopPackage. setAccessible (true); // obtain the value of the Private member variable
                           
                       12. ForceStopPackage. invoke (am, pkgname );
                           
                       13. Flag = true;
                           
                       14. } Catch (IllegalArgumentException e ){
                           
                       15. E. printStackTrace ();
                           
                       16. Flag = false;
                           
                       17. } Catch (IllegalAccessException e ){
                           
                       18. E. printStackTrace ();
                           
                       19. Flag = false;
                           
                       20. } Catch (InvocationTargetException e ){
                           
                       21. E. printStackTrace ();
                           
                       22. Flag = false;
                           
                       23. } Catch (SecurityException e ){
                           
                       24. E. printStackTrace ();
                           
                       25. Flag = false;
                           
                       26. } Catch (NoSuchMethodException e ){
                           
                       27. E. printStackTrace ();
                           
                       28. Flag = false;
                           
                       29. }
                           
                       30. Return flag; copy the code
                           The reflection mechanism is also used to obtain hidden classes.
                           At this point, the application management function is almost the same,
                           The rest is just the interface and the processing process of the program. It should be okay!