void OnFaceDetection::callback() {
/** Use a mutex to make it all thread safe. */
AL::ALCriticalSection section(fCallbackMutex);
try {
/** Retrieve the data raised by the event. */
fFaces = fMemoryProxy.getData("FaceDetected");
qiLogInfo("module.name") <<fFaces<<std::endl;
/** Check that there are faces effectively detected. */
if (fFaces.getSize() < 2 ) {
if (fFacesCount != 0) {
qiLogInfo("module.example") << "No face detected." << std::endl;
fTtsProxy.say("No face detected.");
fFacesCount = 0;
}
fTtsProxy.say("1 face.");
return;
}
/** Check the number of faces from the FaceInfo field, and check that it has
* changed from the last event.*/
if (fFaces[1].getSize() - 1 != fFacesCount) {
qiLogInfo("module.name") << fFaces[1].getSize() - 1 << " face(s) detected." << std::endl;
char buffer[50];
sprintf(buffer, "%d faces detected.", fFaces[1].getSize() - 1);
fTtsProxy.say(std::string(buffer));
/** Update the current number of detected faces. */
fFacesCount = fFaces[1].getSize() - 1;
}
}
catch (const AL::ALError& e) {
qiLogError("module.name") << e.what() << std::endl;
}
}
static void stop_handler(int signal_number)
{
qiLogVerbose() << "Signal " << signal_number << " received!";
static int count_int = 0;
static int count_term = 0;
int sigcount = 0;
if (signal_number == SIGINT) {
count_int++;
sigcount = count_int;
}
else if (signal_number == SIGTERM) {
count_term++;
sigcount = count_term;
}
switch (sigcount) {
case 1:
qiLogInfo() << "Sending the stop command...";
//register the signal again to call exit the next time if stop did not succeed
Application::atSignal(boost::bind<void>(&stop_handler, _1), signal_number);
// Stop might immediately trigger application destruction, so it has
// to go after atSignal.
Application::stop();
return;
default:
//even for SIGTERM this is an error, so return 1.
qiLogInfo() << "signal " << signal_number << " received a second time, calling exit(1).";
exit(1);
return;
}
}
void SubscribeGyro::onMoveForward(const std::string &key, const AL::ALValue &value, const AL::ALValue &msg){
AL::ALCriticalSection section(fCallbackMutex);
gettimeofday(¤tTime);
file << "Forward\t" << std::endl;
bool test = value;
timer();
qiLogInfo("subscribegyro.gyroswing") << "Executing callback method on move forward: " << test << std::endl;
try {
AL::ALProxy genericProxy ("MovementTools", "127.0.0.1" , 9559);
genericProxy.callVoid("setSpeed", 0.8f);
if (test == true && t > 300) {
genericProxy.callVoid("swingForwards");
qiLogInfo("subscribegyro.gyroswing") << "Forward! " << currentTime.tv_sec << std::endl;
//qi::os::sleep(0.5);
gettimeofday(&lastTime);
}
//fTtsProxy = AL::ALTextToSpeechProxy(getParentBroker());
//fTtsProxy.say("Forward");
}
catch (const AL::ALError& e) {
qiLogError("module.example") << e.what() << std::endl;
}
}
// define our callback function
void OnFaceDetection::callback() {
// use a mutex to make this function thread safe
AL::ALCriticalSection section(fCallbackMutex);
try {
// retrieves FaceDetected event data
fFaces = fMemoryProxy.getData("FaceDetected");
// check to see that there have been faces detected
if(fFaces.getSize() < 2) {
// if a face has been previously detected, by any thread, and now there are zero
// faces detected, then advertise that the robot cannot see the person / people anymore
if(fFaceCount != 0) {
qiLogInfo("module.face") << "No faces detected" << std::endl;
// fTextToSpeechProxy.say("Where. are. you? \\vct=5\\\\rspd=10\\\\pau=200\\I\\pau=50\\ am\\pau=50\\ coming\\pau=20\\ for\\pau=20\\ you.\\pau=1500\\ you\\pau=30\\ can\\pau=30\\ run\\pau=30\\ but\\pau=30\\ you\\pau=20\\ can't\\pau=30\\\\vct=1\\ hide");
fTextToSpeechProxy.say("Hey! Where'd you \\vct=120\\go!?");
fFaceCount = 0;
}
return;
}
// if we've gotten this far, then faces have been detected. Check info on them.
// if the number / info on the face being detected has not changed, do nothing.
if(fFaces[1].getSize() - 1 != fFaceCount) {
qiLogInfo("module.face") << (fFaces[1].getSize() - 1) << " face(s) detected." << std::endl;
if(fFaces[1].getSize() > 2) {
char buffer[50];
sprintf(buffer, "I see %d faces!", fFaces[1].getSize() - 1);
fTextToSpeechProxy.say(std::string(buffer));
}
fTextToSpeechProxy.say("There you are!");
// update the number of detected faces
fFaceCount = fFaces[1].getSize() - 1;
}
} catch(const AL::ALError& error) {
qiLogError("module.face") << error.what() << std::endl;
}
}
TEST_F(TestTask, ManyManyTasks)
{
long long time = qi::os::ustime();
unsigned NCLIENTS = 10;
unsigned NTASKS = 10;
if (getenv("NCLIENTS"))
NCLIENTS = strtol(getenv("NCLIENTS"), 0, 0);
if (getenv("NTASKS"))
NTASKS = strtol(getenv("NTASKS"), 0, 0);
unsigned TOTAL_CLIENTS = NTASKS * NCLIENTS;
std::vector<Context> clients;
for (unsigned i=0; i<NCLIENTS; ++i)
{
Context c;
c.session = new qi::Session();
c.session->connect(p.serviceDirectoryEndpoints()[0]);
c.taskGenClient = c.session->service("taskGen");
c.taskGenProxy = qi::Object<TaskGenerator>(taskGenClient);
clients.push_back(c);
}
qiLogInfo() << "Setup clients: " << (qi::os::ustime() - time) << std::endl;
time = qi::os::ustime();
qi::Atomic<int> counter;
for (unsigned i=0; i<NCLIENTS; ++i)
{
for (unsigned j=0; j<NTASKS; ++j)
{
qi::Object<Task> task = clients[i].taskGenProxy->newTask(
boost::lexical_cast<std::string>(i*NTASKS + j));
clients[i].tasks.push_back(task);
task->onStep.connect(
boost::bind(on_step, _1, boost::ref(counter)));
}
}
ASSERT_EQ(NCLIENTS*NTASKS, taskGenProxy->taskCount());
qiLogInfo() << "Setup tasks: " << (qi::os::ustime() - time) << std::endl;
time = qi::os::ustime();
taskGenProxy->step(1);
for (unsigned step=0; step<1000 && *counter < TOTAL_CLIENTS; ++step)
qi::os::msleep(5);
ASSERT_EQ(*counter, TOTAL_CLIENTS);
std::cerr << "Run: " << (qi::os::ustime() - time) << std::endl;
// Teardown
for (unsigned i=0; i<NCLIENTS; ++i)
{
delete clients[i].session;
}
}
qi::Future<void> Session_SD::listenStandalone(const qi::Url &address)
{
if (_init)
throw std::runtime_error("Already initialised");
_init = true;
_server->addObject(1, _serviceBoundObject);
qiLogInfo() << "ServiceDirectory listener created on " << address.str();
qi::Future<void> f = _server->listen(address);
std::map<unsigned int, ServiceInfo>::iterator it =
_sdObject->connectedServices.find(qi::Message::Service_ServiceDirectory);
if (it != _sdObject->connectedServices.end())
{
it->second.setEndpoints(_server->endpoints());
return f;
}
ServiceInfo si;
si.setName("ServiceDirectory");
si.setServiceId(qi::Message::Service_ServiceDirectory);
si.setMachineId(qi::os::getMachineId());
si.setProcessId(qi::os::getpid());
si.setSessionId("0");
si.setEndpoints(_server->endpoints());
unsigned int regid = _sdObject->registerService(si);
(void)regid;
_sdObject->serviceReady(qi::Message::Service_ServiceDirectory);
//serviceDirectory must have id '1'
assert(regid == qi::Message::Service_ServiceDirectory);
_server->_server.endpointsChanged.connect(boost::bind(&Session_SD::updateServiceInfo, this));
return f;
}
bool ParameterModel::addChoice(ChoiceModelPtr choice)
{
qiLogDebug() << "addChoice function" << std::endl;
Signature signature(_p->_metaProperty.signature());
//if false choice and parameter are the same type
if(Signature(choice->value().signature()).isConvertibleTo(signature) < 1.0f )
{
qiLogWarning() << "choice.type (i.e "
<< choice->value().signature().toString()
<< ") != parameter.type (i.e "
<< _p->_defaultValue.signature().toString()
<<")"
<< std::endl;
return false;
}
//If choice.value is not in [parameter.min, paramater.max] then the choice
//is incorrect
if(!_p->inInterval(choice->value(),
_p->_min,
_p->_max)
)
{
qiLogInfo() << "Choice : is not in interval"
<< std::endl;
return false;
}
_p->_choices.push_front(choice);
return true;
}
std::string reply(const std::string &msg, const float &value) {
qiLogInfo() << "Message recv:" << msg << " * " << value;
std::stringstream ss;
ss << msg << value;
return ss.str();
}
void ServiceDirectory::onSocketDisconnected(TransportSocketPtr socket, std::string error)
{
boost::recursive_mutex::scoped_lock lock(mutex);
// clean from idxToSocket
for (std::map<unsigned int, TransportSocketPtr>::iterator it = idxToSocket.begin(), iend = idxToSocket.end(); it != iend;)
{
std::map<unsigned int, TransportSocketPtr>::iterator next = it;
++next;
if (it->second == socket)
idxToSocket.erase(it);
it = next;
}
// if services were connected behind the socket
std::map<TransportSocketPtr, std::vector<unsigned int> >::iterator it;
it = socketToIdx.find(socket);
if (it == socketToIdx.end()) {
return;
}
// Copy the vector, iterators will be invalidated.
std::vector<unsigned int> ids = it->second;
// Always start at the beginning since we erase elements on unregisterService
// and mess up the iterator
for (std::vector<unsigned int>::iterator it2 = ids.begin();
it2 != ids.end();
++it2)
{
qiLogInfo() << "Service #" << *it2 << " disconnected";
try {
unregisterService(*it2);
} catch (std::runtime_error &) {
qiLogWarning() << "Cannot unregister service #" << *it2;
}
}
socketToIdx.erase(it);
}
void Bumper::onRightBumperPressed() {
std::cout<<"onRightBumperPressed()"<<std::endl;
qiLogInfo("module.example") << "Executing callback method on right bumper event" << std::endl;
/**
* As long as this is defined, the code is thread-safe.
*/
AL::ALCriticalSection section(fCallbackMutex);
/**
* Check that the bumper is pressed.
*/
std::cout<<"before memory.getData2"<<std::endl;
fState = fMemoryProxy.getData("RightBumperPressed");
std::cout<<"After memory.getData2"<<std::endl;
if (fState > 0.5f) {
std::cout<<"if"<<std::endl;
return;
}
try {
fTtsProxy = AL::ALTextToSpeechProxy(getParentBroker());
std::cout<<"HELLO"<<std::endl;
fTtsProxy.say("Hello!");
}
catch (const AL::ALError& e) {
qiLogError("module.example") << e.what() << std::endl;
}
std::cout<<"END"<<std::endl;
}
// Find out our async parent and add to it
static bool insertAsyncParentTrace(CallList& l, CallData* d)
{
if (l.empty())
{
qiLogDebug() << "empty";
return false;
}
qiLogDebug() << l.front()->tStart;
// Get first entry that started after our post time.
CallList::iterator it = std::upper_bound(l.begin(), l.end(), CallTime(d->tPost));
if (it == l.begin())
{ // damm, first element is older than us
qiLogInfo() << "No async parent can be found";
return false;
}
--it;
qiLogDebug() << "Child check";
// try if a sync child is better placed than it
bool wasInserted = insertAsyncParentTrace((*it)->children, d);
if (wasInserted)
return true;
// was not inserted in children, insert here
(*it)->asyncChildren.push_back(d);
d->asyncParent = *it;
return true;
}
std::string reply(const int &msg) {
qiLogInfo() << "Message recv:" << msg;
std::stringstream ss;
ss << msg << "bim";
return ss.str();
}
SigGenerator::SigGenerator(int min_deep, int max_deep, int max_tuple_size)
: min_deep(min_deep)
, max_deep(max_deep)
, max_tuple_size(max_tuple_size)
, current_deep(0)
{
qiLogInfo("core.longtermTest") << "signature generator engaged" << std::endl;
}
void ping()
{
while (true)
{
qiLogInfo("test.dump") << "ping";
qi::os::msleep(900);
}
}
qi::Future<void> TestImpl::saySlowerButBetter(const std::string& mess)
{
qiLogInfo() << "Saying " << mess << " slowly";
assert(!_boole.swap(true));
qi::sleepFor(qi::Seconds(1));
++_numberOfSay;
message.set(mess);
onSayMessage(_numberOfSay);
qiLogInfo() << "Middle say";
assert(_boole.swap(false));
return qi::asyncDelay([]{
qiLogInfo() << "End say";
}, qi::Seconds(1));
}
string tulingModule::getResponse(string text)
{
static int index=0;
if(text == ""){
return string("不好意思，我没有听清楚你说的话^startTag(not know)，您可以再说一遍么？");
}
string cmd = "curl -G http://www.tuling123.com/openapi/api -d key=c237b459589ef904699807b7dadcc300 -d info="+text+"/";
string result = exec_shell(cmd);
string rec_result;
qiLogInfo("Result From Tuling:")<<result<<std::endl;
std::string loc = "\"text\"";
int ind_e = result.find(loc);
while(result[ind_e] != ':'){
ind_e++;
}
while(result[ind_e] != '"'){
if(result[ind_e] == '}'){
rec_result = "";
return rec_result;
}
ind_e++;
}
int ind_s = ++ind_e;
while(result[ind_e] != '"'){
ind_e++;
}
rec_result = result.substr(ind_s, ind_e-ind_s);
//char* expr = "animations/Stand/BodyTalk/BodyTalk_";
char* expr = "animations/Stand/Gestures/Explain_";
char buffer[2000];
sprintf(buffer, "^start(%s%d)%s", expr, index%12, rec_result.c_str());
index++;
qiLogInfo("Result From Tuling:")<<string(buffer)<<std::endl;
return string(buffer);
}
/**
* @brief
*/
void oru_walk::initPosition()
{
/// @attention Hardcoded parameter!
unsigned int init_time = 1200;
ALValue initPositionCommands;
initPositionCommands.arraySetSize(6);
initPositionCommands[0] = string("jointActuator");
initPositionCommands[1] = string("ClearAll");
initPositionCommands[2] = string("time-separate");
initPositionCommands[3] = 0;
initPositionCommands[4].arraySetSize(1);
initPositionCommands[5].arraySetSize(JOINTS_NUM);
for (int i = 0; i < JOINTS_NUM; i++)
{
initPositionCommands[5][i].arraySetSize(1);
}
initJointAngles (initPositionCommands[5]);
for (int i = 0; i < LOWER_JOINTS_NUM; i++)
{
ref_joint_angles[i] = initPositionCommands[5][i][0];
}
// set time
try
{
initPositionCommands[4][0] = dcm_proxy->getTime(init_time);
}
catch (const ALError &e)
{
ORUW_THROW_ERROR("Error on DCM getTime : ", e);
}
// send commands
try
{
dcm_proxy->setAlias(initPositionCommands);
}
catch (const AL::ALError &e)
{
ORUW_THROW_ERROR("Error with DCM setAlias : ", e);
}
qi::os::msleep(init_time);
qiLogInfo ("module.oru_walk", "Execution of initPosition() is finished.");
}
unsigned int ServiceDirectory::registerService(const ServiceInfo &svcinfo)
{
boost::shared_ptr<ServiceBoundObject> sbo = serviceBoundObject.lock();
if (!sbo)
throw std::runtime_error("ServiceBoundObject has expired.");
TransportSocketPtr socket = sbo->currentSocket();
boost::recursive_mutex::scoped_lock lock(mutex);
std::map<std::string, unsigned int>::iterator it;
it = nameToIdx.find(svcinfo.name());
if (it != nameToIdx.end())
{
std::stringstream ss;
ss << "Service \"" <<
svcinfo.name() <<
"\" (#" << it->second << ") is already registered. " <<
"Rejecting conflicting registration attempt.";
qiLogWarning() << ss.str();
throw std::runtime_error(ss.str());
}
unsigned int idx = ++servicesCount;
nameToIdx[svcinfo.name()] = idx;
// Do not add serviceDirectory on the map (socket() == null)
if (idx != qi::Message::Service_ServiceDirectory)
socketToIdx[socket].push_back(idx);
pendingServices[idx] = svcinfo;
pendingServices[idx].setServiceId(idx);
idxToSocket[idx] = socket;
std::stringstream ss;
ss << "Registered Service \"" << svcinfo.name() << "\" (#" << idx << ")";
if (! svcinfo.name().empty() && svcinfo.name()[0] == '_') {
// Hide services whose name starts with an underscore
qiLogDebug() << ss.str();
}
else
{
qiLogInfo() << ss.str();
}
qi::UrlVector::const_iterator jt;
for (jt = svcinfo.endpoints().begin(); jt != svcinfo.endpoints().end(); ++jt)
{
qiLogDebug() << "Service \"" << svcinfo.name() << "\" is now on " << jt->str();
}
return idx;
}
void OnFaceDetection::init() {
try {
/** See if there is any face already detected at initialization. */
fFaces = fMemoryProxy.getData("FaceDetected");
if (fFaces.getSize() < 2) {
qiLogInfo("module.example") << "No face detected." << std::endl;
fTtsProxy.say("No face detected");
}
/** Subscribe to the event FaceDetected, with appropriate callback function. */
fMemoryProxy.subscribeToEvent("FaceDetected", "OnFaceDetection", "callback");
}
catch (const AL::ALError& e) {
qiLogError("module.name") << e.what() << std::endl;
}
}
void MessageDispatcher::sent(const qi::Message& msg) {
//store Call id, we can use them later to notify the client
//if the call did not succeed. (network disconnection, message lost)
if (msg.type() == qi::Message::Type_Call)
{
boost::mutex::scoped_lock l(_messageSentMutex);
MessageSentMap::iterator it = _messageSent.find(msg.id());
if (it != _messageSent.end()) {
qiLogInfo() << "Message ID conflict. A message with the same Id is already in flight" << msg.id();
return;
}
_messageSent[msg.id()] = msg.address();
}
return;
}
/**
* @brief Set stiffness of joints.
*
* @param[in] stiffnessValue value of stiffness [0;1]
*/
void oru_walk::setStiffness(const float &stiffnessValue)
{
ALValue stiffnessCommands;
if ((stiffnessValue < 0) || (stiffnessValue > 1))
{
ORUW_THROW("Wrong parameters");
}
// Prepare one dcm command:
// it will linearly "Merge" all joint stiffness
// from last value to "stiffnessValue" in 1 seconde
stiffnessCommands.arraySetSize(3);
stiffnessCommands[0] = std::string("jointStiffness");
stiffnessCommands[1] = std::string("Merge");
stiffnessCommands[2].arraySetSize(1);
stiffnessCommands[2][0].arraySetSize(2);
stiffnessCommands[2][0][0] = stiffnessValue;
/// @attention Hardcoded parameter!
unsigned int stiffness_change_time = 1000;
try
{
stiffnessCommands[2][0][1] = dcm_proxy->getTime(stiffness_change_time);
}
catch (const ALError &e)
{
ORUW_THROW_ERROR("Error on DCM getTime : ", e);
}
try
{
dcm_proxy->set(stiffnessCommands);
}
catch (const ALError &e)
{
ORUW_THROW_ERROR("Error when sending stiffness to DCM : ", e);
}
qi::os::msleep(stiffness_change_time);
qiLogInfo ("module.oru_walk", "Execution of setStiffness() is finished.");
}
//we ensure in that function that connect to all events are already setup when we said we are connect.
//that way we can't be connected without being fully ready.
qi::FutureSync<void> ServiceDirectoryClient::connect(const qi::Url &serviceDirectoryURL) {
if (isConnected()) {
const char* s = "Session is already connected";
qiLogInfo() << s;
return qi::makeFutureError<void>(s);
}
_sdSocket = qi::makeTransportSocket(serviceDirectoryURL.protocol());
if (!_sdSocket)
return qi::makeFutureError<void>(std::string("unrecognized protocol '") + serviceDirectoryURL.protocol() + "' in url '" + serviceDirectoryURL.str() + "'");
_sdSocketDisconnectedSignalLink = _sdSocket->disconnected.connect(&ServiceDirectoryClient::onSocketDisconnected, this, _1);
_remoteObject.setTransportSocket(_sdSocket);
qi::Promise<void> promise;
qi::Future<void> fut = _sdSocket->connect(serviceDirectoryURL);
fut.connect(&ServiceDirectoryClient::onSocketConnected, this, _1, promise);
return promise.future();
}
TestTask()
{
static bool init = false;
static qi::AnyObject tgs;
if (!init)
{
std::vector<std::string> objs = qi::loadObject("task");
qiLogInfo() << "loadobject gave " << objs.size();
if (objs.size() != 1)
throw std::runtime_error("Expected one object in taskService");
tgs = qi::createObject("TaskGenerator");
if (!tgs)
throw std::runtime_error("No TaskGenerator service found");
init = true;
}
taskGenService = tgs;
}
qi::Future<void> Session_SD::listenStandalone(const std::vector<qi::Url> &listenAddresses)
{
if (_init)
throw std::runtime_error("Already initialised");
_init = true;
_server->addObject(1, _serviceBoundObject);
std::ostringstream messInfo;
messInfo << "ServiceDirectory listener created on";
qi::FutureBarrier<void> barrier;
for (const qi::Url& url : listenAddresses)
{
messInfo << " " << url.str();
barrier.addFuture(_server->listen(url));
}
qiLogInfo() << messInfo.str();
qi::Promise<void> prom;
qi::adaptFuture(barrier.future(), prom);
qi::Future<void> f = prom.future();
std::map<unsigned int, ServiceInfo>::iterator it =
_sdObject->connectedServices.find(qi::Message::Service_ServiceDirectory);
if (it != _sdObject->connectedServices.end())
{
it->second.setEndpoints(_server->endpoints());
return f;
}
ServiceInfo si;
si.setName("ServiceDirectory");
si.setServiceId(qi::Message::Service_ServiceDirectory);
si.setMachineId(qi::os::getMachineId());
si.setProcessId(qi::os::getpid());
si.setSessionId("0");
si.setEndpoints(_server->endpoints());
unsigned int regid = _sdObject->registerService(si);
(void)regid;
_sdObject->serviceReady(qi::Message::Service_ServiceDirectory);
//serviceDirectory must have id '1'
QI_ASSERT(regid == qi::Message::Service_ServiceDirectory);
_server->_server.endpointsChanged.connect(boost::bind(&Session_SD::updateServiceInfo, this));
return f;
}
// define init method
void OnFaceDetection::init() {
try {
// check to see if there are faces present at module initialization
fFaces = fMemoryProxy.getData("FaceDetected");
if(fFaces.getSize() < 2) {
qiLogInfo("module.face") << "No faces detected" << std::endl;
fTextToSpeechProxy.say("I... can't... see you.");
}
// subscribe to "FaceDetected" event, with the appropriate callback function
fMemoryProxy.subscribeToEvent("FaceDetected", "OnFaceDetection", "callback");
} catch(const AL::ALError& error) {
qiLogError("module.face") << error.what() << std::endl;
}
}
qi::FutureSync<void> SessionPrivate::connect(const qi::Url &serviceDirectoryURL)
{
if (isConnected()) {
const char* s = "Session is already connected";
qiLogInfo() << s;
return qi::makeFutureError<void>(s);
}
_serverObject.open();
//add the servicedirectory object into the service cache (avoid having
// two remoteObject registered on the same transportSocket)
_serviceHandler.addService("ServiceDirectory", _sdClient.object());
_socketsCache.init();
qi::Future<void> f = _sdClient.connect(serviceDirectoryURL);
qi::Promise<void> p;
// go through hoops to get shared_ptr on this
f.connect(&SessionPrivate::addSdSocketToCache, this, _1, serviceDirectoryURL, p);
return p.future();
}
int main(int argc, char *argv[])
{
qi::Application app(argc, argv);
#if defined(WITH_BREAKPAD) && defined(GATEWAY_BUILD_TAG)
BreakpadExceptionHandler eh(BREAKPAD_DUMP_DIR);
eh.setBuildTag(GATEWAY_BUILD_TAG);
qiLogInfo() << "Build tag: " GATEWAY_BUILD_TAG;
#endif
// declare the program options
po::options_description desc("Usage:\n qi-service masterAddress [options]\nOptions");
desc.add_options()
("help", "Print this help.")
("qi-url",
po::value<std::string>()->default_value(std::string("tcp://127.0.0.1:9559")),
"The master address")
("qi-listen-url",
po::value<std::string>()->default_value(std::string("tcp://0.0.0.0:9559")),
"The gateway address")
("gateway-type",
po::value<std::string>()->default_value(std::string("local")),
"The gateway type");
// allow master address to be specified as the first arg
po::positional_options_description pos;
pos.add("master-address", 1);
// parse and store
po::variables_map vm;
try
{
po::store(po::command_line_parser(argc, argv).
options(desc).positional(pos).run(), vm);
po::notify(vm);
if (vm.count("help"))
{
std::cout << desc << "\n";
return EXIT_SUCCESS;
}
const std::string gatewayAddress = vm["qi-listen-url"].as<std::string>();
const std::string masterAddress = vm["qi-url"].as<std::string>();
const std::string gatewayType = vm["gateway-type"].as<std::string>();
if (gatewayType == "local")
{
qi::Gateway gateway;
bool ok = false;
for (unsigned i = 0; i < NB_RETRY_RECONNECT && !(ok = attachToServiceDirectory(gateway, qi::Url(masterAddress))); ++i)
{
qiLogInfo() << "Connection to SD failed, retrying in 2 seconds";
qi::sleepFor(RETRY_RECONNECT_WAIT);
}
if (!ok || !gateway.listen(gatewayAddress))
{
qiLogError() << "Failed to launch gateway.";
return EXIT_FAILURE;
}
qiLogInfo() << "Local gateway ready: " << gatewayAddress << std::endl;
app.run();
}
else if (gatewayType == "remote")
{
qiLogError() << "Not implemented";
return EXIT_FAILURE;
}
else if (gatewayType == "reverse")
{
qiLogError() << "Not implemented";
return EXIT_FAILURE;
}
else
{
qiLogError() << "unknown type: " << gatewayType;
return EXIT_FAILURE;
}
}
catch (const boost::program_options::error&)
{
qiLogError() << desc;
}
return EXIT_SUCCESS;
}
void cb(std::string s)
{
qiLogInfo() << "callback: said " << s;
}
std::string reply(const std::string &msg) {
qiLogInfo() << "Message recv:" << msg;
return msg + "bim";
}
qi::AnyValue reply(const qi::AnyValue &myval) {
static int i = 0;
qi::AnyReference val = qi::AnyReference::from(myval);
qiLogInfo() << i++ << " Message received with the signature: " << myval.signature(false).toString() << " = " << qi::encodeJSON(val) << std::endl;
return myval;
}
