file_system_management

A comprehensive Flutter package for managing file transfers with progress tracking, queue management, social media-inspired UI widgets, and injectable handlers. Built on top of background_downloader ^9.4.3.

Features

Feature	Description
Parallel Downloads	Split large files into chunks for faster downloads
Queue Management	Control concurrent transfers with priority queuing
Batch Operations	Download/upload multiple files efficiently
Message Widgets	Ready-to-use widgets for chat applications
Social Media Themes	WhatsApp, Telegram, Instagram-inspired designs
Injectable Handlers	Use your own upload/download providers
Background Downloads	Continue downloads when app is in background
Foreground Mode	Run in foreground on Android for longer tasks
Resume Failed	Continue downloads from failure point
Shared Storage	Move files to Downloads folder
Caching	Automatic file caching with URL recognition
Permissions	Built-in permissions helper
RTL Support	Full right-to-left language support

Platform Support

Android	iOS	Web	macOS	Windows	Linux
✅	✅	❌	✅	✅	✅

Installation
What's New in 1.0.0
Getting Started
Usage Scenarios
API Reference
Example App
Migration Guide

Installation

Add to your pubspec.yaml:

dependencies:
  file_system_management: ^1.0.1

Requirements:

Dart SDK: ^3.5.0
Flutter: >=3.24.0

Then run:

flutter pub get

What's New in 1.0.0

⚠️ Breaking Changes

Minimum Dart SDK upgraded to 3.5.0
Minimum Flutter SDK upgraded to 3.24.0
Updated background_downloader to ^9.4.3

New Features

Feature	Description
Parallel Downloads	`createParallelDownloadTask()` for faster large file downloads
Resume Failed	`resumeFailedDownload()` continues from failure point
Reschedule Tasks	`rescheduleMissingTasks()` recovers tasks after crash
Skip Existing	Skip downloads if file already exists
Foreground Mode	Run in foreground on Android for longer tasks
Request Timeout	Configurable timeout duration
Storage Check	`availableSpace()` before downloading large files
Permissions	`permissions` getter for notifications/storage
Batch Operations	`downloadBatch()` and `uploadBatch()`
Shared Storage	`moveToSharedStorage()` to Downloads folder
Database Access	Full task record management
Task Hold/Release	Control task execution timing
Binary Upload	Raw bytes upload without multipart
Clean Architecture	Restructured codebase with domain, data, infrastructure layers

Clean Architecture

The package now follows Clean Architecture principles:

lib/src/
├── domain/                 # Domain Layer (Business Logic)
│   ├── entities/           # Business entities (TransferEntity, TransferConfigEntity)
│   ├── repositories/       # Abstract repository interfaces
│   ├── usecases/           # Business operations (EnqueueDownload, PauseTransfer, etc.)
│   └── failures/           # Domain-specific error types
│
├── data/                   # Data Layer (Implementation)
│   ├── datasources/        # External data source wrappers (DownloaderDataSource)
│   ├── repositories/       # Repository implementations
│   └── models/             # Data transfer objects (TransferModel)
│
├── infrastructure/         # Infrastructure Layer (Cross-cutting)
│   ├── cache/              # File caching (FileCacheManager)
│   └── storage/            # File storage (AppDirectory)
│
├── presentation/           # Presentation Layer
│   ├── controllers/        # State controllers (TransferController)
│   ├── widgets/            # UI widgets
│   └── theme/              # Theming
│
└── core/                   # Core Utilities
    ├── extensions/         # Dart extensions
    └── utils/              # Utilities

Using Clean Architecture API

// Initialize the clean architecture controller
await TransferController.instance.initialize();

// Download using Result pattern
final result = await TransferController.instance.download(
  url: 'https://example.com/file.pdf',
);

// Handle result functionally
result.fold(
  onSuccess: (stream) => stream.listen((entity) {
    print('Progress: ${entity.progressPercent}%');
    print('Speed: ${entity.speed} bytes/s');
  }),
  onFailure: (failure) => print('Error: ${failure.message}'),
);

