path: root/plugins/wearable/display/key-filter.c

/*
 * deviced
 *
 * Copyright (c) 2012 - 2013 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 <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
#include <vconf.h>
#include <sys/types.h>
#include <libsyscommon/dbus-system.h>
#include <linux/input.h>

#include "ambient-mode.h"
#include "util.h"
#include "core.h"
#include "poll.h"
#include "device-node.h"
#include "display-actor.h"
#include "display-ops.h"
#include "core/common.h"
#include "core/devices.h"
#include "core/device-notifier.h"
#include "shared/common.h"
#include "power/power-handler.h"
#include "led/touch-key.h"
#include "apps/apps.h"

#ifndef KEY_SCREENLOCK
#define KEY_SCREENLOCK		0x98
#endif
#ifndef SW_GLOVE
#define SW_GLOVE		0x16
#endif

#define PREDEF_LEAVESLEEP	"leavesleep"
#define POWEROFF_ACT			"poweroff"
#define USEC_PER_SEC			1000000
#define USEC_PER_MSEC			1000
#define CSC_CONFIG_MODE_RUNNING	1

#define CAPTURE_COMBINATION_INTERVAL		0.5	/* 0.5 second */
#define TORCH_COMBINATION_INTERVAL			0.1 /* 0.1 second */
#define DEFAULT_COMBINATION_INTERVAL		0.1 /* 0.1 second */

#define LONGKEY_PRESSED_TIME	4	/* 4 second */

#define KEY_MAX_DELAY_TIME		700	/* ms */

#define SIGNAL_CHANGE_HARDKEY		"ChangeHardkey"
#define SIGNAL_LCDON_BY_POWERKEY	"LCDOnByPowerkey"
#define SIGNAL_LCDOFF_BY_POWERKEY	"LCDOffByPowerkey"

#define NORMAL_POWER			0
#define KEY_TEST_MODE_POWER		2

#define GLOVE_MODE	1

enum key_combination_flags {
	KEY_COMBINATION_STOP		= 0,
	KEY_COMBINATION_POWERKEY	= BIT(0),
	KEY_COMBINATION_MENUKEY		= BIT(1),
	KEY_COMBINATION_VOLUMEUP	= BIT(2),
	KEY_COMBINATION_VOLUMEDOWN	= BIT(3),
};

enum combination_process {
	COMBINATION_STOP	= KEY_COMBINATION_STOP,
	COMBINATION_SCREENCAPTURE	= KEY_COMBINATION_POWERKEY | KEY_COMBINATION_MENUKEY,
	COMBINATION_TORCH	= KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEUP,
	COMBINATION_QUICKTALK	= KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEDOWN,
};

static struct timeval pressed_time;
static guint longkey_timeout_id = 0;
static guint longkey_restore_id = 0;
static guint displayon_by_powerkey_timeout_id = 0;
static int cancel_lcdoff;
static int key_combination = KEY_COMBINATION_STOP;
static double combination_pressed_time;
static bool touch_pressed = false;
static int skip_lcd_off = false;
static int skip_combination = false;
static int bezel_wakeup = true;
static const struct device_ops *touchled;
static int booting_check = true;

static inline int current_state_in_on(void)
{
	return (pm_cur_state == S_LCDDIM || pm_cur_state == S_NORMAL);
}

static inline void restore_custom_brightness(void)
{
	if (pm_cur_state == S_LCDDIM &&
	    backlight_ops.get_custom_status())
		backlight_ops.custom_update();
}

static void longkey_pressed(void)
{
	unsigned int caps;

	_I("Power key long pressed!");
	cancel_lcdoff = 1;

	caps = display_get_caps(DISPLAY_ACTOR_POWER_KEY);

	if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
		/* change state - LCD on */
		if (disp_plgn.pm_change_internal)
			disp_plgn.pm_change_internal(INTERNAL_LOCK_POWERKEY, LCD_NORMAL);
		(*pm_callback)(INPUT_POLL_EVENT, NULL);
	}

	if (!display_has_caps(caps, DISPLAY_CAPA_LCDOFF)) {
		_D("No poweroff capability!");
		return;
	}
	pm_status_flag &= ~PWROFF_FLAG;
}

static gboolean longkey_restore_cb(void *data)
{
	device_notify(DEVICE_NOTIFIER_LONGKEY_RESTORE, (void *)NULL);
	longkey_restore_id = 0;

	return G_SOURCE_REMOVE;
}

