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