Direct Use Case Access

// Create use cases with dependency injection
final repository = TransferRepositoryImpl(...);
final enqueueDownload = EnqueueDownloadUseCase(repository);

// Execute use case
final result = await enqueueDownload(EnqueueDownloadParams(
  url: 'https://example.com/file.pdf',
  config: TransferConfigEntity(
    maxRetries: 3,
    parallelChunks: 4,
  ),
));

Getting Started

1. Initialize the Package

import 'package:file_system_management/file_system_management.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // Initialize directories
  await AppDirectory.init();

  // Initialize with new v1.0.0 options
  await FileSystemController.instance.initialize(
    skipExistingFiles: true,           // Skip if file exists
    skipExistingFilesMinSize: 1024,    // Only skip files > 1KB
    runInForeground: true,             // Android foreground mode
    requestTimeout: Duration(seconds: 30),
  );

  runApp(MyApp());
}

2. Check Permissions

// Check notification permission
final status = await FileSystemController.instance.permissions.status(
  PermissionType.notifications,
);

if (status != PermissionStatus.granted) {
  await FileSystemController.instance.permissions.request(
    PermissionType.notifications,
  );
}

3. Apply Theme (Optional)

MaterialApp(
  theme: ThemeData(
    extensions: [SocialTransferThemeData.whatsapp()],
  ),
)

Usage Scenarios

Scenario 1: Basic File Download

Download a file with progress tracking and caching:

// Create a download task with new options
final task = createDownloadTask(
  url: 'https://example.com/document.pdf',
  directory: 'downloads',
  baseDirectory: BaseDirectory.applicationDocuments,
  priority: 8,               // Higher priority (0-10)
  requiresWiFi: false,       // Allow mobile data
  retries: 3,                // Auto-retry 3 times
  options: createTaskOptions(
    onTaskStart: (task) async {
      print('Starting: ${task.filename}');
      return task;  // Return null to cancel
    },
    onTaskFinished: (task, status) {
      print('Finished: ${task.filename} - $status');
    },
  ),
);

// Enqueue the download
final result = await FileSystemController.instance.enqueueDownload(task);

// Handle the result
switch (result) {
  case EnqueueCached(:final filePath):
    // File already exists in cache
    openFile(filePath);

  case EnqueueStarted(:final controller):
    // Listen to progress
    controller.stream.listen((item) {
      print('Progress: ${item.progressText}');
      print('Speed: ${item.networkSpeedText}');
      print('ETA: ${item.timeRemainingText}');

      if (item.isComplete) {
        openFile(item.filePath);
      }
    });

  case EnqueueInProgress(:final controller):
    // Download already in progress
    controller.stream.listen((item) => print(item.progressText));

  case EnqueuePending(:final controller):
    // Download queued
    print('Download pending...');
}

Scenario 2: Parallel Downloads

Speed up large file downloads by splitting into chunks:

// Create parallel download task (4 chunks by default)
final parallelTask = createParallelDownloadTask(
  url: 'https://example.com/large-file.zip',
  chunks: 8,                    // Split into 8 parallel chunks
  filename: 'large-file.zip',
  directory: 'downloads',
  baseDirectory: BaseDirectory.applicationDocuments,
  priority: 10,                 // Highest priority
);

// Enqueue like a regular download
final result = await FileSystemController.instance.enqueueDownload(parallelTask);

Using Multiple URLs/Mirrors

// Use multiple URLs for different chunks
final parallelTask = createParallelDownloadTask(
  url: 'https://mirror1.example.com/file.zip',
  urls: [
    'https://mirror1.example.com/file.zip',
    'https://mirror2.example.com/file.zip',
    'https://mirror3.example.com/file.zip',
  ],
  chunks: 6,
);

Scenario 3: Batch Operations

Download or upload multiple files efficiently:

