Command line terminal executing on process and input interaction from this process [duplicate]

I hope it answers your question... subProcessStuff "emulates" that sub process. It can be anything - but this way we have all in place. It requires 2 params passed into console. String and Integer. Gobbler got Callback which is an interface, with anonymous implementation - and there are checks for params. To answer if subprocess waits we simply track what is says - just like if a user would operate with it.

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Scanner;

class Test1 {
    public static void main(String[] args) {
        for (String arg : args)
            System.out.println("arg: " + arg);

        for (String arg : args)
            if (arg.equals("-test")) {
                subProcessStuff();
                return;
            }
        mainProcess();

    }

    public static void subProcessStuff() {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            System.out.println("Enter String");
            String s = br.readLine();
            System.out.println("Enered String: " + s);
            System.out.println("Enter Integer:");
            int i = Integer.parseInt(br.readLine());
            System.out.println("Entered Integer: " + i);
        } catch (IOException e) {
            System.err.println("io error - " + e.getMessage());
        } catch (NumberFormatException nfe) {
            System.err.println("Invalid Format!");
        }
    }

    private static PrintStream out;

    public static void mainProcess() {
        String[] commands = { "ls", "-alt" };
        ProcessBuilder builder = new ProcessBuilder("java", "Test1", "-test");

        // builder.inheritIO(); // I avoid this. It was messing me up.

        try {
            Process proc = builder.start();
            InputStream errStream = proc.getErrorStream();
            InputStream inStream = proc.getInputStream();
            OutputStream outStream = proc.getOutputStream();

            new Thread(new StreamGobbler("err", out, errStream)).start();

            out = new PrintStream(new BufferedOutputStream(outStream));

            Callback cb = new Callback() {
                @Override
                public void onNextLine(String line) {
                    if (line.equals("Enter String")) {
                        out.println("aaaaa");
                        out.flush();
                    }
                    if (line.equals("Enter Integer:")) {
                        out.println("123");
                        out.flush();                    
                    }
                }
            };
            new Thread(new StreamGobbler("in", out, inStream, cb)).start();
            int errorCode = proc.waitFor();
            System.out.println("error code: " + errorCode);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }
}

interface Callback {
    void onNextLine(String line);
}

class StreamGobbler implements Runnable {
    private PrintStream out;
    private Scanner inScanner;
    private String name;
    private Callback cb;

    public StreamGobbler(String name, PrintStream out, InputStream inStream) {
        this.name = name;
        this.out = out;
        inScanner = new Scanner(new BufferedInputStream(inStream));
    }

    public StreamGobbler(String name, PrintStream out, InputStream inStream, Callback cb) {
        this.name = name;
        this.out = out;
        inScanner = new Scanner(new BufferedInputStream(inStream));
        this.cb = cb;
    }

    @Override
    public void run() {
        while (inScanner.hasNextLine()) {
            String line = inScanner.nextLine();
            if (cb != null)
                cb.onNextLine(line);
            System.out.printf("%s: %s%n", name, line);
        }
    }
}

I don't think you can check the state of the process from the Java. However you can do it by using some Linux command. (Of course if you're using Linux)

If your Java process has access to the /proc directory then you can read the status file for the process.

For example for a process with process id 12280

/proc/12280/status

Here's the relevant output of the status file

Name:   java
State:  S (sleeping)
Tgid:   12280
Pid:    12280
PPid:   12279
...

Second line gives the state of the process. You'll need to run a thread to continuously poll this file to read the status.

Line by Line The Code i use to interract with a different jar which is a speechRecognizer.I think you want to achieve something like this.

Example:

The jar i am interracting(speechRecognizer) is executing different commands and run some other Threads.Every time it has to interract with the main jar it prints something that i need.For example (user said:How are you),so you can have a same logic and when external jar need interraction with user it prints something and you read it into the main app.So:

// About Process
private Process process;
private BufferedReader bufferedReader;
private boolean stopped = true;
Thread processChecker;

//Running it in a Thread so the app don't lags
new Thread(() -> {
        try {
            stopped = false;
            //Starting the external jar..
            ProcessBuilder builder = new ProcessBuilder("java", "-jar", System.getProperty("user.home")
                    + File.separator + "Desktop" + File.separator + "speechRecognizer.jar", "BITCH_PLEASE");
            //Redirecting the ErrorStream
            builder.redirectErrorStream(true);
            process = builder.start();
            bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;



            //Check continusly if the process is still alive
            //i case of crash i should do something..
            processChecker = new Thread(() -> {
                while (process.isAlive()) {
                    try {
                        Thread.sleep(1200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                stopSpeechReader(false);
            });
            processChecker.start();

            // Continuesly Read Output of external process
            while (!stopped) {
                while ((line = bufferedReader.readLine()) != null && !line.isEmpty()) {
                    System.out.println(line);
                    checkSpeechResult(line);
                }
            }

            // Interrupt the mf Thread if is Alive
            if (processChecker.isAlive())
                processChecker.interrupt();
            System.out.println("SpeechReader Stopped! Process is alive:" + process.isAlive() + " >Exit Value:"
                    + process.exitValue());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();