src/modules/battery/e_mod_dbus.c

   1 #include "e.h"
   2 #include "e_mod_main.h"
   3
   4 static void _battery_dbus_battery_props(void *data, void *reply_data, DBusError *error);
   5 static void _battery_dbus_ac_adapter_props(void *data, void *reply_data, DBusError *error);
   6 static void _battery_dbus_battery_property_changed(void *data, DBusMessage *msg);
   7 static void _battery_dbus_battery_add(const char *udi);
   8 static void _battery_dbus_battery_del(const char *udi);
   9 static void _battery_dbus_ac_adapter_add(const char *udi);
  10 static void _battery_dbus_ac_adapter_del(const char *udi);
  11 static void _battery_dbus_find_battery(void *user_data, void *reply_data, DBusError *err);
  12 static void _battery_dbus_find_ac(void *user_data, void *reply_data, DBusError *err);
  13 static void _battery_dbus_is_battery(void *user_data, void *reply_data, DBusError *err);
  14 static void _battery_dbus_is_ac_adapter(void *user_data, void *reply_data, DBusError *err);
  15 static void _battery_dbus_dev_add(void *data, DBusMessage *msg);
  16 static void _battery_dbus_dev_del(void *data, DBusMessage *msg);
  17
  18 extern Eina_List *device_batteries;
  19 extern Eina_List *device_ac_adapters;
  20 extern double init_time;
  21
  22 static E_DBus_Connection *e_dbus_conn = NULL;
  23
  24 int
  25 _battery_dbus_start(void)
  26 {
  27    e_dbus_conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
  28    if (!e_dbus_conn) return 0;
  29    // FIXME: e_dbus doesn't allow us to track this pending call
  30    e_hal_manager_find_device_by_capability
  31      (e_dbus_conn, "battery", _battery_dbus_find_battery, NULL);
  32    e_hal_manager_find_device_by_capability
  33      (e_dbus_conn, "ac_adapter", _battery_dbus_find_ac, NULL);
  34    battery_config->dbus.dev_add =
  35      e_dbus_signal_handler_add(e_dbus_conn, E_HAL_SENDER,
  36                                E_HAL_MANAGER_PATH,
  37                                E_HAL_MANAGER_INTERFACE,
  38                                "DeviceAdded", _battery_dbus_dev_add, NULL);
  39    battery_config->dbus.dev_del =
  40      e_dbus_signal_handler_add(e_dbus_conn, E_HAL_SENDER,
  41                                E_HAL_MANAGER_PATH,
  42                                E_HAL_MANAGER_INTERFACE,
  43                                "DeviceRemoved", _battery_dbus_dev_del, NULL);
  44    init_time = ecore_time_get();
  45    return 1;
  46 }
  47
  48
  49 void
  50 _battery_dbus_stop(void)
  51 {
  52    Ac_Adapter *ac;
  53    Battery *bat;
  54
  55    if (!e_dbus_conn) return;
  56
  57    if (battery_config->dbus.have)
  58      {
  59         dbus_pending_call_cancel(battery_config->dbus.have);
  60         battery_config->dbus.have = NULL;
  61      }
  62    if (battery_config->dbus.dev_add)
  63      {
  64         e_dbus_signal_handler_del(e_dbus_conn, battery_config->dbus.dev_add);
  65         battery_config->dbus.dev_add = NULL;
  66      }
  67    if (battery_config->dbus.dev_del)
  68      {
  69         e_dbus_signal_handler_del(e_dbus_conn, battery_config->dbus.dev_del);
  70         battery_config->dbus.dev_del = NULL;
  71      }
  72    EINA_LIST_FREE(device_ac_adapters, ac)
  73      {
  74         e_dbus_signal_handler_del(e_dbus_conn, ac->prop_change);
  75         eina_stringshare_del(ac->udi);
  76         eina_stringshare_del(ac->product);
  77         free(ac);
  78      }
  79    EINA_LIST_FREE(device_batteries, bat)
  80      {
  81         e_dbus_signal_handler_del(e_dbus_conn, bat->prop_change);
  82         eina_stringshare_del(bat->udi);
  83         eina_stringshare_del(bat->technology);
  84         eina_stringshare_del(bat->type);
  85         eina_stringshare_del(bat->charge_units);
  86         eina_stringshare_del(bat->model);
  87         eina_stringshare_del(bat->vendor);
  88         free(bat);
  89      }
  90    e_dbus_connection_close(e_dbus_conn);
  91    e_dbus_conn = NULL;
  92 }
  93
  94 static void
  95 _battery_dbus_battery_props(void *data, void *reply_data, DBusError *error __UNUSED__)
  96 {
  97    E_Hal_Properties *ret = reply_data;
  98    Battery *bat = data;
  99    int err = 0;
 100    const char *str;
 101
 102    if (dbus_error_is_set(error))
 103      {
 104         dbus_error_free(error);
 105         return;
 106      }
 107    if (!ret) return;
 108
 109 #undef GET_BOOL
 110 #undef GET_INT
 111 #undef GET_STR
 112 #define GET_BOOL(val, s) bat->val = e_hal_property_bool_get(ret, s, &err)
 113 #define GET_INT(val, s) bat->val = e_hal_property_int_get(ret, s, &err)
 114 #define GET_STR(val, s) \
 115    if (bat->val) eina_stringshare_del(bat->val); \
 116    bat->val = NULL; \
 117    str = e_hal_property_string_get(ret, s, &err); \
 118    if (str) \
 119      { \
 120         bat->val = eina_stringshare_ref(str); \
 121      }
 122
 123    GET_BOOL(present, "battery.present");
 124    GET_STR(technology, "battery.reporting.technology");
 125    GET_STR(model, "battery.model");
 126    GET_STR(vendor, "battery.vendor");
 127    GET_STR(type, "battery.type");
 128    GET_STR(charge_units, "battery.reporting.unit");
 129    GET_INT(percent, "battery.charge_level.percentage");
 130    GET_BOOL(can_charge, "battery.is_rechargeable");
 131    GET_INT(current_charge, "battery.charge_level.current");
 132    GET_INT(charge_rate, "battery.charge_level.rate");
 133    GET_INT(design_charge, "battery.charge_level.design");
 134    GET_INT(last_full_charge, "battery.charge_level.last_full");
 135    if (e_hal_property_bool_get(ret, "battery.rechargeable.is_charging", &err))
 136      {
 137         bat->charging = 1;
 138         GET_INT(time_full, "battery.remaining_time");
 139         bat->time_left = -1;
 140      }
 141    else
 142      {
 143         bat->charging = 0;
 144         GET_INT(time_left, "battery.remaining_time");
 145         bat->time_full = -1;
 146      }
 147    bat->got_prop = 1;
 148    _battery_device_update();
 149 }
 150
 151 static void
 152 _battery_dbus_ac_adapter_props(void *data, void *reply_data, DBusError *error __UNUSED__)
 153 {
 154    E_Hal_Properties *ret = reply_data;
 155    Ac_Adapter *ac = data;
 156    int err = 0;
 157    const char *str;
 158
 159    if (dbus_error_is_set(error))
 160      {
 161         dbus_error_free(error);
 162         return;
 163      }
 164    if (!ret) return;
 165
 166 #undef GET_BOOL
 167 #undef GET_STR
 168 #define GET_BOOL(val, s) ac->val = e_hal_property_bool_get(ret, s, &err)
 169 #define GET_STR(val, s) \
 170    if (ac->val) eina_stringshare_del(ac->val); \
 171    ac->val = NULL; \
 172    str = e_hal_property_string_get(ret, s, &err); \
 173    if (str) \
 174      { \
 175         ac->val = eina_stringshare_ref(str); \
 176      }
 177
 178    GET_BOOL(present, "ac_adapter.present");
 179    GET_STR(product, "info.product");
 180    _battery_device_update();
 181 }
 182
 183 static void
 184 _battery_dbus_battery_property_changed(void *data, DBusMessage *msg __UNUSED__)
 185 {
 186    // FIXME: e_dbus doesn't allow us to track this pending call
 187    e_hal_device_get_all_properties(e_dbus_conn, ((Battery *)data)->udi,
 188                                    _battery_dbus_battery_props, data);
 189 }
 190
 191 static void
 192 _battery_dbus_ac_adapter_property_changed(void *data, DBusMessage *msg __UNUSED__)
 193 {
 194    // FIXME: e_dbus doesn't allow us to track this pending call
 195    e_hal_device_get_all_properties(e_dbus_conn, ((Ac_Adapter *)data)->udi,
 196                                    _battery_dbus_ac_adapter_props, data);
 197 }
 198
 199 static void
 200 _battery_dbus_battery_add(const char *udi)
 201 {
 202    Battery *bat;
 203
 204    bat = _battery_battery_find(udi);
 205    if (!bat)
 206      {
 207         bat = E_NEW(Battery, 1);
 208         if (!bat) return;
 209         bat->udi = eina_stringshare_add(udi);
 210         device_batteries = eina_list_append(device_batteries, bat);
 211         bat->prop_change =
 212         e_dbus_signal_handler_add(e_dbus_conn, E_HAL_SENDER, udi,
 213                                   E_HAL_DEVICE_INTERFACE, "PropertyModified",
 214                                   _battery_dbus_battery_property_changed,
 215                                   bat);
 216      }
 217    // FIXME: e_dbus doesn't allow us to track this pending call
 218    e_hal_device_get_all_properties(e_dbus_conn, udi,
 219                                    _battery_dbus_battery_props, bat);
 220
 221    _battery_device_update();
 222 }
 223
 224 static void
 225 _battery_dbus_battery_del(const char *udi)
 226 {
 227    Battery *bat;
 228
 229    bat = _battery_battery_find(udi);
 230    if (bat)
 231      {
 232         e_dbus_signal_handler_del(e_dbus_conn, bat->prop_change);
 233         device_batteries = eina_list_remove(device_batteries, bat);
 234         eina_stringshare_del(bat->udi);
 235         eina_stringshare_del(bat->technology);
 236         eina_stringshare_del(bat->type);
 237         eina_stringshare_del(bat->charge_units);
 238         eina_stringshare_del(bat->model);
 239         eina_stringshare_del(bat->vendor);
 240         free(bat);
 241         return;
 242      }
 243    _battery_device_update();
 244 }
 245
 246 static void
 247 _battery_dbus_ac_adapter_add(const char *udi)
 248 {
 249    Ac_Adapter *ac;
 250
 251    ac = E_NEW(Ac_Adapter, 1);
 252    if (!ac) return;
 253    ac->udi = eina_stringshare_add(udi);
 254    device_ac_adapters = eina_list_append(device_ac_adapters, ac);
 255    ac->prop_change =
 256      e_dbus_signal_handler_add(e_dbus_conn, E_HAL_SENDER, udi,
 257                                E_HAL_DEVICE_INTERFACE, "PropertyModified",
 258                                _battery_dbus_ac_adapter_property_changed,
 259                                ac);
 260    // FIXME: e_dbus doesn't allow us to track this pending call
 261    e_hal_device_get_all_properties(e_dbus_conn, udi,
 262                                    _battery_dbus_ac_adapter_props, ac);
 263    _battery_device_update();
 264 }
 265
 266 static void
 267 _battery_dbus_ac_adapter_del(const char *udi)
 268 {
 269    Ac_Adapter *ac;
 270
 271    ac = _battery_ac_adapter_find(udi);
 272    if (ac)
 273      {
 274         e_dbus_signal_handler_del(e_dbus_conn, ac->prop_change);
 275         device_ac_adapters = eina_list_remove(device_ac_adapters, ac);
 276         eina_stringshare_del(ac->udi);
 277         eina_stringshare_del(ac->product);
 278         free(ac);
 279         return;
 280      }
 281    _battery_device_update();
 282 }
 283
 284 static void
 285 _battery_dbus_find_battery(void *user_data __UNUSED__, void *reply_data, DBusError *err __UNUSED__)
 286 {
 287    Eina_List *l;
 288    char *device;
 289    E_Hal_Manager_Find_Device_By_Capability_Return *ret;
 290
 291    ret = reply_data;
 292    if (dbus_error_is_set(err))
 293      {
 294         dbus_error_free(err);
 295         return;
 296      }
 297    if (!ret) return;
 298
 299    if (eina_list_count(ret->strings) < 1) return;
 300    EINA_LIST_FOREACH(ret->strings, l, device)
 301      _battery_dbus_battery_add(device);
 302 }
 303
 304 static void
 305 _battery_dbus_find_ac(void *user_data __UNUSED__, void *reply_data, DBusError *err __UNUSED__)
 306 {
 307    Eina_List *l;
 308    char *device;
 309    E_Hal_Manager_Find_Device_By_Capability_Return *ret;
 310
 311
 312    ret = reply_data;
 313    if (dbus_error_is_set(err))
 314      {
 315         dbus_error_free(err);
 316         return;
 317      }
 318    if (!ret) return;
 319
 320    if (eina_list_count(ret->strings) < 1) return;
 321    EINA_LIST_FOREACH(ret->strings, l, device)
 322      _battery_dbus_ac_adapter_add(device);
 323
 324 }
 325
 326 static void
 327 _battery_dbus_is_battery(void *user_data, void *reply_data, DBusError *err)
 328 {
 329    char *udi = user_data;
 330    E_Hal_Device_Query_Capability_Return *ret;
 331
 332
 333    ret = reply_data;
 334    if (dbus_error_is_set(err))
 335      {
 336         dbus_error_free(err);
 337         goto error;
 338      }
 339    if (!ret) goto error;
 340    if (ret->boolean)
 341      _battery_dbus_battery_add(udi);
 342    error:
 343    eina_stringshare_del(udi);
 344 }
 345
 346 static void
 347 _battery_dbus_is_ac_adapter(void *user_data, void *reply_data, DBusError *err)
 348 {
 349    char *udi = user_data;
 350    E_Hal_Device_Query_Capability_Return *ret;
 351
 352
 353    ret = reply_data;
 354    if (dbus_error_is_set(err))
 355      {
 356         dbus_error_free(err);
 357         goto error;
 358      }
 359    if (!ret) goto error;
 360
 361    if (ret->boolean)
 362      _battery_dbus_ac_adapter_add(udi);
 363    error:
 364    eina_stringshare_del(udi);
 365 }
 366
 367 static void
 368 _battery_dbus_dev_add(void *data __UNUSED__, DBusMessage *msg)
 369 {
 370    DBusError err;
 371    char *udi = NULL;
 372
 373    dbus_error_init(&err);
 374    dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &udi, DBUS_TYPE_INVALID);
 375    if (!udi) return;
 376    // FIXME: e_dbus doesn't allow us to track this pending call
 377    e_hal_device_query_capability(e_dbus_conn, udi, "battery",
 378                                  _battery_dbus_is_battery, (void*)eina_stringshare_add(udi));
 379    e_hal_device_query_capability(e_dbus_conn, udi, "ac_adapter",
 380                                  _battery_dbus_is_ac_adapter, (void*)eina_stringshare_add(udi));
 381 }
 382
 383 static void
 384 _battery_dbus_dev_del(void *data __UNUSED__, DBusMessage *msg)
 385 {
 386    DBusError err;
 387    char *udi = NULL;
 388
 389    dbus_error_init(&err);
 390    dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &udi, DBUS_TYPE_INVALID);
 391    if (!udi) return;
 392    _battery_dbus_battery_del(udi);
 393    _battery_dbus_ac_adapter_del(udi);
 394 }