src/views/playback-view.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 "define.h"
  18 #include "common.h"
  19 #include "dbg.h"
  20 #include <AppCommon.h>
  21
  22 #include "song_info.h"
  23 #include "album_info.h"
  24 #include "music-controller.h"
  25 #include "volume-control.h"
  26 #include "i18n.h"
  27 #include "common-ui.h"
  28 #include "playback-view.h"
  29 #include "context-view.h"
  30 #include "HandleVolume.h"
  31 #include "PlaySettingCtxPopup.h"
  32 #include "Info.h"
  33
  34
  35 #define TOTAL_CONTROL_BTNS 6
  36 #define TOTAL_EDIT_BTNS    3
  37 #define S_INTERVAL         1     /* seconds */
  38 #define LP_INTERVAL        0.5   /* seconds */
  39 #define WAIT_INTERVAL      0.5   /* seconds */
  40 #define SLIDER_STEP        5000  /* milli seconds */
  41 #define LP_CHANGE          10000 /* milli seconds */
  42 #define S_INCREMENT        1000  /* milli seconds */
  43
  44
  45 // SSliderWidget
  46 struct SSliderWidget {
  47         Evas_Object *eoSlider;
  48         Evas_Object *eoBase;
  49
  50         Ecore_Timer *etSlider;
  51
  52         CSongInfo *pSongInfo;
  53
  54         CMusicController controller;
  55
  56         SSliderWidget() {
  57                 eoSlider = NULL;
  58                 eoBase = NULL;
  59                 etSlider = NULL;
  60                 pSongInfo = NULL;
  61         }
  62 };
  63
  64
  65 Eina_Bool CSliderWidget::sm_CbUpdateSlider(void *dt)
  66 {
  67         CSliderWidget *root = (CSliderWidget*)dt;
  68         Eina_Bool ret = ECORE_CALLBACK_CANCEL;
  69
  70         if (root)
  71                 ret = root->m_OnUpdateSlider();
  72
  73         return ret;
  74 }
  75
  76
  77 Eina_Bool CSliderWidget::m_OnUpdateSlider(void)
  78 {
  79         char *timestr = NULL;
  80         int value;
  81         int duration;
  82
  83         if (!m->controller.GetPosition(&value)) {
  84                 m->etSlider = NULL;
  85                 return ECORE_CALLBACK_CANCEL;
  86         }
  87
  88         m_UpdateSongInfo();
  89
  90         duration = m->pSongInfo->Duration();
  91
  92         value = value + S_INCREMENT;
  93         if (value > duration) {
  94                 m->etSlider = NULL;
  95                 return ECORE_CALLBACK_CANCEL;
  96         }
  97
  98         elm_slider_value_set(m->eoSlider, value);
  99         timestr = CCommonUI::TimeStrFromMilSeconds(value);
 100         if (timestr) {
 101                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
 102                         timestr);
 103                 free(timestr);
 104         }
 105
 106         return ECORE_CALLBACK_RENEW;
 107 }
 108
 109
 110 bool CSliderWidget::m_AddSlider(void)
 111 {
 112         Evas_Object *eoSlider = NULL;
 113
 114         eoSlider = elm_slider_add(m->eoBase);
 115         if (!eoSlider)
 116                 return false;
 117
 118         elm_slider_indicator_show_set(eoSlider, EINA_FALSE);
 119         elm_slider_indicator_show_on_focus_set(eoSlider, EINA_FALSE);
 120         elm_object_style_set(eoSlider, MUSIC_STYLE_SLIDER);
 121         elm_slider_horizontal_set(eoSlider, EINA_TRUE);
 122         elm_object_part_content_set(m->eoBase, MUSIC_PART_PROGRESSBAR, eoSlider);
 123
 124         Connect(eoSlider, TYPE_CHANGED | TYPE_MOUSE_MOVE);
 125
 126         evas_object_show(eoSlider);
 127         m->eoSlider = eoSlider;
 128
 129         return true;
 130 }
 131
 132
 133 void CSliderWidget::m_RemoveTimer(void)
 134 {
 135         if (m->etSlider) {
 136                 ecore_timer_del(m->etSlider);
 137                 m->etSlider = NULL;
 138         }
 139 }
 140
 141
 142 void CSliderWidget::m_UpdateSongInfo(void)
 143 {
 144         CSongInfo *sinfo = NULL;
 145         int index;
 146
 147         if (!m->controller.GetCurrentSongIndex(&index)) {
 148                 _ERR(" music get current song index failed ");
 149                 return;
 150         }
 151
 152         if (!m->controller.GetSonginfoFromIndex(index, &sinfo)) {
 153                 _ERR(" music get songinfo failed ");
 154                 return;
 155         }
 156         m->pSongInfo = sinfo;
 157 }
 158
 159
 160 bool CSliderWidget::Create(Evas_Object *eoBase)
 161 {
 162         ASSERT(!m);
 163
 164         _CREATE_BEGIN{
 165                 _CHECK(m = new SSliderWidget)
 166                 _COMMAND{ m->eoBase = eoBase; }
 167                 _CHECK(m->controller.Create())
 168                 _CHECK(m->controller.AddListener(this))
 169                 _CHECK(m_AddSlider())
 170
 171                 _CHECK_FAIL{}
 172                 _CHECK_FAIL{ m->controller.RemoveListener(this); }
 173                 _CHECK_FAIL{ m->controller.Destroy(); }
 174                 _CHECK_FAIL{ delete m; m = NULL; }
 175         } _CREATE_END_AND_CATCH{ return false; }
 176
 177         return true;
 178 }
 179
 180
 181 void CSliderWidget::Destroy(void)
 182 {
 183         ASSERT(m);
 184
 185         m->controller.RemoveListener(this);
 186         m_RemoveTimer();
 187
 188         delete m;
 189         m = NULL;
 190 }
 191
 192
 193 Evas_Object* CSliderWidget::Base(void)
 194 {
 195         ASSERT(m);
 196
 197         return m->eoSlider;
 198 }
 199
 200
 201 void CSliderWidget::Init(void)
 202 {
 203         elm_object_disabled_set(m->eoSlider, EINA_TRUE);
 204         elm_slider_value_set(m->eoSlider, 0);
 205 }
 206
 207
 208 void CSliderWidget::OnComplete(void)
 209 {
 210 }
 211
 212
 213 void CSliderWidget::OnStartPlayback(void)
 214 {
 215         int duration;
 216         char *timestr = NULL;
 217         double step;
 218
 219         elm_slider_value_set(m->eoSlider, 0);
 220         elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
 221
 222         elm_object_disabled_set(m->eoSlider, EINA_FALSE);
 223
 224         m_UpdateSongInfo();
 225         duration = m->pSongInfo->Duration();
 226
 227         m_RemoveTimer();
 228         m->etSlider = ecore_timer_add(S_INTERVAL, sm_CbUpdateSlider, this);
 229
 230         elm_slider_min_max_set(m->eoSlider, 0, duration);
 231         timestr = CCommonUI::TimeStrFromMilSeconds(duration);
 232         if (timestr) {
 233                 elm_object_part_text_set(m->eoBase,
 234                         MUSIC_PART_FULLTIME, timestr);
 235                 free(timestr);
 236         }
 237
 238         step = (double)SLIDER_STEP / (double)duration;
 239         elm_slider_step_set(m->eoSlider, step);
 240 }
 241
 242
 243 void CSliderWidget::OnStopPlayback(void)
 244 {
 245         elm_slider_value_set(m->eoSlider, 0);
 246         elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
 247
 248         elm_object_disabled_set(m->eoSlider, EINA_TRUE);
 249         m_RemoveTimer();
 250 }
 251
 252
 253 void CSliderWidget::OnPausePlayback(void)
 254 {
 255         if (m->etSlider)
 256                 ecore_timer_freeze(m->etSlider);
 257 }
 258
 259
 260 void CSliderWidget::OnResumePlayback(void)
 261 {
 262         if (m->etSlider)
 263                 ecore_timer_thaw(m->etSlider);
 264 }
 265
 266
 267 void CSliderWidget::OnPosition(int milsec)
 268 {
 269         elm_slider_value_set(m->eoSlider, milsec);
 270 }
 271
 272
 273 void CSliderWidget::OnChanged(int id, Evas_Object *obj)
 274 {
 275         char *timestr = NULL;
 276         int value;
 277
 278         if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
 279                 if (m->etSlider)
 280                         ecore_timer_freeze(m->etSlider);
 281         }
 282
 283         value = elm_slider_value_get(obj);
 284         m->controller.SetPosition(value);
 285         timestr = CCommonUI::TimeStrFromMilSeconds(value);
 286         if (timestr) {
 287                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
 288                         timestr);
 289                 free(timestr);
 290         }
 291
 292         if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
 293                 if (m->etSlider)
 294                         ecore_timer_thaw(m->etSlider);
 295         }
 296 }
 297
 298
 299 void CSliderWidget::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
 300 {
 301         if (!elm_object_focus_get(obj))
 302                 elm_object_focus_set(obj, EINA_TRUE);
 303 }
 304
 305
 306 // STimer
 307 struct STimer {
 308         int count;
 309         int s, e;
 310         struct SCookie {
 311                 Ecore_Timer *etTimer;
 312                 CTimer *root;
 313                 int     id;
 314                 SCookie(CTimer *timer, int _id) {
 315                         root = timer;
 316                         id = _id;
 317                 }
 318         };
 319
 320         Eina_List *elList;
 321 };
 322
 323
 324 Eina_Bool CTimer::sm_CbTimer(void *data)
 325 {
 326         STimer::SCookie *cookie = (STimer::SCookie*)data;
 327
 328         if (cookie->root)
 329                 cookie->root->t_OnTimer(cookie->id);
 330
 331         cookie->root->m->elList = eina_list_remove(cookie->root->m->elList, cookie);
 332
 333         delete cookie;
 334
 335         return EINA_FALSE;
 336 }
 337
 338
 339 void CTimer::t_OnTimer(int id)
 340 {
 341 }
 342
 343
 344 bool CTimer::Create(void)
 345 {
 346         ASSERT(!m);
 347
 348         m = new STimer;
 349         if (!m)
 350                 return false;
 351
 352         m->elList = NULL;
 353
 354         return true;
 355 }
 356
 357
 358 void CTimer::Destroy(void)
 359 {
 360         ASSERT(m);
 361
 362         delete m;
 363         m = NULL;
 364 }
 365
 366
 367 bool CTimer::SetTimer(int id, int ms)
 368 {
 369         ASSERT(m);
 370
 371
 372         STimer::SCookie *cookie = new STimer::SCookie(this, id);
 373         if (!cookie)
 374                 return false;
 375
 376         m->elList = eina_list_append(m->elList, cookie);
 377         cookie->etTimer = ecore_timer_add(ms, sm_CbTimer, cookie);
 378         return true;
 379 }
 380
 381
 382 void CTimer::KillTimer(int id)
 383 {
 384         ASSERT(m);
 385 }
 386
 387
 388 // CPlaybackView
 389 enum EEvasObject {
 390         EO_BASE,
 391
 392         EO_ERROR_POPUP_BUTTON,
 393
 394         EO_CANCEL,
 395         EO_DESELECT,
 396         EO_DELETE,           // TOTAL_EDIT_BTNS
 397
 398         EO_BTN_SETTINGS,
 399         EO_BTN_SHUFFLE,
 400         EO_BTN_REPEAT,
 401         EO_BTN_REWIND,
 402         EO_BTN_PLAY,
 403         EO_BTN_FORWARD,   // TOTAL_CONTROL_BTNS
 404
 405         EO_PLAYLIST,
 406 };
 407
 408
 409 enum EControlBtns {
 410         BTN_SETTINGS,
 411         BTN_SHUFFLE,
 412         BTN_REPEAT,
 413         BTN_REWIND,
 414         BTN_PLAY,
 415         BTN_FORWARD
 416 };
 417
 418 enum ESettingBtns {
 419         BTN_EDIT,
 420         BTN_CLEAR
 421 };
 422
 423 enum EEditBtns {
 424         BTN_CANCEL,
 425         BTN_DESELECT,
 426         BTN_DELETE
 427 };
 428
 429 enum ETimers {
 430         TIMER_WAIT,
 431         TIMER_LONGPRESS,
 432         TIMER_VOLUME
 433 };
 434
 435 enum EPressTypes {
 436         PRESS_SHORT,
 437         PRESS_SHORT_PAUSE,
 438         PRESS_LONG,
 439         PRESS_LONG_PAUSE,
 440 };
 441
 442 struct SItemInfo {
 443         Elm_Object_Item *item;
 444         CSongInfo *sinfo;
 445         bool edit_mode;
 446         bool check_status;
 447         bool select_status;
 448 };
 449
 450 struct SPlaybackView {
 451         Evas_Object *eoWin;
 452
 453         Evas_Object *eoBase;
 454         CPlaySettingCtxPopup *eoCtxPopup;
 455         Evas_Object *eoErrPopup;
 456         Evas_Object *eoPlaylist;
 457
 458         Elm_Object_Item *focused_item;
 459
 460         Evas_Object *eoBtnControl[TOTAL_CONTROL_BTNS];
 461         Evas_Object *eoBtnEdit[TOTAL_EDIT_BTNS];
 462
 463         Evas_Object *eoAlbumCover;
 464         CSliderWidget *pSliderWidget;
 465         Evas_Object *eoPressedObj;
 466
 467         Eina_List   *elInfo;
 468         Ecore_Timer *etLongPress;
 469         Ecore_Timer *etWait;
 470         CMusicController *pController; //! NOT NULL
 471         CSongInfo *csinfo;
 472         CViewMgr *mgr;
 473         SItemInfo *cs_itinfo;
 474         SContentInfo *ctxtinfo;
 475         EPressTypes press_status;
 476
 477         CHandleVolume *pHandleVolume;
 478
 479         SPlaybackView() {
 480                 memset(this, 0, sizeof(SPlaybackView));
 481         }
 482 };
 483
 484 struct SBtnInfo {
 485         const char *txt;
 486         const char *part;
 487         EEvasObject type;
 488 };
 489
 490
 491 Eina_Bool CPlaybackView::sm_CbLongpressTimer(void *dt)
 492 {
 493         CPlaybackView *root = (CPlaybackView *)dt;
 494         if (root)
 495                 root->m_OnLongpressTimer();
 496
 497         return ECORE_CALLBACK_RENEW;
 498 }
 499
 500
 501 void CPlaybackView::m_OnLongpressTimer(void)
 502 {
 503         m_HandleOnRepeated();
 504 }
 505
 506
 507 Eina_Bool CPlaybackView::sm_CbWaitTimer(void *dt)
 508 {
 509         CPlaybackView *root = (CPlaybackView *)dt;
 510         if (root)
 511                 root->m_OnWaitTimer();
 512
 513         return ECORE_CALLBACK_CANCEL;
 514 }
 515
 516
 517 void CPlaybackView::m_OnWaitTimer(void)
 518 {
 519         m->press_status = PRESS_LONG;
 520         if (m->pController->PlayState() == PLAY_STATUS_PLAY) {
 521                 /* Handle long press */
 522                 m_PlaybackPause();
 523                 m->etLongPress = ecore_timer_add(LP_INTERVAL, sm_CbLongpressTimer, this);
 524         }
 525         else {
 526                 m->press_status = PRESS_LONG_PAUSE;
 527         }
 528
 529         m->etWait = NULL;
 530 }
 531
 532
 533 void CPlaybackView::sm_CbCtxtUpdate(void *dt, enum EActionType type, int lid)
 534 {
 535         CPlaybackView *root = (CPlaybackView *)dt;
 536         if (root)
 537                 root->m_OnCtxtUpdate(type, lid);
 538 }
 539
 540
 541 void CPlaybackView::m_OnCtxtUpdate(EActionType type, int lid)
 542 {
 543         SItemInfo *itinfo = NULL;
 544         Elm_Object_Item *focusedItem = NULL;
 545
 546         if (!m->ctxtinfo || !m->ctxtinfo->context)
 547                 return;
 548
 549         itinfo = m_FindItemInfoFromSong(m->elInfo,
 550                 (CSongInfo *)m->ctxtinfo->context);
 551         if (!itinfo) {
 552                 _ERR(" Unable to find song in the list ");
 553                 return;
 554         }
 555
 556         if (type == ACTION_TYPE_DELETE) {
 557                 itinfo->check_status = true;
 558                 m_DeleteSelectedItems();
 559
 560                 if (!m->mgr->PopView()) {
 561                         _ERR("CViewMgr::PopView failed");
 562                         return;
 563                 }
 564
 565                 SParcel parcel;
 566                 memset(&parcel, 0, sizeof(SParcel));
 567                 parcel.updateType = E_PLAYLIST_UPDATE;
 568                 t_OnUpdate(&parcel);
 569
 570                 focusedItem = m->cs_itinfo->item;
 571         }
 572         else { // ACTION_TYPE_PLAY
 573                 if (m->ctxtinfo->status == PLAY_STATUS_PLAY)
 574                         m_KeyPausePress();
 575                 else {
 576                         if (itinfo == m->cs_itinfo)
 577                                 m_KeyPlayPress();
 578                         else
 579                                 m_HandleGenlistItemActivated(m->eoPlaylist, itinfo->item);
 580                 }
 581
 582                 if (!m->mgr->PopView()) {
 583                         _ERR("CViewMgr::PopView failed");
 584                         return;
 585                 }
 586
 587                 focusedItem = m->focused_item;
 588         }
 589
 590         if (!CViewMgr::GetInstance()->HideView(MUSIC_BASE_VIEW))
 591                 _ERR("CViewMgr::HideView failed");
 592
 593         t_OnShow();
 594
 595         if (focusedItem) {
 596                 elm_genlist_item_show(focusedItem, ELM_GENLIST_ITEM_SCROLLTO_IN);
 597                 elm_object_item_focus_set(focusedItem, EINA_TRUE);
 598         }
 599 }
 600
 601
 602 void CPlaybackView::sm_CbCtxtClose(void *dt)
 603 {
 604         CPlaybackView *root = (CPlaybackView *)dt;
 605         if (root)
 606                 root->m_OnCtxtClose();
 607 }
 608
 609
 610 void CPlaybackView::m_OnCtxtClose(void)
 611 {
 612         if (!m->mgr->PopView()) {
 613                 _ERR("CViewMgr::PopView failed");
 614                 return;
 615         }
 616
 617         elm_object_item_focus_set(m->focused_item, EINA_TRUE);
 618 }
 619
 620
 621 void CPlaybackView::sm_CbCtxPopupBtnSelected(void* cookie, CContextPopup* instance, const char* text)
 622 {
 623         CPlaybackView *root = (CPlaybackView *)cookie;
 624         if (root)
 625                 root->m_CbCtxPopupBtnSelected(instance, text);
 626 }
 627
 628
 629 void CPlaybackView::m_CbCtxPopupBtnSelected(CContextPopup* instance, const char* text)
 630 {
 631         int type = CInfo::PlaybackSettingType();
 632
 633         switch (type) {
 634         case BTN_EDIT:
 635                 m_FromPlaybackToEditMode();
 636                 break;
 637
 638         case BTN_CLEAR:
 639                 m->pController->Stop();
 640                 m->pController->EmptyPlaylist();
 641                 eina_list_free(m->elInfo);
 642                 m->elInfo = NULL;
 643                 elm_genlist_clear(m->eoPlaylist);
 644                 m_UpdateEmptySongInfo();
 645                 break;
 646
 647         default:
 648                 break;
 649         }
 650 }
 651
 652
 653 void CPlaybackView::m_RemoveTimer(int timer_code)
 654 {
 655         ETimers timerCode = (ETimers)timer_code;
 656
 657         switch (timerCode) {
 658         case TIMER_WAIT:
 659                 if (m->etWait) {
 660                         ecore_timer_del(m->etWait);
 661                         m->etWait = NULL;
 662                 }
 663                 break;
 664
 665         case TIMER_LONGPRESS:
 666                 if (m->etLongPress) {
 667                         ecore_timer_del(m->etLongPress);
 668                         m->etLongPress = NULL;
 669                 }
 670                 break;
 671
 672         case TIMER_VOLUME:
 673                 m->pHandleVolume->RemoveTimer();
 674                 break;
 675
 676         default:
 677                 _ERR(" invalid value ");
 678                 break;
 679         }
 680 }
 681
 682
 683 void CPlaybackView::m_PlaybackPause(void)
 684 {
 685         m->pController->Pause();
 686 }
 687
 688
 689 void CPlaybackView::m_PlaybackResume(void)
 690 {
 691         m->pController->Resume();
 692 }
 693
 694
 695 void CPlaybackView::m_ChangeEditmodeAll(Eina_List *list, bool flag)
 696 {
 697         SItemInfo *itinfo = NULL;
 698         void *obj = NULL;
 699         Eina_List *l = NULL;
 700
 701         EINA_LIST_FOREACH(list, l, obj) {
 702                 itinfo = (SItemInfo *)obj;
 703                 itinfo->edit_mode = flag;
 704         }
 705 }
 706
 707
 708 void CPlaybackView::m_DisableCheckAll(Eina_List *list)
 709 {
 710         SItemInfo *itinfo = NULL;
 711         void *obj = NULL;
 712         Eina_List *l = NULL;
 713
 714         EINA_LIST_FOREACH(list, l, obj) {
 715                 itinfo = (SItemInfo *)obj;
 716                 itinfo->check_status = false;
 717         }
 718 }
 719
 720
 721 void CPlaybackView::m_SelectItem(SItemInfo *pItemInfo)
 722 {
 723         if (!pItemInfo || !pItemInfo->item)
 724                 return;
 725
 726         elm_genlist_item_bring_in(pItemInfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
 727         elm_object_item_signal_emit(pItemInfo->item, MUSIC_SIGNAL_SELECT_ITEM, MUSIC_PLAYBACK_VIEW);
 728
 729         pItemInfo->select_status = true;
 730 }
 731
 732
 733 void CPlaybackView::m_UnselectItem(SItemInfo *pItemInfo)
 734 {
 735         if (!pItemInfo || !pItemInfo->item)
 736                 return;
 737
 738         elm_object_item_signal_emit(pItemInfo->item, MUSIC_SIGNAL_UNSELECT_ITEM,
 739                 MUSIC_PLAYBACK_VIEW);
 740
 741         pItemInfo->select_status = false;
 742 }
 743
 744
 745 void CPlaybackView::m_UpdateControlBtns(void)
 746 {
 747         int state;
 748
 749         state = m->pController->PlayState();
 750         switch (state) {
 751         case PLAY_STATUS_INITIAL:
 752                 // Initial State, Do nothing
 753                 break;
 754
 755         case PLAY_STATUS_STOP:
 756                 if (!m->eoErrPopup)
 757                         elm_object_focus_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
 758                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_TRUE);
 759                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_TRUE);
 760                 break;
 761
 762         case PLAY_STATUS_PLAY:
 763                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
 764                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
 765                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
 766                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 767                 break;
 768
 769         case PLAY_STATUS_PAUSE:
 770                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
 771                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
 772                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
 773                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 774                 break;
 775
 776         default:
 777                 ASSERT(!"Invalid State");
 778                 break;
 779         }
 780
 781         state = m->pController->ShuffleState();
 782         switch (state) {
 783         case SHUFFLE_STATUS_OFF:
 784                 elm_object_signal_emit(m->eoBtnControl[BTN_SHUFFLE],
 785                         MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
 786                 break;
 787
 788         case SHUFFLE_STATUS_ON:
 789                 elm_object_signal_emit(m->eoBtnControl[BTN_SHUFFLE],
 790                         MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
 791                 break;
 792
 793         default:
 794                 ASSERT(!"Invalid State");
 795                 break;
 796         }
 797
 798         state = m->pController->RepeatState();
 799         switch (state) {
 800         case REPEAT_STATUS_NONE:
 801                 elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT],
 802                         MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
 803                 break;
 804
 805         case REPEAT_STATUS_ALL:
 806                 elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT],
 807                         MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
 808                 break;
 809
 810         case REPEAT_STATUS_ONE:
 811                 elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT],
 812                         MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
 813                 break;
 814
 815         default:
 816                 ASSERT(!"Invalid State");
 817                 break;
 818         }
 819 }
 820
 821
 822 void CPlaybackView::m_UpdateCurrentSongThumbnail(void)
 823 {
 824         char *path = NULL;
 825         char buf[MAX_LENGTH];
 826
 827         if (!m->cs_itinfo || !m->cs_itinfo->sinfo)
 828                 return;
 829
 830         path = m->cs_itinfo->sinfo->ThumbnailPath();
 831         if (path)
 832                 elm_image_file_set(m->eoAlbumCover, path, NULL);
 833         else {
 834                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 835                         MUSIC_IMAGE_DEFAULT_THUMB_450);
 836                 elm_image_file_set(m->eoAlbumCover, buf, NULL);
 837         }
 838 }
 839
 840
 841 void CPlaybackView::m_UpdateCurrentSongLabels(void)
 842 {
 843         char buf[MAX_LENGTH];
 844
 845         if (!m->csinfo)
 846                 return;
 847
 848         elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
 849                 m->csinfo->Name());
 850
 851         snprintf(buf, sizeof(buf), "%s - %s", m->csinfo->Artist(),
 852                 m->csinfo->Album());
 853
 854         elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM, buf);
 855 }
 856
 857
 858 void CPlaybackView::m_UpdateEmptySongInfo(void)
 859 {
 860         char buf[MAX_LENGTH];
 861
 862         elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
 863                 MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 864         elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
 865         elm_object_focus_next_object_set(m->eoBtnControl[BTN_REPEAT],
 866                 m->eoBtnControl[BTN_REPEAT], ELM_FOCUS_RIGHT);
 867         elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_TRUE);
 868         elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_TRUE);
 869         elm_object_disabled_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
 870         elm_object_part_text_set(m->eoBase, MUSIC_PART_FULLTIME, "00:00");
 871         elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
 872
 873         m->pSliderWidget->Init();
 874
 875         elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
 876                 _(NO_PLAYLIST_MESSAGE));
 877         elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM,
 878                 _(NO_PLAYLIST_MESSAGE_SUB));
 879         snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
 880                 MUSIC_IMAGE_DEFAULT_THUMB_450);
 881         elm_image_file_set(m->eoAlbumCover, buf, NULL);
 882         m->pController->SetPlayState(PLAY_STATUS_INITIAL);
 883 }
 884
 885
 886 void CPlaybackView::m_UpdateCtxtView(int playStatus)
 887 {
 888         if (!m->cs_itinfo || !m->ctxtinfo)
 889                 return;
 890
 891         if (!m->mgr->CheckTop(MUSIC_CONTEXT_VIEW))
 892                 return;
 893
 894         if (m->cs_itinfo->sinfo == m->ctxtinfo->context) {
 895                 m->ctxtinfo->status = (EPlayStatus)playStatus;
 896
 897                 SParcel parcel;
 898                 memset(&parcel, 0, sizeof(SParcel));
 899                 parcel.updateType = E_SONG_UPDATE;
 900                 m->mgr->UpdateView((const char *)MUSIC_CONTEXT_VIEW, &parcel);
 901         }
 902 }
 903
 904
 905 void CPlaybackView::m_UpdateCurrentSongItem(int index)
 906 {
 907         SItemInfo *pItemInfo = NULL;
 908
 909         if (m->cs_itinfo) {
 910                 m_UnselectItem(m->cs_itinfo);
 911                 m_UpdateCtxtView(PLAY_STATUS_PAUSE);
 912         }
 913
 914         pItemInfo = (SItemInfo *)eina_list_nth(m->elInfo, index);
 915
 916         if (pItemInfo) {
 917                 m->cs_itinfo = pItemInfo;
 918                 if (m->pController->PlayState() == PLAY_STATUS_STOP) {
 919                         elm_genlist_item_bring_in(pItemInfo->item,
 920                                 ELM_GENLIST_ITEM_SCROLLTO_IN);
 921                 }
 922                 else {
 923                         m_SelectItem(pItemInfo);
 924                         m_UpdateCtxtView(PLAY_STATUS_PLAY);
 925                 }
 926         }
 927 }
 928
 929
 930 void CPlaybackView::m_UpdateEditmodeFocusSequence(void)
 931 {
 932         elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_LEFT);
 933         elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL], m->eoPlaylist, ELM_FOCUS_RIGHT);
 934         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_DOWN);
 935 }
 936
 937
 938 void CPlaybackView::m_UpdatePlaymodeFocusSequence(void)
 939 {
 940         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoPlaylist,             ELM_FOCUS_UP);
 941         elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnControl[BTN_PLAY], ELM_FOCUS_DOWN);
 942         switch (m->pController->PlayState()) {
 943         case PLAY_STATUS_INITIAL:
 944                 // Do nothing
 945                 break;
 946
 947         case PLAY_STATUS_STOP:
 948                 elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnControl[BTN_PLAY], ELM_FOCUS_LEFT);
 949                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY], m->eoPlaylist, ELM_FOCUS_RIGHT);
 950                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY], m->eoBtnControl[BTN_REPEAT], ELM_FOCUS_LEFT);
 951                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_REPEAT], m->eoBtnControl[BTN_PLAY], ELM_FOCUS_RIGHT);
 952                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY], MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 953                 break;
 954
 955         case PLAY_STATUS_PLAY:
 956         case PLAY_STATUS_PAUSE:
 957                 elm_object_focus_next_object_set(m->eoPlaylist,
 958                         m->eoBtnControl[BTN_FORWARD], ELM_FOCUS_LEFT);
 959                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_FORWARD],
 960                         m->eoPlaylist, ELM_FOCUS_RIGHT);
 961                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY],
 962                         m->eoBtnControl[BTN_FORWARD], ELM_FOCUS_RIGHT);
 963                 break;
 964
 965         default:
 966                 ASSERT(!"Invalid State");
 967                 break;
 968         }
 969 }
 970
 971
 972 void CPlaybackView::m_UpdateCurrentSongInfo(void)
 973 {
 974         CSongInfo *sinfo = NULL;
 975         int index;
 976
 977         if (eina_list_count(m->elInfo) == 0) {
 978                 m_UpdateEmptySongInfo();
 979                 return;
 980         }
 981
 982         if (!m->pController->GetCurrentSongIndex(&index)) {
 983                 _ERR(" music get current song index failed ");
 984                 return;
 985         }
 986
 987         if (!m->pController->GetSonginfoFromIndex(index, &sinfo)) {
 988                 _ERR(" music get songinfo failed ");
 989                 return;
 990         }
 991         m->csinfo = sinfo;
 992
 993         m_UpdateCurrentSongItem(index);
 994         m_UpdateCurrentSongLabels();
 995         m_UpdateCurrentSongThumbnail();
 996         m_UpdateControlBtns();
 997         m_UpdatePlaymodeFocusSequence();
 998 }
 999
