main/email.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 <stdio.h>
  18 #include <appcore-efl.h>
  19 #undef _
  20 #include <ui-gadget-module.h>
  21 #include <Ecore_X.h>
  22 #include <utilX.h>
  23 #include <vconf.h>
  24 #include <glib.h>
  25 #include <glib/gstdio.h>
  26 #include <aul.h>
  27 #include <E_DBus.h>
  28 #include <email-api.h>
  29
  30 #include "email.h"
  31 #include "email-debug.h"
  32 #include "email-utils.h"
  33 #include "email-common-types.h"
  34 #include "email-engine.h"
  35
  36 #define URI_SCHEME_MAILTO "mailto:"
  37 #define URI_SCHEME_FILE "file://"
  38 #define URI_SCHEME_HTTP "http://"
  39
  40 typedef struct appdata appdata;
  41 struct appdata {
  42         int root_w;
  43         int root_h;
  44         int root_x;
  45         int root_y;
  46
  47         Evas *evas;
  48         Evas_Object *win_main;
  49
  50         int account_id;
  51         char *account_name;
  52
  53         ui_gadget_h mailbox_ug;
  54         ui_gadget_h setting_ug;
  55         ui_gadget_h composer_ug;
  56         ui_gadget_h viewer_ug;
  57 };
  58
  59 gboolean _b_setting_opened = false;
  60 extern ui_gadget_h _g_mailbox_ug;
  61
  62 static bool app_create(void *data);
  63 static int app_terminate(void *data);
  64 static int app_pause(void *data);
  65 static int app_resume(void *data);
  66 static int app_reset(service_h b, void *data);
  67 static int app_low_memory(void *data);
  68 static int app_low_battery(void *data);
  69 static int app_lang_changed(void *data);
  70 static int app_region_changed(void *data);
  71
  72 static Evas_Object *create_win(const char *name);
  73 static void win_del(void *data, Evas_Object *obj, void *event);
  74 static void launch_email_ug(service_h b, struct appdata *ad);
  75 static int check_app_svc_operation(service_h b, struct appdata *ad, gint account_id);
  76 static int check_aul_mime_operation(service_h b, struct appdata *ad);
  77 static int check_aul_launch_operation(service_h b, struct appdata *ad);
  78 static void block_clicked_cb(void *data, Evas_Object *obj, void *event_info);
  79 static void popup_block_clicked_cb(void *data, Evas_Object *obj, void *event_info);
  80 static void popup_response_cb(void *data, Evas_Object *obj, void *event_info);
  81 static void layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv);
  82 static void result_cb(ui_gadget_h ug, service_h result, void *priv);
  83 static void destroy_cb(ui_gadget_h ug, void *priv);
  84 static void aul_destroy_cb(ui_gadget_h ug, void *priv);
  85 ui_gadget_h create_ug(char *ug_name, service_h bd, void *data);
  86 static int _email_main_rotation_cb(app_device_orientation_e m, void *data);
  87
  88
  89 static void layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
  90 {
  91         debug_log("");
  92         Evas_Object *base, *win;
  93
  94         if (!ug || !priv)
  95                 return;
  96
  97         base = ug_get_layout(ug);
  98         if (!base) {
  99                 debug_log("ug_get_layout returns NULL");
 100                 return;
 101         }
 102
 103         win = ug_get_window();
 104
 105         switch (mode) {
 106         case UG_MODE_FULLVIEW:
 107                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 108                 elm_win_resize_object_add(win, base);
 109                 ug_disable_effect(ug);
 110                 evas_object_show(base);
 111                 break;
 112         default:
 113                 break;
 114         }
 115 }
 116
 117 static void result_cb(ui_gadget_h ug, service_h result, void *priv)
 118 {
 119         debug_log("");
 120
 121         if (!ug || !priv)
 122                 return;
 123
 124         ug_destroy(ug);
 125 }
 126
 127 static void destroy_cb(ui_gadget_h ug, void *priv)
 128 {
 129         debug_log("");
 130
 131         if (!ug || !priv)
 132                 return;
 133
 134         struct appdata *ad = (struct appdata *)priv;
 135
 136         if (_b_setting_opened == true && ug == ad->setting_ug) {
 137                 _b_setting_opened = false;
 138
 139                 int ret;
 140                 ug_destroy(ad->setting_ug);
 141                 ad->setting_ug = NULL;
 142
 143                 /*relaunch setting when account deleted immediately*/
 144                 if (!email_engine_get_default_account(&ad->account_id)) {
 145                         service_h service = NULL;
 146
 147                         ret = service_create(&service);
 148                         debug_log("service_create: %d", ret);
 149                         if (!service) {
 150                                 debug_log("service create failed");
 151                                 return;
 152                         }
 153
 154                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_VIEW_TYPE, EMAIL_BUNDLE_VAL_VIEW_FIRST_SETUP);
 155                         debug_log("service_add_extra_data: %d", ret);
 156
 157                         if (NULL != (ad->setting_ug = create_ug(UG_NAME_EMAIL_SETTING, service, ad))) {
 158                                 _b_setting_opened = true;
 159                         }
 160
 161                         ret = service_destroy(service);
 162                         debug_log("service_destroy: %d", ret);
 163                         return;
 164                 }
 165
 166                 if (ad->mailbox_ug) {
 167                         debug_log("Mailbox is already running");
 168                         return;
 169                 }
 170
 171                 service_h service = NULL;
 172
 173                 ret = service_create(&service);
 174                 debug_log("service_create: %d", ret);
 175                 if (!service) {
 176                         debug_log("service create failed");
 177                         return;
 178                 }
 179
 180                 char initial[4] = { 0, };
 181                 snprintf(initial, sizeof(initial), "%d", 0);
 182
 183                 ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_INITIAL_RUN, initial);
 184                 debug_log("service_add_extra_data: %d", ret);
 185
 186                 ad->mailbox_ug = create_ug(UG_NAME_EMAIL_MAILBOX, service, ad);
 187                 _g_mailbox_ug = ad->mailbox_ug;
 188
 189                 ret = service_destroy(service);
 190                 debug_log("service_destroy: %d", ret);
 191
 192                 return;
 193         }
 194
 195         if (ug == ad->mailbox_ug) {
 196                 if (!email_engine_get_default_account(&ad->account_id)) {
 197                         ug_destroy(ad->mailbox_ug);
 198                         ad->mailbox_ug = NULL;
 199
 200                         if (ad->setting_ug) {
 201                                 debug_log("Setting is already running");
 202                                 return;
 203                         }
 204
 205                         int ret;
 206                         service_h service = NULL;
 207
 208                         ret = service_create(&service);
 209                         debug_log("service_create: %d", ret);
 210                         if (!service) {
 211                                 debug_log("service create failed");
 212                                 return;
 213                         }
 214
 215                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_VIEW_TYPE, EMAIL_BUNDLE_VAL_VIEW_FIRST_SETUP);
 216                         debug_log("service_add_extra_data: %d", ret);
 217
 218                         if (NULL != (ad->setting_ug = create_ug(UG_NAME_EMAIL_SETTING, service, ad))) {
 219                                 _b_setting_opened = true;
 220                         }
 221
 222                         ret = service_destroy(service);
 223                         debug_log("service_destroy: %d", ret);
 224
 225                         return;
 226                 }
 227         }
 228
 229         if (ug == ad->composer_ug) {
 230                 debug_log("destroy composer_ug");
 231                 ug_destroy(ad->composer_ug);
 232                 ad->composer_ug = NULL;
 233         }
 234
 235         if (ug == ad->viewer_ug) {
 236                 debug_log("destroy viewer_ug");
 237                 ug_destroy(ad->viewer_ug);
 238                 ad->viewer_ug = NULL;
 239         }
 240
 241         elm_exit();
 242         return;
 243 }
 244
 245 static void aul_destroy_cb(ui_gadget_h ug, void *priv)
 246 {
 247         debug_log("");
 248
 249         if (!ug || !priv)
 250                 return;
 251
 252         elm_exit();
 253 }
 254
 255 ui_gadget_h create_ug(char *ug_name, service_h bd, void *data)
 256 {
 257         debug_log("");
 258         ui_gadget_h ug;
 259         struct ug_cbs cbs = { 0, };
 260
 261         cbs.layout_cb = layout_cb;
 262         cbs.result_cb = result_cb;
 263         cbs.destroy_cb = destroy_cb;
 264         cbs.priv = data;
 265
 266         ug = ug_create(NULL, ug_name, UG_MODE_FULLVIEW, bd, &cbs);
 267
 268         return ug;
 269 }
 270
 271 static int _email_main_rotation_cb(app_device_orientation_e m, void *data)
 272 {
 273         debug_log("");
 274         struct appdata *ad = data;
 275
 276         if (ad == NULL || ad->win_main == NULL) {
 277                 return -1;
 278         }
 279         debug_log("%d", m);
 280
 281         switch (m) {
 282         case APP_DEVICE_ORIENTATION_0:
 283                 ug_send_event(UG_EVENT_ROTATE_PORTRAIT);
 284                 break;
 285
 286         case APP_DEVICE_ORIENTATION_180:
 287                 ug_send_event(UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN);
 288                 break;
 289
 290         case APP_DEVICE_ORIENTATION_270:
 291                 ug_send_event(UG_EVENT_ROTATE_LANDSCAPE);
 292                 break;
 293
 294         case APP_DEVICE_ORIENTATION_90:
 295                 ug_send_event(UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN);
 296                 break;
 297
 298         default:
 299                 break;
 300         }
 301
 302         return 0;
 303 }
 304
 305 static bool app_create(void *data)
 306 {
 307         debug_log("");
 308
 309         struct appdata *ad = data;
 310         Evas_Object *win;
 311
 312         elm_config_preferred_engine_set("opengl_x11");  //"software_x11"
 313
 314         /* create window */
 315         win = create_win(PACKAGE);
 316         if (win == NULL) {
 317                 debug_log("create_win returns NULL");
 318                 return false;
 319         }
 320         ad->win_main = win;
 321
 322         UG_INIT_EFL(ad->win_main, UG_OPT_INDICATOR_ENABLE);
 323
 324         /* icu */
 325         email_open_icu_pattern_generator();
 326
 327         return true;
 328 }
 329
 330 static int app_terminate(void *data)
 331 {
 332         debug_log("");
 333
 334         set_app_terminated();
 335
 336         email_engine_finalize_force();
 337
 338         int ret = e_dbus_shutdown();
 339         debug_log("ret: %d", ret);
 340
 341         return 0;
 342 }
 343
 344 static int app_pause(void *data)
 345 {
 346         debug_log("");
 347
 348         set_app_paused();
 349         ug_pause();
 350
 351         return 0;
 352 }
 353
 354 static int app_resume(void *data)
 355 {
 356         debug_log("");
 357
 358         reset_app_paused();
 359         ug_resume();
 360
 361         email_clear_all_notification_bar();
 362
 363         return 0;
 364 }
 365
 366 static int app_reset(service_h b, void *data)
 367 {
 368         debug_log("");
 369         struct appdata *ad = data;
 370
 371         if (ad->win_main)
 372                 elm_win_activate(ad->win_main);
 373
 374         /* init email common module */
 375         if (email_engine_initialize() == FALSE) {
 376                 debug_log("Failed to initialize email engine");
 377                 evas_object_show(ad->win_main);
 378
 379                 Evas_Object *popup = elm_popup_add(ad->win_main);
 380                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 381                 elm_popup_timeout_set(popup, 2.0);
 382                 elm_object_part_text_set(popup, "title,text", dgettext("sys_string", "IDS_COM_POP_INITIALIZING"));
 383
 384                 Evas_Object *progress = elm_progressbar_add(popup);
 385                 elm_object_style_set(progress, "list_process");
 386                 elm_progressbar_pulse_set(progress, EINA_TRUE);
 387                 elm_progressbar_pulse(progress, EINA_TRUE);
 388                 evas_object_show(progress);
 389
 390                 elm_object_content_set(popup, progress);
 391
 392                 /*Evas_Object *btn1 = elm_button_add(popup);
 393                 elm_object_style_set(btn1, "popup_button/default");
 394                 elm_object_text_set(btn1, dgettext("sys_string", "IDS_COM_SK_OK"));
 395                 elm_object_part_content_set(popup, "button1", btn1);
 396                 evas_object_smart_callback_add(btn1, "clicked", popup_block_clicked_cb, NULL);*/
 397
 398                 evas_object_smart_callback_add(popup, "block,clicked", popup_block_clicked_cb, NULL);
 399                 evas_object_smart_callback_add(popup, "timeout", popup_response_cb, NULL);
 400                 evas_object_show(popup);
 401                 return -1;
 402         }
 403
 404         if (ad->setting_ug) {
 405                 debug_log("destroy setting_ug");
 406                 ug_destroy(ad->setting_ug);
 407                 ad->setting_ug = NULL;
 408         }
 409
 410         email_clear_all_notification_bar();
 411
 412         launch_email_ug(b, ad);
 413
 414         evas_object_show(ad->win_main);
 415
 416         return 0;
 417 }
 418
 419 static int app_low_memory(void *data)
 420 {
 421         debug_log("");
 422         ug_send_event(UG_EVENT_LOW_MEMORY);
 423         return 0;
 424 }
 425
 426 static int app_low_battery(void *data)
 427 {
 428         debug_log("");
 429         ug_send_event(UG_EVENT_LOW_BATTERY);
 430         return 0;
 431 }
 432
 433 static int app_lang_changed(void *data)
 434 {
 435         debug_log("");
 436         ug_send_event(UG_EVENT_LANG_CHANGE);
 437         return 0;
 438 }
 439
 440 static int app_region_changed(void *data)
 441 {
 442         debug_log("");
 443         ug_send_event(UG_EVENT_REGION_CHANGE);
 444         return 0;
 445 }
 446
 447 int main(int argc, char *argv[])
 448 {
 449         debug_log("");
 450
 451         if (!g_thread_supported()) {
 452                 g_thread_init(NULL);
 453         }
 454         g_type_init();
 455
 456         app_event_callback_s ops;
 457         memset(&ops, 0x0, sizeof(app_event_callback_s));
 458
 459         ops.create = (app_create_cb)app_create;
 460         ops.terminate = (app_terminate_cb)app_terminate;
 461         ops.pause = (app_pause_cb)app_pause;
 462         ops.resume = (app_resume_cb)app_resume;
 463         ops.service = (app_service_cb)app_reset;
 464         ops.low_memory = (app_low_memory_cb)app_low_memory;
 465         ops.low_battery = (app_low_battery_cb)app_low_battery;
 466         ops.device_orientation = (app_device_orientation_cb)_email_main_rotation_cb;
 467         ops.language_changed = (app_language_changed_cb)app_lang_changed;
 468         ops.region_format_changed = (app_region_format_changed_cb)app_region_changed;
 469
 470         ecore_init();
 471         ecore_thread_max_set(1); /* spawn 1 thread for getting mail list in mailbox */
 472
 473         struct appdata ad;
 474         memset(&ad, 0x0, sizeof(struct appdata));
 475
 476         return app_efl_main(&argc, &argv, &ops, &ad);
 477 }
 478
 479 static Evas_Object *create_win(const char *name)
 480 {
 481         debug_log("");
 482         Evas_Object *eo;
 483         int w, h;
 484
 485         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 486         if (eo) {
 487                 elm_win_title_set(eo, name);
 488                 evas_object_smart_callback_add(eo, "delete,request", win_del, NULL);
 489                 ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
 490                 evas_object_resize(eo, w, h);
 491         }
 492
 493         return eo;
 494 }
 495
 496 static void win_del(void *data, Evas_Object *obj, void *event)
 497 {
 498         debug_log("");
 499         elm_exit();
 500 }
 501
 502 static void launch_email_ug(service_h b, struct appdata *ad)
 503 {
 504         debug_log("");
 505
 506         if (b == NULL || ad == NULL) {
 507                 debug_log("bundle data is NULL");
 508                 return;
 509         }
 510
 511         gint acct_id = 0;
 512
 513         /* 0. run email in no default account */
 514         if (!email_engine_get_default_account(&acct_id)) {
 515                 debug_log("Initial Access");
 516
 517                 if (ad->setting_ug) {
 518                         debug_log("Setting is already running");
 519                         return;
 520                 }
 521
 522                 int ret;
 523                 service_h service = NULL;
 524
 525                 ret = service_create(&service);
 526                 debug_log("service_create: %d", ret);
 527                 if (!service) {
 528                         debug_log("service create failed");
 529                         return;
 530                 }
 531
 532                 ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_VIEW_TYPE, EMAIL_BUNDLE_VAL_VIEW_FIRST_SETUP);
 533                 debug_log("service_add_extra_data: %d", ret);
 534
 535                 ad->setting_ug = create_ug(UG_NAME_EMAIL_SETTING, service, ad);
 536
 537                 if (NULL != ad->setting_ug) {
 538                         _b_setting_opened = true;
 539                 }
 540
 541                 ret = service_destroy(service);
 542                 debug_log("service_destroy: %d", ret);
 543         }
 544
 545         /* 1. run email ug from app service */
 546         if (check_app_svc_operation(b, ad, acct_id)) {
 547                 return;
 548         }
 549
 550         /* 2. run email ug from mime type parsing */
 551         if (check_aul_mime_operation(b, ad)) {
 552                 return;
 553         }
 554
 555         /* 3. run email ug from run type */
 556         if (check_aul_launch_operation(b, ad)) {
 557                 return;
 558         }
 559
 560         /* 4. run email in normal case (from menuscreen) */
 561         if (email_engine_get_default_account(&acct_id)) {
 562                 debug_log("run email in normal case");
 563                 if (ad->mailbox_ug) {
 564                         debug_log("Mailbox is already running");
 565                         return;
 566                 }
 567
 568                 int ret;
 569                 service_h service = NULL;
 570
 571                 ret = service_create(&service);
 572                 debug_log("service_create: %d", ret);
 573                 if (!service) {
 574                         debug_log("service create failed");
 575                         return;
 576                 }
 577
 578                 char initial[4] = { 0, };
 579                 snprintf(initial, sizeof(initial), "%d", 1);
 580
 581                 ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_INITIAL_RUN, initial);
 582                 debug_log("service_add_extra_data: %d", ret);
 583
 584                 ad->mailbox_ug = create_ug(UG_NAME_EMAIL_MAILBOX, service, ad);
 585                 _g_mailbox_ug = ad->mailbox_ug;
 586
 587                 ret = service_destroy(service);
 588                 debug_log("service_destroy: %d", ret);
 589         }
 590 }
 591
 592 static int check_app_svc_operation(service_h b, struct appdata *ad, gint account_id)
 593 {
 594         debug_log("");
 595
 596         char *uri = NULL;
 597         char *mime = NULL;
 598         char *to = NULL;
 599         char *cc = NULL;
 600         char *bcc = NULL;
 601         char *subject = NULL;
 602         char *body = NULL;
 603         char *operation = NULL;
 604         char rtype[10] = { 0, };
 605
 606         service_get_operation(b, &operation);
 607         debug_log("operation = %s", operation);
 608
 609         if (!operation) {
 610                 return FALSE;
 611         } else {
 612                 if (g_strcmp0(operation, SERVICE_OPERATION_SEND) != 0 &&
 613                                 g_strcmp0(operation, SERVICE_OPERATION_SEND_TEXT) != 0) {
 614                         return FALSE;
 615                 }
 616
 617                 if (email_engine_get_default_account(&account_id) == FALSE) {
 618                         Evas_Object *popup = elm_popup_add(ad->win_main);
 619                         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 620                         elm_popup_timeout_set(popup, 2.0);
 621                         elm_object_part_text_set(popup, "title,text", dgettext("sys_string", "IDS_COM_POP_WARNING"));
 622                         elm_object_text_set(popup, _("IDS_EMAIL_POP_THERE_IS_NO_ACCOUNT_CREATE_A_NEW_ACCOUNT_FIRST"));
 623                         evas_object_smart_callback_add(popup, "block,clicked", block_clicked_cb, NULL);
 624                         evas_object_show(popup);
 625                         return FALSE;
 626                 }
 627
 628                 int ret;
 629                 service_h service = NULL;
 630
 631                 ret = service_create(&service);
 632                 debug_log("service_create: %d", ret);
 633                 if (!service) {
 634                         debug_log("service create failed");
 635                         return FALSE;
 636                 }
 637
 638                 snprintf(rtype, sizeof(rtype), "%d", RUN_COMPOSER_EXTERNAL);
 639
 640                 ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_RUN_TYPE, rtype);
 641                 debug_log("service_add_extra_data: %d", ret);
 642
 643                 if (g_strcmp0(operation, SERVICE_OPERATION_SEND) == 0) {
 644                         service_get_uri(b, &uri);
 645                         if (uri) {
 646                                 debug_log("uri: %s", uri);
 647
 648                                 if (g_str_has_prefix(uri, URI_SCHEME_MAILTO)) {
 649                                         gchar **vector;
 650                                         vector = g_strsplit_set(uri, "?", -1);
 651                                         if (vector != NULL) {
 652                                                 char *mailto_uri = g_strdup(vector[0]);
 653                                                 g_strfreev(vector);
 654
 655                                                 if (mailto_uri && (strlen(mailto_uri) - strlen(URI_SCHEME_MAILTO)) > 0) {
 656                                                         to = g_strndup(mailto_uri + strlen(URI_SCHEME_MAILTO),
 657                                                                         strlen(mailto_uri) - strlen(URI_SCHEME_MAILTO));
 658                                                 }
 659
 660                                                 g_free(mailto_uri);
 661                                         }
 662                                 } else if (g_str_has_prefix(uri, URI_SCHEME_FILE)) {
 663                                         char *file_uri = g_strndup(uri + strlen(URI_SCHEME_FILE),
 664                                                         strlen(uri) - strlen(URI_SCHEME_FILE));
 665                                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_ATTACHMENT, file_uri);
 666                                         debug_log("service_add_extra_data: %d", ret);
 667                                 } else if (g_str_has_prefix(uri, URI_SCHEME_HTTP)) {
 668                                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_BODY, uri);
 669                                         debug_log("service_add_extra_data: %d", ret);
 670                                 } else if (g_str_has_prefix(uri, "/")) {
 671                                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_ATTACHMENT, uri);
 672                                         debug_log("service_add_extra_data: %d", ret);
 673                                 }
 674                         }
 675
 676                         service_get_mime(b, &mime);
 677                         if (mime)
 678                                 debug_log("mime: %s", mime);
 679                 }
 680
 681                 if (!to)
 682                         service_get_extra_data(b, SERVICE_DATA_TO, &to);
 683                 if (to) {
 684                         debug_log("to address = %s", to);
 685                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_TO, to);
 686                         debug_log("service_add_extra_data: %d", ret);
 687                 }
 688
 689                 service_get_extra_data(b, SERVICE_DATA_CC, &cc);
 690
 691                 if (cc) {
 692                         debug_log("cc address = %s", cc);
 693                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_CC, cc);
 694                         debug_log("service_add_extra_data: %d", ret);
 695                 }
 696
 697                 service_get_extra_data(b, SERVICE_DATA_BCC, &bcc);
 698
 699                 if (bcc) {
 700                         debug_log("bcc address = %s", bcc);
 701                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_BCC, bcc);
 702                         debug_log("service_add_extra_data: %d", ret);
 703                 }
 704
 705                 service_get_extra_data(b, SERVICE_DATA_SUBJECT, &subject);
 706
 707                 if (subject) {
 708                         debug_log("subject = %s", subject);
 709                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_SUBJECT, subject);
 710                         debug_log("service_add_extra_data: %d", ret);
 711                 }
 712
 713                 service_get_extra_data(b, SERVICE_DATA_TEXT, &body);
 714
 715                 if (body) {
 716                         debug_log("body = %s", body);
 717                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_BODY, body);
 718                         debug_log("service_add_extra_data: %d", ret);
 719                 }
 720
 721                 ad->composer_ug = create_ug(UG_NAME_EMAIL_COMPOSER, service, ad);
 722
 723                 ret = service_destroy(service);
 724                 debug_log("service_destroy: %d", ret);
 725
 726                 if (to)
 727                         g_free(to);
 728                 if (cc)
 729                         g_free(cc);
 730                 if (bcc)
 731                         g_free(bcc);
 732                 if (subject)
 733                         g_free(subject);
 734                 if (body)
 735                         g_free(body);
 736
 737                 return TRUE;
 738         }
 739 }
 740
 741 static int check_aul_mime_operation(service_h b, struct appdata *ad)
 742 {
 743         debug_log("");
 744         char *aul_content = NULL;
 745         char *aul_mime_type = NULL;
 746         char rtype[10] = { 0, };
 747
 748         int ret = service_get_extra_data(b, AUL_K_MIME_TYPE, &aul_mime_type);   //"__AUL_MIME_TYPE__"
 749         debug_log("service_get_extra_data: %d", ret);
 750         ret = service_get_extra_data(b, AUL_K_MIME_CONTENT, &aul_content);      //"__AUL_MIME_CONTENT__"
 751         debug_log("service_get_extra_data: %d", ret);
 752
 753         debug_log("mime_type:%s, content:%s", aul_mime_type, aul_content);
 754         if (aul_mime_type != NULL && aul_content != NULL) {
 755                 if (strcmp(aul_mime_type, "email.uri") == 0) {
 756                         debug_log("AUL CONTENT OPEN, launch composer");
 757                         struct ug_cbs cbs = { 0, };
 758
 759                         cbs.layout_cb = layout_cb;
 760                         cbs.result_cb = result_cb;
 761                         cbs.destroy_cb = aul_destroy_cb;
 762                         cbs.priv = ad;
 763
 764                         service_h service = NULL;
 765
 766                         ret = service_create(&service);
 767                         debug_log("service_create: %d", ret);
 768                         if (!service) {
 769                                 debug_log("service create failed");
 770                                 goto FINISH_MIME_LAUNCH;
 771                         }
 772
 773                         snprintf(rtype, sizeof(rtype), "%d", RUN_COMPOSER_EXTERNAL);
 774
 775                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_RUN_TYPE, rtype);
 776                         debug_log("service_add_extra_data: %d", ret);
 777                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_TO, aul_content);
 778                         debug_log("service_add_extra_data: %d", ret);
 779
 780                         ad->composer_ug = ug_create(NULL, UG_NAME_EMAIL_COMPOSER, UG_MODE_FULLVIEW, service, &cbs);
 781
 782                         ret = service_destroy(service);
 783                         debug_log("service_destroy: %d", ret);
 784                 } else {
 785                         debug_log("Not supported mime type : %s", aul_mime_type);
 786                 }
 787
 788 FINISH_MIME_LAUNCH:
 789                 g_free(aul_content);
 790                 g_free(aul_mime_type);
 791                 return TRUE;
 792         } else {
 793                 if (aul_content)
 794                         g_free(aul_content);
 795                 if (aul_mime_type)
 796                         g_free(aul_mime_type);
 797                 return FALSE;
 798         }
 799 }
 800
 801 static int check_aul_launch_operation(service_h b, struct appdata *ad)
 802 {
 803         debug_log("");
 804
 805         char *runtype = NULL;
 806         char *account_id = NULL;
 807         char *mail_id = NULL;
 808         char *mailbox_id = NULL;
 809         char *thread_id = NULL;
 810         char *to = NULL;
 811         char *cc = NULL;
 812         char *bcc = NULL;
 813         char *subject = NULL;
 814         char *body = NULL;
 815         char *attachment = NULL;
 816
 817         int ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_RUN_TYPE, &runtype);
 818         debug_log("service_get_extra_data: %d", ret);
 819
 820         debug_log("runtype:%s", runtype);
 821         if (runtype != NULL) {
 822                 if (atoi(runtype) == RUN_COMPOSER_EDIT) {
 823                         debug_log("RUN_COMPOSER_EDIT");
 824                         if (ad->composer_ug) {
 825                                 debug_log("Composer is already running");
 826                                 goto FINISH_AUL_LAUNCH;
 827                         }
 828
 829                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_MAILBOX, &mailbox_id);
 830                         debug_log("service_get_extra_data: %d", ret);
 831                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_MAIL_ID, &mail_id);
 832                         debug_log("service_get_extra_data: %d", ret);
 833
 834                         service_h service = NULL;
 835
 836                         ret = service_create(&service);
 837                         debug_log("service_create: %d", ret);
 838                         if (!service) {
 839                                 debug_log("service create failed");
 840                                 goto ERROR_AUL_LAUNCH;
 841                         }
 842
 843                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_RUN_TYPE, runtype);
 844                         debug_log("service_add_extra_data: %d", ret);
 845                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_MAILBOX, mailbox_id);
 846                         debug_log("service_add_extra_data: %d", ret);
 847                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_MAIL_ID, mail_id);
 848                         debug_log("service_add_extra_data: %d", ret);
 849
 850                         ad->composer_ug = create_ug(UG_NAME_EMAIL_COMPOSER, service, ad);
 851
 852                         ret = service_destroy(service);
 853                         debug_log("service_destroy: %d", ret);
 854
 855                         goto FINISH_AUL_LAUNCH;
 856                 }
 857
 858                 else if (atoi(runtype) == RUN_COMPOSER_NEW) {
 859                         debug_log("RUN_COMPOSER_NEW");
 860                         if (ad->composer_ug) {
 861                                 debug_log("Composer is already running");
 862                                 goto FINISH_AUL_LAUNCH;
 863                         }
 864
 865                         int acc_id;
 866                         email_engine_get_default_account(&acc_id);
 867
 868                         service_h service = NULL;
 869
 870                         ret = service_create(&service);
 871                         debug_log("service_create: %d", ret);
 872                         if (!service) {
 873                                 debug_log("service create failed");
 874                                 goto ERROR_AUL_LAUNCH;
 875                         }
 876
 877                         char s_composer_type[14] = { 0, };
 878                         char s_account_id[14] = { 0, };
 879                         snprintf(s_composer_type, sizeof(s_composer_type), "%d", RUN_COMPOSER_NEW);
 880                         snprintf(s_account_id, sizeof(s_account_id), "%d", acc_id);
 881
 882                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_RUN_TYPE, s_composer_type);
 883                         debug_log("service_add_extra_data: %d", ret);
 884                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_ACCOUNT_ID, s_account_id);
 885                         debug_log("service_add_extra_data: %d", ret);
 886
 887                         ad->composer_ug = create_ug(UG_NAME_EMAIL_COMPOSER, service, ad);
 888
 889                         ret = service_destroy(service);
 890                         debug_log("service_destroy: %d", ret);
 891
 892                         goto FINISH_AUL_LAUNCH;
 893                 }
 894
 895                 else if (atoi(runtype) == RUN_COMPOSER_EXTERNAL) {
 896                         debug_log("RUN_COMPOSER_EXTERNAL");
 897                         if (ad->composer_ug) {
 898                                 debug_log("Composer is already running");
 899                                 goto FINISH_AUL_LAUNCH;
 900                         }
 901
 902                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_TO, &to);
 903                         debug_log("service_get_extra_data: %d", ret);
 904                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_CC, &cc);
 905                         debug_log("service_get_extra_data: %d", ret);
 906                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_BCC, &bcc);
 907                         debug_log("service_get_extra_data: %d", ret);
 908                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_SUBJECT, &subject);
 909                         debug_log("service_get_extra_data: %d", ret);
 910                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_BODY, &body);
 911                         debug_log("service_get_extra_data: %d", ret);
 912                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_ATTACHMENT, &attachment);
 913                         debug_log("service_get_extra_data: %d", ret);
 914
 915                         int acc_id;
 916                         email_engine_get_default_account(&acc_id);
 917
 918                         service_h service = NULL;
 919
 920                         ret = service_create(&service);
 921                         debug_log("service_create: %d", ret);
 922                         if (!service) {
 923                                 debug_log("service create failed");
 924                                 goto ERROR_AUL_LAUNCH;
 925                         }
 926
 927                         char s_composer_type[14] = { 0, };
 928                         char s_account_id[14] = { 0, };
 929
 930                         snprintf(s_composer_type, sizeof(s_composer_type), "%d", RUN_COMPOSER_EXTERNAL);
 931                         snprintf(s_account_id, sizeof(s_account_id), "%d", acc_id);
 932
 933                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_RUN_TYPE, s_composer_type);
 934                         debug_log("service_add_extra_data: %d", ret);
 935                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_ACCOUNT_ID, s_account_id);
 936                         debug_log("service_add_extra_data: %d", ret);
 937                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_TO, to);
 938                         debug_log("service_add_extra_data: %d", ret);
 939                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_CC, cc);
 940                         debug_log("service_add_extra_data: %d", ret);
 941                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_BCC, bcc);
 942                         debug_log("service_add_extra_data: %d", ret);
 943                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_SUBJECT, subject);
 944                         debug_log("service_add_extra_data: %d", ret);
 945                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_BODY, body);
 946                         debug_log("service_add_extra_data: %d", ret);
 947                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_ATTACHMENT, attachment);
 948                         debug_log("service_add_extra_data: %d", ret);
 949
 950                         ad->composer_ug = create_ug(UG_NAME_EMAIL_COMPOSER, service, ad);
 951
 952                         ret = service_destroy(service);
 953                         debug_log("service_destroy: %d", ret);
 954
 955                         goto FINISH_AUL_LAUNCH;
 956                 }
 957
 958                 else if (atoi(runtype) == RUN_VIEWER) {
 959                         debug_log("RUN_VIEWER");
 960                         if (ad->viewer_ug) {
 961                                 debug_log("Viewer is already running");
 962                                 goto FINISH_AUL_LAUNCH;
 963                         }
 964
 965                         char internal[10] = { 0, };
 966
 967                         snprintf(internal, sizeof(internal), "%d", 0);
 968
 969                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_ACCOUNT_ID, &account_id);
 970                         debug_log("service_get_extra_data: %d", ret);
 971                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_MAIL_ID, &mail_id);
 972                         debug_log("service_get_extra_data: %d", ret);
 973                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_MAILBOX, &mailbox_id);
 974                         debug_log("service_get_extra_data: %d", ret);
 975
 976                         service_h service = NULL;
 977
 978                         ret = service_create(&service);
 979                         debug_log("service_create: %d", ret);
 980                         if (!service) {
 981                                 debug_log("service create failed");
 982                                 goto ERROR_AUL_LAUNCH;
 983                         }
 984
 985                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_ACCOUNT_ID, account_id);
 986                         debug_log("service_add_extra_data: %d", ret);
 987                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_MAIL_ID, mail_id);
 988                         debug_log("service_add_extra_data: %d", ret);
 989                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_MAILBOX, mailbox_id);
 990                         debug_log("service_add_extra_data: %d", ret);
 991                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_INTERNAL, internal);
 992                         debug_log("service_add_extra_data: %d", ret);
 993
 994                         ad->viewer_ug = create_ug(UG_NAME_EMAIL_VIEWER, service, ad);
 995
 996                         ret = service_destroy(service);
 997                         debug_log("service_destroy: %d", ret);
 998
 999                         goto FINISH_AUL_LAUNCH;
