diff --git a/native/chat/chat-tab-bar.react.js b/native/chat/chat-tab-bar.react.js
index 6e183ea48..c39a9cf15 100644
--- a/native/chat/chat-tab-bar.react.js
+++ b/native/chat/chat-tab-bar.react.js
@@ -1,73 +1,70 @@
 // @flow
 
 import type {
   MaterialTopTabBarProps,
   Route,
   TabBarItemProps,
 } from '@react-navigation/core';
 import { MaterialTopTabBar } from '@react-navigation/material-top-tabs';
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
+import type { MeasureOnSuccessCallback } from 'react-native/Libraries/Renderer/shims/ReactNativeTypes';
 import { TabBarItem } from 'react-native-tab-view';
 
+import type { ReactRefSetter } from 'lib/types/react-types.js';
+
 import {
   nuxTip,
   NUXTipsContext,
 } from '../components/nux-tips-context.react.js';
 import {
   HomeChatThreadListRouteName,
   BackgroundChatThreadListRouteName,
 } from '../navigation/route-names.js';
 
 const ButtonTitleToTip = Object.freeze({
   [BackgroundChatThreadListRouteName]: nuxTip.MUTED,
   [HomeChatThreadListRouteName]: nuxTip.HOME,
 });
 
+const onLayout = () => {};
+
 function TabBarButton(props: TabBarItemProps<Route<>>) {
   const tipsContext = React.useContext(NUXTipsContext);
   invariant(tipsContext, 'NUXTipsContext should be defined');
+  const { registerTipButton } = tipsContext;
 
-  const viewRef = React.useRef<?React.ElementRef<typeof View>>();
-  const onLayout = React.useCallback(() => {
-    const button = viewRef.current;
-    if (!button) {
-      return;
-    }
-
-    const tipType = ButtonTitleToTip[props.route.name];
-    if (!tipType) {
-      return;
-    }
-    button.measure((x, y, width, height, pageX, pageY) => {
-      tipsContext.registerTipButton(tipType, {
-        x,
-        y,
-        width,
-        height,
-        pageX,
-        pageY,
-      });
-    });
-  }, [props.route.name, tipsContext]);
+  const registerRef: ReactRefSetter<React.ElementRef<typeof View>> =
+    React.useCallback(
+      element => {
+        const tipType = ButtonTitleToTip[props.route.name];
+        if (!tipType) {
+          return;
+        }
+        const measure = (callback: MeasureOnSuccessCallback) =>
+          element?.measure(callback);
+        registerTipButton(tipType, measure);
+      },
+      [props.route.name, registerTipButton],
+    );
 
   return (
-    <View ref={viewRef} onLayout={onLayout}>
+    <View ref={registerRef} onLayout={onLayout}>
       <TabBarItem {...props} />
     </View>
   );
 }
 
 export default function TabBarTop(
   props: MaterialTopTabBarProps<Route<>>,
 ): React.Node {
   const renderTabBarItem = React.useCallback(
     (
       innerProps: $ReadOnly<{ ...TabBarItemProps<Route<>>, +key: string, ... }>,
     ) => <TabBarButton {...innerProps} />,
     [],
   );
 
   return <MaterialTopTabBar {...props} renderTabBarItem={renderTabBarItem} />;
 }
diff --git a/native/chat/chat.react.js b/native/chat/chat.react.js
index beb24ac48..25a58d77f 100644
--- a/native/chat/chat.react.js
+++ b/native/chat/chat.react.js
@@ -1,529 +1,527 @@
 // @flow
 
 import type {
   MaterialTopTabNavigationProp,
   StackNavigationState,
   StackOptions,
   StackNavigationEventMap,
   StackNavigatorProps,
   ExtraStackNavigatorProps,
   StackHeaderProps,
   StackNavigationProp,
   StackNavigationHelpers,
   ParamListBase,
   StackRouterOptions,
   MaterialTopTabNavigationHelpers,
   HeaderTitleInputProps,
   StackHeaderLeftButtonProps,
 } from '@react-navigation/core';
 import { createMaterialTopTabNavigator } from '@react-navigation/material-top-tabs';
 import {
   createNavigatorFactory,
   useNavigationBuilder,
 } from '@react-navigation/native';
 import { StackView } from '@react-navigation/stack';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform, View, useWindowDimensions } from 'react-native';
+import type { MeasureOnSuccessCallback } from 'react-native/Libraries/Renderer/shims/ReactNativeTypes';
 
 import MessageStorePruner from 'lib/components/message-store-pruner.react.js';
 import ThreadDraftUpdater from 'lib/components/thread-draft-updater.react.js';
 import { isLoggedIn } from 'lib/selectors/user-selectors.js';
 import { threadSettingsNotificationsCopy } from 'lib/shared/thread-settings-notifications-utils.js';
 import { threadIsPending, threadIsSidebar } from 'lib/shared/thread-utils.js';
