/** * @brief Called by test code to reset state machine to square 1. * * @retval */ static bool TESTresetShutdownState(LSHandle *sh, LSMessage *message, void *user_data) { LSMessageRef(message); LSCallOneReply(GetLunaServiceHandle(), SLEEPD_SHUTDOWN_SERVICE"TESTresetShutdownState", LSMessageGetPayload(message), shutdown_method_cb,(void *)message, NULL, NULL); return true; }
/** * @brief Ack the "shutdownApplications" signal. */ static bool shutdownApplicationsAck(LSHandle *sh, LSMessage *message, void *user_data) { LSMessageRef(message); LSCallOneReply(GetLunaServiceHandle(), SLEEPD_SHUTDOWN_SERVICE"shutdownApplicationsAck", LSMessageGetPayload(message), shutdown_method_cb,(void *)message, NULL, NULL); return true; }
static bool alarmRemove(LSHandle *sh, LSMessage *message, void *ctx) { LSMessageRef(message); LSCallOneReply(GetLunaServiceHandle(), "palm://com.palm.sleep/time/alarmRemove", LSMessageGetPayload(message), alarms_timeout_cb, (void *)message, NULL, NULL); return true; }
void EASPolicyManager::save() { if (!m_service) { g_warning ("Service handle not available yet, cannot query device policy"); return; } LSError lserror; LSErrorInit (&lserror); if (m_callToken) { g_debug ("Cancelling call token %lu", m_callToken); if (LSCallCancel (m_service, m_callToken, &lserror)) { g_warning ("Unable to cancel call with token %lu error message %s", m_callToken, lserror.message); } m_callToken = 0; } json_object* policyJson = m_aggregate->toNewJSON(); json_object_object_add(policyJson, "status", getPolicyStatus()); gchar* policyStr = g_strdup_printf ("{ \"objects\":[%s]}", json_object_to_json_string (policyJson)); g_message ("%s: Writing device policy %s to mojodb", __func__, policyStr); if (m_aggregate->m_id.empty()) { if (!LSCallOneReply (m_service, "palm://com.palm.db/put", policyStr, &EASPolicyManager::cbDevicePolicySaved, this, NULL, &lserror)) { g_warning ("%s: Failed at %s with message %s", __func__, lserror.func, lserror.message); LSErrorFree (&lserror); } } else { if (!LSCallOneReply (m_service, "palm://com.palm.db/merge", policyStr, &EASPolicyManager::cbDevicePolicySaved, this, NULL, &lserror)) { g_warning ("%s: Failed at %s with message %s", __func__, lserror.func, lserror.message); LSErrorFree (&lserror); } } json_object_put (policyJson); g_free (policyStr); }
void EASPolicyManager::querySecurityPolicies() { if (!m_service) { g_warning ("Service handle not available yet, cannot query device policy"); return; } LSError lserror; LSErrorInit (&lserror); gchar* query = g_strdup ("{\"query\":{\"from\":\"com.palm.securitypolicy:1\", \"incDel\" : true}}"); bool result = LSCallOneReply (m_service, "palm://com.palm.db/find", query, &EASPolicyManager::cbSecurityPolicy, this, NULL, &lserror); if (!result) { g_warning ("%s: Failed at %s with message %s", __func__, lserror.func, lserror.message); LSErrorFree (&lserror); } g_free (query); }
/** * @brief Add a new alarm based on calender time. Sets the callback function based on the "subscribe" option value. */ static bool alarmAddCalendar(LSHandle *sh, LSMessage *message, void *ctx) { struct json_object *object=NULL; object = json_tokener_parse(LSMessageGetPayload(message)); if ( is_error(object) ) { goto malformed_json; } struct json_object *subscribe_json = json_object_object_get(object, "subscribe"); bool subscribe = json_object_get_boolean(subscribe_json); LSMessageRef(message); if(subscribe) { struct context *alrm_ctx=NULL; alrm_ctx = malloc(sizeof(struct context)); if(!alrm_ctx) goto error; memset(alrm_ctx,0,sizeof(struct context)); alrm_ctx->replyMessage = message; LSCall(GetLunaServiceHandle(), "palm://com.palm.sleep/time/alarmAddCalender", LSMessageGetPayload(message), alarms_timeout_subscribe_cb, (void *)alrm_ctx, &alrm_ctx->call_token, NULL); } else LSCallOneReply(GetLunaServiceHandle(), "palm://com.palm.sleep/time/alarmAddCalender", LSMessageGetPayload(message), alarms_timeout_cb, (void *)message, NULL, NULL); goto cleanup; malformed_json: LSMessageReplyErrorBadJSON(sh, message); goto cleanup; error: POWERDLOG(LOG_ERR,"Failed to allocate memory"); LSMessageReplyErrorUnknown(sh, message); cleanup: if (!is_error(object)) json_object_put(object); return true; }
void EASPolicyManager::removeTemporaryPolicies() { if (!m_service) { g_warning ("Service handle not available yet, cannot query device policy"); return; } LSError lserror; LSErrorInit (&lserror); gchar* query = g_strdup ("{\"query\":{\"from\":\"com.palm.securitypolicy:1\", \"where\":[{\"prop\":\"isTemp\",\"op\":\"=\",\"val\":true}]}}"); g_debug ("%s: Calling %s with %s", __func__, "palm://com.palm.db/del", query); bool result = LSCallOneReply (m_service, "palm://com.palm.db/del", query, &EASPolicyManager::cbTempPoliciesDeleted, this, NULL, &lserror); if (!result) { g_warning ("%s: Failed at %s with message %s", __func__, lserror.func, lserror.message); LSErrorFree (&lserror); } g_free (query); }
static bool shutdownServicesRegister(LSHandle *sh, LSMessage *message, void *user_data) { LSMessageRef(message); LSCallOneReply(GetLunaServiceHandle(), SLEEPD_SHUTDOWN_SERVICE"shutdownServicesRegister", LSMessageGetPayload(message), shutdown_method_cb,(void *)message, NULL, NULL); bool retVal; LSError lserror; LSErrorInit(&lserror); retVal = LSSubscriptionAdd(sh, "shutdownClient", message, &lserror); if (!retVal) { g_critical("LSSubscriptionAdd failed."); LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); } return true; }
MojErr MojLunaService::sendImpl(MojServiceRequest* req, const MojChar* service, const MojChar* method, Token& tokenOut) { LOG_TRACE("Entering function %s", __FUNCTION__); MojAssert(req && service && method); MojAssert(m_service || m_handle); MojAssertMutexLocked(m_mutex); MojLunaRequest* lunaReq = static_cast<MojLunaRequest*>(req); const MojChar* json = lunaReq->payload(); LOG_DEBUG("[db_lunaService] request sent: %s", json); MojString uri; MojErr err = uri.format(_T("%s://%s/%s"), UriScheme, service, method); MojErrCheck(err); MojLunaErr lserr; LSMessageToken lsToken; LSHandle* handle = getHandle(lunaReq->onPublic()); if (req->numRepliesExpected() > 1) { if (!lunaReq->isProxyRequest()) { bool retVal = LSCall(handle, uri, json, &handleResponse, this, &lsToken, lserr); MojLsErrCheck(retVal, lserr); } else { bool retVal = LSCallFromApplication(handle, uri, json, lunaReq->getRequester(), &handleResponse, this, &lsToken, lserr); MojLsErrCheck(retVal, lserr); } } else { if (!lunaReq->isProxyRequest()) { bool retVal = LSCallOneReply(handle, uri, json, &handleResponse, this, &lsToken, lserr); MojLsErrCheck(retVal, lserr); } else { bool retVal = LSCallFromApplicationOneReply(handle, uri, json, lunaReq->getRequester(), &handleResponse, this, &lsToken, lserr); MojLsErrCheck(retVal, lserr); } } tokenOut = (Token) lsToken; return MojErrNone; }
static gpointer ClientProc(gpointer data) { GMainLoop *mainLoop = g_main_loop_new(NULL, FALSE); gpointer userData = mainLoop; g_timeout_add(10000, &OnTimeout, mainLoop); /*! [client call] */ bool retVal; LSError lserror; LSErrorInit(&lserror); LSMessageToken token = LSMESSAGE_TOKEN_INVALID; LSHandle *serviceHandle; retVal = LSRegister(NULL, &serviceHandle, &lserror); if (!retVal) goto error; retVal = LSCallOneReply(serviceHandle, "luna://com.palm.contacts/category/listContacts", "{ \"json payload\" }", listContactsHandler, userData, &token, &lserror); if (!retVal) goto error; LSGmainAttach(serviceHandle, mainLoop, &lserror); g_main_loop_run(mainLoop); /*! [client call] */ LSUnregister(serviceHandle, &lserror); g_main_loop_unref(mainLoop); g_main_loop_quit((GMainLoop *) data); // Finish the service with the client return GINT_TO_POINTER(0); error: LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); if (serviceHandle) LSUnregister(serviceHandle, &lserror); g_main_loop_unref(mainLoop); g_main_loop_quit((GMainLoop *) data); return GINT_TO_POINTER(1); }
bool LunaServiceCall::execute(const QString& uri, const QString& arguments) { LSError error; LSErrorInit(&error); QString errorMessage; if (mResponseLimit == 1) { if (!LSCallOneReply(mServiceHandle, uri.toUtf8().constData(), arguments.toUtf8().constData(), &LunaServiceCall::responseCallback, this, &mToken, &error)) { qWarning("Failed to call remote service %s", uri.toUtf8().constData()); errorMessage = QString("Failed to call remote service: %0").arg(error.message); goto error; } } else { if (!LSCall(mServiceHandle, uri.toUtf8().constData(), arguments.toUtf8().constData(), &LunaServiceCall::responseCallback, this, &mToken, &error)) { qWarning("Failed to call remote service %s", uri.toUtf8().constData()); errorMessage = QString("Failed to call remote service: %0").arg(error.message); goto error; } } return true; error: if (LSErrorIsSet(&error)) { LSErrorPrint(&error, stderr); LSErrorFree(&error); } if (mErrorCallback.isCallable()) mErrorCallback.call(QJSValueList() << errorMessage); return false; }
void InputManager::headsetStateMachine(QEvent* e) { switch (m_headsetBtnState) { case Start: { if (e->type() == QEvent::KeyPress) { m_headsetBtnState = SinglePressOrHold; m_headsetBtnTimer.start(PRESS_AND_HOLD_TIME_MS, true); // singleshot } // if we get an up in this state, we'll ignore it // that might happen if the user is holding the button down on // start up break; } case SinglePressOrHold: { if (e->type() == QEvent::KeyRelease) { m_headsetBtnTimer.stop(); // single press postKeyToSubscribers(NULL, CATEGORY_HEADSET, STR_HEADSET_BTN, HEADSET_BTN_SINGLE_PRESS); m_headsetBtnState = PotentialDoublePress; m_headsetBtnTimer.start(DOUBLE_PRESS_TIME_MS, true); // singleshot // FIXME: // We start an activity timer to make sure that // we don't go to sleep before the double-click // timer fires. LSCallOneReply(m_publicService, ACTIVITY_START_URI, ACTIVITY_JSON_MSG_HEADSET, activityStartCallback, NULL, NULL, NULL); } else { g_critical("%s: SinglePressOrHold state received event type: %d", __PRETTY_FUNCTION__, (int)e->type()); } break; } case Hold: { if (e->type() == QEvent::KeyRelease) { // make sure timer is stopped m_headsetBtnTimer.stop(); m_headsetBtnState = Start; } else { g_critical("%s: Hold state received event type: %d", __PRETTY_FUNCTION__, (int)e->type()); } break; } case PotentialDoublePress: { if (e->type() == QEvent::KeyPress) { m_headsetBtnTimer.stop(); m_headsetBtnState = DoublePressOrHold; m_headsetBtnTimer.start(PRESS_AND_HOLD_TIME_MS, true); // singleshot } else { g_critical("%s: Hold state received event type: %d", __PRETTY_FUNCTION__, (int)e->type()); } break; } case DoublePressOrHold: { if (e->type() == QEvent::KeyRelease) { m_headsetBtnTimer.stop(); // double press postKeyToSubscribers(NULL, CATEGORY_HEADSET, STR_HEADSET_BTN, HEADSET_BTN_DOUBLE_PRESS); m_headsetBtnState = Start; } break; } default: { g_critical("%s: Invalid headset state: %d", __PRETTY_FUNCTION__, (int)m_headsetBtnState); break; } } }