// Create multiple download tasks
final tasks = [
  createDownloadTask(url: 'https://example.com/file1.pdf'),
  createDownloadTask(url: 'https://example.com/file2.pdf'),
  createDownloadTask(url: 'https://example.com/file3.pdf'),
  createDownloadTask(url: 'https://example.com/file4.pdf'),
  createDownloadTask(url: 'https://example.com/file5.pdf'),
];

// Download batch with progress tracking
final batch = await FileSystemController.instance.downloadBatch(
  tasks,
  onProgress: (succeeded, failed, total) {
    print('Progress: $succeeded/$total succeeded, $failed failed');
  },
  onTaskComplete: (task, status) {
    print('${task.filename}: $status');
  },
);

print('Batch complete: ${batch.succeeded}/${batch.total} succeeded');

Batch Uploads

final uploadTasks = [
  createUploadTask(url: uploadUrl, filePath: '/path/to/file1.jpg'),
  createUploadTask(url: uploadUrl, filePath: '/path/to/file2.jpg'),
];

final batch = await FileSystemController.instance.uploadBatch(
  uploadTasks,
  onProgress: (succeeded, failed, total) {
    print('Uploaded: $succeeded/$total');
  },
);

Scenario 4: Chat Application with Message Widgets

Build a messaging app with transfer widgets:

// Image message
ImageMessageTransferWidget(
  url: 'https://example.com/photo.jpg',
  fileName: 'photo.jpg',
  fileSize: 2 * 1024 * 1024,
  width: 250,
  height: 180,
  config: TransferWidgetConfig(
    direction: BubbleDirection.incoming,
    autoStart: false,
    allowPauseResume: true,
  ),
  onDownload: (payload) async* {
    yield* myDownloadService.download(payload.url);
  },
  onFullScreen: (path) => Navigator.push(
    context,
    MaterialPageRoute(builder: (_) => ImageViewer(path)),
  ),
)

// Audio message with waveform
AudioMessageTransferWidget(
  url: 'https://example.com/voice.mp3',
  fileName: 'voice_message.mp3',
  duration: Duration(seconds: 30),
  waveform: waveformData,
  config: TransferWidgetConfig(
    direction: BubbleDirection.outgoing,
  ),
  onDownload: (payload) => downloadService.download(payload),
  onPlay: () => audioPlayer.play(),
)

// Video message
VideoMessageTransferWidget(
  url: 'https://example.com/video.mp4',
  fileName: 'funny_video.mp4',
  duration: Duration(minutes: 2, seconds: 30),
  fileSize: 15 * 1024 * 1024,
  config: TransferWidgetConfig(
    direction: BubbleDirection.incoming,
  ),
  onDownload: (payload) => downloadService.download(payload),
  onPlay: (path) => openVideoPlayer(path),
)

// Document message
DocumentMessageTransferWidget(
  url: 'https://example.com/report.pdf',
  fileName: 'Annual_Report.pdf',
  fileSize: 5 * 1024 * 1024,
  pageCount: 25,
  onDownload: (payload) => downloadService.download(payload),
  onOpen: (path) => openPdfViewer(path),
)

Scenario 5: Queue Management

Control concurrent downloads with priority queuing:

// Create a queue manager
final queue = DownloadQueueManager(
  maxConcurrent: 3,      // Only 3 downloads run simultaneously
  autoRetry: true,       // Retry failed downloads
  maxRetries: 2,         // Retry up to 2 times
);

// Add downloads with priority
queue.addUrl(
  'https://example.com/urgent.pdf',
  priority: TransferPriority.urgent,  // Starts immediately
);

queue.addUrl(
  'https://example.com/normal.pdf',
  priority: TransferPriority.normal,  // Queued normally
);

// Monitor queue state
queue.stateStream.listen((state) {
  print('Running: ${state.runningCount}/${state.maxConcurrent}');
  print('Pending: ${state.pendingCount}');
  print('Progress: ${(state.overallProgress * 100).toStringAsFixed(1)}%');
});

// Queue control operations
queue.pause();
queue.start();
queue.cancel('download_id');
queue.cancelAll();
queue.retry('download_id');
queue.moveToFront('download_id');
queue.changePriority('id', TransferPriority.urgent);
queue.maxConcurrent = 5;  // Adjust dynamically

