diff --git a/apps/android/src/ui/keyboard-inset.tsx b/apps/android/src/ui/keyboard-inset.tsx
index e18a0b5..bfef503 100644
--- a/apps/android/src/ui/keyboard-inset.tsx
+++ b/apps/android/src/ui/keyboard-inset.tsx
@@ -1,9 +1,21 @@
import { createContext, useCallback, useContext, useEffect, useRef, useState, type ReactNode } from 'react'
-import { AppState, Keyboard, LayoutAnimation, Platform, useWindowDimensions, View } from 'react-native'
+import { Animated, AppState, Keyboard, LayoutAnimation, NativeEventEmitter, NativeModules, Platform, useWindowDimensions, View } from 'react-native'
import { useSafeAreaInsets } from 'react-native-safe-area-context'
const KeyboardInsetActiveContext = createContext(false)
+type KeyboardInsetsNativeModule = {
+ startObserving?: () => Promise<{ paddingBottom?: number; imeVisible?: boolean } | null>
+ addListener?: (eventName: string) => void
+ removeListeners?: (count: number) => void
+}
+
+function androidNativeKeyboardInsets(): KeyboardInsetsNativeModule | undefined {
+ if (Platform.OS !== 'android') return undefined
+ const mod = NativeModules?.DshRemoteKeyboardInsets as KeyboardInsetsNativeModule | undefined
+ return mod && typeof mod.startObserving === 'function' ? mod : undefined
+}
+
/**
* Reserve the band the IME covers so the composer/content clears it,
* while respecting edge-to-edge system insets without double-counting.
@@ -26,6 +38,86 @@ const KeyboardInsetActiveContext = createContext(false)
*/
export function KeyboardInset({ children }: { children: ReactNode }) {
const parentActive = useContext(KeyboardInsetActiveContext)
+ if (parentActive) {
+ return {children}
+ }
+ const nativeModule = androidNativeKeyboardInsets()
+ if (nativeModule !== undefined) {
+ return (
+
+ {children}
+
+ )
+ }
+ return (
+
+ {children}
+
+ )
+}
+
+function AndroidNativeKeyboardInset({
+ nativeModule,
+ children,
+}: {
+ nativeModule: KeyboardInsetsNativeModule
+ children: ReactNode
+}) {
+ const insets = useSafeAreaInsets()
+ const safeBottomRef = useRef(insets.bottom)
+ safeBottomRef.current = insets.bottom
+ const animatedPaddingBottom = useRef(new Animated.Value(insets.bottom)).current
+ const imeVisibleRef = useRef(false)
+ const lastNativeDpRef = useRef(null)
+
+ useEffect(() => {
+ if (!imeVisibleRef.current) {
+ const target = lastNativeDpRef.current === null
+ ? insets.bottom
+ : Math.max(insets.bottom, lastNativeDpRef.current)
+ animatedPaddingBottom.setValue(target)
+ }
+ }, [insets.bottom, animatedPaddingBottom])
+
+ useEffect(() => {
+ let active = true
+ const apply = (paddingBottom?: number, imeVisible?: boolean) => {
+ if (!active || typeof paddingBottom !== 'number' || !Number.isFinite(paddingBottom)) return
+ const visible = imeVisible === true
+ imeVisibleRef.current = visible
+ lastNativeDpRef.current = paddingBottom
+ // When the IME is hidden, never dip below the known safe-area bottom inset.
+ animatedPaddingBottom.setValue(visible ? Math.max(0, paddingBottom) : Math.max(safeBottomRef.current, paddingBottom))
+ }
+
+ const emitter = new NativeEventEmitter(nativeModule as NonNullable)
+ const subscription = emitter.addListener(
+ 'remoteKeyboardInsetsChanged',
+ (event: { paddingBottom?: number; imeVisible?: boolean }) => {
+ apply(event?.paddingBottom, event?.imeVisible)
+ },
+ )
+
+ void nativeModule.startObserving?.()
+ .then(initial => {
+ if (initial) apply(initial.paddingBottom, initial.imeVisible)
+ })
+ .catch(() => undefined)
+
+ return () => {
+ active = false
+ subscription.remove()
+ }
+ }, [nativeModule, animatedPaddingBottom])
+
+ return (
+
+ {children}
+
+ )
+}
+
+function FallbackKeyboardInset({ children }: { children: ReactNode }) {
const insets = useSafeAreaInsets()
const { width: windowWidth, height: windowHeight } = useWindowDimensions()
const [keyboardScreenY, setKeyboardScreenY] = useState(null)
@@ -82,10 +174,6 @@ export function KeyboardInset({ children }: { children: ReactNode }) {
const previous = windowRef.current
windowRef.current = { width: windowWidth, height: windowHeight }
if (previous.width === windowWidth && previous.height === windowHeight) return
- // Rotation (or a window resize) moves the IME's top edge too, and Android
- // does not guarantee another keyboardDidShow for the kept-open keyboard.
- // Re-sync from live metrics so padding is not computed from the old
- // orientation; fall back to the safe-area inset when metrics are gone.
if (Keyboard.isVisible()) {
const metrics = Keyboard.metrics()
setKeyboardScreenY(metrics && typeof metrics.screenY === 'number' ? metrics.screenY : null)
@@ -97,9 +185,6 @@ export function KeyboardInset({ children }: { children: ReactNode }) {
useEffect(() => {
const subscription = AppState.addEventListener('change', state => {
if (state === 'active') {
- // When returning to the foreground, re-sync keyboard coordinates.
- // If the keyboard remained open without emitting a new show event, restore the coordinate.
- // If the keyboard closed while in background, clear it so we fall back to insets.bottom.
if (Keyboard.isVisible()) {
const metrics = Keyboard.metrics()
if (metrics && typeof metrics.screenY === 'number') {
@@ -113,22 +198,17 @@ export function KeyboardInset({ children }: { children: ReactNode }) {
return () => subscription.remove()
}, [])
- // When keyboard is open:
- // - If window did not shrink (e.g. Android 15 edge-to-edge): windowHeight - keyboardScreenY gives the exact IME overlap.
- // - If adjustResize already shrunk the window: windowHeight <= keyboardScreenY, cover collapses to 0 (no extra padding).
- // When keyboard is closed:
- // - Reserve insets.bottom so controls clear the navigation/gesture bar.
- const paddingBottom = parentActive
- ? 0
- : keyboardScreenY !== null
- ? Math.max(0, windowHeight - keyboardScreenY)
- : insets.bottom
+ // Discard stale coordinates synchronously if the window just grew back after keyboard close.
+ const windowGrew = windowHeight > windowRef.current.height
+ const effectiveKeyboardScreenY = windowGrew && !Keyboard.isVisible() ? null : keyboardScreenY
+
+ const paddingBottom = effectiveKeyboardScreenY !== null
+ ? Math.max(0, windowHeight - effectiveKeyboardScreenY)
+ : insets.bottom
return (
-
- 0 ? { paddingBottom } : null]}>
- {children}
-
-
+ 0 ? { paddingBottom } : null]}>
+ {children}
+
)
}