react-native-navigation 7.21.0 → 7.22.0-snapshot.1649

package/lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationReactInitializer.java

@@ -9,67 +9,67 @@ import androidx.annotation.NonNull;
 
 public class NavigationReactInitializer implements ReactInstanceManager.ReactInstanceEventListener {
 
-	private final ReactInstanceManager reactInstanceManager;
-	private final DevPermissionRequest devPermissionRequest;
-	private boolean waitingForAppLaunchEvent = true;
-	private boolean isActivityReadyForUi = false;
+    private final ReactInstanceManager reactInstanceManager;
+    private final DevPermissionRequest devPermissionRequest;
+    private boolean waitingForAppLaunchEvent = true;
+    private boolean isActivityReadyForUi = false;
 
-	NavigationReactInitializer(ReactInstanceManager reactInstanceManager, boolean isDebug) {
-		this.reactInstanceManager = reactInstanceManager;
-		this.devPermissionRequest = new DevPermissionRequest(isDebug);
-	}
+    NavigationReactInitializer(ReactInstanceManager reactInstanceManager, boolean isDebug) {
+        this.reactInstanceManager = reactInstanceManager;
+        this.devPermissionRequest = new DevPermissionRequest(isDebug);
+    }
 
-	void onActivityCreated() {
-		reactInstanceManager.addReactInstanceEventListener(this);
-		waitingForAppLaunchEvent = true;
-	}
+    void onActivityCreated() {
+        reactInstanceManager.addReactInstanceEventListener(this);
+        waitingForAppLaunchEvent = true;
+    }
 
-	void onActivityResumed(NavigationActivity activity) {
-		if (devPermissionRequest.shouldAskPermission(activity)) {
-			devPermissionRequest.askPermission(activity);
-		} else {
-			reactInstanceManager.onHostResume(activity, activity);
+    void onActivityResumed(NavigationActivity activity) {
+        if (devPermissionRequest.shouldAskPermission(activity)) {
+            devPermissionRequest.askPermission(activity);
+        } else {
+            reactInstanceManager.onHostResume(activity, activity);
             isActivityReadyForUi = true;
-			prepareReactApp();
-		}
-	}
+            prepareReactApp();
+        }
+    }
 
-	void onActivityPaused(NavigationActivity activity) {
+    void onActivityPaused(NavigationActivity activity) {
         isActivityReadyForUi = false;
-		if (reactInstanceManager.hasStartedCreatingInitialContext()) {
-			reactInstanceManager.onHostPause(activity);
-		}
-	}
+        if (reactInstanceManager.hasStartedCreatingInitialContext()) {
+            reactInstanceManager.onHostPause(activity);
+        }
+    }
 
-	void onActivityDestroyed(NavigationActivity activity) {
-		reactInstanceManager.removeReactInstanceEventListener(this);
-		if (reactInstanceManager.hasStartedCreatingInitialContext()) {
-			reactInstanceManager.onHostDestroy(activity);
-		}
-	}
+    void onActivityDestroyed(NavigationActivity activity) {
+        reactInstanceManager.removeReactInstanceEventListener(this);
+        if (reactInstanceManager.hasStartedCreatingInitialContext()) {
+            reactInstanceManager.onHostDestroy(activity);
+        }
+    }
 
-	private void prepareReactApp() {
-		if (shouldCreateContext()) {
-			reactInstanceManager.createReactContextInBackground();
-		} else if (waitingForAppLaunchEvent) {
+    private void prepareReactApp() {
+        if (shouldCreateContext()) {
+            reactInstanceManager.createReactContextInBackground();
+        } else if (waitingForAppLaunchEvent) {
             if (reactInstanceManager.getCurrentReactContext() != null) {
-			    emitAppLaunched(reactInstanceManager.getCurrentReactContext());
+                emitAppLaunched(reactInstanceManager.getCurrentReactContext());
             }
-		}
-	}
+        }
+    }
 
-	private void emitAppLaunched(@NonNull ReactContext context) {
-	    if (!isActivityReadyForUi) return;
-		waitingForAppLaunchEvent = false;
-		new EventEmitter(context).appLaunched();
-	}
+    private void emitAppLaunched(@NonNull ReactContext context) {
+        if (!isActivityReadyForUi) return;
+        waitingForAppLaunchEvent = false;
+        new EventEmitter(context).appLaunched();
+    }
 
-	private boolean shouldCreateContext() {
-		return !reactInstanceManager.hasStartedCreatingInitialContext();
-	}
+    private boolean shouldCreateContext() {
+        return !reactInstanceManager.hasStartedCreatingInitialContext();
+    }
 
-	@Override
-	public void onReactContextInitialized(final ReactContext context) {
+    @Override
+    public void onReactContextInitialized(final ReactContext context) {
         emitAppLaunched(context);
-	}
-}
+    }
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/react/modal/Events.kt

