playermgr: convert to class

Change-Id: I7061ce9f64f9873c7a6c9d9698cc7c64544883ad
Signed-off-by: Minkyu Kang <mk7.kang@samsung.com>

diff --git a/include/playermgr.h b/include/playermgr.h
index 90dc6c6..01c66a6 100644 (file)
--- a/include/playermgr.h
+++ b/include/playermgr.h
@@ -24,49 +24,49 @@ enum display_mode {
        E_ORIGINAL
 };
 
-struct playermgr;
+struct SPlayerData;
 
-struct playermgr *playermgr_init(Evas_Object *win,
-               const char *path, const char *playlist);
+class CPlayer {
+private:
+       SPlayerData *m;
 
-int playermgr_play_video(struct playermgr *mgr);
+private:
+       bool m_Play(const char *path);
+       void m_StartFFRew(void);
 
-int playermgr_stop_video(struct playermgr *mgr);
+private:
+       static Eina_Bool sm_CbFFRew(void *dt);
 
-void playermgr_fini(struct playermgr *mgr);
+public:
+       CPlayer(void) : m(0) {}
+       virtual ~CPlayer(void) {}
 
-int playermgr_pause(struct playermgr *mgr);
+       bool Create(Evas_Object *win, const char *path, const char *playlist);
+       void Destroy(void);
 
-int playermgr_resume(struct playermgr *mgr);
+       bool Play(void);
+       bool Stop(void);
+       bool Pause(void);
+       bool Resume(void);
+       bool Prev(void);
+       bool Next(bool repeat);
 
-void playermgr_set_prev_video(struct playermgr *mgr);
+       bool SetFF(int duration);
+       bool SetRew(int duration);
+       bool GetFFRew(void);
+       void StopFFRew(void);
 
-Eina_Bool playermgr_set_next_video(struct playermgr *mgr, Eina_Bool repeat);
+       bool SetCompletedCb(player_completed_cb cb, void *data);
 
-const char *playermgr_get_video_path(struct playermgr *mgr);
+       const char *GetPath(void);
+       bool GetState(player_state_e *state);
+       bool GetPosition(int *ms);
+       bool SetPosition(int ms, player_seek_completed_cb cb, void *data);
+       int GetTotal(void);
+       int GetCurrent(void);
 
-int playermgr_get_state(struct playermgr *mgr, player_state_e *state);
-
-int playermgr_get_position(struct playermgr *mgr, int *position);
-
-int playermgr_set_position(struct playermgr *mgr,
-               int sec, player_seek_completed_cb cb, void *data);
-
-int playermgr_set_ff(struct playermgr *mgr, int duration);
-
-int playermgr_set_rew(struct playermgr *mgr, int duration);
-
-bool playermgr_get_ffrew(struct playermgr *mgr);
-
-void playermgr_stop_ffrew(struct playermgr *mgr);
-
-int playermgr_set_audio_effect(struct playermgr *mgr, int value);
-
-int playermgr_set_display_mode(struct playermgr *mgr, int value);
-
-int playermgr_set_completed_cb(struct playermgr *mgr,
-               player_completed_cb cb, void *data);
-
-void playermgr_get_play_count(struct playermgr *mgr, char *str, int len);
+       bool SetAudioEffect(int value);
+       bool SetDisplayMode(int value);
+};
 
 #endif

diff --git a/include/slider.h b/include/slider.h
index e5cbc93..a4f9416 100644 (file)
--- a/include/slider.h
+++ b/include/slider.h
@@ -53,7 +53,7 @@ public:
         * @param player the pointer of playermgr struct
         * @return if success true is returned otherwise will return false
         */
