myvtm/DevAdapter/cw/hspscanner.1.1/hspscannerimpl.cpp

#include "hspscannerimpl.h"
#include "SSocket.h"

#define ERR_NO_DEVICE   -1
#define ERR_NOT_OPENED  -2
#define ERR_OPEN_FAIL   -3
#define ERR_VIEW_FAIL   -4
#define ERR_DEVICE_CHG  -5

/////////////////////////////////////////////////////////////////////

HSPSClassImpl::HSPSClassImpl()
{
    m_sLibPath[0] = 0;
    m_bIsOpen = false;
    HSPSCall = NULL;
    m_hThreadID = 0;
    m_bThreadExit = true;
}

HSPSClassImpl::~HSPSClassImpl()
{
    if (m_hThreadID)
    {
        m_bThreadExit = true;
        Sleep(100);
    }
}

ErrorCodeEnum HSPSClassImpl::DevOpen()
{
    LOG4VTM_FUNCTION();
    GetCurLibsPath(m_sLibPath, NULL);
    char sTemp[400];
    if (HSPSCall == NULL)
    {
        sprintf(sTemp, "%s/cw/libCmbServConn.cw.so", m_sLibPath);
        void *hlib = dlopen(sTemp, RTLD_LAZY);        //load so
        if(hlib == NULL)
        {
            printf("dlopen - %sn", dlerror());
            return GetErrorInfo(ERR_NO_DEVICE, "DevOpen");
        }
        HSPSCall = (pHSPSCall)dlsym(hlib, "HSPSCall");
    }
    Sleep(200);
    if (m_hThreadID == 0)
    {
        m_bThreadExit = false;
        StartTimer();
    }

    int iRet = 0;
    if (HSPSCall("H 0 0", 0, iRet) < 0)
        return GetErrorInfo(ERR_NO_DEVICE, "DevOpen connect fail");
    if (iRet == ERR_DEVICE_CHG)//重插后摄像头编码变化，目前只能重新启动进程
    {
        LOG4VTM(INFO, "DevOpen camera need reconnected");
        system("killall CmbService.cw");
        Sleep(500);
        if (HSPSCall("H 0 2", 0, iRet) < 0)
            return GetErrorInfo(ERR_NO_DEVICE, "DevOpen camera reopen fail");
    }

    if (iRet == 0)
        m_bIsOpen = true;
    return GetErrorInfo(iRet, "DevOpen");
}

int getFileVer(char* sFile, short& ch1, short& ch2)
{
    ch1 = 0;
    ch2 = 0;
    char* pFind = strstr(sFile, ".so");
    char* pTemp = pFind;
    while (pTemp)
    {
        pFind = pTemp;
        pTemp = strstr(pFind + 3, ".so");
    }
    if (pFind == NULL) return 0;

    pTemp = pFind - 1;
    while(isdigit(*pTemp) && pTemp > sFile) pTemp--;
    if (*pTemp == '.')
        ch2 = atoi(pTemp+1);
    pTemp--;
    while(isdigit(*pTemp) && pTemp > sFile) pTemp--;
    if (*pTemp == '.')
        ch1 = atoi(pTemp+1);
    return 1;
}

ErrorCodeEnum HSPSClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG4VTM_FUNCTION();

    if (!m_bIsOpen)
        return GetErrorInfo(ERR_NOT_OPENED, "GetDevCategory");
    memset(&devCategory, 0, sizeof(devCategory));
    strcpy(devCategory.szModel , "FWID=00000000");
    strcpy(devCategory.szVendor , "cw");
    strcpy(devCategory.szType ,"PVER=LHT#MID=5M01");

    char sPath[256], sFile[128] = {0};
    GetCurLibsPath(sPath, sFile);
    short v1,v2;
    getFileVer(sFile, v1, v2);
    devCategory.version.wMajor = v1;
    devCategory.version.wMinor = v2;

    devCategory.version.wRevision = 0xffff;
    devCategory.version.wBuild = FILE_VERSION;

    int iRet = 0;
    if (HSPSCall("H 3 0", 0, iRet) == 0 && iRet >= 0)
        devCategory.eState = DEVICE_STATUS_NORMAL;
    else
        return GetErrorInfo(ERR_NOT_OPENED, "GetDevCategory");