// Wait for all downloads
final results = await queue.waitForAll();

Individual Pause/Resume/Cancel

final provider = RealDownloadProvider(maxConcurrent: 3);

// Start download
provider.enqueueDownload(url: 'https://example.com/file.zip');

// Pause specific download
await provider.pauseDownload('https://example.com/file.zip');

// Check if paused
final isPaused = provider.isDownloadPaused('https://example.com/file.zip');

// Resume download
await provider.resumeDownload('https://example.com/file.zip');

// Cancel download
provider.cancel('https://example.com/file.zip');

Scenario 6: Upload Operations

Standard Upload (Multipart)

final task = createUploadTask(
  url: 'https://api.example.com/upload',
  filePath: '/path/to/file.jpg',
  filename: 'photo.jpg',
  mimeType: 'image/jpeg',
  headers: {'Authorization': 'Bearer token'},
  fields: {'description': 'My photo', 'album': 'vacation'},
  priority: 8,
  retries: 2,
);

await FileSystemController.instance.enqueueUpload(task);

Binary Upload (Raw bytes)

// For APIs expecting raw file content in request body
final task = createBinaryUploadTask(
  url: 'https://api.example.com/upload',
  filePath: '/path/to/file.bin',
  httpRequestMethod: 'PUT',
  mimeType: 'application/octet-stream',
);

await FileSystemController.instance.enqueueUpload(task);

Multi-File Upload

// Upload multiple files in a single request
final task = createMultiUploadTask(
  url: 'https://api.example.com/upload',
  files: [
    ('photo1', '/path/to/image1.jpg'),
    ('photo2', '/path/to/image2.jpg'),
    ('document', '/path/to/file.pdf'),
  ],
  fields: {'album': 'vacation'},
);

await FileSystemController.instance.enqueueUpload(task);

Data Upload (From Memory)

// Upload generated data or small payloads
final task = createDataUploadTask(
  url: 'https://api.example.com/data',
  data: jsonEncode({'name': 'John', 'age': 30}),
  contentType: 'application/json',
  httpRequestMethod: 'POST',
);

await FileSystemController.instance.enqueueUpload(task);

Authenticated Upload

final task = createUploadTask(
  url: 'https://api.example.com/upload',
  filePath: '/path/to/file.jpg',
  options: createAuthenticatedOptions(
    username: 'user',
    password: 'pass',
    onTaskFinished: (task, status) {
      print('Upload finished: $status');
    },
  ),
);

Scenario 7: Database & Task Management

Resume Failed Downloads

final controller = FileSystemController.instance;

// Get failed downloads
final failedRecords = await controller.getRecordsByStatus(TaskStatus.failed);

for (final record in failedRecords) {
  final item = TransferItem.fromRecord(record);

  // Resume from where it stopped (requires server ETag support)
  final success = await controller.resumeFailedDownload(item);
  print('Resume ${item.filename}: $success');
}

Reschedule Missing Tasks (After Crash)

// Recover tasks after app restart/crash
final (succeeded, failed) = await FileSystemController.instance.rescheduleMissingTasks();

print('Rescheduled ${succeeded.length} tasks');
print('Failed to reschedule ${failed.length} tasks');

Database Operations

final controller = FileSystemController.instance;

// Get all records
final allRecords = await controller.getAllRecords();

// Get record by ID
final record = await controller.getRecordById('task-id');

// Get records by status
final completedRecords = await controller.getRecordsByStatus(TaskStatus.complete);
final runningRecords = await controller.getRecordsByStatus(TaskStatus.running);

// Delete specific record
await controller.deleteRecord('task-id');

// Delete all records
await controller.deleteAllRecords();

// Delete by status
await controller.deleteRecordsByStatus(TaskStatus.failed);

Task Hold/Release

final controller = FileSystemController.instance;

// Create task but don't start yet
final task = createDownloadTask(url: 'https://example.com/file.zip');

