contentLister/src/button.c File Reference

content lister - eReader button handling More...

#include <config.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <time.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/XTest.h>
#include <X11/keysymdef.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include <liberregxml/erregapi.h>
#include <libergtk/ergtk.h>
#include <libermanifest/ermanifest.h>
#include "contentListerLog.h"
#include "erbusy.h"
#include "button.h"
#include "erConnect.h"
#include "system.h"
#include "gtkPincodeScreen.h"
#include "control.h"
#include "programManager.h"
#include "stack.h"
#include "powerManager.h"
#include "click.h"
#include "toolbar.h"
#include "gtkDistListWnd.h"

Go to the source code of this file.

Functions
static void *	readFromButtons (void *arg)
static void *	buttonStateMachine (void *arg)
static int	button_get_timout (void)
static void	button_handler (int button, gpointer data)
static void	default_button_handling (int button, gpointer data)
static void	misc_state_button_handling (int button, gpointer data)
static void	pincode_state_button_handling (int button, gpointer data)
static void	langsel_button_handling (int button, gpointer data)
static gboolean	button_get_flipbar_direction_setting (void)
static gboolean	button_key_buffering_timeout (gpointer data)
static gint	button_get_key_buffering_setting (void)
int	button_init (gpointer data)
void	button_block_all_keys (gboolean do_block)
void	button_enable_key_buffering (gboolean enable)
static gboolean	button_is_enable_key_buffering ()
static regUserSetting_t *	btn_get_user_setting (void)
void	flipbarDirectionSettingInit ()
void	keybufferingSettingInit ()
Variables
static gboolean	g_block_all_keys = FALSE
static gboolean	g_flipbar_direction = TRUE
static gint	g_keybuffering_setting = FALSE
static gboolean	g_enable_key_buffering = TRUE
static int	g_timeout_handler_id = 0
static pthread_cond_t	buttonCond
static pthread_mutex_t	buttonCondMutex
static int	protectedButton
static struct timespec	g_timoutValue

---

Detailed Description

content lister - eReader button handling

<File description>=""> Depending on the configure value "enable-command-line-input" the button input will come from the command line (number 1 till 11) or from the actual button driver

Definition in file button.c.

---

Function Documentation

static regUserSetting_t* btn_get_user_setting

(

void

)

[static]

Definition at line 427 of file button.c.

{
    return erRegGetUserSetting();
}

Here is the call graph for this function:

void button_block_all_keys

(

gboolean

do_block

)

Block/unblock all keys

Parameters:

block

- TRUE/FALSE indicates all keys must be blocked/unblocked

Returns:

-

Definition at line 165 of file button.c.

{
    g_block_all_keys = do_block;
}

void button_enable_key_buffering

(

gboolean

enable

)

enable/disable key buffering

Parameters:

enable

- TRUE/FALSE indicates enable key buffering

Returns:

-

Definition at line 177 of file button.c.

{
    g_enable_key_buffering = enable;

    CL_LOGPRINTF("set g_enable_key_buffering =%d",  enable);        

    if  (TRUE == enable)
    {
        if (g_timeout_handler_id != 0)
        {
              g_source_remove(g_timeout_handler_id);
              g_timeout_handler_id = 0;
        }
    }
    else
    { 
         if  (g_timeout_handler_id == 0)
         {
             g_timeout_handler_id = g_timeout_add (KEYBUFFERING_OFF_TIMEOUT, 
                                          button_key_buffering_timeout, NULL);
         }
    }
}

Here is the call graph for this function:

static gboolean button_get_flipbar_direction_setting

(

void

)

[static]

Definition at line 452 of file button.c.

{
    regUserSetting_t *theUserSetting = NULL;
    gboolean     value =  TRUE;
    
    theUserSetting = btn_get_user_setting();
    if (theUserSetting)
    {
        value = theUserSetting->flipbarLeftIsDown;
        erRegFreeUserSetting(theUserSetting);
    }
    else
    {
        CL_WARNPRINTF("no reader settings");
    }

    CL_LOGPRINTF("flipbarDirection %d", value);
    return value;
}

Here is the call graph for this function:

static gint button_get_key_buffering_setting

(

void

)

[static]

