Update android-specific-use-cases.md (#1119)

docs/android-specific-use-cases.md

 # Android Specific Use Cases
 
-TOC
-* [Activity Lifecycle and onActivityResult](https://github.com/wix/react-native-navigation/wiki/Android#activity-lifecycle-and-onactivityresult)
-* [Adjusting soft input mode](https://github.com/wix/react-native-navigation/wiki/Android/#adjusting-soft-input-mode)
-* [Splash screen](https://github.com/wix/react-native-navigation/wiki/Android/#splash-screen)
-* [Collapsing React header](https://github.com/wix/react-native-navigation/wiki/Android/#collapsing-react-header---android-only)
-  * [Collapsing react view](https://github.com/wix/react-native-navigation/wiki/Android/#collapsing-react-view)
-  * [Collapsing react view with top tabs](https://github.com/wix/react-native-navigation/wiki/Android/_edit#collapsing-react-view-with-top-tabs)
-* [Reloading from terminal](https://github.com/wix/react-native-navigation/wiki/Android/#reloading-from-terminal)
-
-# Activity Lifecycle and onActivityResult
+## Activity Lifecycle and onActivityResult
 In order to listen to activity lifecycle callbacks, set `ActivityCallback` in `MainApplication.onCreate` as follows:
 
 ```java
 }
 ```
 
-## Why overriding these methods in `MainActivity` won't work
+### Why overriding these methods in `MainActivity` won't work
 `MainActivity` extends `SplashActiviy` which is used to start the react context. Once react is up and running `MainActivity` is **stopped** and another activity takes over to run our app: `NavigationActivity`. Due to this design, there's usually no point in overriding lifecycle callbacks in `MainActivity`.
 
-# Splash screen
+## Splash screen
 Override `getSplashLayout` or `createSplashLayout` in `MainActivity` to provide a splash layout which will be displayed while Js context initialises.
 
-# Collapsing React header
+## Collapsing React header
 A screen can have a header, either an image or a react component, that collapses as the screen is scrolled.
 
-## Collapsing react view
+### Collapsing react view
 
 ```js
 export default class CollapsingReactViewScreen extends Component {
 }
 ```
 
-## Collapsing react view with top tabs
+### Collapsing react view with top tabs
 
 **Note:** `example.header` represents a component that's registered as a screen:
 ```js
     ]
 });
 ```
-# Shared Element Transition
+## Shared Element Transition
 Screen transitions provide visual connections between different states through motion and transformations between common elements. You can specify custom animations for transitions of shared elements between screens.
 
 The `<SharedElementTransition>` component determines how views that are shared between two screens transition between these screens. For example, if two screens have the same image in different positions and sizes, the `<SharedElementTransition>` will translate and scale the image smoothly between these screens.
 
-## Supported transitions
+### Supported transitions
 * Scale
 * Text color
 * Linear translation
 * Curved motion translation
 * Image bounds and scale transformation - Unlike the basic scale transformation, this transformation will change the actual image scale and bounds, instead of simply scaling it up or down.
 
-## Specifying shared elements
+### Specifying shared elements
 First, wrap the view you would like to transition in a `<SharedElementTransition/>` and give it a unique id. This is how our `<Text/>` element is defined in the first screen:
 
 ```js
   }
 });
 ```
-## Animating image bounds and scale
+### Animating image bounds and scale
 By default, when animating images, a basic scale transition is used. This is good enough for basic use cases where both images have the same aspect ratio. If the images have different size and scale, you can animate their bounds and scale by setting `animateClipBounds={true}` on the final `<SharedElementTransition/>` element.
 
-## Curved motion
+### Curved motion
 The `path` interpolator transitions elements along a curved path based on Bézier curves. This interpolator specifies a motion curve in a 1x1 square, with anchor points at (0,0) and (1,1) and control points specified using the `showInterpolation` and `hideInterpolation` props.
 
-### Using curved motion
+#### Using curved motion
 First, wrap the view you would like to transition in a `<SharedElementTransition/>` and give it a unique id. In this example we are going to transition an `<Image/>'.
 
 ```js
 });
 ```
 
-## Easing
+### Easing
 specify the rate of change of a parameter over time
 
 * `accelerateDecelerate` - the rate of change starts and ends slowly but accelerates through the middle.
 * `fastOutSlowIn` - the rate of change starts fast but decelerates slowly.
 * `linear` - the rate of change is constant (default)
 
-## Screen animation
+### Screen animation
 When Shared Element Transition is used, a cross-fade transition is used between the entering and exiting screens. Make sure the root `View` has a background color in order for the cross-fade animation to be visible.
 
 To disable the corss-fade animation, set `animated: false` when pushing the second screen. Disabling this animation is useful if you'd like to animate the reset of the elements on screen your self.
 
-# Reloading from terminal
-You can easily reload your app from terminal using `adb shell am broadcast -a react.native.RELOAD`. This is particularly useful when debugging on device.
+## Reloading from terminal
+You can easily reload your app from terminal using `adb shell am broadcast -a react.native.RELOAD`. This is particularly useful when debugging on device.