Battery Last Charge time

Change-Id: I4de8f8bd9897c2e7c61f59037d0643c1f168d81a
Signed-off-by: Dewal Agarwal <d1.agarwal@samsung.com>

diff --git a/include/bm_server_db.h b/include/bm_server_db.h
index 3b766d3..c600c6a 100644 (file)
--- a/include/bm_server_db.h
+++ b/include/bm_server_db.h
@@ -203,6 +203,8 @@ resourceid_usage_s *bm_server_query_resource_usage_resourceid_ci(const char *res
 
 resourceid_usage_s *bm_server_query_resource_base_usage_resourceid_ci(const char *resource_id, long long s_time, long long e_time, int *error_code);
 
+resourceid_usage_s *bm_server_query_battery_last_charge(const char *resource_id, int *error_code);
+
 int bm_server_resource_usage_insert_to_db(resourceid_usage_s *bm_resource_type);
 
 int bm_server_resource_base_usage_insert_to_db(resourceid_usage_s *bm_resource_type);

diff --git a/src/battery_dump/bd_history_item.c b/src/battery_dump/bd_history_item.c
index 1d99b33..21c83eb 100644 (file)
--- a/src/battery_dump/bd_history_item.c
+++ b/src/battery_dump/bd_history_item.c
@@ -777,6 +777,30 @@ static int bd_get_history_detail_from_dump(int index, history_item_s* dump_node)
        return BATTERY_MONITOR_ERROR_NONE;
 }
 
