manager: use SuFile to load webview assets to avoid spoofing manager's mount namespace

manager/app/build.gradle.kts

@@ -100,6 +100,7 @@ dependencies {
 
     implementation(libs.com.github.topjohnwu.libsu.core)
     implementation(libs.com.github.topjohnwu.libsu.service)
+    implementation(libs.com.github.topjohnwu.libsu.io)
 
     implementation(libs.dev.rikka.rikkax.parcelablelist)
 

manager/app/src/main/java/me/weishu/kernelsu/ui/screen/WebScreen.kt

@@ -2,51 +2,32 @@ package me.weishu.kernelsu.ui.screen
 
 import android.annotation.SuppressLint
 import android.app.Activity
-import android.content.Context
-import android.os.Handler
-import android.os.Looper
-import android.text.TextUtils
-import android.view.Window
-import android.webkit.JavascriptInterface
 import android.webkit.WebResourceRequest
 import android.webkit.WebResourceResponse
 import android.webkit.WebView
-import android.widget.Toast
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.core.view.WindowCompat
-import androidx.core.view.WindowInsetsCompat
-import androidx.core.view.WindowInsetsControllerCompat
 import androidx.webkit.WebViewAssetLoader
 import com.google.accompanist.web.AccompanistWebViewClient
 import com.google.accompanist.web.WebView
 import com.google.accompanist.web.rememberWebViewState
 import com.ramcosta.composedestinations.annotation.Destination
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
-import com.topjohnwu.superuser.CallbackList
+import me.weishu.kernelsu.ui.webui.SuFilePathHandler
-import com.topjohnwu.superuser.ShellUtils
+import me.weishu.kernelsu.ui.webui.WebViewInterface
-import me.weishu.kernelsu.ui.util.createRootShell
+import me.weishu.kernelsu.ui.webui.showSystemUI
-import me.weishu.kernelsu.ui.util.serveModule
-import org.json.JSONArray
-import org.json.JSONObject
 import java.io.File
-import java.util.concurrent.CompletableFuture
 
 @SuppressLint("SetJavaScriptEnabled")
 @Destination
 @Composable
 fun WebScreen(navigator: DestinationsNavigator, moduleId: String, moduleName: String) {
 
-    LaunchedEffect(Unit) {
-        serveModule(moduleId)
-    }
-
     val context = LocalContext.current
 
     DisposableEffect(Unit) {
@@ -58,9 +39,11 @@ fun WebScreen(navigator: DestinationsNavigator, moduleId: String, moduleName: St
     }
 
     Scaffold { innerPadding ->
-        val webRoot = File(context.dataDir, "webroot")
+        val webRoot = File("/data/adb/modules/${moduleId}/webroot")
         val webViewAssetLoader = WebViewAssetLoader.Builder()
-            .addPathHandler("/", WebViewAssetLoader.InternalStoragePathHandler(context, webRoot))
+            .addPathHandler("/",
+                SuFilePathHandler(context, webRoot)
+            )
             .build()
 
         val webViewClient = object : AccompanistWebViewClient() {
@@ -87,175 +70,3 @@ fun WebScreen(navigator: DestinationsNavigator, moduleId: String, moduleName: St
             })
     }
 }
-
-class WebViewInterface(val context: Context, private val webView: WebView) {
-
-    companion object {
-        var isHideSystemUI: Boolean = false
-    }
-
-    @JavascriptInterface
-    fun exec(cmd: String): String {
-        val shell = createRootShell()
-        return ShellUtils.fastCmd(shell, cmd)
-    }
-
-    @JavascriptInterface
-    fun exec(cmd: String, callbackFunc: String) {
-        exec(cmd, null, callbackFunc)
-    }
-
-    private fun processOptions(sb: StringBuilder, options: String?) {
-        val opts = if (options == null) JSONObject() else {
-            JSONObject(options)
-        }
-
-        val cwd = opts.optString("cwd")
-        if (!TextUtils.isEmpty(cwd)) {
-            sb.append("cd ${cwd};")
-        }
-
-        opts.optJSONObject("env")?.let { env ->
-            env.keys().forEach { key ->
-                sb.append("export ${key}=${env.getString(key)};")
-            }
-        }
-    }
-
-    @JavascriptInterface
-    fun exec(
-        cmd: String,
-        options: String?,
-        callbackFunc: String
-    ) {
-        val finalCommand = StringBuilder()
-        processOptions(finalCommand, options)
-        finalCommand.append(cmd)
-
-        val shell = createRootShell()
-        val result = shell.newJob().add(finalCommand.toString()).to(ArrayList(), ArrayList()).exec()
-        val stdout = result.out.joinToString(separator = "\n")
-        val stderr = result.err.joinToString(separator = "\n")
-
-        val jsCode =
-            "javascript: (function() { try { ${callbackFunc}(${result.code}, ${
-                JSONObject.quote(
-                    stdout
-                )
-            }, ${JSONObject.quote(stderr)}); } catch(e) { console.error(e); } })();"
-        webView.post {
-            webView.loadUrl(jsCode)
-        }
-    }
-
-    @JavascriptInterface
-    fun spawn(command: String, args: String, options: String?, callbackFunc: String) {
-        val finalCommand = StringBuilder()
-
-        processOptions(finalCommand, options)
-
-        if (!TextUtils.isEmpty(args)) {
-            finalCommand.append(command).append(" ")
-            JSONArray(args).let { argsArray ->
-                for (i in 0 until argsArray.length()) {
-                    finalCommand.append(argsArray.getString(i))
-                    finalCommand.append(" ")
-                }
-            }
-        } else {
-            finalCommand.append(command)
-        }
-
-        val shell = createRootShell()
-
-        val emitData = fun(name: String, data: String) {
-            val jsCode =
-                "javascript: (function() { try { ${callbackFunc}.${name}.emit('data', ${
-                    JSONObject.quote(
-                        data
-                    )
-                }); } catch(e) { console.error('emitData', e); } })();"
-            webView.post {
-                webView.loadUrl(jsCode)
-            }
-        }
-
-        val stdout = object : CallbackList<String>() {
-            override fun onAddElement(s: String) {
-                emitData("stdout", s)
-            }
-        }
-
-        val stderr = object : CallbackList<String>() {
-            override fun onAddElement(s: String) {
-                emitData("stderr", s)
-            }
-        }
-
-        val future = shell.newJob().add(finalCommand.toString()).to(stdout, stderr).enqueue()
-        val completableFuture = CompletableFuture.supplyAsync {
-            future.get()
-        }
-
-        completableFuture.thenAccept { result ->
-            val emitExitCode =
-                "javascript: (function() { try { ${callbackFunc}.emit('exit', ${result.code}); } catch(e) { console.error(`emitExit error: \${e}`); } })();"
-            webView.post {
-                webView.loadUrl(emitExitCode)
-            }
-
-            if (result.code != 0) {
-                val emitErrCode =
-                    "javascript: (function() { try { var err = new Error(); err.exitCode = ${result.code}; err.message = ${
-                        JSONObject.quote(
-                            result.err.joinToString(
-                                "\n"
-                            )
-                        )
-                    };${callbackFunc}.emit('error', err); } catch(e) { console.error('emitErr', e); } })();"
-                webView.post {
-                    webView.loadUrl(emitErrCode)
-                }
-            }
-        }
-    }
-
-    @JavascriptInterface
-    fun toast(msg: String) {
-        webView.post {
-            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
-        }
-    }
-
-    @JavascriptInterface
-    fun fullScreen(enable: Boolean) {
-        if (context is Activity) {
-            Handler(Looper.getMainLooper()).post {
-                if (enable) {
-                    hideSystemUI(context.window)
-                } else {
-                    showSystemUI(context.window)
-                }
-                isHideSystemUI = enable
-            }
-        }
-    }
-
-}
-
-private fun hideSystemUI(window: Window) {
-    WindowCompat.setDecorFitsSystemWindows(window, false)
-    WindowInsetsControllerCompat(window, window.decorView).let { controller ->
-        controller.hide(WindowInsetsCompat.Type.systemBars())
-        controller.systemBarsBehavior =
-            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
-    }
-}
-
-private fun showSystemUI(window: Window) {
-    WindowCompat.setDecorFitsSystemWindows(window, true)
-    WindowInsetsControllerCompat(
-        window,
-        window.decorView
-    ).show(WindowInsetsCompat.Type.systemBars())
-}

