/*! \fn guiDisplaySmartcardUnlockedScreen(uint8_t* username)
* \brief Display the smartcard unlocked screen
* \param username The username (if there's one)
*/
void guiDisplaySmartcardUnlockedScreen(uint8_t* username)
{
#if defined(MINI_VERSION)
uint8_t temp_Y = THREE_LINE_TEXT_SECOND_POS;
// Clear screen, check that the username is valid
oledClear();
if ((username[0] != 0) && (username[0] != 0xFF))
{
temp_Y = THREE_LINE_TEXT_FIRST_POS;
miniOledPutCenteredString(THREE_LINE_TEXT_SECOND_POS, readStoredStringToBuffer(ID_STRING_YOUR_USERNAME));
miniOledPutCenteredString(THREE_LINE_TEXT_THIRD_POS, (char*)username);
}
miniOledPutCenteredString(temp_Y, readStoredStringToBuffer(ID_STRING_CARD_UNLOCKED));
//oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0);
miniOledFlushEntireBufferToDisplay();
#elif defined(HARDWARE_OLIVIER_V1)
uint8_t temp_Y = 24;
// Clear screen, check that the username is valid
oledClear();
if ((username[0] != 0) && (username[0] != 0xFF))
{
temp_Y -= 16;
oledPutstrXY(10, 24, OLED_CENTRE, readStoredStringToBuffer(ID_STRING_YOUR_USERNAME));
oledPutstrXY(10, 40, OLED_CENTRE, (const char*)username);
}
oledPutstrXY(10, temp_Y, OLED_CENTRE, readStoredStringToBuffer(ID_STRING_CARD_UNLOCKED));
oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0);
oledDisplayOtherBuffer();
#endif
}
/*! \fn guiDisplayGoingToSleep(void)
* \brief Going to sleep code
*/
void guiDisplayGoingToSleep(void)
{
oledClear();
oledPutstrXY(10, 24, OLED_CENTRE, readStoredStringToBuffer(ID_STRING_GOINGTOSLEEP));
oledBitmapDrawFlash(2, 17, BITMAP_ZZZ, 0);
oledDisplayOtherBuffer();
}
/*! \fn displayDebugStatusCode(char* text)
* \brief Display a debug status code on the screen to help diagnose usb comms
* \param text The text
*/
void displayDebugStatusCode(char* text)
{
if (oledIsOn() == TRUE)
{
oledWriteActiveBuffer();
oledPutstrXY(0, 0, OLED_LEFT, text);
oledWriteInactiveBuffer();
}
}
/*! \fn displayServiceAtGivenSlot(uint8_t slot, const char* text)
* \brief Display text at a given slot when choosing between services
* \param slot The slot number
* \param text The text to display
*/
void displayServiceAtGivenSlot(uint8_t slot, const char* text)
{
char temp_disptext[40];
// Truncate string and display it
memcpy(temp_disptext, text, sizeof(temp_disptext));
temp_disptext[sizeof(temp_disptext)-1] = 0;
temp_disptext[INDEX_TRUNCATE_SERVICE_SEARCH] = 0;
oledPutstrXY((slot & 0x01)*0xFF, 4 + (slot & 0x02)*20, (slot & 0x01)*OLED_RIGHT, temp_disptext);
}
/*! \fn displayCredentialAtSlot(uint8_t slot, const char* text)
* \brief Display text at a given slot when choosing between credentials/favorites
* \param slot The slot number
* \param text The text to display
* \param truncate_index Index at which we truncate
*/
void displayCredentialAtSlot(uint8_t slot, char* text, uint8_t truncate_index)
{
char temp_disptext[40];
int8_t yoffset = 0;
if (slot & 0x08)
{
yoffset = (slot & 0x02)? -10:10;
}
// Truncate and display string
memcpy(temp_disptext, text, sizeof(temp_disptext));
temp_disptext[sizeof(temp_disptext)-1] = 0;
temp_disptext[truncate_index] = 0;
oledPutstrXY((slot & 0x01)*0xFF, 1 + (slot & 0x02)*24 + yoffset, (slot & 0x01)*OLED_RIGHT, temp_disptext);
}
/*! \fn displayCredentialAtSlot(uint8_t slot, const char* text)
* \brief Display text at a given slot when choosing between credentials/favorites
* \param slot The slot number
* \param text The text to display
*/
void displayCredentialAtSlot(uint8_t slot, char* text)
{
char temp_disptext[40];
int8_t yoffset = 0;
if (slot & 0x08)
{
yoffset = (slot & 0x02)? -10:10;
}
// Truncate and display string
memcpy(temp_disptext, text, sizeof(temp_disptext));
temp_disptext[sizeof(temp_disptext)-1] = 0;
temp_disptext[INDEX_TRUNCATE_LOGIN_FAV] = 0;
oledPutstrXY((slot & 0x01)*0xFF, (slot & 0x02)*23 + yoffset, (slot & 0x01)*OLED_RIGHT, temp_disptext);
}
/*! \fn guiDisplayTextInformationOnScreen(char* text)
* \brief Display text information on screen
* \param text Text to display
*/
void guiDisplayTextInformationOnScreen(char* text)
{
oledClear();
#if defined(HARDWARE_OLIVIER_V1)
// No LEDs
touchDetectionRoutine(0xFF);
oledPutstrXY(10, 24, OLED_CENTRE, text);
oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0);
oledDisplayOtherBuffer();
#elif defined(MINI_VERSION)
miniOledPutCenteredString(THREE_LINE_TEXT_SECOND_POS, text);
//oledPutstrXY(0, 10, OLED_CENTRE, text);
//oledBitmapDrawFlash(2, 17, BITMAP_INFO, 0);
miniOledFlushEntireBufferToDisplay();
#endif
}
/*! \fn displayCurrentSearchLoginTexts(char* text)
* \brief Display current search login text
* \param text Text to be displayed
* \param resultsarray Pointer to the array in which to store the addresses
* \return Number of matching parents we displayed
*/
uint8_t displayCurrentSearchLoginTexts(char* text, uint16_t* resultsarray)
{
uint16_t tempNodeAddr;
pNode temp_pnode;
uint8_t i;
// Set font for search text
oledSetFont(FONT_PROFONT_18);
// Clear current text
oledFillXY(100, 14, 50, 24, 0x00);
// Display new search text
oledPutstrXY(148, 14, OLED_RIGHT, text);
// Set default font
oledSetFont(FONT_DEFAULT);
// Find the address of the first match
tempNodeAddr = searchForServiceName((uint8_t*)text, COMPARE_MODE_COMPARE, SERVICE_CRED_TYPE);
if (tempNodeAddr != last_matching_parent_addr)
{
last_matching_parent_addr = tempNodeAddr;
for (i = 0; i < 4; i++)
{
oledFillXY((i&1)*175, 6+(i&2)*19, 81, 14, 0x00);
}
// Print the next 4 services
i = 0;
while ((tempNodeAddr != NODE_ADDR_NULL) && (i != 4))
{
resultsarray[i] = tempNodeAddr;
readParentNode(&temp_pnode, tempNodeAddr);
displayServiceAtGivenSlot(i, (const char*)temp_pnode.service);
tempNodeAddr = temp_pnode.nextParentAddress;
i++;
}
// Store and return number of children
last_matching_parent_number = i;
}
return last_matching_parent_number;
}
/*! \fn guiGetPinFromUser(volatile uint16_t* pin_code, uint8_t stringID)
* \brief Ask the user to enter a PIN
* \param pin_code Pointer to where to store the pin code
* \param stringID String ID
* \return If the user approved the request
*/
RET_TYPE guiGetPinFromUser(volatile uint16_t* pin_code, uint8_t stringID)
{
// If we don't need a pin code, send default one
#if defined(NO_PIN_CODE_REQUIRED) || defined(HARDWARE_V1) || defined(V2_DEVELOPERS_BOTPCB_BOOTLOADER_SETUP)
*pin_code = SMARTCARD_DEFAULT_PIN;
return RETURN_OK;
#endif
RET_TYPE ret_val = RETURN_NOK;
uint8_t selected_digit = 0;
uint8_t finished = FALSE;
uint8_t current_pin[4];
RET_TYPE temp_rettype;
int8_t temp_int8;
// Set current pin to 0000
memset((void*)current_pin, 0, 4);
// Draw pin entering bitmap
oledClear();
oledBitmapDrawFlash(0, 0, BITMAP_YES_NO, 0);
oledBitmapDrawFlash(83, 51, BITMAP_PIN_LINES, 0);
oledBitmapDrawFlash(238, 23, BITMAP_RIGHT_ARROW, 0);
oledPutstrXY(0, 0, OLED_CENTRE, readStoredStringToBuffer(stringID));
oledDisplayOtherBuffer();
oledSetFont(FONT_PROFONT_24);
oledWriteActiveBuffer();
// Display current pin on screen
guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit);
// While the user hasn't entered his pin
while(!finished)
{
// Still process the USB commands
usbProcessIncoming(USB_CALLER_PIN);
// Detect key touches
temp_rettype = touchDetectionRoutine(0);
// Send it to the touch wheel interface logic
temp_int8 = touchWheelIntefaceLogic(temp_rettype);
// Position increment / decrement
if (temp_int8 != 0)
{
if ((current_pin[selected_digit] == 0x0F) && (temp_int8 == 1))
{
current_pin[selected_digit] = 0xFF;
}
else if ((current_pin[selected_digit] == 0) && (temp_int8 == -1))
{
current_pin[selected_digit] = 0x10;
}
current_pin[selected_digit] += temp_int8;
guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit);
}
if ((isSmartCardAbsent() == RETURN_OK) || (hasTimerExpired(TIMER_USERINT, TRUE) == TIMER_EXPIRED))
{
// Smartcard removed, no reason to continue
ret_val = RETURN_NOK;
finished = TRUE;
}
if (temp_rettype & RETURN_LEFT_PRESSED)
{
if (selected_digit == 1)
{
oledFillXY(0, 23, 18, 18, 0x00);
oledBitmapDrawFlash(0, 24, BITMAP_CROSS, 0);
}
if (selected_digit > 0)
{
// When going back set pin digit to 0
current_pin[selected_digit] = 0;
current_pin[--selected_digit] = 0;
}
else
{
ret_val = RETURN_NOK;
finished = TRUE;
}
guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit);
oledBitmapDrawFlash(238, 23, BITMAP_RIGHT_ARROW, 0);
}
else if (temp_rettype & RETURN_RIGHT_PRESSED)
{
if (selected_digit == 2)
{
oledFillXY(238, 23, 18, 18, 0x00);
oledBitmapDrawFlash(240, 24, BITMAP_TICK, 0);
}
if (selected_digit < 3)
{
selected_digit++;
}
else
{
ret_val = RETURN_OK;
finished = TRUE;
}
guiDisplayPinOnPinEnteringScreen(current_pin, selected_digit);
oledBitmapDrawFlash(0, 23, BITMAP_LEFT_ARROW, 0);
}
}
// Reset default font
oledSetFont(FONT_DEFAULT);
oledWriteInactiveBuffer();
// Store the pin
*pin_code = (uint16_t)(((uint16_t)(current_pin[0]) << 12) | (((uint16_t)current_pin[1]) << 8) | (current_pin[2] << 4) | current_pin[3]);
// Set current pin to 0000
memset((void*)current_pin, 0, 4);
// Prevent touches until the user lifts his finger
touchInhibitUntilRelease();
// Return success status
return ret_val;
}
/*! \fn guiAskForLoginSelect(pNode* p, cNode* c, uint16_t parentNodeAddress)
* \brief Ask for user login selection / approval
* \param p Pointer to a parent node
* \param c Pointer to a child node
* \param parentNodeAddress Address of the parent node
* \param bypass_confirmation Bool to bypass authorisation request
* \return Valid child node address or 0 otherwise
*/
uint16_t guiAskForLoginSelect(pNode* p, cNode* c, uint16_t parentNodeAddress, uint8_t bypass_confirmation)
{
uint16_t first_child_address, temp_child_address;
uint16_t picked_child = NODE_ADDR_NULL;
uint16_t addresses[4];
uint8_t led_mask;
int8_t i, j;
// Check parent node address
if (parentNodeAddress == NODE_ADDR_NULL)
{
return NODE_ADDR_NULL;
}
// Read the parent node
readParentNode(p, parentNodeAddress);
// Read its first child address
first_child_address = p->nextChildAddress;
// Check if there are stored credentials
if (first_child_address == NODE_ADDR_NULL)
{
guiDisplayInformationOnScreenAndWait(ID_STRING_NO_CREDS);
return NODE_ADDR_NULL;
}
// Read child node
readChildNode(c, first_child_address);
// Check if there's only one child, that's a confirmation screen
if (c->nextChildAddress == NODE_ADDR_NULL)
{
confirmationText_t temp_conf_text;
// Prepare asking confirmation screen
temp_conf_text.lines[0] = readStoredStringToBuffer(ID_STRING_CONFACCESSTO);
temp_conf_text.lines[1] = (char*)p->service;
temp_conf_text.lines[2] = readStoredStringToBuffer(ID_STRING_WITHTHISLOGIN);
temp_conf_text.lines[3] = (char*)c->login;
// Prompt user for confirmation, flash the screen
if ((bypass_confirmation == TRUE) || (guiAskForConfirmation(0xF0 | 4, &temp_conf_text) == RETURN_OK))
{
picked_child = first_child_address;
}
}
else
{
temp_child_address = first_child_address;
uint8_t action_chosen = FALSE;
while (action_chosen == FALSE)
{
// Draw asking bitmap
oledBitmapDrawFlash(0, 0, BITMAP_LOGIN, 0);
// Write domain name on screen
char temp_string[INDEX_TRUNCATE_SERVICE_CENTER+1];
memcpy(temp_string, (char*)p->service, sizeof(temp_string));
temp_string[INDEX_TRUNCATE_SERVICE_CENTER] = 0;
oledPutstrXY(0, 24, OLED_CENTRE, temp_string);
// Clear led_mask
led_mask = 0;
i = 0;
// List logins on screen
while ((temp_child_address != NODE_ADDR_NULL) && (i != 4))
{
// Read child node to get login
readChildNode(c, temp_child_address);
// Print Login at the correct slot
displayCredentialAtSlot(i, (char*)c->login, INDEX_TRUNCATE_LOGIN_FAV);
// Store address in array, fetch next address
addresses[i] = temp_child_address;
temp_child_address = c->nextChildAddress;
i++;
}
// If nothing after, hide right arrow
if ((i != 4) || (c->nextChildAddress == NODE_ADDR_NULL))
{
oledFillXY(177, 25, 16, 14, 0x00);
led_mask |= LED_MASK_RIGHT;
}
// Light only the available choices
for (j = i; j < 4; j++)
{
led_mask |= (1 << j);
}
// Display picture
oledDisplayOtherBuffer();
// Get touched quarter
j = getTouchedPositionAnswer(led_mask);
// Check its validity, knowing that by default we will return NODE_ADDR_NULL
if (j == -1)
{
// Time out
action_chosen = TRUE;
}
else if (j < i)
{
picked_child = addresses[j];
action_chosen = TRUE;
}
else if (j == TOUCHPOS_LEFT)
{
// If there is a previous children, go back 4 indexes
if (addresses[0] != first_child_address)
{
c->prevChildAddress = addresses[0];
for (i = 0; i < 5; i++)
{
temp_child_address = c->prevChildAddress;
readChildNode(c, temp_child_address);
}
}
else
{
// otherwise, return
action_chosen = TRUE;
}
}
else if ((j == TOUCHPOS_RIGHT) && (i == 4) && (c->nextChildAddress != NODE_ADDR_NULL))
{
// If there are more nodes to display, let it loop
// temp_child_address = c->nextChildAddress;
}
else
{
// Wrong position
temp_child_address = addresses[0];
}
}
}
return picked_child;
}
/*! \fn displayCurrentSearchLoginTexts(char* text)
* \brief Display current search login text
* \param text Text to be displayed
* \param resultsarray Pointer to the array in which to store the addresses
* \param search_index Current search index (aka strlen(text))
* \return Number of matching parents we displayed
*/
static inline uint8_t displayCurrentSearchLoginTexts(char* text, uint16_t* resultsarray, uint8_t search_index)
{
uint16_t tempNodeAddr;
pNode temp_pnode;
uint8_t i, j;
// Set font for search text
oledSetFont(FONT_PROFONT_18);
// Clear current text
oledFillXY(100, 18, 50, 23, 0x00);
// Display new search text
oledPutstrXY(148, 17, OLED_RIGHT, text);
// Set default font
oledSetFont(FONT_DEFAULT);
// Find the address of the first match
tempNodeAddr = searchForServiceName((uint8_t*)text, COMPARE_MODE_COMPARE, SERVICE_CRED_TYPE);
// Only change display if the first displayed service changed
if (tempNodeAddr != last_matching_parent_addr)
{
last_matching_parent_addr = tempNodeAddr;
for (i = 0; i < 4; i++)
{
oledFillXY((i&1)*170, 2+(i&2)*23, 84, 14, 0x00);
}
// Print the next 4 services (loop is until 5 for additional checks)
i = 0;
uint8_t temp_bool = TRUE;
while ((temp_bool != FALSE) && (i != 5))
{
resultsarray[i] = tempNodeAddr;
readParentNode(&temp_pnode, tempNodeAddr);
// Display only first 4 services
if (i < 4)
{
displayCredentialAtSlot(i, (char*)temp_pnode.service, INDEX_TRUNCATE_SERVICE_SEARCH);
}
// Loop around
if (temp_pnode.nextParentAddress == NODE_ADDR_NULL)
{
tempNodeAddr = getStartingParentAddress();
}
else
{
tempNodeAddr = temp_pnode.nextParentAddress;
}
i++;
// Check that we haven't already displayed the next node
for (j = 0; j < i; j++)
{
if (resultsarray[j] == tempNodeAddr)
{
temp_bool = FALSE;
}
}
}
// Check if we could read 5 services after the given search text to know if we need to show the right arrow
if (i == 5)
{
// Compare our text with the last service text and see if they match
if (strncmp(text, (char*)temp_pnode.service, search_index + 1) == 0)
{
// show arrow
oledBitmapDrawFlash(176, 24, BITMAP_LOGIN_RARROW, 0);
}
else
{
// hide arrow
oledFillXY(176, 24, 16, 16, 0);
i = 4;
}
}
// Store and return number of children
last_matching_parent_number = i;
}
// If the text is 4 chars long no need to display right arrow
if ((search_index == SEARCHTEXT_MAX_LENGTH - 1) && (last_matching_parent_number > 4))
{
// hide arrow
last_matching_parent_number = 4;
oledFillXY(176, 24, 16, 16, 0);
}
return last_matching_parent_number;
}
/*! \fn guiAskForConfirmation(const char* string)
* \brief Ask for user confirmation for different things
* \param nb_args Number of text lines (must be either 1 2 or 3/4 (depending on the MP version))
* \param text_object Pointer to the text object if more than 1 line, pointer to the string if not
* \return User confirmation or not
*/
RET_TYPE guiAskForConfirmation(uint8_t nb_args, confirmationText_t* text_object)
{
uint8_t flash_flag = FALSE;
// Check if we want to flash the screen
if ((nb_args & 0xF0) != 0)
{
nb_args = nb_args & 0x0F;
// Check that the user didn't disable it
if (getMooltipassParameterInEeprom(FLASH_SCREEN_PARAM) != FALSE)
{
flash_flag = TRUE;
}
}
#if defined(HARDWARE_OLIVIER_V1)
// Temp string for truncating
char string_tbd[31];
string_tbd[30] = 0;
// Draw asking bitmap
oledClear();
oledBitmapDrawFlash(0, 0, BITMAP_YES_NO_INT_L, 0);
oledBitmapDrawFlash(222, 0, BITMAP_YES_NO_INT_R, 0);
// If more than one line
if (nb_args == 1)
{
// Yeah, that's a bit dirty
oledPutstrXY(0, 24, OLED_CENTRE, (char*)text_object);
}
else
{
while (nb_args--)
{
// Truncate and then display string
memcpy(string_tbd, text_object->lines[nb_args], 30);
oledPutstrXY(0, 2 + (nb_args << 4), OLED_CENTRE, string_tbd);
}
}
// Display result
oledDisplayOtherBuffer();
#elif defined(MINI_VERSION)
// Variables for scrolling
uint8_t string_y_indexes[3];
uint8_t string_extra_chars[3];
uint8_t string_offset_cntrs[3] = {0,0,0};
// Display variables
uint8_t approve_selected = TRUE;
// Draw asking bitmap
oledClear();
miniOledSetMaxTextY(SSD1305_OLED_WIDTH-15);
oledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0);
// Display lines.
// Note: line are truncated at the oled driver level when miniOledTextWritingYIncrement is set to FALSE
if (nb_args == 1)
{
miniOledPutCenteredString(THREE_LINE_TEXT_SECOND_POS, (char*)text_object);
}
else if (nb_args == 2)
{
string_y_indexes[0] = TWO_LINE_TEXT_FIRST_POS;
string_y_indexes[1] = TWO_LINE_TEXT_SECOND_POS;
}
else
{
string_y_indexes[0] = THREE_LINE_TEXT_FIRST_POS;
string_y_indexes[1] = THREE_LINE_TEXT_SECOND_POS;
string_y_indexes[2] = THREE_LINE_TEXT_THIRD_POS;
}
// For loop to display lines when there is more than one arg
if (nb_args > 1)
{
for (uint8_t i = 0; i < nb_args; i++)
{
string_extra_chars[i] = strlen(text_object->lines[i]) - miniOledPutCenteredString(string_y_indexes[i], text_object->lines[i]);
}
}
miniOledFlushEntireBufferToDisplay();
miniOledResetMaxTextY();
#endif
// In case the display inverted, set it correctly
if (flash_flag == TRUE)
{
activityDetectedRoutine();
oledInvertedDisplay();
timerBased500MsDelay();
oledNormalDisplay();
timerBased500MsDelay();
oledInvertedDisplay();
timerBased500MsDelay();
oledNormalDisplay();
}
// Wait for user input
#if defined(HARDWARE_OLIVIER_V1)
if(getTouchedPositionAnswer(LED_MASK_WHEEL) == TOUCHPOS_RIGHT)
{
return RETURN_OK;
}
else
{
return RETURN_NOK;
}
#elif defined(MINI_VERSION)
RET_TYPE input_answer = MINI_INPUT_RET_NONE;
// Switch on lights
activityDetectedRoutine();
// Clear possible remaining detection
miniWheelClearDetections();
// Arm timer for scrolling (caps timer that isn't relevant here)
activateTimer(TIMER_CAPS, SCROLLING_DEL);
// Loop while no timeout occurs or no button is pressed
while (input_answer == MINI_INPUT_RET_NONE)
{
input_answer = getYesNoAnswerInput(FALSE);
// Text scrolling
if ((hasTimerExpired(TIMER_CAPS, TRUE) == TIMER_EXPIRED) && (nb_args > 1))
{
miniOledDrawRectangle(0, 0, SSD1305_OLED_WIDTH-15, SSD1305_OLED_HEIGHT, FALSE);
activateTimer(TIMER_CAPS, SCROLLING_DEL);
miniOledSetMaxTextY(SSD1305_OLED_WIDTH-15);
for (uint8_t i = 0; i < nb_args; i++)
{
if (string_extra_chars[i] > 0)
{
miniOledPutCenteredString(string_y_indexes[i], (text_object->lines[i]) + string_offset_cntrs[i]);
if (string_offset_cntrs[i]++ == string_extra_chars[i])
{
string_offset_cntrs[i] = 0;
}
}
else
{
miniOledPutCenteredString(string_y_indexes[i], text_object->lines[i]);
}
}
miniOledFlushEntireBufferToDisplay();
miniOledResetMaxTextY();
}
// Approve / deny display change
if (getWheelCurrentIncrement() != 0)
{
if(approve_selected == FALSE)
{
oledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_APPROVE, 0);
}
else
{
oledBitmapDrawFlash(SSD1305_OLED_WIDTH-15, 0, BITMAP_DENY, 0);
}
approve_selected = !approve_selected;
miniOledFlushEntireBufferToDisplay();
}
}
if ((input_answer == MINI_INPUT_RET_YES) && (approve_selected != FALSE))
{
return RETURN_OK;
}
else
{
return RETURN_NOK;
}
#endif
}
