获取su权限，并执行多条命令

工程代码：http://download.youkuaiyun.com/detail/victoryckl/4610617

    在apk中，有时候需要root权限，例如通过apk更新系统库等system的文件等，避免升级固件，或者在apk中需要直接访问某些设备等。下面是在apk中获取root权限的方法，前提是设备已经root过了。

   关键点在于下面这句，通过执行su产生一个具有root权限的进程：

Process p = Runtime.getRuntime().exec("su");

然后，在向这个进程的写入要执行的命令，即可达到以root权限执行命令：

dos = new DataOutputStream(p.getOutputStream());

dos.writeBytes(cmd + "\n");

dos.flush();

或者用下面的方式：

Runtime.getRuntime().exec(new String[]{"/system/bin/su","-c", cmd});

经过测试，以root权限执行命令，只在真机上测试成功，在模拟器上没有成功过。

第一次运行时，会出现请求root权限的界面，选中记住，并允许：

测试程序界面，如果已经root，界面中可以显示出/system分区对应的设备节点：

主要文件：RootCmd.java

[java]  view plain copy

1. package org.ckl.root;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.IOException;  
6.   
7. import android.util.Log;  
8.   
9. public final class RootCmd {  
10.   
11.     private static final String TAG = "RootCmd";  
12.     private static boolean mHaveRoot = false;  
13.   
14.     // 判断机器Android是否已经root，即是否获取root权限  
15.     public static boolean haveRoot() {  
16.         if (!mHaveRoot) {  
17.             int ret = execRootCmdSilent("echo test"); // 通过执行测试命令来检测  
18.             if (ret != -1) {  
19.                 Log.i(TAG, "have root!");  
20.                 mHaveRoot = true;  
21.             } else {  
22.                 Log.i(TAG, "not root!");  
23.             }  
24.         } else {  
25.             Log.i(TAG, "mHaveRoot = true, have root!");  
26.         }  
27.         return mHaveRoot;  
28.     }  
29.   
30.     // 执行命令并且输出结果  
31.     public static String execRootCmd(String cmd) {  
32.         String result = "";  
33.         DataOutputStream dos = null;  
34.         DataInputStream dis = null;  
35.           
36.         try {  
37.             Process p = Runtime.getRuntime().exec("su");// 经过Root处理的android系统即有su命令  
38.             dos = new DataOutputStream(p.getOutputStream());  
39.             dis = new DataInputStream(p.getInputStream());  
40.   
41.             Log.i(TAG, cmd);  
42.             dos.writeBytes(cmd + "\n");  
43.             dos.flush();  
44.             //可以写多条命令
45.             dos.writeBytes("exit\n");  
46.             dos.flush();  
47.             String line = null;  
48.             while ((line = dis.readLine()) != null) {  
49.                 Log.d("result", line);  
50.                 result += line;  
51.             }  
52.             p.waitFor();  
53.         } catch (Exception e) {  
54.             e.printStackTrace();  
55.         } finally {  
56.             if (dos != null) {  
57.                 try {  
58.                     dos.close();  
59.                 } catch (IOException e) {  
60.                     e.printStackTrace();  
61.                 }  
62.             }  
63.             if (dis != null) {  
64.                 try {  
65.                     dis.close();  
66.                 } catch (IOException e) {  
67.                     e.printStackTrace();  
68.                 }  
69.             }  
70.         }  
71.         return result;  
72.     }  
73.   
74.     // 执行命令但不关注结果输出  
75.     public static int execRootCmdSilent(String cmd) {  
76.         int result = -1;  
77.         DataOutputStream dos = null;  
78.           
79.         try {  
80.             Process p = Runtime.getRuntime().exec("su");  
81.             dos = new DataOutputStream(p.getOutputStream());  
82.               
83.             Log.i(TAG, cmd);  
84.             dos.writeBytes(cmd + "\n");  
85.             dos.flush();  
86.             dos.writeBytes("exit\n");  
87.             dos.flush();  
88.             p.waitFor();  
89.             result = p.exitValue();  
90.         } catch (Exception e) {  
91.             e.printStackTrace();  
92.         } finally {  
93.             if (dos != null) {  
94.                 try {  
95.                     dos.close();  
96.                 } catch (IOException e) {  
97.                     e.printStackTrace();  
98.                 }  
99.             }  
100.         }  
101.         return result;  
102.     }  
103. }  

