Started renewed VoiceXMLInvoker

2 files changed, 935 insertions, 0 deletions

diff --git a/src/uscxml/messages/MMIMessages.cpp b/src/uscxml/messages/MMIMessages.cpp
new file mode 100644
index 0000000..1c5b98a
--- /dev/null
+++ b/src/uscxml/messages/MMIMessages.cpp
@@ -0,0 +1,436 @@
+/**
+ *  @file
+ *  @author     2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
+ *  @copyright  Simplified BSD
+ *
+ *  @cond
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the FreeBSD license as published by the FreeBSD
+ *  project.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *  You should have received a copy of the FreeBSD license along with this
+ *  program. If not, see <http://www.opensource.org/licenses/bsd-license>.
+ *  @endcond
+ */
+
+#include "MMIMessages.h"
+
+#include <DOM/Simple/DOMImplementation.hpp>
+#include <DOM/io/Stream.hpp>
+#include <DOM/SAX2DOM/SAX2DOM.hpp>
+#include <SAX/helpers/InputSourceResolver.hpp>
+
+#include <uscxml/DOMUtils.h>
+
+#include <boost/algorithm/string.hpp>
+
+#define STRING_ATTR_OR_EXPR(element, name)\
+(element.hasAttributeNS(nameSpace, "name##Expr") && interpreter ? \
+	interpreter->getDataModel().evalAsString(element.getAttributeNS(nameSpace, "name##Expr")) : \
+	(element.hasAttributeNS(nameSpace, #name) ? element.getAttributeNS(nameSpace, #name) : "") \
+)
+
+#define FIND_EVENT_NODE(node)\
+while (node) {\
+	if (node.getNodeType() == Node_base::ELEMENT_NODE) {\
+		if (boost::iequals(node.getLocalName(), "MMI")) {\
+			node = node.getFirstChild();\
+			continue;\
+		} else {\
+			break;\
+		}\
+	}\
+	node = node.getNextSibling();\
+}\
+
+
+namespace uscxml {
+
+using namespace Arabica::DOM;
+
+std::string MMIEvent::nameSpace = "http://www.w3.org/2008/04/mmi-arch";
+
+MMIEvent::Type MMIEvent::getType(Arabica::DOM::Node<std::string> node) {
+	if (!node || node.getNodeType() != Arabica::DOM::Node_base::ELEMENT_NODE)
+		return INVALID;
+
+	// MMI container?
+	if (boost::iequals(node.getLocalName(), "MMI")) {
+		node = node.getFirstChild();
+		if (!node)
+			return INVALID;
+		while(node.getNodeType() != Arabica::DOM::Node_base::ELEMENT_NODE) {
+			node = node.getNextSibling();
+			if (!node)
+				return INVALID;
+		}
+	}
+	
+	if (boost::iequals(node.getLocalName(), "NEWCONTEXTREQUEST"))
+		return NEWCONTEXTREQUEST;
+	if (boost::iequals(node.getLocalName(), "NEWCONTEXTRESPONSE"))
+		return NEWCONTEXTRESPONSE;
+	if (boost::iequals(node.getLocalName(), "PREPAREREQUEST"))
+		return PREPAREREQUEST;
+	if (boost::iequals(node.getLocalName(), "PREPARERESPONSE"))
+		return PREPARERESPONSE;
+	if (boost::iequals(node.getLocalName(), "STARTREQUEST"))
+		return STARTREQUEST;
+	if (boost::iequals(node.getLocalName(), "STARTRESPONSE"))
+		return STARTRESPONSE;
+	if (boost::iequals(node.getLocalName(), "DONENOTIFICATION"))
+		return DONENOTIFICATION;
+	if (boost::iequals(node.getLocalName(), "CANCELREQUEST"))
+		return CANCELREQUEST;
+	if (boost::iequals(node.getLocalName(), "CANCELRESPONSE"))
+		return CANCELRESPONSE;
+	if (boost::iequals(node.getLocalName(), "PAUSEREQUEST"))
+		return PAUSEREQUEST;
+	if (boost::iequals(node.getLocalName(), "PAUSERESPONSE"))
+		return PAUSERESPONSE;
+	if (boost::iequals(node.getLocalName(), "RESUMEREQUEST"))
+		return RESUMEREQUEST;
+	if (boost::iequals(node.getLocalName(), "RESUMERESPONSE"))
+		return RESUMERESPONSE;
+	if (boost::iequals(node.getLocalName(), "EXTENSIONNOTIFICATION"))
+		return EXTENSIONNOTIFICATION;
+	if (boost::iequals(node.getLocalName(), "CLEARCONTEXTREQUEST"))
+		return CLEARCONTEXTREQUEST;
+	if (boost::iequals(node.getLocalName(), "CLEARCONTEXTRESPONSE"))
+		return CLEARCONTEXTRESPONSE;
+	if (boost::iequals(node.getLocalName(), "STATUSREQUEST"))
+		return STATUSREQUEST;
+	if (boost::iequals(node.getLocalName(), "STATUSRESPONSE"))
+		return STATUSRESPONSE;
+	return INVALID;
+}
+
+Arabica::DOM::Document<std::string> MMIEvent::toXML(bool encapsulateInMMI) const {
+	Arabica::DOM::DOMImplementation<std::string> domFactory = Arabica::SimpleDOM::DOMImplementation<std::string>::getDOMImplementation();
+	Document<std::string> doc = domFactory.createDocument(nameSpace, "", 0);
+	Element<std::string> msgElem = doc.createElementNS(nameSpace, tagName);
+	msgElem.setAttributeNS(nameSpace, "Source", source);
+	msgElem.setAttributeNS(nameSpace, "Target", target);
+	msgElem.setAttributeNS(nameSpace, "RequestID", requestId);
+
+	if (data.size() > 0) {
+		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
+
+		// try to parse content
+		std::stringstream* ss = new std::stringstream();
+		(*ss) << data;
+		std::auto_ptr<std::istream> ssPtr(ss);
+		Arabica::SAX::InputSource<std::string> inputSource;
+		inputSource.setByteStream(ssPtr);
+
+		NameSpacingParser parser;
+		if(parser.parse(inputSource)) {
+			Node<std::string> importedNode = doc.importNode(parser.getDocument().getDocumentElement(), true);
+			dataElem.appendChild(importedNode);
+		} else {
+			Text<std::string> textElem = doc.createTextNode(data);
+			dataElem.appendChild(textElem);
+		}
+		msgElem.appendChild(dataElem);
+	}
+
+	if (encapsulateInMMI) {
+		Element<std::string> mmiElem = doc.createElementNS(nameSpace, "mmi");
+		mmiElem.appendChild(msgElem);
+		doc.appendChild(mmiElem);
+	} else {
+		doc.appendChild(msgElem);
+	}
+	return doc;
+}
+
+Arabica::DOM::Document<std::string> ContextualizedRequest::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = MMIEvent::toXML(encapsulateInMMI);
+	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	msgElem.setAttributeNS(nameSpace, "Context", context);
+	return doc;
+}
+
+Arabica::DOM::Document<std::string> ContentRequest::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
+	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+
+	if (contentURL.href.size() > 0) {
+		Element<std::string> contentURLElem = doc.createElementNS(nameSpace, "ContentURL");
+		contentURLElem.setAttributeNS(nameSpace, "href", contentURL.href);
+		contentURLElem.setAttributeNS(nameSpace, "fetchtimeout", contentURL.fetchTimeout);
+		contentURLElem.setAttributeNS(nameSpace, "max-age", contentURL.maxAge);
+		msgElem.appendChild(contentURLElem);
+	}
+
+	if (content.size() > 0) {
+		Element<std::string> contentElem = doc.createElementNS(nameSpace, "content");
+
+		// try to parse content
+		std::stringstream* ss = new std::stringstream();
+		(*ss) << content;
+		std::auto_ptr<std::istream> ssPtr(ss);
+		Arabica::SAX::InputSource<std::string> inputSource;
+		inputSource.setByteStream(ssPtr);
+
+		Arabica::SAX2DOM::Parser<std::string> parser;
+		if(parser.parse(inputSource)) {
+			Node<std::string> importedNode = doc.importNode(parser.getDocument().getDocumentElement(), true);
+			contentElem.appendChild(importedNode);
+		} else {
+			Text<std::string> textElem = doc.createTextNode(content);
+			contentElem.appendChild(textElem);
+		}
+		msgElem.appendChild(contentElem);
+
+	}
+	return doc;
+}
+
+Arabica::DOM::Document<std::string> ExtensionNotification::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
+	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	msgElem.setAttributeNS(nameSpace, "Name", name);
+	return doc;
+}
+
+Arabica::DOM::Document<std::string> StatusResponse::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
+	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	if (status == ALIVE) {
+		msgElem.setAttributeNS(nameSpace, "Status", "alive");
+	} else if(status == DEAD) {
+		msgElem.setAttributeNS(nameSpace, "Status", "dead");
+	} else if(status == FAILURE) {
+		msgElem.setAttributeNS(nameSpace, "Status", "failure");
+	} else if(status == SUCCESS) {
+		msgElem.setAttributeNS(nameSpace, "Status", "success");
+	}
+	return doc;
+}
+
+Arabica::DOM::Document<std::string> StatusInfoResponse::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = StatusResponse::toXML(encapsulateInMMI);
+	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+
+	Element<std::string> statusInfoElem = doc.createElementNS(nameSpace, "StatusInfo");
+	Text<std::string> statusInfoText = doc.createTextNode(statusInfo);
+	statusInfoElem.appendChild(statusInfoText);
+	msgElem.appendChild(statusInfoElem);
+
+	return doc;
+}
+
+Arabica::DOM::Document<std::string> StatusRequest::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
+	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+
+	if (automaticUpdate) {
+		msgElem.setAttributeNS(nameSpace, "RequestAutomaticUpdate", "true");
+	} else {
+		msgElem.setAttributeNS(nameSpace, "RequestAutomaticUpdate", "false");
+	}
+
+	return doc;
+}
+
+MMIEvent MMIEvent::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	MMIEvent msg;
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	msg.source = STRING_ATTR_OR_EXPR(msgElem, Source);
+	msg.target = STRING_ATTR_OR_EXPR(msgElem, Target);
+//	msg.data = STRING_ATTR_OR_EXPR(msgElem, Data);
+	msg.requestId = STRING_ATTR_OR_EXPR(msgElem, RequestID);
+	msg.tagName = msgElem.getLocalName();
+
+	Element<std::string> dataElem;
+	node = msgElem.getFirstChild();
+	while (node) {
+		if (node.getNodeType() == Node_base::ELEMENT_NODE)
+			dataElem = Element<std::string>(node);
+		if (dataElem && boost::iequals(dataElem.getLocalName(), "data"))
+			break;
+		node = node.getNextSibling();
+	}
+
+	if (dataElem && boost::iequals(dataElem.getLocalName(), "data")) {
+		std::stringstream ss;
+		node = dataElem.getFirstChild();
+		if (node)
+			ss << node;
+		msg.data = ss.str();
+	}
+
+	return msg;
+}
+
+MMIEvent::operator Event() const {
+	Event ev;
+	ev.setOriginType("mmi.event");
+	ev.setOrigin(source);
+	ev.setRaw(data);
+	ev.setSendId(requestId);
+	if (data.length() > 0) {
+		ev.initContent(data);
+	}
+	return ev;
+}
+
+ContextualizedRequest ContextualizedRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	ContextualizedRequest msg(MMIEvent::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	msg.context = STRING_ATTR_OR_EXPR(msgElem, Context);
+	return msg;
+}
+
+ContextualizedRequest::operator Event() const {
+	Event ev = MMIEvent::operator Event();
+	// do we want to represent the context? It's the interpreters name already
+	return ev;
+}
+
+
+ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	ContentRequest msg(ContextualizedRequest::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	Element<std::string> contentElem;
+
+	node = msgElem.getFirstChild();
+	while (node) {
+		if (node.getNodeType() == Node_base::ELEMENT_NODE) {
+			contentElem = Element<std::string>(node);
+			if (boost::iequals(contentElem.getLocalName(), "content") ||
+			        boost::iequals(contentElem.getLocalName(), "contentURL"))
+				break;
+		}
+		node = node.getNextSibling();
+	}
+
+	if (contentElem) {
+		if(boost::iequals(contentElem.getLocalName(), "content")) {
+			std::stringstream ss;
+			node = contentElem.getFirstChild();
+			while (node) {
+				if (node.getNodeType() == Node_base::ELEMENT_NODE) {
+					ss << node;
+					break;
+				}
+				node = node.getNextSibling();
+			}
+			msg.content = ss.str();
+		} else if(boost::iequals(contentElem.getLocalName(), "contentURL")) {
+			msg.contentURL.href = STRING_ATTR_OR_EXPR(contentElem, href);
+			msg.contentURL.maxAge = STRING_ATTR_OR_EXPR(contentElem, max-age);
+			msg.contentURL.fetchTimeout = STRING_ATTR_OR_EXPR(contentElem, fetchtimeout);
+		}
+	}
+
+	//msg.content = msgElem.getAttributeNS(nameSpace, "Context");
+	return msg;
+}
+
+ExtensionNotification ExtensionNotification::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	ExtensionNotification msg(ContextualizedRequest::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	msg.name = STRING_ATTR_OR_EXPR(msgElem, Name);
+	msg.type = EXTENSIONNOTIFICATION;
+	return msg;
+}
+
+ExtensionNotification::operator Event() const {
+	Event ev = ContextualizedRequest::operator Event();
+	if (name.length() > 0) {
+		ev.setName("mmi.extensionnotification." + name);
+	} else {
+		ev.setName("mmi.extensionnotification");
+	}
+	return ev;
+}
+
+StatusResponse StatusResponse::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	StatusResponse msg(ContextualizedRequest::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	std::string status = STRING_ATTR_OR_EXPR(msgElem, Status);
+
+	if (boost::iequals(status, "ALIVE")) {
+		msg.status = ALIVE;
+	} else if(boost::iequals(status, "DEAD")) {
+		msg.status = DEAD;
+	} else if(boost::iequals(status, "FAILURE")) {
+		msg.status = FAILURE;
+	} else if(boost::iequals(status, "SUCCESS")) {
+		msg.status = SUCCESS;
+	}
+	msg.type = STATUSRESPONSE;
+	return msg;
+}
+
+StatusInfoResponse StatusInfoResponse::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	StatusInfoResponse msg(StatusResponse::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	Element<std::string> statusInfoElem;
+
+	node = msgElem.getFirstChild();
+	while (node) {
+		if (node.getNodeType() == Node_base::ELEMENT_NODE) {
+			statusInfoElem = Element<std::string>(node);
+			if (statusInfoElem && boost::iequals(statusInfoElem.getLocalName(), "statusInfo"))
+				break;
+		}
+		node = node.getNextSibling();
+	}
+
+	if (statusInfoElem && boost::iequals(statusInfoElem.getLocalName(), "statusInfo")) {
+		node = statusInfoElem.getFirstChild();
+		while (node) {
+			if (node.getNodeType() == Node_base::TEXT_NODE) {
+				msg.statusInfo = node.getNodeValue();
+				break;
+			}
+			node = node.getNextSibling();
+		}
+	}
+	return msg;
+}
+
+
+StatusRequest StatusRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	StatusRequest msg(ContextualizedRequest::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+
+	Element<std::string> msgElem(node);
+	std::string autoUpdate = STRING_ATTR_OR_EXPR(msgElem, RequestAutomaticUpdate);
+
+	if (boost::iequals(autoUpdate, "true")) {
+		msg.automaticUpdate = true;
+	} else if(boost::iequals(autoUpdate, "on")) {
+		msg.automaticUpdate = true;
+	} else if(boost::iequals(autoUpdate, "yes")) {
+		msg.automaticUpdate = true;
+	} else if(boost::iequals(autoUpdate, "1")) {
+		msg.automaticUpdate = true;
+	} else {
+		msg.automaticUpdate = false;
+	}
+	msg.type = STATUSREQUEST;
+	return msg;
+}
+
+
+}
\ No newline at end of file
diff --git a/src/uscxml/messages/MMIMessages.h b/src/uscxml/messages/MMIMessages.h
new file mode 100644
index 0000000..e4456f8
--- /dev/null
+++ b/src/uscxml/messages/MMIMessages.h
@@ -0,0 +1,499 @@
+/**
+ *  @file
+ *  @author     2012-2013 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
+ *  @copyright  Simplified BSD
+ *
+ *  @cond
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the FreeBSD license as published by the FreeBSD
+ *  project.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *  You should have received a copy of the FreeBSD license along with this
+ *  program. If not, see <http://www.opensource.org/licenses/bsd-license>.
+ *  @endcond
+ */
+
+#ifndef MMIEVENT_H_OS0SE7H5
+#define MMIEVENT_H_OS0SE7H5
+
+#include <DOM/Node.hpp>
+#include <DOM/Document.hpp>
+#include <uscxml/Interpreter.h>
+
+namespace uscxml {
+
+class MMIEvent {
+public:
+	enum Type {
+		NEWCONTEXTREQUEST,
+		NEWCONTEXTRESPONSE,
+		PREPAREREQUEST,
+		PREPARERESPONSE,
+		STARTREQUEST,
+		STARTRESPONSE,
+		DONENOTIFICATION,
+		CANCELREQUEST,
+		CANCELRESPONSE,
+		PAUSEREQUEST,
+		PAUSERESPONSE,
+		RESUMEREQUEST,
+		RESUMERESPONSE,
+		EXTENSIONNOTIFICATION,
+		CLEARCONTEXTREQUEST,
+		CLEARCONTEXTRESPONSE,
+		STATUSREQUEST,
+		STATUSRESPONSE,
+		INVALID
+	};
+
+	static Type getType(Arabica::DOM::Node<std::string> node);
+
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	static MMIEvent fromXML(Arabica::DOM::Node<std::string> node,
+	                        InterpreterImpl* interpreter = NULL);
+
+	// conversion operator
+	operator Event() const;
+
+	std::string source;
+	std::string target;
+	std::string data;
+	std::string requestId;
+	std::string tagName;
+	Type type;
+
+	static std::string nameSpace;
+
+protected:
+	MMIEvent() {}
+};
+
+class MMIEventReceiver {
+public:
+	virtual void received(const MMIEvent& mmiEvent) = 0;
+};
+
+class MMIEventSender {
+public:
+	virtual void send(const MMIEvent& mmiEvent) = 0;
+};
+
+class NewContextRequest : public MMIEvent {
+public:
+	NewContextRequest() {
+		tagName = "NewContextRequest";
+		type = NEWCONTEXTREQUEST;
+	}
+	NewContextRequest(const MMIEvent& father) : MMIEvent(father) {}
+	static NewContextRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                                 InterpreterImpl* interpreter = NULL) {
+		MMIEvent event = MMIEvent::fromXML(node, interpreter);
+		event.type = NEWCONTEXTREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = MMIEvent::operator Event();
+		ev.setName("mmi.newcontextrequest");
+		ev.setDOM(toXML());
+		return ev;
+	}
+	std::string token; ///< special token for server-less modality components
+};
+
+class ContextualizedRequest : public MMIEvent {
+public:
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	static ContextualizedRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                                     InterpreterImpl* interpreter = NULL);
+	operator Event() const;
+	std::string context;
+protected:
+	ContextualizedRequest() {}
+	ContextualizedRequest(const MMIEvent& father) : MMIEvent(father) {}
+};
+
+class PauseRequest : public ContextualizedRequest {
+public:
+	PauseRequest() {
+		tagName = "PauseRequest";
+		type = PAUSEREQUEST;
+	}
+	PauseRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+	static PauseRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                            InterpreterImpl* interpreter = NULL) {
+		PauseRequest event = ContextualizedRequest::fromXML(node, interpreter);
+		event.type = PAUSEREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		ev.setName("mmi.pauserequest");
+		ev.setDOM(toXML());
+		return ev;
+	}
+
+};
+class ResumeRequest : public ContextualizedRequest {
+public:
+	ResumeRequest() {
+		tagName = "ResumeRequest";
+		type = RESUMEREQUEST;
+	}
+	ResumeRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+	static ResumeRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                             InterpreterImpl* interpreter = NULL) {
+		ResumeRequest event = ContextualizedRequest::fromXML(node, interpreter);
+		event.type = RESUMEREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		ev.setDOM(toXML());
+		ev.setName("mmi.resumerequest");
+		return ev;
+	}
+
+};
+class CancelRequest : public ContextualizedRequest {
+public:
+	CancelRequest() {
+		tagName = "CancelRequest";
+		type = CANCELREQUEST;
+	}
+	CancelRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+	static CancelRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                             InterpreterImpl* interpreter = NULL) {
+		CancelRequest event = ContextualizedRequest::fromXML(node, interpreter);
+		event.type = CANCELREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		ev.setName("mmi.cancelrequest");
+		ev.setDOM(toXML());
+		return ev;
+	}
+
+};
+class ClearContextRequest : public ContextualizedRequest {
+public:
+	ClearContextRequest() {
+		tagName = "ClearContextRequest";
+		type = CLEARCONTEXTREQUEST;
+	}
+	ClearContextRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+	static ClearContextRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                                   InterpreterImpl* interpreter = NULL) {
+		ClearContextRequest event = ContextualizedRequest::fromXML(node, interpreter);
+		event.type = CLEARCONTEXTREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		ev.setName("mmi.clearcontextrequest");
+		ev.setDOM(toXML());
+		return ev;
+	}
+
+};
+class StatusRequest : public ContextualizedRequest {
+public:
+	StatusRequest() {
+		tagName = "StatusRequest";
+		type = STARTREQUEST;
+	}
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	static StatusRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                             InterpreterImpl* interpreter = NULL);
+	operator Event() const;
+	bool automaticUpdate;
+protected:
+	StatusRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+};
+
+class ContentRequest : public ContextualizedRequest {
+public:
+	struct ContentURL {
+		std::string href;
+		std::string maxAge;
+		std::string fetchTimeout;
+	};
+
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	static ContentRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                              InterpreterImpl* interpreter = NULL);
+	operator Event() const;
+	std::string content;
+	ContentURL contentURL;
+protected:
+	ContentRequest() {}
+	ContentRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+};
+
+class PrepareRequest : public ContentRequest {
+public:
+	PrepareRequest() {
+		tagName = "PrepareRequest";
+		type = PREPAREREQUEST;
+	}
+	PrepareRequest(const ContentRequest& father) : ContentRequest(father) {}
+	static PrepareRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                              InterpreterImpl* interpreter = NULL) {
+		PrepareRequest event = ContentRequest::fromXML(node, interpreter);
+		event.type = PREPAREREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = ContentRequest::operator Event();
+		ev.setName("mmi.preparerequest");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class StartRequest : public ContentRequest {
+public:
+	StartRequest() {
+		tagName = "StartRequest";
+		type = STARTREQUEST;
+	}
+	StartRequest(const ContentRequest& father) : ContentRequest(father) {}
+	static StartRequest fromXML(Arabica::DOM::Node<std::string> node,
+	                            InterpreterImpl* interpreter = NULL) {
+		StartRequest event = ContentRequest::fromXML(node, interpreter);
+		event.type = STARTREQUEST;
+		return event;
+	}
+	operator Event() const {
+		Event ev = ContentRequest::operator Event();
+		ev.setName("mmi.startrequest");
+		ev.setDOM(toXML());
+		return ev;
+	}
+
+};
+
+class ExtensionNotification : public ContextualizedRequest {
+public:
+	ExtensionNotification() {
+		tagName = "ExtensionNotification";
+		type = EXTENSIONNOTIFICATION;
+	}
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	static ExtensionNotification fromXML(Arabica::DOM::Node<std::string> node,
+	                                     InterpreterImpl* interpreter = NULL);
+	operator Event() const;
+	std::string name;
+protected:
+	ExtensionNotification(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+
+};
+
+class StatusResponse : public ContextualizedRequest {
+public:
+	enum Status {
+		ALIVE = 0,
+		DEAD = 1,
+		SUCCESS = 2,
+		FAILURE = 3
+	};
+
+	StatusResponse() {
+		tagName = "StatusResponse";
+		type = STATUSRESPONSE;
+	}
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	static StatusResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                              InterpreterImpl* interpreter = NULL);
+	Status status;
+protected:
+	StatusResponse(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
+};
+
+class StatusInfoResponse : public StatusResponse {
+public:
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	StatusInfoResponse(const StatusResponse& father) : StatusResponse(father) {}
+	static StatusInfoResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                                  InterpreterImpl* interpreter = NULL);
+	std::string statusInfo;
+protected:
+	StatusInfoResponse() {}
+};
+
+class PrepareResponse : public StatusInfoResponse {
+public:
+	PrepareResponse() {
+		tagName = "PrepareResponse";
+		type = PREPARERESPONSE;
+	}
+	PrepareResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static PrepareResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                               InterpreterImpl* interpreter = NULL) {
+		PrepareResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = PREPARERESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.prepareresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class StartResponse : public StatusInfoResponse {
+public:
+	StartResponse() {
+		tagName = "StartResponse";
+		type = STARTRESPONSE;
+	}
+	StartResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static StartResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                             InterpreterImpl* interpreter = NULL) {
+		StartResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = STARTRESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.startresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class CancelResponse : public StatusInfoResponse {
+public:
+	CancelResponse() {
+		tagName = "CancelResponse";
+		type = CANCELRESPONSE;
+	}
+	CancelResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static CancelResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                              InterpreterImpl* interpreter = NULL) {
+		CancelResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = CANCELRESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.cancelresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class PauseResponse : public StatusInfoResponse {
+public:
+	PauseResponse() {
+		tagName = "PauseResponse";
+		type = PAUSERESPONSE;
+	}
+	PauseResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static PauseResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                             InterpreterImpl* interpreter = NULL) {
+		PauseResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = PAUSERESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.pauseresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class ResumeResponse : public StatusInfoResponse {
+public:
+	ResumeResponse() {
+		tagName = "ResumeResponse";
+		type = RESUMERESPONSE;
+	}
+	ResumeResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static ResumeResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                              InterpreterImpl* interpreter = NULL) {
+		ResumeResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = RESUMERESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.resumeresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class ClearContextResponse : public StatusInfoResponse {
+public:
+	ClearContextResponse() {
+		tagName = "ClearContextResponse";
+		type = CLEARCONTEXTRESPONSE;
+	}
+	ClearContextResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static ClearContextResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                                    InterpreterImpl* interpreter = NULL) {
+		ClearContextResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = CLEARCONTEXTRESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.clearcontextresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+class NewContextResponse : public StatusInfoResponse {
+public:
+	NewContextResponse() {
+		tagName = "NewContextResponse";
+		type = NEWCONTEXTRESPONSE;
+	}
+	NewContextResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static NewContextResponse fromXML(Arabica::DOM::Node<std::string> node,
+	                                  InterpreterImpl* interpreter = NULL) {
+		NewContextResponse event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = NEWCONTEXTRESPONSE;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.newcontextresponse");
+		ev.setDOM(toXML());
+		return ev;
+	}
+
+};
+
+class DoneNotification : public StatusInfoResponse {
+public:
+	DoneNotification() {
+		tagName = "DoneNotification";
+		type = DONENOTIFICATION;
+	}
+	DoneNotification(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
+	static DoneNotification fromXML(Arabica::DOM::Node<std::string> node,
+	                                InterpreterImpl* interpreter = NULL) {
+		DoneNotification event = StatusInfoResponse::fromXML(node, interpreter);
+		event.type = DONENOTIFICATION;
+		return event;
+	}
+	operator Event() const {
+		Event ev = StatusInfoResponse::operator Event();
+		ev.setName("mmi.donenotification");
+		ev.setDOM(toXML());
+		return ev;
+	}
+};
+
+}
+
+#endif /* end of include guard: MMIEVENT_H_OS0SE7H5 */