import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public Shell switchRootShellContext(ShellContext shellContext) throws IOException, TimeoutException, RootDeniedException {
    if (this.shellType == ShellType.ROOT) {
        try {
            Shell.closeRootShell();
        } catch (Exception e) {
            RootShell.log("Problem closing shell while trying to switch context...");
        }

        //create new root shell with new context...

        return Shell.startRootShell(this.shellTimeout, shellContext, 3);
    } else {
        //can only switch context on a root shell...
        RootShell.log("Can only switch context on a root shell!");
        return this;
    }
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public static Shell startCustomShell(String shellPath, int timeout) throws IOException, TimeoutException, RootDeniedException {

        if (Shell.customShell == null) {
            RootShell.log("Starting Custom Shell!");
            Shell.customShell = new Shell(shellPath, ShellType.CUSTOM, ShellContext.NORMAL, timeout);
        } else {
            RootShell.log("Using Existing Custom Shell!");
        }

        return Shell.customShell;
    }
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public static Shell startShell(int timeout) throws IOException, TimeoutException {

        try {
            if (Shell.shell == null) {
                RootShell.log("Starting Shell!");
                Shell.shell = new Shell("/system/bin/sh", ShellType.NORMAL, ShellContext.NORMAL, timeout);
            } else {
                RootShell.log("Using Existing Shell!");
            }
            return Shell.shell;
        } catch (RootDeniedException e) {
            //Root Denied should never be thrown.
            throw new IOException();
        }
    }
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public final void useCWD(Context context) throws IOException, TimeoutException, RootDeniedException {
    add(
            new Command(
                    -1,
                    false,
                    "cd " + context.getApplicationInfo().dataDir)
    );
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public static String runAndWait(String cmd) throws IOException
{
	try
	{
		return runAndWait(cmd, RootTools.getShell(true)).getOutput();
	}
	catch (RootDeniedException | TimeoutException e)
	{
		throw new IOException(e);
	}
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public static Shell getRootShell()
{
	if (rootShell == null || rootShell.isClosed)
	{
		try
		{
			rootShell = RootShell.getShell(true);
		}
		catch (TimeoutException | IOException | RootDeniedException e)
		{
			Logger.errorST("Could not get root access", e);
		}
	}
	return rootShell;
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public static Command runRootCommand(Command command) throws IOException, TimeoutException, RootDeniedException {
    return Shell.startRootShell().add(command);
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
public static Shell startRootShell() throws IOException, TimeoutException, RootDeniedException {
    return Shell.startRootShell(0, 3);
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
/**
 * This will open or return, if one is already open, a shell, you are responsible for managing the shell, reading the output
 * and for closing the shell when you are done using it.
 *
 * @param root         a <code>boolean</code> to Indicate whether or not you want to open a root shell or a standard shell
 * @param timeout      an <code>int</code> to Indicate the length of time to wait before giving up on opening a shell.
 * @param shellContext the context to execute the shell with
 * @param retry        a <code>int</code> to indicate how many times the ROOT shell should try to open with root priviliges...
 */
public static Shell getShell(boolean root, int timeout, Shell.ShellContext shellContext, int retry) throws IOException, TimeoutException, RootDeniedException {
    if (root) {
        return Shell.startRootShell(timeout, shellContext, retry);
    } else {
        return Shell.startShell(timeout);
    }
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
/**
 * This will open or return, if one is already open, a custom shell, you are responsible for managing the shell, reading the output
 * and for closing the shell when you are done using it.
 *
 * @param shellPath a <code>String</code> to Indicate the path to the shell that you want to open.
 * @param timeout   an <code>int</code> to Indicate the length of time before giving up on opening a shell.
 * @throws TimeoutException
 * @throws com.stericson.RootShell.exceptions.RootDeniedException
 * @throws IOException
 */
public static Shell getCustomShell(String shellPath, int timeout) throws IOException, TimeoutException, RootDeniedException {
    return RootShell.getCustomShell(shellPath, timeout);
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
/**
 * This will open or return, if one is already open, a shell, you are responsible for managing the shell, reading the output
 * and for closing the shell when you are done using it.
 *
 * @param root         a <code>boolean</code> to Indicate whether or not you want to open a root shell or a standard shell
 * @param timeout      an <code>int</code> to Indicate the length of time to wait before giving up on opening a shell.
 * @param shellContext the context to execute the shell with
 * @param retry        a <code>int</code> to indicate how many times the ROOT shell should try to open with root priviliges...
 * @throws TimeoutException
 * @throws com.stericson.RootShell.exceptions.RootDeniedException
 * @throws IOException
 */
public static Shell getShell(boolean root, int timeout, Shell.ShellContext shellContext, int retry) throws IOException, TimeoutException, RootDeniedException {
    return RootShell.getShell(root, timeout, shellContext, retry);
}
 

import com.stericson.RootShell.exceptions.RootDeniedException; //导入依赖的package包/类
/**
 * Executes a single argument root command.
 * <p><b>Must be in an async call.</b></p>
 *
 * @param command   a command, ie {@code "rm -f"}, {@code "chmod 644"}...
 * @param uniqueArg the unique argument for the command, usually the file name
 */
private void runRootCommand(String command, String uniqueArg) throws IOException, TimeoutException, RootDeniedException {
    Command cmd = new Command(0, false, String.format(Locale.US, "%s %s", command, uniqueArg));
    RootShell.getShell(true).add(cmd);
}