1000
1001 void CPlaybackView::m_DisableEditButtons(bool flag)
1002 {
1003         /* flag - 1 means disable edit buttons and 0 means enable */
1004         if (flag)
1005                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1006
1007         elm_object_disabled_set(m->eoBtnEdit[BTN_DELETE], (Eina_Bool)flag);
1008         elm_object_disabled_set(m->eoBtnEdit[BTN_DESELECT], (Eina_Bool)flag);
1009         if (flag) {
1010                 m_UpdateEditmodeFocusSequence();
1011                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1012         }
1013         else {
1014                 elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL], m->eoBtnEdit[BTN_DESELECT], ELM_FOCUS_RIGHT);
1015                 elm_object_focus_next_object_set(m->eoBtnEdit[BTN_DELETE], m->eoPlaylist,              ELM_FOCUS_RIGHT);
1016                 elm_object_focus_next_object_set(m->eoPlaylist,            m->eoBtnEdit[BTN_DELETE],   ELM_FOCUS_LEFT);
1017         }
1018 }
1019
1020
1021 void CPlaybackView::m_CreateErrorPopup(void)
1022 {
1023         Evas_Object *popup = NULL, *btn = NULL, *label = NULL;
1024
1025         popup = elm_popup_add(m->eoBase);
1026         if (!popup)
1027                 return;
1028
1029         elm_object_style_set(popup, MUSIC_STYLE_ERROR_POPUP);
1030         evas_object_show(popup);
1031
1032         label = elm_label_add(popup);
1033         if (!label) {
1034                 evas_object_del(popup);
1035                 return;
1036         }
1037
1038         elm_object_style_set(label, MUSIC_STYLE_ERROR_LABEL);
1039         elm_object_text_set(label, MUSIC_TEXT_PLAYBACK_ERROR);
1040         elm_object_content_set(popup, label);
1041
1042         btn = elm_button_add(popup);
1043         if (!btn) {
1044                 evas_object_del(popup);
1045                 return;
1046         }
1047
1048         elm_object_style_set(btn, MUSIC_STYLE_EDIT_BTN);
1049         elm_object_text_set(btn, MUSIC_TEXT_OK);
1050         elm_object_part_content_set(popup, MUSIC_PART_POPUP_BUTTON, btn);
1051
1052         m->eoErrPopup = popup;
1053
1054         Connect(btn, EO_ERROR_POPUP_BUTTON, TYPE_CLICKED | TYPE_KEY_DOWN);
1055
1056         elm_object_focus_set(btn, EINA_TRUE);
1057
1058         return;
1059 }
1060
1061
1062 void CPlaybackView::m_DestroyErrorPopup(void)
1063 {
1064         if (!m->eoErrPopup)
1065                 return;
1066
1067         evas_object_del(m->eoErrPopup);
1068         m->eoErrPopup = NULL;
1069 }
1070
1071
1072 void CPlaybackView::m_CreateSettingsPopup(void)
1073 {
1074         CContextPopup::SCallback cb;
1075         cb.cookie = this;
1076         cb.onSelected = sm_CbCtxPopupBtnSelected;
1077
1078         m->eoCtxPopup = new CPlaySettingCtxPopup;
1079         m->eoCtxPopup->Create(m->eoWin, &cb);
1080 }
1081
1082
1083 void CPlaybackView::m_DestroySettingsPopup(void)
1084 {
1085         if (!m->eoCtxPopup)
1086                 return;
1087
1088         if (m->eoCtxPopup->FlagCreate())
1089                 m->eoCtxPopup->Destroy();
1090
1091         delete m->eoCtxPopup;
1092         m->eoCtxPopup = NULL;
1093 }
1094
1095
1096 void CPlaybackView::m_FromEditToPlaybackMode(void)
1097 {
1098         if (m->pController->PlayState() == PLAY_STATUS_STOP) {
1099                 elm_genlist_item_bring_in(m->cs_itinfo->item,
1100                         ELM_GENLIST_ITEM_SCROLLTO_IN);
1101         }
1102         else
1103                 m_SelectItem(m->cs_itinfo);
1104
1105         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE,
1106                 MUSIC_PLAYBACK_VIEW);
1107         elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
1108
1109         m_ChangeEditmodeAll(m->elInfo, false);
1110
1111         elm_genlist_realized_items_update(m->eoPlaylist);
1112
1113         m_UpdatePlaymodeFocusSequence();
1114 }
1115
1116
1117 void CPlaybackView::m_FromPlaybackToEditMode(void)
1118 {
1119         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_EDIT_MODE,
1120                 MUSIC_PLAYBACK_VIEW);
1121
1122         m_DisableEditButtons(true);
1123
1124         elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1125
1126         m_ChangeEditmodeAll(m->elInfo, true);
1127
1128         elm_genlist_realized_items_update(m->eoPlaylist);
1129
1130         m_UpdateEditmodeFocusSequence();
1131 }
1132
1133
1134 void CPlaybackView::m_HandleOnRepeated(void)
1135 {
1136         Evas_Object *obj = NULL;
1137         int value;
1138         int duration;
1139         char *timestr = NULL;
1140
1141         if (!m->eoPressedObj)
1142                 return;
1143
1144         obj = m->eoPressedObj;
1145
1146
1147         m->pController->GetPosition(&value);
1148         duration = m->cs_itinfo->sinfo->Duration();
1149
1150         if (obj == m->eoBtnControl[BTN_REWIND]) {
1151                 if (value == 0) {
1152                         m_RemoveTimer(TIMER_LONGPRESS);
1153                         return;
1154                 }
1155                 value = value - LP_CHANGE;
1156                 if (value <= 0)
1157                         value = 0;
1158         }
1159         else {
1160                 if (value == duration) {
1161                         m->pController->PlayNextSong();
1162
1163                         m->press_status = PRESS_LONG_PAUSE;
1164                         elm_object_signal_emit(m->eoBtnControl[BTN_PLAY], MUSIC_SIGNAL_PAUSE,
1165                                 MUSIC_PLAYBACK_VIEW);
1166                         m_PlaybackPause();
1167                         m_RemoveTimer(TIMER_LONGPRESS);
1168
1169                         return;
1170                 }
1171                 value = value + LP_CHANGE;
1172                 if (value >= duration)
1173                         value = duration;
1174         }
1175
1176         m->pController->SetPosition(value);
1177         timestr = CCommonUI::TimeStrFromMilSeconds(value);
1178         if (timestr) {
1179                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
1180                         timestr);
1181                 free(timestr);
1182         }
1183
1184         return;
1185 }
1186
1187
1188 void CPlaybackView::m_DeleteSelectedItems(void)
1189 {
1190         Eina_List *l = NULL, *l_next = NULL;
1191         SItemInfo *pItemInfo = NULL;
1192         void *obj = NULL;
1193         bool updateFlag = false;
1194         int index;
1195
1196         m_DisableEditButtons(true);
1197         EINA_LIST_FOREACH_SAFE(m->elInfo, l, l_next, obj) {
1198                 pItemInfo = (SItemInfo *)obj;
1199                 if (pItemInfo->check_status) {
1200                         if (m->cs_itinfo == pItemInfo) {
1201                                 updateFlag = true;
1202                                 m_UnselectItem(m->cs_itinfo);
1203                                 m->cs_itinfo = NULL;
1204                                 m->pController->SetPlayState(PLAY_STATUS_STOP);
1205                                 m->pController->Stop();
1206                         }
1207                         index = elm_genlist_item_index_get(pItemInfo->item);
1208                         m->pController->RemoveSong(pItemInfo->sinfo, index);
1209
1210                         m->elInfo = eina_list_remove(m->elInfo, pItemInfo);
1211                         elm_object_item_del(pItemInfo->item);
1212                 }
1213         }
1214
1215         if (eina_list_count(m->elInfo) == 0) {
1216                 m_UpdateEmptySongInfo();
1217                 elm_genlist_realized_items_update(m->eoPlaylist);
1218                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1219                 return;
1220         }
1221
1222         if (updateFlag)
1223                 m_UpdateCurrentSongInfo();
1224
1225         elm_genlist_realized_items_update(m->eoPlaylist);
1226         elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
1227 }
1228
1229
1230 void CPlaybackView::m_KeyBackPress(void)
1231 {
1232         if (m->eoCtxPopup) {
1233                 m_DestroySettingsPopup();
1234                 elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
1235                 return;
1236         }
1237
1238         t_OnHide();
1239
1240         if (!CViewMgr::GetInstance()->ShowView(MUSIC_BASE_VIEW))
1241                 _ERR("CViewMgr::ShowView failed");
1242
1243         if (CViewMgr::GetInstance()->CheckTop(MUSIC_CONTEXT_VIEW)) {
1244                 if (!CViewMgr::GetInstance()->UpdateView(MUSIC_CONTEXT_VIEW, NULL))
1245                         _ERR("CViewMgr::UpdateView failed");
1246
1247                 if (!CViewMgr::GetInstance()->ShowView(MUSIC_CONTEXT_VIEW))
1248                         _ERR("CViewMgr::ShowView failed");
1249         }
1250 }
1251
1252
1253 void CPlaybackView::m_KeyExitPress(void)
1254 {
1255         m->pController->Stop();
1256         elm_exit();
1257 }
1258
1259
1260 void CPlaybackView::m_KeyPlayPress(void)
1261 {
1262         int state;
1263
1264         if (elm_object_disabled_get(m->eoBtnControl[BTN_PLAY]))
1265                 return;
1266
1267         state = m->pController->PlayState();
1268         if (state == PLAY_STATUS_PAUSE) {
1269                 m_PlaybackResume();
1270                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
1271                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
1272         }
1273         else if (state != PLAY_STATUS_PLAY) {
1274                 m->pController->Start();
1275         }
1276 }
1277
1278
1279 void CPlaybackView::m_KeyPausePress(void)
1280 {
1281         int state;
1282
1283         if (elm_object_disabled_get(m->eoBtnControl[BTN_PLAY]))
1284                 return;
1285
1286         state = m->pController->PlayState();
1287         if (state == PLAY_STATUS_PLAY) {
1288                 elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
1289                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
1290                 m_PlaybackPause();
1291         }
1292 }
1293
1294
1295 void CPlaybackView::m_KeyNextPress(void)
1296 {
1297         if (elm_object_disabled_get(m->eoBtnControl[BTN_FORWARD]))
1298                 return;
1299
1300         m_HandleOnPressed(m->eoBtnControl[BTN_FORWARD]);
1301 }
1302
1303
1304 void CPlaybackView::m_KeyPreviousPress(void)
1305 {
1306         if (elm_object_disabled_get(m->eoBtnControl[BTN_REWIND]))
1307                 return;
1308
1309         m_HandleOnPressed(m->eoBtnControl[BTN_REWIND]);
1310 }
1311
1312
1313 void CPlaybackView::m_KeyNextUnpress(void)
1314 {
1315         if (elm_object_disabled_get(m->eoBtnControl[BTN_FORWARD]))
1316                 return;
1317
1318         m_HandleOnUnpressed(m->eoBtnControl[BTN_FORWARD]);
1319 }
1320
1321
1322 void CPlaybackView::m_KeyPreviousUnpress(void)
1323 {
1324         if (elm_object_disabled_get(m->eoBtnControl[BTN_REWIND]))
1325                 return;
1326
1327         m_HandleOnUnpressed(m->eoBtnControl[BTN_REWIND]);
1328 }
1329
1330
1331 void CPlaybackView::m_HandleKeyPress(char *keyname)
1332 {
1333         if (!strcmp(keyname, (char *)KEY_EXIT))
1334                 m_KeyExitPress();
1335         else if (!strcmp(keyname, (char *)KEY_BACK) ||
1336                 !strcmp(keyname, (char *)KEY_BACK_REMOTE))
1337                 m_KeyBackPress();
1338         else if (!strcmp(keyname, (char *)KEY_PLAY))
1339                 m_KeyPlayPress();
1340         else if (!strcmp(keyname, (char *)KEY_PAUSE))
1341                 m_KeyPausePress();
1342         else if (!strcmp(keyname, (char *)KEY_NEXT))
1343                 m_KeyNextPress();
1344         else if (!strcmp(keyname, (char *)KEY_PREVIOUS))
1345                 m_KeyPreviousPress();
1346         else if (!strcmp(keyname, (char *)KEY_VOLUMEUP))
1347                 m->pHandleVolume->Up();
1348         else if (!strcmp(keyname, (char *)KEY_VOLUMEDOWN))
1349                 m->pHandleVolume->Down();
1350         else if (!strcmp(keyname, (char *)KEY_MUTE))
1351                 m->pHandleVolume->Mute();
1352 }
1353
1354
1355 void CPlaybackView::m_HandleKeyUnpress(char *keyname)
1356 {
1357         if (!strcmp(keyname, KEY_PREVIOUS))
1358                 m_KeyPreviousUnpress();
1359         else if (!strcmp(keyname, KEY_NEXT))
1360                 m_KeyNextUnpress();
1361 }
1362
1363
1364 void CPlaybackView::m_AddAlbumCover(void)
1365 {
1366         Evas_Object *eoAlbumCover = NULL;
1367
1368         eoAlbumCover = elm_image_add(m->eoBase);
1369         if (!eoAlbumCover)
1370                 return;
1371
1372         evas_object_size_hint_weight_set(eoAlbumCover, EVAS_HINT_EXPAND,
1373                         EVAS_HINT_EXPAND);
1374         elm_image_aspect_fixed_set(eoAlbumCover, EINA_FALSE);
1375
1376         elm_object_part_content_set(m->eoBase, MUSIC_PART_ALBUMCOVER,
1377                         eoAlbumCover);
1378         evas_object_show(eoAlbumCover);
1379         m->eoAlbumCover = eoAlbumCover;
1380
1381 }
1382
1383
1384 void CPlaybackView::m_AddCurrentSonginfo(void)
1385 {
1386         m_AddAlbumCover();
1387
1388         m->pSliderWidget = new CSliderWidget;
1389         m->pSliderWidget->Create(m->eoBase);
1390 }
1391
1392
1393 void CPlaybackView::m_AddEditPlaylistButtons(void)
1394 {
1395         Evas_Object *box = NULL;
1396         int i;
1397         SBtnInfo btninfo[TOTAL_EDIT_BTNS];
1398
1399         btninfo[BTN_CANCEL].txt = MUSIC_TEXT_CANCEL;
1400         btninfo[BTN_CANCEL].type = EO_CANCEL;
1401
1402         btninfo[BTN_DESELECT].txt = MUSIC_TEXT_DESELECT;
1403         btninfo[BTN_DESELECT].type = EO_DESELECT;
1404
1405         btninfo[BTN_DELETE].txt = MUSIC_TEXT_DELETE;
1406         btninfo[BTN_DELETE].type = EO_DELETE;
1407
1408         box = CCommonUI::AddBox(m->eoBase);
1409         if (!box)
1410                 return;
1411
1412         elm_box_horizontal_set(box, EINA_TRUE);
1413         elm_box_padding_set(box, MUSIC_EDIT_BTNS_PADDING * elm_config_scale_get(), 0);
1414
1415         for (i = 0; i < TOTAL_EDIT_BTNS; i++) {
1416                 m->eoBtnEdit[i] = elm_button_add(m->eoBase);
1417                 if (!m->eoBtnEdit[i])
1418                         continue;
1419
1420                 elm_object_style_set(m->eoBtnEdit[i], MUSIC_STYLE_EDIT_BTN);
1421                 evas_object_size_hint_weight_set(m->eoBtnEdit[i], EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1422                 elm_box_pack_end(box, m->eoBtnEdit[i]);
1423                 elm_object_text_set(m->eoBtnEdit[i], _(btninfo[i].txt));
1424
1425                 Connect(m->eoBtnEdit[i], btninfo[i].type, TYPE_CLICKED | TYPE_MOUSE_MOVE);
1426
1427                 evas_object_show(m->eoBtnEdit[i]);
1428         }
1429         elm_object_part_content_set(m->eoBase, MUSIC_PART_EDITBTNS, box);
1430         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE, MUSIC_PLAYBACK_VIEW);
1431 }
1432
1433
1434 void CPlaybackView::m_AddControlButtons(void)
1435 {
1436         Evas_Object *box = NULL;
1437         int i;
1438         SBtnInfo btninfo[TOTAL_CONTROL_BTNS];
1439
1440         btninfo[BTN_SETTINGS].txt = MUSIC_STYLE_BTN_SETTINGS;
1441         btninfo[BTN_SETTINGS].type = EO_BTN_SETTINGS;
1442
1443         btninfo[BTN_SHUFFLE].txt = MUSIC_STYLE_BTN_SHUFFLE;
1444         btninfo[BTN_SHUFFLE].type = EO_BTN_SHUFFLE;
1445
1446         btninfo[BTN_REPEAT].txt = MUSIC_STYLE_BTN_REPEAT;
1447         btninfo[BTN_REPEAT].type = EO_BTN_REPEAT;
1448
1449         btninfo[BTN_REWIND].txt = MUSIC_STYLE_BTN_REWIND;
1450         btninfo[BTN_REWIND].type = EO_BTN_REWIND;
1451
1452         btninfo[BTN_PLAY].txt = MUSIC_STYLE_BTN_PLAY;
1453         btninfo[BTN_PLAY].type = EO_BTN_PLAY;
1454
1455         btninfo[BTN_FORWARD].txt = MUSIC_STYLE_BTN_FORWARD;
1456         btninfo[BTN_FORWARD].type = EO_BTN_FORWARD;
1457
1458         box = elm_box_add(m->eoBase);
1459         if (!box)
1460                 return;
1461
1462         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, 0);
1463         evas_object_size_hint_align_set(box, EVAS_HINT_FILL, 0);
1464         elm_box_horizontal_set(box, EINA_TRUE);
1465         elm_box_padding_set(box,
1466                 MUSIC_CONTROL_BTNS_PADDING * elm_config_scale_get(), 0);
1467
1468         for (i = 0; i < TOTAL_CONTROL_BTNS; i++) {
1469                 m->eoBtnControl[i] = elm_button_add(m->eoBase);
1470                 if (!m->eoBtnControl[i])
1471                         continue;
1472
1473                 elm_object_style_set(m->eoBtnControl[i], btninfo[i].txt);
1474                 evas_object_size_hint_weight_set(m->eoBtnControl[i],
1475                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1476                 elm_box_pack_end(box, m->eoBtnControl[i]);
1477
1478                 if (i == BTN_REWIND || i == BTN_FORWARD) {
1479                         Connect(m->eoBtnControl[i], btninfo[i].type, TYPE_PRESSED | TYPE_UNPRESSED | TYPE_MOUSE_MOVE);
1480                 }
1481                 else {
1482                         Connect(m->eoBtnControl[i], btninfo[i].type, TYPE_CLICKED | TYPE_MOUSE_MOVE);
1483                 }
1484                 evas_object_show(m->eoBtnControl[i]);
1485         }
1486
1487         elm_object_part_content_set(m->eoBase, MUSIC_PART_CONTROLBTNS, box);
1488 }
1489
1490
1491 SItemInfo *CPlaybackView::m_FindItemInfoFromSong(Eina_List *list, CSongInfo *sinfo)
1492 {
1493         Eina_List *l = NULL;
1494         SItemInfo *itinfo = NULL;
1495         void *obj = NULL;
1496
1497         EINA_LIST_FOREACH(list, l, obj) {
1498                 itinfo = (SItemInfo *)obj;
1499                 if (itinfo->sinfo == sinfo)
1500                         return itinfo;
1501         }
1502
1503         return NULL;
1504 }
1505
1506
1507 SItemInfo *CPlaybackView::m_FindItemInfoFromItem(Eina_List *list, Elm_Object_Item *item)
1508 {
1509         Eina_List *l = NULL;
1510         SItemInfo *itinfo = NULL;
1511         void *obj = NULL;
1512
1513         EINA_LIST_FOREACH(list, l, obj) {
1514                 itinfo = (SItemInfo *)obj;
1515                 if (itinfo->item == item)
1516                         return itinfo;
1517         }
1518
1519         return NULL;
1520 }
1521
1522
1523 void CPlaybackView::m_UpdateItemCheck(SItemInfo *itinfo)
1524 {
1525         if (!itinfo) {
1526                 _ERR(" No item info to Update check ");
1527                 return;
1528         }
1529
1530         if (itinfo->check_status) {
1531                 elm_object_item_signal_emit(itinfo->item,
1532                         MUSIC_SIGNAL_CHECK_OFF, MUSIC_PLAYBACK_VIEW);
1533                 itinfo->check_status = false;
1534                 return;
1535         }
1536
1537         elm_object_item_signal_emit(itinfo->item,
1538                 MUSIC_SIGNAL_CHECK_ON, MUSIC_PLAYBACK_VIEW);
1539         itinfo->check_status = true;
1540 }
1541
1542
1543 class CElmGenlistItemClass {
1544 public:
1545         static char *sm_CbTextGet(void *data, Evas_Object *obj, const char *part)
1546         {
1547                 CSongInfo *sinfo = NULL;
1548                 SItemInfo *pItemInfo = (SItemInfo *)data;
1549                 char buf[MAX_LENGTH];
1550                 char *timestr = NULL;
1551                 int duration;
1552                 int index;
1553
1554                 if (!pItemInfo || !obj)
1555                         return NULL;
1556
1557                 sinfo = pItemInfo->sinfo;
1558
1559                 snprintf(buf, sizeof(buf), "%s", MUSIC_STR_EMPTY);
1560
1561                 if (!strcmp(part, "elm.text0")) {
1562                         index = elm_genlist_item_index_get(pItemInfo->item);
1563                         snprintf(buf, sizeof(buf), "%d", index);
1564                 }
1565                 else if (!strcmp(part, "elm.text1"))
1566                         snprintf(buf, sizeof(buf), "%s", sinfo->Name());
1567                 else if (!strcmp(part, "elm.text2"))
1568                         snprintf(buf, sizeof(buf), "%s - %s",
1569                         sinfo->Artist(),
1570                         sinfo->Album());
1571                 else if (!strcmp(part, "elm.text3")) {
1572                         duration = sinfo->Duration();
1573                         timestr = CCommonUI::TimeStrFromMilSeconds(duration);
1574                         if (timestr) {
1575                                 snprintf(buf, sizeof(buf), "%s", timestr);
1576                                 free(timestr);
1577                         }
1578                 }
1579
1580                 if (strcmp(buf, MUSIC_STR_EMPTY))
1581                         return strdup(buf);
1582
1583                 return NULL;
1584         }
1585         static Evas_Object *sm_CbContentGet(void *data, Evas_Object *obj, const char *part)
1586         {
1587                 CSongInfo *sinfo = NULL;
1588                 SItemInfo *pItemInfo = (SItemInfo *)data;
1589                 Evas_Object *img = NULL;
1590                 char *path = NULL;
1591                 char buf[MAX_LENGTH];
1592
1593                 if (!pItemInfo || !obj)
1594                         return NULL;
1595
1596                 sinfo = pItemInfo->sinfo;
1597
1598                 img = elm_image_add(obj);
1599                 if (!img)
1600                         return NULL;
1601
1602                 elm_image_aspect_fixed_set(img, EINA_FALSE);
1603
1604                 if (!strcmp(part, "elm.swallow.icon")) {
1605                         path = sinfo->ThumbnailPath();
1606                         if (path)
1607                                 elm_image_file_set(img, path, "NULL");
1608                         else {
1609                                 snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
1610                                         MUSIC_IMAGE_DEFAULT_THUMB_126);
1611                                 elm_image_file_set(img, buf, "NULL");
1612                         }
1613                 }
1614
1615                 return img;
1616
1617         }
1618         static void         sm_CbDel(void *data, Evas_Object *obj)
1619         {
1620                 free(data);
1621         }
1622 };
1623
1624
1625 Elm_Genlist_Item_Class *CPlaybackView::m_GetItemClass(void)
1626 {
1627         Elm_Genlist_Item_Class *list_item = NULL;
1628
1629         list_item = elm_genlist_item_class_new();
1630         if (!list_item) {
1631                 _ERR(" elm_genlist_item_class_new failed ");
1632                 return NULL;
1633         }
1634
1635         list_item->item_style       = MUSIC_STYLE_PLAYLIST;
1636         list_item->func.text_get    = CElmGenlistItemClass::sm_CbTextGet;
1637         list_item->func.content_get = CElmGenlistItemClass::sm_CbContentGet;
1638         list_item->func.state_get   = NULL;
1639         list_item->func.del         = CElmGenlistItemClass::sm_CbDel;
1640
1641         return list_item;
1642 }
1643
1644
1645 void CPlaybackView::m_AddGenlist(void)
1646 {
1647         Evas_Object *genlist = NULL;
1648         Evas_Object *eoBase = NULL;
1649
1650         eoBase = m->eoBase;
1651         genlist = elm_genlist_add(eoBase);
1652         if (!genlist)
1653                 return;
1654
1655         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
1656         evas_object_size_hint_weight_set(genlist,
1657                 EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1658         elm_object_part_content_set(eoBase, MUSIC_PART_PLAYLIST, genlist);
1659         elm_genlist_select_mode_set(genlist, ELM_OBJECT_SELECT_MODE_ALWAYS);
1660         elm_genlist_multi_select_set(genlist, EINA_FALSE);
1661
1662         Connect(genlist, EO_PLAYLIST, TYPE_REALIZED | TYPE_MOUSE_MOVE |
1663                 TYPE_KEY_DOWN | TYPE_ACTIVATED);
1664
1665         evas_object_show(genlist);
1666         m->eoPlaylist = genlist;
1667 }
1668
1669
1670 void CPlaybackView::m_AddPlaylist(void)
1671 {
1672         Elm_Genlist_Item_Class *list_item = NULL;
1673         int ts = 0;
1674         int i, index = -1;
1675         CSongInfo *sinfo = NULL;
1676         Elm_Object_Item *item = NULL;
1677         SItemInfo *pItemInfo = NULL;
1678
1679         m_AddGenlist();
1680         if (!m->eoPlaylist)
1681                 return;
1682
1683         list_item = m_GetItemClass();
1684         if (!list_item) {
1685                 evas_object_del(m->eoPlaylist);
1686                 return;
1687         }
1688
1689         if (!m->pController->GetTotalSongs(&ts)) {
1690                 _ERR(" music get total songs failed ");
1691                 return;
1692         }
1693
1694         if (!m->pController->GetCurrentSongIndex(&index))
1695                 _ERR(" music get current song index failed ");
1696
1697         for (i = 0; i < ts; i++) {
1698                 if (!m->pController->GetSonginfoFromIndex(i, &sinfo)) {
1699                         _ERR(" music get songinfo failed ");
1700                         continue;
1701                 }
1702                 pItemInfo = (SItemInfo *)calloc(1, sizeof(*pItemInfo));
1703                 if (!pItemInfo)
1704                         return;
1705                 pItemInfo->sinfo = sinfo;
1706                 pItemInfo->edit_mode = false;
1707                 pItemInfo->check_status = false;
1708                 pItemInfo->select_status = false;
1709
1710                 // event handling will be done in OnActivated function
1711                 item = elm_genlist_item_append(m->eoPlaylist, list_item,
1712                         pItemInfo, NULL, ELM_GENLIST_ITEM_NONE,
1713                         NULL, m);
1714                 pItemInfo->item = item;
1715
1716                 if (i == index) {
1717                         pItemInfo->select_status = true;
1718                         m->cs_itinfo = pItemInfo;
1719                 }
1720                 m->elInfo = eina_list_append(m->elInfo, pItemInfo);
1721         }
1722 }
1723
1724
1725 void CPlaybackView::m_RemovePlaylist(void)
1726 {
1727         if (m->eoPlaylist) {
1728                 elm_genlist_clear(m->eoPlaylist);
1729                 m->eoPlaylist = NULL;
1730         }
1731
1732         if (m->elInfo) {
1733                 eina_list_free(m->elInfo);
1734                 m->elInfo = NULL;
1735         }
1736 }
1737
1738
1739 void CPlaybackView::m_HandleRewindBtnClicked(Evas_Object *obj)
1740 {
1741         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
1742                 MUSIC_PLAYBACK_VIEW);
1743
1744         if (m->pController->PlayState() == PLAY_STATUS_STOP)
1745                 return;
1746
1747         if (!m->pController->PlayPreviousSong()){
1748                 _ERR(" music play previous song failed ");
1749                 return;
1750         }
1751 }
1752
1753
1754 void CPlaybackView::m_HandleForwardBtnClicked(Evas_Object *obj)
1755 {
1756         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
1757                 MUSIC_PLAYBACK_VIEW);
1758
1759         if (m->pController->PlayState() == PLAY_STATUS_STOP)
1760                 return;
1761
1762         if (!m->pController->PlayNextSong()) {
1763                 _ERR(" music play next song failed ");
1764                 return;
1765         }
1766 }
1767
1768
1769 void CPlaybackView::m_HandleOnPressed(Evas_Object *obj)
1770 {
1771         m->press_status = PRESS_SHORT;
1772         m->eoPressedObj = obj;
1773
1774         m->etWait = ecore_timer_add(WAIT_INTERVAL, sm_CbWaitTimer, this);
1775 }
1776
1777
1778 void CPlaybackView::m_HandleOnUnpressed(Evas_Object *obj)
1779 {
1780         m_RemoveTimer(TIMER_WAIT);
1781         m_RemoveTimer(TIMER_LONGPRESS);
1782
1783         if (m->press_status == PRESS_SHORT) {
1784                 /* Handle song change */
1785                 if (m->pController->PlayState() == PLAY_STATUS_PLAY)
1786                         m_PlaybackPause();
1787
1788                 if (obj == m->eoBtnControl[BTN_FORWARD])
1789                         m_HandleForwardBtnClicked(obj);
1790                 else
1791                         m_HandleRewindBtnClicked(obj);
1792
1793                 if (m->pController->PlayState() != PLAY_STATUS_PLAY)
1794                         m_PlaybackResume();
1795         }
1796         else if (m->press_status == PRESS_LONG) {
1797                 if (m->pController->PlayState() != PLAY_STATUS_PLAY)
1798                         m_PlaybackResume();
1799         }
1800
1801         m->press_status = PRESS_SHORT;
1802 }
1803
1804
1805 void CPlaybackView::m_HandleGenlistItemActivated(Evas_Object *obj, Elm_Object_Item *genListItem)
1806 {
1807         int index;
1808         SItemInfo *itinfo = NULL;
1809
1810         if (!obj || !genListItem)
1811                 return;
1812
1813         itinfo = m_FindItemInfoFromItem(m->elInfo, genListItem);
1814         if (!itinfo) {
1815                 _ERR(" no item info found ");
1816                 return;
1817         }
1818
1819         if (itinfo->edit_mode) {
1820                 m_UpdateItemCheck(itinfo);
1821                 m_DisableEditButtons(false);
1822                 return;
1823         }
1824
1825         index = elm_genlist_item_index_get(genListItem);
1826
1827         m->pController->PlayIndexSong(--index);
1828 }
1829
1830
1831 bool CPlaybackView::Create(void *data)
1832 {
1833         ASSERT(!m);
1834
1835         _CREATE_BEGIN{
1836                 _CHECK(m = new SPlaybackView)
1837                 _CHECK(m->mgr = CViewMgr::GetInstance())
1838                 _CHECK(m->eoWin = m->mgr->Window())
1839                 _CHECK(m->pController = new CMusicController)
1840                 _CHECK(m->pController->Create())
1841                 _CHECK(m->eoBase = CCommonUI::AddBase(m->eoWin, MUSIC_PLAYBACK_VIEW))
1842                 _CHECK(CBaseView::Create(data))
1843                 _CHECK(CTimer::Create());
1844                 _CHECK(m->pController->AddListener(this))
1845
1846                 _WHEN_SUCCESS{
1847                         m->press_status = PRESS_SHORT;
1848                         evas_object_data_set(m->eoBase, PLAYBACK_VIEW_DATA, m);
1849
1850                         m_AddControlButtons();
1851                         m_AddEditPlaylistButtons();
1852                         m_AddCurrentSonginfo();
1853                         m_AddPlaylist();
1854
1855                         m->pHandleVolume = new CHandleVolume;
1856                         m->pHandleVolume->Create(m->eoBase);
1857                         m_UpdatePlaymodeFocusSequence();
1858
1859                         Connect(m->eoBase, EO_BASE, TYPE_KEY_DOWN | TYPE_KEY_UP);
1860                 }
1861
1862                 _CHECK_FAIL{ m->pController->RemoveListener(this); }
1863                 _CHECK_FAIL{ CTimer::Destroy(); }
1864                 _CHECK_FAIL{ CBaseView::Destroy(); }
1865                 _CHECK_FAIL{ evas_object_del(m->eoBase); }
1866                 _CHECK_FAIL{ m->pController->Destroy(); }
1867                 _CHECK_FAIL{ delete m->pController; }
1868                 _CHECK_FAIL{ /* mgr->Window() */ }
1869                 _CHECK_FAIL{ /* CViewerMgr::GetInstance() */}
1870                 _CHECK_FAIL{ delete m; m = NULL; }
1871         }_CREATE_END_AND_CATCH{ return false; }
1872
1873         return true;
1874 }
1875
1876
1877 void CPlaybackView::Destroy(void)
1878 {
1879         ASSERT(m);
1880
1881         Disconnect(m->eoBase);
1882         m->pController->RemoveListener(this);
1883
1884         m_DestroyErrorPopup();
1885
1886         m->pSliderWidget->Destroy();
1887
1888         m_RemoveTimer(TIMER_WAIT);
1889         m_RemoveTimer(TIMER_LONGPRESS);
1890         m_DestroySettingsPopup();
1891
1892         m->pHandleVolume->Destroy();
1893         delete m->pHandleVolume;
1894         CBaseView::Destroy();
1895         evas_object_del(m->eoBase);
1896
1897         free(m->ctxtinfo);
1898         delete m;
1899         m = NULL;
1900 }
1901
1902
1903 Evas_Object* CPlaybackView::Base(void)
1904 {
1905         ASSERT(m);
1906
1907         return m->eoBase;
1908 }
1909
1910
1911 void CPlaybackView::t_OnClickedSettings(Evas_Object *obj)
1912 {
1913         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1914
1915         if (eina_list_count(m->elInfo) == 0)
1916                 return;
1917
1918         elm_object_signal_emit(obj, MUSIC_SIGNAL_CONTROL_SELECTED, MUSIC_PLAYBACK_VIEW);
1919         m_DestroySettingsPopup();
1920         m_CreateSettingsPopup();
1921 }
1922
1923
1924 void CPlaybackView::t_OnClickedShuffle(Evas_Object *obj)
1925 {
1926         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1927
1928         switch (m->pController->ShuffleState()) {
1929         case SHUFFLE_STATUS_OFF:
1930                 m->pController->SetShuffleState(SHUFFLE_STATUS_ON);
1931                 elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
1932                 break;
1933
1934         default:
1935                 m->pController->SetShuffleState(SHUFFLE_STATUS_OFF);
1936                 elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
1937                 break;
1938         }
1939 }
1940
1941
1942 void CPlaybackView::t_OnClickedRepeat(Evas_Object *obj)
1943 {
1944         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1945
1946         switch (m->pController->RepeatState()) {
1947         case REPEAT_STATUS_NONE:
1948                 m->pController->SetRepeatState(REPEAT_STATUS_ALL);
1949                 elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
1950                 break;
1951
1952         case REPEAT_STATUS_ALL:
1953                 m->pController->SetRepeatState(REPEAT_STATUS_ONE);
1954                 elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
1955                 break;
1956
1957         default:
1958                 m->pController->SetRepeatState(REPEAT_STATUS_NONE);
1959                 elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
1960                 break;
1961         }
1962 }
1963
1964
1965 void CPlaybackView::t_OnClickedPlay(Evas_Object *obj)
1966 {
1967         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
1968
1969         switch (m->pController->PlayState()) {
1970         case PLAY_STATUS_PAUSE:
1971                 m_PlaybackResume();
1972                 elm_object_signal_emit(obj, MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
1973                 break;
1974
1975         case PLAY_STATUS_PLAY:
1976                 elm_object_signal_emit(obj, MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
1977                 m_PlaybackPause();
1978                 break;
1979
1980         default:
1981                 if (m->pController)
1982                         m->pController->Start();
1983                 break;
1984         }
1985 }
1986
1987
1988 void CPlaybackView::t_OnShow(void)
1989 {
1990         ASSERT(m);
1991
1992         int state;
1993
1994         m_UpdateCurrentSongInfo();
1995
1996         state = m->pController->PlayState();
1997         if (state == PLAY_STATUS_INITIAL || state == PLAY_STATUS_STOP) {
1998                 m_RemovePlaylist();
1999                 m_AddPlaylist();
2000                 m->pController->Start();
2001         }
2002
2003         if (m->cs_itinfo) {
2004                 elm_genlist_item_show(m->cs_itinfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
2005                 elm_object_item_focus_set(m->cs_itinfo->item, EINA_TRUE);
2006         }
2007
2008         evas_object_show(m->eoBase);
2009 }
2010
2011
2012 void CPlaybackView::t_OnUpdate(void *data)
2013 {
2014         ASSERT(m);
2015
2016         SParcel *parcel = (SParcel *)data;
2017         int updateType;
2018         char *keyEvent = NULL;
2019
2020         if (!parcel)
2021                 updateType = E_PLAYLIST_UPDATE;
2022         else {
2023                 updateType = parcel->updateType;
2024                 keyEvent = (char *)parcel->keyEvent;
2025         }
2026
2027         switch (updateType) {
2028         case E_PLAYLIST_UPDATE:
2029                 m_RemovePlaylist();
2030                 m_AddPlaylist();
2031                 elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
2032                 elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
2033                 elm_object_disabled_set(m->eoBtnControl[BTN_PLAY], EINA_FALSE);
2034                 elm_object_focus_next_object_set(m->eoBtnControl[BTN_REPEAT],
2035                         m->eoBtnControl[BTN_REWIND], ELM_FOCUS_RIGHT);
2036                 m_FromEditToPlaybackMode();
2037                 break;
2038
2039         case E_KEY_PRESS:
2040                 m_HandleKeyPress(keyEvent);
2041                 break;
2042
2043         case E_KEY_RELEASE:
2044                 m_HandleKeyUnpress(keyEvent);
2045                 break;
2046
2047         default:
2048                 break;
2049         }
2050 }
2051
2052
2053 void CPlaybackView::t_OnHide(void)
2054 {
2055         ASSERT(m);
2056
2057         evas_object_hide(m->eoBase);
2058 }
2059
2060
2061 void CPlaybackView::OnKeyDown(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Down *ev)
2062 {
2063         switch (id) {
2064         case EO_BASE:
2065                 m_HandleKeyPress(ev->keyname);
2066                 break;
2067
2068         case EO_ERROR_POPUP_BUTTON:
2069                 if (!strcmp(ev->keyname, KEY_BACK) ||
2070                         !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
2071                         m_DestroyErrorPopup();
2072                         elm_object_focus_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
2073                 }
2074                 break;
2075
2076         case EO_PLAYLIST:
2077                 {
2078                         Elm_Object_Item *it = NULL;
2079                         SContentInfo *ctxtinfo = NULL;
2080                         SItemInfo *itinfo = NULL;
2081                         SParcel parcel;
2082
2083                         if (!strcmp(ev->keyname, KEY_MENU) ||
2084                                 !strcmp(ev->keyname, KEY_MENU_REMOTE)) {
2085                                 it = elm_object_focused_item_get(obj);
2086                                 if (!it) {
2087                                         _ERR(" unable to get focused item ");
2088                                         return;
2089                                 }
2090                                 m->focused_item = it;
2091
2092                                 if (m->ctxtinfo) {
2093                                         free(m->ctxtinfo);
2094                                         m->ctxtinfo = NULL;
2095                                 }
2096
2097                                 ctxtinfo = (SContentInfo *)calloc(1, sizeof(*ctxtinfo));
2098                                 if (!ctxtinfo)
2099                                         return;
2100
2101                                 itinfo = m_FindItemInfoFromItem(m->elInfo, it);
2102                                 if (!itinfo) {
2103                                         free(ctxtinfo);
2104                                         return;
2105                                 }
2106
2107                                 if (m->pController->PlayState() == PLAY_STATUS_PLAY &&
2108                                         itinfo == m->cs_itinfo)
2109                                         ctxtinfo->status = PLAY_STATUS_PLAY;
2110                                 else
2111                                         ctxtinfo->status = PLAY_STATUS_PAUSE;
2112
2113                                 ctxtinfo->cbdata = this;
2114                                 ctxtinfo->update = sm_CbCtxtUpdate;
2115                                 ctxtinfo->close = sm_CbCtxtClose;
2116                                 ctxtinfo->type = CONTEXT_TYPE_PLAYSONG;
2117                                 ctxtinfo->context = itinfo->sinfo;
2118
2119                                 m->ctxtinfo = ctxtinfo;
2120
2121                                 memset(&parcel, 0, sizeof(SParcel));
2122                                 parcel.ctxtInfo = ctxtinfo;
2123                                 if (!m->mgr->PushView(MUSIC_CONTEXT_VIEW, &parcel))
2124                                         _ERR("viewmgr push view MUSIC_CONTEXT_VIEW failed");
2125                         }
2126                 }
2127
2128         default:
2129                 break;
2130         }
2131 }
2132
2133
2134 void CPlaybackView::OnKeyUp(int id, Evas *e, Evas_Object *obj, Evas_Event_Key_Up *ev)
2135 {
2136         switch (id) {
2137         case EO_BASE:
2138                 m_HandleKeyUnpress(ev->keyname);
2139                 break;
2140
2141         default:
2142                 break;
2143         }
2144 }
2145
2146
2147 void CPlaybackView::OnMouseClicked(int id, Evas_Object *obj)
2148 {
2149         switch (id) {
2150         case EO_ERROR_POPUP_BUTTON:
2151                 m_DestroyErrorPopup();
2152                 elm_object_focus_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
2153                 break;
2154
2155         case EO_CANCEL:
2156                 m_DisableCheckAll(m->elInfo);
2157                 m_DisableEditButtons(true);
2158                 m_FromEditToPlaybackMode();
2159                 break;
2160
2161         case EO_DESELECT:
2162                 m_DisableCheckAll(m->elInfo);
2163                 m_DisableEditButtons(true);
2164                 elm_genlist_realized_items_update(m->eoPlaylist);
2165                 elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
2166                 break;
2167
2168         case EO_DELETE:
2169                 m_DeleteSelectedItems();
2170                 break;
2171
2172         case EO_BTN_SETTINGS:
2173                 t_OnClickedSettings(obj);
2174                 break;
2175
2176         case EO_BTN_SHUFFLE:
2177                 t_OnClickedShuffle(obj);
2178                 break;
2179
2180         case EO_BTN_REPEAT:
2181                 t_OnClickedRepeat(obj);
2182                 break;
2183
2184         case EO_BTN_PLAY:
2185                 t_OnClickedPlay(obj);
2186                 break;
2187
2188         default:
2189                 break;
2190         }
2191 }
2192
2193
2194 void CPlaybackView::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
2195 {
2196         switch (id) {
2197         case EO_CANCEL:
2198         case EO_DESELECT:
2199         case EO_DELETE:
2200         case EO_BTN_FORWARD:
2201         case EO_BTN_PLAY:
2202         case EO_BTN_REPEAT:
2203         case EO_BTN_REWIND:
2204         case EO_BTN_SETTINGS:
2205         case EO_BTN_SHUFFLE:
2206                 if (!elm_object_focus_get(obj))
2207                         elm_object_focus_set(obj, EINA_TRUE);
2208                 break;
2209
2210         case EO_PLAYLIST:
2211                 {
2212                         Elm_Object_Item *item;
2213
2214                         item = elm_genlist_at_xy_item_get(obj, ev->cur.canvas.x,
2215                                 ev->cur.canvas.y, NULL);
2216                         if (!item)
2217                                 return;
2218
2219                         if (!elm_object_item_focus_get(item))
2220                                 elm_object_item_focus_set(item, EINA_TRUE);
2221                 }
2222                 break;
2223
2224         default:
2225                 break;
2226         }
2227 }
2228
2229
2230 void CPlaybackView::OnPressed(int id, Evas_Object *obj)
2231 {
2232         switch (id) {
2233         case EO_BTN_FORWARD:
2234         case EO_BTN_REWIND:
2235                 m_HandleOnPressed(obj);
2236                 break;
2237
2238         default:
2239                 break;
2240         }
2241 }
2242
2243
2244 void CPlaybackView::OnUnpressed(int id, Evas_Object *obj)
2245 {
2246         switch (id) {
2247         case EO_BTN_FORWARD:
2248         case EO_BTN_REWIND:
2249                 m_HandleOnUnpressed(obj);
2250                 break;
2251
2252         default:
2253                 break;
2254         }
2255 }
2256
2257
2258 void CPlaybackView::OnRealized(int id, Evas_Object *obj, Elm_Object_Item *item)
2259 {
2260         switch (id) {
2261         case EO_PLAYLIST:
2262                 {
2263                         int index = elm_genlist_item_index_get(item);
2264                         if ((index & 1) == 1)
2265                                 elm_object_item_signal_emit(item,
2266                                         MUSIC_SIGNAL_EVEN_ROW, MUSIC_PLAYBACK_VIEW);
2267                         else
2268                                 elm_object_item_signal_emit(item,
2269                                         MUSIC_SIGNAL_ODD_ROW, MUSIC_PLAYBACK_VIEW);
2270
2271                         SItemInfo *itInfo = m_FindItemInfoFromItem(m->elInfo, item);
2272                         if (itInfo->select_status)
2273                                 elm_object_item_signal_emit(item,
2274                                         MUSIC_SIGNAL_SELECT_ITEM, MUSIC_PLAYBACK_VIEW);
2275                         else
2276                                 elm_object_item_signal_emit(item,
2277                                         MUSIC_SIGNAL_UNSELECT_ITEM, MUSIC_PLAYBACK_VIEW);
2278
2279                         if (itInfo->edit_mode) {
2280                                 elm_object_item_signal_emit(item,
2281                                         MUSIC_SIGNAL_EDITMODE_ON, MUSIC_PLAYBACK_VIEW);
2282                                 if (itInfo->check_status) {
2283                                         elm_object_item_signal_emit(item,
2284                                                 MUSIC_SIGNAL_CHECK_ON, MUSIC_PLAYBACK_VIEW);
2285                                 }
2286                                 else
2287                                         elm_object_item_signal_emit(item,
2288                                                 MUSIC_SIGNAL_CHECK_OFF, MUSIC_PLAYBACK_VIEW);
2289                         }
2290                         else
2291                                 elm_object_item_signal_emit(item,
2292                                         MUSIC_SIGNAL_EDITMODE_OFF, MUSIC_PLAYBACK_VIEW);
2293                 }
2294                 break;
2295
2296         default:
2297                 break;
2298         }
2299 }
2300
2301
2302 void CPlaybackView::OnActivated(int id, Evas_Object *obj, Elm_Object_Item *item)
2303 {
2304         switch (id) {
2305         case EO_PLAYLIST:
2306                 m_HandleGenlistItemActivated(obj, item);
2307                 break;
2308
2309         default:
2310                 break;
2311         }
2312 }
2313
2314
2315 void CPlaybackView::OnComplete(void)
2316 {
2317         m_UpdateCurrentSongInfo();
2318 }
2319
2320
2321 void CPlaybackView::OnError(void)
2322 {
2323         m_CreateErrorPopup();
2324 }
2325
2326
2327 void CPlaybackView::OnUsbStatusChanged(SUsbStorageStatus status)
2328 {
2329 }
2330
2331
2332 void CPlaybackView::OnUpdateContent(void)
2333 {
2334 }
2335
2336
2337 void CPlaybackView::OnStartPlayback(void)
2338 {
2339         m_UpdateCurrentSongInfo();
2340 }
2341
2342
2343 void CPlaybackView::OnStopPlayback(void)
2344 {
2345 }