path: root/libug-setting-location-efl.c

/*
 * Open Service Platform
 * Copyright (c) 2012-2013  Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://floralicense.org/license/
 *
 * 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 UG_MODULE_API
#define UG_MODULE_API __attribute__ ((visibility("default")))
#endif

#include <Elementary.h>
#include <ui-gadget-module.h>
#include <vconf.h>
#include <vconf-internal-location-keys.h>

#include "libug-setting-location-efl.h"
#include "libug-setting-location-efl-mypos.h"
#include "libug-setting-location-efl-help.h"
#include "libug-setting-location-efl-log.h"

#define END_KEY_EVENT 	FALSE

static char *menu[] = {
	N_("IDS_LBS_BODY_GPS"),
	N_("IDS_LBS_BODY_ADVANCED_GPS"),
	N_("IDS_LBS_BODY_NETWORK_POSITION"),
	N_("IDS_LBS_BODY_MY_POSITION")
};

#define LOCATION_MENU_ENABLE	0
#define LOCATION_MENU_AGPS	1
#define LOCATION_MENU_NET	2
#define LOCATION_MENU_MYPOS	3

#define GL_GPS_INDEX 		1

int setting_location_set_int(const char *path, int val)
{
	int ret = vconf_set_int(path, val);
	if (ret == 0) {
		return TRUE;
	}
	return FALSE;
}

void setting_location_check_di(void *data)
{
	LOC_LOG("setting_location_check_di");
	struct ug_data *ugd = (struct ug_data *)data;
	int i;

	elm_check_state_set(ugd->tg_gps, ugd->is_gps);
	elm_object_item_disabled_set(ugd->gi_agps, !ugd->is_gps);

	elm_check_state_set(ugd->tg_net, ugd->is_net);

	elm_object_item_disabled_set(ugd->gi_mypos, !(ugd->is_gps || ugd->is_net));
}

static void setting_location_free_itc(Elm_Genlist_Item_Class *itc)
{
	if (itc == NULL) {
		return;
	}
	elm_genlist_item_class_free(itc);
}

static void setting_location_back_cb(void *data, Evas_Object * obj, void *event_info)
{
	LOC_LOG("setting_location_back_cb");
	struct ug_data *ugd = (struct ug_data *)data;
	int i;

	setting_location_free_itc(ugd->itc_top_sep);
	setting_location_free_itc(ugd->itc_mid_sep);
	setting_location_free_itc(ugd->itc_gps);
	setting_location_free_itc(ugd->itc_agps);
	setting_location_free_itc(ugd->itc_net);
	setting_location_free_itc(ugd->itc_mypos);

	ug_destroy_me(ugd->ug);
}

static void setting_location_help_cb(void *data, Evas_Object * obj, void *event_info)
{
	struct ug_data *ugd = (struct ug_data *)data;

        setting_location_help_view(ugd);
}

static void _setting_location_gps_cb(void *data, Evas_Object * obj, void *event_info)
{
	struct ug_data *ugd = (struct ug_data *)data;

	Eina_Bool state = elm_check_state_get(obj);

	ugd->is_gps = (state == EINA_TRUE) ? KEY_ENABLED : KEY_DISABLED;
	setting_location_set_int(VCONFKEY_LOCATION_ENABLED, ugd->is_gps);
	setting_location_check_di(ugd);
}

static void _setting_location_agps_cb(void *data, Evas_Object * obj, void *event_info)
{
	struct ug_data *ugd = (struct ug_data *)data;

	Eina_Bool state = elm_check_state_get(obj);

	if (ugd->is_gps == KEY_DISABLED) {
		elm_check_state_set(obj, !state);
		return;
	}
	ugd->is_agps = (state == EINA_TRUE) ? KEY_ENABLED : KEY_DISABLED;
	setting_location_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, ugd->is_agps);
}

static void _setting_location_net_cb(void *data, Evas_Object * obj, void *event_info)
{
	struct ug_data *ugd = (struct ug_data *)data;

	Eina_Bool state = elm_check_state_get(obj);

	ugd->is_net = (state == EINA_TRUE) ? KEY_ENABLED : KEY_DISABLED;
	setting_location_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, ugd->is_net);
	setting_location_check_di(ugd);
}

static char *_setting_location_gl_gps_text_get(void *data, Evas_Object * obj, const char *part)
{
	return strdup(_(menu[LOCATION_MENU_ENABLE]));
}

static Evas_Object *_setting_location_gl_gps_check_get(void *data, Evas_Object * obj, const char *part)
{
	struct ug_data *ugd = (struct ug_data *)data;

	Evas_Object *tg;

	ugd->tg_gps = tg = elm_check_add(obj);

	if (ugd->is_gps == KEY_ENABLED) {
		elm_check_state_set(tg, EINA_TRUE);
	} else {
		elm_check_state_set(tg, EINA_FALSE);
	}

	elm_object_style_set(tg, "on&off");
	evas_object_propagate_events_set(tg, EINA_FALSE);
	evas_object_smart_callback_add(tg, "changed", _setting_location_gps_cb, ugd);

	return tg;
}

static char *_setting_location_gl_agps_text_get(void *data, Evas_Object * obj, const char *part)
{
	return strdup(_(menu[LOCATION_MENU_AGPS]));
}

static Evas_Object *_setting_location_gl_agps_check_get(void *data, Evas_Object * obj, const char *part)
{
	struct ug_data *ugd = (struct ug_data *)data;

	Evas_Object *tg;

	ugd->tg_agps = tg = elm_check_add(obj);

	if (ugd->is_agps == KEY_ENABLED) {
		elm_check_state_set(tg, EINA_TRUE);
	} else {
		elm_check_state_set(tg, EINA_FALSE);
	}

	elm_object_style_set(tg, "on&off");
	evas_object_propagate_events_set(tg, EINA_FALSE);
	evas_object_smart_callback_add(tg, "changed", _setting_location_agps_cb, ugd);

	return tg;
}

static char *_setting_location_gl_net_text_get(void *data, Evas_Object * obj, const char *part)
{
	return strdup(_(menu[LOCATION_MENU_NET]));
}

static Evas_Object *_setting_location_gl_net_check_get(void *data, Evas_Object * obj, const char *part)
{
	struct ug_data *ugd = (struct ug_data *)data;

	Evas_Object *tg;

	ugd->tg_net = tg = elm_check_add(obj);

	if (ugd->is_net == KEY_ENABLED) {
		elm_check_state_set(tg, EINA_TRUE);
	} else {
		elm_check_state_set(tg, EINA_FALSE);
	}

	elm_object_style_set(tg, "on&off");
	evas_object_propagate_events_set(tg, EINA_FALSE);
	evas_object_smart_callback_add(tg, "changed", _setting_location_net_cb, ugd);

	return tg;
}

static char *_setting_location_gl_mypos_text_get(void *data, Evas_Object * obj, const char *part)
{
	return strdup(_(menu[LOCATION_MENU_MYPOS]));
}

static Evas_Object *setting_location_create_layout(Evas_Object * parent)
{
	Evas_Object *layout;
	Evas_Object *bg;

	layout = elm_layout_add(parent);
	elm_layout_theme_set(layout, "layout", "application", "default");
	evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);

	bg = elm_bg_add(layout);
	evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	elm_object_part_content_set(layout, "elm.swallow.bg", bg);
	elm_object_style_set(bg, "group_list");
	
	evas_object_show(layout);

	return layout;
}

Evas_Object *setting_location_create_navibar(Evas_Object * parent)
{
	Evas_Object *naviframe;

	naviframe = elm_naviframe_add(parent);
	elm_object_part_content_set(parent, "elm.swallow.content", naviframe);

	evas_object_show(naviframe);

	return naviframe;
}

static void setting_location_gl_gps_sel(void *data, Evas_Object *obj, void *event_info)
{
	LOC_LOG("setting_location_gl_gps_sel");
	struct ug_data *ugd = (struct ug_data *)data;
	Eina_Bool state = elm_check_state_get(ugd->tg_gps);

	ugd->is_gps = (!state == EINA_TRUE) ? KEY_ENABLED : KEY_DISABLED;
	elm_genlist_item_update(ugd->gi_gps);
	setting_location_set_int(VCONFKEY_LOCATION_ENABLED, ugd->is_gps);
	elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
}

static void setting_location_gl_agps_sel(void *data, Evas_Object *obj, void *event_info)
{
	LOC_LOG("setting_location_gl_agps_sel");
	struct ug_data *ugd = (struct ug_data *)data;
	Eina_Bool state = elm_check_state_get(ugd->tg_agps);

	ugd->is_agps = (!state == EINA_TRUE) ? KEY_ENABLED : KEY_DISABLED;
	elm_genlist_item_update(ugd->gi_agps);
	setting_location_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, ugd->is_agps);
	elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
}

static void setting_location_gl_net_sel(void *data, Evas_Object *obj, void *event_info)
{
	LOC_LOG("setting_location_gl_net_sel");
	struct ug_data *ugd = (struct ug_data *)data;
	Eina_Bool state = elm_check_state_get(ugd->tg_net);

	ugd->is_net = (!state == EINA_TRUE) ? KEY_ENABLED : KEY_DISABLED;
	elm_genlist_item_update(ugd->gi_net);
	setting_location_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, ugd->is_net);
	elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
}

static void setting_location_mypos_sel(void *data, Evas_Object *obj, void *event_info)
{
	struct ug_data *ugd = (struct ug_data *)data;

	elm_genlist_select_mode_set(ugd->genlist, ELM_OBJECT_SELECT_MODE_NONE);

	elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
	setting_location_mypos_view(data);
	return;
}

static void setting_location_genlist_realized(void *data, Evas_Object *obj, void *gi)
{
	if (!gi) {
		return;
	}
	Elm_Object_Item *item = gi;
	struct ug_data *ugd = (struct ug_data *)data;
	int index = (int)elm_genlist_item_index_get(gi);
	int mypos_index = ugd->opt_index;
	int applist_index = mypos_index + 3;

	if (ugd->app_count == 2 && index == applist_index)
		return;

	if ((index == GL_GPS_INDEX) || (index == applist_index)){
		LOC_LOG("TOP index = %d", index);
		elm_object_item_signal_emit(gi, "elm,state,top", "");
	} else if ((index == mypos_index) || (index == applist_index + ugd->app_count - 2)) {
		LOC_LOG("BOT index = %d", index);
		elm_object_item_signal_emit(gi, "elm,state,bottom", "");
	} else {
		LOC_LOG("MID index = %d", index);
		elm_object_item_signal_emit(gi, "elm,state,center", "");
	}
}

Evas_Object *setting_location_create_gl(Evas_Object * parent, void *data)
{
	LOC_LOG("setting_location_create_gl");
	struct ug_data *ugd = (struct ug_data *)data;

	Evas_Object *genlist;

	genlist = elm_genlist_add(parent);
	evas_object_smart_callback_add(genlist, "realized", setting_location_genlist_realized, ugd);
	elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);

	ugd->itc_top_sep = elm_genlist_item_class_new();
	ugd->itc_top_sep->item_style = "dialogue/separator";
	ugd->itc_top_sep->func.text_get = NULL;
	ugd->itc_top_sep->func.content_get = NULL;
	ugd->itc_top_sep->func.state_get = NULL;
	ugd->itc_top_sep->func.del = NULL;
	ugd->gi_top_sep = elm_genlist_item_append(genlist, ugd->itc_top_sep, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
	ugd->opt_index = 0;
	elm_genlist_item_select_mode_set(ugd->gi_top_sep, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);

	ugd->itc_gps = elm_genlist_item_class_new();
	ugd->itc_gps->item_style = "dialogue/1text.1icon";
	ugd->itc_gps->func.text_get = _setting_location_gl_gps_text_get;
	ugd->itc_gps->func.content_get = _setting_location_gl_gps_check_get;
	ugd->itc_gps->func.state_get = NULL;
	ugd->itc_gps->func.del = NULL;

	ugd->gi_gps = elm_genlist_item_append(genlist, ugd->itc_gps, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, setting_location_gl_gps_sel, ugd);
	ugd->opt_index++;

	ugd->itc_agps = elm_genlist_item_class_new();
	ugd->itc_agps->item_style = "dialogue/1text.1icon";
	ugd->itc_agps->func.text_get = _setting_location_gl_agps_text_get;
	ugd->itc_agps->func.content_get = _setting_location_gl_agps_check_get;
	ugd->itc_agps->func.state_get = NULL;
	ugd->itc_agps->func.del = NULL;

	ugd->gi_agps = elm_genlist_item_append(genlist, ugd->itc_agps, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, setting_location_gl_agps_sel, ugd);
	ugd->opt_index++;

	ugd->itc_net = elm_genlist_item_class_new();
	ugd->itc_net->item_style = "dialogue/1text.1icon";
	ugd->itc_net->func.text_get = _setting_location_gl_net_text_get;
	ugd->itc_net->func.content_get = _setting_location_gl_net_check_get;
	ugd->itc_net->func.state_get = NULL;
	ugd->itc_net->func.del = NULL;

	if (location_manager_is_supported_method(LOCATIONS_METHOD_WPS)) {
		ugd->gi_net = elm_genlist_item_append(genlist, ugd->itc_net, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, setting_location_gl_net_sel, ugd);
		ugd->opt_index++;
	}
	else ugd->gi_net = NULL;

	ugd->itc_mypos = elm_genlist_item_class_new();
	ugd->itc_mypos->item_style = "dialogue/1text";
	ugd->itc_mypos->func.text_get = _setting_location_gl_mypos_text_get;
	ugd->itc_mypos->func.content_get = NULL;
	ugd->itc_mypos->func.state_get = NULL;
	ugd->itc_mypos->func.del = NULL;

	ugd->gi_mypos = elm_genlist_item_append(genlist, ugd->itc_mypos, (void *)ugd, NULL, ELM_GENLIST_ITEM_NONE, setting_location_mypos_sel, ugd);
	ugd->opt_index++;

	ugd->itc_mid_sep = elm_genlist_item_class_new();
	ugd->itc_mid_sep->item_style = "dialogue/separator";
	ugd->itc_mid_sep->func.text_get = NULL;
	ugd->itc_mid_sep->func.content_get = NULL;
	ugd->itc_mid_sep->func.state_get = NULL;
	ugd->itc_mid_sep->func.del = NULL;
	ugd->gi_mid_sep = elm_genlist_item_append(genlist, ugd->itc_mid_sep, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
	elm_genlist_item_select_mode_set(ugd->gi_mid_sep, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);

	return genlist;
}

static Evas_Object *setting_location_create_view(Evas_Object * parent, struct ug_data *ugd)
{
	Evas_Object *layout_main;
	Elm_Object_Item* navi_it;
	Evas_Object *l_button;
	Evas_Object *help_button;

	layout_main = setting_location_create_layout(parent);

	ugd->naviframe = setting_location_create_navibar(layout_main);

	l_button = elm_button_add(ugd->naviframe);
	elm_object_style_set(l_button, "naviframe/back_btn/default");
	evas_object_smart_callback_add(l_button, "clicked", setting_location_back_cb, ugd);

	ugd->genlist = setting_location_create_gl(ugd->naviframe, ugd);
	evas_object_show(ugd->genlist);

	navi_it = elm_naviframe_item_push(ugd->naviframe, _("IDS_LBS_HEADER_LOCATION"), l_button, NULL, ugd->genlist, NULL);

	help_button = elm_button_add(ugd->naviframe);
	elm_object_style_set(help_button, "naviframe/toolbar/default");
	elm_object_text_set(help_button, S_("IDS_COM_BODY_HELP"));
	evas_object_smart_callback_add(help_button, "clicked", setting_location_help_cb, ugd);
	elm_object_item_part_content_set(navi_it, "toolbar_button2", help_button);

	return layout_main;
}

void gps_enabled_cb(keynode_t * key, void *data)
{
	struct ug_data *ugd = (struct ug_data *)data;
	vconf_get_int(VCONFKEY_LOCATION_ENABLED, &ugd->is_gps);
	setting_location_check_di(ugd);
	elm_genlist_item_update(ugd->gi_gps);
}

void net_enabled_cb(keynode_t * key, void *data)
{
	struct ug_data *ugd = (struct ug_data *)data;
	vconf_get_int(VCONFKEY_LOCATION_NETWORK_ENABLED, &ugd->is_net);
	setting_location_check_di(ugd);
	elm_genlist_item_update(ugd->gi_net);
}

int setting_location_init(struct ug_data *ugd)
{
	LOC_LOG("setting_location_init");
	int ret = TRUE;

	ret &= vconf_get_int(VCONFKEY_LOCATION_ENABLED, &ugd->is_gps);
	ret &= vconf_get_int(VCONFKEY_LOCATION_AGPS_ENABLED, &ugd->is_agps);
	ret &= vconf_get_int(VCONFKEY_LOCATION_NETWORK_ENABLED, &ugd->is_net);
	ret &= vconf_notify_key_changed(VCONFKEY_LOCATION_ENABLED, gps_enabled_cb, (void *)ugd);
	ret &= vconf_notify_key_changed(VCONFKEY_LOCATION_NETWORK_ENABLED, net_enabled_cb, (void *)ugd);

	setting_location_check_di(ugd);

	return ret;
}

int setting_location_deinit(struct ug_data *ugd)
{
	int ret = TRUE;

	ret = vconf_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, gps_enabled_cb);
	ret = vconf_ignore_key_changed(VCONFKEY_LOCATION_NETWORK_ENABLED, net_enabled_cb);

	return ret;
}

UG_MODULE_API int setting_plugin_reset(service_h service, void *priv)
{
	if (vconf_set_int(VCONFKEY_LOCATION_ENABLED, KEY_DISABLED) != 0) {
		return -1;
	}
	if (vconf_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, KEY_DISABLED) != 0) {
		return -1;
	}
	if (vconf_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, KEY_DISABLED) != 0) {
		return -1;
	}

	return 0;
}

static void *on_create(ui_gadget_h ug, enum ug_mode mode, service_h service, void *priv)
{
	Evas_Object *parent;
	struct ug_data *ugd;

	if (!ug || !priv)
		return NULL;

	bindtextdomain("ug-setting-location-efl", LANGDIR);

	ugd = priv;
	ugd->ug = ug;

	parent = ug_get_parent_layout(ug);
	if (!parent) {
		return NULL;
	}

	if (mode == UG_MODE_FULLVIEW) {
		ugd->base = setting_location_create_view(parent, ugd);
		setting_location_init(ugd);
	} else {
		return NULL;
	}

	return ugd->base;
}

static void on_start(ui_gadget_h ug, service_h service, void *priv)
{
	LOC_LOG("on_start is called");
}

static void on_pause(ui_gadget_h ug, service_h service, void *priv)
{
	LOC_LOG("on_pause is called");
}

static void on_resume(ui_gadget_h ug, service_h service, void *priv)
{
	LOC_LOG("on_resume is called");
	struct ug_data *ugd = (struct ug_data *)priv;
	setting_location_check_di(ugd);
}

static void on_destroy(ui_gadget_h ug, service_h service, void *priv)
{
	struct ug_data *ugd = (struct ug_data *)priv;

	if (!ug || !priv) {
		return;
	}

	service_h result;
	char value[32] = {0,};

	service_create(&result);
	if (ugd->is_gps && ugd->is_net) strncpy(value, "GPSEnabled|WPSEnabled", sizeof(value));
	else if (ugd->is_gps && !ugd->is_net) strncpy(value, "GPSEnabled|WPSDisabled", sizeof(value));
	else if (!ugd->is_gps && ugd->is_net) strncpy(value, "GPSDisabled|WPSEnabled", sizeof(value));
	else if (!ugd->is_gps && !ugd->is_net) strncpy(value, "GPSDisabled|WPSDisabled", sizeof(value));
	service_add_extra_data(result, "State", value);

	if (ugd->is_gps) strncpy(value, "enable", sizeof(value));
	else if (!ugd->is_gps) strncpy(value, "disable", sizeof(value));
	service_add_extra_data(result, "http://tizen.org/appcontrol/data/location/gps", value);

	if (ugd->is_net) strncpy(value, "enable", sizeof(value));
	else if (!ugd->is_net) strncpy(value, "disable", sizeof(value));
	service_add_extra_data(result, "http://tizen.org/appcontrol/data/location/wps", value);

	ug_send_result(ug, result);
	service_destroy(result);

	setting_location_deinit(ugd);

	if (ugd->base != NULL) {
		evas_object_del(ugd->base);
	}

	ugd->base = NULL;
}

static void on_message(ui_gadget_h ug, service_h msg, service_h data, void *priv)
{
}

static void on_event(ui_gadget_h ug, enum ug_event event, service_h data, void *priv)
{
	switch (event) {
	case UG_EVENT_LOW_MEMORY:
		break;
	case UG_EVENT_LOW_BATTERY:
		break;
	case UG_EVENT_LANG_CHANGE:
		break;
	case UG_EVENT_ROTATE_PORTRAIT:
		break;
	case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
		break;
	case UG_EVENT_ROTATE_LANDSCAPE:
		break;
	case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
		break;
	default:
		break;
	}
}

static void on_key_event(ui_gadget_h ug, enum ug_key_event event, service_h data, void *priv)
{
	if (!ug) {
		return;
	}

	switch (event) {
	case UG_KEY_EVENT_END:
		ug_destroy_me(ug);
		break;
	default:
		break;
	}
}

UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
{
	struct ug_data *ugd;

	if (!ops) {
		return -1;
	}

	ugd = calloc(1, sizeof(struct ug_data));
	if (!ugd) {
		return -1;
	}

	ops->create = on_create;
	ops->start = on_start;
	ops->pause = on_pause;
	ops->resume = on_resume;
	ops->destroy = on_destroy;
	ops->message = on_message;
	ops->event = on_event;
	ops->key_event = on_key_event;
	ops->priv = ugd;
	ops->opt = UG_OPT_INDICATOR_ENABLE;

	return 0;
}

UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
{
	struct ug_data *ugd;

	if (!ops) {
		return;
	}

	ugd = ops->priv;

	if (ugd) {
		free(ugd);
	}
}