src/common/mp-menu.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 "music.h"
  18 #include <stdio.h>
  19 #include <glib.h>
  20
  21 #include "mp-player-debug.h"
  22 #include "mp-menu.h"
  23 #include "mp-util.h"
  24 #include "mp-popup.h"
  25 #include "mp-play-list.h"
  26 #include "mp-ug-launch.h"
  27 #include "mp-item.h"
  28 #include "mp-player-drm.h"
  29 #include "mp-widget.h"
  30
  31 #include "mp-setting-ctrl.h"
  32
  33 #ifndef MP_SOUND_PLAYER
  34 #include "mp-view-layout.h"
  35 #include "mp-playlist-view.h"
  36 #include "mp-common.h"
  37 #include "mp-view-manager.h"
  38 #endif
  39
  40 #define MP_MENU_FID "mp_menu_fid"
  41 #define MP_MENU_PLAY_LIST_FID "mp_menu_playlist_id"
  42 #define MP_MENU_POPUP_PLAY_LIST_HANDLER                 "mp_menu_popup_handler"
  43 #define MP_MENU_GROUP_ITEM_HANDLER      "mp_menu_group_item_handler"
  44
  45 typedef enum
  46 {
  47         MP_MENU_FUNC_ADD_TO_LIST = 0,
  48         MP_MENU_FUNC_DELETE,
  49 } mp_menu_func_type;
  50
  51
  52 mp_track_type_e
  53 mp_menu_get_track_type_by_group(mp_group_type_e group_type)
  54 {
  55         mp_track_type_e item_type = MP_TRACK_ALL;
  56
  57         if (group_type == MP_GROUP_BY_ALBUM)
  58         {
  59                 item_type = MP_TRACK_BY_ALBUM;
  60         }
  61         else if (group_type == MP_GROUP_BY_ARTIST)
  62         {
  63                 item_type = MP_TRACK_BY_ARTIST;
  64         }
  65         else if (group_type == MP_GROUP_BY_ARTIST_ALBUM)
  66         {
  67                 item_type = MP_TRACK_BY_ALBUM;
  68         }
  69         else if (group_type == MP_GROUP_BY_GENRE)
  70         {
  71                 item_type = MP_TRACK_BY_GENRE;
  72         }
  73         else if (group_type == MP_GROUP_BY_YEAR)
  74         {
  75                 item_type = MP_TRACK_BY_YEAR;
  76         }
  77         else if (group_type == MP_GROUP_BY_COMPOSER)
  78         {
  79                 item_type = MP_TRACK_BY_COMPOSER;
  80         }
  81         else if (group_type == MP_GROUP_BY_FOLDER)
  82         {
  83                 item_type = MP_TRACK_BY_FOLDER;
  84         }
  85
  86         return item_type;
  87 }
  88
  89 #ifndef MP_SOUND_PLAYER
  90 bool
  91 _mp_menu_func_by_group_handle(int plst_id, mp_layout_data_t * layout_data, mp_media_info_h svc_handle,
  92                               mp_menu_func_type menu_func)
  93 {
  94         startfunc;
  95
  96         MP_CHECK_FALSE(layout_data);
  97         MP_CHECK_LAYOUT_DATA(layout_data);
  98
  99         struct appdata *ad = layout_data->ad;
 100         MP_CHECK_FALSE(ad);
 101
 102         int err = -1;
 103         int count = 0;
 104         int index = 0;
 105         int ret = 0;
 106         int playlist_item_count = 0;
 107
 108         mp_media_list_h tracks = NULL;
 109         mp_track_type_e item_type = MP_TRACK_ALL;
 110
 111         item_type = mp_menu_get_track_type_by_group(layout_data->group_type);
 112
 113         char *name = NULL;
 114
 115         if ((item_type == MP_TRACK_BY_FOLDER))
 116         {
 117                 ret = mp_media_info_group_get_folder_id(svc_handle, &name);
 118         }
 119         else
 120         {
 121                 ret = mp_media_info_group_get_main_info(svc_handle, &name);
 122         }
 123
 124         mp_retvm_if(ret != 0, FALSE, "Fail to get value");
 125         mp_retvm_if(name == NULL, FALSE, "Fail to get value");
 126         mp_debug("%s", name);
 127
 128         ret = mp_media_info_list_count(item_type, name, NULL, NULL, 0, &count);
 129         MP_CHECK_EXCEP(ret == 0);
 130
 131         ret = mp_media_info_list_create(&tracks, item_type, name, NULL, NULL, 0, 0, count);
 132         MP_CHECK_EXCEP(ret == 0);
 133
 134 #ifdef MP_PLAYLIST_MAX_ITEM_COUNT
 135         if (menu_func == MP_MENU_FUNC_ADD_TO_LIST)
 136         {
 137                 mp_media_info_list_count(MP_TRACK_BY_PLAYLIST, NULL, NULL, NULL, plst_id, &playlist_item_count);
 138                 if (playlist_item_count >= MP_PLAYLIST_MAX_ITEM_COUNT)
 139                 {
 140                         return false;
 141                 }
 142         }
 143 #endif
 144
 145         for (index = 0; index < count; ++index)
 146         {
 147                 char *fid = 0;
 148                 char *path = NULL;
 149                 mp_media_info_h item;
 150
 151                 item = mp_media_info_list_nth_item(tracks, index);
 152                 mp_media_info_get_media_id(item, &fid);
 153                 mp_media_info_get_file_path(item, &path);
 154
 155                 if (menu_func == MP_MENU_FUNC_ADD_TO_LIST)
 156                 {
 157 #ifdef MP_PLAYLIST_MAX_ITEM_COUNT
 158                         if (playlist_item_count >= MP_PLAYLIST_MAX_ITEM_COUNT)
 159                         {
 160                                 goto mp_exception;
 161                         }
 162 #endif
 163                         err = mp_media_info_playlist_add_media(plst_id, fid);
 164                         MP_CHECK_EXCEP(err == 0);
 165                         playlist_item_count++;
 166                 }
 167                 else
 168                 {
 169                         MP_CHECK_EXCEP(path);
 170
 171                         music_list_item *cur_item =
 172                                 mp_play_list_get_current_item(layout_data->view_data->ad->playing_list);
 173                         if ((cur_item != NULL) && !g_strcmp0(cur_item->key_id ,fid))
 174                         {
 175                                 mp_widget_text_popup(layout_data->view_data->ad,
 176                                                      GET_STR("IDS_MUSIC_POP_UNABLE_TO_DELETE_SELECTED_MUSIC_IS_PLAYING"));
 177                                 goto mp_exception;
 178                         }
 179
 180                         err = remove(path);
 181                         MP_CHECK_EXCEP(err == 0);
 182                 }
 183         }
 184         mp_media_info_list_destroy(tracks);
 185
 186         return true;
 187
 188       mp_exception:
 189         mp_media_info_list_destroy(tracks);
 190         return false;
 191 }
 192
 193 void
 194 mp_menu_add_to_play_list_cancel_create_cb(void *data, Evas_Object * obj, void *event_info)
 195 {
 196         struct appdata *ad = (struct appdata *)data;
 197         MP_CHECK(ad);
 198
 199         mp_retm_if(ad->navi_effect_in_progress, "navi effect in progress");
 200
 201         Evas_Object *current_navi_bar = NULL;
 202         current_navi_bar = ad->naviframe;
 203         MP_CHECK(current_navi_bar);
 204
 205         view_data_t *view_data = evas_object_data_get(current_navi_bar, "view_data");
 206         mp_view_manager_pop_view_content(view_data, FALSE, TRUE);
 207         return;
 208 }
 209
 210 void
 211 mp_menu_add_to_play_list_done_create_cb(void *data, Evas_Object * obj, void *event_info)
 212 {
 213         DEBUG_TRACE_FUNC();
 214         struct appdata *ad = (struct appdata *)data;
 215         MP_CHECK(ad);
 216
 217         mp_retm_if(ad->navi_effect_in_progress, "navi effect in progress");
 218
 219         Evas_Object *current_navi_bar = NULL;
 220         current_navi_bar = ad->naviframe;
 221         MP_CHECK(current_navi_bar);
 222
 223         int plst_uid = -1;
 224
 225         char *converted_name = NULL;
 226         Evas_Object *entry = mp_widget_editfield_entry_get(ad->editfiled_new_playlist);
 227         const char *name = elm_entry_entry_get(entry);
 228
 229         if (name == NULL || strlen(name) == 0)
 230         {
 231                 name = elm_object_part_text_get(ad->editfiled_new_playlist, "elm.guidetext");
 232         }
 233         converted_name = elm_entry_markup_to_utf8(name);
 234
 235         plst_uid = mp_util_create_playlist(ad, converted_name, NULL);
 236         IF_FREE(converted_name);
 237         if (plst_uid < 0)
 238                 return;
 239
 240         view_data_t *view_data = evas_object_data_get(current_navi_bar, "view_data");
 241         mp_view_manager_pop_view_content(view_data, FALSE, TRUE);
 242
 243         if (view_data->view_type == MP_VIEW_TYPE_PLAYLIST)
 244                 mp_view_manager_update_list_contents(view_data, FALSE);
 245
 246         mp_layout_data_t *layout_data = ad->layout_data;
 247         mp_list_category_t category = MP_LAYOUT_TRACK_LIST;
 248
 249         if (layout_data)
 250         {
 251                 MP_CHECK_LAYOUT_DATA(layout_data);
 252                 category = layout_data->category;
 253         }
 254
 255         bool result = false;
 256
 257         if (category == MP_LAYOUT_TRACK_LIST)
 258         {
 259                 result = mp_util_add_to_playlist_by_key(plst_uid, ad->fid);
 260         }
 261         else if (category == MP_LAYOUT_GROUP_LIST)
 262         {
 263                 MP_CHECK(ad->group_item_handler);
 264
 265                 result = _mp_menu_func_by_group_handle(plst_uid, layout_data,
 266                                                        ad->group_item_handler, MP_MENU_FUNC_ADD_TO_LIST);
 267         }
 268
 269         if (result)
 270         {
 271                 mp_debug("sucess add to play list");
 272                 mp_util_create_notify(ad, GET_STR("IDS_MUSIC_POP_ADDED"));
 273         }
 274         else
 275         {
 276                 mp_debug("fail add to play list");
 277 #ifdef MP_PLAYLIST_MAX_ITEM_COUNT
 278                 char *fmt_str = GET_STR("IDS_MUSIC_POP_UNABLE_TO_ADD_MORE_THAN_PD_MUSIC_FILE");
 279                 char *noti_str = g_strdup_printf(fmt_str, MP_PLAYLIST_MAX_ITEM_COUNT);
 280                 mp_util_create_notify(ad, noti_str);
 281                 IF_FREE(noti_str);
 282 #else
 283                 mp_util_create_notify(ad, GET_STR("IDS_MUSIC_POP_UNABLE_TO_ADD"));
 284 #endif
 285         }
 286
 287         return;
 288 }
 289
 290 static void
 291 _mp_menu_add_playlist_create_select_cb(void *data, Evas_Object * obj, void *event_info)
 292 {
 293         startfunc;
 294
 295         struct appdata *ad = (struct appdata *)data;
 296         Evas_Object *current_navi_bar = NULL;
 297         view_data_t *view_data = NULL;
 298         char *new_playlist_name = NULL;
 299
 300         MP_CHECK(ad);
 301         MP_CHECK(ad->library);
 302
 303         current_navi_bar = ad->naviframe;
 304
 305         view_data = evas_object_data_get(current_navi_bar, "view_data");
 306
 307         new_playlist_name = mp_util_get_new_playlist_name();
 308         Evas_Object *create_plst_layout = mp_common_create_editfield_layout(current_navi_bar, ad, new_playlist_name);
 309         IF_FREE(new_playlist_name);
 310         mp_retm_if(create_plst_layout == NULL, "create_plst_layout is NULL");
 311
 312         mp_view_manager_push_view_content(view_data, create_plst_layout, MP_VIEW_CONTENT_NEW_PLAYLIST_BY_SWEEP);
 313
 314         evas_object_show(create_plst_layout);
 315
 316         ad->layout_data = evas_object_data_get(obj, "layout_data");
 317         mp_layout_data_t *layout_data = ad->layout_data;
 318
 319         if (layout_data->category == MP_LAYOUT_TRACK_LIST)
 320         {
 321                 IF_FREE(ad->fid);
 322                 ad->fid = (char *)evas_object_data_get(obj, MP_MENU_FID);
 323         }
 324         else if (layout_data->category == MP_LAYOUT_GROUP_LIST)
 325         {
 326                 ad->group_item_handler = evas_object_data_get(obj, MP_MENU_GROUP_ITEM_HANDLER);
 327         }
 328
 329         if (layout_data->genlist)
 330                 mp_util_reset_genlist_mode_item(layout_data->genlist);
 331
 332         mp_popup_destroy(layout_data->ad);
 333
 334         endfunc;
 335 }
 336
 337
 338 static void
 339 _mp_menu_add_playlist_select_cb(void *data, Evas_Object * obj, void *event_info)
 340 {
 341         DEBUG_TRACE_FUNC();
 342         struct appdata *ad = NULL;
 343         int ret = 0;
 344         int playlist_id = -1;
 345
 346         mp_media_info_h item_handler = data;
 347
 348         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 349         mp_list_category_t category = MP_LAYOUT_TRACK_LIST;
 350
 351         if (layout_data)
 352         {
 353                 MP_CHECK_LAYOUT_DATA(layout_data);
 354                 ad = layout_data->ad;
 355                 category = layout_data->category;
 356
 357         }
 358         else
 359         {
 360                 ad = evas_object_data_get(obj, "ad");
 361         }
 362         MP_CHECK(ad);
 363
 364         char *playlist_name = NULL;
 365         int item_count = 0;
 366         ret = mp_media_info_group_get_main_info(item_handler, &playlist_name);
 367         ret = mp_media_info_group_get_playlist_id(item_handler, &playlist_id);
 368
 369         mp_media_info_list_count(MP_TRACK_BY_PLAYLIST, NULL, NULL, NULL, playlist_id, &item_count);
 370
 371 #ifdef MP_PLAYLIST_MAX_ITEM_COUNT
 372         if (item_count > MP_PLAYLIST_MAX_ITEM_COUNT)
 373         {
 374                 char *fmt_str = GET_STR("IDS_MUSIC_POP_UNABLE_TO_ADD_MORE_THAN_PD_MUSIC_FILE");
 375                 char *noti_str = g_strdup_printf(fmt_str, MP_PLAYLIST_MAX_ITEM_COUNT);
 376                 mp_widget_text_popup(ad, noti_str);
 377                 IF_FREE(noti_str);
 378                 goto END;
 379         }
 380 #endif
 381
 382         mp_retm_if(ret != 0, "Fail to get value");
 383
 384         bool result = false;
 385
 386         if (category == MP_LAYOUT_TRACK_LIST)
 387         {
 388                 char *fid = (char *)evas_object_data_get(obj, MP_MENU_FID);
 389                 result = mp_util_add_to_playlist_by_key(playlist_id, fid);
 390                 IF_FREE(fid);
 391         }
 392         else if (category == MP_LAYOUT_GROUP_LIST)
 393         {
 394                 mp_media_info_h group_item_handler = evas_object_data_get(obj, MP_MENU_GROUP_ITEM_HANDLER);
 395
 396                 MP_CHECK(group_item_handler);
 397
 398                 result = _mp_menu_func_by_group_handle(playlist_id, layout_data,
 399                                                        group_item_handler, MP_MENU_FUNC_ADD_TO_LIST);
 400         }
 401
 402         if (result)
 403         {
 404                 mp_debug("sucess add to play list");
 405
 406                 if (playlist_name)
 407                 {
 408                         mp_util_create_notify(ad, GET_STR("IDS_MUSIC_POP_ADDED"));
 409                 }
 410         }
 411         else
 412         {
 413                 mp_debug("fail add to play list");
 414 #ifdef MP_PLAYLIST_MAX_ITEM_COUNT
 415                 char *fmt_str = GET_STR("IDS_MUSIC_POP_UNABLE_TO_ADD_MORE_THAN_PD_MUSIC_FILE");
 416                 char *noti_str = g_strdup_printf(fmt_str, MP_PLAYLIST_MAX_ITEM_COUNT);
 417                 mp_util_create_notify(ad, noti_str);
 418                 IF_FREE(noti_str);
 419 #else
 420                 mp_util_create_notify(ad, GET_STR("IDS_MUSIC_POP_UNABLE_TO_ADD"));
 421 #endif
 422         }
 423
 424 #ifdef MP_PLAYLIST_MAX_ITEM_COUNT
 425       END:
 426 #endif
 427
 428         mp_media_list_h list = evas_object_data_get(obj, MP_MENU_POPUP_PLAY_LIST_HANDLER);
 429         mp_media_info_group_list_destroy(list);
 430
 431         mp_popup_destroy(ad);
 432         return;
 433
 434 }
 435
 436 static void
 437 _mp_menu_excute_delete_cb(void *data, Evas_Object * obj, void *event_info)
 438 {
 439         DEBUG_TRACE_FUNC();
 440
 441         mp_media_info_h handle = data;
 442         MP_CHECK(handle);
 443
 444         struct appdata *ad = NULL;
 445         char *fid = NULL;
 446         int ret = 0;
 447
 448         Evas_Object *popup = obj;
 449         mp_layout_data_t *layout_data = evas_object_data_get(popup, "layout_data");
 450         MP_CHECK(layout_data);
 451         MP_CHECK_LAYOUT_DATA(layout_data);
 452         ad = layout_data->ad;
 453         ad->popup_delete = NULL;
 454
 455         mp_evas_object_del(popup);
 456         int response = (int)event_info;
 457
 458         if (response == MP_POPUP_YES)
 459         {
 460                 bool result = TRUE;
 461
 462                 if (layout_data->category == MP_LAYOUT_TRACK_LIST)
 463                 {
 464                         if (layout_data->track_type == MP_TRACK_BY_PLAYLIST)
 465                         {
 466                                 int member_id = 0;
 467                                 ret = mp_media_info_get_playlist_member_id(handle, &member_id);
 468                                 mp_media_info_playlist_remove_media(layout_data->playlist_handle, member_id);
 469                         }
 470                         else if (layout_data->track_type == MP_TRACK_BY_ADDED_TIME)
 471                         {
 472                                 ret = mp_media_info_set_added_time(handle, 0);
 473                         }
 474                         else if (layout_data->track_type == MP_TRACK_BY_FAVORITE)
 475                         {
 476                                 ret = mp_media_info_set_favorite(handle, false);
 477                         }
 478                         else if (layout_data->track_type == MP_TRACK_BY_PLAYED_TIME)
 479                         {
 480                                 ret = mp_media_info_set_played_time(handle, 0);
 481                         }
 482                         else if (layout_data->track_type == MP_TRACK_BY_PLAYED_COUNT)
 483                         {
 484                                 ret = mp_media_info_set_played_count(handle, 0);
 485                         }
 486                         else
 487                         {
 488                                 fid = mp_util_get_fid_by_handle(layout_data, handle);
 489                                 if (MP_FILE_DELETE_ERR_NONE != mp_util_delete_track(ad, fid, NULL, FALSE))
 490                                         ret = -1;
 491                         }
 492                         if (ret != 0)
 493                                 result = false;
 494                         else
 495                                 result = true;
 496                 }
 497                 else if (layout_data->category == MP_LAYOUT_GROUP_LIST)
 498                 {
 499                         result = _mp_menu_func_by_group_handle(0, layout_data, handle, MP_MENU_FUNC_DELETE);
 500                 }
 501                 else if (layout_data->category == MP_LAYOUT_PLAYLIST_LIST)
 502                 {
 503                         int plst_id = 0;
 504                         ret = mp_media_info_group_get_playlist_id(handle, &plst_id);
 505                         mp_retm_if(ret != 0, "Fail to get value");
 506
 507                         ret = mp_media_info_playlist_delete_from_db(plst_id);
 508                         mp_retm_if(ret != 0, "Fail to delete playlist");
 509                 }
 510
 511                 if (result)
 512                 {
 513                         Elm_Object_Item *it =
 514                                 (Elm_Object_Item *)elm_genlist_decorated_item_get((const Evas_Object *)layout_data->genlist);
 515                         if(it)
 516                         {
 517                                 layout_data->item_count--;
 518
 519                                 /* update last view when change album track view or artist track view */
 520                                 if (MP_TRACK_BY_ALBUM == layout_data->track_type
 521                                     || MP_TRACK_BY_ARTIST == layout_data->track_type) {
 522                                             layout_data->album_delete_flag = TRUE;
 523                                             mp_view_manager_update_list_contents(layout_data->view_data, FALSE);
 524                                             layout_data->album_delete_flag = FALSE;
 525                                 }
 526
 527                                 //update view in case there is no content. otherwise juse call elm_object_item_del()
 528                                 if(layout_data->item_count<1)
 529                                         mp_view_layout_update(layout_data->layout);
 530                                 else
 531                                 {
 532                                         if (MP_TRACK_BY_ARTIST == layout_data->track_type) {
 533                                                 if(!elm_genlist_item_parent_get(elm_genlist_item_next_get(it))
 534                                                         && !elm_genlist_item_parent_get(elm_genlist_item_prev_get(it)))
 535                                                 {
 536                                                         elm_object_item_del(elm_genlist_item_parent_get(it));
 537                                                 }
 538                                                 else
 539                                                 {
 540                                                         elm_genlist_item_update(elm_genlist_item_parent_get(it));
 541                                                 }
 542                                         } else if (MP_TRACK_BY_ALBUM == layout_data->track_type) {
 543                                                 /* update group title */
 544                                                 elm_genlist_item_update(layout_data->album_group);
 545                                         }
 546
 547                                         elm_object_item_del(it);
 548                                         layout_data->is_item_del = true;
 549
 550                                 }
 551                         }
 552                         MP_CHECK(layout_data->view_data);
 553                         mp_util_create_notify(layout_data->ad, GET_SYS_STR("IDS_COM_POP_DELETED"));
 554                 }
 555                 else
 556                         mp_widget_text_popup(ad, GET_STR("IDS_MUSIC_POP_UNABLE_TO_DELETE_SELECTED_MUSIC_IS_PLAYING"));
 557
 558         }
 559 }
 560
 561 #endif
 562
 563 int
 564 _mp_menu_set_isf_entry(mp_layout_data_t * layout_data)
 565 {
 566
 567         char *init_str = NULL;
 568
 569         init_str = elm_entry_utf8_to_markup(layout_data->old_name);
 570
 571
 572         if (init_str)
 573         {
 574                 elm_entry_entry_set(layout_data->isf_entry, init_str);
 575                 g_free(init_str);
 576                 init_str = NULL;
 577         }
 578         else
 579         {
 580                 DEBUG_TRACE("+++++++ the init str for entry is empty!");
 581                 elm_entry_entry_set(layout_data->isf_entry, "");
 582         }
 583         return 0;
 584 }
 585
 586 void
 587 mp_menu_share_list_select_cb(void *data, Evas_Object * obj, void *event_info)
 588 {
 589         mp_layout_data_t *layout_data = (mp_layout_data_t *) data;
 590
 591         MP_CHECK(layout_data);
 592         MP_CHECK_LAYOUT_DATA(layout_data);
 593
 594         const char *label = elm_object_item_data_get((Elm_Object_Item *) event_info);
 595
 596         if (label)
 597         {
 598                 GString *path = NULL;
 599                 char *path_name = NULL;
 600                 char *fmt = NULL;
 601
 602                 if (g_strcmp0(label, BLUETOOTH_SYS) == 0 || g_strcmp0(label, NFC_SYS) == 0)
 603                         fmt = "?%s";
 604                 else if ( !g_strcmp0(label, EMAIL_SYS) ||!g_strcmp0(label, MESSAGE_SYS))
 605                         fmt = "\n%s";
 606 #ifdef MP_FEATURE_WIFI_SHARE
 607                 else if (g_strcmp0(label, WIFI_SYS) == 0)
 608                         fmt = "|%s";
 609 #endif
 610                 else
 611                 {
 612                         ERROR_TRACE("not available");
 613                         return;
 614                 }
 615
 616                 mp_retm_if(layout_data->genlist == NULL, "genlist is NULL");
 617
 618                 Elm_Object_Item *first_item = elm_genlist_first_item_get(layout_data->genlist);
 619                 MP_CHECK(first_item);
 620
 621                 Elm_Object_Item *current_item = NULL;
 622                 Elm_Object_Item *next_item = NULL;
 623                 mp_genlist_item_data_t *gl_item = NULL;
 624                 int i = 0;
 625
 626                 if (layout_data->checked_count < 1)
 627                 {
 628                         ERROR_TRACE("There is no seleted Item");
 629                         return;
 630                 }
 631
 632                 MP_GENLIST_CHECK_FOREACH_SAFE(first_item, current_item, next_item, gl_item)
 633                 {
 634                         if(elm_genlist_item_select_mode_get(current_item) == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY)
 635                                 continue;
 636
 637                         if (gl_item->checked)
 638                         {
 639                                 mp_media_info_h item = (gl_item->handle);
 640                                 MP_CHECK(item);
 641
 642                                 if (item)
 643                                 {
 644
 645                                         int ret = 0;
 646                                         ret = mp_media_info_get_file_path(item, &path_name);
 647                                         if (ret != 0)
 648                                         {
 649                                                 DEBUG_TRACE("Fail to get file path... ");
 650                                                 continue;
 651                                         }
 652
 653                                         if (path_name)
 654                                         {
 655                                                 if (path == NULL)
 656                                                 {
 657                                                         path = g_string_new(path_name);
 658                                                 }
 659                                                 else
 660                                                 {
 661                                                         g_string_append_printf(path, fmt, path_name);
 662                                                 }
 663                                         }
 664                                         else
 665                                         {
 666                                                 ERROR_TRACE("path name is NULL");
 667                                                 continue;
 668                                         }
 669
 670
 671                                 }
 672                                 else
 673                                 {
 674                                         ERROR_TRACE("item_data is NULL");
 675                                         return;
 676                                 }
 677                                 i++;
 678                         }
 679                 }
 680
 681                 if (path && path->str)
 682                 {
 683                         DEBUG_TRACE("path is [%s]", path->str);
 684
 685                         if (g_strcmp0(label, EMAIL_SYS) == 0)
 686                                         mp_ug_email_attatch_file(path->str, layout_data->ad);
 687                         else if(g_strcmp0(label, MESSAGE_SYS) == 0)
 688                                         mp_ug_message_attatch_file(path->str, layout_data->ad);
 689                         else if(g_strcmp0(label, BLUETOOTH_SYS) == 0)
 690                                 mp_ug_bt_attatch_file(path->str, i, layout_data->ad);
 691 #ifdef MP_FEATURE_WIFI_SHARE
 692                         else if(g_strcmp0(label, WIFI_SYS) == 0)
 693                                 mp_ug_wifi_attatch_file(path->str, i, layout_data->ad);
 694 #endif
 695                         g_string_free(path, TRUE);
 696                 }
 697                 else
 698                 {
 699                         ERROR_TRACE("path is NULL");
 700                 }
 701         }
 702
 703         mp_popup_destroy(layout_data->ad);
 704 }
 705
 706 void
 707 mp_menu_share_select_cb(void *data, Evas_Object * obj, void *event_info)
 708 {
 709         char *path = NULL;      //do not free
 710         struct appdata *ad = NULL;
 711         music_list_item *item = NULL;
 712
 713         const char *label = elm_object_item_data_get((Elm_Object_Item *) event_info);
 714         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 715
 716         if (layout_data)
 717         {
 718                 MP_CHECK_LAYOUT_DATA(layout_data);
 719                 mp_media_info_h handle = NULL;
 720                 handle = data;
 721                 ad = layout_data->ad;
 722                 path = mp_util_get_path_by_handle(layout_data, handle);
 723                 MP_CHECK(path);
 724
 725                 mp_debug("path =%s", path);
 726         }
 727         else
 728         {
 729                 ad = data;
 730                 MP_CHECK(ad);
 731
 732                 item = mp_play_list_get_current_item(ad->playing_list);
 733                 MP_CHECK(item);
 734
 735                 path = item->filename;
 736         }
 737
 738         if (label)
 739         {
 740                 DEBUG_TRACE("%s selected", label);
 741
 742                 if (g_strcmp0(label, BLUETOOTH_SYS) == 0)
 743                 {
 744                         mp_ug_bt_attatch_file(path, 1, ad);
 745                 }
 746                 else if (g_strcmp0(label, EMAIL_SYS) == 0)
 747                 {
 748                         mp_ug_email_attatch_file(path, ad);
 749                 }
 750                 else if (g_strcmp0(label, MESSAGE_SYS) == 0)
 751                         mp_ug_message_attatch_file(path, ad);
 752 #ifdef MP_FEATURE_WIFI_SHARE
 753                 else if (g_strcmp0(label, WIFI_SYS) == 0)
 754                         mp_ug_wifi_attatch_file(path, 1, ad);
 755 #endif
 756         }
 757
 758         mp_popup_destroy(ad);
 759 }
 760
 761 static int
 762 _mp_menu_set_caller_rington(char *path)
 763 {
 764         int ret = -1;
 765         bool is_drm = FALSE;
 766         char *prev_ring_tone_path = NULL;
 767
 768         //drm check..
 769         prev_ring_tone_path = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
 770         if (prev_ring_tone_path && mp_drm_file_right(prev_ring_tone_path))
 771         {
 772                 mp_drm_request_setas_ringtone(prev_ring_tone_path, SETAS_REQUEST_UNREGISTER);
 773                 free(prev_ring_tone_path);
 774         }
 775
 776         if (mp_drm_file_right(path))
 777         {
 778                 if (!mp_drm_request_setas_ringtone(path, SETAS_REQUEST_CHECK_STATUS))
 779                         return -1;
 780                 is_drm = true;
 781         }
 782
 783         ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, path);
 784
 785         if (is_drm)
 786                 mp_drm_request_setas_ringtone(path, SETAS_REQUEST_REGISTER);
 787
 788         return ret;
 789
 790 }
 791
 792 void
 793 mp_menu_set_as_select_cb(void *data, Evas_Object * obj, void *event_info)
 794 {
 795         int ret = 0;
 796         char *path = NULL;      //do not free
 797         struct appdata *ad = NULL;
 798         music_list_item *item = NULL;
 799
 800         const char *label = elm_object_item_data_get((Elm_Object_Item *) event_info);
 801         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 802
 803         if (layout_data)
 804         {
 805                 MP_CHECK_LAYOUT_DATA(layout_data);
 806                 mp_media_info_h handle = NULL;
 807                 handle = data;
 808                 ad = layout_data->ad;
 809                 path = mp_util_get_path_by_handle(layout_data, handle);
 810         }
 811         else
 812         {
 813                 ad = data;
 814                 MP_CHECK(ad);
 815
 816                 item = mp_play_list_get_current_item(ad->playing_list);
 817                 MP_CHECK(item);
 818
 819                 path = item->filename;
 820         }
 821
 822         if (label)
 823         {
 824                 DEBUG_TRACE("%s selected", label);
 825                 if (g_strcmp0(label, GET_STR(CALLER_RINGTONE)) == 0)
 826                 {
 827                         mp_ug_contact_user_sel(path, ad);
 828                 }
 829                 else if (g_strcmp0(label, GET_STR(CALL_RINGTONE)) == 0)
 830                 {
 831                         char *popup_txt = NULL;
 832
 833                         DEBUG_TRACE("path =%s", path);
 834
 835                         ret = _mp_menu_set_caller_rington(path);
 836
 837                         if (!ret)
 838                                 popup_txt = GET_STR("IDS_MUSIC_POP_SET_AS_CALLER_RINGTONE");
 839                         else
 840                                 popup_txt = GET_STR("IDS_MUSIC_POP_UNABLE_TO_SET_AS_RINGTONE");
 841
 842                         mp_widget_text_popup(ad, popup_txt);
 843
 844                 }
 845         }
 846
 847         mp_popup_destroy(ad);
 848
 849         return;
 850 }
 851
 852 void
 853 mp_menu_share_cb(void *data, Evas_Object * obj, void *event_info)
 854 {
 855         DEBUG_TRACE("");
 856
 857         if (data == NULL)
 858                 return;
 859         struct appdata *ad = NULL;
 860
 861         Evas_Object *share_popup = NULL;
 862         Evas_Object *genlist = NULL;
 863
 864         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 865
 866         char *file_name = NULL;
 867
 868         if (layout_data)
 869         {
 870                 MP_CHECK_LAYOUT_DATA(layout_data);
 871                 mp_retm_if(layout_data->ad->navi_effect_in_progress, "navi effect in progress");
 872                 ad = layout_data->ad;
 873
 874                 mp_media_info_h handle = NULL;
 875                 handle = data;
 876                 ad = layout_data->ad;
 877                 file_name = mp_util_get_path_by_handle(layout_data, handle);
 878
 879                 if (mp_drm_check_foward_lock(file_name))
 880                 {
 881                         mp_widget_text_popup(ad, GET_STR("IDS_MUSIC_POP_UNABLE_TO_SHARE_DRM_FILE"));
 882                         return;
 883                 }
 884
 885                 share_popup = mp_genlist_popup_create(ad->win_main, MP_POPUP_PV_SHARE, data, ad);
 886                 MP_CHECK(share_popup);
 887                 genlist = evas_object_data_get(share_popup, "genlist");
 888                 evas_object_data_set(genlist, "layout_data", layout_data);
 889
 890         }
 891         else
 892         {
 893                 ad = data;
 894                 mp_retm_if(ad->navi_effect_in_progress, "navi effect in progress");
 895                 music_list_item *item = mp_play_list_get_current_item(ad->playing_list);
 896
 897                 MP_CHECK(item);
 898
 899                 mp_debug("excuete by list view %s", item->filename);
 900
 901                 if (mp_drm_check_foward_lock(item->filename))
 902                 {
 903                         mp_widget_text_popup(ad, GET_STR("IDS_MUSIC_POP_UNABLE_TO_SHARE_DRM_FILE"));
 904                         return;
 905                 }
 906
 907                 share_popup = mp_genlist_popup_create(ad->win_main, MP_POPUP_PV_SHARE, data, ad);
 908                 MP_CHECK(share_popup);
 909                 genlist = evas_object_data_get(share_popup, "genlist");
 910         }
 911
 912         return;
 913
 914 }
 915
 916 void
 917 mp_menu_set_cb(void *data, Evas_Object * obj, void *event_info)
 918 {
 919         DEBUG_TRACE("");
 920
 921         if (data == NULL)
 922                 return;
 923         struct appdata *ad = NULL;
 924
 925         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 926
 927         if (layout_data)
 928         {
 929                 MP_CHECK_LAYOUT_DATA(layout_data);
 930                 ad = layout_data->ad;
 931         }
 932         else
 933                 ad = data;
 934
 935         mp_retm_if(ad->navi_effect_in_progress, "navi effect in progress");
 936
 937         Evas_Object *popup;
 938
 939         if (layout_data)
 940                 popup = mp_genlist_popup_create(ad->win_main, MP_POPUP_PV_SET_AS, data, ad);
 941         else
 942                 popup = mp_genlist_popup_create(ad->win_main, MP_POPUP_PV_SET_AS_INCLUDE_ADD_TO_HOME, data, ad);
 943
 944         if (layout_data)
 945         {
 946                 Evas_Object *genlist = evas_object_data_get(popup, "genlist");
 947                 evas_object_data_set(genlist, "layout_data", layout_data);
 948         }
 949
 950         return;
 951
 952 }
 953
 954 #ifndef MP_SOUND_PLAYER
 955 void
 956 mp_menu_delete_cb(void *data, Evas_Object * obj, void *event_info)
 957 {
 958         DEBUG_TRACE_FUNC();
 959
 960         struct appdata *ad = NULL;
 961         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 962
 963
 964         MP_CHECK(layout_data);
 965         MP_CHECK_LAYOUT_DATA(layout_data);
 966         mp_media_info_h handle = NULL;
 967         handle = data;
 968
 969         ad = layout_data->ad;
 970
 971         Evas_Object *popup = mp_popup_create(ad->win_main, MP_POPUP_NORMAL, NULL, handle, _mp_menu_excute_delete_cb, ad);
 972         ad->popup_delete = popup;
 973         evas_object_data_set(popup, "layout_data", layout_data);
 974
 975         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 976
 977         elm_object_text_set(popup, GET_SYS_STR("IDS_COM_POP_DELETE_Q"));
 978
 979         mp_popup_button_set(popup, MP_POPUP_BTN_1, GET_SYS_STR("IDS_COM_BODY_DELETE"), MP_POPUP_YES);
 980         mp_popup_button_set(popup, MP_POPUP_BTN_2, GET_SYS_STR("IDS_COM_SK_CANCEL"), MP_POPUP_NO);
 981
 982         evas_object_show(popup);
 983 }
 984
 985
 986 void
 987 mp_menu_add_to_playlist_cb(void *data, Evas_Object * obj, void *event_info)
 988 {
 989         DEBUG_TRACE_FUNC();
 990
 991         int ret = 0;
 992
 993         mp_layout_data_t *layout_data = evas_object_data_get(obj, "layout_data");
 994         music_list_item *item = NULL;
 995
 996         char *fid = NULL;
 997
 998         struct appdata *ad = NULL;
 999
1000         mp_media_info_h handle = NULL;
1001
1002         Evas_Object *popup = NULL;
1003
1004         if (layout_data)
1005         {
1006                 MP_CHECK_LAYOUT_DATA(layout_data);
1007                 ad = layout_data->ad;
1008         }
1009         else
1010                 ad = data;
1011
1012         MP_CHECK_EXCEP(ad);
1013
1014         popup = mp_genlist_popup_create(ad->win_main, MP_POPUP_ADD_TO_PLST, ad, ad);
1015         MP_CHECK(popup);
1016
1017         Evas_Object *genlist = evas_object_data_get(popup, "genlist");
1018         MP_CHECK(genlist);
1019
1020         if (layout_data)
1021         {
1022                 evas_object_data_set(genlist, "layout_data", layout_data);
1023
1024                 handle = data;
1025
1026                 if (layout_data->category == MP_LAYOUT_TRACK_LIST)
1027                 {
1028                         fid = g_strdup(mp_util_get_fid_by_handle(layout_data, handle));
1029                         evas_object_data_set(genlist, MP_MENU_FID, (void *)fid);        //set request fid
1030                 }
1031                 else
1032                 {
1033                         evas_object_data_set(genlist, MP_MENU_GROUP_ITEM_HANDLER, handle);      //set group item handler
1034                 }
1035                 evas_object_data_set(genlist, "layout_data", layout_data);
1036         }
1037         else
1038         {
1039                 item = mp_play_list_get_current_item(ad->playing_list);
1040                 MP_CHECK_EXCEP(item);
1041                 fid = g_strdup(item->key_id);
1042                 evas_object_data_set(genlist, MP_MENU_FID, (void *)fid);        //set request fid
1043                 evas_object_data_set(genlist, "ad", ad);
1044         }
1045
1046         int i = 0, count = -1, err = -1;
1047
1048         mp_genlist_popup_item_append(popup, GET_STR("IDS_MUSIC_OPT_CREATE_PLAYLIST"), NULL,
1049                                      _mp_menu_add_playlist_create_select_cb, ad);
1050
1051         err = mp_media_info_group_list_count(MP_GROUP_BY_PLAYLIST, NULL, NULL, &count);
1052
1053         if ((err != 0) || (count < 0))
1054         {
1055                 ERROR_TRACE("Error in mp_media_info_group_list_count (%d)\n", err);
1056                 return;
1057         }
1058
1059         if (count)
1060         {
1061                 mp_media_list_h playlists = NULL;       //must be free
1062
1063                 ret = mp_media_info_group_list_create(&playlists, MP_GROUP_BY_PLAYLIST, NULL, NULL, 0, count);
1064                 mp_retm_if(ret != 0, "Fail to get playlist");
1065                 evas_object_data_set(popup, MP_MENU_POPUP_PLAY_LIST_HANDLER, (void *)playlists);        //set request handle id for support group item
1066
1067                 for (i = 0; i < count; i++)
1068                 {
1069                         /* it should be released in a proper place */
1070                         mp_media_info_h plst = NULL;
1071                         char *name = NULL;
1072                         plst = mp_media_info_group_list_nth_item(playlists, i);
1073                         mp_retm_if(!plst, "Fail to get item");
1074
1075                         ret = mp_media_info_group_get_main_info(plst, &name);
1076                         mp_retm_if(ret != 0, "Fail to get value");
1077
1078                         mp_genlist_popup_item_append(popup, name, NULL, _mp_menu_add_playlist_select_cb, (void *)plst);
1079                 }
1080
1081         }
1082
1083         evas_object_show(popup);
1084
1085         return;
1086
1087       mp_exception:
1088         mp_evas_object_del(popup);
1089         return;
1090 }
1091 #endif
1092