Definition at line 478 of file button.c.

{
    regUserSetting_t *theUserSetting = NULL;
    gint     value =  0;

    theUserSetting = btn_get_user_setting();
    if (theUserSetting)
    {
        value = theUserSetting->keyBuffering;
        erRegFreeUserSetting(theUserSetting);
    }
    else
    {
        CL_WARNPRINTF("no reader settings");
    }

    CL_LOGPRINTF("keybuffering %d", value);
    return value;
}

Here is the call graph for this function:

static int button_get_timout

(

void

)

[static]

Definition at line 432 of file button.c.

{
    regUserSetting_t *theUserSetting = NULL;
    int value = BUTTON_LONG_PRESS_TIMEOUT;

    theUserSetting = btn_get_user_setting();
    if ((theUserSetting) && (theUserSetting->longkeypressTimeout > 0))
    {
        value = theUserSetting->longkeypressTimeout;
        erRegFreeUserSetting(theUserSetting);
    }
    else
    {
        CL_WARNPRINTF("no reader settings");
    }

    CL_LOGPRINTF("timout %d", value);
    return value;
}

Here is the call graph for this function:

static void button_handler	(	int	button,
		gpointer	data
	)			[static]

Definition at line 505 of file button.c.

{    
    CL_LOGPRINTF("entry: button [0x%04X] state [%d]", button, getListerState());

    // users set "Flipbar right" as default, need to exchange the UP/DOWN button
    if (FALSE == g_flipbar_direction)
    { 
       if (PAGETURN_FORWARD == button)
       {
           button = PAGETURN_BACK;
       }
       else if (PAGETURN_BACK == button)
       {
           button = PAGETURN_FORWARD;
       }
       else if ((PAGETURN_FORWARD | BUTTON_LONG_PRESS) == button)
       {
           button = (PAGETURN_BACK | BUTTON_LONG_PRESS);
       }
       else if ((PAGETURN_BACK | BUTTON_LONG_PRESS) == button)
       {
           button = (PAGETURN_FORWARD | BUTTON_LONG_PRESS);
       }
    }

    // discard key as needed
    if (g_block_all_keys && button != (POWER) && button != (POWER | BUTTON_LONG_PRESS))
    {
        return;
    }

    // with key-lock enabled, click only on the first few keys but discard all keys
    static int keyclicks_when_locked = MAX_KEYCLICKS_WHEN_LOCKED;

    if (   toolbar_is_locked_selected()
        && button != (POWER                    )
        && button != (POWER | BUTTON_LONG_PRESS) )
    {
        // sound key-click as needed
        if (keyclicks_when_locked > 0)
        {
            --keyclicks_when_locked;
            click_key_discard();
        }

        // discard key
        return;
    }   

    // If g_keybuffering_setting > 0, all keys are passed to app in focus.    
    // If g_keybuffering_setting == 0
    // - Keyhandling gets blocked i.e thrown away
    //   - after first key when key handling is unblocked
    // - Keyhandling gets unblocked
    //   - after 1 second timeout
    //   - at a display update
    //   - when busy indicator is switched off
    if (0 == g_keybuffering_setting)
    {
        if (FALSE == button_is_enable_key_buffering() )
        {
            CL_LOGPRINTF("ingore key =%d\n",  button);
            click_key_discard();
            return;
        }
        button_enable_key_buffering(FALSE);
    }


    // key to be processed: reset key-click counter
    keyclicks_when_locked = MAX_KEYCLICKS_WHEN_LOCKED;

    // Button has been pressed: go back to full cpu
    // power management disabled for now, needs more testing
    //power_cpu_full();

#ifdef ENABLE_LOGGING
    // MvdW: Log this key
    erlog_event_button(button);
#endif /* ENABLE LOGGING */

    // sound key-click
    click_key();

    listerState_t lister_state = getListerState();
    if (lister_state == STATE_NORMAL)
    {
        if (listerIsErrorScreenVisible())
        {
            gdk_threads_enter();
            listerHideErrorScreen();
            gdk_threads_leave();
        }
        else
        {
            default_button_handling(button, data);
        }
    }
    else if (lister_state == STATE_USB_CONNECTED)
    {
        switch (button)
        {
            case POWER:
            case POWER | BUTTON_LONG_PRESS:
                // Powerdown button is the only button that works when connected via USB
                gdk_threads_enter();
                ctrl_shutdown();
                gdk_threads_leave();
                break;

            default:
                ctrl_usbmode_keypress();
        }
    }
    else if (lister_state == STATE_DOWNLOADMGR)
    {
        // downloadMgr is launched from pincode screen, user can't press any keys
        if (TRUE == ctrl_is_connect_from_pincode())
        {
            switch (button)
            {
                case OVERVIEW:
                case OVERVIEW | BUTTON_LONG_PRESS:
                case POWER:
                case POWER | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("OVERVIEW_BUTTON or POWER_BUTTON");
                    ctrl_disconnect(connectScrUnchanged);
                    break;

                default:
                    CL_WARNPRINTF("DownloadMgr state from pincode: buttons disabled");
                    erbusy_off();
            }
        }
        else
        {
            erbusy_blink();

            switch (button)
            {
                case OVERVIEW:
                case OVERVIEW | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("OVERVIEW_BUTTON");
                    gdk_threads_enter();
                    pm_SendKey(GDK_F5);
                    gdk_threads_leave();
                    break;

                case MODE:
                case MODE | BUTTON_LONG_PRESS:
                case POWER:
                case POWER | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("MODE_BUTTON or POWER_BUTTON");
                    ctrl_disconnect(connectScrMode);
                    break;

                case NEWSPAPER:
                case NEWSPAPER | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("MY_NEWSPAPERS_BUTTON");
                    ctrl_disconnect(connectScrNews);
                    break;

                case BOOKS:
                case BOOKS | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("MY_BOOKS_BUTTON");
                    ctrl_disconnect(connectScrBooks);
                    break;

                case DOCUMENTS:
                case DOCUMENTS | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("MY_DOCS_BUTTON");
                    ctrl_disconnect(connectScrDocs);
                    break;

                case NOTES:
                case NOTES | BUTTON_LONG_PRESS:
                    CL_LOGPRINTF("MY_NOTES_BUTTON");
                    ctrl_disconnect(connectScrNotes);
                    break;

                default:
                    CL_WARNPRINTF("DownloadMgr state: send key to connectionMgr");
                    default_button_handling(button, data);
                    erbusy_off();
            }
        }
    }
    else if (lister_state == STATE_MISC)
    {
        misc_state_button_handling(button, data);
    }
    else if (lister_state == STATE_PINCODE)
    {
        if (listerIsErrorScreenVisible())
        {
            gdk_threads_enter();
            listerHideErrorScreen();
            gdk_threads_leave();
        }
        else
        {
             pincode_state_button_handling(button, data);
        }
    }
    else if (lister_state == STATE_LANG_SEL)
    {
        if (listerIsErrorScreenVisible())
        {
            gdk_threads_enter();
            listerHideErrorScreen();
            gdk_threads_leave();
        }
        else
        {
            langsel_button_handling(button, data);
        }
    }
    else
    {
        CL_ERRORPRINTF("Unexpected lister_state [%d]", lister_state);
    }

    CL_LOGPRINTF("leave");
}