@@ -0,0 +1,34 @@
+package com.reactnativenavigation.react.modal
+
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+open class RequestCloseModalEvent(viewTag: Int) : Event<RequestCloseModalEvent>(viewTag) {
+
+    companion object{
+        const val EVENT_NAME = "topRequestClose"
+    }
+
+    override fun getEventName(): String {
+        return EVENT_NAME
+    }
+
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+        rctEventEmitter.receiveEvent(viewTag, eventName, null)
+    }
+}
+
+open class ShowModalEvent(viewTag: Int) : Event<ShowModalEvent>(viewTag) {
+
+    companion object{
+        const val EVENT_NAME = "topShow"
+    }
+
+    override fun getEventName(): String {
+        return EVENT_NAME
+    }
+
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+        rctEventEmitter.receiveEvent(viewTag, eventName, null)
+    }
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/react/modal/ModalContentLayout.kt

@@ -0,0 +1,81 @@
+package com.reactnativenavigation.react.modal
+
+import android.content.Context
+import android.view.MotionEvent
+import android.view.View
+import com.facebook.react.bridge.*
+import com.facebook.react.uimanager.*
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.view.ReactViewGroup
+
+
+class ModalContentLayout(context: Context?) : ReactViewGroup(context), RootView{
+    private var hasAdjustedSize = false
+    private var viewWidth = 0
+    private var viewHeight = 0
+    private val mJSTouchDispatcher = JSTouchDispatcher(this)
+
+    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+        super.onSizeChanged(w, h, oldw, oldh)
+        viewWidth = w
+        viewHeight = h
+        this.updateFirstChildView()
+    }
+    private fun updateFirstChildView() {
+        if (this.childCount > 0) {
+            hasAdjustedSize = false
+            val viewTag = getChildAt(0).id
+            val reactContext: ReactContext = this.getReactContext()
+            reactContext.runOnNativeModulesQueueThread(object : GuardedRunnable(reactContext) {
+                override fun runGuarded() {
+                    val uiManager = this@ModalContentLayout.getReactContext().getNativeModule(
+                            UIManagerModule::class.java
+                    ) as UIManagerModule
+                    uiManager.updateNodeSize(
+                            viewTag,
+                            this@ModalContentLayout.viewWidth,
+                            this@ModalContentLayout.viewHeight
+                    )
+                }
+            })
+        } else {
+            hasAdjustedSize = true
+        }
+    }
+
+    override fun addView(child: View?, index: Int, params: LayoutParams?) {
+        super.addView(child, index, params)
+        if (hasAdjustedSize) {
+            updateFirstChildView()
+        }
+    }
+    override fun onChildStartedNativeGesture(androidEvent: MotionEvent?) {
+        mJSTouchDispatcher.onChildStartedNativeGesture(androidEvent, this.getEventDispatcher())
+    }
+    override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {}
+    private fun getEventDispatcher(): EventDispatcher? {
+        val reactContext: ReactContext = this.getReactContext()
+        return reactContext.getNativeModule(UIManagerModule::class.java)!!.eventDispatcher
+    }
+
+
+    override fun handleException(t: Throwable?) {
+        getReactContext().handleException(RuntimeException(t))
+    }
+
+    private fun getReactContext(): ReactContext {
+        return this.context as ReactContext
+    }
+
+    override fun onInterceptTouchEvent(event: MotionEvent?): Boolean {
+        mJSTouchDispatcher.handleTouchEvent(event, getEventDispatcher())
+        return super.onInterceptTouchEvent(event)
+    }
+
+    override fun onTouchEvent(event: MotionEvent?): Boolean {
+        mJSTouchDispatcher.handleTouchEvent(event, getEventDispatcher())
+        super.onTouchEvent(event)
+        return true
+    }
+
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/react/modal/ModalFrameLayout.kt

