Merge branch 'Branch_S550_GUI' of 192.168.6.216:/linux-em-group/s530-ntk into branch_s550_gui_debug

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonItem/MenuQR.c

@@ -1,7 +1,7 @@
 // #include "MenuQR.h"
 #include "PrjInc.h"
 #include "UIWnd/UIFlow.h"
-
+#include "lvgl/src/lv_lib_qrcode/lv_qrcode.h"
 TMDEF_BEGIN_OPTIONS(NETWORK_SELECTION)
 TMDEF_OPTION_TEXT_S(END, TM_OPTION_ENABLE)
 TMDEF_END_OPTIONS()
@@ -79,3 +79,49 @@ int Qr_MenuCallback(UINT32 uiMessage, UINT32 uiParam)
   }
   return TMF_PROCESSED;
 }
+char *qr_code_str = "{\"imei\":\"%s\",\"verizonICCID\":\"%s\",\"attICCID\":\"%s\",\"isEsim\":%s}";
+static lv_obj_t *qr = NULL;
+static lv_obj_t *label = NULL;
+void show_qr_picture_page(lv_obj_t* obj)
+{
+	// lv_color_t colorDrak = {0};
+	// lv_color_t colorLight = {0};
+	UIMenuStoreInfo *puiPara = sf_ui_para_get();
+  // const char *data = "https://github.com/topics/littlevgl";
+#define QR_DATA_LENGTH 1024
+  char qr_date[QR_DATA_LENGTH] = {0};
+  snprintf(qr_date, QR_DATA_LENGTH, qr_code_str, puiPara->ModuleImei, "89011703322284703435", "89011703322284703435", "true");
+
+    if(obj){
+
+        /*Create a 100x100 QR code*/
+       qr = lv_qrcode_create(obj, 120, (lv_color_t) { .full = 0x02}, (lv_color_t) { .full = 0x0A});
+
+        if(qr){
+            /*Set data*/
+            lv_qrcode_update(qr, qr_date, strlen(qr_date));
+            lv_obj_set_pos(qr, 32, 70);
+        }
+    }
+	lv_color_t color = {0};
+	static lv_style_t labelStyle;
+	lv_style_init(&labelStyle);
+	STYLE_COLOR_PROP(0xff, 0xff, 0xff, 0xff) ; lv_style_set_text_color(&labelStyle, LV_STATE_DEFAULT, color);
+    label = lv_label_create(obj, NULL);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_BREAK);
+    lv_label_set_text(label, "Add Camera to Tactacam App");
+    lv_obj_set_pos(label, 180, 78);
+    lv_obj_set_size(label, 110, 63);
+	lv_obj_add_style(label, 0, &labelStyle);
+}
+void hidde_qr_picture_page(void)
+{
+    if(NULL != qr)
+    {
+        lv_qrcode_delete(qr);
+    }
+    if(label)
+    {
+        lv_obj_del(label);
+    }
+}

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonItem/MenuQR.h

@@ -4,4 +4,7 @@
 extern TM_MENU gQrMenu;
 extern TM_ITEM gTM_ITEMS_QR[];
 
+extern void show_qr_picture_page(lv_obj_t* obj);
+extern void hidde_qr_picture_page(void);
+
 #endif

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonOption/UIFlowMenuCommonOptionEventCallback.c

@@ -76,6 +76,47 @@ static void UIFlowMenuCommonOption_CloseScr(lv_obj_t* obj)
 }
 #endif
 
