windows-xp/Source/XPSP1/NT/printscan/wia/drivers/camera/ircamera/device.cpp

//------------------------------------------------------------------------------
// Copyright (c) 1999-2000  Microsoft Corporation.
//
//  device.cpp
//
//  Implement IrTran-P device methods.
//
//  Author:
//
//     EdwardR   12-Aug-1999   Modeled from code by ReedB.
//
//------------------------------------------------------------------------------

#include <windows.h>
#include <tchar.h>
#include <irthread.h>

#include "ircamera.h"
#include "resource.h"
#include "tcamprop.h"

// #include "/nt/private/windows/imagein/ui/uicommon/simstr.h"
// #include "/nt/private/windows/imagein/ui/inc/shellext.h"

extern HINSTANCE g_hInst;
extern DWORD EnableDisableIrCOMM( IN BOOL fDisable );  // irtranp\irtranp.cpp

DWORD  WINAPI EventMonitorThread( IN void *pvIrUsdDevice );  // Forward Ref.

#define SZ_REG_KEY_INFRARED    TEXT("Control Panel\\Infrared")
#define SZ_REG_KEY_IRTRANP     TEXT("Control Panel\\Infrared\\IrTranP")
#define SZ_REG_DISABLE_IRCOMM  TEXT("DisableIrCOMM")

HKEY  g_hRegistryKey = 0;

