android在apk中获取root权限，并执行命令

admin

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

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

1. Process p = Runtime.getRuntime().exec("su");
   
2. 然后，在向这个进程的写入要执行的命令，即可达到以root权限执行命令：
   
3. dos = new DataOutputStream(p.getOutputStream());
   
4. dos.writeBytes(cmd + "\n");
   
5. dos.flush();
   
6. 或者用下面的方式：
   
7. Runtime.getRuntime().exec(new String[]{"/system/bin/su","-c", cmd});

复制代码

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

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

1. 主要文件：RootCmd.java
   
2. [java]
   
3. package org.ckl.root;
   
4. 
   
5. import java.io.DataInputStream;
   
6. import java.io.DataOutputStream;
   
7. import java.io.IOException;
   
8. 
   
9. import android.util.Log;
   
10. 
    
11. public final class RootCmd {
    
12. 
    
13.     private static final String TAG = "RootCmd";
    
14.     private static boolean mHaveRoot = false;
    
15. 
    
16.     // 判断机器Android是否已经root，即是否获取root权限
    
17.     public static boolean haveRoot() {
    
18.         if (!mHaveRoot) {
    
19.             int ret = execRootCmdSilent("echo test"); // 通过执行测试命令来检测
    
20.             if (ret != -1) {
    
21.                 Log.i(TAG, "have root!");
    
22.                 mHaveRoot = true;
    
23.             } else {
    
24.                 Log.i(TAG, "not root!");
    
25.             }
    
26.         } else {
    
27.             Log.i(TAG, "mHaveRoot = true, have root!");
    
28.         }
    
29.         return mHaveRoot;
    
30.     }
    
31. 
    
32.     // 执行命令并且输出结果
    
33.     public static String execRootCmd(String cmd) {
    
34.         String result = "";
    
35.         DataOutputStream dos = null;
    
36.         DataInputStream dis = null;
    
37.          
    
38.         try {
    
39.             Process p = Runtime.getRuntime().exec("su");// 经过Root处理的android系统即有su命令
    
40.             dos = new DataOutputStream(p.getOutputStream());
    
41.             dis = new DataInputStream(p.getInputStream());
    
42. 
    
43.             Log.i(TAG, cmd);
    
44.             dos.writeBytes(cmd + "\n");
    
45.             dos.flush();
    
46.             dos.writeBytes("exit\n");
    
47.             dos.flush();
    
48.             String line = null;
    
49.             while ((line = dis.readLine()) != null) {
    
50.                 Log.d("result", line);
    
51.                 result += line;
    
52.             }
    
53.             p.waitFor();
    
54.         } catch (Exception e) {
    
55.             e.printStackTrace();
    
56.         } finally {
    
57.             if (dos != null) {
    
58.                 try {
    
59.                     dos.close();
    
60.                 } catch (IOException e) {
    
61.                     e.printStackTrace();
    
62.                 }
    
63.             }
    
64.             if (dis != null) {
    
65.                 try {
    
66.                     dis.close();
    
67.                 } catch (IOException e) {
    
68.                     e.printStackTrace();
    
69.                 }
    
70.             }
    
71.         }
    
72.         return result;
    
73.     }
    
74. 
    
75.     // 执行命令但不关注结果输出
    
76.     public static int execRootCmdSilent(String cmd) {
    
77.         int result = -1;
    
78.         DataOutputStream dos = null;
    
79.          
    
80.         try {
    
81.             Process p = Runtime.getRuntime().exec("su");
    
82.             dos = new DataOutputStream(p.getOutputStream());
    
83.             
    
84.             Log.i(TAG, cmd);
    
85.             dos.writeBytes(cmd + "\n");
    
86.             dos.flush();
    
87.             dos.writeBytes("exit\n");
    
88.             dos.flush();
    
89.             p.waitFor();
    
90.             result = p.exitValue();
    
91.         } catch (Exception e) {
    
92.             e.printStackTrace();
    
93.         } finally {
    
94.             if (dos != null) {
    
95.                 try {
    
96.                     dos.close();
    
97.                 } catch (IOException e) {
    
98.                     e.printStackTrace();
    
99.                 }
    
100.             }
     
101.         }
     
102.         return result;
     
103.     }
     
104. }
     
