/** D-Bus callback for the MCE_CPU_KEEPALIVE_WAKEUP_REQ method call
*
* @param msg The D-Bus message
*
* @return TRUE on success, FALSE on failure
*/
static
gboolean
cka_dbus_handle_wakeup_cb(DBusMessage *const msg)
{
gboolean success = FALSE;
const char *sender = 0;
if( !(sender = dbus_message_get_sender(msg)) )
{
goto EXIT;
}
mce_log(LL_NOTICE, "got keepalive wakeup from %s",
mce_dbus_get_name_owner_ident(sender));
cka_clients_handle_wakeup(sender);
success = TRUE;
EXIT:
cka_dbusutil_reply_bool(msg, success);
return success;
}
/** Find existing / create new client data by dbus name
*
* @param dbus_name dbus name of the client
*
* @return client data
*/
static
cka_client_t *
cka_clients_add_client(const gchar *dbus_name)
{
cka_client_t *client = g_hash_table_lookup(cka_clients_lut, dbus_name);
if( !client )
{
/* Make a dummy peer identification request, so we have it already
* cached in case we actually need it later on */
mce_dbus_get_name_owner_ident(dbus_name);
/* The cka_client_create() adds NameOwnerChanged signal match
* so that we know when/if the client exits, crashes or
* otherwise loses dbus connection. */
client = cka_client_create(dbus_name);
g_hash_table_insert(cka_clients_lut, g_strdup(dbus_name), client);
/* Then make an explicit GetNameOwner request to verify that
* the client is still running when we have the signal
* listening in the place. */
cka_clients_verify_name(dbus_name);
}
return client;
}
/**
* D-Bus callback for the remove activity callback method call
*
* @param msg The D-Bus message
* @return TRUE on success, FALSE on failure
*/
static gboolean remove_activity_callback_dbus_cb(DBusMessage *const msg)
{
dbus_bool_t no_reply = dbus_message_get_no_reply(msg);
const gchar *sender = dbus_message_get_sender(msg);
gboolean status = FALSE;
if (sender == NULL) {
mce_log(LL_ERR,
"Received invalid remove activity callback request "
"(sender == NULL)");
goto EXIT;
}
mce_log(LL_DEVEL, "Received remove activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
status = TRUE;
remove_activity_cb(sender);
EXIT:
if (no_reply == FALSE) {
DBusMessage *reply = dbus_new_method_reply(msg);
status = dbus_send_message(reply);
} else {
status = TRUE;
}
return status;
}
/** D-Bus callback for the alarm queue status signal
*
* @param sig The D-Bus signal message
*
* @return TRUE
*/
static gboolean alarm_queue_status_dbus_cb(DBusMessage *const sig)
{
dbus_int32_t bootup = 0;
dbus_int32_t normal = 0;
DBusError error = DBUS_ERROR_INIT;
const gchar *sender = dbus_message_get_sender(sig);
mce_log(LL_DEVEL, "Received alarm queue status signal from %s",
mce_dbus_get_name_owner_ident(sender));
if( !dbus_message_get_args(sig, &error,
DBUS_TYPE_INT32, &bootup,
DBUS_TYPE_INT32, &normal,
DBUS_TYPE_INVALID) ) {
mce_log(LL_ERR, "Failed to parse arguments: %s: %s",
error.name, error.message);
goto EXIT;
}
/* DSME makes sure the device wakes up from suspend at
* the time when timed needs to trigger an alarm. MCE
* needs to make sure device does not get back to suspend
* before alarm ui has had sufficient time to start up
* and signal alarm dialog state.
*
* Timeds sends alarm queue status signal where the "next
* alarm time" has value of one when alarm has been triggered
* and alarm ui will be started up.
*/
queue_monitor_setup(sender, bootup == 1 || normal == 1);
EXIT:
dbus_error_free(&error);
return TRUE;
}
/**
* D-Bus callback for the alarm dialog status signal
*
* @param msg The D-Bus message
* @return TRUE on success, FALSE on failure
*/
static gboolean alarm_dialog_status_dbus_cb(DBusMessage *const msg)
{
alarm_ui_state_t alarm_ui_state = MCE_ALARM_UI_INVALID_INT32;
gboolean status = FALSE;
const gchar *sender = dbus_message_get_sender(msg);
DBusError error;
dbus_int32_t dialog_status;
/* Register error channel */
dbus_error_init(&error);
mce_log(LL_DEVEL, "Received alarm dialog status signal from %s",
mce_dbus_get_name_owner_ident(sender));
if (dbus_message_get_args(msg, &error,
DBUS_TYPE_INT32, &dialog_status,
DBUS_TYPE_INVALID) == FALSE) {
// XXX: should we return an error instead?
mce_log(LL_CRIT,
"Failed to get argument from %s.%s: %s",
VISUAL_REMINDERS_SIGNAL_IF,
VISUAL_REMINDER_STATUS_SIG,
error.message);
dbus_error_free(&error);
goto EXIT;
}
/* Convert alarm dialog status to to MCE alarm ui enum */
switch (dialog_status) {
case VISUAL_REMINDER_ON_SCREEN:
setup_alarm_dbus_monitor(sender);
alarm_ui_state = MCE_ALARM_UI_RINGING_INT32;
break;
case VISUAL_REMINDER_ON_SCREEN_NO_SOUND:
setup_alarm_dbus_monitor(sender);
alarm_ui_state = MCE_ALARM_UI_VISIBLE_INT32;
break;
case VISUAL_REMINDER_NOT_ON_SCREEN:
mce_dbus_owner_monitor_remove(sender, &alarm_owner_monitor_list);
alarm_ui_state = MCE_ALARM_UI_OFF_INT32;
break;
default:
mce_log(LL_ERR,
"Received invalid alarm dialog status; "
"defaulting to OFF");
alarm_ui_state = MCE_ALARM_UI_OFF_INT32;
break;
}
alarm_sync_state_to_datapipe(alarm_ui_state);
status = TRUE;
EXIT:
return status;
}
/** D-Bus callback for the add activity callback method call
*
* @param req The D-Bus message
*
* @return TRUE
*/
static gboolean mia_dbus_add_activity_action_cb(DBusMessage *const req)
{
const char *sender = dbus_message_get_sender(req);
DBusError err = DBUS_ERROR_INIT;
const char *service = 0;
const char *path = 0;
const char *interface = 0;
const char *method = 0;
dbus_bool_t res = false;
if( !sender )
goto EXIT;
mce_log(LL_DEVEL, "Add activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
if( !dbus_message_get_args(req, &err,
DBUS_TYPE_STRING, &service,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &method,
DBUS_TYPE_INVALID) ) {
mce_log(LL_ERR, "Failed to get arguments: %s: %s",
err.name, err.message);
goto EXIT;
}
res = mia_activity_action_add(sender, service, path, interface, method);
EXIT:
if( !dbus_message_get_no_reply(req) ) {
DBusMessage *rsp = dbus_new_method_reply(req);
if( !dbus_message_append_args(rsp,
DBUS_TYPE_BOOLEAN, &res,
DBUS_TYPE_INVALID) ) {
mce_log(LL_ERR, "Failed to append reply argument");
dbus_message_unref(rsp);
}
else {
dbus_send_message(rsp);
}
}
dbus_error_free(&err);
return TRUE;
}
/** D-Bus callback for the MCE_CPU_KEEPALIVE_STOP_REQ method call
*
* @param msg The D-Bus message
*
* @return TRUE on success, FALSE on failure
*/
static
gboolean
cka_dbus_handle_stop_cb(DBusMessage *const msg)
{
gboolean success = FALSE;
DBusError err = DBUS_ERROR_INIT;
const char *sender = 0;
const char *session_id = 0;
if( !(sender = dbus_message_get_sender(msg)) )
{
goto EXIT;
}
mce_log(LL_NOTICE, "got keepalive stop from %s",
mce_dbus_get_name_owner_ident(sender));
if( !dbus_message_get_args(msg, &err,
DBUS_TYPE_STRING, &session_id,
DBUS_TYPE_INVALID) )
{
// initial dbus interface did not include session_id string
if( strcmp(err.name, DBUS_ERROR_INVALID_ARGS) )
{
mce_log(LL_WARN, "%s: %s", err.name, err.message);
goto EXIT;
}
session_id = SESSION_ID_DEFAULT;
mce_log(LL_DEBUG, "sender did not supply session_id string; using '%s'",
session_id);
}
cka_clients_stop_session(sender, session_id);
success = TRUE;
EXIT:
cka_dbusutil_reply_bool(msg, success);
dbus_error_free(&err);
return success;
}
/** D-Bus callback for the MCE_CPU_KEEPALIVE_PERIOD_REQ method call
*
* @param msg The D-Bus message
*
* @return TRUE on success, FALSE on failure
*/
static
gboolean
cka_dbus_handle_period_cb(DBusMessage *const msg)
{
gboolean success = FALSE;
DBusError err = DBUS_ERROR_INIT;
const char *sender = 0;
const char *session_id = 0;
if( !(sender = dbus_message_get_sender(msg)) )
{
goto EXIT;
}
mce_log(LL_NOTICE, "got keepalive period query from %s",
mce_dbus_get_name_owner_ident(sender));
if( !dbus_message_get_args(msg, &err,
DBUS_TYPE_STRING, &session_id,
DBUS_TYPE_INVALID) )
{
// initial dbus interface did not include session_id string
if( strcmp(err.name, DBUS_ERROR_INVALID_ARGS) )
{
mce_log(LL_WARN, "%s: %s", err.name, err.message);
goto EXIT;
}
session_id = SESSION_ID_INITIAL;
mce_log(LL_DEBUG, "sender did not supply session_id string; using '%s'",
session_id);
}
cka_clients_add_session(sender, session_id);
success = cka_dbusutil_reply_int(msg, MCE_CPU_KEEPALIVE_SUGGESTED_PERIOD_S);
EXIT:
dbus_error_free(&err);
return success;
}
/** D-Bus callback for the remove activity callback method call
*
* @param req The D-Bus message
*
* @return TRUE
*/
static gboolean mia_dbus_remove_activity_action_cb(DBusMessage *const req)
{
const char *sender = dbus_message_get_sender(req);
if( !sender )
goto EXIT;
mce_log(LL_DEVEL, "Remove activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
mia_activity_action_remove(sender);
EXIT:
if( !dbus_message_get_no_reply(req) ) {
DBusMessage *reply = dbus_new_method_reply(req);
dbus_send_message(reply);
}
return TRUE;
}
/** Get client identification information
*
* @param self pointer to cka_client_t structure
*
* @return human readable string identifying the client process
*/
static
const char *
cka_client_identify(cka_client_t *self)
{
return mce_dbus_get_name_owner_ident(self->cli_dbus_name);
}
/**
* D-Bus callback for the add activity callback method call
*
* @param msg The D-Bus message
* @return TRUE on success, FALSE on failure
*/
static gboolean add_activity_callback_dbus_cb(DBusMessage *const msg)
{
dbus_bool_t no_reply = dbus_message_get_no_reply(msg);
const gchar *sender = dbus_message_get_sender(msg);
const gchar *service = NULL;
const gchar *path = NULL;
const gchar *interface = NULL;
const gchar *method_name = NULL;
activity_cb_t *tmp = NULL;
gboolean result = FALSE;
gboolean status = FALSE;
DBusError error;
/* Register error channel */
dbus_error_init(&error);
if (sender == NULL) {
mce_log(LL_ERR,
"Received invalid add activity callback request "
"(sender == NULL)");
goto EXIT;
}
mce_log(LL_DEVEL, "Received add activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
/* Extract result */
if (dbus_message_get_args(msg, &error,
DBUS_TYPE_STRING, &service,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &method_name,
DBUS_TYPE_INVALID) == FALSE) {
// XXX: should we return an error instead?
mce_log(LL_CRIT,
"Failed to get argument from %s.%s; %s",
MCE_REQUEST_IF, MCE_ADD_ACTIVITY_CALLBACK_REQ,
error.message);
dbus_error_free(&error);
goto EXIT;
}
if (mce_dbus_owner_monitor_add(sender,
activity_cb_monitor_dbus_cb,
&activity_cb_monitor_list,
ACTIVITY_CB_MAX_MONITORED) == -1) {
mce_log(LL_ERR,
"Failed to add name owner monitoring for `%s'",
sender);
goto EXIT2;
}
tmp = g_malloc(sizeof (activity_cb_t));
tmp->owner = g_strdup(sender);
tmp->service = g_strdup(service);
tmp->path = g_strdup(path);
tmp->interface = g_strdup(interface);
tmp->method_name = g_strdup(method_name);
activity_callbacks = g_slist_prepend(activity_callbacks, tmp);
result = TRUE;
EXIT2:
if (no_reply == FALSE) {
DBusMessage *reply = dbus_new_method_reply(msg);
if (dbus_message_append_args(reply,
DBUS_TYPE_BOOLEAN, &result,
DBUS_TYPE_INVALID) == FALSE) {
mce_log(LL_CRIT,
"Failed to append reply argument to "
"D-Bus message for %s.%s",
MCE_REQUEST_IF,
MCE_ADD_ACTIVITY_CALLBACK_REQ);
dbus_message_unref(reply);
goto EXIT;
}
status = dbus_send_message(reply);
} else {
status = TRUE;
}
EXIT:
return status;
}