+import type { ReactRefSetter } from 'lib/types/react-types.js';
 
 import BackgroundChatThreadList from './background-chat-thread-list.react.js';
 import ChatHeader from './chat-header.react.js';
 import {
   backgroundChatThreadListOptions,
   homeChatThreadListOptions,
 } from './chat-options.js';
 import ChatRouter, {
   type ChatRouterNavigationHelpers,
   type ChatRouterNavigationAction,
 } from './chat-router.js';
 import TabBar from './chat-tab-bar.react.js';
 import ComposeSubchannel from './compose-subchannel.react.js';
 import ComposeThreadButton from './compose-thread-button.react.js';
 import FullScreenThreadMediaGallery from './fullscreen-thread-media-gallery.react.js';
 import HomeChatThreadList from './home-chat-thread-list.react.js';
 import { MessageEditingContext } from './message-editing-context.react.js';
 import MessageListContainer from './message-list-container.react.js';
 import MessageListHeaderTitle from './message-list-header-title.react.js';
 import PinnedMessagesScreen from './pinned-messages-screen.react.js';
 import DeleteThread from './settings/delete-thread.react.js';
 import EmojiThreadAvatarCreation from './settings/emoji-thread-avatar-creation.react.js';
 import ThreadSettingsNotifications from './settings/thread-settings-notifications.react.js';
 import ThreadSettings from './settings/thread-settings.react.js';
 import ThreadScreenPruner from './thread-screen-pruner.react.js';
 import ThreadSettingsButton from './thread-settings-button.react.js';
 import ThreadSettingsHeaderTitle from './thread-settings-header-title.react.js';
 import KeyboardAvoidingView from '../components/keyboard-avoiding-view.react.js';
 import { NUXHandler } from '../components/nux-handler.react.js';
 import {
   nuxTip,
   NUXTipsContext,
 } from '../components/nux-tips-context.react.js';
 import { InputStateContext } from '../input/input-state.js';
 import CommunityDrawerButton from '../navigation/community-drawer-button.react.js';
 import HeaderBackButton from '../navigation/header-back-button.react.js';
 import { activeThreadSelector } from '../navigation/nav-selectors.js';
 import { NavContext } from '../navigation/navigation-context.js';
 import {
   defaultStackScreenOptions,
   transitionPreset,
 } from '../navigation/options.js';
 import {
   ComposeSubchannelRouteName,
   DeleteThreadRouteName,
   ThreadSettingsRouteName,
   EmojiThreadAvatarCreationRouteName,
   FullScreenThreadMediaGalleryRouteName,
   PinnedMessagesScreenRouteName,
   MessageListRouteName,
   ChatThreadListRouteName,
   HomeChatThreadListRouteName,
   BackgroundChatThreadListRouteName,
   ThreadSettingsNotificationsRouteName,
   type ScreenParamList,
   type ChatParamList,
   type ChatTopTabsParamList,
   MessageSearchRouteName,
   ChangeRolesScreenRouteName,
   type NavigationRoute,
 } from '../navigation/route-names.js';
 import type { TabNavigationProp } from '../navigation/tab-navigator.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import ChangeRolesHeaderLeftButton from '../roles/change-roles-header-left-button.react.js';
 import ChangeRolesScreen from '../roles/change-roles-screen.react.js';
 import MessageSearch from '../search/message-search.react.js';
 import SearchHeader from '../search/search-header.react.js';
 import SearchMessagesButton from '../search/search-messages-button.react.js';
 import { useColors, useStyles } from '../themes/colors.js';
 
 const unboundStyles = {
   keyboardAvoidingView: {
     flex: 1,
   },
   view: {
     flex: 1,
     backgroundColor: 'listBackground',
   },
   threadListHeaderStyle: {
     elevation: 0,
     shadowOffset: { width: 0, height: 0 },
     borderBottomWidth: 0,
     backgroundColor: 'tabBarBackground',
   },
 };
 
 export type ChatTopTabsNavigationProp<
   RouteName: $Keys<ChatTopTabsParamList> = $Keys<ChatTopTabsParamList>,
 > = MaterialTopTabNavigationProp<ScreenParamList, RouteName>;
 
 export type ChatTopTabsNavigationHelpers =
   MaterialTopTabNavigationHelpers<ScreenParamList>;
 
 const ChatThreadsTopTab = createMaterialTopTabNavigator<
   ScreenParamList,
   ChatTopTabsParamList,
   ChatTopTabsNavigationHelpers,
 >();
 function ChatThreadsComponent(): React.Node {
   const colors = useColors();
   const { tabBarBackground, tabBarAccent } = colors;
   const screenOptions = React.useMemo(
     () => ({
       tabBarShowIcon: true,
       tabBarStyle: {
         backgroundColor: tabBarBackground,
       },
       tabBarItemStyle: {
         flexDirection: 'row',
       },
       tabBarIndicatorStyle: {
         borderColor: tabBarAccent,
         borderBottomWidth: 2,
       },
     }),
     [tabBarAccent, tabBarBackground],
   );
 
   return (
     <ChatThreadsTopTab.Navigator screenOptions={screenOptions} tabBar={TabBar}>
       <ChatThreadsTopTab.Screen
         name={HomeChatThreadListRouteName}
         component={HomeChatThreadList}
         options={homeChatThreadListOptions}
       />
       <ChatThreadsTopTab.Screen
         name={BackgroundChatThreadListRouteName}
         component={BackgroundChatThreadList}
         options={backgroundChatThreadListOptions}
       />
     </ChatThreadsTopTab.Navigator>
   );
 }
 
 export type ChatNavigationHelpers<ParamList: ParamListBase = ParamListBase> = {
   ...$Exact<StackNavigationHelpers<ParamList>>,
   ...ChatRouterNavigationHelpers,
 };
 
 type ChatNavigatorProps = StackNavigatorProps<ChatNavigationHelpers<>>;
 function ChatNavigator({
   initialRouteName,
   children,
   screenOptions,
   defaultScreenOptions,
   screenListeners,
   id,
   ...rest
 }: ChatNavigatorProps) {
   const { state, descriptors, navigation } = useNavigationBuilder<
     StackNavigationState,
     ChatRouterNavigationAction,
     StackOptions,
     StackRouterOptions,
     ChatNavigationHelpers<>,
     StackNavigationEventMap,
     ExtraStackNavigatorProps,
   >(ChatRouter, {
     id,
     initialRouteName,
     children,
     screenOptions,
     defaultScreenOptions,
     screenListeners,
   });
 
   // Clear ComposeSubchannel screens after each message is sent. If a user goes
   // to ComposeSubchannel to create a new thread, but finds an existing one and
   // uses it instead, we can assume the intent behind opening ComposeSubchannel
   // is resolved
   const inputState = React.useContext(InputStateContext);
   invariant(inputState, 'InputState should be set in ChatNavigator');
   const clearComposeScreensAfterMessageSend = React.useCallback(() => {
     navigation.clearScreens([ComposeSubchannelRouteName]);
   }, [navigation]);
   React.useEffect(() => {
     inputState.registerSendCallback(clearComposeScreensAfterMessageSend);
     return () => {
       inputState.unregisterSendCallback(clearComposeScreensAfterMessageSend);
     };
   }, [inputState, clearComposeScreensAfterMessageSend]);
 
   return (
     <StackView
       {...rest}
       state={state}
       descriptors={descriptors}
       navigation={navigation}
       detachInactiveScreens={Platform.OS !== 'ios'}
     />
   );
 }
 const createChatNavigator = createNavigatorFactory<
   StackNavigationState,
   StackOptions,
   StackNavigationEventMap,
   ChatNavigationHelpers<>,
   ExtraStackNavigatorProps,
 >(ChatNavigator);
 
 const header = (props: StackHeaderProps) => {
   // Flow has trouble reconciling identical types between different libdefs,
   // and flow-typed has no way for one libdef to depend on another
   const castProps: StackHeaderProps = (props: any);
   return <ChatHeader {...castProps} />;
 };
 
 const headerRightStyle = { flexDirection: 'row' };
 
 const messageListOptions = ({
   navigation,
   route,
 }: {
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
 }) => {
   const isSearchEmpty =
     !!route.params.searching && route.params.threadInfo.members.length === 1;
 
   const areSettingsEnabled =
     !threadIsPending(route.params.threadInfo.id) && !isSearchEmpty;
 
   return {
     headerTitle: (props: HeaderTitleInputProps) => (
       <MessageListHeaderTitle
         threadInfo={route.params.threadInfo}
         navigate={navigation.navigate}
         areSettingsEnabled={areSettingsEnabled}
         isSearchEmpty={isSearchEmpty}
         {...props}
       />
     ),
     headerRight: areSettingsEnabled
       ? () => (
           <View style={headerRightStyle}>
             <SearchMessagesButton
               threadInfo={route.params.threadInfo}
               navigate={navigation.navigate}
             />
             <ThreadSettingsButton
               threadInfo={route.params.threadInfo}
               navigate={navigation.navigate}
             />
           </View>
         )
       : undefined,
     headerBackTitleVisible: false,
     headerTitleAlign: isSearchEmpty ? 'center' : 'left',
     headerLeftContainerStyle: { width: Platform.OS === 'ios' ? 32 : 40 },
     headerTitleStyle: areSettingsEnabled ? { marginRight: 20 } : undefined,
   };
 };
 const composeThreadOptions = {
   headerTitle: 'Compose chat',
   headerBackTitleVisible: false,
 };
 const threadSettingsOptions = ({
   route,
 }: {
   +route: NavigationRoute<'ThreadSettings'>,
   ...
 }) => ({
   headerTitle: (props: HeaderTitleInputProps) => (
     <ThreadSettingsHeaderTitle
       threadInfo={route.params.threadInfo}
       {...props}
     />
   ),
   headerBackTitleVisible: false,
 });
 const emojiAvatarCreationOptions = {
   headerTitle: 'Emoji avatar selection',
   headerBackTitleVisible: false,
 };
 const fullScreenThreadMediaGalleryOptions = {
   headerTitle: 'All Media',
   headerBackTitleVisible: false,
 };
 const deleteThreadOptions = {
   headerTitle: 'Delete chat',
   headerBackTitleVisible: false,
 };
 const messageSearchOptions = {
   headerTitle: () => <SearchHeader />,
   headerBackTitleVisible: false,
   headerTitleContainerStyle: {
     width: '100%',
   },
 };
 const pinnedMessagesScreenOptions = {
   headerTitle: 'Pinned Messages',
   headerBackTitleVisible: false,
 };
 const threadSettingsNotificationsOptions = ({
   route,
 }: {
   +route: NavigationRoute<'ThreadSettingsNotifications'>,
   ...
 }) => ({
   headerTitle: threadIsSidebar(route.params.threadInfo)
     ? threadSettingsNotificationsCopy.SIDEBAR_TITLE
     : threadSettingsNotificationsCopy.CHANNEL_TITLE,
   headerBackTitleVisible: false,
 });
 const changeRolesScreenOptions = ({
   route,
 }: {
   +route: NavigationRoute<'ChangeRolesScreen'>,
   ...
 }) => ({
   headerLeft: (headerLeftProps: StackHeaderLeftButtonProps) => (
     <ChangeRolesHeaderLeftButton {...headerLeftProps} route={route} />
   ),
   headerTitle: 'Change Role',
   presentation: 'modal',
   ...transitionPreset,
 });
 
 export type ChatNavigationProp<
   RouteName: $Keys<ChatParamList> = $Keys<ChatParamList>,
 > = {
   ...StackNavigationProp<ScreenParamList, RouteName>,
   ...ChatRouterNavigationHelpers,
 };
 
 const Chat = createChatNavigator<
   ScreenParamList,
   ChatParamList,
   ChatNavigationHelpers<ScreenParamList>,
 >();
 
