Cancelling a LoadAsync operation after a timeout period and recalling LoadAsync afterwards throws exception

Question

I am working with SerialDevice on C++/winrt and need to listen for data coming over the port. I can successfully work with SerialDevice when data is streaming over the port but if nothing is read the DataReader.LoadAsync() function hangs even though I set timeouts through SerialDevice.ReadTimeout() and SerialDevice.WriteTimeout(). So to cancel the operation I am using IAsyncOperation's wait_for() operation which times out after a provided interval and I call IAsyncOperation's Cancel() and Close(). The problem is I can no longer make another call to DataReader.LoadAsync() without getting a take_ownership_from_abi exception. How can I properly cancel a DataReader.LoadAsync() call to allow subsequent calls to LoadAsync() on the same object?

To work around this, I tried setting the timeouts of SerialDevice but it didn't affect the DataRead.LoadAsync() calls. I also tried using create_task with a cancellation token which also didn't allow for an additional call to LoadAsync(). It took a lot of searching to find this article by Kenny Kerr: https://kennykerr.ca/2019/06/10/cppwinrt-async-timeouts-made-easy/ where he describes the use of the IAsyncOperation's wait_for function.

Here is the initialization of the SerialDevice and DataReader:

        DeviceInformation deviceInfo = devices.GetAt(0);
        m_serialDevice = SerialDevice::FromIdAsync(deviceInfo.Id()).get();
        m_serialDevice.BaudRate(nBaudRate);
        m_serialDevice.DataBits(8);
        m_serialDevice.StopBits(SerialStopBitCount::One);
        m_serialDevice.Parity(SerialParity::None);
        m_serialDevice.ReadTimeout(m_ts);
        m_serialDevice.WriteTimeout(m_ts);

        m_dataWriter = DataWriter(m_serialDevice.OutputStream());
        m_dataReader = DataReader(m_serialDevice.InputStream());

Here is the LoadAsync call:

    AsyncStatus iainfo;

        auto async = m_dataReader.LoadAsync(STREAM_SIZE);
    try {
        auto iainfo = async.wait_for(m_ts);
    }
    catch (...) {};

    if (iainfo != AsyncStatus::Completed)
    {
        async.Cancel();
        async.Close();
        return 0;
    }
    else
    {
        nBytesRead = async.get();
        async.Close();
    }

So in the case that the AsyncStatus is not Completed, the IAsyncOperation Cancel() and Close() are called which according to the documentation should cancel the Async call but now on subsequent LoadAsync calls I get a take_ownership_from_abi exception. Anyone have a clue what I'm doing wrong? Why do the SerialDevice timeouts not work in the first place? Is there a better way to cancel the Async call that would allow for further calls without re-initializing DataReader? Generally, it feels like there is very little activity in the C++/winrt space and the documentation is severely lacking (didn't even find the wait_for method until about a day of trying other stuff and randomly searching for clues through different posts) - is there something I'm missing or is this really the case? Thanks!

Answer 1

Cause: When the wait time is over, the async object is in the AsyncStatus::Started state. It means that the async object is still running.

Solution: When you use close() method, you could use Sleep(m_nTO) let asynchronous operation have enough time to close. Refer the following code.

if (iainfo != AsyncStatus::Completed)
{
    m_nReadCount++;
    //Sleep(m_nTO);
    async.Cancel();
    async.Close();
    Sleep(m_nTO);

    return 0;
}