Android 执行shell 命令

package com.haha.xixi;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.ArrayList;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.text.TextUtils;
import android.util.AndroidRuntimeException;

/**
*
*/
public class Cmd {
public static final String RESULT_UNKNOW = "unknown";
public static ArrayList<String> sSuPkgNames = new ArrayList<String>();
static {
// //
sSuPkgNames.add("com.miui.uac");
}

private static final String DEFAULT_CHARSET = "utf-8";

public static String findSuShellBin() {
String pathStr = System.getenv("PATH");
if (pathStr != null && pathStr.length() > 0) {
String[] paths = pathStr.split(":");
for (String path : paths) {
File file = new File(path, "su");
if (file.exists()) {
return file.getPath();
}
}
}
return null;
}

public static String findShShellBin() {
String pathStr = System.getenv("PATH");
if (pathStr != null && pathStr.length() > 0) {
String[] paths = pathStr.split(":");
for (String path : paths) {
File file = new File(path, "sh");
if (file.exists()) {
return file.getPath();
}
}
}
return null;
}
public static final String SU_SOCKET = "/dev/ddd/server";

private static String readStrFromInputStream(InputStream in, String charset)
throws IOException {
final BufferedReader br = new BufferedReader(new InputStreamReader(in,
charset));
final char[] buf = new char[1024];
int readed = 0;
final StringBuilder builder = new StringBuilder();
while ((readed = br.read(buf)) != -1) {
builder.append(buf, 0, readed);
}
return (builder.length() > 0) ? builder.toString() : null;
}

public static String execForString(String cmd) {
try {
Process process = Runtime.getRuntime().exec(cmd);

BufferedReader reader = new BufferedReader(new InputStreamReader(
process.getInputStream()));
int read;
char[] buffer = new char[4096];
StringBuffer output = new StringBuffer();
while ((read = reader.read(buffer)) > 0) {
output.append(buffer, 0, read);
}
reader.close();
process.waitFor();
return output.toString();

} catch (IOException e) {
} catch (InterruptedException e) {
}
return RESULT_UNKNOW;
}

public static String exec(File directory, String... cmd) {
Process process = null;
try {
ProcessBuilder builder = new ProcessBuilder().command(cmd)
.redirectErrorStream(true).directory(directory);
try {
builder.environment().putAll(System.getenv());
} catch (Exception e) {
}
process = builder.start();
InputStream stdOut = process.getInputStream();
String str = readStrFromInputStream(stdOut, DEFAULT_CHARSET);
stdOut.close();
if (str != null) {
return str;
} else {
InputStream stdError = process.getErrorStream();
return readStrFromInputStream(stdError, DEFAULT_CHARSET);
}
} catch (Exception e) {
if (AppEnv.DEBUG) {
e.printStackTrace();
}
// throw new RuntimeException(e);
} finally {
if (process != null) {
process.destroy();
}

}
return RESULT_UNKNOW;
}

public static void exec(String cmd) throws IOException {
Process p = Runtime.getRuntime().exec(cmd);
BufferedReader stdInput = new BufferedReader(new InputStreamReader(
p.getInputStream()));
String s;
while ((s = stdInput.readLine()) != null) {
}
try {
p.waitFor();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static String execOnRoot(File directory, String... cmds)
throws Exception {

Process process = null;
String su = findSuShellBin();
if (su == null)
{
throw new Exception("The devices(" + Build.MODEL + ") has not rooted");
}
try
{

ProcessBuilder builder = new ProcessBuilder().command(su).redirectErrorStream(true).directory(directory);
try
{
builder.environment().putAll(System.getenv());
} catch (Exception e)
{
if (AppEnv.DEBUG)
{
e.printStackTrace();
}
}
process = builder.start();

OutputStream stdIn = process.getOutputStream();
InputStream stdOut = process.getInputStream();
InputStream stdError = process.getErrorStream();

for (String cmd : cmds)
{
if (AppEnv.DEBUG)
{
AssistLog.d("fu","cmd--" + cmd);
}
if (!cmd.endsWith("\n"))
{
cmd += "\n";
}
stdIn.write(cmd.getBytes());
stdIn.flush();
}
stdIn.write("exit\n".getBytes());
stdIn.flush();
stdIn.close();
if (AppEnv.DEBUG)
{
AssistLog.d("fu","readStrFromInputStream start");
}
String str = readStrFromInputStream(stdError, DEFAULT_CHARSET);
if (AppEnv.DEBUG)
{
AssistLog.d("fu","readStrFromInputStream end " + str);
}
if (TextUtils.isEmpty(str))
{
if (AppEnv.DEBUG)
{
AssistLog.d("fu","readStrFromInputStream empty start " + str);
}
str = readStrFromInputStream(stdOut, DEFAULT_CHARSET);
if (AppEnv.DEBUG)
{
AssistLog.d("fu","readStrFromInputStream empty end " + str);
}
}
process.waitFor();
stdOut.close();
stdError.close();
if (AppEnv.DEBUG)
{
AssistLog.d("fu","exit--" + str);
}
return str;
} catch (Exception e)
{
if (AppEnv.DEBUG)
e.printStackTrace();
throw new AndroidRuntimeException(e);
} finally
{
if (process != null)
{
try
{
process.destroy();
} catch (Exception e)
{
if (AppEnv.DEBUG)
e.printStackTrace();
}
}
}
}

public static boolean hasSuCmd() {
try {
return findSuShellBin() != null;
} catch (Exception e) {
return false;
}
}

public static boolean hasSuApk(Context c) {
try {
PackageManager p = c.getPackageManager();
for (String pkg : sSuPkgNames) {
try {
PackageInfo info = p.getPackageInfo(pkg, 0);
if (info != null) {
return true;
}
} catch (Exception e) {
continue;
}
}
return false;
} catch (Exception e) {
return false;
}
}

public static boolean isRoot() {
try {
String rootShell = findSuShellBin();
if (rootShell == null) {
return false;
}
String rtn = exec(new File("/"), rootShell, "-c", "id");
if (TextUtils.isEmpty(rtn)) {
return false;
}
return (-1 != rtn.indexOf("root"));
} catch (Exception e) {
return false;
}
}

public static boolean tryReBoot() {
try {
Runtime.getRuntime()
.exec(new String[] { "su", "-c", "reboot now" });

return true;
} catch (Exception e) {
AssistLog.d("Cmd", " Cmd tryReBoot() Exception=" + e.toString());
if (AppEnv.DEBUG) {
e.printStackTrace();
}
}
return false;
}
}