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 #ifdef ENABLE_CAM_POWER_CONTROL
3167         power_lock_state(POWER_STATE_SCREEN_OFF, 0);
3168 #endif
3169
3170         debug_fenter(LOG_UI);
3171
3172         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3173         camapp = ad->camapp_handle;
3174         cam_retvm_if(camapp == NULL, FALSE, "camapp_handle is NULL");
3175
3176         if (ad->mm_state < CAMERA_STATE_PREVIEW) {
3177                 goto lock_and_exit;
3178         } else if (ad->mm_state == CAMERA_STATE_PREVIEW) {
3179                 goto lock_and_exit;
3180         } else if (ad->mm_state > CAMERA_STATE_PREVIEW) {
3181                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
3182                         DEBUG_TRACE("camera mode");
3183                 } else {
3184                         camapp->rec_stop_type = CAM_REC_STOP_POWER_KEY;
3185                         if (!cam_video_record_stop(ad)) {
3186                                 DEBUG_TRACE("record stop fail");
3187                         }
3188                 }
3189         }
3190         return TRUE;
3191
3192  lock_and_exit:
3193 #ifdef ENABLE_CAM_POWER_CONTROL
3194         power_unlock_state(POWER_STATE_SCREEN_OFF);
3195 #endif
3196
3197         return TRUE;
3198 }
3199 #if 0
3200 static gboolean __cam_end_key_grab_init(void *data)
3201 {
3202         struct appdata *ad = (struct appdata *)data;
3203         Ecore_X_Display *disp = NULL;
3204
3205         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3206         cam_retvm_if(ad->main_xid <= 0, FALSE, "main_xid <= 0");
3207
3208         disp = ecore_x_display_get();
3209         cam_retvm_if(disp == NULL, FALSE, "ecore_x_display_get fail");
3210
3211         if (utilx_grab_key(disp, ad->main_xid, KEY_END, SHARED_GRAB) == -1) {
3212                 cam_critical(LOG_SYS, "%s key grap fail", KEY_END);
3213         }
3214
3215         return TRUE;
3216 }
3217 #endif
3218 gboolean cam_key_grab_init(void *data)
3219 {
3220         struct appdata *ad = (struct appdata *)data;
3221         Ecore_X_Display *disp = NULL;
3222
3223         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3224         cam_retvm_if(ad->main_xid <= 0, FALSE, "main_xid <= 0");
3225         int success = 0;
3226         int ret = TRUE;
3227
3228         if (ad->isGrabed)
3229                 return TRUE;
3230
3231         DEBUG_TRACE("key_grab_init############################");
3232
3233         ad->cancel_key_press = FALSE;
3234
3235         disp = ecore_x_display_get();
3236         cam_retvm_if(disp == NULL, FALSE, "ecore_x_display_get fail");
3237
3238         /* volume key */
3239         if (utilx_grab_key(disp, ad->main_xid, KEY_VOLUMEUP, TOP_POSITION_GRAB) != success) {
3240                 cam_critical(LOG_SYS, "%s key grap fail", KEY_VOLUMEUP);
3241                 ret = FALSE;
3242         }
3243         if (utilx_grab_key(disp, ad->main_xid, KEY_VOLUMEDOWN, TOP_POSITION_GRAB) != success) {
3244                 cam_critical(LOG_SYS, "%s key grap fail", KEY_VOLUMEDOWN);
3245                 ret = FALSE;
3246         }
3247         /* camera key */
3248         if (utilx_grab_key(disp, ad->main_xid, KEY_CAMERA, TOP_POSITION_GRAB)  != success) {
3249                 cam_critical(LOG_SYS, "%s key grap fail", KEY_CAMERA);
3250                 ret = FALSE;
3251         }
3252         if (utilx_grab_key(disp, ad->main_xid, KEY_CONFIG, TOP_POSITION_GRAB)  != success) {
3253                 cam_critical(LOG_SYS, "%s key grap fail", KEY_CONFIG);
3254                 ret = FALSE;
3255         }
3256         /* power key */
3257         if (utilx_grab_key(disp, ad->main_xid, KEY_POWER, SHARED_GRAB) != success) {
3258                 cam_critical(LOG_SYS, "%s key grap fail", KEY_POWER);
3259                 ret = FALSE;
3260         }
3261
3262         /* etc */
3263         if (utilx_grab_key(disp, ad->main_xid, KEY_SEND, SHARED_GRAB) != success) {
3264                 cam_critical(LOG_SYS, "%s key grap fail", KEY_SEND);
3265                 ret = FALSE;
3266         }
3267         if (utilx_grab_key(disp, ad->main_xid, KEY_END, SHARED_GRAB) != success) {
3268                 cam_critical(LOG_SYS, "%s key grap fail", KEY_END);
3269                 ret = FALSE;
3270         }
3271
3272         ad->isGrabed = TRUE;
3273         return ret;
3274 }
3275
3276 gboolean cam_key_grab_deinit(void *data)
3277 {
3278         struct appdata *ad = (struct appdata *)data;
3279         Ecore_X_Display *disp = NULL;
3280         int success = 0;
3281         int ret = TRUE;
3282
3283         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
3284         cam_retvm_if(ad->main_xid <= 0, FALSE, "main_xid <= 0");
3285
3286         if (!ad->isGrabed)
3287                 return TRUE;
3288         DEBUG_TRACE("key_grab_deinit############################");
3289
3290         disp = ecore_x_display_get();
3291         cam_retvm_if(disp == NULL, FALSE, "ecore_x_display_get fail");
3292
3293         /* volume key */
3294         if (utilx_ungrab_key(disp, ad->main_xid, KEY_VOLUMEUP) != success){
3295                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_VOLUMEUP);
3296                 ret = FALSE;
3297         }
3298         if (utilx_ungrab_key(disp, ad->main_xid, KEY_VOLUMEDOWN) != success){
3299                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_VOLUMEDOWN);
3300                 ret = FALSE;
3301         }
3302
3303         /* camera key */
3304         if (utilx_ungrab_key(disp, ad->main_xid, KEY_CAMERA) != success){
3305                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_CAMERA);
3306                 ret = FALSE;
3307
3308         }
3309         if (utilx_ungrab_key(disp, ad->main_xid, KEY_CONFIG) != success){
3310                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_CONFIG);
3311                 ret = FALSE;
3312         }
3313
3314         /* power key */
3315         if (utilx_ungrab_key(disp, ad->main_xid, KEY_POWER) != success){
3316                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_POWER);
3317                 ret = FALSE;
3318         }
3319         if (utilx_ungrab_key(disp, ad->main_xid, KEY_PAUSE) != success){
3320                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_PAUSE);
3321                 ret = FALSE;
3322         }
3323
3324         /* etc */
3325         if (utilx_ungrab_key(disp, ad->main_xid, KEY_SEND) != success){
3326                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_SEND);
3327                 ret = FALSE;
3328         }
3329         if (utilx_ungrab_key(disp, ad->main_xid, KEY_SELECT) != success){
3330                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_SELECT);
3331                 ret = FALSE;
3332         }
3333         if (utilx_ungrab_key(disp, ad->main_xid, KEY_END) != success){
3334                 cam_critical(LOG_SYS, "%s key ungrap fail", KEY_END);
3335                 ret = FALSE;
3336         }
3337
3338         ad->isGrabed = FALSE;
3339         return ret;
3340 }
3341
3342 gboolean cam_app_mouse_event_init(void *data)
3343 {
3344         struct appdata *ad = (struct appdata *)data;
3345         if (ad == NULL) {
3346                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3347                 return FALSE;
3348         }
3349 #if ENABLE_MOUSE_CONTROL
3350         if (ad->mouse_down == NULL) {
3351                 ad->mouse_down =
3352                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
3353                                             cam_mouse_button_down, ad);
3354         }
3355
3356         if (ad->mouse_up == NULL) {
3357                 ad->mouse_up =
3358                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
3359                                             cam_mouse_button_up, ad);
3360         }
3361 #if 0
3362
3363         if (ad->mouse_move == NULL) {
3364                 ad->mouse_down =
3365                     ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
3366                                             cam_mouse_move, ad);
3367         }
3368 #endif
3369 #endif
3370
3371         return TRUE;
3372 }
3373
3374 gboolean cam_app_mouse_event_deinit(void *data)
3375 {
3376         struct appdata *ad = (struct appdata *)data;
3377         if (ad == NULL) {
3378                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3379                 return FALSE;
3380         }
3381         if (ad->mouse_down) {
3382                 ecore_event_handler_del(ad->mouse_down);
3383                 ad->mouse_down = NULL;
3384         }
3385         if (ad->mouse_up) {
3386                 ecore_event_handler_del(ad->mouse_up);
3387                 ad->mouse_up = NULL;
3388         }
3389         if (ad->mouse_move) {
3390                 ecore_event_handler_del(ad->mouse_move);
3391                 ad->mouse_move = NULL;
3392         }
3393
3394         return TRUE;
3395 }
3396
3397 gboolean cam_app_key_event_init(void *data)
3398 {
3399         struct appdata *ad = (struct appdata *)data;
3400
3401         DEBUG_TRACE("cam_app_key_event_init");
3402
3403         if (ad == NULL) {
3404                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3405                 return FALSE;
3406         }
3407         if (ad->key_down == NULL) {
3408                 ad->key_down =
3409                     ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
3410                                             cam_hard_key_down, ad);
3411         }
3412         if (ad->key_up == NULL) {
3413                 ad->key_up =
3414                     ecore_event_handler_add(ECORE_EVENT_KEY_UP, cam_hard_key_up,
3415                                             ad);
3416         }
3417 #if ENABLE_MOUSE_CONTROL
3418         if (ad->mouse_down == NULL) {
3419                 ad->mouse_down =
3420                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
3421                                             cam_mouse_button_down, ad);
3422         }
3423
3424         if (ad->mouse_up == NULL) {
3425                 ad->mouse_up =
3426                     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
3427                                             cam_mouse_button_up, ad);
3428         }
3429 #if 0
3430
3431         if (ad->mouse_move == NULL) {
3432                 ad->mouse_down =
3433                     ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
3434                                             cam_mouse_move, ad);
3435         }
3436 #endif
3437 #endif
3438
3439         return TRUE;
3440 }
3441
3442 gboolean cam_app_key_event_deinit(void *data)
3443 {
3444         struct appdata *ad = (struct appdata *)data;
3445
3446         DEBUG_TRACE("cam_app_key_event_deinit");
3447
3448         if (ad == NULL) {
3449                 cam_critical(LOG_UI, "appdata is NULL, maybe not created");
3450                 return FALSE;
3451         }
3452         if (ad->key_down) {
3453                 ecore_event_handler_del(ad->key_down);
3454                 ad->key_down = NULL;
3455         }
3456         if (ad->key_up) {
3457                 ecore_event_handler_del(ad->key_up);
3458                 ad->key_up = NULL;
3459         }
3460         if (ad->mouse_down) {
3461                 ecore_event_handler_del(ad->mouse_down);
3462                 ad->mouse_down = NULL;
3463         }
3464         if (ad->mouse_up) {
3465                 ecore_event_handler_del(ad->mouse_up);
3466                 ad->mouse_up = NULL;
3467         }
3468         if (ad->mouse_move) {
3469                 ecore_event_handler_del(ad->mouse_move);
3470                 ad->mouse_move = NULL;
3471         }
3472
3473         return TRUE;
3474 }
3475
3476 Eina_Bool cam_hard_key_down(void *data, int type, void *event_info)
3477 {
3478         struct appdata *ad = (struct appdata *)data;
3479         CamAppData *camapp = NULL;
3480
3481
3482         Ecore_Event_Key *kd = (Ecore_Event_Key *) event_info;
3483
3484         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
3485
3486         cam_debug(LOG_UI, "Key name : %s", kd->keyname);
3487
3488         camapp = ad->camapp_handle;
3489         cam_retvm_if(camapp == NULL, -1, "camapp_handle is NULL");
3490
3491         ad->show_menu = FALSE;
3492         ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
3493         cam_toolbar_and_setting_popup_del(ad);
3494
3495         cam_app_timeout_checker_update();
3496
3497         /*  Camera key Press */
3498         if (0 == strcmp(kd->keyname, KEY_CANCEL)) {
3499                 ad->cancel_key_press = TRUE;
3500         }
3501         if (0 == strcmp(kd->keyname, KEY_CONFIG)) {     /* camera key - full */
3502                 if (!camapp->key_lock) {
3503                         camapp->key_lock = TRUE;
3504                         CAM_TA_ACUM_ITEM_BEGIN("Total capture time", 0);
3505                         CAM_TA_ACUM_ITEM_BEGIN
3506                             ("        camera key to capture start", 0);
3507                         if (!cam_camera_key_press(ad)) {
3508                                 cam_warning(LOG_UI,
3509                                             "cam_camera_key_press failed");
3510                         }
3511                         camapp->key_lock = FALSE;
3512                 }
3513         }
3514         /*  Camera key HALF press */
3515         else if (0 == strcmp(kd->keyname, KEY_CAMERA)) {        /* camera key - half */
3516                 if (!camapp->key_lock) {
3517                         camapp->key_lock = TRUE;
3518                         ad->displayed_setting_popup = DISPLAY_NONE_POPUP;
3519                         ad->show_menu = FALSE;
3520                         cam_toolbar_and_setting_popup_del(ad);
3521
3522                         if (!cam_camera_key_half_press(ad)) {
3523                                 cam_warning(LOG_UI,
3524                                             "cam_camera_key_half_press failed");
3525                         }
3526                         camapp->key_lock = FALSE;
3527                 }
3528         } else if (0 == strcmp(kd->keyname, KEY_VOLUMEUP)) {
3529                 if (!camapp->key_lock) {
3530                         camapp->key_lock = TRUE;
3531                         ad->up_key = TRUE;
3532                         cam_add_longpress_key_timer(ad);
3533                         camapp->key_lock = FALSE;
3534                 }
3535         } else if (0 == strcmp(kd->keyname, KEY_VOLUMEDOWN)) {
3536                 if (!camapp->key_lock) {
3537                         camapp->key_lock = TRUE;
3538                         ad->up_key = FALSE;
3539                         cam_add_longpress_key_timer(ad);
3540                         camapp->key_lock = FALSE;
3541                 }
3542         } else if (0 == strcmp(kd->keyname, KEY_SELECT)) {
3543
3544         } else if ((0 == strcmp(kd->keyname, KEY_SELECT))
3545                    && ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
3546                 if (!camapp->key_lock) {
3547                         camapp->key_lock = TRUE;
3548                 }
3549         }
3550 #ifdef ENABLE_CAM_POWER_CONTROL
3551         else if (0 == strcmp(kd->keyname, KEY_POWER)) {
3552                 if (!camapp->key_lock) {
3553                         camapp->key_lock = TRUE;
3554                         power_unlock_state(POWER_STATE_NORMAL);
3555                         cam_power_key_press(ad);
3556                         camapp->key_lock = FALSE;
3557
3558                 }
3559         }
3560 #endif
3561         return 0;
3562 }
3563
3564 Eina_Bool cam_hard_key_up(void *data, int type, void *event_info)
3565 {
3566         struct appdata *ad = (struct appdata *)data;
3567         CamAppData *camapp = NULL;
3568
3569         Ecore_Event_Key *kd = (Ecore_Event_Key *) event_info;
3570         cam_retv_if(ad == NULL, ECORE_CALLBACK_CANCEL);
3571
3572         cam_debug(LOG_UI, "Key name : %s", kd->keyname);
3573
3574         camapp = ad->camapp_handle;
3575         cam_retv_if(camapp == NULL, ECORE_CALLBACK_CANCEL);
3576
3577         cam_app_timeout_checker_update();
3578
3579         if (0 == strcmp(kd->keyname, KEY_CANCEL)) {
3580                 ad->cancel_key_press = FALSE;
3581         }
3582
3583         if(ad->cancel_key_press == TRUE) {
3584                 if (ad->longpress_timer) { /*volume key long press */
3585                         cam_del_longpress_key_timer(ad);
3586                         cam_volume_key_press(ad);
3587                 }
3588                 return FALSE;
3589         }
3590
3591
3592         if (0 == strcmp(kd->keyname, KEY_CONFIG)) {     /* camera key - full  */
3593                 if (!camapp->key_lock) {
3594                         camapp->key_lock = TRUE;
3595                         if (!cam_camera_key_release(ad)) {
3596                                 cam_warning(LOG_UI,
3597                                             "cam_camera_key_release failed");
3598                         }
3599                         camapp->key_lock = FALSE;
3600                 }
3601         } else if (0 == strcmp(kd->keyname, KEY_CAMERA)) {      /* camera key - half */
3602                 if (!camapp->key_lock) {
3603                         camapp->key_lock = TRUE;
3604                         if (!cam_camera_key_half_release(ad)) {
3605                                 cam_warning(LOG_UI,
3606                                             "cam_camera_key_release failed");
3607                         }
3608                         camapp->key_lock = FALSE;
3609                 }
3610         } else if (0 == strcmp(kd->keyname, KEY_VOLUMEUP)
3611                    || 0 == strcmp(kd->keyname, KEY_VOLUMEDOWN)) {
3612                 if (!camapp->key_lock) {
3613                         camapp->key_lock = TRUE;
3614                         cam_del_longpress_key_timer(ad);
3615                         cam_volume_key_press(ad);
3616                         camapp->key_lock = FALSE;
3617                 }
3618         } else if (0 == strcmp(kd->keyname, KEY_END)
3619                    || 0 == strcmp(kd->keyname, KEY_SELECT)) {
3620
3621                 DEBUG_TRACE("camapp->key_lock = %d", camapp->key_lock);
3622                 if (!camapp->key_lock) {
3623                         camapp->key_lock = TRUE;
3624
3625                         if ( ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
3626
3627                                 int mm_state = 0;
3628                                 mm_state = cam_mm_get_state();
3629                                 ad->appcore_state = CAM_APPCORE_PAUSE_STATE;
3630                                 if (mm_state < CAMERA_STATE_CAPTURING) {
3631                                         cam_app_exit(ad);
3632                                 }
3633                                 return 0;
3634                         }
3635
3636                         if (ad->imageviewer_ug) {
3637                                 DEBUG_TRACE("destory imageviewer");
3638                                 cam_app_close_ug(ad);
3639                                 cam_app_start_rotate(ad, false);
3640                                 cam_app_key_event_deinit(ad);
3641                                 if(!cam_key_grab_deinit(ad))
3642                                         DEBUG_TRACE("cam_key_grab_deinit fail");
3643                                 ad->foucs_out_from_quickview = FALSE;
3644                         }
3645                         if ((ad->mm_state == RECORDER_STATE_RECORDING
3646                             || ad->mm_state == RECORDER_STATE_PAUSED)
3647                             &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
3648                                 camapp->rec_stop_type = CAM_REC_STOP_NORMAL;
3649                                 ad->recording_commit = ecore_idler_add(cam_video_idler_record_stop, ad);
3650                                 camapp->key_lock = FALSE;
3651                                 return 0;
3652                         } else if (ad->mm_state == CAMERA_STATE_CAPTURING
3653                         &&camapp->camera_mode == CAM_CAMERA_MODE) {
3654                                 camapp->key_lock = FALSE;
3655                                 return 0;
3656                         } else if ((ad->mm_state == RECORDER_STATE_READY
3657                         &&camapp->camera_mode == CAM_CAMERA_MODE)
3658                         ||(ad->mm_state == CAMERA_STATE_PREVIEW
3659                         &&camapp->camera_mode == CAM_CAMCORDER_MODE)) {
3660                                 ;
3661                         }
3662                         if (0 == strcmp(kd->keyname, KEY_END)) {
3663                                 cam_debug(LOG_UI, " Key up : END Key");
3664                                 /*cam_app_exit(ad);*/
3665                                 /*camapp->key_lock = FALSE;*/
3666                         }
3667                         camapp->key_lock = FALSE;
3668
3669                 } else {
3670                         cam_debug(LOG_UI, "key lock status = %d",
3671                                   camapp->key_lock);
3672                 }
3673         }
3674
3675         return 0;
3676 }
3677
3678 /*note: focus edje zoom in*/
3679 static void __cam_app_set_focus_zoom_in_effect(void *data)
3680 {
3681         struct appdata *ad = (struct appdata *)data;
3682         cam_retm_if(ad == NULL, "appdata is NULL");
3683
3684         if (ad->camapp_handle->enable_touch_af == TRUE) {
3685                 REMOVE_TIMER(ad->continuous_af_timer);
3686                 cam_camera_touch_af_press(ad);
3687         } else {
3688                 cam_app_draw_af_box(ad);
3689                 evas_object_show(ad->focus_edje);
3690                 cam_ui_effect_utils_set_zoom_effect(ad->focus_edje,
3691                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_START_RATE,
3692                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_END_RATE,
3693                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_DURATION);
3694         }
3695 }
3696
3697 /*note: focus edje zoom out*/
3698 static void __cam_app_set_focus_zoom_out_effect(void *data)
3699 {
3700         struct appdata *ad = (struct appdata *)data;
3701         cam_retm_if(ad == NULL, "appdata is NULL");
3702
3703         if (ad->camapp_handle->enable_touch_af == TRUE) {
3704                 REMOVE_TIMER(ad->continuous_af_timer);
3705                 cam_camera_touch_af_press(ad);
3706         } else {
3707                 cam_app_draw_af_box(ad);
3708                 evas_object_show(ad->focus_edje);
3709                 cam_ui_effect_utils_set_zoom_effect(ad->focus_edje,
3710                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_END_RATE,
3711                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_START_RATE,
3712                                                         CAM_FOCUS_EDJE_ZOOM_EFFECT_DURATION);
3713         }
3714 }
3715
3716 #if ENABLE_MOUSE_CONTROL
3717 Eina_Bool cam_mouse_button_down(void *data, int type, void *event_info)
3718 {
3719         struct appdata *ad = (struct appdata *)data;
3720         cam_retvm_if(ad == NULL, EINA_FALSE, "appdata is NULL");
3721         CamAppData *camapp = ad->camapp_handle;
3722         cam_retvm_if(camapp == NULL, EINA_FALSE, "camapp_handle is NULL");
3723
3724         if (ad->zoom_edje
3725                 || ad->setting_ctxpopup
3726                 || (ad->toolbar_show_setting_popup == TRUE)
3727                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)) {
3728                 cam_debug(LOG_UI, "ignore touch event");
3729                 ad->af_outside = TRUE;
3730         }
3731
3732         int toolbar_width = TOOLBAR_W;
3733
3734         Ecore_Event_Mouse_Button *md = (Ecore_Event_Mouse_Button *) event_info;
3735         cam_debug(LOG_UI, "mouse button down[%d, %d]", md->root.x, md->root.y);
3736
3737         ad->touch_lcd_x = md->root.x;   /* LCD x */
3738         ad->touch_lcd_y = md->root.y;   /* LCD y */
3739
3740         ad->af_outside = FALSE;
3741
3742         /* x */
3743         if (ad->touch_lcd_y < toolbar_width
3744             || ad->touch_lcd_y > (ad->win_width - toolbar_width)) {
3745                 ad->af_outside = TRUE;
3746         } else {
3747                 ad->af_x = ad->touch_lcd_y - ad->preview_offset_x;
3748         }
3749         /* y */
3750         if (ad->touch_lcd_x < ad->preview_offset_y
3751             || ad->touch_lcd_x > (ad->preview_h + ad->preview_offset_y)) {
3752                 ad->af_outside = TRUE;
3753         } else {
3754                 ad->af_y = ad->preview_h - ad->touch_lcd_x;
3755         }
3756
3757         ad->af_x = (ad->af_x * ad->camfw_video_width) / ad->preview_w;
3758         ad->af_y = (ad->af_y * ad->camfw_video_height) / ad->preview_h;
3759         DEBUG_TRACE
3760             ("*************************************************************************************");
3761         DEBUG_TRACE("touched lcd x,y=[%d,%d] af x,y=[%d,%d]\n", ad->touch_lcd_x,
3762                     ad->touch_lcd_y, ad->af_x, ad->af_y);
3763         DEBUG_TRACE
3764             ("*************************************************************************************");
3765         if (ad->af_outside == FALSE) {
3766                 __cam_app_set_focus_zoom_in_effect((void *)ad);
3767         }
3768         cam_app_timeout_checker_update();
3769         cam_setting_toolbar_execution_time_checker_update(ad);
3770
3771         return EINA_TRUE;
3772 }
3773
3774 Eina_Bool cam_mouse_button_up(void *data, int type, void *event_info)
3775 {
3776         struct appdata *ad = (struct appdata *)data;
3777         CamAppData *camapp = NULL;
3778
3779         if (ad->zoom_edje
3780                 || ad->setting_ctxpopup
3781                 || (ad->toolbar_show_setting_popup == TRUE)
3782                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)) {
3783                 cam_debug(LOG_UI, "ignore touch event");
3784                 ad->af_outside = TRUE;
3785                 return EINA_TRUE;
3786         }
3787
3788         Ecore_Event_Mouse_Button *md = (Ecore_Event_Mouse_Button *) event_info;
3789         if (ad->shutter_move == TRUE) {
3790                 double y_gap = 0;
3791                 double x_gap = 0;
3792                 double shutter_h_ratio = SHUTTER_H_RATIO;
3793                 double shutter_w_ratio = SHUTTER_W_RATIO;
3794                 double screen_ratio = SCREEN_RATIO;
3795
3796                 y_gap = (double)md->root.y /(double)ad->win_width;
3797                 x_gap = (double)md->root.x /(double)ad->win_height;
3798
3799                 if (x_gap > (screen_ratio -shutter_h_ratio) || x_gap < shutter_h_ratio) {
3800                         if (!cam_camera_key_half_release(ad)) {
3801                                 DEBUG_TRACE("cam_camera_key_half_release");
3802                         }
3803                 } else if (ad->angle == 90 ||ad->angle == 180) {
3804                         if (y_gap > shutter_w_ratio) {
3805                                 if (!cam_camera_key_half_release(ad)) {
3806                                         DEBUG_TRACE("cam_camera_key_half_release");
3807                                 }
3808                         }
3809                 } else {
3810                         if (y_gap < screen_ratio -shutter_w_ratio) {
3811                                 if (!cam_camera_key_half_release(ad)) {
3812                                         DEBUG_TRACE("cam_camera_key_half_release");
3813                                 }
3814                         }
3815                 }
3816         }
3817
3818         cam_retvm_if(ad == NULL, EINA_FALSE, "appdata is NULL");
3819         cam_debug(LOG_UI, "mouse button up[%d, %d]", md->root.x, md->root.y);
3820         if (ad->af_outside == FALSE) {
3821                 __cam_app_set_focus_zoom_out_effect((void *)ad);
3822         }
3823         camapp = ad->camapp_handle;
3824         if (camapp == NULL) {
3825                 cam_warning(LOG_UI, "camapp_handle is NULL, maybe not created");
3826                 return EINA_FALSE;
3827         }
3828         return EINA_TRUE;
3829 }
3830
3831 Eina_Bool cam_mouse_move(void *data, int type, void *event_info)
3832 {
3833         struct appdata *ad = (struct appdata *)data;
3834         CamAppData *camapp = NULL;
3835
3836         Ecore_Event_Mouse_Move *md = (Ecore_Event_Mouse_Move *) event_info;
3837
3838         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
3839         cam_debug(LOG_UI, "mouse move[%d, %d]", md->root.x, md->root.y);
3840         cam_debug(LOG_UI, "mouse move angle[%lf]", md->multi.angle);
3841         cam_debug(LOG_UI, "mouse move pressure[%lf]", md->multi.pressure);
3842         camapp = ad->camapp_handle;
3843         if (camapp == NULL) {
3844                 cam_warning(LOG_UI, "camapp_handle is NULL, maybe not created");
3845                 return -1;
3846         }
3847         cam_app_timeout_checker_update();
3848
3849         return 0;
3850 }
3851 #endif
3852
3853 void cam_app_set_config_group(gint mode)
3854 {
3855         cam_debug(LOG_UI, "mode : %d", mode);
3856
3857         if (mode == CAM_CAMERA_MODE) {
3858                 cam_config_set_group_name(CAM_CONFIG_TYPE_PREVIEW, "still");
3859         } else {
3860                 cam_config_set_group_name(CAM_CONFIG_TYPE_PREVIEW, "video");
3861         }
3862
3863         debug_fleave(LOG_UI);
3864
3865         return;
3866 }
3867
3868 int cam_app_get_latest_mode(void)
3869 {
3870         cam_config_set_group_name(CAM_CONFIG_TYPE_COMMON, "common");
3871         int last_mode =
3872             cam_config_get_int_by_type(CAM_CONFIG_TYPE_COMMON, "mode",
3873                                        CAM_CAMERA_MODE);
3874
3875         debug_msg(LOG_UI, "last mode:%d", last_mode);
3876         return last_mode;
3877 }
3878
3879 const gchar *cam_app_get_target_path(void)
3880 {
3881         CamAppData *camapp = NULL;
3882
3883         camapp = cam_handle_get();
3884
3885         if (camapp) {
3886
3887                 const gchar *default_path = NULL;
3888                 switch (camapp->storage) {
3889                 case CAM_STORAGE_INTERNAL:
3890                         default_path =
3891                             (camapp->camera_mode == CAM_CAMCORDER_MODE) ?
3892                                 cam_file_get_internal_video_path() :
3893                                 cam_file_get_internal_image_path();
3894                         break;
3895                 case CAM_STORAGE_EXTERNAL:
3896                         default_path =
3897                             (camapp->camera_mode == CAM_CAMCORDER_MODE) ?
3898                                 cam_file_get_external_video_path() :
3899                                 cam_file_get_external_image_path();
3900                         break;
3901                 default:
3902                         cam_critical(LOG_UI, "Unknow storage type : %d",
3903                                      camapp->storage);
3904                         break;
3905                 }
3906
3907                 cam_debug(LOG_UI, "target path : [%s]", default_path);
3908                 return default_path;
3909         } else {
3910                 cam_critical(LOG_UI, "camapp handle is NULL");
3911                 return NULL;
3912         }
3913 }
3914
3915 gchar *cam_app_get_last_filename(void)
3916 {
3917         CamAppData *camapp = NULL;
3918         gchar *last_file_path = NULL;
3919         struct appdata *ad = (struct appdata *)cam_appdata_get();
3920         cam_retvm_if(ad == NULL, NULL, "appdata is NULL");
3921
3922         camapp = cam_handle_get();
3923         cam_retvm_if(camapp == NULL, NULL, "cam_handle is NULL");
3924
3925         last_file_path = cam_file_get_last_file_path(ad, cam_app_get_target_path());
3926
3927         if (last_file_path) {
3928                 cam_debug(LOG_UI, "last_file_path  : %s", last_file_path);
3929         } else {
3930                 cam_critical(LOG_UI, "last_file_path is NULL");
3931                 return NULL;
3932         }
3933         return last_file_path;
3934 }
3935
3936 gchar *cam_app_get_next_filename(void)
3937 {
3938
3939         CamAppData *camapp = NULL;
3940         gchar *new_filename = NULL;
3941         struct appdata *ad = (struct appdata *)cam_appdata_get();
3942         cam_retvm_if(ad == NULL, NULL, "appdata is NULL");
3943
3944         camapp = cam_handle_get();
3945         cam_retvm_if(camapp == NULL, NULL, "cam_handle is NULL");
3946         int mm_state = 0;
3947         mm_state = cam_mm_get_state();
3948
3949         if (mm_state == RECORDER_STATE_RECORDING
3950                 &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
3951                 new_filename = cam_file_get_next_filename(cam_app_get_target_path(), INAGE_FILE_NAME, IMAGE_FILE_EXTENSION);
3952         } else {
3953                 new_filename = cam_file_get_next_filename(cam_app_get_target_path(),
3954                                           (camapp->camera_mode ==
3955                                            CAM_CAMERA_MODE) ?
3956                                           INAGE_FILE_NAME :
3957                                           VIDEO_FILE_NAME,
3958                                           (camapp->camera_mode ==
3959                                            CAM_CAMERA_MODE) ?
3960                                           IMAGE_FILE_EXTENSION :
3961                                           VIDEO_FILE_EXTENSION);
3962         }
3963
3964         if (new_filename) {
3965                 cam_debug(LOG_UI, "next filename : %s", new_filename);
3966         } else {
3967                 cam_critical(LOG_UI, "new_filename is NULL");
3968         }
3969
3970         return new_filename;
3971 }
3972
3973 static void __cam_preview_cb(void *stream_buffer, int buffer_size, int width,
3974                 int height, camera_pixel_format_e format, void *user_data)
3975 {
3976
3977         cam_retm_if(user_data == NULL, "data is null");
3978         struct appdata *ad = (struct appdata *)user_data;
3979
3980         CamAppData *camapp = ad->camapp_handle;
3981         cam_retm_if(camapp == NULL, "camapp is null");
3982
3983 }
3984
3985 static void __cam_state_change_cb(camera_state_e previous, camera_state_e current,
3986         bool by_policy, void *user_data)
3987 {
3988         struct appdata *ad = NULL;
3989         CamAppData *camapp = NULL;
3990         ad = (struct appdata *)user_data;
3991         cam_retm_if(ad == NULL, "camapp is null");
3992         camapp = ad->camapp_handle;
3993         cam_retm_if(camapp == NULL, "camapp is null");
3994         DEBUG_TRACE("current= %d, previous = %d, ad->enable_mode_change = %d",
3995                 current, previous, ad->enable_mode_change);
3996         if (current == CAMERA_STATE_PREVIEW) {
3997                 ad->enable_mode_change = TRUE;
3998         } else {
3999                 ad->enable_mode_change = FALSE;
4000         }
4001         DEBUG_TRACE("current= %d, previous = %d, ad->enable_mode_change = %d",
4002                 current, previous, ad->enable_mode_change);
4003         cam_app_state_manager(previous, current, by_policy);
4004
4005 }
4006
4007 static void __cam_focus_cb(camera_focus_state_e state, void *user_data) {
4008
4009         struct appdata *ad = NULL;
4010         CamAppData *camapp = NULL;
4011
4012         ad = (struct appdata *)user_data;
4013         cam_retm_if(ad == NULL, "appdata is NULL");
4014
4015         /*
4016         *       TODO: perhaps we have to consider: in thread, we should not use any efl api.
4017         *               especially:
4018         *               try not to operation the global evas object in asynchronous
4019         *               callback or thread. Some bs perhaps caused by this.
4020         *
4021         */
4022         /*note: while rotating, return. */
4023         if (ad->is_rotating) return;/*note: while rotating, return. */
4024         camapp = ad->camapp_handle;
4025         cam_retm_if(camapp == NULL, "camapp is NULL");
4026
4027
4028         cam_debug(LOG_MM, " Focus state changed to [%d]", state);
4029
4030         if(ad->appcore_state == CAM_APPCORE_PAUSE_STATE)
4031                 return;
4032
4033         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4034                 camapp->focus_state = state ;
4035                 cam_app_focus_guide_update(ad);
4036         } else {
4037                 camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
4038         }
4039         switch (state) {
4040         case CAMERA_FOCUS_STATE_ONGOING:
4041                 break;
4042         case CAMERA_FOCUS_STATE_FOCUSED:
4043                 if (ad->mm_state < CAMERA_STATE_CAPTURING) {
4044                         if (camapp->shutter_sound != CAM_SETTINGS_SOUND_OFF
4045                                 && camapp->camera_mode == CAM_CAMERA_MODE )
4046                                 cam_sound_play (CAM_SOUND_EFFECT_AF_OK, ad);
4047
4048                         if (camapp->focus_mode == CAM_FOCUS_MODE_TOUCH_AUTO){
4049                                 REMOVE_TIMER(ad->continuous_af_timer);
4050                                 DEBUG_TRACE("start caf");
4051                                 cam_app_focus_guide_create(ad);
4052                                 cam_app_focus_guide_update(ad);
4053                                 ad->continuous_af_timer= ecore_timer_add(FOCUS_FOCUSED_TIME_OUT, cam_continuous_af_start, ad);
4054                         }
4055                 }
4056                 break;
4057         case CAMERA_FOCUS_STATE_FAILED:
4058                 if (ad->mm_state < CAMERA_STATE_CAPTURING) {
4059                         if (camapp->shutter_sound != CAM_SETTINGS_SOUND_OFF
4060                                 && camapp->camera_mode == CAM_CAMERA_MODE)
4061                                 cam_sound_play (CAM_SOUND_EFFECT_AF_FAIL, ad);
4062
4063                         if (camapp->focus_mode == CAM_FOCUS_MODE_TOUCH_AUTO) {
4064                                 REMOVE_TIMER(ad->continuous_af_timer);
4065                                 DEBUG_TRACE("start caf");
4066                                 cam_app_focus_guide_create(ad);
4067                                 cam_app_focus_guide_update(ad);
4068                                 ad->continuous_af_timer= ecore_timer_add(FOCUS_FAILED_TIME_OUT, cam_continuous_af_start, ad);
4069                         }
4070                 }
4071                 break;
4072         default:
4073                 break;
4074         }
4075
4076
4077 }
4078
4079 static void __cam_capture_cb(camera_image_data_s* image,
4080         camera_image_data_s* postview,
4081         camera_image_data_s* thumbnail,
4082         void *user_data)
4083 {
4084         struct appdata *ad = (struct appdata *)user_data;
4085         cam_retm_if(ad == NULL, "appdata is NULL");
4086         CamAppData *camapp = NULL;
4087         camapp = ad->camapp_handle;
4088         cam_retm_if(camapp == NULL, "camapp is NULL");
4089
4090         gchar *filename = NULL;
4091         FILE *fp = NULL;
4092         if ((image->format == CAMERA_PIXEL_FORMAT_YUYV)
4093             || (image->format == CAMERA_PIXEL_FORMAT_NV12)) {
4094                 cam_debug(LOG_UI,
4095                           "got raw data - format [%d] data [%p], length [%d], width [%d], height [%d]",
4096                           image->format, image->data, image->size, image->width,
4097                           image->height);
4098                 /* encode data */
4099                 /* MMImageJpegEncodeToFile(filename, src->data, src->width,src->height, src->format, 90); */
4100         } else if (image->format == CAMERA_PIXEL_FORMAT_JPEG) {
4101                 cam_debug(LOG_UI,
4102                           "got JPEG data - data [%p], length [%d], width [%d], height [%d]",
4103                           image->data, image->size, image->width, image->height);
4104
4105                 /* save file */
4106                 filename = cam_app_get_next_filename();
4107                 if (filename == NULL) {
4108                         cam_critical(LOG_SYS, " Get next filename FAILED");
4109                         return;
4110                 }
4111
4112                 fp = fopen(filename, "w+");
4113                 if (fp == NULL) {
4114                         cam_critical(LOG_SYS, "FileOPEN error!!");
4115                         return;
4116                 } else {
4117                         cam_debug(LOG_SYS, "FileOPEN success");
4118                         if (fwrite(image->data, image->size, 1, fp) != 1) {
4119                                 cam_critical(LOG_SYS, "File write error!!");
4120                                 fclose(fp);
4121                                 return;
4122                         }
4123                         /*fsync(fp->_fileno);*/
4124                         /*block for increasing formance of shot-to-shot */
4125                         cam_debug(LOG_SYS, "File write success");
4126                         fclose(fp);
4127                 }
4128                 if (camapp->filename)
4129                         free(camapp->filename);
4130                 camapp->filename = strdup(filename);
4131                 free(filename);
4132         }
4133
4134 }
4135
4136 static void __cam_capture_completed_cb(void *user_data)
4137 {
4138 /*      camera_error_e e;*/
4139         DEBUG_TRACE();
4140         struct appdata *ad = NULL;
4141         CamAppData *camapp = NULL;
4142
4143         ad = (struct appdata *)user_data;
4144         camapp = ad->camapp_handle;
4145
4146         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4147 #ifndef ENABLE_CAPTURE_ANIMATION
4148
4149                                                 /* Idler of capture callback management. wh01.cho@samsung.com. 2010-12-15. */
4150                                                 CamIdlerItem *item = NULL;
4151                                                 item = (CamIdlerItem *)
4152                                                     g_malloc(sizeof(CamIdlerItem));
4153                                                 if (item == NULL)
4154                                                         return;
4155
4156                 if (item) {
4157                         item->data = user_data;
4158                         item->idler = ecore_idler_add(cam_image_capture_handle_idler, item);
4159
4160                         if (item->idler)
4161                                 ad->capture_cb_list = g_list_append(ad->capture_cb_list, item->idler);
4162
4163                         cam_info(LOG_UI, "image capture idler add : %p ", item->idler);
4164                 }
4165 #endif
4166                 DEBUG_TRACE();
4167                 if (!cam_app_preview_start(ad)) {
4168                         cam_critical(LOG_MM, "cam_app_preview_start failed");
4169                         cam_app_notice_popup(ad, "cam_app_preview_start faild ",
4170                                              cam_app_timeout_notice_response_cb);
4171                         return;
4172                 }
4173         }else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
4174
4175                 DEBUG_TRACE("MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED");
4176                 ecore_idler_add(cam_capture_on_recording_handle, ad);
4177         }
4178         DEBUG_TRACE();
4179 }
4180 static void __cam_interrupted_cb(camera_policy_e policy, camera_state_e previous, camera_state_e current, void *data)
4181 {
4182         struct appdata *ad = (struct appdata *)data;
4183         CamAppData *camapp = NULL;
4184         cam_retm_if(ad == NULL, "appdata is NULL");
4185         camapp = ad->camapp_handle;
4186         cam_retm_if(camapp == NULL, "cam_handle is NULL");
4187         DEBUG_TRACE("policy is [%d]",policy);
4188         switch (policy) {
4189         case CAMERA_POLICY_SOUND:
4190                 {
4191                         cam_app_black_screen_show(ad, 2);
4192                         ecore_timer_add(0.01, cam_delay_popup, (void *)ad);
4193                 }
4194                 break;
4195         case CAMERA_POLICY_SECURITY:
4196                         cam_app_mdm_syspopup(ad);
4197                 break;
4198         default:
4199                 break;
4200         }
4201 }
4202
4203 static void __rec_interrupted_cb(recorder_policy_e policy, recorder_state_e previous, recorder_state_e current, void *data)
4204 {
4205         struct appdata *ad = (struct appdata *)data;
4206         CamAppData *camapp = NULL;
4207         cam_retm_if(ad == NULL, "appdata is NULL");
4208         camapp = ad->camapp_handle;
4209         cam_retm_if(camapp == NULL, "cam_handle is NULL");
4210         DEBUG_TRACE("policy is [%d]",policy);
4211
4212         switch (policy) {
4213         case RECORDER_POLICY_SOUND:
4214                 {
4215                         cam_app_black_screen_show(ad, 2);
4216                         ecore_timer_add(0.01, cam_delay_popup, (void *)ad);
4217                 }
4218                 break;
4219         case RECORDER_POLICY_SECURITY:
4220                         cam_app_mdm_syspopup(ad);
4221                 break;
4222         default:
4223                 break;
4224         }
4225 }
4226
4227 static void __cam_error_cb(int error, camera_state_e current_state, void *user_data)
4228 {
4229         struct appdata *ad = NULL;
4230         CamAppData *camapp = NULL;
4231
4232         ad = (struct appdata *)user_data;
4233         cam_retm_if(ad == NULL, "appdata is NULL");
4234         camapp = ad->camapp_handle;
4235         cam_retm_if(camapp == NULL, "camapp is NULL");
4236
4237         int state = 0;
4238         state = current_state;
4239         cam_warning(LOG_MM,
4240                         "MM ERROR occurs : code [%x], state [%d]",
4241                         error, state);
4242
4243         switch (error) {
4244         case CAMERA_ERROR_DEVICE:
4245                 cam_critical(LOG_SYS,
4246                                  "      MM CAMCARORDER ERROR ");
4247                 if (state < CAMERA_STATE_CAPTURING) {
4248                         cam_app_notice_popup(ad,
4249                                 _("IDS_CAM_POP_UNABLE_TO_START_CAMERA"),
4250                                 cam_app_timeout_notice_response_cb);
4251                 } else {
4252                         cam_app_notice_popup(ad,
4253                                 _("IDS_CAM_POP_CAPTURE_TIME_EXCEEDED_START_AGAIN"),
4254                                 cam_app_timeout_notice_response_cb);
4255                 }
4256                 break;
4257         case CAMERA_ERROR_INVALID_PARAMETER:
4258                 if (state == CAMERA_STATE_CAPTURING) {
4259                         cam_app_notice_popup(ad,
4260                                 _("IDS_CAM_POP_CAPTURE_ERROR"),
4261                                 cam_app_timeout_notice_response_cb);
4262                 }
4263                 break;
4264         case CAMERA_ERROR_SOUND_POLICY:
4265                 {
4266                         DEBUG_TRACE(" MM CAMCARORDER ERROR\n");
4267                         cam_app_black_screen_show(ad, 2);
4268                         ecore_timer_add(0.01, cam_delay_popup,
4269                                         (void *)ad);
4270                 }
4271                 break;
4272         case CAMERA_ERROR_INVALID_OPERATION:
4273                 {
4274                         DEBUG_TRACE(" Internal error\n");
4275                         cam_app_black_screen_show(ad, 2);
4276                         ecore_timer_add(0.01, cam_delay_popup,
4277                                         (void *)ad);
4278                 }
4279                 break;
4280         case CAMERA_ERROR_OUT_OF_MEMORY:
4281                 {
4282                         DEBUG_TRACE(" Out of memory\n");
4283                         cam_app_black_screen_show(ad, 2);
4284                         ecore_timer_add(0.01, cam_delay_popup,
4285                                         (void *)ad);
4286                 }
4287                 break;
4288         default:
4289                 {
4290                         DEBUG_TRACE(" MM CAMCARORDER ERROR error code =%x \n", error);
4291                         if (state == CAMERA_STATE_CAPTURING
4292                                 && camapp->camera_mode == CAM_CAMERA_MODE) {
4293                                 cam_app_notice_popup(ad, _("IDS_CAM_POP_CAPTURE_ERROR"),
4294                                         cam_app_capture_error_popup_response_cb);
4295                         }
4296                 }
4297                 break;
4298         }
4299
4300 }
4301
4302 static void __recorder_state_cb(recorder_state_e previous , recorder_state_e current , bool by_policy, void *user_data)
4303 {
4304         struct appdata *ad = NULL;
4305         CamAppData *camapp = NULL;
4306
4307         ad = (struct appdata *)user_data;
4308         cam_retm_if(ad == NULL, "appdata is NULL");
4309         camapp = ad->camapp_handle;
4310         cam_retm_if(camapp == NULL, "camapp is NULL");
4311         if (current == RECORDER_STATE_READY) {
4312                 ad->enable_mode_change = TRUE;
4313         } else {
4314                 ad->enable_mode_change = FALSE;
4315         }
4316         cam_app_state_manager(previous, current, by_policy);
4317 }
4318
4319 void __recording_status_cb(int elapsed_time, int file_size, void *user_data)
4320 {
4321         struct appdata *ad = NULL;
4322         CamAppData *camapp = NULL;
4323         ad = (struct appdata *)user_data;
4324         cam_retm_if(ad == NULL, "appdata is NULL");
4325         camapp = ad->camapp_handle;
4326         cam_retm_if(camapp == NULL, "camapp is NULL");
4327         /* update current time */
4328         DEBUG_TRACE();
4329         guint elapsed = 0;
4330         guint filesize = 0;
4331         elapsed = elapsed_time / 1000;
4332         filesize = file_size;
4333         if (camapp->rec_elapsed < elapsed) {
4334                 GValue value = { 0, };
4335
4336                 cam_debug(LOG_UI, "time updated: %u ", elapsed);
4337                 CAM_GVALUE_SET_UINT(value, elapsed);
4338                 cam_handle_value_set(ad, PROP_REC_TIME, &value);
4339         }
4340         if (camapp->rec_filesize < filesize) {
4341                 GValue value = { 0, };
4342
4343                 cam_debug(LOG_UI, "filesize updated: %u ", filesize);
4344                 CAM_GVALUE_SET_UINT(value, filesize);
4345                 cam_handle_value_set(ad, PROP_REC_FILE_SIZE, &value);
4346         }
4347 }
4348
4349 void __recording_limit_reached_cb(recorder_recording_limit_type_e type, void *user_data)
4350 {
4351         struct appdata *ad = NULL;
4352         CamAppData *camapp = NULL;
4353         ad = (struct appdata *)user_data;
4354         cam_retm_if(ad == NULL, "appdata is NULL");
4355         camapp = ad->camapp_handle;
4356         cam_retm_if(camapp == NULL, "camapp is NULL");
4357
4358         if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
4359                 camapp->rec_stop_type = type;/*CAM_REC_STOP_TIME_LIMIT;*/
4360                 ad->recording_commit =
4361                         ecore_idler_add(cam_video_idler_record_stop, ad);
4362         }
4363 }
4364
4365 gboolean cam_callback_init(void *data)
4366 {
4367         struct appdata *ad = (struct appdata *)data;
4368         CamAppData *camapp = NULL;
4369
4370         debug_fenter(LOG_UI);
4371
4372         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4373         camapp = ad->camapp_handle;
4374         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4375         camapp->error_cb = __cam_error_cb;
4376         camapp->focus_cb = __cam_focus_cb;
4377         camapp->state_cb = __cam_state_change_cb;
4378         camapp->preview_cb = __cam_preview_cb;
4379         camapp->capture_completed_cb = __cam_capture_completed_cb;
4380         camapp->cam_interrupted_cb = __cam_interrupted_cb;
4381
4382         camapp->recording_status_cb = __recording_status_cb;
4383         camapp->recording_state_changed_cb = __recorder_state_cb;
4384         camapp->recording_limit_reached_cb = __recording_limit_reached_cb;
4385         camapp->rec_interrupted_cb = __rec_interrupted_cb;
4386
4387         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4388                 switch (camapp->shooting_mode) {
4389                 case CAM_SINGLE_MODE:
4390                 case CAM_SELF_MODE:
4391                         camapp->capture_cb = (camera_capturing_cb)
4392                                 __cam_capture_cb;
4393                         break;
4394                 default:
4395                         break;
4396                 }
4397         } else {
4398                 camapp->capture_cb = __cam_capture_cb;
4399         }
4400
4401         int ret = 1;
4402         if (camapp->camera_mode == CAM_CAMERA_MODE) {
4403                 /*ret &= cam_mm_recorder_unset_state_changed_cb();*/
4404                 ret &= cam_mm_set_preview_cb(camapp->preview_cb, (void*)ad);
4405                 ret &= cam_mm_set_focus_changed_cb(camapp->focus_cb, (void*)ad);
4406                 ret &= cam_mm_set_state_changed_cb(camapp->state_cb, (void*)ad);
4407                 ret &= cam_mm_set_error_cb(camapp->error_cb, (void*)ad);
4408                 ret &= cam_mm_set_camera_interrupted_cb(camapp->cam_interrupted_cb, (void*)ad);
4409         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
4410                 ret &= cam_mm_unset_state_changed_cb();
4411                 /*ret &= cam_mm_unset_preview_cb();*/
4412                 /*ret &= cam_mm_unset_state_changed_cb();*/
4413                 /*ret &= cam_mm_unset_error_cb();*/
4414                 ret &= cam_mm_recorder_set_state_changed_cb(camapp->recording_state_changed_cb, (void*)ad);
4415                 ret &= cam_mm_recorder_set_recording_status_cb(camapp->recording_status_cb, (void*)ad);
4416                 ret &= cam_mm_recorder_set_recording_limit_reached_cb(camapp->recording_limit_reached_cb, (void*)ad);
4417                 ret &= cam_mm_set_recorder_interrupted_cb(camapp->rec_interrupted_cb, (void*)ad);
4418         }
4419
4420
4421         return ret;
4422 }
4423
4424 static void cam_app_close_ug(void *data)
4425 {
4426         cam_debug(LOG_UI, " ");
4427         struct appdata *ad = (struct appdata *)data;
4428         /* IDS problem */
4429
4430         cam_info(LOG_UI, "ad->imageviewer_ug : %p", ad->imageviewer_ug);
4431         if (ad->imageviewer_ug) {
4432                 ug_destroy(ad->imageviewer_ug);
4433                 ad->imageviewer_ug = NULL;
4434         }
4435         cam_file_init(NULL);
4436         return;
4437 }
4438
4439 static void __ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
4440 {
4441         cam_debug(LOG_UI, " ");
4442
4443         struct appdata *ad = (struct appdata *)priv;
4444         Evas_Object *base;
4445
4446         if (!ug || !priv)
4447                 return;
4448
4449         base = ug_get_layout(ug);
4450         if (!base)
4451                 return;
4452
4453         switch (mode) {
4454         case UG_MODE_FULLVIEW:
4455                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
4456                                                  EVAS_HINT_EXPAND);
4457                 elm_win_resize_object_add(ad->win_main, base);
4458                 evas_object_show(base);
4459                 break;
4460         default:
4461                 break;
4462         }
4463 }
4464
4465 void __ug_result_cb(ui_gadget_h ug, service_h result, void *priv)
4466 {
4467
4468         cam_debug(LOG_UI, " ");
4469
4470         struct appdata *ad = (struct appdata *)priv;
4471         char *val = NULL;
4472
4473         CamAppData *camapp = NULL;
4474
4475         cam_retm_if(ad == NULL, "appdata is NULL");
4476         camapp = ad->camapp_handle;
4477         cam_retm_if(camapp == NULL, "cam_handle is NULL");
4478
4479         if (ad->imageviewer_ug) {
4480                 if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
4481                         if (result == NULL) {
4482                                 ad->path_in_return = false;
4483                                 return;
4484                         }
4485
4486                         if ((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "contacts") == 0)) {
4487                                 service_h reply;
4488                                 service_create(&reply);
4489
4490                                 service_get_extra_data(result, "crop_image_path", &val);
4491                                 service_add_extra_data(reply, "crop_image_path", val);
4492                                 service_get_extra_data(result, "image_path", &val);
4493                                 service_add_extra_data(reply, "image_path", val);
4494
4495                                 service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_SUCCEEDED);
4496                                 service_destroy(reply);
4497
4498                                 ad->path_in_return = true;
4499                                 cam_app_exit(ad);
4500                         } else {
4501                                 /* get result value. */
4502                                 service_get_extra_data(result, "Result", &val);
4503
4504                                 if (strcmp(val, "Ok") == 0) {
4505                                         ad->path_in_return = true;
4506                                         cam_app_exit(ad);
4507                                 }
4508                                 else if (strcmp(val, "Cancel") == 0) {
4509                                         ad->path_in_return = false;
4510                                 }
4511                         }
4512                 }
4513         }
4514 }
4515
4516 void __ug_destroy_cb(ui_gadget_h ug, void *priv)
4517 {
4518         cam_debug(LOG_UI, " ");
4519
4520         if (!ug || !priv)
4521                 return;
4522
4523         struct appdata *ad = (struct appdata *)priv;
4524
4525         cam_retm_if(ad == NULL, "appdata is NULL");
4526         ad->ug_is_deleting_process = TRUE;
4527
4528         cam_app_timeout_checker_init(ad);
4529
4530         /* add mouse down event - image viewer bug */
4531         if (ad->black_screen) {
4532                 DEL_EVAS_OBJECT(ad->black_screen);
4533                 ad->black_screen = NULL;
4534         }
4535
4536         if (ad->imageviewer_ug) {
4537                 ug_destroy(ad->imageviewer_ug);
4538                 ad->imageviewer_ug = NULL;
4539         }
4540
4541         elm_win_indicator_mode_set(ad->win_main, 0);
4542         cam_app_start_rotate(ad, false);
4543
4544         ecore_idler_add(__ug_destory_postprocessing, ad);
4545
4546         return;
4547 }
4548
4549 Eina_Bool __ug_destory_postprocessing(void *data)
4550 {
4551         struct appdata *ad = data;
4552         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4553         ad->ug_is_deleting_process = TRUE;
4554         CamAppData *camapp = NULL;
4555         camapp = ad->camapp_handle;
4556         cam_retvm_if(camapp == NULL, FALSE,  "cam_handle is NULL");
4557
4558         cam_app_mouse_event_init(ad);
4559
4560         show_toolbar_edje(ad);
4561
4562         if (!cam_file_check_exists(camapp->filename)) {
4563                 free(camapp->filename);
4564                 camapp->filename = NULL;
4565         }
4566         if (!cam_app_preview_start(ad)) {
4567                 cam_app_notice_popup(ad,
4568                 "PREVIEW START FAIL !!",
4569                  cam_app_timeout_notice_response_cb);
4570         }
4571
4572         if (!cam_key_grab_init(ad))
4573                 DEBUG_TRACE("cam_key_grab_init fail");
4574         cam_app_key_event_init(ad);
4575         /* update thumbnail to quickview after return from image viewer */
4576         cam_app_update_quickview_icon(ad);
4577         cam_file_init(NULL);
4578         ad->ug_is_deleting_process = FALSE;
4579         return ECORE_CALLBACK_CANCEL;
4580
4581
4582 }
4583
4584 gboolean cam_app_run_image_viewer_ug(void *data, char *file_path)
4585 {
4586         DEBUG_TRACE("START");
4587
4588         struct appdata *ad = (struct appdata *)data;
4589
4590         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4591         cam_retvm_if(file_path == NULL, FALSE, "file_path is NULL");
4592
4593         if (ad->ug_is_deleting_process) /*NOTE:before old ug is not deleted completely, should not create new ug*/
4594                 return FALSE;
4595
4596         cam_debug(LOG_UI, " ");
4597         cam_debug(LOG_UI, "path :%s", file_path);
4598
4599         if (ad->imageviewer_ug) {
4600                 return FALSE;/*NOTE: ug is login, not create ug again.*/
4601         }
4602
4603         /* init */
4604         enum ug_option opt;
4605         opt = UG_OPT_INDICATOR_LANDSCAPE_ONLY | UG_OPT_INDICATOR_DISABLE;
4606         UG_INIT_EFL(ad->win_main, opt);
4607
4608         struct ug_cbs cbs = { 0, };
4609
4610         cbs.layout_cb = __ug_layout_cb;
4611         cbs.result_cb = __ug_result_cb;
4612         cbs.destroy_cb = __ug_destroy_cb;
4613         cbs.priv = (void *)data;
4614
4615         /* param */
4616         if (ad->imageviewer_service)
4617                 service_destroy(ad->imageviewer_service);
4618
4619         service_create(&ad->imageviewer_service);
4620
4621         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
4622                 if ((ad->exe_args->caller) && (strcmp(ad->exe_args->caller, "contacts") == 0)) {
4623                         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_VIEW_MODE_KEY_NAME, "SETAS");
4624                         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_SET_AS_TYPE, "CallerID");
4625                 } else {
4626                         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_VIEW_MODE_KEY_NAME, "DISPLAY");
4627                 }
4628         } else if (ad->launching_mode == CAM_LAUNCHING_MODE_NORMAL) {
4629                 service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_VIEW_MODE_KEY_NAME, "CAMERA");
4630         }
4631         service_add_extra_data(ad->imageviewer_service, IMAGE_VIEWER_FILE_PATH_KEY_NAME, file_path);
4632
4633         switch (ad->rot_current) {
4634         case APP_DEVICE_ORIENTATION_0:
4635                 elm_win_rotation_with_resize_set(ad->win_main, 0);
4636                 break;
4637         case APP_DEVICE_ORIENTATION_270:
4638         case APP_DEVICE_ORIENTATION_180:
4639                 break;
4640         case APP_DEVICE_ORIENTATION_90:
4641                 elm_win_rotation_with_resize_set(ad->win_main, 90);
4642                 break;
4643         default:
4644                 break;
4645         }
4646
4647         /* Create UI gadget */
4648         ad->imageviewer_ug =
4649             ug_create(NULL, IMAGE_VIEWER_UG_NAME, UG_MODE_FULLVIEW,
4650                       ad->imageviewer_service, &cbs);
4651
4652         if (!ad->imageviewer_ug) {
4653                 cam_critical(LOG_SYS, "image viewer UI Gadget create fail...");
4654                 return FALSE;
4655         } else {
4656
4657                 if (ad->imageviewer_ug) {
4658                         cam_app_key_event_deinit(ad);
4659                         if(!cam_key_grab_deinit(ad)){
4660                                 DEBUG_TRACE("cam_key_grab_deinit fail");
4661                         }
4662                         cam_app_preview_stop();
4663 #ifdef ENABLE_CAM_POWER_CONTROL
4664                         power_unlock_state(POWER_STATE_NORMAL);
4665 #endif
4666                 } else {
4667                         cam_warning(LOG_UI, "Cannot create imageviewer ug");
4668                         cam_file_init(NULL);
4669                         return FALSE;
4670                 }
4671         }
4672         DEBUG_TRACE("END");
4673
4674         return TRUE;
4675
4676 }
4677
4678 gboolean cam_app_run_media_browser(void *data, gchar *filename)
4679 {
4680         cam_debug(LOG_UI, "filename = %s", filename);
4681         struct appdata *ad = (struct appdata *)data;
4682         CamAppData *camapp = NULL;
4683         int state = 0;
4684
4685         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4686         camapp = ad->camapp_handle;
4687         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4688
4689         debug_fenter(LOG_UI);
4690         ad->launch_type = CAM_LAUNCH_IS_ALREADY_RUNNING;
4691         DEBUG_TRACE("ad->launch_type = %d", ad->launch_type);
4692         state = cam_mm_get_state();
4693         if (state > CAMERA_STATE_PREVIEW) {
4694                 cam_warning(LOG_MM, "Invaild state : %d", state);
4695                 return FALSE;
4696         }
4697         toolbar_hide_setting_popup(ad);
4698         ad->foucs_out_from_quickview = FALSE;
4699
4700         /* del mouse down event - image viewer bug */
4701         cam_app_mouse_event_deinit(ad);
4702         if (!cam_app_run_image_viewer_ug(ad, cam_app_get_last_filename())) {
4703                 DEBUG_TRACE("cam_app_run_image_viewer_ug failed");
4704                 cam_app_mouse_event_init(ad);
4705                 return FALSE;
4706         }
4707
4708         if (camapp->thumbnail_name) {   /*  Some image is deleted from image viewer and galler -> BS  */
4709                 free(camapp->thumbnail_name);
4710                 camapp->thumbnail_name = NULL;
4711         }
4712
4713         cam_app_timeout_checker_remove();
4714         return TRUE;
4715 }
4716
4717 gboolean cam_app_clear_engine_data(void *data, gboolean release)
4718 {
4719         return TRUE;
4720 }
4721
4722 gboolean cam_app_check_wide_resolution(int id)
4723 {
4724
4725         gfloat get_value = (HIWORD(id) * 3.0) / (LOWORD(id) * 4.0);
4726         if (ABS(get_value - 1.0) < CAM_EPSINON
4727             || ABS((gfloat)((HIWORD(id) * 25.0) / (LOWORD(id) * 36.0)) - 1.0) < CAM_EPSINON) {
4728                 return FALSE;
4729         }
4730
4731         return TRUE;
4732
4733 }
4734
4735 gboolean cam_app_is_skip_video_stream()
4736 {                               /*if true , must finish function in stream callback function */
4737         return video_stream_skip_flag;
4738 }
4739
4740 void cam_app_stop_video_stream()
4741 {
4742         video_stream_skip_flag = TRUE;
4743 }
4744
4745 void cam_app_run_video_stream()
4746 {
4747         video_stream_skip_flag = FALSE;
4748 }
4749
4750 Eina_Bool _auto_shot_idle_cb(void *data)
4751 {
4752         debug_fenter(LOG_CAM);
4753         struct appdata *ad = (struct appdata *)data;
4754         CamAppData *camapp = NULL;
4755
4756         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4757         camapp = ad->camapp_handle;
4758         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4759
4760         if (ad->auto_shot_idle) {
4761                 ecore_idler_del(ad->auto_shot_idle);
4762                 ad->auto_shot_idle = NULL;
4763         }
4764
4765         debug_fleave(LOG_CAM);
4766
4767         return ECORE_CALLBACK_CANCEL;
4768 }
4769
4770 gboolean cam_app_create_progressbar(void *data)
4771 {
4772         struct appdata *ad = (struct appdata *)(data);
4773         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4774
4775         cam_debug(LOG_UI, "");
4776
4777         cam_app_destroy_progressbar(ad);
4778
4779         ad->progressbar = elm_progressbar_add(ad->win_main);
4780         cam_retvm_if(ad->progressbar == NULL, FALSE,
4781                      "Cannot create progressbar object\n");
4782
4783         elm_object_style_set(ad->progressbar, "list_progress");
4784         evas_object_size_hint_align_set(ad->progressbar, EVAS_HINT_FILL,
4785                                         EVAS_HINT_FILL);
4786
4787         evas_object_show(ad->progressbar);
4788
4789         return TRUE;
4790 }
4791
4792 gboolean cam_app_set_progressbar_value(void *data, double value)
4793 {
4794         struct appdata *ad = (struct appdata *)(data);
4795         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4796
4797         cam_debug(LOG_UI, " value [%f]", value);
4798
4799         if (ad->progressbar)
4800                 elm_progressbar_value_set(ad->progressbar, value);
4801
4802         return TRUE;
4803 }
4804
4805 gboolean cam_app_set_progressbar_text(void *data, const char *text)
4806 {
4807         struct appdata *ad = (struct appdata *)(data);
4808         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4809
4810         cam_retv_if(text == NULL, FALSE);
4811
4812         if (ad->progressbar_edje)
4813                 edje_object_part_text_set(_EDJ(ad->progressbar_edje),
4814                                           "progressbar_text", text);
4815
4816         return TRUE;
4817 }
4818
4819 gboolean cam_app_destroy_progressbar(void *data)
4820 {
4821         struct appdata *ad = (struct appdata *)(data);
4822         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4823
4824         cam_debug(LOG_UI, " start");
4825         if (ad->progressbar)
4826                 DEL_EVAS_OBJECT(ad->progressbar);
4827         if (ad->progressbar_edje)
4828                 DEL_EVAS_OBJECT(ad->progressbar_edje);
4829
4830         cam_debug(LOG_UI, " done");
4831
4832         return TRUE;
4833 }
4834
4835 #if ENABLE_HAPTIC
4836 void
4837 cam_app_haptic_cb(void *data, Evas_Object *o, const char *emission,
4838                   const char *source)
4839 {
4840         debug_fenter(LOG_UI);
4841         cam_devman_haptic_play(100);
4842 /*      haptic_oneshot(100); */
4843 }
4844 #endif
4845
4846 static gboolean cam_app_timeout_checker_update()
4847 {
4848         struct appdata *ad = NULL;
4849         CamAppData *camapp = NULL;
4850         gdouble c_time = 0.0;
4851         cam_debug(LOG_UI, "");
4852
4853         ad = (struct appdata *)cam_appdata_get();
4854         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
4855         camapp = ad->camapp_handle;
4856         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
4857
4858         if (ad->timeout_checker) {
4859                 c_time = _get_current_time();
4860                 ecore_timer_delay(ad->timeout_checker,
4861                                   (c_time - camapp->last_time));
4862                 camapp->last_time = c_time;
4863         }
4864
4865         return TRUE;
4866 }
4867 void cam_app_zoom_warring_popup(void *data, const char *msg,
4868                           void (*func) (void *data, Evas_Object *obj, void *event_info))
4869 {
4870         struct appdata *ad = (struct appdata *)(data);
4871         ad->zoom_warring_popup = elm_popup_add(ad->win_main);
4872         evas_object_size_hint_weight_set(ad->zoom_warring_popup, EVAS_HINT_EXPAND,
4873                                          EVAS_HINT_EXPAND);
4874         elm_object_text_set(ad->zoom_warring_popup, msg);
4875         elm_popup_timeout_set(ad->zoom_warring_popup, 3.0);
4876         evas_object_smart_callback_add(ad->zoom_warring_popup, "timeout", func, data);
4877         evas_object_show(ad->zoom_warring_popup);
4878 }
4879 void cam_app_mdm_syspopup(void *data){
4880         struct appdata *ad = (struct appdata *)(data);
4881         cam_retm_if(ad == NULL, " appdata is NULL");
4882         bundle *b = NULL;
4883         b = bundle_create();
4884         if (b != NULL) {
4885                 bundle_add(b, "_SYSPOPUP_CONTENT_", _("IDS_CAM_POP_SECURITY_POLICY_RESTRICTS_USE_OF_CAMERA"));
4886                 syspopup_launch("mdm-syspopup", b);
4887                 bundle_free(b);
4888         }
4889         ecore_idler_add(cam_app_stop,ad);
4890         elm_exit();
4891 }
4892
4893
4894 void cam_app_notice_popup(void *data, const char *msg,
4895                           void (*func) (void *data,
4896                           Evas_Object *obj,
4897                           void *event_info)
4898                           )
4899 {
4900         struct appdata *ad = (struct appdata *)(data);
4901         cam_retm_if(ad == NULL, " appdata is NULL");
4902         cam_retm_if(ad->win_main == NULL, " ad->win_main is NULL");
4903         Evas_Object *popup = NULL;
4904         popup = elm_popup_add(ad->win_main);
4905         if (popup == NULL)
4906                 return;
4907         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
4908                                          EVAS_HINT_EXPAND);
4909         elm_object_text_set(popup, msg);
4910         /*elm_popup_mode_set(popup, ELM_POPUP_TYPE_ALERT);*/
4911         elm_popup_timeout_set(popup, 3.0);
4912         evas_object_smart_callback_add(popup, "timeout", func, data);
4913         ad->waring_popup = popup;
4914         evas_object_show(popup);
4915 }
4916 void cam_app_snapshot_popup(void *data, const char *msg,
4917                           void (*func) (void *data, Evas_Object *obj, void *event_info))
4918 {
4919         struct appdata *ad = (struct appdata *)(data);
4920         cam_retm_if(ad == NULL, " appdata is NULL");
4921         cam_retm_if(ad->win_main == NULL, " ad->win_main is NULL");
4922         Evas_Object *popup = NULL;
4923         popup = elm_popup_add(ad->win_main);
4924         if (popup == NULL)
4925                 return;
4926         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND,
4927                                          EVAS_HINT_EXPAND);
4928         elm_object_text_set(popup, msg);
4929         /*elm_popup_mode_set(popup, ELM_POPUP_TYPE_ALERT);*/
4930         elm_popup_timeout_set(popup, 1.5);
4931         evas_object_smart_callback_add(popup, "timeout", func, data);
4932         ad->is_showing_snapshot_popup = TRUE; /*result popup is showing*/
4933         DEBUG_TRACE("ad->is_showing_snapshot_popup = TRUE");
4934         evas_object_show(popup);
4935 }
4936
4937 static void cam_app_capture_error_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
4938 {
4939         struct appdata *ad = (struct appdata *)cam_appdata_get();
4940         cam_retm_if(ad == NULL, " appdata is NULL");
4941         CamAppData *camapp = ad->camapp_handle;
4942         cam_retm_if(camapp == NULL, " camapp is NULL");
4943         if (obj)
4944                 evas_object_del(obj);
4945         obj = NULL;
4946         cam_mm_capture_stop(FALSE, camapp->camera_mode);
4947         cam_app_exit(ad);
4948 }
4949
4950 void cam_app_timeout_notice_response_cb(void *data, Evas_Object *obj,
4951                                         void *event_info)
4952 {
4953         struct appdata *ad = (struct appdata *)cam_appdata_get();
4954         cam_retm_if(ad == NULL, " appdata is NULL");
4955         if (obj)
4956                 evas_object_del(obj);
4957         obj = NULL;
4958         cam_app_exit(ad);
4959 }
4960
4961 /*set flash close*/
4962 void cam_close_flash_feature(void *data)
4963 {
4964         struct appdata *ad = (struct appdata *)data;
4965         cam_retm_if(ad == NULL, " appdata is NULL");
4966         CamAppData *camapp = ad->camapp_handle;
4967         cam_retm_if(camapp == NULL, " appdata is NULL");
4968         if (camapp->flash > CAM_FLASH_OFF) {
4969                 GValue value = { 0 };
4970                 CAM_GVALUE_SET_INT(value, CAM_FLASH_OFF);
4971                 gint tempval = g_value_get_int(&value);
4972                 if (!cam_mm_set_flash(tempval)) {
4973                         cam_warning(LOG_UI, "flash set fail");
4974                         return;
4975                 }
4976                 camapp->flash = tempval;
4977         }
4978 }
4979 /*lowbattery callback*/
4980 void cam_app_lowbattery_close_flash_cb(void *data, Evas_Object *obj, void *event_info)
4981 {
4982         struct appdata *ad = (struct appdata *)cam_appdata_get();
4983         cam_retm_if(ad == NULL, " appdata is NULL");
4984         if (obj)
4985                 evas_object_del(obj);
4986         obj = NULL;
4987         cam_close_flash_feature(ad);
4988
4989         cam_toolbar_update(ad);
4990 }
4991
4992 static void cam_app_auto_close_popup_response_ok_cb(void *data, Evas_Object *obj,
4993                                                  void *event_info)
4994
4995 {
4996         struct appdata *ad = (struct appdata *)cam_appdata_get();
4997         cam_retm_if(ad == NULL, " appdata is NULL");
4998
4999         if (ad->auto_close_timer) {
5000                 ecore_timer_del(ad->auto_close_timer);
5001                 ad->auto_close_timer = NULL;
5002         }
5003         cam_app_timeout_checker_remove();
5004         if (ad->auto_close_popup)
5005                 evas_object_del(ad->auto_close_popup);
5006         ad->auto_close_popup = NULL;
5007         cam_app_exit(ad);
5008
5009 }
5010
5011 static void cam_app_auto_close_popup_response_cancel_cb(void *data, Evas_Object *obj,
5012                                                  void *event_info)
5013
5014 {
5015         struct appdata *ad = (struct appdata *)cam_appdata_get();
5016         cam_retm_if(ad == NULL, " appdata is NULL");
5017         if (ad->auto_close_timer) {
5018                 ecore_timer_del(ad->auto_close_timer);
5019                 ad->auto_close_timer = NULL;
5020         }
5021         if (ad->auto_close_popup)
5022                 evas_object_del(ad->auto_close_popup);
5023         ad->auto_close_popup = NULL;
5024         cam_app_timeout_checker_init(ad);
5025 }
5026
5027 void cam_app_auto_close_popup(void *data, const char *msg,
5028                               void (*func) (void *data, Evas_Object *obj,
5029                                             void *event_info))
5030 {
5031         struct appdata *ad = (struct appdata *)(data);
5032         cam_retm_if(ad == NULL, " appdata is NULL");
5033         if (ad->auto_close_popup) {
5034                 evas_object_del(ad->auto_close_popup);
5035                 ad->auto_close_popup = NULL;
5036         }
5037         ad->auto_close_popup = elm_popup_add(ad->win_main);
5038         if (ad->auto_close_popup == NULL)
5039                 return;
5040         evas_object_size_hint_weight_set(ad->auto_close_popup, EVAS_HINT_EXPAND,
5041                                          EVAS_HINT_EXPAND);
5042         elm_popup_timeout_set(ad->auto_close_popup, 9.0);
5043         elm_object_text_set(ad->auto_close_popup, msg);
5044         Evas_Object *btn1 = elm_button_add(ad->auto_close_popup);
5045         if (btn1 == NULL) {
5046                 evas_object_del(ad->auto_close_popup);
5047                 ad->auto_close_popup = NULL;
5048                 return;
5049         }
5050         elm_object_text_set(btn1, dgettext("sys_string", "IDS_COM_SK_OK"));
5051         elm_object_part_content_set(ad->auto_close_popup, "button1", btn1);
5052         evas_object_smart_callback_add(btn1, "clicked", cam_app_auto_close_popup_response_ok_cb, (void*)ad);
5053         Evas_Object *btn2 = elm_button_add(ad->auto_close_popup);
5054         if (btn2 == NULL) {
5055                 evas_object_del(ad->auto_close_popup);
5056                 ad->auto_close_popup = NULL;
5057                 btn1 = NULL;
5058                 return;
5059         }
5060         elm_object_text_set(btn2, dgettext("sys_string", "IDS_COM_SK_CANCEL"));
5061         elm_object_part_content_set(ad->auto_close_popup, "button2", btn2);
5062         evas_object_smart_callback_add(btn2, "clicked", cam_app_auto_close_popup_response_cancel_cb, (void*)ad);
5063
5064         evas_object_show(ad->auto_close_popup);
5065
5066 }
5067
5068 #if 0
5069 static Eina_Bool cam_app_auto_close_task(void *data)
5070 {
5071         DEBUG_TRACE(" ");
5072         int num;
5073         char *str = NULL;
5074         char *msg = _("IDS_CAM_POP_CLOSE_CAMERA_IN_PD_SECONDS");
5075         num = 1+ snprintf(NULL, 0, msg, AUTO_CLOSE_COUNT);
5076         DEBUG_TRACE("%d",num);
5077         str = (char *)malloc(num);
5078         if (str) {
5079                 memset(str, 0x00, num);
5080                 snprintf(str, num, msg, AUTO_CLOSE_COUNT);
5081                 DEBUG_TRACE("%s",str);
5082                 cam_app_auto_close_popup(data, str, NULL);
5083                 free(str);
5084                 str = NULL;
5085         }
5086
5087         return ECORE_CALLBACK_CANCEL;
5088 }
5089 #endif
5090
5091 static Eina_Bool cam_app_auto_close_timer_cb(void *data)
5092 {
5093         struct appdata *ad = (struct appdata *)(data);
5094         CamAppData *camapp = NULL;
5095         gdouble diff = 0.0;
5096         int count = 10;
5097
5098         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
5099         camapp = ad->camapp_handle;
5100         cam_retvm_if(camapp == NULL, 0, "cam_handle is NULL");
5101
5102         diff = _get_current_time() - camapp->last_time;
5103
5104         ad->auto_close_count++;
5105
5106         count = count - ad->auto_close_count;
5107
5108         if ((cam_mm_get_state() == CAMERA_STATE_PREVIEW)
5109             && (diff >= CAMERA_APP_TIMEOUT + 10)) {
5110                 cam_debug(LOG_UI,
5111                           "Quit camera application !!!   diff time : [%lf]",
5112                           diff);
5113                 cam_app_timeout_checker_remove();
5114
5115                 cam_app_exit(ad);
5116
5117                 return ECORE_CALLBACK_CANCEL;
5118         }
5119         cam_debug(LOG_UI, "####diff time : [%lf]", diff);
5120
5121         return 1;
5122
5123 }
5124
5125 static Eina_Bool cam_app_timeout_checker_cb(void *data)
5126 {
5127         struct appdata *ad = (struct appdata *)(data);
5128         CamAppData *camapp = NULL;
5129         gdouble diff = 0.0;
5130
5131         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
5132         camapp = ad->camapp_handle;
5133         cam_retvm_if(camapp == NULL, 0, "cam_handle is NULL");
5134
5135         diff = _get_current_time() - camapp->last_time;
5136
5137         if ((cam_mm_get_state() == CAMERA_STATE_PREVIEW)
5138             && (diff >= CAMERA_APP_TIMEOUT)) {
5139                 cam_debug(LOG_UI,
5140                           "auto close popup is closeed after 10 secondes !!!   diff time : [%lf]",
5141                           diff);
5142                 ad->auto_close_count = 0;
5143                 ad->auto_close_timer =
5144                     ecore_timer_add(1, cam_app_auto_close_timer_cb, ad);
5145 //              ecore_idler_add(cam_app_auto_close_task, ad);
5146
5147         }
5148         cam_debug(LOG_UI, "diff time : [%lf]", diff);
5149         return 1;
5150 }
5151
5152 gboolean cam_app_timeout_checker_init(void *data)
5153 {
5154         struct appdata *ad = (struct appdata *)(data);
5155         CamAppData *camapp = NULL;
5156
5157         debug_fenter(LOG_CAM);
5158
5159         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5160         camapp = ad->camapp_handle;
5161         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
5162
5163         if (ad->timeout_checker) {
5164                 ecore_timer_del(ad->timeout_checker);
5165                 ad->timeout_checker = NULL;
5166         }
5167         if (ad->auto_close_timer) {
5168                 ecore_timer_del(ad->auto_close_timer);
5169                 ad->auto_close_timer = NULL;
5170         }
5171         if (ad->auto_close_popup) {
5172                 evas_object_del(ad->auto_close_popup);
5173                 ad->auto_close_popup = NULL;
5174         }
5175         if (ad->timer_timer) {
5176                 ad->timer_activated = false;
5177                 DEL_EVAS_OBJECT(ad->timer_icon_edje);
5178                 REMOVE_TIMER(ad->timer_timer);
5179         }
5180         ad->timeout_checker =
5181             ecore_timer_add(CAMERA_APP_TIMEOUT / 2, cam_app_timeout_checker_cb,
5182                             ad);
5183         camapp->last_time = _get_current_time();
5184
5185         return TRUE;
5186 }
5187
5188 gboolean cam_app_timeout_checker_remove(void)
5189 {
5190         struct appdata *ad = NULL;
5191         CamAppData *camapp = NULL;
5192
5193         debug_fenter(LOG_CAM);
5194
5195         ad = (struct appdata *)cam_appdata_get();
5196         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5197         camapp = ad->camapp_handle;
5198         cam_retvm_if(camapp == NULL, FALSE, "cam_handle is NULL");
5199
5200         if (ad->timeout_checker) {
5201                 ecore_timer_del(ad->timeout_checker);
5202                 ad->timeout_checker = NULL;
5203         }
5204         camapp->last_time = 0;
5205
5206         return TRUE;
5207 }
5208
5209 #ifdef USE_FIFO_THREAD
5210 void *cam_app_FIFO_thread_run(void *data)
5211 {
5212         struct appdata *ad = (struct appdata *)data;
5213
5214         int fd = 0;
5215
5216         char buf[128] = { '\0', };
5217
5218         cam_retvm_if(ad == NULL, NULL, "appdata is NULL");
5219
5220         if (!access(CAM_FIFO_PATH, F_OK)) {
5221                 unlink(CAM_FIFO_PATH);
5222         }
5223
5224         if (-1 == mkfifo(CAM_FIFO_PATH, 0666)) {
5225                 cam_critical(LOG_SYS, " Make CamApp FIFO failed.");
5226                 elm_exit();
5227         }
5228
5229         fd = open(CAM_FIFO_PATH, O_RDWR);
5230         if (fd < 0) {
5231                 cam_critical(LOG_SYS, " Open CamApp FIFO failed.");
5232                 elm_exit();
5233         }
5234
5235         cam_debug(LOG_SYS, "Open CamApp FIFO [%s] success", CAM_FIFO_PATH);
5236
5237         while (1) {
5238                 memset(buf, 0x00, 128);
5239
5240                 cam_debug(LOG_SYS, " Wait CamApp FIFO write...");
5241
5242                 int count = read(fd, buf, 128);
5243                 if (count == -1)
5244                         cam_debug(LOG_SYS, " read error occur!");
5245
5246                 cam_debug(LOG_SYS, " Read from CamApp FIFO : [%s]", buf);
5247
5248                 if (!strcmp(buf, CAM_CAPTURE_AUTO_START)) {
5249                         cam_debug(LOG_SYS, " #### Start _auto_shot_idle_cb");
5250                         _auto_shot_idle_cb(data);
5251                 } else if (!strcmp(buf, CAM_FIFO_CMD_EXIT)) {
5252                         break;
5253                 } else {
5254                         /* Error */
5255                         cam_warning(LOG_SYS, " Skip this...");
5256                 }
5257         }
5258
5259         close(fd);
5260         unlink(CAM_FIFO_PATH);
5261
5262         cam_debug(LOG_SYS, " Exit CamApp FIFO thread...");
5263
5264         return NULL;
5265 }
5266
5267 void cam_app_FIFO_thread_exit()
5268 {
5269         int fd = open(CAM_FIFO_PATH, O_WRONLY);
5270         char *str_write = CAM_FIFO_CMD_EXIT;
5271
5272         if (fd < 0) {
5273                 cam_critical(LOG_SYS, " Open CammApp FIFO file[%s] failed",
5274                              CAM_FIFO_PATH);
5275         } else {
5276                 int count = write(fd, str_write, strlen(str_write));
5277                 if (count == -1)
5278                         cam_debug(LOG_SYS, " write error occur! ");
5279                 close(fd);
5280
5281                 cam_debug(LOG_SYS, " Write [%s] to FIFO Done.", str_write);
5282         }
5283 }
5284
5285 #endif
5286
5287 #ifdef USE_FILE_REG_THREAD
5288
5289 gboolean cam_app_create_file_register_thread(void *data)
5290 {
5291         struct appdata *ad = (struct appdata *)data;
5292
5293         int err = 0;
5294         cam_debug(LOG_SYS, "");
5295
5296         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5297
5298         err = pthread_mutex_init(&(ad->file_reg_mutex), NULL);
5299         if (err != 0) {
5300                 cam_critical(LOG_CAM,
5301                              "Create Camera file register mutex failed");
5302                 return FALSE;
5303         }
5304
5305         err = pthread_cond_init(&(ad->file_reg_cond), NULL);
5306         if (err != 0) {
5307                 cam_critical(LOG_CAM,
5308                              "Create Camera file register cond failed");
5309                 return FALSE;
5310         }
5311
5312         ad->file_reg_queue = g_queue_new();
5313         if (ad->file_reg_queue == NULL) {
5314                 cam_critical(LOG_CAM,
5315                              "Create Camera file register queue failed");
5316                 return FALSE;
5317         }
5318
5319         err =
5320             pthread_create(&(ad->file_reg_thread), NULL,
5321                            cam_app_file_register_thread_run, (void *)ad);
5322         if (err != 0) {
5323                 cam_critical(LOG_CAM,
5324                              "Create Camera file register thread failed");
5325                 return FALSE;
5326         }
5327
5328         return TRUE;
5329 }
5330
5331 void *cam_app_file_register_thread_run(void *data)
5332 {
5333         struct appdata *ad = (struct appdata *)data;
5334         gboolean Exit_loop = FALSE;
5335
5336         cam_debug(LOG_FILE, "");
5337
5338         pthread_mutex_lock(&ad->file_reg_mutex);
5339
5340         while (!Exit_loop) {
5341                 cam_debug(LOG_FILE, " wait signal...");
5342
5343                 pthread_cond_wait(&ad->file_reg_cond, &ad->file_reg_mutex);
5344
5345                 cam_debug(LOG_FILE, " signal received");
5346
5347                 while (!g_queue_is_empty(ad->file_reg_queue)) {
5348                         char *filename = NULL;
5349                         filename = g_queue_pop_head(ad->file_reg_queue);
5350
5351                         if (!strcmp(REG_THREAD_EXIT, filename)) {
5352                                 free(filename);
5353                                 Exit_loop = TRUE;
5354                                 break;
5355                         } else {
5356                                 __cam_single_shot_reg_file(filename);
5357                                 free(filename);
5358                                 cam_debug(LOG_FILE, " register done.");
5359                         }
5360                 }
5361         }
5362
5363         pthread_mutex_unlock(&ad->file_reg_mutex);
5364
5365         pthread_mutex_destroy(&ad->file_reg_mutex);
5366         pthread_cond_destroy(&ad->file_reg_cond);
5367
5368         cam_debug(LOG_SYS, " thread exit...");
5369
5370         return NULL;
5371 }
5372
5373 void cam_app_file_register_thread_exit(void *data)
5374 {
5375         struct appdata *ad = (struct appdata *)data;
5376         char *exit_cmd = NULL;
5377
5378         if (ad->file_reg_queue != NULL) {
5379                 exit_cmd = strdup(REG_THREAD_EXIT);
5380                 g_queue_push_tail(ad->file_reg_queue, exit_cmd);
5381                 pthread_cond_signal(&ad->file_reg_cond);
5382         }
5383         return;
5384 }
5385 #endif
5386 gboolean cam_app_init_with_args(void *data)
5387 {
5388         struct appdata *ad = (struct appdata *)data;
5389         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5390         cam_retvm_if(ad->camapp_handle == NULL, FALSE, "camapp is NULL");
5391
5392         cam_debug(LOG_SYS, "");
5393         if (ad->launching_mode == CAM_LAUNCHING_MODE_EXTERNAL) {
5394                 ad->camapp_handle->camera_mode = ad->exe_args->cam_mode;
5395                 if (CAM_CAMCORDER_MODE == ad->camapp_handle->camera_mode) {
5396                         if (ad->exe_args->resolution == CAM_RESOLUTION_QCIF) {
5397                                 ad->camapp_handle->recording_mode = CAM_RECORD_MMS;
5398                                 ad->camapp_handle->resolution = CAM_RESOLUTION_QCIF;
5399                                 ad->camapp_handle->fps = FPS_SLOW;
5400                                 if (ad->exe_args->size_limit <= 0) {
5401                                         ad->camapp_handle->size_limit = CAM_REC_MMS_MAX_SIZE;
5402                                 } else {
5403                                         ad->camapp_handle->size_limit = ad->exe_args->size_limit;
5404                                 }
5405                                 ad->camapp_handle->size_limit_type = CAM_MM_SIZE_LIMIT_TYPE_BYTE;
5406                         } else {
5407                                 ad->camapp_handle->recording_mode = CAM_RECORD_NORMAL;
5408                                 ad->camapp_handle->resolution = ad->exe_args->resolution;
5409                                 ad->camapp_handle->fps = FPS_DEFAULT;
5410                         }
5411                 } else {
5412                         ad->camapp_handle->shooting_mode = CAM_SINGLE_MODE;
5413                         if (ad->exe_args->width <= 0
5414                             || ad->exe_args->height <= 0) {
5415                                 ad->camapp_handle->resolution = CAM_RESOLUTION_VGA;
5416                         } else {
5417                                 ad->camapp_handle->resolution = CAM_RESOLUTION(ad->exe_args->width, ad->exe_args->height);
5418                         }
5419                         ad->camapp_handle->review = ad->exe_args->review;
5420                 }
5421         } else {
5422                 cam_debug(LOG_SYS, " camera launch mode is normal.");
5423                 return FALSE;
5424         }
5425
5426         cam_debug(LOG_SYS, " done");
5427
5428         return TRUE;
5429 }
5430
5431 Eina_Bool cam_app_focus_guide_create(void *data)
5432 {
5433         struct appdata *ad = (struct appdata *)data;
5434         cam_retv_if(ad == NULL, EINA_FALSE);
5435
5436         DEL_EVAS_OBJECT(ad->focus_edje);
5437
5438         ad->focus_edje =
5439                 cam_app_load_edj(ad->layout_main, CAM_UTILS_EDJ_NAME, "focus_image");
5440         if (ad->focus_edje == NULL) {
5441                 cam_critical(LOG_UI, "focus_edje load failed ");
5442                 return EINA_FALSE;
5443         }
5444
5445         evas_object_resize(ad->focus_edje, ad->camera_focus_w, ad->camera_focus_h);
5446         DEBUG_TRACE("#######################################\n");
5447         DEBUG_TRACE(" MOVE FOCUS_EDJE : %f, %f", ad->af_start_x, ad->af_start_y);
5448         evas_object_move(ad->focus_edje, ad->af_start_x, ad->af_start_y);
5449         evas_object_show(ad->focus_edje);
5450         DEBUG_TRACE("#######################################\n");
5451
5452 #ifdef  CAMERA_MACHINE_I686
5453         evas_object_hide(ad->focus_edje);
5454 #endif
5455
5456         return EINA_TRUE;
5457 }
5458
5459 Eina_Bool cam_app_focus_guide_update(void *data)
5460 {
5461 #ifndef CAMERA_MACHINE_I686
5462         struct appdata *ad = (struct appdata *)data;
5463         cam_retv_if(ad == NULL, EINA_FALSE);
5464
5465         CamAppData *camapp = NULL;
5466
5467         if (ad->focus_edje == NULL) {
5468                 return EINA_FALSE;
5469         }
5470
5471         /*note: relocation the focus edje*/
5472         evas_object_resize(ad->focus_edje, ad->camera_focus_w, ad->camera_focus_h);
5473         evas_object_move(ad->focus_edje, ad->af_start_x, ad->af_start_y);
5474         evas_object_show(ad->focus_edje);
5475
5476         if (ad->setting_ctxpopup
5477                 || (ad->toolbar_show_setting_popup == TRUE)
5478                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)) {
5479                 cam_debug(LOG_UI, "do not need to update focus");
5480                 edje_object_signal_emit(_EDJ(ad->focus_edje), "focus,hide", "program");
5481                 return EINA_FALSE;
5482         }
5483
5484         camapp = ad->camapp_handle;
5485         if (camapp == NULL) {
5486                 return EINA_FALSE;
5487         }
5488         if (ad->mm_state == CAMERA_STATE_CAPTURING
5489                 && camapp->camera_mode == CAM_CAMERA_MODE) {
5490                 return EINA_FALSE;
5491         }
5492         if (ad->mm_state < CAMERA_STATE_PREVIEW || FALSE) {
5493                 edje_object_signal_emit(_EDJ(ad->focus_edje), "focus,hide", "program");
5494                 return EINA_FALSE;
5495         } else {
5496                 DEBUG_TRACE("focus-state = %d, shooting-mode = %d", camapp->focus_state, camapp->shooting_mode);
5497                 if (camapp->recording_mode == CAM_RECORD_SELF
5498                         || camapp->recording_mode == CAM_RECORD_SELF_MMS
5499                         || camapp->shooting_mode == CAM_SELF_MODE) {
5500                         edje_object_signal_emit(_EDJ(ad->focus_edje), "focus,hide", "program");
5501                 } else {
5502                         char signame[30] = { '\0', };
5503                         const char *focus_state_name[4] = {
5504                                 "notready",
5505                                 "notready",
5506                                 "focused",
5507                                 "failed",
5508                         };
5509
5510                         snprintf(signame, sizeof(signame), "%s,%s", "focus", focus_state_name[camapp->focus_state]);
5511
5512                         cam_debug(LOG_UI, "emit signal : %s", signame);
5513                         edje_object_signal_emit(_EDJ(ad->focus_edje), signame, "program");
5514                 }
5515         }
5516 #endif
5517         return EINA_TRUE;
5518 }
5519
5520 static int cam_app_state_manager(int previous, int current, gboolean by_asm)
5521 {
5522         struct appdata *ad = NULL;
5523         CamAppData *camapp = NULL;
5524
5525         cam_info(LOG_UI, "STATE_CHANGED : %d -> %d ", previous, current);
5526
5527         ad = (struct appdata *)cam_appdata_get();
5528         cam_retv_if(ad == NULL, FALSE);
5529
5530         camapp = ad->camapp_handle;
5531         cam_retv_if(camapp == NULL, FALSE);
5532
5533         ad->mm_state = current;
5534
5535         if (camapp->camera_mode == CAM_CAMERA_MODE) {
5536                 if (current == CAMERA_STATE_PREVIEW) {
5537                         if (previous == CAMERA_STATE_CAPTURING) {
5538                                 CAM_TA_ACUM_ITEM_END("    capture stop to preview", 0);
5539                                 CAM_TA_ACUM_ITEM_END("Total capture time", 0);
5540                                 cam_debug(LOG_MM, "capture end, preview start");
5541                         }
5542                 }
5543         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
5544                 if (((previous == RECORDER_STATE_RECORDING)
5545                     && (current != RECORDER_STATE_PAUSED))
5546                     ||((previous == RECORDER_STATE_PAUSED)
5547                     && (current != RECORDER_STATE_RECORDING))) {/*finished recording*/
5548
5549                         cam_info(LOG_UI, "Set gamma NORMAL");
5550                         CamIdlerItem *item = NULL;
5551                         item = (CamIdlerItem *)g_malloc(sizeof(CamIdlerItem));
5552                         if (item == NULL)
5553                                 return FALSE;
5554
5555
5556                         if (camapp->filename)
5557                                 free(camapp->filename);
5558                          cam_mm_get_filename(&camapp->filename,0);/*file size not used,so set to 0*/
5559                          cam_info(LOG_UI, "Recorded file name [%s] ", camapp->filename);
5560
5561                         if (item) {
5562                                 item->data = (void*)ad;
5563                                 item->idler = ecore_idler_add(cam_video_capture_handle_idler, item);
5564
5565                                 if (item->idler)
5566                                         ad->capture_cb_list = g_list_append(ad->capture_cb_list, item->idler);
5567
5568                                 cam_info(LOG_UI, "video capture idler add : %p ", item->idler);
5569                         }
5570
5571                 }
5572
5573         }
5574
5575         return 1;
5576 }
5577
5578 gboolean cam_app_exit(void *data)
5579 {
5580
5581         struct appdata *ad = (struct appdata *)data;
5582         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5583
5584         cam_app_stop(ad);
5585         elm_exit();
5586         return TRUE;
5587 ;
5588 }
5589
5590 static void cam_mmc_state_change_cb(keynode_t *key, void *data)
5591 {
5592         struct appdata *ad = (struct appdata *)data;
5593         CamAppData *camapp = NULL;
5594         int mmc_state = vconf_keynode_get_int(key);
5595
5596         cam_retm_if(ad == NULL, "appdata is NULL");
5597         camapp = ad->camapp_handle;
5598         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
5599
5600         cam_debug(LOG_SYS, " start");
5601
5602         if (mmc_state == VCONFKEY_SYSMAN_MMC_REMOVED
5603             && camapp->storage == CAM_STORAGE_EXTERNAL) {
5604 #ifdef USE_CAM_STORAGE_SETTING
5605                 GValue value = { 0 };
5606 #endif
5607                 int mm_state = cam_mm_get_state();
5608
5609                 if ((mm_state == RECORDER_STATE_RECORDING
5610                     || mm_state == RECORDER_STATE_PAUSED)
5611                     &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
5612                         cam_video_record_cancel(ad);
5613                         cam_app_notice_popup(ad,
5614                                 _("IDS_CAM_POP_REMOVE_MMC_RECORDING"),
5615                                 cam_app_popup_response_cb);
5616                 }
5617 #ifndef CAMERA_MACHINE_I686
5618                 else if (mm_state != CAMERA_STATE_CAPTURING
5619                          &&camapp->camera_mode == CAM_CAMERA_MODE) {
5620                         if (cam_app_check_blocking_popup()) {
5621                                 cam_app_notice_popup(ad,
5622                                         _("IDS_CAM_POP_MEMORY_CARD_REMOVED"),
5623                                         cam_app_popup_response_cb);
5624                         }
5625                 }
5626 #endif
5627
5628 #ifdef USE_CAM_STORAGE_SETTING
5629                 CAM_GVALUE_SET_INT(value, CAM_STORAGE_INTERNAL);
5630                 cam_handle_value_set(ad, PROP_STORAGE, &value);
5631 #endif
5632                 cam_info(LOG_UI, "MMC card is removed");
5633         }
5634         return;
5635 }
5636
5637 #ifdef CAMAPP_SIG_HANDLING
5638 /**
5639 * This function registers a user space signal handler for the signal SIGSEGV (Signal #11)
5640 *
5641 * @return               nothing
5642 */
5643 static void cam_app_register_sigsegv(void)
5644 {
5645         debug_fenter(LOG_SYS);
5646
5647         /* cam_app_act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; */
5648         cam_app_act.sa_flags = SA_SIGINFO;
5649         cam_app_act.sa_handler = (void *)cam_app_sigsegv_handler;
5650         sigemptyset(&cam_app_act.sa_mask);
5651
5652 #ifdef ENABLE_CHECK_CAM_STATUS
5653         sigaction(SIGALRM, &cam_app_act, &cam_app_act_old);     /* register an action with a previous action */
5654 #endif
5655         sigaction(SIGABRT, &cam_app_act, &cam_app_act_old);
5656         sigaction(SIGSEGV, &cam_app_act, &cam_app_act_old);
5657         sigaction(SIGILL, &cam_app_act, &cam_app_act_old);
5658
5659         debug_fleave(LOG_SYS);
5660 }
5661
5662 static void
5663 cam_app_sigsegv_handler(int signal_no, siginfo_t *info, void *context)
5664 {
5665         debug_fenter(LOG_SYS);
5666
5667         cam_debug(LOG_SYS, "signal_no = %d", signal_no);
5668
5669         if (signal_no == SIGALRM) {     /* if alarm, check the camera status. */
5670 #ifdef ENABLE_CHECK_CAM_STATUS
5671                 cam_app_check_status();
5672                 alarm(CAM_CHECK_STATUS_INTERVAL_TIME);
5673 #endif
5674                 return;
5675         } else {
5676                 sigaction(signal_no, &cam_app_act_old, NULL);   /*  register the previous action */
5677                 raise(signal_no);
5678         }
5679
5680         debug_fleave(LOG_SYS);
5681 }
5682
5683 #endif
5684
5685 gboolean cam_app_black_screen_show(void *data, int mode)
5686 {
5687         struct appdata *ad = (struct appdata *)data;
5688         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5689         Evas_Coord witdh = 0, height = 0;
5690
5691         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_black_screen_show", 0);
5692
5693         cam_debug(LOG_UI, "~~~~~~~~~~~ mode :%d", mode);
5694         if (ad->black_screen) {
5695                 evas_object_del(ad->black_screen);
5696                 ad->black_screen = NULL;
5697         } else {
5698                 ad->black_screen =
5699                     cam_app_load_edj(ad->win_main, CAM_MAIN_LAYOUT_EDJ_NAME,
5700                                      "black_screen");
5701                 if (ad->black_screen == NULL) {
5702                         cam_critical(LOG_UI, "black_screen load failed ");
5703                         CAM_TA_ACUM_ITEM_END("      cam_app_black_screen_show",
5704                                              0);
5705                         return FALSE;
5706                 }
5707         }
5708         evas_object_geometry_get(ad->win_main, NULL, NULL, &witdh, &height);
5709         evas_object_resize(ad->black_screen, witdh, height);
5710
5711         evas_object_raise(ad->black_screen);
5712         evas_object_show(ad->black_screen);
5713         evas_object_show(ad->win_main);
5714         evas_render(ad->evas);
5715
5716         CAM_TA_ACUM_ITEM_END("      cam_app_black_screen_show", 0);
5717         return TRUE;
5718 }
5719
5720 gboolean cam_app_black_screen_hide(void *data)
5721 {
5722         struct appdata *ad = (struct appdata *)data;
5723         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5724         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_black_screen_hide", 0);
5725         if (ad->black_screen) {
5726                 evas_object_del(ad->black_screen);
5727                 ad->black_screen = NULL;
5728                 edje_file_cache_flush();
5729         }
5730 /*      evas_render(ad->evas); */
5731         CAM_TA_ACUM_ITEM_END("      cam_app_black_screen_hide", 0);
5732         return TRUE;
5733 }
5734
5735 #ifdef ENABLE_CAPTURE_ANIMATION
5736
5737 static void __cam_app_shutter_animation_finished(void *data, Evas_Object *obj,
5738                                                  const char *emission,
5739                                                  const char *source)
5740 {
5741         cam_debug(LOG_MM, " __cam_app_shutter_animation_finished \n\n ");
5742
5743         struct appdata *ad = (struct appdata *)data;
5744
5745         DEL_EVAS_OBJECT(ad->shutter_screen);
5746
5747 }
5748
5749 static gboolean cam_app_shutter_screen_show(void *data)
5750 {
5751         struct appdata *ad = (struct appdata *)data;
5752         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
5753         Evas_Coord witdh = 0, height = 0;
5754
5755         char *group_name = "shutter_image";
5756
5757         CAM_TA_ACUM_ITEM_BEGIN("      cam_app_shutter_screen_show", 0);
5758
5759         if (ad->shutter_screen) {
5760                 evas_object_del(ad->shutter_screen);
5761                 ad->shutter_screen = NULL;
5762         }
5763
5764         ad->shutter_screen =
5765             cam_app_load_edj(ad->win_main, CAM_MAIN_LAYOUT_EDJ_NAME,
5766                              group_name);
5767         if (ad->shutter_screen == NULL) {
5768                 cam_critical(LOG_UI, "shutter_screen load failed ");
5769                 CAM_TA_ACUM_ITEM_END("      cam_app_shutter_screen_show", 0);
5770                 return FALSE;
5771         }
5772
5773         evas_object_geometry_get(ad->win_main, NULL, NULL, &witdh, &height);
5774         evas_object_resize(ad->shutter_screen, witdh, height);
5775         /* evas_object_resize(ad->black_screen, ad->win_width, ad->win_height); */
5776
5777         /*evas_object_lower(ad->shutter_screen);*/
5778         evas_object_show(ad->shutter_screen);
5779         evas_object_show(ad->win_main);
5780 /*       evas_render(ad->evas); */
5781
5782         edje_object_signal_emit(_EDJ(ad->shutter_screen), "start_animation",
5783                                 "");
5784
5785         edje_object_signal_callback_add(_EDJ(ad->shutter_screen),
5786                                         "animation_finish", "*",
5787                                         __cam_app_shutter_animation_finished,
5788                                         ad);
5789
5790 /*      ecore_timer_add(0.1, cam_app_shutter_timer_cb, ad); */
5791
5792         CAM_TA_ACUM_ITEM_END("      cam_app_shutter_screen_show", 0);
5793         return TRUE;
5794 }
5795 #endif
5796 #ifdef ENABLE_CHECK_CAM_STATUS
5797
5798 static void cam_app_check_status()
5799 {
5800         cam_debug(LOG_SYS, "check status");
5801 }
5802 #endif                          /* ENABLE_CHECK_CAM_STATUS */
5803
5804 static int cam_app_preview_unlock(void *data)
5805 {
5806         struct appdata *ad = (struct appdata *)data;
5807         CamAppData *camapp = NULL;
5808         cam_retv_if(ad == NULL, FALSE);
5809
5810         camapp = ad->camapp_handle;
5811         if (camapp == NULL) {
5812                 cam_critical(LOG_UI, "handle is NULL");
5813                 elm_exit();
5814         }
5815
5816         elm_win_indicator_mode_set(ad->win_main, 0);
5817
5818         return 0;
5819 }
5820
5821 static int cam_app_preview_lock(void *data)
5822 {
5823         struct appdata *ad = (struct appdata *)data;
5824
5825         if (ad == NULL) {
5826                 cam_critical(LOG_UI, "handle is NULL");
5827                 elm_exit();
5828         }
5829
5830         evas_object_hide(ad->timer_icon_edje);
5831         REMOVE_TIMER(ad->timer_timer);
5832         ad->timer_activated = false;
5833         DEL_EVAS_OBJECT(ad->timer_icon_edje);
5834         cam_app_timeout_checker_remove();
5835         if(!cam_key_grab_deinit(ad))
5836                 DEBUG_TRACE("cam_key_grab_deinit fail");
5837         cam_app_key_event_deinit(ad);
5838
5839         return 0;
5840 }
5841
5842 static void cam_idle_lockstate_change_cb(keynode_t *key, void *data)
5843 {
5844         struct appdata *ad = (struct appdata *)data;
5845         CamAppData *camapp = NULL;
5846         int cam_state = -1;
5847         int lock_state = vconf_keynode_get_int(key);
5848         cam_retm_if(ad == NULL, "appdata is NULL");
5849         camapp = ad->camapp_handle;
5850         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
5851
5852         cam_debug(LOG_SYS, "#################IDLE LOCK state changed : %d",
5853                   lock_state);
5854         cam_state = cam_mm_get_state();
5855
5856         if (lock_state) {
5857                 DEBUG_TRACE(" ");
5858                 cam_app_preview_lock(ad);
5859         } else if (!lock_state) {
5860                 DEBUG_TRACE(" ");
5861                 cam_app_preview_unlock(ad);
5862         }
5863         return;
5864 }
5865
5866 static void cam_usb_state_change_cb(keynode_t *key, void *data)
5867 {
5868         struct appdata *ad = (struct appdata *)data;
5869         CamAppData *camapp = NULL;
5870         int usb_state = vconf_keynode_get_int(key);
5871         int mm_state = cam_mm_get_state();
5872
5873         cam_retm_if(ad == NULL, "appdata is NULL");
5874         camapp = ad->camapp_handle;
5875         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
5876
5877         if (usb_state > VCONFKEY_SYSMAN_USB_DISCONNECTED
5878             && (mm_state == RECORDER_STATE_RECORDING
5879                 || mm_state == RECORDER_STATE_PAUSED)
5880                 &&camapp->camera_mode == CAM_CAMCORDER_MODE) {
5881                 camapp->rec_stop_type = CAM_REC_STOP_USB_CONN;
5882                 cam_video_record_stop(ad);
5883         }
5884         return;
5885 }
5886
5887 #ifndef DISABLE_TOOLBAR_TOGGLE
5888 static Eina_Bool _cam_app_toolbar_toggle_timer(void *data)
5889 {
5890         struct appdata *ad = (struct appdata *)data;
5891         if (ad == NULL) {
5892                 goto exit_timer;
5893         }
5894         if (ad->mm_state != CAMERA_STATE_PREVIEW) {
5895                 goto exit_timer;
5896         }
5897
5898         ad->toolbar_hided = TRUE;
5899         cam_app_toggle_indicator(ad, TRUE);
5900         cam_app_toggle_toolbar(ad, TRUE);
5901
5902  exit_timer:
5903         if (ad->toolbar_toggle_timer)
5904                 ecore_timer_del(ad->toolbar_toggle_timer);
5905         ad->toolbar_toggle_timer = NULL;
5906         return EINA_FALSE;
5907 }
5908 #endif
5909
5910 void cam_app_toggle_indicator(void *data, gboolean hide)
5911 {
5912 #ifndef DISABLE_INDICATOR
5913         struct appdata *ad = (struct appdata *)data;
5914
5915         cam_retm_if(ad == NULL, "appdata is NULL");
5916
5917         if (ad->toolbar_toggle_timer) {
5918                 REMOVE_TIMER(ad->toolbar_toggle_timer);
5919         }
5920
5921         indicator_toggle(ad, hide);
5922 #endif
5923         return;
5924 }
5925
5926 void cam_app_toggle_toolbar(void *data, gboolean hide)
5927 {
5928 #ifndef DISABLE_TOOLBAR_TOGGLE
5929         struct appdata *ad = (struct appdata *)data;
5930
5931         cam_retm_if(ad == NULL, "appdata is NULL");
5932
5933         if (ad->toolbar_toggle_timer) {
5934                 REMOVE_TIMER(ad->toolbar_toggle_timer);
5935         }
5936
5937         if (hide) {
5938                 /* toolbar_hide_all_popup(ad); */
5939                 unload_settings_edje(ad);
5940                 hide_toolbar_edje(ad);
5941         } else {
5942                 show_toolbar_edje(ad);
5943         }
5944 #endif
5945         return;
5946 }
5947
5948 static void
5949 cam_app_reset_settings_launch_cb(void *data, Evas_Object *obj, void *event_info)
5950 {
5951         Evas_Object *notify = (Evas_Object *)data;
5952         GValue i_value = { 0, };
5953         GValue b_value = { 0, };
5954         struct appdata *ad = (struct appdata *)cam_appdata_get();
5955         CamAppData *camapp = NULL;
5956
5957         cam_debug(LOG_CAM, "!!!!!!!!!cam_app_reset_settings_launch_cb");
5958
5959         cam_retm_if(ad == NULL, " appdata is NULL");
5960         camapp = ad->camapp_handle;
5961         cam_retm_if(camapp == NULL, " cam_handle is NULL");
5962
5963         cam_popup_remove(notify);
5964         hide_toolbar_edje(ad);
5965
5966         cam_mm_preview_stop(camapp->camera_mode);       /* stop preview */
5967
5968         g_value_init(&i_value, G_TYPE_INT);
5969         g_value_init(&b_value, G_TYPE_BOOLEAN);
5970
5971         /* auto focus */
5972
5973         g_value_set_int(&i_value, AF_DEFAULT);
5974         cam_handle_value_set(ad, PROP_AF_MODE, &i_value);
5975
5976         /* Timer */
5977         g_value_set_int(&i_value, TIMER_DEFAULT);
5978         cam_handle_value_set(ad, PROP_TIMER, &i_value);
5979
5980         /* Effect */
5981         g_value_set_int(&i_value, EFFECT_DEFAULT);
5982         cam_handle_value_set(ad, PROP_EFFECT, &i_value);
5983
5984         /* Image quality */
5985         g_value_set_int(&i_value, QUALITY_DEFAULT);
5986         cam_handle_value_set(ad, PROP_IMAGE_QUALITY, &i_value);
5987
5988         /* Video quality */
5989         g_value_set_int(&i_value, QUALITY_DEFAULT);
5990         cam_handle_value_set(ad, PROP_VIDEO_QUALITY, &i_value);
5991
5992         /* Guide Line */
5993         g_value_set_boolean(&b_value, FALSE);
5994         cam_handle_value_set(ad, PROP_GUIDELINE, &b_value);
5995 #ifdef GUIDE_LINE_ENALBE
5996         settings_guideline_refresh(ad);
5997 #endif
5998         /* Review */
5999         g_value_set_boolean(&b_value, FALSE);
6000         cam_handle_value_set(ad, PROP_REVIEW, &b_value);
6001
6002         /* shutter sound */
6003         g_value_set_int(&i_value, SHUTTER_SOUND_DEFAULT);
6004         cam_handle_value_set(ad, PROP_SHUTTER_SOUND, &i_value);
6005
6006         /* audio recording */
6007         g_value_set_boolean(&b_value, TRUE);
6008         cam_handle_value_set(ad, PROP_AUDIO_REC, &b_value);
6009
6010         /* storage */
6011         g_value_set_int(&i_value, STORAGE_DEFAULT);
6012         cam_handle_value_set(ad, PROP_STORAGE, &i_value);
6013
6014         /* Resolution */
6015         if (camapp->camera_mode == CAM_CAMERA_MODE) {
6016                 g_value_set_int(&i_value, IMAGE_RESOLUTION_DEFAULT);
6017         } else {
6018                 g_value_set_int(&i_value, REC_RESOLUTION_DEFAULT);
6019         }
6020
6021         cam_handle_value_set(ad, PROP_RESOLUTION, &i_value);
6022 #ifndef DISABLE_INDICATOR
6023         if (ad->indicator_edje) {
6024                 /* delete indicator */
6025                 evas_object_hide(ad->indicator_edje);
6026                 cam_indicator_destory(ad);
6027         }
6028         cam_indicator_create(ad);
6029 #endif
6030         show_toolbar_edje(ad);
6031         cam_app_preview_start(ad);
6032 }
6033
6034 void cam_app_reset_settings(void *data)
6035 {
6036         struct appdata *ad = (struct appdata *)data;
6037         cam_retm_if(ad == NULL, "appdata is NULL");
6038         cam_popup_question_add(ad->win_main,
6039                                _("IDS_CAM_POP_RESET_CAMERA_SETTINGS"),
6040                                dgettext("sys_string", "IDS_COM_SK_YES"),
6041                                cam_app_reset_settings_launch_cb,
6042                                dgettext("sys_string", "IDS_COM_SK_NO"),
6043                                _popup_cancel_cb);
6044
6045 }
6046
6047 static gboolean __cam_toolbar_new_thumbnail_create(Evas_Object **obj,
6048                                                         struct appdata *ad,
6049                                                         Evas_Coord *thumbnail_x,
6050                                                         Evas_Coord *thumbnail_y,
6051                                                         Evas_Coord *thumbnail_w,
6052                                                         Evas_Coord *thumbnail_h)
6053 {
6054         cam_retv_if(ad == NULL, FALSE);
6055         CamAppData *camapp = ad->camapp_handle;
6056         cam_retv_if(camapp == NULL, FALSE);
6057         cam_retv_if(obj == NULL, FALSE);
6058         cam_retv_if(ad->evas == NULL, FALSE);
6059         cam_retv_if(ad->toolbar.quickview_item.edje == NULL, FALSE);
6060
6061         if(camapp->thumbnail_name == NULL) {
6062                 *obj = NULL;
6063                 return TRUE;
6064         }
6065         Evas_Object *new_thumbnail_img = elm_icon_add(ad->toolbar.quickview_item.edje);
6066         Evas_Coord x = 0, y = 0, w = 0, h = 0;
6067         Evas_Object *layout = NULL;
6068         Evas_Object *thumbnail_area = NULL;
6069
6070         cam_retv_if(new_thumbnail_img == NULL, FALSE);
6071         elm_icon_file_set(new_thumbnail_img, camapp->thumbnail_name, NULL);
6072         elm_icon_aspect_fixed_set(new_thumbnail_img, EINA_FALSE);
6073         elm_icon_resizable_set(new_thumbnail_img, EINA_TRUE, EINA_TRUE);
6074
6075         layout = elm_layout_edje_get(ad->toolbar.quickview_item.edje);
6076         thumbnail_area = (Evas_Object *) edje_object_part_object_get(layout,"thumbnail_area");
6077         cam_retv_if(thumbnail_area == NULL, FALSE);
6078         evas_object_geometry_get(thumbnail_area, &x, &y, &w, &h);
6079         *thumbnail_x = x;
6080         *thumbnail_y = y;
6081         *thumbnail_w = w;
6082         *thumbnail_h = h;
6083
6084         evas_object_resize(new_thumbnail_img, 0, 0);
6085         evas_object_move(new_thumbnail_img, x, y);
6086         evas_object_show(new_thumbnail_img);
6087         *obj = new_thumbnail_img;
6088         return TRUE;
6089 }
6090
6091 static void cam_app_pipe_handler(void *data, void *buffer, unsigned int nbyte)
6092 {
6093
6094         struct appdata *ad = (struct appdata *)data;
6095         cam_retm_if(ad == NULL, "appdata is NULL");
6096         if (buffer) {
6097                 DEBUG_TRACE();
6098                 /* Caution */
6099                 /* DO NOT free buffer in here */
6100                 /* buffer is freed by ecore */
6101
6102                 int main_pipe_type = *((int *)buffer);
6103                 DEBUG_TRACE("main_pipe_type %d", main_pipe_type);
6104                 switch (main_pipe_type) {
6105                 case CAM_MAIN_PIPE_OP_TYPE_UPDATE_THUMBNAIL: {
6106                                 Evas_Object *new_thumbnail_image = NULL;
6107                                 Evas_Coord x = 0, y = 0, w = 0, h = 0;
6108                                 gboolean ret = FALSE;
6109                                 ret = __cam_toolbar_new_thumbnail_create(&new_thumbnail_image, ad, &x, &y, &w, &h);
6110                                 if (ret == FALSE || !new_thumbnail_image) {
6111                                         if (!new_thumbnail_image && ret) {
6112                                                 DEL_EVAS_OBJECT(ad->toolbar.quickview_item.thumbnail_image);
6113                                         }
6114                                         return;
6115                                 }
6116                                 cam_ui_effect_utils_set_thumbnail_effect(new_thumbnail_image,
6117                                                                         x,
6118                                                                         y,
6119                                                                         w,
6120                                                                         h,
6121                                                                         CAM_THUMBNAIL_ANTIMATION_EFFECT_DURATION);
6122                         }
6123                         break;
6124                 case CAM_MAIN_PIPE_OP_TYPE_ROTATE_ANIMATOR: {
6125                                 ad->is_rotating = TRUE;
6126                                 cam_ui_rotate_utils_rotate_start(ad, CAM_ROTATE_ICONS_ANTIMATION_DURATION);
6127                         }
6128                         break;
6129                 default:
6130                         break;
6131                 }
6132         }
6133
6134         return;
6135 }
6136
6137 void cam_focus_edje_rotate(void *data)
6138 {
6139         struct appdata *ad = (struct appdata *)data;
6140         cam_retm_if(ad == NULL, "appdata is NULL");
6141
6142         DEL_EVAS_OBJECT(ad->focus_edje);
6143         ad->focus_edje = cam_app_load_edj(ad->layout_main, CAM_UTILS_EDJ_NAME, "focus_image");
6144
6145         cam_retm_if(ad->focus_edje == NULL, "focus_edje load failed");
6146
6147         evas_object_resize(ad->focus_edje, ad->camera_focus_w, ad->camera_focus_h);
6148         evas_object_move(ad->focus_edje, ad->af_start_x, ad->af_start_y);
6149         evas_object_show(ad->focus_edje);
6150
6151         cam_app_draw_af_box(ad);
6152         cam_app_focus_guide_update(ad);
6153 }
6154
6155
6156 Eina_Bool cam_screen_rotate(void *data)
6157 {
6158         struct appdata *ad = (struct appdata *)data;
6159         cam_retvm_if(ad == NULL, -1, "appdata is NULL");
6160
6161         /*cam_app_get_preview_offset_coordinate(ad);*/
6162
6163         if (ad->focus_edje)
6164                 cam_focus_edje_rotate(ad);
6165
6166         if (ad->timer_icon_edje)
6167                 cam_app_timer_icon_rotate(ad);
6168
6169         if (ad->toolbar_edje)
6170                 cam_toolbar_rotate(ad);
6171
6172         if (ad->recording_edje)
6173                 cam_recording_rotate(ad);
6174
6175         if (ad->indicator_edje) {
6176                 cam_debug(LOG_CAM, "indicator_edje rotate start");
6177                 cam_indicator_rotate(ad);
6178         }
6179
6180         if (ad->zoom_edje) {
6181                 unload_zoom_edje(ad);
6182                 load_zoom_edje(ad);
6183         }
6184
6185 #ifdef GUIDE_LINE_ENALBE
6186         if (ad->guideline_edje)
6187                 settings_guideline_refresh(ad);
6188 #endif
6189
6190         /*update thumbnail*/
6191         toolbar_update_quickview_thumbnail_no_animation(ad);
6192         /* rotate menu */
6193         if ((ad->show_menu == TRUE ) ||
6194                 (ad->show_menu == FALSE && ad->displayed_setting_popup != DISPLAY_NONE_POPUP )
6195                 || (ad->toolbar_show_edit_shortcuts_popup == TRUE)
6196                 || (ad->toolbar_show_setting_popup == TRUE)) {
6197                 /*ecore_idler_add(cam_show_setting_menu, ad);*/
6198                 /*note: use timer to delay creating the popup*/
6199                 ecore_timer_add(0.1, cam_show_setting_menu, ad);
6200         } else {
6201                 ad->is_rotating = FALSE;
6202         }
6203
6204         return ECORE_CALLBACK_CANCEL;
6205 }
6206
6207 static Ecore_Idler *rotate_delay_idler = NULL;
6208 Eina_Bool cam_app_screen_rotate_idler(void *data)
6209 {
6210         if (rotate_delay_idler) {
6211                 ecore_idler_del(rotate_delay_idler);
6212                 rotate_delay_idler = NULL;
6213         }
6214         struct appdata *ad = (struct appdata *)data;
6215         cam_retv_if(ad == NULL, ECORE_CALLBACK_CANCEL);
6216         if (ad->appcore_state == CAM_APPCORE_TERMINATE_STATE
6217                 || ad->appcore_state == CAM_APPCORE_PAUSE_STATE) {
6218                 ad->is_rotating = FALSE;
6219                 return ECORE_CALLBACK_CANCEL;
6220         }
6221         /*cam_toolbar_rotate(ad);*/
6222         cam_screen_rotate(ad);
6223         return ECORE_CALLBACK_CANCEL;
6224 }
6225
6226 void cam_app_screen_rotate(void *data)
6227 {
6228         struct appdata *ad = (struct appdata *)data;
6229         cam_ret_if(ad == NULL);
6230         if (ad->appcore_state == CAM_APPCORE_TERMINATE_STATE
6231                 || ad->appcore_state == CAM_APPCORE_PAUSE_STATE) {
6232                 ad->is_rotating = FALSE;
6233                 return;
6234         }
6235         CamAppData *cam_handle = ad->camapp_handle;
6236         cam_ret_if(cam_handle == NULL);
6237         DEBUG_TRACE("");
6238
6239         if (ad->toolbar_edje) {
6240                 rotate_delay_idler = ecore_idler_add(cam_app_screen_rotate_idler, data);
6241
6242         }
6243         /*cam_app_get_preview_offset_coordinate(ad);*/
6244 }
6245
6246 gboolean cam_app_get_resolution(int *width, int *height)
6247 {
6248         cam_retv_if(width == NULL || height == NULL, FALSE);
6249
6250         struct appdata *ad = (struct appdata *)cam_appdata_get();
6251         cam_retvm_if(ad == NULL, FALSE, "ad is NULL");
6252
6253         if (ad != NULL) {
6254                 CamAppData *camapp = ad->camapp_handle;
6255
6256                 if (camapp != NULL) {
6257                         *width = CAM_RESOLUTION_W(camapp->resolution);
6258                         *height = CAM_RESOLUTION_H(camapp->resolution);
6259
6260                         return TRUE;
6261                 }
6262         }
6263
6264         return FALSE;
6265 }
6266
6267 gboolean cam_app_reset_resolution(void *data, int width, int height)
6268 {
6269         struct appdata *ad = (struct appdata *)data;
6270         CamAppData *camapp = NULL;
6271         int state = 0;
6272         gboolean need_change_state = FALSE;
6273         gboolean ret = TRUE;
6274
6275         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6276         camapp = ad->camapp_handle;
6277         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6278
6279         state = cam_mm_get_state();
6280         if (state > CAMERA_STATE_CREATED)
6281                 need_change_state = TRUE;
6282
6283         cam_debug(LOG_MM,
6284                   " reset resolution = [%d x %d], current state = [%d], need_change_state = [%d]",
6285                   width, height, state, need_change_state);
6286
6287         if (camapp->camera_mode == CAM_CAMERA_MODE) {
6288 #ifdef ZSL_5M_TEST
6289                 if (camapp->shooting_mode == CAM_SINGLE_MODE
6290                     && (width * height == ZSL_5M_TEST))
6291 #else
6292                 if (0)          /*  camapp->shooting_mode == CAM_SINGLE_MODE  && (width*height <= ZSL_MAX_REL)) */
6293 #endif
6294                 {
6295                         cam_info(LOG_MM, " set real resolution [%dx%d] for zsl",
6296                                  width, height);
6297
6298                         ret &= cam_mm_set_image_size(width, height);
6299
6300                         if (need_change_state) {
6301                                 ret &= cam_mm_preview_stop(camapp->camera_mode);
6302                                 ret &= cam_mm_unrealize();
6303                                 ret &= cam_mm_set_video_size(width, height);
6304                                 ret &= cam_mm_realize();
6305                                 ret &= cam_app_preview_start(ad);
6306                         } else {
6307                                 ret &= cam_mm_set_video_size(width, height);
6308                         }
6309                 } else {
6310                         if (camapp->shooting_mode == CAM_SELF_MODE) {
6311                                 if (need_change_state) {
6312                                         ret &= cam_mm_preview_stop(CAM_CAMERA_MODE);
6313                                         ret &= cam_mm_set_image_size(width, height);
6314                                         ret &= cam_mm_set_video_size(width, height);
6315                                         ret &= cam_app_preview_start(ad);
6316                                 } else {
6317                                         ret &= cam_mm_set_image_size(width, height);
6318                                         ret &= cam_mm_set_video_size(width, height);
6319                                 }
6320                         } else {
6321                                 int p_width = 0;        /* preview width */
6322                                 int p_height = 0;       /* preview height */
6323
6324                                 ret &= cam_mm_get_video_size(&p_width, &p_height);
6325                                 DEBUG_TRACE("get video size [%d]x[%d]", p_width,
6326                                             p_height);
6327                                         if (p_height == camapp->default_preview_height && (p_width == camapp->default_preview_width || p_width == PREVIEW_WIDE_W)) {
6328                                                 /* assume that last mode is normal capture mode */
6329                                                 int cur_width = 0;
6330                                                 int cur_height = 0;
6331                                                 int temp_width = camapp->default_preview_width;
6332                                                 int temp_height = camapp->default_preview_height;
6333                                                 gboolean cur_is_wide = FALSE;
6334                                                 gboolean next_is_wide = FALSE;
6335
6336                                                 ret &= cam_mm_get_image_size(&cur_width, &cur_height);
6337                                                 cur_is_wide = cam_utils_check_wide_resolution(cur_width, cur_height);
6338                                                 cam_debug(LOG_MM,
6339                                                           "current image Resolution[w] : [%d]x[%d][%d]",
6340                                                           cur_width, cur_height,
6341                                                           cur_is_wide);
6342
6343                                                 next_is_wide = cam_utils_check_wide_resolution(width, height);
6344                                                 cam_debug(LOG_MM,
6345                                                           "next image Resolution[w] : [%d]x[%d][%d]",
6346                                                           width, height, next_is_wide);
6347
6348                                                 if (next_is_wide)
6349                                                         temp_width = PREVIEW_WIDE_W;
6350
6351                                                 ret &= cam_mm_set_image_size(width, height);
6352
6353                                                 if ((cur_is_wide != next_is_wide)
6354                                                     || (temp_width != p_width)) {
6355                                                         if (need_change_state) {
6356
6357                                                                 ret &= cam_mm_preview_stop(camapp->camera_mode);
6358                                                                 ret &= cam_mm_set_video_size(temp_width, temp_height);
6359                                                                 ret &= cam_app_preview_start(ad);
6360                                                         } else {
6361                                                                 ret &= cam_mm_set_video_size(temp_width, temp_height);
6362                                                         }
6363                                                 }
6364                                         } else {
6365                                                 /* assume that last mode is zero system lag capture mode */
6366                                                 int temp_width = camapp->default_preview_width;
6367                                                 int temp_height = camapp->default_preview_height;
6368 #ifdef CAMERA_MACHINE_I686
6369                                                 temp_width = 320;
6370                                                 temp_height = 240;
6371 #endif
6372                                                 if (cam_utils_check_wide_resolution(width, height))
6373                                                         temp_width = PREVIEW_WIDE_W;
6374
6375                                                 ret &= cam_mm_set_image_size(width, height);
6376
6377                                                 if (need_change_state) {
6378                                                         ret &= cam_mm_preview_stop(camapp->camera_mode);
6379                                                         ret &= cam_mm_set_video_size(temp_width, temp_height);
6380                                                         ret &= cam_app_preview_start(ad);
6381                                                 } else {
6382                                                         ret &=
6383                                                             cam_mm_set_video_size(temp_width, temp_height);
6384                                                 }
6385                                         }
6386                         }
6387                 }
6388         } else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
6389                 if (need_change_state) {
6390                         ret &= cam_mm_preview_stop(CAM_CAMCORDER_MODE);
6391                         ret &= cam_mm_set_video_size(width, height);
6392                         ret &= cam_app_preview_start(ad);
6393                 } else {
6394                                 ret &= cam_mm_set_video_size(width, height);
6395                 }
6396         } else {
6397                 return FALSE;
6398         }
6399         return ret;
6400 }
6401
6402 int cam_app_get_aenc_bitrate(void *data)
6403 {
6404         struct appdata *ad = (struct appdata *)data;
6405         CamAppData *camapp = NULL;
6406         int bitrate = 0;
6407
6408         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
6409         camapp = ad->camapp_handle;
6410         cam_retvm_if(camapp == NULL, 0, "camapp is NULL");
6411
6412         if ((camapp->recording_mode == CAM_RECORD_MMS) ||(camapp->recording_mode == CAM_RECORD_SELF_MMS)) {
6413                 bitrate = CAM_AUDIO_BITRATE_MMS;
6414         } else {
6415                 bitrate = CAM_AUDIO_BITRATE_NORMAL;
6416         }
6417
6418         return bitrate;
6419 }
6420
6421 int cam_app_get_venc_bitrate(void *data, int quality)
6422 {
6423         struct appdata *ad = (struct appdata *)data;
6424         CamAppData *camapp = NULL;
6425         int return_val = 0;
6426
6427         cam_retvm_if(ad == NULL, 0, "appdata is NULL");
6428         camapp = ad->camapp_handle;
6429         cam_retvm_if(camapp == NULL, 0, "camapp is NULL");
6430
6431         if ((camapp->recording_mode == CAM_RECORD_MMS) ||(camapp->recording_mode == CAM_RECORD_SELF_MMS)) {
6432                 switch (quality) {
6433                 case CAM_QUALITY_HIGH:
6434                 case CAM_QUALITY_BEST:
6435                         return_val = 64000;
6436                         break;
6437
6438                 case CAM_QUALITY_MEDIUM:
6439                         return_val = 32000;
6440                         break;
6441
6442                 case CAM_QUALITY_LOW:
6443                         return_val = 16000;
6444                         break;
6445
6446                 default:
6447                         cam_critical(LOG_MM, "INVALID QUAILTY");
6448                         break;
6449                 }
6450         } else {
6451                 switch (camapp->resolution) {
6452                 case CAM_RESOLUTION_FULLHD:
6453                         {
6454                                 switch (quality) {
6455                                 case CAM_QUALITY_HIGH:
6456                                 case CAM_QUALITY_BEST:
6457                                         return_val = 8000000;
6458                                         break;
6459
6460                                 case CAM_QUALITY_MEDIUM:
6461                                         return_val = 4000000;
6462                                         break;
6463
6464                                 case CAM_QUALITY_LOW:
6465                                         return_val = 2000000;
6466                                         break;
6467
6468                                 default:
6469                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6470                                         break;
6471                                 }
6472                         }
6473                         break;
6474                 case CAM_RESOLUTION_HD:
6475                         {
6476                                 switch (quality) {
6477                                 case CAM_QUALITY_HIGH:
6478                                 case CAM_QUALITY_BEST:
6479                                         return_val = 10000000;
6480                                         break;
6481
6482                                 case CAM_QUALITY_MEDIUM:
6483                                         return_val = 4000000;
6484                                         break;
6485
6486                                 case CAM_QUALITY_LOW:
6487                                         return_val = 2000000;
6488                                         break;
6489
6490                                 default:
6491                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6492                                         break;
6493                                 }
6494                         }
6495                         break;
6496
6497                 case CAM_RESOLUTION_WVGA:
6498                 case CAM_RESOLUTION_WVGA2:
6499                         {
6500                                 switch (quality) {
6501                                 case CAM_QUALITY_HIGH:
6502                                 case CAM_QUALITY_BEST:
6503                                         return_val = 4000000;
6504                                         break;
6505
6506                                 case CAM_QUALITY_MEDIUM:
6507                                         return_val = 2000000;
6508                                         break;
6509
6510                                 case CAM_QUALITY_LOW:
6511                                         return_val = 1000000;
6512                                         break;
6513
6514                                 default:
6515                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6516                                         break;
6517                                 }
6518                         }
6519                         break;
6520
6521                 case CAM_RESOLUTION_VGA:
6522
6523                         {
6524                                 switch (quality) {
6525                                 case CAM_QUALITY_HIGH:
6526                                 case CAM_QUALITY_BEST:
6527                                         return_val = 3000000;
6528                                         break;
6529
6530                                 case CAM_QUALITY_MEDIUM:
6531                                         return_val = 1500000;
6532                                         break;
6533
6534                                 case CAM_QUALITY_LOW:
6535                                         return_val = 500000;
6536                                         break;
6537
6538                                 default:
6539                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6540                                         break;
6541                                 }
6542                         }
6543                         break;
6544
6545                 case CAM_RESOLUTION_WQVGA:
6546                         {
6547                                 switch (quality) {
6548                                 case CAM_QUALITY_HIGH:
6549                                 case CAM_QUALITY_BEST:
6550                                         return_val = 2000000;
6551                                         break;
6552
6553                                 case CAM_QUALITY_MEDIUM:
6554                                         return_val = 1000000;
6555                                         break;
6556
6557                                 case CAM_QUALITY_LOW:
6558                                         return_val = 500000;
6559                                         break;
6560
6561                                 default:
6562                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6563                                         break;
6564                                 }
6565                         }
6566                         break;
6567
6568                 case CAM_RESOLUTION_QVGA:
6569                         {
6570                                 switch (quality) {
6571                                 case CAM_QUALITY_HIGH:
6572                                 case CAM_QUALITY_BEST:
6573                                         return_val = 384000;
6574                                         break;
6575
6576                                 case CAM_QUALITY_MEDIUM:
6577                                         return_val = 192000;
6578                                         break;
6579
6580                                 case CAM_QUALITY_LOW:
6581                                         return_val = 64000;
6582                                         break;
6583
6584                                 default:
6585                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6586                                         break;
6587                                 }
6588                         }
6589                         break;
6590
6591                 case CAM_RESOLUTION_QCIF:
6592                         {
6593                                 switch (quality) {
6594                                 case CAM_QUALITY_HIGH:
6595                                 case CAM_QUALITY_BEST:
6596                                         return_val = 384000;
6597                                         break;
6598
6599                                 case CAM_QUALITY_MEDIUM:
6600                                         return_val = 192000;
6601                                         break;
6602
6603                                 case CAM_QUALITY_LOW:
6604                                         return_val = 64000;
6605                                         break;
6606
6607                                 default:
6608                                         cam_critical(LOG_MM, "INVALID QUAILTY");
6609                                         break;
6610                                 }
6611                         }
6612                         break;
6613
6614                 default:
6615                         cam_critical(LOG_MM, "INVALID QUAILTY");
6616                         break;
6617                 }
6618         }
6619
6620         cam_debug(LOG_MM, "videoenc bit rate = %d, current quilty = %d",
6621                   return_val, quality);
6622         return return_val;
6623 }
6624
6625 gboolean cam_app_set_video_quality(void *data, int quality)
6626 {
6627         struct appdata *ad = (struct appdata *)data;
6628         CamAppData *camapp = NULL;
6629         int v_bitrate = 0;
6630
6631         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6632         camapp = ad->camapp_handle;
6633         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6634
6635         v_bitrate = cam_app_get_venc_bitrate(ad, quality);
6636         if (v_bitrate > 0) {
6637                 cam_mm_set_video_encoder_bitrate(v_bitrate);
6638         } else {
6639                 return FALSE;
6640         }
6641
6642         return TRUE;
6643 }
6644 /*TODO:temporily define this*/
6645 #define AUDIO_FORMAT_PCM_S16_LE 2
6646 #define AUDIO_CODEC_VORBIS 36
6647 #define VIDEO_CODEC_THEORA 27
6648
6649 gboolean cam_app_set_recording_mode(void *data, int mode)
6650 {
6651         struct appdata *ad = (struct appdata *)data;
6652         CamAppData *camapp = NULL;
6653         int video_codec = 0, audio_codec = 0, sample_rate = 0;
6654         int format = AUDIO_FORMAT_PCM_S16_LE;
6655         int channel = 0;
6656         int a_bitrate = 0;
6657
6658         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6659         camapp = ad->camapp_handle;
6660         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6661         DEBUG_TRACE("mode = %d" , mode);
6662         if (mode == CAM_RECORD_MMS || mode == CAM_RECORD_SELF_MMS) {
6663                 DEBUG_TRACE("mode = %d" , mode);
6664                 video_codec = RECORDER_VIDEO_CODEC_H263;
6665                 audio_codec = RECORDER_AUDIO_CODEC_AMR;
6666                 sample_rate = 8000;
6667                 format = AUDIO_FORMAT_PCM_S16_LE;
6668                 channel = 1;
6669         } else {
6670                 DEBUG_TRACE("mode = %d" , mode);
6671                 video_codec = RECORDER_VIDEO_CODEC_MPEG4;
6672                 audio_codec = RECORDER_AUDIO_CODEC_AAC;
6673                 sample_rate = 44100;
6674                 format = AUDIO_FORMAT_PCM_S16_LE;
6675                 channel = 2;
6676         }
6677 #ifdef CAMERA_MACHINE_I686
6678         video_codec = VIDEO_CODEC_THEORA;
6679         audio_codec = AUDIO_CODEC_VORBIS;
6680 #endif
6681
6682         if (!cam_mm_set_codec(audio_codec, video_codec))
6683                 return FALSE;
6684
6685         if (!cam_mm_set_audio_source(sample_rate, format, channel))
6686                 return FALSE;
6687
6688         a_bitrate = cam_app_get_aenc_bitrate(ad);
6689         if (a_bitrate > 0) {
6690                 cam_mm_set_audio_encoder_bitrate(a_bitrate);
6691         } else {
6692                 return FALSE;
6693         }
6694
6695         if (!cam_app_set_video_quality(ad, camapp->video_quality))
6696                 return FALSE;
6697
6698         return TRUE;
6699 }
6700
6701 gboolean cam_app_set_size_limit(int max_val, int size_limit_type)
6702 {
6703         int ret = 0;
6704
6705         switch (size_limit_type) {
6706         case CAM_MM_SIZE_LIMIT_TYPE_BYTE:
6707                 ret = cam_mm_set_max_size(max_val);
6708                 if (!ret)
6709                         return FALSE;
6710                 break;
6711         case CAM_MM_SIZE_LIMIT_TYPE_SECOND:
6712                 ret = cam_mm_set_max_size(0);
6713                 if (!ret)
6714                         return FALSE;
6715                 break;
6716         default:
6717                 g_assert_not_reached();
6718         }
6719         return TRUE;
6720 }
6721
6722 gboolean cam_app_init_attribute(void *data, CamMode mode)
6723 {
6724         struct appdata *ad = (struct appdata *)data;
6725         CamAppData *camapp = NULL;
6726         gboolean ret = TRUE;
6727         int width = 0;
6728         int height = 0;
6729         int state = 0;
6730         int rotate = CAMERA_ROTATION_270;
6731         int camera_rotate = CAMERA_ROTATION_NONE;
6732         int video_dev = 0;
6733         int capture_video_format = -1;
6734         #ifdef TODO_SURRPORT
6735         int recording_video_format = -1;
6736         #endif
6737
6738         cam_retvm_if(ad == NULL, FALSE, "appdata is NULL");
6739         camapp = ad->camapp_handle;
6740         cam_retvm_if(camapp == NULL, FALSE, "camapp is NULL");
6741
6742         state = cam_mm_get_state();
6743
6744         if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
6745                 if (state != RECORDER_STATE_CREATED) {
6746                         return FALSE;
6747                 }
6748         } else if(camapp->camera_mode == CAM_CAMERA_MODE) {
6749                 if (state != CAMERA_STATE_CREATED) {
6750                         return FALSE;
6751                 }
6752         }
6753
6754         cam_mm_get_video_size( &camapp->default_preview_width, &camapp->default_preview_height);
6755         DEBUG_TRACE("default_width = %d,default_height = %d", camapp->default_preview_width, camapp->default_preview_height);
6756
6757         if (ad->launching_mode == CAM_LAUNCHING_MODE_NORMAL) {
6758                 /* get proper resolution */
6759                 cam_mm_get_image_size(&width, &height);
6760                 if (camapp->camera_mode == CAM_CAMERA_MODE) {
6761                         camapp->resolution = CAM_RESOLUTION(width, height);
6762                 }
6763         }
6764         width = CAM_RESOLUTION_W(camapp->resolution);
6765         height = CAM_RESOLUTION_H(camapp->resolution);
6766
6767 #ifdef CAMERA_MACHINE_I686
6768         width = 320;
6769         height = 240;
6770 #endif
6771
6772         if (CAM_CAMERA_MODE == mode) {
6773                 ret &= cam_mm_set_image_size(width, height);
6774                 ret &= cam_mm_set_image_count(camapp->image_count);
6775 #ifdef CAMERA_MACHINE_I686
6776                 ret &= cam_mm_set_fps(CAMERA_ATTR_FPS_15);
6777                 ret &= cam_mm_set_video_source_format(CAMERA_PIXEL_FORMAT_I420);
6778 #else
6779                 ret &= cam_mm_set_fps(CAMERA_ATTR_FPS_AUTO);
6780                 ret &=
6781                     cam_mm_get_video_source_format
6782                     (NULL,
6783                      &capture_video_format);
6784                 ret &= cam_mm_set_video_source_format(capture_video_format);
6785 #endif
6786                 ret &=
6787                     cam_app_set_capture_format_shooting_mode
6788                     (camapp->shooting_mode);
6789
6790         } else if (CAM_CAMCORDER_MODE == mode) {
6791                 ret &= cam_mm_set_video_profile();
6792 #ifdef CAMERA_MACHINE_I686
6793                 ret &= cam_mm_set_fps(CAMERA_ATTR_FPS_15);
6794                 ret &= cam_mm_set_video_source_format(CAMERA_PIXEL_FORMAT_I420);
6795 #else
6796                 ret &= cam_mm_set_fps(camapp->fps);
6797                 ret &= cam_mm_get_video_source_format(NULL, &recording_video_format);
6798                 ret &= cam_mm_set_video_source_format(recording_video_format);
6799 #endif
6800                 ret &= cam_mm_set_audio_recording(camapp->audio_recording);
6801                 ret &= cam_app_set_recording_mode(ad, camapp->recording_mode);
6802                 DEBUG_TRACE("camapp->size_limit = %d" , camapp->size_limit);
6803                 DEBUG_TRACE("camapp->size_limit_type = %d" , camapp->size_limit_type);
6804                 ret &= cam_app_set_size_limit(camapp->size_limit, camapp->size_limit_type);
6805         } else {
6806                 return FALSE;
6807         }
6808         cam_mm_get_video_device(&video_dev);
6809         DEBUG_TRACE("video_dev = %d",video_dev);
6810         if (video_dev == CAM_DEVICE_VGA) {
6811                 int value;
6812                 cam_mm_get_front_cam_display_rotate_value(&value, &rotate);
6813
6814                 DEBUG_TRACE("get front camera rotate %d value = %d", rotate, value);
6815                 /*rotate = value;*/
6816                 #ifdef TODO_SURRPORT
6817                 rotate = CAMERA_ROTATION_270;
6818                 #endif /*TODO:if new capi will released, this could be removed,but take care.*/
6819
6820         }
6821         cam_mm_get_zoom_valid_intrange(&camapp->zoom_min,&camapp->zoom_max);
6822         DEBUG_TRACE("Zoom range [%d - %d]",camapp->zoom_min, camapp->zoom_max);
6823
6824         ret &= cam_mm_set_display_device(CAMERA_DISPLAY_TYPE_X11, GET_DISPLAY(ad->main_xid));
6825         ret &= cam_mm_set_camera_rotate(camera_rotate);
6826         ret &= cam_mm_set_display_rotate(rotate);
6827         ret &= cam_mm_set_display_geometry_method(CAMERA_DISPLAY_MODE_LETTER_BOX);
6828 #ifndef USE_CAMERA_APP_SHUTTER_SOUND
6829         ret &= cam_mm_set_shutter_sound(TRUE);
6830 #endif
6831         ret &= cam_app_reset_resolution(ad, width, height);
6832         ret &= cam_mm_set_zoom(camapp->zoom_min);
6833         ret &= cam_mm_set_effect(camapp->effect);
6834         ret &= cam_mm_set_flash(camapp->flash);
6835         if (camapp->af_mode == CAM_FOCUS_AUTO
6836             || camapp->af_mode == CAM_FOCUS_MACRO) {
6837                 ret &= cam_mm_set_focus_mode(camapp->af_mode);
6838         }
6839
6840         ret &= cam_mm_set_tag_enable(TRUE);
6841
6842         ad->enable_mode_change = TRUE;
6843         ad->is_recording = FALSE;
6844         return ret;
6845
6846 }
6847
6848 static gboolean cam_app_return_ext_app(void *data, const char *r_file_path)
6849 {
6850         struct appdata *ad = (struct appdata *)data;
6851         service_h reply;
6852         service_create(&reply);
6853
6854         if (ad->aul_service_mime != NULL){
6855                 if(r_file_path == NULL){
6856                         service_add_extra_data(reply, SERVICE_DATA_SELECTED, "exit");
6857                         service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_FAILED);
6858                 }else{
6859                         service_add_extra_data(reply, SERVICE_DATA_SELECTED, r_file_path);
6860                         service_reply_to_launch_request(reply, ad->service_handle, SERVICE_RESULT_SUCCEEDED);
6861                 }
6862         }
6863
6864         service_destroy(reply);
6865         return TRUE;
6866
6867 }
6868 static void cam_app_battery_status_cb(keynode_t *key, void *data)
6869 {
6870         struct appdata *ad = (struct appdata *)data;
6871
6872         debug_fenter(LOG_UI);
6873         cam_retm_if(ad == NULL, "appdata is NULL");
6874
6875         int low_status = -1;
6876
6877         if (!vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &low_status)) {
6878                 cam_debug(LOG_UI, "battery status low = %d", low_status);
6879                 if (low_status <= VCONFKEY_SYSMAN_BAT_WARNING_LOW) {
6880                         ad->battery_status = LOW_BATTERY_CRITICAL_STATUS;
6881                         cam_app_notice_popup(ad,
6882                                 dgettext("sys_string", "IDS_COM_BODY_LOW_BATTERY"),
6883                          cam_app_timeout_notice_response_cb);
6884                 } else {
6885                         ad->battery_status = NORMAL_BATTERY_STATUS;
6886                 }
6887         }
6888
6889         return;
6890 }
6891 /*if torch light vconf key value is changed, this cb is called*/
6892 static void cam_torchlight_update_cb(keynode_t *key, void *data)
6893 {
6894         struct appdata *ad = (struct appdata *)data;
6895         cam_retm_if(ad == NULL, "appdata is NULL");
6896         int key_value = vconf_keynode_get_bool(key); /* -1: error, 1:True, 0:False */
6897         if (key_value == -1) {
6898                 DEBUG_TRACE("vconf_keynode_get_bool failed");
6899                 return;
6900         }
6901         DEBUG_TRACE("VCONFKEY_SETAPPL_ACCESSIBILITY_TORCH_LIGHT is changed to %d", key_value);
6902         if (key_value) {
6903                 /* disable flash icon */
6904                 ad->torchlight_on = TRUE;
6905
6906         } else {
6907                 /* enable flash icon */
6908                 ad->torchlight_on = FALSE;
6909         }
6910         cam_toolbar_update(ad); /*update flash icon*/
6911         return;
6912 }
6913
6914 static void cam_app_battery_update_cb(keynode_t *key, void *data)
6915 {
6916         struct appdata *ad = (struct appdata *)data;
6917         CamAppData *camapp = NULL;
6918         char *keyname = NULL;
6919
6920         debug_fenter(LOG_UI);
6921
6922         cam_retm_if(ad == NULL, "appdata is NULL");
6923         camapp = ad->camapp_handle;
6924         cam_retm_if(camapp == NULL, "camapp_handle is NULL");
6925
6926         keyname = vconf_keynode_get_name(key);
6927
6928         if (!strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW)) {
6929                 GValue value = { 0 };
6930                 gint charging = vconf_keynode_get_int(key);
6931                 DEBUG_TRACE("charging = %d", charging);
6932                 CAM_GVALUE_SET_INT(value, charging);
6933                 cam_handle_value_set(ad, PROP_BATTERY_CHARG, &value);
6934
6935         } else if (!strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CAPACITY)) {
6936                 GValue value = { 0 };
6937                 int battery_level = vconf_keynode_get_int(key);
6938                 CAM_GVALUE_SET_INT(value, battery_level);
6939                 cam_handle_value_set(ad, PROP_BATTERY_LEVEL, &value);
6940         }
6941         return;
6942 }
6943
6944 Evas_Object *cam_app_create_win(const char *name)
6945 {
6946         Evas_Object *eo = NULL;
6947         int w, h;
6948 #ifdef CAMERA_MACHINE_I686
6949         ecore_evas_app_comp_sync_set(EINA_FALSE);
6950         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
6951         ecore_evas_app_comp_sync_set(1);
6952 #else
6953         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
6954 #endif
6955         if (eo) {
6956                 elm_win_title_set(eo, name);
6957                 elm_win_borderless_set(eo, EINA_TRUE);
6958                 ecore_x_window_size_get(ecore_x_window_root_first_get(),
6959                                         &w, &h);
6960                 evas_object_resize(eo, w, h);
6961         }
6962
6963         return eo;
6964 }
6965
6966 #if 0
6967 Evas_Object *cam_screen_load_edj(Evas_Object *parent, const char *file,
6968                                  const char *group)
6969 {
6970         Evas_Object *eo;
6971         int r;
6972
6973         eo = elm_layout_add(parent);
6974         if (eo) {
6975                 r = elm_layout_file_set(eo, file, group);
6976                 if (!r) {
6977                         evas_object_del(eo);
6978                         return NULL;
6979                 }
6980
6981                 evas_object_size_hint_weight_set(eo,
6982                                                  EVAS_HINT_EXPAND,
6983                                                  EVAS_HINT_EXPAND);
6984
6985                 /*      //if(!strcmp((const char *)elm_widget_type_get(parent), "win")) { */
6986                 elm_win_resize_object_add(parent, eo);
6987                 /*      //} */
6988         }
6989
6990         return eo;
6991 }
6992 #endif
6993 Evas_Object *cam_app_load_edj(Evas_Object *parent, const char *file,
6994                               const char *group)
6995 {
6996         Evas_Object *eo = NULL;
6997         int r = 0;
6998
6999         eo = elm_layout_add(parent);
7000         if (eo) {
7001                 r = elm_layout_file_set(eo, file, group);
7002                 if (!r) {
7003                         evas_object_del(eo);
7004                         return NULL;
7005                 }
7006
7007                 evas_object_size_hint_weight_set(eo,
7008                                                  EVAS_HINT_EXPAND,
7009                                                  EVAS_HINT_EXPAND);
7010
7011                 elm_win_resize_object_add(parent, eo);
7012                 evas_object_show(eo);
7013         }
7014
7015         return eo;
7016 }
7017
7018 void cam_app_update_ts(Evas_Object *parent, struct text_part *tp)
7019 {
7020         int i;
7021         int size = sizeof(tp) / sizeof(tp[0]);
7022         Evas_Object *eo = elm_layout_edje_get(parent);
7023
7024         if (eo == NULL || tp == NULL || size < 0)
7025                 return;
7026
7027         for (i = 0; i < size; i++) {
7028                 if (tp[i].part && tp[i].msgid)
7029                         edje_object_part_text_set(eo,
7030                                                   tp[i].part, _(tp[i].msgid));
7031         }
7032 }
7033
7034 Eina_Bool __cam_app_update_thumbnail_idler(void *data)
7035 {
7036         struct appdata *ad = (struct appdata *)data;
7037         if (!ad) {
7038                 return ECORE_CALLBACK_CANCEL;
7039         }
7040         CamAppData *camapp = ad->camapp_handle;
7041
7042         if (!camapp) {
7043                 REMOVE_IDLER(ad->update_thumbnail_idler);
7044                 return ECORE_CALLBACK_CANCEL;
7045         }
7046
7047         DEBUG_TRACE(" ");
7048
7049         if (!g_file_test(camapp->filename,G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
7050                 DEBUG_TRACE( "The captured File is not existed");
7051                 REMOVE_IDLER(ad->update_thumbnail_idler);
7052                 return ECORE_CALLBACK_CANCEL;;
7053         }
7054
7055         gboolean ret = FALSE;
7056
7057         if (ad->imageviewer_ug) { /*review on */
7058                 DEBUG_TRACE("Image viewer was LAUNCHED. skip this...");
7059                 REMOVE_IDLER(ad->update_thumbnail_idler);
7060                 return ECORE_CALLBACK_CANCEL;;
7061         }
7062
7063         if (camapp->thumbnail_name != NULL) {
7064                 free (camapp->thumbnail_name);
7065                 camapp->thumbnail_name = NULL;
7066
7067         }
7068
7069         ret = cam_file_get_cam_file_thumbnail_path(camapp->filename, &camapp->thumbnail_name);
7070         DEBUG_TRACE("ret[0:success] = [%d] camapp->filename: [%s]",
7071                   ret, camapp->filename);
7072         DEBUG_TRACE("ret[0:success] = [%d] camapp->thumbnail_name: [%s]",
7073                   ret, camapp->thumbnail_name);
7074         if (!g_file_test(camapp->thumbnail_name, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
7075
7076                 if (g_thumbnail_image_check_count > 10) {
7077                         REMOVE_IDLER(ad->update_thumbnail_idler);
7078                         return ECORE_CALLBACK_CANCEL;
7079                 }
7080
7081                 DEBUG_TRACE("The thumbnail File is not existed,try the %d nums", g_thumbnail_image_check_count);
7082                 g_thumbnail_image_check_count++;
7083                 usleep(THUMBNAIL_UPDATE_WAIT_TIME);
7084                 /*REMOVE_IDLER(ad->update_thumbnail_idler);*//*note:renew, do not delete idler*/
7085                 return ECORE_CALLBACK_RENEW;
7086         }
7087 #ifndef ENABLE_CAPTURE_ANIMATION
7088         else {
7089                 DEBUG_TRACE("thumbnail image check count=[%d]", g_thumbnail_image_check_count);
7090                 toolbar_update_quickview_thumbnail(ad);
7091         }
7092 #else
7093         else if (camapp->camera_mode == CAM_CAMCORDER_MODE) {
7094                 toolbar_update_quickview_thumbnail(ad);
7095
7096         } else {
7097                 DEBUG_TRACE("NOT REACHED CODES REACHED!");
7098         }
7099 #endif
7100         REMOVE_IDLER(ad->update_thumbnail_idler);
7101         return ECORE_CALLBACK_CANCEL;
7102 }
7103 /* update thumbnail to quickview after first launching or return from image viewer */
7104 void cam_app_update_quickview_icon(void *data)
7105 {
7106 #ifdef CAMERA_MACHINE_I686
7107                 return;
7108 #else
7109         struct appdata *ad = (struct appdata *)data;
7110         cam_ret_if(ad == NULL);
7111         cam_ret_if(ad->camapp_handle == NULL);
7112         gchar *filename = NULL;
7113
7114         DEBUG_TRACE("");
7115         /*To update quickview image, get last filename*/
7116         filename = cam_app_get_last_filename();
7117         if (ad->camapp_handle->filename) {
7118                 free(ad->camapp_handle->filename);
7119                 ad->camapp_handle->filename = NULL;
7120         }
7121         if (filename != NULL) {
7122                 if (ad->camapp_handle->filename) {
7123                         free(ad->camapp_handle->filename);
7124                         ad->camapp_handle->filename = NULL;
7125                 }
7126                 ad->camapp_handle->filename = strdup(filename);
7127                 free(filename);
7128                 filename = NULL;
7129                 if (ad->camapp_handle->thumbnail_name) {
7130                         free(ad->camapp_handle->thumbnail_name);
7131                         ad->camapp_handle->thumbnail_name = NULL;
7132                 }
7133                 /*update quickview area */
7134                 if      (cam_file_get_cam_file_thumbnail_path(ad->camapp_handle->filename,
7135                                                                 &ad->camapp_handle->thumbnail_name))
7136                         toolbar_update_quickview_thumbnail_no_animation(ad);
7137         }
7138
7139         return;
7140 #endif
7141 }
7142
7143 void cam_app_update_thumbnail()
7144 {
7145 #ifdef CAMERA_MACHINE_I686
7146         return;
7147 #else
7148         struct appdata *ad = (struct appdata *)cam_appdata_get();
7149         cam_ret_if(ad == NULL);
7150         CamAppData *camapp = ad->camapp_handle;
7151         cam_ret_if(camapp == NULL);
7152
7153         DEBUG_TRACE("cam_app_update_thumbnail");
7154
7155         if (CAM_LAUNCHING_MODE_NORMAL == ad->launching_mode && camapp->filename) {
7156                 DEBUG_TRACE();
7157                 g_thumbnail_image_check_count = 0;
7158                 if (!ad->update_thumbnail_idler)
7159                         ad->update_thumbnail_idler = ecore_idler_add(__cam_app_update_thumbnail_idler, ad);
7160         }
7161         return;
7162 #endif
7163 }
7164
7165 gboolean cam_app_parse_args(CamExeArgs *args, service_h service)
7166 {
7167         struct appdata *ad = (struct appdata *)cam_appdata_get();
7168         cam_retv_if(ad == NULL, FALSE);
7169
7170         ad->aul_service_mime = NULL;
7171
7172         int ret = service_get_mime(service, &ad->aul_service_mime);
7173         if (ret != SERVICE_ERROR_NONE)
7174         {
7175                 cam_debug(LOG_UI, "service_get_mime is error ");
7176                 return FALSE;
7177         }
7178
7179         if(ad->aul_service_mime != NULL){
7180                 /* get mode */
7181                 if(strcmp(ad->aul_service_mime, AUL_SERVICE_MIME_TYPE_IMAGE) == 0){
7182                         cam_debug(LOG_UI, "CAM_CAMERA_MODE");
7183                         args->cam_mode = CAM_CAMERA_MODE;
7184                 }else if(strcmp(ad->aul_service_mime, AUL_SERVICE_MIME_TYPE_VIDEO) == 0){
7185                         cam_debug(LOG_UI, "CAM_CAMCORDER_MODE");
7186                         args->cam_mode = CAM_CAMCORDER_MODE;
7187                 }
7188         }
7189
7190         const char *val = NULL;
7191         /* get caller appl. */
7192         service_get_extra_data(service, "CALLER", (char **)&val);
7193         if (val) {
7194                 cam_debug(LOG_UI, "CALLER %s", val);
7195                 args->caller = strdup(val);
7196         } else {
7197                 args->caller = NULL;
7198         }
7199
7200         /* resolution */
7201         val = NULL;
7202         service_get_extra_data(service, "RESOLUTION", (char **)&val);
7203         if (val) {
7204                 cam_debug(LOG_UI, "RESOLUTION %s", val);
7205
7206                 int res = 0;
7207
7208                 if (args->cam_mode == CAM_CAMERA_MODE) {
7209                         if (0 == strcmp(val, CAM_CAPTURE_RES_BIG))
7210                                 res = CAM_RESOLUTION_3264x2448;
7211                         else if (0 == strcmp(val, CAM_CAPTURE_RES_BIG_WIDE))
7212                                 res = CAM_RESOLUTION_3264x1836;
7213                         else if (0 == strcmp(val, CAM_CAPTURE_RES_MIDDLE))
7214                                 res = CAM_RESOLUTION_2560x1920;
7215                         else if (0 == strcmp(val, CAM_CAPTURE_RES_MIDDLE_WIDE))
7216                                 res = CAM_RESOLUTION_2560x1536;
7217                         else if (0 == strcmp(val, CAM_CAPTURE_RES_SMALL))
7218                                 res = CAM_RESOLUTION_2560x1920;
7219                         else if (0 == strcmp(val, CAM_CAPTURE_RES_SMALL_WIDE))
7220                                 res = CAM_RESOLUTION_1280x720;
7221                         else if (0 == strcmp(val, CAM_CAPTURE_RES_VGA))
7222                                 res = CAM_RESOLUTION_VGA;
7223                         else
7224                                 res = CAM_RESOLUTION_3264x2448;
7225                 } else {
7226                         if (0 == strcmp(val, CAM_RECORDING_RES_HD))
7227                                 res = CAM_RESOLUTION_HD;
7228                         else if (0 == strcmp(val, CAM_RECORDING_RES_VGA))
7229                                 res = CAM_RESOLUTION_VGA;
7230                         else if (0 == strcmp(val, CAM_RECORDING_RES_QCIF))
7231                                 res = CAM_RESOLUTION_QCIF;
7232                         else
7233                                 res = CAM_RESOLUTION_VGA;
7234                 }
7235
7236                 args->width = CAM_RESOLUTION_W(res);
7237                 args->height = CAM_RESOLUTION_H(res);
7238                 args->resolution = res;
7239         }
7240
7241         /* size limit */
7242         val = NULL;
7243         service_get_extra_data(service, "LIMIT", (char **)&val);
7244         if (val) {
7245                 cam_debug(LOG_UI, "LIMIT %s", val);
7246                 args->size_limit = atoi(val);
7247         } else {
7248                 args->size_limit = 0;
7249         }
7250
7251         /* review */
7252         val = NULL;
7253         service_get_extra_data(service, "REVIEW", (char **)&val);
7254         if (val) {
7255                 if (0 == strcmp(val, "TRUE"))
7256                         args->review = TRUE;
7257                 else
7258                         args->review = FALSE;
7259         } else {
7260                 args->review = FALSE;
7261         }
7262
7263         /*  print exe args */
7264         cam_debug(LOG_SYS, "############### exe args ###############");
7265         cam_debug(LOG_SYS, "mode =%d", args->cam_mode);
7266         cam_debug(LOG_SYS, "caller =%s", args->caller);
7267         cam_debug(LOG_SYS, "width =%d", args->width);
7268         cam_debug(LOG_SYS, "height =%d", args->height);
7269         cam_debug(LOG_SYS, "limit =%d", args->size_limit);
7270         cam_debug(LOG_SYS, "review =%d", args->review);
7271         cam_debug(LOG_SYS, "############### end ###############");
7272
7273         return TRUE;
7274 }
7275
7276
7277 void cam_app_draw_af_box(void *data)
7278 {
7279
7280         cam_retm_if(data == NULL, "data is null");
7281         struct appdata *ad = (struct appdata *)data;
7282         ad->af_start_x = 0;
7283         ad->af_start_y = 0;
7284
7285         switch (ad->rot_current) {
7286         case APP_DEVICE_ORIENTATION_0:
7287                 {
7288                         ad->af_start_x = ad->touch_lcd_x;
7289                         ad->af_start_y = ad->touch_lcd_y;
7290                 }
7291                 break;
7292         case APP_DEVICE_ORIENTATION_180:
7293                 {
7294                         ad->af_start_x = ad->win_height - ad->touch_lcd_x;
7295                         ad->af_start_y = ad->win_width - ad->touch_lcd_y;
7296                 }
7297                 break;
7298         case APP_DEVICE_ORIENTATION_270:
7299                 {
7300                         ad->af_start_x = ad->touch_lcd_y;
7301                         ad->af_start_y = ad->win_height - ad->touch_lcd_x;
7302                 }
7303                 break;
7304         case APP_DEVICE_ORIENTATION_90:
7305                 {
7306                         ad->af_start_x = ad->win_width - ad->touch_lcd_y;
7307                         ad->af_start_y = ad->touch_lcd_x;
7308                 }
7309                 break;
7310         default:
7311                 break;
7312         }
7313
7314         /* adjust */
7315         DEBUG_TRACE("ad->af_start_x=%f, ad->af_start_y=%f", ad->af_start_x,
7316                     ad->af_start_y);
7317         ad->camera_focus_w = CAMERA_FOCUS_W * elm_config_scale_get();
7318         ad->camera_focus_h = CAMERA_FOCUS_H * elm_config_scale_get();
7319         DEBUG_TRACE("ad->camera_focus_w=%f, ad->camera_focus_h=%f",
7320                     ad->camera_focus_w, ad->camera_focus_h);
7321
7322         ad->af_start_x = ad->af_start_x - (ad->camera_focus_w / 2);
7323         ad->af_start_y = ad->af_start_y - (ad->camera_focus_h / 2);
7324         DEBUG_TRACE("af area box start x,y =[%f,%f]\n", ad->af_start_x,
7325                     ad->af_start_y);
7326
7327         if (ad->rot_current == APP_DEVICE_ORIENTATION_270
7328             || ad->rot_current == APP_DEVICE_ORIENTATION_90) {
7329                 if (ad->af_start_x < ad->preview_offset_x) {
7330                         ad->af_start_x = ad->preview_offset_x;
7331                 }
7332                 if (ad->af_start_y < ad->preview_offset_y) {
7333                         ad->af_start_y = ad->preview_offset_y;
7334                 }
7335                 if ((ad->af_start_x + ad->camera_focus_w) >
7336                     (ad->preview_w + ad->preview_offset_x)) {
7337                         ad->af_start_x =
7338                             (ad->preview_w + ad->preview_offset_x) -
7339                             ad->camera_focus_w;
7340                 }
7341                 if ((ad->af_start_y + ad->camera_focus_h) >
7342                     (ad->preview_h + ad->preview_offset_y)) {
7343                         ad->af_start_y =
7344                             (ad->preview_h + ad->preview_offset_y) -
7345                             ad->camera_focus_h;
7346                 }
7347
7348         } else {
7349                 if (ad->af_start_y < ad->preview_offset_x) {
7350                         ad->af_start_y = ad->preview_offset_x;
7351                 }
7352                 if (ad->af_start_x < ad->preview_offset_y) {
7353                         ad->af_start_x = ad->preview_offset_y;
7354                 }
7355                 if ((ad->af_start_y + ad->camera_focus_h) >
7356                     (ad->preview_w + ad->preview_offset_x)) {
7357                         ad->af_start_y =
7358                             (ad->preview_w + ad->preview_offset_x) -
7359                             ad->camera_focus_h;
7360                 }
7361                 if ((ad->af_start_x + ad->camera_focus_w) >
7362                     (ad->preview_h + ad->preview_offset_y)) {
7363                         ad->af_start_x =
7364                             (ad->preview_h + ad->preview_offset_y) -
7365                             ad->camera_focus_w;
7366                 }
7367         }
7368         if (ad->focus_edje) {
7369                 DEBUG_TRACE
7370                     ("####################################################");
7371                 DEBUG_TRACE("af area start ,ad->af_start_x,y =[%f,%f]\n",
7372                             ad->af_start_x, ad->af_start_y);
7373                 DEBUG_TRACE
7374                     ("####################################################");
7375                 evas_object_move(ad->focus_edje, ad->af_start_x,
7376                                  ad->af_start_y);
7377                 DEBUG_TRACE(" MOVE FOCUS_EDJE : %f,%f", ad->af_start_x,
7378                             ad->af_start_y);
7379         }
7380
7381 }
7382
7383
7384 /*  get preview start x,y coordinate */
7385 void cam_app_get_preview_offset_coordinate(void *data)
7386 {
7387
7388         cam_retm_if(data == NULL, "data is null");
7389         struct appdata *ad = (struct appdata *)data;
7390
7391         CamAppData *camapp = ad->camapp_handle;
7392         cam_retm_if(camapp == NULL, "camapp is null");
7393
7394         int width = 0;
7395         int height = 0;
7396         CamVideoRectangle result;       /* result ractangle */
7397         CamVideoRectangle window;       /* target window ractangle */
7398         CamVideoRectangle preview;      /* target preview rectangle */
7399         /*wow,now, the MMHandleType is not created*/
7400         cam_mm_get_video_size(&width, &height);
7401
7402         ad->camfw_video_width = width;
7403         ad->camfw_video_height = height;
7404         preview.w = width;
7405         preview.h = height;
7406         DEBUG_TRACE("************************************************");
7407         DEBUG_TRACE("preview.w =%d, preview.h=%d", preview.w, preview.h);
7408
7409         window.h = ad->win_height;
7410         window.w = ad->win_width;
7411         DEBUG_TRACE("window.w =%d, window.h=%d\n", window.w, window.h);
7412         DEBUG_TRACE("************************************************");
7413         cam_app_preview_start_coordinate(preview, window, &result);
7414
7415         ad->preview_offset_x = result.x;
7416         ad->preview_offset_y = result.y;
7417         ad->preview_w = result.w;
7418         ad->preview_h = result.h;
7419
7420         DEBUG_TRACE("************************************************");
7421         DEBUG_TRACE("ad->preview_offset_x = %d, ad->preview_offset_y = %d",
7422                     ad->preview_offset_x, ad->preview_offset_y);
7423         DEBUG_TRACE("*************************************************");
7424
7425         camapp->focus_state = CAM_FOCUS_STATUS_RELEASED;
7426         cam_app_focus_guide_update(ad);
7427
7428         /* init */
7429         ad->af_x = (ad->win_width / 2) - ad->preview_offset_x;
7430         ad->af_y = (ad->win_height / 2) - ad->preview_offset_y;
7431
7432         ad->af_x = (ad->af_x * ad->camfw_video_width) / ad->preview_w;
7433         ad->af_y = (ad->af_y * ad->camfw_video_height) / ad->preview_h;
7434         /* init */
7435         ad->touch_lcd_x = (ad->win_height / 2);
7436         ad->touch_lcd_y = (ad->win_width / 2);
7437
7438         DEBUG_TRACE("*************************************************");
7439         DEBUG_TRACE(" ad->af_x=%d, ad->af_y=%d", ad->af_x, ad->af_y);
7440         DEBUG_TRACE(" ad->af_start_x=%d, ad->af_start_y=%d", ad->af_start_x, ad->af_start_y);
7441         DEBUG_TRACE(" ad->touch_lcd_x=%d, ad->touch_lcd_y=%d", ad->touch_lcd_x,
7442                     ad->touch_lcd_y);
7443         DEBUG_TRACE("*************************************************");
7444
7445         cam_app_draw_af_box(ad);
7446         camapp->focus_mode = CAM_FOCUS_MODE_CONTINUOUS;
7447
7448         if (ad->focus_edje)
7449                 evas_object_show(ad->focus_edje);
7450 }
7451
7452 void cam_app_preview_start_coordinate(CamVideoRectangle src,
7453                                       CamVideoRectangle dst,
7454                                       CamVideoRectangle *result)
7455 {
7456         /* src is target preview rectangle */
7457         /* dst is target window rectangle */
7458         g_return_if_fail(result != NULL);
7459         gdouble src_ratio, dst_ratio;
7460         src_ratio = (gdouble) src.w / src.h;
7461         dst_ratio = (gdouble) dst.w / dst.h;
7462         if (src_ratio > dst_ratio) {
7463                 DEBUG_TRACE("#### case 1\n");
7464                 result->w = dst.w;
7465                 result->h = dst.w / src_ratio;
7466                 result->x = 0;
7467                 result->y = (dst.h - result->h) / 2;
7468         } else if (src_ratio < dst_ratio) {
7469                 DEBUG_TRACE("#### case 2\n");
7470                 result->w = dst.h * src_ratio;
7471                 result->h = dst.h;
7472                 result->x = (dst.w - result->w) / 2;
7473                 result->y = 0;
7474         } else {
7475                 DEBUG_TRACE("#### case 3\n");
7476                 result->x = 0;
7477                 result->y = 0;
7478                 result->w = dst.w;
7479                 result->h = dst.h;
7480         }
7481         DEBUG_TRACE
7482             ("************************************************************");
7483         DEBUG_TRACE
7484             ("source is %dx%d dest is %dx%d, result window size is %dx%d result offset x= %dx y=%d",
7485              src.w, src.h, dst.w, dst.h, result->w, result->h, result->x,
7486              result->y);
7487         DEBUG_TRACE
7488             ("************************************************************");
7489 }
7490
7491
7492 void cam_remove_tmp_file()
7493 {
7494         const gchar *default_path = NULL;
7495         char tmpfile_name[256] = { 0 };
7496
7497         default_path = cam_file_get_internal_video_path();
7498         DEBUG_TRACE(" video = %s", default_path);
7499         snprintf(tmpfile_name, sizeof(tmpfile_name), "%s%s", default_path,
7500                  TMPFILE_PREFIX);
7501         if (g_file_test(tmpfile_name, G_FILE_TEST_EXISTS)) {
7502                 DEBUG_TRACE("REMOVE tmp file");
7503                 unlink(tmpfile_name);
7504         }
7505         default_path = cam_file_get_external_video_path();
7506         DEBUG_TRACE(" video = %s", default_path);
7507         snprintf(tmpfile_name, sizeof(tmpfile_name), "%s%s", default_path,
7508                  TMPFILE_PREFIX);
7509
7510         if (g_file_test(tmpfile_name, G_FILE_TEST_EXISTS)) {
7511                 DEBUG_TRACE("REMOVE tmp file");
7512                 unlink(tmpfile_name);
7513         }
7514
7515 }
7516
7517 Eina_Bool cam_app_launch_after_preview_began(void *data)
7518 {
7519         struct appdata *ad = (struct appdata *)data;
7520         cam_retv_if(ad == NULL, FALSE);
7521
7522         cam_debug(LOG_UI, "cam_app_launch_after_preview_began");
7523
7524         int state = cam_mm_get_state();
7525
7526         if (state != RECORDER_STATE_RECORDING) {
7527                 cam_debug(LOG_UI, "remove previous file");
7528                 cam_remove_tmp_file();
7529         }
7530
7531         cam_app_get_preview_offset_coordinate(data);
7532         cam_toolbar_setting_popup_create(data);
7533         return ECORE_CALLBACK_CANCEL;
7534 }
7535
7536 void cam_utils_remove_idler_all(void *data)
7537 {
7538         struct appdata *ad = (struct appdata *)data;
7539         GList *list = NULL;
7540         Ecore_Idler *idler = NULL;
7541
7542         debug_fenter(LOG_UI);
7543
7544         cam_retm_if(ad == NULL, "appdata is NULL");
7545
7546         /*LOCK
7547            In fact, a Lock is needed here. However, because all related functions are working main loop, practically it may not be needed. */
7548
7549         if (!ad->capture_cb_list) {
7550                 cam_debug(LOG_UI, "No idler is remained.");
7551         } else {
7552                 list = ad->capture_cb_list;
7553
7554                 while (list) {
7555                         idler = list->data;
7556
7557                         if (!idler) {
7558                                 cam_warning(LOG_UI,
7559                                             "Fail to remove idler. The idler is NULL");
7560                         } else {
7561                                 cam_debug(LOG_UI, "Remove idler[%p].", idler);
7562                                 ecore_idler_del(idler);
7563
7564                                 ad->capture_cb_list =
7565                                     g_list_remove(ad->capture_cb_list, idler);
7566                         }
7567
7568                         list = g_list_next(list);
7569                 }
7570
7571                 g_list_free(ad->capture_cb_list);
7572                 ad->capture_cb_list = NULL;
7573         }
7574
7575         /* UNLOCK */
7576         debug_fleave(LOG_UI);
7577         return;
7578 }
7579
7580 Eina_Bool cam_elm_cache_flush()
7581 {
7582 /*Make the canvas discard as much data as possible used by the engine at runtime.*/
7583         DEBUG_TRACE("start");
7584         struct appdata *ad = (struct appdata *)cam_appdata_get();
7585         if (ad) {
7586                 if (ad->evas) {
7587                         evas_render_idle_flush(ad->evas);
7588                 }
7589         }
7590         elm_cache_all_flush();
7591         DEBUG_TRACE("end");
7592         return EINA_TRUE;
7593 }
7594
7595 gboolean cam_condition_check_to_start_camera(void *data)
7596 {
7597         struct appdata *ad = (struct appdata *)data;
7598         cam_retvm_if(ad == NULL, EINA_FALSE, "appdata is NULL");
7599
7600         /* check battery */
7601         if (cam_utils_check_battery_critical_low()) {
7602                 ad->battery_status = LOW_BATTERY_CRITICAL_STATUS;
7603                 cam_app_notice_popup(ad, dgettext("sys_string", "IDS_COM_BODY_LOW_BATTERY"), cam_app_timeout_notice_response_cb);
7604
7605                 return EINA_FALSE;
7606         } else if (cam_utils_check_battery_warning_low()) {
7607                 ad->battery_status = LOW_BATTERY_WARNING_STATUS;
7608         } else {
7609                 ad->battery_status = NORMAL_BATTERY_STATUS;
7610         }
7611
7612         return EINA_TRUE;
7613 }
7614 //end file