如何在Android 4.0 ICS中禁用StatusBar | SystemBar | 状态栏 【完美版】

这个世界上总是有很多牛人，我们不得不对此表示无限钦佩。

在我上次博文发出后，我始终对此耿耿于怀，因为之前提供的解决禁用Statusbar问题在ICS中依然存在问题，即不能自动隐现，需要重启。因此在搜索几个月之后发现，依然难有进展。 

就在前几天，我发现在Acer A510 这个平板上之前的方法已经完全行不通，于是重新搜索整个互联网。茫茫大海，亏我之前做的功课甚多，在Hide Bar (http://ppareit.github.com/HideBar/ 
)这个小工具上得到启发，很巧妙的解决了这个问题。

这个Hide Bar也是一国外小团队做的禁用statusbar工具，六月份之前，仍然没有给出适用ICS版本的更新。于是在这次重新搜索中，我欣然发现它偷偷支持了，等不及下载，看源码，一会功夫我就将这些代码抠到项目中。

说说原理吧，原理很简单，我之前也知道过一部分，他是将com.android.systemui名称的进程杀掉，不过这个杀不同，它是每隔一秒杀一回。之前我也试过kill这个进程，但因为每次kill后隔几秒就会重启，可能因为内核保护吧，当时就没再继续。而Hide Bar跑了个循环，隔一秒杀一下，这下内核想保护也没用了。

当然我手上平板众多，也发现一些小问题，比如一秒有点长，有的板子在这一秒间隔重启了com.android.systemui进程，界面显示出加载的画面，但是不一会又被杀了，界面抖了一下又没了那个进程，因为这样显得有点不稳定，我减小了kill的间隔；还有就是因为调用杀进程的命令是killall，在有的板子上却不支持这个命令，于是我又将其他板子上/system/xbin/下的killall和usleep拿了过来，增加了这个代码的适用性。