Here is the call graph for this function:

int button_init

(

gpointer

data

)

Start up button handling thread

Parameters:

data

value that needs to be passed in the button handling routines

Returns:

-1 in case of failure

Definition at line 120 of file button.c.

{

    pthread_t theThread;

#ifdef COMMAND_LINE_INPUT
    CL_LOGPRINTF("Command line input");

    // Create the thread that will read from the keyboard.
    if (pthread_create(&theThread, NULL, readFromNamedPipe, (void *)data) != 0)
    {
        CL_ERRORPRINTF("Could not create thread");
        return -1;
    }
    else
    {
        return 0;
    }
#else
    CL_LOGPRINTF("Button driver input");
    int timoutValue = button_get_timout();
    g_timoutValue.tv_sec = timoutValue / 1000;
    g_timoutValue.tv_nsec = (timoutValue % 1000) * 1000000;
    keybufferingSettingInit();
    flipbarDirectionSettingInit();
    protectedButton = -1;
    pthread_mutex_init(&buttonCondMutex, NULL);
    pthread_cond_init(&buttonCond, NULL);
    // Create the thread that will read from the button driver.
    if (pthread_create(&theThread, NULL, readFromButtons, (void *)data) != 0)
    {
        CL_ERRORPRINTF("Could not create thread");
        return -1;
    }
    if (pthread_create(&theThread, NULL, buttonStateMachine, (void *)data) != 0)
    {
        CL_ERRORPRINTF("Could not create thread");
        return -1;
    }

    return 0;
#endif //COMMAND_LINE_INPUT
}

