myvtm/DevAdapter/simulator/idcer.1.1/idcer_impl.cpp

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "idcer_impl.h"
#include "idcer_httpans.h"
#include <cstring>
#include <cstdio>
#include "log4vendor.h"
#include <path.h>

typedef unsigned short UINT16;
typedef unsigned char UINT8;

//BMP图片生成功能
#define w 102 //图片宽度
#define h 126 //图片高度
bool WriteBMP(char* img, const char* filename)
{
    int l = (w * 3 + 3) / 4 * 4;
    int bmi[] = {
            l * h + 54,0,54,40,w,h,1 | 3 * 8 << 16,0,l * h,0,0,100,0 };
    FILE* fp = fopen(filename, "wb");

    if (!fp)
    {
        return false;
    }

    fprintf(fp, "BM");
    fwrite(&bmi, 52, 1, fp);
    fwrite(img, 1, l * h, fp);
    fclose(fp);

    return true;
}

bool GenerateBmpFile(string fileName)
{
    string path;
    path = GetCurrentDirectory();
    if (path.length() == 0)
        return  false;

    path = path + SPLIT_SLASH_STR + fileName;

    char img[w * h * 3];
    for (int i = 0; i < w * h * 3; i++)img[i] = rand() % 256;

    return WriteBMP(img, path.c_str());
}

#ifdef _MSC_VER
char* ConvertGBKToUtf8(const char* gbk, int* n)
{
    int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
    WCHAR* wszGBK = new WCHAR[len + 1];
    memset(wszGBK, 0, len * 2 + 2);
    MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);

    len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
    char* szUtf8 = new char[len + 1];
    memset(szUtf8, 0, len + 1);
    WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);

    delete[] wszGBK;
    *n = len - 1;
    return szUtf8;
}

void ConvertGBKToUtf8(std::string& str)
{
    int len = 0;
    char* dst = ConvertGBKToUtf8(str.c_str(), &len);

    str = dst;
    delete[] dst;
}
#endif // _MSC_VER

bool UTF8_to_UCS2(const UINT8* UINT8_code, UINT16* ucs2_code)
{
    UINT16 temp1, temp2;
    bool is_unrecognized = false;
    UINT8* in = (UINT8*)UINT8_code;

    if (!UINT8_code || !ucs2_code)
    {
        return is_unrecognized;
    }

    while (*in != 0)
    {
        //1字节 0xxxxxxx
        //0x80=1000,0000，判断最高位是否为0，如果为0，那么是ASCII字符
        //不需要处理，直接拷贝即可
        if (0x00 == (*in & 0x80))
        {
            /* 1 byte UTF-8 Charater.*/
            *ucs2_code = *in;
            is_unrecognized = true;
            in += 1;
        }
        //2字节 110xxxxx 10xxxxxx 
        //0xe0=1110,0000
        //0xc0=1100,0000
        else if (0xc0 == (*in & 0xe0) && 0x80 == (*(in + 1) & 0xc0))
        {
            /* 2 bytes UTF-8 Charater.*/
            //0x1f=0001,1111，获得第一个字节的后5位
            temp1 = (UINT16)(*in & 0x1f);

            //左移6位
            temp1 <<= 6;

            //0x3f=0011,1111，获得第二个字节的后6位
            //加上上面的5位一共有11位
            temp1 |= (UINT16)(*(in + 1) & 0x3f);

            *ucs2_code = temp1;

            is_unrecognized = true;

            in += 2;
        }
        //3字节 1110xxxx 10xxxxxx 10xxxxxx
        //中文要进入这一个分支
        else if (0xe0 == (*in & 0xf0) &&
            0x80 == (*(in + 1) & 0xc0) &&
            0x80 == (*(in + 2) & 0xc0)
            )
        {
            /* 3bytes UTF-8 Charater.*/
            //0x0f=0000,1111
            //取出第一个字节的低4位
            temp1 = (UINT16)(*in & 0x0f);
            temp1 <<= 12;

            //0x3f=0011,1111
            //取得第二个字节的低6位
            temp2 = (UINT16)(*(in + 1) & 0x3F);
            temp2 <<= 6;

            //取得第三个字节的低6位，最后组成16位
            temp1 = temp1 | temp2 | (UINT16)(*(in + 2) & 0x3F);
            *ucs2_code = temp1;

            //移动到下一个字符
            in += 3;
            is_unrecognized = true;
        }
        else
        {
            /* unrecognize byte. */
            *ucs2_code = 0x22e0;
            is_unrecognized = false;

            //直接退出循环
            break;
        }

        ucs2_code += 1;
    }

    return is_unrecognized;
}

