setting-datausage/src/setting-datausage-main.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <setting-datausage-main.h>
  22 #include <ail.h>
  23 #include <math.h>
  24
  25 #define UNKNOWN_APP "Unknown"
  26 #define DATAUSAGE_POPUP_GUIDE_TEXT "<font_size=32><color=#FF0000>Max limit is 99999</color></font_size>"
  27
  28 const char* data_usage_cycle_arr[] = {
  29                 SETTING_DATAUSAGE_MONTH_STR,
  30                 SETTING_DATAUSAGE_WEEK_STR,
  31                 SETTING_DATAUSAGE_DAY_STR,
  32                 NULL,
  33         };
  34
  35 const char *days_in_month[] = {
  36                 "01", "02", "03", "04", "05", "06",
  37                 "07", "08", "09", "10", "11", "12",
  38                 "13", "14", "15", "16", "17", "18",
  39                 "19", "20", "21", "22", "23", "24",
  40                 "25", "26", "27", "28", "29", "30",
  41                 "31",
  42 };
  43
  44 static int setting_datausage_main_create(void *cb);
  45 static int setting_datausage_main_destroy(void *cb);
  46 static int setting_datausage_main_update(void *cb);
  47 static int setting_datausage_main_cleanup(void *cb);
  48
  49 setting_view setting_view_datausage_main = {
  50         .create = setting_datausage_main_create,
  51         .destroy = setting_datausage_main_destroy,
  52         .update = setting_datausage_main_update,
  53         .cleanup = setting_datausage_main_cleanup,
  54 };
  55
  56 static void __setting_datausage_main_data_items_recreate(void *data);
  57
  58 static int __setting_datausage_main_size_transition(unsigned long long size, char *size_desc)
  59 {
  60         //SETTING_TRACE_BEGIN;
  61         //SETTING_TRACE("size = %lld", size);
  62         double tmp_size = 0.0;
  63         int ret = 0;
  64         if (size < SETTING_DATAUSAGE_MEGABYTE_VALUE) {  // size < 1MB: show x.xKB
  65                 tmp_size = ((double)size) / SETTING_DATAUSAGE_KILOBYTE_VALUE;
  66                 ret = snprintf(size_desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%4.2lf%s", tmp_size, "KB");
  67                 retv_if(ret < 0, SETTING_RETURN_FAIL);
  68         } else {        // show x.xMB
  69                 tmp_size = ((double)size) / SETTING_DATAUSAGE_MEGABYTE_VALUE;
  70                 ret = snprintf(size_desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%4.2lf%s", tmp_size, "MB");
  71                 retv_if(ret < 0, SETTING_RETURN_FAIL);
  72         }
  73
  74         return SETTING_RETURN_SUCCESS;
  75 }
  76
  77 static void __setting_datausage_main_left_time_desc_get(char *desc)
  78 {
  79         SETTING_TRACE_BEGIN;
  80         setting_retm_if(NULL == desc, "desc is NULL");
  81
  82         int err = 0;
  83         int cycle = 0;
  84         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &cycle, &err);
  85         if (ret != 0) {
  86                 SETTING_TRACE_ERROR("get vconf failed");
  87         }
  88
  89         time_t cur_time = time(0);
  90         time_t end_time;
  91         switch (cycle) {
  92         case 0: /* month */
  93                 {
  94                 __setting_datausage_main_days_in_month_get(NULL, &end_time);
  95                 break;
  96                 }
  97         case 1: /* week */
  98                 {
  99                 __setting_datausage_main_days_in_week_get(NULL, &end_time);
 100                 break;
 101                 }
 102         case 2: /* day */
 103                 {
 104                 end_time = time(0);
 105                 break;
 106                 }
 107         default:
 108                 {
 109                 /* do nothing */
 110                 SETTING_TRACE_ERROR("wrong data usage cycle");
 111                 return;
 112                 }
 113         }
 114
 115         struct tm cur_date;
 116         if (NULL == localtime_r(&cur_time, &cur_date)) {
 117                 SETTING_TRACE_ERROR("fail to call localtime_r");
 118                 return;
 119         }
 120
 121         struct tm end_date;
 122         if (NULL == localtime_r(&end_time, &end_date)) {
 123                 SETTING_TRACE_ERROR("fail to call localtime_r");
 124                 return;
 125         }
 126
 127         int start_day = cur_date.tm_mday;
 128         int end_day = end_date.tm_mday;
 129
 130         if (start_day == end_day) {
 131                 int cur_hour = cur_date.tm_hour;
 132                 snprintf(desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%d hours remaining", (SETTING_DATAUSAGE_HOURS_IN_DAY - cur_hour));
 133         } else {
 134                 snprintf(desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%d days remaining", (end_day - start_day));
 135         }
 136 }
 137
 138 static void __setting_datausage_main_round_rectangle_draw(void *data, int width,
 139                                         int red, int green, int blue)
 140 {
 141         //SETTING_TRACE_BEGIN;
 142         setting_retm_if(data == NULL, "data is NULL");
 143         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 144
 145         setting_retm_if(ad->limit_cr == NULL, "ad->limit_cr is NULL");
 146
 147         cairo_set_source_rgba(ad->limit_cr, red/255.0, green/255.0, blue/255.0, 1.0);
 148         cairo_set_line_width(ad->limit_cr, 1);
 149
 150         int x = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_X;
 151         int y = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_Y;
 152         int height = SETTING_DATAUSAGE_ROUND_RECT_HEIGHT;
 153         int r = SETTING_DATAUSAGE_ROUND_RECT_R;
 154
 155         cairo_move_to(ad->limit_cr, x + r, y);
 156         cairo_line_to(ad->limit_cr, x + width - r, y);
 157         cairo_move_to(ad->limit_cr, x + width, y + r);
 158         cairo_line_to(ad->limit_cr, x + width, y + height - r);
 159         cairo_move_to(ad->limit_cr, x + width - r, y + height);
 160         cairo_line_to(ad->limit_cr, x + r, y + height);
 161         cairo_move_to(ad->limit_cr, x, y + height - r);
 162         cairo_line_to(ad->limit_cr, x, y + r);
 163         cairo_arc(ad->limit_cr, x + r, y + r, r, M_PI, 3 * M_PI / 2.0);
 164         cairo_arc(ad->limit_cr, x + width - r, y + r, r, 3 * M_PI / 2, 2 * M_PI);
 165         cairo_arc(ad->limit_cr, x + width - r, y + height - r, r, 0, M_PI / 2);
 166         cairo_arc(ad->limit_cr, x + r, y + height - r, r, M_PI / 2, M_PI);
 167
 168         cairo_stroke_preserve(ad->limit_cr);
 169         cairo_set_source_rgba(ad->limit_cr, red/255.0, green/255.0, blue/255.0, 1.0);
 170         cairo_fill(ad->limit_cr);
 171 }
 172
 173 static void __setting_datausage_main_round_rectangle_draw_1(void *data, int width,
 174                                         int red, int green, int blue)
 175 {
 176         //SETTING_TRACE_BEGIN;
 177         setting_retm_if(data == NULL, "data is NULL");
 178         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 179
 180         setting_retm_if(ad->limit_cr == NULL, "ad->cr is NULL");
 181
 182         cairo_set_source_rgba(ad->limit_cr, red/255.0, green/255.0, blue/255.0, 1.0);
 183         cairo_set_line_width(ad->limit_cr, 1);
 184
 185         int x = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_X;
 186         int y = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_Y;
 187         int height = SETTING_DATAUSAGE_ROUND_RECT_HEIGHT;
 188         int r = SETTING_DATAUSAGE_ROUND_RECT_R;
 189
 190         double radian = acos((double)(r - width) / r);
 191
 192         cairo_move_to(ad->limit_cr, x, y + height - r);
 193         cairo_line_to(ad->limit_cr, x, y + r);
 194         cairo_arc(ad->limit_cr, x + r, y + r, r, M_PI, M_PI + radian);
 195         cairo_arc(ad->limit_cr, x + r, y + height - r, r, M_PI - radian, M_PI);
 196         cairo_close_path(ad->limit_cr);
 197
 198         cairo_stroke_preserve(ad->limit_cr);
 199         cairo_set_source_rgba(ad->limit_cr, red/255.0, green/255.0, blue/255.0, 1.0);
 200         cairo_fill(ad->limit_cr);
 201 }
 202
 203 static void __setting_datausage_main_triangle_draw(void *data, int width)
 204 {
 205         //SETTING_TRACE_BEGIN;
 206         setting_retm_if(data == NULL, "data is NULL");
 207         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 208
 209         setting_retm_if(ad->limit_cr == NULL, "ad->cr is NULL");
 210
 211         cairo_set_source_rgba(ad->limit_cr,
 212                 SETTING_DATAUSAGE_ROUND_RECT_COLOR_RED/255.0,
 213                 SETTING_DATAUSAGE_ROUND_RECT_COLOR_GREEN/255.0,
 214                 SETTING_DATAUSAGE_ROUND_RECT_COLOR_BLUE/255.0,
 215                 1.0);
 216         cairo_set_line_width(ad->limit_cr, 1);
 217
 218         int x = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_X + width;
 219         int y = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_Y + SETTING_DATAUSAGE_ROUND_RECT_HEIGHT + 4;
 220         int r = SETTING_DATAUSAGE_ROUND_RECT_R;
 221
 222         cairo_move_to(ad->limit_cr, x, y);
 223         cairo_line_to(ad->limit_cr, x - r, y + r);
 224         cairo_line_to(ad->limit_cr, x + r, y + r);
 225         cairo_close_path(ad->limit_cr);
 226
 227         cairo_stroke_preserve(ad->limit_cr);
 228         cairo_set_source_rgba(ad->limit_cr,
 229                 SETTING_DATAUSAGE_ROUND_RECT_COLOR_RED/255.0,
 230                 SETTING_DATAUSAGE_ROUND_RECT_COLOR_GREEN/255.0,
 231                 SETTING_DATAUSAGE_ROUND_RECT_COLOR_BLUE/255.0,
 232                 1.0);
 233         cairo_fill(ad->limit_cr);
 234 }
 235
 236 static void __setting_datausage_main_round_rectangle_draw_2(void *data, int width,
 237                                         int red, int green, int blue)
 238 {
 239         //SETTING_TRACE_BEGIN;
 240         setting_retm_if(data == NULL, "data is NULL");
 241         setting_retm_if(width <= SETTING_DATAUSAGE_ROUND_RECT_R, "width is error");
 242         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 243
 244         setting_retm_if(ad->limit_cr == NULL, "ad->cr is NULL");
 245
 246         cairo_set_source_rgba(ad->limit_cr, red/255.0, green/255.0, blue/255.0, 1.0);
 247         cairo_set_line_width(ad->limit_cr, 1);
 248
 249         int x = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_X;
 250         int y = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_Y;
 251         int height = SETTING_DATAUSAGE_ROUND_RECT_HEIGHT;
 252         int left_r = SETTING_DATAUSAGE_ROUND_RECT_R;
 253         int right_r = width - left_r;
 254
 255         cairo_move_to(ad->limit_cr, x + width, y + right_r);
 256         cairo_line_to(ad->limit_cr, x + width, y + height - right_r);
 257         cairo_move_to(ad->limit_cr, x, y + height - left_r);
 258         cairo_line_to(ad->limit_cr, x, y + left_r);
 259         cairo_arc(ad->limit_cr, x + left_r, y + left_r, left_r, M_PI, 3 * M_PI / 2.0);
 260         cairo_arc(ad->limit_cr, x + left_r, y + right_r, right_r, 3 * M_PI / 2, 2 * M_PI);
 261         cairo_arc(ad->limit_cr, x + left_r, y + height - right_r, right_r, 0, M_PI / 2);
 262         cairo_arc(ad->limit_cr, x + left_r, y + height - left_r, left_r, M_PI / 2, M_PI);
 263
 264         cairo_stroke_preserve(ad->limit_cr);
 265         cairo_set_source_rgba(ad->limit_cr, red/255.0, green/255.0, blue/255.0, 1.0);
 266         cairo_fill(ad->limit_cr);
 267 }
 268
 269 static void __setting_datausage_main_text_in_round_rect_draw(void *data)
 270 {
 271         //SETTING_TRACE_BEGIN;
 272         setting_retm_if(data == NULL, "data is NULL");
 273         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 274
 275         setting_retm_if(ad->limit_cr == NULL, "ad->cr is NULL");
 276
 277         cairo_set_source_rgba(ad->limit_cr, 0.0, 0.0, 0.0, 1.0);
 278
 279         int x = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_X + 20;
 280         int y = SETTING_DATAUSAGE_ROUND_RECT_HEAD_POINT_Y + 50;
 281
 282         char total_size[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
 283         __setting_datausage_main_size_transition(ad->total_size, total_size);
 284
 285         char left_size[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
 286         __setting_datausage_main_size_transition(ad->left_size, left_size);
 287
 288         char desc[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
 289         snprintf(desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%s used %s left", total_size, left_size);
 290
 291         cairo_move_to(ad->limit_cr, x, y);
 292         cairo_set_font_size(ad->limit_cr, 38);
 293         cairo_show_text(ad->limit_cr, desc);
 294
 295         int err = 0;
 296         int cycle = 0;
 297         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &cycle, &err);
 298         if (ret != 0) {
 299                 SETTING_TRACE_ERROR("get vconf failed");
 300         }
 301
 302         char left_time_desc[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
 303         __setting_datausage_main_left_time_desc_get(left_time_desc);
 304
 305         cairo_move_to(ad->limit_cr, x, y + 50);
 306         cairo_set_font_size(ad->limit_cr, 36);
 307         cairo_show_text(ad->limit_cr, left_time_desc);
 308 }
 309
 310 static void __setting_datausage_main_table_draw(void *data)
 311 {
 312         //SETTING_TRACE_BEGIN;
 313         setting_retm_if(data == NULL, "data is NULL");
 314         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 315
 316         setting_retm_if(ad->cr == NULL, "ad->cr is NULL");
 317
 318         cairo_set_source_rgba(ad->cr, 0.0, 0.0, 0.0, 1.0);
 319         cairo_set_line_width(ad->cr, 1);
 320
 321         int begin_point_x = SETTING_DATAUSAGE_HEAD_POINT_X;
 322         int begin_point_y = SETTING_DATAUSAGE_HEAD_POINT_Y;
 323         int line_length = SETTING_DATAUSAGE_CHART_WIDTH;
 324         int line_height = SETTING_DATAUSAGE_CHART_HEIGHT;
 325
 326         /* paint y-axis */
 327         cairo_move_to(ad->cr, begin_point_x, begin_point_y);
 328         cairo_line_to(ad->cr, begin_point_x, begin_point_y + line_height);
 329
 330         /* paint horizontal lines */
 331         begin_point_x = SETTING_DATAUSAGE_HEAD_POINT_X;
 332
 333         int line_count = line_height / SETTING_DATAUSAGE_LINE_TO_LINE_SPACE;
 334         int i = 0;
 335         for (; i <= line_count; i++) {
 336                 if (i % SETTING_DATAUSAGE_LINES_IN_HORIZONTAL_GROUP == 0) {
 337                         cairo_set_line_width(ad->cr, 3);
 338                         cairo_move_to(ad->cr, begin_point_x - 12, begin_point_y);
 339                 } else {
 340                         cairo_set_line_width(ad->cr, 1);
 341                         cairo_move_to(ad->cr, begin_point_x, begin_point_y);
 342                 }
 343
 344                 cairo_line_to(ad->cr, begin_point_x + line_length, begin_point_y);
 345                 begin_point_y += SETTING_DATAUSAGE_LINE_TO_LINE_SPACE;
 346                 cairo_stroke(ad->cr);
 347         }
 348 }
 349
 350 static void __setting_datausage_main_text_in_table_draw(void *data)
 351 {
 352         //SETTING_TRACE_BEGIN;
 353         setting_retm_if(data == NULL, "data is NULL");
 354         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 355
 356         setting_retm_if(ad->cr == NULL, "ad->cr is NULL");
 357
 358         cairo_set_source_rgba(ad->cr, 0.0, 0.0, 0.0, 1.0);
 359
 360         int begin_point_x = SETTING_DATAUSAGE_HEAD_POINT_X;
 361         int begin_point_y = SETTING_DATAUSAGE_HEAD_POINT_Y;
 362         int group_space = SETTING_DATAUSAGE_CHART_HEIGHT / SETTING_DATAUSAGE_HORIZONTAL_GROUP;
 363
 364         int interval = ad->maximum / SETTING_DATAUSAGE_HORIZONTAL_GROUP;
 365
 366         int text_x = begin_point_x - 60;
 367
 368         int i = 0;
 369         for (; i <= SETTING_DATAUSAGE_HORIZONTAL_GROUP; i++) {
 370                 cairo_move_to(ad->cr, text_x, begin_point_y + 5);
 371                 cairo_set_font_size(ad->cr, 20);
 372                 char tmp[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
 373                 if (i == SETTING_DATAUSAGE_HORIZONTAL_GROUP) {
 374                         snprintf(tmp, MAX_DISPLAY_NAME_LEN_ON_UI, "%d", 0);
 375                 } else {
 376                         snprintf(tmp, MAX_DISPLAY_NAME_LEN_ON_UI, "%d", (ad->maximum - interval * i));
 377                 }
 378                 cairo_show_text(ad->cr, tmp);
 379                 begin_point_y += group_space;
 380         }
 381 }
 382
 383 static void __setting_datausage_main_pillar_draw(void *data)
 384 {
 385         //SETTING_TRACE_BEGIN;
 386         setting_retm_if(data == NULL, "data is NULL");
 387         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 388         setting_retm_if(ad->cr == NULL, "ad->cr is NULL");
 389
 390         cairo_set_source_rgba(ad->cr, 85/255.0, 145/255.0, 210/255.0, 1.0);
 391         cairo_set_line_width(ad->cr, 1);
 392
 393         int begin_point_x = SETTING_DATAUSAGE_HEAD_POINT_X + 1;
 394         int begin_point_y = SETTING_DATAUSAGE_HEAD_POINT_Y + SETTING_DATAUSAGE_CHART_HEIGHT;
 395         int pillar_width = SETTING_DATAUSAGE_PILLAR_WIDTH;
 396         int pillar_max_height = SETTING_DATAUSAGE_CHART_HEIGHT;
 397
 398         int i = 0;
 399         double tmp_size = 0.0;
 400         int height = 0;
 401         for (; i < ad->data_arr_len; i++) {
 402                 if (ad->data_arr[i] == 0) {
 403                         continue;
 404                 }
 405
 406                 /* get the size xxMB */
 407                 tmp_size = (double)ad->data_arr[i] / SETTING_DATAUSAGE_MEGABYTE_VALUE;
 408                 height = pillar_max_height * (tmp_size / ad->maximum);
 409                 cairo_rectangle(ad->cr, begin_point_x + pillar_width * i,
 410                         begin_point_y - height, pillar_width, height - 1);
 411         }
 412         cairo_stroke_preserve(ad->cr);
 413         cairo_fill(ad->cr);
 414 }
 415
 416 static void __setting_datausage_main_coord_draw(void *data)
 417 {
 418         //SETTING_TRACE_BEGIN;
 419         setting_retm_if(data == NULL, "data is NULL");
 420         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 421         setting_retm_if(ad->cr == NULL, "ad->cr is NULL");
 422
 423         cairo_set_source_rgba(ad->cr, 0.0, 0.0, 0.0, 1.0);
 424         cairo_set_line_width(ad->cr, 1);
 425
 426         int offset = 1;
 427         int begin_point_x = SETTING_DATAUSAGE_HEAD_POINT_X + offset;
 428         int begin_point_y = SETTING_DATAUSAGE_HEAD_POINT_Y + SETTING_DATAUSAGE_CHART_HEIGHT;
 429         int line_space = SETTING_DATAUSAGE_PILLAR_WIDTH / 2;
 430         int line_height = SETTING_DATAUSAGE_PILLAR_WIDTH;
 431
 432         cairo_move_to(ad->cr, begin_point_x, begin_point_y);
 433         cairo_line_to(ad->cr, begin_point_x, begin_point_y + line_height);
 434
 435         int i = 0;
 436         for (; i < SETTING_DATAUSAGE_DAYS_IN_MONTH; i++) {
 437                 begin_point_x = begin_point_x + line_space;
 438                 cairo_move_to(ad->cr, begin_point_x, begin_point_y - line_height / 2);
 439                 cairo_line_to(ad->cr, begin_point_x, begin_point_y + line_height / 2);
 440
 441                 begin_point_x = begin_point_x + line_space;
 442                 cairo_move_to(ad->cr, begin_point_x, begin_point_y);
 443                 cairo_line_to(ad->cr, begin_point_x, begin_point_y + line_height);
 444         }
 445         cairo_stroke(ad->cr);
 446 }
 447
 448 static void __setting_datausage_main_pie_graph(Evas_Object *parent, const char* part, void *data)
 449 {
 450         //SETTING_TRACE_BEGIN;
 451         setting_retm_if(parent == NULL, "parent is NULL");
 452         setting_retm_if(data == NULL, "data is NULL");
 453         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 454
 455         int value = 0;
 456         int err = 0;
 457         int ret = 0;
 458
 459         ret = setting_get_bool_slp_key(BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_BOOL, &value, &err);
 460         if (ret != 0) {
 461                 SETTING_TRACE_ERROR("get vconf failed");
 462         }
 463
 464         int cairo_w = SETTING_DATAUSAGE_CAIRO_W;
 465         int cairo_h = SETTING_DATAUSAGE_CAIRO_H - SETTING_DATAUSAGE_DATA_LIMIT_GRAPH_HEIGHT;
 466
 467         Evas* evas = evas_object_evas_get(parent);
 468         setting_retm_if(evas == NULL, "evas is NULL");
 469
 470         Evas_Object *clip = evas_object_rectangle_add(evas);
 471         evas_object_color_set(clip, 255, 255, 255, 255);
 472         setting_resize_object(clip, cairo_w, cairo_h);
 473
 474         Evas_Object *pie_image_object = evas_object_image_add(evas);
 475         setting_retm_if(pie_image_object == NULL, "pie_image_object is NULL");
 476         evas_object_color_set(pie_image_object, 255, 255, 255, 250);
 477         evas_object_clip_set(pie_image_object, clip);
 478         evas_object_show(pie_image_object);
 479         setting_resize_object(pie_image_object, cairo_w, cairo_h);
 480
 481         evas_object_resize(parent, cairo_w, cairo_h);
 482
 483         elm_object_part_content_set(parent, part, pie_image_object);
 484
 485         if (ad->cairo_surface == NULL) {
 486                 ad->cairo_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, cairo_w, cairo_h);
 487                 setting_retm_if(ad->cairo_surface == NULL, "ad->cairo_surface is NULL");
 488         }
 489
 490         if (ad->cr == NULL) {
 491                 ad->cr = cairo_create(ad->cairo_surface);
 492                 setting_retm_if(ad->cr == NULL, "ad->cr is NULL");
 493         }
 494
 495         __setting_datausage_main_table_draw(ad);
 496
 497         __setting_datausage_main_text_in_table_draw(ad);
 498
 499         __setting_datausage_main_pillar_draw(ad);
 500
 501         __setting_datausage_main_coord_draw(ad);
 502
 503         evas_object_image_size_set(pie_image_object, cairo_w, cairo_h);
 504         evas_object_image_data_set(pie_image_object, cairo_image_surface_get_data(ad->cairo_surface));
 505         evas_object_image_fill_set(pie_image_object, 0, 0, cairo_w, cairo_h);
 506 }
 507
 508 static void __setting_datausage_main_limit_graph(Evas_Object *parent, const char* part, void *data)
 509 {
 510         //SETTING_TRACE_BEGIN;
 511         setting_retm_if(parent == NULL, "parent is NULL");
 512         setting_retm_if(data == NULL, "data is NULL");
 513         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 514
 515         int cairo_w = SETTING_DATAUSAGE_CAIRO_W;
 516         int cairo_h = SETTING_DATAUSAGE_DATA_LIMIT_GRAPH_HEIGHT;
 517
 518         Evas* evas = evas_object_evas_get(parent);
 519         setting_retm_if(evas == NULL, "evas is NULL");
 520
 521         Evas_Object *clip = evas_object_rectangle_add(evas);
 522         evas_object_color_set(clip, 255, 255, 255, 255);
 523         setting_resize_object(clip, cairo_w, cairo_h);
 524
 525         Evas_Object *pie_image_object = evas_object_image_add(evas);
 526         setting_retm_if(pie_image_object == NULL, "pie_image_object is NULL");
 527         evas_object_color_set(pie_image_object, 255, 255, 255, 250);
 528         evas_object_clip_set(pie_image_object, clip);
 529         evas_object_show(pie_image_object);
 530         setting_resize_object(pie_image_object, cairo_w, cairo_h);
 531
 532         elm_object_part_content_set(parent, part, pie_image_object);
 533
 534         if (ad->limit_cairo_surface == NULL) {
 535                 ad->limit_cairo_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, cairo_w, cairo_h);
 536                 setting_retm_if(ad->limit_cairo_surface == NULL, "ad->cairo_surface is NULL");
 537         }
 538
 539         if (ad->limit_cr == NULL) {
 540                 ad->limit_cr = cairo_create(ad->limit_cairo_surface);
 541                 setting_retm_if(ad->limit_cr == NULL, "ad->cr is NULL");
 542         }
 543
 544         __setting_datausage_main_round_rectangle_draw(ad, SETTING_DATAUSAGE_ROUND_RECT_WIDTH,
 545                                 SETTING_DATAUSAGE_ROUND_RECT_BG_COLOR,
 546                                 SETTING_DATAUSAGE_ROUND_RECT_BG_COLOR,
 547                                 SETTING_DATAUSAGE_ROUND_RECT_BG_COLOR);
 548
 549         int width = 0;
 550         if (ad->left_size > 0) {
 551                 double percent = (double)ad->total_size / (ad->total_size + ad->left_size);
 552                 width = SETTING_DATAUSAGE_ROUND_RECT_WIDTH * percent;
 553         } else {
 554                 width = SETTING_DATAUSAGE_ROUND_RECT_WIDTH;
 555         }
 556
 557         if (width > (2 * SETTING_DATAUSAGE_ROUND_RECT_R)) {
 558                 __setting_datausage_main_round_rectangle_draw(ad, width,
 559                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_RED,
 560                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_GREEN,
 561                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_BLUE);
 562         } else if (width > SETTING_DATAUSAGE_ROUND_RECT_R && width <= (2 * SETTING_DATAUSAGE_ROUND_RECT_R)) {
 563                 __setting_datausage_main_round_rectangle_draw_2(ad, width,
 564                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_RED,
 565                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_GREEN,
 566                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_BLUE);
 567         } else {
 568                 __setting_datausage_main_round_rectangle_draw_1(ad, width,
 569                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_RED,
 570                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_GREEN,
 571                                         SETTING_DATAUSAGE_ROUND_RECT_COLOR_BLUE);
 572         }
 573         __setting_datausage_main_triangle_draw(ad, width);
 574         __setting_datausage_main_text_in_round_rect_draw(ad);
 575
 576         evas_object_image_size_set(pie_image_object, cairo_w, cairo_h);
 577         evas_object_image_data_set(pie_image_object, cairo_image_surface_get_data(ad->limit_cairo_surface));
 578         evas_object_image_fill_set(pie_image_object, 0, 0, cairo_w, cairo_h);
 579 }
 580
 581 static void __setting_datausage_main_dismissed_cb(void *data, Evas_Object *obj, void *event_info)
 582 {
 583         SETTING_TRACE_BEGIN;
 584         setting_retm_if(data == NULL, "Data parameter is NULL");
 585         SettingDatausageUG *ad = (SettingDatausageUG *)data;
 586
 587         if(ad->ctxpopup) {
 588                 evas_object_del(ad->ctxpopup);
 589                 ad->ctxpopup = NULL;
 590         }
 591 }
 592
 593 static void __setting_datausage_main_move_ctxpopup(Evas_Object *ctxpopup, Evas_Object *btn)
 594 {
 595         Evas_Coord x, y, w , h;
 596         evas_object_geometry_get(btn, &x, &y, &w, &h);
 597         evas_object_move(ctxpopup, x + (w / 2), y + (h /2));
 598 }
 599
 600 static void __setting_datausage_main_timepicker_cb(void *data, Evas_Object *obj, void *event_info)
 601 {
 602         SETTING_TRACE_BEGIN;
 603         setting_retm_if(data == NULL, "Data parameter is NULL");
 604         SettingDatausageUG *ad = (SettingDatausageUG *)data;
 605         setting_retm_if(ad->starting_date == NULL, "ad->starting_date is NULL");
 606
 607         const char *label = elm_object_item_text_get((Elm_Object_Item *) event_info);
 608         setting_retm_if(label == NULL, "label is NULL");
 609
 610         const char *btn_label = elm_object_text_get(ad->starting_date->eo_check);
 611         if(!safeStrCmp(label, btn_label)) {
 612                 SETTING_TRACE("Not changed");
 613                 return;
 614         } else {
 615                 SETTING_TRACE("text(%s) is clicked!", label);
 616                 elm_object_text_set(ad->starting_date->eo_check, label);
 617
 618                 int starting_date = (int)g_ascii_strtod(label, NULL);
 619                 setting_retm_if(errno == ERANGE, "fail to call g_ascii_strtod");
 620
 621                 int err = 0;
 622                 int ret = setting_set_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, starting_date, &err);
 623                 setting_retm_if(ret != 0, "set vconf failed");
 624
 625                 if(ad->ctxpopup) {
 626                         evas_object_del(ad->ctxpopup);
 627                         ad->ctxpopup = NULL;
 628                 }
 629         }
 630 }
 631
 632 static void __setting_datausage_main_create_ctxpopup_timepicker(void *data, Evas_Object *obj, void *event_info)
 633 {
 634         SETTING_TRACE_BEGIN;
 635         setting_retm_if(data == NULL, "Data parameter is NULL");
 636         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 637         SettingDatausageUG *ad = (SettingDatausageUG *)item_data->userdata;
 638
 639         int idx = 0;
 640         Evas_Object *diskselector = NULL;
 641         Elm_Object_Item *item = NULL;
 642
 643         if(ad->ctxpopup) {
 644                 evas_object_del(ad->ctxpopup);
 645                 ad->ctxpopup = NULL;
 646         }
 647
 648         Evas_Coord w = 0;
 649         evas_object_geometry_get(ad->win_get, NULL, NULL, &w, NULL);
 650
 651         ad->ctxpopup = elm_ctxpopup_add(ad->navibar);
 652         elm_object_style_set(ad->ctxpopup, "timepicker");
 653         evas_object_size_hint_min_set(ad->ctxpopup, w, -1);
 654         evas_object_size_hint_weight_set(ad->ctxpopup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 655         evas_object_smart_callback_add(ad->ctxpopup, "dismissed", __setting_datausage_main_dismissed_cb, ad);
 656
 657         diskselector = elm_diskselector_add(ad->navibar);
 658         elm_diskselector_display_item_num_set(diskselector, 8);
 659         elm_object_style_set(diskselector, "timepicker");
 660
 661         int value = 0;
 662         int err = 0;
 663         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, &value, &err);
 664         if (ret != 0) {
 665                 SETTING_TRACE_ERROR("get vconf failed");
 666         }
 667
 668         int value_to_idx = value - 1;
 669         for(idx = 0; idx < sizeof(days_in_month) / sizeof(days_in_month[0]); idx++) {
 670                 if(value_to_idx == idx) {
 671                         item = elm_diskselector_item_append(diskselector, days_in_month[idx], NULL,
 672                                                 __setting_datausage_main_timepicker_cb, ad);
 673                 } else {
 674                         elm_diskselector_item_append(diskselector, days_in_month[idx], NULL,
 675                                                 __setting_datausage_main_timepicker_cb, ad);
 676                 }
 677         }
 678
 679         if(item != NULL) {
 680                 elm_diskselector_item_selected_set(item, EINA_TRUE);
 681         }
 682
 683         elm_diskselector_round_enabled_set(diskselector, EINA_TRUE);
 684         evas_object_size_hint_weight_set(diskselector, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 685         evas_object_size_hint_align_set(diskselector, EVAS_HINT_FILL, EVAS_HINT_FILL);
 686
 687         evas_object_show(diskselector);
 688         elm_object_content_set(ad->ctxpopup, diskselector);
 689
 690         elm_ctxpopup_direction_priority_set(ad->ctxpopup,
 691                                         ELM_CTXPOPUP_DIRECTION_DOWN,
 692                                         ELM_CTXPOPUP_DIRECTION_UP,
 693                                         ELM_CTXPOPUP_DIRECTION_LEFT,
 694                                         ELM_CTXPOPUP_DIRECTION_RIGHT);
 695
 696         __setting_datausage_main_move_ctxpopup(ad->ctxpopup, obj);
 697         evas_object_show(ad->ctxpopup);
 698 }
 699
 700 static char *_item_label_get(void *data, Evas_Object *obj, const char *part)
 701 {
 702         //SETTING_TRACE_BEGIN;
 703         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 704         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 705
 706         if (!safeStrCmp(part, "elm.text") || !safeStrCmp(part, "elm.text.1")) {
 707                 if (item_data->keyStr) {
 708                         return (char *)g_strdup(_(item_data->keyStr));
 709                 }
 710         } else {
 711                 if (item_data->sub_desc) {
 712                         return (char *)g_strdup(_(item_data->sub_desc));
 713                 }
 714         }
 715
 716         return NULL;
 717 }
 718
 719 static Evas_Object *_item_content_get(void *data, Evas_Object *obj, const char *part)
 720 {
 721         //SETTING_TRACE_BEGIN;
 722         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 723         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 724         int width = 0;
 725         evas_object_geometry_get(obj, NULL, NULL, &width, NULL);
 726
 727         if (!safeStrCmp(part, "elm.icon")) {
 728                 if (!safeStrCmp(item_data->keyStr, "limit_graph")) {
 729                         Evas_Object *sub_layout = elm_layout_add(obj);
 730                         elm_layout_file_set(sub_layout, SETTING_THEME_EDJ_NAME, "screen_mode");
 731                         evas_object_size_hint_weight_set(sub_layout, EVAS_HINT_EXPAND, 0.0);
 732
 733                         __setting_datausage_main_limit_graph(sub_layout, "content", item_data->userdata);
 734                         setting_resize_object(sub_layout, width - 40, SETTING_DATAUSAGE_GRAPH_H);
 735                         evas_object_show(sub_layout);
 736                         return sub_layout;
 737                 } else if (!safeStrCmp(item_data->keyStr, "graph_image")) {
 738                         Evas_Object *sub_layout = elm_layout_add(obj);
 739                         elm_layout_file_set(sub_layout, SETTING_THEME_EDJ_NAME, "screen_mode");
 740                         evas_object_size_hint_weight_set(sub_layout, EVAS_HINT_EXPAND, 0.0);
 741
 742                         __setting_datausage_main_pie_graph(sub_layout, "content", item_data->userdata);
 743                         setting_resize_object(sub_layout, width - 40, SETTING_DATAUSAGE_GRAPH_H);
 744                         evas_object_show(sub_layout);
 745                         return sub_layout;
 746                 } else {
 747                         int offset = 50;
 748
 749                         Evas_Object *label = NULL;
 750                         label = elm_label_add(obj);
 751                         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
 752                         elm_label_line_wrap_set(label, EINA_TRUE);
 753                         elm_label_wrap_width_set(label, width - offset);
 754                         elm_object_text_set(label, _(item_data->keyStr));
 755                         setting_resize_object(label, width - offset, 250);
 756                         evas_object_show(label);
 757                         return label;
 758                 }
 759         }
 760
 761         return NULL;
 762 }
 763
 764 static Evas_Object *_item_content_date_get(void *data, Evas_Object *obj, const char *part)
 765 {
 766         //SETTING_TRACE_BEGIN;
 767         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 768         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 769
 770         if (!safeStrCmp(part, "elm.icon")) {
 771                 Evas_Object *timepicker_btn = NULL;
 772                 timepicker_btn = elm_button_add(obj);
 773                 item_data->eo_check = timepicker_btn;
 774
 775                 int value = 0;
 776                 int err = 0;
 777                 int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, &value, &err);
 778                 if (ret != 0) {
 779                         SETTING_TRACE_ERROR("get vconf failed");
 780                 }
 781
 782                 int count = sizeof(days_in_month) / sizeof(days_in_month[0]);
 783
 784                 int value_to_idx = value - 1;
 785
 786                 if (value_to_idx >= 0 && value_to_idx < count) {
 787                         elm_object_text_set(timepicker_btn, days_in_month[value_to_idx]);
 788                 } else {
 789                         elm_object_text_set(timepicker_btn, days_in_month[0]);
 790                 }
 791
 792                 evas_object_smart_callback_add(timepicker_btn, "clicked", __setting_datausage_main_create_ctxpopup_timepicker, item_data);
 793
 794                 return timepicker_btn;
 795         }
 796
 797         return NULL;
 798 }
 799
 800 static Evas_Object *_item_content3_get(void *data, Evas_Object *obj, const char *part)
 801 {
 802         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 803         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 804
 805         if (!strcmp(part, "elm.icon")) {
 806                 Evas_Object *progressbar = NULL;
 807                 progressbar = elm_progressbar_add(obj);
 808                 elm_object_style_set(progressbar, "list_progress");
 809                 elm_progressbar_horizontal_set(progressbar, EINA_TRUE);
 810                 evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, EVAS_HINT_FILL);
 811                 evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 812
 813                 double percent = item_data->slider_min;
 814
 815                 //SETTING_TRACE("byte_size = %ld, percent = %f", byte_size, percent);
 816                 if (percent <= 0.01) {
 817                         percent =  0.01;
 818                 }
 819
 820                 elm_progressbar_value_set(progressbar, percent);
 821
 822                 return progressbar;
 823         }
 824         return NULL;
 825 }
 826
 827 static void _item_del(void *data, Evas_Object *obj)
 828 {
 829         setting_retm_if(data == NULL, "Data parameter is NULL");
 830         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 831         if (item_data) {
 832                 G_FREE(item_data->keyStr);
 833                 G_FREE(item_data->sub_desc);
 834                 FREE(item_data);
 835         }
 836 }
 837
 838 static void __entry_focused(void *data, Evas_Object *obj, void *event_info) // Focused callback will show X marked button and hide guidetext.
 839 {
 840         SETTING_TRACE_BEGIN;
 841         setting_retm_if(data == NULL, "data is NULL");
 842         Evas_Object *entry_container = (Evas_Object *)data;
 843         if (!elm_entry_is_empty(obj)) {
 844                 elm_object_signal_emit(entry_container, "elm,state,eraser,show", "elm");
 845         }
 846         elm_object_signal_emit(entry_container, "elm,state,guidetext,hide", "elm");
 847 }
 848 static void __eraser_clicked(void *data, Evas_Object *obj, const char *emission, const char *source) // When X marked button is clicked, empty entry's contents.
 849 {
 850         SETTING_TRACE_BEGIN;
 851         setting_retm_if(data == NULL, "data is NULL");
 852         Evas_Object *entry = data;
 853         elm_entry_entry_set(entry, "");
 854         elm_object_focus_set(entry, EINA_TRUE);
 855 }
 856
 857 static void __entry_changed(void *data, Evas_Object *obj, void *event_info)
 858 {
 859         SETTING_TRACE_BEGIN;
 860         setting_retm_if(obj == NULL, "obj is NULL");
 861
 862         Evas_Object *entry_container = elm_object_parent_widget_get(obj);
 863         if (entry_container) {
 864                 if (elm_entry_is_empty(obj)) {
 865                         //elm_object_signal_emit(entry_container, "elm,state,guidetext,show", "elm");
 866                         elm_object_signal_emit(entry_container, "elm,state,eraser,hide", "elm");
 867                 } else {
 868                         elm_object_signal_emit(entry_container, "elm,state,guidetext,hide", "elm");
 869                         elm_object_signal_emit(entry_container, "elm,state,eraser,show", "elm");
 870                 }
 871         }
 872 }
 873
 874 static void __setting_datausage_main_cairo_destroy(void *data)
 875 {
 876         SETTING_TRACE_BEGIN;
 877         setting_retm_if(data == NULL, "data is NULL");
 878         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 879
 880         if (ad->cr) {
 881                 cairo_destroy(ad->cr);
 882                 ad->cr = NULL;
 883         }
 884         if (ad->cairo_surface) {
 885                 cairo_surface_destroy(ad->cairo_surface);
 886                 ad->cairo_surface = NULL;
 887         }
 888 }
 889
 890 static void __setting_datausage_main_limit_cairo_destroy(void *data)
 891 {
 892         SETTING_TRACE_BEGIN;
 893         setting_retm_if(data == NULL, "data is NULL");
 894         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 895
 896         if (ad->limit_cr) {
 897                 cairo_destroy(ad->limit_cr);
 898                 ad->limit_cr = NULL;
 899         }
 900         if (ad->limit_cairo_surface) {
 901                 cairo_surface_destroy(ad->limit_cairo_surface);
 902                 ad->limit_cairo_surface = NULL;
 903         }
 904 }
 905
 906 static void __setting_datausage_main_apps_list_destroy(void *data)
 907 {
 908         SETTING_TRACE_BEGIN;
 909         setting_retm_if(data == NULL, "data is NULL");
 910         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 911
 912         if (ad->app_list) {
 913                 Eina_List *l = NULL;
 914                 rsml_perf_info *new_item;
 915                 EINA_LIST_FOREACH(ad->app_list, l, new_item)
 916                 {
 917                         FREE(new_item->interval);
 918                         G_FREE(new_item->app_id);
 919                         FREE(new_item);
 920                 }
 921                 eina_list_free(ad->app_list);
 922                 ad->app_list = NULL;
 923         }
 924 }
 925
 926 static void __setting_datausage_main_popup_resp_cb(void *data, Evas_Object *obj, void *event_info)
 927 {
 928         SETTING_TRACE_BEGIN;
 929         setting_retm_if(data == NULL, "data is NULL");
 930         int response_type = btn_type(obj);
 931         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 932
 933         if (POPUP_RESPONSE_OK == response_type) {
 934                 setting_retm_if(ad->data_limit_entry == NULL, "ad->data_limit_entry is NULL");
 935                 const char *text = elm_entry_entry_get(ad->data_limit_entry);
 936                 if (isEmptyStr(text)) {
 937                         SETTING_TRACE_DEBUG("text is NULL");
 938                         return;
 939                 }
 940
 941                 int date_limit = (int)g_ascii_strtod(text, NULL);
 942                 setting_retm_if(errno == ERANGE, "fail to call g_ascii_strtod");
 943
 944                 int err = 0;
 945                 int ret = setting_set_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_LIMIT_INT, date_limit, &err);
 946                 setting_retm_if(ret != 0, "set vconf failed");
 947
 948                 setting_hide_input_pannel_cb(ad->data_limit_entry);
 949         } else if (POPUP_RESPONSE_CANCEL == response_type) {
 950                 SETTING_TRACE("POPUP_RESPONSE_CANCEL");
 951         }
 952
 953         if (ad->data_limit_conformant) {
 954                 evas_object_del(ad->data_limit_conformant);
 955                 ad->data_limit_conformant = NULL;
 956         }
 957
 958         if (ad->data_limit_popup) {
 959                 evas_object_del(ad->data_limit_popup);
 960                 ad->data_limit_popup = NULL;
 961         }
 962 }
 963
 964 static void __setting_datausage_main_data_limit_popup(void *data)
 965 {
 966         SETTING_TRACE_BEGIN;
 967         setting_retm_if(data == NULL, "data is NULL");
 968         SettingDatausageUG *ad = (SettingDatausageUG *) data;
 969
 970         Evas_Object *popup = NULL;
 971         Evas_Object *entry = NULL;
 972         Evas_Object *btn1 = NULL;
 973         Evas_Object *btn2 = NULL;
 974         //Evas_Object *content = NULL;
 975
 976         if (ad->data_limit_conformant) {
 977                 evas_object_del(ad->data_limit_conformant);
 978                 ad->data_limit_conformant = NULL;
 979         }
 980         //ad->data_limit_conformant = elm_conformant_add(ad->win_get);
 981         //elm_win_conformant_set(ad->win_get, EINA_TRUE);
 982         //elm_win_resize_object_add(ad->win_get, ad->data_limit_conformant);
 983         //evas_object_size_hint_weight_set(ad->data_limit_conformant, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 984         //evas_object_size_hint_align_set(ad->data_limit_conformant, EVAS_HINT_FILL, EVAS_HINT_FILL);
 985         //evas_object_show(ad->data_limit_conformant);
 986
 987         //content = elm_layout_add(ad->win_get);
 988         //elm_object_content_set(ad->data_limit_conformant, content);
 989         popup = elm_popup_add(ad->navibar);
 990         elm_object_part_text_set(popup, "title,text", _(SETTING_DATAUSAGE_DATA_LIMIT_STR));
 991
 992         Evas_Object* pLy = elm_layout_add(popup);
 993         elm_layout_theme_set(pLy, "layout", "application", "noindicator" );
 994         evas_object_size_hint_weight_set(pLy, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 995
 996         Evas_Object* pBg = elm_bg_add(pLy);
 997         evas_object_size_hint_weight_set(pBg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 998         elm_object_part_content_set(pLy, "elm.swallow.bg", pBg);
 999         elm_bg_color_set(pBg, 255, 255, 255);
1000         evas_object_show(pBg);
1001
1002         Evas_Object *box = elm_box_add(popup);
1003         elm_box_horizontal_set(box, EINA_TRUE);
1004
1005         Evas_Object *editfiled = setting_create_editfiled(popup, NULL, NULL);
1006         entry = elm_object_part_content_get(editfiled, "elm.swallow.content");
1007         ad->data_limit_entry = entry;
1008
1009         elm_entry_single_line_set(entry, EINA_TRUE);
1010         elm_entry_scrollable_set(entry, EINA_TRUE);
1011         elm_entry_autocapital_type_set(entry, ELM_AUTOCAPITAL_TYPE_ALLCHARACTER);
1012         elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
1013
1014         Elm_Entry_Filter_Limit_Size limit_filter_data;
1015         limit_filter_data.max_char_count = 0;
1016         limit_filter_data.max_byte_count = 5;
1017         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size, &limit_filter_data);
1018
1019         /* default handle */
1020         evas_object_smart_callback_add(entry, "changed", __entry_changed, NULL);
1021         evas_object_smart_callback_add(entry, "focused", __entry_focused, editfiled);
1022         elm_object_signal_callback_add(editfiled, "elm,eraser,clicked", "elm", __eraser_clicked, entry);
1023
1024         elm_box_pack_end(box, editfiled);
1025
1026         Evas_Object *label = elm_label_add(popup);
1027         elm_object_text_set(label, "MB");
1028         evas_object_show(label);
1029         elm_box_pack_end(box, label);
1030
1031         evas_object_show(box);
1032
1033         Evas_Object *content_layout = elm_layout_add(pLy);
1034         elm_layout_file_set(content_layout, SETTING_THEME_EDJ_NAME, "custom_popup");
1035         evas_object_size_hint_weight_set(content_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1036         elm_object_part_content_set(content_layout, "content", box);
1037
1038         /* guide text */
1039         Evas_Object *guide_label = elm_label_add(popup);
1040         evas_object_size_hint_weight_set(guide_label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1041         evas_object_size_hint_align_set(guide_label, 0.0, EVAS_HINT_FILL);
1042         elm_label_line_wrap_set(guide_label, EINA_TRUE);
1043         elm_label_wrap_width_set(guide_label, 530);
1044         elm_object_text_set(guide_label, DATAUSAGE_POPUP_GUIDE_TEXT);
1045         evas_object_show(guide_label);
1046         elm_object_part_content_set(content_layout, "content2", guide_label);
1047
1048         evas_object_show(content_layout);
1049
1050         elm_object_part_content_set(pLy, "elm.swallow.content", content_layout);
1051         evas_object_show(pLy);
1052
1053         elm_object_content_set(popup, pLy);
1054
1055         btn1 = elm_button_add(popup);
1056         elm_object_text_set(btn1, _(KeyStr_Save));
1057         elm_object_part_content_set(popup, "button1", btn1);
1058         elm_object_style_set(btn1, "popup_button/default");
1059         evas_object_smart_callback_add(btn1, "clicked", __setting_datausage_main_popup_resp_cb, ad);
1060
1061         btn2 = elm_button_add(popup);
1062         elm_object_text_set(btn2, _("IDS_COM_SK_CANCEL"));
1063         elm_object_part_content_set(popup, "button2", btn2);
1064         elm_object_style_set(btn2, "popup_button/default");
1065         evas_object_smart_callback_add(btn2, "clicked", __setting_datausage_main_popup_resp_cb, ad);
1066
1067         evas_object_show(popup);
1068         ad->data_limit_popup = popup;
1069 }
1070
1071 static int __setting_datausage_main_datausage_quota_set()
1072 {
1073         int err = 0;
1074         int ret = 0;
1075
1076         int time_period = 0;
1077         ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &time_period, &err);
1078         setting_retvm_if(ret == -1, SETTING_RETURN_FAIL, "get vconf failed");
1079
1080         int data_limit = 0;
1081         ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_LIMIT_INT, &data_limit, &err);
1082         setting_retvm_if(ret == -1, SETTING_RETURN_FAIL, "get vconf failed");
1083
1084         rsml_datausage_quota quota;
1085
1086         switch(time_period) {
1087         case 0:
1088                 quota.time_period = RESMAN_PERIOD_MONTH;
1089                 break;
1090         case 1:
1091                 quota.time_period = RESMAN_PERIOD_WEEK;
1092                 break;
1093         case 2:
1094                 quota.time_period = RESMAN_PERIOD_DAY;
1095                 break;
1096         default:
1097                 quota.time_period = RESMAN_PERIOD_UNDEF;
1098                 break;
1099         }
1100         quota.snd_quota = data_limit;
1101         quota.rcv_quota = data_limit;
1102         quota.quota_type = RESMAN_STATE_UNKNOWN;
1103
1104         SETTING_TRACE("quota.time_period = %d", quota.time_period);
1105         SETTING_TRACE("quota.snd_quota = %d", quota.snd_quota);
1106         SETTING_TRACE("quota.rcv_quota = %d", quota.rcv_quota);
1107         SETTING_TRACE("quota.quota_type = %d", quota.quota_type);
1108
1109         rsml_ret_c rsml_ret = set_datausage_quota(SETTING_PKG_NAME, &quota);
1110         SETTING_TRACE("rsml_ret = %d", rsml_ret);
1111         setting_retvm_if(rsml_ret != RESMAN_ERROR_OK, SETTING_RETURN_FAIL, "fail to call set_datausage_quota");
1112
1113         return SETTING_RETURN_SUCCESS;
1114 }
1115
1116 static void __setting_datausage_main_mouse_up_Gendial_list_cb(void *data, Evas_Object * obj, void *event_info)
1117 {
1118         SETTING_TRACE_BEGIN;
1119         setting_retm_if(data == NULL, "Data parameter is NULL");
1120
1121         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
1122         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1123         elm_genlist_item_selected_set(item, 0);
1124         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
1125
1126         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1127
1128         int opposite = !list_item->chk_status;
1129
1130         int err = 0;
1131         int ret = 0;
1132
1133         if (!safeStrCmp(SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_STR, list_item->keyStr)) {
1134                 ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_BOOL, opposite, &err);
1135                 setting_retm_if(ret == -1, "set vconf failed");
1136
1137                 elm_check_state_set(list_item->eo_check, opposite);
1138                 list_item->chk_status = opposite;
1139
1140                 /* if set_data_usage_limit's vconf is false, disable data_limit */
1141                 if (!opposite) {
1142                         setting_disable_genlist_item(ad->data_limit->item);
1143
1144                         rsml_ret_c rsml_ret = remove_datausage_quota(SETTING_PKG_NAME);
1145                         if (rsml_ret != RESMAN_ERROR_OK) {
1146                                 SETTING_TRACE_ERROR("fail to call remove_datausage_quota");
1147                         }
1148
1149                         __setting_datausage_main_data_items_recreate(ad);
1150                 } else {
1151                         ret = __setting_datausage_main_datausage_quota_set();
1152                         if (ret == SETTING_RETURN_FAIL) {
1153                                 SETTING_TRACE_ERROR("failed to set datausage quota");
1154                         }
1155
1156                         setting_enable_genlist_item(ad->data_limit->item);
1157
1158                         __setting_datausage_main_data_items_recreate(ad);
1159                 }
1160         } else if (!safeStrCmp(SETTING_DATAUSAGE_DATA_LIMIT_STR, list_item->keyStr)) {
1161                 __setting_datausage_main_data_limit_popup(ad);
1162         } else if (!safeStrCmp(KeyStr_UsePacketData, list_item->keyStr)) {
1163                 ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_USE_PACKET_DATA, opposite, &err);
1164                 setting_retm_if(ret == -1, "set vconf failed");
1165
1166                 elm_check_state_set(list_item->eo_check, opposite);
1167                 list_item->chk_status = opposite;
1168         }
1169 }
1170
1171 static void __setting_datausage_main_chk_btn_cb(void *data, Evas_Object * obj, void *event_info)
1172 {
1173         SETTING_TRACE_BEGIN;
1174         retm_if(data == NULL, "Data parameter is NULL");
1175         SettingDatausageUG *ad = NULL;
1176
1177         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
1178         ad = list_item->userdata;
1179         list_item->chk_status = elm_check_state_get(obj);       // for genlist update status
1180
1181         int opposite  = (list_item->chk_status == 1) ? SETTING_ON_OFF_BTN_ON : SETTING_ON_OFF_BTN_OFF;
1182
1183         int err = -1;
1184         int ret = -1;
1185
1186         if (obj == ad->use_packet_data->eo_check) {
1187                 ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_USE_PACKET_DATA, opposite, &err);
1188                 setting_retm_if(ret == -1, "set vconf failed");
1189         } else if (obj == ad->set_data_usage_limit->eo_check) {
1190                 ret = setting_set_bool_slp_key(BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_BOOL, opposite, &err);
1191                 setting_retm_if(ret == -1, "set vconf failed");
1192
1193                 /* if set_data_usage_limit's vconf is false, disable data_limit */
1194                 if (!opposite) {
1195                         rsml_ret_c rsml_ret = remove_datausage_quota(SETTING_PKG_NAME);
1196                         if (rsml_ret != RESMAN_ERROR_OK) {
1197                                 SETTING_TRACE_ERROR("fail to call remove_datausage_quota");
1198                         }
1199
1200                         __setting_datausage_main_data_items_recreate(ad);
1201
1202                         setting_disable_genlist_item(ad->data_limit->item);
1203                 } else {
1204                         ret = __setting_datausage_main_datausage_quota_set();
1205                         if (ret == SETTING_RETURN_FAIL) {
1206                                 SETTING_TRACE_ERROR("failed to set datausage quota");
1207                         }
1208
1209                         setting_enable_genlist_item(ad->data_limit->item);
1210
1211                         __setting_datausage_main_data_items_recreate(ad);
1212                 }
1213         }
1214 }
1215
1216 static char *__setting_datausage_main_data_usage_cycle_get()
1217 {
1218         int value = 0;
1219         int err = 0;
1220         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &value, &err);
1221         if (ret != 0) {
1222                 SETTING_TRACE_ERROR("get vconf failed");
1223         }
1224
1225         if (value >= 0 && value < 3) {
1226                 return (char *)data_usage_cycle_arr[value];
1227         } else {
1228                 return (char *)data_usage_cycle_arr[0];
1229         }
1230 }
1231
1232 static void __setting_datausage_main_maximum_get(void *data)
1233 {
1234         SETTING_TRACE_BEGIN;
1235         setting_retm_if(data == NULL,"Data parameter is NULL");
1236         SettingDatausageUG *ad = (SettingDatausageUG *)data;
1237
1238         /* get the max data */
1239         unsigned long long maximum = ad->data_arr[0];
1240
1241         unsigned long long total = 0;
1242         int i = 0;
1243         for (; i < ad->data_arr_len; i++) {
1244                 if (ad->data_arr[i] > maximum) {
1245                         maximum = ad->data_arr[i];
1246                 }
1247
1248                 total += ad->data_arr[i];
1249         }
1250
1251         ad->total_size = total;
1252
1253         /* get the left size */
1254         int date_limit = 0;
1255         int err = 0;
1256         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_LIMIT_INT, &date_limit, &err);
1257         setting_retm_if(ret != 0, "set vconf failed");
1258
1259         double date_limit_d = ((double)date_limit) * SETTING_DATAUSAGE_MEGABYTE_VALUE;
1260
1261         if (date_limit_d <= ad->total_size) {
1262                 ad->left_size = 0;
1263         } else {
1264                 ad->left_size = date_limit_d - ad->total_size;
1265         }
1266
1267         /*get maximum 10% more than the highest of data */
1268         SETTING_TRACE("maximum = %lld", maximum);
1269         unsigned long long tmp = maximum + maximum * 0.1;
1270         SETTING_TRACE("tmp = %lld", tmp);
1271
1272         /* get the size xxMB */
1273         int tmp_size = 0;
1274         tmp_size = (int)(tmp / SETTING_DATAUSAGE_MEGABYTE_VALUE);
1275         SETTING_TRACE("tmp_size = %d", tmp_size);
1276
1277         if (tmp_size <= 5) {
1278                 ad->maximum = 5;    /* 5 MB */
1279         } else {
1280                 ad->maximum = tmp_size;
1281         }
1282 }
1283
1284 static rsml_cb_ret __setting_datausage_main_apps_network_stats_get_cb(const rsml_perf_info *info,
1285                                             void *user_data)
1286 {
1287         Eina_List **list = (Eina_List **) user_data;
1288         rsml_perf_info *new_item = (rsml_perf_info *)calloc(1, sizeof(rsml_perf_info));
1289         rsml_tm_interval *interval_copy = (rsml_tm_interval *)calloc(1, sizeof(rsml_tm_interval));
1290         char *app_id_copy = info->app_id ? g_strdup(info->app_id) : g_strdup(UNKNOWN_APP);
1291
1292         *interval_copy = *(info->interval);
1293         *new_item = *info;
1294         new_item->app_id = app_id_copy;
1295         new_item->interval = interval_copy;
1296
1297         *list = eina_list_append(*list, new_item);
1298         return RESMAN_CONTINUE;
1299 }
1300
1301 /**
1302   * This function get the start day and the end day in current month
1303   * @start : output param, start day in current month, according to the vconf 'starting date'
1304   * @end: output param, end day in current month
1305   * @return days between start and end
1306   */
1307 static int __setting_datausage_main_days_in_month_get(time_t *start, time_t *end)
1308 {
1309         int starting_date = 0;
1310         int err = 0;
1311         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, &starting_date, &err);
1312         if (ret != 0) {
1313                 SETTING_TRACE_ERROR("get vconf failed");
1314         }
1315         //SETTING_TRACE("starting date is %d", starting_data);
1316
1317         time_t cur_time = time(0);
1318
1319         struct tm start_date;
1320         if (NULL == localtime_r(&cur_time, &start_date)) {
1321                 SETTING_TRACE_ERROR("fail to call localtime_r");
1322                 return 0;
1323         }
1324         start_date.tm_mday = 1;    /* set the first day in the month*/
1325         time_t from_time = mktime(&start_date);
1326
1327         /* get the start day in the year */
1328         int from_yday = start_date.tm_yday;
1329         SETTING_TRACE("start_data :%s", asctime(&start_date));
1330         SETTING_TRACE("from_yday :%d", from_yday);
1331
1332         /* get the last day in current month, 2 step:
1333           * 1. get the first day in next month, get the day in year;
1334           * 2. the last day in  current month = the day(in step 1) - 1;
1335           */
1336         /* step 1 */
1337         struct tm tmp_date;
1338         if (NULL == localtime_r(&from_time, &tmp_date)) {
1339                 SETTING_TRACE_ERROR("fail to call localtime_r");
1340                 return 0;
1341         }
1342         int cur_month = tmp_date.tm_mon;
1343         tmp_date.tm_mon = cur_month + 1;
1344         time_t tmp_time = mktime(&tmp_date);
1345         //SETTING_TRACE("tmp_data :%s", ctime(&tmp_time));
1346
1347         /* step 2 */
1348         struct tm end_date;
1349         if (NULL == localtime_r(&tmp_time, &end_date)) {
1350                 SETTING_TRACE_ERROR("fail to call localtime_r");
1351                 return 0;
1352         }
1353         int end_yday = end_date.tm_yday;
1354         int end_month = end_date.tm_mon;
1355         end_date.tm_mon = end_month - 1;
1356         /* if end_yday < from_yday, means it is the day in next year, so the last month in the year must be Dec*/
1357         if (end_yday < from_yday) {
1358                 end_date.tm_mday = 31; /* Dec must have 31 days */
1359         } else {
1360                 end_date.tm_mday = end_yday - from_yday;
1361         }
1362         end_date.tm_hour = 23;
1363         end_date.tm_min = 59;
1364         end_date.tm_sec = 59;
1365         time_t to_time = mktime(&end_date);
1366
1367         start_date.tm_mday = starting_date;    /* set the start day as vconf */
1368         start_date.tm_hour = 0;
1369         start_date.tm_min = 0;
1370         start_date.tm_sec = 0;
1371         time_t start_time = mktime(&start_date);
1372
1373         SETTING_TRACE("start_time :%s", ctime(&start_time));
1374         SETTING_TRACE("to_time :%s", ctime(&to_time));
1375
1376         if (start) {
1377                 *start = start_time;
1378         }
1379         if (end) {
1380                 *end = to_time;
1381         }
1382
1383         // days in current month
1384         int day_in_month = end_date.tm_mday;
1385         SETTING_TRACE("day_in_month :%d", day_in_month);
1386
1387         int left_day = day_in_month - starting_date;
1388
1389         return left_day > 0 ? left_day : 0;
1390 }
1391
1392 /**
1393   * This function get the start day and the end day in current week
1394   * @start : output param, start day in current week
1395   * @end: output param, end day in current week
1396   * @return days between start and end
1397   */
1398 static int __setting_datausage_main_days_in_week_get(time_t *start, time_t *end)
1399 {
1400         time_t cur_time = time(0);
1401
1402         struct tm start_date;
1403         if (NULL == localtime_r(&cur_time, &start_date)) {
1404                 SETTING_TRACE_ERROR("fail to call localtime_r");
1405                 return 0;
1406         }
1407         int cur_wday = start_date.tm_wday;  /* current day in week */
1408         int cur_mday = start_date.tm_mday;  /* current day in month */
1409
1410         start_date.tm_mday = cur_mday - cur_wday;
1411         start_date.tm_hour = 0;
1412         start_date.tm_min = 0;
1413         start_date.tm_sec = 0;
1414         time_t from_time = mktime(&start_date);
1415
1416         struct tm end_data;
1417         if (NULL == localtime_r(&from_time, &end_data)) {
1418                 SETTING_TRACE_ERROR("fail to call localtime_r");
1419                 return 0;
1420         }
1421         cur_mday = end_data.tm_mday;
1422         end_data.tm_mday = cur_mday + 6;   /* get the last day in current week */
1423         end_data.tm_hour = 23;
1424         end_data.tm_min = 59;
1425         end_data.tm_sec = 59;
1426         time_t end_time = mktime(&end_data);
1427
1428         SETTING_TRACE("from_time :%s", ctime(&from_time));
1429         SETTING_TRACE("end_time :%s", ctime(&end_time));
1430
1431         if (start) {
1432                 *start = from_time;
1433         }
1434         if (end) {
1435                 *end = end_time;
1436         }
1437
1438         return SETTING_DATAUSAGE_DAYS_IN_WEEK;
1439 }
1440
1441
1442 /**
1443   * This function get the apps info in current month.
1444   */
1445 static Eina_List * __setting_datausage_main_apps_info_in_cur_month_get(void *data)
1446 {
1447         SETTING_TRACE_BEGIN;
1448         setting_retvm_if(data == NULL, NULL, "data is NULL");
1449         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1450
1451         time_t from_time;
1452         time_t to_time;
1453         int match_days  = __setting_datausage_main_days_in_month_get(&from_time, &to_time);
1454
1455         SETTING_TRACE("from_time :%s", ctime(&from_time));
1456         SETTING_TRACE("to_time :%s", ctime(&to_time));
1457
1458         Eina_List *list = NULL;
1459         data_usage_selection_rule rule = { 0 };
1460
1461         /* if  match_days is 0, means start day is same with end day*/
1462         match_days = match_days > 0 ? match_days : 1;
1463         SETTING_TRACE("match_days :%d", match_days);
1464
1465         rule.granularity = 3600 * 24 * match_days;
1466         rule.iftype = ad->iftype;
1467         rule.from = from_time;
1468         rule.to = to_time;
1469
1470         data_usage_foreach(&rule, __setting_datausage_main_apps_network_stats_get_cb,
1471                            (void *)&list);
1472
1473         return list;
1474 }
1475
1476 static Eina_List * __setting_datausage_main_apps_info_in_cur_week_get(void *data)
1477 {
1478         SETTING_TRACE_BEGIN;
1479         setting_retvm_if(data == NULL, NULL, "data is NULL");
1480         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1481
1482         time_t from_time;
1483         time_t to_time;
1484         int match_days = __setting_datausage_main_days_in_week_get(&from_time, &to_time);
1485
1486         SETTING_TRACE("from_time :%s", ctime(&from_time));
1487         SETTING_TRACE("to_time :%s", ctime(&to_time));
1488
1489         Eina_List *list = NULL;
1490         data_usage_selection_rule rule = { 0 };
1491
1492         rule.granularity = 3600 * 24 * match_days;
1493         rule.iftype = ad->iftype;
1494         rule.from = from_time;
1495         rule.to = to_time;
1496
1497         data_usage_foreach(&rule, __setting_datausage_main_apps_network_stats_get_cb,
1498                            (void *)&list);
1499
1500         return list;
1501 }
1502
1503 static Eina_List * __setting_datausage_main_apps_info_in_cur_day_get(void *data)
1504 {
1505         SETTING_TRACE_BEGIN;
1506         setting_retvm_if(data == NULL, NULL, "data is NULL");
1507         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1508
1509         time_t cur_time = time(0);
1510
1511         struct tm start_date;
1512         if (NULL == localtime_r(&cur_time, &start_date)) {
1513                 SETTING_TRACE_ERROR("fail to call localtime_r");
1514                 return NULL;
1515         }
1516         start_date.tm_hour = 0;
1517         start_date.tm_min = 0;
1518         start_date.tm_sec = 0;
1519         time_t from_time = mktime(&start_date);
1520         SETTING_TRACE("start_data :%s", asctime(&start_date));
1521
1522         struct tm end_date;
1523         if (NULL == localtime_r(&from_time, &end_date)) {
1524                 SETTING_TRACE_ERROR("fail to call localtime_r");
1525                 return NULL;
1526         }
1527         end_date.tm_hour = 23;
1528         end_date.tm_min = 59;
1529         end_date.tm_sec = 59;
1530         time_t end_time = mktime(&end_date);
1531         SETTING_TRACE("end_time :%s", ctime(&end_time));
1532
1533         Eina_List *list = NULL;
1534         data_usage_selection_rule rule = { 0 };
1535
1536         rule.granularity = 3600 * 24;
1537         rule.iftype = ad->iftype;
1538         rule.from = from_time;
1539         rule.to = end_time;
1540
1541         data_usage_foreach(&rule, __setting_datausage_main_apps_network_stats_get_cb,
1542                            (void *)&list);
1543
1544         return list;
1545 }
1546
1547 static Eina_List *__setting_datausage_main_apps_network_stats_get(void *data)
1548 {
1549         SETTING_TRACE_BEGIN;
1550         setting_retvm_if(data == NULL, NULL, "data is NULL");
1551         SettingDatausageUG *ad = (SettingDatausageUG *)data;
1552
1553         int err = 0;
1554         int cycle = 0;
1555         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &cycle, &err);
1556         if (ret != 0) {
1557                 SETTING_TRACE_ERROR("get vconf failed");
1558         }
1559
1560         __setting_datausage_main_apps_list_destroy(ad);
1561
1562         switch (cycle) {
1563         case 0: /* month */
1564                 return __setting_datausage_main_apps_info_in_cur_month_get(ad);
1565         case 1: /* week */
1566                 return __setting_datausage_main_apps_info_in_cur_week_get(ad);
1567         case 2: /* day */
1568                 return __setting_datausage_main_apps_info_in_cur_day_get(ad);
1569         default:
1570                 /* do nothing */
1571                 return NULL;
1572         }
1573 }
1574
1575 static rsml_cb_ret __setting_datausage_main_data_get_cb(const rsml_perf_info *info, void *user_data)
1576 {
1577         unsigned long long sum = 0;
1578         sum += (unsigned long long)info->foreground.cnt.incoming_bytes;
1579         sum += (unsigned long long)info->background.cnt.incoming_bytes;
1580
1581         *((unsigned long long *)user_data) = sum;
1582         return RESMAN_CONTINUE;
1583 }
1584
1585 /**
1586   * This function get the data of per day in current month.
1587   */
1588 static void __setting_datausage_main_days_info_in_cur_month_get(void *data)
1589 {
1590         SETTING_TRACE_BEGIN;
1591         setting_retm_if(data == NULL, "data is NULL");
1592         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1593
1594         int starting_date = 0;
1595         int err = 0;
1596         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, &starting_date, &err);
1597         if (ret != 0) {
1598                 SETTING_TRACE_ERROR("get vconf failed");
1599         }
1600         //SETTING_TRACE("starting date is %d", starting_data);
1601
1602         int days = __setting_datausage_main_days_in_month_get(NULL, NULL);
1603         SETTING_TRACE("days is %d", days);
1604
1605         ad->data_arr_len = days + 1;
1606         int i = 0;
1607         for (; i <= days; i++) {
1608                 if (i >= SETTING_DATAUSAGE_DAYS_IN_MONTH) {
1609                         break;
1610                 }
1611
1612                 time_t cur_time = time(0);
1613
1614                 struct tm start_date;
1615                 if (NULL == localtime_r(&cur_time, &start_date)) {
1616                         SETTING_TRACE_ERROR("fail to call localtime_r");
1617                         return;
1618                 }
1619                 start_date.tm_mday = starting_date + i;    /* set the start day as vonf value*/
1620                 start_date.tm_hour = 0;
1621                 start_date.tm_min = 0;
1622                 start_date.tm_sec = 0;
1623                 time_t from_time = mktime(&start_date);
1624
1625                 struct tm end_date;
1626                 if (NULL == localtime_r(&from_time, &end_date)) {
1627                         SETTING_TRACE_ERROR("fail to call localtime_r");
1628                         return;
1629                 }
1630                 end_date.tm_hour = 23;
1631                 end_date.tm_min = 59;
1632                 end_date.tm_sec = 59;
1633                 time_t to_time = mktime(&end_date);
1634
1635                 SETTING_TRACE("from_time :%s", ctime(&from_time));
1636                 SETTING_TRACE("to_time :%s", ctime(&to_time));
1637
1638                 unsigned long long cnt = 0;
1639                 data_usage_selection_rule rule = { 0 };
1640
1641                 rule.granularity = 3600 * 24;
1642                 rule.iftype = ad->iftype;
1643                 rule.from = from_time;
1644                 rule.to = to_time;
1645
1646                 rsml_ret_c ret = data_usage_foreach(&rule, __setting_datausage_main_data_get_cb,
1647                                            (void *)&cnt);
1648                 SETTING_TRACE("ret : %d, cnt : %lld", ret, cnt);
1649                 ad->data_arr[i] = cnt;
1650         }
1651 }
1652
1653 /**
1654   * This function get the data of per day in current week.
1655   */
1656 static void __setting_datausage_main_days_info_in_cur_week_get(void *data)
1657 {
1658         SETTING_TRACE_BEGIN;
1659         setting_retm_if(data == NULL, "data is NULL");
1660         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1661
1662         time_t cur_time = time(0);
1663
1664         struct tm begin_date;
1665         if (NULL == localtime_r(&cur_time, &begin_date)) {
1666                 SETTING_TRACE_ERROR("fail to call localtime_r");
1667                 return;
1668         }
1669         int cur_wday = begin_date.tm_wday;  /* current day in week */
1670         SETTING_TRACE("cur_wday :%d", cur_wday);
1671         int cur_mday = begin_date.tm_mday;  /* current day in month */
1672
1673         SETTING_TRACE("cur_mday :%d", cur_mday);
1674         begin_date.tm_mday = cur_mday - cur_wday;
1675         time_t begin_time = mktime(&begin_date);
1676         SETTING_TRACE("from_time :%s", ctime(&begin_time));
1677
1678         int starting_date = cur_mday - cur_wday;
1679
1680         ad->data_arr_len = SETTING_DATAUSAGE_DAYS_IN_WEEK;
1681         int i = 0;
1682         for (; i < ad->data_arr_len; i++) {
1683                 time_t cur_time = time(0);
1684
1685                 struct tm start_date;
1686                 if (NULL == localtime_r(&cur_time, &start_date)) {
1687                         SETTING_TRACE_ERROR("fail to call localtime_r");
1688                         return;
1689                 }
1690                 start_date.tm_mday = starting_date + i;    /* set the start day as vonf value*/
1691                 start_date.tm_hour = 0;
1692                 start_date.tm_min = 0;
1693                 start_date.tm_sec = 0;
1694                 time_t from_time = mktime(&start_date);
1695
1696                 struct tm end_date;
1697                 if (NULL == localtime_r(&from_time, &end_date)) {
1698                         SETTING_TRACE_ERROR("fail to call localtime_r");
1699                         return;
1700                 }
1701                 end_date.tm_hour = 23;
1702                 end_date.tm_min = 59;
1703                 end_date.tm_sec = 59;
1704                 time_t to_time = mktime(&end_date);
1705
1706                 SETTING_TRACE("from_time :%s", ctime(&from_time));
1707                 SETTING_TRACE("to_time :%s", ctime(&to_time));
1708
1709                 unsigned long long cnt = 0;
1710                 data_usage_selection_rule rule = { 0 };
1711
1712                 rule.granularity = 3600 * 24;
1713                 rule.iftype = ad->iftype;
1714                 rule.from = from_time;
1715                 rule.to = to_time;
1716
1717                 rsml_ret_c ret = data_usage_foreach(&rule, __setting_datausage_main_data_get_cb,
1718                                            (void *)&cnt);
1719                 SETTING_TRACE("ret : %d", ret);
1720                 ad->data_arr[i] = cnt;
1721         }
1722 }
1723
1724 /**
1725   * This function get the data of per day in current week.
1726   */
1727 static void __setting_datausage_main_hours_info_in_cur_day_get(void *data)
1728 {
1729         SETTING_TRACE_BEGIN;
1730         setting_retm_if(data == NULL, "data is NULL");
1731         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1732
1733         time_t cur_time = time(0);
1734
1735         ad->data_arr_len = SETTING_DATAUSAGE_HOURS_IN_DAY;
1736         int i = 0;
1737         for (; i < ad->data_arr_len; i++) {
1738                 struct tm start;
1739                 if (NULL == localtime_r(&cur_time, &start)) {
1740                         SETTING_TRACE_ERROR("fail to call localtime_r");
1741                         return;
1742                 }
1743                 start.tm_hour = i;
1744                 start.tm_min = 0;
1745                 start.tm_sec = 0;
1746                 time_t from_time = mktime(&start);
1747
1748                 struct tm end;
1749                 if (NULL == localtime_r(&from_time, &end)) {
1750                         SETTING_TRACE_ERROR("fail to call localtime_r");
1751                         return;
1752                 }
1753                 end.tm_hour = i;
1754                 end.tm_min = 59;
1755                 end.tm_sec = 59;
1756                 time_t to_time = mktime(&end);
1757
1758                 SETTING_TRACE("from_time :%s", ctime(&from_time));
1759                 SETTING_TRACE("to_time :%s", ctime(&to_time));
1760
1761                 unsigned long long cnt = 0;
1762                 data_usage_selection_rule rule = { 0 };
1763
1764                 rule.granularity = 3600;
1765                 rule.iftype = ad->iftype;
1766                 rule.from = from_time;
1767                 rule.to = to_time;
1768
1769                 rsml_ret_c ret = data_usage_foreach(&rule, __setting_datausage_main_data_get_cb,
1770                                            (void *)&cnt);
1771                 SETTING_TRACE("ret : %d", ret);
1772                 ad->data_arr[i] = cnt;
1773         }
1774 }
1775
1776
1777 /**
1778   * This function will get the data
1779   * 1. If "Data usage cycle" is month, get the data of per day in current month
1780   * 2. If "Data usage cycle" is week, get the data of per day in current week
1781   * 3. If "Data usage cycle" is day, get the data of per hour in current day
1782   * 'Starting date" is only activated when user selected "Month".
1783   * So If user selected starting date by 1, graph shows on every month that day.
1784   */
1785 static void __setting_datausage_main_data_stats_get(void *data)
1786 {
1787         SETTING_TRACE_BEGIN;
1788         setting_retm_if(NULL == data, "data is NULL");
1789         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1790
1791         int err = 0;
1792         int cycle = 0;
1793         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &cycle, &err);
1794         if (ret != 0) {
1795                 SETTING_TRACE_ERROR("get vconf failed");
1796         }
1797
1798         switch (cycle) {
1799         case 0: /* month */
1800                 __setting_datausage_main_days_info_in_cur_month_get(ad);
1801                 return;
1802         case 1: /* week */
1803                 __setting_datausage_main_days_info_in_cur_week_get(ad);
1804                 return;
1805         case 2: /* day */
1806                 __setting_datausage_main_hours_info_in_cur_day_get(ad);
1807                 return;
1808         default:
1809                 /* do nothing */
1810                 return;
1811         }
1812 }
1813
1814
1815 static void __setting_datausage_main_app_list_item_append(rsml_perf_info *pNode, void *data)
1816 {
1817         SETTING_TRACE_BEGIN;
1818         setting_retm_if(NULL == data, "data is NULL");
1819         setting_retm_if(NULL == pNode, "pNode is NULL");
1820         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1821
1822         unsigned long long byte_size = 0;
1823         byte_size += pNode->foreground.cnt.outgoing_bytes;
1824         byte_size += pNode->foreground.cnt.incoming_bytes;
1825         char size[MAX_DISPLAY_NAME_LEN_ON_UI] = {0,};
1826         __setting_datausage_main_size_transition(byte_size, size);
1827         //SETTING_TRACE("pkg = %s, size = %s ", pNode->app_id, size);
1828
1829         double percent = (double)byte_size / ad->apps_total_size;
1830         char desc[MAX_DISPLAY_NAME_LEN_ON_UI] = {0,};
1831         snprintf(desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%s/%4.2lf%%", size, percent * 100);
1832
1833         Setting_GenGroupItem_Data *item_data = NULL;
1834         item_data = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1835         setting_retm_if(!item_data, "calloc failed");
1836
1837         if (item_data) {
1838                 item_data->keyStr = (char *)g_strdup(pNode->app_id);
1839                 item_data->sub_desc = (char *)g_strdup(desc);
1840                 item_data->userdata = pNode;
1841                 item_data->slider_min = percent; /* use slider_min to store the percent here */
1842                 item_data->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), item_data, NULL,
1843                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
1844                 elm_genlist_item_select_mode_set(item_data->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1845         } else {
1846                 SETTING_TRACE_ERROR("item_data is NULL");
1847         }
1848
1849 }
1850
1851 static Eina_Bool __setting_datausage_main_animator_cb(void *data)
1852 {
1853         //SETTING_TRACE_BEGIN;
1854         setting_retvm_if(NULL == data, ECORE_CALLBACK_CANCEL, "data is NULL");
1855         SettingDatausageUG *ad = (SettingDatausageUG *) data;
1856
1857         int count = eina_list_count(ad->app_list);
1858
1859         //SETTING_TRACE("app_list_index= %d", ad->app_list_index);
1860         if (ad->app_list_index >= count) {
1861                 if (ad->animator) {
1862                         ecore_animator_del(ad->animator);
1863                         ad->animator = NULL;
1864                 }
1865
1866                 Elm_Object_Item *item = NULL;
1867                 item = elm_genlist_item_append(ad->genlist, &(ad->itc_seperator), NULL, NULL,
1868                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
1869                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1870
1871                 return ECORE_CALLBACK_CANCEL;
1872         }
1873
1874         int i = ad->app_list_index++;
1875
1876         rsml_perf_info *pNode = NULL;
1877         pNode = (rsml_perf_info *)eina_list_nth(ad->app_list, i);
1878         setting_retvm_if(NULL == pNode, ECORE_CALLBACK_RENEW, "pNode is NULL");
1879
1880         __setting_datausage_main_app_list_item_append(pNode, ad);
1881         return ECORE_CALLBACK_RENEW;
1882 }
1883
1884 static void __setting_datausage_main_date_desc_get(char *desc)
1885 {
1886         SETTING_TRACE_BEGIN;
1887         setting_retm_if(NULL == desc, "desc is NULL");
1888
1889         int err = 0;
1890         int cycle = 0;
1891         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &cycle, &err);
1892         if (ret != 0) {
1893                 SETTING_TRACE_ERROR("get vconf failed");
1894         }
1895
1896         time_t from_time;
1897         time_t to_time;
1898         switch (cycle) {
1899         case 0: /* month */
1900                 {
1901                 __setting_datausage_main_days_in_month_get(&from_time, &to_time);
1902                 break;
1903                 }
1904         case 1: /* week */
1905                 {
1906                 __setting_datausage_main_days_in_week_get(&from_time, &to_time);
1907                 break;
1908                 }
1909         case 2: /* day */
1910                 {
1911                 from_time = time(0);
1912                 to_time = time(0);
1913                 break;
1914                 }
1915         default:
1916                 {
1917                 /* do nothing */
1918                 SETTING_TRACE_ERROR("wrong data usage cycle");
1919                 return;
1920                 }
1921         }
1922
1923         struct tm start_date;
1924         if (NULL == localtime_r(&from_time, &start_date)) {
1925                 SETTING_TRACE_ERROR("fail to call localtime_r");
1926                 return;
1927         }
1928
1929         struct tm end_date;
1930         if (NULL == localtime_r(&to_time, &end_date)) {
1931                 SETTING_TRACE_ERROR("fail to call localtime_r");
1932                 return;
1933         }
1934
1935         char start_date_desc[MAX_DISPLAY_NAME_LEN_ON_UI] = {0,};
1936         strftime(start_date_desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%b", &start_date);
1937
1938         int start_day = start_date.tm_mday;
1939         int end_day = end_date.tm_mday;
1940
1941         if (start_day == end_day) {
1942                 snprintf(desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%s %d", start_date_desc, start_day);
1943         } else {
1944                 snprintf(desc, MAX_DISPLAY_NAME_LEN_ON_UI, "%s %d-%d", start_date_desc, start_day, end_day);
1945         }
1946 }
1947
1948 static void __setting_datausage_main_data_items_append(void *data)
1949 {
1950         SETTING_TRACE_BEGIN;
1951         setting_retm_if(data == NULL, "data is NULL");
1952         SettingDatausageUG *ad = (SettingDatausageUG *)data;
1953         Elm_Object_Item *item = NULL;
1954
1955         __setting_datausage_main_data_stats_get(ad);
1956         __setting_datausage_main_maximum_get(ad);
1957
1958         int value = 0;
1959         int err = 0;
1960         int ret = 0;
1961
1962         ret = setting_get_bool_slp_key(BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_BOOL, &value, &err);
1963         if (ret != 0) {
1964                 SETTING_TRACE_ERROR("get vconf failed");
1965         }
1966
1967         if (value && ad->iftype == RESMAN_IFACE_DATACALL) {
1968                 /* limit graph */
1969                 ad->limit_graph = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1970                 setting_retm_if(!ad->limit_graph, "calloc failed");
1971
1972                 if (ad->limit_graph) {
1973                         ad->limit_graph->userdata = ad;
1974                         ad->limit_graph->keyStr = (char *)g_strdup("limit_graph");
1975                         ad->limit_graph->item = elm_genlist_item_append(ad->genlist, &(ad->itc_variable_height), ad->limit_graph, NULL,
1976                                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
1977                         elm_genlist_item_select_mode_set(ad->limit_graph->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1978                 } else {
1979                         SETTING_TRACE_ERROR("ad->limit_graph is NULL");
1980                         return;
1981                 }
1982         }
1983
1984         /* graph image */
1985         ad->graph_image = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1986         setting_retm_if(!ad->graph_image, "calloc failed");
1987
1988         if (ad->graph_image) {
1989                 ad->graph_image->userdata = ad;
1990                 ad->graph_image->keyStr = (char *)g_strdup("graph_image");
1991                 ad->graph_image->item = elm_genlist_item_append(ad->genlist, &(ad->itc_variable_height), ad->graph_image, NULL,
1992                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
1993                 elm_genlist_item_select_mode_set(ad->graph_image->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1994         } else {
1995                 SETTING_TRACE_ERROR("ad->graph_image is NULL");
1996                 return;
1997         }
1998
1999         /* description */
2000         char date_info[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
2001         __setting_datausage_main_date_desc_get(date_info);
2002
2003         char used_size[MAX_DISPLAY_NAME_LEN_ON_UI] = {0};
2004         __setting_datausage_main_size_transition(ad->total_size, used_size);
2005
2006         char used_str[SETTING_DATAUSAGE_DESC_LEN_MAX + 1] = {0,};
2007         snprintf(used_str, SETTING_DATAUSAGE_DESC_LEN_MAX, SETTING_DATAUSAGE_GRAPH_DESC_STR,
2008                         date_info, used_size);
2009
2010         char desc_str[2 * SETTING_DATAUSAGE_DESC_LEN_MAX + 1] = {0,};
2011         snprintf(desc_str, 2 * SETTING_DATAUSAGE_DESC_LEN_MAX, "%s<br><br>%s<br>",
2012                         used_str, _(SETTING_DATAUSAGE_DESC_STR));
2013         ad->graph_desc = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_variable_height), NULL,
2014                                          ad, SWALLOW_Type_INVALID,
2015                                          NULL, NULL, 0, desc_str, NULL,
2016                                          NULL);
2017         if (ad->graph_desc) {
2018                 ad->graph_desc->userdata = ad;
2019                 elm_genlist_item_select_mode_set(ad->graph_desc->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2020         } else {
2021                 SETTING_TRACE_ERROR("ad->graph_desc is NULL");
2022                 return;
2023         }
2024
2025         Eina_List *app_list = __setting_datausage_main_apps_network_stats_get(ad);
2026         ad->app_list = app_list;
2027
2028         int count = eina_list_count(ad->app_list);
2029         SETTING_TRACE("count = %d", eina_list_count(ad->app_list));
2030
2031         ad->app_list_index = 0;
2032
2033         /* calculate the total size of all apps */
2034         ad->apps_total_size = 0;
2035         Eina_List *l = NULL;
2036         rsml_perf_info *new_item;
2037         EINA_LIST_FOREACH(ad->app_list, l, new_item)
2038         {
2039                 ad->apps_total_size += new_item->foreground.cnt.outgoing_bytes;
2040                 ad->apps_total_size += new_item->foreground.cnt.incoming_bytes;
2041         }
2042
2043         int i = 0;
2044         for (; i < SETTING_DATAUSAGE_ANIMATOR_START_INDEX; i++) {
2045                 rsml_perf_info *pNode = NULL;
2046                 pNode = (rsml_perf_info *)eina_list_nth(ad->app_list, i);
2047                 if (pNode == NULL)
2048                         continue;
2049
2050                 __setting_datausage_main_app_list_item_append(pNode, ad);
2051         }
2052
2053         ad->app_list_index = i;
2054
2055         if(count > SETTING_DATAUSAGE_ANIMATOR_START_INDEX) {
2056                 /* to continue adding items using animator */
2057                 if (ad->animator) {
2058                         ecore_animator_del(ad->animator);
2059                         ad->animator = NULL;
2060                 }
2061                 ad->animator = ecore_animator_add(__setting_datausage_main_animator_cb, ad);
2062         } else if (count <= SETTING_DATAUSAGE_ANIMATOR_START_INDEX && count > 0) {
2063                 item = elm_genlist_item_append(ad->genlist, &(ad->itc_seperator), NULL, NULL,
2064                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
2065                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2066         } else {
2067                 Setting_GenGroupItem_Data *no_app_item =  NULL;
2068                 no_app_item = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
2069                                                      NULL,
2070                                                      NULL, SWALLOW_Type_INVALID, NULL,
2071                                                      NULL, 0, SETTING_DATAUSAGE_NO_APPS_USE_DATA_STR,
2072                                                      NULL, NULL);
2073                 if (no_app_item) {
2074                         setting_disable_genlist_item(no_app_item->item);
2075                 } else {
2076                         SETTING_TRACE_ERROR("no_app_item is NULL");
2077                         return;
2078                 }
2079
2080                 item = elm_genlist_item_append(ad->genlist, &(ad->itc_seperator), NULL, NULL,
2081                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
2082                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2083         }
2084 }
2085
2086 static void __setting_datausage_main_data_items_recreate(void *data)
2087 {
2088         SETTING_TRACE_BEGIN;
2089         setting_retm_if(data == NULL, "data is NULL");
2090         SettingDatausageUG *ad = (SettingDatausageUG *)data;
2091
2092         /* delete all data items in genlist */
2093         setting_retm_if(ad->starting_date == NULL, "ad->starting_date is NULL");
2094         Elm_Object_Item *item = elm_genlist_item_next_get(ad->starting_date->item);
2095         while (item) {
2096                 elm_object_item_del(item);
2097                 item = elm_genlist_item_next_get(ad->starting_date->item);
2098         }
2099
2100         __setting_datausage_main_cairo_destroy(ad);
2101         __setting_datausage_main_limit_cairo_destroy(ad);
2102
2103         /* recreate the data items in genlist */
2104         __setting_datausage_main_data_items_append(ad);
2105 }
2106
2107 static void __setting_datausage_main_common_list_create(void *data)
2108 {
2109         SETTING_TRACE_BEGIN;
2110         setting_retm_if(data == NULL, "data is NULL");
2111         SettingDatausageUG *ad = (SettingDatausageUG *)data;
2112
2113         Elm_Object_Item *item = NULL;
2114         item = elm_genlist_item_append(ad->genlist, &(ad->itc_seperator), NULL, NULL,
2115                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
2116         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2117
2118         /* Data usage cycle */
2119         ad->data_usage_cycle = setting_create_Gendial_exp_parent_field(ad->genlist,
2120                                                         &(ad->itc_2text_3_parent),
2121                                                         NULL, NULL,
2122                                                         SWALLOW_Type_INVALID,
2123                                                         SETTING_DATAUSAGE_DATA_USAGE_CYCLE_STR,
2124                                                         __setting_datausage_main_data_usage_cycle_get());
2125         if (ad->data_usage_cycle) {
2126                 ad->data_usage_cycle->userdata = ad;
2127                 ad->data_usage_cycle->int_slp_setting_binded = INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT;
2128         } else {
2129                 SETTING_TRACE_ERROR("ad->data_usage_cycle is NULL");
2130                 return;
2131         }
2132
2133         /* Starting date */
2134         ad->itc_1text_1icon_date.item_style = "dialogue/1text.1icon";
2135         ad->itc_1text_1icon_date.func.text_get = _item_label_get;
2136         ad->itc_1text_1icon_date.func.content_get = _item_content_date_get;
2137         ad->itc_1text_1icon_date.func.state_get = NULL;
2138         ad->itc_1text_1icon_date.func.del = _item_del;
2139
2140         Setting_GenGroupItem_Data *starting_date = (Setting_GenGroupItem_Data *)calloc(1, sizeof(Setting_GenGroupItem_Data));
2141         setting_retm_if(!starting_date, "calloc failed");
2142         ad->starting_date = starting_date;
2143         starting_date->userdata = ad;
2144         starting_date->keyStr = (char *)g_strdup(SETTING_DATAUSAGE_STARTING_DATE_STR);
2145
2146         starting_date->item = elm_genlist_item_append(ad->genlist, &(ad->itc_1text_1icon_date), starting_date, NULL,
2147                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
2148         elm_genlist_item_select_mode_set(starting_date->item, ELM_OBJECT_SELECT_MODE_NONE);
2149
2150         __setting_datausage_main_data_items_append(ad);
2151 }
2152
2153
2154 static void __setting_datausage_main_mobile_list_create(void *data)
2155 {
2156         SETTING_TRACE_BEGIN;
2157         setting_retm_if(data == NULL, "data is NULL");
2158         SettingDatausageUG *ad = (SettingDatausageUG *)data;
2159
2160         elm_genlist_clear(ad->genlist); /* first to clear list */
2161
2162         __setting_datausage_main_cairo_destroy(ad);
2163         __setting_datausage_main_limit_cairo_destroy(ad);
2164
2165         Elm_Object_Item *item = NULL;
2166         item = elm_genlist_item_append(ad->genlist, &(ad->itc_seperator), NULL, NULL,
2167                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
2168         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
2169
2170         int value = 0;
2171         int err = 0;
2172         int ret = 0;
2173
2174         /* Use packet data - ON/OFF */
2175         ret = setting_get_bool_slp_key(BOOL_SLP_SETTING_USE_PACKET_DATA, &value, &err);
2176         if (ret != 0) {
2177                 SETTING_TRACE_ERROR("get vconf failed");
2178         }
2179         ad->use_packet_data = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text_1icon),
2180                                              __setting_datausage_main_mouse_up_Gendial_list_cb,
2181                                              ad, SWALLOW_Type_1TOGGLE, NULL,
2182                                              NULL, value,
2183                                              KeyStr_UsePacketData, NULL,
2184                                              __setting_datausage_main_chk_btn_cb);
2185         if (ad->use_packet_data) {
2186                 ad->use_packet_data->userdata = ad;
2187
2188                 /* if flight mode is on, disable Use packet data */
2189                 int value = 0;
2190                 int err = 0;
2191                 setting_get_bool_slp_key(BOOL_SLP_SETTING_FLIGHT_MODE, &value, &err);
2192                 if (value) {
2193                         setting_disable_genlist_item(ad->use_packet_data->item);
2194                 }
2195         } else {
2196                 SETTING_TRACE_ERROR("ad->data_use_packet is NULL");
2197                 return;
2198         }
2199
2200         /* Set data usage limit -ON/OFF */
2201         ret = setting_get_bool_slp_key(BOOL_SLP_SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_BOOL, &value, &err);
2202         if (ret != 0) {
2203                 SETTING_TRACE_ERROR("get vconf failed");
2204         }
2205         ad->set_data_usage_limit = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text_1icon),
2206                                              __setting_datausage_main_mouse_up_Gendial_list_cb,
2207                                              ad, SWALLOW_Type_1TOGGLE, NULL,
2208                                              NULL, value, SETTING_DATAUSAGE_SET_DATA_USAGE_LIMIT_STR,
2209                                              NULL, __setting_datausage_main_chk_btn_cb);
2210         if (ad->set_data_usage_limit) {
2211                 ad->set_data_usage_limit->userdata = ad;
2212         } else {
2213                 SETTING_TRACE_ERROR("ad->set_data_usage_limit is NULL");
2214                 return;
2215         }
2216
2217         /* Data limit */
2218         ad->data_limit = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
2219                                              __setting_datausage_main_mouse_up_Gendial_list_cb,
2220                                              ad, SWALLOW_Type_INVALID, NULL,
2221                                              NULL, 0, SETTING_DATAUSAGE_DATA_LIMIT_STR,
2222                                              NULL, NULL);
2223         if (ad->data_limit) {
2224                 ad->data_limit->userdata = ad;
2225
2226                 /* if set_data_usage_limit's vconf is false, disable data_limit */
2227                 if (!value) {
2228                         setting_disable_genlist_item(ad->data_limit->item);
2229                 }
2230         } else {
2231                 SETTING_TRACE_ERROR("ad->data_limit is NULL");
2232                 return;
2233         }
2234
2235         __setting_datausage_main_common_list_create(ad);
2236 }
2237
2238 static void __setting_datausage_main_wifi_list_create(void *data)
2239 {
2240         SETTING_TRACE_BEGIN;
2241         setting_retm_if(data == NULL, "data is NULL");
2242         SettingDatausageUG *ad = (SettingDatausageUG *)data;
2243
2244         elm_genlist_clear(ad->genlist); /* first to clear list */
2245         __setting_datausage_main_cairo_destroy(ad);
2246         __setting_datausage_main_limit_cairo_destroy(ad);
2247
2248         __setting_datausage_main_common_list_create(ad);
2249 }
2250
2251 static void _first_tab_cb(void* data, Evas_Object* obj, void* event_info)
2252 {
2253         SettingDatausageUG *ad = (SettingDatausageUG *) data;
2254         ad->iftype = RESMAN_IFACE_DATACALL;
2255         __setting_datausage_main_mobile_list_create(ad);
2256 }
2257
2258 static void _second_tab_cb(void* data, Evas_Object* obj, void* event_info)
2259 {
2260         SettingDatausageUG *ad = (SettingDatausageUG *) data;
2261         ad->iftype = RESMAN_IFACE_WIFI;
2262         __setting_datausage_main_wifi_list_create(ad);
2263 }
2264
2265 static void __setting_datausage_main_sub_list_sel_cb(void *data, Evas_Object *obj, void *event_info)
2266 {
2267         SETTING_TRACE_BEGIN;
2268         setting_retm_if(event_info == NULL, "Invalid argument: event info is NULL");
2269         setting_retm_if(NULL == data, "data is NULL");
2270         SettingDatausageUG *ad = (SettingDatausageUG *) data;
2271
2272         Elm_Object_Item *subitem = (Elm_Object_Item *) event_info;
2273         Elm_Object_Item *parentItem = elm_genlist_item_parent_get(subitem);
2274         elm_genlist_item_selected_set(subitem, 0);
2275         Setting_GenGroupItem_Data *data_subItem = elm_object_item_data_get(subitem);
2276         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);      /* parent data */
2277         ret_if(NULL == data_subItem || NULL == data_parentItem);
2278
2279         elm_radio_value_set(data_subItem->rgd, data_subItem->chk_status);
2280         int err = 0;
2281         setting_set_int_slp_key(data_parentItem->int_slp_setting_binded,
2282                                 data_subItem->chk_status, &err);
2283         setting_retm_if(0 != err, "Set vconf error[%d]",data_parentItem->int_slp_setting_binded);
2284
2285         data_parentItem->sub_desc = (char *)g_strdup(_(data_subItem->keyStr));
2286         elm_object_item_data_set(data_parentItem->item, data_parentItem);
2287         elm_genlist_item_update(data_parentItem->item);
2288
2289         /* recreate the data items in genlist */
2290         __setting_datausage_main_data_items_recreate(ad);
2291 }
2292
2293 static void __setting_datausage_main_exp_cb(void *data, Evas_Object *obj, void *event_info)
2294 {
2295         SETTING_TRACE_BEGIN;
2296         setting_retm_if(NULL == data, "data is NULL");
2297         setting_retm_if(NULL == event_info, "event_info is NULL");
2298         SettingDatausageUG *ad = (SettingDatausageUG *) data;
2299         Elm_Object_Item *parentItem = event_info;       /* parent item */
2300
2301         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);      /* parent data */
2302         Evas_Object *scroller = elm_object_item_widget_get(parentItem);
2303
2304         Evas_Object *rgd = NULL;
2305         if (data_parentItem == ad->data_usage_cycle) {
2306                 rgd = elm_radio_add(scroller);
2307                 elm_radio_value_set(rgd, -1);
2308
2309                 int i = 0;
2310                 while (data_usage_cycle_arr[i]) {
2311                         setting_create_Gendial_exp_sub_field(scroller, &(ad->itc_1icon_1text_sub),
2312                                                      __setting_datausage_main_sub_list_sel_cb, ad,
2313                                                      parentItem, SWALLOW_Type_1RADIO, rgd,
2314                                                      i, data_usage_cycle_arr[i],
2315                                                      NULL);
2316                         i++;
2317                 }
2318
2319                 setting_update_chk_status(rgd, data_parentItem->int_slp_setting_binded);
2320         }
2321 }
2322
2323 static void __setting_datausage_main_vconf_change_cb(keynode_t *key, void *data)
2324 {
2325         SETTING_TRACE_BEGIN;
2326         setting_retm_if(NULL == key, "key is NULL");
2327         setting_retm_if(NULL == data, "data is NULL");
2328         SettingDatausageUG *ad = (SettingDatausageUG *)data;
2329
2330         int status = vconf_keynode_get_bool(key);
2331         char *vconf_name = vconf_keynode_get_name(key);
2332
2333         if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_DATA_LIMIT_INT)) {
2334                 __setting_datausage_main_datausage_quota_set();
2335                 __setting_datausage_main_data_items_recreate(ad);
2336         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_DATA_EACH_MONTH_INT)) {
2337                 if (ad->iftype == RESMAN_IFACE_DATACALL) {
2338                         __setting_datausage_main_datausage_quota_set();
2339                 }
2340
2341                 int err = 0;
2342                 int cycle = 0;
2343                 int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATAUSAGE_DATA_USAGE_CYCLE_INT, &cycle, &err);
2344                 if (ret != 0) {
2345                         SETTING_TRACE_ERROR("get vconf failed");
2346                 }
2347
2348                 /* if cycle is not month, don't need to recreate the data items in genlist */
2349                 if (cycle != 0) {
2350                         return;
2351                 }
2352
2353                 __setting_datausage_main_data_items_recreate(ad);
2354         } else if (!safeStrCmp(vconf_name, VCONFKEY_TELEPHONY_FLIGHT_MODE)) {
2355                 if (ad->use_packet_data) {
2356                         if (status) {
2357                                 setting_disable_genlist_item(ad->use_packet_data->item);
2358                         } else {
2359                                 setting_enable_genlist_item(ad->use_packet_data->item);
2360                         }
2361                 }
2362         } else {
2363                 SETTING_TRACE_ERROR("vconf_name is wrong");
2364         }
2365 }
2366
2367 /* ***************************************************
2368  *
2369  *basic func
2370  *
2371  ***************************************************/
2372 static int setting_datausage_main_create(void *cb)
2373 {
2374         SETTING_TRACE_BEGIN;
2375         setting_retvm_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER, "cb is NULL");
2376         SettingDatausageUG *ad = (SettingDatausageUG *) cb;
2377
2378         ad->itc_variable_height.item_style = "1icon";
2379         ad->itc_variable_height.func.text_get = NULL;
2380         ad->itc_variable_height.func.content_get = _item_content_get;
2381         ad->itc_variable_height.func.state_get = NULL;
2382         ad->itc_variable_height.func.del = _item_del;
2383
2384         ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
2385         ad->itc_2text_1icon_4.func.text_get = _item_label_get;
2386         ad->itc_2text_1icon_4.func.content_get = _item_content3_get;
2387         ad->itc_2text_1icon_4.func.state_get = NULL;
2388         ad->itc_2text_1icon_4.func.del = _item_del;
2389
2390         Evas_Object *layout = setting_create_win_layout(ad->win_main_layout, ad->win_get);
2391         setting_retvm_if(layout == NULL, SETTING_RETURN_FAIL, "layout is NULL");
2392         ad->ly_main = layout;
2393
2394         /* create a navigation bar */
2395         ad->navibar = setting_create_navi_bar(layout);
2396
2397         /*  add controlbar */
2398         /* create a GenList */
2399         ad->genlist = elm_genlist_add(ad->navibar);
2400
2401         if ( ! ad->genlist)
2402         {
2403                 SETTING_TRACE(">>>>> ad->genlist is NULL ");
2404         }
2405
2406         elm_object_style_set(ad->genlist, "dialogue");
2407         setting_retvm_if(ad->genlist == NULL, SETTING_RETURN_FAIL, "genlist is NULL");
2408
2409         setting_enable_expandable_genlist(ad->genlist, ad, __setting_datausage_main_exp_cb, NULL);
2410
2411         Elm_Object_Item *navi_it = NULL;
2412         Evas_Object *l_button = NULL;
2413         l_button = setting_create_button(ad->navibar, _("IDS_COM_BODY_BACK"), NAVI_BACK_BUTTON_STYLE, __setting_datausage_main_click_softkey_back_cb, ad);
2414
2415         navi_it = elm_naviframe_item_push(ad->navibar, _(KeyStr_DataUsage), l_button, NULL, ad->genlist, "tabbar");
2416         if ( ! navi_it)
2417         {
2418                 SETTING_TRACE(">>>>> navi_it is NULL ");
2419         }
2420
2421         ad->tabbar = elm_toolbar_add(ad->navibar);
2422         if ( ! ad->tabbar )
2423         {
2424                 SETTING_TRACE(">>>> ad->tabbar is NULL");
2425         }
2426
2427         elm_toolbar_shrink_mode_set(ad->tabbar, ELM_TOOLBAR_SHRINK_EXPAND);
2428         elm_object_style_set(ad->tabbar, "tabbar");
2429         elm_toolbar_transverse_expanded_set(ad->tabbar, EINA_TRUE);
2430
2431         elm_object_item_part_content_set(navi_it, "elm.swallow.tabbar", ad->tabbar);
2432
2433         if (ad->tabbar)
2434         {
2435                 ad->tabbar_item[0] = elm_toolbar_item_append(ad->tabbar, NULL, SETTING_DATAUSAGE_MOBILE_STR, _first_tab_cb,ad);
2436                 ad->tabbar_item[1] = elm_toolbar_item_append(ad->tabbar, NULL, _("IDS_ST_HEADER_WI_FI"), _second_tab_cb,ad);
2437                 elm_object_item_part_content_set(navi_it, "tabbar", ad->tabbar);
2438         }
2439
2440         elm_toolbar_select_mode_set(ad->tabbar, ELM_OBJECT_SELECT_MODE_ALWAYS);
2441         elm_toolbar_item_selected_set(ad->tabbar_item[0], EINA_TRUE);
2442
2443         int ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DATA_LIMIT_INT, __setting_datausage_main_vconf_change_cb, ad);
2444         if (ret != 0) {
2445                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
2446         }
2447
2448         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DATA_EACH_MONTH_INT,
2449                         __setting_datausage_main_vconf_change_cb, ad);
2450         if (ret != 0) {
2451                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
2452         }
2453
2454         ret = vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
2455                         __setting_datausage_main_vconf_change_cb, ad);
2456         if (ret != 0) {
2457                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
2458         }
2459
2460         setting_view_datausage_main.is_create = 1;
2461         return SETTING_RETURN_SUCCESS;
2462 }
2463
2464 static int setting_datausage_main_destroy(void *cb)
2465 {
2466         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2467         SettingDatausageUG *ad = (SettingDatausageUG *) cb;
2468
2469         int ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DATA_LIMIT_INT,
2470                         __setting_datausage_main_vconf_change_cb);
2471         if (ret != 0) {
2472                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
2473         }
2474
2475         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DATA_EACH_MONTH_INT,
2476                         __setting_datausage_main_vconf_change_cb);
2477         if (ret != 0) {
2478                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
2479         }
2480
2481         ret = vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
2482                         __setting_datausage_main_vconf_change_cb);
2483         if (ret != 0) {
2484                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
2485         }
2486
2487         __setting_datausage_main_apps_list_destroy(ad);
2488
2489         if (ad->animator) {
2490                 ecore_animator_del(ad->animator);
2491                 ad->animator = NULL;
2492         }
2493
2494         if (ad->ctxpopup) {
2495                 evas_object_del(ad->ctxpopup);
2496                 ad->ctxpopup = NULL;
2497         }
2498
2499         if (ad->data_limit_conformant) {
2500                 evas_object_del(ad->data_limit_conformant);
2501                 ad->data_limit_conformant = NULL;
2502         }
2503
2504         if (ad->data_limit_popup) {
2505                 evas_object_del(ad->data_limit_popup);
2506                 ad->data_limit_popup = NULL;
2507         }
2508
2509         __setting_datausage_main_cairo_destroy(ad);
2510         __setting_datausage_main_limit_cairo_destroy(ad);
2511
2512         if (ad->tabbar)
2513         {
2514                 evas_object_del(ad->tabbar);
2515                 ad->tabbar = NULL;
2516         }
2517
2518         if (ad->ly_main) {
2519                 evas_object_del(ad->ly_main);
2520                 ad->ly_main = NULL;
2521                 setting_view_datausage_main.is_create = 0;
2522         }
2523
2524         return SETTING_RETURN_SUCCESS;
2525 }
2526
2527 static int setting_datausage_main_update(void *cb)
2528 {
2529         SETTING_TRACE_BEGIN;
2530         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2531
2532         SettingDatausageUG *ad = (SettingDatausageUG *) cb;
2533
2534         if (ad->ly_main) {
2535                 evas_object_show(ad->ly_main);
2536         }
2537
2538         return SETTING_RETURN_SUCCESS;
2539 }
2540
2541 static int setting_datausage_main_cleanup(void *cb)
2542 {
2543         SETTING_TRACE_BEGIN;
2544         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
2545
2546         SettingDatausageUG *ad = (SettingDatausageUG *) cb;
2547
2548         if (ad->ly_main) {
2549                 evas_object_hide(ad->ly_main);
2550         }
2551
2552         return SETTING_RETURN_SUCCESS;
2553 }
2554
2555 static void __setting_datausage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
2556                                         void *event_info)
2557 {
2558         SETTING_TRACE_BEGIN;
2559         ret_if(data == NULL);
2560
2561         SettingDatausageUG *ad = (SettingDatausageUG *) data;
2562         /* Send destroy request */
2563         ug_destroy_me(ad->ug);
2564 }