diff --git a/__tests__/components/brain/my-stream/layout/LayoutContext.test.tsx b/__tests__/components/brain/my-stream/layout/LayoutContext.test.tsx
index 5873410011..14de060876 100644
--- a/__tests__/components/brain/my-stream/layout/LayoutContext.test.tsx
+++ b/__tests__/components/brain/my-stream/layout/LayoutContext.test.tsx
@@ -2,7 +2,18 @@ import React, { useEffect, useRef } from 'react';
 import { render, screen } from '@testing-library/react';
 import { LayoutProvider, useLayout } from '@/components/brain/my-stream/layout/LayoutContext';
 
-jest.mock('@/hooks/useCapacitor', () => ({ __esModule: true, default: () => ({ isCapacitor: false, isAndroid: false, isIos: false }) }));
+// Mock useCapacitor hook with configurable values
+let mockCapacitorValues = { isCapacitor: false, isAndroid: false, isIos: false };
+jest.mock('@/hooks/useCapacitor', () => ({
+  __esModule: true,
+  default: () => mockCapacitorValues
+}));
+
+// Mock useAndroidKeyboard hook with configurable values
+let mockKeyboardValues = { isVisible: false, keyboardHeight: 0, isAndroid: false, getContainerStyle: jest.fn() };
+jest.mock('@/hooks/useAndroidKeyboard', () => ({
+  useAndroidKeyboard: () => mockKeyboardValues
+}));
 
 beforeAll(() => {
   // run RAF callbacks immediately
@@ -19,6 +30,12 @@ afterAll(() => {
   delete (global as any).requestAnimationFrame;
 });
 
+beforeEach(() => {
+  // Reset mocks before each test
+  mockCapacitorValues = { isCapacitor: false, isAndroid: false, isIos: false };
+  mockKeyboardValues = { isVisible: false, keyboardHeight: 0, isAndroid: false, getContainerStyle: jest.fn() };
+});
+
 function TestComponent() {
   const { registerRef, spaces, waveViewStyle } = useLayout();
   const ref = useRef<HTMLDivElement>(null);
@@ -39,7 +56,7 @@ function TestComponent() {
 
 describe('LayoutProvider', () => {
   it('calculates spaces and styles', () => {
-    Object.defineProperty(window, 'innerHeight', { value: 1000, configurable: true });
+    Object.defineProperty(globalThis, 'innerHeight', { value: 1000, configurable: true });
     render(
       <LayoutProvider>
         <TestComponent />
@@ -49,4 +66,66 @@ describe('LayoutProvider', () => {
     expect(content.textContent).toBe('900');
     expect(content.style.height).toContain('calc(100dvh - 100px');
   });
+
+  it('applies 128px capSpace on Android when keyboard is closed', () => {
+    mockCapacitorValues = { isCapacitor: true, isAndroid: true, isIos: false };
+    mockKeyboardValues = { isVisible: false, keyboardHeight: 0, isAndroid: true, getContainerStyle: jest.fn() };
+
+    Object.defineProperty(globalThis, 'innerHeight', { value: 1000, configurable: true });
+    render(
+      <LayoutProvider>
+        <TestComponent />
+      </LayoutProvider>
+    );
+    const content = screen.getByTestId('content');
+    // Should include 128px capSpace
+    expect(content.style.height).toContain('- 128px');
+  });
+
+  it('removes capSpace and subtracts keyboard height on Android when keyboard is open', () => {
+    mockCapacitorValues = { isCapacitor: true, isAndroid: true, isIos: false };
+    mockKeyboardValues = { isVisible: true, keyboardHeight: 350, isAndroid: true, getContainerStyle: jest.fn() };
+
+    Object.defineProperty(globalThis, 'innerHeight', { value: 1000, configurable: true });
+    render(
+      <LayoutProvider>
+        <TestComponent />
+      </LayoutProvider>
+    );
+    const content = screen.getByTestId('content');
+    // Should subtract keyboard height (350px) but not capSpace
+    expect(content.style.height).toContain('- 350px');
+    expect(content.style.height).not.toContain('- 128px');
+  });
+
+  it('applies 20px capSpace on iOS', () => {
+    mockCapacitorValues = { isCapacitor: true, isAndroid: false, isIos: true };
+    mockKeyboardValues = { isVisible: false, keyboardHeight: 0, isAndroid: false, getContainerStyle: jest.fn() };
+
+    Object.defineProperty(globalThis, 'innerHeight', { value: 1000, configurable: true });
+    render(
+      <LayoutProvider>
+        <TestComponent />
+      </LayoutProvider>
+    );
+    const content = screen.getByTestId('content');
+    // Should include 20px capSpace for iOS
+    expect(content.style.height).toContain('- 20px');
+  });
+
+  it('does not apply capSpace on desktop', () => {
+    mockCapacitorValues = { isCapacitor: false, isAndroid: false, isIos: false };
+    mockKeyboardValues = { isVisible: false, keyboardHeight: 0, isAndroid: false, getContainerStyle: jest.fn() };
+
+    Object.defineProperty(globalThis, 'innerHeight', { value: 1000, configurable: true });
+    render(
+      <LayoutProvider>
+        <TestComponent />
+      </LayoutProvider>
+    );
+    const content = screen.getByTestId('content');
+    // Should not include any capSpace
+    expect(content.style.height).not.toContain('- 128px');
+    expect(content.style.height).not.toContain('- 20px');
+  });
 });
diff --git a/__tests__/components/waves/drop/SingleWaveDropChat.test.tsx b/__tests__/components/waves/drop/SingleWaveDropChat.test.tsx
index 301c1077e1..c802de3914 100644
--- a/__tests__/components/waves/drop/SingleWaveDropChat.test.tsx
+++ b/__tests__/components/waves/drop/SingleWaveDropChat.test.tsx
@@ -5,12 +5,26 @@ import { SingleWaveDropChat } from '@/components/waves/drop/SingleWaveDropChat';
 jest.mock('@/hooks/useCapacitor', () => () => false);
 jest.mock('@/components/brain/my-stream/layout/LayoutContext', () => ({ useLayout: () => ({ spaces: { measurementsComplete: true, headerSpace: 10 } }) }));
 
+// Mock useAndroidKeyboard with configurable values
+let mockKeyboardVisible = false;
+let mockGetContainerStyle = jest.fn((baseStyle: any) => baseStyle);
+
+jest.mock('@/hooks/useAndroidKeyboard', () => ({
+  useAndroidKeyboard: () => ({
+    isVisible: mockKeyboardVisible,
+    keyboardHeight: mockKeyboardVisible ? 350 : 0,
+    isAndroid: true,
+    getContainerStyle: mockGetContainerStyle,
+  }),
+}));
+
 let capturedProps: any;
+let capturedCreatorProps: any;
 jest.mock('@/components/waves/drops/wave-drops-all', () => ({ __esModule: true, default: (props: any) => { capturedProps = props; return <div data-testid="drops-all" />; } }));
 
-jest.mock('@/components/waves/CreateDropWaveWrapper', () => ({ CreateDropWaveWrapper: ({ children }: any) => <div>{children}</div>, CreateDropWaveWrapperContext: { SINGLE_DROP: 'SINGLE_DROP' } }));
+jest.mock('@/components/waves/CreateDropWaveWrapper', () => ({ CreateDropWaveWrapper: ({ children }: any) => <div data-testid="wrapper">{children}</div>, CreateDropWaveWrapperContext: { SINGLE_DROP: 'SINGLE_DROP' } }));
 
-jest.mock('@/components/waves/PrivilegedDropCreator', () => ({ __esModule: true, default: (props: any) => <div data-testid="creator" onClick={props.onCancelReplyQuote} data-part={props.activeDrop?.partId} data-action={props.activeDrop?.action} />, DropMode: { BOTH: 'BOTH' } }));
+jest.mock('@/components/waves/PrivilegedDropCreator', () => ({ __esModule: true, default: (props: any) => { capturedCreatorProps = props; return <button data-testid="creator" type="button" onClick={props.onCancelReplyQuote} data-part={props.activeDrop?.partId} data-action={props.activeDrop?.action} />; }, DropMode: { BOTH: 'BOTH' } }));
 
 // Mock window.matchMedia for useDeviceInfo hook
 Object.defineProperty(window, 'matchMedia', {
@@ -28,6 +42,12 @@ Object.defineProperty(window, 'matchMedia', {
 });
 
 describe('SingleWaveDropChat', () => {
+  beforeEach(() => {
+    mockKeyboardVisible = false;
+    mockGetContainerStyle.mockClear();
+    mockGetContainerStyle.mockImplementation((baseStyle: any) => baseStyle);
+  });
+
   it('handles reply and reset actions', () => {
     const wave: any = { id: 'w1' };
     const drop: any = { id: 'd1' };
@@ -42,4 +62,36 @@ describe('SingleWaveDropChat', () => {
     fireEvent.click(document.querySelector('[data-testid="creator"]')!);
     expect(document.querySelector('[data-part="1"]')).toBeInTheDocument();
   });
+
+  it('applies 0px padding when keyboard is visible', () => {
+    mockKeyboardVisible = true;
+
+    const wave: any = { id: 'w1' };
+    const drop: any = { id: 'd1' };
+    render(<SingleWaveDropChat wave={wave} drop={drop} />);
+
+    // getContainerStyle should have been called with paddingBottom: "0px"
+    expect(mockGetContainerStyle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        paddingBottom: '0px',
+      }),
+      0
+    );
+  });
+
+  it('applies safe-area-inset-bottom padding when keyboard is hidden', () => {
+    mockKeyboardVisible = false;
+
+    const wave: any = { id: 'w1' };
+    const drop: any = { id: 'd1' };
+    render(<SingleWaveDropChat wave={wave} drop={drop} />);
+
+    // getContainerStyle should have been called with paddingBottom: safe-area-inset-bottom
+    expect(mockGetContainerStyle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        paddingBottom: 'calc(env(safe-area-inset-bottom))',
+      }),
+      0
+    );
+  });
 });
diff --git a/__tests__/hooks/useAndroidKeyboard.test.ts b/__tests__/hooks/useAndroidKeyboard.test.ts
new file mode 100644
index 0000000000..86378e51f2
--- /dev/null
+++ b/__tests__/hooks/useAndroidKeyboard.test.ts
@@ -0,0 +1,345 @@
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { useAndroidKeyboard } from '@/hooks/useAndroidKeyboard';
+
+// Mock Capacitor
+const mockAddListener = jest.fn();
+const mockIsPluginAvailable = jest.fn();
+const mockGetPlatform = jest.fn();
+
+jest.mock('@capacitor/core', () => ({
+  Capacitor: {
+    getPlatform: () => mockGetPlatform(),
+    isPluginAvailable: (name: string) => mockIsPluginAvailable(name),
+  },
+}));
+
+jest.mock('@capacitor/keyboard', () => ({
+  Keyboard: {
+    addListener: (event: string, callback: Function) => mockAddListener(event, callback),
+  },
+}));
+
+describe('useAndroidKeyboard', () => {
+  let showCallback: Function;
+  let hideCallback: Function;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    showCallback = jest.fn();
+    hideCallback = jest.fn();
+
+    // Default: Android platform with Keyboard plugin available
+    mockGetPlatform.mockReturnValue('android');
+    mockIsPluginAvailable.mockReturnValue(true);
+
+    // Capture callbacks when addListener is called
+    mockAddListener.mockImplementation((event: string, callback: Function) => {
+      if (event === 'keyboardWillShow') {
+        showCallback = callback;
+      } else if (event === 'keyboardWillHide') {
+        hideCallback = callback;
+      }
+      return { remove: jest.fn() };
+    });
+  });
+
+  it('initializes with keyboard hidden on Android', () => {
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    expect(result.current.isVisible).toBe(false);
+    expect(result.current.keyboardHeight).toBe(0);
+    expect(result.current.isAndroid).toBe(true);
+  });
+
+  it('does not set up listeners on non-Android platforms', () => {
+    mockGetPlatform.mockReturnValue('ios');
+
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    expect(result.current.isAndroid).toBe(false);
+    expect(mockAddListener).not.toHaveBeenCalled();
+  });
+
+  it('does not set up listeners when Keyboard plugin unavailable', () => {
+    mockIsPluginAvailable.mockReturnValue(false);
+
+    renderHook(() => useAndroidKeyboard());
+
+    expect(mockAddListener).not.toHaveBeenCalled();
+  });
+
+  it('updates state when keyboard shows', async () => {
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    act(() => {
+      showCallback({ keyboardHeight: 350 });
+    });
+
+    await waitFor(() => {
+      expect(result.current.isVisible).toBe(true);
+      expect(result.current.keyboardHeight).toBe(350);
+    });
+  });
+
+  it('updates state when keyboard hides', async () => {
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    // Show keyboard first
+    act(() => {
+      showCallback({ keyboardHeight: 350 });
+    });
+
+    await waitFor(() => {
+      expect(result.current.isVisible).toBe(true);
+    });
+
+    // Hide keyboard
+    act(() => {
+      hideCallback();
+    });
+
+    await waitFor(() => {
+      expect(result.current.isVisible).toBe(false);
+      expect(result.current.keyboardHeight).toBe(0);
+    });
+  });
+
+  it('uses fallback height when keyboardHeight is null', async () => {
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    act(() => {
+      showCallback({ keyboardHeight: null });
+    });
+
+    await waitFor(() => {
+      expect(result.current.keyboardHeight).toBe(300);
+    });
+  });
+
+  it('uses fallback height when keyboardHeight is undefined', async () => {
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    act(() => {
+      showCallback({});
+    });
+
+    await waitFor(() => {
+      expect(result.current.keyboardHeight).toBe(300);
+    });
+  });
+
+  it('uses actual height of 0 if provided (not fallback)', async () => {
+    const { result } = renderHook(() => useAndroidKeyboard());
+
+    act(() => {
+      showCallback({ keyboardHeight: 0 });
+    });
+
+    await waitFor(() => {
+      expect(result.current.keyboardHeight).toBe(0);
+    });
+  });
+
+  it('sets CSS variable when keyboard shows', () => {
+    const setPropertySpy = jest.spyOn(document.documentElement.style, 'setProperty');
+
+    renderHook(() => useAndroidKeyboard());
+
+    act(() => {
+      showCallback({ keyboardHeight: 400 });
+    });
+
+    expect(setPropertySpy).toHaveBeenCalledWith('--android-keyboard-height', '400px');
+  });
+
+  it('clears CSS variable when keyboard hides', () => {
+    const setPropertySpy = jest.spyOn(document.documentElement.style, 'setProperty');
+
+    renderHook(() => useAndroidKeyboard());
+
+    act(() => {
+      hideCallback();
+    });
+
+    expect(setPropertySpy).toHaveBeenCalledWith('--android-keyboard-height', '0px');
+    setPropertySpy.mockRestore();
+  });
+
+  it('does not update state if unmounted before listener setup completes', async () => {
+    let resolveListener: any;
+
+    // Make addListener async to simulate delay
+    mockAddListener.mockImplementation(() => {
+      return new Promise((resolve) => {
+        resolveListener = resolve;
+      });
+    });
+
+    const { unmount } = renderHook(() => useAndroidKeyboard());
+
+    // Unmount before listener setup completes
+    unmount();
+
+    // Now resolve the listener setup
+    const mockRemove = jest.fn();
+    act(() => {
+      resolveListener?.({ remove: mockRemove });
+    });
+
+    // Listener should be immediately removed since component unmounted
+    await waitFor(() => {
+      expect(mockRemove).toHaveBeenCalled();
+    });
+  });
+
+  it('does not update state when keyboard events fire after unmount', async () => {
+    const { unmount } = renderHook(() => useAndroidKeyboard());
+
+    unmount();
+
+    // Try to trigger callbacks after unmount
+    act(() => {
+      showCallback({ keyboardHeight: 500 });
+    });
+
+    // State should not have changed (we can't access result.current after unmount,
+    // but this test ensures no errors are thrown)
+    expect(() => {
+      showCallback({ keyboardHeight: 500 });
+      hideCallback();
+    }).not.toThrow();
+  });
+
+  describe('getContainerStyle', () => {
+    it('returns base style when keyboard is hidden', () => {
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      const style = result.current.getContainerStyle({ color: 'red' });
+
+      expect(style).toEqual({
+        color: 'red',
+        transition: 'transform 0.1s ease-out',
+      });
+    });
+
+    it('returns base style on non-Android platforms', () => {
+      mockGetPlatform.mockReturnValue('ios');
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      const style = result.current.getContainerStyle({ color: 'blue' });
+
+      expect(style).toEqual({
+        color: 'blue',
+        transition: 'transform 0.1s ease-out',
+      });
+    });
+
+    it('applies transform when keyboard is visible', async () => {
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      act(() => {
+        showCallback({ keyboardHeight: 400 });
+      });
+
+      await waitFor(() => {
+        const style = result.current.getContainerStyle({});
+
+        expect(style.transform).toBe('translateY(-360px)');
+        expect(style.transition).toBe('transform 0.1s ease-out');
+      });
+    });
+
+    it('subtracts adjustment from keyboard height in transform', async () => {
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      act(() => {
+        showCallback({ keyboardHeight: 400 });
+      });
+
+      await waitFor(() => {
+        const style = result.current.getContainerStyle({}, 100);
+
+        expect(style.transform).toBe('translateY(-300px)');
+      });
+    });
+
+    it('does not apply negative transform', async () => {
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      act(() => {
+        showCallback({ keyboardHeight: 50 });
+      });
+
+      await waitFor(() => {
+        const style = result.current.getContainerStyle({}, 100);
+
+        expect(style.transform).toBe('');
+      });
+    });
+
+    it('preserves existing transition if provided', async () => {
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      act(() => {
+        showCallback({ keyboardHeight: 400 });
+      });
+
+      await waitFor(() => {
+        const style = result.current.getContainerStyle({
+          transition: 'all 0.3s ease',
+        });
+
+        expect(style.transition).toBe('all 0.3s ease');
+      });
+    });
+
+    it('combines existing transform with keyboard transform', async () => {
+      const { result } = renderHook(() => useAndroidKeyboard());
+
+      act(() => {
+        showCallback({ keyboardHeight: 400 });
+      });
+
+      await waitFor(() => {
+        const style = result.current.getContainerStyle({
+          transform: 'scale(1.1)',
+        });
+
+        expect(style.transform).toBe('scale(1.1) translateY(-360px)');
+      });
+    });
+  });
+
+  describe('cleanup', () => {
+    it('removes listeners on unmount', () => {
+      const mockRemoveShow = jest.fn();
+      const mockRemoveHide = jest.fn();
+
+      mockAddListener.mockImplementation((event: string) => {
+        if (event === 'keyboardWillShow') {
+          return { remove: mockRemoveShow };
+        } else if (event === 'keyboardWillHide') {
+          return { remove: mockRemoveHide };
+        }
+        return { remove: jest.fn() };
+      });
+
+      const { unmount } = renderHook(() => useAndroidKeyboard());
+
+      unmount();
+
+      expect(mockRemoveShow).toHaveBeenCalled();
+      expect(mockRemoveHide).toHaveBeenCalled();
+    });
+
+    it('clears CSS variable on unmount', () => {
+      const setPropertySpy = jest.spyOn(document.documentElement.style, 'setProperty');
+
+      const { unmount } = renderHook(() => useAndroidKeyboard());
+
+      unmount();
+
+      expect(setPropertySpy).toHaveBeenCalledWith('--android-keyboard-height', '0px');
+    });
+  });
+});
diff --git a/components/brain/content/BrainContent.tsx b/components/brain/content/BrainContent.tsx
index 60e113d7ce..e1ef7ec608 100644
--- a/components/brain/content/BrainContent.tsx
+++ b/components/brain/content/BrainContent.tsx
@@ -6,7 +6,6 @@ import BrainContentPinnedWaves from "./BrainContentPinnedWaves";
 import BrainContentInput from "./input/BrainContentInput";
 import { ActiveDropState } from "@/types/dropInteractionTypes";
 import { useLayout } from "../my-stream/layout/LayoutContext";
-import { useAndroidKeyboard } from "@/hooks/useAndroidKeyboard";
 import useDeviceInfo from "@/hooks/useDeviceInfo";
 
 // Create breakpoint hook with the same values as tailwind classes
@@ -17,7 +16,6 @@ interface BrainContentProps {
   readonly children: React.ReactNode;
   readonly activeDrop: ActiveDropState | null;
   readonly onCancelReplyQuote: () => void;
-  readonly keyboardAdjustment?: number;
   readonly showPinnedWaves?: boolean;
 }
 
@@ -25,14 +23,10 @@ const BrainContent: React.FC<BrainContentProps> = ({
   children,
   activeDrop,
   onCancelReplyQuote,
-  keyboardAdjustment = 40,
   showPinnedWaves = true,
 }) => {
-  // Get layout context registration function for measuring
+  // Get layout context registration function
   const { registerRef } = useLayout();
-  
-  // Android keyboard handling - only apply when input is visible
-  const { getContainerStyle } = useAndroidKeyboard();
 
   // Get current breakpoint and device info
   const breakpoint = useBreakpoint();
@@ -64,11 +58,8 @@ const BrainContent: React.FC<BrainContentProps> = ({
   // Only show pinned waves in the app on small screens (not mobile web)
   const shouldShowPinnedWaves = showPinnedWaves && breakpoint === "S" && isApp;
 
-  // Only apply Android keyboard adjustments when input is visible
-  const containerStyle = activeDrop ? getContainerStyle({}, keyboardAdjustment) : {};
-
   return (
-    <div className="tw-relative tw-flex tw-flex-col tw-h-full" style={containerStyle}>
+    <div className="tw-relative tw-flex tw-flex-col tw-h-full">
       {showPinnedWaves && (
         <div
           ref={setPinnedRef}
diff --git a/components/brain/my-stream/MyStreamWaveChat.tsx b/components/brain/my-stream/MyStreamWaveChat.tsx
index ed801c1912..79e48f269c 100644
--- a/components/brain/my-stream/MyStreamWaveChat.tsx
+++ b/components/brain/my-stream/MyStreamWaveChat.tsx
@@ -9,7 +9,6 @@ import PrivilegedDropCreator, {
 import { ApiDrop } from "@/generated/models/ApiDrop";
 import { ApiWave } from "@/generated/models/ApiWave";
 import { getHomeFeedRoute } from "@/helpers/navigation.helpers";
-import { useAndroidKeyboard } from "@/hooks/useAndroidKeyboard";
 import useDeviceInfo from "@/hooks/useDeviceInfo";
 import { useWave } from "@/hooks/useWave";
 import { selectEditingDropId } from "@/store/editSlice";
@@ -36,7 +35,6 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({ wave }) => {
   const { isMemesWave } = useWave(wave);
   const editingDropId = useSelector(selectEditingDropId);
   const { isApp } = useDeviceInfo();
-  const { getContainerStyle } = useAndroidKeyboard();
   const [activeDrop, setActiveDrop] = useState<ActiveDropState | null>(null);
 
   // Handle URL parameters
@@ -69,10 +67,7 @@ const MyStreamWaveChat: React.FC<MyStreamWaveChatProps> = ({ wave }) => {
     return `${baseStyles} ${heightClass}`;
   }, []);
 
-  // Android keyboard adjustment style using centralized hook
-  const containerStyle = useMemo<React.CSSProperties>(() => {
-    return getContainerStyle(waveViewStyle || {}, 128);
-  }, [waveViewStyle, getContainerStyle]);
+  const containerStyle = waveViewStyle || {};
 
   useEffect(() => setActiveDrop(null), [wave]);
 
diff --git a/components/brain/my-stream/layout/LayoutContext.tsx b/components/brain/my-stream/layout/LayoutContext.tsx
index 23a2f56ded..aa5bf2cf1d 100644
--- a/components/brain/my-stream/layout/LayoutContext.tsx
+++ b/components/brain/my-stream/layout/LayoutContext.tsx
@@ -11,6 +11,7 @@ import React, {
   useMemo,
 } from "react";
 import useCapacitor from "@/hooks/useCapacitor";
+import { useAndroidKeyboard } from "@/hooks/useAndroidKeyboard";
 
 // Define the different spaces that need to be measured
 interface LayoutSpaces {
@@ -64,10 +65,12 @@ const spacesAreEqual = (a: LayoutSpaces, b: LayoutSpaces) =>
 const calculateHeightStyle = (
   view: View,
   spaces: LayoutSpaces,
-  capacitorSpace: number // Accept specific space value
+  capacitorSpace: number, // Accept specific space value
+  keyboardHeight: number = 0 // Keyboard height when visible
 ): React.CSSProperties => {
   // Use dynamic viewport height to avoid extra space on mobile browsers
-  const heightCalc = `calc(100dvh - ${spaces.headerSpace}px - ${spaces.pinnedSpace}px - ${spaces.tabsSpace}px - ${spaces.spacerSpace}px - ${spaces.mobileTabsSpace}px - ${spaces.mobileNavSpace}px - ${capacitorSpace}px)`;
+  // Subtract keyboard height when keyboard is open to shrink container to visible area
+  const heightCalc = `calc(100dvh - ${spaces.headerSpace}px - ${spaces.pinnedSpace}px - ${spaces.tabsSpace}px - ${spaces.spacerSpace}px - ${spaces.mobileTabsSpace}px - ${spaces.mobileNavSpace}px - ${capacitorSpace}px - ${keyboardHeight}px)`;
   return {
     height: heightCalc,
     maxHeight: heightCalc,
@@ -167,6 +170,7 @@ export const LayoutProvider: React.FC<{ children: ReactNode }> = ({
   children,
 }) => {
   const { isCapacitor, isAndroid, isIos } = useCapacitor();
+  const { isVisible: isAndroidKeyboardVisible, keyboardHeight } = useAndroidKeyboard();
 
   // Internal ref storage (source of truth)
   const refMap = useRef<Record<LayoutRefType, HTMLDivElement | null>>({
@@ -377,16 +381,22 @@ export const LayoutProvider: React.FC<{ children: ReactNode }> = ({
   const waveViewStyle = useMemo<React.CSSProperties>(() => {
     if (!spaces.measurementsComplete) return {};
 
+    // Reserve space for input area + bottom nav (only when keyboard closed)
     let capSpace = 0;
+    let kbHeight = 0;
+
     if (isAndroid) {
-      capSpace = 128;
+      // When keyboard open: no capSpace needed, subtract keyboard height instead
+      // When keyboard closed: use 128px capSpace for input + bottom nav
+      capSpace = isAndroidKeyboardVisible ? 0 : 128;
+      kbHeight = isAndroidKeyboardVisible ? keyboardHeight : 0;
     } else if (isIos || isCapacitor) {
       capSpace = 20;
     }
 
     const adjustedSpaces = { ...spaces, mobileNavSpace: 0 };
-    return calculateHeightStyle("wave", adjustedSpaces, capSpace);
-  }, [spaces, isAndroid, isIos, isCapacitor]);
+    return calculateHeightStyle("wave", adjustedSpaces, capSpace, kbHeight);
+  }, [spaces, isAndroid, isAndroidKeyboardVisible, keyboardHeight, isIos, isCapacitor]);
 
   const leaderboardViewStyle = useMemo<React.CSSProperties>(() => {
     if (!spaces.measurementsComplete) return {};
diff --git a/hooks/useAndroidKeyboard.ts b/hooks/useAndroidKeyboard.ts
index f7eb3c7f3f..86cdf7e892 100644
--- a/hooks/useAndroidKeyboard.ts
+++ b/hooks/useAndroidKeyboard.ts
@@ -1,200 +1,95 @@
 "use client"
 
-import { useEffect, useState, useCallback, useRef } from 'react';
+import { useEffect, useState, useCallback, type CSSProperties } from 'react';
 import { Capacitor } from '@capacitor/core';
 import { Keyboard } from '@capacitor/keyboard';
 
-// Debounce utility (simple implementation to avoid lodash dependency)
-function debounce<T extends (...args: any[]) => any>(
-  func: T,
-  wait: number
-): (...args: Parameters<T>) => void {
-  let timeout: NodeJS.Timeout;
-  return (...args: Parameters<T>) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => func(...args), wait);
-  };
-}
-
 interface AndroidKeyboardHookReturn {
   keyboardHeight: number;
   isVisible: boolean;
   isAndroid: boolean;
-  getContainerStyle: (baseStyle?: React.CSSProperties, adjustment?: number) => React.CSSProperties;
+  getContainerStyle: (baseStyle?: CSSProperties, adjustment?: number) => CSSProperties;
 }
 
-export function useAndroidKeyboard(debounceMs: number = 50): AndroidKeyboardHookReturn {
-  // All hooks must be called before any conditional logic
+export function useAndroidKeyboard(): AndroidKeyboardHookReturn {
   const [keyboardHeight, setKeyboardHeight] = useState(0);
   const [isVisible, setIsVisible] = useState(false);
-  const initialHeightRef = useRef(typeof window !== 'undefined' ? window.innerHeight : 0);
 
-  // SSR safety check after hooks are declared
   const isSSR = typeof window === 'undefined';
   const isAndroid = !isSSR && Capacitor.getPlatform() === 'android';
 
-  // Recalculate initial height (for orientation changes)
-  const resetInitialHeight = useCallback(() => {
-    if (isSSR) return;
-    initialHeightRef.current = window.innerHeight;
-  }, [isSSR]);
-
-  const detectKeyboard = useCallback(() => {
-    if (isSSR) return;
-    
-    const currentHeight = window.innerHeight;
-    const initialHeight = initialHeightRef.current;
-    let height = 0;
-    
-    // Method 1: VisualViewport API (most reliable)
-    if (window.visualViewport) {
-      height = initialHeight - window.visualViewport.height;
-    } 
-    // Method 2: Window resize fallback
-    else {
-      height = initialHeight - currentHeight;
-    }
-
-    // Only consider it a keyboard if height difference is significant
-    if (height > 50) {
-      setKeyboardHeight(height);
-      setIsVisible(true);
-      document.documentElement.style.setProperty('--android-keyboard-height', `${height}px`);
-    } else {
-      setKeyboardHeight(0);
-      setIsVisible(false);
-      document.documentElement.style.setProperty('--android-keyboard-height', '0px');
-    }
-  }, [isSSR]);
-
-  // Debounced version to prevent flooding React with state updates
-  const debouncedDetectKeyboard = useRef(debounce(detectKeyboard, debounceMs)).current;
-
-  const handleOrientationChange = useCallback(() => {
-    if (isSSR) return;
-    resetInitialHeight();
-    // Use immediate detection for orientation changes (not debounced)
-    detectKeyboard();
-  }, [isSSR, resetInitialHeight, detectKeyboard]);
-
-  // Simplified focus handlers - remove double state setting
-  const handleFocusIn = useCallback((e: FocusEvent) => {
-    if (isSSR) return;
-    
-    const target = e.target as HTMLElement;
-    if (target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.contentEditable === 'true')) {
-      // Only use fallback if plugin isn't available
-      if (!Capacitor.isPluginAvailable('Keyboard')) {
-        const fallbackHeight = Math.floor(window.innerHeight * 0.35);
-        setKeyboardHeight(fallbackHeight);
-        setIsVisible(true);
-        document.documentElement.style.setProperty('--android-keyboard-height', `${fallbackHeight}px`);
-      }
-    }
-  }, [isSSR]);
-
-  const handleFocusOut = useCallback(() => {
-    if (isSSR) return;
-    
-    // Immediately clear keyboard state when focus leaves input
-    setKeyboardHeight(0);
-    setIsVisible(false);
-    document.documentElement.style.setProperty('--android-keyboard-height', '0px');
-  }, [isSSR]);
-
-  const handleResize = useCallback(() => {
-    if (isSSR) return;
-    debouncedDetectKeyboard();
-  }, [isSSR, debouncedDetectKeyboard]);
-
-  const handleVisualViewportResize = useCallback(() => {
-    if (isSSR) return;
-    debouncedDetectKeyboard();
-  }, [isSSR, debouncedDetectKeyboard]);
-
   useEffect(() => {
     if (isSSR || !isAndroid) return;
 
-    let keyboardShowCleanup: (() => void) | undefined;
-    let keyboardHideCleanup: (() => void) | undefined;
-
-    // Setup Capacitor keyboard listeners (if available)
-    const setupCapacitorKeyboard = async () => {
-      if (Capacitor.isPluginAvailable('Keyboard')) {
-        try {
-          const keyboardWillShowListener = await Keyboard.addListener('keyboardWillShow', (info) => {
-            const height = info.keyboardHeight || 300;
-            setKeyboardHeight(height);
-            setIsVisible(true);
-            document.documentElement.style.setProperty('--android-keyboard-height', `${height}px`);
-          });
-
-          const keyboardWillHideListener = await Keyboard.addListener('keyboardWillHide', () => {
-            setKeyboardHeight(0);
-            setIsVisible(false);
-            document.documentElement.style.setProperty('--android-keyboard-height', '0px');
-          });
-
-          keyboardShowCleanup = () => keyboardWillShowListener.remove();
-          keyboardHideCleanup = () => keyboardWillHideListener.remove();
-        } catch (error) {
-          console.error('[Android Keyboard] Error setting up Capacitor Keyboard:', error);
+    let mounted = true;
+    let showCleanup: (() => void) | undefined;
+    let hideCleanup: (() => void) | undefined;
+
+    const setupKeyboardListeners = async () => {
+      if (!Capacitor.isPluginAvailable('Keyboard')) return;
+
+      try {
+        const showListener = await Keyboard.addListener('keyboardWillShow', (info) => {
+          if (!mounted) return;
+          const height = info.keyboardHeight ?? 300;
+          setKeyboardHeight(height);
+          setIsVisible(true);
+          document.documentElement.style.setProperty('--android-keyboard-height', `${height}px`);
+        });
+
+        const hideListener = await Keyboard.addListener('keyboardWillHide', () => {
+          if (!mounted) return;
+          setKeyboardHeight(0);
+          setIsVisible(false);
+          document.documentElement.style.setProperty('--android-keyboard-height', '0px');
+        });
+
+
+        if (!mounted) {
+          showListener.remove();
+          hideListener.remove();
+          return;
         }
+
+        showCleanup = () => showListener.remove();
+        hideCleanup = () => hideListener.remove();
+      } catch (error) {
+        console.error('[Android Keyboard] Error setting up listeners:', error);
       }
     };
 
-    // Add event listeners with proper cleanup references
-    if (window.visualViewport) {
-      window.visualViewport.addEventListener('resize', handleVisualViewportResize);
-    }
-    
-    window.addEventListener('resize', handleResize);
-    window.addEventListener('orientationchange', handleOrientationChange);
-    document.addEventListener('focusin', handleFocusIn);
-    document.addEventListener('focusout', handleFocusOut);
-
-    // Setup Capacitor keyboard listeners
-    setupCapacitorKeyboard();
-
-    // Initial measurement
-    resetInitialHeight();
-    detectKeyboard();
+    setupKeyboardListeners();
 
     return () => {
-      // Cleanup Capacitor listeners
-      keyboardShowCleanup?.();
-      keyboardHideCleanup?.();
-      
-      // Cleanup DOM listeners (using same function references)
-      if (window.visualViewport) {
-        window.visualViewport.removeEventListener('resize', handleVisualViewportResize);
-      }
-      window.removeEventListener('resize', handleResize);
-      window.removeEventListener('orientationchange', handleOrientationChange);
-      document.removeEventListener('focusin', handleFocusIn);
-      document.removeEventListener('focusout', handleFocusOut);
+      mounted = false;
+      showCleanup?.();
+      hideCleanup?.();
+      document.documentElement.style.setProperty('--android-keyboard-height', '0px');
     };
-  }, [isSSR, isAndroid, handleVisualViewportResize, handleResize, handleOrientationChange, handleFocusIn, handleFocusOut, resetInitialHeight, detectKeyboard]);
+  }, [isSSR, isAndroid]);
 
-  // Centralized container style for keyboard adjustments
   const getContainerStyle = useCallback((
-    baseStyle: React.CSSProperties = {},
+    baseStyle: CSSProperties = {},
     adjustment: number = 40
-  ): React.CSSProperties => {
+  ): CSSProperties => {
     if (isSSR || !isAndroid || !isVisible || keyboardHeight <= 0) {
       return {
         ...baseStyle,
-        transition: 'transform 0.1s ease-out',
+        transition: baseStyle.transition ?? 'transform 0.1s ease-out',
       };
     }
-    
+
     const adjustedTransform = Math.max(0, keyboardHeight - adjustment);
+    const baseTransform = baseStyle.transform ?? '';
+    const translateY = adjustedTransform > 0 ? `translateY(-${adjustedTransform}px)` : '';
+    const combinedTransform = `${baseTransform} ${translateY}`.trim();
+
     return {
       ...baseStyle,
-      transform: `translateY(-${adjustedTransform}px)`,
-      transition: 'transform 0.1s ease-out',
+      transform: combinedTransform || undefined,
+      transition: baseStyle.transition ?? 'transform 0.1s ease-out',
     };
   }, [isSSR, isAndroid, isVisible, keyboardHeight]);
 
   return { keyboardHeight, isVisible, isAndroid, getContainerStyle };
-} 
\ No newline at end of file
+}