diff --git a/native/media/file-utils.js b/native/media/file-utils.js
index 95270cada..069bca49e 100644
--- a/native/media/file-utils.js
+++ b/native/media/file-utils.js
@@ -1,436 +1,442 @@
 // @flow
 
 import base64 from 'base-64';
 import * as MediaLibrary from 'expo-media-library';
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import filesystem from 'react-native-fs';
 
 import {
   mediaConfig,
   pathFromURI,
   fileInfoFromData,
   bytesNeededForFileTypeCheck,
 } from 'lib/media/file-utils';
 import type { Shape } from 'lib/types/core';
 import type {
   MediaMissionStep,
   MediaMissionFailure,
   MediaType,
   ReadFileHeaderMediaMissionStep,
   DisposeTemporaryFileMediaMissionStep,
   MakeDirectoryMediaMissionStep,
   AndroidScanFileMediaMissionStep,
   FetchFileHashMediaMissionStep,
   CopyFileMediaMissionStep,
 } from 'lib/types/media-types';
 import { getMessageForException } from 'lib/utils/errors';
 
 import { stringToIntArray } from './blob-utils';
 import { ffmpeg } from './ffmpeg';
 
 const defaultInputs = Object.freeze({});
 const defaultFields = Object.freeze({});
 
 type FetchFileInfoResult = {|
   +success: true,
   +uri: string,
   +orientation: ?number,
   +fileSize: number,
   +mime: ?string,
   +mediaType: ?MediaType,
 |};
 type OptionalInputs = Shape<{| +mediaNativeID: ?string |}>;
 type OptionalFields = Shape<{|
   +orientation: boolean,
   +mediaType: boolean,
   +mime: boolean,
 |}>;
 async function fetchFileInfo(
   inputURI: string,
   optionalInputs?: OptionalInputs = defaultInputs,
   optionalFields?: OptionalFields = defaultFields,
 ): Promise<{|
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionFailure | FetchFileInfoResult,
 |}> {
   const { mediaNativeID } = optionalInputs;
   const steps = [];
 
   let assetInfoPromise, newLocalURI;
   const inputPath = pathFromURI(inputURI);
   if (mediaNativeID && (!inputPath || optionalFields.orientation)) {
     assetInfoPromise = (async () => {
       const {
         steps: assetInfoSteps,
         result: assetInfoResult,
       } = await fetchAssetInfo(mediaNativeID);
       steps.push(...assetInfoSteps);
       newLocalURI = assetInfoResult.localURI;
       return assetInfoResult;
     })();
   }
 
   const getLocalURIPromise = (async () => {
     if (inputPath) {
       return { localURI: inputURI, path: inputPath };
     }
     if (!assetInfoPromise) {
       return null;
     }
     const { localURI } = await assetInfoPromise;
     if (!localURI) {
       return null;
     }
     const path = pathFromURI(localURI);
     if (!path) {
       return null;
     }
     return { localURI, path };
   })();
 
   const getOrientationPromise = (async () => {
     if (!optionalFields.orientation || !assetInfoPromise) {
       return null;
     }
     const { orientation } = await assetInfoPromise;
     return orientation;
   })();
 
   const getFileSizePromise = (async () => {
     const localURIResult = await getLocalURIPromise;
     if (!localURIResult) {
       return null;
     }
     const { localURI } = localURIResult;
     const { steps: fileSizeSteps, result: fileSize } = await fetchFileSize(
       localURI,
     );
     steps.push(...fileSizeSteps);
     return fileSize;
   })();
 
   const getTypesPromise = (async () => {
     if (!optionalFields.mime && !optionalFields.mediaType) {
       return { mime: null, mediaType: null };
     }
     const [localURIResult, fileSize] = await Promise.all([
       getLocalURIPromise,
       getFileSizePromise,
     ]);
     if (!localURIResult || !fileSize) {
       return { mime: null, mediaType: null };
     }
     const { localURI, path } = localURIResult;
     const readFileStep = await readFileHeader(localURI, fileSize);
     steps.push(readFileStep);
     const { mime, mediaType: baseMediaType } = readFileStep;
     if (!optionalFields.mediaType || !mime || !baseMediaType) {
       return { mime, mediaType: null };
     }
     const {
       steps: getMediaTypeSteps,
       result: mediaType,
     } = await getMediaTypeInfo(path, mime, baseMediaType);
     steps.push(...getMediaTypeSteps);
     return { mime, mediaType };
   })();
 
   const [localURIResult, orientation, fileSize, types] = await Promise.all([
     getLocalURIPromise,
     getOrientationPromise,
     getFileSizePromise,
     getTypesPromise,
   ]);
   if (!localURIResult) {
     return { steps, result: { success: false, reason: 'no_file_path' } };
   }
   const uri = localURIResult.localURI;
   if (!fileSize) {
     return {
       steps,
       result: { success: false, reason: 'file_stat_failed', uri },
     };
   }
 
   let finalURI = uri;
   if (newLocalURI && newLocalURI !== uri) {
     console.log(
       'fetchAssetInfo returned localURI ' +
         `${newLocalURI} when we already had ${uri}`,
     );
     finalURI = newLocalURI;
   }
 
   return {
     steps,
     result: {
       success: true,
       uri: finalURI,
       orientation,
       fileSize,
       mime: types.mime,
       mediaType: types.mediaType,
     },
   };
 }
 
 async function fetchAssetInfo(
   mediaNativeID: string,
 ): Promise<{|
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: {| localURI: ?string, orientation: ?number |},
 |}> {
   let localURI,
     orientation,
     success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     const assetInfo = await MediaLibrary.getAssetInfoAsync(mediaNativeID);
     success = true;
     localURI = assetInfo.localUri;
     if (Platform.OS === 'ios') {
       orientation = assetInfo.orientation;
     } else {
       orientation = assetInfo.exif && assetInfo.exif.Orientation;
     }
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     steps: [
       {
         step: 'asset_info_fetch',
         success,
         exceptionMessage,
         time: Date.now() - start,
         localURI,
         orientation,
       },
     ],
     result: {
       localURI,
       orientation,
     },
   };
 }
 
 async function fetchFileSize(
   uri: string,
 ): Promise<{|
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: ?number,
 |}> {
   let fileSize,
     success = false,
     exceptionMessage;
   const statStart = Date.now();
   try {
     const result = await filesystem.stat(uri);
     success = true;
     fileSize = result.size;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     steps: [
       {
         step: 'stat_file',
         success,
         exceptionMessage,
         time: Date.now() - statStart,
         uri,
         fileSize,
       },
     ],
     result: fileSize,
   };
 }
 
 async function readFileHeader(
   localURI: string,
   fileSize: number,
 ): Promise<ReadFileHeaderMediaMissionStep> {
   const fetchBytes = Math.min(fileSize, bytesNeededForFileTypeCheck);
 
   const start = Date.now();
   let fileData,
     success = false,
     exceptionMessage;
   try {
     fileData = await filesystem.read(localURI, fetchBytes, 0, 'base64');
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
 
   let mime, mediaType;
   if (fileData) {
     const utf8 = base64.decode(fileData);
     const intArray = stringToIntArray(utf8);
     ({ mime, mediaType } = fileInfoFromData(intArray));
   }
 
   return {
     step: 'read_file_header',
     success,
     exceptionMessage,
     time: Date.now() - start,
     uri: localURI,
     mime,
     mediaType,
   };
 }
 
 async function getMediaTypeInfo(
   path: string,
   mime: string,
   baseMediaType: MediaType,
 ): Promise<{|
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: ?MediaType,
 |}> {
   if (!mediaConfig[mime] || mediaConfig[mime].mediaType !== 'photo_or_video') {
     return { steps: [], result: baseMediaType };
   }
 
   let hasMultipleFrames,
     success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     hasMultipleFrames = await ffmpeg.hasMultipleFrames(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   const steps = [
     {
       step: 'frame_count',
       success,
       exceptionMessage,
       time: Date.now() - start,
       path,
       mime,
       hasMultipleFrames,
     },
   ];
   const result = hasMultipleFrames ? 'video' : 'photo';
   return { steps, result };
 }
 
 async function disposeTempFile(
   path: string,
 ): Promise<DisposeTemporaryFileMediaMissionStep> {
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.unlink(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'dispose_temporary_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
   };
 }
 
 async function mkdir(path: string): Promise<MakeDirectoryMediaMissionStep> {
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.mkdir(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'make_directory',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
   };
 }
 
 async function androidScanFile(
   path: string,
 ): Promise<AndroidScanFileMediaMissionStep> {
   invariant(Platform.OS === 'android', 'androidScanFile only works on Android');
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.scanFile(path);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'android_scan_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
   };
 }
 
 async function fetchFileHash(
   path: string,
 ): Promise<FetchFileHashMediaMissionStep> {
   let hash, exceptionMessage;
   const start = Date.now();
   try {
     hash = await filesystem.hash(path, 'md5');
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'fetch_file_hash',
     success: !!hash,
     exceptionMessage,
     time: Date.now() - start,
     path,
     hash,
   };
 }
 
 async function copyFile(
   source: string,
   destination: string,
 ): Promise<CopyFileMediaMissionStep> {
   let success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     await filesystem.copyFile(source, destination);
     success = true;
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'copy_file',
     success,
     exceptionMessage,
     time: Date.now() - start,
     source,
     destination,
   };
 }
 
