Revert D70200854

Summary:
This diff reverts D70200854
To revert for S494669

#bypass-github-export-checks
bypass-github-export-checks

Reviewed By: NickGerleman

Differential Revision: D70347605

fbshipit-source-id: 454cb0a8f5a7562cd6602c32f4978b129821730c

Author: generatedunixname89002005232357

packages/react-native/React/Base/UIKitProxies/RCTInitializeUIKitProxies.mm

@@ -7,6 +7,7 @@
 
 #import "RCTInitializeUIKitProxies.h"
 #import "RCTInitialAccessibilityValuesProxy.h"
+#import "RCTKeyWindowValuesProxy.h"
 #import "RCTTraitCollectionProxy.h"
 #import "RCTWindowSafeAreaProxy.h"
 
@@ -17,5 +18,6 @@ void RCTInitializeUIKitProxies(void)
     [[RCTWindowSafeAreaProxy sharedInstance] startObservingSafeArea];
     [[RCTTraitCollectionProxy sharedInstance] startObservingTraitCollection];
     [[RCTInitialAccessibilityValuesProxy sharedInstance] recordAccessibilityValues];
+    [[RCTKeyWindowValuesProxy sharedInstance] startObservingWindowSizeIfNecessary];
   });
 }

packages/react-native/React/Base/UIKitProxies/RCTKeyWindowValuesProxy.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTKeyWindowValuesProxy : NSObject
+
++ (instancetype)sharedInstance;
+
+@property (assign, readonly) CGSize windowSize;
+@property (assign, readonly) UIInterfaceOrientation currentInterfaceOrientation;
+
+- (void)startObservingWindowSizeIfNecessary;
+
+@end
+
+NS_ASSUME_NONNULL_END

packages/react-native/React/Base/UIKitProxies/RCTKeyWindowValuesProxy.mm

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTKeyWindowValuesProxy.h"
+#import <React/RCTAssert.h>
+#import <React/RCTUtils.h>
+#import <mutex>
+
+#import <React/RCTConstants.h>
+
+static NSString *const kFrameKeyPath = @"frame";
+
+@implementation RCTKeyWindowValuesProxy {
+  BOOL _isObserving;
+  std::mutex _mutex;
+  CGSize _currentWindowSize;
+  UIInterfaceOrientation _currentInterfaceOrientation;
+}
+
++ (instancetype)sharedInstance
+{
+  static RCTKeyWindowValuesProxy *sharedInstance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [RCTKeyWindowValuesProxy new];
+  });
+  return sharedInstance;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    _isObserving = NO;
+    UIView *mainWindow = RCTKeyWindow();
+    _currentWindowSize = mainWindow ? mainWindow.bounds.size : UIScreen.mainScreen.bounds.size;
+  }
+  return self;
+}
+
+- (void)startObservingWindowSizeIfNecessary
+{
+  // Accesing _isObserving must be done under the lock to avoid a race condition.
+  // We can't hold the lock while calling RCTUnsafeExecuteOnMainQueueSync.
+  // Therefore, reading/writing _isObserving is kept separate from calling RCTUnsafeExecuteOnMainQueueSync.
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (_isObserving) {
+      return;
+    }
+    _isObserving = YES;
+  }
+
+  // For backwards compatibility, we register for notifications from the main thread only.
+  // On the new architecture, we are already on the main thread and RCTUnsafeExecuteOnMainQueueSync will simply call
+  // the block.
+  RCTUnsafeExecuteOnMainQueueSync(^{
+    [RCTKeyWindow() addObserver:self forKeyPath:kFrameKeyPath options:NSKeyValueObservingOptionNew context:nil];
+  });
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(_interfaceOrientationDidChange)
+                                               name:UIApplicationDidBecomeActiveNotification
+                                             object:nil];
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary *)change
+                       context:(void *)context
+{
+  if ([keyPath isEqualToString:kFrameKeyPath]) {
+    [[NSNotificationCenter defaultCenter] postNotificationName:RCTWindowFrameDidChangeNotification object:self];
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      _currentWindowSize = RCTKeyWindow().bounds.size;
+    }
+  }
+}
+
+- (CGSize)windowSize
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (_isObserving) {
+      return _currentWindowSize;
+    }
+  }
+
+  __block CGSize size;
+  RCTUnsafeExecuteOnMainQueueSync(^{
+    size = RCTKeyWindow().bounds.size;
+  });
+  return size;
+}
+
+- (UIInterfaceOrientation)currentInterfaceOrientation
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (_isObserving) {
+      return _currentInterfaceOrientation;
+    }
+  }
+
+  __block UIInterfaceOrientation interfaceOrientation;
+  RCTUnsafeExecuteOnMainQueueSync(^{
+    interfaceOrientation = RCTKeyWindow().windowScene.interfaceOrientation;
+  });
+  return interfaceOrientation;
+}
+
+- (void)_interfaceOrientationDidChange
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  _currentInterfaceOrientation = RCTKeyWindow().windowScene.interfaceOrientation;
+}
+
+@end

packages/react-native/React/CoreModules/RCTDeviceInfo.mm