@@ -0,0 +1,19 @@
+package com.reactnativenavigation.react.modal
+
+import android.widget.FrameLayout
+import com.facebook.react.bridge.ReactContext
+import com.reactnativenavigation.utils.StatusBarUtils
+
+class ModalFrameLayout(context: ReactContext) : FrameLayout(context) {
+    val modalContentLayout = ModalContentLayout(context)
+
+    init {
+        addView(modalContentLayout, MarginLayoutParams(MarginLayoutParams.WRAP_CONTENT, MarginLayoutParams.WRAP_CONTENT)
+            .apply {
+                val translucent = context.currentActivity?.window?.let {
+                    StatusBarUtils.isTranslucent(context.currentActivity?.window)
+                } ?: false
+                topMargin = if (translucent) 0 else StatusBarUtils.getStatusBarHeight(context)
+            })
+    }
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/react/modal/ModalHostLayout.kt

@@ -0,0 +1,78 @@
+package com.reactnativenavigation.react.modal
+
+import android.annotation.SuppressLint
+import android.annotation.TargetApi
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewStructure
+import android.view.accessibility.AccessibilityEvent
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.ThemedReactContext
+import com.reactnativenavigation.options.Options
+import com.reactnativenavigation.options.params.Bool
+import com.reactnativenavigation.utils.CompatUtils
+import com.reactnativenavigation.viewcontrollers.viewcontroller.YellowBoxDelegate
+import com.reactnativenavigation.viewcontrollers.viewcontroller.overlay.ViewControllerOverlay
+import java.util.*
+
+@SuppressLint("ViewConstructor")
+open class ModalHostLayout(reactContext: ThemedReactContext) : ViewGroup(reactContext), LifecycleEventListener {
+    val viewController = ModalLayoutController(
+        reactContext,
+        reactContext.currentActivity, CompatUtils.generateViewId().toString(),
+        YellowBoxDelegate(reactContext), Options().apply {
+            hardwareBack.dismissModalOnPress = Bool(false)
+        }, ViewControllerOverlay(reactContext),
+        getHostId = { this.id }
+    )
+    private val mHostView = viewController.view.modalContentLayout
+
+    init {
+        (context as ReactContext).addLifecycleEventListener(this)
+    }
+
+    @TargetApi(23)
+    override fun dispatchProvideStructure(structure: ViewStructure?) {
+        mHostView.dispatchProvideStructure(structure)
+    }
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}
+
+    override fun addView(child: View?, index: Int) {
+        UiThreadUtil.assertOnUiThread()
+        mHostView.addView(child, index)
+    }
+
+    override fun getChildCount(): Int {
+        return mHostView.childCount
+    }
+
+    override fun getChildAt(index: Int): View? {
+        return mHostView.getChildAt(index)
+    }
+
+    override fun removeView(child: View?) {
+        UiThreadUtil.assertOnUiThread()
+        mHostView.removeView(child)
+    }
+
+    override fun removeViewAt(index: Int) {
+        UiThreadUtil.assertOnUiThread()
+        val child = getChildAt(index)
+        mHostView.removeView(child)
+    }
+
+    override fun addChildrenForAccessibility(outChildren: ArrayList<View?>?) {}
+
+    override fun dispatchPopulateAccessibilityEvent(event: AccessibilityEvent?): Boolean { return false }
+
+    open fun onDropInstance() { (this.context as ReactContext).removeLifecycleEventListener(this) }
+
+    override fun onHostResume() {}
+
+    override fun onHostPause() {}
+
+    override fun onHostDestroy() { onDropInstance() }
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/react/modal/ModalLayoutController.kt

@@ -0,0 +1,51 @@
+package com.reactnativenavigation.react.modal
+
+import android.app.Activity
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerModule
+import com.reactnativenavigation.options.Options
+import com.reactnativenavigation.react.Constants
+import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
+import com.reactnativenavigation.viewcontrollers.viewcontroller.YellowBoxDelegate
+import com.reactnativenavigation.viewcontrollers.viewcontroller.overlay.ViewControllerOverlay
+
+class ModalLayoutController(
+    val reactContext: ReactContext,
+    activity: Activity?,
+    id: String?,
+    yellowBoxDelegate: YellowBoxDelegate?,
+    initialOptions: Options?,
+    overlay: ViewControllerOverlay?,
+    val getHostId: () -> Int
+) : ViewController<ModalFrameLayout>(activity, id, yellowBoxDelegate, initialOptions, overlay) {
+    override fun isViewShown(): Boolean {
+        return !isDestroyed && view != null && view!!.isShown
+    }
+
+    override fun isRendered(): Boolean {
+        return isViewCreated
+    }
+
+    override fun getCurrentComponentName(): String = "ModalLayoutController"
+
+
+    override fun createView(): ModalFrameLayout {
+        return ModalFrameLayout(reactContext)
+    }
+
+    override fun sendOnNavigationButtonPressed(buttonId: String?) {
+        if (buttonId == Constants.HARDWARE_BACK_BUTTON_ID) {
+            val dispatcher = reactContext.getNativeModule(
+                UIManagerModule::class.java
+            ).eventDispatcher
+            dispatcher.dispatchEvent(RequestCloseModalEvent(getHostId()))
+        }
+    }
+
+    fun sendShowEvent() {
+        val dispatcher = reactContext.getNativeModule(
+            UIManagerModule::class.java
+        ).eventDispatcher
+        dispatcher.dispatchEvent(ShowModalEvent(getHostId()))
+    }
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/react/modal/ModalViewManager.kt

@@ -0,0 +1,131 @@
+package com.reactnativenavigation.react.modal
+
+import android.content.Context
+import android.graphics.Point
+import android.view.WindowManager
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ReactShadowNodeImpl
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.reactnativenavigation.options.ModalPresentationStyle
+import com.reactnativenavigation.options.Options
+import com.reactnativenavigation.options.params.Bool
+import com.reactnativenavigation.options.parseTransitionAnimationOptions
+import com.reactnativenavigation.options.parsers.JSONParser
+import com.reactnativenavigation.react.CommandListener
+import com.reactnativenavigation.react.CommandListenerAdapter
+import com.reactnativenavigation.utils.StatusBarUtils
+import com.reactnativenavigation.viewcontrollers.navigator.Navigator
+
+private const val MODAL_MANAGER_NAME = "RNNModalViewManager"
+
+@ReactModule(name = MODAL_MANAGER_NAME)
+class ModalViewManager(private val navigator: Navigator) : ViewGroupManager<ModalHostLayout>() {
+    private val jsonParser = JSONParser()
+    override fun getName(): String = MODAL_MANAGER_NAME
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ModalHostLayout {
+        return ModalHostLayout(reactContext)
+    }
+
+    override fun createShadowNodeInstance(): LayoutShadowNode {
+        return ModalHostShadowNode()
+    }
+
+    override fun getShadowNodeClass(): Class<out LayoutShadowNode> {
+        return ModalHostShadowNode::class.java
+    }
+
+    override fun onDropViewInstance(modal: ModalHostLayout) {
+        super.onDropViewInstance(modal)
+        navigator.dismissModal(modal.viewController.id, CommandListenerAdapter())
+        modal.onDropInstance()
+    }
+
+    override fun onAfterUpdateTransaction(modal: ModalHostLayout) {
+        super.onAfterUpdateTransaction(modal)
+        navigator.showModal(modal.viewController, CommandListenerAdapter(object : CommandListener {
+            override fun onSuccess(childId: String?) {
+                modal.viewController.sendShowEvent()
+            }
+
+            override fun onError(message: String?) {
+            }
+
+        }))
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        return MapBuilder.builder<String, Any>()
+            .put(RequestCloseModalEvent.EVENT_NAME, MapBuilder.of("registrationName", "onRequestClose"))
+            .put(ShowModalEvent.EVENT_NAME, MapBuilder.of("registrationName", "onShow"))
+            .build()
+    }
+
+    @ReactProp(name = "animation")
+    fun setAnimation(modal: ModalHostLayout, animation: ReadableMap) {
+        modal.viewController.mergeOptions(Options().apply {
+           val animationJson = jsonParser.parse(animation)
+            val showModal = parseTransitionAnimationOptions(animationJson.optJSONObject("showModal"))
+            val dismissModal = parseTransitionAnimationOptions(animationJson.optJSONObject("dismissModal"))
+            this.animations.showModal = showModal
+            this.animations.dismissModal = dismissModal
+        })
+    }
+    @ReactProp(name = "blurOnUnmount")
+    fun setBlurOnUnmount(modal: ModalHostLayout, blurOnUnmount: Boolean) {
+       modal.viewController.mergeOptions(Options().apply {
+           this.modal.blurOnUnmount = Bool(blurOnUnmount)
+       })
+    }
+    @ReactProp(name = "transparent")
+    fun setTransparent(modal: ModalHostLayout, transparent: Boolean) {
+        modal.viewController.mergeOptions(Options().apply {
+            this.modal.presentationStyle = if(transparent) ModalPresentationStyle.OverCurrentContext else ModalPresentationStyle.None
+        })
+    }
+}
+
+private fun getModalHostSize(context: Context): Point {
+    val MIN_POINT = Point()
+    val MAX_POINT = Point()
+    val SIZE_POINT = Point()
+    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    val display = Assertions.assertNotNull(wm).defaultDisplay
+    // getCurrentSizeRange will return the min and max width and height that the window can be
+    display.getCurrentSizeRange(MIN_POINT, MAX_POINT)
+    // getSize will return the dimensions of the screen in its current orientation
+    display.getSize(SIZE_POINT)
+    val attrs = intArrayOf(android.R.attr.windowFullscreen)
+    val theme = context.theme
+    val ta = theme.obtainStyledAttributes(attrs)
+    val windowFullscreen = ta.getBoolean(0, false)
+
+    // We need to add the status bar height to the height if we have a fullscreen window,
+    // because Display.getCurrentSizeRange doesn't include it.
+    var statusBarHeight = 0
+    if (windowFullscreen) {
+        statusBarHeight = StatusBarUtils.getStatusBarHeight(context)
+    }
+    return if (SIZE_POINT.x < SIZE_POINT.y) {
+        // If we are vertical the width value comes from min width and height comes from max height
+        Point(MIN_POINT.x, MAX_POINT.y + statusBarHeight)
+    } else {
+        // If we are horizontal the width value comes from max width and height comes from min height
+        Point(MAX_POINT.x, MIN_POINT.y + statusBarHeight)
+    }
+}
+
+private class ModalHostShadowNode : LayoutShadowNode() {
+    override fun addChildAt(child: ReactShadowNodeImpl, i: Int) {
+        super.addChildAt(child, i)
+        val modalSize = getModalHostSize(themedContext)
+        child.setStyleWidth(modalSize.x.toFloat())
+        child.setStyleHeight(modalSize.y.toFloat())
+    }
+}

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/CoordinatorLayoutUtils.java

@@ -13,7 +13,7 @@ public class CoordinatorLayoutUtils {
         return new CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
     }
 
-    public static CoordinatorLayout.LayoutParams matchParentWithBehaviour(CoordinatorLayout.Behavior behavior) {
+    public static CoordinatorLayout.LayoutParams matchParentWithBehaviour(CoordinatorLayout.Behavior<?> behavior) {
         CoordinatorLayout.LayoutParams lp = new CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
         lp.setBehavior(behavior);
         return lp;

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/OutlineProvider.kt

@@ -2,7 +2,6 @@ package com.reactnativenavigation.utils
 
 import android.graphics.Outline
 import android.os.Build
-import android.util.Log
 import android.view.View
 import android.view.ViewOutlineProvider
 import androidx.annotation.RequiresApi

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/ReflectionUtils.java

@@ -33,7 +33,7 @@ public class ReflectionUtils {
 		return null;
 	}
 
-	private static Field getField(Class clazz, String name) {
+	private static Field getField(Class<?> clazz, String name) {
 		try {
 			return clazz.getDeclaredField(name);
 		} catch (NoSuchFieldException nsfe) {

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/RenderChecker.java

@@ -7,7 +7,7 @@ import java.util.Collection;
 import static com.reactnativenavigation.utils.CollectionUtils.reduce;
 
 public class RenderChecker {
-    public boolean areRendered(Collection<ViewController> components) {
+    public boolean areRendered(Collection<ViewController<?>> components) {
         return reduce(components, true, ViewController::isRendered);
     }
 }

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/StatusBarUtils.java

@@ -9,8 +9,6 @@ import android.view.WindowManager;
 import static android.view.WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;
 import static com.reactnativenavigation.utils.UiUtils.dpToPx;
 
-import androidx.annotation.VisibleForTesting;
-
 public class StatusBarUtils {
     private static final int STATUS_BAR_HEIGHT_M = 24;
     private static final int STATUS_BAR_HEIGHT_L = 25;

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/UiUtils.java

@@ -11,7 +11,6 @@ import android.view.WindowManager;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.annotation.VisibleForTesting;
 
 public class UiUtils {
     private static final int DEFAULT_TOOLBAR_HEIGHT = 56;
@@ -81,13 +80,13 @@ public class UiUtils {
         });
     }
 
-	public static void runOnMainThread(Runnable runnable) {
-		new Handler(Looper.getMainLooper()).post(runnable);
-	}
+    public static void runOnMainThread(Runnable runnable) {
+        new Handler(Looper.getMainLooper()).post(runnable);
+    }
 
-	public static float getWindowHeight(Context context) {
+    public static float getWindowHeight(Context context) {
         return getDisplayMetrics(context).heightPixels;
-	}
+    }
 
     public static float getWindowWidth(Context context) {
         return getDisplayMetrics(context).widthPixels;

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/ViewParent.kt

@@ -2,9 +2,6 @@ package com.reactnativenavigation.utils
 
 import android.view.View
 import android.view.ViewParent
-import androidx.core.view.doOnLayout
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 
 val ViewParent.scaleX: Float
     get() = (this as View).scaleX

package/lib/android/app/src/main/java/com/reactnativenavigation/utils/ViewUtils.java

@@ -3,7 +3,6 @@ package com.reactnativenavigation.utils;
 import android.graphics.Point;
 import android.view.View;
 import android.view.ViewGroup;
-import android.view.ViewManager;
 import android.view.ViewParent;
 
 import com.facebook.react.views.view.ReactViewBackgroundDrawable;
@@ -34,11 +33,11 @@ public class ViewUtils {
         return null;
     }
 
-    public static <T> List<T> findChildrenByClassRecursive(ViewGroup root, Class clazz) {
+    public static <T> List<T> findChildrenByClassRecursive(ViewGroup root, Class<?> clazz) {
         return findChildrenByClassRecursive(root, clazz, child -> true);
     }
 
-    public static <T> List<T> findChildrenByClassRecursive(ViewGroup root, Class clazz, Matcher<T> matcher) {
+    public static <T> List<T> findChildrenByClassRecursive(ViewGroup root, Class<?> clazz, Matcher<T> matcher) {
         ArrayList<T> ret = new ArrayList<>();
         for (int i = 0; i < root.getChildCount(); i++) {
             View view = root.getChildAt(i);
@@ -56,7 +55,7 @@ public class ViewUtils {
         return findChildrenByClass(root, clazz, child -> true);
     }
 
-    public static <T> List<T> findChildrenByClass(ViewGroup root, Class clazz, Matcher<T> matcher) {
+    public static <T> List<T> findChildrenByClass(ViewGroup root, Class<?> clazz, Matcher<T> matcher) {
         List<T> ret = new ArrayList<>();
         for (int i = 0; i < root.getChildCount(); i++) {
             View child = root.getChildAt(i);
@@ -114,7 +113,7 @@ public class ViewUtils {
         }
         throw new RuntimeException(view.getBackground().getClass().getSimpleName() + " is not ReactViewBackgroundDrawable");
     }
-    
+
 
     public static boolean isVisible(View view) {
         return perform(view, false, v -> v.getVisibility() == View.VISIBLE);