nbgl_screen.c

Go to the documentation of this file.

 
/*********************
 *      INCLUDES
 *********************/
#include "app_config.h"
#include "nbgl_front.h"
#include "nbgl_screen.h"
#include "nbgl_debug.h"
#include "nbgl_touch.h"
#include "os_pic.h"
#include "os_io_seph_ux.h"
#include "os_task.h"
 
/*********************
 *      DEFINES
 *********************/
 
#define SCREEN_STACK_SIZE 4
 
/**********************
 *      TYPEDEFS
 **********************/
 
/**********************
 *      VARIABLES
 **********************/
static nbgl_screen_t screenStack[SCREEN_STACK_SIZE];
// number of screens in the stack
static uint8_t nbScreensOnStack = 0;
// this is a pointer of the current top of stack screen
static nbgl_screen_t *topOfStack;
 
/**********************
 *  STATIC PROTOTYPES
 **********************/
 
/**********************
 *   GLOBAL FUNCTIONS
 **********************/
 
void nbgl_screenRedraw(void)
{
    if (nbScreensOnStack == 0) {
        LOG_WARN(SCREEN_LOGGER, "nbgl_screenRedraw(): no screen to redraw\n");
        return;
    }
    LOG_DEBUG(SCREEN_LOGGER, "nbgl_screenRedraw(): nbScreensOnStack = %d\n", nbScreensOnStack);
#ifdef TARGET_STAX
    // by default, exclude only left border from touch
    // if any sub-object is a keyboard, this will be modified when drawing it
    touch_exclude_borders(OS_IO_TOUCH_AREA_LEFT_BORDER);
#endif  // TARGET_STAX
 
    nbgl_screen_reinit();
    nbgl_objDraw((nbgl_obj_t *) topOfStack);
}
 
nbgl_obj_t *nbgl_screenGetAt(uint8_t screenIndex)
{
    if (screenIndex < nbScreensOnStack) {
        return (nbgl_obj_t *) &screenStack[screenIndex];
    }
    else {
        return NULL;
    }
}
 
nbgl_obj_t *nbgl_screenGetTop(void)
{
    if (nbScreensOnStack > 0) {
        return (nbgl_obj_t *) topOfStack;
    }
    else {
        return NULL;
    }
}
 
uint8_t nbgl_screenGetCurrentStackSize(void)
{
    if ((nbScreensOnStack == 1) && (screenStack[0].container.nbChildren == 0)) {
        return 0;
    }
    return nbScreensOnStack;
}
 
uint8_t nbgl_screenGetUxStackSize(void)
{
    uint8_t        nbUxScreens = 0;
    nbgl_screen_t *screen      = (nbgl_screen_t *) topOfStack;
 
    if (nbgl_screenGetCurrentStackSize() == 0) {
        return 0;
    }
    while (screen != NULL) {
        if (screen->isUxScreen) {
            nbUxScreens++;
        }
        screen = screen->previous;
    }
    return nbUxScreens;
}
 