+#define MESSAGE_ITEM_TRUE 1
+#define MESSAGE_ITEM_FALSE 0
+static int is_message_item(lv_obj_t* obj)
+{
+    TM_MENU*    pMenu = TM_GetMenu();
+    TM_PAGE*    pPage;
+    TM_ITEM*    pItem;
+	pPage = &pMenu->pPages[pMenu->SelPage];
+	pItem = &pPage->pItems[pPage->SelItem];
+	UINT16 itemID = pItem->ItemId;
+	switch (itemID) {
+	case IDM_QR_PICTURE:
+	{
+		printf("Show qr picture.\n");
+		show_qr_picture_page(obj);
+		return MESSAGE_ITEM_TRUE;
+	}
+	default:
+	break;
+	}
+	return MESSAGE_ITEM_FALSE;
+}
+static void message_item_close(void)
+{
+    TM_MENU*    pMenu = TM_GetMenu();
+    TM_PAGE*    pPage;
+    TM_ITEM*    pItem;
+	pPage = &pMenu->pPages[pMenu->SelPage];
+	pItem = &pPage->pItems[pPage->SelItem];
+	UINT16 itemID = pItem->ItemId;
+	switch (itemID) {
+	case IDM_QR_PICTURE:
+	{
+		printf("hide qr picture.\n");
+        hidde_qr_picture_page();
+		return ;
+	}
+	default:
+	break;
+	}
+}
 static void LV_MenuCommonOption_UpdateContent(TM_MENU *pMenu)
 {
 	TM_PAGE    *pPage;
@@ -158,6 +199,15 @@ static void LV_MenuCommonOption_UpdateContent(TM_MENU *pMenu)
 		lv_plugin_label_set_text(label_menu_item_scr_uiflowmenucommonoption, pItem->TextId);
 		lv_plugin_label_update_font(label_menu_item_scr_uiflowmenucommonoption, LV_OBJ_PART_MAIN);
 	} 
+    if(MESSAGE_ITEM_FALSE == is_message_item(lv_plugin_scr_act()))
+	{
+	    lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, false);
+	    // LV_MenuCommonOption_UpdateContent(pMenu);
+	}
+	else
+	{
+	    lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, true);
+	}
 #endif
 	//find startIndex
 	TM_FindStartIndex(pMenu, pItem->Count, &startIndex);
@@ -298,7 +348,15 @@ static void LV_MenuOption_OnOpen(lv_obj_t* obj, TM_MENU *data)
 		/* allocate menu item */
 		lv_plugin_menu_init_items(menu_item, OPTION_PAGE_NUM);
 	}
-
+    // if(MESSAGE_ITEM_FALSE == is_message_item(obj))
+	// {
+	//     lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, false);
+	//     LV_MenuCommonOption_UpdateContent(pMenu);
+	// }
+	// else
+	// {
+	//     lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, true);
+	// }
 	LV_MenuCommonOption_UpdateContent(pMenu);
 
 	//lv_plugin_menu_select_item(menu_item, 0);
@@ -424,6 +482,7 @@ static void LV_MenuOption_OnSelected(lv_obj_t* obj)
 static void UIFlowMenuCommonOption_ScrClose(lv_obj_t* obj)
 {
 	DBG_DUMP("%s\r\n", __func__);
+	message_item_close();
 	UIMenuStoreInfo *puiPara = sf_ui_para_get();
 	printf("camera mode = %d\n", puiPara->CamMode);
 }

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMovie/UIFlowMovieEventCallback.c

@@ -9,6 +9,7 @@
 #include "DCF.h"
 #endif
 
+#include "sf_wifi_svr.h"
 #if HUNTING_CAMERA_MCU == ENABLE
 #include <sf_inc.h>
 #endif
@@ -338,6 +339,56 @@ static void update_rec_time(void)
 	lv_label_set_text_fmt(label_rec_time_scr_uiflowmovie, "%02d:%02d:%02d", rec_sec / 3600, (rec_sec % 3600) / 60, (rec_sec % 3600) % 60);
 }
 
