Update to dms control phase1.

2023-08-21 14:22:41 +08:00
parent d1dc5df680
commit 20fb814608
59 changed files with 2538 additions and 904 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,6 +39,10 @@ source_group(TREE ${CMAKE_SOURCE_DIR} FILES ${project_c})

 find_package(Qt5 COMPONENTS Core Widgets Gui OpenGL Sql VirtualKeyboard Network Multimedia MultimediaWidgets REQUIRED)
 find_package(DCMTK REQUIRED)
+
+set(Req_DIR "${CMAKE_CURRENT_SOURCE_DIR}/thirdParty/Req/pub/cmake")
+find_package(Req REQUIRED)
+message(${Req_INCLUDES_DIRS})
 include_directories(${DCMTK_INCLUDE_DIRS})


@@ -68,6 +72,11 @@ if(${DCMTK_FOUND})
    target_link_libraries(${PROJECT_NAME} ${DCMTK_LIBRARIES})
 endif()

+if(${Req_FOUND})
+    target_include_directories(${PROJECT_NAME} PUBLIC ${Req_INCLUDES_DIRS})
+    target_link_libraries(${PROJECT_NAME} Req)
+endif()
+
 if(NOT UNIX)
 find_program(POWERSHELL_PATH NAMES powershell)

@@ -83,10 +92,12 @@ foreach(_file ${TS_FILES})
 endforeach()
 endif()

-
+set(USE_SHIMLIB ON)
 if(UNIX AND USE_SHIMLIB)
        link_directories(/usr/local/lib64)
-        target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Widgets Qt5::Gui Qt5::OpenGL Qt5::Sql Qt5::VirtualKeyboard Qt5::Network Qt5::Multimedia Qt5::MultimediaWidgets pthread usct_shim dmapi log4c cunit ctomat hdf5 matio m)
+#        target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Widgets Qt5::Gui Qt5::OpenGL Qt5::Sql Qt5::VirtualKeyboard Qt5::Network Qt5::Multimedia Qt5::MultimediaWidgets pthread usct_shim dmapi log4c cunit ctomat hdf5 matio m)
+        target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Widgets Qt5::Gui Qt5::OpenGL Qt5::Sql Qt5::VirtualKeyboard Qt5::Network Qt5::Multimedia Qt5::MultimediaWidgets pthread m)
+elseif(UNIX)
 elseif(UNIX)
        target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Widgets Qt5::Gui Qt5::OpenGL Qt5::Sql Qt5::VirtualKeyboard Qt5::Network Qt5::Multimedia Qt5::MultimediaWidgets pthread)
 else()
