diff --git a/lib/media/media-utils.js b/lib/media/media-utils.js
index fe1bc589b..c3bd68b6e 100644
--- a/lib/media/media-utils.js
+++ b/lib/media/media-utils.js
@@ -1,58 +1,63 @@
 // @flow
 
 import invariant from 'invariant';
 
 import type { PlatformDetails } from '../types/device-types';
 import type { Media } from '../types/media-types';
 import type {
   MultimediaMessageInfo,
   RawMultimediaMessageInfo,
 } from '../types/message-types';
 
 const maxDimensions = Object.freeze({ width: 1920, height: 1920 });
 
 const localhostRegex = /^http:\/\/localhost/;
 function shimUploadURI(uri: string, platformDetails: ?PlatformDetails) {
   if (!platformDetails || platformDetails.platform !== 'android') {
     return uri;
   }
   // We do this for testing in the Android emulator
   return uri.replace(localhostRegex, 'http://10.0.2.2');
 }
 
 function contentStringForMediaArray(media: $ReadOnlyArray<Media>): string {
   invariant(media.length > 0, 'there should be some media');
   if (media.length === 1) {
     return `a ${media[0].type}`;
   }
   let firstType;
   for (const single of media) {
     if (!firstType) {
       firstType = single.type;
     }
     if (firstType === single.type) {
       continue;
     } else {
       return 'some media';
     }
   }
   invariant(firstType, 'there should be some media');
   if (firstType === 'photo') {
     firstType = 'image';
   }
   return `some ${firstType}s`;
 }
 
 function multimediaMessagePreview(
   messageInfo: MultimediaMessageInfo | RawMultimediaMessageInfo,
 ): string {
   const mediaContentString = contentStringForMediaArray(messageInfo.media);
   return `sent ${mediaContentString}`;
 }
 
+function isLocalUploadID(id: string): boolean {
+  return id.startsWith('localUpload');
+}
+
 export {
   maxDimensions,
   shimUploadURI,
   contentStringForMediaArray,
   multimediaMessagePreview,
+  isLocalUploadID,
 };
diff --git a/native/chat/inline-multimedia.react.js b/native/chat/inline-multimedia.react.js
index 8f71e9524..459f93f7f 100644
--- a/native/chat/inline-multimedia.react.js
+++ b/native/chat/inline-multimedia.react.js
@@ -1,156 +1,157 @@
 // @flow
 
 import * as React from 'react';
 import { View, StyleSheet, Text } from 'react-native';
 import * as Progress from 'react-native-progress';
 import Icon from 'react-native-vector-icons/Feather';
 import IonIcon from 'react-native-vector-icons/Ionicons';
 import tinycolor from 'tinycolor2';
 
+import { isLocalUploadID } from 'lib/media/media-utils';
 import type { MediaInfo } from 'lib/types/media-types';
 
 import GestureTouchableOpacity from '../components/gesture-touchable-opacity.react';
 import type { PendingMultimediaUpload } from '../input/input-state';
 import { KeyboardContext } from '../keyboard/keyboard-state';
 import Multimedia from '../media/multimedia.react';
 
 type Props = {|
   +mediaInfo: MediaInfo,
   +onPress: () => void,
   +onLongPress: () => void,
   +postInProgress: boolean,
   +pendingUpload: ?PendingMultimediaUpload,
   +spinnerColor: string,
 |};
 function InlineMultimedia(props: Props) {
   const { mediaInfo, pendingUpload, postInProgress } = props;
 
-  let failed = mediaInfo.id.startsWith('localUpload') && !postInProgress;
+  let failed = isLocalUploadID(mediaInfo.id) && !postInProgress;
   let progressPercent = 1;
   let processingStep;
   if (pendingUpload) {
     ({ progressPercent, failed, processingStep } = pendingUpload);
   }
 
   let progressIndicator;
   if (failed) {
     progressIndicator = (
       <View style={styles.centerContainer}>
         <Icon name="alert-circle" style={styles.uploadError} size={64} />
       </View>
     );
   } else if (progressPercent !== 1) {
     const progressOverlay = (
       <View style={styles.progressOverlay}>
         <Text style={styles.progressPercentText}>
           {`${Math.floor(progressPercent * 100).toString()}%`}
         </Text>
         <Text style={styles.processingStepText}>
           {processingStep ? processingStep : 'pending'}
         </Text>
       </View>
     );
 
     const primaryColor = tinycolor(props.spinnerColor);
     const secondaryColor = primaryColor.isDark()
       ? primaryColor.lighten(20).toString()
       : primaryColor.darken(20).toString();
 
     const progressSpinnerProps = {
       size: 120,
       indeterminate: progressPercent === 0,
       progress: progressPercent,
       fill: secondaryColor,
       unfilledColor: secondaryColor,
       color: props.spinnerColor,
       thickness: 10,
       borderWidth: 0,
     };
 
     let progressSpinner;
     if (processingStep === 'transcoding') {
       progressSpinner = <Progress.Circle {...progressSpinnerProps} />;
     } else {
       progressSpinner = <Progress.Pie {...progressSpinnerProps} />;
     }
 
     progressIndicator = (
       <View style={styles.centerContainer}>
         {progressSpinner}
         {progressOverlay}
       </View>
     );
   }
 
   let playButton;
   if (mediaInfo.type === 'video') {
     playButton = (
       <View style={styles.centerContainer}>
         <IonIcon name="ios-play-circle" style={styles.playButton} size={80} />
       </View>
     );
   }
 
   const keyboardState = React.useContext(KeyboardContext);
   const keyboardShowing = keyboardState?.keyboardShowing;
 
   return (
     <GestureTouchableOpacity
       onPress={props.onPress}
       onLongPress={props.onLongPress}
       disabled={keyboardShowing}
       style={styles.expand}
     >
       <Multimedia mediaInfo={mediaInfo} spinnerColor={props.spinnerColor} />
       {progressIndicator ? progressIndicator : playButton}
     </GestureTouchableOpacity>
   );
 }
 
 const styles = StyleSheet.create({
   centerContainer: {
     alignItems: 'center',
     bottom: 0,
     justifyContent: 'center',
     left: 0,
     position: 'absolute',
     right: 0,
     top: 0,
   },
   expand: {
     flex: 1,
   },
   playButton: {
     color: 'white',
     opacity: 0.9,
     textShadowColor: '#000',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
   },
   processingStepText: {
     color: 'white',
     fontSize: 12,
     textShadowColor: '#000',
     textShadowRadius: 1,
   },
   progressOverlay: {
     alignItems: 'center',
     justifyContent: 'center',
     position: 'absolute',
   },
   progressPercentText: {
     color: 'white',
     fontSize: 24,
     fontWeight: 'bold',
     textShadowColor: '#000',
     textShadowRadius: 1,
   },
   uploadError: {
     color: 'white',
     textShadowColor: '#000',
     textShadowOffset: { width: 0, height: 1 },
     textShadowRadius: 1,
   },
 });
 
 export default InlineMultimedia;