+const communityDrawerButtonOnLayout = () => {};
+
 type Props = {
   +navigation: TabNavigationProp<'Chat'>,
   ...
 };
 export default function ChatComponent(props: Props): React.Node {
   const styles = useStyles(unboundStyles);
   const colors = useColors();
   const loggedIn = useSelector(isLoggedIn);
   let draftUpdater = null;
   if (loggedIn) {
     draftUpdater = <ThreadDraftUpdater />;
   }
 
-  const communityDrawerButtonRef =
-    React.useRef<?React.ElementRef<typeof View>>();
-
   const tipsContext = React.useContext(NUXTipsContext);
   invariant(tipsContext, 'NUXTipsContext should be defined');
   const { registerTipButton } = tipsContext;
 
-  const communityDrawerButtonOnLayout = React.useCallback(() => {
-    communityDrawerButtonRef.current?.measure(
-      (x, y, width, height, pageX, pageY) => {
-        registerTipButton(nuxTip.COMMUNITY_DRAWER, {
-          x,
-          y,
-          width,
-          height,
-          pageX,
-          pageY,
-        });
-      },
-    );
-  }, [registerTipButton]);
+  const communityDrawerButtonRegisterRef: ReactRefSetter<
+    React.ElementRef<typeof View>,
+  > = React.useCallback(
+    element => {
+      const measure = (callback: MeasureOnSuccessCallback) =>
+        element?.measure(callback);
+
+      registerTipButton(nuxTip.COMMUNITY_DRAWER, measure);
+    },
+    [registerTipButton],
+  );
 
   const headerLeftButton = React.useCallback(
     (headerProps: StackHeaderLeftButtonProps) => {
       if (headerProps.canGoBack) {
         return <HeaderBackButton {...headerProps} />;
       }
       return (
         <View
           onLayout={communityDrawerButtonOnLayout}
-          ref={communityDrawerButtonRef}
+          ref={communityDrawerButtonRegisterRef}
         >
           <CommunityDrawerButton navigation={props.navigation} />
         </View>
       );
     },
-    [communityDrawerButtonOnLayout, props.navigation],
+    [communityDrawerButtonRegisterRef, props.navigation],
   );
 
   const messageEditingContext = React.useContext(MessageEditingContext);
   const editState = messageEditingContext?.editState;
   const editMode = !!editState?.editedMessage;
 
   const { width: screenWidth } = useWindowDimensions();
   const screenOptions = React.useMemo(
     () => ({
       ...defaultStackScreenOptions,
       header,
       headerLeft: headerLeftButton,
       headerStyle: {
         backgroundColor: colors.tabBarBackground,
         borderBottomWidth: 1,
       },
       gestureEnabled: true,
       gestureResponseDistance: editMode ? 0 : screenWidth,
     }),
     [colors.tabBarBackground, headerLeftButton, screenWidth, editMode],
   );
 
   const chatThreadListOptions = React.useCallback(
     ({
       navigation,
     }: {
       +navigation: ChatNavigationProp<'ChatThreadList'>,
       ...
     }) => ({
       headerTitle: 'Inbox',
       headerRight:
         Platform.OS === 'ios'
           ? () => <ComposeThreadButton navigate={navigation.navigate} />
           : undefined,
       headerBackTitleVisible: false,
       headerStyle: styles.threadListHeaderStyle,
     }),
     [styles.threadListHeaderStyle],
   );
 
   const frozen = useSelector(state => state.frozen);
   const navContext = React.useContext(NavContext);
   const activeThreadID = activeThreadSelector(navContext);
 
   return (
     <View style={styles.view}>
       <KeyboardAvoidingView
         behavior="padding"
         style={styles.keyboardAvoidingView}
       >
         <Chat.Navigator screenOptions={screenOptions}>
           <Chat.Screen
             name={ChatThreadListRouteName}
             component={ChatThreadsComponent}
             options={chatThreadListOptions}
           />
           <Chat.Screen
             name={MessageListRouteName}
             component={MessageListContainer}
             options={messageListOptions}
           />
           <Chat.Screen
             name={ComposeSubchannelRouteName}
             component={ComposeSubchannel}
             options={composeThreadOptions}
           />
           <Chat.Screen
             name={ThreadSettingsRouteName}
             component={ThreadSettings}
             options={threadSettingsOptions}
           />
           <Chat.Screen
             name={EmojiThreadAvatarCreationRouteName}
             component={EmojiThreadAvatarCreation}
             options={emojiAvatarCreationOptions}
           />
           <Chat.Screen
             name={FullScreenThreadMediaGalleryRouteName}
             component={FullScreenThreadMediaGallery}
             options={fullScreenThreadMediaGalleryOptions}
           />
           <Chat.Screen
             name={DeleteThreadRouteName}
             component={DeleteThread}
             options={deleteThreadOptions}
           />
           <Chat.Screen
             name={PinnedMessagesScreenRouteName}
             component={PinnedMessagesScreen}
             options={pinnedMessagesScreenOptions}
           />
           <Chat.Screen
             name={MessageSearchRouteName}
             component={MessageSearch}
             options={messageSearchOptions}
           />
           <Chat.Screen
             name={ChangeRolesScreenRouteName}
             component={ChangeRolesScreen}
             options={changeRolesScreenOptions}
           />
           <Chat.Screen
             name={ThreadSettingsNotificationsRouteName}
             component={ThreadSettingsNotifications}
             options={threadSettingsNotificationsOptions}
           />
         </Chat.Navigator>
         <MessageStorePruner frozen={frozen} activeThreadID={activeThreadID} />
         <ThreadScreenPruner />
         <NUXHandler />
         {draftUpdater}
       </KeyboardAvoidingView>
     </View>
   );
 }
