How to fix storage/retry-limit-exceeded: Maximum time limit on operation exceeded in Firebase

import { getStorage } from 'firebase/storage';

const storage = getStorage();
// Set max upload retry time to 20 minutes (1200000ms)
storage.maxUploadRetryTime = 1200000;
// Set max download retry time to 20 minutes
storage.maxOperationRetryTime = 1200000;

FirebaseStorage storage = FirebaseStorage.getInstance();
// Set max upload retry time to 20 minutes
storage.setMaxUploadRetryTimeMillis(1200000);
// Set max operation retry time to 20 minutes
storage.setMaxOperationRetryTimeMillis(1200000);

import storage from '@react-native-firebase/storage';

const reference = storage().ref('path/to/file');
// Set timeout on the specific task
reference.setMaxUploadRetryTime(1200000);

async function uploadWithRetry(file, path, maxRetries = 3) {
  const storage = getStorage();
  const storageRef = ref(storage, path);

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const uploadTask = uploadBytesResumable(storageRef, file);

      // Monitor upload progress
      uploadTask.on('state_changed',
        (snapshot) => {
          const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
          console.log(`Upload is ${progress}% done`);
        }
      );

      await uploadTask;
      console.log('Upload successful');
      return uploadTask.snapshot;

    } catch (error) {
      if (error.code === 'storage/retry-limit-exceeded') {
        console.log(`Retry ${attempt} of ${maxRetries} failed`);

        if (attempt === maxRetries) {
          throw new Error('Upload failed after maximum retries');
        }

        // Exponential backoff: wait longer between each retry
        const waitTime = Math.pow(2, attempt) * 1000;
        await new Promise(resolve => setTimeout(resolve, waitTime));
      } else {
        throw error; // Re-throw non-retry errors
      }
    }
  }
}

import { getStorage, ref, uploadBytesResumable } from 'firebase/storage';

async function uploadLargeFile(file, path) {
  const storage = getStorage();
  const chunkSize = 5 * 1024 * 1024; // 5MB chunks

  if (file.size <= chunkSize) {
    // Small file, upload normally
    const storageRef = ref(storage, path);
    return uploadBytesResumable(storageRef, file);
  }

  // For large files, use resumable upload with pause/resume capability
  const storageRef = ref(storage, path);
  const uploadTask = uploadBytesResumable(storageRef, file);

  uploadTask.on('state_changed',
    (snapshot) => {
      const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
      console.log(`Upload is ${progress}% done`);
    },
    (error) => {
      console.error('Upload error:', error);
    },
    () => {
      console.log('Upload completed successfully');
    }
  );

  return uploadTask;
}

let uploadTask;

// Detect network status changes
window.addEventListener('online', () => {
  if (uploadTask && uploadTask.snapshot.state === 'paused') {
    uploadTask.resume();
    console.log('Network restored, resuming upload');
  }
});

window.addEventListener('offline', () => {
  if (uploadTask && uploadTask.snapshot.state === 'running') {
    uploadTask.pause();
    console.log('Network lost, pausing upload');
  }
});

// Start upload with pause/resume capability
function startUpload(file, path) {
  const storage = getStorage();
  const storageRef = ref(storage, path);
  uploadTask = uploadBytesResumable(storageRef, file);

  uploadTask.on('state_changed',
    (snapshot) => {
      console.log(`Progress: ${snapshot.bytesTransferred}/${snapshot.totalBytes}`);
    },
    (error) => {
      if (error.code === 'storage/retry-limit-exceeded') {
        console.error('Upload timeout exceeded');
      }
    },
    () => {
      console.log('Upload complete');
      uploadTask = null;
    }
  );

  return uploadTask;
}

// Calculate minimum required upload speed
function calculateRequiredSpeed(fileSizeBytes, timeoutMs) {
  const fileSizeMB = fileSizeBytes / (1024 * 1024);
  const timeoutMinutes = timeoutMs / (60 * 1000);
  const requiredMbps = (fileSizeMB * 8) / (timeoutMinutes * 60);

  return {
    fileSizeMB: fileSizeMB.toFixed(2),
    timeoutMinutes: timeoutMinutes.toFixed(1),
    requiredMbps: requiredMbps.toFixed(2)
  };
}

// Example: 100MB file with 10-minute timeout
const requirements = calculateRequiredSpeed(100 * 1024 * 1024, 600000);
console.log(`Need at least ${requirements.requiredMbps} Mbps to upload ${requirements.fileSizeMB}MB in ${requirements.timeoutMinutes} minutes`);

const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB

if (file.size > MAX_FILE_SIZE) {
  alert('File too large. Please upload files smaller than 50MB.');
  return;
}