mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-09 19:35:51 +00:00
758ee8a36c
This allows adding another vsync listener that gets called before the regular VsyncSource. And it allows adding the listener on the Java UI thread. The existing infrastructure is pretty adamant about being used on the main thread. Differential Revision: https://phabricator.services.mozilla.com/D96797
141 lines
4.1 KiB
C++
141 lines
4.1 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "AndroidVsync.h"
|
|
|
|
#include "nsTArray.h"
|
|
|
|
/**
|
|
* Implementation for the AndroidVsync class.
|
|
*/
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
StaticDataMutex<ThreadSafeWeakPtr<AndroidVsync>> AndroidVsync::sInstance(
|
|
"AndroidVsync::sInstance");
|
|
|
|
/* static */ RefPtr<AndroidVsync> AndroidVsync::GetInstance() {
|
|
auto weakInstance = sInstance.Lock();
|
|
RefPtr<AndroidVsync> instance(*weakInstance);
|
|
if (!instance) {
|
|
instance = new AndroidVsync();
|
|
*weakInstance = instance;
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
/**
|
|
* Owned by the Java AndroidVsync instance.
|
|
*/
|
|
class AndroidVsyncSupport final
|
|
: public java::AndroidVsync::Natives<AndroidVsyncSupport> {
|
|
public:
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AndroidVsyncSupport)
|
|
|
|
using Base = java::AndroidVsync::Natives<AndroidVsyncSupport>;
|
|
using Base::AttachNative;
|
|
using Base::DisposeNative;
|
|
|
|
explicit AndroidVsyncSupport(AndroidVsync* aAndroidVsync)
|
|
: mAndroidVsync(std::move(aAndroidVsync),
|
|
"AndroidVsyncSupport::mAndroidVsync") {}
|
|
|
|
// Called by Java
|
|
void NotifyVsync(const java::AndroidVsync::LocalRef& aInstance,
|
|
int64_t aFrameTimeNanos) {
|
|
auto androidVsync = mAndroidVsync.Lock();
|
|
if (*androidVsync) {
|
|
(*androidVsync)->NotifyVsync(aFrameTimeNanos);
|
|
}
|
|
}
|
|
|
|
// Called by the AndroidVsync destructor
|
|
void Unlink() {
|
|
auto androidVsync = mAndroidVsync.Lock();
|
|
*androidVsync = nullptr;
|
|
}
|
|
|
|
protected:
|
|
~AndroidVsyncSupport() = default;
|
|
|
|
DataMutex<AndroidVsync*> mAndroidVsync;
|
|
};
|
|
|
|
AndroidVsync::AndroidVsync() : mImpl("AndroidVsync.mImpl") {
|
|
AndroidVsyncSupport::Init();
|
|
|
|
auto impl = mImpl.Lock();
|
|
impl->mSupport = new AndroidVsyncSupport(this);
|
|
impl->mSupportJava = java::AndroidVsync::New();
|
|
AndroidVsyncSupport::AttachNative(impl->mSupportJava, impl->mSupport);
|
|
float fps = impl->mSupportJava->GetRefreshRate();
|
|
impl->mVsyncDuration = TimeDuration::FromMilliseconds(1000.0 / fps);
|
|
}
|
|
|
|
AndroidVsync::~AndroidVsync() {
|
|
auto impl = mImpl.Lock();
|
|
impl->mInputObservers.Clear();
|
|
impl->mRenderObservers.Clear();
|
|
impl->UpdateObservingVsync();
|
|
impl->mSupport->Unlink();
|
|
}
|
|
|
|
TimeDuration AndroidVsync::GetVsyncRate() {
|
|
auto impl = mImpl.Lock();
|
|
return impl->mVsyncDuration;
|
|
}
|
|
|
|
void AndroidVsync::RegisterObserver(Observer* aObserver, ObserverType aType) {
|
|
auto impl = mImpl.Lock();
|
|
if (aType == AndroidVsync::INPUT) {
|
|
impl->mInputObservers.AppendElement(aObserver);
|
|
} else {
|
|
impl->mRenderObservers.AppendElement(aObserver);
|
|
}
|
|
impl->UpdateObservingVsync();
|
|
}
|
|
|
|
void AndroidVsync::UnregisterObserver(Observer* aObserver, ObserverType aType) {
|
|
auto impl = mImpl.Lock();
|
|
if (aType == AndroidVsync::INPUT) {
|
|
impl->mInputObservers.RemoveElement(aObserver);
|
|
} else {
|
|
impl->mRenderObservers.RemoveElement(aObserver);
|
|
}
|
|
impl->UpdateObservingVsync();
|
|
}
|
|
|
|
void AndroidVsync::Impl::UpdateObservingVsync() {
|
|
bool shouldObserve =
|
|
!mInputObservers.IsEmpty() || !mRenderObservers.IsEmpty();
|
|
if (shouldObserve != mObservingVsync) {
|
|
mObservingVsync = mSupportJava->ObserveVsync(shouldObserve);
|
|
}
|
|
}
|
|
|
|
// Always called on the Java UI thread.
|
|
void AndroidVsync::NotifyVsync(int64_t aFrameTimeNanos) {
|
|
// Convert aFrameTimeNanos to a TimeStamp. The value converts trivially to
|
|
// the internal ticks representation of TimeStamp_posix; both use the
|
|
// monotonic clock and are in nanoseconds.
|
|
TimeStamp timeStamp = TimeStamp::FromSystemTime(aFrameTimeNanos);
|
|
|
|
// Do not keep the lock held while calling OnVsync.
|
|
nsTArray<Observer*> observers;
|
|
{
|
|
auto impl = mImpl.Lock();
|
|
observers.AppendElements(impl->mInputObservers);
|
|
observers.AppendElements(impl->mRenderObservers);
|
|
}
|
|
for (Observer* observer : observers) {
|
|
observer->OnVsync(timeStamp);
|
|
}
|
|
}
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|