Integrate full wake history support

(From Tizen 5.5)

- Add support for wake-history cb
- Modify dump output for wakelock tag
- Add listener reset

Change-Id: Ib1f57f57d99d16fae92fd032338a6a41a572b510

diff --git a/include/bm_listeners.h b/include/bm_listeners.h
index 25ecf6495fa4f0697caf3cb05bb6bb8bbdc7d1f8..e33723275cf4d6b5c271f1f92f7c189ac5e76865 100644 (file)
--- a/include/bm_listeners.h
+++ b/include/bm_listeners.h
@@ -68,14 +68,10 @@ int bd_initialize_listeners(void);
 
 int bd_deinitialize_listeners();
 
+int bm_reset_event_listener(int to_enable);
+
 typedef struct _event_pool {
        int type;
        int val;
        char *app;
 } event_pool;
-
-
-
-
-
-

diff --git a/src/battery_dump/bd_history_item.c b/src/battery_dump/bd_history_item.c
index 37dd684fba05a822465089e1b7169aa31e2d933b..71ca87baac484f04e70a8c74aef48732fbdc465d 100644 (file)
--- a/src/battery_dump/bd_history_item.c
+++ b/src/battery_dump/bd_history_item.c
@@ -30,6 +30,7 @@
 #include "bm_private.h"
 #include "bd_private.h"
 #include "bm_config_parser.h"
+#include "bm_listeners.h"
 
 //#define DUMP_DUMMY 1
 #ifdef DUMP_DUMMY
@@ -38,6 +39,7 @@
 
 static dump_data_s history_data[HISTORY_SIZE_MAX];
 static int front = -1, end = -1, h_flag = false;
+static int prev_wake_state = 0;
 
 /*Bit and string map*/
 static char state1_map[32][4] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Wm",
@@ -186,7 +188,7 @@ static int bd_get_pool_entry_from_dump(int fd)
        if (index_s > index_e)
                index_e = HISTORY_SIZE_MAX + index_e;
 