Here is the call graph for this function:

static gboolean button_is_enable_key_buffering

(

)

[static]

Definition at line 201 of file button.c.

{
    return g_enable_key_buffering;
}

static gboolean button_key_buffering_timeout

(

gpointer

data

)

[static]

Definition at line 207 of file button.c.

{
    CL_LOGPRINTF("enable key buffering again for timeout");         
    button_enable_key_buffering(TRUE);
    return TRUE;
}

Here is the call graph for this function:

static void * buttonStateMachine

(

void *

arg

)

[static]

This thread implements the long keypress state machine. The state machine has two states: 0: no button is currently pressed 1: some button is currently pressed. the currently pressed button is stored in int button

in state 0, we wait for a button event to proceed. when a press is received, we go to state 1 in state 1, we do a wait with a timeout of BUTTON_LONG_PRESS_TIMEOUT ms if the wait returns with a timeout, it means the button is still pressed, and we handle it as a long press. if the wait returns because of being signalled, it means a button event has happened. if this is a release, we handle it as a short press.

Definition at line 339 of file button.c.

{
    int button;
    struct timespec times;
    struct timeval timev;

    enum
    {
        buttonReleased,
        buttonPressed
    } state = buttonReleased;

    button = -1;
    while (1)
    {
        CL_LOGPRINTF("smthread: start of loop, state %d", state);
        switch (state)
        {
            case buttonReleased:
                pthread_mutex_lock(&buttonCondMutex);
                CL_LOGPRINTF("smthread: waiting for press");
                pthread_cond_wait(&buttonCond, &buttonCondMutex);
                if (protectedButton == 0xFF)
                {
                    CL_LOGPRINTF("smthread: release in released");
                    pthread_mutex_unlock(&buttonCondMutex);
                }
                else
                {
                    CL_LOGPRINTF("smthread: press in released");
                    button = protectedButton;
                    state = buttonPressed;
                    pthread_mutex_unlock(&buttonCondMutex);
                }
                break;

            case buttonPressed:
                pthread_mutex_lock(&buttonCondMutex);
                // get current time, and add BUTTON_LONG_PRESS_TIMEOUT ms
                // a timeval -> timespec conversion is needed (nanosec to microsec)
                gettimeofday(&timev, NULL);
                times.tv_sec = timev.tv_sec + g_timoutValue.tv_sec;
                times.tv_nsec = (timev.tv_usec * 1000) + g_timoutValue.tv_nsec;
                if (times.tv_nsec >= 1000000000)
                {
                    times.tv_nsec -= 1000000000;
                    times.tv_sec += 1;
                }
                CL_LOGPRINTF("smthread: timed waiting for release");
                if (pthread_cond_timedwait(&buttonCond, &buttonCondMutex, &times) == ETIMEDOUT)
                {
                    CL_LOGPRINTF("smthread: timeout in pressed");
                    pthread_mutex_unlock(&buttonCondMutex);
                    if (button >= 0 && button < NUM_BUTTONS)
                    {
                        CL_LOGPRINTF("smthread: long button handler");
                        button_handler(button | BUTTON_LONG_PRESS, arg);        // long
                    }
                    button = -1;
                    state = buttonReleased;
                }
                else
                {
                    if (protectedButton == 0xFF)
                    {
                        CL_LOGPRINTF("smthread: release in pressed");
                        state = buttonReleased;
                        pthread_mutex_unlock(&buttonCondMutex);
                        if (button >= 0 && button < NUM_BUTTONS)
                        {
                            CL_LOGPRINTF("smthread: short button handler");
                            button_handler(button, arg);        // short
                        }
                        button = -1;
                    }
                    else
                    {
                        CL_LOGPRINTF("smthread: press in pressed");
                        button = protectedButton;
                        pthread_mutex_unlock(&buttonCondMutex);
                    }
                }
                break;
        }
    }
    pthread_exit(NULL);
}

