diff options
Diffstat (limited to 'src/uscxml/messages')
-rw-r--r-- | src/uscxml/messages/MMIMessages.cpp | 436 | ||||
-rw-r--r-- | src/uscxml/messages/MMIMessages.h | 499 |
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 */ |