话不多说了，上代码。

  1 package transight.tablet.android.util;
  2 
  3 import java.io.BufferedInputStream;
  4 import java.io.BufferedReader;
  5 import java.io.DataOutputStream;
  6 import java.io.File;
  7 import java.io.FileNotFoundException;
  8 import java.io.FileOutputStream;
  9 import java.io.IOException;
 10 import java.io.InputStream;
 11 import java.io.InputStreamReader;
 12 import java.util.ArrayList;
 13 import java.util.Map;
 14 
 15 import android.content.Context;
 16 import android.content.res.AssetManager;
 17 import android.util.Log;
 18 
 19 /**
 20  * Class with global information about the specific device.
 21  */
 22 public enum Device {
 23 
 24     INSTANCE;
 25 
 26     private static String TAG = Device.class.getSimpleName();
 27 
 28     private boolean mHasRootBeenChecked = false;
 29     private boolean mIsDeviceRooted = false;
 30 
 31     private boolean mHasBeenInitialized = false;
 32     private Context mAppContext = null;
 33 
 34     // flag if the systembar is currently visible, assume at start this is true
 35     private boolean mSystembarVisible = true;
 36 
 37     static public void initialize(Context appContext) {
 38         if (INSTANCE.mHasBeenInitialized == true) {
 39             Log.e(TAG, "Initializing already initialized class " + TAG);
 40             // throw new IllegalStateException(
 41             // "Trying to initialize already initialized class " + TAG);
 42         }
 43         INSTANCE.mHasBeenInitialized = true;
 44         INSTANCE.mAppContext = appContext;
 45         AddKillAll(appContext, "killall");
 46         AddKillAll(appContext, "usleep");
 47     }
 48 
 49     private static void AddKillAll(Context appContext, String commandFileName) {
 50         File killAllFile = new File("/system/xbin/"+commandFileName);
 51         if (!killAllFile.exists()) {
 52             AssetManager assetManager = appContext.getAssets();
 53             InputStream inputStream = null;
 54             String commandFilePath = null;
 55             try {
 56                 inputStream = assetManager.open(commandFileName);
 57                 commandFilePath = appContext.getApplicationContext().getFilesDir()
 58                         .getAbsolutePath() + File.separator + commandFileName;
 59                 saveToFile(commandFilePath, inputStream);
 60             } catch (IOException e) {
 61                 Log.e("tag", e.toString());
 62             }
 63             try {
 64                 Process p;
 65                 p = Runtime.getRuntime().exec("su");
 66 
 67                 // Attempt to write a file to a root-only
 68                 DataOutputStream os = new DataOutputStream(p.getOutputStream());
 69                 os.writeBytes("cd system/xbin\n");
 70                 os.writeBytes("cat " + commandFilePath + " > " + commandFileName + "\n");
 71                 os.writeBytes("chmod 755 " + commandFileName + "\n");
 72 
 73                 // Close the terminal
 74                 os.writeBytes("exit\n");
 75                 os.flush();
 76                 p.waitFor();
 77             } catch (Exception e) {
 78                 Log.e(TAG, e.toString());
 79             }
 80         }
 81     }
 82 
 83     static public Device getInstance() {
 84         INSTANCE.checkInitialized();
 85         return INSTANCE;
 86     }
 87 
 88     private void checkInitialized() {
 89         if (mHasBeenInitialized == false)
 90             throw new IllegalStateException("Singleton class " + TAG
 91                     + " is not yet initialized");
 92     }
 93 
 94     public boolean isRooted() {
 95 
 96         checkInitialized();
 97 
 98         Log.v(TAG, "isRooted called");
 99 
100         if (mHasRootBeenChecked) {
101             Log.v(TAG, "Result for isRooted is cached: " + mIsDeviceRooted);
102             return mIsDeviceRooted;
103         }
104 
105         // first try
106         Log.v(TAG, "Checking if device is rooted by checking if Superuser is available");
107         try {
108             File file = new File("/system/app/Superuser.apk");
109             if (file.exists()) {
110                 Log.v(TAG, "Device seems rooted");
111                 mHasRootBeenChecked = true;
112                 mIsDeviceRooted = true;
113                 return true;
114             }
115         } catch (Exception e) {
116             e.printStackTrace();
117         }
118 
119         // second try
120         Log.v(TAG, "Checking if device is rooted by checking if su is available");
121         try {
122             // get the existing environment
123             ArrayList<String> envlist = new ArrayList<String>();
124             Map<String, String> env = System.getenv();
125             for (String envName : env.keySet()) {
126                 envlist.add(envName + "=" + env.get(envName));
127             }
128             String[] envp = (String[]) envlist.toArray(new String[0]);
129             // execute which su
130             Process proc = Runtime.getRuntime()
131                     .exec(new String[] { "which", "su" }, envp);
132             BufferedReader in = new BufferedReader(new InputStreamReader(
133                     proc.getInputStream()));
134             // if we receive location, we are on a rooted device
135             // TODO: can break if the executable is on the device, but non working
136             if (in.readLine() != null) {
137                 Log.v(TAG, "Device seems rooted");
138                 mHasRootBeenChecked = true;
139                 mIsDeviceRooted = true;
140                 return true;
141             }
142         } catch (Exception e) {
143             e.printStackTrace();
144         }
145 
146         mHasRootBeenChecked = true;
147         mIsDeviceRooted = false;
148         return false;
149 
150     }
151 
152     public enum AndroidVersion {
153         HC, ICS, JB, UNKNOWN
154     };
155 
156     public AndroidVersion getAndroidVersion() {
157         checkInitialized();
158         Log.v(TAG, "getAndroidVersion called");
159         int sdk = android.os.Build.VERSION.SDK_INT;
160         if (11 <= sdk && sdk <= 13) {
161             Log.v(TAG, "We are running on HoneyComb");
162             return AndroidVersion.HC;
163         } else if (14 <= sdk && sdk <= 15) {
164             Log.v(TAG, "We are running on IceCreamSandwich");
165             return AndroidVersion.ICS;
166         } else if (16 == sdk) {
167             Log.v(TAG, "We are running on JellyBean");
168             return AndroidVersion.JB;
169         } else {
170             Log.v(TAG, "We don't know what we are running on");
171             return AndroidVersion.UNKNOWN;
172         }
173     }
174 
175     public void showSystembar(boolean makeVisible) {
176         checkInitialized();
177         try {
178             // get the existing environment
179             ArrayList<String> envlist = new ArrayList<String>();
180             Map<String, String> env = System.getenv();
181             for (String envName : env.keySet()) {
182                 envlist.add(envName + "=" + env.get(envName));
183             }
184             String[] envp = (String[]) envlist.toArray(new String[0]);
185             // depending on makeVisible, show or hide the bar
186             if (makeVisible) {
187                 Log.v(TAG, "showBar will show systembar");
188                 // execute in correct environment
189                 String command;
190                 Device dev = Device.getInstance();
191                 if (dev.getAndroidVersion() == AndroidVersion.HC) {
192                     command = "LD_LIBRARY_PATH=/vendor/lib:/system/lib am startservice -n com.android.systemui/.SystemUIService";
193                 } else {
194                     command = "rm /sdcard/hidebar-lock\n"
195                             + "sleep 5\n"
196                             + "LD_LIBRARY_PATH=/vendor/lib:/system/lib am startservice -n com.android.systemui/.SystemUIService";
197                 }
198                 Runtime.getRuntime().exec(new String[] { "su", "-c", command }, envp);
199                 // no proc.waitFor();
200                 // we just shown the bar, set flag to visible
201                 mSystembarVisible = true;
202             } else {
203                 Log.v(TAG, "showBar will hide the systembar");
204                 // execute in correct environment
205                 String command;
206                 Device dev = Device.getInstance();
207                 if (dev.getAndroidVersion() == AndroidVersion.HC) {
208                     command = "LD_LIBRARY_PATH=/vendor/lib:/system/lib service call activity 79 s16 com.android.systemui";
209                 } else {
210                     command = "touch /sdcard/hidebar-lock\n"
211                             + "while [ -f /sdcard/hidebar-lock ]\n"
212                             + "do\n"
213                             + "killall com.android.systemui\n"
214 //                            + "sleep 1\n"
215                             + "usleep 600000\n"
216                             + "done\n"
217                             + "LD_LIBRARY_PATH=/vendor/lib:/system/lib am startservice -n com.android.systemui/.SystemUIService";
218                 }
219                 Runtime.getRuntime().exec(new String[] { "su", "-c", command }, envp);
220                 // no proc.waitFor();
221                 // we just hide the bar, set flag to not visible
222                 mSystembarVisible = false;
223             }
224         } catch (Exception e) {
225             e.printStackTrace();
226         }
227     }
228 
229     /**
230      * @return true is the systembar is visible or false when it is not visible
231      */
232     public boolean isSystembarVisible() {
233         checkInitialized();
234         // TODO: this might be improved by using 'ps ...' to see if the systemui process
235         // is running and by checking the /sdcard/hidebar-lock file
236         return mSystembarVisible;
237     }
238 
239     public void sendBackEvent() {
240         Log.v(TAG, "sendBackEvent");
241         try {
242             // get the existing environment
243             ArrayList<String> envlist = new ArrayList<String>();
244             Map<String, String> env = System.getenv();
245             for (String envName : env.keySet()) {
246                 envlist.add(envName + "=" + env.get(envName));
247             }
248             String[] envp = (String[]) envlist.toArray(new String[0]);
249             Runtime.getRuntime().exec(
250                     new String[] { "su", "-c",
251                             "LD_LIBRARY_PATH=/vendor/lib:/system/lib input keyevent 4" },
252                     envp);
253         } catch (Exception e) {
254             e.printStackTrace();
255         }
256     }
257     
258     public static void saveToFile(String filePath, InputStream in){
259         FileOutputStream fos = null;
260         BufferedInputStream bis = null;
261         int BUFFER_SIZE = 1024;
262         byte[] buf = new byte[BUFFER_SIZE];
263         int size = 0;
264         bis = new BufferedInputStream(in);
265         try {
266             fos = new FileOutputStream(filePath);
267             while ((size = bis.read(buf)) != -1)
268                 fos.write(buf, 0, size);
269         } catch (FileNotFoundException e) {
270             e.printStackTrace();
271         } catch (IOException e) {
272             e.printStackTrace();
273         } finally {
274             try {
275                 if (fos != null) {
276                     fos.close();
277                 }
278                 if (bis != null) {
279                     bis.close();
280                 }
281             } catch (IOException e) {
282                 e.printStackTrace();
283             }
284         }
285     }
286 

287 } 

将killall和usleep放到assets文件夹下，执行以下代码即可。

 Device.initialize(getApplicationContext());
2 Device device = Device.getInstance();
3 device.showSystembar(false);