src/cst-barring.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Elementary.h>
  18
  19 #include "cst-common-string.h"
  20 #include "cst-call-setting.h"
  21
  22 #include "cst-barring.h"
  23 #include "cst-barring-ime.h"
  24 #include "cst-widget.h"
  25 #include "cst-common.h"
  26 #include "cst-tapi-request.h"
  27 #include "cst-util.h"
  28
  29 static void __cst_on_click_cb_onoff(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  30
  31 static Elm_Genlist_Item_Class *itc_1text_1icon = NULL;
  32
  33 static CstGlItemDisplayInfo_t list_call_barring[] = {
  34         {1, CST_STR_CALL_ALL_OUTGOING_CALLS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  35         {1, CST_STR_INTL_CALLS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  36         {1, CST_STR_CALL_INTL_EXCEPT_HOME, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  37         {1, CST_STR_ALL_INCOMING_CALLS, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  38         {1, CST_STR_CALL_INCOMING_WHEN_ROAMING, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_1TEXT_ONOFF_PROGRESS, __cst_on_click_cb_onoff},
  39
  40         {1, -1, ELM_GENLIST_ITEM_NONE, CST_GL_ITEM_NONE, NULL},
  41 };
  42
  43 static void __cst_on_click_cb_back_button(void *data, Evas_Object *obj, void *event_info)
  44 {
  45         ENTER(__cst_on_click_cb_back_button);
  46         retm_if(data == NULL, "NULL UgData");
  47
  48         CstUgData_t *ugd = (CstUgData_t *)data;
  49         _cst_cancel_all_ss_request(ugd);
  50
  51         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
  52 }
  53
  54 static void __cst_disable_cb_glitem(CstGlItemData_t *item_data)
  55 {
  56         ENTER(__cst_disable_cb_glitem);
  57         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
  58         ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
  59         elm_genlist_item_update(item_data->gl_item);
  60         elm_object_item_disabled_set(item_data->gl_item, EINA_TRUE);
  61 }
  62
  63 static int __cst_update_cb_state(int call_type, int cb_flavour,
  64                 Eina_Bool cb_state, char *number,
  65                 int error, int req_action, void *data)
  66 {
  67         retv_if(NULL == data, -1);
  68         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
  69         CstUgData_t *ugd = item_data->ugd;
  70         DBG("call_type=%d (0:voice 1:video)", call_type);
  71         DBG("cb_flavour=%d (6:BAOC 7:BAOIC 8:BAOIC exc home 9:BAIC 10:BAIC roaming)", cb_flavour);
  72         DBG("cb_state=%d (1:on 0:off), error=%d", cb_state, error);
  73         DBG("req_action=%d(0: Activate, 1:Deactivate, 2:Query)", req_action);
  74         retv_if((call_type != ugd->call_type && call_type != CST_CALLTYPE_ALL), -1);
  75
  76         if (error == CST_ERROR_NONE) {
  77                 if (cb_state == EINA_TRUE)
  78                         ugd->cb_state[item_data->index] = CST_SS_STATE_ON;
  79                 else
  80                         ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
  81                 elm_genlist_item_update(item_data->gl_item);
  82         } else {
  83                 if (req_action != CST_ACTION_QUERY) {
  84                         if (error != CST_ERROR_SERVICE_UNAVAILABLE &&
  85                                 error != CST_ERROR_REJECTED_BY_NETWORK &&
  86                                 error != CST_ERROR_UNKNOWN) {
  87                                 if (req_action == CST_ACTION_DEACTIVATE)
  88                                         ugd->cb_state[item_data->index] = CST_SS_STATE_ON;
  89                                 else
  90                                         ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
  91                         } else
  92                                 ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
  93
  94                         elm_genlist_item_update(item_data->gl_item);
  95                         ugd->popup = (Evas_Object *)_cst_create_error_popup(ugd->nf, error);
  96                         evas_object_show(ugd->popup);
  97                 } else
  98                         __cst_disable_cb_glitem(item_data);
  99         }
 100         return 0;
 101 }
 102
 103 static void __cst_query_cb_status(CstGlItemData_t *item_data)
 104 {
 105         ENTER(__cst_query_cb_status);
 106         ret_if(NULL == item_data);
 107         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 108         int cb_flavour = -1;
 109
 110         ugd->original_state = EINA_FALSE;
 111         switch (item_data->index) {
 112         case 0:
 113                 cb_flavour = CST_SSTYPE_CB_OC;
 114                 DBG("CST_SSTYPE_CB_OC");
 115                 break;
 116         case 1:
 117                 cb_flavour = CST_SSTYPE_CB_OIC;
 118                 DBG("CST_SSTYPE_CB_OIC");
 119                 break;
 120         case 2:
 121                 cb_flavour = CST_SSTYPE_CB_OICEH;
 122                 DBG("CST_SSTYPE_CB_OICEH");
 123                 break;
 124         case 3:
 125                 cb_flavour = CST_SSTYPE_CB_IC;
 126                 DBG("CST_SSTYPE_CB_IC");
 127                 break;
 128         case 4:
 129                 cb_flavour = CST_SSTYPE_CB_ICR;
 130                 DBG("CST_SSTYPE_CB_ICR");
 131                 break;
 132         default:
 133                 DBG("Error type");
 134                 break;
 135         }
 136
 137         _cst_add_ss_request(&ugd->req_queue,
 138                 CST_ACTION_QUERY, ugd->call_type, cb_flavour,
 139                 NULL, __cst_update_cb_state, item_data, -1, ugd);
 140 }
 141
 142 static void __cst_on_click_cb_ime_done_btn(void *data, Evas_Object *obj, void *event_info)
 143 {
 144         ENTER(__cst_on_click_cb_ime_done_btn);
 145         ret_if(!data);
 146
 147         CallSettingSSReq_t *req = (CallSettingSSReq_t *)data;
 148
 149         CstGlItemData_t *item_data = (CstGlItemData_t *)req->data;
 150         CstUgData_t *ugd = item_data->ugd;
 151
 152         char buffer[CST_MAX_PHONE_NUMBER_LEN];
 153
 154         if (_cst_get_cb_input_password(buffer, ugd) > 0) {
 155                 ugd->cb_state[item_data->index] = CST_SS_STATE_PROGRESS;
 156                 elm_genlist_item_update(item_data->gl_item);
 157
 158                 DBG("activate CB pwd=%s", buffer);
 159                 snprintf(req->number, CST_MAX_PHONE_NUMBER_LEN, "%s", buffer);
 160                 _cst_add_ss_request(&ugd->req_queue,
 161                         req->action, req->call_type, req->flavour,
 162                         req->number, __cst_update_cb_state, item_data, -1, ugd);
 163
 164                 memset(ugd->c_item, 0, sizeof(ugd->c_item));
 165                 elm_naviframe_item_pop(ugd->nf);
 166                 ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 167         }
 168 }
 169
 170 static void __cst_on_click_cb_ime_cancel_btn(void *data, Evas_Object *obj, void *event_info)
 171 {
 172         ENTER(__cst_on_click_cb_ime_cancel_btn);
 173         ret_if(!data);
 174
 175         CallSettingSSReq_t *req = (CallSettingSSReq_t *)data;
 176         CstGlItemData_t *item_data = (CstGlItemData_t *)req->data;
 177         CstUgData_t *ugd = item_data->ugd;
 178
 179         DBG("original state : %d", req->original_state);
 180         if (req->original_state == CST_SS_STATE_ON)
 181                 ugd->cb_state[item_data->index] = CST_SS_STATE_ON;
 182         else
 183                 ugd->cb_state[item_data->index] = CST_SS_STATE_OFF;
 184         elm_genlist_item_update(item_data->gl_item);
 185
 186         memset(ugd->c_item, 0, sizeof(ugd->c_item));
 187         elm_naviframe_item_pop(ugd->nf);
 188         ugd->back_button = _cst_get_navifr_prev_btn(ugd->nf);
 189         if (req)
 190                 free(req);
 191 }
 192
 193 static char *__cst_gl_label_get_cb(void *data, Evas_Object *obj, const char *part)
 194 {
 195         retv_if(NULL == data, NULL);
 196         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 197
 198         if (strcmp(part, "elm.text") == 0) {
 199                 if (list_call_barring[item_data->index].str_id != -1)
 200                         return strdup(T_(list_call_barring[item_data->index].str_id));
 201         }
 202         return NULL;
 203 }
 204
 205 static void __cst_gl_del_cb(void *data, Evas_Object *obj)
 206 {
 207         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 208         if (item_data)
 209                 free(item_data);
 210         return;
 211 }
 212
 213 static void __cst_update_change_cb_req(CstGlItemData_t *item_data, Eina_Bool req_state)
 214 {
 215         ret_if(item_data == NULL);
 216
 217         Evas_Object *eo;
 218         CallSettingSSReq_t *req = NULL;
 219         CstUgData_t *ugd = item_data->ugd;
 220         Elm_Object_Item *navi_it;
 221         Evas_Object *btn;
 222
 223         req = (CallSettingSSReq_t *)calloc(1, sizeof(CallSettingSSReq_t));
 224         ret_if(req == NULL);
 225
 226         ugd->popup = NULL;
 227         req->data = item_data;
 228         req->call_type = ugd->call_type;
 229         req->flavour = -1;
 230
 231         DBG("req_state = %d", req_state);
 232         switch (item_data->index) {
 233         case 0:
 234                 req->flavour = CST_SSTYPE_CB_OC;
 235                 DBG("CST_SSTYPE_CB_OC");
 236                 break;
 237         case 1:
 238                 req->flavour = CST_SSTYPE_CB_OIC;
 239                 DBG("CST_SSTYPE_CB_OIC");
 240                 break;
 241         case 2:
 242                 req->flavour = CST_SSTYPE_CB_OICEH;
 243                 DBG("CST_SSTYPE_CB_OICEH");
 244                 break;
 245         case 3:
 246                 req->flavour = CST_SSTYPE_CB_IC;
 247                 DBG("CST_SSTYPE_CB_IC");
 248                 break;
 249         case 4:
 250                 req->flavour = CST_SSTYPE_CB_ICR;
 251                 DBG("CST_SSTYPE_CB_ICR");
 252                 break;
 253         default:
 254                 DBG("Error type");
 255                 break;
 256         }
 257
 258         ugd->original_state = !req_state;
 259         if (req_state == EINA_TRUE) {
 260                 req->original_state = CST_SS_STATE_OFF;
 261                 req->action = CST_ACTION_ACTIVATE;
 262         } else {
 263                 req->original_state = CST_SS_STATE_ON;
 264                 req->action = CST_ACTION_DEACTIVATE;
 265         }
 266
 267         eo = _cst_create_cb_ime(ugd->nf, NULL, ugd);
 268         _cst_remove_naviframe(ugd->nf);
 269         navi_it = elm_naviframe_item_push(ugd->nf,
 270                 T_(CST_STR_PASSWORD), NULL, NULL, eo, "1line");
 271
 272         btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_CANCEL),
 273                 __cst_on_click_cb_ime_cancel_btn, (void *)req);
 274         elm_object_item_part_content_set(navi_it, "title_right_btn", btn);
 275
 276         btn = _cst_create_title_btn(ugd->nf, (char *)T_(CST_STR_DONE),
 277                 __cst_on_click_cb_ime_done_btn, (void *)req);
 278         elm_object_item_part_content_set(navi_it, "title_left_btn", btn);
 279         elm_object_disabled_set(btn, EINA_TRUE);
 280 }
 281
 282 static void __cst_on_click_cb_onoff(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 283 {
 284         ret_if(NULL == data);
 285         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 286         CstUgData_t *ugd = item_data->ugd;
 287         if (ugd->cb_state[item_data->index] == CST_SS_STATE_PROGRESS)
 288                 return;
 289
 290         Eina_Bool check_state = elm_check_state_get(item_data->eo_check);
 291
 292         __cst_update_change_cb_req(item_data, !check_state);
 293         elm_genlist_item_update(item_data->gl_item);
 294 }
 295
 296 static void __cst_gl_sel_cb(void *data, Evas_Object *obj, void *event_info)
 297 {
 298         ret_if(data == NULL);
 299         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 300         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 301         if (list_call_barring[item_data->index].func)
 302                 list_call_barring[item_data->index].func((void *)item_data, NULL, obj, event_info);
 303         return;
 304 }
 305
 306 static void __cst_on_changed_cb_check(void *data, Evas_Object *obj, void *event_info)
 307 {
 308         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 309         Eina_Bool check_state = elm_check_state_get(obj);
 310
 311         if (elm_object_item_disabled_get(item_data->gl_item) == EINA_TRUE) {
 312                 elm_check_state_set(obj, EINA_FALSE);
 313                 return;
 314         }
 315
 316         __cst_update_change_cb_req(item_data, check_state);
 317 }
 318
 319 static Evas_Object *__cst_gl_icon_get_cb(void *data, Evas_Object *obj, const char *part)
 320 {
 321         retv_if(NULL == data, NULL);
 322         Evas_Object *icon = NULL;
 323         CstGlItemData_t *item_data = (CstGlItemData_t *)data;
 324         CstUgData_t *ugd = (CstUgData_t *)item_data->ugd;
 325         Eina_Bool check_state = EINA_FALSE;
 326
 327         if (!strcmp(part, "elm.icon")) {
 328                 switch (ugd->cb_state[item_data->index]) {
 329                 case CST_SS_STATE_ON:
 330                 case CST_SS_STATE_OFF:
 331                         DBG("ugd->cb_state : %d(%d)",
 332                                 ugd->cb_state[item_data->index], item_data->index);
 333                         if (ugd->cb_state[item_data->index] == CST_SS_STATE_ON)
 334                                 check_state = EINA_TRUE;
 335                         item_data->eo_check = icon = _cst_create_onoff_button(obj, check_state,
 336                                 __cst_on_changed_cb_check, item_data);
 337                         break;
 338                 case CST_SS_STATE_PROGRESS:
 339                         icon = _cst_create_progressbar(obj);
 340                         break;
 341                 default:
 342                         return NULL;
 343                 }
 344         }
 345         return icon;
 346 }
 347
 348 static Evas_Object *__cst_create_genlist_cb(void *data)
 349 {
 350         ENTER(__cst_create_genlist_cb);
 351         retv_if(NULL == data, NULL);
 352         CstUgData_t *ugd = (CstUgData_t *)data;
 353         int index = 0;
 354         Evas_Object *genlist;
 355         CstGlItemData_t *item_data;
 356
 357         if (!itc_1text_1icon)
 358                 itc_1text_1icon = elm_genlist_item_class_new();
 359
 360         itc_1text_1icon->item_style = "dialogue/1text.1icon";
 361         itc_1text_1icon->func.text_get = __cst_gl_label_get_cb;
 362         itc_1text_1icon->func.content_get = __cst_gl_icon_get_cb;
 363         itc_1text_1icon->func.state_get = NULL;
 364         itc_1text_1icon->func.del = __cst_gl_del_cb;
 365
 366         genlist = elm_genlist_add(ugd->nf);
 367         elm_object_style_set(genlist, "dialogue");
 368
 369         _cst_create_genlist_separator(genlist, EINA_FALSE);
 370         for (index = 0; list_call_barring[index].style != CST_GL_ITEM_NONE; ++index) {
 371                 item_data = (CstGlItemData_t *)calloc(1, sizeof(CstGlItemData_t));
 372                 retv_if(item_data == NULL, NULL);
 373                 item_data->index = index;
 374                 item_data->ugd = ugd;
 375                 if (list_call_barring[index].style == CST_GL_ITEM_1TEXT_ONOFF_PROGRESS) {
 376                         ugd->cb_state[index] = CST_SS_STATE_PROGRESS;
 377                         item_data->gl_item = elm_genlist_item_append(genlist, itc_1text_1icon,
 378                                 (void *)item_data, NULL, list_call_barring[index].flags,
 379                                 __cst_gl_sel_cb, item_data);
 380                         __cst_query_cb_status(item_data);
 381                 } else {
 382                         DBG("No style");
 383                         free(item_data);
 384                         item_data = NULL;
 385                         return NULL;
 386                 }
 387         }
 388         _cst_create_genlist_separator_no_line(genlist);
 389
 390         return genlist;
 391 }
 392
 393 void _cst_on_click_call_barring(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 394 {
 395         ENTER(_cst_on_click_call_barring);
 396         ret_if(NULL == data);
 397         CstUgData_t *ugd = (CstUgData_t *)data;
 398         Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *)event_info;
 399         Evas_Object *layout = NULL, *back_btn = NULL;
 400         Elm_Object_Item *navi_it;
 401
 402         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) {
 403                 return;
 404         }
 405
 406         if (_cst_check_flight_mode()) {
 407                 ugd->popup = _cst_create_error_popup(ugd->nf,
 408                         CST_ERROR_CHANGE_FLIGHT_MODE);
 409                 evas_object_show(ugd->popup);
 410                 return;
 411         }
 412
 413         if (!_cst_check_sim_status()) {
 414                 ugd->popup = _cst_create_error_popup(ugd->nf,
 415                         CST_ERROR_INSERT_SIM_CARD);
 416                 evas_object_show(ugd->popup);
 417                 return;
 418         }
 419
 420         ugd->call_type = CST_CALLTYPE_VOICE;
 421         ugd->popup = NULL;
 422
 423         Evas_Object *genlist = __cst_create_genlist_cb(ugd);
 424
 425         layout = elm_layout_add(ugd->nf);
 426         elm_layout_file_set(layout, EDJ_NAME, "toolbar");
 427         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 428         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 429         elm_object_part_content_set(layout, "elm.swallow.contents", genlist);
 430         navi_it = elm_naviframe_item_push(ugd->nf, T_(CST_STR_CALL_BARRING),
 431                 NULL, NULL, layout, "1line");
 432         back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
 433         evas_object_smart_callback_add(back_btn, "clicked",
 434                 __cst_on_click_cb_back_button, ugd);
 435 }
 436