如何克服阻塞的第三方功能

Question

I am using some 3rd party functions (hrmcom.dll) in my win32 application. I have a main windowclass with a winproc and 3 childwindows, all of a second windowclass that share one childproc. The call to the 3rd party functions is in one of the childwindows and handled in the childproc based on a WM_COMMAND (a button is pushed and the functions are called).

One of these functions is blocking. It makes connection to a IrDA device and it 'hangs' when the device is not present and in connect mode. I wanted to take care of this situation with a timeout of the call.

What I tried is to call SetTimer (call at the same window as from where the blocking function is) just before the blocking call and define a WM_TIMER handle. This is not working, debugging shows that the function hangs and the WM_TIMER event is never handled. I tried to call the timer for the main window, but that is also not working.

I saw a working example of this DLL in where one button is used for starting and cancelling the proces of connection to the device.

Question: How could I deal with the hanging function and time it out after X seconds when it is not connecting to the device? I have been reading about threads, but i was wondering if it really can only be done that complicated (I have not been able to get threads work so far).

Below is the header file part of the called function, if that helps:

__declspec (dllexport) BOOL CALLBACK fnHRMCom_StartIRCommunication  (int, LPTSTR);

//  Return value:
//  BOOL bStartOK
//   TRUE           - Starting of communication made succesfully
//   FALSE          - Problems encountered, check the following possible   errors:
//                      * Communication has already been started and it is running
//                      * Communication port already reserved for some other device
//                      * Maybe call was made from 16-bit program. A 32-bit DLL cannot
//                        create an additional thread when that DLL is being called by
//                        a 16-bit program.
//
///////////////////////////////////////////////////////////////////////////////

Latest code included: The thread function (simplified):

VOID Thread(PVOID pvoid)
{
volatile PPARAMS pparams;
pparams = (PPARAMS) pvoid;

if (pparams->bContinue)
{

    if (!fnHRMCom_ResetIRCommunication(0))
    {
        // Resetting IR connection was not successful
        ErrMsg(L"Resetting IR connection was not successful");
        return;
    }
    if (!fnHRMCom_StartIRCommunication(HRMCOM_PARAM_IRDA, L"IR"))
    {
        // IrDA couldn't be opened, stop connection thread
        fnHRMCom_EndIRCommunication(FALSE);
        ErrMsg(L"IrDA couldn't be opened, connection thread stopped");
        return;
    }
    //Status report "IR Communication started"
    SetWindowText(hwndCtrl[11], L"Status: IR Communication started");

    if (!fnHRMCom_ReadMonitorInfo(&psg, &psmi))
    {
        // Reading failed, close connection
        if (pparams->bContinue)
        {
            fnHRMCom_EndIRCommunication(FALSE);
            ErrMsg(L"Reading failed, connection closed01");
            SendMessage(hwndCtrl[8], LB_RESETCONTENT, 0, 0);
            return;
        }
        else
        {
            fnHRMCom_EndIRCommunication(FALSE);
            ErrMsg(L"Connection aborted, connection closed");
            SendMessage(hwndCtrl[8], LB_RESETCONTENT, 0, 0);
            return;
        }
    }

    }
    // End IR communication
    fnHRMCom_EndIRCommunication(FALSE);
}
_endthread();


}

Code for calling and cancelling the Thread manually:

case (ID_CTRL + 12) : 
        //Cancel connect to device
        params.bContinue = FALSE;           
        if (!fnHRMCom_EndIRCommunication(FALSE))
        {
            //TODO: Error
            return 0;
        }
        TerminateThread(hThread, 0);    
        return 0;       
    case (ID_CTRL + 7) : 
        //Load Activities from Device
        params.bContinue = TRUE;
        if (IDCANCEL != MessageBox(hwnd, L"Make sure your device is set to connectmode", L"Warning", MB_OKCANCEL | MB_ICONEXCLAMATION))
        {
            //Start downloading the activities in separate thread
            SetTimer(hwnd, IDT_TIMER1, 10000, NULL );
            hThread = (HANDLE)_beginthread(Thread, 0, &params);
        }
        //cancelled, dont start the IrDA connection thread      
        return 0;

And the code for the timer handler:

case WM_TIMER:
    if (LOWORD(wParam) == IDT_TIMER1)
    {
        if (!fnHRMCom_IsIrDAConnected())
        {
            SetWindowText(hwndCtrl[11], L"Status: IrDA connection timed out");
            TerminateThread(hThread, 0);
            fnHRMCom_EndIRCommunication(FALSE);
            KillTimer(hwnd, IDT_TIMER1);                
            ErrMsg(L"IrDA connection timed out");               
            return 0;
        }
        else KillTimer(hwnd, IDT_TIMER1);
    }
    return 0;

Answer 1

Put the blocking call into it's own thread.

Your threading function could be as simple as something like this:

volatile BOOL success;
volatile BOOL done;

void ConnectThread() {
    success = false;
    done = false;
    if (!fnHRMCom_StartIRCommunication(123, "Some Stuff")) {
        std::cerr << "There's been some IR problem." << std::endl;
        done = true;
        return;
    }
    success = true;
    done = true;
}

Then just do your timeout outside, waiting for some signal, in this example done to be set. If the timeout period is over without done being set, you know that it's taking too long (and you can kill the thread), otherwise you're able to read success to determine whether it worked.

Answer 2

You might also find it interesting about canceling pending i/o operations in Windows

http://msdn.microsoft.com/en-us/library/windows/desktop/aa363789(v=vs.85).aspx