-       for (int k = index_s; k < index_e; k++) {
+       for (int k = index_s; k <= index_e && k >= 0; k++) {
                i = k % HISTORY_SIZE_MAX;
                history_tag_s *pool_info = NULL;
                if (history_data[i].event_tag != NULL && (history_data[i].event_code & ET_FLAG_START)) {
@@ -195,7 +197,8 @@ static int bd_get_pool_entry_from_dump(int fd)
                        if (ret != BATTERY_MONITOR_ERROR_NONE)
                                return BATTERY_MONITOR_ERROR_INTERNAL;
                }
-               if (history_data[i].wakelock_tag != NULL) {
+               /* In case of disabled wake history */
+               if (history_data[i].wakelock_tag != NULL && prev_wake_state == 0) {
                        pool_info = history_data[i].wakelock_tag;
                        ret = bd_print_pool_entry(fd, i, pool_info);
                        if (ret != BATTERY_MONITOR_ERROR_NONE)
@@ -839,6 +842,7 @@ int bd_print_history_item_main(int fd, int num_h_items, long long base_time, boo
        }
 
        int ret = BATTERY_MONITOR_ERROR_NONE;
+       h_flag = false;
 
        history_item_s new_state;
        history_item_s old_state;
@@ -863,7 +867,7 @@ int bd_print_history_item_main(int fd, int num_h_items, long long base_time, boo
        if (index_s > index_e)
                index_e = HISTORY_SIZE_MAX + index_e;
 
-       for (int k = index_s; k < index_e; k++) {
+       for (int k = index_s; k <= index_e && k >= 0; k++) {
                i = k % HISTORY_SIZE_MAX;
                ret = bd_get_history_detail_from_dump(i, &new_state);
                if (ret != BATTERY_MONITOR_ERROR_NONE) {
@@ -876,9 +880,12 @@ int bd_print_history_item_main(int fd, int num_h_items, long long base_time, boo
                        g_string_append_printf(dump_p, "%s,%s,", TIZEN_DUMP_VERSION,
                        DUMP_DATA_TAG);
                        if (old_state.time_s < 0) {
+                               /*
                                g_string_append_printf(dump_p, "%lld",
                                                (new_state.time_s - base_time));
                                _DBG("value %s", dump_p->str);
+                               */
+                               g_string_append(dump_p, "0");
                        } else {
                                g_string_append_printf(dump_p, "%lld",
                                                (new_state.time_s - old_state.time_s));
@@ -1215,6 +1222,7 @@ int bd_print_history_item_main(int fd, int num_h_items, long long base_time, boo
        _DBG("DUMP COMPLETED/DELETE HASH TABLE");
 
        g_hash_table_destroy(app_map);
+       h_flag = true;
 
        EXIT;
        return BATTERY_MONITOR_ERROR_NONE;
@@ -1327,7 +1335,7 @@ static int bd_set_history_from_listener(history_item_s* nrec)
        return BATTERY_MONITOR_ERROR_NONE;
 }
 
-static int bd_reset_history()
+static int bd_reset_history(int to_enable)
 {
        ENTER;
        int ret = BATTERY_MONITOR_ERROR_NONE;
@@ -1354,6 +1362,9 @@ static int bd_reset_history()
        /* Call Battery Listener Reset Function from here
         * Add listener reset call
         * */
+       ret = bm_reset_event_listener(to_enable);
+       if (ret != BATTERY_MONITOR_ERROR_NONE)
+               _ERR("Listener Reset Fails");
 
        EXIT;
        return ret;
@@ -1412,6 +1423,7 @@ int bd_callback(const int fd, const int argc, char **argv)
        int ret;
        char opt = '\0';
        bool checkin = false;
+       int to_enable = 0;
 
        if (argc < 0) {
                _ERR("Input Error From Dumpsys Callback");
@@ -1425,16 +1437,22 @@ int bd_callback(const int fd, const int argc, char **argv)
                        return -1;
                }
        } else {
+               _DBG("%d", argc);
                if (argv[0] == NULL)
                        return -1;
 
                opt = argv[0][0];
-               if (opt > 122 || opt < 97 || argv[0][1] != '\0') {
+               if (opt > 122 || opt < 97) {
                        _ERR("INVALID ARG");
                        return -1;
                }
                switch (opt) {
                case 'c':
+                       if (strncmp(argv[0], "checkin", strlen("checkin")) != 0) {
+                               _ERR("Unsupported Option");
+                               return -1;
+                       }
+
                        _WARN("Case %s", argv[0]);
                        checkin = true;
                        ret = bd_print_history_item_main(fd, -1, 0, checkin);
@@ -1444,8 +1462,59 @@ int bd_callback(const int fd, const int argc, char **argv)
                        }
                        break;
                case 'r':
+                       if (strncmp(argv[0], "reset", strlen("reset")) != 0) {
+                               _ERR("Unsupported Option");
+                               return -1;
+                       }
+
+                       to_enable = 0;
+                       _WARN("Case %s", argv[0]);
+                       ret = bd_reset_history(to_enable);
+                       if (ret != BATTERY_MONITOR_ERROR_NONE) {
+                               _ERR("bd_reset_history failed (%x)", ret);
+                               return -1;
+                       }
+                       break;
+               case 'e':
+                       if (argc != 2 || strncmp(argv[0], "enable", strlen("enable")) != 0
+                                       || strncmp(argv[1], "full-wake-history",
+                                               strlen("full-wake-history")) != 0) {
+                               _ERR("Unsupported Option");
+                               return -1;
+                       }
+
+                       to_enable = 1;
+                       if (prev_wake_state == to_enable) {
+                               _WARN("is already enabled");
+                               return 0;
+                       }
+
+                       prev_wake_state = to_enable;
+
+                       _WARN("Case %s", argv[0]);
+                       ret = bd_reset_history(to_enable);
+                       if (ret != BATTERY_MONITOR_ERROR_NONE) {
+                               _ERR("bd_reset_history failed (%x)", ret);
+                               return -1;
+                       }
+                       break;
+               case 'd':
+                       if (argc != 2 || strncmp(argv[0], "disable", strlen("disable")) != 0
+                                       || strncmp(argv[1], "full-wake-history",
+                                               strlen("full-wake-history")) != 0) {
+                               _ERR("Unsupported Option");
+                               return -1;
+                       }
+
+                       to_enable = 0;
+                       if (prev_wake_state == to_enable) {
+                               _WARN("is already disabled");
+                               return 0;
+                       }
+                       prev_wake_state = to_enable;
+
                        _WARN("Case %s", argv[0]);
-                       ret = bd_reset_history();
+                       ret = bd_reset_history(to_enable);
                        if (ret != BATTERY_MONITOR_ERROR_NONE) {
                                _ERR("bd_reset_history failed (%x)", ret);
                                return -1;
@@ -1489,6 +1558,8 @@ int bd_initialize_battery_dump()
 
        front = -1; end = -1; h_flag = true;
        lst_charge = -1;
+       rst_time = -1;
+       prev_wake_state = 0;
 #ifdef DUMP_DUMMY
        bd_dummy_test_fn();
 #else

diff --git a/src/battery_dump/bm_listeners.c b/src/battery_dump/bm_listeners.c
index 480d58d40b60ae00bfbf81c197c76a0319de9331..623643343de3b6b20593212706cf24bdaef8f6a0 100644 (file)
--- a/src/battery_dump/bm_listeners.c
+++ b/src/battery_dump/bm_listeners.c
@@ -2335,6 +2335,89 @@ static int bd_initialize_data_items()
        return BATTERY_MONITOR_ERROR_NONE;
 }
 
+static int bm_start_recording_event()
+{
+       ENTER;
+       _DBG("History Recorder Started");
+       listener_hsp = -1;
+
+       /*      Reinitialize the hsp variables
+
+       bt_hsp = 0; bt_scan_hsp = 0;
+       wifi_hsp = 0; wifi_scan_hsp = 0; wifi_connected_hsp = 0;
+       display_hsp = 0; gps_hsp = 0; lock_hsp = 0; app_hsp = 0;
+       wakeup_hsp = 0; modem_hsp = 0; lock_ref_count = 0;
+       */
+
+       app_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+
+//     wakelock_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+
+       EXIT;
+       return 0;
+}
+
+static int bm_stop_recording_event()
+{
+       ENTER;
+       _DBG("History Recorder Stopped");
+
+       if (data_obj == NULL) {
+               _ERR("data obj is unavailable");
+               return -1;
+       }
+
+       data_obj->event_code = ET_NONE;
+       if (data_obj->event_tag != NULL) {
+               g_string_free(data_obj->event_tag->string_info, TRUE);
+               free(data_obj->event_tag);
+       }
+       if (data_obj->wakelock_tag != NULL) {
+               g_string_free(data_obj->wakelock_tag->string_info, TRUE);
+               free(data_obj->wakelock_tag);
+       }
+       if (data_obj->wakereason_tag != NULL) {
+               g_string_free(data_obj->wakereason_tag->string_info, TRUE);
+               free(data_obj->wakereason_tag);
+       }
+
+       if (app_list)
+               g_hash_table_destroy(app_list);
+       /*
+       if (wakelock_list)
+               g_hash_table_destroy(wakelock_list);*/
+       EXIT;
+       return BATTERY_MONITOR_ERROR_NONE;
+}
+
+int bm_reset_event_listener(int to_enable)
+{
+       ENTER;
+
+       int ret = BATTERY_MONITOR_ERROR_NONE;
+       _DBG("stop recording");
+       ret = bm_stop_recording_event();
+       if (ret != BATTERY_MONITOR_ERROR_NONE) {
+               _ERR("unable to stop recording");
+               return ret;
+       }
+
+       _DBG("start recording");
+       ret = bm_start_recording_event();
+       if (ret != BATTERY_MONITOR_ERROR_NONE) {
+               _ERR("unable to start recording");
+               return ret;
+       }
+
+       if (to_enable)
+               _DBG("is enabled");
+
+//     reset_val = to_enable;
+
+       EXIT;
+       return ret;
+}
+
 int bd_initialize_listeners(void)
 {
        ENTER;