TnbCeUsbHid.h

[詳解]

#pragma once
#ifndef _WIN32_WCE
    #error TnbCeUsbHid.h is only supported on Windows CE platforms.
#endif // _WIN32_WCE
 
 
 
#include "TnbCommunication.h"
#include "TnbRegistryAccessor.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#ifndef CTL_CODE
 #define CTL_CODE( DeviceType, Function, Method, Access )                  \
    ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) )
#endif
 
#define IOCTL_USBHIDT_BASE 0xFC
 
#endif
 
 
 
class CCeUsbHid : public ICommunication, CCopyImpossible
{
    DEFSUPER(ICommunication);
public:
 
    struct TIoCtrlBlock_CheckDevice
    {
        enum 
        {
            CC = CTL_CODE(IOCTL_USBHIDT_BASE, 0x0F00, 0, 1/*Read*/), 
            SIGNATURE = 'ThiD'
        };
        DWORD   signature;              
        DWORD   version;                
        DWORD   outputReportLength;     
        DWORD   inputReportLength;      
    };
 
    struct TIoCtrlBlock_GetString
    {
        enum
        {
            CC = CTL_CODE(IOCTL_USBHIDT_BASE, 0x0F01, 0, 1/*Read*/) 
        };
        DWORD   type;                   
        DWORD   index;                  
        LPWSTR  lpStringData;           
        DWORD   stringDataBufferSize;   
        DWORD   gotStringDataSize;      
    };
 
    struct TIoCtrlBlock_Read
    {
        enum
        {
            CC = CTL_CODE(IOCTL_USBHIDT_BASE, 0x0F10, 0, 1/*Read*/) 
        };
        DWORD   mode;                   
        DWORD   timeout;                
        LPVOID  lpInputData;            
        DWORD   inputDataBufferSize;    
        DWORD   inputedDataSize;        
    };
 
    struct TIoCtrlBlock_Write
    {
        enum
        {
            CC = CTL_CODE(IOCTL_USBHIDT_BASE, 0x0F20, 0, 2/*Write*/) 
        };
        DWORD   mode;                   
        DWORD   timeout;                
        LPCVOID lpcOutputData;          
        DWORD   outputDataSize;         
    };
 
    enum EStringType
    {
        INDEXED = 0,    
        MANUFACTURER,   
        PRODUCT,        
        SERIALNUMBER,   
    };
 
 
    //------------------------------------
 
 
    explicit CCeUsbHid(void) 
        : m_handle(INVALID_HANDLE_VALUE), m_property(_T("HID"), TNBVIW_KIND_USB), m_recvTimeout(100), m_deviceIndex(1)
    {
    }
 
    virtual ~CCeUsbHid(void)
    {
        Close();
    }
 
    void SetDeviceIndex(int i)
    {
        m_deviceIndex = i;
    }
 
    virtual const TProperty& GetProperty(void) const
    {
        return m_property;
    }
 
    virtual bool Open(void)
    {
        Close();
        // デバイスのオープン
        CStr s;
        s.Format(_T("HID%d:"), m_deviceIndex);
        HANDLE h = ::CreateFile(s, GENERIC_READ | GENERIC_WRITE,0, NULL, OPEN_EXISTING, 0, NULL);
        if ( h == INVALID_HANDLE_VALUE )
        {
            if ( ::GetLastError() != ERROR_DEV_NOT_EXIST )
            {
                _GetLastError("CreateFile");
            }
            return false;
        }
        BOOL r = ::DeviceIoControl(h, m_info.CC, &m_info, sizeof(m_info), NULL, 0, NULL, NULL);
        if ( r == 1 && m_info.signature == m_info.SIGNATURE )
        {
            TRACE1("CeUsbHid.CheckDevice, 結果 = %d\n", r);
            TRACE1(" バージョン情報 = 0x%X\n", m_info.version);
            TRACE1(" OUTPUTサイズ = 0x%X\n", m_info.outputReportLength);
            TRACE1(" INPUTサイズ = 0x%X\n", m_info.inputReportLength);
            //
            m_handle = h;
            m_property.typeName = _T("HID");
            m_property.typeId = TNBVIW_KIND_USB + (reinterpret_cast<ULONG_PTR>(this) & 0xFFFF);
            m_property.receivePacketSize = m_info.inputReportLength;
            m_property.sendPacketSize = m_info.outputReportLength;
            return true;
        }
        return false;
    }
 
    virtual void Close(void)
    {
        //Portのクローズ
        if ( m_handle != INVALID_HANDLE_VALUE )
        {
            ::CloseHandle(m_handle);
            m_handle = INVALID_HANDLE_VALUE;
        }
    }
 
