Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 13 additions & 13 deletions packages/react-native/React/Fabric/RCTScheduler.mm
Original file line number Diff line number Diff line change
Expand Up @@ -24,23 +24,23 @@

class SchedulerDelegateProxy : public SchedulerDelegate {
public:
SchedulerDelegateProxy(void *scheduler) : scheduler_(scheduler) {}
SchedulerDelegateProxy(RCTScheduler *scheduler) : scheduler_(scheduler) {}

void schedulerDidFinishTransaction(const std::shared_ptr<const MountingCoordinator> &mountingCoordinator) override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerDidFinishTransaction:mountingCoordinator];
}

void schedulerShouldRenderTransactions(const std::shared_ptr<const MountingCoordinator> &mountingCoordinator) override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerShouldRenderTransactions:mountingCoordinator];
}

void schedulerShouldMergeReactRevision(SurfaceId surfaceId) override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerShouldMergeReactRevision:surfaceId];
}

Expand All @@ -55,28 +55,28 @@ void schedulerDidDispatchCommand(
const std::string &commandName,
const folly::dynamic &args) override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerDidDispatchCommand:shadowView commandName:commandName args:args];
}

void schedulerDidSetIsJSResponder(const ShadowView &shadowView, bool isJSResponder, bool blockNativeResponder)
override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerDidSetIsJSResponder:isJSResponder
blockNativeResponder:blockNativeResponder
forShadowView:shadowView];
}

void schedulerDidSendAccessibilityEvent(const ShadowView &shadowView, const std::string &eventType) override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerDidSendAccessibilityEvent:shadowView eventType:eventType];
}

void schedulerShouldSynchronouslyUpdateViewOnUIThread(facebook::react::Tag tag, const folly::dynamic &props) override
{
RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
RCTScheduler *scheduler __attribute__((objc_precise_lifetime)) = scheduler_;
[scheduler.delegate schedulerDidSynchronouslyUpdateViewOnUIThread:tag props:props];
}

Expand Down Expand Up @@ -105,7 +105,7 @@ void schedulerDidClearPendingSnapshots() override
}

private:
void *scheduler_;
__weak RCTScheduler *scheduler_;
};

class LayoutAnimationDelegateProxy : public LayoutAnimationStatusDelegate, public RunLoopObserver::Delegate {
Expand Down Expand Up @@ -188,15 +188,15 @@ void pause() override
@implementation RCTScheduler {
std::unique_ptr<Scheduler> _scheduler;
std::shared_ptr<LayoutAnimationDriver> _animationDriver;
std::unique_ptr<SchedulerDelegateProxy> _delegateProxy;
std::shared_ptr<SchedulerDelegateProxy> _delegateProxy;
std::shared_ptr<LayoutAnimationDelegateProxy> _layoutAnimationDelegateProxy;
std::unique_ptr<const PlatformRunLoopObserver> _uiRunLoopObserver;
}

- (instancetype)initWithToolbox:(SchedulerToolbox)toolbox
{
if (self = [super init]) {
_delegateProxy = std::make_unique<SchedulerDelegateProxy>((__bridge void *)self);
_delegateProxy = std::make_shared<SchedulerDelegateProxy>(self);

if (ReactNativeFeatureFlags::enableLayoutAnimationsOnIOS()) {
_layoutAnimationDelegateProxy = std::make_shared<LayoutAnimationDelegateProxy>((__bridge void *)self);
Expand All @@ -213,8 +213,8 @@ - (instancetype)initWithToolbox:(SchedulerToolbox)toolbox
toolbox.animationChoreographer = std::make_shared<RCTAnimationChoreographer>();
}

_scheduler = std::make_unique<Scheduler>(
toolbox, (_animationDriver ? _animationDriver.get() : nullptr), _delegateProxy.get());
_scheduler =
std::make_unique<Scheduler>(toolbox, (_animationDriver ? _animationDriver.get() : nullptr), _delegateProxy);
}

return self;
Expand Down
2 changes: 2 additions & 0 deletions packages/react-native/React/Fabric/RCTSurfacePresenter.mm
Original file line number Diff line number Diff line change
Expand Up @@ -334,7 +334,9 @@ - (void)_stopAllSurfacesWithScheduler:(RCTScheduler *)scheduler

- (void)_applicationWillTerminate
{
RCTScheduler *scheduler = [self scheduler];
[self suspend];
[scheduler stopObservingLayoutAnimations];
}

#pragma mark - RCTSchedulerDelegate
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,29 @@
using facebook::react::RuntimeSchedulerKey;
using facebook::react::SurfaceHandler;

@interface RCTSurfacePresenter (TerminationTesting)
- (void)_applicationWillTerminate;
@end

@interface RCTSchedulerTerminationProbe : NSObject
@property (nonatomic, weak) id delegate;
@property (nonatomic, copy) dispatch_block_t onStopObserving;
@property (nonatomic, copy) void (^onDealloc)(BOOL onMainThread);
- (void)stopObservingLayoutAnimations;
@end

@implementation RCTSchedulerTerminationProbe
- (void)stopObservingLayoutAnimations
{
self.onStopObserving();
}

- (void)dealloc
{
self.onDealloc([NSThread isMainThread]);
}
@end

@interface RCTFabricSurfaceLifecycleTests : XCTestCase
@end

Expand Down Expand Up @@ -79,4 +102,47 @@ - (void)testStopCancelsPendingStart
XCTAssertEqual(surface.surfaceHandler.getStatus(), SurfaceHandler::Status::Registered);
}

- (void)testTerminationStopsObserverBeforeBackgroundSchedulerRelease
{
XCTAssertTrue([NSThread isMainThread]);
RCTSurfacePresenter *presenter = [RCTSurfacePresenter new];
XCTestExpectation *released = [self expectationWithDescription:@"Scheduler released by in-flight callback"];
__block BOOL stoppedOnMain = NO;
__block BOOL releasedOnMain = YES;
__block RCTSchedulerTerminationProbe *inFlightScheduler;
__weak RCTSchedulerTerminationProbe *weakScheduler;
@autoreleasepool {
RCTSchedulerTerminationProbe *scheduler = [RCTSchedulerTerminationProbe new];
scheduler.delegate = presenter;
scheduler.onStopObserving = ^{
stoppedOnMain = [NSThread isMainThread];
};
scheduler.onDealloc = ^(BOOL onMainThread) {
releasedOnMain = onMainThread;
[released fulfill];
};
weakScheduler = scheduler;
inFlightScheduler = scheduler;
[presenter setValue:scheduler forKey:@"scheduler"];
}

@autoreleasepool {
[presenter _applicationWillTerminate];
}

XCTAssertNil(presenter.scheduler);
XCTAssertNotNil(weakScheduler);
XCTAssertNil(weakScheduler.delegate);
XCTAssertTrue(stoppedOnMain);

dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
@autoreleasepool {
inFlightScheduler = nil;
}
});
[self waitForExpectations:@[ released ] timeout:2];
XCTAssertNil(weakScheduler);
XCTAssertFalse(releasedOnMain);
}

