.

Author: RohitKushvaha01

core/main/build.gradle.kts

@@ -103,14 +103,15 @@ dependencies {
     api(libs.ui.graphics)
     api(libs.material3)
     api(libs.navigation.compose)
-    api(libs.terminal.view)
-    api(libs.terminal.emulator)
+    api(project(":core:terminal-view"))
+    api(project(":core:terminal-emulator"))
     api(libs.utilcode)
     //api(libs.commons.net)
     api(libs.okhttp)
     api(libs.anrwatchdog)
     api(libs.androidx.palette)
     api(libs.accompanist.systemuicontroller)
+//    api(libs.termux.shared)
 
     api(project(":core:resources"))
     api(project(":core:components"))

core/main/src/main/java/com/rk/terminal/service/RunCommandService.kt

@@ -0,0 +1,11 @@
+package com.rk.terminal.service
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+
+class RunCommandService : Service() {
+    override fun onBind(intent: Intent?): IBinder? {
+        TODO("Not yet implemented")
+    }
+}

core/main/src/main/java/com/rk/terminal/ui/activities/terminal/MainActivity.kt

@@ -1,5 +1,7 @@
 package com.rk.terminal.ui.activities.terminal
 
+import android.app.Activity
+import android.app.PendingIntent
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
@@ -81,5 +83,9 @@ class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+
+        if (intent.hasExtra("awake_intent")){
+            moveTaskToBack(true)
+        }
     }
 }

core/main/src/main/java/com/rk/terminal/ui/screens/terminal/TerminalBackEnd.kt

@@ -44,13 +44,19 @@ class TerminalBackEnd(val terminal: TerminalView,val activity: MainActivity) : T
         ClipboardUtils.copyText("Terminal", text)
     }
 