+const temporaryDirectoryPath: string = Platform.select({
+  ios: filesystem.TemporaryDirectoryPath,
+  default: `${filesystem.TemporaryDirectoryPath}/`,
+});
+
 export {
   fetchAssetInfo,
   fetchFileInfo,
+  temporaryDirectoryPath,
   disposeTempFile,
   mkdir,
   androidScanFile,
   fetchFileHash,
   copyFile,
 };
diff --git a/native/media/save-media.js b/native/media/save-media.js
index 6414411b1..be3971aa5 100644
--- a/native/media/save-media.js
+++ b/native/media/save-media.js
@@ -1,449 +1,447 @@
 // @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 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 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,
-          `${filesystem.TemporaryDirectoryPath}/`,
-        );
+        } = 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, filesystem.TemporaryDirectoryPath);
+    } = 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 };
diff --git a/native/media/video-utils.js b/native/media/video-utils.js
index 65ebe6445..d9f545c64 100644
--- a/native/media/video-utils.js
+++ b/native/media/video-utils.js
@@ -1,224 +1,222 @@
 // @flow
 
 import invariant from 'invariant';
 import { Platform } from 'react-native';
 import filesystem from 'react-native-fs';
 
 import { mediaConfig, pathFromURI } from 'lib/media/file-utils';
 import { getVideoProcessingPlan } from 'lib/media/video-utils';
 import type {
   MediaMissionStep,
   MediaMissionFailure,
   VideoProbeMediaMissionStep,
   Dimensions,
 } from 'lib/types/media-types';
 import { getMessageForException } from 'lib/utils/errors';
 
 import { ffmpeg } from './ffmpeg';
