c6299b268d
The function is neither reentrant nor ISR callable. Instead of using a ticked-based timeout, have the button driver provide the unboost after a delay when waiting for a button. HAVE_GUI_BOOST gets immediate boost after dequeuing any message, otherwise the queue has to have at least three messages waiting for it to trigger a boost-- essentially the behavior that existed but now combined in one place. Change-Id: I1d924702840f56a1a65abe41fa92b4e753c4e75a
829 lines
26 KiB
C
829 lines
26 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2006 Jonathan Gordon
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "config.h"
|
|
#include "lang.h"
|
|
|
|
#include "appevents.h"
|
|
#include "button.h"
|
|
#include "action.h"
|
|
#include "kernel.h"
|
|
#include "debug.h"
|
|
#include "splash.h"
|
|
#include "settings.h"
|
|
#include "pcmbuf.h"
|
|
#include "misc.h"
|
|
#if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
|
|
#include "language.h"
|
|
#endif
|
|
#include "viewport.h"
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
#include "statusbar-skinned.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_BACKLIGHT
|
|
#include "backlight.h"
|
|
#if CONFIG_CHARGING
|
|
#include "power.h"
|
|
#endif
|
|
#endif /* HAVE_BACKLIGHT */
|
|
|
|
#define LOGF_ENABLE
|
|
#include "logf.h"
|
|
|
|
static int last_button = BUTTON_NONE|BUTTON_REL; /* allow the ipod wheel to
|
|
work on startup */
|
|
static intptr_t last_data = 0;
|
|
static int last_action = ACTION_NONE;
|
|
static bool repeated = false;
|
|
static bool wait_for_release = false;
|
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
static bool short_press = false;
|
|
#endif
|
|
|
|
#define REPEAT_WINDOW_TICKS HZ/4
|
|
static int last_action_tick = 0;
|
|
|
|
#if defined(HAVE_BACKLIGHT) || !defined(HAS_BUTTON_HOLD)
|
|
static inline bool is_action_normal(int action);
|
|
static inline bool mask_has_flag(unsigned int mask, unsigned int flag);
|
|
static inline bool is_action_completed(int button);
|
|
#define LAST_FILTER_TICKS HZ/2 /* timeout between filtered actions */
|
|
#endif /* defined(HAVE_BACKLIGHT) || !defined(HAS_BUTTON_HOLD) */
|
|
|
|
#ifdef HAVE_BACKLIGHT
|
|
static unsigned int backlight_mask = SEL_ACTION_NONE;
|
|
static int do_backlight(int action, int context, bool is_pre_btn);
|
|
static void handle_backlight(bool backlight, bool ignore_next);
|
|
#endif /* HAVE_BACKLIGHT */
|
|
|
|
/* software keylock stuff */
|
|
#ifndef HAS_BUTTON_HOLD
|
|
static bool keys_locked = false;
|
|
static bool screen_has_lock = false;
|
|
static unsigned int softlock_mask = SEL_ACTION_NONE;
|
|
static inline int do_softlock_unlock_combo(int button, int context);
|
|
static int do_softlock(int button, int action, int context, bool is_pre_btn);
|
|
#endif /* HAVE_SOFTWARE_KEYLOCK */
|
|
/*
|
|
* do_button_check is the worker function for get_default_action.
|
|
* returns ACTION_UNKNOWN or the requested return value from the list.
|
|
* BE AWARE is_pre_button can miss pre buttons if a match is found first.
|
|
*/
|
|
static inline int do_button_check(const struct button_mapping *items,int button,
|
|
int last_button, int *start, bool *prebtn)
|
|
{
|
|
int i = 0;
|
|
int ret = ACTION_UNKNOWN;
|
|
|
|
while (items[i].button_code != BUTTON_NONE)
|
|
{
|
|
if (items[i].button_code == button)
|
|
{
|
|
/*
|
|
CAVEAT: This will allways return the action without pre_button_code if it has a
|
|
lower index in the list.
|
|
*/
|
|
if ((items[i].pre_button_code == BUTTON_NONE)
|
|
|| (items[i].pre_button_code == last_button))
|
|
{
|
|
ret = items[i].action_code;
|
|
break;
|
|
}
|
|
}
|
|
else if (items[i].pre_button_code & button)
|
|
*prebtn = true; /* determine if this could be another action */
|
|
i++;
|
|
}
|
|
*start = i;
|
|
return ret;
|
|
}
|
|
|
|
#if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
|
|
/*
|
|
* button is horizontally inverted to support RTL language if the given language
|
|
* and context combination require that
|
|
*/
|
|
static int button_flip_horizontally(int context, int button)
|
|
{
|
|
int newbutton;
|
|
|
|
if (!(lang_is_rtl() && ((context == CONTEXT_STD) ||
|
|
(context == CONTEXT_TREE) || (context == CONTEXT_LIST) ||
|
|
(context == CONTEXT_MAINMENU))))
|
|
{
|
|
return button;
|
|
}
|
|
|
|
newbutton = button &
|
|
~(BUTTON_LEFT | BUTTON_RIGHT
|
|
#if defined(BUTTON_SCROLL_BACK) && defined(BUTTON_SCROLL_FWD) && \
|
|
!defined(SIMULATOR)
|
|
| BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD
|
|
#endif
|
|
#if defined(BUTTON_MINUS) && defined(BUTTON_PLUS) && \
|
|
!defined(SIMULATOR)
|
|
| BUTTON_MINUS | BUTTON_PLUS
|
|
#endif
|
|
);
|
|
|
|
if (button & BUTTON_LEFT)
|
|
newbutton |= BUTTON_RIGHT;
|
|
if (button & BUTTON_RIGHT)
|
|
newbutton |= BUTTON_LEFT;
|
|
#if defined(BUTTON_SCROLL_BACK) && defined(BUTTON_SCROLL_FWD) && \
|
|
!defined(SIMULATOR)
|
|
if (button & BUTTON_SCROLL_BACK)
|
|
newbutton |= BUTTON_SCROLL_FWD;
|
|
if (button & BUTTON_SCROLL_FWD)
|
|
newbutton |= BUTTON_SCROLL_BACK;
|
|
#endif
|
|
#if defined(BUTTON_MINUS) && defined(BUTTON_PLUS) && \
|
|
!defined(SIMULATOR)
|
|
if (button & BUTTON_MINUS)
|
|
newbutton |= BUTTON_PLUS;
|
|
if (button & BUTTON_PLUS)
|
|
newbutton |= BUTTON_MINUS;
|
|
#endif
|
|
|
|
return newbutton;
|
|
}
|
|
#endif
|
|
|
|
static inline int get_next_context(const struct button_mapping *items, int i)
|
|
{
|
|
while (items[i].button_code != BUTTON_NONE)
|
|
i++;
|
|
return (items[i].action_code == ACTION_NONE ) ?
|
|
CONTEXT_STD :
|
|
items[i].action_code;
|
|
}
|
|
|
|
|
|
/*
|
|
* int get_action_worker(int context, int timeout, bool *is_pre_button,
|
|
struct button_mapping *user_mappings)
|
|
This function searches the button list for the given context for the just
|
|
pressed button.
|
|
If there is a match it returns the value from the list.
|
|
If there is no match..
|
|
the last item in the list "points" to the next context in a chain
|
|
so the "chain" is followed until the button is found.
|
|
putting ACTION_NONE will get CONTEXT_STD which is always the last list checked.
|
|
BE AWARE is_pre_button can miss pre buttons if a match is found first.
|
|
it is more for actions that are not yet completed in the desired context
|
|
but are defined in a lower 'chained' context.
|
|
Timeout can be TIMEOUT_NOBLOCK to return immediatly
|
|
TIMEOUT_BLOCK to wait for a button press
|
|
Any number >0 to wait that many ticks for a press
|
|
*/
|
|
static int get_action_worker(int context, int timeout, bool *is_pre_button,
|
|
const struct button_mapping* (*get_context_map)(int) )
|
|
{
|
|
const struct button_mapping *items = NULL;
|
|
int button;
|
|
int i=0;
|
|
int ret = ACTION_UNKNOWN;
|
|
static int last_context = CONTEXT_STD;
|
|
|
|
send_event(GUI_EVENT_ACTIONUPDATE, NULL);
|
|
|
|
button = button_get_w_tmo(timeout);
|
|
|
|
/* Data from sys events can be pulled with button_get_data
|
|
* multimedia button presses don't go through the action system */
|
|
if (button == BUTTON_NONE || button & (SYS_EVENT|BUTTON_MULTIMEDIA))
|
|
{
|
|
/* no button pressed so no point in waiting for release */
|
|
if (button == BUTTON_NONE)
|
|
wait_for_release = false;
|
|
return button;
|
|
}
|
|
|
|
/* the special redraw button should result in a screen refresh */
|
|
if (button == BUTTON_REDRAW)
|
|
return ACTION_REDRAW;
|
|
|
|
/* if action_wait_for_release() was called without a button being pressed
|
|
* then actually waiting for release would do the wrong thing, i.e.
|
|
* the next key press is entirely ignored. So, if here comes a normal
|
|
* button press (neither release nor repeat) the press is a fresh one and
|
|
* no point in waiting for release
|
|
*
|
|
* This logic doesn't work for touchscreen which can send normal
|
|
* button events repeatedly before the first repeat (as in BUTTON_REPEAT).
|
|
* These cannot be distinguished from the very first touch
|
|
* but there's nothing we can do about it here */
|
|
if ((button & (BUTTON_REPEAT|BUTTON_REL)) == 0)
|
|
wait_for_release = false;
|
|
|
|
/* Don't send any buttons through untill we see the release event */
|
|
if (wait_for_release)
|
|
{
|
|
if (button&BUTTON_REL)
|
|
{
|
|
/* remember the button for the below button eating on context
|
|
* change */
|
|
last_button = button;
|
|
wait_for_release = false;
|
|
}
|
|
return ACTION_NONE;
|
|
}
|
|
|
|
if ((context != last_context) && ((last_button & BUTTON_REL) == 0)
|
|
#ifdef HAVE_SCROLLWHEEL
|
|
/* Scrollwheel doesn't generate release events */
|
|
&& !(last_button & (BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD))
|
|
#endif
|
|
)
|
|
{
|
|
if (button & BUTTON_REL)
|
|
{
|
|
last_button = button;
|
|
last_action = ACTION_NONE;
|
|
}
|
|
/* eat all buttons until the previous button was |BUTTON_REL
|
|
(also eat the |BUTTON_REL button) */
|
|
return ACTION_NONE; /* "safest" return value */
|
|
}
|
|
last_context = context;
|
|
|
|
#ifndef HAS_BUTTON_HOLD
|
|
screen_has_lock = ((context & ALLOW_SOFTLOCK) == ALLOW_SOFTLOCK);
|
|
context &= ~ALLOW_SOFTLOCK;
|
|
if (is_keys_locked())
|
|
{
|
|
ret = do_softlock_unlock_combo(button, context);
|
|
if (!is_keys_locked())
|
|
return ret;
|
|
}
|
|
#if defined(HAVE_TOUCHPAD) || defined(HAVE_TOUCHSCREEN)
|
|
else if (!mask_has_flag(softlock_mask, SEL_ACTION_NOTOUCH))
|
|
{
|
|
/* make sure touchpad get reactivated if we quit the screen */
|
|
button_enable_touch(true);
|
|
}
|
|
#endif
|
|
|
|
#endif /* HAS_BUTTON_HOLD */
|
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
if (button & BUTTON_TOUCHSCREEN)
|
|
{
|
|
repeated = false;
|
|
short_press = false;
|
|
if (last_button & BUTTON_TOUCHSCREEN)
|
|
{
|
|
if ((button & BUTTON_REL) &&
|
|
((last_button & BUTTON_REPEAT)==0))
|
|
{
|
|
short_press = true;
|
|
}
|
|
else if (button & BUTTON_REPEAT)
|
|
repeated = true;
|
|
}
|
|
last_button = button;
|
|
return ACTION_TOUCHSCREEN;
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
|
|
button = button_flip_horizontally(context, button);
|
|
#endif
|
|
|
|
/* logf("%x,%x",last_button,button); */
|
|
*is_pre_button = false; /* could the button be another actions pre_button */
|
|
while (1)
|
|
{
|
|
/* logf("context = %x",context); */
|
|
#if (BUTTON_REMOTE != 0)
|
|
if (button & BUTTON_REMOTE)
|
|
context |= CONTEXT_REMOTE;
|
|
#endif
|
|
if ((context & CONTEXT_PLUGIN) && get_context_map)
|
|
items = get_context_map(context);
|
|
else
|
|
items = get_context_mapping(context);
|
|
|
|
if (items == NULL)
|
|
break;
|
|
|
|
ret = do_button_check(items, button, last_button, &i, is_pre_button);
|
|
|
|
if (ret == ACTION_UNKNOWN)
|
|
{
|
|
context = get_next_context(items,i);
|
|
|
|
if (context != (int)CONTEXT_STOPSEARCHING)
|
|
{
|
|
i = 0;
|
|
continue;
|
|
}
|
|
}
|
|
/* Action was found or STOPSEARCHING was specified */
|
|
break;
|
|
}
|
|
/* DEBUGF("ret = %x\n",ret); */
|
|
#ifndef HAS_BUTTON_HOLD
|
|
if(screen_has_lock && is_action_normal(ret))
|
|
ret = do_softlock(button, ret, last_context & ~ALLOW_SOFTLOCK, is_pre_button);
|
|
#endif
|
|
if ((current_tick - last_action_tick < REPEAT_WINDOW_TICKS)
|
|
&& (ret == last_action))
|
|
repeated = true;
|
|
else
|
|
repeated = false;
|
|
|
|
last_button = button;
|
|
last_action = ret;
|
|
last_data = button_get_data();
|
|
last_action_tick = current_tick;
|
|
|
|
#if CONFIG_CODEC == SWCODEC
|
|
/* Produce keyclick */
|
|
keyclick_click(false, ret);
|
|
#endif
|
|
|
|
return ret;
|
|
}/* get_action_worker */
|
|
|
|
int get_action(int context, int timeout)
|
|
{
|
|
bool is_pre_button = false;
|
|
int button = get_action_worker(context, timeout, &is_pre_button, NULL);
|
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
if (button == ACTION_TOUCHSCREEN)
|
|
button = sb_touch_to_button(context);
|
|
#endif
|
|
|
|
#ifdef HAVE_BACKLIGHT
|
|
if (mask_has_flag(backlight_mask, SEL_ACTION_ENABLED) &&
|
|
is_action_normal(button))
|
|
button = do_backlight(button, context & ~ALLOW_SOFTLOCK, is_pre_button);
|
|
#endif
|
|
|
|
return button;
|
|
}
|
|
|
|
int get_custom_action(int context,int timeout,
|
|
const struct button_mapping* (*get_context_map)(int))
|
|
{
|
|
bool is_pre_button = false;
|
|
return get_action_worker(context,timeout, &is_pre_button, get_context_map);
|
|
}
|
|
|
|
bool action_userabort(int timeout)
|
|
{
|
|
bool is_pre_button = false;
|
|
int action = get_action_worker(CONTEXT_STD,timeout, &is_pre_button, NULL);
|
|
bool ret = (action == ACTION_STD_CANCEL);
|
|
if (!ret)
|
|
{
|
|
default_event_handler(action);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
intptr_t get_action_data(void)
|
|
{
|
|
return last_data;
|
|
}
|
|
|
|
int get_action_statuscode(int *button)
|
|
{
|
|
int ret = 0;
|
|
if (button)
|
|
*button = last_button;
|
|
|
|
if (last_button & BUTTON_REMOTE)
|
|
ret |= ACTION_REMOTE;
|
|
if (repeated)
|
|
ret |= ACTION_REPEAT;
|
|
return ret;
|
|
}
|
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
/* return BUTTON_NONE on error
|
|
* BUTTON_REPEAT if repeated press
|
|
* BUTTON_REPEAT|BUTTON_REL if release after repeated press
|
|
* BUTTON_REL if it's a short press = release after press
|
|
* BUTTON_TOUCHSCREEN if press
|
|
*/
|
|
int action_get_touchscreen_press(short *x, short *y)
|
|
{
|
|
static int last_data = 0;
|
|
int data;
|
|
if ((last_button & BUTTON_TOUCHSCREEN) == 0)
|
|
return BUTTON_NONE;
|
|
data = button_get_data();
|
|
if (last_button & BUTTON_REL)
|
|
{
|
|
*x = (last_data&0xffff0000)>>16;
|
|
*y = (last_data&0xffff);
|
|
}
|
|
else
|
|
{
|
|
*x = (data&0xffff0000)>>16;
|
|
*y = (data&0xffff);
|
|
}
|
|
last_data = data;
|
|
if (repeated)
|
|
return BUTTON_REPEAT;
|
|
if (short_press)
|
|
return BUTTON_REL;
|
|
/* This is to return a BUTTON_REL after a BUTTON_REPEAT. */
|
|
if (last_button & BUTTON_REL)
|
|
return BUTTON_REPEAT|BUTTON_REL;
|
|
return BUTTON_TOUCHSCREEN;
|
|
}
|
|
|
|
int action_get_touchscreen_press_in_vp(short *x1, short *y1, struct viewport *vp)
|
|
{
|
|
short x, y;
|
|
int ret;
|
|
|
|
ret = action_get_touchscreen_press(&x, &y);
|
|
|
|
if (ret != BUTTON_NONE && viewport_point_within_vp(vp, x, y))
|
|
{
|
|
*x1 = x - vp->x;
|
|
*y1 = y - vp->y;
|
|
return ret;
|
|
}
|
|
if (ret & BUTTON_TOUCHSCREEN)
|
|
return ACTION_UNKNOWN;
|
|
return BUTTON_NONE;
|
|
}
|
|
#endif
|
|
|
|
/* Don't let get_action*() return any ACTION_* values until the current buttons
|
|
* have been released. SYS_* and BUTTON_NONE will go through.
|
|
* Any actions relying on _RELEASE won't get seen.
|
|
*
|
|
* Note this doesn't currently work for touchscreen targets if called
|
|
* when the screen isn't currently touched, because they can send normal
|
|
* (non-BUTTON_REPEAT) events repeatedly, if the touch coordinates change.
|
|
* This cannot be distinguished from normal buttons events.
|
|
*/
|
|
void action_wait_for_release(void)
|
|
{
|
|
wait_for_release = true;
|
|
}
|
|
|
|
#if defined(HAVE_BACKLIGHT) || !defined(HAS_BUTTON_HOLD)
|
|
/* HELPER FUNCTIONS
|
|
* Selective softlock and backlight use this lookup based on mask to decide
|
|
* which actions are filtered, or could be filtered but not currently set.
|
|
* returns false if the action isn't found, true if the action is found
|
|
*/
|
|
static bool is_action_filtered(int action, unsigned int mask, int context)
|
|
{
|
|
bool match = false;
|
|
|
|
switch (action)
|
|
{
|
|
case ACTION_NONE:
|
|
break;
|
|
/*Actions that are not mapped will not turn on the backlight option NOUNMAPPED*/
|
|
case ACTION_UNKNOWN:
|
|
match = mask_has_flag(mask, SEL_ACTION_NOUNMAPPED);
|
|
break;
|
|
case ACTION_WPS_PLAY:
|
|
case ACTION_FM_PLAY:
|
|
match = mask_has_flag(mask, SEL_ACTION_PLAY);
|
|
break;
|
|
case ACTION_STD_PREVREPEAT:
|
|
case ACTION_STD_NEXTREPEAT:
|
|
case ACTION_WPS_SEEKBACK:
|
|
case ACTION_WPS_SEEKFWD:
|
|
case ACTION_WPS_STOPSEEK:
|
|
match = mask_has_flag(mask, SEL_ACTION_SEEK);
|
|
break;
|
|
case ACTION_STD_PREV:
|
|
case ACTION_STD_NEXT:
|
|
case ACTION_WPS_SKIPNEXT:
|
|
case ACTION_WPS_SKIPPREV:
|
|
case ACTION_FM_NEXT_PRESET:
|
|
case ACTION_FM_PREV_PRESET:
|
|
match = mask_has_flag(mask, SEL_ACTION_SKIP);
|
|
break;
|
|
case ACTION_WPS_VOLUP:
|
|
case ACTION_WPS_VOLDOWN:
|
|
match = mask_has_flag(mask, SEL_ACTION_VOL);
|
|
break;
|
|
case ACTION_SETTINGS_INC:/*FMS*/
|
|
case ACTION_SETTINGS_INCREPEAT:/*FMS*/
|
|
case ACTION_SETTINGS_DEC:/*FMS*/
|
|
case ACTION_SETTINGS_DECREPEAT:/*FMS*/
|
|
match = (context == CONTEXT_FM) && mask_has_flag(mask, SEL_ACTION_VOL);
|
|
break;
|
|
default:
|
|
/* display action code of unfiltered actions */
|
|
logf ("unfiltered actions: context: %d action: %d, last btn: %d, \
|
|
mask: %d", context, action, last_button, mask);
|
|
break;
|
|
}/*switch*/
|
|
|
|
return match;
|
|
}
|
|
/* compares mask to a flag return true if set false otherwise*/
|
|
static inline bool mask_has_flag(unsigned int mask, unsigned int flag)
|
|
{
|
|
return ((mask & flag) != 0);
|
|
}
|
|
/* returns true if the supplied context is to be filtered by selective BL/SL*/
|
|
static inline bool is_context_filtered(int context)
|
|
{
|
|
return (context == CONTEXT_FM || context == CONTEXT_WPS);
|
|
}
|
|
/* returns true if action can be passed on to selective backlight/softlock */
|
|
static inline bool is_action_normal(int action)
|
|
{
|
|
return (action != ACTION_REDRAW && (action & SYS_EVENT) == 0);
|
|
}
|
|
/*returns true if Button & released, repeated; or won't generate those events*/
|
|
static inline bool is_action_completed(int button)
|
|
{
|
|
return ((button & (BUTTON_REPEAT | BUTTON_REL)) != 0
|
|
#ifdef HAVE_SCROLLWHEEL
|
|
/* Scrollwheel doesn't generate release events */
|
|
|| (button & (BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD)) != 0
|
|
#endif
|
|
);
|
|
}
|
|
|
|
/* most every action takes two rounds through get_action_worker,
|
|
* once for the keypress and once for the key release,
|
|
* actions with pre_button codes take even more, some actions however, only
|
|
* take once; actions defined with only a button and no release/repeat event,
|
|
* these actions should be acted upon immediately except when we have
|
|
* selective backlighting/softlock enabled and in this case we only act upon
|
|
* them immediately if there is no chance they have another event tied to them
|
|
* determined using is_pre_button and is_action_completed()
|
|
*returns true if event was not filtered and false if it was
|
|
*/
|
|
static bool is_action_unfiltered(int action,int button, bool is_pre_button,
|
|
bool filtered, int *tick)
|
|
{
|
|
bool ret = false;
|
|
/*directly after a match a key release event may trigger another*/
|
|
if (filtered && action != ACTION_UNKNOWN)
|
|
*tick = current_tick + LAST_FILTER_TICKS;
|
|
/* has button been rel/rep or is this the only action it could be */
|
|
if (is_action_completed(button) || !is_pre_button)
|
|
{
|
|
/* reset last action , if the action is not filtered and
|
|
this isn't just a key release event then return true */
|
|
if (!filtered && *tick < current_tick)
|
|
{
|
|
*tick = 0;
|
|
ret = true;
|
|
}
|
|
}/*is_action_completed() || !is_pre_button*/
|
|
return ret;
|
|
}
|
|
#endif /*defined(HAVE_BACKLIGHT) || !defined(HAS_BUTTON_HOLD) HELPER FUNCTIONS*/
|
|
|
|
#ifdef HAVE_BACKLIGHT
|
|
static void handle_backlight(bool backlight, bool ignore_next)
|
|
{
|
|
if (backlight)
|
|
{
|
|
backlight_on_ignore(false, 0);
|
|
backlight_on();
|
|
#ifdef HAVE_BUTTON_LIGHT
|
|
buttonlight_on_ignore(false, 0);
|
|
buttonlight_on();
|
|
}
|
|
buttonlight_on_ignore(ignore_next, 5*HZ);/* as a precautionary fallback */
|
|
#else
|
|
}
|
|
#endif
|
|
backlight_on_ignore(ignore_next, 5*HZ);/*must be set everytime we handle bl*/
|
|
}
|
|
|
|
/* Need to look up actions before we can decide to turn on backlight, if
|
|
* selective backlighting is true filter first keypress events need to be
|
|
* taken into account as well
|
|
*/
|
|
static int do_backlight(int action, int context, bool is_pre_btn)
|
|
{
|
|
static int last_filtered_tick = 0;
|
|
|
|
bool bl_is_active = is_backlight_on(false);
|
|
bool bl_activate = false;
|
|
bool filtered;
|
|
|
|
#if CONFIG_CHARGING /* disable if on external power */
|
|
if (!bl_is_active && is_context_filtered(context) &&
|
|
!(mask_has_flag(backlight_mask, SEL_ACTION_NOEXT) && power_input_present()))
|
|
#else /* skip if backlight is on or incorrect context */
|
|
if (!bl_is_active && is_context_filtered(context))
|
|
#endif
|
|
{
|
|
filtered = is_action_filtered(action, backlight_mask, context);
|
|
bl_activate = is_action_unfiltered(action, last_button, is_pre_btn,
|
|
filtered, &last_filtered_tick);
|
|
}/*is_context_filtered(context)*/
|
|
else
|
|
bl_activate = true;
|
|
|
|
if (action != ACTION_NONE && bl_activate)
|
|
{
|
|
handle_backlight(true, true);
|
|
|
|
if (mask_has_flag(backlight_mask, SEL_ACTION_FFKEYPRESS) && !bl_is_active)
|
|
{
|
|
action = ACTION_NONE;
|
|
last_button = BUTTON_NONE;
|
|
}
|
|
}
|
|
else
|
|
handle_backlight(false, true);/* set ignore next true */
|
|
|
|
return action;
|
|
}
|
|
|
|
/* Enable selected actions to leave the backlight off */
|
|
void set_selective_backlight_actions(bool selective, unsigned int mask,
|
|
bool filter_fkp)
|
|
{
|
|
handle_backlight(true, selective);
|
|
if (selective) /* we will handle filter_first_keypress here so turn it off*/
|
|
{
|
|
set_backlight_filter_keypress(false);/* turnoff ffkp in button.c */
|
|
backlight_mask = mask | SEL_ACTION_ENABLED;
|
|
if(filter_fkp)
|
|
backlight_mask |= SEL_ACTION_FFKEYPRESS;
|
|
}
|
|
else
|
|
{
|
|
set_backlight_filter_keypress(filter_fkp);
|
|
backlight_mask = SEL_ACTION_NONE;
|
|
}
|
|
}
|
|
#endif /* HAVE_BACKLIGHT */
|
|
|
|
#ifndef HAS_BUTTON_HOLD
|
|
bool is_keys_locked(void)
|
|
{
|
|
return (screen_has_lock && keys_locked);
|
|
}
|
|
|
|
static inline void do_key_lock(bool lock)
|
|
{
|
|
keys_locked = lock;
|
|
last_button = BUTTON_NONE;
|
|
button_clear_queue();
|
|
#if defined(HAVE_TOUCHPAD) || defined(HAVE_TOUCHSCREEN)
|
|
/* disable touch device on keylock if std behavior or selected disable touch */
|
|
if (!mask_has_flag(softlock_mask, SEL_ACTION_ENABLED) ||
|
|
mask_has_flag(softlock_mask, SEL_ACTION_NOTOUCH))
|
|
button_enable_touch(!lock);
|
|
#endif
|
|
}
|
|
|
|
/* user selected autolock based on backlight timeout; toggles autolock on / off
|
|
by ACTION_STD_KEYLOCK presses, Activates autolock if set on backlight timeout
|
|
*/
|
|
#ifdef HAVE_BACKLIGHT
|
|
static inline int do_auto_softlock(int button, int action, int *unlock_combo)
|
|
{
|
|
if(mask_has_flag(softlock_mask, SEL_ACTION_ALOCK_OK) && !is_backlight_on(false))
|
|
do_key_lock(true);
|
|
|
|
else if (action == ACTION_STD_KEYLOCK)
|
|
{
|
|
*unlock_combo = button;/* set unlock combo to allow unlock */
|
|
softlock_mask ^= SEL_ACTION_ALOCK_OK;
|
|
handle_backlight(true, false);
|
|
/* If we don't wait for a moment for the backlight queue
|
|
* to process, the user will never see the message */
|
|
if (!is_backlight_on(false))
|
|
sleep(HZ/2);
|
|
|
|
if (mask_has_flag(softlock_mask, SEL_ACTION_ALOCK_OK))
|
|
{
|
|
splash(HZ/2, ID2P(LANG_ACTION_AUTOLOCK_ON));
|
|
action = ACTION_REDRAW;
|
|
}
|
|
else
|
|
splash(HZ/2, ID2P(LANG_ACTION_AUTOLOCK_OFF));
|
|
}
|
|
return action;
|
|
}
|
|
#endif
|
|
|
|
/* Allows unlock softlock when action is not yet known but unlock_combo set*/
|
|
static inline int do_softlock_unlock_combo(int button, int context)
|
|
{
|
|
return do_softlock(button, ACTION_NONE, context, false);
|
|
}
|
|
|
|
/* Handles softlock once action is known */
|
|
static int do_softlock(int button, int action, int context, bool is_pre_btn)
|
|
{
|
|
static int last_filtered_tick = 0;
|
|
static int unlock_combo = BUTTON_NONE; /*Moved from GLOBAL*/
|
|
bool filtered = true;
|
|
bool notify_user = false;
|
|
bool sl_activate = true; /* standard softlock behavior */
|
|
|
|
#ifdef HAVE_BACKLIGHT
|
|
if (!keys_locked && mask_has_flag(softlock_mask, SEL_ACTION_AUTOLOCK))
|
|
action = do_auto_softlock(button, action, &unlock_combo);
|
|
#endif
|
|
/* Lock/Unlock toggled by ACTION_STD_KEYLOCK presses*/
|
|
if ((action == ACTION_STD_KEYLOCK) || (keys_locked && unlock_combo == button))
|
|
{
|
|
unlock_combo = button;
|
|
do_key_lock(!keys_locked);
|
|
notify_user = true;
|
|
}
|
|
#if (BUTTON_REMOTE != 0)/* Allow remote actions through */
|
|
else if (mask_has_flag(button, BUTTON_REMOTE))
|
|
notify_user = false;
|
|
#endif
|
|
else if (keys_locked && action != ACTION_NONE && action != ACTION_REDRAW)
|
|
{
|
|
if (mask_has_flag(softlock_mask, SEL_ACTION_ENABLED))
|
|
{
|
|
filtered = is_action_filtered(action, softlock_mask, context);
|
|
|
|
sl_activate = is_action_unfiltered(action, button, is_pre_btn,
|
|
filtered, &last_filtered_tick);
|
|
}
|
|
/*All non-std softlock options are set to 0 if advanced sl is disabled*/
|
|
if (sl_activate)
|
|
{
|
|
if (!mask_has_flag(softlock_mask, SEL_ACTION_NONOTIFY))
|
|
{ /* always true on standard softlock behavior*/
|
|
notify_user = mask_has_flag(button, BUTTON_REL);
|
|
action = ACTION_REDRAW;
|
|
}
|
|
else
|
|
action = ACTION_NONE;
|
|
}
|
|
else if (!filtered)/*catch blocked actions on fast repeated presses*/
|
|
action = ACTION_NONE;
|
|
} /* keys_locked */
|
|
|
|
#ifdef BUTTON_POWER /*always notify if power button pressed while keys locked*/
|
|
notify_user |= (mask_has_flag(button, BUTTON_POWER) && keys_locked);
|
|
#endif
|
|
|
|
if (notify_user)
|
|
{
|
|
#ifdef HAVE_BACKLIGHT
|
|
handle_backlight(true, false);
|
|
/* If we don't wait for a moment for the backlight queue
|
|
* to process, the user will never see the message */
|
|
if (!is_backlight_on(false))
|
|
sleep(HZ/2);
|
|
#endif
|
|
if (keys_locked)
|
|
splash(HZ/2, ID2P(LANG_KEYLOCK_ON));
|
|
else
|
|
splash(HZ/2, ID2P(LANG_KEYLOCK_OFF));
|
|
|
|
last_button = BUTTON_NONE;
|
|
action = ACTION_REDRAW;
|
|
button_clear_queue();
|
|
}
|
|
|
|
return action;
|
|
}
|
|
|
|
void set_selective_softlock_actions(bool selective, unsigned int mask)
|
|
{
|
|
keys_locked = false;
|
|
if(selective)
|
|
softlock_mask = mask | SEL_ACTION_ENABLED;
|
|
else
|
|
softlock_mask = SEL_ACTION_NONE;
|
|
}
|
|
|
|
#endif /* HAS_BUTTON_HOLD */
|