@end
Original file line number Diff line number Diff line change
Expand Up @@ -32,11 +32,39 @@

namespace facebook::react {

struct Scheduler::DelegateState {
explicit DelegateState(
SchedulerDelegate* delegate,
std::shared_ptr<SchedulerDelegate> owner = nullptr)
: delegate(delegate), owner(std::move(owner)) {}

SchedulerDelegate* delegate;
std::shared_ptr<SchedulerDelegate> owner;
std::atomic<bool> invalidated{false};
};

Scheduler::Scheduler(
const SchedulerToolbox& schedulerToolbox,
UIManagerAnimationDelegate* animationDelegate,
SchedulerDelegate* delegate)
: runtimeExecutor_(schedulerToolbox.runtimeExecutor),
: Scheduler(schedulerToolbox, animationDelegate, delegate, nullptr) {}

Scheduler::Scheduler(
const SchedulerToolbox& schedulerToolbox,
UIManagerAnimationDelegate* animationDelegate,
std::shared_ptr<SchedulerDelegate> delegate)
: Scheduler(schedulerToolbox, animationDelegate, delegate.get(), delegate) {
}

Scheduler::Scheduler(
const SchedulerToolbox& schedulerToolbox,
UIManagerAnimationDelegate* animationDelegate,
SchedulerDelegate* delegate,
std::shared_ptr<SchedulerDelegate> owner)
: delegate_(delegate),
delegateState_(
std::make_shared<DelegateState>(delegate, std::move(owner))),
runtimeExecutor_(schedulerToolbox.runtimeExecutor),
contextContainer_(schedulerToolbox.contextContainer) {
// Creating a container for future `EventDispatcher` instance.
eventDispatcher_ = std::make_shared<std::optional<const EventDispatcher>>();
Expand Down Expand Up @@ -156,7 +184,6 @@ Scheduler::Scheduler(
std::weak_ptr<const ComponentDescriptorRegistry>(
componentDescriptorRegistry_));

delegate_ = delegate;
commitHooks_ = schedulerToolbox.commitHooks;

// Layout events (`onLayout`) are emitted as a standalone consumer of the
Expand Down Expand Up @@ -185,6 +212,8 @@ Scheduler::Scheduler(
}

Scheduler::~Scheduler() {
setDelegate(nullptr);

LOG(WARNING) << "Scheduler::~Scheduler() was called (address: " << this
<< ").";

Expand Down Expand Up @@ -278,11 +307,26 @@ Scheduler::findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(
#pragma mark - Delegate

void Scheduler::setDelegate(SchedulerDelegate* delegate) {
delegate_ = delegate;
std::shared_ptr<DelegateState> previousState;
{
std::lock_guard lock(delegateStateMutex_);
if (delegate_ == delegate) {
return;
}
previousState = std::move(delegateState_);
previousState->invalidated.store(true);
delegate_ = delegate;
delegateState_ = std::make_shared<DelegateState>(delegate);
}
}

SchedulerDelegate* Scheduler::getDelegate() const {
return delegate_;
return getDelegateState()->delegate;
}

std::shared_ptr<Scheduler::DelegateState> Scheduler::getDelegateState() const {
std::lock_guard lock(delegateStateMutex_);
return delegateState_;
}

#pragma mark - UIManagerAnimationDelegate
Expand All @@ -301,22 +345,30 @@ void Scheduler::uiManagerDidFinishTransaction(
bool mountSynchronously) {
TraceSection s("Scheduler::uiManagerDidFinishTransaction");

if (delegate_ != nullptr) {
auto delegateState = getDelegateState();
if (delegateState->delegate != nullptr) {
// This is no-op on all platforms except for Android where we need to
// observe each transaction to be able to mount correctly.
delegate_->schedulerDidFinishTransaction(mountingCoordinator);
delegateState->delegate->schedulerDidFinishTransaction(mountingCoordinator);

if (!mountSynchronously) {
auto surfaceId = mountingCoordinator->getSurfaceId();

runtimeScheduler_->scheduleRenderingUpdate(
surfaceId,
[delegate = delegate_,
[delegateState,
mountingCoordinator = std::move(mountingCoordinator)]() {
delegate->schedulerShouldRenderTransactions(mountingCoordinator);
if (!delegateState->invalidated.load()) {
delegateState->delegate->schedulerShouldRenderTransactions(
mountingCoordinator);
}
});
} else {
delegate_->schedulerShouldRenderTransactions(mountingCoordinator);
auto currentDelegateState = getDelegateState();
if (currentDelegateState->delegate != nullptr) {
currentDelegateState->delegate->schedulerShouldRenderTransactions(
mountingCoordinator);
}
}
}
}
Expand All @@ -333,15 +385,19 @@ void Scheduler::uiManagerDidDispatchCommand(
const folly::dynamic& args) {
TraceSection s(
"Scheduler::uiManagerDispatchCommand", "commandName", commandName);
if (delegate_ != nullptr) {
auto delegateState = getDelegateState();
if (delegateState->delegate != nullptr) {
auto shadowView = ShadowView(*shadowNode);
runtimeScheduler_->scheduleRenderingUpdate(
shadowNode->getSurfaceId(),
[delegate = delegate_,
[delegateState,
shadowView = std::move(shadowView),
commandName,
args]() {
delegate->schedulerDidDispatchCommand(shadowView, commandName, args);
if (!delegateState->invalidated.load()) {
delegateState->delegate->schedulerDidDispatchCommand(
shadowView, commandName, args);
}
});
}
}
Expand Down Expand Up @@ -424,13 +480,17 @@ void Scheduler::uiManagerShouldRemoveEventListener(
}

void Scheduler::uiManagerDidFinishReactCommit(const ShadowTree& shadowTree) {
if (delegate_ == nullptr) {
auto delegateState = getDelegateState();
if (delegateState->delegate == nullptr) {
return;
}

auto surfaceId = shadowTree.getSurfaceId();
runtimeScheduler_->scheduleRenderingUpdate(
surfaceId, [surfaceId, uiManager = uiManager_, delegate = delegate_]() {
surfaceId, [surfaceId, uiManager = uiManager_, delegateState]() {
if (delegateState->invalidated.load()) {
return;
}
bool promoted = false;

uiManager->getShadowTreeRegistry().visit(
Expand All @@ -439,7 +499,7 @@ void Scheduler::uiManagerDidFinishReactCommit(const ShadowTree& shadowTree) {
});

if (promoted) {
delegate->schedulerShouldMergeReactRevision(surfaceId);
delegateState->delegate->schedulerShouldMergeReactRevision(surfaceId);
}
});
}
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,7 @@

#include <atomic>
#include <memory>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <vector>
Expand Down Expand Up @@ -44,6 +45,10 @@ class Scheduler final : public UIManagerDelegate {
const SchedulerToolbox &schedulerToolbox,
UIManagerAnimationDelegate *animationDelegate,
SchedulerDelegate *delegate);
Scheduler(
const SchedulerToolbox &schedulerToolbox,
UIManagerAnimationDelegate *animationDelegate,
std::shared_ptr<SchedulerDelegate> delegate);
~Scheduler() override;

#pragma mark - Surface Management
Expand Down Expand Up @@ -123,8 +128,18 @@ class Scheduler final : public UIManagerDelegate {

private:
friend class SurfaceHandler;
struct DelegateState;

Scheduler(
const SchedulerToolbox &schedulerToolbox,
UIManagerAnimationDelegate *animationDelegate,
SchedulerDelegate *delegate,
std::shared_ptr<SchedulerDelegate> owner);
std::shared_ptr<DelegateState> getDelegateState() const;

SchedulerDelegate *delegate_;
mutable std::mutex delegateStateMutex_;
std::shared_ptr<DelegateState> delegateState_;
SharedComponentDescriptorRegistry componentDescriptorRegistry_;
RuntimeExecutor runtimeExecutor_;
std::shared_ptr<UIManager> uiManager_;
Expand Down
Loading
Loading