kdcardctl.cpp

磁卡读写器编程

/*********************************************************************
 *   Designed by xiaohuiyang 2002.03.15    E-mail: [e-mail]  * 
 *********************************************************************/
// KDCARDCtl.cpp : Implementation of the CKDCARDCtrl ActiveX Control class.

#include "stdafx.h"
#include "KDCARD.h"
#include "KDCARDCtl.h"
#include "KDCARDPpg.h"
#include "mywnd.h"
#include "comcat.h"
#include "objsafe.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define WM_THREADFIREEVENT WM_USER+102
#define WM_THREADTAKECARDEVENT WM_USER+103

LONG ThreadProc(LPVOID pParam);
LONG ThreadCheckProc(LPVOID pParam);
extern void TraceDebug(char *pchData, int len);

HRESULT CreateComponentCategory(CATID catid, WCHAR* catDescription)
{

    ICatRegister* pcr = NULL;
    HRESULT hr = S_OK;

    hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, 
			NULL, CLSCTX_INPROC_SERVER, IID_ICatRegister, (void**)&pcr);
	if(FAILED(hr))
		return hr;

    // Make sure the HKCR\Component Categories\{..catid...}
    // key is registered
    CATEGORYINFO catinfo;
    catinfo.catid = catid;
    catinfo.lcid = 0x0409; // english

	// Make sure the provided description is not too long.
	// Only copy the first 127 characters if it is
	int len = wcslen(catDescription);
	if(len > 127)
		len = 127;
    wcsncpy(catinfo.szDescription, catDescription, len);
	// Make sure the description is null terminated
	catinfo.szDescription[len] = '\0';

    hr = pcr->RegisterCategories(1, &catinfo);
	pcr->Release();

	return hr;
}

// Helper function to register a CLSID as belonging to a component category
HRESULT RegisterCLSIDInCategory(REFCLSID clsid, CATID catid)
{
// Register your component categories information.
    ICatRegister* pcr = NULL;
    HRESULT hr = S_OK;
    hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, 
			NULL, CLSCTX_INPROC_SERVER, IID_ICatRegister, (void**)&pcr);
    if(SUCCEEDED(hr))
    {
       // Register this category as being "implemented" by
       // the class.
       CATID rgcatid[1];
       rgcatid[0] = catid;
       hr = pcr->RegisterClassImplCategories(clsid, 1, rgcatid);
    }

    if(pcr != NULL)
        pcr->Release();
  
	return hr;
}

// Helper function to unregister a CLSID as belonging to a component category
HRESULT UnRegisterCLSIDInCategory(REFCLSID clsid, CATID catid)
{
    ICatRegister* pcr = NULL;
    HRESULT hr = S_OK;
    hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, 
			NULL, CLSCTX_INPROC_SERVER, IID_ICatRegister, (void**)&pcr);
    if(SUCCEEDED(hr))
    {
       // Unregister this category as being "implemented" by
       // the class.
       CATID rgcatid[1];
       rgcatid[0] = catid;
       hr = pcr->UnRegisterClassImplCategories(clsid, 1, rgcatid);
    }

    if(pcr != NULL)
	{
        pcr->Release();
	}
	return hr;
}



BSTR AsciiToBSTR(const char* pszFName) 
{ 
    WCHAR wszURL[MAX_PATH]; 
    ::MultiByteToWideChar(CP_ACP, 0, pszFName, -1, wszURL, MAX_PATH); 

    return SysAllocString(wszURL); 
} 

char * BSTRToAscii(BSTR bstr)
{ 
    char buf[MAX_PATH], *pStr; 

    ::WideCharToMultiByte(CP_ACP, 0, bstr, -1, buf, MAX_PATH, NULL, NULL); 
    pStr = new char[strlen(buf)+1]; 
    strcpy(pStr, buf); 
    return pStr; 
} 



IMPLEMENT_DYNCREATE(CKDCARDCtrl, COleControl)


/////////////////////////////////////////////////////////////////////////////
// Message map

BEGIN_MESSAGE_MAP(CKDCARDCtrl, COleControl)
	//{{AFX_MSG_MAP(CKDCARDCtrl)
	// NOTE - ClassWizard will add and remove message map entries
	//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_MSG_MAP
	ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// Dispatch map

