GitLocker: The Coding Marketplace

Description:

tus client dart

A tus client #

A tus client in pure dart. Resumable uploads using tus protocol
Forked from tus_client

tus is a protocol based on HTTP for resumable file uploads. Resumable
means that an upload can be interrupted at any moment and can be resumed without
re-uploading the previous data again. An interruption may happen willingly, if
the user wants to pause, or by accident in case of a network issue or server
outage.

A tus client

Usage

Using Persistent URL Store
Adding Extra Headers
Adding extra data
Changing chunk size
Pausing upload

Example
Maintainers

Usage #
import 'package:cross_file/cross_file.dart' show XFile;

// File to be uploaded
final file = XFile("/path/to/my/pic.jpg");

// Create a client
final client = TusClient(
Uri.parse("https://master.tus.io/files/"),
file,
store: TusMemoryStore(),
);

// Starts the upload
await client.upload(
onStart:(TusClient client, Duration? estimate){
// If estimate is not null, it will provide the estimate time for completion
// it will only be not null if measuring upload speed
print('This is the client to be used $client and $estimate time');
},
onComplete: () {
print("Complete!");

// Prints the uploaded file URL
print(client.uploadUrl.toString());
},
onProgress: (double progress, Duration estimate, TusClient client) {
print("Progress: $progress, Estimated time: ${estimate.inSeconds}");
},

// Set this to true if you want to measure upload speed at the start of the upload
measureUploadSpeed: true,
);
copied to clipboard
Using Persistent URL Store #
This is only supported on Flutter Android, iOS, desktop and web.
You need to add to your pubspec.yaml:
import 'package:path_provider/path_provider.dart';

//creates temporal directory to store the upload progress
final tempDir = await getTemporaryDirectory();
final tempDirectory = Directory('${tempDir.path}/${gameId}_uploads');
if (!tempDirectory.existsSync()) {
tempDirectory.createSync(recursive: true);
}

// Create a client
final client = TusClient(
Uri.parse("https://example.com/tus"),
file,
store: TusFileStore(tempDirectory),
);

// Start upload
// Don't forget to delete the tempDirectory
await client.upload();
copied to clipboard
Adding Extra Headers #
final client = TusClient(
Uri.parse("https://master.tus.io/files/"),
file,
headers: {"Authorization": "..."},
);
copied to clipboard
Adding extra data #
final client = TusClient(
Uri.parse("https://master.tus.io/files/"),
file,
metadata: {"for-gallery": "..."},
);
copied to clipboard
Changing chunk size #
The file is uploaded in chunks. Default size is 512KB. This should be set considering speed of upload vs device memory constraints
final client = TusClient(
Uri.parse("https://master.tus.io/files/"),
file,
maxChunkSize: 10 * 1024 * 1024, // chunk is 10MB
);
copied to clipboard
Pausing upload #
Pausing upload can be done after current uploading in chunk is completed.
final client = TusClient(
Uri.parse("https://master.tus.io/files/"),
file
);

// Pause after 5 seconds
Future.delayed(Duration(seconds: 5)).then((_) =>client.pause());

// Starts the upload
await client.upload(
onComplete: () {
print("Complete!");
},
onProgress: (double progress, Duration estimate, TusClient client) {
print("Progress: $progress, Estimated time: ${estimate.inSeconds}");
},
);
copied to clipboard
Set up the retry mechanism #
It is posible to set up how many times the upload can fail before throw an error to increase robustness of the upload.
Just indicate how many retries to set up the number of attempts before fail, the retryInterval (in seconds) to indicate the time between every retry
and the retryScale (constant by default) to indicate how this time should increase or not between every retry.
final client = TusClient(
Uri.parse("https://master.tus.io/files/"),
file
retries: 5,
retryInterval: 2,
retryScale: RetryScale.exponential,
);
copied to clipboard
Example #
For an example of usage in a Flutter app (using file picker) see: /example
Maintainers #

Nazareno Cavazzon
Jorge Rincon
Tomás Sasovsky