// Hold the task (prevents execution)
await controller.holdTask(task);

// Enqueue (won't start because it's held)
await controller.enqueueDownload(task);

// Later, release the task to start
await controller.releaseTask(task);

// Or release all held tasks in a group
await controller.releaseHeldTasks(group: 'my-group');

Task Queries

final controller = FileSystemController.instance;

// Get all tracked tasks
final allTasks = await controller.getAllTasks();

// Get tasks in a specific group
final groupTasks = await controller.getTasksByGroup('downloads');

// Get task by ID
final task = await controller.getTaskById('task-id');

// Reset (cancel all and clear database)
await controller.reset();

Scenario 8: Shared Storage

Move completed downloads to public Downloads folder:

final controller = FileSystemController.instance;

// After download completes
final result = await controller.enqueueDownload(task);

if (result case EnqueueStarted(:final controller)) {
  controller.stream.listen((item) async {
    if (item.isComplete) {
      // Move to Downloads folder
      final sharedPath = await FileSystemController.instance.moveToSharedStorage(
        item,
        destination: SharedStorage.downloads,
        directory: 'MyApp',  // Creates MyApp folder in Downloads
        mimeType: 'application/pdf',
      );

      print('File moved to: $sharedPath');
    }
  });
}

// Check if file is in shared storage
final isShared = await controller.isInSharedStorage(filePath);

// Open file from path
await controller.openFileByPath(filePath, mimeType: 'application/pdf');

Check Available Space

// Check space before downloading large file
final availableBytes = await FileSystemController.instance.availableSpace(
  baseDirectory: BaseDirectory.applicationDocuments,
);

final requiredBytes = 500 * 1024 * 1024;  // 500 MB

if (availableBytes != null && availableBytes > requiredBytes) {
  // Safe to download
  await controller.enqueueDownload(largeFileTask);
} else {
  // Warn user about insufficient space
  showInsufficientSpaceDialog();
}

Scenario 9: Permissions Handling

final permissions = FileSystemController.instance.permissions;

// Check notification permission
final notifStatus = await permissions.status(PermissionType.notifications);

if (notifStatus != PermissionStatus.granted) {
  final result = await permissions.request(PermissionType.notifications);
  print('Notification permission: $result');
}

// Check storage permission (Android)
final storageStatus = await permissions.status(PermissionType.storage);

if (storageStatus == PermissionStatus.denied) {
  await permissions.request(PermissionType.storage);
}

Apply pre-built or custom themes:

// WhatsApp theme
MaterialApp(
  theme: ThemeData(
    extensions: [SocialTransferThemeData.whatsapp()],
  ),
  darkTheme: ThemeData(
    brightness: Brightness.dark,
    extensions: [SocialTransferThemeData.whatsapp(isDark: true)],
  ),
)

// Telegram theme
MaterialApp(
  theme: ThemeData(
    extensions: [SocialTransferThemeData.telegram()],
  ),
)

// Instagram theme
MaterialApp(
  theme: ThemeData(
    extensions: [SocialTransferThemeData.instagram()],
  ),
)

// Custom theme
MaterialApp(
  theme: ThemeData(
    extensions: [
      SocialTransferThemeData(
        primaryColor: Colors.purple,
        bubbleColor: Colors.purple.shade50,
        progressForegroundColor: Colors.purple,
        successColor: Colors.green,
        errorColor: Colors.red,
        bubbleBorderRadius: BorderRadius.circular(20),
        actionButtonSize: 52,
        showSpeed: true,
        showEta: true,
      ),
    ],
  ),
)

API Reference

FileSystemController

Main controller for file operations.

Initialization

Method	Description
`initialize()`	Initialize the controller with options
`dispose()`	Cleanup resources

Initialize Options:

Parameter	Type	Default	Description
`skipExistingFiles`	`bool`	`false`	Skip if file exists
`skipExistingFilesMinSize`	`int?`	`null`	Min size for skipping
`runInForeground`	`bool`	`false`	Android foreground mode
`requestTimeout`	`Duration?`	`null`	Request timeout