+static void update_wifi(void)
+{
+    const int EMPTY_IMAGE = 0;
+    SF_WIFI_STATUS_E status = sf_get_wifi_status();
+	lv_plugin_res_id res[] = {
+		    EMPTY_IMAGE,
+			LV_PLUGIN_IMG_ID_SF_WIFI_UNCONNECTED,
+			LV_PLUGIN_IMG_ID_SF_WIFI_CONNECTED,
+			LV_PLUGIN_IMG_ID_SF_WIFI_UNSUPPORT
+	};	
+	const int WIFI_NOT_INIT = 0;
+	const int WIFI_UNCONNECTED = 1;
+	const int WIFI_UNSUPPORT = 3;
+	if (WIFI_NOT_INIT == status
+	    || status < WIFI_UNCONNECTED
+		|| status > WIFI_UNSUPPORT)
+	{
+	    lv_obj_set_hidden(image_wifi_connected_scr_uiflowmovie, true);
+		return;
+	}
+	int index = status;
+	lv_obj_set_hidden(image_wifi_connected_scr_uiflowmovie, false);
+	lv_plugin_img_set_src(image_wifi_connected_scr_uiflowmovie, res[index]);
+}
+
+static void update_bluetooth(void)
+{
+    const int EMPTY_IMAGE = 0;
+    SF_WIFI_STATUS_E status = sf_get_wifi_status();
+	lv_plugin_res_id res[] = {
+		    EMPTY_IMAGE,
+			LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNCONNECTED,
+			LV_PLUGIN_IMG_ID_SF_BLUETOOTH_CONNECTED,
+			LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNSUPPORT
+	};	
+	const int WIFI_NOT_INIT = 0;
+	const int WIFI_UNCONNECTED = 1;
+	const int WIFI_UNSUPPORT = 3;
+	if (WIFI_NOT_INIT == status
+	    || status < WIFI_UNCONNECTED
+		|| status > WIFI_UNSUPPORT)
+	{
+	    lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowmovie, true);
+		return;
+	}
+	int index = status;
+	lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowmovie, false);
+	lv_plugin_img_set_src(image_bluetooth_connected_scr_uiflowmovie, res[index]);
+}
+
 static void update_size(void)
 {
 	lv_label_set_text(label_size_scr_uiflowmovie, resolution_Buf[SysGetFlag(FL_MOVIE_SIZE)]);
@@ -445,16 +496,16 @@ static void update_card(void)
 	}
 }
 
-static void update_wifi(void)
+// static void update_wifi(void)
-{
+// {
-	static lv_plugin_res_id res[] = {
+// 	static lv_plugin_res_id res[] = {
-			LV_PLUGIN_IMG_ID_ICON_WIFI_OFF,
+// 			LV_PLUGIN_IMG_ID_ICON_WIFI_OFF,
-		      LV_PLUGIN_IMG_ID_ICON_WIFI_ON,
+// 		      LV_PLUGIN_IMG_ID_ICON_WIFI_ON,
-		      LV_PLUGIN_IMG_ID_ICON_CLOUD_ON,
+// 		      LV_PLUGIN_IMG_ID_ICON_CLOUD_ON,
-	};
+// 	};
 
-	lv_plugin_img_set_src(image_wifi_scr_uiflowmovie, res[SysGetFlag(FL_WIFI)]);
+// 	lv_plugin_img_set_src(image_wifi_scr_uiflowmovie, res[SysGetFlag(FL_WIFI)]);
-}
+// }
 
 
 static void update_icons(void)
@@ -465,7 +516,6 @@ static void update_icons(void)
 	update_size();
 	update_ev();
 	update_card();
-	update_wifi();
 	update_hdr();
 	update_motionDet();
 	update_cyclic_rec();
@@ -473,7 +523,8 @@ static void update_icons(void)
 	update_max_rec_time();
 	update_4g_module_icon();
 	update_camera_message();
-
+    update_wifi();
+	update_bluetooth();
 }
 
 static void UIFlowMovie_MotionDetect(void)

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c

@@ -14,7 +14,7 @@
 #include "exif/Exif.h"
 #include <kwrap/util.h>
 #include "SysMain.h"
-
+#include "sf_wifi_svr.h"
 #if (USE_DCF == ENABLE)
 #include "DCF.h"
 #endif
@@ -374,6 +374,31 @@ static void update_4g_module_icon(void)
 		// Nothing changed.
 		// printf(" nothing changed.\n");
 	}	
+const int EMPTY_IMAGE = 0;
+	UIMenuStoreInfo *puiPara = sf_ui_para_get();
+	lv_plugin_res_id res[] = {
+			EMPTY_IMAGE,
+			EMPTY_IMAGE,
+			LV_PLUGIN_IMG_ID_SF_NET2G,
+			LV_PLUGIN_IMG_ID_SF_NET3G,
+			LV_PLUGIN_IMG_ID_SF_NET4G
+	};	
+// printf("NetGeneration:%d\n", puiPara->NetGeneration);
+	const int SIM_CARD_NOT_INIT = 0;
+	const int NET_GENERATION_2G = 2;
+	// const int NET_GENERATION_3G = 3;
+	const int NET_GENERATION_4G = 4;
+	// puiPara->NetGeneration = NET_GENERATION_4G; // Test
+	if (SIM_CARD_NOT_INIT == puiPara->NetGeneration
+	    || puiPara->NetGeneration < NET_GENERATION_2G
+		|| puiPara->NetGeneration > NET_GENERATION_4G)
+	{
+	    lv_obj_set_hidden(image_4g_scr_uiflowphoto, true);
+		return;
+	}
+	int index = puiPara->NetGeneration;
+	lv_obj_set_hidden(image_4g_scr_uiflowphoto, false);
+	lv_plugin_img_set_src(image_4g_scr_uiflowphoto, res[index]);
 }
 
 static void update_camera_message(void)
