twain2/CUSBHotPlugged.cpp

#include "stdafx.h"
#include "CUSBHotPlugged.h"

CUSBHotPlugged::CUSBHotPlugged()
{
	//usbHotPlugged=this;
	isconnected=true;
	tHandle=NULL;
	hWnd=NULL;
	initThread();
}

CUSBHotPlugged::~CUSBHotPlugged()
{
	if (tHandle!=NULL)
	{
			PostThreadMessage(iThread,THRD_MESSAGE_EXIT,0,0);
			WaitForSingleObject(tHandle,1000);
			CloseHandle(tHandle);
	}
	if (hWnd!=NULL&&IsWindow(hWnd))
	{
		//PostQuitMessage(0);
		//SendMessage(hWnd,WM_CLOSE,);
		BOOL ret= UnregisterClass(CLASS_NAME,GetModuleHandle(NULL));
		BOOL ret1=DestroyWindow(hWnd);
	    hWnd=NULL;
		int  aa=-1;
	}
}

bool CUSBHotPlugged::getIsConnected()
{
	return isconnected;
}

void CUSBHotPlugged::UpdateDevice(PDEV_BROADCAST_DEVICEINTERFACE pDevInf, WPARAM wParam)
{
	CString szDevId = pDevInf->dbcc_name + 4;
	int idx = szDevId.ReverseFind(_T('#'));
	szDevId.Truncate(idx);
	szDevId.Replace(_T('#'), _T('\\'));
	szDevId.MakeUpper();

	CString szClass;
	idx = szDevId.Find(_T('\\'));
	szClass = szDevId.Left(idx);

	CString szTmp;
	if (DBT_DEVICEARRIVAL == wParam) \
		szTmp.Format(_T("Adding %s\r\n"), szDevId.GetBuffer());
	else
		szTmp.Format(_T("Removing %s\r\n"), szDevId.GetBuffer());

	_tprintf(szTmp);
}

LRESULT CUSBHotPlugged::DeviceChange(UINT message, WPARAM wParam, LPARAM lParam)
{
	if (DBT_DEVICEARRIVAL == wParam || DBT_DEVICEREMOVECOMPLETE == wParam)
	{
		PDEV_BROADCAST_HDR pHdr = (PDEV_BROADCAST_HDR)lParam;
		PDEV_BROADCAST_DEVICEINTERFACE pDevInf;
		PDEV_BROADCAST_HANDLE pDevHnd;
		PDEV_BROADCAST_OEM pDevOem;
		PDEV_BROADCAST_PORT pDevPort;
		PDEV_BROADCAST_VOLUME pDevVolume;
		switch (pHdr->dbch_devicetype)
		{
		case DBT_DEVTYP_DEVICEINTERFACE:
			pDevInf = (PDEV_BROADCAST_DEVICEINTERFACE)pHdr;
			CUSBHotPlugged::UpdateDevice(pDevInf, wParam);
			break;

		case DBT_DEVTYP_HANDLE:
			pDevHnd = (PDEV_BROADCAST_HANDLE)pHdr;
			break;

		case DBT_DEVTYP_OEM:
			pDevOem = (PDEV_BROADCAST_OEM)pHdr;
			break;

		case DBT_DEVTYP_PORT:
			pDevPort = (PDEV_BROADCAST_PORT)pHdr;
			break;

		case DBT_DEVTYP_VOLUME:
			pDevVolume = (PDEV_BROADCAST_VOLUME)pHdr;
			break;
		}
	}
	return 0;
}

LRESULT CALLBACK CUSBHotPlugged::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_PAINT:
		break;
	case WM_SIZE:
		break;
	case WM_DEVICECHANGE:
		return DeviceChange(message, wParam, lParam);
	}

	return DefWindowProc(hWnd, message, wParam, lParam);
}

bool CUSBHotPlugged::CreateMessageOnlyWindow()
{
	hWnd = CreateWindowEx(0, CLASS_NAME, _T(""), WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
		NULL,       // Parent window    
		NULL,       // Menu
		GetModuleHandle(NULL),  // Instance handle
		NULL        // Additional application data
		);

	return hWnd != NULL;
}

void CUSBHotPlugged::RegisterDeviceNotify()
{
	HDEVNOTIFY hDevNotify;
	for (int i = 0; i < sizeof(GUID_DEVINTERFACE_LIST) / sizeof(GUID); i++)
	{
		DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;
		ZeroMemory(&NotificationFilter, sizeof(NotificationFilter));
		NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
		NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
		NotificationFilter.dbcc_classguid = GUID_DEVINTERFACE_LIST[i];
		hDevNotify = RegisterDeviceNotification(hWnd, &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE);
	}
}

DWORD  CUSBHotPlugged::ThrdFunc(LPVOID lpParam)
{

	if (0 ==MyRegisterClass())
		return -1;

	if (!CreateMessageOnlyWindow())
		return -1;

	RegisterDeviceNotify();

	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (msg.message == THRD_MESSAGE_EXIT)
		{
			//cout << "worker receive the exiting Message..." << endl;
			return 0;
		}

		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}

int CUSBHotPlugged::initThread()
{
	int ret=-1;
	if (tHandle==NULL)
	{
		tHandle=CreateThread(NULL, sizeof(CUSBHotPlugged),_usbhotPlugDetect, (LPVOID)this, 0L, &iThread);
		if (tHandle==NULL)
		{
			return ret;
		}
		ret=0;
	}
	return ret;
}

DWORD WINAPI CUSBHotPlugged::_usbhotPlugDetect(LPVOID lp_param)
{
	CUSBHotPlugged* This=(CUSBHotPlugged*) lp_param;
	return This->ThrdFunc(lp_param);
}

ATOM CUSBHotPlugged::MyRegisterClass()
{
	//CUSBHotPlugged* This=(CUSBHotPlugged*) lp_param;
	WNDCLASS wc = { 0 };
	wc.lpfnWndProc =WndProc;
	wc.hInstance = GetModuleHandle(NULL);
	wc.lpszClassName = CLASS_NAME;
	return RegisterClass(&wc);
}