//        devCategory.eState = DEVICE_STATUS_NOT_READY;
    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::Reset()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(ERR_NOT_OPENED, "Reset");
    int iRet = 0;
    return GetErrorInfo(iRet, "Reset");
}
ErrorCodeEnum HSPSClassImpl::DevClose()
{
    LOG4VTM_FUNCTION();

    int iRet = 0;
    HSPSCall("H 0 1", 0, iRet);

    Sleep(50);
    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    memcpy(&devErrInfo, &m_DevErrInfo, sizeof(DevErrorInfo));
    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(ERR_NOT_OPENED, "SetParam");
    char sCmd[64];
    sprintf(sCmd, "SetParam type=%d val=%d", type, value);
    LOG4VTM(INFO, sCmd);
    switch(type){
    case HSPS_MODEL_COLOR:
        sprintf(sCmd, "H 2 2 %d", (value == HSPS_COLOR_GREY));
        break;
    case HSPS_MODEL_ROTATE:
        sprintf(sCmd, "H 2 3 %d", value - HSPS_ROTATE_NOANGLE);
        break;
    case HSPS_MODEL_SCANSIZE:
        sprintf(sCmd, "H 2 4 %d", value - HSPS_SCAN_FULL);
        break;
    case HSPS_MODEL_VIEW:
        sprintf(sCmd, "H 2 1 %d", (value == HSPS_VIEW_SHOW));
    }

    int iRet = 0;
    if (HSPSCall(sCmd, 0, iRet) < 0)
        return GetErrorInfo(ERR_NOT_OPENED, "SetParam");

    return Error_Succeed;
}

//  更新20161117： nValue值为 1 时打开预览，确保当前打开预览过程执行结束且窗口处于显示状态才返回Error_Succeed,
//	nValue值为 0 时关闭预览并隐藏窗口
ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
{
    LOG4VTM_FUNCTION();
    Sleep(100);
    if (!m_bIsOpen)
        return GetErrorInfo(ERR_NOT_OPENED, "SetPreview not open");
    int iRet = 0;
    if (nValue == 1)
    {
        //预览，打开摄像头
        if (HSPSCall("H 2 0 1", 0, iRet) < 0)
            return GetErrorInfo(ERR_NOT_OPENED, "SetPreview connect fail");

        if (iRet == ERR_DEVICE_CHG)//重插后摄像头编码变化，目前只能重新启动进程
        {
            LOG4VTM(INFO, "SetPreview camera need reconnected");

            system("killall CmbService.cw");
            Sleep(400);
            if (HSPSCall("H 0 2", 0, iRet) < 0)
                return GetErrorInfo(ERR_NO_DEVICE, "SetPreview camera reopen fail");

            if (iRet != 0)
                return GetErrorInfo(ERR_NO_DEVICE, "SetPreview camera reopen %d", iRet);

            if (HSPSCall("H 2 0 2", 0, iRet) < 0)   //预览，恢复保存的参数
                return GetErrorInfo(ERR_NOT_OPENED, "SetPreview camera review fail");
        }

        if (iRet != 0)
            return GetErrorInfo(ERR_NOT_OPENED, "SetPreview opencam %d", iRet);

        //显示界面
        HSPSCall("H 2 1 1", 0, iRet);
//        Sleep(2000);
    }
    else
    {
        int iOK = HSPSCall("H 2 0 0", 0, iRet);
        HSPSCall("H 2 1 0", 0, iRet);
        if (iOK < 0)
            return GetErrorInfo(ERR_NOT_OPENED, "SetPreview openwin");
    }
    return GetErrorInfo(iRet, "SetPreview");
}