1000                 }
1001
1002                 else if (atoi(runtype) == RUN_MAILBOX_THREAD) {
1003                         debug_log("RUN_MAILBOX_THREAD");
1004                         if (ad->mailbox_ug) {
1005                                 debug_log("Mailbox is already running");
1006                                 goto FINISH_AUL_LAUNCH;
1007                         }
1008
1009                         ret = service_get_extra_data(b, EMAIL_BUNDLE_KEY_THREAD_ID, &thread_id);
1010                         debug_log("service_get_extra_data: %d", ret);
1011                         debug_log("thread_id: [%d]", atoi(thread_id));
1012
1013                         service_h service = NULL;
1014
1015                         ret = service_create(&service);
1016                         debug_log("service_create: %d", ret);
1017                         if (!service) {
1018                                 debug_log("service create failed");
1019                                 goto ERROR_AUL_LAUNCH;
1020                         }
1021
1022                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_THREAD_ID, thread_id);
1023                         debug_log("service_add_extra_data: %d", ret);
1024
1025                         ad->mailbox_ug = create_ug(UG_NAME_EMAIL_MAILBOX, service, ad);
1026
1027                         ret = service_destroy(service);
1028                         debug_log("service_destroy: %d", ret);
1029
1030                         goto FINISH_AUL_LAUNCH;
1031                 }
1032
1033                 else if (atoi(runtype) == RUN_SETTING_ACCOUNT_ADD) {
1034                         debug_log("RUN_SETTING_ACCOUNT_ADD");
1035
1036                         gint acct_id = 0;
1037                         if (email_engine_get_default_account(&acct_id)) {
1038                                 debug_log("Default accont is exist");
1039                                 goto ERROR_AUL_LAUNCH;
1040                         }
1041
1042                         if (ad->setting_ug) {
1043                                 debug_log("Setting is already running");
1044                                 goto FINISH_AUL_LAUNCH;
1045                         }
1046
1047                         service_h service = NULL;
1048
1049                         ret = service_create(&service);
1050                         debug_log("service_create: %d", ret);
1051                         if (!service) {
1052                                 debug_log("service create failed");
1053                                 goto ERROR_AUL_LAUNCH;
1054                         }
1055
1056                         ret = service_add_extra_data(service, EMAIL_BUNDLE_KEY_VIEW_TYPE, EMAIL_BUNDLE_VAL_VIEW_FIRST_SETUP);
1057                         debug_log("service_add_extra_data: %d", ret);
1058
1059                         ad->setting_ug = create_ug(UG_NAME_EMAIL_SETTING, service, ad);
1060
1061                         ret = service_destroy(service);
1062                         debug_log("service_destroy: %d", ret);
1063
1064                         goto FINISH_AUL_LAUNCH;
1065                 }
1066
1067 FINISH_AUL_LAUNCH:
1068                 g_free(runtype);
1069                 g_free(mailbox_id);
1070                 g_free(mail_id);
1071                 g_free(account_id);
1072                 g_free(thread_id);
1073                 g_free(to);
1074                 g_free(cc);
1075                 g_free(bcc);
1076                 g_free(subject);
1077                 g_free(body);
1078                 g_free(attachment);
1079                 return TRUE;
1080
1081 ERROR_AUL_LAUNCH:
1082                 g_free(runtype);
1083                 g_free(mailbox_id);
1084                 g_free(mail_id);
1085                 g_free(account_id);
1086                 g_free(thread_id);
1087                 g_free(to);
1088                 g_free(cc);
1089                 g_free(bcc);
1090                 g_free(subject);
1091                 g_free(body);
1092                 g_free(attachment);
1093                 return FALSE;
1094         }
1095
1096         return FALSE;
1097 }
1098
1099 static void block_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1100 {
1101         evas_object_del(obj);
1102 }
1103
1104 static void popup_block_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1105 {
1106         debug_log("");
1107
1108         if (obj)
1109                 evas_object_del(obj);
1110
1111         elm_exit();
1112 }
1113
1114 static void popup_response_cb(void *data, Evas_Object *obj, void *event_info)
1115 {
1116         debug_log("");
1117         elm_exit();
1118 }
1119
1120 /* EOF */