Download Operations

Method	Description
`enqueueDownload(task)`	Enqueue a download task
`pause(item)`	Pause a download
`resume(item)`	Resume a download
`cancel(item)`	Cancel a download
`retry(item)`	Retry a failed download
`resumeFailedDownload(item)`	Resume from failure point
`openFile(item)`	Open completed file

Batch Operations

Method	Description
`downloadBatch(tasks)`	Download multiple files
`uploadBatch(tasks)`	Upload multiple files
`pauseAll(items)`	Pause multiple transfers
`resumeAll(items)`	Resume multiple transfers
`cancelAll(items)`	Cancel multiple transfers

Shared Storage

Method	Description
`moveToSharedStorage(item)`	Move to Downloads folder
`isInSharedStorage(path)`	Check if in shared storage
`openFileByPath(path)`	Open file by path
`availableSpace()`	Check available storage

Database Operations

Method	Description
`getAllRecords()`	Get all task records
`getRecordById(id)`	Get record by ID
`getRecordsByStatus(status)`	Get records by status
`deleteRecord(id)`	Delete a record
`deleteAllRecords()`	Delete all records
`deleteRecordsByStatus(status)`	Delete by status

Task Management

Method	Description
`holdTask(task)`	Hold task from executing
`releaseTask(task)`	Release held task
`releaseHeldTasks()`	Release all held tasks
`getAllTasks()`	Get all tracked tasks
`getTasksByGroup(group)`	Get tasks by group
`getTaskById(id)`	Get task by ID
`rescheduleMissingTasks()`	Recover tasks after crash
`reset()`	Cancel all and clear database

Properties

Property	Type	Description
`permissions`	`Permissions`	Permissions helper
`isInitialized`	`bool`	Initialization state
`activeTransfers`	`Map<String, TransferItem>`	Active transfers
`completedPaths`	`Map<String, String>`	Cached file paths

Task Factory Functions

Function	Description
`createDownloadTask()`	Create standard download task
`createParallelDownloadTask()`	Create parallel download task
`createUploadTask()`	Create multipart upload task
`createBinaryUploadTask()`	Create binary upload task
`createMultiUploadTask()`	Create multi-file upload task
`createDataUploadTask()`	Create data upload task
`createTaskOptions()`	Create task lifecycle options
`createAuthenticatedOptions()`	Create authenticated options

createDownloadTask Options

Parameter	Type	Default	Description
`url`	`String`	required	Download URL
`filename`	`String?`	URL hash	File name
`directory`	`String`	`""`	Subdirectory
`baseDirectory`	`BaseDirectory`	`temporary`	Base directory
`allowPause`	`bool`	`true`	Allow pausing
`updates`	`Updates`	`statusAndProgress`	Update type
`group`	`String?`	default	Task group
`headers`	`Map<String, String>?`	`null`	HTTP headers
`metaData`	`String?`	`null`	Custom metadata
`priority`	`int`	`5`	Priority (0-10)
`requiresWiFi`	`bool`	`false`	Require WiFi
`retries`	`int`	`0`	Auto-retry count
`options`	`TaskOptions?`	`null`	Task options

createParallelDownloadTask Options

Parameter	Type	Default	Description
`url`	`String`	required	Primary URL
`urls`	`List<String>?`	`null`	Mirror URLs
`chunks`	`int`	`4`	Parallel chunks
Plus all standard download options

Queue Classes

Class	Description
`TransferQueueManager<T>`	Generic queue manager
`DownloadQueueManager`	Specialized download queue
`UploadQueueManager`	Specialized upload queue
`QueuedTransferProvider`	Widget integration provider
`RealDownloadProvider`	Production download provider

Message Widgets

Widget	Use Case
`AudioMessageTransferWidget`	Voice messages, audio files
`ImageMessageTransferWidget`	Photos, images
`VideoMessageTransferWidget`	Videos
`FileMessageTransferWidget`	Generic files (ZIP, APK, etc.)
`DocumentMessageTransferWidget`	PDF, DOCX, XLSX, PPTX

