diff --git a/lib/socket/activity-handler.react.js b/lib/socket/activity-handler.react.js
index b32eb3174..af7841c11 100644
--- a/lib/socket/activity-handler.react.js
+++ b/lib/socket/activity-handler.react.js
@@ -1,123 +1,122 @@
 // @flow
 
 import * as React from 'react';
 import { useDispatch } from 'react-redux';
 
 import {
   updateActivityActionTypes,
   updateActivity,
 } from '../actions/activity-actions';
+import { getMostRecentNonLocalMessageID } from '../shared/message-utils';
 import { queueActivityUpdatesActionType } from '../types/activity-types';
 import { useServerCall, useDispatchActionPromise } from '../utils/action-utils';
 import { useSelector } from '../utils/redux-utils';
 
 type Props = {|
-  activeThread: ?string,
-  frozen: boolean,
+  +activeThread: ?string,
+  +frozen: boolean,
 |};
 function ActivityHandler(props: Props) {
   const { activeThread, frozen } = props;
 
   const prevActiveThreadRef = React.useRef();
   React.useEffect(() => {
     prevActiveThreadRef.current = activeThread;
   }, [activeThread]);
   const prevActiveThread = prevActiveThreadRef.current;
 
   const connection = useSelector((state) => state.connection);
   const connectionStatus = connection.status;
   const prevConnectionStatusRef = React.useRef();
   React.useEffect(() => {
     prevConnectionStatusRef.current = connectionStatus;
   }, [connectionStatus]);
   const prevConnectionStatus = prevConnectionStatusRef.current;
 
   const activeThreadLatestMessage = useSelector((state) => {
     if (!activeThread) {
       return undefined;
     }
-    return state.messageStore.threads[activeThread]?.messageIDs.find(
-      (id) => !id.startsWith('local'),
-    );
+    return getMostRecentNonLocalMessageID(activeThread, state.messageStore);
   });
   const prevActiveThreadLatestMessageRef = React.useRef();
   React.useEffect(() => {
     prevActiveThreadLatestMessageRef.current = activeThreadLatestMessage;
   }, [activeThreadLatestMessage]);
   const prevActiveThreadLatestMessage =
     prevActiveThreadLatestMessageRef.current;
 
   const canSend = connectionStatus === 'connected' && !frozen;
   const prevCanSendRef = React.useRef();
   React.useEffect(() => {
     prevCanSendRef.current = canSend;
   }, [canSend]);
   const prevCanSend = prevCanSendRef.current;
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
   const callUpdateActivity = useServerCall(updateActivity);
 
   React.useEffect(() => {
     const activityUpdates = [];
     if (activeThread !== prevActiveThread) {
       if (prevActiveThread) {
         activityUpdates.push({
           focus: false,
           threadID: prevActiveThread,
           latestMessage: prevActiveThreadLatestMessage,
         });
       }
       if (activeThread) {
         activityUpdates.push({
           focus: true,
           threadID: activeThread,
           latestMessage: activeThreadLatestMessage,
         });
       }
     }
 
     if (
       !frozen &&
       connectionStatus !== 'connected' &&
       prevConnectionStatus === 'connected' &&
       activeThread
     ) {
       // When the server closes a socket it also deletes any activity rows
       // associated with that socket's session. If that activity is still
       // ongoing, we should make sure that we clarify that with the server once
       // we reconnect.
       activityUpdates.push({
         focus: true,
         threadID: activeThread,
       });
     }
 
     if (activityUpdates.length > 0) {
       dispatch({
         type: queueActivityUpdatesActionType,
         payload: { activityUpdates },
       });
     }
 
     if (!canSend) {
       return;
     }
 
     if (!prevCanSend) {
       activityUpdates.unshift(...connection.queuedActivityUpdates);
     }
 
     if (activityUpdates.length === 0) {
       return;
     }
     dispatchActionPromise(
       updateActivityActionTypes,
       callUpdateActivity(activityUpdates),
     );
   });
 
   return null;
 }
 
 export default ActivityHandler;