WinBioWait-Funktion (winbio.h)

Blockiert die Ausführung des Aufrufers, bis alle ausstehenden biometrischen Vorgänge für eine Sitzung abgeschlossen oder abgebrochen wurden. Ab Windows 10, Build 1607, ist diese Funktion für die Verwendung mit einem mobilen Image verfügbar.

Syntax

HRESULT WinBioWait(
  [in] WINBIO_SESSION_HANDLE SessionHandle
);

Die Parameter

[in] SessionHandle

Ein WINBIO_SESSION_HANDLE Wert, der eine geöffnete biometrische Sitzung identifiziert. Öffnen Sie ein synchrones Sitzungshandle, indem Sie WinBioOpenSession aufrufen. Öffnen Sie ein asynchrones Sitzungshandle, indem Sie WinBioAsyncOpenSession aufrufen.

Rückgabewert

Wenn die Funktion erfolgreich ist, wird S_OK zurückgegeben. Wenn die Funktion fehlschlägt, wird ein HRESULT-Wert zurückgegeben, der den Fehler angibt. Mögliche Werte sind die Werte in der folgenden Tabelle, sind jedoch nicht beschränkt. Eine Liste allgemeiner Fehlercodes finden Sie unter "Allgemeine HRESULT-Werte".

Bemerkungen

WinBioWait blockiert den Thread des Aufrufers unabhängig davon, ob Sie ein synchrones oder asynchrones Sitzungshandle an den SessionHandle-Parameter übergeben.

Im Gegensatz zu allen anderen Funktionen, die mithilfe eines asynchronen Sitzungshandle aufgerufen werden können, erstellt das Framework keine WINBIO_ASYNC_RESULT Struktur für die WinBioWait-Funktion .

Rufen Sie WinBioWait nicht aus dem Kontext einer Rückrufroutine oder einer beliebigen Funktion auf, die indirekt von einer Rückrufroutine aufgerufen werden kann. Dies führt zu einem dauerhaften Deadlock.

Rufen Sie WinBioWait nicht aus einer Fensterprozedur auf. Dies bewirkt, dass die Benutzeroberfläche eingefroren wird, bis die Ereignisbenachrichtigung eintrifft.

Wenn Sie WinBioWait aus einer asynchronen Sitzung aufrufen, die Fensternachrichten generiert, gibt es keine Garantie für die Reihenfolge, in der die Fensternachricht und die "Wake-from-Wait"-Nachricht eingehen. Es wird empfohlen, keinen Code zu schreiben, der von der Reihenfolge dieser Ereignisse abhängt.

Examples

Das folgende Codebeispiel zeigt, wie die WinBioWait-Funktion aufgerufen wird, um die Ausführung zu blockieren und auf den Abschluss der Verarbeitung eines asynchronen Threads zu warten. Verknüpfen Sie die statische Winbio.lib-Bibliothek, und fügen Sie die folgenden Headerdateien ein:

• Windows.h
• Stdio.h
• Conio.h
• Winbio.h

HRESULT CaptureSampleWithCallback(BOOL bCancel)
{
    HRESULT hr = S_OK;
    WINBIO_SESSION_HANDLE sessionHandle = NULL;

    // Connect to the system pool. 
    hr = WinBioOpenSession( 
            WINBIO_TYPE_FINGERPRINT,    // Service provider
            WINBIO_POOL_SYSTEM,         // Pool type
            WINBIO_FLAG_RAW,            // Raw access
            NULL,                       // Array of biometric unit IDs
            0,                          // Count of biometric unit IDs
            WINBIO_DB_DEFAULT,          // Default database
            &sessionHandle              // [out] Session handle
            );
    if (FAILED(hr))
    {
        wprintf_s(L"\n WinBioOpenSession failed. hr = 0x%x\n", hr);
        goto e_Exit;
    }

    // Capture a biometric sample asynchronously.
    wprintf_s(L"\n Calling WinBioCaptureSampleWithCallback ");
    hr = WinBioCaptureSampleWithCallback(
            sessionHandle,                  // Open session handle
            WINBIO_NO_PURPOSE_AVAILABLE,    // Intended use of the sample
            WINBIO_DATA_FLAG_RAW,           // Sample format
            CaptureSampleCallback,          // Callback function
            NULL                            // Optional context
            );
    if (FAILED(hr))
    {
        wprintf_s(L"\n WinBioCaptureSampleWithCallback failed. ");
        wprintf_s(L"hr = 0x%x\n", hr);
        goto e_Exit;
    }
    wprintf_s(L"\n Swipe the sensor ...\n");

    // Cancel the identification if the bCancel flag is set.
    if (bCancel)
    {
        wprintf_s(L"\n Starting CANCEL timer...");
        Sleep( 7000 );

        wprintf_s(L"\n Calling WinBioCancel\n");
        hr = WinBioCancel( sessionHandle );
        if (FAILED(hr))
        {
            wprintf_s(L"\n WinBioCancel failed. hr = 0x%x\n", hr);
            goto e_Exit;
        }
    }

    // Wait for the asynchronous identification process to complete 
    // or be canceled.
    hr = WinBioWait( sessionHandle );
    if (FAILED(hr))
    {
        wprintf_s(L"\n WinBioWait failed. hr = 0x%x\n", hr);
    }

e_Exit:

    if (sessionHandle != NULL)
    {
        WinBioCloseSession(sessionHandle);
        sessionHandle = NULL;
    }

    wprintf_s(L"\n Press any key to exit...");
    _getch();

    return hr;
}

//------------------------------------------------------------------------
// The following function is the callback for WinBioCaptureSampleWithCallback.
// The function filters the response from the biometric subsystem and 
// writes a result to the console window.
//
VOID CALLBACK CaptureSampleCallback(
    __in_opt PVOID CaptureCallbackContext,
    __in HRESULT OperationStatus,
    __in WINBIO_UNIT_ID UnitId,
    __in_bcount(SampleSize) PWINBIO_BIR Sample,
    __in SIZE_T SampleSize,
    __in WINBIO_REJECT_DETAIL RejectDetail
    )
{
    UNREFERENCED_PARAMETER(CaptureCallbackContext);

    wprintf_s(L"\n CaptureSampleCallback executing");
    wprintf_s(L"\n Swipe processed - Unit ID: %d", UnitId);

    if (FAILED(OperationStatus))
    {
        if (OperationStatus == WINBIO_E_BAD_CAPTURE)
        {
            wprintf_s(L"\n Bad capture; reason: %d\n", RejectDetail);
         }
        else
        {
            wprintf_s(L"\n WinBioCaptureSampleWithCallback failed. ");
            wprintf_s(L" OperationStatus = 0x%x\n", OperationStatus);
        }
        goto e_Exit;
    }

    wprintf_s(L"\n Captured %d bytes.\n", SampleSize);

e_Exit:

    if (Sample != NULL)
    {
        WinBioFree(Sample);
        Sample = NULL;
    }
}

Anforderungen

Siehe auch

WinBioCaptureSampleWithCallback

WinBioEnrollCaptureWithCallback

WinBioIdentifyWithCallback

WinBioLocateSensorWithCallback

WinBioVerifyWithCallback