+import { temporaryDirectoryPath } from './file-utils';
 
 // These are some numbers I sorta kinda made up
 // We should try to calculate them on a per-device basis
 const uploadSpeeds = Object.freeze({
   wifi: 4096, // in KiB/s
   cellular: 512, // in KiB/s
 });
 const clientTranscodeSpeed = 1.15; // in seconds of video transcoded per second
 
 type ProcessVideoInfo = {|
   +uri: string,
   +mime: string,
   +filename: string,
   +fileSize: number,
   +dimensions: Dimensions,
   +hasWiFi: boolean,
 |};
 
 type VideoProcessConfig = {|
   +onTranscodingProgress: (percent: number) => void,
 |};
 
 type ProcessVideoResponse = {|
   +success: true,
   +uri: string,
   +mime: string,
   +dimensions: Dimensions,
   +loop: boolean,
 |};
 async function processVideo(
   input: ProcessVideoInfo,
   config: VideoProcessConfig,
 ): Promise<{|
   steps: $ReadOnlyArray<MediaMissionStep>,
   result: MediaMissionFailure | ProcessVideoResponse,
 |}> {
   const steps = [];
 
   const path = pathFromURI(input.uri);
   invariant(path, `could not extract path from ${input.uri}`);
 
   const initialCheckStep = await checkVideoInfo(path);
   steps.push(initialCheckStep);
   if (!initialCheckStep.success || !initialCheckStep.duration) {
     return { steps, result: { success: false, reason: 'video_probe_failed' } };
   }
   const { validFormat, duration } = initialCheckStep;
 
   const plan = getVideoProcessingPlan({
     inputPath: path,
     inputHasCorrectContainerAndCodec: validFormat,
     inputFileSize: input.fileSize,
     inputFilename: input.filename,
     inputDuration: duration,
     inputDimensions: input.dimensions,
-    outputDirectory: Platform.select({
-      ios: filesystem.TemporaryDirectoryPath,
-      default: `${filesystem.TemporaryDirectoryPath}/`,
-    }),
+    outputDirectory: temporaryDirectoryPath,
     // We want ffmpeg to use hardware-accelerated encoders. On iOS we can do
     // this using VideoToolbox, but ffmpeg on Android is still missing
     // MediaCodec encoding support: https://trac.ffmpeg.org/ticket/6407
     outputCodec: Platform.select({
       ios: 'h264_videotoolbox',
       //android: 'h264_mediacodec',
       default: 'h264',
     }),
     clientConnectionInfo: {
       hasWiFi: input.hasWiFi,
       speed: input.hasWiFi ? uploadSpeeds.wifi : uploadSpeeds.cellular,
     },
     clientTranscodeSpeed,
   });
   if (plan.action === 'reject') {
     return { steps, result: plan.failure };
   }
   if (plan.action === 'none') {
     return {
       steps,
       result: {
         success: true,
         uri: input.uri,
         mime: 'video/mp4',
         dimensions: input.dimensions,
         loop: false,
       },
     };
   }
   const { outputPath, ffmpegCommand } = plan;
 
   let returnCode,
     newPath,
     stats,
     success = false,
     exceptionMessage;
   const start = Date.now();
   try {
     const { rc, lastStats } = await ffmpeg.transcodeVideo(
       ffmpegCommand,
       duration,
       config.onTranscodingProgress,
     );
     success = rc === 0;
     if (success) {
       returnCode = rc;
       newPath = outputPath;
       stats = lastStats;
     }
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   if (!success) {
     unlink(outputPath);
   }
 
   steps.push({
     step: 'video_ffmpeg_transcode',
     success,
     exceptionMessage,
     time: Date.now() - start,
     returnCode,
     newPath,
     stats,
   });
 
   if (!success) {
     return {
       steps,
       result: { success: false, reason: 'video_transcode_failed' },
     };
   }
 
   const transcodeProbeStep = await checkVideoInfo(outputPath);
   steps.push(transcodeProbeStep);
   if (!transcodeProbeStep.validFormat) {
     unlink(outputPath);
     return {
       steps,
       result: { success: false, reason: 'video_transcode_failed' },
     };
   }
 
   const dimensions = transcodeProbeStep.dimensions
     ? transcodeProbeStep.dimensions
     : input.dimensions;
   const loop = !!(
     mediaConfig[input.mime] &&
     mediaConfig[input.mime].videoConfig &&
     mediaConfig[input.mime].videoConfig.loop
   );
   return {
     steps,
     result: {
       success: true,
       uri: `file://${outputPath}`,
       mime: 'video/mp4',
       dimensions,
       loop,
     },
   };
 }
 
 async function checkVideoInfo(
   path: string,
 ): Promise<VideoProbeMediaMissionStep> {
   let codec,
     format,
     dimensions,
     duration,
     success = false,
     validFormat = false,
     exceptionMessage;
   const start = Date.now();
   try {
     ({ codec, format, dimensions, duration } = await ffmpeg.getVideoInfo(path));
     success = true;
     validFormat = codec === 'h264' && format.includes('mp4');
   } catch (e) {
     exceptionMessage = getMessageForException(e);
   }
   return {
     step: 'video_probe',
     success,
     exceptionMessage,
     time: Date.now() - start,
     path,
     validFormat,
     duration,
     codec,
     format,
     dimensions,
   };
 }
 
 async function unlink(path: string) {
   try {
     await filesystem.unlink(path);
   } catch {}
 }
 
 function formatDuration(seconds: number) {
   const mm = Math.floor(seconds / 60);
   const ss = (seconds % 60).toFixed(0).padStart(2, '0');
   return `${mm}:${ss}`;
 }
 
 export { processVideo, formatDuration };