-       bool Create(Evas_Object *base, playermgr *player);
+       bool Create(Evas_Object *base, CPlayer *player);
 
        /**
         * Destroy the slider

diff --git a/src/playermgr.cpp b/src/playermgr.cpp
index 141c561..3609aad 100644 (file)
--- a/src/playermgr.cpp
+++ b/src/playermgr.cpp
@@ -16,6 +16,7 @@
 
 #include <Elementary.h>
 #include <Eina.h>
+#include <AppCommon.h>
 #include <dbg.h>
 #include "define.h"
 #include "playermgr.h"
@@ -35,7 +36,7 @@ static int _speed[] = {
        8000
 };
 
-struct playermgr {
+struct SPlayerData {
        player_h player;
        Evas_Object *win;
        Eina_List *media_list;
@@ -56,9 +57,6 @@ static void _destroy_list(Eina_List *list)
        char *buf;
        void *o;
 
-       if (!list)
-               return;
-
        EINA_LIST_FREE(list, o) {
                buf = (char *)o;
                free(buf);
@@ -108,469 +106,434 @@ static int _get_current(Eina_List *list, const char *path)
        return cur;
 }
 
-struct playermgr *playermgr_init(Evas_Object *win,
-               const char *path, const char *playlist)
+bool CPlayer::Create(Evas_Object *win, const char *path, const char *playlist)
 {
-       struct playermgr *mgr;
+       ASSERT(!m);
 
-       mgr = (playermgr *)calloc(1, sizeof(*mgr));
-       if (!mgr) {
-               _ERR("Allocation fail");
-               return NULL;
+       m = new SPlayerData;
+       if (!m) {
+               _ERR("allocation fail");
+               return false;
        }
 
-       mgr->win = win;
-       mgr->display_mode = E_FULL_SCREEN;
-       mgr->audio_effect = 0;
-       mgr->rew_speed = 0;
-       mgr->ff_speed = 0;
+       m->win = win;
+       m->display_mode = E_FULL_SCREEN;
+       m->audio_effect = 0;
+       m->rew_speed = 0;
+       m->ff_speed = 0;
 
-       mgr->media_list = _create_list(playlist);
-       if (!mgr->media_list) {
+       m->media_list = _create_list(playlist);
+       if (!m->media_list) {
                _ERR("play list is null");
-               free(mgr);
-               return NULL;
+               delete m;
+               return false;
        }
 
-       mgr->current = _get_current(mgr->media_list, path);
-       mgr->total = eina_list_count(mgr->media_list);
+       m->current = _get_current(m->media_list, path);
+       m->total = eina_list_count(m->media_list);
 
-       if (player_create(&mgr->player) != PLAYER_ERROR_NONE) {
+       if (player_create(&m->player) != PLAYER_ERROR_NONE) {
                _ERR("PLAYER CREATION ERROR");
-               free(mgr);
-               return NULL;
+               delete m;
+               return false;
        }
 
+       return true;
+}
+
+void CPlayer::Destroy(void)
+{
+       ASSERT(m);
+
+       ecore_timer_del(m->ffrew_timer);
+
+       if (m->media_list)
+               _destroy_list(m->media_list);
+
+       if (m->player) {
+               player_pause(m->player);
+               player_stop(m->player);
+               player_unprepare(m->player);
+               player_destroy(m->player);
+       }
 
-       return mgr;
+       delete m;
+       m = NULL;
 }
 
-static int _play_video(struct playermgr *mgr, const char *path)
+bool CPlayer::m_Play(const char *path)
 {
+       ASSERT(m);
+       ASSERT(m->player);
+
        int r;
 
-       if (player_set_uri(mgr->player, path) != PLAYER_ERROR_NONE) {
+       if (player_set_uri(m->player, path) != PLAYER_ERROR_NONE) {
                _ERR("PLAYER SET URI ERROR");
-               return -1;
+               return false;
        }
 
-       r = player_set_display(mgr->player, PLAYER_DISPLAY_TYPE_OVERLAY,
-                       GET_DISPLAY(mgr->win));
+       r = player_set_display(m->player, PLAYER_DISPLAY_TYPE_OVERLAY,
+                       GET_DISPLAY(m->win));
        if (r != PLAYER_ERROR_NONE) {
                _ERR("SETTING DISPLAY ERROR: %d", r);
-               return -1;
+               return false;
        }
 
-       playermgr_set_display_mode(mgr, mgr->display_mode);
+       SetDisplayMode(m->display_mode);
+       SetAudioEffect(m->audio_effect);
 
-       r = player_prepare(mgr->player);
+       r = player_prepare(m->player);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("PLAYER PREPARE ERROR: %d", r);
-               return -1;
+               return false;
        }
 
-       r = player_start(mgr->player);
+       r = player_start(m->player);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("PLAYER START ERROR: %d", r);
-               return -1;
+               return false;
        }
 
-       playermgr_set_audio_effect(mgr, mgr->audio_effect);
-
-       return 0;
+       return true;
 }
 
-int playermgr_stop_video(struct playermgr *mgr)
+bool CPlayer::Stop(void)
 {
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       ASSERT(m);
+       ASSERT(m->player);
 
-       player_pause(mgr->player);
-       player_stop(mgr->player);
-       player_unprepare(mgr->player);
+       player_pause(m->player);
+       player_stop(m->player);
+       player_unprepare(m->player);
 
-       return 0;
+       return true;
 }
 
-int playermgr_play_video(struct playermgr *mgr)
+bool CPlayer::Play(void)
 {
-       const char *path;
-       int r;
+       ASSERT(m);
 
-       if (!mgr || !mgr->media_list) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       const char *path;
+       bool r;
 
-       r = playermgr_stop_video(mgr);
-       if (r < 0)
+       r = Stop();
+       if (!r)
                return r;
 
-       path = playermgr_get_video_path(mgr);
-       r = _play_video(mgr, path);
+       path = GetPath();
+       if (!path) {
+               _ERR("video path is NULL");
+               return false;
+       }
+
+       r = m_Play(path);
 
        return r;
 }
 
-void playermgr_set_prev_video(struct playermgr *mgr)
+bool CPlayer::Prev(void)
 {
-       if (!mgr) {
-               _ERR("invalid parameter");
-               return;
-       }
+       ASSERT(m);
 
-       if (mgr->current == 0)
-               mgr->current = mgr->total - 1;
+       if (m->current == 0)
+               m->current = m->total - 1;
        else
-               mgr->current--;
+               m->current--;
+
+       return true;
 }
 
-Eina_Bool playermgr_set_next_video(struct playermgr *mgr, Eina_Bool repeat)
+bool CPlayer::Next(bool repeat)
 {
-       if (!mgr) {
-               _ERR("invalid parameter");
-               return EINA_FALSE;
-       }
+       ASSERT(m);
 
-       if (mgr->current == mgr->total - 1) {
-               mgr->current = 0;
+       if (m->current == m->total - 1) {
+               m->current = 0;
 
                if (!repeat)
-                       return EINA_FALSE;
+                       return false;
        } else {
-               mgr->current++;
+               m->current++;
        }
 
-       return EINA_TRUE;
+       return true;
 }
 
-const char *playermgr_get_video_path(struct playermgr *mgr)
+const char *CPlayer::GetPath(void)
 {
+       ASSERT(m);
+
        const char *path;
 
-       if (!mgr || !mgr->media_list) {
+       if (!m->media_list) {
                _ERR("invalid parameter");
                return NULL;
        }
 
-       path = (const char *)eina_list_nth(mgr->media_list, mgr->current);
+       path = (const char *)eina_list_nth(m->media_list, m->current);
 
        return path;
 }
 
-void playermgr_fini(struct playermgr *mgr)
+bool CPlayer::Pause(void)
 {
-       if (!mgr)
-               return;
-
-       if (mgr->ffrew_timer)
-               ecore_timer_del(mgr->ffrew_timer);
-
-       if (mgr->media_list)
-               _destroy_list(mgr->media_list);
-
-       if (mgr->player) {
-               player_pause(mgr->player);
-               player_stop(mgr->player);
-               player_unprepare(mgr->player);
-               player_destroy(mgr->player);
-       }
+       ASSERT(m);
+       ASSERT(m->player);
 
-       free(mgr);
-}
-
-int playermgr_pause(struct playermgr *mgr)
-{
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
-
-       if (player_pause(mgr->player) != PLAYER_ERROR_NONE) {
+       if (player_pause(m->player) != PLAYER_ERROR_NONE) {
                _ERR("Player pause error");
-               return -1;
+               return false;
        }
 
-       return 0;
+       return true;
 }
 
-int playermgr_resume(struct playermgr *mgr)
+bool CPlayer::Resume(void)
 {
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       ASSERT(m);
+       ASSERT(m->player);
 
-       if (player_start(mgr->player) != PLAYER_ERROR_NONE) {
+       if (player_start(m->player) != PLAYER_ERROR_NONE) {
                _ERR("Player resume error");
-               return -1;
+               return false;
        }
 
-       return 0;
+       return true;
 }
 
-int playermgr_get_state(struct playermgr *mgr, player_state_e *state)
+bool CPlayer::GetState(player_state_e *state)
 {
-       int r;
+       ASSERT(m);
+       ASSERT(m->player);
 
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       int r;
 
-       r = player_get_state(mgr->player, state);
+       r = player_get_state(m->player, state);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("Player get state error");
-               return -1;
+               return false;
        }
 
-       return 0;
+       return true;
 }
 
-int playermgr_get_position(struct playermgr *mgr, int *position)
+bool CPlayer::GetPosition(int *ms)
 {
-       int r;
+       ASSERT(m);
+       ASSERT(m->player);
 
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       int r;
 
-       r = player_get_play_position(mgr->player, position);
+       r = player_get_play_position(m->player, ms);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("Player get position error");
-               return -1;
+               return false;
        }
 
-       return 0;
+       return true;
 }
 
-int playermgr_set_position(struct playermgr *mgr,
-               int sec, player_seek_completed_cb cb, void *data)
+bool CPlayer::SetPosition(int ms, player_seek_completed_cb cb, void *data)
 {
-       int r;
+       ASSERT(m);
+       ASSERT(m->player);
 
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       int r;
 
-       r = player_set_play_position(mgr->player, sec, false, cb, data);
+       r = player_set_play_position(m->player, ms, false, cb, data);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("Player set position error");
-               return -1;
+               return false;
        }
 
-       return 0;
+       return true;
 }
 
-int playermgr_set_audio_effect(struct playermgr *mgr, int value)
+bool CPlayer::SetAudioEffect(int value)
 {
+       ASSERT(m);
+
        /* audio_effect not supported, just return 0 */