+static void bd_get_last_charge_time(long int def_time, int *ret)
+{
+       ENTER;
+
+       if (lst_charge < 0) {
+               char *str = "battery";
+               resourceid_usage_s *bat_use = bm_server_query_battery_last_charge(str, ret);
+               if (*ret == BATTERY_MONITOR_ERROR_NONE) {
+                       if (bat_use->log_time > 0)
+                               lst_charge = bat_use->log_time;
+                       else
+                               lst_charge = def_time;
+                       _DBG("LC [%ld]", lst_charge);
+                       BM_FREE(bat_use);
+               } else {
+                       _ERR("LAST CHG time failed");
+                       lst_charge = def_time;
+               }
+       }
+
+       EXIT;
+       return;
+}
+
 int bd_print_history_item_reset(history_item_s* old_state)
 {
        ENTER;
@@ -1211,10 +1235,8 @@ int bd_print_history_item_main(int fd, int num_h_items, long long base_time, boo
                _ERR("UID data dump failed");
        // Get Last charge time to dump "l" field
        long int duration = 0;
-       if (lst_charge < 0)
-               duration = base_time/1000;
-       else
-               duration = lst_charge;
+       bd_get_last_charge_time(base_time/1000, &ret);
+       duration = lst_charge;
 
        ret = bd_get_and_print_gn_stat_entry_from_dump(fd, duration);
        if (ret != BATTERY_MONITOR_ERROR_NONE)
@@ -1451,7 +1473,7 @@ int bd_initialize_battery_dump()
        int ret = BATTERY_MONITOR_ERROR_NONE;
 
        h_count = 0; h_flag = true;
-
+       lst_charge = -1;
 #ifdef DUMP_DUMMY
        bd_dummy_test_fn();
 #else
@@ -1489,6 +1511,16 @@ int bd_deinitialize_battery_dump()
                return BATTERY_MONITOR_ERROR_NOT_INITIALIZED;
        }
 
+       if (lst_charge != -1) {
+               resourceid_usage_s battery_use;
+               battery_use.ResourceId = "battery";
+               battery_use.log_time = lst_charge;
+               battery_use.usage = 0;
+               ret = bm_server_resource_base_usage_insert_to_db(&battery_use);
+               if (ret != BATTERY_MONITOR_ERROR_NONE)
+                       _WARN("Battery Time Insert fail");
+       }
+
        ret = bd_free_history_data_memory();
        if (ret != BATTERY_MONITOR_ERROR_NONE)
                _WARN("memory free failed (%x)", ret);

diff --git a/src/bm_server_db.c b/src/bm_server_db.c
index b34b21d..db079f1 100644 (file)
--- a/src/bm_server_db.c
+++ b/src/bm_server_db.c
@@ -549,6 +549,17 @@ static void bm_convert_column_to_resourceid_usage(bm_stmt hstmt, resourceid_usag
        return;
 }
 
+static void bm_convert_column_to_battery_last_charge(bm_stmt hstmt, resourceid_usage_s* bm_resource_type)
+{
+       ENTER;
+
+       bm_resource_type->log_time = bm_query_table_column_int(hstmt, 0);
+       _DBG("log-time %ld", bm_resource_type->log_time);
+
+       EXIT;
+       return;
+}
+
 static void bm_convert_column_to_appid_usage(bm_stmt hstmt, appid_usage_s* bm_app_type)
 {
        ENTER;
@@ -2016,6 +2027,67 @@ CATCH:
        return NULL;
 }
 
+static resourceid_usage_s* bm_query_battery_last_charge(sqlite3 *bm_db_handle, const char *resource_id, int *error_code)
+{
+       ENTER;
+       bm_stmt hstmt = NULL;
+       int rc = 0;
+       *error_code = BATTERY_MONITOR_ERROR_NONE;
+       char query[BATTERY_MONITOR_SQL_LEN_MAX] = {0, };
+       BM_MEMSET(query, 0x00, BATTERY_MONITOR_SQL_LEN_MAX);
+       BM_SNPRINTF(query, sizeof(query), "SELECT MAX(log_time) FROM %s WHERE ResourceId = '%s'",
+                       BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE, resource_id);
+
+       hstmt = bm_prepare_query(bm_db_handle, query);
+       if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+               _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+               *error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+               return NULL;
+       }
+
+       resourceid_usage_s *bm_resource_type = NULL;
+       rc = bm_query_step(hstmt);
+       BM_CATCH_ERROR_P(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.(%s)\n", resource_id));
+
+       bm_resource_type = (resourceid_usage_s *)calloc(1, sizeof(resourceid_usage_s));
+       if (bm_resource_type == NULL) {
+               _ERR("memory allocation failed");
+               if (hstmt != NULL) {
+                       rc = bm_query_finalize(hstmt);
+                       BM_RETURN_VAL((rc == BATTERY_MONITOR_ERROR_NONE), { *error_code = rc; }, NULL, ("finalize error"));
+                       hstmt = NULL;
+               }
+               *error_code = BATTERY_MONITOR_ERROR_OUT_OF_MEMORY;
+               return NULL;
+       }
+       bm_convert_column_to_battery_last_charge(hstmt, bm_resource_type);
+
+       rc = bm_query_finalize(hstmt);
+       BM_CATCH_ERROR_P((rc == BATTERY_MONITOR_ERROR_NONE), {}, rc, ("finalize error"));
+       hstmt = NULL;
+       *error_code = BATTERY_MONITOR_ERROR_NONE;
+
+CATCH:
+       if (hstmt != NULL) {
+               rc = bm_query_finalize(hstmt);
+               if (rc != BATTERY_MONITOR_ERROR_NONE) {
+                       *error_code = rc;
+                       _ERR("finalize error");
+               }
+               hstmt = NULL;
+       }
+       if ((*error_code != BATTERY_MONITOR_ERROR_NONE) && bm_resource_type) {
+               BM_FREE(bm_resource_type);
+               bm_resource_type = NULL;
+       }
+       if ((*error_code == BATTERY_MONITOR_ERROR_NONE) && bm_resource_type != NULL) {
+               _INFO("Returning battery plug time");
+               return bm_resource_type;
+       }
+       EXIT;
+       return NULL;
+}
+
 static int bm_delete_table(sqlite3 *bm_db_handle, bm_stmt *phstmt, int num_app_id, const char *app_id, const char* table)
 {
        ENTER;
@@ -2155,7 +2227,8 @@ static int bm_delete_table_by_time_interval(sqlite3 *bm_db_handle, const char* t
        BM_RETURN_VAL((bm_db_handle != NULL), {}, BATTERY_MONITOR_ERROR_DB_NOT_OPENED, ("The database isn't connected."));
        BM_RETURN_VAL((table != NULL), {}, BATTERY_MONITOR_ERROR_INVALID_PARAMETER, ("table is null!"));
 
-       if ((g_strcmp0(table, BATTERY_MONITOR_APP_ID_USAGE_TABLE) == 0 || g_strcmp0(table, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE) == 0))
+       if ((g_strcmp0(table, BATTERY_MONITOR_APP_ID_USAGE_TABLE) == 0 || g_strcmp0(table, BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE) == 0
+                               || g_strcmp0(table, BATTERY_MONITOR_RES_ID_BASE_USAGE_TABLE) == 0))
                BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE log_time <= %ld", table, duration);
        else
                BM_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE time_s <= %ld", table, duration);
@@ -2452,6 +2525,20 @@ resourceid_usage_s *bm_server_query_resource_base_usage_resourceid_ci(const char
        return bm_resource_type;
 }
 
+resourceid_usage_s *bm_server_query_battery_last_charge(const char *resource_id, int *error_code)
+{
+       resourceid_usage_s *bm_resource_type = NULL;
+       *error_code = BATTERY_MONITOR_ERROR_NONE;
+
+       BM_RETURN_VAL((g_hBatteryMonitorDB != NULL), { *error_code = BATTERY_MONITOR_ERROR_DB_NOT_OPENED; }, NULL, ("The database isn't connected."));
+       BM_RETURN_VAL((resource_id != NULL), { *error_code = BATTERY_MONITOR_ERROR_INVALID_PARAMETER; }, NULL, ("The Battery Monitor Handle is NULL"));
+
+       bm_resource_type = bm_query_battery_last_charge(g_hBatteryMonitorDB, resource_id, error_code);
+
+       EXIT;
+       return bm_resource_type;
+}
+
 GSList* bm_server_query_appid_map(int *error_code)
 {
        ENTER;