Here is the call graph for this function:

static void default_button_handling	(	int	button,
		gpointer	data
	)			[static]

Definition at line 730 of file button.c.

{
    CL_LOGPRINTF("entry: button [0x%04X]", button);

    erbusy_blink();

    switch (button)
    {
        case NEWSPAPER:
        case NEWSPAPER | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("MY_NEWSPAPERS_BUTTON");
            gdk_threads_enter();
            ctrl_contentType_button_clicked(st_ContentTypeNews);
            gdk_threads_leave();
            break;

        case BOOKS:
        case BOOKS | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("MY_BOOKS_BUTTON");
            gdk_threads_enter();
            ctrl_contentType_button_clicked(st_ContentTypeBooks);
            gdk_threads_leave();
            break;

        case DOCUMENTS:
        case DOCUMENTS | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("MY_DOCS_BUTTON");
            gdk_threads_enter();
            ctrl_contentType_button_clicked(st_ContentTypeDocs);
            gdk_threads_leave();
            break;

        case NOTES:
        case NOTES | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("MY_NOTES_BUTTON");
            gdk_threads_enter();
            ctrl_contentType_button_clicked(st_ContentTypeNotes);
            gdk_threads_leave();
            break;

        case MODE:
            CL_LOGPRINTF("MODE_BUTTON");
            gdk_threads_enter();
            ctrl_mode_button_clicked();
            gdk_threads_leave();
            break;

        case MODE | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("MODE_BUTTON LONG");
            gdk_threads_enter();
            ctrl_mode_button_long_clicked();
            gdk_threads_leave();
            break;

        case PAGETURN_FORWARD:
            CL_LOGPRINTF("PAGETURN_FORWARD");
            gdk_threads_enter();
            pm_SendKey(GDK_Page_Down);
            gdk_threads_leave();
            break;

        case PAGETURN_FORWARD | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("PAGETURN_FORWARD LONG");
            gdk_threads_enter();
            pm_SendKey(GDK_F1);
            gdk_threads_leave();
            break;

        case PAGETURN_BACK:
            CL_LOGPRINTF("PAGETURN_BACK");
            gdk_threads_enter();
            pm_SendKey(GDK_Page_Up);
            gdk_threads_leave();
            break;

        case PAGETURN_BACK | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("PAGETURN_BACK LONG");
            gdk_threads_enter();
            pm_SendKey(GDK_F2);
            gdk_threads_leave();
            break;

        case OVERVIEW:
            CL_LOGPRINTF("OVERVIEW_BUTTON");
            gdk_threads_enter();
            pm_SendKey(GDK_F5);
            gdk_threads_leave();
            break;

        case OVERVIEW | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("OVERVIEW_BUTTON LONG");
            gdk_threads_enter();
            pm_SendKey(GDK_Home);
            gdk_threads_leave();
            break;

        case NAVIGATE_3:
            CL_LOGPRINTF("NEXT_LINK_BUTTON");
            gdk_threads_enter();
            pm_SendKey(GDK_Down);
            gdk_threads_leave();
            break;

        case NAVIGATE_3 | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("NEXT_LINK_BUTTON LONG");
            gdk_threads_enter();
            pm_SendKey(GDK_F3);
            gdk_threads_leave();
            break;

        case NAVIGATE_1:
            CL_LOGPRINTF("PREVIOUS_LINK_BUTTON");
            gdk_threads_enter();
            pm_SendKey(GDK_Up);
            gdk_threads_leave();
            break;

        case NAVIGATE_1 | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("PREVIOUS_LINK_BUTTON LONG");
            gdk_threads_enter();
            pm_SendKey(GDK_F4);
            gdk_threads_leave();
            break;

        case NAVIGATE_2:
            CL_LOGPRINTF("CONFIRM_BUTTON");
            gdk_threads_enter();
            pm_SendKey(GDK_Return);
            gdk_threads_leave();
            break;

        case NAVIGATE_2 | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("CONFIRM_BUTTON LONG");
            gdk_threads_enter();
            pm_SendKey(GDK_F6);
            gdk_threads_leave();
            break;

        case CONNECT:
            CL_LOGPRINTF("CONNECT_BUTTON");
            gdk_threads_enter();
            ctrl_display_download_history();
            gdk_threads_leave();
            break;

        case CONNECT | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("CONNECT_BUTTON LONG");
            gdk_threads_enter();
            ctrl_connect_button_clicked();
            gdk_threads_leave();
            break;

        case POWER:
        case POWER | BUTTON_LONG_PRESS:
            gdk_threads_enter();
            ctrl_shutdown();
            gdk_threads_leave();
            break;

        default:
            CL_ERRORPRINTF("unknown value %d", button);
            erbusy_off();
    }
}

