path: root/src/util/playermgr.c

/*
 * Copyright (c) 2015 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 <stdbool.h>
#include <Elementary.h>
#include <app_debug.h>
#include <player.h>

#include "define.h"

#define EVENT_INTERVAL 0.1

struct _player_cb {
	void (*func)(void *data);
	void *data;
};

struct playermgr {
	Evas_Object *win;
	Ecore_Timer *event_loop;
	Eina_List *cb_list;
	player_h player;
	char *path;
	struct _player_cb complete_cb;
};

static Eina_Bool _event_cb(void *data)
{
	struct playermgr *m;
	struct _player_cb *cb;
	Eina_List *l;

	if (!data)
		return ECORE_CALLBACK_CANCEL;

	m = data;

	if (!eina_list_count(m->cb_list))
		return ECORE_CALLBACK_RENEW;

	EINA_LIST_FOREACH(m->cb_list, l, cb) {
		if (cb && cb->func)
			cb->func(cb->data);
	}

	m->cb_list = eina_list_free(m->cb_list);

	return ECORE_CALLBACK_RENEW;
}

static void _event_loop_stop(struct playermgr *m)
{
	ecore_timer_del(m->event_loop);
	m->event_loop = NULL;
}

static void _event_loop_start(struct playermgr *m)
{
	if (m->event_loop)
		ecore_timer_reset(m->event_loop);
	else
		m->event_loop = ecore_timer_add(EVENT_INTERVAL, _event_cb, m);
}

static void _player_complete_cb(void *data)
{
	struct playermgr *m;

	if (!data)
		return;

	m = data;

	m->cb_list = eina_list_append(m->cb_list, &m->complete_cb);
}

static void _set_path(struct playermgr *m, const char *path)
{
	free(m->path);

	if (path)
		m->path = strdup(path);
	else
		m->path = NULL;
}

const char *playermgr_get_path(struct playermgr *m)
{
	if (!m) {
		_ERR("invalid parameter");
		return NULL;
	}

	return m->path;
}

int playermgr_get_duration(struct playermgr *m)
{
	int r;
	int ms;

	if (!m) {
		_ERR("invalid parameter");
		return 0;
	}

	r = player_get_duration(m->player, &ms);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: get_position error (%d)", r);
		return 0;
	}

	return ms;
}

int playermgr_get_position(struct playermgr *m)
{
	int r;
	int ms;

	if (!m) {
		_ERR("invalid parameter");
		return 0;
	}

	r = player_get_play_position(m->player, &ms);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: get_position error (%d)", r);
		return 0;
	}

	return ms;
}

bool playermgr_set_position(struct playermgr *m, int ms,
		player_seek_completed_cb cb, void *data)
{
	int r;

	if (!m) {
		_ERR("invalid parameter");
		return false;
	}

	r = player_set_play_position(m->player, ms, false, cb, data);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: set_position error (%d)", r);
		return false;
	}

	return true;
}

void playermgr_get_state(struct playermgr *m, player_state_e *state)
{
	int r;

	if (!m) {
		_ERR("invalid parameter");
		return;
	}

	r = player_get_state(m->player, state);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: get_state error (%d)", r);
		*state = PLAYER_STATE_NONE;
	}
}

bool playermgr_pause(struct playermgr *m)
{
	player_state_e state;
	int r;

	if (!m) {
		_ERR("invalid parameter");
		return false;
	}

	playermgr_get_state(m, &state);
	if (state == PLAYER_STATE_PAUSED)
		return true;

	r = player_pause(m->player);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: pause error (%d)", r);
		_event_loop_stop(m);
		return false;
	}

	_event_loop_stop(m);

	return true;
}

bool playermgr_resume(struct playermgr *m)
{
	player_state_e state;
	int r;

	if (!m) {
		_ERR("invalid parameter");
		return false;
	}

	playermgr_get_state(m, &state);
	if (state == PLAYER_STATE_PLAYING)
		return true;

	r = player_start(m->player);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: start error (%d)", r);
		return false;
	}

	_event_loop_start(m);

	return true;
}

void playermgr_stop(struct playermgr *m)
{
	if (!m) {
		_ERR("invalid parameter");
		return;
	}

	player_pause(m->player);
	player_unprepare(m->player);

	_set_path(m, NULL);
	_event_loop_stop(m);
}

bool playermgr_play(struct playermgr *m, const char *path, int ms)
{
	int r;

	if (!m || !path) {
		_ERR("invalid parameter");
		return false;
	}

	playermgr_stop(m);

	r = player_set_uri(m->player, path);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: set_uri error (%d)", r);
		return false;
	}

	_set_path(m, path);

	if (m->win) {
		r = player_set_display(m->player, PLAYER_DISPLAY_TYPE_OVERLAY,
				GET_DISPLAY(m->win));
		if (r != PLAYER_ERROR_NONE) {
			_ERR("player: set_display error (%d)", r);
			return false;
		}

		r = player_set_display_mode(m->player,
				PLAYER_DISPLAY_MODE_FULL_SCREEN);
		if (r != PLAYER_ERROR_NONE) {
			_ERR("player: set_display_mode error (%d)", r);
			return false;
		}

		r = player_set_display_rotation(m->player,
				PLAYER_DISPLAY_ROTATION_NONE);
		if (r != PLAYER_ERROR_NONE) {
			_ERR("player: set_display_rotation error (%d)", r);
			return false;
		}
	}

	r = player_prepare(m->player);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: prepare error (%d)", r);
		return false;
	}

	r = player_start(m->player);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: start error (%d)", r);
		return false;
	}

	if (ms)
		playermgr_set_position(m, ms, NULL, NULL);

	_event_loop_start(m);

	return true;
}

bool playermgr_set_completed_cb(struct playermgr *m,
		player_completed_cb cb, void *data)
{
	int r;

	r = player_set_completed_cb(m->player, _player_complete_cb, m);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: set callback error (%d)", r);
		return false;
	}

	m->complete_cb.func = cb;
	m->complete_cb.data = data;

	return true;
}

struct playermgr *playermgr_create(Evas_Object *win)
{
	struct playermgr *m;
	int r;

	m = calloc(1, sizeof(*m));
	if (!m) {
		_ERR("failed to allocate");
		return NULL;
	}

	r = player_create(&m->player);
	if (r != PLAYER_ERROR_NONE) {
		_ERR("player: creation error (%d)", r);
		free(m);
		return NULL;
	}

	m->win = win;
	m->path = NULL;
	m->event_loop = NULL;

	return m;
}

void playermgr_destroy(struct playermgr *m)
{
	if (!m) {
		_ERR("invalid parameter");
		return;
	}

	_event_loop_stop(m);

	eina_list_free(m->cb_list);

	if (m->player) {
		playermgr_stop(m);
		player_destroy(m->player);
	}

	free(m->path);
	free(m);
}