V3 (#5372)

# Changes
* Support RN 0.60
* Migrate to AndroidX
* Improve draw behind StatusBar (Preparation for #4258)
* Don't push BottomTabs when keyboard is displayed (Fixes #4005, #3424)
    - It won't be needed to toggle the BottomTabs when Keyboard is visible
* BottomTab badge and dot indicator are not animated by default on Android (parity with iOS)

# Updating from v2
v3 is currently in alpha. To update simply npm install `3.0.0-alpha.11` - `npm install --save react-native-navigation@3.0.0-alpha.11`.
Breaking changes are outlined below.

## Layout system changes on **Android**
* Parent layouts (BottomsTabs, Stack, SideMenu) are always laid out behind the StatusBar.
* Components (`component` and `externalComponent`) are measured and offset according to the StatusBar.

In this release, We're changing the layout system in order to provide better support for immersive and full screen apps. In this release we've improved support for drawing behind the StatusBar,  next we'll address drawing behind the NavigationBar. 

Use the `drawBehind` and `translucent` options to control the StatusBar
```js
statusBar: {
  drawBehind: true,  // will draw a screen behind the StatusBar
  translucent: true // Usually you'll want to have drawBehind: true when this is true
}
```

While this isn't a breaking API change - there are a few breaking side effects.

### How will my app be effected
1. When the keyboard is opened, BottomTabs will now be drawn behind the keyboard and won't shift upwards. This is in parity with the current behaviour in iOS. For the most part, this isn't a breaking change. Toggling BottomTabs when TextInput's focus changes won't be needed anymore.

2. While parent controllers are drawn behind the StatusBar, their background isn't.
This means that when transitioning from a destinations drawn under the StatusBar to a destination drawn behind it, the application's default background color will be visible behind the StatusBar.
If you application's theme is dark, you might want to change the `windowBackground` property to mitigate this:

Add the following to your application's `style.xml`
```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
        <item name="android:windowBackground">@color/backgroundColor</item>
    </style>

    <!--This is your application's default background color.
    It will be visible when the app is first opened (while the splash layout is visible)
    and when transitioning between a destination a screen drawn under the StatusBar to
    a destination drawn behind it-->
    <item name="backgroundColor" type="color">#f00</item>
</resources>
```

## AndroidX migration
We've migrated RNN to AndroidX, please follow migration instructions in the react-native repo.

## Removed SyncUiImplementation
[SyncUiImplementation](https://github.com/wix/react-native-navigation/blob/master/lib/android/app/src/reactNative57WixFork/java/com/reactnativenavigation/react/SyncUiImplementation.java) was used to overcome a bug in RN's UiImplementation. This workaround was added to RN's `UiImplementation` in RN 0.60 (thanks @SudoPlz) and can be removed from RNN.

If you're using `SyncUiImplementation` your app will fail to compile after upgrading to v3. Simply remove the following code from your `MainApplication.java`
```diff
- import com.facebook.react.uimanager.UIImplementationProvider;
- import com.reactnativenavigation.react.SyncUiImplementation;


- @Override
- protected UIImplementationProvider getUIImplementationProvider() {
-     return new SyncUiImplementation.Provider();
- }
```

## BottomTab badge and dot indicator are not animated by default on Android (parity with iOS)
Showing and hiding badge and dot indicator are now not animated by default. Badge animation is now controlled with the `bottomTab.animateBadge` property and dot indicator with `bottomTab.dotIndicator.animate` property.

#### The following option will show a badge with animation
```js
bottomTab: {
  badge: 'new,
  animateBadge: true
}
```

#### The following option will show a dot indicator with animation
```js
bottomTab: {
  dotIndicator: {
    visible: true,
    animate: true
  }
}
```

closes #5228

docs/docs/Installing.md

 	{
 		NSURL *jsCodeLocation = [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index" fallbackResource:nil];
 		[ReactNativeNavigation bootstrap:jsCodeLocation launchOptions:launchOptions];
-		
+
 		return YES;
 	}
 
 	@end
 	```
 
-3a. If, in Xcode, you see the following error message in `AppDelegate.m` next to `#import "RCTBundleURLProvider.h"`: 
+3a. If, in Xcode, you see the following error message in `AppDelegate.m` next to `#import "RCTBundleURLProvider.h"`:
 ```
 ! 'RCTBundleURLProvider.h' file not found
 ```
-This is because the `React` scheme is missing from your project. You can verify this by opening the `Product` menu and the `Scheme` submenu. 
+This is because the `React` scheme is missing from your project. You can verify this by opening the `Product` menu and the `Scheme` submenu.
 
 To make the `React` scheme available to your project, run `npm install -g react-native-git-upgrade` followed by `react-native-git-upgrade`. Once this is done, you can click back to the menu in Xcode: `Product -> Scheme -> Manage Schemes`, then click '+' to add a new scheme. From the `Target` menu, select "React", and click the checkbox to make the scheme `shared`. This should make the error disappear.
 
 allprojects {
 	repositories {
 +		google()
-+		mavenCentral()
 		mavenLocal()
 		jcenter()
 		maven {
 }
 
 ext {
--    buildToolsVersion = "26.0.3"
-+    buildToolsVersion = "27.0.3"
 -    minSdkVersion = 16
 +    minSdkVersion = 19
     compileSdkVersion = 26
 
 dependencies {
 -    compile fileTree(dir: "libs", include: ["*.jar"])
--    compile "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"
 -    compile "com.facebook.react:react-native:+"  // From node_modules
 +    implementation fileTree(dir: "libs", include: ["*.jar"])
-+    implementation "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"
 +    implementation "com.facebook.react:react-native:+"  // From node_modules
 +    implementation project(':react-native-navigation')
 }
 ```
 
 ### 5 RNN and React Native version
-
 react-native-navigation supports multiple React Native versions. Target the React Native version required by your project by specifying the RNN build flavor in `android/app/build.gradle`.
 
 ```diff
 >`reactNative55` - RN 0.55.x<Br>
 >`reactNative56` - RN 0.56.x<Br>
 >`reactNative57` - RN 0.57.0 - 0.57.4<Br>
->`reactNative57_5` - RN 0.57.5 and above<Br>
+>`reactNative57_5` - RN 0.57.5 - 0.59.9<Br>
+>`reactNative60` - RN 0.60.0 and above
 
 Now we need to instruct gradle how to build that flavor. To do so here two solutions:
 
-#### 5.1 Build app with gradle command 
+#### 5.1 Build app with gradle command
 
 **prefered solution** The RNN flavor you would like to build is specified in `app/build.gradle`. Therefore in order to compile only that flavor, instead of building your entire project using `./gradlew assembleDebug`, you should instruct gradle to build the app module: `./gradlew app:assembleDebug`. The easiest way is to add a package.json command to build and install your debug Android APK .
 
 -import com.facebook.react.ReactActivity;
 +import com.reactnativenavigation.NavigationActivity;
 
--public class MainActivity extends ReactActivity { 
+-public class MainActivity extends ReactActivity {
 +public class MainActivity extends NavigationActivity {
 -    @Override
 -    protected String getMainComponentName() {
 ### 7. Update `MainApplication.java`
 
 This file is located in `android/app/src/main/java/com/<yourproject>/MainApplication.java`.
-	
+
 ```diff
 ...
 import android.app.Application;
 
 -public class MainApplication extends Application implements ReactApplication {
 +public class MainApplication extends NavigationApplication {
-+    
++
 +    @Override
 +    protected ReactGateway createReactGateway() {
 +        ReactNativeHost host = new NavigationReactNativeHost(this, isDebug(), createAdditionalReactPackages()) {
 +            // eg. new VectorIconsPackage()
 +        );
 +    }
-+  
++
 +    @Override
 +    public List<ReactPackage> createAdditionalReactPackages() {
 +        return getPackages();
 ## You can use react-native-navigation \o/
 
 Update `index.js` file
-
-
 ```diff
 +import { Navigation } from "react-native-navigation";
 -import {AppRegistry} from 'react-native';

lib/android/app/build.gradle

 apply plugin: 'com.android.library'
-apply from: '../prepare-robolectric.gradle'
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 
 def DEFAULT_COMPILE_SDK_VERSION = 28
 def DEFAULT_MIN_SDK_VERSION = 19
-def DEFAULT_SUPPORT_LIB_VERSION = '28.0.0'
 def DEFAULT_TARGET_SDK_VERSION = 28
 
 android {
     }
 
     testOptions {
+        unitTests.includeAndroidResources = true
         unitTests.all { t ->
             reports {
                 html.enabled true
             dimension "RNN.reactNativeVersion"
             buildConfigField("int", "REACT_NATVE_VERSION_MINOR", "57")
         }
+        reactNative60 {
+            dimension "RNN.reactNativeVersion"
+            buildConfigField("int", "REACT_NATVE_VERSION_MINOR", "60")
+        }
     }
 }
 
     }
 }
 
-def supportLibVersion = safeExtGet('supportLibVersion', DEFAULT_SUPPORT_LIB_VERSION)
-
 dependencies {
-    implementation "com.android.support:design:${supportLibVersion}"
-    implementation "com.android.support:appcompat-v7:${supportLibVersion}"
-    implementation "com.android.support:support-v4:${supportLibVersion}"
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.annotation:annotation:1.1.0'
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
+    implementation 'com.google.android.material:material:1.1.0-alpha08'
 
-    implementation 'com.github.wix-playground:ahbottomnavigation:2.4.15'
+    implementation 'com.github.wix-playground:ahbottomnavigation:3.0.2'
     implementation 'com.github.wix-playground:reflow-animator:1.0.4'
     implementation 'com.github.clans:fab:1.6.4'
 
 
     // tests
     testImplementation 'junit:junit:4.12'
-    testImplementation 'org.robolectric:robolectric:3.5.1'
+    testImplementation "org.robolectric:robolectric:4.3-beta-1"
     testImplementation 'org.assertj:assertj-core:3.8.0'
     testImplementation 'com.squareup.assertj:assertj-android:1.1.1'
-    testImplementation 'org.mockito:mockito-core:2.13.0'
+    testImplementation 'org.mockito:mockito-core:2.28.2'
 }

lib/android/app/src/main/java/com/reactnativenavigation/NavigationActivity.java

 import android.graphics.Color;
 import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v7.app.AppCompatActivity;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
 import android.view.KeyEvent;
 import android.view.View;
 

lib/android/app/src/main/java/com/reactnativenavigation/NavigationApplication.java

 package com.reactnativenavigation;
 
 import android.app.Application;
-import android.support.annotation.Nullable;
-import android.support.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.NonNull;
 
 import com.facebook.react.ReactApplication;
 import com.facebook.react.ReactNativeHost;

lib/android/app/src/main/java/com/reactnativenavigation/anim/BaseAnimator.java

 import android.animation.ObjectAnimator;
 import android.animation.TimeInterpolator;
 import android.content.Context;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.animation.AccelerateDecelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
         set.setDuration(DURATION);
         ObjectAnimator translationY = ObjectAnimator.ofFloat(view, TRANSLATION_Y, this.translationY, 0);
         ObjectAnimator alpha = ObjectAnimator.ofFloat(view, ALPHA, 0, 1);
+        translationY.setDuration(DURATION);
+        alpha.setDuration(DURATION);
         set.playTogether(translationY, alpha);
         return set;
     }

lib/android/app/src/main/java/com/reactnativenavigation/anim/FabCollapseBehaviour.java

 package com.reactnativenavigation.anim;
 
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 

lib/android/app/src/main/java/com/reactnativenavigation/anim/NavigationAnimator.java

 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.content.Context;
-import android.support.annotation.RestrictTo;
+import androidx.annotation.RestrictTo;
 import android.view.View;
 import android.view.ViewGroup;
 

lib/android/app/src/main/java/com/reactnativenavigation/anim/TopBarAnimator.java

 import android.animation.ObjectAnimator;
 import android.animation.TimeInterpolator;
 import android.view.View;
-import android.view.animation.AccelerateDecelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.LinearInterpolator;
 
 import com.reactnativenavigation.parse.AnimationOptions;
-import com.reactnativenavigation.utils.ViewUtils;
+import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.topbar.TopBar;
 
-import javax.annotation.Nullable;
-
 import static android.view.View.TRANSLATION_Y;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+import static com.reactnativenavigation.utils.ViewUtils.getHeight;
 
 public class TopBarAnimator {
 
     private static final int DURATION = 300;
     private static final TimeInterpolator DECELERATE = new DecelerateInterpolator();
     private static final TimeInterpolator LINEAR = new LinearInterpolator();
-    private static final TimeInterpolator ACCELERATE_DECELERATE = new AccelerateDecelerateInterpolator();
 
     private TopBar topBar;
     private String stackId;
     private Animator hideAnimator;
     private Animator showAnimator;
 
-    public TopBarAnimator(TopBar topBar) {
+    public TopBarAnimator() {
+    }
+
+    TopBarAnimator(TopBar topBar) {
         this.topBar = topBar;
     }
 
-    public TopBarAnimator(TopBar topBar, @Nullable String stackId) {
+    public void bindView(TopBar topBar, StackLayout stack) {
         this.topBar = topBar;
-        this.stackId = stackId;
+        stackId = stack.getStackId();
     }
 
-    public void show(AnimationOptions options) {
+    public void show(AnimationOptions options, int translationStartDy) {
         topBar.setVisibility(View.VISIBLE);
         if (options.hasValue() && (!options.id.hasValue() || options.id.get().equals(stackId))) {
+            options.setValueDy(TRANSLATION_Y, -translationStartDy, 0);
             showAnimator = options.getAnimation(topBar);
         } else {
-            showAnimator = getDefaultShowAnimator(-1 * ViewUtils.getHeight(topBar), DECELERATE, DURATION);
+            showAnimator = getDefaultShowAnimator(translationStartDy, DECELERATE, DURATION);
         }
-        show();
+        showInternal();
     }
 
     public void show(float startTranslation) {
         showAnimator = getDefaultShowAnimator(startTranslation, LINEAR, DEFAULT_COLLAPSE_DURATION);
-        show();
+        showInternal();
     }
 
-    private void show() {
+    private void showInternal() {
         showAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
                 topBar.setVisibility(View.VISIBLE);
             }
         });
-        topBar.resetAnimationOptions();
         if (isAnimatingHide()) hideAnimator.cancel();
         showAnimator.start();
     }
 
-    private AnimatorSet getDefaultShowAnimator(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator showAnimator = ObjectAnimator.ofFloat(topBar, TRANSLATION_Y, startTranslation, 0);
-        showAnimator.setInterpolator(interpolator);
-        showAnimator.setDuration(duration);
-        AnimatorSet set = new AnimatorSet();
-        set.play(showAnimator);
-        return set;
-    }
-
-    public void hide(AnimationOptions options, Runnable onAnimationEnd) {
+    public void hide(AnimationOptions options, Runnable onAnimationEnd, float translationStartDy, float translationEndDy) {
         if (options.hasValue() && (!options.id.hasValue() || options.id.get().equals(stackId))) {
+            options.setValueDy(TRANSLATION_Y, translationStartDy, -translationEndDy);
             hideAnimator = options.getAnimation(topBar);
         } else {
-            hideAnimator = getDefaultHideAnimator(0, ACCELERATE_DECELERATE, DURATION);
+            hideAnimator = getDefaultHideAnimator(translationStartDy, translationEndDy, DECELERATE, DURATION);
         }
-        hide(onAnimationEnd);
+        hideInternal(onAnimationEnd);
     }
 
-    void hide(float startTranslation) {
-        hideAnimator = getDefaultHideAnimator(startTranslation, LINEAR, DEFAULT_COLLAPSE_DURATION);
-        hide(() -> {});
+    public void hide(float translationStart, float translationEndDy) {
+        hideAnimator = getDefaultHideAnimator(translationStart, translationEndDy, LINEAR, DEFAULT_COLLAPSE_DURATION);
+        hideInternal(() -> {});
     }
 
-    private void hide(Runnable onAnimationEnd) {
+    private void hideInternal(Runnable onAnimationEnd) {
         hideAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
         hideAnimator.start();
     }
 
-    private Animator getDefaultHideAnimator(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator hideAnimator = ObjectAnimator.ofFloat(topBar, TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
-        hideAnimator.setInterpolator(interpolator);
-        hideAnimator.setDuration(duration);
-        return hideAnimator;
-    }
-
     public boolean isAnimatingHide() {
         return hideAnimator != null && hideAnimator.isRunning();
     }
     public boolean isAnimatingShow() {
          return showAnimator != null && showAnimator.isRunning();
     }
+
+    public boolean isAnimating() {
+        return perform(showAnimator, false, Animator::isRunning) ||
+               perform(hideAnimator, false, Animator::isRunning);
+    }
+
+    private AnimatorSet getDefaultShowAnimator(float translationStart, TimeInterpolator interpolator, int duration) {
+        ObjectAnimator showAnimator = ObjectAnimator.ofFloat(topBar, TRANSLATION_Y, -getHeight(topBar) - translationStart, 0);
+        showAnimator.setInterpolator(interpolator);
+        showAnimator.setDuration(duration);
+        AnimatorSet set = new AnimatorSet();
+        set.play(showAnimator);
+        return set;
+    }
+
+    private Animator getDefaultHideAnimator(float translationStart, float translationEndDy, TimeInterpolator interpolator, int duration) {
+        ObjectAnimator hideAnimator = ObjectAnimator.ofFloat(topBar, TRANSLATION_Y, translationStart, -topBar.getMeasuredHeight() - translationEndDy);
+        hideAnimator.setInterpolator(interpolator);
+        hideAnimator.setDuration(duration);
+        return hideAnimator;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/anim/TopBarCollapseBehavior.java

 
 
 import android.view.View;
+import android.view.ViewGroup;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.views.topbar.TopBar;
 
     @Override
     public void onHide() {
-        animator.hide(topBar.getTranslationY());
+        animator.hide(topBar.getTranslationY(), ((ViewGroup.MarginLayoutParams) topBar.getLayoutParams()).topMargin);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/AnimationOptions.java

 import java.util.Iterator;
 import java.util.List;
 
-public class AnimationOptions {
+import static com.reactnativenavigation.utils.CollectionUtils.*;
 
+public class AnimationOptions {
     public static AnimationOptions parse(JSONObject json) {
         AnimationOptions options = new AnimationOptions();
         if (json == null) return options;
         if (!hasAnimation()) return defaultAnimation;
         AnimatorSet animationSet = new AnimatorSet();
         List<Animator> animators = new ArrayList<>();
-        for (ValueAnimationOptions options : valueOptions) {
-            animators.add(options.getAnimation(view));
-        }
+        forEach(valueOptions, options -> animators.add(options.getAnimation(view)));
         animationSet.playTogether(animators);
         return animationSet;
     }
     public boolean hasAnimation() {
         return !valueOptions.isEmpty();
     }
+
+    public void setValueDy(Property<View, Float> animation, float fromDelta, float toDelta) {
+        first(valueOptions, o -> o.equals(animation), param -> {
+            param.setFromDelta(fromDelta);
+            param.setToDelta(toDelta);
+        });
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/BottomTabOptions.java

 package com.reactnativenavigation.parse;
 
 import android.graphics.Typeface;
-import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;
+import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.parse.params.NullColor;
 import com.reactnativenavigation.parse.params.NullNumber;
 import com.reactnativenavigation.parse.params.NullText;
 import com.reactnativenavigation.parse.params.Number;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.BoolParser;
 import com.reactnativenavigation.parse.parsers.ColorParser;
 import com.reactnativenavigation.parse.parsers.NumberParser;
 import com.reactnativenavigation.parse.parsers.TextParser;
 
 import org.json.JSONObject;
 
+import androidx.annotation.Nullable;
+
 public class BottomTabOptions {
 
     public static BottomTabOptions parse(TypefaceLoader typefaceManager, JSONObject json) {
         options.selectedIconColor = ColorParser.parse(json, "selectedIconColor");
         options.badge = TextParser.parse(json, "badge");
         options.badgeColor = ColorParser.parse(json, "badgeColor");
+        options.animateBadge = BoolParser.parse(json, "animateBadge");
         options.testId = TextParser.parse(json, "testID");
         options.fontFamily = typefaceManager.getTypeFace(json.optString("fontFamily", ""));
         options.fontSize = NumberParser.parse(json, "fontSize");
     public Text testId = new NullText();
     public Text badge = new NullText();
     public Colour badgeColor = new NullColor();
+    public Bool animateBadge = new NullBool();
     public DotIndicatorOptions dotIndicator = new DotIndicatorOptions();
     public Number fontSize = new NullNumber();
     public Number selectedFontSize = new NullNumber();
         if (other.selectedIconColor.hasValue()) selectedIconColor = other.selectedIconColor;
         if (other.badge.hasValue()) badge = other.badge;
         if (other.badgeColor.hasValue()) badgeColor = other.badgeColor;
+        if (other.animateBadge.hasValue()) animateBadge = other.animateBadge;
         if (other.testId.hasValue()) testId = other.testId;
         if (other.fontSize.hasValue()) fontSize = other.fontSize;
         if (other.selectedFontSize.hasValue()) selectedFontSize = other.selectedFontSize;
         if (!selectedIconColor.hasValue()) selectedIconColor = defaultOptions.selectedIconColor;
         if (!badge.hasValue()) badge = defaultOptions.badge;
         if (!badgeColor.hasValue()) badgeColor = defaultOptions.badgeColor;
+        if (!animateBadge.hasValue()) animateBadge = defaultOptions.animateBadge;
         if (!fontSize.hasValue()) fontSize = defaultOptions.fontSize;
         if (!selectedFontSize.hasValue()) selectedFontSize = defaultOptions.selectedFontSize;
         if (fontFamily == null) fontFamily = defaultOptions.fontFamily;

lib/android/app/src/main/java/com/reactnativenavigation/parse/DotIndicatorOptions.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.Nullable;
-
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.parse.params.NullBool;
 
 import org.json.JSONObject;
 
+import androidx.annotation.Nullable;
+
 public class DotIndicatorOptions {
     public static DotIndicatorOptions parse(@Nullable JSONObject json) {
         DotIndicatorOptions options = new DotIndicatorOptions();
         options.color = ColorParser.parse(json, "color");
         options.size = NumberParser.parse(json, "size");
         options.visible = BoolParser.parse(json, "visible");
+        options.animate = BoolParser.parse(json, "animate");
 
         return options;
     }
     public Colour color = new NullColor();
     public Number size = new NullNumber();
     public Bool visible = new NullBool();
+    public Bool animate = new NullBool();
 
     public boolean hasValue() {
         return visible.hasValue();

lib/android/app/src/main/java/com/reactnativenavigation/parse/LayoutFactory.java

 package com.reactnativenavigation.parse;
 
 import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.support.annotation.RestrictTo;
 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.presentation.BottomTabPresenter;
 import com.reactnativenavigation.presentation.BottomTabsPresenter;
 import com.reactnativenavigation.presentation.ComponentPresenter;
+import com.reactnativenavigation.presentation.ExternalComponentPresenter;
 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.SideMenuPresenter;
 import java.util.List;
 import java.util.Map;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+
 import static com.reactnativenavigation.parse.Options.parse;
 
 public class LayoutFactory {
                 externalComponentCreators.get(externalComponent.name.get()),
                 reactInstanceManager,
                 new EventEmitter(reactInstanceManager.getCurrentReactContext()),
+                new ExternalComponentPresenter(),
                 parse(typefaceManager, node.getOptions())
         );
     }

lib/android/app/src/main/java/com/reactnativenavigation/parse/LayoutOptions.java

         if (other.topMargin.hasValue()) topMargin = other.topMargin;
         if (other.orientation.hasValue()) orientation = other.orientation;
         if (other.direction.hasValue()) direction = other.direction;
-
     }
 
     public void mergeWithDefault(LayoutOptions defaultOptions) {

lib/android/app/src/main/java/com/reactnativenavigation/parse/ModalOptions.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.NullBool;

lib/android/app/src/main/java/com/reactnativenavigation/parse/Options.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
-
 import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.parse.params.NullNumber;
 import com.reactnativenavigation.parse.params.NullText;
 
 import org.json.JSONObject;
 
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
+
 public class Options {
     public static final Options EMPTY = new Options();
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/OrientationOptions.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.CheckResult;
+import androidx.annotation.CheckResult;
 
 import com.reactnativenavigation.parse.params.Orientation;
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/StatusBarOptions.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;
         result.textColorScheme = TextColorScheme.fromString(json.optString("style"));
         result.visible = BoolParser.parse(json, "visible");
         result.drawBehind = BoolParser.parse(json, "drawBehind");
+        result.translucent = BoolParser.parse(json, "translucent");
 
         return result;
     }
     public TextColorScheme textColorScheme = TextColorScheme.None;
     public Bool visible = new NullBool();
     public Bool drawBehind = new NullBool();
+    public Bool translucent = new NullBool();
 
     public void mergeWith(StatusBarOptions other) {
         if (other.backgroundColor.hasValue()) backgroundColor = other.backgroundColor;
         if (other.textColorScheme.hasValue()) textColorScheme = other.textColorScheme;
         if (other.visible.hasValue()) visible = other.visible;
         if (other.drawBehind.hasValue()) drawBehind = other.drawBehind;
+        if (other.translucent.hasValue()) translucent = other.translucent;
     }
 
     public void mergeWithDefault(StatusBarOptions defaultOptions) {
         if (!textColorScheme.hasValue()) textColorScheme = defaultOptions.textColorScheme;
         if (!visible.hasValue()) visible = defaultOptions.visible;
         if (!drawBehind.hasValue()) drawBehind = defaultOptions.drawBehind;
+        if (!translucent.hasValue()) translucent = defaultOptions.translucent;
+    }
+
+    public boolean isHiddenOrDrawBehind() {
+        return drawBehind.isTrue() || visible.isFalse();
+    }
+
+    public boolean hasTransparency() {
+        return translucent.isTrue() || visible.isFalse() || backgroundColor.hasTransparency();
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/SubtitleOptions.java

 package com.reactnativenavigation.parse;
 
 import android.graphics.Typeface;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.parse.params.Fraction;

lib/android/app/src/main/java/com/reactnativenavigation/parse/TitleOptions.java

 package com.reactnativenavigation.parse;
 
 import android.graphics.Typeface;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.parse.params.Fraction;

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopBarButtons.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.utils.CollectionUtils;

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopBarOptions.java

             subtitle.text = new NullText();
         }
     }
+
+    public boolean isHiddenOrDrawBehind() {
+        return drawBehind.isTrue() || visible.isFalse();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopTabOptions.java

 package com.reactnativenavigation.parse;
 
 import android.graphics.Typeface;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.parse.params.NullText;
 import com.reactnativenavigation.parse.params.Text;

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopTabsOptions.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;

lib/android/app/src/main/java/com/reactnativenavigation/parse/Transitions.java

 package com.reactnativenavigation.parse;
 
-import android.support.annotation.RestrictTo;
+import androidx.annotation.RestrictTo;
 
 import org.json.JSONArray;
 import org.json.JSONObject;

lib/android/app/src/main/java/com/reactnativenavigation/parse/ValueAnimationOptions.java

     private Property<View, Float> animProp;
 
     private FloatParam from = new NullFloatParam();
+    private FloatParam fromDelta = new FloatParam(0f);
     private FloatParam to = new NullFloatParam();
+    private FloatParam toDelta = new FloatParam(0f);
     private Number duration = new NullNumber();
     private Number startDelay = new NullNumber();
     private Interpolation interpolation = Interpolation.NO_VALUE;
 
+    void setFromDelta(float fromDelta) {
+        this.fromDelta = new FloatParam(fromDelta);
+    }
+
+    void setToDelta(float toDelta) {
+        this.toDelta = new FloatParam(toDelta);
+    }
+
     Animator getAnimation(View view) {
         if (!from.hasValue() || !to.hasValue()) throw new IllegalArgumentException("Params 'from' and 'to' are mandatory");
-        ObjectAnimator animator = ObjectAnimator.ofFloat(view, animProp, from.get(), to.get());
+        ObjectAnimator animator = ObjectAnimator.ofFloat(view,
+                animProp,
+                from.get() + fromDelta.get(),
+                to.get() + toDelta.get()
+        );
         animator.setInterpolator(interpolation.getInterpolator());
         if (duration.hasValue()) animator.setDuration(duration.get());
         if (startDelay.hasValue()) animator.setStartDelay(startDelay.get());
         return animProp.equals(((ValueAnimationOptions) o).animProp);
     }
 
+    public boolean equals(Property<View, Float> animationProperty) {
+        return animProp.getName().equals(animationProperty.getName());
+    }
+
     @Override
     public int hashCode() {
         return animProp.hashCode();

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Button.java

 package com.reactnativenavigation.parse.params;
 
 import android.graphics.Typeface;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 import android.view.MenuItem;
 
 import com.reactnativenavigation.parse.Component;

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Colour.java

 package com.reactnativenavigation.parse.params;
 
-import android.support.annotation.ColorInt;
+import android.graphics.Color;
+import androidx.annotation.ColorInt;
 
 public class Colour extends Param<Integer>{
 
     public String toString() {
         return String.format("#%06X", (0xFFFFFF & get()));
     }
+
+    public boolean hasTransparency() {
+        return hasValue() && Color.alpha(value) < 1;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Orientation.java

 package com.reactnativenavigation.parse.params;
 
 import android.content.pm.ActivityInfo;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 public enum Orientation {
     Portrait("portrait", ActivityInfo.SCREEN_ORIENTATION_PORTRAIT),

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Text.java

 package com.reactnativenavigation.parse.params;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 public class Text extends Param<String> {
     public Text(String value) {

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/TitleDisplayMode.java

 package com.reactnativenavigation.parse.params;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation.TitleState;
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/LayoutNodeParser.java

 package com.reactnativenavigation.parse.parsers;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.reactnativenavigation.parse.LayoutNode;
 

lib/android/app/src/main/java/com/reactnativenavigation/presentation/BottomTabPresenter.java

 
 import android.content.Context;
 import android.graphics.drawable.Drawable;
-import android.support.annotation.NonNull;
 
 import com.aurelhubert.ahbottomnavigation.notification.AHNotification;
 import com.reactnativenavigation.parse.BottomTabOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.ImageLoadingListenerAdapter;
+import com.reactnativenavigation.utils.LateInit;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabFinder;
 import com.reactnativenavigation.views.BottomTabs;
-import com.reactnativenavigation.views.Component;
 
 import java.util.List;
 
+import androidx.annotation.NonNull;
+
+import static com.reactnativenavigation.utils.CollectionUtils.*;
 import static com.reactnativenavigation.utils.UiUtils.dpToPx;
 
 public class BottomTabPresenter {
     private ImageLoader imageLoader;
     private Options defaultOptions;
     private final BottomTabFinder bottomTabFinder;
-    private BottomTabs bottomTabs;
+    private LateInit<BottomTabs> bottomTabs = new LateInit<>();
     private final List<ViewController> tabs;
     private final int defaultDotIndicatorSize;
 
     }
 
     public void bindView(BottomTabs bottomTabs) {
-        this.bottomTabs = bottomTabs;
+        this.bottomTabs.set(bottomTabs);
     }
 
     public void applyOptions() {
-        for (int i = 0; i < tabs.size(); i++) {
-            BottomTabOptions tab = tabs.get(i).resolveCurrentOptions(defaultOptions).bottomTabOptions;
-            bottomTabs.setTitleTypeface(i, tab.fontFamily);
-            bottomTabs.setIconActiveColor(i, tab.selectedIconColor.get(null));
-            bottomTabs.setIconInactiveColor(i, tab.iconColor.get(null));
-            bottomTabs.setTitleActiveColor(i, tab.selectedTextColor.get(null));
-            bottomTabs.setTitleInactiveColor(i, tab.textColor.get(null));
-            bottomTabs.setTitleInactiveTextSizeInSp(i, tab.fontSize.hasValue() ? Float.valueOf(tab.fontSize.get()) : null);
-            bottomTabs.setTitleActiveTextSizeInSp(i, tab.selectedFontSize.hasValue() ? Float.valueOf(tab.selectedFontSize.get()) : null);
-            if (tab.testId.hasValue()) bottomTabs.setTag(i, tab.testId.get());
-            if (shouldApplyDot(tab)) applyDotIndicator(i, tab.dotIndicator); else applyBadge(i, tab);
-        }
+        bottomTabs.perform(bottomTabs -> {
+            for (int i = 0; i < tabs.size(); i++) {
+                BottomTabOptions tab = tabs.get(i).resolveCurrentOptions(defaultOptions).bottomTabOptions;
+                bottomTabs.setTitleTypeface(i, tab.fontFamily);
+                bottomTabs.setIconActiveColor(i, tab.selectedIconColor.get(null));
+                bottomTabs.setIconInactiveColor(i, tab.iconColor.get(null));
+                bottomTabs.setTitleActiveColor(i, tab.selectedTextColor.get(null));
+                bottomTabs.setTitleInactiveColor(i, tab.textColor.get(null));
+                bottomTabs.setTitleInactiveTextSizeInSp(i, tab.fontSize.hasValue() ? Float.valueOf(tab.fontSize.get()) : null);
+                bottomTabs.setTitleActiveTextSizeInSp(i, tab.selectedFontSize.hasValue() ? Float.valueOf(tab.selectedFontSize.get()) : null);
+                if (tab.testId.hasValue()) bottomTabs.setTag(i, tab.testId.get());
+                if (shouldApplyDot(tab)) applyDotIndicator(i, tab.dotIndicator); else applyBadge(i, tab);
+            }
+        });
+    }
+
+    public void mergeOptions(Options options) {
+        bottomTabs.perform(bottomTabs -> {
+            bottomTabs.disableItemsCreation();
+            forEach(tabs, tab -> mergeChildOptions(options, tab));
+            bottomTabs.enableItemsCreation();
+        });
     }
 
-    public void mergeChildOptions(Options options, Component child) {
-        int index = bottomTabFinder.findByComponent(child);
-        if (index >= 0) {
-            BottomTabOptions tab = options.bottomTabOptions;
-            if (tab.fontFamily != null) bottomTabs.setTitleTypeface(index, tab.fontFamily);
-            if (tab.selectedIconColor.hasValue()) bottomTabs.setIconActiveColor(index, tab.selectedIconColor.get());
-            if (tab.iconColor.hasValue()) bottomTabs.setIconInactiveColor(index, tab.iconColor.get());
-            if (tab.selectedTextColor.hasValue()) bottomTabs.setTitleActiveColor(index, tab.selectedTextColor.get());
-            if (tab.textColor.hasValue()) bottomTabs.setTitleInactiveColor(index, tab.textColor.get());
-            if (tab.text.hasValue()) bottomTabs.setText(index, tab.text.get());
-            if (tab.icon.hasValue()) imageLoader.loadIcon(context, tab.icon.get(), new ImageLoadingListenerAdapter() {
-                @Override
-                public void onComplete(@NonNull Drawable drawable) {
-                    bottomTabs.setIcon(index, drawable);
-                }
-            });
-            if (tab.testId.hasValue()) bottomTabs.setTag(index, tab.testId.get());
-            if (shouldApplyDot(tab)) mergeDotIndicator(index, tab.dotIndicator); else mergeBadge(index, tab);
-        }
+    public void mergeChildOptions(Options options, ViewController child) {
+        bottomTabs.perform(bottomTabs -> {
+            int index = bottomTabFinder.findByControllerId(child.getId());
+            if (index >= 0) {
+                BottomTabOptions tab = options.bottomTabOptions;
+                if (tab.fontFamily != null) bottomTabs.setTitleTypeface(index, tab.fontFamily);
+                if (tab.selectedIconColor.hasValue()) bottomTabs.setIconActiveColor(index, tab.selectedIconColor.get());
+                if (tab.iconColor.hasValue()) bottomTabs.setIconInactiveColor(index, tab.iconColor.get());
+                if (tab.selectedTextColor.hasValue()) bottomTabs.setTitleActiveColor(index, tab.selectedTextColor.get());
+                if (tab.textColor.hasValue()) bottomTabs.setTitleInactiveColor(index, tab.textColor.get());
+                if (tab.text.hasValue()) bottomTabs.setText(index, tab.text.get());
+                if (tab.icon.hasValue()) imageLoader.loadIcon(context, tab.icon.get(), new ImageLoadingListenerAdapter() {
+                    @Override
+                    public void onComplete(@NonNull Drawable drawable) {
+                        bottomTabs.setIcon(index, drawable);
+                    }
+                });
+                if (tab.testId.hasValue()) bottomTabs.setTag(index, tab.testId.get());
+                if (shouldApplyDot(tab)) mergeDotIndicator(index, tab.dotIndicator); else mergeBadge(index, tab);
+            }
+        });
     }
 
     private void applyDotIndicator(int tabIndex, DotIndicatorOptions dotIndicator) {
         AHNotification.Builder builder = new AHNotification.Builder()
                 .setText("")
                 .setBackgroundColor(dotIndicator.color.get(null))
-                .setSize(dotIndicator.size.get(defaultDotIndicatorSize));
-        bottomTabs.setNotification(builder.build(), tabIndex);
+                .setSize(dotIndicator.size.get(defaultDotIndicatorSize))
+                .animate(dotIndicator.animate.get(false));
+        bottomTabs.perform(bottomTabs -> bottomTabs.setNotification(builder.build(), tabIndex));
     }
 
     private void applyBadge(int tabIndex, BottomTabOptions tab) {
+        if (bottomTabs == null) return;
         AHNotification.Builder builder = new AHNotification.Builder()
                 .setText(tab.badge.get(""))
-                .setBackgroundColor(tab.badgeColor.get(null));
-        bottomTabs.setNotification(builder.build(), tabIndex);
+                .setBackgroundColor(tab.badgeColor.get(null))
+                .animate(tab.animateBadge.get(false));
+        bottomTabs.perform(bottomTabs -> bottomTabs.setNotification(builder.build(), tabIndex));
     }
 
     private void mergeBadge(int index, BottomTabOptions tab) {
+        if (bottomTabs == null) return;
         if (!tab.badge.hasValue()) return;
         AHNotification.Builder builder = new AHNotification.Builder();
         if (tab.badge.hasValue()) builder.setText(tab.badge.get());
         if (tab.badgeColor.hasValue()) builder.setBackgroundColor(tab.badgeColor.get());
-        bottomTabs.setNotification(builder.build(), index);
+        if (tab.badgeColor.hasValue()) builder.setBackgroundColor(tab.badgeColor.get());
+        if (tab.animateBadge.hasValue()) builder.animate(tab.animateBadge.get());
+        bottomTabs.perform(bottomTabs -> bottomTabs.setNotification(builder.build(), index));
     }
 
     private void mergeDotIndicator(int index, DotIndicatorOptions dotIndicator) {
+        if (bottomTabs == null) return;
         AHNotification.Builder builder = new AHNotification.Builder();
         if (dotIndicator.color.hasValue()) builder.setBackgroundColor(dotIndicator.color.get());
         builder.setSize(dotIndicator.visible.isFalse() ? 0 : dotIndicator.size.get(defaultDotIndicatorSize));
+        if (dotIndicator.animate.hasValue()) builder.animate(dotIndicator.animate.get());
         AHNotification notification = builder.build();
-        if (notification.hasValue()) bottomTabs.setNotification(notification, index);
+        if (notification.hasValue()) bottomTabs.perform(bottomTabs -> bottomTabs.setNotification(notification, index));
     }
 
     private boolean shouldApplyDot(BottomTabOptions tab) {

lib/android/app/src/main/java/com/reactnativenavigation/presentation/BottomTabsPresenter.java

 package com.reactnativenavigation.presentation;
 
 import android.graphics.Color;
-import android.support.annotation.IntRange;
 import android.view.ViewGroup;
-import android.view.ViewGroup.MarginLayoutParams;
 
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation.TitleState;
 import com.reactnativenavigation.anim.BottomTabsAnimator;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabFinder;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.TabSelector;
 import com.reactnativenavigation.views.BottomTabs;
-import com.reactnativenavigation.views.Component;
 
 import java.util.List;
 
-import static com.reactnativenavigation.utils.ViewUtils.getHeight;
+import androidx.annotation.IntRange;
 
 public class BottomTabsPresenter {
     private final BottomTabFinder bottomTabFinder;
         animator = new BottomTabsAnimator(bottomTabs);
     }
 
-    public void applyLayoutParamsOptions(Options options, int tabIndex) {
-        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
-        applyDrawBehind(withDefaultOptions.bottomTabsOptions, tabIndex);
-    }
-
     public void mergeOptions(Options options) {
         mergeBottomTabsOptions(options);
     }
         applyBottomTabsOptions(options.copy().withDefaultOptions(defaultOptions));
     }
 
-    public void applyChildOptions(Options options, Component child) {
-        int tabIndex = bottomTabFinder.findByComponent(child);
+    public void applyChildOptions(Options options, ViewController child) {
+        int tabIndex = bottomTabFinder.findByControllerId(child.getId());
         if (tabIndex >= 0) {
-            Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
-            applyBottomTabsOptions(withDefaultOptions);
-            applyDrawBehind(withDefaultOptions.bottomTabsOptions, tabIndex);
+            applyBottomTabsOptions(options.copy().withDefaultOptions(defaultOptions));
+            applyDrawBehind(tabIndex);
         }
     }
 
-    public void mergeChildOptions(Options options, Component child) {
+    public void mergeChildOptions(Options options, ViewController child) {
         mergeBottomTabsOptions(options);
-        int tabIndex = bottomTabFinder.findByComponent(child);
-        if (tabIndex >= 0) mergeDrawBehind(options.bottomTabsOptions, tabIndex);
+        int tabIndex = bottomTabFinder.findByControllerId(child.getId());
+        if (tabIndex >= 0) mergeDrawBehind(tabIndex);
     }
 
     private void mergeBottomTabsOptions(Options options) {
         }
     }
 
-    private void applyDrawBehind(BottomTabsOptions options, @IntRange(from = 0) int tabIndex) {
-        ViewGroup tab = tabs.get(tabIndex).getView();
-        MarginLayoutParams lp = (MarginLayoutParams) tab.getLayoutParams();
-        if (options.drawBehind.isTrue()) {
-            lp.bottomMargin = 0;
-        } else if (options.visible.isTrueOrUndefined()) {
-            lp.bottomMargin = getHeight(bottomTabs);
-        }
+    private void applyDrawBehind(@IntRange(from = 0) int tabIndex) {
+        tabs.get(tabIndex).applyBottomInset();
     }
 
-    private void mergeDrawBehind(BottomTabsOptions options, int tabIndex) {
-        ViewGroup tab = tabs.get(tabIndex).getView();
-        MarginLayoutParams lp = (MarginLayoutParams) tab.getLayoutParams();
-        if (options.drawBehind.isTrue()) {
-            lp.bottomMargin = 0;
-        } else if (options.visible.isTrue() && options.drawBehind.isFalse()) {
-            lp.bottomMargin = getHeight(bottomTabs);
-        }
+    private void mergeDrawBehind(int tabIndex) {
+        tabs.get(tabIndex).applyBottomInset();
     }
 
     private void applyBottomTabsOptions(Options options) {
             bottomTabs.setUseElevation(true, bottomTabsOptions.elevation.get().floatValue());
         }
     }
+
+    public void applyBottomInset(int bottomInset) {
+        ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams) bottomTabs.getLayoutParams();
+        lp.bottomMargin = bottomInset;
+        bottomTabs.requestLayout();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/presentation/ComponentPresenter.java

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.views.ComponentLayout;
 
-public class ComponentPresenter {
+public class ComponentPresenter extends ComponentPresenterBase {
     public Options defaultOptions;
 
     public ComponentPresenter(Options defaultOptions) {

lib/android/app/src/main/java/com/reactnativenavigation/presentation/ComponentPresenterBase.java

+package com.reactnativenavigation.presentation;
+
+import androidx.annotation.NonNull;
+import android.view.View;
+import android.view.ViewGroup.MarginLayoutParams;
+
+public class ComponentPresenterBase {
+    public void applyTopInsets(@NonNull View view, int topInsets) {
+        MarginLayoutParams lp = (MarginLayoutParams) view.getLayoutParams();
+        if (lp.topMargin != topInsets) {
+            lp.topMargin = topInsets;
+            view.requestLayout();
+        }
+    }
+
+    public void applyBottomInset(@NonNull View view, int bottomInset) {
+        MarginLayoutParams lp = (MarginLayoutParams) view.getLayoutParams();
+        if (lp.bottomMargin!= bottomInset) {
+            lp.bottomMargin = bottomInset;
+            view.requestLayout();
+        }
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/presentation/ExternalComponentPresenter.java

+package com.reactnativenavigation.presentation;
+
+public class ExternalComponentPresenter extends ComponentPresenterBase {
+}

lib/android/app/src/main/java/com/reactnativenavigation/presentation/FabPresenter.java

 package com.reactnativenavigation.presentation;
 
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;

lib/android/app/src/main/java/com/reactnativenavigation/presentation/OverlayManager.java

 
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.BehaviourDelegate;
 
 import java.util.HashMap;
 
+import static com.reactnativenavigation.utils.CoordinatorLayoutUtils.matchParentWithBehaviour;
+
 public class OverlayManager {
     private final HashMap<String, ViewController> overlayRegistry = new HashMap<>();
 
     public void show(ViewGroup overlaysContainer, ViewController overlay, CommandListener listener) {
         overlayRegistry.put(overlay.getId(), overlay);
         overlay.addOnAppearedListener(() -> listener.onSuccess(overlay.getId()));
-        overlaysContainer.addView(overlay.getView());
+        overlaysContainer.addView(overlay.getView(), matchParentWithBehaviour(new BehaviourDelegate(overlay)));
     }
 
     public void dismiss(String componentId, CommandListener listener) {

lib/android/app/src/main/java/com/reactnativenavigation/presentation/Presenter.java

 
 import android.app.Activity;
 import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
 import android.os.Build;
 import android.view.View;
 import android.view.ViewGroup.MarginLayoutParams;
+import android.view.Window;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.OrientationOptions;
 import com.reactnativenavigation.parse.StatusBarOptions;
 import com.reactnativenavigation.parse.StatusBarOptions.TextColorScheme;
 import com.reactnativenavigation.parse.params.Bool;
-import com.reactnativenavigation.utils.UiUtils;
+import com.reactnativenavigation.utils.StatusBarUtils;
+import com.reactnativenavigation.viewcontrollers.ParentController;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.viewcontrollers.navigator.Navigator;
+
+import static android.view.WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;
 
 @SuppressWarnings("FieldCanBeLocal")
 public class Presenter {
         mergeStatusBarOptions(view, options.statusBar);
     }
 
-    public void applyOptions(View view, Options options) {
+    public void applyOptions(ViewController view, Options options) {
         Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
         applyOrientation(withDefaultOptions.layout.orientation);
         applyViewOptions(view, withDefaultOptions);
-        applyStatusBarOptions(view, withDefaultOptions.statusBar);
-    }
-
-    public void applyRootOptions(View view, Options options) {
-        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
-        setDrawBehindStatusBar(view, withDefaultOptions.statusBar);
+        applyStatusBarOptions(withDefaultOptions);
     }
 
-    public void onViewBroughtToFront(View view, Options options) {
+    public void onViewBroughtToFront(Options options) {
         Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
-        applyStatusBarOptions(view, withDefaultOptions.statusBar);
+        applyStatusBarOptions(withDefaultOptions);
     }
 
     private void applyOrientation(OrientationOptions options) {
         activity.setRequestedOrientation(options.getValue());
     }
 
-    private void applyViewOptions(View view, Options options) {
-        if (options.layout.backgroundColor.hasValue()) {
-            view.setBackgroundColor(options.layout.backgroundColor.get());
-        }
-        applyTopMargin(view, options);
+    private void applyViewOptions(ViewController view, Options options) {
+        applyBackgroundColor(view, options);
+        applyTopMargin(view.getView(), options);
     }
 
     private void applyTopMargin(View view, Options options) {
         }
     }
 
-    private void applyStatusBarOptions(View view, StatusBarOptions statusBar) {
-        setStatusBarBackgroundColor(statusBar);
-        setTextColorScheme(statusBar.textColorScheme);
-        setStatusBarVisible(view, statusBar.visible, statusBar.drawBehind);
+    private void applyBackgroundColor(ViewController view, Options options) {
+        if (options.layout.backgroundColor.hasValue()) {
+            if (view instanceof Navigator) return;
+
+            LayerDrawable ld = new LayerDrawable(new Drawable[]{new ColorDrawable(options.layout.backgroundColor.get())});
+            int top = view.resolveCurrentOptions().statusBar.drawBehind.isTrue() ? 0 : StatusBarUtils.getStatusBarHeight(view.getActivity());
+            if (!(view instanceof ParentController)) {
+                MarginLayoutParams lp = (MarginLayoutParams) view.getView().getLayoutParams();
+                if (lp.topMargin != 0) top = 0;
+            }
+            ld.setLayerInset(0, 0, top, 0, 0);
+            view.getView().setBackground(ld);
+        }
     }
 
-    private void setStatusBarVisible(View view, Bool visible, Bool drawBehind) {
+    private void applyStatusBarOptions(Options options) {
+        setStatusBarBackgroundColor(options.statusBar);
+        setTextColorScheme(options.statusBar.textColorScheme);
+        setTranslucent(options.statusBar);
+        setStatusBarVisible(options.statusBar.visible);
+    }
+
+    private void setTranslucent(StatusBarOptions options) {
+        Window window = activity.getWindow();
+        if (options.translucent.isTrue()) {
+            window.setFlags(FLAG_TRANSLUCENT_STATUS, FLAG_TRANSLUCENT_STATUS);
+        } else {
+            window.clearFlags(FLAG_TRANSLUCENT_STATUS);
+        }
+    }
+
+    private void setStatusBarVisible(Bool visible) {
+        View decorView = activity.getWindow().getDecorView();
+        int flags = decorView.getSystemUiVisibility();
         if (visible.isFalse()) {
-            view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_FULLSCREEN);
-        } else if (drawBehind.isTrue()) {
-            view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
+            flags |= View.SYSTEM_UI_FLAG_FULLSCREEN;
+        } else {
+            flags &= ~View.SYSTEM_UI_FLAG_FULLSCREEN;
         }
+        decorView.setSystemUiVisibility(flags);
     }
 
     private void setStatusBarBackgroundColor(StatusBarOptions statusBar) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-            activity.getWindow().setStatusBarColor(statusBar.backgroundColor.get(Color.BLACK));
+            int defaultColor = statusBar.visible.isTrueOrUndefined() ? Color.BLACK : Color.TRANSPARENT;
+            activity.getWindow().setStatusBarColor(statusBar.backgroundColor.get(defaultColor));
         }
     }
 
         view.setSystemUiVisibility(flags);
     }
 
-    private void setDrawBehindStatusBar(View view, StatusBarOptions statusBar) {
-        if (statusBar.visible.isFalse()) {
-            ((MarginLayoutParams) view.getLayoutParams()).topMargin = statusBar.drawBehind.isTrue() ?
-                    0 : UiUtils.getStatusBarHeight(activity);
-        }
-    }
-
-
     private void mergeStatusBarOptions(View view, StatusBarOptions statusBar) {
         mergeStatusBarBackgroundColor(statusBar);
         mergeTextColorScheme(statusBar.textColorScheme);
+        mergeTranslucent(statusBar);
         mergeStatusBarVisible(view, statusBar.visible, statusBar.drawBehind);
     }
 
         }
     }
 
+    private void mergeTranslucent(StatusBarOptions options) {
+        Window window = activity.getWindow();
+        if (options.translucent.isTrue()) {
+            window.setFlags(FLAG_TRANSLUCENT_STATUS, FLAG_TRANSLUCENT_STATUS);
+        } else if (options.translucent.isFalse()) {
+            window.clearFlags(FLAG_TRANSLUCENT_STATUS);
+        }
+    }
+
     private void mergeStatusBarVisible(View view, Bool visible, Bool drawBehind) {
         if (visible.hasValue()) {
             int flags = view.getSystemUiVisibility();

lib/android/app/src/main/java/com/reactnativenavigation/presentation/RootPresenter.java

 package com.reactnativenavigation.presentation;
 
 import android.content.Context;
-import android.widget.FrameLayout;
 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.BehaviourDelegate;
 import com.reactnativenavigation.views.element.ElementTransitionManager;
 
+import androidx.annotation.VisibleForTesting;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
+import static com.reactnativenavigation.utils.CoordinatorLayoutUtils.matchParentWithBehaviour;
+
 public class RootPresenter {
     private NavigationAnimator animator;
+    private CoordinatorLayout rootLayout;
     private LayoutDirectionApplier layoutDirectionApplier;
-    private FrameLayout rootLayout;
 
-    public void setRootContainer(FrameLayout rootLayout) {
+    public void setRootContainer(CoordinatorLayout rootLayout) {
         this.rootLayout = rootLayout;
     }
 
         this(new NavigationAnimator(context, new ElementTransitionManager()), new LayoutDirectionApplier());
     }
 
+    @VisibleForTesting
     public RootPresenter(NavigationAnimator animator, LayoutDirectionApplier layoutDirectionApplier) {
         this.animator = animator;
         this.layoutDirectionApplier = layoutDirectionApplier;
 
     public void setRoot(ViewController root, Options defaultOptions, CommandListener listener, ReactInstanceManager reactInstanceManager) {
         layoutDirectionApplier.apply(root, defaultOptions, reactInstanceManager);
-        rootLayout.addView(root.getView());
+        rootLayout.addView(root.getView(), matchParentWithBehaviour(new BehaviourDelegate(root)));
         Options options = root.resolveCurrentOptions(defaultOptions);
         root.setWaitForRender(options.animations.setRoot.waitForRender);
         if (options.animations.setRoot.waitForRender.isTrue()) {

lib/android/app/src/main/java/com/reactnativenavigation/presentation/SideMenuPresenter.java

 package com.reactnativenavigation.presentation;
 
-import android.support.v4.widget.DrawerLayout;
 import android.view.Gravity;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.SideMenuRootOptions;
+import com.reactnativenavigation.views.SideMenu;
+
+import androidx.annotation.RestrictTo;
+import androidx.drawerlayout.widget.DrawerLayout;
 
 public class SideMenuPresenter {
 
-    private DrawerLayout sideMenu;
+    private SideMenu sideMenu;
 
-    public void bindView(DrawerLayout sideMenu) {
+    public void bindView(SideMenu sideMenu) {
         this.sideMenu = sideMenu;
     }
 
             sideMenu.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED, Gravity.RIGHT);
         }
     }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public SideMenu getSideMenu() {
+        return sideMenu;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/presentation/StackPresenter.java

 
 import android.app.Activity;
 import android.graphics.Color;
-import android.support.annotation.Nullable;
-import android.support.annotation.RestrictTo;
-import android.support.v7.widget.Toolbar;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup.LayoutParams;
 import com.reactnativenavigation.utils.CollectionUtils;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.ObjectUtils;
+import com.reactnativenavigation.utils.StatusBarUtils;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 import com.reactnativenavigation.viewcontrollers.TitleBarReactViewController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.button.NavigationIconResolver;
+import com.reactnativenavigation.viewcontrollers.stack.StackController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
-import com.reactnativenavigation.views.Component;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 import com.reactnativenavigation.views.topbar.TopBar;
 import com.reactnativenavigation.views.topbar.TopBarBackgroundViewCreator;
 import java.util.List;
 import java.util.Map;
 
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.appcompat.widget.Toolbar;
+
 import static com.reactnativenavigation.utils.CollectionUtils.*;
 import static com.reactnativenavigation.utils.ObjectUtils.perform;
 
     private final Activity activity;
 
     private TopBar topBar;
+    private TopBarController topBarController;
     private final TitleBarReactViewCreator titleViewCreator;
     private TitleBarButtonController.OnClickListener onClickListener;
     private final ImageLoader imageLoader;
     private final TopBarBackgroundViewCreator topBarBackgroundViewCreator;
     private final ReactViewCreator buttonCreator;
     private Options defaultOptions;
-    private Map<Component, TitleBarReactViewController> titleControllers = new HashMap();
-    private Map<Component, TopBarBackgroundViewController> backgroundControllers = new HashMap();
-    private Map<Component, Map<String, TitleBarButtonController>> componentRightButtons = new HashMap();
-    private Map<Component, Map<String, TitleBarButtonController>> componentLeftButtons = new HashMap();
+
     private List<TitleBarButtonController> currentRightButtons = new ArrayList<>();
+    private Map<View, TitleBarReactViewController> titleControllers = new HashMap();
+    private Map<View, TopBarBackgroundViewController> backgroundControllers = new HashMap();
+    private Map<View, Map<String, TitleBarButtonController>> componentRightButtons = new HashMap();
+    private Map<View, Map<String, TitleBarButtonController>> componentLeftButtons = new HashMap();
 
     public StackPresenter(Activity activity,
                           TitleBarReactViewCreator titleViewCreator,
         return defaultOptions;
     }
 
-    public void bindView(TopBar topBar) {
-        this.topBar = topBar;
+    public void bindView(TopBarController topBarController) {
+        this.topBarController = topBarController;
+        topBar = topBarController.getView();
     }
 
-    public boolean isRendered(Component component) {
+    public boolean isRendered(View component) {
         ArrayList<ViewController> controllers = new ArrayList<>(perform(componentRightButtons.get(component), new ArrayList<>(), Map::values));
         controllers.add(backgroundControllers.get(component));
         controllers.add(titleControllers.get(component));
         return renderChecker.areRendered(filter(controllers, ObjectUtils::notNull));
     }
 
-    public void applyLayoutParamsOptions(Options options, View view) {
-        Options withDefault = options.copy().withDefaultOptions(defaultOptions);
-        if (view instanceof Component) {
-            if (withDefault.topBar.drawBehind.isTrue() && !withDefault.layout.topMargin.hasValue()) {
-                ((Component) view).drawBehindTopBar();
-            } else if (options.topBar.drawBehind.isFalseOrUndefined()) {
-                ((Component) view).drawBelowTopBar(topBar);
-            }
-        }
-    }
-
-    public void mergeOptions(Options options, Component currentChild) {
+    public void mergeOptions(Options options, StackController stack, ViewController currentChild) {
         mergeOrientation(options.layout.orientation);
 //        mergeButtons(topBar, withDefault.topBar.buttons, child);
-        mergeTopBarOptions(options, currentChild);
+        mergeTopBarOptions(options, stack, currentChild);
         mergeTopTabsOptions(options.topTabs);
         mergeTopTabOptions(options.topTabOptions);
     }
         setInitialTopBarVisibility(withDefault.topBar);
     }
 
-    public void applyChildOptions(Options options, Component child) {
+    public void applyChildOptions(Options options, StackController stack, ViewController child) {
         Options withDefault = options.copy().withDefaultOptions(defaultOptions);
         applyOrientation(withDefault.layout.orientation);
         applyButtons(withDefault.topBar, child);
-        applyTopBarOptions(withDefault, child, options);
+        applyTopBarOptions(withDefault, stack, child, options);
         applyTopTabsOptions(withDefault.topTabs);
         applyTopTabOptions(withDefault.topTabOptions);
     }
         ((Activity) topBar.getContext()).setRequestedOrientation(withDefaultOptions.getValue());
     }
 
-    public void onChildDestroyed(Component child) {
-        perform(titleControllers.remove(child), TitleBarReactViewController::destroy);
-        perform(backgroundControllers.remove(child), TopBarBackgroundViewController::destroy);
-        destroyButtons(componentRightButtons.get(child));
-        destroyButtons(componentLeftButtons.get(child));
-        componentRightButtons.remove(child);
-        componentLeftButtons.remove(child);
+    public void onChildDestroyed(ViewController child) {
+        perform(titleControllers.remove(child.getView()), TitleBarReactViewController::destroy);
+        perform(backgroundControllers.remove(child.getView()), TopBarBackgroundViewController::destroy);
+        destroyButtons(componentRightButtons.get(child.getView()));
+        destroyButtons(componentLeftButtons.get(child.getView()));
+        componentRightButtons.remove(child.getView());
+        componentLeftButtons.remove(child.getView());
     }
 
     private void destroyButtons(@Nullable Map<String, TitleBarButtonController> buttons) {
         if (buttons != null) forEach(buttons.values(), ViewController::destroy);
     }
 
-    private void applyTopBarOptions(Options options, Component component, Options componentOptions) {
+    private void applyTopBarOptions(Options options, StackController stack, ViewController child, Options componentOptions) {
+        final View component = child.getView();
         TopBarOptions topBarOptions = options.topBar;
         AnimationsOptions animationOptions = options.animations;
 
+        topBar.setTestId(topBarOptions.testId.get(""));
         topBar.setLayoutDirection(options.layout.direction);
         topBar.setHeight(topBarOptions.height.get(UiUtils.getTopBarHeightDp(activity)));
         topBar.setElevation(topBarOptions.elevation.get(DEFAULT_ELEVATION));
             topBar.clearBackgroundComponent();
         }
 
-        if (topBarOptions.testId.hasValue()) topBar.setTestId(topBarOptions.testId.get());
-        applyTopBarVisibility(topBarOptions, animationOptions, componentOptions);
-        if (topBarOptions.drawBehind.isTrue() && !componentOptions.layout.topMargin.hasValue()) {
-            component.drawBehindTopBar();
-        } else if (topBarOptions.drawBehind.isFalseOrUndefined()) {
-            component.drawBelowTopBar(topBar);
-        }
+        applyTopBarVisibility(topBarOptions, animationOptions, componentOptions, stack, child);
         if (topBarOptions.hideOnScroll.isTrue()) {
             if (component instanceof IReactView) {
                 topBar.enableCollapse(((IReactView) component).getScrollEventListener());
 
     private void setInitialTopBarVisibility(TopBarOptions options) {
         if (options.visible.isFalse()) {
-            topBar.hide();
+            topBarController.hide();
         }
         if (options.visible.isTrueOrUndefined()) {
-            topBar.show();
+            topBarController.show();
         }
     }
 
-    private void applyTopBarVisibility(TopBarOptions options, AnimationsOptions animationOptions, Options componentOptions) {
+    private void applyTopBarVisibility(TopBarOptions options, AnimationsOptions animationOptions, Options componentOptions, StackController stack, ViewController child) {
         if (options.visible.isFalse()) {
+            topBarController.resetViewProperties();
             if (options.animate.isTrueOrUndefined() && componentOptions.animations.push.enabled.isTrueOrUndefined()) {
-                topBar.hideAnimate(animationOptions.pop.topBar);
+                topBarController.hideAnimate(animationOptions.pop.topBar, 0, getTopBarTranslationAnimationDelta(stack, child));
             } else {
-                topBar.hide();
+                topBarController.hide();
             }
-        }
-        if (options.visible.isTrueOrUndefined()) {
+        } else if (options.visible.isTrueOrUndefined()) {
+            topBarController.resetViewProperties();
             if (options.animate.isTrueOrUndefined() && componentOptions.animations.push.enabled.isTrueOrUndefined()) {
-                topBar.showAnimate(animationOptions.push.topBar);
+                topBarController.showAnimate(animationOptions.push.topBar, getTopBarTranslationAnimationDelta(stack, child));
             } else {
-                topBar.show();
+                topBarController.show();
             }
         }
     }
 
-    private void applyButtons(TopBarOptions options, Component child) {
+    private void applyButtons(TopBarOptions options, ViewController child) {
         List<Button> rightButtons = mergeButtonsWithColor(options.buttons.right, options.rightButtonColor, options.rightButtonDisabledColor);
         List<Button> leftButtons = mergeButtonsWithColor(options.buttons.left, options.leftButtonColor, options.leftButtonDisabledColor);
 
         if (rightButtons != null) {
-            List<TitleBarButtonController> rightButtonControllers = getOrCreateButtonControllers(componentRightButtons.get(child), rightButtons);
-            componentRightButtons.put(child, keyBy(rightButtonControllers, TitleBarButtonController::getButtonInstanceId));
+            List<TitleBarButtonController> rightButtonControllers = getOrCreateButtonControllers(componentRightButtons.get(child.getView()), rightButtons);
+            componentRightButtons.put(child.getView(), keyBy(rightButtonControllers, TitleBarButtonController::getButtonInstanceId));
             if (!CollectionUtils.equals(currentRightButtons, rightButtonControllers)) {
                 currentRightButtons = rightButtonControllers;
                 topBar.setRightButtons(rightButtonControllers);
         }
 
         if (leftButtons != null) {
-            List<TitleBarButtonController> leftButtonControllers = getOrCreateButtonControllers(componentLeftButtons.get(child), leftButtons);
-            componentLeftButtons.put(child, keyBy(leftButtonControllers, TitleBarButtonController::getButtonInstanceId));
+            List<TitleBarButtonController> leftButtonControllers = getOrCreateButtonControllers(componentLeftButtons.get(child.getView()), leftButtons);
+            componentLeftButtons.put(child.getView(), keyBy(leftButtonControllers, TitleBarButtonController::getButtonInstanceId));
             topBar.setLeftButtons(leftButtonControllers);
         } else {
             topBar.clearLeftButtons();
         if (topTabOptions.fontFamily != null) topBar.setTopTabFontFamily(topTabOptions.tabIndex, topTabOptions.fontFamily);
     }
 
-    public void onChildWillAppear(Options appearing, Options disappearing) {
-        if (disappearing.topBar.visible.isTrueOrUndefined() && appearing.topBar.visible.isFalse()) {
-            if (disappearing.topBar.animate.isTrueOrUndefined() && disappearing.animations.pop.enabled.isTrueOrUndefined()) {
-                topBar.hideAnimate(disappearing.animations.pop.topBar);
+    public void onChildWillAppear(StackController parent, ViewController appearing, ViewController disappearing) {
+        if (disappearing.options.topBar.visible.isTrueOrUndefined() && appearing.options.topBar.visible.isFalse()) {
+            if (disappearing.options.topBar.animate.isTrueOrUndefined() && disappearing.options.animations.pop.enabled.isTrueOrUndefined()) {
+                topBarController.hideAnimate(disappearing.options.animations.pop.topBar, 0, getTopBarTranslationAnimationDelta(parent, appearing));
             } else {
-                topBar.hide();
+                topBarController.hide();
             }
         }
     }
 
-    public void mergeChildOptions(Options toMerge, Options resolvedOptions, Component child) {
+    public void mergeChildOptions(Options toMerge, Options resolvedOptions, StackController stack, ViewController child) {
         TopBarOptions topBar = toMerge.copy().mergeWith(resolvedOptions).withDefaultOptions(defaultOptions).topBar;
         mergeOrientation(toMerge.layout.orientation);
-        mergeButtons(topBar, toMerge.topBar.buttons, child);
-        mergeTopBarOptions(toMerge, child);
+        mergeButtons(topBar, toMerge.topBar.buttons, child.getView());
+        mergeTopBarOptions(toMerge, stack, child);
         mergeTopTabsOptions(toMerge.topTabs);
         mergeTopTabOptions(toMerge.topTabOptions);
     }
         if (orientationOptions.hasValue()) applyOrientation(orientationOptions);
     }
 
-    private void mergeButtons(TopBarOptions options, TopBarButtons buttons, Component child) {
+    private void mergeButtons(TopBarOptions options, TopBarButtons buttons, View child) {
         List<Button> rightButtons = mergeButtonsWithColor(buttons.right, options.rightButtonColor, options.rightButtonDisabledColor);
         List<Button> leftButtons = mergeButtonsWithColor(buttons.left, options.leftButtonColor, options.leftButtonDisabledColor);
 
         return result;
     }
 
-    private void mergeTopBarOptions(Options options, Component component) {
+    private void mergeTopBarOptions(Options options, StackController stack, ViewController child) {
+        AnimationsOptions animationsOptions = options.copy().withDefaultOptions(defaultOptions).animations;
         TopBarOptions topBarOptions = options.topBar;
-        AnimationsOptions animationsOptions = options.animations;
-
+        final View component = child.getView();
         if (options.layout.direction.hasValue()) topBar.setLayoutDirection(options.layout.direction);
         if (topBarOptions.height.hasValue()) topBar.setHeight(topBarOptions.height.get());
         if (topBarOptions.elevation.hasValue()) topBar.setElevation(topBarOptions.elevation.get());
 
         if (topBarOptions.testId.hasValue()) topBar.setTestId(topBarOptions.testId.get());
 
+        topBarController.resetViewProperties();
         if (topBarOptions.visible.isFalse()) {
             if (topBarOptions.animate.isTrueOrUndefined()) {
-                topBar.hideAnimate(animationsOptions.pop.topBar);
+                topBarController.hideAnimate(animationsOptions.pop.topBar, 0, getTopBarTranslationAnimationDelta(stack, child));
             } else {
-                topBar.hide();
+                topBarController.hide();
             }
         }
         if (topBarOptions.visible.isTrue()) {
             if (topBarOptions.animate.isTrueOrUndefined()) {
-                topBar.showAnimate(animationsOptions.push.topBar);
+                topBarController.showAnimate(animationsOptions.push.topBar, getTopBarTranslationAnimationDelta(stack, child));
             } else {
-                topBar.show();
+                topBarController.show();
             }
         }
-        if (topBarOptions.drawBehind.isTrue()) {
-            component.drawBehindTopBar();
-        }
-        if (topBarOptions.drawBehind.isFalse()) {
-            component.drawBelowTopBar(topBar);
-        }
         if (topBarOptions.hideOnScroll.isTrue() && component instanceof IReactView) {
             topBar.enableCollapse(((IReactView) component).getScrollEventListener());
         }
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    public Map<Component, TitleBarReactViewController> getTitleComponents() {
+    public Map<View, TitleBarReactViewController> getTitleComponents() {
         return titleControllers;
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    public Map<Component, TopBarBackgroundViewController> getBackgroundComponents() {
+    public Map<View, TopBarBackgroundViewController> getBackgroundComponents() {
         return backgroundControllers;
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    public List<TitleBarButtonController> getComponentButtons(Component child) {
+    public List<TitleBarButtonController> getComponentButtons(View child) {
         return merge(getRightButtons(child), getLeftButtons(child), Collections.EMPTY_LIST);
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    public List<TitleBarButtonController> getComponentButtons(Component child, List<TitleBarButtonController> defaultValue) {
+    public List<TitleBarButtonController> getComponentButtons(View child, List<TitleBarButtonController> defaultValue) {
         return merge(getRightButtons(child), getLeftButtons(child), defaultValue);
     }
 
-    private List<TitleBarButtonController> getRightButtons(Component child) {
+    public void applyTopInsets(StackController stack, ViewController child) {
+        if (stack.isCurrentChild(child)) applyStatusBarInsets(stack, child);
+        child.applyTopInset();
+    }
+
+    private List<TitleBarButtonController> getRightButtons(View child) {
         return componentRightButtons.containsKey(child) ? new ArrayList<>(componentRightButtons.get(child).values()) : null;
     }
 
-    private List<TitleBarButtonController> getLeftButtons(Component child) {
+    private List<TitleBarButtonController> getLeftButtons(View child) {
         return componentLeftButtons.containsKey(child) ? new ArrayList<>(componentLeftButtons.get(child).values()) : null;
     }
+
+    private void applyStatusBarInsets(StackController stack, ViewController child) {
+        MarginLayoutParams lp = (MarginLayoutParams) topBar.getLayoutParams();
+        lp.topMargin = getTopBarTopMargin(stack, child);
+        topBar.requestLayout();
+    }
+
+    private int getTopBarTranslationAnimationDelta(StackController stack, ViewController child) {
+        Options options = stack.resolveChildOptions(child).withDefaultOptions(defaultOptions);
+        return options.statusBar.hasTransparency() ? getTopBarTopMargin(stack, child) : 0;
+    }
+
+    private int getTopBarTopMargin(StackController stack, ViewController child) {
+        Options withDefault = stack.resolveChildOptions(child).withDefaultOptions(defaultOptions);
+        int topMargin = UiUtils.dpToPx(activity, withDefault.topBar.topMargin.get(0));
+        int statusBarInset = withDefault.statusBar.visible.isTrueOrUndefined() ? StatusBarUtils.getStatusBarHeight(child.getActivity()) : 0;
+        return topMargin + statusBarInset;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationModule.java

 package com.reactnativenavigation.react;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.parse.parsers.LayoutNodeParser;
 import com.reactnativenavigation.utils.NativeCommandListener;
 import com.reactnativenavigation.utils.Now;
+import com.reactnativenavigation.utils.StatusBarUtils;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.utils.UiThread;
 import com.reactnativenavigation.utils.UiUtils;
 
 import java.util.ArrayList;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import static com.reactnativenavigation.utils.UiUtils.pxToDp;
+
 public class NavigationModule extends ReactContextBaseJavaModule {
     private static final String NAME = "RNNBridgeModule";
 
         WritableMap constants = Arguments.createMap();
         constants.putString(Constants.BACK_BUTTON_JS_KEY, Constants.BACK_BUTTON_ID);
         constants.putDouble(Constants.BOTTOM_TABS_HEIGHT_KEY, Constants.BOTTOM_TABS_HEIGHT);
-        constants.putDouble(Constants.STATUS_BAR_HEIGHT_KEY, UiUtils.pxToDp(ctx, UiUtils.getStatusBarHeight(ctx)));
-        constants.putDouble(Constants.TOP_BAR_HEIGHT_KEY, UiUtils.pxToDp(ctx, UiUtils.getTopBarHeight(ctx)));
+        constants.putDouble(Constants.STATUS_BAR_HEIGHT_KEY, pxToDp(ctx, StatusBarUtils.getStatusBarHeight(ctx)));
+        constants.putDouble(Constants.TOP_BAR_HEIGHT_KEY, pxToDp(ctx, UiUtils.getTopBarHeight(ctx)));
         promise.resolve(constants);
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationPackage.java

 package com.reactnativenavigation.react;
 
-import android.support.annotation.NonNull;
-
 import com.facebook.react.ReactNativeHost;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.uimanager.ViewManager;
 import com.reactnativenavigation.parse.LayoutFactory;
 
-import java.util.Collections;
 import java.util.List;
 
+import androidx.annotation.NonNull;
+
+import static java.util.Collections.singletonList;
+
 public class NavigationPackage implements ReactPackage {
 
     private ReactNativeHost reactNativeHost;
 
-    @SuppressWarnings("WeakerAccess")
     public NavigationPackage(final ReactNativeHost reactNativeHost) {
         this.reactNativeHost = reactNativeHost;
     }
     @NonNull
     @Override
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-        return Collections.singletonList(new NavigationModule(
+        return singletonList(new NavigationModule(
                         reactContext,
                         reactNativeHost.getReactInstanceManager(),
                         new LayoutFactory(reactNativeHost.getReactInstanceManager())
 
     @NonNull
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-        return Collections.singletonList(new ElementViewManager());
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return singletonList(new ElementViewManager());
     }
 }

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

 package com.reactnativenavigation.react;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.bridge.ReactContext;

lib/android/app/src/main/java/com/reactnativenavigation/react/ReactView.java

 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.os.Bundle;
-import android.support.annotation.RestrictTo;
+import androidx.annotation.RestrictTo;
 import android.view.MotionEvent;
 
 import com.facebook.react.ReactInstanceManager;

lib/android/app/src/main/java/com/reactnativenavigation/utils/ButtonPresenter.java

 import android.graphics.PorterDuffColorFilter;
 import android.graphics.Typeface;
 import android.graphics.drawable.Drawable;
-import android.support.annotation.NonNull;
-import android.support.v7.widget.ActionMenuView;
-import android.support.v7.widget.Toolbar;
+import androidx.annotation.NonNull;
+import androidx.appcompat.widget.ActionMenuView;
+import androidx.appcompat.widget.Toolbar;
 import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.style.AbsoluteSizeSpan;

lib/android/app/src/main/java/com/reactnativenavigation/utils/CollectionUtils.java

 package com.reactnativenavigation.utils;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.util.Pair;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.util.Pair;
+
 public class CollectionUtils {
     public interface Apply<T> {
         void on(T t);
         return null;
     }
 
+    public static @Nullable <T> T first(@Nullable Collection<T> items, Filter<T> by, Functions.Func1<T> apply) {
+        if (isNullOrEmpty(items)) return null;
+        for (T item : items) {
+            if (by.filter(item)) {
+                apply.run(item);
+                return item;
+            }
+        }
+        return null;
+    }
+
     public static <T> T last(@Nullable List<T> items) {
         return CollectionUtils.isNullOrEmpty(items) ? null : items.get(items.size() - 1);
     }

lib/android/app/src/main/java/com/reactnativenavigation/utils/ColorUtils.java

 public class ColorUtils {
     public static double[] colorToLAB(int color) {
         final double[] result = new double[3];
-        android.support.v4.graphics.ColorUtils.colorToLAB(color, result);
+        androidx.core.graphics.ColorUtils.colorToLAB(color, result);
         return result;
     }
 
     public static int labToColor(double[] lab) {
-        return android.support.v4.graphics.ColorUtils.LABToColor(lab[0], lab[1], lab[2]);
+        return androidx.core.graphics.ColorUtils.LABToColor(lab[0], lab[1], lab[2]);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/utils/CommandListenerAdapter.java

 package com.reactnativenavigation.utils;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 public class CommandListenerAdapter implements CommandListener {
 

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

+package com.reactnativenavigation.utils;
+
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+public class CoordinatorLayoutUtils {
+    public static CoordinatorLayout.LayoutParams matchParentLP() {
+        return new CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
+    }
+
+    public static CoordinatorLayout.LayoutParams matchParentWithBehaviour(CoordinatorLayout.Behavior behavior) {
+        CoordinatorLayout.LayoutParams lp = new CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        lp.setBehavior(behavior);
+        return lp;
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/utils/ImageLoader.java

 import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.StrictMode;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
 import com.reactnativenavigation.NavigationApplication;

lib/android/app/src/main/java/com/reactnativenavigation/utils/ImageLoadingListenerAdapter.java

 package com.reactnativenavigation.utils;
 
 import android.graphics.drawable.Drawable;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import java.util.List;
 

lib/android/app/src/main/java/com/reactnativenavigation/utils/LateInit.java

+package com.reactnativenavigation.utils;
+
+import com.reactnativenavigation.utils.Functions.Func1;
+
+import androidx.annotation.NonNull;
+
+public class LateInit<T> {
+    private T value;
+
+    public T get() {
+        return value;
+    }
+
+    public void set(@NonNull T value) {
+        this.value = value;
+    }
+
+    public void perform(Func1<T> task) {
+        if (value != null) task.run(value);
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/utils/NativeCommandListener.java

 package com.reactnativenavigation.utils;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.react.EventEmitter;

lib/android/app/src/main/java/com/reactnativenavigation/utils/ObjectUtils.java

 package com.reactnativenavigation.utils;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import com.reactnativenavigation.utils.Functions.Func1;
 import com.reactnativenavigation.utils.Functions.FuncR1;

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

 package com.reactnativenavigation.utils;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 import java.lang.reflect.Field;
 

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

+package com.reactnativenavigation.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.Build;
+
+import static com.reactnativenavigation.utils.UiUtils.dpToPx;
+
+public class StatusBarUtils {
+    private static final int STATUS_BAR_HEIGHT_M = 24;
+    private static final int STATUS_BAR_HEIGHT_L = 25;
+    private static int statusBarHeight = -1;
+
+    public static void saveStatusBarHeight(int height) {
+        statusBarHeight = height;
+    }
+
+    public static int getStatusBarHeight(Context context) {
+        if (statusBarHeight > 0) {
+            return statusBarHeight;
+        }
+        final Resources resources = context.getResources();
+        final int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
+        statusBarHeight = resourceId > 0 ?
+                resources.getDimensionPixelSize(resourceId) :
+                dpToPx(context, Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? STATUS_BAR_HEIGHT_M : STATUS_BAR_HEIGHT_L);
+        return statusBarHeight;
+    }
+
+}

lib/android/app/src/main/java/com/reactnativenavigation/utils/StringUtils.java

 package com.reactnativenavigation.utils;
 
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 
 public class StringUtils {
 

lib/android/app/src/main/java/com/reactnativenavigation/utils/TextViewUtils.java

 package com.reactnativenavigation.utils;
 
 import android.graphics.Color;
-import android.support.annotation.ColorInt;
+import androidx.annotation.ColorInt;
 import android.text.SpannableString;
 import android.text.Spanned;
 import android.text.SpannedString;

lib/android/app/src/main/java/com/reactnativenavigation/utils/TypefaceLoader.java

 import android.content.Context;
 import android.content.res.AssetManager;
 import android.graphics.Typeface;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 import android.text.TextUtils;
 
 import java.io.IOException;

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

 
 import android.content.Context;
 import android.content.res.Resources;
-import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.util.DisplayMetrics;
 import android.view.View;
 import android.view.ViewTreeObserver;
 import android.view.WindowManager;
 
 public class UiUtils {
-    private static final int STATUS_BAR_HEIGHT_M = 24;
-    private static final int STATUS_BAR_HEIGHT_L = 25;
     private static final int DEFAULT_TOOLBAR_HEIGHT = 56;
 
-    private static int statusBarHeight = -1;
     private static int topBarHeight = -1;
 
     public static <T extends View> void runOnPreDrawOnce(@Nullable final T view, final Functions.Func1<T> task) {
         return metrics;
     }
 
-    public static int getStatusBarHeight(Context context) {
-        if (statusBarHeight > 0) {
-            return statusBarHeight;
-        }
-        final Resources resources = context.getResources();
-        final int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
-        statusBarHeight = resourceId > 0 ?
-                resources.getDimensionPixelSize(resourceId) :
-                dpToPx(context, Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? STATUS_BAR_HEIGHT_M : STATUS_BAR_HEIGHT_L);
-        return statusBarHeight;
-    }
-
     public static int getTopBarHeightDp(Context context) {
         return (int) UiUtils.pxToDp(context, getTopBarHeight(context));
     }

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

 package com.reactnativenavigation.utils;
 
 import android.graphics.Point;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewManager;
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+
 public class ViewUtils {
     @Nullable
     public static <T extends View> T findChildByClass(ViewGroup root, Class<T> clazz) {
     }
 
     public static boolean isChildOf(ViewGroup parent, View child) {
-        if (parent == child) return true;
+        if (parent == child) return false;
 
         for (int i = 0; i < parent.getChildCount(); i++) {
             View view = parent.getChildAt(i);
             ((ViewManager) parent).removeView(view);
         }
     }
+
+    public static boolean isVisible(View view) {
+        return perform(view, false, v -> v.getVisibility() == View.VISIBLE);
+    }
+
+    public static int topMargin(View view) {
+        return ((ViewGroup.MarginLayoutParams) view.getLayoutParams()).topMargin;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/utils/WindowInsetsUtils.java

+package com.reactnativenavigation.utils;
+
+import androidx.core.view.WindowInsetsCompat;
+import android.util.Log;
+
+public class WindowInsetsUtils {
+    private static final String TAG = "GUYCA";
+
+    public static void log(WindowInsetsCompat i) {
+        Log.i(TAG, "t: " + i.getStableInsetTop() +
+                   " sysT: " + i.getSystemWindowInsetTop() +
+                   " b: " + i.getStableInsetBottom() +
+                   " sysB: " + i.getSystemWindowInsetBottom());
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ChildController.java

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
-import android.support.annotation.CallSuper;
+import androidx.annotation.CallSuper;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
+import android.view.View;
 import android.view.ViewGroup;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.Presenter;
+import com.reactnativenavigation.utils.StatusBarUtils;
 import com.reactnativenavigation.viewcontrollers.navigator.Navigator;
 import com.reactnativenavigation.views.Component;
 
 public abstract class ChildController<T extends ViewGroup> extends ViewController<T>  {
-    final Presenter presenter;
+    private final Presenter presenter;
     private final ChildControllersRegistry childRegistry;
 
     public ChildControllersRegistry getChildRegistry() {
         this.childRegistry = childRegistry;
     }
 
+    @Override
+    public T getView() {
+        if (view == null) {
+            super.getView();
+            view.setFitsSystemWindows(true);
+            ViewCompat.setOnApplyWindowInsetsListener(view, this::onApplyWindowInsets);
+        }
+        return view;
+    }
+
     @Override
     @CallSuper
     public void setDefaultOptions(Options defaultOptions) {
     }
 
     public void onViewBroughtToFront() {
-        presenter.onViewBroughtToFront(getView(), options);
+        presenter.onViewBroughtToFront(resolveCurrentOptions());
     }
 
     @Override
     public void applyOptions(Options options) {
         super.applyOptions(options);
         Options resolvedOptions = resolveCurrentOptions();
-        presenter.applyOptions(getView(), resolvedOptions);
-        if (isRoot()) {
-            presenter.applyRootOptions(getView(), resolvedOptions);
-        }
+        presenter.applyOptions(this, resolvedOptions);
     }
 
     @Override
     @Override
     public void destroy() {
         if (!isDestroyed() && getView() instanceof Component) {
-            performOnParentController(parent -> parent.onChildDestroyed((Component) getView()));
+            performOnParentController(parent -> parent.onChildDestroyed(this));
         }
         super.destroy();
         childRegistry.onChildDestroyed(this);
                 !(this instanceof Navigator) &&
                 getView().getParent() != null;
     }
+
+    private WindowInsetsCompat onApplyWindowInsets(View view, WindowInsetsCompat insets) {
+        StatusBarUtils.saveStatusBarHeight(insets.getSystemWindowInsetTop());
+        return applyWindowInsets(findController(view), insets);
+    }
+
+    protected WindowInsetsCompat applyWindowInsets(ViewController view, WindowInsetsCompat insets) {
+        return insets.replaceSystemWindowInsets(
+                insets.getSystemWindowInsetLeft(),
+                0,
+                insets.getSystemWindowInsetRight(),
+                insets.getSystemWindowInsetBottom()
+        );
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ChildControllersRegistry.java

 
 import java.util.ArrayDeque;
 
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+
 public class ChildControllersRegistry {
     private ArrayDeque<ChildController> children = new ArrayDeque<>();
 
     }
 
     private boolean isTopChild(ChildController child) {
-        return children.peek().equals(child);
+        return perform(children.peek(), false, c -> c.equals(child));
     }
 
     public int size() {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ComponentViewController.java

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
-import android.support.annotation.NonNull;
 import android.view.View;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.ComponentPresenter;
 import com.reactnativenavigation.presentation.Presenter;
+import com.reactnativenavigation.utils.StatusBarUtils;
 import com.reactnativenavigation.views.ComponentLayout;
 import com.reactnativenavigation.views.ReactComponent;
 
-public class ComponentViewController extends ChildController<ComponentLayout> {
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsCompat;
+
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
 
+public class ComponentViewController extends ChildController<ComponentLayout> {
     private final String componentName;
     private ComponentPresenter presenter;
     private final ReactViewCreator viewCreator;
 
+    ReactComponent getComponent() {
+        return view;
+    }
+
     public ComponentViewController(final Activity activity,
                                    final ChildControllersRegistry childRegistry,
                                    final String id,
     @Override
     public void onViewAppeared() {
         super.onViewAppeared();
-        view.sendComponentStart();
+        if (view != null) view.sendComponentStart();
     }
 
     @Override
     public void onViewDisappear() {
-        view.sendComponentStop();
+        if (view != null) view.sendComponentStop();
         super.onViewDisappear();
     }
 
 
     @Override
     public void applyOptions(Options options) {
+        if (isRoot()) applyTopInset();
         super.applyOptions(options);
         getView().applyOptions(options);
         presenter.applyOptions(getView(), resolveCurrentOptions(presenter.defaultOptions));
 
     @Override
     public boolean isViewShown() {
-        return super.isViewShown() && view.isReady();
+        return super.isViewShown() && view != null && view.isReady();
     }
 
     @NonNull
     public void mergeOptions(Options options) {
         if (options == Options.EMPTY) return;
         presenter.mergeOptions(getView(), options);
-        performOnParentController(parentController -> parentController.mergeChildOptions(options, this, getView()));
         super.mergeOptions(options);
+        performOnParentController(parentController -> parentController.mergeChildOptions(options, this));
     }
 
-    ReactComponent getComponent() {
-        return view;
+    @Override
+    public void applyTopInset() {
+        if (view != null) presenter.applyTopInsets(view, getTopInset());
+    }
+
+    @Override
+    public int getTopInset() {
+        int statusBarInset = resolveCurrentOptions().statusBar.isHiddenOrDrawBehind() ? 0 : StatusBarUtils.getStatusBarHeight(getActivity());
+        return statusBarInset + perform(getParentController(), 0, p -> p.getTopInset(this));
+    }
+
+    @Override
+    public void applyBottomInset() {
+        if (view != null) presenter.applyBottomInset(view, getBottomInset());
+    }
+
+    @Override
+    protected WindowInsetsCompat applyWindowInsets(ViewController view, WindowInsetsCompat insets) {
+        ViewCompat.onApplyWindowInsets(view.getView(), insets.replaceSystemWindowInsets(
+                insets.getSystemWindowInsetLeft(),
+                insets.getSystemWindowInsetTop(),
+                insets.getSystemWindowInsetRight(),
+                Math.max(insets.getSystemWindowInsetBottom() - getBottomInset(), 0)
+        ));
+        return insets;
     }
 
     @Override

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/IdStack.java

 package com.reactnativenavigation.viewcontrollers;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.reactnativenavigation.utils.StringUtils;
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ParentController.java

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
-import android.support.annotation.CallSuper;
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.view.ViewPager;
+import android.view.View;
 import android.view.ViewGroup;
 
 import com.reactnativenavigation.parse.Options;
 
 import java.util.Collection;
 
-import static com.reactnativenavigation.utils.CollectionUtils.forEach;
+import androidx.annotation.CallSuper;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.viewpager.widget.ViewPager;
+
+import static com.reactnativenavigation.utils.CollectionUtils.*;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
 
 public abstract class ParentController<T extends ViewGroup> extends ChildController {
 
                 .withDefaultOptions(initialOptions);
     }
 
+    public Options resolveChildOptions(ViewController child) {
+	    if (child == this) return resolveCurrentOptions();
+        return child
+                .resolveCurrentOptions()
+                .copy()
+                .withDefaultOptions(initialOptions);
+    }
+
     @Override
     @CheckResult
     public Options resolveCurrentOptions(Options defaultOptions) {
         return resolveCurrentOptions().withDefaultOptions(defaultOptions);
     }
 
+    public boolean isCurrentChild(ViewController child) {
+        return getCurrentChild() == child;
+    }
+
     protected abstract ViewController getCurrentChild();
 
     @NonNull
 		return null;
 	}
 
+    @Nullable
+    @Override
+    public ViewController findController(View child) {
+        ViewController fromSuper = super.findController(child);
+        if (fromSuper != null) return fromSuper;
+
+        for (ViewController childController : getChildControllers()) {
+            ViewController fromChild = childController.findController(child);
+            if (fromChild != null) return fromChild;
+        }
+
+        return null;
+    }
+
     @Override
     public boolean containsComponent(Component component) {
         if (super.containsComponent(component)) {
     }
 
     @CallSuper
-    public void applyChildOptions(Options options, Component child) {
+    public void applyChildOptions(Options options, ViewController child) {
         this.options = initialOptions.mergeWith(options);
-        if (isRoot()) {
-            presenter.applyRootOptions(getView(), options);
-        }
     }
 
     @CallSuper
-    public void mergeChildOptions(Options options, ViewController childController, Component child) {
+    public void mergeChildOptions(Options options, ViewController childController) {
 
     }
 
 	@Override
 	public void destroy() {
 		super.destroy();
-		for (ViewController child : getChildControllers()) {
-			child.destroy();
-		}
+		forEach(getChildControllers(), ViewController::destroy);
 	}
 
-	@CallSuper
+	@SuppressWarnings("WeakerAccess")
+    @CallSuper
     protected void clearOptions() {
 	    performOnParentController(parent -> ((ParentController) parent).clearOptions());
         options = initialOptions.copy().clearOneTimeOptions();
         return getCurrentChild() != null && getCurrentChild().isRendered();
     }
 
-    public void onChildDestroyed(Component child) {
+    public void onChildDestroyed(ViewController child) {
+
+    }
+
+    @Override
+    public void applyTopInset() {
+	    forEach(getChildControllers(), ViewController::applyTopInset);
+    }
+
+    public int getTopInset(ViewController child) {
+        return perform(getParentController(), 0, p -> p.getTopInset(child));
+    }
+
+    @Override
+    public void applyBottomInset() {
+        forEach(getChildControllers(), ViewController::applyBottomInset);
+    }
 
+    public int getBottomInset(ViewController child) {
+        return perform(getParentController(), 0, p -> p.getBottomInset(child));
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/TitleBarButtonController.java

 import android.app.Activity;
 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
-import android.support.annotation.NonNull;
-import android.support.annotation.RestrictTo;
-import android.support.v7.widget.ActionMenuView;
-import android.support.v7.widget.Toolbar;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.appcompat.widget.ActionMenuView;
+import androidx.appcompat.widget.Toolbar;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.widget.ImageButton;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewController.java

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
-import android.support.annotation.CallSuper;
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.annotation.VisibleForTesting;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewManager;
 import com.reactnativenavigation.utils.UiThread;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
+import com.reactnativenavigation.views.BehaviourAdapter;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.Renderable;
 import com.reactnativenavigation.views.element.Element;
 import java.util.Collections;
 import java.util.List;
 
-import static com.reactnativenavigation.utils.CollectionUtils.forEach;
+import androidx.annotation.CallSuper;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
 
-public abstract class ViewController<T extends ViewGroup> implements ViewTreeObserver.OnGlobalLayoutListener, ViewGroup.OnHierarchyChangeListener {
+import static com.reactnativenavigation.utils.CollectionUtils.*;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+
+public abstract class ViewController<T extends ViewGroup> implements ViewTreeObserver.OnGlobalLayoutListener,
+        ViewGroup.OnHierarchyChangeListener,
+        BehaviourAdapter<T> {
 
     private final List<Runnable> onAppearedListeners = new ArrayList();
     private boolean appearEventPosted;
         return activity;
     }
 
+    public void performOnView(Func1<View> task) {
+        if (view != null) task.run(view);
+    }
+
     protected void performOnParentController(Func1<ParentController> task) {
         if (parentController != null) task.run(parentController);
     }
             task.run((StackController) parentController);
         } else if (this instanceof StackController) {
             task.run((StackController) this);
-        } else if (parentController != null){
-            parentController.performOnParentStack(task);
-        }
+        } else performOnParentController(parent -> parent.performOnParentStack(task));
     }
 
     public T getView() {
         return isSameId(id) ? this : null;
     }
 
+    @Nullable
+    public ViewController findController(View child) {
+        return view == child ? this : null;
+    }
+
     public boolean containsComponent(Component component) {
         return getView().equals(component);
     }
         applyOptions(options);
         performOnParentController(parentController -> {
             parentController.clearOptions();
-            if (getView() instanceof Component) parentController.applyChildOptions(options, (Component) getView());
+            if (getView() instanceof Component) parentController.applyChildOptions(options, this);
         });
         if (!onAppearedListeners.isEmpty() && !appearEventPosted) {
             appearEventPosted = true;
     public List<Element> getElements() {
         return getView() instanceof IReactView && view != null? ((IReactView) view).getElements() : Collections.EMPTY_LIST;
     }
+
+    @Override
+    @CallSuper
+    public boolean onMeasureChild(CoordinatorLayout parent, T child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed) {
+        perform(findController(child), ViewController::applyTopInset);
+        return false;
+    }
+
+    @Override
+    public boolean onDependentViewChanged(CoordinatorLayout parent, T child, View dependency) {
+        return false;
+    }
+
+    public void applyTopInset() {
+
+    }
+
+    public int getTopInset() {
+        return 0;
+    }
+
+    public void applyBottomInset() {
+
+    }
+
+    public int getBottomInset() {
+        return perform(parentController, 0, p -> p.getBottomInset(this));
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/YellowBoxDelegate.java

 package com.reactnativenavigation.viewcontrollers;
 
-import android.support.annotation.RestrictTo;
+import androidx.annotation.RestrictTo;
 import android.view.View;
 import android.view.ViewGroup;
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/YellowBoxHelper.java

 package com.reactnativenavigation.viewcontrollers;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/AttachMode.java

 package com.reactnativenavigation.viewcontrollers.bottomtabs;
 
-import android.support.annotation.VisibleForTesting;
-import android.view.*;
-import android.widget.*;
+import androidx.annotation.VisibleForTesting;
+import android.view.View;
+import android.view.ViewGroup;
 
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.presentation.*;
-import com.reactnativenavigation.viewcontrollers.*;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.BottomTabsPresenter;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.bottomtabs.BottomTabsBehaviour;
 
-import java.util.*;
+import java.util.List;
 
-import static android.view.ViewGroup.LayoutParams.*;
+import static com.reactnativenavigation.utils.CoordinatorLayoutUtils.matchParentWithBehaviour;
 
 public abstract class AttachMode {
     protected final ViewGroup parent;
     protected final BottomTabsPresenter presenter;
     protected final List<ViewController> tabs;
     final ViewController initialTab;
-    private final Options resolved;
-
 
     public static AttachMode get(ViewGroup parent, List<ViewController> tabs, BottomTabsPresenter presenter, Options resolved) {
         switch (resolved.bottomTabsOptions.tabsAttachMode) {
         this.parent = parent;
         this.tabs = tabs;
         this.presenter = presenter;
-        this.resolved = resolved;
         initialTab = tabs.get(resolved.bottomTabsOptions.currentTabIndex.get(0));
     }
 
     @VisibleForTesting(otherwise = VisibleForTesting.PROTECTED)
     public void attach(ViewController tab) {
         ViewGroup view = tab.getView();
-        view.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
-        presenter.applyLayoutParamsOptions(resolved, tabs.indexOf(tab));
         view.setVisibility(tab == initialTab ? View.VISIBLE : View.INVISIBLE);
-        parent.addView(view);
+        parent.addView(view, matchParentWithBehaviour(new BottomTabsBehaviour(tab.getParentController())));
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabFinder.java

 package com.reactnativenavigation.viewcontrollers.bottomtabs;
 
-import android.support.annotation.IntRange;
+import androidx.annotation.IntRange;
 
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.views.Component;
 
 import java.util.List;
 
         this.tabs = tabs;
     }
 
-    @IntRange(from = -1)
-    public int findByComponent(Component component) {
-        for (int i = 0; i < tabs.size(); i++) {
-            if (tabs.get(i).containsComponent(component)) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
     @IntRange(from = -1)
     public int findByControllerId(String id) {
         for (int i = 0; i < tabs.size(); i++) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabsAttacher.java

 package com.reactnativenavigation.viewcontrollers.bottomtabs;
 
-import android.support.annotation.VisibleForTesting;
+import androidx.annotation.VisibleForTesting;
 import android.view.ViewGroup;
 
 import com.reactnativenavigation.parse.Options;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabsController.java

 package com.reactnativenavigation.viewcontrollers.bottomtabs;
 
 import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.support.annotation.RestrictTo;
+import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.RelativeLayout;
 
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.views.BottomTabs;
-import com.reactnativenavigation.views.Component;
+import com.reactnativenavigation.views.bottomtabs.BottomTabsLayout;
 
 import java.util.Collection;
 import java.util.List;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
-import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
-import static com.reactnativenavigation.react.Constants.BOTTOM_TABS_HEIGHT;
+import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
 import static com.reactnativenavigation.utils.CollectionUtils.*;
-import static com.reactnativenavigation.utils.UiUtils.dpToPx;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
 
-public class BottomTabsController extends ParentController implements AHBottomNavigation.OnTabSelectedListener, TabSelector {
+public class BottomTabsController extends ParentController<BottomTabsLayout> implements AHBottomNavigation.OnTabSelectedListener, TabSelector {
 
 	private BottomTabs bottomTabs;
 	private List<ViewController> tabs;
         this.tabsAttacher = tabsAttacher;
         this.presenter = bottomTabsPresenter;
         this.tabPresenter = bottomTabPresenter;
-        forEach(tabs, (tab) -> tab.setParentController(this));
+        forEach(tabs, tab -> tab.setParentController(this));
     }
 
     @Override
 
     @NonNull
 	@Override
-	protected ViewGroup createView() {
-		RelativeLayout root = new RelativeLayout(getActivity());
-		bottomTabs = createBottomTabs();
+	protected BottomTabsLayout createView() {
+        BottomTabsLayout root = new BottomTabsLayout(getActivity());
+
+        bottomTabs = createBottomTabs();
         tabsAttacher.init(root, resolveCurrentOptions());
         presenter.bindView(bottomTabs, this);
         tabPresenter.bindView(bottomTabs);
         bottomTabs.setOnTabSelectedListener(this);
-		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, dpToPx(getActivity(), BOTTOM_TABS_HEIGHT));
-		lp.addRule(ALIGN_PARENT_BOTTOM);
+        CoordinatorLayout.LayoutParams lp = new CoordinatorLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT);
+        lp.gravity = Gravity.BOTTOM;
 		root.addView(bottomTabs, lp);
-		bottomTabs.addItems(createTabs());
+
+        bottomTabs.addItems(createTabs());
         tabsAttacher.attach();
         return root;
 	}
     @Override
     public void mergeOptions(Options options) {
         presenter.mergeOptions(options);
+        tabPresenter.mergeOptions(options);
         super.mergeOptions(options);
         this.options.bottomTabsOptions.clearOneTimeOptions();
         this.initialOptions.bottomTabsOptions.clearOneTimeOptions();
     }
 
     @Override
-    public void applyChildOptions(Options options, Component child) {
+    public void applyChildOptions(Options options, ViewController child) {
         super.applyChildOptions(options, child);
         presenter.applyChildOptions(resolveCurrentOptions(), child);
         performOnParentController(parentController ->
     }
 
     @Override
-    public void mergeChildOptions(Options options, ViewController childController, Component child) {
-        super.mergeChildOptions(options, childController, child);
+    public void mergeChildOptions(Options options, ViewController child) {
+        super.mergeChildOptions(options, child);
         presenter.mergeChildOptions(options, child);
         tabPresenter.mergeChildOptions(options, child);
         performOnParentController(parentController ->
-                ((ParentController) parentController).mergeChildOptions(options.copy().clearBottomTabsOptions(), childController, child)
+                ((ParentController) parentController).mergeChildOptions(options.copy().clearBottomTabsOptions(), child)
         );
     }
 
 		return bottomTabs.getCurrentItem();
 	}
 
-	@NonNull
+    @Override
+    public boolean onMeasureChild(CoordinatorLayout parent, ViewGroup child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed) {
+        perform(findController(child), ViewController::applyBottomInset);
+        return super.onMeasureChild(parent, child, parentWidthMeasureSpec, widthUsed, parentHeightMeasureSpec, heightUsed);
+    }
+
+    @Override
+    public int getBottomInset(ViewController child) {
+        int bottomTabsInset = resolveChildOptions(child).bottomTabsOptions.drawBehind.isTrue() ? 0 : bottomTabs.getHeight();
+        return bottomTabsInset + perform(getParentController(), 0, p -> p.getBottomInset(this));
+    }
+
+    @Override
+    public void applyBottomInset() {
+        presenter.applyBottomInset(getBottomInset());
+        super.applyBottomInset();
+    }
+
+    @NonNull
 	@Override
 	public Collection<ViewController> getChildControllers() {
 		return tabs;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/button/NavigationIconResolver.java

 
 import android.content.Context;
 import android.graphics.drawable.Drawable;
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
 import android.util.Log;
 import android.view.View;
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/externalcomponent/ExternalComponentCreator.java

 package com.reactnativenavigation.viewcontrollers.externalcomponent;
 
-import android.support.v4.app.FragmentActivity;
+import androidx.fragment.app.FragmentActivity;
 
 import com.facebook.react.ReactInstanceManager;
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/externalcomponent/ExternalComponentViewController.java

 package com.reactnativenavigation.viewcontrollers.externalcomponent;
 
 import android.app.Activity;
-import android.support.v4.app.FragmentActivity;
+import androidx.fragment.app.FragmentActivity;
+import androidx.core.view.ViewCompat;
+import android.view.View;
 
 import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.parse.ExternalComponent;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.ExternalComponentPresenter;
 import com.reactnativenavigation.react.EventEmitter;
+import com.reactnativenavigation.utils.CoordinatorLayoutUtils;
+import com.reactnativenavigation.utils.StatusBarUtils;
 import com.reactnativenavigation.viewcontrollers.NoOpYellowBoxDelegate;
 import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.BehaviourDelegate;
 import com.reactnativenavigation.views.ExternalComponentLayout;
 
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+
 public class ExternalComponentViewController extends ViewController<ExternalComponentLayout> {
     private final ExternalComponent externalComponent;
     private final ExternalComponentCreator componentCreator;
     private ReactInstanceManager reactInstanceManager;
     private final EventEmitter emitter;
+    private final ExternalComponentPresenter presenter;
 
-    public ExternalComponentViewController(Activity activity, String id, ExternalComponent externalComponent, ExternalComponentCreator componentCreator, ReactInstanceManager reactInstanceManager, EventEmitter emitter, Options initialOptions) {
+    public ExternalComponentViewController(Activity activity, String id, ExternalComponent externalComponent, ExternalComponentCreator componentCreator, ReactInstanceManager reactInstanceManager, EventEmitter emitter, ExternalComponentPresenter presenter, Options initialOptions) {
         super(activity, id, new NoOpYellowBoxDelegate(), initialOptions);
         this.externalComponent = externalComponent;
         this.componentCreator = componentCreator;
         this.reactInstanceManager = reactInstanceManager;
         this.emitter = emitter;
+        this.presenter = presenter;
     }
 
     @Override
     protected ExternalComponentLayout createView() {
         ExternalComponentLayout content = new ExternalComponentLayout(getActivity());
+        enableDrawingBehindStatusBar(content);
         content.addView(componentCreator
                 .create(getActivity(), reactInstanceManager, externalComponent.passProps)
-                .asView());
+                .asView(), CoordinatorLayoutUtils.matchParentWithBehaviour(new BehaviourDelegate(this)));
         return content;
     }
 
     @Override
     public void mergeOptions(Options options) {
         if (options == Options.EMPTY) return;
-        performOnParentController(parentController -> parentController.mergeChildOptions(options, this, getView()));
+        performOnParentController(parentController -> parentController.mergeChildOptions(options, this));
         super.mergeOptions(options);
     }
 
         emitter.emitComponentDidDisappear(getId(), externalComponent.name.get());
     }
 
+    @Override
+    public void applyTopInset() {
+        if (view != null) presenter.applyTopInsets(view, getTopInset());
+    }
+
+    @Override
+    public int getTopInset() {
+        int statusBarInset = resolveCurrentOptions().statusBar.drawBehind.isTrue() ? 0 : StatusBarUtils.getStatusBarHeight(getActivity());
+        return statusBarInset + perform(getParentController(), 0, p -> p.getTopInset(this));
+    }
+
+    @Override
+    public void applyBottomInset() {
+        if (view != null) presenter.applyBottomInset(view, getBottomInset());
+    }
+
     public FragmentActivity getActivity() {
         return (FragmentActivity) super.getActivity();
     }
+
+    private void enableDrawingBehindStatusBar(View view) {
+        view.setFitsSystemWindows(true);
+        ViewCompat.setOnApplyWindowInsetsListener(view, (v, insets) -> insets);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenter.java

 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
-import android.support.annotation.Nullable;
 import android.view.ViewGroup;
 
 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
+import androidx.annotation.Nullable;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
+import static com.reactnativenavigation.utils.CoordinatorLayoutUtils.matchParentLP;
+
 public class ModalPresenter {
 
     private ViewGroup rootLayout;
-    private ViewGroup modalsLayout;
+    private CoordinatorLayout modalsLayout;
     private ModalAnimator animator;
     private Options defaultOptions = new Options();
 
         this.animator = animator;
     }
 
-    public void setRootLayout(ViewGroup rootLayout) {
+    void setRootLayout(ViewGroup rootLayout) {
         this.rootLayout = rootLayout;
     }
 
-    void setModalsLayout(ViewGroup modalsLayout) {
+    void setModalsLayout(CoordinatorLayout modalsLayout) {
         this.modalsLayout = modalsLayout;
     }
 
             listener.onError("Can not show modal before activity is created");
             return;
         }
+
         Options options = toAdd.resolveCurrentOptions(defaultOptions);
         toAdd.setWaitForRender(options.animations.showModal.waitForRender);
-        modalsLayout.addView(toAdd.getView());
+        modalsLayout.addView(toAdd.getView(), matchParentLP());
+
         if (options.animations.showModal.enabled.isTrueOrUndefined()) {
+            toAdd.getView().setAlpha(0);
             if (options.animations.showModal.waitForRender.isTrue()) {
                 toAdd.addOnAppearedListener(() -> animateShow(toAdd, toRemove, listener, options));
             } else {
 
     private void animateShow(ViewController toAdd, ViewController toRemove, CommandListener listener, Options options) {
         animator.show(toAdd.getView(), options.animations.showModal, new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                toAdd.getView().setAlpha(1);
+            }
+
             @Override
             public void onAnimationEnd(Animator animation) {
                 onShowModalEnd(toAdd, toRemove, listener);

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalStack.java

 package com.reactnativenavigation.viewcontrollers.modal;
 
 import android.app.Activity;
-import android.support.annotation.RestrictTo;
+import androidx.annotation.RestrictTo;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
 import android.view.ViewGroup;
 
 import com.reactnativenavigation.anim.ModalAnimator;
         this.presenter = presenter;
     }
 
-    public void setModalsLayout(ViewGroup modalsLayout) {
+    public void setModalsLayout(CoordinatorLayout modalsLayout) {
         presenter.setModalsLayout(modalsLayout);
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/navigator/Navigator.java

 package com.reactnativenavigation.viewcontrollers.navigator;
 
 import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.annotation.RestrictTo;
 import android.view.ViewGroup;
-import android.widget.FrameLayout;
 
+import com.facebook.react.ReactInstanceManager;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OverlayManager;
 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 
-import com.facebook.react.ReactInstanceManager;
-
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
 public class Navigator extends ParentController {
 
     private final ModalStack modalStack;
     private final OverlayManager overlayManager;
     private final RootPresenter rootPresenter;
     private ViewController root;
+
     private ViewController previousRoot;
-    private final FrameLayout rootLayout;
-    private final FrameLayout modalsLayout;
-    private final FrameLayout overlaysLayout;
+
+    private final CoordinatorLayout rootLayout;
+    private final CoordinatorLayout modalsLayout;
+    private final CoordinatorLayout overlaysLayout;
     private ViewGroup contentLayout;
     private Options defaultOptions = new Options();
 
         return defaultOptions;
     }
 
-    FrameLayout getRootLayout() {
+    CoordinatorLayout getRootLayout() {
         return rootLayout;
     }
 
         this.modalStack = modalStack;
         this.overlayManager = overlayManager;
         this.rootPresenter = rootPresenter;
-        rootLayout = new FrameLayout(getActivity());
-        modalsLayout = new FrameLayout(getActivity());
-        overlaysLayout = new FrameLayout(getActivity());
+        rootLayout = new CoordinatorLayout(getActivity());
+        modalsLayout = new CoordinatorLayout(getActivity());
+        overlaysLayout = new CoordinatorLayout(getActivity());
     }
 
     public void bindViews() {
         rootPresenter.setRoot(root, defaultOptions, new CommandListenerAdapter(commandListener) {
             @Override
             public void onSuccess(String childId) {
-                if (removeSplashView) removePreviousContentView();
+                if (removeSplashView) contentLayout.removeViewAt(0);
                 super.onSuccess(childId);
                 destroyPreviousRoot();
             }
-
-            private void removePreviousContentView() {
-                contentLayout.removeViewAt(0);
-            }
         }, reactInstanceManager);
     }
 
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    FrameLayout getModalsLayout() {
+    CoordinatorLayout getModalsLayout() {
         return modalsLayout;
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/sidemenu/SideMenuController.java

 package com.reactnativenavigation.viewcontrollers.sidemenu;
 
 import android.app.Activity;
-import android.content.res.Resources;
-import android.support.annotation.NonNull;
-import android.support.v4.widget.DrawerLayout;
-import android.support.v4.widget.DrawerLayout.LayoutParams;
-import android.util.TypedValue;
 import android.view.Gravity;
 import android.view.View;
 
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.parse.SideMenuOptions;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.SideMenuPresenter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.views.*;
+import com.reactnativenavigation.views.SideMenu;
+import com.reactnativenavigation.views.SideMenuRoot;
 
 import java.util.ArrayList;
 import java.util.Collection;
 
-import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.drawerlayout.widget.DrawerLayout;
+import androidx.drawerlayout.widget.DrawerLayout.LayoutParams;
 
-public class SideMenuController extends ParentController<DrawerLayout> implements DrawerLayout.DrawerListener {
+public class SideMenuController extends ParentController<SideMenuRoot> implements DrawerLayout.DrawerListener {
 
 	private ViewController center;
 	private ViewController left;
 
     @Override
     protected ViewController getCurrentChild() {
-	    if (getView().isDrawerOpen(Gravity.LEFT)) {
-            return left;
-        } else if (getView().isDrawerOpen(Gravity.RIGHT)) {
-            return right;
+        if (!isDestroyed()) {
+            if (getView().isDrawerOpen(Gravity.LEFT)) {
+                return left;
+            } else if (getView().isDrawerOpen(Gravity.RIGHT)) {
+                return right;
+            }
         }
         return center;
     }
 
     @NonNull
 	@Override
-	protected DrawerLayout createView() {
-        DrawerLayout sideMenu = new SideMenu(getActivity());
+	protected SideMenuRoot createView() {
+        SideMenu sideMenu = new SideMenu(getActivity());
         presenter.bindView(sideMenu);
         sideMenu.addDrawerListener(this);
-        return sideMenu;
+
+        SideMenuRoot root = new SideMenuRoot(getActivity());
+        root.addSideMenu(sideMenu, this);
+        return root;
 	}
 
     @Override
 	}
 
     @Override
-    public void applyChildOptions(Options options, Component child) {
+    public void applyChildOptions(Options options, ViewController child) {
         super.applyChildOptions(options, child);
         presenter.applyChildOptions(resolveCurrentOptions());
         performOnParentController(parentController ->
     }
 
     @Override
-    public void mergeChildOptions(Options options, ViewController childController, Component child) {
-        super.mergeChildOptions(options, childController, child);
+    public void mergeChildOptions(Options options, ViewController child) {
+        super.mergeChildOptions(options, child);
         presenter.mergeChildOptions(options.sideMenuRootOptions);
         performOnParentController(parentController ->
-                ((ParentController) parentController).mergeChildOptions(options.copy().clearSideMenuOptions(), childController, child)
+                ((ParentController) parentController).mergeChildOptions(options.copy().clearSideMenuOptions(), child)
         );
     }
 
+    @Override
+    public void onViewAppeared() {
+        super.onViewAppeared();
+        if (left != null) left.performOnView(view -> ((View) view).requestLayout());
+        if (right != null) right.performOnView(view -> ((View) view).requestLayout());
+    }
+
     @Override
     public void mergeOptions(Options options) {
         super.mergeOptions(options);
     @Override
     public Options resolveCurrentOptions() {
         Options options = super.resolveCurrentOptions();
-        if (getView().isDrawerOpen(Gravity.LEFT) || getView().isDrawerOpen(Gravity.RIGHT)) {
+        if (isDrawerOpen(Gravity.LEFT) || isDrawerOpen(Gravity.RIGHT)) {
             options = options.mergeWith(center.resolveCurrentOptions());
         }
         return options;
     }
 
-    //For onDrawerOpened and onDrawerClosed :
-    //Merge the options to the current state, if this happened due to a gesture we need to
-    //update the option state
+    public boolean isDrawerOpen(int gravity) {
+        return !isDestroyed() && getView().isDrawerOpen(gravity);
+    }
 
     @Override
     public void onDrawerOpened(@NonNull View drawerView) {
         return presenter.handleBack() || center.handleBack(listener) || super.handleBack(listener);
     }
 
+    @Nullable
+    @Override
+    public ViewController findController(View child) {
+        return getView().isSideMenu(child) ? this : super.findController(child);
+    }
+
     public void setCenterController(ViewController centerController) {
-		this.center = centerController;
-		View childView = centerController.getView();
-		getView().addView(childView);
+		center = centerController;
+        getView().setCenter(center);
 	}
 
     public void setLeftController(ViewController controller) {
-        this.left = controller;
-        int height = getHeight(options.sideMenuRootOptions.left);
-        int width = getWidth(options.sideMenuRootOptions.left);
-        getView().addView(controller.getView(), new LayoutParams(width, height, Gravity.LEFT));
+        left = controller;
+        getView().setLeft(left, options);
     }
 
     public void setRightController(ViewController controller) {
-        this.right = controller;
-        int height = getHeight(options.sideMenuRootOptions.right);
-        int width = getWidth(options.sideMenuRootOptions.right);
-        getView().addView(controller.getView(), new LayoutParams(width, height, Gravity.RIGHT));
-    }
-
-    private int getWidth(SideMenuOptions sideMenuOptions) {
-        int width = MATCH_PARENT;
-        if (sideMenuOptions.width.hasValue()) {
-            width = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, sideMenuOptions.width.get(), Resources.getSystem().getDisplayMetrics());
-        }
-        return width;
-    }
-
-    private int getHeight(SideMenuOptions sideMenuOptions) {
-        int height = MATCH_PARENT;
-        if (sideMenuOptions.height.hasValue()) {
-            height = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, sideMenuOptions.height.get(), Resources.getSystem().getDisplayMetrics());
-        }
-        return height;
+        right = controller;
+        getView().setRight(right, options);
     }
 
     private ViewController getMatchingView (View drawerView) {
     }
 
     private void dispatchSideMenuVisibilityEvents(ViewController drawer, float prevOffset, float offset) {
-        if (prevOffset == 0 && offset> 0) {
+        if (prevOffset == 0 && offset > 0) {
             drawer.onViewAppeared();
         } else if (prevOffset > 0 && offset == 0) {
             drawer.onViewDisappear();
         }
     }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    SideMenu getSideMenu() {
+        return presenter.getSideMenu();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/BackButtonHelper.java

 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 public class BackButtonHelper {
-    public void addToPushedChild(ViewController child) {
-        if (child.options.topBar.buttons.left != null || child.options.topBar.buttons.back.visible.isFalse()) return;
-        Options options = new Options();
-        options.topBar.buttons.back.setVisible();
-        child.mergeOptions(options);
-    }
-
     public void clear(ViewController child) {
         if (!child.options.topBar.buttons.back.hasValue()) {
             child.options.topBar.buttons.back.visible = new Bool(false);
         }
     }
+
+    void addToPushedChild(ViewController child) {
+        if (child.options.topBar.buttons.left != null || child.options.topBar.buttons.back.visible.isFalse()) return;
+        Options options = new Options();
+        options.topBar.buttons.back.setVisible();
+        child.mergeOptions(options);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackController.java

 package com.reactnativenavigation.viewcontrollers.stack;
 
 import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.support.annotation.RestrictTo;
-import android.support.annotation.VisibleForTesting;
-import android.support.v4.view.ViewPager;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.react.Constants;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
+import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.IdStack;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.ReactComponent;
 import com.reactnativenavigation.views.StackLayout;
+import com.reactnativenavigation.views.stack.StackBehaviour;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 
-import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import androidx.viewpager.widget.ViewPager;
+
 import static com.reactnativenavigation.utils.CollectionUtils.*;
+import static com.reactnativenavigation.utils.CoordinatorLayoutUtils.matchParentWithBehaviour;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
 
 public class StackController extends ParentController<StackLayout> {
 
         this.presenter = stackPresenter;
         stackPresenter.setButtonOnClickListener(this::onNavigationButtonPressed);
         for (ViewController child : children) {
-            stack.push(child.getId(), child);
             child.setParentController(this);
+            stack.push(child.getId(), child);
             if (size() > 1) backButtonHelper.addToPushedChild(child);
         }
     }
         if (getCurrentChild().isDestroyed()) return false;
         ViewGroup currentChild = getCurrentChild().getView();
         if (currentChild instanceof Component) {
-            return super.isRendered() && presenter.isRendered((Component) currentChild);
+            return super.isRendered() && presenter.isRendered(currentChild);
         }
         return super.isRendered();
     }
     @Override
     public void onAttachToParent() {
         if (!isEmpty() && !getCurrentChild().isDestroyed() && !isViewShown()) {
-            presenter.applyChildOptions(resolveCurrentOptions(), (Component) getCurrentChild().getView());
+            presenter.applyChildOptions(resolveCurrentOptions(), this, getCurrentChild());
         }
     }
 
     @Override
     public void mergeOptions(Options options) {
-        presenter.mergeOptions(options, (Component) getCurrentChild().getView());
+        presenter.mergeOptions(options, this, getCurrentChild());
         super.mergeOptions(options);
     }
 
     @Override
-    public void applyChildOptions(Options options, Component child) {
+    public void applyChildOptions(Options options, ViewController child) {
         super.applyChildOptions(options, child);
-        presenter.applyChildOptions(resolveCurrentOptions(), child);
-        if (child instanceof ReactComponent) {
-            fabOptionsPresenter.applyOptions(this.options.fabOptions, (ReactComponent) child, getView());
+        presenter.applyChildOptions(resolveCurrentOptions(), this, child);
+        if (child.getView() instanceof ReactComponent) {
+            fabOptionsPresenter.applyOptions(this.options.fabOptions, (ReactComponent) child.getView(), getView());
         }
         performOnParentController(parentController ->
                 ((ParentController) parentController).applyChildOptions(
     }
 
     @Override
-    public void mergeChildOptions(Options options, ViewController childController, Component child) {
-        super.mergeChildOptions(options, childController, child);
-        if (childController.isViewShown() && peek() == childController) {
-            presenter.mergeChildOptions(options, resolveCurrentOptions(), child);
+    public void mergeChildOptions(Options options, ViewController child) {
+        super.mergeChildOptions(options, child);
+        if (child.isViewShown() && peek() == child) {
+            presenter.mergeChildOptions(options, resolveCurrentOptions(), this, child);
             if (options.fabOptions.hasValue() && child instanceof ReactComponent) {
                 fabOptionsPresenter.mergeOptions(options.fabOptions, (ReactComponent) child, getView());
             }
                                 .clearFabOptions()
                                 .clearTopTabOptions()
                                 .clearTopTabsOptions(),
-                        childController,
                         child
                 )
         );
     }
 
     @Override
-    public void onChildDestroyed(Component child) {
+    public void onChildDestroyed(ViewController child) {
         super.onChildDestroyed(child);
         presenter.onChildDestroyed(child);
     }
     }
 
     private void addChildToStack(ViewController child, View view, Options resolvedOptions) {
-        view.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
         child.setWaitForRender(resolvedOptions.animations.push.waitForRender);
-        presenter.applyLayoutParamsOptions(resolvedOptions, view);
         if (size() == 1) presenter.applyInitialChildLayoutOptions(resolvedOptions);
-        getView().addView(view, getView().getChildCount() - 1);
+        getView().addView(view, getView().getChildCount() - 1, matchParentWithBehaviour(new StackBehaviour(this)));
     }
 
     public void setRoot(List<ViewController> children, CommandListener listener) {
         disappearing.onViewWillDisappear();
         appearing.onViewWillAppear();
 
-        Options resolvedOptions = resolveCurrentOptions();
         ViewGroup appearingView = appearing.getView();
         if (appearingView.getLayoutParams() == null) {
-            appearingView.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
-            presenter.applyLayoutParamsOptions(resolvedOptions, appearingView);
+            appearingView.setLayoutParams(matchParentWithBehaviour(new StackBehaviour(this)));
         }
         if (appearingView.getParent() == null) {
             getView().addView(appearingView, 0);
         }
-        presenter.onChildWillAppear(appearing.options, disappearing.options);
+        presenter.onChildWillAppear(this, appearing, disappearing);
         if (disappearingOptions.animations.pop.enabled.isTrueOrUndefined()) {
             animator.pop(disappearing.getView(), disappearingOptions.animations.pop, () -> finishPopping(disappearing, listener));
         } else {
     @Override
     protected StackLayout createView() {
         StackLayout stackLayout = new StackLayout(getActivity(), topBarController, getId());
-        presenter.bindView(topBarController.getView());
+        presenter.bindView(topBarController);
         addInitialChild(stackLayout);
         return stackLayout;
     }
     private void addInitialChild(StackLayout stackLayout) {
         if (isEmpty()) return;
         ViewGroup child = peek().getView();
-        child.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
-        Options options = resolveCurrentOptions();
-        presenter.applyLayoutParamsOptions(options, child);
-        presenter.applyInitialChildLayoutOptions(options);
-        stackLayout.addView(child, 0);
+        child.setId(CompatUtils.generateViewId());
+        presenter.applyInitialChildLayoutOptions(resolveCurrentOptions());
+        stackLayout.addView(child, 0, matchParentWithBehaviour(new StackBehaviour(this)));
     }
 
     private void onNavigationButtonPressed(String buttonId) {
         topBarController.clearTopTabs();
     }
 
+    @Override
+    public boolean onDependentViewChanged(CoordinatorLayout parent, ViewGroup child, View dependency) {
+        perform(findController(child), controller -> presenter.applyTopInsets(this, controller));
+        return false;
+    }
+
+    @Override
+    public int getTopInset(ViewController child) {
+        return resolveChildOptions(child).topBar.isHiddenOrDrawBehind() ? 0 : topBarController.getHeight();
+    }
+
     @RestrictTo(RestrictTo.Scope.TESTS)
     public TopBar getTopBar() {
         return topBarController.getView();

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackControllerBuilder.java

 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.element.ElementTransitionManager;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 public class StackControllerBuilder {
     private Activity activity;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/topbar/TopBarController.java

 package com.reactnativenavigation.viewcontrollers.topbar;
 
 import android.content.Context;
-import android.support.v4.view.ViewPager;
 import android.view.View;
 
+import com.reactnativenavigation.anim.TopBarAnimator;
+import com.reactnativenavigation.parse.AnimationOptions;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.topbar.TopBar;
 
+import androidx.annotation.VisibleForTesting;
+import androidx.viewpager.widget.ViewPager;
+
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
+import static com.reactnativenavigation.utils.ViewUtils.isVisible;
+
 
 public class TopBarController {
     private TopBar topBar;
+    private TopBarAnimator animator;
+
+    public TopBarController() {
+        animator = new TopBarAnimator();
+    }
+
+    public TopBar getView() {
+        return topBar;
+    }
 
-    public View createView(Context context, StackLayout stackLayout) {
+    public int getHeight() {
+        return perform(topBar, 0, View::getHeight);
+    }
+
+    @VisibleForTesting
+    public void setAnimator(TopBarAnimator animator) {
+        this.animator = animator;
+    }
+
+    public TopBar createView(Context context, StackLayout parent) {
         if (topBar == null) {
-            topBar = createTopBar(context, stackLayout);
+            topBar = createTopBar(context, parent);
             topBar.setId(CompatUtils.generateViewId());
+            animator.bindView(topBar, parent);
         }
         return topBar;
     }
 
     protected TopBar createTopBar(Context context, StackLayout stackLayout) {
-        return new TopBar(context, stackLayout);
-    }
-
-    public TopBar getView() {
-        return topBar;
+        return new TopBar(context);
     }
 
     public void initTopTabs(ViewPager viewPager) {
     public void clearTopTabs() {
         topBar.clearTopTabs();
     }
+
+    public void show() {
+        if (isVisible(topBar) || animator.isAnimatingShow()) return;
+        topBar.setVisibility(View.VISIBLE);
+    }
+
+    public void showAnimate(AnimationOptions options, int translationDy) {
+        if (isVisible(topBar) || animator.isAnimatingShow()) return;
+        animator.show(options, translationDy);
+    }
+
+    public void hide() {
+        if (!animator.isAnimatingHide()) {
+            topBar.setVisibility(View.GONE);
+        }
+    }
+
+    public void hideAnimate(AnimationOptions options, float translationStart, float translationEnd) {
+        hideAnimate(options, () -> {}, translationStart, translationEnd);
+    }
+
+    private void hideAnimate(AnimationOptions options, Runnable onAnimationEnd, float translationStart, float translationEnd) {
+        if (!isVisible(topBar)) return;
+        animator.hide(options, onAnimationEnd, translationStart, translationEnd);
+    }
+
+    public void resetViewProperties() {
+        topBar.setTranslationY(0);
+        topBar.setTranslationX(0);
+        topBar.setAlpha(1);
+        topBar.setScaleY(1);
+        topBar.setScaleX(1);
+        topBar.setRotationX(0);
+        topBar.setRotationY(0);
+        topBar.setRotation(0);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsAdapter.java

 package com.reactnativenavigation.viewcontrollers.toptabs;
 
-import android.support.v4.view.PagerAdapter;
-import android.support.v4.view.ViewPager;
+import androidx.viewpager.widget.PagerAdapter;
+import androidx.viewpager.widget.ViewPager;
 import android.view.View;
 import android.view.ViewGroup;
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsController.java

 package com.reactnativenavigation.viewcontrollers.toptabs;
 
 import android.app.Activity;
-import android.support.annotation.CallSuper;
-import android.support.annotation.NonNull;
+import androidx.annotation.CallSuper;
+import androidx.annotation.NonNull;
 import android.view.View;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.ViewVisibilityListenerAdapter;
-import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.toptabs.TopTabsLayoutCreator;
 import com.reactnativenavigation.views.toptabs.TopTabsViewPager;
 
     }
 
     @Override
-    public void applyChildOptions(Options options, Component child) {
+    public void applyChildOptions(Options options, ViewController child) {
         super.applyChildOptions(options, child);
         performOnParentController(parentController -> ((ParentController) parentController).applyChildOptions(this.options.copy(), child));
     }
 
     @CallSuper
-    public void mergeChildOptions(Options options, ViewController childController, Component child) {
-        super.mergeChildOptions(options, childController, child);
+    public void mergeChildOptions(Options options, ViewController child) {
+        super.mergeChildOptions(options, child);
         performOnParentController(parentController -> ((ParentController) parentController).applyChildOptions(options.copy(), child));
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/views/BehaviourAdapter.java

+package com.reactnativenavigation.views;
+
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import android.view.View;
+import android.view.ViewGroup;
+
+public interface BehaviourAdapter<V extends ViewGroup> {
+    /**
+     * @see CoordinatorLayout.Behavior#onMeasureChild
+     * @return true if the Behavior measured the child view, false if the CoordinatorLayout should perform its default measurement
+     */
+    boolean onMeasureChild(CoordinatorLayout parent, V child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed);
+
+    /**
+     * @see CoordinatorLayout.Behavior#onDependentViewChanged
+     * @return true if the Behavior changed the child view's size or position, false otherwise
+     */
+    boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency);
+}

lib/android/app/src/main/java/com/reactnativenavigation/views/BehaviourDelegate.java

+package com.reactnativenavigation.views;
+
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import android.view.View;
+import android.view.ViewGroup;
+
+public class BehaviourDelegate<V extends ViewGroup> extends CoordinatorLayout.Behavior<V> {
+
+    private BehaviourAdapter delegate;
+
+    public BehaviourDelegate(BehaviourAdapter<V> delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency) {
+        return delegate.onDependentViewChanged(parent, child, dependency);
+    }
+
+    @Override
+    public boolean onMeasureChild(CoordinatorLayout parent, V child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed) {
+        return delegate.onMeasureChild(parent, child, parentWidthMeasureSpec, widthUsed, parentHeightMeasureSpec, heightUsed);
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/views/BottomTabs.java

 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.drawable.Drawable;
-import android.support.annotation.IntRange;
 import android.widget.LinearLayout;
 
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
+import com.reactnativenavigation.BuildConfig;
+import com.reactnativenavigation.R;
 import com.reactnativenavigation.parse.LayoutDirection;
-import com.reactnativenavigation.utils.CompatUtils;
+
+import androidx.annotation.IntRange;
 
 import static com.reactnativenavigation.utils.ViewUtils.findChildByClass;
 
     private boolean itemsCreationEnabled = true;
     private boolean shouldCreateItems = true;
 
+    public BottomTabs(Context context) {
+        super(context);
+        setId(R.id.bottomTabs);
+        if (BuildConfig.DEBUG) setContentDescription("BottomTabs");
+    }
+
     public void disableItemsCreation() {
         itemsCreationEnabled = false;
     }
         if (shouldCreateItems) createItems();
     }
 
-    public BottomTabs(Context context) {
-        super(context);
-        setId(CompatUtils.generateViewId());
-    }
-
     @Override
     protected void createItems() {
         if (itemsCreationEnabled) {
         super.createItems();
     }
 
-    public void setBadge(int bottomTabIndex, String badge) {
-        setNotification(badge, bottomTabIndex);
-    }
-
     @Override
     public void setCurrentItem(@IntRange(from = 0) int position) {
         super.setCurrentItem(position);

lib/android/app/src/main/java/com/reactnativenavigation/views/Component.java

 package com.reactnativenavigation.views;
 
-import com.reactnativenavigation.views.topbar.TopBar;
-
 public interface Component extends Renderable {
-    void drawBehindTopBar();
 
-    void drawBelowTopBar(TopBar topBar);
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/ComponentLayout.java

 import android.content.Context;
 import android.view.MotionEvent;
 import android.view.View;
-import android.widget.FrameLayout;
-import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
-import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.views.element.Element;
-import com.reactnativenavigation.views.topbar.TopBar;
 import com.reactnativenavigation.views.touch.OverlayTouchDelegate;
 
 import java.util.List;
 
-import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
+import static com.reactnativenavigation.utils.CoordinatorLayoutUtils.matchParentLP;
 
 @SuppressLint("ViewConstructor")
-public class ComponentLayout extends FrameLayout implements ReactComponent, TitleBarButtonController.OnClickListener {
+public class ComponentLayout extends CoordinatorLayout implements ReactComponent, TitleBarButtonController.OnClickListener {
 
     private IReactView reactView;
     private final OverlayTouchDelegate touchDelegate;
     public ComponentLayout(Context context, IReactView reactView) {
 		super(context);
 		this.reactView = reactView;
-        addView(reactView.asView(), MATCH_PARENT, MATCH_PARENT);
+        addView(reactView.asView(), matchParentLP());
         touchDelegate = new OverlayTouchDelegate(reactView);
     }
 
         reactView.dispatchTouchEventToJs(event);
     }
 
-    @Override
-    public void drawBehindTopBar() {
-        if (getLayoutParams() instanceof RelativeLayout.LayoutParams) {
-            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-            layoutParams.topMargin = 0;
-            setLayoutParams(layoutParams);
-        }
-    }
-
-    @Override
-    public void drawBelowTopBar(TopBar topBar) {
-        if (getLayoutParams() instanceof RelativeLayout.LayoutParams) {
-            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-            if (topBar.getLayoutParams() instanceof MarginLayoutParams) {
-                layoutParams.topMargin = ViewUtils.getHeight(topBar) + ((MarginLayoutParams) topBar.getLayoutParams()).topMargin;
-            } else {
-                layoutParams.topMargin = ViewUtils.getHeight(topBar);
-            }
-            try {
-                setLayoutParams(layoutParams);
-            } catch (IllegalStateException ignored) { }
-        }
-    }
-
     @Override
     public boolean isRendered() {
         return reactView.isRendered();

lib/android/app/src/main/java/com/reactnativenavigation/views/ExternalComponentLayout.java

 
 import android.annotation.SuppressLint;
 import android.content.Context;
-import android.widget.FrameLayout;
-import android.widget.RelativeLayout;
-
-import com.reactnativenavigation.views.topbar.TopBar;
-
-import static android.widget.RelativeLayout.BELOW;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
 
 @SuppressLint("ViewConstructor")
-public class ExternalComponentLayout extends FrameLayout implements Component {
+public class ExternalComponentLayout extends CoordinatorLayout implements Component {
     public ExternalComponentLayout(Context context) {
 		super(context);
     }
 
-    @Override
-    public void drawBehindTopBar() {
-        if (getParent() instanceof RelativeLayout) {
-            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-            layoutParams.removeRule(BELOW);
-            setLayoutParams(layoutParams);
-        }
-    }
-
-    @Override
-    public void drawBelowTopBar(TopBar topBar) {
-        if (getParent() instanceof RelativeLayout) {
-            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-            layoutParams.addRule(BELOW, topBar.getId());
-            setLayoutParams(layoutParams);
-        }
-    }
-
     @Override
     public boolean isRendered() {
         return getChildCount() >= 1;

lib/android/app/src/main/java/com/reactnativenavigation/views/Fab.java

 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.Drawable;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.github.clans.fab.FloatingActionButton;
 import com.reactnativenavigation.anim.FabAnimator;

lib/android/app/src/main/java/com/reactnativenavigation/views/SideMenu.java

 package com.reactnativenavigation.views;
 
 import android.content.Context;
-import android.support.annotation.NonNull;
-import android.support.v4.widget.DrawerLayout;
 import android.util.Log;
 
+import androidx.annotation.NonNull;
+import androidx.drawerlayout.widget.DrawerLayout;
+
 public class SideMenu extends DrawerLayout {
     public SideMenu(@NonNull Context context) {
         super(context);