Here is the call graph for this function:

void flipbarDirectionSettingInit

(

)

read the value of flipbar direction from er_registry.txt

Parameters:

Returns:

-

Definition at line 472 of file button.c.

{
    // get the value of flipbar direction from the user settings
    g_flipbar_direction = button_get_flipbar_direction_setting();
}

Here is the call graph for this function:

void keybufferingSettingInit

(

)

read the value of key buffering from er_registry.txt

Parameters:

Returns:

-

Definition at line 498 of file button.c.

{
    // get the value of key buffering from the user settings
    g_keybuffering_setting = button_get_key_buffering_setting();
}

Here is the call graph for this function:

static void langsel_button_handling	(	int	button,
		gpointer	data
	)			[static]

Definition at line 999 of file button.c.

{
    CL_LOGPRINTF("entry: button [0x%04X]", button);

    erbusy_blink();

    switch (button)
    {
        case OVERVIEW: 
        case OVERVIEW | BUTTON_LONG_PRESS:
        case NAVIGATE_3:
        case NAVIGATE_3 | BUTTON_LONG_PRESS:
        case NAVIGATE_1:
        case NAVIGATE_1 | BUTTON_LONG_PRESS:
        case NAVIGATE_2:
        case NAVIGATE_2 | BUTTON_LONG_PRESS:
        case POWER:
        case POWER | BUTTON_LONG_PRESS:
            default_button_handling(button, data);
            break;
        default:
            CL_ERRORPRINTF("unknown value %d", button);
            erbusy_off();
            break;
    }
}

Here is the call graph for this function:

static void misc_state_button_handling	(	int	button,
		gpointer	data
	)			[static]

Definition at line 896 of file button.c.

{
    CL_LOGPRINTF("entry");

    int i;

    erbusy_blink();

    switch (button)
    {
        case OVERVIEW:
        case OVERVIEW | BUTTON_LONG_PRESS:
            gdk_threads_enter();
            ctrl_hide_misc_screen();
            gdk_threads_leave();
            break;
            
        case MODE:
        case MODE | BUTTON_LONG_PRESS:
        case NEWSPAPER:
        case NEWSPAPER | BUTTON_LONG_PRESS:
        case BOOKS:
        case BOOKS | BUTTON_LONG_PRESS:
        case DOCUMENTS:
        case DOCUMENTS | BUTTON_LONG_PRESS:
        case NOTES:
        case NOTES | BUTTON_LONG_PRESS:
        case POWER:
        case POWER | BUTTON_LONG_PRESS:
            default_button_handling(button, data);
            break;

        case PAGETURN_FORWARD:
        case PAGETURN_FORWARD | BUTTON_LONG_PRESS:
            gdk_threads_enter();
            if (dist_list_wnd_is_visible())
            {
                i = (button & BUTTON_LONG_PRESS) ? 5 : 1;
                dist_list_wnd_page_forward(i);
            }
            else
            {
                CL_WARNPRINTF("misc state: buttons disabled");
                erbusy_off();
            }
            gdk_threads_leave();
            break;

        case PAGETURN_BACK:
        case PAGETURN_BACK | BUTTON_LONG_PRESS:
            gdk_threads_enter();
            if (dist_list_wnd_is_visible())
            {
                i = (button & BUTTON_LONG_PRESS) ? 5 : 1;
                dist_list_wnd_page_back(i);
            }
            else
            {
                CL_WARNPRINTF("misc state: buttons disabled");
                erbusy_off();
            }
            gdk_threads_leave();
            break;

        default:
            CL_WARNPRINTF("misc state: buttons disabled");
            erbusy_off();
    }
}

