Compartir a través de


PWINBIO_IDENTIFY_CALLBACK función de devolución de llamada (winbio.h)

El marco biométrico de Windows llama a la función PWINBIO_IDENTIFY_CALLBACK para devolver resultados de la función asincrónica WinBioIdentifyWithCallback . La aplicación cliente debe implementar esta función.

Importante Te recomendamos que, a partir de Windows 8, ya no uses la combinación PWINBIO_IDENTIFY_CALLBACK/WinBioIdentifyWithCallback. En su lugar, haga lo siguiente:
  • Implemente una función de PWINBIO_ASYNC_COMPLETION_CALLBACK para recibir aviso cuando se complete la operación.
  • Llame a la función WinBioAsyncOpenSession . Pase la dirección de la devolución de llamada en el parámetro CallbackRoutine . Pase WINBIO_ASYNC_NOTIFY_CALLBACK en el parámetro NotificationMethod . Recupere un identificador de sesión asincrónico.
  • Use el identificador de sesión asincrónico para llamar a WinBioIdentify. Cuando finalice la operación, Windows Biometric Framework asignará e inicializará una estructura de WINBIO_ASYNC_RESULT con los resultados e invocará la devolución de llamada con un puntero a la estructura de resultados.
  • Llame a WinBioFree desde la implementación de devolución de llamada para liberar la estructura de WINBIO_ASYNC_RESULT una vez que haya terminado de usarlo.
 

Sintaxis

PWINBIO_IDENTIFY_CALLBACK PwinbioIdentifyCallback;

void PwinbioIdentifyCallback(
  [in, optional] PVOID IdentifyCallbackContext,
  [in]           HRESULT OperationStatus,
  [in]           WINBIO_UNIT_ID UnitId,
  [in]           WINBIO_IDENTITY *Identity,
  [in]           WINBIO_BIOMETRIC_SUBTYPE SubFactor,
  [in]           WINBIO_REJECT_DETAIL RejectDetail
)
{...}

Parámetros

[in, optional] IdentifyCallbackContext

Puntero a un búfer definido por la aplicación y pasado al parámetro IdentifyCallbackContext de la función WinBioIdentifyWithCallback . El marco o la unidad biométrica no modifican el búfer. La aplicación puede usar los datos para ayudar a determinar qué acciones realizar o mantener información adicional sobre la captura biométrica.

[in] OperationStatus

Código de error devuelto por la operación de captura.

[in] UnitId

Número de identificador de unidad biométrica.

[in] Identity

Estructura WINBIO_IDENTITY que recibe el GUID o el SID del usuario que proporciona la muestra biométrica.

[in] SubFactor

Valor de WINBIO_BIOMETRIC_SUBTYPE que recibe el subfactor asociado a la muestra biométrica. Para obtener información más detallada, consulte la sección Comentarios.

[in] RejectDetail

Información adicional sobre el error, si existe, para realizar la operación. Para obtener más información, vea la sección Comentarios.

Valor devuelto

None

Observaciones

Actualmente, Windows Biometric Framework solo admite lectores de huellas digitales. Por lo tanto, si se produce un error en una operación y devuelve información adicional en una constante WINBIO_REJECT_DETAIL , será uno de los siguientes valores:

  • WINBIO_FP_TOO_HIGH
  • WINBIO_FP_TOO_LOW
  • WINBIO_FP_TOO_LEFT
  • WINBIO_FP_TOO_RIGHT
  • WINBIO_FP_TOO_FAST
  • WINBIO_FP_TOO_SLOW
  • WINBIO_FP_POOR_QUALITY
  • WINBIO_FP_TOO_SKEWED
  • WINBIO_FP_TOO_SHORT
  • WINBIO_FP_MERGE_FAILURE

Ejemplos

En el ejemplo de código siguiente se llama a WinBioIdentifyWithCallback para identificar a un usuario de un examen biométrico. WinBioIdentifyWithCallback es una función asincrónica que configura el subsistema biométrico para procesar la entrada biométrica en otro subproceso. A continuación, la salida del subsistema biométrico se envía a una función de devolución de llamada personalizada denominada IdentifyCallback. Vincule a la biblioteca estática Winbio.lib e incluya los siguientes archivos de encabezado:

  • Windows.h
  • Stdio.h
  • Conio.h
  • Winbio.h