diff --git a/native/components/nux-tips-context.react.js b/native/components/nux-tips-context.react.js
index 92f998654..3f84388e0 100644
--- a/native/components/nux-tips-context.react.js
+++ b/native/components/nux-tips-context.react.js
@@ -1,137 +1,131 @@
 // @flow
 
 import * as React from 'react';
+import type { MeasureOnSuccessCallback } from 'react-native/Libraries/Renderer/shims/ReactNativeTypes';
 
 import { values } from 'lib/utils/objects.js';
 
 import type { AppNavigationProp } from '../navigation/app-navigator.react.js';
 import type { NUXTipRouteNames } from '../navigation/route-names.js';
 import {
   CommunityDrawerTipRouteName,
   MutedTabTipRouteName,
   HomeTabTipRouteName,
   IntroTipRouteName,
 } from '../navigation/route-names.js';
 
 const nuxTip = Object.freeze({
   INTRO: 'intro',
   COMMUNITY_DRAWER: 'community_drawer',
   HOME: 'home',
   MUTED: 'muted',
 });
 
 export type NUXTip = $Values<typeof nuxTip>;
 
 type NUXTipParams = {
   +nextTip: ?NUXTip,
   +tooltipLocation: 'below' | 'above' | 'absolute',
   +routeName: NUXTipRouteNames,
   +exitingCallback?: <Route: NUXTipRouteNames>(
     navigation: AppNavigationProp<Route>,
   ) => void,
 };
 
 const firstNUXTipKey = nuxTip.INTRO;
 
 const nuxTipParams: { +[NUXTip]: NUXTipParams } = {
   [nuxTip.INTRO]: {
     nextTip: nuxTip.COMMUNITY_DRAWER,
     tooltipLocation: 'absolute',
     routeName: IntroTipRouteName,
   },
   [nuxTip.COMMUNITY_DRAWER]: {
     nextTip: nuxTip.HOME,
     tooltipLocation: 'below',
     routeName: CommunityDrawerTipRouteName,
   },
   [nuxTip.HOME]: {
     nextTip: nuxTip.MUTED,
     tooltipLocation: 'below',
     routeName: HomeTabTipRouteName,
   },
   [nuxTip.MUTED]: {
     nextTip: undefined,
     routeName: MutedTabTipRouteName,
     tooltipLocation: 'below',
     exitingCallback: navigation => navigation.goBack(),
   },
 };
 
 function getNUXTipParams(currentTipKey: NUXTip): NUXTipParams {
   return nuxTipParams[currentTipKey];
 }
 