-       mgr->audio_effect = value;
+       m->audio_effect = value;
 
-       return 0;
+       return true;
 }
 
-int playermgr_set_display_mode(struct playermgr *mgr, int value)
+bool CPlayer::SetDisplayMode(int value)
 {
+       ASSERT(m);
+       ASSERT(m->player);
+
        int r;
        player_display_mode_e mode;
 
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
-
-       switch (value) {
-       case E_FULL_SCREEN:
-               mode = PLAYER_DISPLAY_MODE_FULL_SCREEN;
-               break;
-       case E_ORIGINAL:
-               mode = PLAYER_DISPLAY_MODE_ORIGIN_SIZE;
-               break;
-       default:
-               _ERR("Invalid value");
-               return -1;
-       }
+       /* display mode not supported, set to full screen forced */
+       mode = PLAYER_DISPLAY_MODE_FULL_SCREEN;
 
-       r = player_set_display_mode(mgr->player, mode);
+       r = player_set_display_mode(m->player, mode);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("Player display mode set error");
-               return -1;
+               return false;
        }
 
-       mgr->display_mode = value;
+       m->display_mode = value;
 
-       return 0;
+       return true;
 }
 
-int playermgr_set_completed_cb(struct playermgr *mgr,
-               player_completed_cb cb, void *data)
+bool CPlayer::SetCompletedCb(player_completed_cb cb, void *data)
 {
-       int r;
+       ASSERT(m);
+       ASSERT(m->player);
 
-       if (!mgr || !mgr->player) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       int r;
 
-       r = player_set_completed_cb(mgr->player, cb, data);
+       r = player_set_completed_cb(m->player, cb, data);
        if (r != PLAYER_ERROR_NONE) {
                _ERR("Player set completed cb error");
-               return -1;
+               return false;
        }
 
-       return 0;
+       return true;
 }
 
