react-native-screens 1.0.0-alpha.2 → 1.0.0-alpha.23

package/README.md

@@ -1,3 +1,165 @@
 # react-native-screens
 
-First incomplete navigation solution for your React Native app
+This project aims to expose native navigation container components to React Native. It is not designed to be used as a standalone library but rather as a dependency of a [full-featured navigation library](https://github.com/react-navigation/react-navigation).
+
+## How can I take advantage of that?
+
+Screens are already integrated with the React Native's most popular navigation library [react-navigation](https://github.com/react-navigation/react-navigation) and [Expo](https://expo.io).
+Read usage guide depending on if you are [using Expo](#usage-in-expo-with-react-navigation) or [not](#usage-with-react-navigation-without-expo).
+
+## Usage with [react-navigation](https://github.com/react-navigation/react-navigation) (without Expo)
+
+Screens support is built into [react-navigation](https://github.com/react-navigation/react-navigation) starting from version [2.14.0](https://github.com/react-navigation/react-navigation/releases/tag/2.14.0) for all the different navigator types (stack, tab, drawer, etc). We plan on adding it to other navigators in near future.
+
+To configure react-navigation to use screens instead of plain RN Views for rendering screen views, follow the steps below:
+
+1. Add this library as a depedency to your project:
+```
+yarn add react-native-screens
+```
+
+2. Link native modules this library ships with into your app:
+```
+react-native link react-native-screens
+```
+
+ > If you are not familiar with the concept of linking libraries [read on here](https://facebook.github.io/react-native/docs/linking-libraries-ios).
+
+3. Enable screens support before any of your navigation screen renders. Add the following code to your main application file (e.g. App.js):
+```js
+import { useScreens } from 'react-native-screens';
+
+useScreens();
+```
+
+Note that the above code need to execute before first render of a navigation screen. You can check Example's app [App.js](https://github.com/kmagiera/react-native-screens/blob/master/Example/App.js#L16) file as a reference.
+
+4. On Android change your main activity class to extend [`ReactFragmentActivity`](https://github.com/facebook/react-native/blob/0.57-stable/ReactAndroid/src/main/java/com/facebook/react/ReactFragmentActivity.java). The file you'll have to change is likely called `MainActivity.java` unless you customized it after creating your project:
+```diff
+-import com.facebook.react.ReactActivity;
++import android.os.Bundle;
++import com.facebook.react.ReactFragmentActivity;
+ import com.facebook.react.ReactActivityDelegate;
+
+-public class MainActivity extends ReactActivity {
++public class MainActivity extends ReactFragmentActivity {
++
++    @Override
++    protected void onCreate(Bundle savedInstanceState) {
++        super.onCreate(null);
++    }
+
+     @Override
+     protected String getMainComponentName() {
+```
+
+5. Make sure that the version of [react-navigation](https://github.com/react-navigation/react-navigation) you are using is 2.14.0 or higher
+
+5. You are all set 🎉 – when screens are enabled in your application code react-navigation will automatically use them instead of relying on plain React Native Views.
+
+## Usage in Expo with [react-navigation](https://github.com/react-navigation/react-navigation)
+
+Screens support is built into Expo [SDK 30](https://blog.expo.io/expo-sdk-30-0-0-is-now-available-e64d8b1db2a7) and react-navigation starting from [2.14.0](https://github.com/react-navigation/react-navigation/releases/tag/2.14.0). Make sure your app use these versions before you start.
+
+1. Add screens library as dependency to your project – you can skip this step when using snack as the dependency will be imported when you import it in one of the JS files
+```
+yarn add react-native-screens
+```
+
+2. Open your App.js file and add the following snippet somewhere near the top of the file (e.g. right after import statements):
+```
+import { useScreens } from 'react-native-screens';
+
+useScreens();
+```
+
+3. That's all 🎉 – enjoy faster navigation in your Expo app. Keep in mind screens are in pretty early phase so please report if you discover some issues.
+
+## Interop with [react-native-navigation](https://github.com/wix/react-native-navigation)
+
+React-native-navigation library already uses native containers for rendering navigation scenes so wrapping these scenes with `<ScreenContainer>` or `<Screen>` component does not provide any benefits. Yet if you would like to build a component that uses screens primitives under the hood (for example a view pager component) it is safe to use `<ScreenContainer>` and `<Screen>` components for that as these work out of the box when rendered on react-native-navigation scenes.
+
+## Interop with other libraries
+
+This library should work out of the box with all existing react-native libraries. If you expirience problems with interoperability please [report an issue](https://github.com/kmagiera/react-native-screens/issues).
+
+
+## Guide for navigation library authors
+
+If you are building navigation library you may want to use react-native-screens to have a control which parts of the react component tree are attached to the native view hierarchy.
+To do that react-native-screens provides you with two components documented below:
+
+### `<ScreenContainer/>`
+
+This component is a container for one or more `Screen` components.
+It does not accept other component types are direct children.
+The role of container is to control which of its children screens should be attached to the view hierarchy.
+It does that by monitoring `active` property of each of its children.
+It it possible to have as many `active` children as you'd like but in order for the component to be the most effictent we should keep the number of active screens to the minimum.
+In a case of stack navigator or tabs navigator we only want to have one active screen (the top most view on a stack or the selected tab).
+Then for the time of transitioning between views we may want to activate a second screen for the duration of transition, and then go back to just one active screen.
+
+### `<Screen/>`
+
+This component is a container for views we want to display on a navigation screen.
+It is designed to only be rendered as a direct child of `ScreenContainer`.
+In addition to plain React Native [View props](http://facebook.github.io/react-native/docs/view#props) this component only accepts a single additional property called `active`.
+When `active` is set to `0`, the parent container will detach its views from the native view hierarchy.
+Otherwise the views will be attached as long as the parent container is attached too.
+
+### Example
+
+```js
+<ScreenContainer>
+  <Screen>{tab1}</Screen>
+  <Screen active={1}>{tab2}</Screen>
+  <Screen>{tab3}</Screen>
+</ScreenContainer>
+```
+
+## Guide for native component authors
+
+If you are adding a new native component to be used from the React Native app, you may want it to respond to navigation lifecycle events.
+
+Good example is a map component that shows current user location. When component is on the top-most screen it should register for location updates and display users location on the map. But if we navigate away from a screen that has a map, e.g. by pushing new screen on top of it or if it is in one of a tabs and user just switched to the previous app, we may want to stop listening to location updates.
+
+In order to achieve that we need to know at the native component level when our native view goes out of sight. With react-native-screens you can do that in the following way:
+
+### Navigation lifecycle on iOS
+
+In order for your native view on iOS to be notified when its parent navigation container goes into background override `didMoveToWindow` method:
+
+```objective-c
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  BOOL isVisible = self.superview && self.window;
+  if (isVisible) {
+    // navigation container this view belongs to became visible
+  } else {
+    // we are in a background
+  }
+}
+```
+
+You can check our example app for a fully functional demo see [RNSSampleLifecycleAwareView.m](https://github.com/kmagiera/react-native-screens/blob/master/Example/ios/ScreensExample/RNSSampleLifecycleAwareView.m) for more details.
+
+### Navigation lifecycle on Android
+
+On Android you can use [LifecycleObserver](https://developer.android.com/reference/android/arch/lifecycle/LifecycleObserver) interface which is a part of Android compat library to make your view handle lifecycle events.
+Check [LifecycleAwareView.java](https://github.com/kmagiera/react-native-screens/blob/master/Example/android/app/src/main/java/com/swmansion/rnscreens/example/LifecycleAwareView.java) from our example app for more details on that.
+
+In addition to that you will need to register for receiving these updates. This can be done using [`LifecycleHelper.register`](https://github.com/kmagiera/react-native-screens/blob/master/android/src/main/java/com/swmansion/rnscreens/LifecycleHelper.java#L50).
+Remember to call [`LifecycleHelper.unregister`](https://github.com/kmagiera/react-native-screens/blob/master/android/src/main/java/com/swmansion/rnscreens/LifecycleHelper.java#L59) before the view is dropped.
+Please refer to [SampleLifecycleAwareViewManager.java](https://github.com/kmagiera/react-native-screens/blob/master/Example/android/app/src/main/java/com/swmansion/rnscreens/example/SampleLifecycleAwareViewManager.java) from our example app to see what are the best ways of using the above methods.
+
+## License
+
+React native screens library is licensed under [The MIT License](LICENSE).
+
+## Credits
+
+This project is supported by amazing people from [Expo.io](https://expo.io) and [Software Mansion](https://swmansion.com)
+
+[![expo](https://avatars2.githubusercontent.com/u/12504344?v=3&s=100 "Expo.io")](https://expo.io)
+[![swm](https://avatars1.githubusercontent.com/u/6952717?v=3&s=100 "Software Mansion")](https://swmansion.com)

package/RNScreens.podspec

@@ -0,0 +1,24 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "RNScreens"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.description  = <<-DESC
+                  RNScreens - first incomplete navigation solution for your React Native app
+                   DESC
+  s.homepage     = "https://github.com/kmagiera/react-native-screens"
+  s.license      = "MIT"
+  # s.license    = { :type => "MIT", :file => "FILE_LICENSE" }
+  s.author       = { "author" => "author@domain.cn" }
+  s.platform     = :ios, "7.0"
+  s.source       = { :git => "https://github.com/kmagiera/react-native-screens.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m}"
+  s.requires_arc = true
+
+  s.dependency "React"
+end
+

package/android/build.gradle

@@ -1,26 +1,29 @@
 
 buildscript {
     repositories {
+        google()
         jcenter()
     }
 
     dependencies {
-        // Matches the RN Hello World template
-        // https://github.com/facebook/react-native/blob/1e8f3b11027fe0a7514b4fc97d0798d3c64bc895/local-cli/templates/HelloWorld/android/build.gradle#L8
-        classpath 'com.android.tools.build:gradle:2.2.3'
+       classpath 'com.android.tools.build:gradle:3.3.1'
     }
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'maven'
 
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
 android {
-    compileSdkVersion 26
-    buildToolsVersion "26.0.3"
+    compileSdkVersion safeExtGet('compileSdkVersion', 28)
+    buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
 
     defaultConfig {
-        minSdkVersion 16
-        targetSdkVersion 22
+        minSdkVersion safeExtGet('minSdkVersion', 16)
+        targetSdkVersion safeExtGet('targetSdkVersion', 22)
         versionCode 1
         versionName "1.0"
     }
@@ -37,10 +40,14 @@ repositories {
         url "$projectDir/../node_modules/react-native/android"
     }
     mavenCentral()
+    mavenLocal()
+    google()
+    jcenter()
+
 }
 
 dependencies {
-    compile 'com.facebook.react:react-native:+'
+    implementation 'com.facebook.react:react-native:+'
 }
 
 def configureReactNativePom(def pom) {
@@ -93,8 +100,8 @@ afterEvaluate { project ->
 
     android.libraryVariants.all { variant ->
         def name = variant.name.capitalize()
-        task "jar${name}"(type: Jar, dependsOn: variant.javaCompile) {
-            from variant.javaCompile.destinationDir
+        task "jar${name}"(type: Jar, dependsOn: variant.javaCompileProvider.get()) {
+            from variant.javaCompileProvider.get().destinationDir
         }
     }
 

package/android/src/main/java/com/swmansion/rnscreens/LifecycleHelper.java

@@ -1,16 +1,12 @@
 package com.swmansion.rnscreens;
 
-import android.arch.lifecycle.Lifecycle;
-import android.arch.lifecycle.LifecycleObserver;
-import android.support.v4.app.Fragment;
-import android.util.Log;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.fragment.app.Fragment;
+
 import android.view.View;
 import android.view.ViewParent;
 
-import com.facebook.react.modules.core.ChoreographerCompat;
-import com.facebook.react.modules.core.ReactChoreographer;
-
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 

package/android/src/main/java/com/swmansion/rnscreens/{RNScreenPackage.java → RNScreensPackage.java}

@@ -9,7 +9,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-public class RNScreenPackage implements ReactPackage {
+public class RNScreensPackage implements ReactPackage {
   @Override
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
     return Collections.emptyList();
@@ -19,7 +19,6 @@ public class RNScreenPackage implements ReactPackage {
   public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
     return Arrays.<ViewManager>asList(
             new ScreenContainerViewManager(),
-            new ScreenStackViewManager(),
             new ScreenViewManager()
     );
   }

package/android/src/main/java/com/swmansion/rnscreens/Screen.java

@@ -1,15 +1,20 @@
 package com.swmansion.rnscreens;
 
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+
 import android.annotation.SuppressLint;
 import android.content.Context;
+import android.graphics.Paint;
 import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 
-public class Screen extends ViewGroup {
+import com.facebook.react.uimanager.PointerEvents;
+import com.facebook.react.uimanager.ReactPointerEventsView;
+
+public class Screen extends ViewGroup implements ReactPointerEventsView {
 
   public static class ScreenFragment extends Fragment {
 
@@ -36,6 +41,7 @@ public class Screen extends ViewGroup {
   private final Fragment mFragment;
   private @Nullable ScreenContainer mContainer;
   private boolean mActive;
+  private boolean mTransitioning;
 
   public Screen(Context context) {
     super(context);
@@ -47,6 +53,38 @@ public class Screen extends ViewGroup {
     // no-op
   }
 
+  /**
+   * While transitioning this property allows to optimize rendering behavior on Android and provide
+   * a correct blending options for the animated screen. It is turned on automatically by the container
+   * when transitioning is detected and turned off immediately after
+   */
+  public void setTransitioning(boolean transitioning) {
+    if (mTransitioning == transitioning) {
+      return;
+    }
+    mTransitioning = transitioning;
+    super.setLayerType(transitioning ? View.LAYER_TYPE_HARDWARE : View.LAYER_TYPE_NONE, null);
+  }
+
+  @Override
+  public boolean hasOverlappingRendering() {
+    return mTransitioning;
+  }
+
+  @Override
+  public PointerEvents getPointerEvents() {
+    return mTransitioning ? PointerEvents.NONE : PointerEvents.AUTO;
+  }
+
+  @Override
+  public void setLayerType(int layerType, @Nullable Paint paint) {
+    // ignore - layer type is controlled by `transitioning` prop
+  }
+
+  public void setNeedsOffscreenAlphaCompositing(boolean needsOffscreenAlphaCompositing) {
+    // ignore - offscreen alpha is controlled by `transitioning` prop
+  }
+
   protected void setContainer(@Nullable ScreenContainer mContainer) {
     this.mContainer = mContainer;
   }
@@ -60,6 +98,9 @@ public class Screen extends ViewGroup {
   }
 
   public void setActive(boolean active) {
+    if (active == mActive) {
+      return;
+    }
     mActive = active;
     if (mContainer != null) {
       mContainer.notifyChildUpdate();

package/android/src/main/java/com/swmansion/rnscreens/ScreenContainer.java

@@ -1,15 +1,16 @@
 package com.swmansion.rnscreens;
 
-import android.app.Activity;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentTransaction;
+
 import android.content.Context;
-import android.support.annotation.Nullable;
-import android.support.v4.app.Fragment;
-import android.support.v4.app.FragmentActivity;
-import android.support.v4.app.FragmentManager;
-import android.support.v4.app.FragmentTransaction;
+import android.content.ContextWrapper;
 import android.view.ViewGroup;
+import android.view.ViewParent;
 
-import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.ReactRootView;
 import com.facebook.react.modules.core.ChoreographerCompat;
 import com.facebook.react.modules.core.ReactChoreographer;
 
@@ -22,10 +23,10 @@ public class ScreenContainer extends ViewGroup {
 
   private final ArrayList<Screen> mScreens = new ArrayList<>();
   private final Set<Screen> mActiveScreens = new HashSet<>();
-  private final FragmentManager mFragmentManager;
 
   private @Nullable FragmentTransaction mCurrentTransaction;
   private boolean mNeedUpdate;
+  private boolean mIsAttached;
 
   private ChoreographerCompat.FrameCallback mFrameCallback = new ChoreographerCompat.FrameCallback() {
     @Override
@@ -36,13 +37,6 @@ public class ScreenContainer extends ViewGroup {
 
   public ScreenContainer(Context context) {
     super(context);
-    Activity activity = ((ReactContext) context).getCurrentActivity();
-    if (activity instanceof FragmentActivity) {
-      mFragmentManager = ((FragmentActivity) activity).getSupportFragmentManager();
-    } else {
-      throw new IllegalStateException(
-              "In order to use RNScreen components your app's activity need to extend ReactFragmentActivity or ReactCompatActivity");
-    }
   }
 
   @Override
@@ -85,9 +79,35 @@ public class ScreenContainer extends ViewGroup {
     return mScreens.get(index);
   }
 
+  private FragmentActivity findRootFragmentActivity() {
+    ViewParent parent = this;
+    while (!(parent instanceof ReactRootView) && parent.getParent() != null) {
+      parent = parent.getParent();
+    }
+    // we expect top level view to be of type ReactRootView, this isn't really necessary but in order
+    // to find root view we test if parent is null. This could potentially happen also when the view
+    // is detached from the hierarchy and that test would not correctly indicate the root view. So
+    // in order to make sure we indeed reached the root we test if it is of a correct type. This
+    // allows us to provide a more descriptive error message for the aforementioned case.
+    if (!(parent instanceof ReactRootView)) {
+      throw new IllegalStateException("ScreenContainer is not attached under ReactRootView");
+    }
+    // ReactRootView is expected to be initialized with the main React Activity as a context but
+    // in case of Expo the activity is wrapped in ContextWrapper and we need to unwrap it
+    Context context = ((ReactRootView) parent).getContext();
+    while (!(context instanceof FragmentActivity) && context instanceof ContextWrapper) {
+      context = ((ContextWrapper) context).getBaseContext();
+    }
+    if (!(context instanceof FragmentActivity)) {
+      throw new IllegalStateException(
+              "In order to use RNScreens components your app's activity need to extend ReactFragmentActivity or ReactCompatActivity");
+    }
+    return (FragmentActivity) context;
+  }
+
   private FragmentTransaction getOrCreateTransaction() {
     if (mCurrentTransaction == null) {
-      mCurrentTransaction = mFragmentManager.beginTransaction();
+      mCurrentTransaction = findRootFragmentActivity().getSupportFragmentManager().beginTransaction();
       mCurrentTransaction.setReorderingAllowed(true);
     }
     return mCurrentTransaction;
@@ -95,7 +115,7 @@ public class ScreenContainer extends ViewGroup {
 
   private void tryCommitTransaction() {
     if (mCurrentTransaction != null) {
-      mCurrentTransaction.commitNow();
+      mCurrentTransaction.commitAllowingStateLoss();
       mCurrentTransaction = null;
     }
   }
@@ -121,8 +141,21 @@ public class ScreenContainer extends ViewGroup {
     return screen.isActive();
   }
 
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+    mIsAttached = true;
+    updateIfNeeded();
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    mIsAttached = false;
+  }
+
   private void updateIfNeeded() {
-    if (!mNeedUpdate || mFragmentManager.isDestroyed()) {
+    if (!mNeedUpdate || !mIsAttached) {
       return;
     }
     mNeedUpdate = false;
@@ -144,6 +177,15 @@ public class ScreenContainer extends ViewGroup {
       }
     }
 
+    // detect if we are "transitioning" based on the number of active screens
+    int activeScreens = 0;
+    for (int i = 0, size = mScreens.size(); i < size; i++) {
+      if (isScreenActive(mScreens.get(i), mScreens)) {
+        activeScreens += 1;
+      }
+    }
+    boolean transitioning = activeScreens > 1;
+
     // attach newly activated screens
     boolean addedBefore = false;
     for (int i = 0, size = mScreens.size(); i < size; i++) {
@@ -155,6 +197,7 @@ public class ScreenContainer extends ViewGroup {
       } else if (isActive && addedBefore) {
         moveToFront(screen);
       }
+      screen.setTransitioning(transitioning);
     }
     tryCommitTransaction();
   }

package/android/src/main/java/com/swmansion/rnscreens/ScreenContainerViewManager.java

@@ -24,7 +24,7 @@ public class ScreenContainerViewManager extends ViewGroupManager<ScreenContainer
   @Override
   public void addView(ScreenContainer parent, View child, int index) {
     if (!(child instanceof Screen)) {
-      throw new IllegalArgumentException("Attempt attach child that is not of type RNScreen");
+      throw new IllegalArgumentException("Attempt attach child that is not of type RNScreens");
     }
     parent.addScreen((Screen) child, index);
   }

package/android/src/main/java/com/swmansion/rnscreens/ScreenViewManager.java

@@ -20,8 +20,8 @@ public class ScreenViewManager extends ViewGroupManager<Screen> {
     return new Screen(reactContext);
   }
 
-  @ReactProp(name = "active", defaultBoolean = false)
-  public void setActive(Screen view, boolean active) {
-    view.setActive(active);
+  @ReactProp(name = "active", defaultFloat = 0)
+  public void setActive(Screen view, float active) {
+    view.setActive(active != 0);
   }
 }

package/ios/RNSScreen.h

@@ -13,6 +13,8 @@
 @property (nonatomic, retain) UIViewController *controller;
 @property (nonatomic) BOOL active;
 
+- (void)notifyFinishTransitioning;
+
 @end
 
 @interface UIView (RNSScreen)

package/ios/RNSScreen.m

@@ -4,10 +4,15 @@
 @interface RNSScreen : UIViewController
 
 - (instancetype)initWithView:(UIView *)view;
+- (void)notifyFinishTransitioning;
 
 @end
 
-@implementation RNSScreenView
+@implementation RNSScreenView {
+  RNSScreen *_controller;
+}
+
+@synthesize controller = _controller;
 
 - (instancetype)init
 {
@@ -20,18 +25,21 @@
 
 - (void)setActive:(BOOL)active
 {
-  _active = active;
-  [_reactSuperview markChildUpdated];
+  if (active != _active) {
+    _active = active;
+    [_reactSuperview markChildUpdated];
+  }
 }
 
-- (UIView *)reactSuperview
+- (void)setPointerEvents:(RCTPointerEvents)pointerEvents
 {
-  return _reactSuperview;
+  // pointer events settings are managed by the parent screen container, we ignore any attempt
+  // of setting that via React props
 }
 
-- (void)didSetProps:(NSArray<NSString *> *)changedProps
+- (UIView *)reactSuperview
 {
-  [_reactSuperview didUpdateChildren];
+  return _reactSuperview;
 }
 
 - (void)invalidate
@@ -40,10 +48,16 @@
   _controller = nil;
 }
 
+- (void)notifyFinishTransitioning
+{
+  [_controller notifyFinishTransitioning];
+}
+
 @end
 
 @implementation RNSScreen {
   __weak UIView *_view;
+  __weak id _previousFirstResponder;
 }
 
 - (instancetype)initWithView:(UIView *)view
@@ -54,6 +68,36 @@
   return self;
 }
 
+- (id)findFirstResponder:(UIView*)parent
+{
+  if (parent.isFirstResponder) {
+    return parent;
+  }
+  for (UIView *subView in parent.subviews) {
+    id responder = [self findFirstResponder:subView];
+    if (responder != nil) {
+      return responder;
+    }
+  }
+  return nil;
+}
+
+- (void)willMoveToParentViewController:(UIViewController *)parent
+{
+  if (parent == nil) {
+    id responder = [self findFirstResponder:self.view];
+    if (responder != nil) {
+      _previousFirstResponder = responder;
+    }
+  }
+}
+
+- (void)notifyFinishTransitioning
+{
+  [_previousFirstResponder becomeFirstResponder];
+  _previousFirstResponder = nil;
+}
+
 - (void)loadView
 {
   self.view = _view;

package/ios/RNSScreenContainer.h

@@ -3,16 +3,8 @@
 @protocol RNSScreenContainerDelegate
 
 - (void)markChildUpdated;
-- (void)didUpdateChildren;
 
 @end
 
 @interface RNSScreenContainerView : UIView <RNSScreenContainerDelegate>
-
-- (void)markChildUpdated;
-- (void)didUpdateChildren;
-
-@end
-
-@interface RNSScreenContainerManager : RCTViewManager
 @end