libug/libug-gallery-efl/src/gallery-efl.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 #ifndef UG_MODULE_API
  18 #define UG_MODULE_API __attribute__ ((visibility("default")))
  19 #endif
  20
  21 #include <Evas.h>
  22 #include <aul.h>
  23 #include "gallery-efl.h"
  24 #include "ge-debug.h"
  25 #include "ge-albums.h"
  26 #include "ge-gridview.h"
  27 #include "ge-db-handler.h"
  28 #include "ge-ui-util.h"
  29 #include "ge-util.h"
  30 #include "ge-ext-ug-load.h"
  31 #include "ge-strings.h"
  32
  33 static ge_view_mode g_view_mode = GE_AlbumsView_Mode;
  34 #define GE_BG_COLOR_DEFAULT 45
  35 #define GE_BG_ALPHA_DEFAULT 255
  36
  37
  38 ge_view_mode _ge_get_view_mode(void)
  39 {
  40         return g_view_mode;
  41 }
  42
  43 void _ge_set_view_mode(ge_view_mode mode)
  44 {
  45         g_view_mode = mode;
  46 }
  47
  48 static int _ge_create_ly_view(ge_ugdata *ugd)
  49 {
  50         GE_CHECK_VAL(ugd, -1);
  51         GE_CHECK_VAL(ugd->navi_bar, -1);
  52
  53         /**
  54         * Init libmedia-info.
  55         * If failed, records couldn't be got from DB, cluster list is emty.
  56         * Show warning message instead of return -1;
  57         */
  58         if(ge_db_init(ugd) != GE_DB_SUCCESS)
  59         {
  60                 ge_dbgW("ge_db_init failed!");
  61         }
  62
  63         /**
  64         * Get cluster list from DB.
  65         * If cluster list is empty, GE_DB_FAILED returned,
  66         * "No contents" view would be created and showed.
  67         * Show warning message instead of return -1;
  68         */
  69         if(ge_db_get_clusters_list(ugd) != GE_DB_SUCCESS)
  70         {
  71                 ge_dbgW("ge_db_get_clusters_list failed!");
  72         }
  73         /* Create layout of albums view */
  74         ugd->albums_view_ly = ge_albums_create_ly(ugd->navi_bar);
  75         GE_CHECK_VAL(ugd->albums_view_ly, -1);
  76         /* Create albums view */
  77         ugd->albums_view = ge_albums_create_view(ugd, ugd->albums_view_ly);
  78         GE_CHECK_VAL(ugd->albums_view, -1);
  79         elm_object_part_content_set(ugd->albums_view_ly, "contents", ugd->albums_view);
  80
  81         ge_ui_create_title_and_push(ugd, ugd->navi_bar, ugd->albums_view_ly, AlbumsView_Title, ugd->albums_view_title);
  82         _ge_set_view_mode( GE_AlbumsView_Mode );
  83
  84         return 0;
  85 }
  86
  87 static Evas_Object *_ge_create_bg(Evas_Object *parent)
  88 {
  89         ge_dbg("");
  90         GE_CHECK_NULL(parent);
  91         Evas_Object *bg = NULL;
  92
  93         bg = elm_bg_add(parent);
  94         /* Show special color(48,48,48,255) of background */
  95         elm_bg_color_set(bg, GE_BG_COLOR_DEFAULT,
  96                          GE_BG_COLOR_DEFAULT, GE_BG_COLOR_DEFAULT);
  97
  98         evas_object_size_hint_weight_set(bg,
  99                                          EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 100         evas_object_size_hint_align_set(bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
 101         evas_object_show(bg);
 102
 103         return bg;
 104 }
 105
 106 static int _ge_init_view(ge_ugdata *ugd)
 107 {
 108         ge_dbg("");
 109         GE_CHECK_VAL(ugd, -1);
 110
 111         /* Base Layout */
 112         ugd->ly_main = ge_ui_create_main_ly(ugd, ugd->win);
 113         GE_CHECK_VAL(ugd->ly_main, -1);
 114
 115         /* Background */
 116         ugd->bg = _ge_create_bg(ugd->ly_main);
 117         GE_CHECK_VAL(ugd->bg, -1);
 118         /* Pack bg to swallow */
 119         elm_object_part_content_set(ugd->ly_main, "elm.swallow.bg", ugd->bg);
 120
 121         /* Navigation Bar */
 122         ugd->navi_bar = ge_ui_create_navibar(ugd, ugd->ly_main);
 123         GE_CHECK_VAL(ugd->navi_bar, -1);
 124
 125         /* Albums view and its layout */
 126         if(_ge_create_ly_view(ugd) != 0)
 127         {
 128                 ge_dbgE("Create albums view and layout failed!");
 129                 return -1;
 130         }
 131
 132         return 0;
 133 }
 134
 135 static int _ge_create_view(ge_ugdata *ugd)
 136 {
 137         ge_dbg("");
 138         GE_CHECK_VAL(ugd, -1);
 139
 140         /* Set inited flag as TRUE */
 141         ugd->b_inited_view = true;
 142         /* Add new theme */
 143         ugd->th = elm_theme_new();
 144         GE_CHECK_VAL(ugd->th, -1);
 145         elm_theme_ref_set(ugd->th, NULL);
 146         elm_theme_extension_add(ugd->th, GE_EDJ_FILE);
 147         elm_theme_extension_add(ugd->th, GALLERY_BLACK_EDJ_FILE);
 148
 149         /* Initialize gallery ug view */
 150         if(_ge_init_view(ugd) != 0)
 151         {
 152                 ge_dbgE("Initialize view failed!");
 153                 return -1;
 154         }
 155
 156         /* Register MMC and UMS changed callback */
 157         if(ge_reg_db_update_noti(ugd) != 0) {
 158                 ge_dbgE("ge_reg_db_update_noti failed!");
 159                 return -1;
 160         }
 161         if(ge_reg_ums_noti(ugd) != 0) {
 162                 ge_dbgE("ge_reg_ums_noti failed!");
 163                 return -1;
 164         }
 165
 166         return 0;
 167 }
 168
 169 static int _ge_close_view(ge_ugdata *ugd)
 170 {
 171         GE_CHECK_VAL(ugd, -1);
 172
 173         GE_DEL_OBJ(ugd->popup)
 174
 175         GE_FREE_MEM(ugd->file_setas_callid_path)
 176         GE_FREE_MEM(ugd->file_setas_homescreen_path)
 177         GE_FREE_MEM(ugd->file_setas_lockscreen_path)
 178         GE_FREE_MEM(ugd->file_setas_callid_size)
 179         GE_FREE_MEM(ugd->file_setas_image_path)
 180         GE_FREE_MEM(ugd->file_setas_crop_image_path)
 181
 182         if(ugd->b_inited_view) {
 183                 /* Destroy UG called by me */
 184                 if (ugd->ug_called_by_me) {
 185                         ug_destroy(ugd->ug_called_by_me);
 186                         ugd->ug_called_by_me = NULL;
 187                 }
 188
 189                 GE_DEL_TIMER(ugd->ums_update_timer)
 190                 GE_DEL_TIMER(ugd->del_timer)
 191                 GE_DEL_TIMER(ugd->thumbs_clicked_timer)
 192                 GE_DEL_IDLER(ugd->grid_append_idler)
 193
 194                 ge_dereg_db_update_noti();
 195                 ge_dereg_ums_noti();
 196
 197                 ge_grid_del_callbacks(ugd);
 198                 ge_albums_del_callbacks(ugd);
 199
 200                 GE_DEL_OBJ(ugd->navi_bar)
 201                 GE_DEL_OBJ(ugd->bg)
 202                 GE_DEL_OBJ(ugd->ly_main)
 203
 204                 ge_albums_free_cover_thumbs(ugd);
 205
 206                 /* Disconnet with libmedia-info */
 207                 ge_db_finalize(ugd);
 208                 if(ugd->th) {
 209                         elm_theme_extension_del(ugd->th, GE_EDJ_FILE);
 210                         elm_theme_extension_del(ugd->th,
 211                                                 GALLERY_BLACK_EDJ_FILE);
 212                         elm_theme_free(ugd->th);
 213                         ugd->th = NULL;
 214                 }
 215                 ugd->b_inited_view = false;
 216         }
 217
 218         return 0;
 219 }
 220
 221 static void __ge_parse_param_launch_type_setas(ge_ugdata *ugd, bundle *data)
 222 {
 223         GE_CHECK(ugd);
 224         GE_CHECK(data);
 225         bundle* b = data;
 226
 227         const char *setas_type = NULL;
 228         const char *callerid_size = NULL;
 229         const char *callerid_path = NULL;
 230         const char *wallpaper_path = NULL;
 231         const char *lockscreen_path = NULL;
 232
 233         setas_type = bundle_get_val(b, GE_BUNDLE_SETAS_TYPE);
 234         if(setas_type == NULL) {
 235                 ge_dbg("setas-type NULL");
 236                 return;
 237         }
 238
 239         if (!strcasecmp(setas_type, GE_FILE_SELECT_SETAS_WALLPALER)) {
 240                 ugd->file_select_setas_mode = GE_File_Select_Setas_Wallpaper;
 241                 g_strlcpy(ugd->albums_view_title, GE_TITLE_CHANGE_WALLPAPER,
 242                                 GE_ALBUM_NAME_LEN_MAX);
 243
 244                 wallpaper_path = bundle_get_val(b, GE_BUNDLE_HOMESCREEN_PATH);
 245                 if (wallpaper_path) {
 246                         ge_dbg("path:%s", wallpaper_path);
 247                         ugd->file_setas_homescreen_path = strdup(wallpaper_path);
 248                 }
 249
 250                 lockscreen_path = bundle_get_val(b, GE_BUNDLE_LOCKSCREEN_PATH);
 251                 if (lockscreen_path) {
 252                         ge_dbg("path:%s", lockscreen_path);
 253                         ugd->file_setas_lockscreen_path = strdup(lockscreen_path);
 254                 }
 255         } else if (!strcasecmp(setas_type, GE_FILE_SELECT_SETAS_CALLERID))
 256         {
 257                 ugd->file_select_setas_mode = GE_File_Select_Setas_CallerID;
 258                 g_strlcpy(ugd->albums_view_title, GE_TITLE_CHANGE_CALLER_ID,
 259                                 GE_ALBUM_NAME_LEN_MAX);
 260
 261                 callerid_size = bundle_get_val(b, GE_BUNDLE_CALLERID_SIZE);
 262                 if (callerid_size) {
 263                         ge_dbg("size:%s", callerid_size);
 264                         ugd->file_setas_callid_size = strdup(callerid_size);
 265                 }
 266
 267                 callerid_path = bundle_get_val(b, GE_BUNDLE_CALLERID_PATH);
 268                 if (callerid_path) {
 269                         ge_dbg("path:%s", callerid_path);
 270                         ugd->file_setas_callid_path = strdup(callerid_path);
 271                 }
 272         }
 273 }
 274
 275 static void __ge_parse_param_file_type(ge_ugdata *ugd, bundle *data)
 276 {
 277         GE_CHECK(ugd);
 278         GE_CHECK(data);
 279         bundle* b = data;
 280
 281         const char *file_type = NULL;
 282         char file_type_str[GE_ALBUM_NAME_LEN_MAX] = {0,};
 283         bool b_singular = true;
 284
 285
 286         if( (ugd->file_select_mode == GE_File_Select_Multiple) ||
 287             (ugd->file_select_mode == GE_File_Select_Imft)) {
 288                 b_singular = false;
 289         }
 290
 291         /* file-type */
 292         file_type = bundle_get_val(b, GE_BUNDLE_FILE_TYPE);
 293         if(file_type == NULL)
 294                 goto DEFAULT_FILE_TYPE;
 295
 296         if (!strcasecmp(file_type, GE_FILE_SELECT_TYPE_IMAGE)) {
 297                 ugd->file_type_mode = GE_File_Select_Type_Image;
 298                 if(b_singular) {
 299                         g_strlcat(ugd->albums_view_title, GE_TITLE_IMAGE,
 300                                 sizeof(ugd->albums_view_title));
 301                 } else {
 302                         g_strlcat(ugd->albums_view_title, GE_TITLE_IMAGES,
 303                                 sizeof(ugd->albums_view_title));
 304                 }
 305                 return;
 306
 307         } else if (!strcasecmp(file_type, GE_FILE_SELECT_TYPE_VIDEO)) {
 308                 ugd->file_type_mode = GE_File_Select_Type_Video;
 309                 if(b_singular) {
 310                         g_strlcat(ugd->albums_view_title, GE_TITLE_VIDEO,
 311                                 sizeof(ugd->albums_view_title));
 312                 } else {
 313                         g_strlcat(ugd->albums_view_title, GE_TITLE_VIDEOS,
 314                                 sizeof(ugd->albums_view_title));
 315                 }
 316                 return;
 317         }
 318
 319 DEFAULT_FILE_TYPE:
 320         ge_dbg("file type is default, set default type(ALL).");
 321         ugd->file_type_mode = GE_File_Select_Type_All;
 322         if(b_singular) {
 323                 g_strlcpy(file_type_str, GE_TITLE_FILE, sizeof(file_type_str));
 324         } else {
 325                 g_strlcpy(file_type_str, GE_TITLE_FILES, sizeof(file_type_str));
 326         }
 327
 328         g_strlcat(ugd->albums_view_title, file_type_str,
 329                   sizeof(ugd->albums_view_title));
 330
 331         return;
 332 }
 333
 334 /* analysis parameters */
 335 static int _ge_parse_param(ge_ugdata *ugd, bundle *data)
 336 {
 337         GE_CHECK_VAL(ugd, -1);
 338         GE_CHECK_VAL(data, -1);
 339         bundle* b = data;
 340         const char *launch_type = NULL;
 341
 342         launch_type = bundle_get_val(b, GE_BUNDLE_LAUNCH_TYPE);
 343         if (launch_type == NULL) {
 344                 ge_dbg("launch-type == NULL");
 345                 return -1;
 346         }
 347         ge_dbg("launch-type [%s]", launch_type);
 348
 349         if(!strcasecmp(launch_type, GE_ALBUM_SELECT_ONE))
 350         {
 351                 ugd->album_select_mode = GE_Album_Select_One;
 352                 g_strlcpy(ugd->albums_view_title, GE_TITLE_ALBUMS,
 353                                 GE_ALBUM_NAME_LEN_MAX);
 354         } else if (!strcasecmp(launch_type, GE_FILE_SELECT_SETAS)) {
 355                 ugd->file_select_mode = GE_File_Select_Setas;
 356                 __ge_parse_param_launch_type_setas(ugd, data);
 357                 /* Checkme: Only image type is offered in SETAS  case */
 358                 ugd->file_type_mode = GE_File_Select_Type_Image;
 359         } else {
 360                 g_strlcpy(ugd->albums_view_title, GE_TITLE_ADD,
 361                                 GE_ALBUM_NAME_LEN_MAX);
 362                 g_strlcat(ugd->albums_view_title," ",GE_ALBUM_NAME_LEN_MAX);
 363
 364                 if (!strcasecmp(launch_type, GE_FILE_SELECT_ONE)) {
 365                         ugd->file_select_mode = GE_File_Select_One;
 366                 } else if (!strcasecmp(launch_type, GE_FILE_SELECT_MULTIPLE)) {
 367                         ugd->file_select_mode = GE_File_Select_Multiple;
 368                 } else if (!strcasecmp(launch_type, GE_FILE_SELECT_IMFT)) {
 369                         ugd->file_select_mode = GE_File_Select_Imft;
 370
 371                         const char *contact_id = NULL;
 372                         contact_id = bundle_get_val(b, "contact");
 373                         if (contact_id) {
 374                                 ugd->file_select_contact_id = atoi(contact_id);
 375                         } else {
 376                                 ugd->file_select_mode = GE_File_Select_None;
 377                                 ugd->file_select_contact_id = -1;
 378                                 ge_dbg("Invalid args");
 379                                 return -1;
 380                         }
 381
 382                         ge_dbg("contact_id: %d", ugd->file_select_contact_id);
 383                 }
 384
 385                 __ge_parse_param_file_type(ugd, data);
 386
 387         }
 388
 389         return 0;
 390 }
 391
 392 /**
 393 * @brief
 394 *
 395 * @param ug
 396 * @param mode
 397 * @param data
 398 * @param priv
 399 *
 400 * @return
 401 */
 402 static void * _ge_create(struct ui_gadget *ug, enum ug_mode mode, bundle *data, void *priv)
 403 {
 404         ge_dbg("Enter...");
 405         Evas_Object *parent = NULL;
 406         ge_ugdata *ugd = NULL;
 407         int w = 0;
 408         int h = 0;
 409
 410         GE_CHECK_NULL(priv);
 411         GE_CHECK_NULL(data);
 412         GE_CHECK_NULL(ug);
 413         ge_dbgW("Gallery UG start...");
 414
 415         ugd = (ge_ugdata *)priv;
 416         ugd->ug = ug;
 417         /* Get window */
 418         parent = (Evas_Object *)ug_get_window();
 419         GE_CHECK_NULL(parent);
 420         ugd->win = parent;
 421         /* Bind text domain for internalization */
 422         bindtextdomain("ug-gallery-efl" , "/opt/ug/res/locale");
 423         /* Reset inited flag, it would be set as TRUE if albums view created */
 424         ugd->b_inited_view = false;
 425         /* Get UMS state */
 426         ge_get_ums_state(ugd);
 427         /* Set view mode */
 428         _ge_set_view_mode(GE_AlbumsView_Mode);
 429
 430         Ecore_X_Window x_win = ecore_x_window_focus_get();
 431         GE_CHECK_NULL(x_win);
 432         Ecore_X_Window root_win = ecore_x_window_root_get(x_win);
 433         GE_CHECK_NULL(root_win);
 434         ecore_x_window_size_get(root_win, &w, &h);
 435         ge_dbg("x_window_w : %d, x_window_h: %d.", w, h);
 436         ugd->win_w = w;
 437         ugd->win_h = h;
 438         ugd->win_scale = (double)(((double)w)/((double)GE_BASE_WIN_WIDTH));
 439         ugd->bundle = data;
 440         /* Parse parameters passed from parent */
 441         if(_ge_parse_param(ugd, data) != 0) {
 442                 ge_dbgE("Failed to parse parameters!");
 443                 return NULL;
 444         }
 445
 446         if ((ugd->file_select_mode == GE_File_Select_Setas) ||
 447             (ugd->file_select_mode != GE_File_Select_None) ||
 448             (ugd->album_select_mode != GE_Album_Select_None)) {
 449                 /* create gallery UG */
 450                 if(_ge_create_view(ugd) != 0) {
 451                         ge_dbgE("Failed to create Gallery UG view!");
 452                         return NULL;
 453                 }
 454         } else {
 455                 ge_dbgE("Wrong file_select_mode[%d] or album_select_mode[%d]",
 456                         ugd->file_select_mode, ugd->album_select_mode);
 457         }
 458
 459         return ugd->ly_main;
 460 }
 461
 462 /**
 463 * @brief
 464 *
 465 * @param ug
 466 * @param data
 467 * @param priv
 468 */
 469 static void _ge_start(struct ui_gadget *ug, bundle *data, void *priv)
 470 {
 471 }
 472
 473 /**
 474 * @brief
 475 *
 476 * @param ug
 477 * @param data
 478 * @param priv
 479 */
 480 static void _ge_pause(struct ui_gadget *ug, bundle *data, void *priv)
 481 {
 482         ge_dbg("");
 483 }
 484
 485 /**
 486 * @brief
 487 *
 488 * @param ug
 489 * @param data
 490 * @param priv
 491 */
 492 static void _ge_resume(struct ui_gadget *ug, bundle *data, void *priv)
 493 {
 494         ge_dbg("");
 495         GE_CHECK(priv);
 496         ge_ugdata *ugd = (ge_ugdata *)priv;
 497         /*update*/
 498         if (!_ge_ug_iv_get())
 499         {
 500                 ge_update_view(ugd, GE_UPDATE_NONE);
 501         }
 502 }
 503
 504 /**
 505 * @brief
 506 *
 507 * @param ug
 508 * @param data
 509 * @param priv
 510 */
 511 static void _ge_destroy(struct ui_gadget *ug, bundle *data, void *priv)
 512 {
 513         ge_dbgW("");
 514         GE_CHECK(ug);
 515         GE_CHECK(priv);
 516         ge_ugdata *ugd = (ge_ugdata *)priv;
 517
 518         _ge_close_view(ugd);
 519         ge_dbgW("End of the gallery UG!");
 520 }
 521
 522 /**
 523 * @brief
 524 *
 525 * @param ug
 526 * @param msg
 527 * @param data
 528 * @param priv
 529 */
 530 static void _ge_message(struct ui_gadget *ug, bundle *msg, bundle *data, void *priv)
 531 {
 532         ge_dbg("");
 533 }
 534
 535 /**
 536 * @brief
 537 *
 538 * @param ug
 539 * @param event
 540 * @param data
 541 * @param priv
 542 */
 543 static void _ge_event(struct ui_gadget *ug, enum ug_event event, bundle *data, void *priv)
 544 {
 545         GE_CHECK(priv);
 546
 547         switch (event)
 548         {
 549         case UG_EVENT_LOW_MEMORY:
 550                 ge_dbg("UG_EVENT_LOW_MEMORY");
 551                 break;
 552
 553         case UG_EVENT_LOW_BATTERY:
 554                 ge_dbg("UG_EVENT_LOW_BATTERY");
 555                 break;
 556
 557         case UG_EVENT_LANG_CHANGE:
 558                 ge_dbg("UG_EVENT_LANG_CHANGE");
 559                 break;
 560         default:
 561                 break;
 562         }
 563
 564         return;
 565 }
 566
 567 static void _ge_key_event(struct ui_gadget *ug, enum ug_key_event event, bundle *data, void *priv)
 568 {
 569         ge_dbg("");
 570         GE_CHECK(ug);
 571
 572     switch (event)
 573         {
 574         case UG_KEY_EVENT_END:
 575                         ge_dbg("Receive key end event");
 576             ug_destroy_me(ug);
 577             break;
 578
 579         default:
 580             break;
 581     }
 582 }
 583
 584 /**
 585 * @brief
 586 *
 587 * @param ops
 588 *
 589 * @return
 590 */
 591 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 592 {
 593         ge_dbgW("UG_MODULE_INIT");
 594         ge_ugdata *ugd = NULL;
 595         GE_CHECK_VAL(ops, -1);
 596
 597         ugd = calloc(1, sizeof(ge_ugdata));
 598         GE_CHECK_VAL(ugd, -1);
 599
 600         ops->create = _ge_create;
 601         ops->start = _ge_start;
 602         ops->pause = _ge_pause;
 603         ops->resume = _ge_resume;
 604         ops->destroy = _ge_destroy;
 605         ops->message = _ge_message;
 606         ops->event = _ge_event;
 607         ops->key_event = _ge_key_event;
 608         ops->priv = ugd;
 609         ops->opt = UG_OPT_INDICATOR_ENABLE;
 610
 611         return 0;
 612 }
 613
 614 /**
 615 * @brief
 616 *
 617 * @param ops
 618 *
 619 * @return
 620 */
 621 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 622 {
 623         struct ug_data *ugd = NULL;
 624         GE_CHECK(ops);
 625
 626         ugd = ops->priv;
 627         if (ugd)
 628         {
 629                 free(ugd);
 630                 ugd = NULL;
 631         }
 632 }
 633