package lee.gaismamedia;
 
import java.io.*;
/**
 * Created with IntelliJ IDEA.
 * User: lee ( lee@konglie.web.id )
 * Date: 7/10/14
 * Time: 12:56 PM
 */
public class JPinger {
        // external command which to be executed
    private final String PING_CMD;
 
    private Process pinger;
    private JPingerListener listener;
    private Boolean isPinging;
    public JPinger(JPingerListener l){
        String OS = System.getProperty("os.name");
        System.out.println(OS);
        if(OS.toLowerCase().indexOf("win") >= 0){
            // -t for ping until stopped
            // -a for resolve ip to hostname
            PING_CMD = "ping -t -a";
        } else {
            // on linux, this is the default behaviour
            PING_CMD = "ping";
        }
 
        this.listener = l;
        this.isPinging = false;
    }
 
    private Thread processReader;
 
    public void ping(String target){
        // only take the first-before-space destination
        // this actually affect nothing, as we are passing everything to PING
        String pingCommand = String.format("%s %s",
                PING_CMD, target.trim().split(" ")[0]);
 
        stopPing();
        try{
            listener.PingOutput("Execute: " + pingCommand + "\n");
 
            // create the Process instance
            pinger = Runtime.getRuntime().exec(pingCommand);
 
            // to make it easier,
            // we will pipe the InputStream and Error Stream to one single channel
            // so we will only focus accepting whatever the process are printing out
            PipedInputStream in = new PipedInputStream(1024 * 1024);
            PipedOutputStream out = new PipedOutputStream(in);
            final BufferedReader io = new BufferedReader(new InputStreamReader(in));
 
            // pipe the inputStream
            new StreamReader(pinger.getInputStream(), out).start();
 
            // pipe the errorStrem
            new StreamReader(pinger.getErrorStream(), out).start();
 
            // what about the OutputStream ??
            // well, in this case, PING does not accept any input from us once it is running
            // so, we don't care about the OutputStream
 
            // read and pass the output, line by line, to our listener
            processReader = new Thread(new Runnable(){
                @Override
                public void run() {
                    String line;
                    try{
                        while( (line = io.readLine()) != null && !Thread.interrupted()){
                            listener.PingOutput(line);
                        }
                    } catch (Exception e){
 
                    }
                }
            });
            processReader.start();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
 
    public void stopPing(){
        try {
            // destroy everything
            pinger.destroy();
            processReader.interrupt();
        } catch (Exception e){
            return;
        }
    }
}
 
class StreamReader extends Thread {
    private InputStream in;
    private OutputStream out;
 
    public StreamReader(InputStream in, OutputStream out) {
        this.in = in;
        this.out = out;
    }
 
    public void run()
    {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            PrintStream printStream = new PrintStream(out);
            String line;
 
            // get line from the stream, and write it to the destination pipe.
            while ( (line = reader.readLine()) != null) {
                printStream.println(line);
            }
 
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
 
}

package lee.gaismamedia;
 
/**
 * Created with IntelliJ IDEA.
 * User: lee ( lee@konglie.web.id )
 * Date: 7/10/14
 * Time: 1:02 PM
 */
public interface JPingerListener {
    public void PingOutput(String line);
}