static gboolean longkey_pressed_cb(void *data)
{
	longkey_pressed();
	longkey_timeout_id = 0;

	return G_SOURCE_REMOVE;
}

static unsigned long timediff_usec(struct timeval t1, struct timeval t2)
{
	unsigned long udiff;

	udiff = (t2.tv_sec - t1.tv_sec) * USEC_PER_SEC;
	udiff += (t2.tv_usec - t1.tv_usec);

	return udiff;
}

static inline void check_key_pair(int code, int new, int *old)
{
	if (new == *old)
		_E("key pair is not matched! (%d, %d)", code, new);
	else
		*old = new;
}

static inline void broadcast_lcdon_by_powerkey(void)
{
	dbus_handle_emit_dbus_signal(NULL,
					DEVICED_PATH_DISPLAY,
					DEVICED_INTERFACE_DISPLAY,
					SIGNAL_LCDON_BY_POWERKEY,
					NULL);
}

static inline void broadcast_lcdoff_by_powerkey(void)
{
	dbus_handle_emit_dbus_signal(NULL,
					DEVICED_PATH_DISPLAY,
					DEVICED_INTERFACE_DISPLAY,
					SIGNAL_LCDOFF_BY_POWERKEY,
					NULL);
}

static inline bool switch_on_lcd(enum device_flags flags)
{
	if (current_state_in_on())
		return false;

	if (backlight_ops.get_lcd_power() == DPMS_ON) {
		if (ambient_get_state() == false)
			return false;
	}

	if (flags & LCD_ON_BY_POWER_KEY)
		broadcast_lcdon_by_powerkey();
	else if (flags & LCD_ON_BY_TOUCH)
		_I("Display on by Touch_wakeup event");

	lcd_on_direct(flags);

	return true;
}

static inline void switch_off_lcd(void)
{
	if (!current_state_in_on())
		return;

	if (backlight_ops.get_lcd_power() == DPMS_OFF)
		return;

	broadcast_lcdoff_by_powerkey();

	lcd_off_procedure(LCD_OFF_BY_POWER_KEY);
}

static void check_key_combination(struct input_event *pinput)
{
	double press_time, diff_time;
	press_time = (pinput->time).tv_sec + USEC_TO_SEC((pinput->time).tv_usec);
	diff_time = press_time - combination_pressed_time;

	switch (key_combination) {
	case COMBINATION_SCREENCAPTURE:
		if (diff_time <= CAPTURE_COMBINATION_INTERVAL) {
			_I("Combination key : SCREENCAPTURE mode");
			skip_combination = true;
		}
		break;
	case COMBINATION_TORCH:
		if (diff_time <= TORCH_COMBINATION_INTERVAL) {
			/* When torch combination, display control should be not change. */
			if (displayon_by_powerkey_timeout_id) {
				g_source_remove(displayon_by_powerkey_timeout_id);
				displayon_by_powerkey_timeout_id = 0;
			}
			_I("Combination key : TORCH mode");
			skip_combination = true;
		} else
			key_combination = COMBINATION_STOP;
		break;
	case COMBINATION_QUICKTALK:
		if (diff_time <= DEFAULT_COMBINATION_INTERVAL) {
			_I("Combination key : QUICK-TALK mode");
			skip_combination = true;
			if (longkey_timeout_id) {
				g_source_remove(longkey_timeout_id);
				longkey_timeout_id = 0;
			}
		}
		break;
	default:
		combination_pressed_time = press_time;
		return;
	}

}

static void start_key_combination(struct input_event *pinput)
{
	switch (pinput->code) {
	case KEY_POWER:
		key_combination |= KEY_COMBINATION_POWERKEY;
		break;
	case KEY_MENU:
		key_combination |= KEY_COMBINATION_MENUKEY;
		break;
	case KEY_VOLUMEUP:
		key_combination |= KEY_COMBINATION_VOLUMEUP;
		break;
	case KEY_VOLUMEDOWN:
		key_combination |= KEY_COMBINATION_VOLUMEDOWN;
		break;
	default:
		return;
	}

	check_key_combination(pinput);
}