//		specifies that where the image will be located and what it would be named.
//	拍摄照片，传入的文件名已带绝对路径，无需再进行拼接处理
//
ErrorCodeEnum HSPSClassImpl::ScanImage(const char* pszFileName)
{
    LOG4VTM_FUNCTION();

    if (!m_bIsOpen)
        return GetErrorInfo(ERR_NOT_OPENED, "ScanImage");

    int iRet = 0;
    if (HSPSCall("H 3 2", 0, iRet) < 0 || iRet != 1)
        return GetErrorInfo(ERR_NOT_OPENED, "ScanImage");

    char sSend[300];
    strcpy(sSend, "H 4 ");
    strcat(sSend, pszFileName);
    HSPSCall(sSend, 0, iRet);
    return GetErrorInfo(iRet, "ScanImage");
}

//	Scan Image from device and return the image data in byte format.
//	-pBtImg[out] The buffer used to store the scanned image data.
//		存储图片字节流的缓冲区，大小为 nBtLen 字节
//	-nBtLen[in,out] Indicate the max byte-type size of pBtImg could be stored
//		and Store the real byte-type size of pBtImg had used when returned.
//		when detect value of nBtLen is 0 or smaller that necessary size, please
//		set nBtlen with real byte-type size and return Error_TooSmallBuffer.
//		如果nBtLen指定的字节数过小，那么对nBtLen赋值实际所需的大小并返回 Error_TooSmallBuffer，此操作仅允许一次
//	-pszFileName[in] Store the path and name where the image file should be located
//		while "" indicates that the image file shouldn't be stored at locate.
//		文件名长度为零表示不在本地生成图片文件
ErrorCodeEnum HSPSClassImpl::ScanImageEx(BYTE* pBtImg, int& nBtLen, const char* pszFileName)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOpen)
        return GetErrorInfo(ERR_NOT_OPENED, "ScanImage");

    int iRet = 0;
    if (HSPSCall("H 3 2", 0, iRet) < 0 || iRet != 1)
        return GetErrorInfo(ERR_NOT_OPENED, "ScanImage");

    char sSend[300];
    strcpy(sSend, "H 4 ");
    bool bFile = false;
    if (strlen(pszFileName))
    {
        strcpy(sSend + 4, pszFileName);
        bFile = true;
    }
    else
        sprintf(sSend + 4, "%s/hsps-temp.jpg", m_sLibPath);
    HSPSCall(sSend, 0, iRet);

    ErrorCodeEnum eRet = Error_Succeed;
    if (iRet != 0)
        return GetErrorInfo(iRet, "ScanImageEx");
    FILE* fp = fopen(sSend + 4, "rb");
    if (fp == NULL)
        return GetErrorInfo(Error_Param, "ScanImageEx");

    fseek(fp, 0, SEEK_END);
    int iLen = ftell(fp);
    if (pBtImg && iLen < nBtLen)
    {
        fseek(fp, 0, SEEK_SET);
        fread(pBtImg, 1, iLen, fp);
        nBtLen = iLen;
    }
    else
    {
        eRet = Error_TooSmallBuffer;
        nBtLen = iLen*1.2;//照片会动态变化，大概率出现下次拍照更大
    }
    fclose(fp);
    if (!bFile) remove(sSend + 4);
    return eRet;
}

