src/cam_app.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 <X11/Xlib.h>
  18 #include <X11/keysymdef.h>
  19 #include <sys/wait.h>
  20 #include <pthread.h>
  21 #include <unistd.h>
  22 #include <aul.h>
  23 #include <power.h>
  24 #include <syspopup_caller.h>
  25
  26 #include "cam.h"
  27 #include "cam_app.h"
  28 #include "edc_string.h"
  29 #include "cam_sound.h"
  30 #include "cam_file.h"
  31 #include "cam_ta.h"
  32 #include "cam_error.h"
  33 #include "cam_config.h"
  34 #include "cam_mm.h"
  35 #include "cam_rec.h"
  36 #include "cam_devman.h"
  37 #include "cam_popup.h"
  38
  39 #include "cam_common_edc_callback.h"
  40 #include "cam_indicator_edc_callback.h"
  41 #include "cam_recording_edc_callback.h"
  42 #include "cam_toolbar_edc_callback.h"
  43 #include "cam_zoom_edc_callback.h"
  44 #include "camera_utils.h"
  45
  46 #include "cam_ui_effect_utils.h"
  47 #include "cam_ui_rotate_utils.h"
  48
  49 #include "cam_menu_composer.h"
  50 #include "cam_device_capacity.h"
  51
  52
  53 #ifdef ENABLE_CAPTURE_ANIMATION
  54 #include "cam_animation.h"
  55 #endif
  56
  57 #define ZSL_MAX_REL (1280*720)  /* 1m wide */
  58 #define FOCUS_FOCUSED_TIME_OUT 3
  59 #define FOCUS_FAILED_TIME_OUT 2
  60 #define THUMBNAIL_UPDATE_WAIT_TIME (100*1000)
  61
  62
  63 /* 5m ZSL TEST*/
  64 /* #define ZSL_5M_TEST (2560*1920) */
  65
  66 #define NEW_NOTI_API
  67
  68 static CamAppData *cam_handle = NULL;
  69 static struct appdata *app_handle = NULL;
  70
  71 /* static Ecore_Idler *spy_rotation_idler=NULL; */
  72
  73 #define TEMP_SAVE_PATH "/tmp/temp_image.jpg"    /* not used maybe... */
  74 #define SELF_SHOT_TEMP_SAVE_PATH "/tmp/self_temp_shot.jpg"
  75
  76 #define LONG_PRESS_INTERVAL 0.5 /* sec */
  77
  78 #define INAGE_FILE_NAME                 "IMAGE"
  79 #define VIDEO_FILE_NAME                 "VIDEO"
  80 #define TEMP_FILE_NAME                          ".camera_result"
  81 #define IMAGE_FILE_EXTENSION            ".jpg"
  82 #define VIDEO_FILE_EXTENSION            ".3gp"
  83
  84 #define SHUTTER_W_RATIO 0.1
  85 #define SHUTTER_H_RATIO 0.34
  86 #define SCREEN_RATIO 1.0
  87 #define AUTO_CLOSE_COUNT        10
  88 /* #define CAMAPP_SIG_HANDLING */
  89
  90 /* #define ENABLE_CHECK_CAM_STATUS       //provent camera hang,  */
  91
  92 #ifdef ENABLE_CHECK_CAM_STATUS
  93 #define CAM_CHECK_STATUS_INTERVAL_TIME 10
  94 #ifndef CAMAPP_SIG_HANDLING
  95 #define CAMAPP_SIG_HANDLING
  96 #endif
  97 #endif
  98
  99
 100 static int cam_app_start_rotate(struct appdata *ad, bool bInitial);
 101 static void cam_app_get_win_size(struct appdata *ad);
 102 #ifdef ENABLE_CHECK_CAM_STATUS
 103 static void cam_app_check_status();
 104 #endif
 105
 106 #ifndef DISABLE_TOOLBAR_TOGGLE
 107 static Eina_Bool _cam_app_toolbar_toggle_timer(void *data);
 108 #endif
 109
 110 static gboolean cam_power_key_press(void *data);
 111 static gboolean cam_app_return_ext_app(void *data, const char *r_file_path);
 112
 113 /* vconf changed cb */
 114 static void cam_app_battery_update_cb(keynode_t *key, void *data);
 115 static void cam_app_battery_status_cb(keynode_t *key, void *data);
 116 static void cam_mmc_state_change_cb(keynode_t *key, void *data);
 117 static void cam_idle_lockstate_change_cb(keynode_t *key, void *data);
 118 static void cam_usb_state_change_cb(keynode_t *key, void *data);
 119 static void cam_torchlight_update_cb(keynode_t *key, void *data);
 120
 121 void cam_app_preview_start_coordinate(CamVideoRectangle src,
 122                                       CamVideoRectangle dst,
 123                                       CamVideoRectangle *result);
 124 void cam_app_timeout_notice_response_cb(void *data, Evas_Object *obj, void *event_info);
 125 static void cam_app_capture_error_popup_response_cb(void *data, Evas_Object *obj, void *event_info);
 126 Eina_Bool cam_app_launch_after_preview_began(void *data);
 127
 128 static void cam_app_auto_close_popup_response_cancel_cb(void *data, Evas_Object *obj, void *event_info);
 129 static void cam_app_auto_close_popup_response_ok_cb(void *data, Evas_Object *obj, void *event_info);
 130 static void cam_app_timer_update_count(void *data);
 131
 132
 133 /* video streamming */
 134 static gboolean video_stream_skip_flag = false;
 135
 136 /* thumbnail image check count */
 137 static int g_thumbnail_image_check_count = 0;
 138
 139 /*popup */
 140 gboolean g_blocking_popup = false;
 141
 142 void cam_app_set_blocking_popup()
 143 {
 144         g_blocking_popup = true;
 145 }
 146
 147 void cam_app_free_blocking_popup()
 148 {
 149         g_blocking_popup = false;
 150 }
 151
 152 gboolean cam_app_check_blocking_popup()
 153 {
 154         return !g_blocking_popup;
 155 }
 156
 157 struct noti_callback {
 158         char *setting_key;
 159         void (*noti_func) (keynode_t *, void *);
 160 };
 161
 162 #define CAMERA_NOTI_MAX         7
 163 struct noti_callback notis[CAMERA_NOTI_MAX] = {
 164         {VCONFKEY_SYSMAN_BATTERY_CAPACITY, *cam_app_battery_update_cb},
 165         {VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, *cam_app_battery_update_cb},
 166         {VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, *cam_app_battery_status_cb},
 167         {VCONFKEY_SYSMAN_MMC_STATUS, *cam_mmc_state_change_cb},
 168         {VCONFKEY_IDLE_LOCK_STATE, *cam_idle_lockstate_change_cb},
 169         {VCONFKEY_SYSMAN_USB_STATUS, *cam_usb_state_change_cb},
 170         {VCONFKEY_SETAPPL_ACCESSIBILITY_TORCH_LIGHT, *cam_torchlight_update_cb}
 171 };
 172
 173 #ifdef CAMAPP_SIG_HANDLING
 174 #include <signal.h>
 175 static struct sigaction cam_app_act;
 176 static struct sigaction cam_app_act_old;
 177
 178 static void cam_app_register_sigsegv(void);
 179 static void cam_app_sigsegv_handler(int signal_no, siginfo_t *info,
 180                                     void *context);
 181 #endif
 182
 183 static void cam_app_pipe_handler(void *data, void *buffer, unsigned int nbyte);
 184 static int cam_app_state_manager(int previous, int current, gboolean by_asm);
 185 static void cam_app_close_ug(void *data);
 186 Eina_Bool __ug_destory_postprocessing(void *data);
 187
 188 /* timeout */
 189 static gboolean cam_app_timeout_checker_update();
 190 static Eina_Bool cam_app_timeout_checker_cb(void *data);
 191
 192 gdouble _get_current_time(void)
 193 {
 194         struct timeval tv;
 195         gettimeofday(&tv, NULL);
 196         return (gdouble) tv.tv_sec + (gdouble) tv.tv_usec / 1E6;
 197 }
 198 void cam_app_zoom_warring_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
 199 {
 200         if (obj) {
 201                 evas_object_del(obj);
 202                 obj = NULL;
 203         }
 204 }
 205 void cam_app_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
 206 {
 207         if (obj) {
 208                 evas_object_del(obj);
 209                 obj = NULL;
 210         }
 211 }
 212
 213 void cam_app_snapshot_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
 214 {
 215         struct appdata *ad = data;
 216         cam_retm_if(ad == NULL, "appdata is NULL");
 217
 218         if (obj) {
 219                 evas_object_del(obj);
 220                 obj = NULL;
 221         }
 222         ad->is_showing_snapshot_popup = FALSE;
 223         DEBUG_TRACE("ad->is_showing_snapshot_popup = FALSE");
 224 }
 225
 226 static Eina_Bool cam_delay_popup(void *data)
 227 {
 228
 229         cam_app_notice_popup(data,_("IDS_CAM_POP_UNABLE_TO_START_CAMERA_DURING_CALL"),
 230                              cam_app_timeout_notice_response_cb);
 231         return EINA_FALSE;
 232
 233 }
 234 static void cam_add_longpress_key_timer(void *data)
 235 {
 236         struct appdata *ad = (struct appdata *)data;
 237         cam_retm_if(ad == NULL, "appdata is NULL");
 238         if (!ad->longpress_timer) {
 239                 ad->longpress_timer =
 240                         ecore_timer_add(LONG_PRESS_INTERVAL, cam_volume_key_press, ad);
 241         }
 242 }
 243
 244 static void cam_del_longpress_key_timer(void *data)
 245 {
 246         struct appdata *ad = (struct appdata *)data;
 247         cam_retm_if(ad == NULL, "appdata is NULL");
 248         if (ad->longpress_timer) {
 249                 ecore_timer_del(ad->longpress_timer);
 250                 ad->longpress_timer = 0;
 251         }
 252 }
 253
 254 Eina_Bool _message_popup_destroy_and_exit(void *data)
 255 {
 256         Evas_Object *obj = (Evas_Object *)data;
 257         cam_popup_remove(obj);
 258         elm_exit();
 259
 260         return ECORE_CALLBACK_CANCEL;
 261 }
 262
 263 Eina_Bool cam_app_real_exit(void *data)
 264 {
 265         struct appdata *ad = (struct appdata *)data;
 266
 267         debug_fenter(LOG_UI);
 268         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
 269
 270         if (ad->timeout_checker) {
 271                 ecore_timer_del(ad->timeout_checker);
 272                 ad->timeout_checker = NULL;
 273         }
 274
 275         cam_app_key_event_deinit(ad);
 276
 277         elm_exit();
 278
 279         return 0;
 280 }
 281 #ifdef EFL_TEMP_CODE
 282 void cam_win_transparent_set(void *data)
 283 {
 284         struct appdata *ad = (struct appdata *)data;
 285         cam_ret_if(ad == NULL);
 286
 287         Evas *evas;
 288         Evas_Object *rect;
 289         int width =0, height=0;
 290         evas_object_geometry_get(ad->win_main, NULL, NULL, &height, &width);
 291         evas = evas_object_evas_get(ad->win_main);
 292         rect = evas_object_rectangle_add(evas);
 293         evas_object_color_set(rect, 0, 0, 0, 0);
 294         evas_object_render_op_set(rect, EVAS_RENDER_COPY);
 295         if (width >= height) {
 296                 evas_object_resize(rect, width, width);
 297         } else {
 298                 evas_object_resize(rect, height, height);
 299         }
 300         evas_object_show(rect);
 301 }
 302 #endif
 303 void cam_set_orient_value(void *data)
 304 {
 305         struct appdata *ad = (struct appdata *)data;
 306         cam_retm_if(ad == NULL, "appdata is NULL");
 307         int orient_value = 0;
 308 #if 0
 309         CamAppData *camapp = ad->camapp_handle;
 310         if (camapp->shooting_mode == CAM_SELF_MODE) {
 311                 switch (ad->rot_current) {
 312                 case APPCORE_RM_PORTRAIT_NORMAL:
 313                         orient_value = 1;
 314                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 315                                     ad->rot_current, orient_value);
 316                         break;
 317                 case APPCORE_RM_PORTRAIT_REVERSE:
 318                         orient_value = 3;
 319                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 320                                     ad->rot_current, orient_value);
 321                         break;
 322                 case APPCORE_RM_LANDSCAPE_NORMAL:
 323                         orient_value = 8;
 324                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 325                                     ad->rot_current, orient_value);
 326                         break;
 327                 case APPCORE_RM_LANDSCAPE_REVERSE:
 328                         orient_value = 6;
 329                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 330                                     ad->rot_current, orient_value);
 331                         break;
 332                 default:
 333                         break;
 334                 }
 335         } else {
 336 #endif
 337                 switch (ad->rot_current) {
 338                 case APP_DEVICE_ORIENTATION_0:
 339                         orient_value = 6;
 340                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 341                                     ad->rot_current, orient_value);
 342                         break;
 343                 case APP_DEVICE_ORIENTATION_180:
 344                         orient_value = 8;
 345                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 346                                     ad->rot_current, orient_value);
 347                         break;
 348                 case APP_DEVICE_ORIENTATION_90:
 349                         orient_value = 3;
 350                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 351                                     ad->rot_current, orient_value);
 352                         break;
 353                 case APP_DEVICE_ORIENTATION_270:
 354                         orient_value = 1;
 355                         DEBUG_TRACE("rot_cuttent=%d orient_value=%d\n",
 356                                     ad->rot_current, orient_value);
 357                         break;
 358                 default:
 359                         break;
 360                 }
 361
 362         /*orient_value = CAMERA_ATTR_TAG_ORIENTATION_TOP_LEFT;*/
 363
 364         if (cam_mm_set_tag_img_orient(orient_value))
 365                 DEBUG_TRACE("set image orient succeed %d", orient_value);
 366         else
 367                 DEBUG_TRACE("set image orient failed %d", orient_value);
 368
 369 }
 370
 371 int cam_noti_init(void *data)
 372 {
 373         struct appdata *ad = (struct appdata *)data;
 374         int i = 0;
 375
 376         debug_fenter(LOG_UI);
 377
 378         cam_retvm_if(ad == NULL, EXIT_FAILURE, "appdata is NULL");
 379
 380
 381         /* setting noti */
 382         for (i = 0; i < CAMERA_NOTI_MAX; i++) {
 383                 if (0 !=
 384                     vconf_notify_key_changed(notis[i].setting_key,
 385                                              notis[i].noti_func, ad)) {
 386                         cam_critical(LOG_SYS,
 387                                      "vconf_notify_key_changed() failed. count=%d ",
 388                                      i);
 389                 }
 390         }
 391         return EXIT_SUCCESS;
 392 }
 393
 394 int cam_noti_deinit(void *data)
 395 {
 396         int i;
 397         struct appdata *ad = (struct appdata *)data;
 398
 399         debug_fenter(LOG_SYS);
 400
 401         cam_retvm_if(ad == NULL, EXIT_FAILURE, "appdata is NULL");
 402
 403
 404
 405
 406         for (i = 0; i < CAMERA_NOTI_MAX; i++) {
 407                 vconf_ignore_key_changed(notis[i].setting_key,
 408                                          notis[i].noti_func);
 409         }
 410
 411         return EXIT_SUCCESS;
 412 }
 413
 414 void *cam_appdata_get(void)
 415 {
 416         if (app_handle) {
 417                 return app_handle;
 418         }
 419         return NULL;
 420 }
 421
 422 static void cam_app_get_win_size(struct appdata *ad)
 423 {
 424         DEBUG_TRACE();
 425
 426         cam_ret_if(ad == NULL || ad->win_main == NULL);
 427         evas_object_geometry_get(ad->win_main, NULL, NULL, &(ad->win_height),
 428                                  &(ad->win_width));
 429
 430         cam_debug(LOG_UI, "main window ----- win_width, win_height: [%d, %d]",
 431                   ad->win_width, ad->win_height);
 432 }
 433
 434 int cam_appdata_init(void *data)
 435 {
 436         struct appdata *ad = (struct appdata *)data;
 437         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
 438
 439
 440         app_handle = ad;
 441
 442         ad->main_pipe = ecore_pipe_add(cam_app_pipe_handler, ad);
 443         ad->rot_current = app_get_device_orientation();
 444         ad->rot_previous = ad->rot_current;
 445
 446         cam_app_get_win_size(ad);
 447
 448         CAM_TA_ACUM_ITEM_BEGIN("      cam_handle_create", 0);
 449         if (!cam_handle_create(data)) {
 450                 cam_critical(LOG_CAM, "cam_handle_create failed");
 451                 return FALSE;
 452         }
 453         CAM_TA_ACUM_ITEM_END("      cam_handle_create", 0);
 454
 455         ad->last_camera_zoom_mode = 1;
 456
 457         return 1;
 458 }
 459
 460 int cam_appdata_fini(void *data)
 461 {
 462         struct appdata *ad = (struct appdata *)data;
 463
 464         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
 465
 466         cam_layout_del_all(ad);
 467
 468         if (ad->imageviewer_service) {
 469                 service_destroy(ad->imageviewer_service);
 470                 ad->imageviewer_service = NULL;
 471         }
 472         if (ad->timeout_checker) {
 473                 ecore_timer_del(ad->timeout_checker);
 474                 ad->timeout_checker = NULL;
 475         }
 476         if (ad->key_down) {
 477                 ecore_event_handler_del(ad->key_down);
 478                 ad->key_down = NULL;
 479         }
 480         if (ad->key_up) {
 481                 ecore_event_handler_del(ad->key_up);
 482                 ad->key_up = NULL;
 483         }
 484         if (ad->mouse_up) {
 485                 ecore_event_handler_del(ad->mouse_up);
 486                 ad->mouse_up = NULL;
 487         }
 488         if (ad->mouse_down) {
 489                 ecore_event_handler_del(ad->mouse_down);
 490                 ad->mouse_down = NULL;
 491         }
 492         if (ad->recording_commit) {
 493                 ecore_idler_del(ad->recording_commit);
 494                 ad->recording_commit = NULL;
 495         }
 496         if (ad->still_captured_idle) {
 497                 ecore_idler_del(ad->still_captured_idle);
 498                 ad->still_captured_idle = NULL;
 499         }
 500         if (ad->capture_idle) {
 501                 ecore_idler_del(ad->capture_idle);
 502                 ad->capture_idle = NULL;
 503         }
 504         /* Remove Idle handler of capture callback. wh01.cho@samsung.com. 2010-12-15. */
 505         if (ad->capture_cb_list) {
 506                 cam_utils_remove_idler_all(ad);
 507         }
 508         if (ad->auto_shot_idle) {
 509                 ecore_idler_del(ad->auto_shot_idle);
 510                 ad->auto_shot_idle = NULL;
 511         }
 512         if (ad->update_thumbnail_idler) {
 513                 ecore_idler_del(ad->update_thumbnail_idler);
 514                 ad->update_thumbnail_idler = NULL;
 515         }
 516         if (ad->timer_timer) {
 517                 ecore_timer_del(ad->timer_timer);
 518                 ad->timer_timer = NULL;
 519         }
 520         if (ad->timeout_checker) {
 521                 ecore_timer_del(ad->timeout_checker);
 522                 ad->timeout_checker = NULL;
 523         }
 524         if (ad->rec_icon_updater) {
 525                 ecore_timer_del(ad->rec_icon_updater);
 526                 ad->rec_icon_updater = NULL;
 527         }
 528         if (ad->rec_time_updater) {
 529                 ecore_timer_del(ad->rec_time_updater);
 530                 ad->rec_time_updater = NULL;
 531         }
 532         if( ad->setting_menu_composer != NULL){
 533                 cam_compose_free(ad->setting_menu_composer);
 534         }
 535         if (ad->camapp_handle) {
 536                 cam_handle_free(ad);
 537         }
 538         if (ad->exe_args) {
 539                 if (ad->exe_args->caller) {
 540                         free(ad->exe_args->caller);
 541                         ad->exe_args->caller = NULL;
 542                 }
 543                 free(ad->exe_args);
 544                 ad->exe_args = NULL;
 545         }
 546 #ifdef USE_FILE_REG_THREAD
 547
 548         if (ad->file_reg_thread) {
 549                 pthread_join(ad->file_reg_thread, NULL);
 550         }
 551
 552         if (ad->file_reg_queue) {
 553                 while (!g_queue_is_empty(ad->file_reg_queue)) {
 554                         char *filename = NULL;
 555                         filename = g_queue_pop_head(ad->file_reg_queue);
 556
 557                         cam_critical(LOG_FILE, "[%s] didn't processed",
 558                                      filename);
 559
 560                         if (!strcmp(REG_THREAD_EXIT, filename)) {
 561                                 free(filename);
 562                         } else {
 563                                 __cam_single_shot_reg_file(filename);
 564                                 free(filename);
 565                                 cam_debug(LOG_FILE, " register done.");
 566                         }
 567                 }
 568                 g_queue_free(ad->file_reg_queue);
 569                 ad->file_reg_queue = NULL;
 570         }
 571 #endif
 572
 573         if (ad->main_pipe) {
 574                 ecore_pipe_del(ad->main_pipe);
 575                 ad->main_pipe = NULL;
 576         }
 577         /* init global handle */
 578         app_handle = NULL;
 579
 580         return 1;
 581 }
 582
 583 CamAppData *cam_handle_get(void)
 584 {
 585         if (cam_handle) {
 586                 return cam_handle;
 587         }
 588         return NULL;
 589 }
 590
 591 gboolean cam_app_init(void *data)
 592 {
 593         struct appdata *ad = (struct appdata *)data;
 594         GError *error = NULL;
 595
 596         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 597
 598         CAM_TA_ACUM_ITEM_BEGIN("    cam_appdata_init", 0);
 599         if (!cam_appdata_init(ad)) {
 600                 cam_critical(LOG_CAM, "cam_appdata_init failed");
 601                 return FALSE;
 602         }
 603         CAM_TA_ACUM_ITEM_END("    cam_appdata_init", 0);
 604
 605         cam_retvm_if(ad->camapp_handle == NULL, FALSE, "camapp_handle is NULL");
 606
 607         CAM_TA_ACUM_ITEM_BEGIN("    cam_config_init", 0);
 608         if (!cam_config_init(&error)) {
 609                 cam_critical(LOG_SYS, "cam_config_init failed");
 610                 if (error != NULL) {
 611                         cam_critical(LOG_SYS, "cam_config_init error [%s]",
 612                                      error->message);
 613                         g_error_free(error);
 614                         error = NULL;
 615                 }
 616                 return FALSE;
 617         }
 618         CAM_TA_ACUM_ITEM_END("    cam_config_init", 0);
 619
 620         CAM_TA_ACUM_ITEM_BEGIN("    cam_noti_init", 0);
 621         if (EXIT_FAILURE == cam_noti_init(ad)) {
 622                 cam_critical(LOG_CAM, "cam_noti_init failed");
 623         }
 624         CAM_TA_ACUM_ITEM_END("    cam_noti_init", 0);
 625
 626         CAM_TA_ACUM_ITEM_BEGIN("    cam_file_init", 0);
 627         if (!cam_file_init(&error)) {
 628                 cam_critical(LOG_FILE, "cam_file_init failed");
 629                 if (error != NULL) {
 630                         cam_critical(LOG_FILE, "cam_file_init error [%s]",
 631                                      error->message);
 632                         g_error_free(error);
 633                         error = NULL;
 634                 }
 635                 return FALSE;
 636         }
 637         CAM_TA_ACUM_ITEM_END("    cam_file_init", 0);
 638         CAM_TA_ACUM_ITEM_BEGIN("    cam_sound_init", 0);
 639         if (!cam_sound_init(&error)) {
 640                 cam_critical(LOG_SND, "cam_sound_init failed");
 641                 if (error != NULL) {
 642                         cam_critical(LOG_SND, "cam_sound_init error [%s]",
 643                                      error->message);
 644                         g_error_free(error);
 645                         error = NULL;
 646                 }
 647                 return FALSE;
 648         }
 649         CAM_TA_ACUM_ITEM_END("    cam_sound_init", 0);
 650
 651 #ifdef USE_FILE_REG_THREAD
 652         CAM_TA_ACUM_ITEM_BEGIN("    cam_app_create_file_register_thread", 0);
 653         if (!cam_app_create_file_register_thread(ad)) {
 654                 cam_critical(LOG_SYS,
 655                              " cam_app_create_file_register_thread failed");
 656                 return FALSE;
 657         }
 658         CAM_TA_ACUM_ITEM_END("    cam_app_create_file_register_thread", 0);
 659 #endif
 660
 661 #ifdef CAMAPP_SIG_HANDLING
 662         /* register singal handler */
 663         CAM_TA_ACUM_ITEM_BEGIN("    cam_app_create_file_register_thread", 0);
 664         cam_app_register_sigsegv();
 665         CAM_TA_ACUM_ITEM_BEGIN("    cam_app_create_file_register_thread", 0);
 666 #endif
 667
 668 #if ENABLE_HAPTIC
 669         CAM_TA_ACUM_ITEM_BEGIN("    cam_devman_init", 0);
 670         if (!cam_devman_init(ad)) {
 671                 cam_critical(LOG_SYS, " cam_devman_init failed");
 672                 return FALSE;
 673         }
 674         CAM_TA_ACUM_ITEM_END("    cam_devman_init", 0);
 675 #endif
 676
 677         if(media_content_connect() == MEDIA_CONTENT_ERROR_NONE) {
 678                 DEBUG_TRACE("connection is success");
 679         } else {
 680                 cam_critical(LOG_SYS, " media_content_connect failed");
 681                 return FALSE;
 682         }
 683
 684         if (error != NULL) {
 685                 g_error_free(error);
 686                 error = NULL;
 687         }
 688         return TRUE;
 689 }
 690
 691 gboolean cam_app_start(void *data)
 692 {
 693         CAM_TA_ACUM_ITEM_BEGIN("#########cam_app_start", 0);
 694
 695         struct appdata *ad = (struct appdata *)data;
 696         CamAppData *camapp = NULL;
 697         /*int session_type;*/
 698
 699         debug_fenter(LOG_CAM);
 700
 701         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 702         camapp = ad->camapp_handle;
 703         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 704
 705         /*init guideline value*/
 706 #ifdef GUIDE_LINE_ENALBE
 707         camapp->guideline = FALSE;
 708 #endif
 709
 710         CAM_TA_ACUM_ITEM_BEGIN("    cam_mm_create", 0);
 711         if (cam_mm_is_created() == FALSE) {
 712                 if (!cam_mm_create(CAM_DEVICE_MEGA, camapp->camera_mode)) {
 713                         cam_critical(LOG_MM, "cam_mm_create failed");
 714                         cam_app_notice_popup(ad, "UNABLE TO LAUNCH CAMERA", cam_app_timeout_notice_response_cb);
 715                         return FALSE;
 716                 }
 717         }
 718         CAM_TA_ACUM_ITEM_END("    cam_mm_create", 0);
 719
 720         CAM_TA_ACUM_ITEM_BEGIN("    cam_callback_init", 0);
 721         if (!cam_callback_init(ad)) {
 722                 cam_critical(LOG_CAM, "cam_init_mm_callback failed");
 723                 cam_app_notice_popup(ad, "UNABLE TO START PREVIEW", cam_app_timeout_notice_response_cb);
 724                 return FALSE;
 725         }
 726         CAM_TA_ACUM_ITEM_END("    cam_callback_init", 0);
 727
 728         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_init_attribute", 0);
 729         if (!cam_app_init_attribute(ad, camapp->camera_mode)) {
 730                 cam_critical(LOG_MM, "cam_app_init_attribute failed");
 731 //              return FALSE;
 732         }
 733         CAM_TA_ACUM_ITEM_END("      cam_app_init_attribute", 0);
 734
 735         CAM_TA_ACUM_ITEM_BEGIN("    cam_app_preview_start", 0);
 736
 737         /*
 738         *       TODO: this func dealt with efl ui api, but cam_app_start is called in thread.
 739         *               We should consider it carefully.
 740         */
 741         cam_continuous_af_start(ad);
 742         if (!cam_app_preview_start(ad)) {
 743                 if (ad->is_calling == CAMERA_ERROR_SOUND_POLICY ||ad->is_calling == RECORDER_ERROR_SOUND_POLICY) {
 744                         DEBUG_TRACE(" MM CAMCARORDER ERROR\n");
 745                         cam_app_black_screen_show(ad, 2);
 746                         ecore_timer_add(0.01, cam_delay_popup, (void *)ad);
 747                         return FALSE;
 748                 }
 749
 750                 cam_critical(LOG_MM, "cam_app_preview_start failed");
 751                 cam_app_notice_popup(ad, "UNABLE TO START PREVIEW", cam_app_timeout_notice_response_cb);
 752                 return FALSE;
 753         }
 754         CAM_TA_ACUM_ITEM_END("    cam_app_preview_start", 0);
 755
 756         if(!cam_key_grab_init(ad))
 757                 DEBUG_TRACE("cam_key_grab_init fail");
 758         cam_app_key_event_init(ad);
 759         cam_app_timeout_checker_init(ad);
 760
 761 #ifdef ENABLE_CHECK_CAM_STATUS
 762         alarm(CAM_CHECK_STATUS_INTERVAL_TIME);  /* start alarm */
 763 #endif
 764         CAM_TA_ACUM_ITEM_END("#########cam_app_start", 0);
 765
 766         return TRUE;
 767 }
 768
 769 gboolean cam_app_pause(void *data)
 770 {
 771         DEBUG_TRACE("#############cam_app_pause - START #############\n");
 772         struct appdata *ad = (struct appdata *)data;
 773         CamAppData *camapp = NULL;
 774         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 775         camapp = ad->camapp_handle;
 776         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 777
 778         int mm_state = 0;
 779         mm_state = cam_mm_get_state();
 780
 781         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
 782                 if ((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "contacts") == 0)) {
 783                         DEBUG_TRACE(" contact is paused ");
 784                         service_h reply;
 785                         service_create(&reply);
 786                         service_add_extra_data(reply, "camera_end", "1");
 787                         service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_CANCELED);
 788                         service_destroy(reply);
 789                 }
 790         }
 791
 792         if ((mm_state == RECORDER_STATE_RECORDING
 793             || mm_state == RECORDER_STATE_PAUSED)
 794             &&(camapp->camera_mode == CAM_CAMCORDER_MODE)) {
 795                 int shutter_sound_state = 0;
 796                 /* get current sound */
 797                 cam_mm_get_shutter_sound(&shutter_sound_state);
 798                 /* disable shutter sound */
 799                 cam_mm_set_shutter_sound(FALSE);
 800                 /*stop recording */
 801                 cam_video_record_stop(ad);
 802                 /*restore shutter sound */
 803                 cam_mm_set_shutter_sound(shutter_sound_state);
 804         } else if (mm_state == CAMERA_STATE_CAPTURING
 805                 && (camapp->camera_mode == CAM_CAMERA_MODE)) {
 806                 cam_mm_capture_stop(TRUE, CAM_CAMERA_MODE);
 807         }
 808
 809         if (ad->imageviewer_ug) {       /*  image viewer is running and camera app is fous out */
 810                 ad->foucs_out_from_quickview = TRUE;
 811         }
 812         CAM_TA_ACUM_ITEM_BEGIN("    cam_app_preview_stop", 0);
 813         if (!cam_app_preview_stop()) {
 814                 cam_critical(LOG_MM, "cam_app_preview_stop fail");
 815         }
 816         CAM_TA_ACUM_ITEM_END("    cam_app_preview_stop", 0);
 817
 818         cam_app_key_event_deinit(ad);
 819         if (!cam_key_grab_deinit(ad)) {
 820                 DEBUG_TRACE("cam_key_grab_deinit fail");
 821         }
 822
 823         cam_app_timeout_checker_init(ad);
 824
 825         DEBUG_TRACE("#############cam_app_pause - END #############\n");
 826         return TRUE;
 827 }
 828
 829 gboolean cam_app_resume(void *data)
 830 {
 831         struct appdata *ad = (struct appdata *)data;
 832         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
 833
 834         CamAppData *camapp = NULL;
 835         camapp = ad->camapp_handle;
 836         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
 837
 838         int cam_state = -1;
 839         debug_fenter(LOG_CAM);
 840
 841         if (!cam_condition_check_to_start_camera(ad)) {
 842                 cam_critical(LOG_CAM, "cannot start camera");
 843                 return ECORE_CALLBACK_CANCEL;
 844         }
 845
 846         cam_app_timeout_checker_init(ad);
 847
 848         if (ad->imageviewer_ug == NULL) { /* home key destory imageviewer_ug */
 849                 elm_win_indicator_mode_set(ad->win_main, ELM_WIN_INDICATOR_HIDE);
 850                 cam_state = cam_mm_get_state();
 851                 cam_app_get_preview_offset_coordinate(ad);
 852
 853                 CAM_TA_ACUM_ITEM_BEGIN("    cam_app_preview_start", 0);
 854                 if (!cam_app_preview_start(ad)) {
 855                         if (ad->is_calling == CAMERA_ERROR_SOUND_POLICY || ad->is_calling == RECORDER_ERROR_SOUND_POLICY) {
 856                                 DEBUG_TRACE(" MM CAMCARORDER ERROR\n");
 857                                 cam_app_black_screen_show(ad, 2);
 858                                 ecore_timer_add(0.01, cam_delay_popup, (void *)ad);
 859                                 return TRUE;
 860                         }
 861
 862                         cam_critical(LOG_MM, "cam_app_preview_start failed");
 863                         cam_app_notice_popup(ad,
 864                          "PREVIEW START FAILED !!",
 865                          cam_app_timeout_notice_response_cb);
 866                         return FALSE;
 867                 }
 868                 CAM_TA_ACUM_ITEM_END("    cam_app_preview_start", 0);
 869         }
 870
 871         CAM_TA_ACUM_ITEM_BEGIN("    cam_key_grab_init", 0);
 872
 873    if (!ad->imageviewer_ug) {
 874                 if (!cam_key_grab_init(ad))
 875                         DEBUG_TRACE("cam_key_grab_init fail");
 876                 CAM_TA_ACUM_ITEM_END("    cam_key_grab_init", 0);
 877                 cam_app_key_event_init(ad);
 878         }
 879 #ifdef ENABLE_CHECK_CAM_STATUS
 880         alarm(CAM_CHECK_STATUS_INTERVAL_TIME);  /* start alarm */
 881 #endif
 882
 883         return TRUE;
 884 }
 885
 886 Eina_Bool cam_app_stop(void *data)
 887 {
 888         struct appdata *ad = (struct appdata *)data;
 889         CamAppData *camapp = NULL;
 890
 891         char *filename = NULL;
 892         debug_fenter(LOG_CAM);
 893         cam_retvm_if(ad == NULL, EXIT_FAILURE, "appdata is NULL");
 894
 895         CAM_TA_ACUM_ITEM_BEGIN("  cam_app_stop", 0);
 896
 897         camapp = ad->camapp_handle;
 898         cam_retvm_if(camapp == NULL, EXIT_FAILURE, "camapp_handle is NULL");
 899
 900         /* return aul result path */
 901         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
 902                 if (ad->exe_args == NULL) {
 903                         DEBUG_TRACE("ad->exe_args is NULL");
 904                         return EXIT_FAILURE;
 905                 }
 906                 if (ad->path_in_return) {
 907                         if ((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "contacts") == 0)) {
 908                                 DEBUG_TRACE("contacts -not need sending result");
 909                         } else {
 910                                 if (ad->appcore_state != CAM_APPCORE_PAUSE_STATE) {
 911                                         if (camapp->filename != NULL) {
 912                                                 filename = strdup(camapp->filename);
 913                                                 cam_app_return_ext_app(ad, filename);
 914                                         }
 915                                 }
 916                         }
 917                 } else {
 918                         cam_app_return_ext_app(ad, filename);
 919                 }
 920         }
 921
 922         if (ad->imageviewer_ug) {
 923                 cam_app_close_ug(ad);
 924         }
 925
 926         cam_popup_remove_all();
 927         cam_toolbar_destroy(ad);
 928         cam_app_clear_engine_data(ad, true);
 929
 930         if (ad->timer_activated) {
 931                 ad->timer_activated = false;
 932
 933                 DEL_EVAS_OBJECT(ad->timer_icon_edje);
 934                 REMOVE_TIMER(ad->timer_timer);
 935         }
 936         REMOVE_TIMER(ad->toolbar_toggle_timer);
 937         cam_app_timeout_checker_remove();
 938         if (ad->auto_close_timer) {
 939                 ecore_timer_del(ad->auto_close_timer);
 940                 ad->auto_close_timer = NULL;
 941         }
 942 #if 1
 943         if (EXIT_FAILURE == cam_noti_deinit(ad)) {
 944                 cam_critical(LOG_UI, "cam_noti_deinit failed");
 945         }
 946 #endif
 947         cam_app_key_event_deinit(ad);
 948         if(!cam_key_grab_deinit(ad))
 949                 DEBUG_TRACE("cam_key_grab_deinit fail");
 950
 951         /* destory camcorder */
 952         if (cam_mm_is_created()) {
 953                 int state = 0;
 954                 state = cam_mm_get_state();
 955                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
 956                         switch (state) {
 957                         case CAMERA_STATE_NONE:
 958                         case CAMERA_STATE_CREATED:
 959                                 break;
 960                         case CAMERA_STATE_PREVIEW:
 961                                 break;
 962                         case CAMERA_STATE_CAPTURING:
 963                                 cam_mm_capture_stop(TRUE, CAM_CAMERA_MODE);
 964                                 break;
 965                         case CAMERA_STATE_CAPTURED:
 966                                 break;
 967                         default:
 968                                 /*g_assert_not_reached();*/
 969                                 break;
 970                         }
 971                 }else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
 972                         switch (state) {
 973                         case RECORDER_STATE_NONE:
 974                         case RECORDER_STATE_CREATED:
 975                                 break;
 976                         case RECORDER_STATE_READY:
 977                                 break;
 978                         case RECORDER_STATE_RECORDING:
 979                         case RECORDER_STATE_PAUSED:
 980                                 cam_video_record_stop(ad);
 981                                 break;
 982                         default:
 983                                 /*g_assert_not_reached();*/
 984                                 break;
 985                         }
 986
 987                 }
 988                 CAM_TA_ACUM_ITEM_BEGIN("    cam_app_preview_stop", 0);
 989                 if (!cam_app_preview_stop()) {
 990                         cam_critical(LOG_MM, "cam_app_preview_stop faild");
 991                 }
 992                 CAM_TA_ACUM_ITEM_END("    cam_app_preview_stop", 0);
 993                 CAM_TA_ACUM_ITEM_BEGIN("    cam_mm_destory", 0);
 994                 if (!cam_mm_destory()) {
 995                         cam_critical(LOG_MM, "cam_mm_destory faild");
 996                 }
 997                 CAM_TA_ACUM_ITEM_END("    cam_mm_destory", 0);
 998         }
 999
