ui/src/vcui-view-common.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 <system_info.h>
  18
  19 #include "vcui-application.h"
  20 #include "vcui-view-common.h"
  21 #include "vcui-view-layout-hd.h"
  22
  23 #include "vcui-view-dialing.h"
  24 #include "vcui-view-incoming-lock.h"
  25 #include "vcui-view-single-call.h"
  26 #include "vcui-view-multi-call-split.h"
  27 #include "vcui-view-multi-call-conf.h"
  28 #include "vcui-view-multi-call-list.h"
  29 #include "vcui-view-keypad.h"
  30 #include "vcui-view-callend.h"
  31 #include "vcui-view-quickpanel.h"
  32
  33 static vcui_view_common_t gincall_common_data;
  34
  35 void _vcui_view_common_init()
  36 {
  37         memset(&gincall_common_data, 0, sizeof(vcui_view_common_t));
  38 }
  39
  40 static vcui_view_common_t *__vcui_view_common_get_common_data()
  41 {
  42         return &gincall_common_data;
  43 }
  44
  45 static Eina_Bool __vcui_view_common_timer_cb(void *data)
  46 {
  47         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
  48         char dur[TIME_BUF_LEN];
  49         static int end_count = 0;
  50
  51         if (common_data->timer_flag == 1) {
  52                 if (common_data->time_end_flag == TIME_END_START) {
  53                         end_count = 0;
  54                         return 1;
  55                 } else if (common_data->time_end_flag == TIME_END_NO) {
  56                         end_count++;
  57                         if (end_count == 1) {
  58                                 return 1;
  59                         }
  60                 }
  61         }
  62         common_data->current_call_time = time(NULL);
  63
  64         if (common_data->timer_flag == 1) {
  65                 if (common_data->current_call_time > common_data->start_call_time) {
  66                         time_t call_time = common_data->current_call_time - common_data->start_call_time;
  67                         struct tm loctime;
  68
  69                         gmtime_r((const time_t *)&call_time, &loctime);
  70                         snprintf(dur, TIME_BUF_LEN, "%02d:%02d:%02d", loctime.tm_hour, loctime.tm_min, loctime.tm_sec);
  71
  72                         _vcui_view_common_set_text_time(dur);
  73                 }
  74         }
  75
  76         return 1;
  77 }
  78
  79 static Eina_Bool __vcui_view_common_timer_end_cb(void *data)
  80 {
  81         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
  82         int end_type = common_data->end_type;
  83         char dur[TIME_BUF_LEN];
  84
  85         if ((common_data->timer_flag == 1) && (common_data->time_end_flag == TIME_END_START)) {
  86                 snprintf(dur, TIME_BUF_LEN, "%02d:%02d:%02d", common_data->hour, common_data->min, common_data->sec);
  87                 if (common_data->time_count == 0) {
  88                         _vcui_view_common_set_text_time(dur);
  89                 } else if (common_data->time_count == 1) {
  90                         _vcui_view_common_set_text_time(_(" "));
  91                 } else if (common_data->time_count == 2) {
  92                         _vcui_view_common_set_text_time(dur);
  93                 } else if (common_data->time_count == 3) {
  94                         _vcui_view_common_set_text_time(_(" "));
  95                 } else if (common_data->time_count == 4) {
  96                         char data_txt[VC_DATA_LENGTH_MAX] = { 0, };
  97                         _vcui_view_common_set_text_time(_vcui_get_endcause_string(end_type, data_txt));
  98                 }
  99
 100                 common_data->time_count++;
 101                 if (common_data->time_count == TIME_END_MAX_SHOW) {
 102                         common_data->time_end_flag = TIME_END_NO;
 103                         common_data->time_count = 0;
 104
 105                         if (common_data->tm_end) {
 106                                 ecore_timer_del(common_data->tm_end);
 107                                 common_data->tm_end = NULL;
 108                         }
 109
 110                         _vcui_view_common_call_terminate_or_view_change();
 111                 }
 112         }
 113         return 1;
 114 }
 115
 116 static Eina_Bool __vcui_view_common_timer_end_dialing_cb(void *data)
 117 {
 118         CALL_UI_DEBUG("..");
 119         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 120
 121         if (common_data->tm_end_dialing) {
 122                 ecore_timer_del(common_data->tm_end_dialing);
 123                 common_data->tm_end_dialing = NULL;
 124         }
 125
 126         if (common_data->bredial == EINA_TRUE) {
 127                 vcall_engine_process_auto_redial(EINA_TRUE);
 128                 _vcui_view_popup_load_redial();
 129         } else {
 130                 _vcui_view_common_call_terminate_or_view_change();
 131         }
 132
 133         return 1;
 134 }
 135
 136 static Eina_Bool __vcui_view_common_timer_end_force_cb(void *data)
 137 {
 138         CALL_UI_DEBUG("..");
 139         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 140
 141         if (common_data->tm_end_force) {
 142                 ecore_timer_del(common_data->tm_end_force);
 143                 common_data->tm_end_force = NULL;
 144         }
 145
 146         _vcui_view_common_call_terminate_or_view_change();
 147
 148         return 1;
 149 }
 150
 151 void _vcui_view_common_set_text_time(char *time_dur)
 152 {
 153         vcui_app_call_data_t *ad = _vcui_get_app_data();
 154         voice_call_view_data_t *data = ad->view_st[ad->view_top];
 155
 156         if (data != NULL) {
 157                 if (data->type == VIEW_INCALL_ONECALL_VIEW) {
 158                         _vc_ui_view_single_call_set_call_timer(data, time_dur);
 159                 } else if (data->type == VIEW_INCALL_MULTICALL_SPLIT_VIEW) {
 160                         _vcui_view_multi_call_split_set_call_timer(data, time_dur);
 161                 } else if (data->type == VIEW_INCALL_MULTICALL_CONF_VIEW) {
 162                         _vcui_view_multi_call_conf_set_call_timer(data, time_dur);
 163                 } else if (data->type == VIEW_INCALL_MULTICALL_LIST_VIEW) {
 164                         _vcui_view_multi_call_list_set_call_timer(data, time_dur);
 165                 } else if (data->type == VIEW_ENDCALL_VIEW) {
 166                         _vc_ui_view_callend_set_call_timer(data, time_dur);
 167                 } else {
 168                         /*to do nothing in case of other view. */
 169                 }
 170         }
 171
 172         if (ad->win_quickpanel && ad->quickpanel_layout) {
 173                 _vc_ui_view_qp_set_call_timer(ad->quickpanel_layout, time_dur);
 174         }
 175 }
 176
 177 void _vcui_view_common_set_each_time(time_t starttime)
 178 {
 179         time_t curr_time;
 180         unsigned long call_duration_in_sec = 0;
 181         unsigned long sec = 0;
 182         unsigned long min = 0;
 183         unsigned long hr = 0;
 184
 185         curr_time = time(&curr_time);
 186         call_duration_in_sec = curr_time - starttime;
 187         sec = call_duration_in_sec % 60;
 188         min = (call_duration_in_sec / 60) % 60;
 189         hr = call_duration_in_sec / 3600;
 190
 191         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 192
 193         /*set the start time for every call */
 194         common_data->start_call_time = starttime;
 195         CALL_UI_DEBUG(" common_data->start_call_time %lu", (unsigned long)common_data->start_call_time);
 196
 197         CALL_UI_DEBUG(" _vcui_view_common_set_each_time curr_time %d starttime %d", (int)curr_time, (int)starttime);
 198
 199         common_data->sec = sec;
 200         common_data->min = min;
 201         common_data->hour = hr;
 202
 203         char dur[TIME_BUF_LEN];
 204         snprintf(dur, TIME_BUF_LEN, "%02d:%02d:%02d", common_data->hour, common_data->min, common_data->sec);
 205         if (common_data->timer_flag == 1)
 206                 _vcui_view_common_set_text_time(dur);
 207
 208         CALL_UI_DEBUG(" complete input time");
 209
 210 }
 211
 212 void _vcui_view_common_timer_text_init()
 213 {
 214         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 215
 216         if (!common_data->tm) {
 217                 if (common_data->timer_flag == 0) {
 218                         common_data->sec = 0;
 219                         common_data->min = 0;
 220                         common_data->hour = 0;
 221                         common_data->timer_flag = 1;
 222                 }
 223                 common_data->tm = ecore_timer_add(TIMER_TIMEOUT_1_SEC, __vcui_view_common_timer_cb, NULL);
 224         }
 225 }
 226
 227 void _vcui_view_common_timer_destroy()
 228 {
 229         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 230         if (common_data->tm) {
 231                 ecore_timer_del(common_data->tm);
 232                 common_data->tm = NULL;
 233         }
 234 }
 235
 236 void _vcui_view_common_timer_end_destroy()
 237 {
 238         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 239         if (common_data->tm_end) {
 240                 ecore_timer_del(common_data->tm_end);
 241                 common_data->tm_end = NULL;
 242         }
 243 }
 244
 245 void _vcui_view_common_timer_end_dialing_destroy()
 246 {
 247         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 248         if (common_data->tm_end_dialing) {
 249                 ecore_timer_del(common_data->tm_end_dialing);
 250                 common_data->tm_end_dialing = NULL;
 251         }
 252 }
 253
 254 void _vcui_view_common_timer_redial_reset()
 255 {
 256         CALL_UI_DEBUG("..");
 257         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 258
 259         _vcui_view_common_timer_end_destroy();
 260         _vcui_view_common_timer_end_dialing_destroy();
 261         common_data->time_end_flag = TIME_END_NO;
 262 }
 263
 264 void _vcui_view_common_call_end_show_dialing(int end_type, int bredial)
 265 {
 266         CALL_UI_DEBUG("end_type:[%d]", end_type);
 267         vcui_app_call_data_t *ad = _vcui_get_app_data();
 268         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 269         char data[VC_DATA_LENGTH_MAX] = { 0, };
 270
 271         if (ad->call_end_type == CALL_END_TYPE_NONE) {
 272                 _vcui_view_dialing_draw_txt_ended(ad->view_st[ad->view_top], end_type);
 273         } else if (ad->call_end_type == CALL_END_TYPE_SINGLE_CALL) {
 274                 common_data->time_end_flag = TIME_END_START;    /*to stop timer from updating the call end screen */
 275                 _vcui_view_common_set_text_time(_vcui_get_endcause_string(end_type, data));
 276         }
 277
 278         if (common_data->tm_end_dialing) {
 279                 ecore_timer_del(common_data->tm_end_dialing);
 280                 common_data->tm_end_dialing = NULL;
 281         }
 282         common_data->bredial = bredial;
 283         common_data->tm_end_dialing = ecore_timer_add(TIMER_TIMEOUT_2_SEC, __vcui_view_common_timer_end_dialing_cb, NULL);
 284
 285 }
 286
 287 void _vcui_view_common_call_end_show(time_t start_time, int end_type)
 288 {
 289         CALL_UI_DEBUG("end_type:[%d]", end_type);
 290         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 291
 292         if (common_data->tm_end) {
 293                 ecore_timer_del(common_data->tm_end);
 294                 common_data->tm_end = NULL;
 295         }
 296         common_data->time_end_flag = TIME_END_START;
 297         _vcui_view_common_set_each_time(start_time);
 298
 299         common_data->end_type = end_type;
 300         common_data->tm_end = ecore_timer_add(TIMER_TIMEOUT_0_3_SEC, __vcui_view_common_timer_end_cb, NULL);
 301 }
 302
 303 void _vcui_view_common_call_end_timer_reset(void)
 304 {
 305         CALL_UI_DEBUG("..");
 306         vcui_view_common_t *common_data = __vcui_view_common_get_common_data();
 307         if (common_data->tm_end) {
 308                 ecore_timer_del(common_data->tm_end);
 309                 common_data->tm_end = NULL;
 310         }
 311
 312         if (common_data->tm_end_dialing) {
 313                 ecore_timer_del(common_data->tm_end_dialing);
 314                 common_data->tm_end_dialing = NULL;
 315         }
 316
 317         common_data->tm_end_force = ecore_timer_add(TIMER_TIMEOUT_2_SEC, __vcui_view_common_timer_end_force_cb, NULL);
 318 }
 319
 320 int _vcui_view_common_call_terminate_or_view_change(void)
 321 {
 322         CALL_UI_DEBUG("..");
 323         vcui_app_call_data_t *ad = _vcui_get_app_data();
 324
 325         if (_vcui_doc_get_all_call_data_count() == 0) {
 326                 if (ad->contact_ug == NULL) {
 327                         CALL_UI_DEBUG("EXIT - contact ug is closed");
 328                         elm_exit();
 329                 } else {
 330                         CALL_UI_DEBUG("show contact ug");
 331                         CALL_UI_DEBUG("hide & destory [%d]", ad->view_top);
 332                         if (ad->view_top != -1) {
 333                                 ad->view_st[ad->view_top]->onHide(ad->view_st[ad->view_top]);
 334                                 ad->view_st[ad->view_top]->onDestroy(ad->view_st[ad->view_top]);
 335                                 ad->view_top = -1;
 336                         }
 337                         evas_object_show((Evas_Object *)ug_get_layout(ad->contact_ug));
 338                 }
 339         } else {
 340                 _vcui_view_auto_change();
 341         }
 342         return VC_NO_ERROR;
 343 }
 344
 345 void _vcui_view_common_show_noid_image(Evas_Object *layout)
 346 {
 347     CALL_UI_DEBUG("..");
 348     vcui_app_call_data_t *ad = _vcui_get_app_data();
 349     Evas_Object *noid_icon = NULL;
 350
 351     noid_icon = edje_object_part_swallow_get(_EDJ(layout), "swl-cid-noid");
 352     if (noid_icon) {
 353                 edje_object_part_unswallow(_EDJ(layout), noid_icon);
 354                 evas_object_del(noid_icon);
 355     }
 356
 357     noid_icon = elm_image_add(ad->win_main);
 358     elm_object_part_content_set(layout, "swl-cid-noid", noid_icon);
 359     elm_image_file_set(noid_icon, MO_NOCALLER_ID_ICON, NULL);
 360
 361     edje_object_signal_emit(_EDJ(layout), "show-noid-image", "show-noid");
 362 }
 363
 364 void _vcui_view_common_update_mute_btn()
 365 {
 366         vcui_app_call_data_t *ad = _vcui_get_app_data();
 367         vcui_app_call_view_id_t view_id = ad->view_top;
 368         voice_call_view_data_t *vd = ad->view_st[view_id];
 369         VCUI_RETURN_IF_FAIL(vd);
 370
 371         int valid = 0;
 372
 373         if (vd->layout) {
 374                 if (view_id == VIEW_DIALLING_VIEW) {
 375                         valid = _vc_ui_view_dialing_check_valid_eo(vd);
 376                 } else if (view_id == VIEW_INCALL_ONECALL_VIEW) {
 377                         valid = _vc_ui_view_single_call_check_valid_eo(vd);
 378                 } else if (view_id == VIEW_INCALL_MULTICALL_SPLIT_VIEW) {
 379                         valid = _vcui_view_multi_call_split_check_valid_eo(vd);
 380                 } else if (view_id == VIEW_INCALL_MULTICALL_CONF_VIEW) {
 381                         valid = _vcui_view_multi_call_conf_check_valid_eo(vd);
 382                 } else if (view_id == VIEW_INCALL_MULTICALL_LIST_VIEW) {
 383                         valid = _vcui_view_multi_call_list_check_valid_eo(vd);
 384                 } else {
 385                         CALL_UI_DEBUG("[============ BAD INPUT!!!! Check Input Layout!!!!! %d============]", view_id);
 386                 }
 387                 if (valid == -1) {
 388                         CALL_UI_DEBUG("[========== WARNING!! Invalid Evas Object  ==========]");
 389                         return;
 390                 }
 391         }
 392
 393         _vcui_create_bottom_middle_button(vd);
 394 }
 395
 396 gboolean _vcui_view_common_is_emul_bin(void)
 397 {
 398         char *model_str = NULL;
 399         int ret = system_info_get_value_string(SYSTEM_INFO_KEY_MODEL, &model_str);
 400
 401         if (ret != SYSTEM_INFO_ERROR_NONE) {
 402                 CALL_UI_DEBUG("fail to call system_info_get_value_string");
 403                 free(model_str);
 404                 return FALSE;
 405         }
 406
 407         if (strncmp("Emulator", model_str, 8) == 0) {
 408                 free(model_str);
 409                 return TRUE;
 410         } else {
 411                 free(model_str);
 412                 return FALSE;
 413         }
 414 }
 415