Use different touch contexts for App & UX

lib_nbgl/include/nbgl_obj.h

@@ -578,6 +578,7 @@ void     nbgl_objInit(void);
 void     nbgl_objDraw(nbgl_obj_t *obj);
 void     nbgl_objAllowDrawing(bool enable);
 uint8_t *nbgl_objGetRAMBuffer(void);
+bool     nbgl_objIsUx(nbgl_obj_t *obj);
 
 void         nbgl_objPoolRelease(uint8_t layer);
 nbgl_obj_t  *nbgl_objPoolGet(nbgl_obj_type_t type, uint8_t layer);

lib_nbgl/include/nbgl_touch.h

@@ -23,18 +23,19 @@ extern "C" {
 // duration of a short touch on touch panel (in ms)
 #define SHORT_TOUCH_DURATION 0
 // duration of a long touch on touch panel (in ms)
-#define LONG_TOUCH_DURATION  1500
+#define LONG_TOUCH_DURATION  3000
 /**********************
  *      TYPEDEFS
  **********************/
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
-void        nbgl_touchHandler(nbgl_touchStatePosition_t *touchEvent, uint32_t currentTimeMs);
-bool        nbgl_touchGetTouchedPosition(nbgl_obj_t                 *obj,
-                                         nbgl_touchStatePosition_t **firstPos,
-                                         nbgl_touchStatePosition_t **lastPos);
+void nbgl_touchInit(bool fromUx);
+void nbgl_touchHandler(bool fromUx, nbgl_touchStatePosition_t *touchEvent, uint32_t currentTimeMs);
+bool nbgl_touchGetTouchedPosition(nbgl_obj_t                 *obj,
+                                  nbgl_touchStatePosition_t **firstPos,
+                                  nbgl_touchStatePosition_t **lastPos);
 uint32_t    nbgl_touchGetTouchDuration(nbgl_obj_t *obj);
 nbgl_obj_t *nbgl_touchGetObjectFromId(nbgl_obj_t *obj, uint8_t id);
 

lib_nbgl/src/nbgl_fonts.c

@@ -66,12 +66,13 @@ static const LANGUAGE_PACK *language_pack;
 #include "nbgl_font_open_sans_light_16.inc"
 #endif  // SCREEN_SIZE_WALLET
 
-const nbgl_font_t *const C_nbgl_fonts[] = {
+__attribute__((section("._nbgl_fonts_"))) const nbgl_font_t *const C_nbgl_fonts[] = {
 
 #include "nbgl_font_rom_struct.inc"
 
 };
-const unsigned int C_nbgl_fonts_count = sizeof(C_nbgl_fonts) / sizeof(C_nbgl_fonts[0]);
+__attribute__((section("._nbgl_fonts_"))) const unsigned int C_nbgl_fonts_count
+    = sizeof(C_nbgl_fonts) / sizeof(C_nbgl_fonts[0]);
 
 #if (defined(HAVE_BOLOS) && !defined(BOLOS_OS_UPGRADER_APP))
 #if !defined(HAVE_LANGUAGE_PACK)

lib_nbgl/src/nbgl_obj.c

@@ -14,6 +14,7 @@
 #include "nbgl_front.h"
 #include "nbgl_debug.h"
 #include "nbgl_screen.h"
+#include "nbgl_touch.h"
 #include "os_print.h"
 #include "os_helpers.h"
 #include "os_pic.h"
@@ -1629,12 +1630,17 @@ void nbgl_refreshReset(void)
 
 /**
  * @brief This functions inits all internal of nbgl objects layer
+ * @note it is supposed to be called only from App
  *
  */
 void nbgl_objInit(void)
 {
     // init area to the smallest size
     nbgl_refreshReset();
+    objDrawingDisabled = false;
+#ifdef HAVE_SE_TOUCH
+    nbgl_touchInit(false);
+#endif
 }
 
 /**
@@ -1650,9 +1656,30 @@ void nbgl_objAllowDrawing(bool enable)
 /**
  * @brief This function is used to get the all purpose RAM buffer
  *
- * @param enable if true, enables drawing/refresh, otherwise disables
+ * @return a pointer to the all purpose RAM buffer
  */
 uint8_t *nbgl_objGetRAMBuffer(void)
 {
     return ramBuffer;
 }
+
+/**
+ * @brief This function returns true if the object belongs to a UxScreen
+ *
+ * @return true if the object belongs to a UxScreen
+ */
+bool nbgl_objIsUx(nbgl_obj_t *obj)
+{
+    nbgl_obj_t *parent = obj;
+    // search screen in parenthood
+    while (parent->parent != NULL) {
+        parent = parent->parent;
+    }
+    if (parent->type == SCREEN) {
+        return (((nbgl_screen_t *) parent)->isUxScreen);
+    }
+    else {
+        // should never happen
+        return true;
+    }
+}

lib_nbgl/src/nbgl_screen.c

@@ -368,7 +368,7 @@ int nbgl_screenPush(nbgl_obj_t                           ***elements,
                 nbgl_touchStatePosition_t touchStatePosition = {.state = RELEASED, .x = 0, .y = 0};
                 // make a fake touch release for the current top-of-stack to avoid issue
                 // (for example in long-touch press)
-                nbgl_touchHandler(&touchStatePosition, 0);
+                nbgl_touchHandler(topOfStack->isUxScreen, &touchStatePosition, 0);
 #endif  // HAVE_SE_TOUCH
         // new top of stack
                 topOfStack       = &screenStack[screenIndex];

lib_nbgl/src/nbgl_touch.c

@@ -20,10 +20,23 @@
 /*********************
  *      DEFINES
  *********************/
+enum {
+    UX_CTX = 0,
+    APP_CTX,
+    NB_CTXS
+};
 
 /**********************
  *      TYPEDEFS
  **********************/
+typedef struct nbgl_touchCtx_s {
+    nbgl_touchState_t         lastState;
+    uint32_t                  lastPressedTime;
+    uint32_t                  lastCurrentTime;
+    nbgl_obj_t               *lastPressedObj;
+    nbgl_touchStatePosition_t firstTouchedPosition;
+    nbgl_touchStatePosition_t lastTouchedPosition;
+} nbgl_touchCtx_t;
 
 /**********************
  *  STATIC PROTOTYPES
@@ -32,10 +45,7 @@
 /**********************
  *  STATIC VARIABLES
  **********************/
-static uint32_t                  lastPressedTime = 0;
-static uint32_t                  lastCurrentTime = 0;
-static nbgl_obj_t               *lastPressedObj  = NULL;
-static nbgl_touchStatePosition_t firstTouchedPosition, lastTouchedPosition;
+static nbgl_touchCtx_t touchCtxs[NB_CTXS];
 
 /**********************
  *      VARIABLES
@@ -255,29 +265,41 @@ static nbgl_touchType_t nbgl_detectSwipe(nbgl_touchStatePosition_t *last,
 /**********************
  *   GLOBAL FUNCTIONS
  **********************/
+/**
+ * @brief Function to initialize the touch context
+ * @param fromUx if true, means to initialize the UX context, otherwise App one
+ */
+void nbgl_touchInit(bool fromUx)
+{
+    nbgl_touchCtx_t *ctx = fromUx ? &touchCtxs[UX_CTX] : &touchCtxs[APP_CTX];
+    memset(ctx, 0, sizeof(nbgl_touchCtx_t));
+}
 
 /**
  * @brief Function to be called periodically to check touchscreen state
  * and coordinates
+ * @param fromUx if true, means this is called from the UX, not the App
  * @param touchStatePosition state and position read from touch screen
  * @param currentTime current time in ms
  */
-void nbgl_touchHandler(nbgl_touchStatePosition_t *touchStatePosition, uint32_t currentTime)
+void nbgl_touchHandler(bool                       fromUx,
+                       nbgl_touchStatePosition_t *touchStatePosition,
+                       uint32_t                   currentTime)
 {
-    static nbgl_touchState_t lastState = RELEASED;
-    nbgl_obj_t              *foundObj;
+    nbgl_obj_t      *foundObj;
+    nbgl_touchCtx_t *ctx = fromUx ? &touchCtxs[UX_CTX] : &touchCtxs[APP_CTX];
 
     // save last received currentTime
-    lastCurrentTime = currentTime;
+    ctx->lastCurrentTime = currentTime;
 
-    if (lastState == RELEASED) {
+    if (ctx->lastState == RELEASED) {
         // filter out not realistic cases (successive RELEASE events)
         if (RELEASED == touchStatePosition->state) {
-            lastState = touchStatePosition->state;
+            ctx->lastState = touchStatePosition->state;
             return;
         }
         // memorize first touched position
-        memcpy(&firstTouchedPosition, touchStatePosition, sizeof(nbgl_touchStatePosition_t));
+        memcpy(&ctx->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);
@@ -289,95 +311,98 @@ void nbgl_touchHandler(nbgl_touchStatePosition_t *touchStatePosition, uint32_t c
     // foundObj->type);
     if (foundObj == NULL) {
         LOG_DEBUG(TOUCH_LOGGER, "nbgl_touchHandler: no found obj\n");
-        if ((touchStatePosition->state == PRESSED) && (lastState == PRESSED)
-            && (lastPressedObj != NULL)) {
+        if ((touchStatePosition->state == PRESSED) && (ctx->lastState == PRESSED)
+            && (ctx->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);
+            if (nbgl_screenContainsObj(ctx->lastPressedObj)) {
+                applytouchStatePosition(ctx->lastPressedObj, OUT_OF_TOUCH);
             }
         }
         // Released event has been handled, forget lastPressedObj
-        lastPressedObj = NULL;
+        ctx->lastPressedObj = NULL;
     }
 
     // memorize last touched position
-    memcpy(&lastTouchedPosition, touchStatePosition, sizeof(nbgl_touchStatePosition_t));
+    memcpy(&ctx->lastTouchedPosition, touchStatePosition, sizeof(nbgl_touchStatePosition_t));
 
     if (touchStatePosition->state == RELEASED) {
-        nbgl_touchType_t swipe    = nbgl_detectSwipe(touchStatePosition, &firstTouchedPosition);
+        nbgl_touchType_t swipe = nbgl_detectSwipe(touchStatePosition, &ctx->firstTouchedPosition);
         bool             consumed = false;
 
         if (swipe != NB_TOUCH_TYPES) {
             // Swipe detected
             nbgl_obj_t *swipedObj = getSwipableObject(
-                nbgl_screenGetTop(), &firstTouchedPosition, &lastTouchedPosition, swipe);
+                nbgl_screenGetTop(), &ctx->firstTouchedPosition, &ctx->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)))) {
+        if (!consumed && (ctx->lastPressedObj != NULL)
+            && ((foundObj == ctx->lastPressedObj)
+                || (nbgl_screenContainsObj(ctx->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);
+            applytouchStatePosition(ctx->lastPressedObj, TOUCH_RELEASED);
+            if (currentTime >= (ctx->lastPressedTime + LONG_TOUCH_DURATION)) {
+                applytouchStatePosition(ctx->lastPressedObj, LONG_TOUCHED);
             }
-            else if (currentTime >= (lastPressedTime + SHORT_TOUCH_DURATION)) {
-                applytouchStatePosition(lastPressedObj, TOUCHED);
+            else if (currentTime >= (ctx->lastPressedTime + SHORT_TOUCH_DURATION)) {
+                applytouchStatePosition(ctx->lastPressedObj, TOUCHED);
             }
         }
         // Released event has been handled, forget lastPressedObj
-        lastPressedObj = NULL;
+        ctx->lastPressedObj = NULL;
     }
     else {  // PRESSED
-        if ((lastState == PRESSED) && (lastPressedObj != NULL)) {
-            if (foundObj != lastPressedObj) {
+        if ((ctx->lastState == PRESSED) && (ctx->lastPressedObj != NULL)) {
+            if (foundObj != ctx->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);
+                if (nbgl_screenContainsObj(ctx->lastPressedObj)) {
+                    applytouchStatePosition(ctx->lastPressedObj, OUT_OF_TOUCH);
                 }
-                lastPressedObj = NULL;
+                ctx->lastPressedObj = NULL;
             }
             else {
                 // warn the concerned object that it is still touched
                 applytouchStatePosition(foundObj, TOUCHING);
             }
         }
-        else if (lastState == RELEASED) {
+        else if (ctx->lastState == RELEASED) {
             // newly touched object
-            lastPressedObj  = foundObj;
-            lastPressedTime = currentTime;
+            ctx->lastPressedObj  = foundObj;
+            ctx->lastPressedTime = currentTime;
             applytouchStatePosition(foundObj, TOUCH_PRESSED);
             applytouchStatePosition(foundObj, TOUCHING);
         }
     }
 
-    lastState = touchStatePosition->state;
+    ctx->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;
+    nbgl_touchCtx_t *ctx = nbgl_objIsUx(obj) ? &touchCtxs[UX_CTX] : &touchCtxs[APP_CTX];
+    LOG_DEBUG(TOUCH_LOGGER, "nbgl_touchGetTouchedPosition: %p %p\n", obj, ctx->lastPressedObj);
+    if (obj == ctx->lastPressedObj) {
+        *firstPos = &ctx->firstTouchedPosition;
+        *lastPos  = &ctx->lastTouchedPosition;
         return true;
     }
     return false;
 }
 
 uint32_t nbgl_touchGetTouchDuration(nbgl_obj_t *obj)
 {
-    if (obj == lastPressedObj) {
-        return (lastCurrentTime - lastPressedTime);
+    nbgl_touchCtx_t *ctx = nbgl_objIsUx(obj) ? &touchCtxs[UX_CTX] : &touchCtxs[APP_CTX];
+    if (obj == ctx->lastPressedObj) {
+        return (ctx->lastCurrentTime - ctx->lastPressedTime);
     }
     return 0;
 }

lib_ux_nbgl/ux.c

@@ -75,7 +75,7 @@ void ux_process_finger_event(uint8_t seph_packet[])
 #ifdef HAVE_HW_TOUCH_SWIPE
         pos.swipe = seph_packet[10];
 #endif  // HAVE_HW_TOUCH_SWIPE
-        nbgl_touchHandler(&pos, nbTicks * 100);
+        nbgl_touchHandler(false, &pos, nbTicks * 100);
         nbgl_refresh();
     }
 }
@@ -115,13 +115,16 @@ void ux_process_ticker_event(void)
 
     // enable/disable drawing according to UX decision
     nbgl_objAllowDrawing(displayEnabled);
-    // update ticker in NBGL
-    nbgl_screenHandler(100);
 
+    // do not do any action on screens if display is disabled, because
+    // UX has the hand
     if (!displayEnabled) {
         return;
     }
 
+    // update ticker in NBGL
+    nbgl_screenHandler(100);
+
 #ifdef HAVE_SE_TOUCH
     // handle touch only if detected as pressed in last touch message
     if (pos.state == PRESSED) {
@@ -131,7 +134,7 @@ void ux_process_ticker_event(void)
         pos.x     = touch_info.x;
         pos.y     = touch_info.y;
         // Send current touch position to nbgl
-        nbgl_touchHandler(&pos, nbTicks * 100);
+        nbgl_touchHandler(false, &pos, nbTicks * 100);
     }
 #endif  // HAVE_SE_TOUCH
     nbgl_refresh();

unit-tests/lib_nbgl/test_nbgl_obj.c

@@ -188,8 +188,9 @@ void nbgl_screen_reinit(void)
 {
     return;
 }
-
 #ifdef HAVE_SE_TOUCH
+void nbgl_touchInit(void) {}
+
 static void test_draw_obj(void **state __attribute__((unused)))
 {
     nbgl_image_t          *image;