105. 
     
106. 相关文件：SystemPartition.java，获取/system分区设备节点，并支持重新mount /system为可读写：
     
107. [java]
     
108. package org.ckl.root;
     
109. 
     
110. import java.io.DataInputStream;
     
111. import java.io.File;
     
112. import java.io.FileInputStream;
     
113. import java.io.IOException;
     
114. 
     
115. import android.util.Log;
     
116. 
     
117. public class SystemPartition {
     
118.     private static final String TAG = "SystemMount";
     
119.     private static String TMP_PATH = "/sdcard/mount.txt";
     
120.     private static String mMountPiont = null;
     
121.     private static boolean mWriteable = false;
     
122.      
     
123.     private SystemPartition() {
     
124.         Log.i(TAG, "new SystemMount()");
     
125.     }
     
126.      
     
127.     private static class SystemPartitionHolder {
     
128.         private static SystemPartition instance = new SystemPartition();
     
129.     }
     
130.      
     
131.     public SystemPartition getInstance() {
     
132.         return SystemPartitionHolder.instance;
     
133.     }
     
134.      
     
135.     public static String getSystemMountPiont() {
     
136.         DataInputStream dis = null;
     
137.         if (mMountPiont == null) {  
     
138.             try {
     
139.                 RootCmd.execRootCmd("mount > " + TMP_PATH);
     
140. //              Runtime.getRuntime().exec("mount > " + TMP_PATH);
     
141.                  
     
142.                 dis = new DataInputStream(new FileInputStream(TMP_PATH));
     
143.                  
     
144.                 String line = null;
     
145.                 int index = -1;
     
146.                 while ( (line = dis.readLine()) != null ) {
     
147.                     index = line.indexOf(" /system ");
     
148.                     if (index > 0) {
     
149.                         mMountPiont = line.substring(0, index);
     
150.                         if (line.indexOf(" rw") > 0) {
     
151.                             mWriteable = true;
     
152.                             Log.i(TAG, "/system is writeable !");
     
153.                         } else {
     
154.                             mWriteable = false;
     
155.                             Log.i(TAG, "/system is readonly !");
     
156.                         }
     
157.                         break;
     
158.                     }
     
159.                 }
     
160.             } catch (Exception e) {
     
161.                 e.printStackTrace();
     
162.             } finally {
     
163.                 if (dis != null) {
     
164.                     try {
     
165.                         dis.close();
     
166.                     } catch (IOException e1) {
     
167.                         e1.printStackTrace();
     
168.                     }
     
169.                     dis = null;
     
170.                 }
     
171.                  
     
172.                 File f = new File(TMP_PATH);
     
173.                 if (f.exists()) {
     
174.                     f.delete();
     
175.                 }
     
176.             }
     
177.         }
     
178.          
     
179.         if (mMountPiont != null) {
     
180.             Log.i(TAG, "/system mount piont: " + mMountPiont);
     
181.         } else {
     
182.             Log.i(TAG, "get /system mount piont failed !!!");
     
183.         }
     
184.          
     
185.         return mMountPiont;
     
186.     }
     
187.      
     
188.     public static boolean isWriteable() {
     
189.         mMountPiont = null;
     
190.         getSystemMountPiont();
     
191.         return mWriteable;
     
192.     }
     
193.      
     
194.     public static void remountSystem(boolean writeable) {
     
195.         String cmd = null;
     
196.         getSystemMountPiont();
     
197.         if (mMountPiont != null && RootCmd.haveRoot()) {
     
198.             if (writeable) {
     
199.                 cmd = "mount -o remount,rw " + mMountPiont + " /system";
     
200.             } else {
     
201.                 cmd = "mount -o remount,ro " + mMountPiont + " /system";
     
202.             }
     
203.             RootCmd.execRootCmdSilent(cmd);
     
204.             
     
205.             isWriteable();
     
206.         }
     
207.     }
     
208. }

复制代码