//	传入预览窗口显示的坐标，左上角的横坐标nX，左上角的纵坐标nY，以及预览窗口的宽，宽与高的比例为 16:9
ErrorCodeEnum HSPSClassImpl::SetViewPos(int nX, int nY, int nWidth)
{
    LOG4VTM_FUNCTION();
    int iRet = 0;
    char sSend[32];
    sprintf(sSend, "H 1 %d %d %d %d", nX, nY, nWidth, nWidth*9/16);
    LOG4VTM(INFO, sSend);
    if (HSPSCall(sSend, 0, iRet) < 0)
        return GetErrorInfo(ERR_NOT_OPENED, "SetViewPos");

    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::GetDevStatus(HspsDevStatus& status)
{
    LOG4VTM_FUNCTION();
    int iRet = 0;
    if (HSPSCall("H 3 4", 0, iRet) < 0)
        return GetErrorInfo(ERR_NOT_OPENED, "ScanImage");

    status.isConnected = (iRet & 4) > 0;
    status.inPreview = (iRet & 2) > 0;
    status.inShow = (iRet & 1) == 0;
    return Error_Succeed;
}

/////////////////////////////////////////////////////////////////////////////

//  DEC_SUCCESS DEC_HARDWARE DEC_TIMEOUT DEC_INVALID_PARAMETER DEC_INVALID_MASTER_KEY
const static CmbErrorDef HSPSErrInfo[] = {
    {0,             "命令执行成功", Error_Succeed, DEC_SUCCESS},
    {ERR_NO_DEVICE, "未发现设备", Error_Hardware, DEC_DEV_NOT_FOUND},
    {ERR_NOT_OPENED, "设备尚未打开", Error_Param, DEC_DEV_NOT_OPENED},
    {ERR_OPEN_FAIL, "设备打开失败", Error_Hardware, DEC_HARDWARE},
    {ERR_VIEW_FAIL, "启动预览失败", Error_Hardware, DEC_HARDWARE},
};

ErrorCodeEnum HSPSClassImpl::GetErrorInfo(int iCode, char* sErr, ...)
{
    size_t iLenOne = sizeof(CmbErrorDef);
    size_t iLenAll = sizeof(HSPSErrInfo);
    int iCount = iLenAll / iLenOne;
    char sErrInfo[256]="";
    DWORD dSta = 0;
    int iErr = -1;
    for (int ia = 0; ia < iCount; ia++)
    {
        if (HSPSErrInfo[ia].iCode == iCode)
        {
            dSta = HSPSErrInfo[ia].iInf;
            strcpy(sErrInfo, HSPSErrInfo[ia].sInf);
            iErr = HSPSErrInfo[ia].iRet;
            break;
        }
    }

    char sErrAll[300];
    va_list arglist;
    va_start(arglist, sErr);
    _vsnprintf(sErrAll, 128, sErr, arglist);
    va_end(arglist);

    if (sErrInfo[0])
    {
        strcat(sErrAll, " ");
        strcat(sErrAll, sErrInfo);
    }
    sErrAll[200] = 0;
    iLenOne = strlen(sErrAll);
    sprintf(m_DevErrInfo.szErrMsg, "{\"ErrCode\":\"%04x\"，\"Description\":\"%s\"}", iErr, sErrAll);
//    strcpy(m_DevErrInfo.szErrMsg, sErrAll);
    m_DevErrInfo.dwErrMsgLen = ((dSta << 16) & 0xffff0000) + iLenOne;
    if (iErr != Error_Succeed)
        LOG4VTM(WARN, m_DevErrInfo.szErrMsg);
    else
        LOG4VTM(INFO, m_DevErrInfo.szErrMsg);
    return (ErrorCodeEnum)iErr;
}

void    HSPSClassImpl::ThreadRun()
{
    HspsState* pBuf = (HspsState*) m_ShereMem.GetShareMem();
    while (1)
    {
        Sleep(50);
        if (m_bThreadExit) break;
        Sleep(50);
        if (m_bThreadExit) break;
        pBuf->iTime = GetSystemTime();
    }
}

void	HSPSClassImpl::StartTimer()
{
    pthread_attr_t	attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
    pthread_create(&m_hThreadID, &attr, Proc, (void*) this);
    pthread_attr_destroy(&attr);
}

void*	HSPSClassImpl::Proc(void* inPara)
{
    HSPSClassImpl*	pCtrl = (HSPSClassImpl*)inPara;
    pCtrl->ThreadRun();
    pCtrl->CloseThread(pCtrl->m_hThreadID);
    return 0;
}

void HSPSClassImpl::CloseThread(pthread_t& h)
{
    pthread_exit(0);
    m_hThreadID = 0;
}