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 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;
}
static int
_power_timeout_init(void)
{
/* Set up luna service */
psh = GetPalmService();
LSError lserror;
LSErrorInit(&lserror);
if (!LSPalmServiceRegisterCategory(psh,
"/timeout", timeout_methods /*public*/, NULL /*private*/, NULL, NULL, &lserror)) {
POWERDLOG(LOG_ERR, "%s could not register category: %s",
__FUNCTION__, lserror.message);
LSErrorFree(&lserror);
goto error;
}
if (!LSRegisterCategory(GetLunaServiceHandle(),
"/time", time_methods, NULL, NULL, &lserror))
{
goto error;
}
UEventListen("/com/palm/powerd/timechange/uevent", _timechange_callback);
return 0;
error:
return -1;
}
MojErr MojLunaService::addCategory(const MojChar* name, CategoryHandler* handler)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(name && handler);
MojAssertMutexUnlocked(m_mutex);
MojThreadGuard guard(m_mutex);
// create array of LSMethods
MethodVec pubMethods;
MethodVec privMethods;
const CategoryHandler::CallbackMap& callbacks = handler->callbacks();
for (CategoryHandler::CallbackMap::ConstIterator i = callbacks.begin();
i != callbacks.end();
i++) {
LSMethod m = {i.key(), &handleRequest};
MethodVec& methods = i->m_pub ? pubMethods : privMethods;
MojErr err = methods.push(m);
MojErrCheck(err);
}
LSMethod nullMethod = {NULL, NULL};
MojErr err = pubMethods.push(nullMethod);
MojErrCheck(err);
err = privMethods.push(nullMethod);
MojErrCheck(err);
// create category object to hang on to method array
MojRefCountedPtr<LunaCategory> cat(new LunaCategory(this, handler, pubMethods, privMethods));
MojAllocCheck(cat.get());
LSMethod* pubLsMethods = const_cast<LSMethod*>(cat->m_pubMethods.begin());
LSMethod* privLsMethods = const_cast<LSMethod*>(cat->m_privMethods.begin());
MojLunaErr lserr;
bool retVal;
if (m_service) {
retVal = LSPalmServiceRegisterCategory(m_service, name, pubLsMethods, privLsMethods, NULL, cat.get(), lserr);
MojLsErrCheck(retVal, lserr);
} else {
MojAssert(m_handle);
retVal = LSRegisterCategory(m_handle, name, privLsMethods, NULL, NULL, lserr);
MojLsErrCheck(retVal, lserr);
retVal = LSCategorySetData(m_handle, name, cat.get(), lserr);
MojLsErrCheck(retVal, lserr);
}
MojString categoryStr;
err = categoryStr.assign(name);
MojErrCheck(err);
err = m_categories.put(categoryStr, cat);
MojErrCheck(err);
return MojErrNone;
}
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;
}
void DeviceInfoService::setServiceHandle(LSPalmService* service)
{
m_service = service;
LSError lsError;
LSErrorInit(&lsError);
bool result = LSPalmServiceRegisterCategory(m_service, "/deviceInfo",
NULL, s_device_methods,
NULL, this, &lsError);
if (!result) {
qCritical() << "Failed in registering deviceinfo handler method:" << lsError.message;
LSErrorFree(&lsError);
return;
}
}
static int initialize_luna_service(void)
{
LSError error;
g_message("Initializing luna service ...");
LSErrorInit(&error);
if (!LSPalmServiceRegisterCategory(palm_service_handle, "/", NULL, service_methods,
NULL, NULL, &error)) {
g_warning("Could not register service category");
LSErrorFree(&error);
return -EIO;
}
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;
}
static int
com_palm_power_lunabus_init(void)
{
LSError lserror;
LSErrorInit(&lserror);
if (!LSPalmServiceRegisterCategory(GetPalmService(), "/com/palm/power",
com_palm_power_public_methods, com_palm_power_methods, com_palm_power_signals,
NULL, &lserror))
{
goto error;
}
return 0;
error:
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
return -1;
}
void TimeZoneService::setServiceHandle(LSPalmService* service)
{
m_service = service;
LSError lsError;
LSErrorInit(&lsError);
bool result = LSPalmServiceRegisterCategory(m_service, "/timezone",
s_methods, NULL,
NULL, this, &lsError);
if (!result) {
g_critical("Failed in registering timezone handler method: %s", lsError.message);
LSErrorFree(&lsError);
return;
}
m_serviceHandlePublic = LSPalmServiceGetPublicConnection(m_service);
m_serviceHandlePrivate = LSPalmServiceGetPrivateConnection(m_service);
}
bool register_methods(LSPalmService *serviceHandle, LSError lserror)
{
log("register_methods");
return LSPalmServiceRegisterCategory(serviceHandle, "/", luna_methods, NULL, NULL, NULL, &lserror);
}
