[SM]][Data Usage] Preferences are read on start

Change-Id: I785107893a0031a531d451d72dcd5edce44ad14f
Signed-off-by: Radek Kintop <r.kintop@samsung.com>

diff --git a/setting-smartmanager/smartmanager-data/src/smartmanager-data.c b/setting-smartmanager/smartmanager-data/src/smartmanager-data.c
index 60238581f2549f41b7f81d5f59f39c70e807606d..9c73cc26f91f39dc50fc6bd0e6195a70748e3843 100755 (executable)
--- a/setting-smartmanager/smartmanager-data/src/smartmanager-data.c
+++ b/setting-smartmanager/smartmanager-data/src/smartmanager-data.c
@@ -26,7 +26,9 @@ static stc_callback_ret_e _total_stats_cb(stc_error_e result,
 static stc_callback_ret_e _get_restrictions_cb(stc_error_e result,
                                                                stc_restriction_info_h info, void *user_data);
 
-static void _initialize_limits(Data_Limits_T *limits);
+static void _initialize_cycle(Data_Limits_T *limits);
+static void _read_all_stat_cycles(void);
+static void _set_stats_time_frame_from_cycle(Data_Limits_T *limits);
 
 static Eina_Bool _delayed_timer_cb(void *data);
 
@@ -38,6 +40,7 @@ static bool wifi_total_stats_checked = false;
 static bool sim_total_stats_checked = false;
 static bool wifi_restrictions_checked = false;
 static bool sim_restrictions_checked = false;
+static bool all_stat_cycles_checked = false;
 static Ecore_Timer *periodic_update_timer = NULL;
 
 static void _lang_changed(app_event_info_h event_info, void *data)
@@ -57,9 +60,15 @@ static Eina_Bool _delayed_timer_cb(void *data)
        data_usage_app_item_t *item = NULL;
        bool tmp = false;
 
+       if (!all_stat_cycles_checked) {
+               _read_all_stat_cycles();
+               all_stat_cycles_checked = true;
+       }
+
        if (!sim_total_stats_checked) {
                ad.sim_1_limits.total_data_used = 0;
                ad.sim_2_limits.total_data_used = 0;
+
                tmp = get_sim_total_stats(ad.stc, _total_stats_cb);
                if (tmp)
                        sim_total_stats_checked = true;
@@ -68,6 +77,7 @@ static Eina_Bool _delayed_timer_cb(void *data)
 
        if (!wifi_total_stats_checked) {
                ad.wifi_limits.total_data_used = 0;
+
                tmp = get_wifi_total_stats(ad.stc, _total_stats_cb);
                if (tmp)
                        wifi_total_stats_checked = true;
@@ -137,6 +147,7 @@ void smartmanager_stc_get_all_data(void)
        sim_total_stats_checked = false;
        wifi_restrictions_checked = false;
        sim_restrictions_checked = false;
+       all_stat_cycles_checked = false;
 
        periodic_update_timer = ecore_timer_add(0.2, _delayed_timer_cb, NULL);
        if (!periodic_update_timer)
@@ -222,9 +233,8 @@ static bool _create_app(void *data)
                _count_available_sim_cards(ad);
        }
 
-       _initialize_limits(&ad->sim_1_limits);
-       _initialize_limits(&ad->sim_2_limits);
-       _initialize_limits(&ad->wifi_limits);
+       _read_all_stat_cycles();
+
        ret = stc_initialize(&ad->stc);
        if (ret != STC_ERROR_NONE) {
                SETTING_TRACE_ERROR("stc_initialize() error: %s", get_error_message(ret));
@@ -669,10 +679,100 @@ static stc_callback_ret_e _get_restrictions_cb(stc_error_e result,
        return STC_CALLBACK_CONTINUE;
 }
 
-static void _initialize_limits(Data_Limits_T *limits)
+static void _initialize_cycle(Data_Limits_T *limits)
 {
        limits->custom_mode_interval = 0;
        limits->cycle_mode = CYCLE_MODE_MONTHLY;
        limits->cycle_start = 1;
 }
 
+static void _read_all_stat_cycles(void)
+{
+       _initialize_cycle(&ad.sim_1_limits);
+       _initialize_cycle(&ad.sim_2_limits);
+       _initialize_cycle(&ad.wifi_limits);
+
+       if (!read_sim_1_cycle_mode((int *)&(ad.sim_1_limits.cycle_mode)))
+               SETTING_TRACE_ERROR("sim1 cycle mode read error");
+
+       read_sim_1_cycle_start(&(ad.sim_1_limits.cycle_start));
+       read_sim_1_cycle_interval(&(ad.sim_1_limits.custom_mode_interval));
+
+       if (!read_sim_2_cycle_mode((int *)&(ad.sim_2_limits.cycle_mode)))
+               SETTING_TRACE_ERROR("sim2 cycle mode read error");
+
+       read_sim_2_cycle_start(&(ad.sim_2_limits.cycle_start));
+       read_sim_2_cycle_interval(&(ad.sim_2_limits.custom_mode_interval));
+
+       if (!read_wifi_cycle_mode((int *)&(ad.wifi_limits.cycle_mode)))
+               SETTING_TRACE_ERROR("wifi cycle mode read error");
+
+       read_wifi_cycle_start(&(ad.wifi_limits.cycle_start));
+       read_wifi_cycle_interval(&(ad.wifi_limits.custom_mode_interval));
+
+       _set_stats_time_frame_from_cycle(&ad.sim_1_limits);
+       _set_stats_time_frame_from_cycle(&ad.sim_2_limits);
+       _set_stats_time_frame_from_cycle(&ad.wifi_limits);
+}
+
+static void _set_stats_time_frame_from_cycle(Data_Limits_T *limits)
+{
+       time_t now = 0;
+       long long custom_cycles_reminder = 0;
+       struct tm tm_past_delta = {0,};
+       struct tm tm_future_delta = {0,};
+       time(&now);
+       struct tm *tm_now = localtime(&now);
+       tm_now->tm_sec = 1;
+       tm_now->tm_min = 0;
+       tm_now->tm_hour = 0;
+       tm_past_delta = *tm_now;
+       tm_future_delta = *tm_now;
+
+       switch (limits->cycle_mode) {
+       case CYCLE_MODE_MONTHLY:
+               tm_past_delta.tm_mday = limits->cycle_start;
+               if (tm_now->tm_mday >= limits->cycle_start) {
+                       tm_future_delta.tm_mon++;
+                       tm_future_delta.tm_mday = limits->cycle_start;
+               } else {
+                       tm_past_delta.tm_mon--;
+                       tm_future_delta.tm_mday = limits->cycle_start;
+               }
+               break;
+       case CYCLE_MODE_WEEKLY:
+               tm_now->tm_wday--;
+               if (tm_now->tm_wday < 0)
+                       tm_now->tm_wday = 6;
+               if (tm_now->tm_wday >= limits->cycle_start) {
+                       tm_past_delta.tm_mday -= (tm_now->tm_wday + 1 - limits->cycle_start);
+                       tm_future_delta.tm_mday += (7 + limits->cycle_start - tm_now->tm_wday);
+               } else {
+                       tm_past_delta.tm_mday -= (7 + tm_now->tm_wday - limits->cycle_start);
+                       tm_future_delta.tm_mday += (limits->cycle_start - tm_now->tm_wday);
+               }
+               break;
+       case CYCLE_MODE_DAILY:
+               tm_future_delta.tm_sec = 59;
+               tm_future_delta.tm_min = 59;
+               tm_future_delta.tm_hour = 23;
+               break;
+       case CYCLE_MODE_CUSTOM:
+               if (limits->custom_mode_interval <= 0) {
+                       SETTING_TRACE_ERROR("Error: custom mode interval is %d",
+                                                               limits->custom_mode_interval);
+                       return;
+               }
+               custom_cycles_reminder = (now - (time_t)limits->cycle_start) %
+               (limits->custom_mode_interval * 24 * 60 * 60);
+               limits->interval_from = now - custom_cycles_reminder;
+               limits->interval_to = limits->interval_from +
+                                       (((time_t)limits->custom_mode_interval) * 24 * 60 * 60);
+               return;
+       default:
+               return;
+       }
+
+       limits->interval_from = mktime(&tm_past_delta);
+       limits->interval_to = mktime(&tm_future_delta);
+}

diff --git a/setting-smartmanager/smartmanager-data/src/smartmanager-utils.c b/setting-smartmanager/smartmanager-data/src/smartmanager-utils.c
index 9fa3c1cd35cd3efcd1d7bd1fef33f689abb8405f..d630fbed02ab28109dbdc6313e31f2a9290d8f2e 100755 (executable)
--- a/setting-smartmanager/smartmanager-data/src/smartmanager-utils.c
+++ b/setting-smartmanager/smartmanager-data/src/smartmanager-utils.c
@@ -351,17 +351,25 @@ static bool _read_int_value(const char *key, int *value)
 {
        bool existing = false;
        int res = preference_is_existing(key, &existing);
-       if (PREFERENCE_ERROR_NONE != res || !existing)
+       if (PREFERENCE_ERROR_NONE != res || !existing) {
+               SETTING_TRACE_ERROR("Preferences: checking if %s key exists %d," \
+                               " err: %s", key, existing, get_error_message(res));
                return false;
+       }
        res = preference_get_int(key, value);
-       if (PREFERENCE_ERROR_NONE != res)
+       if (PREFERENCE_ERROR_NONE != res) {
+               SETTING_TRACE_ERROR("Preferences: reading  %s key" \
+                               " err: %s", key, get_error_message(res));
                return false;
+       }
        return true;
 }
 
 static bool _write_int_value(const char *key, int value)
 {
        int res = preference_set_int(key, value);
+       SETTING_TRACE_DEBUG("Preferences: writing %s key %d value, result: %s",
+                       key, value, get_error_message(res));
        return (PREFERENCE_ERROR_NONE == res);
 }