//--------------------------------------------------------------------------
// SignalWIA()
//
// Helper function used by the IrTran-P code to signal WIA that a new
// picture has arrived.
//
// Arguments:
//
//    pvIrUsdDevice  -- Device object. IrTran-P only knows this as a void*.
//
//--------------------------------------------------------------------------
DWORD SignalWIA( IN char *pszPathPlusFileName,
                 IN void *pvIrUsdDevice )
    {
    HRESULT hr;
    DWORD   dwStatus = 0;
    IrUsdDevice *pIrUsdDevice = (IrUsdDevice*)pvIrUsdDevice;


    //
    // First, add the new picture to the tree representing the images:
    //
    if (pIrUsdDevice && pIrUsdDevice->IsInitialized())
        {
        TCHAR *ptszPath;
        TCHAR *ptszFileName;

        #ifdef UNICODE

        int      iStatus;
        WCHAR    wszTemp[MAX_PATH];

        iStatus = MultiByteToWideChar( CP_ACP,
                                       0,
                                       pszPathPlusFileName,
                                       -1, // Auto-calculate length...
                                       wszTemp,
                                       MAX_PATH);

        ptszPath = wszTemp;
        ptszFileName = wcsrchr(wszTemp,L'\\');
        ptszFileName++;

        #else

        ptszPath = pszPathPlusFileName;
        ptszFileName = strrchr(pszPathPlusFileName,'\\');
        ptszFileName++;

        #endif

        IrUsdDevice *pIrUsdDevice = (IrUsdDevice*)pvIrUsdDevice;
        IWiaDrvItem *pNewImage;

        hr = pIrUsdDevice->CreateItemFromFileName(
                             WiaItemTypeFile | WiaItemTypeImage,
                             ptszPath,
                             ptszFileName,
                             &pNewImage);

        if (!FAILED(hr))
            {
            IWiaDrvItem *pDrvItemRoot = pIrUsdDevice->GetDrvItemRoot();

            hr = pNewImage->AddItemToFolder(pDrvItemRoot);

            pNewImage->Release();
            }
        else
            {
            WIAS_ERROR((g_hInst,"SignalWIA(): CreateItemFromFileName() Failed: %x",hr));
            }
        }

    //
    // Now, signal WIA:
    //
    if (pIrUsdDevice)
        {
        DWORD dwNewTime = GetTickCount();
        DWORD dwDelta = dwNewTime - pIrUsdDevice->m_dwLastConnectTime;

        if (dwDelta > RECONNECT_TIMEOUT)
            {
            pIrUsdDevice->m_guidLastEvent = WIA_EVENT_DEVICE_CONNECTED;
            if (!SetEvent(pIrUsdDevice->m_hSignalEvent))
                {
                dwStatus = GetLastError();
                WIAS_ERROR((g_hInst,"SignalWIA(): SetEvent() Failed: %d",dwStatus));
                }
            }
        else
            {
            pIrUsdDevice->m_guidLastEvent = WIA_EVENT_ITEM_CREATED;
            if (!SetEvent(pIrUsdDevice->m_hSignalEvent))
                {
                dwStatus = GetLastError();
                WIAS_ERROR((g_hInst,"SignalWIA(): SetEvent() Failed: %d",dwStatus));
                }
            }

        pIrUsdDevice->m_dwLastConnectTime = dwNewTime;
        }
    else
        {
        WIAS_ERROR((g_hInst,"SignalWIA(): null pvIrUsdDevice object"));
        return dwStatus;
        }

    //
    // Display IrCamera browser if it's not already up:
    //
#if FALSE
    HINSTANCE hInst = LoadLibrary(TEXT("WIASHEXT.DLL"));
    if (hInst)
        {
        WIAMAKEFULLPIDLFORDEVICE pfn =
              (WIAMAKEFULLPIDLFORDEVICE)GetProcAddress(hInst, "MakeFullPidlForDevice");

        if (pfn)
            {
            LPITEMIDLIST pidl = NULL;

            pfn( pIrUsdDevice->m_bstrDeviceID, &pidl );

            if (pidl)
                {
                SHELLEXECUTEINFO sei;

                memset( &sei, 0, sizeof(sei) );

                sei.cbSize      = sizeof(sei);
                // sei.hwnd        = hDlg;
                sei.fMask       = SEE_MASK_IDLIST;
                sei.nShow       = SW_SHOW;
                sei.lpIDList    = pidl;

                ShellExecuteEx( &sei );

                LPMALLOC pMalloc = NULL;
                if (SUCCEEDED(SHGetMalloc(&pMalloc)) && pMalloc)
                    {
                    pMalloc->Free(pidl);
                    pMalloc->Release();
                    }
                }
            }


        FreeLibrary( hInst );
        }
#endif

    return dwStatus;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::IrUsdDevice()
//
//   Device class constructor
//
// Arguments:
//
//    punkOuter
//
// Return Value:
//
//    None
//
//--------------------------------------------------------------------------
IrUsdDevice::IrUsdDevice( LPUNKNOWN punkOuter ):
                  m_cRef(1),
                  m_punkOuter(NULL),
                  m_dwLastConnectTime(0),
                  m_fValid(FALSE),
                  m_pIStiDevControl(NULL),
                  m_hShutdownEvent(INVALID_HANDLE_VALUE),
                  m_hRegistryEvent(INVALID_HANDLE_VALUE),
                  m_hSignalEvent(INVALID_HANDLE_VALUE),
                  m_hIrTranPThread(NULL),
                  m_hEventMonitorThread(NULL),
                  m_guidLastEvent(GUID_NULL),
                  m_pIWiaEventCallback(NULL),
                  m_pStiDevice(NULL),
                  m_bstrDeviceID(NULL),
                  m_bstrRootFullItemName(NULL),
                  m_pIDrvItemRoot(NULL)
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::IrUsdDevice"));

    //
    // See if we are aggregated. If we are (almost always the case) save
    // pointer to the controlling Unknown , so subsequent calls will be
    // delegated. If not, set the same pointer to "this".
    //

    if (punkOuter)
        {
        m_punkOuter = punkOuter;
        }
    else
        {
        //
        // Cast below is needed in order to point to right virtual table
        //
        m_punkOuter = reinterpret_cast<IUnknown*>
                      (static_cast<INonDelegatingUnknown*>
                      (this));
        }
    }

HRESULT IrUsdDevice::PrivateInitialize()
{
    HRESULT hr = S_OK;
    
    __try {
        if(!InitializeCriticalSectionAndSpinCount(&m_csShutdown, MINLONG))
        {
            hr = HRESULT_FROM_WIN32(::GetLastError());
            WIAS_ERROR((g_hInst,"IrUsdDevice::PrivateInitialize, create shutdown CritSect failed"));
        }
    }
    __except(EXCEPTION_EXECUTE_HANDLER) {
        hr = E_OUTOFMEMORY;
    }

    if(hr == S_OK) {

        //
        // Create event for syncronization of notifications shutdown.
        //
        m_hShutdownEvent =  CreateEvent(NULL,
                                        FALSE,
                                        FALSE,
                                        NULL);

        if (m_hShutdownEvent && (INVALID_HANDLE_VALUE != m_hShutdownEvent))
        {
            m_fValid = TRUE;
        }
        else
        {
            hr = HRESULT_FROM_WIN32(::GetLastError());
            WIAS_ERROR((g_hInst,"IrUsdDevice::PrivateInitialize, create shutdown event failed"));
        }
    }
    
    return hr;
}

                  