-type TipProps = {
-  +x: number,
-  +y: number,
-  +width: number,
-  +height: number,
-  +pageX: number,
-  +pageY: number,
-};
+type TipProps = (callback: MeasureOnSuccessCallback) => void;
 
 export type NUXTipsContextType = {
   +registerTipButton: (type: NUXTip, tipProps: ?TipProps) => void,
   +tipsProps: ?{ +[type: NUXTip]: TipProps },
 };
 
 const NUXTipsContext: React.Context<?NUXTipsContextType> =
   React.createContext<?NUXTipsContextType>();
 
 type Props = {
   +children: React.Node,
 };
 
 function NUXTipsContextProvider(props: Props): React.Node {
   const { children } = props;
 
   const [tipsPropsState, setTipsPropsState] = React.useState<{
     +[tip: NUXTip]: ?TipProps,
   }>(() => ({}));
 
   const registerTipButton = React.useCallback(
     (type: NUXTip, tipProps: ?TipProps) => {
       setTipsPropsState(currenttipsPropsState => {
         const newtipsPropsState = { ...currenttipsPropsState };
         newtipsPropsState[type] = tipProps;
         return newtipsPropsState;
       });
     },
     [],
   );
 
   const tipsProps = React.useMemo(() => {
     const result: { [tip: NUXTip]: TipProps } = {};
     for (const type of values(nuxTip)) {
       if (nuxTipParams[type].tooltipLocation === 'absolute') {
         continue;
       }
       if (!tipsPropsState[type]) {
         return null;
       }
       result[type] = tipsPropsState[type];
     }
 
     return result;
   }, [tipsPropsState]);
 
   const value = React.useMemo(
     () => ({
       registerTipButton,
       tipsProps,
     }),
     [tipsProps, registerTipButton],
   );
 
   return (
     <NUXTipsContext.Provider value={value}>{children}</NUXTipsContext.Provider>
   );
 }
 
 export {
   NUXTipsContext,
   NUXTipsContextProvider,
   nuxTip,
   getNUXTipParams,
   firstNUXTipKey,
 };