-void playermgr_get_play_count(struct playermgr *mgr, char *str, int len)
+int CPlayer::GetTotal(void)
 {
-       if (!mgr) {
-               _ERR("invalid parameter");
-               return;
-       }
+       ASSERT(m);
+
+       return m->total;
+}
 
-       snprintf(str, len, "%d/%d", mgr->current + 1, mgr->total);
+int CPlayer::GetCurrent(void)
+{
+       ASSERT(m);
+
+       return m->current;
 }
 
-static Eina_Bool _ffrew_timer_cb(void *dt)
+Eina_Bool CPlayer::sm_CbFFRew(void *dt)
 {
-       struct playermgr *mgr;
+       CPlayer *p;
+       SPlayerData *m;
        int pos;
-       int r;
 
        if (!dt)
                return ECORE_CALLBACK_CANCEL;
 
-       mgr = (struct playermgr *)dt;
+       p = (CPlayer *)dt;
+       m = p->m;
 
-       if (!mgr->player)
+       ASSERT(m);
+
+       if (!m->player)
                return ECORE_CALLBACK_CANCEL;
 
-       playermgr_get_position(mgr, &pos);
+       p->GetPosition(&pos);
 
-       if (mgr->ff_speed) {
-               pos = pos + _speed[mgr->ff_speed];
-               if (pos > mgr->duration)
-                       pos = mgr->duration;
-       } else if (mgr->rew_speed) {
-               pos = pos - _speed[mgr->rew_speed];
+       if (m->ff_speed) {
+               pos = pos + _speed[m->ff_speed];
+               if (pos > m->duration)
+                       pos = m->duration;
+       } else if (m->rew_speed) {
+               pos = pos - _speed[m->rew_speed];
                if (pos < 0)
                        pos = 0;
-       } else {
-               r = playermgr_resume(mgr);
-               if (r < 0)
-                       return ECORE_CALLBACK_RENEW;
-
-               return ECORE_CALLBACK_CANCEL;
        }
 
-       playermgr_set_position(mgr, pos, NULL, NULL);
+       p->SetPosition(pos, NULL, NULL);
 
-       if (mgr->rew_speed && pos <= 0) {
-               mgr->rew_speed = SPEED_MIN;
+       if (m->rew_speed && pos <= 0) {
+               m->rew_speed = SPEED_MIN;
                return ECORE_CALLBACK_CANCEL;
        }
 
-       if (mgr->ff_speed && pos >= mgr->duration) {
-               mgr->ff_speed = SPEED_MIN;
+       if (m->ff_speed && pos >= m->duration) {
+               m->ff_speed = SPEED_MIN;
                return ECORE_CALLBACK_CANCEL;
        }
 
-       if (ecore_timer_interval_get(mgr->ffrew_timer) != TIME_INTERVAL)
-               ecore_timer_interval_set(mgr->ffrew_timer, TIME_INTERVAL);
+       if (ecore_timer_interval_get(m->ffrew_timer) != TIME_INTERVAL)
+               ecore_timer_interval_set(m->ffrew_timer, TIME_INTERVAL);
 
        return ECORE_CALLBACK_RENEW;
 }
 
-static void _start_ffrew_timer(struct playermgr *mgr)
+void CPlayer::m_StartFFRew(void)
 {
-       playermgr_pause(mgr);
+       Pause();
 
-       if (!mgr->ffrew_timer) {
-               mgr->ffrew_timer = ecore_timer_add(0.0,
-                               _ffrew_timer_cb, mgr);
-               if (!mgr->ffrew_timer)
-                       return;
+       if (!m->ffrew_timer) {
+               m->ffrew_timer = ecore_timer_add(0.0, sm_CbFFRew, this);
        } else {
-               ecore_timer_interval_set(mgr->ffrew_timer, 0.0);
-               ecore_timer_reset(mgr->ffrew_timer);
+               ecore_timer_interval_set(m->ffrew_timer, 0.0);
+               ecore_timer_reset(m->ffrew_timer);
        }
 }
 
-int playermgr_set_ff(struct playermgr *mgr, int duration)
+bool CPlayer::SetFF(int duration)
 {
-       int r;
+       ASSERT(m);
 
-       if (!mgr) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       bool r;
 
-       r = 0;
-       mgr->duration = duration;
-       mgr->rew_speed = SPEED_MIN;
+       m->duration = duration;
+       m->rew_speed = SPEED_MIN;
 
-       if (mgr->ff_speed == SPEED_MAX)
-               return r;
+       if (m->ff_speed == SPEED_MAX)
+               return false;
 
-       if (mgr->ff_speed == SPEED_MIN) {
-               _start_ffrew_timer(mgr);
-               r = 1;
+       r = false;
+       if (m->ff_speed == SPEED_MIN) {
+               m_StartFFRew();
+               r = true;
        }
 
-       mgr->ff_speed++;
+       m->ff_speed++;
 
        return r;
 }
 
-int playermgr_set_rew(struct playermgr *mgr, int duration)
+bool CPlayer::SetRew(int duration)
 {
-       int r;
+       ASSERT(m);
 
-       if (!mgr) {
-               _ERR("invalid parameter");
-               return -1;
-       }
+       bool r;
 
-       r = 0;
-       mgr->duration = duration;
-       mgr->ff_speed = SPEED_MIN;
+       m->duration = duration;
+       m->ff_speed = SPEED_MIN;
 
-       if (mgr->rew_speed == SPEED_MAX)
-               return r;
+       if (m->rew_speed == SPEED_MAX)
+               return false;
 
-       if (mgr->rew_speed == SPEED_MIN) {
-               _start_ffrew_timer(mgr);
-               r = 1;
+       r = false;
+       if (m->rew_speed == SPEED_MIN) {
+               m_StartFFRew();
+               r = true;
        }
 
-       mgr->rew_speed++;
+       m->rew_speed++;
 
        return r;
 }
 
-bool playermgr_get_ffrew(struct playermgr *mgr)
+bool CPlayer::GetFFRew(void)
 {
-       if (mgr->ff_speed || mgr->rew_speed)
+       ASSERT(m);
+
+       if (m->ff_speed || m->rew_speed)
                return true;
 
        return false;
 }
 
-void playermgr_stop_ffrew(struct playermgr *mgr)
+void CPlayer::StopFFRew(void)
 {
-       if (!mgr)
-               _ERR("invalid parameter");
+       ASSERT(m);
 
-       mgr->ff_speed = SPEED_MIN;
-       mgr->rew_speed = SPEED_MIN;
+       m->ff_speed = SPEED_MIN;
+       m->rew_speed = SPEED_MIN;
 
-       if (mgr->ffrew_timer) {
-               ecore_timer_del(mgr->ffrew_timer);
-               mgr->ffrew_timer = NULL;
-       }
+       ecore_timer_del(m->ffrew_timer);
+       m->ffrew_timer = NULL;
 }

diff --git a/src/slider.cpp b/src/slider.cpp
index 9355c14..cabacdb 100644 (file)
--- a/src/slider.cpp
+++ b/src/slider.cpp
@@ -34,7 +34,7 @@ struct SSliderData {
        Evas_Object *base;
        Evas_Object *slider;
        Ecore_Timer *timer;
-       struct playermgr *player;
+       CPlayer *player;
 };
 
 static void _get_timestr(char *str, int size, unsigned int ms)
@@ -51,7 +51,8 @@ static void _slider_seek_completed(void *dt)
 {
        SSliderData *data;
        char str[32];
-       int pos, r;
+       int pos;
+       bool r;
        update_action action;
 
        if (!dt)
@@ -59,8 +60,8 @@ static void _slider_seek_completed(void *dt)
 
        data = (SSliderData *)dt;
 
-       r = playermgr_get_position(data->player, &pos);
-       if (r < 0) {
+       r = data->player->GetPosition(&pos);
+       if (!r) {
                _ERR("Get Position Failed");
                return;
        }
@@ -75,7 +76,8 @@ static void _slider_seek_completed(void *dt)
 Eina_Bool CVideoSlider::sm_CbTimer(void *dt)
 {
        SSliderData *data;
-       int pos, r;
+       int pos;
+       bool r;
        char str[32];
 
        if (!dt)
@@ -86,8 +88,8 @@ Eina_Bool CVideoSlider::sm_CbTimer(void *dt)
        if (!data->player)
                goto error;
 
-       r = playermgr_get_position(data->player, &pos);
-       if (r < 0)
+       r = data->player->GetPosition(&pos);
+       if (!r)
                goto error;
 
        elm_slider_value_set(data->slider, pos);
@@ -146,7 +148,7 @@ void CVideoSlider::Reset(int duration, int position)
        elm_object_part_text_set(m->base, PART_TOTALTIME_TEXT, str);
 }
 
-bool CVideoSlider::Create(Evas_Object *base, playermgr *player)
+bool CVideoSlider::Create(Evas_Object *base, CPlayer *player)
 {
        ASSERT(!m);
 
@@ -215,7 +217,7 @@ void CVideoSlider::OnMouseUp(int id, Evas *e, Evas_Object *obj,
        int v;
 
        v = elm_slider_value_get(obj);
-       playermgr_set_position(m->player, v, _slider_seek_completed, m);
+       m->player->SetPosition(v, _slider_seek_completed, m);
 }
 
 void CVideoSlider::OnMouseMove(int id, Evas *e, Evas_Object *obj,

diff --git a/src/view_player.cpp b/src/view_player.cpp
index ea54b44..20c303a 100644 (file)
--- a/src/view_player.cpp
+++ b/src/view_player.cpp
@@ -47,6 +47,7 @@
 /* Workaround */
 #define KEY_VOLUMEUP_REMOTE "XF86AudioRaiseVolume"
 #define KEY_VOLUMEDOWN_REMOTE "XF86AudioLowerVolume"
+#define KEY_MUTE_REMOTE "XF86AudioMute"
 
 static const char *_control_name[] = {
        "prev",
@@ -64,8 +65,7 @@ struct SPlayerView {
        Evas_Object *base;
        char *id;
 
-       playermgr *player;
-
+       CPlayer *player;
        CVolume *volume;
        CVideoController *control;
        CVideoSlider *slider;
@@ -129,7 +129,8 @@ void CPlayerView::m_UpdateInfoBar(void)
        elm_object_part_text_set(m->base, PART_SOURCETEXT, _(source));
 
        /* Playlist Count */
-       playermgr_get_play_count(m->player, buf, sizeof(buf));
+       snprintf(buf, sizeof(buf), "%d/%d",
+                       m->player->GetCurrent() + 1, m->player->GetTotal());
        elm_object_part_text_set(m->base, PART_CURRENTTEXT, buf);
 
        /* Resolution */
@@ -145,13 +146,13 @@ void CPlayerView::m_UpdateInfoBar(void)
 bool CPlayerView::m_PlayerInit(void)
 {
        const char *path;
-       int r;
+       bool r;
 
-       r = playermgr_play_video(m->player);
+       r = m->player->Play();
        if (r < 0)
                return false;
 
-       path = playermgr_get_video_path(m->player);
+       path = m->player->GetPath();
 
        m->mediadata->Create(path);
        m_UpdateInfoBar();
@@ -171,14 +172,14 @@ bool CPlayerView::m_PlayerInit(void)
 void CPlayerView::sm_EvtRewindBtn(void *dt)
 {
        SPlayerView *data;
-       int r;
+       bool r;
 
        if (!dt)
                return;
 
        data = (SPlayerView *)dt;
 
-       r = playermgr_set_rew(data->player, data->duration);
+       r = data->player->SetRew(data->duration);
 
        if (r > 0) {
                data->slider->Pause();
@@ -189,14 +190,14 @@ void CPlayerView::sm_EvtRewindBtn(void *dt)
 void CPlayerView::sm_EvtForwardBtn(void *dt)
 {
        SPlayerView *data;
-       int r;
+       bool r;
 
        if (!dt)
                return;
 
        data = (SPlayerView *)dt;
 
-       r = playermgr_set_ff(data->player, data->duration);
+       r = data->player->SetFF(data->duration);
 
        if (r > 0) {
                data->slider->Pause();
@@ -214,8 +215,8 @@ void CPlayerView::sm_EvtPrevBtn(void *dt)
 
        data = (SPlayerView *)dt;
 
-       playermgr_stop_ffrew(data->player);
-       playermgr_set_prev_video(data->player);
+       data->player->StopFFRew();
+       data->player->Prev();
 
        action = ACTION_INIT;
        CViewMgr::GetInstance()->UpdateView(data->id, (void *)&action);
@@ -231,8 +232,8 @@ void CPlayerView::sm_EvtNextBtn(void *dt)
 
        data = (SPlayerView *)dt;
 
-       playermgr_stop_ffrew(data->player);
-       playermgr_set_next_video(data->player, EINA_TRUE);
+       data->player->StopFFRew();
+       data->player->Next(true);
 
        action = ACTION_INIT;
        CViewMgr::GetInstance()->UpdateView(data->id, (void *)&action);
@@ -266,32 +267,32 @@ void CPlayerView::sm_EvtPlayBtn(void *dt)
 {
        SPlayerView *data;
        player_state_e state;
-       int r;
+       bool r;
 
        if (!dt)
                return;
 
        data = (SPlayerView *)dt;
 
-       if (playermgr_get_ffrew(data->player)) {
-               playermgr_stop_ffrew(data->player);
-               playermgr_resume(data->player);
+       if (data->player->GetFFRew()) {
+               data->player->StopFFRew();
+               data->player->Resume();
                data->slider->Resume();
                return;
        }
 
-       r = playermgr_get_state(data->player, &state);
-       if (r < 0)
+       r = data->player->GetState(&state);
+       if (!r)
                return;
 
        switch (state) {
        case PLAYER_STATE_PLAYING:
-               playermgr_pause(data->player);
+               data->player->Pause();
                data->slider->Pause();
                break;
 
        case PLAYER_STATE_PAUSED:
-               playermgr_resume(data->player);
+               data->player->Resume();
                data->slider->Resume();
                break;
        default:
@@ -327,7 +328,7 @@ void CPlayerView::sm_CbPlayComplete(void *dt)
 {
        SPlayerView *data;
        update_action action;
-       Eina_Bool r;
+       bool r;
 
        if (!dt)
                return;
@@ -335,10 +336,8 @@ void CPlayerView::sm_CbPlayComplete(void *dt)
        data = (SPlayerView *)dt;
        r = EINA_TRUE;
 
-       if (data->repeat == E_REPEAT_NONE)
-               r = playermgr_set_next_video(data->player, EINA_FALSE);
-       else if (data->repeat == E_REPEAT_ALL)
-               r = playermgr_set_next_video(data->player, EINA_TRUE);
+       if (data->repeat != E_REPEAT_ONE)
+               r = data->player->Next(!data->repeat);
 
        if (!r) {
                elm_exit();
@@ -451,7 +450,8 @@ void CPlayerView::sm_CbEcoreEvent(void *dt, int type, void *ei)
                else if (!strcmp(ev->keyname, KEY_VOLUMEDOWN) ||
                                !strcmp(ev->keyname, KEY_VOLUMEDOWN_REMOTE))
                        sm_EvtVolume(data, E_VOLUME_DOWN);
-               else if (!strcmp(ev->keyname, KEY_MUTE))
+               else if (!strcmp(ev->keyname, KEY_MUTE) ||
+                               !strcmp(ev->keyname, KEY_MUTE_REMOTE))
                        sm_EvtVolume(data, E_VOLUME_MUTE);
                else
                        update = true;
@@ -513,6 +513,8 @@ Eina_Bool CPlayerView::sm_CbDrawAnimation(void *dt)
 
 void CPlayerView::m_ControlInit(SPlayerParam *param)
 {
+       bool r;
+
        m->mediadata = new CMediaData;
        if (!m->mediadata)
                _ERR("mediadata init failed");
@@ -520,10 +522,14 @@ void CPlayerView::m_ControlInit(SPlayerParam *param)
        if (param->id)
                m->id = strdup(param->id);
 
-       m->player = playermgr_init(m->win, param->filepath, param->playlist);
+       m->player = new CPlayer;
        if (!m->player)
                _ERR("player init failed");
 
+       r = m->player->Create(m->win, param->filepath, param->playlist);
+       if (!r)
+               _ERR("player creation failed");
+
        m->control = new CVideoController;
        if (!m->control)
                _ERR("control init failed");
@@ -603,7 +609,7 @@ bool CPlayerView::Create(void *data)
                goto err;
        }
 
-       playermgr_set_completed_cb(m->player, sm_CbPlayComplete, m);
+       m->player->SetCompletedCb(sm_CbPlayComplete, m);
 
        elm_object_signal_callback_add(m->base, "show,view,finish", "",
                        sm_CbShowViewFinish, m);
@@ -625,14 +631,14 @@ err:
 
 void CPlayerView::m_Fini(void)
 {
-       if (m->drawanim_timer)
-               ecore_timer_del(m->drawanim_timer);
+       ecore_timer_del(m->drawanim_timer);
        m->drawanim_timer = NULL;
 
        delete m->mediadata;
        m->mediadata = NULL;
 
-       playermgr_fini(m->player);
+       m->player->Destroy();
+       delete m->player;
        m->player = NULL;
 
        timeout_handler_fini(m->timeout_handle);
@@ -707,11 +713,11 @@ void CPlayerView::t_OnUpdate(void *dt)
                m_ShowBar();
                break;
        case ACTION_RESUME:
-               playermgr_resume(m->player);
+               m->player->Resume();
                m->slider->Resume();
                break;
        case ACTION_PAUSE:
-               playermgr_pause(m->player);
+               m->player->Pause();
                m->slider->Pause();
                break;
        case ACTION_INIT: