nbgl_touch.c

Go to the documentation of this file.

 
#include "app_config.h"
 
#ifdef HAVE_SE_TOUCH
/*********************
 *      INCLUDES
 *********************/
#include <string.h>
#include "nbgl_obj.h"
#include "nbgl_debug.h"
#include "nbgl_touch.h"
#include "nbgl_screen.h"
#include "os_pic.h"
#include "os_io_seproxyhal.h"
 
/*********************
 *      DEFINES
 *********************/
 
/**********************
 *      TYPEDEFS
 **********************/
 
/**********************
 *  STATIC PROTOTYPES
 **********************/
 
/**********************
 *  STATIC VARIABLES
 **********************/
static uint32_t                  lastPressedTime = 0;
static uint32_t                  lastCurrentTime = 0;
static nbgl_obj_t               *lastPressedObj  = NULL;
static nbgl_touchStatePosition_t firstTouchedPosition, lastTouchedPosition;
 
/**********************
 *      VARIABLES
 **********************/
 
/**********************
 *  STATIC PROTOTYPES
 **********************/
 
static void applytouchStatePosition(nbgl_obj_t *obj, nbgl_touchType_t eventType)
{
    nbgl_screen_t *screen = (nbgl_screen_t *) nbgl_screenGetTop();
    LOG_DEBUG(TOUCH_LOGGER, "Apply event %d on object of type %d\n", eventType, obj->type);
    if (!obj) {
        return;
    }
    /* the first action is the one provided by the application */
    if ((obj->touchMask & (1 << eventType)) != 0) {
        // for some specific objects, call directly a specific callback
        switch (obj->type) {
#ifdef NBGL_KEYBOARD
            case KEYBOARD:
                nbgl_keyboardTouchCallback(obj, eventType);
                break;
#endif  // NBGL_KEYBOARD
#ifdef NBGL_KEYPAD
            case KEYPAD:
                nbgl_keypadTouchCallback(obj, eventType);
                break;
#endif  // NBGL_KEYPAD
            default:
                if (screen->touchCallback != NULL) {
                    ((nbgl_touchCallback_t) PIC(screen->touchCallback))((void *) obj, eventType);
                }
                break;
        }
    }
}
 
static nbgl_obj_t *getTouchedObject(nbgl_obj_t *obj, nbgl_touchStatePosition_t *event)
{
    if (obj == NULL) {
        return NULL;
    }
    /* check coordinates
       no need to go further if the touched point is not within the object
       And because the children are also within the object, no need to check them either */
    if ((event->x < obj->area.x0) || (event->x >= (obj->area.x0 + obj->area.width))
        || (event->y < obj->area.y0) || (event->y >= (obj->area.y0 + obj->area.height))) {
        return NULL;
    }
    if ((obj->type == SCREEN) || (obj->type == CONTAINER)) {
        nbgl_container_t *container = (nbgl_container_t *) obj;
        // parse the children, if any
        if (container->children != NULL) {
            uint8_t i;
            for (i = 0; i < container->nbChildren; i++) {
                nbgl_obj_t *current = container->children[i];
                if (current != NULL) {
                    current = getTouchedObject(current, event);
                    if (current != NULL) {
                        return current;
                    }
                }
            }
        }
    }
    /* now see if the object is interested by touch events (any of them) */
    if (obj->touchMask != 0) {
        // LOG_DEBUG(TOUCH_LOGGER,"%d %d \n",clickableObjectTypes ,(1<<obj->type));
        return obj;
    }
    else {
        return NULL;
    }
}
 
static nbgl_obj_t *getSwipableObjectAtPos(nbgl_obj_t                *obj,
                                          nbgl_touchStatePosition_t *pos,
                                          nbgl_touchType_t           detectedSwipe)
{
    if (obj == NULL) {
        return NULL;
    }
 
    // Check if pos position belongs to obj
    if ((pos->x < obj->area.x0) || (pos->x >= (obj->area.x0 + obj->area.width))
        || (pos->y < obj->area.y0) || (pos->y >= (obj->area.y0 + obj->area.height))) {
        return NULL;
    }
 
    if ((obj->type == SCREEN) || (obj->type == CONTAINER)) {
        nbgl_container_t *container = (nbgl_container_t *) obj;
        for (uint8_t i = 0; i < container->nbChildren; i++) {
            nbgl_obj_t *current = container->children[i];
            if (current != NULL) {
                nbgl_obj_t *child = getSwipableObjectAtPos(current, pos, detectedSwipe);
                if (child) {
                    return child;
                }
            }
        }
    }
    if (obj->touchMask & (1 << detectedSwipe)) {
        return obj;
    }
    return NULL;
}
 