HRESULT IdentifyWithCallback(BOOL bCancel)
{
    // Declare variables.
    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_DEFAULT,        // Configuration and access 
            NULL,                       // Array of biometric unit IDs 
            0,                          // Count of biometric unit IDs 
            WINBIO_DB_DEFAULT,          // Database ID 
            &sessionHandle              // [out] Session handle
            );
    if (FAILED(hr))
    {
        wprintf_s(L"\n WinBioOpenSession failed. hr = 0x%x\n", hr);
        goto e_Exit;
    }

    // Call WinBioIdentifyWithCallback. The method is asynchronous
    // and returns immediately.
    wprintf_s(L"\n Calling WinBioIdentifyWithCallback");
    wprintf_s(L"\n Swipe the sensor ...\n");
    hr = WinBioIdentifyWithCallback( 
            sessionHandle,              // Open biometric session
            IdentifyCallback,           // Callback function
            NULL                        // Optional context
            );
    if (FAILED(hr))
    {
        wprintf_s(L"\n WinBioIdentifyWithCallback failed. hr = 0x%x\n", hr);
        goto e_Exit;
    }

    // Cancel user identification if the bCancel flag is set.
    if (bCancel)
    {
        wprintf_s(L"\n Starting CANCEL timer...\n");
        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)
    {
       wprintf_s(L"\n Closing the session.\n");

        hr = WinBioCloseSession(sessionHandle);
        if (FAILED(hr))
        {
            wprintf_s(L"\n WinBioCloseSession failed. hr = 0x%x\n", hr);
        }
        sessionHandle = NULL;
    }

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

    return hr;
}

//------------------------------------------------------------------------
// The following function is the callback for WinBioIdentifyWithCallback.
// The function filters the response from the biometric subsystem and 
// writes a result to the console window.
// 
VOID CALLBACK IdentifyCallback(
    __in_opt PVOID IdentifyCallbackContext,
    __in HRESULT OperationStatus,
    __in WINBIO_UNIT_ID UnitId,
    __in WINBIO_IDENTITY *Identity,
    __in WINBIO_BIOMETRIC_SUBTYPE SubFactor,
    __in WINBIO_REJECT_DETAIL RejectDetail
    )
{
    UNREFERENCED_PARAMETER(IdentifyCallbackContext);
    UNREFERENCED_PARAMETER(Identity);

    wprintf_s(L"\n IdentifyCallback executing");
    wprintf_s(L"\n Swipe processed for unit ID %d\n", UnitId);

    // The attempt to process the fingerprint failed.
    if (FAILED(OperationStatus))
    {
        if (OperationStatus == WINBIO_E_UNKNOWN_ID)
        {
            wprintf_s(L"\n Unknown identity.\n");
        }
        else if (OperationStatus == WINBIO_E_BAD_CAPTURE)
        {
            wprintf_s(L"\n Bad capture; reason: %d\n", RejectDetail);
        }
        else
        {
            wprintf_s(L"IdentifyCallback failed.");
            wprintf_s(L"OperationStatus = 0x%x\n", OperationStatus); 
        }
    }
    // Processing succeeded and the finger swiped is written
    // to the console window.
    else
    {
        wprintf_s(L"\n The following finger was used:");
        switch (SubFactor)
        {
            case WINBIO_SUBTYPE_NO_INFORMATION:
                wprintf_s(L"\n No information\n");
                break;
            case WINBIO_ANSI_381_POS_RH_THUMB:
                wprintf_s(L"\n RH thumb\n");
                break;
            case WINBIO_ANSI_381_POS_RH_INDEX_FINGER:
                wprintf_s(L"\n RH index finger\n");
                break;
            case WINBIO_ANSI_381_POS_RH_MIDDLE_FINGER:
                wprintf_s(L"\n RH middle finger\n");
                break;
            case WINBIO_ANSI_381_POS_RH_RING_FINGER:
                wprintf_s(L"\n RH ring finger\n");
                break;
            case WINBIO_ANSI_381_POS_RH_LITTLE_FINGER:
                wprintf_s(L"\n RH little finger\n");
                break;
            case WINBIO_ANSI_381_POS_LH_THUMB:
                wprintf_s(L"\n LH thumb\n");
                break;
            case WINBIO_ANSI_381_POS_LH_INDEX_FINGER:
                wprintf_s(L"\n LH index finger\n");
                break;
            case WINBIO_ANSI_381_POS_LH_MIDDLE_FINGER:
                wprintf_s(L"\n LH middle finger\n");
                break;
            case WINBIO_ANSI_381_POS_LH_RING_FINGER:
                wprintf_s(L"\n LH ring finger\n");
                break;
            case WINBIO_ANSI_381_POS_LH_LITTLE_FINGER:
                wprintf_s(L"\n LH little finger\n");
                break;
            case WINBIO_SUBTYPE_ANY:
                wprintf_s(L"\n Any finger\n");
                break;
            default:
                break;
        }
    }
}


Requisitos

Requisito Value
Cliente mínimo compatible Windows 7 [solo aplicaciones de escritorio]
Servidor mínimo compatible Windows Server 2008 R2 [solo aplicaciones de escritorio]
Plataforma de destino Windows
Encabezado winbio.h