KeyboardStickyView - only footer is moving (container is not
+ resized)
+
+ }
+ rightText={
+
+ KeyboardAvoidingView - entire container is getting resized
+
+ }
+/>
+
+## Example
+
+```tsx
+const offset = { closed: 0, opened: 20 };
+
+const StickyFooter = () => {
+ return (
+
+
+
+## Features
+
+- **Fully customizable UI** 🎨: Tailor the appearance of the toolbar to match your app's design.
+- **Supports dark/light theme** 🌓: Adapts to the theme settings of the user's device for a seamless experience.
+- **Extended accessibility support** 🔍: Ensures that all users, including those with disabilities, can navigate through inputs effectively.
+- **Full control over the buttons behavior** 🔧: Customize the actions triggered by the next, previous, and done buttons according to your needs.
+
+## Props
+
+### `button`
+
+This property allows to render custom touchable component for next, previous and done button.
+
+```tsx
+import { TouchableOpacity } from "react-native-gesture-handler";
+import {
+ KeyboardToolbar,
+ KeyboardToolbarProps,
+} from "react-native-keyboard-controller";
+
+const CustomButton: KeyboardToolbarProps["button"] = ({
+ children,
+ onPress,
+}) =>
+
+
+ This function is called before the keyboard movement starts.{" "}
+
+
+
+ height and progress values will have{" "}
+ destination values, i. e. if keyboard was closed but will appear -
+ these values will have a values like "keyboard is already opened" (
+ progress will be equal to 1 and{" "}
+ height will have non-zero value).
+ +
+
{onStartCode}
+
+ ![]({require("./start.png").default})
+
+
+ {onStartCode}
+
+#### `onMove`
+
+export const onMoveCode = (
+
+
+
+ This function will be called every frame when the keyboard changes its
+ position.
+
+
+
+ +
+
{onMoveCode}
+
+ ![]({require("./move.png").default})
+
+
+ {onMoveCode}
+
+:::info Not precise values
+There is no corresponding events in iOS for this hook. So values will not be perfectly synchronized with the keyboard.
+
+The same is applied to Android < 11 - these OS versions don't have API for getting keyboard positions during an animation.
+:::
+
+#### `onInteractive`
+
+export const onInteractiveCode = (
+
+
+
+ This function will be called every frame when user changes position of the
+ keyboard by the drag.
+
+
+ If finger is released and keyboard animates to its final destination, then the + standard
+
+
+ +
+ If finger is released and keyboard animates to its final destination, then the + standard
onStart/onMove/onEnd lifecycles
+ will be triggered.
+ +
+
{onInteractiveCode}
+
+ ![]({require("./interactive.png").default})
+
+
+ {onInteractiveCode}
+
+:::info Event availability
+This event is available only on Android >= 11. To receive it you need to use [KeyboardGestureArea](./../../keyboard-gesture-area).
+
+On iOS you need to specify `keyboardDismissMode="interactive"` on your `ScrollView`.
+:::
+
+#### `onEnd`
+
+export const onEndCode = (
+
+
+
+
+ This function will be called when the keyboard has completed its movement.
+ The event will contain current keyboard metrics.
+
+
+
+ +
+
{onEndCode}
+
+ ![]({require("./end.png").default})
+
+
+ {onEndCode}
diff --git a/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/interactive.png b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/interactive.png
new file mode 100644
index 000000000..9702e198a
Binary files /dev/null and b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/interactive.png differ
diff --git a/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/move.png b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/move.png
new file mode 100644
index 000000000..5e5e92121
Binary files /dev/null and b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/move.png differ
diff --git a/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/start.png b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/start.png
new file mode 100644
index 000000000..72e5b64d1
Binary files /dev/null and b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-keyboard-handler/start.png differ
diff --git a/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-reanimated-keyboard-animation.md b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-reanimated-keyboard-animation.md
new file mode 100644
index 000000000..25c7d79c7
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/hooks/keyboard/use-reanimated-keyboard-animation.md
@@ -0,0 +1,60 @@
+---
+keywords:
+ [
+ react-native-keyboard-controller,
+ useReanimatedKeyboardAnimation,
+ react-native-reanimated,
+ react hook,
+ ]
+---
+
+# useReanimatedKeyboardAnimation
+
+`useReanimatedKeyboardAnimation` is a hook which gives access to two reanimated values:
+
+- `height` - value which changes between **0** and **keyboardHeight**;
+- `progress` - value which changes between **0** (keyboard closed) and **1** (keyboard opened).
+
+## Example
+
+```tsx
+import { useReanimatedKeyboardAnimation } from "react-native-keyboard-controller";
+
+const { height, progress } = useReanimatedKeyboardAnimation();
+```
+
+Also have a look on [example](https://github.com/kirillzyusko/react-native-keyboard-controller/tree/main/example) app for more comprehensive usage.
+
+## Using with class component
+
+```tsx
+import {
+ KeyboardController,
+ KeyboardContext,
+ AndroidSoftInputModes,
+} from "react-native-keyboard-controller";
+
+class KeyboardAnimation extends React.PureComponent {
+ // 1. use context value
+ static contextType = KeyboardContext;
+
+ componentDidMount() {
+ // 2. set input mode for android to `adjustResize`
+ // (can be omitted if you already have `adjustResize` in `AndroidManifest.xml`)
+ KeyboardController.setInputMode(
+ AndroidSoftInputModes.SOFT_INPUT_ADJUST_RESIZE,
+ );
+ }
+
+ componentWillUnmount() {
+ // 2. return to default input mode (for Android)
+ // in order not to break other part of your app
+ KeyboardController.setDefaultMode();
+ }
+
+ render() {
+ // 3. consume reanimated values 😊
+ const { reanimated } = this.context;
+ }
+}
+```
diff --git a/docs/versioned_docs/version-1.11.0/api/hooks/module/_category_.json b/docs/versioned_docs/version-1.11.0/api/hooks/module/_category_.json
new file mode 100644
index 000000000..cccd2b80c
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/hooks/module/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "📂 Module",
+ "position": 3
+}
diff --git a/docs/versioned_docs/version-1.11.0/api/hooks/module/use-keyboard-controller.md b/docs/versioned_docs/version-1.11.0/api/hooks/module/use-keyboard-controller.md
new file mode 100644
index 000000000..d947f8dbf
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/hooks/module/use-keyboard-controller.md
@@ -0,0 +1,60 @@
+---
+keywords:
+ [
+ react-native-keyboard-controller,
+ useKeyboardController,
+ enabled,
+ disabled,
+ setEnabled,
+ ]
+---
+
+# useKeyboardController
+
+`useKeyboardController` is a hook which gives an access to the state of the `react-native-keyboard-controller` library. It return two values:
+
+- `enabled` - boolean value which indicates whether the library is enabled in app;
+- `setEnabled` - function that changes state of `enabled` property.
+
+This hook can be handy in situations when your app is relying on default window resizing behavior on Android. Once the module is enabled - it moves the app in [edge-to-edge](https://developer.android.com/training/gestures/edge-to-edge) and prevents window from being resized (works as iOS). However if you need default Android behavior you can disable this module where needed and make a gradual integration of this library into your application.
+
+:::caution Use it only when you really need it
+Nonetheless that you can fallback to default Android behavior I still strongly recommend you not to go with this approach just because you'll loose all attractiveness of smooth animated keyboard transitions and your app will not look as great as it possibly can.
+
+Consider to use [KeyboardAvoidingView](../../components/keyboard-avoiding-view.mdx) which also resize the window, but does it with beautiful animated transitions that makes your interactions with app smooth and pleasant.
+:::
+
+## Example
+
+```tsx
+import { useKeyboardController } from "react-native-keyboard-controller";
+
+const { enabled, setEnabled } = useKeyboardController();
+
+setEnabled(false);
+```
+
+Also have a look on [example](https://github.com/kirillzyusko/react-native-keyboard-controller/tree/main/example) app for more comprehensive usage.
+
+## Using with class component
+
+```tsx
+import {
+ KeyboardController,
+ KeyboardContext,
+ AndroidSoftInputModes,
+} from "react-native-keyboard-controller";
+
+class KeyboardAnimation extends React.PureComponent {
+ // 1. use context value
+ static contextType = KeyboardContext;
+
+ componentDidMount() {
+ // 2. get an access to `enabled` and `setEnabled` props
+ const { enabled, setEnabled } = this.context;
+
+ // 3. disable a module on demand in your app
+ setEnabled(false);
+ }
+}
+```
diff --git a/docs/versioned_docs/version-1.11.0/api/keyboard-controller-view.md b/docs/versioned_docs/version-1.11.0/api/keyboard-controller-view.md
new file mode 100644
index 000000000..8a927d742
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/keyboard-controller-view.md
@@ -0,0 +1,46 @@
+---
+sidebar_position: 3
+keywords: [react-native-keyboard-controller, KeyboardControllerView, view]
+---
+
+# KeyboardControllerView
+
+A plain react-native `View` with some additional methods and props. Used internally in [KeyboardProvider](./keyboard-provider.md)
+
+## Props
+
+### `onKeyboardMoveStart`
+
+A callback function which is fired when keyboard starts a transition from one to another state (from closed to open, for example).
+
+### `onKeyboardMove`
+
+A callback function which is fired every time, when keyboard changes its position on the screen.
+
+### `onKeyboardMoveInteractive`
+
+A callback function which is fired every time, when user drags keyboard.
+
+### `onKeyboardMoveEnd`
+
+A callback function which is fired when keyboard finished a transition from one to another state (from closed to open, for example).
+
+### `onFocusedInputLayoutChanged`
+
+A callback function which is fired when layout of focused input gets changed.
+
+### `onFocusedInputTextChanged`
+
+A callback function which is fired every time when user changes a text (types/deletes symbols).
+
+### `statusBarTranslucent`
+
+A boolean prop to indicate whether `StatusBar` should be translucent on `Android` or not.
+
+### `navigationBarTranslucent`
+
+A boolean prop to indicate whether [NavigationBar](https://m2.material.io/design/platform-guidance/android-bars.html#android-navigation-bar) should be translucent on `Android` or not.
+
+### `enabled`
+
+A boolean prop indicating whether the view is active or not. If it's `true` then it moves application to [edge-to-edge](https://developer.android.com/training/gestures/edge-to-edge) mode on Android and setup keyboard callbacks. When `false` - moves app away from [edge-to-edge](https://developer.android.com/training/gestures/edge-to-edge) and removes keyboard listeners.
diff --git a/docs/versioned_docs/version-1.11.0/api/keyboard-controller.md b/docs/versioned_docs/version-1.11.0/api/keyboard-controller.md
new file mode 100644
index 000000000..dcc59e541
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/keyboard-controller.md
@@ -0,0 +1,63 @@
+---
+sidebar_position: 5
+keywords:
+ [
+ react-native-keyboard-controller,
+ react-native,
+ KeyboardController,
+ module,
+ dismiss,
+ dismiss keyboard,
+ windowSoftInputMode,
+ adjustResize,
+ adjustPan,
+ ]
+---
+
+# KeyboardController
+
+The `KeyboardController` module in React Native provides a convenient set of methods for managing the behavior of the keyboard. With seamless runtime adjustments, this module allows developers to dynamically change the `windowSoftInputMode` on Android and dismiss the keyboard on both platforms.
+
+## Methods
+
+### `setInputMode`
+
+This method is used to dynamically change the `windowSoftInputMode` during runtime in an Android application. It takes an argument that specifies the desired input mode. The example provided sets the input mode to `SOFT_INPUT_ADJUST_RESIZE`:
+
+```ts
+KeyboardController.setInputMode(AndroidSoftInputModes.SOFT_INPUT_ADJUST_RESIZE);
+```
+
+### `setDefaultMode`
+
+This method is used to restore the default `windowSoftInputMode` declared in the `AndroidManifest.xml`. It resets the input mode to the default value:
+
+```ts
+KeyboardController.setDefaultMode();
+```
+
+### `dismiss`
+
+This method is used to hide the keyboard. It triggers the dismissal of the keyboard:
+
+```ts
+KeyboardController.dismiss();
+```
+
+:::info What is the difference comparing to `react-native` implementation?
+The equivalent method from `react-native` relies on specific internal components, such as `TextInput`, and may not work as intended if a custom input component is used.
+
+In contrast, the described method enables keyboard dismissal for any focused input, extending functionality beyond the limitations of the default implementation.
+:::
+
+### `setFocusTo`
+
+This method sets focus to the selected field. Possible values:
+
+- `prev` - set focus to the previous field;
+- `current` - set focus to the last focused field (i. e. if keyboard was closed you can restore focus);
+- `next` - set focus to the next field.
+
+```ts
+setFocusTo("next");
+```
diff --git a/docs/versioned_docs/version-1.11.0/api/keyboard-events.md b/docs/versioned_docs/version-1.11.0/api/keyboard-events.md
new file mode 100644
index 000000000..9920b5f0d
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/keyboard-events.md
@@ -0,0 +1,53 @@
+---
+sidebar_position: 6
+keywords:
+ [
+ react-native-keyboard-controller,
+ events,
+ keyboardWillShow,
+ keyboardWillHide,
+ android,
+ iOS,
+ cross platform,
+ ]
+---
+
+# KeyboardEvents
+
+This library exposes 4 events which are available on all platforms:
+
+- keyboardWillShow
+- keyboardWillHide
+- keyboardDidShow
+- keyboardDidHide
+
+## Event structure
+
+All events have following properties:
+
+```ts
+type KeyboardEventData = {
+ height: number; // height of the keyboard
+ duration: number; // duration of the animation
+ timestamp: number; // timestamp of the event from native thread
+ target: number; // tag of the focused TextInput
+};
+```
+
+## Example
+
+```ts
+import { KeyboardEvents } from "react-native-keyboard-controller";
+
+useEffect(() => {
+ const show = KeyboardEvents.addListener("keyboardWillShow", (e) => {
+ // place your code here
+ });
+
+ return () => {
+ show.remove();
+ };
+}, []);
+```
+
+Also have a look on [example](https://github.com/kirillzyusko/react-native-keyboard-controller/tree/main/example) app for more comprehensive usage.
diff --git a/docs/versioned_docs/version-1.11.0/api/keyboard-gesture-area.md b/docs/versioned_docs/version-1.11.0/api/keyboard-gesture-area.md
new file mode 100644
index 000000000..840be5b91
--- /dev/null
+++ b/docs/versioned_docs/version-1.11.0/api/keyboard-gesture-area.md
@@ -0,0 +1,45 @@
+---
+sidebar_position: 4
+keywords:
+ [
+ react-native-keyboard-controller,
+ KeyboardGestureArea,
+ interactive keyboard,
+ view,
+ ]
+---
+
+# KeyboardGestureArea
+
+`KeyboardGestureArea` allows you to define a region on the screen, where gestures will control the keyboard position.
+
+:::info Platform availability
+This component is available only for Android >= 11. For iOS and Android < 11 it will render `React.Fragment`.
+:::
+
+## Props
+
+### `interpolator`
+
+String with possible values `linear` and `ios`:
+
+- **ios** - interactive keyboard dismissing will work as in iOS: swipes in non-keyboard area will not affect keyboard positioning, but if your swipe touches keyboard - keyboard will follow finger position.
+- **linear** - gestures inside the component will linearly affect the position of the keyboard, i.e. if the user swipes down by 20 pixels, then the keyboard will also be moved down by 20 pixels, even if the gesture was not made over the keyboard area.
+
+### `showOnSwipeUp`
+
+A boolean prop which allows to customize interactive keyboard behavior. If set to `true` then it allows to show keyboard (if it's already closed) by swipe up gesture. `false` by default.
+
+### `enableSwipeToDismiss`
+
+A boolean prop which allows to customize interactive keyboard behavior. If set to `false`, then any gesture will not affect keyboard position if the keyboard is shown. `true` by default.
+
+## Example
+
+```tsx
+
+
+
+## Android
+
+### Start point
+
+First of all let's consider a simple example and layout for typical chat application. Of course in real-application layout will be much more complex, but since it's a guide we will consider an over-simplified example to get a main idea.
+
+```tsx
+