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