int main(int argc, char* argv[])
{
// Setup bad allocation handler
std::set_new_handler(badAllocationHandler);
#ifndef _WIN32
// ignore sigpipe...
struct sigaction sigh;
sigh.sa_handler = SIG_IGN;
sigh.sa_flags = 0;
sigemptyset(&sigh.sa_mask);
sigaction(SIGPIPE, &sigh, nullptr);
#endif
ServiceManager servicer;
g_dispatcher.start();
g_scheduler.start();
g_dispatcher.addTask(createTask(std::bind(mainLoader, argc, argv, &servicer)));
g_loaderSignal.wait(g_loaderUniqueLock);
if (servicer.is_running()) {
std::cout << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " Server Online!" << std::endl << std::endl;
#ifdef _WIN32
SetConsoleCtrlHandler([](DWORD) -> BOOL {
g_dispatcher.addTask(createTask([]() {
g_dispatcher.addTask(createTask(
std::bind(&Game::shutdown, &g_game)
));
g_scheduler.stop();
g_databaseTasks.stop();
g_dispatcher.stop();
}));
ExitThread(0);
}, 1);
#endif
servicer.run();
g_scheduler.join();
g_databaseTasks.join();
g_dispatcher.join();
} else {
std::cout << ">> No services running. The server is NOT online." << std::endl;
g_dispatcher.addTask(createTask([]() {
g_dispatcher.addTask(createTask([]() {
g_scheduler.shutdown();
g_databaseTasks.shutdown();
g_dispatcher.shutdown();
}));
g_scheduler.stop();
g_databaseTasks.stop();
g_dispatcher.stop();
}));
g_scheduler.join();
g_databaseTasks.join();
g_dispatcher.join();
}
return 0;
}
bool ApService::InitApService(std::string ApListenIp, int ApListenPort, int threadPoolNum) {
bool status = true;
_ApListenIp = ApListenIp;
_ApListenPort = ApListenPort;
_threadPoolNum = threadPoolNum;
SharedPointer<IProcessor> xp(
new apapiProcessor(
SharedPointer<apapi>(
new ApService)));
ServiceManager sm;
sm.add_service(xp);
ThreadPool tp;
tp.init(_threadPoolNum);
Server* server = new Server(&sm, &tp, _ApListenPort);
if (0 != server->serve()) {
status = false;
}
return status;
}
void DirectoryWalker::walk(const char* filename, const char* suffixes[],
bool recursive)
{
struct dirent *walker;
DIR *dir;
char tempName[1024];
dir = opendir(filename);
if (dir == NULL)
return;
while ((walker = readdir(dir)) != NULL)
{
if (_serviceMan->stopRequested())
{
_serviceMan->stopCompleted();
break;
}
if (strcmp(walker->d_name, "..") == 0 ||
strcmp(walker->d_name, ".") == 0)
continue;
if (walker->d_type == DT_DIR && recursive)
{
strcpy(tempName, filename);
strcat(tempName, "/");
strcat(tempName, walker->d_name);
walk(tempName, suffixes, recursive);
} else if (walker->d_type == DT_REG)
{
int i = 0;
const char *nextSuffix = suffixes[i++];
while (nextSuffix != NULL)
{
if (strstr(walker->d_name, nextSuffix) != 0)
{
strcpy(tempName, filename);
strcat(tempName, "/");
strcat(tempName, walker->d_name);
LabelablePtr label = new Labelable(); // Ice will clean up so don't delete
ImageSubstratePtr sub = new ImageSubstrate();
label->sub = sub;
sub->path.filename = std::string(walker->d_name);
sub->path.directory.relativePath = std::string(filename);
ResultSet res = (*_detectFunc)(_detect, tempName);
// put the "original" label into the result set
for (unsigned int idx=0; idx<res.results.size(); idx++)
{
res.results[idx].original = label;
}
_callback->foundNewResults(res);
}
nextSuffix = suffixes[i++];
}
}
}
}
WebResponse* CreateServiceHandler::Execute(WebRequest* pWebRequest, User* pUser)
{
ServiceManager* pServiceManager = NULL;
Service* pService = NULL;
CreateServiceRequest* pRequest = static_cast<CreateServiceRequest*>(pWebRequest);
g_uint user_id = pUser->GetID();
const char* name = pRequest->GetName();
const char* mapName = pRequest->GetMapName();
const char* uri = pRequest->GetURI();
pServiceManager = augeGetServiceManagerInstance();
if(pServiceManager->Has(user_id, name))
{
char msg[AUGE_MSG_MAX];
g_sprintf(msg, "%s already exists.", name);
WebExceptionResponse* pExpResponse = augeCreateWebExceptionResponse();
pExpResponse->SetMessage(msg);
return pExpResponse;
}
RESULTCODE rc = pServiceManager->Register(user_id,name,mapName,uri);
if(rc!=AG_SUCCESS)
{
GError* pError = augeGetErrorInstance();
WebExceptionResponse* pExpResponse = augeCreateWebExceptionResponse();
pExpResponse->SetMessage(pError->GetLastError());
return pExpResponse;
}
WebSuccessResponse* pSusResponse = augeCreateWebSuccessResponse();
pSusResponse->SetRequest("CreateService");
return pSusResponse;
}
bool RpcChannel::handleRequest(rpc::Message *messageEnvelope)
{
ServiceManager *mgr = ServiceManager::instance();
rpc::Request *request = messageEnvelope->mutable_request();
const FieldDescriptor *descriptor = this->extractDataField(request);
if (!descriptor) {
this->setErrorString("Unable to extract data field from message");
return false;
}
int methodId = descriptor->number();
ServiceDispatcher *dispatcher = mgr->lookupServiceDispatcher(methodId);
if(!dispatcher) {
std::ostringstream msg;
msg << "Can't load dispatcher for methodId: " << methodId;
this->setErrorString(msg.str());
return false;
}
const Reflection *reflection = request->GetReflection();
Message *in
= reflection->MutableMessage(request, descriptor);
dispatcher->dispatch(methodId, messageEnvelope, in, this);
return true;
}
void main(int argc, char** argv)
{
omsg("OmicronSDK - SAGEInputServer");
omsg("Copyright (C) 2010-2015 Electronic Visualization Laboratory\nUniversity of Illinois at Chicago");
omsg("======================================================");
omsg("");
SAGEInputServer app;
// Read config file name from command line or use default one.
const char* cfgName = "sageTouch.cfg";
if(argc == 2) cfgName = argv[1];
Config* cfg = new Config(cfgName);
DataManager* dm = DataManager::getInstance();
// Add a default filesystem data source using current work dir.
dm->addSource(new FilesystemDataSource("./"));
dm->addSource(new FilesystemDataSource(OMICRON_DATA_PATH));
ServiceManager* sm = new ServiceManager();
sm->setupAndStart(cfg);
Sleep(1000);
Setting& stRoot = cfg->getRootSetting()["config"];
if( stRoot.exists("sagePort") )
{
DIM_PORT = cfg->getIntValue("sagePort", stRoot, 20005);
ofmsg("SAGE port set to %1%", %DIM_PORT);
}
//--------------------------------------------------------------------------
// setServiceStatus:
//--------------------------------------------------------------------------
int setServiceState (ClientData clientData,
Tcl_Interp *interp,
int argc,
const char *argv[])
{
const char usageMessage[] =
"Usage: %s serviceId [HOLDING|ACTIVE|DISCARDING]";
if (argc != 3)
{
sprintf (interp->result,
usageMessage,
SET_SERVICE_STATE_CMD);
return TCL_ERROR;
}
const char *serviceId = argv[1];
const char *stateStr = argv[2];
try
{
PortableServer::POAManager::State state;
if (strcmp (stateStr, "HOLDING") == 0)
{
state = PortableServer::POAManager::HOLDING;
Tcl_SetResult (interp, "HOLDING", TCL_STATIC);
}
else if (strcmp (stateStr, "ACTIVE") == 0)
{
state = PortableServer::POAManager::ACTIVE;
Tcl_SetResult (interp, "ACTIVE", TCL_STATIC);
}
else if (strcmp (stateStr, "DISCARDING") == 0)
{
state = PortableServer::POAManager::DISCARDING;
Tcl_SetResult (interp, "DISCARDING", TCL_STATIC);
}
else
{
sprintf (interp->result,
usageMessage,
SET_SERVICE_STATE_CMD);
return TCL_ERROR;
}
ServiceManager *serviceManager = ServiceManager::instance();
serviceManager->setServiceState (serviceId, state);
}
catch (Exception &exp)
{
error ("%s:%d %s", exp.getFile (), exp.getLine (), exp.getMessage ());
interp->result = exp.getMessage ();
return TCL_ERROR;
}
return TCL_OK;
}
int main(int argc, char* argv[])
{
StringVec args = StringVec(argv, argv + argc);
if(argc > 1 && !argumentsHandler(args))
return 0;
std::set_new_handler(allocationHandler);
ServiceManager servicer;
g_config.startup();
#ifdef __OTSERV_ALLOCATOR_STATS__
boost::thread(boost::bind(&allocatorStatsThread, (void*)NULL));
// TODO: shutdown this thread?
#endif
#ifdef __EXCEPTION_TRACER__
ExceptionHandler mainExceptionHandler;
mainExceptionHandler.InstallHandler();
#endif
#ifndef WINDOWS
// ignore sigpipe...
struct sigaction sigh;
sigh.sa_handler = SIG_IGN;
sigh.sa_flags = 0;
sigemptyset(&sigh.sa_mask);
sigaction(SIGPIPE, &sigh, NULL);
// register signals
signal(SIGHUP, signalHandler); //save
signal(SIGTRAP, signalHandler); //clean
signal(SIGCHLD, signalHandler); //refresh
signal(SIGUSR1, signalHandler); //close server
signal(SIGUSR2, signalHandler); //open server
signal(SIGCONT, signalHandler); //reload all
signal(SIGQUIT, signalHandler); //save & shutdown
signal(SIGTERM, signalHandler); //shutdown
#endif
OutputHandler::getInstance();
Dispatcher::getInstance().addTask(createTask(boost::bind(otserv, args, &servicer)));
g_loaderSignal.wait(g_loaderUniqueLock);
if(servicer.isRunning())
{
std::clog << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " server Online!" << std::endl << std::endl;
servicer.run();
}
else
std::clog << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " server Offline! No services available..." << std::endl << std::endl;
#ifdef __EXCEPTION_TRACER__
mainExceptionHandler.RemoveHandler();
#endif
return 0;
}
void mouse_position_callback(GLFWwindow* window, double xpos, double ypos)
{
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->lockEvents();
Event* evt = sm->writeHead();
evt->reset(Event::Move, Service::Pointer);
evt->setPosition((float)xpos, (float)ypos);
evt->setFlags(sKeyFlags);
sm->unlockEvents();
}
void ServiceInstanceUnitTests::testGetDescription()
{
ServiceManager scm;
scm.Open();
ServiceInstance instance;
instance.Open(scm, L"W32Time");
std::wcout << std::endl << instance.GetDescription();
CPPUNIT_ASSERT(AppSecInc::StringUtils::startsWith(instance.GetDescription(),
L"Maintains date and time synchronization on all clients and servers in the network."));
}
void ServiceInstanceUnitTests::testGetServiceProcessStatus()
{
ServiceManager scm;
scm.Open();
ServiceInstance instance;
instance.Open(scm, L"Eventlog");
SERVICE_STATUS_PROCESS status = { 0 };
instance.GetServiceProcessStatus(& status);
std::wcout << std::endl << L"Process ID: " << status.dwProcessId;
CPPUNIT_ASSERT(0 != status.dwProcessId);
}
void mouse_scroll_callback(GLFWwindow* window, double x, double y)
{
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->lockEvents();
Event* evt = sm->writeHead();
evt->reset(Event::Zoom, Service::Pointer);
evt->setExtraDataType(Event::ExtraDataIntArray);
evt->setExtraDataInt(0, (int)y);
evt->setFlags(sKeyFlags);
sm->unlockEvents();
}
void ServiceInstanceUnitTests::testOpenClose()
{
ServiceManager scm;
scm.Open();
ServiceInstance Instance;
Instance.Open(scm, L"Eventlog");
CPPUNIT_ASSERT(Instance.IsOpen());
Instance.Close();
CPPUNIT_ASSERT(! Instance.IsOpen());
Instance.Open(scm, L"Winmgmt");
CPPUNIT_ASSERT(Instance.IsOpen());
}
void ServiceInstanceUnitTests::testGetConfig()
{
ServiceManager scm;
scm.Open();
ServiceInstance instance;
instance.Open(scm, L"W32Time");
ServiceConfig config = instance.GetConfig();
std::wcout << std::endl << config.service_start_name;
CPPUNIT_ASSERT(config.display_name == L"Windows Time");
std::wcout << std::endl << config.service_start_name;
CPPUNIT_ASSERT(config.service_start_name == L"LocalSystem" || config.service_start_name == L"NT AUTHORITY\\LocalService");
}
int main(int argc, char **argv)
{
Cgicc cgi;
cout<<"Content-type: text/html"<<endl<<endl;
cout<<"<html><head></head><body>"<<endl;
cout<<"hello world"<<endl;
DBconnector db;
db.testConnection();
const CgiEnvironment& env = cgi.getEnvironment();
string pathInfo = env.getPathInfo();
string var("");
string secondary("");
//parse_path_info(pathInfo);
Punct_stream ps(pathInfo);
ps.whitespace("/");
vector<string> vars;
while (ps>>var){
vars.push_back(var);
}
for (int i = 0; i < vars.size(); i++)
cout << vars[i];
ServiceManager sm;
sm.ServiceParser(vars);
if (env.getRequestMethod() == POST_METHOD){
cout << "POST";
//get POST content
}
if (env.getRequestMethod() == GET_METHOD){
cout << "GET";
//get GET content
}
string post = env.getPathInfo();
cout<<"<br>"<<endl;
cout<<post << endl;
cout<<"</body></html>"<<endl;
return 0;
}
void doFetch(std::list<RequestInfo>::iterator iter, ServiceIterator::ErrorType reason) {
/* FIXME: this does not acquire a lock--which will cause a problem
* if this class is destructed while we are executing doFetch.
*/
RequestInfo &info = *iter;
if (cleanup || !info.serviter) {
SILOG(transfer,error,"None of the services registered for " <<
info.fileId.uri() << " were successful.");
CacheLayer::getData(info.fileId, info.range, info.callback);
boost::unique_lock<boost::mutex> transfer_lock(mActiveTransferLock);
mActiveTransfers.erase(iter);
mCleanupCV.notify_one();
return;
}
URI lookupUri;
std::tr1::shared_ptr<DownloadHandler> handler;
ServiceParams params;
if (mService->getNextProtocol(info.serviter,reason,info.fileId.uri(),lookupUri,params,handler)) {
// info IS GETTING FREED BEFORE download RETURNS TO SET info.httpreq!!!!!!!!!
info.httpreq = DownloadHandler::TransferDataPtr();
handler->download(&info.httpreq, params, lookupUri, info.range,
std::tr1::bind(&NetworkCacheLayer::httpCallback, this, iter, _1, _2));
// info may be deleted by now (not so unlikely as it sounds -- it happens if you connect to localhost)
} else {
info.serviter = NULL; // deleted.
doFetch(iter, ServiceIterator::UNSUPPORTED);
}
}
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
// Ignore repeat events
if (action == GLFW_REPEAT) return;
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->lockEvents();
Event* evt = sm->writeHead();
Event::Type et = Event::Down;
if (action == GLFW_RELEASE) et = Event::Up;
evt->reset(et, Service::Keyboard, key);
evt->setExtraDataType(EventBase::ExtraDataIntArray);
evt->setExtraDataInt(0, scancode);
uint keyFlagsToRemove = 0;
HANDLE_KEY_FLAG(KEY_LEFT_ALT, Alt);
HANDLE_KEY_FLAG(KEY_LEFT_SHIFT, Shift);
HANDLE_KEY_FLAG(KEY_LEFT_CONTROL, Ctrl);
HANDLE_KEY_FLAG(KEY_RIGHT_ALT, Alt);
HANDLE_KEY_FLAG(KEY_RIGHT_SHIFT, Shift);
HANDLE_KEY_FLAG(KEY_RIGHT_CONTROL, Ctrl);
HANDLE_KEY_FLAG(KEY_LEFT, ButtonLeft);
HANDLE_KEY_FLAG(KEY_RIGHT, ButtonRight);
HANDLE_KEY_FLAG(KEY_UP, ButtonUp);
HANDLE_KEY_FLAG(KEY_DOWN, ButtonDown);
HANDLE_KEY_FLAG(KEY_ENTER, Button4);
//HANDLE_KEY_FLAG(KEY_BACKSPACE, Button5);
HANDLE_KEY_FLAG(KEY_TAB, Button6);
HANDLE_KEY_FLAG(KEY_HOME, Button7);
evt->setFlags(sKeyFlags);
// Remove the bit of all buttons that have been unpressed.
sKeyFlags &= ~keyFlagsToRemove;
// If ESC is pressed, request exit.
if (evt->isKeyDown(KEY_ESCAPE)) SystemManager::instance()->postExitRequest();
sm->unlockEvents();
}
void* server_func(const bool* isstopped, void*)
{
SharedPointer<IProcessor> xp(
new ManyClientsProcessor(
SharedPointer<ManyClients>(
new ManyClientsImpl)));
ServiceManager sm;
sm.add_service(xp);
ThreadPool tp;
tp.init(10);
Server* server = new Server(&sm, &tp, 8321);
if (0 != server->serve()) {
return 0;
}
return NULL;
}
void char_callback(GLFWwindow* window, unsigned int codepoint)
{
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->lockEvents();
char aChar = (char)codepoint;
String evtStr = string(1,aChar);
//omsg("creating Character Event");
Event* evt = sm->writeHead();
Event::Type et = Event::Down;
evt->reset(et, Service::Keyboard, 0);
evt->setExtraDataType(EventBase::ExtraDataString);
evt->setExtraDataString(evtStr);
evt->setFlags(sKeyFlags);
// int evtkey = key;
// evt->reset(et, Service::Keyboard, evtkey);
sm->unlockEvents();
}
void doNameLookup(const Callback &cb, const URI &origNamedUri, ServiceIterator *services, ServiceIterator::ErrorType reason) {
URI lookupUri;
ServiceParams params;
std::tr1::shared_ptr<NameLookupHandler> handler;
if (mNameServ->getNextProtocol(services,reason,origNamedUri,lookupUri,params,handler)) {
/// FIXME: Need a way of aborting a name lookup that is taking too long.
handler->nameLookup(NULL, lookupUri,
std::tr1::bind(&NameLookupManager::gotNameLookup, this, cb, origNamedUri, services, _1, _2, _3));
} else {
SILOG(transfer,warn,"None of the services registered for " <<
origNamedUri << " were successful for NameLookup.");
/// Hashed download.
if (mDownloadServ) {
mDownloadServ->lookupService(origNamedUri.context(),
std::tr1::bind(&NameLookupManager::hashedDownload, this, cb, origNamedUri, _1));
} else {
cb(origNamedUri, NULL);
}
return;
}
}
void ServiceInstanceUnitTests::testControl()
{
ServiceManager scm;
scm.Open();
ServiceInstance instance;
instance.Open(scm, L"W32Time");
if (! instance.IsStarted())
{
instance.Start();
instance.Wait();
}
CPPUNIT_ASSERT(instance.IsStarted());
instance.Stop();
CPPUNIT_ASSERT(instance.Wait());
CPPUNIT_ASSERT(! instance.IsStarted());
CPPUNIT_ASSERT(instance.IsStopped());
instance.Start();
CPPUNIT_ASSERT(instance.Wait());
CPPUNIT_ASSERT(instance.IsStarted());
}
void mouse_button_callback(GLFWwindow* window, int key, int action, int mods)
{
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->lockEvents();
Event* evt = sm->writeHead();
Event::Type et = Event::Down;
if (action == GLFW_RELEASE) et = Event::Up;
evt->reset(et, Service::Pointer);
uint keyFlagsToRemove = 0;
HANDLE_KEY_FLAG(GLFW_MOUSE_BUTTON_1, Button1);
HANDLE_KEY_FLAG(GLFW_MOUSE_BUTTON_2, Button2);
HANDLE_KEY_FLAG(GLFW_MOUSE_BUTTON_3, Button3);
evt->setFlags(sKeyFlags);
sKeyFlags &= ~keyFlagsToRemove;
sm->unlockEvents();
}
void ProgressMeter::check() {
// TODO
// if made progress since last time
// print progress
// reschedule
// else
// server->stop();
// For now, just stop after 10 seconds.
static int i=0;
if (++i == 10) {
std::cout << "stop" << std::endl;
service_->stop();
return;
}
std::cout << "." << std::flush;
Callback<void>* cb = makeCallableOnce(&ProgressMeter::check, this);
IOManager* io_manager = service_->io_manager();
io_manager->addTimer(1.0 /*sec*/ , cb);
}
void ServiceInstanceUnitTests::testCreateDelete()
{
ServiceManager scm;
scm.Open();
ServiceInstance instance;
AppSecInc::Service::ServiceCreateInfo create_info;
create_info.name = L"MsiExtDemoService";
if (scm.ServiceExists(create_info.name))
{
ServiceInstance deleteinstance;
deleteinstance.Open(scm, create_info.name);
deleteinstance.Delete();
}
create_info.binary_path_name = AppSecInc::File::DirectoryCombine(AppSecInc::File::GetModuleDirectoryW(), L"DemoService.exe");
CPPUNIT_ASSERT(AppSecInc::File::FileExists(create_info.binary_path_name));
instance.Create(scm, create_info);
try
{
{
ServiceInstance instance2;
instance2.Open(scm, create_info.name);
}
instance.Start();
instance.Wait();
CPPUNIT_ASSERT(instance.IsStarted());
instance.Stop();
instance.Delete();
}
catch(std::exception& ex)
{
std::wcout << std::endl << L"Unexpected exception: " << AppSecInc::StringUtils::mb2wc(ex.what());
instance.Delete();
throw;
}
}
int main(int argc, char* argv[])
{
// Setup bad allocation handler
std::set_new_handler(badAllocationHandler);
#ifndef WIN32
// ignore sigpipe...
struct sigaction sigh;
sigh.sa_handler = SIG_IGN;
sigh.sa_flags = 0;
sigemptyset(&sigh.sa_mask);
sigaction(SIGPIPE, &sigh, NULL);
#endif
ServiceManager servicer;
g_dispatcher.start();
g_scheduler.start();
g_dispatcher.addTask(createTask(boost::bind(mainLoader, argc, argv, &servicer)));
g_loaderSignal.wait(g_loaderUniqueLock);
if (servicer.is_running()) {
std::cout << ">> " << g_config.getString(ConfigManager::SERVER_NAME) << " Server Online!" << std::endl << std::endl;
servicer.run();
g_scheduler.join();
g_dispatcher.join();
} else {
std::cout << ">> No services running. The server is NOT online." << std::endl;
g_scheduler.stop();
g_dispatcher.stop();
g_dispatcher.addTask(createTask(boost::bind(shutdown)));
g_scheduler.join();
g_dispatcher.join();
}
return 0;
}
int main( int argc, char **argv){
log_open("server.cfg");
SharedPointer<IProcessor> proc_send(
new demo::CallbackSenderProcessor(
SharedPointer<callback_send_impl_t> (new callback_send_impl_t) ));
ServiceManager mgr;
mgr.add_service(proc_send);
ThreadPool pool;
pool.init(POOL_SIZE);
Server server(&mgr,&pool,LISTEN_PORT);
SharedPointer<Thread> thrd(new Thread( SharedPointer<Runnable>( new callback_send_thrd_t )));
thrd->start();
server.serve();
return 0;
}
void OTK_API omegaToolkitPythonApiInit()
{
static bool sApiInitialized = false;
if(!sApiInitialized)
{
omega::PythonInterpreter* interp = SystemManager::instance()->getScriptInterpreter();
interp->lockInterpreter();
sApiInitialized = true;
//omsg("omegaToolkitPythonApiInit()");
//MenuManager::mysInstance = NULL;
initomegaToolkit();
// import the module by default
interp->eval("from omegaToolkit import *");
interp->unlockInterpreter();
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->registerService("WandPointerSwitcher", (ServiceAllocator)WandPointerSwitcher::New);
}
}
void UiModule::initialize()
{
//omsg("UiModule initializing...");
myWidgetFactory = new ui::DefaultWidgetFactory(getEngine());
myUi = new ui::Container(getEngine());
myUi->setAutosize(false);
myUi->setLayout(ui::Container::LayoutFree);
myUi->setBlendMode(ui::Widget::BlendNormal);
Config* cfg = getEngine()->getSystemManager()->getAppConfig();
//myLocalEventsEnabled = cfg->getBoolValue("config/ui/enableLocalEvents", true);
myLocalEventsEnabled = true;
bool wandPointerSwitcher = false;
if(SystemManager::settingExists("config/ui"))
{
Setting& sUi = SystemManager::settingLookup("config/ui");
mysConfirmButton = Event::parseButtonName(Config::getStringValue("confirmButton", sUi, "Button3"));
mysCancelButton = Event::parseButtonName(Config::getStringValue("cancelButton", sUi, "Button4"));
mysClickButton = Event::parseButtonName(Config::getStringValue("clickButton", sUi, "Button1"));
myGamepadInteractionEnabled = Config::getBoolValue("gamepadInteractionEnabled", sUi, myGamepadInteractionEnabled);
myPointerInteractionEnabled = Config::getBoolValue("pointerInteractionEnabled", sUi, myPointerInteractionEnabled);
wandPointerSwitcher = Config::getBoolValue("wandPointerSwitcher", sUi, false);
}
if(wandPointerSwitcher)
{
omsg("Wand Pointer Switcher enabled.");
ServiceManager* sm = SystemManager::instance()->getServiceManager();
sm->addService(WandPointerSwitcher::New());
}
//omsg("UiModule initialization OK");
}
virtual void getData(const RemoteFileId &downloadFileId,
const Range &requestedRange,
const TransferCallback &callback) {
RequestInfo info(downloadFileId, requestedRange, callback);
SILOG(transfer,error,"NetworkCacheLayer: "<<downloadFileId.uri()<<" range "<<requestedRange);
std::list<RequestInfo>::iterator infoIter;
{
boost::unique_lock<boost::mutex> transfer_lock(mActiveTransferLock);
infoIter = mActiveTransfers.insert(mActiveTransfers.end(), info);
}
mService->lookupService(downloadFileId.uri().context(),
std::tr1::bind(&NetworkCacheLayer::gotServices, this, infoIter, _1));
}
int main(int argc, char** argv) {
Node n;
ServiceManager svcMgr;
Discovery disc(Discovery::MDNS);
disc.add(n);
// set some random properties to query for
ServiceDescription echoSvcDesc;
echoSvcDesc.setProperty("host", Host::getHostId());
echoSvcDesc.setProperty("someString", "this is some random string with 123 numbers inside");
echoSvcDesc.setProperty("someNumber", "1");
EchoService* echoSvc = new EchoService();
svcMgr.addService(echoSvc, echoSvcDesc);
PingService* pingSvc = new PingService();
svcMgr.addService(pingSvc);
n.connect(&svcMgr);
while(true)
Thread::sleepMs(1000);
}