static int nbgl_screenSetAt(uint8_t                                 screenIndex,
                            nbgl_obj_t                           ***children,
                            uint8_t                                 nbChildren,
                            const nbgl_screenTickerConfiguration_t *ticker,
#ifdef HAVE_SE_TOUCH
                            nbgl_touchCallback_t callback)
{
#else   // HAVE_SE_TOUCH
                            nbgl_buttonCallback_t callback)
{
#endif  // HAVE_SE_TOUCH
    if (screenIndex >= SCREEN_STACK_SIZE) {
        LOG_WARN(SCREEN_LOGGER, "nbgl_screenSetAt(): forbidden screenIndex (%d)\n", screenIndex);
        return -1;
    }
    *children                                   = nbgl_containerPoolGet(nbChildren, screenIndex);
    screenStack[screenIndex].container.obj.type = SCREEN;
#ifdef HAVE_SE_TOUCH
    screenStack[screenIndex].container.obj.area.backgroundColor = WHITE;
#else   // HAVE_SE_TOUCH
    screenStack[screenIndex].container.obj.area.backgroundColor = BLACK;
#endif  // HAVE_SE_TOUCH
    screenStack[screenIndex].container.obj.area.height = SCREEN_HEIGHT;
    screenStack[screenIndex].container.obj.area.width  = SCREEN_WIDTH;
    screenStack[screenIndex].container.obj.area.x0     = 0;
    screenStack[screenIndex].container.obj.area.y0     = 0;
    screenStack[screenIndex].container.obj.rel_x0      = 0;
    screenStack[screenIndex].container.obj.rel_y0      = 0;
    screenStack[screenIndex].index                     = screenIndex;
    screenStack[screenIndex].container.layout          = VERTICAL;
    screenStack[screenIndex].container.children        = *children;
    screenStack[screenIndex].container.nbChildren      = nbChildren;
#ifdef HAVE_SE_TOUCH
    screenStack[screenIndex].touchCallback = callback;
#else   // HAVE_SE_TOUCH
    screenStack[screenIndex].buttonCallback                     = callback;
#endif  // HAVE_SE_TOUCH
    if (ticker != NULL) {
        screenStack[screenIndex].ticker.tickerCallback
            = (nbgl_tickerCallback_t) PIC(ticker->tickerCallback);
        screenStack[screenIndex].ticker.tickerIntervale = ticker->tickerIntervale;
        screenStack[screenIndex].ticker.tickerValue     = ticker->tickerValue;
    }
    else {
        screenStack[screenIndex].ticker.tickerCallback = NULL;
    }
    screenStack[screenIndex].isUxScreen = (os_sched_current_task() == TASK_BOLOS_UX);
    return 0;
}
 
int nbgl_screenSet(nbgl_obj_t                           ***elements,
                   uint8_t                                 nbElements,
                   const nbgl_screenTickerConfiguration_t *ticker,
#ifdef HAVE_SE_TOUCH
                   nbgl_touchCallback_t callback)
{
#else   // HAVE_SE_TOUCH
                   nbgl_buttonCallback_t callback)
{
#endif  // HAVE_SE_TOUCH
    // if no screen, consider it as a first fake push
    if (nbScreensOnStack == 0) {
        nbScreensOnStack++;
        topOfStack = &screenStack[0];
    }
    // release used objects and containers
    nbgl_objPoolRelease(0);
    nbgl_containerPoolRelease(0);
    // always use the first layer (background) for user application
    return nbgl_screenSetAt(0, elements, nbElements, ticker, callback);
}
 
int nbgl_screenUpdateNbElements(uint8_t screenIndex, uint8_t nbElements)
{
    screenStack[screenIndex].container.nbChildren = nbElements;
    return 0;
}
 
int nbgl_screenUpdateBackgroundColor(uint8_t screenIndex, color_t color)
{
    screenStack[screenIndex].container.obj.area.backgroundColor = color;
    return 0;
}
 
int nbgl_screenUpdateTicker(uint8_t screenIndex, const nbgl_screenTickerConfiguration_t *ticker)
{
    if (ticker != NULL) {
        screenStack[screenIndex].ticker.tickerCallback
            = (nbgl_tickerCallback_t) PIC(ticker->tickerCallback);
        screenStack[screenIndex].ticker.tickerIntervale = ticker->tickerIntervale;
        screenStack[screenIndex].ticker.tickerValue     = ticker->tickerValue;
    }
    else {
        screenStack[screenIndex].ticker.tickerCallback = NULL;
    }
    return 0;
}
 
nbgl_obj_t **nbgl_screenGetElements(uint8_t screenIndex)
{
    return screenStack[screenIndex].container.children;
}
 
