bool
nsNetworkManagerListener::HandleMessage(DBusMessage* message)
{
if (dbus_message_is_signal(message, NM_DBUS_INTERFACE,
NM_DBUS_SIGNAL_STATE_CHANGE) ||
dbus_message_is_signal(message, NM_DBUS_INTERFACE,
NM_DBUS_SIGNAL_STATE_CHANGED)) {
UpdateNetworkStatus(message);
return true;
}
return false;
}
bool CLogindUPowerSyscall::PumpPowerEvents(IPowerEventsCallback *callback)
{
bool result = false;
bool releaseLock = false;
if (m_connection)
{
dbus_connection_read_write(m_connection, 0);
DBusMessage *msg = dbus_connection_pop_message(m_connection);
if (msg)
{
if (dbus_message_is_signal(msg, "org.freedesktop.login1.Manager", "PrepareForSleep"))
{
dbus_bool_t arg;
// the boolean argument defines whether we are going to sleep (true) or just woke up (false)
dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &arg, DBUS_TYPE_INVALID);
CLog::Log(LOGDEBUG, "LogindUPowerSyscall: Received PrepareForSleep with arg %i", (int)arg);
if (arg)
{
callback->OnSleep();
releaseLock = true;
}
else
{
callback->OnWake();
InhibitDelayLock();
}
result = true;
}
else if (dbus_message_is_signal(msg, "org.freedesktop.UPower", "DeviceChanged"))
{
bool lowBattery = m_lowBattery;
UpdateBatteryLevel();
if (m_lowBattery && !lowBattery)
callback->OnLowBattery();
result = true;
}
else
CLog::Log(LOGDEBUG, "LogindUPowerSyscall - Received unknown signal %s", dbus_message_get_member(msg));
dbus_message_unref(msg);
}
}
if (releaseLock)
ReleaseDelayLock();
return result;
}
DBusHandlerResult a2dp_event_filter(DBusMessage *msg, JNIEnv *env) {
DBusError err;
if (!nat) {
LOGV("... skipping %s\n", __FUNCTION__);
LOGV("... ignored\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
dbus_error_init(&err);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_is_signal(msg, "org.bluez.AudioSink",
"PropertyChanged")) {
jobjectArray str_array =
parse_property_change(env, msg, (Properties *)&sink_properties,
sizeof(sink_properties) / sizeof(Properties));
const char *c_path = dbus_message_get_path(msg);
jstring path = env->NewStringUTF(c_path);
env->CallVoidMethod(nat->me,
method_onSinkPropertyChanged,
path,
str_array);
env->DeleteLocalRef(path);
result = DBUS_HANDLER_RESULT_HANDLED;
return result;
} else if (dbus_message_is_signal(msg, "org.bluez.Control",
"GetPlayStatus")) {
const char *c_path = dbus_message_get_path(msg);
jstring path = env->NewStringUTF(c_path);
env->CallVoidMethod(nat->me, method_onGetPlayStatusRequest, path);
env->DeleteLocalRef(path);
result = DBUS_HANDLER_RESULT_HANDLED;
return result;
}else {
LOGV("... ignored");
}
if (env->ExceptionCheck()) {
LOGE("VM Exception occurred while handling %s.%s (%s) in %s,"
" leaving for VM",
dbus_message_get_interface(msg), dbus_message_get_member(msg),
dbus_message_get_path(msg), __FUNCTION__);
}
return result;
}
/*
* This function gets called if a dbus message arrives that we have
* subscribed to.
*/
static DBusHandlerResult dbus_gotmessage(DBusConnection __unused *connection,
DBusMessage *message,
void __unused *user_data)
{
/* handle disconnect events first */
if (dbus_message_is_signal(message, DBUS_ERROR_DISCONNECTED,
"Disconnected")) {
/* FIXME: need to exit the gtk main loop here */
return DBUS_HANDLER_RESULT_HANDLED;
}
/* check if it's the daemon that asks for permission */
if (dbus_message_is_signal(message,
"org.kerneloops.submit.permission", "ask")) {
if (user_preference > 0) {
/* the user / config file says "always" */
send_permission("always");
} else if (user_preference < 0) {
/* the user / config file says "never" */
send_permission("never");
} else {
/* ok time to ask the user */
gtk_status_icon_set_visible(statusicon, TRUE);
dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &detail_file_name,
DBUS_TYPE_INVALID);
got_a_message();
gtk_status_icon_set_visible(statusicon, FALSE);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
/* check if it's the daemon that asks for permission */
if (dbus_message_is_signal(message,
"org.kerneloops.submit.sent", "sent")) {
gtk_status_icon_set_visible(statusicon, TRUE);
sent_an_oops();
gtk_status_icon_set_visible(statusicon, FALSE);
return DBUS_HANDLER_RESULT_HANDLED;
}
/* check if it's the daemon that asks for permission */
if (dbus_message_is_signal(message,
"org.kerneloops.submit.url", "url")) {
got_an_url(message);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
void onDbusMessage(DBusConnection *conn)
{
if ( !m_bus )
return;
DBusMessage* msg;
DBusMessageIter args;
DBusError err;
int ret;
char* sigvalue;
// non blocking read of the next available message
dbus_connection_read_write_dispatch(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't read a message
if (NULL == msg)
{
return;
}
//check if the message is a signal from the correct interface and with the correct name
if (dbus_message_is_signal (msg, "com.burtonini.dbus.Signal", "Ping"))
{
//read the parameters
if (!dbus_message_iter_init(msg, &args))
CRLog::error("dbus: Message Has No Parameters\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
CRLog::error("dbus: Argument is not string!\n");
else
{
dbus_message_iter_get_basic(&args, &sigvalue);
CRLog::info("dbus: Got Signal with value %s\n", sigvalue);
}
}
else if (dbus_message_is_signal (msg, "com.burtonini.dbus.Signal", "Exit"))
{
//read the parameters
if (!dbus_message_iter_init(msg, &args))
CRLog::error("dbus: Message Has No Parameters\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
CRLog::error("dbus: Argument is not string!\n");
else
{
dbus_message_iter_get_basic(&args, &sigvalue);
CRLog::info("dbus: Got Signal with value %s\n", sigvalue);
}
}
//free the message
dbus_message_unref(msg);
}
static DBusHandlerResult
mcd_client_registry_name_owner_filter (DBusConnection *conn,
DBusMessage *msg,
gpointer data)
{
McdClientRegistry *self = MCD_CLIENT_REGISTRY (data);
/* make sure this is the right kind of signal: */
if (dbus_message_is_signal (msg, DBUS_INTERFACE_DBUS, "NameOwnerChanged"))
{
const gchar *dbus_name = NULL;
const gchar *old_owner = NULL;
const gchar *new_owner = NULL;
gboolean ok = dbus_message_get_args (msg, NULL,
DBUS_TYPE_STRING, &dbus_name,
DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID);
/* could not unpack args -> invalid -> stop processing right here */
if (!ok)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (tp_str_empty (old_owner) && !tp_str_empty (new_owner))
_mcd_client_registry_found_name (self, dbus_name, new_owner, FALSE);
}
/* in case somebody else is also interested */
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
filter_func (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
dbus_bool_t handled = FALSE;
char *signal_text = NULL;
if (dbus_message_is_signal (message, "com.wiley.test", "TestSignal")) {
DBusError dberr;
dbus_error_init (&dberr);
dbus_message_get_args (message, &dberr, DBUS_TYPE_STRING, &signal_text, DBUS_TYPE_INVALID);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "Error getting message args: %s", dberr.message);
dbus_error_free (&dberr);
} else {
DBusConnection *dbconn = (DBusConnection*) user_data;
printf ("Received TestSignal with value of: '%s'\n", signal_text);
handled = TRUE;
}
}
return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}
static DBusHandlerResult filter (DBusConnection *conn, DBusMessage *msg,
void *arg) {
(void) conn;
(void) arg;
struct ep_list_head_s *head = &cb_list;
struct ep_list_node_s *node = NULL;
struct cb_data *data = NULL;
/* printf("libep: policy event received\n"); */
if (ep_list_empty(head))
goto end;
node = head->first;
while (node) {
data = node->data;
if (dbus_message_is_signal(msg, POLICY_DBUS_INTERFACE, data->signal)) {
handle_message(msg, data);
}
node = node->next;
}
end:
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
signal_filter(DBusConnection* connection, DBusMessage *message, void *user_data)
{
DBusError error;
struct context_thread_data* data=(struct context_thread_data*)user_data;
dbus_error_init(&error);
if (dbus_message_is_signal(message, SERVICE_NAME, "globalContextChanged"))
{
const char* previousContext;
const char* nextContext;
if (dbus_message_get_args(
message, &error,
DBUS_TYPE_STRING, &previousContext,
DBUS_TYPE_STRING, &nextContext,
DBUS_TYPE_INVALID))
{
qDebug("LibContext: Transit from %s to %s\n", previousContext, nextContext);
data->ccc(previousContext, nextContext, data->user_data);
}
else
{
qDebug("Cannot get arguments !!\n");
dbus_error_free(&error);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
system_filter_func (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
GaleonDbus *galeon_dbus = GALEON_DBUS (user_data);
GaleonDbusPrivate *priv = galeon_dbus->priv;
// LOG ("GaleonDbus filtering message from system bus");
if (dbus_message_is_signal (message,
DBUS_INTERFACE_LOCAL,
"Disconnected"))
{
// LOG ("GaleonDbus disconnected from system bus");
dbus_g_connection_unref (priv->system_bus);
priv->system_bus = NULL;
g_signal_emit (galeon_dbus, signals[DISCONNECTED], 0, GALEON_DBUS_SYSTEM);
/* try to reconnect later ... */
priv->system_reconnect_timeout_id =
g_timeout_add_seconds (RECONNECT_DELAY,
(GSourceFunc) galeon_dbus_connect_to_system_bus_cb,
galeon_dbus);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
client_disconnect_filter (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
if (!dbus_message_is_signal (message,
DBUS_INTERFACE_LOCAL,
"Disconnected"))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
_dbus_verbose ("Removing client %p in disconnect handler\n",
connection);
_dbus_list_remove (&clients, connection);
dbus_connection_unref (connection);
if (clients == NULL)
{
_dbus_loop_unref (client_loop);
client_loop = NULL;
}
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
dbus_energy_scan_handler(
DBusConnection *connection,
DBusMessage * message,
void * user_data
) {
DBusMessageIter iter;
int ret;
int16_t channel;
int8_t maxRssi;
if (!dbus_message_is_signal(message, WPANTUND_DBUS_APIv1_INTERFACE, WPANTUND_IF_SIGNAL_ENERGY_SCAN_RESULT)) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
dbus_message_iter_init(message, &iter);
ret = parse_energy_scan_result_from_iter(&channel, &maxRssi, &iter);
require_noerr(ret, bail);
printf(" %4d | %4d\n", channel, maxRssi);
bail:
return DBUS_HANDLER_RESULT_HANDLED;
}
static void check_bus() {
DBusMessage* msg;
DBusMessageIter args;
char *player, *oldowner, *newowner;
while(1) {
dbus_connection_read_write(dbus.session.connection, 0);
if(!(msg=dbus_connection_pop_message(dbus.session.connection)))
break;
if(dbus_message_is_signal(msg, dbus.interface, "NameOwnerChanged")) {
if(!(dbus_message_iter_init(msg, &args)&&dbus_message_iter_get_arg_type(&args)==DBUS_TYPE_STRING))
continue;
dbus_message_iter_get_basic(&args, &player);
dbus_message_iter_next(&args);
dbus_message_iter_get_basic(&args, &oldowner);
dbus_message_iter_next(&args);
dbus_message_iter_get_basic(&args, &newowner);
if(!strncmp(player, mpris.base, strlen(mpris.base))) {
if(!strlen(oldowner)&&strlen(newowner))
mediaplayer_register(player+strlen(mpris.base));
if(!strlen(newowner))
mediaplayer_deregister(player+strlen(mpris.base));
}
}
dbus_message_unref(msg);
}
}
static DBusHandlerResult
no_bus_server_filter (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
ServerData *sd = user_data;
if (dbus_message_is_signal (message,
DBUS_INTERFACE_LOCAL,
"Disconnected"))
{
g_printerr ("Client disconnected from server\n");
sd->n_clients -= 1;
if (sd->n_clients == 0)
g_main_loop_quit (sd->loop);
}
else if (dbus_message_is_method_call (message,
ECHO_INTERFACE,
ECHO_PING_METHOD))
{
sd->handled += 1;
send_echo_method_return (connection, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
filter_func(DBusConnection *connection, DBusMessage *message, void *usr_data)
{
dbus_bool_t handled = false;
char *word = NULL;
DBusError dberr;
int count=0;
if (dbus_message_is_signal(message, "imobile.buttonsd.Type", "Pressed")) {
dbus_error_init(&dberr);
dbus_message_get_args(message, &dberr, DBUS_TYPE_STRING, &word, DBUS_TYPE_INVALID);
if (dbus_error_is_set(&dberr)) {
dbus_error_free(&dberr);
} else {
for (count=0; count<5; count++) {
if ((strstr(word, "button:") == word) && (strstr(word, buttons[count].button) == (word+7))) {
system(buttons[count].command);
break;
}
}
handled = true;
}
}
return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}
DBusHandlerResult FcitxNotificationItemDBusFilter(DBusConnection* connection, DBusMessage* msg, void* user_data)
{
FcitxNotificationItem* notificationitem = (FcitxNotificationItem*) user_data;
if (dbus_message_is_signal(msg, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
const char* service, *oldowner, *newowner;
DBusError error;
dbus_error_init(&error);
do {
if (!dbus_message_get_args(msg, &error,
DBUS_TYPE_STRING, &service ,
DBUS_TYPE_STRING, &oldowner ,
DBUS_TYPE_STRING, &newowner ,
DBUS_TYPE_INVALID)) {
break;
}
/* old die and no new one */
if (strcmp(service, NOTIFICATION_WATCHER_DBUS_ADDR) != 0) {
break;
}
FcitxNotificationItemSetAvailable (notificationitem, strlen(newowner) > 0);
return DBUS_HANDLER_RESULT_HANDLED;
} while(0);
dbus_error_free(&error);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
void listen_signal()
{
DBusMessage * msg;
DBusMessageIter arg;
DBusConnection * connection;
DBusError err;
int ret;
char * sigvalue;
//步骤1:建立与D-Bus后台的连接
dbus_error_init(&err);
connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Connection Error %s/n",err.message);
dbus_error_free(&err);
}
if(connection == NULL)
return;
//步骤2:给连接名分配一个可记忆名字test.singal.dest作为Bus name，这个步骤不是必须的,但推荐这样处理
ret = dbus_bus_request_name(connection,"test.singal.dest",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Name Error %s/n",err.message);
dbus_error_free(&err);
}
if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
return;
//步骤3:通知D-Bus daemon，希望监听来行接口test.signal.Type的信号
dbus_bus_add_match(connection,"type='signal',interface='test.signal.Type'",&err);
//实际需要发送东西给daemon来通知希望监听的内容，所以需要flush
dbus_connection_flush(connection);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Match Error %s/n",err.message);
dbus_error_free(&err);
}
//步骤4:在循环中监听，每隔开1秒，就去试图自己的连接中获取这个信号。这里给出的是中连接中获取任何消息的方式，所以获取后去检查一下这个消息是否我们期望的信号，并获取内容。我们也可以通过这个方式来获取method call消息。
while(1){
dbus_connection_read_write(connection,0);
msg = dbus_connection_pop_message (connection);
if(msg == NULL)
{ printf("Sleeping\n");
sleep(10);
continue;
}
printf("received something\n");
if(dbus_message_is_signal(msg,"test.signal.Type","Test") ){
if(!dbus_message_iter_init(msg,&arg) )
fprintf(stderr,"Message Has no Param");
else if(dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_STRING)
fprintf(stderr,"Param is not string");
else
dbus_message_iter_get_basic(&arg,&sigvalue);
printf("Got Singal with value : %s\n\n",sigvalue);
}
dbus_message_unref(msg);
}//End of while
}
static DBusHandlerResult
with_or_without_bus_client_filter (DBusConnection *connection,
DBusMessage *message,
ClientData *cd)
{
if (dbus_message_is_signal (message,
DBUS_INTERFACE_LOCAL,
"Disconnected"))
{
g_printerr ("Client thread disconnected\n");
exit (1);
}
else if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
{
cd->iterations += 1;
if (cd->iterations >= N_ITERATIONS)
{
g_printerr ("\nCompleted %d iterations\n", N_ITERATIONS);
g_main_loop_quit (cd->loop);
}
else if (cd->iterations % (N_ITERATIONS/N_PROGRESS_UPDATES) == 0)
{
g_printerr ("%d%% ", (int) (cd->iterations/(double)N_ITERATIONS * 100.0));
}
send_echo_method_call (connection);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/** D-Bus message filter for handling NameOwnerChanged signals
*
* @param con dbus connection
* @param msg message to be acted upon
* @param user_data (not used)
*
* @return DBUS_HANDLER_RESULT_NOT_YET_HANDLED (other filters see the msg too)
*/
static
DBusHandlerResult
cpu_keepalive_dbus_filter_cb(DBusConnection *con, DBusMessage *msg,
void *user_data)
{
(void)user_data;
DBusHandlerResult res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
const char *sender = 0;
const char *object = 0;
const char *name = 0;
const char *prev = 0;
const char *curr = 0;
DBusError err = DBUS_ERROR_INIT;
if( con != systembus )
{
goto EXIT;
}
if( !dbus_message_is_signal(msg, DBUS_INTERFACE_DBUS, "NameOwnerChanged") )
{
goto EXIT;
}
sender = dbus_message_get_sender(msg);
if( strcmp(sender, DBUS_SERVICE_DBUS) )
{
goto EXIT;
}
object = dbus_message_get_path(msg);
if( strcmp(object, DBUS_PATH_DBUS) )
{
goto EXIT;
}
if( !dbus_message_get_args(msg, &err,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &prev,
DBUS_TYPE_STRING, &curr,
DBUS_TYPE_INVALID) )
{
mce_log(LL_WARN, "%s: %s", err.name, err.message);
goto EXIT;
}
if( !*curr )
{
mce_log(LL_INFO, "name lost owner: %s", name);
cpu_keepalive_remove_client(name);
}
EXIT:
dbus_error_free(&err);
return res;
}
static DBusHandlerResult
filter_session_message (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
dbus_bool_t *service_died_p = user_data;
const char *name, *old_owner, *new_owner;
if (dbus_message_is_signal (message,
DBUS_INTERFACE_DBUS,
"NameOwnerChanged") &&
dbus_message_has_sender (message, DBUS_SERVICE_DBUS) &&
dbus_message_get_args (message, NULL,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID) &&
strcmp (name, PRIVSERVER_SERVICE) == 0 &&
old_owner[0] != '\0' &&
new_owner[0] == '\0')
{
*service_died_p = TRUE;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult __dbus_event_filter(DBusConnection *sys_conn,
DBusMessage *msg, void *data)
{
char *member;
const char *path = dbus_message_get_path(msg);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (path == NULL || strcmp(path, "/") == 0)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
member = (char *)dbus_message_get_member(msg);
if (dbus_message_is_signal(msg, NETWORK_SERIAL_INTERFACE,
"ready_for_serial")) {
char *res = NULL;
dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &res,
DBUS_TYPE_INVALID);
if (g_strcmp0(res, "OK") == 0)
_send_serial_status_signal(SERIAL_OPENED);
} else {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
mce_signal_filter (DBusConnection *connection, DBusMessage *msg, void *user_data)
{
(void) connection;
(void) user_data;
if (dbus_message_is_signal(msg, MCE_SIGNAL_IF, MCE_LED_PATTERN_DEACTIVATED_SIG)) {
DBusError error;
dbus_error_init(&error);
gchar *pattern = NULL;
if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &pattern, DBUS_TYPE_INVALID)) {
N_WARNING ("%s >> failed to read MCE signal arguments, cause: %s", __FUNCTION__, error.message);
dbus_error_free(&error);
} else {
GList *event;
N_DEBUG ("%s >> mce finished playing %s", __FUNCTION__, pattern);
for (event = active_events; event != NULL; event = g_list_next(event)) {
MceData *data = (MceData *) event->data;
if (g_strcmp0(pattern, data->pattern) == 0) {
n_sink_interface_complete(data->iface, data->request);
N_DEBUG ("%s >> led pattern %s complete", __FUNCTION__, data->pattern);
active_events = g_list_remove_all(active_events, data);
break;
}
}
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
on_name_changed_filter (DBusConnection *connection, DBusMessage *message, void *user_data)
{
const char *object_name;
const char *new_owner;
const char *old_owner;
/* org.freedesktop.DBus.NameOwnerChanged(STRING name, STRING old_owner, STRING new_owner) */
if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged") &&
dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &object_name,
DBUS_TYPE_STRING, &old_owner, DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID)) {
/* See if it's the secret service going away */
if (object_name && g_str_equal (gkr_service_name (), object_name) &&
new_owner && g_str_equal ("", new_owner)) {
/* Clear any session, when the service goes away */
gkr_session_clear ();
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
signal_filter(DBusConnection *connection, DBusMessage *message, void *user_data) {
/* User data is the place to store the received position */
dbus_mm_pos_t *mmpos = user_data;
if(dbus_message_is_signal(message, MM_DBUS_SERVICE, "view_position_changed")) {
DBusError error;
double lat, lon;
long zoom;
dbus_error_init(&error);
if(dbus_message_get_args(message, &error,
DBUS_TYPE_DOUBLE, &lat,
DBUS_TYPE_DOUBLE, &lon,
DBUS_TYPE_INT32, &zoom,
DBUS_TYPE_INVALID)) {
g_print("MM: position received: %f/%f, zoom = %ld\n",
(float)lat, (float)lon, zoom);
/* store position for further processing */
mmpos->pos.lat = lat;
mmpos->pos.lon = lon;
mmpos->zoom = zoom;
mmpos->valid = TRUE;
} else {
g_print(" Error getting message: %s\n", error.message);
dbus_error_free (&error);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
dbus_beacon_handler(
DBusConnection *connection,
DBusMessage * message,
void * user_data
) {
DBusMessageIter iter;
int ret;
struct wpan_network_info_s network_info;
if (!dbus_message_is_signal(message, WPANTUND_DBUS_APIv1_INTERFACE, WPANTUND_IF_SIGNAL_NET_SCAN_BEACON)) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
dbus_message_iter_init(message, &iter);
ret = parse_network_info_from_iter(&network_info, &iter);
require_noerr(ret, bail);
if (network_info.network_name[0]) {
if (gScannedNetworkCount < SCANNED_NET_BUFFER_SIZE) {
gScannedNetworks[gScannedNetworkCount++] = network_info;
printf("%2d", gScannedNetworkCount);
} else {
printf("--"); //This means that we cannot act on the PAN as we do not save the info
}
} else {
printf(" ");
}
printf(" | %s", network_info.allowing_join ? " YES" : " NO");
if (network_info.network_name[0]) {
printf(" | \"%s\"%s",
network_info.network_name,
&" "[strlen(network_info.network_name)]);
} else {
printf(" | ------ NONE ------");
}
printf(" | 0x%04X", network_info.pan_id);
printf(" | %2d", network_info.channel);
printf(" | %016llX", (unsigned long long)network_info.xpanid);
printf(" | %02X%02X%02X%02X%02X%02X%02X%02X",
network_info.hwaddr[0],
network_info.hwaddr[1],
network_info.hwaddr[2],
network_info.hwaddr[3],
network_info.hwaddr[4],
network_info.hwaddr[5],
network_info.hwaddr[6],
network_info.hwaddr[7]);
printf(" | %4d", network_info.rssi);
printf("\n");
bail:
return DBUS_HANDLER_RESULT_HANDLED;
}
DBusHandlerResult
filter(DBusConnection *connection, DBusMessage *message, void *user_data)
{
dbg(0,"type=%s interface=%s path=%s member=%s signature=%s\n", dbus_message_type_to_string(dbus_message_get_type(message)), dbus_message_get_interface(message), dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_signature(message));
if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
gboolean
ibus_message_is_signal (IBusMessage *message,
const gchar *interface,
const gchar *signal_name)
{
return dbus_message_is_signal (message,
interface,
signal_name);
}
PRBool
nsNetworkManagerListener::HandleMessage(DBusMessage* message) {
if (dbus_message_is_signal(message, NM_DBUS_INTERFACE,
NM_DBUS_SIGNAL_STATE_CHANGE)) {
UpdateNetworkStatus(message);
return PR_TRUE;
}
return PR_FALSE;
}
static DBusHandlerResult
dsme_dbus_filter(DBusConnection *con, DBusMessage *msg, void *aptr)
{
if( dbus_message_is_signal(msg, DBUS_INTERFACE_LOCAL, "Disconnected") ) {
dsme_log(LOG_CRIT, "Disconnected from system bus; terminating");
dsme_exit(EXIT_FAILURE);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
hd_hildon_home_system_bus_signal_handler (DBusConnection *conn,
DBusMessage *msg, void *data)
{
if (dbus_message_is_signal(msg, DSME_SIGNAL_INTERFACE,
DSME_SHUTDOWN_SIGNAL_NAME))
gtk_main_quit ();
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