//------------------------------------------------------------------------
// IrUsdDevice::~IrUsdDevice
//
//   Device class destructor
//
// Arguments:
//
//    None
//
// Return Value:
//
//    None
//
//------------------------------------------------------------------------
IrUsdDevice::~IrUsdDevice(void)
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::~IrUsdDevice"));


    //
    // Kill notification thread if it exists.
    //

    SetNotificationHandle(NULL);

    //
    // Close event for syncronization of notifications shutdown.
    //

    if (m_hShutdownEvent && (m_hShutdownEvent != INVALID_HANDLE_VALUE))
        {
        CloseHandle(m_hShutdownEvent);
        }

    if (m_hRegistryEvent && (m_hRegistryEvent != INVALID_HANDLE_VALUE))
        {
        CloseHandle(m_hRegistryEvent);
        }

    //
    // Release the device control interface.
    //

    if (m_pIStiDevControl)
        {
        m_pIStiDevControl->Release();
        m_pIStiDevControl = NULL;
        }

    //
    // WIA member destruction
    //
    // Cleanup the WIA event sink.
    //

    if (m_pIWiaEventCallback)
        {
        m_pIWiaEventCallback->Release();
        }

    //
    // Free the storage for the device ID.
    //

    if (m_bstrDeviceID)
        {
        SysFreeString(m_bstrDeviceID);
        }

    //
    // Release the objects supporting device property storage.
    //

    if (m_bstrRootFullItemName)
        {
        SysFreeString(m_bstrRootFullItemName);
        }

    //
    // Free the critical section.
    //
    DeleteCriticalSection(&m_csShutdown);
    
    }

/**************************************************************************\
* IrUsdDevice::GetCapabilities
*
*   Get the device STI capabilities.
*
* Arguments:
*
*   pUsdCaps    - Pointer to USD capabilities data.
*
* Return Value:
*
*    Status.
*
* History:
*
*    9/11/1998 Original Version
*
\**************************************************************************/

STDMETHODIMP IrUsdDevice::GetCapabilities(PSTI_USD_CAPS pUsdCaps)
{
    ZeroMemory(pUsdCaps, sizeof(*pUsdCaps));

    pUsdCaps->dwVersion = STI_VERSION;

    //
    // We do support device notifications, but do not requiring polling.
    //

    pUsdCaps->dwGenericCaps = STI_USD_GENCAP_NATIVE_PUSHSUPPORT;

    return STI_OK;
}

//--------------------------------------------------------------------------
// IrUsdDevice::GetStatus()
//
//   Query device online and/or event status.
//
// Arguments:
//
//   pDevStatus  - Pointer to device status data.
//
// Return Value:
//
//    HRESULT - STI_OK
//              E_INVALIDARG
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::GetStatus( IN OUT PSTI_DEVICE_STATUS pDevStatus )
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::GetStatus()"));

    //
    // Validate parameters.
    //
    if (!pDevStatus)
        {
        WIAS_ERROR((g_hInst,"IrUsdDevice::GetStatus, NULL device status"));
        return E_INVALIDARG;
        }

    //
    // If we are asked, verify whether device is online.
    //
    pDevStatus->dwOnlineState = 0L;
    if (pDevStatus->StatusMask & STI_DEVSTATUS_ONLINE_STATE)
        {
        //
        // The IrTran-P device is always on-line:
        //
        pDevStatus->dwOnlineState |= STI_ONLINESTATE_OPERATIONAL;
        }

    //
    // If we are asked, verify state of event.
    //
    pDevStatus->dwEventHandlingState &= ~STI_EVENTHANDLING_PENDING;

    if (pDevStatus->StatusMask & STI_DEVSTATUS_EVENTS_STATE)
        {
        //
        // Generate an event the first time we load.
        //
        if (m_bUsdLoadEvent)
            {
            pDevStatus->dwEventHandlingState = STI_EVENTHANDLING_PENDING;

            m_guidLastEvent = guidEventFirstLoaded;

            m_bUsdLoadEvent = FALSE;
            }

        //
        // event pending ???
        //
        }

    return STI_OK;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::DeviceReset()
//
//   Reset data file pointer to start of file. For IrTran-P, we don't need
//   to do anything.
//
// Arguments:
//
//    None
//
// Return Value:
//
//    HRESULT - STI_OK
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::DeviceReset(void)
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::DeviceReset()"));

    return STI_OK;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::Diagnostic()