BEGIN_DISPATCH_MAP(CKDCARDCtrl, COleControl)
	//{{AFX_DISPATCH_MAP(CKDCARDCtrl)
	DISP_PROPERTY_EX(CKDCARDCtrl, "DeviceStatus", GetDeviceStatus, SetDeviceStatus, VT_I2)
	DISP_PROPERTY_EX(CKDCARDCtrl, "ExtPortKD6006", GetExtPortKD6006, SetExtPortKD6006, VT_I2)
	DISP_PROPERTY_EX(CKDCARDCtrl, "ExtPortKDE", GetExtPortKDE, SetExtPortKDE, VT_I2)
	DISP_PROPERTY_EX(CKDCARDCtrl, "SerialPortKD6006", GetSerialPortKD6006, SetSerialPortKD6006, VT_I2)
	DISP_PROPERTY_EX(CKDCARDCtrl, "SerialPortKDE", GetSerialPortKDE, SetSerialPortKDE, VT_I2)
	DISP_PROPERTY_EX(CKDCARDCtrl, "Track2", GetTrack2, SetTrack2, VT_BSTR)
	DISP_PROPERTY_EX(CKDCARDCtrl, "Track3", GetTrack3, SetTrack3, VT_BSTR)
	DISP_FUNCTION(CKDCARDCtrl, "CancelCheckCard", CancelCheckCard, VT_I2, VTS_NONE)
	DISP_FUNCTION(CKDCARDCtrl, "CheckCardAtGate", CheckCardAtGate, VT_I2, VTS_I2)
	DISP_FUNCTION(CKDCARDCtrl, "CloseDevice", CloseDevice, VT_I2, VTS_NONE)
	DISP_FUNCTION(CKDCARDCtrl, "EjectCardKDE", EjectCardKDE, VT_I2, VTS_NONE)
	DISP_FUNCTION(CKDCARDCtrl, "GetPortFromIni", GetPortFromIni, VT_I2, VTS_NONE)
	DISP_FUNCTION(CKDCARDCtrl, "SendICC", SendICC, VT_I2, VTS_BSTR VTS_BSTR VTS_BSTR)
	DISP_FUNCTION(CKDCARDCtrl, "TakeBackCard", TakeBackCard, VT_I2, VTS_NONE)
	DISP_FUNCTION(CKDCARDCtrl, "WaittingCard", WaittingCard, VT_I2, VTS_I2)
	DISP_FUNCTION(CKDCARDCtrl, "OpenKD6006Com", OpenKD6006Com, VT_I2, VTS_NONE)
	DISP_FUNCTION(CKDCARDCtrl, "OpenKDECom", OpenKDECom, VT_I2, VTS_NONE)
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()


/////////////////////////////////////////////////////////////////////////////
// Event map

BEGIN_EVENT_MAP(CKDCARDCtrl, COleControl)
	//{{AFX_EVENT_MAP(CKDCARDCtrl)
	EVENT_CUSTOM("CardDataComming", FireCardDataComming, VTS_I2)
	EVENT_CUSTOM("TakeCardComming", FireTakeCardComming, VTS_NONE)
	//}}AFX_EVENT_MAP
END_EVENT_MAP()


/////////////////////////////////////////////////////////////////////////////
// Property pages

// TODO: Add more property pages as needed.  Remember to increase the count!
BEGIN_PROPPAGEIDS(CKDCARDCtrl, 1)
	PROPPAGEID(CKDCARDPropPage::guid)
END_PROPPAGEIDS(CKDCARDCtrl)


/////////////////////////////////////////////////////////////////////////////
// Initialize class factory and guid

IMPLEMENT_OLECREATE_EX(CKDCARDCtrl, "KDCARD.KDCARDCtrl.1",
	0xc80b31a6, 0x34da, 0x11d6, 0x8b, 0x8b, 0, 0x10, 0x5c, 0xb2, 0x11, 0x4e)


/////////////////////////////////////////////////////////////////////////////
// Type library ID and version

IMPLEMENT_OLETYPELIB(CKDCARDCtrl, _tlid, _wVerMajor, _wVerMinor)


/////////////////////////////////////////////////////////////////////////////
// Interface IDs

const IID BASED_CODE IID_DKDCARD =
		{ 0x52bb5a19, 0xab7e, 0x4b49, { 0x85, 0x5b, 0x7a, 0x9b, 0x46, 0xa, 0x89, 0xeb } };
const IID BASED_CODE IID_DKDCARDEvents =
		{ 0x9a59eb4a, 0x8715, 0x4bbc, { 0xb6, 0xdb, 0x4, 0xd2, 0xad, 0x71, 0x3c, 0x10 } };


/////////////////////////////////////////////////////////////////////////////
// Control type information

static const DWORD BASED_CODE _dwKDCARDOleMisc =
	OLEMISC_ACTIVATEWHENVISIBLE |
	OLEMISC_SETCLIENTSITEFIRST |
	OLEMISC_INSIDEOUT |
	OLEMISC_CANTLINKINSIDE |
	OLEMISC_RECOMPOSEONRESIZE;

IMPLEMENT_OLECTLTYPE(CKDCARDCtrl, IDS_KDCARD, _dwKDCARDOleMisc)


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl::CKDCARDCtrlFactory::UpdateRegistry -
// Adds or removes system registry entries for CKDCARDCtrl