diff --git a/native/input/input-state-container.react.js b/native/input/input-state-container.react.js
index 75e077c81..7d813fb86 100644
--- a/native/input/input-state-container.react.js
+++ b/native/input/input-state-container.react.js
@@ -1,1168 +1,1161 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform } from 'react-native';
 import * as Upload from 'react-native-background-upload';
 import { useDispatch } from 'react-redux';
 import { createSelector } from 'reselect';
 
 import {
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   sendMultimediaMessage,
   sendTextMessageActionTypes,
   sendTextMessage,
 } from 'lib/actions/message-actions';
 import { queueReportsActionType } from 'lib/actions/report-actions';
 import {
   uploadMultimedia,
   updateMultimediaMessageMediaActionType,
   type MultimediaUploadCallbacks,
   type MultimediaUploadExtras,
 } from 'lib/actions/upload-actions';
 import { pathFromURI } from 'lib/media/file-utils';
+import { isLocalUploadID } from 'lib/media/media-utils';
 import { videoDurationLimit } from 'lib/media/video-utils';
 import {
   createLoadingStatusSelector,
   combineLoadingStatuses,
 } from 'lib/selectors/loading-selectors';
 import { createMediaMessageInfo } from 'lib/shared/message-utils';
 import { isStaff } from 'lib/shared/user-utils';
 import type {
   UploadMultimediaResult,
   Media,
   NativeMediaSelection,
   MediaMissionResult,
   MediaMission,
 } from 'lib/types/media-types';
 import {
   messageTypes,
   type RawMessageInfo,
   type RawMultimediaMessageInfo,
   type SendMessageResult,
   type SendMessagePayload,
 } from 'lib/types/message-types';
 import type { RawImagesMessageInfo } from 'lib/types/messages/images';
 import type { RawMediaMessageInfo } from 'lib/types/messages/media';
 import type { RawTextMessageInfo } from 'lib/types/messages/text';
 import type { Dispatch } from 'lib/types/redux-types';
 import {
   type MediaMissionReportCreationRequest,
   reportTypes,
 } from 'lib/types/report-types';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 import { getConfig } from 'lib/utils/config';
 import { getMessageForException, cloneError } from 'lib/utils/errors';
 import type {
   FetchJSONOptions,
   FetchJSONServerResponse,
 } from 'lib/utils/fetch-json';
 
 import { disposeTempFile } from '../media/file-utils';
 import { processMedia } from '../media/media-utils';
 import { displayActionResultModal } from '../navigation/action-result-modal';
 import { useSelector } from '../redux/redux-utils';
 import {
   InputStateContext,
   type PendingMultimediaUploads,
   type MultimediaProcessingStep,
 } from './input-state';
 
 let nextLocalUploadID = 0;
 function getNewLocalID() {
   return `localUpload${nextLocalUploadID++}`;
 }
 
 type MediaIDs =
   | {| +type: 'photo', +localMediaID: string |}
   | {| +type: 'video', +localMediaID: string, +localThumbnailID: string |};
 type UploadFileInput = {|
   +selection: NativeMediaSelection,
   +ids: MediaIDs,
 |};
 type CompletedUploads = { +[localMessageID: string]: ?Set<string> };
 
 type BaseProps = {|
   +children: React.Node,
 |};
 type Props = {|
   ...BaseProps,
   +viewerID: ?string,
   +nextLocalID: number,
   +messageStoreMessages: { [id: string]: RawMessageInfo },
   +ongoingMessageCreation: boolean,
   +hasWiFi: boolean,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   +uploadMultimedia: (
     multimedia: Object,
     extras: MultimediaUploadExtras,
     callbacks: MultimediaUploadCallbacks,
   ) => Promise<UploadMultimediaResult>,
   +sendMultimediaMessage: (
     threadID: string,
     localID: string,
     mediaIDs: $ReadOnlyArray<string>,
   ) => Promise<SendMessageResult>,
   +sendTextMessage: (
     threadID: string,
     localID: string,
     text: string,
   ) => Promise<SendMessageResult>,
 |};
 type State = {|
   +pendingUploads: PendingMultimediaUploads,
 |};
 class InputStateContainer extends React.PureComponent<Props, State> {
   state: State = {
     pendingUploads: {},
   };
   sendCallbacks: Array<() => void> = [];
   activeURIs = new Map();
   replyCallbacks: Array<(message: string) => void> = [];
 
   static getCompletedUploads(props: Props, state: State): CompletedUploads {
     const completedUploads = {};
     for (const localMessageID in state.pendingUploads) {
       const messagePendingUploads = state.pendingUploads[localMessageID];
       const rawMessageInfo = props.messageStoreMessages[localMessageID];
       if (!rawMessageInfo) {
         continue;
       }
       invariant(
         rawMessageInfo.type === messageTypes.IMAGES ||
           rawMessageInfo.type === messageTypes.MULTIMEDIA,
         `rawMessageInfo ${localMessageID} should be multimedia`,
       );
 
-      const completed = [];
       let allUploadsComplete = true;
-      for (const localUploadID in messagePendingUploads) {
-        let media;
-        for (const singleMedia of rawMessageInfo.media) {
-          if (singleMedia.id === localUploadID) {
-            media = singleMedia;
-            break;
-          }
-        }
-        if (media) {
+      const completedUploadIDs = new Set(Object.keys(messagePendingUploads));
+      for (const singleMedia of rawMessageInfo.media) {
+        if (isLocalUploadID(singleMedia.id)) {
           allUploadsComplete = false;
-        } else {
-          completed.push(localUploadID);
+          completedUploadIDs.delete(singleMedia.id);
         }
       }
 
       if (allUploadsComplete) {
         completedUploads[localMessageID] = null;
-      } else if (completed.length > 0) {
-        completedUploads[localMessageID] = new Set(completed);
+      } else if (completedUploadIDs.size > 0) {
+        completedUploads[localMessageID] = completedUploadIDs;
       }
     }
     return completedUploads;
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (this.props.viewerID !== prevProps.viewerID) {
       this.setState({ pendingUploads: {} });
       return;
     }
 
     const currentlyComplete = InputStateContainer.getCompletedUploads(
       this.props,
       this.state,
     );
     const previouslyComplete = InputStateContainer.getCompletedUploads(
       prevProps,
       prevState,
     );
 
     const newPendingUploads = {};
     let pendingUploadsChanged = false;
     const readyMessageIDs = [];
     for (const localMessageID in this.state.pendingUploads) {
       const messagePendingUploads = this.state.pendingUploads[localMessageID];
       const prevRawMessageInfo = prevProps.messageStoreMessages[localMessageID];
       const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
       const completedUploadIDs = currentlyComplete[localMessageID];
       const previouslyCompletedUploadIDs = previouslyComplete[localMessageID];
 
       if (!rawMessageInfo && prevRawMessageInfo) {
         pendingUploadsChanged = true;
         continue;
       } else if (completedUploadIDs === null) {
         // All of this message's uploads have been completed
         newPendingUploads[localMessageID] = {};
         if (previouslyCompletedUploadIDs !== null) {
           readyMessageIDs.push(localMessageID);
           pendingUploadsChanged = true;
         }
         continue;
       } else if (!completedUploadIDs) {
         // Nothing has been completed
         newPendingUploads[localMessageID] = messagePendingUploads;
         continue;
       }
 
       const newUploads = {};
       let uploadsChanged = false;
       for (const localUploadID in messagePendingUploads) {
         if (!completedUploadIDs.has(localUploadID)) {
           newUploads[localUploadID] = messagePendingUploads[localUploadID];
         } else if (
           !previouslyCompletedUploadIDs ||
           !previouslyCompletedUploadIDs.has(localUploadID)
         ) {
           uploadsChanged = true;
         }
       }
 
       if (uploadsChanged) {
         pendingUploadsChanged = true;
         newPendingUploads[localMessageID] = newUploads;
       } else {
         newPendingUploads[localMessageID] = messagePendingUploads;
       }
     }
     if (pendingUploadsChanged) {
       this.setState({ pendingUploads: newPendingUploads });
     }
 
     for (const localMessageID of readyMessageIDs) {
       const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
       if (!rawMessageInfo) {
         continue;
       }
       invariant(
         rawMessageInfo.type === messageTypes.IMAGES ||
           rawMessageInfo.type === messageTypes.MULTIMEDIA,
         `rawMessageInfo ${localMessageID} should be multimedia`,
       );
       this.dispatchMultimediaMessageAction(rawMessageInfo);
     }
   }
 
   dispatchMultimediaMessageAction(messageInfo: RawMultimediaMessageInfo) {
     this.props.dispatchActionPromise(
       sendMultimediaMessageActionTypes,
       this.sendMultimediaMessageAction(messageInfo),
       undefined,
       messageInfo,
     );
   }
 
   async sendMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<SendMessagePayload> {
     const { localID, threadID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     const mediaIDs = [];
     for (const { id } of messageInfo.media) {
       mediaIDs.push(id);
     }
     try {
       const result = await this.props.sendMultimediaMessage(
         threadID,
         localID,
         mediaIDs,
       );
       return {
         localID,
         serverID: result.id,
         threadID,
         time: result.time,
         interface: result.interface,
       };
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = localID;
       copy.threadID = threadID;
       throw copy;
     }
   }
 
   inputStateSelector = createSelector(
     (state: State) => state.pendingUploads,
     (pendingUploads: PendingMultimediaUploads) => ({
       pendingUploads,
       sendTextMessage: this.sendTextMessage,
       sendMultimediaMessage: this.sendMultimediaMessage,
       addReply: this.addReply,
       addReplyListener: this.addReplyListener,
       removeReplyListener: this.removeReplyListener,
       messageHasUploadFailure: this.messageHasUploadFailure,
       retryMessage: this.retryMessage,
       registerSendCallback: this.registerSendCallback,
       unregisterSendCallback: this.unregisterSendCallback,
       uploadInProgress: this.uploadInProgress,
       reportURIDisplayed: this.reportURIDisplayed,
     }),
   );
 
   uploadInProgress = () => {
     if (this.props.ongoingMessageCreation) {
       return true;
     }
     for (const localMessageID in this.state.pendingUploads) {
       const messagePendingUploads = this.state.pendingUploads[localMessageID];
       for (const localUploadID in messagePendingUploads) {
         const { failed } = messagePendingUploads[localUploadID];
         if (!failed) {
           return true;
         }
       }
     }
     return false;
   };
 
   sendTextMessage = (messageInfo: RawTextMessageInfo) => {
     this.sendCallbacks.forEach((callback) => callback());
     this.props.dispatchActionPromise(
       sendTextMessageActionTypes,
       this.sendTextMessageAction(messageInfo),
       undefined,
       messageInfo,
     );
   };
 
   async sendTextMessageAction(
     messageInfo: RawTextMessageInfo,
   ): Promise<SendMessagePayload> {
     try {
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
       const result = await this.props.sendTextMessage(
         messageInfo.threadID,
         localID,
         messageInfo.text,
       );
       return {
         localID,
         serverID: result.id,
         threadID: messageInfo.threadID,
         time: result.time,
         interface: result.interface,
       };
     } catch (e) {
       const copy = cloneError(e);
       copy.localID = messageInfo.localID;
       copy.threadID = messageInfo.threadID;
       throw copy;
     }
   }
 
   sendMultimediaMessage = async (
     threadID: string,
     selections: $ReadOnlyArray<NativeMediaSelection>,
   ) => {
     this.sendCallbacks.forEach((callback) => callback());
     const localMessageID = `local${this.props.nextLocalID}`;
 
     const uploadFileInputs = [],
       media = [];
     for (const selection of selections) {
       const localMediaID = getNewLocalID();
       let ids;
       if (selection.step === 'photo_library') {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'photo',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
         });
         ids = { type: 'photo', localMediaID };
       } else if (selection.step === 'photo_capture') {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'photo',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
         });
         ids = { type: 'photo', localMediaID };
       } else if (selection.step === 'photo_paste') {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'photo',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
         });
         ids = { type: 'photo', localMediaID };
       }
       const localThumbnailID = getNewLocalID();
       if (selection.step === 'video_library') {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'video',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
           loop: false,
         });
         ids = { type: 'video', localMediaID, localThumbnailID };
       }
       invariant(ids, `unexpected MediaSelection ${selection.step}`);
       uploadFileInputs.push({ selection, ids });
     }
 
     const pendingUploads = {};
     for (const uploadFileInput of uploadFileInputs) {
       const { localMediaID } = uploadFileInput.ids;
       pendingUploads[localMediaID] = {
         failed: null,
         progressPercent: 0,
       };
       if (uploadFileInput.ids.type === 'video') {
         const { localThumbnailID } = uploadFileInput.ids;
         pendingUploads[localThumbnailID] = {
           failed: null,
           progressPercent: 0,
         };
       }
     }
 
     this.setState(
       (prevState) => {
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [localMessageID]: pendingUploads,
           },
         };
       },
       () => {
         const creatorID = this.props.viewerID;
         invariant(creatorID, 'need viewer ID in order to send a message');
         const messageInfo = createMediaMessageInfo({
           localID: localMessageID,
           threadID,
           creatorID,
           media,
         });
         this.props.dispatch({
           type: createLocalMessageActionType,
           payload: messageInfo,
         });
       },
     );
 
     await this.uploadFiles(localMessageID, uploadFileInputs);
   };
 
   async uploadFiles(
     localMessageID: string,
     uploadFileInputs: $ReadOnlyArray<UploadFileInput>,
   ) {
     const results = await Promise.all(
       uploadFileInputs.map((uploadFileInput) =>
         this.uploadFile(localMessageID, uploadFileInput),
       ),
     );
     const errors = [...new Set(results.filter(Boolean))];
     if (errors.length > 0) {
       displayActionResultModal(errors.join(', ') + ' :(');
     }
   }
 
   async uploadFile(
     localMessageID: string,
     uploadFileInput: UploadFileInput,
   ): Promise<?string> {
     const { ids, selection } = uploadFileInput;
     const localID = ids.localMediaID;
     const start = selection.sendTime;
     const steps = [selection];
     let serverID;
     let userTime;
     let errorMessage;
     let reportPromise;
 
     const finish = async (result: MediaMissionResult) => {
       if (reportPromise) {
         const finalSteps = await reportPromise;
         steps.push(...finalSteps);
       }
       const totalTime = Date.now() - start;
       userTime = userTime ? userTime : totalTime;
       this.queueMediaMissionReport(
         { localID, localMessageID, serverID },
         { steps, result, totalTime, userTime },
       );
       return errorMessage;
     };
     const fail = (message: string) => {
       errorMessage = message;
       this.handleUploadFailure(localMessageID, localID, message);
       userTime = Date.now() - start;
     };
 
     let processedMedia;
     const processingStart = Date.now();
     try {
       const processMediaReturn = processMedia(
         selection,
         this.mediaProcessConfig(localMessageID, localID),
       );
       reportPromise = processMediaReturn.reportPromise;
       const processResult = await processMediaReturn.resultPromise;
       if (!processResult.success) {
         const message =
           processResult.reason === 'video_too_long'
             ? `can't do vids longer than ${videoDurationLimit}min`
             : 'processing failed';
         fail(message);
         return await finish(processResult);
       }
       processedMedia = processResult;
     } catch (e) {
       fail('processing failed');
       return await finish({
         success: false,
         reason: 'processing_exception',
         time: Date.now() - processingStart,
         exceptionMessage: getMessageForException(e),
       });
     }
 
     const { uploadURI, shouldDisposePath, filename, mime } = processedMedia;
 
     const { hasWiFi } = this.props;
 
     const uploadStart = Date.now();
     let uploadExceptionMessage, uploadResult, mediaMissionResult;
     try {
       uploadResult = await this.props.uploadMultimedia(
         { uri: uploadURI, name: filename, type: mime },
         { ...processedMedia.dimensions, loop: processedMedia.loop },
         {
           onProgress: (percent: number) =>
             this.setProgress(localMessageID, localID, 'uploading', percent),
           uploadBlob: this.uploadBlob,
         },
       );
       mediaMissionResult = { success: true };
     } catch (e) {
       uploadExceptionMessage = getMessageForException(e);
       fail('upload failed');
       mediaMissionResult = {
         success: false,
         reason: 'http_upload_failed',
         exceptionMessage: uploadExceptionMessage,
       };
     }
 
     if (uploadResult) {
       const { id, mediaType, uri, dimensions, loop } = uploadResult;
       serverID = id;
       // When we dispatch this action, it updates Redux and triggers the
       // componentDidUpdate in this class. componentDidUpdate will handle
       // calling dispatchMultimediaMessageAction once all the uploads are
       // complete, and does not wait until this function concludes.
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: {
           messageID: localMessageID,
           currentMediaID: localID,
           mediaUpdate: {
             id,
             type: mediaType,
             uri,
             dimensions,
             localMediaSelection: undefined,
             loop,
           },
         },
       });
       userTime = Date.now() - start;
     }
 
     const processSteps = await reportPromise;
     reportPromise = null;
     steps.push(...processSteps);
     steps.push({
       step: 'upload',
       success: !!uploadResult,
       exceptionMessage: uploadExceptionMessage,
       time: Date.now() - uploadStart,
       inputFilename: filename,
       outputMediaType: uploadResult && uploadResult.mediaType,
       outputURI: uploadResult && uploadResult.uri,
       outputDimensions: uploadResult && uploadResult.dimensions,
       outputLoop: uploadResult && uploadResult.loop,
       hasWiFi,
     });
 
     const promises = [];
 
     if (shouldDisposePath) {
       // If processMedia needed to do any transcoding before upload, we dispose
       // of the resultant temporary file here. Since the transcoded temporary
       // file is only used for upload, we can dispose of it after processMedia
       // (reportPromise) and the upload are complete
       promises.push(
         (async () => {
           const disposeStep = await disposeTempFile(shouldDisposePath);
           steps.push(disposeStep);
         })(),
       );
     }
 
     if (selection.captureTime || selection.step === 'photo_paste') {
       // If we are uploading a newly captured photo, we dispose of the original
       // file here. Note that we try to save photo captures to the camera roll
       // if we have permission. Even if we fail, this temporary file isn't
       // visible to the user, so there's no point in keeping it around. Since
       // the initial URI is used in rendering paths, we have to wait for it to
       // be replaced with the remote URI before we can dispose. Check out the
       // Multimedia component to see how the URIs get switched out.
       const captureURI = selection.uri;
       promises.push(
         (async () => {
           const {
             steps: clearSteps,
             result: capturePath,
           } = await this.waitForCaptureURIUnload(captureURI);
           steps.push(...clearSteps);
           if (!capturePath) {
             return;
           }
           const disposeStep = await disposeTempFile(capturePath);
           steps.push(disposeStep);
         })(),
       );
     }
 
     await Promise.all(promises);
 
     return await finish(mediaMissionResult);
   }
 
   mediaProcessConfig(localMessageID: string, localID: string) {
     const { hasWiFi, viewerID } = this.props;
     const onTranscodingProgress = (percent: number) => {
       this.setProgress(localMessageID, localID, 'transcoding', percent);
     };
     if (__DEV__ || (viewerID && isStaff(viewerID))) {
       return {
         hasWiFi,
         finalFileHeaderCheck: true,
         onTranscodingProgress,
       };
     }
     return { hasWiFi, onTranscodingProgress };
   }
 
   setProgress(
     localMessageID: string,
     localUploadID: string,
     processingStep: MultimediaProcessingStep,
     progressPercent: number,
   ) {
     this.setState((prevState) => {
       const pendingUploads = prevState.pendingUploads[localMessageID];
       if (!pendingUploads) {
         return {};
       }
       const pendingUpload = pendingUploads[localUploadID];
       if (!pendingUpload) {
         return {};
       }
       const newOutOfHundred = Math.floor(progressPercent * 100);
       const oldOutOfHundred = Math.floor(pendingUpload.progressPercent * 100);
       if (newOutOfHundred === oldOutOfHundred) {
         return {};
       }
       const newPendingUploads = {
         ...pendingUploads,
         [localUploadID]: {
           ...pendingUpload,
           progressPercent,
           processingStep,
         },
       };
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: newPendingUploads,
         },
       };
     });
   }
 
   uploadBlob = async (
     url: string,
     cookie: ?string,
     sessionID: ?string,
     input: { [key: string]: mixed },
     options?: ?FetchJSONOptions,
   ): Promise<FetchJSONServerResponse> => {
     invariant(
       cookie &&
         input.multimedia &&
         Array.isArray(input.multimedia) &&
         input.multimedia.length === 1 &&
         input.multimedia[0] &&
         typeof input.multimedia[0] === 'object',
       'InputStateContainer.uploadBlob sent incorrect input',
     );
     const { uri, name, type } = input.multimedia[0];
     invariant(
       typeof uri === 'string' &&
         typeof name === 'string' &&
         typeof type === 'string',
       'InputStateContainer.uploadBlob sent incorrect input',
     );
 
     const parameters = {};
     parameters.cookie = cookie;
     parameters.filename = name;
 
     for (const key in input) {
       if (
         key === 'multimedia' ||
         key === 'cookie' ||
         key === 'sessionID' ||
         key === 'filename'
       ) {
         continue;
       }
       const value = input[key];
       invariant(
         typeof value === 'string',
         'blobUpload calls can only handle string values for non-multimedia keys',
       );
       parameters[key] = value;
     }
 
     let path = uri;
     if (Platform.OS === 'android') {
       const resolvedPath = pathFromURI(uri);
       if (resolvedPath) {
         path = resolvedPath;
       }
     }
     const uploadID = await Upload.startUpload({
       url,
       path,
       type: 'multipart',
       headers: {
         Accept: 'application/json',
       },
       field: 'multimedia',
       parameters,
     });
     if (options && options.abortHandler) {
       options.abortHandler(() => {
         Upload.cancelUpload(uploadID);
       });
     }
     return await new Promise((resolve, reject) => {
       Upload.addListener('error', uploadID, (data) => {
         reject(data.error);
       });
       Upload.addListener('cancelled', uploadID, () => {
         reject(new Error('request aborted'));
       });
       Upload.addListener('completed', uploadID, (data) => {
         try {
           resolve(JSON.parse(data.responseBody));
         } catch (e) {
           reject(e);
         }
       });
       if (options && options.onProgress) {
         const { onProgress } = options;
         Upload.addListener('progress', uploadID, (data) =>
           onProgress(data.progress / 100),
         );
       }
     });
   };
 
   handleUploadFailure(
     localMessageID: string,
     localUploadID: string,
     message: string,
   ) {
     this.setState((prevState) => {
       const uploads = prevState.pendingUploads[localMessageID];
       const upload = uploads[localUploadID];
       if (!upload) {
         // The upload has been completed before it failed
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: {
             ...uploads,
             [localUploadID]: {
               ...upload,
               failed: message,
               progressPercent: 0,
             },
           },
         },
       };
     });
   }
 
   queueMediaMissionReport(
     ids: {| localID: string, localMessageID: string, serverID: ?string |},
     mediaMission: MediaMission,
   ) {
     const report: MediaMissionReportCreationRequest = {
       type: reportTypes.MEDIA_MISSION,
       time: Date.now(),
       platformDetails: getConfig().platformDetails,
       mediaMission,
       uploadServerID: ids.serverID,
       uploadLocalID: ids.localID,
       messageLocalID: ids.localMessageID,
     };
     this.props.dispatch({
       type: queueReportsActionType,
       payload: {
         reports: [report],
       },
     });
   }
 
   messageHasUploadFailure = (localMessageID: string) => {
     const pendingUploads = this.state.pendingUploads[localMessageID];
     if (!pendingUploads) {
       return false;
     }
     for (const localUploadID in pendingUploads) {
       const { failed } = pendingUploads[localUploadID];
       if (failed) {
         return true;
       }
     }
     return false;
   };
 
   addReply = (message: string) => {
     this.replyCallbacks.forEach((addReplyCallback) =>
       addReplyCallback(message),
     );
   };
 
   addReplyListener = (callbackReply: (message: string) => void) => {
     this.replyCallbacks.push(callbackReply);
   };
 
   removeReplyListener = (callbackReply: (message: string) => void) => {
     this.replyCallbacks = this.replyCallbacks.filter(
       (candidate) => candidate !== callbackReply,
     );
   };
 
   retryTextMessage = (rawMessageInfo: RawTextMessageInfo) => {
     this.sendTextMessage({
       ...rawMessageInfo,
       time: Date.now(),
     });
   };
 
   retryMultimediaMessage = async (
     rawMessageInfo: RawMultimediaMessageInfo,
     localMessageID: string,
   ) => {
     let pendingUploads = this.state.pendingUploads[localMessageID];
     if (!pendingUploads) {
       pendingUploads = {};
     }
 
     const now = Date.now();
 
     const updateMedia = <T: Media>(media: $ReadOnlyArray<T>): T[] =>
       media.map((singleMedia) => {
         const oldID = singleMedia.id;
-        if (!oldID.startsWith('localUpload')) {
+        if (!isLocalUploadID(oldID)) {
           // already uploaded
           return singleMedia;
         }
         if (pendingUploads[oldID] && !pendingUploads[oldID].failed) {
           // still being uploaded
           return singleMedia;
         }
 
         // If we have an incomplete upload that isn't in pendingUploads, that
         // indicates the app has restarted. We'll reassign a new localID to
         // avoid collisions. Note that this isn't necessary for the message ID
         // since the localID reducer prevents collisions there
         const id = pendingUploads[oldID] ? oldID : getNewLocalID();
 
         const oldSelection = singleMedia.localMediaSelection;
         invariant(
           oldSelection,
           'localMediaSelection should be set on locally created Media',
         );
         const retries = oldSelection.retries ? oldSelection.retries + 1 : 1;
 
         // We switch for Flow
         let selection;
         if (oldSelection.step === 'photo_capture') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else if (oldSelection.step === 'photo_library') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else if (oldSelection.step === 'photo_paste') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else {
           selection = { ...oldSelection, sendTime: now, retries };
         }
 
         if (singleMedia.type === 'photo') {
           return {
             type: 'photo',
             ...singleMedia,
             id,
             localMediaSelection: selection,
           };
         } else {
           return {
             type: 'video',
             ...singleMedia,
             id,
             localMediaSelection: selection,
           };
         }
       });
 
     let newRawMessageInfo;
     // This conditional is for Flow
     if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: now,
         media: updateMedia(rawMessageInfo.media),
       }: RawMediaMessageInfo);
     } else if (rawMessageInfo.type === messageTypes.IMAGES) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: now,
         media: updateMedia(rawMessageInfo.media),
       }: RawImagesMessageInfo);
     } else {
       invariant(false, `rawMessageInfo ${localMessageID} should be multimedia`);
     }
 
     const incompleteMedia: Media[] = [];
     for (const singleMedia of newRawMessageInfo.media) {
-      if (singleMedia.id.startsWith('localUpload')) {
+      if (isLocalUploadID(singleMedia.id)) {
         incompleteMedia.push(singleMedia);
       }
     }
     if (incompleteMedia.length === 0) {
       this.dispatchMultimediaMessageAction(newRawMessageInfo);
       this.setState((prevState) => ({
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: {},
         },
       }));
       return;
     }
 
     const retryMedia = incompleteMedia.filter(
       ({ id }) => !pendingUploads[id] || pendingUploads[id].failed,
     );
     if (retryMedia.length === 0) {
       // All media are already in the process of being uploaded
       return;
     }
 
     // We're not actually starting the send here,
     // we just use this action to update the message in Redux
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: newRawMessageInfo,
     });
 
     // We clear out the failed status on individual media here,
     // which makes the UI show pending status instead of error messages
     for (const { id } of retryMedia) {
       pendingUploads[id] = {
         failed: null,
         progressPercent: 0,
         processingStep: null,
       };
     }
     this.setState((prevState) => ({
       pendingUploads: {
         ...prevState.pendingUploads,
         [localMessageID]: pendingUploads,
       },
     }));
 
     const uploadFileInputs = retryMedia.map((singleMedia) => {
       const { id, localMediaSelection } = singleMedia;
       invariant(
         localMediaSelection && localMediaSelection.step !== 'video_library',
         'localMediaSelection should be set on locally created Media',
       );
       return {
         selection: localMediaSelection,
         ids: { type: 'photo', localMediaID: id },
       };
     });
 
     await this.uploadFiles(localMessageID, uploadFileInputs);
   };
 
   retryMessage = async (localMessageID: string) => {
     const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
     invariant(rawMessageInfo, `rawMessageInfo ${localMessageID} should exist`);
 
     if (rawMessageInfo.type === messageTypes.TEXT) {
       this.retryTextMessage(rawMessageInfo);
     } else if (
       rawMessageInfo.type === messageTypes.IMAGES ||
       rawMessageInfo.type === messageTypes.MULTIMEDIA
     ) {
       await this.retryMultimediaMessage(rawMessageInfo, localMessageID);
     }
   };
 
   registerSendCallback = (callback: () => void) => {
     this.sendCallbacks.push(callback);
   };
 
   unregisterSendCallback = (callback: () => void) => {
     this.sendCallbacks = this.sendCallbacks.filter(
       (candidate) => candidate !== callback,
     );
   };
 
   reportURIDisplayed = (uri: string, loaded: boolean) => {
     const prevActiveURI = this.activeURIs.get(uri);
     const curCount = prevActiveURI && prevActiveURI.count;
     const prevCount = curCount ? curCount : 0;
     const count = loaded ? prevCount + 1 : prevCount - 1;
     const prevOnClear = prevActiveURI && prevActiveURI.onClear;
     const onClear = prevOnClear ? prevOnClear : [];
     const activeURI = { count, onClear };
     if (count) {
       this.activeURIs.set(uri, activeURI);
       return;
     }
     this.activeURIs.delete(uri);
     for (const callback of onClear) {
       callback();
     }
   };
 
   waitForCaptureURIUnload(uri: string) {
     const start = Date.now();
     const path = pathFromURI(uri);
     if (!path) {
       return Promise.resolve({
         result: null,
         steps: [
           {
             step: 'wait_for_capture_uri_unload',
             success: false,
             time: Date.now() - start,
             uri,
           },
         ],
       });
     }
 
     const getResult = () => ({
       result: path,
       steps: [
         {
           step: 'wait_for_capture_uri_unload',
           success: true,
           time: Date.now() - start,
           uri,
         },
       ],
     });
 
     const activeURI = this.activeURIs.get(uri);
     if (!activeURI) {
       return Promise.resolve(getResult());
     }
 
     return new Promise((resolve) => {
       const finish = () => resolve(getResult());
       const newActiveURI = {
         ...activeURI,
         onClear: [...activeURI.onClear, finish],
       };
       this.activeURIs.set(uri, newActiveURI);
     });
   }
 
   render() {
     const inputState = this.inputStateSelector(this.state);
     return (
       <InputStateContext.Provider value={inputState}>
         {this.props.children}
       </InputStateContext.Provider>
     );
   }
 }
 
 const mediaCreationLoadingStatusSelector = createLoadingStatusSelector(
   sendMultimediaMessageActionTypes,
 );
 const textCreationLoadingStatusSelector = createLoadingStatusSelector(
   sendTextMessageActionTypes,
 );
 
 export default React.memo<BaseProps>(function ConnectedInputStateContainer(
   props: BaseProps,
 ) {
   const viewerID = useSelector(
     (state) => state.currentUserInfo && state.currentUserInfo.id,
   );
   const nextLocalID = useSelector((state) => state.nextLocalID);
   const messageStoreMessages = useSelector(
     (state) => state.messageStore.messages,
   );
   const ongoingMessageCreation = useSelector(
     (state) =>
       combineLoadingStatuses(
         mediaCreationLoadingStatusSelector(state),
         textCreationLoadingStatusSelector(state),
       ) === 'loading',
   );
   const hasWiFi = useSelector((state) => state.connectivity.hasWiFi);
   const callUploadMultimedia = useServerCall(uploadMultimedia);
   const callSendMultimediaMessage = useServerCall(sendMultimediaMessage);
   const callSendTextMessage = useServerCall(sendTextMessage);
   const dispatchActionPromise = useDispatchActionPromise();
   const dispatch = useDispatch();
 
   return (
     <InputStateContainer
       {...props}
       viewerID={viewerID}
       nextLocalID={nextLocalID}
       messageStoreMessages={messageStoreMessages}
       ongoingMessageCreation={ongoingMessageCreation}
       hasWiFi={hasWiFi}
       uploadMultimedia={callUploadMultimedia}
       sendMultimediaMessage={callSendMultimediaMessage}
       sendTextMessage={callSendTextMessage}
       dispatchActionPromise={dispatchActionPromise}
       dispatch={dispatch}
     />
   );
 });
