diff --git a/website/versioned_docs/version-0.70/_getting-started-linux-android.md b/website/versioned_docs/version-0.70/_getting-started-linux-android.md
new file mode 100644
index 00000000000..839c6882c65
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_getting-started-linux-android.md
@@ -0,0 +1,177 @@
+import RemoveGlobalCLI from './\_remove-global-cli.md';
+
+## Installing dependencies
+
+You will need Node, the React Native command line interface, a JDK, and Android Studio.
+
+While you can use any editor of your choice to develop your app, you will need to install Android Studio in order to set up the necessary tooling to build your React Native app for Android.
+
+
Node
+
+Follow the [installation instructions for your Linux distribution](https://nodejs.org/en/download/package-manager/) to install Node 14 or newer.
+
+
Java Development Kit
+
+React Native currently recommends version 11 of the Java SE Development Kit (JDK). You may encounter problems using higher JDK versions. You may download and install [OpenJDK](http://openjdk.java.net) from [AdoptOpenJDK](https://adoptopenjdk.net/) or your system packager.
+
+
Android development environment
+
+Setting up your development environment can be somewhat tedious if you're new to Android development. If you're already familiar with Android development, there are a few things you may need to configure. In either case, please make sure to carefully follow the next few steps.
+
+
1. Install Android Studio
+
+[Download and install Android Studio](https://developer.android.com/studio/index.html). While on Android Studio installation wizard, make sure the boxes next to all of the following items are checked:
+
+- `Android SDK`
+- `Android SDK Platform`
+- `Android Virtual Device`
+
+Then, click "Next" to install all of these components.
+
+> If the checkboxes are grayed out, you will have a chance to install these components later on.
+
+Once setup has finalized and you're presented with the Welcome screen, proceed to the next step.
+
+
2. Install the Android SDK
+
+Android Studio installs the latest Android SDK by default. Building a React Native app with native code, however, requires the `Android 12 (S)` SDK in particular. Additional Android SDKs can be installed through the SDK Manager in Android Studio.
+
+To do that, open Android Studio, click on "Configure" button and select "SDK Manager".
+
+> The SDK Manager can also be found within the Android Studio "Preferences" dialog, under **Appearance & Behavior** → **System Settings** → **Android SDK**.
+
+Select the "SDK Platforms" tab from within the SDK Manager, then check the box next to "Show Package Details" in the bottom right corner. Look for and expand the `Android 12 (S)` entry, then make sure the following items are checked:
+
+- `Android SDK Platform 31`
+- `Intel x86 Atom_64 System Image` or `Google APIs Intel x86 Atom System Image`
+
+Next, select the "SDK Tools" tab and check the box next to "Show Package Details" here as well. Look for and expand the "Android SDK Build-Tools" entry, then make sure that `31.0.0` is selected.
+
+Finally, click "Apply" to download and install the Android SDK and related build tools.
+
+
3. Configure the ANDROID_SDK_ROOT environment variable
+
+The React Native tools require some environment variables to be set up in order to build apps with native code.
+
+Add the following lines to your `$HOME/.bash_profile` or `$HOME/.bashrc` (if you are using `zsh` then `~/.zprofile` or `~/.zshrc`) config file:
+
+```shell
+export ANDROID_SDK_ROOT=$HOME/Library/Android/Sdk
+export PATH=$PATH:$ANDROID_SDK_ROOT/emulator
+export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools
+```
+
+> `.bash_profile` is specific to `bash`. If you're using another shell, you will need to edit the appropriate shell-specific config file.
+
+Type `source $HOME/.bash_profile` for `bash` or `source $HOME/.zprofile` to load the config into your current shell. Verify that ANDROID_SDK_ROOT has been set by running `echo $ANDROID_SDK_ROOT` and the appropriate directories have been added to your path by running `echo $PATH`.
+
+> Please make sure you use the correct Android SDK path. You can find the actual location of the SDK in the Android Studio "Preferences" dialog, under **Appearance & Behavior** → **System Settings** → **Android SDK**.
+
+
Watchman
+
+Follow the [Watchman installation guide](https://facebook.github.io/watchman/docs/install/#buildinstall) to compile and install Watchman from source.
+
+> [Watchman](https://facebook.github.io/watchman/docs/install/) is a tool by Facebook for watching changes in the filesystem. It is highly recommended you install it for better performance and increased compatibility in certain edge cases (translation: you may be able to get by without installing this, but your mileage may vary; installing this now may save you from a headache later).
+
+
React Native Command Line Interface
+
+React Native has a built-in command line interface. Rather than install and manage a specific version of the CLI globally, we recommend you access the current version at runtime using `npx`, which ships with Node.js. With `npx react-native `, the current stable version of the CLI will be downloaded and executed at the time the command is run.
+
+
Creating a new application
+
+
+
+React Native has a built-in command line interface, which you can use to generate a new project. You can access it without installing anything globally using `npx`, which ships with Node.js. Let's create a new React Native project called "AwesomeProject":
+
+```shell
+npx react-native init AwesomeProject
+```
+
+This is not necessary if you are integrating React Native into an existing application, if you "ejected" from Expo, or if you're adding Android support to an existing React Native project (see [Integration with Existing Apps](integration-with-existing-apps.md)). You can also use a third-party CLI to init your React Native app, such as [Ignite CLI](https://github.com/infinitered/ignite).
+
+
[Optional] Using a specific version or template
+
+If you want to start a new project with a specific React Native version, you can use the `--version` argument:
+
+```shell
+npx react-native init AwesomeProject --version X.XX.X
+```
+
+You can also start a project with a custom React Native template, like TypeScript, with `--template` argument:
+
+```shell
+npx react-native init AwesomeTSProject --template react-native-template-typescript
+```
+
+
Preparing the Android device
+
+You will need an Android device to run your React Native Android app. This can be either a physical Android device, or more commonly, you can use an Android Virtual Device which allows you to emulate an Android device on your computer.
+
+Either way, you will need to prepare the device to run Android apps for development.
+
+
Using a physical device
+
+If you have a physical Android device, you can use it for development in place of an AVD by plugging it in to your computer using a USB cable and following the instructions [here](running-on-device.md).
+
+
Using a virtual device
+
+If you use Android Studio to open `./AwesomeProject/android`, you can see the list of available Android Virtual Devices (AVDs) by opening the "AVD Manager" from within Android Studio. Look for an icon that looks like this:
+
+
+
+If you have recently installed Android Studio, you will likely need to [create a new AVD](https://developer.android.com/studio/run/managing-avds.html). Select "Create Virtual Device...", then pick any Phone from the list and click "Next", then select the **S** API Level 31 image.
+
+> We recommend configuring [VM acceleration](https://developer.android.com/studio/run/emulator-acceleration.html#vm-linux) on your system to improve performance. Once you've followed those instructions, go back to the AVD Manager.
+
+Click "Next" then "Finish" to create your AVD. At this point you should be able to click on the green triangle button next to your AVD to launch it, then proceed to the next step.
+
+
Running your React Native application
+
+
Step 1: Start Metro
+
+First, you will need to start Metro, the JavaScript bundler that ships with React Native. Metro "takes in an entry file and various options, and returns a single JavaScript file that includes all your code and its dependencies."—[Metro Docs](https://facebook.github.io/metro/docs/concepts)
+
+To start Metro, run `npx react-native start` inside your React Native project folder:
+
+```shell
+npx react-native start
+```
+
+`react-native start` starts Metro Bundler.
+
+> If you use the Yarn package manager, you can use `yarn` instead of `npx` when running React Native commands inside an existing project.
+
+> If you're familiar with web development, Metro is a lot like webpack—for React Native apps. Unlike Kotlin or Java, JavaScript isn't compiled—and neither is React Native. Bundling isn't the same as compiling, but it can help improve startup performance and translate some platform-specific JavaScript into more widely supported JavaScript.
+
+
Step 2: Start your application
+
+Let Metro Bundler run in its own terminal. Open a new terminal inside your React Native project folder. Run the following:
+
+```shell
+npx react-native run-android
+```
+
+If everything is set up correctly, you should see your new app running in your Android emulator shortly.
+
+`npx react-native run-android` is one way to run your app - you can also run it directly from within Android Studio.
+
+> If you can't get this to work, see the [Troubleshooting](troubleshooting.md) page.
+
+
Modifying your app
+
+Now that you have successfully run the app, let's modify it.
+
+- Open `App.js` in your text editor of choice and edit some lines.
+- Press the `R` key twice or select `Reload` from the Developer Menu (`Ctrl + M`) to see your changes!
+
+
That's it!
+
+Congratulations! You've successfully run and modified your first React Native app.
+
+
+
+
Now what?
+
+- If you want to add this new React Native code to an existing application, check out the [Integration guide](integration-with-existing-apps.md).
+
+If you're curious to learn more about React Native, check out the [Introduction to React Native](getting-started).
diff --git a/website/versioned_docs/version-0.70/_getting-started-macos-android.md b/website/versioned_docs/version-0.70/_getting-started-macos-android.md
new file mode 100644
index 00000000000..fd52291bab0
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_getting-started-macos-android.md
@@ -0,0 +1,191 @@
+import RemoveGlobalCLI from './\_remove-global-cli.md';
+
+## Installing dependencies
+
+You will need Node, Watchman, the React Native command line interface, a JDK, and Android Studio.
+
+While you can use any editor of your choice to develop your app, you will need to install Android Studio in order to set up the necessary tooling to build your React Native app for Android.
+
+
Node & Watchman
+
+We recommend installing Node and Watchman using [Homebrew](http://brew.sh/). Run the following commands in a Terminal after installing Homebrew:
+
+```shell
+brew install node
+brew install watchman
+```
+
+If you have already installed Node on your system, make sure it is Node 14 or newer.
+
+[Watchman](https://facebook.github.io/watchman) is a tool by Facebook for watching changes in the filesystem. It is highly recommended you install it for better performance.
+
+
Java Development Kit
+
+We recommend installing the OpenJDK distribution called Azul **Zulu** using [Homebrew](http://brew.sh/). Run the following commands in a Terminal after installing Homebrew:
+
+```shell
+brew tap homebrew/cask-versions
+brew install --cask zulu11
+```
+
+The Zulu OpenJDK distribution offers JDKs for **both Intel and M1 Macs**. This will make sure your builds are faster on M1 Macs compared to using an Intel-based JDK.
+
+If you have already installed JDK on your system, we recommend JDK 11. You may encounter problems using higher JDK versions.
+
+
Android development environment
+
+Setting up your development environment can be somewhat tedious if you're new to Android development. If you're already familiar with Android development, there are a few things you may need to configure. In either case, please make sure to carefully follow the next few steps.
+
+
1. Install Android Studio
+
+[Download and install Android Studio](https://developer.android.com/studio/index.html). While on Android Studio installation wizard, make sure the boxes next to all of the following items are checked:
+
+- `Android SDK`
+- `Android SDK Platform`
+- `Android Virtual Device`
+
+Then, click "Next" to install all of these components.
+
+> If the checkboxes are grayed out, you will have a chance to install these components later on.
+
+Once setup has finalized and you're presented with the Welcome screen, proceed to the next step.
+
+
2. Install the Android SDK
+
+Android Studio installs the latest Android SDK by default. Building a React Native app with native code, however, requires the `Android 12 (S)` SDK in particular. Additional Android SDKs can be installed through the SDK Manager in Android Studio.
+
+To do that, open Android Studio, click on "More Actions" button and select "SDK Manager".
+
+
+
+> The SDK Manager can also be found within the Android Studio "Preferences" dialog, under **Appearance & Behavior** → **System Settings** → **Android SDK**.
+
+Select the "SDK Platforms" tab from within the SDK Manager, then check the box next to "Show Package Details" in the bottom right corner. Look for and expand the `Android 12 (S)` entry, then make sure the following items are checked:
+
+- `Android SDK Platform 31`
+- `Intel x86 Atom_64 System Image` or `Google APIs Intel x86 Atom System Image` or (for Apple M1 Silicon) `Google APIs ARM 64 v8a System Image`
+
+Next, select the "SDK Tools" tab and check the box next to "Show Package Details" here as well. Look for and expand the "Android SDK Build-Tools" entry, then make sure that `31.0.0` is selected.
+
+Finally, click "Apply" to download and install the Android SDK and related build tools.
+
+
3. Configure the ANDROID_SDK_ROOT environment variable
+
+The React Native tools require some environment variables to be set up in order to build apps with native code.
+
+Add the following lines to your `$HOME/.bash_profile` or `$HOME/.bashrc` (if you are using `zsh` then `~/.zprofile` or `~/.zshrc`) config file:
+
+```shell
+export ANDROID_SDK_ROOT=$HOME/Library/Android/sdk
+export PATH=$PATH:$ANDROID_SDK_ROOT/emulator
+export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools
+```
+
+> `.bash_profile` is specific to `bash`. If you're using another shell, you will need to edit the appropriate shell-specific config file.
+
+Type `source $HOME/.bash_profile` for `bash` or `source $HOME/.zprofile` to load the config into your current shell. Verify that ANDROID_SDK_ROOT has been set by running `echo $ANDROID_SDK_ROOT` and the appropriate directories have been added to your path by running `echo $PATH`.
+
+> Please make sure you use the correct Android SDK path. You can find the actual location of the SDK in the Android Studio "Preferences" dialog, under **Appearance & Behavior** → **System Settings** → **Android SDK**.
+
+
React Native Command Line Interface
+
+React Native has a built-in command line interface. Rather than install and manage a specific version of the CLI globally, we recommend you access the current version at runtime using `npx`, which ships with Node.js. With `npx react-native `, the current stable version of the CLI will be downloaded and executed at the time the command is run.
+
+
Creating a new application
+
+
+
+React Native has a built-in command line interface, which you can use to generate a new project. You can access it without installing anything globally using `npx`, which ships with Node.js. Let's create a new React Native project called "AwesomeProject":
+
+```shell
+npx react-native init AwesomeProject
+```
+
+This is not necessary if you are integrating React Native into an existing application, if you "ejected" from Expo, or if you're adding Android support to an existing React Native project (see [Integration with Existing Apps](integration-with-existing-apps.md)). You can also use a third-party CLI to init your React Native app, such as [Ignite CLI](https://github.com/infinitered/ignite).
+
+
[Optional] Using a specific version or template
+
+If you want to start a new project with a specific React Native version, you can use the `--version` argument:
+
+```shell
+npx react-native init AwesomeProject --version X.XX.X
+```
+
+You can also start a project with a custom React Native template, like TypeScript, with `--template` argument:
+
+```shell
+npx react-native init AwesomeTSProject --template react-native-template-typescript
+```
+
+
Preparing the Android device
+
+You will need an Android device to run your React Native Android app. This can be either a physical Android device, or more commonly, you can use an Android Virtual Device which allows you to emulate an Android device on your computer.
+
+Either way, you will need to prepare the device to run Android apps for development.
+
+
Using a physical device
+
+If you have a physical Android device, you can use it for development in place of an AVD by plugging it in to your computer using a USB cable and following the instructions [here](running-on-device.md).
+
+
Using a virtual device
+
+If you use Android Studio to open `./AwesomeProject/android`, you can see the list of available Android Virtual Devices (AVDs) by opening the "AVD Manager" from within Android Studio. Look for an icon that looks like this:
+
+
+
+If you have recently installed Android Studio, you will likely need to [create a new AVD](https://developer.android.com/studio/run/managing-avds.html). Select "Create Virtual Device...", then pick any Phone from the list and click "Next", then select the **S** API Level 31 image.
+
+Click "Next" then "Finish" to create your AVD. At this point you should be able to click on the green triangle button next to your AVD to launch it, then proceed to the next step.
+
+
Running your React Native application
+
+
Step 1: Start Metro
+
+First, you will need to start Metro, the JavaScript bundler that ships with React Native. Metro "takes in an entry file and various options, and returns a single JavaScript file that includes all your code and its dependencies."—[Metro Docs](https://facebook.github.io/metro/docs/concepts)
+
+To start Metro, run `npx react-native start` inside your React Native project folder:
+
+```shell
+npx react-native start
+```
+
+`react-native start` starts Metro Bundler.
+
+> If you use the Yarn package manager, you can use `yarn` instead of `npx` when running React Native commands inside an existing project.
+
+> If you're familiar with web development, Metro is a lot like webpack—for React Native apps. Unlike Kotlin or Java, JavaScript isn't compiled—and neither is React Native. Bundling isn't the same as compiling, but it can help improve startup performance and translate some platform-specific JavaScript into more widely supported JavaScript.
+
+
Step 2: Start your application
+
+Let Metro Bundler run in its own terminal. Open a new terminal inside your React Native project folder. Run the following:
+
+```shell
+npx react-native run-android
+```
+
+If everything is set up correctly, you should see your new app running in your Android emulator shortly.
+
+
+
+`npx react-native run-android` is one way to run your app - you can also run it directly from within Android Studio.
+
+> If you can't get this to work, see the [Troubleshooting](troubleshooting.md) page.
+
+
Modifying your app
+
+Now that you have successfully run the app, let's modify it.
+
+- Open `App.js` in your text editor of choice and edit some lines.
+- Press the `R` key twice or select `Reload` from the Developer Menu (`⌘M`) to see your changes!
+
+
That's it!
+
+Congratulations! You've successfully run and modified your first React Native app.
+
+
+
+
Now what?
+
+- If you want to add this new React Native code to an existing application, check out the [Integration guide](integration-with-existing-apps.md).
+
+If you're curious to learn more about React Native, check out the [Introduction to React Native](getting-started).
diff --git a/website/versioned_docs/version-0.70/_getting-started-macos-ios.md b/website/versioned_docs/version-0.70/_getting-started-macos-ios.md
new file mode 100644
index 00000000000..9860a4cc4ba
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_getting-started-macos-ios.md
@@ -0,0 +1,150 @@
+import M1Cocoapods from './\_markdown-m1-cocoapods.mdx'; import RemoveGlobalCLI from './\_remove-global-cli.md';
+
+## Installing dependencies
+
+You will need Node, Watchman, the React Native command line interface, Xcode and CocoaPods.
+
+While you can use any editor of your choice to develop your app, you will need to install Xcode in order to set up the necessary tooling to build your React Native app for iOS.
+
+### Node & Watchman
+
+We recommend installing Node and Watchman using [Homebrew](http://brew.sh/). Run the following commands in a Terminal after installing Homebrew:
+
+```shell
+brew install node
+brew install watchman
+```
+
+If you have already installed Node on your system, make sure it is Node 14 or newer.
+
+[Watchman](https://facebook.github.io/watchman) is a tool by Facebook for watching changes in the filesystem. It is highly recommended you install it for better performance.
+
+### Xcode
+
+The easiest way to install Xcode is via the [Mac App Store](https://itunes.apple.com/us/app/xcode/id497799835?mt=12). Installing Xcode will also install the iOS Simulator and all the necessary tools to build your iOS app.
+
+If you have already installed Xcode on your system, make sure it is version 10 or newer.
+
+#### Command Line Tools
+
+You will also need to install the Xcode Command Line Tools. Open Xcode, then choose "Preferences..." from the Xcode menu. Go to the Locations panel and install the tools by selecting the most recent version in the Command Line Tools dropdown.
+
+
+
+#### Installing an iOS Simulator in Xcode
+
+To install a simulator, open Xcode > Preferences... and select the Components tab. Select a simulator with the corresponding version of iOS you wish to use.
+
+#### CocoaPods
+
+[CocoaPods](https://cocoapods.org/) is built with Ruby and it will be installable with the default Ruby available on macOS.
+
+Using the default Ruby available on macOS will require you to use `sudo` when installing gems. (This is only an issue for the duration of the gem installation, though.)
+
+```shell
+sudo gem install cocoapods
+```
+
+Otherwise you can use a Ruby version manager, such as `rbenv`. Apps created with the command `npx react-native init` described below are configured to work well with `rbenv` and will pick the correct Ruby version requested by the template.
+
+For more information, please visit [CocoaPods Getting Started guide](https://guides.cocoapods.org/using/getting-started.html).
+
+
+
+### React Native Command Line Interface
+
+React Native has a built-in command line interface. Rather than install and manage a specific version of the CLI globally, we recommend you access the current version at runtime using `npx`, which ships with Node.js. With `npx react-native `, the current stable version of the CLI will be downloaded and executed at the time the command is run.
+
+## Creating a new application
+
+
+
+You can use React Native's built-in command line interface to generate a new project. Let's create a new React Native project called "AwesomeProject":
+
+```shell
+npx react-native init AwesomeProject
+```
+
+This is not necessary if you are integrating React Native into an existing application, if you "ejected" from Expo, or if you're adding iOS support to an existing React Native project (see [Integration with Existing Apps](integration-with-existing-apps.md)). You can also use a third-party CLI to init your React Native app, such as [Ignite CLI](https://github.com/infinitered/ignite).
+
+### [Optional] Using a specific version or template
+
+If you want to start a new project with a specific React Native version, you can use the `--version` argument:
+
+```shell
+npx react-native init AwesomeProject --version X.XX.X
+```
+
+You can also start a project with a custom React Native template, like TypeScript, with `--template` argument:
+
+```shell
+npx react-native init AwesomeTSProject --template react-native-template-typescript
+```
+
+> **Note** If the above command is failing, you may have old version of `react-native` or `react-native-cli` installed globally on your pc. Try uninstalling the cli and run the cli using `npx`.
+
+### [Optional] Configuring your environment
+
+Starting from React Native version 0.69, it is possible to configure the Xcode environment using the `.xcode.env` file provided by the template.
+
+The `.xcode.env` file contains an environment variable to export the path to the `node` executable in the `NODE_BINARY` variable.
+This is the **suggested approach** to decouple the build infrastructure from the system version of `node`. You should customize this variable with your own path or your own `node` version manager, if it differs from the default.
+
+On top of this, it's possible to add any other environment variable and to source the `.xcode.env` file in your build script phases. If you need to run script that requires some specific environment, this is the **suggested approach**: it allows to decouple the build phases from a specific environment.
+
+## Running your React Native application
+
+### Step 1: Start Metro
+
+First, you will need to start Metro, the JavaScript bundler that ships with React Native. Metro "takes in an entry file and various options, and returns a single JavaScript file that includes all your code and its dependencies."—[Metro Docs](https://facebook.github.io/metro/docs/concepts)
+
+To start Metro, run `npx react-native start` inside your React Native project folder:
+
+```shell
+npx react-native start
+```
+
+`react-native start` starts Metro Bundler.
+
+> If you use the Yarn package manager, you can use `yarn` instead of `npx` when running React Native commands inside an existing project.
+
+> If you're familiar with web development, Metro is a lot like webpack—for React Native apps. Unlike Swift or Objective-C, JavaScript isn't compiled—and neither is React Native. Bundling isn't the same as compiling, but it can help improve startup performance and translate some platform-specific JavaScript into more widely supported JavaScript.
+
+### Step 2: Start your application
+
+Let Metro Bundler run in its own terminal. Open a new terminal inside your React Native project folder. Run the following:
+
+```shell
+npx react-native run-ios
+```
+
+You should see your new app running in the iOS Simulator shortly.
+
+
+
+`npx react-native run-ios` is one way to run your app. You can also run it directly from within Xcode.
+
+> If you can't get this to work, see the [Troubleshooting](troubleshooting.md) page.
+
+### Running on a device
+
+The above command will automatically run your app on the iOS Simulator by default. If you want to run the app on an actual physical iOS device, please follow the instructions [here](running-on-device.md).
+
+### Modifying your app
+
+Now that you have successfully run the app, let's modify it.
+
+- Open `App.js` in your text editor of choice and edit some lines.
+- Hit `⌘R` in your iOS Simulator to reload the app and see your changes!
+
+### That's it!
+
+Congratulations! You've successfully run and modified your first React Native app.
+
+
+
+## Now what?
+
+- If you want to add this new React Native code to an existing application, check out the [Integration guide](integration-with-existing-apps.md).
+
+If you're curious to learn more about React Native, check out the [Introduction to React Native](getting-started).
diff --git a/website/versioned_docs/version-0.70/_getting-started-windows-android.md b/website/versioned_docs/version-0.70/_getting-started-windows-android.md
new file mode 100644
index 00000000000..038a898e240
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_getting-started-windows-android.md
@@ -0,0 +1,210 @@
+import RemoveGlobalCLI from './\_remove-global-cli.md';
+
+
Installing dependencies
+
+You will need Node, the React Native command line interface, a JDK, and Android Studio.
+
+While you can use any editor of your choice to develop your app, you will need to install Android Studio in order to set up the necessary tooling to build your React Native app for Android.
+
+
Node, JDK
+
+We recommend installing Node via [Chocolatey](https://chocolatey.org), a popular package manager for Windows.
+
+It is recommended to use an LTS version of Node. If you want to be able to switch between different versions, you might want to install Node via [nvm-windows](https://github.com/coreybutler/nvm-windows), a Node version manager for Windows.
+
+React Native also requires [Java SE Development Kit (JDK)](https://openjdk.java.net/projects/jdk/11/), which can be installed using Chocolatey as well.
+
+Open an Administrator Command Prompt (right click Command Prompt and select "Run as Administrator"), then run the following command:
+
+```powershell
+choco install -y nodejs-lts openjdk11
+```
+
+If you have already installed Node on your system, make sure it is Node 14 or newer. If you already have a JDK on your system, we recommend JDK11. You may encounter problems using higher JDK versions.
+
+> You can find additional installation options on [Node's Downloads page](https://nodejs.org/en/download/).
+
+> If you're using the latest version of Java Development Kit, you'll need to change the Gradle version of your project so it can recognize the JDK. You can do that by going to `{project root folder}\android\gradle\wrapper\gradle-wrapper.properties` and changing the `distributionUrl` value to upgrade the Gradle version. You can check out [here the lastest releases of Gradle](https://gradle.org/releases/).
+
+
Android development environment
+
+Setting up your development environment can be somewhat tedious if you're new to Android development. If you're already familiar with Android development, there are a few things you may need to configure. In either case, please make sure to carefully follow the next few steps.
+
+
1. Install Android Studio
+
+[Download and install Android Studio](https://developer.android.com/studio/index.html). While on Android Studio installation wizard, make sure the boxes next to all of the following items are checked:
+
+- `Android SDK`
+- `Android SDK Platform`
+- `Android Virtual Device`
+- If you are not already using Hyper-V: `Performance (Intel ® HAXM)` ([See here for AMD or Hyper-V](https://android-developers.googleblog.com/2018/07/android-emulator-amd-processor-hyper-v.html))
+
+Then, click "Next" to install all of these components.
+
+> If the checkboxes are grayed out, you will have a chance to install these components later on.
+
+Once setup has finalized and you're presented with the Welcome screen, proceed to the next step.
+
+
2. Install the Android SDK
+
+Android Studio installs the latest Android SDK by default. Building a React Native app with native code, however, requires the `Android 12 (S)` SDK in particular. Additional Android SDKs can be installed through the SDK Manager in Android Studio.
+
+To do that, open Android Studio, click on "More Actions" button and select "SDK Manager".
+
+
+
+> The SDK Manager can also be found within the Android Studio "Preferences" dialog, under **Appearance & Behavior** → **System Settings** → **Android SDK**.
+
+Select the "SDK Platforms" tab from within the SDK Manager, then check the box next to "Show Package Details" in the bottom right corner. Look for and expand the `Android 12 (S)` entry, then make sure the following items are checked:
+
+- `Android SDK Platform 31`
+- `Intel x86 Atom_64 System Image` or `Google APIs Intel x86 Atom System Image`
+
+Next, select the "SDK Tools" tab and check the box next to "Show Package Details" here as well. Look for and expand the `Android SDK Build-Tools` entry, then make sure that `31.0.0` is selected.
+
+Finally, click "Apply" to download and install the Android SDK and related build tools.
+
+
3. Configure the ANDROID_HOME environment variable
+
+The React Native tools require some environment variables to be set up in order to build apps with native code.
+
+1. Open the **Windows Control Panel.**
+2. Click on **User Accounts,** then click **User Accounts** again
+3. Click on **Change my environment variables**
+4. Click on **New...** to create a new `ANDROID_HOME` user variable that points to the path to your Android SDK:
+
+
+
+The SDK is installed, by default, at the following location:
+
+```powershell
+%LOCALAPPDATA%\Android\Sdk
+```
+
+You can find the actual location of the SDK in the Android Studio "Settings" dialog, under **Appearance & Behavior** → **System Settings** → **Android SDK**.
+
+Open a new Command Prompt window to ensure the new environment variable is loaded before proceeding to the next step.
+
+1. Open powershell
+2. Copy and paste **Get-ChildItem -Path Env:\\** into powershell
+3. Verify `ANDROID_HOME` has been added
+
+
4. Add platform-tools to Path
+
+1. Open the **Windows Control Panel.**
+2. Click on **User Accounts,** then click **User Accounts** again
+3. Click on **Change my environment variables**
+4. Select the **Path** variable.
+5. Click **Edit.**
+6. Click **New** and add the path to platform-tools to the list.
+
+The default location for this folder is:
+
+```powershell
+%LOCALAPPDATA%\Android\Sdk\platform-tools
+```
+
+
React Native Command Line Interface
+
+React Native has a built-in command line interface. Rather than install and manage a specific version of the CLI globally, we recommend you access the current version at runtime using `npx`, which ships with Node.js. With `npx react-native `, the current stable version of the CLI will be downloaded and executed at the time the command is run.
+
+
Creating a new application
+
+
+
+React Native has a built-in command line interface, which you can use to generate a new project. You can access it without installing anything globally using `npx`, which ships with Node.js. Let's create a new React Native project called "AwesomeProject":
+
+```shell
+npx react-native init AwesomeProject
+```
+
+This is not necessary if you are integrating React Native into an existing application, if you "ejected" from Expo, or if you're adding Android support to an existing React Native project (see [Integration with Existing Apps](integration-with-existing-apps.md)). You can also use a third-party CLI to init your React Native app, such as [Ignite CLI](https://github.com/infinitered/ignite).
+
+
[Optional] Using a specific version or template
+
+If you want to start a new project with a specific React Native version, you can use the `--version` argument:
+
+```shell
+npx react-native init AwesomeProject --version X.XX.X
+```
+
+You can also start a project with a custom React Native template, like TypeScript, with `--template` argument:
+
+```shell
+npx react-native init AwesomeTSProject --template react-native-template-typescript
+```
+
+
Preparing the Android device
+
+You will need an Android device to run your React Native Android app. This can be either a physical Android device, or more commonly, you can use an Android Virtual Device which allows you to emulate an Android device on your computer.
+
+Either way, you will need to prepare the device to run Android apps for development.
+
+
Using a physical device
+
+If you have a physical Android device, you can use it for development in place of an AVD by plugging it in to your computer using a USB cable and following the instructions [here](running-on-device.md).
+
+
Using a virtual device
+
+If you use Android Studio to open `./AwesomeProject/android`, you can see the list of available Android Virtual Devices (AVDs) by opening the "AVD Manager" from within Android Studio. Look for an icon that looks like this:
+
+
+
+If you have recently installed Android Studio, you will likely need to [create a new AVD](https://developer.android.com/studio/run/managing-avds.html). Select "Create Virtual Device...", then pick any Phone from the list and click "Next", then select the **S** API Level 31 image.
+
+> If you don't have HAXM installed, click on "Install HAXM" or follow [these instructions](https://github.com/intel/haxm/wiki/Installation-Instructions-on-Windows) to set it up, then go back to the AVD Manager.
+
+Click "Next" then "Finish" to create your AVD. At this point you should be able to click on the green triangle button next to your AVD to launch it, then proceed to the next step.
+
+
Running your React Native application
+
+
Step 1: Start Metro
+
+First, you will need to start Metro, the JavaScript bundler that ships with React Native. Metro "takes in an entry file and various options, and returns a single JavaScript file that includes all your code and its dependencies."—[Metro Docs](https://facebook.github.io/metro/docs/concepts)
+
+To start Metro, run `npx react-native start` inside your React Native project folder:
+
+```shell
+npx react-native start
+```
+
+`react-native start` starts Metro Bundler.
+
+> If you use the Yarn package manager, you can use `yarn` instead of `npx` when running React Native commands inside an existing project.
+
+> If you're familiar with web development, Metro is a lot like webpack—for React Native apps. Unlike Kotlin or Java, JavaScript isn't compiled—and neither is React Native. Bundling isn't the same as compiling, but it can help improve startup performance and translate some platform-specific JavaScript into more widely supported JavaScript.
+
+
Step 2: Start your application
+
+Let Metro Bundler run in its own terminal. Open a new terminal inside your React Native project folder. Run the following:
+
+```shell
+npx react-native run-android
+```
+
+If everything is set up correctly, you should see your new app running in your Android emulator shortly.
+
+
+
+`npx react-native run-android` is one way to run your app - you can also run it directly from within Android Studio.
+
+> If you can't get this to work, see the [Troubleshooting](troubleshooting.md) page.
+
+
Modifying your app
+
+Now that you have successfully run the app, let's modify it.
+
+- Open `App.js` in your text editor of choice and edit some lines.
+- Press the `R` key twice or select `Reload` from the Developer Menu (`Ctrl + M`) to see your changes!
+
+
That's it!
+
+Congratulations! You've successfully run and modified your first React Native app.
+
+
+
+
Now what?
+
+- If you want to add this new React Native code to an existing application, check out the [Integration guide](integration-with-existing-apps.md).
+
+If you're curious to learn more about React Native, check out the [Introduction to React Native](getting-started).
diff --git a/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-java.md b/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-java.md
new file mode 100644
index 00000000000..f090f7083be
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-java.md
@@ -0,0 +1,388 @@
+## Key Concepts
+
+The keys to integrating React Native components into your Android application are to:
+
+1. Set up React Native dependencies and directory structure.
+2. Develop your React Native components in JavaScript.
+3. Add a `ReactRootView` to your Android app. This view will serve as the container for your React Native component.
+4. Start the React Native server and run your native application.
+5. Verify that the React Native aspect of your application works as expected.
+
+## Prerequisites
+
+Follow the React Native CLI Quickstart in the [environment setup guide](environment-setup) to configure your development environment for building React Native apps for Android.
+
+### 1. Set up directory structure
+
+To ensure a smooth experience, create a new folder for your integrated React Native project, then copy your existing Android project to an `/android` subfolder.
+
+### 2. Install JavaScript dependencies
+
+Go to the root directory for your project and create a new `package.json` file with the following contents:
+
+```
+{
+ "name": "MyReactNativeApp",
+ "version": "0.0.1",
+ "private": true,
+ "scripts": {
+ "start": "yarn react-native start"
+ }
+}
+```
+
+Next, make sure you have [installed the yarn package manager](https://yarnpkg.com/lang/en/docs/install/).
+
+Install the `react` and `react-native` packages. Open a terminal or command prompt, then navigate to the directory with your `package.json` file and run:
+
+```shell
+$ yarn add react-native
+```
+
+This will print a message similar to the following (scroll up in the yarn output to see it):
+
+> warning "react-native@0.52.2" has unmet peer dependency "react@16.2.0".
+
+This is OK, it means we also need to install React:
+
+```shell
+$ yarn add react@version_printed_above
+```
+
+Yarn has created a new `/node_modules` folder. This folder stores all the JavaScript dependencies required to build your project.
+
+Add `node_modules/` to your `.gitignore` file.
+
+## Adding React Native to your app
+
+### Configuring maven
+
+Add the React Native and JSC dependency to your app's `build.gradle` file:
+
+```gradle
+dependencies {
+ implementation "com.android.support:appcompat-v7:27.1.1"
+ ...
+ implementation "com.facebook.react:react-native:+" // From node_modules
+ implementation "org.webkit:android-jsc:+"
+}
+```
+
+> If you want to ensure that you are always using a specific React Native version in your native build, replace `+` with an actual React Native version you've downloaded from `npm`.
+
+Add an entry for the local React Native and JSC maven directories to the top-level `build.gradle`. Be sure to add it to the “allprojects” block, above other maven repositories:
+
+```gradle
+allprojects {
+ repositories {
+ maven {
+ // All of React Native (JS, Android binaries) is installed from npm
+ url "$rootDir/../node_modules/react-native/android"
+ }
+ maven {
+ // Android JSC is installed from npm
+ url("$rootDir/../node_modules/jsc-android/dist")
+ }
+ ...
+ }
+ ...
+}
+```
+
+> Make sure that the path is correct! You shouldn’t run into any “Failed to resolve: com.facebook.react:react-native:0.x.x" errors after running Gradle sync in Android Studio.
+
+### Enable native modules autolinking
+
+To use the power of [autolinking](https://github.com/react-native-community/cli/blob/master/docs/autolinking.md), we have to apply it a few places. First add the following entry to `settings.gradle`:
+
+```gradle
+apply from: file("../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesSettingsGradle(settings)
+```
+
+Next add the following entry at the very bottom of the `app/build.gradle`:
+
+```gradle
+apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)
+```
+
+### Configuring permissions
+
+Next, make sure you have the Internet permission in your `AndroidManifest.xml`:
+
+
+
+If you need to access to the `DevSettingsActivity` add to your `AndroidManifest.xml`:
+
+
+
+This is only used in dev mode when reloading JavaScript from the development server, so you can strip this in release builds if you need to.
+
+### Cleartext Traffic (API level 28+)
+
+> Starting with Android 9 (API level 28), cleartext traffic is disabled by default; this prevents your application from connecting to the [Metro bundler][metro]. The changes below allow cleartext traffic in debug builds.
+
+#### 1. Apply the `usesCleartextTraffic` option to your Debug `AndroidManifest.xml`
+
+```xml
+
+
+
+
+
+```
+
+This is not required for Release builds.
+
+To learn more about Network Security Config and the cleartext traffic policy [see this link](https://developer.android.com/training/articles/security-config#CleartextTrafficPermitted).
+
+### Code integration
+
+Now we will actually modify the native Android application to integrate React Native.
+
+#### The React Native component
+
+The first bit of code we will write is the actual React Native code for the new "High Score" screen that will be integrated into our application.
+
+##### 1. Create a `index.js` file
+
+First, create an empty `index.js` file in the root of your React Native project.
+
+`index.js` is the starting point for React Native applications, and it is always required. It can be a small file that `require`s other file that are part of your React Native component or application, or it can contain all the code that is needed for it. In our case, we will put everything in `index.js`.
+
+##### 2. Add your React Native code
+
+In your `index.js`, create your component. In our sample here, we will add a `` component within a styled ``:
+
+```jsx
+import React from 'react';
+import {
+ AppRegistry,
+ StyleSheet,
+ Text,
+ View
+} from 'react-native';
+
+const HelloWorld = () => {
+ return (
+
+ Hello, World
+
+ );
+};
+var styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center'
+ },
+ hello: {
+ fontSize: 20,
+ textAlign: 'center',
+ margin: 10
+ }
+});
+
+AppRegistry.registerComponent(
+ 'MyReactNativeApp',
+ () => HelloWorld
+);
+```
+
+##### 3. Configure permissions for development error overlay
+
+If your app is targeting the Android `API level 23` or greater, make sure you have the permission `android.permission.SYSTEM_ALERT_WINDOW` enabled for the development build. You can check this with `Settings.canDrawOverlays(this);`. This is required in dev builds because React Native development errors must be displayed above all the other windows. Due to the new permissions system introduced in the API level 23 (Android M), the user needs to approve it. This can be achieved by adding the following code to your Activity's in `onCreate()` method.
+
+```java
+private final int OVERLAY_PERMISSION_REQ_CODE = 1; // Choose any value
+
+...
+
+if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if (!Settings.canDrawOverlays(this)) {
+ Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+ Uri.parse("package:" + getPackageName()));
+ startActivityForResult(intent, OVERLAY_PERMISSION_REQ_CODE);
+ }
+}
+```
+
+Finally, the `onActivityResult()` method (as shown in the code below) has to be overridden to handle the permission Accepted or Denied cases for consistent UX. Also, for integrating Native Modules which use `startActivityForResult`, we need to pass the result to the `onActivityResult` method of our `ReactInstanceManager` instance.
+
+```java
+@Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == OVERLAY_PERMISSION_REQ_CODE) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if (!Settings.canDrawOverlays(this)) {
+ // SYSTEM_ALERT_WINDOW permission not granted
+ }
+ }
+ }
+ mReactInstanceManager.onActivityResult( this, requestCode, resultCode, data );
+}
+```
+
+#### The Magic: `ReactRootView`
+
+Let's add some native code in order to start the React Native runtime and tell it to render our JS component. To do this, we're going to create an `Activity` that creates a `ReactRootView`, starts a React application inside it and sets it as the main content view.
+
+> If you are targeting Android version <5, use the `AppCompatActivity` class from the `com.android.support:appcompat` package instead of `Activity`.
+
+```java
+public class MyReactActivity extends Activity implements DefaultHardwareBackBtnHandler {
+ private ReactRootView mReactRootView;
+ private ReactInstanceManager mReactInstanceManager;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ SoLoader.init(this, false);
+
+ mReactRootView = new ReactRootView(this);
+ List packages = new PackageList(getApplication()).getPackages();
+ // Packages that cannot be autolinked yet can be added manually here, for example:
+ // packages.add(new MyReactNativePackage());
+ // Remember to include them in `settings.gradle` and `app/build.gradle` too.
+
+ mReactInstanceManager = ReactInstanceManager.builder()
+ .setApplication(getApplication())
+ .setCurrentActivity(this)
+ .setBundleAssetName("index.android.bundle")
+ .setJSMainModulePath("index")
+ .addPackages(packages)
+ .setUseDeveloperSupport(BuildConfig.DEBUG)
+ .setInitialLifecycleState(LifecycleState.RESUMED)
+ .build();
+ // The string here (e.g. "MyReactNativeApp") has to match
+ // the string in AppRegistry.registerComponent() in index.js
+ mReactRootView.startReactApplication(mReactInstanceManager, "MyReactNativeApp", null);
+
+ setContentView(mReactRootView);
+ }
+
+ @Override
+ public void invokeDefaultOnBackPressed() {
+ super.onBackPressed();
+ }
+}
+```
+
+> If you are using a starter kit for React Native, replace the "HelloWorld" string with the one in your index.js file (it’s the first argument to the `AppRegistry.registerComponent()` method).
+
+Perform a “Sync Project files with Gradle” operation.
+
+If you are using Android Studio, use `Alt + Enter` to add all missing imports in your MyReactActivity class. Be careful to use your package’s `BuildConfig` and not the one from the `facebook` package.
+
+We need set the theme of `MyReactActivity` to `Theme.AppCompat.Light.NoActionBar` because some React Native UI components rely on this theme.
+
+```xml
+
+
+```
+
+> A `ReactInstanceManager` can be shared by multiple activities and/or fragments. You will want to make your own `ReactFragment` or `ReactActivity` and have a singleton _holder_ that holds a `ReactInstanceManager`. When you need the `ReactInstanceManager` (e.g., to hook up the `ReactInstanceManager` to the lifecycle of those Activities or Fragments) use the one provided by the singleton.
+
+Next, we need to pass some activity lifecycle callbacks to the `ReactInstanceManager` and `ReactRootView`:
+
+```java
+@Override
+protected void onPause() {
+ super.onPause();
+
+ if (mReactInstanceManager != null) {
+ mReactInstanceManager.onHostPause(this);
+ }
+}
+
+@Override
+protected void onResume() {
+ super.onResume();
+
+ if (mReactInstanceManager != null) {
+ mReactInstanceManager.onHostResume(this, this);
+ }
+}
+
+@Override
+protected void onDestroy() {
+ super.onDestroy();
+
+ if (mReactInstanceManager != null) {
+ mReactInstanceManager.onHostDestroy(this);
+ }
+ if (mReactRootView != null) {
+ mReactRootView.unmountReactApplication();
+ }
+}
+```
+
+We also need to pass back button events to React Native:
+
+```java
+@Override
+ public void onBackPressed() {
+ if (mReactInstanceManager != null) {
+ mReactInstanceManager.onBackPressed();
+ } else {
+ super.onBackPressed();
+ }
+}
+```
+
+This allows JavaScript to control what happens when the user presses the hardware back button (e.g. to implement navigation). When JavaScript doesn't handle the back button press, your `invokeDefaultOnBackPressed` method will be called. By default this finishes your `Activity`.
+
+Finally, we need to hook up the dev menu. By default, this is activated by (rage) shaking the device, but this is not very useful in emulators. So we make it show when you press the hardware menu button (use `Ctrl + M` if you're using Android Studio emulator):
+
+```java
+@Override
+public boolean onKeyUp(int keyCode, KeyEvent event) {
+ if (keyCode == KeyEvent.KEYCODE_MENU && mReactInstanceManager != null) {
+ mReactInstanceManager.showDevOptionsDialog();
+ return true;
+ }
+ return super.onKeyUp(keyCode, event);
+}
+```
+
+Now your activity is ready to run some JavaScript code.
+
+### Test your integration
+
+You have now done all the basic steps to integrate React Native with your current application. Now we will start the [Metro bundler][metro] to build the `index.bundle` package and the server running on localhost to serve it.
+
+##### 1. Run the packager
+
+To run your app, you need to first start the development server. To do this, run the following command in the root directory of your React Native project:
+
+```shell
+$ yarn start
+```
+
+##### 2. Run the app
+
+Now build and run your Android app as normal.
+
+Once you reach your React-powered activity inside the app, it should load the JavaScript code from the development server and display:
+
+
+
+### Creating a release build in Android Studio
+
+You can use Android Studio to create your release builds too! It’s as quick as creating release builds of your previously-existing native Android app. There’s one additional step, which you’ll have to do before every release build. You need to execute the following to create a React Native bundle, which will be included with your native Android app:
+
+```shell
+$ npx react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/com/your-company-name/app-package-name/src/main/assets/index.android.bundle --assets-dest android/com/your-company-name/app-package-name/src/main/res/
+```
+
+> Don’t forget to replace the paths with correct ones and create the assets folder if it doesn’t exist.
+
+Now, create a release build of your native app from within Android Studio as usual and you should be good to go!
+
+### Now what?
+
+At this point you can continue developing your app as usual. Refer to our [debugging](debugging) and [deployment](running-on-device) docs to learn more about working with React Native.
+
+[metro]: https://facebook.github.io/metro/
diff --git a/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-objc.md b/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-objc.md
new file mode 100644
index 00000000000..893187c9b91
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-objc.md
@@ -0,0 +1,398 @@
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants'; import M1Cocoapods from './\_markdown-m1-cocoapods.mdx';
+
+## Key Concepts
+
+The keys to integrating React Native components into your iOS application are to:
+
+1. Set up React Native dependencies and directory structure.
+2. Understand what React Native components you will use in your app.
+3. Add these components as dependencies using CocoaPods.
+4. Develop your React Native components in JavaScript.
+5. Add a `RCTRootView` to your iOS app. This view will serve as the container for your React Native component.
+6. Start the React Native server and run your native application.
+7. Verify that the React Native aspect of your application works as expected.
+
+## Prerequisites
+
+Follow the React Native CLI Quickstart in the [environment setup guide](environment-setup) to configure your development environment for building React Native apps for iOS.
+
+### 1. Set up directory structure
+
+To ensure a smooth experience, create a new folder for your integrated React Native project, then copy your existing iOS project to a `/ios` subfolder.
+
+### 2. Install JavaScript dependencies
+
+Go to the root directory for your project and create a new `package.json` file with the following contents:
+
+```
+{
+ "name": "MyReactNativeApp",
+ "version": "0.0.1",
+ "private": true,
+ "scripts": {
+ "start": "yarn react-native start"
+ }
+}
+```
+
+Next, make sure you have [installed the yarn package manager](https://yarnpkg.com/lang/en/docs/install/).
+
+Install the `react` and `react-native` packages. Open a terminal or command prompt, then navigate to the directory with your `package.json` file and run:
+
+
+
+
+```shell
+npm install react-native
+```
+
+
+
+
+```shell
+yarn add react-native
+```
+
+
+
+
+This will print a message similar to the following (scroll up in the yarn output to see it):
+
+> warning "react-native@0.52.2" has unmet peer dependency "react@16.2.0".
+
+This is OK, it means we also need to install React:
+
+
+
+
+```shell
+npm install react@version_printed_above
+```
+
+
+
+
+```shell
+yarn add react@version_printed_above
+```
+
+
+
+
+Installation process has created a new `/node_modules` folder. This folder stores all the JavaScript dependencies required to build your project.
+
+Add `node_modules/` to your `.gitignore` file.
+
+### 3. Install CocoaPods
+
+[CocoaPods](http://cocoapods.org) is a package management tool for iOS and macOS development. We use it to add the actual React Native framework code locally into your current project.
+
+We recommend installing CocoaPods using [Homebrew](http://brew.sh/).
+
+```shell
+brew install cocoapods
+```
+
+> It is technically possible not to use CocoaPods, but that would require manual library and linker additions that would overly complicate this process.
+
+## Adding React Native to your app
+
+Assume the [app for integration](https://github.com/JoelMarcey/iOS-2048) is a [2048](https://en.wikipedia.org/wiki/2048_%28video_game%29) game. Here is what the main menu of the native application looks like without React Native.
+
+
+
+### Command Line Tools for Xcode
+
+Install the Command Line Tools. Choose "Preferences..." in the Xcode menu. Go to the Locations panel and install the tools by selecting the most recent version in the Command Line Tools dropdown.
+
+
+
+### Configuring CocoaPods dependencies
+
+Before you integrate React Native into your application, you will want to decide what parts of the React Native framework you would like to integrate. We will use CocoaPods to specify which of these "subspecs" your app will depend on.
+
+The list of supported `subspec`s is available in [`/node_modules/react-native/React.podspec`](https://github.com/facebook/react-native/blob/master/React.podspec). They are generally named by functionality. For example, you will generally always want the `Core` `subspec`. That will get you the `AppRegistry`, `StyleSheet`, `View` and other core React Native libraries. If you want to add the React Native `Text` library (e.g., for `` elements), then you will need the `RCTText` `subspec`. If you want the `Image` library (e.g., for `` elements), then you will need the `RCTImage` `subspec`.
+
+You can specify which `subspec`s your app will depend on in a `Podfile` file. The easiest way to create a `Podfile` is by running the CocoaPods `init` command in the `/ios` subfolder of your project:
+
+```shell
+pod init
+```
+
+The `Podfile` will contain a boilerplate setup that you will tweak for your integration purposes.
+
+> The `Podfile` version changes depending on your version of `react-native`. Refer to https://react-native-community.github.io/upgrade-helper/ for the specific version of `Podfile` you should be using.
+
+Ultimately, your `Podfile` should look something similar to this:
+
+```
+# The target name is most likely the name of your project.
+target 'NumberTileGame' do
+
+ # Your 'node_modules' directory is probably in the root of your project,
+ # but if not, adjust the `:path` accordingly
+ pod 'FBLazyVector', :path => "../node_modules/react-native/Libraries/FBLazyVector"
+ pod 'FBReactNativeSpec', :path => "../node_modules/react-native/Libraries/FBReactNativeSpec"
+ pod 'RCTRequired', :path => "../node_modules/react-native/Libraries/RCTRequired"
+ pod 'RCTTypeSafety', :path => "../node_modules/react-native/Libraries/TypeSafety"
+ pod 'React', :path => '../node_modules/react-native/'
+ pod 'React-Core', :path => '../node_modules/react-native/'
+ pod 'React-CoreModules', :path => '../node_modules/react-native/React/CoreModules'
+ pod 'React-Core/DevSupport', :path => '../node_modules/react-native/'
+ pod 'React-RCTActionSheet', :path => '../node_modules/react-native/Libraries/ActionSheetIOS'
+ pod 'React-RCTAnimation', :path => '../node_modules/react-native/Libraries/NativeAnimation'
+ pod 'React-RCTBlob', :path => '../node_modules/react-native/Libraries/Blob'
+ pod 'React-RCTImage', :path => '../node_modules/react-native/Libraries/Image'
+ pod 'React-RCTLinking', :path => '../node_modules/react-native/Libraries/LinkingIOS'
+ pod 'React-RCTNetwork', :path => '../node_modules/react-native/Libraries/Network'
+ pod 'React-RCTSettings', :path => '../node_modules/react-native/Libraries/Settings'
+ pod 'React-RCTText', :path => '../node_modules/react-native/Libraries/Text'
+ pod 'React-RCTVibration', :path => '../node_modules/react-native/Libraries/Vibration'
+ pod 'React-Core/RCTWebSocket', :path => '../node_modules/react-native/'
+
+ pod 'React-cxxreact', :path => '../node_modules/react-native/ReactCommon/cxxreact'
+ pod 'React-jsi', :path => '../node_modules/react-native/ReactCommon/jsi'
+ pod 'React-jsiexecutor', :path => '../node_modules/react-native/ReactCommon/jsiexecutor'
+ pod 'React-jsinspector', :path => '../node_modules/react-native/ReactCommon/jsinspector'
+ pod 'ReactCommon/callinvoker', :path => "../node_modules/react-native/ReactCommon"
+ pod 'ReactCommon/turbomodule/core', :path => "../node_modules/react-native/ReactCommon"
+ pod 'Yoga', :path => '../node_modules/react-native/ReactCommon/yoga'
+
+ pod 'DoubleConversion', :podspec => '../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec'
+ pod 'glog', :podspec => '../node_modules/react-native/third-party-podspecs/glog.podspec'
+ pod 'Folly', :podspec => '../node_modules/react-native/third-party-podspecs/Folly.podspec'
+
+end
+```
+
+After you have created your `Podfile`, you are ready to install the React Native pod.
+
+```shell
+$ pod install
+```
+
+You should see output such as:
+
+```
+Analyzing dependencies
+Fetching podspec for `React` from `../node_modules/react-native`
+Downloading dependencies
+Installing React (0.62.0)
+Generating Pods project
+Integrating client project
+Sending stats
+Pod installation complete! There are 3 dependencies from the Podfile and 1 total pod installed.
+```
+
+> If this fails with errors mentioning `xcrun`, make sure that in Xcode in **Preferences > Locations** the Command Line Tools are assigned.
+
+
+
+### Code integration
+
+Now we will actually modify the native iOS application to integrate React Native. For our 2048 sample app, we will add a "High Score" screen in React Native.
+
+#### The React Native component
+
+The first bit of code we will write is the actual React Native code for the new "High Score" screen that will be integrated into our application.
+
+##### 1. Create a `index.js` file
+
+First, create an empty `index.js` file in the root of your React Native project.
+
+`index.js` is the starting point for React Native applications, and it is always required. It can be a small file that `require`s other file that are part of your React Native component or application, or it can contain all the code that is needed for it. In our case, we will put everything in `index.js`.
+
+##### 2. Add your React Native code
+
+In your `index.js`, create your component. In our sample here, we will add a `` component within a styled ``
+
+```jsx
+import React from 'react';
+import {
+ AppRegistry,
+ StyleSheet,
+ Text,
+ View
+} from 'react-native';
+
+const RNHighScores = ({ scores }) => {
+ const contents = scores.map((score) => (
+
+ {score.name}:{score.value}
+ {'\n'}
+
+ ));
+ return (
+
+
+ 2048 High Scores!
+
+ {contents}
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center',
+ alignItems: 'center',
+ backgroundColor: '#FFFFFF'
+ },
+ highScoresTitle: {
+ fontSize: 20,
+ textAlign: 'center',
+ margin: 10
+ },
+ scores: {
+ textAlign: 'center',
+ color: '#333333',
+ marginBottom: 5
+ }
+});
+
+// Module name
+AppRegistry.registerComponent('RNHighScores', () => RNHighScores);
+```
+
+> `RNHighScores` is the name of your module that will be used when you add a view to React Native from within your iOS application.
+
+#### The Magic: `RCTRootView`
+
+Now that your React Native component is created via `index.js`, you need to add that component to a new or existing `ViewController`. The easiest path to take is to optionally create an event path to your component and then add that component to an existing `ViewController`.
+
+We will tie our React Native component with a new native view in the `ViewController` that will actually contain it called `RCTRootView` .
+
+##### 1. Create an Event Path
+
+You can add a new link on the main game menu to go to the "High Score" React Native page.
+
+
+
+##### 2. Event Handler
+
+We will now add an event handler from the menu link. A method will be added to the main `ViewController` of your application. This is where `RCTRootView` comes into play.
+
+When you build a React Native application, you use the [Metro bundler][metro] to create an `index.bundle` that will be served by the React Native server. Inside `index.bundle` will be our `RNHighScore` module. So, we need to point our `RCTRootView` to the location of the `index.bundle` resource (via `NSURL`) and tie it to the module.
+
+We will, for debugging purposes, log that the event handler was invoked. Then, we will create a string with the location of our React Native code that exists inside the `index.bundle`. Finally, we will create the main `RCTRootView`. Notice how we provide `RNHighScores` as the `moduleName` that we created [above](#the-react-native-component) when writing the code for our React Native component.
+
+First `import` the `RCTRootView` header.
+
+```objectivec
+#import
+```
+
+> The `initialProperties` are here for illustration purposes so we have some data for our high score screen. In our React Native component, we will use `this.props` to get access to that data.
+
+```objectivec
+- (IBAction)highScoreButtonPressed:(id)sender {
+ NSLog(@"High Score Button Pressed");
+ NSURL *jsCodeLocation = [NSURL URLWithString:@"http://localhost:8081/index.bundle?platform=ios"];
+
+ RCTRootView *rootView =
+ [[RCTRootView alloc] initWithBundleURL: jsCodeLocation
+ moduleName: @"RNHighScores"
+ initialProperties:
+ @{
+ @"scores" : @[
+ @{
+ @"name" : @"Alex",
+ @"value": @"42"
+ },
+ @{
+ @"name" : @"Joel",
+ @"value": @"10"
+ }
+ ]
+ }
+ launchOptions: nil];
+ UIViewController *vc = [[UIViewController alloc] init];
+ vc.view = rootView;
+ [self presentViewController:vc animated:YES completion:nil];
+}
+```
+
+> Note that `RCTRootView initWithURL` starts up a new JSC VM. To save resources and simplify the communication between RN views in different parts of your native app, you can have multiple views powered by React Native that are associated with a single JS runtime. To do that, instead of using `[RCTRootView alloc] initWithURL`, use [`RCTBridge initWithBundleURL`](https://github.com/facebook/react-native/blob/master/React/Base/RCTBridge.h#L93) to create a bridge and then use `RCTRootView initWithBridge`.
+
+> When moving your app to production, the `NSURL` can point to a pre-bundled file on disk via something like `[[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];`. You can use the `react-native-xcode.sh` script in `node_modules/react-native/scripts/` to generate that pre-bundled file.
+
+##### 3. Wire Up
+
+Wire up the new link in the main menu to the newly added event handler method.
+
+
+
+> One of the easier ways to do this is to open the view in the storyboard and right click on the new link. Select something such as the `Touch Up Inside` event, drag that to the storyboard and then select the created method from the list provided.
+
+### Test your integration
+
+You have now done all the basic steps to integrate React Native with your current application. Now we will start the [Metro bundler][metro] to build the `index.bundle` package and the server running on `localhost` to serve it.
+
+##### 1. Add App Transport Security exception
+
+Apple has blocked implicit cleartext HTTP resource loading. So we need to add the following our project's `Info.plist` (or equivalent) file.
+
+```xml
+NSAppTransportSecurity
+
+ NSExceptionDomains
+
+ localhost
+
+ NSTemporaryExceptionAllowsInsecureHTTPLoads
+
+
+
+
+```
+
+> App Transport Security is good for your users. Make sure to re-enable it prior to releasing your app for production.
+
+##### 2. Run the packager
+
+To run your app, you need to first start the development server. To do this, run the following command in the root directory of your React Native project:
+
+
+
+
+```shell
+npm start
+```
+
+
+
+
+```shell
+yarn start
+```
+
+
+
+
+##### 3. Run the app
+
+If you are using Xcode or your favorite editor, build and run your native iOS application as normal. Alternatively, you can run the app from the command line using:
+
+```
+# From the root of your project
+$ npx react-native run-ios
+```
+
+In our sample application, you should see the link to the "High Scores" and then when you click on that you will see the rendering of your React Native component.
+
+Here is the _native_ application home screen:
+
+
+
+Here is the _React Native_ high score screen:
+
+
+
+> If you are getting module resolution issues when running your application please see [this GitHub issue](https://github.com/facebook/react-native/issues/4968) for information and possible resolution. [This comment](https://github.com/facebook/react-native/issues/4968#issuecomment-220941717) seemed to be the latest possible resolution.
+
+### Now what?
+
+At this point you can continue developing your app as usual. Refer to our [debugging](debugging) and [deployment](running-on-device) docs to learn more about working with React Native.
+
+[metro]: https://facebook.github.io/metro/
diff --git a/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-swift.md b/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-swift.md
new file mode 100644
index 00000000000..a1c8ea18456
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_integration-with-exisiting-apps-swift.md
@@ -0,0 +1,348 @@
+import M1Cocoapods from './\_markdown-m1-cocoapods.mdx';
+
+## Key Concepts
+
+The keys to integrating React Native components into your iOS application are to:
+
+1. Set up React Native dependencies and directory structure.
+2. Understand what React Native components you will use in your app.
+3. Add these components as dependencies using CocoaPods.
+4. Develop your React Native components in JavaScript.
+5. Add a `RCTRootView` to your iOS app. This view will serve as the container for your React Native component.
+6. Start the React Native server and run your native application.
+7. Verify that the React Native aspect of your application works as expected.
+
+## Prerequisites
+
+Follow the React Native CLI Quickstart in the [environment setup guide](environment-setup) to configure your development environment for building React Native apps for iOS.
+
+### 1. Set up directory structure
+
+To ensure a smooth experience, create a new folder for your integrated React Native project, then copy your existing iOS project to a `/ios` subfolder.
+
+### 2. Install JavaScript dependencies
+
+Go to the root directory for your project and create a new `package.json` file with the following contents:
+
+```
+{
+ "name": "MyReactNativeApp",
+ "version": "0.0.1",
+ "private": true,
+ "scripts": {
+ "start": "yarn react-native start"
+ }
+}
+```
+
+Next, make sure you have [installed the yarn package manager](https://yarnpkg.com/lang/en/docs/install/).
+
+Install the `react` and `react-native` packages. Open a terminal or command prompt, then navigate to the directory with your `package.json` file and run:
+
+```shell
+$ yarn add react-native
+```
+
+This will print a message similar to the following (scroll up in the yarn output to see it):
+
+> warning "react-native@0.52.2" has unmet peer dependency "react@16.2.0".
+
+This is OK, it means we also need to install React:
+
+```shell
+$ yarn add react@version_printed_above
+```
+
+Yarn has created a new `/node_modules` folder. This folder stores all the JavaScript dependencies required to build your project.
+
+Add `node_modules/` to your `.gitignore` file.
+
+### 3. Install CocoaPods
+
+[CocoaPods](http://cocoapods.org) is a package management tool for iOS and macOS development. We use it to add the actual React Native framework code locally into your current project.
+
+We recommend installing CocoaPods using [Homebrew](http://brew.sh/).
+
+```shell
+$ brew install cocoapods
+```
+
+> It is technically possible not to use CocoaPods, but that would require manual library and linker additions that would overly complicate this process.
+
+## Adding React Native to your app
+
+Assume the [app for integration](https://github.com/JoelMarcey/swift-2048) is a [2048](https://en.wikipedia.org/wiki/2048_%28video_game%29) game. Here is what the main menu of the native application looks like without React Native.
+
+
+
+### Command Line Tools for Xcode
+
+Install the Command Line Tools. Choose "Preferences..." in the Xcode menu. Go to the Locations panel and install the tools by selecting the most recent version in the Command Line Tools dropdown.
+
+
+
+### Configuring CocoaPods dependencies
+
+Before you integrate React Native into your application, you will want to decide what parts of the React Native framework you would like to integrate. We will use CocoaPods to specify which of these "subspecs" your app will depend on.
+
+The list of supported `subspec`s is available in [`/node_modules/react-native/React.podspec`](https://github.com/facebook/react-native/blob/master/React.podspec). They are generally named by functionality. For example, you will generally always want the `Core` `subspec`. That will get you the `AppRegistry`, `StyleSheet`, `View` and other core React Native libraries. If you want to add the React Native `Text` library (e.g., for `` elements), then you will need the `RCTText` `subspec`. If you want the `Image` library (e.g., for `` elements), then you will need the `RCTImage` `subspec`.
+
+You can specify which `subspec`s your app will depend on in a `Podfile` file. The easiest way to create a `Podfile` is by running the CocoaPods `init` command in the `/ios` subfolder of your project:
+
+```shell
+$ pod init
+```
+
+The `Podfile` will contain a boilerplate setup that you will tweak for your integration purposes.
+
+> The `Podfile` version changes depending on your version of `react-native`. Refer to https://react-native-community.github.io/upgrade-helper/ for the specific version of `Podfile` you should be using.
+
+Ultimately, your `Podfile` should look something similar to this:
+
+```
+source 'https://github.com/CocoaPods/Specs.git'
+
+# Required for Swift apps
+platform :ios, '8.0'
+use_frameworks!
+
+# The target name is most likely the name of your project.
+target 'swift-2048' do
+
+ # Your 'node_modules' directory is probably in the root of your project,
+ # but if not, adjust the `:path` accordingly
+ pod 'React', :path => '../node_modules/react-native', :subspecs => [
+ 'Core',
+ 'CxxBridge', # Include this for RN >= 0.47
+ 'DevSupport', # Include this to enable In-App Devmenu if RN >= 0.43
+ 'RCTText',
+ 'RCTNetwork',
+ 'RCTWebSocket', # needed for debugging
+ # Add any other subspecs you want to use in your project
+ ]
+ # Explicitly include Yoga if you are using RN >= 0.42.0
+ pod "Yoga", :path => "../node_modules/react-native/ReactCommon/yoga"
+
+ # Third party deps podspec link
+ pod 'DoubleConversion', :podspec => '../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec'
+ pod 'glog', :podspec => '../node_modules/react-native/third-party-podspecs/glog.podspec'
+ pod 'Folly', :podspec => '../node_modules/react-native/third-party-podspecs/Folly.podspec'
+
+end
+```
+
+After you have created your `Podfile`, you are ready to install the React Native pod.
+
+```shell
+$ pod install
+```
+
+You should see output such as:
+
+```
+Analyzing dependencies
+Fetching podspec for `React` from `../node_modules/react-native`
+Downloading dependencies
+Installing React (0.62.0)
+Generating Pods project
+Integrating client project
+Sending stats
+Pod installation complete! There are 3 dependencies from the Podfile and 1 total pod installed.
+```
+
+> If this fails with errors mentioning `xcrun`, make sure that in Xcode in **Preferences > Locations** the Command Line Tools are assigned.
+
+> If you get a warning such as "_The `swift-2048 [Debug]` target overrides the `FRAMEWORK_SEARCH_PATHS` build setting defined in `Pods/Target Support Files/Pods-swift-2048/Pods-swift-2048.debug.xcconfig`. This can lead to problems with the CocoaPods installation_", then make sure the `Framework Search Paths` in `Build Settings` for both `Debug` and `Release` only contain `$(inherited)`.
+
+
+
+### Code integration
+
+Now we will actually modify the native iOS application to integrate React Native. For our 2048 sample app, we will add a "High Score" screen in React Native.
+
+#### The React Native component
+
+The first bit of code we will write is the actual React Native code for the new "High Score" screen that will be integrated into our application.
+
+##### 1. Create a `index.js` file
+
+First, create an empty `index.js` file in the root of your React Native project.
+
+`index.js` is the starting point for React Native applications, and it is always required. It can be a small file that `require`s other file that are part of your React Native component or application, or it can contain all the code that is needed for it. In our case, we will put everything in `index.js`.
+
+##### 2. Add your React Native code
+
+In your `index.js`, create your component. In our sample here, we will add a `` component within a styled ``
+
+```jsx
+import React from 'react';
+import {
+ AppRegistry,
+ StyleSheet,
+ Text,
+ View
+} from 'react-native';
+
+const RNHighScores = ({ scores }) => {
+ const contents = scores.map((score) => (
+
+ {score.name}:{score.value}
+ {'\n'}
+
+ ));
+ return (
+
+
+ 2048 High Scores!
+
+ {contents}
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center',
+ alignItems: 'center',
+ backgroundColor: '#FFFFFF'
+ },
+ highScoresTitle: {
+ fontSize: 20,
+ textAlign: 'center',
+ margin: 10
+ },
+ scores: {
+ textAlign: 'center',
+ color: '#333333',
+ marginBottom: 5
+ }
+});
+
+// Module name
+AppRegistry.registerComponent('RNHighScores', () => RNHighScores);
+```
+
+> `RNHighScores` is the name of your module that will be used when you add a view to React Native from within your iOS application.
+
+#### The Magic: `RCTRootView`
+
+Now that your React Native component is created via `index.js`, you need to add that component to a new or existing `ViewController`. The easiest path to take is to optionally create an event path to your component and then add that component to an existing `ViewController`.
+
+We will tie our React Native component with a new native view in the `ViewController` that will actually contain it called `RCTRootView` .
+
+##### 1. Create an Event Path
+
+You can add a new link on the main game menu to go to the "High Score" React Native page.
+
+
+
+##### 2. Event Handler
+
+We will now add an event handler from the menu link. A method will be added to the main `ViewController` of your application. This is where `RCTRootView` comes into play.
+
+When you build a React Native application, you use the [Metro bundler][metro] to create an `index.bundle` that will be served by the React Native server. Inside `index.bundle` will be our `RNHighScore` module. So, we need to point our `RCTRootView` to the location of the `index.bundle` resource (via `NSURL`) and tie it to the module.
+
+We will, for debugging purposes, log that the event handler was invoked. Then, we will create a string with the location of our React Native code that exists inside the `index.bundle`. Finally, we will create the main `RCTRootView`. Notice how we provide `RNHighScores` as the `moduleName` that we created [above](#the-react-native-component) when writing the code for our React Native component.
+
+First `import` the `React` library.
+
+```jsx
+import React
+```
+
+> The `initialProperties` are here for illustration purposes so we have some data for our high score screen. In our React Native component, we will use `this.props` to get access to that data.
+
+```swift
+@IBAction func highScoreButtonTapped(sender : UIButton) {
+ NSLog("Hello")
+ let jsCodeLocation = URL(string: "http://localhost:8081/index.bundle?platform=ios")
+ let mockData:NSDictionary = ["scores":
+ [
+ ["name":"Alex", "value":"42"],
+ ["name":"Joel", "value":"10"]
+ ]
+ ]
+
+ let rootView = RCTRootView(
+ bundleURL: jsCodeLocation,
+ moduleName: "RNHighScores",
+ initialProperties: mockData as [NSObject : AnyObject],
+ launchOptions: nil
+ )
+ let vc = UIViewController()
+ vc.view = rootView
+ self.present(vc, animated: true, completion: nil)
+}
+```
+
+> Note that `RCTRootView bundleURL` starts up a new JSC VM. To save resources and simplify the communication between RN views in different parts of your native app, you can have multiple views powered by React Native that are associated with a single JS runtime. To do that, instead of using `RCTRootView bundleURL`, use [`RCTBridge initWithBundleURL`](https://github.com/facebook/react-native/blob/master/React/Base/RCTBridge.h#L89) to create a bridge and then use `RCTRootView initWithBridge`.
+
+> When moving your app to production, the `NSURL` can point to a pre-bundled file on disk via something like `let mainBundle = NSBundle(URLForResource: "main" withExtension:"jsbundle")`. You can use the `react-native-xcode.sh` script in `node_modules/react-native/scripts/` to generate that pre-bundled file.
+
+##### 3. Wire Up
+
+Wire up the new link in the main menu to the newly added event handler method.
+
+
+
+> One of the easier ways to do this is to open the view in the storyboard and right click on the new link. Select something such as the `Touch Up Inside` event, drag that to the storyboard and then select the created method from the list provided.
+
+### Test your integration
+
+You have now done all the basic steps to integrate React Native with your current application. Now we will start the [Metro bundler][metro] to build the `index.bundle` package and the server running on `localhost` to serve it.
+
+##### 1. Add App Transport Security exception
+
+Apple has blocked implicit cleartext HTTP resource loading. So we need to add the following our project's `Info.plist` (or equivalent) file.
+
+```xml
+NSAppTransportSecurity
+
+ NSExceptionDomains
+
+ localhost
+
+ NSTemporaryExceptionAllowsInsecureHTTPLoads
+
+
+
+
+```
+
+> App Transport Security is good for your users. Make sure to re-enable it prior to releasing your app for production.
+
+##### 2. Run the packager
+
+To run your app, you need to first start the development server. To do this, run the following command in the root directory of your React Native project:
+
+```shell
+$ npm start
+```
+
+##### 3. Run the app
+
+If you are using Xcode or your favorite editor, build and run your native iOS application as normal. Alternatively, you can run the app from the command line using:
+
+```
+# From the root of your project
+$ npx react-native run-ios
+```
+
+In our sample application, you should see the link to the "High Scores" and then when you click on that you will see the rendering of your React Native component.
+
+Here is the _native_ application home screen:
+
+
+
+Here is the _React Native_ high score screen:
+
+
+
+> If you are getting module resolution issues when running your application please see [this GitHub issue](https://github.com/facebook/react-native/issues/4968) for information and possible resolution. [This comment](https://github.com/facebook/react-native/issues/4968#issuecomment-220941717) seemed to be the latest possible resolution.
+
+### Now what?
+
+At this point you can continue developing your app as usual. Refer to our [debugging](debugging) and [deployment](running-on-device) docs to learn more about working with React Native.
+
+[metro]: https://facebook.github.io/metro/
diff --git a/website/versioned_docs/version-0.70/_integration-with-existing-apps-kotlin.md b/website/versioned_docs/version-0.70/_integration-with-existing-apps-kotlin.md
new file mode 100644
index 00000000000..9500da50e71
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_integration-with-existing-apps-kotlin.md
@@ -0,0 +1,381 @@
+## Key Concepts
+
+The keys to integrating React Native components into your Android application are to:
+
+1. Set up React Native dependencies and directory structure.
+2. Develop your React Native components in JavaScript.
+3. Add a `ReactRootView` to your Android app. This view will serve as the container for your React Native component.
+4. Start the React Native server and run your native application.
+5. Verify that the React Native aspect of your application works as expected.
+
+## Prerequisites
+
+Follow the React Native CLI Quickstart in the [environment setup guide](environment-setup) to configure your development environment for building React Native apps for Android.
+
+### 1. Set up directory structure
+
+To ensure a smooth experience, create a new folder for your integrated React Native project, then copy your existing Android project to an `/android` subfolder.
+
+### 2. Install JavaScript dependencies
+
+Go to the root directory for your project and create a new `package.json` file with the following contents:
+
+```
+{
+ "name": "MyReactNativeApp",
+ "version": "0.0.1",
+ "private": true,
+ "scripts": {
+ "start": "yarn react-native start"
+ }
+}
+```
+
+Next, make sure you have [installed the yarn package manager](https://yarnpkg.com/lang/en/docs/install/).
+
+Install the `react` and `react-native` packages. Open a terminal or command prompt, then navigate to the directory with your `package.json` file and run:
+
+```shell
+$ yarn add react-native
+```
+
+This will print a message similar to the following (scroll up in the yarn output to see it):
+
+> warning "react-native@0.52.2" has unmet peer dependency "react@16.2.0".
+
+This is OK, it means we also need to install React:
+
+```shell
+$ yarn add react@version_printed_above
+```
+
+Yarn has created a new `/node_modules` folder. This folder stores all the JavaScript dependencies required to build your project.
+
+Add `node_modules/` to your `.gitignore` file.
+
+## Adding React Native to your app
+
+### Configuring maven
+
+Add the React Native and JSC dependency to your app's `build.gradle` file:
+
+```gradle
+dependencies {
+ implementation "com.android.support:appcompat-v7:27.1.1"
+ ...
+ implementation "com.facebook.react:react-native:+" // From node_modules
+ implementation "org.webkit:android-jsc:+"
+}
+```
+
+> If you want to ensure that you are always using a specific React Native version in your native build, replace `+` with an actual React Native version you've downloaded from `npm`.
+
+Add an entry for the local React Native and JSC maven directories to the top-level `settings.gradle`. Be sure to add it to the “dependencyResolutionManagement” block, above other maven repositories:
+
+```gradle
+dependencyResolutionManagement {
+ ...
+ repositories {
+ ...
+ maven {
+ url "$rootDir/../node_modules/react-native/android"
+ }
+ maven {
+ url("$rootDir/../node_modules/jsc-android/dist")
+ }
+ }
+}
+```
+
+> If your project has the dependency repositories configured in the top-level `build.gradle`, be sure to add the entries to the “allprojects” block above other maven repositories:
+
+```gradle
+allprojects {
+ repositories {
+ maven {
+ // All of React Native (JS, Android binaries) is installed from npm
+ url "$rootDir/../node_modules/react-native/android"
+ }
+ maven {
+ // Android JSC is installed from npm
+ url("$rootDir/../node_modules/jsc-android/dist")
+ }
+ ...
+ }
+ ...
+}
+```
+
+> Make sure that the path is correct! You shouldn’t run into any “Failed to resolve: com.facebook.react:react-native:0.x.x" errors after running Gradle sync in Android Studio.
+
+### Enable native modules autolinking
+
+To use the power of [autolinking](https://github.com/react-native-community/cli/blob/master/docs/autolinking.md), we have to apply it a few places. First add the following entry to `settings.gradle`:
+
+```gradle
+apply from: file("../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesSettingsGradle(settings)
+```
+
+Next add the following entry at the very bottom of the `app/build.gradle`:
+
+```gradle
+apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)
+```
+
+### Configuring permissions
+
+Next, make sure you have the Internet permission in your `AndroidManifest.xml`:
+
+
+
+If you need to access to the `DevSettingsActivity` add to your `AndroidManifest.xml`:
+
+
+
+This is only used in dev mode when reloading JavaScript from the development server, so you can strip this in release builds if you need to.
+
+### Cleartext Traffic (API level 28+)
+
+> Starting with Android 9 (API level 28), cleartext traffic is disabled by default; this prevents your application from connecting to the [Metro bundler][metro]. The changes below allow cleartext traffic in debug builds.
+
+#### 1. Apply the `usesCleartextTraffic` option to your Debug `AndroidManifest.xml`
+
+```xml
+
+
+
+
+
+```
+
+This is not required for Release builds.
+
+To learn more about Network Security Config and the cleartext traffic policy [see this link](https://developer.android.com/training/articles/security-config#CleartextTrafficPermitted).
+
+### Code integration
+
+Now we will actually modify the native Android application to integrate React Native.
+
+#### The React Native component
+
+The first bit of code we will write is the actual React Native code for the new "High Score" screen that will be integrated into our application.
+
+##### 1. Create a `index.js` file
+
+First, create an empty `index.js` file in the root of your React Native project.
+
+`index.js` is the starting point for React Native applications, and it is always required. It can be a small file that `require`s other file that are part of your React Native component or application, or it can contain all the code that is needed for it. In our case, we will put everything in `index.js`.
+
+##### 2. Add your React Native code
+
+In your `index.js`, create your component. In our sample here, we will add a `` component within a styled ``:
+
+```jsx
+import React from 'react';
+import {
+ AppRegistry,
+ StyleSheet,
+ Text,
+ View
+} from 'react-native';
+
+const HelloWorld = () => {
+ return (
+
+ Hello, World
+
+ );
+};
+var styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center'
+ },
+ hello: {
+ fontSize: 20,
+ textAlign: 'center',
+ margin: 10
+ }
+});
+
+AppRegistry.registerComponent(
+ 'MyReactNativeApp',
+ () => HelloWorld
+);
+```
+
+##### 3. Configure permissions for development error overlay
+
+If your app is targeting the Android `API level 23` or greater, make sure you have the permission `android.permission.SYSTEM_ALERT_WINDOW` enabled for the development build. You can check this with `Settings.canDrawOverlays(this)`. This is required in dev builds because React Native development errors must be displayed above all the other windows. Due to the new permissions system introduced in the API level 23 (Android M), the user needs to approve it. This can be achieved by adding the following code to your Activity's in `onCreate()` method.
+
+```kotlin
+companion object {
+ const val OVERLAY_PERMISSION_REQ_CODE = 1 // Choose any value
+}
+
+...
+
+if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if(!Settings.canDrawOverlays(this)) {
+ val intent = Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+ Uri.parse("package: $packageName"))
+ startActivityForResult(intent, OVERLAY_PERMISSION_REQ_CODE);
+ }
+}
+```
+
+Finally, the `onActivityResult()` method (as shown in the code below) has to be overridden to handle the permission Accepted or Denied cases for consistent UX. Also, for integrating Native Modules which use `startActivityForResult`, we need to pass the result to the `onActivityResult` method of our `ReactInstanceManager` instance.
+
+```kotlin
+override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+ if (requestCode == OVERLAY_PERMISSION_REQ_CODE) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if (!Settings.canDrawOverlays(this)) {
+ // SYSTEM_ALERT_WINDOW permission not granted
+ }
+ }
+ }
+ reactInstanceManager?.onActivityResult(this, requestCode, resultCode, data)
+}
+```
+
+#### The Magic: `ReactRootView`
+
+Let's add some native code in order to start the React Native runtime and tell it to render our JS component. To do this, we're going to create an `Activity` that creates a `ReactRootView`, starts a React application inside it and sets it as the main content view.
+
+> If you are targeting Android version <5, use the `AppCompatActivity` class from the `com.android.support:appcompat` package instead of `Activity`.
+
+```kotlin
+class MyReactActivity : Activity(), DefaultHardwareBackBtnHandler {
+ private lateinit var reactRootView: ReactRootView
+ private lateinit var reactInstanceManager: ReactInstanceManager
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ SoLoader.init(this, false)
+ reactRootView = ReactRootView(this)
+ val packages: List = PackageList(application).packages
+ // Packages that cannot be autolinked yet can be added manually here, for example:
+ // packages.add(MyReactNativePackage())
+ // Remember to include them in `settings.gradle` and `app/build.gradle` too.
+ reactInstanceManager = ReactInstanceManager.builder()
+ .setApplication(application)
+ .setCurrentActivity(this)
+ .setBundleAssetName("index.android.bundle")
+ .setJSMainModulePath("index")
+ .addPackages(packages)
+ .setUseDeveloperSupport(BuildConfig.DEBUG)
+ .setInitialLifecycleState(LifecycleState.RESUMED)
+ .build()
+ // The string here (e.g. "MyReactNativeApp") has to match
+ // the string in AppRegistry.registerComponent() in index.js
+ reactRootView?.startReactApplication(reactInstanceManager, "MyReactNativeApp", null)
+ setContentView(reactRootView)
+ }
+
+ override fun invokeDefaultOnBackPressed() {
+ super.onBackPressed()
+ }
+}
+```
+
+> If you are using a starter kit for React Native, replace the "HelloWorld" string with the one in your index.js file (it’s the first argument to the `AppRegistry.registerComponent()` method).
+
+Perform a “Sync Project files with Gradle” operation.
+
+If you are using Android Studio, use `Alt + Enter` to add all missing imports in your MyReactActivity class. Be careful to use your package’s `BuildConfig` and not the one from the `facebook` package.
+
+We need set the theme of `MyReactActivity` to `Theme.AppCompat.Light.NoActionBar` because some React Native UI components rely on this theme.
+
+```xml
+
+
+```
+
+> A `ReactInstanceManager` can be shared by multiple activities and/or fragments. You will want to make your own `ReactFragment` or `ReactActivity` and have a singleton _holder_ that holds a `ReactInstanceManager`. When you need the `ReactInstanceManager` (e.g., to hook up the `ReactInstanceManager` to the lifecycle of those Activities or Fragments) use the one provided by the singleton.
+
+Next, we need to pass some activity lifecycle callbacks to the `ReactInstanceManager` and `ReactRootView`:
+
+```kotlin
+override fun onPause() {
+ super.onPause()
+ reactInstanceManager.onHostPause(this)
+}
+
+override fun onResume() {
+ super.onResume()
+ reactInstanceManager.onHostResume(this, this)
+}
+
+override fun onDestroy() {
+ super.onDestroy()
+ reactInstanceManager.onHostDestroy(this)
+ reactRootView.unmountReactApplication()
+}
+```
+
+We also need to pass back button events to React Native:
+
+```kotlin
+override fun onBackPressed() {
+ reactInstanceManager.onBackPressed()
+ super.onBackPressed()
+}
+```
+
+This allows JavaScript to control what happens when the user presses the hardware back button (e.g. to implement navigation). When JavaScript doesn't handle the back button press, your `invokeDefaultOnBackPressed` method will be called. By default this finishes your `Activity`.
+
+Finally, we need to hook up the dev menu. By default, this is activated by (rage) shaking the device, but this is not very useful in emulators. So we make it show when you press the hardware menu button (use `Ctrl + M` if you're using Android Studio emulator):
+
+```kotlin
+override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+ if (keyCode == KeyEvent.KEYCODE_MENU && reactInstanceManager != null) {
+ reactInstanceManager.showDevOptionsDialog()
+ return true
+ }
+ return super.onKeyUp(keyCode, event)
+}
+```
+
+Now your activity is ready to run some JavaScript code.
+
+### Test your integration
+
+You have now done all the basic steps to integrate React Native with your current application. Now we will start the [Metro bundler][metro] to build the `index.bundle` package and the server running on localhost to serve it.
+
+##### 1. Run the packager
+
+To run your app, you need to first start the development server. To do this, run the following command in the root directory of your React Native project:
+
+```shell
+$ yarn start
+```
+
+##### 2. Run the app
+
+Now build and run your Android app as normal.
+
+Once you reach your React-powered activity inside the app, it should load the JavaScript code from the development server and display:
+
+
+
+### Creating a release build in Android Studio
+
+You can use Android Studio to create your release builds too! It’s as quick as creating release builds of your previously-existing native Android app. There’s one additional step, which you’ll have to do before every release build. You need to execute the following to create a React Native bundle, which will be included with your native Android app:
+
+```shell
+$ npx react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/com/your-company-name/app-package-name/src/main/assets/index.android.bundle --assets-dest android/com/your-company-name/app-package-name/src/main/res/
+```
+
+> Don’t forget to replace the paths with correct ones and create the assets folder if it doesn’t exist.
+
+Now, create a release build of your native app from within Android Studio as usual and you should be good to go!
+
+### Now what?
+
+At this point you can continue developing your app as usual. Refer to our [debugging](debugging) and [deployment](running-on-device) docs to learn more about working with React Native.
+
+[metro]: https://facebook.github.io/metro/
diff --git a/website/versioned_docs/version-0.70/_markdown-m1-cocoapods.mdx b/website/versioned_docs/version-0.70/_markdown-m1-cocoapods.mdx
new file mode 100644
index 00000000000..41161b15791
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_markdown-m1-cocoapods.mdx
@@ -0,0 +1,11 @@
+
+ Note for Mac M1 users
+
+Mac M1 architecture is not directly compatible with Cocoapods. If you encounter issues when installing pods, you can solve it by running:
+
+- `sudo arch -x86_64 gem install ffi`
+- `arch -x86_64 pod install`
+
+These commands install the `ffi` package, to load dynamically-linked libraries and let you run the `pod install` properly, and runs `pod install` with the proper architecture.
+
+
diff --git a/website/versioned_docs/version-0.70/_markdown-new-architecture-warning.mdx b/website/versioned_docs/version-0.70/_markdown-new-architecture-warning.mdx
new file mode 100644
index 00000000000..d52c490153b
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_markdown-new-architecture-warning.mdx
@@ -0,0 +1,7 @@
+:::caution
+
+This documentation is still **experimental** and details are subject to changes as we iterate. Feel free to share your feedback on the [discussion inside the working group](https://github.com/reactwg/react-native-new-architecture/discussions/8) for this page.
+
+Moreover, it contains several **manual steps**. Please note that this won't be representative of the final developer experience once the New Architecture is stable. We're working on tools, templates and libraries to help you get started fast on the New Architecture, without having to go through the whole setup.
+
+:::
diff --git a/website/versioned_docs/version-0.70/_remove-global-cli.md b/website/versioned_docs/version-0.70/_remove-global-cli.md
new file mode 100644
index 00000000000..08d0d9ba3c1
--- /dev/null
+++ b/website/versioned_docs/version-0.70/_remove-global-cli.md
@@ -0,0 +1,5 @@
+> If you previously installed a global `react-native-cli` package, please remove it as it may cause unexpected issues:
+>
+> ```shell
+> npm uninstall -g react-native-cli @react-native-community/cli
+> ```
diff --git a/website/versioned_docs/version-0.70/accessibility.md b/website/versioned_docs/version-0.70/accessibility.md
new file mode 100644
index 00000000000..17f444c3552
--- /dev/null
+++ b/website/versioned_docs/version-0.70/accessibility.md
@@ -0,0 +1,345 @@
+---
+id: accessibility
+title: Accessibility
+description: Create mobile apps accessible to assistive technology with React Native's suite of APIs designed to work with Android and iOS.
+---
+
+Both Android and iOS provide APIs for integrating apps with assistive technologies like the bundled screen readers VoiceOver (iOS) and TalkBack (Android). React Native has complementary APIs that let your app accommodate all users.
+
+:::info
+Android and iOS differ slightly in their approaches, and thus the React Native implementations may vary by platform.
+:::
+
+## Accessibility properties
+
+### `accessible`
+
+When `true`, indicates that the view is an accessibility element. When a view is an accessibility element, it groups its children into a single selectable component. By default, all touchable elements are accessible.
+
+On Android, `accessible={true}` property for a react-native View will be translated into native `focusable={true}`.
+
+```jsx
+
+ text one
+ text two
+
+```
+
+In the above example, we can't get accessibility focus separately on 'text one' and 'text two'. Instead we get focus on a parent view with 'accessible' property.
+
+### `accessibilityLabel`
+
+When a view is marked as accessible, it is a good practice to set an accessibilityLabel on the view, so that people who use VoiceOver know what element they have selected. VoiceOver will read this string when a user selects the associated element.
+
+To use, set the `accessibilityLabel` property to a custom string on your View, Text or Touchable:
+
+```jsx
+
+
+ Press me!
+
+
+```
+
+In the above example, the `accessibilityLabel` on the TouchableOpacity element would default to "Press me!". The label is constructed by concatenating all Text node children separated by spaces.
+
+### `accessibilityLabelledBy`
Android
+
+A reference to another element [nativeID](view.md#nativeid) used to build complex forms.
+The value of `accessibilityLabelledBy` should match the `nativeID` of the related element:
+
+```jsx
+
+ Label for Input Field
+
+
+```
+
+In the above example, the screenreader announces `Input, Edit Box for Label for Input Field` when focusing on the TextInput.
+
+### `accessibilityHint`
+
+An accessibility hint helps users understand what will happen when they perform an action on the accessibility element when that result is not clear from the accessibility label.
+
+To use, set the `accessibilityHint` property to a custom string on your View, Text or Touchable:
+
+```jsx
+
+
+ Back
+
+
+```
+
+
iOS
+
+In the above example, VoiceOver will read the hint after the label, if the user has hints enabled in the device's VoiceOver settings. Read more about guidelines for `accessibilityHint` in the [iOS Developer Docs](https://developer.apple.com/documentation/objectivec/nsobject/1615093-accessibilityhint)
+
+
Android
+
+In the above example, TalkBack will read the hint after the label. At this time, hints cannot be turned off on Android.
+
+### `accessibilityLanguage`
iOS
+
+By using the `accessibilityLanguage` property, the screen reader will understand which language to use while reading the element's **label**, **value** and **hint**. The provided string value must follow the [BCP 47 specification](https://www.rfc-editor.org/info/bcp47).
+
+```jsx
+
+ 🍕
+
+```
+
+### `accessibilityIgnoresInvertColors`
iOS
+
+Inverting screen colors is an Accessibility feature that makes the iPhone and iPad easier on the eyes for some people with a sensitivity to brightness, easier to distinguish for some people with color blindness, and easier to make out for some people with low vision. However, sometimes you have views such as photos that you don't want to be inverted. In this case, you can set this property to be `true` so that these specific views won't have their colors inverted.
+
+### `accessibilityLiveRegion`
Android
+
+When components dynamically change, we want TalkBack to alert the end user. This is made possible by the `accessibilityLiveRegion` property. It can be set to `none`, `polite` and `assertive`:
+
+- **none** Accessibility services should not announce changes to this view.
+- **polite** Accessibility services should announce changes to this view.
+- **assertive** Accessibility services should interrupt ongoing speech to immediately announce changes to this view.
+
+```jsx
+
+
+ Click me
+
+
+
+ Clicked {count} times
+
+```
+
+In the above example method `addOne` changes the state variable `count`. As soon as an end user clicks the TouchableWithoutFeedback, TalkBack reads text in the Text view because of its `accessibilityLiveRegion="polite"` property.
+
+### `accessibilityRole`
+
+`accessibilityRole` communicates the purpose of a component to the user of an assistive technology.
+
+`accessibilityRole` can be one of the following:
+
+- **adjustable** Used when an element can be "adjusted" (e.g. a slider).
+- **alert** Used when an element contains important text to be presented to the user.
+- **button** Used when the element should be treated as a button.
+- **checkbox** Used when an element represents a checkbox which can be checked, unchecked, or have mixed checked state.
+- **combobox** Used when an element represents a combo box, which allows the user to select among several choices.
+- **header** Used when an element acts as a header for a content section (e.g. the title of a navigation bar).
+- **image** Used when the element should be treated as an image. Can be combined with button or link, for example.
+- **imagebutton** Used when the element should be treated as a button and is also an image.
+- **keyboardkey** Used when the element acts as a keyboard key.
+- **link** Used when the element should be treated as a link.
+- **menu** Used when the component is a menu of choices.
+- **menubar** Used when a component is a container of multiple menus.
+- **menuitem** Used to represent an item within a menu.
+- **none** Used when the element has no role.
+- **progressbar** Used to represent a component which indicates progress of a task.
+- **radio** Used to represent a radio button.
+- **radiogroup** Used to represent a group of radio buttons.
+- **scrollbar** Used to represent a scroll bar.
+- **search** Used when the text field element should also be treated as a search field.
+- **spinbutton** Used to represent a button which opens a list of choices.
+- **summary** Used when an element can be used to provide a quick summary of current conditions in the app when the app first launches.
+- **switch** Used to represent a switch which can be turned on and off.
+- **tab** Used to represent a tab.
+- **tablist** Used to represent a list of tabs.
+- **text** Used when the element should be treated as static text that cannot change.
+- **timer** Used to represent a timer.
+- **togglebutton** Used to represent a toggle button. Should be used with accessibilityState checked to indicate if the button is toggled on or off.
+- **toolbar** Used to represent a tool bar (a container of action buttons or components).
+
+### `accessibilityState`
+
+Describes the current state of a component to the user of an assistive technology.
+
+`accessibilityState` is an object. It contains the following fields:
+
+| Name | Description | Type | Required |
+| -------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | -------- |
+| disabled | Indicates whether the element is disabled or not. | boolean | No |
+| selected | Indicates whether a selectable element is currently selected or not. | boolean | No |
+| checked | Indicates the state of a checkable element. This field can either take a boolean or the "mixed" string to represent mixed checkboxes. | boolean or 'mixed' | No |
+| busy | Indicates whether an element is currently busy or not. | boolean | No |
+| expanded | Indicates whether an expandable element is currently expanded or collapsed. | boolean | No |
+
+To use, set the `accessibilityState` to an object with a specific definition.
+
+### `accessibilityValue`
+
+Represents the current value of a component. It can be a textual description of a component's value, or for range-based components, such as sliders and progress bars, it contains range information (minimum, current, and maximum).
+
+`accessibilityValue` is an object. It contains the following fields:
+
+| Name | Description | Type | Required |
+| ---- | ---------------------------------------------------------------------------------------------- | ------- | ------------------------- |
+| min | The minimum value of this component's range. | integer | Required if `now` is set. |
+| max | The maximum value of this component's range. | integer | Required if `now` is set. |
+| now | The current value of this component's range. | integer | No |
+| text | A textual description of this component's value. Will override `min`, `now`, and `max` if set. | string | No |
+
+### `accessibilityViewIsModal`
iOS
+
+A Boolean value indicating whether VoiceOver should ignore the elements within views that are siblings of the receiver.
+
+For example, in a window that contains sibling views `A` and `B`, setting `accessibilityViewIsModal` to `true` on view `B` causes VoiceOver to ignore the elements in the view `A`. On the other hand, if view `B` contains a child view `C` and you set `accessibilityViewIsModal` to `true` on view `C`, VoiceOver does not ignore the elements in view `A`.
+
+### `accessibilityElementsHidden`
iOS
+
+A Boolean value indicating whether the accessibility elements contained within this accessibility element are hidden.
+
+For example, in a window that contains sibling views `A` and `B`, setting `accessibilityElementsHidden` to `true` on view `B` causes VoiceOver to ignore the elements in the view `B`. This is similar to the Android property `importantForAccessibility="no-hide-descendants"`.
+
+### `importantForAccessibility`
Android
+
+In the case of two overlapping UI components with the same parent, default accessibility focus can have unpredictable behavior. The `importantForAccessibility` property will resolve this by controlling if a view fires accessibility events and if it is reported to accessibility services. It can be set to `auto`, `yes`, `no` and `no-hide-descendants` (the last value will force accessibility services to ignore the component and all of its children).
+
+```jsx
+
+
+ First layout
+
+
+ Second layout
+
+
+```
+
+In the above example, the `yellow` layout and its descendants are completely invisible to TalkBack and all other accessibility services. So we can use overlapping views with the same parent without confusing TalkBack.
+
+### `onAccessibilityEscape`
iOS
+
+Assign this property to a custom function which will be called when someone performs the "escape" gesture, which is a two finger Z shaped gesture. An escape function should move back hierarchically in the user interface. This can mean moving up or back in a navigation hierarchy or dismissing a modal user interface. If the selected element does not have an `onAccessibilityEscape` function, the system will attempt to traverse up the view hierarchy until it finds a view that does or bonk to indicate it was unable to find one.
+
+### `onAccessibilityTap`
+
+Use this property to assign a custom function to be called when someone activates an accessible element by double tapping on it while it's selected.
+
+### `onMagicTap`
iOS
+
+Assign this property to a custom function which will be called when someone performs the "magic tap" gesture, which is a double-tap with two fingers. A magic tap function should perform the most relevant action a user could take on a component. In the Phone app on iPhone, a magic tap answers a phone call, or ends the current one. If the selected element does not have an `onMagicTap` function, the system will traverse up the view hierarchy until it finds a view that does.
+
+## Accessibility Actions
+
+Accessibility actions allow an assistive technology to programmatically invoke the actions of a component. In order to support accessibility actions, a component must do two things:
+
+- Define the list of actions it supports via the `accessibilityActions` property.
+- Implement an `onAccessibilityAction` function to handle action requests.
+
+The `accessibilityActions` property should contain a list of action objects. Each action object should contain the following fields:
+
+| Name | Type | Required |
+| ----- | ------ | -------- |
+| name | string | Yes |
+| label | string | No |
+
+Actions either represent standard actions, such as clicking a button or adjusting a slider, or custom actions specific to a given component such as deleting an email message. The `name` field is required for both standard and custom actions, but `label` is optional for standard actions.
+
+When adding support for standard actions, `name` must be one of the following:
+
+- `'magicTap'` - iOS only - While VoiceOver focus is on or inside the component, the user double tapped with two fingers.
+- `'escape'` - iOS only - While VoiceOver focus is on or inside the component, the user performed a two finger scrub gesture (left, right, left).
+- `'activate'` - Activate the component. Typically this should perform the same action as when the user touches or clicks the component when not using an assistive technology. This is generated when a screen reader user double taps the component.
+- `'increment'` - Increment an adjustable component. On iOS, VoiceOver generates this action when the component has a role of `'adjustable'` and the user places focus on it and swipes upward. On Android, TalkBack generates this action when the user places accessibility focus on the component and presses the volume up button.
+- `'decrement'` - Decrement an adjustable component. On iOS, VoiceOver generates this action when the component has a role of `'adjustable'` and the user places focus on it and swipes downward. On Android, TalkBack generates this action when the user places accessibility focus on the component and presses the volume down button.
+- `'longpress'` - Android only - This action is generated when the user places accessibility focus on the component and double tap and holds one finger on the screen. Typically, this should perform the same action as when the user holds down one finger on the component while not using an assistive technology.
+
+The `label` field is optional for standard actions, and is often unused by assistive technologies. For custom actions, it is a localized string containing a description of the action to be presented to the user.
+
+To handle action requests, a component must implement an `onAccessibilityAction` function. The only argument to this function is an event containing the name of the action to perform. The below example from RNTester shows how to create a component which defines and handles several custom actions.
+
+```jsx
+ {
+ switch (event.nativeEvent.actionName) {
+ case 'cut':
+ Alert.alert('Alert', 'cut action success');
+ break;
+ case 'copy':
+ Alert.alert('Alert', 'copy action success');
+ break;
+ case 'paste':
+ Alert.alert('Alert', 'paste action success');
+ break;
+ }
+ }}
+/>
+```
+
+## Checking if a Screen Reader is Enabled
+
+The `AccessibilityInfo` API allows you to determine whether or not a screen reader is currently active. See the [AccessibilityInfo documentation](accessibilityinfo) for details.
+
+## Sending Accessibility Events
Android
+
+Sometimes it is useful to trigger an accessibility event on a UI component (i.e. when a custom view appears on a screen or set accessibility focus to a view). Native UIManager module exposes a method ‘sendAccessibilityEvent’ for this purpose. It takes two arguments: view tag and a type of an event. The supported event types are `typeWindowStateChanged`, `typeViewFocused` and `typeViewClicked`.
+
+```jsx
+import {
+ Platform,
+ UIManager,
+ findNodeHandle
+} from 'react-native';
+
+if (Platform.OS === 'android') {
+ UIManager.sendAccessibilityEvent(
+ findNodeHandle(this),
+ UIManager.AccessibilityEventTypes.typeViewFocused
+ );
+}
+```
+
+## Testing TalkBack Support
Android
+
+To enable TalkBack, go to the Settings app on your Android device or emulator. Tap Accessibility, then TalkBack. Toggle the "Use service" switch to enable or disable it.
+
+Android emulators don't have TalkBack installed by default. You can install TalkBack on your emulator via the Google Play Store. Make sure to choose an emulator with the Google Play store installed. These are available in Android Studio.
+
+You can use the volume key shortcut to toggle TalkBack. To turn on the volume key shortcut, go to the Settings app, then Accessibility. At the top, turn on Volume key shortcut.
+
+To use the volume key shortcut, press both volume keys for 3 seconds to start an accessibility tool.
+
+Additionally, if you prefer, you can toggle TalkBack via command line with:
+
+```shell
+# disable
+adb shell settings put secure enabled_accessibility_services com.android.talkback/com.google.android.marvin.talkback.TalkBackService
+
+# enable
+adb shell settings put secure enabled_accessibility_services com.google.android.marvin.talkback/com.google.android.marvin.talkback.TalkBackService
+```
+
+## Testing VoiceOver Support
iOS
+
+To enable VoiceOver, go to the Settings app on your iOS device (it's not available for simulator). Tap General, then Accessibility. There you will find many tools that people use to make their devices more usable, such as bolder text, increased contrast, and VoiceOver.
+
+To enable VoiceOver, tap on VoiceOver under "Vision" and toggle the switch that appears at the top.
+
+At the very bottom of the Accessibility settings, there is an "Accessibility Shortcut". You can use this to toggle VoiceOver by triple clicking the Home button.
+
+## Additional Resources
+
+- [Making React Native Apps Accessible](https://engineering.fb.com/ios/making-react-native-apps-accessible/)
diff --git a/website/versioned_docs/version-0.70/accessibilityinfo.md b/website/versioned_docs/version-0.70/accessibilityinfo.md
new file mode 100644
index 00000000000..3d0555520b1
--- /dev/null
+++ b/website/versioned_docs/version-0.70/accessibilityinfo.md
@@ -0,0 +1,316 @@
+---
+id: accessibilityinfo
+title: AccessibilityInfo
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+Sometimes it's useful to know whether or not the device has a screen reader that is currently active. The `AccessibilityInfo` API is designed for this purpose. You can use it to query the current state of the screen reader as well as to register to be notified when the state of the screen reader changes.
+
+## Example
+
+
+
+
+```SnackPlayer name=AccessibilityInfo%20Function%20Component%20Example&supportedPlatforms=android,ios
+import React, { useState, useEffect } from "react";
+import { AccessibilityInfo, View, Text, StyleSheet } from "react-native";
+
+const App = () => {
+ const [reduceMotionEnabled, setReduceMotionEnabled] = useState(false);
+ const [screenReaderEnabled, setScreenReaderEnabled] = useState(false);
+
+ useEffect(() => {
+ const reduceMotionChangedSubscription = AccessibilityInfo.addEventListener(
+ "reduceMotionChanged",
+ reduceMotionEnabled => {
+ setReduceMotionEnabled(reduceMotionEnabled);
+ }
+ );
+ const screenReaderChangedSubscription = AccessibilityInfo.addEventListener(
+ "screenReaderChanged",
+ screenReaderEnabled => {
+ setScreenReaderEnabled(screenReaderEnabled);
+ }
+ );
+
+ AccessibilityInfo.isReduceMotionEnabled().then(
+ reduceMotionEnabled => {
+ setReduceMotionEnabled(reduceMotionEnabled);
+ }
+ );
+ AccessibilityInfo.isScreenReaderEnabled().then(
+ screenReaderEnabled => {
+ setScreenReaderEnabled(screenReaderEnabled);
+ }
+ );
+
+ return () => {
+ reduceMotionChangedSubscription.remove();
+ screenReaderChangedSubscription.remove();
+ };
+ }, []);
+
+ return (
+
+
+ The reduce motion is {reduceMotionEnabled ? "enabled" : "disabled"}.
+
+
+ The screen reader is {screenReaderEnabled ? "enabled" : "disabled"}.
+
+
+ );
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ status: {
+ margin: 30
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=AccessibilityInfo%20Class%20Component%20Example&supportedPlatforms=android,ios
+import React, { Component } from 'react';
+import { AccessibilityInfo, View, Text, StyleSheet } from 'react-native';
+
+class AccessibilityStatusExample extends Component {
+ state = {
+ reduceMotionEnabled: false,
+ screenReaderEnabled: false,
+ };
+
+ componentDidMount() {
+ this.reduceMotionChangedSubscription = AccessibilityInfo.addEventListener(
+ 'reduceMotionChanged',
+ reduceMotionEnabled => {
+ this.setState({ reduceMotionEnabled });
+ }
+ );
+ this.screenReaderChangedSubscription = AccessibilityInfo.addEventListener(
+ 'screenReaderChanged',
+ screenReaderEnabled => {
+ this.setState({ screenReaderEnabled });
+ }
+ );
+
+ AccessibilityInfo.isReduceMotionEnabled().then(reduceMotionEnabled => {
+ this.setState({ reduceMotionEnabled });
+ });
+ AccessibilityInfo.isScreenReaderEnabled().then(screenReaderEnabled => {
+ this.setState({ screenReaderEnabled });
+ });
+ }
+
+ componentWillUnmount() {
+ this.reduceMotionChangedSubscription.remove();
+ this.screenReaderChangedSubscription.remove();
+ }
+
+ render() {
+ return (
+
+
+ The reduce motion is{' '}
+ {this.state.reduceMotionEnabled ? 'enabled' : 'disabled'}.
+
+
+ The screen reader is{' '}
+ {this.state.screenReaderEnabled ? 'enabled' : 'disabled'}.
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: 'center',
+ justifyContent: 'center',
+ },
+ status: {
+ margin: 30,
+ },
+});
+
+export default AccessibilityStatusExample;
+```
+
+
+
+
+---
+
+# Reference
+
+## Methods
+
+### `addEventListener()`
+
+```jsx
+static addEventListener(eventName, handler)
+```
+
+Add an event handler. Supported events:
+
+| Event name | Description |
+| ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `accessibilityServiceChanged`
Android
| Fires when some services such as TalkBack, other Android assistive technologies, and third-party accessibility services are enabled. The argument to the event handler is a boolean. The boolean is `true` when a some accessibility services is enabled and `false` otherwise. |
+| `announcementFinished`
iOS
| Fires when the screen reader has finished making an announcement. The argument to the event handler is a dictionary with these keys:
`announcement`: The string announced by the screen reader.
`success`: A boolean indicating whether the announcement was successfully made.
|
+| `boldTextChanged`
iOS
| Fires when the state of the bold text toggle changes. The argument to the event handler is a boolean. The boolean is `true` when bold text is enabled and `false` otherwise. |
+| `grayscaleChanged`
iOS
| Fires when the state of the gray scale toggle changes. The argument to the event handler is a boolean. The boolean is `true` when a gray scale is enabled and `false` otherwise. |
+| `invertColorsChanged`
iOS
| Fires when the state of the invert colors toggle changes. The argument to the event handler is a boolean. The boolean is `true` when invert colors is enabled and `false` otherwise. |
+| `reduceMotionChanged` | Fires when the state of the reduce motion toggle changes. The argument to the event handler is a boolean. The boolean is `true` when a reduce motion is enabled (or when "Transition Animation Scale" in "Developer options" is "Animation off") and `false` otherwise. |
+| `reduceTransparencyChanged`
iOS
| Fires when the state of the reduce transparency toggle changes. The argument to the event handler is a boolean. The boolean is `true` when reduce transparency is enabled and `false` otherwise. |
+| `screenReaderChanged` | Fires when the state of the screen reader changes. The argument to the event handler is a boolean. The boolean is `true` when a screen reader is enabled and `false` otherwise. |
+
+---
+
+### `announceForAccessibility()`
+
+```jsx
+static announceForAccessibility(announcement)
+```
+
+Post a string to be announced by the screen reader.
+
+---
+
+### `announceForAccessibilityWithOptions()`
+
+```jsx
+static announceForAccessibilityWithOptions(announcement, options)
+```
+
+Post a string to be announced by the screen reader with modification options. By default announcements will interrupt any existing speech, but on iOS they can be queued behind existing speech by setting `queue` to `true` in the options object.
+
+**Parameters:**
+
+| Name | Type | Description |
+| ------------------------------------------------------------- | ------ | ---------------------------------------------------------------------------------------- |
+| announcement
Required
| string | The string to be announced |
+| options
+
+```jsx
+static getRecommendedTimeoutMillis(originalTimeout)
+```
+
+Gets the timeout in millisecond that the user needs.
+This value is set in "Time to take action (Accessibility timeout)" of "Accessibility" settings.
+
+**Parameters:**
+
+| Name | Type | Description |
+| ---------------------------------------------------------------- | ------ | ------------------------------------------------------------------------------------- |
+| originalTimeout
Required
| number | The timeout to return if "Accessibility timeout" is not set. Specify in milliseconds. |
+
+---
+
+### `isAccessibilityServiceEnabled()`
Android
+
+```jsx
+static isAccessibilityServiceEnabled(): Promise
+```
+
+Check whether any accessibility service is enabled. This includes TalkBack but also any third-party accessibility app that may be installed. To only check whether TalkBack is enabled, use [isScreenReaderEnabled](#isscreenreaderenabled). Returns a promise which resolves to a boolean. The result is `true` when some accessibility services is enabled and `false` otherwise.
+
+> **Note**: Please use [isScreenReaderEnabled](#isscreenreaderenabled) if you only want to check the status of TalkBack.
+
+---
+
+### `isBoldTextEnabled()`
iOS
+
+```jsx
+static isBoldTextEnabled()
+```
+
+Query whether a bold text is currently enabled. Returns a promise which resolves to a boolean. The result is `true` when bold text is enabled and `false` otherwise.
+
+---
+
+### `isGrayscaleEnabled()`
iOS
+
+```jsx
+static isGrayscaleEnabled()
+```
+
+Query whether grayscale is currently enabled. Returns a promise which resolves to a boolean. The result is `true` when grayscale is enabled and `false` otherwise.
+
+---
+
+### `isInvertColorsEnabled()`
iOS
+
+```jsx
+static isInvertColorsEnabled()
+```
+
+Query whether invert colors is currently enabled. Returns a promise which resolves to a boolean. The result is `true` when invert colors is enabled and `false` otherwise.
+
+---
+
+### `isReduceMotionEnabled()`
+
+```jsx
+static isReduceMotionEnabled()
+```
+
+Query whether reduce motion is currently enabled. Returns a promise which resolves to a boolean. The result is `true` when reduce motion is enabled and `false` otherwise.
+
+---
+
+### `isReduceTransparencyEnabled()`
iOS
+
+```jsx
+static isReduceTransparencyEnabled()
+```
+
+Query whether reduce transparency is currently enabled. Returns a promise which resolves to a boolean. The result is `true` when a reduce transparency is enabled and `false` otherwise.
+
+---
+
+### `isScreenReaderEnabled()`
+
+```jsx
+static isScreenReaderEnabled()
+```
+
+Query whether a screen reader is currently enabled. Returns a promise which resolves to a boolean. The result is `true` when a screen reader is enabled and `false` otherwise.
+
+---
+
+### `removeEventListener()`
+
+```jsx
+static removeEventListener(eventName, handler)
+```
+
+> **Deprecated.** Use the `remove()` method on the event subscription returned by [`addEventListener()`](#addeventlistener).
+
+---
+
+### `setAccessibilityFocus()`
+
+```jsx
+static setAccessibilityFocus(reactTag)
+```
+
+Set accessibility focus to a React component.
+
+On Android, this calls `UIManager.sendAccessibilityEvent` method with passed `reactTag` and `UIManager.AccessibilityEventTypes.typeViewFocused` arguments.
+
+> **Note**: Make sure that any `View` you want to receive the accessibility focus has `accessible={true}`.
diff --git a/website/versioned_docs/version-0.70/actionsheetios.md b/website/versioned_docs/version-0.70/actionsheetios.md
new file mode 100644
index 00000000000..a56f4629f9e
--- /dev/null
+++ b/website/versioned_docs/version-0.70/actionsheetios.md
@@ -0,0 +1,132 @@
+---
+id: actionsheetios
+title: ActionSheetIOS
+---
+
+Displays native to iOS [Action Sheet](https://developer.apple.com/design/human-interface-guidelines/ios/views/action-sheets/) component.
+
+## Example
+
+```SnackPlayer name=ActionSheetIOS&supportedPlatforms=ios
+import React, { useState } from "react";
+import { ActionSheetIOS, Button, StyleSheet, Text, View } from "react-native";
+
+const App = () => {
+ const [result, setResult] = useState("🔮");
+
+ const onPress = () =>
+ ActionSheetIOS.showActionSheetWithOptions(
+ {
+ options: ["Cancel", "Generate number", "Reset"],
+ destructiveButtonIndex: 2,
+ cancelButtonIndex: 0,
+ userInterfaceStyle: 'dark'
+ },
+ buttonIndex => {
+ if (buttonIndex === 0) {
+ // cancel action
+ } else if (buttonIndex === 1) {
+ setResult(Math.floor(Math.random() * 100) + 1);
+ } else if (buttonIndex === 2) {
+ setResult("🔮");
+ }
+ }
+ );
+
+ return (
+
+ {result}
+
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "center"
+ },
+ result: {
+ fontSize: 64,
+ textAlign: "center"
+ }
+});
+
+export default App;
+```
+
+# Reference
+
+## Methods
+
+### `showActionSheetWithOptions()`
+
+```jsx
+static showActionSheetWithOptions(options, callback)
+```
+
+Display an iOS action sheet. The `options` object must contain one or more of:
+
+- `options` (array of strings) - a list of button titles (required)
+- `cancelButtonIndex` (int) - index of cancel button in `options`
+- `cancelButtonTintColor` (string) - the [color](colors) used for the change the text color of the cancel button
+- `destructiveButtonIndex` (int or array of ints) - indices of destructive buttons in `options`
+- `title` (string) - a title to show above the action sheet
+- `message` (string) - a message to show below the title
+- `anchor` (number) - the node to which the action sheet should be anchored (used for iPad)
+- `tintColor` (string) - the [color](colors) used for non-destructive button titles
+- `disabledButtonIndices` (array of numbers) - a list of button indices which should be disabled
+- `userInterfaceStyle` (string) - the interface style used for the action sheet, can be set to `light` or `dark`, otherwise the default system style will be used
+
+The 'callback' function takes one parameter, the zero-based index of the selected item.
+
+Minimal example:
+
+```jsx
+ActionSheetIOS.showActionSheetWithOptions(
+ {
+ options: ['Cancel', 'Remove'],
+ destructiveButtonIndex: 1,
+ cancelButtonIndex: 0
+ },
+ (buttonIndex) => {
+ if (buttonIndex === 1) {
+ /* destructive action */
+ }
+ }
+);
+```
+
+---
+
+### `dismissActionSheet()`
+
+```jsx
+static dismissActionSheet()
+```
+
+Dismisses the most upper iOS action sheet presented, if no action sheet is present a warning is displayed.
+
+---
+
+### `showShareActionSheetWithOptions()`
+
+```jsx
+static showShareActionSheetWithOptions(options, failureCallback, successCallback)
+```
+
+Display the iOS share sheet. The `options` object should contain one or both of `message` and `url` and can additionally have a `subject` or `excludedActivityTypes`:
+
+- `url` (string) - a URL to share
+- `message` (string) - a message to share
+- `subject` (string) - a subject for the message
+- `excludedActivityTypes` (array) - the activities to exclude from the ActionSheet
+
+> **Note:** If `url` points to a local file, or is a base64-encoded uri, the file it points to will be loaded and shared directly. In this way, you can share images, videos, PDF files, etc. If `url` points to a remote file or address it must conform to URL format as described in [RFC 2396](https://www.ietf.org/rfc/rfc2396.txt). For example, a web URL without a proper protocol (HTTP/HTTPS) will not be shared.
+
+The 'failureCallback' function takes one parameter, an error object. The only property defined on this object is an optional `stack` property of type `string`.
+
+The 'successCallback' function takes two parameters:
+
+- a boolean value signifying success or failure
+- a string that, in the case of success, indicates the method of sharing
diff --git a/website/versioned_docs/version-0.70/activityindicator.md b/website/versioned_docs/version-0.70/activityindicator.md
new file mode 100644
index 00000000000..33e05f8d587
--- /dev/null
+++ b/website/versioned_docs/version-0.70/activityindicator.md
@@ -0,0 +1,127 @@
+---
+id: activityindicator
+title: ActivityIndicator
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+Displays a circular loading indicator.
+
+## Example
+
+
+
+
+```SnackPlayer name=ActivityIndicator%20Function%20Component%20Example
+import React from "react";
+import { ActivityIndicator, StyleSheet, Text, View } from "react-native";
+
+const App = () => (
+
+
+
+
+
+
+);
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "center"
+ },
+ horizontal: {
+ flexDirection: "row",
+ justifyContent: "space-around",
+ padding: 10
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=ActivityIndicator%20Class%20Component%20Example
+import React, { Component } from "react";
+import { ActivityIndicator, StyleSheet, Text, View } from "react-native";
+
+class App extends Component {
+ render() {
+ return (
+
+
+
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "center"
+ },
+ horizontal: {
+ flexDirection: "row",
+ justifyContent: "space-around",
+ padding: 10
+ }
+});
+
+export default App;
+```
+
+
+
+
+# Reference
+
+## Props
+
+### [View Props](view#props)
+
+Inherits [View Props](view#props).
+
+---
+
+### `animating`
+
+Whether to show the indicator (`true`) or hide it (`false`).
+
+| Type | Default |
+| ---- | ------- |
+| bool | `true` |
+
+---
+
+### `color`
+
+The foreground color of the spinner.
+
+| Type | Default |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [color](colors) | `null` (system accent default color)
Android
`'#999999'`
iOS
|
+
+---
+
+### `hidesWhenStopped`
iOS
+
+Whether the indicator should hide when not animating.
+
+| Type | Default |
+| ---- | ------- |
+| bool | `true` |
+
+---
+
+### `size`
+
+Size of the indicator.
+
+| Type | Default |
+| ------------------------------------------------------------------------------ | --------- |
+| enum(`'small'`, `'large'`)number
Android
| `'small'` |
diff --git a/website/versioned_docs/version-0.70/alert.md b/website/versioned_docs/version-0.70/alert.md
new file mode 100644
index 00000000000..cd332863c3b
--- /dev/null
+++ b/website/versioned_docs/version-0.70/alert.md
@@ -0,0 +1,316 @@
+---
+id: alert
+title: Alert
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+Launches an alert dialog with the specified title and message.
+
+Optionally provide a list of buttons. Tapping any button will fire the respective onPress callback and dismiss the alert. By default, the only button will be an 'OK' button.
+
+This is an API that works both on Android and iOS and can show static alerts. Alert that prompts the user to enter some information is available on iOS only.
+
+## Example
+
+
+
+
+```SnackPlayer name=Alert%20Function%20Component%20Example&supportedPlatforms=ios,android
+import React, { useState } from "react";
+import { View, StyleSheet, Button, Alert } from "react-native";
+
+const App = () => {
+ const createTwoButtonAlert = () =>
+ Alert.alert(
+ "Alert Title",
+ "My Alert Msg",
+ [
+ {
+ text: "Cancel",
+ onPress: () => console.log("Cancel Pressed"),
+ style: "cancel"
+ },
+ { text: "OK", onPress: () => console.log("OK Pressed") }
+ ]
+ );
+
+ const createThreeButtonAlert = () =>
+ Alert.alert(
+ "Alert Title",
+ "My Alert Msg",
+ [
+ {
+ text: "Ask me later",
+ onPress: () => console.log("Ask me later pressed")
+ },
+ {
+ text: "Cancel",
+ onPress: () => console.log("Cancel Pressed"),
+ style: "cancel"
+ },
+ { text: "OK", onPress: () => console.log("OK Pressed") }
+ ]
+ );
+
+ return (
+
+
+
+
+ );
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "space-around",
+ alignItems: "center"
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=Alert%20Class%20Component%20Example&supportedPlatforms=ios,android
+import React, { Component } from "react";
+import { View, StyleSheet, Button, Alert } from "react-native";
+
+class App extends Component {
+ createTwoButtonAlert = () =>
+ Alert.alert(
+ "Alert Title",
+ "My Alert Msg",
+ [
+ {
+ text: "Cancel",
+ onPress: () => console.log("Cancel Pressed"),
+ style: "cancel"
+ },
+ { text: "OK", onPress: () => console.log("OK Pressed") }
+ ]
+ );
+
+ createThreeButtonAlert = () =>
+ Alert.alert(
+ "Alert Title",
+ "My Alert Msg",
+ [
+ {
+ text: "Ask me later",
+ onPress: () => console.log("Ask me later pressed")
+ },
+ {
+ text: "Cancel",
+ onPress: () => console.log("Cancel Pressed"),
+ style: "cancel"
+ },
+ { text: "OK", onPress: () => console.log("OK Pressed") }
+ ]
+ );
+
+ render() {
+ return (
+
+
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "space-around",
+ alignItems: "center"
+ }
+});
+
+export default App;
+```
+
+
+
+
+## iOS
+
+On iOS you can specify any number of buttons. Each button can optionally specify a style, available options are represented by the [AlertButtonStyle](#alertbuttonstyle-ios) enum.
+
+## Android
+
+On Android at most three buttons can be specified. Android has a concept of a neutral, negative and a positive button:
+
+- If you specify one button, it will be the 'positive' one (such as 'OK')
+- Two buttons mean 'negative', 'positive' (such as 'Cancel', 'OK')
+- Three buttons mean 'neutral', 'negative', 'positive' (such as 'Later', 'Cancel', 'OK')
+
+Alerts on Android can be dismissed by tapping outside of the alert box. It is disabled by default and can be enabled by providing an optional [Options](alert#options) parameter with the cancelable property set to `true` i.e. `{ cancelable: true }`.
+
+The cancel event can be handled by providing an `onDismiss` callback property inside the `options` parameter.
+
+### Example
| string | The dialog's title. Passing `null` or empty string will hide the title. |
+| message | string | An optional message that appears below the dialog's title. |
+| buttons | [Buttons](alert#buttons) | An optional array containing buttons configuration. |
+| options | [Options](alert#options) | An optional Alert configuration. |
+
+---
+
+### `prompt()`
iOS
+
+```jsx
+static prompt(title, message?, callbackOrButtons?, type?, defaultValue?, keyboardType?)
+```
+
+Create and display a prompt to enter some text in form of Alert.
+
+**Parameters:**
+
+| Name | Type | Description |
+| ------------------------------------------------------ | ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| title
Required
| string | The dialog's title. |
+| message | string | An optional message that appears above the text input. |
+| callbackOrButtons | function[Buttons](alert#buttons) | If passed a function, it will be called with the prompt's value `(text: string) => void`, when the user taps 'OK'.If passed an array, buttons will be configured based on the array content. |
+| type | [AlertType](alert#alerttype-ios) | This configures the text input. |
+| defaultValue | string | The default text in text input. |
+| keyboardType | string | The keyboard type of first text field (if exists). One of TextInput [keyboardTypes](textinput#keyboardtype). |
+| options | [Options](alert#options) | An optional Alert configuration. |
+
+---
+
+## Type Definitions
+
+### AlertButtonStyle
+
+An iOS Alert type.
+
+| Type |
+| ---- |
+| enum |
+
+**Constants:**
+
+| Value | Description |
+| ------------------ | ---------------------------- |
+| `'default'` | Default alert with no inputs |
+| `'plain-text'` | Plain text input alert |
+| `'secure-text'` | Secure text input alert |
+| `'login-password'` | Login and password alert |
+
+---
+
+### Buttons
+
+Array of objects containing Alert buttons configuration.
+
+| Type |
+| ---------------- |
+| array of objects |
+
+**Objects properties:**
+
+| Name | Type | Description |
+| -------------------------------------- | ---------------------------------------------- | ------------------------------------------------------- |
+| text | string | Button label. |
+| onPress | function | Callback function when button is pressed. |
+| style
iOS
| [AlertButtonStyle](alert#alertbuttonstyle-ios) | Button style, on Android this property will be ignored. |
+
+---
+
+### Options
+
+| Type |
+| ------ |
+| object |
+
+**Properties:**
+
+| Name | Type | Description |
+| --------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------- |
+| cancelable
Android
| boolean | Defines if alert can be dismissed by tapping outside of the alert box. |
+| userInterfaceStyle
iOS
| string | The interface style used for the alert, can be set to `light` or `dark`, otherwise the default system style will be used. |
+| onDismiss
Android
| function | Callback function fired when alert has been dismissed. |
diff --git a/website/versioned_docs/version-0.70/alertios.md b/website/versioned_docs/version-0.70/alertios.md
new file mode 100644
index 00000000000..e338397bbd6
--- /dev/null
+++ b/website/versioned_docs/version-0.70/alertios.md
@@ -0,0 +1,190 @@
+---
+id: alertios
+title: '🚧 AlertIOS'
+---
+
+> **Deprecated.** Use [`Alert`](alert) instead.
+
+`AlertIOS` provides functionality to create an iOS alert dialog with a message or create a prompt for user input.
+
+Creating an iOS alert:
+
+```jsx
+AlertIOS.alert(
+ 'Sync Complete',
+ 'All your data are belong to us.'
+);
+```
+
+Creating an iOS prompt:
+
+```jsx
+AlertIOS.prompt('Enter a value', null, (text) =>
+ console.log('You entered ' + text)
+);
+```
+
+We recommend using the [`Alert.alert`](alert) method for cross-platform support if you don't need to create iOS-only prompts.
+
+---
+
+# Reference
+
+## Methods
+
+### `alert()`
+
+```jsx
+static alert(title: string, [message]: string, [callbackOrButtons]: ?(() => void), ButtonsArray, [type]: AlertType): [object Object]
+```
+
+Create and display a popup alert.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ----------------- | --------------------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| title | string | Yes | The dialog's title. Passing null or '' will hide the title. |
+| message | string | No | An optional message that appears below the dialog's title. |
+| callbackOrButtons | ?(() => void),[ButtonsArray](alertios#buttonsarray) | No | This optional argument should be either a single-argument function or an array of buttons. If passed a function, it will be called when the user taps 'OK'. If passed an array of button configurations, each button should include a `text` key, as well as optional `onPress` and `style` keys. `style` should be one of 'default', 'cancel' or 'destructive'. |
+| type | [AlertType](alertios#alerttype) | No | Deprecated, do not use. |
+
+Example with custom buttons:
+
+```jsx
+AlertIOS.alert(
+ 'Update available',
+ 'Keep your app up to date to enjoy the latest features',
+ [
+ {
+ text: 'Cancel',
+ onPress: () => console.log('Cancel Pressed'),
+ style: 'cancel'
+ },
+ {
+ text: 'Install',
+ onPress: () => console.log('Install Pressed')
+ }
+ ]
+);
+```
+
+---
+
+### `prompt()`
+
+```jsx
+static prompt(title: string, [message]: string, [callbackOrButtons]: ?((text: string) => void), ButtonsArray, [type]: AlertType, [defaultValue]: string, [keyboardType]: string): [object Object]
+```
+
+Create and display a prompt to enter some text.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ----------------- | --------------------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| title | string | Yes | The dialog's title. |
+| message | string | No | An optional message that appears above the text input. |
+| callbackOrButtons | ?((text: string) => void),[ButtonsArray](alertios#buttonsarray) | No | This optional argument should be either a single-argument function or an array of buttons. If passed a function, it will be called with the prompt's value when the user taps 'OK'. If passed an array of button configurations, each button should include a `text` key, as well as optional `onPress` and `style` keys (see example). `style` should be one of 'default', 'cancel' or 'destructive'. |
+| type | [AlertType](alertios#alerttype) | No | This configures the text input. One of 'plain-text', 'secure-text' or 'login-password'. |
+| defaultValue | string | No | The default text in text input. |
+| keyboardType | string | No | The keyboard type of first text field(if exists). One of 'default', 'email-address', 'numeric', 'phone-pad', 'ascii-capable', 'numbers-and-punctuation', 'url', 'number-pad', 'name-phone-pad', 'decimal-pad', 'twitter' or 'web-search'. |
+
+Example with custom buttons:
+
+```jsx
+AlertIOS.prompt(
+ 'Enter password',
+ 'Enter your password to claim your $1.5B in lottery winnings',
+ [
+ {
+ text: 'Cancel',
+ onPress: () => console.log('Cancel Pressed'),
+ style: 'cancel'
+ },
+ {
+ text: 'OK',
+ onPress: (password) =>
+ console.log('OK Pressed, password: ' + password)
+ }
+ ],
+ 'secure-text'
+);
+```
+
+,
+
+Example with the default button and a custom callback:
+
+```jsx
+AlertIOS.prompt(
+ 'Update username',
+ null,
+ (text) => console.log('Your username is ' + text),
+ null,
+ 'default'
+);
+```
+
+## Type Definitions
+
+### AlertType
+
+An Alert button type
+
+| Type |
+| ------ |
+| \$Enum |
+
+**Constants:**
+
+| Value | Description |
+| -------------- | ---------------------------- |
+| default | Default alert with no inputs |
+| plain-text | Plain text input alert |
+| secure-text | Secure text input alert |
+| login-password | Login and password alert |
+
+---
+
+### AlertButtonStyle
+
+An Alert button style
+
+| Type |
+| ------ |
+| \$Enum |
+
+**Constants:**
+
+| Value | Description |
+| ----------- | ------------------------ |
+| default | Default button style |
+| cancel | Cancel button style |
+| destructive | Destructive button style |
+
+---
+
+### ButtonsArray
+
+Array or buttons
+
+| Type |
+| ----- |
+| Array |
+
+**Properties:**
+
+| Name | Type | Description |
+| --------- | --------------------------------------------- | ------------------------------------- |
+| [text] | string | Button label |
+| [onPress] | function | Callback function when button pressed |
+| [style] | [AlertButtonStyle](alertios#alertbuttonstyle) | Button style |
+
+**Constants:**
+
+| Value | Description |
+| ------- | ------------------------------------- |
+| text | Button label |
+| onPress | Callback function when button pressed |
+| style | Button style |
diff --git a/website/versioned_docs/version-0.70/animated.md b/website/versioned_docs/version-0.70/animated.md
new file mode 100644
index 00000000000..0e278ac247c
--- /dev/null
+++ b/website/versioned_docs/version-0.70/animated.md
@@ -0,0 +1,603 @@
+---
+id: animated
+title: Animated
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+The `Animated` library is designed to make animations fluid, powerful, and painless to build and maintain. `Animated` focuses on declarative relationships between inputs and outputs, configurable transforms in between, and `start`/`stop` methods to control time-based animation execution.
+
+The core workflow for creating an animation is to create an `Animated.Value`, hook it up to one or more style attributes of an animated component, and then drive updates via animations using `Animated.timing()`.
+
+
+
+
+> Don't modify the animated value directly. You can use the [`useRef` Hook](https://reactjs.org/docs/hooks-reference.html#useref) to return a mutable ref object. This ref object's `current` property is initialized as the given argument and persists throughout the component lifecycle.
+
+
+
+
+> Don't modify the animated value directly. It is usually stored as a [state variable](intro-react#state) in class components.
+
+
+
+
+## Example
+
+The following example contains a `View` which will fade in and fade out based on the animated value `fadeAnim`
+
+
+
+
+```SnackPlayer name=Animated
+import React, { useRef } from "react";
+import { Animated, Text, View, StyleSheet, Button, SafeAreaView } from "react-native";
+
+const App = () => {
+ // fadeAnim will be used as the value for opacity. Initial Value: 0
+ const fadeAnim = useRef(new Animated.Value(0)).current;
+
+ const fadeIn = () => {
+ // Will change fadeAnim value to 1 in 5 seconds
+ Animated.timing(fadeAnim, {
+ toValue: 1,
+ duration: 5000
+ }).start();
+ };
+
+ const fadeOut = () => {
+ // Will change fadeAnim value to 0 in 3 seconds
+ Animated.timing(fadeAnim, {
+ toValue: 0,
+ duration: 3000
+ }).start();
+ };
+
+ return (
+
+
+ Fading View!
+
+
+
+
+
+
+ );
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ fadingContainer: {
+ padding: 20,
+ backgroundColor: "powderblue"
+ },
+ fadingText: {
+ fontSize: 28
+ },
+ buttonRow: {
+ flexBasis: 100,
+ justifyContent: "space-evenly",
+ marginVertical: 16
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=Animated
+import React, { Component } from "react";
+import { Animated, Text, View, StyleSheet, Button, SafeAreaView } from "react-native";
+
+class App extends Component {
+ // fadeAnim will be used as the value for opacity. Initial Value: 0
+ state = {
+ fadeAnim: new Animated.Value(0)
+ };
+
+ fadeIn = () => {
+ // Will change fadeAnim value to 1 in 5 seconds
+ Animated.timing(this.state.fadeAnim, {
+ toValue: 1,
+ duration: 5000
+ }).start();
+ };
+
+ fadeOut = () => {
+ // Will change fadeAnim value to 0 in 3 seconds
+ Animated.timing(this.state.fadeAnim, {
+ toValue: 0,
+ duration: 3000
+ }).start();
+ };
+
+ render() {
+ return (
+
+
+ Fading View!
+
+
+
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ fadingContainer: {
+ padding: 20,
+ backgroundColor: "powderblue"
+ },
+ fadingText: {
+ fontSize: 28
+ },
+ buttonRow: {
+ flexBasis: 100,
+ justifyContent: "space-evenly",
+ marginVertical: 16
+ }
+});
+
+export default App;
+```
+
+
+
+
+Refer to the [Animations](animations#animated-api) guide to see additional examples of `Animated` in action.
+
+## Overview
+
+There are two value types you can use with `Animated`:
+
+- [`Animated.Value()`](animated#value) for single values
+- [`Animated.ValueXY()`](animated#valuexy) for vectors
+
+`Animated.Value` can bind to style properties or other props, and can be interpolated as well. A single `Animated.Value` can drive any number of properties.
+
+### Configuring animations
+
+`Animated` provides three types of animation types. Each animation type provides a particular animation curve that controls how your values animate from their initial value to the final value:
+
+- [`Animated.decay()`](animated#decay) starts with an initial velocity and gradually slows to a stop.
+- [`Animated.spring()`](animated#spring) provides a basic spring physics model.
+- [`Animated.timing()`](animated#timing) animates a value over time using [easing functions](easing).
+
+In most cases, you will be using `timing()`. By default, it uses a symmetric easeInOut curve that conveys the gradual acceleration of an object to full speed and concludes by gradually decelerating to a stop.
+
+### Working with animations
+
+Animations are started by calling `start()` on your animation. `start()` takes a completion callback that will be called when the animation is done. If the animation finished running normally, the completion callback will be invoked with `{finished: true}`. If the animation is done because `stop()` was called on it before it could finish (e.g. because it was interrupted by a gesture or another animation), then it will receive `{finished: false}`.
+
+```jsx
+Animated.timing({}).start(({ finished }) => {
+ /* completion callback */
+});
+```
+
+### Using the native driver
+
+By using the native driver, we send everything about the animation to native before starting the animation, allowing native code to perform the animation on the UI thread without having to go through the bridge on every frame. Once the animation has started, the JS thread can be blocked without affecting the animation.
+
+You can use the native driver by specifying `useNativeDriver: true` in your animation configuration. See the [Animations](animations#using-the-native-driver) guide to learn more.
+
+### Animatable components
+
+Only animatable components can be animated. These unique components do the magic of binding the animated values to the properties, and do targeted native updates to avoid the cost of the React render and reconciliation process on every frame. They also handle cleanup on unmount so they are safe by default.
+
+- [`createAnimatedComponent()`](animated#createanimatedcomponent) can be used to make a component animatable.
+
+`Animated` exports the following animatable components using the above wrapper:
+
+- `Animated.Image`
+- `Animated.ScrollView`
+- `Animated.Text`
+- `Animated.View`
+- `Animated.FlatList`
+- `Animated.SectionList`
+
+### Composing animations
+
+Animations can also be combined in complex ways using composition functions:
+
+- [`Animated.delay()`](animated#delay) starts an animation after a given delay.
+- [`Animated.parallel()`](animated#parallel) starts a number of animations at the same time.
+- [`Animated.sequence()`](animated#sequence) starts the animations in order, waiting for each to complete before starting the next.
+- [`Animated.stagger()`](animated#stagger) starts animations in order and in parallel, but with successive delays.
+
+Animations can also be chained together by setting the `toValue` of one animation to be another `Animated.Value`. See [Tracking dynamic values](animations#tracking-dynamic-values) in the Animations guide.
+
+By default, if one animation is stopped or interrupted, then all other animations in the group are also stopped.
+
+### Combining animated values
+
+You can combine two animated values via addition, subtraction, multiplication, division, or modulo to make a new animated value:
+
+- [`Animated.add()`](animated#add)
+- [`Animated.subtract()`](animated#subtract)
+- [`Animated.divide()`](animated#divide)
+- [`Animated.modulo()`](animated#modulo)
+- [`Animated.multiply()`](animated#multiply)
+
+### Interpolation
+
+The `interpolate()` function allows input ranges to map to different output ranges. By default, it will extrapolate the curve beyond the ranges given, but you can also have it clamp the output value. It uses linear interpolation by default but also supports easing functions.
+
+- [`interpolate()`](animated#interpolate)
+
+Read more about interpolation in the [Animation](animations#interpolation) guide.
+
+### Handling gestures and other events
+
+Gestures, like panning or scrolling, and other events can map directly to animated values using `Animated.event()`. This is done with a structured map syntax so that values can be extracted from complex event objects. The first level is an array to allow mapping across multiple args, and that array contains nested objects.
+
+- [`Animated.event()`](animated#event)
+
+For example, when working with horizontal scrolling gestures, you would do the following in order to map `event.nativeEvent.contentOffset.x` to `scrollX` (an `Animated.Value`):
+
+```jsx
+ onScroll={Animated.event(
+ // scrollX = e.nativeEvent.contentOffset.x
+ [{ nativeEvent: {
+ contentOffset: {
+ x: scrollX
+ }
+ }
+ }]
+ )}
+```
+
+---
+
+# Reference
+
+## Methods
+
+When the given value is a ValueXY instead of a Value, each config option may be a vector of the form `{x: ..., y: ...}` instead of a scalar.
+
+### `decay()`
+
+```jsx
+static decay(value, config)
+```
+
+Animates a value from an initial velocity to zero based on a decay coefficient.
+
+Config is an object that may have the following options:
+
+- `velocity`: Initial velocity. Required.
+- `deceleration`: Rate of decay. Default 0.997.
+- `isInteraction`: Whether or not this animation creates an "interaction handle" on the `InteractionManager`. Default true.
+- `useNativeDriver`: Uses the native driver when true. Default false.
+
+---
+
+### `timing()`
+
+```jsx
+static timing(value, config)
+```
+
+Animates a value along a timed easing curve. The [`Easing`](easing) module has tons of predefined curves, or you can use your own function.
+
+Config is an object that may have the following options:
+
+- `duration`: Length of animation (milliseconds). Default 500.
+- `easing`: Easing function to define curve. Default is `Easing.inOut(Easing.ease)`.
+- `delay`: Start the animation after delay (milliseconds). Default 0.
+- `isInteraction`: Whether or not this animation creates an "interaction handle" on the `InteractionManager`. Default true.
+- `useNativeDriver`: Uses the native driver when true. Default false.
+
+---
+
+### `spring()`
+
+```jsx
+static spring(value, config)
+```
+
+Animates a value according to an analytical spring model based on [damped harmonic oscillation](https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator). Tracks velocity state to create fluid motions as the `toValue` updates, and can be chained together.
+
+Config is an object that may have the following options.
+
+Note that you can only define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one:
+
+The friction/tension or bounciness/speed options match the spring model in [`Facebook Pop`](https://github.com/facebook/pop), [Rebound](https://github.com/facebookarchive/rebound), and [Origami](http://origami.design/).
+
+- `friction`: Controls "bounciness"/overshoot. Default 7.
+- `tension`: Controls speed. Default 40.
+- `speed`: Controls speed of the animation. Default 12.
+- `bounciness`: Controls bounciness. Default 8.
+
+Specifying stiffness/damping/mass as parameters makes `Animated.spring` use an analytical spring model based on the motion equations of a [damped harmonic oscillator](https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator). This behavior is slightly more precise and faithful to the physics behind spring dynamics, and closely mimics the implementation in iOS's CASpringAnimation.
+
+- `stiffness`: The spring stiffness coefficient. Default 100.
+- `damping`: Defines how the spring’s motion should be damped due to the forces of friction. Default 10.
+- `mass`: The mass of the object attached to the end of the spring. Default 1.
+
+Other configuration options are as follows:
+
+- `velocity`: The initial velocity of the object attached to the spring. Default 0 (object is at rest).
+- `overshootClamping`: Boolean indicating whether the spring should be clamped and not bounce. Default false.
+- `restDisplacementThreshold`: The threshold of displacement from rest below which the spring should be considered at rest. Default 0.001.
+- `restSpeedThreshold`: The speed at which the spring should be considered at rest in pixels per second. Default 0.001.
+- `delay`: Start the animation after delay (milliseconds). Default 0.
+- `isInteraction`: Whether or not this animation creates an "interaction handle" on the `InteractionManager`. Default true.
+- `useNativeDriver`: Uses the native driver when true. Default false.
+
+---
+
+### `add()`
+
+```jsx
+static add(a, b)
+```
+
+Creates a new Animated value composed from two Animated values added together.
+
+---
+
+### `subtract()`
+
+```jsx
+static subtract(a, b)
+```
+
+Creates a new Animated value composed by subtracting the second Animated value from the first Animated value.
+
+---
+
+### `divide()`
+
+```jsx
+static divide(a, b)
+```
+
+Creates a new Animated value composed by dividing the first Animated value by the second Animated value.
+
+---
+
+### `multiply()`
+
+```jsx
+static multiply(a, b)
+```
+
+Creates a new Animated value composed from two Animated values multiplied together.
+
+---
+
+### `modulo()`
+
+```jsx
+static modulo(a, modulus)
+```
+
+Creates a new Animated value that is the (non-negative) modulo of the provided Animated value
+
+---
+
+### `diffClamp()`
+
+```jsx
+static diffClamp(a, min, max)
+```
+
+Create a new Animated value that is limited between 2 values. It uses the difference between the last value so even if the value is far from the bounds it will start changing when the value starts getting closer again. (`value = clamp(value + diff, min, max)`).
+
+This is useful with scroll events, for example, to show the navbar when scrolling up and to hide it when scrolling down.
+
+---
+
+### `delay()`
+
+```jsx
+static delay(time)
+```
+
+Starts an animation after the given delay.
+
+---
+
+### `sequence()`
+
+```jsx
+static sequence(animations)
+```
+
+Starts an array of animations in order, waiting for each to complete before starting the next. If the current running animation is stopped, no following animations will be started.
+
+---
+
+### `parallel()`
+
+```jsx
+static parallel(animations, config?)
+```
+
+Starts an array of animations all at the same time. By default, if one of the animations is stopped, they will all be stopped. You can override this with the `stopTogether` flag.
+
+---
+
+### `stagger()`
+
+```jsx
+static stagger(time, animations)
+```
+
+Array of animations may run in parallel (overlap), but are started in sequence with successive delays. Nice for doing trailing effects.
+
+---
+
+### `loop()`
+
+```jsx
+static loop(animation, config?)
+```
+
+Loops a given animation continuously, so that each time it reaches the end, it resets and begins again from the start. Will loop without blocking the JS thread if the child animation is set to `useNativeDriver: true`. In addition, loops can prevent `VirtualizedList`-based components from rendering more rows while the animation is running. You can pass `isInteraction: false` in the child animation config to fix this.
+
+Config is an object that may have the following options:
+
+- `iterations`: Number of times the animation should loop. Default `-1` (infinite).
+
+---
+
+### `event()`
+
+```jsx
+static event(argMapping, config?)
+```
+
+Takes an array of mappings and extracts values from each arg accordingly, then calls `setValue` on the mapped outputs. e.g.
+
+```jsx
+ onScroll={Animated.event(
+ [{nativeEvent: {contentOffset: {x: this._scrollX}}}],
+ {listener: (event) => console.log(event)}, // Optional async listener
+ )}
+ ...
+ onPanResponderMove: Animated.event([
+ null, // raw event arg ignored
+ {dx: this._panX}], // gestureState arg
+{listener: (event, gestureState) => console.log(event, gestureState)}, // Optional async listener
+ ),
+```
+
+Config is an object that may have the following options:
+
+- `listener`: Optional async listener.
+- `useNativeDriver`: Uses the native driver when true. Default false.
+
+---
+
+### `forkEvent()`
+
+```jsx
+static forkEvent(event, listener)
+```
+
+Advanced imperative API for snooping on animated events that are passed in through props. It permits to add a new javascript listener to an existing `AnimatedEvent`. If `animatedEvent` is a javascript listener, it will merge the 2 listeners into a single one, and if `animatedEvent` is null/undefined, it will assign the javascript listener directly. Use values directly where possible.
+
+---
+
+### `unforkEvent()`
+
+```jsx
+static unforkEvent(event, listener)
+```
+
+---
+
+### `start()`
+
+```jsx
+static start([callback]: ?(result?: {finished: boolean}) => void)
+```
+
+Animations are started by calling start() on your animation. start() takes a completion callback that will be called when the animation is done or when the animation is done because stop() was called on it before it could finish.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | ------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| callback | ?(result?: {finished: boolean}) | No | Function that will be called after the animation finished running normally or when the animation is done because stop() was called on it before it could finish |
+
+Start example with callback:
+
+```jsx
+Animated.timing({}).start(({ finished }) => {
+ /* completion callback */
+});
+```
+
+---
+
+### `stop()`
+
+```jsx
+static stop()
+```
+
+Stops any running animation.
+
+---
+
+### `reset()`
+
+```jsx
+static reset()
+```
+
+Stops any running animation and resets the value to its original.
+
+## Properties
+
+### `Value`
+
+Standard value class for driving animations. Typically initialized with `new Animated.Value(0);`
+
+You can read more about `Animated.Value` API on the separate [page](animatedvalue).
+
+---
+
+### `ValueXY`
+
+2D value class for driving 2D animations, such as pan gestures.
+
+You can read more about `Animated.ValueXY` API on the separate [page](animatedvaluexy).
+
+---
+
+### `Interpolation`
+
+Exported to use the Interpolation type in flow.
+
+---
+
+### `Node`
+
+Exported for ease of type checking. All animated values derive from this class.
+
+---
+
+### `createAnimatedComponent`
+
+Make any React component Animatable. Used to create `Animated.View`, etc.
+
+---
+
+### `attachNativeEvent`
+
+Imperative API to attach an animated value to an event on a view. Prefer using `Animated.event` with `useNativeDrive: true` if possible.
diff --git a/website/versioned_docs/version-0.70/animatedvalue.md b/website/versioned_docs/version-0.70/animatedvalue.md
new file mode 100644
index 00000000000..36b782c777c
--- /dev/null
+++ b/website/versioned_docs/version-0.70/animatedvalue.md
@@ -0,0 +1,210 @@
+---
+id: animatedvalue
+title: Animated.Value
+---
+
+Standard value for driving animations. One `Animated.Value` can drive multiple properties in a synchronized fashion, but can only be driven by one mechanism at a time. Using a new mechanism (e.g. starting a new animation, or calling `setValue`) will stop any previous ones.
+
+Typically initialized with `new Animated.Value(0);`
+
+---
+
+# Reference
+
+## Methods
+
+### `setValue()`
+
+```jsx
+setValue(value);
+```
+
+Directly set the value. This will stop any animations running on the value and update all the bound properties.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ----- | ------ | -------- | ----------- |
+| value | number | Yes | Value |
+
+---
+
+### `setOffset()`
+
+```jsx
+setOffset(offset);
+```
+
+Sets an offset that is applied on top of whatever value is set, whether via `setValue`, an animation, or `Animated.event`. Useful for compensating things like the start of a pan gesture.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ------ | ------ | -------- | ------------ |
+| offset | number | Yes | Offset value |
+
+---
+
+### `flattenOffset()`
+
+```jsx
+flattenOffset();
+```
+
+Merges the offset value into the base value and resets the offset to zero. The final output of the value is unchanged.
+
+---
+
+### `extractOffset()`
+
+```jsx
+extractOffset();
+```
+
+Sets the offset value to the base value, and resets the base value to zero. The final output of the value is unchanged.
+
+---
+
+### `addListener()`
+
+```jsx
+addListener(callback);
+```
+
+Adds an asynchronous listener to the value so you can observe updates from animations. This is useful because there is no way to synchronously read the value because it might be driven natively.
+
+Returns a string that serves as an identifier for the listener.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------- | -------- | ------------------------------------------------------------------------------------------- |
+| callback | function | Yes | The callback function which will receive an object with a `value` key set to the new value. |
+
+---
+
+### `removeListener()`
+
+```jsx
+removeListener(id);
+```
+
+Unregister a listener. The `id` param shall match the identifier previously returned by `addListener()`.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ---- | ------ | -------- | ---------------------------------- |
+| id | string | Yes | Id for the listener being removed. |
+
+---
+
+### `removeAllListeners()`
+
+```jsx
+removeAllListeners();
+```
+
+Remove all registered listeners.
+
+---
+
+### `stopAnimation()`
+
+```jsx
+stopAnimation([callback]);
+```
+
+Stops any running animation or tracking. `callback` is invoked with the final value after stopping the animation, which is useful for updating state to match the animation position with layout.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------- | -------- | --------------------------------------------- |
+| callback | function | No | A function that will receive the final value. |
+
+---
+
+### `resetAnimation()`
+
+```jsx
+resetAnimation([callback]);
+```
+
+Stops any animation and resets the value to its original.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------- | -------- | ------------------------------------------------ |
+| callback | function | No | A function that will receive the original value. |
+
+---
+
+### `interpolate()`
+
+```jsx
+interpolate(config);
+```
+
+Interpolates the value before updating the property, e.g. mapping 0-1 to 0-10.
+
+See `AnimatedInterpolation.js`
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ------ | ------ | -------- | ----------- |
+| config | object | Yes | See below. |
+
+The `config` object is composed of the following keys:
+
+- `inputRange`: an array of numbers
+- `outputRange`: an array of numbers or strings
+- `easing` (optional): a function that returns a number, given an input number
+- `extrapolate` (optional): a string such as 'extend', 'identity', or 'clamp'
+- `extrapolateLeft` (optional): a string such as 'extend', 'identity', or 'clamp'
+- `extrapolateRight` (optional): a string such as 'extend', 'identity', or 'clamp'
+
+---
+
+### `animate()`
+
+```jsx
+animate(animation, callback);
+```
+
+Typically only used internally, but could be used by a custom Animation class.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| --------- | --------- | -------- | ------------------- |
+| animation | Animation | Yes | See `Animation.js`. |
+| callback | function | Yes | Callback function. |
+
+---
+
+### `stopTracking()`
+
+```jsx
+stopTracking();
+```
+
+Typically only used internally.
+
+---
+
+### `track()`
+
+```jsx
+track(tracking);
+```
+
+Typically only used internally.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | ------------ | -------- | --------------------- |
+| tracking | AnimatedNode | Yes | See `AnimatedNode.js` |
diff --git a/website/versioned_docs/version-0.70/animatedvaluexy.md b/website/versioned_docs/version-0.70/animatedvaluexy.md
new file mode 100644
index 00000000000..cfe73bc5a59
--- /dev/null
+++ b/website/versioned_docs/version-0.70/animatedvaluexy.md
@@ -0,0 +1,221 @@
+---
+id: animatedvaluexy
+title: Animated.ValueXY
+---
+
+2D Value for driving 2D animations, such as pan gestures. Almost identical API to normal [`Animated.Value`](animatedvalue), but multiplexed. Contains two regular `Animated.Value`s under the hood.
+
+## Example
+
+```SnackPlayer name=Animated.ValueXY
+import React, { useRef } from "react";
+import { Animated, PanResponder, StyleSheet, View } from "react-native";
+
+const DraggableView = () => {
+ const pan = useRef(new Animated.ValueXY()).current;
+
+ const panResponder = PanResponder.create({
+ onStartShouldSetPanResponder: () => true,
+ onPanResponderMove: Animated.event([
+ null,
+ {
+ dx: pan.x, // x,y are Animated.Value
+ dy: pan.y,
+ },
+ ]),
+ onPanResponderRelease: () => {
+ Animated.spring(
+ pan, // Auto-multiplexed
+ { toValue: { x: 0, y: 0 } } // Back to zero
+ ).start();
+ },
+ });
+
+ return (
+
+
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "center",
+ alignItems: "center",
+ },
+ box: {
+ backgroundColor: "#61dafb",
+ width: 80,
+ height: 80,
+ borderRadius: 4,
+ },
+});
+
+export default DraggableView;
+```
+
+---
+
+# Reference
+
+## Methods
+
+### `setValue()`
+
+```jsx
+setValue(value);
+```
+
+Directly set the value. This will stop any animations running on the value and update all the bound properties.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ----- | ------ | -------- | ----------- |
+| value | number | Yes | Value |
+
+---
+
+### `setOffset()`
+
+```jsx
+setOffset(offset);
+```
+
+Sets an offset that is applied on top of whatever value is set, whether via `setValue`, an animation, or `Animated.event`. Useful for compensating things like the start of a pan gesture.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ------ | ------ | -------- | ------------ |
+| offset | number | Yes | Offset value |
+
+---
+
+### `flattenOffset()`
+
+```jsx
+flattenOffset();
+```
+
+Merges the offset value into the base value and resets the offset to zero. The final output of the value is unchanged.
+
+---
+
+### `extractOffset()`
+
+```jsx
+extractOffset();
+```
+
+Sets the offset value to the base value, and resets the base value to zero. The final output of the value is unchanged.
+
+---
+
+### `addListener()`
+
+```jsx
+addListener(callback);
+```
+
+Adds an asynchronous listener to the value so you can observe updates from animations. This is useful because there is no way to synchronously read the value because it might be driven natively.
+
+Returns a string that serves as an identifier for the listener.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------- | -------- | ------------------------------------------------------------------------------------------- |
+| callback | function | Yes | The callback function which will receive an object with a `value` key set to the new value. |
+
+---
+
+### `removeListener()`
+
+```jsx
+removeListener(id);
+```
+
+Unregister a listener. The `id` param shall match the identifier previously returned by `addListener()`.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ---- | ------ | -------- | ---------------------------------- |
+| id | string | Yes | Id for the listener being removed. |
+
+---
+
+### `removeAllListeners()`
+
+```jsx
+removeAllListeners();
+```
+
+Remove all registered listeners.
+
+---
+
+### `stopAnimation()`
+
+```jsx
+stopAnimation([callback]);
+```
+
+Stops any running animation or tracking. `callback` is invoked with the final value after stopping the animation, which is useful for updating state to match the animation position with layout.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------- | -------- | --------------------------------------------- |
+| callback | function | No | A function that will receive the final value. |
+
+---
+
+### `resetAnimation()`
+
+```jsx
+resetAnimation([callback]);
+```
+
+Stops any animation and resets the value to its original.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------- | -------- | ------------------------------------------------ |
+| callback | function | No | A function that will receive the original value. |
+
+---
+
+### `getLayout()`
+
+```jsx
+getLayout();
+```
+
+Converts `{x, y}` into `{left, top}` for use in style, e.g.
+
+```jsx
+style={this.state.anim.getLayout()}
+```
+
+---
+
+### `getTranslateTransform()`
+
+```jsx
+getTranslateTransform();
+```
+
+Converts `{x, y}` into a useable translation transform, e.g.
+
+```jsx
+style={{
+ transform: this.state.anim.getTranslateTransform()
+}}
+```
diff --git a/website/versioned_docs/version-0.70/animations.md b/website/versioned_docs/version-0.70/animations.md
new file mode 100644
index 00000000000..18704441310
--- /dev/null
+++ b/website/versioned_docs/version-0.70/animations.md
@@ -0,0 +1,821 @@
+---
+id: animations
+title: Animations
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+Animations are very important to create a great user experience. Stationary objects must overcome inertia as they start moving. Objects in motion have momentum and rarely come to a stop immediately. Animations allow you to convey physically believable motion in your interface.
+
+React Native provides two complementary animation systems: [`Animated`](animations#animated-api) for granular and interactive control of specific values, and [`LayoutAnimation`](animations#layoutanimation-api) for animated global layout transactions.
+
+## `Animated` API
+
+The [`Animated`](animated) API is designed to concisely express a wide variety of interesting animation and interaction patterns in a very performant way. `Animated` focuses on declarative relationships between inputs and outputs, with configurable transforms in between, and `start`/`stop` methods to control time-based animation execution.
+
+`Animated` exports six animatable component types: `View`, `Text`, `Image`, `ScrollView`, `FlatList` and `SectionList`, but you can also create your own using `Animated.createAnimatedComponent()`.
+
+For example, a container view that fades in when it is mounted may look like this:
+
+```SnackPlayer
+import React, { useRef, useEffect } from 'react';
+import { Animated, Text, View } from 'react-native';
+
+const FadeInView = (props) => {
+ const fadeAnim = useRef(new Animated.Value(0)).current // Initial value for opacity: 0
+
+ useEffect(() => {
+ Animated.timing(
+ fadeAnim,
+ {
+ toValue: 1,
+ duration: 10000,
+ }
+ ).start();
+ }, [fadeAnim])
+
+ return (
+
+ {props.children}
+
+ );
+}
+
+// You can then use your `FadeInView` in place of a `View` in your components:
+export default () => {
+ return (
+
+
+ Fading in
+
+
+ )
+}
+```
+
+Let's break down what's happening here. In the `FadeInView` constructor, a new `Animated.Value` called `fadeAnim` is initialized as part of `state`. The opacity property on the `View` is mapped to this animated value. Behind the scenes, the numeric value is extracted and used to set opacity.
+
+When the component mounts, the opacity is set to 0. Then, an easing animation is started on the `fadeAnim` animated value, which will update all of its dependent mappings (in this case, only the opacity) on each frame as the value animates to the final value of 1.
+
+This is done in an optimized way that is faster than calling `setState` and re-rendering. Because the entire configuration is declarative, we will be able to implement further optimizations that serialize the configuration and runs the animation on a high-priority thread.
+
+### Configuring animations
+
+Animations are heavily configurable. Custom and predefined easing functions, delays, durations, decay factors, spring constants, and more can all be tweaked depending on the type of animation.
+
+`Animated` provides several animation types, the most commonly used one being [`Animated.timing()`](animated#timing). It supports animating a value over time using one of various predefined easing functions, or you can use your own. Easing functions are typically used in animation to convey gradual acceleration and deceleration of objects.
+
+By default, `timing` will use an easeInOut curve that conveys gradual acceleration to full speed and concludes by gradually decelerating to a stop. You can specify a different easing function by passing an `easing` parameter. Custom `duration` or even a `delay` before the animation starts is also supported.
+
+For example, if we want to create a 2-second long animation of an object that slightly backs up before moving to its final position:
+
+```jsx
+Animated.timing(this.state.xPosition, {
+ toValue: 100,
+ easing: Easing.back(),
+ duration: 2000
+}).start();
+```
+
+Take a look at the [Configuring animations](animated#configuring-animations) section of the `Animated` API reference to learn more about all the config parameters supported by the built-in animations.
+
+### Composing animations
+
+Animations can be combined and played in sequence or in parallel. Sequential animations can play immediately after the previous animation has finished, or they can start after a specified delay. The `Animated` API provides several methods, such as `sequence()` and `delay()`, each of which take an array of animations to execute and automatically calls `start()`/`stop()` as needed.
+
+For example, the following animation coasts to a stop, then it springs back while twirling in parallel:
+
+```jsx
+Animated.sequence([
+ // decay, then spring to start and twirl
+ Animated.decay(position, {
+ // coast to a stop
+ velocity: { x: gestureState.vx, y: gestureState.vy }, // velocity from gesture release
+ deceleration: 0.997
+ }),
+ Animated.parallel([
+ // after decay, in parallel:
+ Animated.spring(position, {
+ toValue: { x: 0, y: 0 } // return to start
+ }),
+ Animated.timing(twirl, {
+ // and twirl
+ toValue: 360
+ })
+ ])
+]).start(); // start the sequence group
+```
+
+If one animation is stopped or interrupted, then all other animations in the group are also stopped. `Animated.parallel` has a `stopTogether` option that can be set to `false` to disable this.
+
+You can find a full list of composition methods in the [Composing animations](animated#composing-animations) section of the `Animated` API reference.
+
+### Combining animated values
+
+You can [combine two animated values](animated#combining-animated-values) via addition, multiplication, division, or modulo to make a new animated value.
+
+There are some cases where an animated value needs to invert another animated value for calculation. An example is inverting a scale (2x --> 0.5x):
+
+```jsx
+const a = new Animated.Value(1);
+const b = Animated.divide(1, a);
+
+Animated.spring(a, {
+ toValue: 2
+}).start();
+```
+
+### Interpolation
+
+Each property can be run through an interpolation first. An interpolation maps input ranges to output ranges, typically using a linear interpolation but also supports easing functions. By default, it will extrapolate the curve beyond the ranges given, but you can also have it clamp the output value.
+
+A basic mapping to convert a 0-1 range to a 0-100 range would be:
+
+```jsx
+value.interpolate({
+ inputRange: [0, 1],
+ outputRange: [0, 100]
+});
+```
+
+For example, you may want to think about your `Animated.Value` as going from 0 to 1, but animate the position from 150px to 0px and the opacity from 0 to 1. This can be done by modifying `style` from the example above like so:
+
+```jsx
+ style={{
+ opacity: this.state.fadeAnim, // Binds directly
+ transform: [{
+ translateY: this.state.fadeAnim.interpolate({
+ inputRange: [0, 1],
+ outputRange: [150, 0] // 0 : 150, 0.5 : 75, 1 : 0
+ }),
+ }],
+ }}
+```
+
+[`interpolate()`](animated#interpolate) supports multiple range segments as well, which is handy for defining dead zones and other handy tricks. For example, to get a negation relationship at -300 that goes to 0 at -100, then back up to 1 at 0, and then back down to zero at 100 followed by a dead-zone that remains at 0 for everything beyond that, you could do:
+
+```jsx
+value.interpolate({
+ inputRange: [-300, -100, 0, 100, 101],
+ outputRange: [300, 0, 1, 0, 0]
+});
+```
+
+Which would map like so:
+
+```
+Input | Output
+------|-------
+ -400| 450
+ -300| 300
+ -200| 150
+ -100| 0
+ -50| 0.5
+ 0| 1
+ 50| 0.5
+ 100| 0
+ 101| 0
+ 200| 0
+```
+
+`interpolate()` also supports mapping to strings, allowing you to animate colors as well as values with units. For example, if you wanted to animate a rotation you could do:
+
+```jsx
+value.interpolate({
+ inputRange: [0, 360],
+ outputRange: ['0deg', '360deg']
+});
+```
+
+`interpolate()` also supports arbitrary easing functions, many of which are already implemented in the [`Easing`](easing) module. `interpolate()` also has configurable behavior for extrapolating the `outputRange`. You can set the extrapolation by setting the `extrapolate`, `extrapolateLeft`, or `extrapolateRight` options. The default value is `extend` but you can use `clamp` to prevent the output value from exceeding `outputRange`.
+
+### Tracking dynamic values
+
+Animated values can also track other values by setting the `toValue` of an animation to another animated value instead of a plain number. For example, a "Chat Heads" animation like the one used by Messenger on Android could be implemented with a `spring()` pinned on another animated value, or with `timing()` and a `duration` of 0 for rigid tracking. They can also be composed with interpolations:
+
+```jsx
+Animated.spring(follower, { toValue: leader }).start();
+Animated.timing(opacity, {
+ toValue: pan.x.interpolate({
+ inputRange: [0, 300],
+ outputRange: [1, 0]
+ })
+}).start();
+```
+
+The `leader` and `follower` animated values would be implemented using `Animated.ValueXY()`. `ValueXY` is a handy way to deal with 2D interactions, such as panning or dragging. It is a basic wrapper that contains two `Animated.Value` instances and some helper functions that call through to them, making `ValueXY` a drop-in replacement for `Value` in many cases. It allows us to track both x and y values in the example above.
+
+### Tracking gestures
+
+Gestures, like panning or scrolling, and other events can map directly to animated values using [`Animated.event`](animated#event). This is done with a structured map syntax so that values can be extracted from complex event objects. The first level is an array to allow mapping across multiple args, and that array contains nested objects.
+
+For example, when working with horizontal scrolling gestures, you would do the following in order to map `event.nativeEvent.contentOffset.x` to `scrollX` (an `Animated.Value`):
+
+```jsx
+ onScroll={Animated.event(
+ // scrollX = e.nativeEvent.contentOffset.x
+ [{ nativeEvent: {
+ contentOffset: {
+ x: scrollX
+ }
+ }
+ }]
+ )}
+```
+
+The following example implements a horizontal scrolling carousel where the scroll position indicators are animated using the `Animated.event` used in the `ScrollView`
+
+#### ScrollView with Animated Event Example
+
+
+
+
+```SnackPlayer name=Animated&supportedPlatforms=ios,android
+import React, { useRef } from "react";
+import {
+ SafeAreaView,
+ ScrollView,
+ Text,
+ StyleSheet,
+ View,
+ ImageBackground,
+ Animated,
+ useWindowDimensions
+} from "react-native";
+
+const images = new Array(6).fill('https://images.unsplash.com/photo-1556740749-887f6717d7e4');
+
+const App = () => {
+ const scrollX = useRef(new Animated.Value(0)).current;
+
+ const { width: windowWidth } = useWindowDimensions();
+
+ return (
+
+
+
+ {images.map((image, imageIndex) => {
+ return (
+
+
+
+
+ {"Image - " + imageIndex}
+
+
+
+
+ );
+ })}
+
+
+ {images.map((image, imageIndex) => {
+ const width = scrollX.interpolate({
+ inputRange: [
+ windowWidth * (imageIndex - 1),
+ windowWidth * imageIndex,
+ windowWidth * (imageIndex + 1)
+ ],
+ outputRange: [8, 16, 8],
+ extrapolate: "clamp"
+ });
+ return (
+
+ );
+ })}
+
+
+
+ );
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ scrollContainer: {
+ height: 300,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ card: {
+ flex: 1,
+ marginVertical: 4,
+ marginHorizontal: 16,
+ borderRadius: 5,
+ overflow: "hidden",
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ textContainer: {
+ backgroundColor: "rgba(0,0,0, 0.7)",
+ paddingHorizontal: 24,
+ paddingVertical: 8,
+ borderRadius: 5
+ },
+ infoText: {
+ color: "white",
+ fontSize: 16,
+ fontWeight: "bold"
+ },
+ normalDot: {
+ height: 8,
+ width: 8,
+ borderRadius: 4,
+ backgroundColor: "silver",
+ marginHorizontal: 4
+ },
+ indicatorContainer: {
+ flexDirection: "row",
+ alignItems: "center",
+ justifyContent: "center"
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=Animated&supportedPlatforms=ios,android
+import React, { Component } from "react";
+import {
+ SafeAreaView,
+ ScrollView,
+ Text,
+ StyleSheet,
+ View,
+ ImageBackground,
+ Animated,
+ Dimensions
+} from "react-native";
+
+const images = new Array(6).fill('https://images.unsplash.com/photo-1556740749-887f6717d7e4');
+
+const window = Dimensions.get("window");
+
+export default class App extends Component {
+ scrollX = new Animated.Value(0);
+
+ state = {
+ dimensions: {
+ window
+ }
+ };
+
+ onDimensionsChange = ({ window }) => {
+ this.setState({ dimensions: { window } });
+ };
+
+ componentDidMount() {
+ Dimensions.addEventListener("change", this.onDimensionsChange);
+ }
+
+ componentWillUnmount() {
+ Dimensions.removeEventListener("change", this.onDimensionsChange);
+ }
+
+ render() {
+ const windowWidth = this.state.dimensions.window.width;
+
+ return (
+
+
+
+ {images.map((image, imageIndex) => {
+ return (
+
+
+
+
+ {"Image - " + imageIndex}
+
+
+
+
+ );
+ })}
+
+
+ {images.map((image, imageIndex) => {
+ const width = this.scrollX.interpolate({
+ inputRange: [
+ windowWidth * (imageIndex - 1),
+ windowWidth * imageIndex,
+ windowWidth * (imageIndex + 1)
+ ],
+ outputRange: [8, 16, 8],
+ extrapolate: "clamp"
+ });
+ return (
+
+ );
+ })}
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ scrollContainer: {
+ height: 300,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ card: {
+ flex: 1,
+ marginVertical: 4,
+ marginHorizontal: 16,
+ borderRadius: 5,
+ overflow: "hidden",
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ textContainer: {
+ backgroundColor: "rgba(0,0,0, 0.7)",
+ paddingHorizontal: 24,
+ paddingVertical: 8,
+ borderRadius: 5
+ },
+ infoText: {
+ color: "white",
+ fontSize: 16,
+ fontWeight: "bold"
+ },
+ normalDot: {
+ height: 8,
+ width: 8,
+ borderRadius: 4,
+ backgroundColor: "silver",
+ marginHorizontal: 4
+ },
+ indicatorContainer: {
+ flexDirection: "row",
+ alignItems: "center",
+ justifyContent: "center"
+ }
+});
+```
+
+
+
+
+When using `PanResponder`, you could use the following code to extract the x and y positions from `gestureState.dx` and `gestureState.dy`. We use a `null` in the first position of the array, as we are only interested in the second argument passed to the `PanResponder` handler, which is the `gestureState`.
+
+```jsx
+onPanResponderMove={Animated.event(
+ [null, // ignore the native event
+ // extract dx and dy from gestureState
+ // like 'pan.x = gestureState.dx, pan.y = gestureState.dy'
+ {dx: pan.x, dy: pan.y}
+])}
+```
+
+#### PanResponder with Animated Event Example
+
+
+
+
+```SnackPlayer name=Animated
+import React, { useRef } from "react";
+import { Animated, View, StyleSheet, PanResponder, Text } from "react-native";
+
+const App = () => {
+ const pan = useRef(new Animated.ValueXY()).current;
+ const panResponder = useRef(
+ PanResponder.create({
+ onMoveShouldSetPanResponder: () => true,
+ onPanResponderMove: Animated.event([
+ null,
+ { dx: pan.x, dy: pan.y }
+ ]),
+ onPanResponderRelease: () => {
+ Animated.spring(pan, { toValue: { x: 0, y: 0 } }).start();
+ }
+ })
+ ).current;
+
+ return (
+
+ Drag & Release this box!
+
+
+
+
+ );
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ titleText: {
+ fontSize: 14,
+ lineHeight: 24,
+ fontWeight: "bold"
+ },
+ box: {
+ height: 150,
+ width: 150,
+ backgroundColor: "blue",
+ borderRadius: 5
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=Animated
+import React, { Component } from "react";
+import { Animated, View, StyleSheet, PanResponder, Text } from "react-native";
+
+export default class App extends Component {
+ pan = new Animated.ValueXY();
+ panResponder = PanResponder.create({
+ onMoveShouldSetPanResponder: () => true,
+ onPanResponderMove: Animated.event([
+ null,
+ { dx: this.pan.x, dy: this.pan.y }
+ ]),
+ onPanResponderRelease: () => {
+ Animated.spring(this.pan, { toValue: { x: 0, y: 0 } }).start();
+ }
+ });
+
+ render() {
+ return (
+
+ Drag & Release this box!
+
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ titleText: {
+ fontSize: 14,
+ lineHeight: 24,
+ fontWeight: "bold"
+ },
+ box: {
+ height: 150,
+ width: 150,
+ backgroundColor: "blue",
+ borderRadius: 5
+ }
+});
+```
+
+
+
+
+### Responding to the current animation value
+
+You may notice that there is no clear way to read the current value while animating. This is because the value may only be known in the native runtime due to optimizations. If you need to run JavaScript in response to the current value, there are two approaches:
+
+- `spring.stopAnimation(callback)` will stop the animation and invoke `callback` with the final value. This is useful when making gesture transitions.
+- `spring.addListener(callback)` will invoke `callback` asynchronously while the animation is running, providing a recent value. This is useful for triggering state changes, for example snapping a bobble to a new option as the user drags it closer, because these larger state changes are less sensitive to a few frames of lag compared to continuous gestures like panning which need to run at 60 fps.
+
+`Animated` is designed to be fully serializable so that animations can be run in a high performance way, independent of the normal JavaScript event loop. This does influence the API, so keep that in mind when it seems a little trickier to do something compared to a fully synchronous system. Check out `Animated.Value.addListener` as a way to work around some of these limitations, but use it sparingly since it might have performance implications in the future.
+
+### Using the native driver
+
+The `Animated` API is designed to be serializable. By using the [native driver](/blog/2017/02/14/using-native-driver-for-animated), we send everything about the animation to native before starting the animation, allowing native code to perform the animation on the UI thread without having to go through the bridge on every frame. Once the animation has started, the JS thread can be blocked without affecting the animation.
+
+Using the native driver for normal animations is straightforward. You can add `useNativeDriver: true` to the animation config when starting it.
+
+```jsx
+Animated.timing(this.state.animatedValue, {
+ toValue: 1,
+ duration: 500,
+ useNativeDriver: true // <-- Add this
+}).start();
+```
+
+Animated values are only compatible with one driver so if you use native driver when starting an animation on a value, make sure every animation on that value also uses the native driver.
+
+The native driver also works with `Animated.event`. This is especially useful for animations that follow the scroll position as without the native driver, the animation will always run a frame behind the gesture due to the async nature of React Native.
+
+```jsx
+
+ {content}
+
+```
+
+You can see the native driver in action by running the [RNTester app](https://github.com/facebook/react-native/blob/master/packages/rn-tester/), then loading the Native Animated Example. You can also take a look at the [source code](https://github.com/facebook/react-native/blob/master/packages/rn-tester/js/examples/NativeAnimation/NativeAnimationsExample.js) to learn how these examples were produced.
+
+#### Caveats
+
+Not everything you can do with `Animated` is currently supported by the native driver. The main limitation is that you can only animate non-layout properties: things like `transform` and `opacity` will work, but Flexbox and position properties will not. When using `Animated.event`, it will only work with direct events and not bubbling events. This means it does not work with `PanResponder` but does work with things like `ScrollView#onScroll`.
+
+When an animation is running, it can prevent `VirtualizedList` components from rendering more rows. If you need to run a long or looping animation while the user is scrolling through a list, you can use `isInteraction: false` in your animation's config to prevent this issue.
+
+### Bear in mind
+
+While using transform styles such as `rotateY`, `rotateX`, and others ensure the transform style `perspective` is in place. At this time some animations may not render on Android without it. Example below.
+
+```jsx
+
+```
+
+### Additional examples
+
+The RNTester app has various examples of `Animated` in use:
+
+- [AnimatedGratuitousApp](https://github.com/facebook/react-native/tree/main/packages/rn-tester/js/examples/AnimatedGratuitousApp)
+- [NativeAnimationsExample](https://github.com/facebook/react-native/blob/main/packages/rn-tester/js/examples/NativeAnimation/NativeAnimationsExample.js)
+
+## `LayoutAnimation` API
+
+`LayoutAnimation` allows you to globally configure `create` and `update` animations that will be used for all views in the next render/layout cycle. This is useful for doing Flexbox layout updates without bothering to measure or calculate specific properties in order to animate them directly, and is especially useful when layout changes may affect ancestors, for example a "see more" expansion that also increases the size of the parent and pushes down the row below which would otherwise require explicit coordination between the components in order to animate them all in sync.
+
+Note that although `LayoutAnimation` is very powerful and can be quite useful, it provides much less control than `Animated` and other animation libraries, so you may need to use another approach if you can't get `LayoutAnimation` to do what you want.
+
+Note that in order to get this to work on **Android** you need to set the following flags via `UIManager`:
+
+```jsx
+UIManager.setLayoutAnimationEnabledExperimental &&
+ UIManager.setLayoutAnimationEnabledExperimental(true);
+```
+
+```SnackPlayer name=LayoutAnimations&supportedPlatforms=ios,android
+import React from 'react';
+import {
+ NativeModules,
+ LayoutAnimation,
+ Text,
+ TouchableOpacity,
+ StyleSheet,
+ View,
+} from 'react-native';
+
+const { UIManager } = NativeModules;
+
+UIManager.setLayoutAnimationEnabledExperimental &&
+ UIManager.setLayoutAnimationEnabledExperimental(true);
+
+export default class App extends React.Component {
+ state = {
+ w: 100,
+ h: 100,
+ };
+
+ _onPress = () => {
+ // Animate the update
+ LayoutAnimation.spring();
+ this.setState({w: this.state.w + 15, h: this.state.h + 15})
+ }
+
+ render() {
+ return (
+
+
+
+
+ Press me!
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: 'center',
+ justifyContent: 'center',
+ },
+ box: {
+ width: 200,
+ height: 200,
+ backgroundColor: 'red',
+ },
+ button: {
+ backgroundColor: 'black',
+ paddingHorizontal: 20,
+ paddingVertical: 15,
+ marginTop: 15,
+ },
+ buttonText: {
+ color: '#fff',
+ fontWeight: 'bold',
+ },
+});
+```
+
+This example uses a preset value, you can customize the animations as you need, see [LayoutAnimation.js](https://github.com/facebook/react-native/blob/master/Libraries/LayoutAnimation/LayoutAnimation.js) for more information.
+
+## Additional notes
+
+### `requestAnimationFrame`
+
+`requestAnimationFrame` is a polyfill from the browser that you might be familiar with. It accepts a function as its only argument and calls that function before the next repaint. It is an essential building block for animations that underlies all of the JavaScript-based animation APIs. In general, you shouldn't need to call this yourself - the animation APIs will manage frame updates for you.
+
+### `setNativeProps`
+
+As mentioned [in the Direct Manipulation section](direct-manipulation), `setNativeProps` allows us to modify properties of native-backed components (components that are actually backed by native views, unlike composite components) directly, without having to `setState` and re-render the component hierarchy.
+
+We could use this in the Rebound example to update the scale - this might be helpful if the component that we are updating is deeply nested and hasn't been optimized with `shouldComponentUpdate`.
+
+If you find your animations with dropping frames (performing below 60 frames per second), look into using `setNativeProps` or `shouldComponentUpdate` to optimize them. Or you could run the animations on the UI thread rather than the JavaScript thread [with the useNativeDriver option](/blog/2017/02/14/using-native-driver-for-animated). You may also want to defer any computationally intensive work until after animations are complete, using the [InteractionManager](interactionmanager). You can monitor the frame rate by using the In-App Developer Menu "FPS Monitor" tool.
diff --git a/website/versioned_docs/version-0.70/app-extensions.md b/website/versioned_docs/version-0.70/app-extensions.md
new file mode 100644
index 00000000000..809cacfe1dd
--- /dev/null
+++ b/website/versioned_docs/version-0.70/app-extensions.md
@@ -0,0 +1,26 @@
+---
+id: app-extensions
+title: App Extensions
+---
+
+App extensions let you provide custom functionality and content outside of your main app. There are different types of app extensions on iOS, and they are all covered in the [App Extension Programming Guide](https://developer.apple.com/library/content/documentation/General/Conceptual/ExtensibilityPG/index.html#//apple_ref/doc/uid/TP40014214-CH20-SW1). In this guide, we'll briefly cover how you may take advantage of app extensions on iOS.
+
+## Memory use in extensions
+
+As these extensions are loaded outside of the regular app sandbox, it's highly likely that several of these app extensions will be loaded simultaneously. As you might expect, these extensions have small memory usage limits. Keep these in mind when developing your app extensions. It's always highly recommended to test your application on an actual device, and more so when developing app extensions: too frequently, developers find that their extension works fine in the iOS Simulator, only to get user reports that their extension is not loading on actual devices.
+
+We highly recommend that you watch Conrad Kramer's talk on [Memory Use in Extensions](https://www.youtube.com/watch?v=GqXMqn6MXrM) to learn more about this topic.
+
+### Today widget
+
+The memory limit of a Today widget is 16 MB. As it happens, Today widget implementations using React Native may work unreliably because the memory usage tends to be too high. You can tell if your Today widget is exceeding the memory limit if it yields the message 'Unable to Load':
+
+
+
+Always make sure to test your app extensions in a real device, but be aware that this may not be sufficient, especially when dealing with Today widgets. Debug-configured builds are more likely to exceed the memory limits, while release-configured builds don't fail right away. We highly recommend that you use [Xcode's Instruments](https://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/index.html) to analyze your real world memory usage, as it's very likely that your release-configured build is very close to the 16 MB limit. In situations like these, you can quickly go over the 16 MB limit by performing common operations, such as fetching data from an API.
+
+To experiment with the limits of React Native Today widget implementations, try extending the example project in [react-native-today-widget](https://github.com/matejkriz/react-native-today-widget/).
+
+### Other app extensions
+
+Other types of app extensions have greater memory limits than the Today widget. For instance, Custom Keyboard extensions are limited to 48 MB, and Share extensions are limited to 120 MB. Implementing such app extensions with React Native is more viable. One proof of concept example is [react-native-ios-share-extension](https://github.com/andrewsardone/react-native-ios-share-extension).
diff --git a/website/versioned_docs/version-0.70/appearance.md b/website/versioned_docs/version-0.70/appearance.md
new file mode 100644
index 00000000000..8e742ba0821
--- /dev/null
+++ b/website/versioned_docs/version-0.70/appearance.md
@@ -0,0 +1,90 @@
+---
+id: appearance
+title: Appearance
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+```jsx
+import { Appearance } from 'react-native';
+```
+
+The `Appearance` module exposes information about the user's appearance preferences, such as their preferred color scheme (light or dark).
+
+#### Developer notes
+
+
+
+
+
+> The `Appearance` API is inspired by the [Media Queries draft](https://drafts.csswg.org/mediaqueries-5/) from the W3C. The color scheme preference is modeled after the [`prefers-color-scheme` CSS media feature](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme).
+
+
+
+
+> The color scheme preference will map to the user's Light or [Dark theme](https://developer.android.com/guide/topics/ui/look-and-feel/darktheme) preference on Android 10 (API level 29) devices and higher.
+
+
+
+
+> The color scheme preference will map to the user's Light or [Dark Mode](https://developer.apple.com/design/human-interface-guidelines/ios/visual-design/dark-mode/) preference on iOS 13 devices and higher.
+
+
+
+
+## Example
+
+You can use the `Appearance` module to determine if the user prefers a dark color scheme:
+
+```jsx
+const colorScheme = Appearance.getColorScheme();
+if (colorScheme === 'dark') {
+ // Use dark color scheme
+}
+```
+
+Although the color scheme is available immediately, this may change (e.g. scheduled color scheme change at sunrise or sunset). Any rendering logic or styles that depend on the user preferred color scheme should try to call this function on every render, rather than caching the value. For example, you may use the [`useColorScheme`](usecolorscheme) React hook as it provides and subscribes to color scheme updates, or you may use inline styles rather than setting a value in a `StyleSheet`.
+
+---
+
+# Reference
+
+## Methods
+
+### `getColorScheme()`
+
+```jsx
+static getColorScheme()
+```
+
+Indicates the current user preferred color scheme. The value may be updated later, either through direct user action (e.g. theme selection in device settings) or on a schedule (e.g. light and dark themes that follow the day/night cycle).
+
+Supported color schemes:
+
+- `light`: The user prefers a light color theme.
+- `dark`: The user prefers a dark color theme.
+- null: The user has not indicated a preferred color theme.
+
+See also: `useColorScheme` hook.
+
+> Note: `getColorScheme()` will always return `light` when debugging with Chrome.
+
+---
+
+### `addChangeListener()`
+
+```jsx
+static addChangeListener(listener)
+```
+
+Add an event handler that is fired when appearance preferences change.
+
+---
+
+### `removeChangeListener()`
+
+```jsx
+static removeChangeListener(listener)
+```
+
+> **Deprecated.** Use the `remove()` method on the event subscription returned by [`addChangeListener()`](#addchangelistener).
diff --git a/website/versioned_docs/version-0.70/appregistry.md b/website/versioned_docs/version-0.70/appregistry.md
new file mode 100644
index 00000000000..0adf5b64772
--- /dev/null
+++ b/website/versioned_docs/version-0.70/appregistry.md
@@ -0,0 +1,392 @@
+---
+id: appregistry
+title: AppRegistry
+---
+
+
+
Project with Native Code Required
+
+ If you are using the managed Expo workflow there is only ever one entry component registered with AppRegistry and it is handled automatically (or through registerRootComponent). You do not need to use this API.
+
+
+
+`AppRegistry` is the JS entry point to running all React Native apps. App root components should register themselves with `AppRegistry.registerComponent`, then the native system can load the bundle for the app and then actually run the app when it's ready by invoking `AppRegistry.runApplication`.
+
+```jsx
+import { Text, AppRegistry } from 'react-native';
+
+const App = (props) => (
+
+ App1
+
+);
+
+AppRegistry.registerComponent('Appname', () => App);
+```
+
+To "stop" an application when a view should be destroyed, call `AppRegistry.unmountApplicationComponentAtRootTag` with the tag that was passed into `runApplication`. These should always be used as a pair.
+
+`AppRegistry` should be required early in the `require` sequence to make sure the JS execution environment is setup before other modules are required.
+
+---
+
+# Reference
+
+## Methods
+
+### `cancelHeadlessTask()`
+
+```jsx
+static cancelHeadlessTask(taskId, taskKey)
+```
+
+Only called from native code. Cancels a headless task.
+
+**Parameters:**
+
+| Name | Type | Description |
+| ------------------------------------------------------------ | ------ | --------------------------------------------------------------------------------------- |
+| taskId
Required
| number | The native id for this task instance that was used when `startHeadlessTask` was called. |
+| taskKey
Required
| string | The key for the task that was used when `startHeadlessTask` was called. |
+
+---
+
+### `enableArchitectureIndicator()`
+
+```jsx
+static enableArchitectureIndicator(enabled)
+```
+
+**Parameters:**
+
+| Name | Type |
+| ------------------------------------------------------------ | ------- |
+| enabled
| string |
+
+---
+
+### `getSectionKeys()`
+
+```jsx
+static getSectionKeys()
+```
+
+Returns an array of strings.
+
+---
+
+### `getSections()`
+
+```jsx
+static getSections()
+```
+
+Returns a [Runnables](appregistry#runnables) object.
+
+---
+
+### `registerCancellableHeadlessTask()`
+
+```jsx
+static registerCancellableHeadlessTask(taskKey, taskProvider, taskCancelProvider)
+```
+
+Register a headless task which can be cancelled. A headless task is a bit of code that runs without a UI.
+
+**Parameters:**
+
+| Name | Type | Description |
+| ------------------------------------------------------------------------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| taskKey
Required
| string | The native id for this task instance that was used when startHeadlessTask was called. |
+| taskProvider
Required
| [TaskProvider](appregistry#taskprovider) | A promise returning function that takes some data passed from the native side as the only argument. When the promise is resolved or rejected the native side is notified of this event and it may decide to destroy the JS context. |
+| taskCancelProvider
Required
| [TaskCancelProvider](appregistry#taskcancelprovider) | a void returning function that takes no arguments; when a cancellation is requested, the function being executed by taskProvider should wrap up and return ASAP. |
+
+---
+
+### `registerComponent()`
+
+```jsx
+static registerComponent(appKey, componentProvider, section?)
+```
+
+**Parameters:**
+
+| Name | Type |
+| ---------------------------------------------------------------------- | ----------------- |
+| appKey
| [AppConfig](appregistry#appconfig) |
+
+---
+
+### `registerHeadlessTask()`
+
+```jsx
+static registerHeadlessTask(taskKey, taskProvider)
+```
+
+Register a headless task. A headless task is a bit of code that runs without a UI.
+
+This is a way to run tasks in JavaScript while your app is in the background. It can be used, for example, to sync fresh data, handle push notifications, or play music.
+
+**Parameters:**
+
+| Name | Type | Description |
+| --------------------------------------------------------------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| taskKey
Required
| string | The native id for this task instance that was used when startHeadlessTask was called. |
+| taskProvider
Required
| [TaskProvider](appregistry#taskprovider) | A promise returning function that takes some data passed from the native side as the only argument. When the promise is resolved or rejected the native side is notified of this event and it may decide to destroy the JS context. |
+
+---
+
+### `registerRunnable()`
+
+```jsx
+static registerRunnable(appKey, run)
+```
+
+**Parameters:**
+
+| Name | Type |
+| ----------------------------------------------------------- | -------- |
+| appKey
Required
| string |
+| run
Required
| function |
+
+---
+
+### `registerSection()`
+
+```jsx
+static registerSection(appKey, component)
+```
+
+**Parameters:**
+
+| Name | Type |
+| -------------------------------------------------------------- | ----------------- |
+| appKey
Required
| string |
+| component
Required
| ComponentProvider |
+
+---
+
+### `runApplication()`
+
+```jsx
+static runApplication(appKey, appParameters)
+```
+
+Loads the JavaScript bundle and runs the app.
+
+**Parameters:**
+
+| Name | Type |
+| ------------------------------------------------------------------ | ------ |
+| appKey
Required
| string |
+| appParameters
Required
| any |
+
+---
+
+### `setComponentProviderInstrumentationHook()`
+
+```jsx
+static setComponentProviderInstrumentationHook(hook)
+```
+
+**Parameters:**
+
+| Name | Type |
+| --------------------------------------------------------- | -------- |
+| hook
Required
| function |
+
+A valid `hook` function accepts the following as arguments:
+
+| Name | Type |
+| ---------------------------------------------------------------------------- | ------------------ |
+| component
Required
| ComponentProvider |
+| scopedPerformanceLogger
Required
| IPerformanceLogger |
+
+The function must also return a React Component.
+
+---
+
+### `setWrapperComponentProvider()`
+
+```jsx
+static setWrapperComponentProvider(provider)
+```
+
+**Parameters:**
+
+| Name | Type |
+| ------------------------------------------------------------- | ----------------- |
+| provider
Required
| ComponentProvider |
+
+---
+
+### `startHeadlessTask()`
+
+```jsx
+static startHeadlessTask(taskId, taskKey, data)
+```
+
+Only called from native code. Starts a headless task.
+
+**Parameters:**
+
+| Name | Type | Description |
+| ------------------------------------------------------------ | ------ | -------------------------------------------------------------------- |
+| taskId
Required
| number | The native id for this task instance to keep track of its execution. |
+| taskKey
Required
| string | The key for the task to start. |
+| data
Required
| any | The data to pass to the task. |
+
+---
+
+### `unmountApplicationComponentAtRootTag()`
+
+```jsx
+static unmountApplicationComponentAtRootTag(rootTag)
+```
+
+Stops an application when a view should be destroyed.
+
+**Parameters:**
+
+| Name | Type |
+| ------------------------------------------------------------ | ------ |
+| rootTag
Required
| number |
+
+## Type Definitions
+
+### AppConfig
+
+Application configuration for the `registerConfig` method.
+
+| Type |
+| ------ |
+| object |
+
+**Properties:**
+
+| Name | Type |
+| ----------------------------------------------------------- | ----------------- |
+| appKey
Required
| string |
+| component | ComponentProvider |
+| run | function |
+| section | boolean |
+
+> **Note:** Every config is expected to set either `component` or `run` function.
+
+### Registry
+
+| Type |
+| ------ |
+| object |
+
+**Properties:**
+
+| Name | Type |
+| --------- | ------------------------------------------ |
+| runnables | array of [Runnables](appregistry#runnable) |
+| sections | array of strings |
+
+### Runnable
+
+| Type |
+| ------ |
+| object |
+
+**Properties:**
+
+| Name | Type |
+| --------- | ----------------- |
+| component | ComponentProvider |
+| run | function |
+
+### Runnables
+
+An object with key of `appKey` and value of type of [`Runnable`](appregistry#runnable).
+
+| Type |
+| ------ |
+| object |
+
+### Task
+
+A `Task` is a function that accepts any data as argument and returns a Promise that resolves to `undefined`.
+
+| Type |
+| -------- |
+| function |
+
+### TaskCanceller
+
+A `TaskCanceller` is a function that accepts no argument and returns void.
+
+| Type |
+| -------- |
+| function |
+
+### TaskCancelProvider
+
+A valid `TaskCancelProvider` is a function that returns a [`TaskCanceller`](appregistry#taskcanceller).
+
+| Type |
+| -------- |
+| function |
+
+### TaskProvider
+
+A valid `TaskProvider` is a function that returns a [`Task`](appregistry#task).
+
+| Type |
+| -------- |
+| function |
diff --git a/website/versioned_docs/version-0.70/appstate.md b/website/versioned_docs/version-0.70/appstate.md
new file mode 100644
index 00000000000..9ba3b7d3533
--- /dev/null
+++ b/website/versioned_docs/version-0.70/appstate.md
@@ -0,0 +1,182 @@
+---
+id: appstate
+title: AppState
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+`AppState` can tell you if the app is in the foreground or background, and notify you when the state changes.
+
+AppState is frequently used to determine the intent and proper behavior when handling push notifications.
+
+### App States
+
+- `active` - The app is running in the foreground
+- `background` - The app is running in the background. The user is either:
+ - in another app
+ - on the home screen
+ - [Android] on another `Activity` (even if it was launched by your app)
+- [iOS] `inactive` - This is a state that occurs when transitioning between foreground & background, and during periods of inactivity such as entering the multitasking view, opening the Notification Center or in the event of an incoming call.
+
+For more information, see [Apple's documentation](https://developer.apple.com/documentation/uikit/app_and_scenes/managing_your_app_s_life_cycle)
+
+## Basic Usage
+
+To see the current state, you can check `AppState.currentState`, which will be kept up-to-date. However, `currentState` will be null at launch while `AppState` retrieves it over the bridge.
+
+
+
+
+```SnackPlayer name=AppState%20Function%20Component%20Example
+import React, { useRef, useState, useEffect } from "react";
+import { AppState, StyleSheet, Text, View } from "react-native";
+
+const AppStateExample = () => {
+ const appState = useRef(AppState.currentState);
+ const [appStateVisible, setAppStateVisible] = useState(appState.current);
+
+ useEffect(() => {
+ const subscription = AppState.addEventListener("change", nextAppState => {
+ if (
+ appState.current.match(/inactive|background/) &&
+ nextAppState === "active"
+ ) {
+ console.log("App has come to the foreground!");
+ }
+
+ appState.current = nextAppState;
+ setAppStateVisible(appState.current);
+ console.log("AppState", appState.current);
+ });
+
+ return () => {
+ subscription.remove();
+ };
+ }, []);
+
+ return (
+
+ Current state is: {appStateVisible}
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "center",
+ alignItems: "center",
+ },
+});
+
+export default AppStateExample;
+```
+
+If you don't want to see the AppState update from `active` to `inactive` on iOS you can remove the state variable and use the `appState.current` value.
+
+
+
+
+```SnackPlayer name=AppState%20Class%20Component%20Example
+import React, { Component } from "react";
+import { AppState, StyleSheet, Text, View } from "react-native";
+
+class AppStateExample extends Component {
+ state = {
+ appState: AppState.currentState
+ };
+
+ componentDidMount() {
+ this.appStateSubscription = AppState.addEventListener(
+ "change",
+ nextAppState => {
+ if (
+ this.state.appState.match(/inactive|background/) &&
+ nextAppState === "active"
+ ) {
+ console.log("App has come to the foreground!");
+ }
+ this.setState({ appState: nextAppState });
+ }
+ );
+ }
+
+ componentWillUnmount() {
+ this.appStateSubscription.remove();
+ }
+
+ render() {
+ return (
+
+ Current state is: {this.state.appState}
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: "center",
+ alignItems: "center"
+ }
+});
+
+export default AppStateExample;
+```
+
+
+
+
+This example will only ever appear to say "Current state is: active" because the app is only visible to the user when in the `active` state, and the null state will happen only momentarily. If you want to experiment with the code we recommend to use your own device instead of embedded preview.
+
+---
+
+# Reference
+
+## Events
+
+### `change`
+
+This event is received when the app state has changed. The listener is called with one of [the current app state values](appstate#app-states).
+
+### `memoryWarning`
+
+This event is used in the need of throwing memory warning or releasing it.
+
+### `focus`
Android
+
+Received when the app gains focus (the user is interacting with the app).
+
+### `blur`
Android
+
+Received when the user is not actively interacting with the app. Useful in situations when the user pulls down the [notification drawer](https://developer.android.com/guide/topics/ui/notifiers/notifications#bar-and-drawer). `AppState` won't change but the `blur` event will get fired.
+
+## Methods
+
+### `addEventListener()`
+
+```jsx
+addEventListener(eventType, listener);
+```
+
+Sets up a function that will be called whenever the specified event type on AppState occurs. Valid values for `eventType` are
+[listed above](#events). Returns the `EventSubscription`.
+
+---
+
+### `removeEventListener()`
+
+```jsx
+removeEventListener(eventType, listener);
+```
+
+> **Deprecated.** Use the `remove()` method on the `EventSubscription` returned by [`addEventListener()`](#addeventlistener).
+
+## Properties
+
+### `currentState`
+
+```jsx
+AppState.currentState;
+```
diff --git a/website/versioned_docs/version-0.70/asyncstorage.md b/website/versioned_docs/version-0.70/asyncstorage.md
new file mode 100644
index 00000000000..04e507f8b57
--- /dev/null
+++ b/website/versioned_docs/version-0.70/asyncstorage.md
@@ -0,0 +1,365 @@
+---
+id: asyncstorage
+title: '🚧 AsyncStorage'
+---
+
+> **Deprecated.** Use one of the [community packages](https://reactnative.directory/?search=storage) instead.
+
+`AsyncStorage` is an unencrypted, asynchronous, persistent, key-value storage system that is global to the app. It should be used instead of LocalStorage.
+
+It is recommended that you use an abstraction on top of `AsyncStorage` instead of `AsyncStorage` directly for anything more than light usage since it operates globally.
+
+On iOS, `AsyncStorage` is backed by native code that stores small values in a serialized dictionary and larger values in separate files. On Android, `AsyncStorage` will use either [RocksDB](http://rocksdb.org/) or SQLite based on what is available.
+
+The `AsyncStorage` JavaScript code is a facade that provides a clear JavaScript API, real `Error` objects, and non-multi functions. Each method in the API returns a `Promise` object.
+
+Importing the `AsyncStorage` library:
+
+```jsx
+import { AsyncStorage } from 'react-native';
+```
+
+Persisting data:
+
+```jsx
+_storeData = async () => {
+ try {
+ await AsyncStorage.setItem(
+ '@MySuperStore:key',
+ 'I like to save it.'
+ );
+ } catch (error) {
+ // Error saving data
+ }
+};
+```
+
+Fetching data:
+
+```jsx
+_retrieveData = async () => {
+ try {
+ const value = await AsyncStorage.getItem('TASKS');
+ if (value !== null) {
+ // We have data!!
+ console.log(value);
+ }
+ } catch (error) {
+ // Error retrieving data
+ }
+};
+```
+
+---
+
+# Reference
+
+## Methods
+
+### `getItem()`
+
+```jsx
+static getItem(key: string, [callback]: ?(error: ?Error, result: ?string) => void)
+```
+
+Fetches an item for a `key` and invokes a callback upon completion. Returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | ------------------------------------------- | -------- | ----------------------------------------------------------------- |
+| key | string | Yes | Key of the item to fetch. |
+| callback | `?(error: ?Error, result: ?string) => void` | No | Function that will be called with a result if found or any error. |
+
+---
+
+### `setItem()`
+
+```jsx
+static setItem(key: string, value: string, [callback]: ?(error: ?Error) => void)
+```
+
+Sets the value for a `key` and invokes a callback upon completion. Returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------------------------- | -------- | -------------------------------------------- |
+| key | string | Yes | Key of the item to set. |
+| value | string | Yes | Value to set for the `key`. |
+| callback | `?(error: ?Error) => void` | No | Function that will be called with any error. |
+
+---
+
+### `removeItem()`
+
+```jsx
+static removeItem(key: string, [callback]: ?(error: ?Error) => void)
+```
+
+Removes an item for a `key` and invokes a callback upon completion. Returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------------------------- | -------- | -------------------------------------------- |
+| key | string | Yes | Key of the item to remove. |
+| callback | `?(error: ?Error) => void` | No | Function that will be called with any error. |
+
+---
+
+### `mergeItem()`
+
+```jsx
+static mergeItem(key: string, value: string, [callback]: ?(error: ?Error) => void)
+```
+
+Merges an existing `key` value with an input value, assuming both values are stringified JSON. Returns a `Promise` object.
+
+**NOTE:** This is not supported by all native implementations.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------------------------- | -------- | -------------------------------------------- |
+| key | string | Yes | Key of the item to modify. |
+| value | string | Yes | New value to merge for the `key`. |
+| callback | `?(error: ?Error) => void` | No | Function that will be called with any error. |
+
+Example:
+
+```jsx
+let UID123_object = {
+ name: 'Chris',
+ age: 30,
+ traits: { hair: 'brown', eyes: 'brown' }
+};
+// You only need to define what will be added or updated
+let UID123_delta = {
+ age: 31,
+ traits: { eyes: 'blue', shoe_size: 10 }
+};
+
+AsyncStorage.setItem(
+ 'UID123',
+ JSON.stringify(UID123_object),
+ () => {
+ AsyncStorage.mergeItem(
+ 'UID123',
+ JSON.stringify(UID123_delta),
+ () => {
+ AsyncStorage.getItem('UID123', (err, result) => {
+ console.log(result);
+ });
+ }
+ );
+ }
+);
+
+// Console log result:
+// => {'name':'Chris','age':31,'traits':
+// {'shoe_size':10,'hair':'brown','eyes':'blue'}}
+```
+
+---
+
+### `clear()`
+
+```jsx
+static clear([callback]: ?(error: ?Error) => void)
+```
+
+Erases _all_ `AsyncStorage` for all clients, libraries, etc. You probably don't want to call this; use `removeItem` or `multiRemove` to clear only your app's keys. Returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | -------------------------- | -------- | -------------------------------------------- |
+| callback | `?(error: ?Error) => void` | No | Function that will be called with any error. |
+
+---
+
+### `getAllKeys()`
+
+```jsx
+static getAllKeys([callback]: ?(error: ?Error, keys: ?Array) => void)
+```
+
+Gets _all_ keys known to your app; for all callers, libraries, etc. Returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | ------------------------------------------------ | -------- | --------------------------------------------------------------- |
+| callback | `?(error: ?Error, keys: ?Array) => void` | No | Function that will be called with all keys found and any error. |
+
+---
+
+### `flushGetRequests()`
+
+```jsx
+static flushGetRequests(): [object Object]
+```
+
+Flushes any pending requests using a single batch call to get the data.
+
+---
+
+### `multiGet()`
+
+```jsx
+static multiGet(keys: Array, [callback]: ?(errors: ?Array, result: ?Array>) => void)
+```
+
+This allows you to batch the fetching of items given an array of `key` inputs. Your callback will be invoked with an array of corresponding key-value pairs found:
+
+```
+multiGet(['k1', 'k2'], cb) -> cb([['k1', 'val1'], ['k2', 'val2']])
+```
+
+The method returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | ----------------------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------- |
+| keys | `Array` | Yes | Array of key for the items to get. |
+| callback | `?(errors: ?Array, result: ?Array>) => void` | No | Function that will be called with a key-value array of the results, plus an array of any key-specific errors found. |
+
+Example:
+
+```jsx
+AsyncStorage.getAllKeys((err, keys) => {
+ AsyncStorage.multiGet(keys, (err, stores) => {
+ stores.map((result, i, store) => {
+ // get at each store's key/value so you can work with it
+ let key = store[i][0];
+ let value = store[i][1];
+ });
+ });
+});
+```
+
+---
+
+### `multiSet()`
+
+```jsx
+static multiSet(keyValuePairs: Array>, [callback]: ?(errors: ?Array) => void)
+```
+
+Use this as a batch operation for storing multiple key-value pairs. When the operation completes you'll get a single callback with any errors:
+
+```
+multiSet([['k1', 'val1'], ['k2', 'val2']], cb);
+```
+
+The method returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ------------- | ---------------------------------- | -------- | ---------------------------------------------------------------------------- |
+| keyValuePairs | `Array>` | Yes | Array of key-value array for the items to set. |
+| callback | `?(errors: ?Array) => void` | No | Function that will be called with an array of any key-specific errors found. |
+
+---
+
+### `multiRemove()`
+
+```jsx
+static multiRemove(keys: Array, [callback]: ?(errors: ?Array) => void)
+```
+
+Call this to batch the deletion of all keys in the `keys` array. Returns a `Promise` object.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| -------- | ---------------------------------- | -------- | ----------------------------------------------------------------------- |
+| keys | `Array` | Yes | Array of key for the items to delete. |
+| callback | `?(errors: ?Array) => void` | No | Function that will be called an array of any key-specific errors found. |
+
+Example:
+
+```jsx
+let keys = ['k1', 'k2'];
+AsyncStorage.multiRemove(keys, (err) => {
+ // keys k1 & k2 removed, if they existed
+ // do most stuff after removal (if you want)
+});
+```
+
+---
+
+### `multiMerge()`
+
+```jsx
+static multiMerge(keyValuePairs: Array>, [callback]: ?(errors: ?Array) => void)
+```
+
+Batch operation to merge in existing and new values for a given set of keys. This assumes that the values are stringified JSON. Returns a `Promise` object.
+
+**NOTE**: This is not supported by all native implementations.
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ------------- | ---------------------------------- | -------- | ---------------------------------------------------------------------------- |
+| keyValuePairs | `Array>` | Yes | Array of key-value array for the items to merge. |
+| callback | `?(errors: ?Array) => void` | No | Function that will be called with an array of any key-specific errors found. |
+
+Example:
+
+```jsx
+// first user, initial values
+let UID234_object = {
+ name: 'Chris',
+ age: 30,
+ traits: { hair: 'brown', eyes: 'brown' }
+};
+
+// first user, delta values
+let UID234_delta = {
+ age: 31,
+ traits: { eyes: 'blue', shoe_size: 10 }
+};
+
+// second user, initial values
+let UID345_object = {
+ name: 'Marge',
+ age: 25,
+ traits: { hair: 'blonde', eyes: 'blue' }
+};
+
+// second user, delta values
+let UID345_delta = {
+ age: 26,
+ traits: { eyes: 'green', shoe_size: 6 }
+};
+
+let multi_set_pairs = [
+ ['UID234', JSON.stringify(UID234_object)],
+ ['UID345', JSON.stringify(UID345_object)]
+];
+let multi_merge_pairs = [
+ ['UID234', JSON.stringify(UID234_delta)],
+ ['UID345', JSON.stringify(UID345_delta)]
+];
+
+AsyncStorage.multiSet(multi_set_pairs, (err) => {
+ AsyncStorage.multiMerge(multi_merge_pairs, (err) => {
+ AsyncStorage.multiGet(['UID234', 'UID345'], (err, stores) => {
+ stores.map((result, i, store) => {
+ let key = store[i][0];
+ let val = store[i][1];
+ console.log(key, val);
+ });
+ });
+ });
+});
+
+// Console log results:
+// => UID234 {"name":"Chris","age":31,"traits":{"shoe_size":10,"hair":"brown","eyes":"blue"}}
+// => UID345 {"name":"Marge","age":26,"traits":{"shoe_size":6,"hair":"blonde","eyes":"green"}}
+```
diff --git a/website/versioned_docs/version-0.70/backhandler.md b/website/versioned_docs/version-0.70/backhandler.md
new file mode 100644
index 00000000000..f86a5730492
--- /dev/null
+++ b/website/versioned_docs/version-0.70/backhandler.md
@@ -0,0 +1,299 @@
+---
+id: backhandler
+title: BackHandler
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+The Backhandler API detects hardware button presses for back navigation, lets you register event listeners for the system's back action, and lets you control how your application responds. It is Android-only.
+
+The event subscriptions are called in reverse order (i.e. the last registered subscription is called first).
+
+- **If one subscription returns true,** then subscriptions registered earlier will not be called.
+- **If no subscription returns true or none are registered,** it programmatically invokes the default back button functionality to exit the app.
+
+> **Warning for modal users:** If your app shows an opened `Modal`, `BackHandler` will not publish any events ([see `Modal` docs](modal#onrequestclose)).
+
+## Pattern
+
+```jsx
+BackHandler.addEventListener('hardwareBackPress', function () {
+ /**
+ * this.onMainScreen and this.goBack are just examples,
+ * you need to use your own implementation here.
+ *
+ * Typically you would use the navigator here to go to the last state.
+ */
+
+ if (!this.onMainScreen()) {
+ this.goBack();
+ /**
+ * When true is returned the event will not be bubbled up
+ * & no other back action will execute
+ */
+ return true;
+ }
+ /**
+ * Returning false will let the event to bubble up & let other event listeners
+ * or the system's default back action to be executed.
+ */
+ return false;
+});
+```
+
+## Example
+
+The following example implements a scenario where you confirm if the user wants to exit the app:
+
+
+
+
+```SnackPlayer name=BackHandler&supportedPlatforms=android
+import React, { useEffect } from "react";
+import { Text, View, StyleSheet, BackHandler, Alert } from "react-native";
+
+const App = () => {
+ useEffect(() => {
+ const backAction = () => {
+ Alert.alert("Hold on!", "Are you sure you want to go back?", [
+ {
+ text: "Cancel",
+ onPress: () => null,
+ style: "cancel"
+ },
+ { text: "YES", onPress: () => BackHandler.exitApp() }
+ ]);
+ return true;
+ };
+
+ const backHandler = BackHandler.addEventListener(
+ "hardwareBackPress",
+ backAction
+ );
+
+ return () => backHandler.remove();
+ }, []);
+
+ return (
+
+ Click Back button!
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ text: {
+ fontSize: 18,
+ fontWeight: "bold"
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=BackHandler&supportedPlatforms=android
+import React, { Component } from "react";
+import { Text, View, StyleSheet, BackHandler, Alert } from "react-native";
+
+class App extends Component {
+ backAction = () => {
+ Alert.alert("Hold on!", "Are you sure you want to go back?", [
+ {
+ text: "Cancel",
+ onPress: () => null,
+ style: "cancel"
+ },
+ { text: "YES", onPress: () => BackHandler.exitApp() }
+ ]);
+ return true;
+ };
+
+ componentDidMount() {
+ this.backHandler = BackHandler.addEventListener(
+ "hardwareBackPress",
+ this.backAction
+ );
+ }
+
+ componentWillUnmount() {
+ this.backHandler.remove();
+ }
+
+ render() {
+ return (
+
+ Click Back button!
+
+ );
+ }
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ text: {
+ fontSize: 18,
+ fontWeight: "bold"
+ }
+});
+
+export default App;
+```
+
+
+
+
+`BackHandler.addEventListener` creates an event listener & returns a `NativeEventSubscription` object which should be cleared using `NativeEventSubscription.remove` method.
+
+Additionally `BackHandler.removeEventListener` can also be used to clear the event listener. Ensure the callback has the reference to the same function used in the `addEventListener` call as shown the following example ﹣
+
+
+
+
+```SnackPlayer name=BackHandler&supportedPlatforms=android
+import React, { useEffect } from "react";
+import { Text, View, StyleSheet, BackHandler, Alert } from "react-native";
+
+const App = () => {
+ const backAction = () => {
+ Alert.alert("Hold on!", "Are you sure you want to go back?", [
+ {
+ text: "Cancel",
+ onPress: () => null,
+ style: "cancel"
+ },
+ { text: "YES", onPress: () => BackHandler.exitApp() }
+ ]);
+ return true;
+ };
+
+ useEffect(() => {
+ BackHandler.addEventListener("hardwareBackPress", backAction);
+
+ return () =>
+ BackHandler.removeEventListener("hardwareBackPress", backAction);
+ }, []);
+
+ return (
+
+ Click Back button!
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ text: {
+ fontSize: 18,
+ fontWeight: "bold"
+ }
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=BackHandler&supportedPlatforms=android
+import React, { Component } from "react";
+import { Text, View, StyleSheet, BackHandler, Alert } from "react-native";
+
+class App extends Component {
+ backAction = () => {
+ Alert.alert("Hold on!", "Are you sure you want to go back?", [
+ {
+ text: "Cancel",
+ onPress: () => null,
+ style: "cancel"
+ },
+ { text: "YES", onPress: () => BackHandler.exitApp() }
+ ]);
+ return true;
+ };
+
+ componentDidMount() {
+ BackHandler.addEventListener("hardwareBackPress", this.backAction);
+ }
+
+ componentWillUnmount() {
+ BackHandler.removeEventListener("hardwareBackPress", this.backAction);
+ }
+
+ render() {
+ return (
+
+ Click Back button!
+
+ );
+ }
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center"
+ },
+ text: {
+ fontSize: 18,
+ fontWeight: "bold"
+ }
+});
+
+export default App;
+```
+
+
+
+
+## Usage with React Navigation
+
+If you are using React Navigation to navigate across different screens, you can follow their guide on [Custom Android back button behaviour](https://reactnavigation.org/docs/custom-android-back-button-handling/)
+
+## Backhandler hook
+
+[React Native Hooks](https://github.com/react-native-community/hooks#usebackhandler) has a nice `useBackHandler` hook which will simplify the process of setting up event listeners.
+
+---
+
+# Reference
+
+## Methods
+
+### `addEventListener()`
+
+```jsx
+static addEventListener(eventName, handler)
+```
+
+---
+
+### `exitApp()`
+
+```jsx
+static exitApp()
+```
+
+---
+
+### `removeEventListener()`
+
+```jsx
+static removeEventListener(eventName, handler)
+```
diff --git a/website/versioned_docs/version-0.70/build-speed.md b/website/versioned_docs/version-0.70/build-speed.md
new file mode 100644
index 00000000000..7cbcacb390c
--- /dev/null
+++ b/website/versioned_docs/version-0.70/build-speed.md
@@ -0,0 +1,235 @@
+---
+id: build-speed
+title: Speeding up your Build phase
+---
+
+Building your React Native app could be **expensive** and take several minutes of developers time.
+This can be problematic as your project grows and generally in bigger organizations with multiple React Native developers.
+
+With [the New React Native Architecture](/docs/next/new-architecture-app-modules-android), this problem is becoming more critical
+as you might have to compile some native C++ code in your project with the Android NDK in addition to the native code already necessary for the iOS and Android platforms.
+
+To mitigate this performance hit, this page shares some suggestions on how to **improve your build time**.
+
+## Build only one ABI during development (Android-only)
+
+When building your android app locally, by default you build all the 4 [Application Binary Interfaces (ABIs)](https://developer.android.com/ndk/guides/abis) : `armeabi-v7a`, `arm64-v8a`, `x86` & `x86_64`.
+
+However, you probably don't need to build all of them if you're building locally and testing your emulator or on a physical device.
+
+This should reduce your build time by a **~75% factor**.
+
+If you're using the React Native CLI, you can use the `--active-arch-only` flag together with the `run-android` command.
+This flag will make sure the correct ABI is picked up from either the running emulator or the plugged in phone.
+To confirm that this approach is working fine, you'll see a message like `info Detected architectures arm64-v8a` on console.
+
+```
+$ yarn react-native run-android --active-arch-only
+
+[ ... ]
+info Running jetifier to migrate libraries to AndroidX. You can disable it using "--no-jetifier" flag.
+Jetifier found 1037 file(s) to forward-jetify. Using 32 workers...
+info JS server already running.
+info Detected architectures arm64-v8a
+info Installing the app...
+```
+
+This mechanism relies on the `reactNativeArchitectures` Gradle property.
+
+Therefore, if you're building directly with Gradle from the command line and without the CLI, you can specify the ABI you want to build as follows:
+
+```
+$ ./gradlew :app:assembleDebug -PreactNativeArchitectures=x86,x86_64
+```
+
+This can be useful if you wish to build your Android App on a CI and use a matrix to parallelize the build of the different architectures.
+
+If you wish, you can also override this value locally, using the `gradle.properties` file you have in the [top-level folder](https://github.com/facebook/react-native/blob/19cf70266eb8ca151aa0cc46ac4c09cb987b2ceb/template/android/gradle.properties#L30-L33) of your project:
+
+```
+# Use this property to specify which architecture you want to build.
+# You can also override it from the CLI using
+# ./gradlew -PreactNativeArchitectures=x86_64
+reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64
+```
+
+Once you build a **release version** of your app, don't forget to remove those flags as you want to build an apk/app bundle that works for all the ABIs and not only for the one you're using in your daily development workflow.
+
+## Use a compiler cache
+
+If you're running frequent native builds (either C++ or Objective-C), you might benefit from using a **compiler cache**.
+
+Specifically you can use two type of caches: local compiler caches and distributed compiler caches.
+
+### Local caches
+
+:::info
+The following instructions will work for **both Android & iOS**.
+If you're building only Android apps, you should be good to go.
+If you're building also iOS apps, please follow the instructions in the [XCode Specific Setup](#xcode-specific-setup) section below.
+:::
+
+We suggest to use [**ccache**](https://ccache.dev/) to cache the compilation of your native builds.
+Ccache works by wrapping the C++ compilers, storing the compilation results, and skipping the compilation
+if an intermediate compilation result was originally stored.
+
+To install it, you can follow the [official installation instructions](https://github.com/ccache/ccache/blob/master/doc/INSTALL.md).
+
+On Mac OS, we can install ccache with `brew install ccache`.
+Once installed you can configure it as follows to cache NDK compile results:
+
+```
+ln -s ccache /usr/local/bin/gcc
+ln -s ccache /usr/local/bin/g++
+ln -s ccache /usr/local/bin/cc
+ln -s ccache /usr/local/bin/c++
+ln -s ccache /usr/local/bin/clang
+ln -s ccache /usr/local/bin/clang++
+```
+
+This will create symbolic links to `ccache` inside the `/usr/local/bin/` which are called `gcc`, `g++`, and so on.
+
+This works as long as `/usr/local/bin/` comes first than `/usr/bin/` inside your `$PATH` variable, which is the default.
+
+You can verify that it works using the `which` command:
+
+```
+$ which gcc
+/usr/local/bin/gcc
+```
+
+If the results is `/usr/local/bin/gcc`, then you're effectively calling `ccache` which will wrap the `gcc` calls.
+
+:::caution
+Please note that this setup of `ccache` will affect all the compilations that you're running on your machine, not only those related to React Native. Use it at your own risk. If you're failing to install/compile other software, this might be the reason. If that is the case, you can remove the symlink you created with:
+
+```
+unlink /usr/local/bin/gcc
+unlink /usr/local/bin/g++
+unlink /usr/local/bin/cc
+unlink /usr/local/bin/c++
+unlink /usr/local/bin/clang
+unlink /usr/local/bin/clang++
+```
+
+to revert your machine to the original status and use the default compilers.
+:::
+
+You can then do two clean builds (e.g. on Android you can first run `yarn react-native run-android`, delete the `android/app/build` folder and run the first command once more). You will notice that the second build was way faster than the first one (it should take seconds rather than minutes).
+While building, you can verify that `ccache` works correctly and check the cache hits/miss rate `ccache -s`
+
+```
+$ ccache -s
+Summary:
+ Hits: 196 / 3068 (6.39 %)
+ Direct: 0 / 3068 (0.00 %)
+ Preprocessed: 196 / 3068 (6.39 %)
+ Misses: 2872
+ Direct: 3068
+ Preprocessed: 2872
+ Uncacheable: 1
+Primary storage:
+ Hits: 196 / 6136 (3.19 %)
+ Misses: 5940
+ Cache size (GB): 0.60 / 20.00 (3.00 %)
+```
+
+Note that `ccache` aggregates the stats over all builds. You can use `ccache --zero-stats` to reset them before a build to verify the cache-hit ratio.
+
+Should you need to wipe your cache, you can do so with `ccache --clear`
+
+#### XCode Specific Setup
+
+To make sure `ccache` works correctly with iOS and XCode, you need to follow a couple of extra steps:
+
+1. You must alter the way Xcode and `xcodebuild` call for the compiler command. By default they use _fully specified paths_ to the compiler binaries, so the symbolic links installed in `/usr/local/bin` will not be used. You may configure Xcode to use _relative_ names for the compilers using either of these two options:
+
+- environment variables prefixed on the command line if you use a direct command line: `CLANG=clang CLANGPLUSPLUS=clang++ LD=clang LDPLUSPLUS=clang++ xcodebuild `
+- A `post_install` section in your `ios/Podfile` that alters the compiler in your Xcode workspace during the `pod install` step:
+
+```ruby
+ post_install do |installer|
+ react_native_post_install(installer)
+
+ # ...possibly other post_install items here
+
+ installer.pods_project.targets.each do |target|
+ target.build_configurations.each do |config|
+ # Using the un-qualified names means you can swap in different implementations, for example ccache
+ config.build_settings["CC"] = "clang"
+ config.build_settings["LD"] = "clang"
+ config.build_settings["CXX"] = "clang++"
+ config.build_settings["LDPLUSPLUS"] = "clang++"
+ end
+ end
+
+ __apply_Xcode_12_5_M1_post_install_workaround(installer)
+ end
+```
+
+2. You need a ccache configuration that allows for a certain level of sloppiness and cache behavior such that ccache registers cache hits during Xcode compiles. The ccache configuration variables that are different from standard are as follows if configured by environment variable:
+
+```bash
+export CCACHE_SLOPPINESS=clang_index_store,file_stat_matches,include_file_ctime,include_file_mtime,ivfsoverlay,pch_defines,modules,system_headers,time_macros
+export CCACHE_FILECLONE=true
+export CCACHE_DEPEND=true
+export CCACHE_INODECACHE=true
+```
+
+The same may be configured in a `ccache.conf` file or any other mechanism ccache provides. More on this can be found in the [official ccache manual](https://ccache.dev/manual/4.3.html).
+
+#### Using this approach on a CI
+
+Ccache uses the `/Users/$USER/Library/Caches/ccache` folder on macOS to store the cache.
+Therefore you could save & restore the corresponding folder also on CI to speedup your builds.
+
+However, there are a couple of things to be aware:
+
+1. On CI, we recommend to do a full clean build, to avoid poisoned cache problems. If you follow the approach mentioned in the previous paragraph, you should be able to parallelize the native build on 4 different ABIs and you will most likely not need `ccache` on CI.
+
+2. `ccache` relies on timestamps to compute a cache hit. This doesn't work well on CI as files are re-downloaded at every CI run. To overcome this, you'll need to use the `compiler_check content` option which relies instead on [hashing the content of the file](https://ccache.dev/manual/4.3.html).
+
+### Distributed caches
+
+Similar to local caches, you might want to consider using a distributed cache for your native builds.
+This could be specifically useful in bigger organizations that are doing frequent native builds.
+
+We recommend to use [sccache](https://github.com/mozilla/sccache) to achieve this.
+We defer to the sccache [distributed compilation quickstart](https://github.com/mozilla/sccache/blob/main/docs/DistributedQuickstart.md) for instructions on how to setup and use this tool.
+
+## Troubleshooting
+
+Please find instructions on how to solve some of the most common build performance issue in this section.
+
+### Clean Android build with `--active-arch-only` is failing.
+
+If you're using the `--active-arch-only` flag on a clean Android build (e.g. after having cloned a project or after having created a new project) you might experience a build failures as follows:
+
+```
+Android NDK: ERROR:/.../android/app/src/main/jni/Android.mk:fb: LOCAL_SRC_FILES points to a missing file
+Android NDK: Check that /.../android/app/build/react-ndk/exported/armeabi-v7a/libfb.so exists or that its path is correct
+
+/.../Android/sdk/ndk/24.0.8079956/build/core/prebuilt-library.mk:51: *** Android NDK: Aborting . Stop.
+```
+
+To overcome this, you can either:
+
+1. Run a full build before without `--active-arch-only`. Subsequent builds with `--active-arch-only` will work correctly.
+2. Add an `abiFilter` block inside your `android/app/build.gradle` file [as follows](https://github.com/facebook/react-native/commit/5dff920177220ae5f4e37c662c63c27ebf696c83):
+
+```diff
+ android {
+ defaultConfig {
+
+ // ...
+
++ if (!enableSeparateBuildPerCPUArchitecture) {
++ ndk {
++ abiFilters (*reactNativeArchitectures())
++ }
++ }
+ }
+ }
+```
+
+Projects created with React Native 0.69 and subsequent versions already contain this fix.
diff --git a/website/versioned_docs/version-0.70/building-for-tv.md b/website/versioned_docs/version-0.70/building-for-tv.md
new file mode 100644
index 00000000000..f5e52bf1400
--- /dev/null
+++ b/website/versioned_docs/version-0.70/building-for-tv.md
@@ -0,0 +1,191 @@
+---
+id: building-for-tv
+title: Building For TV Devices
+hide_table_of_contents: true
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+TV devices support has been implemented with the intention of making existing React Native applications work on Apple TV and Android TV, with few or no changes needed in the JavaScript code for the applications.
+
+
+
+
+
+## Build changes
+
+- _Native layer_: To run React Native project on Android TV make sure to make the following changes to `AndroidManifest.xml`
+
+```xml
+
+
+ ...
+
+ ...
+
+
+
+ ...
+
+```
+
+- _JavaScript layer_: Support for Android TV has been added to `Platform.android.js`. You can check whether code is running on Android TV by doing
+
+```js
+var Platform = require('Platform');
+var running_on_android_tv = Platform.isTV;
+```
+
+## Code changes
+
+- _Access to touchable controls_: When running on Android TV the Android framework will automatically apply a directional navigation scheme based on relative position of focusable elements in your views. The `Touchable` mixin has code added to detect focus changes and use existing methods to style the components properly and initiate the proper actions when the view is selected using the TV remote, so `TouchableWithoutFeedback`, `TouchableHighlight`, `TouchableOpacity` and `TouchableNativeFeedback` will work as expected. In particular:
+
+ - `onFocus` will be executed when the touchable view goes into focus
+ - `onBlur` will be executed when the touchable view goes out of focus
+ - `onPress` will be executed when the touchable view is actually selected by pressing the "select" button on the TV remote.
+
+- _TV remote/keyboard input_: A new native class, `ReactAndroidTVRootViewHelper`, sets up key events handlers for TV remote events. When TV remote events occur, this class fires a JS event. This event will be picked up by instances of the `TVEventHandler` JavaScript object. Application code that needs to implement custom handling of TV remote events can create an instance of `TVEventHandler` and listen for these events, as in the following code:
+
+```jsx
+var TVEventHandler = require('TVEventHandler');
+
+class Game2048 extends React.Component {
+ _tvEventHandler: any;
+
+ _enableTVEventHandler() {
+ this._tvEventHandler = new TVEventHandler();
+ this._tvEventHandler.enable(this, function (cmp, evt) {
+ if (evt && evt.eventType === 'right') {
+ cmp.setState({ board: cmp.state.board.move(2) });
+ } else if (evt && evt.eventType === 'up') {
+ cmp.setState({ board: cmp.state.board.move(1) });
+ } else if (evt && evt.eventType === 'left') {
+ cmp.setState({ board: cmp.state.board.move(0) });
+ } else if (evt && evt.eventType === 'down') {
+ cmp.setState({ board: cmp.state.board.move(3) });
+ } else if (evt && evt.eventType === 'playPause') {
+ cmp.restartGame();
+ }
+ });
+ }
+
+ _disableTVEventHandler() {
+ if (this._tvEventHandler) {
+ this._tvEventHandler.disable();
+ delete this._tvEventHandler;
+ }
+ }
+
+ componentDidMount() {
+ this._enableTVEventHandler();
+ }
+
+ componentWillUnmount() {
+ this._disableTVEventHandler();
+ }
+}
+```
+
+- _Dev Menu support_: On the emulator, cmd-M will bring up the developer menu, similar to Android. To bring it up on a real Android TV device, press the menu button or long press the fast-forward button on the remote. (Please do not shake the Android TV device, that will not work :) )
+
+- _Known issues_:
+
+ - `TextInput` components do not work for now (i.e. they cannot receive focus automatically, see [this comment](https://github.com/facebook/react-native/pull/16500#issuecomment-629285638)).
+ - It is however possible to use a ref to manually trigger `inputRef.current.focus()`.
+ - You can wrap your input inside a `TouchableWithoutFeedback` component and trigger focus in the `onFocus` event of that touchable. This enables opening the keyboard via the arrow keys.
+ - The keyboard might reset its state after each keypress (this might only happen inside the Android TV emulator).
+ - The content of `Modal` components cannot receive focus, see [this issue](https://github.com/facebook/react-native/issues/24448) for details.
+
+
+
+
+> **Deprecated.** Use [react-native-tvos](https://github.com/react-native-community/react-native-tvos) instead. For the details please check the [0.62 release blog post](https://reactnative.dev/blog/#moving-apple-tv-to-react-native-tvos).
+
+## Build changes
+
+- _Native layer_: React Native Xcode projects all now have Apple TV build targets, with names ending in the string '-tvOS'.
+
+- _react-native init_: New React Native projects created with `react-native init` will have Apple TV target automatically created in their XCode projects.
+
+- _JavaScript layer_: Support for Apple TV has been added to `Platform.ios.js`. You can check whether code is running on AppleTV by doing
+
+```jsx
+var Platform = require('Platform');
+var running_on_tv = Platform.isTV;
+
+// If you want to be more specific and only detect devices running tvOS
+// (but no Android TV devices) you can use:
+var running_on_apple_tv = Platform.isTVOS;
+```
+
+## Code changes
+
+- _General support for tvOS_: Apple TV specific changes in native code are all wrapped by the TARGET_OS_TV define. These include changes to suppress APIs that are not supported on tvOS (e.g. web views, sliders, switches, status bar, etc.), and changes to support user input from the TV remote or keyboard.
+
+- _Common codebase_: Since tvOS and iOS share most Objective-C and JavaScript code in common, most documentation for iOS applies equally to tvOS.
+
+- _Access to touchable controls_: When running on Apple TV, the native view class is `RCTTVView`, which has additional methods to make use of the tvOS focus engine. The `Touchable` mixin has code added to detect focus changes and use existing methods to style the components properly and initiate the proper actions when the view is selected using the TV remote, so `TouchableWithoutFeedback`, `TouchableHighlight` and `TouchableOpacity` will work as expected. In particular:
+
+ - `onFocus` will be executed when the touchable view goes into focus
+ - `onBlur` will be executed when the touchable view goes out of focus
+ - `onPress` will be executed when the touchable view is actually selected by pressing the "select" button on the TV remote.
+
+- _TV remote/keyboard input_: A new native class, `RCTTVRemoteHandler`, sets up gesture recognizers for TV remote events. When TV remote events occur, this class fires notifications that are picked up by `RCTTVNavigationEventEmitter` (a subclass of `RCTEventEmitter`), that fires a JS event. This event will be picked up by instances of the `TVEventHandler` JavaScript object. Application code that needs to implement custom handling of TV remote events can create an instance of `TVEventHandler` and listen for these events, as in the following code:
+
+```jsx
+var TVEventHandler = require('TVEventHandler');
+
+class Game2048 extends React.Component {
+ _tvEventHandler: any;
+
+ _enableTVEventHandler() {
+ this._tvEventHandler = new TVEventHandler();
+ this._tvEventHandler.enable(this, function (cmp, evt) {
+ if (evt && evt.eventType === 'right') {
+ cmp.setState({ board: cmp.state.board.move(2) });
+ } else if (evt && evt.eventType === 'up') {
+ cmp.setState({ board: cmp.state.board.move(1) });
+ } else if (evt && evt.eventType === 'left') {
+ cmp.setState({ board: cmp.state.board.move(0) });
+ } else if (evt && evt.eventType === 'down') {
+ cmp.setState({ board: cmp.state.board.move(3) });
+ } else if (evt && evt.eventType === 'playPause') {
+ cmp.restartGame();
+ }
+ });
+ }
+
+ _disableTVEventHandler() {
+ if (this._tvEventHandler) {
+ this._tvEventHandler.disable();
+ delete this._tvEventHandler;
+ }
+ }
+
+ componentDidMount() {
+ this._enableTVEventHandler();
+ }
+
+ componentWillUnmount() {
+ this._disableTVEventHandler();
+ }
+}
+```
+
+- _Dev Menu support_: On the simulator, cmd-D will bring up the developer menu, similar to iOS. To bring it up on a real Apple TV device, make a long press on the play/pause button on the remote. (Please do not shake the Apple TV device, that will not work :) )
+
+- _TV remote animations_: `RCTTVView` native code implements Apple-recommended parallax animations to help guide the eye as the user navigates through views. The animations can be disabled or adjusted with new optional view properties.
+
+- _Back navigation with the TV remote menu button_: The `BackHandler` component, originally written to support the Android back button, now also supports back navigation on the Apple TV using the menu button on the TV remote.
+
+- _TabBarIOS behavior_: The `TabBarIOS` component wraps the native `UITabBar` API, which works differently on Apple TV. To avoid jittery re-rendering of the tab bar in tvOS (see [this issue](https://github.com/facebook/react-native/issues/15081)), the selected tab bar item can only be set from JavaScript on initial render, and is controlled after that by the user through native code.
+
+- _Known issues_:
+
+ - [ListView scrolling](https://github.com/facebook/react-native/issues/12793). The issue can be worked around by setting `removeClippedSubviews` to false in ListView and similar components. For more discussion of this issue, see [this PR](https://github.com/facebook/react-native/pull/12944).
+
+
+
diff --git a/website/versioned_docs/version-0.70/button.md b/website/versioned_docs/version-0.70/button.md
new file mode 100644
index 00000000000..78f7fcaa637
--- /dev/null
+++ b/website/versioned_docs/version-0.70/button.md
@@ -0,0 +1,273 @@
+---
+id: button
+title: Button
+---
+
+A basic button component that should render nicely on any platform. Supports a minimal level of customization.
+
+If this button doesn't look right for your app, you can build your own button using [TouchableOpacity](touchableopacity) or [TouchableWithoutFeedback](touchablewithoutfeedback). For inspiration, look at the [source code for this button component](https://github.com/facebook/react-native/blob/master/Libraries/Components/Button.js). Or, take a look at the [wide variety of button components built by the community](https://js.coach/?menu%5Bcollections%5D=React%20Native&page=1&query=button).
+
+```jsx
+
+```
+
+## Example
+
+```SnackPlayer name=Button%20Example
+import React from 'react';
+import { StyleSheet, Button, View, SafeAreaView, Text, Alert } from 'react-native';
+
+const Separator = () => (
+
+);
+
+const App = () => (
+
+
+
+ The title and onPress handler are required. It is recommended to set accessibilityLabel to help make your app usable by everyone.
+
+
+
+
+
+ Adjust the color in a way that looks standard on each platform. On iOS, the color prop controls the color of the text. On Android, the color adjusts the background color of the button.
+
+
+
+
+
+ All interaction for the component are disabled.
+
+
+
+
+
+ This layout strategy lets the title define the width of the button.
+
+
+
+
+
+);
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center',
+ marginHorizontal: 16,
+ },
+ title: {
+ textAlign: 'center',
+ marginVertical: 8,
+ },
+ fixToText: {
+ flexDirection: 'row',
+ justifyContent: 'space-between',
+ },
+ separator: {
+ marginVertical: 8,
+ borderBottomColor: '#737373',
+ borderBottomWidth: StyleSheet.hairlineWidth,
+ },
+});
+
+export default App;
+```
+
+---
+
+# Reference
+
+## Props
+
+###
Required
**`onPress`**
+
+Handler to be called when the user taps the button.
+
+| Type |
+| ------------------------------------------- |
+| ({ nativeEvent: [PressEvent](pressevent) }) |
+
+---
+
+###
Required
**`title`**
+
+Text to display inside the button. On Android the given title will be converted to the uppercased form.
+
+| Type |
+| ------ |
+| string |
+
+---
+
+### `accessibilityLabel`
+
+Text to display for blindness accessibility features.
+
+| Type |
+| ------ |
+| string |
+
+---
+
+### `accessibilityLanguage`
iOS
+
+A value indicating which language should be used by the screen reader when the user interacts with the element. It should follow the [BCP 47 specification](https://www.rfc-editor.org/info/bcp47).
+
+See the [iOS `accessibilityLanguage` doc](https://developer.apple.com/documentation/objectivec/nsobject/1615192-accessibilitylanguage) for more information.
+
+| Type |
+| ------ |
+| string |
+
+---
+
+### `accessibilityActions`
+
+Accessibility actions allow an assistive technology to programmatically invoke the actions of a component. The `accessibilityActions` property should contain a list of action objects. Each action object should contain the field name and label.
+
+See the [Accessibility guide](accessibility.md#accessibility-actions) for more information.
+
+| Type | Required |
+| ----- | -------- |
+| array | No |
+
+---
+
+### `onAccessibilityAction`
+
+Invoked when the user performs the accessibility actions. The only argument to this function is an event containing the name of the action to perform.
+
+See the [Accessibility guide](accessibility.md#accessibility-actions) for more information.
+
+| Type | Required |
+| -------- | -------- |
+| function | No |
+
+---
+
+### `color`
+
+Color of the text (iOS), or background color of the button (Android).
+
+| Type | Default |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [color](colors) | `'#2196F3'`
Android
`'#007AFF'`
iOS
|
+
+---
+
+### `disabled`
+
+If `true`, disable all interactions for this component.
+
+| Type | Default |
+| ---- | ------- |
+| bool | `false` |
+
+---
+
+### `hasTVPreferredFocus`
+
+Designates the next view to receive focus when the user navigates down. See the [Android documentation](https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusDown).
+
+| Type |
+| ------ |
+| number |
+
+---
+
+### `nextFocusForward`
Android
TV
+
+Designates the next view to receive focus when the user navigates forward. See the [Android documentation](https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusForward).
+
+| Type |
+| ------ |
+| number |
+
+---
+
+### `nextFocusLeft`
Android
TV
+
+Designates the next view to receive focus when the user navigates left. See the [Android documentation](https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusLeft).
+
+| Type |
+| ------ |
+| number |
+
+---
+
+### `nextFocusRight`
Android
TV
+
+Designates the next view to receive focus when the user navigates right. See the [Android documentation](https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusRight).
+
+| Type |
+| ------ |
+| number |
+
+---
+
+### `nextFocusUp`
Android
TV
+
+Designates the next view to receive focus when the user navigates up. See the [Android documentation](https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusUp).
+
+| Type |
+| ------ |
+| number |
+
+---
+
+### `testID`
+
+Used to locate this view in end-to-end tests.
+
+| Type |
+| ------ |
+| string |
+
+---
+
+### `touchSoundDisabled`
Android
+
+If `true`, doesn't play system sound on touch.
+
+| Type | Default |
+| ------- | ------- |
+| boolean | `false` |
diff --git a/website/versioned_docs/version-0.70/checkbox.md b/website/versioned_docs/version-0.70/checkbox.md
new file mode 100644
index 00000000000..9253aa616b2
--- /dev/null
+++ b/website/versioned_docs/version-0.70/checkbox.md
@@ -0,0 +1,113 @@
+---
+id: checkbox
+title: '🚧 CheckBox'
+---
+
+> **Removed.** Use one of the [community packages](https://reactnative.directory/?search=checkbox) instead.
+
+Renders a boolean input (Android only).
+
+This is a controlled component that requires an `onValueChange` callback that updates the `value` prop in order for the component to reflect user actions. If the `value` prop is not updated, the component will continue to render the supplied `value` prop instead of the expected result of any user actions.
+
+## Example
+
+```SnackPlayer name=CheckBox%20Component%20Example&supportedPlatforms=android,web
+import React, { useState } from "react";
+import { CheckBox, Text, StyleSheet, View } from "react-native";
+
+const App = () => {
+ const [isSelected, setSelection] = useState(false);
+
+ return (
+
+
+
+ Do you like React Native?
+
+ Is CheckBox selected: {isSelected ? "👍" : "👎"}
+
+ );
+};
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ alignItems: "center",
+ justifyContent: "center",
+ },
+ checkboxContainer: {
+ flexDirection: "row",
+ marginBottom: 20,
+ },
+ checkbox: {
+ alignSelf: "center",
+ },
+ label: {
+ margin: 8,
+ },
+});
+
+export default App;
+```
+
+---
+
+# Reference
+
+## Props
+
+Inherits [View Props](view#props).
+
+---
+
+### `disabled`
+
+If true the user won't be able to toggle the checkbox. Default value is `false`.
+
+| Type | Required |
+| ---- | -------- |
+| bool | No |
+
+---
+
+### `onChange`
+
+Used in case the props change removes the component.
+
+| Type | Required |
+| -------- | -------- |
+| function | No |
+
+---
+
+### `onValueChange`
+
+Invoked with the new value when the value changes.
+
+| Type | Required |
+| -------- | -------- |
+| function | No |
+
+---
+
+### `testID`
+
+Used to locate this view in end-to-end tests.
+
+| Type | Required |
+| ------ | -------- |
+| string | No |
+
+---
+
+### `value`
+
+The value of the checkbox. If true the checkbox will be turned on. Default value is `false`.
+
+| Type | Required |
+| ---- | -------- |
+| bool | No |
diff --git a/website/versioned_docs/version-0.70/clipboard.md b/website/versioned_docs/version-0.70/clipboard.md
new file mode 100644
index 00000000000..1b33930e84c
--- /dev/null
+++ b/website/versioned_docs/version-0.70/clipboard.md
@@ -0,0 +1,105 @@
+---
+id: clipboard
+title: '🚧 Clipboard'
+---
+
+> **Deprecated.** Use one of the [community packages](https://reactnative.directory/?search=clipboard) instead.
+
+`Clipboard` gives you an interface for setting and getting content from Clipboard on both Android and iOS
+
+---
+
+## Example
+
+```SnackPlayer name=Clipboard%20API%20Example&supportedPlatforms=ios,android
+
+import React, { useState } from 'react'
+import { SafeAreaView, View, Text, TouchableOpacity, Clipboard, StyleSheet } from 'react-native'
+
+const App = () => {
+ const [copiedText, setCopiedText] = useState('')
+
+ const copyToClipboard = () => {
+ Clipboard.setString('hello world')
+ }
+
+ const fetchCopiedText = async () => {
+ const text = await Clipboard.getString()
+ setCopiedText(text)
+ }
+
+ return (
+
+
+ copyToClipboard()}>
+ Click here to copy to Clipboard
+
+ fetchCopiedText()}>
+ View copied text
+
+
+ {copiedText}
+
+
+
+ )
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center',
+ alignItems: 'center'
+ },
+ copiedText: {
+ marginTop: 10,
+ color: 'red'
+ }
+})
+
+export default App
+```
+
+# Reference
+
+## Methods
+
+### `getString()`
+
+```jsx
+static getString()
+```
+
+Get content of string type, this method returns a `Promise`, so you can use following code to get clipboard content
+
+```jsx
+async _getContent() {
+ var content = await Clipboard.getString();
+}
+```
+
+---
+
+### `setString()`
+
+```jsx
+static setString(content)
+```
+
+Set content of string type. You can use following code to set clipboard content
+
+```jsx
+_setContent() {
+ Clipboard.setString('hello world');
+}
+```
+
+**Parameters:**
+
+| Name | Type | Required | Description |
+| ------- | ------ | -------- | ----------------------------------------- |
+| content | string | Yes | The content to be stored in the clipboard |
+
+_Notice_
+
+Be careful when you're trying to copy to clipboard any data except `string` and `number`, some data need additional stringification. For example, if you will try to copy array - Android will raise an exception, but iOS will not.
diff --git a/website/versioned_docs/version-0.70/colors.md b/website/versioned_docs/version-0.70/colors.md
new file mode 100644
index 00000000000..b396bfbfb38
--- /dev/null
+++ b/website/versioned_docs/version-0.70/colors.md
@@ -0,0 +1,210 @@
+---
+id: colors
+title: Color Reference
+---
+
+Components in React Native are [styled using JavaScript](style). Color properties usually match how [CSS works on the web](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value). General guides on the color usage on each platform could be found below:
+
+- [Android](https://material.io/design/color/color-usage.html)
+- [iOS](https://developer.apple.com/design/human-interface-guidelines/ios/visual-design/color/)
+
+## Color APIs
+
+React Native has several color APIs designed to allow you to take full advantage of your platform's design and user preferences.
+
+- [PlatformColor](platformcolor) lets you reference the platform's color system.
+- [DynamicColorIOS](dynamiccolorios) is iOS specific and allows you to specify which colors should be used in light or Dark Mode.
+
+## Color representations
+
+### Red Green Blue (RGB)
+
+React Native supports `rgb()` and `rgba()` in both hexadecimal and functional notation:
+
+- `'#f0f'` (#rgb)
+- `'#ff00ff'` (#rrggbb)
+- `'#f0ff'` (#rgba)
+- `'#ff00ff00'` (#rrggbbaa)
+- `'rgb(255, 0, 255)'`
+- `'rgba(255, 0, 255, 1.0)'`
+
+### Hue Saturation Lightness (HSL)
+
+React Native supports `hsl()` and `hsla()` in functional notation:
+
+- `'hsl(360, 100%, 100%)'`
+- `'hsla(360, 100%, 100%, 1.0)'`
+
+### Color ints
+
+React Native supports also colors as an `int` values (in RGB color mode):
+
+- `0xff00ff00` (0xrrggbbaa)
+
+:::caution
+This might appear similar to the Android [Color](https://developer.android.com/reference/android/graphics/Color) ints representation but on Android values are stored in SRGB color mode (0xaarrggbb).
+:::
+
+### Named colors
+
+In React Native you can also use color name strings as values.
+
+:::info
+React Native only supports lowercase color names. Uppercase color names are not supported.
+:::
+
+#### `transparent`
+
+This is a shortcut for `rgba(0,0,0,0)`, same like in [CSS3](https://www.w3.org/TR/css-color-3/#transparent).
+
+#### Color keywords
+
+Named colors implementation follows the [CSS3/SVG specification](https://www.w3.org/TR/css-color-3/#svg-color):
+
+
+
+- aliceblue (`#f0f8ff`)
+- antiquewhite (`#faebd7`)
+- aqua (`#00ffff`)
+- aquamarine (`#7fffd4`)
+- azure (`#f0ffff`)
+- beige (`#f5f5dc`)
+- bisque (`#ffe4c4`)
+- black (`#000000`)
+- blanchedalmond (`#ffebcd`)
+- blue (`#0000ff`)
+- blueviolet (`#8a2be2`)
+- brown (`#a52a2a`)
+- burlywood (`#deb887`)
+- cadetblue (`#5f9ea0`)
+- chartreuse (`#7fff00`)
+- chocolate (`#d2691e`)
+- coral (`#ff7f50`)
+- cornflowerblue (`#6495ed`)
+- cornsilk (`#fff8dc`)
+- crimson (`#dc143c`)
+- cyan (`#00ffff`)
+- darkblue (`#00008b`)
+- darkcyan (`#008b8b`)
+- darkgoldenrod (`#b8860b`)
+- darkgray (`#a9a9a9`)
+- darkgreen (`#006400`)
+- darkgrey (`#a9a9a9`)
+- darkkhaki (`#bdb76b`)
+- darkmagenta (`#8b008b`)
+- darkolivegreen (`#556b2f`)
+- darkorange (`#ff8c00`)
+- darkorchid (`#9932cc`)
+- darkred (`#8b0000`)
+- darksalmon (`#e9967a`)
+- darkseagreen (`#8fbc8f`)
+- darkslateblue (`#483d8b`)
+- darkslategrey (`#2f4f4f`)
+- darkturquoise (`#00ced1`)
+- darkviolet (`#9400d3`)
+- deeppink (`#ff1493`)
+- deepskyblue (`#00bfff`)
+- dimgray (`#696969`)
+- dimgrey (`#696969`)
+- dodgerblue (`#1e90ff`)
+- firebrick (`#b22222`)
+- floralwhite (`#fffaf0`)
+- forestgreen (`#228b22`)
+- fuchsia (`#ff00ff`)
+- gainsboro (`#dcdcdc`)
+- ghostwhite (`#f8f8ff`)
+- gold (`#ffd700`)
+- goldenrod (`#daa520`)
+- gray (`#808080`)
+- green (`#008000`)
+- greenyellow (`#adff2f`)
+- grey (`#808080`)
+- honeydew (`#f0fff0`)
+- hotpink (`#ff69b4`)
+- indianred (`#cd5c5c`)
+- indigo (`#4b0082`)
+- ivory (`#fffff0`)
+- khaki (`#f0e68c`)
+- lavender (`#e6e6fa`)
+- lavenderblush (`#fff0f5`)
+- lawngreen (`#7cfc00`)
+- lemonchiffon (`#fffacd`)
+- lightblue (`#add8e6`)
+- lightcoral (`#f08080`)
+- lightcyan (`#e0ffff`)
+- lightgoldenrodyellow (`#fafad2`)
+- lightgray (`#d3d3d3`)
+- lightgreen (`#90ee90`)
+- lightgrey (`#d3d3d3`)
+- lightpink (`#ffb6c1`)
+- lightsalmon (`#ffa07a`)
+- lightseagreen (`#20b2aa`)
+- lightskyblue (`#87cefa`)
+- lightslategrey (`#778899`)
+- lightsteelblue (`#b0c4de`)
+- lightyellow (`#ffffe0`)
+- lime (`#00ff00`)
+- limegreen (`#32cd32`)
+- linen (`#faf0e6`)
+- magenta (`#ff00ff`)
+- maroon (`#800000`)
+- mediumaquamarine (`#66cdaa`)
+- mediumblue (`#0000cd`)
+- mediumorchid (`#ba55d3`)
+- mediumpurple (`#9370db`)
+- mediumseagreen (`#3cb371`)
+- mediumslateblue (`#7b68ee`)
+- mediumspringgreen (`#00fa9a`)
+- mediumturquoise (`#48d1cc`)
+- mediumvioletred (`#c71585`)
+- midnightblue (`#191970`)
+- mintcream (`#f5fffa`)
+- mistyrose (`#ffe4e1`)
+- moccasin (`#ffe4b5`)
+- navajowhite (`#ffdead`)
+- navy (`#000080`)
+- oldlace (`#fdf5e6`)
+- olive (`#808000`)
+- olivedrab (`#6b8e23`)
+- orange (`#ffa500`)
+- orangered (`#ff4500`)
+- orchid (`#da70d6`)
+- palegoldenrod (`#eee8aa`)
+- palegreen (`#98fb98`)
+- paleturquoise (`#afeeee`)
+- palevioletred (`#db7093`)
+- papayawhip (`#ffefd5`)
+- peachpuff (`#ffdab9`)
+- peru (`#cd853f`)
+- pink (`#ffc0cb`)
+- plum (`#dda0dd`)
+- powderblue (`#b0e0e6`)
+- purple (`#800080`)
+- rebeccapurple (`#663399`)
+- red (`#ff0000`)
+- rosybrown (`#bc8f8f`)
+- royalblue (`#4169e1`)
+- saddlebrown (`#8b4513`)
+- salmon (`#fa8072`)
+- sandybrown (`#f4a460`)
+- seagreen (`#2e8b57`)
+- seashell (`#fff5ee`)
+- sienna (`#a0522d`)
+- silver (`#c0c0c0`)
+- skyblue (`#87ceeb`)
+- slateblue (`#6a5acd`)
+- slategray (`#708090`)
+- snow (`#fffafa`)
+- springgreen (`#00ff7f`)
+- steelblue (`#4682b4`)
+- tan (`#d2b48c`)
+- teal (`#008080`)
+- thistle (`#d8bfd8`)
+- tomato (`#ff6347`)
+- turquoise (`#40e0d0`)
+- violet (`#ee82ee`)
+- wheat (`#f5deb3`)
+- white (`#ffffff`)
+- whitesmoke (`#f5f5f5`)
+- yellow (`#ffff00`)
+- yellowgreen (`#9acd32`)
diff --git a/website/versioned_docs/version-0.70/communication-android.md b/website/versioned_docs/version-0.70/communication-android.md
new file mode 100644
index 00000000000..bcf2dec3037
--- /dev/null
+++ b/website/versioned_docs/version-0.70/communication-android.md
@@ -0,0 +1,149 @@
+---
+id: communication-android
+title: Communication between native and React Native
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+In [Integrating with Existing Apps guide](integration-with-existing-apps) and [Native UI Components guide](native-components-android) we learn how to embed React Native in a native component and vice versa. When we mix native and React Native components, we'll eventually find a need to communicate between these two worlds. Some ways to achieve that have been already mentioned in other guides. This article summarizes available techniques.
+
+## Introduction
+
+React Native is inspired by React, so the basic idea of the information flow is similar. The flow in React is one-directional. We maintain a hierarchy of components, in which each component depends only on its parent and its own internal state. We do this with properties: data is passed from a parent to its children in a top-down manner. If an ancestor component relies on the state of its descendant, one should pass down a callback to be used by the descendant to update the ancestor.
+
+The same concept applies to React Native. As long as we are building our application purely within the framework, we can drive our app with properties and callbacks. But, when we mix React Native and native components, we need some specific, cross-language mechanisms that would allow us to pass information between them.
+
+## Properties
+
+Properties are the most straightforward way of cross-component communication. So we need a way to pass properties both from native to React Native, and from React Native to native.
+
+### Passing properties from native to React Native
+
+You can pass properties down to the React Native app by providing a custom implementation of `ReactActivityDelegate` in your main activity. This implementation should override `getLaunchOptions` to return a `Bundle` with the desired properties.
+
+
+
+
+
+```java
+public class MainActivity extends ReactActivity {
+ @Override
+ protected ReactActivityDelegate createReactActivityDelegate() {
+ return new ReactActivityDelegate(this, getMainComponentName()) {
+ @Override
+ protected Bundle getLaunchOptions() {
+ Bundle initialProperties = new Bundle();
+ ArrayList imageList = new ArrayList(Arrays.asList(
+ "http://foo.com/bar1.png",
+ "http://foo.com/bar2.png"
+ ));
+ initialProperties.putStringArrayList("images", imageList);
+ return initialProperties;
+ }
+ };
+ }
+}
+```
+
+
+
+
+
+```kotlin
+class MainActivity : ReactActivity() {
+ override fun createReactActivityDelegate(): ReactActivityDelegate {
+ return object : ReactActivityDelegate(this, mainComponentName) {
+ override fun getLaunchOptions(): Bundle {
+ val imageList = arrayListOf("http://foo.com/bar1.png", "http://foo.com/bar2.png")
+ val initialProperties = Bundle().apply { putStringArrayList("images", imageList) }
+ return initialProperties
+ }
+ }
+ }
+}
+```
+
+
+
+
+```jsx
+import React from 'react';
+import { View, Image } from 'react-native';
+
+export default class ImageBrowserApp extends React.Component {
+ renderImage(imgURI) {
+ return ;
+ }
+ render() {
+ return {this.props.images.map(this.renderImage)};
+ }
+}
+```
+
+`ReactRootView` provides a read-write property `appProperties`. After `appProperties` is set, the React Native app is re-rendered with new properties. The update is only performed when the new updated properties differ from the previous ones.
+
+
+
+
+
+```java
+Bundle updatedProps = mReactRootView.getAppProperties();
+ArrayList imageList = new ArrayList(Arrays.asList(
+ "http://foo.com/bar3.png",
+ "http://foo.com/bar4.png"
+));
+updatedProps.putStringArrayList("images", imageList);
+
+mReactRootView.setAppProperties(updatedProps);
+```
+
+
+
+
+
+```kotlin
+var updatedProps: Bundle = reactRootView.getAppProperties()
+var imageList = arrayListOf("http://foo.com/bar3.png", "http://foo.com/bar4.png")
+```
+
+
+
+
+
+It is fine to update properties anytime. However, updates have to be performed on the main thread. You use the getter on any thread.
+
+There is no way to update only a few properties at a time. We suggest that you build it into your own wrapper instead.
+
+> **_Note:_** Currently, JS function `componentWillUpdateProps` of the top level RN component will not be called after a prop update. However, you can access the new props in `componentDidMount` function.
+
+### Passing properties from React Native to native
+
+The problem exposing properties of native components is covered in detail in [this article](native-components-android#3-expose-view-property-setters-using-reactprop-or-reactpropgroup-annotation). In short, properties that are to be reflected in JavaScript needs to be exposed as setter method annotated with `@ReactProp`, then use them in React Native as if the component was an ordinary React Native component.
+
+### Limits of properties
+
+The main drawback of cross-language properties is that they do not support callbacks, which would allow us to handle bottom-up data bindings. Imagine you have a small RN view that you want to be removed from the native parent view as a result of a JS action. There is no way to do that with props, as the information would need to go bottom-up.
+
+Although we have a flavor of cross-language callbacks ([described here](native-modules-android#callbacks)), these callbacks are not always the thing we need. The main problem is that they are not intended to be passed as properties. Rather, this mechanism allows us to trigger a native action from JS, and handle the result of that action in JS.
+
+## Other ways of cross-language interaction (events and native modules)
+
+As stated in the previous chapter, using properties comes with some limitations. Sometimes properties are not enough to drive the logic of our app and we need a solution that gives more flexibility. This chapter covers other communication techniques available in React Native. They can be used for internal communication (between JS and native layers in RN) as well as for external communication (between RN and the 'pure native' part of your app).
+
+React Native enables you to perform cross-language function calls. You can execute custom native code from JS and vice versa. Unfortunately, depending on the side we are working on, we achieve the same goal in different ways. For native - we use events mechanism to schedule an execution of a handler function in JS, while for React Native we directly call methods exported by native modules.
+
+### Calling React Native functions from native (events)
+
+Events are described in detail in [this article](native-components-android#events). Note that using events gives us no guarantees about execution time, as the event is handled on a separate thread.
+
+Events are powerful, because they allow us to change React Native components without needing a reference to them. However, there are some pitfalls that you can fall into while using them:
+
+- As events can be sent from anywhere, they can introduce spaghetti-style dependencies into your project.
+- Events share namespace, which means that you may encounter some name collisions. Collisions will not be detected statically, which makes them hard to debug.
+- If you use several instances of the same React Native component and you want to distinguish them from the perspective of your event, you'll likely need to introduce identifiers and pass them along with events (you can use the native view's `reactTag` as an identifier).
+
+### Calling native functions from React Native (native modules)
+
+Native modules are Java/Kotlin classes that are available in JS. Typically one instance of each module is created per JS bridge. They can export arbitrary functions and constants to React Native. They have been covered in detail in [this article](native-modules-android).
+
+> **_Warning_**: All native modules share the same namespace. Watch out for name collisions when creating new ones.
diff --git a/website/versioned_docs/version-0.70/communication-ios.md b/website/versioned_docs/version-0.70/communication-ios.md
new file mode 100644
index 00000000000..6130662a864
--- /dev/null
+++ b/website/versioned_docs/version-0.70/communication-ios.md
@@ -0,0 +1,204 @@
+---
+id: communication-ios
+title: Communication between native and React Native
+---
+
+In [Integrating with Existing Apps guide](integration-with-existing-apps) and [Native UI Components guide](native-components-ios) we learn how to embed React Native in a native component and vice versa. When we mix native and React Native components, we'll eventually find a need to communicate between these two worlds. Some ways to achieve that have been already mentioned in other guides. This article summarizes available techniques.
+
+## Introduction
+
+React Native is inspired by React, so the basic idea of the information flow is similar. The flow in React is one-directional. We maintain a hierarchy of components, in which each component depends only on its parent and its own internal state. We do this with properties: data is passed from a parent to its children in a top-down manner. If an ancestor component relies on the state of its descendant, one should pass down a callback to be used by the descendant to update the ancestor.
+
+The same concept applies to React Native. As long as we are building our application purely within the framework, we can drive our app with properties and callbacks. But, when we mix React Native and native components, we need some specific, cross-language mechanisms that would allow us to pass information between them.
+
+## Properties
+
+Properties are the most straightforward way of cross-component communication. So we need a way to pass properties both from native to React Native, and from React Native to native.
+
+### Passing properties from native to React Native
+
+In order to embed a React Native view in a native component, we use `RCTRootView`. `RCTRootView` is a `UIView` that holds a React Native app. It also provides an interface between native side and the hosted app.
+
+`RCTRootView` has an initializer that allows you to pass arbitrary properties down to the React Native app. The `initialProperties` parameter has to be an instance of `NSDictionary`. The dictionary is internally converted into a JSON object that the top-level JS component can reference.
+
+```objectivec
+NSArray *imageList = @[@"http://foo.com/bar1.png",
+ @"http://foo.com/bar2.png"];
+
+NSDictionary *props = @{@"images" : imageList};
+
+RCTRootView *rootView = [[RCTRootView alloc] initWithBridge:bridge
+ moduleName:@"ImageBrowserApp"
+ initialProperties:props];
+```
+
+```jsx
+import React from 'react';
+import { View, Image } from 'react-native';
+
+export default class ImageBrowserApp extends React.Component {
+ renderImage(imgURI) {
+ return ;
+ }
+ render() {
+ return {this.props.images.map(this.renderImage)};
+ }
+}
+```
+
+`RCTRootView` also provides a read-write property `appProperties`. After `appProperties` is set, the React Native app is re-rendered with new properties. The update is only performed when the new updated properties differ from the previous ones.
+
+```objectivec
+NSArray *imageList = @[@"http://foo.com/bar3.png",
+ @"http://foo.com/bar4.png"];
+
+rootView.appProperties = @{@"images" : imageList};
+```
+
+It is fine to update properties anytime. However, updates have to be performed on the main thread. You use the getter on any thread.
+
+:::note
+Currently, there is a known issue where setting appProperties during the bridge startup, the change can be lost. See https://github.com/facebook/react-native/issues/20115 for more information.
+:::
+
+There is no way to update only a few properties at a time. We suggest that you build it into your own wrapper instead.
+
+### Passing properties from React Native to native
+
+The problem exposing properties of native components is covered in detail in [this article](native-components-ios#properties). In short, export properties with `RCT_CUSTOM_VIEW_PROPERTY` macro in your custom native component, then use them in React Native as if the component was an ordinary React Native component.
+
+### Limits of properties
+
+The main drawback of cross-language properties is that they do not support callbacks, which would allow us to handle bottom-up data bindings. Imagine you have a small RN view that you want to be removed from the native parent view as a result of a JS action. There is no way to do that with props, as the information would need to go bottom-up.
+
+Although we have a flavor of cross-language callbacks ([described here](native-modules-ios#callbacks)), these callbacks are not always the thing we need. The main problem is that they are not intended to be passed as properties. Rather, this mechanism allows us to trigger a native action from JS, and handle the result of that action in JS.
+
+## Other ways of cross-language interaction (events and native modules)
+
+As stated in the previous chapter, using properties comes with some limitations. Sometimes properties are not enough to drive the logic of our app and we need a solution that gives more flexibility. This chapter covers other communication techniques available in React Native. They can be used for internal communication (between JS and native layers in RN) as well as for external communication (between RN and the 'pure native' part of your app).
+
+React Native enables you to perform cross-language function calls. You can execute custom native code from JS and vice versa. Unfortunately, depending on the side we are working on, we achieve the same goal in different ways. For native - we use events mechanism to schedule an execution of a handler function in JS, while for React Native we directly call methods exported by native modules.
+
+### Calling React Native functions from native (events)
+
+Events are described in detail in [this article](native-components-ios#events). Note that using events gives us no guarantees about execution time, as the event is handled on a separate thread.
+
+Events are powerful, because they allow us to change React Native components without needing a reference to them. However, there are some pitfalls that you can fall into while using them:
+
+- As events can be sent from anywhere, they can introduce spaghetti-style dependencies into your project.
+- Events share namespace, which means that you may encounter some name collisions. Collisions will not be detected statically, which makes them hard to debug.
+- If you use several instances of the same React Native component and you want to distinguish them from the perspective of your event, you'll likely need to introduce identifiers and pass them along with events (you can use the native view's `reactTag` as an identifier).
+
+The common pattern we use when embedding native in React Native is to make the native component's RCTViewManager a delegate for the views, sending events back to JavaScript via the bridge. This keeps related event calls in one place.
+
+### Calling native functions from React Native (native modules)
+
+Native modules are Objective-C classes that are available in JS. Typically one instance of each module is created per JS bridge. They can export arbitrary functions and constants to React Native. They have been covered in detail in [this article](native-modules-ios#content).
+
+The fact that native modules are singletons limits the mechanism in the context of embedding. Let's say we have a React Native component embedded in a native view and we want to update the native, parent view. Using the native module mechanism, we would export a function that not only takes expected arguments, but also an identifier of the parent native view. The identifier would be used to retrieve a reference to the parent view to update. That said, we would need to keep a mapping from identifiers to native views in the module.
+
+Although this solution is complex, it is used in `RCTUIManager`, which is an internal React Native class that manages all React Native views.
+
+Native modules can also be used to expose existing native libraries to JS. The [Geolocation library](https://github.com/michalchudziak/react-native-geolocation) is a living example of the idea.
+
+:::caution
+All native modules share the same namespace. Watch out for name collisions when creating new ones.
+:::
+
+## Layout computation flow
+
+When integrating native and React Native, we also need a way to consolidate two different layout systems. This section covers common layout problems and provides a brief description of mechanisms to address them.
+
+### Layout of a native component embedded in React Native
+
+This case is covered in [this article](native-components-ios#styles). To summarize, since all our native react views are subclasses of `UIView`, most style and size attributes will work like you would expect out of the box.
+
+### Layout of a React Native component embedded in native
+
+#### React Native content with fixed size
+
+The general scenario is when we have a React Native app with a fixed size, which is known to the native side. In particular, a full-screen React Native view falls into this case. If we want a smaller root view, we can explicitly set RCTRootView's frame.
+
+For instance, to make an RN app 200 (logical) pixels high, and the hosting view's width wide, we could do:
+
+```objectivec title='SomeViewController.m'
+- (void)viewDidLoad
+{
+ [...]
+ RCTRootView *rootView = [[RCTRootView alloc] initWithBridge:bridge
+ moduleName:appName
+ initialProperties:props];
+ rootView.frame = CGRectMake(0, 0, self.view.width, 200);
+ [self.view addSubview:rootView];
+}
+```
+
+When we have a fixed size root view, we need to respect its bounds on the JS side. In other words, we need to ensure that the React Native content can be contained within the fixed-size root view. The easiest way to ensure this is to use Flexbox layout. If you use absolute positioning, and React components are visible outside the root view's bounds, you'll get overlap with native views, causing some features to behave unexpectedly. For instance, 'TouchableHighlight' will not highlight your touches outside the root view's bounds.
+
+It's totally fine to update root view's size dynamically by re-setting its frame property. React Native will take care of the content's layout.
+
+#### React Native content with flexible size
+
+In some cases we'd like to render content of initially unknown size. Let's say the size will be defined dynamically in JS. We have two solutions to this problem.
+
+1. You can wrap your React Native view in a `ScrollView` component. This guarantees that your content will always be available and it won't overlap with native views.
+2. React Native allows you to determine, in JS, the size of the RN app and provide it to the owner of the hosting `RCTRootView`. The owner is then responsible for re-laying out the subviews and keeping the UI consistent. We achieve this with `RCTRootView`'s flexibility modes.
+
+`RCTRootView` supports 4 different size flexibility modes:
+
+```objectivec title='RCTRootView.h'
+typedef NS_ENUM(NSInteger, RCTRootViewSizeFlexibility) {
+ RCTRootViewSizeFlexibilityNone = 0,
+ RCTRootViewSizeFlexibilityWidth,
+ RCTRootViewSizeFlexibilityHeight,
+ RCTRootViewSizeFlexibilityWidthAndHeight,
+};
+```
+
+`RCTRootViewSizeFlexibilityNone` is the default value, which makes a root view's size fixed (but it still can be updated with `setFrame:`). The other three modes allow us to track React Native content's size updates. For instance, setting mode to `RCTRootViewSizeFlexibilityHeight` will cause React Native to measure the content's height and pass that information back to `RCTRootView`'s delegate. An arbitrary action can be performed within the delegate, including setting the root view's frame, so the content fits. The delegate is called only when the size of the content has changed.
+
+:::caution
+Making a dimension flexible in both JS and native leads to undefined behavior. For example - don't make a top-level React component's width flexible (with `flexbox`) while you're using `RCTRootViewSizeFlexibilityWidth` on the hosting `RCTRootView`.
+:::
+
+Let's look at an example.
+
+```objectivec title='FlexibleSizeExampleView.m'
+- (instancetype)initWithFrame:(CGRect)frame
+{
+ [...]
+
+ _rootView = [[RCTRootView alloc] initWithBridge:bridge
+ moduleName:@"FlexibilityExampleApp"
+ initialProperties:@{}];
+
+ _rootView.delegate = self;
+ _rootView.sizeFlexibility = RCTRootViewSizeFlexibilityHeight;
+ _rootView.frame = CGRectMake(0, 0, self.frame.size.width, 0);
+}
+
+#pragma mark - RCTRootViewDelegate
+- (void)rootViewDidChangeIntrinsicSize:(RCTRootView *)rootView
+{
+ CGRect newFrame = rootView.frame;
+ newFrame.size = rootView.intrinsicContentSize;
+
+ rootView.frame = newFrame;
+}
+```
+
+In the example we have a `FlexibleSizeExampleView` view that holds a root view. We create the root view, initialize it and set the delegate. The delegate will handle size updates. Then, we set the root view's size flexibility to `RCTRootViewSizeFlexibilityHeight`, which means that `rootViewDidChangeIntrinsicSize:` method will be called every time the React Native content changes its height. Finally, we set the root view's width and position. Note that we set there height as well, but it has no effect as we made the height RN-dependent.
+
+You can checkout full source code of the example [here](https://github.com/facebook/react-native/blob/master/packages/rn-tester/RNTester/NativeExampleViews/FlexibleSizeExampleView.m).
+
+It's fine to change root view's size flexibility mode dynamically. Changing flexibility mode of a root view will schedule a layout recalculation and the delegate `rootViewDidChangeIntrinsicSize:` method will be called once the content size is known.
+
+:::note
+React Native layout calculation is performed on a separate thread, while native UI view updates are done on the main thread.
+This may cause temporary UI inconsistencies between native and React Native. This is a known problem and our team is working on synchronizing UI updates coming from different sources.
+:::
+
+:::note
+React Native does not perform any layout calculations until the root view becomes a subview of some other views.
+If you want to hide React Native view until its dimensions are known, add the root view as a subview and make it initially hidden (use `UIView`'s `hidden` property). Then change its visibility in the delegate method.
+:::
diff --git a/website/versioned_docs/version-0.70/components-and-apis.md b/website/versioned_docs/version-0.70/components-and-apis.md
new file mode 100644
index 00000000000..555d419118a
--- /dev/null
+++ b/website/versioned_docs/version-0.70/components-and-apis.md
@@ -0,0 +1,207 @@
+---
+id: components-and-apis
+title: Core Components and APIs
+---
+
+React Native provides a number of built-in [Core Components](intro-react-native-components) ready for you to use in your app. You can find them all in the left sidebar (or menu above, if you are on a narrow screen). If you're not sure where to get started, take a look at the following categories:
+
+- [Basic Components](components-and-apis#basic-components)
+- [User Interface](components-and-apis#user-interface)
+- [List Views](components-and-apis#list-views)
+- [Android-specific](components-and-apis#android-components-and-apis)
+- [iOS-specific](components-and-apis#ios-components-and-apis)
+- [Others](components-and-apis#others)
+
+You're not limited to the components and APIs bundled with React Native. React Native has a community of thousands of developers. If you're looking for a library that does something specific, please refer to [this guide about finding libraries](libraries#finding-libraries).
+
+## Basic Components
+
+Most apps will end up using one of these basic components.
+
+
+
+## List Views
+
+Unlike the more generic [`ScrollView`](./scrollview), the following list view components only render elements that are currently showing on the screen. This makes them a performant choice for displaying long lists of data.
+
+
+
+## Others
+
+These components may be useful for certain applications. For an exhaustive list of components and APIs, check out the sidebar to the left (or menu above, if you are on a narrow screen).
+
+
diff --git a/website/versioned_docs/version-0.70/custom-webview-android.md b/website/versioned_docs/version-0.70/custom-webview-android.md
new file mode 100644
index 00000000000..581f230e1a2
--- /dev/null
+++ b/website/versioned_docs/version-0.70/custom-webview-android.md
@@ -0,0 +1,403 @@
+---
+id: custom-webview-android
+title: Custom WebView
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+While the built-in web view has a lot of features, it is not possible to handle every use-case in React Native. You can, however, extend the web view with native code without forking React Native or duplicating all the existing web view code.
+
+:::info
+The React Native WebView component has been extracted to [`react-native-webview`](https://github.com/react-native-webview/react-native-webview) package as part of the [Lean Core effort](https://github.com/facebook/react-native/issues/23313).
+That is the recommended way to use WebView in React Native as of today. You should not use the [WebView](https://reactnative.dev/docs/0.61/webview) component as that was deprecated and removed from React Native.
+:::
+
+Before you do this, you should be familiar with the concepts in [native UI components](native-components-android). You should also familiarise yourself with the [native code for web views](https://github.com/react-native-webview/react-native-webview/blob/master/android/src/main/java/com/reactnativecommunity/webview/RNCWebViewManager.java), as you will have to use this as a reference when implementing new features—although a deep understanding is not required.
+
+## Native Code
+
+:::info
+This example assumes you already have [`react-native-webview`](https://github.com/react-native-webview/react-native-webview) installed, if not please follow their [Getting Started guide](https://github.com/react-native-webview/react-native-webview/blob/master/docs/Getting-Started.md) first.
+:::
+
+To get started, you'll need to create a subclass of `RNCWebViewManager`, `RNCWebView`, and `RNCWebViewClient`. In your view manager, you'll then need to override:
+
+- `createRNCWebViewInstance`
+- `getName`
+- `addEventEmitters`
+
+
+
+
+```java
+@ReactModule(name = CustomWebViewManager.REACT_CLASS)
+public class CustomWebViewManager extends RNCWebViewManager {
+ /* This name must match what we're referring to in JS */
+ protected static final String REACT_CLASS = "RCTCustomWebView";
+
+ protected static class CustomWebViewClient extends RNCWebViewClient { }
+
+ protected static class CustomWebView extends RNCWebView {
+ public CustomWebView(ThemedReactContext reactContext) {
+ super(reactContext);
+ }
+ }
+
+ @Override
+ protected RNCWebView createRNCWebViewInstance(ThemedReactContext reactContext) {
+ return new CustomWebView(reactContext);
+ }
+
+ @Override
+ public String getName() {
+ return REACT_CLASS;
+ }
+
+ @Override
+ protected void addEventEmitters(ThemedReactContext reactContext, WebView view) {
+ view.setWebViewClient(new CustomWebViewClient());
+ }
+}
+```
+
+
+
+
+```kotlin
+@ReactModule(name = CustomWebViewManager.REACT_CLASS)
+class CustomWebViewManager : RNCWebViewManager() {
+ protected class CustomWebViewClient : RNCWebViewClient()
+ protected inner class CustomWebView(reactContext: ThemedReactContext?) :
+ RNCWebView(reactContext)
+
+ override fun createRNCWebViewInstance(reactContext: ThemedReactContext?): RNCWebView {
+ return CustomWebView(reactContext)
+ }
+
+ override fun addEventEmitters(reactContext: ThemedReactContext, view: WebView) {
+ view.webViewClient = CustomWebViewClient()
+ }
+
+ companion object {
+ /* This name must match what we're referring to in JS */
+ const val REACT_CLASS = "RCTCustomWebView"
+ }
+}
+```
+
+
+
+
+You'll need to follow the usual steps to [register the module](native-modules-android.md#register-the-module).
+
+### Adding New Properties
+
+To add a new property, you'll need to add it to `CustomWebView`, and then expose it in `CustomWebViewManager`.
+
+
+
+
+```java
+public class CustomWebViewManager extends RNCWebViewManager {
+ ...
+ protected static class CustomWebView extends RNCWebView {
+ public CustomWebView(ThemedReactContext reactContext) {
+ super(reactContext);
+ }
+
+ protected @Nullable String mFinalUrl;
+
+ public void setFinalUrl(String url) {
+ mFinalUrl = url;
+ }
+
+ public String getFinalUrl() {
+ return mFinalUrl;
+ }
+ }
+
+ ...
+
+ @ReactProp(name = "finalUrl")
+ public void setFinalUrl(WebView view, String url) {
+ ((CustomWebView) view).setFinalUrl(url);
+ }
+}
+```
+
+
+
+
+```kotlin
+class CustomWebViewManager : RNCWebViewManager() {
+ protected inner class CustomWebView(
+ reactContext: ThemedReactContext?,
+ var finalUrl: String? = null
+ ) : RNCWebView(reactContext)
+
+ @ReactProp(name = "finalUrl")
+ fun setFinalUrl(view: WebView, url: String?) {
+ (view as CustomWebView).finalUrl = url
+ }
+}
+```
+
+
+
+
+### Adding New Events
+
+For events, you'll first need to make create event subclass.
+
+
+
+
+```java
+// NavigationCompletedEvent.java
+public class NavigationCompletedEvent extends Event {
+ private WritableMap mParams;
+
+ public NavigationCompletedEvent(int viewTag, WritableMap params) {
+ super(viewTag);
+ this.mParams = params;
+ }
+
+ @Override
+ public String getEventName() {
+ return "navigationCompleted";
+ }
+
+ @Override
+ public void dispatch(RCTEventEmitter rctEventEmitter) {
+ init(getViewTag());
+ rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mParams);
+ }
+}
+```
+
+
+
+
+```kotlin
+// NavigationCompletedEvent.kt
+class NavigationCompletedEvent(viewTag: Int, val params: WritableMap) :
+ Event(viewTag) {
+ override fun getEventName(): String = "navigationCompleted"
+
+ override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+ init(viewTag)
+ rctEventEmitter.receiveEvent(viewTag, eventName, params)
+ }
+}
+```
+
+
+
+
+You can trigger the event in your web view client. You can hook existing handlers if your events are based on them.
+
+You should refer to [RNCWebViewManager.java](https://github.com/react-native-webview/react-native-webview/blob/master/android/src/main/java/com/reactnativecommunity/webview/RNCWebViewManager.java) in the React Native WebView codebase to see what handlers are available and how they are implemented. You can extend any methods here to provide extra functionality.
+
+
+
+
+```java
+public class NavigationCompletedEvent extends Event {
+ private WritableMap mParams;
+
+ public NavigationCompletedEvent(int viewTag, WritableMap params) {
+ super(viewTag);
+ this.mParams = params;
+ }
+
+ @Override
+ public String getEventName() {
+ return "navigationCompleted";
+ }
+
+ @Override
+ public void dispatch(RCTEventEmitter rctEventEmitter) {
+ init(getViewTag());
+ rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mParams);
+ }
+}
+
+// CustomWebViewManager.java
+protected static class CustomWebViewClient extends RNCWebViewClient {
+ @Override
+ public boolean shouldOverrideUrlLoading(WebView view, String url) {
+ boolean shouldOverride = super.shouldOverrideUrlLoading(view, url);
+ String finalUrl = ((CustomWebView) view).getFinalUrl();
+
+ if (!shouldOverride && url != null && finalUrl != null && new String(url).equals(finalUrl)) {
+ final WritableMap params = Arguments.createMap();
+ dispatchEvent(view, new NavigationCompletedEvent(view.getId(), params));
+ }
+
+ return shouldOverride;
+ }
+}
+```
+
+
+
+
+```kotlin
+class NavigationCompletedEvent(viewTag: Int, val params: WritableMap) :
+ Event(viewTag) {
+
+ override fun getEventName(): String = "navigationCompleted"
+
+ override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+ init(viewTag)
+ rctEventEmitter.receiveEvent(viewTag, eventName, params)
+ }
+}
+
+// CustomWebViewManager.kt
+
+protected class CustomWebViewClient : RNCWebViewClient() {
+ override fun shouldOverrideUrlLoading(view: WebView, url: String?): Boolean {
+ val shouldOverride: Boolean = super.shouldOverrideUrlLoading(view, url)
+ val finalUrl: String? = (view as CustomWebView).finalUrl
+ if (!shouldOverride && url != null && finalUrl != null && url == finalUrl) {
+ val params: WritableMap = Arguments.createMap()
+ dispatchEvent(view, NavigationCompletedEvent(view.getId(), params))
+ }
+ return shouldOverride
+ }
+}
+```
+
+
+
+
+Finally, you'll need to expose the events in `CustomWebViewManager` through `getExportedCustomDirectEventTypeConstants`. Note that currently, the default implementation returns `null`, but this may change in the future.
+
+
+
+
+```java
+public class CustomWebViewManager extends RNCWebViewManager {
+ ...
+
+ @Override
+ public @Nullable
+ Map getExportedCustomDirectEventTypeConstants() {
+ Map export = super.getExportedCustomDirectEventTypeConstants();
+ if (export == null) {
+ export = MapBuilder.newHashMap();
+ }
+ export.put("navigationCompleted", MapBuilder.of("registrationName", "onNavigationCompleted"));
+ return export;
+ }
+}
+```
+
+
+
+
+```kotlin
+class CustomWebViewManager : RNCWebViewManager() {
+ override fun getExportedCustomDirectEventTypeConstants(): MutableMap? {
+ val superTypeConstants = super.getExportedCustomDirectEventTypeConstants()
+ val export = superTypeConstants ?: MapBuilder.newHashMap()
+ export["navigationCompleted"] = MapBuilder.of("registrationName", "onNavigationCompleted")
+ return export
+ }
+}
+```
+
+
+
+
+## JavaScript Interface
+
+To use your custom web view, you'll need to create a class for it. Your class must:
+
+- Export all the prop types from `WebView.propTypes`
+- Return a `WebView` component with the prop `nativeConfig.component` set to your native component (see below)
+
+To get your native component, you must use `requireNativeComponent`: the same as for regular custom components. However, you must pass in an extra third argument, `WebView.extraNativeComponentConfig`. This third argument contains prop types that are only required for native code.
+
+```jsx
+import React, { Component, PropTypes } from 'react';
+import { WebView, requireNativeComponent } from 'react-native';
+
+export default class CustomWebView extends Component {
+ static propTypes = WebView.propTypes;
+
+ render() {
+ return (
+
+ );
+ }
+}
+
+const RCTCustomWebView = requireNativeComponent(
+ 'RCTCustomWebView',
+ CustomWebView,
+ WebView.extraNativeComponentConfig
+);
+```
+
+If you want to add custom props to your native component, you can use `nativeConfig.props` on the web view.
+
+For events, the event handler must always be set to a function. This means it isn't safe to use the event handler directly from `this.props`, as the user might not have provided one. The standard approach is to create a event handler in your class, and then invoking the event handler given in `this.props` if it exists.
+
+If you are unsure how something should be implemented from the JS side, look at [WebView.android.js](https://github.com/react-native-webview/react-native-webview/blob/master/src/WebView.android.tsx) in the React Native WebView source.
+
+```jsx
+export default class CustomWebView extends Component {
+ static propTypes = {
+ ...WebView.propTypes,
+ finalUrl: PropTypes.string,
+ onNavigationCompleted: PropTypes.func
+ };
+
+ static defaultProps = {
+ finalUrl: 'about:blank'
+ };
+
+ _onNavigationCompleted = (event) => {
+ const { onNavigationCompleted } = this.props;
+ onNavigationCompleted && onNavigationCompleted(event);
+ };
+
+ render() {
+ return (
+
+ );
+ }
+}
+```
+
+Similar to regular native components, you must provide all your prop types in the component to have them forwarded on to the native component. However, if you have some prop types that are only used internally in component, you can add them to the `nativeOnly` property of the third argument previously mentioned. For event handlers, you have to use the value `true` instead of a regular prop type.
+
+For example, if you wanted to add an internal event handler called `onScrollToBottom`, you would use,
+
+```jsx
+const RCTCustomWebView = requireNativeComponent(
+ 'RCTCustomWebView',
+ CustomWebView,
+ {
+ ...WebView.extraNativeComponentConfig,
+ nativeOnly: {
+ ...WebView.extraNativeComponentConfig.nativeOnly,
+ onScrollToBottom: true
+ }
+ }
+);
+```
diff --git a/website/versioned_docs/version-0.70/custom-webview-ios.md b/website/versioned_docs/version-0.70/custom-webview-ios.md
new file mode 100644
index 00000000000..72675fc4e7d
--- /dev/null
+++ b/website/versioned_docs/version-0.70/custom-webview-ios.md
@@ -0,0 +1,236 @@
+---
+id: custom-webview-ios
+title: Custom WebView
+---
+
+While the built-in web view has a lot of features, it is not possible to handle every use-case in React Native. You can, however, extend the web view with native code without forking React Native or duplicating all the existing web view code.
+
+Before you do this, you should be familiar with the concepts in [native UI components](native-components-ios). You should also familiarise yourself with the [native code for web views](https://github.com/react-native-webview/react-native-webview/blob/master/apple/RNCWebViewManager.m), as you will have to use this as a reference when implementing new features—although a deep understanding is not required.
+
+## Native Code
+
+Like for regular native components, you need a view manager and an web view.
+
+For the view, you'll need to make a subclass of `RCTWebView`.
+
+```objc
+// RCTCustomWebView.h
+#import
+
+@interface RCTCustomWebView : RCTWebView
+
+@end
+
+// RCTCustomWebView.m
+#import "RCTCustomWebView.h"
+
+@interface RCTCustomWebView ()
+
+@end
+
+@implementation RCTCustomWebView { }
+
+@end
+```
+
+For the view manager, you need to make a subclass `RCTWebViewManager`. You must still include:
+
+- `(UIView *)view` that returns your custom view
+- The `RCT_EXPORT_MODULE()` tag
+
+```objc
+// RCTCustomWebViewManager.h
+#import
+
+@interface RCTCustomWebViewManager : RCTWebViewManager
+
+@end
+
+// RCTCustomWebViewManager.m
+#import "RCTCustomWebViewManager.h"
+#import "RCTCustomWebView.h"
+
+@interface RCTCustomWebViewManager ()
+
+@end
+
+@implementation RCTCustomWebViewManager { }
+
+RCT_EXPORT_MODULE()
+
+- (UIView *)view
+{
+ RCTCustomWebView *webView = [RCTCustomWebView new];
+ webView.delegate = self;
+ return webView;
+}
+
+@end
+```
+
+### Adding New Events and Properties
+
+Adding new properties and events is the same as regular UI components. For properties, you define an `@property` in the header. For events, you define a `RCTDirectEventBlock` in the view's `@interface`.
+
+```objc
+// RCTCustomWebView.h
+@property (nonatomic, copy) NSString *finalUrl;
+
+// RCTCustomWebView.m
+@interface RCTCustomWebView ()
+
+@property (nonatomic, copy) RCTDirectEventBlock onNavigationCompleted;
+
+@end
+```
+
+Then expose it in the view manager's `@implementation`.
+
+```objc
+// RCTCustomWebViewManager.m
+RCT_EXPORT_VIEW_PROPERTY(onNavigationCompleted, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(finalUrl, NSString)
+```
+
+### Extending Existing Events
+
+You should refer to [RCTWebView.m](https://github.com/react-native-webview/react-native-webview/blob/master/apple/RNCWebView.m) in the React Native WebView codebase to see what handlers are available and how they are implemented. You can extend any methods here to provide extra functionality.
+
+By default, most methods aren't exposed from RCTWebView. If you need to expose them, you need to create an [Objective C category](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html), and then expose all the methods you need to use.
+
+```objc
+// RCTWebView+Custom.h
+#import
+
+@interface RCTWebView (Custom)
+- (BOOL)webView:(__unused UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType;
+- (NSMutableDictionary *)baseEvent;
+@end
+```
+
+Once these are exposed, you can reference them in your custom web view class.
+
+```objc
+// RCTCustomWebView.m
+
+// Remember to import the category file.
+#import "RCTWebView+Custom.h"
+
+- (BOOL)webView:(__unused UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request
+ navigationType:(UIWebViewNavigationType)navigationType
+{
+ BOOL allowed = [super webView:webView shouldStartLoadWithRequest:request navigationType:navigationType];
+
+ if (allowed) {
+ NSString* url = request.URL.absoluteString;
+ if (url && [url isEqualToString:_finalUrl]) {
+ if (_onNavigationCompleted) {
+ NSMutableDictionary *event = [self baseEvent];
+ _onNavigationCompleted(event);
+ }
+ }
+ }
+
+ return allowed;
+}
+```
+
+## JavaScript Interface
+
+To use your custom web view, you'll need to create a class for it. Your class must:
+
+- Export all the prop types from `WebView.propTypes`
+- Return a `WebView` component with the prop `nativeConfig.component` set to your native component (see below)
+
+To get your native component, you must use `requireNativeComponent`: the same as for regular custom components. However, you must pass in an extra third argument, `WebView.extraNativeComponentConfig`. This third argument contains prop types that are only required for native code.
+
+```jsx
+import React, { Component, PropTypes } from 'react';
+import {
+ WebView,
+ requireNativeComponent,
+ NativeModules
+} from 'react-native';
+const { CustomWebViewManager } = NativeModules;
+
+export default class CustomWebView extends Component {
+ static propTypes = WebView.propTypes;
+
+ render() {
+ return (
+
+ );
+ }
+}
+
+const RCTCustomWebView = requireNativeComponent(
+ 'RCTCustomWebView',
+ CustomWebView,
+ WebView.extraNativeComponentConfig
+);
+```
+
+If you want to add custom props to your native component, you can use `nativeConfig.props` on the web view. For iOS, you should also set the `nativeConfig.viewManager` prop with your custom WebView ViewManager as in the example above.
+
+For events, the event handler must always be set to a function. This means it isn't safe to use the event handler directly from `this.props`, as the user might not have provided one. The standard approach is to create a event handler in your class, and then invoking the event handler given in `this.props` if it exists.
+
+If you are unsure how something should be implemented from the JS side, look at [WebView.ios.tsx](https://github.com/react-native-webview/react-native-webview/blob/master/src/WebView.ios.tsx) in the React Native source.
+
+```jsx
+export default class CustomWebView extends Component {
+ static propTypes = {
+ ...WebView.propTypes,
+ finalUrl: PropTypes.string,
+ onNavigationCompleted: PropTypes.func
+ };
+
+ static defaultProps = {
+ finalUrl: 'about:blank'
+ };
+
+ _onNavigationCompleted = (event) => {
+ const { onNavigationCompleted } = this.props;
+ onNavigationCompleted && onNavigationCompleted(event);
+ };
+
+ render() {
+ return (
+
+ );
+ }
+}
+```
+
+Similar to regular native components, you must provide all your prop types in the component to have them forwarded on to the native component. However, if you have some prop types that are only used internally in component, you can add them to the `nativeOnly` property of the third argument previously mentioned. For event handlers, you have to use the value `true` instead of a regular prop type.
+
+For example, if you wanted to add an internal event handler called `onScrollToBottom`, you would use,
+
+```jsx
+const RCTCustomWebView = requireNativeComponent(
+ 'RCTCustomWebView',
+ CustomWebView,
+ {
+ ...WebView.extraNativeComponentConfig,
+ nativeOnly: {
+ ...WebView.extraNativeComponentConfig.nativeOnly,
+ onScrollToBottom: true
+ }
+ }
+);
+```
diff --git a/website/versioned_docs/version-0.70/datepickerandroid.md b/website/versioned_docs/version-0.70/datepickerandroid.md
new file mode 100644
index 00000000000..ed943d6cbf1
--- /dev/null
+++ b/website/versioned_docs/version-0.70/datepickerandroid.md
@@ -0,0 +1,74 @@
+---
+id: datepickerandroid
+title: '🚧 DatePickerAndroid'
+---
+
+> **Deprecated.** Use one of the [community packages](https://reactnative.directory/?search=datepicker) instead.
+
+Opens the standard Android date picker dialog.
+
+### Example
+
+```jsx
+try {
+ const { action, year, month, day } =
+ await DatePickerAndroid.open({
+ // Use `new Date()` for current date.
+ // May 25 2020. Month 0 is January.
+ date: new Date(2020, 4, 25)
+ });
+ if (action !== DatePickerAndroid.dismissedAction) {
+ // Selected year, month (0-11), day
+ }
+} catch ({ code, message }) {
+ console.warn('Cannot open date picker', message);
+}
+```
+
+---
+
+# Reference
+
+## Methods
+
+### `open()`
+
+```jsx
+static open(options)
+```
+
+Opens the standard Android date picker dialog.
+
+The available keys for the `options` object are:
+
+- `date` (`Date` object or timestamp in milliseconds) - date to show by default
+- `minDate` (`Date` or timestamp in milliseconds) - minimum date that can be selected
+- `maxDate` (`Date` object or timestamp in milliseconds) - maximum date that can be selected
+- `mode` (`enum('calendar', 'spinner', 'default')`) - To set the date-picker mode to calendar/spinner/default
+ - 'calendar': Show a date picker in calendar mode.
+ - 'spinner': Show a date picker in spinner mode.
+ - 'default': Show a default native date picker(spinner/calendar) based on android versions.
+
+Returns a Promise which will be invoked an object containing `action`, `year`, `month` (0-11), `day` if the user picked a date. If the user dismissed the dialog, the Promise will still be resolved with action being `DatePickerAndroid.dismissedAction` and all the other keys being undefined. **Always** check whether the `action` is equal to `DatePickerAndroid.dateSetAction` before reading the values.
+
+Note the native date picker dialog has some UI glitches on Android 4 and lower when using the `minDate` and `maxDate` options.
+
+---
+
+### `dateSetAction()`
+
+```jsx
+static dateSetAction()
+```
+
+A date has been selected.
+
+---
+
+### `dismissedAction()`
+
+```jsx
+static dismissedAction()
+```
+
+The dialog has been dismissed.
diff --git a/website/versioned_docs/version-0.70/datepickerios.md b/website/versioned_docs/version-0.70/datepickerios.md
new file mode 100644
index 00000000000..b20f41ccba4
--- /dev/null
+++ b/website/versioned_docs/version-0.70/datepickerios.md
@@ -0,0 +1,213 @@
+---
+id: datepickerios
+title: '🚧 DatePickerIOS'
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+> **Deprecated.** Use one of the [community packages](https://reactnative.directory/?search=datepicker) instead.
+
+Use `DatePickerIOS` to render a date/time picker (selector) on iOS. This is a controlled component, so you must hook in to the `onDateChange` callback and update the `date` prop in order for the component to update, otherwise the user's change will be reverted immediately to reflect `props.date` as the source of truth.
+
+### Example
+
+
+
+
+```SnackPlayer name=DatePickerIOS&supportedPlatforms=ios
+import React, {useState} from 'react';
+import {DatePickerIOS, View, StyleSheet} from 'react-native';
+
+const App = () => {
+
+ const [chosenDate, setChosenDate] = useState(new Date());
+
+ return (
+
+
+
+ );
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center',
+ },
+});
+
+export default App;
+```
+
+
+
+
+```SnackPlayer name=DatePickerIOS&supportedPlatforms=ios
+import React, {Component} from 'react';
+import {DatePickerIOS, View, StyleSheet} from 'react-native';
+
+export default class App extends Component {
+ constructor(props) {
+ super(props);
+ this.state = {chosenDate: new Date()};
+
+ this.setDate = this.setDate.bind(this);
+ }
+
+ setDate(newDate) {
+ this.setState({chosenDate: newDate});
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+}
+
+const styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ justifyContent: 'center',
+ },
+});
+```
+
+
+
+
+---
+
+# Reference
+
+## Props
+
+Inherits [View Props](view.md#props).
+
+### `date`
+
+The currently selected date.
+
+| Type | Required |
+| ---- | -------- |
+| Date | Yes |
+
+---
+
+### `onChange`
+
+Date change handler.
+
+This is called when the user changes the date or time in the UI. The first and only argument is an Event. For getting the date the picker was changed to, use onDateChange instead.
+
+| Type | Required |
+| -------- | -------- |
+| function | No |
+
+---
+
+### `onDateChange`
+
+Date change handler.
+
+This is called when the user changes the date or time in the UI. The first and only argument is a Date object representing the new date and time.
+
+| Type | Required |
+| -------- | -------- |
+| function | Yes |
+
+---
+
+### `maximumDate`
+
+Maximum date.
+
+Restricts the range of possible date/time values.
+
+| Type | Required |
+| ---- | -------- |
+| Date | No |
+
+Example with `maximumDate` set to December 31, 2017:
+
+
+
+---
+
+### `minimumDate`
+
+Minimum date.
+
+Restricts the range of possible date/time values.
+
+| Type | Required |
+| ---- | -------- |
+| Date | No |
+
+See [`maximumDate`](#maximumdate) for an example image.
+
+---
+
+### `minuteInterval`
+
+The interval at which minutes can be selected.
+
+| Type | Required |
+| ------------------------------------------ | -------- |
+| enum(1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30) | No |
+
+Example with `minuteInterval` set to `10`:
+
+
+
+---
+
+### `mode`
+
+The date picker mode.
+
+| Type | Required |
+| --------------------------------------------- | -------- |
+| enum('date', 'time', 'datetime', 'countdown') | No |
+
+Example with `mode` set to `date`, `time`, and `datetime`: 
+
+---
+
+### `locale`
+
+The locale for the date picker. Value needs to be a [Locale ID](https://developer.apple.com/library/content/documentation/MacOSX/Conceptual/BPInternational/LanguageandLocaleIDs/LanguageandLocaleIDs.html).
+
+| Type | Required |
+| ------ | -------- |
+| String | No |
+
+---
+
+### `timeZoneOffsetInMinutes`
+
+Timezone offset in minutes.
+
+By default, the date picker will use the device's timezone. With this parameter, it is possible to force a certain timezone offset. For instance, to show times in Pacific Standard Time, pass -7 \* 60.
+
+| Type | Required |
+| ------ | -------- |
+| number | No |
+
+---
+
+### `initialDate`
+
+Provides an initial value that will change when the user starts selecting a date. It is useful for use-cases where you do not want to deal with listening to events and updating the date prop to keep the controlled state in sync. The controlled state has known bugs which causes it to go out of sync with native. The initialDate prop is intended to allow you to have native be source of truth.
+
+| Type | Required |
+| ---- | -------- |
+| Date | No |
diff --git a/website/versioned_docs/version-0.70/debugging.md b/website/versioned_docs/version-0.70/debugging.md
new file mode 100644
index 00000000000..1aac31a688c
--- /dev/null
+++ b/website/versioned_docs/version-0.70/debugging.md
@@ -0,0 +1,202 @@
+---
+id: debugging
+title: Debugging
+---
+
+import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; import constants from '@site/core/TabsConstants';
+
+## Accessing the In-App Developer Menu
+
+You can access the developer menu by shaking your device or by selecting "Shake Gesture" inside the Hardware menu in the iOS Simulator. You can also use the `⌘D` keyboard shortcut when your app is running in the iOS Simulator, or `⌘M` when running in an Android emulator on macOS and `Ctrl+M` on Windows and Linux. Alternatively for Android, you can run the command `adb shell input keyevent 82` to open the dev menu (82 being the Menu key code).
+
+
+
+> The Developer Menu is disabled in release (production) builds.
+
+## Enabling Fast Refresh
+
+Fast Refresh is a React Native feature that allows you to get near-instant feedback for changes in your React components. While debugging, it can help to have [Fast Refresh](fast-refresh.md) enabled. Fast Refresh is enabled by default, and you can toggle "Enable Fast Refresh" in the React Native developer menu. When enabled, most of your edits should be visible within a second or two.
+
+## Enabling Keyboard Shortcuts
+
+React Native supports a few keyboard shortcuts in the iOS Simulator. They are described below. To enable them on macOS, inside the Simulator app, open the I/O menu, select Keyboard, and make sure that "Connect Hardware Keyboard" is checked.
+
+## LogBox
+
+Errors and warnings in development builds are displayed in LogBox inside your app.
+
+> LogBox is automatically disabled in release (production) builds.
+
+### Console Errors and Warnings
+
+Console errors and warnings are displayed as on-screen notifications with a red or yellow badge, and the number of errors or warning in the console respectively. To view a console error or warnings, tap the notification to view the full screen information about the log and to paginate through all of the logs in the console.
+
+These notifications can be hidden using `LogBox.ignoreAllLogs()`. This is useful when giving product demos, for example. Additionally, notifications can be hidden on a per-log basis via `LogBox.ignoreLogs()`. This is useful when there's a noisy warning that cannot be fixed, like those in a third-party dependency.
+
+> Ignore logs as a last resort and create a task to fix any logs that are ignored.
+
+```jsx
+import { LogBox } from 'react-native';
+
+// Ignore log notification by message:
+LogBox.ignoreLogs(['Warning: ...']);
+
+// Ignore all log notifications:
+LogBox.ignoreAllLogs();
+```
+
+### Unhandled Errors
+
+Unhandled JavaScript errors such as `undefined is not a function` will automatically open a full screen LogBox error with the source of the error. These errors are dismissable and minimizable so that you can see the state of your app when these errors occur, but should always be addressed.
+
+### Syntax Errors
+
+When syntax error occurs the full screen LogBox error will automatically open with the stack trace and location of the syntax error. This error is not dismissable because it represents invalid JavaScript execution that must be fixed before continuing with your app. To dismiss these errors, fix the syntax error and either save to automatically dismiss (with Fast Refresh enabled) or cmd+r to reload (with Fast Refresh disabled).
+
+## Chrome Developer Tools
+
+To debug the JavaScript code in Chrome, select "Debug JS Remotely" from the Developer Menu. This will open a new tab at [http://localhost:8081/debugger-ui](http://localhost:8081/debugger-ui).
+
+Select `Tools → Developer Tools` from the Chrome Menu to open the [Developer Tools](https://developer.chrome.com/devtools). You may also access the DevTools using keyboard shortcuts (`⌘⌥I` on macOS, `Ctrl` `Shift` `I` on Windows). You may also want to enable [Pause On Caught Exceptions](http://stackoverflow.com/questions/2233339/javascript-is-there-a-way-to-get-chrome-to-break-on-all-errors/17324511#17324511) for a better debugging experience.
+
+> Note: on Android, if the times between the debugger and device have drifted; things such as animation, event behavior, etc., might not work properly or the results may not be accurate. Please correct this by running `` adb shell "date `date +%m%d%H%M%Y.%S%3N`" `` on your debugger machine. Root access is required for the use in real device.
+
+> Note: the React Developer Tools Chrome extension does not work with React Native, but you can use its standalone version instead. Read [this section](debugging.md#react-developer-tools) to learn how.
+
+### Debugging using a custom JavaScript debugger
+
+To use a custom JavaScript debugger in place of Chrome Developer Tools, set the `REACT_DEBUGGER` environment variable to a command that will start your custom debugger. You can then select "Debug JS Remotely" from the Developer Menu to start debugging.
+
+The debugger will receive a list of all project roots, separated by a space. For example, if you set `REACT_DEBUGGER="node /path/to/launchDebugger.js --port 2345 --type ReactNative"`, then the command `node /path/to/launchDebugger.js --port 2345 --type ReactNative /path/to/reactNative/app` will be used to start your debugger.
+
+> Custom debugger commands executed this way should be short-lived processes, and they shouldn't produce more than 200 kilobytes of output.
+
+## Safari Developer Tools
+
+You can use Safari to debug the iOS version of your app without having to enable "Debug JS Remotely".
+
+- On a physical device go to: `Settings → Safari → Advanced → Make sure "Web Inspector" is turned on` (This step is not needed on the Simulator)
+- On your Mac enable Develop menu in Safari: `Preferences → Advanced → Select "Show Develop menu in menu bar"`
+- Select your app's JSContext: `Develop → Simulator (or other device) → JSContext`
+- Safari's Web Inspector should open which has a Console and a Debugger
+
+While sourcemaps may not be enabled by default, you can follow [this guide](http://blog.nparashuram.com/2019/10/debugging-react-native-ios-apps-with.html) or [video](https://www.youtube.com/watch?v=GrGqIIz51k4) to enable them and set break points at the right places in the source code.
+
+However, every time the app is reloaded (using live reload, or by manually reloading), a new JSContext is created. Choosing "Automatically Show Web Inspectors for JSContexts" saves you from having to select the latest JSContext manually.
+
+## React Developer Tools
+
+You can use [the standalone version of React Developer Tools](https://github.com/facebook/react/tree/main/packages/react-devtools) to debug the React component hierarchy. To use it, install the `react-devtools` package globally:
+
+> Note: Version 4 of `react-devtools` requires `react-native` version 0.62 or higher to work properly.
+
+
+
+
+```shell
+npm install -g react-devtools
+```
+
+
+
+
+```shell
+yarn global add react-devtools
+```
+
+
+
+
+Now run `react-devtools` from the terminal to launch the standalone DevTools app:
+
+```shell
+react-devtools
+```
+
+
+
+It should connect to your simulator within a few seconds.
+
+:::info
+If connecting to the emulator proves troublesome (especially Android 12), try running `adb reverse tcp:8097 tcp:8097` in a new terminal.
+:::
+
+:::info
+If you prefer to avoid global installations, you can add `react-devtools` as a project dependency. Add the `react-devtools` package to your project using `npm install --save-dev react-devtools`, then add `"react-devtools": "react-devtools"` to the `scripts` section in your `package.json`, and then run `npm run react-devtools` from your project folder to open the DevTools.
+:::
+
+### Integration with React Native Inspector
+
+Open the in-app developer menu and choose "Toggle Inspector". It will bring up an overlay that lets you tap on any UI element and see information about it:
+
+
+
+However, when `react-devtools` is running, Inspector will enter a collapsed mode, and instead use the DevTools as primary UI. In this mode, clicking on something in the simulator will bring up the relevant components in the DevTools:
+
+
+
+You can choose "Toggle Inspector" in the same menu to exit this mode.
+
+### Inspecting Component Instances
+
+When debugging JavaScript in Chrome, you can inspect the props and state of the React components in the browser console.
+
+First, follow the instructions for debugging in Chrome to open the Chrome console.
+
+Make sure that the dropdown in the top left corner of the Chrome console says `debuggerWorker.js`. **This step is essential.**
+
+Then select a React component in React DevTools. There is a search box at the top that helps you find one by name. As soon as you select it, it will be available as `$r` in the Chrome console, letting you inspect its props, state, and instance properties.
+
+
+
+## Performance Monitor
+
+You can enable a performance overlay to help you debug performance problems by selecting "Perf Monitor" in the Developer Menu.
+
+
+
+## Debugging Application State
+
+[Reactotron](https://github.com/infinitered/reactotron) is an open-source desktop app that allows you to inspect Redux or MobX-State-Tree application state as well as view custom logs, run custom commands such as resetting state, store and restore state snapshots, and other helpful debugging features for React Native apps.
+
+You can view installation instructions [in the README](https://github.com/infinitered/reactotron). If you're using Expo, here is an article detailing [how to install on Expo](https://shift.infinite.red/start-using-reactotron-in-your-expo-project-today-in-3-easy-steps-a03d11032a7a).
+
+# Native Debugging
+
+
+
Projects with Native Code Only
+
+ The following section only applies to projects with native code exposed. If you are using the managed Expo workflow, see the guide on prebuild to use this API.
+
+
+
+## Accessing console logs
+
+You can display the console logs for an iOS or Android app by using the following commands in a terminal while the app is running:
+
+```shell
+npx react-native log-ios
+npx react-native log-android
+```
+
+You may also access these through `Debug → Open System Log...` in the iOS Simulator or by running `adb logcat *:S ReactNative:V ReactNativeJS:V` in a terminal while an Android app is running on a device or emulator.
+
+> If you're using Create React Native App or Expo CLI, console logs already appear in the same terminal output as the bundler.
+
+## Debugging on a device with Chrome Developer Tools
+
+> If you're using Create React Native App or Expo CLI, this is configured for you already.
+
+On iOS devices, open the file [`RCTWebSocketExecutor.mm`](https://github.com/facebook/react-native/blob/master/React/CoreModules/RCTWebSocketExecutor.mm) and change "localhost" to the IP address of your computer, then select "Debug JS Remotely" from the Developer Menu.
+
+On Android 5.0+ devices connected via USB, you can use the [`adb` command line tool](http://developer.android.com/tools/help/adb.html) to setup port forwarding from the device to your computer:
+
+`adb reverse tcp:8081 tcp:8081`
+
+Alternatively, select "Dev Settings" from the Developer Menu, then update the "Debug server host for device" setting to match the IP address of your computer.
+
+> If you run into any issues, it may be possible that one of your Chrome extensions is interacting in unexpected ways with the debugger. Try disabling all of your extensions and re-enabling them one-by-one until you find the problematic extension.
+
+## Debugging native code
+
+When working with native code, such as when writing native modules, you can launch the app from Android Studio or Xcode and take advantage of the native debugging features (setting up breakpoints, etc.) as you would in case of building a standard native app.
diff --git a/website/versioned_docs/version-0.70/devsettings.md b/website/versioned_docs/version-0.70/devsettings.md
new file mode 100644
index 00000000000..1c46f3bcd8f
--- /dev/null
+++ b/website/versioned_docs/version-0.70/devsettings.md
@@ -0,0 +1,51 @@
+---
+id: devsettings
+title: DevSettings
+---
+
+The `DevSettings` module exposes methods for customizing settings for developers in development.
+
+---
+
+# Reference
+
+## Methods
+
+### `addMenuItem()`
+
+```jsx
+static addMenuItem(title, handler)
+```
+
+Add a custom menu item to the developer menu.
+
+**Parameters:**
+
+| Name | Type |
+| ------------------------------------------------------------ | -------- |
+| title
Required
| string |
+| handler
Required
| function |
+
+**Example:**
+
+```jsx
+DevSettings.addMenuItem('Show Secret Dev Screen', () => {
+ Alert.alert('Showing secret dev screen!');
+});
+```
+
+---
+
+### `reload()`
+
+```jsx
+static reload()
+```
+
+Reload the application. Can be invoked directly or on user interaction.
+
+**Example:**
+
+```jsx
+
