Playback module make events when playback status is changed.
Change-Id: I7a5e9da3b9ed54c62335126e4da4d2eb7abe91c7
Signed-off-by: Kim Youngjin <yj21c.kim@samsung.com>
src/views/RemovePopupWindow.cpp
src/playback/playlist-mgr.cpp
src/playback/music-controller.cpp
+ src/playback/MusicControllerImpl.cpp
src/playback/playback-mgr.cpp
src/playback/volume-control.cpp
src/data/mediadata.cpp
#include <Eina.h>
#include <UsbConnectionListener.h>
+#include "playback-mgr.h"
class IMusicControllerListener {
};
public:
- static void s_CbComplete(void *cookie);
- static void s_CbError(void *cookie);
- static void s_CbUsbStatusChagned(void *cookie, SUsbStorageStatus status);
- static void s_CbUpdateContent(void *cookie);
-
- virtual void OnComplete(void) = 0;
- virtual void OnError(void) = 0;
- virtual void OnUsbStatusChanged(SUsbStorageStatus status) = 0;
- virtual void OnUpdateContent(void) = 0;
+ //! This function is invoked when playback is complete.
+ virtual void OnComplete(void) {}
+ //! This function is invoked when playback occurs any error.
+ virtual void OnError(void) {}
+ //! This function is invoked when usb is connected or not.
+ virtual void OnUsbStatusChanged(SUsbStorageStatus status) {}
+ //! This function is invoked when content is updated..
+ virtual void OnUpdateContent(void) {}
+ //! This function is invoked when new song is played.
+ virtual void OnStartPlayback(void) {}
+ //! This function is invoked when the playback is stopped.
+ virtual void OnStopPlayback(void) {}
+ //! This function is invoked when playback is paused.
+ virtual void OnPausePlayback(void) {}
+ //! This function is invoked when playback is resumed.
+ virtual void OnResumePlayback(void) {}
+ //!
+ virtual void OnPosition(int milsec) {}
};
-class CMusicController : public CUsbConnectionListener {
+class CMusicController {
private:
- static CMusicController *instance;
- static int refCnt;
-
struct SMusicController *m;
-private:
- enum EDirectionType {
- DIR_PREVIOUS,
- DIR_NEXT
- };
-
- enum ENextType {
- E_ON_COMPLETE,
- E_BUTTON_CLICK
- };
-
-private:
- CMusicController() {}
- virtual ~CMusicController() {}
-
-private:
- static void sm_CbPlaybackCompletion(void *data);
- void m_OnPlaybackCompletion(void);
- static void sm_CbContentUpdated(void *dt);
- void m_OnContentUpdated(void);
-
- void m_InvokeErrorCallback(SMusicController *m, int type);
-
-protected:
- bool t_PlayNext(int direction, int playnext_type);
- SMusicController* t_Create(void);
- void t_Destroy(void);
-
public:
- static bool Initialize(void);
- static void Finalize(void);
-
- static CMusicController* GetInstance(void);
+ CMusicController() : m(0) {}
+ virtual ~CMusicController() {}
+ bool FlagCreate(void) { return !!m; }
+ bool Create(void);
+ virtual void Destroy(void);
+
bool Start(void);
bool Stop(void);
bool Resume(void);
bool GetCurrentSongIndex(int *ind);
bool GetTotalSongs(int *ts);
bool GetSonginfoFromIndex(int index, CSongInfo **const csinfo);
-
+
bool SetPosition(int milsec);
bool GetPosition(int *const milseconds);
bool UpdatePlaylist(Eina_List *slist, int addmode);
bool EmptyPlaylist(void);
+
bool PlayPreviousSong(void);
bool PlayNextSong(void);
bool PlayIndexSong(int index);
+
bool RemoveSong(CSongInfo *sinfo, int index);
bool MediaGetList(int EListType, void *info, Eina_List **list);
bool SetRepeatState(ERepeatStatus state);
ERepeatStatus RepeatState(void);
-
-public:
- virtual void OnStatusChanged(SUsbHostDeviceInfo *changedDevice,
- SUsbHostDeviceStatus status);
};
-
#endif /*__MUSIC_CONTROLLER_H__*/
#include <player.h>
+class ICompleteListener {
+public:
+ virtual void t_OnPlayComplete(void) = 0;
+};
+
+
class CPlayback {
private:
struct SPlayback* m;
-public:
+private:
+ static void sm_CbComplete(void *cookie);
+public:
CPlayback() : m(0) {}
virtual ~CPlayback() {}
bool FlagCreate(void) { return !!m; }
bool Create(void);
virtual void Destroy(void);
- bool SetCallback(player_completed_cb cbPlaybackCompletion, void *data);
+ bool SetCallback(ICompleteListener *listener);//player_completed_cb cbPlaybackCompletion, void *data);
bool UnsetCallback(void);
bool Start(void);
struct SItemInfo;
+class CSliderWidget :
+ public CListenerMgr,
+ public IMusicControllerListener,
+ public IMouseMoveListener,
+ public IChangedListener {
+private:
+ struct SSliderWidget *m;
+
+private:
+ static Eina_Bool sm_CbUpdateSlider(void *dt);
+ Eina_Bool m_OnUpdateSlider(void);
+
+ bool m_AddSlider(void);
+ void m_RemoveTimer(void);
+
+ void m_UpdateSongInfo(void);
+
+public:
+ CSliderWidget() :
+ IMouseMoveListener(this),
+ IChangedListener(this),
+ m(0) {}
+ virtual ~CSliderWidget() {}
+
+ bool Create(Evas_Object *eoParent);
+ virtual void Destroy(void);
+
+ Evas_Object* Base(void);
+
+ void Init(void);
+
+ //! This function is invoked when playback is complete.
+ virtual void OnComplete(void);
+ //! This function is invoked when new song is played.
+ virtual void OnStartPlayback(void);
+ //!
+ virtual void OnStopPlayback(void);
+ //! This function is invoked when playback is paused.
+ virtual void OnPausePlayback(void);
+ //! This function is invoked when playback is resumed.
+ virtual void OnResumePlayback(void);
+ //!
+ virtual void OnPosition(int milsec);
+
+ virtual void OnChanged(int id, Evas_Object *obj);
+ virtual void OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev);
+};
+
+
+class CTimer {
+private:
+ struct STimer *m;
+
+private:
+ static Eina_Bool sm_CbTimer(void *data);
+
+protected:
+ virtual void t_OnTimer(int id);
+
+public:
+ CTimer() : m(0) {}
+ virtual ~CTimer() {}
+
+ bool Create(void);
+ virtual void Destroy(void);
+
+ bool SetTimer(int id, int ms);
+ void KillTimer(int id);
+};
+
+
class CPlaybackView : public CBaseView,
public IMouseClickedListener,
public IMouseMoveListener,
public IPressedListener,
public IUnpressedListener,
- public IChangedListener,
public IRealizedListener,
public IActivatedListener,
- public IMusicControllerListener {
+ public IMusicControllerListener,
+ public CTimer {
private:
struct SPlaybackView* m;
private:
- static Eina_Bool sm_CbUpdateSlider(void *dt);
+ //static Eina_Bool sm_CbUpdateSlider(void *dt);
static Eina_Bool sm_CbLongpressTimer(void *dt);
void m_OnLongpressTimer(void);
void m_HandleOnRepeated(void);
void m_DeleteSelectedItems(void);
- void m_AddSlider(void);
void m_AddAlbumCover(void);
void m_AddCurrentSonginfo(void);
void m_AddEditPlaylistButtons(void);
public:
CPlaybackView(const char *pViewId) : CBaseView(pViewId),
IMouseClickedListener(this), IMouseMoveListener(this),
- IPressedListener(this), IUnpressedListener(this), IChangedListener(this),
+ IPressedListener(this), IUnpressedListener(this),
IRealizedListener(this), IActivatedListener(this),
m(0) {}
virtual ~CPlaybackView() {}
virtual void OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev);
virtual void OnPressed(int id, Evas_Object *obj);
virtual void OnUnpressed(int id, Evas_Object *obj);
- virtual void OnChanged(int id, Evas_Object *obj);
virtual void OnRealized(int id, Evas_Object *obj, Elm_Object_Item *item);
virtual void OnActivated(int id, Evas_Object *obj, Elm_Object_Item *item);
virtual void OnError(void);
virtual void OnUsbStatusChanged(SUsbStorageStatus status);
virtual void OnUpdateContent(void);
+ virtual void OnStartPlayback(void);
+ virtual void OnStopPlayback(void);
};
bool SetCurrentSong(char *mediaid);
};
-/*
-struct playlist *playlist_create(Eina_List *songlist);
-struct playlist *playlist_update(struct playlist *plist, Eina_List *songlist,
- int addmode);
-void playlist_destroy(struct playlist *plist);
-
-const char *playlist_get_songpath_from_index(struct playlist *plist, int index);
-int playlist_get_songinfo_from_index(struct playlist *plist, int index,
- struct SSongInfo **const csinfo);
-int playlist_get_total_songs(struct playlist *plist, int *total_songs);
-int playlist_get_cur_song_index(struct playlist *plist, int *index);
-int playlist_set_cur_song_index(struct playlist *plist, int index);
-int playlist_load_next_song(struct playlist *plist, int shufstate);
-int playlist_load_previous_song(struct playlist *plist, int shufstate);
-int playlist_remove_song(struct playlist *plist, struct SSongInfo *sinfo,
- int index, int shufstate);
-void playlist_update_shuffle(struct playlist *plist);
-int playlist_set_current_song(struct playlist *plist, char *mediaid);
-*/
#endif /*__PLAYLIST_MGR_H__*/
CSortMgr::Finalize();
CViewMgr::Finalize();
- CMusicController::Finalize();
delete m_cBaseView;
delete m_cPlaybackView;
ad.arglist->uri = uri;
ad.arglist->source = source;
CViewMgr::Finalize();
- CMusicController::Finalize();
- _DBG("");
-
- if (!CMusicController::Initialize()) {
- _ERR(" music init failed ");
- goto error;
- }
_DBG("");
CViewMgr::Initialize(ad.win, (void*)"path");
m_pViewMgr = CViewMgr::GetInstance();
if (!m_pViewMgr) {
_ERR(" viewmgr init failed ");
- CMusicController::Finalize();
goto error;
}
_DBG("");
if (!m_pViewMgr->PushView(MUSIC_PLAYBACK_VIEW, NULL, false)) {
_ERR(" view push failed ");
CViewMgr::Finalize();
- CMusicController::Finalize();
goto error;
}
if (!m_pViewMgr->PushView(MUSIC_BASE_VIEW, ad.arglist)) {
_ERR(" view push failed ");
CViewMgr::Finalize();
- CMusicController::Finalize();
goto error;
}
_DBG("");
--- /dev/null
+/*
+* Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the License);
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an AS IS BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include <app.h>
+#include <string.h>
+#include <stdlib.h>
+#include "dbg.h"
+#include "i18n.h"
+
+#include <AppCommon.h>
+
+#include "song_info.h"
+#include "album_info.h"
+#include "folder_info.h"
+#include "common.h"
+#include "category_info.h"
+#include "music-controller.h"
+#include "MusicControllerImpl.h"
+#include "playlist-mgr.h"
+#include "playback-mgr.h"
+#include "mediadata.h"
+#include "bus.h"
+#include "Info.h"
+
+
+struct SMusicControllerImpl {
+ CPlayback *pPlayback;
+ CPlaylist* pPlaylist;
+ CMediadata* pMediadata;
+ CAlbumInfo *alinfo;
+ Eina_List *elListener;
+ int initial_index;
+
+ EPlayStatus statePlay;
+ EShuffleStatus stateShuffle;
+
+ ERepeatStatus repeatstate;
+ SCbInfo *cbinfo;
+
+ SMusicControllerImpl() {
+ pPlayback = NULL;
+ pPlaylist = NULL;
+ pMediadata = NULL;
+ alinfo = NULL;
+ elListener = NULL;
+ initial_index = 0;
+ statePlay = (EPlayStatus)0;
+ stateShuffle= (EShuffleStatus)0;
+ repeatstate= (ERepeatStatus)0;
+ cbinfo = NULL;
+ }
+};
+
+
+void CMusicControllerImpl::sm_CbContentUpdated(void *dt)
+{
+ CMusicControllerImpl *root = (CMusicControllerImpl *)dt;
+ if (root)
+ root->m_OnContentUpdated();
+}
+
+
+void CMusicControllerImpl::m_OnContentUpdated(void)
+{
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnUpdateContent();
+ }
+}
+
+
+void CMusicControllerImpl::m_InvokeErrorCallback(SMusicControllerImpl *m, int type)
+{
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+
+ if (!m)
+ return;
+
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnError();
+ }
+}
+
+
+bool CMusicControllerImpl::t_PlayNext(int direction, int playnext_type)
+{
+ bool r;
+ int index;
+
+ if (!m->pPlaylist->FlagCreate())
+ return false;
+
+ Stop();
+
+ if (playnext_type == E_ON_COMPLETE &&
+ m->repeatstate == REPEAT_STATUS_ONE)
+ goto finish;
+
+ if (direction == DIR_NEXT) {
+ r = m->pPlaylist->LoadNextSong(m->stateShuffle);
+ }
+ else {
+ r = m->pPlaylist->LoadPreviousSong(m->stateShuffle);
+ }
+
+ if (r == false) {
+ _ERR(" playlist load next/previous failed ");
+ return false;
+ }
+
+ if (playnext_type == E_ON_COMPLETE &&
+ m->repeatstate == REPEAT_STATUS_NONE) {
+ r = m->pPlaylist->GetCurSongIndex(&index);
+ if (r == false) {
+ _ERR(" get cur song index failed ");
+ return false;
+ }
+
+ if (index == m->initial_index)
+ return true;
+ }
+
+finish:
+ Start();
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::Create(void)
+{
+ ASSERT(!m);
+
+ _CREATE_BEGIN{
+ _CHECK(m = new SMusicControllerImpl)
+ _CHECK(m->alinfo = new CAlbumInfo)
+ _CHECK(m->alinfo->Create() == true)
+ _CHECK(m->pMediadata = new CMediadata)
+ _CHECK(m->pMediadata->Create() == true)
+ _CHECK(m->pPlayback = new CPlayback)
+ _CHECK(m->pPlayback->Create() == true)
+ _CHECK(m->pPlayback->SetCallback(this))
+ _CHECK(m->pPlaylist = new CPlaylist)
+
+ _WHEN_SUCCESS{
+ m->statePlay = PLAY_STATUS_INITIAL;
+ m->stateShuffle = SHUFFLE_STATUS_OFF;
+ m->repeatstate = REPEAT_STATUS_ALL;
+ m->initial_index = 0;
+ CInfo::SetSortType(E_SORT_TITLE_A_Z);
+ CInfo::SetSourceType(SOURCE_TYPE_ALL);
+ m->cbinfo = m->pMediadata->AddCallback(E_CONTENT_UPDATE, sm_CbContentUpdated, this);
+
+ // Even if CUsbConnectionListener creation failed,
+ // application should run properly.
+ if (!CUsbConnectionListener::Create())
+ _DBG("CUsbConnectionListener::Create failed");
+ }
+
+ _CHECK_FAIL{ delete m->pPlaylist; }
+ _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pPlayback->Destroy(); }
+ _CHECK_FAIL{ delete m->pPlayback; }
+ _CHECK_FAIL{ m->pMediadata->Destroy(); }
+ _CHECK_FAIL{ delete m->pMediadata; }
+ _CHECK_FAIL{ m->alinfo->Destroy(); }
+ _CHECK_FAIL{ delete m->alinfo; }
+
+ _CHECK_FAIL{ delete m; m = NULL; }
+ } _CREATE_END_AND_CATCH{ return NULL; }
+
+ return true;
+}
+
+
+void CMusicControllerImpl::Destroy(void)
+{
+ if (CUsbConnectionListener::FlagCreate())
+ CUsbConnectionListener::Destroy();
+
+ if (!m->pPlayback->UnsetCallback())
+ _ERR(" playback remove completion callback failed");
+
+ m->pPlayback->Destroy();
+ delete m->pPlayback;
+
+ if (m->pPlaylist->FlagCreate()) {
+ m->pPlaylist->Destroy();
+ }
+ delete m->pPlaylist;
+
+ m->pMediadata->RemoveCallback(m->cbinfo);
+ m->pMediadata->Destroy();
+ delete m->pMediadata;
+
+ m->alinfo->Destroy();
+ delete m->alinfo;
+ delete m;
+ m = NULL;
+}
+
+
+bool CMusicControllerImpl::Start(void)
+{
+ ASSERT(m);
+
+ const char *songpath;
+ int index;
+ CPlaylist *pPlaylist;
+ CPlayback *pPlayback;
+ CSongInfo *sinfo;
+ char *media_id;
+
+ pPlaylist = m->pPlaylist;
+ pPlayback = m->pPlayback;
+
+ _CREATE_BEGIN{
+ _CHECK(pPlaylist->FlagCreate())
+ _CHECK(pPlaylist->GetCurSongIndex(&index))
+ _CHECK(songpath = pPlaylist->SongpathFromIndex(index))
+ _CHECK(pPlayback->SetUri(songpath))
+ _CHECK(pPlayback->Prepare())
+ _CHECK(pPlayback->Start())
+
+ _COMMAND{ m->statePlay = PLAY_STATUS_PLAY; }
+
+ _CHECK(m->pPlaylist->GetSonginfoFromIndex(index, &sinfo))
+ _CHECK(media_id = sinfo->Id())
+ _CHECK(m->pMediadata->SetPlayedTime(media_id))
+
+ _WHEN_SUCCESS{
+ bus_send_signal();
+ }
+
+ _CHECK_FAIL{}
+ _CHECK_FAIL{}
+ _CHECK_FAIL{}
+
+ _CHECK_FAIL{}
+ _CHECK_FAIL{}
+ _CHECK_FAIL{ _ERR("Playback Failed!!"); m_InvokeErrorCallback(m, E_PLAYBACK_ERROR); }
+ _CHECK_FAIL{}
+ _CHECK_FAIL{}
+ _CHECK_FAIL{ _ERR("CMusicControllerImpl::Start Failed!!"); Stop(); }
+ } _CREATE_END_AND_CATCH{ return false; }
+
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnStartPlayback();
+ }
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::Stop(void)
+{
+ ASSERT(m);
+
+ if (!m->pPlayback->Stop()) {
+ _ERR("playback stop failed");
+ return false;
+ }
+
+ m->statePlay = PLAY_STATUS_STOP;
+
+ if (!m->pPlayback->Unprepare()) {
+ _ERR("playback unprepare failed");
+ return false;
+ }
+
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnStopPlayback();
+ }
+
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::Resume(void)
+{
+ ASSERT(m);
+
+ if (!m->pPlayback->Resume()) {
+ _ERR("playback resume failed");
+ return false;
+ }
+
+ m->statePlay = PLAY_STATUS_PLAY;
+
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnResumePlayback();
+ }
+ return true;
+}
+
+
+bool CMusicControllerImpl::Pause(void)
+{
+ ASSERT(m);
+
+ if (!m->pPlayback->Pause()) {
+ _ERR("playback Pause failed");
+ return false;
+ }
+
+ m->statePlay = PLAY_STATUS_PAUSE;
+
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnPausePlayback();
+ }
+
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::AddListener(IMusicControllerListener *listener)
+{
+ ASSERT(m);
+ ASSERT(listener);
+
+ m->elListener = eina_list_append(m->elListener, listener);
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::RemoveListener(IMusicControllerListener *listener)
+{
+ ASSERT(m);
+ ASSERT(listener);
+
+ m->elListener = eina_list_remove(m->elListener, listener);
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::GetCurrentSongIndex(int *ind)
+{
+ ASSERT(m);
+
+ int index;
+
+ if (!m || !m->pPlaylist->FlagCreate()) {
+ _ERR("NULL received");
+ return false;
+ }
+
+ if (!m->pPlaylist->GetCurSongIndex(&index)) {
+ _ERR(" playlist get current song index failed");
+ return false;
+ }
+
+ *ind = index;
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::GetTotalSongs(int *ts)
+{
+ ASSERT(m);
+
+ int count;
+
+ if (!m->pPlaylist->FlagCreate()) {
+ _ERR("NULL received");
+ return false;
+ }
+
+ if (!m->pPlaylist->GetTotalSongs(&count)) {
+ _ERR(" playlist get current song index failed");
+ return false;
+ }
+
+ *ts = count;
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::GetSonginfoFromIndex(int index, CSongInfo **const csinfo)
+{
+ ASSERT(m);
+
+ if (!m->pPlaylist->FlagCreate() || !csinfo) {
+ _ERR("NULL received");
+ return false;
+ }
+
+ if (!m->pPlaylist->GetSonginfoFromIndex(index, csinfo)) {
+ _ERR(" playlist get current song info failed");
+ return false;
+ }
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::SetPosition(int milseconds)
+{
+ ASSERT(m);
+
+ if (!m->pPlayback->SetPosition(milseconds)) {
+ _ERR("playback set position failed");
+ return false;
+ }
+
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnPosition(milseconds);
+ }
+ return true;
+}
+
+
+bool CMusicControllerImpl::GetPosition(int *const milseconds)
+{
+ ASSERT(m);
+
+ if (!m->pPlayback->GetPosition(milseconds)) {
+ _ERR("playback get position failed");
+ return false;
+ }
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::SetCurrentSong(char *mediaid)
+{
+ ASSERT(m);
+ ASSERT(mediaid);
+
+ if (!m->pPlaylist->FlagCreate())
+ return false;
+
+ m->pPlaylist->SetCurrentSong(mediaid);
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::GetCurrentSong(CSongInfo **const sinfo)
+{
+ ASSERT(m);
+
+ int index;
+
+ if (!m->pPlaylist->FlagCreate())
+ return false;
+
+ if (!m->pPlaylist->GetCurSongIndex(&index)) {
+ _ERR(" playlist get current song index failed");
+ return false;
+ }
+
+ if (!m->pPlaylist->GetSonginfoFromIndex(index, sinfo)) {
+ _ERR(" playlist get current song info failed");
+ return false;
+ }
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::UpdatePlaylist(Eina_List *slist, int addmode)
+{
+ ASSERT(m);
+ ASSERT(slist);
+
+ if (m->pPlaylist->FlagCreate())
+ m->pPlaylist->Update(slist, addmode);
+ else {
+ if (!m->pPlaylist->Create(slist))
+ _ERR(" playlist create failed ");
+ }
+ return true;
+}
+
+
+bool CMusicControllerImpl::EmptyPlaylist(void)
+{
+ ASSERT(m);
+
+ if (!m->pPlaylist->FlagCreate())
+ return false;
+
+ m->pPlaylist->Destroy();
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::PlayPreviousSong(void)
+{
+ ASSERT(m);
+
+ return t_PlayNext(DIR_PREVIOUS, E_BUTTON_CLICK);
+}
+
+
+bool CMusicControllerImpl::PlayNextSong(void)
+{
+ ASSERT(m);
+
+ return t_PlayNext(DIR_NEXT, E_BUTTON_CLICK);
+}
+
+
+bool CMusicControllerImpl::PlayIndexSong(int index)
+{
+ ASSERT(m);
+
+ if (!m->pPlaylist->FlagCreate())
+ return false;
+
+ Stop();
+
+ if (!m->pPlaylist->SetCurSongIndex(index))
+ return false;
+
+ Start();
+
+ m->initial_index = index;
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::RemoveSong(CSongInfo *sinfo, int index)
+{
+ ASSERT(m);
+ ASSERT(sinfo);
+
+ int ind;
+
+ if (!m->pPlaylist->FlagCreate())
+ return false;
+
+ if (!GetCurrentSongIndex(&ind)) {
+ _ERR("unable to find current song index");
+ return false;
+ }
+
+ if (!m->pPlaylist->RemoveSong(sinfo, index, m->stateShuffle)) {
+ _ERR("Song can not be deleted");
+ return false;
+ }
+
+ if (ind != 0 && ind == index)
+ Stop();
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::MediaGetList(int EListType, void *info, Eina_List **list)
+{
+ ASSERT(m);
+
+ Eina_List *mlist;
+
+ mlist = m->pMediadata->Medialist(CInfo::SourceType(), EListType, info);
+ if (!mlist)
+ return false;
+
+ *list = eina_list_clone(mlist);
+
+ return true;
+}
+
+
+bool CMusicControllerImpl::MediaInsertPlaylist(const char *name, Eina_List *idlist)
+{
+ ASSERT(m);
+ ASSERT(name);
+ ASSERT(idlist);
+
+ return m->pMediadata->Alloc(name, idlist);
+}
+
+
+bool CMusicControllerImpl::MediaExistPlaylist(const char *name)
+{
+ ASSERT(m);
+ ASSERT(name);
+
+ return m->pMediadata->ExistPlaylist(name);
+}
+
+
+bool CMusicControllerImpl::MediaDeletePlaylist(int id)
+{
+ ASSERT(m);
+
+ return m->pMediadata->Delete(id);
+}
+
+
+bool CMusicControllerImpl::MediaRenamePlaylist(int id, const char *name)
+{
+ ASSERT(m);
+ ASSERT(name);
+
+ return m->pMediadata->Rename(id, name);
+}
+
+
+bool CMusicControllerImpl::MediaAddmediaPlaylist(int id, Eina_List *idlist)
+{
+ ASSERT(m);
+ ASSERT(idlist);
+
+ return m->pMediadata->Insert(id, idlist);
+}
+
+
+bool CMusicControllerImpl::MediaRemovemediaPlaylist(int id, Eina_List *idlist)
+{
+ ASSERT(m);
+ ASSERT(idlist);
+
+ return m->pMediadata->Remove(id, idlist);
+}
+
+
+bool CMusicControllerImpl::MediaAddsongsPlaylist(int lid, Eina_List *list)
+{
+ ASSERT(m);
+ ASSERT(list);
+
+ Eina_List *idlist, *l;
+ CSongInfo *sinfo;
+ void *obj;
+ char *id;
+
+ idlist = NULL;
+ EINA_LIST_FOREACH(list, l, obj) {
+ sinfo = (CSongInfo *)obj;
+ id = sinfo->Id();
+ if (id)
+ idlist = eina_list_append(idlist, id);
+ }
+
+ if (!MediaAddmediaPlaylist(lid, idlist)) {
+ _ERR(" Failed to add songs to playlist ");
+ return false;
+ }
+
+ return true;
+}
+
+
+CSongInfo *CMusicControllerImpl::MediaSongByUri(char *uri)
+{
+ ASSERT(m);
+ ASSERT(uri);
+
+ CSongInfo *sinfo;
+
+ sinfo = m->pMediadata->SongByUri(uri);
+ if (!sinfo)
+ return NULL;
+
+ return sinfo;
+}
+
+
+bool CMusicControllerImpl::SetPlayState(EPlayStatus state)
+{
+ ASSERT(m);
+
+ m->statePlay = state;
+
+ return true;
+}
+
+
+EPlayStatus CMusicControllerImpl::PlayState(void)
+{
+ ASSERT(m);
+
+ return m->statePlay;
+}
+
+
+bool CMusicControllerImpl::SetShuffleState(EShuffleStatus state)
+{
+ ASSERT(m);
+
+ m->stateShuffle = state;
+ if (state && m->pPlaylist->FlagCreate())
+ m->pPlaylist->UpdateShuffle();
+
+ return true;
+}
+
+
+EShuffleStatus CMusicControllerImpl::ShuffleState(void)
+{
+ ASSERT(m);
+
+ return m->stateShuffle;
+}
+
+
+bool CMusicControllerImpl::SetRepeatState(ERepeatStatus state)
+{
+ ASSERT(m);
+
+ m->repeatstate = state;
+
+ return true;
+}
+
+
+ERepeatStatus CMusicControllerImpl::RepeatState(void)
+{
+ ASSERT(m);
+
+ return m->repeatstate;
+}
+
+
+void CMusicControllerImpl::OnStatusChanged(SUsbHostDeviceInfo *changedDevice,
+ SUsbHostDeviceStatus status)
+{
+ if (!m)
+ return;
+
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;;
+ void *obj;
+
+ if (status == USB_HOST_DEV_CONNECTED) {
+ if (CInfo::SourceType() == SOURCE_TYPE_USB) {
+ if (!FlagConnected())
+ CInfo::SetSourceType(SOURCE_TYPE_ALL);
+ }
+
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnUsbStatusChanged(IMusicControllerListener::USB_STORAGE_CONNECTED);
+ }
+ }
+ else {
+ if (CInfo::SourceType() == SOURCE_TYPE_USB) {
+ CInfo::SetSourceType(SOURCE_TYPE_ALL);
+ }
+
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnUsbStatusChanged(IMusicControllerListener::USB_STORAGE_DISCONNECTED);
+ }
+ }
+}
+
+
+void CMusicControllerImpl::t_OnPlayComplete(void)
+{
+ bool r;
+ Eina_List *l;
+ IMusicControllerListener *mcListener = NULL;
+ void *obj;
+
+ r = t_PlayNext(DIR_NEXT, E_ON_COMPLETE);
+ if (r == false)
+ _ERR(" music play next song failed ");
+
+ EINA_LIST_FOREACH(m->elListener, l, obj) {
+ mcListener = (IMusicControllerListener *)obj;
+ if (mcListener)
+ mcListener->OnComplete();
+ }
+}
--- /dev/null
+/*
+* Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the License);
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an AS IS BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __MUSIC_CONTROLLER_IMPL_H__
+#define __MUSIC_CONTROLLER_IMPL_H__
+
+
+class CMusicControllerImpl :
+ public CUsbConnectionListener,
+ public ICompleteListener {
+private:
+ struct SMusicControllerImpl *m;
+
+private:
+ enum EDirectionType {
+ DIR_PREVIOUS,
+ DIR_NEXT
+ };
+
+ enum ENextType {
+ E_ON_COMPLETE,
+ E_BUTTON_CLICK
+ };
+
+private:
+ static void sm_CbContentUpdated(void *dt);
+ void m_OnContentUpdated(void);
+
+ void m_InvokeErrorCallback(SMusicControllerImpl *m, int type);
+
+protected:
+ bool t_PlayNext(int direction, int playnext_type);
+
+public:
+ CMusicControllerImpl() {}
+ virtual ~CMusicControllerImpl() {}
+
+ bool Create(void);
+ virtual void Destroy(void);
+
+ bool Start(void);
+ bool Stop(void);
+ bool Resume(void);
+ bool Pause(void);
+
+ bool AddListener(IMusicControllerListener *listener);
+ bool RemoveListener(IMusicControllerListener *listener);
+
+ bool GetCurrentSongIndex(int *ind);
+ bool GetTotalSongs(int *ts);
+ bool GetSonginfoFromIndex(int index, CSongInfo **const csinfo);
+
+ bool SetPosition(int milsec);
+ bool GetPosition(int *const milseconds);
+
+ bool SetCurrentSong(char *mediaid);
+ bool GetCurrentSong(CSongInfo **const sinfo);
+
+ bool UpdatePlaylist(Eina_List *slist, int addmode);
+ bool EmptyPlaylist(void);
+
+ bool PlayPreviousSong(void);
+ bool PlayNextSong(void);
+ bool PlayIndexSong(int index);
+
+ bool RemoveSong(CSongInfo *sinfo, int index);
+
+ bool MediaGetList(int EListType, void *info, Eina_List **list);
+ bool MediaInsertPlaylist(const char *name, Eina_List *idlist);
+ bool MediaExistPlaylist(const char *name);
+ bool MediaDeletePlaylist(int id);
+ bool MediaRenamePlaylist(int id, const char *name);
+ bool MediaAddmediaPlaylist(int id, Eina_List *idlist);
+ bool MediaRemovemediaPlaylist(int id, Eina_List *idlist);
+ bool MediaAddsongsPlaylist(int lid, Eina_List *list);
+
+ CSongInfo *MediaSongByUri(char *uri);
+
+ bool SetPlayState(EPlayStatus state);
+ EPlayStatus PlayState(void);
+
+ bool SetShuffleState(EShuffleStatus state);
+ EShuffleStatus ShuffleState(void);
+
+ bool SetRepeatState(ERepeatStatus state);
+ ERepeatStatus RepeatState(void);
+
+public:
+ virtual void OnStatusChanged(SUsbHostDeviceInfo *changedDevice,
+ SUsbHostDeviceStatus status);
+
+ virtual void t_OnPlayComplete(void);
+};
+
+
+#endif /* __MUSIC_CONTROLLER_IMPL_H__ */
\ No newline at end of file
-/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <app.h>
#include <string.h>
#include <stdlib.h>
#include "dbg.h"
-#include "i18n.h"
-
#include <AppCommon.h>
-
#include "song_info.h"
-#include "album_info.h"
-#include "folder_info.h"
#include "common.h"
-#include "category_info.h"
#include "music-controller.h"
-#include "playlist-mgr.h"
-#include "playback-mgr.h"
-#include "mediadata.h"
-#include "bus.h"
-#include "Info.h"
+#include "MusicControllerImpl.h"
struct SMusicController {
- CPlayback* pPlayback;
- CPlaylist* pPlaylist;
- CMediadata* pMediadata;
- CAlbumInfo *alinfo;
- Eina_List *elListener;
- int initial_index;
-
- EPlayStatus statePlay;
- EShuffleStatus stateShuffle;
-
- ERepeatStatus repeatstate;
- SCbInfo *cbinfo;
+ static CMusicControllerImpl ref;
+ static int refCnt;
};
-CMusicController *CMusicController::instance = NULL;
-int CMusicController::refCnt = 0;
-
-
-// Implementation of IMusicControllerListener
-void IMusicControllerListener::s_CbComplete(void *cookie)
-{
- IMusicControllerListener *root = (IMusicControllerListener *)cookie;
- if (root)
- root->OnComplete();
-}
-
-
-void IMusicControllerListener::s_CbError(void *cookie)
-{
- IMusicControllerListener *root = (IMusicControllerListener *)cookie;
- if (root)
- root->OnError();
-}
-
-
-void IMusicControllerListener::s_CbUsbStatusChagned(void *cookie, SUsbStorageStatus status)
-{
- IMusicControllerListener *root = (IMusicControllerListener *)cookie;
- if (root)
- root->OnUsbStatusChanged(status);
-}
-
-
-void IMusicControllerListener::s_CbUpdateContent(void *cookie)
-{
- IMusicControllerListener *root = (IMusicControllerListener *)cookie;
- if (root)
- root->OnUpdateContent();
-}
-
-
-// Implementation of CMusicController
-void CMusicController::sm_CbPlaybackCompletion(void *dt)
-{
- CMusicController* root = (CMusicController*)dt;
- if (root)
- root->m_OnPlaybackCompletion();
-}
-
-
-void CMusicController::m_OnPlaybackCompletion(void)
-{
- bool r;
- Eina_List *l;
- IMusicControllerListener *mcListener = NULL;
- void *obj;
-
- r = t_PlayNext(DIR_NEXT, E_ON_COMPLETE);
- if (r == false)
- _ERR(" music play next song failed ");
-
- EINA_LIST_FOREACH(m->elListener, l, obj) {
- mcListener = (IMusicControllerListener *)obj;
- if (mcListener)
- mcListener->s_CbComplete(mcListener);
- }
-}
-
-
-void CMusicController::sm_CbContentUpdated(void *dt)
-{
- CMusicController *root = (CMusicController *)dt;
- if (root)
- root->m_OnContentUpdated();
-}
-
-
-void CMusicController::m_OnContentUpdated(void)
-{
- Eina_List *l;
- IMusicControllerListener *mcListener = NULL;
- void *obj;
-
- EINA_LIST_FOREACH(m->elListener, l, obj) {
- mcListener = (IMusicControllerListener *)obj;
- if (mcListener)
- mcListener->s_CbUpdateContent(mcListener);
- }
-}
+CMusicControllerImpl SMusicController::ref;
+int SMusicController::refCnt = 0;
-void CMusicController::m_InvokeErrorCallback(SMusicController *m, int type)
+bool CMusicController::Create(void)
{
- Eina_List *l;
- IMusicControllerListener *mcListener = NULL;
- void *obj;
+ ASSERT(!m);
+ m = new SMusicController;
if (!m)
- return;
-
- EINA_LIST_FOREACH(m->elListener, l, obj) {
- mcListener = (IMusicControllerListener *)obj;
- if (mcListener)
- mcListener->s_CbError(mcListener);
- }
-}
-
-
-bool CMusicController::t_PlayNext(int direction, int playnext_type)
-{
- bool r;
- int index;
-
- if (!m->pPlaylist->FlagCreate())
- return false;
-
- Stop();
-
- if (playnext_type == E_ON_COMPLETE &&
- m->repeatstate == REPEAT_STATUS_ONE)
- goto finish;
-
- if (direction == DIR_NEXT) {
- r = m->pPlaylist->LoadNextSong(m->stateShuffle);
- }
- else {
- r = m->pPlaylist->LoadPreviousSong(m->stateShuffle);
- }
-
- if (r == false) {
- _ERR(" playlist load next/previous failed ");
return false;
- }
- if (playnext_type == E_ON_COMPLETE &&
- m->repeatstate == REPEAT_STATUS_NONE) {
- r = m->pPlaylist->GetCurSongIndex(&index);
- if (r == false) {
- _ERR(" get cur song index failed ");
+ if (m->refCnt == 0) {
+ if (!m->ref.Create()) {
+ delete m;
+ m = NULL;
return false;
}
-
- if (index == m->initial_index)
- return true;
}
-
-finish:
- Start();
+ m->refCnt++;
return true;
}
-SMusicController *CMusicController::t_Create(void)
-{
- SMusicController *mhandle = NULL;
-
- _CREATE_BEGIN {
- _CHECK(mhandle = new SMusicController)
-
- _WHEN_SUCCESS{
- memset(mhandle, 0, sizeof(SMusicController));
-
- _CHECK(mhandle->alinfo = new CAlbumInfo)
- _CHECK(mhandle->alinfo->Create() == true)
- _CHECK(mhandle->pMediadata = new CMediadata)
- _CHECK(mhandle->pMediadata->Create() == true)
- _CHECK(mhandle->pPlayback = new CPlayback)
- _CHECK(mhandle->pPlayback->Create() == true)
- _CHECK(mhandle->pPlayback->SetCallback(sm_CbPlaybackCompletion, this) == true)
- _CHECK(mhandle->pPlaylist = new CPlaylist)
-
- _WHEN_SUCCESS{
- mhandle->statePlay = PLAY_STATUS_INITIAL;
- mhandle->stateShuffle = SHUFFLE_STATUS_OFF;
- mhandle->repeatstate = REPEAT_STATUS_ALL;
- mhandle->initial_index = 0;
- CInfo::SetSortType(E_SORT_TITLE_A_Z);
- CInfo::SetSourceType(SOURCE_TYPE_ALL);
- mhandle->cbinfo = mhandle->pMediadata->AddCallback(E_CONTENT_UPDATE, sm_CbContentUpdated, this);
-
- // Even if CUsbConnectionListener creation failed,
- // application should run properly.
- if (!CUsbConnectionListener::Create())
- _DBG("CUsbConnectionListener::Create failed");
- }
-
- _CHECK_FAIL{ delete mhandle->pPlaylist; }
- _CHECK_FAIL{}
- _CHECK_FAIL{ mhandle->pPlayback->Destroy(); }
- _CHECK_FAIL{ delete mhandle->pPlayback; }
- _CHECK_FAIL{ mhandle->pMediadata->Destroy(); }
- _CHECK_FAIL{ delete mhandle->pMediadata; }
- _CHECK_FAIL{ mhandle->alinfo->Destroy(); }
- _CHECK_FAIL{ delete mhandle->alinfo; }
- }
-
- _CHECK_FAIL{ delete mhandle; mhandle = NULL; }
- } _CREATE_END_AND_CATCH{ return NULL; }
-
- return mhandle;
-}
-
-
-void CMusicController::t_Destroy(void)
+void CMusicController::Destroy(void)
{
- if (CUsbConnectionListener::FlagCreate())
- CUsbConnectionListener::Destroy();
-
- if (!m->pPlayback->UnsetCallback())
- _ERR(" playback remove completion callback failed");
-
- m->pPlayback->Destroy();
- delete m->pPlayback;
+ ASSERT(m);
- if (m->pPlaylist->FlagCreate()) {
- m->pPlaylist->Destroy();
+ m->refCnt--;
+ if (m->refCnt == 0) {
+ m->ref.Destroy();
}
- delete m->pPlaylist;
-
- m->pMediadata->RemoveCallback(m->cbinfo);
- m->pMediadata->Destroy();
- delete m->pMediadata;
-
- m->alinfo->Destroy();
- delete m->alinfo;
delete m;
-}
-
-
-bool CMusicController::Initialize(void)
-{
- if (refCnt == 0) {
- instance = new CMusicController;
- if (instance == NULL) {
- return false;
- }
- instance->m = instance->t_Create();
- if (!instance->m) {
- _ERR("music_init failed");
- delete instance;
- instance = NULL;
- return false;
- }
- }
-
- refCnt++;
-
- return true;
-}
-
-
-void CMusicController::Finalize(void)
-{
- if (refCnt > 0) {
- refCnt--;
- }
- if (refCnt == 0) {
- if (instance) {
- instance->t_Destroy();
- delete instance;
- instance = NULL;
- }
- }
-}
-
-CMusicController* CMusicController::GetInstance(void)
-{
- return instance;
+ m = NULL;
}
{
ASSERT(m);
- const char *songpath;
- int index;
- CPlaylist *pPlaylist;
- CPlayback *pPlayback;
- CSongInfo *sinfo;
- char *media_id;
-
- pPlaylist = m->pPlaylist;
- pPlayback = m->pPlayback;
-
- _CREATE_BEGIN{
- _CHECK(pPlaylist->FlagCreate())
- _CHECK(pPlaylist->GetCurSongIndex(&index))
- _CHECK(songpath = pPlaylist->SongpathFromIndex(index))
- _CHECK(pPlayback->SetUri(songpath))
- _CHECK(pPlayback->Prepare())
- _CHECK(pPlayback->Start())
-
- _WHEN_SUCCESS{
- m->statePlay = PLAY_STATUS_PLAY;
-
- _CHECK(m->pPlaylist->GetSonginfoFromIndex(index, &sinfo))
- _CHECK(media_id = sinfo->Id())
- _CHECK(m->pMediadata->SetPlayedTime(media_id))
-
- _WHEN_SUCCESS{
- bus_send_signal();
- }
-
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- }
-
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{ _ERR("Playback Failed!!"); m_InvokeErrorCallback(m, E_PLAYBACK_ERROR); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{ _ERR("CMusicController::Start Failed!!"); Stop(); }
- } _CREATE_END_AND_CATCH{ return false; }
-
- return true;
+ return m->ref.Start();
}
{
ASSERT(m);
- if (!m->pPlayback->Stop()) {
- _ERR("playback stop failed");
- return false;
- }
-
- m->statePlay = PLAY_STATUS_STOP;
-
- if (!m->pPlayback->Unprepare()) {
- _ERR("playback unprepare failed");
- return false;
- }
-
- return true;
+ return m->ref.Stop();
}
{
ASSERT(m);
- if (!m->pPlayback->Resume()) {
- _ERR("playback resume failed");
- return false;
- }
-
- m->statePlay = PLAY_STATUS_PLAY;
-
- return true;
+ return m->ref.Resume();
}
{
ASSERT(m);
- if (!m->pPlayback->Pause()) {
- _ERR("playback Pause failed");
- return false;
- }
-
- m->statePlay = PLAY_STATUS_PAUSE;
-
- return true;
+ return m->ref.Pause();
}
bool CMusicController::AddListener(IMusicControllerListener *listener)
{
ASSERT(m);
- ASSERT(listener);
-
- m->elListener = eina_list_append(m->elListener, listener);
- return true;
+ return m->ref.AddListener(listener);
}
bool CMusicController::RemoveListener(IMusicControllerListener *listener)
{
ASSERT(m);
- ASSERT(listener);
- m->elListener = eina_list_remove(m->elListener, listener);
-
- return true;
+ return m->ref.RemoveListener(listener);
}
{
ASSERT(m);
- int index;
-
- if (!m || !m->pPlaylist->FlagCreate()) {
- _ERR("NULL received");
- return false;
- }
-
- if (!m->pPlaylist->GetCurSongIndex(&index)) {
- _ERR(" playlist get current song index failed");
- return false;
- }
-
- *ind = index;
-
- return true;
+ return m->ref.GetCurrentSongIndex(ind);
}
{
ASSERT(m);
- int count;
-
- if (!m->pPlaylist->FlagCreate()) {
- _ERR("NULL received");
- return false;
- }
-
- if (!m->pPlaylist->GetTotalSongs(&count)) {
- _ERR(" playlist get current song index failed");
- return false;
- }
-
- *ts = count;
-
- return true;
+ return m->ref.GetTotalSongs(ts);
}
{
ASSERT(m);
- if (!m->pPlaylist->FlagCreate() || !csinfo) {
- _ERR("NULL received");
- return false;
- }
-
- if (!m->pPlaylist->GetSonginfoFromIndex(index, csinfo)) {
- _ERR(" playlist get current song info failed");
- return false;
- }
-
- return true;
+ return m->ref.GetSonginfoFromIndex(index, csinfo);
}
-bool CMusicController::SetPosition(int milseconds)
+bool CMusicController::SetPosition(int milsec)
{
ASSERT(m);
- if (!m->pPlayback->SetPosition(milseconds)) {
- _ERR("playback set position failed");
- return false;
- }
-
- return true;
+ return m->ref.SetPosition(milsec);
}
{
ASSERT(m);
- if (!m->pPlayback->GetPosition(milseconds)) {
- _ERR("playback get position failed");
- return false;
- }
-
- return true;
+ return m->ref.GetPosition(milseconds);
}
bool CMusicController::SetCurrentSong(char *mediaid)
{
ASSERT(m);
- ASSERT(mediaid);
- if (!m->pPlaylist->FlagCreate())
- return false;
-
- m->pPlaylist->SetCurrentSong(mediaid);
-
- return true;
+ return m->ref.SetCurrentSong(mediaid);
}
{
ASSERT(m);
- int index;
-
- if (!m->pPlaylist->FlagCreate())
- return false;
-
- if (!m->pPlaylist->GetCurSongIndex(&index)) {
- _ERR(" playlist get current song index failed");
- return false;
- }
-
- if (!m->pPlaylist->GetSonginfoFromIndex(index, sinfo)) {
- _ERR(" playlist get current song info failed");
- return false;
- }
-
- return true;
+ return m->ref.GetCurrentSong(sinfo);
}
bool CMusicController::UpdatePlaylist(Eina_List *slist, int addmode)
{
ASSERT(m);
- ASSERT(slist);
- if (m->pPlaylist->FlagCreate())
- m->pPlaylist->Update(slist, addmode);
- else {
- if (!m->pPlaylist->Create(slist))
- _ERR(" playlist create failed ");
- }
- return true;
+ return m->ref.UpdatePlaylist(slist, addmode);
}
{
ASSERT(m);
- if (!m->pPlaylist->FlagCreate())
- return false;
-
- m->pPlaylist->Destroy();
-
- return true;
+ return m->ref.EmptyPlaylist();
}
{
ASSERT(m);
- return t_PlayNext(DIR_PREVIOUS, E_BUTTON_CLICK);
+ return m->ref.PlayPreviousSong();
}
{
ASSERT(m);
- return t_PlayNext(DIR_NEXT, E_BUTTON_CLICK);
+ return m->ref.PlayNextSong();
}
{
ASSERT(m);
- if (!m->pPlaylist->FlagCreate())
- return false;
-
- Stop();
-
- if (!m->pPlaylist->SetCurSongIndex(index))
- return false;
-
- Start();
-
- m->initial_index = index;
-
- return true;
+ return m->ref.PlayIndexSong(index);
}
bool CMusicController::RemoveSong(CSongInfo *sinfo, int index)
{
ASSERT(m);
- ASSERT(sinfo);
- int ind;
-
- if (!m->pPlaylist->FlagCreate())
- return false;
-
- if (!GetCurrentSongIndex(&ind)) {
- _ERR("unable to find current song index");
- return false;
- }
-
- if (!m->pPlaylist->RemoveSong(sinfo, index, m->stateShuffle)) {
- _ERR("Song can not be deleted");
- return false;
- }
-
- if (ind != 0 && ind == index)
- Stop();
-
- return true;
+ return m->ref.RemoveSong(sinfo, index);
}
{
ASSERT(m);
- Eina_List *mlist;
-
- mlist = m->pMediadata->Medialist(CInfo::SourceType(), EListType, info);
- if (!mlist)
- return false;
-
- *list = eina_list_clone(mlist);
-
- return true;
+ return m->ref.MediaGetList(EListType, info, list);
}
bool CMusicController::MediaInsertPlaylist(const char *name, Eina_List *idlist)
{
ASSERT(m);
- ASSERT(name);
- ASSERT(idlist);
- return m->pMediadata->Alloc(name, idlist);
+ return m->ref.MediaInsertPlaylist(name, idlist);
}
bool CMusicController::MediaExistPlaylist(const char *name)
{
ASSERT(m);
- ASSERT(name);
- return m->pMediadata->ExistPlaylist(name);
+ return m->ref.MediaExistPlaylist(name);
}
{
ASSERT(m);
- return m->pMediadata->Delete(id);
+ return m->ref.MediaDeletePlaylist(id);
}
bool CMusicController::MediaRenamePlaylist(int id, const char *name)
{
ASSERT(m);
- ASSERT(name);
- return m->pMediadata->Rename(id, name);
+ return m->ref.MediaRenamePlaylist(id, name);
}
bool CMusicController::MediaAddmediaPlaylist(int id, Eina_List *idlist)
{
ASSERT(m);
- ASSERT(idlist);
- return m->pMediadata->Insert(id, idlist);
+ return m->ref.MediaAddmediaPlaylist(id, idlist);
}
bool CMusicController::MediaRemovemediaPlaylist(int id, Eina_List *idlist)
{
ASSERT(m);
- ASSERT(idlist);
- return m->pMediadata->Remove(id, idlist);
+ return m->ref.MediaRemovemediaPlaylist(id, idlist);
}
bool CMusicController::MediaAddsongsPlaylist(int lid, Eina_List *list)
{
ASSERT(m);
- ASSERT(list);
-
- Eina_List *idlist, *l;
- CSongInfo *sinfo;
- void *obj;
- char *id;
-
- idlist = NULL;
- EINA_LIST_FOREACH(list, l, obj) {
- sinfo = (CSongInfo *)obj;
- id = sinfo->Id();
- if (id)
- idlist = eina_list_append(idlist, id);
- }
-
- if (!MediaAddmediaPlaylist(lid, idlist)) {
- _ERR(" Failed to add songs to playlist ");
- return false;
- }
- return true;
+ return m->ref.MediaAddsongsPlaylist(lid, list);
}
CSongInfo *CMusicController::MediaSongByUri(char *uri)
{
ASSERT(m);
- ASSERT(uri);
-
- CSongInfo *sinfo;
-
- sinfo = m->pMediadata->SongByUri(uri);
- if (!sinfo)
- return NULL;
- return sinfo;
+ return m->ref.MediaSongByUri(uri);
}
{
ASSERT(m);
- m->statePlay = state;
-
- return true;
+ return m->ref.SetPlayState(state);
}
{
ASSERT(m);
- return m->statePlay;
+ return m->ref.PlayState();
}
{
ASSERT(m);
- m->stateShuffle = state;
- if (state && m->pPlaylist->FlagCreate())
- m->pPlaylist->UpdateShuffle();
-
- return true;
+ return m->ref.SetShuffleState(state);
}
{
ASSERT(m);
- return m->stateShuffle;
+ return m->ref.ShuffleState();
}
{
ASSERT(m);
- m->repeatstate = state;
-
- return true;
+ return m->ref.SetRepeatState(state);
}
{
ASSERT(m);
- return m->repeatstate;
+ return m->ref.RepeatState();
}
-void CMusicController::OnStatusChanged(SUsbHostDeviceInfo *changedDevice,
- SUsbHostDeviceStatus status)
-{
- if (!m)
- return;
-
- Eina_List *l;
- IMusicControllerListener *mcListener = NULL;;
- void *obj;
-
- if (status == USB_HOST_DEV_CONNECTED) {
- if (CInfo::SourceType() == SOURCE_TYPE_USB) {
- if (!FlagConnected())
- CInfo::SetSourceType(SOURCE_TYPE_ALL);
- }
- EINA_LIST_FOREACH(m->elListener, l, obj) {
- mcListener = (IMusicControllerListener *)obj;
- if (mcListener)
- mcListener->s_CbUsbStatusChagned(mcListener,
- IMusicControllerListener::USB_STORAGE_CONNECTED);
- }
- }
- else {
- if (CInfo::SourceType() == SOURCE_TYPE_USB) {
- CInfo::SetSourceType(SOURCE_TYPE_ALL);
- }
-
- EINA_LIST_FOREACH(m->elListener, l, obj) {
- mcListener = (IMusicControllerListener *)obj;
- if (mcListener)
- mcListener->s_CbUsbStatusChagned(mcListener,
- IMusicControllerListener::USB_STORAGE_DISCONNECTED);
- }
- }
-}
\ No newline at end of file
struct SPlayback {
player_h player;
+ ICompleteListener *listener;
};
}
+void CPlayback::sm_CbComplete(void *cookie)
+{
+ CPlayback *root = (CPlayback*)cookie;
+ if (root)
+ root->m->listener->t_OnPlayComplete();
+}
+
+
bool CPlayback::Create(void)
{
ASSERT(!m);
return false;
}
+ m->listener = NULL;
+
return true;
}
}
-bool CPlayback::SetCallback(player_completed_cb on_playback_completion, void *data)
+bool CPlayback::SetCallback(ICompleteListener *listener)//player_completed_cb on_playback_completion, void *data)
{
ASSERT(m);
ASSERT(m->player);
- int r = player_set_completed_cb(m->player, on_playback_completion, data);
+ m->listener = listener;
+ int r = player_set_completed_cb(m->player, sm_CbComplete, this);// on_playback_completion, data);
if (r != PLAYER_ERROR_NONE) {
_ERR("Player set completed callaback failed");
return false;
ASSERT(m);
ASSERT(m->player);
+ m->listener = NULL;
int r = player_unset_completed_cb(m->player);
if (r != PLAYER_ERROR_NONE) {
_ERR("Player unset completed cb failed");
bool CPlayListCtxPopup::Create(Evas_Object* base, const SCallback* callback, Eina_List *playList)
{
- Eina_List *l = NULL;
- SCtxtPlaylistItem *item = NULL;
+ //Eina_List *l = NULL;
+ //SCtxtPlaylistItem *item = NULL;
_CREATE_BEGIN{
_CHECK(m = new SPlayListCtxPopup)
_CHECK(m->listSize = eina_list_count(playList))
_CHECK(m->settingTexts = new char*[m->listSize])
- _COMMAND{ memset(m->settingTexts, NULL, m->listSize * sizeof(char*)); }
+ _COMMAND{ memset(m->settingTexts, 0, m->listSize * sizeof(char*)); }
_CHECK(m->btnIds = new char*[m->listSize])
- _COMMAND{ memset(m->btnIds, NULL, m->listSize * sizeof(char*)); }
+ _COMMAND{ memset(m->btnIds, 0, m->listSize * sizeof(char*)); }
_CHECK(m->dbIds = new int[m->listSize])
- _COMMAND{ memset(m->dbIds, NULL, m->listSize * sizeof(int)); }
+ _COMMAND{ memset(m->dbIds, 0, m->listSize * sizeof(int)); }
_CHECK(m_SetBtnString(playList))
_CHECK(CCtxPopup::Create(base, callback, true))
Eina_List *alblist;
Eina_List *it_infolist;
Elm_Gengrid_Item_Class *item_class;
- CMusicController *mhandle;
+ CMusicController *pController;
CLayoutMgr *lmgr;
CViewMgr *vmgr;
SContentInfo *ctxtinfo;
if (!m->ctxtinfo || !m->ctxtinfo->context)
return;
- m->mhandle->MediaGetList(LIST_TYPE_ALBUM_SONG,
+ m->pController->MediaGetList(LIST_TYPE_ALBUM_SONG,
m->ctxtinfo->context, &list);
switch (type) {
break;
case ACTION_TYPE_ADDTO:
- if (m->mhandle->MediaAddsongsPlaylist(lid, list))
+ if (m->pController->MediaAddsongsPlaylist(lid, list))
CCommonUI::CreateMsgBox(m->base, MUSIC_TEXT_ADDTO_MSG);
else
_ERR(" Adding songs to playlist failed ");
break;
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
sinfo = (CSongInfo *)eina_list_data_get(list);
eina_list_free(list);
if (type == ACTION_TYPE_PLAY) {
- m->mhandle->Stop();
- m->mhandle->SetCurrentSong(sinfo->Id());
+ m->pController->Stop();
+ m->pController->SetCurrentSong(sinfo->Id());
}
CCommonUI::UpdatePlaybackView(mode, Layout(), m->focusedItem);
m_EmptyAlbumGrid(sort_flag);
if (!sort_flag) {
- r = m->mhandle->MediaGetList(LIST_TYPE_ALBUM, NULL, &(m->alblist));
+ r = m->pController->MediaGetList(LIST_TYPE_ALBUM, NULL, &(m->alblist));
if (r == false ||
eina_list_count(m->alblist) == 0) {
_ERR(" Fetching album list from media failed ");
ASSERT(mgr);
_CREATE_BEGIN{
- Evas_Object *base = NULL;
- Evas_Object *win = NULL;
Evas_Object *layout = NULL;
- CMusicController *mhandle = NULL;
- CViewMgr *vmgr = NULL;
CAlbumSongsLayout *layoutAlbumSongs = NULL;
SParcel parcel;
_CHECK(m = new SAlbumLayout)
- _CHECK(vmgr = CViewMgr::GetInstance())
- _CHECK(base = mgr->Base())
- _CHECK(win = vmgr->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
- _CHECK(layout = CCommonUI::AddBase(base, MUSIC_ALBUM_LAYOUT))
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
+ _CHECK(m->base = mgr->Base())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
+ _CHECK(layout = CCommonUI::AddBase(m->base, MUSIC_ALBUM_LAYOUT))
_CHECK(CExtBaseLayout::Create(layout))
- _CHECK(layoutAlbumSongs = new CAlbumSongsLayout(MUSIC_ALBUM_SONGS_LAYOUT))
- _CHECK(layoutAlbumSongs->Create(mgr))
+ _CHECK(m->layoutAlbumSongs = new CAlbumSongsLayout(MUSIC_ALBUM_SONGS_LAYOUT))
+ _CHECK(m->layoutAlbumSongs->Create(mgr))
_CHECK(mgr->AddLayout(layoutAlbumSongs))
_WHEN_SUCCESS{
else
m->album_id = NULL;
- m->win = win;
- m->base = base;
- m->vmgr = vmgr;
- m->mhandle = mhandle;
m->lmgr = mgr;
m->callback.cbHandleEmptyStatus = NULL;
m->callback.cookie = NULL;
- m->layoutAlbumSongs = layoutAlbumSongs;
m_CreateAlbumGrid();
Connect(layout, ALBUM_LAYOUT, TYPE_KEY_DOWN);
_CHECK_FAIL{ delete m->layoutAlbumSongs; }
_CHECK_FAIL{ CExtBaseLayout::Destroy(); }
_CHECK_FAIL{ evas_object_del(layout); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* Window */ }
+ _CHECK_FAIL{ /* Base() */ }
+ _CHECK_FAIL{ /* GetInstance() */}
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
free(m->ctxtinfo);
delete[] m->album_id;
+
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
Evas_Object *albumCover;
Elm_Object_Item *focused_item;
- CMusicController* mhandle;
+ CMusicController* pController;
CLayoutMgr *mgr;
CViewMgr *vmgr;
CAlbumInfo *alinfo;
break;
case ACTION_TYPE_ADDTO:
- if (m->mhandle->MediaAddsongsPlaylist(lid, list))
+ if (m->pController->MediaAddsongsPlaylist(lid, list))
CCommonUI::CreateMsgBox(m->base, MUSIC_TEXT_ADDTO_MSG);
else
_ERR(" Adding songs to playlist failed ");
break;
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (type == ACTION_TYPE_PLAY) {
- m->mhandle->Stop();
- m->mhandle->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
+ m->pController->Stop();
+ m->pController->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
}
CCommonUI::UpdatePlaybackView(mode, Layout(), m->focused_item);
/* Remove existing songlist and prepare afresh */
m_EmptySongList();
- if (!m->mhandle->MediaGetList(LIST_TYPE_ALBUM_SONG, m->alinfo, &(m->slist))) {
+ if (!m->pController->MediaGetList(LIST_TYPE_ALBUM_SONG, m->alinfo, &(m->slist))) {
_ERR(" Fetching song list from media failed ");
return;
}
list = eina_list_append(list, itinfo->sinfo);
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (mode == ADD_TYPE_FRESH) {
- m->mhandle->Stop();
+ m->pController->Stop();
if (id) /* If want to play selected song */
- m->mhandle->SetCurrentSong(id);
+ m->pController->SetCurrentSong(id);
}
CCommonUI::UpdatePlaybackView((EAddType)mode, Layout(), NULL);
ASSERT(mgr);
_CREATE_BEGIN{
- Evas_Object *base = NULL;
- Evas_Object *win = NULL;
Evas_Object *layout = NULL;
- CMusicController *mhandle = NULL;
- CViewMgr *vmgr = NULL;
- CAlbumInfo *alinfo = NULL;
_CHECK(m = new SAlbumSongsLayout)
- _CHECK(vmgr = CViewMgr::GetInstance())
- _CHECK(base = mgr->Base())
- _CHECK(win = vmgr->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
- _CHECK(layout = CCommonUI::AddBase(base, MUSIC_ALBUM_SONGS_LAYOUT))
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
+ _CHECK(m->base = mgr->Base())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
+ _CHECK(layout = CCommonUI::AddBase(m->base, MUSIC_ALBUM_SONGS_LAYOUT))
_CHECK(CExtBaseLayout::Create(layout))
- _CHECK(alinfo = new CAlbumInfo)
+ _CHECK(m->alinfo = new CAlbumInfo)
_WHEN_SUCCESS{
- m->win = win;
- m->base = base;
- m->vmgr = vmgr;
- m->mhandle = mhandle;
m->mgr = mgr;
- m->alinfo = alinfo;
Connect(layout, ALBUM_SONGS_LAYOUT, TYPE_KEY_DOWN);
SetCurrentAlbum(NULL);
}
- _CHECK_FAIL{ delete alinfo; }
+ _CHECK_FAIL{ delete m->alinfo; }
_CHECK_FAIL{ CExtBaseLayout::Destroy(); }
_CHECK_FAIL{ evas_object_del(layout); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* Window */ }
+ _CHECK_FAIL{ /* Base() */ }
+ _CHECK_FAIL{ /* GetInstance */}
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
evas_object_del(Layout());
free(m->ctxtinfo);
+
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
bool CArtistLayout::t_GetMediaList(Eina_List **list)
{
- return CMusicController::GetInstance()->MediaGetList(LIST_TYPE_ARTIST, NULL, list);
+ CMusicController mc;
+ mc.Create();
+ bool ret = mc.MediaGetList(LIST_TYPE_ARTIST, NULL, list);
+ mc.Destroy();
+ return ret;
}
Evas_Object *popup;
Elm_Transit *transit;
Evas_Object *c_grpbtn;
- CMusicController *mhandle;
+ CMusicController *pController;
CLayoutMgr *lmgr;
SArgList *arglist;
int btntype;
bool fresh_view;
bool srcBtnFocusedBySecondBtn;
- CSongLayout *layoutSong;
- CAlbumLayout *layoutAlbum;
+ CSongLayout *layoutSong;
+ CAlbumLayout *layoutAlbum;
CArtistLayout *layoutArtist;
- CGenreLayout *layoutGenre;
+ CGenreLayout *layoutGenre;
CPlaylistLayout *layoutPlaylists;
CFolderLayout *layoutFolder;
char buf[MAX_LENGTH];
int state;
- state = m->mhandle->PlayState();
+ state = m->pController->PlayState();
if (state != PLAY_STATUS_INITIAL && state != PLAY_STATUS_STOP) {
- if (!m->mhandle->GetCurrentSong(&sinfo)) {
+ if (!m->pController->GetCurrentSong(&sinfo)) {
_ERR(" failed to find song info ");
return;
}
void CMusicBaseView::m_SetSourceType(void)
{
- if (!m->arglist || !m->arglist->source || !m->mhandle)
+ if (!m->arglist || !m->arglist->source || !m->pController)
return;
if (!strcmp(g_sourceArg[SOURCE_TYPE_USB], m->arglist->source))
_CREATE_BEGIN{
Evas_Object *win = NULL;
Evas_Object *base = NULL;
- CMusicController *mhandle = NULL;
+ CMusicController *pController = NULL;
CLayoutMgr *lmgr = NULL;
CSongLayout *layoutSong = NULL;
CAlbumLayout *layoutAlbum = NULL;
_CHECK(m = new SMusicBaseView)
_CHECK(win = CViewMgr::GetInstance()->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
_CHECK(base = CCommonUI::AddBase(win, MUSIC_BASE_VIEW))
_CHECK(lmgr = new CLayoutMgr)
_CHECK(lmgr->Create(base, NULL))
_CHECK(lmgr->AddLayout(layoutFolder))
_CHECK(handleVolume = new CHandleVolume)
_CHECK(handleVolume->Create(base))
- _CHECK(mhandle->AddListener(this))
+ _CHECK(pController->AddListener(this))
_WHEN_SUCCESS{
m->base = base;
m->win = win;
- m->mhandle = mhandle;
+ m->pController = pController;
m->lmgr = lmgr;
m->fresh_view = true;
m->arglist = (SArgList *)data;
Connect(m->base, BASE_VIEW, TYPE_KEY_DOWN | TYPE_KEY_UP);
}
- _CHECK_FAIL{ m->mhandle->RemoveListener(this); }
+ _CHECK_FAIL{ m->pController->RemoveListener(this); }
_CHECK_FAIL{ handleVolume->Destroy(); }
_CHECK_FAIL{ delete handleVolume; }
_CHECK_FAIL{ lmgr->RemoveLayout(layoutFolder); }
_CHECK_FAIL{ lmgr->Destroy(); }
_CHECK_FAIL{ delete lmgr; }
_CHECK_FAIL{ evas_object_del(m->base); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* win */ }
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
{
ASSERT(m);
- m->mhandle->RemoveListener(this);
+ m->pController->RemoveListener(this);
m->pHandleVolume->Destroy();
m->lmgr->RemoveLayout(m->layoutFolder);
delete m->lmgr;
evas_object_del(m->base);
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
switch (id) {
case BASE_VIEW:
if (!strcmp(ev->keyname, KEY_EXIT)) {
- m->mhandle->Stop();
+ m->pController->Stop();
elm_exit();
}
else if (!strcmp(ev->keyname, KEY_ENTER) ||
case BASE_VIEW_GROUP_PLAYLIST:
if (!strcmp(ev->keyname, KEY_BACK) ||
!strcmp(ev->keyname, KEY_BACK_REMOTE)) {
- m->mhandle->Stop();
+ m->pController->Stop();
elm_exit();
}
break;
bool r;
int state;
- state = m->mhandle->PlayState();
+ state = m->pController->PlayState();
if (state != PLAY_STATUS_INITIAL) {
t_OnHide();
return;
}
- r = m->mhandle->MediaGetList(LIST_TYPE_SONG, NULL, &list);
+ r = m->pController->MediaGetList(LIST_TYPE_SONG, NULL, &list);
if (r == false || eina_list_count(list) == 0) {
_ERR(" No songs ");
return;
}
- m->mhandle->Stop();
- m->mhandle->UpdatePlaylist(list, ADD_TYPE_FRESH);
+ m->pController->Stop();
+ m->pController->UpdatePlaylist(list, ADD_TYPE_FRESH);
eina_list_free(list);
m_GotoPlayback();
Eina_List *songlist;
Eina_List *it_infolist;
Ecore_Idler *focusIdler;
- CMusicController *pMusicController;
+ CMusicController *pController;
CLayoutMgr *lmgr;
CViewMgr *vmgr;
CSongInfo *c_sinfo;
return;
}
- if (m->pMusicController->MediaExistPlaylist(str)) {
+ if (m->pController->MediaExistPlaylist(str)) {
CCommonUI::CreateMsgBox(Layout(), MUSIC_TEXT_INUSE_MSG);
free(str);
return;
}
- if (!m->pMusicController->MediaInsertPlaylist(str, idlist)) {
+ if (!m->pController->MediaInsertPlaylist(str, idlist)) {
_ERR("Playlist creation failed ");
free(str);
return;
return;
if (t.depth == E_DEPTH_ALBUM) {
- m->pMusicController->MediaGetList(LIST_TYPE_ALBUM_SONG,
+ m->pController->MediaGetList(LIST_TYPE_ALBUM_SONG,
t.ctxtinfo->context, &list);
sinfo = (CSongInfo *)eina_list_data_get(list);
}
EINA_LIST_FOREACH(alist, l, obj) {
alinfo = (CAlbumInfo *)obj;
slist = NULL;
- if (!m->pMusicController->MediaGetList(LIST_TYPE_ALBUM_SONG, (void *)alinfo, &slist)) {
+ if (!m->pController->MediaGetList(LIST_TYPE_ALBUM_SONG, (void *)alinfo, &slist)) {
_ERR(" Failed to get album songlist ");
continue;
}
case ACTION_TYPE_ADDTO:
{
- if (m->pMusicController->MediaAddsongsPlaylist(lid, list))
+ if (m->pController->MediaAddsongsPlaylist(lid, list))
CCommonUI::CreateMsgBox(t.base, MUSIC_TEXT_ADDTO_MSG);
else
_ERR(" Adding songs to playlist failed ");
break;
}
- m->pMusicController->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
if (type == ACTION_TYPE_PLAY) {
- m->pMusicController->Stop();
- m->pMusicController->SetCurrentSong(sinfo->Id());
+ m->pController->Stop();
+ m->pController->SetCurrentSong(sinfo->Id());
}
if (t.depth == E_DEPTH_CATEGORY) {
return;
if (mode == ADD_TYPE_FRESH) {
- m->pMusicController->Stop();
+ m->pController->Stop();
if (id) /* If want to play selected song */
- m->pMusicController->SetCurrentSong(id);
+ m->pController->SetCurrentSong(id);
}
CCommonUI::UpdatePlaybackView((EAddType)mode, Layout(), NULL);
SCatItemInfo *itinfo = NULL;
void *obj = NULL;
Eina_List *infolist = m->it_infolist;
- CMusicController *pMusicController = m->pMusicController;
+ CMusicController *pController = m->pController;
list = NULL;
EINA_LIST_FOREACH(infolist, l, obj) {
itinfo = (SCatItemInfo *)obj;
slist = NULL;
- if (!pMusicController->MediaGetList(LIST_TYPE_ALBUM_SONG, itinfo->alinfo, &slist)) {
+ if (!pController->MediaGetList(LIST_TYPE_ALBUM_SONG, itinfo->alinfo, &slist)) {
_ERR(" Failed to get album songlist ");
continue;
}
eina_list_free(slist);
}
- pMusicController->UpdatePlaylist(list, mode);
+ pController->UpdatePlaylist(list, mode);
EINA_LIST_FREE(list, obj) {
sinfo = (CSongInfo *)obj;
sinfo->Destroy();
struct SCatItemInfo *itinfo = NULL;
void *obj = NULL;
Eina_List *infolist = m->it_infolist;
- CMusicController *pMusicController = m->pMusicController;
+ CMusicController *pController = m->pController;
list = NULL;
EINA_LIST_FOREACH(infolist, l, obj) {
list = eina_list_append(list, itinfo->sinfo);
}
- pMusicController->UpdatePlaylist(list, mode);
+ pController->UpdatePlaylist(list, mode);
eina_list_free(list);
}
ASSERT(!m);
ASSERT(mgr);
+ memset(&t, 0, sizeof(SCategoryLayoutProtected));
+
_CREATE_BEGIN{
- Evas_Object *base = NULL;
- Evas_Object *win = NULL;
Evas_Object *layout = NULL;
- CMusicController *pMusicController = NULL;
- CViewMgr *vmgr = NULL;
CEntryPopup *popup = NULL;
- CCategorySongsLayout *layoutCatSongs = NULL;
- const char *catSongLayoutId = NULL;
_CHECK(m = new SCategoryLayout)
- _CHECK(vmgr = CViewMgr::GetInstance())
- _CHECK(base = mgr->Base())
- _CHECK(win = vmgr->Window())
- _CHECK(pMusicController = CMusicController::GetInstance())
- _CHECK(layout = elm_layout_add(base))
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
+ _CHECK(t.base = mgr->Base())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
+ _CHECK(layout = elm_layout_add(t.base))
_CHECK(CExtBaseLayout::Create(layout))
_CHECK(popup = new CEntryPopup)
- _CHECK(catSongLayoutId = m_CategorySongLayoutId())
- _CHECK(layoutCatSongs = new CCategorySongsLayout(catSongLayoutId))
- _CHECK(layoutCatSongs->Create(mgr, this))
- _CHECK(mgr->AddLayout(layoutCatSongs))
+ _CHECK(m->catSongLayoutId = m_CategorySongLayoutId())
+ _CHECK(m->layoutCatSongs = new CCategorySongsLayout(m->catSongLayoutId))
+ _CHECK(m->layoutCatSongs->Create(mgr, this))
+ _CHECK(mgr->AddLayout(m->layoutCatSongs))
_WHEN_SUCCESS{
- memset(&t, 0, sizeof(SCategoryLayoutProtected));
- m->win = win;
- t.base = base;
- m->vmgr = vmgr;
- m->pMusicController = pMusicController;
m->lmgr = mgr;
t.depth = E_DEPTH_CATEGORY;
m->callback.cbHandleEmptyStatus = NULL;
m->callback.cookie = NULL;
t.epopup = popup;
- m->catSongLayoutId = catSongLayoutId;
- m->layoutCatSongs = layoutCatSongs;
t_UpdateLayout(false);
Connect(Layout(), CATEGORY_LAYOUT, TYPE_KEY_DOWN);
}
- _CHECK_FAIL{ mgr->RemoveLayout(layoutCatSongs); }
+ _CHECK_FAIL{ mgr->RemoveLayout(m->layoutCatSongs); }
_CHECK_FAIL{ m->layoutCatSongs->Destroy(); }
- _CHECK_FAIL{ delete layoutCatSongs; }
+ _CHECK_FAIL{ delete m->layoutCatSongs; }
_CHECK_FAIL{}
_CHECK_FAIL{ delete popup; }
_CHECK_FAIL{ CExtBaseLayout::Destroy(); }
_CHECK_FAIL{ evas_object_del(layout); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* Window */ }
+ _CHECK_FAIL{ /* Base */ }
+ _CHECK_FAIL{ /* GetInsteance */ }
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
evas_object_del(Layout());
free(t.ctxtinfo);
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
Evas_Object *albumCover;
Ecore_Idler *focusIdler;
- CMusicController* mhandle;
+ CMusicController* pController;
CLayoutMgr *mgr;
CViewMgr *vmgr;
SContentInfo *ctxtinfo;
break;
case ACTION_TYPE_ADDTO:
- if (m->mhandle->MediaAddsongsPlaylist(lid, list))
+ if (m->pController->MediaAddsongsPlaylist(lid, list))
CCommonUI::CreateMsgBox(m->base, MUSIC_TEXT_ADDTO_MSG);
else
_ERR(" Adding songs to playlist failed ");
break;
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (type == ACTION_TYPE_PLAY) {
- m->mhandle->Stop();
- m->mhandle->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
+ m->pController->Stop();
+ m->pController->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
}
CCommonUI::UpdatePlaybackView(mode, Layout(), m->focused_item);
// event handling will be done in OnActivated function
item_select_fn = NULL;
if (m->selectType == SELECT_TYPE_REMOVE)
- m->mhandle->MediaGetList(LIST_TYPE_PLAYLISTS_SONG, m->catInfo, &(m->slist));
+ m->pController->MediaGetList(LIST_TYPE_PLAYLISTS_SONG, m->catInfo, &(m->slist));
else
- m->mhandle->MediaGetList(LIST_TYPE_SONG, NULL, &(m->slist));
+ m->pController->MediaGetList(LIST_TYPE_SONG, NULL, &(m->slist));
}
else {
item_select_fn = sm_CbSongItemSelect;
if (m->depth == DEPTH_SHOW_LIST)
- m->mhandle->MediaGetList(LIST_TYPE_PLAYLISTS_SONG, m->catInfo, &(m->slist));
+ m->pController->MediaGetList(LIST_TYPE_PLAYLISTS_SONG, m->catInfo, &(m->slist));
else
- m->mhandle->MediaGetList(LIST_TYPE_ALBUM_SONG, m->albumInfo, &(m->slist));
+ m->pController->MediaGetList(LIST_TYPE_ALBUM_SONG, m->albumInfo, &(m->slist));
}
EINA_LIST_FOREACH(m->slist, l, obj) {
list = eina_list_append(list, itinfo->sinfo);
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (mode == ADD_TYPE_FRESH) {
- m->mhandle->Stop();
+ m->pController->Stop();
if (id) /* If want to play selected song */
- m->mhandle->SetCurrentSong(id);
+ m->pController->SetCurrentSong(id);
}
CCommonUI::UpdatePlaybackView((EAddType)mode, Layout(), NULL);
if (!lid || !idlist)
return;
- if (!m->mhandle->MediaAddmediaPlaylist(lid, idlist)) {
+ if (!m->pController->MediaAddmediaPlaylist(lid, idlist)) {
_ERR(" Failed to add songs to playlist ");
return;
}
if (!lid || !idlist)
return;
- if (!m->mhandle->MediaRemovemediaPlaylist(lid, idlist)) {
+ if (!m->pController->MediaRemovemediaPlaylist(lid, idlist)) {
_ERR(" Failed to remove songs from playlist ");
return;
}
_CREATE_BEGIN{
Evas_Object *base = NULL;
- Evas_Object *win = NULL;
Evas_Object *layout = NULL;
- CMusicController *mhandle = NULL;
- CViewMgr *vmgr = NULL;
CCategoryInfo *catInfo = NULL;
_CHECK(m = new SCategorySongsLayout)
- _CHECK(vmgr = CViewMgr::GetInstance())
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
_CHECK(base = mgr->Base())
- _CHECK(win = vmgr->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
_CHECK(layout = CCommonUI::AddBase(base, MUSIC_CATEGORY_SONGS_LAYOUT))
_CHECK(CExtBaseLayout::Create(layout))
_CHECK(catInfo = new CCategoryInfo)
_WHEN_SUCCESS{
- m->win = win;
m->base = base;
- m->vmgr = vmgr;
- m->mhandle = mhandle;
m->mgr = mgr;
m->parent = parent;
m->curCatInfo = catInfo;
_CHECK_FAIL{ delete catInfo; }
_CHECK_FAIL{ CExtBaseLayout::Destroy(); }
_CHECK_FAIL{ evas_object_del(layout); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /*Window() */ }
+ _CHECK_FAIL{ /* mgr->Base() */ }
+ _CHECK_FAIL{ /* CViewMgr::GetInstance() */ }
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
evas_object_del(Layout());
free(m->ctxtinfo);
+
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
CRemovePopupWindow *popup;
CPlayListCtxPopup *ctxpopup;
Ecore_Idler *idler;
- CMusicController *mhandle;
+ CMusicController *pController;
CViewMgr *vmgr;
SContentInfo *ctxtinfo;
EContextType type;
ASSERT(!m);
ASSERT(data);
- Evas_Object *base = NULL;
- Evas_Object *win = NULL;
- CMusicController *mhandle = NULL;
- CViewMgr *mgr = NULL;
SParcel *parcel = (SParcel *)data;
SContentInfo *ctxtinfo = parcel->ctxtInfo;
}
_CREATE_BEGIN{
- _CHECK(mgr = CViewMgr::GetInstance())
- _CHECK(win = mgr->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
_CHECK(m = new SContextView)
- _CHECK(base = CCommonUI::AddBase(win, MUSIC_CONTEXT_VIEW))
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
+ _CHECK(m->base = CCommonUI::AddBase(m->win, MUSIC_CONTEXT_VIEW))
_CHECK(CBaseView::Create(data))
_WHEN_SUCCESS{
m->type = ctxtinfo->type;
- m->vmgr = mgr;
- m->win = win;
- m->mhandle = mhandle;
- m->base = base;
m->ctxtinfo = ctxtinfo;
- Connect(base, CONTEXT_VIEW, TYPE_KEY_DOWN);
+ Connect(m->base, CONTEXT_VIEW, TYPE_KEY_DOWN);
_CHECK(m_CreateFullView())
_CHECK_FAIL{}
}
_CHECK_FAIL{ CBaseView::Destroy(); }
- _CHECK_FAIL{ evas_object_del(base); }
+ _CHECK_FAIL{ evas_object_del(m->base); }
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* Window() */ }
+ _CHECK_FAIL{ /* CViewMgr::GetInstance() */ }
_CHECK_FAIL{ delete m; m = NULL; }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
} _CREATE_END_AND_CATCH{ return false; }
return true;
CBaseView::Destroy();
evas_object_del(m->base);
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
Elm_Gengrid_Item_Class *item_class;
Elm_Gengrid_Item_Class *songitem_class;
Ecore_Idler *focusIdler;
- CMusicController *mhandle;
+ CMusicController *pController;
CLayoutMgr *lmgr;
CViewMgr *vmgr;
CFolderInfo *c_finfo;
list = eina_list_append(list, sinfo);
}
else {
- m->mhandle->MediaGetList(LIST_TYPE_FOLDER_SONG,
+ m->pController->MediaGetList(LIST_TYPE_FOLDER_SONG,
m->ctxtinfo->context, &list);
sinfo = (CSongInfo *)eina_list_data_get(list);
}
break;
case ACTION_TYPE_ADDTO:
- if (m->mhandle->MediaAddsongsPlaylist(lid, list))
+ if (m->pController->MediaAddsongsPlaylist(lid, list))
CCommonUI::CreateMsgBox(m->base, MUSIC_TEXT_ADDTO_MSG);
else
_ERR(" Adding songs to playlist failed ");
break;
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (type == ACTION_TYPE_PLAY) {
- m->mhandle->Stop();
- m->mhandle->SetCurrentSong(sinfo->Id());
+ m->pController->Stop();
+ m->pController->SetCurrentSong(sinfo->Id());
}
CCommonUI::UpdatePlaybackView((EAddType)type, Layout(), m->focused_item);
}
}
else {
- r = m->mhandle->MediaGetList(LIST_TYPE_SONG, NULL, &list);
+ r = m->pController->MediaGetList(LIST_TYPE_SONG, NULL, &list);
if (r == false || eina_list_count(list) == 0)
return;
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (mode == ADD_TYPE_FRESH) {
- m->mhandle->Stop();
+ m->pController->Stop();
if (id) /* If want to play selected song */
- m->mhandle->SetCurrentSong(id);
+ m->pController->SetCurrentSong(id);
}
CCommonUI::UpdatePlaybackView((EAddType)mode, Layout(), NULL);
if (!sort_flag) {
if (m->depth == E_DEPTH_SONG) {
- r = m->mhandle->MediaGetList(LIST_TYPE_FOLDER_SONG, m->c_finfo, &(m->flist));
+ r = m->pController->MediaGetList(LIST_TYPE_FOLDER_SONG, m->c_finfo, &(m->flist));
if (r == false ||
eina_list_count(m->flist) == 0) {
_ERR(" Fetching folder list failed ");
}
}
else {
- r = m->mhandle->MediaGetList(LIST_TYPE_FOLDER,
+ r = m->pController->MediaGetList(LIST_TYPE_FOLDER,
NULL, &(m->flist));
if (r == false ||
eina_list_count(m->flist) == 0) {
ASSERT(mgr);
_CREATE_BEGIN{
- Evas_Object *base = NULL;
- Evas_Object *win = NULL;
Evas_Object *layout = NULL;
- CMusicController *mhandle = NULL;
- CViewMgr *vmgr = NULL;
_CHECK(m = new SFolderLayout)
- _CHECK(vmgr = CViewMgr::GetInstance())
- _CHECK(base = mgr->Base())
- _CHECK(win = vmgr->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
- _CHECK(layout = CCommonUI::AddBase(base, MUSIC_FOLDER_LAYOUT))
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
+ _CHECK(m->base = mgr->Base())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController);
+ _CHECK(m->pController->Create())
+ _CHECK(layout = CCommonUI::AddBase(m->base, MUSIC_FOLDER_LAYOUT))
_CHECK(CExtBaseLayout::Create(layout))
_WHEN_SUCCESS{
- m->win = win;
- m->base = base;
- m->vmgr = vmgr;
- m->mhandle = mhandle;
m->lmgr = mgr;
m->depth = E_DEPTH_FOLDER;
_CHECK_FAIL{ CExtBaseLayout::Destroy(); }
_CHECK_FAIL{ evas_object_del(layout); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* Window() */ }
+ _CHECK_FAIL{ /* Base() */}
+ _CHECK_FAIL{ /* CViewMgr::GetInstance() */ }
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
m->c_sinfo->Destroy();
delete m->c_sinfo;
free(m->ctxtinfo);
+
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
bool CGenreLayout::t_GetMediaList(Eina_List **list)
{
- return CMusicController::GetInstance()->MediaGetList(LIST_TYPE_GENRE, NULL, list);
+ CMusicController mc;
+ mc.Create();
+ bool ret = mc.MediaGetList(LIST_TYPE_GENRE, NULL, list);
+ mc.Destroy();
+ return ret;
}
#define S_INCREMENT 1000 /* milli seconds */
+////////////////////////////////////////////////////////////////////////////////
+//
+struct SSliderWidget {
+ Evas_Object *eoSlider;
+ Evas_Object *eoBase;
+
+ Ecore_Timer *etSlider;
+
+ CSongInfo *pSongInfo;
+
+ CMusicController controller;
+
+ SSliderWidget() {
+ eoSlider = NULL;
+ eoBase = NULL;
+ etSlider = NULL;
+ pSongInfo = NULL;
+ }
+};
+
+
+Eina_Bool CSliderWidget::sm_CbUpdateSlider(void *dt)
+{
+ CSliderWidget *root = (CSliderWidget*)dt;
+ Eina_Bool ret = ECORE_CALLBACK_CANCEL;
+
+ if (root)
+ ret = root->m_OnUpdateSlider();
+
+ return ret;
+}
+
+
+Eina_Bool CSliderWidget::m_OnUpdateSlider(void)
+{
+ char *timestr = NULL;
+ int value;
+ int duration;
+
+ if (!m->controller.GetPosition(&value)) {
+ m->etSlider = NULL;
+ return ECORE_CALLBACK_CANCEL;
+ }
+
+ m_UpdateSongInfo();
+
+ duration = m->pSongInfo->Duration();
+
+ value = value + S_INCREMENT;
+ if (value > duration) {
+ m->etSlider = NULL;
+ return ECORE_CALLBACK_CANCEL;
+ }
+
+ elm_slider_value_set(m->eoSlider, value);
+ timestr = CCommonUI::TimeStrFromMilSeconds(value);
+ if (timestr) {
+ elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
+ timestr);
+ free(timestr);
+ }
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+
+bool CSliderWidget::m_AddSlider(void)
+{
+ Evas_Object *eoSlider = NULL;
+
+ eoSlider = elm_slider_add(m->eoBase);
+ if (!eoSlider)
+ return false;
+
+ elm_slider_indicator_show_set(eoSlider, EINA_FALSE);
+ elm_slider_indicator_show_on_focus_set(eoSlider, EINA_FALSE);
+ elm_object_style_set(eoSlider, MUSIC_STYLE_SLIDER);
+ elm_slider_horizontal_set(eoSlider, EINA_TRUE);
+ elm_object_part_content_set(m->eoBase, MUSIC_PART_PROGRESSBAR, eoSlider);
+
+ Connect(eoSlider, TYPE_CHANGED | TYPE_MOUSE_MOVE);
+
+ evas_object_show(eoSlider);
+ m->eoSlider = eoSlider;
+
+ return true;
+}
+
+
+void CSliderWidget::m_RemoveTimer(void)
+{
+ if (m->etSlider) {
+ ecore_timer_del(m->etSlider);
+ m->etSlider = NULL;
+ }
+}
+
+
+void CSliderWidget::m_UpdateSongInfo(void)
+{
+ CSongInfo *sinfo = NULL;
+ int index;
+
+ if (!m->controller.GetCurrentSongIndex(&index)) {
+ _ERR(" music get current song index failed ");
+ return;
+ }
+
+ if (!m->controller.GetSonginfoFromIndex(index, &sinfo)) {
+ _ERR(" music get songinfo failed ");
+ return;
+ }
+ m->pSongInfo = sinfo;
+}
+
+
+bool CSliderWidget::Create(Evas_Object *eoBase)
+{
+ ASSERT(!m);
+
+ _CREATE_BEGIN{
+ _CHECK(m = new SSliderWidget)
+ _CHECK(m->controller.Create())
+ _CHECK(m->controller.AddListener(this))
+ _CHECK(m_AddSlider())
+
+ _CHECK_FAIL{}
+ _CHECK_FAIL{ m->controller.RemoveListener(this); }
+ _CHECK_FAIL{ m->controller.Destroy(); }
+ _CHECK_FAIL{ delete m; m = NULL; }
+ } _CREATE_END_AND_CATCH{ return false; }
+
+ return true;
+}
+
+
+void CSliderWidget::Destroy(void)
+{
+ ASSERT(m);
+
+ m->controller.RemoveListener(this);
+ m_RemoveTimer();
+
+ delete m;
+ m = NULL;
+}
+
+
+Evas_Object* CSliderWidget::Base(void)
+{
+ ASSERT(m);
+
+ return m->eoSlider;
+}
+
+
+void CSliderWidget::Init(void)
+{
+ elm_object_disabled_set(m->eoSlider, EINA_TRUE);
+ elm_slider_value_set(m->eoSlider, 0);
+}
+
+
+void CSliderWidget::OnComplete(void)
+{
+}
+
+
+void CSliderWidget::OnStartPlayback(void)
+{
+ int duration;
+ char *timestr = NULL;
+ double step;
+
+ elm_slider_value_set(m->eoSlider, 0);
+ elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
+
+ elm_object_disabled_set(m->eoSlider, EINA_FALSE);
+
+ m_UpdateSongInfo();
+ duration = m->pSongInfo->Duration();
+
+ m_RemoveTimer();
+ m->etSlider = ecore_timer_add(S_INTERVAL, sm_CbUpdateSlider, this);
+
+ elm_slider_min_max_set(m->eoSlider, 0, duration);
+ timestr = CCommonUI::TimeStrFromMilSeconds(duration);
+ if (timestr) {
+ elm_object_part_text_set(m->eoBase,
+ MUSIC_PART_FULLTIME, timestr);
+ free(timestr);
+ }
+
+ step = (double)SLIDER_STEP / (double)duration;
+ elm_slider_step_set(m->eoSlider, step);
+}
+
+
+void CSliderWidget::OnStopPlayback(void)
+{
+ elm_slider_value_set(m->eoSlider, 0);
+ elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
+
+ elm_object_disabled_set(m->eoSlider, EINA_TRUE);
+ m_RemoveTimer();
+}
+
+
+void CSliderWidget::OnPausePlayback(void)
+{
+ if (m->etSlider)
+ ecore_timer_freeze(m->etSlider);
+}
+
+
+void CSliderWidget::OnResumePlayback(void)
+{
+ if (m->etSlider)
+ ecore_timer_thaw(m->etSlider);
+}
+
+
+void CSliderWidget::OnPosition(int milsec)
+{
+ elm_slider_value_set(m->eoSlider, milsec);
+}
+
+
+void CSliderWidget::OnChanged(int id, Evas_Object *obj)
+{
+ char *timestr = NULL;
+ int value;
+
+ if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
+ if (m->etSlider)
+ ecore_timer_freeze(m->etSlider);
+ }
+
+ value = elm_slider_value_get(obj);
+ m->controller.SetPosition(value);
+ timestr = CCommonUI::TimeStrFromMilSeconds(value);
+ if (timestr) {
+ elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
+ timestr);
+ free(timestr);
+ }
+
+ if (m->controller.PlayState() == PLAY_STATUS_PLAY) {
+ if (m->etSlider)
+ ecore_timer_thaw(m->etSlider);
+ }
+}
+
+
+void CSliderWidget::OnMouseMove(int id, Evas *e, Evas_Object *obj, Evas_Event_Mouse_Move *ev)
+{
+ if (!elm_object_focus_get(obj))
+ elm_object_focus_set(obj, EINA_TRUE);
+}
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+struct STimer {
+ int count;
+ int s, e;
+ struct SCookie {
+ Ecore_Timer *etTimer;
+ CTimer *root;
+ int id;
+ SCookie(CTimer *timer, int _id) {
+ root = timer;
+ id = _id;
+ }
+ };
+
+ Eina_List *elList;
+};
+
+
+Eina_Bool CTimer::sm_CbTimer(void *data)
+{
+ STimer::SCookie *cookie = (STimer::SCookie*)data;
+
+ if (cookie->root)
+ cookie->root->t_OnTimer(cookie->id);
+
+ cookie->root->m->elList = eina_list_remove(cookie->root->m->elList, cookie);
+
+ delete cookie;
+
+ return EINA_FALSE;
+}
+
+
+void CTimer::t_OnTimer(int id)
+{
+}
+
+
+bool CTimer::Create(void)
+{
+ ASSERT(!m);
+
+ m = new STimer;
+ if (!m)
+ return false;
+
+ m->elList = NULL;
+
+ return true;
+}
+
+
+void CTimer::Destroy(void)
+{
+ ASSERT(m);
+
+ delete m;
+ m = NULL;
+}
+
+
+bool CTimer::SetTimer(int id, int ms)
+{
+ ASSERT(m);
+
+
+ STimer::SCookie *cookie = new STimer::SCookie(this, id);
+ if (!cookie)
+ return false;
+
+ m->elList = eina_list_append(m->elList, cookie);
+ cookie->etTimer = ecore_timer_add(ms, sm_CbTimer, cookie);
+ return true;
+}
+
+
+void CTimer::KillTimer(int id)
+{
+ ASSERT(m);
+
+
+}
+
+
+
+
+
+
enum EEvasObject {
EO_BASE,
EO_BTN_PLAY,
EO_BTN_FORWARD, // TOTAL_CONTROL_BTNS
- EO_SLIDER,
-
EO_PLAYLIST,
-
- EO_BOX,
};
bool select_status;
};
+
+enum EPressTypes {
+ PRESS_SHORT,
+ PRESS_SHORT_PAUSE,
+ PRESS_LONG,
+ PRESS_LONG_PAUSE,
+};
+
+
struct SPlaybackView {
Evas_Object *eoWin;
Evas_Object *eoBtnEdit[TOTAL_EDIT_BTNS];
Evas_Object *eoAlbumCover;
- Evas_Object *eoSlider;
+ //Evas_Object *eoSlider;
+ CSliderWidget *pSliderWidget;
Evas_Object *eoPressedObj;
Eina_List *elInfo;
- Ecore_Timer *etSlider;
Ecore_Timer *etLongPress;
Ecore_Timer *etWait;
- CMusicController *hMusicController; //! NOT NULL
+ CMusicController *pController; //! NOT NULL
CSongInfo *csinfo;
CViewMgr *mgr;
SItemInfo *cs_itinfo;
SContentInfo *ctxtinfo;
- int press_status;
+ EPressTypes press_status;
CHandleVolume *pHandleVolume;
SPlaybackView() {
memset(this, 0, sizeof(SPlaybackView));
- pHandleVolume = new CHandleVolume;
}
~SPlaybackView() {
- delete pHandleVolume;
}
};
EEvasObject type;
};
-enum EPressTypes {
- PRESS_SHORT,
- PRESS_SHORT_PAUSE,
- PRESS_LONG,
- PRESS_LONG_PAUSE,
-};
enum EControlBtns {
BTN_SETTINGS,
};
enum ETimers {
- TIMER_SLIDER,
+ //TIMER_SLIDER,
TIMER_WAIT,
TIMER_LONGPRESS,
TIMER_VOLUME
};
-Eina_Bool CPlaybackView::sm_CbUpdateSlider(void *dt)
-{
- SPlaybackView *m = (SPlaybackView *)dt;
- char *timestr = NULL;
- int value;
- int duration;
-
- if (!m)
- return ECORE_CALLBACK_CANCEL;
-
- if (!m->hMusicController->GetPosition(&value)) {
- m->etSlider = NULL;
- return ECORE_CALLBACK_CANCEL;
- }
-
- duration = m->csinfo->Duration();
-
- value = value + S_INCREMENT;
- if (value > duration) {
- m->etSlider = NULL;
- return ECORE_CALLBACK_CANCEL;
- }
-
- elm_slider_value_set(m->eoSlider, value);
- timestr = CCommonUI::TimeStrFromMilSeconds(value);
- if (timestr) {
- elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
- timestr);
- free(timestr);
- }
-
- return ECORE_CALLBACK_RENEW;
-}
-
Eina_Bool CPlaybackView::sm_CbLongpressTimer(void *dt)
{
void CPlaybackView::m_OnWaitTimer(void)
{
m->press_status = PRESS_LONG;
- if (m->hMusicController->PlayState() == PLAY_STATUS_PLAY) {
+ if (m->pController->PlayState() == PLAY_STATUS_PLAY) {
/* Handle long press */
m_PlaybackPause();
m->etLongPress = ecore_timer_add(LP_INTERVAL, sm_CbLongpressTimer, this);
break;
case BTN_CLEAR:
- m->hMusicController->Stop();
- m->hMusicController->EmptyPlaylist();
+ m->pController->Stop();
+ m->pController->EmptyPlaylist();
eina_list_free(m->elInfo);
m->elInfo = NULL;
elm_genlist_clear(m->eoPlaylist);
ETimers timerCode = (ETimers)timer_code;
switch (timerCode) {
- case TIMER_SLIDER:
- if (m->etSlider) {
- ecore_timer_del(m->etSlider);
- m->etSlider = NULL;
- }
- break;
-
case TIMER_WAIT:
if (m->etWait) {
ecore_timer_del(m->etWait);
void CPlaybackView::m_PlaybackPause(void)
{
- m->hMusicController->Pause();
-
- if (m->etSlider)
- ecore_timer_freeze(m->etSlider);
+ m->pController->Pause();
}
void CPlaybackView::m_PlaybackResume(void)
{
- m->hMusicController->Resume();
-
- if (m->etSlider)
- ecore_timer_thaw(m->etSlider);
+ m->pController->Resume();
}
{
int state;
- state = m->hMusicController->PlayState();
+ state = m->pController->PlayState();
if (state != PLAY_STATUS_STOP) {
elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_FALSE);
elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_FALSE);
elm_object_signal_emit(m->eoBtnControl[BTN_PLAY], MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
}
- state = m->hMusicController->ShuffleState();
+ state = m->pController->ShuffleState();
if (state == SHUFFLE_STATUS_OFF) {
elm_object_signal_emit(m->eoBtnControl[BTN_SHUFFLE], MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
}
elm_object_signal_emit(m->eoBtnControl[BTN_SHUFFLE], MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
}
- state = m->hMusicController->RepeatState();
+ state = m->pController->RepeatState();
if (state == REPEAT_STATUS_NONE) {
elm_object_signal_emit(m->eoBtnControl[BTN_REPEAT], MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
}
}
-void CPlaybackView::m_UpdateCurrentSongProgressbar(void)
-{
- int duration;
- char *timestr = NULL;
- double step;
- int state;
-
- if (!m->csinfo)
- return;
-
- elm_slider_value_set(m->eoSlider, 0);
- elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
-
- state = m->hMusicController->PlayState();
-
- if (state == PLAY_STATUS_STOP) {
- elm_object_disabled_set(m->eoSlider, EINA_TRUE);
- m_RemoveTimer(TIMER_SLIDER);
- return;
- }
-
- elm_object_disabled_set(m->eoSlider, EINA_FALSE);
-
- duration = m->csinfo->Duration();
- {
- m_RemoveTimer(TIMER_SLIDER);
- m->etSlider = ecore_timer_add(S_INTERVAL,
- sm_CbUpdateSlider, m);
-
- elm_slider_min_max_set(m->eoSlider, 0, duration);
- timestr = CCommonUI::TimeStrFromMilSeconds(duration);
- if (timestr) {
- elm_object_part_text_set(m->eoBase,
- MUSIC_PART_FULLTIME, timestr);
- free(timestr);
- }
-
- step = (double)SLIDER_STEP / (double)duration;
- elm_slider_step_set(m->eoSlider, step);
- }
-}
-
-
void CPlaybackView::m_UpdateCurrentSongThumbnail(void)
{
char *path = NULL;
elm_object_disabled_set(m->eoBtnControl[BTN_FORWARD], EINA_TRUE);
elm_object_disabled_set(m->eoBtnControl[BTN_REWIND], EINA_TRUE);
elm_object_disabled_set(m->eoBtnControl[BTN_PLAY], EINA_TRUE);
- elm_object_disabled_set(m->eoSlider, EINA_TRUE);
elm_object_part_text_set(m->eoBase, MUSIC_PART_FULLTIME, "00:00");
elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME, "00:00");
- elm_slider_value_set(m->eoSlider, 0);
+
+ m->pSliderWidget->Init();
+
elm_object_part_text_set(m->eoBase, MUSIC_PART_SONG_TITLE,
_(NO_PLAYLIST_MESSAGE));
elm_object_part_text_set(m->eoBase, MUSIC_PART_ARTIST_ALBUM,
snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR,
MUSIC_IMAGE_DEFAULT_THUMB_450);
elm_image_file_set(m->eoAlbumCover, buf, NULL);
- m->hMusicController->SetPlayState(PLAY_STATUS_INITIAL);
+ m->pController->SetPlayState(PLAY_STATUS_INITIAL);
}
if (pItemInfo) {
m->cs_itinfo = pItemInfo;
- if (m->hMusicController->PlayState() == PLAY_STATUS_STOP) {
+ if (m->pController->PlayState() == PLAY_STATUS_STOP) {
elm_genlist_item_bring_in(pItemInfo->item,
ELM_GENLIST_ITEM_SCROLLTO_IN);
}
void CPlaybackView::m_UpdateEditmodeFocusSequence(void)
{
- elm_object_focus_next_object_set(m->eoPlaylist,
- m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_LEFT);
- elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL],
- m->eoPlaylist, ELM_FOCUS_RIGHT);
- elm_object_focus_next_object_set(m->eoSlider, m->eoBtnEdit[BTN_CANCEL],
- ELM_FOCUS_DOWN);
+ elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_LEFT);
+ elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL], m->eoPlaylist, ELM_FOCUS_RIGHT);
+ elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnEdit[BTN_CANCEL], ELM_FOCUS_DOWN);
}
void CPlaybackView::m_UpdatePlaymodeFocusSequence(void)
{
- elm_object_focus_next_object_set(m->eoSlider, m->eoPlaylist,
- ELM_FOCUS_UP);
- elm_object_focus_next_object_set(m->eoSlider, m->eoBtnControl[BTN_PLAY],
- ELM_FOCUS_DOWN);
- if (m->hMusicController->PlayState() == PLAY_STATUS_STOP) {
- elm_object_focus_next_object_set(m->eoPlaylist,
- m->eoBtnControl[BTN_PLAY], ELM_FOCUS_LEFT);
- elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY],
- m->eoPlaylist, ELM_FOCUS_RIGHT);
+ elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoPlaylist, ELM_FOCUS_UP);
+ elm_object_focus_next_object_set(m->pSliderWidget->Base(), m->eoBtnControl[BTN_PLAY], ELM_FOCUS_DOWN);
+ if (m->pController->PlayState() == PLAY_STATUS_STOP) {
+ elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnControl[BTN_PLAY], ELM_FOCUS_LEFT);
+ elm_object_focus_next_object_set(m->eoBtnControl[BTN_PLAY], m->eoPlaylist, ELM_FOCUS_RIGHT);
}
else {
elm_object_focus_next_object_set(m->eoPlaylist,
return;
}
- if (!m->hMusicController->GetCurrentSongIndex(&index)) {
+ if (!m->pController->GetCurrentSongIndex(&index)) {
_ERR(" music get current song index failed ");
return;
}
- if (!m->hMusicController->GetSonginfoFromIndex(index, &sinfo)) {
+ if (!m->pController->GetSonginfoFromIndex(index, &sinfo)) {
_ERR(" music get songinfo failed ");
return;
}
m_UpdateCurrentSongItem(index);
m_UpdateCurrentSongLabels();
m_UpdateCurrentSongThumbnail();
- m_UpdateCurrentSongProgressbar();
+ //m_UpdateCurrentSongProgressbar();
m_UpdateControlBtns();
m_UpdatePlaymodeFocusSequence();
}
elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
}
else {
- elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL],
- m->eoBtnEdit[BTN_DESELECT], ELM_FOCUS_RIGHT);
- elm_object_focus_next_object_set(m->eoBtnEdit[BTN_DELETE],
- m->eoPlaylist, ELM_FOCUS_RIGHT);
- elm_object_focus_next_object_set(m->eoPlaylist,
- m->eoBtnEdit[BTN_DELETE], ELM_FOCUS_LEFT);
+ elm_object_focus_next_object_set(m->eoBtnEdit[BTN_CANCEL], m->eoBtnEdit[BTN_DESELECT], ELM_FOCUS_RIGHT);
+ elm_object_focus_next_object_set(m->eoBtnEdit[BTN_DELETE], m->eoPlaylist, ELM_FOCUS_RIGHT);
+ elm_object_focus_next_object_set(m->eoPlaylist, m->eoBtnEdit[BTN_DELETE], ELM_FOCUS_LEFT);
}
}
void CPlaybackView::m_CreateSettingsPopup(void)
{
- CPlaySettingCtxPopup *eoCtxPopup = new CPlaySettingCtxPopup;
CCtxPopup::SCallback cb;
cb.cookie = this;
cb.onSelected = sm_CbCtxPopupBtnSelected;
- eoCtxPopup->Create(m->eoWin, &cb);
-
- m->eoCtxPopup = eoCtxPopup;
+ m->eoCtxPopup = new CPlaySettingCtxPopup;
+ m->eoCtxPopup->Create(m->eoWin, &cb);
}
void CPlaybackView::m_FromEditToPlaybackMode(void)
{
- if (m->hMusicController->PlayState() == PLAY_STATUS_STOP) {
+ if (m->pController->PlayState() == PLAY_STATUS_STOP) {
elm_genlist_item_bring_in(m->cs_itinfo->item,
ELM_GENLIST_ITEM_SCROLLTO_IN);
}
obj = m->eoPressedObj;
- value = elm_slider_value_get(m->eoSlider);
+
+ m->pController->GetPosition(&value); //value = elm_slider_value_get(m->eoSlider);
duration = m->cs_itinfo->sinfo->Duration();
if (obj == m->eoBtnControl[BTN_REWIND]) {
}
else {
if (value == duration) {
- if (m->hMusicController->PlayNextSong())
- m_UpdateCurrentSongInfo();
- else
- _ERR(" music play next song failed ");
+ m->pController->PlayNextSong();
m->press_status = PRESS_LONG_PAUSE;
elm_object_signal_emit(m->eoBtnControl[BTN_PLAY], MUSIC_SIGNAL_PAUSE,
value = duration;
}
- m->hMusicController->SetPosition(value);
- elm_slider_value_set(m->eoSlider, value);
+ m->pController->SetPosition(value);
timestr = CCommonUI::TimeStrFromMilSeconds(value);
if (timestr) {
elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
SItemInfo *pItemInfo = NULL;
void *obj = NULL;
int index;
- bool flag = false;
m_DisableEditButtons(true);
EINA_LIST_FOREACH_SAFE(m->elInfo, l, l_next, obj) {
pItemInfo = (SItemInfo *)obj;
if (pItemInfo->check_status) {
if (m->cs_itinfo == pItemInfo) {
- flag = true;
m_UnselectItem(m->cs_itinfo);
- m_RemoveTimer(TIMER_SLIDER);
m->cs_itinfo = NULL;
- m->hMusicController->SetPlayState(PLAY_STATUS_STOP);
- m->hMusicController->Stop();
+ m->pController->SetPlayState(PLAY_STATUS_STOP);
+ m->pController->Stop();
}
index = elm_genlist_item_index_get(pItemInfo->item);
- m->hMusicController->RemoveSong(pItemInfo->sinfo, index);
+ m->pController->RemoveSong(pItemInfo->sinfo, index);
- m->elInfo = eina_list_remove(m->elInfo,
- pItemInfo);
+ m->elInfo = eina_list_remove(m->elInfo, pItemInfo);
elm_object_item_del(pItemInfo->item);
}
}
return;
}
- if (flag)
- m_UpdateCurrentSongInfo();
-
elm_genlist_realized_items_update(m->eoPlaylist);
elm_object_focus_set(m->eoBtnEdit[BTN_CANCEL], EINA_TRUE);
}
{
if (m->eoCtxPopup) {
m_DestroySettingsPopup();
- elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_FALSE);
+ //elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_FALSE);
elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
return;
}
void CPlaybackView::m_KeyExitPress(void)
{
- m_RemoveTimer(TIMER_SLIDER);
- m->hMusicController->Stop();
+ m->pController->Stop();
elm_exit();
}
if (elm_object_disabled_get(m->eoBtnControl[BTN_PLAY]))
return;
- state = m->hMusicController->PlayState();
+ state = m->pController->PlayState();
if (state == PLAY_STATUS_PAUSE) {
m_PlaybackResume();
elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
}
else if (state != PLAY_STATUS_PLAY) {
- if (m->hMusicController)
- m->hMusicController->Start();
-
- m_UpdateCurrentSongInfo();
+ m->pController->Start();
}
}
if (elm_object_disabled_get(m->eoBtnControl[BTN_PLAY]))
return;
- state = m->hMusicController->PlayState();
+ state = m->pController->PlayState();
if (state == PLAY_STATUS_PLAY) {
elm_object_signal_emit(m->eoBtnControl[BTN_PLAY],
MUSIC_SIGNAL_PAUSE, MUSIC_PLAYBACK_VIEW);
}
-void CPlaybackView::m_AddSlider(void)
-{
- Evas_Object *eoSlider = NULL;
-
- eoSlider = elm_slider_add(m->eoBase);
- if (!eoSlider)
- return;
-
- elm_slider_indicator_show_set(eoSlider, EINA_FALSE);
- elm_slider_indicator_show_on_focus_set(eoSlider, EINA_FALSE);
- elm_object_style_set(eoSlider, MUSIC_STYLE_SLIDER);
- elm_slider_horizontal_set(eoSlider, EINA_TRUE);
- elm_object_part_content_set(m->eoBase, MUSIC_PART_PROGRESSBAR, eoSlider);
-
- Connect(eoSlider, EO_SLIDER, TYPE_CHANGED | TYPE_MOUSE_MOVE);
-
- evas_object_show(eoSlider);
- m->eoSlider = eoSlider;
-}
-
-
void CPlaybackView::m_AddAlbumCover(void)
{
Evas_Object *eoAlbumCover = NULL;
void CPlaybackView::m_AddCurrentSonginfo(void)
{
m_AddAlbumCover();
- m_AddSlider();
+
+ m->pSliderWidget = new CSliderWidget;
+ m->pSliderWidget->Create(m->eoBase);
+ //m_AddSlider();
}
return;
elm_box_horizontal_set(box, EINA_TRUE);
- elm_box_padding_set(box,
- MUSIC_EDIT_BTNS_PADDING * elm_config_scale_get(), 0);
+ elm_box_padding_set(box, MUSIC_EDIT_BTNS_PADDING * elm_config_scale_get(), 0);
for (i = 0; i < TOTAL_EDIT_BTNS; i++) {
m->eoBtnEdit[i] = elm_button_add(m->eoBase);
if (!m->eoBtnEdit[i])
continue;
- elm_object_style_set(m->eoBtnEdit[i],
- MUSIC_STYLE_EDIT_BTN);
- evas_object_size_hint_weight_set(m->eoBtnEdit[i],
- EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_object_style_set(m->eoBtnEdit[i], MUSIC_STYLE_EDIT_BTN);
+ evas_object_size_hint_weight_set(m->eoBtnEdit[i], EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_box_pack_end(box, m->eoBtnEdit[i]);
elm_object_text_set(m->eoBtnEdit[i], _(btninfo[i].txt));
evas_object_show(m->eoBtnEdit[i]);
}
elm_object_part_content_set(m->eoBase, MUSIC_PART_EDITBTNS, box);
- elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE,
- MUSIC_PLAYBACK_VIEW);
+ elm_object_signal_emit(m->eoBase, MUSIC_SIGNAL_PLAYBACK_MODE, MUSIC_PLAYBACK_VIEW);
}
return;
}
- if (!m->hMusicController->GetTotalSongs(&ts)) {
+ if (!m->pController->GetTotalSongs(&ts)) {
_ERR(" music get total songs failed ");
return;
}
- if (!m->hMusicController->GetCurrentSongIndex(&index))
+ if (!m->pController->GetCurrentSongIndex(&index))
_ERR(" music get current song index failed ");
for (i = 0; i < ts; i++) {
- if (!m->hMusicController->GetSonginfoFromIndex(i, &sinfo)) {
+ if (!m->pController->GetSonginfoFromIndex(i, &sinfo)) {
_ERR(" music get songinfo failed ");
continue;
}
elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
MUSIC_PLAYBACK_VIEW);
- if (m->hMusicController->PlayState() == PLAY_STATUS_STOP)
+ if (m->pController->PlayState() == PLAY_STATUS_STOP)
return;
- if (!m->hMusicController->PlayPreviousSong()){
+ if (!m->pController->PlayPreviousSong()){
_ERR(" music play previous song failed ");
return;
}
-
- m_UpdateCurrentSongInfo();
}
elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED,
MUSIC_PLAYBACK_VIEW);
- if (m->hMusicController->PlayState() == PLAY_STATUS_STOP)
+ if (m->pController->PlayState() == PLAY_STATUS_STOP)
return;
- if (!m->hMusicController->PlayNextSong()) {
+ if (!m->pController->PlayNextSong()) {
_ERR(" music play next song failed ");
return;
}
-
- m_UpdateCurrentSongInfo();
}
if (m->press_status == PRESS_SHORT) {
/* Handle song change */
- if (m->hMusicController->PlayState() == PLAY_STATUS_PLAY)
+ if (m->pController->PlayState() == PLAY_STATUS_PLAY)
m_PlaybackPause();
if (obj == m->eoBtnControl[BTN_FORWARD])
else
m_HandleRewindBtnClicked(obj);
- if (m->hMusicController->PlayState() != PLAY_STATUS_PLAY)
+ if (m->pController->PlayState() != PLAY_STATUS_PLAY)
m_PlaybackResume();
}
else if (m->press_status == PRESS_LONG) {
- if (m->hMusicController->PlayState() != PLAY_STATUS_PLAY)
+ if (m->pController->PlayState() != PLAY_STATUS_PLAY)
m_PlaybackResume();
}
index = elm_genlist_item_index_get(genListItem);
- m->hMusicController->PlayIndexSong(--index);
- m_UpdateCurrentSongInfo();
+ m->pController->PlayIndexSong(--index);
}
_CHECK(m = new SPlaybackView)
_CHECK(m->mgr = CViewMgr::GetInstance())
_CHECK(m->eoWin = m->mgr->Window())
- _CHECK(m->hMusicController = CMusicController::GetInstance())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
_CHECK(m->eoBase = CCommonUI::AddBase(m->eoWin, MUSIC_PLAYBACK_VIEW))
_CHECK(CBaseView::Create(data))
- _CHECK(m->hMusicController->AddListener(this))
+ _CHECK(CTimer::Create());
+ _CHECK(m->pController->AddListener(this))
_WHEN_SUCCESS{
m->press_status = PRESS_SHORT;
m_AddCurrentSonginfo();
m_AddPlaylist();
+ m->pHandleVolume = new CHandleVolume;
m->pHandleVolume->Create(m->eoBase);
m_UpdatePlaymodeFocusSequence();
Connect(m->eoBase, EO_BASE, TYPE_KEY_DOWN | TYPE_KEY_UP);
}
- _CHECK_FAIL{ m->hMusicController->RemoveListener(this); }
+ _CHECK_FAIL{ m->pController->RemoveListener(this); }
+ _CHECK_FAIL{ CTimer::Destroy(); }
_CHECK_FAIL{ CBaseView::Destroy(); }
_CHECK_FAIL{ evas_object_del(m->eoBase); }
- _CHECK_FAIL{ /* CMusicController::GetInstance())*/ }
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
_CHECK_FAIL{ /* mgr->Window() */ }
_CHECK_FAIL{ /* CViewerMgr::GetInstance() */}
_CHECK_FAIL{ delete m; m = NULL; }
ASSERT(m);
Disconnect(m->eoBase);
- m->hMusicController->RemoveListener(this);
+ m->pController->RemoveListener(this);
m_DestroyErrorPopup();
- m_RemoveTimer(TIMER_SLIDER);
+ m->pSliderWidget->Destroy();
+
m_RemoveTimer(TIMER_WAIT);
m_RemoveTimer(TIMER_LONGPRESS);
m_DestroySettingsPopup();
m->pHandleVolume->Destroy();
+ delete m->pHandleVolume;
CBaseView::Destroy();
evas_object_del(m->eoBase);
{
elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
- switch (m->hMusicController->ShuffleState()) {
+ switch (m->pController->ShuffleState()) {
case SHUFFLE_STATUS_OFF:
- m->hMusicController->SetShuffleState(SHUFFLE_STATUS_ON);
+ m->pController->SetShuffleState(SHUFFLE_STATUS_ON);
elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_ON, MUSIC_PLAYBACK_VIEW);
break;
default:
- m->hMusicController->SetShuffleState(SHUFFLE_STATUS_OFF);
+ m->pController->SetShuffleState(SHUFFLE_STATUS_OFF);
elm_object_signal_emit(obj, MUSIC_SIGNAL_SHUFFLE_OFF, MUSIC_PLAYBACK_VIEW);
break;
}
{
elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
- switch (m->hMusicController->RepeatState()) {
+ switch (m->pController->RepeatState()) {
case REPEAT_STATUS_NONE:
- m->hMusicController->SetRepeatState(REPEAT_STATUS_ALL);
+ m->pController->SetRepeatState(REPEAT_STATUS_ALL);
elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ALL, MUSIC_PLAYBACK_VIEW);
break;
case REPEAT_STATUS_ALL:
- m->hMusicController->SetRepeatState(REPEAT_STATUS_ONE);
+ m->pController->SetRepeatState(REPEAT_STATUS_ONE);
elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_ONE, MUSIC_PLAYBACK_VIEW);
break;
default:
- m->hMusicController->SetRepeatState(REPEAT_STATUS_NONE);
+ m->pController->SetRepeatState(REPEAT_STATUS_NONE);
elm_object_signal_emit(obj, MUSIC_SIGNAL_REPEAT_OFF, MUSIC_PLAYBACK_VIEW);
break;
}
{
elm_object_signal_emit(obj, MUSIC_SIGNAL_BTN_CLICKED, MUSIC_PLAYBACK_VIEW);
- switch (m->hMusicController->PlayState()) {
+ switch (m->pController->PlayState()) {
case PLAY_STATUS_PAUSE:
m_PlaybackResume();
elm_object_signal_emit(obj, MUSIC_SIGNAL_PLAY, MUSIC_PLAYBACK_VIEW);
break;
default:
- if (m->hMusicController)
- m->hMusicController->Start();
- m_UpdateCurrentSongInfo();
+ if (m->pController)
+ m->pController->Start();
break;
}
}
m_UpdateCurrentSongInfo();
- state = m->hMusicController->PlayState();
+ state = m->pController->PlayState();
if (state == PLAY_STATUS_INITIAL || state == PLAY_STATUS_STOP) {
m_RemovePlaylist();
m_AddPlaylist();
- m->hMusicController->Start();
- m_UpdateCurrentSongInfo();
+ m->pController->Start();
}
if (m->cs_itinfo) {
- elm_genlist_item_show(m->cs_itinfo->item,
- ELM_GENLIST_ITEM_SCROLLTO_IN);
+ elm_genlist_item_show(m->cs_itinfo->item, ELM_GENLIST_ITEM_SCROLLTO_IN);
elm_object_item_focus_set(m->cs_itinfo->item, EINA_TRUE);
}
return;
}
- if (m->hMusicController->PlayState() == PLAY_STATUS_PLAY &&
+ if (m->pController->PlayState() == PLAY_STATUS_PLAY &&
itinfo == m->cs_itinfo)
ctxtinfo->status = PLAY_STATUS_PLAY;
else
_ERR("viewmgr push view MUSIC_CONTEXT_VIEW failed");
}
- case EO_BOX:
- if (!strcmp(ev->keyname, KEY_BACK) ||
- !strcmp(ev->keyname, KEY_BACK_REMOTE)) {
- _ERR("eoCtxPopup BACK key pressed ");
- m_DestroySettingsPopup();
- elm_object_focus_set(m->eoBtnControl[BTN_SETTINGS], EINA_TRUE);
-
- }
- else if (!strcmp(ev->keyname, KEY_EXIT)) {
- _ERR("eoCtxPopup EXIT key pressed ");
- m_DestroySettingsPopup();
- m_RemoveTimer(TIMER_SLIDER);
- m->hMusicController->Stop();
- elm_exit();
- }
- break;
-
default:
break;
}
case EO_CANCEL:
case EO_DESELECT:
case EO_DELETE:
- case EO_SLIDER:
case EO_BTN_FORWARD:
case EO_BTN_PLAY:
case EO_BTN_REPEAT:
}
-void CPlaybackView::OnChanged(int id, Evas_Object *obj)
-{
- switch (id) {
- case EO_SLIDER:
- {
- char *timestr = NULL;
- int value;
-
- if (m->hMusicController->PlayState() == PLAY_STATUS_PLAY) {
- if (m->etSlider)
- ecore_timer_freeze(m->etSlider);
- }
-
- value = elm_slider_value_get(obj);
- m->hMusicController->SetPosition(value);
- timestr = CCommonUI::TimeStrFromMilSeconds(value);
- if (timestr) {
- elm_object_part_text_set(m->eoBase, MUSIC_PART_PROGRESSTIME,
- timestr);
- free(timestr);
- }
-
- if (m->hMusicController->PlayState() == PLAY_STATUS_PLAY) {
- if (m->etSlider)
- ecore_timer_thaw(m->etSlider);
- }
- }
- break;
-
- default:
- break;
- }
-}
-
-
void CPlaybackView::OnRealized(int id, Evas_Object *obj, Elm_Object_Item *item)
{
switch (id) {
void CPlaybackView::OnUpdateContent(void)
{
}
+
+
+void CPlaybackView::OnStartPlayback(void)
+{
+ m_UpdateCurrentSongInfo();
+}
+
+
+void CPlaybackView::OnStopPlayback(void)
+{
+ m_UpdateCurrentSongInfo();
+}
t.epopup->Destroy();
- if (CMusicController::GetInstance()->MediaExistPlaylist(str)) {
+ CMusicController mc;
+ mc.Create();
+
+ if (mc.MediaExistPlaylist(str)) {
CCommonUI::CreateMsgBox(Layout(), MUSIC_TEXT_INUSE_MSG);
elm_object_item_focus_set(t.focused_item, EINA_TRUE);
free(str);
+ mc.Destroy();
return;
}
- if (!CMusicController::GetInstance()->MediaRenamePlaylist(id, str))
+ if (!mc.MediaRenamePlaylist(id, str))
_ERR(" Rename playlist failed ");
+ mc.Destroy();
t.depth = E_DEPTH_CATEGORY;
t_UpdateLayoutWithFocus();
}
case ACTION_TYPE_DELETE:
{
id = catinfo->CategoryId();
- if (!CMusicController::GetInstance()->MediaDeletePlaylist(id))
+ CMusicController mc;
+ mc.Create();
+ if (!mc.MediaDeletePlaylist(id))
_ERR(" Delete playlist failed ");
+ mc.Destroy();
t_UpdateLayout(false);
elm_object_focus_set(t.grid, EINA_TRUE);
bool CPlaylistLayout::t_GetMediaList(Eina_List **list)
{
- return CMusicController::GetInstance()->MediaGetList(LIST_TYPE_PLAYLISTS, NULL, list);
+ CMusicController mc;
+ mc.Create();
+ bool ret = mc.MediaGetList(LIST_TYPE_PLAYLISTS, NULL, list);
+ mc.Destroy();
+ return ret;
}
Eina_List *slist;
Eina_List *it_infolist;
Elm_Genlist_Item_Class *item_class;
- CMusicController *mhandle;
+ CMusicController *pController;
CLayoutMgr* mgr;
CViewMgr* vmgr;
SContentInfo *ctxtinfo;
break;
case ACTION_TYPE_ADDTO:
- if (m->mhandle->MediaAddsongsPlaylist(lid, list))
+ if (m->pController->MediaAddsongsPlaylist(lid, list))
CCommonUI::CreateMsgBox(m->base, MUSIC_TEXT_ADDTO_MSG);
else
_ERR(" Adding songs to playlist failed ");
break;
}
- m->mhandle->UpdatePlaylist(list, mode);
+ m->pController->UpdatePlaylist(list, mode);
eina_list_free(list);
if (type == ACTION_TYPE_PLAY) {
- m->mhandle->Stop();
- m->mhandle->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
+ m->pController->Stop();
+ m->pController->SetCurrentSong(((CSongInfo *)m->ctxtinfo->context)->Id());
}
CCommonUI::UpdatePlaybackView(mode, Layout(), m->focused_item);
mediaId = itinfo->sinfo->Id();
- m->mhandle->Stop();
- m->mhandle->UpdatePlaylist(m->slist, ADD_TYPE_FRESH);
- m->mhandle->SetCurrentSong(mediaId);
+ m->pController->Stop();
+ m->pController->UpdatePlaylist(m->slist, ADD_TYPE_FRESH);
+ m->pController->SetCurrentSong(mediaId);
m_GotoPlayback();
m_EmptySongList(sort_flag);
if (!sort_flag) {
- r = m->mhandle->MediaGetList(LIST_TYPE_SONG, NULL, &(m->slist));
+ r = m->pController->MediaGetList(LIST_TYPE_SONG, NULL, &(m->slist));
if (r == false || eina_list_count(m->slist) == 0) {
_ERR(" Fetching song list from media failed ");
void CSongLayout::m_GotoPlaybackUri(void)
{
Eina_List *list = NULL;
- CSongInfo *sinfo = m->mhandle->MediaSongByUri(m->uri);
+ CSongInfo *sinfo = m->pController->MediaSongByUri(m->uri);
if (!sinfo) {
_ERR(" Fetching song list from uri failed ");
return;
if (!list)
return;
- m->mhandle->UpdatePlaylist(list, ADD_TYPE_FRESH);
+ m->pController->UpdatePlaylist(list, ADD_TYPE_FRESH);
eina_list_free(list);
ASSERT(mgr);
_CREATE_BEGIN{
- Evas_Object *base = NULL;
- Evas_Object *win = NULL;
Evas_Object *layout = NULL;
- CMusicController *mhandle = NULL;
- CViewMgr *vmgr = NULL;
_CHECK(m = new SSongLayout)
- _CHECK(vmgr = CViewMgr::GetInstance())
- _CHECK(base = mgr->Base())
- _CHECK(win = vmgr->Window())
- _CHECK(mhandle = CMusicController::GetInstance())
- _CHECK(layout = CCommonUI::AddBase(base, MUSIC_SONG_LAYOUT))
+ _CHECK(m->vmgr = CViewMgr::GetInstance())
+ _CHECK(m->base = mgr->Base())
+ _CHECK(m->win = m->vmgr->Window())
+ _CHECK(m->pController = new CMusicController)
+ _CHECK(m->pController->Create())
+ _CHECK(layout = CCommonUI::AddBase(m->base, MUSIC_SONG_LAYOUT))
_CHECK(CExtBaseLayout::Create(layout))
_WHEN_SUCCESS{
else
m->uri = NULL;
- m->win = win;
- m->base = base;
- m->vmgr = vmgr;
- m->mhandle = mhandle;
m->mgr = mgr;
m_CreateSongList();
_CHECK_FAIL{ CExtBaseLayout::Destroy(); }
_CHECK_FAIL{ evas_object_del(layout); }
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
- _CHECK_FAIL{}
+ _CHECK_FAIL{ m->pController->Destroy(); }
+ _CHECK_FAIL{ delete m->pController; }
+ _CHECK_FAIL{ /* Window */ }
+ _CHECK_FAIL{ /* Base */ }
+ _CHECK_FAIL{ /* GetInstance() */ }
_CHECK_FAIL{ delete m; m = NULL; }
} _CREATE_END_AND_CATCH{ return false; }
return true;
}
+
void CSongLayout::Destroy(void)
{
ASSERT(m);
free(m->ctxtinfo);
delete[] m->uri;
+
+ m->pController->Destroy();
+ delete m->pController;
delete m;
m = NULL;
}
projects / profile / tv / apps / native / musicplayer.git / commitdiff