diff --git a/native/media/save-media.js b/native/media/save-media.js
index be3971aa5..202dfc73a 100644
--- a/native/media/save-media.js
+++ b/native/media/save-media.js
@@ -1,447 +1,448 @@
 // @flow
 
 import * as MediaLibrary from 'expo-media-library';
 import invariant from 'invariant';
 import { Platform, PermissionsAndroid } from 'react-native';
 import filesystem from 'react-native-fs';
 
 import { queueReportsActionType } from 'lib/actions/report-actions';
 import { readableFilename, pathFromURI } from 'lib/media/file-utils';
+import { isLocalUploadID } from 'lib/media/media-utils';
 import type {
   MediaMissionStep,
   MediaMissionResult,
   MediaMissionFailure,
 } from 'lib/types/media-types';
 import {
   reportTypes,
   type MediaMissionReportCreationRequest,
 } from 'lib/types/report-types';
 import { getConfig } from 'lib/utils/config';
 import { getMessageForException } from 'lib/utils/errors';
 import { promiseAll } from 'lib/utils/promises';
 
 import { displayActionResultModal } from '../navigation/action-result-modal';
 import { dispatch } from '../redux/redux-setup';
 import { requestAndroidPermission } from '../utils/android-permissions';
 import { fetchBlob } from './blob-utils';
 import {
   fetchAssetInfo,
   fetchFileInfo,
   disposeTempFile,
   mkdir,
   androidScanFile,
   fetchFileHash,
   copyFile,
   temporaryDirectoryPath,
 } from './file-utils';
 import { getMediaLibraryIdentifier } from './identifier-utils';
 
 async function intentionalSaveMedia(
   uri: string,
   ids: {|
     uploadID: string,
     messageServerID: ?string,
     messageLocalID: ?string,
   |},
 ): Promise<void> {
   const start = Date.now();
   const steps = [{ step: 'save_media', uri, time: start }];
 
   const { resultPromise, reportPromise } = saveMedia(uri, 'request');
   const result = await resultPromise;
   const userTime = Date.now() - start;
 
   let message;
   if (result.success) {
     message = 'saved!';
   } else if (result.reason === 'save_unsupported') {
     const os = Platform.select({
       ios: 'iOS',
       android: 'Android',
       default: Platform.OS,
     });
     message = `saving media is unsupported on ${os}`;
   } else if (result.reason === 'missing_permission') {
     message = "don't have permission :(";
   } else if (
     result.reason === 'resolve_failed' ||
     result.reason === 'data_uri_failed'
   ) {
     message = 'failed to resolve :(';
   } else if (result.reason === 'fetch_failed') {
     message = 'failed to download :(';
   } else {
     message = 'failed to save :(';
   }
   displayActionResultModal(message);
 
   const reportSteps = await reportPromise;
   steps.push(...reportSteps);
   const totalTime = Date.now() - start;
   const mediaMission = { steps, result, userTime, totalTime };
 
   const { uploadID, messageServerID, messageLocalID } = ids;
-  const uploadIDIsLocal = uploadID.startsWith('localUpload');
+  const uploadIDIsLocal = isLocalUploadID(uploadID);
   const report: MediaMissionReportCreationRequest = {
     type: reportTypes.MEDIA_MISSION,
     time: Date.now(),
     platformDetails: getConfig().platformDetails,
     mediaMission,
     uploadServerID: uploadIDIsLocal ? undefined : uploadID,
     uploadLocalID: uploadIDIsLocal ? uploadID : undefined,
     messageServerID,
     messageLocalID,
   };
   dispatch({
     type: queueReportsActionType,
     payload: { reports: [report] },
   });
 }
 
 type Permissions = 'check' | 'request';
 
 function saveMedia(
   uri: string,
   permissions?: Permissions = 'check',
 ): {|
   resultPromise: Promise<MediaMissionResult>,
   reportPromise: Promise<$ReadOnlyArray<MediaMissionStep>>,
 |} {
   let resolveResult;
   const sendResult = (result) => {
     if (resolveResult) {
       resolveResult(result);
     }
   };
 
   const reportPromise = innerSaveMedia(uri, permissions, sendResult);
   const resultPromise = new Promise((resolve) => {
     resolveResult = resolve;
   });
 
   return { reportPromise, resultPromise };
 }
 
 async function innerSaveMedia(
   uri: string,
   permissions: Permissions,
   sendResult: (result: MediaMissionResult) => void,
 ): Promise<$ReadOnlyArray<MediaMissionStep>> {
   if (Platform.OS === 'android') {
     return await saveMediaAndroid(uri, permissions, sendResult);
   } else if (Platform.OS === 'ios') {
     return await saveMediaIOS(uri, sendResult);
   } else {
     sendResult({ success: false, reason: 'save_unsupported' });
     return [];
   }
 }
 
 const androidSavePermission =
   PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE;
 
 // On Android, we save the media to our own SquadCal folder in the
 // Pictures directory, and then trigger the media scanner to pick it up
 async function saveMediaAndroid(
   inputURI: string,
   permissions: Permissions,
   sendResult: (result: MediaMissionResult) => void,
 ): Promise<$ReadOnlyArray<MediaMissionStep>> {
   const steps = [];
 
   let hasPermission = false,
     permissionCheckExceptionMessage;
   const permissionCheckStart = Date.now();
   try {
     hasPermission = await requestAndroidPermission(
       androidSavePermission,
       'throw',
     );
   } catch (e) {
     permissionCheckExceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'permissions_check',
     success: hasPermission,
     exceptionMessage: permissionCheckExceptionMessage,
     time: Date.now() - permissionCheckStart,
     platform: Platform.OS,
     permissions: [androidSavePermission],
   });
   if (!hasPermission) {
     sendResult({ success: false, reason: 'missing_permission' });
     return steps;
   }
 
   const promises = [];
   let success = true;
   const saveFolder = `${filesystem.PicturesDirectoryPath}/SquadCal/`;
   promises.push(
     (async () => {
       const makeDirectoryStep = await mkdir(saveFolder);
       if (!makeDirectoryStep.success) {
         success = false;
         sendResult({ success, reason: 'make_directory_failed' });
       }
       steps.push(makeDirectoryStep);
     })(),
   );
 
   let uri = inputURI;
   let tempFile, mime;
   if (uri.startsWith('http')) {
     promises.push(
       (async () => {
         const {
           result: tempSaveResult,
           steps: tempSaveSteps,
         } = await saveRemoteMediaToDisk(uri, temporaryDirectoryPath);
         steps.push(...tempSaveSteps);
         if (!tempSaveResult.success) {
           success = false;
           sendResult(tempSaveResult);
         } else {
           tempFile = tempSaveResult.path;
           uri = `file://${tempFile}`;
           mime = tempSaveResult.mime;
         }
       })(),
     );
   }
 
   await Promise.all(promises);
   if (!success) {
     return steps;
   }
 
   const { result: copyResult, steps: copySteps } = await copyToSortedDirectory(
     uri,
     saveFolder,
     mime,
   );
   steps.push(...copySteps);
   if (!copyResult.success) {
     sendResult(copyResult);
     return steps;
   }
   sendResult({ success: true });
 
   const postResultPromises = [];
 
   postResultPromises.push(
     (async () => {
       const scanFileStep = await androidScanFile(copyResult.path);
       steps.push(scanFileStep);
     })(),
   );
 
   if (tempFile) {
     postResultPromises.push(
       (async (file: string) => {
         const disposeStep = await disposeTempFile(file);
         steps.push(disposeStep);
       })(tempFile),
     );
   }
 
   await Promise.all(postResultPromises);
   return steps;
 }
 
 // On iOS, we save the media to the camera roll
 async function saveMediaIOS(
   inputURI: string,
   sendResult: (result: MediaMissionResult) => void,
 ): Promise<$ReadOnlyArray<MediaMissionStep>> {
   const steps = [];
 
   let uri = inputURI;
   let tempFile;
   if (uri.startsWith('http')) {
     const {
       result: tempSaveResult,
       steps: tempSaveSteps,
     } = await saveRemoteMediaToDisk(uri, temporaryDirectoryPath);
     steps.push(...tempSaveSteps);
     if (!tempSaveResult.success) {
       sendResult(tempSaveResult);
       return steps;
     }
     tempFile = tempSaveResult.path;
     uri = `file://${tempFile}`;
   } else if (!uri.startsWith('file://')) {
     const mediaNativeID = getMediaLibraryIdentifier(uri);
     if (mediaNativeID) {
       const {
         result: fetchAssetInfoResult,
         steps: fetchAssetInfoSteps,
       } = await fetchAssetInfo(mediaNativeID);
       steps.push(...fetchAssetInfoSteps);
       const { localURI } = fetchAssetInfoResult;
       if (localURI) {
         uri = localURI;
       }
     }
   }
 
   if (!uri.startsWith('file://')) {
     sendResult({ success: false, reason: 'resolve_failed', uri });
     return steps;
   }
 
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await MediaLibrary.saveToLibraryAsync(uri);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'ios_save_to_library',
     success,
     exceptionMessage,
     time: Date.now() - start,
     uri,
   });
 
   if (success) {
     sendResult({ success: true });
   } else {
     sendResult({ success: false, reason: 'save_to_library_failed', uri });
   }
 
   if (tempFile) {
     const disposeStep = await disposeTempFile(tempFile);
     steps.push(disposeStep);
   }
   return steps;
 }
 
 type IntermediateSaveResult = {|
   result: {| success: true, path: string, mime: string |} | MediaMissionFailure,
   steps: $ReadOnlyArray<MediaMissionStep>,
 |};
 
 async function saveRemoteMediaToDisk(
   inputURI: string,
   directory: string, // should end with a /
 ): Promise<IntermediateSaveResult> {
   const steps = [];
 
   const { result: fetchBlobResult, steps: fetchBlobSteps } = await fetchBlob(
     inputURI,
   );
   steps.push(...fetchBlobSteps);
   if (!fetchBlobResult.success) {
     return { result: fetchBlobResult, steps };
   }
   const { mime, base64 } = fetchBlobResult;
 
   const tempName = readableFilename('', mime);
   if (!tempName) {
     return {
       result: { success: false, reason: 'mime_check_failed', mime },
       steps,
     };
   }
   const tempPath = `${directory}tempsave.${tempName}`;
 
   const start = Date.now();
   let success = false,
     exceptionMessage;
   try {
     await filesystem.writeFile(tempPath, base64, 'base64');
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'write_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path: tempPath,
     length: base64.length,
   });
 
   if (!success) {
     return { result: { success: false, reason: 'write_file_failed' }, steps };
   }
   return { result: { success: true, path: tempPath, mime }, steps };
 }
 
 async function copyToSortedDirectory(
   localURI: string,
   directory: string, // should end with a /
   inputMIME: ?string,
 ): Promise<IntermediateSaveResult> {
   const steps = [];
 
   const path = pathFromURI(localURI);
   if (!path) {
     return {
       result: { success: false, reason: 'resolve_failed', uri: localURI },
       steps,
     };
   }
   let mime = inputMIME;
 
   const promises = {};
   promises.hashStep = fetchFileHash(path);
   if (!mime) {
     promises.fileInfoResult = fetchFileInfo(localURI, undefined, {
       mime: true,
     });
   }
   const { hashStep, fileInfoResult } = await promiseAll(promises);
 
   steps.push(hashStep);
   if (!hashStep.success) {
     return {
       result: { success: false, reason: 'fetch_file_hash_failed' },
       steps,
     };
   }
   const { hash } = hashStep;
   invariant(hash, 'hash should be truthy if hashStep.success is truthy');
 
   if (fileInfoResult) {
     steps.push(...fileInfoResult.steps);
     if (fileInfoResult.result.success && fileInfoResult.result.mime) {
       ({ mime } = fileInfoResult.result);
     }
   }
   if (!mime) {
     return {
       result: { success: false, reason: 'mime_check_failed', mime },
       steps,
     };
   }
 
   const name = readableFilename(hash, mime);
   if (!name) {
     return {
       result: { success: false, reason: 'mime_check_failed', mime },
       steps,
     };
   }
   const newPath = `${directory}${name}`;
 
   const copyStep = await copyFile(path, newPath);
   steps.push(copyStep);
   if (!copyStep.success) {
     return {
       result: { success: false, reason: 'copy_file_failed' },
       steps,
     };
   }
 
   return {
     result: { success: true, path: newPath, mime },
     steps,
   };
 }
 
 export { intentionalSaveMedia, saveMedia };