int nbgl_screenPush(nbgl_obj_t                           ***elements,
                    uint8_t                                 nbElements,
                    const nbgl_screenTickerConfiguration_t *ticker,
#ifdef HAVE_SE_TOUCH
                    nbgl_touchCallback_t callback)
{
#else   // HAVE_SE_TOUCH
                    nbgl_buttonCallback_t callback)
{
#endif  // HAVE_SE_TOUCH
    uint8_t screenIndex;
    if (nbScreensOnStack >= SCREEN_STACK_SIZE) {
        LOG_WARN(SCREEN_LOGGER,
                 "nbgl_screenPush(): already in highest index in the stack(%d)\n",
                 nbScreensOnStack - 1);
        return -1;
    }
    // if no screen, consider it as a first fake push
    if (nbScreensOnStack == 0) {
        screenIndex      = 1;  // push at position 1 because 0 is reserved for background
        topOfStack       = &screenStack[screenIndex];
        topOfStack->next = NULL;
        // link top of stack to background (even if empty)
        topOfStack->previous                = &screenStack[0];
        screenStack[0].next                 = topOfStack;
        screenStack[0].container.nbChildren = 0;
        // count empty background as an active screen
        nbScreensOnStack++;
    }
    else {
        // find a non used screen in the array
        for (screenIndex = 1; screenIndex < SCREEN_STACK_SIZE; screenIndex++) {
            if (screenStack[screenIndex].previous == NULL) {
                // if no previous, means unused, so take it
                // update previous topOfStack
                topOfStack->next                  = &screenStack[screenIndex];
                screenStack[screenIndex].previous = topOfStack;
                // search for a potential progress bar in current topOfStack to reset it if needed
                nbgl_progress_bar_t *progress
                    = (nbgl_progress_bar_t *) nbgl_screenContainsObjType(topOfStack, PROGRESS_BAR);
                if ((progress != NULL) && (progress->resetIfOverriden)) {
                    progress->state = 0;
                }
#ifdef SCREEN_SIZE_WALLET
                // search for a potential keypad in current topOfStack to force redraw if needed
                nbgl_keypad_t *keypad
                    = (nbgl_keypad_t *) nbgl_screenContainsObjType(topOfStack, KEYPAD);
                if (keypad != NULL) {
                    keypad->digitsChanged = true;
                }
#endif  // SCREEN_SIZE_WALLET
        // new top of stack
                topOfStack       = &screenStack[screenIndex];
                topOfStack->next = NULL;
                break;
            }
        }
        if (screenIndex == SCREEN_STACK_SIZE) {
            // should never happen
            LOG_WARN(SCREEN_LOGGER, "nbgl_screenPush(): corruption in stack\n");
        }
    }
    if (nbgl_screenSetAt(screenIndex, elements, nbElements, ticker, callback) >= 0) {
        nbScreensOnStack++;
        LOG_DEBUG(SCREEN_LOGGER, "nbgl_screenPush(): screen %d is now top of stack\n", screenIndex);
        return screenIndex;
    }
    else {
        return -1;
    }
}
 
int nbgl_screenPop(uint8_t screenIndex)
{
    if (nbScreensOnStack == 0) {
        LOG_WARN(SCREEN_LOGGER, "nbgl_screenPop(): already in lowest index in the stack\n");
        return -1;
    }
    LOG_DEBUG(SCREEN_LOGGER, "nbgl_screenPop(): at index %d\n", screenIndex);
    nbScreensOnStack--;
    // move top of stack if needed
    if (&screenStack[screenIndex] == topOfStack) {
        if (nbScreensOnStack == 0) {
            topOfStack = NULL;
        }
        else {
            topOfStack = topOfStack->previous;
        }
    }
    else {
        // connect previous to next
        if (screenStack[screenIndex].previous != NULL) {
            screenStack[screenIndex].previous->next = screenStack[screenIndex].next;
        }
        if (screenStack[screenIndex].next != NULL) {
            screenStack[screenIndex].next->previous = screenStack[screenIndex].previous;
        }
    }
    // free slot
    screenStack[screenIndex].previous             = NULL;
    screenStack[screenIndex].next                 = NULL;
    screenStack[screenIndex].container.nbChildren = 0;
    screenStack[screenIndex].container.children   = NULL;
    // release used objects and containers
    nbgl_objPoolRelease(screenIndex);
    nbgl_containerPoolRelease(screenIndex);
 
    // special case when we pop the only modal and no real background is under it
    if ((nbScreensOnStack == 1) && (screenStack[0].container.nbChildren == 0)) {
        nbScreensOnStack = 0;
        topOfStack       = NULL;
    }
    return 0;
}
 