ErrorCodeEnum IDCerClassImpl::ex2HttpFunction(IDCerInfoEx2& idCerInfoEx2)
{
    IDCerDevAns idCerRet;
    ErrorCodeEnum resFlag = SimulatorHttpFunction(EntityName, "IDCerGetDataEx2", idCerRet);

    if (resFlag == Error_Succeed) {
        if (idCerRet.name.data.length() <= 0)
        {
            return Error_Unexpect;
        }

#ifdef _MSC_VER
        ConvertGBKToUtf8(idCerRet.name.data);
        ConvertGBKToUtf8(idCerRet.sex.data);
        ConvertGBKToUtf8(idCerRet.nation.data);
        ConvertGBKToUtf8(idCerRet.birthday.data);
        ConvertGBKToUtf8(idCerRet.address.data);
        ConvertGBKToUtf8(idCerRet.idno.data);
        ConvertGBKToUtf8(idCerRet.department.data);
        ConvertGBKToUtf8(idCerRet.startDate.data);
        ConvertGBKToUtf8(idCerRet.endDate.data);
        ConvertGBKToUtf8(idCerRet.photoPath.data);
        ConvertGBKToUtf8(idCerRet.newAddress.data);
        ConvertGBKToUtf8(idCerRet.englishName.data);
        ConvertGBKToUtf8(idCerRet.nationality.data);
        ConvertGBKToUtf8(idCerRet.idVersion.data);
        ConvertGBKToUtf8(idCerRet.idType.data);
        ConvertGBKToUtf8(idCerRet.reserved.data);
        ConvertGBKToUtf8(idCerRet.txzCode.data);
        ConvertGBKToUtf8(idCerRet.issuedSN.data);
        ConvertGBKToUtf8(idCerRet.reserved2.data);
        ConvertGBKToUtf8(idCerRet.reserved3.data);
        ConvertGBKToUtf8(idCerRet.reserved4.data);
        ConvertGBKToUtf8(idCerRet.reserved5.data);
#endif // _MSC_VER

        char name[1024]; memset(name, 0, 1024);
        std::strcpy(name, idCerRet.name.data.c_str());
        UTF8_to_UCS2((UINT8*)name, (UINT16*)idCerInfoEx2.name.data);
        idCerInfoEx2.name.dwSize = strlen(idCerInfoEx2.name.data);

        char sex[1024]; memset(sex, 0, 1024);
        std::strcpy(sex, idCerRet.sex.data.c_str());
        UTF8_to_UCS2((UINT8*)sex, (UINT16*)idCerInfoEx2.sex.data);
        idCerInfoEx2.sex.dwSize = strlen(idCerInfoEx2.sex.data);

        char nation[1024]; memset(nation, 0, 1024);
        std::strcpy(nation, idCerRet.nation.data.c_str());
        UTF8_to_UCS2((UINT8*)nation, (UINT16*)idCerInfoEx2.nation.data);
        idCerInfoEx2.nation.dwSize = strlen(idCerInfoEx2.nation.data);

        char birthday[1024]; memset(birthday, 0, 1024);
        std::strcpy(birthday, idCerRet.birthday.data.c_str());
        UTF8_to_UCS2((UINT8*)birthday, (UINT16*)idCerInfoEx2.birthday.data);
        idCerInfoEx2.birthday.dwSize = strlen(idCerInfoEx2.birthday.data);

        char address[1024]; memset(address, 0, 1024);
        std::strcpy(address, idCerRet.address.data.c_str());
        UTF8_to_UCS2((UINT8*)address, (UINT16*)idCerInfoEx2.address.data);
        idCerInfoEx2.address.dwSize = strlen(idCerInfoEx2.address.data);

        char idno[1024]; memset(idno, 0, 1024);
        std::strcpy(idno, idCerRet.idno.data.c_str());
        UTF8_to_UCS2((UINT8*)idno, (UINT16*)idCerInfoEx2.idno.data);
        idCerInfoEx2.idno.dwSize = strlen(idCerInfoEx2.idno.data);

        char department[1024]; memset(department, 0, 1024);
        std::strcpy(department, idCerRet.department.data.c_str());
        UTF8_to_UCS2((UINT8*)department, (UINT16*)idCerInfoEx2.department.data);
        idCerInfoEx2.department.dwSize = strlen(idCerInfoEx2.department.data);

        char startDate[1024]; memset(startDate, 0, 1024);
        std::strcpy(startDate, idCerRet.startDate.data.c_str());
        UTF8_to_UCS2((UINT8*)startDate, (UINT16*)idCerInfoEx2.startDate.data);
        idCerInfoEx2.startDate.dwSize = strlen(idCerInfoEx2.startDate.data);

        char endDate[1024]; memset(endDate, 0, 1024);
        std::strcpy(endDate, idCerRet.endDate.data.c_str());
        UTF8_to_UCS2((UINT8*)endDate, (UINT16*)idCerInfoEx2.endDate.data);
        idCerInfoEx2.endDate.dwSize = strlen(idCerInfoEx2.endDate.data);

        char photoPath[1024]; memset(photoPath, 0, 1024);
        std::strcpy(photoPath, idCerRet.photoPath.data.c_str());
        UTF8_to_UCS2((UINT8*)photoPath, (UINT16*)idCerInfoEx2.photoPath.data);
        idCerInfoEx2.photoPath.dwSize = strlen(idCerInfoEx2.photoPath.data);

        char newAddress[1024]; memset(newAddress, 0, 1024);
        std::strcpy(newAddress, idCerRet.newAddress.data.c_str());
        UTF8_to_UCS2((UINT8*)newAddress, (UINT16*)idCerInfoEx2.newAddress.data);
        idCerInfoEx2.newAddress.dwSize = strlen(idCerInfoEx2.newAddress.data);

        char englishname[1024]; memset(englishname, 0, 1024);
        std::strcpy(englishname, idCerRet.englishName.data.c_str());
        UTF8_to_UCS2((UINT8*)englishname, (UINT16*)idCerInfoEx2.englishName.data);
        idCerInfoEx2.englishName.dwSize = strlen(idCerInfoEx2.englishName.data);

        char nationality[1024]; memset(nationality, 0, 1024);
        std::strcpy(nationality, idCerRet.nationality.data.c_str());
        UTF8_to_UCS2((UINT8*)nationality, (UINT16*)idCerInfoEx2.nationality.data);
        idCerInfoEx2.nationality.dwSize = strlen(idCerInfoEx2.nationality.data);

        char idVersion[1024]; memset(idVersion, 0, 1024);
        std::strcpy(idVersion, idCerRet.idVersion.data.c_str());
        UTF8_to_UCS2((UINT8*)idVersion, (UINT16*)idCerInfoEx2.idVersion.data);
        idCerInfoEx2.idVersion.dwSize = strlen(idCerInfoEx2.idVersion.data);

        char idType[1024]; memset(idType, 0, 1024);
        std::strcpy(idType, idCerRet.idType.data.c_str());
        UTF8_to_UCS2((UINT8*)idType, (UINT16*)idCerInfoEx2.idType.data);
        idCerInfoEx2.idType.dwSize = strlen(idCerInfoEx2.idType.data);

        char reserved[1024]; memset(reserved, 0, 1024);
        std::strcpy(reserved, idCerRet.reserved.data.c_str());
        UTF8_to_UCS2((UINT8*)reserved, (UINT16*)idCerInfoEx2.reserved.data);
        idCerInfoEx2.reserved.dwSize = strlen(idCerInfoEx2.reserved.data);

        char txzCode[1024]; memset(txzCode, 0, 1024);
        std::strcpy(txzCode, idCerRet.txzCode.data.c_str());
        UTF8_to_UCS2((UINT8*)txzCode, (UINT16*)idCerInfoEx2.txzCode.data);
        idCerInfoEx2.txzCode.dwSize = strlen(idCerInfoEx2.txzCode.data);

        char issuedSN[1024]; memset(issuedSN, 0, 1024);
        std::strcpy(issuedSN, idCerRet.issuedSN.data.c_str());
        UTF8_to_UCS2((UINT8*)issuedSN, (UINT16*)idCerInfoEx2.issuedSN.data);
        idCerInfoEx2.issuedSN.dwSize = strlen(idCerInfoEx2.issuedSN.data);

        char reserved2[1024]; memset(reserved2, 0, 1024);
        std::strcpy(reserved2, idCerRet.reserved2.data.c_str());
        UTF8_to_UCS2((UINT8*)reserved2, (UINT16*)idCerInfoEx2.reserved2.data);
        idCerInfoEx2.reserved2.dwSize = strlen(idCerInfoEx2.reserved2.data);

        char reserved3[1024]; memset(reserved3, 0, 1024);
        std::strcpy(reserved3, idCerRet.reserved3.data.c_str());
        UTF8_to_UCS2((UINT8*)reserved3, (UINT16*)idCerInfoEx2.reserved3.data);
        idCerInfoEx2.reserved3.dwSize = strlen(idCerInfoEx2.reserved3.data);

        char reserved4[1024]; memset(reserved4, 0, 1024);
        std::strcpy(reserved4, idCerRet.reserved4.data.c_str());
        UTF8_to_UCS2((UINT8*)reserved4, (UINT16*)idCerInfoEx2.reserved4.data);
        idCerInfoEx2.reserved4.dwSize = strlen(idCerInfoEx2.reserved4.data);

        char reserved5[1024]; memset(reserved5, 0, 1024);
        std::strcpy(reserved5, idCerRet.reserved5.data.c_str());
        UTF8_to_UCS2((UINT8*)reserved5, (UINT16*)idCerInfoEx2.reserved5.data);
        idCerInfoEx2.reserved5.dwSize = strlen(idCerInfoEx2.reserved5.data);
    }
    return resFlag;
}

