Interface IMFSensorActivityMonitor (mfidl.h)

Fornece métodos para controlar um monitor de atividade do sensor.

Herança

A interface IMFSensorActivityMonitor herda da interface IUnknown . IMFSensorActivityMonitor também tem estes tipos de membros:

Métodos

A interface IMFSensorActivityMonitor tem esses métodos.

Comentários

Obtenha uma instância dessa classe chamando MFCreateSensorActivityMonitor. Os relatórios de atividade do sensor são entregues por meio da interface IMFSensorActivitiesReportCallback passada para esse método.

Exemplos

Os exemplos a seguir estão usando C++/WinRT para criar a classe de retorno de chamada COM e o WIL (Bibliotecas de Implementação do Windows).

O projeto de exemplo completo do Visual Studio pode ser encontrado no repositório GitHub windows-camera

O exemplo a seguir mostra uma declaração de classe que implementa IMFSensorActivitiesReportCallback.

class MyCameraNotificationCallback : public winrt::implements <MyCameraNotificationCallback, IMFSensorActivitiesReportCallback>
{
public:
    
    static HRESULT CreateInstance(_In_z_ LPCWSTR symbolicName, _COM_Outptr_ MyCameraNotificationCallback** value) noexcept;

    // IMFSensorActivitiesReportCallback
    IFACEMETHODIMP OnActivitiesReport(_In_ IMFSensorActivitiesReport* sensorActivitiesReport) override;

    bool IsInUse();

private:

    HRESULT Initialize(_In_z_ LPCWSTR symbolicName);

    WCHAR   _symbolicName[MAX_PATH] = {};
    bool    _inUse = false;
    wil::slim_event  _event;
};

O exemplo a seguir mostra a implementação do retorno de chamada OnActivitiesReport .

A função OnActivitiesReport atualiza um membro de classe booliana para indicar se o dispositivo de sensor consultado está atualmente em uso e, em seguida, define um evento para sinalizar que o status foi obtido.

Observe que o retorno de chamada pode ser chamado várias vezes e pode não conter relatórios, portanto, o evento só é definido quando os relatórios foram encontrados.

IFACEMETHODIMP MyCameraNotificationCallback::OnActivitiesReport(_In_ IMFSensorActivitiesReport* sensorActivitiesReport)
{
    bool inUse = false;
    wil::com_ptr_nothrow<IMFSensorActivityReport> sensorActivity;
    ULONG cProcCount = 0;

    printf("\nGetActivityReportByDeviceName [%ws] \n", _symbolicName);
    RETURN_IF_FAILED_WITH_EXPECTED(sensorActivitiesReport->GetActivityReportByDeviceName(_symbolicName, &sensorActivity),MF_E_NOT_FOUND);

    RETURN_IF_FAILED(sensorActivity->GetProcessCount(&cProcCount));
    for (ULONG i = 0; i < cProcCount; i++)
    {
        BOOL fStreaming = FALSE;
        wil::com_ptr_nothrow<IMFSensorProcessActivity> processActivity;

        RETURN_IF_FAILED(sensorActivity->GetProcessActivity(i, &processActivity));
        RETURN_IF_FAILED(PrintProcessActivity(processActivity.get()));
        
        RETURN_IF_FAILED(processActivity->GetStreamingState(&fStreaming));

        if (fStreaming)
        {
            inUse = true;
            break;
        }
    }

    // Set flag that the device is in use and then signal event
    _inUse = inUse;
    if (cProcCount > 0)
    {
        _event.SetEvent();
    }

    return S_OK;
}

Este exemplo mostra um método de classe que aguarda o evento ser sinalizado pelo retorno de chamada OnActivitiesReport . Como OnActivitiesReport só definirá SetEvent quando as atividades forem encontradas, queremos usar algum valor de tempo limite razoável para WaitForSingleObject, este exemplo usa 500ms e quaisquer casos de tempo limite serão convertidos em "câmera não em uso".

bool MyCameraNotificationCallback::IsInUse( )
{
    if (_event.wait(500))
    {
        return _inUse;
    }

    return false;
}

O exemplo a seguir mostra uma implementação que chama MFCreateSensorActivityMonitor para criar o monitor de atividade e, em seguida, chama o método de classe IsInUse mostrado acima para determinar se o sensor especificado está em uso no momento.

HRESULT IsCameraInUse(
    _In_z_ LPCWSTR symbolicName,
    bool& inUse
)
{
    wil::com_ptr_nothrow<MyCameraNotificationCallback> cameraNotificationCallback;
    wil::com_ptr_nothrow<IMFSensorActivityMonitor> activityMonitor;
    wil::com_ptr_nothrow<IMFShutdown> spShutdown;

    RETURN_IF_FAILED(MyCameraNotificationCallback::CreateInstance(symbolicName, &cameraNotificationCallback));

    // Create the IMFSensorActivityMonitor, passing in the IMFSensorActivitiesReportCallback.
    RETURN_IF_FAILED(MFCreateSensorActivityMonitor(cameraNotificationCallback.get(), &activityMonitor));

    // Start the monitor
    RETURN_IF_FAILED(activityMonitor->Start());

    // Call the method that checks to if the monitored device is in use.
    inUse = cameraNotificationCallback->IsInUse();

    // Stop the activity monitor.
    RETURN_IF_FAILED(activityMonitor->Stop());

    // Shutdown the monitor.
    RETURN_IF_FAILED(activityMonitor.query_to(&spShutdown));

    RETURN_IF_FAILED(spShutdown->Shutdown());

    return S_OK;
}

Requisitos