@@ -14,7 +14,9 @@
 #import <React/RCTEventDispatcherProtocol.h>
 #import <React/RCTInitializing.h>
 #import <React/RCTInvalidating.h>
+#import <React/RCTKeyWindowValuesProxy.h>
 #import <React/RCTUtils.h>
+#import <React/RCTWindowSafeAreaProxy.h>
 #import <atomic>
 
 #import "CoreModulesPlugins.h"
@@ -31,34 +33,21 @@ @implementation RCTDeviceInfo {
   std::atomic<BOOL> _invalidated;
 }
 
-static NSString *const kFrameKeyPath = @"frame";
-
 @synthesize moduleRegistry = _moduleRegistry;
 
 RCT_EXPORT_MODULE()
 
 - (instancetype)init
 {
   if (self = [super init]) {
-    [RCTKeyWindow() addObserver:self forKeyPath:kFrameKeyPath options:NSKeyValueObservingOptionNew context:nil];
+    [[RCTKeyWindowValuesProxy sharedInstance] startObservingWindowSizeIfNecessary];
   }
   return self;
 }
 
-- (void)observeValueForKeyPath:(NSString *)keyPath
-                      ofObject:(id)object
-                        change:(NSDictionary *)change
-                       context:(void *)context
-{
-  if ([keyPath isEqualToString:kFrameKeyPath]) {
-    [self interfaceFrameDidChange];
-    [[NSNotificationCenter defaultCenter] postNotificationName:RCTWindowFrameDidChangeNotification object:self];
-  }
-}
-
 + (BOOL)requiresMainQueueSetup
 {
-  return YES;
+  return NO;
 }
 
 - (dispatch_queue_t)methodQueue
@@ -92,7 +81,7 @@ - (void)initialize
 
 #if TARGET_OS_IOS
 
-  _currentInterfaceOrientation = RCTKeyWindow().windowScene.interfaceOrientation;
+  _currentInterfaceOrientation = [RCTKeyWindowValuesProxy sharedInstance].currentInterfaceOrientation;
 
   [[NSNotificationCenter defaultCenter] addObserver:self
                                            selector:@selector(interfaceFrameDidChange)
@@ -131,8 +120,6 @@ - (void)_cleanupObservers
 
   [[NSNotificationCenter defaultCenter] removeObserver:self name:RCTBridgeWillInvalidateModulesNotification object:nil];
 
-  [RCTKeyWindow() removeObserver:self forKeyPath:kFrameKeyPath];
-
 #if TARGET_OS_IOS
   [[NSNotificationCenter defaultCenter] removeObserver:self name:UIDeviceOrientationDidChangeNotification object:nil];
 #endif
@@ -145,13 +132,8 @@ static BOOL RCTIsIPhoneNotched()
 
 #if TARGET_OS_IOS
   dispatch_once(&onceToken, ^{
-    RCTAssertMainQueue();
-
     // 20pt is the top safeArea value in non-notched devices
-    UIWindow *keyWindow = RCTKeyWindow();
-    if (keyWindow) {
-      isIPhoneNotched = keyWindow.safeAreaInsets.top > 20;
-    }
+    isIPhoneNotched = [RCTWindowSafeAreaProxy sharedInstance].currentSafeAreaInsets.top > 20;
   });
 #endif
 
@@ -160,13 +142,11 @@ static BOOL RCTIsIPhoneNotched()
 
 static NSDictionary *RCTExportedDimensions(CGFloat fontScale)
 {
-  RCTAssertMainQueue();
   UIScreen *mainScreen = UIScreen.mainScreen;
   CGSize screenSize = mainScreen.bounds.size;
-  UIView *mainWindow = RCTKeyWindow();
 
   // We fallback to screen size if a key window is not found.
-  CGSize windowSize = mainWindow ? mainWindow.bounds.size : screenSize;
+  CGSize windowSize = [RCTKeyWindowValuesProxy sharedInstance].windowSize;
 
   NSDictionary<NSString *, NSNumber *> *dimsWindow = @{
     @"width" : @(windowSize.width),
@@ -202,20 +182,14 @@ - (NSDictionary *)_exportedDimensions
 
 - (NSDictionary<NSString *, id> *)getConstants
 {
-  __block NSDictionary<NSString *, id> *constants;
-  __weak __typeof(self) weakSelf = self;
-  RCTUnsafeExecuteOnMainQueueSync(^{
-    constants = @{
-      @"Dimensions" : [weakSelf _exportedDimensions],
-      // Note:
-      // This prop is deprecated and will be removed in a future release.
-      // Please use this only for a quick and temporary solution.
-      // Use <SafeAreaView> instead.
-      @"isIPhoneX_deprecated" : @(RCTIsIPhoneNotched()),
-    };
-  });
-
-  return constants;
+  return @{
+    @"Dimensions" : [self _exportedDimensions],
+    // Note:
+    // This prop is deprecated and will be removed in a future release.
+    // Please use this only for a quick and temporary solution.
+    // Use <SafeAreaView> instead.
+    @"isIPhoneX_deprecated" : @(RCTIsIPhoneNotched()),
+  };
 }
 
 - (void)didReceiveNewContentSizeMultiplier