TnbUsbHid.h

[詳解]

#pragma once
#include "TnbCommunication.h"
#include "TnbVector.h"
#include "TnbUsbHidPathName.h"
#include "TnbOverlapReader.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CUsbHid : public ICommunication, CUsbHidApi, CCopyImpossible
{
    DEFSUPER(ICommunication);
public:
 
    explicit CUsbHid(void) 
        : m_hUpPipe(INVALID_HANDLE_VALUE), m_hDownPipe(INVALID_HANDLE_VALUE), m_sendTimeout(0)
        , m_reportId(0), m_property(_T("HID"), TNBVIW_KIND_USB, 100)
    {
        ASSERT( m_property.receiveTimeout == 100 );
    }
 
    virtual ~CUsbHid(void)
    {
        Close();
    }
 
    virtual const TProperty& GetProperty(void) const
    {
        return m_property;
    }
 
    virtual bool Open(void)
    {
        Close();
        // デバイスのオープン
        DWORD x = (m_sendTimeout != 0) ? FILE_FLAG_OVERLAPPED : 0;
        HANDLE hDown = ::CreateFile(
                        m_hidName.GetPathName(), GENERIC_WRITE,
                        (FILE_SHARE_READ | FILE_SHARE_WRITE), NULL, OPEN_EXISTING, x, 0);
        if ( hDown == INVALID_HANDLE_VALUE )
        {
            _GetLastError("CreateFile");
            ::SetLastError(ERROR_NOT_FOUND);
            return false;
        }
        HANDLE hUp = ::CreateFile (
                        m_hidName.GetPathName(), (GENERIC_READ | GENERIC_WRITE),
                        (FILE_SHARE_READ | FILE_SHARE_WRITE), NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
        if ( hUp == INVALID_HANDLE_VALUE )
        {
            _GetLastError("CreateFile");
            // Read が出来なくても以下に続く。
        }
        m_hDownPipe = hDown;
        m_hUpPipe = hUp;
        //
        TRACE0( "CHid::Openしました\n" );
        m_property.typeName = CStr::Fmt(_T("HID-V%04X-P%04X"), m_hidName.GetVendorId(), m_hidName.GetProductId());  // タイプ名。
        m_property.typeId = TNBVIW_KIND_USB + (reinterpret_cast<ULONG_PTR>(this) & 0xFFFF);
        m_property.receivePacketSize = m_hidName.GetInputReportByteLength() - 1;
        m_property.sendPacketSize = m_hidName.GetOutputReportByteLength() - 1;
        m_reader.Attach(m_hUpPipe, m_property.receivePacketSize + 1);
        return true;
    }
 
    virtual void Close(void)
    {
        m_reader.Detach();
        //Portのクローズ
        if ( m_hUpPipe != INVALID_HANDLE_VALUE )
        {
            m_CloseHandle(m_hUpPipe);
            m_hUpPipe = INVALID_HANDLE_VALUE;
        }
        if ( m_hDownPipe != INVALID_HANDLE_VALUE )
        {
            m_CloseHandle(m_hDownPipe);
            m_hDownPipe = INVALID_HANDLE_VALUE;
        }
    }
 
    virtual bool IsOpened(void) const
    {
        return m_hDownPipe != INVALID_HANDLE_VALUE; 
    }
 
    virtual bool IsConnect(void) const
    {
        GetReceiveBufferCount();
        if ( ::GetLastError() == ERROR_DEVICE_NOT_CONNECTED )
        {
            return false;
        }
        return IsOpened();
    }
 
    virtual bool CanSend(void) const
    {
        return (m_hDownPipe != INVALID_HANDLE_VALUE) && (m_hidName.GetOutputReportByteLength() > 0);
    }
 
    virtual bool CanReceive(void) const
    {
        return (m_hUpPipe != INVALID_HANDLE_VALUE) && (m_hidName.GetInputReportByteLength() > 0);
    }
 
    void SetReportId(BYTE id)
    {
        m_reportId = id;
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        m_property.receiveTimeout = to;
        return true;
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        if ( ! CanSend() )
        {
            return INVALID_SIZE;
        }
        size_t sizeOutputReport = m_hidName.GetOutputReportByteLength();
        size_t sentTotalSize = 0;       // 送信済みデータサイズ合計
        size_t sendSize = 0;            // 送信データサイズ
        CWorkMem work(sizeOutputReport);
        work[0] = m_reportId;       // REPORT_ID
        const BYTE* lpbData = static_cast<const BYTE*>(P);
        //
        bool isSuccess = true;
        //
        while ( true )
        {
            if ( (size - sentTotalSize) < sizeOutputReport )
            {
                sendSize = size - sentTotalSize;
                memset(work, 0, sizeOutputReport);
            }
            else
            {
                sendSize = sizeOutputReport -1;
            }
            // 送信データ 先頭は必ずREPORT_ID値とする（0x00 固定）
            MemCopy(&work[1], &lpbData[sentTotalSize], sendSize);
            // データ送信(NG時はリトライする(10回まで))
            bool r = false;
            loop ( i, 10 )
            {
                DWORD dwWriteLen = 0;
                if ( m_Write(m_hDownPipe, work, ToDword(sizeOutputReport), &dwWriteLen) )
                {
                    if ( sizeOutputReport == dwWriteLen )
                    {
                        r = true; //成功
                        break;
                    }
                }
                if ( _GetLastError("WriteFile") == ERROR_DEVICE_NOT_CONNECTED )
                {
                    Close();
                    break;
                }
            }
            if ( ! r )
            {
                //送信失敗
                isSuccess = false;
                break;
            }
            sentTotalSize += sendSize;  // 送信済みサイズ
            if ( size <= sentTotalSize )
            {
                break;
            }
        }
        return isSuccess ? size : INVALID_SIZE;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        if ( ! CanReceive() )
        {
            return INVALID_SIZE;
        }
        size_t sizeInputReport = m_property.receivePacketSize; 
        CWorkMem work(sizeInputReport + 1);
        size_t r = m_reader.Read(work.Ref(), m_property.receiveTimeout);
        if ( r != INVALID_SIZE && r != 0 )
        {
            r--;
            if ( r > size )
            {
                r = size;
            }
            MemCopy(static_cast<BYTE*>(_P), work.Ref() + 1, r);
        }
        else
        {
            if ( ::GetLastError() == ERROR_DEVICE_NOT_CONNECTED )
            {
                Close();
            }
        }
        return r;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        return INVALID_SIZE;
    }
 
    virtual EState Check(void) const
    {
        return IsConnect() ? CONNECTING : CLOSED;
    }
 
    virtual void Purge(void) 
    {
        HidD_FlushQueue(m_hDownPipe);
    }
 
    DWORD SetHidPathName(const CUsbHidPathName& hidName)
    {
        if ( hidName.IsEmpty() )
        {
            return ERROR_NOT_FOUND;
        }
        return SetHidPathName(hidName.GetPathName());
    }
 
    DWORD SetHidPathName(LPCTSTR lpszPathName)
    {
        Close();
        return m_hidName.SetPathName(lpszPathName);
    }       
 
    void SetSendTimeout(DWORD to)
    {
        Close();
        m_sendTimeout = to;
    }
 
    bool SetOutputReport(size_t dataSize, LPCVOID lpcvData)
    {
        if ( m_hidName.GetOutputReportByteLength() == dataSize )
        {
            return !! HidD_SetOutputReport(m_hDownPipe, const_cast<LPVOID>(lpcvData), ToDword(dataSize));
        }
        return false;
    }
 
    CByteVector GetInputReport(void) const
    {
        CByteVector vb;
        size_t l = m_hidName.GetInputReportByteLength();
        if ( l > 0 )
        {
            BOOL r = !! HidD_GetInputReport(m_hUpPipe, vb.GetBuffer(l), ToDword(l));
            vb.ReleaseBuffer();
            if ( ! r )
            {
                vb.Invalid();
            }
        }
        return vb;
    }
 
    bool SetFeature(size_t dataSize, LPCVOID lpcvData)
    {
        if ( m_hidName.GetFeatureReportByteLength() == dataSize )
        {
            return !! HidD_SetFeature(m_hDownPipe, const_cast<LPVOID>(lpcvData), ToDword(dataSize));
        }
        return false;
    }
 
    CByteVector GetFeature(void) const
    {
        CByteVector vb;
        size_t l = m_hidName.GetFeatureReportByteLength();
        if ( l > 0 )
        {
            BOOL r = !! HidD_GetFeature(m_hDownPipe, vb.GetBuffer(l), ToDword(l));
            vb.ReleaseBuffer();
            if ( ! r )
            {
                vb.Invalid();
            }
        }
        return vb;
    }
 
    const CUsbHidPathName& GetName(void) const
    {
        return m_hidName;
    }
 
    size_t GetFeatureReportByteLength(void) const
    {
        return m_hidName.GetFeatureReportByteLength();
    }
 
    CStr GetManufacturerString(void) const
    {
        CUnicode s;
        bool r = !! HidD_GetManufacturerString(m_hDownPipe, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        return r ? CStr(s) : _T("");
    }
 
    CStr GetProductString(void) const
    {
        CUnicode s;
        bool r = !! HidD_GetProductString(m_hDownPipe, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        return r ? CStr(s) : _T("");
    }
 
    CStr GetSerialNumberString(void) const
    {
        CUnicode s;
        bool r = !! HidD_GetSerialNumberString(m_hDownPipe, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        return r ? CStr(s) : _T("");
    }
 
    CStr GetIndexedString(INDEX index) const
    {
        CUnicode s;
        bool r = !! HidD_GetIndexedString(m_hDownPipe, index, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        return r ? CStr(s) : _T("");
    }
 
    DWORD GetReceiveBufferCount(void) const
    {
        ULONG numberBuffers;
        BOOLEAN r = HidD_GetNumInputBuffers(m_hDownPipe, &numberBuffers);
        return r ? numberBuffers : 0;
    }
 
    bool SetReceiveBufferCount(DWORD c)
    {
        return !! HidD_SetNumInputBuffers(m_hDownPipe, c);
    }
 
private:
    bool m_CloseHandle(HANDLE h)
    {
        DWORD f;
        if ( ! ::GetHandleInformation(h, &f) )
        {
            _GetLastError("GetHandleInformation");
            return false;
        }
        return !! ::CloseHandle(h);
    }
    bool m_Write(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten)
    {
        if ( m_sendTimeout == 0 )
        {
            return !! ::WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, NULL);
        }
        OVERLAPPED overLapped;
        Zero(overLapped);
        HANDLE hEvent = ::CreateEvent(NULL, FALSE, TRUE, NULL); 
        ::ResetEvent(hEvent);
        overLapped.hEvent = hEvent;
        BOOL r = ::WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, &overLapped);
        if ( r )
        {
            // 成功
        }
        else if ( ::GetLastError() == ERROR_IO_PENDING )
        {
            // 非同期読み取り操作の結果をチェックする。
            ::Sleep(0);
            switch ( ::WaitForSingleObject(overLapped.hEvent, m_sendTimeout) )
            {
            case WAIT_OBJECT_0:
                r = ::GetOverlappedResult(hFile, &overLapped, lpNumberOfBytesWritten, FALSE);
                break;
            case WAIT_TIMEOUT:
            case WAIT_ABANDONED:
            case WAIT_FAILED:
            default:
                ::CancelIo(hFile);
                r = FALSE;
                break;
            }
        }
        ::CloseHandle(hEvent);
        return !! r;
    }
 
    HANDLE          m_hUpPipe;          
    HANDLE          m_hDownPipe;        
    CUsbHidPathName m_hidName;          
    TProperty       m_property;         
    BYTE            m_reportId;         
    COverlapReader  m_reader;           
    DWORD           m_sendTimeout;      
    friend class CUsbHidTest;
};
 
 
 
}; // TNB