Changed!: Rename TermuxTask to AppShell since its not part of termux-app or com.termux.shared.termux package

app/src/main/java/com/termux/app/TermuxService.java

@@ -29,6 +29,7 @@ import com.termux.shared.data.IntentUtils;
 import com.termux.shared.net.uri.UriUtils;
 import com.termux.shared.errors.Errno;
 import com.termux.shared.shell.ShellUtils;
+import com.termux.shared.shell.command.runner.app.AppShell;
 import com.termux.shared.termux.shell.TermuxShellEnvironmentClient;
 import com.termux.shared.termux.shell.TermuxShellUtils;
 import com.termux.shared.termux.TermuxConstants;
@@ -42,7 +43,6 @@ import com.termux.shared.notification.NotificationUtils;
 import com.termux.shared.android.PermissionUtils;
 import com.termux.shared.data.DataUtils;
 import com.termux.shared.shell.command.ExecutionCommand;
-import com.termux.shared.shell.command.runner.app.TermuxTask;
 import com.termux.terminal.TerminalEmulator;
 import com.termux.terminal.TerminalSession;
 import com.termux.terminal.TerminalSessionClient;
@@ -51,7 +51,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * A service holding a list of {@link TermuxSession} in {@link #mTermuxSessions} and background {@link TermuxTask}
+ * A service holding a list of {@link TermuxSession} in {@link #mTermuxSessions} and background {@link AppShell}
  * in {@link #mTermuxTasks}, showing a foreground notification while running so that it is not terminated.
  * The user interacts with the session through {@link TermuxActivity}, but this service may outlive
  * the activity when the user or the system disposes of the activity. In that case the user may
@@ -63,7 +63,7 @@ import java.util.List;
  * Optionally may hold a wake and a wifi lock, in which case that is shown in the notification - see
  * {@link #buildNotification()}.
  */
-public final class TermuxService extends Service implements TermuxTask.TermuxTaskClient, TermuxSession.TermuxSessionClient {
+public final class TermuxService extends Service implements AppShell.AppShellClient, TermuxSession.TermuxSessionClient {
 
     private static int EXECUTION_ID = 1000;
 
@@ -87,7 +87,7 @@ public final class TermuxService extends Service implements TermuxTask.TermuxTas
     /**
      * The background TermuxTasks which this service manages.
      */
-    final List<TermuxTask> mTermuxTasks = new ArrayList<>();
+    final List<AppShell> mTermuxTasks = new ArrayList<>();
 
     /**
      * The pending plugin ExecutionCommands that have yet to be processed by this service.
@@ -263,7 +263,7 @@ public final class TermuxService extends Service implements TermuxTask.TermuxTas
             termuxSessions.get(i).killIfExecuting(this, processResult);
         }
 
-        List<TermuxTask> termuxTasks = new ArrayList<>(mTermuxTasks);
+        List<AppShell> termuxTasks = new ArrayList<>(mTermuxTasks);
         for (int i = 0; i < termuxTasks.size(); i++) {
             ExecutionCommand executionCommand = termuxTasks.get(i).getExecutionCommand();
             if (executionCommand.isPluginExecutionCommandWithPendingResult())
@@ -403,24 +403,24 @@ public final class TermuxService extends Service implements TermuxTask.TermuxTas
 
 
 
-    /** Execute a shell command in background {@link TermuxTask}. */
+    /** Execute a shell command in background TermuxTask. */
     private void executeTermuxTaskCommand(ExecutionCommand executionCommand) {
         if (executionCommand == null) return;
 
         Logger.logDebug(LOG_TAG, "Executing background \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask command");
 
-        TermuxTask newTermuxTask = createTermuxTask(executionCommand);
+        AppShell newTermuxTask = createTermuxTask(executionCommand);
     }
 
-    /** Create a {@link TermuxTask}. */
+    /** Create a TermuxTask. */
     @Nullable
-    public TermuxTask createTermuxTask(String executablePath, String[] arguments, String stdin, String workingDirectory) {
+    public AppShell createTermuxTask(String executablePath, String[] arguments, String stdin, String workingDirectory) {
         return createTermuxTask(new ExecutionCommand(getNextExecutionId(), executablePath, arguments, stdin, workingDirectory, true, false));
     }
 
-    /** Create a {@link TermuxTask}. */
+    /** Create a TermuxTask. */
     @Nullable
-    public synchronized TermuxTask createTermuxTask(ExecutionCommand executionCommand) {
+    public synchronized AppShell createTermuxTask(ExecutionCommand executionCommand) {
         if (executionCommand == null) return null;
 
         Logger.logDebug(LOG_TAG, "Creating \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask");
@@ -433,7 +433,7 @@ public final class TermuxService extends Service implements TermuxTask.TermuxTas
         if (Logger.getLogLevel() >= Logger.LOG_LEVEL_VERBOSE)
             Logger.logVerboseExtended(LOG_TAG, executionCommand.toString());
 
-        TermuxTask newTermuxTask = TermuxTask.execute(this, executionCommand, this, new TermuxShellEnvironmentClient(), false);
+        AppShell newTermuxTask = AppShell.execute(this, executionCommand, this, new TermuxShellEnvironmentClient(), false);
         if (newTermuxTask == null) {
             Logger.logError(LOG_TAG, "Failed to execute new TermuxTask command for:\n" + executionCommand.getCommandIdAndLabelLogString());
             // If the execution command was started for a plugin, then process the error
@@ -456,9 +456,9 @@ public final class TermuxService extends Service implements TermuxTask.TermuxTas
         return newTermuxTask;
     }
 
-    /** Callback received when a {@link TermuxTask} finishes. */
+    /** Callback received when a TermuxTask finishes. */
     @Override
-    public void onTermuxTaskExited(final TermuxTask termuxTask) {
+    public void onAppShellExited(final AppShell termuxTask) {
         mHandler.post(() -> {
             if (termuxTask != null) {
                 ExecutionCommand executionCommand = termuxTask.getExecutionCommand();

termux-shared/src/main/java/com/termux/shared/shell/command/ExecutionCommand.java

@@ -12,7 +12,7 @@ import com.termux.shared.errors.Error;
 import com.termux.shared.logger.Logger;
 import com.termux.shared.markdown.MarkdownUtils;
 import com.termux.shared.data.DataUtils;
-import com.termux.shared.shell.command.runner.app.TermuxTask;
+import com.termux.shared.shell.command.runner.app.AppShell;
 
 import java.util.Collections;
 import java.util.List;
@@ -87,10 +87,10 @@ public class ExecutionCommand {
     public boolean isFailsafe;
 
     /**
-     * The {@link ExecutionCommand} custom log level for background {@link TermuxTask}
+     * The {@link ExecutionCommand} custom log level for background {@link AppShell}
      * commands. By default, @link com.termux.shared.shell.StreamGobbler} only logs stdout and
      * stderr if {@link Logger} `CURRENT_LOG_LEVEL` is >= {@link Logger#LOG_LEVEL_VERBOSE} and
-     * {@link TermuxTask} only logs stdin if `CURRENT_LOG_LEVEL` is >=
+     * {@link AppShell} only logs stdin if `CURRENT_LOG_LEVEL` is >=
      * {@link Logger#LOG_LEVEL_DEBUG}.
      */
     public Integer backgroundCustomLogLevel;

termux-shared/src/main/java/com/termux/shared/shell/command/runner/app/AppShell.java

@@ -24,23 +24,23 @@ import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 
 /**
- * A class that maintains info for background Termux tasks run with {@link Runtime#exec(String[], String[], File)}.
+ * A class that maintains info for background app shells run with {@link Runtime#exec(String[], String[], File)}.
  * It also provides a way to link each {@link Process} with the {@link ExecutionCommand}
- * that started it.
+ * that started it. The shell is run in the app user context.
  */
-public final class TermuxTask {
+public final class AppShell {
 
     private final Process mProcess;
     private final ExecutionCommand mExecutionCommand;
-    private final TermuxTaskClient mTermuxTaskClient;
+    private final AppShellClient mAppShellClient;
 
-    private static final String LOG_TAG = "TermuxTask";
+    private static final String LOG_TAG = "AppShell";
 
-    private TermuxTask(@NonNull final Process process, @NonNull final ExecutionCommand executionCommand,
+    private AppShell(@NonNull final Process process, @NonNull final ExecutionCommand executionCommand,
-                       final TermuxTaskClient termuxTaskClient) {
+                     final AppShellClient appShellClient) {
         this.mProcess = process;
         this.mExecutionCommand = executionCommand;
-        this.mTermuxTaskClient = termuxTaskClient;
+        this.mAppShellClient = appShellClient;
     }
 
     /**
@@ -52,23 +52,23 @@ public final class TermuxTask {
      *
      * @param context The {@link Context} for operations.
      * @param executionCommand The {@link ExecutionCommand} containing the information for execution command.
-     * @param termuxTaskClient The {@link TermuxTaskClient} interface implementation.
+     * @param appShellClient The {@link AppShellClient} interface implementation.
-     *                           The {@link TermuxTaskClient#onTermuxTaskExited(TermuxTask)} will
+     *                           The {@link AppShellClient#onAppShellExited(AppShell)} will
      *                           be called regardless of {@code isSynchronous} value but not if
      *                           {@code null} is returned by this method. This can
      *                           optionally be {@code null}.
      * @param shellEnvironmentClient The {@link ShellEnvironmentClient} interface implementation.
      * @param isSynchronous If set to {@code true}, then the command will be executed in the
      *                      caller thread and results returned synchronously in the {@link ExecutionCommand}
-     *                      sub object of the {@link TermuxTask} returned.
+     *                      sub object of the {@link AppShell} returned.
      *                      If set to {@code false}, then a new thread is started run the commands
      *                      asynchronously in the background and control is returned to the caller thread.
-     * @return Returns the {@link TermuxTask}. This will be {@code null} if failed to start the execution command.
+     * @return Returns the {@link AppShell}. This will be {@code null} if failed to start the execution command.
      */
-    public static TermuxTask execute(@NonNull final Context context, @NonNull ExecutionCommand executionCommand,
+    public static AppShell execute(@NonNull final Context context, @NonNull ExecutionCommand executionCommand,
-                                     final TermuxTaskClient termuxTaskClient,
+                                   final AppShellClient appShellClient,
-                                     @NonNull final ShellEnvironmentClient shellEnvironmentClient,
+                                   @NonNull final ShellEnvironmentClient shellEnvironmentClient,
-                                     final boolean isSynchronous) {
+                                   final boolean isSynchronous) {
         if (executionCommand.workingDirectory == null || executionCommand.workingDirectory.isEmpty())
             executionCommand.workingDirectory = shellEnvironmentClient.getDefaultWorkingDirectoryPath();
         if (executionCommand.workingDirectory.isEmpty())
@@ -79,8 +79,8 @@ public final class TermuxTask {
         final String[] commandArray = shellEnvironmentClient.setupProcessArgs(executionCommand.executable, executionCommand.arguments);
 
         if (!executionCommand.setState(ExecutionState.EXECUTING)) {
-            executionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_failed_to_execute_termux_task_command, executionCommand.getCommandIdAndLabelLogString()));
+            executionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_failed_to_execute_app_shell_command, executionCommand.getCommandIdAndLabelLogString()));
-            TermuxTask.processTermuxTaskResult(null, executionCommand);
+            AppShell.processAppShellResult(null, executionCommand);
             return null;
         }
 
@@ -98,16 +98,16 @@ public final class TermuxTask {
         try {
             process = Runtime.getRuntime().exec(commandArray, env, new File(executionCommand.workingDirectory));
         } catch (IOException e) {
-            executionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_failed_to_execute_termux_task_command, executionCommand.getCommandIdAndLabelLogString()), e);
+            executionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_failed_to_execute_app_shell_command, executionCommand.getCommandIdAndLabelLogString()), e);
-            TermuxTask.processTermuxTaskResult(null, executionCommand);
+            AppShell.processAppShellResult(null, executionCommand);
             return null;
         }
 
-        final TermuxTask termuxTask = new TermuxTask(process, executionCommand, termuxTaskClient);
+        final AppShell appShell = new AppShell(process, executionCommand, appShellClient);
 
         if (isSynchronous) {
             try {
-                termuxTask.executeInner(context);
+                appShell.executeInner(context);
             } catch (IllegalThreadStateException | InterruptedException e) {
                 // TODO: Should either of these be handled or returned?
             }
@@ -116,7 +116,7 @@ public final class TermuxTask {
                 @Override
                 public void run() {
                     try {
-                        termuxTask.executeInner(context);
+                        appShell.executeInner(context);
                     } catch (IllegalThreadStateException | InterruptedException e) {
                         // TODO: Should either of these be handled or returned?
                     }
@@ -124,22 +124,22 @@ public final class TermuxTask {
             }.start();
         }
 
-        return termuxTask;
+        return appShell;
     }
 
     /**
      * Sets up stdout and stderr readers for the {@link #mProcess} and waits for the process to end.
      *
      * If the processes finishes, then sets {@link ResultData#stdout}, {@link ResultData#stderr}
-     * and {@link ResultData#exitCode} for the {@link #mExecutionCommand} of the {@code termuxTask}
+     * and {@link ResultData#exitCode} for the {@link #mExecutionCommand} of the {@code appShell}
-     * and then calls {@link #processTermuxTaskResult(TermuxTask, ExecutionCommand) to process the result}.
+     * and then calls {@link #processAppShellResult(AppShell, ExecutionCommand) to process the result}.
      *
      * @param context The {@link Context} for operations.
      */
     private void executeInner(@NonNull final Context context) throws IllegalThreadStateException, InterruptedException {
         final int pid = ShellUtils.getPid(mProcess);
 
-        Logger.logDebug(LOG_TAG, "Running \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid);
+        Logger.logDebug(LOG_TAG, "Running \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell with pid " + pid);
 
         mExecutionCommand.resultData.exitCode = null;
 
@@ -168,9 +168,9 @@ public final class TermuxTask {
                 } else {
                     // other issues we don't know how to handle, leads to
                     // returning null
-                    mExecutionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_exception_received_while_executing_termux_task_command, mExecutionCommand.getCommandIdAndLabelLogString(), e.getMessage()), e);
+                    mExecutionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_exception_received_while_executing_app_shell_command, mExecutionCommand.getCommandIdAndLabelLogString(), e.getMessage()), e);
                     mExecutionCommand.resultData.exitCode = 1;
-                    TermuxTask.processTermuxTaskResult(this, null);
+                    AppShell.processAppShellResult(this, null);
                     kill();
                     return;
                 }
@@ -196,13 +196,13 @@ public final class TermuxTask {
 
         // Process result
         if (exitCode == 0)
-            Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid + " exited normally");
+            Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell with pid " + pid + " exited normally");
         else
-            Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid + " exited with code: " + exitCode);
+            Logger.logDebug(LOG_TAG, "The \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell with pid " + pid + " exited with code: " + exitCode);
 
         // If the execution command has already failed, like SIGKILL was sent, then don't continue
         if (mExecutionCommand.isStateFailed()) {
-            Logger.logDebug(LOG_TAG, "Ignoring setting \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask state to ExecutionState.EXECUTED and processing results since it has already failed");
+            Logger.logDebug(LOG_TAG, "Ignoring setting \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell state to ExecutionState.EXECUTED and processing results since it has already failed");
             return;
         }
 
@@ -211,30 +211,30 @@ public final class TermuxTask {
         if (!mExecutionCommand.setState(ExecutionState.EXECUTED))
             return;
 
-        TermuxTask.processTermuxTaskResult(this, null);
+        AppShell.processAppShellResult(this, null);
     }
 
     /**
-     * Kill this {@link TermuxTask} by sending a {@link OsConstants#SIGILL} to its {@link #mProcess}
+     * Kill this {@link AppShell} by sending a {@link OsConstants#SIGILL} to its {@link #mProcess}
      * if its still executing.
      *
      * @param context The {@link Context} for operations.
-     * @param processResult If set to {@code true}, then the {@link #processTermuxTaskResult(TermuxTask, ExecutionCommand)}
+     * @param processResult If set to {@code true}, then the {@link #processAppShellResult(AppShell, ExecutionCommand)}
      *                      will be called to process the failure.
      */
     public void killIfExecuting(@NonNull final Context context, boolean processResult) {
         // If execution command has already finished executing, then no need to process results or send SIGKILL
         if (mExecutionCommand.hasExecuted()) {
-            Logger.logDebug(LOG_TAG, "Ignoring sending SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask since it has already finished executing");
+            Logger.logDebug(LOG_TAG, "Ignoring sending SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell since it has already finished executing");
             return;
         }
 
-        Logger.logDebug(LOG_TAG, "Send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask");
+        Logger.logDebug(LOG_TAG, "Send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell");
 
         if (mExecutionCommand.setStateFailed(Errno.ERRNO_FAILED.getCode(), context.getString(R.string.error_sending_sigkill_to_process))) {
             if (processResult) {
                 mExecutionCommand.resultData.exitCode = 137; // SIGKILL
-                TermuxTask.processTermuxTaskResult(this, null);
+                AppShell.processAppShellResult(this, null);
             }
         }
 
@@ -244,7 +244,7 @@ public final class TermuxTask {
     }
 
     /**
-     * Kill this {@link TermuxTask} by sending a {@link OsConstants#SIGILL} to its {@link #mProcess}.
+     * Kill this {@link AppShell} by sending a {@link OsConstants#SIGILL} to its {@link #mProcess}.
      */
     public void kill() {
         int pid = ShellUtils.getPid(mProcess);
@@ -252,43 +252,43 @@ public final class TermuxTask {
             // Send SIGKILL to process
             Os.kill(pid, OsConstants.SIGKILL);
         } catch (ErrnoException e) {
-            Logger.logWarn(LOG_TAG, "Failed to send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask with pid " + pid + ": " + e.getMessage());
+            Logger.logWarn(LOG_TAG, "Failed to send SIGKILL to \"" + mExecutionCommand.getCommandIdAndLabelLogString() + "\" AppShell with pid " + pid + ": " + e.getMessage());
         }
     }
 
     /**
-     * Process the results of {@link TermuxTask} or {@link ExecutionCommand}.
+     * Process the results of {@link AppShell} or {@link ExecutionCommand}.
      *
-     * Only one of {@code termuxTask} and {@code executionCommand} must be set.
+     * Only one of {@code appShell} and {@code executionCommand} must be set.
      *
-     * If the {@code termuxTask} and its {@link #mTermuxTaskClient} are not {@code null},
+     * If the {@code appShell} and its {@link #mAppShellClient} are not {@code null},
-     * then the {@link TermuxTaskClient#onTermuxTaskExited(TermuxTask)} callback will be called.
+     * then the {@link AppShellClient#onAppShellExited(AppShell)} callback will be called.
      *
-     * @param termuxTask The {@link TermuxTask}, which should be set if
+     * @param appShell The {@link AppShell}, which should be set if
-     *                  {@link #execute(Context, ExecutionCommand, TermuxTaskClient, ShellEnvironmentClient, boolean)}
+     *                  {@link #execute(Context, ExecutionCommand, AppShellClient, ShellEnvironmentClient, boolean)}
      *                   successfully started the process.
      * @param executionCommand The {@link ExecutionCommand}, which should be set if
-     *                          {@link #execute(Context, ExecutionCommand, TermuxTaskClient, ShellEnvironmentClient, boolean)}
+     *                          {@link #execute(Context, ExecutionCommand, AppShellClient, ShellEnvironmentClient, boolean)}
      *                          failed to start the process.
      */
-    private static void processTermuxTaskResult(final TermuxTask termuxTask, ExecutionCommand executionCommand) {
+    private static void processAppShellResult(final AppShell appShell, ExecutionCommand executionCommand) {
-        if (termuxTask != null)
+        if (appShell != null)
-            executionCommand = termuxTask.mExecutionCommand;
+            executionCommand = appShell.mExecutionCommand;
 
         if (executionCommand == null) return;
 
         if (executionCommand.shouldNotProcessResults()) {
-            Logger.logDebug(LOG_TAG, "Ignoring duplicate call to process \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask result");
+            Logger.logDebug(LOG_TAG, "Ignoring duplicate call to process \"" + executionCommand.getCommandIdAndLabelLogString() + "\" AppShell result");
             return;
         }
 
-        Logger.logDebug(LOG_TAG, "Processing \"" + executionCommand.getCommandIdAndLabelLogString() + "\" TermuxTask result");
+        Logger.logDebug(LOG_TAG, "Processing \"" + executionCommand.getCommandIdAndLabelLogString() + "\" AppShell result");
 
-        if (termuxTask != null && termuxTask.mTermuxTaskClient != null) {
+        if (appShell != null && appShell.mAppShellClient != null) {
-            termuxTask.mTermuxTaskClient.onTermuxTaskExited(termuxTask);
+            appShell.mAppShellClient.onAppShellExited(appShell);
         } else {
             // If a callback is not set and execution command didn't fail, then we set success state now
-            // Otherwise, the callback host can set it himself when its done with the termuxTask
+            // Otherwise, the callback host can set it himself when its done with the appShell
             if (!executionCommand.isStateFailed())
                 executionCommand.setState(ExecutionCommand.ExecutionState.SUCCESS);
         }
@@ -304,14 +304,14 @@ public final class TermuxTask {
 
 
 
-    public interface TermuxTaskClient {
+    public interface AppShellClient {
 
         /**
-         * Callback function for when {@link TermuxTask} exits.
+         * Callback function for when {@link AppShell} exits.
          *
-         * @param termuxTask The {@link TermuxTask} that exited.
+         * @param appShell The {@link AppShell} that exited.
          */
-        void onTermuxTaskExited(TermuxTask termuxTask);
+        void onAppShellExited(AppShell appShell);
 
     }
 

termux-shared/src/main/java/com/termux/shared/termux/TermuxUtils.java

@@ -14,6 +14,7 @@ import com.termux.shared.R;
 import com.termux.shared.android.AndroidUtils;
 import com.termux.shared.data.DataUtils;
 import com.termux.shared.file.FileUtils;
+import com.termux.shared.shell.command.runner.app.AppShell;
 import com.termux.shared.termux.file.TermuxFileUtils;
 import com.termux.shared.logger.Logger;
 import com.termux.shared.markdown.MarkdownUtils;
@@ -21,7 +22,6 @@ import com.termux.shared.shell.command.ExecutionCommand;
 import com.termux.shared.errors.Error;
 import com.termux.shared.android.PackageUtils;
 import com.termux.shared.termux.shell.TermuxShellEnvironmentClient;
-import com.termux.shared.shell.command.runner.app.TermuxTask;
 
 import org.apache.commons.io.IOUtils;
 
@@ -519,8 +519,8 @@ public class TermuxUtils {
         ExecutionCommand executionCommand = new ExecutionCommand(1, TermuxConstants.TERMUX_BIN_PREFIX_DIR_PATH + "/bash", null, aptInfoScript, null, true, false);
         executionCommand.commandLabel = "APT Info Command";
         executionCommand.backgroundCustomLogLevel = Logger.LOG_LEVEL_OFF;
-        TermuxTask termuxTask = TermuxTask.execute(context, executionCommand, null, new TermuxShellEnvironmentClient(), true);
+        AppShell appShell = AppShell.execute(context, executionCommand, null, new TermuxShellEnvironmentClient(), true);
-        if (termuxTask == null || !executionCommand.isSuccessful() || executionCommand.resultData.exitCode != 0) {
+        if (appShell == null || !executionCommand.isSuccessful() || executionCommand.resultData.exitCode != 0) {
             Logger.logErrorExtended(LOG_TAG, executionCommand.toString());
             return null;
         }
@@ -577,8 +577,8 @@ public class TermuxUtils {
         ExecutionCommand executionCommand = new ExecutionCommand(1, "/system/bin/sh", null, logcatScript + "\n", "/", true, true);
         executionCommand.commandLabel = "Logcat dump command";
         executionCommand.backgroundCustomLogLevel = Logger.LOG_LEVEL_OFF;
-        TermuxTask termuxTask = TermuxTask.execute(context, executionCommand, null, new TermuxShellEnvironmentClient(), true);
+        AppShell appShell = AppShell.execute(context, executionCommand, null, new TermuxShellEnvironmentClient(), true);
-        if (termuxTask == null || !executionCommand.isSuccessful()) {
+        if (appShell == null || !executionCommand.isSuccessful()) {
             Logger.logErrorExtended(LOG_TAG, executionCommand.toString());
             return null;
         }

termux-shared/src/main/java/com/termux/shared/termux/file/TermuxFileUtils.java

@@ -12,7 +12,7 @@ import com.termux.shared.shell.command.ExecutionCommand;
 import com.termux.shared.errors.Error;
 import com.termux.shared.file.FileUtilsErrno;
 import com.termux.shared.termux.shell.TermuxShellEnvironmentClient;
-import com.termux.shared.shell.command.runner.app.TermuxTask;
+import com.termux.shared.shell.command.runner.app.AppShell;
 import com.termux.shared.android.AndroidUtils;
 import com.termux.shared.termux.TermuxConstants;
 import com.termux.shared.termux.TermuxUtils;
@@ -345,8 +345,8 @@ public class TermuxFileUtils {
         ExecutionCommand executionCommand = new ExecutionCommand(1, "/system/bin/sh", null, statScript.toString() + "\n", "/", true, true);
         executionCommand.commandLabel = TermuxConstants.TERMUX_APP_NAME + " Files Stat Command";
         executionCommand.backgroundCustomLogLevel = Logger.LOG_LEVEL_OFF;
-        TermuxTask termuxTask = TermuxTask.execute(context, executionCommand, null, new TermuxShellEnvironmentClient(), true);
+        AppShell appShell = AppShell.execute(context, executionCommand, null, new TermuxShellEnvironmentClient(), true);
-        if (termuxTask == null || !executionCommand.isSuccessful()) {
+        if (appShell == null || !executionCommand.isSuccessful()) {
             Logger.logErrorExtended(LOG_TAG, executionCommand.toString());
             return null;
         }

termux-shared/src/main/res/values/strings.xml

@@ -60,13 +60,13 @@
 
 
 
-    <!-- ShellUtils -->
+    <!-- Shell -->
     <string name="error_sending_sigkill_to_process">Sending SIGKILL to process on user request or because android is killing the execution service</string>
     <string name="error_execution_cancelled">Execution has been cancelled since execution service is being killed</string>
     <string name="error_failed_to_execute_termux_session_command">"Failed to execute \"%1$s\" termux session command"</string>
-    <string name="error_failed_to_execute_termux_task_command">"Failed to execute \"%1$s\" termux task command"</string>
+    <string name="error_failed_to_execute_app_shell_command">"Failed to execute \"%1$s\" app shell command"</string>
     <string name="error_exception_received_while_executing_termux_session_command">Exception received while to executing \"%1$s\" termux session command.\nException: %2$s</string>
-    <string name="error_exception_received_while_executing_termux_task_command">Exception received while to executing \"%1$s\" termux task command.\nException: %2$s"</string>
+    <string name="error_exception_received_while_executing_app_shell_command">Exception received while to executing \"%1$s\" app shell command.\nException: %2$s"</string>