@sdcx/overlay 0.5.0 → 1.0.0

package/android/src/main/java/com/reactnative/overlay/OverlayRootView.java

@@ -1,119 +1,101 @@
 package com.reactnative.overlay;
 
 import android.content.Context;
-import android.os.Bundle;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
-import android.view.ViewTreeObserver;
-
-import androidx.annotation.Nullable;
-
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactRootView;
-
-import java.lang.reflect.Method;
-
-public class OverlayRootView extends ReactRootView {
-
-    public OverlayRootView(Context context) {
-        super(context);
-    }
-
-    public OverlayRootView(Context context, AttributeSet attrs) {
-        super(context, attrs);
-    }
-
-    public OverlayRootView(Context context, AttributeSet attrs, int defStyle) {
-        super(context, attrs, defStyle);
-    }
-
-    private boolean shouldConsumeTouchEvent = true;
-
-    public void setShouldConsumeTouchEvent(boolean consume) {
-        this.shouldConsumeTouchEvent = consume;
-    }
-
-    @Override
-    public boolean onTouchEvent(MotionEvent ev) {
-        int action = ev.getAction() & MotionEvent.ACTION_MASK;
-        if (action == MotionEvent.ACTION_DOWN) {
-            onChildStartedNativeGesture(ev);
-        }
-        return shouldConsumeTouchEvent;
-    }
-
-    @Override
-    protected void onAttachedToWindow() {
-        super.onAttachedToWindow();
-        removeOnGlobalLayoutListener();
-    }
-
-    @Override
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        removeOnGlobalLayoutListener();
-    }
-
-    @Override
-    public void startReactApplication(ReactInstanceManager reactInstanceManager, String moduleName, @Nullable Bundle initialProperties) {
-        super.startReactApplication(reactInstanceManager, moduleName, initialProperties);
-        removeOnGlobalLayoutListener();
-    }
-
-    // 避免 reload 时，重复 run 的问题
-    private boolean shouldRunApplication = true;
-
-    @Override
-    public void runApplication() {
-        if (shouldRunApplication) {
-            shouldRunApplication = false;
-            super.runApplication();
-        }
-    }
-
-    private boolean hbd_isAttachedToReactInstance;
-
-    @Override
-    public void onAttachedToReactInstance() {
-        super.onAttachedToReactInstance();
-        hbd_isAttachedToReactInstance = true;
-    }
-
-    @Override
-    public void setAppProperties(@Nullable Bundle appProperties) {
-        if (hbd_isAttachedToReactInstance) {
-            shouldRunApplication = true;
-            super.setAppProperties(appProperties);
-        }
-    }
-
-    @Override
-    public void unmountReactApplication() {
-        super.unmountReactApplication();
-        removeOnGlobalLayoutListener();
-    }
-
-    private ViewTreeObserver.OnGlobalLayoutListener mGlobalLayoutListener;
-
-    private ViewTreeObserver.OnGlobalLayoutListener getGlobalLayoutListener() {
-        if (mGlobalLayoutListener == null) {
-            try {
-                Method method = ReactRootView.class.getDeclaredMethod("getCustomGlobalLayoutListener");
-                method.setAccessible(true);
-                mGlobalLayoutListener = (ViewTreeObserver.OnGlobalLayoutListener) method.invoke(this);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-        return mGlobalLayoutListener;
-    }
-
-    void addOnGlobalLayoutListener() {
-        removeOnGlobalLayoutListener();
-        getViewTreeObserver().addOnGlobalLayoutListener(getGlobalLayoutListener());
-    }
-
-    void removeOnGlobalLayoutListener() {
-        getViewTreeObserver().removeOnGlobalLayoutListener(getGlobalLayoutListener());
-    }
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.runtime.ReactSurfaceView;
+import com.facebook.react.uimanager.TouchTargetHelper;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.common.UIManagerType;
+
+public class OverlayRootView extends FrameLayout {
+	private static final String TAG = "Overlay";
+
+	public OverlayRootView(Context context) {
+		super(context);
+	}
+
+	public OverlayRootView(Context context, AttributeSet attrs) {
+		super(context, attrs);
+	}
+
+	public OverlayRootView(Context context, AttributeSet attrs, int defStyle) {
+		super(context, attrs, defStyle);
+	}
+
+	private boolean passThroughTouches = false;
+
+	public void setPassThroughTouches(boolean passThroughTouches) {
+		this.passThroughTouches = passThroughTouches;
+	}
+
+	ReactSurfaceView reactSurfaceView;
+
+	@Override
+	public boolean dispatchTouchEvent(MotionEvent ev) {
+		// FLog.i(TAG, "dispatchTouchEvent");
+		if (reactSurfaceView == null) {
+			reactSurfaceView = findReactSurfaceView(this);
+		}
+
+		if (reactSurfaceView != null) {
+			if (shouldPassTouches(ev)) return false;
+		}
+
+		return super.dispatchTouchEvent(ev);
+	}
+
+	private boolean shouldPassTouches(MotionEvent ev) {
+		if (!passThroughTouches) {
+			return false;
+		}
+
+		int action = ev.getAction() & MotionEvent.ACTION_MASK;
+		if (action != MotionEvent.ACTION_DOWN) {
+			return false;
+		}
+
+		int tag = TouchTargetHelper.findTargetTagForTouch(ev.getX(), ev.getY(), reactSurfaceView.getRootViewGroup());
+		// FLog.i(TAG, "findTargetTagForTouch:" + tag);
+		UIManager uiManager = UIManagerHelper.getUIManager(reactSurfaceView.getCurrentReactContext(), UIManagerType.FABRIC);
+		if (uiManager == null) {
+			return false;
+		}
+
+		View view = uiManager.resolveView(tag);
+		if (view == null) {
+			return false;
+		}
+
+		// FLog.i(TAG, "child name:%s", view.getClass().getSimpleName());
+		// FLog.i(TAG, "target, width:%d, height:%d", view.getWidth(), view.getHeight());
+
+		if (view == reactSurfaceView || view == reactSurfaceView.getChildAt(0)) {
+			if (view.getWidth() == reactSurfaceView.getWidth() && view.getHeight() == reactSurfaceView.getHeight()) {
+				reactSurfaceView.onChildStartedNativeGesture(reactSurfaceView, ev);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private ReactSurfaceView findReactSurfaceView(ViewGroup parent) {
+		for (int i = 0; i < parent.getChildCount(); i++) {
+			View child = parent.getChildAt(i);
+			if (child instanceof ReactSurfaceView) {
+				return (ReactSurfaceView) child;
+			}
+			if (child instanceof ViewGroup) {
+				ReactSurfaceView result = findReactSurfaceView((ViewGroup) child);
+				if (result != null) return result;
+			}
+		}
+		return null;
+	}
+
 }

package/dist/NativeOverlay.d.ts

@@ -0,0 +1,11 @@
+import type { TurboModule, CodegenTypes } from 'react-native';
+export interface OverlayOptions {
+    overlayId: CodegenTypes.Int32;
+    passThroughTouches?: boolean;
+}
+export interface Spec extends TurboModule {
+    show(moduleName: string, options: OverlayOptions): void;
+    hide(moduleName: string, overlayId: CodegenTypes.Int32): void;
+}
+declare const _default: Spec;
+export default _default;

package/dist/NativeOverlay.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('OverlayHost');

package/{lib → dist}/index.d.ts

@@ -1,8 +1,5 @@
-import { Insets } from 'react-native';
-export interface OverlayOptions {
-    id: number;
-    passThroughTouches?: boolean;
-}
+import { type Insets } from 'react-native';
+import { type OverlayOptions } from './NativeOverlay';
 export interface OverlayProps extends OverlayOptions {
     insets: Insets;
 }

package/dist/index.js

@@ -0,0 +1,9 @@
+import NativeOverlay from './NativeOverlay';
+function show(moduleName, options) {
+    NativeOverlay.show(moduleName, options);
+}
+function hide(moduleName, id) {
+    NativeOverlay.hide(moduleName, id);
+}
+const Overlay = { show, hide };
+export { Overlay };

package/ios/Overlay/RNOverlay.h

@@ -1,9 +1,10 @@
 #import <UIKit/UIKit.h>
-#import <React/RCTBridge.h>
+
+@class RCTHost;
 
 @interface RNOverlay : NSObject
 
-- (instancetype)initWithModuleName:(NSString *)moduleName bridge:(RCTBridge *)bridge;
+- (instancetype)initWithModuleName:(NSString *)moduleName host:(RCTHost *)rctHost;
 
 - (void)show:(NSDictionary *)props options:(NSDictionary *)options;
 

package/ios/Overlay/RNOverlay.mm

@@ -0,0 +1,58 @@
+#import "RNOverlay.h"
+#import "RNOverlayHostingView.h"
+
+#import <React-RuntimeApple/ReactCommon/RCTHost.h>
+#import <React/RCTUtils.h>
+
+@interface RNOverlay ()
+
+@property(nonatomic, weak) UIWindow *keyWindow;
+@property(nonatomic, strong) RNOverlayHostingView *rootView;
+@property(nonatomic, copy) NSString *moduleName;
+@property(nonatomic, weak) RCTHost *rctHost;
+
+@end
+
+@implementation RNOverlay
+
+- (instancetype)initWithModuleName:(NSString *)moduleName host:(RCTHost *)rctHost {
+	if (self = [super init]) {
+		_moduleName = moduleName;
+		_rctHost = rctHost;
+	}
+	return self;
+}
+
+- (void)show:(NSDictionary *)props options:(NSDictionary *)options {
+	RNOverlayHostingView *rctView = [self createReactRootView:props];
+    rctView.passThroughTouches = [options[@"passThroughTouches"] boolValue];
+    rctView.frame = [UIScreen mainScreen].bounds;
+    self.rootView = rctView;
+
+	UIWindow *keyWindow = RCTKeyWindow();
+    [keyWindow addSubview:rctView];
+}
+
+- (void)hide {
+    if (self.rootView) {
+        [self.rootView removeFromSuperview];
+        self.rootView = nil;
+    }
+}
+
+- (void)update {
+	UIWindow *keyWindow = RCTKeyWindow();
+    if (keyWindow != self.keyWindow) {
+        [self.rootView removeFromSuperview];
+        [keyWindow addSubview:self.rootView];
+        self.keyWindow = keyWindow;
+    }
+}
+
+- (RNOverlayHostingView *)createReactRootView:(NSDictionary *)props {
+	RCTFabricSurface *surface = [self.rctHost createSurfaceWithModuleName:self.moduleName initialProperties:props];
+	RNOverlayHostingView *rootView = [[RNOverlayHostingView alloc] initWithSurface:(id)surface];
+    return rootView;
+}
+
+@end

package/ios/Overlay/RNOverlayHostingView.h

@@ -0,0 +1,24 @@
+#import <UIKit/UIKit.h>
+
+#import <React/RCTSurfaceDelegate.h>
+#import <React/RCTSurfaceProtocol.h>
+#import <React/RCTSurfaceSizeMeasureMode.h>
+#import <React/RCTSurfaceStage.h>
+
+@class RCTSurface;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNOverlayHostingView : UIView <RCTSurfaceDelegate>
+
+- (instancetype)initWithSurface:(id<RCTSurfaceProtocol>)surface;
+
+@property (nonatomic, strong, readonly) id<RCTSurfaceProtocol> surface;
+
+@property (nonatomic, assign) BOOL passThroughTouches;
+
+@property (nonatomic, assign) RCTSurfaceSizeMeasureMode sizeMeasureMode;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Overlay/RNOverlayHostingView.mm

@@ -0,0 +1,194 @@
+#import "RNOverlayHostingView.h"
+
+#import "RCTConstants.h"
+#import "RCTDefines.h"
+#import "RCTSurface.h"
+#import "RCTSurfaceDelegate.h"
+#import "RCTSurfaceView.h"
+#import "RCTUtils.h"
+
+@interface RNOverlayHostingView ()
+
+@property (nonatomic, assign) BOOL isSurfaceViewVisible;
+
+@end
+
+@implementation RNOverlayHostingView {
+	UIView *_Nullable _surfaceView;
+	RCTSurfaceStage _stage;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)
+RCT_NOT_IMPLEMENTED(-(nullable instancetype)initWithCoder : (NSCoder *)coder)
+
+- (instancetype)initWithSurface:(id<RCTSurfaceProtocol>)surface {
+	return [self initWithSurface:surface sizeMeasureMode:RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact];
+}
+
+- (instancetype)initWithSurface:(id<RCTSurfaceProtocol>)surface
+                sizeMeasureMode:(RCTSurfaceSizeMeasureMode)sizeMeasureMode {
+	if (self = [super initWithFrame:CGRectZero]) {
+		_surface = surface;
+		_sizeMeasureMode = sizeMeasureMode;
+		_surface.delegate = self;
+		_stage = surface.stage;
+		[self _updateViews];
+	}
+
+	return self;
+}
+
+- (void)dealloc {
+	[_surface stop];
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
+	UIView *hitView = [super hitTest:point withEvent:event];
+	if (self.passThroughTouches && [self shouldPassTouches:hitView]) {
+		return nil;
+	}
+	return hitView;
+}
+
+- (BOOL)shouldPassTouches:(UIView *)hitView {
+	if (!hitView) {
+		return true;
+	}
+
+	// RCTRootComponentView
+	if (hitView == _surfaceView || hitView == [_surfaceView.subviews firstObject]) {
+		return true;
+	}
+
+	return false;
+}
+
+- (void)layoutSubviews {
+	[super layoutSubviews];
+
+	CGSize minimumSize;
+	CGSize maximumSize;
+
+	RCTSurfaceMinimumSizeAndMaximumSizeFromSizeAndSizeMeasureMode(
+	  self.bounds.size, _sizeMeasureMode, &minimumSize, &maximumSize);
+	CGRect windowFrame = [self.window convertRect:self.frame fromView:self.superview];
+
+	[_surface setMinimumSize:minimumSize maximumSize:maximumSize viewportOffset:windowFrame.origin];
+}
+
+- (CGSize)intrinsicContentSize {
+	if (RCTSurfaceStageIsPreparing(_stage)) {
+		return CGSizeZero;
+	}
+
+	return _surface.intrinsicSize;
+}
+
+- (CGSize)sizeThatFits:(CGSize)size {
+	if (RCTSurfaceStageIsPreparing(_stage)) {
+		return CGSizeZero;
+	}
+
+	CGSize minimumSize;
+	CGSize maximumSize;
+
+	RCTSurfaceMinimumSizeAndMaximumSizeFromSizeAndSizeMeasureMode(size, _sizeMeasureMode, &minimumSize, &maximumSize);
+
+	return [_surface sizeThatFitsMinimumSize:minimumSize maximumSize:maximumSize];
+}
+
+- (void)setStage:(RCTSurfaceStage)stage {
+	if (stage == _stage) {
+		return;
+	}
+
+	BOOL shouldInvalidateLayout = RCTSurfaceStageIsRunning(stage) != RCTSurfaceStageIsRunning(_stage) ||
+	  RCTSurfaceStageIsPreparing(stage) != RCTSurfaceStageIsPreparing(_stage);
+
+	_stage = stage;
+
+	if (shouldInvalidateLayout) {
+		[self _invalidateLayout];
+		[self _updateViews];
+	}
+}
+
+- (void)setSizeMeasureMode:(RCTSurfaceSizeMeasureMode)sizeMeasureMode {
+	if (sizeMeasureMode == _sizeMeasureMode) {
+		return;
+	}
+
+	_sizeMeasureMode = sizeMeasureMode;
+	[self _invalidateLayout];
+}
+
+
+#pragma mark - isSurfaceViewVisible
+
+- (void)setIsSurfaceViewVisible:(BOOL)visible {
+	if (_isSurfaceViewVisible == visible) {
+		return;
+	}
+
+	_isSurfaceViewVisible = visible;
+
+	if (visible) {
+		_surfaceView = _surface.view;
+		_surfaceView.frame = self.bounds;
+		_surfaceView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+		[self addSubview:_surfaceView];
+	} else {
+		[_surfaceView removeFromSuperview];
+		_surfaceView = nil;
+	}
+}
+
+#pragma mark - UITraitCollection updates
+
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection {
+	[super traitCollectionDidChange:previousTraitCollection];
+
+	if (RCTSharedApplication().applicationState == UIApplicationStateBackground) {
+		return;
+	}
+
+	[[NSNotificationCenter defaultCenter]
+	  postNotificationName:RCTUserInterfaceStyleDidChangeNotification
+					object:self
+				  userInfo:@{
+					RCTUserInterfaceStyleDidChangeNotificationTraitCollectionKey : self.traitCollection,
+				  }];
+}
+
+#pragma mark - Private stuff
+
+- (void)_invalidateLayout {
+	[self invalidateIntrinsicContentSize];
+	[self.superview setNeedsLayout];
+}
+
+- (void)_updateViews {
+	self.isSurfaceViewVisible = RCTSurfaceStageIsRunning(_stage);
+}
+
+- (void)didMoveToWindow {
+	[super didMoveToWindow];
+	[self _updateViews];
+}
+
+#pragma mark - RCTSurfaceDelegate
+
+- (void)surface:(__unused RCTSurface *)surface didChangeStage:(RCTSurfaceStage)stage {
+	RCTExecuteOnMainQueue(^{
+		[self setStage:stage];
+	});
+}
+
+- (void)surface:(__unused RCTSurface *)surface didChangeIntrinsicSize:(__unused CGSize)intrinsicSize {
+	RCTExecuteOnMainQueue(^{
+		[self _invalidateLayout];
+	});
+}
+
+@end

package/ios/Overlay/RNOverlayModule.h

@@ -1,9 +1,14 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTInvalidating.h>
+#import <Foundation/Foundation.h>
+#import <overlay/overlay.h>
+#import <React/RCTInitializing.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface RNOverlayModule : NSObject <RCTBridgeModule, RCTInvalidating>
+@class RCTHost;
+
+@interface RNOverlayModule : NSObject <NativeOverlaySpec, RCTInvalidating>
+
+- (instancetype)initWithHost:(RCTHost *)host;
 
 @end
 

package/ios/Overlay/RNOverlayModule.mm

@@ -0,0 +1,101 @@
+#import "RNOverlayModule.h"
+#import "RNOverlay.h"
+
+#import <React/RCTLog.h>
+#import <React-RuntimeApple/ReactCommon/RCTHost.h>
+#import <React/RCTConversions.h>
+
+NSString* genKey(NSString* moduleName, NSNumber* id) {
+    return [NSString stringWithFormat:@"%@-%@", moduleName, id];
+}
+
+@interface RNOverlayModule ()
+
+@property(nonatomic, strong) NSMutableDictionary *overlays;
+@property(nonatomic, strong) RCTHost *host;
+
+@end
+
+@implementation RNOverlayModule
+
+
++ (BOOL)requiresMainQueueSetup {
+	return YES;
+}
+
+- (dispatch_queue_t)methodQueue {
+	return dispatch_get_main_queue();
+}
+
+RCT_EXPORT_MODULE(OverlayHost)
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeOverlaySpecJSI>(params);
+}
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _overlays = [[NSMutableDictionary alloc] init];
+    }
+    return self;
+}
+
+- (instancetype)initWithHost:(RCTHost *)host {
+	if (self = [super init]) {
+		_overlays = [[NSMutableDictionary alloc] init];
+		_host = host;
+	}
+	return self;
+}
+
+- (void)handleReload {
+    for (NSString *key in self.overlays) {
+        RNOverlay *overlay = self.overlays[key];
+        [overlay hide];
+    }
+    [self.overlays removeAllObjects];
+}
+
+- (void)invalidate {
+    [self handleReload];
+}
+
+- (void)show:(NSString *)moduleName options:(JS::NativeOverlay::OverlayOptions &)options {
+	NSString* key = genKey(moduleName, @(options.overlayId()));
+	RNOverlay *overlay = self.overlays[key];
+	if (overlay != nil) {
+		[overlay update];
+		return;
+	}
+
+	overlay = [[RNOverlay alloc] initWithModuleName:moduleName host:self.host];
+	self.overlays[key] = overlay;
+
+	UIWindow *window = RCTKeyWindow();
+	UIEdgeInsets safeAreaInsets = window.safeAreaInsets;
+	NSDictionary* insets = @{
+	  @"top" : @(safeAreaInsets.top),
+	  @"right" : @(safeAreaInsets.right),
+	  @"bottom" : @(safeAreaInsets.bottom),
+	  @"left" : @(safeAreaInsets.left),
+	};
+
+	NSDictionary *props = @{
+		@"insets": insets,
+		@"overlayId": @(options.overlayId()),
+		@"passThroughTouches": @((BOOL)options.passThroughTouches())
+	};
+	[overlay show:props options:props];
+}
+
+- (void)hide:(NSString *)moduleName overlayId:(NSInteger)overlayId {
+	NSString* key = genKey(moduleName, @(overlayId));
+	RNOverlay *overlay = self.overlays[key];
+	if (!overlay) {
+		return;
+	}
+	[self.overlays removeObjectForKey:key];
+	[overlay hide];
+}
+
+@end