    virtual bool IsOpened(void) const
    {
        return m_handle != INVALID_HANDLE_VALUE; 
    }
 
    virtual bool IsConnect(void) const
    {
        return IsOpened();
    }
 
    virtual bool CanSend(void) const
    {
        return IsOpened() && (m_info.outputReportLength > 0);
    }
 
    virtual bool CanReceive(void) const
    {
        return IsOpened() && (m_info.inputReportLength > 0);
    }
 
    bool SetReceiveTimeout(DWORD to)
    {
        m_recvTimeout = to;
        return true;
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        if ( ! CanSend() )
        {
            return INVALID_SIZE;
        }
        TIoCtrlBlock_Write cb;
        cb.mode = 0;
        cb.timeout = 300;
        cb.outputDataSize = size;
        cb.lpcOutputData = P;
        BOOL r = ::DeviceIoControl(m_handle, cb.CC, &cb, sizeof(cb), NULL, 0, NULL, NULL);
        if ( ! r )
        {
            m_ConnectCheck();
        }
        return r ? size : INVALID_SIZE;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        if ( ! CanReceive() )
        {
            return INVALID_SIZE;
        }
        TIoCtrlBlock_Read cb;
        cb.mode = 0;
        cb.timeout = m_recvTimeout;
        cb.inputDataBufferSize = size;
        cb.lpInputData = _P;
        BOOL r = ::DeviceIoControl(m_handle, cb.CC, &cb, sizeof(cb), NULL, 0, NULL, NULL);
        if ( ! r )
        {
            m_ConnectCheck();
        }
        return r ? cb.inputedDataSize : INVALID_SIZE;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        return INVALID_SIZE;
    }
 
    virtual EState Check(void) const
    {
        return IsConnect() ? CONNECTING : CLOSED;
    }
 
    virtual void Purge(void) {}
 
    CStr GetString(EStringType type, INDEX index = 0) const
    {
        const int LEN = 1024;
        CStr s;
        TIoCtrlBlock_GetString cb;
        cb.type = type;
        cb.index = index;
        cb.lpStringData = s.GetBuffer(LEN);
        cb.stringDataBufferSize = LEN;
        BOOL r = ::DeviceIoControl(m_handle, cb.CC, &cb, sizeof(cb), NULL, 0, NULL, NULL);
        s.ReleaseBuffer();
        if ( ! r )
        {
            s.Empty();
        }
        return s;
    }
 
    const TIoCtrlBlock_CheckDevice& GetDeviceInfo(void) const
    {
        return m_info;
    }
 
    static bool RegistDriver(WORD vendorId = 0x20FC, WORD productId = 1, WORD usagePage = 0xFF00, WORD usageId = 1, LPCTSTR lpszDriverName = _T("USBHID_T.DLL"))
    {
        CStr s;
        //---
        s.Format(_T("\\Windows\\%s"), lpszDriverName);
        ::SetLastError(0);
        DWORD a = ::GetFileAttributes(s);
        if ( _GetLastError("GetFileAttributes") == ERROR_FILE_NOT_FOUND )
        {
            return false;
        }
        //---
        CRegistryAccessor reg(HKEY_LOCAL_MACHINE, _T("Drivers"));
        //
        s.Format(_T("USB\\LoadClients\\%d_%d\\Default\\3\\Hid_Class"), vendorId, productId);
        CRegistryAccessor::CSection sec = reg[s];
        sec.WriteString(_T("DLL"), lpszDriverName);
        //
        s.Format(_T("USB\\ClientDrivers\\Hid_t\\Hid_Class"));
        sec = reg[s];
        sec.WriteString(_T("DLL"), lpszDriverName);
        sec.WriteString(_T("Prefix"), _T("HID"));
        sec.WriteDword(_T("QueuedTransferCount"), 2);
        //
        s.Format(_T("USB\\ClientDrivers\\Hid_t\\Instance"));
        sec = reg[s];
        sec.WriteString(_T("DLL"), lpszDriverName);
        //
        s.Format(_T("HID\\LoadClients\\Default\\Default\\%d_%d\\PSL"), usagePage, usageId);
        sec = reg[s];
        sec.WriteString(_T("DLL"), lpszDriverName);
        return true;
    }
 
private:
    void m_ConnectCheck(void)
    {
        switch ( ::GetLastError() )
        {
        case 0x649:
        case ERROR_NOT_SUPPORTED:
            Close();
            break;
        default:
            break;
        }
    }
    int                         m_deviceIndex;  
    TIoCtrlBlock_CheckDevice    m_info;         
    HANDLE                      m_handle;       
    TProperty                   m_property;     
    DWORD                       m_recvTimeout;  
};
 
 
 
}; //TNB