diff --git a/native/tooltip/nux-tips-overlay.react.js b/native/tooltip/nux-tips-overlay.react.js
index b50b31445..c4c28a2f6 100644
--- a/native/tooltip/nux-tips-overlay.react.js
+++ b/native/tooltip/nux-tips-overlay.react.js
@@ -1,464 +1,498 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { View, TouchableWithoutFeedback, Platform, Text } from 'react-native';
 import Animated, {
   FadeOut,
   withTiming,
   // eslint-disable-next-line no-unused-vars
   type EntryAnimationsValues,
   // eslint-disable-next-line no-unused-vars
   type ExitAnimationsValues,
 } from 'react-native-reanimated';
 
 import Button from '../components/button.react.js';
 import {
   getNUXTipParams,
   NUXTipsContext,
   type NUXTip,
 } from '../components/nux-tips-context.react.js';
 import type { AppNavigationProp } from '../navigation/app-navigator.react.js';
 import { OverlayContext } from '../navigation/overlay-context.js';
 import type {
   NavigationRoute,
   NUXTipRouteNames,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 import type { LayoutEvent } from '../types/react-native.js';
 import { AnimatedView } from '../types/styles.js';
 import type { WritableAnimatedStyleObj } from '../types/styles.js';
 
 const { Value } = Animated;
 
 const animationDuration = 150;
 
 const unboundStyles = {
   container: {
     flex: 1,
   },
   contentContainer: {
     flex: 1,
     overflow: 'hidden',
   },
   items: {
     backgroundColor: 'tooltipBackground',
     borderRadius: 5,
     overflow: 'hidden',
     paddingHorizontal: 20,
     paddingTop: 20,
     paddingBottom: 18,
   },
   triangleUp: {
     borderBottomColor: 'tooltipBackground',
     borderBottomWidth: 10,
     borderLeftColor: 'transparent',
     borderLeftWidth: 10,
     borderRightColor: 'transparent',
     borderRightWidth: 10,
     borderStyle: 'solid',
     borderTopColor: 'transparent',
     borderTopWidth: 0,
     bottom: Platform.OS === 'android' ? -1 : 0,
     height: 10,
     width: 10,
   },
   triangleDown: {
     borderBottomColor: 'transparent',
     borderBottomWidth: 0,
     borderLeftColor: 'transparent',
     borderLeftWidth: 10,
     borderRightColor: 'transparent',
     borderRightWidth: 10,
     borderStyle: 'solid',
     borderTopColor: 'tooltipBackground',
     borderTopWidth: 10,
     height: 10,
     top: Platform.OS === 'android' ? -1 : 0,
     width: 10,
   },
   tipText: {
     color: 'panelForegroundLabel',
     fontSize: 18,
     marginBottom: 10,
   },
   buttonContainer: {
     alignSelf: 'flex-end',
   },
   okButtonText: {
     fontSize: 18,
     color: 'panelForegroundLabel',
     textAlign: 'center',
     paddingVertical: 10,
     paddingHorizontal: 20,
   },
   okButton: {
     backgroundColor: 'purpleButton',
     borderRadius: 8,
   },
 };
 
 export type NUXTipsOverlayParams = {
   +tipKey: NUXTip,
 };
 
 export type NUXTipsOverlayProps<Route: NUXTipRouteNames> = {
   +navigation: AppNavigationProp<Route>,
   +route: NavigationRoute<Route>,
 };
 
 const marginVertical: number = 20;
 const marginHorizontal: number = 10;
 
 function createNUXTipsOverlay<Route: NUXTipRouteNames>(
   ButtonComponent: ?React.ComponentType<void | NUXTipsOverlayProps<Route>>,
   tipText: string,
 ): React.ComponentType<NUXTipsOverlayProps<Route>> {
   function NUXTipsOverlay(props: NUXTipsOverlayProps<Route>) {
     const nuxTipContext = React.useContext(NUXTipsContext);
     const { navigation, route } = props;
 
     const dimensions = useSelector(state => state.dimensions);
 
-    const { initialCoordinates, verticalBounds } = React.useMemo(() => {
+    const [coordinates, setCoordinates] = React.useState<?{
+      +initialCoordinates: {
+        +height: number,
+        +width: number,
+        +x: number,
+        +y: number,
+      },
+      +verticalBounds: {
+        +height: number,
+        +y: number,
+      },
+    }>(null);
+
+    React.useEffect(() => {
       if (!ButtonComponent) {
-        const y = (dimensions.height * 2) / 5;
-        const x = dimensions.width / 2;
-        return {
-          initialCoordinates: { height: 0, width: 0, x, y },
-          verticalBounds: { height: 0, y },
-        };
+        const yInitial = (dimensions.height * 2) / 5;
+        const xInitial = dimensions.width / 2;
+        setCoordinates({
+          initialCoordinates: { height: 0, width: 0, x: xInitial, y: yInitial },
+          verticalBounds: { height: 0, y: yInitial },
+        });
+        return;
       }
-      const tipProps = nuxTipContext?.tipsProps?.[route.params.tipKey];
-      invariant(tipProps, 'button should be registered with nuxTipContext');
-      const { pageX, pageY, width, height } = tipProps;
-
-      return {
-        initialCoordinates: { height, width, x: pageX, y: pageY },
-        verticalBounds: { height, y: pageY },
-      };
+      const measure = nuxTipContext?.tipsProps?.[route.params.tipKey];
+      invariant(measure, 'button should be registered with nuxTipContext');
+
+      measure((x, y, width, height, pageX, pageY) =>
+        setCoordinates({
+          initialCoordinates: { height, width, x: pageX, y: pageY },
+          verticalBounds: { height, y: pageY },
+        }),
+      );
     }, [dimensions, nuxTipContext?.tipsProps, route.params.tipKey]);
 
     const overlayContext = React.useContext(OverlayContext);
     invariant(overlayContext, 'NUXTipsOverlay should have OverlayContext');
     const { onExitFinish } = overlayContext;
 
     const { goBackOnce } = navigation;
 
     const styles = useStyles(unboundStyles);
 
     const contentContainerStyle = React.useMemo(() => {
+      if (!coordinates) {
+        return {};
+      }
       const fullScreenHeight = dimensions.height;
-      const top = verticalBounds.y;
+      const top = coordinates.verticalBounds.y;
       const bottom =
-        fullScreenHeight - verticalBounds.y - verticalBounds.height;
+        fullScreenHeight -
+        coordinates.verticalBounds.y -
+        coordinates.verticalBounds.height;
       return {
         ...styles.contentContainer,
         marginTop: top,
         marginBottom: bottom,
       };
-    }, [
-      dimensions.height,
-      styles.contentContainer,
-      verticalBounds.height,
-      verticalBounds.y,
-    ]);
+    }, [dimensions.height, styles.contentContainer, coordinates]);
 
     const buttonStyle = React.useMemo(() => {
-      const { x, y, width, height } = initialCoordinates;
+      if (!coordinates) {
+        return {};
+      }
+      const { x, y, width, height } = coordinates.initialCoordinates;
       return {
         width: Math.ceil(width),
         height: Math.ceil(height),
-        marginTop: y - verticalBounds.y,
+        marginTop: y - coordinates.verticalBounds.y,
         marginLeft: x,
       };
-    }, [initialCoordinates, verticalBounds]);
+    }, [coordinates]);
 
     const tipHorizontalOffsetRef = React.useRef(new Value(0));
     const tipHorizontalOffset = tipHorizontalOffsetRef.current;
 
     const onTipContainerLayout = React.useCallback(
       (event: LayoutEvent) => {
-        const { x, width } = initialCoordinates;
+        if (!coordinates) {
+          return;
+        }
+        const { x, width } = coordinates.initialCoordinates;
 
         const extraLeftSpace = x;
         const extraRightSpace = dimensions.width - width - x;
 
         const actualWidth = event.nativeEvent.layout.width;
         if (extraLeftSpace < extraRightSpace) {
           const minWidth = width + 2 * extraLeftSpace;
           tipHorizontalOffset.setValue((minWidth - actualWidth) / 2);
         } else {
           const minWidth = width + 2 * extraRightSpace;
           tipHorizontalOffset.setValue((actualWidth - minWidth) / 2);
         }
       },
-      [dimensions.width, initialCoordinates, tipHorizontalOffset],
+      [coordinates, dimensions.width, tipHorizontalOffset],
     );
 
     const tipParams = getNUXTipParams(route.params.tipKey);
     const { tooltipLocation } = tipParams;
 
     const baseTipContainerStyle = React.useMemo(() => {
+      if (!coordinates) {
+        return {};
+      }
+      const { initialCoordinates, verticalBounds } = coordinates;
       const { y, x, height, width } = initialCoordinates;
 
       const style: WritableAnimatedStyleObj = {
         position: 'absolute',
         alignItems: 'center',
       };
 
       if (tooltipLocation === 'below') {
         style.top =
           Math.min(y + height, verticalBounds.y + verticalBounds.height) +
           marginVertical;
       } else {
         style.bottom =
           dimensions.height - Math.max(y, verticalBounds.y) + marginVertical;
       }
 
       const extraLeftSpace = x;
       const extraRightSpace = dimensions.width - width - x;
       if (tooltipLocation === 'absolute') {
         style.left = marginHorizontal;
         style.right = marginHorizontal;
       } else if (extraLeftSpace < extraRightSpace) {
         style.left = marginHorizontal;
         style.minWidth = width + 2 * extraLeftSpace;
         style.marginRight = 2 * marginHorizontal;
       } else {
         style.right = marginHorizontal;
         style.minWidth = width + 2 * extraRightSpace;
         style.marginLeft = 2 * marginHorizontal;
       }
 
       return style;
-    }, [
-      dimensions.height,
-      dimensions.width,
-      initialCoordinates,
-      tooltipLocation,
-      verticalBounds.height,
-      verticalBounds.y,
-    ]);
+    }, [coordinates, dimensions.height, dimensions.width, tooltipLocation]);
 
     const triangleStyle = React.useMemo(() => {
-      const { x, width } = initialCoordinates;
+      if (!coordinates) {
+        return {};
+      }
+      const { x, width } = coordinates.initialCoordinates;
       const extraLeftSpace = x;
       const extraRightSpace = dimensions.width - width - x;
       if (extraLeftSpace < extraRightSpace) {
         return {
           alignSelf: 'flex-start',
           left: extraLeftSpace + (4 / 10) * width - marginHorizontal,
         };
       } else {
         return {
           alignSelf: 'flex-end',
           right: extraRightSpace + (4 / 10) * width - marginHorizontal,
         };
       }
-    }, [dimensions.width, initialCoordinates]);
+    }, [coordinates, dimensions.width]);
 
     // prettier-ignore
     const tipContainerEnteringAnimation = React.useCallback(
       (values/*: EntryAnimationsValues*/) => {
         'worklet';
 
+        if (!coordinates) {
+          return {
+            animations: {},
+            initialValues:{},
+          };
+        }
+
         if(tooltipLocation === 'absolute'){
           return {
             animations: {
               opacity: withTiming(1, { duration: animationDuration }),
               transform: [     
                 { scale: withTiming(1, { duration: animationDuration }) },
               ],
             },
             initialValues: {
               opacity: 0,
               transform: [
                 { scale: 0 },
               ],
             },
           };
         }
 
         const initialX =
           (-values.targetWidth +
-            initialCoordinates.width +
-            initialCoordinates.x) /
+            coordinates.initialCoordinates.width +
+            coordinates.initialCoordinates.x) /
           2;
         const initialY =
           tooltipLocation === 'below'
             ? -values.targetHeight / 2
             : values.targetHeight / 2;
 
         return {
           animations: {
             opacity: withTiming(1, { duration: animationDuration }),
             transform: [
               { translateX: withTiming(0, { duration: animationDuration }) },
               { translateY: withTiming(0, { duration: animationDuration }) },
               { scale: withTiming(1, { duration: animationDuration }) },
             ],
           },
           initialValues: {
             opacity: 0,
             transform: [
               { translateX: initialX },
               { translateY: initialY },
               { scale: 0 },
             ],
           },
         };
       },
