bool service_register(const char *name) { bool rc; LSError err; LSErrorInit(&err); loop = g_main_loop_new(NULL, FALSE); if(loop == NULL) goto end; rc = LSRegisterPalmService(name, &handle, &err); if(rc) { pub = LSPalmServiceGetPublicConnection(handle); prv = LSPalmServiceGetPrivateConnection(handle); } else goto end; rc = LSPalmServiceRegisterCategory(handle, "/", methods, NULL, NULL, NULL, &err); LSGmainAttachPalmService(handle, loop, &err); if(!rc) goto end; end: if(LSErrorIsSet(&err)) { LSErrorPrint(&err, stderr); LSErrorFree(&err); puts("servece startup error..."); } return rc; }
bool luna_service_initialize(const char *dbusAddress) { bool returnVal = FALSE; LSError lserror; LSErrorInit(&lserror); loop = g_main_loop_new(NULL, FALSE); if (loop==NULL) goto end; returnVal = LSRegisterPalmService(dbusAddress, &serviceHandle, &lserror); if (returnVal) { pub_serviceHandle = LSPalmServiceGetPublicConnection(serviceHandle); priv_serviceHandle = LSPalmServiceGetPrivateConnection(serviceHandle); } else goto end; returnVal = register_methods(serviceHandle, lserror); if (returnVal) { LSGmainAttachPalmService(serviceHandle, loop, &lserror); } end: if (LSErrorIsSet(&lserror)) { LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); } return returnVal; }
void InputManager::startService() { LSError lserror; LSErrorInit(&lserror); bool result; GMainLoop* mainLoop = HostBase::instance()->mainLoop(); g_debug ("%s starting", __PRETTY_FUNCTION__); result = LSRegisterPalmService(LUNA_KEYS, &m_palmService, &lserror); if (!result) goto Error; // Save off public and private bus handles m_publicService = LSPalmServiceGetPublicConnection(m_palmService); if (NULL == m_publicService) { g_message("unable to get public handle"); } m_service = LSPalmServiceGetPrivateConnection(m_palmService); if (NULL == m_service) { g_message("unable to get private handle"); } // We're providing the notion of "key categories" that you can // subscribe to in order to get notifications when a key is pressed result = LSPalmServiceRegisterCategory(m_palmService, CATEGORY_AUDIO, s_audioMethods, NULL, NULL, this, &lserror); if (!result) goto Error; // For now the media keys are the only ones that have been requested // to be put on the public bus -- the calling syntax is a little // strange, but when using this call everything on the public bus // is also put on the private bus result = LSPalmServiceRegisterCategory(m_palmService, CATEGORY_MEDIA, s_mediaMethods, NULL, NULL, this, &lserror); if (!result) goto Error; result = LSPalmServiceRegisterCategory(m_palmService, CATEGORY_SWITCHES, s_switchesMethods, NULL, NULL, this, &lserror); if (!result) goto Error; result = LSPalmServiceRegisterCategory(m_palmService, CATEGORY_HEADSET, s_headsetMethods, NULL, NULL, this, &lserror); if (!result) goto Error; result = LSGmainAttachPalmService(m_palmService, mainLoop, &lserror); if (!result) goto Error; g_debug ("%s service started", LUNA_KEYS); return; Error: if (LSErrorIsSet(&lserror)) { LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); } g_debug(":%s: Unable to start service", __PRETTY_FUNCTION__); }
bool ImageServices::init(MainLoopProvider * p) { if (p == NULL) return false; //grab the main loop ptr from the provider m_p_mainloop = p->getMainLoopPtr(); if (m_p_mainloop == NULL) return false; //register the service LSError lsError; bool result; LSErrorInit(&lsError); // Register the service result = LSRegisterPalmService("com.palm.image", &m_service, &lsError); if (!result) { g_warning("Failed to register service: com.palm.image"); return false; } m_serviceHandlePublic = LSPalmServiceGetPublicConnection(m_service); m_serviceHandlePrivate = LSPalmServiceGetPrivateConnection(m_service); result = LSGmainAttachPalmService(m_service, m_p_mainloop, &lsError); if (!result) { g_warning("Failed to attach service handle to main loop"); LSErrorFree(&lsError); LSErrorInit(&lsError); result = LSUnregisterPalmService(m_service,&lsError); if (!result) LSErrorFree(&lsError); return false; } //register methods result = LSPalmServiceRegisterCategory( m_service, "/", s_methods_public, s_methods_private, NULL, this, &lsError); if (!result) { g_warning("Failed in registering handler methods on /: %s", lsError.message); LSErrorFree(&lsError); result = LSUnregisterPalmService(m_service,&lsError); if (!result) LSErrorFree(&lsError); return false; } return true; }
int main(int argc, char **argv) { LSError lserror; g_type_init(); g_log_set_handler (NULL, G_LOG_LEVEL_MASK, log_handler, NULL); signal(SIGTERM, signal_term_handler); signal(SIGINT, signal_term_handler); mainloop = g_main_loop_new(NULL, FALSE); LSErrorInit(&lserror); if (!LSRegisterPalmService("org.webosinternals.service.update", &palm_service_handle, &lserror)) { g_error("Failed to initialize the Luna Palm service: %s", lserror.message); LSErrorFree(&lserror); goto cleanup; } if (!LSGmainAttachPalmService(palm_service_handle, mainloop, &lserror)) { g_error("Failed to attach to glib mainloop for palm service: %s", lserror.message); LSErrorFree(&lserror); goto cleanup; } private_service_handle = LSPalmServiceGetPrivateConnection(palm_service_handle); initialize_luna_service(); g_main_loop_run(mainloop); cleanup: shutdown_luna_service(); if (palm_service_handle != NULL && LSUnregisterPalmService(palm_service_handle, &lserror) < 0) { g_error("Could not unregister palm service: %s", lserror.message); LSErrorFree(&lserror); } g_source_remove(signal); g_main_loop_unref(mainloop); return 0; }
bool SysmgrDebuggerService::startup() { LSError lserror; LSErrorInit(&lserror); bool result; if (m_p_service) { qWarning() << __FUNCTION__ << " will exit since it seems the service handle is already active; shutdown first" ; return true; } GMainLoop *mainLoop = HostBase::instance()->mainLoop(); result = LSRegisterPalmService("com.palm.sysmgrdebugger", &m_p_service, &lserror); if (!result) { qWarning() << __FUNCTION__ << " failed" ; LSErrorFree(&lserror); m_p_service = 0; return false; } result = LSPalmServiceRegisterCategory( m_p_service, "/", s_public_methods, s_private_methods, NULL, NULL, &lserror); if (!result) { qWarning() << __FUNCTION__ << " failed" ; LSErrorFree(&lserror); (void)shutdown(); return false; } result = LSGmainAttachPalmService(m_p_service, mainLoop, &lserror); if (!result) { qWarning() << __FUNCTION__ << " failed" ; LSErrorFree(&lserror); (void)shutdown(); return false; } //qDebug() << __FUNCTION__ << " Ok" ; return true; }
MojErr MojLunaService::attach(GMainLoop* loop) { MojAssert(loop); LOG_TRACE("Entering function %s", __FUNCTION__); MojLunaErr lserr; bool retVal; if (m_service) { retVal= LSGmainAttachPalmService(m_service, loop, lserr); MojLsErrCheck(retVal, lserr); } else { MojAssert(m_handle); retVal= LSGmainAttach(m_handle, loop, lserr); MojLsErrCheck(retVal, lserr); } m_loop = loop; return MojErrNone; }
/** * Connect to mediaserver using lunaservice. */ LSPalmService* SoundPlayer::connectToBus() { PRINTF_BLUE("SoundPlayer::connectToBus(%s)", getStateName()); VERIFY(m_state == eState_Connecting); setState(eState_Connecting); if (m_serviceHandle) return m_serviceHandle; bool result = true; LSError lserror; LSErrorInit(&lserror); result = LSRegisterPalmService(NULL, &m_serviceHandle, &lserror); if (!result) { CRITICAL("SoundPlayer::connectToBus: Could not register SoundPlayer"); LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); // Make next health check fail ASAP... m_lastPlayingTime = 0; return NULL; } result = LSGmainAttachPalmService (m_serviceHandle, HostBase::instance()->mainLoop(), &lserror); if (!result) { CRITICAL("SoundPlayer::connectToBus: Could not attach SoundPlayer to main loop"); LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); // Make next health check fail ASAP... m_lastPlayingTime = 0; return NULL; } return m_serviceHandle; }
/** * Main entry point for sleepd - runs the initialization hooks installed at program load time * * A bit counter-intuitively, this is not the first part of this program which * is run. * * First, everything which uses the {@link INIT_FUNC} macro in init.h are run, * which registers a bunch of hooks with the initialization system so that * individual modules can be registered without touching the main sleepd * initialization code. Then, once all of those hooks are installed, execution * proceeds to this function which actually runs those hooks. * * - Initializes sleepd. * - Attaches as a Luna service under com.palm.sleep. * - Attaches to Nyx. * - Subscribes to events related to the charger being plugged and unplugged from the com.palm.power service. * - Calls {@link TheOneInit()} to finish initialization of the service. * - Issues a request to the com.palm.power service to check on the plugged/unplugged status of the charger. * * @param argc Number of command-line arguments. * @param argv List of command-line arguments. * * @todo Move the logging initialization functionality into {@link TheOneInit()}. */ int main(int argc, char **argv) { bool retVal; /* * Register a function to be able to gracefully handle termination signals * from the OS or other processes. */ signal(SIGTERM, term_handler); signal(SIGINT, term_handler); #if !GLIB_CHECK_VERSION(2,32,0) if (!g_thread_supported()) { g_thread_init(NULL); } #endif mainloop = g_main_loop_new(NULL, FALSE); /* * initialize the lunaservice and we want it before all the init * stuff happening. */ LSError lserror; LSErrorInit(&lserror); /* * Register ourselves as the com.palm.sleep service. */ retVal = LSRegisterPalmService("com.palm.sleep", &psh, &lserror); if (retVal) { /* * Attach our main loop to the service so we can process IPC messages addressed to us. */ retVal = LSGmainAttachPalmService(psh, mainloop, &lserror); if (retVal) { /* * Get our private bus for our service so we can pass a message to com.palm.power. */ private_sh = LSPalmServiceGetPrivateConnection(psh); /* * Register with com.palm.power for events regarding changes in status * to the plug/unplug state of any chargers which may be attached to our * device. */ retVal = LSCall(private_sh, "luna://com.palm.lunabus/signal/addmatch", "{\"category\":\"/com/palm/power\"," "\"method\":\"USBDockStatus\"}", ChargerStatus, NULL, NULL, &lserror); if (retVal) { /* * Connect to Nyx so we can use it later. */ int ret = nyx_device_open(NYX_DEVICE_SYSTEM, "Main", &nyxSystem); if (ret != NYX_ERROR_NONE) { SLEEPDLOG_CRITICAL(MSGID_NYX_DEVICE_OPEN_FAIL, 1, PMLOGKS(CAUSE, "Unable to open the nyx device system"), ""); abort(); } /* * Call our main initialization function - this is the function which * is supposed to handle initializing pretty much everything for us. */ TheOneInit(); /* * Now that we've got something listening for charger status changes, * request the current state of the charger from com.palm.power. */ LSCall(private_sh, "luna://com.palm.power/com/palm/power/chargerStatusQuery", "{}", ChargerStatus, NULL, NULL, &lserror); SLEEPDLOG_DEBUG("Sleepd daemon started"); g_main_loop_run(mainloop); } } } else { SLEEPDLOG_CRITICAL(MSGID_SRVC_REGISTER_FAIL, 1, PMLOGKS(ERRTEXT, lserror.message), "Could not initialize sleepd"); LSErrorFree(&lserror); } g_main_loop_unref(mainloop); return 0; }
int main(int argc, char **argv) { GOptionContext *context; LSError lserror; GError *err = NULL; guint signal; struct telephony_service *service; g_message("Telephony Interface Layer Daemon %s", VERSION); g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_handler, NULL); context = g_option_context_new(NULL); g_option_context_add_main_entries(context, options, NULL); if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) { if (err != NULL) { g_printerr("%s\n", err->message); g_error_free(err); exit(1); } g_printerr("An unknown error occurred\n"); exit(1); } g_option_context_free(context); if (option_version == TRUE) { printf("%s\n", VERSION); exit(0); } if (option_detach == TRUE) { if (daemon(0, 0)) { perror("Can't start daemon"); return 1; } } signal = setup_signalfd(); event_loop = g_main_loop_new(NULL, FALSE); LSErrorInit(&lserror); if (!LSRegisterPalmService("com.palm.telephony", &palm_serivce_handle, &lserror)) { g_error("Failed to initialize the Luna Palm service: %s", lserror.message); LSErrorFree(&lserror); goto cleanup; } if (!LSGmainAttachPalmService(palm_serivce_handle, event_loop, &lserror)) { g_error("Failed to attach to glib mainloop for palm service: %s", lserror.message); LSErrorFree(&lserror); goto cleanup; } private_service_handle = LSPalmServiceGetPrivateConnection(palm_serivce_handle); service = telephony_service_create(palm_serivce_handle); /* FIXME this should be done as part of a plugin mechanism */ ofono_init(service); g_main_loop_run(event_loop); cleanup: /* FIXME this should be done as part of a plugin mechanism */ ofono_exit(service); telephony_service_free(service); if (palm_serivce_handle != NULL && LSUnregisterPalmService(palm_serivce_handle, &lserror) < 0) { g_error("Could not unregister palm service: %s", lserror.message); LSErrorFree(&lserror); } g_source_remove(signal); g_main_loop_unref(event_loop); return 0; }
int main(int argc, char **argv) { bool retVal; gboolean debug = FALSE; gboolean fake_battery = FALSE; gboolean visual_leds_suspend = FALSE; gboolean verbose = FALSE; gboolean err_on_crit = FALSE; gboolean fasthalt = FALSE; gint maxtemp = 0; gint temprate = 0; GOptionEntry entries[] = { {"debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "turn debug logging on", NULL}, {"use-fake-battery", 'b', 0, G_OPTION_ARG_NONE, &fake_battery, "Use fake battery", NULL}, {"visual-leds-suspend", 'l', 0, G_OPTION_ARG_NONE, &visual_leds_suspend, "Use LEDs to show wake/suspend state", NULL}, {"verbose-syslog", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Use Verbose syslog output", NULL}, {"error-on-critical", 'e', 0, G_OPTION_ARG_NONE, &err_on_crit, "Crash on critical error", NULL}, {"maxtemp", 'M', 0, G_OPTION_ARG_INT, &maxtemp, "Set maximum temperature before shutdown (default 60)", NULL}, {"temprate", 'T', 0, G_OPTION_ARG_INT, &temprate, "Expected maxiumum temperature slew rate (default 12)", NULL}, {"fasthalt", 'F', 0, G_OPTION_ARG_NONE, &fasthalt, "On overtemp, shut down quickly not cleanly", NULL}, { NULL } }; GError *error = NULL; GOptionContext *ctx; ctx = g_option_context_new(" - power daemon"); g_option_context_add_main_entries(ctx, entries, NULL); if (!g_option_context_parse(ctx, &argc, &argv, &error)) { g_critical("option parsing failed: %s", error->message); exit(1); } // FIXME integrate this into TheOneInit() LOGInit(); LOGSetHandler(LOGSyslog); if (debug) { powerd_debug = true; LOGSetLevel(G_LOG_LEVEL_DEBUG); LOGSetHandler(LOGGlibLog); } signal(SIGTERM, term_handler); signal(SIGINT, term_handler); if (!g_thread_supported ()) g_thread_init (NULL); mainloop = g_main_loop_new(NULL, FALSE); /** * initialize the lunaservice and we want it before all the init * stuff happening. */ LSError lserror; LSErrorInit(&lserror); retVal = LSRegisterPalmService("com.palm.power", &psh, &lserror); if (!retVal) { goto ls_error; } retVal = LSGmainAttachPalmService(psh, mainloop, &lserror); if (!retVal) { goto ls_error; } private_sh = LSPalmServiceGetPrivateConnection(psh); /** * Calls the init functions of all the modules in priority order. */ TheOneInit(); g_main_loop_run(mainloop); end: g_main_loop_unref(mainloop); // save time before quitting... timesaver_save(); return 0; ls_error: g_critical("Fatal - Could not initialize powerd. Is LunaService Down?. %s", lserror.message); LSErrorFree(&lserror); goto end; }
int main(int argc, char ** argv) { setenv("QT_PLUGIN_PATH","/usr/plugins",1); setenv("QT_QPA_PLATFORM", "minimal",1); QApplication app(argc, argv); parseCommandlineOptions(argc, argv); setLoglevel(Settings::settings()->m_logLevel.c_str()); g_log_set_default_handler(logFilter, NULL); g_warning("Started"); SystemRestore::createSpecialDirectories(); // Initialize the Preferences database (void) PrefsDb::instance(); ///and system restore (refresh settings while I'm at it...) SystemRestore::instance()->refreshDefaultSettings(); //run startup restore before anything else starts SystemRestore::startupConsistencyCheck(); Mainloop * mainLoopObj = new Mainloop(); g_gmainLoop = mainLoopObj->getMainLoopPtr(); //GMainLoop* mainLoop = g_main_loop_new(NULL, FALSE); LSPalmService* serviceHandle = NULL; LSError lsError; bool result; LSErrorInit(&lsError); // Register the service result = LSRegisterPalmService("com.palm.systemservice", &serviceHandle, &lsError); if (!result) { g_warning("Failed to register service: com.palm.sysservice"); return -1; } // LSHandle * serviceHandlePublic = LSPalmServiceGetPublicConnection(serviceHandle); LSHandle * serviceHandlePrivate = LSPalmServiceGetPrivateConnection(serviceHandle); result = LSGmainAttachPalmService(serviceHandle, g_gmainLoop, &lsError); if (!result) { g_warning("Failed to attach service handle to main loop"); return -1; } //turn novacom on if requested if (Settings::settings()->m_turnNovacomOnAtStartup) { turnNovacomOn(serviceHandlePrivate); } if ((result = LSCall(serviceHandlePrivate,"palm://com.palm.bus/signal/registerServerStatus", "{\"serviceName\":\"com.palm.image2\", \"subscribe\":true}", cbComPalmImage2Status,NULL,NULL, &lsError)) == false) { //non-fatal LSErrorFree(&lsError); LSErrorInit(&lsError); } // register for storage daemon signals result = LSCall(serviceHandlePrivate, "palm://com.palm.lunabus/signal/addmatch", "{\"category\":\"/storaged\", \"method\":\"MSMAvail\"}", SystemRestore::msmAvailCallback, NULL, SystemRestore::instance()->getLSStorageToken(), &lsError); if (!result) return -1; result = LSCall(serviceHandlePrivate, "palm://com.palm.lunabus/signal/addmatch", "{\"category\":\"/storaged\", \"method\":\"MSMProgress\"}", SystemRestore::msmProgressCallback, NULL, SystemRestore::instance()->getLSStorageToken(), &lsError); if (!result) return -1; result = LSCall(serviceHandlePrivate, "palm://com.palm.lunabus/signal/addmatch", "{\"category\":\"/storaged\", \"method\":\"MSMEntry\"}", SystemRestore::msmEntryCallback, NULL, SystemRestore::instance()->getLSStorageToken(), &lsError); if (!result) return -1; result = LSCall(serviceHandlePrivate, "palm://com.palm.lunabus/signal/addmatch", "{\"category\":\"/storaged\", \"method\":\"MSMFscking\"}", SystemRestore::msmFsckingCallback, NULL, SystemRestore::instance()->getLSStorageToken(), &lsError); if (!result) return -1; result = LSCall(serviceHandlePrivate, "palm://com.palm.lunabus/signal/addmatch", "{\"category\":\"/storaged\", \"method\":\"PartitionAvail\"}", SystemRestore::msmPartitionAvailCallback, NULL, SystemRestore::instance()->getLSStorageToken(), &lsError); if (!result) return -1; // Initialize the Prefs Factory PrefsFactory::instance()->setServiceHandle(serviceHandle); BackupManager::instance()->setServiceHandle(serviceHandle); //init the image service ImageServices * imgSvc = ImageServices::instance(mainLoopObj); if (!imgSvc) { g_warning("Image service failed init!"); } //init the timezone service; TimeZoneService* tzSvc = TimeZoneService::instance(); tzSvc->setServiceHandle(serviceHandle); // Run the main loop g_main_loop_run(g_gmainLoop); return 0; }
int main(int argc, char **argv) { bool retVal; // FIXME integrate this into TheOneInit() LOGInit(); LOGSetHandler(LOGSyslog); signal(SIGTERM, term_handler); signal(SIGINT, term_handler); if (!g_thread_supported ()) g_thread_init (NULL); mainloop = g_main_loop_new(NULL, FALSE); /** * initialize the lunaservice and we want it before all the init * stuff happening. */ LSError lserror; LSErrorInit(&lserror); retVal = LSRegisterPalmService("com.palm.sleep", &psh, &lserror); if (!retVal) { goto ls_error; } retVal = LSGmainAttachPalmService(psh, mainloop, &lserror); if (!retVal) { goto ls_error; } private_sh = LSPalmServiceGetPrivateConnection(psh); retVal = LSCall(private_sh,"luna://com.palm.lunabus/signal/addmatch","{\"category\":\"/com/palm/power\"," "\"method\":\"USBDockStatus\"}", ChargerStatus, NULL, NULL, &lserror); if (!retVal) { SLEEPDLOG(LOG_CRIT,"Error in registering for luna-signal \"chargerStatus\""); goto ls_error; } int ret = nyx_device_open(NYX_DEVICE_SYSTEM, "Main", &nyxSystem); if(ret != NYX_ERROR_NONE) { SLEEPDLOG(LOG_CRIT,"Sleepd: Unable to open the nyx device system"); abort(); } TheOneInit(); LSCall(private_sh,"luna://com.palm.power/com/palm/power/chargerStatusQuery","{}",ChargerStatus,NULL,NULL,&lserror); SLEEPDLOG(LOG_INFO,"Sleepd daemon started\n"); g_main_loop_run(mainloop); end: g_main_loop_unref(mainloop); return 0; ls_error: SLEEPDLOG(LOG_CRIT,"Fatal - Could not initialize sleepd. Is LunaService Down?. %s", lserror.message); LSErrorFree(&lserror); goto end; }