1000         cam_config_save();
1001         ad->toolbar_hided = FALSE;
1002         cam_app_toggle_indicator(ad, FALSE);
1003         cam_app_toggle_toolbar(ad, FALSE);
1004
1005         /* Idler of capture callback management. wh01.cho@samsung.com. 2010-12-15. */
1006         cam_app_destroy_progressbar(ad);
1007         cam_utils_remove_idler_all(ad);
1008
1009         if (filename != NULL) {
1010                 free(filename);
1011                 filename = NULL;
1012         }
1013
1014         CAM_TA_ACUM_ITEM_END("  cam_app_stop", 0);
1015
1016         CAM_TA_ACUM_ITEM_SHOW_RESULT_TO(CAM_TA_SHOW_FILE);
1017         CAM_TA_RELEASE();
1018
1019         return EXIT_SUCCESS;
1020
1021 }
1022
1023 gboolean cam_app_quit(void *data)
1024 {
1025         struct appdata *ad = (struct appdata *)data;
1026         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1027
1028         if (cam_mm_is_created()) {
1029                 /*TODO: new logic will be add for save file while camera process is killed*/
1030                 /*stop*/
1031                 int state = 0;
1032                 state = cam_mm_get_state();
1033                 if (ad->camapp_handle) {
1034                         if (ad->camapp_handle->camera_mode == CAM_CAMCORDER_MODE) {
1035                                 switch (state) {
1036                                 case RECORDER_STATE_NONE:
1037                                 case RECORDER_STATE_CREATED:
1038                                         break;
1039                                 case RECORDER_STATE_READY:
1040                                         break;
1041                                 case RECORDER_STATE_RECORDING:
1042                                 case RECORDER_STATE_PAUSED:
1043                                         cam_video_record_stop(ad);
1044                                         break;
1045                                 default:
1046                                         /*g_assert_not_reached();*/
1047                                         break;
1048                                 }
1049                         }
1050                 }
1051
1052                 CAM_TA_ACUM_ITEM_BEGIN("    cam_app_preview_stop", 0);
1053                 if (!cam_app_preview_stop()) {
1054                         cam_critical(LOG_MM, "cam_app_preview_stop failed");
1055                 }
1056                 CAM_TA_ACUM_ITEM_END("    cam_app_preview_stop", 0);
1057
1058                 CAM_TA_ACUM_ITEM_BEGIN("    cam_mm_destory", 0);
1059                 if (!cam_mm_destory()) {
1060                         cam_critical(LOG_MM, "cam_mm_destory failed");
1061                 }
1062                 CAM_TA_ACUM_ITEM_END("    cam_mm_destory", 0);
1063         }
1064 #if ENABLE_HAPTIC
1065         cam_devman_deinit();
1066 #endif
1067
1068         if (EXIT_FAILURE == cam_noti_deinit(ad)) {
1069                 cam_critical(LOG_UI, "cam_noti_deinit failed");
1070         }
1071         /* crear data & engine */
1072         CAM_TA_ACUM_ITEM_BEGIN("    cam_app_clear_engine_data", 0);
1073         cam_app_clear_engine_data(data, true);
1074         CAM_TA_ACUM_ITEM_END("    cam_app_clear_engine_data", 0);
1075         CAM_TA_ACUM_ITEM_BEGIN("    cam_file_finalize", 0);
1076         cam_file_finalize();
1077         CAM_TA_ACUM_ITEM_END("    cam_file_finalize", 0);
1078         CAM_TA_ACUM_ITEM_BEGIN("    cam_sound_finalize", 0);
1079         cam_sound_finalize();
1080         CAM_TA_ACUM_ITEM_END("    cam_sound_finalize", 0);
1081         /*  clean config */
1082         CAM_TA_ACUM_ITEM_BEGIN("    cam_config_finalize", 0);
1083         cam_config_finalize();
1084         CAM_TA_ACUM_ITEM_END("    cam_config_finalize", 0);
1085
1086         /*  disconnect media content */
1087         CAM_TA_ACUM_ITEM_BEGIN("    media_content_disconnect", 0);
1088
1089         if(media_content_disconnect() == MEDIA_CONTENT_ERROR_NONE) {
1090                 DEBUG_TRACE("dis connection is success");
1091         } else {
1092                 cam_critical(LOG_SYS, " media_content_disconnect failed");
1093         }
1094
1095         CAM_TA_ACUM_ITEM_END("    media_content_disconnect", 0);
1096
1097         /*  cam_handle_free(ad); */
1098         cam_appdata_fini(ad);
1099
1100         return TRUE;
1101 }
1102
1103 gboolean cam_app_preview_start(void *data)
1104 {
1105         CAM_TA_ACUM_ITEM_BEGIN("----cam_app_preview_start", 0);
1106         DEBUG_TRACE
1107             ("------------------------------START---------------------------------");
1108
1109         struct appdata *ad = (struct appdata *)data;
1110         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1111         CamAppData *camapp = ad->camapp_handle;
1112         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
1113
1114         int state = cam_mm_get_state();
1115         DEBUG_TRACE("state: %d ", state);
1116
1117         if (state < CAMERA_STATE_NONE || state < RECORDER_STATE_NONE)
1118                 return FALSE;
1119
1120         if (camapp->camera_mode == CAM_CAMERA_MODE) {
1121                 switch(state) {
1122                 case CAMERA_STATE_CREATED:
1123                 case CAMERA_STATE_CAPTURED:
1124                         {
1125                                 CAM_TA_ACUM_ITEM_BEGIN("          cam_mm_preview_start", 0);
1126                                 if (!cam_mm_preview_start(camapp->camera_mode)) {
1127                                         cam_critical(LOG_MM, "cam_mm_preview_start failed");
1128                                         return FALSE;
1129                                 }
1130                                 CAM_TA_ACUM_ITEM_END("          cam_mm_preview_start", 0);
1131                         }
1132                         break;
1133                 case CAMERA_STATE_CAPTURING:
1134                         {
1135                                 if (cam_mm_capture_stop(FALSE, camapp->camera_mode) == FALSE) {
1136                                         cam_critical(LOG_MM, "cam_mm_capture_stop failed");
1137                                         return FALSE;
1138                                 }
1139                         }
1140                         break;
1141                 default:
1142                         break;
1143                 }
1144         }else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
1145                 switch(state) {
1146                 case RECORDER_STATE_CREATED:
1147                 case RECORDER_STATE_PAUSED:
1148                         {
1149                                 if (!cam_mm_preview_start(camapp->camera_mode)) {
1150                                         cam_critical(LOG_MM, "cam_mm_preview_start failed");
1151                                         return FALSE;
1152                                 }
1153                         }
1154                         break;
1155                 default:
1156                         break;
1157
1158                 }
1159         }
1160
1161         CAM_TA_ACUM_ITEM_END("----cam_app_preview_start", 0);
1162         return TRUE;
1163 }
1164
1165 gboolean cam_app_preview_stop(void)
1166 {
1167         struct appdata *ad = (struct appdata *)cam_appdata_get();
1168         if (ad == NULL)
1169                 return FALSE;
1170         CamAppData *camapp = ad->camapp_handle;
1171         if (camapp == NULL)
1172                 return FALSE;
1173         if (!cam_mm_preview_stop(camapp->camera_mode)) {
1174                 cam_critical(LOG_MM, "cam_mm_preview_stop failed");
1175                 return FALSE;
1176         }
1177         return TRUE;
1178 }
1179
1180 static void
1181 _main_layout_click_cb(void *data, Evas_Object *obj, void *event_info)
1182 {
1183         struct appdata *ad = (struct appdata *)data;
1184
1185         if (!ad)
1186                 return;
1187
1188         unload_zoom_edje(ad);
1189
1190         if (ad->setting_ctxpopup || ad->toolbar_popup) {
1191                 /* destroy toolbar popup and setting popup */
1192                 ad->show_menu = FALSE;
1193                 ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
1194                 cam_toolbar_and_setting_popup_del(ad);
1195                 if (ad->shot_mode_guide_popup)
1196                         toolbar_shot_guide_popup_create(ad, ad->camapp_handle->shooting_mode);
1197         } else if (ad->toolbar_show_setting_popup == TRUE) {
1198                 ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
1199                 ad->show_menu = FALSE;
1200                 toolbar_hide_setting_popup(ad);
1201                 if (ad->toolbar_show_edit_shortcuts_popup == TRUE) {
1202                         toolbar_destroy_shortcuts_popup(ad);
1203                         ad->toolbar_show_edit_shortcuts_popup = FALSE;
1204                 }
1205         } else if (ad->toolbar_show_edit_shortcuts_popup == TRUE) {
1206                 toolbar_destroy_shortcuts_popup(ad);
1207                 ad->toolbar_show_edit_shortcuts_popup = FALSE;
1208         } else {
1209                 if (ad->camapp_handle->enable_touch_af == TRUE) {
1210                         REMOVE_TIMER(ad->continuous_af_timer);
1211                         cam_camera_touch_af_press(ad);
1212                 }
1213         }
1214
1215         return;
1216 }
1217
1218 static void cam_app_timer_icon_rotate(void *data)
1219 {
1220         struct appdata *ad = (struct appdata *)data;
1221         cam_retm_if(ad == NULL, "appdata is NULL");
1222
1223         DEL_EVAS_OBJECT(ad->timer_icon_edje);
1224         cam_app_timer_update_count(ad);
1225 }
1226
1227 static int cam_app_start_rotate(struct appdata *ad, bool bInitial)
1228 {
1229         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
1230
1231         cam_debug(LOG_UI, "rotated : %d, window rotation angle=%d", ad->rot_current);   /*, elm_win_rotation_get(ad->win_main)); */
1232
1233
1234         int angle = 0;
1235
1236         switch (ad->rot_current) {
1237         case APP_DEVICE_ORIENTATION_0:
1238                 ad->camcorder_rotate = CAMERA_ROTATION_90;
1239                 ad->target_direction = CAM_TARGET_DIRECTION_PORTRAIT;
1240                 angle = 0;
1241                 break;
1242
1243         case APP_DEVICE_ORIENTATION_180:
1244                 ad->camcorder_rotate = CAMERA_ROTATION_270;
1245                 ad->target_direction = CAM_TARGET_DIRECTION_PORTRAIT_INVERSE;
1246                 angle = 180;
1247                 break;
1248
1249         case APP_DEVICE_ORIENTATION_270:
1250                 ad->camcorder_rotate = CAMERA_ROTATION_NONE;
1251                 ad->target_direction = CAM_TARGET_DIRECTION_LANDSCAPE;
1252                 angle = 270;
1253                 break;
1254
1255         case APP_DEVICE_ORIENTATION_90:
1256                 ad->camcorder_rotate = CAMERA_ROTATION_180;
1257                 ad->target_direction = CAM_TARGET_DIRECTION_LANDSCAPE_INVERSE;
1258                 angle = 90;
1259                 break;
1260
1261         default:
1262                 break;
1263         }
1264         ad->angle = angle;
1265         ad->angle_pre = ad->angle;
1266
1267
1268 ////////////////////////////////////////////////////////////////////////////
1269         if (ad->toolbar_edj_file) {
1270                 free(ad->toolbar_edj_file);
1271                 ad->toolbar_edj_file = NULL;
1272         }
1273         /*ad->angle = 270;*/
1274         switch (ad->angle) {
1275         case 270:
1276                 ad->toolbar_edj_file = strdup(CAM_TOOLBAR_LAYOUT_EDJ_NAME);
1277                 break;
1278         case 0:
1279                 ad->toolbar_edj_file = strdup(CAM_TOOLBAR_LAYOUT_VERTICAL_EDJ_NAME);
1280                 break;
1281         case 90:
1282                 ad->toolbar_edj_file = strdup(CAM_TOOLBAR_LAYOUT_INVERSE_EDJ_NAME);
1283                 break;
1284         case 180:
1285                 ad->toolbar_edj_file = strdup(CAM_TOOLBAR_LAYOUT_VERTICAL_INVERSE_EDJ_NAME);
1286                 break;
1287         default:
1288                 ad->toolbar_edj_file = strdup(CAM_TOOLBAR_LAYOUT_EDJ_NAME);
1289                 break;
1290
1291         }
1292
1293         elm_win_rotation_with_resize_set(ad->win_main, ad->angle);
1294
1295         /* cam_app_get_win_size(ad); */
1296         cam_app_get_preview_offset_coordinate(ad);
1297
1298         if (!bInitial) {
1299                 if (ad->toolbar_edje)
1300                         cam_toolbar_rotate(ad);
1301
1302                 if (ad->indicator_edje)
1303                         cam_indicator_rotate(ad);
1304
1305                 if (ad->recording_edje)
1306                         cam_recording_rotate(ad);
1307
1308                 if (ad->timer_icon_edje)
1309                         cam_app_timer_icon_rotate(ad);
1310
1311                 if (ad->zoom_edje) {
1312                         unload_zoom_edje(ad);
1313                         load_zoom_edje(ad);
1314                 }
1315                 /* guideline */
1316 #ifdef GUIDE_LINE_ENALBE
1317                 if (ad->guideline_edje)
1318                         settings_guideline_refresh(ad);
1319 #endif
1320
1321         }
1322         return 0;
1323 }
1324
1325 gboolean cam_layout_init(void *data)
1326 {
1327         DEBUG_TRACE("START");
1328
1329         struct appdata *ad = (struct appdata *)data;
1330         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1331
1332         if (ad->win_main == NULL) {
1333                 cam_critical(LOG_UI, "win_main is NULL");
1334                 return FALSE;
1335         }
1336
1337         elm_win_indicator_mode_set(ad->win_main, ELM_WIN_INDICATOR_HIDE);
1338
1339         cam_app_start_rotate(ad, TRUE);
1340         DEBUG_TRACE("ad->angle = %d", ad->angle);
1341         /*elm_win_rotation_with_resize_set(ad->win_main, 270);*/
1342         cam_app_get_preview_offset_coordinate(ad);
1343         elm_theme_extension_add(NULL, CAM_SETTING_POPUP_STYLE_EDJ_NAME);
1344         elm_theme_extension_add(NULL, CAM_SETTING_POPUP_STYLE_WITH_RADIO_EDJ_NAME);
1345         elm_theme_extension_add(NULL, CAM_SLIDER_STYLE_EDJ_NAME);
1346
1347         CAM_TA_ACUM_ITEM_BEGIN("      layout_main load", 0);
1348         if (ad->layout_main == NULL) {
1349                 ad->layout_main =
1350                     cam_app_load_edj(ad->win_main, CAM_MAIN_LAYOUT_EDJ_NAME,
1351                                      "main_layout");
1352                 if (ad->layout_main == NULL) {
1353                         CAM_TA_ACUM_ITEM_END("      layout_main load", 0);
1354                         cam_critical(LOG_UI, "layout_main load failed ");
1355                         return FALSE;
1356                 }
1357
1358 #ifndef CAMERA_MACHINE_I686
1359                 evas_object_smart_callback_del(_EDJ(ad->layout_main),
1360                                                "mouse.click",
1361                                                _main_layout_click_cb);
1362
1363                 evas_object_smart_callback_add(_EDJ(ad->layout_main),
1364                                                "mouse.click",
1365                                                _main_layout_click_cb, ad);
1366
1367                 define_mouse_callback(_EDJ(ad->layout_main),
1368                                       _EDJ(ad->layout_main));
1369 #endif
1370         }
1371         CAM_TA_ACUM_ITEM_END("      layout_main load", 0);
1372
1373         cam_app_focus_guide_create(ad);
1374
1375         CAM_TA_ACUM_ITEM_BEGIN("      load_toolbar_edje", 0);
1376         if (cam_toolbar_create(ad)) {
1377                 CAM_TA_ACUM_ITEM_END("      load_toolbar_edje", 0);
1378                 cam_critical(LOG_UI, " load_toolbar_edje failed ");
1379                 return FALSE;
1380         }
1381         CAM_TA_ACUM_ITEM_END("      load_toolbar_edje", 0);
1382
1383 #ifndef DISABLE_INDICATOR
1384         CAM_TA_ACUM_ITEM_BEGIN("      cam_indicator_create", 0);
1385         if (ad->indicator_edje) {
1386                 evas_object_hide(ad->indicator_edje);
1387                 cam_indicator_destory(ad);
1388         }
1389         if (cam_indicator_create(ad)) {
1390                 CAM_TA_ACUM_ITEM_END("      cam_indicator_create", 0);
1391                 cam_critical(LOG_UI, "cam_indicator_create failed ");
1392                 return FALSE;
1393         }
1394         CAM_TA_ACUM_ITEM_END("      cam_indicator_create", 0);
1395 #endif
1396
1397         cam_app_update_quickview_icon(ad);
1398
1399         DEBUG_TRACE("END");
1400
1401         return TRUE;
1402 }
1403
1404 gboolean cam_handle_create(void *data)
1405 {
1406         CAM_TA_ACUM_ITEM_BEGIN("------cam_handle_create", 0);
1407         struct appdata *ad = (struct appdata *)data;
1408         CamAppData *camapp = NULL;
1409
1410         debug_fenter(LOG_CAM);
1411         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1412
1413         if (ad->camapp_handle && cam_handle) {
1414                 cam_handle_free(ad);
1415         }
1416
1417         camapp = (CamAppData *)malloc(sizeof(CamAppData));
1418         cam_retv_if(camapp == NULL, FALSE);
1419         memset(camapp, 0x00, sizeof(CamAppData));
1420
1421         cam_handle = camapp;
1422         ad->camapp_handle = camapp;
1423         CAM_TA_ACUM_ITEM_END("------cam_handle_create", 0);
1424
1425         return TRUE;
1426 }
1427
1428 gboolean cam_handle_free(void *data)
1429 {
1430         struct appdata *ad = (struct appdata *)data;
1431         CamAppData *camapp = NULL;
1432
1433         debug_fenter(LOG_CAM);
1434         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1435         camapp = ad->camapp_handle;
1436         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1437
1438         cam_config_save();
1439
1440         if (camapp && cam_handle) {
1441                 if (camapp->battery_ani_timer) {
1442                         ecore_timer_del(camapp->battery_ani_timer);
1443                         camapp->battery_ani_timer = NULL;
1444                 }
1445
1446                 if (camapp->filename) {
1447                         free(camapp->filename);
1448                         camapp->filename = NULL;
1449                 }
1450
1451                 if (camapp->thumbnail_name) {
1452                         free(camapp->thumbnail_name);
1453                         camapp->thumbnail_name = NULL;
1454                 }
1455
1456                 if (camapp) {
1457                         free(camapp);
1458                         camapp = NULL;
1459                 }
1460                 DEBUG_TRACE();
1461                 ad->camapp_handle = NULL;
1462                 cam_handle = NULL;
1463         }
1464
1465         return TRUE;
1466 }
1467
1468 gboolean cam_toolbar_menu_config_init(void *data, int mode) {
1469         struct appdata *ad = (struct appdata *)data;
1470         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1471         ad->toolbar_1_type = cam_config_get_int( PROP_TOOLBAR_1_TYPE_NAME, CAM_MENU_EMPTY);
1472         ad->toolbar_2_type = cam_config_get_int( PROP_TOOLBAR_2_TYPE_NAME, CAM_MENU_EMPTY);
1473         ad->toolbar_3_type = cam_config_get_int( PROP_TOOLBAR_3_TYPE_NAME, CAM_MENU_EMPTY);
1474         ad->toolbar_4_type = cam_config_get_int( PROP_TOOLBAR_4_TYPE_NAME, CAM_MENU_EMPTY);
1475         DEBUG_TRACE("ad->toolbar_1_type= %d", ad->toolbar_1_type);
1476         DEBUG_TRACE("ad->toolbar_2_type= %d", ad->toolbar_2_type);
1477         DEBUG_TRACE("ad->toolbar_3_type= %d", ad->toolbar_3_type);
1478         DEBUG_TRACE("ad->toolbar_4_type= %d", ad->toolbar_4_type);
1479
1480         return TRUE;
1481 }
1482
1483 gboolean cam_toolbar_menu_config_update(void *data)
1484 {
1485         struct appdata *ad = (struct appdata *)data;
1486         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1487
1488         int toolbar_1_type;
1489         int toolbar_2_type;
1490         int toolbar_3_type;
1491         int toolbar_4_type;
1492
1493         toolbar_1_type = cam_config_get_int( PROP_TOOLBAR_1_TYPE_NAME, CAM_MENU_EMPTY);
1494         toolbar_2_type = cam_config_get_int( PROP_TOOLBAR_2_TYPE_NAME, CAM_MENU_EMPTY);
1495         toolbar_3_type = cam_config_get_int( PROP_TOOLBAR_3_TYPE_NAME, CAM_MENU_EMPTY);
1496         toolbar_4_type = cam_config_get_int( PROP_TOOLBAR_4_TYPE_NAME, CAM_MENU_EMPTY);
1497
1498         if (toolbar_1_type != ad->toolbar_1_type)
1499                 cam_config_set_int(PROP_TOOLBAR_1_TYPE_NAME, ad->toolbar_1_type);
1500         if (toolbar_2_type != ad->toolbar_2_type)
1501                 cam_config_set_int(PROP_TOOLBAR_2_TYPE_NAME, ad->toolbar_2_type);
1502         if (toolbar_3_type != ad->toolbar_3_type)
1503                 cam_config_set_int(PROP_TOOLBAR_3_TYPE_NAME, ad->toolbar_3_type);
1504         if (toolbar_4_type != ad->toolbar_4_type)
1505                 cam_config_set_int(PROP_TOOLBAR_4_TYPE_NAME, ad->toolbar_4_type);
1506
1507         return TRUE;
1508
1509 }
1510
1511 gboolean cam_handle_init(void *data, int mode)
1512 {
1513         struct appdata *ad = data;
1514         CamAppData *camapp = NULL;
1515         int charging = 0;
1516
1517         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1518
1519         camapp = ad->camapp_handle;
1520         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1521
1522         cam_info(LOG_UI, "mode : %d ", mode);
1523         camapp->camera_mode = mode;
1524
1525         cam_info(LOG_UI, "camera_mode = %d ", camapp->camera_mode);
1526
1527         cam_config_set_int_by_type(CAM_CONFIG_TYPE_COMMON, PROP_MODE_NAME, mode);
1528
1529         cam_app_set_config_group(camapp->camera_mode);
1530
1531 #ifdef USE_CAM_STORAGE_SETTING
1532         camapp->storage = cam_config_get_int( PROP_STORAGE_NAME, CAM_STORAGE_INTERNAL);
1533 #else
1534         vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, &(camapp->storage));
1535 #endif
1536
1537         /* use shot mode as default value */
1538         camapp->recording_mode = RECMODE_DEFAULT;
1539         camapp->shooting_mode = SHOTMODE_DEFAULT;
1540
1541         camapp->af_mode = AF_DEFAULT;
1542
1543         if (camapp->camera_mode == CAM_CAMERA_MODE) {
1544                 camapp->flash = cam_config_get_int(PROP_FLASH_NAME, FLASH_DEFAULT);
1545         } else {
1546                 camapp->flash = cam_config_get_int(PROP_FLASH_NAME, REC_FLASH_DEFAULT);
1547         }
1548
1549 #ifdef GUIDE_LINE_ENALBE
1550         camapp->guideline = cam_config_get_boolean(PROP_GUIDELINE_NAME, GUIDE_LINE_DEFAULT);
1551         DEBUG_TRACE("camapp->guideline = %d" ,camapp->guideline);
1552 #endif
1553
1554         camapp->effect = EFFECT_DEFAULT;
1555
1556         if (camapp->camera_mode == CAM_CAMERA_MODE)
1557                 DEBUG_TRACE("default resolution will be got from FW API");
1558         else
1559                 camapp->resolution = cam_config_get_int(PROP_RESOLUTION_NAME, REC_RESOLUTION_DEFAULT);
1560
1561         camapp->image_quality = cam_config_get_int(PROP_IMAGE_QUALITY_NAME, QUALITY_DEFAULT);
1562         camapp->video_quality = cam_config_get_int(PROP_VIDEO_QUALITY_NAME, QUALITY_DEFAULT);
1563         camapp->audio_recording = AUDIOREC_DEFAULT;
1564         camapp->review = cam_config_get_boolean(PROP_REVIEW_NAME, FALSE);
1565
1566         camapp->battery_level = cam_utils_get_battery_level();
1567         charging = cam_utils_get_charging_status();
1568         if (charging == 1)
1569                 camapp->battery_charging = charging;
1570         else
1571                 camapp->battery_charging = 0;
1572
1573 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
1574         camapp->shutter_sound =
1575             cam_config_get_int(PROP_SHUTTER_SOUND_NAME, SHUTTER_SOUND_DEFAULT);
1576 #endif
1577         /*sound*/
1578         cam_mm_set_shutter_sound(SOUND_DEFAULT);
1579         camapp->shutter_sound = SHUTTER_SOUND_DEFAULT;  /* on */
1580
1581         /* below item had been saved in ini file */
1582         camapp->zoom_mode = 1;
1583         camapp->image_count = IMAGE_COUNT_DEFAULT;
1584         camapp->size_limit_type = CAM_MM_SIZE_LIMIT_TYPE_BYTE;
1585         camapp->size_limit = REC_SIZE_LIMIT_DEFAULT;
1586         camapp->timer = TIMER_DEFAULT;
1587         camapp->fps = FPS_DEFAULT;
1588
1589         camapp->enable_touch_af = TRUE;
1590         camapp->key_lock = FALSE;
1591
1592         /*init toolbar menu config */
1593         cam_toolbar_menu_config_init((void*)ad, mode);
1594
1595         return TRUE;
1596 }
1597
1598 gboolean cam_handle_value_set(void *data, int type, const GValue *value)
1599 {
1600         struct appdata *ad = (struct appdata *)data;
1601         CamAppData *camapp = NULL;
1602
1603         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
1604         camapp = ad->camapp_handle;
1605         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
1606
1607         cam_debug(LOG_CAM, "type : %d", type);
1608
1609         switch (type) {
1610         case PROP_MODE:
1611                 {
1612                         gint current = 0;
1613                         gint tempval = g_value_get_int(value);
1614
1615                         current = camapp->camera_mode;
1616                         if (!cam_mode_change(ad, tempval)) {
1617                                 cam_critical(LOG_CAM,
1618                                              "MODE CHANGE IS FAILED by MIDDLE WARE");
1619                                 cam_app_notice_popup(data,
1620                                                      "MODE CHANGE FAILED !!",
1621                                                      cam_app_timeout_notice_response_cb);
1622                         }
1623                 }
1624                 break;
1625
1626         case PROP_SHOT_MODE:
1627                 {
1628                         gint tempval = g_value_get_int(value);
1629                         gint cur_mode = camapp->shooting_mode;
1630
1631                         camapp->shooting_mode = tempval;
1632
1633                         if (!cam_shooting_mode_change(ad)) {
1634                                 cam_critical(LOG_UI, "shot mode set fail");
1635                                 camapp->shooting_mode = cur_mode;
1636                                 return FALSE;
1637                         }
1638                         printf(" ##### %s %d tempval = %d\n", __FUNCTION__,
1639                                __LINE__, tempval);
1640                         cam_config_set_int(PROP_SHOT_MODE_NAME, tempval);
1641                         cam_app_focus_guide_update(ad);
1642                 }
1643                 break;
1644         case PROP_REC_MODE:
1645                 {
1646                         gint tempval = g_value_get_int(value);
1647                         /* set recording mode */
1648                         camapp->recording_mode = tempval;
1649                         cam_config_set_int(PROP_REC_MODE_NAME, tempval);
1650
1651                         if (!cam_recording_mode_change(ad, tempval)) {
1652                                 cam_critical(LOG_UI, "rec mode change fail - mode[%d]", tempval);
1653                                 return FALSE;
1654                         }
1655
1656                 }
1657                 break;
1658         case PROP_RESOLUTION:
1659                 {
1660                         gint tempval = g_value_get_int(value);
1661                         /* int af_x,af_y; */
1662
1663                         DEBUG_TRACE
1664                             ("*******************************************************");
1665                         DEBUG_TRACE("value set : PROP_RESOLUTION setting");
1666                         DEBUG_TRACE(" tempval = %d ", tempval);
1667                         DEBUG_TRACE
1668                             ("CAM_RESOLUTION_W = %d ,CAM_RESOLUTION_H=%d ",
1669                              CAM_RESOLUTION_W(tempval),
1670                              CAM_RESOLUTION_H(tempval));
1671                         DEBUG_TRACE
1672                             ("*******************************************************");
1673
1674
1675                         cam_critical(LOG_FILE, "1111111111");
1676
1677                         if (!cam_app_reset_resolution(ad, CAM_RESOLUTION_W(tempval), CAM_RESOLUTION_H(tempval))) {
1678                                 cam_warning(LOG_UI, "resolution set fail");
1679                                 return FALSE;
1680                         }
1681 #ifdef GUIDE_LINE_ENALBE
1682                         settings_guideline_refresh(ad);
1683 #endif
1684                         camapp->resolution = tempval;
1685                         cam_critical(LOG_FILE, " camapp->resolution %d", camapp->resolution);
1686
1687                         if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
1688                                 cam_app_set_video_quality(ad, camapp->video_quality);
1689                                 /*  cam_mm_set_video_quality(camapp->recording_mode, camapp->video_quality); */
1690                         }
1691
1692                         if ((camapp->camera_mode == CAM_CAMERA_MODE
1693                              && camapp->shooting_mode == CAM_SINGLE_MODE)
1694                             || (camapp->camera_mode == CAM_CAMCORDER_MODE
1695                                 && camapp->recording_mode == CAM_RECORD_NORMAL)) {
1696                                 cam_debug(LOG_UI,
1697                                           "resolution saved : [%d]x[%d]",
1698                                           CAM_RESOLUTION_W(tempval),
1699                                           CAM_RESOLUTION_H(tempval));
1700                                 cam_config_set_int(PROP_RESOLUTION_NAME,
1701                                                    tempval);
1702                         }
1703                         cam_app_get_preview_offset_coordinate(ad);
1704                         ad->remained_count = cam_system_get_still_count_by_resolution(ad);
1705                 }
1706                 break;
1707         case PROP_FPS:
1708                 {               /*  fps may not set it alone */
1709                         gint tempval = g_value_get_int(value);
1710                         /* set fps */
1711                         if (!cam_mm_set_fps(tempval)) {
1712                                 cam_warning(LOG_UI, "fps set fail");
1713                                 return FALSE;
1714                         }
1715                         camapp->fps = tempval;
1716                 }
1717                 break;
1718         case PROP_EFFECT:
1719                 {
1720                         gint tempval = g_value_get_int(value);
1721                         if (!cam_mm_set_effect(tempval)) {
1722                                 cam_warning(LOG_UI, "effect set fail : %d",
1723                                             tempval);
1724                                 return FALSE;
1725                         }
1726                         camapp->effect = tempval;
1727                         cam_config_set_int(PROP_EFFECT_NAME, tempval);
1728                 }
1729                 break;
1730         case PROP_AF_MODE:
1731                 {
1732                         gint tempval = g_value_get_int(value);
1733                         gint oldval = cam_config_get_int(PROP_AF_NAME, CAM_FOCUS_AUTO);
1734
1735                         if ((tempval == CAM_FOCUS_AUTO)
1736                                    || (tempval == CAM_FOCUS_MACRO)) {
1737                                 if (!cam_mm_set_focus_mode(tempval)) {
1738                                         cam_warning(LOG_UI, "af mode set fail");
1739                                         return FALSE;
1740                                 }
1741
1742                         } else {
1743                                 cam_warning(LOG_UI, "unknow af mode : %d",
1744                                             tempval);
1745                                 return FALSE;
1746                         }
1747                         camapp->af_mode = tempval;
1748                         cam_app_focus_guide_update(ad);
1749                         if (camapp->camera_mode == CAM_CAMERA_MODE
1750                             && camapp->shooting_mode == CAM_SINGLE_MODE) {
1751                                 cam_config_set_int(PROP_AF_NAME, tempval);
1752                         }
1753                 }
1754                 break;
1755         case PROP_FLASH:
1756                 {
1757                         gint tempval = g_value_get_int(value);
1758                         if (!cam_mm_set_flash(tempval)) {
1759                                 cam_warning(LOG_UI, "flash set fail");
1760                                 return FALSE;
1761                         }
1762                         camapp->flash = tempval;
1763                         /*fix me ,why only when in camera single mode ,
1764                                 save the FLASH setting value to config file*/
1765                         if ((camapp->camera_mode == CAM_CAMERA_MODE
1766                              && camapp->shooting_mode == CAM_SINGLE_MODE)
1767                             || camapp->camera_mode == CAM_CAMCORDER_MODE) {
1768                                 cam_config_set_int(PROP_FLASH_NAME, tempval);
1769                         }
1770                 }
1771                 break;
1772         case PROP_TIMER:
1773                 {
1774                         gint tempval = g_value_get_int(value);
1775                         /*set timer */
1776                         camapp->timer = tempval;
1777                 }
1778                 break;
1779         case PROP_IMAGE_QUALITY:
1780                 {
1781                         gint tempval = g_value_get_int(value);
1782                         if (!cam_mm_set_image_enc_quality(tempval)) {
1783                                 cam_warning(LOG_UI,
1784                                             "image quality[%d] set fail",
1785                                             tempval);
1786                                 return FALSE;
1787                         }
1788                         /*set quality */
1789                         camapp->image_quality = tempval;
1790                         cam_config_set_int(PROP_IMAGE_QUALITY_NAME, tempval);
1791                 }
1792                 break;
1793         case PROP_VIDEO_QUALITY:
1794                 {
1795                         gint tempval = g_value_get_int(value);
1796                         if (!cam_app_set_video_quality(ad, tempval)) {
1797                                 cam_warning(LOG_UI,
1798                                             "video quality[%d] set fail",
1799                                             tempval);
1800                                 return FALSE;
1801                         }
1802                         /* set quality */
1803                         camapp->video_quality = tempval;
1804                         cam_config_set_int(PROP_VIDEO_QUALITY_NAME, tempval);
1805                 }
1806                 break;
1807         case PROP_AUDIO_REC:
1808                 {
1809                         gboolean tempval = g_value_get_boolean(value);
1810                         if (!cam_mm_set_audio_recording(tempval)) {
1811                                 cam_warning(LOG_UI, "audio_recording set fail");
1812                                 return FALSE;
1813                         }
1814                         camapp->audio_recording = tempval;
1815                         cam_config_set_boolean(PROP_AUDIO_REC_NAME, tempval);
1816
1817                 }
1818                 break;
1819         case PROP_AUDIO_QUALITY:
1820                 {
1821                         gint tempval = g_value_get_int(value);
1822                         /* set audio quality */
1823                         camapp->audio_quality = tempval;
1824                         cam_config_set_int(PROP_AUDIO_QUALITY_NAME, tempval);
1825                 }
1826                 break;
1827         case PROP_BATTERY_CHARG:
1828                 {
1829                                 gint tempval_charging = g_value_get_int(value);
1830
1831                                 DEBUG_TRACE("charging = %d", tempval_charging);
1832                                 camapp->battery_charging = tempval_charging;
1833                                 camapp->battery_level = cam_utils_get_battery_level();
1834                                 indicator_update_battery(ad, camapp->battery_level);
1835                 }
1836                 break;
1837         case PROP_BATTERY_LEVEL:
1838                 {
1839                         gint tempval = g_value_get_int(value);
1840                         camapp->battery_charging = cam_utils_get_charging_status();
1841                         camapp->battery_level = tempval;
1842                         indicator_update_battery(ad, camapp->battery_level);
1843
1844                 }
1845                 break;
1846         case PROP_ZOOM:
1847                 {
1848                         gint tempval = g_value_get_int(value);
1849                         if (!cam_mm_set_zoom(tempval)) {
1850                                 cam_warning(LOG_UI, "zoom set fail");
1851                                 return FALSE;
1852                         }
1853                         camapp->zoom = tempval;
1854                 }
1855                 break;
1856         case PROP_STORAGE:
1857                 {
1858                         gint tempval = g_value_get_int(value);
1859
1860                         camapp->storage = tempval;
1861                         cam_config_set_int(PROP_STORAGE_NAME, tempval);
1862                 }
1863                 break;
1864         case PROP_GUIDELINE:
1865                 {
1866                         gboolean tempval = g_value_get_boolean(value);
1867
1868                         camapp->guideline = tempval;
1869                         cam_config_set_boolean(PROP_GUIDELINE_NAME, tempval);
1870                 }
1871                 break;
1872         case PROP_REVIEW:
1873                 {
1874                         gboolean tempval = g_value_get_boolean(value);
1875                         camapp->review = tempval;
1876                         cam_config_set_boolean(PROP_REVIEW_NAME, tempval);
1877                 }
1878                 break;
1879         case PROP_IMAGE_COUNT:
1880                 {
1881                         gint tempval = g_value_get_int(value);
1882                         if (!cam_mm_set_image_count(tempval)) {
1883                                 cam_warning(LOG_UI, "image_count set fail");
1884                                 return FALSE;
1885                         }
1886                         camapp->image_count = tempval;
1887                 }
1888                 break;
1889         case PROP_SHUTTER_SOUND:
1890                 {
1891                         gint tempval = g_value_get_int(value);
1892                         camapp->shutter_sound = tempval;
1893                         cam_config_set_int(PROP_SHUTTER_SOUND_NAME, tempval);
1894                 }
1895                 break;
1896         case PROP_SIZE_LIMIT:
1897                 {
1898                         gint tempval = g_value_get_int(value);
1899                         if (!cam_app_set_size_limit
1900                             (tempval, camapp->size_limit_type)) {
1901                                 cam_warning(LOG_UI, "size_limit set fail");
1902                                 return FALSE;
1903                         }
1904                         camapp->size_limit = tempval;
1905                 }
1906                 break;
1907         case PROP_SIZE_LIMIT_TYPE:
1908                 {
1909                         gint tempval = g_value_get_int(value);
1910                         camapp->size_limit_type = tempval;
1911                 }
1912                 break;
1913         case PROP_REC_TIME:
1914                 {
1915                         guint tempval = g_value_get_uint(value);
1916                         camapp->rec_elapsed = tempval;
1917                 }
1918                 break;
1919         case PROP_REC_FILE_SIZE:
1920                 {
1921                         guint tempval = g_value_get_uint(value);
1922                         camapp->rec_filesize = tempval;
1923                 }
1924                 break;
1925         default:
1926                 cam_warning(LOG_UI, "unknow type :%d ", type);
1927                 return FALSE;
1928                 break;
1929         }
1930         /* indicator should be updated here!!! */
1931 /*      change_indicator_mode_icons(ad); */
1932         return TRUE;
1933 }
1934
1935 gboolean cam_mode_change(void *data, int to_mode)
1936 {
1937         struct appdata *ad = (struct appdata *)data;
1938         cam_retv_if(ad == NULL, FALSE);
1939         CamAppData *camapp = ad->camapp_handle;
1940         cam_retv_if(camapp == NULL, FALSE);
1941
1942         int session_type;
1943         debug_fenter(LOG_UI);
1944
1945         cam_elm_cache_flush();
1946
1947         evas_object_hide(ad->timer_icon_edje);
1948         REMOVE_TIMER(ad->timer_timer);
1949         ad->timer_activated = false;
1950         DEL_EVAS_OBJECT(ad->timer_icon_edje);
1951 #ifdef GUIDE_LINE_ENALBE
1952         DEL_EVAS_OBJECT(ad->guideline_edje);
1953         camapp->guideline = FALSE;
1954 #endif
1955         cam_app_timeout_checker_remove();
1956         /* draw to_mode icon in preview area */
1957 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
1958         if (ad->play_rec_sound != 0)
1959                 return TRUE;
1960 #endif
1961         /*cam_app_black_screen_show(ad, to_mode);*/
1962
1963         if (cam_mm_get_state() == CAMERA_STATE_CAPTURING
1964                 && (camapp->camera_mode == CAM_CAMERA_MODE)) {
1965                 cam_mm_capture_stop(true, CAM_CAMERA_MODE);
1966         }
1967
1968         /*  stop preview and destory mmfw handle */
1969         if (!cam_app_preview_stop()) {
1970                 cam_critical(LOG_MM, "cam_app_preview_stop faild");
1971                 goto MODE_CHANGE_FAILED;
1972
1973         }
1974
1975         if (!cam_mm_destory()) {
1976                 cam_critical(LOG_MM, "cam_mm_destory faild");
1977                 cam_app_notice_popup(data,
1978                                      "cam_mm_destory faild BY MIDDLE WARE",
1979                                      cam_app_timeout_notice_response_cb);
1980                 return FALSE;
1981         }
1982
1983         if (to_mode == CAM_CAMERA_MODE) {
1984                 DEBUG_TRACE("session_type :SOUND_SESSION_TYPE_SHARE");
1985                 session_type = SOUND_SESSION_TYPE_SHARE;
1986         } else {
1987                 DEBUG_TRACE("session_type :SOUND_SESSION_TYPE_EXCLUSIVE");
1988                 session_type = SOUND_SESSION_TYPE_EXCLUSIVE;
1989         }
1990         if (!cam_mm_session_init(session_type)) {
1991                 cam_critical(LOG_MM, "cam_mm_session_init faild");
1992                 goto MODE_CHANGE_FAILED;
1993
1994         }
1995         if (!cam_mm_create(CAM_DEVICE_MEGA, to_mode)) {
1996                 cam_critical(LOG_MM, "cam_mm_create failed");
1997                 goto MODE_CHANGE_FAILED;
1998
1999         }
2000         /* Idler of capture callback management. wh01.cho@samsung.com. 2010-12-15. */
2001         cam_utils_remove_idler_all(ad);
2002
2003         if (to_mode == CAM_CAMCORDER_MODE) {
2004                 ad->last_camera_zoom_mode = camapp->zoom_mode;
2005         }
2006
2007         if (!cam_handle_create(ad)) {
2008                 cam_critical(LOG_CAM, "cam_handle_create faild");
2009                 goto MODE_CHANGE_FAILED;
2010
2011         }
2012
2013         if (!cam_handle_init(ad, to_mode)) {
2014                 cam_critical(LOG_CAM, "cam_handle_init faild");
2015                 goto MODE_CHANGE_FAILED;
2016
2017         }
2018
2019         else if (to_mode == CAM_CAMERA_MODE) {
2020                 camapp->zoom_mode = ad->last_camera_zoom_mode;
2021         }
2022         if (!cam_callback_init(ad)) {
2023                 cam_critical(LOG_MM, "cam_init_mm_callback failed");
2024                 goto MODE_CHANGE_FAILED;
2025
2026         }
2027         DEBUG_TRACE("camera mode = %d", to_mode);
2028         if (!cam_app_init_attribute(ad, to_mode)) {
2029                 cam_critical(LOG_MM, "cam_app_init_attribute failed");
2030 //              goto MODE_CHANGE_FAILED;
2031         }
2032
2033         cam_app_get_preview_offset_coordinate(ad);
2034
2035         cam_continuous_af_start(ad);
2036         if (!cam_app_preview_start(ad)) {
2037                 cam_critical(LOG_MM, "cam_app_preview_start failed");
2038                 goto MODE_CHANGE_FAILED;
2039
2040         }
2041         cam_app_timeout_checker_init(ad);
2042         ResetCaps();
2043
2044         /*update toolbar shortcuts*/
2045         cam_toolbar_destroy(ad);
2046         cam_toolbar_create(ad);
2047         cam_app_update_quickview_icon((void *)ad);
2048
2049         return TRUE;
2050
2051 MODE_CHANGE_FAILED:
2052         cam_app_notice_popup(ad, "PREVIEW START FAILED !!", cam_app_timeout_notice_response_cb);
2053         return FALSE;
2054 }
2055
2056 gboolean cam_recording_mode_change(void *data, int rec_mode)
2057 {
2058         struct appdata *ad = (struct appdata *)data;
2059         CamAppData *camapp = NULL;
2060         CamDeviceType device_type = CAM_DEVICE_MEGA;
2061         GValue value = { 0 };
2062         int video_dev = 0;
2063         gboolean cam_reset = FALSE;
2064
2065         debug_fenter(LOG_CAM);
2066
2067         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2068         camapp = ad->camapp_handle;
2069         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2070
2071         cam_app_timeout_checker_remove();
2072
2073         g_value_init(&value, G_TYPE_INT);
2074
2075         cam_mm_get_video_device(&video_dev);
2076         if (((camapp->recording_mode == CAM_RECORD_SELF || camapp->recording_mode == CAM_RECORD_SELF_MMS )&& video_dev == CAM_DEVICE_MEGA)
2077             || ((camapp->recording_mode != CAM_RECORD_SELF || camapp->recording_mode == CAM_RECORD_SELF_MMS) && video_dev == CAM_DEVICE_VGA)) {
2078
2079                 /*  stop preview and destory mmfw handle */
2080                 cam_reset = TRUE;
2081                 if (!cam_app_preview_stop()) {
2082                         cam_critical(LOG_MM, "cam_app_preview_stop faild");
2083                         return FALSE;
2084                 }
2085                 if (!cam_mm_destory()) {
2086                         cam_critical(LOG_MM, "cam_mm_destory faild");
2087                         return FALSE;
2088                 }
2089                 if (camapp->recording_mode == CAM_RECORD_SELF ||camapp->recording_mode == CAM_RECORD_SELF_MMS ) {
2090                         device_type = CAM_DEVICE_VGA;
2091                 } else {
2092                         device_type = CAM_DEVICE_MEGA;
2093                 }
2094
2095                 if (!cam_mm_create(device_type, camapp->camera_mode)) {
2096                         cam_critical(LOG_MM, "cam_mm_create failed");
2097                         cam_app_notice_popup(ad, "cam_app_preview_start failed", cam_app_timeout_notice_response_cb);
2098                         return FALSE;
2099                 }
2100                 cam_mm_get_video_size( &camapp->default_preview_width, &camapp->default_preview_height);
2101                 DEBUG_TRACE("default_width = %d,default_height = %d", camapp->default_preview_width, camapp->default_preview_height);
2102
2103         }else {
2104                 if (!cam_app_preview_stop()) {
2105                         cam_critical(LOG_MM, "cam_app_preview_stop faild");
2106                         return FALSE;
2107                 }
2108         }
2109
2110         ad->camapp_handle->enable_touch_af = TRUE;
2111
2112         if(rec_mode == CAM_RECORD_SELF) {
2113
2114                 ad->camapp_handle->enable_touch_af = FALSE;
2115                 g_value_set_int(&value, FPS_SLOW);
2116                 if (!cam_handle_value_set(ad, PROP_FPS, &value)) {
2117                         cam_critical(LOG_UI, "fps set fail");
2118                         return FALSE;
2119                 }
2120
2121                 g_value_set_int(&value, CAM_RESOLUTION_VGA);
2122                 if (!cam_handle_value_set(ad, PROP_RESOLUTION, &value)) {
2123                         cam_critical(LOG_UI, "resolution set fail");
2124                         return FALSE;
2125                 }
2126
2127                 g_value_set_int(&value, REC_SIZE_LIMIT_DEFAULT);
2128                 if (!cam_handle_value_set(ad, PROP_SIZE_LIMIT, &value)) {
2129                         cam_critical(LOG_UI, "size limit set fail");
2130                         return FALSE;
2131                 }
2132
2133                 if (!cam_mm_reset_recording_motion_fps()) {
2134                         cam_critical(LOG_UI,
2135                                      "slow motion fps set fail");
2136                         return FALSE;
2137                 }
2138                 camapp->recording_mode = CAM_RECORD_SELF;
2139         } else if (rec_mode == CAM_RECORD_MMS ||rec_mode == CAM_RECORD_SELF_MMS ) {
2140                 g_value_set_int(&value, FPS_SLOW);
2141                 if (!cam_handle_value_set(ad, PROP_FPS, &value)) {
2142                         cam_critical(LOG_UI, "fps set fail");
2143                         return FALSE;
2144                 }
2145
2146                 g_value_set_int(&value, CAM_RESOLUTION_QCIF);
2147                 if (!cam_handle_value_set(ad, PROP_RESOLUTION, &value)) {
2148                         cam_critical(LOG_UI, "resolution set fail");
2149                         return FALSE;
2150                 }
2151
2152                 g_value_set_int(&value, CAM_REC_MMS_MAX_SIZE);
2153                 if (!cam_handle_value_set(ad, PROP_SIZE_LIMIT, &value)) {
2154                         cam_critical(LOG_UI, "size limit set fail");
2155                         return FALSE;
2156                 }
2157
2158                 if (!cam_mm_reset_recording_motion_fps()) {
2159                         cam_critical(LOG_UI,
2160                                      "slow motion fps set fail");
2161                         return FALSE;
2162                 }
2163                 if (rec_mode == CAM_RECORD_MMS)
2164                         camapp->recording_mode = CAM_RECORD_MMS;
2165                 else
2166                         camapp->recording_mode = CAM_RECORD_SELF_MMS;
2167
2168         } else {
2169                 int resolution_n =
2170                     cam_config_get_int(PROP_RESOLUTION_NAME,  REC_RESOLUTION_DEFAULT);
2171
2172                 g_value_set_int(&value, FPS_DEFAULT);
2173                 if (!cam_handle_value_set(ad, PROP_FPS, &value)) {
2174                         cam_critical(LOG_UI, "fps set fail");
2175                         return FALSE;
2176                 }
2177
2178                 g_value_set_int(&value, resolution_n);
2179                 if (!cam_handle_value_set(ad, PROP_RESOLUTION, &value)) {
2180                         cam_critical(LOG_UI, "resolution set fail");
2181                         return FALSE;
2182                 }
2183
2184                 g_value_set_int(&value, REC_SIZE_LIMIT_DEFAULT);
2185                 if (!cam_handle_value_set(ad, PROP_SIZE_LIMIT, &value)) {
2186                         cam_critical(LOG_UI, "size limit set fail");
2187                         return FALSE;
2188                 }
2189
2190                 if (!cam_mm_reset_recording_motion_fps()) {
2191                         cam_critical(LOG_UI,
2192                                      "slow motion fps set fail");
2193                         return FALSE;
2194                 }
2195                 camapp->recording_mode = CAM_RECORD_NORMAL;
2196
2197         }
2198         if (cam_reset) {
2199                 if (!cam_app_init_attribute(ad, camapp->camera_mode)) {
2200                         cam_critical(LOG_MM, "cam_app_init_attribute failed");
2201 //                              return FALSE;
2202                 }
2203         } else {
2204                 if (!cam_app_set_recording_mode(ad, rec_mode)) {
2205                         DEBUG_TRACE("cam_app_set_recording_mode failed");
2206 //                              return FALSE;
2207                 }
2208         }
2209
2210         cam_app_get_preview_offset_coordinate(ad);
2211
2212         if (!cam_callback_init(ad)) {
2213                 cam_critical(LOG_MM, "cam_init_mm_callback failed");
2214                 cam_app_notice_popup(ad, "PREVIEW START FAILED !!", cam_app_timeout_notice_response_cb);
2215                 return FALSE;
2216         }
2217
2218         cam_continuous_af_start(ad);
2219         if (!cam_app_preview_start(ad)) {
2220                 cam_critical(LOG_MM, "cam_app_preview_start failed");
2221                 cam_app_notice_popup(ad, "PREVIEW START FAILED !!", cam_app_timeout_notice_response_cb);
2222                 return FALSE;
2223         }
2224
2225         cam_app_timeout_checker_init(ad);
2226
2227         return TRUE;
2228
2229 }
2230
2231 static gboolean cam_app_set_capture_format_shooting_mode(int mode)
2232 {
2233         switch (mode) {
2234         case CAM_SINGLE_MODE:
2235         case CAM_SELF_MODE:
2236                 if (!cam_mm_set_capture_format(CAMERA_PIXEL_FORMAT_JPEG))
2237                         return FALSE;
2238                 break;
2239         default:
2240                 break;
2241         }
2242
2243         cam_debug(LOG_UI,
2244                   "\n################# shooting mode set return success : %d\n",
2245                   mode);
2246
2247         return TRUE;
2248 }
2249
2250 static void cam_shooting_mode_reset(void *data)
2251 {
2252         return;
2253 }
2254
2255 gboolean cam_shooting_mode_change(void *data)
2256 {
2257         struct appdata *ad = (struct appdata *)data;
2258         CamAppData *camapp = NULL;
2259         CamDeviceType device_type = CAM_DEVICE_MEGA;
2260         GValue value = { 0 };
2261         int video_dev = 0;
2262         gboolean cam_reset = FALSE;
2263
2264         debug_fenter(LOG_CAM);
2265
2266         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2267         camapp = ad->camapp_handle;
2268         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2269
2270         cam_elm_cache_flush();
2271
2272         cam_app_stop_video_stream();
2273         cam_app_timeout_checker_remove();
2274         cam_shooting_mode_reset(ad);
2275         cam_mm_get_video_device(&video_dev);
2276
2277         if ((camapp->shooting_mode == CAM_SELF_MODE && video_dev == CAM_DEVICE_MEGA)
2278             || (camapp->shooting_mode != CAM_SELF_MODE && video_dev == CAM_DEVICE_VGA)) {
2279                 /*  stop preview and destory mmfw handle */
2280                 cam_reset = TRUE;
2281                 if (!cam_app_preview_stop()) {
2282                         cam_critical(LOG_MM, "cam_app_preview_stop faild");
2283                         return FALSE;
2284                 }
2285                 if (!cam_mm_destory()) {
2286                         cam_critical(LOG_MM, "cam_mm_destory faild");
2287                         return FALSE;
2288                 }
2289                 if (camapp->shooting_mode == CAM_SELF_MODE) {
2290                         device_type = CAM_DEVICE_VGA;
2291                 } else {
2292                         device_type = CAM_DEVICE_MEGA;
2293                 }
2294                 DEBUG_TRACE("device_type = %d" ,device_type);
2295                 if (!cam_mm_create(device_type, camapp->camera_mode)) {
2296                         cam_critical(LOG_MM, "cam_mm_create failed");
2297                         cam_app_notice_popup(ad, "cam_app_preview_start faild ", cam_app_timeout_notice_response_cb);
2298                         return FALSE;
2299                 }
2300                 cam_mm_get_video_size( &camapp->default_preview_width, &camapp->default_preview_height);
2301                 DEBUG_TRACE("default_width = %d,default_height = %d", camapp->default_preview_width, camapp->default_preview_height);
2302
2303                 cam_continuous_af_start(ad);
2304         }
2305
2306         g_value_init(&value, G_TYPE_INT);
2307
2308         cam_debug(LOG_CAM, "Shooting mode = %d ", camapp->shooting_mode);
2309
2310         if (ad->shot_mode_guide_popup)
2311                 toolbar_shot_guide_popup_destory(ad);
2312
2313         switch (camapp->shooting_mode) {
2314         case CAM_SINGLE_MODE:
2315                 {
2316                         int resolution = 0, flash = 0, auto_focus = 0;
2317                         resolution = cam_config_get_int(PROP_RESOLUTION_NAME,  IMAGE_RESOLUTION_DEFAULT);
2318                         flash =
2319                             cam_config_get_int(PROP_FLASH_NAME, FLASH_DEFAULT);
2320                         auto_focus =
2321                             cam_config_get_int(PROP_AF_NAME, AF_DEFAULT);
2322                         /* set resolution */
2323                         g_value_set_int(&value, resolution);
2324                         cam_handle_value_set(ad, PROP_RESOLUTION, &value);
2325
2326                         /* set flash off */
2327                         g_value_set_int(&value, flash);
2328                         cam_handle_value_set(ad, PROP_FLASH, &value);
2329
2330                         /* set auto focus */
2331                         g_value_set_int(&value, auto_focus);
2332                         cam_handle_value_set(ad, PROP_AF_MODE, &value);
2333
2334                         /* set capture count */
2335                         g_value_set_int(&value, IMAGE_COUNT_DEFAULT);
2336                         cam_handle_value_set(ad, PROP_IMAGE_COUNT, &value);
2337                 }
2338                 break;
2339
2340         case CAM_SELF_MODE:
2341                 /* set resolution */
2342                  g_value_set_int(&value, CAM_RESOLUTION_VGA);
2343                 cam_handle_value_set(ad, PROP_RESOLUTION, &value);
2344
2345                 /* set flash off */
2346                 g_value_set_int(&value, CAM_FLASH_OFF);
2347                 cam_handle_value_set(ad, PROP_FLASH, &value);
2348
2349                 /* set auto focus */
2350                 g_value_set_int(&value, CAM_FOCUS_AUTO);
2351                 cam_handle_value_set(ad, PROP_AF_MODE, &value);
2352
2353                 /* set capture count */
2354                 g_value_set_int(&value, IMAGE_COUNT_DEFAULT);
2355                 cam_handle_value_set(ad, PROP_IMAGE_COUNT, &value);
2356                 break;
2357         default:
2358                 break;
2359         }
2360
2361         if (cam_reset) {
2362                 if (!cam_app_init_attribute(ad, camapp->camera_mode)) {
2363                         cam_critical(LOG_MM, "cam_app_init_attribute failed");
2364                 }
2365         } else {
2366                 /* cam_app_set_source_format_shooting_mode(camapp->shooting_mode); */
2367                 cam_app_set_capture_format_shooting_mode(camapp->shooting_mode);
2368         }
2369
2370         cam_app_get_preview_offset_coordinate(ad);
2371
2372         if (!cam_callback_init(ad)) {
2373                 cam_critical(LOG_MM, "cam_init_mm_callback failed");
2374                 cam_app_notice_popup(ad, "PREVIEW START FAILED !!", cam_app_timeout_notice_response_cb);
2375                 return FALSE;
2376         }
2377
2378         if (!cam_app_preview_start(ad)) {
2379                 cam_critical(LOG_MM, "cam_app_preview_start failed");
2380                 cam_app_notice_popup(ad, "PREVIEW START FAILED !!", cam_app_timeout_notice_response_cb);
2381                 return FALSE;
2382         }
2383         cam_app_timeout_checker_init(ad);
2384         return TRUE;
2385 }
2386
2387 gboolean __cam_single_shot_reg_file(char *file_path)
2388 {
2389         GError *error = NULL;
2390
2391         if (file_path) {
2392                 DEBUG_TRACE("register file : %s", file_path);
2393
2394                 if (!cam_file_register(file_path, &error)) {
2395                         cam_critical(LOG_FILE, "cam_file_register fail");
2396                         if (error != NULL) {
2397                                 if (error->message != NULL) {
2398                                         cam_critical(LOG_FILE,
2399                                                      "cam_file_register error [%s]",
2400                                                  error->message);
2401                                 } else {
2402                                         cam_critical(LOG_FILE,
2403                                                      "cam_file_register error but error message is NULL");
2404                                 }
2405                                 g_error_free(error);
2406                                 error = NULL;
2407                         }
2408                 }
2409         } else {
2410                 cam_warning(LOG_FILE, " file path is NULL...");
2411
2412                 return FALSE;
2413         }
2414
2415         return TRUE;
2416 }
2417
2418 static void cam_app_timer_update_count(void *data)
2419 {
2420         struct appdata *ad = (struct appdata *)data;
2421         char count_string[3] = "";
2422
2423         cam_retm_if(ad == NULL, "appdata is NULL");
2424
2425         cam_debug(LOG_UI, "timer count ... [ %d ]", ad->timer_count);
2426
2427         if (ad->timer_icon_edje == NULL) {
2428                 switch (ad->target_direction) {
2429                 case CAM_TARGET_DIRECTION_LANDSCAPE:
2430                 case CAM_TARGET_DIRECTION_LANDSCAPE_INVERSE:
2431                         ad->timer_icon_edje = cam_app_load_edj(ad->win_main, CAM_UTILS_EDJ_NAME, "timer_icon_landscape");
2432                         break;
2433                 case CAM_TARGET_DIRECTION_PORTRAIT:
2434                 case CAM_TARGET_DIRECTION_PORTRAIT_INVERSE:
2435                         ad->timer_icon_edje = cam_app_load_edj(ad->win_main, CAM_UTILS_EDJ_NAME, "timer_icon_portrait");
2436                         break;
2437                 default:
2438                         DEBUG_TRACE("Invalid direction type!!!");
2439                 }
2440
2441                 cam_ret_if(ad->timer_icon_edje == NULL);
2442         }
2443
2444         snprintf(count_string, sizeof(count_string), "%d", ad->timer_count);
2445
2446         edje_object_part_text_set(_EDJ(ad->timer_icon_edje), "text", count_string);
2447
2448         evas_object_show(ad->timer_icon_edje);
2449
2450         return;
2451 }
2452
2453 static Eina_Bool cam_app_timer_cb(void *data)
2454 {
2455         struct appdata *ad = (struct appdata *)data;
2456         cam_retv_if(ad == NULL, ECORE_CALLBACK_CANCEL);
2457
2458         CamAppData *camapp = NULL;
2459
2460         camapp = ad->camapp_handle;
2461         if (camapp == NULL) {
2462                 cam_critical(LOG_UI, "camapp_handle is NULL");
2463                 ad->timer_timer = NULL;
2464                 return ECORE_CALLBACK_CANCEL;
2465         }
2466
2467         ad->timer_count = ad->timer_count - 1;
2468
2469         if (ad->timer_count > 0) {
2470                 cam_debug(LOG_UI, "timer continue ... ");
2471                 cam_app_timer_update_count(ad);
2472                 if (camapp->shutter_sound != CAM_SETTINGS_SOUND_OFF)
2473                         cam_sound_play(CAM_SOUND_EFFECT_TICK, ad);
2474                 return ECORE_CALLBACK_RENEW;
2475         } else {
2476                 cam_debug(LOG_UI, "timer terminated ...");
2477
2478                 ad->timer_activated = false;
2479
2480                 if (ad->timer_icon_edje != NULL) {
2481                         evas_object_del(ad->timer_icon_edje);
2482                         ad->timer_icon_edje = NULL;
2483                 }
2484
2485                 cam_toolbar_update(ad);
2486
2487                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
2488                         cam_set_orient_value(ad);
2489                         cam_image_capture_start(ad);
2490                 } else {
2491                         cam_video_record_start(ad);
2492                 }
2493
2494                 ad->timer_timer = NULL;
2495                 return ECORE_CALLBACK_CANCEL;
2496         }
2497 }
2498
2499 static void cam_app_start_timer(void *data)
2500 {
2501         struct appdata *ad = (struct appdata *)data;
2502
2503         cam_retm_if(ad == NULL, "appdata is NULL");
2504
2505         ad->timer_activated = true;
2506
2507         switch (ad->camapp_handle->timer) {
2508         case CAM_SETTINGS_TIMER_2SEC:
2509                 ad->timer_count = 2;
2510                 break;
2511         case CAM_SETTINGS_TIMER_5SEC:
2512                 ad->timer_count = 5;
2513                 break;
2514         case CAM_SETTINGS_TIMER_10SEC:
2515                 ad->timer_count = 10;
2516                 break;
2517
2518         case CAM_SETTINGS_TIMER_OFF:
2519         default:
2520                 CAM_UI_LOG("can not reach here");
2521                 return;
2522         }
2523
2524         cam_toolbar_update(ad);
2525
2526         cam_app_timer_update_count(ad);
2527
2528         if (ad->timer_timer != NULL) {
2529                 ecore_timer_del(ad->timer_timer);
2530                 ad->timer_timer = NULL;
2531         }
2532
2533         ad->timer_timer = ecore_timer_add(1.0, cam_app_timer_cb, ad);
2534 }
2535
2536 void cam_app_cancel_timer(void *data)
2537 {
2538         struct appdata *ad = (struct appdata *)data;
2539
2540         ad->timer_activated = FALSE;
2541
2542         REMOVE_TIMER(ad->timer_timer);
2543         DEL_EVAS_OBJECT(ad->timer_icon_edje);
2544
2545         cam_toolbar_update(ad);
2546 }
2547
2548 static void _popup_cancel_cb(void *data, Evas_Object *obj, void *event_info)
2549 {
2550         /* cam_app_free_blocking_popup(); */
2551         Evas_Object *notify = (Evas_Object *)data;
2552         cam_popup_remove(notify);
2553         /* evas_object_del(notify); */
2554 }
2555
2556 gboolean cam_image_capture_start(void *data)
2557 {
2558         struct appdata *ad = (struct appdata *)data;
2559         CamAppData *camapp = NULL;
2560         gint64 remain = 0;
2561         gboolean ret = TRUE;
2562
2563         debug_fenter(LOG_UI);
2564
2565         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2566         camapp = ad->camapp_handle;
2567         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2568         CAM_TA_ACUM_ITEM_BEGIN("    cam_image_capture_start", 0);
2569
2570         remain = cam_system_get_still_count_by_resolution(ad);
2571
2572         cam_set_orient_value(ad);
2573
2574         switch (camapp->shooting_mode) {
2575         case CAM_SELF_MODE:
2576         case CAM_SINGLE_MODE:
2577                 ret = cam_mm_capture_start(camapp->capture_cb, camapp->capture_completed_cb, (void*)ad);
2578 #ifdef USE_CAMERA_APP_SHUTTER_SOUND
2579                 cam_sound_play(camapp->shutter_sound, ad);
2580 #ifdef ENABLE_CAPTURE_ANIMATION
2581                 cam_app_shutter_screen_show(ad);
2582 #endif
2583
2584 #endif
2585                 break;
2586         default:
2587                 ret = cam_mm_capture_start(camapp->capture_cb, camapp->capture_completed_cb, (void*)ad); /*capture on recoring */
2588                 break;
2589         }
2590
2591         CAM_TA_ACUM_ITEM_END("    cam_image_capture_start", 0);
2592         CAM_TA_ACUM_ITEM_BEGIN("    capture_start to capturecallback", 0);
2593         return ret;
2594 }
2595
2596 static gboolean cam_image_capture_stop(void *data)
2597 {
2598         struct appdata *ad = (struct appdata *)data;
2599         CamAppData *camapp = NULL;
2600
2601         debug_fenter(LOG_UI);
2602         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2603         camapp = ad->camapp_handle;
2604         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2605
2606         return TRUE;
2607 }
2608
2609 Eina_Bool cam_image_capture_handle_idler(void *itm)
2610 {
2611         CamIdlerItem *item = (CamIdlerItem *) itm;
2612         struct appdata *ad = NULL;
2613         cam_retvm_if(!item, ECORE_CALLBACK_CANCEL, "CamIdlerItem is NULL");
2614
2615         ad = (struct appdata *)item->data;
2616         cam_retvm_if(!ad, ECORE_CALLBACK_CANCEL, "appdata is NULL");
2617
2618         cam_info(LOG_UI, "call idler[ %p] ", item->idler);
2619         ad->capture_cb_list = g_list_remove(ad->capture_cb_list, item->idler);
2620         if (item->idler) {
2621                 ecore_idler_del(item->idler);
2622                 item->idler = NULL;
2623         }
2624         free(item);
2625         item = NULL;
2626
2627 #ifdef ENABLE_CAPTURE_ANIMATION
2628         __cam_save_captured_file(ad);
2629 #endif
2630
2631         return cam_image_capture_handle(ad);
2632 }
2633 Eina_Bool cam_capture_on_recording_handle(void *data)
2634 {
2635         struct appdata *ad = (struct appdata *)data;
2636         cam_retvm_if(ad == NULL, ECORE_CALLBACK_CANCEL, "appdata is NULL");
2637         CamAppData *camapp = NULL;
2638         camapp = ad->camapp_handle;
2639         cam_retvm_if(camapp == NULL, ECORE_CALLBACK_CANCEL,
2640                      "camapp_handle is NULL");
2641         gboolean preview_skip = FALSE;
2642         char *str = NULL;
2643         char popup_str[256] = { 0 };
2644
2645
2646         if (camapp->filename) {
2647 #ifdef USE_FILE_REG_THREAD
2648                 cam_debug(LOG_SYS,
2649                           "#########camapp->filename=%s",
2650                           camapp->filename);
2651                 CAM_TA_ACUM_ITEM_BEGIN
2652                     ("    send signal to register thread",
2653                      0);
2654                 g_queue_push_tail(ad->file_reg_queue,
2655                                   strdup
2656                                   (camapp->filename));
2657                 pthread_cond_signal(&ad->file_reg_cond);
2658                 CAM_TA_ACUM_ITEM_END("    send signal to register thread", 0);
2659 #else
2660                 __cam_single_shot_reg_file(camapp->filename);
2661 #endif
2662         } else {
2663                 cam_app_notice_popup(ad,
2664                      "Your storage have trouble ",
2665                         cam_app_popup_response_cb);
2666         }
2667         if (!cam_mm_capture_stop (preview_skip, CAM_CAMERA_MODE)) {
2668                 cam_critical(LOG_MM, " cam_mm_capture_stop error ");
2669         }
2670         str = strrchr(camapp->filename, '/');
2671         snprintf(popup_str, sizeof(popup_str), "%s %s", (str+1), _("IDS_CAM_POP_SAVED"));
2672         cam_app_snapshot_popup(ad, popup_str, cam_app_snapshot_popup_response_cb);
2673
2674         return ECORE_CALLBACK_CANCEL;
2675 }
2676
2677 Eina_Bool cam_image_capture_handle(void *data)
2678 {
2679         struct appdata *ad = (struct appdata *)data;
2680         CamAppData *camapp = NULL;
2681 /*      gboolean last_capture = FALSE; */
2682         gboolean bClosedEyesFoundFlag = FALSE;
2683         gboolean preview_skip = FALSE;
2684
2685         debug_fenter(LOG_UI);
2686
2687         cam_retvm_if(ad == NULL, ECORE_CALLBACK_CANCEL, "appdata is NULL");
2688         camapp = ad->camapp_handle;
2689         cam_retvm_if(camapp == NULL, ECORE_CALLBACK_CANCEL,
2690                      "camapp_handle is NULL");
2691
2692         CAM_TA_ACUM_ITEM_END("    captured message to cam_image_capture_handle",
2693                              0);
2694         CAM_TA_ACUM_ITEM_BEGIN("    cam_image_capture_handle", 0);
2695
2696         switch (camapp->shooting_mode) {
2697         case CAM_SINGLE_MODE:
2698         case CAM_SELF_MODE:
2699
2700                 cam_app_destroy_progressbar(ad);
2701
2702                 if (!bClosedEyesFoundFlag) {
2703                         if (camapp->review) {
2704                                 if (camapp->filename) {
2705                                         __cam_single_shot_reg_file
2706                                             (camapp->filename);
2707                                         /* run media browser. */
2708                                         cam_app_black_screen_show(ad, -1);      /* after capture , to hide preview screen , The hide is in preview_start */
2709                                 } else {
2710                                         cam_app_notice_popup(ad,
2711                                                              "Your storage have trouble ",
2712                                                              cam_app_popup_response_cb);
2713                                 }
2714                                 if (!cam_mm_capture_stop(TRUE, camapp->camera_mode)) {
2715                                         cam_critical(LOG_MM, "cam_mm_capture_stop error ");
2716                                 }
2717                                 /* del mouse down event - image viewer bug */
2718                                 cam_app_mouse_event_deinit(ad);
2719                                 if (!cam_app_run_image_viewer_ug
2720                                     (ad, camapp->filename)) {
2721                                         cam_app_mouse_event_init(ad);
2722                                         return ECORE_CALLBACK_CANCEL;
2723                                 }
2724                         } else {
2725                                 if (camapp->filename) {
2726 #ifdef USE_FILE_REG_THREAD
2727                                         cam_debug(LOG_SYS,
2728                                                   "#########camapp->filename=%s",
2729                                                   camapp->filename);
2730                                         CAM_TA_ACUM_ITEM_BEGIN
2731                                             ("    send signal to register thread",
2732                                              0);
2733                                         g_queue_push_tail(ad->file_reg_queue,
2734                                                           strdup
2735                                                           (camapp->filename));
2736                                         pthread_cond_signal(&ad->file_reg_cond);
2737                                         CAM_TA_ACUM_ITEM_END("    send signal to register thread", 0);
2738                                         cam_app_update_thumbnail();
2739
2740 #else
2741                                         __cam_single_shot_reg_file(camapp->filename);
2742 #endif
2743                                 } else {
2744                                         cam_app_notice_popup(ad,
2745                                                              "Your storage have trouble ",
2746                                                              cam_app_popup_response_cb);
2747                                 }
2748
2749                                 if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
2750                                         if(!((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "gallery") == 0))) {
2751                                                         preview_skip = TRUE;
2752                                         }
2753                                 }
2754
2755                                 if (!cam_mm_capture_stop (preview_skip, camapp->camera_mode)) {
2756                                         cam_critical(LOG_MM,"cam_mm_capture_stop error ");
2757                                 }
2758                                 CAM_TA_ACUM_ITEM_BEGIN
2759                                     ("    capture stop to preview", 0);
2760
2761                                 if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
2762                                         if (ad->appcore_state == CAM_APPCORE_PAUSE_STATE) {
2763                                                 cam_app_exit(ad);
2764                                                 return ECORE_CALLBACK_CANCEL;
2765                                         }
2766                                         /* view image select page */
2767                                         if(!((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "gallery") == 0))) {
2768                                                 cam_app_mouse_event_deinit(ad);
2769                                                 if (!cam_app_run_image_viewer_ug(ad, camapp->filename)) {
2770                                                         cam_app_mouse_event_init(ad);
2771                                                         return ECORE_CALLBACK_CANCEL;
2772                                                 }
2773                                         }
2774                                 }
2775
2776                         }
2777                 }
2778                 cam_app_toggle_indicator(ad, ad->toolbar_hided);
2779                 cam_app_toggle_toolbar(ad, ad->toolbar_hided);
2780                 cam_app_get_preview_offset_coordinate(ad);
2781
2782                 break;
2783
2784         default:
2785                 cam_debug(LOG_UI, " Not matched shooting mode [%d]",
2786                           camapp->shooting_mode);
2787                 break;
2788         }
2789         ad->remained_count--;
2790         CAM_TA_ACUM_ITEM_END("    cam_image_capture_handle", 0);
2791
2792         return ECORE_CALLBACK_CANCEL;
2793 }
2794
2795 gboolean cam_camera_touch_af_press(void *data)
2796 {
2797         struct appdata *ad = (struct appdata *)data;
2798         CamAppData *camapp = NULL;
2799         debug_fenter(LOG_UI);
2800         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2801         camapp = ad->camapp_handle;
2802         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2803         camapp->focus_mode = 0;
2804         if (ad->af_outside == TRUE) {
2805                 DEBUG_TRACE("########## out if af area !!");
2806                 return TRUE;
2807         }
2808         if (CAM_CAMERA_MODE == camapp->camera_mode) {
2809                 camapp->focus_mode = CAM_FOCUS_MODE_TOUCH_AUTO;
2810
2811         } else {
2812                 camapp->focus_mode = CAM_FOCUS_MODE_CONTINUOUS;
2813         }
2814
2815         cam_app_draw_af_box(ad);
2816         evas_object_show(ad->focus_edje);
2817         cam_ui_effect_utils_set_zoom_effect(ad->focus_edje,
2818                                                 CAM_FOCUS_EDJE_ZOOM_EFFECT_END_RATE,
2819                                                 CAM_FOCUS_EDJE_ZOOM_EFFECT_START_RATE,
2820                                                 CAM_FOCUS_EDJE_ZOOM_EFFECT_DURATION);
2821
2822         if (!ad->camapp_handle->key_lock) {
2823                 ad->camapp_handle->key_lock = TRUE;
2824                 if (!cam_camera_key_half_press(ad)) {
2825                         DEBUG_TRACE("cam_camera_key_half_press failed");
2826                         return FALSE;
2827                 }
2828                 ad->camapp_handle->key_lock = FALSE;
2829         }
2830
2831         return TRUE;
2832 }
2833
2834 gboolean cam_camera_key_half_press(void *data)
2835 {
2836         struct appdata *ad = (struct appdata *)data;
2837         CamAppData *camapp = NULL;
2838
2839         debug_fenter(LOG_UI);
2840         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2841         camapp = ad->camapp_handle;
2842         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2843
2844         REMOVE_TIMER(ad->toolbar_toggle_timer);
2845 #ifndef CAMERA_MACHINE_I686
2846         if (camapp->camera_mode == CAM_CAMERA_MODE
2847             && camapp->shooting_mode != CAM_SELF_MODE)
2848 #else
2849         if (camapp->camera_mode == CAM_CAMERA_MODE
2850             && camapp->shooting_mode != CAM_SELF_MODE
2851                 && TRUE)
2852 #endif
2853         {
2854                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
2855                         camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
2856                         cam_app_focus_guide_update(ad);
2857                 }
2858                 if (!cam_mm_set_af_area(ad->af_x, ad->af_y, ad->camera_focus_w, ad->camera_focus_h)) {
2859                         DEBUG_TRACE("cam_mm_set_af_area failed");
2860                         return FALSE;
2861                 }
2862                 DEBUG_TRACE("focus mode = %d", camapp->focus_mode);
2863                 if (!cam_mm_start_focusing(camapp->focus_mode)) {
2864                         cam_critical(LOG_MM, " cam_mm_start_focusing error " );
2865                 }
2866
2867         }
2868
2869         return TRUE;
2870 }
2871
2872 gboolean cam_camera_key_half_release(void *data)
2873 {
2874         struct appdata *ad = (struct appdata *)data;
2875         CamAppData *camapp = NULL;
2876
2877         debug_fenter(LOG_UI);
2878
2879         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2880         camapp = ad->camapp_handle;
2881         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2882 #ifndef CAMERA_MACHINE_I686
2883         if (camapp->camera_mode == CAM_CAMERA_MODE
2884             && camapp->shooting_mode != CAM_SELF_MODE)
2885 #else
2886         if (camapp->camera_mode == CAM_CAMERA_MODE
2887             && camapp->shooting_mode != CAM_SELF_MODE
2888                 && TRUE)
2889 #endif
2890         {
2891                 camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
2892                 cam_app_focus_guide_update(ad);
2893         }
2894
2895         return TRUE;
2896 }
2897
2898 gboolean cam_camera_key_press(void *data)
2899 {
2900         struct appdata *ad = (struct appdata *)data;
2901         CamAppData *camapp = NULL;
2902         int state = 0;
2903
2904         debug_fenter(LOG_UI);
2905
2906         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2907         if (ad->is_rotating)
2908                 return FALSE;/*note: now is rotating*/
2909         camapp = ad->camapp_handle;
2910         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
2911         CAM_TA_ACUM_ITEM_BEGIN("  cam_camera_key_press", 0);
2912
2913         if (camapp->camera_mode == CAM_CAMERA_MODE) {
2914                 state = cam_mm_get_state();
2915                 cam_debug(LOG_UI, " state = %d", state);
2916                 switch (state) {
2917                 case CAMERA_STATE_PREVIEW:
2918                 case CAMERA_STATE_CAPTURED:
2919                         cam_app_toggle_indicator(ad, TRUE);
2920                         cam_app_toggle_toolbar(ad, TRUE);
2921                         if (ad->timer_activated) {
2922                                 CAM_UI_LOG("timer activated!");
2923                         } else if (camapp->timer >
2924                                    CAM_SETTINGS_TIMER_OFF) {
2925                                 CAM_UI_LOG("timer start");
2926                                 cam_app_start_timer(ad);
2927                         } else if (!cam_image_capture_start(ad)) {
2928                                 return FALSE;
2929                         }
2930
2931                         break;
2932                 case CAMERA_STATE_CAPTURING:
2933                         cam_debug(LOG_UI, "capturing state");
2934                         return TRUE;
2935                         break;
2936                 case CAMERA_STATE_NONE:
2937                 case CAMERA_STATE_CREATED:
2938                         return FALSE;
2939                         break;
2940                 default:
2941                         return FALSE;
2942                         break;
2943
2944                 }
2945         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
2946                 state = cam_mm_get_state();
2947                 cam_debug(LOG_UI, " state = %d", state);
2948                 switch (state) {
2949                 case RECORDER_STATE_READY:
2950                         {
2951                                 if (ad->timer_activated) {
2952                                         CAM_UI_LOG("timer activated!");
2953                                 } else if (camapp->timer >
2954                                            CAM_SETTINGS_TIMER_OFF) {
2955                                         CAM_UI_LOG("timer start");
2956                                         cam_app_start_timer(ad);
2957                                 } else if (!cam_video_record_start(ad)) {
2958                                         return FALSE;
2959                                 }
2960                         }
2961                         break;
2962                 case RECORDER_STATE_RECORDING:
2963 #if 1
2964                         camapp->rec_stop_type = CAM_REC_STOP_NORMAL;
2965                         if (!cam_video_record_stop(ad)) {
2966                                 return FALSE;
2967                         }
2968                         return FALSE;
2969 #endif
2970                         break;
2971                 case RECORDER_STATE_NONE:
2972                 case RECORDER_STATE_CREATED:
2973                 case RECORDER_STATE_PAUSED:
2974                         return FALSE;
2975                         break;
2976                 default:
2977                         return FALSE;
2978                         break;
2979
2980                 }
2981         } else {
2982                 cam_critical(LOG_MM, "Unknow camera mode");
2983                 return FALSE;
2984         }
2985         CAM_TA_ACUM_ITEM_END("  cam_camera_key_press", 0);
2986         return TRUE;
2987 }
2988
2989 gboolean cam_camera_key_release(void *data)
2990 {
2991         struct appdata *ad = (struct appdata *)data;
2992         CamAppData *camapp = NULL;
2993         int state = 0;
2994
2995         debug_fenter(LOG_UI);
2996
2997         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
2998         camapp = ad->camapp_handle;
2999         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
3000
3001         if (camapp->camera_mode == CAM_CAMERA_MODE) {
3002
3003                 state = cam_mm_get_state();
3004                 cam_debug(LOG_UI, " state = %d", state);
3005                 switch (state) {
3006                 case CAMERA_STATE_CAPTURING:
3007                         if (!cam_image_capture_stop(ad)) {
3008                                 return FALSE;
3009                         }
3010                         return TRUE;
3011                         break;
3012                 case CAMERA_STATE_PREVIEW:
3013                 case CAMERA_STATE_CREATED:
3014                 case CAMERA_STATE_NONE:
3015                 case CAMERA_STATE_CAPTURED:
3016                         return FALSE;
3017                         break;
3018                 default:
3019                         return FALSE;
3020                         break;
3021
3022                 }
3023         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
3024 #if 0
3025                 state = cam_mm_get_state();
3026                 switch (state) {
3027                 case MM_CAMCORDER_STATE_PREPARE:
3028                         if (!cam_video_record_start(ad)) {
3029                                 return FALSE;
3030                         }
3031                         break;
3032                 case MM_CAMCORDER_STATE_RECORDING:
3033                         if (!cam_video_record_stop(ad)) {
3034                                 return FALSE;
3035                         }
3036                         return FALSE;
3037                         break;
3038                 case MM_CAMCORDER_STATE_NONE:
3039                 case MM_CAMCORDER_STATE_NULL:
3040                 case MM_CAMCORDER_STATE_READY:
3041                 case MM_CAMCORDER_STATE_CAPTURING:
3042                 case MM_CAMCORDER_STATE_PAUSED:
3043                         return FALSE;
3044                         break;
3045                 default:
3046                         return FALSE;
3047                         break;
3048
3049                 }
3050 #endif
3051         } else {
3052                 cam_critical(LOG_MM, "Unknow camera mode");
3053                 return FALSE;
3054         }
3055
3056         return TRUE;
3057 }
3058
3059 Eina_Bool cam_continuous_af_start(void *data)
3060 {
3061
3062         struct appdata *ad = (struct appdata *)data;
3063         cam_retvm_if(ad == NULL, ECORE_CALLBACK_CANCEL, "appdata is NULL");
3064
3065         CamAppData *camapp = NULL;
3066         camapp = ad->camapp_handle;
3067         cam_retvm_if(camapp == NULL, ECORE_CALLBACK_CANCEL, "camapp_handle is NULL");
3068
3069         DEBUG_TRACE("cam_continuous_af_start");
3070
3071         /* init */
3072         ad->af_x = (ad->win_width / 2) - ad->preview_offset_x;
3073         ad->af_y = (ad->win_height / 2) - ad->preview_offset_y;
3074
3075         ad->af_x = (ad->af_x * ad->camfw_video_width) / ad->preview_w;
3076         ad->af_y = (ad->af_y * ad->camfw_video_height) / ad->preview_h;
3077         /* init */
3078         ad->touch_lcd_x = (ad->win_height / 2);
3079         ad->touch_lcd_y = (ad->win_width / 2);
3080
3081         cam_app_draw_af_box(ad);
3082         camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
3083         cam_app_focus_guide_update(ad);
3084
3085         evas_object_show(ad->focus_edje);
3086
3087         camapp->focus_mode = CAM_FOCUS_MODE_CONTINUOUS;
3088
3089         /* cam_mm_set_af_area include init focusing */
3090         DEBUG_TRACE("start continuous AF");
3091         if (cam_mm_set_af_area(ad->af_x, ad->af_y, ad->camera_focus_w, ad->camera_focus_h)) {
3092                 DEBUG_TRACE("cam_mm_set_af_area success!");
3093                 /*focus guide update*/
3094         } else {
3095                 DEBUG_TRACE("cam_mm_set_af_area error!");
3096         }
3097         if (!cam_mm_start_focusing(camapp->focus_mode)) {
3098                 cam_critical(LOG_MM, "cam_mm_start_focusing error");
3099         }
3100         return ECORE_CALLBACK_CANCEL;
3101 }
3102
3103 Eina_Bool cam_volume_key_press(void *data)
3104 {
3105         struct appdata *ad = (struct appdata *)data;
3106         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3107
3108         CamAppData *camapp = NULL;
3109         camapp = ad->camapp_handle;
3110         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
3111
3112         if (ad->cancel_key_press == TRUE)
3113                 return ECORE_CALLBACK_CANCEL;
3114
3115         int state = 0;
3116         gboolean up_key = ad->up_key;
3117         debug_fenter(LOG_UI);
3118
3119         state = cam_mm_get_state();
3120         cam_debug(LOG_UI, " state = %d", state);
3121         if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
3122                 switch (state) {
3123                 case RECORDER_STATE_RECORDING:
3124                 case RECORDER_STATE_PAUSED:
3125                 case RECORDER_STATE_READY:
3126                         {
3127                                 if (!camapp->zoom_lock) {
3128                                         zoom_in(ad, up_key);
3129                                 }
3130                         }
3131                         break;
3132                 case RECORDER_STATE_NONE:
3133                 case RECORDER_STATE_CREATED:
3134                         break;
3135                 default:
3136                         break;
3137                 }
3138         } else if(camapp->camera_mode == CAM_CAMERA_MODE) {
3139                 switch (state) {
3140                 case CAMERA_STATE_PREVIEW:
3141                 case CAMERA_STATE_CAPTURED:
3142                         {
3143                                 if (!camapp->zoom_lock) {
3144                                         zoom_in(ad, up_key);
3145                                 }
3146                         }
3147                         break;
3148                 case CAMERA_STATE_NONE:
3149                 case CAMERA_STATE_CREATED:
3150                 case CAMERA_STATE_CAPTURING:
3151                         break;
3152                 default:
3153                         break;
3154                 }
3155
3156         }
3157
3158         return ECORE_CALLBACK_RENEW;
3159 }
3160
3161 static gboolean cam_power_key_press(void *data)
3162 {
3163         struct appdata *ad = (struct appdata *)data;
3164         CamAppData *camapp = NULL;
3165
3166         power_lock_state(POWER_STATE_SCREEN_OFF, 0);
3167
3168         debug_fenter(LOG_UI);
3169
3170         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3171         camapp = ad->camapp_handle;
3172         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
3173
3174         if (ad->mm_state < CAMERA_STATE_PREVIEW) {
3175                 goto lock_and_exit;
3176         } else if (ad->mm_state == CAMERA_STATE_PREVIEW) {
3177                 goto lock_and_exit;
3178         } else if (ad->mm_state > CAMERA_STATE_PREVIEW) {
3179                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
3180                         DEBUG_TRACE("camera mode");
3181                 } else {
3182                         camapp->rec_stop_type = CAM_REC_STOP_POWER_KEY;
3183                         if (!cam_video_record_stop(ad)) {
3184                                 DEBUG_TRACE("record stop fail");
3185                         }
3186                 }
3187         }
3188         return TRUE;
3189
3190  lock_and_exit:
3191         power_unlock_state(POWER_STATE_SCREEN_OFF);
3192
3193         return TRUE;
3194 }
3195 #if 0
3196 static gboolean __cam_end_key_grab_init(void *data)
3197 {
3198         struct appdata *ad = (struct appdata *)data;
3199         Ecore_X_Display *disp = NULL;
3200
3201         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3202         cam_retvm_if(ad->main_xid <= 0, FALSE, "main_xid <= 0");
3203
3204         disp = ecore_x_display_get();
3205         cam_retvm_if(disp == NULL, FALSE, "ecore_x_display_get fail");
3206
3207         if (utilx_grab_key(disp, ad->main_xid, KEY_END, SHARED_GRAB) == -1) {
3208                 cam_critical(LOG_SYS, "%s key grap fail", KEY_END);
3209         }
3210
3211         return TRUE;
3212 }
3213 #endif
3214 gboolean cam_key_grab_init(void *data)
3215 {
3216         struct appdata *ad = (struct appdata *)data;
3217         Ecore_X_Display *disp = NULL;
3218
3219         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3220         cam_retvm_if(ad->main_xid <= 0, FALSE, "main_xid <= 0");
3221         int success = 0;
3222         int ret = TRUE;
3223
3224         if (ad->isGrabed)
3225                 return TRUE;
3226
3227         DEBUG_TRACE("key_grab_init############################");
3228
3229         ad->cancel_key_press = FALSE;
3230
3231         disp = ecore_x_display_get();
3232         cam_retvm_if(disp == NULL, FALSE, "ecore_x_display_get fail");
3233
3234         /* volume key */
3235         if (utilx_grab_key(disp, ad->main_xid, KEY_VOLUMEUP, TOP_POSITION_GRAB) != success) {
3236                 cam_critical(LOG_SYS, "%s key grap fail", KEY_VOLUMEUP);
3237                 ret = FALSE;
3238         }
3239         if (utilx_grab_key(disp, ad->main_xid, KEY_VOLUMEDOWN, TOP_POSITION_GRAB) != success) {
3240                 cam_critical(LOG_SYS, "%s key grap fail", KEY_VOLUMEDOWN);
3241                 ret = FALSE;
3242         }
3243         /* camera key */
3244         if (utilx_grab_key(disp, ad->main_xid, KEY_CAMERA, TOP_POSITION_GRAB)  != success) {
3245                 cam_critical(LOG_SYS, "%s key grap fail", KEY_CAMERA);
3246                 ret = FALSE;
3247         }
3248         if (utilx_grab_key(disp, ad->main_xid, KEY_CONFIG, TOP_POSITION_GRAB)  != success) {
3249                 cam_critical(LOG_SYS, "%s key grap fail", KEY_CONFIG);
3250                 ret = FALSE;
3251         }
3252         /* power key */
3253         if (utilx_grab_key(disp, ad->main_xid, KEY_POWER, SHARED_GRAB) != success) {
3254                 cam_critical(LOG_SYS, "%s key grap fail", KEY_POWER);
3255                 ret = FALSE;
3256         }
3257
3258         /* etc */
3259         if (utilx_grab_key(disp, ad->main_xid, KEY_SEND, SHARED_GRAB) != success) {
3260                 cam_critical(LOG_SYS, "%s key grap fail", KEY_SEND);
3261                 ret = FALSE;
3262         }
3263         if (utilx_grab_key(disp, ad->main_xid, KEY_END, SHARED_GRAB) != success) {
3264                 cam_critical(LOG_SYS, "%s key grap fail", KEY_END);
3265                 ret = FALSE;
3266         }
3267
3268         ad->isGrabed = TRUE;
3269         return ret;
3270 }
3271
3272 gboolean cam_key_grab_deinit(void *data)
3273 {
3274         struct appdata *ad = (struct appdata *)data;
3275         Ecore_X_Display *disp = NULL;
3276         int success = 0;
3277         int ret = TRUE;
3278
3279         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3280         cam_retvm_if(ad->main_xid <= 0, FALSE, "main_xid <= 0");
3281
3282         if (!ad->isGrabed)
3283                 return TRUE;
3284         DEBUG_TRACE("key_grab_deinit############################");
3285
3286         disp = ecore_x_display_get();
3287         cam_retvm_if(disp == NULL, FALSE, "ecore_x_display_get fail");
3288
3289         /* volume key */
3290         if (utilx_ungrab_key(disp, ad->main_xid, KEY_VOLUMEUP) != success){
3291                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_VOLUMEUP);
3292                 ret = FALSE;
3293         }
3294         if (utilx_ungrab_key(disp, ad->main_xid, KEY_VOLUMEDOWN) != success){
3295                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_VOLUMEDOWN);
3296                 ret = FALSE;
3297         }
3298
3299         /* camera key */
3300         if (utilx_ungrab_key(disp, ad->main_xid, KEY_CAMERA) != success){
3301                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_CAMERA);
3302                 ret = FALSE;
3303
3304         }
3305         if (utilx_ungrab_key(disp, ad->main_xid, KEY_CONFIG) != success){
3306                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_CONFIG);
3307                 ret = FALSE;
3308         }
3309
3310         /* power key */
3311         if (utilx_ungrab_key(disp, ad->main_xid, KEY_POWER) != success){
3312                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_POWER);
3313                 ret = FALSE;
3314         }
3315         if (utilx_ungrab_key(disp, ad->main_xid, KEY_PAUSE) != success){
3316                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_PAUSE);
3317                 ret = FALSE;
3318         }
3319
3320         /* etc */
3321         if (utilx_ungrab_key(disp, ad->main_xid, KEY_SEND) != success){
3322                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_SEND);
3323                 ret = FALSE;
3324         }
3325         if (utilx_ungrab_key(disp, ad->main_xid, KEY_SELECT) != success){
3326                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_SELECT);
3327                 ret = FALSE;
3328         }
3329         if (utilx_ungrab_key(disp, ad->main_xid, KEY_END) != success){
3330                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_END);
3331                 ret = FALSE;
3332         }
3333
3334         ad->isGrabed = FALSE;
3335         return ret;
3336 }
3337
3338 gboolean cam_app_mouse_event_init(void *data)
3339 {
3340         struct appdata *ad = (struct appdata *)data;
3341         if (ad == NULL) {
3342                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3343                 return FALSE;
3344         }
3345 #if ENABLE_MOUSE_CONTROL
3346         if (ad->mouse_down == NULL) {
3347                 ad->mouse_down =
3348                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
3349                                             cam_mouse_button_down, ad);
3350         }
3351
3352         if (ad->mouse_up == NULL) {
3353                 ad->mouse_up =
3354                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
3355                                             cam_mouse_button_up, ad);
3356         }
3357 #if 0
3358
3359         if (ad->mouse_move == NULL) {
3360                 ad->mouse_down =
3361                     ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
3362                                             cam_mouse_move, ad);
3363         }
3364 #endif
3365 #endif
3366
3367         return TRUE;
3368 }
3369
3370 gboolean cam_app_mouse_event_deinit(void *data)
3371 {
3372         struct appdata *ad = (struct appdata *)data;
3373         if (ad == NULL) {
3374                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3375                 return FALSE;
3376         }
3377         if (ad->mouse_down) {
3378                 ecore_event_handler_del(ad->mouse_down);
3379                 ad->mouse_down = NULL;
3380         }
3381         if (ad->mouse_up) {
3382                 ecore_event_handler_del(ad->mouse_up);
3383                 ad->mouse_up = NULL;
3384         }
3385         if (ad->mouse_move) {
3386                 ecore_event_handler_del(ad->mouse_move);
3387                 ad->mouse_move = NULL;
3388         }
3389
3390         return TRUE;
3391 }
3392
3393 gboolean cam_app_key_event_init(void *data)
3394 {
3395         struct appdata *ad = (struct appdata *)data;
3396
3397         DEBUG_TRACE("cam_app_key_event_init");
3398
3399         if (ad == NULL) {
3400                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3401                 return FALSE;
3402         }
3403         if (ad->key_down == NULL) {
3404                 ad->key_down =
3405                     ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
3406                                             cam_hard_key_down, ad);
3407         }
3408         if (ad->key_up == NULL) {
3409                 ad->key_up =
3410                     ecore_event_handler_add(ECORE_EVENT_KEY_UP, cam_hard_key_up,
3411                                             ad);
3412         }
3413 #if ENABLE_MOUSE_CONTROL
3414         if (ad->mouse_down == NULL) {
3415                 ad->mouse_down =
3416                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
3417                                             cam_mouse_button_down, ad);
3418         }
3419
3420         if (ad->mouse_up == NULL) {
3421                 ad->mouse_up =
3422                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
3423                                             cam_mouse_button_up, ad);
3424         }
3425 #if 0
3426
3427         if (ad->mouse_move == NULL) {
3428                 ad->mouse_down =
3429                     ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
3430                                             cam_mouse_move, ad);
3431         }
3432 #endif
3433 #endif
3434
3435         return TRUE;
3436 }
3437
3438 gboolean cam_app_key_event_deinit(void *data)
3439 {
3440         struct appdata *ad = (struct appdata *)data;
3441
3442         DEBUG_TRACE("cam_app_key_event_deinit");
3443
3444         if (ad == NULL) {
3445                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3446                 return FALSE;
3447         }
3448         if (ad->key_down) {
3449                 ecore_event_handler_del(ad->key_down);
3450                 ad->key_down = NULL;
3451         }
3452         if (ad->key_up) {
3453                 ecore_event_handler_del(ad->key_up);
3454                 ad->key_up = NULL;
3455         }
3456         if (ad->mouse_down) {
3457                 ecore_event_handler_del(ad->mouse_down);
3458                 ad->mouse_down = NULL;
3459         }
3460         if (ad->mouse_up) {
3461                 ecore_event_handler_del(ad->mouse_up);
3462                 ad->mouse_up = NULL;
3463         }
3464         if (ad->mouse_move) {
3465                 ecore_event_handler_del(ad->mouse_move);
3466                 ad->mouse_move = NULL;
3467         }
3468
3469         return TRUE;
3470 }
3471
3472 Eina_Bool cam_hard_key_down(void *data, int type, void *event_info)
3473 {
3474         struct appdata *ad = (struct appdata *)data;
3475         CamAppData *camapp = NULL;
3476
3477
3478         Ecore_Event_Key *kd = (Ecore_Event_Key *) event_info;
3479
3480         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
3481
3482         cam_debug(LOG_UI, "Key name : %s", kd->keyname);
3483
3484         camapp = ad->camapp_handle;
3485         cam_retvm_if(camapp == NULL, -1, "camapp_handle is NULL");
3486
3487         ad->show_menu = FALSE;
3488         ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
3489         cam_toolbar_and_setting_popup_del(ad);
3490
3491         cam_app_timeout_checker_update();
3492
3493         /*  Camera key Press */
3494         if (0 == strcmp(kd->keyname, KEY_CANCEL)) {
3495                 ad->cancel_key_press = TRUE;
3496         }
3497         if (0 == strcmp(kd->keyname, KEY_CONFIG)) {     /* camera key - full */
3498                 if (!camapp->key_lock) {
3499                         camapp->key_lock = TRUE;
3500                         CAM_TA_ACUM_ITEM_BEGIN("Total capture time", 0);
3501                         CAM_TA_ACUM_ITEM_BEGIN
3502                             ("        camera key to capture start", 0);
3503                         if (!cam_camera_key_press(ad)) {
3504                                 cam_warning(LOG_UI,
3505                                             "cam_camera_key_press failed");
3506                         }
3507                         camapp->key_lock = FALSE;
3508                 }
3509         }
3510         /*  Camera key HALF press */
3511         else if (0 == strcmp(kd->keyname, KEY_CAMERA)) {        /* camera key - half */
3512                 if (!camapp->key_lock) {
3513                         camapp->key_lock = TRUE;
3514                         ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
3515                         ad->show_menu = FALSE;
3516                         cam_toolbar_and_setting_popup_del(ad);
3517
3518                         if (!cam_camera_key_half_press(ad)) {
3519                                 cam_warning(LOG_UI,
3520                                             "cam_camera_key_half_press failed");
3521                         }
3522                         camapp->key_lock = FALSE;
3523                 }
3524         } else if (0 == strcmp(kd->keyname, KEY_VOLUMEUP)) {
3525                 if (!camapp->key_lock) {
3526                         camapp->key_lock = TRUE;
3527                         ad->up_key = TRUE;
3528                         cam_add_longpress_key_timer(ad);
3529                         camapp->key_lock = FALSE;
3530                 }
3531         } else if (0 == strcmp(kd->keyname, KEY_VOLUMEDOWN)) {
3532                 if (!camapp->key_lock) {
3533                         camapp->key_lock = TRUE;
3534                         ad->up_key = FALSE;
3535                         cam_add_longpress_key_timer(ad);
3536                         camapp->key_lock = FALSE;
3537                 }
3538         } else if (0 == strcmp(kd->keyname, KEY_SELECT)) {
3539
3540         } else if ((0 == strcmp(kd->keyname, KEY_SELECT))
3541                    && ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
3542                 if (!camapp->key_lock) {
3543                         camapp->key_lock = TRUE;
3544                 }
3545         } else if (0 == strcmp(kd->keyname, KEY_POWER)) {
3546                 if (!camapp->key_lock) {
3547                         camapp->key_lock = TRUE;
3548                         power_unlock_state(POWER_STATE_NORMAL);
3549                         cam_power_key_press(ad);
3550                         camapp->key_lock = FALSE;
3551
3552                 }
3553         }
3554
3555         return 0;
3556 }
3557
3558 Eina_Bool cam_hard_key_up(void *data, int type, void *event_info)
3559 {
3560         struct appdata *ad = (struct appdata *)data;
3561         CamAppData *camapp = NULL;
3562
3563         Ecore_Event_Key *kd = (Ecore_Event_Key *) event_info;
3564         cam_retv_if(ad == NULL, ECORE_CALLBACK_CANCEL);
3565
3566         cam_debug(LOG_UI, "Key name : %s", kd->keyname);
3567
3568         camapp = ad->camapp_handle;
3569         cam_retv_if(camapp == NULL, ECORE_CALLBACK_CANCEL);
3570
3571         cam_app_timeout_checker_update();
3572
3573         if (0 == strcmp(kd->keyname, KEY_CANCEL)) {
3574                 ad->cancel_key_press = FALSE;
3575         }
3576
3577         if(ad->cancel_key_press == TRUE) {
3578                 if (ad->longpress_timer) { /*volume key long press */
3579                         cam_del_longpress_key_timer(ad);
3580                         cam_volume_key_press(ad);
3581                 }
3582                 return FALSE;
3583         }
3584
3585
3586         if (0 == strcmp(kd->keyname, KEY_CONFIG)) {     /* camera key - full  */
3587                 if (!camapp->key_lock) {
3588                         camapp->key_lock = TRUE;
3589                         if (!cam_camera_key_release(ad)) {
3590                                 cam_warning(LOG_UI,
3591                                             "cam_camera_key_release failed");
3592                         }
3593                         camapp->key_lock = FALSE;
3594                 }
3595         } else if (0 == strcmp(kd->keyname, KEY_CAMERA)) {      /* camera key - half */
3596                 if (!camapp->key_lock) {
3597                         camapp->key_lock = TRUE;
3598                         if (!cam_camera_key_half_release(ad)) {
3599                                 cam_warning(LOG_UI,
3600                                             "cam_camera_key_release failed");
3601                         }
3602                         camapp->key_lock = FALSE;
3603                 }
3604         } else if (0 == strcmp(kd->keyname, KEY_VOLUMEUP)
3605                    || 0 == strcmp(kd->keyname, KEY_VOLUMEDOWN)) {
3606                 if (!camapp->key_lock) {
3607                         camapp->key_lock = TRUE;
3608                         cam_del_longpress_key_timer(ad);
3609                         cam_volume_key_press(ad);
3610                         camapp->key_lock = FALSE;
3611                 }
3612         } else if (0 == strcmp(kd->keyname, KEY_END)
3613                    || 0 == strcmp(kd->keyname, KEY_SELECT)) {
3614
3615                 DEBUG_TRACE("camapp->key_lock = %d", camapp->key_lock);
3616                 if (!camapp->key_lock) {
3617                         camapp->key_lock = TRUE;
3618
3619                         if ( ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
3620
3621                                 int mm_state = 0;
3622                                 mm_state = cam_mm_get_state();
3623                                 ad->appcore_state = CAM_APPCORE_PAUSE_STATE;
3624                                 if (mm_state < CAMERA_STATE_CAPTURING) {
3625                                         cam_app_exit(ad);
3626                                 }
3627                                 return 0;
3628                         }
3629
3630                         if (ad->imageviewer_ug) {
3631                                 DEBUG_TRACE("destory imageviewer");
3632                                 cam_app_close_ug(ad);
3633                                 cam_app_start_rotate(ad, false);
3634                                 cam_app_key_event_deinit(ad);
3635                                 if(!cam_key_grab_deinit(ad))
3636                                         DEBUG_TRACE("cam_key_grab_deinit fail");
3637                                 ad->foucs_out_from_quickview = FALSE;
3638                         }
3639                         if ((ad->mm_state == RECORDER_STATE_RECORDING
3640                             || ad->mm_state == RECORDER_STATE_PAUSED)
3641                             &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
3642                                 camapp->rec_stop_type = CAM_REC_STOP_NORMAL;
3643                                 ad->recording_commit = ecore_idler_add(cam_video_idler_record_stop, ad);
3644                                 camapp->key_lock = FALSE;
3645                                 return 0;
3646                         } else if (ad->mm_state == CAMERA_STATE_CAPTURING
3647                         &&camapp->camera_mode == CAM_CAMERA_MODE) {
3648                                 camapp->key_lock = FALSE;
3649                                 return 0;
3650                         } else if ((ad->mm_state == RECORDER_STATE_READY
3651                         &&camapp->camera_mode == CAM_CAMERA_MODE)
3652                         ||(ad->mm_state == CAMERA_STATE_PREVIEW
3653                         &&camapp->camera_mode == CAM_CAMCORDER_MODE)) {
3654                                 ;
3655                         }
3656                         if (0 == strcmp(kd->keyname, KEY_END)) {
3657                                 cam_debug(LOG_UI, " Key up : END Key");
3658                                 /*cam_app_exit(ad);*/
3659                                 /*camapp->key_lock = FALSE;*/
3660                         }
3661                         camapp->key_lock = FALSE;
3662
3663                 } else {
3664                         cam_debug(LOG_UI, "key lock status = %d",
3665                                   camapp->key_lock);
3666                 }
3667         }
3668
3669         return 0;
3670 }
3671
3672 /*note: focus edje zoom in*/
3673 static void __cam_app_set_focus_zoom_in_effect(void *data)
3674 {
3675         struct appdata *ad = (struct appdata *)data;
3676         cam_retm_if(ad == NULL, "appdata is NULL");
3677
3678         if (ad->camapp_handle->enable_touch_af == TRUE) {
3679                 REMOVE_TIMER(ad->continuous_af_timer);
3680                 cam_camera_touch_af_press(ad);
3681         } else {
3682                 cam_app_draw_af_box(ad);
3683                 evas_object_show(ad->focus_edje);
3684                 cam_ui_effect_utils_set_zoom_effect(ad->focus_edje,
3685                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_START_RATE,
3686                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_END_RATE,
3687                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_DURATION);
3688         }
3689 }
3690
3691 /*note: focus edje zoom out*/
3692 static void __cam_app_set_focus_zoom_out_effect(void *data)
3693 {
3694         struct appdata *ad = (struct appdata *)data;
3695         cam_retm_if(ad == NULL, "appdata is NULL");
3696
3697         if (ad->camapp_handle->enable_touch_af == TRUE) {
3698                 REMOVE_TIMER(ad->continuous_af_timer);
3699                 cam_camera_touch_af_press(ad);
3700         } else {
3701                 cam_app_draw_af_box(ad);
3702                 evas_object_show(ad->focus_edje);
3703                 cam_ui_effect_utils_set_zoom_effect(ad->focus_edje,
3704                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_END_RATE,
3705                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_START_RATE,
3706                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_DURATION);
3707         }
3708 }
3709
3710 #if ENABLE_MOUSE_CONTROL
3711 Eina_Bool cam_mouse_button_down(void *data, int type, void *event_info)
3712 {
3713         struct appdata *ad = (struct appdata *)data;
3714         cam_retvm_if(ad == NULL, EINA_FALSE, "appdata is NULL");
3715         CamAppData *camapp = ad->camapp_handle;
3716         cam_retvm_if(camapp == NULL, EINA_FALSE, "camapp_handle is NULL");
3717
3718         if (ad->zoom_edje
3719                 || ad->setting_ctxpopup
3720                 || (ad->toolbar_show_setting_popup == TRUE)
3721                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)) {
3722                 cam_debug(LOG_UI, "ignore touch event");
3723                 ad->af_outside = TRUE;
3724         }
3725
3726         int toolbar_width = TOOLBAR_W;
3727
3728         Ecore_Event_Mouse_Button *md = (Ecore_Event_Mouse_Button *) event_info;
3729         cam_debug(LOG_UI, "mouse button down[%d, %d]", md->root.x, md->root.y);
3730
3731         ad->touch_lcd_x = md->root.x;   /* LCD x */
3732         ad->touch_lcd_y = md->root.y;   /* LCD y */
3733
3734         ad->af_outside = FALSE;
3735
3736         /* x */
3737         if (ad->touch_lcd_y < toolbar_width
3738             || ad->touch_lcd_y > (ad->win_width - toolbar_width)) {
3739                 ad->af_outside = TRUE;
3740         } else {
3741                 ad->af_x = ad->touch_lcd_y - ad->preview_offset_x;
3742         }
3743         /* y */
3744         if (ad->touch_lcd_x < ad->preview_offset_y
3745             || ad->touch_lcd_x > (ad->preview_h + ad->preview_offset_y)) {
3746                 ad->af_outside = TRUE;
3747         } else {
3748                 ad->af_y = ad->preview_h - ad->touch_lcd_x;
3749         }
3750
3751         ad->af_x = (ad->af_x * ad->camfw_video_width) / ad->preview_w;
3752         ad->af_y = (ad->af_y * ad->camfw_video_height) / ad->preview_h;
3753         DEBUG_TRACE
3754             ("*************************************************************************************");
3755         DEBUG_TRACE("touched lcd x,y=[%d,%d] af x,y=[%d,%d]\n", ad->touch_lcd_x,
3756                     ad->touch_lcd_y, ad->af_x, ad->af_y);
3757         DEBUG_TRACE
3758             ("*************************************************************************************");
3759         if (ad->af_outside == FALSE) {
3760                 __cam_app_set_focus_zoom_in_effect((void *)ad);
3761         }
3762         cam_app_timeout_checker_update();
3763         cam_setting_toolbar_execution_time_checker_update(ad);
3764
3765         return EINA_TRUE;
3766 }
3767
3768 Eina_Bool cam_mouse_button_up(void *data, int type, void *event_info)
3769 {
3770         struct appdata *ad = (struct appdata *)data;
3771         CamAppData *camapp = NULL;
3772
3773         if (ad->zoom_edje
3774                 || ad->setting_ctxpopup
3775                 || (ad->toolbar_show_setting_popup == TRUE)
3776                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)) {
3777                 cam_debug(LOG_UI, "ignore touch event");
3778                 ad->af_outside = TRUE;
3779                 return EINA_TRUE;
3780         }
3781
3782         Ecore_Event_Mouse_Button *md = (Ecore_Event_Mouse_Button *) event_info;
3783         if (ad->shutter_move == TRUE) {
3784                 double y_gap = 0;
3785                 double x_gap = 0;
3786                 double shutter_h_ratio = SHUTTER_H_RATIO;
3787                 double shutter_w_ratio = SHUTTER_W_RATIO;
3788                 double screen_ratio = SCREEN_RATIO;
3789
3790                 y_gap = (double)md->root.y /(double)ad->win_width;
3791                 x_gap = (double)md->root.x /(double)ad->win_height;
3792
3793                 if (x_gap > (screen_ratio -shutter_h_ratio) || x_gap < shutter_h_ratio) {
3794                         if (!cam_camera_key_half_release(ad)) {
3795                                 DEBUG_TRACE("cam_camera_key_half_release");
3796                         }
3797                 } else if (ad->angle == 90 ||ad->angle == 180) {
3798                         if (y_gap > shutter_w_ratio) {
3799                                 if (!cam_camera_key_half_release(ad)) {
3800                                         DEBUG_TRACE("cam_camera_key_half_release");
3801                                 }
3802                         }
3803                 } else {
3804                         if (y_gap < screen_ratio -shutter_w_ratio) {
3805                                 if (!cam_camera_key_half_release(ad)) {
3806                                         DEBUG_TRACE("cam_camera_key_half_release");
3807                                 }
3808                         }
3809                 }
3810         }
3811
3812         cam_retvm_if(ad == NULL, EINA_FALSE, "appdata is NULL");
3813         cam_debug(LOG_UI, "mouse button up[%d, %d]", md->root.x, md->root.y);
3814         if (ad->af_outside == FALSE) {
3815                 __cam_app_set_focus_zoom_out_effect((void *)ad);
3816         }
3817         camapp = ad->camapp_handle;
3818         if (camapp == NULL) {
3819                 cam_warning(LOG_UI, "camapp_handle is NULL, maybe not created");
3820                 return EINA_FALSE;
3821         }
3822         return EINA_TRUE;
3823 }
3824
3825 Eina_Bool cam_mouse_move(void *data, int type, void *event_info)
3826 {
3827         struct appdata *ad = (struct appdata *)data;
3828         CamAppData *camapp = NULL;
3829
3830         Ecore_Event_Mouse_Move *md = (Ecore_Event_Mouse_Move *) event_info;
3831
3832         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
3833         cam_debug(LOG_UI, "mouse move[%d, %d]", md->root.x, md->root.y);
3834         cam_debug(LOG_UI, "mouse move angle[%lf]", md->multi.angle);
3835         cam_debug(LOG_UI, "mouse move pressure[%lf]", md->multi.pressure);
3836         camapp = ad->camapp_handle;
3837         if (camapp == NULL) {
3838                 cam_warning(LOG_UI, "camapp_handle is NULL, maybe not created");
3839                 return -1;
3840         }
3841         cam_app_timeout_checker_update();
3842
3843         return 0;
3844 }
3845 #endif
3846
3847 void cam_app_set_config_group(gint mode)
3848 {
3849         cam_debug(LOG_UI, "mode : %d", mode);
3850
3851         if (mode == CAM_CAMERA_MODE) {
3852                 cam_config_set_group_name(CAM_CONFIG_TYPE_PREVIEW, "still");
3853         } else {
3854                 cam_config_set_group_name(CAM_CONFIG_TYPE_PREVIEW, "video");
3855         }
3856
3857         debug_fleave(LOG_UI);
3858
3859         return;
3860 }
3861
3862 int cam_app_get_latest_mode(void)
3863 {
3864         cam_config_set_group_name(CAM_CONFIG_TYPE_COMMON, "common");
3865         int last_mode =
3866             cam_config_get_int_by_type(CAM_CONFIG_TYPE_COMMON, "mode",
3867                                        CAM_CAMERA_MODE);
3868
3869         debug_msg(LOG_UI, "last mode:%d", last_mode);
3870         return last_mode;
3871 }
3872
3873 const gchar *cam_app_get_target_path(void)
3874 {
3875         CamAppData *camapp = NULL;
3876
3877         camapp = cam_handle_get();
3878
3879         if (camapp) {
3880
3881                 const gchar *default_path = NULL;
3882                 switch (camapp->storage) {
3883                 case CAM_STORAGE_INTERNAL:
3884                         default_path =
3885                             (camapp->camera_mode == CAM_CAMCORDER_MODE) ?
3886                                 cam_file_get_internal_video_path() :
3887                                 cam_file_get_internal_image_path();
3888                         break;
3889                 case CAM_STORAGE_EXTERNAL:
3890                         default_path =
3891                             (camapp->camera_mode == CAM_CAMCORDER_MODE) ?
3892                                 cam_file_get_external_video_path() :
3893                                 cam_file_get_external_image_path();
3894                         break;
3895                 default:
3896                         cam_critical(LOG_UI, "Unknow storage type : %d",
3897                                      camapp->storage);
3898                         break;
3899                 }
3900
3901                 cam_debug(LOG_UI, "target path : [%s]", default_path);
3902                 return default_path;
3903         } else {
3904                 cam_critical(LOG_UI, "camapp handle is NULL");
3905                 return NULL;
3906         }
3907 }
3908
3909 gchar *cam_app_get_last_filename(void)
3910 {
3911         CamAppData *camapp = NULL;
3912         gchar *last_file_path = NULL;
3913         struct appdata *ad = (struct appdata *)cam_appdata_get();
3914         cam_retvm_if(ad == NULL, NULL, "appdata is NULL");
3915
3916         camapp = cam_handle_get();
3917         cam_retvm_if(camapp == NULL, NULL, "cam_handle is NULL");
3918
3919         last_file_path = cam_file_get_last_file_path(ad, cam_app_get_target_path());
3920
3921         if (last_file_path) {
3922                 cam_debug(LOG_UI, "last_file_path  : %s", last_file_path);
3923         } else {
3924                 cam_critical(LOG_UI, "last_file_path is NULL");
3925                 return NULL;
3926         }
3927         return last_file_path;
3928 }
3929
3930 gchar *cam_app_get_next_filename(void)
3931 {
3932
3933         CamAppData *camapp = NULL;
3934         gchar *new_filename = NULL;
3935         struct appdata *ad = (struct appdata *)cam_appdata_get();
3936         cam_retvm_if(ad == NULL, NULL, "appdata is NULL");
3937
3938         camapp = cam_handle_get();
3939         cam_retvm_if(camapp == NULL, NULL, "cam_handle is NULL");
3940         int mm_state = 0;
3941         mm_state = cam_mm_get_state();
3942
3943         if (mm_state == RECORDER_STATE_RECORDING
3944                 &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
3945                 new_filename = cam_file_get_next_filename(cam_app_get_target_path(), INAGE_FILE_NAME, IMAGE_FILE_EXTENSION);
3946         } else {
3947                 new_filename = cam_file_get_next_filename(cam_app_get_target_path(),
3948                                           (camapp->camera_mode ==
3949                                            CAM_CAMERA_MODE) ?
3950                                           INAGE_FILE_NAME :
3951                                           VIDEO_FILE_NAME,
3952                                           (camapp->camera_mode ==
3953                                            CAM_CAMERA_MODE) ?
3954                                           IMAGE_FILE_EXTENSION :
3955                                           VIDEO_FILE_EXTENSION);
3956         }
3957
3958         if (new_filename) {
3959                 cam_debug(LOG_UI, "next filename : %s", new_filename);
3960         } else {
3961                 cam_critical(LOG_UI, "new_filename is NULL");
3962         }
3963
3964         return new_filename;
3965 }
3966
3967 static void __cam_preview_cb(void *stream_buffer, int buffer_size, int width,
3968                 int height, camera_pixel_format_e format, void *user_data)
3969 {
3970
3971         cam_retm_if(user_data == NULL, "data is null");
3972         struct appdata *ad = (struct appdata *)user_data;
3973
3974         CamAppData *camapp = ad->camapp_handle;
3975         cam_retm_if(camapp == NULL, "camapp is null");
3976
3977 }
3978
3979 static void __cam_state_change_cb(camera_state_e previous, camera_state_e current,
3980         bool by_policy, void *user_data)
3981 {
3982         struct appdata *ad = NULL;
3983         CamAppData *camapp = NULL;
3984         ad = (struct appdata *)user_data;
3985         cam_retm_if(ad == NULL, "camapp is null");
3986         camapp = ad->camapp_handle;
3987         cam_retm_if(camapp == NULL, "camapp is null");
3988         DEBUG_TRACE("current= %d, previous = %d, ad->enable_mode_change = %d",
3989                 current, previous, ad->enable_mode_change);
3990         if (current == CAMERA_STATE_PREVIEW) {
3991                 ad->enable_mode_change = TRUE;
3992         } else {
3993                 ad->enable_mode_change = FALSE;
3994         }
3995         DEBUG_TRACE("current= %d, previous = %d, ad->enable_mode_change = %d",
3996                 current, previous, ad->enable_mode_change);
3997         cam_app_state_manager(previous, current, by_policy);
3998
3999 }
4000
4001 static void __cam_focus_cb(camera_focus_state_e state, void *user_data) {
4002
4003         struct appdata *ad = NULL;
4004         CamAppData *camapp = NULL;
4005
4006         ad = (struct appdata *)user_data;
4007         cam_retm_if(ad == NULL, "appdata is NULL");
4008
4009         /*
4010         *       TODO: perhaps we have to consider: in thread, we should not use any efl api.
4011         *               especially:
4012         *               try not to operation the global evas object in asynchronous
4013         *               callback or thread. Some bs perhaps caused by this.
4014         *
4015         */
4016         /*note: while rotating, return. */
4017         if (ad->is_rotating) return;/*note: while rotating, return. */
4018         camapp = ad->camapp_handle;
4019         cam_retm_if(camapp == NULL, "camapp is NULL");
4020
4021
4022         cam_debug(LOG_MM, " Focus state changed to [%d]", state);
4023
4024         if(ad->appcore_state == CAM_APPCORE_PAUSE_STATE)
4025                 return;
4026
4027         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4028                 camapp->focus_state = state ;
4029                 cam_app_focus_guide_update(ad);
4030         } else {
4031                 camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
4032         }
4033         switch (state) {
4034         case CAMERA_FOCUS_STATE_ONGOING:
4035                 break;
4036         case CAMERA_FOCUS_STATE_FOCUSED:
4037                 if (ad->mm_state < CAMERA_STATE_CAPTURING) {
4038                         if (camapp->shutter_sound != CAM_SETTINGS_SOUND_OFF
4039                                 && camapp->camera_mode == CAM_CAMERA_MODE )
4040                                 cam_sound_play (CAM_SOUND_EFFECT_AF_OK, ad);
4041
4042                         if (camapp->focus_mode == CAM_FOCUS_MODE_TOUCH_AUTO){
4043                                 REMOVE_TIMER(ad->continuous_af_timer);
4044                                 DEBUG_TRACE("start caf");
4045                                 cam_app_focus_guide_create(ad);
4046                                 cam_app_focus_guide_update(ad);
4047                                 ad->continuous_af_timer= ecore_timer_add(FOCUS_FOCUSED_TIME_OUT, cam_continuous_af_start, ad);
4048                         }
4049                 }
4050                 break;
4051         case CAMERA_FOCUS_STATE_FAILED:
4052                 if (ad->mm_state < CAMERA_STATE_CAPTURING) {
4053                         if (camapp->shutter_sound != CAM_SETTINGS_SOUND_OFF
4054                                 && camapp->camera_mode == CAM_CAMERA_MODE)
4055                                 cam_sound_play (CAM_SOUND_EFFECT_AF_FAIL, ad);
4056
4057                         if (camapp->focus_mode == CAM_FOCUS_MODE_TOUCH_AUTO) {
4058                                 REMOVE_TIMER(ad->continuous_af_timer);
4059                                 DEBUG_TRACE("start caf");
4060                                 cam_app_focus_guide_create(ad);
4061                                 cam_app_focus_guide_update(ad);
4062                                 ad->continuous_af_timer= ecore_timer_add(FOCUS_FAILED_TIME_OUT, cam_continuous_af_start, ad);
4063                         }
4064                 }
4065                 break;
4066         default:
4067                 break;
4068         }
4069
4070
4071 }
4072
4073 static void __cam_capture_cb(camera_image_data_s* image,
4074         camera_image_data_s* postview,
4075         camera_image_data_s* thumbnail,
4076         void *user_data)
4077 {
4078         struct appdata *ad = (struct appdata *)user_data;
4079         cam_retm_if(ad == NULL, "appdata is NULL");
4080         CamAppData *camapp = NULL;
4081         camapp = ad->camapp_handle;
4082         cam_retm_if(camapp == NULL, "camapp is NULL");
4083
4084         gchar *filename = NULL;
4085         FILE *fp = NULL;
4086         if ((image->format == CAMERA_PIXEL_FORMAT_YUYV)
4087             || (image->format == CAMERA_PIXEL_FORMAT_NV12)) {
4088                 cam_debug(LOG_UI,
4089                           "got raw data - format [%d] data [%p], length [%d], width [%d], height [%d]",
4090                           image->format, image->data, image->size, image->width,
4091                           image->height);
4092                 /* encode data */
4093                 /* MMImageJpegEncodeToFile(filename, src->data, src->width,src->height, src->format, 90); */
4094         } else if (image->format == CAMERA_PIXEL_FORMAT_JPEG) {
4095                 cam_debug(LOG_UI,
4096                           "got JPEG data - data [%p], length [%d], width [%d], height [%d]",
4097                           image->data, image->size, image->width, image->height);
4098
4099                 /* save file */
4100                 filename = cam_app_get_next_filename();
4101                 if (filename == NULL) {
4102                         cam_critical(LOG_SYS, " Get next filename FAILED");
4103                         return;
4104                 }
4105
4106                 fp = fopen(filename, "w+");
4107                 if (fp == NULL) {
4108                         cam_critical(LOG_SYS, "FileOPEN error!!");
4109                         return;
4110                 } else {
4111                         cam_debug(LOG_SYS, "FileOPEN success");
4112                         if (fwrite(image->data, image->size, 1, fp) != 1) {
4113                                 cam_critical(LOG_SYS, "File write error!!");
4114                                 fclose(fp);
4115                                 return;
4116                         }
4117                         /*fsync(fp->_fileno);*/
4118                         /*block for increasing formance of shot-to-shot */
4119                         cam_debug(LOG_SYS, "File write success");
4120                         fclose(fp);
4121                 }
4122                 if (camapp->filename)
4123                         free(camapp->filename);
4124                 camapp->filename = strdup(filename);
4125                 free(filename);
4126         }
4127
4128 }
4129
4130 static void __cam_capture_completed_cb(void *user_data)
4131 {
4132 /*      camera_error_e e;*/
4133         DEBUG_TRACE();
4134         struct appdata *ad = NULL;
4135         CamAppData *camapp = NULL;
4136
4137         ad = (struct appdata *)user_data;
4138         camapp = ad->camapp_handle;
4139
4140         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4141 #ifndef ENABLE_CAPTURE_ANIMATION
4142
4143                                                 /* Idler of capture callback management. wh01.cho@samsung.com. 2010-12-15. */
4144                                                 CamIdlerItem *item = NULL;
4145                                                 item = (CamIdlerItem *)
4146                                                     g_malloc(sizeof(CamIdlerItem));
4147                                                 if (item == NULL)
4148                                                         return;
4149
4150                 if (item) {
4151                         item->data = user_data;
4152                         item->idler = ecore_idler_add(cam_image_capture_handle_idler, item);
4153
4154                         if (item->idler)
4155                                 ad->capture_cb_list = g_list_append(ad->capture_cb_list, item->idler);
4156
4157                         cam_info(LOG_UI, "image capture idler add : %p ", item->idler);
4158                 }
4159 #endif
4160                 DEBUG_TRACE();
4161                 if (!cam_app_preview_start(ad)) {
4162                         cam_critical(LOG_MM, "cam_app_preview_start failed");
4163                         cam_app_notice_popup(ad, "cam_app_preview_start faild ",
4164                                              cam_app_timeout_notice_response_cb);
4165                         return;
4166                 }
4167         }else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
4168
4169                 DEBUG_TRACE("MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED");
4170                 ecore_idler_add(cam_capture_on_recording_handle, ad);
4171         }
4172         DEBUG_TRACE();
4173 }
4174 static void __cam_interrupted_cb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *data)
4175 {
4176         struct appdata *ad = (struct appdata *)data;
4177         CamAppData *camapp = NULL;
4178         cam_retm_if(ad == NULL, "appdata is NULL");
4179         camapp = ad->camapp_handle;
4180         cam_retm_if(camapp == NULL, "cam_handle is NULL");
4181         DEBUG_TRACE("policy is [%d]",policy);
4182         switch (policy) {
4183         case CAMERA_POLICY_SOUND:
4184                 {
4185                         cam_app_black_screen_show(ad, 2);
4186                         ecore_timer_add(0.01, cam_delay_popup, (void *)ad);
4187                 }
4188                 break;
4189         case CAMERA_POLICY_SECURITY:
4190                         cam_app_mdm_syspopup(ad);
4191                 break;
4192         default:
4193                 break;
4194         }
4195 }
4196
4197 static void __rec_interrupted_cb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *data)
4198 {
4199         struct appdata *ad = (struct appdata *)data;
4200         CamAppData *camapp = NULL;
4201         cam_retm_if(ad == NULL, "appdata is NULL");
4202         camapp = ad->camapp_handle;
4203         cam_retm_if(camapp == NULL, "cam_handle is NULL");
4204         DEBUG_TRACE("policy is [%d]",policy);
4205
4206         switch (policy) {
4207         case RECORDER_POLICY_SOUND:
4208                 {
4209                         cam_app_black_screen_show(ad, 2);
4210                         ecore_timer_add(0.01, cam_delay_popup, (void *)ad);
4211                 }
4212                 break;
4213         case RECORDER_POLICY_SECURITY:
4214                         cam_app_mdm_syspopup(ad);
4215                 break;
4216         default:
4217                 break;
4218         }
4219 }
4220
4221 static void __cam_error_cb(int error, camera_state_e current_state, void *user_data)
4222 {
4223         struct appdata *ad = NULL;
4224         CamAppData *camapp = NULL;
4225
4226         ad = (struct appdata *)user_data;
4227         cam_retm_if(ad == NULL, "appdata is NULL");
4228         camapp = ad->camapp_handle;
4229         cam_retm_if(camapp == NULL, "camapp is NULL");
4230
4231         int state = 0;
4232         state = current_state;
4233         cam_warning(LOG_MM,
4234                         "MM ERROR occurs : code [%x], state [%d]",
4235                         error, state);
4236
4237         switch (error) {
4238         case CAMERA_ERROR_DEVICE:
4239                 cam_critical(LOG_SYS,
4240                                  "      MM CAMCARORDER ERROR ");
4241                 if (state < CAMERA_STATE_CAPTURING) {
4242                         cam_app_notice_popup(ad,
4243                                 _("IDS_CAM_POP_UNABLE_TO_START_CAMERA"),
4244                                 cam_app_timeout_notice_response_cb);
4245                 } else {
4246                         cam_app_notice_popup(ad,
4247                                 _("IDS_CAM_POP_CAPTURE_TIME_EXCEEDED_START_AGAIN"),
4248                                 cam_app_timeout_notice_response_cb);
4249                 }
4250                 break;
4251         case CAMERA_ERROR_INVALID_PARAMETER:
4252                 if (state == CAMERA_STATE_CAPTURING) {
4253                         cam_app_notice_popup(ad,
4254                                 _("IDS_CAM_POP_CAPTURE_ERROR"),
4255                                 cam_app_timeout_notice_response_cb);
4256                 }
4257                 break;
4258         case CAMERA_ERROR_SOUND_POLICY:
4259                 {
4260                         DEBUG_TRACE(" MM CAMCARORDER ERROR\n");
4261                         cam_app_black_screen_show(ad, 2);
4262                         ecore_timer_add(0.01, cam_delay_popup,
4263                                         (void *)ad);
4264                 }
4265                 break;
4266         case CAMERA_ERROR_INVALID_OPERATION:
4267                 {
4268                         DEBUG_TRACE(" Internal error\n");
4269                         cam_app_black_screen_show(ad, 2);
4270                         ecore_timer_add(0.01, cam_delay_popup,
4271                                         (void *)ad);
4272                 }
4273                 break;
4274         case CAMERA_ERROR_OUT_OF_MEMORY:
4275                 {
4276                         DEBUG_TRACE(" Out of memory\n");
4277                         cam_app_black_screen_show(ad, 2);
4278                         ecore_timer_add(0.01, cam_delay_popup,
4279                                         (void *)ad);
4280                 }
4281                 break;
4282         default:
4283                 {
4284                         DEBUG_TRACE(" MM CAMCARORDER ERROR error code =%x \n", error);
4285                         if (state == CAMERA_STATE_CAPTURING
4286                                 && camapp->camera_mode == CAM_CAMERA_MODE) {
4287                                 cam_app_notice_popup(ad, _("IDS_CAM_POP_CAPTURE_ERROR"),
4288                                         cam_app_capture_error_popup_response_cb);
4289                         }
4290                 }
4291                 break;
4292         }
4293
4294 }
4295
4296 static void __recorder_state_cb(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data)
4297 {
4298         struct appdata *ad = NULL;
4299         CamAppData *camapp = NULL;
4300
4301         ad = (struct appdata *)user_data;
4302         cam_retm_if(ad == NULL, "appdata is NULL");
4303         camapp = ad->camapp_handle;
4304         cam_retm_if(camapp == NULL, "camapp is NULL");
4305         if (current == RECORDER_STATE_READY) {
4306                 ad->enable_mode_change = TRUE;
4307         } else {
4308                 ad->enable_mode_change = FALSE;
4309         }
4310         cam_app_state_manager(previous, current, by_policy);
4311 }
4312
4313 void __recording_status_cb(int elapsed_time, int file_size, void *user_data)
4314 {
4315         struct appdata *ad = NULL;
4316         CamAppData *camapp = NULL;
4317         ad = (struct appdata *)user_data;
4318         cam_retm_if(ad == NULL, "appdata is NULL");
4319         camapp = ad->camapp_handle;
4320         cam_retm_if(camapp == NULL, "camapp is NULL");
4321         /* update current time */
4322         DEBUG_TRACE();
4323         guint elapsed = 0;
4324         guint filesize = 0;
4325         elapsed = elapsed_time / 1000;
4326         filesize = file_size;
4327         if (camapp->rec_elapsed < elapsed) {
4328                 GValue value = { 0, };
4329
4330                 cam_debug(LOG_UI, "time updated: %u ", elapsed);
4331                 CAM_GVALUE_SET_UINT(value, elapsed);
4332                 cam_handle_value_set(ad, PROP_REC_TIME, &value);
4333         }
4334         if (camapp->rec_filesize < filesize) {
4335                 GValue value = { 0, };
4336
4337                 cam_debug(LOG_UI, "filesize updated: %u ", filesize);
4338                 CAM_GVALUE_SET_UINT(value, filesize);
4339                 cam_handle_value_set(ad, PROP_REC_FILE_SIZE, &value);
4340         }
4341 }
4342
4343 void __recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
4344 {
4345         struct appdata *ad = NULL;
4346         CamAppData *camapp = NULL;
4347         ad = (struct appdata *)user_data;
4348         cam_retm_if(ad == NULL, "appdata is NULL");
4349         camapp = ad->camapp_handle;
4350         cam_retm_if(camapp == NULL, "camapp is NULL");
4351
4352         if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
4353                 camapp->rec_stop_type = type;/*CAM_REC_STOP_TIME_LIMIT;*/
4354                 ad->recording_commit =
4355                         ecore_idler_add(cam_video_idler_record_stop, ad);
4356         }
4357 }
4358
4359 gboolean cam_callback_init(void *data)
4360 {
4361         struct appdata *ad = (struct appdata *)data;
4362         CamAppData *camapp = NULL;
4363
4364         debug_fenter(LOG_UI);
4365
4366         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4367         camapp = ad->camapp_handle;
4368         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4369         camapp->error_cb = __cam_error_cb;
4370         camapp->focus_cb = __cam_focus_cb;
4371         camapp->state_cb = __cam_state_change_cb;
4372         camapp->preview_cb = __cam_preview_cb;
4373         camapp->capture_completed_cb = __cam_capture_completed_cb;
4374         camapp->cam_interrupted_cb = __cam_interrupted_cb;
4375
4376         camapp->recording_status_cb = __recording_status_cb;
4377         camapp->recording_state_changed_cb = __recorder_state_cb;
4378         camapp->recording_limit_reached_cb = __recording_limit_reached_cb;
4379         camapp->rec_interrupted_cb = __rec_interrupted_cb;
4380
4381         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4382                 switch (camapp->shooting_mode) {
4383                 case CAM_SINGLE_MODE:
4384                 case CAM_SELF_MODE:
4385                         camapp->capture_cb = (camera_capturing_cb)
4386                                 __cam_capture_cb;
4387                         break;
4388                 default:
4389                         break;
4390                 }
4391         } else {
4392                 camapp->capture_cb = __cam_capture_cb;
4393         }
4394
4395         int ret = 1;
4396         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4397                 /*ret &= cam_mm_recorder_unset_state_changed_cb();*/
4398                 ret &= cam_mm_set_preview_cb(camapp->preview_cb, (void*)ad);
4399                 ret &= cam_mm_set_focus_changed_cb(camapp->focus_cb, (void*)ad);
4400                 ret &= cam_mm_set_state_changed_cb(camapp->state_cb, (void*)ad);
4401                 ret &= cam_mm_set_error_cb(camapp->error_cb, (void*)ad);
4402                 ret &= cam_mm_set_camera_interrupted_cb(camapp->cam_interrupted_cb, (void*)ad);
4403         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
4404                 ret &= cam_mm_unset_state_changed_cb();
4405                 /*ret &= cam_mm_unset_preview_cb();*/
4406                 /*ret &= cam_mm_unset_state_changed_cb();*/
4407                 /*ret &= cam_mm_unset_error_cb();*/
4408                 ret &= cam_mm_recorder_set_state_changed_cb(camapp->recording_state_changed_cb, (void*)ad);
4409                 ret &= cam_mm_recorder_set_recording_status_cb(camapp->recording_status_cb, (void*)ad);
4410                 ret &= cam_mm_recorder_set_recording_limit_reached_cb(camapp->recording_limit_reached_cb, (void*)ad);
4411                 ret &= cam_mm_set_recorder_interrupted_cb(camapp->rec_interrupted_cb, (void*)ad);
4412         }
4413
4414
4415         return ret;
4416 }
4417
4418 static void cam_app_close_ug(void *data)
4419 {
4420         cam_debug(LOG_UI, " ");
4421         struct appdata *ad = (struct appdata *)data;
4422         /* IDS problem */
4423
4424         cam_info(LOG_UI, "ad->imageviewer_ug : %p", ad->imageviewer_ug);
4425         if (ad->imageviewer_ug) {
4426                 ug_destroy(ad->imageviewer_ug);
4427                 ad->imageviewer_ug = NULL;
4428         }
4429         cam_file_init(NULL);
4430         return;
4431 }
4432
4433 static void __ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
4434 {
4435         cam_debug(LOG_UI, " ");
4436
4437         struct appdata *ad = (struct appdata *)priv;
4438         Evas_Object *base;
4439
4440         if (!ug || !priv)
4441                 return;
4442
4443         base = ug_get_layout(ug);
4444         if (!base)
4445                 return;
4446
4447         switch (mode) {
4448         case UG_MODE_FULLVIEW:
4449                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
4450                                                  EVAS_HINT_EXPAND);
4451                 elm_win_resize_object_add(ad->win_main, base);
4452                 evas_object_show(base);
4453                 break;
4454         default:
4455                 break;
4456         }
4457 }
4458
4459 void __ug_result_cb(ui_gadget_h ug, service_h result, void *priv)
4460 {
4461
4462         cam_debug(LOG_UI, " ");
4463
4464         struct appdata *ad = (struct appdata *)priv;
4465         char *val = NULL;
4466
4467         CamAppData *camapp = NULL;
4468
4469         cam_retm_if(ad == NULL, "appdata is NULL");
4470         camapp = ad->camapp_handle;
4471         cam_retm_if(camapp == NULL, "cam_handle is NULL");
4472
4473         if (ad->imageviewer_ug) {
4474                 if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
4475                         if (result == NULL) {
4476                                 ad->path_in_return = false;
4477                                 return;
4478                         }
4479
4480                         if ((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "contacts") == 0)) {
4481                                 service_h reply;
4482                                 service_create(&reply);
4483
4484                                 service_get_extra_data(result, "crop_image_path", &val);
4485                                 service_add_extra_data(reply, "crop_image_path", val);
4486                                 service_get_extra_data(result, "image_path", &val);
4487                                 service_add_extra_data(reply, "image_path", val);
4488
4489                                 service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_SUCCEEDED);
4490                                 service_destroy(reply);
4491
4492                                 ad->path_in_return = true;
4493                                 cam_app_exit(ad);
4494                         } else {
4495                                 /* get result value. */
4496                                 service_get_extra_data(result, "Result", &val);
4497
4498                                 if (strcmp(val, "Ok") == 0) {
4499                                         ad->path_in_return = true;
4500                                         cam_app_exit(ad);
4501                                 }
4502                                 else if (strcmp(val, "Cancel") == 0) {
4503                                         ad->path_in_return = false;
4504                                 }
4505                         }
4506                 }
4507         }
4508 }
4509
4510 void __ug_destroy_cb(ui_gadget_h ug, void *priv)
4511 {
4512         cam_debug(LOG_UI, " ");
4513
4514         if (!ug || !priv)
4515                 return;
4516
4517         struct appdata *ad = (struct appdata *)priv;
4518
4519         cam_retm_if(ad == NULL, "appdata is NULL");
4520         ad->ug_is_deleting_process = TRUE;
4521
4522         cam_app_timeout_checker_init(ad);
4523
4524         /* add mouse down event - image viewer bug */
4525         if (ad->black_screen) {
4526                 DEL_EVAS_OBJECT(ad->black_screen);
4527                 ad->black_screen = NULL;
4528         }
4529
4530         if (ad->imageviewer_ug) {
4531                 ug_destroy(ad->imageviewer_ug);
4532                 ad->imageviewer_ug = NULL;
4533         }
4534
4535         elm_win_indicator_mode_set(ad->win_main, 0);
4536         cam_app_start_rotate(ad, false);
4537
4538         ecore_idler_add(__ug_destory_postprocessing, ad);
4539
4540         return;
4541 }
4542
4543 Eina_Bool __ug_destory_postprocessing(void *data)
4544 {
4545         struct appdata *ad = data;
4546         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4547         ad->ug_is_deleting_process = TRUE;
4548         CamAppData *camapp = NULL;
4549         camapp = ad->camapp_handle;
4550         cam_retvm_if(camapp == NULL, FALSE,  "cam_handle is NULL");
4551
4552         cam_app_mouse_event_init(ad);
4553
4554         show_toolbar_edje(ad);
4555
4556         if (!cam_file_check_exists(camapp->filename)) {
4557                 free(camapp->filename);
4558                 camapp->filename = NULL;
4559         }
4560         if (!cam_app_preview_start(ad)) {
4561                 cam_app_notice_popup(ad,
4562                 "PREVIEW START FAIL !!",
4563                  cam_app_timeout_notice_response_cb);
4564         }
4565
4566         if (!cam_key_grab_init(ad))
4567                 DEBUG_TRACE("cam_key_grab_init fail");
4568         cam_app_key_event_init(ad);
4569         /* update thumbnail to quickview after return from image viewer */
4570         cam_app_update_quickview_icon(ad);
4571         cam_file_init(NULL);
4572         ad->ug_is_deleting_process = FALSE;
4573         return ECORE_CALLBACK_CANCEL;
4574
4575
4576 }
4577
4578 gboolean cam_app_run_image_viewer_ug(void *data, char *file_path)
4579 {
4580         DEBUG_TRACE("START");
4581
4582         struct appdata *ad = (struct appdata *)data;
4583
4584         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4585         cam_retvm_if(file_path == NULL, FALSE, "file_path is NULL");
4586
4587         if (ad->ug_is_deleting_process) /*NOTE:before old ug is not deleted completely, should not create new ug*/
4588                 return FALSE;
4589
4590         cam_debug(LOG_UI, " ");
4591         cam_debug(LOG_UI, "path :%s", file_path);
4592
4593         if (ad->imageviewer_ug) {
4594                 return FALSE;/*NOTE: ug is login, not create ug again.*/
4595         }
4596
4597         /* init */
4598         enum ug_option opt;
4599         opt = UG_OPT_INDICATOR_LANDSCAPE_ONLY | UG_OPT_INDICATOR_DISABLE;
4600         UG_INIT_EFL(ad->win_main, opt);
4601
4602         struct ug_cbs cbs = { 0, };
4603
4604         cbs.layout_cb = __ug_layout_cb;
4605         cbs.result_cb = __ug_result_cb;
4606         cbs.destroy_cb = __ug_destroy_cb;
4607         cbs.priv = (void *)data;
4608
4609         /* param */
4610         if (ad->imageviewer_service)
4611                 service_destroy(ad->imageviewer_service);
4612
4613         service_create(&ad->imageviewer_service);
4614
4615         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
4616                 if ((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "contacts") == 0)) {
4617                         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_VIEW_MODE_KEY_NAME, "SETAS");
4618                         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_SET_AS_TYPE, "CallerID");
4619                 } else {
4620                         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_VIEW_MODE_KEY_NAME, "DISPLAY");
4621                 }
4622         } else if (ad->launching_mode == CAM_LAUNCHING_MODE_NORMAL) {
4623                 service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_VIEW_MODE_KEY_NAME, "CAMERA");
4624         }
4625         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_FILE_PATH_KEY_NAME, file_path);
4626
4627         switch (ad->rot_current) {
4628         case APP_DEVICE_ORIENTATION_0:
4629                 elm_win_rotation_with_resize_set(ad->win_main, 0);
4630                 break;
4631         case APP_DEVICE_ORIENTATION_270:
4632         case APP_DEVICE_ORIENTATION_180:
4633                 break;
4634         case APP_DEVICE_ORIENTATION_90:
4635                 elm_win_rotation_with_resize_set(ad->win_main, 90);
4636                 break;
4637         default:
4638                 break;
4639         }
4640
4641         /* Create UI gadget */
4642         ad->imageviewer_ug =
4643             ug_create(NULL, IMAGE_VIEWER_UG_NAME, UG_MODE_FULLVIEW,
4644                       ad->imageviewer_service, &cbs);
4645
4646         if (!ad->imageviewer_ug) {
4647                 cam_critical(LOG_SYS, "image viewer UI Gadget create fail...");
4648                 return FALSE;
4649         } else {
4650
4651                 if (ad->imageviewer_ug) {
4652                         cam_app_key_event_deinit(ad);
4653                         if(!cam_key_grab_deinit(ad)){
4654                                 DEBUG_TRACE("cam_key_grab_deinit fail");
4655                         }
4656                         cam_app_preview_stop();
4657                         power_unlock_state(POWER_STATE_NORMAL);
4658                 } else {
4659                         cam_warning(LOG_UI, "Cannot create imageviewer ug");
4660                         cam_file_init(NULL);
4661                         return FALSE;
4662                 }
4663         }
4664         DEBUG_TRACE("END");
4665
4666         return TRUE;
4667
4668 }
4669
4670 gboolean cam_app_run_media_browser(void *data, gchar *filename)
4671 {
4672         cam_debug(LOG_UI, "filename = %s", filename);
4673         struct appdata *ad = (struct appdata *)data;
4674         CamAppData *camapp = NULL;
4675         int state = 0;
4676
4677         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4678         camapp = ad->camapp_handle;
4679         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4680
4681         debug_fenter(LOG_UI);
4682         ad->launch_type = CAM_LAUNCH_IS_ALREADY_RUNNING;
4683         DEBUG_TRACE("ad->launch_type = %d", ad->launch_type);
4684         state = cam_mm_get_state();
4685         if (state > CAMERA_STATE_PREVIEW) {
4686                 cam_warning(LOG_MM, "Invaild state : %d", state);
4687                 return FALSE;
4688         }
4689         toolbar_hide_setting_popup(ad);
4690         ad->foucs_out_from_quickview = FALSE;
4691
4692         /* del mouse down event - image viewer bug */
4693         cam_app_mouse_event_deinit(ad);
4694         if (!cam_app_run_image_viewer_ug(ad, cam_app_get_last_filename())) {
4695                 DEBUG_TRACE("cam_app_run_image_viewer_ug failed");
4696                 cam_app_mouse_event_init(ad);
4697                 return FALSE;
4698         }
4699
4700         if (camapp->thumbnail_name) {   /*  Some image is deleted from image viewer and galler -> BS  */
4701                 free(camapp->thumbnail_name);
4702                 camapp->thumbnail_name = NULL;
4703         }
4704
4705         cam_app_timeout_checker_remove();
4706         return TRUE;
4707 }
4708
4709 gboolean cam_app_clear_engine_data(void *data, gboolean release)
4710 {
4711         return TRUE;
4712 }
4713
4714 gboolean cam_app_check_wide_resolution(int id)
4715 {
4716
4717         gfloat get_value = (HIWORD(id) * 3.0) / (LOWORD(id) * 4.0);
4718         if (ABS(get_value - 1.0) < CAM_EPSINON
4719             || ABS((gfloat)((HIWORD(id) * 25.0) / (LOWORD(id) * 36.0)) - 1.0) < CAM_EPSINON) {
4720                 return FALSE;
4721         }
4722
4723         return TRUE;
4724
4725 }
4726
4727 gboolean cam_app_is_skip_video_stream()
4728 {                               /*if true , must finish function in stream callback function */
4729         return video_stream_skip_flag;
4730 }
4731
4732 void cam_app_stop_video_stream()
4733 {
4734         video_stream_skip_flag = TRUE;
4735 }
4736
4737 void cam_app_run_video_stream()
4738 {
4739         video_stream_skip_flag = FALSE;
4740 }
4741
4742 Eina_Bool _auto_shot_idle_cb(void *data)
4743 {
4744         debug_fenter(LOG_CAM);
4745         struct appdata *ad = (struct appdata *)data;
4746         CamAppData *camapp = NULL;
4747
4748         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4749         camapp = ad->camapp_handle;
4750         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4751
4752         if (ad->auto_shot_idle) {
4753                 ecore_idler_del(ad->auto_shot_idle);
4754                 ad->auto_shot_idle = NULL;
4755         }
4756
4757         debug_fleave(LOG_CAM);
4758
4759         return ECORE_CALLBACK_CANCEL;
4760 }
4761
4762 gboolean cam_app_create_progressbar(void *data)
4763 {
4764         struct appdata *ad = (struct appdata *)(data);
4765         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4766
4767         cam_debug(LOG_UI, "");
4768
4769         cam_app_destroy_progressbar(ad);
4770
4771         ad->progressbar = elm_progressbar_add(ad->win_main);
4772         cam_retvm_if(ad->progressbar == NULL, FALSE,
4773                      "Cannot create progressbar object\n");
4774
4775         elm_object_style_set(ad->progressbar, "list_progress");
4776         evas_object_size_hint_align_set(ad->progressbar, EVAS_HINT_FILL,
4777                                         EVAS_HINT_FILL);
4778
4779         evas_object_show(ad->progressbar);
4780
4781         return TRUE;
4782 }
4783
4784 gboolean cam_app_set_progressbar_value(void *data, double value)
4785 {
4786         struct appdata *ad = (struct appdata *)(data);
4787         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4788
4789         cam_debug(LOG_UI, " value [%f]", value);
4790
4791         if (ad->progressbar)
4792                 elm_progressbar_value_set(ad->progressbar, value);
4793
4794         return TRUE;
4795 }
4796
4797 gboolean cam_app_set_progressbar_text(void *data, const char *text)
4798 {
4799         struct appdata *ad = (struct appdata *)(data);
4800         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4801
4802         cam_retv_if(text == NULL, FALSE);
4803
4804         if (ad->progressbar_edje)
4805                 edje_object_part_text_set(_EDJ(ad->progressbar_edje),
4806                                           "progressbar_text", text);
4807
4808         return TRUE;
4809 }
4810
4811 gboolean cam_app_destroy_progressbar(void *data)
4812 {
4813         struct appdata *ad = (struct appdata *)(data);
4814         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4815
4816         cam_debug(LOG_UI, " start");
4817         if (ad->progressbar)
4818                 DEL_EVAS_OBJECT(ad->progressbar);
4819         if (ad->progressbar_edje)
4820                 DEL_EVAS_OBJECT(ad->progressbar_edje);
4821
4822         cam_debug(LOG_UI, " done");
4823
4824         return TRUE;
4825 }
4826
4827 #if ENABLE_HAPTIC
4828 void
4829 cam_app_haptic_cb(void *data, Evas_Object *o, const char *emission,
4830                   const char *source)
4831 {
4832         debug_fenter(LOG_UI);
4833         cam_devman_haptic_play(100);
4834 /*      haptic_oneshot(100); */
4835 }
4836 #endif
4837
4838 static gboolean cam_app_timeout_checker_update()
4839 {
4840         struct appdata *ad = NULL;
4841         CamAppData *camapp = NULL;
4842         gdouble c_time = 0.0;
4843         cam_debug(LOG_UI, "");
4844
4845         ad = (struct appdata *)cam_appdata_get();
4846         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4847         camapp = ad->camapp_handle;
4848         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4849
4850         if (ad->timeout_checker) {
4851                 c_time = _get_current_time();
4852                 ecore_timer_delay(ad->timeout_checker,
4853                                   (c_time - camapp->last_time));
4854                 camapp->last_time = c_time;
4855         }
4856
4857         return TRUE;
4858 }
4859 void cam_app_zoom_warring_popup(void *data, const char *msg,
4860                           void (*func) (void *data, Evas_Object *obj, void *event_info))
4861 {
4862         struct appdata *ad = (struct appdata *)(data);
4863         ad->zoom_warring_popup = elm_popup_add(ad->win_main);
4864         evas_object_size_hint_weight_set(ad->zoom_warring_popup, EVAS_HINT_EXPAND,
4865                                          EVAS_HINT_EXPAND);
4866         elm_object_text_set(ad->zoom_warring_popup, msg);
4867         elm_popup_timeout_set(ad->zoom_warring_popup, 3.0);
4868         evas_object_smart_callback_add(ad->zoom_warring_popup, "timeout", func, data);
4869         evas_object_show(ad->zoom_warring_popup);
4870 }
4871 void cam_app_mdm_syspopup(void *data){
4872         struct appdata *ad = (struct appdata *)(data);
4873         cam_retm_if(ad == NULL, " appdata is NULL");
4874         bundle *b = NULL;
4875         b = bundle_create();
4876         if (b != NULL) {
4877                 bundle_add(b, "_SYSPOPUP_CONTENT_", _("IDS_CAM_POP_SECURITY_POLICY_RESTRICTS_USE_OF_CAMERA"));
4878                 syspopup_launch("mdm-syspopup", b);
4879                 bundle_free(b);
4880         }
4881         ecore_idler_add(cam_app_stop,ad);
4882         elm_exit();
4883 }
4884
4885
4886 void cam_app_notice_popup(void *data, const char *msg,
4887                           void (*func) (void *data,
4888                           Evas_Object *obj,
4889                           void *event_info)
4890                           )
4891 {
4892         struct appdata *ad = (struct appdata *)(data);
4893         cam_retm_if(ad == NULL, " appdata is NULL");
4894         cam_retm_if(ad->win_main == NULL, " ad->win_main is NULL");
4895         Evas_Object *popup = NULL;
4896         popup = elm_popup_add(ad->win_main);
4897         if (popup == NULL)
4898                 return;
4899         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
4900                                          EVAS_HINT_EXPAND);
4901         elm_object_text_set(popup, msg);
4902         /*elm_popup_mode_set(popup, ELM_POPUP_TYPE_ALERT);*/
4903         elm_popup_timeout_set(popup, 3.0);
4904         evas_object_smart_callback_add(popup, "timeout", func, data);
4905         ad->waring_popup = popup;
4906         evas_object_show(popup);
4907 }
4908 void cam_app_snapshot_popup(void *data, const char *msg,
4909                           void (*func) (void *data, Evas_Object *obj, void *event_info))
4910 {
4911         struct appdata *ad = (struct appdata *)(data);
4912         cam_retm_if(ad == NULL, " appdata is NULL");
4913         cam_retm_if(ad->win_main == NULL, " ad->win_main is NULL");
4914         Evas_Object *popup = NULL;
4915         popup = elm_popup_add(ad->win_main);
4916         if (popup == NULL)
4917                 return;
4918         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
4919                                          EVAS_HINT_EXPAND);
4920         elm_object_text_set(popup, msg);
4921         /*elm_popup_mode_set(popup, ELM_POPUP_TYPE_ALERT);*/
4922         elm_popup_timeout_set(popup, 1.5);
4923         evas_object_smart_callback_add(popup, "timeout", func, data);
4924         ad->is_showing_snapshot_popup = TRUE; /*result popup is showing*/
4925         DEBUG_TRACE("ad->is_showing_snapshot_popup = TRUE");
4926         evas_object_show(popup);
4927 }
4928
4929 static void cam_app_capture_error_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
4930 {
4931         struct appdata *ad = (struct appdata *)cam_appdata_get();
4932         cam_retm_if(ad == NULL, " appdata is NULL");
4933         CamAppData *camapp = ad->camapp_handle;
4934         cam_retm_if(camapp == NULL, " camapp is NULL");
4935         if (obj)
4936                 evas_object_del(obj);
4937         obj = NULL;
4938         cam_mm_capture_stop(FALSE, camapp->camera_mode);
4939         cam_app_exit(ad);
4940 }
4941
4942 void cam_app_timeout_notice_response_cb(void *data, Evas_Object *obj,
4943                                         void *event_info)
4944 {
4945         struct appdata *ad = (struct appdata *)cam_appdata_get();
4946         cam_retm_if(ad == NULL, " appdata is NULL");
4947         if (obj)
4948                 evas_object_del(obj);
4949         obj = NULL;
4950         cam_app_exit(ad);
4951 }
4952
4953 /*set flash close*/
4954 void cam_close_flash_feature(void *data)
4955 {
4956         struct appdata *ad = (struct appdata *)data;
4957         cam_retm_if(ad == NULL, " appdata is NULL");
4958         CamAppData *camapp = ad->camapp_handle;
4959         cam_retm_if(camapp == NULL, " appdata is NULL");
4960         if (camapp->flash > CAM_FLASH_OFF) {
4961                 GValue value = { 0 };
4962                 CAM_GVALUE_SET_INT(value, CAM_FLASH_OFF);
4963                 gint tempval = g_value_get_int(&value);
4964                 if (!cam_mm_set_flash(tempval)) {
4965                         cam_warning(LOG_UI, "flash set fail");
4966                         return;
4967                 }
4968                 camapp->flash = tempval;
4969         }
4970 }
4971 /*lowbattery callback*/
4972 void cam_app_lowbattery_close_flash_cb(void *data, Evas_Object *obj, void *event_info)
4973 {
4974         struct appdata *ad = (struct appdata *)cam_appdata_get();
4975         cam_retm_if(ad == NULL, " appdata is NULL");
4976         if (obj)
4977                 evas_object_del(obj);
4978         obj = NULL;
4979         cam_close_flash_feature(ad);
4980
4981         cam_toolbar_update(ad);
4982 }
4983
4984 static void cam_app_auto_close_popup_response_ok_cb(void *data, Evas_Object *obj,
4985                                                  void *event_info)
4986
4987 {
4988         struct appdata *ad = (struct appdata *)cam_appdata_get();
4989         cam_retm_if(ad == NULL, " appdata is NULL");
4990
4991         if (ad->auto_close_timer) {
4992                 ecore_timer_del(ad->auto_close_timer);
4993                 ad->auto_close_timer = NULL;
4994         }
4995         cam_app_timeout_checker_remove();
4996         if (ad->auto_close_popup)
4997                 evas_object_del(ad->auto_close_popup);
4998         ad->auto_close_popup = NULL;
4999         cam_app_exit(ad);
5000
5001 }
5002
5003 static void cam_app_auto_close_popup_response_cancel_cb(void *data, Evas_Object *obj,
5004                                                  void *event_info)
5005
5006 {
5007         struct appdata *ad = (struct appdata *)cam_appdata_get();
5008         cam_retm_if(ad == NULL, " appdata is NULL");
5009         if (ad->auto_close_timer) {
5010                 ecore_timer_del(ad->auto_close_timer);
5011                 ad->auto_close_timer = NULL;
5012         }
5013         if (ad->auto_close_popup)
5014                 evas_object_del(ad->auto_close_popup);
5015         ad->auto_close_popup = NULL;
5016         cam_app_timeout_checker_init(ad);
5017 }
5018
5019 void cam_app_auto_close_popup(void *data, const char *msg,
5020                               void (*func) (void *data, Evas_Object *obj,
5021                                             void *event_info))
5022 {
5023         struct appdata *ad = (struct appdata *)(data);
5024         cam_retm_if(ad == NULL, " appdata is NULL");
5025         if (ad->auto_close_popup) {
5026                 evas_object_del(ad->auto_close_popup);
5027                 ad->auto_close_popup = NULL;
5028         }
5029         ad->auto_close_popup = elm_popup_add(ad->win_main);
5030         if (ad->auto_close_popup == NULL)
5031                 return;
5032         evas_object_size_hint_weight_set(ad->auto_close_popup, EVAS_HINT_EXPAND,
5033                                          EVAS_HINT_EXPAND);
5034         elm_popup_timeout_set(ad->auto_close_popup, 9.0);
5035         elm_object_text_set(ad->auto_close_popup, msg);
5036         Evas_Object *btn1 = elm_button_add(ad->auto_close_popup);
5037         if (btn1 == NULL) {
5038                 evas_object_del(ad->auto_close_popup);
5039                 ad->auto_close_popup = NULL;
5040                 return;
5041         }
5042         elm_object_text_set(btn1, dgettext("sys_string", "IDS_COM_SK_OK"));
5043         elm_object_part_content_set(ad->auto_close_popup, "button1", btn1);
5044         evas_object_smart_callback_add(btn1, "clicked", cam_app_auto_close_popup_response_ok_cb, (void*)ad);
5045         Evas_Object *btn2 = elm_button_add(ad->auto_close_popup);
5046         if (btn2 == NULL) {
5047                 evas_object_del(ad->auto_close_popup);
5048                 ad->auto_close_popup = NULL;
5049                 btn1 = NULL;
5050                 return;
5051         }
5052         elm_object_text_set(btn2, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
5053         elm_object_part_content_set(ad->auto_close_popup, "button2", btn2);
5054         evas_object_smart_callback_add(btn2, "clicked", cam_app_auto_close_popup_response_cancel_cb, (void*)ad);
5055
5056         evas_object_show(ad->auto_close_popup);
5057
5058 }
5059
5060 #if 0
5061 static Eina_Bool cam_app_auto_close_task(void *data)
5062 {
5063         DEBUG_TRACE(" ");
5064         int num;
5065         char *str = NULL;
5066         char *msg = _("IDS_CAM_POP_CLOSE_CAMERA_IN_PD_SECONDS");
5067         num = 1+ snprintf(NULL, 0, msg, AUTO_CLOSE_COUNT);
5068         DEBUG_TRACE("%d",num);
5069         str = (char *)malloc(num);
5070         if (str) {
5071                 memset(str, 0x00, num);
5072                 snprintf(str, num, msg, AUTO_CLOSE_COUNT);
5073                 DEBUG_TRACE("%s",str);
5074                 cam_app_auto_close_popup(data, str, NULL);
5075                 free(str);
5076                 str = NULL;
5077         }
5078
5079         return ECORE_CALLBACK_CANCEL;
5080 }
5081 #endif
5082
5083 static Eina_Bool cam_app_auto_close_timer_cb(void *data)
5084 {
5085         struct appdata *ad = (struct appdata *)(data);
5086         CamAppData *camapp = NULL;
5087         gdouble diff = 0.0;
5088         int count = 10;
5089
5090         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
5091         camapp = ad->camapp_handle;
5092         cam_retvm_if(camapp == NULL, 0, "cam_handle is NULL");
5093
5094         diff = _get_current_time() - camapp->last_time;
5095
5096         ad->auto_close_count++;
5097
5098         count = count - ad->auto_close_count;
5099
5100         if ((cam_mm_get_state() == CAMERA_STATE_PREVIEW)
5101             && (diff >= CAMERA_APP_TIMEOUT + 10)) {
5102                 cam_debug(LOG_UI,
5103                           "Quit camera application !!!   diff time : [%lf]",
5104                           diff);
5105                 cam_app_timeout_checker_remove();
5106
5107                 cam_app_exit(ad);
5108
5109                 return ECORE_CALLBACK_CANCEL;
5110         }
5111         cam_debug(LOG_UI, "####diff time : [%lf]", diff);
5112
5113         return 1;
5114
5115 }
5116
5117 static Eina_Bool cam_app_timeout_checker_cb(void *data)
5118 {
5119         struct appdata *ad = (struct appdata *)(data);
5120         CamAppData *camapp = NULL;
5121         gdouble diff = 0.0;
5122
5123         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
5124         camapp = ad->camapp_handle;
5125         cam_retvm_if(camapp == NULL, 0, "cam_handle is NULL");
5126
5127         diff = _get_current_time() - camapp->last_time;
5128
5129         if ((cam_mm_get_state() == CAMERA_STATE_PREVIEW)
5130             && (diff >= CAMERA_APP_TIMEOUT)) {
5131                 cam_debug(LOG_UI,
5132                           "auto close popup is closeed after 10 secondes !!!   diff time : [%lf]",
5133                           diff);
5134                 ad->auto_close_count = 0;
5135                 ad->auto_close_timer =
5136                     ecore_timer_add(1, cam_app_auto_close_timer_cb, ad);
5137 //              ecore_idler_add(cam_app_auto_close_task, ad);
5138
5139         }
5140         cam_debug(LOG_UI, "diff time : [%lf]", diff);
5141         return 1;
5142 }
5143
5144 gboolean cam_app_timeout_checker_init(void *data)
5145 {
5146         struct appdata *ad = (struct appdata *)(data);
5147         CamAppData *camapp = NULL;
5148
5149         debug_fenter(LOG_CAM);
5150
5151         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5152         camapp = ad->camapp_handle;
5153         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
5154
5155         if (ad->timeout_checker) {
5156                 ecore_timer_del(ad->timeout_checker);
5157                 ad->timeout_checker = NULL;
5158         }
5159         if (ad->auto_close_timer) {
5160                 ecore_timer_del(ad->auto_close_timer);
5161                 ad->auto_close_timer = NULL;
5162         }
5163         if (ad->auto_close_popup) {
5164                 evas_object_del(ad->auto_close_popup);
5165                 ad->auto_close_popup = NULL;
5166         }
5167         if (ad->timer_timer) {
5168                 ad->timer_activated = false;
5169                 DEL_EVAS_OBJECT(ad->timer_icon_edje);
5170                 REMOVE_TIMER(ad->timer_timer);
5171         }
5172         ad->timeout_checker =
5173             ecore_timer_add(CAMERA_APP_TIMEOUT / 2, cam_app_timeout_checker_cb,
5174                             ad);
5175         camapp->last_time = _get_current_time();
5176
5177         return TRUE;
5178 }
5179
5180 gboolean cam_app_timeout_checker_remove(void)
5181 {
5182         struct appdata *ad = NULL;
5183         CamAppData *camapp = NULL;
5184
5185         debug_fenter(LOG_CAM);
5186
5187         ad = (struct appdata *)cam_appdata_get();
5188         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5189         camapp = ad->camapp_handle;
5190         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
5191
5192         if (ad->timeout_checker) {
5193                 ecore_timer_del(ad->timeout_checker);
5194                 ad->timeout_checker = NULL;
5195         }
5196         camapp->last_time = 0;
5197
5198         return TRUE;
5199 }
5200
5201 #ifdef USE_FIFO_THREAD
5202 void *cam_app_FIFO_thread_run(void *data)
5203 {
5204         struct appdata *ad = (struct appdata *)data;
5205
5206         int fd = 0;
5207
5208         char buf[128] = { '\0', };
5209
5210         cam_retvm_if(ad == NULL, NULL, "appdata is NULL");
5211
5212         if (!access(CAM_FIFO_PATH, F_OK)) {
5213                 unlink(CAM_FIFO_PATH);
5214         }
5215
5216         if (-1 == mkfifo(CAM_FIFO_PATH, 0666)) {
5217                 cam_critical(LOG_SYS, " Make CamApp FIFO failed.");
5218                 elm_exit();
5219         }
5220
5221         fd = open(CAM_FIFO_PATH, O_RDWR);
5222         if (fd < 0) {
5223                 cam_critical(LOG_SYS, " Open CamApp FIFO failed.");
5224                 elm_exit();
5225         }
5226
5227         cam_debug(LOG_SYS, "Open CamApp FIFO [%s] success", CAM_FIFO_PATH);
5228
5229         while (1) {
5230                 memset(buf, 0x00, 128);
5231
5232                 cam_debug(LOG_SYS, " Wait CamApp FIFO write...");
5233
5234                 int count = read(fd, buf, 128);
5235                 if (count == -1)
5236                         cam_debug(LOG_SYS, " read error occur!");
5237
5238                 cam_debug(LOG_SYS, " Read from CamApp FIFO : [%s]", buf);
5239
5240                 if (!strcmp(buf, CAM_CAPTURE_AUTO_START)) {
5241                         cam_debug(LOG_SYS, " #### Start _auto_shot_idle_cb");
5242                         _auto_shot_idle_cb(data);
5243                 } else if (!strcmp(buf, CAM_FIFO_CMD_EXIT)) {
5244                         break;
5245                 } else {
5246                         /* Error */
5247                         cam_warning(LOG_SYS, " Skip this...");
5248                 }
5249         }
5250
5251         close(fd);
5252         unlink(CAM_FIFO_PATH);
5253
5254         cam_debug(LOG_SYS, " Exit CamApp FIFO thread...");
5255
5256         return NULL;
5257 }
5258
5259 void cam_app_FIFO_thread_exit()
5260 {
5261         int fd = open(CAM_FIFO_PATH, O_WRONLY);
5262         char *str_write = CAM_FIFO_CMD_EXIT;
5263
5264         if (fd < 0) {
5265                 cam_critical(LOG_SYS, " Open CammApp FIFO file[%s] failed",
5266                              CAM_FIFO_PATH);
5267         } else {
5268                 int count = write(fd, str_write, strlen(str_write));
5269                 if (count == -1)
5270                         cam_debug(LOG_SYS, " write error occur! ");
5271                 close(fd);
5272
5273                 cam_debug(LOG_SYS, " Write [%s] to FIFO Done.", str_write);
5274         }
5275 }
5276
5277 #endif
5278
5279 #ifdef USE_FILE_REG_THREAD
5280
5281 gboolean cam_app_create_file_register_thread(void *data)
5282 {
5283         struct appdata *ad = (struct appdata *)data;
5284
5285         int err = 0;
5286         cam_debug(LOG_SYS, "");
5287
5288         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5289
5290         err = pthread_mutex_init(&(ad->file_reg_mutex), NULL);
5291         if (err != 0) {
5292                 cam_critical(LOG_CAM,
5293                              "Create Camera file register mutex failed");
5294                 return FALSE;
5295         }
5296
5297         err = pthread_cond_init(&(ad->file_reg_cond), NULL);
5298         if (err != 0) {
5299                 cam_critical(LOG_CAM,
5300                              "Create Camera file register cond failed");
5301                 return FALSE;
5302         }
5303
5304         ad->file_reg_queue = g_queue_new();
5305         if (ad->file_reg_queue == NULL) {
5306                 cam_critical(LOG_CAM,
5307                              "Create Camera file register queue failed");
5308                 return FALSE;
5309         }
5310
5311         err =
5312             pthread_create(&(ad->file_reg_thread), NULL,
5313                            cam_app_file_register_thread_run, (void *)ad);
5314         if (err != 0) {
5315                 cam_critical(LOG_CAM,
5316                              "Create Camera file register thread failed");
5317                 return FALSE;
5318         }
5319
5320         return TRUE;
5321 }
5322
5323 void *cam_app_file_register_thread_run(void *data)
5324 {
5325         struct appdata *ad = (struct appdata *)data;
5326         gboolean Exit_loop = FALSE;
5327
5328         cam_debug(LOG_FILE, "");
5329
5330         pthread_mutex_lock(&ad->file_reg_mutex);
5331
5332         while (!Exit_loop) {
5333                 cam_debug(LOG_FILE, " wait signal...");
5334
5335                 pthread_cond_wait(&ad->file_reg_cond, &ad->file_reg_mutex);
5336
5337                 cam_debug(LOG_FILE, " signal received");
5338
5339                 while (!g_queue_is_empty(ad->file_reg_queue)) {
5340                         char *filename = NULL;
5341                         filename = g_queue_pop_head(ad->file_reg_queue);
5342
5343                         if (!strcmp(REG_THREAD_EXIT, filename)) {
5344                                 free(filename);
5345                                 Exit_loop = TRUE;
5346                                 break;
5347                         } else {
5348                                 __cam_single_shot_reg_file(filename);
5349                                 free(filename);
5350                                 cam_debug(LOG_FILE, " register done.");
5351                         }
5352                 }
5353         }
5354
5355         pthread_mutex_unlock(&ad->file_reg_mutex);
5356
5357         pthread_mutex_destroy(&ad->file_reg_mutex);
5358         pthread_cond_destroy(&ad->file_reg_cond);
5359
5360         cam_debug(LOG_SYS, " thread exit...");
5361
5362         return NULL;
5363 }
5364
5365 void cam_app_file_register_thread_exit(void *data)
5366 {
5367         struct appdata *ad = (struct appdata *)data;
5368         char *exit_cmd = NULL;
5369
5370         if (ad->file_reg_queue != NULL) {
5371                 exit_cmd = strdup(REG_THREAD_EXIT);
5372                 g_queue_push_tail(ad->file_reg_queue, exit_cmd);
5373                 pthread_cond_signal(&ad->file_reg_cond);
5374         }
5375         return;
5376 }
5377 #endif
5378 gboolean cam_app_init_with_args(void *data)
5379 {
5380         struct appdata *ad = (struct appdata *)data;
5381         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5382         cam_retvm_if(ad->camapp_handle == NULL, FALSE, "camapp is NULL");
5383
5384         cam_debug(LOG_SYS, "");
5385         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
5386                 ad->camapp_handle->camera_mode = ad->exe_args->cam_mode;
5387                 if (CAM_CAMCORDER_MODE == ad->camapp_handle->camera_mode) {
5388                         if (ad->exe_args->resolution == CAM_RESOLUTION_QCIF) {
5389                                 ad->camapp_handle->recording_mode = CAM_RECORD_MMS;
5390                                 ad->camapp_handle->resolution = CAM_RESOLUTION_QCIF;
5391                                 ad->camapp_handle->fps = FPS_SLOW;
5392                                 if (ad->exe_args->size_limit <= 0) {
5393                                         ad->camapp_handle->size_limit = CAM_REC_MMS_MAX_SIZE;
5394                                 } else {
5395                                         ad->camapp_handle->size_limit = ad->exe_args->size_limit;
5396                                 }
5397                                 ad->camapp_handle->size_limit_type = CAM_MM_SIZE_LIMIT_TYPE_BYTE;
5398                         } else {
5399                                 ad->camapp_handle->recording_mode = CAM_RECORD_NORMAL;
5400                                 ad->camapp_handle->resolution = ad->exe_args->resolution;
5401                                 ad->camapp_handle->fps = FPS_DEFAULT;
5402                         }
5403                 } else {
5404                         ad->camapp_handle->shooting_mode = CAM_SINGLE_MODE;
5405                         if (ad->exe_args->width <= 0
5406                             || ad->exe_args->height <= 0) {
5407                                 ad->camapp_handle->resolution = CAM_RESOLUTION_VGA;
5408                         } else {
5409                                 ad->camapp_handle->resolution = CAM_RESOLUTION(ad->exe_args->width, ad->exe_args->height);
5410                         }
5411                         ad->camapp_handle->review = ad->exe_args->review;
5412                 }
5413         } else {
5414                 cam_debug(LOG_SYS, " camera launch mode is normal.");
5415                 return FALSE;
5416         }
5417
5418         cam_debug(LOG_SYS, " done");
5419
5420         return TRUE;
5421 }
5422
5423 Eina_Bool cam_app_focus_guide_create(void *data)
5424 {
5425         struct appdata *ad = (struct appdata *)data;
5426         cam_retv_if(ad == NULL, EINA_FALSE);
5427
5428         DEL_EVAS_OBJECT(ad->focus_edje);
5429
5430         ad->focus_edje =
5431                 cam_app_load_edj(ad->layout_main, CAM_UTILS_EDJ_NAME, "focus_image");
5432         if (ad->focus_edje == NULL) {
5433                 cam_critical(LOG_UI, "focus_edje load failed ");
5434                 return EINA_FALSE;
5435         }
5436
5437         evas_object_resize(ad->focus_edje, ad->camera_focus_w, ad->camera_focus_h);
5438         DEBUG_TRACE("#######################################\n");
5439         DEBUG_TRACE(" MOVE FOCUS_EDJE : %f, %f", ad->af_start_x, ad->af_start_y);
5440         evas_object_move(ad->focus_edje, ad->af_start_x, ad->af_start_y);
5441         evas_object_show(ad->focus_edje);
5442         DEBUG_TRACE("#######################################\n");
5443
5444 #ifdef  CAMERA_MACHINE_I686
5445         evas_object_hide(ad->focus_edje);
5446 #endif
5447
5448         return EINA_TRUE;
5449 }
5450
5451 Eina_Bool cam_app_focus_guide_update(void *data)
5452 {
5453 #ifndef CAMERA_MACHINE_I686
5454         struct appdata *ad = (struct appdata *)data;
5455         cam_retv_if(ad == NULL, EINA_FALSE);
5456
5457         CamAppData *camapp = NULL;
5458
5459         if (ad->focus_edje == NULL) {
5460                 return EINA_FALSE;
5461         }
5462
5463         /*note: relocation the focus edje*/
5464         evas_object_resize(ad->focus_edje, ad->camera_focus_w, ad->camera_focus_h);
5465         evas_object_move(ad->focus_edje, ad->af_start_x, ad->af_start_y);
5466         evas_object_show(ad->focus_edje);
5467
5468         if (ad->setting_ctxpopup
5469                 || (ad->toolbar_show_setting_popup == TRUE)
5470                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)) {
5471                 cam_debug(LOG_UI, "do not need to update focus");
5472                 edje_object_signal_emit(_EDJ(ad->focus_edje), "focus,hide", "program");
5473                 return EINA_FALSE;
5474         }
5475
5476         camapp = ad->camapp_handle;
5477         if (camapp == NULL) {
5478                 return EINA_FALSE;
5479         }
5480         if (ad->mm_state == CAMERA_STATE_CAPTURING
5481                 && camapp->camera_mode == CAM_CAMERA_MODE) {
5482                 return EINA_FALSE;
5483         }
5484         if (ad->mm_state < CAMERA_STATE_PREVIEW || FALSE) {
5485                 edje_object_signal_emit(_EDJ(ad->focus_edje), "focus,hide", "program");
5486                 return EINA_FALSE;
5487         } else {
5488                 DEBUG_TRACE("focus-state = %d, shooting-mode = %d", camapp->focus_state, camapp->shooting_mode);
5489                 if (camapp->recording_mode == CAM_RECORD_SELF
5490                         || camapp->recording_mode == CAM_RECORD_SELF_MMS
5491                         || camapp->shooting_mode == CAM_SELF_MODE) {
5492                         edje_object_signal_emit(_EDJ(ad->focus_edje), "focus,hide", "program");
5493                 } else {
5494                         char signame[30] = { '\0', };
5495                         const char *focus_state_name[4] = {
5496                                 "notready",
5497                                 "notready",
5498                                 "focused",
5499                                 "failed",
5500                         };
5501
5502                         snprintf(signame, sizeof(signame), "%s,%s", "focus", focus_state_name[camapp->focus_state]);
5503
5504                         cam_debug(LOG_UI, "emit signal : %s", signame);
5505                         edje_object_signal_emit(_EDJ(ad->focus_edje), signame, "program");
5506                 }
5507         }
5508 #endif
5509         return EINA_TRUE;
5510 }
5511
5512 static int cam_app_state_manager(int previous, int current, gboolean by_asm)
5513 {
5514         struct appdata *ad = NULL;
5515         CamAppData *camapp = NULL;
5516
5517         cam_info(LOG_UI, "STATE_CHANGED : %d -> %d ", previous, current);
5518
5519         ad = (struct appdata *)cam_appdata_get();
5520         cam_retv_if(ad == NULL, FALSE);
5521
5522         camapp = ad->camapp_handle;
5523         cam_retv_if(camapp == NULL, FALSE);
5524
5525         ad->mm_state = current;
5526
5527         if (camapp->camera_mode == CAM_CAMERA_MODE) {
5528                 if (current == CAMERA_STATE_PREVIEW) {
5529                         if (previous == CAMERA_STATE_CAPTURING) {
5530                                 CAM_TA_ACUM_ITEM_END("    capture stop to preview", 0);
5531                                 CAM_TA_ACUM_ITEM_END("Total capture time", 0);
5532                                 cam_debug(LOG_MM, "capture end, preview start");
5533                         }
5534                 }
5535         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
5536                 if (((previous == RECORDER_STATE_RECORDING)
5537                     && (current != RECORDER_STATE_PAUSED))
5538                     ||((previous == RECORDER_STATE_PAUSED)
5539                     && (current != RECORDER_STATE_RECORDING))) {/*finished recording*/
5540
5541                         cam_info(LOG_UI, "Set gamma NORMAL");
5542                         CamIdlerItem *item = NULL;
5543                         item = (CamIdlerItem *)g_malloc(sizeof(CamIdlerItem));
5544                         if (item == NULL)
5545                                 return FALSE;
5546
5547
5548                         if (camapp->filename)
5549                                 free(camapp->filename);
5550                          cam_mm_get_filename(&camapp->filename,0);/*file size not used,so set to 0*/
5551                          cam_info(LOG_UI, "Recorded file name [%s] ", camapp->filename);
5552
5553                         if (item) {
5554                                 item->data = (void*)ad;
5555                                 item->idler = ecore_idler_add(cam_video_capture_handle_idler, item);
5556
5557                                 if (item->idler)
5558                                         ad->capture_cb_list = g_list_append(ad->capture_cb_list, item->idler);
5559
5560                                 cam_info(LOG_UI, "video capture idler add : %p ", item->idler);
5561                         }
5562
5563                 }
5564
5565         }
5566
5567         return 1;
5568 }
5569
5570 gboolean cam_app_exit(void *data)
5571 {
5572
5573         struct appdata *ad = (struct appdata *)data;
5574         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5575
5576         cam_app_stop(ad);
5577         elm_exit();
5578         return TRUE;
5579 ;
5580 }
5581
5582 static void cam_mmc_state_change_cb(keynode_t *key, void *data)
5583 {
5584         struct appdata *ad = (struct appdata *)data;
5585         CamAppData *camapp = NULL;
5586         int mmc_state = vconf_keynode_get_int(key);
5587
5588         cam_retm_if(ad == NULL, "appdata is NULL");
5589         camapp = ad->camapp_handle;
5590         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
5591
5592         cam_debug(LOG_SYS, " start");
5593
5594         if (mmc_state == VCONFKEY_SYSMAN_MMC_REMOVED
5595             && camapp->storage == CAM_STORAGE_EXTERNAL) {
5596 #ifdef USE_CAM_STORAGE_SETTING
5597                 GValue value = { 0 };
5598 #endif
5599                 int mm_state = cam_mm_get_state();
5600
5601                 if ((mm_state == RECORDER_STATE_RECORDING
5602                     || mm_state == RECORDER_STATE_PAUSED)
5603                     &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
5604                         cam_video_record_cancel(ad);
5605                         cam_app_notice_popup(ad,
5606                                 _("IDS_CAM_POP_REMOVE_MMC_RECORDING"),
5607                                 cam_app_popup_response_cb);
5608                 }
5609 #ifndef CAMERA_MACHINE_I686
5610                 else if (mm_state != CAMERA_STATE_CAPTURING
5611                          &&camapp->camera_mode == CAM_CAMERA_MODE) {
5612                         if (cam_app_check_blocking_popup()) {
5613                                 cam_app_notice_popup(ad,
5614                                         _("IDS_CAM_POP_MEMORY_CARD_REMOVED"),
5615                                         cam_app_popup_response_cb);
5616                         }
5617                 }
5618 #endif
5619
5620 #ifdef USE_CAM_STORAGE_SETTING
5621                 CAM_GVALUE_SET_INT(value, CAM_STORAGE_INTERNAL);
5622                 cam_handle_value_set(ad, PROP_STORAGE, &value);
5623 #endif
5624                 cam_info(LOG_UI, "MMC card is removed");
5625         }
5626         return;
5627 }
5628
5629 #ifdef CAMAPP_SIG_HANDLING
5630 /**
5631 * This function registers a user space signal handler for the signal SIGSEGV (Signal #11)
5632 *
5633 * @return               nothing
5634 */
5635 static void cam_app_register_sigsegv(void)
5636 {
5637         debug_fenter(LOG_SYS);
5638
5639         /* cam_app_act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; */
5640         cam_app_act.sa_flags = SA_SIGINFO;
5641         cam_app_act.sa_handler = (void *)cam_app_sigsegv_handler;
5642         sigemptyset(&cam_app_act.sa_mask);
5643
5644 #ifdef ENABLE_CHECK_CAM_STATUS
5645         sigaction(SIGALRM, &cam_app_act, &cam_app_act_old);     /* register an action with a previous action */
5646 #endif
5647         sigaction(SIGABRT, &cam_app_act, &cam_app_act_old);
5648         sigaction(SIGSEGV, &cam_app_act, &cam_app_act_old);
5649         sigaction(SIGILL, &cam_app_act, &cam_app_act_old);
5650
5651         debug_fleave(LOG_SYS);
5652 }
5653
5654 static void
5655 cam_app_sigsegv_handler(int signal_no, siginfo_t *info, void *context)
5656 {
5657         debug_fenter(LOG_SYS);
5658
5659         cam_debug(LOG_SYS, "signal_no = %d", signal_no);
5660
5661         if (signal_no == SIGALRM) {     /* if alarm, check the camera status. */
5662 #ifdef ENABLE_CHECK_CAM_STATUS
5663                 cam_app_check_status();
5664                 alarm(CAM_CHECK_STATUS_INTERVAL_TIME);
5665 #endif
5666                 return;
5667         } else {
5668                 sigaction(signal_no, &cam_app_act_old, NULL);   /*  register the previous action */
5669                 raise(signal_no);
5670         }
5671
5672         debug_fleave(LOG_SYS);
5673 }
5674
5675 #endif
5676
5677 gboolean cam_app_black_screen_show(void *data, int mode)
5678 {
5679         struct appdata *ad = (struct appdata *)data;
5680         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5681         Evas_Coord witdh = 0, height = 0;
5682
5683         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_black_screen_show", 0);
5684
5685         cam_debug(LOG_UI, "~~~~~~~~~~~ mode :%d", mode);
5686         if (ad->black_screen) {
5687                 evas_object_del(ad->black_screen);
5688                 ad->black_screen = NULL;
5689         } else {
5690                 ad->black_screen =
5691                     cam_app_load_edj(ad->win_main, CAM_MAIN_LAYOUT_EDJ_NAME,
5692                                      "black_screen");
5693                 if (ad->black_screen == NULL) {
5694                         cam_critical(LOG_UI, "black_screen load failed ");
5695                         CAM_TA_ACUM_ITEM_END("      cam_app_black_screen_show",
5696                                              0);
5697                         return FALSE;
5698                 }
5699         }
5700         evas_object_geometry_get(ad->win_main, NULL, NULL, &witdh, &height);
5701         evas_object_resize(ad->black_screen, witdh, height);
5702
5703         evas_object_raise(ad->black_screen);
5704         evas_object_show(ad->black_screen);
5705         evas_object_show(ad->win_main);
5706         evas_render(ad->evas);
5707
5708         CAM_TA_ACUM_ITEM_END("      cam_app_black_screen_show", 0);
5709         return TRUE;
5710 }
5711
5712 gboolean cam_app_black_screen_hide(void *data)
5713 {
5714         struct appdata *ad = (struct appdata *)data;
5715         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5716         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_black_screen_hide", 0);
5717         if (ad->black_screen) {
5718                 evas_object_del(ad->black_screen);
5719                 ad->black_screen = NULL;
5720                 edje_file_cache_flush();
5721         }
5722 /*      evas_render(ad->evas); */
5723         CAM_TA_ACUM_ITEM_END("      cam_app_black_screen_hide", 0);
5724         return TRUE;
5725 }
5726
5727 #ifdef ENABLE_CAPTURE_ANIMATION
5728
5729 static void __cam_app_shutter_animation_finished(void *data, Evas_Object *obj,
5730                                                  const char *emission,
5731                                                  const char *source)
5732 {
5733         cam_debug(LOG_MM, " __cam_app_shutter_animation_finished \n\n ");
5734
5735         struct appdata *ad = (struct appdata *)data;
5736
5737         DEL_EVAS_OBJECT(ad->shutter_screen);
5738
5739 }
5740
5741 static gboolean cam_app_shutter_screen_show(void *data)
5742 {
5743         struct appdata *ad = (struct appdata *)data;
5744         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5745         Evas_Coord witdh = 0, height = 0;
5746
5747         char *group_name = "shutter_image";
5748
5749         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_shutter_screen_show", 0);
5750
5751         if (ad->shutter_screen) {
5752                 evas_object_del(ad->shutter_screen);
5753                 ad->shutter_screen = NULL;
5754         }
5755
5756         ad->shutter_screen =
5757             cam_app_load_edj(ad->win_main, CAM_MAIN_LAYOUT_EDJ_NAME,
5758                              group_name);
5759         if (ad->shutter_screen == NULL) {
5760                 cam_critical(LOG_UI, "shutter_screen load failed ");
5761                 CAM_TA_ACUM_ITEM_END("      cam_app_shutter_screen_show", 0);
5762                 return FALSE;
5763         }
5764
5765         evas_object_geometry_get(ad->win_main, NULL, NULL, &witdh, &height);
5766         evas_object_resize(ad->shutter_screen, witdh, height);
5767         /* evas_object_resize(ad->black_screen, ad->win_width, ad->win_height); */
5768
5769         /*evas_object_lower(ad->shutter_screen);*/
5770         evas_object_show(ad->shutter_screen);
5771         evas_object_show(ad->win_main);
5772 /*       evas_render(ad->evas); */
5773
5774         edje_object_signal_emit(_EDJ(ad->shutter_screen), "start_animation",
5775                                 "");
5776
5777         edje_object_signal_callback_add(_EDJ(ad->shutter_screen),
5778                                         "animation_finish", "*",
5779                                         __cam_app_shutter_animation_finished,
5780                                         ad);
5781
5782 /*      ecore_timer_add(0.1, cam_app_shutter_timer_cb, ad); */
5783
5784         CAM_TA_ACUM_ITEM_END("      cam_app_shutter_screen_show", 0);
5785         return TRUE;
5786 }
5787 #endif
5788 #ifdef ENABLE_CHECK_CAM_STATUS
5789
5790 static void cam_app_check_status()
5791 {
5792         cam_debug(LOG_SYS, "check status");
5793 }
5794 #endif                          /* ENABLE_CHECK_CAM_STATUS */
5795
5796 static int cam_app_preview_unlock(void *data)
5797 {
5798         struct appdata *ad = (struct appdata *)data;
5799         CamAppData *camapp = NULL;
5800         cam_retv_if(ad == NULL, FALSE);
5801
5802         camapp = ad->camapp_handle;
5803         if (camapp == NULL) {
5804                 cam_critical(LOG_UI, "handle is NULL");
5805                 elm_exit();
5806         }
5807
5808         elm_win_indicator_mode_set(ad->win_main, 0);
5809
5810         return 0;
5811 }
5812
5813 static int cam_app_preview_lock(void *data)
5814 {
5815         struct appdata *ad = (struct appdata *)data;
5816
5817         if (ad == NULL) {
5818                 cam_critical(LOG_UI, "handle is NULL");
5819                 elm_exit();
5820         }
5821
5822         evas_object_hide(ad->timer_icon_edje);
5823         REMOVE_TIMER(ad->timer_timer);
5824         ad->timer_activated = false;
5825         DEL_EVAS_OBJECT(ad->timer_icon_edje);
5826         cam_app_timeout_checker_remove();
5827         if(!cam_key_grab_deinit(ad))
5828                 DEBUG_TRACE("cam_key_grab_deinit fail");
5829         cam_app_key_event_deinit(ad);
5830
5831         return 0;
5832 }
5833
5834 static void cam_idle_lockstate_change_cb(keynode_t *key, void *data)
5835 {
5836         struct appdata *ad = (struct appdata *)data;
5837         CamAppData *camapp = NULL;
5838         int cam_state = -1;
5839         int lock_state = vconf_keynode_get_int(key);
5840         cam_retm_if(ad == NULL, "appdata is NULL");
5841         camapp = ad->camapp_handle;
5842         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
5843
5844         cam_debug(LOG_SYS, "#################IDLE LOCK state changed : %d",
5845                   lock_state);
5846         cam_state = cam_mm_get_state();
5847
5848         if (lock_state) {
5849                 DEBUG_TRACE(" ");
5850                 cam_app_preview_lock(ad);
5851         } else if (!lock_state) {
5852                 DEBUG_TRACE(" ");
5853                 cam_app_preview_unlock(ad);
5854         }
5855         return;
5856 }
5857
5858 static void cam_usb_state_change_cb(keynode_t *key, void *data)
5859 {
5860         struct appdata *ad = (struct appdata *)data;
5861         CamAppData *camapp = NULL;
5862         int usb_state = vconf_keynode_get_int(key);
5863         int mm_state = cam_mm_get_state();
5864
5865         cam_retm_if(ad == NULL, "appdata is NULL");
5866         camapp = ad->camapp_handle;
5867         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
5868
5869         if (usb_state > VCONFKEY_SYSMAN_USB_DISCONNECTED
5870             && (mm_state == RECORDER_STATE_RECORDING
5871                 || mm_state == RECORDER_STATE_PAUSED)
5872                 &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
5873                 camapp->rec_stop_type = CAM_REC_STOP_USB_CONN;
5874                 cam_video_record_stop(ad);
5875         }
5876         return;
5877 }
5878
5879 #ifndef DISABLE_TOOLBAR_TOGGLE
5880 static Eina_Bool _cam_app_toolbar_toggle_timer(void *data)
5881 {
5882         struct appdata *ad = (struct appdata *)data;
5883         if (ad == NULL) {
5884                 goto exit_timer;
5885         }
5886         if (ad->mm_state != CAMERA_STATE_PREVIEW) {
5887                 goto exit_timer;
5888         }
5889
5890         ad->toolbar_hided = TRUE;
5891         cam_app_toggle_indicator(ad, TRUE);
5892         cam_app_toggle_toolbar(ad, TRUE);
5893
5894  exit_timer:
5895         if (ad->toolbar_toggle_timer)
5896                 ecore_timer_del(ad->toolbar_toggle_timer);
5897         ad->toolbar_toggle_timer = NULL;
5898         return EINA_FALSE;
5899 }
5900 #endif
5901
5902 void cam_app_toggle_indicator(void *data, gboolean hide)
5903 {
5904 #ifndef DISABLE_INDICATOR
5905         struct appdata *ad = (struct appdata *)data;
5906
5907         cam_retm_if(ad == NULL, "appdata is NULL");
5908
5909         if (ad->toolbar_toggle_timer) {
5910                 REMOVE_TIMER(ad->toolbar_toggle_timer);
5911         }
5912
5913         indicator_toggle(ad, hide);
5914 #endif
5915         return;
5916 }
5917
5918 void cam_app_toggle_toolbar(void *data, gboolean hide)
5919 {
5920 #ifndef DISABLE_TOOLBAR_TOGGLE
5921         struct appdata *ad = (struct appdata *)data;
5922
5923         cam_retm_if(ad == NULL, "appdata is NULL");
5924
5925         if (ad->toolbar_toggle_timer) {
5926                 REMOVE_TIMER(ad->toolbar_toggle_timer);
5927         }
5928
5929         if (hide) {
5930                 /* toolbar_hide_all_popup(ad); */
5931                 unload_settings_edje(ad);
5932                 hide_toolbar_edje(ad);
5933         } else {
5934                 show_toolbar_edje(ad);
5935         }
5936 #endif
5937         return;
5938 }
5939
5940 static void
5941 cam_app_reset_settings_launch_cb(void *data, Evas_Object *obj, void *event_info)
5942 {
5943         Evas_Object *notify = (Evas_Object *)data;
5944         GValue i_value = { 0, };
5945         GValue b_value = { 0, };
5946         struct appdata *ad = (struct appdata *)cam_appdata_get();
5947         CamAppData *camapp = NULL;
5948
5949         cam_debug(LOG_CAM, "!!!!!!!!!cam_app_reset_settings_launch_cb");
5950
5951         cam_retm_if(ad == NULL, " appdata is NULL");
5952         camapp = ad->camapp_handle;
5953         cam_retm_if(camapp == NULL, " cam_handle is NULL");
5954
5955         cam_popup_remove(notify);
5956         hide_toolbar_edje(ad);
5957
5958         cam_mm_preview_stop(camapp->camera_mode);       /* stop preview */
5959
5960         g_value_init(&i_value, G_TYPE_INT);
5961         g_value_init(&b_value, G_TYPE_BOOLEAN);
5962
5963         /* auto focus */
5964
5965         g_value_set_int(&i_value, AF_DEFAULT);
5966         cam_handle_value_set(ad, PROP_AF_MODE, &i_value);
5967
5968         /* Timer */
5969         g_value_set_int(&i_value, TIMER_DEFAULT);
5970         cam_handle_value_set(ad, PROP_TIMER, &i_value);
5971
5972         /* Effect */
5973         g_value_set_int(&i_value, EFFECT_DEFAULT);
5974         cam_handle_value_set(ad, PROP_EFFECT, &i_value);
5975
5976         /* Image quality */
5977         g_value_set_int(&i_value, QUALITY_DEFAULT);
5978         cam_handle_value_set(ad, PROP_IMAGE_QUALITY, &i_value);
5979
5980         /* Video quality */
5981         g_value_set_int(&i_value, QUALITY_DEFAULT);
5982         cam_handle_value_set(ad, PROP_VIDEO_QUALITY, &i_value);
5983
5984         /* Guide Line */
5985         g_value_set_boolean(&b_value, FALSE);
5986         cam_handle_value_set(ad, PROP_GUIDELINE, &b_value);
5987 #ifdef GUIDE_LINE_ENALBE
5988         settings_guideline_refresh(ad);
5989 #endif
5990         /* Review */
5991         g_value_set_boolean(&b_value, FALSE);
5992         cam_handle_value_set(ad, PROP_REVIEW, &b_value);
5993
5994         /* shutter sound */
5995         g_value_set_int(&i_value, SHUTTER_SOUND_DEFAULT);
5996         cam_handle_value_set(ad, PROP_SHUTTER_SOUND, &i_value);
5997
5998         /* audio recording */
5999         g_value_set_boolean(&b_value, TRUE);
6000         cam_handle_value_set(ad, PROP_AUDIO_REC, &b_value);
6001
6002         /* storage */
6003         g_value_set_int(&i_value, STORAGE_DEFAULT);
6004         cam_handle_value_set(ad, PROP_STORAGE, &i_value);
6005
6006         /* Resolution */
6007         if (camapp->camera_mode == CAM_CAMERA_MODE) {
6008                 g_value_set_int(&i_value, IMAGE_RESOLUTION_DEFAULT);
6009         } else {
6010                 g_value_set_int(&i_value, REC_RESOLUTION_DEFAULT);
6011         }
6012
6013         cam_handle_value_set(ad, PROP_RESOLUTION, &i_value);
6014 #ifndef DISABLE_INDICATOR
6015         if (ad->indicator_edje) {
6016                 /* delete indicator */
6017                 evas_object_hide(ad->indicator_edje);
6018                 cam_indicator_destory(ad);
6019         }
6020         cam_indicator_create(ad);
6021 #endif
6022         show_toolbar_edje(ad);
6023         cam_app_preview_start(ad);
6024 }
6025
6026 void cam_app_reset_settings(void *data)
6027 {
6028         struct appdata *ad = (struct appdata *)data;
6029         cam_retm_if(ad == NULL, "appdata is NULL");
6030         cam_popup_question_add(ad->win_main,
6031                                _("IDS_CAM_POP_RESET_CAMERA_SETTINGS"),
6032                                dgettext("sys_string", "IDS_COM_SK_YES"),
6033                                cam_app_reset_settings_launch_cb,
6034                                dgettext("sys_string", "IDS_COM_SK_NO"),
6035                                _popup_cancel_cb);
6036
6037 }
6038
6039 static gboolean __cam_toolbar_new_thumbnail_create(Evas_Object **obj,
6040                                                         struct appdata *ad,
6041                                                         Evas_Coord *thumbnail_x,
6042                                                         Evas_Coord *thumbnail_y,
6043                                                         Evas_Coord *thumbnail_w,
6044                                                         Evas_Coord *thumbnail_h)
6045 {
6046         cam_retv_if(ad == NULL, FALSE);
6047         CamAppData *camapp = ad->camapp_handle;
6048         cam_retv_if(camapp == NULL, FALSE);
6049         cam_retv_if(obj == NULL, FALSE);
6050         cam_retv_if(ad->evas == NULL, FALSE);
6051         cam_retv_if(ad->toolbar.quickview_item.edje == NULL, FALSE);
6052
6053         if(camapp->thumbnail_name == NULL) {
6054                 *obj = NULL;
6055                 return TRUE;
6056         }
6057         Evas_Object *new_thumbnail_img = elm_icon_add(ad->toolbar.quickview_item.edje);
6058         Evas_Coord x = 0, y = 0, w = 0, h = 0;
6059         Evas_Object *layout = NULL;
6060         Evas_Object *thumbnail_area = NULL;
6061
6062         cam_retv_if(new_thumbnail_img == NULL, FALSE);
6063         elm_icon_file_set(new_thumbnail_img, camapp->thumbnail_name, NULL);
6064         elm_icon_aspect_fixed_set(new_thumbnail_img, EINA_FALSE);
6065         elm_icon_resizable_set(new_thumbnail_img, EINA_TRUE, EINA_TRUE);
6066
6067         layout = elm_layout_edje_get(ad->toolbar.quickview_item.edje);
6068         thumbnail_area = (Evas_Object *) edje_object_part_object_get(layout,"thumbnail_area");
6069         cam_retv_if(thumbnail_area == NULL, FALSE);
6070         evas_object_geometry_get(thumbnail_area, &x, &y, &w, &h);
6071         *thumbnail_x = x;
6072         *thumbnail_y = y;
6073         *thumbnail_w = w;
6074         *thumbnail_h = h;
6075
6076         evas_object_resize(new_thumbnail_img, 0, 0);
6077         evas_object_move(new_thumbnail_img, x, y);
6078         evas_object_show(new_thumbnail_img);
6079         *obj = new_thumbnail_img;
6080         return TRUE;
6081 }
6082
6083 static void cam_app_pipe_handler(void *data, void *buffer, unsigned int nbyte)
6084 {
6085
6086         struct appdata *ad = (struct appdata *)data;
6087         cam_retm_if(ad == NULL, "appdata is NULL");
6088         if (buffer) {
6089                 DEBUG_TRACE();
6090                 /* Caution */
6091                 /* DO NOT free buffer in here */
6092                 /* buffer is freed by ecore */
6093
6094                 int main_pipe_type = *((int *)buffer);
6095                 DEBUG_TRACE("main_pipe_type %d", main_pipe_type);
6096                 switch (main_pipe_type) {
6097                 case CAM_MAIN_PIPE_OP_TYPE_UPDATE_THUMBNAIL: {
6098                                 Evas_Object *new_thumbnail_image = NULL;
6099                                 Evas_Coord x = 0, y = 0, w = 0, h = 0;
6100                                 gboolean ret = FALSE;
6101                                 ret = __cam_toolbar_new_thumbnail_create(&new_thumbnail_image, ad, &x, &y, &w, &h);
6102                                 if (ret == FALSE || !new_thumbnail_image) {
6103                                         if (!new_thumbnail_image && ret) {
6104                                                 DEL_EVAS_OBJECT(ad->toolbar.quickview_item.thumbnail_image);
6105                                         }
6106                                         return;
6107                                 }
6108                                 cam_ui_effect_utils_set_thumbnail_effect(new_thumbnail_image,
6109                                                                         x,
6110                                                                         y,
6111                                                                         w,
6112                                                                         h,
6113                                                                         CAM_THUMBNAIL_ANTIMATION_EFFECT_DURATION);
6114                         }
6115                         break;
6116                 case CAM_MAIN_PIPE_OP_TYPE_ROTATE_ANIMATOR: {
6117                                 ad->is_rotating = TRUE;
6118                                 cam_ui_rotate_utils_rotate_start(ad, CAM_ROTATE_ICONS_ANTIMATION_DURATION);
6119                         }
6120                         break;
6121                 default:
6122                         break;
6123                 }
6124         }
6125
6126         return;
6127 }
6128
6129 void cam_focus_edje_rotate(void *data)
6130 {
6131         struct appdata *ad = (struct appdata *)data;
6132         cam_retm_if(ad == NULL, "appdata is NULL");
6133
6134         DEL_EVAS_OBJECT(ad->focus_edje);
6135         ad->focus_edje = cam_app_load_edj(ad->layout_main, CAM_UTILS_EDJ_NAME, "focus_image");
6136
6137         cam_retm_if(ad->focus_edje == NULL, "focus_edje load failed");
6138
6139         evas_object_resize(ad->focus_edje, ad->camera_focus_w, ad->camera_focus_h);
6140         evas_object_move(ad->focus_edje, ad->af_start_x, ad->af_start_y);
6141         evas_object_show(ad->focus_edje);
6142
6143         cam_app_draw_af_box(ad);
6144         cam_app_focus_guide_update(ad);
6145 }
6146
6147
6148 Eina_Bool cam_screen_rotate(void *data)
6149 {
6150         struct appdata *ad = (struct appdata *)data;
6151         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
6152
6153         /*cam_app_get_preview_offset_coordinate(ad);*/
6154
6155         if (ad->focus_edje)
6156                 cam_focus_edje_rotate(ad);
6157
6158         if (ad->timer_icon_edje)
6159                 cam_app_timer_icon_rotate(ad);
6160
6161         if (ad->toolbar_edje)
6162                 cam_toolbar_rotate(ad);
6163
6164         if (ad->recording_edje)
6165                 cam_recording_rotate(ad);
6166
6167         if (ad->indicator_edje) {
6168                 cam_debug(LOG_CAM, "indicator_edje rotate start");
6169                 cam_indicator_rotate(ad);
6170         }
6171
6172         if (ad->zoom_edje) {
6173                 unload_zoom_edje(ad);
6174                 load_zoom_edje(ad);
6175         }
6176
6177 #ifdef GUIDE_LINE_ENALBE
6178         if (ad->guideline_edje)
6179                 settings_guideline_refresh(ad);
6180 #endif
6181
6182         /*update thumbnail*/
6183         toolbar_update_quickview_thumbnail_no_animation(ad);
6184         /* rotate menu */
6185         if ((ad->show_menu == TRUE ) ||
6186                 (ad->show_menu == FALSE && ad->displayed_setting_popup != DISPLAY_NONE_POPUP )
6187                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)
6188                 || (ad->toolbar_show_setting_popup == TRUE)) {
6189                 /*ecore_idler_add(cam_show_setting_menu, ad);*/
6190                 /*note: use timer to delay creating the popup*/
6191                 ecore_timer_add(0.1, cam_show_setting_menu, ad);
6192         } else {
6193                 ad->is_rotating = FALSE;
6194         }
6195
6196         return ECORE_CALLBACK_CANCEL;
6197 }
6198
6199 static Ecore_Idler *rotate_delay_idler = NULL;
6200 Eina_Bool cam_app_screen_rotate_idler(void *data)
6201 {
6202         if (rotate_delay_idler) {
6203                 ecore_idler_del(rotate_delay_idler);
6204                 rotate_delay_idler = NULL;
6205         }
6206         struct appdata *ad = (struct appdata *)data;
6207         cam_retv_if(ad == NULL, ECORE_CALLBACK_CANCEL);
6208         if (ad->appcore_state == CAM_APPCORE_TERMINATE_STATE
6209                 || ad->appcore_state == CAM_APPCORE_PAUSE_STATE) {
6210                 ad->is_rotating = FALSE;
6211                 return ECORE_CALLBACK_CANCEL;
6212         }
6213         /*cam_toolbar_rotate(ad);*/
6214         cam_screen_rotate(ad);
6215         return ECORE_CALLBACK_CANCEL;
6216 }
6217
6218 void cam_app_screen_rotate(void *data)
6219 {
6220         struct appdata *ad = (struct appdata *)data;
6221         cam_ret_if(ad == NULL);
6222         if (ad->appcore_state == CAM_APPCORE_TERMINATE_STATE
6223                 || ad->appcore_state == CAM_APPCORE_PAUSE_STATE) {
6224                 ad->is_rotating = FALSE;
6225                 return;
6226         }
6227         CamAppData *cam_handle = ad->camapp_handle;
6228         cam_ret_if(cam_handle == NULL);
6229         DEBUG_TRACE("");
6230
6231         if (ad->toolbar_edje) {
6232                 rotate_delay_idler = ecore_idler_add(cam_app_screen_rotate_idler, data);
6233
6234         }
6235         /*cam_app_get_preview_offset_coordinate(ad);*/
6236 }
6237
6238 gboolean cam_app_get_resolution(int *width, int *height)
6239 {
6240         cam_retv_if(width == NULL || height == NULL, FALSE);
6241
6242         struct appdata *ad = (struct appdata *)cam_appdata_get();
6243         cam_retvm_if(ad == NULL, FALSE, "ad is NULL");
6244
6245         if (ad != NULL) {
6246                 CamAppData *camapp = ad->camapp_handle;
6247
6248                 if (camapp != NULL) {
6249                         *width = CAM_RESOLUTION_W(camapp->resolution);
6250                         *height = CAM_RESOLUTION_H(camapp->resolution);
6251
6252                         return TRUE;
6253                 }
6254         }
6255
6256         return FALSE;
6257 }
6258
6259 gboolean cam_app_reset_resolution(void *data, int width, int height)
6260 {
6261         struct appdata *ad = (struct appdata *)data;
6262         CamAppData *camapp = NULL;
6263         int state = 0;
6264         gboolean need_change_state = FALSE;
6265         gboolean ret = TRUE;
6266
6267         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6268         camapp = ad->camapp_handle;
6269         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6270
6271         state = cam_mm_get_state();
6272         if (state > CAMERA_STATE_CREATED)
6273                 need_change_state = TRUE;
6274
6275         cam_debug(LOG_MM,
6276                   " reset resolution = [%d x %d], current state = [%d], need_change_state = [%d]",
6277                   width, height, state, need_change_state);
6278
6279         if (camapp->camera_mode == CAM_CAMERA_MODE) {
6280 #ifdef ZSL_5M_TEST
6281                 if (camapp->shooting_mode == CAM_SINGLE_MODE
6282                     && (width * height == ZSL_5M_TEST))
6283 #else
6284                 if (0)          /*  camapp->shooting_mode == CAM_SINGLE_MODE  && (width*height <= ZSL_MAX_REL)) */
6285 #endif
6286                 {
6287                         cam_info(LOG_MM, " set real resolution [%dx%d] for zsl",
6288                                  width, height);
6289
6290                         ret &= cam_mm_set_image_size(width, height);
6291
6292                         if (need_change_state) {
6293                                 ret &= cam_mm_preview_stop(camapp->camera_mode);
6294                                 ret &= cam_mm_unrealize();
6295                                 ret &= cam_mm_set_video_size(width, height);
6296                                 ret &= cam_mm_realize();
6297                                 ret &= cam_app_preview_start(ad);
6298                         } else {
6299                                 ret &= cam_mm_set_video_size(width, height);
6300                         }
6301                 } else {
6302                         if (camapp->shooting_mode == CAM_SELF_MODE) {
6303                                 if (need_change_state) {
6304                                         ret &= cam_mm_preview_stop(CAM_CAMERA_MODE);
6305                                         ret &= cam_mm_set_image_size(width, height);
6306                                         ret &= cam_mm_set_video_size(width, height);
6307                                         ret &= cam_app_preview_start(ad);
6308                                 } else {
6309                                         ret &= cam_mm_set_image_size(width, height);
6310                                         ret &= cam_mm_set_video_size(width, height);
6311                                 }
6312                         } else {
6313                                 int p_width = 0;        /* preview width */
6314                                 int p_height = 0;       /* preview height */
6315
6316                                 ret &= cam_mm_get_video_size(&p_width, &p_height);
6317                                 DEBUG_TRACE("get video size [%d]x[%d]", p_width,
6318                                             p_height);
6319                                         if (p_height == camapp->default_preview_height && (p_width == camapp->default_preview_width || p_width == PREVIEW_WIDE_W)) {
6320                                                 /* assume that last mode is normal capture mode */
6321                                                 int cur_width = 0;
6322                                                 int cur_height = 0;
6323                                                 int temp_width = camapp->default_preview_width;
6324                                                 int temp_height = camapp->default_preview_height;
6325                                                 gboolean cur_is_wide = FALSE;
6326                                                 gboolean next_is_wide = FALSE;
6327
6328                                                 ret &= cam_mm_get_image_size(&cur_width, &cur_height);
6329                                                 cur_is_wide = cam_utils_check_wide_resolution(cur_width, cur_height);
6330                                                 cam_debug(LOG_MM,
6331                                                           "current image Resolution[w] : [%d]x[%d][%d]",
6332                                                           cur_width, cur_height,
6333                                                           cur_is_wide);
6334
6335                                                 next_is_wide = cam_utils_check_wide_resolution(width, height);
6336                                                 cam_debug(LOG_MM,
6337                                                           "next image Resolution[w] : [%d]x[%d][%d]",
6338                                                           width, height, next_is_wide);
6339
6340                                                 if (next_is_wide)
6341                                                         temp_width = PREVIEW_WIDE_W;
6342
6343                                                 ret &= cam_mm_set_image_size(width, height);
6344
6345                                                 if ((cur_is_wide != next_is_wide)
6346                                                     || (temp_width != p_width)) {
6347                                                         if (need_change_state) {
6348
6349                                                                 ret &= cam_mm_preview_stop(camapp->camera_mode);
6350                                                                 ret &= cam_mm_set_video_size(temp_width, temp_height);
6351                                                                 ret &= cam_app_preview_start(ad);
6352                                                         } else {
6353                                                                 ret &= cam_mm_set_video_size(temp_width, temp_height);
6354                                                         }
6355                                                 }
6356                                         } else {
6357                                                 /* assume that last mode is zero system lag capture mode */
6358                                                 int temp_width = camapp->default_preview_width;
6359                                                 int temp_height = camapp->default_preview_height;
6360 #ifdef CAMERA_MACHINE_I686
6361                                                 temp_width = 320;
6362                                                 temp_height = 240;
6363 #endif
6364                                                 if (cam_utils_check_wide_resolution(width, height))
6365                                                         temp_width = PREVIEW_WIDE_W;
6366
6367                                                 ret &= cam_mm_set_image_size(width, height);
6368
6369                                                 if (need_change_state) {
6370                                                         ret &= cam_mm_preview_stop(camapp->camera_mode);
6371                                                         ret &= cam_mm_set_video_size(temp_width, temp_height);
6372                                                         ret &= cam_app_preview_start(ad);
6373                                                 } else {
6374                                                         ret &=
6375                                                             cam_mm_set_video_size(temp_width, temp_height);
6376                                                 }
6377                                         }
6378                         }
6379                 }
6380         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
6381                 if (need_change_state) {
6382                         ret &= cam_mm_preview_stop(CAM_CAMCORDER_MODE);
6383                         ret &= cam_mm_set_video_size(width, height);
6384                         ret &= cam_app_preview_start(ad);
6385                 } else {
6386                                 ret &= cam_mm_set_video_size(width, height);
6387                 }
6388         } else {
6389                 return FALSE;
6390         }
6391         return ret;
6392 }
6393
6394 int cam_app_get_aenc_bitrate(void *data)
6395 {
6396         struct appdata *ad = (struct appdata *)data;
6397         CamAppData *camapp = NULL;
6398         int bitrate = 0;
6399
6400         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
6401         camapp = ad->camapp_handle;
6402         cam_retvm_if(camapp == NULL, 0, "camapp is NULL");
6403
6404         if ((camapp->recording_mode == CAM_RECORD_MMS) ||(camapp->recording_mode == CAM_RECORD_SELF_MMS)) {
6405                 bitrate = CAM_AUDIO_BITRATE_MMS;
6406         } else {
6407                 bitrate = CAM_AUDIO_BITRATE_NORMAL;
6408         }
6409
6410         return bitrate;
6411 }
6412
6413 int cam_app_get_venc_bitrate(void *data, int quality)
6414 {
6415         struct appdata *ad = (struct appdata *)data;
6416         CamAppData *camapp = NULL;
6417         int return_val = 0;
6418
6419         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
6420         camapp = ad->camapp_handle;
6421         cam_retvm_if(camapp == NULL, 0, "camapp is NULL");
6422
6423         if ((camapp->recording_mode == CAM_RECORD_MMS) ||(camapp->recording_mode == CAM_RECORD_SELF_MMS)) {
6424                 switch (quality) {
6425                 case CAM_QUALITY_HIGH:
6426                 case CAM_QUALITY_BEST:
6427                         return_val = 64000;
6428                         break;
6429
6430                 case CAM_QUALITY_MEDIUM:
6431                         return_val = 32000;
6432                         break;
6433
6434                 case CAM_QUALITY_LOW:
6435                         return_val = 16000;
6436                         break;
6437
6438                 default:
6439                         cam_critical(LOG_MM, "INVALID QUAILTY");
6440                         break;
6441                 }
6442         } else {
6443                 switch (camapp->resolution) {
6444                 case CAM_RESOLUTION_FULLHD:
6445                         {
6446                                 switch (quality) {
6447                                 case CAM_QUALITY_HIGH:
6448                                 case CAM_QUALITY_BEST:
6449                                         return_val = 8000000;
6450                                         break;
6451
6452                                 case CAM_QUALITY_MEDIUM:
6453                                         return_val = 4000000;
6454                                         break;
6455
6456                                 case CAM_QUALITY_LOW:
6457                                         return_val = 2000000;
6458                                         break;
6459
6460                                 default:
6461                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6462                                         break;
6463                                 }
6464                         }
6465                         break;
6466                 case CAM_RESOLUTION_HD:
6467                         {
6468                                 switch (quality) {
6469                                 case CAM_QUALITY_HIGH:
6470                                 case CAM_QUALITY_BEST:
6471                                         return_val = 10000000;
6472                                         break;
6473
6474                                 case CAM_QUALITY_MEDIUM:
6475                                         return_val = 4000000;
6476                                         break;
6477
6478                                 case CAM_QUALITY_LOW:
6479                                         return_val = 2000000;
6480                                         break;
6481
6482                                 default:
6483                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6484                                         break;
6485                                 }
6486                         }
6487                         break;
6488
6489                 case CAM_RESOLUTION_WVGA:
6490                 case CAM_RESOLUTION_WVGA2:
6491                         {
6492                                 switch (quality) {
6493                                 case CAM_QUALITY_HIGH:
6494                                 case CAM_QUALITY_BEST:
6495                                         return_val = 4000000;
6496                                         break;
6497
6498                                 case CAM_QUALITY_MEDIUM:
6499                                         return_val = 2000000;
6500                                         break;
6501
6502                                 case CAM_QUALITY_LOW:
6503                                         return_val = 1000000;
6504                                         break;
6505
6506                                 default:
6507                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6508                                         break;
6509                                 }
6510                         }
6511                         break;
6512
6513                 case CAM_RESOLUTION_VGA:
6514
6515                         {
6516                                 switch (quality) {
6517                                 case CAM_QUALITY_HIGH:
6518                                 case CAM_QUALITY_BEST:
6519                                         return_val = 3000000;
6520                                         break;
6521
6522                                 case CAM_QUALITY_MEDIUM:
6523                                         return_val = 1500000;
6524                                         break;
6525
6526                                 case CAM_QUALITY_LOW:
6527                                         return_val = 500000;
6528                                         break;
6529
6530                                 default:
6531                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6532                                         break;
6533                                 }
6534                         }
6535                         break;
6536
6537                 case CAM_RESOLUTION_WQVGA:
6538                         {
6539                                 switch (quality) {
6540                                 case CAM_QUALITY_HIGH:
6541                                 case CAM_QUALITY_BEST:
6542                                         return_val = 2000000;
6543                                         break;
6544
6545                                 case CAM_QUALITY_MEDIUM:
6546                                         return_val = 1000000;
6547                                         break;
6548
6549                                 case CAM_QUALITY_LOW:
6550                                         return_val = 500000;
6551                                         break;
6552
6553                                 default:
6554                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6555                                         break;
6556                                 }
6557                         }
6558                         break;
6559
6560                 case CAM_RESOLUTION_QVGA:
6561                         {
6562                                 switch (quality) {
6563                                 case CAM_QUALITY_HIGH:
6564                                 case CAM_QUALITY_BEST:
6565                                         return_val = 384000;
6566                                         break;
6567
6568                                 case CAM_QUALITY_MEDIUM:
6569                                         return_val = 192000;
6570                                         break;
6571
6572                                 case CAM_QUALITY_LOW:
6573                                         return_val = 64000;
6574                                         break;
6575
6576                                 default:
6577                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6578                                         break;
6579                                 }
6580                         }
6581                         break;
6582
6583                 case CAM_RESOLUTION_QCIF:
6584                         {
6585                                 switch (quality) {
6586                                 case CAM_QUALITY_HIGH:
6587                                 case CAM_QUALITY_BEST:
6588                                         return_val = 384000;
6589                                         break;
6590
6591                                 case CAM_QUALITY_MEDIUM:
6592                                         return_val = 192000;
6593                                         break;
6594
6595                                 case CAM_QUALITY_LOW:
6596                                         return_val = 64000;
6597                                         break;
6598
6599                                 default:
6600                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6601                                         break;
6602                                 }
6603                         }
6604                         break;
6605
6606                 default:
6607                         cam_critical(LOG_MM, "INVALID QUAILTY");
6608                         break;
6609                 }
6610         }
6611
6612         cam_debug(LOG_MM, "videoenc bit rate = %d, current quilty = %d",
6613                   return_val, quality);
6614         return return_val;
6615 }
6616
6617 gboolean cam_app_set_video_quality(void *data, int quality)
6618 {
6619         struct appdata *ad = (struct appdata *)data;
6620         CamAppData *camapp = NULL;
6621         int v_bitrate = 0;
6622
6623         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6624         camapp = ad->camapp_handle;
6625         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6626
6627         v_bitrate = cam_app_get_venc_bitrate(ad, quality);
6628         if (v_bitrate > 0) {
6629                 cam_mm_set_video_encoder_bitrate(v_bitrate);
6630         } else {
6631                 return FALSE;
6632         }
6633
6634         return TRUE;
6635 }
6636 /*TODO:temporily define this*/
6637 #define AUDIO_FORMAT_PCM_S16_LE 2
6638 #define AUDIO_CODEC_VORBIS 36
6639 #define VIDEO_CODEC_THEORA 27
6640
6641 gboolean cam_app_set_recording_mode(void *data, int mode)
6642 {
6643         struct appdata *ad = (struct appdata *)data;
6644         CamAppData *camapp = NULL;
6645         int video_codec = 0, audio_codec = 0, sample_rate = 0;
6646         int format = AUDIO_FORMAT_PCM_S16_LE;
6647         int channel = 0;
6648         int a_bitrate = 0;
6649
6650         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6651         camapp = ad->camapp_handle;
6652         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6653         DEBUG_TRACE("mode = %d" , mode);
6654         if (mode == CAM_RECORD_MMS || mode == CAM_RECORD_SELF_MMS) {
6655                 DEBUG_TRACE("mode = %d" , mode);
6656                 video_codec = RECORDER_VIDEO_CODEC_H263;
6657                 audio_codec = RECORDER_AUDIO_CODEC_AMR;
6658                 sample_rate = 8000;
6659                 format = AUDIO_FORMAT_PCM_S16_LE;
6660                 channel = 1;
6661         } else {
6662                 DEBUG_TRACE("mode = %d" , mode);
6663                 video_codec = RECORDER_VIDEO_CODEC_MPEG4;
6664                 audio_codec = RECORDER_AUDIO_CODEC_AAC;
6665                 sample_rate = 44100;
6666                 format = AUDIO_FORMAT_PCM_S16_LE;
6667                 channel = 2;
6668         }
6669 #ifdef CAMERA_MACHINE_I686
6670         video_codec = VIDEO_CODEC_THEORA;
6671         audio_codec = AUDIO_CODEC_VORBIS;
6672 #endif
6673
6674         if (!cam_mm_set_codec(audio_codec, video_codec))
6675                 return FALSE;
6676
6677         if (!cam_mm_set_audio_source(sample_rate, format, channel))
6678                 return FALSE;
6679
6680         a_bitrate = cam_app_get_aenc_bitrate(ad);
6681         if (a_bitrate > 0) {
6682                 cam_mm_set_audio_encoder_bitrate(a_bitrate);
6683         } else {
6684                 return FALSE;
6685         }
6686
6687         if (!cam_app_set_video_quality(ad, camapp->video_quality))
6688                 return FALSE;
6689
6690         return TRUE;
6691 }
6692
6693 gboolean cam_app_set_size_limit(int max_val, int size_limit_type)
6694 {
6695         int ret = 0;
6696
6697         switch (size_limit_type) {
6698         case CAM_MM_SIZE_LIMIT_TYPE_BYTE:
6699                 ret = cam_mm_set_max_size(max_val);
6700                 if (!ret)
6701                         return FALSE;
6702                 break;
6703         case CAM_MM_SIZE_LIMIT_TYPE_SECOND:
6704                 ret = cam_mm_set_max_size(0);
6705                 if (!ret)
6706                         return FALSE;
6707                 break;
6708         default:
6709                 g_assert_not_reached();
6710         }
6711         return TRUE;
6712 }
6713
6714 gboolean cam_app_init_attribute(void *data, CamMode mode)
6715 {
6716         struct appdata *ad = (struct appdata *)data;
6717         CamAppData *camapp = NULL;
6718         gboolean ret = TRUE;
6719         int width = 0;
6720         int height = 0;
6721         int state = 0;
6722         int rotate = CAMERA_ROTATION_270;
6723         int camera_rotate = CAMERA_ROTATION_NONE;
6724         int video_dev = 0;
6725         int capture_video_format = -1;
6726         #ifdef TODO_SURRPORT
6727         int recording_video_format = -1;
6728         #endif
6729
6730         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6731         camapp = ad->camapp_handle;
6732         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6733
6734         state = cam_mm_get_state();
6735
6736         if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
6737                 if (state != RECORDER_STATE_CREATED) {
6738                         return FALSE;
6739                 }
6740         } else if(camapp->camera_mode == CAM_CAMERA_MODE) {
6741                 if (state != CAMERA_STATE_CREATED) {
6742                         return FALSE;
6743                 }
6744         }
6745
6746         cam_mm_get_video_size( &camapp->default_preview_width, &camapp->default_preview_height);
6747         DEBUG_TRACE("default_width = %d,default_height = %d", camapp->default_preview_width, camapp->default_preview_height);
6748
6749         if (ad->launching_mode == CAM_LAUNCHING_MODE_NORMAL) {
6750                 /* get proper resolution */
6751                 cam_mm_get_image_size(&width, &height);
6752                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
6753                         camapp->resolution = CAM_RESOLUTION(width, height);
6754                 }
6755         }
6756         width = CAM_RESOLUTION_W(camapp->resolution);
6757         height = CAM_RESOLUTION_H(camapp->resolution);
6758
6759 #ifdef CAMERA_MACHINE_I686
6760         width = 320;
6761         height = 240;
6762 #endif
6763
6764         if (CAM_CAMERA_MODE == mode) {
6765                 ret &= cam_mm_set_image_size(width, height);
6766                 ret &= cam_mm_set_image_count(camapp->image_count);
6767 #ifdef CAMERA_MACHINE_I686
6768                 ret &= cam_mm_set_fps(CAMERA_ATTR_FPS_15);
6769                 ret &= cam_mm_set_video_source_format(CAMERA_PIXEL_FORMAT_I420);
6770 #else
6771                 ret &= cam_mm_set_fps(CAMERA_ATTR_FPS_AUTO);
6772                 ret &=
6773                     cam_mm_get_video_source_format
6774                     (NULL,
6775                      &capture_video_format);
6776                 ret &= cam_mm_set_video_source_format(capture_video_format);
6777 #endif
6778                 ret &=
6779                     cam_app_set_capture_format_shooting_mode
6780                     (camapp->shooting_mode);
6781
6782         } else if (CAM_CAMCORDER_MODE == mode) {
6783                 ret &= cam_mm_set_video_profile();
6784 #ifdef CAMERA_MACHINE_I686
6785                 ret &= cam_mm_set_fps(CAMERA_ATTR_FPS_15);
6786                 ret &= cam_mm_set_video_source_format(CAMERA_PIXEL_FORMAT_I420);
6787 #else
6788                 ret &= cam_mm_set_fps(camapp->fps);
6789                 ret &= cam_mm_get_video_source_format(NULL, &recording_video_format);
6790                 ret &= cam_mm_set_video_source_format(recording_video_format);
6791 #endif
6792                 ret &= cam_mm_set_audio_recording(camapp->audio_recording);
6793                 ret &= cam_app_set_recording_mode(ad, camapp->recording_mode);
6794                 DEBUG_TRACE("camapp->size_limit = %d" , camapp->size_limit);
6795                 DEBUG_TRACE("camapp->size_limit_type = %d" , camapp->size_limit_type);
6796                 ret &= cam_app_set_size_limit(camapp->size_limit, camapp->size_limit_type);
6797         } else {
6798                 return FALSE;
6799         }
6800         cam_mm_get_video_device(&video_dev);
6801         DEBUG_TRACE("video_dev = %d",video_dev);
6802         if (video_dev == CAM_DEVICE_VGA) {
6803                 int value;
6804                 cam_mm_get_front_cam_display_rotate_value(&value, &rotate);
6805
6806                 DEBUG_TRACE("get front camera rotate %d value = %d", rotate, value);
6807                 /*rotate = value;*/
6808                 #ifdef TODO_SURRPORT
6809                 rotate = CAMERA_ROTATION_270;
6810                 #endif /*TODO:if new capi will released, this could be removed,but take care.*/
6811
6812         }
6813         cam_mm_get_zoom_valid_intrange(&camapp->zoom_min,&camapp->zoom_max);
6814         DEBUG_TRACE("Zoom range [%d - %d]",camapp->zoom_min, camapp->zoom_max);
6815
6816         ret &= cam_mm_set_display_device(CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(ad->main_xid));
6817         ret &= cam_mm_set_camera_rotate(camera_rotate);
6818         ret &= cam_mm_set_display_rotate(rotate);
6819         ret &= cam_mm_set_display_geometry_method(CAMERA_DISPLAY_MODE_LETTER_BOX);
6820 #ifndef USE_CAMERA_APP_SHUTTER_SOUND
6821         ret &= cam_mm_set_shutter_sound(TRUE);
6822 #endif
6823         ret &= cam_app_reset_resolution(ad, width, height);
6824         ret &= cam_mm_set_zoom(camapp->zoom_min);
6825         ret &= cam_mm_set_effect(camapp->effect);
6826         ret &= cam_mm_set_flash(camapp->flash);
6827         if (camapp->af_mode == CAM_FOCUS_AUTO
6828             || camapp->af_mode == CAM_FOCUS_MACRO) {
6829                 ret &= cam_mm_set_focus_mode(camapp->af_mode);
6830         }
6831
6832         ret &= cam_mm_set_tag_enable(TRUE);
6833
6834         ad->enable_mode_change = TRUE;
6835         ad->is_recording = FALSE;
6836         return ret;
6837
6838 }
6839
6840 static gboolean cam_app_return_ext_app(void *data, const char *r_file_path)
6841 {
6842         struct appdata *ad = (struct appdata *)data;
6843         service_h reply;
6844         service_create(&reply);
6845
6846         if (ad->aul_service_mime != NULL){
6847                 if(r_file_path == NULL){
6848                         service_add_extra_data(reply, SERVICE_DATA_SELECTED, "exit");
6849                         service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_FAILED);
6850                 }else{
6851                         service_add_extra_data(reply, SERVICE_DATA_SELECTED, r_file_path);
6852                         service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_SUCCEEDED);
6853                 }
6854         }
6855
6856         service_destroy(reply);
6857         return TRUE;
6858
6859 }
6860 static void cam_app_battery_status_cb(keynode_t *key, void *data)
6861 {
6862         struct appdata *ad = (struct appdata *)data;
6863
6864         debug_fenter(LOG_UI);
6865         cam_retm_if(ad == NULL, "appdata is NULL");
6866
6867         int low_status = -1;
6868
6869         if (!vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &low_status)) {
6870                 cam_debug(LOG_UI, "battery status low = %d", low_status);
6871                 if (low_status <= VCONFKEY_SYSMAN_BAT_WARNING_LOW) {
6872                         ad->battery_status = LOW_BATTERY_CRITICAL_STATUS;
6873                         cam_app_notice_popup(ad,
6874                                 dgettext("sys_string", "IDS_COM_BODY_LOW_BATTERY"),
6875                          cam_app_timeout_notice_response_cb);
6876                 } else {
6877                         ad->battery_status = NORMAL_BATTERY_STATUS;
6878                 }
6879         }
6880
6881         return;
6882 }
6883 /*if torch light vconf key value is changed, this cb is called*/
6884 static void cam_torchlight_update_cb(keynode_t *key, void *data)
6885 {
6886         struct appdata *ad = (struct appdata *)data;
6887         cam_retm_if(ad == NULL, "appdata is NULL");
6888         int key_value = vconf_keynode_get_bool(key); /* -1: error, 1:True, 0:False */
6889         if (key_value == -1) {
6890                 DEBUG_TRACE("vconf_keynode_get_bool failed");
6891                 return;
6892         }
6893         DEBUG_TRACE("VCONFKEY_SETAPPL_ACCESSIBILITY_TORCH_LIGHT is changed to %d", key_value);
6894         if (key_value) {
6895                 /* disable flash icon */
6896                 ad->torchlight_on = TRUE;
6897
6898         } else {
6899                 /* enable flash icon */
6900                 ad->torchlight_on = FALSE;
6901         }
6902         cam_toolbar_update(ad); /*update flash icon*/
6903         return;
6904 }
6905
6906 static void cam_app_battery_update_cb(keynode_t *key, void *data)
6907 {
6908         struct appdata *ad = (struct appdata *)data;
6909         CamAppData *camapp = NULL;
6910         char *keyname = NULL;
6911
6912         debug_fenter(LOG_UI);
6913
6914         cam_retm_if(ad == NULL, "appdata is NULL");
6915         camapp = ad->camapp_handle;
6916         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
6917
6918         keyname = vconf_keynode_get_name(key);
6919
6920         if (!strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW)) {
6921                 GValue value = { 0 };
6922                 gint charging = vconf_keynode_get_int(key);
6923                 DEBUG_TRACE("charging = %d", charging);
6924                 CAM_GVALUE_SET_INT(value, charging);
6925                 cam_handle_value_set(ad, PROP_BATTERY_CHARG, &value);
6926
6927         } else if (!strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CAPACITY)) {
6928                 GValue value = { 0 };
6929                 int battery_level = vconf_keynode_get_int(key);
6930                 CAM_GVALUE_SET_INT(value, battery_level);
6931                 cam_handle_value_set(ad, PROP_BATTERY_LEVEL, &value);
6932         }
6933         return;
6934 }
6935
6936 Evas_Object *cam_app_create_win(const char *name)
6937 {
6938         Evas_Object *eo = NULL;
6939         int w, h;
6940 #ifdef CAMERA_MACHINE_I686
6941         ecore_evas_app_comp_sync_set(EINA_FALSE);
6942         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
6943         ecore_evas_app_comp_sync_set(1);
6944 #else
6945         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
6946 #endif
6947         if (eo) {
6948                 elm_win_title_set(eo, name);
6949                 elm_win_borderless_set(eo, EINA_TRUE);
6950                 ecore_x_window_size_get(ecore_x_window_root_first_get(),
6951                                         &w, &h);
6952                 evas_object_resize(eo, w, h);
6953         }
6954
6955         return eo;
6956 }
6957
6958 #if 0
6959 Evas_Object *cam_screen_load_edj(Evas_Object *parent, const char *file,
6960                                  const char *group)
6961 {
6962         Evas_Object *eo;
6963         int r;
6964
6965         eo = elm_layout_add(parent);
6966         if (eo) {
6967                 r = elm_layout_file_set(eo, file, group);
6968                 if (!r) {
6969                         evas_object_del(eo);
6970                         return NULL;
6971                 }
6972
6973                 evas_object_size_hint_weight_set(eo,
6974                                                  EVAS_HINT_EXPAND,
6975                                                  EVAS_HINT_EXPAND);
6976
6977                 /*      //if(!strcmp((const char *)elm_widget_type_get(parent), "win")) { */
6978                 elm_win_resize_object_add(parent, eo);
6979                 /*      //} */
6980         }
6981
6982         return eo;
6983 }
6984 #endif
6985 Evas_Object *cam_app_load_edj(Evas_Object *parent, const char *file,
6986                               const char *group)
6987 {
6988         Evas_Object *eo = NULL;
6989         int r = 0;
6990
6991         eo = elm_layout_add(parent);
6992         if (eo) {
6993                 r = elm_layout_file_set(eo, file, group);
6994                 if (!r) {
6995                         evas_object_del(eo);
6996                         return NULL;
6997                 }
6998
6999                 evas_object_size_hint_weight_set(eo,
7000                                                  EVAS_HINT_EXPAND,
7001                                                  EVAS_HINT_EXPAND);
7002
7003                 elm_win_resize_object_add(parent, eo);
7004                 evas_object_show(eo);
7005         }
7006
7007         return eo;
7008 }
7009
7010 void cam_app_update_ts(Evas_Object *parent, struct text_part *tp)
7011 {
7012         int i;
7013         int size = sizeof(tp) / sizeof(tp[0]);
7014         Evas_Object *eo = elm_layout_edje_get(parent);
7015
7016         if (eo == NULL || tp == NULL || size < 0)
7017                 return;
7018
7019         for (i = 0; i < size; i++) {
7020                 if (tp[i].part && tp[i].msgid)
7021                         edje_object_part_text_set(eo,
7022                                                   tp[i].part, _(tp[i].msgid));
7023         }
7024 }
7025
7026 Eina_Bool __cam_app_update_thumbnail_idler(void *data)
7027 {
7028         struct appdata *ad = (struct appdata *)data;
7029         if (!ad) {
7030                 return ECORE_CALLBACK_CANCEL;
7031         }
7032         CamAppData *camapp = ad->camapp_handle;
7033
7034         if (!camapp) {
7035                 REMOVE_IDLER(ad->update_thumbnail_idler);
7036                 return ECORE_CALLBACK_CANCEL;
7037         }
7038
7039         DEBUG_TRACE(" ");
7040
7041         if (!g_file_test(camapp->filename,G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
7042                 DEBUG_TRACE( "The captured File is not existed");
7043                 REMOVE_IDLER(ad->update_thumbnail_idler);
7044                 return ECORE_CALLBACK_CANCEL;;
7045         }
7046
7047         gboolean ret = FALSE;
7048
7049         if (ad->imageviewer_ug) { /*review on */
7050                 DEBUG_TRACE("Image viewer was LAUNCHED. skip this...");
7051                 REMOVE_IDLER(ad->update_thumbnail_idler);
7052                 return ECORE_CALLBACK_CANCEL;;
7053         }
7054
7055         if (camapp->thumbnail_name != NULL) {
7056                 free (camapp->thumbnail_name);
7057                 camapp->thumbnail_name = NULL;
7058
7059         }
7060
7061         ret = cam_file_get_cam_file_thumbnail_path(camapp->filename, &camapp->thumbnail_name);
7062         DEBUG_TRACE("ret[0:success] = [%d] camapp->filename: [%s]",
7063                   ret, camapp->filename);
7064         DEBUG_TRACE("ret[0:success] = [%d] camapp->thumbnail_name: [%s]",
7065                   ret, camapp->thumbnail_name);
7066         if (!g_file_test(camapp->thumbnail_name, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
7067
7068                 if (g_thumbnail_image_check_count > 10) {
7069                         REMOVE_IDLER(ad->update_thumbnail_idler);
7070                         return ECORE_CALLBACK_CANCEL;
7071                 }
7072
7073                 DEBUG_TRACE("The thumbnail File is not existed,try the %d nums", g_thumbnail_image_check_count);
7074                 g_thumbnail_image_check_count++;
7075                 usleep(THUMBNAIL_UPDATE_WAIT_TIME);
7076                 /*REMOVE_IDLER(ad->update_thumbnail_idler);*//*note:renew, do not delete idler*/
7077                 return ECORE_CALLBACK_RENEW;
7078         }
7079 #ifndef ENABLE_CAPTURE_ANIMATION
7080         else {
7081                 DEBUG_TRACE("thumbnail image check count=[%d]", g_thumbnail_image_check_count);
7082                 toolbar_update_quickview_thumbnail(ad);
7083         }
7084 #else
7085         else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
7086                 toolbar_update_quickview_thumbnail(ad);
7087
7088         } else {
7089                 DEBUG_TRACE("NOT REACHED CODES REACHED!");
7090         }
7091 #endif
7092         REMOVE_IDLER(ad->update_thumbnail_idler);
7093         return ECORE_CALLBACK_CANCEL;
7094 }
7095 /* update thumbnail to quickview after first launching or return from image viewer */
7096 void cam_app_update_quickview_icon(void *data)
7097 {
7098 #ifdef CAMERA_MACHINE_I686
7099                 return;
7100 #else
7101         struct appdata *ad = (struct appdata *)data;
7102         cam_ret_if(ad == NULL);
7103         cam_ret_if(ad->camapp_handle == NULL);
7104         gchar *filename = NULL;
7105
7106         DEBUG_TRACE("");
7107         /*To update quickview image, get last filename*/
7108         filename = cam_app_get_last_filename();
7109         if (ad->camapp_handle->filename) {
7110                 free(ad->camapp_handle->filename);
7111                 ad->camapp_handle->filename = NULL;
7112         }
7113         if (filename != NULL) {
7114                 if (ad->camapp_handle->filename) {
7115                         free(ad->camapp_handle->filename);
7116                         ad->camapp_handle->filename = NULL;
7117                 }
7118                 ad->camapp_handle->filename = strdup(filename);
7119                 free(filename);
7120                 filename = NULL;
7121                 if (ad->camapp_handle->thumbnail_name) {
7122                         free(ad->camapp_handle->thumbnail_name);
7123                         ad->camapp_handle->thumbnail_name = NULL;
7124                 }
7125                 /*update quickview area */
7126                 if      (cam_file_get_cam_file_thumbnail_path(ad->camapp_handle->filename,
7127                                                                 &ad->camapp_handle->thumbnail_name))
7128                         toolbar_update_quickview_thumbnail_no_animation(ad);
7129         }
7130
7131         return;
7132 #endif
7133 }
7134
7135 void cam_app_update_thumbnail()
7136 {
7137 #ifdef CAMERA_MACHINE_I686
7138         return;
7139 #else
7140         struct appdata *ad = (struct appdata *)cam_appdata_get();
7141         cam_ret_if(ad == NULL);
7142         CamAppData *camapp = ad->camapp_handle;
7143         cam_ret_if(camapp == NULL);
7144
7145         DEBUG_TRACE("cam_app_update_thumbnail");
7146
7147         if (CAM_LAUNCHING_MODE_NORMAL == ad->launching_mode && camapp->filename) {
7148                 DEBUG_TRACE();
7149                 g_thumbnail_image_check_count = 0;
7150                 if (!ad->update_thumbnail_idler)
7151                         ad->update_thumbnail_idler = ecore_idler_add(__cam_app_update_thumbnail_idler, ad);
7152         }
7153         return;
7154 #endif
7155 }
7156
7157 gboolean cam_app_parse_args(CamExeArgs *args, service_h service)
7158 {
7159         struct appdata *ad = (struct appdata *)cam_appdata_get();
7160         cam_retv_if(ad == NULL, FALSE);
7161
7162         ad->aul_service_mime = NULL;
7163
7164         int ret = service_get_mime(service, &ad->aul_service_mime);
7165         if (ret != SERVICE_ERROR_NONE)
7166         {
7167                 cam_debug(LOG_UI, "service_get_mime is error ");
7168                 return FALSE;
7169         }
7170
7171         if(ad->aul_service_mime != NULL){
7172                 /* get mode */
7173                 if(strcmp(ad->aul_service_mime, AUL_SERVICE_MIME_TYPE_IMAGE) == 0){
7174                         cam_debug(LOG_UI, "CAM_CAMERA_MODE");
7175                         args->cam_mode = CAM_CAMERA_MODE;
7176                 }else if(strcmp(ad->aul_service_mime, AUL_SERVICE_MIME_TYPE_VIDEO) == 0){
7177                         cam_debug(LOG_UI, "CAM_CAMCORDER_MODE");
7178                         args->cam_mode = CAM_CAMCORDER_MODE;
7179                 }
7180         }
7181
7182         const char *val = NULL;
7183         /* get caller appl. */
7184         service_get_extra_data(service, "CALLER", (char **)&val);
7185         if (val) {
7186                 cam_debug(LOG_UI, "CALLER %s", val);
7187                 args->caller = strdup(val);
7188         } else {
7189                 args->caller = NULL;
7190         }
7191
7192         /* resolution */
7193         val = NULL;
7194         service_get_extra_data(service, "RESOLUTION", (char **)&val);
7195         if (val) {
7196                 cam_debug(LOG_UI, "RESOLUTION %s", val);
7197
7198                 int res = 0;
7199
7200                 if (args->cam_mode == CAM_CAMERA_MODE) {
7201                         if (0 == strcmp(val, CAM_CAPTURE_RES_BIG))
7202                                 res = CAM_RESOLUTION_3264x2448;
7203                         else if (0 == strcmp(val, CAM_CAPTURE_RES_BIG_WIDE))
7204                                 res = CAM_RESOLUTION_3264x1836;
7205                         else if (0 == strcmp(val, CAM_CAPTURE_RES_MIDDLE))
7206                                 res = CAM_RESOLUTION_2560x1920;
7207                         else if (0 == strcmp(val, CAM_CAPTURE_RES_MIDDLE_WIDE))
7208                                 res = CAM_RESOLUTION_2560x1536;
7209                         else if (0 == strcmp(val, CAM_CAPTURE_RES_SMALL))
7210                                 res = CAM_RESOLUTION_2560x1920;
7211                         else if (0 == strcmp(val, CAM_CAPTURE_RES_SMALL_WIDE))
7212                                 res = CAM_RESOLUTION_1280x720;
7213                         else if (0 == strcmp(val, CAM_CAPTURE_RES_VGA))
7214                                 res = CAM_RESOLUTION_VGA;
7215                         else
7216                                 res = CAM_RESOLUTION_3264x2448;
7217                 } else {
7218                         if (0 == strcmp(val, CAM_RECORDING_RES_HD))
7219                                 res = CAM_RESOLUTION_HD;
7220                         else if (0 == strcmp(val, CAM_RECORDING_RES_VGA))
7221                                 res = CAM_RESOLUTION_VGA;
7222                         else if (0 == strcmp(val, CAM_RECORDING_RES_QCIF))
7223                                 res = CAM_RESOLUTION_QCIF;
7224                         else
7225                                 res = CAM_RESOLUTION_VGA;
7226                 }
7227
7228                 args->width = CAM_RESOLUTION_W(res);
7229                 args->height = CAM_RESOLUTION_H(res);
7230                 args->resolution = res;
7231         }
7232
7233         /* size limit */
7234         val = NULL;
7235         service_get_extra_data(service, "LIMIT", (char **)&val);
7236         if (val) {
7237                 cam_debug(LOG_UI, "LIMIT %s", val);
7238                 args->size_limit = atoi(val);
7239         } else {
7240                 args->size_limit = 0;
7241         }
7242
7243         /* review */
7244         val = NULL;
7245         service_get_extra_data(service, "REVIEW", (char **)&val);
7246         if (val) {
7247                 if (0 == strcmp(val, "TRUE"))
7248                         args->review = TRUE;
7249                 else
7250                         args->review = FALSE;
7251         } else {
7252                 args->review = FALSE;
7253         }
7254
7255         /*  print exe args */
7256         cam_debug(LOG_SYS, "############### exe args ###############");
7257         cam_debug(LOG_SYS, "mode =%d", args->cam_mode);
7258         cam_debug(LOG_SYS, "caller =%s", args->caller);
7259         cam_debug(LOG_SYS, "width =%d", args->width);
7260         cam_debug(LOG_SYS, "height =%d", args->height);
7261         cam_debug(LOG_SYS, "limit =%d", args->size_limit);
7262         cam_debug(LOG_SYS, "review =%d", args->review);
7263         cam_debug(LOG_SYS, "############### end ###############");
7264
7265         return TRUE;
7266 }
7267
7268
7269 void cam_app_draw_af_box(void *data)
7270 {
7271
7272         cam_retm_if(data == NULL, "data is null");
7273         struct appdata *ad = (struct appdata *)data;
7274         ad->af_start_x = 0;
7275         ad->af_start_y = 0;
7276
7277         switch (ad->rot_current) {
7278         case APP_DEVICE_ORIENTATION_0:
7279                 {
7280                         ad->af_start_x = ad->touch_lcd_x;
7281                         ad->af_start_y = ad->touch_lcd_y;
7282                 }
7283                 break;
7284         case APP_DEVICE_ORIENTATION_180:
7285                 {
7286                         ad->af_start_x = ad->win_height - ad->touch_lcd_x;
7287                         ad->af_start_y = ad->win_width - ad->touch_lcd_y;
7288                 }
7289                 break;
7290         case APP_DEVICE_ORIENTATION_270:
7291                 {
7292                         ad->af_start_x = ad->touch_lcd_y;
7293                         ad->af_start_y = ad->win_height - ad->touch_lcd_x;
7294                 }
7295                 break;
7296         case APP_DEVICE_ORIENTATION_90:
7297                 {
7298                         ad->af_start_x = ad->win_width - ad->touch_lcd_y;
7299                         ad->af_start_y = ad->touch_lcd_x;
7300                 }
7301                 break;
7302         default:
7303                 break;
7304         }
7305
7306         /* adjust */
7307         DEBUG_TRACE("ad->af_start_x=%f, ad->af_start_y=%f", ad->af_start_x,
7308                     ad->af_start_y);
7309         ad->camera_focus_w = CAMERA_FOCUS_W * elm_config_scale_get();
7310         ad->camera_focus_h = CAMERA_FOCUS_H * elm_config_scale_get();
7311         DEBUG_TRACE("ad->camera_focus_w=%f, ad->camera_focus_h=%f",
7312                     ad->camera_focus_w, ad->camera_focus_h);
7313
7314         ad->af_start_x = ad->af_start_x - (ad->camera_focus_w / 2);
7315         ad->af_start_y = ad->af_start_y - (ad->camera_focus_h / 2);
7316         DEBUG_TRACE("af area box start x,y =[%f,%f]\n", ad->af_start_x,
7317                     ad->af_start_y);
7318
7319         if (ad->rot_current == APP_DEVICE_ORIENTATION_270
7320             || ad->rot_current == APP_DEVICE_ORIENTATION_90) {
7321                 if (ad->af_start_x < ad->preview_offset_x) {
7322                         ad->af_start_x = ad->preview_offset_x;
7323                 }
7324                 if (ad->af_start_y < ad->preview_offset_y) {
7325                         ad->af_start_y = ad->preview_offset_y;
7326                 }
7327                 if ((ad->af_start_x + ad->camera_focus_w) >
7328                     (ad->preview_w + ad->preview_offset_x)) {
7329                         ad->af_start_x =
7330                             (ad->preview_w + ad->preview_offset_x) -
7331                             ad->camera_focus_w;
7332                 }
7333                 if ((ad->af_start_y + ad->camera_focus_h) >
7334                     (ad->preview_h + ad->preview_offset_y)) {
7335                         ad->af_start_y =
7336                             (ad->preview_h + ad->preview_offset_y) -
7337                             ad->camera_focus_h;
7338                 }
7339
7340         } else {
7341                 if (ad->af_start_y < ad->preview_offset_x) {
7342                         ad->af_start_y = ad->preview_offset_x;
7343                 }
7344                 if (ad->af_start_x < ad->preview_offset_y) {
7345                         ad->af_start_x = ad->preview_offset_y;
7346                 }
7347                 if ((ad->af_start_y + ad->camera_focus_h) >
7348                     (ad->preview_w + ad->preview_offset_x)) {
7349                         ad->af_start_y =
7350                             (ad->preview_w + ad->preview_offset_x) -
7351                             ad->camera_focus_h;
7352                 }
7353                 if ((ad->af_start_x + ad->camera_focus_w) >
7354                     (ad->preview_h + ad->preview_offset_y)) {
7355                         ad->af_start_x =
7356                             (ad->preview_h + ad->preview_offset_y) -
7357                             ad->camera_focus_w;
7358                 }
7359         }
7360         if (ad->focus_edje) {
7361                 DEBUG_TRACE
7362                     ("####################################################");
7363                 DEBUG_TRACE("af area start ,ad->af_start_x,y =[%f,%f]\n",
7364                             ad->af_start_x, ad->af_start_y);
7365                 DEBUG_TRACE
7366                     ("####################################################");
7367                 evas_object_move(ad->focus_edje, ad->af_start_x,
7368                                  ad->af_start_y);
7369                 DEBUG_TRACE(" MOVE FOCUS_EDJE : %f,%f", ad->af_start_x,
7370                             ad->af_start_y);
7371         }
7372
7373 }
7374
7375
7376 /*  get preview start x,y coordinate */
7377 void cam_app_get_preview_offset_coordinate(void *data)
7378 {
7379
7380         cam_retm_if(data == NULL, "data is null");
7381         struct appdata *ad = (struct appdata *)data;
7382
7383         CamAppData *camapp = ad->camapp_handle;
7384         cam_retm_if(camapp == NULL, "camapp is null");
7385
7386         int width = 0;
7387         int height = 0;
7388         CamVideoRectangle result;       /* result ractangle */
7389         CamVideoRectangle window;       /* target window ractangle */
7390         CamVideoRectangle preview;      /* target preview rectangle */
7391         /*wow,now, the MMHandleType is not created*/
7392         cam_mm_get_video_size(&width, &height);
7393
7394         ad->camfw_video_width = width;
7395         ad->camfw_video_height = height;
7396         preview.w = width;
7397         preview.h = height;
7398         DEBUG_TRACE("************************************************");
7399         DEBUG_TRACE("preview.w =%d, preview.h=%d", preview.w, preview.h);
7400
7401         window.h = ad->win_height;
7402         window.w = ad->win_width;
7403         DEBUG_TRACE("window.w =%d, window.h=%d\n", window.w, window.h);
7404         DEBUG_TRACE("************************************************");
7405         cam_app_preview_start_coordinate(preview, window, &result);
7406
7407         ad->preview_offset_x = result.x;
7408         ad->preview_offset_y = result.y;
7409         ad->preview_w = result.w;
7410         ad->preview_h = result.h;
7411
7412         DEBUG_TRACE("************************************************");
7413         DEBUG_TRACE("ad->preview_offset_x = %d, ad->preview_offset_y = %d",
7414                     ad->preview_offset_x, ad->preview_offset_y);
7415         DEBUG_TRACE("*************************************************");
7416
7417         camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
7418         cam_app_focus_guide_update(ad);
7419
7420         /* init */
7421         ad->af_x = (ad->win_width / 2) - ad->preview_offset_x;
7422         ad->af_y = (ad->win_height / 2) - ad->preview_offset_y;
7423
7424         ad->af_x = (ad->af_x * ad->camfw_video_width) / ad->preview_w;
7425         ad->af_y = (ad->af_y * ad->camfw_video_height) / ad->preview_h;
7426         /* init */
7427         ad->touch_lcd_x = (ad->win_height / 2);
7428         ad->touch_lcd_y = (ad->win_width / 2);
7429
7430         DEBUG_TRACE("*************************************************");
7431         DEBUG_TRACE(" ad->af_x=%d, ad->af_y=%d", ad->af_x, ad->af_y);
7432         DEBUG_TRACE(" ad->af_start_x=%d, ad->af_start_y=%d", ad->af_start_x, ad->af_start_y);
7433         DEBUG_TRACE(" ad->touch_lcd_x=%d, ad->touch_lcd_y=%d", ad->touch_lcd_x,
7434                     ad->touch_lcd_y);
7435         DEBUG_TRACE("*************************************************");
7436
7437         cam_app_draw_af_box(ad);
7438         camapp->focus_mode = CAM_FOCUS_MODE_CONTINUOUS;
7439
7440         if (ad->focus_edje)
7441                 evas_object_show(ad->focus_edje);
7442 }
7443
7444 void cam_app_preview_start_coordinate(CamVideoRectangle src,
7445                                       CamVideoRectangle dst,
7446                                       CamVideoRectangle *result)
7447 {
7448         /* src is target preview rectangle */
7449         /* dst is target window rectangle */
7450         g_return_if_fail(result != NULL);
7451         gdouble src_ratio, dst_ratio;
7452         src_ratio = (gdouble) src.w / src.h;
7453         dst_ratio = (gdouble) dst.w / dst.h;
7454         if (src_ratio > dst_ratio) {
7455                 DEBUG_TRACE("#### case 1\n");
7456                 result->w = dst.w;
7457                 result->h = dst.w / src_ratio;
7458                 result->x = 0;
7459                 result->y = (dst.h - result->h) / 2;
7460         } else if (src_ratio < dst_ratio) {
7461                 DEBUG_TRACE("#### case 2\n");
7462                 result->w = dst.h * src_ratio;
7463                 result->h = dst.h;
7464                 result->x = (dst.w - result->w) / 2;
7465                 result->y = 0;
7466         } else {
7467                 DEBUG_TRACE("#### case 3\n");
7468                 result->x = 0;
7469                 result->y = 0;
7470                 result->w = dst.w;
7471                 result->h = dst.h;
7472         }
7473         DEBUG_TRACE
7474             ("************************************************************");
7475         DEBUG_TRACE
7476             ("source is %dx%d dest is %dx%d, result window size is %dx%d result offset x= %dx y=%d",
7477              src.w, src.h, dst.w, dst.h, result->w, result->h, result->x,
7478              result->y);
7479         DEBUG_TRACE
7480             ("************************************************************");
7481 }
7482
7483
7484 void cam_remove_tmp_file()
7485 {
7486         const gchar *default_path = NULL;
7487         char tmpfile_name[256] = { 0 };
7488
7489         default_path = cam_file_get_internal_video_path();
7490         DEBUG_TRACE(" video = %s", default_path);
7491         snprintf(tmpfile_name, sizeof(tmpfile_name), "%s%s", default_path,
7492                  TMPFILE_PREFIX);
7493         if (g_file_test(tmpfile_name, G_FILE_TEST_EXISTS)) {
7494                 DEBUG_TRACE("REMOVE tmp file");
7495                 unlink(tmpfile_name);
7496         }
7497         default_path = cam_file_get_external_video_path();
7498         DEBUG_TRACE(" video = %s", default_path);
7499         snprintf(tmpfile_name, sizeof(tmpfile_name), "%s%s", default_path,
7500                  TMPFILE_PREFIX);
7501
7502         if (g_file_test(tmpfile_name, G_FILE_TEST_EXISTS)) {
7503                 DEBUG_TRACE("REMOVE tmp file");
7504                 unlink(tmpfile_name);
7505         }
7506
7507 }
7508
7509 Eina_Bool cam_app_launch_after_preview_began(void *data)
7510 {
7511         struct appdata *ad = (struct appdata *)data;
7512         cam_retv_if(ad == NULL, FALSE);
7513
7514         cam_debug(LOG_UI, "cam_app_launch_after_preview_began");
7515
7516         int state = cam_mm_get_state();
7517
7518         if (state != RECORDER_STATE_RECORDING) {
7519                 cam_debug(LOG_UI, "remove previous file");
7520                 cam_remove_tmp_file();
7521         }
7522
7523         cam_app_get_preview_offset_coordinate(data);
7524         cam_toolbar_setting_popup_create(data);
7525         return ECORE_CALLBACK_CANCEL;
7526 }
7527
7528 void cam_utils_remove_idler_all(void *data)
7529 {
7530         struct appdata *ad = (struct appdata *)data;
7531         GList *list = NULL;
7532         Ecore_Idler *idler = NULL;
7533
7534         debug_fenter(LOG_UI);
7535
7536         cam_retm_if(ad == NULL, "appdata is NULL");
7537
7538         /*LOCK
7539            In fact, a Lock is needed here. However, because all related functions are working main loop, practically it may not be needed. */
7540
7541         if (!ad->capture_cb_list) {
7542                 cam_debug(LOG_UI, "No idler is remained.");
7543         } else {
7544                 list = ad->capture_cb_list;
7545
7546                 while (list) {
7547                         idler = list->data;
7548
7549                         if (!idler) {
7550                                 cam_warning(LOG_UI,
7551                                             "Fail to remove idler. The idler is NULL");
7552                         } else {
7553                                 cam_debug(LOG_UI, "Remove idler[%p].", idler);
7554                                 ecore_idler_del(idler);
7555
7556                                 ad->capture_cb_list =
7557                                     g_list_remove(ad->capture_cb_list, idler);
7558                         }
7559
7560                         list = g_list_next(list);
7561                 }
7562
7563                 g_list_free(ad->capture_cb_list);
7564                 ad->capture_cb_list = NULL;
7565         }
7566
7567         /* UNLOCK */
7568         debug_fleave(LOG_UI);
7569         return;
7570 }
7571
7572 Eina_Bool cam_elm_cache_flush()
7573 {
7574 /*Make the canvas discard as much data as possible used by the engine at runtime.*/
7575         DEBUG_TRACE("start");
7576         struct appdata *ad = (struct appdata *)cam_appdata_get();
7577         if (ad) {
7578                 if (ad->evas) {
7579                         evas_render_idle_flush(ad->evas);
7580                 }
7581         }
7582         elm_cache_all_flush();
7583         DEBUG_TRACE("end");
7584         return EINA_TRUE;
7585 }
7586
7587 gboolean cam_condition_check_to_start_camera(void *data)
7588 {
7589         struct appdata *ad = (struct appdata *)data;
7590         cam_retvm_if(ad == NULL, EINA_FALSE, "appdata is NULL");
7591
7592         /* check battery */
7593         if (cam_utils_check_battery_critical_low()) {
7594                 ad->battery_status = LOW_BATTERY_CRITICAL_STATUS;
7595                 cam_app_notice_popup(ad, dgettext("sys_string", "IDS_COM_BODY_LOW_BATTERY"), cam_app_timeout_notice_response_cb);
7596
7597                 return EINA_FALSE;
7598         } else if (cam_utils_check_battery_warning_low()) {
7599                 ad->battery_status = LOW_BATTERY_WARNING_STATUS;
7600         } else {
7601                 ad->battery_status = NORMAL_BATTERY_STATUS;
7602         }
7603
7604         return EINA_TRUE;
7605 }
7606 //end file