jremconfigreader.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.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import fildiv.jremcntl.common.core.Command;
import fildiv.jremcntl.common.core.Config;
import fildiv.jremcntl.common.core.Context;
import fildiv.jremcntl.common.core.Extension;
import fildiv.jremcntl.common.core.JRemCommandData;
import fildiv.jremcntl.common.core.JRemConfigData;
import fildiv.jremcntl.common.core.JRemContextData;
import fildiv.jremcntl.common.core.JRemExtensionData;
import fildiv.jremcntl.common.core.JRemRuntimeException;
import fildiv.jremcntl.common.core.Logger;
import fildiv.jremcntl.common.core.SupportExtension;
import fildiv.jremcntl.common.util.JRemUtils;
import fildiv.jremcntl.server.core.JRemPropertyMapper.JRemPropertyValueMapper;


public class JRemConfigReader {
	
	private JRemEnv env;
	private String filePath;
	private Config config;
	private JRemPropertyInvoker invoker;
	private JRemPropertyMapper pm;
	private ExtensionLoader loader;
	private Logger logger;
	
	public JRemConfigReader(String filePath) {
		
		env = JRemEnv.getInstance();
		this.filePath = filePath;
		this.logger = JRemEnv.getInstance().getLogger();
		
		invoker = new JRemPropertyInvoker();
		pm = env.getPropertiesMapper();
		loader = JRemEnv.getInstance().getExtensionLoader();
		
		readConfig(filePath);
	}

	public String getFilePath() {
		return filePath;
	}
	
	public Config getConfig() {
		return config;
	}
	
	private void readConfig(String filePath) {

		this.filePath = filePath;
		
		DocumentBuilderFactory factory =
	            DocumentBuilderFactory.newInstance();
		
		factory.setValidating(false);
//        factory.setNamespaceAware(false);
//        factory.setIgnoringComments(true);
        
		File confFile = null;
		Document document = null;
		
		try {
		 	
		 	confFile = new File(filePath);
		 	
			DocumentBuilder builder = factory.newDocumentBuilder();
			document = builder.parse(confFile);
			readConfig(document);
			
		} catch (SAXException sxe) {

	          Exception x = sxe;
	          if (sxe.getException() != null)
	              x = sxe.getException();
	          
	          throw new JRemRuntimeException(x);
	          
		} catch (ParserConfigurationException pce) {
			throw new JRemRuntimeException(pce);
		} catch (IOException ioe) {
			throw new JRemRuntimeException(ioe);
        } finally {
        	

        }
	}

	private void readConfig(Document document) {
		
		Element root = document.getDocumentElement();
		config = new JRemConfigData();
		
		setupProperties(JRemConfigProperties.OBJ_CONFIG_NAME, 
				config, root, false);
		
		Extension ext = readExtension(null, root);
		if (ext == null) 
			ext = createRootExtension();

		config.setExtension(ext);

		NodeList list = root.getChildNodes();
		
		for (int index = 0; index < list.getLength(); ++index) {
			
			Node node = list.item(index);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				Element elem = (Element) node;
				
				if (elem.getTagName().equals("contexts")) {
					readContexts(elem);
				} 
			}
		}
	}

	private Extension createRootExtension() {
		
		JRemEnv env = JRemEnv.getInstance();
		
		AppExtension appExt = env.getAppExtensions().getDefault();
		JRemExtension ext = env.getExtensionLoader().getExtension(
				appExt.getClassName());
		
		JRemExtensionData ed = new JRemExtensionData(null);
		
		ed.setID(appExt.getID());
		ed.setShortName(appExt.getShortName());
		ed.setClassName(appExt.getClassName());
		ed.setImplObj(ext);
		
		return ed;
	}

	private void readContexts(Element elemContexts) {

		NodeList list = elemContexts.getChildNodes();

		for (int index = 0; index < list.getLength(); ++index) {
			
			Node node = list.item(index);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				Element elem = (Element) node;

				if (elem.getTagName().equals("context")) {
					
					Context context = new JRemContextData(config);
					config.appendContext(context);
					
					setupProperties(JRemConfigProperties.OBJ_CONTEXT_NAME, 
							context, elem, false);
					
					Extension ext = readExtension(context, elem);
					if (ext != null)
						context.setExtension(ext);
					
					readCommands(context, elem);
				}
			}
		}		
	}

	private void readCommands(Context context, Element elemContext) {
	
		NodeList list = elemContext.getChildNodes();
		
		for (int index = 0; index < list.getLength(); ++index) {
			
			Node node = list.item(index);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				Element elem = (Element) node;
				
				if (elem.getTagName().equals("command")) {
										
					Command command = new JRemCommandData(context);
					context.appendCommand(command);
					
					setupProperties(JRemConfigProperties.OBJ_COMMAND_NAME,
							command, elem, false);
					
					Extension ext = readExtension(command, elem);
					if (ext != null)
						command.setExtension(ext);

				}
			}
		}
	}

	private Extension readExtension(SupportExtension parent, Element elemRoot) {

		NodeList list = elemRoot.getChildNodes();

		for (int index = 0; index < list.getLength(); ++index) {
			
			Node node = list.item(index);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				Element elem = (Element) node;
			
				if (elem.getTagName().equals("extension")) {
	
					JRemExtensionData extData = new JRemExtensionData(parent);
					setupProperties(JRemConfigProperties.OBJ_EXTENSION_NAME, 
							extData, elem, true);
					
					String extClassName = extData.getClassName();
					if (JRemUtils.isEmptyString(extClassName))
						return null;
					
					JRemExtension ext = loader.getExtension(extClassName);
					if (ext == null) {
						logger.error("Extension with class " + 
								extClassName + " not found!");
						return null;
					}
					
					String id = ext.getID();
			
					extData.setID(id);
					extData.setImplObj(ext);
					
					setupProperties(id, ext.getDocument(), elem, true);
	
					return extData;
				}
			}

		}
		
		return null;
	}

	private void setupProperties(String objName, Object object, Element elem, 
			boolean ignoreWarnings) {

		NamedNodeMap map = elem.getAttributes();
		
		for (int index = 0; index < map.getLength(); ++index) {
			Node node = map.item(index);
			
			if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
				
				String propertyName = node.getNodeName();
				String propertyValue = node.getNodeValue();
				invokeSet(objName, object, 
						propertyName, propertyValue, ignoreWarnings);
			}
		}
		
	}

	private void invokeSet(String objName, Object object, String xmlPropertyName, String propertyValue, 
			boolean ignoreWarnings) {

		try {
			
			JRemProperty p = pm.findProperty(objName, 
					xmlPropertyName, JRemPropertyMapper.FIND_TYPE_XMLNAME);
			if (p == null) {
			
				if (!ignoreWarnings)
					logger.warning(
							"The property " + xmlPropertyName + 
							" was not defined!");

				return;
			}
			
			JRemPropertyValueMapper pvm = p.getPropertyValueMapper();
			
			invoker.invokeSet(p.getClsPropName(), object, 
					pvm.toCls(propertyValue));
			
		} catch(Exception e) {
			logger.error(e);
			
			// continue processing
		}
	}

}