Interfaccia IMFSensorActivityMonitor (mfidl.h)

Articolo
08/24/2023

Fornisce metodi per il controllo di un monitoraggio attività del sensore.

Ereditarietà

L'interfaccia IMFSensorActivityMonitor eredita dall'interfaccia IUnknown . IMFSensorActivityMonitor ha anche questi tipi di membri:

Metodi

L'interfaccia IMFSensorActivityMonitor include questi metodi.


IMFSensorActivityMonitor::Start Avvia il monitoraggio dell'attività del sensore.
IMFSensorActivityMonitor::Stop Arresta il monitoraggio dell'attività del sensore.

Commenti

Ottenere un'istanza di questa classe chiamando MFCreateSensorActivityMonitor. I report sulle attività del sensore vengono recapitati tramite l'interfaccia IMFSensorActivitiesReportCallback passata a questo metodo.

Esempio

Gli esempi seguenti usano C++/WinRT per creare la classe di callback COM e le librerie di implementazione di Windows (WIL).The examples below are using C++/WinRT to author COM callback class and Windows Implementation Libraries (WIL).

Il progetto di Visual Studio completo di esempio è disponibile nel repository GitHub di Windows-Camera

Nell'esempio seguente viene illustrata una dichiarazione di classe che 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;
};

Nell'esempio seguente viene illustrata l'implementazione del callback OnActivitiesReport .

La funzione OnActivitiesReport aggiorna un membro della classe booleana per indicare se il dispositivo sensore sottoposto a query è attualmente in uso e quindi imposta un evento per segnalare che lo stato è stato ottenuto.

Si noti che il callback può essere chiamato più volte e potrebbe non contenere report, quindi l'evento viene impostato solo quando sono stati trovati report.


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;
}

In questo esempio viene illustrato un metodo di classe che attende che l'evento venga segnalato dal callback OnActivitiesReport . Poiché OnActivitiesReport userà solo SetEvent quando vengono trovate attività, si vuole usare un valore di timeout ragionevole per WaitForSingleObject, questo esempio usa 500 ms e tutti i casi di timeout verranno convertiti in "fotocamera non in uso".

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

    return false;
}

Nell'esempio seguente viene illustrata un'implementazione che chiama MFCreateSensorActivityMonitor per creare il monitoraggio attività e quindi chiama il metodo della classe IsInUse illustrato in precedenza per determinare se il sensore specificato è attualmente in uso.

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;
}

Requisiti


Client minimo supportato	Windows 10 versione 1703 [solo app desktop]
Server minimo supportato	Nessuno supportato
Piattaforma di destinazione	Windows
Intestazione	mfidl.h

Condividi tramite