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_UpdateSongInfo(void)
 454 {
 455         CSongInfo *sinfo = NULL;
 456         int index;
 457
 458         if (!m->controller.GetCurrentSongIndex(&index)) {
 459                 _ERR(" music get current song index failed ");
 460                 return;
 461         }
 462
 463         if (!m->controller.GetSonginfoFromIndex(index, &sinfo)) {
 464                 _ERR(" music get songinfo failed ");
 465                 return;
 466         }
 467         m->pSongInfo = sinfo;
 468 }
 469
 470
 471 void CPlaybackController::m_HandleOnPressed(Evas_Object *obj)
 472 {
 473         m->press_status = PRESS_SHORT;
 474         m->eoPressedObj = obj;
 475
 476         m->etWait = ecore_timer_add(WAIT_INTERVAL, sm_CbWaitTimer, this);
 477 }
 478
 479
 480 void CPlaybackController::m_HandleOnUnpressed(Evas_Object *obj)
 481 {
 482         m_RemoveTimer(TIMER_WAIT);
 483         m_RemoveTimer(TIMER_LONGPRESS);
 484
 485         if (m->press_status == PRESS_SHORT) {
 486                 /* Handle song change */
 487                 if (m->controller.PlayState() == PLAY_STATUS_PLAY)
 488                         m->controller.Pause();
 489
 490                 if (obj == m->eoBtnControl[CTRL_BTN_FORWARD])
 491                         m_HandleForwardBtnClicked(obj);
 492                 else
 493                         m_HandleRewindBtnClicked(obj);
 494
 495                 if (m->controller.PlayState() != PLAY_STATUS_PLAY)
 496                         m->controller.Resume();
 497         }
 498         else if (m->press_status == PRESS_LONG) {
 499                 if (m->controller.PlayState() != PLAY_STATUS_PLAY)
 500                         m->controller.Resume();
 501         }
 502
 503         m->press_status = PRESS_SHORT;
 504 }
 505
 506
 507 bool CPlaybackController::Create(Evas_Object *eoBase, SCallback *cb)
 508 {
 509         ASSERT(!m);
 510
 511         _CREATE_BEGIN{
 512                 _CHECK(m = new SPlaybackController)
 513                 _COMMAND{ m->eoBase = eoBase; }
 514                 _CHECK(m->controller.Create())
 515                 _CHECK(m->controller.AddListener(this))
 516
 517                 _WHEN_SUCCESS{
 518                         m_AddControlButtons();
 519                         m_AddEditPlaylistButtons();
 520                         m->cb = *cb;
 521                         m->press_status = PRESS_SHORT;
 522                 }
 523
 524                 _CHECK_FAIL{ m->controller.RemoveListener(this); }
 525                 _CHECK_FAIL{ m->controller.Destroy(); }
 526
 527                 _CHECK_FAIL{ delete m; m = NULL; }
 528         } _CREATE_END_AND_CATCH{ return false; }
 529
 530         return true;
 531 }
 532
 533
 534 void CPlaybackController::Destroy(void)
 535 {
 536         ASSERT(m);
 537
 538         m_DestroyErrorPopup();
 539         m_DestroySettingsPopup();
 540         m->controller.RemoveListener(this);
 541
 542         delete m;
 543         m = NULL;
 544 }
 545
 546
 547 void CPlaybackController::Update(void)
 548 {
 549         int state;
 550
 551         state = m->controller.PlayState();
 552         switch (state) {
 553         case PLAY_STATUS_INITIAL:
 554                 // Initial State, Do nothing
 555                 break;
 556
 557         case PLAY_STATUS_STOP:
 558                 if (!m->eoErrPopup)
 559                         elm_object_focus_set(m->eoBtnControl[CTRL_BTN_PLAY], EINA_TRUE);
 560                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_TRUE);
 561                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_TRUE);
 562                 break;
 563
 564         case PLAY_STATUS_PLAY:
 565                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_FALSE);
 566                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_FALSE);
 567                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 568                         MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 569                 break;
 570
 571         case PLAY_STATUS_PAUSE:
 572                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_FORWARD], EINA_FALSE);
 573                 elm_object_disabled_set(m->eoBtnControl[CTRL_BTN_REWIND], EINA_FALSE);
 574                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_PLAY],
 575                         MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 576                 break;
 577
 578         default:
 579                 ASSERT(!"Invalid State");
 580                 break;
 581         }
 582
 583         state = m->controller.ShuffleState();
 584         switch (state) {
 585         case SHUFFLE_STATUS_OFF:
 586                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_SHUFFLE],
 587                         MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
 588                 break;
 589
 590         case SHUFFLE_STATUS_ON:
 591                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_SHUFFLE],
 592                         MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
 593                 break;
 594
 595         default:
 596                 ASSERT(!"Invalid State");
 597                 break;
 598         }
 599
 600         state = m->controller.RepeatState();
 601         switch (state) {
 602         case REPEAT_STATUS_NONE:
 603                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_REPEAT],
 604                         MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
 605                 break;
 606
 607         case REPEAT_STATUS_ALL:
 608                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_REPEAT],
 609                         MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
 610                 break;
 611
 612         case REPEAT_STATUS_ONE:
 613                 elm_object_signal_emit(m->eoBtnControl[CTRL_BTN_REPEAT],
 614                         MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
 615                 break;
 616
 617         default:
 618                 ASSERT(!"Invalid State");
 619                 break;
 620         }
 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::OnComplete(void)
 639 {
 640 }
 641
 642
 643 void CPlaybackController::OnStartPlayback(void)
 644 {
 645         m_UpdateSongInfo();
 646         m->duration = m->pSongInfo->Duration();
 647 }
 648
 649
 650 void CPlaybackController::OnStopPlayback(void)
 651 {
 652 }
 653
 654
 655 void CPlaybackController::OnPausePlayback(void)
 656 {
 657 }
 658
 659
 660 void CPlaybackController::OnResumePlayback(void)
 661 {
 662 }
 663
 664
 665 void CPlaybackController::OnPosition(int milsec)
 666 {
 667 }
 668
 669
 670 void CPlaybackController::OnError(void)
 671 {
 672         m_CreateErrorPopup();
 673 }
 674
 675
 676 void CPlaybackController::OnEmptyPlaylist(void)
 677 {
 678         m_UpdateForEmptySong();
 679 }
 680
 681
 682 void CPlaybackController::OnRemoteButtonEvent(Evas_Object *eoBtn, EPlayerBtnsEvent ev)
 683 {
 684         switch (ev) {
 685         case EVENT_PRESSED:
 686                 m_HandleOnPressed(eoBtn);
 687                 break;
 688
 689         case EVENT_UNPRESSED:
 690                 m_HandleOnUnpressed(eoBtn);
 691                 break;
 692
 693         default:
 694                 ASSERT(!"Invalid Event.");
 695                 break;
 696         }
 697 }
 698
 699
 700 void CPlaybackController::OnPressed(int id, Evas_Object *obj)
 701 {
 702         switch (id) {
 703         case EO_BTN_FORWARD:
 704         case EO_BTN_REWIND:
 705                 m_HandleOnPressed(obj);
 706                 break;
 707
 708         default:
 709                 break;
 710         }
 711 }
 712
 713
 714 void CPlaybackController::OnUnpressed(int id, Evas_Object *obj)
 715 {
 716         switch (id) {
 717         case EO_BTN_FORWARD:
 718         case EO_BTN_REWIND:
 719                 m_HandleOnUnpressed(obj);
 720                 break;
 721
 722         default:
 723                 break;
 724         }
 725 }
 726
 727
 728 void CPlaybackController::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
 729 {
 730         switch (id) {
 731         case EO_CANCEL:
 732         case EO_DESELECT:
 733         case EO_DELETE:
 734         case EO_BTN_FORWARD:
 735         case EO_BTN_PLAY:
 736         case EO_BTN_REPEAT:
 737         case EO_BTN_REWIND:
 738         case EO_BTN_SETTINGS:
 739         case EO_BTN_SHUFFLE:
 740                 if (!elm_object_focus_get(obj))
 741                         elm_object_focus_set(obj, EINA_TRUE);
 742                 break;
 743
 744         default:
 745                 break;
 746         }
 747 }
 748
 749
 750 void CPlaybackController::OnMouseClicked(int id, Evas_Object *obj)
 751 {
 752         switch (id) {
 753         case EO_CANCEL:
 754                 m->controller.HandlePlaylistEditButtons(EDIT_BTN_CANCEL);
 755                 m->controller.ChangePlayerMode(MODE_PLAYBACK);
 756
 757                 break;
 758
 759         case EO_DESELECT:
 760                 m->controller.HandlePlaylistEditButtons(EDIT_BTN_DESELECT);
 761                 elm_object_focus_set(m->eoBtnEdit[EDIT_BTN_CANCEL], EINA_TRUE);
 762                 break;
 763
 764         case EO_DELETE:
 765                 m->controller.HandlePlaylistEditButtons(EDIT_BTN_DELETE);
 766                 break;
 767
 768         case EO_BTN_SETTINGS:
 769                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 770
 771                 if (m->cb.OnCurrentSongCount &&
 772                         m->cb.OnCurrentSongCount(m->cb.cookie) == 0)
 773                         return;
 774
 775                 elm_object_signal_emit(obj, MUSIC_SIGNAL_CONTROL_SELECTED, MUSIC_PLAYBACK_VIEW);
 776                 m_DestroySettingsPopup();
 777                 m_CreateSettingsPopup();
 778                 break;
 779
 780         case EO_BTN_SHUFFLE:
 781                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 782
 783                 switch (m->controller.ShuffleState()) {
 784                 case SHUFFLE_STATUS_OFF:
 785                         m->controller.SetShuffleState(SHUFFLE_STATUS_ON);
 786                         elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
 787                         break;
 788
 789                 default:
 790                         m->controller.SetShuffleState(SHUFFLE_STATUS_OFF);
 791                         elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
 792                         break;
 793                 }
 794                 break;
 795
 796         case EO_BTN_REPEAT:
 797                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 798
 799                 switch (m->controller.RepeatState()) {
 800                 case REPEAT_STATUS_NONE:
 801                         m->controller.SetRepeatState(REPEAT_STATUS_ALL);
 802                         elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
 803                         break;
 804
 805                 case REPEAT_STATUS_ALL:
 806                         m->controller.SetRepeatState(REPEAT_STATUS_ONE);
 807                         elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
 808                         break;
 809
 810                 default:
 811                         m->controller.SetRepeatState(REPEAT_STATUS_NONE);
 812                         elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
 813                         break;
 814                 }
 815                 break;
 816
 817         case EO_BTN_PLAY:
 818                 elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
 819
 820                 switch (m->controller.PlayState()) {
 821                 case PLAY_STATUS_PAUSE:
 822                         m->controller.Resume();
 823                         elm_object_signal_emit(obj, MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
 824                         break;
 825
 826                 case PLAY_STATUS_PLAY:
 827                         elm_object_signal_emit(obj, MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
 828                         m->controller.Pause();
 829                         break;
 830
 831                 default:
 832                         m->controller.Start();
 833                         break;
 834                 }
 835                 break;
 836
 837         default:
 838                 break;
 839         }
 840 }