@@ -421,6 +446,56 @@ static void update_camera_message(void)
 	}
 }
 
+static void update_wifi(void)
+{
+    const int EMPTY_IMAGE = 0;
+    SF_WIFI_STATUS_E status = sf_get_wifi_status();
+	lv_plugin_res_id res[] = {
+		    EMPTY_IMAGE,
+			LV_PLUGIN_IMG_ID_SF_WIFI_UNCONNECTED,
+			LV_PLUGIN_IMG_ID_SF_WIFI_CONNECTED,
+			LV_PLUGIN_IMG_ID_SF_WIFI_UNSUPPORT
+	};	
+	const int WIFI_NOT_INIT = 0;
+	const int WIFI_UNCONNECTED = 1;
+	const int WIFI_UNSUPPORT = 3;
+	if (WIFI_NOT_INIT == status
+	    || status < WIFI_UNCONNECTED
+		|| status > WIFI_UNSUPPORT)
+	{
+	    lv_obj_set_hidden(image_wifi_connected_scr_uiflowphoto, true);
+		return;
+	}
+	int index = status;
+	lv_obj_set_hidden(image_wifi_connected_scr_uiflowphoto, false);
+	lv_plugin_img_set_src(image_wifi_connected_scr_uiflowphoto, res[index]);
+}
+
+static void update_bluetooth(void)
+{
+    const int EMPTY_IMAGE = 0;
+    SF_WIFI_STATUS_E status = sf_get_wifi_status();
+	lv_plugin_res_id res[] = {
+		    EMPTY_IMAGE,
+			LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNCONNECTED,
+			LV_PLUGIN_IMG_ID_SF_BLUETOOTH_CONNECTED,
+			LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNSUPPORT
+	};	
+	const int WIFI_NOT_INIT = 0;
+	const int WIFI_UNCONNECTED = 1;
+	const int WIFI_UNSUPPORT = 3;
+	if (WIFI_NOT_INIT == status
+	    || status < WIFI_UNCONNECTED
+		|| status > WIFI_UNSUPPORT)
+	{
+	    lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowphoto, true);
+		return;
+	}
+	int index = status;
+	lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowphoto, false);
+	lv_plugin_img_set_src(image_bluetooth_connected_scr_uiflowphoto, res[index]);
+}
+
 static void update_fd_frame(void)
 {
 	if (SysGetFlag(FL_FD) != FD_OFF){
@@ -458,6 +533,8 @@ static void update_icons(void)
 	update_dzoom();
 	update_4g_module_icon();
 	update_camera_message();
+	update_wifi();
+	update_bluetooth();
 }
 
 static void FlowPhoto_InitStartupFuncs(void)

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPlay/UIFlowPlayEventCallback.c

@@ -114,6 +114,7 @@ static void UIFlowPlay_IconImageSize(BOOL bShow)
 	}
 	//show icon
 	if (uiFileFmt & (PBFMT_MOVMJPG | PBFMT_AVI | PBFMT_MP4 | PBFMT_TS)) {
+        printf("This is video.\n");
 		PB_GetParam(PBPRMID_INFO_VDO, (UINT32 *)&MovieInfo);
 		switch (MovieInfo.uiVidWidth) {
 		case 3840:
@@ -171,6 +172,7 @@ static void UIFlowPlay_IconImageSize(BOOL bShow)
 			snprintf(item1_Buf, 32, "%lux%lu", OriImgWidth, OriImgHeight);
 		}
 	} else {
+        printf("This is picture.\n");
 		snprintf(item1_Buf, 32, "%lux%lu", OriImgWidth, OriImgHeight);
 	}
 

code/lib/source/lvgl/Makefile

@@ -137,6 +137,8 @@ SRC = \
 	lvgl/src/lv_hal/lv_hal_indev.c \
 	lvgl/src/lv_hal/lv_hal_tick.c \
 	lvgl/src/lv_gpu/lv_gpu_nvt_dma2d.c \