manager/app/src/main/java/me/weishu/kernelsu/ui/util/KsuCli.kt

@@ -31,11 +31,15 @@ fun getRootShell(): Shell {
     return KsuCli.SHELL
 }
 
-fun createRootShell(): Shell {
+fun createRootShell(globalMnt: Boolean = false): Shell {
     Shell.enableVerboseLogging = BuildConfig.DEBUG
     val builder = Shell.Builder.create()
     return try {
+        if (globalMnt) {
+            builder.build(getKsuDaemonPath(), "debug", "su", "-g")
+        } else {
             builder.build(getKsuDaemonPath(), "debug", "su")
+        }
     } catch (e: Throwable) {
         Log.e(TAG, "su failed: ", e)
         builder.build("sh")
@@ -131,15 +135,6 @@ fun installModule(
     }
 }
 
-fun serveModule(id: String): Boolean {
-    // we should use a new root shell to avoid blocking the global shell
-    val shell = createRootShell()
-    return ShellUtils.fastCmdResult(
-        shell,
-        "${getKsuDaemonPath()} module link-manager $id ${android.os.Process.myPid()} ${BuildConfig.APPLICATION_ID}"
-    )
-}
-
 fun reboot(reason: String = "") {
     val shell = getRootShell()
     if (reason == "recovery") {

manager/app/src/main/java/me/weishu/kernelsu/ui/webui/MimeUtil.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package me.weishu.kernelsu.ui.webui;
+
+import java.net.URLConnection;
+
+class MimeUtil {
+
+    public static String getMimeFromFileName(String fileName) {
+        if (fileName == null) {
+            return null;
+        }
+
+        // Copying the logic and mapping that Chromium follows.
+        // First we check against the OS (this is a limited list by default)
+        // but app developers can extend this.
+        // We then check against a list of hardcoded mime types above if the
+        // OS didn't provide a result.
+        String mimeType = URLConnection.guessContentTypeFromName(fileName);
+
+        if (mimeType != null) {
+            return mimeType;
+        }
+
+        return guessHardcodedMime(fileName);
+    }
+
+    // We should keep this map in sync with the lists under
+    // //net/base/mime_util.cc in Chromium.
+    // A bunch of the mime types don't really apply to Android land
+    // like word docs so feel free to filter out where necessary.
+    private static String guessHardcodedMime(String fileName) {
+        int finalFullStop = fileName.lastIndexOf('.');
+        if (finalFullStop == -1) {
+            return null;
+        }
+
+        final String extension = fileName.substring(finalFullStop + 1).toLowerCase();
+
+        switch (extension) {
+            case "webm":
+                return "video/webm";
+            case "mpeg":
+            case "mpg":
+                return "video/mpeg";
+            case "mp3":
+                return "audio/mpeg";
+            case "wasm":
+                return "application/wasm";
+            case "xhtml":
+            case "xht":
+            case "xhtm":
+                return "application/xhtml+xml";
+            case "flac":
+                return "audio/flac";
+            case "ogg":
+            case "oga":
+            case "opus":
+                return "audio/ogg";
+            case "wav":
+                return "audio/wav";
+            case "m4a":
+                return "audio/x-m4a";
+            case "gif":
+                return "image/gif";
+            case "jpeg":
+            case "jpg":
+            case "jfif":
+            case "pjpeg":
+            case "pjp":
+                return "image/jpeg";
+            case "png":
+                return "image/png";
+            case "apng":
+                return "image/apng";
+            case "svg":
+            case "svgz":
+                return "image/svg+xml";
+            case "webp":
+                return "image/webp";
+            case "mht":
+            case "mhtml":
+                return "multipart/related";
+            case "css":
+                return "text/css";
+            case "html":
+            case "htm":
+            case "shtml":
+            case "shtm":
+            case "ehtml":
+                return "text/html";
+            case "js":
+            case "mjs":
+                return "application/javascript";
+            case "xml":
+                return "text/xml";
+            case "mp4":
+            case "m4v":
+                return "video/mp4";
+            case "ogv":
+            case "ogm":
+                return "video/ogg";
+            case "ico":
+                return "image/x-icon";
+            case "woff":
+                return "application/font-woff";
+            case "gz":
+            case "tgz":
+                return "application/gzip";
+            case "json":
+                return "application/json";
+            case "pdf":
+                return "application/pdf";
+            case "zip":
+                return "application/zip";
+            case "bmp":
+                return "image/bmp";
+            case "tiff":
+            case "tif":
+                return "image/tiff";
+            default:
+                return null;
+        }
+    }
+}

manager/app/src/main/java/me/weishu/kernelsu/ui/webui/SuFilePathHandler.java

@@ -0,0 +1,195 @@
+package me.weishu.kernelsu.ui.webui;
+
+import android.content.Context;
+import android.util.Log;
+import android.webkit.WebResourceResponse;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.WorkerThread;
+import androidx.webkit.WebViewAssetLoader;
+
+import com.topjohnwu.superuser.Shell;
+import com.topjohnwu.superuser.io.SuFile;
+import com.topjohnwu.superuser.io.SuFileInputStream;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+import me.weishu.kernelsu.ui.util.KsuCliKt;
+
+/**
+ * Handler class to open files from file system by root access
+ * For more information about android storage please refer to
+ * <a href="https://developer.android.com/guide/topics/data/data-storage">Android Developers
+ * Docs: Data and file storage overview</a>.
+ * <p class="note">
+ * To avoid leaking user or app data to the web, make sure to choose {@code directory}
+ * carefully, and assume any file under this directory could be accessed by any web page subject
+ * to same-origin rules.
+ * <p>
+ * A typical usage would be like:
+ * <pre class="prettyprint">
+ * File publicDir = new File(context.getFilesDir(), "public");
+ * // Host "files/public/" in app's data directory under:
+ * // http://appassets.androidplatform.net/public/...
+ * WebViewAssetLoader assetLoader = new WebViewAssetLoader.Builder()
+ *          .addPathHandler("/public/", new InternalStoragePathHandler(context, publicDir))
+ *          .build();
+ * </pre>
+ */
+public final class SuFilePathHandler implements WebViewAssetLoader.PathHandler {
+    private static final String TAG = "SuFilePathHandler";
+
+    /**
+     * Default value to be used as MIME type if guessing MIME type failed.
+     */
+    public static final String DEFAULT_MIME_TYPE = "text/plain";
+
+    /**
+     * Forbidden subdirectories of {@link Context#getDataDir} that cannot be exposed by this
+     * handler. They are forbidden as they often contain sensitive information.
+     * <p class="note">
+     * Note: Any future addition to this list will be considered breaking changes to the API.
+     */
+    private static final String[] FORBIDDEN_DATA_DIRS =
+            new String[] {"/data/data", "/data/system"};
+
+    @NonNull
+    private final File mDirectory;
+
+    private final Shell mShell;
+
+    /**
+     * Creates PathHandler for app's internal storage.
+     * The directory to be exposed must be inside either the application's internal data
+     * directory {@link Context#getDataDir} or cache directory {@link Context#getCacheDir}.
+     * External storage is not supported for security reasons, as other apps with
+     * {@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} may be able to modify the
+     * files.
+     * <p>
+     * Exposing the entire data or cache directory is not permitted, to avoid accidentally
+     * exposing sensitive application files to the web. Certain existing subdirectories of
+     * {@link Context#getDataDir} are also not permitted as they are often sensitive.
+     * These files are ({@code "app_webview/"}, {@code "databases/"}, {@code "lib/"},
+     * {@code "shared_prefs/"} and {@code "code_cache/"}).
+     * <p>
+     * The application should typically use a dedicated subdirectory for the files it intends to
+     * expose and keep them separate from other files.
+     *
+     * @param context {@link Context} that is used to access app's internal storage.
+     * @param directory the absolute path of the exposed app internal storage directory from
+     *                  which files can be loaded.
+     * @throws IllegalArgumentException if the directory is not allowed.
+     */
+    public SuFilePathHandler(@NonNull Context context, @NonNull File directory) {
+        try {
+            mDirectory = new File(getCanonicalDirPath(directory));
+            if (!isAllowedInternalStorageDir(context)) {
+                throw new IllegalArgumentException("The given directory \"" + directory
+                        + "\" doesn't exist under an allowed app internal storage directory");
+            }
+            mShell = KsuCliKt.createRootShell(true);
+        } catch (IOException e) {
+            throw new IllegalArgumentException(
+                    "Failed to resolve the canonical path for the given directory: "
+                            + directory.getPath(), e);
+        }
+    }
+
+    private boolean isAllowedInternalStorageDir(@NonNull Context context) throws IOException {
+        String dir = getCanonicalDirPath(mDirectory);
+
+        for (String forbiddenPath : FORBIDDEN_DATA_DIRS) {
+            if (dir.startsWith(forbiddenPath)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Opens the requested file from the exposed data directory.
+     * <p>
+     * The matched prefix path used shouldn't be a prefix of a real web path. Thus, if the
+     * requested file cannot be found or is outside the mounted directory a
+     * {@link WebResourceResponse} object with a {@code null} {@link InputStream} will be
+     * returned instead of {@code null}. This saves the time of falling back to network and
+     * trying to resolve a path that doesn't exist. A {@link WebResourceResponse} with
+     * {@code null} {@link InputStream} will be received as an HTTP response with status code
+     * {@code 404} and no body.
+     * <p class="note">
+     * The MIME type for the file will be determined from the file's extension using
+     * {@link java.net.URLConnection#guessContentTypeFromName}. Developers should ensure that
+     * files are named using standard file extensions. If the file does not have a
+     * recognised extension, {@code "text/plain"} will be used by default.
+     *
+     * @param path the suffix path to be handled.
+     * @return {@link WebResourceResponse} for the requested file.
+     */
+    @Override
+    @WorkerThread
+    @NonNull
+    public WebResourceResponse handle(@NonNull String path) {
+        try {
+            File file = getCanonicalFileIfChild(mDirectory, path);
+            if (file != null) {
+                InputStream is = openFile(file, mShell);
+                String mimeType = guessMimeType(path);
+                return new WebResourceResponse(mimeType, null, is);
+            } else {
+                Log.e(TAG, String.format(
+                        "The requested file: %s is outside the mounted directory: %s", path,
+                        mDirectory));
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Error opening the requested path: " + path, e);
+        }
+        return new WebResourceResponse(null, null, null);
+    }
+
+    public static String getCanonicalDirPath(@NonNull File file) throws IOException {
+        String canonicalPath = file.getCanonicalPath();
+        if (!canonicalPath.endsWith("/")) canonicalPath += "/";
+        return canonicalPath;
+    }
+
+    public static File getCanonicalFileIfChild(@NonNull File parent, @NonNull String child)
+            throws IOException {
+        String parentCanonicalPath = getCanonicalDirPath(parent);
+        String childCanonicalPath = new File(parent, child).getCanonicalPath();
+        if (childCanonicalPath.startsWith(parentCanonicalPath)) {
+            return new File(childCanonicalPath);
+        }
+        return null;
+    }
+
+    @NonNull
+    private static InputStream handleSvgzStream(@NonNull String path,
+                                                @NonNull InputStream stream) throws IOException {
+        return path.endsWith(".svgz") ? new GZIPInputStream(stream) : stream;
+    }
+
+    public static InputStream openFile(@NonNull File file, @NonNull Shell shell) throws FileNotFoundException,
+            IOException {
+        SuFile suFile = new SuFile(file.getAbsolutePath());
+        suFile.setShell(shell);
+        InputStream fis = SuFileInputStream.open(suFile);
+        return handleSvgzStream(file.getPath(), fis);
+    }
+
+    /**
+     * Use {@link MimeUtil#getMimeFromFileName} to guess MIME type or return the
+     * {@link #DEFAULT_MIME_TYPE} if it can't guess.
+     *
+     * @param filePath path of the file to guess its MIME type.
+     * @return MIME type guessed from file extension or {@link #DEFAULT_MIME_TYPE}.
+     */
+    @NonNull
+    public static String guessMimeType(@NonNull String filePath) {
+        String mimeType = MimeUtil.getMimeFromFileName(filePath);
+        return mimeType == null ? DEFAULT_MIME_TYPE : mimeType;
+    }
+}

manager/app/src/main/java/me/weishu/kernelsu/ui/webui/WebViewInterface.kt

@@ -0,0 +1,192 @@
+package me.weishu.kernelsu.ui.webui
+
+import android.app.Activity
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.text.TextUtils
+import android.view.Window
+import android.webkit.JavascriptInterface
+import android.webkit.WebView
+import android.widget.Toast
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.topjohnwu.superuser.CallbackList
+import com.topjohnwu.superuser.ShellUtils
+import me.weishu.kernelsu.ui.util.createRootShell
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.CompletableFuture
+
+class WebViewInterface(val context: Context, private val webView: WebView) {
+
+    companion object {
+        var isHideSystemUI: Boolean = false
+    }
+
+    @JavascriptInterface
+    fun exec(cmd: String): String {
+        val shell = createRootShell()
+        return ShellUtils.fastCmd(shell, cmd)
+    }
+
+    @JavascriptInterface
+    fun exec(cmd: String, callbackFunc: String) {
+        exec(cmd, null, callbackFunc)
+    }
+
+    private fun processOptions(sb: StringBuilder, options: String?) {
+        val opts = if (options == null) JSONObject() else {
+            JSONObject(options)
+        }
+
+        val cwd = opts.optString("cwd")
+        if (!TextUtils.isEmpty(cwd)) {
+            sb.append("cd ${cwd};")
+        }
+
+        opts.optJSONObject("env")?.let { env ->
+            env.keys().forEach { key ->
+                sb.append("export ${key}=${env.getString(key)};")
+            }
+        }
+    }
+
+    @JavascriptInterface
+    fun exec(
+        cmd: String,
+        options: String?,
+        callbackFunc: String
+    ) {
+        val finalCommand = StringBuilder()
+        processOptions(finalCommand, options)
+        finalCommand.append(cmd)
+
+        val shell = createRootShell()
+        val result = shell.newJob().add(finalCommand.toString()).to(ArrayList(), ArrayList()).exec()
+        val stdout = result.out.joinToString(separator = "\n")
+        val stderr = result.err.joinToString(separator = "\n")
+
+        val jsCode =
+            "javascript: (function() { try { ${callbackFunc}(${result.code}, ${
+                JSONObject.quote(
+                    stdout
+                )
+            }, ${JSONObject.quote(stderr)}); } catch(e) { console.error(e); } })();"
+        webView.post {
+            webView.loadUrl(jsCode)
+        }
+    }
+
+    @JavascriptInterface
+    fun spawn(command: String, args: String, options: String?, callbackFunc: String) {
+        val finalCommand = StringBuilder()
+
+        processOptions(finalCommand, options)
+
+        if (!TextUtils.isEmpty(args)) {
+            finalCommand.append(command).append(" ")
+            JSONArray(args).let { argsArray ->
+                for (i in 0 until argsArray.length()) {
+                    finalCommand.append(argsArray.getString(i))
+                    finalCommand.append(" ")
+                }
+            }
+        } else {
+            finalCommand.append(command)
+        }
+
+        val shell = createRootShell()
+
+        val emitData = fun(name: String, data: String) {
+            val jsCode =
+                "javascript: (function() { try { ${callbackFunc}.${name}.emit('data', ${
+                    JSONObject.quote(
+                        data
+                    )
+                }); } catch(e) { console.error('emitData', e); } })();"
+            webView.post {
+                webView.loadUrl(jsCode)
+            }
+        }
+
+        val stdout = object : CallbackList<String>() {
+            override fun onAddElement(s: String) {
+                emitData("stdout", s)
+            }
+        }
+
+        val stderr = object : CallbackList<String>() {
+            override fun onAddElement(s: String) {
+                emitData("stderr", s)
+            }
+        }
+
+        val future = shell.newJob().add(finalCommand.toString()).to(stdout, stderr).enqueue()
+        val completableFuture = CompletableFuture.supplyAsync {
+            future.get()
+        }
+
+        completableFuture.thenAccept { result ->
+            val emitExitCode =
+                "javascript: (function() { try { ${callbackFunc}.emit('exit', ${result.code}); } catch(e) { console.error(`emitExit error: \${e}`); } })();"
+            webView.post {
+                webView.loadUrl(emitExitCode)
+            }
+
+            if (result.code != 0) {
+                val emitErrCode =
+                    "javascript: (function() { try { var err = new Error(); err.exitCode = ${result.code}; err.message = ${
+                        JSONObject.quote(
+                            result.err.joinToString(
+                                "\n"
+                            )
+                        )
+                    };${callbackFunc}.emit('error', err); } catch(e) { console.error('emitErr', e); } })();"
+                webView.post {
+                    webView.loadUrl(emitErrCode)
+                }
+            }
+        }
+    }
+
+    @JavascriptInterface
+    fun toast(msg: String) {
+        webView.post {
+            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
+        }
+    }
+
+    @JavascriptInterface
+    fun fullScreen(enable: Boolean) {
+        if (context is Activity) {
+            Handler(Looper.getMainLooper()).post {
+                if (enable) {
+                    hideSystemUI(context.window)
+                } else {
+                    showSystemUI(context.window)
+                }
+                isHideSystemUI = enable
+            }
+        }
+    }
+
+}
+
+fun hideSystemUI(window: Window) {
+    WindowCompat.setDecorFitsSystemWindows(window, false)
+    WindowInsetsControllerCompat(window, window.decorView).let { controller ->
+        controller.hide(WindowInsetsCompat.Type.systemBars())
+        controller.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+    }
+}
+
+fun showSystemUI(window: Window) {
+    WindowCompat.setDecorFitsSystemWindows(window, true)
+    WindowInsetsControllerCompat(
+        window,
+        window.decorView
+    ).show(WindowInsetsCompat.Type.systemBars())
+}

manager/gradle/libs.versions.toml

@@ -45,6 +45,7 @@ com-google-accompanist-webview = { group = "com.google.accompanist", name = "acc
 
 com-github-topjohnwu-libsu-core = { group = "com.github.topjohnwu.libsu", name = "core", version.ref = "libsu" }
 com-github-topjohnwu-libsu-service = { group = "com.github.topjohnwu.libsu", name = "service", version.ref = "libsu" }
+com-github-topjohnwu-libsu-io= { group = "com.github.topjohnwu.libsu", name = "io", version.ref = "libsu" }
 
 dev-rikka-rikkax-parcelablelist = { module = "dev.rikka.rikkax.parcelablelist:parcelablelist", version = "2.0.1" }