static nbgl_obj_t *getSwipableObject(nbgl_obj_t                *obj,
                                     nbgl_touchStatePosition_t *first,
                                     nbgl_touchStatePosition_t *last,
                                     nbgl_touchType_t           detectedSwipe)
{
    if (obj == NULL) {
        return NULL;
    }
 
    nbgl_obj_t *first_obj = getSwipableObjectAtPos(obj, first, detectedSwipe);
 
    if (first_obj == NULL) {
        return NULL;
    }
 
    nbgl_obj_t *last_obj = getSwipableObjectAtPos(obj, last, detectedSwipe);
 
    // Swipable objects match
    if (first_obj == last_obj) {
        return first_obj;
    }
 
    return NULL;
}
 
// Swipe detection
 
#ifndef HAVE_HW_TOUCH_SWIPE
#define SWIPE_THRESHOLD_X 10
#define SWIPE_THRESHOLD_Y 20
#else
// Mapping between nbgl_hardwareSwipe_t and nbgl_touchEvent_t
const nbgl_touchType_t SWIPE_GESTURES[] = {[HARDWARE_SWIPE_UP]    = SWIPED_UP,
                                           [HARDWARE_SWIPE_DOWN]  = SWIPED_DOWN,
                                           [HARDWARE_SWIPE_LEFT]  = SWIPED_LEFT,
                                           [HARDWARE_SWIPE_RIGHT] = SWIPED_RIGHT};
#endif  // HAVE_HW_TOUCH_SWIPE
 
static nbgl_touchType_t nbgl_detectSwipe(nbgl_touchStatePosition_t *last,
                                         nbgl_touchStatePosition_t *first)
{
#ifdef HAVE_HW_TOUCH_SWIPE
    // Swipe is detected by hardware
    (void) first;
 
    if (last->swipe >= NO_HARDWARE_SWIPE) {
        return NB_TOUCH_TYPES;
    }
 
    return SWIPE_GESTURES[last->swipe];
 
#else
    // Swipe is detected by software
    nbgl_touchType_t detected_swipe = NB_TOUCH_TYPES;
    if ((last->x - first->x) >= SWIPE_THRESHOLD_X) {
        detected_swipe = SWIPED_RIGHT;
    }
    else if ((first->x - last->x) >= SWIPE_THRESHOLD_X) {
        detected_swipe = SWIPED_LEFT;
    }
    else if ((last->y - first->y) >= SWIPE_THRESHOLD_Y) {
        detected_swipe = SWIPED_DOWN;
    }
    else if ((first->y - last->y) >= SWIPE_THRESHOLD_Y) {
        detected_swipe = SWIPED_UP;
    }
 
    return detected_swipe;
#endif  // HAVE_HW_TOUCH_SWIPE
}
 
/**********************
 *   GLOBAL FUNCTIONS
 **********************/
 