+	lvgl/src/lv_lib_qrcode/lv_qrcode.c \
+	lvgl/src/lv_lib_qrcode/qrcodegen.c \
 
 
 OBJ = $(SRC:.c=.o)
@@ -289,6 +291,8 @@ SRC = \
 	lvgl/src/lv_hal/lv_hal_indev.c \
 	lvgl/src/lv_hal/lv_hal_tick.c \
 	lvgl/src/lv_gpu/lv_gpu_nvt_dma2d.c \
+	lvgl/src/lv_lib_qrcode/lv_qrcode.c \
+	lvgl/src/lv_lib_qrcode/qrcodegen.c \
 	
 copy = if [ ! -z "$(1)" -a "$(1)" != " " ]; then cp -avf $(1) $(2); fi
 

code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/lv_qrcode.c

@@ -0,0 +1,205 @@
+/**
+ * @file lv_qrcode.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_qrcode.h"
+#include "qrcodegen.h"
+#include "stdio.h"
+#include "kwrap/util.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define QR_SIZE     140
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Create an empty QR code (an `lv_canvas`) object.
+ * @param parent point to an object where to create the QR code
+ * @param size width and height of the QR code
+ * @param dark_color dark color of the QR code
+ * @param light_color light color of the QR code
+ * @return pointer to the created QR code object
+ */
+lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color)
+{
+   uint32_t buf_size = LV_CANVAS_BUF_SIZE_INDEXED_1BIT(size, size);
+   uint8_t * buf = lv_mem_alloc(buf_size);
+#if LV_VERSION_CHECK(6,0,0)
+   lv_mem_assert(buf);
+#else
+   LV_ASSERT_MEM(buf);
+#endif
+   if(buf == NULL) return NULL;
+
+   lv_obj_t * canvas = lv_canvas_create(parent, NULL);
+   if(canvas == NULL) return NULL;
+
+   if(LV_COLOR_DEPTH == 8){
+	   lv_canvas_set_buffer(canvas, buf, size, size, LV_IMG_CF_INDEXED_1BIT);
+	   lv_canvas_set_palette(canvas, 0, dark_color);
+	   lv_canvas_set_palette(canvas, 1, light_color);
+   }
+   else{
+	   lv_canvas_set_buffer(canvas, buf, size, size, LV_IMG_CF_INDEXED_1BIT);
+	   lv_canvas_set_palette(canvas, 0, dark_color);
+	   lv_canvas_set_palette(canvas, 1, light_color);
+   }
+
+   return canvas;
+
+}
+
+/**
+ * Set the data of a QR code object
+ * @param qrcode pointer to aQ code object
+ * @param data data to display
+ * @param data_len length of data in bytes
+ * @return LV_RES_OK: if no error; LV_RES_INV: on error
+ */
+lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len)
+{
+	uint8_t* qr0 = NULL;
+	uint8_t* data_tmp = NULL;
+	lv_res_t ret = LV_RES_OK;
+    lv_color_t c;
+    c.full = 1;
+
+#if LV_VERSION_CHECK(7,0,0)
+    lv_canvas_fill_bg(qrcode, c, LV_OPA_COVER);
+#else
+    lv_canvas_fill_bg(qrcode, c);
+#endif
+
+    if(data_len > qrcodegen_BUFFER_LEN_MAX) return LV_RES_INV;
+
+    qr0 = (uint8_t*)lv_mem_alloc(qrcodegen_BUFFER_LEN_MAX);
+    if(qr0 == NULL){
+    	ret = LV_RES_INV;
+    	goto EXIT;
+    }
+
+    data_tmp = (uint8_t*)lv_mem_alloc(qrcodegen_BUFFER_LEN_MAX);
+    if(data_tmp == NULL){
+    	ret = LV_RES_INV;
+    	goto EXIT;
+    }
+
+    memcpy(data_tmp, data, data_len);
+
+    bool ok = qrcodegen_encodeBinary(data_tmp, data_len,
+            qr0, qrcodegen_Ecc_MEDIUM,
+            qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX,
+            qrcodegen_Mask_AUTO, true);
+
+    if (!ok) {
+    	ret = LV_RES_INV;
+    	goto EXIT;
+    }
+
+    lv_coord_t obj_w = lv_obj_get_width(qrcode);
+    int qr_size = qrcodegen_getSize(qr0);
+    int scale = obj_w / qr_size;
+    int scaled = qr_size * scale;
+    int margin = (obj_w - scaled) / 2;
+    lv_img_dsc_t * img = lv_canvas_get_img(qrcode);
+    uint8_t * buf_u8 = (uint8_t *)img->data + 8;    /*+8 skip the palette*/
+    /* Copy the qr code canvas:
+     * A simple `lv_canvas_set_px` would work but it's slow for so many pixels.
+     * So buffer 1 byte (8 px) from the qr code and set it in the canvas image */
+    uint32_t row_byte_cnt = (img->header.w + 7) >> 3;
+    int y;
+    for (y = margin; y < scaled + margin; y+=scale) {
+        uint8_t b = 0;
+        uint8_t p = 0;
+        bool aligned = false;
+        int x;
+        for (x = margin; x < scaled + margin; x++) {
+            bool a = qrcodegen_getModule(qr0, (x - margin) / scale, (y - margin) / scale);
+
+            if(aligned == false && (x & 0x7) == 0) aligned = true;
+
+            if(aligned == false) {
+                c.full = a ? 0 : 1;
+                lv_canvas_set_px(qrcode, x, y, c);
+            } else {
+                if(!a) b |= (1 << (7 - p));
+                p++;
+                if(p == 8) {
+                    uint32_t px = row_byte_cnt * y + (x >> 3);
+                    buf_u8[px] = b;
+                    b = 0;
+                    p = 0;
+                }
+            }
+        }
+
+        /*Process the last byte of the row*/
+        if(p) {
+            /*Make the rest of the bits white*/
+            b |= (1 << (8 - p)) - 1;
+
+            uint32_t px = row_byte_cnt * y + (x >> 3);
+            buf_u8[px] = b;
+        }
+
+      /*The Qr is probably scaled so simply to the repeated rows*/
+      int s;
+      const uint8_t * row_ori = buf_u8 + row_byte_cnt * y;
+      for(s = 1; s < scale; s++) {
+          memcpy((uint8_t*)buf_u8 + row_byte_cnt * (y + s), row_ori, row_byte_cnt);
+      }
+    }
+
+EXIT:
+
+	if(qr0){
+		lv_mem_free(qr0);
+	}
+
+	if(data_tmp){
+		lv_mem_free(data_tmp);
+	}
+
+    return ret;
+}
+
+/**
+ * Delete a QR code object
+ * @param qrcode pointer to a QR code obejct
+ */
+void lv_qrcode_delete(lv_obj_t * qrcode)
+{
+    lv_img_dsc_t * img = lv_canvas_get_img(qrcode);
+    lv_img_cache_invalidate_src(img);
+    lv_mem_free(img->data);
+    lv_obj_del(qrcode);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+

code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/lv_qrcode.h

@@ -0,0 +1,67 @@
+/**
+ * @file lv_qrcode
+ *
+ */
+
+#ifndef LV_QRCODE_H
+#define LV_QRCODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#ifdef LV_LVGL_H_INCLUDE_SIMPLE
+#include <lvgl.h>
+#else
+#include <lvgl/lvgl.h>
+#endif
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Create an empty QR code (an `lv_canvas`) object.
+ * @param parent point to an object where to create the QR code
+ * @param size width and height of the QR code
+ * @param dark_color dark color of the QR code
+ * @param light_color light color of the QR code
+ * @return pointer to the created QR code object
+ */
+lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color);
+
+/**
+ * Set the data of a QR code object
+ * @param qrcode pointer to aQ code object
+ * @param data data to display
+ * @param data_len length of data in bytes
+ * @return LV_RES_OK: if no error; LV_RES_INV: on error
+ */
+lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len);
+
+/**
+ * Delete a QR code object
+ * @param qrcode pointer to a QR code object
+ */
+void lv_qrcode_delete(lv_obj_t * qrcode);
+
+/**********************
+ *      MACROS
+ **********************/
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_QRCODE_H*/