int nbgl_screenReset(void)
{
    uint8_t screenIndex;
    for (screenIndex = 0; screenIndex < SCREEN_STACK_SIZE; screenIndex++) {
        if ((screenStack[screenIndex].previous != NULL)
            || (screenStack[screenIndex].next != NULL)) {
            // release used objects and containers
            nbgl_objPoolRelease(screenIndex);
            nbgl_containerPoolRelease(screenIndex);
        }
        screenStack[screenIndex].container.children   = NULL;
        screenStack[screenIndex].container.nbChildren = 0;
    }
    nbScreensOnStack = 0;
    topOfStack       = NULL;
    return 1;
}
 
void nbgl_screenHandler(uint32_t intervaleMs)
{
    // ensure a screen exists
    if (nbScreensOnStack == 0) {
        return;
    }
    // call ticker callback of top of stack if active and not expired yet (for a non periodic)
    if ((topOfStack->ticker.tickerCallback != NULL) && (topOfStack->ticker.tickerValue != 0)) {
        topOfStack->ticker.tickerValue -= MIN(topOfStack->ticker.tickerValue, intervaleMs);
        if (topOfStack->ticker.tickerValue == 0) {
            // rearm if intervale is not null, and call the registered function
            topOfStack->ticker.tickerValue = topOfStack->ticker.tickerIntervale;
            topOfStack->ticker.tickerCallback();
        }
    }
}
 
static bool objIsIn(nbgl_obj_t *refObj, nbgl_obj_t *obj)
{
    uint8_t i;
 
    if (obj == NULL) {
        return false;
    }
    if ((nbgl_obj_t *) refObj == obj) {
        LOG_DEBUG(SCREEN_LOGGER, "nbgl_screenContainsObj(): yes\n");
        return true;
    }
 
    if ((refObj->type == SCREEN) || (refObj->type == CONTAINER)) {
        nbgl_container_t *container = (nbgl_container_t *) refObj;
        // draw the children, if any
        if (container->children != NULL) {
            for (i = 0; i < container->nbChildren; i++) {
                nbgl_obj_t *current = container->children[i];
                if (current != NULL) {
                    if (objIsIn(current, obj) == true) {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}
 
static nbgl_obj_t *objIsOfType(nbgl_obj_t *refObj, nbgl_obj_type_t type)
{
    uint8_t i;
 
    if (refObj->type == type) {
        LOG_DEBUG(SCREEN_LOGGER, "objIsOfType(): yes\n");
        return refObj;
    }
 
    if ((refObj->type == SCREEN) || (refObj->type == CONTAINER)) {
        nbgl_container_t *container = (nbgl_container_t *) refObj;
        // draw the children, if any
        if (container->children != NULL) {
            for (i = 0; i < container->nbChildren; i++) {
                nbgl_obj_t *current = container->children[i];
                if (current != NULL) {
                    nbgl_obj_t *found = objIsOfType(current, type);
                    if (found) {
                        return found;
                    }
                }
            }
        }
    }
    return NULL;
}
 
bool nbgl_screenContainsObj(nbgl_obj_t *obj)
{
    if (nbScreensOnStack == 0) {
        return false;
    }
    return objIsIn((nbgl_obj_t *) topOfStack, obj);
}
 
nbgl_obj_t *nbgl_screenContainsObjType(nbgl_screen_t *screen, nbgl_obj_type_t type)
{
    if (nbScreensOnStack == 0) {
        return NULL;
    }
 
    return objIsOfType((nbgl_obj_t *) screen, type);
}