static void stop_key_combination(struct input_event *pinput)
{
	if (pinput == NULL) {
		key_combination = KEY_COMBINATION_STOP;
		return;
	}

	switch (pinput->code) {
	case KEY_POWER:
		key_combination &= ~KEY_COMBINATION_POWERKEY;
		break;
	case KEY_MENU:
		key_combination &= ~KEY_COMBINATION_MENUKEY;
		break;
	case KEY_VOLUMEUP:
		key_combination &= ~KEY_COMBINATION_VOLUMEUP;
		break;
	case KEY_VOLUMEDOWN:
		key_combination &= ~KEY_COMBINATION_VOLUMEDOWN;
		break;
	default:
		_E("This code(%d) is not combination type.", pinput->code);
		break;
	}
}

static void process_combination_key(struct input_event *pinput)
{
	if (pinput->value == KEY_PRESSED)
		start_key_combination(pinput);
	else if (pinput->value == KEY_RELEASED)
		stop_key_combination(pinput);
}

static int process_menu_key(struct input_event *pinput)
{
	int caps;

	caps = display_get_caps(DISPLAY_ACTOR_MENU_KEY);

	if (!display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
		if (current_state_in_on())
			return false;
		_D("No lcd-on capability!");
		return true;
	} else if (pinput->value == KEY_PRESSED)
		switch_on_lcd(LCD_ON_BY_POWER_KEY);

	return false;
}

static int decide_lcdoff(void)
{
	/* It's not needed if it's already LCD off state */
	if (!current_state_in_on() &&
	    backlight_ops.get_lcd_power() != DPMS_ON)
		return false;

	/*
	 * This flag is set at the moment
	 * that LCD is turned on by power key
	 * LCD has not to turned off in the situation.
	 */
	if (skip_lcd_off)
		return false;

	/* LCD is not turned off when powerkey is pressed,not released */
	if (key_combination == KEY_COMBINATION_POWERKEY)
		return false;

	/* LCD-off is blocked at the moment poweroff popup shows */
	if (cancel_lcdoff)
		return false;

	/* LCD-off is blocked when powerkey and volmedown key are pressed */
	if (skip_combination)
		return false;

	/* At booting time, display must do not turn off */
	if (booting_check)
		return false;

	return true;
}

static int lcdoff_powerkey(void)
{
	int ignore = true;

	if (decide_lcdoff() == true) {
		check_processes(S_NORMAL);
		check_processes(S_LCDDIM);

		if (!check_holdkey_block(S_NORMAL) &&
		    !check_holdkey_block(S_LCDDIM)) {
			if (display_info.update_auto_brightness)
				display_info.update_auto_brightness(false);
			switch_off_lcd();
			delete_condition(S_NORMAL);
			delete_condition(S_LCDDIM);
			update_lcdoff_source(VCONFKEY_PM_LCDOFF_BY_POWERKEY);
			if (disp_plgn.pm_change_internal)
				disp_plgn.pm_change_internal(INTERNAL_LOCK_POWERKEY, LCD_OFF);
		}
	} else {
		ignore = false;
		skip_combination = false;
	}
	cancel_lcdoff = 0;

	return ignore;
}

static int process_back_key(struct input_event *pinput)
{
	int ignore = true;

	if (pinput->value == KEY_PRESSED) {
		switch_on_lcd(LCD_ON_BY_BACK_KEY);
		_I("back key pressed");
		ignore = false;
	}

	return ignore;
}

static int process_power_key(struct input_event *pinput)
{
	int ignore = true;
	static int value = KEY_RELEASED;
	unsigned int caps;

	caps = display_get_caps(DISPLAY_ACTOR_POWER_KEY);

	switch (pinput->value) {
	case KEY_RELEASED:
		check_key_pair(pinput->code, pinput->value, &value);

		if (!display_conf.powerkey_doublepress) {
			if (display_has_caps(caps, DISPLAY_CAPA_LCDOFF))
				lcdoff_powerkey();
			else
				_D("No lcdoff capability!");
		} else if (skip_lcd_off)
			ignore = false;

		if (!display_has_caps(caps, DISPLAY_CAPA_LCDON))
			ignore = true;

		if (longkey_timeout_id > 0) {
			g_source_remove(longkey_timeout_id);
			longkey_timeout_id = 0;
		}

		if (longkey_restore_id > 0) {
			g_source_remove(longkey_restore_id);
			longkey_restore_id = 0;
		}

		break;
	case KEY_PRESSED:
		if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) {
			skip_lcd_off = switch_on_lcd(LCD_ON_BY_POWER_KEY);
		} else {
			_D("No lcdon capability!");
			skip_lcd_off = false;
		}
		check_key_pair(pinput->code, pinput->value, &value);
		_I("power key pressed");
		pressed_time.tv_sec = (pinput->time).tv_sec;
		pressed_time.tv_usec = (pinput->time).tv_usec;
		if (key_combination == KEY_COMBINATION_POWERKEY) {
			/* add long key timer */
			longkey_timeout_id = g_timeout_add(
				    display_conf.longpress_interval,
				    longkey_pressed_cb, NULL);
			/* add long key restore timer */
			longkey_restore_id = g_timeout_add(
				    LONGKEY_PRESSED_TIME,
				    longkey_restore_cb, NULL);
		}
		cancel_lcdoff = 0;

		break;
	case KEY_BEING_PRESSED:
		if (timediff_usec(pressed_time, pinput->time) >
		    (display_conf.longpress_interval * USEC_PER_MSEC))
			longkey_pressed();
		break;
	}
	return ignore;
}