Transfer Types

Class	Description
`TransferProgress`	Progress information (bytes, speed, ETA)
`TransferResult`	Sealed: `TransferSuccess`, `TransferFailure`, `TransferCancelled`
`TransferStatus`	Enum: `pending`, `running`, `paused`, `completed`, `failed`, `cancelled`
`TransferPriority`	Enum: `urgent`, `high`, `normal`, `low`
`TransferItem`	Transfer state wrapper

Example App

The package includes a comprehensive example app demonstrating:

Chat Demo: Message widgets with different file types
Queue Demo: Queue management with priority control
Queued Chat Demo: WhatsApp-like interface with real downloads
Video/Audio Playback: Media playback after download
Settings: Theme switching, dark mode, RTL toggle

Run the example:

cd example
flutter run

Migration Guide

From 0.2.x to 1.0.0

Update SDK requirements

environment:
  sdk: ^3.5.0
  flutter: ">=3.24.0"

New initialization options

// Old
await FileSystemController.instance.initialize();

// New (with options)
await FileSystemController.instance.initialize(
  skipExistingFiles: true,
  runInForeground: true,
  requestTimeout: Duration(seconds: 30),
);

New download task options

// Old
final task = createDownloadTask(url: url);

// New (with priority, retries, options)
final task = createDownloadTask(
  url: url,
  priority: 8,
  requiresWiFi: false,
  retries: 3,
  options: createTaskOptions(
    onTaskStart: (task) async => task,
    onTaskFinished: (task, status) {},
  ),
);

Parallel downloads

// New in 1.0.0
final task = createParallelDownloadTask(
  url: url,
  chunks: 8,
);

Batch operations

// New in 1.0.0
await controller.downloadBatch(tasks, onProgress: ...);
await controller.uploadBatch(tasks, onProgress: ...);

From 0.1.x to 0.2.x

TaskItem renamed to TransferItem

// Old
TaskItem item = ...;

// New
TransferItem item = ...;

New message widgets

// Use pre-built widgets
AudioMessageTransferWidget(...)
ImageMessageTransferWidget(...)

Dependencies

Package	Purpose
`background_downloader`	Background download support (^9.4.3)
`cached_network_image`	Network image caching
`path_provider`	System directories
`crypto`	Hash generation

License

MIT License - see LICENSE for details.

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting a pull request.

file_system_management

Features

Platform Support

Table of Contents

Installation

What's New in 1.0.0

⚠️ Breaking Changes

New Features

Clean Architecture

Using Clean Architecture API

Direct Use Case Access

Getting Started

1. Initialize the Package

2. Check Permissions

3. Apply Theme (Optional)

Usage Scenarios

Scenario 1: Basic File Download

Scenario 2: Parallel Downloads

Using Multiple URLs/Mirrors

Scenario 3: Batch Operations

Batch Uploads

Scenario 4: Chat Application with Message Widgets

Scenario 5: Queue Management

Individual Pause/Resume/Cancel

Scenario 6: Upload Operations

Standard Upload (Multipart)

Binary Upload (Raw bytes)

Multi-File Upload

Data Upload (From Memory)

Authenticated Upload

Scenario 7: Database & Task Management

Resume Failed Downloads

Reschedule Missing Tasks (After Crash)

Database Operations

Task Hold/Release

Task Queries

Scenario 8: Shared Storage

Check Available Space

Scenario 9: Permissions Handling

Scenario 10: Social Media Theming

API Reference

FileSystemController

Initialization

Download Operations

Batch Operations

Shared Storage

Database Operations

Task Management

Properties

Task Factory Functions

createDownloadTask Options

createParallelDownloadTask Options

Queue Classes

Message Widgets

Transfer Types

Example App

Migration Guide

From 0.2.x to 1.0.0

From 0.1.x to 0.2.x

Dependencies

License

Contributing

Support

Libraries

file_system_management package