Source/WebCore/Modules/mediasession/MediaSessionCoordinator.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2021 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "MediaSessionCoordinator.h"

 #if ENABLE(MEDIA_SESSION_COORDINATOR)

 #include "EventNames.h"
 #include "JSDOMException.h"
 #include "JSDOMPromiseDeferred.h"
 #include "JSMediaSessionCoordinatorState.h"
 #include "Logging.h"
 #include "MediaMetadata.h"
 #include "MediaSession.h"
 #include "MediaSessionCoordinatorPrivate.h"
 #include <wtf/CompletionHandler.h>
 #include <wtf/Logger.h>
 #include <wtf/LoggerHelper.h>
 #include <wtf/Seconds.h>

 static const Seconds CommandTimeTolerance = 50_ms;

 namespace WebCore {

 static const void* nextCoordinatorLogIdentifier()
 {
     static uint64_t logIdentifier = cryptographicallyRandomNumber();
     return reinterpret_cast<const void*>(++logIdentifier);
 }

 Ref<MediaSessionCoordinator> MediaSessionCoordinator::create(ScriptExecutionContext* context)
 {
     auto coordinator = adoptRef(*new MediaSessionCoordinator(context));
     coordinator->suspendIfNeeded();
     return coordinator;
 }

 MediaSessionCoordinator::MediaSessionCoordinator(ScriptExecutionContext* context)
     : ActiveDOMObject(context)
     , m_logger(Document::sharedLogger())
     , m_logIdentifier(nextCoordinatorLogIdentifier())
 {
     ALWAYS_LOG(LOGIDENTIFIER);
 }

 void MediaSessionCoordinator::setMediaSessionCoordinatorPrivate(Ref<MediaSessionCoordinatorPrivate>&& privateCoordinator)
 {
     ALWAYS_LOG(LOGIDENTIFIER);
     if (m_privateCoordinator)
         m_privateCoordinator->leave();
     m_privateCoordinator = WTFMove(privateCoordinator);
     m_privateCoordinator->setLogger(m_logger.copyRef(), m_logIdentifier);
     m_privateCoordinator->setClient(*this);
     coordinatorStateChanged(MediaSessionCoordinatorState::Waiting);
 }

 MediaSessionCoordinator::~MediaSessionCoordinator() = default;

 void MediaSessionCoordinator::eventListenersDidChange()
 {
     m_hasCoordinatorsStateChangeEventListener = hasEventListeners(eventNames().coordinatorstatechangeEvent);
 }

 bool MediaSessionCoordinator::virtualHasPendingActivity() const
 {
     // Need to keep the JS wrapper alive as long as it may still fire events in the future.
     return shouldFireEvents();
 }

 void MediaSessionCoordinator::join(DOMPromiseDeferred<void>&& promise)
 {
     auto identifier = LOGIDENTIFIER;
     ALWAYS_LOG(identifier, m_state);

     if (m_state != MediaSessionCoordinatorState::Waiting) {
         ERROR_LOG(identifier, "invalid state");
         promise.reject(Exception { InvalidStateError, makeString("Unable to join when state is ", convertEnumerationToString(m_state)) });
         return;
     }
     ASSERT(m_privateCoordinator, "We must be in Waiting state if no private coordinator is set");

     m_privateCoordinator->join([protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
         if (!protectedThis->m_session) {
             promise.reject(Exception { InvalidStateError });
             return;
         }

         if (exception) {
             protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.join failed!");
             promise.reject(WTFMove(*exception));
             return;
         }

         protectedThis->coordinatorStateChanged(MediaSessionCoordinatorState::Joined);

         promise.resolve();
     });
 }

 ExceptionOr<void> MediaSessionCoordinator::leave()
 {
     ALWAYS_LOG(LOGIDENTIFIER);
     if (m_state != MediaSessionCoordinatorState::Joined)
         return Exception { InvalidStateError, makeString("Unable to leave when state is ", convertEnumerationToString(m_state)) };

     close();

     return { };
 }

 void MediaSessionCoordinator::close()
 {
     ALWAYS_LOG(LOGIDENTIFIER);
     coordinatorStateChanged(MediaSessionCoordinatorState::Closed);
     if (!m_privateCoordinator)
         return;

     m_privateCoordinator->leave();
     m_privateCoordinator = nullptr;
 }

 void MediaSessionCoordinator::seekTo(double time, DOMPromiseDeferred<void>&& promise)
 {
     auto identifier = LOGIDENTIFIER;
     ALWAYS_LOG(identifier, time);

     if (!m_session) {
         ERROR_LOG(identifier, "MediaSession is NULL!");
         promise.reject(Exception { InvalidStateError });
         return;
     }

     if (m_state != MediaSessionCoordinatorState::Joined) {
         ERROR_LOG(identifier, ".state is ", m_state);
         promise.reject(Exception { InvalidStateError, makeString("Unable to seekTo when state is ", convertEnumerationToString(m_state)) });
         return;
     }

     m_privateCoordinator->seekTo(time, [protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
         if (!protectedThis->m_session) {
             promise.reject(Exception { InvalidStateError });
             return;
         }

         if (exception) {
             promise.reject(WTFMove(*exception));
             protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.seekTo failed!");
             return;
         }

         promise.resolve();
     });
 }

 void MediaSessionCoordinator::play(DOMPromiseDeferred<void>&& promise)
 {
     auto identifier = LOGIDENTIFIER;
     ALWAYS_LOG(identifier);

     if (!m_session) {
         ERROR_LOG(identifier, "MediaSession is NULL!");
         promise.reject(Exception { InvalidStateError });
         return;
     }

     if (m_state != MediaSessionCoordinatorState::Joined) {
         ERROR_LOG(identifier, ".state is ", m_state);
         promise.reject(Exception { InvalidStateError, makeString("Unable to play when state is ", convertEnumerationToString(m_state)) });
         return;
     }

     m_privateCoordinator->play([protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
         if (!protectedThis->m_session) {
             promise.reject(Exception { InvalidStateError });
             return;
         }

         if (exception) {
             promise.reject(WTFMove(*exception));
             protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.play failed!");
             return;
         }

         promise.resolve();
     });
 }

 void MediaSessionCoordinator::pause(DOMPromiseDeferred<void>&& promise)
 {
     auto identifier = LOGIDENTIFIER;
     ALWAYS_LOG(identifier);

     if (!m_session) {
         ERROR_LOG(identifier, "MediaSession is NULL!");
         promise.reject(Exception { InvalidStateError });
         return;
     }

     if (m_state != MediaSessionCoordinatorState::Joined) {
         ERROR_LOG(identifier, ".state is ", m_state);
         promise.reject(Exception { InvalidStateError, makeString("Unable to pause when state is ", convertEnumerationToString(m_state)) });
         return;
     }

     m_privateCoordinator->pause([protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
         if (!protectedThis->m_session) {
             promise.reject(Exception { InvalidStateError });
             return;
         }

         if (exception) {
             promise.reject(WTFMove(*exception));
             protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.pause failed!");
             return;
         }

         promise.resolve();
     });
 }

 void MediaSessionCoordinator::setTrack(const String& track, DOMPromiseDeferred<void>&& promise)
 {
     auto identifier = LOGIDENTIFIER;
     ALWAYS_LOG(identifier);

     if (!m_session) {
         ERROR_LOG(identifier, "MediaSession is NULL!");
         promise.reject(Exception { InvalidStateError });
         return;
     }

     if (m_state != MediaSessionCoordinatorState::Joined) {
         ERROR_LOG(identifier, ".state is ", m_state);
         promise.reject(Exception { InvalidStateError, makeString("Unable to setTrack when state is ", convertEnumerationToString(m_state)) });
         return;
     }

     m_privateCoordinator->setTrack(track, [protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
         if (!protectedThis->m_session) {
             promise.reject(Exception { InvalidStateError });
             return;
         }

         if (exception) {
             promise.reject(WTFMove(*exception));
             protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.setTrack failed!");
             return;
         }

         promise.resolve();
     });
 }

 void MediaSessionCoordinator::setMediaSession(MediaSession* session)
 {
     ALWAYS_LOG(LOGIDENTIFIER);
     m_session = session;

     if (m_session)
         m_session->addObserver(*this);
 }

 void MediaSessionCoordinator::metadataChanged(const RefPtr<MediaMetadata>& metadata)
 {
 #if ENABLE(MEDIA_SESSION_PLAYLIST)
     if (!m_privateCoordinator)
         return;

     auto identifier = metadata ? metadata->trackIdentifier() : emptyString();
     ALWAYS_LOG(LOGIDENTIFIER, m_state, ", trackIdentifier:", identifier);
     m_privateCoordinator->trackIdentifierChanged(identifier);
 #endif
 }

 void MediaSessionCoordinator::positionStateChanged(const std::optional<MediaPositionState>& positionState)
 {
     if (positionState)
         ALWAYS_LOG(LOGIDENTIFIER, positionState.value());
     else
         ALWAYS_LOG(LOGIDENTIFIER, "{ }");

     if (m_state != MediaSessionCoordinatorState::Joined)
         return;

     if (!m_privateCoordinator)
         return;

     if (!positionState) {
         m_privateCoordinator->positionStateChanged({ });
         return;
     }

     m_privateCoordinator->positionStateChanged(MediaPositionState { positionState->duration, positionState->playbackRate, positionState->position });
 }

 void MediaSessionCoordinator::playbackStateChanged(MediaSessionPlaybackState playbackState)
 {
     ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", playbackState);

     if (m_state != MediaSessionCoordinatorState::Joined)
         return;

     if (!m_privateCoordinator)
         return;

     m_privateCoordinator->playbackStateChanged(playbackState);
 }

 void MediaSessionCoordinator::readyStateChanged(MediaSessionReadyState readyState)
 {
     ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", readyState);

     if (m_state != MediaSessionCoordinatorState::Joined)
         return;

     if (!m_privateCoordinator)
         return;

     m_privateCoordinator->readyStateChanged(readyState);
 }

 void MediaSessionCoordinator::seekSessionToTime(double time, CompletionHandler<void(bool)>&& completionHandler)
 {
     ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", time);

     if (m_state != MediaSessionCoordinatorState::Joined) {
         completionHandler(false);
         return;
     }

     bool isPaused = m_session->playbackState() == MediaSessionPlaybackState::Paused;

     if (isPaused && currentPositionApproximatelyEqualTo(time)) {
         completionHandler(true);
         return;
     }

     if (!isPaused)
         m_session->callActionHandler({ .action = MediaSessionAction::Pause });

     m_session->callActionHandler({ .action = MediaSessionAction::Seekto, .seekTime = time });
     completionHandler(true);
 }

 void MediaSessionCoordinator::playSession(std::optional<double> atTime, std::optional<MonotonicTime> hostTime, CompletionHandler<void(bool)>&& completionHandler)
 {
     auto now = MonotonicTime::now();
     auto delta = hostTime ? *hostTime - now : Seconds::nan();
     ALWAYS_LOG(LOGIDENTIFIER, m_state, " time: ", atTime ? *atTime : -1, " hostTime: ", (hostTime ? *hostTime : MonotonicTime::nan()).secondsSinceEpoch().value(), " delta: ", delta.value());

     if (m_state != MediaSessionCoordinatorState::Joined) {
         completionHandler(false);
         return;
     }

     if (atTime && !currentPositionApproximatelyEqualTo(*atTime))
         m_session->callActionHandler({ .action = MediaSessionAction::Seekto, .seekTime = *atTime });

     m_currentPlaySessionCommand = { atTime, hostTime };
     m_session->callActionHandler({ .action = MediaSessionAction::Play });
     completionHandler(true);
 }

 void MediaSessionCoordinator::pauseSession(CompletionHandler<void(bool)>&& completionHandler)
 {
     ALWAYS_LOG(LOGIDENTIFIER, m_state);

     if (m_state != MediaSessionCoordinatorState::Joined) {
         completionHandler(false);
         return;
     }

     m_session->callActionHandler({ .action = MediaSessionAction::Pause });
     completionHandler(true);
 }

 void MediaSessionCoordinator::setSessionTrack(const String& track, CompletionHandler<void(bool)>&& completionHandler)
 {
     ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", track);

     if (m_state != MediaSessionCoordinatorState::Joined) {
         completionHandler(false);
         return;
     }

     m_session->callActionHandler({ .action = MediaSessionAction::Settrack, .trackIdentifier = track });
     completionHandler(true);
 }

 bool MediaSessionCoordinator::shouldFireEvents() const
 {
     return m_hasCoordinatorsStateChangeEventListener && m_session;
 }


 void MediaSessionCoordinator::coordinatorStateChanged(MediaSessionCoordinatorState state)
 {
     if (m_state == state)
         return;
     m_state = state;
     ALWAYS_LOG(LOGIDENTIFIER, m_state);
     if (shouldFireEvents())
         queueTaskToDispatchEvent(*this, TaskSource::MediaElement, Event::create(eventNames().coordinatorstatechangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
 }

 bool MediaSessionCoordinator::currentPositionApproximatelyEqualTo(double time) const
 {
     if (!m_session)
         return false;

     auto currentPosition = m_session->currentPosition();
     if (!currentPosition)
         return false;

     auto delta = Seconds(abs(*currentPosition - time));
     return delta <= CommandTimeTolerance;
 }

 WTFLogChannel& MediaSessionCoordinator::logChannel()
 {
     return LogMedia;
 }

 }

 #endif // ENABLE(MEDIA_SESSION_COORDINATOR)
	/*
	* Copyright (C) 2021 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "MediaSessionCoordinator.h"

	#if ENABLE(MEDIA_SESSION_COORDINATOR)

	#include "EventNames.h"
	#include "JSDOMException.h"
	#include "JSDOMPromiseDeferred.h"
	#include "JSMediaSessionCoordinatorState.h"
	#include "Logging.h"
	#include "MediaMetadata.h"
	#include "MediaSession.h"
	#include "MediaSessionCoordinatorPrivate.h"
	#include <wtf/CompletionHandler.h>
	#include <wtf/Logger.h>
	#include <wtf/LoggerHelper.h>
	#include <wtf/Seconds.h>

	static const Seconds CommandTimeTolerance = 50_ms;

	namespace WebCore {

	static const void* nextCoordinatorLogIdentifier()
	{
	static uint64_t logIdentifier = cryptographicallyRandomNumber();
	return reinterpret_cast<const void*>(++logIdentifier);
	}

	Ref<MediaSessionCoordinator> MediaSessionCoordinator::create(ScriptExecutionContext* context)
	{
	auto coordinator = adoptRef(*new MediaSessionCoordinator(context));
	coordinator->suspendIfNeeded();
	return coordinator;
	}

	MediaSessionCoordinator::MediaSessionCoordinator(ScriptExecutionContext* context)
	: ActiveDOMObject(context)
	, m_logger(Document::sharedLogger())
	, m_logIdentifier(nextCoordinatorLogIdentifier())
	{
	ALWAYS_LOG(LOGIDENTIFIER);
	}

	void MediaSessionCoordinator::setMediaSessionCoordinatorPrivate(Ref<MediaSessionCoordinatorPrivate>&& privateCoordinator)
	{
	ALWAYS_LOG(LOGIDENTIFIER);
	if (m_privateCoordinator)
	m_privateCoordinator->leave();
	m_privateCoordinator = WTFMove(privateCoordinator);
	m_privateCoordinator->setLogger(m_logger.copyRef(), m_logIdentifier);
	m_privateCoordinator->setClient(*this);
	coordinatorStateChanged(MediaSessionCoordinatorState::Waiting);
	}

	MediaSessionCoordinator::~MediaSessionCoordinator() = default;

	void MediaSessionCoordinator::eventListenersDidChange()
	{
	m_hasCoordinatorsStateChangeEventListener = hasEventListeners(eventNames().coordinatorstatechangeEvent);
	}

	bool MediaSessionCoordinator::virtualHasPendingActivity() const
	{
	// Need to keep the JS wrapper alive as long as it may still fire events in the future.
	return shouldFireEvents();
	}

	void MediaSessionCoordinator::join(DOMPromiseDeferred<void>&& promise)
	{
	auto identifier = LOGIDENTIFIER;
	ALWAYS_LOG(identifier, m_state);

	if (m_state != MediaSessionCoordinatorState::Waiting) {
	ERROR_LOG(identifier, "invalid state");
	promise.reject(Exception { InvalidStateError, makeString("Unable to join when state is ", convertEnumerationToString(m_state)) });
	return;
	}
	ASSERT(m_privateCoordinator, "We must be in Waiting state if no private coordinator is set");

	m_privateCoordinator->join([protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
	if (!protectedThis->m_session) {
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (exception) {
	protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.join failed!");
	promise.reject(WTFMove(*exception));
	return;
	}

	protectedThis->coordinatorStateChanged(MediaSessionCoordinatorState::Joined);

	promise.resolve();
	});
	}

	ExceptionOr<void> MediaSessionCoordinator::leave()
	{
	ALWAYS_LOG(LOGIDENTIFIER);
	if (m_state != MediaSessionCoordinatorState::Joined)
	return Exception { InvalidStateError, makeString("Unable to leave when state is ", convertEnumerationToString(m_state)) };

	close();

	return { };
	}

	void MediaSessionCoordinator::close()
	{
	ALWAYS_LOG(LOGIDENTIFIER);
	coordinatorStateChanged(MediaSessionCoordinatorState::Closed);
	if (!m_privateCoordinator)
	return;

	m_privateCoordinator->leave();
	m_privateCoordinator = nullptr;
	}

	void MediaSessionCoordinator::seekTo(double time, DOMPromiseDeferred<void>&& promise)
	{
	auto identifier = LOGIDENTIFIER;
	ALWAYS_LOG(identifier, time);

	if (!m_session) {
	ERROR_LOG(identifier, "MediaSession is NULL!");
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (m_state != MediaSessionCoordinatorState::Joined) {
	ERROR_LOG(identifier, ".state is ", m_state);
	promise.reject(Exception { InvalidStateError, makeString("Unable to seekTo when state is ", convertEnumerationToString(m_state)) });
	return;
	}

	m_privateCoordinator->seekTo(time, [protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
	if (!protectedThis->m_session) {
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (exception) {
	promise.reject(WTFMove(*exception));
	protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.seekTo failed!");
	return;
	}

	promise.resolve();
	});
	}

	void MediaSessionCoordinator::play(DOMPromiseDeferred<void>&& promise)
	{
	auto identifier = LOGIDENTIFIER;
	ALWAYS_LOG(identifier);

	if (!m_session) {
	ERROR_LOG(identifier, "MediaSession is NULL!");
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (m_state != MediaSessionCoordinatorState::Joined) {
	ERROR_LOG(identifier, ".state is ", m_state);
	promise.reject(Exception { InvalidStateError, makeString("Unable to play when state is ", convertEnumerationToString(m_state)) });
	return;
	}

	m_privateCoordinator->play([protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
	if (!protectedThis->m_session) {
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (exception) {
	promise.reject(WTFMove(*exception));
	protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.play failed!");
	return;
	}

	promise.resolve();
	});
	}

	void MediaSessionCoordinator::pause(DOMPromiseDeferred<void>&& promise)
	{
	auto identifier = LOGIDENTIFIER;
	ALWAYS_LOG(identifier);

	if (!m_session) {
	ERROR_LOG(identifier, "MediaSession is NULL!");
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (m_state != MediaSessionCoordinatorState::Joined) {
	ERROR_LOG(identifier, ".state is ", m_state);
	promise.reject(Exception { InvalidStateError, makeString("Unable to pause when state is ", convertEnumerationToString(m_state)) });
	return;
	}

	m_privateCoordinator->pause([protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
	if (!protectedThis->m_session) {
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (exception) {
	promise.reject(WTFMove(*exception));
	protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.pause failed!");
	return;
	}

	promise.resolve();
	});
	}

	void MediaSessionCoordinator::setTrack(const String& track, DOMPromiseDeferred<void>&& promise)
	{
	auto identifier = LOGIDENTIFIER;
	ALWAYS_LOG(identifier);

	if (!m_session) {
	ERROR_LOG(identifier, "MediaSession is NULL!");
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (m_state != MediaSessionCoordinatorState::Joined) {
	ERROR_LOG(identifier, ".state is ", m_state);
	promise.reject(Exception { InvalidStateError, makeString("Unable to setTrack when state is ", convertEnumerationToString(m_state)) });
	return;
	}

	m_privateCoordinator->setTrack(track, [protectedThis = Ref { *this }, identifier, promise = WTFMove(promise)] (std::optional<Exception>&& exception) mutable {
	if (!protectedThis->m_session) {
	promise.reject(Exception { InvalidStateError });
	return;
	}

	if (exception) {
	promise.reject(WTFMove(*exception));
	protectedThis->logger().error(protectedThis->logChannel(), identifier, "coordinator.setTrack failed!");
	return;
	}

	promise.resolve();
	});
	}

	void MediaSessionCoordinator::setMediaSession(MediaSession* session)
	{
	ALWAYS_LOG(LOGIDENTIFIER);
	m_session = session;

	if (m_session)
	m_session->addObserver(*this);
	}

	void MediaSessionCoordinator::metadataChanged(const RefPtr<MediaMetadata>& metadata)
	{
	#if ENABLE(MEDIA_SESSION_PLAYLIST)
	if (!m_privateCoordinator)
	return;

	auto identifier = metadata ? metadata->trackIdentifier() : emptyString();
	ALWAYS_LOG(LOGIDENTIFIER, m_state, ", trackIdentifier:", identifier);
	m_privateCoordinator->trackIdentifierChanged(identifier);
	#endif
	}

	void MediaSessionCoordinator::positionStateChanged(const std::optional<MediaPositionState>& positionState)
	{
	if (positionState)
	ALWAYS_LOG(LOGIDENTIFIER, positionState.value());
	else
	ALWAYS_LOG(LOGIDENTIFIER, "{ }");

	if (m_state != MediaSessionCoordinatorState::Joined)
	return;

	if (!m_privateCoordinator)
	return;

	if (!positionState) {
	m_privateCoordinator->positionStateChanged({ });
	return;
	}

	m_privateCoordinator->positionStateChanged(MediaPositionState { positionState->duration, positionState->playbackRate, positionState->position });
	}

	void MediaSessionCoordinator::playbackStateChanged(MediaSessionPlaybackState playbackState)
	{
	ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", playbackState);

	if (m_state != MediaSessionCoordinatorState::Joined)
	return;

	if (!m_privateCoordinator)
	return;

	m_privateCoordinator->playbackStateChanged(playbackState);
	}

	void MediaSessionCoordinator::readyStateChanged(MediaSessionReadyState readyState)
	{
	ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", readyState);

	if (m_state != MediaSessionCoordinatorState::Joined)
	return;

	if (!m_privateCoordinator)
	return;

	m_privateCoordinator->readyStateChanged(readyState);
	}

	void MediaSessionCoordinator::seekSessionToTime(double time, CompletionHandler<void(bool)>&& completionHandler)
	{
	ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", time);

	if (m_state != MediaSessionCoordinatorState::Joined) {
	completionHandler(false);
	return;
	}

	bool isPaused = m_session->playbackState() == MediaSessionPlaybackState::Paused;

	if (isPaused && currentPositionApproximatelyEqualTo(time)) {
	completionHandler(true);
	return;
	}

	if (!isPaused)
	m_session->callActionHandler({ .action = MediaSessionAction::Pause });

	m_session->callActionHandler({ .action = MediaSessionAction::Seekto, .seekTime = time });
	completionHandler(true);
	}

	void MediaSessionCoordinator::playSession(std::optional<double> atTime, std::optional<MonotonicTime> hostTime, CompletionHandler<void(bool)>&& completionHandler)
	{
	auto now = MonotonicTime::now();
	auto delta = hostTime ? *hostTime - now : Seconds::nan();
	ALWAYS_LOG(LOGIDENTIFIER, m_state, " time: ", atTime ? atTime : -1, " hostTime: ", (hostTime ? hostTime : MonotonicTime::nan()).secondsSinceEpoch().value(), " delta: ", delta.value());

	if (m_state != MediaSessionCoordinatorState::Joined) {
	completionHandler(false);
	return;
	}

	if (atTime && !currentPositionApproximatelyEqualTo(*atTime))
	m_session->callActionHandler({ .action = MediaSessionAction::Seekto, .seekTime = *atTime });

	m_currentPlaySessionCommand = { atTime, hostTime };
	m_session->callActionHandler({ .action = MediaSessionAction::Play });
	completionHandler(true);
	}

	void MediaSessionCoordinator::pauseSession(CompletionHandler<void(bool)>&& completionHandler)
	{
	ALWAYS_LOG(LOGIDENTIFIER, m_state);

	if (m_state != MediaSessionCoordinatorState::Joined) {
	completionHandler(false);
	return;
	}

	m_session->callActionHandler({ .action = MediaSessionAction::Pause });
	completionHandler(true);
	}

	void MediaSessionCoordinator::setSessionTrack(const String& track, CompletionHandler<void(bool)>&& completionHandler)
	{
	ALWAYS_LOG(LOGIDENTIFIER, m_state, ", ", track);

	if (m_state != MediaSessionCoordinatorState::Joined) {
	completionHandler(false);
	return;
	}

	m_session->callActionHandler({ .action = MediaSessionAction::Settrack, .trackIdentifier = track });
	completionHandler(true);
	}

	bool MediaSessionCoordinator::shouldFireEvents() const
	{
	return m_hasCoordinatorsStateChangeEventListener && m_session;
	}


	void MediaSessionCoordinator::coordinatorStateChanged(MediaSessionCoordinatorState state)
	{
	if (m_state == state)
	return;
	m_state = state;
	ALWAYS_LOG(LOGIDENTIFIER, m_state);
	if (shouldFireEvents())
	queueTaskToDispatchEvent(*this, TaskSource::MediaElement, Event::create(eventNames().coordinatorstatechangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
	}

	bool MediaSessionCoordinator::currentPositionApproximatelyEqualTo(double time) const
	{
	if (!m_session)
	return false;

	auto currentPosition = m_session->currentPosition();
	if (!currentPosition)
	return false;

	auto delta = Seconds(abs(*currentPosition - time));
	return delta <= CommandTimeTolerance;
	}

	WTFLogChannel& MediaSessionCoordinator::logChannel()
	{
	return LogMedia;
	}

	}

	#endif // ENABLE(MEDIA_SESSION_COORDINATOR)