static int process_screenlock_key(struct input_event *pinput)
{
	if (pinput->value != KEY_RELEASED) {
		stop_key_combination(NULL);
		return true;
	}

	if (!current_state_in_on())
		return false;

	check_processes(S_NORMAL);
	check_processes(S_LCDDIM);

	if (!check_holdkey_block(S_NORMAL) && !check_holdkey_block(S_LCDDIM)) {
		delete_condition(S_NORMAL);
		delete_condition(S_LCDDIM);
		update_lcdoff_source(VCONFKEY_PM_LCDOFF_BY_POWERKEY);

		/* LCD off forcly */
		if (disp_plgn.pm_change_internal)
			disp_plgn.pm_change_internal(-1, LCD_OFF);
	}

	return true;
}

static void process_hardkey_backlight(struct input_event *pinput)
{
	int opt;

	_E("pinput->value : %d", pinput->value);
	if (pinput->value == KEY_PRESSED) {
		if (touchled && touchled->execute) {
			opt = TOUCHLED_PRESS;
			touchled->execute(&opt);
		}
	} else if (pinput->value == KEY_RELEASED) {
		/* if lockscreen is idle lock */
		if (__get_lock_screen_state() == VCONFKEY_IDLE_LOCK) {
			_D("Lock state, key backlight is off when phone is unlocked!");
			return;
		}

		if (touchled && touchled->execute) {
			opt = TOUCHLED_RELEASE;
			touchled->execute(&opt);
		}
	}
}

static void update_vital_state(struct input_event *pinput)
{
	int type;

	/* Change vital state to  VITAL_EXIT only if vital mode is active */
	if (!vital_mode())
		return;

	/* Touch or Menu Key Release Event */
	if (pinput->type == EV_ABS || (pinput->type == EV_KEY &&
	    pinput->value == KEY_RELEASED && pinput->code == KEY_MENU)) {
		/* Enable all services upon receiving user input, else maintain same state */
		type = VITAL_EXIT;
		device_notify(DEVICE_NOTIFIER_VITAL_STATE, &type);
	}
}

static int check_key(struct input_event *pinput, int fd)
{
	int ignore = true;

	process_combination_key(pinput);
	switch (pinput->code) {
	case KEY_MENU:
		ignore = process_menu_key(pinput);
		break;
	case KEY_POWER:
		ignore = process_power_key(pinput);
		if (current_state_in_on())
			ignore = false;
		break;
	case KEY_SCREENLOCK:
		ignore = process_screenlock_key(pinput);
		break;
	case KEY_BACK:
		ignore = process_back_key(pinput);
		stop_key_combination(NULL);
		if (current_state_in_on()) {
			process_hardkey_backlight(pinput);
			ignore = false;
		}
		break;
	case KEY_PHONE:
		stop_key_combination(NULL);
		if (current_state_in_on()) {
			process_hardkey_backlight(pinput);
			ignore = false;
		}
		break;
	case KEY_VOLUMEUP:
	case KEY_VOLUMEDOWN:
		if (current_state_in_on())
			ignore = false;
		break;
	case KEY_CAMERA:
	case KEY_EXIT:
	case KEY_CONFIG:
	case KEY_MEDIA:
	case KEY_MUTE:
	case KEY_PLAYPAUSE:
	case KEY_PLAYCD:
	case KEY_PAUSECD:
	case KEY_STOPCD:
	case KEY_NEXTSONG:
	case KEY_PREVIOUSSONG:
	case KEY_REWIND:
	case KEY_FASTFORWARD:
		stop_key_combination(NULL);
		if (current_state_in_on())
			ignore = false;
		break;
	case 0x1DB:
	case 0x1DC:
	case 0x1DD:
	case 0x1DE:
		stop_key_combination(NULL);
		break;
	default:
		stop_key_combination(NULL);
		ignore = false;
	}
#ifdef ENABLE_PM_LOG
	if (pinput->value == KEY_PRESSED)
		pm_history_save(PM_LOG_KEY_PRESS, pinput->code);
	else if (pinput->value == KEY_RELEASED)
		pm_history_save(PM_LOG_KEY_RELEASE, pinput->code);
#endif
	return ignore;
}