-      [initialCoordinates.width, initialCoordinates.x, tooltipLocation],
+      [coordinates, tooltipLocation],
     );
 
     // prettier-ignore
     const tipContainerExitingAnimation = React.useCallback(
       (values/*: ExitAnimationsValues*/) => {
         'worklet';
 
+        if (!coordinates) {
+          return {
+            animations: {},
+            initialValues:{},
+          };
+        }
+
         if (tooltipLocation === 'absolute') {
           return {
             animations: {
               opacity: withTiming(0, { duration: animationDuration }),
               transform: [
                 { scale: withTiming(0, { duration: animationDuration }) },
               ],
             },
             initialValues: {
               opacity: 1,
               transform: [{ scale: 1 }],
             },
             callback: onExitFinish,
           };
         }
 
         const toValueX =
           (-values.currentWidth +
-            initialCoordinates.width +
-            initialCoordinates.x) /
+            coordinates.initialCoordinates.width +
+            coordinates.initialCoordinates.x) /
           2;
         const toValueY =
           tooltipLocation === 'below'
             ? -values.currentHeight / 2
             : values.currentHeight / 2;
 
         return {
           animations: {
             opacity: withTiming(0, { duration: animationDuration }),
             transform: [
               {
                 translateX: withTiming(toValueX, {
                   duration: animationDuration,
                 }),
               },
               {
                 translateY: withTiming(toValueY, {
                   duration: animationDuration,
                 }),
               },
               { scale: withTiming(0, { duration: animationDuration }) },
             ],
           },
           initialValues: {
             opacity: 1,
             transform: [{ translateX: 0 }, { translateY: 0 }, { scale: 1 }],
           },
           callback: onExitFinish,
         };
       },
