src/views/PlaybackController.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 <AppCommon.h>
  18 #include "i18n.h"
  19 #include "define.h"
  20 #include "common.h"
  21 #include "song_info.h"
  22 #include "music-controller.h"
  23 #include "common-ui.h"
  24 #include "PlaySettingCtxPopup.h"
  25 #include "ErrorPopupWindow.h"
  26 #include "Info.h"
  27 #include "PlaybackController.h"
  28
  29 #define TOTAL_CONTROL_BTNS 6
  30 #define TOTAL_EDIT_BTNS    3
  31 #define LP_INTERVAL        0.5   /* seconds */
  32 #define WAIT_INTERVAL      0.5   /* seconds */
  33 #define LP_CHANGE          10000 /* milli seconds */
  34
  35 enum EEvasObject {
  36         EO_CANCEL,
  37         EO_DESELECT,
  38         EO_DELETE,           // TOTAL_EDIT_BTNS
  39
  40         EO_BTN_SETTINGS,
  41         EO_BTN_SHUFFLE,
  42         EO_BTN_REPEAT,
  43         EO_BTN_REWIND,
  44         EO_BTN_PLAY,
  45         EO_BTN_FORWARD,      // TOTAL_CONTROL_BTNS
  46 };
  47
  48 struct SBtnInfo {
  49         const char *txt;
  50         const char *part;
  51         EEvasObject type;
  52 };
  53
  54 enum ESettingBtns {
  55         BTN_EDIT,
  56         BTN_CLEAR
  57 };
  58
  59 enum ETimers {
  60         TIMER_WAIT,
  61         TIMER_LONGPRESS,
  62         TIMER_VOLUME
  63 };
  64
  65 enum EPressTypes {
  66         PRESS_SHORT,
  67         PRESS_SHORT_PAUSE,
  68         PRESS_LONG,
  69         PRESS_LONG_PAUSE,
  70 };
  71
  72 struct SPlaybackController {
  73         Evas_Object *eoBase;
  74         CPlaySettingCtxPopup *eoCtxPopup;
  75         CErrorPopupWindow *eoErrPopup;
  76         Evas_Object *eoPressedObj;
  77
  78         Evas_Object *eoBtnControl[TOTAL_CONTROL_BTNS];
  79         Evas_Object *eoBtnEdit[TOTAL_EDIT_BTNS];
  80
  81         Ecore_Timer *etWait;
  82         Ecore_Timer *etLongPress;
  83
  84         CMusicController controller;
  85         EPressTypes press_status;
  86
  87         CPlaybackController::SCallback cb;
  88
  89         CSongInfo *pSongInfo;
  90         int duration;
  91
  92         SPlaybackController() {
  93                 memset(this, 0, sizeof(SPlaybackController));
  94         }
  95 };
  96
  97
  98 void CPlaybackController::sm_CbCtxPopupBtnSelected(void* cookie, CContextPopup* instance, const char* text)
  99 {
 100         CPlaybackController *root = (CPlaybackController *)cookie;
 101         if (root)
 102                 root->m_OnCtxPopupBtnSelected(instance, text);
 103 }
 104
 105
 106 void CPlaybackController::m_OnCtxPopupBtnSelected(CContextPopup* instance, const char* text)
 107 {
 108         int type = CInfo::PlaybackSettingType();
 109
 110         switch (type) {
 111         case BTN_EDIT:
 112                 m->controller.ChangePlayerMode(MODE_PLAYLIST_EDIT);
 113                 break;
 114
 115         case BTN_CLEAR:
 116                 m->controller.Stop();
 117                 m->controller.EmptyPlaylist();
 118                 break;
 119
 120         default:
 121                 break;
 122         }
 123 }
 124
 125
 126 void CPlaybackController::sm_CbErrorPopupBtnSelected(void* cookie, CMessagePopup *instance)
 127 {
 128         CPlaybackController *root = (CPlaybackController *)cookie;
 129         if (root)
 130                 root->m_OnErrorPopupBtnSelected(instance);
 131 }
 132
 133
 134 void CPlaybackController::m_OnErrorPopupBtnSelected(CMessagePopup *instance)
 135 {
 136         m_DestroyErrorPopup();
 137         elm_object_focus_set(m->eoBtnControl[CTRL_BTN_PLAY], EINA_TRUE);
 138 }
 139
 140
 141 Eina_Bool CPlaybackController::sm_CbWaitTimer(void *dt)
 142 {
 143         CPlaybackController *root = (CPlaybackController *)dt;
 144         if (root)
 145                 root->m_OnWaitTimer();
 146
 147         return ECORE_CALLBACK_CANCEL;
 148 }
 149
 150
 151 void CPlaybackController::m_OnWaitTimer(void)
 152 {
 153         m->press_status = PRESS_LONG;
 154         if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
 155                 /* Handle long press */
 156                 m->controller.Pause();
 157                 m->etLongPress = ecore_timer_add(LP_INTERVAL, sm_CbLongpressTimer, this);
 158         }
 159         else {
 160                 m->press_status = PRESS_LONG_PAUSE;
 161         }
 162
 163         m->etWait = NULL;
 164 }
 165
 166
 167 Eina_Bool CPlaybackController::sm_CbLongpressTimer(void *dt)
 168 {
 169         CPlaybackController *root = (CPlaybackController *)dt;
 170         if (root)
 171                 root->m_OnLongpressTimer();
 172
 173         return ECORE_CALLBACK_RENEW;
 174 }
 175
 176
 177 void CPlaybackController::m_OnLongpressTimer(void)
 178 {
 179         m_HandleOnRepeated();
 180 }
 181
 182
 183 void CPlaybackController::m_AddControlButtons(void)
 184 {
 185         Evas_Object *box = NULL;
 186         int i;
 187         SBtnInfo btninfo[TOTAL_CONTROL_BTNS];
 188
 189         btninfo[CTRL_BTN_SETTINGS].txt = MUSIC_STYLE_BTN_SETTINGS;
 190         btninfo[CTRL_BTN_SETTINGS].type = EO_BTN_SETTINGS;
 191
 192         btninfo[CTRL_BTN_SHUFFLE].txt = MUSIC_STYLE_BTN_SHUFFLE;
 193         btninfo[CTRL_BTN_SHUFFLE].type = EO_BTN_SHUFFLE;
 194
 195         btninfo[CTRL_BTN_REPEAT].txt = MUSIC_STYLE_BTN_REPEAT;
 196         btninfo[CTRL_BTN_REPEAT].type = EO_BTN_REPEAT;
 197
 198         btninfo[CTRL_BTN_REWIND].txt = MUSIC_STYLE_BTN_REWIND;
 199         btninfo[CTRL_BTN_REWIND].type = EO_BTN_REWIND;
 200
 201         btninfo[CTRL_BTN_PLAY].txt = MUSIC_STYLE_BTN_PLAY;
 202         btninfo[CTRL_BTN_PLAY].type = EO_BTN_PLAY;
 203
 204         btninfo[CTRL_BTN_FORWARD].txt = MUSIC_STYLE_BTN_FORWARD;
 205         btninfo[CTRL_BTN_FORWARD].type = EO_BTN_FORWARD;
 206
 207         box = elm_box_add(m->eoBase);
 208         if (!box)
 209                 return;
 210
 211         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, 0);
 212         evas_object_size_hint_align_set(box, EVAS_HINT_FILL, 0);
 213         elm_box_horizontal_set(box, EINA_TRUE);
 214         elm_box_padding_set(box,
 215                 MUSIC_CONTROL_BTNS_PADDING * elm_config_scale_get(), 0);
 216
 217         for (i = 0; i < TOTAL_CONTROL_BTNS; i++) {
 218                 m->eoBtnControl[i] = elm_button_add(m->eoBase);
 219                 if (!m->eoBtnControl[i])
 220                         continue;
 221
 222                 elm_object_style_set(m->eoBtnControl[i], btninfo[i].txt);
 223                 evas_object_size_hint_weight_set(m->eoBtnControl[i],
 224                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 225                 elm_box_pack_end(box, m->eoBtnControl[i]);
 226
 227                 if (i == CTRL_BTN_REWIND || i == CTRL_BTN_FORWARD) {
 228                         Connect(m->eoBtnControl[i], btninfo[i].type, TYPE_PRESSED | TYPE_UNPRESSED | TYPE_MOUSE_MOVE);
 229                 }
 230                 else {
 231                         Connect(m->eoBtnControl[i], btninfo[i].type, TYPE_CLICKED | TYPE_MOUSE_MOVE);
 232                 }
 233                 evas_object_show(m->eoBtnControl[i]);
 234         }
 235
 236         elm_object_part_content_set(m->eoBase, MUSIC_PART_CONTROLBTNS, box);
 237 }
 238
 239
 240 void CPlaybackController::m_AddEditPlaylistButtons(void)
 241 {
 242         Evas_Object *box = NULL;
 243         int i;
 244         SBtnInfo btninfo[TOTAL_EDIT_BTNS];
 245
 246         btninfo[EDIT_BTN_CANCEL].txt = MUSIC_TEXT_CANCEL;
 247         btninfo[EDIT_BTN_CANCEL].type = EO_CANCEL;
 248
 249         btninfo[EDIT_BTN_DESELECT].txt = MUSIC_TEXT_DESELECT;
 250         btninfo[EDIT_BTN_DESELECT].type = EO_DESELECT;
 251
 252         btninfo[EDIT_BTN_DELETE].txt = MUSIC_TEXT_DELETE;
 253         btninfo[EDIT_BTN_DELETE].type = EO_DELETE;
 254
 255         box = CCommonUI::AddBox(m->eoBase);
 256         if (!box)
 257                 return;
 258
 259         elm_box_horizontal_set(box, EINA_TRUE);
 260         elm_box_padding_set(box, MUSIC_EDIT_BTNS_PADDING * elm_config_scale_get(), 0);
 261
 262         for (i = 0; i < TOTAL_EDIT_BTNS; i++) {
 263                 m->eoBtnEdit[i] = elm_button_add(m->eoBase);
 264                 if (!m->eoBtnEdit[i])
 265                         continue;
 266
 267                 elm_object_style_set(m->eoBtnEdit[i], MUSIC_STYLE_EDIT_BTN);
 268                 evas_object_size_hint_weight_set(m->eoBtnEdit[i], EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 269                 elm_box_pack_end(box, m->eoBtnEdit[i]);
 270                 elm_object_text_set(m->eoBtnEdit[i], _(btninfo[i].txt));
 271
 272                 Connect(m->eoBtnEdit[i], btninfo[i].type, TYPE_CLICKED | TYPE_MOUSE_MOVE);
 273
 274                 evas_object_show(m->eoBtnEdit[i]);
 275         }
 276         elm_object_part_content_set(m->eoBase, MUSIC_PART_EDITBTNS, box);
 277         elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE, MUSIC_PLAYBACK_VIEW);
 278 }
 279
 280
 281 void CPlaybackController::m_UpdateForEmptySong(void)
 282 {
 283         elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 284                 MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 285         elm_object_focus_set(m->eoBtnControl[CTRL_BTN_SETTINGS], EINA_TRUE);
 286         elm_object_focus_next_object_set(m->eoBtnControl[CTRL_BTN_REPEAT],
 287                 m->eoBtnControl[CTRL_BTN_REPEAT], ELM_FOCUS_RIGHT);
 288         elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_TRUE);
 289         elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_TRUE);
 290         elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_PLAY], EINA_TRUE);
 291 }
 292
 293
 294 void CPlaybackController::m_CreateErrorPopup(void)
 295 {
 296         CMessagePopup::SCallback cb;
 297         cb.cookie = this;
 298         cb.onBtn1Pressed = sm_CbErrorPopupBtnSelected;
 299
 300         m->eoErrPopup = new CErrorPopupWindow;
 301         m->eoErrPopup->Create(m->eoBase, &cb, MUSIC_TEXT_PLAYBACK_ERROR);
 302
 303
 304         return;
 305 }
 306
 307
 308 void CPlaybackController::m_DestroyErrorPopup(void)
 309 {
 310         if (!m->eoErrPopup)
 311                 return;
 312
 313         if (m->eoErrPopup->FlagCreate())
 314                 m->eoErrPopup->Destroy();
 315
 316         delete m->eoErrPopup;
 317         m->eoErrPopup = NULL;
 318 }
 319
 320
 321 void CPlaybackController::m_CreateSettingsPopup(void)
 322 {
 323         CContextPopup::SCallback cb;
 324         cb.cookie = this;
 325         cb.onSelected = sm_CbCtxPopupBtnSelected;
 326
 327         m->eoCtxPopup = new CPlaySettingCtxPopup;
 328         m->eoCtxPopup->Create(m->eoBase, &cb);
 329 }
 330
 331
 332 void CPlaybackController::m_DestroySettingsPopup(void)
 333 {
 334         if (!m->eoCtxPopup)
 335                 return;
 336
 337         if (m->eoCtxPopup->FlagCreate())
 338                 m->eoCtxPopup->Destroy();
 339
 340         delete m->eoCtxPopup;
 341         m->eoCtxPopup = NULL;
 342 }
 343
 344
 345 void CPlaybackController::m_HandleForwardBtnClicked(Evas_Object *obj)
 346 {
 347         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
 348                 MUSIC_PLAYBACK_VIEW);
 349
 350         if (m->controller.PlayState() == PLAY_STATUS_STOP)
 351                 return;
 352
 353         if (!m->controller.PlayNextSong()) {
 354                 _ERR(" music play next song failed ");
 355                 return;
 356         }
 357 }
 358
 359
 360 void CPlaybackController::m_HandleRewindBtnClicked(Evas_Object *obj)
 361 {
 362         elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
 363                 MUSIC_PLAYBACK_VIEW);
 364
 365         if (m->controller.PlayState() == PLAY_STATUS_STOP)
 366                 return;
 367
 368         if (!m->controller.PlayPreviousSong()) {
 369                 _ERR(" music play previous song failed ");
 370                 return;
 371         }
 372 }
 373
 374
 375 void CPlaybackController::m_HandleOnRepeated(void)
 376 {
 377         Evas_Object *obj = NULL;
 378         int value;
 379         char *timestr = NULL;
 380
 381         if (!m->eoPressedObj)
 382                 return;
 383
 384         obj = m->eoPressedObj;
 385
 386
 387         m->controller.GetPosition(&value);
 388
 389         if (obj == m->eoBtnControl[CTRL_BTN_REWIND]) {
 390                 if (value == 0) {
 391                         m_RemoveTimer(TIMER_LONGPRESS);
 392                         return;
 393                 }
 394                 value = value - LP_CHANGE;
 395                 if (value <= 0)
 396                         value = 0;
 397         }
 398         else {
 399                 if (value == m->duration) {
 400                         m->controller.PlayNextSong();
 401
 402                         m->press_status = PRESS_LONG_PAUSE;
 403                         elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY], MUSIC_SIGNAL_PAUSE,
 404                                 MUSIC_PLAYBACK_VIEW);
 405                         m->controller.Pause();
 406                         m_RemoveTimer(TIMER_LONGPRESS);
 407
 408                         return;
 409                 }
 410                 value = value + LP_CHANGE;
 411                 if (value >= m->duration)
 412                         value = m->duration;
 413         }
 414
 415         m->controller.SetPosition(value);
 416         timestr = CCommonUI::TimeStrFromMilSeconds(value);
 417         if (timestr) {
 418                 elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
 419                         timestr);
 420                 free(timestr);
 421         }
 422
 423         return;
 424 }
 425
 426
 427 void CPlaybackController::m_RemoveTimer(int timer_code)
 428 {
 429         ETimers timerCode = (ETimers)timer_code;
 430
 431         switch (timerCode) {
 432         case TIMER_WAIT:
 433                 if (m->etWait) {
 434                         ecore_timer_del(m->etWait);
 435                         m->etWait = NULL;
 436                 }
 437                 break;
 438
 439         case TIMER_LONGPRESS:
 440                 if (m->etLongPress) {
 441                         ecore_timer_del(m->etLongPress);
 442                         m->etLongPress = NULL;
 443                 }
 444                 break;
 445
 446         default:
 447                 _ERR(" invalid value ");
 448                 break;
 449         }
 450 }
 451
 452
 453 void CPlaybackController::m_HandleOnPressed(Evas_Object *obj)
 454 {
 455         m->press_status = PRESS_SHORT;
 456         m->eoPressedObj = obj;
 457
 458         m->etWait = ecore_timer_add(WAIT_INTERVAL, sm_CbWaitTimer, this);
 459 }
 460
 461
 462 void CPlaybackController::m_HandleOnUnpressed(Evas_Object *obj)
 463 {
 464         m_RemoveTimer(TIMER_WAIT);
 465         m_RemoveTimer(TIMER_LONGPRESS);
 466
 467         if (m->press_status == PRESS_SHORT) {
 468                 /* Handle song change */
 469                 if (m->controller.PlayState() == PLAY_STATUS_PLAY)
 470                         m->controller.Pause();
 471
 472                 if (obj == m->eoBtnControl[CTRL_BTN_FORWARD])
 473                         m_HandleForwardBtnClicked(obj);
 474                 else
 475                         m_HandleRewindBtnClicked(obj);
 476
 477                 if (m->controller.PlayState() != PLAY_STATUS_PLAY)
 478                         m->controller.Resume();
 479         }
 480         else if (m->press_status == PRESS_LONG) {
 481                 if (m->controller.PlayState() != PLAY_STATUS_PLAY)
 482                         m->controller.Resume();
 483         }
 484
 485         m->press_status = PRESS_SHORT;
 486 }
 487
 488
 489 void CPlaybackController::m_UpdateSongInfo(void)
 490 {
 491         CSongInfo *sinfo = NULL;
 492         int index;
 493
 494         if (!m->controller.GetCurrentSongIndex(&index)) {
 495                 _ERR(" music get current song index failed ");
 496                 return;
 497         }
 498
 499         if (!m->controller.GetSonginfoFromIndex(index, &sinfo)) {
 500                 _ERR(" music get songinfo failed ");
 501                 return;
 502         }
 503         m->pSongInfo = sinfo;
 504 }
 505
 506
 507 void CPlaybackController::m_Update(void)
 508 {
 509         int state;
 510
 511         state = m->controller.PlayState();
 512         switch (state) {
 513         case PLAY_STATUS_INITIAL:
 514                 // Initial State, Do nothing
 515                 break;
 516
 517         case PLAY_STATUS_STOP:
 518                 if (!m->eoErrPopup)
 519                         elm_object_focus_set(m->eoBtnControl[CTRL_BTN_PLAY], EINA_TRUE);
 520                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_TRUE);
 521                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_TRUE);
 522                 break;
 523
 524         case PLAY_STATUS_PLAY:
 525                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_FALSE);
 526                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_FALSE);
 527                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 528                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 529                 break;
 530
 531         case PLAY_STATUS_PAUSE:
 532                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_FALSE);
 533                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_FALSE);
 534                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 535                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 536                 break;
 537
 538         default:
 539                 ASSERT(!"Invalid State");
 540                 break;
 541         }
 542
 543         state = m->controller.ShuffleState();
 544         switch (state) {
 545         case SHUFFLE_STATUS_OFF:
 546                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_SHUFFLE],
 547                         MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
 548                 break;
 549
 550         case SHUFFLE_STATUS_ON:
 551                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_SHUFFLE],
 552                         MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
 553                 break;
 554
 555         default:
 556                 ASSERT(!"Invalid State");
 557                 break;
 558         }
 559
 560         state = m->controller.RepeatState();
 561         switch (state) {
 562         case REPEAT_STATUS_NONE:
 563                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_REPEAT],
 564                         MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
 565                 break;
 566
 567         case REPEAT_STATUS_ALL:
 568                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_REPEAT],
 569                         MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
 570                 break;
 571
 572         case REPEAT_STATUS_ONE:
 573                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_REPEAT],
 574                         MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
 575                 break;
 576
 577         default:
 578                 ASSERT(!"Invalid State");
 579                 break;
 580         }
 581 }
 582
 583
 584 bool CPlaybackController::Create(Evas_Object *eoBase, SCallback *cb)
 585 {
 586         ASSERT(!m);
 587
 588         _CREATE_BEGIN{
 589                 _CHECK(m = new SPlaybackController)
 590                 _COMMAND{ m->eoBase = eoBase; }
 591                 _CHECK(m->controller.Create())
 592                 _CHECK(m->controller.AddListener(this))
 593
 594                 _WHEN_SUCCESS{
 595                         m_AddControlButtons();
 596                         m_AddEditPlaylistButtons();
 597                         m->cb = *cb;
 598                         m->press_status = PRESS_SHORT;
 599                 }
 600
 601                 _CHECK_FAIL{ m->controller.RemoveListener(this); }
 602                 _CHECK_FAIL{ m->controller.Destroy(); }
 603
 604                 _CHECK_FAIL{ delete m; m = NULL; }
 605         } _CREATE_END_AND_CATCH{ return false; }
 606
 607         return true;
 608 }
 609
 610
 611 void CPlaybackController::Destroy(void)
 612 {
 613         ASSERT(m);
 614
 615         m_DestroyErrorPopup();
 616         m_DestroySettingsPopup();
 617         m->controller.RemoveListener(this);
 618
 619         delete m;
 620         m = NULL;
 621 }
 622
 623
 624 Evas_Object *CPlaybackController::ControlBtnsObject(EPlayerControlBtns id)
 625 {
 626         ASSERT(m);
 627         return m->eoBtnControl[id];
 628 }
 629
 630
 631 Evas_Object *CPlaybackController::EditBtnsObject(EPlayerEditBtns id)
 632 {
 633         ASSERT(m);
 634         return m->eoBtnEdit[id];
 635 }
 636
 637
 638 void CPlaybackController::OnStartPlayback(void)
 639 {
 640         m_UpdateSongInfo();
 641         m->duration = m->pSongInfo->Duration();
 642 }
 643
 644
 645 void CPlaybackController::OnError(void)
 646 {
 647         m_CreateErrorPopup();
 648 }
 649
 650
 651 void CPlaybackController::OnEmptyPlaylist(void)
 652 {
 653         m_UpdateForEmptySong();
 654 }
 655
 656
 657 void CPlaybackController::OnRemoteButtonEvent(Evas_Object *eoBtn, EPlayerBtnsEvent ev)
 658 {
 659         switch (ev) {
 660         case EVENT_PRESSED:
 661                 m_HandleOnPressed(eoBtn);
 662                 break;
 663
 664         case EVENT_UNPRESSED:
 665                 m_HandleOnUnpressed(eoBtn);
 666                 break;
 667
 668         default:
 669                 ASSERT(!"Invalid Event.");
 670                 break;
 671         }
 672 }
 673
 674
 675 void CPlaybackController::OnUpdatePlayerUI(void)
 676 {
 677         m_Update();
 678 }
 679
 680
 681 void CPlaybackController::OnPressed(int id, Evas_Object *obj)
 682 {
 683         switch (id) {
 684         case EO_BTN_FORWARD:
 685         case EO_BTN_REWIND:
 686                 m_HandleOnPressed(obj);
 687                 break;
 688
 689         default:
 690                 break;
 691         }
 692 }
 693
 694
 695 void CPlaybackController::OnUnpressed(int id, Evas_Object *obj)
 696 {
 697         switch (id) {
 698         case EO_BTN_FORWARD:
 699         case EO_BTN_REWIND:
 700                 m_HandleOnUnpressed(obj);
 701                 break;
 702
 703         default:
 704                 break;
 705         }
 706 }
 707
 708
 709 void CPlaybackController::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
 710 {
 711         switch (id) {
 712         case EO_CANCEL:
 713         case EO_DESELECT:
 714         case EO_DELETE:
 715         case EO_BTN_FORWARD:
 716         case EO_BTN_PLAY:
 717         case EO_BTN_REPEAT:
 718         case EO_BTN_REWIND:
 719         case EO_BTN_SETTINGS:
 720         case EO_BTN_SHUFFLE:
 721                 if (!elm_object_focus_get(obj))
 722                         elm_object_focus_set(obj, EINA_TRUE);
 723                 break;
 724
 725         default:
 726                 break;
 727         }
 728 }
 729
 730
 731 void CPlaybackController::OnMouseClicked(int id, Evas_Object *obj)
 732 {
 733         switch (id) {
 734         case EO_CANCEL:
 735                 m->controller.HandlePlaylistEditButtons(EDIT_BTN_CANCEL);
 736                 m->controller.ChangePlayerMode(MODE_PLAYBACK);
 737
 738                 break;
 739
 740         case EO_DESELECT:
 741                 m->controller.HandlePlaylistEditButtons(EDIT_BTN_DESELECT);
 742                 elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 743                 break;
 744
 745         case EO_DELETE:
 746                 m->controller.HandlePlaylistEditButtons(EDIT_BTN_DELETE);
 747                 break;
 748
 749         case EO_BTN_SETTINGS:
 750                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 751
 752                 if (m->cb.OnCurrentSongCount &&
 753                         m->cb.OnCurrentSongCount(m->cb.cookie) == 0)
 754                         return;
 755
 756                 elm_object_signal_emit(obj, MUSIC_SIGNAL_CONTROL_SELECTED, MUSIC_PLAYBACK_VIEW);
 757                 m_DestroySettingsPopup();
 758                 m_CreateSettingsPopup();
 759                 break;
 760
 761         case EO_BTN_SHUFFLE:
 762                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 763
 764                 switch (m->controller.ShuffleState()) {
 765                 case SHUFFLE_STATUS_OFF:
 766                         m->controller.SetShuffleState(SHUFFLE_STATUS_ON);
 767                         elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
 768                         break;
 769
 770                 default:
 771                         m->controller.SetShuffleState(SHUFFLE_STATUS_OFF);
 772                         elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
 773                         break;
 774                 }
 775                 break;
 776
 777         case EO_BTN_REPEAT:
 778                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 779
 780                 switch (m->controller.RepeatState()) {
 781                 case REPEAT_STATUS_NONE:
 782                         m->controller.SetRepeatState(REPEAT_STATUS_ALL);
 783                         elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
 784                         break;
 785
 786                 case REPEAT_STATUS_ALL:
 787                         m->controller.SetRepeatState(REPEAT_STATUS_ONE);
 788                         elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
 789                         break;
 790
 791                 default:
 792                         m->controller.SetRepeatState(REPEAT_STATUS_NONE);
 793                         elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
 794                         break;
 795                 }
 796                 break;
 797
 798         case EO_BTN_PLAY:
 799                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 800
 801                 switch (m->controller.PlayState()) {
 802                 case PLAY_STATUS_PAUSE:
 803                         m->controller.Resume();
 804                         elm_object_signal_emit(obj, MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 805                         break;
 806
 807                 case PLAY_STATUS_PLAY:
 808                         elm_object_signal_emit(obj, MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 809                         m->controller.Pause();
 810                         break;
 811
 812                 default:
 813                         m->controller.Start();
 814                         break;
 815                 }
 816                 break;
 817
 818         default:
 819                 break;
 820         }
 821 }