Here is the call graph for this function:

static void pincode_state_button_handling	(	int	button,
		gpointer	data
	)			[static]

Definition at line 966 of file button.c.

{
    erbusy_blink();
    
    switch (button)
    {
       case OVERVIEW:
            CL_LOGPRINTF("OVERVIEW_BUTTON");
            gdk_threads_enter();
            ctrl_pincode_overview_button_clicked();
            gdk_threads_leave();
            break;

       case CONNECT | BUTTON_LONG_PRESS:
            CL_LOGPRINTF("CONNECT_BUTTON LONG");
            gdk_threads_enter();
            ctrl_pincode_connect_button_clicked();
            gdk_threads_leave();
            break;

        case POWER:
        case POWER | BUTTON_LONG_PRESS:
            gdk_threads_enter();
            ctrl_shutdown();
            gdk_threads_leave();
            break;

        default:
            CL_WARNPRINTF("Pincode state: buttons(%d) disabled", button);
            ctrl_pincode_button_clicked();
    }
}

Here is the call graph for this function:

static void * readFromButtons

(

void *

arg

)

[static]

This thread will do a blocking read until a button is pressed or released; store the button in protectedButton; signal the buttonStateMachine thread

Definition at line 258 of file button.c.

{
    int status;
    int button_device;
    int ret;

    button_device = open("/dev/buttons", O_RDWR);
    if (button_device == -1)
    {
        CL_ERRORPRINTF("Error opening buttondriver.");
        exit(-1);
    }

    // Disable the activity led 
    ioctl(button_device, BUTTON_IOCTL_WRITE_ACTIVITY_LED, 0);

    // Scan keycode and detect status change
    int button;
    int button_old = 0xff;
    while (1)
    {
        usleep(100 * 1000L);
        ret = ioctl(button_device, BUTTON_IOCTL_GET_STATUS, &status);
        if (ret)
        {
            CL_ERRORPRINTF("ioctl returned 0x%x", ret);
        }
        else
        {
            button = GETBUTTON(status);
            if (button != button_old)
            {
                // Button has changed
                CL_LOGPRINTF("Button changed: new 0x%04X, old 0x%04X", button, button_old);
                button_old = button;
                pthread_mutex_lock(&buttonCondMutex);
                protectedButton = button;

                /* Check if a button was pressed or released */
                if (protectedButton == 0xff)
                {
                    CL_LOGPRINTF("ioctlthread: Button released");
                    if (ret)
                    {
                        CL_ERRORPRINTF("ioctl returned 0x%x", ret);
                    }
                }
                else if (protectedButton >= 0 && protectedButton < NUM_BUTTONS)
                {
                    CL_LOGPRINTF
                        ("ioctlthread: Button pressed: %d, Pen detect: %s",
                         protectedButton, GETPENDETECT(status) ? "Yes" : "No");
                    if (ret)
                    {
                        CL_ERRORPRINTF("ioctl returned 0x%x", ret);
                    }
                }
                else
                {
                    CL_LOGPRINTF("ioctlthread: button weirdness");
                }
                pthread_cond_signal(&buttonCond);
                pthread_mutex_unlock(&buttonCondMutex);
            }
        }
    }
    pthread_exit(NULL);
}

---

Variable Documentation

pthread_cond_t buttonCond [static]

Definition at line 104 of file button.c.

pthread_mutex_t buttonCondMutex [static]

Definition at line 105 of file button.c.

gboolean g_block_all_keys = FALSE [static]

Definition at line 80 of file button.c.

gboolean g_enable_key_buffering = TRUE [static]

Definition at line 92 of file button.c.

gboolean g_flipbar_direction = TRUE [static]

Definition at line 83 of file button.c.

gint g_keybuffering_setting = FALSE [static]

Definition at line 86 of file button.c.

int g_timeout_handler_id = 0 [static]

Definition at line 95 of file button.c.

struct timespec g_timoutValue [static]

Definition at line 107 of file button.c.

int protectedButton [static]

Definition at line 106 of file button.c.