char *sig;
dbus_message_iter_recurse(from, &fsub);
sig = dbus_message_iter_get_signature(&fsub);
- dbus_message_iter_open_container(to, type, sig, &tsub);
- copy_message(&fsub, &tsub);
- dbus_message_iter_close_container(to, &tsub);
+ if (dbus_message_iter_open_container(to, type, sig, &tsub))
+ {
+ copy_message(&fsub, &tsub);
+ dbus_message_iter_close_container(to, &tsub);
+ }
+ else
+ {
+ printf("ERR: container open failed\n");
+ }
}
}
dbus_message_iter_next(from);
return EINA_FALSE;
}
- dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &variant);
-
- snprintf(typestr, sizeof(typestr),
- (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- "%c"
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
- type);
-
- dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, typestr, &dict);
- dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
-
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
- if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
- dbus_message_iter_append_basic(&entry, type, &value);
+ if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &variant))
+ {
+ snprintf(typestr, sizeof(typestr),
+ (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ "%c"
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+ type);
+
+ if (dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, typestr, &dict))
+ {
+ if (dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
+ dbus_message_iter_append_basic(&entry, type, &value);
+ else
+ dbus_message_iter_append_basic(&entry, type, value);
+
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&variant, &dict);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&itr, &variant);
+ }
else
- dbus_message_iter_append_basic(&entry, type, value);
-
- dbus_message_iter_close_container(&dict, &entry);
- dbus_message_iter_close_container(&variant, &dict);
- dbus_message_iter_close_container(&itr, &variant);
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
return e_bluez_element_message_send
(element, name, NULL, msg, &element->_pending.property_set, cb, data);
typestr[0] = type;
typestr[1] = '\0';
- dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &v);
- if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
- {
- dbus_message_iter_append_basic(&v, type, &value);
- }
- else if (type == DBUS_TYPE_BOOLEAN)
+ if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &v))
{
- unsigned int b = *(char *)value;
- dbus_message_iter_append_basic(&v, type, &b);
+ if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
+ {
+ dbus_message_iter_append_basic(&v, type, &value);
+ }
+ else if (type == DBUS_TYPE_BOOLEAN)
+ {
+ unsigned int b = *(char *)value;
+ dbus_message_iter_append_basic(&v, type, &b);
+ }
+ else
+ {
+ dbus_message_iter_append_basic(&v, type, value);
+ }
+ dbus_message_iter_close_container(&itr, &v);
}
else
{
- dbus_message_iter_append_basic(&v, type, value);
+ ERR("dbus_message_iter_open_container() failed");
}
-
- dbus_message_iter_close_container(&itr, &v);
-
+
return e_bluez_element_message_send
(element, name, NULL, msg, &element->_pending.property_set, cb, data);
}
return EINA_FALSE;
}
- dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &variant);
-
- snprintf(typestr, sizeof(typestr),
- (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- "%c"
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
- type);
-
- dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, typestr, &dict);
- dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
-
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
- if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
- dbus_message_iter_append_basic(&entry, type, &value);
+ if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &variant))
+ {
+ snprintf(typestr, sizeof(typestr),
+ (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ "%c"
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+ type);
+ if (dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, typestr, &dict))
+ {
+ if (dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
+ dbus_message_iter_append_basic(&entry, type, &value);
+ else
+ dbus_message_iter_append_basic(&entry, type, value);
+
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&variant, &dict);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&itr, &variant);
+ }
else
- dbus_message_iter_append_basic(&entry, type, value);
-
- dbus_message_iter_close_container(&dict, &entry);
- dbus_message_iter_close_container(&variant, &dict);
- dbus_message_iter_close_container(&itr, &variant);
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
return e_connman_element_message_send
(element, name, NULL, msg, &element->_pending.property_set, cb, data);
typestr[0] = type;
typestr[1] = '\0';
- dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &v);
- if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
- {
- dbus_message_iter_append_basic(&v, type, &value);
- }
- else if (type == DBUS_TYPE_BOOLEAN)
+ if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &v))
{
- unsigned int b = *(char *)value;
- dbus_message_iter_append_basic(&v, type, &b);
+ if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
+ {
+ dbus_message_iter_append_basic(&v, type, &value);
+ }
+ else if (type == DBUS_TYPE_BOOLEAN)
+ {
+ unsigned int b = *(char *)value;
+ dbus_message_iter_append_basic(&v, type, &b);
+ }
+ else
+ {
+ dbus_message_iter_append_basic(&v, type, value);
+ }
+
+ dbus_message_iter_close_container(&itr, &v);
}
else
{
- dbus_message_iter_append_basic(&v, type, value);
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&itr, &v);
-
return e_connman_element_message_send
(element, name, NULL, msg, &element->_pending.property_set, cb, data);
}
dbus_message_iter_init_append(msg, &itr);
dbus_message_iter_append_basic(&itr, DBUS_TYPE_STRING, &prop);
- dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, array_sig,
- &variant);
- dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, type_sig,
- &array);
-
- if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH)
+ if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, array_sig, &variant))
{
- unsigned int i;
- for (i = 0; i < count; i++)
+ if (dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, type_sig, &array))
+ {
+ if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH)
+ {
+ unsigned int i;
+ for (i = 0; i < count; i++)
+ {
+ const void *entry = values[i];
+ dbus_message_iter_append_basic(&array, type, &entry);
+ }
+ }
+ else
+ {
+ unsigned int i;
+ for (i = 0; i < count; i++)
+ {
+ const void *entry = values[i];
+ dbus_message_iter_append_basic(&array, type, entry);
+ }
+ }
+
+ dbus_message_iter_close_container(&variant, &array);
+ }
+ else
{
- const void *entry = values[i];
- dbus_message_iter_append_basic(&array, type, &entry);
+ ERR("dbus_message_iter_open_container() failed");
}
+ dbus_message_iter_close_container(&itr, &variant);
}
else
{
- unsigned int i;
- for (i = 0; i < count; i++)
- {
- const void *entry = values[i];
- dbus_message_iter_append_basic(&array, type, entry);
- }
+ ERR("dbus_message_iter_open_container() failed");
}
-
- dbus_message_iter_close_container(&variant, &array);
- dbus_message_iter_close_container(&itr, &variant);
-
+
return e_connman_element_message_send(element, name, NULL, msg,
&element->_pending.property_set,
cb, data);
dbus_message_iter_append_basic
(&itr, DBUS_TYPE_STRING, &e_connman_prop_ipv4_configuration);
- dbus_message_iter_open_container
- (&itr, DBUS_TYPE_VARIANT,
- (DBUS_TYPE_ARRAY_AS_STRING
- DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
- &variant);
- dbus_message_iter_open_container
- (&variant, DBUS_TYPE_ARRAY,
- (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
- &dict);
-
- dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
- dbus_message_iter_append_basic
- (&entry, DBUS_TYPE_STRING, &e_connman_prop_method);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &method);
- dbus_message_iter_close_container(&dict, &entry);
-
- dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
- dbus_message_iter_append_basic
- (&entry, DBUS_TYPE_STRING, &e_connman_prop_address);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &address);
- dbus_message_iter_close_container(&dict, &entry);
-
- if (netmask)
+ if (dbus_message_iter_open_container
+ (&itr, DBUS_TYPE_VARIANT,
+ (DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+ &variant))
{
- dbus_message_iter_open_container
- (&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
- dbus_message_iter_append_basic
- (&entry, DBUS_TYPE_STRING, &e_connman_prop_netmask);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &netmask);
- dbus_message_iter_close_container(&dict, &entry);
+ if (dbus_message_iter_open_container
+ (&variant, DBUS_TYPE_ARRAY,
+ (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+ &dict))
+ {
+ if (dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic
+ (&entry, DBUS_TYPE_STRING, &e_connman_prop_method);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &method);
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ if (dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic
+ (&entry, DBUS_TYPE_STRING, &e_connman_prop_address);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &address);
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ if (netmask)
+ {
+ if (dbus_message_iter_open_container
+ (&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic
+ (&entry, DBUS_TYPE_STRING, &e_connman_prop_netmask);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &netmask);
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ }
+
+ if (gateway)
+ {
+ if (dbus_message_iter_open_container
+ (&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic
+ (&entry, DBUS_TYPE_STRING, &e_connman_prop_gateway);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &gateway);
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ }
+ dbus_message_iter_close_container(&variant, &dict);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&itr, &variant);
}
-
- if (gateway)
+ else
{
- dbus_message_iter_open_container
- (&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
- dbus_message_iter_append_basic
- (&entry, DBUS_TYPE_STRING, &e_connman_prop_gateway);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &gateway);
- dbus_message_iter_close_container(&dict, &entry);
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&variant, &dict);
- dbus_message_iter_close_container(&itr, &variant);
-
return e_connman_element_message_send
(service, name, NULL, msg, &service->_pending.property_set, cb, data);
}
dbus_message_iter_init_append(msg, &iter);
sig[0] = value_type;
sig[1] = 0;
- dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig, &sub);
- dbus_message_iter_append_basic(&sub, value_type, value);
- dbus_message_iter_close_container(&iter, &sub);
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig, &sub))
+ {
+ dbus_message_iter_append_basic(&sub, value_type, value);
+ dbus_message_iter_close_container(&iter, &sub);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
ret = e_dbus_message_send(conn, msg, cb_return, -1, (void *)data);
dbus_message_unref(msg);
{
reply = dbus_message_new_method_return(msg);
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, e_dbus_basic_type_as_string(type), &sub);
- dbus_message_iter_append_basic(&sub, type, &value);
- dbus_message_iter_close_container(&iter, &sub);
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, e_dbus_basic_type_as_string(type), &sub))
+ {
+ dbus_message_iter_append_basic(&sub, type, &value);
+ dbus_message_iter_close_container(&iter, &sub);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
return reply;
}
else
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &mount_point);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fstype);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
-
- if (options)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter))
{
- const char *opt;
-
- EINA_LIST_FOREACH(options, l, opt)
+ if (options)
{
- dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ {
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
}
+ dbus_message_iter_close_container(&iter, &subiter);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&iter, &subiter) ;
ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
dbus_message_unref(msg);
msg = e_hal_device_volume_call_new(udi, "Unmount");
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
- if (options)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter))
{
- const char *opt;
-
- EINA_LIST_FOREACH(options, l, opt)
+ if (options)
{
- dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ {
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
}
+ dbus_message_iter_close_container(&iter, &subiter);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&iter, &subiter) ;
ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
dbus_message_unref(msg);
msg = e_hal_device_volume_call_new(udi, "Eject");
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
- if (options)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter))
{
- const char *opt;
-
- EINA_LIST_FOREACH(options, l, opt)
+ if (options)
{
- dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ {
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
}
+ dbus_message_iter_close_container(&iter, &subiter);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&iter, &subiter) ;
ret = e_dbus_method_call_send(conn, msg, NULL, cb_func, NULL, -1, data);
dbus_message_unref(msg);
#include "e_notify_private.h"
#include <string.h>
-#define DBG(...) EINA_LOG_DOM_DBG(log_dom, __VA_ARGS__)
-#define INF(...) EINA_LOG_DOM_INFO(log_dom, __VA_ARGS__)
-#define WRN(...) EINA_LOG_DOM_WARN(log_dom, __VA_ARGS__)
-#define ERR(...) EINA_LOG_DOM_ERR(log_dom, __VA_ARGS__)
-#define CRIT(...) EINA_LOG_DOM_CRITICAL(log_dom, __VA_ARGS__)
-static int log_dom = -1;
static int init_count = 0;
static E_DBus_Interface *daemon_iface = NULL;
{
if (init_count) return ++init_count;
if (!e_dbus_init()) return 0;
- log_dom = eina_log_domain_register
- ("e_dbus_notification_daemon", E_DBUS_COLOR_DEFAULT);
- if (log_dom < 0)
- {
- ERR("Impossible to create e_dbus_notification_daemon domain");
- e_dbus_shutdown();
- return 0;
- }
daemon_iface = e_dbus_interface_new(E_NOTIFICATION_INTERFACE);
e_notification_daemon_shutdown(void)
{
if (--init_count) return init_count;
- eina_log_domain_unregister(log_dom);
e_dbus_shutdown();
return 0;
}
void e_notify_marshal_hint_image(DBusMessageIter *iter, E_Notification_Image *img);
E_Notification_Image * e_notify_unmarshal_hint_image(DBusMessageIter *iter);
+extern int _e_dbus_notify_log_dom;
#ifndef E_DBUS_COLOR_DEFAULT
#define E_DBUS_COLOR_DEFAULT EINA_COLOR_CYAN
#endif
+#undef DBG
+#undef INF
+#undef WRN
+#undef ERR
+
+#define DBG(...) EINA_LOG_DOM_DBG(_e_dbus_notify_log_dom, __VA_ARGS__)
+#define INF(...) EINA_LOG_DOM_INFO(_e_dbus_notify_log_dom, __VA_ARGS__)
+#define WRN(...) EINA_LOG_DOM_WARN(_e_dbus_notify_log_dom, __VA_ARGS__)
+#define ERR(...) EINA_LOG_DOM_ERR(_e_dbus_notify_log_dom, __VA_ARGS__)
+
struct E_Notification_Image
{
int width;
{
DBusMessageIter entry, variant;
- dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, "sv", &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
- dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, type_str, &variant);
- func(&variant, data);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(iter, &entry);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, "sv", &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+ if (dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, type_str, &variant))
+ {
+ func(&variant, data);
+ dbus_message_iter_close_container(&entry, &variant);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(iter, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
void
{
DBusMessageIter entry, variant;
- dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, "sv", &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
- dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &value);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(iter, &entry);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, "sv", &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+ if (dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant))
+ {
+ dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &value);
+ dbus_message_iter_close_container(&entry, &variant);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(iter, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
void
if (!key || !value) return;
- dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
- dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "y", &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_BYTE, &value);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(iter, &entry);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+ if (dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "y", &variant))
+ {
+ dbus_message_iter_append_basic(&variant, DBUS_TYPE_BYTE, &value);
+ dbus_message_iter_close_container(&entry, &variant);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(iter, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
void
if (!key || !value) return;
- dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, "sv", &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
- dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "i", &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_INT32, &value);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(iter, &entry);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, "sv", &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+ if (dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "i", &variant))
+ {
+ dbus_message_iter_append_basic(&variant, DBUS_TYPE_INT32, &value);
+ dbus_message_iter_close_container(&entry, &variant);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(iter, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
void
const char **str;
DBusMessageIter arr;
- dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "s", &arr);
-
- for (str = strings; *str; str++)
- dbus_message_iter_append_basic(&arr, DBUS_TYPE_STRING, str);
-
- dbus_message_iter_close_container(iter, &arr);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "s", &arr))
+ {
+ for (str = strings; *str; str++)
+ dbus_message_iter_append_basic(&arr, DBUS_TYPE_STRING, str);
+ dbus_message_iter_close_container(iter, &arr);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
void
DBusMessageIter arr;
Eina_List *l;
- dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "s", &arr);
-
- EINA_LIST_FOREACH (strings, l, str)
- dbus_message_iter_append_basic(&arr, DBUS_TYPE_STRING, &str);
-
- dbus_message_iter_close_container(iter, &arr);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "s", &arr))
+ {
+ EINA_LIST_FOREACH (strings, l, str)
+ dbus_message_iter_append_basic(&arr, DBUS_TYPE_STRING, &str);
+ dbus_message_iter_close_container(iter, &arr);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
Eina_List *
);
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub);
- if (n->actions)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub))
{
- E_Notification_Action *action;
- EINA_LIST_FOREACH (n->actions, l, action)
+ if (n->actions)
{
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &(action->id));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &(action->name));
+ E_Notification_Action *action;
+ EINA_LIST_FOREACH (n->actions, l, action)
+ {
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &(action->id));
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &(action->name));
+ }
}
+ dbus_message_iter_close_container(&iter, &sub);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&iter, &sub);
/* hints */
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub);
- if (n->hints.urgency) /* we only need to send this if its non-zero*/
- e_notify_marshal_dict_byte(&sub, "urgency", n->hints.urgency);
- if (n->hints.category)
- e_notify_marshal_dict_string(&sub, "category", n->hints.category);
- if (n->hints.desktop)
- e_notify_marshal_dict_string(&sub, "desktop_entry", n->hints.desktop);
- if (n->hints.image_data)
- e_notify_marshal_dict_variant(&sub, "image-data", "(iiibiiay)", E_DBUS_VARIANT_MARSHALLER(e_notify_marshal_hint_image), n->hints.image_data);
- if (n->hints.sound_file)
- e_notify_marshal_dict_string(&sub, "sound-file", n->hints.sound_file);
- if (n->hints.suppress_sound) /* we only need to send this if its true */
- e_notify_marshal_dict_byte(&sub, "suppress-sound", n->hints.suppress_sound);
- if (n->hints.x > -1 && n->hints.y > -1)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub))
{
- e_notify_marshal_dict_int(&sub, "x", n->hints.x);
- e_notify_marshal_dict_int(&sub, "y", n->hints.y);
+ if (n->hints.urgency) /* we only need to send this if its non-zero*/
+ e_notify_marshal_dict_byte(&sub, "urgency", n->hints.urgency);
+ if (n->hints.category)
+ e_notify_marshal_dict_string(&sub, "category", n->hints.category);
+ if (n->hints.desktop)
+ e_notify_marshal_dict_string(&sub, "desktop_entry", n->hints.desktop);
+ if (n->hints.image_data)
+ e_notify_marshal_dict_variant(&sub, "image-data", "(iiibiiay)", E_DBUS_VARIANT_MARSHALLER(e_notify_marshal_hint_image), n->hints.image_data);
+ if (n->hints.sound_file)
+ e_notify_marshal_dict_string(&sub, "sound-file", n->hints.sound_file);
+ if (n->hints.suppress_sound) /* we only need to send this if its true */
+ e_notify_marshal_dict_byte(&sub, "suppress-sound", n->hints.suppress_sound);
+ if (n->hints.x > -1 && n->hints.y > -1)
+ {
+ e_notify_marshal_dict_int(&sub, "x", n->hints.x);
+ e_notify_marshal_dict_int(&sub, "y", n->hints.y);
+ }
+ dbus_message_iter_close_container(&iter, &sub);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
}
-
- dbus_message_iter_close_container(&iter, &sub);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &(n->expire_timeout));
return msg;
}
int data_len = 0;
data_len = ((img->height - 1) * img->rowstride) + (img->width * (((img->channels * img->bits_per_sample) + 7) / 8));
- dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->width));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->height));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->rowstride));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_BOOLEAN, &(img->has_alpha));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->bits_per_sample));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->channels));
- dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &arr);
- dbus_message_iter_append_fixed_array(&arr, DBUS_TYPE_BYTE, &(img->data), data_len);
- dbus_message_iter_close_container(&sub, &arr);
- dbus_message_iter_close_container(iter, &sub);
+ if (dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &sub))
+ {
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->width));
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->height));
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->rowstride));
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_BOOLEAN, &(img->has_alpha));
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->bits_per_sample));
+ dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &(img->channels));
+ if (dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "y", &arr))
+ {
+ dbus_message_iter_append_fixed_array(&arr, DBUS_TYPE_BYTE, &(img->data), data_len);
+ dbus_message_iter_close_container(&sub, &arr);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(iter, &sub);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
}
E_Notification_Image *
static E_Notification_Action *e_notification_action_new(const char *id,
const char *name);
+int _e_dbus_notify_log_dom = -1;
+
+static void
+loginit(void)
+{
+ if (_e_dbus_notify_log_dom == -1)
+ _e_dbus_notify_log_dom = eina_log_domain_register("e_dbus_notify", E_DBUS_COLOR_DEFAULT);
+}
+
/* (con|de)structor */
EAPI E_Notification *
{
E_Notification *n;
+ loginit();
n = e_notification_new();
if (!n) return NULL;
e_notification_new(void)
{
E_Notification *n;
+
+ loginit();
n = calloc(1, sizeof(E_Notification));
if (!n) return NULL;
n->refcount = 1;
EAPI void
e_notification_ref(E_Notification *n)
{
+ loginit();
n->refcount++;
}
EAPI void
e_notification_unref(E_Notification *n)
{
+ loginit();
if (--n->refcount == 0) e_notification_free(n);
}
EAPI void
e_notification_free(E_Notification *n)
{
+ loginit();
if (!n) return;
eina_stringshare_del(n->app_name);
EAPI void
e_notification_id_set(E_Notification *note, unsigned int id)
{
+ loginit();
note->id = id;
}
EAPI void
e_notification_app_name_set(E_Notification *note, const char *app_name)
{
+ loginit();
eina_stringshare_replace(¬e->app_name, app_name);
}
EAPI void
e_notification_app_icon_set(E_Notification *note, const char *app_icon)
{
+ loginit();
eina_stringshare_replace(¬e->app_icon, app_icon);
}
EAPI void
e_notification_summary_set(E_Notification *note, const char *summary)
{
+ loginit();
eina_stringshare_replace(¬e->summary, summary);
}
EAPI void
e_notification_body_set(E_Notification *note, const char *body)
{
+ loginit();
eina_stringshare_replace(¬e->body, body);
}
{
E_Notification_Action *a;
+ loginit();
if (!n->actions)
n->actions = e_notification_action_list_new();
EAPI void
e_notification_replaces_id_set(E_Notification *note, int replaces_id)
{
+ loginit();
note->replaces_id = replaces_id;
}
EAPI void
e_notification_timeout_set(E_Notification *note, int timeout)
{
+ loginit();
note->expire_timeout = timeout;
}
EAPI void
e_notification_closed_set(E_Notification *note, unsigned char closed)
{
+ loginit();
note->closed = closed;
}
EAPI unsigned int
e_notification_id_get(E_Notification *note)
{
+ loginit();
return note->id;
}
EAPI const char *
e_notification_app_name_get(E_Notification *note)
{
+ loginit();
return note->app_name;
}
EAPI const char *
e_notification_app_icon_get(E_Notification *note)
{
+ loginit();
return note->app_icon;
}
EAPI const char *
e_notification_summary_get(E_Notification *note)
{
+ loginit();
return note->summary;
}
EAPI const char *
e_notification_body_get(E_Notification *note)
{
+ loginit();
return note->body;
}
EAPI Eina_List *
e_notification_actions_get(E_Notification *note)
{
+ loginit();
return note->actions;
}
EAPI int
e_notification_replaces_id_get(E_Notification *note)
{
+ loginit();
return note->replaces_id;
}
EAPI int
e_notification_timeout_get(E_Notification *note)
{
+ loginit();
return note->expire_timeout;
}
EAPI unsigned char
e_notification_closed_get(E_Notification *note)
{
+ loginit();
return note->closed;
}
{
Eina_List *alist;
+ loginit();
alist = NULL;
return alist;
}
e_notification_action_new(const char *id, const char *name)
{
E_Notification_Action *act;
+
+ loginit();
act = malloc(sizeof(E_Notification_Action));
act->id = eina_stringshare_add(id);
act->name = eina_stringshare_add(name);
EAPI const char *
e_notification_action_id_get(E_Notification_Action *a)
{
+ loginit();
EINA_SAFETY_ON_NULL_RETURN_VAL(a, NULL);
return a->id;
}
EAPI const char *
e_notification_action_name_get(E_Notification_Action *a)
{
+ loginit();
EINA_SAFETY_ON_NULL_RETURN_VAL(a, NULL);
return a->name;
}
EAPI void
e_notification_hint_transient_set(E_Notification *n, Eina_Bool transient)
{
+ loginit();
if (transient)
n->hint_flags |= E_NOTIFICATION_HINT_TRANSIENT;
else
EAPI void
e_notification_hint_resident_set(E_Notification *n, Eina_Bool resident)
{
+ loginit();
if (resident)
n->hint_flags |= E_NOTIFICATION_HINT_RESIDENT;
else
EAPI void
e_notification_hint_action_icons_set(E_Notification *n, Eina_Bool action_icons)
{
+ loginit();
if (action_icons)
n->hint_flags |= E_NOTIFICATION_HINT_ACTION_ICONS;
else
EAPI void
e_notification_hint_urgency_set(E_Notification *n, char urgency)
{
+ loginit();
n->hints.urgency = urgency;
n->hint_flags |= E_NOTIFICATION_HINT_URGENCY;
}
EAPI void
e_notification_hint_image_path_set(E_Notification *n, const char *path)
{
+ loginit();
eina_stringshare_replace(&n->hints.image_path, path);
}
EAPI void
e_notification_hint_category_set(E_Notification *n, const char *category)
{
+ loginit();
eina_stringshare_replace(&n->hints.category, category);
n->hint_flags |= E_NOTIFICATION_HINT_CATEGORY;
}
EAPI void
e_notification_hint_desktop_set(E_Notification *n, const char *desktop)
{
+ loginit();
eina_stringshare_replace(&n->hints.desktop, desktop);
n->hint_flags |= E_NOTIFICATION_HINT_DESKTOP;
}
EAPI void
e_notification_hint_sound_file_set(E_Notification *n, const char *sound_file)
{
+ loginit();
eina_stringshare_replace(&n->hints.sound_file, sound_file);
n->hint_flags |= E_NOTIFICATION_HINT_SOUND_FILE;
}
EAPI void
e_notification_hint_suppress_sound_set(E_Notification *n, char suppress_sound)
{
+ loginit();
n->hints.suppress_sound = suppress_sound;
n->hint_flags |= E_NOTIFICATION_HINT_SUPPRESS_SOUND;
}
EAPI void
e_notification_hint_xy_set(E_Notification *n, int x, int y)
{
+ loginit();
n->hints.x = x;
n->hints.y = y;
n->hint_flags |= E_NOTIFICATION_HINT_XY;
EAPI void
e_notification_hint_image_data_set(E_Notification *n, E_Notification_Image *image)
{
+ loginit();
n->hints.image_data = image;
}
EAPI char
e_notification_hint_urgency_get(E_Notification *n)
{
+ loginit();
return n->hint_flags & E_NOTIFICATION_HINT_URGENCY ? n->hints.urgency : 1;
}
EAPI const char *
e_notification_hint_category_get(E_Notification *n)
{
+ loginit();
return n->hints.category;
}
EAPI const char *
e_notification_hint_desktop_get(E_Notification *n)
{
+ loginit();
return n->hints.desktop;
}
EAPI const char *
e_notification_hint_image_path_get(E_Notification *n)
{
+ loginit();
return n->hints.image_path;
}
EAPI const char *
e_notification_hint_sound_file_get(E_Notification *n)
{
+ loginit();
return n->hints.sound_file;
}
EAPI char
e_notification_hint_suppress_sound_get(E_Notification *n)
{
+ loginit();
return n->hints.suppress_sound;
}
EAPI int
e_notification_hint_xy_get(E_Notification *n, int *x, int *y)
{
+ loginit();
if (x) *x = n->hints.x;
if (y) *y = n->hints.y;
EAPI E_Notification_Image *
e_notification_hint_image_data_get(E_Notification *n)
{
+ loginit();
return n->hints.image_data;
}
EAPI E_Notification_Image *
e_notification_hint_icon_data_get(E_Notification *n)
{
+ loginit();
return n->hints.icon_data;
}
{
E_Notification_Image *img;
+ loginit();
img = calloc(1, sizeof(E_Notification_Image));
img->bits_per_sample = 8;
return img;
int rowstride;
int *s;
+ loginit();
EINA_SAFETY_ON_NULL_RETURN_VAL(img, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
EAPI void
e_notification_image_free(E_Notification_Image *img)
{
+ loginit();
if (!img) return;
free(img->data);
free(img);
{
Evas_Object *o = NULL;
+ loginit();
if ((!evas) || (!img)) return NULL;
o = evas_object_image_filled_add(evas);
evas_object_resize(o, img->width, img->height);
return EINA_FALSE;
}
- dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &variant);
-
- snprintf(typestr, sizeof(typestr),
- (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- "%c"
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
- type);
-
- dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, typestr, &dict);
- dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
-
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
- if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
- dbus_message_iter_append_basic(&entry, type, &value);
+ if (dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT, typestr, &variant))
+ {
+ snprintf(typestr, sizeof(typestr),
+ (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ "%c"
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
+ type);
+
+ if (dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, typestr, &dict))
+ {
+ if (dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry))
+ {
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ if ((type == DBUS_TYPE_STRING) || (type == DBUS_TYPE_OBJECT_PATH))
+ dbus_message_iter_append_basic(&entry, type, &value);
+ else
+ dbus_message_iter_append_basic(&entry, type, value);
+
+ dbus_message_iter_close_container(&dict, &entry);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&variant, &dict);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+ dbus_message_iter_close_container(&itr, &variant);
+ }
else
- dbus_message_iter_append_basic(&entry, type, value);
-
- dbus_message_iter_close_container(&dict, &entry);
- dbus_message_iter_close_container(&variant, &dict);
- dbus_message_iter_close_container(&itr, &variant);
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
return e_ofono_element_message_send
(element, name, NULL, NULL, msg,
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fstype);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
-
- if (options)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter))
{
- const char *opt;
-
- EINA_LIST_FOREACH(options, l, opt)
- dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ if (options)
+ {
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
+ dbus_message_iter_close_container(&iter, &subiter);
+ }
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
}
- dbus_message_iter_close_container(&iter, &subiter) ;
ret = e_dbus_method_call_send(conn, msg, NULL, NULL, NULL, -1, NULL);
dbus_message_unref(msg);
msg = e_ukit_device_call_new(udi, "FilesystemUnmount");
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
- if (options)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter))
{
- const char *opt;
-
- EINA_LIST_FOREACH(options, l, opt)
- dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ if (options)
+ {
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
+ dbus_message_iter_close_container(&iter, &subiter);
}
- dbus_message_iter_close_container(&iter, &subiter) ;
-
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+
ret = e_dbus_method_call_send(conn, msg, NULL, NULL, NULL, -1, NULL);
dbus_message_unref(msg);
return ret;
msg = e_ukit_device_call_new(udi, "DriveEject");
dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter);
- if (options)
+ if (dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &subiter))
{
- const char *opt;
-
- EINA_LIST_FOREACH(options, l, opt)
- dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ if (options)
+ {
+ const char *opt;
+
+ EINA_LIST_FOREACH(options, l, opt)
+ dbus_message_iter_append_basic(&subiter, DBUS_TYPE_STRING, &opt);
+ }
+ dbus_message_iter_close_container(&iter, &subiter);
}
- dbus_message_iter_close_container(&iter, &subiter) ;
-
+ else
+ {
+ ERR("dbus_message_iter_open_container() failed");
+ }
+
ret = e_dbus_method_call_send(conn, msg, NULL, NULL, NULL, -1, NULL);
dbus_message_unref(msg);
return ret;
projects / framework / uifw / edbus.git / commitdiff