相关文件：SystemPartition.java，获取/system分区设备节点，并支持重新mount /system为可读写：

[java]  view plain copy

1. package org.ckl.root;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.File;  
5. import java.io.FileInputStream;  
6. import java.io.IOException;  
7.   
8. import android.util.Log;  
9.   
10. public class SystemPartition {  
11.     private static final String TAG = "SystemMount";  
12.     private static String TMP_PATH = "/sdcard/mount.txt";  
13.     private static String mMountPiont = null;  
14.     private static boolean mWriteable = false;  
15.       
16.     private SystemPartition() {  
17.         Log.i(TAG, "new SystemMount()");  
18.     }  
19.       
20.     private static class SystemPartitionHolder {  
21.         private static SystemPartition instance = new SystemPartition();  
22.     }  
23.       
24.     public SystemPartition getInstance() {  
25.         return SystemPartitionHolder.instance;  
26.     }  
27.       
28.     public static String getSystemMountPiont() {  
29.         DataInputStream dis = null;  
30.         if (mMountPiont == null) {   
31.             try {  
32.                 RootCmd.execRootCmd("mount > " + TMP_PATH);  
33. //              Runtime.getRuntime().exec("mount > " + TMP_PATH);  
34.                   
35.                 dis = new DataInputStream(new FileInputStream(TMP_PATH));  
36.                   
37.                 String line = null;  
38.                 int index = -1;  
39.                 while ( (line = dis.readLine()) != null ) {  
40.                     index = line.indexOf(" /system ");  
41.                     if (index > 0) {  
42.                         mMountPiont = line.substring(0, index);  
43.                         if (line.indexOf(" rw") > 0) {  
44.                             mWriteable = true;  
45.                             Log.i(TAG, "/system is writeable !");  
46.                         } else {  
47.                             mWriteable = false;  
48.                             Log.i(TAG, "/system is readonly !");  
49.                         }  
50.                         break;  
51.                     }  
52.                 }  
53.             } catch (Exception e) {  
54.                 e.printStackTrace();  
55.             } finally {  
56.                 if (dis != null) {  
57.                     try {  
58.                         dis.close();  
59.                     } catch (IOException e1) {  
60.                         e1.printStackTrace();  
61.                     }  
62.                     dis = null;  
63.                 }  
64.                   
65.                 File f = new File(TMP_PATH);  
66.                 if (f.exists()) {  
67.                     f.delete();  
68.                 }  
69.             }  
70.         }  
71.           
72.         if (mMountPiont != null) {  
73.             Log.i(TAG, "/system mount piont: " + mMountPiont);  
74.         } else {  
75.             Log.i(TAG, "get /system mount piont failed !!!");  
76.         }  
77.           
78.         return mMountPiont;  
79.     }  
80.       
81.     public static boolean isWriteable() {  
82.         mMountPiont = null;  
83.         getSystemMountPiont();  
84.         return mWriteable;  
85.     }  
86.       
87.     public static void remountSystem(boolean writeable) {  
88.         String cmd = null;  
89.         getSystemMountPiont();  
90.         if (mMountPiont != null && RootCmd.haveRoot()) {  
91.             if (writeable) {  
92.                 cmd = "mount -o remount,rw " + mMountPiont + " /system";  
93.             } else {  
94.                 cmd = "mount -o remount,ro " + mMountPiont + " /system";  
95.             }  
96.             RootCmd.execRootCmdSilent(cmd);  
97.               
98.             isWriteable();  
99.         }  
100.     }  
101. }  
     
102.