BOOL CKDCARDCtrl::CKDCARDCtrlFactory::UpdateRegistry(BOOL bRegister)
{
	// TODO: Verify that your control follows apartment-model threading rules.
	// Refer to MFC TechNote 64 for more information.
	// If your control does not conform to the apartment-model rules, then
	// you must modify the code below, changing the 6th parameter from
	// afxRegApartmentThreading to 0.

	if(bRegister)
		return AfxOleRegisterControlClass(
			AfxGetInstanceHandle(),
			m_clsid,
			m_lpszProgID,
			IDS_KDCARD,
			IDB_KDCARD,
			afxRegApartmentThreading,
			_dwKDCARDOleMisc,
			_tlid,
			_wVerMajor,
			_wVerMinor);
	else
		return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl::CKDCARDCtrl - Constructor

CKDCARDCtrl::CKDCARDCtrl()
{
	InitializeIIDs(&IID_DKDCARD, &IID_DKDCARDEvents);

	// TODO: Initialize your control's instance data here.
    pCom = new CDeviceInfo;
	if(pCom == NULL)
	{
		return;
	}
	threadHandle = NULL;
    threadCheck = NULL;
	mThreadRunning = 0;
    mThreadCheckRun = 0;
	mDeviceCloseing = 0;
	ICFlag = 0;
    FinishThreadFlag = 0;
	pWnd = new CMyWindow(this);
	if(NULL == pWnd)
	{
		delete pCom;
		pCom = NULL;
		return;
	}
	hWndMsg = pWnd->Create();
	hKillThread = NULL;
	hFinishThread = NULL;

	hKillThread = CreateEvent(NULL, FALSE, FALSE, NULL);
	hFinishThread = CreateEvent(NULL,FALSE,FALSE,NULL);
	if(NULL == hFinishThread || NULL == hKillThread)
	{
		delete pCom;
		pCom = NULL;

		delete pWnd;
		pWnd = NULL;
		return;
	}
}


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl::~CKDCARDCtrl - Destructor

CKDCARDCtrl::~CKDCARDCtrl()
{
	// TODO: Cleanup your control's instance data here.
	if(pWnd != NULL)
	{
		pWnd->Close();
		pWnd = NULL;
	}

	if(pCom != NULL)
	{
		delete pCom;
		pCom = NULL;
	}
	if(hKillThread != NULL)
	{
		CloseHandle(hKillThread);
		hKillThread = NULL;
	}

	if(hFinishThread != NULL)
	{
		CloseHandle(hFinishThread);
		hFinishThread = NULL;
	}
    
	if(threadHandle != NULL)
	{
	    CloseHandle(threadHandle);
	    threadHandle = NULL;
	}
}


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl::OnDraw - Drawing function

void CKDCARDCtrl::OnDraw(CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
	// TODO: Replace the following code with your own drawing code.
}


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl::DoPropExchange - Persistence support

void CKDCARDCtrl::DoPropExchange(CPropExchange* pPX)
{
	ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
	COleControl::DoPropExchange(pPX);

	// TODO: Call PX_ functions for each persistent custom property.
}


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl::OnResetState - Reset control to default state

void CKDCARDCtrl::OnResetState()
{
	COleControl::OnResetState();  // Resets defaults found in DoPropExchange

	// TODO: Reset any other control state here.
}


/////////////////////////////////////////////////////////////////////////////
// CKDCARDCtrl message handlers

DWORD CKDCARDCtrl::GetControlFlags() 
{
	DWORD dwFlags = COleControl::GetControlFlags();


	// The control can activate without creating a window.
	// TODO: when writing the control's message handlers, avoid using
	//		the m_hWnd member variable without first checking that its
	//		value is non-NULL.
	dwFlags |= windowlessActivate;	
	return dwFlags;
}

short CKDCARDCtrl::CancelCheckCard() 
{
	// TODO: Add your dispatch handler code here
	if(threadHandle != NULL)
	{
		Sleep(100);
	}

    if(threadCheck != NULL)
	{
		Sleep(100);
	}

	pCom->kde4787.EjectCard(1);

    mThreadCheckRun = 0;
	return 0;
}

short CKDCARDCtrl::CheckCardAtGate(short gTimeOut) 
{
	// TODO: Add your dispatch handler code here
	DWORD dwID;
	short ret;

	TimeOut = gTimeOut;
	if(mThreadCheckRun) 
		return 0;
	ret = pCom->kde4787.gOpenKDMCom();
	if(ret!=0)
	{
		return -1;
	}

	ret = pCom->kde4787.KDMStatusRequest();
	if(ret < _KDE_CARD_ATGATE) 
		return 0;

	threadCheck = CreateThread(NULL,NULL,
							   (LPTHREAD_START_ROUTINE)ThreadCheckProc,
							   (LPVOID)this,
							   NULL,
							   &dwID);

	if(!threadCheck) 
		return -1;
	mThreadCheckRun = 1;
	return 1;

}

short CKDCARDCtrl::CloseDevice()
{
	// TODO: Add your dispatch handler code here
	int ret;

	TraceDebug("关闭控件CloseDevice，开始...：", 0);            //可能会出现弹卡失败，从此退出程序，却没关串口
    if(mThreadRunning == 1)