//
//   Run the camera through a test diagnostic. The IrTran-P device will
//   always pass the diagnostic.
//
// Arguments:
//
//    pBuffer    - Pointer o diagnostic results data.
//
// Return Value:
//
//    HRESULT - STI_OK
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::Diagnostic( IN OUT LPSTI_DIAG pBuffer )
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::Diagnostic()"));

    //
    // Initialize response buffer
    //
    pBuffer->dwStatusMask = 0;

    memset( &pBuffer->sErrorInfo, 0, sizeof(pBuffer->sErrorInfo) );

    pBuffer->sErrorInfo.dwGenericError = NOERROR;
    pBuffer->sErrorInfo.dwVendorError = 0;

    return STI_OK;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::StartIrTranPThread()
//
//--------------------------------------------------------------------------
DWORD IrUsdDevice::StartIrTranPThread()
    {
    DWORD   dwStatus = S_OK;
    DWORD   dwThread;

    if (!m_hIrTranPThread)
        {
        m_hIrTranPThread = CreateThread( NULL,       // Default security
                                         0,          // Default stack size
                                         IrTranP,    // IrTran-P protocol eng.
                                         (LPVOID)this,
                                         0,          // Creation flags
                                         &dwThread); // New thread ID.

        if (!m_hIrTranPThread)
            {
            dwStatus = ::GetLastError();
            WIAS_ERROR((g_hInst,"IrUsdDevice::SetNotificationHandle(): unable to create IrTran-P thread: %d",dwStatus));
            }
        }

    return dwStatus;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::StopIrTranPThread()
//
//--------------------------------------------------------------------------
DWORD IrUsdDevice::StopIrTranPThread()
    {
    DWORD   dwStatus;

    //
    // Shutdown the listen on IrCOMM, this will cause the IrTran-P thread
    // to exit.
    //
    dwStatus = EnableDisableIrCOMM(TRUE);  // TRUE == Disable.

    m_hIrTranPThread = NULL;

    return dwStatus;
    }
//--------------------------------------------------------------------------
// IrUsdDevice::StartEventMonitorThread()
//
//--------------------------------------------------------------------------
DWORD IrUsdDevice::StartEventMonitorThread()
    {
    DWORD   dwStatus = S_OK;
    DWORD   dwThread;

    //
    //  Event to signal for registry changes:
    //
    if ((!m_hRegistryEvent)||(m_hRegistryEvent == INVALID_HANDLE_VALUE))
        {
        m_hRegistryEvent = CreateEvent( NULL,    // Security
                                        FALSE,   // Auto-reset
                                        FALSE,   // Initially not set
                                        NULL );  // No name
        }

    if (!m_hRegistryEvent)
        {
        dwStatus = ::GetLastError();

        WIAS_ERROR((g_hInst,"IrUsdDevice::StartEventMonitorThread(): unable to create Registry Monitor Event: %d",dwStatus));

        return dwStatus;
        }

    //
    //  Start monitoring the registry to look for enable/disable changes
    //  for access to the IrCOMM port.
    //
    if (!m_hEventMonitorThread)
        {
        m_hEventMonitorThread = CreateThread(
                                        NULL,        // Default security
                                        0,           // Default stack size
                                        EventMonitorThread,
                                        (LPVOID)this,// Function data
                                        0,           // Creation flags
                                        &dwThread ); // New thread ID
        if (!m_hEventMonitorThread)
            {
            dwStatus = ::GetLastError();
            WIAS_ERROR((g_hInst,"IrUsdDevice::StartEventMonitorThread(): unable to create Registry Monitor Thread: %d",dwStatus));
            }
        }

    return dwStatus;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::SetNotificationHandle()
//
//   Starts and stops the event notification thread.
//
// Arguments:
//
//    hEvent -   Event to use in signaling WIA of events (like CONNECT etc.)
//               If valid start the notification thread otherwise kill the
//               notification thread.
//
// Return Value:
//
//    HRESULT  - STI_OK
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::SetNotificationHandle( IN HANDLE hEvent )
    {
    DWORD   dwStatus;
    HRESULT hr = STI_OK;

    WIAS_TRACE((g_hInst,"IrUsdDevice::SetNotificationHandle"));


    EnterCriticalSection(&m_csShutdown);

    //
    // Are we starting or stopping the notification thread?
    //
    if (hEvent && (hEvent != INVALID_HANDLE_VALUE))
        {
        m_hSignalEvent = hEvent;

        //
        // Initialize to no event.
        //
        m_guidLastEvent = GUID_NULL;

#if FALSE
        //
        // Create the notification thread.
        //
        if (!m_hIrTranPThread)
            {
            DWORD   dwThread;

            m_hIrTranPThread = CreateThread(
                                         NULL,       // Default security
                                         0,          // Default stack size
                                         IrTranP,    // IrTran-P protocol eng.
                                         (LPVOID)this,
                                         0,          // Creation flags
                                         &dwThread); // New thread ID.

            if (m_hIrTranPThread)
                {
                WIAS_TRACE((g_hInst,"IrUsdDevice::SetNotificationHandle(): Enabling IrTran-P"));
                }
            else
                {
                dwStatus = ::GetLastError();
                WIAS_ERROR((g_hInst,"IrUsdDevice::SetNotificationHandle(): unable to create IrTran-P thread: %d",dwStatus));
                hr = HRESULT_FROM_WIN32(dwStatus);
                }
            }
        else
            {
            WIAS_ERROR((g_hInst,"IrUsdDevice::SetNotificationHandle(): spurious IrTran-P thread"));
            hr = STI_OK;   // STIERR_UNSUPPORTED;
            }
#endif

        dwStatus = StartEventMonitorThread();

        if (dwStatus)
            {
            hr = HRESULT_FROM_WIN32(dwStatus);
            }
        }
    else
        {
        //
        // Disable event notifications.
        //
        SetEvent(m_hShutdownEvent);

        if (m_hIrTranPThread)
            {
            WIAS_TRACE((g_hInst,"IrUsdDevice::SetNotificationHandle(): stopping IrTran-P thread"));
            UninitializeIrTranP(m_hIrTranPThread);
            }
        }

    LeaveCriticalSection(&m_csShutdown);

    return hr;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::GetNotificationData()
//
//   WIA calls this function to get data on the event. Currently for IrTran-P,
//   we get one of two events either WIA_EVENT_DEVICE_CONNECTED or
//   WIA_EVENT_ITEM_CREATED.
//
// Arguments:
//
//    pStiNotify - Pointer to event data.
//
// Return Value:
//
//    HRESULT  - STI_OK
//               STIERR_NOEVENT (not currently returned).
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::GetNotificationData( IN OUT LPSTINOTIFY pStiNotify )
    {
    DWORD  dwStatus;

    WIAS_TRACE((g_hInst,"IrUsdDevice::GetNotificationData()"));

    memset(pStiNotify,0,sizeof(STINOTIFY));

    pStiNotify->dwSize = sizeof(STINOTIFY);

    pStiNotify->guidNotificationCode =  m_guidLastEvent;

    //
    // If we are to return a device connected then follow it by an item
    // created event.
    //
    if (IsEqualGUID(m_guidLastEvent,WIA_EVENT_DEVICE_CONNECTED))
        {
        m_guidLastEvent = WIA_EVENT_ITEM_CREATED;
        if (!SetEvent(m_hSignalEvent))
            {
            dwStatus = ::GetLastError();
            WIAS_ERROR((g_hInst,"SignalWIA(): SetEvent() Failed: %d",dwStatus));
            }
        }

    return STI_OK;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::Escape()
//
//   Used to issue a command to the device. IrTran-P doesn't support this.
//
// Arguments:
//
//    EscapeFunction - Command to be issued.
//    pInData        - Input data to be passed with command.
//    cbInDataSize   - Size of input data.
//    pOutData       - Output data to be passed back from command.
//    cbOutDataSize  - Size of output data buffer.
//    pcbActualData  - Size of output data actually written.
//
// Return Value:
//
//    HRESULT - STI_OK
//              STIERR_UNSUPPORTED
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::Escape(
                            STI_RAW_CONTROL_CODE EscapeFunction,
                            LPVOID               pInData,
                            DWORD                cbInDataSize,
                            LPVOID               pOutData,
                            DWORD                cbOutDataSize,
                            LPDWORD              pcbActualData )
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::Escape(): unsupported"));

    //
    // Write command to device if needed.
    //

    return STIERR_UNSUPPORTED;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::GetLastError()
//
//   Get the last error from the device.
//
// Arguments:
//
//    pdwLastDeviceError - Pointer to last error data.
//
// Return Value:
//
//    HRESULT - STI_OK
//              STIERR_INVALID_PARAM
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::GetLastError( OUT LPDWORD pdwLastDeviceError )
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::GetLastError()"));

    if (IsBadWritePtr(pdwLastDeviceError, sizeof(DWORD)))
        {
        return STIERR_INVALID_PARAM;
        }

    *pdwLastDeviceError = m_dwLastOperationError;

    return STI_OK;
    }

/**************************************************************************\
* IrUsdDevice::GetLastErrorInfo
*
*   Get extended error information from the device.
*
* Arguments:
*
*    pLastErrorInfo - Pointer to extended device error data.
*
* Return Value:
*
*    Status.
*
* History:
*
*    9/11/1998 Original Version
*
\**************************************************************************/

STDMETHODIMP IrUsdDevice::GetLastErrorInfo(STI_ERROR_INFO *pLastErrorInfo)
{
    WIAS_TRACE((g_hInst,"IrUsdDevice::GetLastErrorInfo"));

    if (IsBadWritePtr(pLastErrorInfo, sizeof(STI_ERROR_INFO))) {
        return STIERR_INVALID_PARAM;
    }

    pLastErrorInfo->dwGenericError = m_dwLastOperationError;
    pLastErrorInfo->szExtendedErrorText[0] = '\0';

    return STI_OK;
}

/**************************************************************************\
* IrUsdDevice::LockDevice
*
*   Lock access to the device.
*
* Arguments:
*
*    None
*
* Return Value:
*
*    Status.
*
* History:
*
*    9/11/1998 Original Version
*
\**************************************************************************/

STDMETHODIMP IrUsdDevice::LockDevice(void)
    {
    return STI_OK;
    }

/**************************************************************************\
* IrUsdDevice::UnLockDevice
*
*   Unlock access to the device.
*
* Arguments:
*
*    None
*
* Return Value:
*
*    Status.
*
* History:
*
*    9/11/1998 Original Version
*
\**************************************************************************/

STDMETHODIMP IrUsdDevice::UnLockDevice(void)
{
    return STI_OK;
}

/**************************************************************************\
* IrUsdDevice::RawReadData
*
*   Read raw data from the device.
*
* Arguments:
*
*    lpBuffer           -
*    lpdwNumberOfBytes  -
*    lpOverlapped       -
*
* Return Value:
*
*    Status.
*
* History:
*
*    9/11/1998 Original Version
*
\**************************************************************************/

STDMETHODIMP IrUsdDevice::RawReadData(
    LPVOID          lpBuffer,
    LPDWORD         lpdwNumberOfBytes,
    LPOVERLAPPED    lpOverlapped)
{
    WIAS_TRACE((g_hInst,"IrUsdDevice::RawReadData"));

    return STI_OK;
}

/**************************************************************************\
* IrUsdDevice::RawWriteData
*
*   Write raw data to the device.
*
* Arguments:
*
*    lpBuffer           -
*    dwNumberOfBytes    -
*    lpOverlapped       -
*
* Return Value:
*
*    Status.
*
* History:
*
*    9/11/1998 Original Version
*
\**************************************************************************/

STDMETHODIMP IrUsdDevice::RawWriteData(
    LPVOID          lpBuffer,
    DWORD           dwNumberOfBytes,
    LPOVERLAPPED    lpOverlapped)
{
    WIAS_TRACE((g_hInst,"IrUsdDevice::RawWriteData"));

    return STI_OK;
}

//--------------------------------------------------------------------------
// IrUsdDevice::RawReadCommand()
//
//    Raw read of bytes directly from the camera. Not supported by IrTran-P
//    device.
//
// Arguments:
//
//    lpBuffer           -
//    lpdwNumberOfBytes  -
//    lpOverlapped       -
//
// Return Value:
//
//    HRESULT  - STIERR_UNSUPPORTED
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::RawReadCommand(
                             IN LPVOID          lpBuffer,
                             IN LPDWORD         lpdwNumberOfBytes,
                             IN LPOVERLAPPED    lpOverlapped)
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::RawReadCommand() not supported"));

    return STIERR_UNSUPPORTED;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::RawWriteCommand()
//
//    Raw write of byte directly to a camera. Not supported by IrTran-P device.
//
// Arguments:
//
//    lpBuffer       -
//    nNumberOfBytes -
//    lpOverlapped   -
//
// Return Value:
//
//    HRESULT  - STIERR_UNSUPPORTED
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::RawWriteCommand(
                             IN LPVOID          lpBuffer,
                             IN DWORD           nNumberOfBytes,
                             IN LPOVERLAPPED    lpOverlapped )
    {
    WIAS_TRACE((g_hInst,"IrUsdDevice::RawWriteCommand(): not supported"));

    return STIERR_UNSUPPORTED;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::Initialize()
//
//   Initialize the device object.
//
// Arguments:
//
//    pIStiDevControlNone    -
//    dwStiVersion           -
//    hParametersKey         -
//
// Return Value:
//
//    HRESULT  STI_OK
//             STIERR_INVALID_PARAM
//
//--------------------------------------------------------------------------
STDMETHODIMP IrUsdDevice::Initialize(
                               PSTIDEVICECONTROL pIStiDevControl,
                               DWORD             dwStiVersion,
                               HKEY              hParametersKey )
    {
    HRESULT  hr = STI_OK;
    UINT     uiNameLen = 0;
    CAMERA_STATUS   camStatus;

    WIAS_TRACE((g_hInst,"IrUsdDevice::Initialize"));

    if (!pIStiDevControl)
        {
        WIAS_ERROR((g_hInst,"IrUsdDevice::Initialize(): invalid device control interface"));
        return STIERR_INVALID_PARAM;
        }

    //
    // Cache the device control interface:
    //
    m_pIStiDevControl = pIStiDevControl;
    m_pIStiDevControl->AddRef();

    //
    // Try to open the camera only once here during Initialize:
    //
    hr = CamOpenCamera(&camStatus);

    return hr;
    }

//--------------------------------------------------------------------------
// IrUsdDevice::RunNotifications()
//
//   Monitor changes to the source data file parent directory.
//
// Arguments:
//
//    None
//
// Return Value:
//
//    None
//
//--------------------------------------------------------------------------
VOID IrUsdDevice::RunNotifications(void)
    {
    //
    // Start up camera event dlg
    //
    WIAS_TRACE((g_hInst,"IrUsdDevice::RunNotifications: start up event dlg"));

    HWND hWnd = GetDesktopWindow();

    int iret = DialogBoxParam( g_hInst,
                               MAKEINTRESOURCE(IDD_EVENT_DLG),
                               hWnd,
                               CameraEventDlgProc,
                               (LPARAM)this );

    WIAS_TRACE((g_hInst,"IrUsdDevice::RunNotifications, iret = 0x%lx",iret));

    if (iret == -1)
        {
        DWORD dwStatus = ::GetLastError();
        WIAS_TRACE((g_hInst,"IrUsdDevice::RunNotifications, dlg error = 0x%lx",dwStatus));
        }
    }

//--------------------------------------------------------------------------
// NotificationsThread()
//
//   Calls RunNotifications() to put up a dialog to start events.
//
// Arguments:
//
//    lpParameter    - Pointer to device object.
//
// Return Value:
//
//    None
//
//--------------------------------------------------------------------------
VOID NotificationsThread( LPVOID lpParameter )
    {
    WIAS_TRACE((g_hInst,"NotificationsThread(): Start"));

    IrUsdDevice *pThisDevice = (IrUsdDevice*)lpParameter;

    pThisDevice->RunNotifications();
    }


//--------------------------------------------------------------------------
//  OpenIrTranPKey()
//
//  Open and return a registry handle to the IrTranP key in the registry.
//  This key will be monitored for changes in value.
//--------------------------------------------------------------------------
DWORD OpenIrTranPKey( HKEY *phRegistryKey )
    {
    DWORD dwStatus = 0;
    DWORD dwDisposition = 0;
    HKEY  hKey;

    *phRegistryKey = 0;

    //
    // If we've been called before, then we don't need to reopen the key.
    //
    if (g_hRegistryKey)
        {
        *phRegistryKey = g_hRegistryKey;
        return 0;
        }

    if (RegCreateKeyEx(HKEY_CURRENT_USER,
                       SZ_REG_KEY_INFRARED,
                       0,              // reserved MBZ
                       0,              // class name
                       REG_OPTION_NON_VOLATILE,
                       KEY_ALL_ACCESS,
                       0,              // security attributes
                       &hKey,
                       &dwDisposition))
        {
        // Create failed.
        dwStatus = GetLastError();
        WIAS_TRACE((g_hInst,"OpenIrTranPKey(): RegCreateKeyEx(): '%' failed %d", SZ_REG_KEY_INFRARED, dwStatus));
        }

    if (RegCloseKey(hKey))
        {
        // Close failed.
        }

    if (RegCreateKeyEx(HKEY_CURRENT_USER,
                       SZ_REG_KEY_IRTRANP,
                       0,              // reserved, MBZ
                       0,              // class name
                       REG_OPTION_NON_VOLATILE,
                       KEY_ALL_ACCESS,
                       0,
                       &hKey,          // security attributes
                       &dwDisposition))
        {
        // Create failed
        dwStatus = GetLastError();
        WIAS_TRACE((g_hInst,"OpenIrTranPKey(): RegCreateKeyEx(): '%' failed %d", SZ_REG_KEY_IRTRANP, dwStatus));
        }

    *phRegistryKey = g_hRegistryKey = hKey;

    return dwStatus;
    }

//--------------------------------------------------------------------------
//  CheckForIrCOMMEnabled()
//
//  Check the registry to see if IrCOMM for IrTran-P is enabled, if it is
//  then return TRUE, else return FALSE.
//
//  Note: Don't close the key, it is maintained globally and will be closed
//  at shutdown.
//--------------------------------------------------------------------------
BOOL  CheckForIrCOMMEnabled( IN IrUsdDevice *pIrUsdDevice )
    {
    DWORD dwStatus;
    DWORD dwType;
    DWORD dwDisabled;
    DWORD dwValueSize = sizeof(dwDisabled);
    HKEY  hKey;

    dwStatus = OpenIrTranPKey(&hKey);
    if (dwStatus)
        {
        // If the key doesn't exist, or can't be opened, then assume that
        // we are enabled...
        return TRUE;
        }

    //
    // Check the value of the "DisableIrCOMM" value. Zero or missing value
    // means fEnabled == TRUE, non-zero value means fEnabled == FALSE.
    //
    if (RegQueryValueEx( hKey,         // IrTranP registry key
                         SZ_REG_DISABLE_IRCOMM,
                         NULL,         // reserved, MB NULL
                         &dwType,      // out, value type (expect: REG_DWORD)
                         (BYTE*)&dwDisabled, // out, value
                         &dwValueSize))      // in/out, size of value
        {
        // Query disabled flag registry value failed, assume enabled.
        return TRUE;
        }

    if ((dwType == REG_DWORD) && (dwDisabled))
        {
        // Disabled flag is set.
        return FALSE;
        }

    return TRUE;
    }

//--------------------------------------------------------------------------
//  EventMonitorThread()
//
//--------------------------------------------------------------------------
DWORD WINAPI EventMonitorThread( IN void *pvIrUsdDevice )
    {
    DWORD  dwStatus = 0;
    BOOL   fEnabled;
    HANDLE hHandles[2];
    HKEY   hRegistryKey;
    IrUsdDevice *pIrUsdDevice = (IrUsdDevice*)pvIrUsdDevice;

    //
    // Get the IrTranP registry key. We will monitor this key for
    // changes...
    //
    dwStatus = OpenIrTranPKey(&hRegistryKey);
    if (dwStatus)
        {
        return dwStatus;
        }

    //
    // We will Monitor two events. One for shutdown of the USD, the
    // other for registry state changes (to enable/disable listen on
    // IrCOMM).
    //
    hHandles[0] = pIrUsdDevice->m_hShutdownEvent;
    hHandles[1] = pIrUsdDevice->m_hRegistryEvent;

    while (TRUE)
        {
        fEnabled = CheckForIrCOMMEnabled(pIrUsdDevice);

        if ((fEnabled) && (!pIrUsdDevice->m_hIrTranPThread))
            {
            // Start IrTran-P listen/protocol thread.
            dwStatus = pIrUsdDevice->StartIrTranPThread();
            }
        else if (pIrUsdDevice->m_hIrTranPThread)
            {
            // Stop IrTran-P listen/protocol thread.
            dwStatus = pIrUsdDevice->StopIrTranPThread();
            }

        dwStatus = RegNotifyChangeKeyValue( hRegistryKey,  // IrTranP key
                                            FALSE,    // don't watch subtree
                                            REG_NOTIFY_CHANGE_LAST_SET,
                                            pIrUsdDevice->m_hRegistryEvent,
                                            TRUE );   // Asynchronous

        dwStatus = WaitForMultipleObjects( 2,
                                           hHandles,
                                           FALSE,
                                           INFINITE);
        if (dwStatus == WAIT_FAILED)
            {
            dwStatus = GetLastError();
            break;
            }

        if (dwStatus == WAIT_OBJECT_0)
            {
            // Received a shutdown event. If the IrTranP thread is running
            // then shut it down. Break out of this while loop to stop this
            // monitor thread.
            break;
            }

        if (dwStatus == WAIT_OBJECT_0+1)
            {
            // Received a registry change event. We'll continue around the
            // while loop and check to see if IrTranP over IrCOMM has been
            // disabled...
            continue;
            }

        else if (dwStatus == WAIT_ABANDONED_0)
            {
            // Wait abandonded on the shutdown event
            }
        else if (dwStatus == WAIT_ABANDONED_0+1)
            {
            // Wait abandonded on the registry change event
            }
        }

    return dwStatus;
    }