-    override fun onPasteTextFromClipboard(session: TerminalSession) {
+    override fun onPasteTextFromClipboard(session: TerminalSession?) {
         val clip = ClipboardUtils.getText().toString()
         if (clip.trim { it <= ' ' }.isNotEmpty() && terminal.mEmulator != null) {
             terminal.mEmulator.paste(clip)
         }
     }
-    
+
+    override fun setTerminalShellPid(
+        session: TerminalSession,
+        pid: Int
+    ) {}
+
+
     override fun onBell(session: TerminalSession) {
         if (Settings.bell){
             activity.lifecycleScope.launch{

core/terminal-emulator/build.gradle

@@ -0,0 +1,59 @@
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+
+android {
+    compileSdkVersion 35
+    ndkVersion = "27.2.12479018"
+    namespace = "com.termux.terminal"
+
+    defaultConfig {
+	minSdkVersion 26
+        externalNativeBuild {
+            ndkBuild {
+                cFlags "-std=c11", "-Wall", "-Wextra", "-Werror", "-Os", "-fno-stack-protector", "-Wl,--gc-sections"
+            }
+        }
+
+        ndk {
+            abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    externalNativeBuild {
+        ndkBuild {
+            path "src/main/jni/Android.mk"
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    testOptions {
+        unitTests.returnDefaultValues = true
+    }
+}
+
+tasks.withType(Test) {
+    testLogging {
+        events "started", "passed", "skipped", "failed"
+    }
+}
+
+dependencies {
+    implementation "androidx.annotation:annotation:1.3.0"
+    testImplementation "junit:junit:4.13.2"
+}
+
+task sourceJar(type: Jar) {
+    from android.sourceSets.main.java.srcDirs
+    archiveClassifier.set("sources")
+}

core/terminal-emulator/proguard-rules.pro

@@ -0,0 +1,25 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /Users/fornwall/lib/android-sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

core/terminal-emulator/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

core/terminal-emulator/src/main/java/com/termux/terminal/ByteQueue.java

@@ -0,0 +1,108 @@
+package com.termux.terminal;
+
+/** A circular byte buffer allowing one producer and one consumer thread. */
+final class ByteQueue {
+
+    private final byte[] mBuffer;
+    private int mHead;
+    private int mStoredBytes;
+    private boolean mOpen = true;
+
+    public ByteQueue(int size) {
+        mBuffer = new byte[size];
+    }
+
+    public synchronized void close() {
+        mOpen = false;
+        notify();
+    }
+
+    public synchronized int read(byte[] buffer, boolean block) {
+        while (mStoredBytes == 0 && mOpen) {
+            if (block) {
+                try {
+                    wait();
+                } catch (InterruptedException e) {
+                    // Ignore.
+                }
+            } else {
+                return 0;
+            }
+        }
+        if (!mOpen) return -1;
+
+        int totalRead = 0;
+        int bufferLength = mBuffer.length;
+        boolean wasFull = bufferLength == mStoredBytes;
+        int length = buffer.length;
+        int offset = 0;
+        while (length > 0 && mStoredBytes > 0) {
+            int oneRun = Math.min(bufferLength - mHead, mStoredBytes);
+            int bytesToCopy = Math.min(length, oneRun);
+            System.arraycopy(mBuffer, mHead, buffer, offset, bytesToCopy);
+            mHead += bytesToCopy;
+            if (mHead >= bufferLength) mHead = 0;
+            mStoredBytes -= bytesToCopy;
+            length -= bytesToCopy;
+            offset += bytesToCopy;
+            totalRead += bytesToCopy;
+        }
+        if (wasFull) notify();
+        return totalRead;
+    }
+
+    /**
+     * Attempt to write the specified portion of the provided buffer to the queue.
+     * <p/>
+     * Returns whether the output was totally written, false if it was closed before.
+     */
+    public boolean write(byte[] buffer, int offset, int lengthToWrite) {
+        if (lengthToWrite + offset > buffer.length) {
+            throw new IllegalArgumentException("length + offset > buffer.length");
+        } else if (lengthToWrite <= 0) {
+            throw new IllegalArgumentException("length <= 0");
+        }
+
+        final int bufferLength = mBuffer.length;
+
+        synchronized (this) {
+            while (lengthToWrite > 0) {
+                while (bufferLength == mStoredBytes && mOpen) {
+                    try {
+                        wait();
+                    } catch (InterruptedException e) {
+                        // Ignore.
+                    }
+                }
+                if (!mOpen) return false;
+                final boolean wasEmpty = mStoredBytes == 0;
+                int bytesToWriteBeforeWaiting = Math.min(lengthToWrite, bufferLength - mStoredBytes);
+                lengthToWrite -= bytesToWriteBeforeWaiting;
+
+                while (bytesToWriteBeforeWaiting > 0) {
+                    int tail = mHead + mStoredBytes;
+                    int oneRun;
+                    if (tail >= bufferLength) {
+                        // Buffer: [.............]
+                        // ________________H_______T
+                        // =>
+                        // Buffer: [.............]
+                        // ___________T____H
+                        // onRun= _____----_
+                        tail = tail - bufferLength;
+                        oneRun = mHead - tail;
+                    } else {
+                        oneRun = bufferLength - tail;
+                    }
+                    int bytesToCopy = Math.min(oneRun, bytesToWriteBeforeWaiting);
+                    System.arraycopy(buffer, offset, mBuffer, tail, bytesToCopy);
+                    offset += bytesToCopy;
+                    bytesToWriteBeforeWaiting -= bytesToCopy;
+                    mStoredBytes += bytesToCopy;
+                }
+                if (wasEmpty) notify();
+            }
+        }
+        return true;
+    }
+}

core/terminal-emulator/src/main/java/com/termux/terminal/JNI.java

@@ -0,0 +1,41 @@
+package com.termux.terminal;
+
+/**
+ * Native methods for creating and managing pseudoterminal subprocesses. C code is in jni/termux.c.
+ */
+final class JNI {
+
+    static {
+        System.loadLibrary("termux");
+    }
+
+    /**
+     * Create a subprocess. Differs from {@link ProcessBuilder} in that a pseudoterminal is used to communicate with the
+     * subprocess.
+     * <p/>
+     * Callers are responsible for calling {@link #close(int)} on the returned file descriptor.
+     *
+     * @param cmd       The command to execute
+     * @param cwd       The current working directory for the executed command
+     * @param args      An array of arguments to the command
+     * @param envVars   An array of strings of the form "VAR=value" to be added to the environment of the process
+     * @param processId A one-element array to which the process ID of the started process will be written.
+     * @return the file descriptor resulting from opening /dev/ptmx master device. The sub process will have opened the
+     * slave device counterpart (/dev/pts/$N) and have it as stdint, stdout and stderr.
+     */
+    public static native int createSubprocess(String cmd, String cwd, String[] args, String[] envVars, int[] processId, int rows, int columns, int cellWidth, int cellHeight);
+
+    /** Set the window size for a given pty, which allows connected programs to learn how large their screen is. */
+    public static native void setPtyWindowSize(int fd, int rows, int cols, int cellWidth, int cellHeight);
+
+    /**
+     * Causes the calling thread to wait for the process associated with the receiver to finish executing.
+     *
+     * @return if >= 0, the exit status of the process. If < 0, the signal causing the process to stop negated.
+     */
+    public static native int waitFor(int processId);
+
+    /** Close a file descriptor through the close(2) system call. */
+    public static native void close(int fileDescriptor);
+
+}