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