void nbgl_touchHandler(nbgl_touchStatePosition_t *touchStatePosition, uint32_t currentTime)
{
    static nbgl_touchState_t lastState = RELEASED;
    nbgl_obj_t              *foundObj;
 
    // save last received currentTime
    lastCurrentTime = currentTime;
 
    if (lastState == RELEASED) {
        // filter out not realistic cases (successive RELEASE events)
        if (RELEASED == touchStatePosition->state) {
            lastState = touchStatePosition->state;
            return;
        }
        // memorize first touched position
        memcpy(&firstTouchedPosition, touchStatePosition, sizeof(nbgl_touchStatePosition_t));
    }
    // LOG_DEBUG(TOUCH_LOGGER,"state = %s, x = %d, y=%d\n",(touchStatePosition->state ==
    // RELEASED)?"RELEASED":"PRESSED",touchStatePosition->x,touchStatePosition->y);
 
    // parse the whole screen to find proper object
    foundObj = getTouchedObject(nbgl_screenGetTop(), touchStatePosition);
 
    // LOG_DEBUG(TOUCH_LOGGER,"nbgl_touchHandler: found obj %p, type = %d\n",foundObj,
    // foundObj->type);
    if (foundObj == NULL) {
        LOG_DEBUG(TOUCH_LOGGER, "nbgl_touchHandler: no found obj\n");
        if ((touchStatePosition->state == PRESSED) && (lastState == PRESSED)
            && (lastPressedObj != NULL)) {
            // finger has moved out of an object
            // make sure lastPressedObj still belongs to current screen before warning it
            if (nbgl_screenContainsObj(lastPressedObj)) {
                applytouchStatePosition(lastPressedObj, OUT_OF_TOUCH);
            }
        }
        // Released event has been handled, forget lastPressedObj
        lastPressedObj = NULL;
    }
 
    // memorize last touched position
    memcpy(&lastTouchedPosition, touchStatePosition, sizeof(nbgl_touchStatePosition_t));
 
    if (touchStatePosition->state == RELEASED) {
        nbgl_touchType_t swipe    = nbgl_detectSwipe(touchStatePosition, &firstTouchedPosition);
        bool             consumed = false;
 
        if (swipe != NB_TOUCH_TYPES) {
            // Swipe detected
            nbgl_obj_t *swipedObj = getSwipableObject(
                nbgl_screenGetTop(), &firstTouchedPosition, &lastTouchedPosition, swipe);
            // if a swipable object has been found
            if (swipedObj) {
                applytouchStatePosition(swipedObj, swipe);
                consumed = true;
            }
        }
        if (!consumed && (lastPressedObj != NULL)
            && ((foundObj == lastPressedObj) || (nbgl_screenContainsObj(lastPressedObj)))) {
            // very strange if lastPressedObj != foundObj, let's consider that it's a normal release
            // on lastPressedObj make sure lastPressedObj still belongs to current screen before
            // "releasing" it
            applytouchStatePosition(lastPressedObj, TOUCH_RELEASED);
            if (currentTime >= (lastPressedTime + LONG_TOUCH_DURATION)) {
                applytouchStatePosition(lastPressedObj, LONG_TOUCHED);
            }
            else if (currentTime >= (lastPressedTime + SHORT_TOUCH_DURATION)) {
                applytouchStatePosition(lastPressedObj, TOUCHED);
            }
        }
        // Released event has been handled, forget lastPressedObj
        lastPressedObj = NULL;
    }
    else {  // PRESSED
        if ((lastState == PRESSED) && (lastPressedObj != NULL)) {
            if (foundObj != lastPressedObj) {
                // finger has moved out of an object
                // make sure lastPressedObj still belongs to current screen before warning it
                if (nbgl_screenContainsObj(lastPressedObj)) {
                    applytouchStatePosition(lastPressedObj, OUT_OF_TOUCH);
                }
                lastPressedObj = NULL;
            }
            else {
                // warn the concerned object that it is still touched
                applytouchStatePosition(foundObj, TOUCHING);
            }
        }
        else if (lastState == RELEASED) {
            // newly touched object
            lastPressedObj  = foundObj;
            lastPressedTime = currentTime;
            applytouchStatePosition(foundObj, TOUCH_PRESSED);
            applytouchStatePosition(foundObj, TOUCHING);
        }
    }
 
    lastState = touchStatePosition->state;
}
 
bool nbgl_touchGetTouchedPosition(nbgl_obj_t                 *obj,
                                  nbgl_touchStatePosition_t **firstPos,
                                  nbgl_touchStatePosition_t **lastPos)
{
    LOG_DEBUG(TOUCH_LOGGER, "nbgl_touchGetTouchedPosition: %p %p\n", obj, lastPressedObj);
    if (obj == lastPressedObj) {
        *firstPos = &firstTouchedPosition;
        *lastPos  = &lastTouchedPosition;
        return true;
    }
    return false;
}
 
uint32_t nbgl_touchGetTouchDuration(nbgl_obj_t *obj)
{
    if (obj == lastPressedObj) {
        return (lastCurrentTime - lastPressedTime);
    }
    return 0;
}
 
nbgl_obj_t *nbgl_touchGetObjectFromId(nbgl_obj_t *obj, uint8_t id)
{
    if (obj == NULL) {
        return NULL;
    }
    if ((obj->type == SCREEN) || (obj->type == CONTAINER)) {
        nbgl_container_t *container = (nbgl_container_t *) obj;
        // parse the children, if any
        if (container->children != NULL) {
            uint8_t i;
            for (i = 0; i < container->nbChildren; i++) {
                nbgl_obj_t *current = container->children[i];
                if (current != NULL) {
                    current = nbgl_touchGetObjectFromId(current, id);
                    if (current != NULL) {
                        return current;
                    }
                }
            }
        }
    }
    /* now see if the object is interested by touch events (any of them) */
    if ((obj->touchMask != 0) && (obj->touchId == id)) {
        LOG_DEBUG(TOUCH_LOGGER, "found %p: id = %d, type = %d \n", obj, obj->touchId, obj->type);
        return obj;
    }
    else {
        return NULL;
    }
}
#endif  // HAVE_SE_TOUCH