How to fix storage/retry-limit-exceeded in Firebase

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

const storage = getStorage();
// Increase max retry times to 20 minutes (1200000ms)
storage.maxUploadRetryTime = 1200000;      // 20 minutes
storage.maxDownloadRetryTime = 1200000;    // 20 minutes
storage.maxOperationRetryTime = 1200000;   // 20 minutes for other operations

import com.google.firebase.storage.FirebaseStorage;

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

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

// Set timeout on storage instance
const storageRef = storage().ref('path/to/file');
storageRef.setMaxUploadRetryTime(1200000); // 20 minutes
storageRef.setMaxDownloadRetryTime(1200000);

import 'package:firebase_storage/firebase_storage.dart';

FirebaseStorage storage = FirebaseStorage.instance;
// Create upload task with custom timeout
final uploadTask = storage
    .ref('path/to/file')
    .putFile(file);

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

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);

      return new Promise((resolve, reject) => {
        uploadTask.on('state_changed',
          (snapshot) => {
            const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
            console.log(`Upload progress: ${progress}%`);
          },
          (error) => {
            if (error.code === 'storage/retry-limit-exceeded' && attempt < maxRetries) {
              console.log(`Attempt ${attempt} failed with retry-limit-exceeded, retrying...`);
              reject(error);
            } else {
              reject(error);
            }
          },
          () => {
            console.log('Upload successful');
            resolve(uploadTask.snapshot);
          }
        );
      });

    } catch (error) {
      if (error.code === 'storage/retry-limit-exceeded' && attempt < maxRetries) {
        // Calculate exponential backoff: 2^attempt seconds
        const waitMs = Math.pow(2, attempt) * 1000;
        console.log(`Retrying in ${waitMs}ms (attempt ${attempt}/${maxRetries})`);
        await new Promise(resolve => setTimeout(resolve, waitMs));
      } else {
        throw error; // Re-throw if last attempt or different error
      }
    }
  }

  throw new Error(`Upload failed after ${maxRetries} attempts`);
}

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

function uploadLargeFile(file, path) {
  const storage = getStorage();
  const storageRef = ref(storage, path);

  // uploadBytesResumable automatically handles large files
  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`);

      // You can pause the upload if needed
      // uploadTask.pause();
    },
    (error) => {
      if (error.code === 'storage/retry-limit-exceeded') {
        console.error('Upload timeout. Try again or increase maxUploadRetryTime.');
      } else {
        console.error('Upload error:', error);
      }
    },
    () => {
      console.log('Upload completed successfully');
      // Handle successful upload
    }
  );

  return uploadTask;
}

// Usage
const fileInput = document.getElementById('fileInput');
const uploadBtn = document.getElementById('uploadBtn');

uploadBtn.addEventListener('click', () => {
  const file = fileInput.files[0];
  if (file) {
    uploadLargeFile(file, `uploads/${file.name}`);
  }
});

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

let uploadTask = null;

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

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

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}`);
      // Update UI with progress
    },
    (error) => {
      if (error.code === 'storage/retry-limit-exceeded') {
        console.error('Operation timed out. Check network and retry.');
      } else {
        console.error('Upload error:', error);
      }
    },
    () => {
      console.log('Upload complete');
      uploadTask = null;
    }
  );
}

// Define maximum file sizes based on expected connection speed
const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
const RECOMMENDED_FILE_SIZE_WIFI = 500 * 1024 * 1024; // 500MB
const RECOMMENDED_FILE_SIZE_CELLULAR = 20 * 1024 * 1024; // 20MB

// Detect connection type (works in modern browsers)
function getConnectionType() {
  const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
  if (!connection) return 'unknown';
  return connection.effectiveType; // 4g, 3g, 2g, slow-2g
}

function validateBeforeUpload(file) {
  const connectionType = getConnectionType();

  if (file.size > MAX_FILE_SIZE) {
    alert(`File too large (${(file.size / 1024 / 1024).toFixed(2)}MB). Maximum is ${(MAX_FILE_SIZE / 1024 / 1024)}MB.`);
    return false;
  }

  if (connectionType === '2g' || connectionType === 'slow-2g') {
    alert('Connection too slow for large file uploads. Please use WiFi.');
    return false;
  }

  if (connectionType === '3g' && file.size > RECOMMENDED_FILE_SIZE_CELLULAR) {
    alert(`File large for cellular connection. Recommended max: ${(RECOMMENDED_FILE_SIZE_CELLULAR / 1024 / 1024)}MB`);
    return false;
  }

  return true;
}

// Before upload
const fileInput = document.getElementById('fileInput');
const uploadBtn = document.getElementById('uploadBtn');

uploadBtn.addEventListener('click', () => {
  const file = fileInput.files[0];
  if (file && validateBeforeUpload(file)) {
    startUpload(file, `uploads/${file.name}`);
  }
});