Merge branch '0_0_3_st1' into fix_sogouProcess_003st1

CMakeLists.txt

@@ -92,7 +92,7 @@ endif($ENV{PIPELINE_BUILD_ID})
 # stable Îȶ¨°æ±¾
 
 #Set the project version
-set(RAW_VERSION_STRING "0.2.4-beta1")
+set(RAW_VERSION_STRING "0.2.5-beta1")
 string(STRIP ${RAW_VERSION_STRING} RAW_VERSION_STRING)
 
 set(VERSION_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)")

ChangeLog.in

@@ -2,6 +2,26 @@
 
 *Last Built Day: @BUILD_DATE_STRING@*
 
+## V0.2.6
+
+* [BugFix] Http组件 Get 请求报 500 问题修复
+* [BugFix][PinPad] 告警码校准：取消输入时历史接口异常不抛送告警码
+* 添加安装耗时时长记录，安装版本记录以及安装时间戳，支持终端信息获取URL地址可编辑
+* [Config] Alarm 启动选项提前，并启动级别调为 0
+
+## V0.2.5
+
+* [LocalMaintainDesktop] 添加重启浏览器的操作（针对业务卡住情况，谨慎使用）
+* [CenterSettings] 优化集中配置下载提示内容
+* [Healthmanager] 添加总行新模式升级的标识
+* [ResourceWatcher] CPU实时获取数据校准
+* 坐席回显帧率支持通过集中配置控制
+* 网络断连提示优化
+* 硬件实体错误码等信息告警同步
+* CMBPrint 支持运通卡卡bin（采用源码编译）
+* CPU实时获取监控校准
+* [BugFix] 修复准入不会每天自动更新密钥的问题
+
 ## V0.2.4
 
 * [ResourceWatcher][BugFix] 添加屏幕分辨率的告警上传，后后续排查搜狗输入法位置显示异常的问题做参考

DevAdapter/CMakeLists.txt

@@ -139,7 +139,7 @@ message(STATUS "vendor log library: ${VENDOR_LOG_LIB_NAME}")
 
 # 通过conan的方式管理厂商库
 if(DEVADAPTER_USING_CONAN)
-    set(KEBA_CONAN_LIB_NAME keba/2021.1020.01@LR04.02_VendorLib/testing)
+    set(KEBA_CONAN_LIB_NAME keba/2022.0425.01@LR04.02_VendorLib/testing)
 	set(NANTIAN_CONAN_LIB_NAME nantian/2022.0224.01@LR04.02_VendorLib/testing)
 	set(GRG_CONAN_LIB_NAME grg/2022.0310.01@LR04.02_VendorLib/testing)
 	set(CW_CONAN_LIB_NAME cw/2021.0927.01@LR04.02_VendorLib/testing)

DevAdapter/keba/CardIssuer.keba.1.1/ACT-Sankyo_DevCtrl.cpp

@@ -790,6 +790,10 @@ WORD CACT_Sankyo_DevCtrl::CheckReleaseIC()
 	return wResult;
 }
 
+
+
+
+/*
 WORD CACT_Sankyo_DevCtrl::GetErrorDetail(LPDevErrDetail lpErrDetail)
 {
 	WORD wResult = CRT_SUCCESS;
@@ -968,12 +972,12 @@ WORD CACT_Sankyo_DevCtrl::GetWarningDetail(LPDevErrDetail lpErrDetail, WORD wRes
 	switch(wRes)
 	{
 	case EXWORDHL(CRT_RES_CMD_UNDEFINED):
-		memcpy(lpErrDetail->szErrCode, "00", strlen("00"));
-		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_UNDEFINED", strlen("CRT_RES_CMD_UNDEFINED"));
+        memcpy(lpErrDetail->szErrCode, "00", strlen("00"));
+        memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_UNDEFINED", strlen("CRT_RES_CMD_UNDEFINED"));
 		break;
 	case EXWORDHL(CRT_RES_CMD_PARAM_ERROR):
-		memcpy(lpErrDetail->szErrCode, "01", strlen("01"));
-		memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_PARAM_ERROR", strlen("CRT_RES_CMD_PARAM_ERROR"));
+        memcpy(lpErrDetail->szErrCode, "01", strlen("01"));
+        memcpy(&lpErrDetail->szErrDetail[wOffSet], "CRT_RES_CMD_PARAM_ERROR", strlen("CRT_RES_CMD_PARAM_ERROR"));
 		break;
 	case EXWORDHL(CRT_RES_CMD_UNABLE_EXECUTE):
 		memcpy(lpErrDetail->szErrCode, "02", strlen("02"));
@@ -1089,6 +1093,372 @@ WORD CACT_Sankyo_DevCtrl::GetWarningDetail(LPDevErrDetail lpErrDetail, WORD wRes
 
 	return CRT_SUCCESS;
 }
+*/
+
+
+WORD CACT_Sankyo_DevCtrl::GetErrorDetail(LPDevErrDetail lpErrDetail)
+{
+    WORD wResult = CRT_SUCCESS;
+    WORD wErrCode = 0;
+    WORD wOffSet = 0;
+    CHAR szDetail[] = "HWERROR: ";
+    wOffSet = strlen(szDetail);
+    memset(lpErrDetail->szErrDetail, 0x00, sizeof(lpErrDetail->szErrDetail));
+    memcpy(lpErrDetail->szErrDetail, szDetail, wOffSet);
+    REPLY reply;
+
+    wResult = GetDevErrCode(&reply);
+    if (wResult == CRT_OFFLINE)
+    {
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_OFFLINE;
+        strcpy(lpErrDetail->szErrCode, "FF");
+        strcpy(lpErrDetail->szErrDetail, "发卡模块离线!");
+        return wResult;
+    }
+
+    if (reply.replyType == PositiveReply)
+    {
+        lpErrDetail->iErrCode = DEP_SUCCESS;
+        strcpy(lpErrDetail->szErrCode, "00");
+        strcpy(lpErrDetail->szErrDetail, "成功!");
+        return CRT_SUCCESS;
+    }
+
+    wErrCode = m_pDevCtrlImpl->GetErrResValue(reply.message.negativeReply);
+
+    switch(wErrCode)
+    {
+    case EXWORDHL(CRT_RES_CARD_JAM):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_JAM;
+        strcpy(lpErrDetail->szErrCode, "10");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡介质堵塞，CRT_RES_CARD_JAM");
+        break;
+    case EXWORDHL(CRT_RES_SHUTTER_ABNORMAL):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_SHUTTER_FAIL;
+        strcpy(lpErrDetail->szErrCode, "11");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "闸门错误，CRT_RES_SHUTTER_ABNORMAL");
+        break;
+    case EXWORDHL(CRT_RES_SENSOR_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "12");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "传感器错误，CRT_RES_SENSOR_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_CARD_TOO_LONG):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEDIA_ERROR;
+        strcpy(lpErrDetail->szErrCode, "13");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡太长，CRT_RES_CARD_TOO_LONG");
+        break;
+    case EXWORDHL(CRT_RES_CARD_TOO_SHORT):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEDIA_ERROR;
+        strcpy(lpErrDetail->szErrCode, "14");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡太短，CRT_RES_CARD_TOO_SHORT");
+        break;
+    case EXWORDHL(CRT_RES_FRAM_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
+        strcpy(lpErrDetail->szErrCode, "15");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "未知错误，CRT_RES_FRAM_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_CARD_POS_MOVE):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "16");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡被强行移动，CRT_RES_CARD_POS_MOVE");
+        break;
+    case EXWORDHL(CRT_RES_CARD_JAM_ON_REINTAKE):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
+        strcpy(lpErrDetail->szErrCode, "17");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "再次吸卡时堵塞，CRT_RES_CARD_JAM_ON_REINTAKE");
+        break;
+    case EXWORDHL(CRT_RES_SW1_SW2_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_INVALID_DATA;
+        strcpy(lpErrDetail->szErrCode, "18");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "SW1SW2数据错误，CRT_RES_SW1_SW2_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_CARD_NOT_INTAKE_FROM_REAR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "19");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡未从后部吸入，CRT_RES_CARD_NOT_INTAKE_FROM_REAR");
+        break;
+    case EXWORDHL(CRT_RES_POWER_OFF):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
+        strcpy(lpErrDetail->szErrCode, "30");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "已掉电，CRT_RES_POWER_OFF");
+        break;
+    case EXWORDHL(CRT_RES_DSR_OFF):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_DEV_UNKNOWN;
+        strcpy(lpErrDetail->szErrCode, "31");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "未知错误，CRT_RES_DSR_OFF");
+        break;
+    case EXWORDHL(CRT_RES_CARD_TAKEN_WHEN_RETAIN):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "40");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "吞卡时卡被拿走，CRT_RES_CARD_TAKEN_WHEN_RETAIN");
+        break;
+    case EXWORDHL(CRT_RES_IC_CONTACTOR_SENSOR_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "41");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC接触器传感器错误，CRT_RES_IC_CONTACTOR_SENSOR_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_NOT_REMOVE_TO_IC_POS):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "43");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡片未移动到正确位置，CRT_RES_NOT_REMOVE_TO_IC_POS");
+        break;
+    case EXWORDHL(CRT_RES_FORCE_EJECT):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "45");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "卡片被强制拔出，CRT_RES_FORCE_EJECT");
+        break;
+    case EXWORDHL(CRT_RES_FRONT_CARD_TAKEN_TIMEOUT):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "46");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "前出卡口取卡超时，CRT_RES_FRONT_CARD_TAKEN_TIMEOUT");
+        break;
+    case EXWORDHL(CRT_RES_RETAIN_COUNT_OVERFLOW):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "50");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "回收张数超限，CRT_RES_RETAIN_COUNT_OVERFLOW");
+        break;
+    case EXWORDHL(CRT_RES_MOTOR_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "51");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "电机故障，CRT_RES_MOTOR_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_READ_DIGIT_DECODE_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_INVALID_DATA;
+        strcpy(lpErrDetail->szErrCode, "53");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "读取时数据解码失败，CRT_RES_READ_DIGIT_DECODE_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_HOOK_REMOVE_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "54");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子移除故障，CRT_RES_HOOK_REMOVE_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_HOOK_SET_ALREADY):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "55");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子已经落下，CRT_RES_HOOK_SET_ALREADY");
+        break;
+    case EXWORDHL(CRT_RES_CHIP_DETECT_SENSOR_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "56");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "芯片侦测传感器故障，CRT_RES_CHIP_DETECT_SENSOR_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_HOOK_MOVING):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "58");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子移动中，CRT_RES_HOOK_MOVING");
+        break;
+    case EXWORDHL(CRT_RES_ESU_CHU_COMM_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "76");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "ESU、CHU通讯错误，CRT_RES_ESU_CHU_COMM_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_ESU_ERROR_OR_NO_CONNECT):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "95");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "ESU故障或未连接，CRT_RES_ESU_ERROR_OR_NO_CONNECT");
+        break;
+    case EXWORDHL(CRT_RES_ESU_OVERCURRENT):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "99");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "ESU电流过载，CRT_RES_ESU_OVERCURRENT");
+        break;
+    case EXWORDHL(CRT_RES_NOT_RECEIVE_INITIAL_CMD):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "B0");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "未收到初始化命令，CRT_RES_NOT_RECEIVE_INITIAL_CMD");
+        break;
+    case EXWORDHL(ACT_RES_CARDREADER_COMM_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "A2");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "读卡器通讯错误，ACT_RES_CARDREADER_COMM_ERROR");
+        break;
+    case EXWORDHL(ACT_RES_JAM_OR_SENSOR_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "A5");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "阻塞或传感器故障，ACT_RES_JAM_OR_SENSOR_ERROR");
+        break;
+    case EXWORDHL(ACT_RES_HOOK_NOT_AT_POS):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "A6");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "钩子未归位，ACT_RES_HOOK_NOT_AT_POS");
+        break;
+    case EXWORDHL(ACT_RES_MOTOR_JAM_OR_OVERLOAD):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_HWERR;
+        strcpy(lpErrDetail->szErrCode, "A7");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "电机阻塞或过载，ACT_RES_MOTOR_JAM_OR_OVERLOAD");
+        break;
+    default:
+        break;
+    }
+
+    return CRT_SUCCESS;
+}
+
+WORD CACT_Sankyo_DevCtrl::GetWarningDetail(LPDevErrDetail lpErrDetail, WORD wRes)
+{
+    WORD wResult = CRT_SUCCESS;
+    WORD wErrCode = 0;
+    WORD wOffSet = 0;
+    CHAR szDetail[] = "Warning: ";
+    wOffSet = strlen(szDetail);
+    memset(lpErrDetail->szErrDetail, 0x00, sizeof(lpErrDetail->szErrDetail));
+    memcpy(lpErrDetail->szErrDetail, szDetail, wOffSet);
+
+    switch(wRes)
+    {
+    case EXWORDHL(CRT_RES_CMD_UNDEFINED):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "00");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令未定义，CRT_RES_CMD_UNDEFINED");
+        break;
+    case EXWORDHL(CRT_RES_CMD_PARAM_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "01");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令参数错误，CRT_RES_CMD_PARAM_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_CMD_UNABLE_EXECUTE):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "02");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令无法执行，CRT_RES_CMD_UNABLE_EXECUTE");
+        break;
+    case EXWORDHL(CRT_RES_CMD_NOT_SUPPORT):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "03");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令不支持，CRT_RES_CMD_NOT_SUPPORT");
+        break;
+    case EXWORDHL(CRT_RES_CMD_RES_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "04");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令返回错误，CRT_RES_CMD_RES_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_CMD_IC_NOT_RELEASE):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "05");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令执行时IC卡未释放，CRT_RES_CMD_IC_NOT_RELEASE");
+        break;
+    case EXWORDHL(CRT_RES_CMD_KEY_NOT_FOUND):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_PARAM_ERR;
+        strcpy(lpErrDetail->szErrCode, "06");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "命令Key未找到，CRT_RES_CMD_KEY_NOT_FOUND");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_PARITY_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "20");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_PARITY_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "21");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡读取失败，CRT_RES_MAG_READ_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_WRITE_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "22");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡写入失败，CRT_RES_MAG_WRITE_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_NO_DATA):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "23");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_NO_DATA");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "24");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_NO_TRACKS_OR_BLANK");
+        break;
+    case EXWORDHL(CRT_RES_MAG_WRITE_QUALITY_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "25");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_WRITE_QUALITY_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_SS_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "26");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_SS_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_ES_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "27");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_ES_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_READ_LRC_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "28");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_READ_LRC_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_MAG_WRITE_CHECK_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_MEIDA_INVALID;
+        strcpy(lpErrDetail->szErrCode, "29");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "磁条卡介质无效，CRT_RES_MAG_WRITE_CHECK_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_VCC_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "60");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_VCC_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_ATR_COMM_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "61");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_ATR_COMM_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_ATR_INVALID):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "62");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_ATR_INVALID");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "63");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_COMM_NO_RESPONSE");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_COMM_ERROR):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "64");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_COMM_ERROR");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_NO_ACTIVATE):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "65");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_NO_ACTIVATE");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "66");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_NOT_SUPP_NO_EMV");
+        break;
+    case EXWORDHL(CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_IC_INVALID;
+        strcpy(lpErrDetail->szErrCode, "69");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "IC无效，CRT_RES_IC_OR_SAM_NOT_SUPP_ONLY_EMV");
+        break;
+    case EXWORDHL(ACT_RES_CARD_BOX_EMPTY):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "A0");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "发卡箱为空，ACT_RES_CARD_BOX_EMPTY");
+        break;
+    case EXWORDHL(ACT_RES_RETAIN_BIN_FULL):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_USER_ERROR;
+        strcpy(lpErrDetail->szErrCode, "AC");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "回收盒已满，ACT_RES_RETAIN_BIN_FULL");
+        break;
+    case EXWORDHL(ACT_RES_INVALID_DATA):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_INVALID_DATA;
+        strcpy(lpErrDetail->szErrCode, "C0");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "无效数据，ACT_RES_INVALID_DATA");
+        break;
+    case EXWORDHL(ACT_RES_NO_MEDIA):
+        lpErrDetail->iErrCode = DEP_NO_E_CARDISSUER_NO_MEDIA;
+        strcpy(lpErrDetail->szErrCode, "C1");
+        strcpy(&lpErrDetail->szErrDetail[wOffSet], "没有介质，ACT_RES_NO_MEDIA");
+        break;
+    default:
+        break;
+    }
+
+    return CRT_SUCCESS;
+}
+
 
 WORD CACT_Sankyo_DevCtrl::GetCRTErrCode(WORD wValue)
 {

DevAdapter/keba/CardIssuer.keba.1.1/ACT-Sankyo_DevDefine.h

@@ -174,6 +174,7 @@ typedef struct tag_CardReaderCardStatus
 
 typedef struct tag_DevErrDetail
 {
+    int iErrCode;
 	CHAR szErrCode[CARD_READER_ERRCODE_BUFF];
 	CHAR szErrDetail[CARD_READER_ERRDETAIL_BUFF];
 }DevErrDetail, *LPDevErrDetail;

DevAdapter/keba/CardIssuer.keba.1.1/CMakeLists.txt

@@ -3,6 +3,9 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
+
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
     set(CMAKE_CXX_FLAGS "-std=c++11")
@@ -43,6 +46,9 @@ target_link_libraries(${MODULE_FULL_NAME} ${VENDOR_LOG_LIB_NAME})
 #链接keba依赖的日志库以及锁库
 target_link_libraries(${MODULE_FULL_NAME} Common.keba)
 
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
+
 #设置动态库输出路径:/data/home/keba/DevAdapter/cmbsz/lib/gcc_aarch64或者gcc_x64
 
 SET(LIBRARY_OUTPUT_PATH ${VENDOR_CURRENT_LIB_DIR})

DevAdapter/keba/CardIssuer.keba.1.1/CardIssuerClassImpl_ACT-Sankyo.cpp

@@ -1,4 +1,4 @@
-// CardIssuer.keba.4.1.cpp : ???? DLL ??ó??????????????
+// CardIssuer.keba.4.1.cpp : ???? DLL ??贸??????????????
 //
 
 #include "stdafx.h"
@@ -21,8 +21,7 @@ CardIssuerClassImpl::CardIssuerClassImpl():
     int nRet = Error_Succeed;
     m_pACT_Sankyo_DevCtrl = new CACT_Sankyo_DevCtrl();
     memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
-
-    LogM("CardIssuer,Ver:202106101912");
+    //LogM("CardIssuer,Ver:202106101912");
 }
 
 CardIssuerClassImpl::~CardIssuerClassImpl()
@@ -91,6 +90,12 @@ ErrorCodeEnum CardIssuerClassImpl::DevClose()
 ErrorCodeEnum CardIssuerClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
 {
     LOG_FUNCTION();
+
+    devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
+    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    memcpy(devErrInfo.szErrMsg, m_szErrMsg, devErrInfo.dwErrMsgLen<MAX_DEV_ERROR_MSG_LEN? devErrInfo.dwErrMsgLen:MAX_DEV_ERROR_MSG_LEN);
+    return Error_Succeed;
+    /*
     devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
     memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
     devErrInfo.dwErrMsgLen = (m_wDevErrCode << 16);
@@ -98,6 +103,7 @@ ErrorCodeEnum CardIssuerClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
     devErrInfo.dwErrMsgLen += (strlen(devErrInfo.szErrMsg) & 0x0000FFFF);
     LogM("GetLastErr->szErrMsg=%s,line=%d",devErrInfo.szErrMsg,__LINE__);
     return Error_Succeed;
+    */
 }
 
 ErrorCodeEnum CardIssuerClassImpl::DevOpen(DWORD dwPort,DWORD dwBaudRate)
@@ -129,7 +135,7 @@ ErrorCodeEnum CardIssuerClassImpl::GetDevStatus(CardIssuerStatus &devStatus)
 //    CSetupMutex baseMutex(CARDISSUER_ADAPTER_MUTEX);
     std::lock_guard<std::mutex> lock(m_mutex);
     return GetDevStatus_Private(devStatus);
- }
+}
 
 ErrorCodeEnum CardIssuerClassImpl::GetDevStatus_Private(CardIssuerStatus &devStatus)
 {
@@ -290,7 +296,7 @@ ErrorCodeEnum CardIssuerClassImpl::GetDevStatus_Private(CardIssuerStatus &devSta
  }
 //
 //	Get device serial number.
-//	设备唯一标识，且需贴在设备外壳上
+//	璁惧�鍞�竴鏍囪瘑锛屼笖闇€璐村湪璁惧�澶栧３涓�
 ErrorCodeEnum CardIssuerClassImpl::GetDeviceSN(char *&pDevSN)
 {
 //    CSetupMutex baseMutex(CARDISSUER_ADAPTER_MUTEX);
@@ -303,7 +309,7 @@ ErrorCodeEnum CardIssuerClassImpl::GetDeviceSN(char *&pDevSN)
 }
 //
 //	Move card to specified position.
-//	hopperNo:多卡箱发卡时指定发卡箱号（面对发卡机，从左往右依次是1,2,3，...号卡箱）
+//	hopperNo:澶氬崱绠卞彂鍗℃椂鎸囧畾鍙戝崱绠卞彿锛堥潰瀵瑰彂鍗℃満锛屼粠宸﹀線鍙充緷娆℃槸1,2,3锛�...鍙峰崱绠憋級
 //
 ErrorCodeEnum CardIssuerClassImpl::MoveCard(CardPosEnum eCardPos, int hopperNo)
 {
@@ -320,9 +326,9 @@ ErrorCodeEnum CardIssuerClassImpl::MoveCard(CardPosEnum eCardPos, int hopperNo)
     WORD wRet = CRT_SUCCESS;
     if (eCardPos == CI_MOVECARD_BACK_NOT_HOLD)
     {
-        if(CI_RETAIN_NOTSUPP == devStatus.eRetainBin) //回收盒未放置
+        if(CI_RETAIN_NOTSUPP == devStatus.eRetainBin) //鍥炴敹鐩掓湭鏀剧疆
         {
-            SaveErrorInfo("CARD_READER_RETAINBIN_NOT_POS", "CI_RETAIN_NOTSUPP", Error_Hardware);
+            SaveErrorInfo("鍥炴敹鐩掓湭鏀剧疆,CARD_READER_RETAINBIN_NOT_POS", DEP_NO_E_CARDISSUER_USER_ERROR);
             LogM("MoveCard(),m_szErrMsg={%s} ,m_wDevErrCode=[%d] line=%d", m_szErrMsg, m_wDevErrCode,__LINE__);
             return Error_Hardware;
         }
@@ -664,13 +670,13 @@ ErrorCodeEnum CardIssuerClassImpl::RFTypeABCommand(CmdInfo sendBuf, CmdInfo &rec
     return Error_NotImpl;
 }
 /////////////////////////////////////////////////////////////////////////
-///以下是便携式卡机特有API，接口实现中其他机型直接返回Error_NotImpl即可//
+///浠ヤ笅鏄�究鎼哄紡鍗℃満鐗规湁API锛屾帴鍙ｅ疄鐜颁腑鍏朵粬鏈哄瀷鐩存帴杩斿洖Error_NotImpl鍗冲彲//
 /////////////////////////////////////////////////////////////////////////
-//	便携式发卡机调用打开设备
-//	btOpenType:设定通过哪种方式连接设备，由DevOpenType的枚举值组合。usb及蓝牙设备连接可忽略dwPort，dwBaudRate
-//	通过pDevSN来指定连接对应设备号的蓝牙发卡机（考虑存在多台发卡机的情况）
-//	例如通过蓝牙或者usb连接设备，则btOpenType = (DEV_OPEN_TYPE_USB|DEV_OPEN_TYPE_BLUETOOTH)
-//	btType返回设备实际通过哪种方式相连，返回值参考DevOpenType
+//	渚挎惡寮忓彂鍗℃満璋冪敤鎵撳紑璁惧�
+//	btOpenType:璁惧畾閫氳繃鍝��鏂瑰紡杩炴帴璁惧�锛岀敱DevOpenType鐨勬灇涓惧€肩粍鍚堛€倁sb鍙婅摑鐗欒�澶囪繛鎺ュ彲蹇界暐dwPort锛宒wBaudRate
+//	閫氳繃pDevSN鏉ユ寚瀹氳繛鎺ュ�搴旇�澶囧彿鐨勮摑鐗欏彂鍗℃満锛堣€冭檻瀛樺湪澶氬彴鍙戝崱鏈虹殑鎯呭喌锛�
+//	渚嬪�閫氳繃钃濈墮鎴栬€卽sb杩炴帴璁惧�锛屽垯btOpenType = (DEV_OPEN_TYPE_USB|DEV_OPEN_TYPE_BLUETOOTH)
+//	btType杩斿洖璁惧�瀹為檯閫氳繃鍝��鏂瑰紡鐩歌繛锛岃繑鍥炲€煎弬鑰僁evOpenType
 
 ErrorCodeEnum CardIssuerClassImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType,const char *pDevSN, BYTE &btType)
 {
@@ -695,10 +701,10 @@ ErrorCodeEnum CardIssuerClassImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYT
     LogM("CardIssuerClassImpl::leave->DevOpenEx() failed line=%d",__LINE__);
     return ErrorCodeToCMB(wRet);
 }
-//	返回值Error_Succeed表示成功，其他值表示失败
-//	iStatus   0:成功   -1:银行公钥不存在   -2:产生设备密钥故障  -x:其他厂商自定义故障
-//	Cr1：随机数r1的密文； Cr3：随机数r3的密文，dKey：用银行公钥加密的设备公钥密文
-//	r1，r3第16字节为数据完整性校验字节，例如r1为B1B2...B15B16,则B16=B1^B2^...^B15
+//	杩斿洖鍊糆rror_Succeed琛ㄧず鎴愬姛锛屽叾浠栧€艰〃绀哄け璐�
+//	iStatus   0:鎴愬姛   -1:閾惰�鍏�挜涓嶅瓨鍦�   -2:浜х敓璁惧�瀵嗛挜鏁呴殰  -x:鍏朵粬鍘傚晢鑷�畾涔夋晠闅�
+//	Cr1锛氶殢鏈烘暟r1鐨勫瘑鏂囷紱 Cr3锛氶殢鏈烘暟r3鐨勫瘑鏂囷紝dKey锛氱敤閾惰�鍏�挜鍔犲瘑鐨勮�澶囧叕閽ュ瘑鏂�
+//	r1锛宺3绗�16瀛楄妭涓烘暟鎹�畬鏁存€ф牎楠屽瓧鑺傦紝渚嬪�r1涓築1B2...B15B16,鍒橞16=B1^B2^...^B15
 ErrorCodeEnum CardIssuerClassImpl::TransferEnInit(int &iStatus, BYTE *&Cr1, int &lenR1, BYTE *&Cr3, int &lenR3, BYTE *&dKey, int &lenKey)
 {
     LOG_FUNCTION();
@@ -760,63 +766,63 @@ ErrorCodeEnum CardIssuerClassImpl::SLOpenDoor(const SCITempData data)
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//安全锁接口部分 end
+//瀹夊叏閿佹帴鍙ｉ儴鍒� end
 
-//蓝牙控制部分 start
-//蓝牙指令控制，命令参看SCIBluetoothCMD说明
+//钃濈墮鎺у埗閮ㄥ垎 start
+//钃濈墮鎸囦护鎺у埗锛屽懡浠ゅ弬鐪婼CIBluetoothCMD璇存槑
 ErrorCodeEnum CardIssuerClassImpl::BluetoothControl(SCIBluetoothCMD eCmd)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//修改配对密码
+//淇�敼閰嶅�瀵嗙爜
 ErrorCodeEnum CardIssuerClassImpl::BluetoothModifyKey(unsigned char *key)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//修改蓝牙设备名称
+//淇�敼钃濈墮璁惧�鍚嶇О
 ErrorCodeEnum CardIssuerClassImpl::BluetoothModifyName(unsigned char *name)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//修改蓝牙设备名称
+//淇�敼钃濈墮璁惧�鍚嶇О
 ErrorCodeEnum CardIssuerClassImpl::BluetoothGetVersion(char *&version)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//获取连接设备名称
+//鑾峰彇杩炴帴璁惧�鍚嶇О
 ErrorCodeEnum CardIssuerClassImpl::BluetoothGetConnectName(unsigned char *&name)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//获取连接设备信号强度
+//鑾峰彇杩炴帴璁惧�淇″彿寮哄害
 ErrorCodeEnum CardIssuerClassImpl::BluetoothGetSignalStrength(unsigned char *&signal)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//蓝牙控制部分 end
+//钃濈墮鎺у埗閮ㄥ垎 end
 
-//控制灯光
-//eLight：所控制的灯 ；
-//bOnOff：true 亮灯；fasle 灭灯
+//鎺у埗鐏�厜
+//eLight锛氭墍鎺у埗鐨勭伅 锛�
+//bOnOff锛歵rue 浜�伅锛沠asle 鐏�伅
 ErrorCodeEnum CardIssuerClassImpl::LightControl(SCILightType eLight, bool bOnOff)
 {
     LOG_FUNCTION();
     LogM("Error_NotImpl");
     return Error_NotImpl;
 }
-//以百分比数值返回剩余电量（1-100），例如剩余51%，则bat赋值为51
+//浠ョ櫨鍒嗘瘮鏁板€艰繑鍥炲墿浣欑數閲忥紙1-100锛夛紝渚嬪�鍓╀綑51%锛屽垯bat璧嬪€间负51
 ErrorCodeEnum CardIssuerClassImpl::QueryBatteryPower(int &bat)
 {
     LOG_FUNCTION();
@@ -824,30 +830,69 @@ ErrorCodeEnum CardIssuerClassImpl::QueryBatteryPower(int &bat)
     return Error_NotImpl;
 }
 //Private
-void CardIssuerClassImpl::SaveErrorInfo(CHAR* errMsg, CHAR* errCode, WORD wDevCode)
+/*void CardIssuerClassImpl::SaveErrorInfo(CHAR* errMsg, CHAR* errCode, WORD wDevCode)
 {
     memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
     m_wDevErrCode = 0;
     sprintf(m_szErrMsg, "Description:[%s] ErrCode:[%s]", errMsg, errCode);
     m_wDevErrCode = wDevCode;
+}*/
+
+void CardIssuerClassImpl::_SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
+{
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s(V%d.%d.%d.%d)", strFunc, nLine, errMsg, FILE_MAJOR, FILE_MINOR, FILE_REVISION, FILE_BUILD);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s(V%d.%d.%d.%d)", strFunc, nLine, errMsg, FILE_MAJOR, FILE_MINOR, FILE_REVISION, FILE_BUILD);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //绱у噾鏍煎紡
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //鏍囧噯JSON鏍煎紡    QString strJson(root_str);
+    QString strJson(root_str);
+    //QByteArray ba = strJson.toLatin1();
+    //char* sErrMsg = ba.data();
+    //memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
+    //sprintf(m_szErrMsg, sErrMsg);
+    //LogM(m_szErrMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
 }
+
 //String Format
 int CardIssuerClassImpl::string_format(std::string &str, const std::string fmt, ...)
 {
     return 0;
 }
 
-ErrorCodeEnum CardIssuerClassImpl::ErrorCodeToCMB(WORD wRes)
+ErrorCodeEnum CardIssuerClassImpl::_ErrorCodeToCMB(WORD wRes, const CHAR* strFunc, int nLine)
 {
     ErrorCodeEnum eRet = Error_Succeed;
     LOG_FUNCTION_INT32(eRet);
 
+    CHAR szErrDetail[CARD_READER_ERRDETAIL_BUFF * 2];
+    memset(szErrDetail, 0x00, sizeof(szErrDetail));
+
     DevErrDetail getErrDetail = {0x00};
     WORD wResult = DEV_UNKNOWN;
     LogM("ErrorCodeToCMB return[%x] !", wRes);
 
     if (wRes == CRT_SUCCESS)
     {
+        getErrDetail.iErrCode = DEP_SUCCESS;
+        strcpy(getErrDetail.szErrCode, "00");
+        strcpy(getErrDetail.szErrDetail, "鎴愬姛!");
+        sprintf(szErrDetail, "%s,Code=[%s]", getErrDetail.szErrDetail, getErrDetail.szErrCode);
+        _SaveErrorInfo(szErrDetail, getErrDetail.iErrCode, strFunc, nLine);
+
         return eRet;
     }
 
@@ -876,13 +921,15 @@ ErrorCodeEnum CardIssuerClassImpl::ErrorCodeToCMB(WORD wRes)
         eRet = Error_DevMedia;
         break;
     default:
+        eRet = Error_Hardware;
         break;
     }
 
     if (wResult == CRT_OFFLINE)
     {
-        memcpy(getErrDetail.szErrCode, "FF", strlen("FF"));
-        memcpy(getErrDetail.szErrDetail, "Device OffLine!", strlen("Device OffLine!"));
+        getErrDetail.iErrCode = DEP_NO_E_CARDISSUER_OFFLINE;
+        strcpy(getErrDetail.szErrCode, "FF");
+        strcpy(getErrDetail.szErrDetail, "鍙戝崱妯″潡绂荤嚎!");
     }
     else if (wResult == CRT_MEIDA_INVALID || wResult == CRT_IC_INVALID || wResult == CRT_USER_ERROR)
     {
@@ -893,7 +940,8 @@ ErrorCodeEnum CardIssuerClassImpl::ErrorCodeToCMB(WORD wRes)
         m_pACT_Sankyo_DevCtrl->GetErrorDetail(&getErrDetail);
     }
 
-    SaveErrorInfo(getErrDetail.szErrDetail, getErrDetail.szErrCode,wRes);
+    sprintf(szErrDetail, "%s,Code=[%s]", getErrDetail.szErrDetail, getErrDetail.szErrCode);
+    _SaveErrorInfo(szErrDetail, getErrDetail.iErrCode, strFunc, nLine);
 
     return eRet;
 }

DevAdapter/keba/CardIssuer.keba.1.1/CardIssuerClassImpl_ACT-Sankyo.h

@@ -8,6 +8,15 @@
 
 #define CARDISSUER_ADAPTER_MUTEX		"CardIssuerAdapterMutex"
 
+//±àÒë°æ±¾
+#define  FILE_MAJOR  1
+#define  FILE_MINOR  0
+#define  FILE_REVISION  0
+#define  FILE_BUILD  1
+
+#define SaveErrorInfo(errMsg, errCode)  _SaveErrorInfo(errMsg, errCode, __FUNCTION__, __LINE__)
+#define ErrorCodeToCMB(wRes)  _ErrorCodeToCMB(wRes, __FUNCTION__, __LINE__)
+
 class CardIssuerClassImpl : public CardIssuerClass
 {
 public:
@@ -115,14 +124,15 @@ private:
 	bool m_bDevOpen;
 	CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
     WORD m_wDevErrCode;
-    void SaveErrorInfo(CHAR* errMsg, CHAR* errCode, WORD wDevCode);
+    //void SaveErrorInfo(CHAR* errMsg, CHAR* errCode, WORD wDevCode);
+    void _SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine);
     ErrorCodeEnum GetDevStatus_Private(CardIssuerStatus &devStatus);
 
 private:
 	int string_format(std::string &str, const std::string fmt, ...);
 
 private:
-	ErrorCodeEnum ErrorCodeToCMB(WORD wRes);
+    ErrorCodeEnum _ErrorCodeToCMB(WORD wRes, const CHAR* strFunc, int nLine);
 
 private:
 	CACT_Sankyo_DevCtrl* m_pACT_Sankyo_DevCtrl;

DevAdapter/keba/CardIssuer.keba.1.1/stdafx.h

@@ -9,6 +9,10 @@
 
 #include "wintypes.h"
 
+//#include <QJsonDocument>//²Î¿¼Á´½Ó£ºhttps://www.cnblogs.com/whik/p/11234889.html
+//#include <QJsonObject>
+//#include <QJsonArray>
+
 #include <string>
 #include <map>
 #include <list>
@@ -17,4 +21,8 @@
 //#include "TraceManager.h"
 #include "CkLog.h"
 
+#include "winfunc.h"
 #include "CommDef.h"
+#include "DeviceBaseClass.h"
+//#include "DepErrorCode.h"
+#include "DepErrorCode_CardIssuer.h"

DevAdapter/keba/ContactlessCard.keba.1.1/CMakeLists.txt

@@ -3,6 +3,9 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
+
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
     set(CMAKE_CXX_FLAGS "-std=c++11")
@@ -32,6 +35,9 @@ target_include_directories(${MODULE_FULL_NAME} PUBLIC  ${INCLUDE_KEBA})
 #设置日志依赖库文件的路径变量路径
 target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${DEVADAPTER_CURRENT_LIB_DIR})
 
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
+
 #86下依赖的库连接这个文件路径:/data/home/keba/DevAdapter/keba/lib/gcc_x64?gcc_aarch64
 #target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR})
 target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/keba)

DevAdapter/keba/ContactlessCard.keba.1.1/rficclassimpl_crt603cz7.cpp

@@ -41,7 +41,7 @@ RFICClassImpl::RFICClassImpl():
     m_strIniPath = m_strModulePath;
     m_strIniPath += "CK-VTM-E1000.INI";
     m_strDllPath = m_strModulePath;
-
+    SaveErrorInfo("RFICClassImpl 成功", DEP_SUCCESS, __FUNCTION__ , __LINE__);
     //--------------------------------------------------------------------
 }
 RFICClassImpl::~RFICClassImpl()
@@ -112,6 +112,7 @@ ErrorCodeEnum RFICClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
 ErrorCodeEnum RFICClassImpl::Reset()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard Reset()!");
     int nRet = CRT_SUCCESS;
     if (m_bDevOpen == FALSE)
@@ -121,7 +122,8 @@ ErrorCodeEnum RFICClassImpl::Reset()
      nRet = m_pDll->CrtReset();
      if (nRet != CRT_SUCCESS)
      {
-         SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+         sprintf(szErrorMsg, "复位失败");
+         SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
          return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
      }
      LogM("RFICClassImpl::Leave->ContactlessCard Reset() sucessfull!");
@@ -133,12 +135,14 @@ ErrorCodeEnum RFICClassImpl::Reset()
 ErrorCodeEnum RFICClassImpl::DevClose()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard DevClose()!");
     int nRet = CRT_SUCCESS;
     nRet = m_pDll->CrtDevCLose();
     if (nRet != CRT_SUCCESS)
     {
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        sprintf(szErrorMsg, "关闭智能读卡器失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CONNECT, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
 
     }
@@ -167,6 +171,7 @@ ErrorCodeEnum RFICClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
 ErrorCodeEnum RFICClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard DevOpen()!");
     int nRet = CRT_SUCCESS;
     CHAR strDllPath[256] = {0};
@@ -178,7 +183,8 @@ ErrorCodeEnum RFICClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     if (nullptr == m_pDll)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard DevOpen() new object CDevDllLoad failed!");
-        SaveErrorInfo("对象创建失败", DEC_DEV_OBJECT_CREATE_FAILED);
+        sprintf(szErrorMsg, "加载依赖的DLL失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_LOADDLL, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
     nRet = m_pDll->CrtDevOpen();
@@ -187,13 +193,29 @@ ErrorCodeEnum RFICClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
         LogM("RFICClassImpl::Entry->ContactlessCard DevOpen() failed! <=> iRet = %d",nRet);
         if (nRet == CRT_ERR_LOADDLL)
         {
-            SaveErrorInfo("Load CRT DLL Error! ", nRet);
+            sprintf(szErrorMsg, "加载依赖的DLL失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_LOADDLL, __FUNCTION__, __LINE__);
         }
         else
         {
-            SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+            switch(nRet)
+            {
+            case CRT_ERR_SET_READERTYPE:
+                sprintf(szErrorMsg, "设置读卡器类型失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_TYPE_CAP, __FUNCTION__, __LINE__);
+                break;
+            case CRT_ERR_SET_READERNAME:
+                sprintf(szErrorMsg, "设置读卡器名称失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_TYPE_CAP, __FUNCTION__, __LINE__);
+                break;
+            case CRT_ERR_CONNECT:
+                sprintf(szErrorMsg, "模块链接设备失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CONNECT, __FUNCTION__, __LINE__);
+                break;
+            default:
+                break;
+            }
         }
-
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Entry->ContactlessCard DevOpen() success! <=> iRet = %d",nRet);
@@ -201,7 +223,19 @@ ErrorCodeEnum RFICClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtInitSet() failed! <=> iRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        switch(nRet)
+        {
+        case CRT_ERR_SET_CONTRAL_CMD:
+            sprintf(szErrorMsg, "控制命令错");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_CONTRAL_CMD, __FUNCTION__, __LINE__);
+            break;
+        case CRT_ERR_SET_TYPE_CAP:
+            sprintf(szErrorMsg, "设置读卡器能读取TYPE B卡能力失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_TYPE_CAP, __FUNCTION__, __LINE__);
+            break;
+        default:
+            break;
+        }
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Entry->ContactlessCard CrtInitSet() success! <=> iRet = %d",nRet);
@@ -216,6 +250,7 @@ ErrorCodeEnum RFICClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
 ErrorCodeEnum RFICClassImpl::GetDevStatus(RFICReaderStatus &devStatus)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard GetDevStatus()!");
     int nRet = CRT_SUCCESS;
     int nType = CRT_CARD_TYPE_UNKNOWN;
@@ -230,7 +265,8 @@ ErrorCodeEnum RFICClassImpl::GetDevStatus(RFICReaderStatus &devStatus)
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtFindCard() failed! <=> iRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        sprintf(szErrorMsg, "获取卡状态失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_GET_SATUTS, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Entry->ContactlessCard CrtFindCard() success! <=> iRet = %d",nRet);
@@ -241,7 +277,8 @@ ErrorCodeEnum RFICClassImpl::GetDevStatus(RFICReaderStatus &devStatus)
             if (nRet != CRT_SUCCESS)
             {
                 LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() failed! <=> iRet = %d",nRet);
-                SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+                sprintf(szErrorMsg, "获取卡类型失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_GET_CARD_TYPE, __FUNCTION__, __LINE__);
                 return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
             }
             LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() success! <=> nType = %d",nType);
@@ -289,6 +326,7 @@ ErrorCodeEnum RFICClassImpl::AbortRead()
 ErrorCodeEnum RFICClassImpl::ActiveContactlessICCard(char fstType,char scdType,char thdType,char &outType)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard ActiveContactlessICCard()!");
     int nRet = CRT_SUCCESS;
     int nType = CRT_CARD_TYPE_UNKNOWN;
@@ -303,7 +341,8 @@ ErrorCodeEnum RFICClassImpl::ActiveContactlessICCard(char fstType,char scdType,c
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() failed! <=> iRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        sprintf(szErrorMsg, "获取卡类型失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_GET_CARD_TYPE, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() success! <=> nType = %d",nType);
@@ -324,7 +363,8 @@ ErrorCodeEnum RFICClassImpl::ActiveContactlessICCard(char fstType,char scdType,c
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtActiveCard() failed! <=> nRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        sprintf(szErrorMsg, "无卡或不支持的卡片");
+        SaveErrorInfo(szErrorMsg, DEP_PROTOCOL_UNSUPPORTED, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     m_EjectCard = false;
@@ -339,6 +379,7 @@ ErrorCodeEnum RFICClassImpl::ActiveContactlessICCard(char fstType,char scdType,c
 ErrorCodeEnum RFICClassImpl::DeactContactlessICCard()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard DeactContactlessICCard()!");
     int nRet = CRT_SUCCESS;
     if (m_bDevOpen == FALSE)
@@ -350,7 +391,8 @@ ErrorCodeEnum RFICClassImpl::DeactContactlessICCard()
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtDeActive() failed! <=> iRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        sprintf(szErrorMsg, "弹卡下电失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     m_EjectCard = true;
@@ -364,6 +406,7 @@ ErrorCodeEnum RFICClassImpl::DeactContactlessICCard()
 ErrorCodeEnum RFICClassImpl::WarmReset()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard WarmReset()!");
     int nRet = CRT_SUCCESS;
     if (m_bDevOpen == FALSE)
@@ -375,7 +418,8 @@ ErrorCodeEnum RFICClassImpl::WarmReset()
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtWarmReset() failed! <=> iRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        sprintf(szErrorMsg, "热复位失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Entry->ContactlessCard CrtWarmReset() success! <=> iRet = %d",nRet);
@@ -415,11 +459,13 @@ ErrorCodeEnum RFICClassImpl::MifareCommand(MifareFuctionEnum eFunType,CmdInfo se
 ErrorCodeEnum RFICClassImpl::RFTypeABCommand(CmdInfo sendBuf,CmdInfo &recvBuf)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("RFICClassImpl::Entry->ContactlessCard RFTypeABCommand()!");
     int nRet = CRT_SUCCESS;
     if(m_EjectCard == true)
     {
-        SaveErrorInfo("IC卡已下电", Error_Param);
+        sprintf(szErrorMsg, "IC卡已下电");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
         return Error_Param;
     }
     CRT_Chip_Info sendChip = {0x00};
@@ -437,7 +483,19 @@ ErrorCodeEnum RFICClassImpl::RFTypeABCommand(CmdInfo sendBuf,CmdInfo &recvBuf)
     if (nRet != CRT_SUCCESS)
     {
         LogM("RFICClassImpl::Entry->ContactlessCard CrtChipIO() failed! <=> iRet = %d",nRet);
-        SaveErrorInfo(m_pDll->CrtGetLastErrDetail(), nRet);
+        switch(nRet)
+        {
+        case CRT_ERR_PARAM:
+            sprintf(szErrorMsg, "参数错");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_PARAM, __FUNCTION__, __LINE__);
+            break;
+        case CRT_ERR_CHIPIO:
+            sprintf(szErrorMsg, "CHIPIO失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPIO, __FUNCTION__, __LINE__);
+            break;
+        default:
+            break;
+        }
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Entry->ContactlessCard CrtChipIO() success! <=> iRet = %d",nRet);
@@ -458,11 +516,28 @@ ErrorCodeEnum RFICClassImpl::HaltCard()
 }
 
 //Private
-void RFICClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
+void RFICClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
 {
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
     memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-    snprintf(m_szErrMsg, sizeof (m_szErrMsg),"%s[%d]", errMsg, errCode);
-    ErrorCodeToCMB(errCode);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
 }
 ErrorCodeEnum RFICClassImpl::ErrorCodeToCMB(int nRes)
 {
@@ -472,27 +547,27 @@ ErrorCodeEnum RFICClassImpl::ErrorCodeToCMB(int nRes)
     {
     case CRT_SUCCESS:
         eRet = Error_Succeed;
-        m_shErrCode = DEC_SUCCESS;
+        m_shErrCode = DEP_SUCCESS;
         break;
     case CRT_ERR_TYPE_CONNECT:
         eRet = Error_DevNotAvailable;
-        m_shErrCode = DEC_DEV_CONNECT_FAILED;
+        m_shErrCode = DEP_DEV_CONNECT_FAILED;
         break;
     case CRT_ERR_TYPE_HWERROR:
         eRet = Error_Hardware;
-        m_shErrCode = DEC_HARDWARE;
+        m_shErrCode = DEP_HARDWARE;
         break;
     case CRT_ERR_TYPE_MEDIA:
         eRet = Error_NotImpl;
-        m_shErrCode = DEC_EXCEPTION;
+        m_shErrCode = DEP_EXCEPTION;
         break;
     case CRT_ERR_TYPE_MIFARE:
         eRet = Error_NotImpl;
-        m_shErrCode = DEC_EXCEPTION;
+        m_shErrCode = DEP_EXCEPTION;
         break;
     case CRT_ERR_TYPE_PARAM:
         eRet = Error_Param;
-        m_shErrCode = DEC_INVALID_PARAMETER;
+        m_shErrCode = DEP_INVALID_PARAMETER;
         break;
     default:
         break;

DevAdapter/keba/ContactlessCard.keba.1.1/rficclassimpl_crt603cz7.h

@@ -99,7 +99,7 @@ private:
     CDevDllLoad *m_pDll;
     BOOL m_bDevOpen;
     CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
-    void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+    void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
     int GetDllPathLocal(std::string &dllPath);
     char m_strModulePath[256];
     std::string m_strIniPath;

DevAdapter/keba/ContactlessCard.keba.1.1/stdafx.h

@@ -17,7 +17,11 @@
 #include <dlfcn.h>
 
 // TODO: 在此处引用程序需要的其他头文件
-#include "DevErrorCode.h"
+#include "DepErrorCode.h"
 #include "TraceManager.h"
 #include "CommDef.h"
+//#include <QJsonParseError>  //https://www.cnblogs.com/whik/p/11234889.html
+//#include <QVariantMap>
+//#include <QJsonObject>
+//#include <QJsonArray>
 #endif // STDAFX_H

DevAdapter/keba/FingerPrint.keba.1.1/CMakeLists.txt

@@ -6,6 +6,8 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
 
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
@@ -43,7 +45,8 @@ target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/ke
 target_link_libraries(${MODULE_FULL_NAME} ${VENDOR_LOG_LIB_NAME})
 #链接keba日志库
 target_link_libraries(${MODULE_FULL_NAME} Common.keba)
-
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
 #设置动态库输出路径:/data/home/keba/DevAdapter/cmbsz/lib/gcc_aarch64或者gcc_x64
 SET(LIBRARY_OUTPUT_PATH ${VENDOR_CURRENT_LIB_DIR})
 message(STATUS "LIBRARY_OUTPUT_PATH: ${VENDOR_CURRENT_LIB_DIR}")

DevAdapter/keba/FingerPrint.keba.1.1/fingerprint.cpp

@@ -47,6 +47,7 @@ FingerPrintClassImpl::FingerPrintClassImpl():
     m_strIniPath = m_strModulePath;
     m_strIniPath += "CK-VTM-E1000.INI";
     m_strDllPath = m_strModulePath;
+    SaveErrorInfo("FingerPrintClassImpl 成功", DEP_SUCCESS, __FUNCTION__ , __LINE__);
 }
 
 
@@ -64,6 +65,7 @@ FingerPrintClassImpl::~FingerPrintClassImpl()
 ErrorCodeEnum FingerPrintClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::Entry->FingerPrint GetDevCategory()!");
     int iRet = 0;
     char szDevInfo[128] = {0};
@@ -82,7 +84,8 @@ ErrorCodeEnum FingerPrintClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
     else
     {
         memcpy(devCategory.szType, "PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]", strlen("PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]"));
-        SaveErrorInfo(iRet);
+        sprintf(szErrorMsg, "获取设备硬件信息失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_UNSUCCESS, __FUNCTION__, __LINE__);
     }
     memcpy(devCategory.szVendor, "keba", strlen("keba"));
     LogM("devCategory.szType = %s",devCategory.szType);
@@ -110,13 +113,25 @@ ErrorCodeEnum FingerPrintClassImpl::DevClose()
 {
     //记日志
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
+    int iRet =0;
     LogM("FingerPrintClassImpl::Entry->FingerPrint DevClose()!");
     if(!m_bDevOpen)
     {
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         return Error_Succeed;
     }
     //CLOSEDEV();
-    m_pDll->FPIDeviceClose();
+    //m_pDll->FPIDeviceClose();
+    iRet = m_pDll->FPIDeviceClose();
+    if(iRet != FP_ERROR_SUCCESS)
+    {
+        sprintf(szErrorMsg, "关闭设备失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_UNSUCCESS, __FUNCTION__, __LINE__);
+        LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Cancel() failed");
+        return Error_DevMedia;
+    }
     m_pDll->FreeDLL();
     m_bDevOpen = false;
     LogM("FingerPrintClassImpl::Leave->FingerPrint DevClose() sucessfull!");
@@ -143,6 +158,7 @@ ErrorCodeEnum FingerPrintClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
 ErrorCodeEnum FingerPrintClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen()!");
     int  iRet;
     CHAR strDllPath[256] = {0};
@@ -154,13 +170,16 @@ ErrorCodeEnum FingerPrintClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     if (nullptr == m_pDll)
     {
         LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen() new object CDevDllLoad failed!");
-        SaveErrorInfo("对象创建失败", DEC_DEV_OBJECT_CREATE_FAILED);
+        sprintf(szErrorMsg, "加载厂家库失败");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_OBJECT_CREATE_FAILED, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
     iRet = m_pDll->FPIDeviceInit();
     //记日志
     if(iRet != 1)
     {
+        sprintf(szErrorMsg, "初始化的时候，检测到设备不存在");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_DEVICE_NOT_FOUND, __FUNCTION__, __LINE__);
         LogM("FingerPrintClassImpl::Entry->FingerPrint DevOpen()->m_pDll->FPIDeviceInit() failed! <=> iRet = %d",iRet);
         m_bDevOpen = false;
         return Error_DevNotAvailable;
@@ -176,6 +195,30 @@ ErrorCodeEnum FingerPrintClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     }
     return Error_Succeed;
 }
+void FingerPrintClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
+{
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
+}
+/*
 void FingerPrintClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
 {
     LOG_FUNCTION();
@@ -193,207 +236,154 @@ void FingerPrintClassImpl::SaveErrorInfo(DevErrorInfo devErrorInfo)
     snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%s",devErrorInfo.szErrMsg);
     LogM("FingerPrintClassImpl::Leave->FingerPrint DevOpen()->m_pDll->SaveErrorInfo(DevErrorInfo devErrorInfo) sucessfull!");
 }
-void FingerPrintClassImpl::SaveErrorInfo(int nErrorCode)
+*/
+void FingerPrintClassImpl::SaveErrorInfo(int nErrorCode,const CHAR* strFunc, int nLine)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::Entry->FingerPrint SaveErrorInfo(int nErrorCode)! <=> nErrorCode = %d",nErrorCode);
     ErrorCodeEnum ret;
     switch (nErrorCode)
     {
     case FP_ERROR_SUCCESS:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_SUCCESS, "成功");
-        m_shErrCode = DEC_SUCCESS;
-        ret = Error_Succeed;
+        sprintf(szErrorMsg, "成功");
+        SaveErrorInfo(szErrorMsg, DEP_SUCCESS, strFunc, nLine);
         break;
     case FP_ERROR_INVALID_PARAMETER:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_INVALID_PARAMETER, "参数错误。给定函数的参数有错误。");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "参数错误。给定函数的参数有错误。");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_INVALID_PARAMETER, strFunc, nLine);
         break;
     case FP_ERROR_NOT_ENOUGH_MEMORY:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_NOT_ENOUGH_MEMORY, "内存分配失败。没有分配到足够的内存。");
-        m_shErrCode = DEC_ALLOC_DENY;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "内存分配失败。没有分配到足够的内存");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_NOT_ENOUGH_MEMORY, strFunc, nLine);
         break;
     case FP_ERROR_NOT_SUPPORT_FUNCTION:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_NOT_SUPPORT_FUNCTION, "功能未开放。调用函数的功能没有实现。");
-        m_shErrCode = DEC_FUNCTION_MISMATCH;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "功能未开放。调用函数的功能没有实现");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_NOT_SUPPORT_FUNCTION, strFunc, nLine);
         break;
     case FP_ERROR_DEVICE_NOT_FOUND:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_DEVICE_NOT_FOUND, "设备不存在。初始化的时候，检测到设备不存在。");
-        m_shErrCode = DEC_DEV_NOT_FOUND;
-        ret = Error_DevConnFailed;
+        sprintf(szErrorMsg, "设备不存在。初始化的时候，检测到设备不存在");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_DEVICE_NOT_FOUND, strFunc, nLine);
         break;
     case FP_ERROR_DEVICE_NOT_INIT:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_DEVICE_NOT_INIT, "设备未初始化。");
-        m_shErrCode = DEC_DEV_NOT_OPENED;
-        ret = Error_NotInit;
+        sprintf(szErrorMsg, "设备未初始化");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_DEVICE_NOT_INIT, strFunc, nLine);
         break;
     case FP_ERROR_INVALIDE_CODE:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_INVALIDE_CODE, "非法的错误号。");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "非法的错误号");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_INVALIDE_CODE, strFunc, nLine);
         break;
     case FP_ERROR_NO_PRIVILEGE:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_NO_PRIVILEGE, "没有授权。");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "没有授权。");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_NO_PRIVILEGE, strFunc, nLine);
         break;
     case FP_ERROR_BASE64:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_DEVICE_NOT_FOUND, "BASE64编解码失败。");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "BASE64编解码失败。");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_BASE64, strFunc, nLine);
         break;
     case FP_ERROR_EXCEPTION:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_EXCEPTION, "操作异常");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "操作异常");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_EXCEPTION, strFunc, nLine);
         break;
     case FP_ERROR_RESERVE:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_RESERVE, "系统保留");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "系统保留");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_RESERVE, strFunc, nLine);
         break;
     case FP_ERROR_MAC:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_MAC, "MAC错误");
-        m_shErrCode = DEC_INVALID_MAC;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "MAC错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_MAC, strFunc, nLine);
         break;
     case FP_ERROR_ID:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_ID, "设备ID错误");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "设备ID错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_ID, strFunc, nLine);
         break;
     case FP_ERROR_IMAGE:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_IMAGE, "图像错误");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "图像错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_IMAGE, strFunc, nLine);
         break;
     case FP_ERROR_FILE_NO_FOUND:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_FILE_NO_FOUND, "文件不存在");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "文件不存在");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_FILE_NO_FOUND, strFunc, nLine);
         break;
     case FP_ERROR_UNSUCCESS:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_UNSUCCESS, "操作失败");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "操作失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_UNSUCCESS, strFunc, nLine);
         break;
     case FP_ERROR_UNKNOWN:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_UNKNOWN, "未知错误");
-        m_shErrCode = DEC_UNEXPECTED;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "未知错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_UNKNOWN, strFunc, nLine);
         break;
     case FP_ERROR_DEVICECMD:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_DEVICECMD, "通讯错误");
-        m_shErrCode = DEC_COMMUNICATION_FAILED;
-        ret = Error_DevCommFailed;
+        sprintf(szErrorMsg, "通讯错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_DEVICECMD, strFunc, nLine);
         break;
     case FP_ERROR_TIMEOUT:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_TIMEOUT, "操作超时");
-        m_shErrCode = DEC_TIMEOUT;
-        ret = Error_TimeOut;
+        sprintf(szErrorMsg, "操作超时");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_TIMEOUT, strFunc, nLine);
         break;
     case FP_ERROR_CANCEL:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_CANCEL, "操作取消");
-        m_shErrCode = DEC_CANCEL;
-        ret = Error_Cancel;
+        sprintf(szErrorMsg, "操作取消");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_CANCEL, strFunc, nLine);
         break;
     case FP_ERROR_IMAGE_NOTENOUGH:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_IMAGE_NOTENOUGH, "图像不合格");
-        m_shErrCode = DEC_EXCEPTION;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "图像不合格");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_IMAGE_NOTENOUGH, strFunc, nLine);
         break;
     case FP_ERROR_IS_BUSY:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_IS_BUSY, "设备正忙");
-        m_shErrCode = DEC_HARDWARE;
-        ret = Error_Busy;
+        sprintf(szErrorMsg, "设备正忙");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_IS_BUSY, strFunc, nLine);
         break;
     case FP_ERROR_FINGER_VERIFY:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_FINGER_VERIFY, "指纹比对失败");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_MisMatched;
+        sprintf(szErrorMsg, "指纹比对失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_FINGER_VERIFY, strFunc, nLine);
         break;
     case FP_ERROR_FINGER_EXTRACT:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_FINGER_EXTRACT, "合成特征失败");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "合成特征失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_EXTRACT, strFunc, nLine);
         break;
     case FP_ERROR_FINGER_ENROLL:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_FINGER_ENROLL, "合成模板失败");
-        m_shErrCode = DEC_INVALID_PARAMETER;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "合成模板失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_FINGER_ENROLL, strFunc, nLine);
         break;
     case FP_ERROR_FINGER_ILLEGAL:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_FINGER_ILLEGAL, "非法指纹数据");
-        m_shErrCode = DEC_INVALID_DATA;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "非法指纹数据");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_FINGER_ILLEGAL, strFunc, nLine);
         break;
     case FP_ERROR_INVALID_TEMPLATE:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FP_ERROR_INVALID_TEMPLATE, "模板参数错误");
-        m_shErrCode = DEC_INVALID_DATA;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "模板参数错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_INVALID_TEMPLATE, strFunc, nLine);
         break;
     case FP_ERROR_INVALID_FEATURE:
-        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FP_ERROR_INVALID_FEATURE, "特征参数错误");
-        m_shErrCode = DEC_INVALID_DATA;
-        ret = Error_Param;
+        sprintf(szErrorMsg, "特征参数错误");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_INVALID_FEATURE, strFunc, nLine);
         break;
     default:
         memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
         snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",nErrorCode, "其它未定义的错误");
-        m_shErrCode = DEC_ERROR_CODE_UNRECOGNIZABLE;
+        m_shErrCode = DEP_ERROR_CODE_UNRECOGNIZABLE;
         ret = Error_Param;
         break;
     }
     LogM("FingerPrintClassImpl::Leave->FingerPrint DevOpen()->m_pDll->SaveErrorInfo(int nErrorCode) sucessfull!");
 }
 
-
 ErrorCodeEnum FingerPrintClassImpl::ScanFingerAndSaveImage(const char* imageName)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::Entry->FingerPrint ScanFingerAndSaveImage(const char* imageName)! <=>imageName = %s",imageName);
     int iRet =0;
     if( !m_bDevOpen )
     {
-        SaveErrorInfo("ScanFingerAndSaveImage()->Dev is not open",Error_DevNotAvailable );
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         //记日志
         return Error_DevNotAvailable;
     }
     iRet= m_pDll->FPIImg2Bmp(const_cast<char*>(imageName));
     if(iRet != FP_ERROR_SUCCESS)
     {
-        SaveErrorInfo(iRet);
+        SaveErrorInfo(iRet,__FUNCTION__, __LINE__);
         LogM("FingerPrintClassImpl::entry->FingerPrint ScanFingerAndSaveImage()->m_pDll->FPIImg2Bmp failed!");
         return Error_DevMedia;
     }
@@ -407,6 +397,7 @@ ErrorCodeEnum FingerPrintClassImpl::ScanFingerAndSaveImage(const char* imageName
 ErrorCodeEnum FingerPrintClassImpl::Image2Feature(const char* imagePath, LPBYTE lpbFeature, int &iLength)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()");
     int iRet =0;
     CHAR strImgPath[256] = {0};
@@ -414,12 +405,15 @@ ErrorCodeEnum FingerPrintClassImpl::Image2Feature(const char* imagePath, LPBYTE
     LogM("自己改造好的PATH=%s",strImgPath);
     if( !m_bDevOpen )
     {
-        SaveErrorInfo("Image2Feature()->Dev is not open",Error_DevNotAvailable );
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()->Dev is not open");
         return Error_DevNotAvailable;
     }
     if(Error_Succeed != ScanFingerAndSaveImage(strImgPath))
     {
+        sprintf(szErrorMsg, "生成指纹图像失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_IMAGE, __FUNCTION__, __LINE__);
         LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()->ScanFingerAndSaveImage() failed");
         return Error_DevMedia;
     }
@@ -428,7 +422,8 @@ ErrorCodeEnum FingerPrintClassImpl::Image2Feature(const char* imagePath, LPBYTE
     {
         LOG4VTM(INFO,"FingerPrintClassImpl::entry FingerPrint->Image2Feature()->m_pDll->FPIBmp2Feature failed");
         LogM("FingerPrintClassImpl::entry FingerPrint->Image2Feature()->m_pDll->FPIBmp2Feature failed");
-        SaveErrorInfo(iRet);
+        sprintf(szErrorMsg, "生成特征值失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_EXTRACT, __FUNCTION__, __LINE__);
         return Error_DevMedia;
     }
     LogM("特征值长度=%d ",iLength);
@@ -441,6 +436,7 @@ ErrorCodeEnum FingerPrintClassImpl::Image2Feature(const char* imagePath, LPBYTE
 ErrorCodeEnum FingerPrintClassImpl::Image2Template(const char* imagePath1, const char* imagePath2, const char* imagePath3, LPBYTE lpbTemplate, int &iLength)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::entry FingerPrint->Image2Template()");
     LogM("招行传递的图片PATH1=%s ",imagePath1);
     LogM("招行传递的图片PATH2=%s ",imagePath2);
@@ -455,13 +451,14 @@ ErrorCodeEnum FingerPrintClassImpl::Image2Template(const char* imagePath1, const
 
     if( !m_bDevOpen )
     {
-        SaveErrorInfo("Image2Template()->Dev is not open",Error_DevNotAvailable );
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
     iRet = m_pDll->FPIBmp2Template(const_cast<char*>(imagePath1), const_cast<char*>(imagePath2), const_cast<char*>(imagePath3), (char*)lpbTemplate,&iLength);
     if(iRet != FP_ERROR_SUCCESS)
     {
-        SaveErrorInfo(iRet);
+        SaveErrorInfo(iRet,__FUNCTION__, __LINE__);
         LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Image2Template() failed ");
         return Error_DevMedia;
     }
@@ -474,13 +471,15 @@ ErrorCodeEnum FingerPrintClassImpl::Image2Template(const char* imagePath1, const
 ErrorCodeEnum FingerPrintClassImpl::Match(LPBYTE lpbTemplate[], int iTemplateLen[] ,int templateNum, LPBYTE lbpFeature, int &iFeatureLen ,int level)
 {
    LOG_FUNCTION();
+   char szErrorMsg[256] = {0};
    LogM("FingerPrintClassImpl::entry FingerPrint->Match()");
    LogM("模板数组的个数=%d ",templateNum);
    LogM("特征值长度=%d ",iFeatureLen);
    int iRet =0;
    if( !m_bDevOpen )
    {
-       SaveErrorInfo("Match()->Dev is not open",Error_DevNotAvailable );
+       sprintf(szErrorMsg, "设备未打开");
+       SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
        LogM("FingerPrintClassImpl::leave FingerPrint->Match() failed");
        return Error_DevNotAvailable;
    }
@@ -507,18 +506,21 @@ ErrorCodeEnum FingerPrintClassImpl::Match(LPBYTE lpbTemplate[], int iTemplateLen
 ErrorCodeEnum FingerPrintClassImpl::Cancel()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogM("FingerPrintClassImpl::entry FingerPrint->Cancel()!");
     int iRet =0;
     if( !m_bDevOpen )
     {
-        //SaveErrorInfo("Cancel()->Dev is not open",Error_DevNotAvailable );
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Cancel() failed");
         return Error_DevNotAvailable;
     }
     iRet = m_pDll->FPICancel();
     if(iRet != FP_ERROR_SUCCESS)
     {
-        SaveErrorInfo(iRet);
+        sprintf(szErrorMsg, "取消采集指纹图片失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_FINGERPRINT_CANCEL, __FUNCTION__, __LINE__);
         LOG4VTM(INFO,"FingerPrintClassImpl::leave FingerPrint->Cancel() failed");
         return Error_DevMedia;
     }

DevAdapter/keba/FingerPrint.keba.1.1/fingerprint.h

@@ -79,9 +79,10 @@ private:
     bool m_bDevOpen;
     int m_nPort;
     CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
-    void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
-    void SaveErrorInfo(DevErrorInfo devErrorInfo);
-    void SaveErrorInfo(int nErrorCode);
+    void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
+    //void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+    //void SaveErrorInfo(DevErrorInfo devErrorInfo);
+    void SaveErrorInfo(int nErrorCode,const CHAR* strFunc = NULL, int nLine = 0);
     std::string m_LogFileNamePath;
     int m_nLogLevel;
     std::string m_strIniPath;

DevAdapter/keba/FingerPrint.keba.1.1/stdafx.h

@@ -17,8 +17,11 @@
 #include <dlfcn.h>
 
 // TODO: 在此处引用程序需要的其他头文件
-#include "DevErrorCode.h"
+#include "DepErrorCode.h"
 #include "TraceManager.h"
 #include "CommDef.h"
-
+//#include <QJsonParseError>  //https://www.cnblogs.com/whik/p/11234889.html
+//#include <QVariantMap>
+//#include <QJsonObject>
+//#include <QJsonArray>
 #endif // STDAFX_H

DevAdapter/keba/Gpio.keba.1.1/CMakeLists.txt

@@ -3,6 +3,9 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
+
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
     set(CMAKE_CXX_FLAGS "-std=c++11")
@@ -38,7 +41,8 @@ target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/ke
 target_link_libraries(${MODULE_FULL_NAME} ${VENDOR_LOG_LIB_NAME})
 #链接keba依赖库
 target_link_libraries(${MODULE_FULL_NAME} Common.keba)
-
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
 #设置动态库输出路径:/data/home/keba/DevAdapter/cmbsz/lib/gcc_aarch64或者gcc_x64
 SET(LIBRARY_OUTPUT_PATH ${VENDOR_CURRENT_LIB_DIR})
 message(STATUS "LIBRARY_OUTPUT_PATH: ${VENDOR_CURRENT_LIB_DIR}")

DevAdapter/keba/Gpio.keba.1.1/GpioClassImpl_DistrBusUSB.cpp

@@ -121,6 +121,7 @@ ErrorCodeEnum GpioClassImpl::Reset()
 	BYTE inBuffer[8]={0};
 	BYTE outBuffer[8]={0};
 	ULONG  bytesReturned = 0; 
+    char szErrorMsg[256] = {0};
 
     if(!m_bDevOpen)
 	{
@@ -132,7 +133,8 @@ ErrorCodeEnum GpioClassImpl::Reset()
 		}
 		if(DevOpen(initParam))
 		{
-			SaveErrorInfo("Reset(): returnError_DevNotAvailable",Error_DevNotAvailable );
+            sprintf(szErrorMsg, "打开设备失败");
+            SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
             LogM("Reset() return Error_DevNotAvailable");
             m_wDevStatus = DEVICE_STATUS_NOT_READY;
 			return Error_DevNotAvailable;
@@ -141,12 +143,16 @@ ErrorCodeEnum GpioClassImpl::Reset()
     if(KEBA_DevCtrl->Reset() != FALSE)
 	{
 //        LogM("Reset() OK!");
+        sprintf(szErrorMsg, "复位成功");
+        SaveErrorInfo(szErrorMsg, DEP_SUCCESS, __FUNCTION__, __LINE__);
         m_wDevStatus = DEVICE_STATUS_NORMAL;
 		return Error_Succeed;
 	}
 	else
 	{
         LogM("Reset() return Error_DevNotAvailable");
+        sprintf(szErrorMsg, "复位失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_GPIO_IOCONTROL, __FUNCTION__, __LINE__);
         m_wDevStatus = DEVICE_STATUS_FAULT;
 		return Error_DevNotAvailable;
 	}
@@ -207,6 +213,8 @@ ErrorCodeEnum GpioClassImpl::DevOpen(GpioInitParam initParam)
 //    dllPath += "keba/Adapter_L.keba.INI";
 //    memcpy(g_sIniPath, dllPath.c_str(), dllPath.length());
 
+    char szErrorMsg[256] = {0};
+
     CFileDir::GetFilePathName(
                 getpid(), "keba", "Adapter_L.keba.INI",
                 g_sIniPath, sizeof(g_sIniPath));
@@ -231,6 +239,8 @@ ErrorCodeEnum GpioClassImpl::DevOpen(GpioInitParam initParam)
     if(m_bDevOpen)
 	{
         m_wDevStatus = DEVICE_STATUS_NORMAL;
+        sprintf(szErrorMsg, "已经打开设备成功");
+        SaveErrorInfo(szErrorMsg, DEP_SUCCESS, __FUNCTION__, __LINE__);
 //        LogM("DevOpen() Dev is open already. Return Error_Succeed;");
 		return Error_Succeed;
 	}
@@ -242,12 +252,16 @@ ErrorCodeEnum GpioClassImpl::DevOpen(GpioInitParam initParam)
         LogM("DevOpen()->GetFileType() failed. return Error_DevNotAvailable;");
         DevClose();
         m_wDevStatus = DEVICE_STATUS_NOT_READY;
+        sprintf(szErrorMsg, "打开设备失败");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
 
 	m_bDevOpen = true;
 
     m_wDevStatus = DEVICE_STATUS_NORMAL;
+    sprintf(szErrorMsg, "打开设备成功");
+    SaveErrorInfo(szErrorMsg, DEP_SUCCESS, __FUNCTION__, __LINE__);
     return Error_Succeed;
 
    /*
@@ -290,10 +304,14 @@ ErrorCodeEnum GpioClassImpl::WritePort(DWORD dwPort, BYTE btData)
 		}
 	}
 
+    char szErrorMsg[256] = {0};
+
     if(!m_bDevOpen)
 	{
         LogM("WritePort() return Error_DevNotAvailable");
         m_wDevStatus = DEVICE_STATUS_NOT_READY;
+        sprintf(szErrorMsg, "没有打开设备");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
 		return Error_DevNotAvailable;
 	}
 	if(!m_dir[dwPort])
@@ -321,7 +339,6 @@ ErrorCodeEnum GpioClassImpl::WritePort(DWORD dwPort, BYTE btData)
 	iOutputs = 0;   //PinStatus need change,will put into buffer[4]~[7]
     BOOL bRet = FALSE;
     bool bIsOn[8] = {FALSE};
-    CHAR cErrmsg[128] = {0};
     WORD wOutputNobuf[8] = {0};
 
 	int iPin, iOutputNo;
@@ -417,10 +434,11 @@ ErrorCodeEnum GpioClassImpl::WritePort(DWORD dwPort, BYTE btData)
     bRet = KEBA_DevCtrl->SetGuidLight(wOutputNobuf, bIsOn, iCnt);
     if (bRet == FALSE)
     {
-        sprintf(cErrmsg, "SetGuidLight() Execute Fail");
-        SaveErrorInfo(cErrmsg, Error_DevNotAvailable);
+        sprintf(szErrorMsg, "SetGuidLight() 执行失败，点灯失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_GPIO_IOCONTROL, __FUNCTION__, __LINE__);
+
         LogM("WritePort()input parameter:dwPort:%d, btData:0x%02x", dwPort, btData);
-        LogM("WritePort()->SetGuidLight(): %s",cErrmsg);
+        LogM("WritePort()->SetGuidLight(): %s",szErrorMsg);
         m_wDevStatus = DEVICE_STATUS_FAULT;
         return Error_DevNotAvailable;
     }
@@ -439,10 +457,12 @@ ErrorCodeEnum GpioClassImpl::WritePort(DWORD dwPort, BYTE btData)
 ErrorCodeEnum GpioClassImpl::ReadPort(DWORD dwPort,BYTE &btStatus)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
 //    LogM("ReadPort()input parameter:dwPort:%d", dwPort);
     if(!m_bDevOpen)
 	{
-		SaveErrorInfo("ReadPort(): returnError_DevNotAvailable",Error_DevNotAvailable );
+        sprintf(szErrorMsg, "没有打开设备");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LogM("ReadPort() return Error_DevNotAvailable");
         m_wDevStatus = DEVICE_STATUS_NOT_READY;
 		return Error_DevNotAvailable;
@@ -464,7 +484,7 @@ ErrorCodeEnum GpioClassImpl::ReadPort(DWORD dwPort,BYTE &btStatus)
     int portno = 0;
     BOOL bRet = FALSE, bFailFlag = FALSE;
     WORD wStatus = 0;
-    CHAR cErrmsg[128] = {0};
+
 	memset(inBuffer, 0x00, 8);
 
 	btStatus = 0x00;
@@ -613,10 +633,10 @@ ErrorCodeEnum GpioClassImpl::ReadPort(DWORD dwPort,BYTE &btStatus)
 
         if (bRet == FALSE)
         {
-            sprintf(cErrmsg, "getChannelStatus(channel=%d) Execute Fail", iInputNo);
-            SaveErrorInfo(cErrmsg, Error_DevNotAvailable);
+            sprintf(szErrorMsg, "getChannelStatus(channel=%d) 执行失败，获取状态失败", iInputNo);
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_GPIO_IOCONTROL, __FUNCTION__, __LINE__);
             LogM("ReadPort()input parameter:dwPort:%d", dwPort);
-            LogM("WritePort()->SetGuidLight(): %s",cErrmsg);
+            LogM("WritePort()->SetGuidLight(): %s",szErrorMsg);
             bFailFlag = TRUE;
         }
         if(wStatus)
@@ -638,6 +658,7 @@ ErrorCodeEnum GpioClassImpl::ReadPort(DWORD dwPort,BYTE &btStatus)
 }
 
 //Private
+/*
 void GpioClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
 {
     LOG_FUNCTION();
@@ -647,16 +668,48 @@ void GpioClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
     sprintf(m_szErrMsg, "%s[%d]", errMsg, errCode);
 //    LogM("SaveErrorInfo() OK!");
 }
+*/
+
+void GpioClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
+{
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+
+
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+
+    QString strJson(root_str);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
+}
+
 
 ErrorCodeEnum GpioClassImpl::LightTurnOn()
 {
     LOG_FUNCTION();
     int iOutputNo = 0;
     char outputPin[20] = {0};
+    CHAR szErrorMsg[256] = {0};
 
     if(!m_bDevOpen)
 	{
         LogM("LightTurnOn() return Error_DevNotAvailable");
+        sprintf(szErrorMsg, "没有打开设备");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         m_wDevStatus = DEVICE_STATUS_NOT_READY;
 		return Error_DevNotAvailable;
 	}
@@ -664,7 +717,7 @@ ErrorCodeEnum GpioClassImpl::LightTurnOn()
 	BYTE outBuffer[8]={0};
 	ULONG  bytesReturned = 0; 
     BOOL bRet = FALSE;
-    CHAR cErrmsg[128] = {0};
+
     int iCnt = 0;
     WORD wOutputNoBuf[16] = {0};
     bool bOnStat[16] = {1};
@@ -759,9 +812,9 @@ ErrorCodeEnum GpioClassImpl::LightTurnOn()
     bRet = KEBA_DevCtrl->SetGuidLight(wOutputNoBuf, bOnStat, 16);
     if (bRet == FALSE)
     {
-        sprintf(cErrmsg, "SetGuidLight() Execute Fail");
-        SaveErrorInfo(cErrmsg, Error_DevNotAvailable);
-        LogM("WritePort()->SetGuidLight(): %s",cErrmsg);
+        sprintf(szErrorMsg, "SetGuidLight() 执行失败，点灯失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_GPIO_IOCONTROL, __FUNCTION__, __LINE__);
+        LogM("WritePort()->SetGuidLight(): %s",szErrorMsg);
         m_wDevStatus = DEVICE_STATUS_FAULT;
         return Error_DevNotAvailable;
     }

DevAdapter/keba/Gpio.keba.1.1/GpioClassImpl_DistrBusUSB.h

@@ -103,7 +103,8 @@ private:
     //CHAR m_szErrMsg[MAX_DEV_ERR_MSG];
     CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
     ErrorCodeEnum LightTurnOn();
-    void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+//    void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+    void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
     int CtlCode( int deviceType, int function, int method, int access )
     {
         return ((deviceType) << 16) | ((access) << 14) | ((function) << 2) | (method);

DevAdapter/keba/Gpio.keba.1.1/stdafx.h

@@ -1,4 +1,4 @@
-// stdafx.h : 标准系统包含文件的包含文件，
+// stdafx.h : 标准系统包含文件的包含文件，
 // 或是经常使用但不常更改的
 // 特定于项目的包含文件
 //
@@ -7,6 +7,10 @@
 
 
 // TODO: 在此处引用程序需要的其他头文件
+//#include <QJsonParseError>  //https://www.cnblogs.com/whik/p/11234889.html
+//#include <QVariantMap>
+//#include <QJsonObject>
+//#include <QJsonArray>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -23,5 +27,6 @@
 #include "portio_lib.h"
 #include "csinglelock.h"
 #include "CkLog.h"
-#include "DevErrorCode.h"
+#include "DepErrorCode.h"
+
 

DevAdapter/keba/HSPScanner.keba.1.2/CMakeLists.txt

@@ -5,7 +5,10 @@ rvc_dev_define_module("HSPScanner")
 set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "2")
+#set(CMAKE_PREFIX_PATH $ENV{QTDIR594})
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
 
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
@@ -32,10 +35,14 @@ rvc_dev_config_library(${MODULE_NAME} ${MODULE_PREFIX})
 
 #设置头文件查找路径变量
 target_include_directories(${MODULE_FULL_NAME} PUBLIC  ${INCLUDE_KEBA})
+message(STATUS "KEBA_include_directories: ${INCLUDE_KEBA}")
 
 #设置日志依赖库文件的路径变量路径
 target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${DEVADAPTER_CURRENT_LIB_DIR})
 
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
+
 #86下依赖的库连接这个文件路径:/data/home/keba/DevAdapter/keba/lib/gcc_x64?gcc_aarch64
 #target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR})
 target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/keba)

DevAdapter/keba/HSPScanner.keba.1.2/hspscannerimpl.cpp

@@ -70,6 +70,34 @@ HSPSClassImpl::~HSPSClassImpl()
     m_bShow = false;
 }
 
+int HSPSClassImpl::ErrorCodeConvert(int nErrorCode)
+{
+    switch (nErrorCode) {
+    case FR_RET_SUCC:
+        return DEP_SUCCESS;
+    case FR_RET_FAIL:
+        return DEP_NO_E_HSPSCANNER_FR_RET_FAIL;
+    case FR_RET_PARA:
+        return DEP_NO_E_HSPSCANNER_FR_RET_PARA;
+    case FR_RET_NDEV:
+        return DEP_NO_E_HSPSCANNER_FR_RET_NDEV;
+    case FR_RET_NINI:
+        return DEP_NO_E_HSPSCANNER_FR_RET_NINI;
+    case FR_RET_BUSY:
+        return DEP_NO_E_HSPSCANNER_FR_RET_BUSY;
+    case FR_RET_DATA:
+        return DEP_NO_E_HSPSCANNER_FR_RET_DATA;
+    case FR_RET_NLNK:
+        return DEP_NO_E_HSPSCANNER_FR_RET_NLNK;
+    case FR_RET_NMEM:
+        return DEP_NO_E_HSPSCANNER_FR_RET_NMEM;
+    case FR_RET_ARDY:
+        return DEP_NO_E_HSPSCANNER_FR_RET_ARDY;
+    default:
+        return DEP_ERROR_CODE_UNRECOGNIZABLE;
+    }
+}
+
 ErrorCodeEnum HSPSClassImpl::DevOpen()
 {
     LOG_FUNCTION();
@@ -84,16 +112,24 @@ ErrorCodeEnum HSPSClassImpl::DevOpen()
     if (nullptr == m_pDll)
     {
         LogM("HSPSClassImpl::Entry->HSPS DevOpen() new object CDevDllLoad failed!");
-        SaveErrorInfo("对象创建失败", DEC_DEV_OBJECT_CREATE_FAILED);
+        SaveErrorInfo("厂家库libBHCamBase.so调用失败", DEP_DLL_NOT_FOUND, __PRETTY_FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
+//    if(m_bDevOpen)
+//    {
+//        LogM("HSPSClassImpl::DevOpen() already open");
+//        SaveErrorInfo("高拍仪已经打开", DEP_ALREADY_EXIST, __PRETTY_FUNCTION__, __LINE__);
+//        return Error_DevAlreadyConnected;
+//    }
     iRet = m_pDll->HIGH_StartCamera();
     //记日志
     if(iRet != FR_RET_SUCC)
     {
         LogM("HSPSClassImpl::Entry->HSPS DevOpen()->m_pDll->HIGH_StartCamera() failed! <=> iRet = %d",iRet);
         m_bDevOpen = false;
-        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "设备打开失败，HIGH_StartCamera() =[%d] ", iRet);
+        SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
     LogM("HSPSClassImpl::Entry->HSPS DevOpen()->m_pDll->HIGH_StartCamera() success! <=> iRet = %d",iRet);
@@ -133,7 +169,7 @@ ErrorCodeEnum HSPSClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
     else
     {
         //memcpy(devCategory.szType, "PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]", strlen("PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]"));
-        SaveErrorInfo(iRet);
+        SaveErrorInfo("获取固件版本失败",ErrorCodeConvert(iRet),__PRETTY_FUNCTION__,__LINE__);
         return Error_DevConnFailed;
     }
     memcpy(devCategory.szVendor, "keba", strlen("keba"));
@@ -163,9 +199,21 @@ ErrorCodeEnum HSPSClassImpl::DevClose()
     }
     //CLOSEDEV();
 	iRet = m_pDll->HIGH_CloseWindow();
-	
+    if(iRet != FR_RET_SUCC)
+    {
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "窗口关闭失败，HIGH_CloseWindow() =[%d] ", iRet);
+        SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+    }
     iRet = m_pDll->HIGH_StopCamera();
     
+    if(iRet != FR_RET_SUCC)
+    {
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "摄像头关闭失败，HIGH_StopCamera() =[%d] ", iRet);
+        SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+    }
+
     if(iRet == FR_RET_SUCC)
         m_bPreview = false;
 
@@ -177,7 +225,7 @@ ErrorCodeEnum HSPSClassImpl::DevClose()
 
 ErrorCodeEnum HSPSClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
 {
-    LOG_FUNCTION();
+    /*LOG_FUNCTION();
     LogM("HSPSClassImpl::Entry->HSPS GetLastErr()!");
     devErrInfo.dwErrMsgLen = 0;
     memset(devErrInfo.szErrMsg, 0, sizeof(devErrInfo.szErrMsg));
@@ -187,6 +235,11 @@ ErrorCodeEnum HSPSClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
     devErrInfo.dwErrMsgLen += (strlen(devErrInfo.szErrMsg) & 0x0000FFFF);
     LogM("devErrInfo.szErrMsg = %s",devErrInfo.szErrMsg);
     LogM("HSPSClassImpl::Leave->HSPS GetLastErr() sucessfull!");
+    return Error_Succeed;*/
+    LOG_FUNCTION();
+    devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
+    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    memcpy(devErrInfo.szErrMsg, m_szErrMsg, devErrInfo.dwErrMsgLen<MAX_DEV_ERROR_MSG_LEN? devErrInfo.dwErrMsgLen:MAX_DEV_ERROR_MSG_LEN);
     return Error_Succeed;
 }
 
@@ -196,9 +249,10 @@ ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
     int iRet = -1;
     if(!m_bDevOpen)
     {
-        SaveErrorInfo("SetParam()->Dev is not open",Error_DevNotAvailable );
-        LogM("HSPSClassImpl::leave HSPS->SetParam() failed");
+        SaveErrorInfo("SetParam设备未打开，设置参数失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->SetParam() failed 设备未打开");
         return Error_DevNotAvailable;
+
     }
 	LogM("HSPSClassImpl::SetParam(type=%d,value=%d),line=%d",type,value,__LINE__);
     if(type == HSPS_MODEL_COLOR)
@@ -210,10 +264,21 @@ ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
             iRet = m_pDll->HIGH_SetColorType(1);
         }
         else {
-            SaveErrorInfo("SetParam()->ParamType COLOR ParamTypeValue error",Error_Param );
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam输入色彩参数有误，type[%d] value[%d]", type, value);
+            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
             LogM("HSPSClassImpl::leave HSPS->SetParam(COLOR) ParamTypeValue error(%d)", value);
             return Error_Param;
         }
+        if(iRet != FR_RET_SUCC)
+        {
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam色彩设置失败，type[%d] value[%d]，return[%d]", type, value,iRet);
+            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
+            return Error_DevMedia;
+        }
+
     }
     else if (type == HSPS_MODEL_ROTATE)
     {
@@ -230,10 +295,20 @@ ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
             iRet = m_pDll->HIGH_SetRotateSize(3);
 
         else {
-            SaveErrorInfo("SetParam()->ParamType ROTATE ParamTypeValue error",Error_Param );
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam输入旋转方向参数有误，type[%d] value[%d]", type, value);
+            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
             LogM("HSPSClassImpl::leave HSPS->SetParam(ROTATE) ParamTypeValue error(%d)", value);
             return Error_Param;
         }
+        if(iRet != FR_RET_SUCC)
+        {
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam图像旋转失败，type[%d] value[%d]，return[%d]", type, value,iRet);
+            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
+            return Error_DevMedia;
+        }
     }
     else if (type == HSPS_MODEL_SCANSIZE)
     {
@@ -254,13 +329,17 @@ ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
             //
 
         else {
-            SaveErrorInfo("SetParam()->ParamType SCANSIZE ParamTypeValue error",Error_Param );
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam自动纠偏参数有误，type[%d] value[%d]", type, value);
+            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
             LogM("HSPSClassImpl::leave HSPS->SetParam(SCANSIZE) ParamTypeValue error(%d)", value);
             return Error_Param;
         }
         if(iRet != FR_RET_SUCC)
         {
-            SaveErrorInfo(iRet);
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam自动纠偏设置失败，type[%d] value[%d]，return[%d]", type, value,iRet);
+            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
             LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
             return Error_DevMedia;
         }
@@ -275,26 +354,38 @@ ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
             iRet = m_pDll->HIGH_HideWindow(0);
 
         else {
-            SaveErrorInfo("SetParam()->ParamType VIEW ParamTypeValue error",Error_Param );
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetParam显示隐藏参数有误，type[%d] value[%d]", type, value);
+            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
             LogM("HSPSClassImpl::leave HSPS->SetParam(VIEW) ParamTypeValue error(%d)", value);
             return Error_Param;
         }
+        if(iRet != FR_RET_SUCC)
+        {
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "显示隐藏设置失败，type[%d] value[%d]，return[%d]", type, value,iRet);
+            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
+            return Error_DevMedia;
+        }
 
     }
     else
     {
-        SaveErrorInfo("SetParam()->ParamType error",Error_Param );
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "SetParam类型参数有误，type[%d] value[%d]", type, value);
+        SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
         LogM("HSPSClassImpl::leave HSPS->SetParam error(%d)", type);
         return Error_Param;
     }
 
-    if(iRet != FR_RET_SUCC)
-    {
-        SaveErrorInfo(iRet);
-        LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] error,line=%d",type,value,iRet,__LINE__);
-        return Error_DevMedia;
-    }
-                return Error_Succeed;
+//    if(iRet != FR_RET_SUCC)
+//    {
+//        SaveErrorInfo(iRet);
+//        LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] error,line=%d",type,value,iRet,__LINE__);
+//        return Error_DevMedia;
+//    }
+     return Error_Succeed;
 }
 
 ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
@@ -304,7 +395,7 @@ ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
     int iRet = -1;
     if(!m_bDevOpen)
     {
-        SaveErrorInfo("SetPreview()->Dev is not open",Error_DevNotAvailable );
+        SaveErrorInfo("SetPreview设备离线，打开预览失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
         LogM("HSPSClassImpl::leave HSPS->SetPreview() failed");
         return Error_DevNotAvailable;
     }
@@ -322,6 +413,9 @@ ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
         }
         else {
             LogM("HSPSClassImpl::SetPreview() DevStatus = [%d] DevError:1->OFFLIN,2->BUSY,3->HARDWAREERROR,4->UNKNOW,line=%d",DevStatus,__LINE__);
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetPreview设备状态异常，HIGH_GetStatus() =[%d] ", DevStatus);
+            SaveErrorInfo(strMsg, DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
             return Error_DevMedia;
         }
    }
@@ -329,18 +423,27 @@ ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
     {
         iRet = m_pDll->HIGH_CloseWindow();
         if(iRet == FR_RET_SUCC)
-            m_bShow = 0;           
+        {
+            m_bShow = 0;
             m_bPreview = false;
+        }
+        else
+        {
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "SetPreview关闭窗口失败，HIGH_CloseWindow() =[%d] ", iRet);
+            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+            return Error_DevMedia;
+        }
+
     }
 
     else {
-        SaveErrorInfo("SetPreview()->nValue error",Error_Param );
+        SaveErrorInfo("SetPreview参数错误",DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__ );
         LogM("HSPSClassImpl::leave HSPS->SetPreview(%d) error", nValue);
         return Error_Param;
     }
     if(iRet != FR_RET_SUCC)
     {
-        SaveErrorInfo(iRet);
         LogM("HSPSClassImpl::SetPreview(value=%d) = [%d] error,line=%d",nValue,iRet,__LINE__);
         return Error_DevMedia;
     }
@@ -356,8 +459,14 @@ ErrorCodeEnum HSPSClassImpl::ScanImage(const char* pszFileName)
     int iRet = -1;
     if(!m_bDevOpen)
     {
-        SaveErrorInfo("ScanImage()->Dev is not open",Error_DevNotAvailable );
-        LogM("HSPSClassImpl::leave HSPS->ScanImage() failed");
+        SaveErrorInfo("ScanImage设备未打开，打开预览失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->ScanImage() failed 设备未打开");
+        return Error_DevNotAvailable;
+    }
+    if(!m_bPreview)
+    {
+        SaveErrorInfo("ScanImage设备不在预览状态",DEP_NO_E_HSPSCANNER_NOT_IN_PREVIEW, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->ScanImage() failed 设备不在预览状态");
         return Error_DevNotAvailable;
     }
     iRet = m_pDll->HIGH_TakePicture(pszFileName);
@@ -365,11 +474,21 @@ ErrorCodeEnum HSPSClassImpl::ScanImage(const char* pszFileName)
     //iRet = m_pDll->HIGH_CreateWindow(m_nX, m_nY, 0, m_nWidth*9/16);
     if(iRet != FR_RET_SUCC)
     {
-        SaveErrorInfo(iRet);
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "ScanImage保存图片失败，HIGH_TakePicture(%s) =[%d] ",pszFileName,iRet);
+        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
         LogM("HSPSClassImpl::ScanImage(pszFileName=%s) = [%d] error,line=%d",pszFileName,iRet,__LINE__);
         return Error_DevMedia;
     }
     iRet = m_pDll->HIGH_HideWindow(TRUE);
+    if(iRet != FR_RET_SUCC)
+    {
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "ScanImage结束后，隐藏窗口失败，HIGH_HideWindow(TRUE) =[%d] ",iRet);
+        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::ScanImage(pszFileName=%s) = [%d] error,line=%d",pszFileName,iRet,__LINE__);
+        return Error_DevMedia;
+    }
     m_bShow = 0;
     return Error_Succeed;
 }
@@ -384,21 +503,31 @@ ErrorCodeEnum HSPSClassImpl::ScanImageEx(BYTE* pBtImg,  int& nBtLen, const char*
     int iRet = -1;
     if(!m_bDevOpen)
     {
-        SaveErrorInfo("ScanImageEx()->Dev is not open",Error_DevNotAvailable );
-        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed");
+        SaveErrorInfo("ScanImageEx设备未打开，打开预览失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 设备未打开");
+        return Error_DevNotAvailable;
+    }
+    if(!m_bPreview)
+    {
+        SaveErrorInfo("ScanImageEx设备不在预览状态",DEP_NO_E_HSPSCANNER_NOT_IN_PREVIEW, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 设备不在预览状态");
         return Error_DevNotAvailable;
     }
     iRet = m_pDll->HIGH_TakePicture("tmp.jpg");
     if(iRet != FR_RET_SUCC)
     {
-        SaveErrorInfo(iRet);
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "ScanImageEx保存临时图片失败，HIGH_TakePicture(tmp.jpg) =[%d] ",iRet);
+        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
         LogM("HSPSClassImpl::ScanImageEx HIGH_TakePicture = [%d] error,line=%d",iRet,__LINE__);
         return Error_DevMedia;
     }
     iRet = m_pDll->HIGH_HideWindow(TRUE);
     if(iRet != FR_RET_SUCC)
     {
-        SaveErrorInfo(iRet);
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "ScanImageEx结束后，隐藏窗口失败，HIGH_HideWindow(TRUE) =[%d] ",iRet);
+        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
         LogM("HSPSClassImpl::ScanImageEx HIGH_HideWindow = [%d] error,line=%d",iRet,__LINE__);
         return Error_DevMedia;
     }
@@ -418,8 +547,8 @@ ErrorCodeEnum HSPSClassImpl::ScanImageEx(BYTE* pBtImg,  int& nBtLen, const char*
         fclose(fp);
     }
     else {
-        SaveErrorInfo("ScanImageEx()->fopen tmp.jpg error",Error_NoTarget );
-        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed");
+        SaveErrorInfo("读取 tmp.jpg 失败",DEP_FILE_NOT_FOUND, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 读取 tmp.jpg 失败");
         return Error_NoTarget;
     }
     //memcpy(pBtImg, pFileData, file_size);
@@ -440,7 +569,7 @@ ErrorCodeEnum HSPSClassImpl::ScanImageEx(BYTE* pBtImg,  int& nBtLen, const char*
     {
         memcpy(pBtImg, pFileData, file_size);
         nBtLen = file_size;
-        SaveErrorInfo(iRet);
+        SaveErrorInfo("图片大小超限",DEP_LENGTH_LIMIT_EXCEEDED, __PRETTY_FUNCTION__, __LINE__);
         LogM("ScanImageEx()->nBtLen[%d] < file_size[%d]",nBtLen,file_size);
         return Error_TooSmallBuffer;
     }
@@ -458,8 +587,8 @@ ErrorCodeEnum HSPSClassImpl::SetViewPos(int nX, int nY, int nWidth)
     int iRet = -1;
     if(!m_bDevOpen)
     {
-        SaveErrorInfo("SetViewPos()->Dev is not open",Error_DevNotAvailable );
-        LogM("HSPSClassImpl::leave HSPS->SetViewPos() failed");
+        SaveErrorInfo("SetViewPos设备未打开，设置失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
+        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 设备未打开");
         return Error_DevNotAvailable;
     }
     if(nX >= 0 && nY >= 0 )
@@ -481,7 +610,9 @@ ErrorCodeEnum HSPSClassImpl::SetViewPos(int nX, int nY, int nWidth)
     }
     else
     {
-        SaveErrorInfo("SetViewPos()->Param < 0",Error_Param );
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "SetViewPos坐标参数有误，nX[%d] nY[%d]",nX,nY);
+        SaveErrorInfo(strMsg,DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
         LogM("HSPSClassImpl::leave HSPS->SetViewPos() failed");
         return Error_Param;
     }
@@ -508,7 +639,9 @@ ErrorCodeEnum HSPSClassImpl::SetViewPos(int nX, int nY, int nWidth)
             else
             {
 
-                SaveErrorInfo("SetViewPos()->Param < 0",Error_Param );
+                CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+                sprintf(strMsg, "SetViewPos宽度参数有误，nWidth[%d]",nWidth);
+                SaveErrorInfo(strMsg,DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
                 LogM("HSPSClassImpl::leave HSPS->SetViewPos() failed");
                 return Error_Param;
             }
@@ -543,7 +676,36 @@ ErrorCodeEnum HSPSClassImpl::GetDevStatus(HspsDevStatus& status)
     return Error_Succeed;
 }
 
-void HSPSClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
+void HSPSClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
+{
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
+    //QByteArray ba = strJson.toLatin1();
+    //char* sErrMsg = ba.data();
+    //memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
+    //sprintf(m_szErrMsg, sErrMsg);
+    //LogM(m_szErrMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
+}
+/*void HSPSClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
 {
     LOG_FUNCTION();
     LogM("HSPSClassImpl::Entry->HSPS SaveErrorInfo(CHAR* errMsg, int errCode)! <=> errMsg = %s errCode = %d",errMsg,errCode);
@@ -635,5 +797,5 @@ void HSPSClassImpl::SaveErrorInfo(int nErrorCode)
         break;
     }
     LogM("HSPSClassImpl::Leave->HSPS DevOpen()->m_pDll->SaveErrorInfo(int nErrorCode) sucessfull!");
-}
+}*/
 

DevAdapter/keba/HSPScanner.keba.1.2/hspscannerimpl.h

@@ -74,12 +74,15 @@ private:
     char m_strModulePath[256];
     short m_shErrCode;
     CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
-    void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+    /*void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
     void SaveErrorInfo(DevErrorInfo devErrorInfo);
-    void SaveErrorInfo(int nErrorCode);
+    void SaveErrorInfo(int nErrorCode);*/
+    void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
     bool DevWindow;
     int m_nX, m_nY, m_nWidth, m_nHeight,DevStatus;
 
+    int ErrorCodeConvert(int nErrorCode);
+
 };
 
 #endif // HSPSCANNERIMPL_H

DevAdapter/keba/HSPScanner.keba.1.2/stdafx.h

@@ -3,6 +3,13 @@
 // Ìض¨ÓÚÏîÄ¿µÄ°üº¬Îļþ
 //
 #pragma once
+//#include <QJsonParseError>
+
+//#include <QFile>
+//#include <QJsonDocument>
+//#include <QVariantMap>
+//#include <QJsonObject>
+//#include <QJsonArray>
 
 #include <stdio.h>
 #include <stdarg.h>
@@ -19,7 +26,7 @@
 #include "wintypes.h"
 
 #include "ErrorCode.h"
-#include "DevErrorCode.h"
+//#include "DevErrorCode.h"
 #include "HSPScannerClass.h"
-
+#include "DepErrorCode.h"
 #include "CkLog.h"

DevAdapter/keba/IDCertificate.keba.1.1/BS_ID81IDCLibImpl.cpp

@@ -1,4 +1,4 @@
-#include "stdafx.h"
+#include "stdafx.h"
 //ILog* g_pLog;
 extern mEnumScannerDevice               EnumScannerDevice;
 extern mOpenConnection                   OpenConnection;
@@ -39,13 +39,13 @@ extern mSetLog           SetLog;
 
 BS_ID81IDCLibImpl::BS_ID81IDCLibImpl(void)
 {
-    bool bTemp = false;
     char cTemp[256] = {0};
-    bTemp = load_so(cTemp);
-    LOG4VTM(INFO,("BS_ID81IDCLibImpl  creat function()!"));
-    if (bTemp == false)
+    m_bLoadLibRet = load_so(cTemp);
+    //LOG4VTM(INFO,("BS_ID81IDCLibImpl  creat function()!"));
+    if (m_bLoadLibRet == false)
     {
         printf("动态库加载失败！");
+        return;
     }
     bool Output = false;
     char LogPath[256] = {0};
@@ -68,7 +68,7 @@ int BS_ID81IDCLibImpl::EnumScannerDev(ScannerInfoRec *ScannerInfo, unsigned  *De
 {
     if (EnumScannerDevice == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = EnumScannerDevice(ScannerInfo, DeviceNumber);
 
@@ -80,7 +80,7 @@ int BS_ID81IDCLibImpl::OpenDev(unsigned DeviceID)
 {
     if (OpenConnection == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = OpenConnection(DeviceID);
     return nRet;
@@ -91,7 +91,7 @@ int BS_ID81IDCLibImpl::CloseDev(unsigned DeviceID)
 {
     if (CloseConnection == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = CloseConnection(DeviceID);
     return nRet;
@@ -101,7 +101,7 @@ int BS_ID81IDCLibImpl::CheckIdCard(unsigned DeviceID,int CheckTime)
 {
     if (CheckHaveIdCard == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = CheckHaveIdCard(DeviceID,CheckTime);
     return nRet;
@@ -112,7 +112,7 @@ int BS_ID81IDCLibImpl::CheckCardOut(unsigned DeviceID,int CheckTime)
 {
     if (TakeOutIdCard == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = TakeOutIdCard(DeviceID,CheckTime);
     return nRet;
@@ -123,7 +123,7 @@ int BS_ID81IDCLibImpl::StartScan(unsigned DeviceID)
 {
     if (StartScanIdCard == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = StartScanIdCard(DeviceID);
     return nRet;
@@ -134,7 +134,7 @@ int BS_ID81IDCLibImpl::ReadCard(unsigned DeviceID, char* cFrontImgBuf,char* cRea
 {
     if (SavePicToMemory == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = SavePicToMemory(DeviceID, cFrontImgBuf,cRearImgBuf, iFrontLen, iRearLen);
     return nRet;
@@ -145,7 +145,7 @@ int BS_ID81IDCLibImpl::SaveToFile(unsigned DeviceID, char *cBmpBuf, int iBufLen,
 {
     if (SavePicToFile == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = SavePicToFile(DeviceID, cBmpBuf, iBufLen,FileName, Format);
     return nRet;
@@ -156,7 +156,7 @@ int BS_ID81IDCLibImpl::RetainCard(unsigned DeviceID)
 {
     if (RetainIdCard == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = RetainIdCard(DeviceID);
     return nRet;
@@ -167,7 +167,7 @@ int BS_ID81IDCLibImpl::EjectIdCard(unsigned DeviceID)
 {
     if (BackIdCard == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = BackIdCard(DeviceID);
     return nRet;
@@ -178,7 +178,7 @@ int BS_ID81IDCLibImpl::BackAndHoldCard(unsigned DeviceID)
 {
     if (BackAndHoldIdCard == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = BackAndHoldIdCard(DeviceID);
     return nRet;
@@ -189,7 +189,7 @@ int BS_ID81IDCLibImpl::LastErrorCode()
 {
     if (GetLastErrorCode == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetLastErrorCode();
     return nRet;
@@ -201,7 +201,7 @@ int BS_ID81IDCLibImpl::LastErrorStr(char* errStr)
 {
     if (GetLastErrorStr == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetLastErrorStr(errStr);
     return nRet;
@@ -211,7 +211,7 @@ int BS_ID81IDCLibImpl::FWVersion(unsigned DeviceID,char *cVersionInfo)
 {
     if (GetFWVersion == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetFWVersion(DeviceID,cVersionInfo);
     return nRet;
@@ -222,7 +222,7 @@ int BS_ID81IDCLibImpl::GetInfo(unsigned DeviceID, IDInfo *mIDInfo, char *ImageNa
 {
     if (GetID2Info == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetID2Info(DeviceID, mIDInfo, ImageName);
     return nRet;
@@ -233,7 +233,7 @@ int BS_ID81IDCLibImpl::ResetDev(unsigned DeviceID)
 {
     if (ResetDevice == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = ResetDevice(DeviceID);
     return nRet;
@@ -244,7 +244,7 @@ int BS_ID81IDCLibImpl::Update(unsigned DeviceID,char *FileName)
 {
     if (UpdateOnLine == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = UpdateOnLine(DeviceID,FileName);
     return nRet;
@@ -255,7 +255,7 @@ int BS_ID81IDCLibImpl::CIS(unsigned DeviceID)
 {
     if (CISCalibrate == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = CISCalibrate(DeviceID);
     return nRet;
@@ -265,7 +265,7 @@ int BS_ID81IDCLibImpl::Sensor(unsigned DeviceID)
 {
     if (SensorCalibrate == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = SensorCalibrate(DeviceID);
     return nRet;
@@ -275,7 +275,7 @@ int BS_ID81IDCLibImpl::SWVersion(char *cVersionInfo)
 {
     if (GetSWVersion == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetSWVersion(cVersionInfo);
     return nRet;
@@ -286,7 +286,7 @@ int BS_ID81IDCLibImpl::DeviceStatus(unsigned DeviceID,DEVSTATUS *DevStatus)
 {
     if (GetDevStatus == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetDevStatus(DeviceID,DevStatus);
     return nRet;
@@ -296,7 +296,7 @@ int BS_ID81IDCLibImpl::ResetWithAction(unsigned DeviceID,int iMode)
 {
     if (SoftResetDevice == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = SoftResetDevice(DeviceID,iMode);
     return nRet;
@@ -306,7 +306,7 @@ int BS_ID81IDCLibImpl::GetMyIDCardInfo(unsigned DeviceID,int iCardType,void* idi
 {
     if (GetAllTypeIdInfo == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetAllTypeIdInfo(DeviceID, iCardType, idinfo, ImageName);
     return nRet;
@@ -316,7 +316,7 @@ int BS_ID81IDCLibImpl::GetMyIDCardType(unsigned DeviceID, int* iCardType)
 {
     if (GetIDCardType == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetIDCardType(DeviceID, iCardType);
     return nRet;
@@ -325,7 +325,7 @@ int BS_ID81IDCLibImpl::GetMyGATIDInfo(unsigned DeviceID, IDInfoGAT* mIDInfoGAT,
 {
     if (GetIDInfoGAT == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetIDInfoGAT(DeviceID, mIDInfoGAT, ImageName);
     return nRet;
@@ -335,7 +335,7 @@ int BS_ID81IDCLibImpl::GetAllTypeCardInfo(unsigned DeviceID,int iCardType,void*
 {
     if (GetAllTypeIdInfo == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = GetAllTypeIdInfo(DeviceID, iCardType,idinfo, ImageName);
     return nRet;
@@ -345,7 +345,7 @@ int BS_ID81IDCLibImpl::SetIDLog(bool Output, char* LogPath)
 {
     if (SetLog == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = SetLog(Output, LogPath);
     return nRet;
@@ -356,7 +356,7 @@ int BS_ID81IDCLibImpl::SetAutoFeedEnabled(unsigned DeviceID, int nMode)
 {
     if (SetAutoFeedEnable == NULL)
     {
-        return IDDIGITALCOPIER_PORT_ERROR;
+        return IDDIGITALCOPIER_HAVE_NOT_INIT;
     }
     int nRet = SetAutoFeedEnable(DeviceID, nMode);
     return nRet;

DevAdapter/keba/IDCertificate.keba.1.1/BS_ID81IDCLibImpl.h

@@ -53,6 +53,7 @@ public:
     int SetAutoFeedEnabled(unsigned DeviceID,int nMode);
 
 public:
+    BOOL m_bLoadLibRet;
     // -------2019-07-09----------------------
 
 };

DevAdapter/keba/IDCertificate.keba.1.1/CMakeLists.txt

@@ -3,6 +3,9 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
+
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
     set(CMAKE_CXX_FLAGS "-std=c++11")
@@ -37,7 +40,8 @@ target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/ke
 target_link_libraries(${MODULE_FULL_NAME} ${VENDOR_LOG_LIB_NAME})
 #链接keba依赖库
 target_link_libraries(${MODULE_FULL_NAME} Common.keba)
-
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
 #设置动态库输出路径:/data/home/keba/DevAdapter/cmbsz/lib/gcc_aarch64或者gcc_x64
 SET(LIBRARY_OUTPUT_PATH ${VENDOR_CURRENT_LIB_DIR})
 message(STATUS "LIBRARY_OUTPUT_PATH: ${VENDOR_CURRENT_LIB_DIR}")

DevAdapter/keba/IDCertificate.keba.1.1/idcertificate.cpp

@@ -1,4 +1,4 @@
-#include "idcertificate.h"
+#include "idcertificate.h"
 #include <stdarg.h>
 #include "log4vendor.h"
 #include "stdafx.h"
@@ -66,8 +66,10 @@ m_bDevOpen(false)
     ,m_iCardType(-1)
 {
     LOG_FUNCTION();
-    SecDeviceNum = 0;
+    m_SecDeviceNum = 0xFF;
     m_wDevStatus = DEVICE_STATUS_NOT_READY;
+
+    memset(m_szErrMsg, 0x00, MAX_DEV_ERROR_MSG_LEN);
 }
 
 IDCerClassImpl::~IDCerClassImpl()
@@ -75,7 +77,8 @@ IDCerClassImpl::~IDCerClassImpl()
     LOG_FUNCTION();
     m_bDevOpen = false;
     DevClose();
-    SecDeviceNum = 0;
+    m_SecDeviceNum = 0xFF;
+    memset(m_szErrMsg, 0x00, MAX_DEV_ERROR_MSG_LEN);
     std::string tmpPath = "";
     m_wDevStatus = DEVICE_STATUS_NOT_READY;
     if( GetDllPathLocal(tmpPath) == Error_Succeed )
@@ -177,26 +180,6 @@ ErrorCodeEnum IDCerClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
     devCategory.version.wRevision = 0xffff;
     devCategory.version.wBuild = 2;
 
-//    char szFwVer[256] = {0};
-//    char szSwVer[256] = {0};
-//    int nRet = m_cBS_ID81IDCImpl.FWVersion(SecDeviceNum, szFwVer);
-//    if (nRet == IDDIGITALCOPIER_NO_ERROR)
-//    {
-//        nRet = m_cBS_ID81IDCImpl.SWVersion(szSwVer);
-//        if (nRet == IDDIGITALCOPIER_NO_ERROR)
-//        {
-//            sprintf(devCategory.szType, "PVER=SNBC#MID=ID8101.%s-%s", szFwVer, szSwVer);
-//        }
-//        else
-//        {
-//            sprintf(devCategory.szType, "PVER=SNBC#MID=ID8101.%s", szFwVer);
-//        }
-//    }
-//    else
-//    {
-//        memcpy(devCategory.szType, "PVER=SNBC#MID=", strlen("PVER=SNBC#MID="));
-//    }
-
     memcpy(devCategory.szModel, "STYLE=IG#FUNCTION=ITF", strlen("STYLE=IG#FUNCTION=ITF"));
     LogM("GetDevCategory() return:\n\
                       devCategory.szType=%s,\n\
@@ -218,20 +201,20 @@ ErrorCodeEnum IDCerClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
 
     DEVSTATUS m_DeviceStatus;
     memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
-    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
+    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
     if (nRet == IDDIGITALCOPIER_PORT_ERROR)
     {
         sleep(1);
-        DevOpen(SecDeviceNum);
-        nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
-        if (nRet == IDDIGITALCOPIER_PORT_ERROR)
+        DevOpen(m_SecDeviceNum);
+        nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
+        if (nRet != IDDIGITALCOPIER_NO_ERROR)
         {
-            SaveErrorInfo("通讯异常", Error_DevCommFailed);
-            LogM("DeviceStatus(), 通讯异常, nRet=%d,line=%d", nRet, __LINE__);
+            SaveErrorInfo(__LINE__, __FUNCTION__);
+            LogM("GetDevCategory->DeviceStatus()失败, nRet=%d,line=%d", nRet, __LINE__);
             m_wDevStatus = DEVICE_STATUS_FAULT;
         }
     }
-
+    LogM("GetDevCategory() Succeed.");
     return Error_Succeed;
 }
 
@@ -249,17 +232,17 @@ ErrorCodeEnum IDCerClassImpl::Reset()
          if (DevOpen(0) != Error_Succeed)
          {
              m_wDevStatus = DEVICE_STATUS_NOT_READY;
-             SaveErrorInfo("设备未打开", Error_DevNotAvailable);
-             LogM("Reset(), 设备未打开, nRet=%d,line=%d", Error_DevNotAvailable, __LINE__);
+             SaveErrorInfo("Reset()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+             LogM("Reset()设备未打开, nRet=%d,line=%d", Error_DevNotAvailable, __LINE__);
              return Error_DevNotAvailable;
          }
     }
 
-    int nRet = m_cBS_ID81IDCImpl.ResetWithAction(SecDeviceNum, 0);//复位模式，0---退卡，1---吞卡，2---退卡并持卡，3---无动作。
+    int nRet = m_cBS_ID81IDCImpl.ResetWithAction(m_SecDeviceNum, 0);//复位模式，0---退卡，1---吞卡，2---退卡并持卡，3---无动作。
     if (IDDIGITALCOPIER_NO_ERROR != nRet)
     {
         m_wDevStatus = DEVICE_STATUS_FAULT;
-        SaveErrorInfo("设备通信异常", Error_DevConnFailed);
+        SaveErrorInfo(__LINE__, __FUNCTION__);
         LogM("Reset() 复位模式， 0-- 退卡 动作失败,line=%d", __LINE__);
         return Error_DevConnFailed;
     }
@@ -276,13 +259,30 @@ ErrorCodeEnum IDCerClassImpl::DevClose()
 {
     LOG_FUNCTION();
     LogM("DevClose() Entry.");
-    m_wDevStatus = DEVICE_STATUS_NOT_READY;
-    int nRet = m_cBS_ID81IDCImpl.CloseDev(SecDeviceNum);
+//    if(!m_bDevOpen)
+//    {
+//        LogM("DevClose()设备未打开, line=%d", __LINE__);
+//        return Error_Succeed;
+//    }
 
+    m_wDevStatus = DEVICE_STATUS_NOT_READY;
+    if (m_SecDeviceNum < 0 || m_SecDeviceNum > 16)
+    {
+        return Error_Succeed;
+    }
+    int nRet = m_cBS_ID81IDCImpl.CloseDev(m_SecDeviceNum);
+    if (IDDIGITALCOPIER_NO_ERROR != nRet)
+    {
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        LogM("DevClose(m_SecDeviceNum = %d)失败, nRet=%d,line=%d", m_SecDeviceNum, nRet, __LINE__);
+        return Error_DevConnFailed;
+    }
     m_bDevOpen = false;
     m_bAuthed = false;
     m_iCardType = -1;
-    LogM("DevClose(SecDeviceNum = %d), nRet=%d,line=%d", SecDeviceNum, nRet, __LINE__);
+    //m_SecDeviceNum = 0xFF;
+
+    LogM("DevClose(m_SecDeviceNum = %d) ok, nRet=%d,line=%d", m_SecDeviceNum, nRet, __LINE__);
     return Error_Succeed;
 }
 
@@ -316,24 +316,47 @@ ErrorCodeEnum IDCerClassImpl::DevOpen(DWORD dwPort)
     m_bAuthed = false;
     m_iCardType = -1;
 
-    DevClose();
+    if(m_cBS_ID81IDCImpl.m_bLoadLibRet == false)
+    {
+        SaveErrorInfo("DevOpen()动库加载失败", DEP_NO_E_IDCERTIFICATE_TABPAR_NONE, __FUNCTION__, __LINE__);
+        SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
+        SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
+        SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
+        LogE("DevOpen()动态库加载失败 nRet=%d,line=%d", Error_DevLoadFileFailed, __LINE__);
+        return Error_DevLoadFileFailed;
+    }
+	
+     ErrorCodeEnum nRetCode = DevClose();
+    if (nRetCode != Error_Succeed)
+    {
+        //m_bDevOpen = false;
+        m_wDevStatus = DEVICE_STATUS_NOT_READY;
+        SaveErrorInfo("DevOpen()->DevClose()关闭端口失败", DEP_DEV_NOT_FOUND, __FUNCTION__, __LINE__);
+        SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
+        SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
+        SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
+        LogE("DevOpen()->DevClose()关闭端口失败 nRet=%d,line=%d", nRetCode, __LINE__);
+        return nRetCode;
+    }
+
     int nRet = m_cBS_ID81IDCImpl.EnumScannerDev(ScannerInfo, &DevNumber);
     if (DevNumber <= 0)
     {
-        m_bDevOpen = false;
+        //m_bDevOpen = false;
         m_wDevStatus = DEVICE_STATUS_NOT_READY;
-        SaveErrorInfo("未找到设备", Error_DevNotAvailable);
+		SaveErrorInfo("DevOpen()未找到设备", DEP_DEV_NOT_FOUND, __FUNCTION__, __LINE__);
         SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
         SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
         SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
+		LogE("DevOpen() 未找到设备 nRet=%d,line=%d", Error_DevNotAvailable, __LINE__);
         return Error_DevNotAvailable;
     }
 
     for (unsigned int i = 0; i < DevNumber; i++)
     {
-        SecDeviceNum = ScannerInfo[i].DeviceID;
-        printf(" SecDeviceNum=%d", SecDeviceNum);
-        nRet = m_cBS_ID81IDCImpl.OpenDev(SecDeviceNum);
+        m_SecDeviceNum = ScannerInfo[i].DeviceID;
+        printf(" m_SecDeviceNum=%d", m_SecDeviceNum);
+        nRet = m_cBS_ID81IDCImpl.OpenDev(m_SecDeviceNum);
         if (IDDIGITALCOPIER_NO_ERROR == nRet)
         {
             m_bDevOpen = true;
@@ -341,17 +364,17 @@ ErrorCodeEnum IDCerClassImpl::DevOpen(DWORD dwPort)
             SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
             SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
             SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
-            LogM("DevOpen(), SecDeviceNum = %d, nRet=%d,line=%d", SecDeviceNum, nRet, __LINE__);
+            LogM("DevOpen()成功, m_SecDeviceNum = %d, nRet=%d,line=%d", m_SecDeviceNum, Error_Succeed, __LINE__);
             return Error_Succeed;
         }
     }
-    m_bDevOpen = false;
+    //m_bDevOpen = false;
     m_wDevStatus = DEVICE_STATUS_NOT_READY;
-    SaveErrorInfo("设备通信异常", Error_DevConnFailed);
+    SaveErrorInfo(__LINE__, __FUNCTION__);
     SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
     SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
     SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
-    LogE("DevOpen, 设备通信异常, nRet = %d,line=%d ", nRet, __LINE__);
+    LogE("DevOpen()设备通信异常, nRet = %d,line=%d ", Error_DevConnFailed, __LINE__);
     return Error_DevConnFailed;
 }
 //
@@ -364,93 +387,25 @@ ErrorCodeEnum IDCerClassImpl::IDCerRFControl(bool bControl)
 {
     LOG_FUNCTION();
     LogM("IDCerRFControl(), bControl = %d", bControl);
+	if(!m_bDevOpen)
+	{
+		SaveErrorInfo("IDCerRFControl()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+		return Error_DevNotAvailable;
+	}
     if (bControl)
     {
-        /*
-        //------------2019-07-19--------根据DevTestTool连续测试的指令流程，应在此处检测入卡；
-        //IDCerAuthenticate();
-        DWORD	dwStart = GetTickCount();
-        DWORD	dwNow = dwStart;
-        DEVSTATUS m_DeviceStatus;
-        int pos = -1;
-        int nRet;
-        bool bCard = false;
-        while ((dwNow - dwStart) <= 1000)
-        {
-            pos = -1;
-            memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
-            nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
-            if (nRet != IDDIGITALCOPIER_NO_ERROR)
-            {
-                char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-                sprintf(err, "通讯异常%d", nRet);
-                SaveErrorInfo(err, Error_DevCommFailed);
-                //m_cBS_ID81IDCImpl.ResetDev(SecDeviceNum);
-                return Error_DevCommFailed;
-                //SaveErrorInfo("通讯异常", Error_DevCommFailed);
-                //return Error_DevCommFailed;
-            }
-            if ((m_DeviceStatus.iStatusInputSensorHaveCard == 1) &&
-                (m_DeviceStatus.iStatusMiddleSensorHaveCard == 0) &&
-                (m_DeviceStatus.iStatusScanSensorHaveCard ==0))
-            {
-                pos = 2;
-            }
-            else if ((m_DeviceStatus.iStatusMiddleSensorHaveCard == 1) ||
-                     (m_DeviceStatus.iStatusScanSensorHaveCard ==1))
-            {
-                pos = 1;
-            }
-            else
-            {
-                pos = 0;
-            }
-            if (pos <= 0)
-            {
-                Sleep(100);
-                dwNow = GetTickCount();
-            }
-            else
-            {
-                bCard = true;
-                break;
-            }
-        }
-        if (!bCard)
-        {
-            SaveErrorInfo("未检测到卡", Error_Unexpect);
-            return Error_Unexpect;
-        }
-
-        nRet = m_cBS_ID81IDCImpl.CheckIdCard(SecDeviceNum, 100);
-        if ((IDDIGITALCOPIER_TIMEOUT_ERROR == nRet) ||
-            (IDDIGITALCOPIER_NO_CARD == nRet))
-        {
-            //2019-02-28 《可视化柜台设备厂商适配器开发说明文档V1.3.doc》 P12关于身份证读卡器改造说明
-            //1.	检测到有卡片插入/放置，但不是身份证时，IDCerAuthenticate返回Error_DevMedia；
-            //2.	未检测到卡片插入/放置，IDCerAuthenticate返回Error_Unexpect；
-            //3.	检测到身份证且认证成功（注意：部分厂商不做卡认证直接返回成功，需要根据实际情况按照步骤1和2返回对应值），IDCerAuthenticate返回Error_Succeed。
-            //SaveErrorInfo("未检测到卡", Error_DevMedia);
-            //printf(" SecDeviceNum=%d",SecDeviceNum);
-            //return Error_DevMedia;
-            SaveErrorInfo("未检测到卡", Error_Unexpect);
-            return Error_Unexpect;
-        }
-        else if (IDDIGITALCOPIER_NO_ERROR != nRet)
-        {
-            char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-            sprintf(err, "通讯失败%d", nRet);
-            SaveErrorInfo(err, Error_DevConnFailed);
-            //m_cBS_ID81IDCImpl.ResetDev(SecDeviceNum);
-            return Error_DevConnFailed;
-        }
-        */
+        
     }
     else
     {
-        ForceIDEject();
+		ErrorCodeEnum nRet = ForceIDEject();
+		if(nRet != Error_Succeed)
+		{
+			LogM("IDCerRFControl->ForceIDEject(), nRet = %d,line=%d", Error_Succeed, __LINE__);
+			return nRet;
+		}
     }
-    LogM("IDCerRFControl(), nRet = %d,line=%d", Error_Succeed, __LINE__);
+    LogM("IDCerRFControl() success, nRet = %d,line=%d", Error_Succeed, __LINE__);
     return Error_Succeed;
 }
 
@@ -462,10 +417,19 @@ ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
 {
     LOG_FUNCTION();
     LogM("IDCerAuthenticate() Entry.");
+    if(!m_bDevOpen)
+    {
+        SaveErrorInfo("IDCerAuthenticate()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+        LogM("IDCerAuthenticate()设备未打开, line=%d", __LINE__);
+        return Error_DevNotAvailable;
+    }
     int nRet = 0;
     ErrorCodeEnum nRetErr =OnCheckCard();
     if (nRetErr  != Error_Succeed)
     {
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        //SaveErrorInfo("IDCerAuthenticate()->OnCheckCard()未检测到卡", DEP_NO_E_IDCERTIFICATE_NO_CARD, __FUNCTION__, __LINE__);
+        LogM("IDCerAuthenticate()->OnCheckCard()未检测到卡, nRet=%d,line=%d", nRetErr, __LINE__);
         return nRetErr;
     }
     LogM("IDCerAuthenticate():CheckIdCard检测到卡并已吸入, nRet=%d,line=%d", nRetErr, __LINE__);
@@ -483,29 +447,29 @@ ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
     memcpy(FileName0, dllPath.c_str(), dllPath.length());
     std::string strLog = "IDCerAuthenticate(),PhotoPath=[" + dllPath + "]";
     LogM("%s,line=%d",strLog.c_str(), __LINE__);
-    nRet = m_cBS_ID81IDCImpl.GetMyIDCardType(SecDeviceNum, &iCardType);
+    nRet = m_cBS_ID81IDCImpl.GetMyIDCardType(m_SecDeviceNum, &iCardType);
     if(nRet == IDDIGITALCOPIER_NO_ERROR)
     {
 
     }
     else if (nRet == IDDIGITALCOPIER_IDDATA_PROCESS_ERROR)
     {
-        SaveErrorInfo("无效卡", Error_DevMedia);
-         LogE("IDCerAuthenticate()，无效卡, nRet=%d,line=%d", Error_DevMedia, __LINE__);
+         SaveErrorInfo("IDCerAuthenticate()->GetMyIDCardType()无效卡", DEP_NO_E_IDCERTIFICATE_INVALID_CARD, __FUNCTION__, __LINE__);
+         LogE("IDCerAuthenticate()->GetMyIDCardType()无效卡, nRet=%d,line=%d", Error_DevMedia, __LINE__);
         return Error_DevMedia;
     }
     else if (IDDIGITALCOPIER_STATUS_PASSAGE_JAM == nRet)
     {
         char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-        sprintf(err, "塞卡%d", nRet);
-        SaveErrorInfo(err, Error_Unexpect);
-        LogE("IDCerAuthenticate()，塞卡，nRet=%d, SecDeviceNum=%d,line=%d", nRet, SecDeviceNum, __LINE__);
+        sprintf(err, "IDCerAuthenticate()->GetMyIDCardType()塞卡%d", nRet);
+        SaveErrorInfo(err, DEP_NO_E_IDCERTIFICATE_PASSAGE_JAM, __FUNCTION__, __LINE__);
+        LogE("IDCerAuthenticate()->GetMyIDCardType()塞卡，nRet=%d, m_SecDeviceNum=%d,line=%d", nRet, m_SecDeviceNum, __LINE__);
         return Error_Unexpect;
     }
     else
     {
-        SaveErrorInfo("通讯异常", Error_DevCommFailed);
-        LogE("IDCerAuthenticate()，通讯异常%d，nRet=%d,line=%d", nRet, Error_DevCommFailed, __LINE__);
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        LogE("IDCerAuthenticate()->GetMyIDCardType()异常%d，nRet=%d,line=%d", nRet, Error_DevCommFailed, __LINE__);
         m_wDevStatus = DEVICE_STATUS_FAULT;
         return Error_DevCommFailed;
     }
@@ -529,12 +493,12 @@ ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
     }
     if (iCardType == 2)
     {
-        nRet = m_cBS_ID81IDCImpl.GetMyGATIDInfo(SecDeviceNum, &m_IDInfoGAT, FileName0);
+        nRet = m_cBS_ID81IDCImpl.GetMyGATIDInfo(m_SecDeviceNum, &m_IDInfoGAT, FileName0);
 
     }
     else
     {
-        nRet = m_cBS_ID81IDCImpl.GetAllTypeCardInfo(SecDeviceNum, iCardType, AllTypeInfo, FileName0);
+        nRet = m_cBS_ID81IDCImpl.GetAllTypeCardInfo(m_SecDeviceNum, iCardType, AllTypeInfo, FileName0);
     }
 
 
@@ -542,32 +506,29 @@ ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
     {
         LogM("IDCerAuthenticate()，认证成功,line=%d", __LINE__);
     }
-    else if ((nRet == IDDIGITALCOPIER_NO_ERROR) ||
-        (nRet == IDDIGITALCOPIER_IDDATA_PROCESS_ERROR))    //身份证电子信息处理错误
+    else if(nRet == IDDIGITALCOPIER_IDDATA_PROCESS_ERROR)    //身份证电子信息处理错误
     {
-        SaveErrorInfo("无效卡", Error_DevMedia);
+        SaveErrorInfo("IDCerAuthenticate()无效卡", DEP_NO_E_IDCERTIFICATE_UNAUTHED, __FUNCTION__, __LINE__);
         LogE("IDCerAuthenticate()，无效卡, nRet=%d,line=%d", Error_DevMedia, __LINE__);
         return Error_DevMedia;
     }
     else if (IDDIGITALCOPIER_STATUS_PASSAGE_JAM == nRet)
     {
         char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-        sprintf(err, "塞卡%d", nRet);
-        SaveErrorInfo(err, Error_Unexpect);
-        LogE("IDCerAuthenticate()，塞卡，nRet=%d, SecDeviceNum=%d,line=%d", nRet, SecDeviceNum, __LINE__);
+        sprintf(err, "IDCerAuthenticate()塞卡%d", nRet);
+        SaveErrorInfo(err, DEP_NO_E_IDCERTIFICATE_PASSAGE_JAM, __FUNCTION__, __LINE__);
+        LogE("IDCerAuthenticate()，塞卡，nRet=%d, m_SecDeviceNum=%d,line=%d", nRet, m_SecDeviceNum, __LINE__);
         return Error_Unexpect;
     }
     else
     {
-        char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-        sprintf(err, "通讯失败%d", nRet);
-        SaveErrorInfo(err, Error_DevConnFailed);
-        LogE("IDCerAuthenticate()通讯失败, nRet=%d,line=%d", Error_DevCommFailed, __LINE__);
+        SaveErrorInfo(__LINE__,__FUNCTION__);
+        LogE("IDCerAuthenticate()获取卡片信息失败, nRet=%d,line=%d", Error_DevCommFailed, __LINE__);
         m_wDevStatus = DEVICE_STATUS_FAULT;
         return Error_DevConnFailed;
     }
     m_bAuthed = true;     // true：认证成功；
-    m_iCardType = iCardType;    // 认证成功后，卡的类型；
+    m_iCardType = iCardType;    //认证成功后，卡的类型；
     LogM("IDCerAuthenticate(), nRet=%d,line=%d", Error_Succeed, __LINE__);
     return Error_Succeed;
 }
@@ -579,9 +540,17 @@ ErrorCodeEnum IDCerClassImpl::IDCerGetData(IDCerInfo &idCerInfo)
     LOG_FUNCTION();
     LogM("IDCerGetData() Entry,line=%d", __LINE__);
 
+    if(!m_bDevOpen)
+    {
+        SaveErrorInfo("IDCerGetData()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+        LogM("IDCerGetData()设备未打开, line=%d", __LINE__);
+        return Error_DevNotAvailable;
+    }
+
     if (!m_bAuthed)
     {
-        SaveErrorInfo("未认证成功。", Error_DevMedia);
+        //SaveErrorInfo(__LINE__, __FUNCTION__);
+        SaveErrorInfo("IDCerGetData()未认证成功", DEP_NO_E_IDCERTIFICATE_UNAUTHED, __FUNCTION__, __LINE__);
         LogE("IDCerGetData()，未认证成功, nRet=%d,line=%d", Error_DevMedia, __LINE__);
         return Error_DevMedia;
     }
@@ -888,7 +857,7 @@ ErrorCodeEnum IDCerClassImpl::IDCerGetData(IDCerInfo &idCerInfo)
     else
     {
         //无效卡（这里包括港澳台居住证，因为未接到招行提出改造此接口要求；）
-        SaveErrorInfo("无效卡", Error_DevMedia);
+        SaveErrorInfo("IDCerGetData()无效卡", DEP_NO_E_IDCERTIFICATE_INVALID_CARD, __FUNCTION__, __LINE__);
         LogE("IDCerGetData(), 无效卡, nRet=%d", Error_DevMedia);
         return Error_DevMedia;
     }
@@ -910,9 +879,17 @@ ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx(IDCerInfoEx &idCerInfoEx)
 {
     LOG_FUNCTION();
 
+    if(!m_bDevOpen)
+    {
+        SaveErrorInfo("IDCerGetDataEx()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+        LogM("IDCerGetDataEx()设备未打开, line=%d", __LINE__);
+        return Error_DevNotAvailable;
+    }
+
     if (!m_bAuthed)
     {
-        SaveErrorInfo("未认证成功。", Error_DevMedia);
+        //SaveErrorInfo(__LINE__, __FUNCTION__);
+        SaveErrorInfo("未认证成功。", DEP_NO_E_IDCERTIFICATE_UNAUTHED, __FUNCTION__, __LINE__);
         LogE("IDCerGetDataEx()，未认证成功, nRet=%d", Error_DevMedia);
         return Error_DevMedia;
     }
@@ -1407,7 +1384,7 @@ ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx(IDCerInfoEx &idCerInfoEx)
     else
     {
         //无效卡（这里包括港澳台居住证，因为未接到招行提出改造此接口要求；）
-        SaveErrorInfo("无效卡", Error_DevMedia);
+        SaveErrorInfo("IDCerGetDataEx()无效卡", DEP_NO_E_IDCERTIFICATE_INVALID_CARD, __FUNCTION__, __LINE__);
         //g_pLog->Print("IDCerGetDataEx(), 无效卡, nRet=%d", Error_DevMedia);
         return Error_DevMedia;
     }
@@ -1431,28 +1408,43 @@ ErrorCodeEnum IDCerClassImpl::ForceIDEject()
     LOG_FUNCTION();
     LogM("ForceIDEject() Entry,line=%d", __LINE__);
 
+//    if(!m_bDevOpen)
+//    {
+//        SaveErrorInfo("ForceIDEject()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+//        LogM("ForceIDEject()设备未打开, line=%d", __LINE__);
+//        return Error_DevNotAvailable;
+//    }
+
     int pos = -1;
     ErrorCodeEnum nRet = QueryCardPos(pos);
     if ((nRet == Error_Succeed) && pos == 0)
     {
-        SaveErrorInfo("未检测到卡", Error_DevMedia);
+		SaveErrorInfo("ForceIDEject()未检测到卡", DEP_NO_E_IDCERTIFICATE_NO_CARD, __FUNCTION__, __LINE__);
         LogM("ForceIDEject(), 未检测到卡, nRet=%d,line=%d", Error_DevMedia, __LINE__);
         //return Error_DevMedia;
     }
-    int bRet = m_cBS_ID81IDCImpl.EjectIdCard(SecDeviceNum);
+    int bRet = m_cBS_ID81IDCImpl.EjectIdCard(m_SecDeviceNum);
     if (bRet != IDDIGITALCOPIER_NO_ERROR)
     {
-        SaveErrorInfo("通讯异常", Error_DevCommFailed);
-        LogM("ForceIDEject(), 通讯异常, nRet=%d, SecDeviceNum = %d,line=%d", bRet, SecDeviceNum, __LINE__);
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        LogM("ForceIDEject(), 异常, nRet=%d, m_SecDeviceNum = %d,line=%d", bRet, m_SecDeviceNum, __LINE__);
         return Error_DevCommFailed;
     }
-    LogM("ForceIDEject(), nRet=%d, SecDeviceNum = %d,line=%d", bRet, SecDeviceNum, __LINE__);
+    LogM("ForceIDEject(), nRet=%d, m_SecDeviceNum = %d,line=%d", bRet, m_SecDeviceNum, __LINE__);
     return Error_Succeed;
 }
 
 ErrorCodeEnum IDCerClassImpl::ScanIDAndSaveImage()
 {
     LOG_FUNCTION();
+    LogM("ScanIDAndSaveImage Entry, nRet=%d", Error_Succeed);
+
+//    if(!m_bDevOpen)
+//    {
+//        SaveErrorInfo("ScanIDAndSaveImage()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+//        LogM("ScanIDAndSaveImage()设备未打开, line=%d", __LINE__);
+//        return Error_DevNotAvailable;
+//    }
 
     memset(PhotoPath, 0, MAX_FILE_PATH);
     std::string dllPath = "";
@@ -1467,64 +1459,98 @@ ErrorCodeEnum IDCerClassImpl::ScanIDAndSaveImage()
 
     DEVSTATUS m_DeviceStatus;
     memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
-    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
+    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
     if (nRet == IDDIGITALCOPIER_PORT_ERROR)
     {
         sleep(1);
-        DevOpen(SecDeviceNum);
-        nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
-        if (nRet == IDDIGITALCOPIER_PORT_ERROR)
+        DevOpen(m_SecDeviceNum);
+        nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
+        if (nRet != IDDIGITALCOPIER_NO_ERROR)
         {
-            SaveErrorInfo("通讯异常", Error_DevCommFailed);
-            LogM("DeviceStatus(), 通讯异常, nRet=%d,line=%d", nRet, __LINE__);
+            SaveErrorInfo(__LINE__, __FUNCTION__);
+            LogM("ScanIDAndSaveImage()->DeviceStatus()失败, nRet=%d,line=%d", nRet, __LINE__);
             m_wDevStatus = DEVICE_STATUS_FAULT;
             return Error_DevCommFailed;
         }
     }
-    LogM("DeviceStatus()正常, nRet=%d, line=%d", nRet, __LINE__);
-    nRet = m_cBS_ID81IDCImpl.StartScan(SecDeviceNum);
+    LogM("ScanIDAndSaveImage()->DeviceStatus()正常, nRet=%d, line=%d", nRet, __LINE__);
+
+    ErrorCodeEnum nRetErr =OnCheckCard();
+    if (nRetErr  != Error_Succeed)
+    {
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        //SaveErrorInfo("ScanIDAndSaveImage()->OnCheckCard()未检测到卡", DEP_NO_E_IDCERTIFICATE_NO_CARD, __FUNCTION__, __LINE__);
+        LogM("ScanIDAndSaveImage()->OnCheckCard()未检测到卡, nRet=%d,line=%d", nRetErr, __LINE__);
+        return nRetErr;
+    }
+    LogM("ScanIDAndSaveImage():CheckIdCard检测到卡并已吸入, nRet=%d,line=%d", nRetErr, __LINE__);
+
+    nRet = m_cBS_ID81IDCImpl.StartScan(m_SecDeviceNum);
     if (nRet != IDDIGITALCOPIER_NO_ERROR)
     {
         m_wDevStatus = DEVICE_STATUS_FAULT;
-        SaveErrorInfo("通讯异常", Error_DevCommFailed);
-        LogM("StartScan(), 通讯异常, nRet=%d, line=%d", nRet, __LINE__);
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        LogM("ScanIDAndSaveImage()->StartScan(), 异常, nRet=%d, line=%d", nRet, __LINE__);
         return Error_DevCommFailed;
     }
-    LogM("StartScan()正常, nRet=%d, line=%d", nRet, __LINE__);
+    LogM("ScanIDAndSaveImage()->StartScan()正常, nRet=%d, line=%d", nRet, __LINE__);
     int iFrontLen;
     int iRearLen;
     //--------------改为与厂家DEMO相似，采用NEW方式申请数组空间；
     char* cFrontImgBuf = new char[MAX_PICTURE_SIZE];
     char* cRearImgBuf = new char[MAX_PICTURE_SIZE];
-    nRet=m_cBS_ID81IDCImpl.ReadCard(SecDeviceNum, cFrontImgBuf, cRearImgBuf, &iFrontLen, &iRearLen);
+    nRet=m_cBS_ID81IDCImpl.ReadCard(m_SecDeviceNum, cFrontImgBuf, cRearImgBuf, &iFrontLen, &iRearLen);
+    if(nRet != IDDIGITALCOPIER_NO_ERROR)
+    {
+        SaveErrorInfo(__LINE__, __FUNCTION__);
+        delete []cFrontImgBuf;
+        delete []cRearImgBuf;
+        return Error_DevCommFailed;
+    }
     if (iFrontLen > 0)
     {
-        nRet = m_cBS_ID81IDCImpl.SaveToFile(SecDeviceNum, cFrontImgBuf, iFrontLen, FileNamefront, 1);
+        nRet = m_cBS_ID81IDCImpl.SaveToFile(m_SecDeviceNum, cFrontImgBuf, iFrontLen, FileNamefront, 1);
         if (nRet != IDDIGITALCOPIER_NO_ERROR)
         {
-            SaveErrorInfo("通讯异常", Error_DevCommFailed);
-            LogM("SaveToFile(), 通讯异常, nRet=%d,line=%d", Error_DevCommFailed, __LINE__);
+            SaveErrorInfo(__LINE__, __FUNCTION__);
+            LogM("ScanIDAndSaveImage()->SaveToFile(), 异常, nRet=%d,line=%d", Error_DevCommFailed, __LINE__);
             delete []cFrontImgBuf;
             delete []cRearImgBuf;
             return Error_DevCommFailed;
         }
-        LogM("SaveToFile()正常, nRet=%d, iFrontLen=%d， line=%d", nRet, iFrontLen, __LINE__);
+        LogM("ScanIDAndSaveImage()->SaveToFile()正常, nRet=%d, iFrontLen=%d， line=%d", nRet, iFrontLen, __LINE__);
     }
-    LogM("ReadCard()正常, nRet=%d, iFrontLen = %d, line=%d", nRet, iFrontLen, __LINE__);
+	else
+	{
+		SaveErrorInfo("保存正面图片失败", DEP_NO_E_IDCERTIFICATE_SAVE_IMAGE_ERROR, __FUNCTION__, __LINE__);
+		SH_DeleteFileOrDirectory(FileNamefront);
+		SH_DeleteFileOrDirectory(FileNameback);
+		delete []cFrontImgBuf;
+		delete []cRearImgBuf;
+		return Error_DevCommFailed;
+	}
+    LogM("ScanIDAndSaveImage()->ReadCard()正常, nRet=%d, iFrontLen = %d, line=%d", nRet, iFrontLen, __LINE__);
     if (iRearLen>0)
     {
-        nRet = m_cBS_ID81IDCImpl.SaveToFile(SecDeviceNum,cRearImgBuf,iRearLen,FileNameback,1);
+        nRet = m_cBS_ID81IDCImpl.SaveToFile(m_SecDeviceNum,cRearImgBuf,iRearLen,FileNameback,1);
         if (nRet != IDDIGITALCOPIER_NO_ERROR)
         {
-            SaveErrorInfo("通讯异常", Error_DevCommFailed);
-            LogM("SaveToFile(), 通讯异常, nRet=%d, iRearLen = %d, line=%d", Error_DevCommFailed, iRearLen, __LINE__);
+            SaveErrorInfo(__LINE__, __FUNCTION__);
+            LogM("ScanIDAndSaveImage()->SaveToFile(), 通讯异常, nRet=%d, iRearLen = %d, line=%d", Error_DevCommFailed, iRearLen, __LINE__);
             delete []cFrontImgBuf;
             delete []cRearImgBuf;
             return Error_DevCommFailed;
         }
-        LogM("SaveToFile()正常, nRet=%d, iRearLen = %d, line=%d", nRet, iRearLen, __LINE__);
+        LogM("ScanIDAndSaveImage()->SaveToFile()正常, nRet=%d, iRearLen = %d, line=%d", nRet, iRearLen, __LINE__);
     }
-    LogM("ScanIDAndSaveImage(), nRet=%d", Error_Succeed);
+	else
+	{
+		SaveErrorInfo("保存背面图片失败", DEP_NO_E_IDCERTIFICATE_SAVE_IMAGE_ERROR, __FUNCTION__, __LINE__);
+		delete []cFrontImgBuf;
+		delete []cRearImgBuf;
+		return Error_DevCommFailed;
+	}
+    LogM("ScanIDAndSaveImage() OK, nRet=%d", Error_Succeed);
     delete []cFrontImgBuf;
     delete []cRearImgBuf;
     return Error_Succeed;
@@ -1535,19 +1561,32 @@ ErrorCodeEnum IDCerClassImpl::QueryCardPos(int &pos)
     LOG_FUNCTION();
     LogM("QueryCardPos() Entry,line=%d", __LINE__);
 
+//    if(!m_bDevOpen)
+//    {
+//        SaveErrorInfo("QueryCardPos()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+//        LogM("QueryCardPos()设备未打开, line=%d", __LINE__);
+//        return Error_DevNotAvailable;
+//    }
+
     DEVSTATUS m_DeviceStatus;
     memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
 
-    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
-    if (nRet == IDDIGITALCOPIER_PORT_ERROR)
+    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
+    if (nRet != IDDIGITALCOPIER_NO_ERROR)
     {
         sleep(1);
-        DevOpen(SecDeviceNum);
-        nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
-        if (nRet == IDDIGITALCOPIER_PORT_ERROR)
+        ErrorCodeEnum RetCode = DevOpen(m_SecDeviceNum);
+//        if (RetCode != Error_Succeed)
+//        {
+//            SaveErrorInfo("QueryCardPos()设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
+//            LogM("QueryCardPos()设备未打开, line=%d", __LINE__);
+//            return Error_DevNotAvailable;
+//        }
+        nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
+        if (nRet != IDDIGITALCOPIER_NO_ERROR)
         {
-            SaveErrorInfo("通讯异常", Error_DevCommFailed);
-            LogM("DeviceStatus(), 通讯异常, nRet=%d,line=%d", nRet, __LINE__);
+            SaveErrorInfo(__LINE__, __FUNCTION__);
+            LogM("QueryCardPos()->DeviceStatus()失败, nRet=%d,line=%d", nRet, __LINE__);
             m_wDevStatus = DEVICE_STATUS_FAULT;
             return Error_DevCommFailed;
         }
@@ -1579,11 +1618,196 @@ ErrorCodeEnum IDCerClassImpl::QueryCardPos(int &pos)
 
 
 //Private
-void IDCerClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
+void IDCerClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
 {
-    LOG_FUNCTION();
+
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    char chLastStr[MAX_DEV_ERROR_MSG_LEN] = {0};
+    int nErrCode = m_cBS_ID81IDCImpl.LastErrorCode();
+    m_cBS_ID81IDCImpl.LastErrorStr(chLastStr);
+    sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", strFunc, nLine, nErrCode, chLastStr, errMsg);
     memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-    sprintf(m_szErrMsg, "%s[%d]", errMsg, errCode);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    char chLastStr[MAX_DEV_ERROR_MSG_LEN] = {0};
+    int nErrCode = m_cBS_ID81IDCImpl.LastErrorCode();
+    m_cBS_ID81IDCImpl.LastErrorStr(chLastStr);
+    sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", strFunc, nLine, nErrCode, chLastStr, errMsg);
+
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
+}
+
+void IDCerClassImpl::SaveErrorInfo(int nLine, const char* chFunction)
+{
+    char chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    char chLastStr[MAX_DEV_ERROR_MSG_LEN] = {0};
+    memset(m_szErrMsg, 0x00, MAX_DEV_ERROR_MSG_LEN);
+    int nErrCode = m_cBS_ID81IDCImpl.LastErrorCode();
+    short shErrCode;
+    m_cBS_ID81IDCImpl.LastErrorStr(chLastStr);
+
+    switch (nErrCode)
+    {
+    case IDDIGITALCOPIER_NO_ERROR:
+        shErrCode = DEP_SUCCESS;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "正常");
+        break;
+    case IDDIGITALCOPIER_NO_DEVICE:
+        shErrCode = DEP_DEV_NOT_FOUND;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "无设备");
+        break;
+    case IDDIGITALCOPIER_PORT_ERROR:
+        shErrCode = DEP_INVALID_PORT;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "端口错误");
+        break;
+    case IDDIGITALCOPIER_TABPAR_NONE:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_TABPAR_NONE;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "参数文件错误");
+        break;
+    case IDDIGITALCOPIER_HAVE_NOT_INIT:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_HAVE_NOT_INIT;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "未初始化");
+        break;
+    case IDDIGITALCOPIER_INVALID_ARGUMENT:
+        shErrCode = DEP_INVALID_PARAMETER;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "无效参数");
+        break;
+    case IDDIGITALCOPIER_TIMEOUT_ERROR:
+        shErrCode = DEP_TIMEOUT;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "超时错误");
+        break;
+    case IDDIGITALCOPIER_STATUS_COVER_OPENED:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_COVER_OPENED;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "上盖打开");
+        break;
+    case IDDIGITALCOPIER_STATUS_PASSAGE_JAM:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_PASSAGE_JAM;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "塞卡");
+        break;
+    case IDDIGITALCOPIER_OUT_OF_MEMORY:
+        shErrCode = DEP_BUFFER_LIMIT_EXCEEDED;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "内存溢出");
+        break;
+    case IDDIGITALCOPIER_NO_ID_DATA:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_NO_ID_DATA;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "没有二代证数据");
+        break;
+    case IDDIGITALCOPIER_NO_IMAGE_DATA:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_NO_IMAGE_DATA;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "没有图像数据");
+        break;
+    case IDDIGITALCOPIER_IMAGE_PROCESS_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_IMAGE_PROCESS_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "图像处理错误");
+        break;
+    case IDDIGITALCOPIER_IMAGE_JUDGE_DIRECTION_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_JUDGE_DIRECTION_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "判断图像方向错误");
+        break;
+    case IDDIGITALCOPIER_CLOSE_FAILED:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_CLOSE_FAILED;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "关闭端口失败");
+        break;
+    case IDDIGITALCOPIER_IDDATA_PROCESS_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_IDDATA_PROCESS_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "身份证电子信息处理错误");
+        break;
+    case IDDIGITALCOPIER_SENSORVALIDATE:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_SENSORVALIDATE;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "传感器校验错误");
+        break;
+    case IDDIGITALCOPIER_VOLTAGE_LOW:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_VOLTAGE_LOW;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "电压低");
+        break;
+    case IDDIGITALCOPIER_CIS_CORRECTION_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_CIS_CORRECTION_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "校正错误");
+        break;
+    case IDDIGITALCOPIER_NO_CARD:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_NO_CARD;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "无卡");
+        break;
+    case IDDIGITALCOPIER_FIRMWARE_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_FIRMWARE_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "未知错误固件错误");
+        break;
+    case IDDIGITALCOPIER_SAVE_IMAGE_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_SAVE_IMAGE_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "保存位图错误");
+        break;
+    case IDDIGITALCOPIER_POWER_OFF:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_POWER_OFF;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "掉电错误");
+        break;
+    case IDDIGITALCOPIER_INPUT_BOOT:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_INPUT_BOOT;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "BOOT错误");
+        break;
+    case IDDIGITALCOPIER_BUTTON_UP:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_BUTTON_UP;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "按键抬起");
+        break;
+    case IDDIGITALCOPIER_RECOGNISE_FAILED:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_RECOGNISE_FAILED;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "识别错误");
+        break;
+    case IDDIGITALCOPIER_SCAN_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_SCAN_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "扫描错误");
+        break;
+    case IDDIGITALCOPIER_FEED_ERROR:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_FEED_ERROR;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "走卡错误");
+        break;
+    case IDDIGITALCOPIER_MAX_CODE:
+        shErrCode = DEP_NO_E_IDCERTIFICATE_MAX_CODE;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "最大错误码");
+        break;
+    default:
+        shErrCode = DEP_COMMUNICATION_FAILED;
+        sprintf(chJson, "Func:%s,Line:%d,Msg:[%d]%s, %s", chFunction, nLine, nErrCode, chLastStr, "通讯异常");
+        break;
+    }
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", shErrCode,chJson);
+
+
+
+    /*
+    try
+    {
+        QJsonObject root_Obj;
+        QJsonDocument root_Doc;
+        root_Obj.insert("ErrCode", shErrCode);
+        root_Obj.insert("Description", chJson);
+        root_Doc.setObject(root_Obj);
+        //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+        QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+        QString strJson(root_str);
+        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+        sprintf(m_szErrMsg, strJson.toUtf8().data());
+        LogM(m_szErrMsg);
+    }
+    catch (std::exception &ex)
+    {
+        sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", shErrCode,chJson);
+    }
+    LogM(m_szErrMsg);
+    */
 }
 
 int IDCerClassImpl::string_format(std::string &str, const std::string fmt, ...)
@@ -1651,43 +1875,56 @@ ErrorCodeEnum IDCerClassImpl::OnCheckCard()
     DEVSTATUS m_DeviceStatus;
 
      memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
-     nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
+     nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
      if (nRet == IDDIGITALCOPIER_PORT_ERROR)
      {
          sleep(1);
-         DevOpen(SecDeviceNum);
-         nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
-         if (nRet == IDDIGITALCOPIER_PORT_ERROR)
+         DevOpen(m_SecDeviceNum);
+         nRet = m_cBS_ID81IDCImpl.DeviceStatus(m_SecDeviceNum, &m_DeviceStatus);
+         if (nRet != IDDIGITALCOPIER_NO_ERROR)
          {
-             SaveErrorInfo("通讯异常", Error_DevCommFailed);
-             LogM("DeviceStatus(), 通讯异常, nRet=%d", nRet);
+             SaveErrorInfo(__LINE__, __FUNCTION__);
+             LogM("OnCheckCard()->DeviceStatus()失败, nRet=%d", nRet);
              m_wDevStatus = DEVICE_STATUS_FAULT;
              return Error_DevCommFailed;
          }
      }
-     nRet = m_cBS_ID81IDCImpl.CheckIdCard(SecDeviceNum, 3000);
+     nRet = m_cBS_ID81IDCImpl.CheckIdCard(m_SecDeviceNum, 3000);
      if ((IDDIGITALCOPIER_TIMEOUT_ERROR == nRet) ||
          (IDDIGITALCOPIER_NO_CARD == nRet))
      {
-         SaveErrorInfo("未检测到卡", Error_Unexpect);
-         LogE("IDCerAuthenticate()，未检测到卡, nRet=%d, SecDeviceNum=%d", nRet, SecDeviceNum);
+         SaveErrorInfo("IDCerAuthenticate()->CheckIdCard()未检测到卡", DEP_NO_E_IDCERTIFICATE_NO_CARD, __FUNCTION__, __LINE__);
+         LogE("IDCerAuthenticate()->CheckIdCard()，未检测到卡, nRet=%d, m_SecDeviceNum=%d", nRet, m_SecDeviceNum);
          return Error_Unexpect;
      }
      else if (IDDIGITALCOPIER_STATUS_PASSAGE_JAM == nRet)
      {
          char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-         sprintf(err, "塞卡%d", nRet);
-         SaveErrorInfo(err, Error_Unexpect);
-         m_cBS_ID81IDCImpl.ResetWithAction(SecDeviceNum, 3);
-         LogE("IDCerAuthenticate()，塞卡后软复位，nRet=%d, SecDeviceNum=%d,line=%d", nRet, SecDeviceNum, __LINE__);
+         sprintf(err, "IDCerAuthenticate()->CheckIdCard()塞卡%d", nRet);
+         SaveErrorInfo(err, DEP_NO_E_IDCERTIFICATE_PASSAGE_JAM, __FUNCTION__, __LINE__);
+         sleep(1);
+         nRet = m_cBS_ID81IDCImpl.ResetWithAction(m_SecDeviceNum, 3);
+         if(IDDIGITALCOPIER_STATUS_PASSAGE_JAM == nRet)
+         {
+             sleep(1);
+             m_cBS_ID81IDCImpl.ResetWithAction(m_SecDeviceNum, 2);
+             nRet = m_cBS_ID81IDCImpl.CheckIdCard(m_SecDeviceNum, 3000);
+             LogE("IDCerAuthenticate()，塞卡后软复位重新check，nRet=%d, m_SecDeviceNum=%d,line=%d", nRet, m_SecDeviceNum, __LINE__);
+             if(nRet == IDDIGITALCOPIER_NO_ERROR)
+                 return Error_Succeed;
+             else {
+                 SaveErrorInfo(__LINE__, __FUNCTION__);
+                 sleep(1);
+                 m_cBS_ID81IDCImpl.ResetWithAction(m_SecDeviceNum, 0);
+             }
+         }
+        SaveErrorInfo(__LINE__, __FUNCTION__);
          return Error_Unexpect;
      }
      else if (IDDIGITALCOPIER_NO_ERROR != nRet)
      {
-         char err[MAX_DEV_ERROR_MSG_LEN] = {0};
-         sprintf(err, "通讯失败%d", nRet);
-         SaveErrorInfo(err, Error_DevConnFailed);
-         LogE("IDCerAuthenticate()，通讯失败，nRet=%d, SecDeviceNum=%d,line=%d", nRet, SecDeviceNum, __LINE__);
+         SaveErrorInfo(__LINE__, __FUNCTION__);
+         LogE("IDCerAuthenticate()，通讯失败，nRet=%d, m_SecDeviceNum=%d,line=%d", nRet, m_SecDeviceNum, __LINE__);
          return Error_DevConnFailed;
      }
      return Error_Succeed;

DevAdapter/keba/IDCertificate.keba.1.1/idcertificate.h

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #ifndef IDCERTIFICATE_H
 #define IDCERTIFICATE_H
 //#pragma pack(push,1)
@@ -77,7 +77,8 @@ private:
     bool m_bDevOpen;
     WORD m_wDevStatus;
     CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
-    void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+    void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
+    void SaveErrorInfo(int nLine=0, const char* chFunction=NULL);
     bool SH_DeleteFileOrDirectory(char *strFileName);
 public:
     ErrorCodeEnum OnCheckCard();
@@ -91,7 +92,7 @@ public:
 
 protected:
     BS_ID81IDCLibImpl		m_cBS_ID81IDCImpl;
-    unsigned				SecDeviceNum;
+    unsigned				m_SecDeviceNum;
     DEVSTATUS				Devstatus;
     IDInfo					m_IDInfo;                          //二代证身份证信息
     IDInfoForeign			m_IDForeignInfo;                   //外国人证件信息

DevAdapter/keba/IDCertificate.keba.1.1/libID81_SO.cpp

@@ -51,13 +51,6 @@ mSetLog                     SetLog            = NULL;
 
 bool load_so(char *cErrorInfo)
 {
-    //load动态库
-    if(hlibID81)
-	{
-        sprintf(cErrorInfo, "hlibID81 != NULL");
-        return false;
-	}
-
     Dl_info path_info;
     dladdr("load_so",&path_info);
     char str_FilePath[256]{0};

DevAdapter/keba/IDCertificate.keba.1.1/stdafx.h

@@ -7,6 +7,10 @@
 
 
 // TODO: 在此处引用程序需要的其他头文件
+//#include <QJsonParseError>  //https://www.cnblogs.com/whik/p/11234889.html
+//#include <QVariantMap>
+//#include <QJsonObject>
+//#include <QJsonArray>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -20,4 +24,5 @@
 #include "TraceManager.h"
 #include "CommDef.h"
 #include "CkLog.h"
+#include "DepErrorCode.h"
 

DevAdapter/keba/PinPad.keba.1.1/CMakeLists.txt

@@ -6,6 +6,8 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
 
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
@@ -42,7 +44,8 @@ target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/ke
 target_link_libraries(${MODULE_FULL_NAME} ${VENDOR_LOG_LIB_NAME})
 #链接keba依赖库
 target_link_libraries(${MODULE_FULL_NAME} Common.keba)
-
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
 #设置动态库输出路径:/data/home/keba/DevAdapter/cmbsz/lib/gcc_aarch64或者gcc_x64
 SET(LIBRARY_OUTPUT_PATH ${VENDOR_CURRENT_LIB_DIR})
 message(STATUS "LIBRARY_OUTPUT_PATH: ${VENDOR_CURRENT_LIB_DIR}")

DevAdapter/keba/PinPad.keba.1.1/PinPadClassImpl_ZT598M.cpp

@@ -163,16 +163,16 @@ ErrorCodeEnum PinPadClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
     short v1,v2;
     getFileVer(sFile, v1, v2);
 
+    /*
     devCategory.version.wMajor = v1;
     devCategory.version.wMinor = v2;
-
     devCategory.version.wRevision = 0xffff;
     devCategory.version.wBuild = FILE_VERSION;
-
-    //devCategory.version.wRevision = 0xFFFF;
-    //devCategory.version.wBuild = 1;
-    //devCategory.version.wMajor = 0;
-    //devCategory.version.wMinor = 0;
+    */
+    devCategory.version.wMajor = FILE_MAJOR;
+    devCategory.version.wMinor = FILE_MINOR;
+    devCategory.version.wRevision = FILE_REVISION;
+    devCategory.version.wBuild = FILE_BUILD;
     LogM( "devCategory.szType=%s",devCategory.szType);
     LogM( "devCategory.szModel=%s [0x%x]", devCategory.szModel, m_szMainChipSN[9]);
     LogM( "devCategory.szVendor=%s",devCategory.szVendor);
@@ -192,7 +192,7 @@ ErrorCodeEnum PinPadClassImpl::Reset()
     lRet = ZT598M1FD_DevCtrl->CloseDevice();
     if(lRet != STATUS_SUCCESS)
     {
-        SaveErrorInfo(lRet);
+        SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
     }
     LogM("==>Leave PinPadClassImpl::Reset() = %d", lRet);
     return DevOpen(0, 0);
@@ -211,12 +211,9 @@ ErrorCodeEnum PinPadClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
 {
     LOG_FUNCTION();
     LogM("<==Enter PinPadClassImpl::GetLastErr()");
-    devErrInfo.dwErrMsgLen = 0;
+    devErrInfo.dwErrMsgLen = m_devErrInfo.dwErrMsgLen;
     memset(devErrInfo.szErrMsg, 0, sizeof(devErrInfo.szErrMsg));
-
-    devErrInfo.dwErrMsgLen = (m_shErrCode << 16);
-    sprintf(devErrInfo.szErrMsg, m_szErrMsg);
-    devErrInfo.dwErrMsgLen += (strlen(devErrInfo.szErrMsg) & 0x0000FFFF);
+    sprintf(devErrInfo.szErrMsg, m_devErrInfo.szErrMsg);
     LogM("==>Leave PinPadClassImpl::GetLastErr()");
     return Error_Succeed;
 }
@@ -244,7 +241,7 @@ ErrorCodeEnum PinPadClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     if(lRet != STATUS_SUCCESS)
     {
         LogM("==>Leave PinPadClassImpl::DevOpen(): InitDevice()=%d", lRet);
-        return SaveErrorInfo(lRet);
+        return SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
     }
     //根据能力调整硬件配置
     //设置硬件配置参数
@@ -252,7 +249,7 @@ ErrorCodeEnum PinPadClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     if(lRet != STATUS_SUCCESS)
     {
         LogM("==>Leave PinPadClassImpl::DevOpen(): SetDeviceConfigure=%d", lRet);
-        return SaveErrorInfo(lRet);
+        return SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
     }
     if(PIN_INSTALL== m_cfgSP.byRemoveInstall||PIN_REMOVE==m_cfgSP.byRemoveInstall)
     {
@@ -260,7 +257,7 @@ ErrorCodeEnum PinPadClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
         if(ERR_PIN_PHYSICALLY_UNINSTALLED==lRet||ERR_PIN_LOGICALLY_UNINSTALLED==lRet)
         {
             LogM("==>Leave PinPadClassImpl::DevOpen():RemoveInstallAuthen=%d", lRet);
-            return SaveErrorInfo(lRet);
+            return SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         }
         if (STATUS_SUCCESS==lRet && PIN_REMOVE == m_cfgSP.byRemoveInstall)
         {
@@ -295,7 +292,9 @@ ErrorCodeEnum PinPadClassImpl::KeyRead(BYTE &ch)
     DWORD dwCoveredDataSize = 0;
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
 
@@ -343,22 +342,27 @@ ErrorCodeEnum PinPadClassImpl::KeyRead(BYTE &ch)
             {
                 ch = byCurrentChar;
                 //sensitive info
-                LogM("KeyRead: return char:%c(0x%02X)", ch, ch);
+                LogM("KeyRead: return char:(0x%02x)", ch);
                 LogM("pinpadReadData.data:%s pinpadReadData.dwSize:%d pinpadReadData.dwCurrentRead:%d", m_pinpadReadData.data, m_pinpadReadData.dwSize, m_pinpadReadData.dwCurrentRead);
                 return Error_Succeed;
             }
             else
             {
                 //special char
-                LogM("KeyRead: return special char:%c(0x%02X) ", byCurrentChar, byCurrentChar);
+                LogM("KeyRead: return special char:(0x%02x) ", byCurrentChar);
                 switch (byCurrentChar)
                 {
                 case 0x80:
-                    ret = SaveErrorInfo(ERR_PIN_PRESS_KEY_OVERTIME);
+
+                    memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                    strcpy(m_szErrMsg, "ERR_PIN_PRESS_KEY_OVERTIME长按键");
+                    ret = SaveErrorInfo(ERR_PIN_PRESS_KEY_OVERTIME, __FUNCTION__, __LINE__);
                     break;
                 case 0x82:
                 default:
-                    ret = SaveErrorInfo(ERR_PIN_KEY_CODE_NOT_FOUND);
+                    memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                    strcpy(m_szErrMsg, "ERR_PIN_KEY_CODE_NOT_FOUND硬件返回不认识的按键值");
+                    ret = SaveErrorInfo(ERR_PIN_KEY_CODE_NOT_FOUND, __FUNCTION__, __LINE__);
                     break;
                 }
                 return ret;
@@ -376,7 +380,7 @@ ErrorCodeEnum PinPadClassImpl::KeyRead(BYTE &ch)
     /*
     else
     {
-        SaveErrorInfo(lRet);
+        SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
     */
@@ -433,7 +437,9 @@ ErrorCodeEnum PinPadClassImpl::PinRead(BYTE &ch)
                 lRet = ZT598M1FD_DevCtrl->DelEntryPinKey(DELETE_LAST_ENTERED, m_LPPinpadStatus);
 				m_nCurrentPinLen = m_nMaxPinLen;
                 LogM("Exceed the maximum length.");
-                ret = SaveErrorInfo(STATUS_INVALID_PIN_LENGTH);
+                memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                strcpy(m_szErrMsg, "STATUS_INVALID_PIN_LENGTH输入的按键数量错误");
+                ret = SaveErrorInfo(STATUS_INVALID_PIN_LENGTH, __FUNCTION__, __LINE__);
                 goto END_LABEL;
 			}
 		}
@@ -472,39 +478,47 @@ ErrorCodeEnum PinPadClassImpl::PinRead(BYTE &ch)
 		else
 		{
 			//special char
-            LogM("KeyRead: return special char:%c(0x%02X) ", byCurrentChar, byCurrentChar);
+            LogM("KeyRead: return special char:(0x%02x) ", byCurrentChar);
 			switch (byCurrentChar)
 			{
 			case 0x80:
-                ret = SaveErrorInfo(ERR_PIN_PRESS_KEY_OVERTIME);
+                memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                strcpy(m_szErrMsg, "ERR_PIN_PRESS_KEY_OVERTIME长按键");
+                ret = SaveErrorInfo(ERR_PIN_PRESS_KEY_OVERTIME, __FUNCTION__, __LINE__);
 				break;
 			case 0x81:
 				if (m_nCurrentPinLen == 0)
 				{
-                    ret = SaveErrorInfo(ERR_PIN_TIMEOUT);
-                    //SaveErrorInfo("等待按键输入超时", DEC_PRESS_KEY_TIMEOUT);
+                    memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                    strcpy(m_szErrMsg, "ERR_PIN_TIMEOUT等待按键超时");
+                    ret = SaveErrorInfo(ERR_PIN_TIMEOUT, __FUNCTION__, __LINE__);
 				}
 				else
 				{
-                    ret = SaveErrorInfo(ERR_PIN_TIMEOUT);
-                    //SaveErrorInfo("两次按键间隔时间超时", DEC_PRESS_KEY_INTERVAL_TIMEOUT);
+                    memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                    strcpy(m_szErrMsg, "ERR_PIN_TIMEOUT两次按键间隔时间超时");
+                    ret = SaveErrorInfo(ERR_PIN_TIMEOUT, __FUNCTION__, __LINE__);
 				}
 				break;
 			default:
-                ret = SaveErrorInfo(ERR_PIN_KEY_CODE_NOT_FOUND);
+                memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+                strcpy(m_szErrMsg, "ERR_PIN_KEY_CODE_NOT_FOUND硬件返回不认识的按键值");
+                ret = SaveErrorInfo(ERR_PIN_KEY_CODE_NOT_FOUND, __FUNCTION__, __LINE__);
 				break;
 			}
             goto END_LABEL;
 		}
 		//sensitive info
-        LogM("PinRead: return char:%c(0x%02X)", ch, ch);
+        LogM("PinRead: return char:(0x%02x)", ch);
         LogM("pinpadReadData.dwSize:%d pinpadReadData.dwCurrentRead:%d", m_pinpadReadData.dwSize, m_pinpadReadData.dwCurrentRead);
         goto END_LABEL;
 	}
 	else
 	{
 		//no key pressed
-        ret = SaveErrorInfo(STATUS_PIN_NOPIN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "STATUS_PIN_NOPIN无按键输入");
+        ret = SaveErrorInfo(STATUS_PIN_NOPIN, __FUNCTION__, __LINE__);
         goto END_LABEL;
 	}
 END_LABEL:
@@ -547,15 +561,31 @@ ErrorCodeEnum PinPadClassImpl::StartPinInputCommon(BYTE byLen)
     memset(m_pinpadReadData.data, 0x00, MAX_PIN_READ_SIZE);
     //清除缓冲势
     lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
+    if(lRet != STATUS_SUCCESS)
+    {
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
+        goto END_LABEL;
+    }
     lRet = ZT598M1FD_DevCtrl->ReadEntryText(byTextBufer, sizeof(byTextBufer));
-
+    if(lRet != STATUS_SUCCESS)
+    {
+        goto END_LABEL;
+    }
     lRet = ZT598M1FD_DevCtrl->SetControlMode(CONTROL_MODE_SBS, eBeep);
-
+    if(lRet != STATUS_SUCCESS)
+    {
+        goto END_LABEL;
+    }
     lRet = ZT598M1FD_DevCtrl->SetEntryMode(m_nCurrentEntryMode, 0x0000, 0x0000);
-    //lRet = ZT598M1FD_DevCtrl->ReadEntryText(byTextBufer, sizeof(byTextBufer));
-    //lRet = ZT598M1FD_DevCtrl->ReadEntryText(byTextBufer, sizeof(byTextBufer));
+    if(lRet != STATUS_SUCCESS)
+    {
+        goto END_LABEL;
+    }
 END_LABEL:
-    ret = SaveErrorInfo(lRet);
+    if(lRet != STATUS_SUCCESS)
+    {
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
+    }
     LogM("<==Leave PinPadClassImpl::StartPinInputCommon()return %d", ret);
     return ret;
 }
@@ -586,7 +616,7 @@ ErrorCodeEnum PinPadClassImpl::StartPinInputConfirm(BYTE byLen)
     lRet = StartPinInputCommon(byLen);
     if(lRet != STATUS_SUCCESS)
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
 END_LABEL:
@@ -602,7 +632,9 @@ ErrorCodeEnum PinPadClassImpl::StartPlainInput()
     LONG lRet = STATUS_SUCCESS;
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         LogM("PinPad:Device not open");
         goto END_LABEL;
     }
@@ -610,7 +642,7 @@ ErrorCodeEnum PinPadClassImpl::StartPlainInput()
     lRet = StartPinInputCommon(0);
     if(lRet != STATUS_SUCCESS)
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
 END_LABEL:
@@ -626,7 +658,9 @@ ErrorCodeEnum PinPadClassImpl::StopInput()
     LONG lRet = STATUS_SUCCESS;
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         LogM("PinPad:Device not open");
         goto END_LABEL;
     }
@@ -637,7 +671,7 @@ ErrorCodeEnum PinPadClassImpl::StopInput()
     lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
     m_nCurrentEntryMode = CLOSE_ENTRY;
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
 END_LABEL:
@@ -672,13 +706,17 @@ ErrorCodeEnum PinPadClassImpl::LoadMasterKey(MasterKeyParam masterKey)
 
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         LogM("PinPad:Device not open");
         goto END_LABEL;
     }
     if (masterKey.smFlag > 1 || masterKey.smFlag < 0)
     {
-        ret = SaveErrorInfo(ERR_PARAM_ERROR);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        sprintf(m_szErrMsg, "ERR_PARAM_ERROR参数错误masterKey.smFlag=%d", masterKey.smFlag);
+        ret = SaveErrorInfo(ERR_PARAM_ERROR, __FUNCTION__, __LINE__);
         LogM("PinPad:masterkey.smFlag is invalid param");
         return Error_Param;
     }
@@ -693,7 +731,7 @@ ErrorCodeEnum PinPadClassImpl::LoadMasterKey(MasterKeyParam masterKey)
         wKeyCheckMode, lpsEncKeyName, lpbKCVData, usKCVLength, byKCV, wKCVLen, m_LPPinpadStatus);
     if(lRet != STATUS_SUCCESS)
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
 
@@ -730,14 +768,18 @@ ErrorCodeEnum PinPadClassImpl::LoadWorkingKey(WorkKeyParam wkKey)
 
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         LogM("PinPad:Device not open");
         goto END_LABEL;
     }
 
     if (wkKey.smFlag > 1 || wkKey.smFlag < 0)
     {
-        ret = SaveErrorInfo(ERR_PARAM_ERROR);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        sprintf(m_szErrMsg, "ERR_PARAM_ERROR参数错误masterKey.smFlag=%d", wkKey.smFlag);
+        ret = SaveErrorInfo(ERR_PARAM_ERROR, __FUNCTION__, __LINE__);
         LogM("PinPad:wkKey.smFlag is invalid param");
         return Error_Param;
     }
@@ -754,7 +796,7 @@ ErrorCodeEnum PinPadClassImpl::LoadWorkingKey(WorkKeyParam wkKey)
         wKeyCheckMode, lpsEncKeyName, lpbKCVData, usKCVLength, byKCV, wKCVLen, m_LPPinpadStatus);
     if(lRet != STATUS_SUCCESS)
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
 
@@ -818,7 +860,9 @@ ErrorCodeEnum PinPadClassImpl::SetParam(SetParamTypeEnum eType, SetParamValueEnu
                 m_wCryptDataAlgorithm = PIN_CRYPTSM4CBC;
             break;
         default:
-            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
+            memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+            sprintf(m_szErrMsg, "STATUS_INVALID_DATA_SPECIFIED指定了非法参数eType=%d,eValue=%d", eType, eValue);
+            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED, __FUNCTION__, __LINE__);
             return Error_Param;
             break;
         }
@@ -854,7 +898,9 @@ ErrorCodeEnum PinPadClassImpl::SetParam(SetParamTypeEnum eType, SetParamValueEnu
             }
             break;
         default:
-            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
+            memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+            sprintf(m_szErrMsg, "STATUS_INVALID_DATA_SPECIFIED指定了非法参数eType=%d,eValue=%d", eType, eValue);
+            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED, __FUNCTION__, __LINE__);
             return Error_Param;
             break;
         }
@@ -876,7 +922,9 @@ ErrorCodeEnum PinPadClassImpl::SetParam(SetParamTypeEnum eType, SetParamValueEnu
             m_wPinFormat = PIN_FORMISO0;  //TODO:WFS_PIN_FORMANSI or WFS_PIN_FORMISO0?
             break;
         default:
-            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
+            memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+            sprintf(m_szErrMsg, "STATUS_INVALID_DATA_SPECIFIED指定了非法参数eType=%d,eValue=%d", eType, eValue);
+            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED, __FUNCTION__, __LINE__);
             return Error_Param;
             break;
         }
@@ -898,13 +946,17 @@ ErrorCodeEnum PinPadClassImpl::SetParam(SetParamTypeEnum eType, SetParamValueEnu
             m_wCryptDataAlgorithm = PIN_CRYPT_CBC;
             break;
         default:
-            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
+            memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+            sprintf(m_szErrMsg, "STATUS_INVALID_DATA_SPECIFIED指定了非法参数eType=%d,eValue=%d", eType, eValue);
+            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED, __FUNCTION__, __LINE__);
             return Error_Param;
             break;
         }
         break;
     default:
-        SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        sprintf(m_szErrMsg, "STATUS_INVALID_DATA_SPECIFIED指定了非法参数eType=%d,eValue=%d", eType, eValue);
+        SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED, __FUNCTION__, __LINE__);
         return Error_Param;
         break;
     }
@@ -968,14 +1020,18 @@ ErrorCodeEnum PinPadClassImpl::GetPinBlock(PinBlock &block)
 
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         LogM("PinPad:Device not open");
         goto END_LABEL;
     }
     lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
     if (sizeof(block.data) == 0 || block.data == NULL)
     {
-        ret = SaveErrorInfo(ERR_PIN_INVALIDDATA);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_INVALIDDATA输入数据地址为空");
+        ret = SaveErrorInfo(ERR_PIN_INVALIDDATA, __FUNCTION__, __LINE__);
         return Error_Param;
     }
     sprintf(szKeyName, "%s%s%d", m_bSM ? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, WORKING_KEY_NAEM_LABEL, m_dwWorkingKeySN);
@@ -984,7 +1040,7 @@ ErrorCodeEnum PinPadClassImpl::GetPinBlock(PinBlock &block)
            lpsEncKeyName, byResult, wResultLen, m_LPPinpadStatus);
     if(lRet != STATUS_SUCCESS)
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
     block.dwSize = CDataConvert::HexToString(byResult, wResultLen, (CHAR*)block.data, sizeof(block.data));
@@ -1000,7 +1056,9 @@ ErrorCodeEnum PinPadClassImpl::SetAccNo(AccountInfo accInfo)
     LogM("==>Enter PinPadClassImpl::SetAccNo():%s", accInfo.account);
     if (accInfo.dwAccLen == 0 || accInfo.dwAccLen >= MAX_ACCOUNT_LEN)
     {
-        SaveErrorInfo(ERR_PIN_INVALIDCUSTOMERDATA);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        sprintf(m_szErrMsg, "ERR_PIN_INVALIDCUSTOMERDATA输入的账号长度错误accInfo.dwAccLen=%d",accInfo.dwAccLen);
+        SaveErrorInfo(ERR_PIN_INVALIDCUSTOMERDATA, __FUNCTION__, __LINE__);
         return Error_Param;
     }
     //sensitive info
@@ -1109,13 +1167,17 @@ ErrorCodeEnum PinPadClassImpl::EncryptCommon(EnDecryptInfo srcInfo, EnDecryptInf
 
     if(!m_bDevOpen)
     {
-        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        strcpy(m_szErrMsg, "ERR_PIN_DEVNOTOPEN设备未打开");
+        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN, __FUNCTION__, __LINE__);
         LogM("PinPad:Device not open");
         goto END_LABEL;
     }
     if (srcInfo.dwSize == 0 || srcInfo.dwSize > MAX_EN_DECRYPT_DATA_SIZE)
     {
-        ret = SaveErrorInfo(ERR_PIN_INVALIDDATA);
+        memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+        sprintf(m_szErrMsg, "ERR_PIN_INVALIDDATA输入数据非法srcInfo.dwSize=%d",srcInfo.dwSize);
+        ret = SaveErrorInfo(ERR_PIN_INVALIDDATA, __FUNCTION__, __LINE__);
         return Error_Param;
     }
 
@@ -1124,7 +1186,9 @@ ErrorCodeEnum PinPadClassImpl::EncryptCommon(EnDecryptInfo srcInfo, EnDecryptInf
     sprintf(szKeyName, "%s%s%d", m_bSM ? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, WORKING_KEY_NAEM_LABEL, m_dwWorkingKeySN);
     if((srcInfo.dwSize == 0) || (srcInfo.dwSize != strlen((CHAR*)srcInfo.data)))
     {
-            ret = SaveErrorInfo(ERR_PIN_INVALIDDATA);
+            memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+            sprintf(m_szErrMsg, "ERR_PIN_INVALIDDATA输入数据非法srcInfo.dwSize=%d",srcInfo.dwSize);
+            ret = SaveErrorInfo(ERR_PIN_INVALIDDATA, __FUNCTION__, __LINE__);
             return Error_Param;
     }
     if (wKeyType == KEY_TYPE_DES)
@@ -1397,7 +1461,7 @@ ErrorCodeEnum PinPadClassImpl::EncryptCommon(EnDecryptInfo srcInfo, EnDecryptInf
     }
     if(lRet != STATUS_SUCCESS)
     {
-        ret = SaveErrorInfo(lRet);
+        ret = SaveErrorInfo(lRet, __FUNCTION__, __LINE__);
         goto END_LABEL;
     }
     destInfo.dwSize = CDataConvert::HexToString(lpbyResult, wResultLen, (CHAR*)destInfo.data, sizeof(destInfo.data));
@@ -1405,34 +1469,37 @@ ErrorCodeEnum PinPadClassImpl::EncryptCommon(EnDecryptInfo srcInfo, EnDecryptInf
     LogM("==>Leave PinPadClassImpl::EncryptCommon()");
     return ret;
 }
-ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode)
+ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode, const CHAR* strFunc, int nLine)
 {
     LOG_FUNCTION();
     ErrorCodeEnum ret;
-    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-    strcpy(m_szErrMsg, ZT598M1FD_DevCtrl->m_stPinpadStatus.sDescription);
+    if(strlen(m_szErrMsg) == 0)
+    {
+        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+        strcpy(m_szErrMsg, ZT598M1FD_DevCtrl->m_stPinpadStatus.sDescription);
+    }
 
     switch (iErrCode)
     {
     case STATUS_SUCCESS:
-        m_shErrCode = DEC_SUCCESS;
+        m_shErrCode = DEP_SUCCESS;
         ret = Error_Succeed;
         break;
     case STATUS_INVALID_COMMAND_LENGTH:
     case ERR_COMMON_ERROR:
-        m_shErrCode = DEC_INVALID_PARAMETER;
+        m_shErrCode = DEP_INVALID_PARAMETER;
         ret = Error_Param;
         break;
     case STATUS_INVALID_KEYID:
-        m_shErrCode = DEC_INVALID_KEY_ID;
+        m_shErrCode = DEP_INVALID_KEY_ID;
         ret = Error_Param;
         break;
     case STATUS_KEYID_NOT_EXIST:
-        m_shErrCode = DEC_KEY_NOT_EXIST;
+        m_shErrCode = DEP_KEY_NOT_EXIST;
         ret = Error_Param;
         break;
     case STATUS_KEYID_LOCKED:
-        m_shErrCode = DEC_KEY_LOCKED;
+        m_shErrCode = DEP_KEY_LOCKED;
         ret = Error_Param;
         break;
     case STATUS_INVALID_WRITE_MODE:
@@ -1441,72 +1508,72 @@ ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode)
     case STATUS_KEY_ATTRIBUTES_NOT_MATCHED:
     case STATUS_KEY_USEVIOLATION:
     case STATUS_KEY_NOTALLOWED:
-        m_shErrCode = DEC_E_KEY_LOST;
+        m_shErrCode = DEP_E_KEY_LOST;
         ret = Error_Param;
         break;
     case STATUS_KCV_VERIFICATION_FAIL:
     case STATUS_INVALID_CHECK_MODE:
     case STATUS_INVALID_VERIFY_MODE:
-        m_shErrCode = DEC_E_KCV_VERIFICATION;
+        m_shErrCode = DEP_E_KCV_VERIFICATION;
         ret = Error_Param;
         break;
     case STATUS_INVALID_AUTHENTICATION_MODE:
-        m_shErrCode = DEC_INVALID_AUTHENTICATION_MODE;
+        m_shErrCode = DEP_INVALID_AUTHENTICATION_MODE;
         ret = Error_Param;
         break;
     case STATUS_INVALID_MACING:
-        m_shErrCode = DEC_INVALID_MAC;
+        m_shErrCode = DEP_INVALID_MAC;
         ret = Error_Param;
         break;
     case STATUS_INVALID_MODE:
-        m_shErrCode = DEC_INVALID_MODE;
+        m_shErrCode = DEP_INVALID_MODE;
         ret = Error_Param;
         break;
     case STATUS_INVALID_DATA_SPECIFIED:
-        m_shErrCode = DEC_INVALID_PARAMETER;
+        m_shErrCode = DEP_INVALID_PARAMETER;
         ret = Error_Param;
         break;
     case STATUS_INVALID_KEY_VALUE:
     case STATUS_KEY_INVALID:
-        m_shErrCode = DEC_INVALID_KEY_VALUE;
+        m_shErrCode = DEP_INVALID_KEY_VALUE;
         ret = Error_Param;
         break;
     case STATUS_INVALID_KEY_LENGTH:
     case STATUS_INVALID_LENGTH_OR_SUM:
-        m_shErrCode = DEC_INVALID_KEY_LEN;
+        m_shErrCode = DEP_INVALID_KEY_LEN;
         ret = Error_Param;
         break;
     case STATUS_INVALID_OFFSET_LENGTH:
-        m_shErrCode = DEC_INVALID_LENGTH;
+        m_shErrCode = DEP_INVALID_LENGTH;
         ret = Error_Param;
         break;
     case STATUS_INVALID_PIN_LENGTH:
     case STATUS_PIN_NOPIN:
     case STATUS_INVALID_PIN2_LENGTH:
-        m_shErrCode = DEC_INVALID_PIN_LEN;
+        m_shErrCode = DEP_INVALID_PIN_LEN;
         ret = Error_Param;
         break;
     case STATUS_PIN_VERIFICATION_FAIL:
     case STATUS_PIN2_VERIFICATION_FAIL:
-        m_shErrCode = DEC_VERIFICATION_FAILED;
+        m_shErrCode = DEP_VERIFICATION_FAILED;
         ret = Error_Param;
         break;
     case STATUS_PIN_ENCRYPTION_SUSPENDED:
-        m_shErrCode = DEC_ENCRYPT_SUSPENDED;
+        m_shErrCode = DEP_ENCRYPT_SUSPENDED;
         ret = Error_Param;
         break;
     case STATUS_INVALID_MODULUS_LENGTH:
     case ERR_PIN_INVALID_MOD_LEN:
-        m_shErrCode = DEC_INVALID_MODULE_LEN;
+        m_shErrCode = DEP_INVALID_MODULE_LEN;
         ret = Error_Param;
         break;
     case STATUS_INVALID_EXPONENT_LENGTH:
-        m_shErrCode = DEC_INVALID_EXPONENT_LEN;
+        m_shErrCode = DEP_INVALID_EXPONENT_LEN;
         ret = Error_Param;
         break;
     case STATUS_INVALID_PKCS_STRUCTURE:
     case STATUS_INVALID_PKCS_PADDING:
-        m_shErrCode = DEC_INVALID_PKCS;
+        m_shErrCode = DEP_INVALID_PKCS;
         ret = Error_Param;
         break;
     case STATUS_INVALID_SIGNATURE_LENGTH:
@@ -1514,15 +1581,15 @@ ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode)
     case ERR_PIN_SIG_KEYNOTFOUND:
     case ERR_PIN_SIG_KEYUSEVIOLATION:
 
-        m_shErrCode = DEC_INVALID_SIGNATURE;
+        m_shErrCode = DEP_INVALID_SIGNATURE;
         ret = Error_Param;
         break;
     case STATUS_SIGNATURE_VERIFICATION_FAIL:
-        m_shErrCode = DEC_E_SIGNATURE_VERIFICATION;
+        m_shErrCode = DEP_E_SIGNATURE_VERIFICATION;
         ret = Error_Param;
         break;
     case STATUS_KEY_NOT_LOADED:
-        m_shErrCode = DEC_KEY_NOT_LOADED;
+        m_shErrCode = DEP_KEY_NOT_LOADED;
         ret = Error_Param;
         break;
     case STATUS_INVALID_CERTIFICATE_FROMAT:
@@ -1532,50 +1599,50 @@ ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode)
     case STATUS_INVALID_CERTIFICATE_SUBJECT:
     case STATUS_INVALID_CERTIFICATE_ALGOR:
     case STATUS_CERTIFICATE_NOT_EXIST:
-        m_shErrCode = DEC_INVALID_CERTIFICATE;
+        m_shErrCode = DEP_INVALID_CERTIFICATE;
         ret = Error_Param;
         break;
     case STATUS_INVALID_DATA_DISABLEED:
-        m_shErrCode = DEC_INVALID_DATA;
+        m_shErrCode = DEP_INVALID_DATA;
         ret = Error_Param;
         break;
     case STATUS_INVALID_USERBLOCK_ADDRESS:
-        m_shErrCode = DEC_INVALID_USER_BLOCK_ADDR;
+        m_shErrCode = DEP_INVALID_USER_BLOCK_ADDR;
         ret = Error_Param;
         break;
     case STATUS_INVALID_SERIALNO_SPECIFIED:
-        m_shErrCode = DEC_E_SERIAL_NUMBER;
+        m_shErrCode = DEP_E_SERIAL_NUMBER;
         ret = Error_Param;
         break;
     case STATUS_NO_CARD:
     case STATUS_CARD_APDU_ERROR:
-        m_shErrCode = DEC_E_SERIAL_NUMBER;
+        m_shErrCode = DEP_E_SERIAL_NUMBER;
         ret = Error_Param;
         break;
     case STATUS_EMV_NOT_INITIALIZED:
     case STATUS_EPP_NOT_INITIALIZED:
     case ERR_PIN_NEED_INITIALIZATION:
-        m_shErrCode = DEC_EPP_NOT_INITIALIZED;
+        m_shErrCode = DEP_EPP_NOT_INITIALIZED;
         ret = Error_Param;
         break;
     case STATUS_EMV_NOT_READY:
-        m_shErrCode = DEC_EMV_NOT_READY;
+        m_shErrCode = DEP_EMV_NOT_READY;
         ret = Error_Param;
         break;
     case STATUS_EMV_NEED_REINITIALIZE:
-        m_shErrCode = DEC_EMV_NEED_REINITIALIZE;
+        m_shErrCode = DEP_EMV_NEED_REINITIALIZE;
         ret = Error_Param;
         break;
     case STATUS_EMV_TIMEOUT:
-        m_shErrCode = DEC_EMV_TIMEOUT;
+        m_shErrCode = DEP_EMV_TIMEOUT;
         ret = Error_Param;
         break;
     case STATUS_EMV_ALREADY_INITIALIZED:
-        m_shErrCode = DEC_EMV_INIT_ALREADY;
+        m_shErrCode = DEP_EMV_INIT_ALREADY;
         ret = Error_Param;
         break;
     case STATUS_ALGORITHMNOTSUPP:
-        m_shErrCode = DEC_ALGORITHM_UNSUPPORTED;
+        m_shErrCode = DEP_ALGORITHM_UNSUPPORTED;
         ret = Error_Param;
         break;
     case STATUS_COMMANDUPSUPP:
@@ -1589,175 +1656,205 @@ ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode)
     case STATUS_FW_WRITE_FAIL:
     case STATUS_FW_EARSE_FAIL:
     case ERR_PIN_INVALID_FW_FILE:
-        m_shErrCode = DEC_COMMAND_UNSUPPORTED;
+        m_shErrCode = DEP_COMMAND_UNSUPPORTED;
         ret = Error_Param;
         break;
     case STATUS_ERROR_INTER_ERROR:
     case STATUS_MRAM_HARDWARE_ERROR:
     case STATUS_OTHER_ABNORMAL_ERROR:
     case ERR_INTERNAL_ERROR:
-        m_shErrCode = DEC_HARDWARE;
+        m_shErrCode = DEP_HARDWARE;
         ret = Error_Hardware;
         break;
     case STATUS_COMMAND_LOCK:
-        m_shErrCode = DEC_COMMAND_LOCKED;
+        m_shErrCode = DEP_COMMAND_LOCKED;
         ret = Error_Hardware;
         break;
     case STATUS_INVALID_COMMAND_MAC:
-        m_shErrCode = DEC_INVALID_MAC;
+        m_shErrCode = DEP_INVALID_MAC;
         ret = Error_Param;
         break;
     case STATUS_AUTHENTICATION_FAILED:
     case STATUS_NOT_AUTHENTE:
-        m_shErrCode = DEC_EPP_NOT_AUTHORIZED;
+        m_shErrCode = DEP_EPP_NOT_AUTHORIZED;
         ret = Error_Param;
         break;
     case STATUS_EPP_ALREADY_INITIALIZED:
-        m_shErrCode = DEC_EPP_INIT_ALREADY;
+        m_shErrCode = DEP_EPP_INIT_ALREADY;
         ret = Error_Hardware;
         break;
     case STATUS_CERTIFICATE_ALREADY:
-        m_shErrCode = DEC_EPP_CERTIFICATE_ALREADY;
+        m_shErrCode = DEP_EPP_CERTIFICATE_ALREADY;
         ret = Error_Hardware;
         break;
     case STATUS_PHYSICALLY_NOT_INSTALLED:
     case ERR_PIN_PHYSICALLY_UNINSTALLED:
-        m_shErrCode = DEC_EPP_NOT_PHYSICALLY_INSTALLED;
+        m_shErrCode = DEP_EPP_NOT_PHYSICALLY_INSTALLED;
         ret = Error_Hardware;
         break;
     case STATUS_LOGICALLY_NOT_INSTALLED:
     case ERR_PIN_LOGICALLY_UNINSTALLED:
-        m_shErrCode = DEC_EPP_NOT_LOGICALLY_INSTALLED;
+        m_shErrCode = DEP_EPP_NOT_LOGICALLY_INSTALLED;
         ret = Error_Hardware;
         break;
     case STATUS_INPUT_KEY_TIMEOUT:
-        m_shErrCode = DEC_PRESS_KEY_TIMEOUT;
+        m_shErrCode = DEP_PRESS_KEY_TIMEOUT;
         ret = Error_Param;
         break;
     case STATUS_INVLAID_PASSWORD_LENGTH:
-        m_shErrCode = DEC_INVALID_PASSWORD_LEN;
+        m_shErrCode = DEP_INVALID_PASSWORD_LEN;
         ret = Error_Hardware;
         break;
     case STATUS_INVALID_PASSWORD:
-        m_shErrCode = DEC_INVALID_PASSWORD;
+        m_shErrCode = DEP_INVALID_PASSWORD;
         ret = Error_Hardware;
         break;
     case STATUS_INPUT_PASSWORD_LOCKED:
-        m_shErrCode = DEC_PASSWORD_UPDATE_CMD_LOCKED;
+        m_shErrCode = DEP_PASSWORD_UPDATE_CMD_LOCKED;
         ret = Error_Hardware;
         break;
     case STATUS_SYSTEM_TIME_NOT_SET:
-        m_shErrCode = DEC_SYSTEM_TIME_NOT_SET;
+        m_shErrCode = DEP_SYSTEM_TIME_NOT_SET;
         ret = Error_Hardware;
         break;
     case STATUS_SYSTEM_TIME_ALREADY_SET:
-        m_shErrCode = DEC_SYSTEM_TIME_SET_ALREADY;
+        m_shErrCode = DEP_SYSTEM_TIME_SET_ALREADY;
         ret = Error_Hardware;
         break;
     case STATUS_DEVICE_TAMPERED:
-        m_shErrCode = DEC_DEVICE_TAMPERED;
+        m_shErrCode = DEP_DEVICE_TAMPERED;
         ret = Error_Hardware;
         break;
     case STATUS_A980_NO_RESPONSE:
-        m_shErrCode = DEC_COMMUNICATION_FAILED;
+        m_shErrCode = DEP_COMMUNICATION_FAILED;
         ret = Error_Hardware;
         break;
     case STATUS_INVALID_SM4_KEYVAL:
-        m_shErrCode = DEC_INVALID_SM4_KEY;
+        m_shErrCode = DEP_INVALID_SM4_KEY;
         ret = Error_Param;
         break;
     case STATUS_EXTERNAL_FALSH_WRITE_ERROR:
     case STATUS_FLASH_CRC_CHECK_ERROR:
-        m_shErrCode = DEC_E_EXTERNAL_FLASH_HARDWARE;
+        m_shErrCode = DEP_E_EXTERNAL_FLASH_HARDWARE;
         ret = Error_Hardware;
         break;
     case STATUS_ADDRESS_OUTRANG:
-        m_shErrCode = DEC_INVALID_USER_BLOCK_ADDR;
+        m_shErrCode = DEP_INVALID_USER_BLOCK_ADDR;
         ret = Error_Param;
         break;
     case ERR_EXCHANGE_FAILED:
-        m_shErrCode = DEC_DEV_NOT_FOUND;
+        m_shErrCode = DEP_DEV_NOT_FOUND;
         ret = Error_DevNotAvailable;
         break;
     case ERR_PIN_AUTHENTICATION_FAILED:
     case ERR_PIN_HOST_AUTHENTICATE_FAILED:
-        m_shErrCode = DEC_INVALID_AUTHENTICATION_MODE;
+        m_shErrCode = DEP_INVALID_AUTHENTICATION_MODE;
         ret = Error_DevNotAvailable;
         break;
     case ERR_PIN_INVALIDCUSTOMERDATA:
-        m_shErrCode =DEC_INVALID_PAN;
+        m_shErrCode =DEP_INVALID_PAN;
         ret = Error_Param;
         break;
     case ERR_PIN_ENC_KEYNOTFOUND:
     case ERR_PIN_KEYNOTFOUND:
     case ERR_PIN_STARTVALUE_KEYNOTFOUND:
-        m_shErrCode = DEC_INVALID_KEY_ID;
+        m_shErrCode = DEP_INVALID_KEY_ID;
         ret = Error_Param;
         break;
     case ERR_PIN_BATTERY_LOW:
-        m_shErrCode = DEC_EPP_BATTERY_LOWORERROR;
+        m_shErrCode = DEP_EPP_BATTERY_LOWORERROR;
         ret = Error_Succeed;
         break;
     case ERR_PIN_INVALIDDATA:
-        m_shErrCode = DEC_INVALID_PARAMETER;
+        m_shErrCode = DEP_INVALID_PARAMETER;
         ret = Error_Param;
         break;
     case ERR_PARAM_ERROR:
-        m_shErrCode =DEC_INVALID_PARAMETER;
+        m_shErrCode =DEP_INVALID_PARAMETER;
         ret = Error_Param;
         break;
     case ERR_PIN_DEVNOTOPEN:
-        m_shErrCode =DEC_DEV_NOT_OPENED;
+        m_shErrCode =DEP_DEV_NOT_OPENED;
         ret = Error_DevNotAvailable;
         break;
     case ERR_PIN_INVALIDKEYLENGTH:
-        m_shErrCode = DEC_INVALID_KEY_LEN;
+        m_shErrCode = DEP_INVALID_KEY_LEN;
         ret = Error_Param;
         break;
     case ERR_PIN_ENC_KEYUSEVIOLATION:
     case ERR_PIN_USEVIOLATION:
     case ERR_PIN_STARTVALUE_KEYUSEVIOLATION:
-        m_shErrCode = DEC_KEY_VIOLATION;
+        m_shErrCode = DEP_KEY_VIOLATION;
         ret = Error_Param;
         break;
     case ERR_PIN_DUPLICATEKEY:
-        m_shErrCode = DEC_KEY_LOADED_ALREADY;
+        m_shErrCode = DEP_KEY_LOADED_ALREADY;
         ret = Error_Param;
         break;
     case ERR_DATA_TOO_LONG:
-        m_shErrCode = DEC_INVALID_PARAMETER;
+        m_shErrCode = DEP_INVALID_PARAMETER;
         ret = Error_Param;
     case ERR_PIN_NOKEYRAM:
-        m_shErrCode = DEC_KEY_NO_MORE_SPACE;
+        m_shErrCode = DEP_KEY_NO_MORE_SPACE;
         ret = Error_Hardware;
         break;
     case ERR_PIN_CHECK_KCV_FAILED:
-        m_shErrCode = DEC_VERIFICATION_FAILED;
+        m_shErrCode = DEP_VERIFICATION_FAILED;
         ret = Error_Param;
         break;
     case ERR_PIN_PRESS_KEY_OVERTIME:
-        m_shErrCode = DEC_PRESS_KEY_TIMEOUT;
+        m_shErrCode = DEP_PRESS_KEY_TIMEOUT;
         ret = Error_DevCommFailed;
         break;
     case ERR_PIN_TIMEOUT:
-        m_shErrCode = DEC_PRESS_KEY_TIMEOUT;
+        m_shErrCode = DEP_PRESS_KEY_TIMEOUT;
         ret = Error_DevCommFailed;
         break;
     case ERR_PIN_KEY_CODE_NOT_FOUND:
-        m_shErrCode = DEC_UNEXPECTED_RET_VALUE;
+        m_shErrCode = DEP_UNEXPECTED_RET_VALUE;
         ret = Error_DevCommFailed;
         break;
     case ERR_PIN_UNSUPPORT:
     case ERR_PIN_NOT_SUPP:
-        m_shErrCode = DEC_PIN_FORMAT_UNSUPPORTED;
+        m_shErrCode = DEP_PIN_FORMAT_UNSUPPORTED;
         ret = Error_Param;
         break;
     default:
-        m_shErrCode = DEC_ERROR_CODE_UNRECOGNIZABLE;
+        m_shErrCode = DEP_ERROR_CODE_UNRECOGNIZABLE;
         ret = Error_NoDefine;
         break;
     }
-    LogM("ErrorInfo:[0x%x][0x%x]:%s", ret, iErrCode, m_szErrMsg);
+
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s(V%d.%d.%d.%d)", strFunc, nLine, m_szErrMsg, FILE_MAJOR, FILE_MINOR, FILE_REVISION, FILE_BUILD);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", m_shErrCode,chJson);
+    memset(&m_devErrInfo, 0x00, sizeof(m_devErrInfo));
+    m_devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
+    sprintf(m_devErrInfo.szErrMsg, m_szErrMsg);
+    LogM("ErrorInfo:[0x%x]:%s", ret, m_szErrMsg);
+    memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
+
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s(V%d.%d.%d.%d)", strFunc, nLine, m_szErrMsg, FILE_MAJOR, FILE_MINOR, FILE_REVISION, FILE_BUILD);
+    root_Obj.insert("ErrCode", m_shErrCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    memset(&m_devErrInfo, 0x00, sizeof(m_devErrInfo));
+    m_devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
+    sprintf(m_devErrInfo.szErrMsg, m_szErrMsg);
+    LogM("ErrorInfo:[0x%x]:%s", ret, m_szErrMsg);
+    memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
+    */
+
     return ret;
 }
 

DevAdapter/keba/PinPad.keba.1.1/PinPadClassImpl_ZT598M.h

@@ -11,7 +11,10 @@
 //#include "log4vendor.h"
 #pragma pack(push,1)
 //编译版本
-#define  FILE_VERSION  1
+#define  FILE_MAJOR  1
+#define  FILE_MINOR  0
+#define  FILE_REVISION  0
+#define  FILE_BUILD  1
 
 typedef struct tag_KeyReadData
 {
@@ -116,6 +119,7 @@ private:
     BOOL m_bNeedInitialization;
     CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
     short m_shErrCode;
+    DevErrorInfo m_devErrInfo;
     CHAR m_sIniPath[MAX_PATH];
     SetParamValueEnum m_enumEncryptMethod;
     SetParamValueEnum m_enumEcbCbcMode;
@@ -137,7 +141,7 @@ public:
     CZT598M1FD_DevCtrl *ZT598M1FD_DevCtrl;
 protected:
     BOOL ReadPinpadConfig(/*LPCTSTR lpszSPIniPath, */LPPinpadDevConfig lpDevConfig, LPPinpadSPConfig lpSPConfig);
-    ErrorCodeEnum SaveErrorInfo(int iErrCode);
+    ErrorCodeEnum SaveErrorInfo(int iErrCode, const CHAR* strFunc = NULL, int nLine = 0);
     ErrorCodeEnum EncryptCommon(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo, bool bMac = false);
 
 

DevAdapter/keba/PinPad.keba.1.1/ZT598MGFD_DevCtrl.cpp

@@ -710,363 +710,364 @@ VOID CZT598M1FD_DevCtrl::SetERRCode(LPCTSTR szFile, LONG lLine, BYTE byType, ULO
 
     lpErr->stCode.cErrType = byType;
     _itoa_s(ulERRCode, lpErr->stCode.sCode + (9 - strlen(szErrorCode)), 9, 16);
-
+    memset(m_stPinpadStatus.sDescription, 0x00, sizeof(m_stPinpadStatus.sDescription));
     switch (ulERRCode)
     {
     case STATUS_SUCCESS:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:status OK", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SUCCESS成功", ulERRCode);
         break;
     case STATUS_INVALID_COMMAND_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Command length not comply with definition.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_COMMAND_LENGTH命令长度错误", ulERRCode);
         break;
     case STATUS_INVALID_KEYID:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:KeyID(s) is outside of valid range.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_KEYID密钥ID超出范围", ulERRCode);
         break;
     case STATUS_INVALID_WRITE_MODE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Write Mode Specified.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_WRITE_MODE指定的写模式错误", ulERRCode);
         break;
     case STATUS_KEYID_NOT_EXIST:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key with specified ID doesn't exist.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEYID_NOT_EXIST指定的密钥ID不存在", ulERRCode);
         break;
     case STATUS_KEYID_LOCKED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key with specified ID is locked.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEYID_LOCKED指定的密钥ID被锁住", ulERRCode);
         break;
     case STATUS_INVALID_KEY_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The Key to be stored has invalid length.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_KEY_LENGTH要存储的密钥长度错误", ulERRCode);
         break;
     case STATUS_INVALID_KEY_ATTRIBUTES:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key ID has wrong attribute.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_KEY_ATTRIBUTES密钥属性错误", ulERRCode);
         break;
     case STATUS_INVALID_IV_ATTRIBUTES:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:IV has wrong attribute.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_IV_ATTRIBUTES向量属性错误", ulERRCode);
         break;
     case STATUS_KEY_ATTRIBUTES_NOT_MATCHED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key Attribute not Match the Attribute.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEY_ATTRIBUTES_NOT_MATCHED.密钥属性不匹配", ulERRCode);
         break;
     case STATUS_KCV_VERIFICATION_FAIL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key Check Value Verification Failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KCV_VERIFICATION_FAIL密钥校验值检查错误", ulERRCode);
         break;
     case STATUS_INVALID_KEY_VALUE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Other KeyId Has the Same Key Value.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_KEY_VALUE密钥值错误", ulERRCode);
         break;
     case STATUS_KEY_USEVIOLATION:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key with specified ID Use violation.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEY_USEVIOLATION违反密钥用法", ulERRCode);
         break;
     case STATUS_KEY_NOTALLOWED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key with specified ID Not Allowed to do that.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEY_NOTALLOWED指定的密钥不允许", ulERRCode);
         break;
     case STATUS_INVALID_CHECK_MODE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Check Mode Invalid.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CHECK_MODE检查模式错误", ulERRCode);
         break;
     case STATUS_INVALID_VERIFY_MODE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Verify Mode Invalid.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_VERIFY_MODE验证模式错误", ulERRCode);
         break;
     case STATUS_INVALID_MACING:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:KCV verification failed.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_MACING密钥验证错误", ulERRCode);
         break;
     case STATUS_INVALID_AUTHENTICATION_MODE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Macing Invalid Or Verify Failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_AUTHENTICATION_MODE授权模式错误", ulERRCode);
         break;
     case STATUS_INVALID_MODE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Mode or Entry Mode specified.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_MODE模式错误", ulERRCode);
         break;
     case STATUS_INVALID_DATA_SPECIFIED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid data - values out of range.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_DATA_SPECIFIED指定数据值超出范围", ulERRCode);
         break;
     case STATUS_INVALID_LENGTH_OR_SUM:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Length or Offset+Length - out of range.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_LENGTH_OR_SUM长度或者偏移量超出范围", ulERRCode);
         break;
     case STATUS_INVALID_OFFSET_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Offset or Length - out of range.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_OFFSET_LENGTH偏移量或者长度超出范围", ulERRCode);
         break;
     case STATUS_INVALID_PIN_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid PIN Length.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_PIN_LENGTH密码长度错误", ulERRCode);
         break;
     case STATUS_PIN_VERIFICATION_FAIL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN verification failed.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_PIN_VERIFICATION_FAIL密码校验失败", ulERRCode);
         break;
     case STATUS_PIN_ENCRYPTION_SUSPENDED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN Encryption Suspended ,try Pin after one hour.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_PIN_ENCRYPTION_SUSPENDED加密算法因操作频繁被挂起，1个小时后再尝试", ulERRCode);
         break;
     case STATUS_PIN_NOPIN:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:No Pin.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_PIN_NOPIN没有密码", ulERRCode);
         break;
     case STATUS_INVALID_PIN2_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The password in key buffer has wrong length.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_PIN2_LENGTH The password in key buffer has wrong length.", ulERRCode);
         break;
     case STATUS_PIN2_VERIFICATION_FAIL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The password in key buffer verification failed.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_PIN2_VERIFICATION_FAIL The password in key buffer verification failed.", ulERRCode);
         break;
     case STATUS_INVALID_MODULUS_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid modulus length specified.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_MODULUS_LENGTH指定的模长度错误", ulERRCode);
         break;
     case STATUS_INVALID_EXPONENT_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid exponent length specified.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_EXPONENT_LENGTH指定的指数长度错误", ulERRCode);
         break;
     case STATUS_INVALID_PKCS_STRUCTURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid structure received.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_PKCS_STRUCTURE PKCS结构错误", ulERRCode);
         break;
     case STATUS_INVALID_PKCS_PADDING:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid PKCS Padding.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_PKCS_PADDING PKCS填充错误", ulERRCode);
         break;
     case STATUS_INVALID_SIGNATURE_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Signature Length.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_SIGNATURE_LENGTH签名长度错误", ulERRCode);
         break;
     case STATUS_SIGNATURE_VERIFICATION_FAIL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Signature verification failed.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SIGNATURE_VERIFICATION_FAIL签名校验错误", ulERRCode);
         break;
     case STATUS_KEY_NOT_LOADED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key with specified ID not Loaded.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEY_NOT_LOADED指定ID对应的密钥没加载", ulERRCode);
         break;
     case STATUS_INVALID_CERTIFICATE_FROMAT:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALID CERTIFICATE FROMAT.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CERTIFICATE_FROMAT", ulERRCode);
         break;
     case STATUS_INVALID_CERTIFICATE_VERSION:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALID CERTIFICATE VERSION.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CERTIFICATE_VERSION", ulERRCode);
         break;
     case STATUS_INVALID_CERTIFICATE_VALIDITY:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALID CERTIFICATE ISSUER.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CERTIFICATE_VALIDITY", ulERRCode);
         break;
     case STATUS_INVALID_CERTIFICATE_ISSUER:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALID CERTIFICATE VALIDITY.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CERTIFICATE_ISSUER", ulERRCode);
         break;
     case STATUS_INVALID_CERTIFICATE_SUBJECT:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALID CERTIFICATE SUBJECT.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CERTIFICATE_SUBJECT", ulERRCode);
         break;
     case STATUS_INVALID_CERTIFICATE_ALGOR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALID CERTIFICATE ALGOR.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_CERTIFICATE_ALGOR", ulERRCode);
         break;
     case STATUS_CERTIFICATE_NOT_EXIST:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Certificate with specified ID Not Exist.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_CERTIFICATE_NOT_EXIST", ulERRCode);
         break;
     case STATUS_INVALID_DATA_DISABLEED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Data Disabled.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_DATA_DISABLEED错误数据被禁止", ulERRCode);
         break;
     case STATUS_INVALID_USERBLOCK_ADDRESS:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid User Block Address specified.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_USERBLOCK_ADDRESS用户数据区地址错误", ulERRCode);
         break;
     case STATUS_INVALID_SERIALNO_SPECIFIED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Serial Number specified.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_SERIALNO_SPECIFIED指定的系列号错误", ulERRCode);
         break;
     case STATUS_NO_CARD:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The smart card not set or not exist.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_NO_CARD The smart card not set or not exist.", ulERRCode);
         break;
     case STATUS_CARD_APDU_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The smart card not answer the APDU command.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_CARD_APDU_ERROR The smart card not answer the APDU command.", ulERRCode);
         break;
     case STATUS_KEY_INVALID:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid dukpt Key value.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEY_INVALID Invalid dukpt Key value.", ulERRCode);
         break;
     case STATUS_EMV_NOT_INITIALIZED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Dukpt not initialize.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_KEY_INVALID Dukpt not initialize.", ulERRCode);
         break;
     case STATUS_EMV_NOT_READY:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:KSN not imported.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EMV_NOT_READY KSN not imported.", ulERRCode);
         break;
     case STATUS_EMV_ALREADY_INITIALIZED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Already initialized.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EMV_ALREADY_INITIALIZED Already initialized.", ulERRCode);
         break;
     case STATUS_EMV_NEED_REINITIALIZE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:No resource.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EMV_NEED_REINITIALIZE No resource.", ulERRCode);
         break;
     case STATUS_EMV_TIMEOUT:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Software Timeout.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EMV_TIMEOUT Software Timeout.", ulERRCode);
         break;
     case STATUS_ALGORITHMNOTSUPP:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:ALGORITHM  UNSUPP.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_ALGORITHMNOTSUPP ALGORITHM  UNSUPP.", ulERRCode);
         break;
     case STATUS_COMMANDUPSUPP:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:COMMAND UNSUPP.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_COMMANDUPSUPP不支持的命令.", ulERRCode);
         break;
     case STATUS_ERROR_INTER_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:HARDWARE ERROR OR INTER ERROR.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_ERROR_INTER_ERROR硬件错误或者内部错误", ulERRCode);
         break;
     case STATUS_COMMAND_LOCK:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Command Lock :Not allow execute.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_COMMAND_LOCK命令被锁，不允许执行", ulERRCode);
         break;
     case STATUS_INVALID_COMMAND_MAC:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid Command MAC Value.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_COMMAND_MAC命令MAC值错误", ulERRCode);
         break;
     case STATUS_AUTHENTICATION_FAILED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Authentication failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_AUTHENTICATION_FAILED授权失败", ulERRCode);
         break;
     case STATUS_NOT_AUTHENTE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Key with specified ID doesn't authentication.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_NOT_AUTHENTE指定密钥未授权", ulERRCode);
         break;
     case STATUS_EPP_NOT_INITIALIZED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:EPP Keypair and/or Serial# signature not loaded.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EPP_NOT_INITIALIZED密码键盘未初始化，无密钥对或者系列号签名", ulERRCode);
         break;
     case STATUS_EPP_ALREADY_INITIALIZED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:EPP Keypair and/or Serial# signature already loaded.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EPP_ALREADY_INITIALIZED密码键盘已经初始化，已经加载密钥对及系列号", ulERRCode);
         break;
     case STATUS_CERTIFICATE_ALREADY:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:EPP Certification already loaded.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_CERTIFICATE_ALREADY EPP Certification already loaded.", ulERRCode);
         break;
     case STATUS_PHYSICALLY_NOT_INSTALLED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:EPP is not Physically Installed.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_PHYSICALLY_NOT_INSTALLED密码键盘没有物理安装", ulERRCode);
         break;
     case STATUS_LOGICALLY_NOT_INSTALLED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:EPP is not Logically Installed.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_PHYSICALLY_NOT_INSTALLED密码键盘没有逻辑安装", ulERRCode);
         break;
     case STATUS_INPUT_KEY_TIMEOUT:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:two pressed key time interval surpasses 1 minute.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INPUT_KEY_TIMEOUT两次按键间隔时间超过1分钟", ulERRCode);
         break;
     case STATUS_INVLAID_PASSWORD_LENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Password length error.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVLAID_PASSWORD_LENGTH密码长度错误", ulERRCode);
         break;
     case STATUS_INVALID_PASSWORD:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid password value.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_PASSWORD密码值错误", ulERRCode);
         break;
     case STATUS_INPUT_PASSWORD_LOCKED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The wrong password more than 5 times, Input Password command will be locked 24 hours.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INPUT_PASSWORD_LOCKED密码错超过5次，输入密码的命令将被锁24小时", ulERRCode);
         break;
     case STATUS_SYSTEM_TIME_NOT_SET:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The device's system time not set.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SYSTEM_TIME_NOT_SET设备没设置系统时间", ulERRCode);
         break;
     case STATUS_SYSTEM_TIME_ALREADY_SET:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The device's system time has been set.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SYSTEM_TIME_ALREADY_SET设备已经设置系统时间", ulERRCode);
         break;
     case STATUS_MRAM_HARDWARE_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:External Flash hardware error.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:外部闪存硬件错误", ulERRCode);
         break;
     case STATUS_DEVICE_TAMPERED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:The Device was tampered.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_DEVICE_TAMPERED设备被恶意破坏", ulERRCode);
         break;
     case STATUS_SM2_ENCRYPT_FAILURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Sm2 encrypt failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SM2_ENCRYPT_FAILURE SM2加密失败", ulERRCode);
         break;
     case STATUS_SM2_DECRYPT_FAILURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Sm2 decrypt failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SM2_DECRYPT_FAILURE Sm2解密失败", ulERRCode);
         break;
     case STATUS_SM2_SIGNATURE_FAILURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Sm2 signature failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SM2_SIGNATURE_FAILURE Sm2签名失败", ulERRCode);
         break;
     case STATUS_SM2_VERSIG_FAILURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:SM2 verify signature failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SM2_VERSIG_FAILURE SM2验签失败", ulERRCode);
         break;
     case STATUS_SM2_KEYEXC_FAILURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:SM2 Key exchange failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SM2_KEYEXC_FAILURE SM2密钥交换失败", ulERRCode);
         break;
     case STATUS_SM2_VER_KEYEXC_FAILURE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:SM2 Verify key exchange failure.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_SM2_VER_KEYEXC_FAILURE SM2验证密钥交换失败", ulERRCode);
         break;
     case STATUS_A980_NO_RESPONSE:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:chip no response.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_A980_NO_RESPONSE国密芯片无应答", ulERRCode);
         break;
     case STATUS_INVALID_SM4_KEYVAL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid sm4 key value.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_INVALID_SM4_KEYVAL国密密钥值错误", ulERRCode);
         break;
     case STATUS_OTHER_ABNORMAL_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Other abnormal error.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_OTHER_ABNORMAL_ERROR其它异常错误", ulERRCode);
         break;
     case STATUS_FW_VERIFY_FIAL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Verify signature fail.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_FW_VERIFY_FIAL验签失败", ulERRCode);
         break;
     case STATUS_FW_WRITE_FAIL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Write firmware fail.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_FW_WRITE_FAIL写固件失败", ulERRCode);
         break;
     case STATUS_FW_EARSE_FAIL:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Erase firmware fail.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_FW_EARSE_FAIL擦除固件失败", ulERRCode);
         break;
     case STATUS_EXTERNAL_FALSH_WRITE_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Write into flash fail.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_EXTERNAL_FALSH_WRITE_ERROR写闪存失败", ulERRCode);
         break;
     case STATUS_ADDRESS_OUTRANG:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Invalid address.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_ADDRESS_OUTRANG地址超出范围", ulERRCode);
         break;
     case STATUS_FLASH_CRC_CHECK_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:CRC Check value error.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:STATUS_FLASH_CRC_CHECK_ERROR闪存CRC校验值失败", ulERRCode);
         break;
     //case STATUS_APPCODE_NOT_COMPLETE:   duplicate with ERR_DATA_TOO_LONG
     //    sprintf(m_stPinpadStatus.sDescription, "0x%x:The Main FW is not download or tampered.", ulERRCode);
     //    break;
     case ERR_EXCHANGE_FAILED:
         sprintf(lpErr->stCode.sCode, ERR_CODE_OFFLINE);
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Device off line.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_EXCHANGE_FAILED设备离线", ulERRCode);
         break;
     case ERR_COMMON_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:COMMON_ERROR.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_COMMON_ERROR通讯失败", ulERRCode);
         break;
     case ERR_INTERNAL_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INTERNAL_ERROR.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_INTERNAL_ERROR内部错误", ulERRCode);
         break;
     case ERR_PIN_HOST_AUTHENTICATE_FAILED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:HOST_AUTHENTICATE_FAILED.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_HOST_AUTHENTICATE_FAILED主机授权失败", ulERRCode);
         break;
     case ERR_PIN_KEYNOTFOUND:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_KEYNOTFOUND.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_KEYNOTFOUND逻辑密钥丢失", ulERRCode);
         break;
     case ERR_PARAM_ERROR:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PARAM_ERROR.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PARAM_ERROR软件参数错误", ulERRCode);
         break;
     case ERR_DATA_TOO_LONG:
         if(byType == ERR_FROM_VENDOR) //STATUS_APPCODE_NOT_COMPLETE ERR_DATA_TOO_LONG
         {
-            sprintf(m_stPinpadStatus.sDescription, "0x%x:The Main FW is not download or tampered.", ulERRCode);
+            sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_DATA_TOO_LONG主固件下载失败或者损坏", ulERRCode);
         }
         else //ERR_DATA_TOO_LONG
         {
-            sprintf(m_stPinpadStatus.sDescription, "0x%x:DATA_TOO_LONG..", ulERRCode);
+            sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_DATA_TOO_LONG数据太长", ulERRCode);
         }
         break;
     case ERR_PIN_DUPLICATEKEY:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_DUPLICATEKEY.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_DUPLICATEKEY密码雷同", ulERRCode);
         break;
     case ERR_PIN_USEVIOLATION:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_USEVIOLATION.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_USEVIOLATION用法错误", ulERRCode);
         break;
     case ERR_PIN_UNSUPPORT:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_UNSUPPORT.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_UNSUPPORT不支持", ulERRCode);
         break;
     case ERR_PIN_CHECK_KCV_FAILED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_CHECK_KCV_FAILED.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_CHECK_KCV_FAILED校验值错误", ulERRCode);
         break;
     case ERR_PIN_INVALIDKEYLENGTH:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:INVALIDKEYLENGTH.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_INVALIDKEYLENGTH密钥长度错误.", ulERRCode);
         break;
     case ERR_PIN_NOKEYRAM:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_NOKEYRAM.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_NOKEYRAM无密钥存储空间", ulERRCode);
         break;
     case ERR_PIN_ENC_KEYUSEVIOLATION:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_ENC_KEYUSEVIOLATION.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_ENC_KEYUSEVIOLATION密钥用法错", ulERRCode);
         break;
     case ERR_PIN_ENC_KEYNOTFOUND:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_ENC_KEYNOTFOUND.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_ENC_KEYNOTFOUND密钥没找到", ulERRCode);
         break;
     case ERR_PIN_PHYSICALLY_UNINSTALLED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_PHYSICALLY_UNINSTALLED.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_PHYSICALLY_UNINSTALLED密码键盘没有物理安装", ulERRCode);
         break;
     case ERR_PIN_AUTHENTICATION_FAILED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:AUTHENTICATION_FAILED.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_AUTHENTICATION_FAILED授权失败", ulERRCode);
         break;
     case ERR_PIN_STARTVALUE_KEYNOTFOUND:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_STARTVALUE_KEYNOTFOUND.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_STARTVALUE_KEYNOTFOUND没找到初始值密钥", ulERRCode);
         break;
     case ERR_PIN_STARTVALUE_KEYUSEVIOLATION:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_STARTVALUE_KEYUSEVIOLATION.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_STARTVALUE_KEYUSEVIOLATION初始值密钥用法错误", ulERRCode);
         break;
     case ERR_PIN_INVALIDDATA:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_INVALIDDATA.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_INVALIDDATA数据错误", ulERRCode);
         break;
     case ERR_PIN_KEY_CODE_NOT_FOUND:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_KEY_CODE_NOT_FOUND.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_KEY_CODE_NOT_FOUND", ulERRCode);
         break;
     case ERR_PIN_LOGICALLY_UNINSTALLED:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_LOGICALLY_UNINSTALLED.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_LOGICALLY_UNINSTALLED密码键盘没有逻辑安装", ulERRCode);
         break;
     case ERR_PIN_NEED_INITIALIZATION:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_NEED_INITIALIZATION.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_NEED_INITIALIZATION密码键盘需要初始化", ulERRCode);
         break;
     case ERR_PIN_BATTERY_LOW:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_BATTERY_LOW.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_BATTERY_LOW电池电量低", ulERRCode);
         break;
     case ERR_PIN_PRESS_KEY_OVERTIME:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:PIN_PRESS_KEY_OVERTIME.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:ERR_PIN_PRESS_KEY_OVERTIME按键时间超时", ulERRCode);
         break;
     default:
-        sprintf(m_stPinpadStatus.sDescription, "0x%x:Unknown error.", ulERRCode);
+        sprintf(m_stPinpadStatus.sDescription, "0x%x:Unknown error未定义的错误", ulERRCode);
         break;
    }
+    sprintf(m_stPinpadStatus.sDescription, "%s(%s:%d)", m_stPinpadStatus.sDescription, szFile, lLine);
 }
 
 BOOL CZT598M1FD_DevCtrl::ClearKeyInfo(BYTE byLogicKeyId, BOOL bSM)

DevAdapter/keba/PinPad.keba.1.1/stdafx.h

@@ -7,6 +7,10 @@
 
 
 // TODO: 在此处引用程序需要的其他头文件
+//#include <QJsonDocument>//参考链接：https://www.cnblogs.com/whik/p/11234889.html
+//#include <QJsonObject>
+//#include <QJsonArray>
+
 #include "cstdlib"
 #include <string.h>
 #include <stdarg.h>
@@ -25,6 +29,6 @@
 //#include "TraceManager.h"
 #include "CkLog.h"
 #include "PinPadClass.h"
-#include "DevErrorCode.h"
+#include "DepErrorCode.h"
 #include <dlfcn.h>
 

DevAdapter/keba/Ups.keba.1.1/CMakeLists.txt

@@ -6,6 +6,8 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
 
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
@@ -34,6 +36,8 @@ message(STATUS "KEBA_include_directories: ${INCLUDE_KEBA}")
 
 #设置日志依赖库文件的路径变量路径
 target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${DEVADAPTER_CURRENT_LIB_DIR})
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
 
 #86下依赖的库连接这个文件路径:/data/home/keba/DevAdapter/keba/lib/gcc_x64?gcc_aarch64
 #target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR})

DevAdapter/keba/Ups.keba.1.1/UpsClassImpl_East.cpp

@@ -65,7 +65,8 @@ UpsClassImpl::UpsClassImpl() :
     memset( m_cDevType, 0x00, sizeof(m_cDevType) );
     memset( m_cFWMain, 0x00, sizeof(m_cFWMain) );
     memset( &m_stDevStatus, 0x00, sizeof (m_stDevStatus));
-    SaveErrorInfo("OK", Error_Succeed);
+    memset(m_szErrMsg, 0x00, sizeof (m_szErrMsg));
+    SaveErrorInfo("UpsClassImpl 成功", DEP_SUCCESS, __FUNCTION__ , __LINE__);
 }
 
 UpsClassImpl::~UpsClassImpl()
@@ -85,7 +86,9 @@ ErrorCodeEnum UpsClassImpl::GetDevStatus(UpsStatusEnum &eStatus)
     {
         if(DevOpen(m_nPort, m_nBaudRate) != Error_Succeed)
         {
-            SaveErrorInfo("GetDevStatus() DevOpen() failed", Error_DevNotAvailable);
+            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+            sprintf(strMsg, "端口错误: port=%d, baudrate=%d", m_nPort, m_nBaudRate);
+            SaveErrorInfo(strMsg, DEP_INVALID_PORT, __FUNCTION__, __LINE__);
             g_SerialComm.Disconnect(m_hDevHnd);				//Get status failed
             m_hDevHnd = NULL;
             m_bDevOpen = false;
@@ -97,7 +100,7 @@ ErrorCodeEnum UpsClassImpl::GetDevStatus(UpsStatusEnum &eStatus)
     {
         if(g_SerialComm.SendAndReceive(m_hDevHnd, sCommand, strlen((char*)sCommand), 10, &stComResult) != 0)
         {
-            SaveErrorInfo("GetDevStatus() SendAndReceive failed", Error_DevNotAvailable);
+            SaveErrorInfo("g_SerialComm.SendAndReceive 通讯失败", DEP_COMMUNICATION_FAILED, __FUNCTION__, __LINE__);
             g_SerialComm.Disconnect(m_hDevHnd);				//Get status failed
             m_hDevHnd = NULL;
             m_bDevOpen = false;
@@ -133,12 +136,14 @@ ErrorCodeEnum UpsClassImpl::Shutdown(DWORD dwShutTime,DWORD dwRestartTime)
     {
         //LogM("Shutdown(dwShutTime=%d, dwRestartTime=%d): invalid parameter", dwShutTime, dwRestartTime);
         //sprintf(strErrorInfo,"Shutdown(dwShutTime=%d, dwRestartTime=%d): invalid parameter", dwShutTime, dwRestartTime);
-        SaveErrorInfo("Shutdown() invalid parameter",Error_Param );
+        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
+        sprintf(strMsg, "Shutdown() 参数错误:dwShutTime=%d, dwRestartTime=%d", dwShutTime, dwRestartTime);
+        SaveErrorInfo(strMsg,DEP_INVALID_PARAMETER, __FUNCTION__, __LINE__);
         return Error_Param;
     }
     if( !m_bDevOpen )
     {
-        SaveErrorInfo("Shutdown()->Dev is not open",Error_DevNotAvailable );
+        SaveErrorInfo("设备未打开", DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
     dataBuf[0]=0x53;
@@ -167,7 +172,7 @@ ErrorCodeEnum UpsClassImpl::Shutdown(DWORD dwShutTime,DWORD dwRestartTime)
     nRet = g_SerialComm.SendData(m_hDevHnd, dataBuf, nLen );
     if(nRet < 0)
     {
-        SaveErrorInfo("GetDevStatus() DevOpen() failed", Error_DevNotAvailable);
+        SaveErrorInfo("g_SerialComm.SendData 发送数据失败", DEP_COMMUNICATION_FAILED, __FUNCTION__, __LINE__);
         g_SerialComm.Disconnect(m_hDevHnd);				//Get status failed
         m_hDevHnd = NULL;
         m_bDevOpen = false;
@@ -199,6 +204,7 @@ ErrorCodeEnum UpsClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
     memcpy(devCategory.szType, "keba.UPS.EAST", strlen("keba.UPS.EAST"));
     memcpy(devCategory.szModel, "", strlen(""));
     memcpy(devCategory.szVendor, "keba", strlen("keba"));
+    /*
     char sPath[256], sFile[128] = {0};
     GetCurModulePath(sPath, sFile);
     short v1,v2;
@@ -208,10 +214,18 @@ ErrorCodeEnum UpsClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
 
     devCategory.version.wRevision = 0xffff;
     devCategory.version.wBuild = FILE_VERSION;
-    //devCategory.version.wRevision = 0xFFFF;
-    //devCategory.version.wBuild = 1;
-    //devCategory.version.wMajor = 0;
-    //devCategory.version.wMinor = 0;
+    */
+    devCategory.version.wMajor = FILE_MAJOR;
+    devCategory.version.wMinor = FILE_MINOR;
+    devCategory.version.wRevision = FILE_REVISION;
+    devCategory.version.wBuild = FILE_BUILD;
+    LogM( "devCategory.szType=%s",devCategory.szType);
+    LogM( "devCategory.szModel=%s", devCategory.szModel);
+    LogM( "devCategory.szVendor=%s",devCategory.szVendor);
+    LogM( "devCategory.eState=%d",devCategory.eState);
+    LogM( "devCategory.version=%d.%d.%d.%d", devCategory.version.wMajor, devCategory.version.wMinor, devCategory.version.wRevision, devCategory.version.wBuild);
+    LogM("==>Leave PinPadClassImpl::GetDevCategory()");
+
     return Error_Succeed;
 }
 
@@ -257,8 +271,8 @@ ErrorCodeEnum UpsClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     if(nullptr == lpPort)
     {
         m_bDevOpen = false;
-        sprintf(szErrorMsg, "Invalid COM name");
-        SaveErrorInfo(szErrorMsg, Error_DevNotAvailable);
+        sprintf(szErrorMsg, "串口名称错误");
+        SaveErrorInfo(szErrorMsg, DEP_INVALID_PORT, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
 
@@ -266,14 +280,14 @@ ErrorCodeEnum UpsClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     int ret = g_SerialComm.Connect(m_cDeviceID, 2400, 2, 1, &m_hDevHnd, 8);
     if( ret == 0) //返回0， 串口打开成功
     {
-        sprintf(szErrorMsg, "Open %s OK:%d COM：%s", lpPort, ret, m_cDeviceID);
-        SaveErrorInfo(szErrorMsg, Error_Succeed);
+        sprintf(szErrorMsg, "打开串口 %s 成功:%d 串口：%s", lpPort, ret, m_cDeviceID);
+        SaveErrorInfo(szErrorMsg, DEP_SUCCESS, __FUNCTION__, __LINE__);
     }
     else
     {
         m_bDevOpen = false;
-        sprintf(szErrorMsg, "Open %s OK:%d COM：%s", lpPort, ret, m_cDeviceID);
-        SaveErrorInfo(szErrorMsg, Error_DevNotAvailable);
+        sprintf(szErrorMsg, "打开串口 %s 失败:%d 串口：%s", lpPort, ret, m_cDeviceID);
+        SaveErrorInfo(szErrorMsg, DEP_INVALID_PORT, __FUNCTION__, __LINE__);
         return Error_DevNotAvailable;
     }
 
@@ -282,11 +296,35 @@ ErrorCodeEnum UpsClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
     return GetDevStatus(eStatus);
 }
 
-void UpsClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
+void UpsClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
 {
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s(V%d.%d.%d.%d)", strFunc, nLine, errMsg, FILE_MAJOR, FILE_MINOR, FILE_REVISION, FILE_BUILD);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+
+    /*
+    //QTJson
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s(V%d.%d.%d.%d)", strFunc, nLine, errMsg, FILE_MAJOR, FILE_MINOR, FILE_REVISION, FILE_BUILD);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
+    //QByteArray ba = strJson.toLatin1();
+    //char* sErrMsg = ba.data();
+    //memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
+    //sprintf(m_szErrMsg, sErrMsg);
+    //LogM(m_szErrMsg);
     memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
-    sprintf(m_szErrMsg, "%s[%d]", errMsg, errCode);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
     LogM(m_szErrMsg);
+    */
 }
 
 char* UpsClassImpl::GetCOMPortString(DWORD dwCOM)

DevAdapter/keba/Ups.keba.1.1/UpsClassImpl_East.h

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #ifndef UPSCLASSIMPL_EAST_H
 #define UPSCLASSIMPL_EAST_H
 #include "stdafx.h"
@@ -7,7 +7,11 @@
 
 
 //编译版本
-#define  FILE_VERSION  1
+//编译版本
+#define  FILE_MAJOR  1
+#define  FILE_MINOR  0
+#define  FILE_REVISION  0
+#define  FILE_BUILD  1
 
 struct StDevStatus
 {
@@ -51,7 +55,8 @@ public:
     CHAR		m_cFWMain[256];
 
 private:
-    void SaveErrorInfo(CHAR* errMsg, int errCode);
+    //void SaveErrorInfo(CHAR* errMsg, int errCode, CHAR* strFunc = NULL, int nLine = 0);
+    void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
     char* GetCOMPortString(DWORD dwCOM);
     int m_nPort;
     int m_nBaudRate;

DevAdapter/keba/Ups.keba.1.1/stdafx.h

@@ -1,33 +1,21 @@
-// stdafx.h : 标准系统包含文件的包含文件，
+// stdafx.h : 标准系统包含文件的包含文件，
 // 或是经常使用但不常更改的
 // 特定于项目的包含文件
 //
 
 #pragma once
-
-
 // TODO: 在此处引用程序需要的其他头文件
+//#include <QJsonParseError>  //https://www.cnblogs.com/whik/p/11234889.html
+//#include <QVariantMap>
+//#include <QJsonDocument>//参考链接：https://www.cnblogs.com/whik/p/11234889.html
+//#include <QJsonObject>
+//#include <QJsonArray>
+//#include <QApplication>
+
 #include "winfunc.h"
 #include "UpsClass.h"
 #include "CkLog.h"
 #include "SerialComm.h"
 #include "CommDef.h"
-
-/*
-#include "cstdlib"
-#include <string.h>
-#include <stdarg.h>
-#include "FileDir.h"
-#include "FileAccess.h"
-#include "Algorithm.h"
-#include "EntryDes.h"
-#include "CommDef.h"
-#include "DataConvert.h"
-#include "DevComm.h"
-#include "lfsapi.h"
-#include "FileDir.h"
-#include "INIAccess.h"
-#include "DevErrorCode.h"
-#include <dlfcn.h>
-*/
+#include "DepErrorCode.h"
 

DevAdapter/keba/WatchDog.keba.1.1/CMakeLists.txt

@@ -6,6 +6,8 @@ set(${MODULE_PREFIX}_VENDOR "keba")
 set(${MODULE_PREFIX}_VERSION "1")
 set(${MODULE_PREFIX}_BATCH "1")
 
+#链接QT5 使用<Q..>头文件
+#find_package(Qt5 COMPONENTS Core Gui Qml Quick REQUIRED)
 
 #设置编译的一些参数
 if(NOT RVC_INTEGRATE_BUILD)
@@ -40,6 +42,10 @@ target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${DEVADAPTER_CURRENT_LIB_DIR
 target_link_directories(${MODULE_FULL_NAME} PUBLIC  ${VENDOR_CURRENT_LIB_DIR}/keba)
 #链接招行日志库
 target_link_libraries(${MODULE_FULL_NAME} ${VENDOR_LOG_LIB_NAME})
+
+#链接QT5 使用<Q..>头文件
+#target_link_libraries(${MODULE_FULL_NAME}  Qt5::Core Qt5::Gui Qt5::Qml Qt5::Quick)
+
 #链接keba依赖库
 #target_link_libraries(${MODULE_FULL_NAME} DevComm.keba Algorithm.keba DataConvert.keba winfunc.keba FileDir.keba INIAccess.keba FileAccess.keba TraceManager.keba TimerCtrl.keba)
 target_link_libraries(${MODULE_FULL_NAME} Common.keba)

DevAdapter/keba/WatchDog.keba.1.1/WatchDogClassImpl.cpp

@@ -1,7 +1,11 @@
 #include "WatchDogClassImpl.h"
+//#include <QJsonParseError>  //https://www.cnblogs.com/whik/p/11234889.html
+//#include <QVariantMap>
+//#include <QJsonObject>
+//#include <QJsonArray>
+#include "DepErrorCode.h"
 //#include "CkLog.h"
 
-
 LOG_EXTERN()
 //extern CTraceManager g_Trace;
 static DWORD dwWDTTime = 0;
@@ -74,20 +78,27 @@ ErrorCodeEnum WatchDogClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
 ErrorCodeEnum WatchDogClassImpl::Reset()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     if (!m_bDevOpen)
     {
-        SaveErrorInfo("Reset m_bDevOpen is null!", Error_DevNotAvailable);
+        sprintf(szErrorMsg, "设备未初始化");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_NOT_INITIALIZED, __FUNCTION__, __LINE__);
         LogE("WatchDogClassImpl::Reset()->Reset m_bDevOpen is nullline=%d",__LINE__);
         return Error_DevNotAvailable;
     }
 
     if(m_wfd == NULL)
     {
-        SaveErrorInfo("Reset m_pMB330CRM is null!", Error_DevNotAvailable);
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LogE("WatchDogClassImpl::Reset()->Reset m_wfd is null! line=%d",__LINE__);
         return Error_DevNotAvailable;
     }
-    ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD);
+    if(-1==ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD))
+    {
+        sprintf(szErrorMsg, "设置看门狗关闭状态失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
+    }
     LogM("WatchDogClassImpl::Reset()->Reset is Execute success! line=%d",__LINE__);
     return Error_Succeed;
 }
@@ -95,14 +106,20 @@ ErrorCodeEnum WatchDogClassImpl::Reset()
 ErrorCodeEnum WatchDogClassImpl::DevClose()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     m_bDevOpen = false;
     if(m_wfd == NULL)
     {
-        SaveErrorInfo("DevClose m_pMB330CRM is null!", Error_DevNotAvailable);     
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LogE(" WatchDogClassImpl::DevClose()-> DevClose m_wfd is null! line=%d",__LINE__);
         return Error_DevNotAvailable;
     }
-    ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD) ;
+    if(-1==ioctl(m_wfd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD) )
+    {
+        sprintf(szErrorMsg, "设置看门狗关闭状态失败");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
+    }
     char stopmagic='v';
     write(m_wfd, &stopmagic, sizeof(stopmagic));
     close(m_wfd);
@@ -122,10 +139,12 @@ ErrorCodeEnum WatchDogClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
 ErrorCodeEnum WatchDogClassImpl::DevOpen()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     int preset_timeout{0};
     if(m_bDevOpen)
     {
-        SaveErrorInfo("DevOpen DevAlreadyConnected!");
+        sprintf(szErrorMsg, "设备已经连接成功");
+        SaveErrorInfo(szErrorMsg, DEP_ALREADY_EXIST, __FUNCTION__, __LINE__);
         LogW("DevOpen DevAlreadyConnected! line=%d",__LINE__);
         return  Error_DevAlreadyConnected;
     }
@@ -135,6 +154,8 @@ ErrorCodeEnum WatchDogClassImpl::DevOpen()
         m_wfd = open(WATCHDOG0, O_RDWR);
         if (m_wfd == -1)
         {
+            sprintf(szErrorMsg, "看门狗设备文件打开失败，检查驱动");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_DRIVER_ERROR, __FUNCTION__, __LINE__);
             eErr = Error_Failed;
             LogE("WatchDogClassImpl::DevOpen Error_DevCommFailed=%d line=%d",eErr,__LINE__);
             return Error_Failed;
@@ -146,6 +167,8 @@ ErrorCodeEnum WatchDogClassImpl::DevOpen()
        int flag=WDIOS_DISABLECARD;
        if(-1== ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
        {
+           sprintf(szErrorMsg, "设置看门狗关闭状态失败");
+           SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
             LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_DISABLECARD); line=%d",__LINE__);
        }
        else
@@ -160,10 +183,14 @@ ErrorCodeEnum WatchDogClassImpl::DevOpen()
         /*测试能否获取看门狗打开后，默认的时间*/
         if(-1==ioctl(m_wfd, WDIOC_GETTIMEOUT, &preset_timeout))
         {
+            sprintf(szErrorMsg, "获取看门狗超时时间失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_READ_ERROR, __FUNCTION__, __LINE__);
             LogW("-1==ioctl(m_wfd, WDIOC_GETTIMEOUT, &preset_timeout=%d) line=%d",preset_timeout,__LINE__);
             char stopmagic = 'V';
             if (write(m_wfd, &stopmagic, sizeof(stopmagic)) != sizeof(stopmagic))
             {
+                sprintf(szErrorMsg, "缓存溢出");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_MORE_DATA, __FUNCTION__, __LINE__);
                 LogW("Watchdog magic stop write error  line=%d",__LINE__);
             }
             close(m_wfd);
@@ -177,6 +204,8 @@ ErrorCodeEnum WatchDogClassImpl::DevOpen()
     }
     else
     {
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         eErr = Error_DevCommFailed;
         LogE("WatchDogClassImpl::DevOpen Error_DevCommFailed=%d line=%d",eErr,__LINE__);
     }
@@ -186,16 +215,19 @@ ErrorCodeEnum WatchDogClassImpl::DevOpen()
 ErrorCodeEnum WatchDogClassImpl::StartWatch(DWORD dwDelay, DWORD dwTimeout)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     LogE("StartWatch dwDelay=%d,dwTimeout=%d,line=%d",dwDelay,dwTimeout,__LINE__);
     if (!m_bDevOpen)
     {
-        SaveErrorInfo("StartWatch m_bDevOpen is null!");
+        sprintf(szErrorMsg, "设备未初始化");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_NOT_INITIALIZED, __FUNCTION__, __LINE__);
         LogE("StartWatch m_bDevOpen is null! line=%d",__LINE__);
         return Error_DevNotAvailable;
     }
     if(m_wfd == NULL)
     {
-        SaveErrorInfo("StartWatch m_pMB330CRM is null!");
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LogE("StartWatch m_pMB330CRM is null! Error_DevNotAvailable=%d line=%d",Error_DevNotAvailable,__LINE__);
         return Error_DevNotAvailable;
     }
@@ -242,6 +274,8 @@ ErrorCodeEnum WatchDogClassImpl::StartWatch(DWORD dwDelay, DWORD dwTimeout)
             int flag=WDIOS_ENABLECARD;
             if(-1== ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
             {
+                sprintf(szErrorMsg, "设置看门狗开启状态失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
                 LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_ENABLECARD); line=%d",__LINE__);
             }
             dwTimeout=1;
@@ -255,10 +289,16 @@ ErrorCodeEnum WatchDogClassImpl::StartWatch(DWORD dwDelay, DWORD dwTimeout)
             int flag=WDIOS_ENABLECARD;
             if(-1== ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
             {
+                sprintf(szErrorMsg, "设置看门狗开启状态失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
                 LogW("-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag=WDIOS_ENABLECARD); line=%d",__LINE__);
             }
             LogW("dwTimeout=%d, line=%d",dwTimeout,__LINE__);
-            ioctl(m_wfd,WDIOC_SETTIMEOUT,&dwTimeout);
+            if(-1==ioctl(m_wfd,WDIOC_SETTIMEOUT,&dwTimeout))
+            {
+                sprintf(szErrorMsg, "设置看门狗超时时间失败");
+                SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
+            }
             return Error_Succeed;
         }
         else if (dwTimeout > 178)
@@ -284,9 +324,11 @@ ErrorCodeEnum WatchDogClassImpl::StartWatch(DWORD dwDelay, DWORD dwTimeout)
 ErrorCodeEnum WatchDogClassImpl::StopWatch()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     if (!m_bDevOpen)
     {
-        SaveErrorInfo("StopWatch m_bDevOpen is null!");
+        sprintf(szErrorMsg, "设备未初始化");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_NOT_INITIALIZED, __FUNCTION__, __LINE__);
         LogE(" WatchDogClassImpl::StopWatch()->StopWatch m_bDevOpen is null !");
         return Error_DevNotAvailable;
     }
@@ -312,7 +354,11 @@ ErrorCodeEnum WatchDogClassImpl::StopWatch()
     {
         //m_pMB330CRM->StopWDT();
         int flag = WDIOS_DISABLECARD;
-        ioctl(m_wfd, WDIOC_SETOPTIONS, &flag);
+        if(-1==ioctl(m_wfd, WDIOC_SETOPTIONS, &flag))
+        {
+            sprintf(szErrorMsg, "设置看门狗关闭状态失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
+        }
         char stopmagic = 'V';
         write(m_wfd, &stopmagic, sizeof(stopmagic));
     }
@@ -324,16 +370,19 @@ ErrorCodeEnum WatchDogClassImpl::StopWatch()
 ErrorCodeEnum WatchDogClassImpl::RefreshDog()
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     if (!m_bDevOpen)
     {
-        SaveErrorInfo("RefreshDog m_bDevOpen is null!");
+        sprintf(szErrorMsg, "设备未初始化");
+        SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_NOT_INITIALIZED, __FUNCTION__, __LINE__);
         LogW("WatchDogClassImpl::RefreshDog()->RefreshDog m_bDevOpen is false! line=%d",__LINE__);
         return Error_DevNotAvailable;
     }
 
     if(m_wfd == NULL)
     {
-        SaveErrorInfo("RefreshDog m_pMB330CRM is null!");
+        sprintf(szErrorMsg, "设备未打开");
+        SaveErrorInfo(szErrorMsg, DEP_DEV_NOT_OPENED, __FUNCTION__, __LINE__);
         LogE(" WatchDogClassImpl::RefreshDog()->RefreshDog m_wfd is null! line=%d",__LINE__);
         return Error_DevNotAvailable;
     }
@@ -359,7 +408,11 @@ ErrorCodeEnum WatchDogClassImpl::RefreshDog()
             m_TimerCtrl->EndTimer_ptr(m_mmWDTTimerID);
             LogW("WatchDogClassImpl::RefreshDog()->RefreshDog  Kill m_mmWDTTimerID = %d !", m_mmWDTTimerID );
         }
-        ioctl(m_wfd, WDIOC_KEEPALIVE, 0);
+        if(-1==ioctl(m_wfd, WDIOC_KEEPALIVE, 0))
+        {
+            sprintf(szErrorMsg, "重置看门狗超时时间失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
+        }
         m_TimerCtrl->SetTimerFunction(WDTTimer);
         m_TimerCtrl->StartTimer_ptr(m_mmDelayTimerID,this, _TIMER_DELAY,TRUE);
         LogW("WatchDogClassImpl::RefreshDog()->RefreshDog  timeSetEvent m_mmWDTTimerID = %d !", m_mmWDTTimerID );
@@ -369,13 +422,17 @@ ErrorCodeEnum WatchDogClassImpl::RefreshDog()
     else
     {
         //m_pMB330CRM->TimeOutFresh();
-        ioctl(m_wfd, WDIOC_KEEPALIVE, 0);
+        if(-1==ioctl(m_wfd, WDIOC_KEEPALIVE, 0))
+        {
+            sprintf(szErrorMsg, "重置看门狗超时时间失败");
+            SaveErrorInfo(szErrorMsg, DEP_NO_E_WATCHDOG_WRITE_ERROR, __FUNCTION__, __LINE__);
+        }
         LogW("WatchDogClassImpl::RefreshDog()->RefreshDog  TimeOutFresh ok!");
     }
     LogW("WatchDogClassImpl::RefreshDog()->RefreshDog is Execute success!");
     return Error_Succeed;
 }
-
+/*
 void WatchDogClassImpl::SaveErrorInfo(CHAR *errMsg, int errCode)
 {
     LOG_FUNCTION();
@@ -383,39 +440,39 @@ void WatchDogClassImpl::SaveErrorInfo(CHAR *errMsg, int errCode)
     sprintf(m_szErrMsg, "%s[%d]", errMsg, errCode);
     LogE("SaveErrorInfo(errMsg=%s, errCode=%d)",errMsg,errCode);
 }
-
+*/
+//Private
+void WatchDogClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
+{
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
+    LogM(m_szErrMsg);
+
+    /*
+    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
+    QJsonObject root_Obj;
+    QJsonDocument root_Doc;
+    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
+    root_Obj.insert("ErrCode", errCode);
+    root_Obj.insert("Description", chJson);
+    root_Doc.setObject(root_Obj);
+    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
+    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
+    QString strJson(root_str);
+    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
+    sprintf(m_szErrMsg, strJson.toUtf8().data());
+    LogM(m_szErrMsg);
+    */
+}
 void WatchDogClassImpl::DelayTimer(sigval_t ptr)
 {
     LOG_FUNCTION();
+    char szErrorMsg[256] = {0};
     WatchDogClassImpl *pThis = (WatchDogClassImpl *)ptr.sival_ptr;
-
     static bool bTimeSet = false;
 
-//    if (pThis->m_dwDelayTime > 0 && !bTimeSet)
-//    {
-//        dwDelayTime++ ;
-//        if (dwDelayTime < pThis->m_dwDelayTime)
-//        {
-//            return;
-//        }
-//        //timeKillEvent(pThis->m_mmDelayTimerID);
-//        pThis->m_TimerCtrl->EndTimer_ptr(pThis->m_mmDelayTimerID);
-
-//        if (pThis->m_dwDelayRemain > 0 && !bTimeSet)
-//        {
-//            //pThis->m_mmDelayTimerID = timeSetEvent( pThis->m_dwDelayRemain*1000, 1, &DelayTimer, (DWORD)pThis, TIME_ONESHOT );
-//            pThis->m_TimerCtrl->SetTimerFunction(DelayTimer);
-//            pThis->m_TimerCtrl->StartTimer_ptr(pThis->m_mmDelayTimerID,pThis,pThis->m_dwDelayRemain*1000,FALSE);
-//            LogW("WatchDogClassImpl::DelayTimer->DelayTimer TimeOut timeSetEvent  m_mmWDTTimerID = %d !  TIME_ONESHOT line=%d ", pThis->m_mmWDTTimerID ,__LINE__);
-//            pThis->m_bDelayTimer = true;
-//            bTimeSet = true;
-//            if (bTimeSet)
-//            {
-//                return;
-//            }
-//        }
-//    }
-
     //Start WDTTimer
     if(0==pThis->m_dwRealTimeOut)
     {

DevAdapter/keba/WatchDog.keba.1.1/WatchDogClassImpl.h

@@ -95,8 +95,8 @@ public:
         timer_t m_mmWDTTimerID;
         //CHAR m_szErrMsg[MAX_DEV_ERR_MSG];
         CHAR m_szErrMsg[MAX_DEV_ERROR_MSG_LEN];
-        void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
-
+        //void SaveErrorInfo(CHAR* errMsg, int errCode=95555);
+        void SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc = NULL, int nLine = 0);
 
         std::string m_LogFileNamePath;
         int m_wfd;

Module/include/DevFSMCommBase.hpp

@@ -691,7 +691,7 @@ inline void CCommDevFSM<TFSM, TDevClass>::LogErrMsg(
 template<class TFSM, class TDevClass>
 inline void CCommDevFSM<TFSM, TDevClass>::LogErrMsgEx(ErrorPackage errPkg, const char* pMsgBody, DWORD finalErrCode /*= 0*/, BOOL bToBusiness)
 {
-	CSimpleStringA alarmMsg = CSimpleStringA::Format("(%s)%s failed EC= 0x%x : %s", errPkg.devSN.GetData(), errPkg.msgHead.GetData(), errPkg.devErrCode, pMsgBody);
+	CSimpleStringA alarmMsg = CSimpleStringA::Format("(%s)%s failed EC= %s : %s", errPkg.devSN.GetData(), errPkg.msgHead.GetData(), SpStrError(errPkg.devErrCode), pMsgBody);
 	if (bToBusiness)
 		LogError(Severity_High, errPkg.devErrCode, finalErrCode, alarmMsg.GetData());
 	else

Module/include/EventCode.h

@@ -592,6 +592,15 @@ ERROR_ACCESSAUTH_CONNECT_ACS}
 #define LOG_WARN_COUNTERCONNECT_CALL_CONNECT_TIME					0x30460008	 //call connect time
 #define LOG_WARN_COUNTERCONNECT_ASSIST_CONNECT_FAILED				0x30460009	 //assist channel connect failed
 #define LOG_WARN_COUNTERCONNECT_SIP_CONNECT_FAILED					0x3046000A	 //sip channel connect failed
+#define LOG_WARN_COUNTERCONNECT_CALL_STATE_TRANS					0x3046000B	 //call state trans
+#define LOG_WARN_COUNTERCONNECT_BROADCAST_CALL_STATE				0x3046000C	 //broadcast call state trans
+
+#define LOG_WARN_COUNTERCONNECT_CALLROUTE_ADDRESS					0x30461001	 //call route address
+#define LOG_WARN_COUNTERCONNECT_CALLROUTE_CONNECT_FAILED			0x30461002	 //call route connect server failed
+#define LOG_WARN_COUNTERCONNECT_CALLROUTE_SUCCESS					0x30461003	 //call route success
+#define LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED					0x30461004	 //call route failed
+#define LOG_WARN_COUNTERCONNECT_HEADOFFICE_CALL						0x30461005	 //head office call
+#define LOG_WARN_COUNTERCONNECT_BRANCHMODE_CALL						0x30461006	 //branch mode call
 /*----End--CounterConnector------------------------------*/  
 
 
@@ -857,6 +866,8 @@ ERROR_ACCESSAUTH_CONNECT_ACS}
 #define LOG_RESOURCEWATCHER_SOGOU_PROCESS_STATUS_CHANGE 0x50A0001B
 #define LOG_RESOURCEWATCHER_OSD_RECOVER_ENABLE 0x50A0001C
 #define LOG_RESOURCEWATCHER_OSD_REMOVE_SUCC 0x50A0001D
+#define LOG_RESOURCEWATCHE_CHANGE_CURRENT_VERSION 0x50A0001E
+#define LOG_RESOURCEWATCHE_DELETE_VERSION 0x50A0001F
 
 #define EVENT_MOD_RELEASESIP_TIMEOUT  0x30470001  //SIP释放超时，重启SIPPHONE模块 
 

Module/mod_CenterSetting/CenterSettingConn.cpp

@@ -131,7 +131,7 @@ ErrorCodeEnum CenterSettingsMicroServiceHelper::GetCenterSetting(CSimpleStringA&
                     if (mTerminalInfo.strSite.Compare("cmb.LIB", true) == 0) {
                         cur = getCenterSettingsAns.biz;
                     }
-                    Dbg("local last update time(%s) vs server last update time(%s)", cur.lastUpdateTime.c_str(), getCenterSettingsReqJson.lastUpdateTimie.c_str());
+                    Dbg("local last update time(%s) vs server last update time(%s)", getCenterSettingsReqJson.lastUpdateTimie.c_str(), cur.lastUpdateTime.c_str());
                     SyncConfigAndRenameCenterFile(cur);
                     LogEvent(Severity_Middle, EVENT_MOD_CENTERSETTING_UPDATE,
                              CSimpleString::Format("Update CenterSetting.%s.ini.", cur.mapSiteName.c_str()));

Module/mod_CenterSetting/mod_centersetting.cpp

@@ -149,7 +149,7 @@ void CCenterSettingEntity::OnStarted()
              }
              SP::Module::Comm::Settings::StoreHeadBranchServicesMode(this, TRUE);
              LogWarn(Severity_Middle, Error_Succeed, EVENT_MOD_CENTERSETTING_CONNECT_SUCC, 
-                     CSimpleStringA::Format("Get centersetting succ: %", strLastErrInfo.GetData()));
+                     CSimpleStringA::Format("Get centersetting succ: %s", strLastErrInfo.GetData()));
          }
          ReturnAndClearDownloadContext(rc);
          return rc;
@@ -175,12 +175,13 @@ void CCenterSettingEntity::OnStarted()
                      LogWarn(Severity_Middle, rc, ERR_MOD_CENTERSETTING_CONNECT_FAILED, 
                              CSimpleStringA::Format("Get centersetting failed:%s", strLastErrInfo.GetData()));
                  } else {
-                     LogWarn(Severity_Middle, Error_Succeed, EVENT_MOD_CENTERSETTING_CONNECT_SUCC, "Get centersetting succ.");
+                     LogWarn(Severity_Middle, Error_Succeed, EVENT_MOD_CENTERSETTING_CONNECT_SUCC,
+                             CSimpleStringA::Format("Get centersetting succ: %s", strLastErrInfo.GetData()));
                  }
                  ReturnAndClearDownloadContext(rc);
                  return rc;
              } else {
-                 LogWarn(Severity_High, Error_DataCheck, ERR_MOD_CENTERSETTING_FILE_LEGALITY_UNEXPECTED, "CenterSetting file is illegality!");
+                 LogWarn(Severity_Middle, Error_DataCheck, ERR_MOD_CENTERSETTING_FILE_LEGALITY_UNEXPECTED, "CenterSetting file is illegality!");
                  ReturnAndClearDownloadContext(Error_DataCheck);
                  return Error_DataCheck;
              }

Module/mod_IDCertificate/IDCertFSM.cpp

@@ -508,24 +508,10 @@ int CIDCertFSM::ReadInfo(SpReqAnsContext<IDCert_Read_Req, IDCert_Read_Ans>::Poin
 					Dbg("x to X");
 					ctx->Ans.idcode[ctx->Ans.idcode.GetLength() - 1] = 'X';
 				}
-				//ctx->Ans.idcode = "370285198804025014";
 				ctx->Ans.department = idInfo.department.data;
 				ctx->Ans.startdate = idInfo.startDate.data;
 				ctx->Ans.enddate = idInfo.endDate.data;
 
-				//ctx->Ans.startdate = "2015.08.06";
-				//ctx->Ans.enddate = "2035.08.06";
-
-				//oiltest
-				/*Dbg("Name:%s,Sex:%s,Nation:%s,Birthday:%s,StartDate:%s,EndDate:%s,IDNo:%s****%s,Address:%s,"
-					,idInfo.name.data
-					,idInfo.sex.data
-					,idInfo.nation.data
-					,idInfo.birthday.data
-					,idInfo.startDate.data
-					,idInfo.endDate.data
-					,(const char*)ctx->Ans.idcode.SubString(0, 4), (const char*)ctx->Ans.idcode.SubString(ctx->Ans.idcode.GetLength() - 1, 1)
-					,idInfo.address.data);*/
 				Dbg("Sex:%s,Nation:%s,EndDate:%s,IDNo:%s****%s,"
 					,idInfo.sex.data
 					,idInfo.nation.data
@@ -559,14 +545,7 @@ int CIDCertFSM::ReadInfo(SpReqAnsContext<IDCert_Read_Req, IDCert_Read_Ans>::Poin
 		ctx->Answer(Error_TimeOut);
 	else
 		ctx->Answer(Error_Unexpect, AlarmDECToBusiness());
-	//if (!bGetIDCert)
-		//LogWarn(Severity_Low,Error_DevCommFailed,LOG_WARN_IDCERTIFICATE_ACTION,"IDCertificate read failed.");
 	Dbg("after send ack");
-	//if (!bOpenRF)
-	//{
-	//	LOG_TRACE("rf failed.");
-	//	return 1;
-	//}
 	if(bOpenRF) {
 		hr = m_hDevHelper->IDCerRFControl(false);
 		if (hr != Error_Succeed)

Module/mod_ResourceWatcher/mod_ResourceWatcher.cpp

@@ -766,6 +766,9 @@ void ResourceWatcherEntity::ManipulateVersion(SpReqAnsContext<ResourceWatcherSer
         if (!UpdateCurrentVersionName(strActiveFile, ctx->Req.value, strActiveFileBackup)) {
             tmpResult = Error_Unexpect;
             tmpMsg = "切换版本失败";
+        } else {
+            LogWarn(Severity_Low, Error_IO, LOG_RESOURCEWATCHE_CHANGE_CURRENT_VERSION,
+                    CSimpleStringA::Format("changed version from %s to %s", strCurrVer.GetData(), ctx->Req.value.GetData()));
         }
     }
         break;
@@ -778,6 +781,9 @@ void ResourceWatcherEntity::ManipulateVersion(SpReqAnsContext<ResourceWatcherSer
             if (!RemoveDirRecursiveA(strVersionDirPath)) {
                 tmpResult = Error_Unexpect;
                 tmpMsg = "删除版本失败";
+            } else {
+                LogWarn(Severity_Low, Error_IO, LOG_RESOURCEWATCHE_DELETE_VERSION,
+                        CSimpleStringA::Format("delete version %s", ctx->Req.value.GetData()));
             }
         }
     }

Module/mod_ResourceWatcher/mod_ResourceWatcher.h

@@ -63,6 +63,18 @@ private:
 	ResourceWatcherEntity* m_pEntity;
 };
 
+
+struct CPUTestTask : public ITaskSp
+{
+    void Process()
+    {
+		while (true) {
+			int cal = 123232323 + 23434324;
+			double t = 334243.334 / 34343.2;
+		}
+    }
+};
+
 class ResourceWatcherEntity : public CEntityBase, public IBroadcastListener, public ITimerListener, public ISysVarListener
 {
 public:
@@ -117,10 +129,6 @@ public:
 	void OnStarted()
 	{
 		m_fsm.AfterInit();
-		///**TODO(Gifur@10/21/2021): ´Ë½Ó¿ÚÓÐÎÊÌ⣬´ý²é£¡£¡£¡ */
-		//m_bInitMode = m_fsm.IsInitMode();
-        //Dbg("%s: %u", __FUNCTION__, m_bInitMode);
-
 		if (!m_bInitMode) {
             CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
             spEntityFunction->SetTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE,
@@ -131,13 +139,16 @@ public:
 	/*ignore*/
 	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
 	{
-        UOS::MonitorInfo info;
-        info.name = "VGA-0";
-        info.nResolutionX = 1280;
-        info.nResolutionY = 1024;
-        info.isPrimary = true;
 
-        ConfigMonitorSetting(info);
+		GetFunction()->PostThreadPoolTask(new CPUTestTask());
+
+        //UOS::MonitorInfo info;
+        //info.name = "VGA-0";
+        //info.nResolutionX = 1280;
+        //info.nResolutionY = 1024;
+        //info.isPrimary = true;
+
+        //ConfigMonitorSetting(info);
 
 		pTransactionContext->SendAnswer(Error_Succeed);
 	}
@@ -145,14 +156,15 @@ public:
 	/*ignore*/
 	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
 	{
-        UOS::MonitorInfo info;
-        info.name = "HDMI-A-0";
-        info.nResolutionX = 1024;
-        info.nResolutionY = 768;
-        info.isPrimary = false;
-        info.other = "VGA-0";
-        info.posDirecttion = 2;
-		ConfigMonitorSetting(info);
+        //UOS::MonitorInfo info;
+        //info.name = "HDMI-A-0";
+        //info.nResolutionX = 1024;
+        //info.nResolutionY = 768;
+        //info.isPrimary = false;
+        //info.other = "VGA-0";
+        //info.posDirecttion = 2;
+        //ConfigMonitorSetting(info);
+
 		pTransactionContext->SendAnswer(Error_Succeed);
 	}
 

Module/mod_accessauth/AccessAuthFSM.cpp

@@ -477,6 +477,9 @@ struct UpdateWKTask : ITaskSp {
 
 	void Process()
 	{
+		LOG_FUNCTION();
+
+
 		if (m_fsm->GetmAccessAuthHost().IsNullOrEmpty())
 		{
 			LogWarn(Severity_Middle, Error_Unexpect, AccessAuthorization_UserErrorCode_AccessAuth_NULL, "UpdateWKTask：准入Url为空");
@@ -494,11 +497,11 @@ struct UpdateWKTask : ITaskSp {
 
             struct UpdateWKAns
             {
-                string TMK;
-                string TPK;
-                string EDK;
+                string tmk;
+                string tpk;
+                string edk;
                 string index;
-                JSONCONVERT2OBJECT_MEMEBER_REGISTER(TMK, TPK, EDK, index)
+                JSONCONVERT2OBJECT_MEMEBER_REGISTER(tmk, tpk, edk, index)
             } updateWKAns;
 
             updateWKReq.terminalNo = si.strTerminalID.GetData();
@@ -511,8 +514,10 @@ struct UpdateWKTask : ITaskSp {
 
             RestfulClient client = RestfulClient::getInstance();
             config.PreDo();
+			Dbg("to Post with new restful....");
             client.Do(&config, &result);
             if (result.ResponseOK()) {
+				Dbg("UpdateWKTask Connect With Restful Success.");
                 SP::Module::Restful::CommResponseJson responseStatus;
                 SP::Module::Restful::GetStatusFromDebranchResponse(result.content, responseStatus);
                 if (!responseStatus.IsOperatedOK()) {
@@ -522,7 +527,7 @@ struct UpdateWKTask : ITaskSp {
                 }
                 SP::Module::Restful::ExtractDataFromDebranchResponse(result.content, updateWKAns);
                 int len = 0;
-                char* tmp = Hex2Str(updateWKAns.TMK.c_str(), len);
+                char* tmp = Hex2Str(updateWKAns.tmk.c_str(), len);
                 int textLen = 2 * len;
                 BYTE* text = new BYTE[textLen];
                 memset(text, 0, textLen);
@@ -532,16 +537,16 @@ struct UpdateWKTask : ITaskSp {
                     goto UpdateWKRetError;
                 }
 
-				updateWKAns.TMK.assign((char*)text);
+				updateWKAns.tmk.assign((char*)text);
                 delete[] text;
                 delete tmp;
 
-                Dbg("tmk=%s %d", updateWKAns.TMK.c_str(), updateWKAns.TMK.size());
-                Dbg("tpk=%s %d", updateWKAns.TPK.c_str(), updateWKAns.TPK.size());
-                Dbg("edk=%s %d", updateWKAns.EDK.c_str(), updateWKAns.EDK.size());
+                Dbg("tmk=%s %d", updateWKAns.tmk.c_str(), updateWKAns.tmk.size());
+                Dbg("tpk=%s %d", updateWKAns.tpk.c_str(), updateWKAns.tpk.size());
+                Dbg("edk=%s %d", updateWKAns.edk.c_str(), updateWKAns.edk.size());
                 Dbg("index=%s %d", updateWKAns.index.c_str(), updateWKAns.index.size());
 
-                DWORD rc = m_entity->LoadKeysToPinPadNew(updateWKAns.TMK, updateWKAns.TPK, updateWKAns.EDK, updateWKAns.index);
+                DWORD rc = m_entity->LoadKeysToPinPadNew(updateWKAns.tmk, updateWKAns.tpk, updateWKAns.edk, updateWKAns.index);
                 if (rc == Error_Succeed) {
                     Dbg("UpdateWKTask LoadKeysToPinPadNew Success");
                     FSMEvent* pEvent = new FSMEvent(CAccessAuthFSM::Event_UpdateWKSucc);
@@ -1855,7 +1860,8 @@ ErrorCodeEnum CAccessAuthFSM::GetStrFromCS(const char* pcSection, const char* pc
 	return Error;
 }
 
-bool CAccessAuthFSM::DecryptWithSessionKey(BYTE* encText, int encTextLen, BYTE * decTest,int &decTestLen) {
+bool CAccessAuthFSM::DecryptWithSessionKey(BYTE* encText, int encTextLen, BYTE * decTest,int &decTestLen) 
+{
 	BYTE key[16] = { 0 };
 	memcpy(key, ((CAccessAuthEntity*)m_pEntity)->m_AuthSessionKey,16);
 	char* keyTmp = Str2Hex((char *)key,16);

Module/mod_counterconnector/CMakeLists.txt

@@ -7,6 +7,14 @@ set(${MODULE_PREFIX}_SRCS
 	ConnectorFSM.cpp
 	mod_counterconnector.h
 	mod_counterconnector.cpp
+	strutil.h
+	strutil.cpp
+	callroute_nodelist.h
+	callroute_nodelist.cpp
+	callroute_request.h
+	callroute_request.cpp
+	callrouter.h
+	callrouter.cpp
 	)
 
 set(MOD_VERSION_STRING "0.0.1-dev1")
@@ -21,7 +29,9 @@ target_link_directories(${MODULE_NAME} PRIVATE
 
 
 # 添加实体需要依赖的其他共享库（包括系统库）
-set(${MODULE_PREFIX}_LIBS  ${MODULE_BASE_LIBS})
+set(${MODULE_PREFIX}_LIBS  ${MODULE_BASE_LIBS}
+	uuid
+)
 target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS})
 
 deploy_module(${MODULE_PREFIX} ${MODULE_NAME})

Module/mod_counterconnector/ConnectorFSM.cpp

@@ -2,7 +2,7 @@
 #include "ConnectorFSM.h"
 #include "../include/ModuleMix.h"
 #include "../include/EventCode.h"
-
+#include "json/json.h"
 
 #define RELEASEING_TIMER_INTERVAL	1200
 #define RELEASEING_SIP_TIMER		20000
@@ -26,6 +26,46 @@ unsigned long GetTickCount()
 }
 #endif
 
+static int iHttpLogCount = 0; 
+
+struct GrayLaunchReq : CHTTPReq{
+	GrayLaunchReq(){m_timeOut = 5;}
+	CSimpleStringA m_terminal_no;
+	CSimpleStringA m_branch_no;
+    CSimpleStringA m_modular;
+	virtual string ToJson(){
+		char reqcontent[512];
+		//string reqcontent = "{\"terminal_no\":\"" + m_terminal_no.GetData() + "\",\"branch_no\":\"" + m_branch_no.GetData() + 
+		//	"\",\"m_modular\":\"" + m_modular.GetData() + "\"}";
+		sprintf(reqcontent, "{\"terminal_no\":\"%s\",\"branch_no\":\"%s\",\"modular\":\"%s\"}", m_terminal_no.GetData(), 
+			m_branch_no.GetData(), m_modular.GetData());
+		return reqcontent;
+	}
+};
+
+
+struct GrayLaunchResponse : CHTTPRet{
+	GrayLaunchResponse():m_result(false){}
+	bool m_result;
+	virtual bool Parse(string strData){
+		Dbg("GrayLaunchResponse: data = %s", strData.c_str());
+		Json::Value root;
+		Json::Reader reader;
+		reader.parse(strData, root, false);
+		if (root["data"].isBool()) {
+			m_result = root["data"].asBool();
+		}
+		return m_result;
+	}
+};
+
+static void HTTPLogCallback(const char* msg){
+	if (0 == iHttpLogCount){
+		LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_GRAY_FAILED, msg);
+		iHttpLogCount++;
+	}	
+}
+
 class  SyncServiceClient:public SyncService_ClientBase
 {
 public:
@@ -135,6 +175,11 @@ ErrorCodeEnum ACMCallFSM::OnInit()
 	memset(m_strChanCallNum,0,sizeof(m_strChanCallNum));
 	memset(m_strChanProxyIP,0,sizeof(m_strChanProxyIP));
 	memset(m_iSIPProxyPort,0,sizeof(m_iSIPProxyPort));
+	m_strCallRouteIP = NULL;
+	m_iCallRoutePort = 0;
+	m_strCallRouteBranchNo = NULL;
+	m_strCallRouteAccessNo = NULL;
+	m_pCallRouteList = NULL;
 	ErrorCodeEnum Error = LoadConfig();
 	if (Error != Error_Succeed)
 		goto on_error;
@@ -145,6 +190,7 @@ ErrorCodeEnum ACMCallFSM::OnInit()
 		goto on_error;
 	Dbg("sip proxy ip1:%s,num1:%s,port1:%d;ip2:%s,num2:%s,port2:%d", (LPCSTR)m_strSIPProxyIP[0],(LPCSTR)m_strSIPCallNum[0], m_iSIPProxyPort[0],(LPCSTR)m_strSIPProxyIP[1],(LPCSTR)m_strSIPCallNum[1], m_iSIPProxyPort[1]);
 	Dbg("chan proxy ip1:%s,num1:%s,port1:%d;ip2:%s,num2:%s,port2:%d", (LPCSTR)m_strChanProxyIP[0],(LPCSTR)m_strChanCallNum[0], m_iChanProxyPort[0],(LPCSTR)m_strChanProxyIP[1],(LPCSTR)m_strChanCallNum[1], m_iChanProxyPort[1]);
+	Dbg("CallRouteIP:%s,port:%d", (LPCSTR)m_strCallRouteIP,m_iCallRoutePort);
 	Dbg("TerminalId: %s", (LPCSTR)m_strTerminalId);
 	m_bHangup = FALSE;
 	m_bHandFree = TRUE;
@@ -337,8 +383,11 @@ void ACMCallFSM::OnStateTrans(int iSrcState, int iDstState)
 			if (!((st2 == eState_Fail)&&(m_nCurChanServer != Error_Server)&&(m_nCurSipServer != Error_Server))||m_bHangup)
 			{
 				if (eState_Fail != st1 || eState_Connecting != st2){
-					Dbg("Broadcast state from %d to %d", st1, st2);
+					char strmsg[MAX_PATH] = {0};
+					_snprintf(strmsg, MAX_PATH,"Broadcast state from %d to %d", st1, st2);
+					Dbg(strmsg);
 					SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(PhoneState), SP_MSG_SIG_OF(PhoneState), evt);
+					LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_BROADCAST_CALL_STATE, strmsg);
 				} 
 				else{
 					char strinfo[MAX_PATH] = {0};
@@ -364,6 +413,7 @@ void ACMCallFSM::OnStateTrans(int iSrcState, int iDstState)
 
 ErrorCodeEnum ACMCallFSM::SetCallState(int state)
 {
+	LOG_FUNCTION();
 	char *sts[] = {
 		"O", // Offline
 		"C", // Connecting
@@ -392,6 +442,10 @@ void ACMCallFSM::s0_on_entry()
 	memset(&m_CallingParam,0,sizeof(m_CallingParam));
 	GetEntityBase()->GetFunction()->SetSysVar("CallType", "N"); //进入初始状态时设置呼叫模式为常规呼叫
 	m_nSysCallType = 0;
+	if(m_pCallRouteList != NULL){
+		free_node_list(m_pCallRouteList);	
+		m_pCallRouteList = NULL;
+	}
 }
 void ACMCallFSM::s0_on_exit() 
 {
@@ -532,6 +586,15 @@ unsigned int ACMCallFSM::s9_on_event(FSMEvent* event)
 
 void ACMCallFSM::s8_on_entry() 
 {
+	//get call route,采用直接总行方式
+	call_info_t call_info;
+	call_info.callroute_server_ip = m_strCallRouteIP;
+	call_info.callroute_server_port = m_iCallRoutePort;
+	call_info.szbranchno = m_strCallRouteBranchNo;
+	call_info.szcaller_num = m_strTerminalId;
+	call_info.szdest_num = m_strCallRouteAccessNo;
+	m_pCallRouteList = get_callroute_list(&call_info);
+			
 	int time = GetDelayTime();
 	Dbg("get Delay time = %d",time);
 	if (time > 0)
@@ -596,50 +659,75 @@ void ACMCallFSM::s11_on_entry()
 	if (m_nCurSipServer == Error_Server){
 		Error = Error_NetBroken;
 	}
-	if (Error == Error_Succeed)
-	{
-		if (m_CallingParam.nCallType != NORMAL_CALLTYPE && m_CallingParam.nCallType != DOUBLERECORD_CALLTYPE)
-		{
-			Dbg("Begin Make Distribute Call!");
-			Error = MakeCall(m_nCurSipServer,m_CallingParam);
-			if (Error!=Error_Succeed)
-			{
-				m_nCurSipServer?(m_nCurSipServer=Error_Server):(m_nCurSipServer=BACK_SERVER);
-			}
-			Dbg("make call result:0x%08x", Error);
-		}
-		else
-		{	
-			if (NORMAL_CALLTYPE == m_CallingParam.nCallType){
-				Dbg("Begin Make Normal Call!");
-			}
+
+	if (Error == Error_Succeed){
+		bool center_connect = FALSE;
+		//get call route,采用直接总行方式
+		if (m_strCallRouteIP.GetLength() != 0) {
+			callurl_node_t *node = get_no_used_node(m_pCallRouteList);
+			if (node != NULL){
+				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_HEADOFFICE_CALL, "Begin Head Office Make Call!");
+				char ipstr[256] = {0};
+				char callid_str[64] = { 0 };
+				GetLocalIP(ipstr, 64);
+				get_format_uuid(callid_str, 64);
+				Error = MakeCall(node->strcallurl, CSimpleStringA::Format("sip:%s@%s;transport=UDP", node->strnewcallernum, ipstr), 
+					callid_str, m_CallingParam);
+				m_iChanProxyPort[0] = node->uassistport;
+				m_iChanProxyPort[1] = node->uassistport;
+				m_strChanProxyIP[0] = node->strassistip;
+				m_strChanProxyIP[1] = node->strassistip;
+				if (Error!=Error_Succeed){
+					m_nCurSipServer?(m_nCurSipServer=Error_Server):(m_nCurSipServer=BACK_SERVER);
+				}
+				m_nCurChanServer = BACK_SERVER;
+				node->bused = TRUE;
+				char strmsg[256] = { 0 };
+				_snprintf(strmsg, 256, "head office make call result:0x%08x", Error);
+				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_BRANCHMODE_CALL, strmsg);
+				center_connect = TRUE;
+			}	
 			else{
-				Dbg("Begin Make Record Call!");
-			}
-			
-			Error = MakeCall(m_strHintCallNum.GetLength() > 0 ? (LPCSTR)m_strHintCallNum : (LPCSTR)m_strSIPCallNum[m_nCurSipServer],m_nCurSipServer);
-			if (Error!=Error_Succeed)
-			{
-				m_nCurSipServer?(m_nCurSipServer=Error_Server):(m_nCurSipServer=BACK_SERVER);
-			}
-			Dbg("make call result:0x%08x", Error);
+				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_BRANCHMODE_CALL, "head office mode no more call router, try to connect branch server.");
+				//m_nCurSipServer = MAIN_SERVER;
+				//m_nCurChanServer = MAIN_SERVER;
+				center_connect = FALSE;
+			}		
 		}
-	}
 
-	if (Error != Error_Succeed) {
-		if (Error_NetBroken == Error || Error_Unexpect == Error){
-			PostEventFIFO(new FSMEvent(USER_EVT_HANGUP));
-			m_bHangup = TRUE;
-			if (Error_Unexpect == Error){
-				LogFatal(Severity_High, Error_Unexpect, 0, "获取IP失败，请检查机器网络!");
+		//old call branch server方式
+		if(!center_connect){
+			if (m_CallingParam.nCallType != NORMAL_CALLTYPE && m_CallingParam.nCallType != DOUBLERECORD_CALLTYPE)
+			{
+				Dbg("Begin Branch Make Distribute Call!");
+				Error = MakeCall(m_nCurSipServer,m_CallingParam);
+				if (Error!=Error_Succeed)
+				{
+					m_nCurSipServer?(m_nCurSipServer=Error_Server):(m_nCurSipServer=BACK_SERVER);
+				}
+				Dbg("branch make call result:0x%08x", Error);
 			}
-			else{
-				LogFatal(Severity_High, Error_NetBroken, 0, "系统故障，尝试恢复中（预计90s内），请稍等！");
+			else
+			{	
+				if (NORMAL_CALLTYPE == m_CallingParam.nCallType){
+					Dbg("Begin Branch Make Normal Call!");
+				}
+				else{
+					Dbg("Begin Branch Make Record Call!");
+				}
+				
+				Error = MakeCall(m_strHintCallNum.GetLength() > 0 ? (LPCSTR)m_strHintCallNum : (LPCSTR)m_strSIPCallNum[m_nCurSipServer],m_nCurSipServer);
+				if (Error!=Error_Succeed)
+				{
+					m_nCurSipServer?(m_nCurSipServer=Error_Server):(m_nCurSipServer=BACK_SERVER);
+				}
+				Dbg("branch make call result:0x%08x", Error);
 			}
 		}
-		else{
-			PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
-		}
+	}
+	if (Error != Error_Succeed) 
+	{
+		PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
 	}
 	else
 	{

Module/mod_counterconnector/ConnectorFSM.h

@@ -3,13 +3,15 @@
 #include "SpHelper.h"
 #include "SpFSM.h"
 #include "SpIni.h"
+#include "IHttpFunc.h"
 
 #include "Event.h"
+#include "callrouter.h"
 
 #ifdef _WIN32
 #include "resource.h"
 #else
-
+#include "uuid/uuid.h"
 #endif
 
 
@@ -490,6 +492,86 @@ private:
 	int TranslateState(int innerState);
 	ErrorCodeEnum SetCallState(int state);
 
+	void get_format_uuid(char* strbuffer, size_t ulen)
+	{
+#ifdef RVC_OS_WIN
+		UUID uuid;
+		size_t uuidlen = 0;
+		RPC_CSTR buf;
+		UuidCreate((UUID*)&uuid);
+		UuidToString((UUID*)&uuid, &buf);
+
+		uuidlen = strlen((const char*)buf);
+		if (uuidlen < ulen) {
+			memcpy(strbuffer, (const char*)buf, uuidlen);
+		}
+
+		RpcStringFree(&buf);
+#else
+		uuid_t uuid;
+		uuid_generate(uuid);
+		uuid_unparse(uuid, strbuffer);
+#endif
+	}
+
+	ErrorCodeEnum GetLocalIP(char *buff, size_t ulen)
+	{
+#ifdef RVC_OS_WIN
+		char tmp[256];
+		gethostname(tmp, sizeof(tmp));
+		hostent *ent = gethostbyname(tmp);
+		if (ent) {
+			for (int i = 0; ent->h_addr_list[i]; ++i) {
+				if (ent->h_addrtype == AF_INET) {
+					struct in_addr *in = (struct in_addr*)ent->h_addr_list[i];
+					char *p = inet_ntoa(*in);
+					if (p[0] != '0') 
+					{
+						if(strstr(p,"198.168.") == NULL)
+						{
+							strcpy(buff, p);
+							Dbg("local ip == %s", buff);
+							return Error_Succeed;
+						}
+					}
+				}
+			}
+		}
+		return Error_Unexpect;
+#else
+		ErrorCodeEnum error = Error_Unexpect;
+		int sockfd = -1;
+		struct ifconf ifconf;
+		struct ifreq* ifreq = NULL;
+		char strbuf[256] = { 0 };
+		ifconf.ifc_len = 256;
+		ifconf.ifc_buf = strbuf;
+		if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+			Dbg("socket error");
+			return error;
+		}
+		ioctl(sockfd, SIOCGIFCONF, &ifconf); //get all socket info
+		ifreq = (struct ifreq*)ifconf.ifc_buf;
+		for (int i = (ifconf.ifc_len / sizeof(struct ifreq)); i > 0; i--) {
+			if (ifreq->ifr_flags == AF_INET) { //for ipv4
+				char* strIP = inet_ntoa(((struct sockaddr_in*) & (ifreq->ifr_addr))->sin_addr);
+				Dbg("name = %s, local addr = %s", ifreq->ifr_name, strIP);
+				ifreq++;
+				if (NULL != strIP) {
+					if (NULL == strstr(strIP, "198.168.") && NULL == strstr(strIP, "127.0.0.1"))
+					{
+						strcpy(buff, strIP);
+						Dbg("local ip == %s", buff);
+						error = Error_Succeed;
+						break;
+					}
+				}
+			}
+		}
+		return error;
+#endif
+	}
+
 	ErrorCodeEnum MakeCall(int nSipServer,CallingParam callingparam)
 	{
 		if (!m_pPhoneClient)
@@ -503,17 +585,17 @@ private:
 			{
 				CSimpleStringA session = "80";
 				session+=callingparam.connect_session;
-				Req.call_uri = MakeCallUri(session,callingparam.connect_ip,callingparam.connect_port);
+				Req.to_uri = MakeCallUri(session,callingparam.connect_ip,callingparam.connect_port);
 			}
 			else if((callingparam.nCallType == PADTOPAD_CALLTYPE)||(callingparam.nCallType == MOBILETOPAD_CALLTYPE))
 			{
 				CSimpleStringA session = "90";
 				session+=callingparam.connect_session;
-				Req.call_uri = MakeCallUri(session,callingparam.connect_ip,callingparam.connect_port);
+				Req.to_uri = MakeCallUri(session,callingparam.connect_ip,callingparam.connect_port);
 			}
 			else
 			{
-				Req.call_uri = MakeCallUri(callingparam.connect_session,callingparam.connect_ip,callingparam.connect_port);
+				Req.to_uri = MakeCallUri(callingparam.connect_session,callingparam.connect_ip,callingparam.connect_port);
 			}
 		}
 		else
@@ -528,17 +610,17 @@ private:
 				{
 					CSimpleStringA session = "80";
 					session+=callingparam.connect_session;
-					Req.call_uri = MakeCallUri(session,nSipServer);
+					Req.to_uri = MakeCallUri(session,nSipServer);
 				}
 				else if((callingparam.nCallType == PADTOPAD_CALLTYPE)||(callingparam.nCallType == MOBILETOPAD_CALLTYPE))
 				{
 					CSimpleStringA session = "90";
 					session+=callingparam.connect_session;
-					Req.call_uri = MakeCallUri(session,nSipServer);
+					Req.to_uri = MakeCallUri(session,nSipServer);
 				}
 				else
 				{
-					Req.call_uri = MakeCallUri(callingparam.connect_session,nSipServer);
+					Req.to_uri = MakeCallUri(callingparam.connect_session,nSipServer);
 				}
 			}
 		}
@@ -549,7 +631,7 @@ private:
 		info.connect_ip = callingparam.connect_ip;
 		info.connect_port = callingparam.connect_port;
 	    m_pPhoneClient->SetCallingParam(info);
-		Dbg("Make Distribute Call CallType = %d", info.CallType);
+		Dbg("Make Distribute Call CallType = %d, to_uri:%s", info.CallType, Req.to_uri.GetData());
 
 		ErrorCodeEnum Error = m_pPhoneClient->MakeCall(Req, Ans, 10000);
 		return Error;
@@ -568,7 +650,7 @@ private:
 		CSimpleStringA strCode;
 		PhoneService_MakeCall_Req Req;
 		PhoneService_MakeCall_Ans Ans;
-		Req.call_uri = MakeCallUri(hint_callnum,nSipServer);
+		Req.to_uri = MakeCallUri(hint_callnum,nSipServer);
 
 		PhoneService_SetCallingParam_Info info;
 		info.CallType = NORMAL_CALLTYPE;
@@ -578,7 +660,32 @@ private:
 		}
 		m_pPhoneClient->SetCallingParam(info);
 
-		Dbg("before make call, call type is %d", info.CallType);
+		Dbg("before make call, call type is %d, to_uri:%s", info.CallType, Req.to_uri.GetData());
+		ErrorCodeEnum Error = m_pPhoneClient->MakeCall(Req, Ans, 10000);
+		return Error;
+	}
+
+	ErrorCodeEnum MakeCall(const char *to_uri, const char *from_uri, const char *call_id, CallingParam callingparam)
+	{
+		if (!m_pPhoneClient)
+			return Error_NetBroken;
+		CSimpleStringA strCode;
+		PhoneService_MakeCall_Req Req;
+		PhoneService_MakeCall_Ans Ans;
+		Req.to_uri = to_uri;
+		Req.from_uri = from_uri;
+		Req.call_id = call_id;
+
+
+		//设置呼叫参数
+		PhoneService_SetCallingParam_Info info;
+		info.CallType = callingparam.nCallType;
+		info.connect_session = callingparam.connect_session;
+		info.connect_ip = callingparam.connect_ip;
+		info.connect_port = callingparam.connect_port;
+		m_pPhoneClient->SetCallingParam(info);
+		Dbg("before make call, call type is %d, to_uri:%s, from_uri:%s, call_id:%s", info.CallType, to_uri, from_uri, call_id);
+
 		ErrorCodeEnum Error = m_pPhoneClient->MakeCall(Req, Ans, 10000);
 		return Error;
 	}
@@ -739,6 +846,10 @@ private:
 		table.AddEntryString("CounterConnector", "chan_proxy_ip_backup", m_strChanProxyIP[1], NULL);
 		table.AddEntryInt("CounterConnector", "chan_proxy_port_backup", m_iChanProxyPort[1], 0);
 		table.AddEntryString("CounterConnector", "chan_default_call_no_backup", m_strChanCallNum[1], NULL);
+		table.AddEntryString("CounterConnector", "call_route_ip", m_strCallRouteIP, NULL);
+		table.AddEntryInt("CounterConnector", "call_route_port", m_iCallRoutePort, 0);
+		table.AddEntryString("CounterConnector", "call_route_access_no", m_strCallRouteAccessNo, NULL);
+		table.AddEntryString("Initializer", "SubBankNo", m_strCallRouteBranchNo, NULL);
 		CSmartPointer<IConfigInfo> spConfig;
 		ErrorCodeEnum Error = m_pEntity->GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
 		if (Error == Error_Succeed) {
@@ -860,5 +971,12 @@ private:
 	int m_iChanProxyPort[2];
 	CSimpleStringA m_strChanCallNum[2];
 
+	//去分行化
+	CSimpleStringA m_strCallRouteIP;
+	int m_iCallRoutePort;
+	CSimpleStringA m_strCallRouteBranchNo;
+	CSimpleStringA m_strCallRouteAccessNo;
+	node_list_head_t *m_pCallRouteList;
+
 	BOOL m_bRing;
 };

Module/mod_counterconnector/Event.h

@@ -2,24 +2,23 @@
 //交互日志事件
 #define EVENT_MOD_CONNECT_CONNECT_SUCCESS		0x30400001		//连线成功,级别1
 #define EVENT_MOD_CONNECT_GOTO_DISCONNECT		0x30400002		//进入离线,级别1	
-#define LOG_EVT_RELEASELIVEDETECTION			0x30400003    //通知sipphone释放主动活体
-#define LOG_EVT_STARTLIVEDETECTDISPLAY			0x30400004    //开始主动活体回显
-#define LOG_EVT_STOPLIVEDETECTDISPLAY			0x30400005    //停止主动活体回显
+#define LOG_EVT_RELEASELIVEDETECTION			0x30400003      //通知sipphone释放主动活体
+#define LOG_EVT_STARTLIVEDETECTDISPLAY			0x30400004      //开始主动活体回显
+#define LOG_EVT_STOPLIVEDETECTDISPLAY			0x30400005      //停止主动活体回显
 
 
-#define LOG_EVT_HANDFREE_MODE_REMOTE_CALL		0x30400006    //以免提模式开始远程连线
-#define LOG_EVT_PICKUP_MODE_REMOTE_CALL			0x30400007    //以话筒模式开始远程连线
+#define LOG_EVT_HANDFREE_MODE_REMOTE_CALL		0x30400006      //以免提模式开始远程连线
+#define LOG_EVT_PICKUP_MODE_REMOTE_CALL			0x30400007      //以话筒模式开始远程连线
 
-#define LOG_EVT_STOPLIVEDETECTNOTICEDISPLAY		0x30400008	  //停止主动活体文字显示
+#define LOG_EVT_STOPLIVEDETECTNOTICEDISPLAY		0x30400008	    //停止主动活体文字显示
 
 //错误日志事件
 #define EVENT_MOD_CONNECT_CONNECT_TIMEOUT		0x30480001		//尝试连线超时,级别1	
 
-#define EVENT_MOD_RELEASESIP_TIMEOUT		0x30470001		//SIP释放超时，重启SIPPHONE模块	
+#define EVENT_MOD_RELEASESIP_TIMEOUT		0x30470001			//SIP释放超时，重启SIPPHONE模块	
 
-
-#define EVENT_MOD_CONNECT_GPIO_PICKUP		0x20900005		//PICKUP		
-#define EVENT_MOD_CONNECT_GPIO_HANDFREE		0x20900006		//HANDFREE
+#define EVENT_MOD_CONNECT_GPIO_PICKUP		0x20900005			//PICKUP		
+#define EVENT_MOD_CONNECT_GPIO_HANDFREE		0x20900006			//HANDFREE
 
 //事件转换发出事件
 #define EVENT_MOD_CONNECT_PICKUP_CALL	0x10303041		// 提机呼叫  
@@ -31,12 +30,12 @@
 #define EVENT_MOD_CONNECT_HANNUP_BY_CONNECTING	0x10303049	//话筒未接通时挂机
 #define EVENT_MOD_CONNECT_HANNUP_BY_AGENT		0x10313086	// 授权操作
 
-#define EVENT_MOD_CONNECT_SLV_HANDFREECALL	0x10303050   //界面拨号，免提呼叫发送给SIPPHONE
-#define EVENT_MOD_CONNECT_SLV_PICKUPCALL	0x10303051   //界面拨号，话筒呼叫发送给SIPPHONE
+#define EVENT_MOD_CONNECT_SLV_HANDFREECALL	0x10303050		//界面拨号，免提呼叫发送给SIPPHONE
+#define EVENT_MOD_CONNECT_SLV_PICKUPCALL	0x10303051		//界面拨号，话筒呼叫发送给SIPPHONE
 
 #define EVENT_MOD_CONNECT_AGENT_HANDFREE_PICKUP		0x10303052	//坐席控制免提转话筒
 #define EVENT_MOD_CONNECT_AGENT_PICKUP_HANDFREE		0x10303053	//坐席控制话筒转免提
-#define EVENT_MOD_CONNECT_SLV_PICKUPCALL_HAS_CMD		0x10303054	//界面拨号，带有指令信息
+#define EVENT_MOD_CONNECT_SLV_PICKUPCALL_HAS_CMD	0x10303054	//界面拨号，带有指令信息
 
 #define LOG_EVT_SELFCHECK_ASSISTANTCHANNEL_IDLE		0x50500001  //协助通道重启
 #define LOG_EVT_SELFCHECK_SIPPHONE_IDLE				0x50500002  //sip话机重启
@@ -48,6 +47,7 @@
 #define LOG_EVT_DISTRIBUTE_ASSISTANTCHANNEL_IDLE	0x30C00001		// 协助通道重置
 #define LOG_EVT_DISTRIBUTE_SIPPHONE_IDLE			0x30C00002		// sip话机重置
 
+
 #define SYSVAR_CALLTYPE	"CallType"
 #define CALLTYPE_NORMAL "N" // 呼叫类型，普通模式
 #define CALLTYPE_MOBILE	"M" // 呼叫类型，手机模式

Module/mod_counterconnector/callroute_nodelist.cpp

@@ -0,0 +1,134 @@
+#include "callroute_nodelist.h"
+#include "strutil.h"
+#include <string.h>
+
+#ifndef	SAFE_FREE
+#define SAFE_FREE(p)		if (p){free(p);	p = NULL;}
+#endif
+
+node_list_head_t* create_node_list_head(const char* pcallernum)
+{
+	node_list_head_t* pnode = NULL;
+	if (NULL != pcallernum){
+		pnode = (node_list_head_t*)malloc(sizeof(node_list_head_t));
+		if (NULL != pnode){
+			size_t ulen = strlen(pcallernum);
+			char* pnumber = (char*)malloc(ulen+1);
+			memset(pnumber, 0, ulen+1);
+			memcpy(pnumber, pcallernum, ulen);
+			pnode->pcallernum = pnumber;
+			pnode->nodecount = 0;
+			pnode->pnext = NULL;
+		}
+	}
+
+	return pnode;
+} 
+
+
+int add_node_to_list(node_list_head_t* plist, const char* newcallernum, const char* pcallurl, const char* pstrassistip, const char*  pstrport)
+{
+	int ret = -1;
+	if (NULL == plist){
+		return ret;
+	}
+
+	if (NULL != pcallurl && NULL != pstrassistip && NULL != pstrport){
+		callurl_node_t* plast = plist->pnext;
+		callurl_node_t* pnode = (callurl_node_t*)malloc(sizeof(callurl_node_t));
+
+		size_t ulen = strlen(pcallurl);
+		char* psipurl = (char*)malloc(ulen+1);
+		char* pstrnewcallernum = NULL;
+		char* pstrip = NULL;
+		int uport = atoi(pstrport);
+
+		memset(psipurl, 0, ulen+1);
+		fifter_string(psipurl, ulen+1, pcallurl, '\'');
+
+		ulen = strlen(pstrassistip);
+		pstrip = (char*)malloc(ulen+1);
+		memset(pstrip, 0, ulen+1);
+		memcpy(pstrip, pstrassistip, ulen);
+
+		ulen = strlen(newcallernum);
+		pstrnewcallernum = (char*)malloc(ulen+1);
+		memset(pstrnewcallernum, 0, ulen+1);
+		memcpy(pstrnewcallernum, newcallernum, ulen);
+
+		pnode->strcallurl = psipurl;
+		pnode->strassistip = pstrip;
+		pnode->strnewcallernum = pstrnewcallernum;
+		pnode->uassistport = (unsigned int)uport;
+		pnode->bused = false;
+		pnode->pnext = NULL;
+
+		if (NULL != plast){
+			while(plast && NULL != plast->pnext){
+				plast = plast->pnext;
+			}
+			plast->pnext = pnode;
+			plist->nodecount++;
+		}
+		else{
+			*(&plist->pnext) = pnode;
+			plist->nodecount++;
+		}
+		ret = 0;
+	}
+	return ret;
+}
+
+
+callurl_node_t* get_no_used_node(node_list_head_t* plist){
+	callurl_node_t *phead = NULL;
+	callurl_node_t *pnode = NULL;
+	if (NULL != plist){
+		phead = plist->pnext;
+		while(phead){
+			pnode = phead;
+			if (pnode->bused == false){
+				return pnode;
+			}
+			phead = phead->pnext;
+		}
+	}
+	return NULL;
+}
+
+
+int free_node_list(node_list_head_t* plist)
+{
+	callurl_node_t *phead = NULL;
+	callurl_node_t *pnode = NULL;
+	if (NULL != plist){
+		free(plist->pcallernum);
+		plist->pcallernum = NULL;
+		phead = plist->pnext;
+		while(phead){
+			pnode = phead;
+			phead = phead->pnext;
+			free_callurl_node(pnode);
+		}
+		SAFE_FREE(plist);
+	}
+
+	return 0;
+}
+
+int free_callurl_node(callurl_node_t* pnode)
+{
+	int ret = -1;
+	if (NULL == pnode){
+		return ret;
+	}
+
+	SAFE_FREE(pnode->strnewcallernum);
+	SAFE_FREE(pnode->strassistip);
+	SAFE_FREE(pnode->strcallurl);
+
+	free(pnode);
+	pnode = NULL;
+	
+	return ret;
+}

Module/mod_counterconnector/callroute_nodelist.h

@@ -0,0 +1,28 @@
+#ifndef	_CALLROUTE_NODELIST_
+#define _CALLROUTE_NODELIST_
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct callurl_node_s{
+	bool	bused;
+	char*	strnewcallernum;
+	char*	strcallurl;
+	char*	strassistip;
+	unsigned int	uassistport;
+	struct callurl_node_s* pnext; 
+}callurl_node_t;
+
+
+typedef struct node_list_head_s{
+	char* pcallernum;
+	unsigned int nodecount;
+	callurl_node_t*	pnext;
+}node_list_head_t;
+
+node_list_head_t* create_node_list_head(const char* pcallernum);
+int add_node_to_list(node_list_head_t* plist, const char* newcallernum, const char* pcallurl, const char* pstrassistip, const char* pstrport);
+int free_node_list(node_list_head_t* plist);
+callurl_node_t* get_no_used_node(node_list_head_t* plist);
+int free_callurl_node(callurl_node_t* pnode);
+
+#endif

Module/mod_counterconnector/callroute_request.cpp

@@ -0,0 +1,75 @@
+#include "callroute_request.h"
+#include "strutil.h"
+
+
+
+/*ÕûÐÎת×Ö·ûÐÍ*/
+char* itoa(int value, char* pstring, int radix)
+{
+	char tmp[33] = {0};
+	char* tp = tmp;
+	int i;
+	unsigned v;
+	int sign;
+	char* sp;
+
+	if (radix > 36 || radix <= 1 || NULL == pstring)
+	{
+		return 0;
+	}
+
+	sign = (radix == 10 && value < 0);
+	if (sign)
+		v = -value;
+	else
+		v = (unsigned)value;
+	while (v || tp == tmp)
+	{
+		i = v % radix;
+		v = v / radix;
+		if (i < 10)
+			* tp++ = i + '0';
+		else
+			*tp++ = i + 'a' - 10;
+	}
+
+	sp = pstring;
+
+	if (sign)
+		* sp++ = '-';
+	while (tp > tmp)
+		* sp++ = *--tp;
+	*sp = 0;
+	return pstring;
+}
+
+int fill_packet(proxy_req_packet_t* req_packet, const char* paccessnum, const char* pcalleridnum, const char* branchnum, char*strTime)
+{
+	int ret = -1;
+	char striLen[10] = {0};
+	int iLen =  sizeof(proxy_req_packet_t) - 4;
+
+	if (NULL == req_packet){
+		return ret;
+	}
+
+	itoa(iLen, striLen, 10);
+	proxy_copy(req_packet->req_hdr.packgelen, striLen);
+	req_packet->req_hdr.version = '1';
+	proxy_copy(req_packet->req_hdr.tradefrom, "VGA");
+	proxy_copy(req_packet->req_hdr.requestcode, "RvcRouteReq");
+
+	proxy_copy(req_packet->req_hdr.reqtime, strTime);
+	proxy_copy(req_packet->req_body.bodysnum, "1");
+	proxy_copy(req_packet->req_body.bodylen, "40");
+	proxy_copy(req_packet->req_body.bodyname, "RvcRouteReq");
+	proxy_copy(req_packet->req_body.accessnum, paccessnum);
+	proxy_copy(req_packet->req_body.terminalno, pcalleridnum);
+	proxy_copy(req_packet->req_body.branchno, branchnum);
+
+	ret = 0;
+
+	return ret;
+}
+
+

Module/mod_counterconnector/callroute_request.h

@@ -0,0 +1,60 @@
+#ifndef	_CALLROUTE_REQUEST_
+#define _CALLROUTE_REQUEST_
+#include <stdio.h>
+#include <stdlib.h>
+
+//请求包数据结构
+typedef struct proxy_req_hdr
+{
+	char	packgelen[4];					// 整包长,不含此字段(4bit)
+	char	version;						// 版本号（1bit）
+	char	tradefrom[3];					// 渠道代码（3bit） MGA
+	char	terminalno[30];					// 终端号(30bit),可不填
+	char	reqtime[14];					// 请求时间（14bit）
+	char	requestcode[16];				// 请求码（16bit）
+	char	errorcode[7];					// 错误码（7bit）回包填
+	char	errormsg[20];					// 错误信息（20bit）回包填
+	char	reserved[30];					// 保留字段（30bit）
+}proxy_req_hdr_t;
+
+typedef struct proxy_req_body
+{
+	char	bodysnum[4];					// 包体数量(4bit)
+	char	bodyname[30];					// 包体名(30bit)
+	char	bodylen[4];						// 单个包体长度(4bit)
+	char	branchno[10];					// 分行编号(10bit)可不填      
+	char	terminalno[20];					// 终端号(20bit)可不填
+	char	accessnum[10];					// 呼入码(10bit)必填
+}proxy_req_body_t;
+
+typedef struct proxy_req_packet
+{
+	proxy_req_hdr_t		req_hdr;			//请求包头
+	proxy_req_body_t	req_body;			//请求包体
+}proxy_req_packet_t;
+
+typedef struct proxy_rsp_body
+{
+	char	unkown_flag_a[4];			//1
+	char	gateway_type_a[30];			//网关类型
+	char	audio_len[4];				//内容长度
+	char	audio_centent[150];			//内容
+
+	char	unkown_flag_b[4];			//1
+	char	gateway_type_b[30];			//网关类型
+	char	video_len[4];				//内容长度
+	char	video_content_ip[20];		//内容（前20字节为ip，后10字节为端口号	
+	char	video_content_port[10];		//内容（前20字节为ip，后10字节为端口号	
+}proxy_rsp_body_t;
+
+//回复包数据结构
+typedef struct proxy_rsp_packet{
+	proxy_req_hdr_t		req_hdr;			//请求包头
+	proxy_rsp_body_t	rsp_body;
+}proxy_rsp_packet_t;
+
+
+int fill_packet(proxy_req_packet_t* req_packet, const char* paccessnum, const char* pcalleridnum, const char* branchnum, char*strTime);
+
+
+#endif

Module/mod_counterconnector/callrouter.cpp

@@ -0,0 +1,327 @@
+
+#include "callrouter.h"
+#include "strutil.h"
+#include "callroute_request.h"
+#include "callroute_nodelist.h"
+#include "SpBase.h"
+#include "../include/EventCode.h"
+
+#ifdef RVC_OS_WIN
+#include <process.h>
+#include <DbgHelp.h>
+#pragma comment(lib, "dbghelp.lib")
+#else
+#include <sys/socket.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <sys/ioctl.h> 
+#include <sys/types.h>
+
+
+typedef int SOCKET;
+
+#ifndef INVALID_SOCKET
+#define INVALID_SOCKET (SOCKET)(~0)
+#endif
+#ifndef SOCKET_ERROR
+#define SOCKET_ERROR (-1)
+#endif
+
+#endif // RVC_WIN32
+
+
+
+
+static int get_sys_time(char* pDst, size_t iLen)
+{
+	int iret = 0;
+	if (NULL == pDst) {
+		return iret;
+	}
+
+#ifdef RVC_OS_WIN
+	SYSTEMTIME sys; 
+	GetLocalTime( &sys ); 
+	_snprintf(pDst, iLen, "%04d%02d%02d%02d%02d%02d",sys.wYear, sys.wMonth, sys.wDay, sys.wHour, sys.wMinute, sys.wSecond); 
+#else
+	struct tm* t;
+	time_t tt;
+	time(&tt);
+	t = localtime(&tt);
+	_snprintf(pDst, iLen, "%04d%02d%02d%02d%02d%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
+#endif
+	iret = strlen(pDst);
+	return iret;
+}
+
+
+static int set_socket_attribute(SOCKET client_socket, struct timeval timeout)
+{
+	int ret = -1;
+
+	if(setsockopt(client_socket,SOL_SOCKET,SO_SNDTIMEO,(const void*)& timeout,sizeof(timeout))==SOCKET_ERROR){
+#ifdef RVC_OS_WIN
+		closesocket(client_socket);
+#else
+		close(client_socket);
+#endif // RVC_OS_WIN
+		return ret;
+	}
+
+	if(setsockopt(client_socket,SOL_SOCKET,SO_RCVTIMEO,(const void*)& timeout,sizeof(timeout))==SOCKET_ERROR){
+#ifdef RVC_OS_WIN
+		closesocket(client_socket);
+#else
+		close(client_socket);
+#endif // RVC_OS_WIN
+		return ret;
+	}
+
+	ret = 0;
+
+	return ret;
+}
+
+static int request_voipgateway_address(call_info_t *call_info, proxy_rsp_packet_t* rsp_packet, const size_t rsp_len)
+{
+	int ret = -1;
+	//套接字控制模式
+	u_long mode = 1;
+	//请求包结构体
+	proxy_req_packet_t	req_info = {0};
+	size_t len = sizeof(proxy_req_packet_t);
+
+	char strtime[RVC_DATALEN] = {0};
+	BOOL bconnected = FALSE;
+	int itimelen = 0;
+
+	SOCKET client_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	struct timeval timeout = { 2,0 };
+	if (set_socket_attribute(client_socket, timeout)){
+		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_CONNECT_FAILED, "request_voipgateway_address set_socket_attribute failed.");
+		return ret;
+	}
+	if (INVALID_SOCKET != client_socket){
+		struct sockaddr_in sa;  
+		sa.sin_family = AF_INET;  
+		sa.sin_addr.s_addr = inet_addr(call_info->callroute_server_ip.GetData());
+		sa.sin_port = htons(call_info->callroute_server_port);
+		memset(sa.sin_zero, 0, sizeof(sa.sin_zero));
+		char strmsg[256] = { 0 };
+		_snprintf(strmsg, 256, "dest route addr is %s:%d.", call_info->callroute_server_ip.GetData(), call_info->callroute_server_port);
+		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_ADDRESS, strmsg);
+		//控制为非阻塞方式
+#ifdef RVC_OS_WIN
+		ioctlsocket(client_socket, FIONBIO, &mode);
+#else
+		ioctl(client_socket, FIONBIO, &mode);
+#endif // RVC_OS_WIN
+		ret = connect(client_socket, (struct sockaddr *)&sa, sizeof(struct sockaddr));
+		if (0 == ret){
+			bconnected = TRUE;
+		}
+		else{
+			if (EINPROGRESS == errno) {
+				fd_set writeset;
+				struct timeval timeout;
+				FD_ZERO(&writeset);
+				FD_SET(client_socket, &writeset);
+				timeout.tv_sec = 2;
+				timeout.tv_usec = 0;
+				if (select(client_socket+1, NULL, &writeset, NULL, &timeout) > 0) {
+					if (FD_ISSET(client_socket, &writeset)) {
+						bconnected = TRUE;
+					}
+					
+				}
+			}
+		}
+		//控制为阻塞方式
+		mode = 0;  
+#ifdef RVC_OS_WIN
+		ioctlsocket(client_socket, FIONBIO, &mode);
+#else
+		ioctl(client_socket, FIONBIO, &mode);
+#endif // RVC_OS_WIN
+		if (!bconnected){	//连接失败  
+#ifdef RVC_OS_WIN
+			closesocket(client_socket);
+#else
+			close(client_socket);
+#endif // RVC_OS_WIN
+			char strerror[256];
+			_snprintf(strerror, 256, "request_voipgateway_address connect callroute server timeout(%d).", errno);
+			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_CONNECT_FAILED, strerror);
+			return ret;      //超时
+		} 
+		reset_buffer(&req_info, 0x20, sizeof(proxy_req_packet_t));
+		itimelen = get_sys_time(strtime, RVC_DATALEN);
+		if (0 < itimelen){
+			fill_packet(&req_info, call_info->szdest_num, call_info->szcaller_num, call_info->szbranchno, strtime);
+		}
+		ret = send(client_socket, (const char*)(&req_info), len, 0);
+		if (ret <= 0){
+#ifdef RVC_OS_WIN
+			closesocket(client_socket);
+#else
+			close(client_socket);
+#endif // RVC_OS_WIN
+			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, "request_voipgateway_address send to callroute server failed.");
+			return ret;
+		}
+		ret = recv(client_socket, (char*)rsp_packet, rsp_len, 0);
+
+#ifdef RVC_OS_WIN
+		closesocket(client_socket);
+#else
+		close(client_socket);
+#endif // RVC_OS_WIN
+		if (ret <= 0){
+			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, "request_voipgateway_address recv from callroute server failed.");
+			return ret;
+		}
+	}
+	return ret;
+}
+
+static bool is_response_packet_valid(proxy_rsp_packet_t* packet_info)
+{
+	bool bret = false;
+	if (NULL != packet_info){
+		char strflag[] = {0x33, 0x37, 0x37, 0x20, 0x0};
+		size_t uflaglen = strlen(strflag);
+		if (0 != memcmp(packet_info->req_hdr.packgelen, strflag, uflaglen)){
+			char packgelen[5] = {0};
+			char tradefrom[4] = {0};
+			char requestcode[17] = {0};
+			memcpy(packgelen, packet_info->req_hdr.packgelen, 4);
+		    memcpy(tradefrom, packet_info->req_hdr.tradefrom, 3);
+			memcpy(requestcode, packet_info->req_hdr.requestcode, 16);
+			char strmsg[256] = { 0 };
+			_snprintf(strmsg, 256, "get mediaserver address from callroute server failed, rsp packgelen:%s, tradefrom:%s, requestcode:%s!", 
+				packgelen,tradefrom, requestcode);
+			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, strmsg);
+		}else{
+			bret = true;
+		}
+	}
+	return bret;
+}
+
+static int fifter_sparate_flag(proxy_rsp_packet_t* packet_info)
+{
+	int ret = -1;
+	if (NULL != packet_info){
+		rend_string(packet_info->rsp_body.audio_centent, 0x20);
+		rend_string(packet_info->rsp_body.video_content_ip, 0x20);
+		rend_string(packet_info->rsp_body.video_content_port, 0x20);
+		ret = 0;
+	}
+	return ret;
+} 
+static unsigned int separate_string_string(char *buf, const char *delim, char **array, unsigned int arraylen)
+{
+	unsigned int count = 0;
+	char *d;
+	size_t dlen = strlen(delim);
+
+	array[count++] = buf;
+
+	while (count < arraylen && array[count - 1]) {
+		if ((d = strstr(array[count - 1], delim))) {
+			*d = '\0';
+			d += dlen;
+			array[count++] = d;
+		} else
+			break;
+	}
+
+	return count;
+}
+
+
+static node_list_head_t *create_node_list_by_callernum(call_info_t *call_info, proxy_rsp_packet_t* packet_info)
+{
+	
+	node_list_head_t *phead = NULL;
+	char new_touri[RVC_DATALEN]={0};
+	char strinterip[RVC_DATALEN]={0};
+	char new_caller_number[RVC_DATALEN]={0};
+	
+	if (NULL == call_info || NULL == packet_info){
+		return NULL;
+	}
+	if (is_response_packet_valid(packet_info)){
+		if (0 == fifter_sparate_flag(packet_info)){
+			char *dp[10] = {NULL};
+			int argc, x = 0;
+			argc = separate_string_string(packet_info->rsp_body.audio_centent, ",", dp, (sizeof(dp) / sizeof(dp[0])));
+			if (argc < 1){
+				return NULL;
+			}
+			phead = create_node_list_head(call_info->szcaller_num);
+			for (x = 0; x < argc; x++) {
+				char *dpname = dp[x];
+				if (dpname) {
+					//去掉'号
+					char to_uri[RVC_DATALEN]={0};
+					fifter_string(to_uri, RVC_DATALEN, dpname, '\'');
+					//to url 前面+8
+					if ('8' == dpname[0]){
+						_snprintf(new_touri, RVC_DATALEN, "%s%s", "sip:", to_uri);
+					}
+					else{
+						_snprintf(new_touri, RVC_DATALEN, "%s%s%s", "sip:", "8", to_uri);
+					}
+					//new new_caller_id_number=callernum#assist_int_ip
+					get_interger_netaddr(strinterip, RVC_DATALEN, packet_info->rsp_body.video_content_ip);
+					_snprintf(new_caller_number, RVC_DATALEN, "%s%s%s",
+						call_info->szcaller_num.GetData(), "#", strinterip);
+					char strmsg[256] = { 0 };
+					_snprintf(strmsg, 256,"new callroute node: new_caller_number:%s new_touri:%s, assist_ip:%s, assist_port:%s!", 
+									new_caller_number, new_touri, packet_info->rsp_body.video_content_ip, packet_info->rsp_body.video_content_port);
+					LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, strmsg);
+					add_node_to_list(phead, new_caller_number, new_touri, packet_info->rsp_body.video_content_ip, packet_info->rsp_body.video_content_port);
+				}
+			}
+		}
+	}else{
+		char strerror[256] = { 0 };
+		_snprintf(strerror, 256, "create_node_list_by_callernum failed. szbranchno:%s, szcaller_num:%s, szdest_num:%s.", call_info->szbranchno.GetData(), call_info->szcaller_num.GetData(), call_info->szdest_num.GetData());
+		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, strerror);
+	}
+
+	return phead;
+}
+
+node_list_head_t *get_callroute_list(call_info_t *call_info)
+{
+	int ret;
+	proxy_rsp_packet_t  rsp_info = {0}; 
+	size_t recvlen = sizeof(proxy_rsp_packet_t);
+
+	if (call_info->callroute_server_ip.GetLength() == 0 || 
+		call_info->callroute_server_port == 0 || 
+		call_info->szdest_num.GetLength() == 0 ||
+		call_info->szcaller_num.GetLength() == 0 ||
+		call_info->szbranchno.GetLength() == 0) {
+		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, "get_callroute_list failed call_info param is null.");
+		return NULL;
+	}
+	reset_buffer(&rsp_info, 0x20, sizeof(proxy_rsp_packet_t));
+	ret = request_voipgateway_address(call_info, &rsp_info, recvlen);
+	if (ret <= 0){
+		char strmsg[256] = { 0 };
+		_snprintf(strmsg, 256, "get_callroute_list failed szbranchno:%s, szcaller_num:%s, szdest_num:%s.", call_info->szbranchno.GetData(), call_info->szcaller_num.GetData(), call_info->szdest_num.GetData());
+		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, strmsg);
+		return NULL;
+	}
+	return create_node_list_by_callernum(call_info, &rsp_info);
+}
+
+

Module/mod_counterconnector/callrouter.h

@@ -0,0 +1,25 @@
+#ifndef	_CALLROUTER_
+#define _CALLROUTER_
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "callroute_nodelist.h"
+#include "SimpleString.h"
+
+#ifndef RVC_DATALEN
+#define RVC_DATALEN 126
+#endif
+
+//call_info
+typedef struct call_info{
+	CSimpleStringA callroute_server_ip;
+	int callroute_server_port;
+	CSimpleStringA szdest_num;
+	CSimpleStringA szcaller_num;
+	CSimpleStringA szbranchno;
+}call_info_t; 
+
+
+node_list_head_t *get_callroute_list(call_info_t *call_info);
+
+#endif

Module/mod_counterconnector/strutil.cpp

@@ -0,0 +1,148 @@
+#include "stdafx.h"
+#include "strutil.h"
+
+int reset_buffer(void* pbuf, int idata, size_t ulen)
+{
+	int ret = -1;
+	if (pbuf){
+		memset(pbuf, idata, ulen);
+		ret = 0;
+	}
+
+	return ret;
+}
+
+
+int rend_string(char* pSrc, int iflag)
+{
+	int ret = -1;
+	if (pSrc){
+		char* pindex = pSrc;
+		while(*pindex != iflag){
+			pindex++;
+		};
+		*pindex = '\0';
+		ret = 0;
+	}
+
+	return ret;
+}
+
+int fifter_string(char*pbuf, size_t usize, const char* psrc, const char cflag)
+{
+	int ret = -1;
+	int i = 0;
+	int j = 0;
+	size_t ulen = 0;
+	const char* pindex = psrc;
+	if (NULL == psrc){
+		return ret;
+	}
+
+	ulen = strlen(psrc);
+	for (i=0; i<ulen && i<usize; i++){
+		if (pindex[i] != cflag){
+			pbuf[j++] = pindex[i];
+		}
+	}
+	if (j == ulen - 2){
+		ret = 0;
+	}
+
+	return ret;
+}
+
+
+/*ÎÞ·ûºÅ³¤ÕûÐÎת×Ö·ûÐÍ*/
+char* _ultoa(unsigned long value, char* pstring, int radix)
+{
+	char tmp[33] = { 0 };
+	char* tp = tmp;
+	long i;
+	unsigned long v = value;
+	char* sp;
+
+	if (radix > 36 || radix <= 1 || NULL == pstring){
+		return 0;
+	}
+
+
+	while (v || tp == tmp)
+	{
+		i = v % radix;
+		v = v / radix;
+		if (i < 10)
+			* tp++ = i + '0';
+		else
+			*tp++ = i + 'a' - 10;
+	}
+
+	sp = pstring;
+
+	while (tp > tmp)
+		* sp++ = *--tp;
+	*sp = 0;
+	return pstring;
+}
+
+int get_interger_netaddr(char *strbuf, size_t ubufszie, const char* szip)
+{
+	int ret = -1;
+
+	unsigned long ulip = 0;
+	if (NULL == strbuf || NULL == szip){
+		return ret;
+	}
+
+	ulip = inet_addr(szip);
+	_ultoa(ulip, strbuf, 10);
+
+	ret = 0;
+	return ret;
+}
+
+int convert_interaddr_strip(char *strbuf, size_t ubufszie, const char* szinter_ip)
+{
+	int ret = -1;
+	char* strip = NULL;
+	struct sockaddr_in addr = {0};
+	if (!szinter_ip || !strbuf){
+		return ret;
+	}
+
+	addr.sin_addr.s_addr = strtoul(szinter_ip, NULL, 10);//inet_addr(config->switch_server);
+	strip = inet_ntoa(addr.sin_addr);
+	if (strip){
+		size_t ulen = strlen(strip);
+		if (ulen < ubufszie){
+			memcpy(strbuf, strip, ulen);
+			ret = 0;
+		}
+	}
+
+	return ret;
+}
+
+
+int connect_strings(char* strbuf, size_t ulen, const char* psrca, const char* pstr, const char* psrcb)
+{
+	int ret = -1;
+	size_t ulena = 0;
+	size_t ulenb = 0;
+	size_t ulenstr = 0;
+
+	if(!psrca || !psrcb || !pstr){
+		return ret;
+	}
+
+	ulena = strlen(psrca);
+	ulenb = strlen(psrcb);
+	ulenstr = strlen(pstr);
+
+	if (ulen > ulena + ulenb + ulenstr){
+		_snprintf(strbuf, ulen, "%s%s%s", psrca, pstr, psrcb);
+		ret = 0;
+	}
+
+	return ret;
+}

Module/mod_counterconnector/strutil.h

@@ -0,0 +1,21 @@
+#ifndef _STR_UTIL_
+#define _STR_UTIL_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef RVC_DATALEN
+#define RVC_DATALEN 126
+#endif
+
+#define proxy_copy(pDst, pSrc)		if(pSrc)	{	memcpy(pDst, pSrc, strlen(pSrc));	}
+
+int reset_buffer(void* pbuf, int idata, size_t ulen);
+int rend_string(char* pSrc, int iflag);
+int fifter_string(char*pbuf, size_t usize, const char* psrc, const char cflag);
+int get_interger_netaddr(char *strbuf, size_t ubufszie, const char* szip);
+int convert_interaddr_strip(char *strbuf, size_t ubufszie, const char* szinter_ip);
+int connect_strings(char* strbuf, size_t ulen, const char* psrca, const char* psrcb, const char* pstr);
+
+#endif

Module/mod_healthmanager/HealthManagerFSM.cpp

@@ -2412,7 +2412,7 @@ void CHealthManagerFSM::ToLogWarnTermAboutInfo(BOOL bSuccessFlag)
 
     CSmartPointer<IConfigInfo> pConfig;
 	GetEntityBase()->GetFunction()->OpenConfig(Config_Cache, pConfig);
-    int stepStatus(0), curStep(0), lastRecordTime(0);
+    int stepStatus(0), curStep(0), lastRecordTime(0), beginInstallRecordTime(0);
 	CSimpleStringA strInstallVersion(true);
     CSimpleStringA strAdditonalMsg(true);
     pConfig->ReadConfigValueInt("TerminalDeploy", "CurrStep", curStep);
@@ -2424,10 +2424,16 @@ void CHealthManagerFSM::ToLogWarnTermAboutInfo(BOOL bSuccessFlag)
         pConfig->ReadConfigValueInt("TerminalDeploy", "TimeStamp", lastRecordTime);
 		pConfig->ReadConfigValue("TerminalDeploy", "InstallVersion", strInstallVersion);
         pConfig->ReadConfigValue("TerminalDeploy", "LastInfo", strAdditonalMsg);
+		pConfig->ReadConfigValueInt("TerminalDeploy", "StartTimeStamp", beginInstallRecordTime);
+
+		const DWORD consumeTick = lastRecordTime - beginInstallRecordTime;
 
         LogWarn(Severity_High, Error_Debug, LOG_WARN_HEALTH_INSTALL_TIMESTAMP, 
-				CSimpleString::Format("[{\"timeStamp\":\"%s\",\"step\":%d,\"state\":%d, \"version\":\"%s\", \"msg\":\"%s\"}]", 
-									  CSmallDateTime(lastRecordTime).ToTimeString().GetData(), curStep, stepStatus
+				CSimpleString::Format("{\"begin\":\"%s\",\"finished\":\"%s\", \"consume\":\"%s\", \"step\":%d,\"state\":%d, \"version\":\"%s\", \"msg\":\"%s\"}", 
+                                      CSmallDateTime(beginInstallRecordTime).ToTimeString().GetData(),
+									  CSmallDateTime(lastRecordTime).ToTimeString().GetData(), 
+                                      CSmallDateTime(consumeTick).ToTimeString().GetData(),
+									  curStep, stepStatus
 									  , strInstallVersion.GetData(), strAdditonalMsg.GetData()));
 
         pConfig->WriteConfigValueInt("TerminalDeploy", "CurrStep", DeployStep_Begin);
@@ -2436,6 +2442,15 @@ void CHealthManagerFSM::ToLogWarnTermAboutInfo(BOOL bSuccessFlag)
 		if (!strAdditonalMsg.IsNullOrEmpty()) {
             pConfig->WriteConfigValue("TerminalDeploy", "LastInfo", NULL);
 		}
+        pConfig->WriteConfigValue("TerminalDeploy", "StartTimeStamp", NULL);
+
+		do 
+		{
+            CSmartPointer<IConfigInfo> spConfigRun;
+            GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
+			spConfigRun->WriteConfigValue("DeployInfo", "InstallVersion", strInstallVersion);
+			spConfigRun->WriteConfigValueInt("DeployInfo", "InstallTimeStamp", lastRecordTime);
+		} while (false);
     }
 }
 

Module/mod_healthmanager/mod_healthmanager.cpp

@@ -2427,6 +2427,41 @@ ErrorCodeEnum CHealthManagerEntity::GetTmpRootFilePath(CSimpleStringA& rootPath,
 	return ec;
 }
 
+void CHealthManagerEntity::RecordInstallBeginTimeStamp(const CSimpleString& strTimeStamp, BOOL forceReset)
+{
+    if (!forceReset) {
+        CSimpleStringA strReserved(true);
+        const ErrorCodeEnum rc = GetInstallBeginTimeStamp(strReserved);
+		if (!strReserved.IsNullOrEmpty()) {
+			return;
+		}
+    }
+
+    CSmartPointer<IConfigInfo> pConfig;
+    GetFunction()->OpenConfig(Config_Cache, pConfig);
+
+	if (strTimeStamp.IsNullOrEmpty()) {
+        pConfig->WriteConfigValue("TerminalDeploy", "StartTimeStamp", CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
+	} else {
+        pConfig->WriteConfigValue("TerminalDeploy", "StartTimeStamp", strTimeStamp);
+	}
+}
+
+ErrorCodeEnum CHealthManagerEntity::GetInstallBeginTimeStamp(CSimpleString& strTimeStamp)
+{
+    CSmartPointer<IConfigInfo> pConfig;
+    GetFunction()->OpenConfig(Config_Cache, pConfig);
+	CSimpleStringA strValue(true);
+	pConfig->ReadConfigValue("TerminalDeploy", "StartTimeStamp", strValue);
+	if (strValue.IsNullOrEmpty()) {
+		return Error_DataCheck;
+	}
+
+	strTimeStamp = strValue;
+	return Error_Succeed;
+
+}
+
 ErrorCodeEnum CHealthManagerEntity::GetGuidePageUrlWithStep(int whichStep, CSimpleStringA& strUrl)
 {
 	strUrl.Clear();
@@ -2708,12 +2743,16 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
 				}
 			}
 
+			/*读取第一启动的时间戳，有用*/
+			CSimpleStringA strBeginTimeReserved(true);
+			GetInstallBeginTimeStamp(strBeginTimeReserved);
+
 			CSimpleStringA strCachePath;
             CSimpleStringA strRootTmpFile;
             CSimpleStringA strRootIniFullPath;
             CSimpleStringA strRunInfoDirPath;
 			CSimpleStringA strRunCfgDirPath;
-
+			///**TODO(Gifur@4/21/2022): 既然删除了，前面就没必要清空字段内容了 */
 			GetFunction()->GetPath("RunInfo", strRunInfoDirPath);
 			strCachePath = strRunInfoDirPath + SPLIT_SLASH_STR + "Global.ini";
             if (ExistsFileA(strCachePath)) {
@@ -2721,8 +2760,12 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
                 fileutil_delete_file(strCachePath);
             }
 
-			//GetFunction()->GetPath("RunCfg", strRunCfgDirPath);
-			strRunCfgDirPath = strRunInfoDirPath + SPLIT_SLASH_STR + "runcfg";
+			GetFunction()->GetPath("RunCfg", strRunCfgDirPath);
+			if (strRunCfgDirPath.IsNullOrEmpty()) {
+                strRunCfgDirPath = strRunInfoDirPath + SPLIT_SLASH_STR + "runcfg";
+			} else {
+				Dbg("Get RunCfg from GetPath directly:%s", strRunCfgDirPath.GetData());
+			}
 			if (ExistsDirA(strRunCfgDirPath)) {
 				Dbg("remove runinfo dir");
 				RemoveDirRecursiveA(strRunCfgDirPath);
@@ -2735,7 +2778,13 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
 				fileutil_copy_file(strBackupFile, strRootIniFullPath);
 				fileutil_delete_file(strRootIniFullPath);
 			}
-            LogWarn(Severity_High, Error_Debug, LOG_WARN_HEALTH_INSTALL_RESET, "install reset");
+            LogWarn(Severity_High, Error_Debug, LOG_WARN_HEALTH_INSTALL_RESET, "user requires installation reset!");
+
+			/** 将首次安装的时间写进去*/
+			if (!strBeginTimeReserved.IsNullOrEmpty()) {
+				RecordInstallBeginTimeStamp(strBeginTimeReserved);
+			}
+
 		} else {
 			result = Error_NotImpl;
 		}
@@ -2772,6 +2821,7 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
 			bool fHeadOfficeMode(false);
 			CSimpleStringA matchInfo(true);
 
+			///**TODO(Gifur@4/21/2022): 走分行的逻辑后续要移除 */
 			if (ctx->Req.param1 == 0) { //走分行服务
 				CTerminalInfoQuery* pCnn = new CTerminalInfoQuery(this);
                 /** 1050 是固定的服务端实体端口 [Gifur@20211013]*/
@@ -2960,6 +3010,7 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
 							/** 其他信息的校验和应用 [Gifur@2022123]*/
                             if (!bMatched) {
                                 tmpResult = Error_DataCheck;
+								if (!matchInfo.IsNullOrEmpty()) { matchInfo += "。请核验录入信息是否准确！"; }
                                 tmpMsg = matchInfo;
                             } else {
                                 toRecord = true;
@@ -2979,7 +3030,7 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
 					}
 				} else {
 					tmpResult = Error_ServerNotAvailable;
-					if (result.content.length() > 0) {
+					if (!result.content.empty()) {
                         tmpMsg = CSimpleStringA::Format("访问 %s 失败：%d,%s", config.GetRequestUri().c_str(), result.statusCode, result.content.c_str());
 					} else {
                         tmpMsg = CSimpleStringA::Format("访问 %s 失败：%d", config.GetRequestUri().c_str(), result.statusCode);
@@ -3018,14 +3069,13 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
                         fileutil_delete_file(strRootIniFullPath);
                         Dbg("root.ini exists!");
                     }
-
+					const CSimpleStringA machineType(strTerminalType);
+                    const CSimpleStringA rootPattern("root");
+                    const CSimpleStringA pattern = rootPattern + "\\-" + machineType + "\\-" + strVendorName + "\\-[a-zA-Z0-9_\\(\\)\\-]*" + ".ini";
                     ec = GetFunction()->GetPath("HardwareCfg", strRootCfgPath);
                     array_header_t* subs = fileutil_get_sub_files_a(strRootCfgPath);
                     if (subs) {
                         regex_t reg;
-                        CSimpleStringA machineType(strTerminalType);
-                        CSimpleStringA rootPattern("root");
-                        CSimpleStringA pattern = rootPattern + "\\-" + machineType + "\\-" + strVendorName + "\\-[a-zA-Z0-9_\\(\\)\\-]*" + ".ini";
                         int ret = regcomp(&reg, pattern, REG_EXTENDED | REG_NOSUB);
                         if (ret) {
                             char ebuff[256];
@@ -3061,7 +3111,8 @@ void CHealthManagerEntity::DeployTerminal(SpReqAnsContext<HealthManagerService_D
                             inifile_write_str(strRootTmpFile, "Terminal", "SN", strDeviceSN);
                         }
                     } else {
-                        tmpMsg = "harewarecfg下找不到对应的备选配置，请确认选择的机型和设备厂商是否正确";
+						CSimpleStringA::Format("%s", pattern.GetData());
+                        tmpMsg = "harewarecfg下匹配不到相应的配置文件，请确认选择的机型和设备厂商是否正确";
                         tmpResult = Error_InvalidState;
                     }
 

Module/mod_healthmanager/mod_healthmanager.h

@@ -126,6 +126,10 @@ public:
 		int curStep(0);
 		bool isNeedConfig = IsNotConfigMode(curStep);
 		if (isNeedConfig) {
+			if (curStep == -1) { /** 无root.ini [Gifur@2022422]*/
+				CSimpleStringA strNow(true);
+				RecordInstallBeginTimeStamp(strNow);
+			}
             m_fsm.SetConfigMode(true);
 		} else {
 			DoRestart();
@@ -318,6 +322,10 @@ private:
 	bool IsTestMode();
 
 	ErrorCodeEnum GetTmpRootFilePath(CSimpleStringA& rootPath, CSimpleStringA& rootTmpPath, CSimpleStringA& rootBackPath);
+
+	void RecordInstallBeginTimeStamp(const CSimpleString& strTimeStamp, BOOL forceReset = FALSE);
+    ErrorCodeEnum GetInstallBeginTimeStamp(CSimpleString& strTimeStamp);
+
 	ErrorCodeEnum GetGuidePageUrlWithStep(int whichStep, CSimpleStringA& strUrl);
 
 	ErrorCodeEnum TellChromiumOpenGuidePage(const CSimpleStringA& pageUrl);

Module/mod_mediacontroller/Event.h

@@ -42,6 +42,18 @@
 //warning
 #define ERROR_MOD_MEDIACONTROLLER_HANDFREEIN_INITFAIL		0x20880044  //免提初始化失败,级别3
 #define ERROR_MOD_MEDIACONTROLLER_HANDFREEOUT_INITFAIL		0x20880045  //免提初始化失败,级别3
+
+
+#define ERROR_MOD_MEDIACONTROLLER_CAMERA_OPEN				0x20880061  //打开摄像头
+#define ERROR_MOD_MEDIACONTROLLER_CAMERA_CLOSE				0x20880062  //关闭摄像头
+
+#define ERROR_MOD_MEDIACONTROLLER_ENV_CAMERA_INFO			0x20880063  //env摄像头信息
+#define ERROR_MOD_MEDIACONTROLLER_OPT_CAMERA_INFO			0x20880064  //opt摄像头信息
+
+#define LOG_EVT_MEDIACONTROLLER_CAMERA_MATCHED_FORMAT		0x20880065  //匹配的摄像头分辨率
+#define LOG_EVT_MEDIACONTROLLER_CAMERA_OUTPUT_FORMAT		0x20880066  //摄像头输出图像信息
+
+
 //sysvar
 #define SYSVAR_CAMERASTATE	"CameraState"
 #define CAMERA_NO_ERROR		"N"

Module/mod_mediacontroller/capture.cpp

@@ -1236,6 +1236,18 @@ static void __videocaplog(void* user_data, const char* fmt, va_list arg)
 	vDbg(fmt, arg);
 }
 
+static void __logevent(int itype, const char* strmessage)
+{
+	if (0 == itype) {
+		LogWarn(Severity_Middle, Error_Debug, LOG_EVT_MEDIACONTROLLER_CAMERA_MATCHED_FORMAT, strmessage);
+	}
+	else if (1 == itype) {
+		LogWarn(Severity_Middle, Error_Debug, LOG_EVT_MEDIACONTROLLER_CAMERA_OUTPUT_FORMAT, strmessage);
+	}
+	else {
+		Dbg("unknown type event.");
+	}
+}
 static int video_capture_start_linux(video_capture_t* video_cap)
 {
 	LOG_FUNCTION();
@@ -1282,6 +1294,7 @@ static int video_capture_start_linux(video_capture_t* video_cap)
 
 	videocap_callback_t t_callback = { 0 };
 	t_callback.debug = &__videocaplog;
+	t_callback.logevent = &__logevent;
 	video_cap->pVideoCap = CreateVideoCaptureObj(&t_callback);
 	if (NULL != video_cap->pVideoCap){
 		if (0 == video_cap->pVideoCap->VideoCaptureSetParam(&t_param)) {

Module/mod_pinpad/PinPadFSM.cpp

@@ -989,9 +989,6 @@ Err:
 	if (bCancelInput)
 	{
 		Dbg("input cancel(pin)");
-		if (ec4KeyRead != Error_Succeed) {
-			LOG_PINPAD_ERROR_MSG_MACRO(ec4KeyRead, KeyRead);
-		}
 		return Error_Cancel;
 	}
 	if (readed < len) {
@@ -1687,7 +1684,8 @@ int CPinPadFSM::LoadKeySM(SpReqAnsContext<PinPadService_LoadKeysSM_Req, PinPadSe
 			{
 				spConfig->WriteConfigValue("Load", "SN_SM", ctx->Req.reserved3);
 				m_keySNSM = ctx->Req.reserved3;
-				LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_LoadKey_SMSN, m_keySNSM.GetData());
+				LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_LoadKey_SMSN,
+						CSimpleStringA::Format("{\"type\": \"SN_SM\", \"value\": \"%s\"}", m_keySNSM.GetData()));
 			}
 		}
 		if (eErr != Error_Succeed)

Module/mod_sipphone/Event.h

@@ -102,6 +102,10 @@
 #define ERROR_MOD_SIP_AUDIO_RTP_CREATE_FAILED						0x3019060B  //audio rtp create failed,级别2
 #define ERROR_MOD_SIP_AUDIO_CONTEXT_CREATE_FAILED					0x3019060C  //audio context create failed,级别2
 
+
+#define ERROR_MOD_SIP_GET_ENV_VIDEO_FAILED							0x30190801  //获取env摄像头图像失败
+#define ERROR_MOD_SIP_GET_OPT_VIDEO_FAILED							0x30190802  //获取opt摄像头图像失败
+
 #define EVENT_MOD_SIP_ENTITY_STARTED		0x301A0001		//sipphone entity start
 #define EVENT_MOD_SIP_INVITE_SEND			0x301A0002		//sip invite send
 #define EVENT_MOD_SIP_PROCESS_MSG			0x301A0003		//sip process messsage

Module/mod_sipphone/SIPPhone_def_g.h

@@ -51,11 +51,13 @@ namespace SIPPhone {
 
 struct PhoneService_MakeCall_Req
 {
-	CSimpleStringA call_uri;
+	CSimpleStringA to_uri;
+	CSimpleStringA from_uri;
+	CSimpleStringA call_id;
 
 	void Serialize(SpBuffer &Buf)
 	{
-		auto & buf = Buf & call_uri;
+		auto & buf = Buf & to_uri & from_uri & call_id;
 	}
 
 };

Module/mod_sipphone/SipService.xml

@@ -10,7 +10,9 @@
 	<class name="PhoneService" overlap="true" exclusive="false">
 		<twoway name="MakeCall" overlap="true">
 			<req>
-				<param name="call_uri" type="string"/>
+				<param name="to_uri" type="string"/>
+				<param name="from_uri" type="string"/>
+				<param name="call_id" type="string"/>
 			</req>
 		</twoway>
 		<twoway name="HangupCall" overlap="true">

Module/mod_sipphone/mod_sipphone.cpp

@@ -2098,11 +2098,11 @@ void CSIPPhoneSession::OnClose( ErrorCodeEnum eErrorCode )
 void CSIPPhoneSession::Handle_MakeCall( SpReqAnsContext<PhoneService_MakeCall_Req, PhoneService_MakeCall_Ans>::Pointer ctx )
 {
 	LOG_FUNCTION();
-	LOG_TRACE("make call [%s]", (LPCSTR)ctx->Req.call_uri);
+	LOG_TRACE("make call [%s]", (LPCSTR)ctx->Req.to_uri);
 	int rc;
 	MakeCallCommand *cmd = new MakeCallCommand();
 	cmd->pSIPPhoneSession = this;
-	cmd->strUri = ctx->Req.call_uri;
+	cmd->strUri = ctx->Req.to_uri;
 	///////////重新初始化sip话机,防止断网导致IP改变//////////////////
 
 	if (m_pEntity->m_pEndpoint){

Module/mod_sipphone/video_session.cpp

@@ -134,6 +134,7 @@ struct video_session_t
 	bool bvideorecved;
 	bool blocalrender;
 	bool bremoterender;
+	bool bcamera_error_posted;
 };
 
 
@@ -153,6 +154,21 @@ static void __logevent(void* user_data, int itype, const char* strmessage)
 	}
 }
 
+static bool __camera_error_event(bool bhaspost, int icameraid)
+{
+	bool bret = false;
+	if (false == bhaspost){
+		if (0 == icameraid){
+			LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_GET_ENV_VIDEO_FAILED, "get video from env queue failed!");
+		}
+		else{
+			LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_GET_OPT_VIDEO_FAILED, "get video from opt queue failed!");
+		}		
+		bret = true;
+	}
+	return bret;
+}
+
 
 static int translate_image_resolution(video_frame** dstframe,const int iwidth, const int iheight, const video_frame* psrcframe)
 {
@@ -815,6 +831,9 @@ static int get_local_video_frame(void* user_data, video_frame** frame)
 		}
 		else {
 			video_frame_fill_black(tmp_frame_preview);
+			if (__camera_error_event(session->bcamera_error_posted, 0)) {
+				session->bcamera_error_posted = true;
+			}
 		}
 	}
 	else
@@ -866,7 +885,11 @@ static int get_local_video_frame(void* user_data, video_frame** frame)
 				tmp_frame_preview = video_frame_new(REC_COMMON_VIDEO_PREVIEW_WIDTH, REC_COMMON_VIDEO_PREVIEW_HEIGHT, VIDEO_FORMAT_RGB24);
 				videoq_frame frm;
 				frm.data = tmp_frame_preview->data[0];
-				session->video_shm_q_preview->GetVideo(&frm, VIDEOQUEUE_FLAG_HORIZONTAL_FLIP);
+				if (FALSE == session->video_shm_q_preview->GetVideo(&frm, VIDEOQUEUE_FLAG_HORIZONTAL_FLIP)) {
+					if (__camera_error_event(session->bcamera_error_posted, 0)) {
+						session->bcamera_error_posted = true;
+					}
+				}
 			}
 			else
 			{
@@ -879,7 +902,11 @@ static int get_local_video_frame(void* user_data, video_frame** frame)
 						videoq_frame frm;
 						int offset = (REC_COMMON_VIDEO_SNAPSHOT_WIDTH - REC_COMMON_VIDEO_SNAPSHOT_HEIGHT) / 2;
 						frm.data = tmp_frame_preview->data[0] + offset * tmp_frame_preview->linesize[0];
-						session->video_shm_q_env->GetVideo(&frm, VIDEOQUEUE_FLAG_VERTICAL_FLIP);
+						if (FALSE == session->video_shm_q_env->GetVideo(&frm, VIDEOQUEUE_FLAG_VERTICAL_FLIP)){
+							if (__camera_error_event(session->bcamera_error_posted, 0)) {
+								session->bcamera_error_posted = true;
+							}
+						}
 					}
 				}
 				else if (*session->conf.ref_camera_switch == CAMERA_TYPE_OPT)//显示下摄像头
@@ -893,7 +920,11 @@ static int get_local_video_frame(void* user_data, video_frame** frame)
 						tt.linesize[0] = tmp_frame_preview->linesize[0];
 						tt.width = REC_COMMON_VIDEO_SNAPSHOT_HEIGHT;
 						tt.height = REC_COMMON_VIDEO_SNAPSHOT_WIDTH;
-						session->video_shm_q_opt->GetVideo2(&tt, VIDEOQUEUE_FLAG_VERTICAL_FLIP);
+						if (FALSE == session->video_shm_q_opt->GetVideo2(&tt, VIDEOQUEUE_FLAG_VERTICAL_FLIP)) {
+							if (__camera_error_event(session->bcamera_error_posted, 1)) {
+								session->bcamera_error_posted = true;
+							}
+						}
 					}
 				}
 			}
@@ -951,6 +982,9 @@ static int get_local_video_frame(void* user_data, video_frame** frame)
 			}
 			else {
 				video_frame_fill_black(tmp_frame_preview);
+				if (__camera_error_event(session->bcamera_error_posted, 0)) {
+					session->bcamera_error_posted = true;
+				}
 			}
 		}
 	}

Module/mod_sipphone/volumekeeper.cpp

@@ -14,7 +14,6 @@
 
 class volume_keeper_t : public IAudioEndpointVolumeCallback
 {
-
 	//float fLevelMinDB;
 	//float fLevelMaxDB;
 	//float fLevelIncDB;

Other/libRestfulFunc/RestfulFuncImpl.cpp

@@ -109,7 +109,10 @@ void RestfulClient::Do(const HttpClientRequestConfig* const pRequestConfig, Http
     }
     request.set_request_uri(urib.to_string());
     request.headers().add(header_names::accept, pRequestConfig->GetAcceptType());
-    request.set_body(pRequestConfig->GetBodyContent(), pRequestConfig->GetContentType());
+
+    if (pRequestConfig->GetRequestType() != HttpRequestMethod::GET) {
+        request.set_body(pRequestConfig->GetBodyContent(), pRequestConfig->GetContentType());
+    }
 
     if (pRequestConfig->GetRequestType() == HttpRequestMethod::DOWNLOAD) {
         pplx::task<void> requestTask = client.request(request)

Other/libvideocapture/ivideocaptureinterface.h

@@ -126,6 +126,7 @@ typedef struct videocap_callback_s {
 	void (*debug)(void* user_data, const char* fmt, va_list arg);
 	void (*oncapturefailed)();
 	void (*onvideocapexcption)();
+	void (*logevent)(int itype, const char* strmessage);
 	void* user_data;
 }videocap_callback_t;
 

Other/libvideocapture/linux/videocapture_linux.cpp

@@ -339,7 +339,9 @@ int32_t VideoCaptureImpl::IncomingFrame(uint8_t* videoFrame,
 	const int32_t height = frameInfo.height;
 
 	if (0 == m_ilogcount){
-		CapLog("IncomingFrame capture_time is %d, videoType=%d, rotate=%d, videoFrameLength=%d, width=%d, height=%d, and destination width=%d, height=%d.", captureTime, frameInfo.videoType, m_rotate, videoFrameLength, width, height, m_out_cap_width, m_out_cap_height);
+		char strmsg[256] = { 0 };
+		snprintf(strmsg, 256, "IncomingFrame capture_time is %d, videoType=%d, rotate=%d, videoFrameLength=%d, width=%d, height=%d, and destination width=%d, height=%d.", captureTime, frameInfo.videoType, m_rotate, videoFrameLength, width, height, m_out_cap_width, m_out_cap_height);
+		CapLogEvent(1, strmsg);
 		m_ilogcount++;
 	}
 	
@@ -651,7 +653,9 @@ int VideoCaptureImpl::StartVideoCapture()
 	else {
 		char strformat[32] = { 0 };
 		GetFourccName(strformat, 32, fmts[fmtsIdx]);
-		CapLog("we prefer format %s.", strformat);
+		char strmsg[256] = { 0 };
+		snprintf(strmsg, 256, "we prefer format %s.", strformat);
+		CapLogEvent(1, strmsg);
 	}
 
 	struct v4l2_format video_fmt;
@@ -713,7 +717,6 @@ int VideoCaptureImpl::StartVideoCapture()
 			streamparms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 			streamparms.parm.capture.timeperframe.numerator = 1;
 			streamparms.parm.capture.timeperframe.denominator = (int32_t)m_capture->param.fps;
-			CapLog("Set Camera video capture timeperframe numerator is %d, denominator is %d.", streamparms.parm.capture.timeperframe.numerator, streamparms.parm.capture.timeperframe.denominator);
 			
 			if (ioctl(m_deviceFd, VIDIOC_S_PARM, &streamparms) < 0) {
 				CapLog("Failed to set the framerate. error info is %s.", strerror(errno));
@@ -721,10 +724,14 @@ int VideoCaptureImpl::StartVideoCapture()
 			}
 			else {
 				m_currentFrameRate = (int32_t)m_capture->param.fps;
-				CapLog("Set Camera video capture rate to %d, and numerator is %d, denominator is %d.", m_currentFrameRate, streamparms.parm.capture.timeperframe.numerator, streamparms.parm.capture.timeperframe.denominator);
-				
+				char strframerate[256] = { 0 };
+				snprintf(strframerate, 256, "Set Camera video capture rate to %d, and numerator is %d, denominator is %d.", m_currentFrameRate, streamparms.parm.capture.timeperframe.numerator, streamparms.parm.capture.timeperframe.denominator);
+				CapLogEvent(0, strframerate);
+
 				if (ioctl(m_deviceFd, VIDIOC_G_PARM, &streamparms) == 0) {	
-					CapLog("Get video capture numerator is %d, denominator is %d.", streamparms.parm.capture.timeperframe.numerator, streamparms.parm.capture.timeperframe.denominator);
+					char stroutrate[256] = { 0 };
+					snprintf(stroutrate, 256, "Get video capture numerator is %d, denominator is %d.", streamparms.parm.capture.timeperframe.numerator, streamparms.parm.capture.timeperframe.denominator);
+					CapLogEvent(1, stroutrate);
 				}
 			}
 		}
@@ -1110,3 +1117,10 @@ void VideoCaptureImpl::CapLog(const char* fmt, ...)
 		va_end(arg);
 	}
 }
+
+void VideoCaptureImpl::CapLogEvent(int itype, const char* strmessage)
+{
+	if (m_callback.logevent) {
+		(*m_callback.logevent)(itype, strmessage);
+	}
+}

Other/libvideocapture/linux/videocapture_linux.h

@@ -76,6 +76,7 @@ public:
 	int32_t IncomingFrame(uint8_t* videoFrame, size_t videoFrameLength,	const VideoCaptureCapability& frameInfo, int64_t captureTime = 0);
 	Buffer* GetCaptureBuffer();
 	void CapLog(const char* fmt, ...);
+	void CapLogEvent(int itype, const char* strmessage);
 
 private:
 	int TransToRealBrightnessValue(int ibright);

Other/libwmvrecord/libwmvrecord.cpp

@@ -479,7 +479,7 @@ private:
 			{
 				size = m_videoqueue2->GetFrameSize(width2,height2);
 				(width2>height2)?(nWidth=nHeight=width2):(nWidth=nHeight=height2);
-				m_pHostApi->Debug("eSingleSide Record, videoqueue2 size: %d,  width2: %d, height2: %d.", size, width2, height2);
+				//m_pHostApi->Debug("eSingleSide Record, videoqueue2 size: %d,  width2: %d, height2: %d.", size, width2, height2);
 			}
 
 			if (!m_SubtitleParam.bSubtitle || !m_SubtitleParam.bSubtitleSection)
@@ -506,7 +506,7 @@ private:
 					nWidth = width1*2;
 					nHeight = height1;
 					size = nWidth*nHeight*3;
-					m_pHostApi->Debug("ePad2Agent Record, remotevideoqueue size: %d, nWidth: %d, nHeight: %d.", size, nWidth, nHeight);
+					//m_pHostApi->Debug("ePad2Agent Record, remotevideoqueue size: %d, nWidth: %d, nHeight: %d.", size, nWidth, nHeight);
 				}
 				else if (eStand2Agent == m_eRecordType) //大机以终端的视频大小确定画布,终端为640*360，远端固定为320*240，则画布为640*640+320*240  = 960*640
 				{
@@ -516,7 +516,7 @@ private:
 					int width2  = 0;
 					int height2 = 0;
 					size = m_videoqueue->GetFrameSize(width1,height1);
-					m_pHostApi->Debug("eStand2Agent Record, videoqueue size: %d,  width1: %d, height1: %d.", size, width1, height1);
+					//m_pHostApi->Debug("eStand2Agent Record, videoqueue size: %d,  width1: %d, height1: %d.", size, width1, height1);
 					if (size)
 					{
 						(width1>height1)?(nWidth=nHeight=width1):(nWidth=nHeight=height1);
@@ -525,7 +525,7 @@ private:
 					{
 						size = m_videoqueue2->GetFrameSize(width2,height2);
 						(width2>height2)?(nWidth=nHeight=width2):(nWidth=nHeight=height2);
-						m_pHostApi->Debug("eStand2Agent Record, videoqueue2 size: %d,  width2: %d, height2: %d.", size, width2, height2);
+						//m_pHostApi->Debug("eStand2Agent Record, videoqueue2 size: %d,  width2: %d, height2: %d.", size, width2, height2);
 					}
 
 					//远端视频320*240
@@ -540,7 +540,7 @@ private:
 						nHeight += 50;
 						size = nWidth*nHeight*3;
 					}
-					m_pHostApi->Debug("eStand2Agent Record, bSubtitle: %d, size: %d, nWidth: %d, nHeight: %d.", m_SubtitleParam.bSubtitle, size, nWidth, nHeight);
+					//m_pHostApi->Debug("eStand2Agent Record, bSubtitle: %d, size: %d, nWidth: %d, nHeight: %d.", m_SubtitleParam.bSubtitle, size, nWidth, nHeight);
 				}
 
 			}
@@ -559,8 +559,8 @@ private:
 					nHeight=height1+50;
 					size = nWidth*nHeight*3;
 				}
-				m_pHostApi->Debug("eSingleSide Record No Local videoqueue2, bSubtitle: %d, size: %d, nWidth: %d, nHeight: %d.", 
-					m_SubtitleParam.bSubtitle, size, nWidth, nHeight);
+				//m_pHostApi->Debug("eSingleSide Record No Local videoqueue2, bSubtitle: %d, size: %d, nWidth: %d, nHeight: %d.", 
+				//	m_SubtitleParam.bSubtitle, size, nWidth, nHeight);
 			}
 		}
 		return size;
@@ -598,8 +598,8 @@ private:
 
 						BOOL bGetLocalvideo = FALSE;
 						bGetLocalvideo = GetVideoFrame(&tmp_frm,1,m_videoqueue);	//获取本地视频的数组形式数据
-						m_pHostApi->Debug("%s mode have remote video queue, local video queue format: %d, width: %d, height: %d.",
-							record_type_table[m_eRecordType], tmp_frm.format, tmp_frm.width, tmp_frm.height);
+						//m_pHostApi->Debug("%s mode have remote video queue, local video queue format: %d, width: %d, height: %d.",
+						//	record_type_table[m_eRecordType], tmp_frm.format, tmp_frm.width, tmp_frm.height);
 						if (bGetLocalvideo)
 						{
 							//本地录像需要偏移量
@@ -608,8 +608,8 @@ private:
 							{
 								nOffset = (Video->height-h)/2*Video->width*3;
 							}
-							m_pHostApi->Debug("%s mode local video queue offset: %d, Video width: %d, Video height: %d, width: %d, height: %d.",
-								record_type_table[m_eRecordType], nOffset, Video->width, Video->height, w, h);
+							//m_pHostApi->Debug("%s mode local video queue offset: %d, Video width: %d, Video height: %d, width: %d, height: %d.",
+							//	record_type_table[m_eRecordType], nOffset, Video->width, Video->height, w, h);
 
 							for (int i= 0;i<tmp_frm.height && i<Video->height;i++)
 							{
@@ -626,8 +626,8 @@ private:
 						tmp_frm.height = h;
 						BOOL bGetRemotevideo = FALSE;
 						bGetRemotevideo = GetVideoFrame(&tmp_frm,1,m_remotevideoqueue);
-						m_pHostApi->Debug("%s mode have remote video queue, remote video queue format: %d, width: %d, height: %d.",
-							record_type_table[m_eRecordType], tmp_frm.format, tmp_frm.width, tmp_frm.height);
+						//m_pHostApi->Debug("%s mode have remote video queue, remote video queue format: %d, width: %d, height: %d.",
+						//	record_type_table[m_eRecordType], tmp_frm.format, tmp_frm.width, tmp_frm.height);
 						if (bGetRemotevideo)
 						{
 							for (int i= 0;i<tmp_frm.height&&i<Video->height;i++)
@@ -656,8 +656,8 @@ private:
 				if (!m_SubtitleParam.bSubtitle || !m_SubtitleParam.bSubtitleSection)
 				{
 					bool result =  m_videoqueue->GetVideo(Video,flags);
-					m_pHostApi->Debug("%s mode No bSubtitle, local video queue format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], Video->format, Video->width, Video->height);
+					//m_pHostApi->Debug("%s mode No bSubtitle, local video queue format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], Video->format, Video->width, Video->height);
 					return result;
 				}
 				else
@@ -670,11 +670,11 @@ private:
 					videoq_frame*tmp_frm = new videoq_frame;
 					//下移30
 					tmp_frm->data = Video->data+ Video->width*30*3;
-					m_pHostApi->Debug("%s mode local video queue offset: %d, Video width: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], Video->width * 30 * 3, Video->width, width, height);
+					//m_pHostApi->Debug("%s mode local video queue offset: %d, Video width: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], Video->width * 30 * 3, Video->width, width, height);
 					bRslt = m_videoqueue->GetVideo(tmp_frm, flags);
-					m_pHostApi->Debug("%s mode local video queue format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
+					//m_pHostApi->Debug("%s mode local video queue format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
 					if (!bRslt)
 					{
 						delete tmp_frm;
@@ -715,12 +715,12 @@ private:
 					videoq_frame*tmp_frm = new videoq_frame;
 					//if (!m_SubtitleParam.bSubtitle || !m_SubtitleParam.bSubtitleSection)
 					tmp_frm->data = localtmp_frm.data[0]+ width*(width-height)/2*3;    //在画布中加上偏移量
-					m_pHostApi->Debug("%s mode local video queue offset: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], width* (width - height) / 2 * 3, width, height);
+					//m_pHostApi->Debug("%s mode local video queue offset: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], width* (width - height) / 2 * 3, width, height);
 					//横向摄像头拼接
 					bRslt = m_videoqueue->GetVideo(tmp_frm, flags);
-					m_pHostApi->Debug("%s mode local video queue format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
+					//m_pHostApi->Debug("%s mode local video queue format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
 					if (!bRslt)
 					{
 						delete tmp_frm;
@@ -733,12 +733,12 @@ private:
 				{
 					videoq_frame*tmp_frm = new videoq_frame;
 					tmp_frm->data = localtmp_frm.data[0] + (width-height)/2*3;  //在画布中加上偏移量
-					m_pHostApi->Debug("%s mode local videoqueue2 offset: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], (width - height) / 2 * 3, width, height);
+					//m_pHostApi->Debug("%s mode local videoqueue2 offset: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], (width - height) / 2 * 3, width, height);
 					//竖向摄像头图像，拼接
 					bRslt = m_videoqueue2->GetVideo3(tmp_frm, flags);
-					m_pHostApi->Debug("%s mode local videoqueue2 format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
+					//m_pHostApi->Debug("%s mode local videoqueue2 format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
 					if (!bRslt)
 					{
 						delete tmp_frm;	
@@ -786,8 +786,8 @@ private:
 					tmp_frm.height = h;
 					BOOL bGetRemotevideo = FALSE;
 					bGetRemotevideo = GetVideoFrame(&tmp_frm,1,m_remotevideoqueue);
-					m_pHostApi->Debug("%s mode remote video queue format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], tmp_frm.format, tmp_frm.width, tmp_frm.height);
+					//m_pHostApi->Debug("%s mode remote video queue format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], tmp_frm.format, tmp_frm.width, tmp_frm.height);
 					if (bGetRemotevideo)
 					{
 						for (int i= 0;i<tmp_frm.height&&i<Video->height;i++)
@@ -821,18 +821,18 @@ private:
 					if (!m_SubtitleParam.bSubtitle || !m_SubtitleParam.bSubtitleSection)
 					{
 						tmp_frm->data = Video->data+ Video->width*(width-height)/2*3;
-						m_pHostApi->Debug("%s mode no remote video queue, no bSubtitle offset: %d, width: %d, height: %d.",
-							record_type_table[m_eRecordType], Video->width* (width - height) / 2 * 3, width, height);
+						//m_pHostApi->Debug("%s mode no remote video queue, no bSubtitle offset: %d, width: %d, height: %d.",
+						//	record_type_table[m_eRecordType], Video->width* (width - height) / 2 * 3, width, height);
 					}
 					else
 					{
 						tmp_frm->data = Video->data+ Video->width*((width-height)/2+30)*3;
-						m_pHostApi->Debug("%s mode no remote video queue, have bSubtitle offset: %d, width: %d, height: %d.",
-							record_type_table[m_eRecordType], Video->width* ((width - height) / 2 + 30) * 3, width, height);
+						//m_pHostApi->Debug("%s mode no remote video queue, have bSubtitle offset: %d, width: %d, height: %d.",
+						//	record_type_table[m_eRecordType], Video->width* ((width - height) / 2 + 30) * 3, width, height);
 					}
 					bRslt = m_videoqueue->GetVideo(tmp_frm, flags);
-					m_pHostApi->Debug("%s mode no remote video queue, local video queue format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
+					//m_pHostApi->Debug("%s mode no remote video queue, local video queue format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
 					if (!bRslt)
 					{
 						delete tmp_frm;
@@ -847,19 +847,19 @@ private:
 					if (!m_SubtitleParam.bSubtitle || !m_SubtitleParam.bSubtitleSection)
 					{
 						tmp_frm->data = Video->data + (width-height)/2*3;
-						m_pHostApi->Debug("%s mode no remote video queue, no bSubtitle offset: %d, width: %d, height: %d.",
-							record_type_table[m_eRecordType], (width - height) / 2 * 3, width, height);
+						//m_pHostApi->Debug("%s mode no remote video queue, no bSubtitle offset: %d, width: %d, height: %d.",
+						//	record_type_table[m_eRecordType], (width - height) / 2 * 3, width, height);
 					}
 					else
 					{
 						tmp_frm->data = Video->data + (Video->width*30+(width-height)/2)*3;
-						m_pHostApi->Debug("%s mode no remote video queue, have bSubtitle offset: %d, width: %d, height: %d.",
-							record_type_table[m_eRecordType], (Video->width * 30 + (width - height) / 2) * 3, width, height);
+						//m_pHostApi->Debug("%s mode no remote video queue, have bSubtitle offset: %d, width: %d, height: %d.",
+						//	record_type_table[m_eRecordType], (Video->width * 30 + (width - height) / 2) * 3, width, height);
 					}
 					//横向摄像头图像，拼接
 					bRslt = m_videoqueue2->GetVideo3(tmp_frm, flags);
-					m_pHostApi->Debug("%s mode no remote video queue, local videoqueue2 format: %d, width: %d, height: %d.",
-						record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
+					//m_pHostApi->Debug("%s mode no remote video queue, local videoqueue2 format: %d, width: %d, height: %d.",
+					//	record_type_table[m_eRecordType], tmp_frm->format, tmp_frm->width, tmp_frm->height);
 					if (!bRslt)
 					{
 						delete tmp_frm;	
@@ -1088,7 +1088,7 @@ private:
 			uOutBitRate = Get44KOutPutBitRate(iChannels, eType);
 			break;
 		default:
-			Dbg("not support format, input sample rate is %d, channels number is %d.", iInPutSamperate, iChannels);
+			m_pHostApi->Debug("not support format, input sample rate is %d, channels number is %d.", iInPutSamperate, iChannels);
 			break;
 		}
 		return uOutBitRate;
@@ -1217,13 +1217,13 @@ private:
 						if (nAudioFrameSize <=0)
 						{
 							++nAudioSizeFailedTimes;
-							m_pHostApi->Debug("nAudioFrameSize = 0");
+							//m_pHostApi->Debug("nAudioFrameSize = 0");
 							//nAudioFrameSize = m_remoteaudioqueue->GetFrameSize();
 							//m_pHostApi->Debug("use m_remoteaudioqueue audio frame size init audio frame size.");
 							FSleep(10);
 							continue;
 						}
-						m_pHostApi->Debug("Local Audio Frame Size = %d", nAudioFrameSize);
+						//m_pHostApi->Debug("Local Audio Frame Size = %d", nAudioFrameSize);
 					}
 					//初始化视频buffer
 					if (videoframe->data == NULL)
@@ -1484,28 +1484,28 @@ private:
 								//	audioframe->samplespersec, audioframe->framesize, audioframe->nchannels, audioframe->format, audioframe->bitspersample, audioframe->iseriesnumber);
 								nAudioFromQueNum++;
 								if ((0 == nAudioFromQueNum%100) && 0 != audioframe->iseriesnumber){
-									m_pHostApi->Debug("single side record current audio queue len is %d and audio series number is: %d.",nAudioLens, audioframe->iseriesnumber);
+									//m_pHostApi->Debug("single side record current audio queue len is %d and audio series number is: %d.",nAudioLens, audioframe->iseriesnumber);
 								}
 
 								if (m_bIsAudioTransOn && NULL != m_salestransqueue){
 									if (m_salestransqueue->Enqueue(audioframe)){
 										//if (0 == audioframe->iseriesnumber%100){
-											m_pHostApi->Debug("audio frame enqueue sales trans queue, and frame series number is %d.", audioframe->iseriesnumber);
+											//m_pHostApi->Debug("audio frame enqueue sales trans queue, and frame series number is %d.", audioframe->iseriesnumber);
 										//}
 									}
 									else{
-										Dbg("audio frame enqueue sales trans queue failed, and frame series number is %d.", audioframe->iseriesnumber);
+										//m_pHostApi->Debug("audio frame enqueue sales trans queue failed, and frame series number is %d.", audioframe->iseriesnumber);
 									}
 								}
 							}
 							else{
-								m_pHostApi->Debug("get audio from m_audioqueue failed.");
+								//m_pHostApi->Debug("get audio from m_audioqueue failed.");
 								FSleep(2); //huchen add ，避免不停获取音频数据导致cpu占用高
 							}
 						}
 					}
 					else {
-						m_pHostApi->Debug("get audio length from m_audioqueue failed.");
+						//m_pHostApi->Debug("get audio length from m_audioqueue failed.");
 						FSleep(2); //huchen add ，避免不停获取音频数据导致cpu占用高
 					}
 				}
@@ -1539,11 +1539,11 @@ private:
 								nAudioBufferLens += audioframe->framesize;
 								nAudioFromQueNum++;
 								if ((0 == nAudioFromQueNum%100) && (0 != audioframe->iseriesnumber)){
-									m_pHostApi->Debug("not single side record,but no remote audio data and current local audio queue len is %d, local audio series number is: %d.", nAudioLens, audioframe->iseriesnumber);
+									//m_pHostApi->Debug("not single side record,but no remote audio data and current local audio queue len is %d, local audio series number is: %d.", nAudioLens, audioframe->iseriesnumber);
 								}
 							}
 							else{
-								m_pHostApi->Debug("get audio from m_audioqueue failed.");
+								//m_pHostApi->Debug("get audio from m_audioqueue failed.");
 								FSleep(2);
 							}
 						}
@@ -1577,7 +1577,7 @@ private:
 								nRemoteAudioNum++;
 							}
 							else {
-								m_pHostApi->Debug("get audio from m_remoteaudioqueue failed.");
+								//m_pHostApi->Debug("get audio from m_remoteaudioqueue failed.");
 								FSleep(2);
 							}
 							delete RemoteAudio;
@@ -1625,11 +1625,11 @@ private:
 								}
 								nAudioFromQueNum++;
 								if ((0 == nAudioFromQueNum%100) && (0 != audioframe->iseriesnumber)){
-									m_pHostApi->Debug("not single side record,and current local audio queue len is %d audio series number is: %d.",nAudioLens, audioframe->iseriesnumber);
+									//m_pHostApi->Debug("not single side record,and current local audio queue len is %d audio series number is: %d.",nAudioLens, audioframe->iseriesnumber);
 								}
 							}
 							else{
-								m_pHostApi->Debug("get audio from m_audioqueue failed.");
+								//m_pHostApi->Debug("get audio from m_audioqueue failed.");
 								FSleep(2);
 							}
 						}
@@ -1666,13 +1666,13 @@ private:
 								nAudioFromQueNum++;
 							}
 							else {
-								m_pHostApi->Debug("get audio from m_remoteaudioqueue failed.");
+								//m_pHostApi->Debug("get audio from m_remoteaudioqueue failed.");
 								FSleep(2);
 							}
 						}
 					}
 					else {
-						m_pHostApi->Debug("get audio length from m_remoteaudioqueue and m_audioqueue failed.");
+						//m_pHostApi->Debug("get audio length from m_remoteaudioqueue and m_audioqueue failed.");
 						FSleep(2);
 					}
 				}	
@@ -2086,7 +2086,7 @@ public:
 		}
 
 		//Dbg("m_audioOutBitRate = %d.", m_audioOutBitRate);
-		Dbg("record output audio quality type is = %s, noise suppression flag is %s, noise suppression policy is %d, audio transfer flag is %s.", audio_quality_type_table[m_eAudioType], m_bIsAudioNsOn ? "true":"false", m_iNsPolicy, m_bIsAudioTransOn ? "true":"false");
+		m_pHostApi->Debug("record output audio quality type is = %s, noise suppression flag is %s, noise suppression policy is %d, audio transfer flag is %s.", audio_quality_type_table[m_eAudioType], m_bIsAudioNsOn ? "true":"false", m_iNsPolicy, m_bIsAudioTransOn ? "true":"false");
 		//m_salestransqueue = new Clibaudiotransqueue(m_FileName);
 		if (m_bIsAudioTransOn){
 			m_salestransqueue = new Clibaudiotransqueue(m_FileName);

Other/libwmvrecord/libwmvrecord.h

@@ -7,7 +7,6 @@
 #ifndef LIBWMVRECORD_H
 #define LIBWMVRECORD_H
 
-
 #include "SpBase.h"
 
 #ifdef RVC_OS_WIN

addin/cfg/HealthManager.ini

@@ -1,15 +1,14 @@
 [CoreBoot.RVC.Stand2S]
+Alarm=0
 PinPad=0
 WatchDog=0
 Ups=0
 DeviceControl=0
 CardReadAdapter=0
 CustMngrAuth=0
-Alarm=1
 ;please use --test to boot up the entity
 ;TestDeamon=0
 Chromium=0
-
 [SafeLoad.RVC.Stand2S]
 Initializer=2
 CenterSetting=2
@@ -46,9 +45,6 @@ HSPScanner=0
 RemoteController=0
 ResourceWatcher=0
 
-;CameraConfigManage=0
-;SalesAudioTrans=0
-
 [Operating.RVC.Stand2S]
 CardIssuer=0
 IDCertificate=0

addin/res/ManagerDesktop/guide.html

@@ -335,7 +335,7 @@
                                     </div>
                                 </div>
                                 <div class="pull-left input_normal text-left">
-                                    <input id="guide_server_ip" type="text" autocomplete="off" disabled="disabled"
+                                    <input id="guide_server_ip" type="text" autocomplete="off"
                                         onfocus="showInputBorder(this)" onblur="hideInputBorder(this)"
                                         oncontextmenu="return false;" maxlength="128" value="">
                                 </div>