diff options
Diffstat (limited to 'src')
19 files changed, 667 insertions, 52 deletions
diff --git a/src/uscxml/Factory.cpp b/src/uscxml/Factory.cpp index 643c358..ae7af11 100644 --- a/src/uscxml/Factory.cpp +++ b/src/uscxml/Factory.cpp @@ -49,6 +49,10 @@ # include "uscxml/plugins/invoker/calendar/CalendarInvoker.h" # endif +# ifdef LIBPURPLE_FOUND +# include "uscxml/plugins/invoker/im/IMInvoker.h" +# endif + #ifdef OPENAL_FOUND # include "uscxml/plugins/invoker/audio/OpenALInvoker.h" #endif @@ -168,6 +172,13 @@ Factory::Factory() { } #endif +#ifdef LIBPURPLE_FOUND + { + IMInvoker* invoker = new IMInvoker(); + registerInvoker(invoker); + } +#endif + #if (defined OPENAL_FOUND && (defined LIBSNDFILE_FOUND || defined AUDIOTOOLBOX_FOUND)) { OpenALInvoker* invoker = new OpenALInvoker(); diff --git a/src/uscxml/Interpreter.cpp b/src/uscxml/Interpreter.cpp index 3946bef..7e61ed7 100644 --- a/src/uscxml/Interpreter.cpp +++ b/src/uscxml/Interpreter.cpp @@ -905,7 +905,7 @@ void InterpreterImpl::invoke(const Arabica::DOM::Node<std::string>& element) { } if (_dataModel) { try { - _dataModel.assign("_invokers['" + invokeReq.invokeid + "']", invoker.getDataModelVariables()); +// _dataModel.assign("_invokers['" + invokeReq.invokeid + "']", invoker.getDataModelVariables()); } catch(...) { LOG(ERROR) << "Exception caught while assigning datamodel variables from invoker " << invokeReq.invokeid; } diff --git a/src/uscxml/URL.cpp b/src/uscxml/URL.cpp index 1b15dee..8332c1d 100644 --- a/src/uscxml/URL.cpp +++ b/src/uscxml/URL.cpp @@ -56,6 +56,34 @@ std::string URL::tmpDir() { return tmpDir; } +std::map<std::string, std::string> URL::mimeTypes; + std::string URL::getMimeType(const std::string extension, std::string magic) { + if (mimeTypes.empty()) { + mimeTypes["txt"] = "text/plain"; + mimeTypes["c"] = "text/plain"; + mimeTypes["h"] = "text/plain"; + mimeTypes["html"] = "text/html"; + mimeTypes["htm"] = "text/htm"; + mimeTypes["css"] = "text/css"; + mimeTypes["bmp"] = "image/bmp"; + mimeTypes["gif"] = "image/gif"; + mimeTypes["jpg"] = "image/jpeg"; + mimeTypes["jpeg"] = "image/jpeg"; + mimeTypes["mpg"] = "video/mpeg"; + mimeTypes["mov"] = "video/quicktime"; + mimeTypes["png"] = "image/png"; + mimeTypes["pdf"] = "application/pdf"; + mimeTypes["ps"] = "application/postscript"; + mimeTypes["tif"] = "image/tiff"; + mimeTypes["tiff"] = "image/tiff"; + } + + if (mimeTypes.find(extension) != mimeTypes.end()) { + return mimeTypes[extension]; + } + return ""; +} + std::string URL::getTmpFilename(const std::string& suffix) { std::string tmpFilename = tmpDir(); diff --git a/src/uscxml/URL.h b/src/uscxml/URL.h index c00d24a..26b9437 100644 --- a/src/uscxml/URL.h +++ b/src/uscxml/URL.h @@ -246,7 +246,9 @@ public: } static std::string tmpDir(); - + static std::map<std::string, std::string> mimeTypes; + static std::string getMimeType(const std::string extension, std::string magic = ""); + friend class URLFetcher; friend std::ostream & operator<<(std::ostream &stream, const URL& p); diff --git a/src/uscxml/concurrency/eventqueue/DelayedEventQueue.cpp b/src/uscxml/concurrency/eventqueue/DelayedEventQueue.cpp index 14028fa..cbb82eb 100644 --- a/src/uscxml/concurrency/eventqueue/DelayedEventQueue.cpp +++ b/src/uscxml/concurrency/eventqueue/DelayedEventQueue.cpp @@ -1,6 +1,7 @@ #include "DelayedEventQueue.h" #include <assert.h> #include <event2/event.h> +#include <sstream> namespace uscxml { @@ -36,6 +37,27 @@ void DelayedEventQueue::run(void* instance) { } } +void DelayedEventQueue::addEvent(std::string eventId, int fd, short opMask, void (*callback)(void*, const std::string eventId), void* userData, bool persist) { + if(_callbackData.find(eventId) != _callbackData.end()) { + cancelEvent(eventId); + } + + if (persist) + opMask |= EV_PERSIST; + + struct event* event = event_new(_eventLoop, fd, opMask, DelayedEventQueue::fileCallback, &_callbackData[eventId]); + + _callbackData[eventId].eventId = eventId; + _callbackData[eventId].userData = userData; + _callbackData[eventId].eventQueue = this; + _callbackData[eventId].callback = callback; + _callbackData[eventId].event = event; + _callbackData[eventId].persist = false; + + event_add(event, NULL); + +} + void DelayedEventQueue::addEvent(std::string eventId, void (*callback)(void*, const std::string eventId), uint32_t delayMs, void* userData, bool persist) { if(_callbackData.find(eventId) != _callbackData.end()) { cancelEvent(eventId); @@ -83,6 +105,13 @@ void DelayedEventQueue::stop() { void DelayedEventQueue::dummyCallback(evutil_socket_t fd, short what, void *arg) { } +void DelayedEventQueue::fileCallback(evutil_socket_t fd, short what, void *arg) { + struct callbackData *data = (struct callbackData*)arg; + tthread::lock_guard<tthread::recursive_mutex> lock(data->eventQueue->_mutex); + std::string eventId = data->eventId; // copy eventId + data->callback(data->userData, eventId); +} + void DelayedEventQueue::timerCallback(evutil_socket_t fd, short what, void *arg) { struct callbackData *data = (struct callbackData*)arg; tthread::lock_guard<tthread::recursive_mutex> lock(data->eventQueue->_mutex); diff --git a/src/uscxml/concurrency/eventqueue/DelayedEventQueue.h b/src/uscxml/concurrency/eventqueue/DelayedEventQueue.h index 7ce766b..0b72719 100644 --- a/src/uscxml/concurrency/eventqueue/DelayedEventQueue.h +++ b/src/uscxml/concurrency/eventqueue/DelayedEventQueue.h @@ -18,6 +18,12 @@ namespace uscxml { class DelayedEventQueue { public: + enum OpMask { + FD_READ = EV_READ, + FD_WRITE = EV_WRITE, + FD_SIGNAL = EV_SIGNAL + }; + struct callbackData { void *userData; void (*callback)(void*, const std::string eventId); @@ -30,6 +36,7 @@ public: DelayedEventQueue(); virtual ~DelayedEventQueue(); + void addEvent(std::string eventId, int fd, short opMask, void (*callback)(void*, const std::string eventId), void* userData, bool persist = true); void addEvent(std::string eventId, void (*callback)(void*, const std::string eventId), uint32_t delayMs, void* userData, bool persist = false); void cancelEvent(std::string eventId); @@ -42,6 +49,7 @@ public: } static void timerCallback(evutil_socket_t fd, short what, void *arg); + static void fileCallback(evutil_socket_t fd, short what, void *arg); static void dummyCallback(evutil_socket_t fd, short what, void *arg); bool _isStarted; diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp index 0e72c67..d479a63 100644 --- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp +++ b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp @@ -124,11 +124,14 @@ boost::shared_ptr<DataModelImpl> V8DataModel::create(InterpreterImpl* interprete V8DataModel::getIOProcessors, V8DataModel::setWithException, v8::External::New(reinterpret_cast<void*>(dm.get()))); + context->Global()->SetAccessor(v8::String::New("_invokers"), + V8DataModel::getInvokers, + V8DataModel::setWithException, + v8::External::New(reinterpret_cast<void*>(dm.get()))); dm->_contexts.push_back(context); // instantiate objects - we have to have a context for that! - dm->eval(Element<std::string>(), "_invokers = {};"); dm->eval(Element<std::string>(), "_x = {};"); return dm; @@ -147,21 +150,35 @@ void V8DataModel::setWithException(v8::Local<v8::String> property, v8::Local<v8: v8::Handle<v8::Value> V8DataModel::getIOProcessors(v8::Local<v8::String> property, const v8::AccessorInfo& info) { V8DataModel* dataModel = V8DOM::toClassPtr<V8DataModel>(info.Data()); - if (dataModel->_ioProcessors.IsEmpty()) { - dataModel->_ioProcessors = v8::Persistent<v8::Object>::New(v8::Object::New()); - //v8::Handle<v8::Object> ioProcessorObj = v8::Object::New(); - std::map<std::string, IOProcessor> ioProcessors = dataModel->_interpreter->getIOProcessors(); - std::map<std::string, IOProcessor>::const_iterator ioProcIter = ioProcessors.begin(); - while(ioProcIter != ioProcessors.end()) { + dataModel->_ioProcessors = v8::Persistent<v8::Object>::New(v8::Object::New()); + //v8::Handle<v8::Object> ioProcessorObj = v8::Object::New(); + std::map<std::string, IOProcessor> ioProcessors = dataModel->_interpreter->getIOProcessors(); + std::map<std::string, IOProcessor>::const_iterator ioProcIter = ioProcessors.begin(); + while(ioProcIter != ioProcessors.end()) { // std::cout << ioProcIter->first << std::endl; - dataModel->_ioProcessors->Set(v8::String::New(ioProcIter->first.c_str()), - dataModel->getDataAsValue(ioProcIter->second.getDataModelVariables())); - ioProcIter++; - } + dataModel->_ioProcessors->Set(v8::String::New(ioProcIter->first.c_str()), + dataModel->getDataAsValue(ioProcIter->second.getDataModelVariables())); + ioProcIter++; } return dataModel->_ioProcessors; } +v8::Handle<v8::Value> V8DataModel::getInvokers(v8::Local<v8::String> property, const v8::AccessorInfo& info) { + V8DataModel* dataModel = V8DOM::toClassPtr<V8DataModel>(info.Data()); + + dataModel->_invokers = v8::Persistent<v8::Object>::New(v8::Object::New()); + //v8::Handle<v8::Object> ioProcessorObj = v8::Object::New(); + std::map<std::string, Invoker> invokers = dataModel->_interpreter->getInvokers(); + std::map<std::string, Invoker>::const_iterator invokerIter = invokers.begin(); + while(invokerIter != invokers.end()) { + // std::cout << ioProcIter->first << std::endl; + dataModel->_invokers->Set(v8::String::New(invokerIter->first.c_str()), + dataModel->getDataAsValue(invokerIter->second.getDataModelVariables())); + invokerIter++; + } + return dataModel->_invokers; +} + void V8DataModel::pushContext() { _contexts.push_back(_contexts.back().New(_contexts.back())); } diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h index 0dffa27..1672919 100644 --- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h +++ b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.h @@ -81,7 +81,9 @@ protected: Arabica::DOM::V8DOM* _dom; v8::Persistent<v8::Object> _ioProcessors; + v8::Persistent<v8::Object> _invokers; static v8::Handle<v8::Value> getIOProcessors(v8::Local<v8::String> property, const v8::AccessorInfo& info); + static v8::Handle<v8::Value> getInvokers(v8::Local<v8::String> property, const v8::AccessorInfo& info); static v8::Handle<v8::Value> getAttribute(v8::Local<v8::String> property, const v8::AccessorInfo& info); static void setWithException(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info); diff --git a/src/uscxml/plugins/element/respond/RespondElement.cpp b/src/uscxml/plugins/element/respond/RespondElement.cpp index ae81fed..9da3002 100644 --- a/src/uscxml/plugins/element/respond/RespondElement.cpp +++ b/src/uscxml/plugins/element/respond/RespondElement.cpp @@ -98,7 +98,7 @@ void RespondElement::enterElement(const Arabica::DOM::Node<std::string>& node) { size_t lastDot; if ((lastDot = file.path().find_last_of(".")) != std::string::npos) { std::string extension = file.path().substr(lastDot + 1); - std::string mimeType = HTTPServer::mimeTypeForExtension(extension); + std::string mimeType = URL::getMimeType(extension); if (mimeType.length() > 0) { httpReply.headers["Content-Type"] = mimeType; } diff --git a/src/uscxml/plugins/invoker/CMakeLists.txt b/src/uscxml/plugins/invoker/CMakeLists.txt index db0d61f..5f767c9 100644 --- a/src/uscxml/plugins/invoker/CMakeLists.txt +++ b/src/uscxml/plugins/invoker/CMakeLists.txt @@ -131,6 +131,27 @@ if (FFMPEG_FOUND) endif() +# instant messaging invoker + +if (LIBPURPLE_FOUND) + set(USCXML_INVOKERS "im ${USCXML_INVOKERS}") + file(GLOB_RECURSE LIBPURPLE_INVOKER + im/*.cpp + im/*.h + ) + source_group("Invoker\\im" FILES ${LIBPURPLE_INVOKER}) + if (BUILD_AS_PLUGINS) + add_library( + invoker_im SHARED + ${LIBPURPLE_INVOKER}) + target_link_libraries(invoker_im uscxml) + set_target_properties(invoker_im PROPERTIES FOLDER "Plugin Invoker") + else() + list (APPEND USCXML_FILES ${LIBPURPLE_INVOKER}) + endif() +endif() + + # calendar invoker if (LIBICAL_FOUND) diff --git a/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h b/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h index e95b32e..ecce031 100644 --- a/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h +++ b/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h @@ -46,7 +46,8 @@ protected: frame_count(0), width(0), height(0), - sws_flags(SWS_BICUBIC) {} + sws_flags(SWS_BICUBIC), + sws_ctx(NULL) {} virtual ~EncodingContext() { if (sws_ctx) diff --git a/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp b/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp index 1292e3a..559e441 100644 --- a/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp +++ b/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp @@ -49,7 +49,27 @@ boost::shared_ptr<InvokerImpl> DirMonInvoker::create(InterpreterImpl* interprete } Data DirMonInvoker::getDataModelVariables() { + tthread::lock_guard<tthread::recursive_mutex> lock(_mutex); + Data data; + data.compound["dir"] = Data(_dir, Data::VERBATIM); + + std::set<std::string>::iterator suffixIter = _suffixes.begin(); + while(suffixIter != _suffixes.end()) { + data.compound["suffixes"].array.push_back(Data(*suffixIter, Data::VERBATIM)); + suffixIter++; + } + + std::map<std::string, struct stat> entries = _watcher->getAllEntries(); + std::map<std::string, struct stat>::iterator entryIter = entries.begin(); + while(entryIter != entries.end()) { + data.compound["file"].compound[entryIter->first].compound["mtime"] = toStr(entryIter->second.st_mtime); + data.compound["file"].compound[entryIter->first].compound["ctime"] = toStr(entryIter->second.st_mtime); + data.compound["file"].compound[entryIter->first].compound["atime"] = toStr(entryIter->second.st_mtime); + data.compound["file"].compound[entryIter->first].compound["size"] = toStr(entryIter->second.st_mtime); + entryIter++; + } + return data; } @@ -115,7 +135,10 @@ void DirMonInvoker::invoke(const InvokeRequest& req) { void DirMonInvoker::run(void* instance) { while(((DirMonInvoker*)instance)->_isRunning) { - ((DirMonInvoker*)instance)->_watcher->updateEntries(); + { + tthread::lock_guard<tthread::recursive_mutex> lock(((DirMonInvoker*)instance)->_mutex); + ((DirMonInvoker*)instance)->_watcher->updateEntries(); + } tthread::this_thread::sleep_for(tthread::chrono::milliseconds(20)); } } @@ -233,7 +256,7 @@ DirectoryWatch::~DirectoryWatch() { } } - + void DirectoryWatch::reportAsDeleted() { std::map<std::string, struct stat>::iterator fileIter = _knownEntries.begin(); while(fileIter != _knownEntries.end()) { @@ -248,8 +271,8 @@ void DirectoryWatch::reportAsDeleted() { monIter++; } } - _knownEntries.erase(fileIter->first); - fileIter++; + _knownEntries.erase(fileIter++); +// fileIter++; } assert(_knownDirs.size() == 0); assert(_knownEntries.size() == 0); diff --git a/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.h b/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.h index 59eee81..f5aa4bc 100644 --- a/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.h +++ b/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.h @@ -44,7 +44,7 @@ public: std::map<std::string, struct stat> dirEntries = dirIter->second->getAllEntries(); std::map<std::string, struct stat>::iterator dirEntryIter = dirEntries.begin(); while(dirEntryIter != dirEntries.end()) { - entries[dirIter->first + PATH_SEPERATOR + dirEntryIter->first] = dirEntryIter->second; + entries[dirIter->first + '/' + dirEntryIter->first] = dirEntryIter->second; dirEntryIter++; } dirIter++; diff --git a/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp b/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp index 0e8430c..a6f303a 100644 --- a/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp +++ b/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp @@ -247,7 +247,7 @@ void OSGConverter::process(const SendRequest& req) { osgViewer::ScreenCaptureHandler* captureHandler = new osgViewer::ScreenCaptureHandler(cOp, -1); { -// tthread::lock_guard<tthread::recursive_mutex> lock(_viewerMutex); + tthread::lock_guard<tthread::recursive_mutex> lock(_viewerMutex); osgViewer::Viewer viewer; osg::ref_ptr<osg::GraphicsContext> gc; @@ -259,7 +259,9 @@ void OSGConverter::process(const SendRequest& req) { osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits(ds); traits->width = width; traits->height = height; + // this fails with ubuntu in a VM in parallels traits->pbuffer = true; + gc = osg::GraphicsContext::createGraphicsContext(traits.get()); if (!gc.valid()) { @@ -267,6 +269,11 @@ void OSGConverter::process(const SendRequest& req) { return; } + if (!traits->width || !traits->height) { + LOG(ERROR) << "Traits returned with zero dimensions"; + return; + } + GLenum pbuffer = gc->getTraits()->doubleBuffer ? GL_BACK : GL_FRONT; viewer.setCameraManipulator(new osgGA::TrackballManipulator()); @@ -300,6 +307,11 @@ void OSGConverter::process(const SendRequest& req) { void OSGConverter::reportSuccess(const SendRequest& req, const Data& content) { Event event(req); + + std::string format; + Event::getParam(req.params, "format", format); + + event.data.compound["mimetype"] = Data(URL::getMimeType(format), Data::VERBATIM); if (event.name.length() == 0) event.name = "convert"; @@ -519,6 +531,10 @@ void OSGConverter::dumpMatrix(const osg::Matrix& m) { void OSGConverter::NameRespectingWriteToFile::operator()(const osg::Image& image, const unsigned int context_id) { +// std::cout << "NameRespectingWriteToFile" << std::endl; +// std::cout << image.s() << std::endl; +// std::cout << image.t() << std::endl; + // write to memory first std::string format; if (_req.params.find("format") != _req.params.end()) { @@ -533,7 +549,9 @@ void OSGConverter::NameRespectingWriteToFile::operator()(const osg::Image& image // osgDB got confused when we write to a stringstream std::string tempFile = URL::getTmpFilename(format); - osgDB::writeImageFile(image, tempFile, op); + if (!osgDB::writeImageFile(image, tempFile, op)) { + _converter->reportFailure(_req); + } char* buffer = NULL; size_t length = 0; @@ -547,7 +565,9 @@ void OSGConverter::NameRespectingWriteToFile::operator()(const osg::Image& image file.read(buffer, length); } - remove(tempFile.c_str()); + std::cout << tempFile << std::endl; + +// remove(tempFile.c_str()); // osg::ref_ptr<osgDB::ReaderWriter> writerFormat = osgDB::Registry::instance()->getReaderWriterForExtension(format); // if(!writerFormat.valid()) // _converter->reportFailure(_req); diff --git a/src/uscxml/plugins/invoker/im/IMInvoker.cpp b/src/uscxml/plugins/invoker/im/IMInvoker.cpp new file mode 100644 index 0000000..a7fd146 --- /dev/null +++ b/src/uscxml/plugins/invoker/im/IMInvoker.cpp @@ -0,0 +1,361 @@ +#include "IMInvoker.h" +#include <glog/logging.h> + +#ifdef BUILD_AS_PLUGINS +#include <Pluma/Connector.hpp> +#endif + +namespace uscxml { + +#ifdef BUILD_AS_PLUGINS +PLUMA_CONNECTOR +bool connect(pluma::Host& host) { + host.add( new IMInvokerProvider() ); + return true; +} +#endif + +Data IMInvoker::_pluginData; +GHashTable* IMInvoker::_uiInfo = NULL; +GRand* IMInvoker::_gRand = NULL; + +PurpleEventLoopUiOps IMInvoker::_uiEventLoopOps = +{ + purpleEventTimeoutAdd, + purpleEventTimeoutRemove, + purpleEventInputAdd, + purpleEventInputRemove, + purpleEventInputGetError, + purpleEventTimeoutAddSec, + + /* padding */ + NULL, + NULL, + NULL +}; + +PurpleAccountUiOps IMInvoker::_accountUIOps = { + accountNotifyAdded, + accountStatusChanged, + accountRequestAdd, + accountRequestAuthorize, + accountCloseRequest, + NULL, + NULL, + NULL +}; + +/*** Conversation uiops ***/ +static void +null_write_conv(PurpleConversation *conv, const char *who, const char *alias, + const char *message, PurpleMessageFlags flags, time_t mtime) +{ + const char *name; + if (alias && *alias) + name = alias; + else if (who && *who) + name = who; + else + name = NULL; + + printf("(%s) %s %s: %s\n", purple_conversation_get_name(conv), + purple_utf8_strftime("(%H:%M:%S)", localtime(&mtime)), + name, message); +} + +static PurpleConversationUiOps null_conv_uiops = +{ + NULL, /* create_conversation */ + NULL, /* destroy_conversation */ + NULL, /* write_chat */ + NULL, /* write_im */ + null_write_conv, /* write_conv */ + NULL, /* chat_add_users */ + NULL, /* chat_rename_user */ + NULL, /* chat_remove_users */ + NULL, /* chat_update_user */ + NULL, /* present */ + NULL, /* has_focus */ + NULL, /* custom_smiley_add */ + NULL, /* custom_smiley_write */ + NULL, /* custom_smiley_close */ + NULL, /* send_confirm */ + NULL, + NULL, + NULL, + NULL +}; + +static void +null_ui_init(void) +{ + /** + * This should initialize the UI components for all the modules. Here we + * just initialize the UI for conversations. + */ + purple_conversations_set_ui_ops(&null_conv_uiops); +} + +static PurpleCoreUiOps null_core_uiops = +{ + NULL, + NULL, + null_ui_init, + NULL, + + /* padding */ + NULL, + NULL, + NULL, + NULL +}; + +DelayedEventQueue* IMInvoker::_eventQueue = NULL; + +void IMInvoker::initLibPurple(void *userdata, const std::string event) { + _uiInfo = g_hash_table_new(g_str_hash, g_str_equal); + _gRand = g_rand_new(); + + /* Set a custom user directory (optional) */ + //purple_util_set_user_dir(CUSTOM_USER_DIRECTORY); + + /* We do not want any debugging for now to keep the noise to a minimum. */ + purple_debug_set_enabled(false); + + purple_core_set_ui_ops(&null_core_uiops); +// purple_eventloop_set_ui_ops(&glib_eventloops); + purple_eventloop_set_ui_ops(&_uiEventLoopOps); + + purple_plugins_add_search_path("/usr/local/lib/purple-3"); + // purple_plugins_probe(G_MODULE_SUFFIX); + + if (!purple_core_init("uscxml")) { + LOG(ERROR) << "libpurple initialization failed." << std::endl; + return; + } + + /* Load the preferences. */ + purple_prefs_load(); + purple_plugins_load_saved("/purple/uscxml/plugins/saved"); + + GList *l; + PurplePlugin *plugin; + + for (l = purple_plugins_get_all(); l != NULL; l = l->next) { + plugin = (PurplePlugin *)l->data; + + Data pluginData; + if (plugin->info->id) pluginData.compound["id"] = Data(plugin->info->id, Data::VERBATIM); + if (plugin->info->homepage) pluginData.compound["homepage"] = Data(plugin->info->homepage, Data::VERBATIM); + if (plugin->info->author) pluginData.compound["author"] = Data(plugin->info->author, Data::VERBATIM); + if (plugin->info->description) pluginData.compound["description"] = Data(plugin->info->description, Data::VERBATIM); + if (plugin->info->name) pluginData.compound["name"] = Data(plugin->info->name, Data::VERBATIM); + if (plugin->info->summary) pluginData.compound["summary"] = Data(plugin->info->summary, Data::VERBATIM); + if (plugin->info->version) pluginData.compound["version"] = Data(plugin->info->version, Data::VERBATIM); + if (plugin->info->major_version) pluginData.compound["majorVersion"] = Data(toStr(plugin->info->major_version), Data::VERBATIM); + if (plugin->info->minor_version) pluginData.compound["minorVersion"] = Data(toStr(plugin->info->minor_version), Data::VERBATIM); + + if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) + _pluginData.compound["protocol"].compound[plugin->info->id] = pluginData; + + } + +} + +void IMInvoker::send(void *userdata, const std::string event) { + EventContext* ctx = (EventContext*)userdata; + delete(ctx); +} + +static void +signed_on(PurpleConnection *gc, gpointer null) +{ + PurpleAccount *account = purple_connection_get_account(gc); + printf("Account connected: %s %s\n", purple_account_get_username(account), purple_account_get_protocol_id(account)); +} + +void IMInvoker::invoke(void *userdata, const std::string event) { + EventContext* ctx = (EventContext*)userdata; + IMInvoker* instance = ctx->instance; + + std::string username; + Event::getParam(ctx->invokeReq.params, "username", username); + std::string protocolId; + Event::getParam(ctx->invokeReq.params, "protocol", protocolId); + std::string password; + Event::getParam(ctx->invokeReq.params, "password", password); + + instance->_account = purple_account_new(username.c_str(), protocolId.c_str()); + purple_account_set_password(instance->_account, password.c_str(), NULL, NULL); + + purple_accounts_set_ui_ops(&_accountUIOps); + + purple_account_set_enabled(instance->_account, "uscxml", true); + + PurpleSavedStatus* status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE); + purple_savedstatus_activate(status); + + int handle; + purple_signal_connect(purple_connections_get_handle(), "signed-on", &handle, + PURPLE_CALLBACK(signed_on), NULL); + + delete(ctx); +} + +IMInvoker::IMInvoker() { + _account = NULL; + if (!_eventQueue) { + _eventQueue = new DelayedEventQueue(); + _eventQueue->addEvent("initLibPurple", IMInvoker::initLibPurple, 0, NULL); + _eventQueue->start(); + + + } + +} + +IMInvoker::~IMInvoker() { + if (_account) { + purple_account_destroy(_account); + } +}; + +boost::shared_ptr<InvokerImpl> IMInvoker::create(InterpreterImpl* interpreter) { + boost::shared_ptr<IMInvoker> invoker = boost::shared_ptr<IMInvoker>(new IMInvoker()); + return invoker; +} + +Data IMInvoker::getDataModelVariables() { + return _pluginData; +} + +void IMInvoker::send(const SendRequest& req) { + EventContext* ctx = new EventContext(); + ctx->sendReq = req; + ctx->instance = this; + _eventQueue->addEvent(req.sendid, IMInvoker::invoke, 0, ctx); + return; +} + +void IMInvoker::cancel(const std::string sendId) { +} + +void IMInvoker::invoke(const InvokeRequest& req) { + + EventContext* ctx = new EventContext(); + ctx->invokeReq = req; + ctx->instance = this; + _eventQueue->addEvent(req.sendid, IMInvoker::invoke, 0, ctx); + return; +} + +guint IMInvoker::purpleEventTimeoutAdd(guint interval, GSourceFunc function, gpointer data) { + PurpleEventContext* ctx = new PurpleEventContext(); + ctx->function = function; + ctx->input = NULL; + ctx->data = data; + uintptr_t ptr = reinterpret_cast<uintptr_t>(ctx); + + _eventQueue->addEvent(toStr(ptr), purpleCallback, interval, ctx); + return ptr; +} + +gboolean IMInvoker::purpleEventTimeoutRemove(guint handle) { + _eventQueue->cancelEvent(toStr(handle)); + return true; +} + +guint IMInvoker::purpleEventTimeoutAddSec(guint interval, GSourceFunc function, gpointer data) { + return purpleEventTimeoutAdd(interval * 1000, function, data); +} + +guint IMInvoker::purpleEventInputAdd(int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer data) { + PurpleEventContext* ctx = new PurpleEventContext(); + ctx->function = NULL; + ctx->input = func; + ctx->inputFD = fd; + ctx->cond = cond; + ctx->data = data; + + short opMask = 0; + if (cond & PURPLE_INPUT_READ) + opMask |= DelayedEventQueue::FD_READ; + if (cond & PURPLE_INPUT_WRITE) + opMask |= DelayedEventQueue::FD_WRITE; + + guint eventId = g_rand_int(_gRand); + _eventQueue->addEvent(toStr(eventId), fd, opMask, purpleCallback, ctx, true); + return eventId; +} + +gboolean IMInvoker::purpleEventInputRemove(guint handle) { + _eventQueue->cancelEvent(toStr(handle)); + return true; +} + +int IMInvoker::purpleEventInputGetError(int fd, int *error) { + std::cout << "purpleEventInputGetError" << std::endl; + return 0; +} + +void IMInvoker::purpleCallback(void *userdata, const std::string event) { + PurpleEventContext* ctx = (PurpleEventContext*)userdata; + if (ctx->function) { + ctx->function(ctx->data); + delete ctx; + } else if(ctx->input) { + ctx->input(ctx->data, ctx->inputFD, ctx->cond); + } +} + +void IMInvoker::purplePrefsInit(void) {} +void IMInvoker::purpleDebugInit(void) {} +void IMInvoker::purpleUIInit(void) {} +void IMInvoker::purpleQuit(void) {} + +GHashTable* IMInvoker::purpleGetUIInfo(void) { + return _uiInfo; +} + +void IMInvoker::accountNotifyAdded(PurpleAccount *account, + const char *remote_user, + const char *id, + const char *alias, + const char *message) { + std::cout << "accountNotifyAdded" << std::endl; +} + +void IMInvoker::accountStatusChanged(PurpleAccount *account, + PurpleStatus *status) { + std::cout << "accountStatusChanged" << std::endl; + +} + +void IMInvoker::accountRequestAdd(PurpleAccount *account, + const char *remote_user, + const char *id, + const char *alias, + const char *message) { + std::cout << "accountRequestAdd" << std::endl; +} + +void* IMInvoker::accountRequestAuthorize(PurpleAccount *account, + const char *remote_user, + const char *id, + const char *alias, + const char *message, + gboolean on_list, + PurpleAccountRequestAuthorizationCb authorize_cb, + PurpleAccountRequestAuthorizationCb deny_cb, + void *user_data) { + // always accept all requests + authorize_cb(message, user_data); + return user_data; +} + +void IMInvoker::accountCloseRequest(void *ui_handle) { + std::cout << "accountCloseRequest" << std::endl; +} + + +}
\ No newline at end of file diff --git a/src/uscxml/plugins/invoker/im/IMInvoker.h b/src/uscxml/plugins/invoker/im/IMInvoker.h new file mode 100644 index 0000000..fb02e46 --- /dev/null +++ b/src/uscxml/plugins/invoker/im/IMInvoker.h @@ -0,0 +1,117 @@ +#ifndef IMINVOKER_H_FNWG0XCQ +#define IMINVOKER_H_FNWG0XCQ + +#include <uscxml/Interpreter.h> + +//extern "C" { +#include <libpurple/purple.h> +//} + +#ifdef BUILD_AS_PLUGINS +#include "uscxml/plugins/Plugins.h" +#endif + +namespace uscxml { + +class IMInvoker : public InvokerImpl { +public: + struct EventContext { + InvokeRequest invokeReq; + SendRequest sendReq; + IMInvoker* instance; + }; + + IMInvoker(); + virtual ~IMInvoker(); + virtual boost::shared_ptr<InvokerImpl> create(InterpreterImpl* interpreter); + + virtual std::set<std::string> getNames() { + std::set<std::string> names; + names.insert("im"); + names.insert("instant-messaging"); + names.insert("http://uscxml.tk.informatik.tu-darmstadt.de/#instant-messaging"); + return names; + } + + virtual Data getDataModelVariables(); + virtual void send(const SendRequest& req); + virtual void cancel(const std::string sendId); + virtual void invoke(const InvokeRequest& req); + +protected: + static bool _libPurpleIsInitialized; + static Data _pluginData; + static PurpleAccountUiOps _accountUIOps; + static PurpleEventLoopUiOps _uiEventLoopOps; + static PurpleCoreUiOps _uiCoreOps; + static GHashTable* _uiInfo; + static GRand* _gRand; + + static DelayedEventQueue* _eventQueue; + + // these are only being called from the delayed queue's thread + static void initLibPurple(void *userdata, const std::string event); + static void send(void *userdata, const std::string event); + static void invoke(void *userdata, const std::string event); + + // libpurple ui operations + static guint purpleEventTimeoutAdd(guint interval, GSourceFunc function, gpointer data); + static gboolean purpleEventTimeoutRemove(guint handle); + static guint purpleEventInputAdd(int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer user_data); + static gboolean purpleEventInputRemove(guint handle); + static int purpleEventInputGetError(int fd, int *error); + static guint purpleEventTimeoutAddSec(guint interval, GSourceFunc function, gpointer data); + + // callback contexts + struct PurpleEventContext { + PurpleInputFunction input; + PurpleInputCondition cond; + int inputFD; + GSourceFunc function; + gpointer data; + }; + static void purpleCallback(void *userdata, const std::string event); + + // libpurple core operations + static void purplePrefsInit(void); + static void purpleDebugInit(void); + static void purpleUIInit(void); + static void purpleQuit(void); + static GHashTable* purpleGetUIInfo(void); + + // account operations + static void accountNotifyAdded(PurpleAccount *account, + const char *remote_user, + const char *id, + const char *alias, + const char *message); + static void accountStatusChanged(PurpleAccount *account, + PurpleStatus *status); + static void accountRequestAdd(PurpleAccount *account, + const char *remote_user, + const char *id, + const char *alias, + const char *message); + static void* accountRequestAuthorize(PurpleAccount *account, + const char *remote_user, + const char *id, + const char *alias, + const char *message, + gboolean on_list, + PurpleAccountRequestAuthorizationCb authorize_cb, + PurpleAccountRequestAuthorizationCb deny_cb, + void *user_data); + static void accountCloseRequest(void *ui_handle); + + + PurpleAccount* _account; +}; + +#ifdef BUILD_AS_PLUGINS +PLUMA_INHERIT_PROVIDER(IMInvoker, InvokerImpl); +#endif + +} + + +#endif /* end of include guard: IMINVOKER_H_FNWG0XCQ */ diff --git a/src/uscxml/plugins/invoker/sample/SampleInvoker.cpp b/src/uscxml/plugins/invoker/sample/SampleInvoker.cpp index 4d514ef..bb17370 100644 --- a/src/uscxml/plugins/invoker/sample/SampleInvoker.cpp +++ b/src/uscxml/plugins/invoker/sample/SampleInvoker.cpp @@ -23,7 +23,6 @@ SampleInvoker::~SampleInvoker() { boost::shared_ptr<InvokerImpl> SampleInvoker::create(InterpreterImpl* interpreter) { boost::shared_ptr<SampleInvoker> invoker = boost::shared_ptr<SampleInvoker>(new SampleInvoker()); - invoker->_interpreter = interpreter; return invoker; } diff --git a/src/uscxml/server/HTTPServer.cpp b/src/uscxml/server/HTTPServer.cpp index 0521d74..8799fc2 100644 --- a/src/uscxml/server/HTTPServer.cpp +++ b/src/uscxml/server/HTTPServer.cpp @@ -71,7 +71,6 @@ HTTPServer::~HTTPServer() { HTTPServer* HTTPServer::_instance = NULL; tthread::recursive_mutex HTTPServer::_instanceMutex; -std::map<std::string, std::string> HTTPServer::mimeTypes; HTTPServer* HTTPServer::getInstance(int port) { // tthread::lock_guard<tthread::recursive_mutex> lock(_instanceMutex); @@ -80,25 +79,6 @@ HTTPServer* HTTPServer::getInstance(int port) { WSADATA wsaData; WSAStartup(MAKEWORD(2, 2), &wsaData); #endif - // this is but a tiny list, supply a content-type <header> yourself - mimeTypes["txt"] = "text/plain"; - mimeTypes["c"] = "text/plain"; - mimeTypes["h"] = "text/plain"; - mimeTypes["html"] = "text/html"; - mimeTypes["htm"] = "text/htm"; - mimeTypes["css"] = "text/css"; - mimeTypes["bmp"] = "image/bmp"; - mimeTypes["gif"] = "image/gif"; - mimeTypes["jpg"] = "image/jpeg"; - mimeTypes["jpeg"] = "image/jpeg"; - mimeTypes["mpg"] = "video/mpeg"; - mimeTypes["mov"] = "video/quicktime"; - mimeTypes["png"] = "image/png"; - mimeTypes["pdf"] = "application/pdf"; - mimeTypes["ps"] = "application/postscript"; - mimeTypes["tif"] = "image/tiff"; - mimeTypes["tiff"] = "image/tiff"; - #ifndef _WIN32 evthread_use_pthreads(); #else @@ -110,12 +90,6 @@ HTTPServer* HTTPServer::getInstance(int port) { return _instance; } -std::string HTTPServer::mimeTypeForExtension(const std::string& ext) { - if (mimeTypes.find(ext) != mimeTypes.end()) - return mimeTypes[ext]; - return ""; -} - /** * This callback is registered for all HTTP requests */ @@ -165,7 +139,10 @@ void HTTPServer::httpRecvReqCallback(struct evhttp_request *req, void *callbackD request.data.compound["httpMajor"] = Data(toStr((unsigned short)req->major), Data::VERBATIM); request.data.compound["httpMinor"] = Data(toStr((unsigned short)req->minor), Data::VERBATIM); request.data.compound["uri"] = Data(HTTPServer::getBaseURL() + req->uri, Data::VERBATIM); - request.data.compound["path"] = Data(evhttp_uri_get_path(evhttp_request_get_evhttp_uri(req)), Data::VERBATIM); + + char* pathCStr = evhttp_decode_uri(evhttp_uri_get_path(evhttp_request_get_evhttp_uri(req))); + request.data.compound["path"] = Data(pathCStr, Data::VERBATIM); + free(pathCStr); raw << " " << request.data.compound["path"].atom; const char* query = evhttp_uri_get_query(evhttp_request_get_evhttp_uri(req)); diff --git a/src/uscxml/server/HTTPServer.h b/src/uscxml/server/HTTPServer.h index d216d5e..3e0d91c 100644 --- a/src/uscxml/server/HTTPServer.h +++ b/src/uscxml/server/HTTPServer.h @@ -45,7 +45,6 @@ public: static std::string getBaseURL(); static void reply(const Reply& reply); - static std::string mimeTypeForExtension(const std::string& ext); static bool registerServlet(const std::string& path, HTTPServlet* servlet); ///< Register a servlet, returns false if path is already taken static void unregisterServlet(HTTPServlet* servlet); |