-      [
-        initialCoordinates.width,
-        initialCoordinates.x,
-        onExitFinish,
-        tooltipLocation,
-      ],
+      [coordinates, onExitFinish, tooltipLocation],
     );
 
     let triangleDown = null;
     let triangleUp = null;
     if (tooltipLocation === 'above') {
       triangleDown = <View style={[styles.triangleDown, triangleStyle]} />;
     } else if (tooltipLocation === 'below') {
       triangleUp = <View style={[styles.triangleUp, triangleStyle]} />;
     }
 
     const onPressOk = React.useCallback(() => {
       const { nextTip, exitingCallback } = tipParams;
       goBackOnce();
 
       if (exitingCallback) {
         exitingCallback?.(navigation);
       }
 
       if (!nextTip) {
         return;
       }
       const { routeName } = getNUXTipParams(nextTip);
 
       navigation.navigate<NUXTipRouteNames>({
         name: routeName,
         params: {
           tipKey: nextTip,
         },
       });
     }, [goBackOnce, navigation, tipParams]);
 
     const button = React.useMemo(
       () =>
         ButtonComponent ? (
           <View style={contentContainerStyle}>
             <Animated.View
               style={buttonStyle}
               exiting={FadeOut.duration(animationDuration)}
             >
               <ButtonComponent navigation={props.navigation} route={route} />
             </Animated.View>
           </View>
         ) : undefined,
       [buttonStyle, contentContainerStyle, props.navigation, route],
     );
 
+    if (!coordinates) {
+      return null;
+    }
+
     return (
       <TouchableWithoutFeedback onPress={onPressOk}>
         <View style={styles.container}>
           {button}
           <AnimatedView
             style={baseTipContainerStyle}
             onLayout={onTipContainerLayout}
             entering={tipContainerEnteringAnimation}
             exiting={tipContainerExitingAnimation}
           >
             {triangleUp}
             <View style={styles.items}>
               <Text style={styles.tipText}>{tipText}</Text>
               <View style={styles.buttonContainer}>
                 <Button
                   onPress={onPressOk}
                   iosActiveOpacity={0.6}
                   style={styles.okButton}
                 >
                   <Text style={styles.okButtonText}>Next</Text>
                 </Button>
               </View>
             </View>
             {triangleDown}
           </AnimatedView>
         </View>
       </TouchableWithoutFeedback>
     );
   }
 
   function NUXTipsOverlayWrapper(props: NUXTipsOverlayProps<Route>) {
     const overlayContext = React.useContext(OverlayContext);
     invariant(overlayContext, 'NUXTipsOverlay should have OverlayContext');
     const { shouldRenderScreenContent } = overlayContext;
 
     return shouldRenderScreenContent ? <NUXTipsOverlay {...props} /> : null;
   }
 
   return React.memo<NUXTipsOverlayProps<Route>>(NUXTipsOverlayWrapper);
 }
 
 export { createNUXTipsOverlay, animationDuration };