hlrc

/*

* This file is part of hlrc_server

*

* Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

* http://opensource.cit-ec.de/projects/hlrc_server

*

* This file may be licensed under the terms of the

* GNU General Public License Version 3 (the ``GPL''),

* or (at your option) any later version.

*

* Software distributed under the License is distributed

* on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

* express or implied. See the GPL for the specific language

* governing rights and limitations.

*

* You should have received a copy of the GPL along with this

* program. If not, go to http://www.gnu.org/licenses/gpl.html

* or write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

*

* The development of this software was supported by the

* Excellence Cluster EXC 277 Cognitive Interaction Technology.

* The Excellence Cluster EXC 277 is a grant of the Deutsche

* Forschungsgemeinschaft (DFG) in the context of the German

* Excellence Initiative.

*

*/

#include "MiddlewareRSB.h"

#ifdef RSB_SUPPORT

#include <rsb/converter/Repository.h>

#include <rsb/converter/ProtocolBufferConverter.h>

#include <cstdio>

//CallbackWrapper:

#include "RSB/GazeCallbackWrapper.h"

#include "RSB/MouthCallbackWrapper.h"

#include "RSB/SpeechCallbackWrapper.h"

#include "RSB/UtteranceCallbackWrapper.h"

#include "RSB/EmotionCallbackWrapper.h"

#include "RSB/AnimationCallbackWrapper.h"

#include "RSB/UtteranceRSB.h"

using namespace std;

using namespace rsb;

using namespace rsb::patterns;

MiddlewareRSB::MiddlewareRSB(Arbiter *arbiter, std::string scope) : Middleware(arbiter, scope){

    init();

}

MiddlewareRSB::~MiddlewareRSB(){

}

void MiddlewareRSB::tick(){

    //nothing to do

}

void MiddlewareRSB::init(){

    printf("> registering converters\n");

    //converter for EmotionState

    try {

    rsb::converter::Converter<string>::Ptr emotionStateConverter(new rsb::converter::ProtocolBufferConverter<rst::animation::EmotionExpression>());

    rsb::converter::converterRepository<string>()->registerConverter(emotionStateConverter);

    } catch (...) {}

    //converter for SoundChunk

    try {

    rsb::converter::Converter<string>::Ptr SoundChunkConverter(new rsb::converter::ProtocolBufferConverter<rst::audition::SoundChunk>());

    rsb::converter::converterRepository<string>()->registerConverter(SoundChunkConverter);

    } catch (...) {}

    //converter for Utterance

    try {

    rsb::converter::Converter<string>::Ptr UtteranceConverter(new rsb::converter::ProtocolBufferConverter<rst::audition::Utterance>());

    rsb::converter::converterRepository<string>()->registerConverter(UtteranceConverter);

    } catch (...) {}

    //converter for GazeTarget

    try {

    rsb::converter::Converter<string>::Ptr gazeTargetConverter(new rsb::converter::ProtocolBufferConverter<rst::animation::BinocularHeadGaze>());

    rsb::converter::converterRepository<string>()->registerConverter(gazeTargetConverter);

    } catch (...) {}

    //converter for MouthTarget

    //rsb::converter::Converter<string>::Ptr mouthTargetConverter(new rsb::converter::ProtocolBufferConverter<rst::robot::MouthTarget>());

    //rsb::converter::converterRepository<string>()->registerConverter(mouthTargetConverter);

    //converter for Animation

    try {

    rsb::converter::Converter<string>::Ptr animationConverter(new rsb::converter::ProtocolBufferConverter<rst::animation::HeadAnimation>());

    rsb::converter::converterRepository<string>()->registerConverter(animationConverter);

    } catch (...) {}

    //first get a factory instance that is used to create RSB domain objects

    Factory &factory = getFactory();

    //scope to listen on:

    string scope = base_scope + "/set/";

    //get server

    server = factory.createLocalServer(scope);

    //get tts server:

    string tts_scope = base_scope + "/tts_provider";

    printf("> registering remote server on %s\n",tts_scope.c_str());

    tts_server = factory.createRemoteServer(tts_scope);

    //create local server with parallel exec strategy (HACK!)

    rsb::ParticipantConfig config = factory.getDefaultParticipantConfig();

    rsc::runtime::Properties &properties = config.mutableEventReceivingStrategy().mutableOptions();

    properties.set<string>("parallelhandlercalls", "1");

    //now we can create a server with parallel execution:

    server_parallel = factory.createLocalServer(scope, config);

    //this server will now handle/call these methods in multiple threads:

    server_parallel->registerMethod("animation", LocalServer::CallbackPtr(new AnimationCallbackWrapper(this)));

    //initialise callbacks:

    init_callbacks();

    //informer->publish(gaze_target);

    printf("> MiddlewareRSB initialised\n");

}

void MiddlewareRSB::init_callback(string name, LocalServer::CallbackPtr callback_ptr){

    printf("> init_callback(%s%s)\n", server->getScope()->toString().c_str(), name.c_str());

    server->registerMethod(name, callback_ptr);

}

void MiddlewareRSB::init_callbacks(){

    printf("> registering callbacks (rpc methods)\n");

    init_callback("speech",    LocalServer::CallbackPtr(new SpeechCallbackWrapper(this)));

    init_callback("utterance", LocalServer::CallbackPtr(new UtteranceCallbackWrapper(this)));

    init_callback("gaze",      LocalServer::CallbackPtr(new GazeCallbackWrapper(this)));

    ///init_callback("mouth",     LocalServer::CallbackPtr(new MouthCallbackWrapper(this)));

    EmotionCallbackWrapper *emotion_cb = new EmotionCallbackWrapper(this);

    init_callback("defaultEmotion", LocalServer::CallbackPtr(emotion_cb));

    init_callback("currentEmotion", LocalServer::CallbackPtr(emotion_cb));

}

//call a tts system to convert a string to an utterance

std::shared_ptr<Utterance> MiddlewareRSB::tts_call(string text){

    double tts_timeout = 1.0; //seconds. DO NOT CHANGE THIS!

    //build request

    std::shared_ptr<std::string> request(new string(text));

    //try to fetch it asynchronously:

    try{

        RemoteServer::DataFuture<rst::audition::Utterance> future_ptr = tts_server->callAsync<rst::audition::Utterance>("create_utterance", request);

        //try to fetch the result

        std::shared_ptr<rst::audition::Utterance> utterance_ptr = future_ptr.get(tts_timeout);

        //done, return utterance ptr

        std::shared_ptr<Utterance> utterance(new UtteranceRSB(*(utterance_ptr.get())));

        printf("> done. got utterance (text=%s)\n",utterance->get_text().c_str());

        return utterance;

    }catch(rsc::threading::FutureTimeoutException e){

        printf("> error: tts_call timed out after %3.1f seconds.\n", tts_timeout);

    }catch(rsc::threading::FutureTaskExecutionException e){

        printf("> error: tts_call failed: %s\n", e.what());

    }

    printf("> failed... got no utterance\n");

    std::shared_ptr<Utterance> utterance(new Utterance());

    return utterance;

}

#endif