jremenv.java

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

/*
 * JRemCntl - Copyright (C) 2007 Filippo Di Vattimo <[e-mail]>
 * See COPYING
 */

package fildiv.jremcntl.server.core;

import java.io.File;
import java.net.URL;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import fildiv.jremcntl.common.core.JRemVersion;
import fildiv.jremcntl.common.core.Logger;
import fildiv.jremcntl.common.util.JRemUtils;
import fildiv.jremcntl.server.gui.app.JRemServerGUI;
import fildiv.jremcntl.server.utils.JRemServerUtils;

public class JRemEnv implements Environment {
	
	private final static String CONFIG_DIR = "config";
	private final static String LIB_DIR = "lib";
	private final static String EXT_DIR = LIB_DIR + File.separator + "ext";
	
	private final static String COPYING_FILE = "COPYING";
	
	private Settings settings;

	private String baseDirPath;
	private String confDirPath;
	private String extDirPath;
	
	private AppConfiguration conf;
	
	private Map svMap;

	private boolean logEnabled = true;
	private Logger logger;
	
	private ExtensionLoader loader;
	private AppExtensions exts;
	
	private JRemPropertyMapper pm;
	private HelpTool ht;
	
	private JRemServer server;

	private final URL imageURL = 
		JRemServerGUI.class.getResource("/fildiv/jremcntl/server/res/JRemoteControlGUI.gif");
	private final URL smallImageURL = 
		JRemServerGUI.class.getResource("/fildiv/jremcntl/server/res/jrc_small.gif");

	private final URL serverRunningImageURL = 
		JRemServerGUI.class.getResource("/fildiv/jremcntl/server/res/jrc_run.gif");
	private final URL serverStoppedImageURL = 
		JRemServerGUI.class.getResource("/fildiv/jremcntl/server/res/jrc_stop.gif");
	private final URL clientConnectedImageURL = 
		JRemServerGUI.class.getResource("/fildiv/jremcntl/server/res/jrc_connected.gif");
	
	private static JRemEnv singleton = null;
	
	public static JRemEnv createEnvironment(Settings settings, Logger logger, boolean logEnabled) {
		
		if (singleton != null)
			throw new IllegalStateException();
		
		singleton = new JRemEnv(settings, logger, logEnabled);
		singleton.afterCreate();
		
		return singleton;
	}

	public static JRemEnv createEnvironment(String filePropPath, Logger logger, boolean logEnabled) {
		
		if (singleton != null)
			throw new IllegalStateException();
		
		singleton = new JRemEnv(filePropPath, logger, logEnabled);
		singleton.afterCreate();
		
		return singleton;
	}

	public static JRemEnv getInstance() {

		if (singleton == null)
			throw new IllegalStateException("Environment not created");
		
		return singleton;
	}
	
	protected JRemEnv(Settings settings, Logger logger, boolean logEnabled) {
		
		init(settings, logger, logEnabled);
	}
	
	protected JRemEnv(String filePropPath, Logger logger, boolean logEnabled) {
		
		FilePropEnvSettings p = new FilePropEnvSettings(filePropPath,
				getApplicationName() + 
				" Configuration file");
		init(p, logger, logEnabled);
		
	}
	
	private void init(Settings settings, Logger logger, boolean logEnabled) {
		
		conf = new AppConfiguration(settings);
		
		this.logger = logger;
		this.logEnabled = logEnabled;

		baseDirPath = settings.getStringValue("jrem.home");
		if (JRemUtils.isEmptyString(baseDirPath))
			baseDirPath = System.getProperty("JREMHOME");
		
		if (JRemUtils.isEmptyString(baseDirPath))
			throw new IllegalArgumentException(
					"Invalid configuration, home path is missing.");
				
		confDirPath = JRemServerUtils.stripPathSeparator(baseDirPath) 
			+ File.separator + CONFIG_DIR;
		extDirPath = JRemServerUtils.stripPathSeparator(baseDirPath) 
			+ File.separator + EXT_DIR;
		
		this.settings = settings;
		
		pm = JRemConfigProperties.createPropertiesMapper();		
		registerSV();		
		
		ht = new HelpTool(this);		
	}
	
	protected void afterCreate() {
		
		server = new JRemServer();
		
		exts = new AppExtensions();
		initLoader();
	}

	private void initLoader() {

		loader = new ExtensionLoader();
		
		// Setup repositories
		
		List extsList = exts.asList();
		
		for (int index = 0; index < extsList.size(); ++index) {
			
			AppExtension appExt = (AppExtension) extsList.get(index);
			loader.addRepository(appExt.getRepositoryPath());
		}
	}

	private void registerSV() {
		svMap = new HashMap();

		svMap.put(JRemSysVarNames.SV_JREM_HOME, 
				new JRemSystemVariable(JRemSysVarNames.SV_JREM_HOME, baseDirPath));

		svMap.put(JRemSysVarNames.SV_JAVA_HOME, 
				new JRemSystemVariable(JRemSysVarNames.SV_JAVA_HOME, 
						System.getProperties().getProperty("java.home") ));
		
	}

	public String getBaseDirPath() {
		return baseDirPath;
	}

	public String getConfigDirPath() {
		return confDirPath;		
	}
	
	public String getExtDirPath() {
		return extDirPath;
	}

	public String getCoopyingFilePath() {
		return baseDirPath + File.separatorChar + COPYING_FILE;
	}
	
	public String getApplicationName() {
		return "JRemote Control GUI " + JRemVersion.VERSION;
	}
	
	public void savePreferences() {
		settings.store();
	}
	
	public JRemSystemVariable getSystemVariable(String name) {
		return (JRemSystemVariable) svMap.get(name);
	}
	
	public void setSystemVariableValue(String name, String value) {
		
		JRemSystemVariable sv = getSystemVariable(name);
		if (sv == null) {
			sv = new JRemSystemVariable(name, value);
			svMap.put(name, sv);
			
		} else {
			sv.setValue(value);
		}
	}
	
	public Map getSystemVariables() {
		return svMap; 
	}

	public String expand(String expr) {

		Collection svc = svMap.values();
		
		for (Iterator i = svc.iterator(); i.hasNext(); ) {
			
			JRemSystemVariable sv = (JRemSystemVariable) i.next();
			expr = JRemServerUtils.expand(expr, sv.getName(), sv.getValue());
		}
		
		return expr;
	}

	public Logger getLogger() {
		return logger;
	}

	public boolean isLogEnabled() {
		return logEnabled;
	}
	
	public ExtensionLoader getExtensionLoader() {
		return loader;
	}
	
	public AppConfiguration getAppConfiguration() {
		return conf;
	}

	public AppExtensions getAppExtensions() {
		return exts;
	}

	public JRemPropertyMapper getPropertiesMapper() {
		return pm;
	}
	
	public HelpTool getHelpTool() {
		return ht;
	}
	
	public JRemServer getServer() {
		return server;
	}
	
	public URL getAppImageURL() {
		return imageURL;
	}
	
	public URL getAppSmallImageURL() {
		return smallImageURL;
	}
	
	public URL getAppServerRunningImageURL() {
		return serverRunningImageURL;
	}
	
	public URL getAppServerStoppedImageURL() {
		return serverStoppedImageURL;
	}
	
	public URL getAppClientConnectedImageURL() {
		return clientConnectedImageURL;
	}

	protected void finalize() throws Throwable {
		server.dispose();
		super.finalize();
	}
}