IDCerClassImpl::IDCerClassImpl()
{

}

IDCerClassImpl::~IDCerClassImpl()
{

}

ErrorCodeEnum IDCerClassImpl::GetDevCategory(DevCategoryInfo& devCategory)
{

    ErrorCodeEnum err = Error_Succeed;
    SimulatorDevCategoryAns ans;

    err = SimulatorHttpFunction(EntityName, "GetDevCategory", ans);
    LOG4VTM(INFO, "GetDevCategory err = " << err);

    strcpy(devCategory.szType, ans.szType.c_str());
    strcpy(devCategory.szModel, ans.szModel.c_str());
    strcpy(devCategory.szVendor, ans.szVendor.c_str());
    devCategory.eState = (DevStateEnum)ans.eState;
    devCategory.version.wMajor = ans.version.wMajor;
    devCategory.version.wMinor = ans.version.wMinor;
    devCategory.version.wRevision = ans.version.wRevision;
    devCategory.version.wBuild = ans.version.wBuild;
    
    return err;
}

ErrorCodeEnum IDCerClassImpl::Reset()
{
    ErrorCodeEnum err = Error_Succeed;
    err = SimulatorHttpFunction(EntityName, "Reset");
    LOG4VTM(INFO, "Reset err = " << err);

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
{
    ErrorCodeEnum err = Error_Succeed;
    err = SimulatorHttpFunction(EntityName, "IDCerAuthenticate");
    LOG4VTM(INFO, "IDCerAuthenticate err = " << err);

    return err;
}

ErrorCodeEnum IDCerClassImpl::ForceIDEject()
{
    ErrorCodeEnum err = Error_Succeed;    
    err = SimulatorHttpFunction(EntityName, "ForceIDEject");
    LOG4VTM(INFO, "ForceIDEject err = " << err);

    return err;
}

ErrorCodeEnum IDCerClassImpl::ScanIDAndSaveImage()
{
    ErrorCodeEnum err = Error_NotImpl;
    err = SimulatorHttpFunction(EntityName, "ScanIDAndSaveImage");
    LOG4VTM(INFO, "ScanIDAndSaveImage err = " << err);

   /* if (err == Error_Succeed)
    {
        bool flag1 = GenerateBmpFile("idfront.bmp");
        bool flag2 = GenerateBmpFile("idback.bmp");
        if (!(flag1 & flag2))
        {
            err = Error_Bug;
        }
    }*/

    return err;
}

ErrorCodeEnum IDCerClassImpl::QueryCardPos(int& pos)
{
    ErrorCodeEnum err = Error_Succeed;
    QueryCardPosAns ans;

    err = SimulatorHttpFunction(EntityName, "QueryCardPos", ans);
    LOG4VTM(INFO, "QueryCardPos err = " << err);

    pos = ans.pos;

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerRFControl(bool bControl)
{
    ErrorCodeEnum err = Error_Succeed;
    err = SimulatorHttpFunction(EntityName, "IDCerRFControl");
    LOG4VTM(INFO, "IDCerRFControl err = " << err);

    return err;
}

ErrorCodeEnum IDCerClassImpl::DevOpen(DWORD dwPort)
{
    ErrorCodeEnum err = Error_Succeed;
    err = SimulatorHttpFunction(EntityName, "DevOpen");
    LOG4VTM(INFO, "DevOpen err = " << err);

    return err;
}

ErrorCodeEnum IDCerClassImpl::DevClose()
{
    ErrorCodeEnum err = Error_Succeed;
    err = SimulatorHttpFunction(EntityName, "DevClose");
    LOG4VTM(INFO, "DevClose err = " << err);
    
    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerGetData(IDCerInfo& idCerInfo)
{
    ErrorCodeEnum err = Error_Succeed;
    memset(&idCerInfo, 0, sizeof(IDCerInfo));

    strcpy(idCerInfo.startDate.data, "2009.03.25");
    idCerInfo.startDate.dwSize = strlen("2009.03.25");

    strcpy(idCerInfo.endDate.data, "2029.03.24");
    idCerInfo.endDate.dwSize = strlen("2029.03.24");

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx(IDCerInfoEx& idCerInfoEx)
{
    ErrorCodeEnum err = Error_Succeed;
    memset(&idCerInfoEx, 0, sizeof(IDCerInfo));

    strcpy(idCerInfoEx.startDate.data, "2009.03.25");
    idCerInfoEx.startDate.dwSize = strlen("2009.03.25");

    strcpy(idCerInfoEx.endDate.data, "2029.03.24");
    idCerInfoEx.endDate.dwSize = strlen("2029.03.24");

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx2(IDCerInfoEx2& idCerInfoEx2)
{
    ErrorCodeEnum err = Error_Succeed;
    memset(&idCerInfoEx2, 0, sizeof(IDCerInfoEx2));
    err = ex2HttpFunction(idCerInfoEx2);
    /*bool flag = GenerateBmpFile("zp.bmp");
    if (!flag)
    {
        err = Error_Bug;
    }*/

    LOG4VTM(INFO, "IDCerGetDataEx2 err = " << err);
    return err;
}


ErrorCodeEnum IDCerClassImpl::GetLastErr(DevErrorInfo& devErrInfo)
{
    ErrorCodeEnum err = Error_Succeed;
    SimulatorDevErrInfoAns ans;

    err = SimulatorHttpFunction(EntityName, "GetLastErr", ans);
    LOG4VTM(INFO, "GetLastErr err = " << err);

    devErrInfo.dwErrMsgLen = ans.dwErrMsgLen;
    strcpy(devErrInfo.szErrMsg, ans.szErrMsg.c_str());

    return err;
}

#ifdef _MSC_VER
BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
#endif // _MSC_VER

DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass*& pBaseObj)
{
    pBaseObj = new IDCerClassImpl();
    if (pBaseObj == NULL)
        return Error_Resource;

    cmb::log_init_config config;
    config.dev_name = "vendor_IDCertificate";
#ifdef _MSC_VER
    config.log_dir = ("D:\\rvc\\dbg\\");
#else
    config.log_dir = ("/opt/rvc/dbg/");
#endif 
    std::string str;
    cmb::log4vendor::init(config, str);

    std::string tmpStr = GetSimulatorUrl();
    LOG4VTM(INFO, "URL = " << tmpStr.c_str());

    return Error_Succeed;
}
DEVICEBASE_API ErrorCodeEnum ReleaseDevComponent(DeviceBaseClass*& pBaseObj)
{
    if (pBaseObj == NULL)
        return Error_Param;
    IDCerClassImpl* pTmp = (IDCerClassImpl*)(pBaseObj);
    delete pTmp;
    pTmp = NULL;
    pBaseObj = NULL;
    return Error_Succeed;
}

#ifdef NEWER_COMPILER_WORKAROUNDS

DEVICEBASE_API ErrorCodeEnum  GetDevAdapterVersion(DevSoftVersion& retVesion)
{
    retVesion.wMajor = retVesion.wMinor = retVesion.wBuild = retVesion.wRevision = 0;
    return Error_Succeed;
}

#endif // NEWER_COMPILER_WORKAROUNDS