path: root/src/main.c

/*
 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
 *
 * 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 <Elementary.h>
#include <viewmgr.h>
#include <inputmgr.h>
#include <app_debug.h>

#include "define.h"
#include "tv.h"
#include "util.h"
#include "view.h"

#define KEY_MAX 256

SET_TAG(PACKAGE)

struct _appdata {
	const char *name;
	Evas_Object *win;

	int is_signal;
};

struct key_map {
	const char *view;
	const char *key[KEY_MAX];
};

static struct key_map g_kmap[] = {
	{
		VIEW_CHANNELINFO,
		{
			KEY_ENTER, KEY_ENTER_REMOTE,
			KEY_CHANNELUP, KEY_CHANNELUP_REMOTE,
			KEY_CHANNELDOWN, KEY_CHANNELDOWN_REMOTE
		}
	},
	{
		VIEW_CHANNELNUMBER,
		{
			KEY_0, KEY_1, KEY_2, KEY_3,
			KEY_4, KEY_5, KEY_6, KEY_7,
			KEY_8, KEY_9, KEY_MINUS
		}
	},
};

static void _key_down_cb(int id, void *data, Evas *e, Evas_Object *obj,
		Evas_Event_Key_Down *ev)
{
	size_t i, j;

	for (i = 0; i < sizeof(g_kmap) / sizeof(*g_kmap); i++) {
		j = 0;
		while (g_kmap[i].key[j]) {
			if (!strcmp(ev->keyname, g_kmap[i].key[j])) {
				viewmgr_show_view(g_kmap[i].view);
				viewmgr_update_view(g_kmap[i].view,
						UPDATE_TYPE_INPUT_KEY_DOWN, ev);
				return;
			}
			j++;
		}
	}
}

static void _key_up_cb(int id, void *data, Evas *e, Evas_Object *obj,
		Evas_Event_Key_Up *ev)
{
	size_t i, j;

	for (i = 0; i < sizeof(g_kmap) / sizeof(*g_kmap); i++) {
		j = 0;
		while (g_kmap[i].key[j]) {
			if (!strcmp(ev->keyname, g_kmap[i].key[j])) {
				viewmgr_show_view(g_kmap[i].view);
				viewmgr_update_view(g_kmap[i].view,
						UPDATE_TYPE_INPUT_KEY_UP, ev);
				return;
			}
			j++;
		}
	}
}

static input_handler key_handler = {
	.key_down = _key_down_cb,
	.key_up = _key_up_cb,
};

static Evas_Object *_add_win(const char *name)
{
	Evas_Object *win, *trans;

	win = elm_win_add(NULL, name, ELM_WIN_BASIC);
	if (!win) {
		_ERR("elm_win_add failed");
		return NULL;
	}
	elm_win_alpha_set(win, EINA_FALSE);
	elm_win_focus_highlight_enabled_set(win, EINA_FALSE);
	elm_win_focus_highlight_style_set(win, "invisible");

	evas_object_show(win);

	trans = evas_object_rectangle_add(evas_object_evas_get(win));
	if (!trans) {
		_ERR("Create transparent layer failed");
		evas_object_del(win);
		return NULL;
	}

	/* for transparent layer */
	evas_object_color_set(trans, 0, 0, 0, 0);
	evas_object_render_op_set(trans, EVAS_RENDER_COPY);
	elm_win_resize_object_add(win, trans);
	evas_object_size_hint_weight_set(trans,
			EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	evas_object_show(trans);

	return win;
}

int _set_tv_overlay(Evas_Object *win)
{
	int r;
	Ecore_Wl_Window *wl_win;

	wl_win = elm_win_wl_window_get(win);

	r = tv_overlay_set(wl_win);

	return r;
}

static void _tv_signal_cb(void *data, int is_signal)
{
	struct _appdata *ad;

	if (!data) {
		_ERR("failed to get data");
		return;
	}

	ad = data;

	if (ad->is_signal == is_signal)
		return;

	ad->is_signal = is_signal;
}

static void _pause(void *data)
{
}

static void _resume(void *data)
{
	struct _appdata *ad;
	int r;

	if (!data) {
		_ERR("failed to get data");
		return;
	}

	ad = data;

	r = tv_resume();
	if (r < 0) {
		_ERR("Resume tv service failed");
		return;
	} else if (r > 0) {
		r = tv_channel_tune();
		if (r < 0) {
			_ERR("Tune channel failed");
			return;
		}
	}

	r = _set_tv_overlay(ad->win);
	if (r < 0) {
		_ERR("Set overlay failed");
		return;
	}
}

static bool _create(void *data)
{
	struct _appdata *ad;
	Evas_Object *win;
	int r;

	if (!data) {
		_ERR("failed to get data");
		return false;
	}

	ad = data;

	elm_theme_overlay_add(NULL, THEMEFILE);

	win = _add_win(ad->name);
	if (!win) {
		_ERR("failed to create win object");
		return false;
	}

	if (!viewmgr_create(win)) {
		_ERR("failed to initialize viewmgr");
		evas_object_del(win);
		return false;
	}

	viewmgr_add_view(view_channelinfo_get_vclass(), NULL);
	viewmgr_add_view(view_channelnumber_get_vclass(), NULL);

	r = tv_create();
	if (r < 0) {
		_ERR("Create TV failed");
		evas_object_del(win);
		return false;
	}

	r = _set_tv_overlay(ad->win);
	if (r < 0) {
		_ERR("Set overlay failed");
		evas_object_del(win);
		return false;
	}

	ad->win = win;

	tv_signal_cb_set(_tv_signal_cb, ad);
	inputmgr_add_callback(ad->win, 0, &key_handler, NULL);
	return true;
}

static void _terminate(void *data)
{
	struct _appdata *ad;

	if (!data) {
		_ERR("failed to get data");
		return;
	}

	ad = data;

	if (ad->win) {
		tv_destroy();

		inputmgr_remove_callback(ad->win, &key_handler);

		viewmgr_remove_view(VIEW_CHANNELINFO);
		viewmgr_remove_view(VIEW_CHANNELNUMBER);
		viewmgr_destroy();

		evas_object_del(ad->win);
		ad->win = NULL;
	}
}

static void _control(app_control_h control, void *data)
{
	char *svcid;
	int r;

	if (!data) {
		_ERR("failed to get data");
		return;
	}

	r = app_control_get_extra_data(control, KEY_SVCID, &svcid);
	if (r == SERVICE_ERROR_NONE) {
		tv_channel_tune_with_service_id(atoll(svcid));
		free(svcid);
	} else {
		tv_channel_tune();
	}

	viewmgr_show_view(VIEW_CHANNELINFO);
}

int main(int argc, char *argv[])
{
	struct _appdata ad;
	ui_app_lifecycle_callback_s cbs = {
		.create = _create,
		.terminate = _terminate,
		.pause = _pause,
		.resume = _resume,
		.app_control = _control,
	};

	memset(&ad, 0x00, sizeof(ad));
	ad.name = PACKAGE;

	return ui_app_main(argc, argv, &cbs, &ad);
}