ui/vcui-view-incoming-lock.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
  18 #include "vcui-application.h"
  19 #include "vcui-view-incoming-lock.h"
  20
  21 #define ACCEPT_DIFF_VALUE (130)
  22 #define ACCEPT_DIFF_VALUE_MAX (182)
  23
  24 #define REJECT_DIFF_VALUE (-130)
  25 #define REJECT_DIFF_VALUE_MAX (-182)
  26
  27 static int __vcui_view_incoming_lock_oncreate(voice_call_view_data_t *view_data, int param1, void *param2, void *param3);
  28 static int __vcui_view_incoming_lock_onupdate(voice_call_view_data_t *view_data, void *update_data1, void *update_data2);
  29 static int __vcui_view_incoming_lock_onhide(voice_call_view_data_t *view_data);
  30 static int __vcui_view_incoming_lock_onshow(voice_call_view_data_t *view_data);
  31 static int __vcui_view_incoming_lock_ondestroy(voice_call_view_data_t *view_data);
  32
  33 static voice_call_view_data_t s_view = {
  34         .type = VIEW_INCOMING_LOCK_VIEW,
  35         .app_data = NULL,
  36         .layout = NULL,
  37         .onCreate = __vcui_view_incoming_lock_oncreate,
  38         .onUpdate = __vcui_view_incoming_lock_onupdate,
  39         .onHide = __vcui_view_incoming_lock_onhide,
  40         .onShow = __vcui_view_incoming_lock_onshow,
  41         .onDestroy = __vcui_view_incoming_lock_ondestroy,
  42         .priv = NULL,
  43 };
  44
  45 voice_call_view_data_t *_vcui_view_incoming_lock_new(vcui_app_call_data_t *ad)
  46 {
  47
  48         s_view.app_data = ad;
  49         s_view.priv = calloc(1, sizeof(incoming_lock_view_priv_t));
  50
  51         if (!s_view.priv) {
  52                 CALL_UI_DEBUG("ERROR!!!!!!!!!!!");
  53         }
  54
  55         return &s_view;
  56 }
  57
  58 static Evas_Object *__vcui_view_incoming_lock_load_edj(Evas *evas, char *edjname, const char *grpname)
  59 {
  60         Evas_Object *edj;
  61
  62         edj = edje_object_add(evas);
  63         if (!edje_object_file_set(edj, edjname, grpname)) {
  64                 CALL_UI_DEBUG("ERROR!!");
  65                 return NULL;
  66         }
  67
  68         return edj;
  69 }
  70
  71 static void __vcui_view_incoming_lock_accept_mouse_down_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
  72 {
  73         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
  74         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
  75         Evas_Event_Mouse_Move *ev = event_info;
  76
  77         priv->accept_start_x = ev->cur.canvas.x;
  78 }
  79
  80 static void __vcui_view_incoming_lock_accept_mouse_move_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
  81 {
  82         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
  83         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
  84         vcui_app_call_data_t *ad = vd->app_data;
  85         Evas_Event_Mouse_Move *ev = event_info;
  86
  87         int diff_x = 0;
  88
  89         priv->accept_cur_x = ev->cur.canvas.x;
  90         diff_x = priv->accept_cur_x - priv->accept_start_x;
  91
  92
  93         if (diff_x >= 0) {
  94                 if (diff_x < (ACCEPT_DIFF_VALUE * ad->scale_factor)) {
  95                         evas_object_move(priv->lock_accept, diff_x, 0);
  96
  97                         edje_object_signal_emit(priv->lock_reject, "lock_reject,default", "prog");
  98                 } else if (diff_x < (ACCEPT_DIFF_VALUE_MAX * ad->scale_factor)) {
  99                         evas_object_move(priv->lock_accept, diff_x, 0);
 100                         evas_object_move(priv->lock_reject, (diff_x - (ACCEPT_DIFF_VALUE * ad->scale_factor)), 0);
 101
 102                         edje_object_signal_emit(priv->lock_reject, "lock_reject,default", "prog");
 103                 } else {
 104                         evas_object_move(priv->lock_accept, (ACCEPT_DIFF_VALUE_MAX * ad->scale_factor), 0);
 105                         evas_object_move(priv->lock_reject, ((ACCEPT_DIFF_VALUE_MAX * ad->scale_factor) - (ACCEPT_DIFF_VALUE * ad->scale_factor)), 0);
 106
 107                         edje_object_signal_emit(priv->lock_reject, "lock_reject,alpha", "prog");
 108                 }
 109         }
 110 }
 111
 112 static void __vcui_view_incoming_lock_accept_mouse_up_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 113 {
 114         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 115         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 116         vcui_app_call_data_t *ad = vd->app_data;
 117
 118         int diff_x = priv->accept_cur_x - priv->accept_start_x;
 119
 120         if (diff_x >= (ACCEPT_DIFF_VALUE_MAX * ad->scale_factor)) {
 121                 if(_vcui_is_phonelock_status() == EINA_FALSE)
 122                         vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);
 123                 _vcui_engine_answer_call();
 124         } else {
 125                 evas_object_move(priv->lock_accept, 0, 0);
 126                 evas_object_move(priv->lock_reject, 0, 0);
 127         }
 128
 129 }
 130
 131 static Evas_Object *__vcui_view_incoming_lock_create_button_accept(void *data)
 132 {
 133         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 134         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 135         vcui_app_call_data_t *ad = vd->app_data;
 136
 137         if(priv->lock_accept != NULL) {
 138                 evas_object_del(priv->lock_accept);
 139                 priv->lock_accept = NULL;
 140         }
 141         priv->lock_accept = __vcui_view_incoming_lock_load_edj(evas_object_evas_get(ad->win_main), EDJ_NAME, GRP_LOCK_ACCEPT);
 142         evas_object_resize(priv->lock_accept, ad->root_w, ad->root_h);
 143
 144         evas_object_event_callback_add(priv->lock_accept, EVAS_CALLBACK_MOUSE_DOWN, __vcui_view_incoming_lock_accept_mouse_down_cb, vd);
 145         evas_object_event_callback_add(priv->lock_accept, EVAS_CALLBACK_MOUSE_MOVE, __vcui_view_incoming_lock_accept_mouse_move_cb, vd);
 146         evas_object_event_callback_add(priv->lock_accept, EVAS_CALLBACK_MOUSE_UP, __vcui_view_incoming_lock_accept_mouse_up_cb, vd);
 147
 148         edje_object_part_text_set(priv->lock_accept, "accept_text", _("IDS_CALL_BUTTON_ACCEPT"));
 149
 150         evas_object_show(priv->lock_accept);
 151
 152         return priv->lock_accept;
 153 }
 154
 155 static void __vcui_view_incoming_lock_reject_mouse_down_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 156 {
 157         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 158         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 159         Evas_Event_Mouse_Move *ev = event_info;
 160
 161         priv->reject_start_x = ev->cur.canvas.x;
 162 }
 163
 164 static void __vcui_view_incoming_lock_reject_mouse_move_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 165 {
 166         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 167         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 168         vcui_app_call_data_t *ad = vd->app_data;
 169         Evas_Event_Mouse_Move *ev = event_info;
 170
 171         int diff_x = 0;
 172
 173         priv->reject_cur_x = ev->cur.canvas.x;
 174         diff_x = priv->reject_cur_x - priv->reject_start_x;
 175
 176         if (diff_x <= 0) {
 177                 if (diff_x > (REJECT_DIFF_VALUE * ad->scale_factor)) {
 178                         evas_object_move(priv->lock_reject, diff_x, 0);
 179
 180                         edje_object_signal_emit(priv->lock_accept, "lock_accept,default", "prog");
 181                 } else if (diff_x > (REJECT_DIFF_VALUE_MAX * ad->scale_factor)) {
 182                         evas_object_move(priv->lock_reject, diff_x, 0);
 183                         evas_object_move(priv->lock_accept, (diff_x - (REJECT_DIFF_VALUE * ad->scale_factor)), 0);
 184
 185                         edje_object_signal_emit(priv->lock_accept, "lock_accept,default", "prog");
 186                 } else {
 187                         evas_object_move(priv->lock_reject, (REJECT_DIFF_VALUE_MAX * ad->scale_factor), 0);
 188                         evas_object_move(priv->lock_accept, ((REJECT_DIFF_VALUE_MAX * ad->scale_factor) - (REJECT_DIFF_VALUE * ad->scale_factor)), 0);
 189
 190                         edje_object_signal_emit(priv->lock_accept, "lock_accept,alpha", "prog");
 191
 192                 }
 193         }
 194 }
 195
 196 static void __vcui_view_incoming_lock_reject_mouse_up_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
 197 {
 198         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 199         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 200         vcui_app_call_data_t *ad = vd->app_data;
 201
 202         int diff_x = priv->reject_cur_x - priv->reject_start_x;
 203
 204         if (diff_x <= (REJECT_DIFF_VALUE_MAX * ad->scale_factor)) {
 205 /*              vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_UNLOCK);*/
 206                 _vcui_engine_reject_call();
 207         } else {
 208                 evas_object_move(priv->lock_reject, 0, 0);
 209                 evas_object_move(priv->lock_accept, 0, 0);
 210         }
 211
 212 }
 213
 214 static Evas_Object *__vcui_view_incoming_lock_create_button_reject(void *data)
 215 {
 216         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 217         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 218         vcui_app_call_data_t *ad = vd->app_data;
 219
 220         if(priv->lock_reject != NULL) {
 221                 evas_object_del(priv->lock_reject);
 222                 priv->lock_reject = NULL;
 223         }
 224         priv->lock_reject = __vcui_view_incoming_lock_load_edj(evas_object_evas_get(ad->win_main), EDJ_NAME, GRP_LOCK_REJECT);
 225         evas_object_resize(priv->lock_reject, ad->root_w, ad->root_h);
 226
 227         evas_object_event_callback_add(priv->lock_reject, EVAS_CALLBACK_MOUSE_DOWN, __vcui_view_incoming_lock_reject_mouse_down_cb, vd);
 228         evas_object_event_callback_add(priv->lock_reject, EVAS_CALLBACK_MOUSE_MOVE, __vcui_view_incoming_lock_reject_mouse_move_cb, vd);
 229         evas_object_event_callback_add(priv->lock_reject, EVAS_CALLBACK_MOUSE_UP, __vcui_view_incoming_lock_reject_mouse_up_cb, vd);
 230
 231         edje_object_part_text_set(priv->lock_reject, "reject_text", _("IDS_CALL_BUTTON_REJECT"));
 232
 233         evas_object_show(priv->lock_reject);
 234
 235         return priv->lock_reject;
 236 }
 237
 238 static void __vcui_view_incoming_lock_draw_screen(voice_call_view_data_t *vd)
 239 {
 240         CALL_UI_DEBUG("..");
 241
 242         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 243         Evas_Object *eo = priv->contents;
 244         vcui_app_call_data_t *ad = vd->app_data;
 245
 246         priv->now_data = _vcui_doc_get_recent_mt();
 247         if (priv->now_data == NULL) {
 248                 CALL_UI_DEBUG("call data is null");
 249                 return;
 250         }
 251         if (priv->now_data->mo_mt_status != CALL_INCOMING) {
 252                 CALL_UI_DEBUG("it is not call_incoming.");
 253                 return;
 254         }
 255
 256         /* call image */
 257         if (strcmp((char *)priv->now_data->call_file_path, NOIMG_ICON) == 0) {
 258                 _vcui_show_wallpaper_image(priv->contents);
 259         } else {
 260                 CALL_UI_DEBUG("there is caller image.");
 261                 _vcui_show_wallpaper_image(priv->contents);
 262                 priv->ic = _vcui_show_contact_image(priv->contents, vd->app_data->win_main, priv->now_data->call_file_path);
 263         }
 264
 265         /* call name (if nothing, call number) */
 266         if (strlen((char *)priv->now_data->call_display) == 0) {
 267                 edje_object_part_text_set(_EDJ(eo), "txt_call_name", (char *)priv->now_data->call_num);
 268         } else {
 269                 edje_object_part_text_set(_EDJ(eo), "txt_call_name", (char *)priv->now_data->call_display);
 270                 edje_object_part_text_set(_EDJ(eo), "txt_contact_phone_type", (char *)priv->now_data->call_num);
 271         }
 272
 273         __vcui_view_incoming_lock_create_button_accept(vd);
 274         __vcui_view_incoming_lock_create_button_reject(vd);
 275
 276         ad->beffect_needed = EINA_TRUE;
 277
 278         evas_object_show(eo);
 279
 280 }
 281
 282 static Evas_Object *__vcui_view_incoming_lock_create_contents(void *data)
 283 {
 284         if (data == NULL) {
 285                 CALL_UI_DEBUG("ERROR");
 286                 return NULL;
 287         }
 288         voice_call_view_data_t *vd = (voice_call_view_data_t *)data;
 289         Evas_Object *eo;
 290
 291         /* load edje */
 292         eo = _vcui_load_edj(vd->app_data->win_main, EDJ_NAME, GRP_MTLOCK);
 293         if (eo == NULL)
 294                 return NULL;
 295
 296         return eo;
 297 }
 298
 299 static Evas_Object *__vcui_view_incoming_lock_create_layout_main(Evas_Object *parent)
 300 {
 301         if (parent == NULL) {
 302                 CALL_UI_DEBUG("ERROR");
 303                 return NULL;
 304         }
 305
 306         Evas_Object *ly;
 307         ly = elm_layout_add(parent);
 308         retvm_if(ly == NULL, NULL, "Failed elm_layout_add.");
 309
 310         elm_layout_theme_set(ly, "standard", "window", "integration");
 311         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 312         elm_win_resize_object_add(parent, ly);
 313
 314         edje_object_signal_emit(_EDJ(ly), "elm,state,show,indicator", "elm");
 315         edje_object_signal_emit(_EDJ(ly), "elm,state,show,content", "elm");
 316         evas_object_show(ly);
 317
 318         return ly;
 319 }
 320
 321 static int __vcui_view_incoming_lock_oncreate(voice_call_view_data_t *view_data, int param1, void *param2, void *param3)
 322 {
 323         CALL_UI_DEBUG("mt-lock view create!!");
 324
 325         vcui_app_call_data_t *ad = view_data->app_data;
 326         incoming_lock_view_priv_t *priv = view_data->priv;
 327
 328         if (!view_data->layout) {
 329                 view_data->layout = __vcui_view_incoming_lock_create_layout_main(ad->win_main);
 330                 if (view_data->layout == NULL) {
 331                         CALL_UI_DEBUG("ERROR");
 332                         return VC_ERROR;
 333                 }
 334                 priv->contents = __vcui_view_incoming_lock_create_contents(view_data);
 335                 elm_object_part_content_set(view_data->layout, "elm.swallow.content", priv->contents);
 336
 337                 evas_object_name_set(priv->contents, "INCOMINGLOCKVIEW");
 338                 CALL_UI_DEBUG("[========== INCOMINGLOCKVIEW: priv->contents Addr : [%p] ==========]", priv->contents);
 339
 340         }
 341
 342         __vcui_view_incoming_lock_onshow(view_data);
 343         return VC_NO_ERROR;
 344 }
 345
 346 static int __vcui_view_incoming_lock_onupdate(voice_call_view_data_t *view_data, void *update_data1, void *update_data2)
 347 {
 348         CALL_UI_DEBUG("mt-lock view update!!");
 349
 350         __vcui_view_incoming_lock_onshow(view_data);
 351         return VC_NO_ERROR;
 352 }
 353
 354 static int __vcui_view_incoming_lock_onhide(voice_call_view_data_t *view_data)
 355 {
 356         CALL_UI_DEBUG("mt-lock view hide!!");
 357
 358         evas_object_hide(view_data->layout);
 359         return VC_NO_ERROR;
 360 }
 361
 362 static int __vcui_view_incoming_lock_onshow(voice_call_view_data_t *view_data)
 363 {
 364         CALL_UI_DEBUG("mt-lock view show!!");
 365         vcui_app_call_data_t *ad = _vcui_get_app_data();
 366         int result = 0;
 367
 368         __vcui_view_incoming_lock_draw_screen(view_data);
 369
 370         evas_object_hide(view_data->layout);
 371         evas_object_show(view_data->layout);
 372         _vcui_app_win_set_noti_type(EINA_TRUE);
 373
 374         return VC_NO_ERROR;
 375 }
 376
 377 static int __vcui_view_incoming_lock_ondestroy(voice_call_view_data_t *view_data)
 378 {
 379         CALL_UI_DEBUG("mt-lock view destroy!!");
 380
 381         vcui_app_call_data_t *ad = _vcui_get_app_data();
 382
 383         voice_call_view_data_t *vd = ad->view_st[VIEW_INCOMING_LOCK_VIEW];
 384         incoming_lock_view_priv_t *priv = (incoming_lock_view_priv_t *)vd->priv;
 385
 386         if (_vcui_is_idle_lock() == CALL_LOCK)
 387                 _vcui_app_win_set_noti_type(EINA_TRUE);
 388         else
 389                 _vcui_app_win_set_noti_type(EINA_FALSE);
 390
 391         ad->bmute_ringtone = EINA_FALSE;
 392         if (priv != NULL) {
 393                 if (priv->lock_accept) {
 394                         evas_object_del(priv->lock_accept);
 395                         priv->lock_accept = NULL;
 396                 }
 397                 if (priv->lock_reject) {
 398                         evas_object_del(priv->lock_reject);
 399                         priv->lock_reject = NULL;
 400                 }
 401                 if (priv->contents) {
 402                         evas_object_del(priv->contents);
 403                         priv->contents = NULL;
 404                 }
 405
 406                 free(priv);
 407                 priv = NULL;
 408         }
 409
 410         if (vd->layout != NULL) {
 411                 evas_object_hide(vd->layout);
 412                 evas_object_del(vd->layout);
 413                 vd->layout = NULL;
 414         }
 415
 416         ad->view_st[VIEW_INCOMING_LOCK_VIEW] = NULL;
 417
 418         _vcui_cache_flush();
 419
 420         return VC_NO_ERROR;
 421 }