code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/qrcodegen.h

@@ -0,0 +1,311 @@
+/* 
+ * QR Code generator library (C)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * - The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ * - The Software is provided "as is", without warranty of any kind, express or
+ *   implied, including but not limited to the warranties of merchantability,
+ *   fitness for a particular purpose and noninfringement. In no event shall the
+ *   authors or copyright holders be liable for any claim, damages or other
+ *   liability, whether in an action of contract, tort or otherwise, arising from,
+ *   out of or in connection with the Software or the use or other dealings in the
+ *   Software.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* 
+ * This library creates QR Code symbols, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * A QR Code structure is an immutable square grid of black and white cells.
+ * The library provides functions to create a QR Code from text or binary data.
+ * The library covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+ * 
+ * Ways to create a QR Code object:
+ * - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
+ * - Low level: Custom-make the list of segments and call
+ *   qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
+ * (Note that all ways require supplying the desired error correction level and various byte buffers.)
+ */
+
+
+/*---- Enum and struct types----*/
+
+/* 
+ * The error correction level in a QR Code symbol.
+ */
+enum qrcodegen_Ecc {
+	// Must be declared in ascending order of error protection
+	// so that an internal qrcodegen function works properly
+	qrcodegen_Ecc_LOW = 0 ,  // The QR Code can tolerate about  7% erroneous codewords
+	qrcodegen_Ecc_MEDIUM  ,  // The QR Code can tolerate about 15% erroneous codewords
+	qrcodegen_Ecc_QUARTILE,  // The QR Code can tolerate about 25% erroneous codewords
+	qrcodegen_Ecc_HIGH    ,  // The QR Code can tolerate about 30% erroneous codewords
+};
+
+
+/* 
+ * The mask pattern used in a QR Code symbol.
+ */
+enum qrcodegen_Mask {
+	// A special value to tell the QR Code encoder to
+	// automatically select an appropriate mask pattern
+	qrcodegen_Mask_AUTO = -1,
+	// The eight actual mask patterns
+	qrcodegen_Mask_0 = 0,
+	qrcodegen_Mask_1,
+	qrcodegen_Mask_2,
+	qrcodegen_Mask_3,
+	qrcodegen_Mask_4,
+	qrcodegen_Mask_5,
+	qrcodegen_Mask_6,
+	qrcodegen_Mask_7,
+};
+
+
+/* 
+ * Describes how a segment's data bits are interpreted.
+ */
+enum qrcodegen_Mode {
+	qrcodegen_Mode_NUMERIC      = 0x1,
+	qrcodegen_Mode_ALPHANUMERIC = 0x2,
+	qrcodegen_Mode_BYTE         = 0x4,
+	qrcodegen_Mode_KANJI        = 0x8,
+	qrcodegen_Mode_ECI          = 0x7,
+};
+
+
+/* 
+ * A segment of character/binary/control data in a QR Code symbol.
+ * The mid-level way to create a segment is to take the payload data
+ * and call a factory function such as qrcodegen_makeNumeric().
+ * The low-level way to create a segment is to custom-make the bit buffer
+ * and initialize a qrcodegen_Segment struct with appropriate values.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * Moreover, the maximum allowed bit length is 32767 because
+ * the largest QR Code (version 40) has 31329 modules.
+ */
+struct qrcodegen_Segment {
+	// The mode indicator of this segment.
+	enum qrcodegen_Mode mode;
+	
+	// The length of this segment's unencoded data. Measured in characters for
+	// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	// Always zero or positive. Not the same as the data's bit length.
+	int numChars;
+	
+	// The data bits of this segment, packed in bitwise big endian.
+	// Can be null if the bit length is zero.
+	uint8_t *data;
+	
+	// The number of valid data bits used in the buffer. Requires
+	// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
+	// The character count (numChars) must agree with the mode and the bit buffer length.
+	int bitLength;
+};
+
+
+
+/*---- Macro constants and functions ----*/
+
+#define qrcodegen_VERSION_MIN   1  // The minimum version number supported in the QR Code Model 2 standard
+#define qrcodegen_VERSION_MAX  40  // The maximum version number supported in the QR Code Model 2 standard
+
+// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
+// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
+// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
+// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
+#define qrcodegen_BUFFER_LEN_FOR_VERSION(n)  ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
+
+// The worst-case number of bytes needed to store one QR Code, up to and including
+// version 40. This value equals 3918, which is just under 4 kilobytes.
+// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
+#define qrcodegen_BUFFER_LEN_MAX  qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
+
+
+
+/*---- Functions (high level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given text string to a QR Code, returning true if encoding succeeded.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * - The input text must be encoded in UTF-8 and contain no NULs.
+ * - The variables ecl and mask must correspond to enum constant values.
+ * - Requires 1 <= minVersion <= maxVersion <= 40.
+ * - The arrays tempBuffer and qrcode must each have a length
+ *   of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
+ * - After the function returns, tempBuffer contains no useful data.
+ * - If successful, the resulting QR Code may use numeric,
+ *   alphanumeric, or byte mode to encode the text.
+ * - In the most optimistic case, a QR Code at version 40 with low ECC
+ *   can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
+ *   up to 4296 characters, or any digit string up to 7089 characters.
+ *   These numbers represent the hard upper limit of the QR Code standard.
+ * - Please consult the QR Code specification for information on
+ *   data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/* 
+ * Encodes the given binary data to a QR Code, returning true if encoding succeeded.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * - The input array range dataAndTemp[0 : dataLen] should normally be
+ *   valid UTF-8 text, but is not required by the QR Code standard.
+ * - The variables ecl and mask must correspond to enum constant values.
+ * - Requires 1 <= minVersion <= maxVersion <= 40.
+ * - The arrays dataAndTemp and qrcode must each have a length
+ *   of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
+ * - After the function returns, the contents of dataAndTemp may have changed,
+ *   and does not represent useful data anymore.
+ * - If successful, the resulting QR Code will use byte mode to encode the data.
+ * - In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
+ *   sequence up to length 2953. This is the hard upper limit of the QR Code standard.
+ * - Please consult the QR Code specification for information on
+ *   data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/*---- Functions (low level) to generate QR Codes ----*/
+
+/* 
+ * Renders a QR Code representing the given segments at the given error correction level.
+ * The smallest possible QR Code version is automatically chosen for the output. Returns true if
+ * QR Code creation succeeded, or false if the data is too long to fit in any version. The ECC level
+ * of the result may be higher than the ecl argument if it can be done without increasing the version.
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ * To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
+ * result in them being clobbered, but the QR Code output will still be correct.
+ * But the qrcode array must not overlap tempBuffer or any segment's data buffer.
+ */
+bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
+	enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Renders a QR Code representing the given segments with the given encoding parameters.
+ * Returns true if QR Code creation succeeded, or false if the data is too long to fit in the range of versions.
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask number is either between 0 to 7 (inclusive) to force that
+ * mask, or -1 to automatically choose an appropriate mask (which may be slow).
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ * To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
+ * result in them being clobbered, but the QR Code output will still be correct.
+ * But the qrcode array must not overlap tempBuffer or any segment's data buffer.
+ */
+bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
+	int minVersion, int maxVersion, int mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in alphanumeric mode.
+ * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+ * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+bool qrcodegen_isAlphanumeric(const char *text);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in numeric mode.
+ * A string is encodable iff each character is in the range 0 to 9.
+ */
+bool qrcodegen_isNumeric(const char *text);
+
+
+/* 
+ * Returns the number of bytes (uint8_t) needed for the data buffer of a segment
+ * containing the given number of characters using the given mode. Notes:
+ * - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or
+ *   the number of needed bits exceeds INT16_MAX (i.e. 32767).
+ * - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
+ * - It is okay for the user to allocate more bytes for the buffer than needed.
+ * - For byte mode, numChars measures the number of bytes, not Unicode code points.
+ * - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
+ *   An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
+ */
+size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
+
+
+/* 
+ * Returns a segment representing the given binary data encoded in
+ * byte mode. All input byte arrays are acceptable. Any text string
+ * can be converted to UTF-8 bytes and encoded as a byte mode segment.
+ */
+struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given string of decimal digits encoded in numeric mode.
+ */
+struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given text string encoded in alphanumeric mode.
+ * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+ * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing an Extended Channel Interpretation
+ * (ECI) designator with the given assignment value.
+ */
+struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
+
+
+/*---- Functions to extract raw data from QR Codes ----*/
+
+/* 
+ * Returns the side length of the given QR Code, assuming that encoding succeeded.
+ * The result is in the range [21, 177]. Note that the length of the array buffer
+ * is related to the side length - every 'uint8_t qrcode[]' must have length at least
+ * qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
+ */
+int qrcodegen_getSize(const uint8_t qrcode[]);
+
+
+/* 
+ * Returns the color of the module (pixel) at the given coordinates, which is false
+ * for white or true for black. The top left corner has the coordinates (x=0, y=0).
+ * If the given coordinates are out of bounds, then false (white) is returned.
+ */
+bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
+
+
+#ifdef __cplusplus
+}
+#endif