Interface IMFSensorActivityMonitor (mfidl.h)

Article
08/24/2023

Fournit des méthodes pour contrôler un moniteur d’activité de capteur.

Héritage

L’interface IMFSensorActivityMonitor hérite de l’interface IUnknown. IMFSensorActivityMonitor a également les types de membres suivants :

Méthodes

L’interface IMFSensorActivityMonitor utilise ces méthodes.


IMFSensorActivityMonitor::Start Démarre le moniteur d’activité du capteur.
IMFSensorActivityMonitor::Stop Arrête le moniteur d’activité du capteur.

Notes

Obtenez un instance de cette classe en appelant MFCreateSensorActivityMonitor. Les rapports d’activité des capteurs sont fournis via l’interface IMFSensorActivitiesReportCallback transmise à cette méthode.

Exemples

Les exemples ci-dessous utilisent C++/WinRT pour créer une classe de rappel COM et des bibliothèques d’implémentation Windows (WIL).

L’exemple complet de projet Visual Studio est disponible à partir du référentiel GitHub Windows-Camera

L’exemple suivant montre une déclaration de classe qui implémente 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;
};

L’exemple suivant montre l’implémentation du rappel OnActivitiesReport .

La fonction OnActivitiesReport met à jour un membre de classe booléenne pour indiquer si le périphérique de capteur interrogé est en cours d’utilisation, puis définit un événement pour signaler que le status a été obtenu.

Notez que le rappel peut être appelé plusieurs fois et peut ne pas contenir de rapports. L’événement n’est donc défini que lorsque des rapports ont été trouvés.


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

Cet exemple montre une méthode de classe qui attend que l’événement soit signalé par le rappel OnActivitiesReport . Comme OnActivitiesReport n’est défini que sur SetEvent lorsque les activités sont trouvées, nous voulons utiliser une valeur de délai d’expiration raisonnable pour WaitForSingleObject, cet exemple utilise 500 ms et tous les cas de délai d’expiration sont traduits en « caméra non utilisée ».

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

    return false;
}

L’exemple suivant montre une implémentation qui appelle MFCreateSensorActivityMonitor pour créer le moniteur d’activité, puis appelle la méthode de classe IsInUse ci-dessus pour déterminer si le capteur spécifié est actuellement utilisé.

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

Spécifications


Client minimal pris en charge	Windows 10, version 1703 [applications de bureau uniquement]
Serveur minimal pris en charge	Aucun pris en charge
Plateforme cible	Windows
En-tête	mfidl.h

Partager via