systemruntime.java

JRemoteControl is a simple Java&#8482 driven bluetooth remote control.It allows you to initiate virt

/*
 * Copyright (C) 2007 Filippo Di Vattimo - See LICENSE
 *
 */

package fildiv.jremcntl.server.core;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

import fildiv.jremcntl.common.core.JRemRuntimeException;
import fildiv.jremcntl.server.utils.SystemRuntimeProcessor;

public class SystemRuntime {
	
	protected static abstract class AbstractPipeInputStreamToOutputStream implements Runnable {
		
		private final InputStream is;
		protected SystemRuntimeProcessor processor;

		AbstractPipeInputStreamToOutputStream(InputStream is, SystemRuntimeProcessor processor) {
			this.is = is;
			this.processor = processor;
		}

		AbstractPipeInputStreamToOutputStream(InputStream is) {
			this(is, null);
		}

		public void run() {
			
			InputStreamReader converter = null;
			
			try {

				converter = new InputStreamReader(is, Charset.forName("UTF-8"));
				BufferedReader in = new BufferedReader(converter);

				for (String line = null; (line = in.readLine()) != null; ) {
					
					if (processor != null) {
						processData(line + "\n");
					}
				}
				
			} catch (IOException e) {
				throw new JRemRuntimeException(e);
				
			} finally {
				if (converter != null)
					try {
						converter.close();
					} catch (IOException e) {
						// Ignored
					}
			}
		}

		protected abstract void processData(String data);
	}
	
	protected static class StdOutProcessor extends AbstractPipeInputStreamToOutputStream {

		StdOutProcessor(InputStream is, SystemRuntimeProcessor processor) {
			super(is, processor);
		}

		protected void processData(String data) {
			processor.processStdOutput(data);
		}
		
	}

	protected static class StdErrProcessor extends AbstractPipeInputStreamToOutputStream {

		StdErrProcessor(InputStream is, SystemRuntimeProcessor processor) {
			super(is, processor);
		}

		protected void processData(String data) {
			processor.processStdError(data);
		}
		
	}

	public static synchronized void run(String execPath, String[] envs,
			SystemRuntimeProcessor listener) {

		if (listener == null)
			throw new IllegalArgumentException();

		asyncExec(execPath, envs, listener);
	}

	private static void asyncExec(final String execPath,
			final String[] envs, final SystemRuntimeProcessor listener) {

		Thread pThread = new Thread() {
			public void run() {

				execProcess(execPath, envs, listener);
			}
		};

		pThread.start();
	}

	protected static void execProcess(final String execPath,
			String[] envs, final SystemRuntimeProcessor processor) {
		
		int exitCode = -1;
		
		try {
			final Process p = Runtime.getRuntime().exec(execPath, envs);

			new Thread(new StdOutProcessor(p.getInputStream(),
					processor)).start();

			new Thread(new StdErrProcessor(p.getErrorStream(),
					processor)).start();
			
			exitCode = p.waitFor();

		} catch (Exception e) {
		
			processor.processErrorOccurred(e);
		} finally {
			
			processor.processTerminated(execPath, exitCode);
		}
	}

}