RealtimeMediaSourceCenter.h [plain text]
#pragma once
#if ENABLE(MEDIA_STREAM)
#include "ExceptionOr.h"
#include "RealtimeMediaSource.h"
#include "RealtimeMediaSourceSupportedConstraints.h"
#include <wtf/Function.h>
#include <wtf/RefPtr.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class CaptureDevice;
class CaptureDeviceManager;
class RealtimeMediaSourceSettings;
class RealtimeMediaSourceSupportedConstraints;
class TrackSourceInfo;
struct MediaConstraints;
class RealtimeMediaSourceCenter {
public:
virtual ~RealtimeMediaSourceCenter();
WEBCORE_EXPORT static RealtimeMediaSourceCenter& singleton();
static void setSharedStreamCenterOverride(RealtimeMediaSourceCenter*);
using ValidConstraintsHandler = WTF::Function<void(Vector<String>&& audioDeviceUIDs, Vector<String>&& videoDeviceUIDs, String&&)>;
using InvalidConstraintsHandler = WTF::Function<void(const String& invalidConstraint)>;
virtual void validateRequestConstraints(ValidConstraintsHandler&&, InvalidConstraintsHandler&&, const MediaConstraints& audioConstraints, const MediaConstraints& videoConstraints, String&&);
using NewMediaStreamHandler = std::function<void(RefPtr<MediaStreamPrivate>&&)>;
virtual void createMediaStream(NewMediaStreamHandler&&, const String& audioDeviceID, const String& videoDeviceID, const MediaConstraints* audioConstraints, const MediaConstraints* videoConstraints);
WEBCORE_EXPORT virtual Vector<CaptureDevice> getMediaStreamDevices();
const RealtimeMediaSourceSupportedConstraints& supportedConstraints() { return m_supportedConstraints; }
virtual RealtimeMediaSource::AudioCaptureFactory& defaultAudioFactory() = 0;
virtual RealtimeMediaSource::VideoCaptureFactory& defaultVideoFactory() = 0;
virtual CaptureDeviceManager& defaultAudioCaptureDeviceManager() = 0;
virtual CaptureDeviceManager& defaultVideoCaptureDeviceManager() = 0;
WEBCORE_EXPORT void setAudioFactory(RealtimeMediaSource::AudioCaptureFactory&);
WEBCORE_EXPORT void unsetAudioFactory(RealtimeMediaSource::AudioCaptureFactory&);
WEBCORE_EXPORT RealtimeMediaSource::AudioCaptureFactory& audioFactory();
WEBCORE_EXPORT void setVideoFactory(RealtimeMediaSource::VideoCaptureFactory&);
WEBCORE_EXPORT void unsetVideoFactory(RealtimeMediaSource::VideoCaptureFactory&);
WEBCORE_EXPORT RealtimeMediaSource::VideoCaptureFactory& videoFactory();
WEBCORE_EXPORT void setAudioCaptureDeviceManager(CaptureDeviceManager&);
WEBCORE_EXPORT void unsetAudioCaptureDeviceManager(CaptureDeviceManager&);
CaptureDeviceManager& audioCaptureDeviceManager();
WEBCORE_EXPORT void setVideoCaptureDeviceManager(CaptureDeviceManager&);
WEBCORE_EXPORT void unsetVideoCaptureDeviceManager(CaptureDeviceManager&);
CaptureDeviceManager& videoCaptureDeviceManager();
String hashStringWithSalt(const String& id, const String& hashSalt);
WEBCORE_EXPORT std::optional<CaptureDevice> captureDeviceWithUniqueID(const String& id, const String& hashSalt);
WEBCORE_EXPORT ExceptionOr<void> setDeviceEnabled(const String&, bool);
using DevicesChangedObserverToken = unsigned;
DevicesChangedObserverToken addDevicesChangedObserver(std::function<void()>&&);
void removeDevicesChangedObserver(DevicesChangedObserverToken);
void captureDevicesChanged();
void setVideoCapturePageState(bool, bool);
protected:
RealtimeMediaSourceCenter();
static RealtimeMediaSourceCenter& platformCenter();
RealtimeMediaSourceSupportedConstraints m_supportedConstraints;
RealtimeMediaSource::AudioCaptureFactory* m_audioFactory { nullptr };
RealtimeMediaSource::VideoCaptureFactory* m_videoFactory { nullptr };
CaptureDeviceManager* m_audioCaptureDeviceManager { nullptr };
CaptureDeviceManager* m_videoCaptureDeviceManager { nullptr };
};
}
#endif // ENABLE(MEDIA_STREAM)