Expo FileSystem

Copies a directory.

Copies a directory synchronously.

Creates a directory that the current uri points to.

Deletes a directory. Also deletes all files and directories inside the directory.

Retrieves an object containing properties of a directory.

Lists the contents of a directory. Calling this method if the parent directory does not exist will throw an error.

Moves a directory. Updates the uri property that now points to the new location.

Moves a directory synchronously. Updates the uri property that now points to the new location.

Renames a directory.

Watches this directory for changes to its contents or the directory itself.

Events are emitted when files or subdirectories are created, modified, deleted, or renamed within this directory. On iOS, child changes are surfaced as a coarse-grained modified event on the directory itself, so filtering for child-level created, deleted, or renamed events is not reliable. The watcher automatically stops when the directory is deleted or renamed. To stop watching manually, call remove() on the returned subscription.

const cacheDir = new Directory(Paths.cache);
const subscription = cacheDir.watch((event) => {
  console.log(`${event.type}: ${event.target.uri}`);
});

// Later, stop watching:
subscription.remove();

Adds a listener for download progress events.

Note: Prefer the onProgress option unless you need manual subscription control.

Cancels the download operation.

If downloadAsync() or resumeAsync() is pending, its promise is rejected after the native request is cancelled. Calling this method after the task reaches completed, cancelled, or error has no effect.

Starts the download operation.

This method can only be called once, while the task is idle. The promise resolves with the downloaded file when the transfer completes, or with null if the task is paused before completion. It is rejected when the request fails or the task is cancelled.

If options.signal is aborted, the promise is rejected with an AbortError.

Creates a paused download task from saved state.

Use this to continue a download after persisting the value returned by savable(). New options can attach progress callbacks or an abort signal because functions and signals are not stored in DownloadPauseState. If both saved state and new options include headers, the new headers override saved headers with the same names.

Requests pausing the active download operation.

The pending downloadAsync() or resumeAsync() promise resolves with null after native code produces resume data and the task enters the paused state. Use pauseAsync() if you need to wait until the task is ready to resume or save.

Requests pausing the active download operation and waits until the task reaches the paused state.

Releases the native task handle.

Call this when you no longer need the task and want to release native resources manually.

Resumes a paused download operation.

The promise resolves with the downloaded file when the transfer completes, or with null if the task is paused again before completion. It is rejected when the request fails or the task is cancelled.

Returns the paused task state that can be persisted and restored later.

This method can only be called while the task is paused. The returned state contains platform-specific resume data and request metadata, but does not include callbacks or abort signals.

The arrayBuffer() method of the Blob interface returns a Promise that resolves with the contents of the blob as binary data contained in an ArrayBuffer.

MDN Reference

Retrieves content of the file as base64.

Retrieves content of the file as base64.

Retrieves byte content of the entire file.

Retrieves byte content of the entire file.

Copies a file.

Copies a file synchronously.

Creates a file.

Creates a download task without starting it.

Call downloadAsync() on the returned task to start the download. Use this when you need pause/resume support, task state, cancellation, or manual progress subscriptions.

const destination = new File(Paths.document, 'video.mp4');
const task = File.createDownloadTask('https://example.com/video.mp4', destination, {
  onProgress: ({ bytesWritten, totalBytes }) => {
    console.log(`${bytesWritten} / ${totalBytes}`);
  },
});

const file = await task.downloadAsync();

Creates an upload task for this file without starting it.

Call uploadAsync() on the returned task to start the upload. Use this when you need to inspect task state, cancel the upload, or subscribe to progress manually.

const file = new File(Paths.document, 'photo.jpg');
const task = file.createUploadTask('https://example.com/upload', {
  uploadType: UploadType.MULTIPART,
  onProgress: ({ bytesSent, totalBytes }) => {
    console.log(`${bytesSent} / ${totalBytes}`);
  },
});

const result = await task.uploadAsync();

Deletes a file.

Retrieves an object containing properties of a file

Moves a directory. Updates the uri property that now points to the new location.

Moves a file synchronously. Updates the uri property that now points to the new location.

Returns A FileHandle object that can be used to read and write data to the file.

Opens the system file picker for selecting a single file.

This overload requires options.multipleFiles to be undefined or false.

Opens the system file picker for selecting multiple files.

This overload requires options.multipleFiles to be true.

const result = await File.pickFileAsync({
  multipleFiles: true,
  mimeTypes: ['image/*', 'application/pdf'],
});

if (!result.canceled) {
  for (const file of result.result) {
    console.log(file.uri);
  }
}

A static method that opens a file picker to select a single file of specified type. On iOS, it returns a temporary copy of the file leaving the original file untouched.

Selecting multiple files is not supported yet.

Renames a file.

The slice() method of the Blob interface creates and returns a new Blob object which contains data from a subset of the blob on which it's called.

MDN Reference

The stream() method of the Blob interface returns a ReadableStream which upon reading returns the data contained within the Blob.

MDN Reference

Retrieves text from the file.

Retrieves text from the file.

Uploads this file to a server and starts the request immediately.

The promise resolves with the HTTP response metadata and body for any completed response, including non-2xx status codes. It is rejected only when the file cannot be read, the request fails, or the upload is cancelled.

Watches this file for changes on the filesystem.

The watcher automatically stops when the file is deleted or renamed. To stop watching manually, call remove() on the returned subscription.

const file = new File(Paths.cache, 'data.json');
const subscription = file.watch((event) => {
  console.log(`File ${event.type}`);
});

// Later, stop watching:
subscription.remove();

Writes content to the file.

Returns the base name of a path.

Returns the directory name of a path.

Returns the extension of a path.

Returns an object that indicates if the specified path represents a directory.

Checks if a path is absolute.

Joins path segments into a single path.

Normalizes a path.

Parses a path into its components.

Resolves a relative path to an absolute path.

Adds a listener for upload progress events.

Note: Prefer the onProgress option unless you need manual subscription control.

Cancels the upload operation.

If uploadAsync() is pending, its promise is rejected after the native request is cancelled. Calling this method after the task reaches completed, cancelled, or error has no effect.

Releases the native task handle.

Call this when you no longer need the task and want to release native resources manually.

Starts the upload operation.

This method can only be called once, while the task is idle. The promise resolves with response metadata and body for completed HTTP responses, including non-2xx status codes. It is rejected when the file cannot be read, the request fails, or the task is cancelled.

If options.signal is aborted, the promise is rejected with an AbortError.

Closes the file handle. This allows the file to be deleted, moved or read by a different process. Subsequent calls to readBytes or writeBytes will throw an error.

Reads the specified amount of bytes from the file at the current offset. Max amount of bytes read at once is capped by ArrayBuffer max size (32 bit signed MAX_INT on Android and 64 bit on iOS), but you can read from a FileHandle multiple times.

Writes the specified bytes to the file at the current offset.