src/logd_grabber/event.c

   1 #include <Eina.h>
   2 #include <string.h>
   3 #include "core/log.h"
   4 #include "battery.h"
   5 #include "display.h"
   6 #include "devices.h"
   7 #include "event.h"
   8 #include "events.h"
   9 #include "journal-reader.h"
  10 #include "macro.h"
  11 #include "nlproc-stat.h"
  12
  13 static Eina_Hash *stored_appids;
  14 static Eina_Hash *event_handlers;
  15
  16 static enum logd_db_query load_apps_cb(int id, const char *app, void *user_data)
  17 {
  18         char *tmp;
  19
  20         if (!eina_hash_find(stored_appids, app)) {
  21                 tmp = strdup(app);
  22                 if (!tmp) {
  23                         _E("strdup failed: %s", strerror(errno));
  24                         return LOGD_DB_QUERY_CONTINUE;
  25                 }
  26
  27                 if (eina_hash_add(stored_appids, tmp, (void*)id) == EINA_FALSE) {
  28                         _E("eina_hash_set failed: %s", eina_error_msg_get(eina_error_get()));
  29                 }
  30         }
  31
  32         return LOGD_DB_QUERY_CONTINUE;
  33 }
  34
  35 int init_event_handlers(void)
  36 {
  37         int key;
  38
  39         event_handlers = eina_hash_int32_new(NULL);
  40         if (!event_handlers) {
  41                 _E("eina_hash_int32_new failed");
  42                 return -ENOMEM;
  43         }
  44
  45         /* LOGD_DISPLAY | LOGD_CHANGED */
  46         key = LOGD_DISPLAY | LOGD_SHIFT_ACTION(LOGD_CHANGED);
  47         if (eina_hash_add(event_handlers,
  48                 &key, brightness_change_event_handler) == EINA_FALSE) {
  49                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  50                 return -ENOMEM;
  51         }
  52
  53         /* LOGD_DISPLAY | LOGD_ON */
  54         key = LOGD_DISPLAY | LOGD_SHIFT_ACTION(LOGD_ON);
  55         if (eina_hash_add(event_handlers,
  56                 &key, display_on_off_event_handler) == EINA_FALSE) {
  57                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  58                 return -ENOMEM;
  59         }
  60
  61         /* LOGD_DISPLAY | LOGD_OFF */
  62         key = LOGD_DISPLAY | LOGD_SHIFT_ACTION(LOGD_OFF);
  63         if (eina_hash_add(event_handlers,
  64                 &key, display_on_off_event_handler) == EINA_FALSE) {
  65                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  66                 return -ENOMEM;
  67         }
  68
  69         /* LOGD_BATTERY_SOC | LOGD_CHANGED */
  70         key = LOGD_BATTERY_SOC | LOGD_SHIFT_ACTION(LOGD_CHANGED);
  71         if (eina_hash_add(event_handlers,
  72                 &key, battery_level_changed_event_handler) == EINA_FALSE) {
  73                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  74                 return -ENOMEM;
  75         }
  76
  77         /* LOGD_CHARGER | LOGD_ON */
  78         key = LOGD_CHARGER | LOGD_SHIFT_ACTION(LOGD_ON);
  79         if (eina_hash_add(event_handlers,
  80                 &key, battery_charger_event_handler) == EINA_FALSE) {
  81                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  82                 return -ENOMEM;
  83         }
  84
  85         /* LOGD_CHARGER | LOGD_OFF */
  86         key = LOGD_CHARGER | LOGD_SHIFT_ACTION(LOGD_OFF);
  87         if (eina_hash_add(event_handlers,
  88                 &key, battery_charger_event_handler) == EINA_FALSE) {
  89                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  90                 return -ENOMEM;
  91         }
  92
  93         /* LOGD_POWER_MODE | LOGD_CHANGED */
  94         key = LOGD_POWER_MODE | LOGD_SHIFT_ACTION(LOGD_CHANGED);
  95         if (eina_hash_add(event_handlers,
  96                 &key, battery_power_mode_changed_event_handler) == EINA_FALSE) {
  97                 _E("eina_hash_add failed: %s", eina_error_msg_get(eina_error_get()));
  98                 return -ENOMEM;
  99         }
 100
 101
 102         return 0;
 103 }
 104
 105 int event_init()
 106 {
 107         int ret;
 108
 109         stored_appids = eina_hash_string_superfast_new(NULL);
 110         if (!stored_appids) {
 111                 _E("eina_hash_string_superfast_new failed");
 112                 return -ENOMEM;
 113         }
 114
 115         ret = logd_load_apps(load_apps_cb, NULL);
 116         if (ret < 0) {
 117                 _E("logd_load_apps failed");
 118                 return ret;
 119         }
 120
 121         ret = init_event_handlers();
 122         if (ret < 0) {
 123                 _E("init_event_handlers failed");
 124                 return ret;
 125         }
 126
 127         return 0;
 128 }
 129
 130 int event_exit()
 131 {
 132         if (event_handlers)
 133                 eina_hash_free(event_handlers);
 134
 135         if (stored_appids)
 136                 eina_hash_free(stored_appids);
 137
 138         return 0;
 139 }
 140
 141 void free_event(struct logd_grabber_event *event)
 142 {
 143         if (!event)
 144                 return;
 145         if (event->application)
 146                 free((void*)event->application);
 147         if (event->message)
 148                 free((void*)event->message);
 149 }
 150
 151 int store_event(struct logd_grabber_event *event)
 152 {
 153         int id;
 154         int ret;
 155
 156         if (event->action == LOGD_ON || event->action == LOGD_OFF)
 157                 if (store_devices_workingtime(event->object, event->action) < 0)
 158                         _E("store_devices_workingtime failed");
 159         id = (int)eina_hash_find(stored_appids, event->application);
 160         if (!id) {
 161                 if (logd_store_app(event->application) < 0) {
 162                         _E("logd_store_app failed");
 163                 }
 164
 165                 logd_load_apps(load_apps_cb, NULL);
 166
 167                 id = (int)eina_hash_find(stored_appids, event->application);
 168                 if (!id) {
 169                         _E("eina_hash_find failed");
 170                 }
 171         }
 172
 173         ret = logd_store_event(event->type, event->date, id, event->message);
 174         if (ret < 0) {
 175                 _E("logd_store_event failed");
 176         }
 177
 178         return ret;
 179 }
 180
 181 void event_socket_cb(void *user_data)
 182 {
 183         struct logd_grabber_event event;
 184         int ret;
 185
 186         ret = get_next_event(&event);
 187         if (ret < 0) {
 188                 _E("get_next_event failed");
 189                 return;
 190         } else if (ret == 0) {
 191                 event_handler_func func;
 192
 193                 _D("object %d, action %d, message: %s\n", event.object,
 194                         event.action, event.message);
 195
 196                 func = (event_handler_func) eina_hash_find(event_handlers, &event.type);
 197                 if (!func) {
 198                         free_event(&event);
 199                         return;
 200                 }
 201                 if (func(&event) < 0) {
 202                         _E("Event handle failed: object %d, action %d, message: %s\n",
 203                                 event.object, event.action, event.message);
 204                 }
 205                 if (store_event(&event) < 0) {
 206                         _E("store_event failed");
 207                 }
 208                 free_event(&event);
 209         }
 210 }