--- a/cfgs/client.crt
+++ b/cfgs/client.crt
@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv0CFFktR8kwVStd/hzYzeFFe/oChSu2MA0GCSqGSIb3DQEBCwUAMEox
+CzAJBgNVBAYTAkNOMQswCQYDVQQIDAJaSjELMAkGA1UEBwwCSFoxDDAKBgNVBAoM
+A0VROTETMBEGA1UEAwwKRVE5U2VydmVyMTAeFw0yMzA3MTMwOTE1MjBaFw0yNDA3
+MTIwOTE1MjBaMEQxCzAJBgNVBAYTAkNOMQswCQYDVQQIDAJaSjELMAkGA1UEBwwC
+SFoxDDAKBgNVBAoMA0VROTENMAsGA1UEAwwEa3JhZDCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBAN1y63ON02zYLJEtR7wn0X2BvB6tDUJvL0E38VLCcICs
+c/2djiFYYxOk25n2Hy2jlgUX3nJvNGIOFTRLseAzpMkaH9F0sA3AGEM2LAAJt/jW
+0y8xztbrNDs8E/jHtP4mobEIel/W9cGqIJpNjRMIh0qitzA2znDnLNdvn39aa6iP
+IaZMqDZRUMSP6wkC8DOlo6Hr4kSdw9MVzmQ0/Vhw0ishriHsFY+tri3B2Tt8A7g8
+pkL6Siq4lbUFlgyqs2V2T9EnNOIGwP4qzq//sCxV7Ak8JAn+oCE41VlCja+4dd83
+N1d3p8/HVamo/Dtd5X6wo54cELzc6JS5CkNz9jMcPo0xT4gObZAeJiaKoHG2WBrx
+dD35jksZ+4Z5fSMpjz9dVz3nDnhUvI36T0hUsthZ+eiwDaTpMgIhGXH9qSrD0Hnc
+oRoYrwjl+ksorztN9QWQOVJwN8jn90X1kbKNOPkA84QY3uLgv1HPKt2xR6h9wu2s
+Ug9OhG1ofN6IXI6GCc06Q8g41Xl4G8MuoOxwlnKZZaEjLGkF+0AKFkkrmiv5/tJ+
+bSebaw6rwAv4LnPoDT194PkPh08Bq0q7TksaEcjMLnzWac0npdJSZlr+i6AJ+xz7
+ecMS/0xuKPQDD0G1bHlqhraOmeSuFzAvwuf9osS49Pz7BGswaXdrHsyQ0oD6Kfr9
+AgMBAAEwDQYJKoZIhvcNAQELBQADggEBAFP12Rr6N4jhiKzgvUIjnutAa75iF9zs
+7fX47U4khVWACF7Exb2rmfUT1/pTuhMGeyj3l0LMarJH0/+AoaCX6diFt4yrnRKQ
+rQteTOEfA05ovv9WeEAMkbRTTH+xecqg0zYAiAcRXCnCAL8sdvcgkXYXF3PKjYHq
+XtVZGCc+58SzqjkISavt1UJUmlz9lqe7N54AY7qxsQqng6Y21SLHlqtB/4AOQhtu
+n/ZgjO5eH6Tq1weWS2bxBlwIkZPAHVRVWTuG22WxMiZb029kxNEfDCdICB6NOJRs
+c84WXxovopVQqi3RmLvhaDB+iUg8kkoWmc6UFt8lW+nxXrAUs/kWQ5w=
+-----END CERTIFICATE-----
--- a/cfgs/client.key
+++ b/cfgs/client.key
@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIJKQIBAAKCAgEA3XLrc43TbNgskS1HvCfRfYG8Hq0NQm8vQTfxUsJwgKxz/Z2O
+IVhjE6TbmfYfLaOWBRfecm80Yg4VNEux4DOkyRof0XSwDcAYQzYsAAm3+NbTLzHO
+1us0OzwT+Me0/iahsQh6X9b1waogmk2NEwiHSqK3MDbOcOcs12+ff1prqI8hpkyo
+NlFQxI/rCQLwM6WjoeviRJ3D0xXOZDT9WHDSKyGuIewVj62uLcHZO3wDuDymQvpK
+KriVtQWWDKqzZXZP0Sc04gbA/irOr/+wLFXsCTwkCf6gITjVWUKNr7h13zc3V3en
+z8dVqaj8O13lfrCjnhwQvNzolLkKQ3P2Mxw+jTFPiA5tkB4mJoqgcbZYGvF0PfmO
+Sxn7hnl9IymPP11XPecOeFS8jfpPSFSy2Fn56LANpOkyAiEZcf2pKsPQedyhGhiv
+COX6SyivO031BZA5UnA3yOf3RfWRso04+QDzhBje4uC/Uc8q3bFHqH3C7axSD06E
+bWh83ohcjoYJzTpDyDjVeXgbwy6g7HCWcplloSMsaQX7QAoWSSuaK/n+0n5tJ5tr
+DqvAC/guc+gNPX3g+Q+HTwGrSrtOSxoRyMwufNZpzSel0lJmWv6LoAn7HPt5wxL/
+TG4o9AMPQbVseWqGto6Z5K4XMC/C5/2ixLj0/PsEazBpd2sezJDSgPop+v0CAwEA
+AQKCAgEAyQXdPtRsLM5ABrm3+NGclfYDM0WcV8ZeezGxW5MuVWA3Gu6/av21UsvA
+nY6S1vc84/q6796LCsgF76cXHZND71pLr/PhLVpHrBus7Yvk+Xrp0lnAjdCNZYgw
+CRIg9uVSukYb8IxOIzOwzOHBQpnnVpVG/fmChXMVfavSeeU2/ZiQz0mfGU/Ppd+P
+WGrWacvfMsnSaL9eWGvfI5AGuxYPcx/r1tdc60SabOcfr6PwLHrB4uMaGJXfMKiV
+gYIjv+MaqZ6RnuzKnO93GMVew6Br2CZEAN6ntgDFi3Wi8PTd63dQQZJZP4CP/qdr
+8OhXwB3RKWIIv6k5aGhhLMJDqDnnfMuezi0maTSwZ2qr9NAofWzhaHBNvTQ2b+UE
+46flpiJJrARiw37BNN/hM4dAqF3zDOZWOGffRi1s6Ax4jEnjpO4QwrkTK+OGN7N4
+0a68QEQrrIOgc3Szk1LjyGJX7GefKmRSoB7XVf2gKdrm17g9EnYVyrp9KSxAgBw3
+CTmL5tDYlAgQdFKoybRlnq4SUdjaX6Z328XwX278Jt8myQLS86IRuCA6ozRTshb9
+e5R8jg/Rgl0jLbZm7nZLrer+YyW1bDtkUUFiFecpccmGch/gI0OLtpgDiL2hZBjh
+tydKphVLa5JUKKIJ3CTmhoCtkiHXdaEVesxp20VazmzvEOqgUnECggEBAPlApVDk
+tjrtIL2Vs8ogbdHxUWZug2zzVLY+q4M6n5yPJHAhtijxy9Z8ZstzqDfwXuAC7Kf3
+Myfq19vJ6pteJfukp3F1zW7k1fa3yjqWu7NiBOrc55iTtjl1i2CtseWxRp9jNzD3
+rpQEtUxTbcm3ShmPwMnD2CFaoGObnDeMnC6qSQWPdO10IkL3aXARcZw1YXSOWf8i
+dLa2Mg33qmRAdeKTbF01zQNK1tSFZcxd8+rau2Ry16inDjgxGELFzsAFowOa+IyN
+ptDm5eczQHL5rrxolF141fTHLpBDbgE9WsIJyG3eIrXcfkFH0ccms14J56FTg/mZ
+3iI7GJCb/RWVxcMCggEBAONxl1DaW+EmfAUJXfr2gNjO0zsOXyvJILC4WHC1VO5X
+/DY6irTIUNffrB/EuTOHDlv/6m/pP1DQdgyYUKd5cQMYBMu5EIsGH/gl28tgs9rT
+0q3Vm8ReWJNfQAUBf3Y6ZlsvVO4KF1MVDQfZYkdPs87l5gDwsXc3zu5iJtGxvU5R
+RRalrr3bXhRoJJxN/k60l7yzA4Vos4GpSWEDopL9Ygsj2xPaiEjzczrmIX9/s4yo
+WuaYAh/eXYmYCuWQhkbIVSWUekj6FfNX7wLTuA016jqHBstx1s6S+V5SpsrYVDTH
+oNYwDJNwoRppnmaXzVWTWqUnbaKBjyH/aoFIRTuDcD8CggEANyl/bK+xRMlF/a8r
+4wfaRiRKB4ldvLb9gHfOLXTD7jofrlFHpzgcDJPrjAtEp1yjIqCDD4k94Q+wRgwh
+x9DGRzLhe9K+bFRopfl24BCL6d8/h1rsRnAqW/0Po43NWTAqmQu0IzotgMSp+wJb
+wdC2rYGLARw+sOMFrAW8RO7xgcJd9sUQ85xIGNn4k7zIj/GgZ9M5R6Wwft9DpKOz
+Kgy6CjLmQJqvjJL7iH0dUmVYnhlab5ia8dBG7ViwLdbpMsYMlbeuWizfRkxThR9q
+nAd2DGx4qVccwtdyDqtdpRiXBWp02RvYQrdRmdDzNEf0WlOG18VL5+mNp7W8cgST
+tjs3UQKCAQBiJtEACVuBLFR07/fop5wu9AJgB/G2OZOr78Hq0bYXLU0gMd9N6OxK
+XLIw+3pY7D2cIjKPnP6/51YqVUjpHRVSGnlnWTP0au487kmN2OuE0cinT/lqorRi
+1MYR4vWYldc6HpDuMNij9/+plXw9/f1AmiHJ4hUTt7fLU/wgni1tsNC510IzmIlf
+ERpLgbTvTiv1OOOaHPbqS53pCeKMwGAhIpYWWUZbBQSDNHDcTsWzO6wOuyafjhyb
+lkuNifMIdMeZ8htbhuEWJKp2c9uHh+7O1xptjXD/sJmAxPZJr1WXeVbFV/L1ZbOA
+bHf5GiV4eqCxiPRdHsAgEdNqez+1USGNAoIBAQCizud3lUBLQ9e5H6wmP496Su+W
+OpLJLk0pxNu8cB/qXrKbYy/PIJjt615zXwpI7IrrwhZh0Omq0qtEbYPMAWeE2AP2
+BuTlZn9Hh0LuXKPuvQstp8z8lI5nihFXqxTaLv82Iurj3dRNMC9IXHguagjywYp5
+CRUlGC/SrwadAlnvVmTD3bpotalMJr0GtMZiOsIUp2zsTO2AvsdGJe8xVWTXARjc
+6X2cwxY6QHBiSHcR4vf52RuZJSDE9Nypzjtb3j1vBj6kAhlLA0Q30kCU1U9tJp6b
+TJTZUebUsvhWDP4d9pTJmgSnyoZzEkyeVRm5/F7LnU4rvb+5dQpiyM9vfzlE
+-----END RSA PRIVATE KEY-----
--- a/src/ShimLib/ShimLib.c
+++ b/src/ShimLib/ShimLib.c
@@ -1,400 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "ShimLib.h"
-
-#ifdef _WIN32
-#include <Windows.h>
-#include <process.h>
-#else
-#include <pthread.h>
-#include <semaphore.h>
-#include <fcntl.h>
-#include <sys/time.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <string.h>
-#endif
-#include <stdbool.h>
-#include <time.h>
-
-typedef void(*error_cb)(const char* msg);
-// level:0 infomation,1 warning,2 error,3 sucessed
-typedef void(*message_callback)(const char* aMessage,const unsigned int aInfoType);
-
-int statusCountFlag = 0;
-error_cb innerCallback = NULL;
-message_callback msgCallback = NULL;
-bool isAutoScan = false;
-
-#ifdef _WIN32
-void ThreadFunc(void*);
-HANDLE th;
-HANDLE e1,e2;
-#else
-void* ThreadFunc(void*);
-void InitSever();
-pthread_t th;
-pthread_t severThread;
-sem_t e1;
-sem_t e2;
-#endif
-
-int InitLib(error_cb cb)
-{
-    innerCallback = cb;
-    innerCallback("11111");
-#ifdef _WIN32
-    e1 = CreateEvent(NULL, FALSE, FALSE, "e1");
-    e2 = CreateEvent(NULL, FALSE, FALSE, "e2");
-    th = _beginthread(ThreadFunc, 0, NULL);
-#else
-    sem_init(&e1, 0, 0);
-    sem_init(&e2, 0, 0);
-    th = pthread_create(&th, NULL, ThreadFunc, (void*)"");
-    severThread = pthread_create(&severThread, NULL, InitSever,  (void*)"");
-#endif
-    return 0;
-}
-
-void SetMessageCallback(message_callback cb)
-{
-    msgCallback = cb;
-    msgCallback("info message", 0);
-    msgCallback("warning message", 1);
-    msgCallback("error message", 2);
-    msgCallback("sucess message", 3);
-}
-
-volatile int running = 1;
-volatile int progress = 0;
-volatile int status = READY;
-volatile int stop_flag = 0;
-volatile int empty = 0;
-char output_path[256] = {0};
-
-#ifdef _WIN32
-void ThreadFunc(void* args)
-{
-#else
-void* ThreadFunc(__attribute__((unused))void* args)
-{
-#endif
-    while (running)
-	{
-        stop_flag = 0;
-        progress = 0;
-#ifdef _WIN32		
-		WaitForSingleObject(e1, INFINITE);
-#else
-        sem_wait(&e1);
-#endif
-        status = SCANNING;
-#ifdef _WIN32
-        Sleep(300);
-#else
-        usleep(300000);
-#endif
-        if (empty)
-        {
-            GetPreviewData();
-        }
-        if (isAutoScan)
-        {
-            for (int i = 0; i <= 50; ++i)
-            {
-                if (stop_flag > 0 || status != SCANNING)
-                {
-                    stop_flag = 0;
-                    break;
-                }
-                if (i == 20)
-                {
-                    progress = 139;
-#ifdef _WIN32
-                    WaitForSingleObject(e2, INFINITE);
-#else
-                    sem_wait(&e2);
-#endif
-                }
-                else if (i > 20 && i < 35)
-                {
-                    progress = i * 2 + 100;
-                }
-                else if (i >= 35)
-                {
-                    progress = i * 2 + 200;
-                }
-                else
-                {
-                    progress = i * 2;
-                }
-                if (stop_flag > 0 || status != SCANNING)
-                {
-                    stop_flag = 0;
-                    break;
-                }
-#ifdef _WIN32
-                Sleep(300);
-#else
-                usleep(300000);
-#endif
-            }
-        }
-        else
-        {
-            while (progress < 100)
-            {
-
-            }
-        }
-        status = READY;
-	}
-}
-
-#ifdef _WIN32
-#else
-void InitSever()
-{
-    int severFd = socket(AF_INET,SOCK_STREAM,0);
-    if (-1 == severFd)
-    {
-        printf("socket failed");
-        return;
-    }
-    struct sockaddr_in severAddr;
-    severAddr.sin_family = AF_INET;
-    severAddr.sin_addr.s_addr = htonl(INADDR_ANY);
-    severAddr.sin_port = htons(8888);
-    if(0> bind(severFd,(struct sockaddr*)&severAddr,sizeof(severAddr)))
-    {
-        printf("bind failed");
-        return;
-    }
-
-    if(0> listen(severFd,2))
-    {
-        printf("listen failed");
-        return;
-    }
-    while (1)
-    {
-        int clientFd;
-        struct sockaddr_in clientAddr;
-        socklen_t clientAddrLen = sizeof(clientAddr);
-        clientFd = accept(severFd, (struct sockaddr*)&clientAddr, &clientAddrLen);
-        if (0 > clientFd)
-        {
-            printf("accept failed\n");
-            return;
-        }
-        printf("accept sucess\n");
-        while (1)
-        {
-            isAutoScan = false;
-            char receiveBuffer[64] = { 0 };
-            int ref = recv(clientFd, receiveBuffer, 64, 0);
-            if (ref > 0)
-            {
-                printf("received %s\n", receiveBuffer);
-                char* data = strtok(receiveBuffer,",");
-                if (!data || strlen(data) != 1)
-                {
-                    send(clientFd,"unknow command",sizeof("unknow command"),0);
-                    continue;
-                }
-                if (data[0] == '0')
-                {
-                    char* arg1 = strtok(NULL,",");
-                    char* arg2 = strtok(NULL,",");
-                    if (!arg1 || !arg2)
-                    {
-                        send(clientFd,"unknow command",sizeof("unknow command"),0);
-                        continue;
-                    }
-                    msgCallback(arg1, atoi(arg2));
-                    send(clientFd,"msgCallback sucess",sizeof("msgCallback sucess"),0);
-                }
-                else if (data[0] == '1')
-                {
-                    char* arg1 = strtok(NULL,",");
-                    if (!arg1)
-                    {
-                        send(clientFd,"unknow command",sizeof("unknow command"),0);
-                        continue;
-                    }
-                    innerCallback(arg1);
-                    send(clientFd,"innerCallback sucess",sizeof("innerCallback sucess"),0);
-                }
-                else if (data[0] == 'p')
-                {
-                    char* arg1 = strtok(NULL, ",");
-                    if (!arg1)
-                    {
-                        send(clientFd,"unknow command",sizeof("unknow command"),0);
-                        continue;
-                    }
-                    if (status == SCANNING)
-                    {
-                        progress = atoi(arg1);
-                        send(clientFd, "set scan progress sucess", sizeof("set scan progress sucess"), 0);
-                    }
-                    else
-                    {
-                        send(clientFd, "status is not scaning", sizeof("status is not scaning"), 0);
-                    }
-                }
-                else if (data[0] == 'e')
-                {
-                    printf("client closed\n");
-                    close(clientFd);
-                    break;
-                } 
-            }
-            else
-            {
-                printf("client closed\n");
-                close(clientFd);
-                break;
-            }
-        }
-        isAutoScan = true;
-        close(clientFd);
-    }
-    close(severFd);
-}
-#endif
-
-
-int ScanControl(ScanAction actionType) {
-
-	switch (actionType) {
-        case SCAN:
-            printf("Do Scan!\r\n");
-            statusCountFlag = 2;
-#ifdef _WIN32
-            SYSTEMTIME st = {0};
-            GetLocalTime(&st);
-#else
-        time_t now;
-        struct tm* st;
-        time(&now);
-        st = localtime(&now);
-#endif
-            sprintf(output_path, "%d%02d%02dT%02d%02d%02d",
-#ifdef _WIN32
-                    st.wYear,
-                    st.wMonth,
-                    st.wDay,
-                    st.wHour,
-                    st.wMinute,
-                    st.wSecond);
-            SetEvent(e1);
-#else
-            st->tm_year+1900,
-            st->tm_mon+1,
-            st->tm_mday,
-            st->tm_hour,
-            st->tm_min,
-            st->tm_sec);
-        sem_post(&e1);
-#endif
-            break;
-        case PREVIEW_SCAN:
-            statusCountFlag = 1;
-            status = SCANNING;
-            printf("Do preview!\r\n");
-            break;
-        case STOP:
-            statusCountFlag = 0;
-            stop_flag = 1;
-            progress = 0;
-            status = READY;
-#ifdef _WIN32
-            SetEvent(e2);
-#else
-        sem_post(&e2);
-#endif
-            printf("Stop everything!\r\n");
-            break;
-        case SCAN_CONTINUE:
-#ifdef _WIN32
-            SetEvent(e2);
-#else
-        sem_post(&e2);
-#endif
-            break;
-    }
-	return 0;
-}
-
-
-
-StatusInfo GetStatus() {
-	StatusInfo inf;
-	inf.status = status;
-	inf.progress = progress;
-	return inf;
-}
-
-//result, 0 success, other false
-#ifdef _WIN32
-int SetScanInfo(const char* jsonString, int e) {
-#else
-int SetScanInfo(const __attribute__((unused))char* jsonString, __attribute__((unused))int e){
-#endif
-    empty = e;
-	return 0;
-}
-
-int preivew_change_flag = 0;
-
-const size_t Row = 140;
-const size_t Col = 140;
-
-#define BUFFER_SIZE Row * Col
-
-const char* FRAME_FILE_PATH_1 = "./img1_v2.bin";
-const char* FRAME_FILE_PATH_2 = "./pre_image.bin";
-
-int previewCount = 0;
-const char* GetPreviewData() {
-    previewCount++;
-//    if (previewCount>3){
-//        status = READY;
-//        innerCallback("Preview Device Error");
-//        return NULL;
-//    }
-	FILE* file;
-	preivew_change_flag++;
-	preivew_change_flag = preivew_change_flag % 2;
-	//    _sleep(2000);
-	if (file = fopen(preivew_change_flag ? FRAME_FILE_PATH_1 : FRAME_FILE_PATH_2, "rb")) {
-		unsigned char* buffer = malloc(sizeof(unsigned char) * BUFFER_SIZE);
-		fread(buffer, sizeof(unsigned char), BUFFER_SIZE, file);
-		fclose(file);
-		return buffer;
-	}
-
-	return NULL;
-}
-
-const char* GetDeviceInfo(DeviceInfo infoType) {
-	switch (infoType) {
-		case MEAN_TEMPERATURE:
-			return "28";
-		case VERSION:
-			return "6.6.06";
-		case DEV_OUTPATH:
-			return output_path;
-	}
-	return "";
-}
-
-#ifdef _WIN32
-void StopDevice(){
-    CloseHandle(e1);
-    CloseHandle(e2);
-}
-#endif
--- a/src/ShimLib/ShimLib.h
+++ b/src/ShimLib/ShimLib.h
@@ -1,61 +0,0 @@
-//
-// Created by Krad on 2021/10/12.
-//
-
-#ifndef GUI_SHIMLIB_H
-#define GUI_SHIMLIB_H
-#ifdef __cplusplus
-extern "C"{
-#endif
-typedef enum {
-    BUSY,// device is preparing for scan
-    READY,// device is ready for scan
-    SCANNING,// device is doing scan
-    ERROR// some device inner error are occured
-} DeviceStatus;
-
-typedef struct StatusInfo {
-    DeviceStatus status;// a enum represent device current status
-    int progress;// percent value of operation
-} StatusInfo;
-
-
-//3 kinds of scan action
-typedef enum {
-    SCAN,// Start scan action
-    PREVIEW_SCAN,// Start preview scan action
-    STOP,// Stop current scan
-    SCAN_CONTINUE,//Continue pending scan
-} ScanAction;
-
-//kinds of device information
-typedef enum {
-    MEAN_TEMPERATURE,
-    VERSION,
-    DEV_OUTPATH
-} DeviceInfo;
-
-extern int InitLib(void(*)(const char *msg));
-
-extern void SetMessageCallback(void(*)(const char* aMessage,const unsigned int aInfoType));
-
-extern int ScanControl(ScanAction actionType);
-
-extern StatusInfo GetStatus();
-
-extern int SetScanInfo(const char *jsonString,int empty);
-
-extern const char *GetPreviewData();
-
-extern const char *GetDeviceInfo(DeviceInfo infoType);
-
-#ifdef _WIN32
-extern void StopDevice();
-#endif
-
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif //GUI_SHIMLIB_H
--- a/src/components/TimeSliderPickerBox.cpp
+++ b/src/components/TimeSliderPickerBox.cpp
@@ -0,0 +1,95 @@
+#include "TimeSliderPickerBox.h"
+#include <QHBoxLayout>
+#include <QLabel>
+
+TimeSlidePickerBox::TimeSlidePickerBox(QWidget* aParent)
+ : QWidget(aParent)
+ , mLayout(new QHBoxLayout(this))
+ , mHourBox1(new SlidePickerBox(this))
+ , mHourBox2(new SlidePickerBox(this))
+ , mMinuteBox1(new SlidePickerBox(this))
+ , mMinuteBox2(new SlidePickerBox(this))
+ , mSecondBox1(new SlidePickerBox(this))
+ , mSecondBox2(new SlidePickerBox(this))
+ , mIsMinuteSixty(false)
+ , mIsSecondSixty(false)
+{
+    initBox(mHourBox1, {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, 56);
+    initBox(mHourBox2, {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, 56);
+
+    QLabel* hour = new QLabel(this);
+    hour->setText("H");
+    hour->setAlignment(Qt::AlignCenter);
+    hour->setFixedWidth(50);
+    hour->setObjectName("sliderSpliterLabel");
+    mLayout->addWidget(hour);
+
+    initBox(mMinuteBox1, {"0", "1", "2", "3", "4", "5"}, 56);
+    initBox(mMinuteBox2, {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, 56);
+
+    QLabel* min = new QLabel(this);
+    min->setText("M");
+    min->setAlignment(Qt::AlignCenter);
+    min->setFixedWidth(50);
+    min->setObjectName("sliderSpliterLabel");
+    mLayout->addWidget(min);
+
+    initBox(mSecondBox1, {"0", "1", "2", "3", "4", "5"}, 56);
+    initBox(mSecondBox2, {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, 56);
+
+    QLabel* sec = new QLabel(this);
+    sec->setText("S");
+    sec->setAlignment(Qt::AlignCenter);
+    sec->setFixedWidth(50);
+    sec->setObjectName("sliderSpliterLabel");
+    mLayout->addWidget(sec);
+}
+
+void TimeSlidePickerBox::initBox(SlidePickerBox* aBox, const QStringList& aItemsValues, int width)
+{
+    aBox->setItems(aItemsValues);
+    mLayout->addWidget(aBox);
+    aBox->setFixedWidth(width);
+}
+
+void TimeSlidePickerBox::resizeLabel()
+{
+    mHourBox1->resizeLabelWidth();
+    mHourBox2->resizeLabelWidth();
+    mMinuteBox1->resizeLabelWidth();
+    mMinuteBox2->resizeLabelWidth();
+    mSecondBox1->resizeLabelWidth();
+    mSecondBox2->resizeLabelWidth();
+}
+
+QString TimeSlidePickerBox::getSelectedValue() const
+{
+    return QString("%1%2%3%4%5%6%7%8%9").arg(mHourBox1->getSelectedValue())
+                                        .arg(mHourBox2->getSelectedValue())
+                                        .arg(tr("Hour"))
+                                        .arg(mMinuteBox1->getSelectedValue())
+                                        .arg(mMinuteBox2->getSelectedValue())
+                                        .arg(tr("Min"))
+                                        .arg(mSecondBox1->getSelectedValue())
+                                        .arg(mSecondBox2->getSelectedValue())
+                                        .arg(tr("Sec"));
+}
+int TimeSlidePickerBox::getTotalSeconds() const
+{
+    return mHourBox1->getSelectedValue().toInt() * 10 * 3600 +
+           mHourBox2->getSelectedValue().toInt() * 3600 +
+           mMinuteBox1->getSelectedValue().toInt() * 10 * 60 +
+           mMinuteBox2->getSelectedValue().toInt() * 60 +
+           mSecondBox1->getSelectedValue().toInt() * 10 +
+           mSecondBox2->getSelectedValue().toInt();
+}
+
+void TimeSlidePickerBox::setSelectedValue(const int& aSeconds)
+{
+    mHourBox1->setSelectedValue(QString::number(aSeconds / 36000));
+    mHourBox2->setSelectedValue(QString::number((aSeconds / 3600) % 10));
+    mMinuteBox1->setSelectedValue(QString::number((aSeconds % 3600) / 600));
+    mMinuteBox2->setSelectedValue(QString::number((aSeconds % 600) / 60));
+    mSecondBox1->setSelectedValue(QString::number((aSeconds % 60) / 10));
+    mSecondBox2->setSelectedValue(QString::number(aSeconds % 10));
+}
--- a/src/components/TimeSliderPickerBox.h
+++ b/src/components/TimeSliderPickerBox.h
@@ -0,0 +1,33 @@
+#ifndef GUI_TIMESLIDEPICKERBOX_H
+#define GUI_TIMESLIDEPICKERBOX_H
+
+#include <QWidget>
+#include "SlidePickerBox.h"
+
+class QHBoxLayout;
+
+class TimeSlidePickerBox : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit TimeSlidePickerBox(QWidget* aParent = nullptr);
+    QString getSelectedValue() const;
+    int getTotalSeconds() const;
+    void setSelectedValue(const int& aSeconds);
+    void resizeLabel();
+
+private:
+    QHBoxLayout* mLayout;
+    SlidePickerBox* mHourBox1;
+    SlidePickerBox* mHourBox2;
+    SlidePickerBox* mMinuteBox1;
+    SlidePickerBox* mMinuteBox2;
+    SlidePickerBox* mSecondBox1;
+    SlidePickerBox* mSecondBox2;
+    bool mIsMinuteSixty;
+    bool mIsSecondSixty;
+    void initBox(SlidePickerBox* aBox, const QStringList& aItemsValues, int width = 50);
+};
+
+
+#endif //GUI_TIMESLIDEPICKERBOX_H
--- a/src/db/SQLHelper.cpp
+++ b/src/db/SQLHelper.cpp
@@ -135,3 +135,48 @@ void SQLHelper::QueryMap(const QString& sql, QMap<QString, QVariant> &result, co
        }
    }
 }
+
+bool SQLHelper::exec(const QString& aSql)
+{
+    QSqlQuery query(*defaultDatabase);
+    bool result = query.exec(aSql);
+    if(!result)
+    {
+        qDebug() << query.lastError().text();
+    }
+    return result;
+}
+
+QVariant SQLHelper::queryValue(const QString& aSql)
+{
+    QSqlQuery query(*defaultDatabase);
+    if (!query.exec(aSql))
+    {
+        qDebug()<<query.lastError().text();
+        return QVariant();
+    }
+    if(query.next())
+    {
+        return query.value(0);
+    }
+
+    return QVariant();
+}
+
+QList<QVariant> SQLHelper::queryValues(const QString& aSql)
+{
+    QList<QVariant> result;
+    QSqlQuery query(*defaultDatabase);
+    if (!query.exec(aSql))
+    {
+        qDebug()<<query.lastError().text();
+        return QList<QVariant>();
+    }
+
+    while(query.next())
+    {
+        result.append(query.value(0));
+    }
+
+    return result;
+}
--- a/src/db/SQLHelper.h
+++ b/src/db/SQLHelper.h
@@ -23,6 +23,9 @@ public:
    static QSqlQueryModel* QueryModel(const QString &queryName);
    static QSqlQueryModel* QueryModel(const QString &queryName, const QString &sql, const QMap<QString, QVariant> &params = QMap<QString, QVariant>());
    static QSqlTableModel* getTable(const QString & tableName);
+    static bool exec(const QString& aSql);
+    static QVariant queryValue(const QString& aSql);
+    static QList<QVariant> queryValues(const QString& aSql);
 private:
    static QSqlDatabase*  defaultDatabase;
 };
--- a/src/device/DeviceDefs.h
+++ b/src/device/DeviceDefs.h
@@ -0,0 +1,16 @@
+#ifndef DEVICEDEFS_H
+#define DEVICEDEFS_H
+
+#include "daq_define.h"
+
+enum class DeviceStatus
+{
+    Busy = 0,	    // device is preparing for scan
+    Rready,		    // device is ready for scan
+    Scanning,	    // device is doing scan
+    Error,   	    // some device inner error are occured
+    Unkonw          // dms connection error
+};
+
+
+#endif // DEVICEDEFS_H
--- a/src/device/DeviceManager.cpp
+++ b/src/device/DeviceManager.cpp
--- a/src/device/DeviceManager.h
+++ b/src/device/DeviceManager.h
@@ -7,8 +7,14 @@

 #include <QObject>
 #include <QThread>
+#include "DeviceDefs.h"
+
+class DmsSyncAction;
+class DmsAsyncAction;
+
+class DeviceManager : public QObject
+{

-class DeviceManager : public QObject {
    Q_OBJECT

 public:
@@ -19,7 +25,16 @@ public:

    DeviceManager() = default;

-    ~DeviceManager() override = default;
+    ~DeviceManager() override
+    {
+//        mCmdSendThread->quit();
+//        mCmdSendThread->wait();
+//        mCmdSendThread->deleteLater();
+
+        mDmsInfoReceiveThread->quit();
+        mDmsInfoReceiveThread->wait();
+        mDmsInfoReceiveThread->deleteLater();
+    }

    DeviceManager(const DeviceManager &) = delete;

@@ -41,24 +56,19 @@ public:
     * Get Firm ware version
     * @return Firm ware version
     */
-    static QString getSoftwareVersion();
+    QString getSoftwareVersion();

-    /**
-     * Get Scan data output path
-     * @return Scan data output path
-     */
-    static QString getScanOutputPath();
+//    void setErrorOccurred(bool v) {
+//        mErrorOccurred = v;
+//    }

-    void setErrorOccurred(bool v) {
-        mErrorOccurred = v;
-    }
-
-    bool getErrorOccurred() {
-        return mErrorOccurred;
-    }
+//    bool getErrorOccurred() {
+//        return mErrorOccurred;
+//    }

    void emitErrorCallback(const char *msg);
-    void emitInfoCallback(const char* aMessage,const unsigned int aInfoType);
+    void emitInfoCallback(const QString& aMessage,const unsigned int aInfoType);
+    bool hasValidEmptyScan();

 signals:

@@ -74,50 +84,90 @@ private:
     * @param json The patient information json string
     * @param empty Empty scan flag
     */
-    void startScan(const char *json, bool empty = false);
-
-    /**
-     * Post Scan start command to Shimlib
-     */
-    void postScanCommand();
-
-    /**
-     * Post Continue Scan command to Shimlib
-     * @param useTimer start a new timer flag
-     */
-    void postContinueCommand(bool useTimer = false);
-
-    /**
-     * Prepare for finishing the Scan
-     */
-    void prepareFinishScan();
-
-    /**
-     * exit the current Scan process timer
-     */
-    void exitScanTimer();
-
-    /**
-     * Process scan progress change
-     * @param Scan progress
-     */
-    void scanProcess(int aProgress);
-
-    void initPreviewThread();
-
-    void stopScan();
-
+    void startScan(const QString& json, bool empty = false);
    void startPreview();
+    void shutdown();
+    void createScanReconRecord(const QString& aScanID, const QString& aPatientID, const QString& aReferenceID);

-    int mScanPhase = 1;
-    volatile int mTimerID = -1;
-    int mDeviceInfTimerID = -1;
-    int mLastStatus = -1;
-    bool mPreviewing = false;
-    volatile bool mEndLoop = false;
-    volatile bool mErrorOccurred = false;
-    QThread *mPreviewDataCaller = nullptr;
+//-----------------new
+    DeviceStatus getDeviceStatus();
+    bool startFullScan(const QString& aPatientInfo);
+    void stopFullScan();
+    void stopPreviewScan();
+    void getDeviceTemperature();
+    void getScanProcess();
+    void startTransfer();
+    void initEmptyScanMeasurementID();
+    void updateReconState();

+    void processScanProcess(const QString& aProgress);
+    void prepareFinishScan(bool isNormalFinish, const QString& aReason = "");
+    void processAlarm(const QString& aAlarm);
+    void processPreviewData(const QString& aPreviewData);
+    void processGetSoftwareVersion(const QString& aSoftwareVersion);
+    void processDeviceTemperature(const QString& aResponseTemperature);
+    void processTransferProgress(const QString& aProgress);
+
+    void insertEmptyScanRecord();
+    void insertScanRecord();
+
+
+private slots:
+    //DMS
+    void processReceiveDMSInfoResult(int aServerID, int aActionID, const QString& aContents);
+    //Recon
+    void processReconCreateEmptyScan(bool aResult, const QString& aScanID, const QString& aMessage);
+    void processReconCreateScan(bool aResult, const QString& aScanID, const QString& aMessage);
+    void processReconQueryScanState(const QMap<QString, int> aResult);
+    //GUI
+    void scanTimeout();
+
+signals:
+    //DMS
+    void responseGetDeviceStatus(const QString& aDeviceStatus);
+    void responseGetDeviceTemperature(const QString& aDeviceTemperature);
+    void responseFullScan(const QString& aResponse);
+    void responseGetScanProgress(const QString& aProgrese);
+    void responseStopScan(const QString& aResponse);
+    void responsePreviewScan(const QString& aResponse);
+    void responseGetSoftwareVersion(const QString& aSoftwareVersion);
+    void responseTransfer(const QString& aResponse);
+    //Recon
+    void createEmptyScanToRecon(const QString& aScanID, const QString& aPath);
+    void createScanToRecon(const QString& aScanID, const QString& aPatientID, const QString& aReferenceID, const QString& aPath);
+    void queryScanStatusToRecon(const QStringList& aScanIDs);
+
+
+private:
+    int mTemperatureTimer = -1;
+    int mScanProgressTimer = -1;
+    bool mIsEmptyScan = false;
+    bool mIsTransferEmptyScan = false;
+    bool mIsScanning = false;
+    bool mIsTransfering = false;
+    bool mIsPreviewing = false;
+
+    QString mCurrentScanMeasurementID = "";
+    QString mCurrentEmptyMeasurementID = "";
+    QString mCurrentPatientName = "";
+    QString mCurrentPatientID = "";
+    QString mCurrentLaterality = "";
+    QString mCurrentOperatorName = "";
+    QString mCurrentTransferMeasurementID = "";
+    QString mCurrentTransferPatientID = "";
+    QString mSoftwareVersion = "";
+    QThread* mDmsInfoReceiveThread = nullptr;
+    QThread* mReconHttpThread = nullptr;
+    DmsSyncAction* mGetDeviceStatusAction = nullptr;
+    DmsSyncAction* mFullScanAction = nullptr;
+    DmsSyncAction* mPreviewScanAction = nullptr;
+    DmsSyncAction* mCEScanAction = nullptr;
+    DmsSyncAction* mStopScanAction = nullptr;
+    DmsSyncAction* mTransferAction = nullptr;
+
+    DmsAsyncAction* mGetDeviceTemperatureAction = nullptr;
+    DmsAsyncAction* mGetScanProgressAction = nullptr;
+    DmsAsyncAction* mGetSoftwareVersionAction = nullptr;

 };

--- a/src/device/DmsAsyncAction.cpp
+++ b/src/device/DmsAsyncAction.cpp
@@ -0,0 +1,46 @@
+#include "DmsAsyncAction.h"
+#include "dms_mq.h"
+
+#include <QTimer>
+
+namespace
+{
+    const int TIMEOUT_MSEC = 500;
+}
+
+DmsAsyncAction::DmsAsyncAction(int aServerId, int aActionId, QObject* aObject, const QString& aResponseSignal, QObject* aParent)
+    : QObject(aParent)
+    , mServerId(aServerId)
+    , mActionId(aActionId)
+    , mTimer(new QTimer(this))
+    , mObject(aObject)
+    , mResponseSignal(aResponseSignal)
+    , mSendData()
+{
+    mTimer->setSingleShot(true);
+    connect(mTimer, &QTimer::timeout, this, &DmsAsyncAction::sendTimeoutSignal);
+    connect(mObject, ("2" + mResponseSignal).toStdString().c_str(), mTimer, SLOT(stop()));
+}
+
+DmsAsyncAction::~DmsAsyncAction()
+{
+    disconnect(mTimer, &QTimer::timeout, this, &DmsAsyncAction::sendTimeoutSignal);
+    disconnect(mObject, ("2" + mResponseSignal).toStdString().c_str(), mTimer, SLOT(stop()));
+}
+
+bool DmsAsyncAction::execute()
+{
+    QByteArray byteArray = mSendData.toUtf8();
+    uint8_t* data = reinterpret_cast<uint8_t*>(byteArray.data());
+    if(dmsmq_send(mServerId, mActionId, data, byteArray.size()) < 0)
+    {
+        return false;
+    }
+    mTimer->start(TIMEOUT_MSEC);
+    return true;
+}
+
+void DmsAsyncAction::sendTimeoutSignal()
+{
+    emit timeout();
+}
--- a/src/device/DmsAsyncAction.h
+++ b/src/device/DmsAsyncAction.h
@@ -0,0 +1,45 @@
+#ifndef DMSASYNCACTION_H
+#define DMSASYNCACTION_H
+
+#include <QObject>
+
+class QEventLoop;
+class QTimer;
+
+struct DmsAsyncActionResult
+{
+    DmsAsyncActionResult(bool aIsSucessful = false, const QString& aData = "")
+    {
+        mIsSucessful = aIsSucessful;
+        mData = aData;
+    }
+    bool mIsSucessful;
+    QString mData;
+};
+
+class DmsAsyncAction : public QObject
+{
+    Q_OBJECT
+public:
+    DmsAsyncAction(int aServerId, int aActionId, QObject* aObject, const QString& aResponseSignal, QObject* aParent = nullptr);
+    ~DmsAsyncAction();
+
+    bool execute();
+    void setSendData(const QString& aData);
+
+signals:
+    void timeout();
+
+private slots:
+    void sendTimeoutSignal();
+
+private:
+    int mServerId;
+    int mActionId;
+    QTimer* mTimer;
+    QObject* mObject;
+    QString mResponseSignal;
+    QString mSendData;
+};
+
+#endif // DMSASYNCACTION_H
--- a/src/device/DmsSyncAction.cpp
+++ b/src/device/DmsSyncAction.cpp
@@ -0,0 +1,74 @@
+#include "DmsSyncAction.h"
+#include "dms_mq.h"
+
+#include <QEventLoop>
+#include <QTimer>
+#include <QDebug>
+namespace
+{
+    const int TIMEOUT_MSEC = 500;
+}
+
+DmsSyncAction::DmsSyncAction(int aServerId, int aActionId, QObject* aObject, const QString& aSignal, QObject* aParent)
+    : QObject(aParent)
+    , mServerId(aServerId)
+    , mActionId(aActionId)
+    , mLoop(new QEventLoop(this))
+    , mTimer(new QTimer(this))
+    , mObject(aObject)
+    , mSignal(aSignal)
+    , mTimeoutMsec(TIMEOUT_MSEC)
+    , mSendData()
+    , mActionResult()
+{
+    mTimer->setSingleShot(true);
+    connect(mObject, ("2" + mSignal).toStdString().c_str(), this, SLOT(saveActionResult(const QString&)));
+    connect(mObject, ("2" + mSignal).toStdString().c_str(), mLoop, SLOT(quit()));
+    connect(mTimer, &QTimer::timeout, mLoop, &QEventLoop::quit);
+}
+
+DmsSyncAction::~DmsSyncAction()
+{
+    disconnect(mObject, ("2" + mSignal).toStdString().c_str(), mLoop, SLOT(quit()));
+    disconnect(mObject, ("2" + mSignal).toStdString().c_str(), this, SLOT(saveActionResult(const QString&)));
+    disconnect(mTimer, &QTimer::timeout, mLoop, &QEventLoop::quit);
+}
+
+DmsSyncActionResult DmsSyncAction::execute()
+{
+    QByteArray byteArray = mSendData.toUtf8();
+    uint8_t* data = reinterpret_cast<uint8_t*>(byteArray.data());
+    if(dmsmq_send(mServerId, mActionId, data, byteArray.size()) < 0)
+    {
+        DmsSyncActionResult result(false, "mq error");
+        return result;
+    }
+    if(!waitUntilSignalReceived())
+    {
+        DmsSyncActionResult result(false, "time out");
+        return result;
+    }
+    return DmsSyncActionResult(true, mActionResult);
+}
+
+void DmsSyncAction::saveActionResult(const QString& aResult)
+{
+    mActionResult = aResult;
+}
+
+void DmsSyncAction::setSendData(const QString& aData)
+{
+    mSendData = aData;
+}
+
+bool DmsSyncAction::waitUntilSignalReceived()
+{
+    mTimer->start(mTimeoutMsec);
+    mLoop->exec();
+    if(!mTimer->isActive())
+    {
+        return false;
+    }
+    mTimer->stop();
+    return true;
+}
--- a/src/device/DmsSyncAction.h
+++ b/src/device/DmsSyncAction.h
@@ -0,0 +1,48 @@
+#ifndef DMSSYNCACTION_H
+#define DMSSYNCACTION_H
+
+#include <QObject>
+
+class QEventLoop;
+class QTimer;
+
+struct DmsSyncActionResult
+{
+    DmsSyncActionResult(bool aIsSucessful = false, const QString& aData = "")
+    {
+        mIsSucessful = aIsSucessful;
+        mData = aData;
+    }
+    bool mIsSucessful;
+    QString mData;
+};
+
+class DmsSyncAction : public QObject
+{
+    Q_OBJECT
+public:
+    DmsSyncAction(int aServerId, int aActionId, QObject* aObject, const QString& aSignal, QObject* aParent = nullptr);
+    ~DmsSyncAction();
+
+    DmsSyncActionResult execute();
+    void setSendData(const QString& aData);
+
+private slots:
+    void saveActionResult(const QString& aResult);
+
+private:
+    bool waitUntilSignalReceived();
+
+private:
+    int mServerId;
+    int mActionId;
+    QEventLoop* mLoop;
+    QTimer* mTimer;
+    QObject* mObject;
+    QString mSignal;
+    int mTimeoutMsec;
+    QString mSendData;
+    QString mActionResult;
+};
+
+#endif // DMSSYNCACTION_H
--- a/src/device/InfoReceiveWorker.cpp
+++ b/src/device/InfoReceiveWorker.cpp
@@ -0,0 +1,35 @@
+#include "InfoReceiveWorker.h"
+#include "dms_mq.h"
+#include "daq_define.h"
+
+InfoReceiveWorker::InfoReceiveWorker(QObject* aParent)
+    : QObject(aParent)
+{
+
+}
+
+void InfoReceiveWorker::startListen()
+{
+    int serverID;
+    int actionID;
+    uint8_t* data = new uint8_t[4096];
+    int count;
+    for(;;)
+    {
+        count = dmsmq_recv(&serverID, &actionID,data);
+        if(count >= 0)
+        {
+            uint8_t* copyData = data;
+            if(serverID == USRV_LOGALARM && actionID == ACT_LOGALM_RPT)
+            {
+                data[count] = '\0';
+                QString myQString = QString::fromUtf8(reinterpret_cast<const char*>(copyData + 3));
+                emit infoReceived(serverID, actionID, myQString);
+                continue;
+            }
+            data[count] = '\0';
+            QString myQString = QString::fromUtf8(reinterpret_cast<const char*>(copyData));
+            emit infoReceived(serverID, actionID, myQString);
+        }
+    }
+}
--- a/src/device/InfoReceiveWorker.h
+++ b/src/device/InfoReceiveWorker.h
@@ -0,0 +1,21 @@
+#ifndef INFORECEIVEWORKER_H
+#define INFORECEIVEWORKER_H
+
+#include <QObject>
+#include <QSharedPointer>
+
+class InfoReceiveWorker : public QObject
+{
+    Q_OBJECT
+public:
+    InfoReceiveWorker(QObject* aParent);
+
+public slots:
+    void startListen();
+
+signals:
+    void infoReceived(int aServerID, int aActionID, const QString& aContents);
+
+};
+
+#endif // INFORECEIVEWORKER_H
--- a/src/device/daq_define.h
+++ b/src/device/daq_define.h
@@ -0,0 +1,119 @@
+#ifndef _DAQ_DEFINE_H_
+#define _DAQ_DEFINE_H_
+
+
+//-------------------- 定义服务和动作 ---------------------------
+enum{
+    USRV_NONE = 0,
+    USRV_SCAN,          //扫查服务
+    USRV_XFR,           //数据传输服务
+    USRV_INFOCFG,       //信息与配置服务
+    USRV_CONTROL,       //杂类控制和调试服务
+    USRV_FIRMWARE,      //设备升级
+    USRV_LOGALARM,      //日志和报警服务
+    USRV_HEARTBEAT,     //心跳服务
+    USRV_NET,           //网络服务，设备端专用
+};
+
+//扫查服务动作
+enum{
+    ACT_SCAN_NONE = 0,
+    ACT_SCAN_RESP,      //上报扫查状态（错误码，结束等）
+    ACT_SCAN_PREVIEW,   //预扫
+    ACT_SCAN_FULLSCAN,  //全扫
+    ACT_SCAN_CE,        //CE自检
+    ACT_SCAN_STOP,      //停止扫查
+    ACT_SCAN_PROGRESS_ACTIVE,  //DMS主动上报扫查进度
+    ACT_SCAN_APPCFG,    //扫查加载应用配置
+    ACT_SCAN_STATUS,    //查询扫查状态
+    ACT_SCAN_TEMP,      //查询平均温度
+    ACT_SCAN_POSITION,  //查询位置相关信息
+    ACT_SCAN_PROGRESS_PASSIVE,  //被动上报扫查进度（GUI查询）
+    ACT_SCAN_SINGLE,    //单独FEB扫查
+    ACT_SCAN_SIMULATOR, //配置模拟模式 1：模拟模式，0：真实模式，默认是0
+    ACT_SCAN_PRESIG,    //预扫数据产生完成信号
+    ACT_SCAN_PRERESP,   //上位机处理完数据后的响应
+};
+
+//数据传输服务
+enum{
+    ACT_XFR_NONE = 0,
+    ACT_XFR_RESP,       //上报传输状态(错误码，结束等)
+    ACT_XFR_START,      //启动传输（含SRC和DST参数）
+    ACT_XFR_CFG,        //传输配置，比如限速等
+    ACT_XFR_STOP,       //停止/取消传输
+    ACT_XFR_PROGRESS_ACTIVE,    //DMS主动上报传输进度（100%代表完成）
+    ACT_XFR_PROGRESS_PASSIVE,   //被动上报传输进度（GUI查询）
+    ACT_XFR_STATUS,     //查询传输状态
+};
+
+//信息与配置服务
+enum{
+    ACT_IFCFG_NONE = 0,
+    ACT_IFCFG_RESP,     //默认的配置回复
+    ACT_IFCFG_VERINFO,   //GUI发给设备为请求数据，设备上报数据内容（软硬件版本，系统信息等一系列信息。）
+    ACT_IFCFG_SCANCFG,  //GUI发给设备为请求数据，设备上报数据内容
+    ACT_IFCFG_SYSCFG,   //GUI发给设备为请求数据，设备上报数据内容
+    ACT_IFCFG_HBCFG,    //设置心跳频率
+    ACT_IFCFG_DEFAULT,  //将配置恢复到默认值（再次加载配置文件到结构体）
+};
+
+//杂类控制和调试服务
+//配置成不透传模式，则XX_RESP永远不会上传数据，有错误也是通过LOG发回来。
+//如果配置成透传，则所有结果都从XX_RESP再上报一次。XX_RESP的另外一个作用就是打包和判定是否需要上传。
+enum{
+    ACT_CTL_NONE = 0,
+    ACT_CTL_MOTOR_CFG,  //电机配置（0不透传，1透传）
+    ACT_CTL_MOTOR_CMD,  //下发电机控制命令
+    ACT_CTL_MOTOR_RESP, //上传电机响应
+    ACT_CTL_MOTOR_RESET,//设备异常的时候强制复位。
+    ACT_CTL_POWER_CFG,  //电源配置（0不透传，1透传）
+    ACT_CTL_POWER_CMD,  //下发电源控制命令
+    ACT_CTL_POWER_RESP, //上传电源响应
+    ACT_CTL_POWER_RESET,//设备异常的时候强制复位。
+    ACT_CTL_DB_CFG,
+    ACT_CTL_DB_CMD,
+    ACT_CTL_DB_RESP,
+    ACT_CTL_DB_RESET,
+    ACT_CTL_FEB_CFG,
+    ACT_CTL_FEB_CMD,
+    ACT_CTL_FEB_RESP,
+    ACT_CTL_FEB_RESET,
+};
+
+//设备升级
+enum{
+    ACT_FMW_NONE = 0,
+    ACT_FMW_RESP,       //上报升级结果        
+    ACT_FMW_CFG,        //固件升级配置（json格式）
+    ACT_FMW_LOAD,       //下载固件到设备
+    ACT_FMW_START,      //启动固件升级
+};
+
+//日志和报警服务
+enum{
+    ACT_LOGALM_NONE = 0,
+    ACT_LOGALM_RPT,     //日志上报
+    ACT_LOGALM_CFG,     //日志配置（调整日志等级）
+};
+
+//心跳服务
+enum{
+    ACT_HB_NONE = 0,
+    ACT_HB_BEAT,        //心跳包
+};
+
+//网络服务
+enum{
+    ACT_NET_NONE = 0,
+    ACT_NET_LOCAL,      //向LocalSocket发送数据
+    ACT_NET_REMOTE,     //想远程GUI发送数据
+    ACT_NET_DEBUG,      //向调试工具发送数据
+    ACT_NET_SVMQ,       //本地基于 SystemV的MQ通讯
+    ACT_NET_ALL,        //向上述四个通道发送数据
+    ACT_NET_CFG,        //网络配置
+    ACT_NET_DEFAULT,    //重置网络
+};
+
+
+#endif
--- a/src/device/dms_mq.h
+++ b/src/device/dms_mq.h
@@ -0,0 +1,33 @@
+#ifndef _DMS_MQ_H_
+#define _DMS_MQ_H_
+
+enum{
+    MQERR_DISCONNECT = -1,
+    MQERR_FULL = -2,
+    MQERR_NOMSGID = -3,
+    MQERR_MSGCTL_FAILED = -4,
+    MQERR_BLOCKED = -5,
+    MQERR_LOSTMSG = -6,
+    MQERR_PACKERR = -7,
+    MQERR_THDERR = -8,
+};
+
+//初始化DMS的MQ序列
+int dmsmq_init( void );
+
+//接收DMS的MQ序列，阻塞方式。
+// srvid   服务ID
+// actid   动作ID
+// data    数据指针
+// 返回值  >= 0    数据长度， < 0 异常信息
+int dmsmq_recv( int *srvid, int *actid, uint8_t *data );
+
+// 发送DMS的MQ序列，立即返回。
+// srvid   服务ID
+// actid   动作ID
+// data    发送数据指针
+// len     发送数据长度
+// 返回值  0 成功，< 0 异常信息
+int dmsmq_send( int srvid, int actid, uint8_t *data, int len );
+
+#endif
--- a/src/device/libdms_mq.cpp
+++ b/src/device/libdms_mq.cpp
@@ -0,0 +1,254 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <stdarg.h>
+
+#include <sys/msg.h>
+
+#include "dms_mq.h"
+enum{
+    USRV_NONE = 0,
+    USRV_SCAN,          //扫查服务
+    USRV_XFR,           //数据传输服务
+    USRV_INFOCFG,       //信息与配置服务
+    USRV_CONTROL,       //杂类控制和调试服务
+    USRV_FIRMWARE,      //设备升级
+    USRV_LOGALARM,      //日志和报警服务
+    USRV_HEARTBEAT,     //心跳服务
+    USRV_NET,           //网络服务，设备端专用
+};
+//心跳服务
+enum{
+    ACT_HB_NONE = 0,
+    ACT_HB_BEAT,        //心跳包
+};
+
+#define MSG_S2C     ( 202301 )
+#define MSG_C2S     ( 202302 )
+
+int msgid_s2c = -1;
+int msgid_c2s = -1;
+
+
+#define MAX_BUFSIZE ( 4096 )
+#define DBG_HEAD    ( 0xDB )
+#define DBG_TAIL    ( 0xA1 )
+#pragma pack( 1 )
+typedef struct{
+    uint8_t head;   // 0xDB
+    uint8_t srvid;  //服务ID
+    uint8_t actid;  //动作ID
+    uint16_t len;   //数据长度
+    uint8_t tail;   //数据尾，固定0xA1
+    uint8_t data[ 0 ];
+}prot_dbg_t;
+#pragma pack( 0 )
+
+typedef struct{
+    uint32_t type;
+    uint8_t data[ 0 ];
+}msgbuf_t;
+
+pthread_t pid = 0;
+
+void *fn_heart( void *arg )
+{
+    uint32_t cnt = 0;
+
+    for( ; ; ){
+        cnt++;
+        dmsmq_send( USRV_HEARTBEAT, ACT_HB_BEAT, ( uint8_t* )( &cnt ), sizeof( cnt ) );
+        // printf( "GUI Run cnt = %d\r", cnt );
+        // fflush( stdout );
+        sleep( 1 );
+    }
+}
+
+//初始化DMS的MQ序列
+int dmsmq_init( void )
+{
+    msgid_c2s = msgget( ( key_t)MSG_C2S, IPC_CREAT | 0600 );
+    if( msgid_c2s == -1 ){
+        perror( "Msgid C2S create error" );
+        return MQERR_NOMSGID;
+    }
+    printf( "MSGID C2S = %d\n", msgid_c2s );
+
+    msgid_s2c = msgget( ( key_t)MSG_S2C, IPC_CREAT | 0600 );
+    if( msgid_s2c == -1 ){
+        perror( "Msgid S2C create error" );
+        return MQERR_NOMSGID;
+    }
+    printf( "MSGID S2C = %d\n", msgid_s2c );    
+
+    //FIXME 如果有阻塞内容，先清理阻塞再次创建msgid。
+    struct msqid_ds mds;
+    int ret;
+    uint8_t tmpbuf[ 4096 ] = { 0x00 };
+    msgbuf_t *mbuf = ( msgbuf_t* )tmpbuf;
+    printf( "Start to clean queue.\n" );
+
+    int msgid[ 2 ];
+    msgid[ 0 ] = msgid_s2c;
+    msgid[ 1 ] = msgid_c2s;
+
+    for( int idx = 0; idx < 2; idx++ ){
+        printf( "Clean msgid %d\n", msgid[ idx ] );
+        for( ; ; ){
+            if( msgctl( msgid[ idx ], MSG_STAT, &mds ) < 0 ){
+                perror( "Get mq info failed..." );
+                return MQERR_MSGCTL_FAILED;
+            }
+            //判断长度并清除
+            if( mds.msg_qnum > 0 ){
+                ret = msgrcv( msgid[ idx ], mbuf, MAX_BUFSIZE, 0, 0 );
+                if( ret == -1 ){
+                    perror( "MQ Recv Error" );
+                    return MQERR_LOSTMSG;
+                }
+            }else{
+                break;
+            }  
+        }
+    }
+
+    //FIXME 创建心跳线程监测状态
+    printf( "Start to create heartbeat thread.\n" );
+    if( pid == 0 ){
+        if( pthread_create( &pid, NULL, fn_heart, NULL ) < 0 ){
+            printf( "Thread create failed...\n" );
+            return MQERR_THDERR;
+        }
+        printf( "Thread create success...\n" );   
+    }
+    
+    return 0;
+}
+
+char hexbuf[4096];
+int hexdump(uint8_t* data, int len, const char* str, ...)
+{
+    va_list args;
+    int idx, xlen;
+
+    if ((str == NULL) || (strlen(str) == 0))
+        return -1;
+
+    va_start(args, str);
+    xlen = (uint32_t)vsprintf((char*)hexbuf, str, args);
+    va_end(args);
+
+    for (idx = 0; idx < len; idx++)
+    {
+        xlen += sprintf(hexbuf + xlen, "%02X ", data[idx]);
+        if (xlen > (int)(sizeof(hexbuf) * 3 / 4))
+        {
+            hexbuf[xlen] = 0x00;
+            printf("%s", hexbuf);
+            xlen = 0;;
+        }
+    }
+    xlen += sprintf(hexbuf + xlen, "\r\n");
+    hexbuf[xlen] = 0x00;
+    printf("%s", hexbuf);
+
+    return 0;
+}
+
+
+//接收DMS的MQ序列，阻塞方式。
+// srvid   服务ID
+// actid   动作ID
+// data    数据指针
+// 返回值  >= 0    数据长度， < 0 异常信息
+#include <iostream>
+int dmsmq_recv( int *srvid, int *actid, uint8_t *data )
+{
+    int ret;
+    uint8_t tmpbuf[ 4096 ] = { 0x00 };
+    msgbuf_t *mbuf = ( msgbuf_t* )tmpbuf;
+
+    ret = msgrcv( msgid_s2c, mbuf, MAX_BUFSIZE, 0, 0 );
+    if( ret == -1 ){
+        printf( "msgrecv error! msgid_s2c = %d\n", msgid_s2c );
+        perror( "MSGRECV : " );
+
+        msgid_s2c = msgget( ( key_t)MSG_S2C, IPC_CREAT | 0600 );
+        if( msgid_s2c == -1 ){
+            perror( "Msgid C2S create error" );
+            return MQERR_NOMSGID;
+        }
+        printf( "MSGID S2C = %d\n", msgid_s2c );    
+        return MQERR_LOSTMSG;
+    }   
+
+    // hexdump( mbuf->data, ret, "mbuf->data hexdump: " );
+
+    if( ret < sizeof( prot_dbg_t ) )
+        return MQERR_PACKERR;
+    prot_dbg_t *prot = ( prot_dbg_t* )( mbuf->data );
+    int head = prot->head;
+    int tail = ( mbuf->data )[ ret - 1 ];
+    if( head != DBG_HEAD || tail != DBG_TAIL )
+        return MQERR_PACKERR;
+    *srvid = prot->srvid;
+    *actid = prot->actid;
+    if( prot->len > 0 )
+        memcpy( data,  mbuf->data + 5, prot->len );
+
+    return prot->len;
+}
+
+// 发送DMS的MQ序列，立即返回。
+// srvid   服务ID
+// actid   动作ID
+// data    发送数据指针
+// len     发送数据长度
+// 返回值  0 成功，< 0 异常信息
+int dmsmq_send( int srvid, int actid, uint8_t *data, int len )
+{
+    uint8_t buf[ 4096 ] = { 0x00 };
+    int dlen = 0;
+    msgbuf_t *mbuf = ( msgbuf_t* )buf;
+
+    mbuf->type = srvid;
+    mbuf->data[ 0 ] = DBG_HEAD;
+    mbuf->data[ 1 ] = srvid;
+    mbuf->data[ 2 ] = actid;
+    *( uint16_t* )( mbuf->data + 3 ) = len;
+    if( len > 0 )
+        memcpy( mbuf->data + 5, data, len );
+    ( mbuf->data )[ len + 5 ] = DBG_TAIL;
+    dlen = 5 + len + 1;
+    struct msqid_ds mds;
+    if( msgctl( msgid_c2s, MSG_STAT, &mds ) < 0 ){
+        perror( "Get mq info failed..." );
+        return MQERR_MSGCTL_FAILED;
+    }
+    if( mds.msg_qnum > 2 ){
+        //printf( "MQ Blocked!\n" );
+        return MQERR_BLOCKED;
+    }
+
+    int trytime = 3;
+    while( trytime-- >= 0 ){
+        if( msgsnd( msgid_c2s, mbuf, dlen, 0 ) == -1 ){
+            perror( "msgsnd error!" );
+            msgid_c2s = msgget( ( key_t)MSG_S2C, IPC_CREAT | 0600 );
+            if( msgid_c2s < 0 ){
+                perror( "Msgid S2C create error" );
+                usleep( 10 * 1000 );
+                continue;
+            }
+        }  
+        break;
+    }
+
+    if( trytime < 0 ){
+        return MQERR_DISCONNECT;
+    }
+    return 0;
+}
+
--- a/src/dialogs/DialogManager.cpp
+++ b/src/dialogs/DialogManager.cpp
@@ -15,6 +15,7 @@
 #include "dialogs/EditPatientDialog.h"
 #include "dialogs/AlertDialog.h"
 #include "dialogs/DateSelectDialog.h"
+#include "dialogs/TimeSelectDialog.h"
 #include "dialogs/SelectDialog.h"
 #include "dialogs/GetWorkListDialog.h"

@@ -89,6 +90,11 @@ void DialogManager::requestLogin(QWidget* aParent)
    if (!mFunctionDialog){
        mFunctionDialog = new LoginDialog(aParent);
    }
+
+    if(mFunctionDialog->isRunning())
+    {
+        return;
+    }
    setTopWidget(mFunctionDialog);
    mFunctionDialog->setWindowModality(Qt::WindowModal);
    mFunctionDialog->exec();
@@ -188,6 +194,17 @@ DialogResult DialogManager::requestSelectDate(const QString& aDate)
    return DialogResult(ret,dialog.getSelectedValue());
 }

+DialogResult DialogManager::requestSelectTime(const int& aSeconds)
+{
+    TimeSelectDialog dialog(mTopWidget);
+    setTopWidget(&dialog);
+    dialog.setSelectedValue(aSeconds);
+    dialog.setWindowModality(Qt::WindowModal);
+    int ret = dialog.exec();
+    releaseTopWidget(&dialog);
+    return DialogResult(ret, dialog.getTotalSeconds());
+}
+
 DialogResult DialogManager::requestSelectLanguage()
 {
    SelectDialog dialog(mTopWidget);
@@ -366,7 +383,6 @@ void DialogManager::invokeOperationStart(QObject *parent, QObject *msg) {
    }
    mOperationMessageDialog->hideExitButton();
    mOperationMessageDialog->startLoading();
-    AppGlobalValues::setInProcessing(true);
    if (mOperationMessageDialog->isHidden())
    {
        mOperationMessageDialog->showFullScreen();
@@ -413,10 +429,10 @@ void DialogManager::invokeOperationEnd(QObject *parent, QObject *msg) {
    if (!mOperationMessageDialog) return;
    if (!mOperationMessageDialog->isHidden())
    {
-        if (msg && ((QVariant*)msg)->toBool())
+        if (msg != nullptr)
        {
            mOperationMessageDialog->stopLoading();
-            mOperationMessageDialog->showMessage("Scan completed!");
+            mOperationMessageDialog->showMessage(*(QString*)msg);
            mOperationMessageDialog->showExitButton();
            mOperationMessageDialog->setWindowModality(Qt::WindowModal);
            mOperationMessageDialog->showFullScreen();
@@ -427,7 +443,6 @@ void DialogManager::invokeOperationEnd(QObject *parent, QObject *msg) {
            mOperationMessageDialog->accept();
        }
        delete mOperationMessageDialog;
-        AppGlobalValues::setInProcessing(false);
    }
 }

--- a/src/dialogs/DialogManager.h
+++ b/src/dialogs/DialogManager.h
@@ -52,6 +52,7 @@ public:
    int requestEditPatientInfo(PatientInformation* aPatientFrom, QSqlTableModel* aModel);
    int requestAlertMessage(const QString& aMessage, DialogButtonMode aButtonMode,const QString& aTitle = QString());
    DialogResult requestSelectDate(const QString& aDate);
+    DialogResult requestSelectTime(const int& aSeconds);
    DialogResult requestSelectLanguage();
    DialogResult requestSelectProtocal();
    DialogResult requestSelectFilter();
--- a/src/dialogs/EditPatientDialog.cpp
+++ b/src/dialogs/EditPatientDialog.cpp
@@ -10,7 +10,7 @@
 #include <QSqlTableModel>
 #include <QSqlError>
 #include <QUuid>
-#include <qDebug>
+#include <QDebug>

 #include "dialogs/SelectDialog.h"
 #include "dialogs/DialogManager.h"
--- a/src/dialogs/GUIMessageDialog.cpp
+++ b/src/dialogs/GUIMessageDialog.cpp
@@ -94,7 +94,7 @@ void GUIMessageDialog::startLoading() {
            mTimerID = -1;
        }
        accept();
-        EventCenter::Default()->triggerEvent(GUIEvents::RequestStop, nullptr, nullptr);
+        EventCenter::Default()->triggerEvent(GUIEvents::RequestFullScanStop, nullptr, nullptr);
        LOG_USER_OPERATION(Stop);
    });
    mTimerID = startTimer(100);
--- a/src/dialogs/MultyMessageDialog.cpp
+++ b/src/dialogs/MultyMessageDialog.cpp
@@ -48,16 +48,16 @@ void MultyMessageDialog::initializeIcon()
 {
    switch (mLevel)
    {
-    case Info:
+    case MessageLevel::Info:
        mIcon->setObjectName("MultyMessageDialogInfo");
        break;
-    case Warning:
+    case MessageLevel::Warning:
        mIcon->setObjectName("MultyMessageDialogWarning");
        break;
-    case Error:
+    case MessageLevel::Error:
        mIcon->setObjectName("MultyMessageDialogError");
        break;
-    case Sucess:
+    case MessageLevel::Sucess:
        mIcon->setObjectName("MultyMessageDialogSucess");
        break;
    default:
--- a/src/dialogs/TimeSelectDialog.cpp
+++ b/src/dialogs/TimeSelectDialog.cpp
@@ -0,0 +1,40 @@
+#include "TimeSelectDialog.h"
+#include "components/TimeSliderPickerBox.h"
+
+#include <QVBoxLayout>
+
+TimeSelectDialog::TimeSelectDialog(QWidget *aParent, Qt::WindowFlags f)
+    : GUIFormBaseDialog(aParent)
+    , mSlidePickerBox(new TimeSlidePickerBox(mFormWidget))
+{
+    this->setFixedSize(460, 380);
+    QVBoxLayout* layout = new QVBoxLayout(mFormWidget);
+    mSlidePickerBox->setObjectName("slidePicker");
+    layout->addWidget(mSlidePickerBox);
+}
+
+TimeSelectDialog::~TimeSelectDialog()
+{
+
+}
+
+void TimeSelectDialog::setSelectedValue(const int& aSeconds)
+{
+    mSlidePickerBox->setSelectedValue(aSeconds);
+    mSlidePickerBox->resizeLabel();
+}
+
+QString TimeSelectDialog::getSelectedValue() const
+{
+    return mSlidePickerBox->getSelectedValue();
+}
+
+bool TimeSelectDialog::updateReferenceData()
+{
+    return true;
+}
+
+int TimeSelectDialog::getTotalSeconds() const
+{
+    return mSlidePickerBox->getTotalSeconds();
+}
--- a/src/dialogs/TimeSelectDialog.h
+++ b/src/dialogs/TimeSelectDialog.h
@@ -0,0 +1,24 @@
+#ifndef GUI_TIMESELECTDIALOG_H
+#define GUI_TIMESELECTDIALOG_H
+
+#include "dialogs/GUIFormBaseDialog.h"
+
+class TimeSlidePickerBox;
+
+class TimeSelectDialog : public GUIFormBaseDialog
+{
+    Q_OBJECT
+public:
+    explicit TimeSelectDialog(QWidget *aParent, Qt::WindowFlags f = Qt::WindowFlags());
+    ~TimeSelectDialog() override;
+    QString getSelectedValue() const;
+    int getTotalSeconds() const;
+    void setSelectedValue(const int& aSeconds);
+
+protected:
+    bool updateReferenceData() override;
+    TimeSlidePickerBox* mSlidePickerBox;
+};
+
+
+#endif //GUI_TIMESELECTDIALOG_H
--- a/src/event/EventCenter.h
+++ b/src/event/EventCenter.h
@@ -9,17 +9,19 @@

 #define ADD_EVENT()\
 ADD_EVENT_VALUE(RequestLogin)\
+ADD_EVENT_VALUE(RequestShutdown)\
 ADD_EVENT_VALUE(LoginRoleChanged)\
 ADD_EVENT_VALUE(PatientSelected)\
 ADD_EVENT_VALUE(RequestPreviewScan)\
 ADD_EVENT_VALUE(RequestEmptyScan)\
 ADD_EVENT_VALUE(RequestPatientScan)\
 ADD_EVENT_VALUE(RequestContinueScan)\
-ADD_EVENT_VALUE(RequestStop)\
+ADD_EVENT_VALUE(RequestFullScanStop)\
+ADD_EVENT_VALUE(RequestPreviewStop)\
 ADD_EVENT_VALUE(ResponseDeviceTemperature)\
 ADD_EVENT_VALUE(ResponsePreview)\
 ADD_EVENT_VALUE(ResponsePreviewData)\
-ADD_EVENT_VALUE(ResponseStop)\
+ADD_EVENT_VALUE(ResponseStopPreview)\
 ADD_EVENT_VALUE(DeviceErrorRaise)\
 ADD_EVENT_VALUE(ShimLibInnerFault)\
 ADD_EVENT_VALUE(InvokeOperationStart)\
--- a/src/forms/TabFormWidget.cpp
+++ b/src/forms/TabFormWidget.cpp
@@ -1,5 +1,5 @@
 #include "TabFormWidget.h"
-#include "ui_tabformwidget.h"
+#include "ui_TabFormWidget.h"
 #include <QDateTime>

 #if defined(_MSC_VER) && (_MSC_VER >= 1600) 
--- a/src/forms/recon/ReconFormWidget.cpp
+++ b/src/forms/recon/ReconFormWidget.cpp
@@ -1,6 +1,6 @@

 #include "ReconFormWidget.h"
-#include "ui_tabformwidget.h"
+#include "ui_TabFormWidget.h"

 #include <QToolButton>
 #include <QVBoxLayout>
--- a/src/forms/scan/PatientInformationForm.cpp
+++ b/src/forms/scan/PatientInformationForm.cpp
@@ -3,6 +3,7 @@
 #include "json/cJSON.h"
 #include "event/EventCenter.h"
 #include "json/ScanJson.h"
+#include "models/User.h"

 PatientInformationForm::PatientInformationForm(QWidget* parent)
 : QWidget(parent)
@@ -45,21 +46,25 @@ void PatientInformationForm::setProtocol(int type) {
 	}
 }

-const char* PatientInformationForm::getCurrentPatientJsonString(bool empty) {
-	cJSON* root = cJSON_CreateObject();
-	cJSON_AddItemToObject(root, "PatientName", cJSON_CreateString(mUI->lbl_Name->text().replace(' ', '_').toStdString().data()));
-	cJSON_AddItemToObject(root, "PatientID", cJSON_CreateString(mUI->lbl_ID->text().replace(' ', '_').toStdString().data()));
-	cJSON_AddItemToObject(root, "PatientSex", cJSON_CreateString(mUI->lbl_Sex->text().toStdString().data()));
-	cJSON_AddItemToObject(root, "PatientBirthDate",
+const char* PatientInformationForm::getCurrentPatientJsonString(bool empty)
+{
+    cJSON* patientInfoObject = cJSON_CreateObject();
+    cJSON_AddItemToObject(patientInfoObject, "PatientName", cJSON_CreateString(mUI->lbl_Name->text().replace(' ', '_').toStdString().data()));
+    cJSON_AddItemToObject(patientInfoObject, "PatientID", cJSON_CreateString(mUI->lbl_ID->text().replace(' ', '_').toStdString().data()));
+    cJSON_AddItemToObject(patientInfoObject, "PatientSex", cJSON_CreateString(mUI->lbl_Sex->text().toStdString().data()));
+    cJSON_AddItemToObject(patientInfoObject, "PatientBirthDate",
 		cJSON_CreateString(mUI->lbl_Date->text().replace("/", "").replace("-", "").replace(' ', '.').toStdString().data()));
-	cJSON_AddItemToObject(root, "Laterality", cJSON_CreateString(mCurrentProtocol ? "R" : "L"));
-	cJSON_AddItemToObject(root, "IsEmptyData", cJSON_CreateNumber(empty ? 1 : 0));
-	cJSON_AddItemToObject(root, "OperatorName", cJSON_CreateString("Bob"));
-	cJSON_AddItemToObject(root, "ReferringPhysicianName", cJSON_CreateString("XX"));
-	cJSON_AddItemToObject(root, "InstitutionName", cJSON_CreateString("EQ9"));
-	cJSON_AddItemToObject(root, "InstitutionAddress", cJSON_CreateString("HZ"));
+    cJSON_AddItemToObject(patientInfoObject, "Laterality", cJSON_CreateString(mCurrentProtocol ? "R" : "L"));
+    cJSON_AddItemToObject(patientInfoObject, "IsEmptyData", cJSON_CreateNumber(empty ? 1 : 0));
+    cJSON_AddItemToObject(patientInfoObject, "OperatorName", cJSON_CreateString(User::Current()->getUserName().toStdString().c_str()));
+    cJSON_AddItemToObject(patientInfoObject, "ReferringPhysicianName", cJSON_CreateString("XX"));
+    cJSON_AddItemToObject(patientInfoObject, "InstitutionName", cJSON_CreateString("EQ9"));
+    cJSON_AddItemToObject(patientInfoObject, "InstitutionAddress", cJSON_CreateString("HZ"));
+
+    cJSON* rootObject = cJSON_CreateObject();
+    cJSON_AddItemToObject(rootObject, "Patient Info", patientInfoObject);
 	delete mJsonStr;
-    mJsonStr = cJSON_Print(root);
-    ScanJson::Current()->store(root);
+    mJsonStr = cJSON_PrintUnformatted (rootObject);
+    ScanJson::Current()->store(rootObject);
 	return mJsonStr;
 }
--- a/src/forms/scan/ScanFormWidget.cpp
+++ b/src/forms/scan/ScanFormWidget.cpp
@@ -3,7 +3,7 @@
 //

 #include "ScanFormWidget.h"
-#include "ui_tabformwidget.h"
+#include "ui_TabFormWidget.h"

 #include <QVBoxLayout>
 #include <QToolButton>
@@ -16,6 +16,7 @@
 #include "event/EventCenter.h"
 #include "log/UserOperationLog.h"
 #include "json/jsonobject.h"
+#include "device/DeviceManager.h"

 #ifdef WIN32
 #else
@@ -157,7 +158,7 @@ void ScanFormWidget::initScanControlBar(QHBoxLayout *layout){
    connect(mBtnScan, &QToolButton::clicked, [=]() {
        QString patientInf(mPatInf->getCurrentPatientJsonString(false));
        LOG_USER_OPERATION(StartScan)
-        if (!JsonObject::Instance()->getEmptyScanID()){
+        if (!DeviceManager::Default()->hasValidEmptyScan()){
            QString msg(tr("No refresh data exists, please do Refresh operation first."));
            EventCenter::Default()->triggerEvent(DeviceErrorRaise, nullptr, (QObject*)(&msg));
            return;
@@ -166,7 +167,7 @@ void ScanFormWidget::initScanControlBar(QHBoxLayout *layout){
    });
    connect(mBtnStop, &QToolButton::clicked, [=]() {
        LOG_USER_OPERATION(Stop)
-        EventCenter::Default()->triggerEvent(RequestStop, nullptr, nullptr);
+        EventCenter::Default()->triggerEvent(RequestPreviewStop, nullptr, nullptr);
    });
    connect(mBtnDrainage, &QToolButton::toggled, [=](bool aSatus) {
        //Drainage
@@ -218,7 +219,7 @@ void ScanFormWidget::renderLoading() {
    mViewer->setPixmap(pic);
 }

-void ScanFormWidget::renderPreviewData(const QObject *sender,const QObject *data) {
+void ScanFormWidget::renderPreviewData(const QObject* /*sender*/,const QObject *data) {
    if (!data)return;
    auto array = (QByteArray*)data;
    auto raw_dataptr = (uchar*)array->data();
@@ -268,7 +269,7 @@ void ScanFormWidget::initEvents() {//Events-------------------------------------
        }
        mPatInf->setPatientInformation((PatientInformation*)data);
    });
-    connect(EventCenter::Default(), &EventCenter::ResponseStop, [=](QObject* sender, QObject* data) {
+    connect(EventCenter::Default(), &EventCenter::ResponseStopPreview, [=](QObject* sender, QObject* data) {
        setPreviewing(false);
    });
    connect(EventCenter::Default(), &EventCenter::ResponsePreview, this,&ScanFormWidget::renderLoading);
--- a/src/forms/select/SelectFormWidget.cpp
+++ b/src/forms/select/SelectFormWidget.cpp
@@ -1,7 +1,7 @@
 //
 // Created by Krad on 2021/10/8.
 //
-#include "ui_tabformwidget.h"
+#include "ui_TabFormWidget.h"
 #include "SelectFormWidget.h"

 #include <QToolButton>
@@ -57,7 +57,7 @@ SelectFormWidget::SelectFormWidget(QWidget* parent)
        prepareButtons(true);
 		});
    // event ResponseStop slot
-	connect(EventCenter::Default(), &EventCenter::ResponseStop, [=](QObject* sender, QObject* data) {
+    connect(EventCenter::Default(), &EventCenter::ResponseStopPreview, [=](QObject* sender, QObject* data) {
        prepareButtons(false);
 	});
    // event ReloadLanguage slot;
--- a/src/forms/settings/AboutForm.cpp
+++ b/src/forms/settings/AboutForm.cpp
@@ -75,7 +75,7 @@ void AboutForm::initUiWidget()
    pMainLayout->addWidget(pGuiVer);

    pEmbededSoftVer = new QLabel(this);
-    pEmbededSoftVer->setText(tr("Embedded Software %1, Data store Path:%2").arg(getEmbVersion(), getDataStorePath()));
+    pEmbededSoftVer->setText(tr("Embedded Software %1").arg(getEmbVersion()));
    pMainLayout->addWidget(pEmbededSoftVer);

    pReconSotfVer = new QLabel(this);
@@ -130,7 +130,7 @@ void AboutForm::initUiWidget()
        pBtnHelp->setText(tr("?"));
        pCompanyCopyRight->setText(tr("Copyright © 2017-2020 Zhejiang Equilibrium Nine Medical Equipment Co., Ltd. All Rights Reversed"));
        pGuiVer->setText(QString(tr("GUI Software V%1")).arg(getGUIVersion()));
-        pEmbededSoftVer->setText(tr("Embedded Software %1, Data store Path:%2").arg(getEmbVersion(), getDataStorePath()));
+        pEmbededSoftVer->setText(tr("Embedded Software %1").arg(getEmbVersion()));
        pReconSotfVer->setText(tr("Reconstruction Software V1.2"));
        pFEBVer->setText(tr("FEB Information"));
        });
@@ -160,8 +160,3 @@ QString AboutForm::getEmbVersion()
 {
    return DeviceManager::Default()->getSoftwareVersion();
 }
-
-QString AboutForm::getDataStorePath()
-{
-    return DeviceManager::Default()->getScanOutputPath();;
-}
--- a/src/forms/settings/AboutForm.h
+++ b/src/forms/settings/AboutForm.h
@@ -18,7 +18,6 @@ public:

    QString getGUIVersion();
    QString getEmbVersion();
-    QString getDataStorePath();

 private slots:
    void openHelpFile();
--- a/src/forms/settings/GeneralForm.cpp
+++ b/src/forms/settings/GeneralForm.cpp
@@ -1,4 +1,4 @@
-#include "generalform.h"
+#include "GeneralForm.h"

 #include <QApplication>
 #include <QPushButton>
@@ -19,6 +19,31 @@
 namespace
 {
    const int MINIMUM_LOCKTIME = 30;
+
+    QString toTimeString(int aSeconds)
+    {
+        if(aSeconds == 0)
+        {
+            return "-";
+        }
+
+        if(aSeconds < 3600)
+        {
+            return QString("%1%2%3 %4%5%6 ").arg(QString::number((aSeconds % 3600) / 600))
+                                            .arg(QString::number((aSeconds % 600) / 60))
+                                            .arg(QObject::tr("Min"))
+                                            .arg(QString::number((aSeconds % 60) / 10))
+                                            .arg(QString::number(aSeconds % 10))
+                                            .arg(QObject::tr("Sec"));
+        }
+
+        return QString("%1%2%3 %4%5%6 ").arg(QString::number(aSeconds / 36000))
+                                            .arg(QString::number((aSeconds / 3600) % 10))
+                                            .arg(QObject::tr("Hour"))
+                                            .arg(QString::number((aSeconds % 3600) / 600))
+                                            .arg(QString::number((aSeconds % 600) / 60))
+                                            .arg(QObject::tr("Min"));
+    }
 }

 GeneralForm::GeneralForm(QWidget* aParent)
@@ -61,14 +86,26 @@ GeneralForm::GeneralForm(QWidget* aParent)
    QLabel* lockScreenLabel = new QLabel(tr("Lock Screen"));
    lockHeaderLayout->addWidget(lockScreenLabel);

-    QLineEdit* lockTime = new ULineEdit(lockHeader);
-    lockTime->setMaximumSize(QSize(300, 32768));
+    ListBox* lockTime = new ListBox(lockHeader);
    lockHeaderLayout->addWidget(lockTime);
-
-    QLabel* ss = new QLabel(tr("s"));
-    lockHeaderLayout->addWidget(ss);
    lockHeaderLayout->addSpacerItem(new QSpacerItem(20, 20, QSizePolicy::Expanding));

+    QWidget* shutdownHeader = new QWidget(this);
+    mLayout->addWidget(shutdownHeader);
+    QHBoxLayout* shutdownHeaderLayout = new QHBoxLayout(shutdownHeader);
+    QToolButton* shutdownButton = new QToolButton(this);
+    shutdownButton->setText(tr("Shut Down"));
+    shutdownHeaderLayout->addWidget(shutdownButton);
+    shutdownHeaderLayout->addSpacerItem(new QSpacerItem(20, 20, QSizePolicy::Expanding));
+    connect(shutdownButton, &QToolButton::clicked, []()
+    {
+        if(DialogManager::Default()->requestAlertMessage(QString(tr("Shut down now ?")), DialogButtonMode::OkAndCancel,tr("Shut Down")) == QDialog::Accepted)
+        {
+            EventCenter::Default()->triggerEvent(GUIEvents::RequestShutdown, nullptr, nullptr);
+        }
+    });
+
+
    //...
    mLayout->addSpacerItem(new QSpacerItem(20, 300, QSizePolicy::Minimum, QSizePolicy::Expanding));

@@ -76,8 +113,7 @@ GeneralForm::GeneralForm(QWidget* aParent)
    btnLan->setText(JsonObject::Instance()->defaultLanguage());
    instName->setText(JsonObject::Instance()->institutionName());
    instAddr->setText(JsonObject::Instance()->institutionAddr());
-    lockTime->setText(JsonObject::Instance()->lockScreenTimeout());
-
+    lockTime->setText(toTimeString(JsonObject::Instance()->lockScreenTimeout().toInt()));
    //connection
    connect(instName, &QLineEdit::textChanged, [=](const QString& str)
        {
@@ -88,14 +124,30 @@ GeneralForm::GeneralForm(QWidget* aParent)
        {
            JsonObject::Instance()->setInstitutionAddr(str);
        });
-    connect(lockTime, &QLineEdit::textChanged, [=](const QString& str)
+    connect(lockTime, &QToolButton::clicked, [=]()
        {
            //take effect
-            int time = str.toInt();
-            if (MINIMUM_LOCKTIME < time)
+            int second = JsonObject::Instance()->lockScreenTimeout().toInt();
+            DialogResult result = DialogManager::Default()->requestSelectTime(second);
+            if (result.ResultCode == false)
            {
-                JsonObject::Instance()->setLockScreenTimeout(str);
-                Locker::getInstance()->setTimer(str.toInt() * 1000);
+                return;
+            }
+            second = result.ResultData.toInt();
+            if(second == 0)
+            {
+                JsonObject::Instance()->setLockScreenTimeout(QString::number(second));
+                lockTime->setText(toTimeString(second));
+                Locker::getInstance()->setIsEnable(false);
+                return;
+            }
+
+            if (MINIMUM_LOCKTIME < second)
+            {
+                JsonObject::Instance()->setLockScreenTimeout(QString::number(second));
+                Locker::getInstance()->setTimer(second * 1000);
+                Locker::getInstance()->setIsEnable(true);
+                lockTime->setText(toTimeString(second));
            }

        });
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -18,7 +18,7 @@
 #include "src/utilities/Locker.h"
 #include "src/utilities/LanguageSwitcher.h"
 #include "utilities/TouchScreenSignalSender.h"
-#include "Keyboard/KeyboardManager.h"
+#include "keyboard/KeyboardManager.h"

 QString loadFontFromFile(QString path)
 {
@@ -50,6 +50,7 @@ int main(int argc, char* argv[])
    qRegisterMetaType<QPair<QString, uint>>("QPair<QString, uint>");
    qRegisterMetaType<Qt::Orientation>("Qt::Orientation");
    qRegisterMetaType<ActionResult>("ActionResult");
+    qRegisterMetaType<QMap<QString,int>>("QMap<QString,int>");

    QString layouts_path = QString(QCoreApplication::applicationDirPath()).append("/layouts");
    qputenv("QT_VIRTUALKEYBOARD_LAYOUT_PATH", QByteArray(layouts_path.toStdString().c_str()));
@@ -86,10 +87,8 @@ int main(int argc, char* argv[])
    DialogManager::Default()->init(&w);
    UserOperationLog::Default()->init();

-    //暂时为了调试关闭锁屏
-    //Locker::getInstance()->setIsEnable(true);
-    //Locker::getInstance()->start();
-    //QObject::connect(TouchScreenSignalSender::getInstance(), SIGNAL(touchScreen()), Locker::getInstance(), SLOT(refreshTimer()));
+    Locker::getInstance()->start();
+    QObject::connect(TouchScreenSignalSender::getInstance(), SIGNAL(touchScreen()), Locker::getInstance(), SLOT(refreshTimer()));
    QList<Qt::GestureType> gestures;
    gestures << Qt::SwipeGesture;
    gestures << Qt::PanGesture;
--- a/src/network/DicomCfgDialog.cpp
+++ b/src/network/DicomCfgDialog.cpp
@@ -2,6 +2,7 @@

 #include <QDialogButtonBox>
 #include <QPushButton>
+#include <QRegularExpressionValidator>

 #include "json/jsonobject.h"
 #include "ui_DicomCfgDialog.h"
@@ -39,22 +40,28 @@ DicomCfgDialog::~DicomCfgDialog()

 void DicomCfgDialog::loadServersInfo()
 {
+    QRegularExpression regex("^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)$");
+    QRegularExpressionValidator* validator = new QRegularExpressionValidator(regex, this);
+
    host serverInfo;
    serverInfo = JsonObject::Instance()->getServer(JsonObject::RECON);
    mUi->recon_AE->setText(serverInfo.ae);
    mUi->recon_IP->setText(serverInfo.ip);
+    mUi->recon_IP->setValidator(validator);
    mUi->recon_Name->setText(serverInfo.name);
    mUi->recon_Port->setText(serverInfo.port);

    serverInfo = JsonObject::Instance()->getServer(JsonObject::PACS);
    mUi->pacs_AE->setText(serverInfo.ae);
    mUi->pacs_IP->setText(serverInfo.ip);
+    mUi->pacs_IP->setValidator(validator);
    mUi->pacs_Name->setText(serverInfo.name);
    mUi->pacs_Port->setText(serverInfo.port);

    serverInfo = JsonObject::Instance()->getServer(JsonObject::WORKLIST);
    mUi->wl_AE->setText(serverInfo.ae);
    mUi->wl_IP->setText(serverInfo.ip);
+    mUi->wl_IP->setValidator(validator);
    mUi->wl_Name->setText(serverInfo.name);
    mUi->wl_Port->setText(serverInfo.port);
 }
--- a/src/network/GetIPDialog.cpp
+++ b/src/network/GetIPDialog.cpp
@@ -4,6 +4,7 @@

 #include "GetIPDialog.h"

+#include <QRegularExpressionValidator>
 #include <QFormLayout>
 #include <QLabel>
 #include "components/ULineEdit.h"
@@ -26,6 +27,12 @@ GetIPDialog::GetIPDialog(QWidget* parent, Qt::WindowFlags f)

    mLabelError->setObjectName(QString::fromUtf8("warn"));
    formLayout->addRow("", mLabelError);
+
+    //set ip input restrictions
+    QRegularExpression regex("^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)$");
+    QRegularExpressionValidator* validator = new QRegularExpressionValidator(regex, this);
+    mIp->setValidator(validator);
+    mMask->setValidator(validator);
 }

 GetIPDialog::~GetIPDialog()
--- a/src/network/GetRouteDialog.cpp
+++ b/src/network/GetRouteDialog.cpp
@@ -4,6 +4,7 @@

 #include "GetRouteDialog.h"

+#include <QRegularExpressionValidator>
 #include <QFormLayout>
 #include <QLabel>
 #include "components/ULineEdit.h"
@@ -24,6 +25,13 @@ GetRouteDialog::GetRouteDialog(QWidget* parent, Qt::WindowFlags f)
    formLayout->addRow(QString(tr("Gateway")), mGateway);
    mLabelError->setObjectName("warn");
    formLayout->addRow("", mLabelError);
+
+    //set ip input restrictions
+    QRegularExpression regex("^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)$");
+    QRegularExpressionValidator* validator = new QRegularExpressionValidator(regex, this);
+    mDestination->setValidator(validator);
+    mNetmask->setValidator(validator);
+    mGateway->setValidator(validator);
 }

 GetRouteDialog::~GetRouteDialog()
--- a/src/network/NetworkCfgDialog.cpp
+++ b/src/network/NetworkCfgDialog.cpp
@@ -2,6 +2,7 @@

 #include <QItemSelectionModel>
 #include <QGraphicsDropShadowEffect>
+#include <QRegularExpression>
 #include <QThread>

 #include "ui_NetworkCfgDialog.h"
@@ -68,6 +69,13 @@ NetworkCfgDialog::NetworkCfgDialog(QWidget* parent)
    mUi->tbl_route->setColumnWidth(2, 230);
    mUi->tbl_route->horizontalHeader()->setFixedHeight(38);

+    //set ip input restrictions
+    QRegularExpression regex("^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)$");
+    QRegularExpressionValidator* validator = new QRegularExpressionValidator(regex, this);
+    mUi->addr_ip->setValidator(validator);
+    mUi->addr_mask->setValidator(validator);
+    mUi->led_gw->setValidator(validator);
+
    connect(mUi->btn_addr_add, &QPushButton::clicked, [=]()
        {
            DialogResult result = DialogManager::Default()->requestEditIpAndNetMask();
--- a/src/recon/ProtocolStructs.h
+++ b/src/recon/ProtocolStructs.h
@@ -0,0 +1,20 @@
+#ifndef __SCAN_H__
+#define __SCAN_H__
+#include <string>
+struct Scan{
+    std::string ScanID;
+    std::string PatientID;
+    std::string ReferenceID;
+    std::string ReferencePath;
+    int Type; 
+};
+
+struct TaskQueryResult
+{
+    std::string ScanID;
+    std::string ReconID;
+    int SeqID ;
+    bool Start ;
+};
+
+#endif // __SCAN_H__
--- a/src/recon/ReconClient.cpp
+++ b/src/recon/ReconClient.cpp
@@ -0,0 +1,139 @@
+#include "ReconClient.h"
+#include "Request.h"
+#include "json/cJSON.h"
+#include <cstddef>
+#include <malloc.h>
+#include <string>
+namespace {
+    const char* CREATE_URL = "/Scan/Create/";
+    const char* QUERY_SCAN_URL = "/Scan/Query/";
+    const char* QUERY_VERSION_URL = "/Version/";
+    const char* QUERY_RECON_URL = "/Task/Query/";
+    const char* QUERY_TRANSFER_URL = "/Transfer/Query/";
+}
+namespace Recon {
+
+    ReconClient::ReconClient(std::string aCerPath, std::string aKeyPath)
+    {
+        Req::Request::Init();
+        mHeaders["Content-Type"] = "application/json";
+        mRequest.setClientCertificate(aCerPath,aKeyPath);
+    }
+
+    ReconClient::~ReconClient()
+    {
+        Req::Request::Dispose();
+    }
+    
+    void ReconClient::SetHost(const std::string& aHost)
+    {
+        mHost = aHost;
+    }
+    
+    RequestResult ReconClient::Create( const Scan& aScan)
+    {
+        cJSON * obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "ScanID", aScan.ScanID.c_str());
+        cJSON_AddStringToObject(obj, "PatientID", aScan.PatientID.c_str());
+        cJSON_AddStringToObject(obj, "ReferencePath", aScan.ReferencePath.c_str());
+        if (!aScan.ReferencePath.empty()){
+            cJSON_AddStringToObject(obj, "ReferenceID", aScan.ReferenceID.c_str());
+        }
+        cJSON_AddNumberToObject(obj, "Type", aScan.Type);
+        char* str = cJSON_Print(obj);
+        cJSON_Delete(obj);
+        std::string content;
+        content.append(str);
+        free(str);
+        auto resp = mRequest.post(mHost+CREATE_URL,content,mHeaders);
+        if (resp.httpCode() == 201){
+            return RequestResult::Success();
+        }
+        else{
+            mErrorMessage = resp.getContent();
+            return RequestResult::Fail(mErrorMessage);
+        }
+    }
+    
+    RequestResult ReconClient::QueryScan(const std::string& aScanID, int& state)
+    {
+        cJSON * obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "ScanID", aScanID.data());
+        char* str = cJSON_Print(obj);
+        cJSON_Delete(obj);
+        std::string content;
+        content.append(str);
+        free(str);
+        auto resp = mRequest.post(mHost+QUERY_SCAN_URL,content,mHeaders);
+        if (resp.httpCode() == 200){
+            cJSON * scans = cJSON_Parse(resp.getContent().data());
+            int size = cJSON_GetArraySize(scans);
+            if (size == 1){
+                cJSON * scaninf = cJSON_GetArrayItem(scans, 0);
+                if (scaninf!=NULL){
+                    cJSON * value = cJSON_GetObjectItem(scaninf, "State");
+                    state = value->valueint;
+                    cJSON_Delete(scans);
+                    return RequestResult::Success();
+                }
+            }
+            mErrorMessage ="get null from server";
+            return RequestResult::Fail(mErrorMessage);
+        }
+        else{
+            mErrorMessage = resp.getContent();
+            return RequestResult::Fail(mErrorMessage);
+        }
+    }
+    
+    RequestResult ReconClient::QueryReconID(const std::string& aScanID, std::string& aReconID)
+    {
+        cJSON * obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "ScanID", aScanID.data());
+        char* str = cJSON_Print(obj);
+        cJSON_Delete(obj);
+        std::string content;
+        content.append(str);
+        free(str);
+        auto resp = mRequest.post(mHost+QUERY_RECON_URL,content,mHeaders);
+        if (resp.httpCode() == 204){
+            return RequestResult::Success();
+        }
+        else if (resp.httpCode() == 200){
+                        
+            aReconID = resp.getContent();
+            return RequestResult::Success(aReconID);
+        }
+        else{
+            mErrorMessage = resp.getContent();
+            return RequestResult::Fail(mErrorMessage);
+
+        }
+    }
+    
+    RequestResult ReconClient::QueryReconTask(const std::string& aReconID, TaskQueryResult& aTask)
+    {
+        cJSON * obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "ReconID", aReconID.data());
+        char* str = cJSON_Print(obj);
+        cJSON_Delete(obj);
+        std::string content;
+        content.append(str);
+        free(str);
+        auto resp = mRequest.post(mHost+QUERY_RECON_URL,content,mHeaders);
+        if (resp.httpCode() == 200){
+            cJSON * task = cJSON_Parse(resp.getContent().data());
+            aTask.ReconID = cJSON_GetObjectItem(task, "ReconID")->valuestring;
+            aTask.ScanID= cJSON_GetObjectItem(task, "ScanID")->valuestring;
+            aTask.Start = cJSON_GetObjectItem(task, "Start")->valueint!=0;
+            aTask.SeqID = cJSON_GetObjectItem(task, "SeqID")->valueint;
+            cJSON_Delete(task);
+            return RequestResult::Success();
+        }
+        else{
+            mErrorMessage = resp.getContent();
+            return RequestResult::Fail(mErrorMessage);
+        }
+    }
+    
+}
--- a/src/recon/ReconClient.h
+++ b/src/recon/ReconClient.h
@@ -0,0 +1,31 @@
+#ifndef __RECONCLIENT_H__
+#define __RECONCLIENT_H__
+#include <string>
+#include "Request.h"
+#include "RequestResult.h"
+#include "ProtocolStructs.h"
+namespace Recon {
+    class ReconClient
+    {
+        public:
+            ReconClient(std::string aCerPath, std::string aKeyPath);
+            ~ReconClient();
+            void SetHost(const std::string& aHost);
+            RequestResult Create(const Scan& aScan);
+            RequestResult QueryScan(const std::string& aScanID, int& state);
+            RequestResult QueryReconID(const std::string& aScanID, std::string& aReconID);
+            RequestResult QueryReconTask(const std::string& aReconID, TaskQueryResult& aTask);
+            RequestResult QueryVersion();
+
+        private:
+            std::string mVersionContent;
+            std::string mHost;
+            std::string mErrorMessage;
+            Req::Request mRequest;
+            std::unordered_map<std::string, std::string> mHeaders;
+    };
+};
+
+
+
+#endif // __RECONCLIENT_H__
--- a/src/recon/ReconManager.cpp
+++ b/src/recon/ReconManager.cpp
@@ -0,0 +1,93 @@
+#include "ReconManager.h"
+#include "ReconClient.h"
+#include "json/jsonobject.h"
+
+#include "QDebug"
+
+namespace
+{
+    const std::string CRT_FILE = "./cfgs/client.crt";
+    const std::string KEY_FILE = "./cfgs/client.key";
+
+    std::string toReconServerAddress(const QString& aIp, const QString& aPort)
+    {
+        return ("https://" + aIp + ":" + aPort).toStdString();
+    }
+}
+
+ReconManager* ReconManager::getInstance()
+{
+    static ReconManager instance;
+    return &instance;
+}
+
+ReconManager::ReconManager(QObject* aParent)
+    : QObject(aParent)
+    , mReconClient(new Recon::ReconClient(CRT_FILE, KEY_FILE))
+{
+    init();
+}
+
+ReconManager::~ReconManager()
+{
+    delete mReconClient;
+}
+
+void ReconManager::init()
+{
+    host reconServerInfo = JsonObject::Instance()->getServer(JsonObject::RECON);
+    mReconClient->SetHost(toReconServerAddress(reconServerInfo.ip , reconServerInfo.port));
+}
+
+void ReconManager::setReconIpAndPort(const QString& aIp, const QString& aPort)
+{
+    mReconClient->SetHost(toReconServerAddress(aIp, aPort));
+}
+
+void ReconManager::createEmptyScan(const QString& aScanID, const QString& aPath)
+{
+    Scan empty{aScanID.toStdString(), "", "", aPath.toStdString(),0};
+    auto result = mReconClient->Create(empty);
+    if(result.good())
+    {
+        qDebug()<< "create empty scan success, scanID: "<< aScanID;
+        emit createEmptyScanResponsed(true, aScanID);
+    }
+    else
+    {
+        qDebug()<< "Create empty scan fail by %s\n" << result.error().data();
+        emit createEmptyScanResponsed(false, aScanID, result.error().data());
+    }
+}
+
+void ReconManager::createScan(const QString& aScanID, const QString& aPatientID, const QString& aReferenceID, const QString& aPath)
+{
+    Scan scan{aScanID.toStdString(), aPatientID.toStdString(), aReferenceID.toStdString(), aPath.toStdString(), 1};
+    auto response = mReconClient->Create(scan);
+    if(response.good())
+    {
+        qDebug()<< "create scan success, scanID: "<< aScanID;
+        emit createScanResponsed(true, aScanID);
+    }
+    else
+    {
+        qDebug()<< "Create scan fail by " << response.error().data();
+        emit createScanResponsed(false, aScanID, response.error().data());
+    }
+}
+
+void ReconManager::queryReconStatus(const QStringList& aScanIDs)
+{
+    QMap<QString, int> result;
+    for(QString scanID : aScanIDs)
+    {
+        int state;
+        auto response = mReconClient->QueryScan(scanID.toStdString(), state);
+        if(response.bad())
+        {
+            break;
+        }
+        result.insert(scanID, state);
+    }
+    emit queryReconStateResponsed(result);
+}
--- a/src/recon/ReconManager.h
+++ b/src/recon/ReconManager.h
@@ -0,0 +1,39 @@
+#ifndef RECONMANAGER_H
+#define RECONMANAGER_H
+
+#include <QObject>
+
+namespace Recon
+{
+    class ReconClient;
+}
+
+class ReconManager : public QObject
+{
+    Q_OBJECT
+public:
+    static ReconManager* getInstance();
+    explicit ReconManager(QObject* aParent = nullptr);
+    ~ReconManager();
+
+public:
+    void setReconIpAndPort(const QString& aIp, const QString& aPort);
+
+public slots:
+    void createEmptyScan(const QString& aScanID, const QString& aPath);
+    void createScan(const QString& aScanID, const QString& aPatientID, const QString& aReferenceID, const QString& aPath);
+    void queryReconStatus(const QStringList& aScanIDs);
+
+private:
+    void init();
+
+signals:
+    void createEmptyScanResponsed(bool aResult, const QString& aScanID, const QString& aMessage = "");
+    void createScanResponsed(bool aResult,  const QString& aScanID, const QString& aMessage = "");
+    void queryReconStateResponsed(const QMap<QString, int> aResult);
+
+private:
+    Recon::ReconClient* mReconClient;
+};
+
+#endif // RECONMANAGER_H
--- a/src/recon/RequestResult.cpp
+++ b/src/recon/RequestResult.cpp
@@ -0,0 +1,46 @@
+#include "RequestResult.h"
+
+void RequestResult::becomeGood(const std::string& aMessage)
+{
+    mSuccess = true;
+    mMessage = aMessage;
+}
+
+void RequestResult::becomeBad(const std::string& aMessage)
+{
+    mSuccess = false;
+    mError = aMessage;
+}
+
+bool RequestResult::good()
+{
+    return mSuccess;
+}
+
+bool RequestResult::bad()
+{
+    return !mSuccess;
+}
+
+std::string RequestResult::error()
+{
+    return mError;
+}
+
+std::string RequestResult::message()
+{
+    return mMessage;
+}
+RequestResult RequestResult::Success(const std::string& aMessage)
+{
+    RequestResult r;
+    r.becomeGood(aMessage);
+    return r;
+}
+
+RequestResult RequestResult::Fail(const std::string& aMessage)
+{
+    RequestResult r;
+    r.becomeBad(aMessage);
+    return r;
+}
--- a/src/recon/RequestResult.h
+++ b/src/recon/RequestResult.h
@@ -0,0 +1,33 @@
+#ifndef __REQUESTRESULT_H__
+#define __REQUESTRESULT_H__
+#include <string>
+class RequestResult
+{
+public:
+    static RequestResult Success(const std::string& aMessage= std::string());
+    static RequestResult Fail(const std::string& aMessage);
+
+    RequestResult()=default;
+    RequestResult(RequestResult &&) = default;
+    RequestResult(const RequestResult &) = default;
+    RequestResult &operator=(RequestResult &&) = default;
+    RequestResult &operator=(const RequestResult &) = default;
+    ~RequestResult()=default;
+
+    bool good();
+    bool bad();
+    std::string message();
+    std::string error();
+
+private:
+
+    std::string mMessage;
+    std::string mError;
+    bool mSuccess;
+    void becomeGood(const std::string& aMessage );
+    void becomeBad(const std::string& aMessage);
+
+};
+
+
+#endif // __REQUESTRESULT_H__
--- a/src/screensaver/ScreenSaverWindow.cpp
+++ b/src/screensaver/ScreenSaverWindow.cpp
@@ -13,6 +13,7 @@

 #include "json/jsonobject.h"
 #include "utilities/Locker.h"
+#include "event/EventCenter.h"

 namespace
 {
@@ -71,6 +72,7 @@ void ScreenSaverWindow::initializeMultimediaList()
 void ScreenSaverWindow::mousePressEvent(QMouseEvent* aEvent)
 {
    stop();
+    EventCenter::Default()->triggerEvent(GUIEvents::RequestLogin, nullptr, nullptr);
    QWidget::mousePressEvent(aEvent);
 }

@@ -142,5 +144,5 @@ void ScreenSaverWindow::handleVideoStatusChanged(QMediaPlayer::MediaStatus aStat

 void ScreenSaverWindow::startLocker()
 {
-    Locker::getInstance()->setIsEnable(true);
+    Locker::getInstance()->start();
 }
--- a/src/utilities/Locker.cpp
+++ b/src/utilities/Locker.cpp
@@ -17,6 +17,11 @@ Locker::Locker()
    , mCounter(JsonObject::Instance()->lockerCount())
    , mIsEnable(false)
 {
+    if(mCounter > 0)
+    {
+        setIsEnable(true);
+    }
+    mScreenTimer->setSingleShot(true);
    connect(mScreenTimer, SIGNAL(timeout()), this, SLOT(coverScreen()));
 }

@@ -28,6 +33,7 @@ void Locker::start()
 {
    if (mIsEnable)
    {
+        mScreenTimer->stop();
        mScreenTimer->start(mCounter);
    }
 }
@@ -54,18 +60,12 @@ void Locker::coverScreen()
    else
    {
        mScreenTimer->stop();
-        //EventCenter::Default()->triggerEvent(GUIEvents::RequestLogin, nullptr, nullptr);
        EventCenter::Default()->triggerEvent(GUIEvents::RequestScreenSaver, nullptr, nullptr);
    }
 }
 void Locker::setTimer(int aInterval)
 {
    mCounter = aInterval;
-    mScreenTimer->stop();
-    if (mIsEnable)
-    {
-        mScreenTimer->start(mCounter);
-    }
 }
 void Locker::refreshTimer()
 {
--- a/src/windows/LoginDialog.cpp
+++ b/src/windows/LoginDialog.cpp
@@ -22,6 +22,7 @@ LoginDialog::LoginDialog(QWidget* aParent)
    , mPasswordEdit(new ULineEdit(mDialogFrame))
    , mLoginButton(nullptr)
    , mErrorMessage(new QLabel(this))
+    , mIsRunning(false)
 {
    initializeAllWidget();
    setWindowFlags(windowFlags() | Qt::Window | Qt::FramelessWindowHint | Qt::WindowSystemMenuHint| Qt::BypassWindowManagerHint);
@@ -133,9 +134,22 @@ void LoginDialog::doLogin()
    }
 }

-void LoginDialog::accept() {
+void LoginDialog::accept()
+{
    QDialog::accept();
    clearInputData();
+    mIsRunning = false;
+}
+
+int LoginDialog::exec()
+{
+    mIsRunning = true;
+    return QDialog::exec();
+}
+
+bool LoginDialog::isRunning()
+{
+    return mIsRunning;
 }


--- a/src/windows/LoginDialog.h
+++ b/src/windows/LoginDialog.h
@@ -21,6 +21,8 @@ public:

    void accept() override;
    void clearInputData();
+    int exec() override;
+    bool isRunning();

 signals:
    void sigUserLoginSuccessful(const QString& aUserCode);
@@ -46,6 +48,7 @@ private:
    ULineEdit* mPasswordEdit;
    QToolButton* mLoginButton;
    QLabel* mErrorMessage;
+    bool mIsRunning;
 };

 #endif // LOGINDIALOG_H
--- a/thirdParty/Req/pub/cmake/ReqConfig.cmake
+++ b/thirdParty/Req/pub/cmake/ReqConfig.cmake
@@ -0,0 +1,5 @@
+get_filename_component(_DIR "${CMAKE_CURRENT_LIST_DIR}" PATH)
+set(Req_INCLUDES_DIRS "${_DIR}/include")
+add_library(Req SHARED IMPORTED)
+set_target_properties(Req PROPERTIES IMPORTED_LOCATION "${_DIR}/lib/libReq.so")
+set(Req_FOUND ON)
--- a/thirdParty/Req/pub/include/Request.h
+++ b/thirdParty/Req/pub/include/Request.h
@@ -0,0 +1,32 @@
+#ifndef __REQUEST_H__
+#define __REQUEST_H__
+#include <string>
+#include <unordered_map>
+
+#include "Response.h"
+namespace Req {
+    class Request {
+    public:
+        static void Init();
+        static void Dispose();
+        Request();
+        Request(Request &&) = delete;
+        Request(const Request &) = delete;
+        Request &operator=(Request &&) = delete;
+        Request &operator=(const Request &) = delete;
+        ~Request();
+        void setClientCertificate(const std::string &cerPath, const std::string &keyPath);
+        void setVerbose(bool verbose);
+        Response post(const std::string& url, const std::string &body = std::string(),
+                        const std::unordered_map<std::string, std::string>& headers =
+                            std::unordered_map<std::string, std::string>());
+
+    private:
+        void* mCurl;
+        void* mHeaders;
+        std::string mCert;
+        std::string mKey;
+        bool mVerbose;
+    };
+}
+#endif // __REQUEST_H__
--- a/thirdParty/Req/pub/include/Response.h
+++ b/thirdParty/Req/pub/include/Response.h
@@ -0,0 +1,23 @@
+#ifndef __RESPONSE_H__
+#define __RESPONSE_H__
+#include "string"
+#include <string>
+namespace Req {
+    class Response
+    {
+    public:
+        Response();
+        Response(Response &&) = default;
+        Response(const Response &) = default;
+        Response &operator=(Response &&) = delete;
+        Response &operator=(const Response &) = delete;
+        ~Response();
+        long httpCode();
+        void setHttpCode(long code);
+        std::string& getContent();
+    private:
+        long mHttpCode = 404;
+        std::string mContent;
+    };
+};
+#endif // __RESPONSE_H__
--- a/thirdParty/Req/pub/lib/libReq.so
+++ b/thirdParty/Req/pub/lib/libReq.so