static int check_key_filter(void *data, int fd)
{
	struct input_event *pinput = data;
	int ignore = true;
	static int old_fd, code, value;

	assert(pinput);

	switch (pinput->type) {
	case EV_KEY:
		if (pinput->code == BTN_TOUCH &&
			pinput->value == KEY_RELEASED)
			touch_pressed = false;
		/*
		 * Normally, touch press/release events don't occur
		 * in lcd off state. But touch release events can occur
		 * in the state abnormally. Then touch events are ignored
		 * when lcd is off state.
		 */
		if (pinput->code == BTN_TOUCH && !current_state_in_on())
			break;
		if (pinput->code == code && pinput->value == value) {
			_E("Same key(%d, %d) is polled [%d,%d]",
				code, value, old_fd, fd);
		}
		old_fd = fd;
		code = pinput->code;
		value = pinput->value;

		update_vital_state(pinput);
		ignore = check_key(pinput, fd);
		restore_custom_brightness();

		break;
	case EV_REL:
		if (pm_cur_state == S_LCDOFF && bezel_wakeup) {
			switch_on_lcd(LCD_ON_BY_BEZEL);
			ignore = false;
		} else if (pm_cur_state != S_LCDOFF)
			ignore = false;
		break;
	case EV_ABS:
		update_vital_state(pinput);
		if (pinput->value == KEY_PRESSED) {
			switch_on_lcd(LCD_ON_BY_TOUCH);
			ignore = false;
		}

		if (current_state_in_on())
			ignore = false;

		restore_custom_brightness();

		if (pinput->value == KEY_PRESSED)
			touch_pressed = true;
		else if (pinput->value == KEY_RELEASED)
			touch_pressed = false;
		break;
	case EV_SW:
		break;
	}

	if (ignore)
		return 1;

	return 0;
}

static int booting_done_cb(void *data)
{
	booting_check = 0;

	return 0;
}

static int bezel_wakeup_cb(void *data)
{
	bezel_wakeup = (int)((intptr_t)data);

	return 0;
}

/*
 * Default capability
 * powerkey := LCDON | LCDOFF | POWEROFF
 * homekey  := LCDON
 */
static struct display_actor_ops display_powerkey_actor = {
	.id	= DISPLAY_ACTOR_POWER_KEY,
	.caps	= DISPLAY_CAPA_LCDON |
		  DISPLAY_CAPA_LCDOFF |
		  DISPLAY_CAPA_POWEROFF,
};

static struct display_actor_ops display_menukey_actor = {
	.id	= DISPLAY_ACTOR_MENU_KEY,
	.caps	= DISPLAY_CAPA_LCDON,
};

static void keyfilter_init(void)
{
	display_add_actor(&display_powerkey_actor);
	display_add_actor(&display_menukey_actor);

	touchled = find_device(TOUCHLED_NAME);

	register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb);
	register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb);
}

static void key_backlight_enable(bool enable)
{
	int opt;

	if (!touchled || !touchled->execute)
		return;

	if (enable)
		opt = TOUCHLED_DIRECT_ON;
	else
		opt = TOUCHLED_DIRECT_OFF;

	touchled->execute(&opt);
}

static const struct display_keyfilter_ops normal_keyfilter_ops = {
	.init			= keyfilter_init,
	.check			= check_key_filter,
	.set_powerkey_ignore	= NULL,
	.powerkey_lcdoff	= NULL,
	.backlight_enable	= key_backlight_enable,
};

const struct display_keyfilter_ops *keyfilter_ops = &normal_keyfilter_ops;