Dedupe native transfer/notification code and split ServerProvider into focused controllers

Consolidates duplicated GET/PUT/notification-channel logic across
DownloadService/ShareUploadService/SyncEngine into shared Kotlin helpers,
gives upload/download real batch queueing instead of dropping a second
concurrent batch, and dedupes repeated Dart channel-argument boilerplate.

Replaces the 2300+ line ServerProvider god object with ten focused
ChangeNotifiers (SessionController, SettingsController, FilesController,
PhotosController, FavoritesController, TrashController, SharesController,
RecentController, SyncStatusController, PickController) plus ItemOperations,
a plain coordinator for cross-domain item mutations - fixing the coupling
where device-sync status, per-tab data, and global UI prefs all lived in
one object. Updates every view/widget call site accordingly and refreshes
the architecture/server/standards/styling docs to match.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

lib/main.dart

@@ -6,7 +6,17 @@ import 'package:provider/provider.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'models/app_tab.dart';
 import 'models/pick_request.dart';
-import 'providers/server_provider.dart';
+import 'providers/favorites_controller.dart';
+import 'providers/files_controller.dart';
+import 'providers/item_operations.dart';
+import 'providers/photos_controller.dart';
+import 'providers/pick_controller.dart';
+import 'providers/recent_controller.dart';
+import 'providers/session_controller.dart';
+import 'providers/settings_controller.dart';
+import 'providers/shares_controller.dart';
+import 'providers/sync_status_controller.dart';
+import 'providers/trash_controller.dart';
 import 'services/pick_intent_service.dart';
 import 'services/share_intent_service.dart';
 import 'theme/app_theme.dart';
@@ -20,8 +30,51 @@ import 'widgets/floating_bottom_bar.dart';
 void main() {
   WidgetsFlutterBinding.ensureInitialized();
   runApp(
-    ChangeNotifierProvider(
-      create: (_) => ServerProvider(),
+    MultiProvider(
+      // Split out of the former single `ServerProvider` god object - see
+      // `.claude/context/architecture.md`'s "State management" section.
+      // Order matters: each `create` below reads earlier providers via
+      // `context.read`, which is safe here since none of them are ever
+      // replaced/recreated for the app's lifetime (account switching is
+      // internal state on SessionController, not a new provider instance).
+      providers: [
+        ChangeNotifierProvider(create: (_) => SessionController()),
+        ChangeNotifierProvider(create: (_) => SettingsController()),
+        ChangeNotifierProvider(
+          create: (context) => SyncStatusController(context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) => FilesController(context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) =>
+              PhotosController(context.read(), context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) =>
+              FavoritesController(context.read(), context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) => TrashController(context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) => SharesController(context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) => RecentController(context.read()),
+        ),
+        ChangeNotifierProvider(
+          create: (context) => PickController(context.read()),
+        ),
+        Provider(
+          create: (context) => ItemOperations(
+            session: context.read(),
+            files: context.read(),
+            photos: context.read(),
+            favorites: context.read(),
+          ),
+        ),
+      ],
       child: const NextcloudApp(),
     ),
   );
@@ -32,7 +85,8 @@ class NextcloudApp extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final settings = context.watch<SettingsController>();
+    final session = context.watch<SessionController>();
 
     return DynamicColorBuilder(
       builder: (lightDynamic, darkDynamic) {
@@ -40,22 +94,22 @@ class NextcloudApp extends StatelessWidget {
           title: 'Noo',
           debugShowCheckedModeBanner: false,
           theme: AppTheme.light(
-            provider.seedColor,
+            settings.seedColor,
             dynamicScheme: lightDynamic,
-            useDynamicColor: provider.useDynamicColor,
+            useDynamicColor: settings.useDynamicColor,
           ),
           darkTheme: AppTheme.dark(
-            provider.seedColor,
+            settings.seedColor,
             dynamicScheme: darkDynamic,
-            useDynamicColor: provider.useDynamicColor,
-            amoled: provider.amoledDark,
+            useDynamicColor: settings.useDynamicColor,
+            amoled: settings.amoledDark,
           ),
-          themeMode: provider.themeMode,
-          home: provider.isRestoringSession
+          themeMode: settings.themeMode,
+          home: session.isRestoringSession
               ? const _SplashView()
-              : (!provider.isLoggedIn
+              : (!session.isLoggedIn
                     ? const LoginView()
-                    : (provider.needsUnlock
+                    : (session.needsUnlock
                           ? const LockScreenView()
                           : const MainShellView())),
         );
@@ -128,7 +182,7 @@ class _MainShellViewState extends State<MainShellView> {
     // Preferences load asynchronously, but in practice finish well before
     // session restore (which also has to hit the network) does, so by the
     // time this shell mounts `defaultTab` already reflects the saved value.
-    _currentTab = context.read<ServerProvider>().defaultTab;
+    _currentTab = context.read<SettingsController>().defaultTab;
 
     // Handles both a cold start via another app's "Share to..." sheet
     // (getInitialShare) and a share arriving while the app is already
@@ -143,11 +197,11 @@ class _MainShellViewState extends State<MainShellView> {
     // another app may have launched Noo as its GET_CONTENT picker.
     PickIntentService.getPickRequest().then((request) {
       if (request != null && mounted) {
-        context.read<ServerProvider>().setPickRequest(request);
+        context.read<PickController>().setPickRequest(request);
       }
     });
     _pickSub = PickIntentService.onNewPickRequest.listen((request) {
-      if (mounted) context.read<ServerProvider>().setPickRequest(request);
+      if (mounted) context.read<PickController>().setPickRequest(request);
     });
 
     WidgetsBinding.instance.addPostFrameCallback(
@@ -220,20 +274,21 @@ class _MainShellViewState extends State<MainShellView> {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final settings = context.watch<SettingsController>();
+    final pick = context.watch<PickController>();
 
     // A one-shot request (e.g. tapping a search result) to switch tabs -
     // consumed here so it only fires once, then cleared after this frame
     // (clearing it synchronously would call notifyListeners mid-build).
-    final requestedTab = provider.requestedTab;
+    final requestedTab = settings.requestedTab;
     if (requestedTab != null) {
       _currentTab = requestedTab;
       WidgetsBinding.instance.addPostFrameCallback(
-        (_) => provider.consumeRequestedTab(),
+        (_) => settings.consumeRequestedTab(),
       );
     }
 
-    final pickRequest = provider.pickRequest;
+    final pickRequest = pick.pickRequest;
     // While acting as another app's picker, only Files and Photos make
     // sense as browsable sources - Trash/Shares/Activity/Recent aren't
     // real "pick a file from here" destinations, and only these two tabs'
@@ -242,7 +297,7 @@ class _MainShellViewState extends State<MainShellView> {
     // them, since picking is a separate mode from normal browsing.
     final visible = pickRequest != null
         ? [AppTab.files, AppTab.photos]
-        : provider.visibleTabs;
+        : settings.visibleTabs;
     final selectedTab = visible.contains(_currentTab)
         ? _currentTab
         : (visible.isNotEmpty ? visible.first : AppTab.files);
@@ -260,7 +315,7 @@ class _MainShellViewState extends State<MainShellView> {
       // there's no Navigator route to pop at this, the root screen.
       canPop: pickRequest == null,
       onPopInvokedWithResult: (didPop, result) {
-        if (!didPop && pickRequest != null) provider.cancelPick();
+        if (!didPop && pickRequest != null) pick.cancelPick();
       },
       child: Scaffold(
         body: Stack(
@@ -271,7 +326,7 @@ class _MainShellViewState extends State<MainShellView> {
                   .map((tab) => buildAppTabView(tab, _scrollControllers[tab]!))
                   .toList(),
             ),
-            if (provider.isDownloadingForPick) const _PickingProgressOverlay(),
+            if (pick.isDownloadingForPick) const _PickingProgressOverlay(),
             // Each tab now renders its own sticky selection toolbar inline
             // (right under its sort/filter row) instead of this shell
             // swapping in a shared floating bar - the bottom nav stays put
@@ -279,12 +334,12 @@ class _MainShellViewState extends State<MainShellView> {
             FloatingBottomNavBar(
               selectedIndex: selectedIndex,
               items: navItems,
-              opacity: provider.bottomBarOpacity,
-              blurSigma: provider.bottomBarBlur,
+              opacity: settings.bottomBarOpacity,
+              blurSigma: settings.bottomBarBlur,
               onDestinationSelected: (index) {
                 final tappedTab = visible[index];
                 if (tappedTab == _currentTab) {
-                  if (provider.tapTabToScrollTop) {
+                  if (settings.tapTabToScrollTop) {
                     final controller = _scrollControllers[tappedTab];
                     if (controller != null && controller.hasClients) {
                       controller.animateTo(
@@ -315,7 +370,7 @@ class _MainShellViewState extends State<MainShellView> {
 
 /// Blocks interaction while the selected file(s) download to a local cache
 /// folder before being handed back to the caller (see
-/// `ServerProvider.confirmPick`) - can take a moment for a large file/video.
+/// `PickController.confirmPick`) - can take a moment for a large file/video.
 class _PickingProgressOverlay extends StatelessWidget {
   const _PickingProgressOverlay();
 

lib/models/app_tab.dart

@@ -3,7 +3,7 @@ import 'package:material_symbols_icons/symbols.dart';
 
 /// Every destination the bottom nav bar can show. Order here is only the
 /// fallback default — actual order/visibility/default-tab are user
-/// configurable and persisted in [ServerProvider].
+/// configurable and persisted in `SettingsController`.
 enum AppTab { files, photos, favorites, activity, trash, shares, recent }
 
 /// At most this many tabs may be visible in the bottom nav bar at once —

lib/models/move_copy_result.dart

@@ -2,7 +2,7 @@ import 'nextcloud_item.dart';
 
 /// A resolution choice for one conflicting item in a Move/Copy batch -
 /// keyed by `item.id` in [ConflictChoice] maps passed to
-/// `ServerProvider.resolveConflicts`.
+/// `ItemOperations.resolveConflicts`.
 enum ConflictChoice { overwrite, keepBoth, skip }
 
 /// One item that couldn't be moved/copied because something with the same
@@ -14,7 +14,7 @@ class MoveCopyConflict {
 }
 
 /// Outcome of a Move/Copy batch (an initial attempt via
-/// `ServerProvider.moveItems`/`copyItems`, or a follow-up
+/// `ItemOperations.moveItems`/`copyItems`, or a follow-up
 /// `resolveConflicts` call). [blockedReason] is set instead of attempting
 /// anything at all when the destination itself is invalid (e.g. moving a
 /// folder into its own subfolder).

lib/models/sync_status.dart

@@ -34,5 +34,5 @@ enum SyncItemStatus { none, syncing, synced, conflict }
 
 /// The persistent header chip/panel's overall status (account-wide, not
 /// scoped to whatever folder is currently browsed) - see
-/// `ServerProvider.syncHeaderStatus`.
+/// `SyncStatusController.syncHeaderStatus`.
 enum SyncHeaderStatus { off, syncing, done, alert }

lib/providers/favorites_controller.dart

@@ -0,0 +1,110 @@
+import 'package:flutter/material.dart';
+import '../models/nextcloud_item.dart';
+import 'files_controller.dart';
+import 'session_controller.dart';
+
+/// The Favorites tab: every favorited item across the whole account (not
+/// scoped to any one folder - a favorited item several folders deep still
+/// shows up regardless of whether its parent folders are themselves
+/// favorited, which is exactly why this is its own account-wide fetch
+/// rather than a filter toggle over whatever folder Files happens to be
+/// browsing - see `server.md`'s Favorites section for the full history of
+/// why a filter-toggle approach was tried and reverted). Depends on
+/// [FilesController] to reuse its exact
+/// display prefs (hidden/type-filter/sort/storage-scope) via
+/// [FilesController.applyFilesDisplayPrefs] - deliberately shared rather
+/// than a second parallel settings dimension.
+class FavoritesController extends ChangeNotifier {
+  final SessionController session;
+  final FilesController files;
+
+  List<NextcloudItem> _allFavorites = [];
+  bool _isLoading = false;
+  String? _errorMessage;
+  // True once fetchAll has run at least once (i.e. the Favorites tab has
+  // been visited) - delete/rename/move/copy re-sync afterward, but only
+  // when it's actually been loaded, so those actions don't pay for an
+  // extra network round-trip on every Files/Photos edit for an account
+  // that's never opened the Favorites tab this session.
+  bool _everFetched = false;
+
+  FavoritesController(this.session, this.files) {
+    session.addAccountClearedListener(_onAccountCleared);
+  }
+
+  bool get isLoading => _isLoading;
+  String? get errorMessage => _errorMessage;
+
+  /// The Favorites tab's content, run through the exact same hidden/type-
+  /// filter/sort/storage-scope display prefs as the Files tab. No
+  /// favorites filter needed here - the source list is already
+  /// all-favorites.
+  List<NextcloudItem> get items => files.applyFilesDisplayPrefs(_allFavorites);
+
+  void _onAccountCleared() {
+    _allFavorites = [];
+    _isLoading = false;
+    _errorMessage = null;
+    _everFetched = false;
+    notifyListeners();
+  }
+
+  /// Loads every favorited item across the whole account for the Favorites
+  /// tab.
+  Future<void> fetchAll() async {
+    final service = session.service;
+    if (!session.isLoggedIn || service == null) return;
+    final gen = session.sessionGeneration;
+    _everFetched = true;
+
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    try {
+      final favorites = await service.fetchFavorites();
+      if (gen != session.sessionGeneration) return;
+      _allFavorites = favorites;
+      debugPrint('[FavoritesController] Loaded ${_allFavorites.length} favorites');
+    } catch (e) {
+      if (gen != session.sessionGeneration) return;
+      debugPrint('[FavoritesController] Error fetching favorites: $e');
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+    } finally {
+      if (gen == session.sessionGeneration) {
+        _isLoading = false;
+        notifyListeners();
+      }
+    }
+  }
+
+  /// Re-syncs [_allFavorites] after a delete/rename/move/copy elsewhere in
+  /// the app - those operations don't know how to patch this list in place
+  /// (a move changes an item's path; WebDAV COPY's handling of custom
+  /// properties like `oc:favorite` isn't reliable enough to assume the
+  /// copy is still favorited), so this just refetches - but only if
+  /// Favorites has actually been loaded this session. Called by
+  /// `ItemOperations` after delete/rename/move/copy.
+  Future<void> syncIfLoaded() {
+    return _everFetched ? fetchAll() : Future.value();
+  }
+
+  /// Patches a favorite-toggle result into [_allFavorites] in place (added
+  /// if newly favorited, removed if un-favorited, updated otherwise) -
+  /// called by `ItemOperations.toggleItemFavorite` after a successful
+  /// server call. Cheap enough not to need a full refetch, unlike
+  /// [syncIfLoaded].
+  void applyFavoriteToggle(NextcloudItem updated) {
+    final index = _allFavorites.indexWhere((i) => i.id == updated.id);
+    if (updated.isFavorite) {
+      if (index != -1) {
+        _allFavorites[index] = updated;
+      } else {
+        _allFavorites = [..._allFavorites, updated];
+      }
+    } else if (index != -1) {
+      _allFavorites = [..._allFavorites]..removeAt(index);
+    }
+    notifyListeners();
+  }
+}

lib/providers/files_controller.dart

@@ -0,0 +1,557 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/nextcloud_item.dart';
+import 'session_controller.dart';
+
+enum FileSortField { name, dateCreated, dateModified, size }
+
+/// Which storage a listing shows — always exactly one, like the list/grid
+/// view toggle, not an optional filter. Shared across Files/Photos/
+/// Favorites (see [applyCommonFilters]'s doc comment).
+enum StorageScope { cloud, external }
+
+/// The Files tab's files/folders/both filter — independent of and applied
+/// after [StorageScope]/favorites/hidden filtering.
+enum FilesTypeFilter { all, filesOnly, foldersOnly }
+
+/// How aggressively the Files tab's folder listings (not thumbnails/file
+/// content - just the list of names/sizes/dates) are reused across
+/// navigation instead of refetched from the server every time.
+enum CachePolicy {
+  /// Every navigation refetches - today's behavior.
+  never,
+
+  /// A listing is reused until it's older than [FilesController.
+  /// cacheIntervalMinutes]; a timer also proactively refreshes the current
+  /// folder on that same interval while the app is in the foreground.
+  interval,
+
+  /// A listing is reused indefinitely until the user pulls to refresh.
+  manual,
+}
+
+/// One cached folder listing and when it was fetched.
+class _CachedDirectory {
+  final List<NextcloudItem> items;
+  final DateTime fetchedAt;
+
+  const _CachedDirectory(this.items, this.fetchedAt);
+}
+
+/// The Files tab: current folder/browsing state, display prefs (grid/list,
+/// hidden, type filter, storage scope, sort), the directory-listing cache,
+/// and - piggybacked onto the same fetch cycle as the original single
+/// provider did - account quota and the Activity tab's feed (neither is
+/// really "Files" data, but both were always fetched alongside the current
+/// folder's listing, not independently; preserved here as-is rather than
+/// invented a home for them, since untangling that wasn't asked for). Also
+/// the shared [storageScope]/[applyCommonFilters]/[applyFilesDisplayPrefs]
+/// logic Photos/Favorites both reuse - see their own controllers' doc
+/// comments for why they depend on this one.
+///
+/// Split out of the former single `ServerProvider` god object.
+class FilesController extends ChangeNotifier with WidgetsBindingObserver {
+  final SessionController session;
+
+  static const _prefGridView = 'ui_grid_view';
+  static const _prefStorageScope = 'ui_storage_scope';
+  static const _prefFilesTypeFilter = 'ui_files_type_filter';
+  static const _prefShowHiddenFiles = 'ui_show_hidden';
+  static const _prefFolderSort = 'ui_folder_sort';
+  static const _prefCachePolicy = 'ui_cache_policy';
+  static const _prefCacheIntervalMinutes = 'ui_cache_interval_minutes';
+
+  String _currentFolderPath = '/';
+  List<String> _pathStack = ['/'];
+
+  bool _isGridView = false;
+  StorageScope _storageScope = StorageScope.cloud;
+  FilesTypeFilter _filesTypeFilter = FilesTypeFilter.all;
+  bool _showHiddenFiles = false;
+
+  final Map<String, FileSortField> _folderSortField = {};
+  final Map<String, bool> _folderSortAscending = {};
+
+  CachePolicy _cachePolicy = CachePolicy.never;
+  int _cacheIntervalMinutes = 5;
+  final Map<String, _CachedDirectory> _directoryCache = {};
+  Timer? _cacheRefreshTimer;
+
+  List<NextcloudItem> _items = [];
+  NextcloudUserQuota? _quota;
+  List<NextcloudActivity> _activities = [];
+  bool _isLoading = false;
+  String? _errorMessage;
+
+  FilesController(this.session) {
+    WidgetsBinding.instance.addObserver(this);
+    session.addAccountClearedListener(_onAccountCleared);
+    session.addAccountActivatedListener(_onAccountActivated);
+  }
+
+  // Getters
+  String get currentFolderPath => _currentFolderPath;
+  List<String> get pathStack => _pathStack;
+  bool get isGridView => _isGridView;
+  StorageScope get storageScope => _storageScope;
+  FilesTypeFilter get filesTypeFilter => _filesTypeFilter;
+  bool get showHiddenFiles => _showHiddenFiles;
+  FileSortField get filesSortField =>
+      _folderSortField[_currentFolderPath] ?? FileSortField.name;
+  bool get filesSortAscending =>
+      _folderSortAscending[_currentFolderPath] ?? true;
+  CachePolicy get cachePolicy => _cachePolicy;
+  int get cacheIntervalMinutes => _cacheIntervalMinutes;
+  bool get isLoading => _isLoading;
+  String? get errorMessage => _errorMessage;
+  NextcloudUserQuota? get quota => _quota;
+  List<NextcloudActivity> get activities => _activities;
+
+  List<NextcloudItem> get items => applyFilesDisplayPrefs(_items);
+
+  int _compareItems(NextcloudItem a, NextcloudItem b, FileSortField field) {
+    switch (field) {
+      case FileSortField.name:
+        return a.name.toLowerCase().compareTo(b.name.toLowerCase());
+      case FileSortField.dateCreated:
+        return a.dateCreated.compareTo(b.dateCreated);
+      case FileSortField.dateModified:
+        return a.lastModified.compareTo(b.lastModified);
+      case FileSortField.size:
+        return a.size.compareTo(b.size);
+    }
+  }
+
+  /// True if [item] or any ancestor folder in its path is a dotfile/dotfolder.
+  bool _isHiddenItem(NextcloudItem item) {
+    return item.path
+        .split('/')
+        .where((segment) => segment.isNotEmpty)
+        .any((segment) => segment.startsWith('.'));
+  }
+
+  /// Applies the shared favorites-only/hidden-files/storage-scope toggles -
+  /// shared by Files' own [items], Photos' `photoItems` (its own favorites-
+  /// only/hidden toggles, but [storageScope] here), and Favorites'
+  /// `favoriteItems` (via [applyFilesDisplayPrefs]).
+  List<NextcloudItem> applyCommonFilters(
+    List<NextcloudItem> source, {
+    required bool showFavoritesOnly,
+    required bool showHidden,
+  }) {
+    var filtered = source;
+    if (showFavoritesOnly) {
+      filtered = filtered.where((item) => item.isFavorite).toList();
+    }
+    if (!showHidden) {
+      filtered = filtered.where((item) => !_isHiddenItem(item)).toList();
+    }
+    filtered = filtered
+        .where(
+          (item) => _storageScope == StorageScope.external
+              ? item.isExternalStorage
+              : !item.isExternalStorage,
+        )
+        .toList();
+    return filtered;
+  }
+
+  /// Applies the Files tab's current sort/filter display prefs (hidden,
+  /// type filter, storage scope, sort field/direction) to an arbitrary raw
+  /// item list - factored out of the [items] getter so both the Favorites
+  /// tab and the Move/Copy destination picker (which fetches its own
+  /// listings via [fetchFolderListing] rather than reading [items] itself)
+  /// can render with the exact same controls/behavior as the Files tab
+  /// without duplicating this logic.
+  List<NextcloudItem> applyFilesDisplayPrefs(List<NextcloudItem> rawItems) {
+    var filtered = applyCommonFilters(
+      rawItems,
+      // Files itself doesn't filter by favorite - that's the dedicated
+      // Favorites tab's job.
+      showFavoritesOnly: false,
+      showHidden: _showHiddenFiles,
+    );
+    switch (_filesTypeFilter) {
+      case FilesTypeFilter.all:
+        break;
+      case FilesTypeFilter.filesOnly:
+        filtered = filtered.where((i) => !i.isFolder).toList();
+      case FilesTypeFilter.foldersOnly:
+        filtered = filtered.where((i) => i.isFolder).toList();
+    }
+
+    final field = filesSortField;
+    final folders = filtered.where((i) => i.isFolder).toList()
+      ..sort((a, b) => _compareItems(a, b, field));
+    final files = filtered.where((i) => !i.isFolder).toList()
+      ..sort((a, b) => _compareItems(a, b, field));
+    return filesSortAscending
+        ? [...folders, ...files]
+        : [...folders.reversed, ...files.reversed];
+  }
+
+  void _onAccountCleared() {
+    _cacheRefreshTimer?.cancel();
+    _directoryCache.clear();
+    _folderSortField.clear();
+    _folderSortAscending.clear();
+    _items = [];
+    _quota = null;
+    _activities = [];
+    _currentFolderPath = '/';
+    _pathStack = ['/'];
+    _isGridView = false;
+    _storageScope = StorageScope.cloud;
+    _filesTypeFilter = FilesTypeFilter.all;
+    _showHiddenFiles = false;
+    _cachePolicy = CachePolicy.never;
+    _cacheIntervalMinutes = 5;
+    _isLoading = false;
+    _errorMessage = null;
+    notifyListeners();
+  }
+
+  Future<void> _onAccountActivated() async {
+    final id = session.activeAccountId;
+    if (id != null) {
+      final prefs = await session.prefsFuture;
+      String k(String base) => session.accountStore.accountPrefKey(id, base);
+
+      _isGridView = prefs.getBool(k(_prefGridView)) ?? false;
+      final storageScopeName = prefs.getString(k(_prefStorageScope));
+      _storageScope = StorageScope.values.firstWhere(
+        (s) => s.name == storageScopeName,
+        orElse: () => StorageScope.cloud,
+      );
+      final filesTypeFilterName = prefs.getString(k(_prefFilesTypeFilter));
+      _filesTypeFilter = FilesTypeFilter.values.firstWhere(
+        (f) => f.name == filesTypeFilterName,
+        orElse: () => FilesTypeFilter.all,
+      );
+      _showHiddenFiles = prefs.getBool(k(_prefShowHiddenFiles)) ?? false;
+
+      final folderSortJson = prefs.getString(k(_prefFolderSort));
+      if (folderSortJson != null) {
+        try {
+          final decoded = jsonDecode(folderSortJson) as Map<String, dynamic>;
+          for (final entry in decoded.entries) {
+            final value = entry.value as Map<String, dynamic>;
+            final fieldName = value['field'] as String?;
+            if (fieldName != null) {
+              _folderSortField[entry.key] = FileSortField.values.firstWhere(
+                (f) => f.name == fieldName,
+                orElse: () => FileSortField.name,
+              );
+            }
+            final ascending = value['ascending'] as bool?;
+            if (ascending != null) _folderSortAscending[entry.key] = ascending;
+          }
+        } catch (e) {
+          debugPrint('[FilesController] Folder sort restore failed: $e');
+        }
+      }
+
+      final cachePolicyName = prefs.getString(k(_prefCachePolicy));
+      _cachePolicy = CachePolicy.values.firstWhere(
+        (c) => c.name == cachePolicyName,
+        orElse: () => CachePolicy.never,
+      );
+      _cacheIntervalMinutes = prefs.getInt(k(_prefCacheIntervalMinutes)) ?? 5;
+      notifyListeners();
+    }
+    _startCacheRefreshTimerIfNeeded();
+    await refreshData();
+  }
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    // Only relevant under CachePolicy.interval.
+    if (state == AppLifecycleState.resumed) {
+      _startCacheRefreshTimerIfNeeded();
+    } else if (state == AppLifecycleState.paused) {
+      _cacheRefreshTimer?.cancel();
+    }
+  }
+
+  void _startCacheRefreshTimerIfNeeded() {
+    _cacheRefreshTimer?.cancel();
+    if (_cachePolicy != CachePolicy.interval || !session.isLoggedIn) return;
+    _cacheRefreshTimer = Timer.periodic(
+      Duration(minutes: _cacheIntervalMinutes),
+      (_) => refreshData(),
+    );
+  }
+
+  bool _isCacheFresh(String path) {
+    if (_cachePolicy == CachePolicy.never) return false;
+    final cached = _directoryCache[path];
+    if (cached == null) return false;
+    if (_cachePolicy == CachePolicy.manual) return true;
+    return DateTime.now().difference(cached.fetchedAt) <
+        Duration(minutes: _cacheIntervalMinutes);
+  }
+
+  Future<void> refreshData() async {
+    final service = session.service;
+    if (!session.isLoggedIn || service == null) {
+      debugPrint(
+        '[FilesController] refreshData skipped: isLoggedIn=${session.isLoggedIn}, service=${service != null}',
+      );
+      return;
+    }
+    // Captured so a response landing after an account switch mid-flight
+    // can recognize it's for an account the user has already left and
+    // discard itself instead of overwriting the new account's content.
+    final gen = session.sessionGeneration;
+
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    debugPrint('[FilesController] Refreshing data for path: $_currentFolderPath');
+
+    try {
+      final items = await service.fetchDirectory(_currentFolderPath);
+      if (gen != session.sessionGeneration) return;
+      _items = items;
+      _directoryCache[_currentFolderPath] = _CachedDirectory(
+        _items,
+        DateTime.now(),
+      );
+      debugPrint(
+        '[FilesController] Loaded ${_items.length} items for $_currentFolderPath',
+      );
+      try {
+        _quota = await service.fetchUserQuota();
+      } catch (e) {
+        debugPrint('[FilesController] Quota fetch warning: $e');
+      }
+      try {
+        _activities = await service.fetchActivities();
+      } catch (e) {
+        debugPrint('[FilesController] Activity fetch warning: $e');
+      }
+    } catch (e) {
+      if (gen != session.sessionGeneration) return;
+      debugPrint('[FilesController] Error fetching directory: $e');
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+    } finally {
+      if (gen == session.sessionGeneration) {
+        _isLoading = false;
+        notifyListeners();
+      }
+    }
+  }
+
+  Future<List<NextcloudItem>> searchFiles(String query) async {
+    final service = session.service;
+    if (service == null) return [];
+    return service.searchFiles(query);
+  }
+
+  Future<void> navigateToFolder(String path) async {
+    _pathStack.add(path);
+    await _navigateTo(path);
+  }
+
+  Future<void> navigateUp() async {
+    if (_pathStack.length > 1) {
+      _pathStack.removeLast();
+      await _navigateTo(_pathStack.last);
+    }
+  }
+
+  /// Jumps directly to an ancestor folder by its position in [pathStack]
+  /// (as tapped from a breadcrumb), trimming everything below it.
+  Future<void> navigateToPathIndex(int index) async {
+    if (index < 0 || index >= _pathStack.length - 1) return;
+    _pathStack = _pathStack.sublist(0, index + 1);
+    await _navigateTo(_pathStack.last);
+  }
+
+  /// Navigates directly to an arbitrary absolute folder path (e.g. from a
+  /// search result) - unlike [navigateToFolder], which assumes [path] is a
+  /// child of wherever the user is currently browsing and just appends it,
+  /// this rebuilds the whole breadcrumb trail from root so it's correct
+  /// regardless of where the user was before.
+  Future<void> navigateToAbsoluteFolder(String path) async {
+    final normalized = path.trim().replaceAll(RegExp(r'/+$'), '');
+    final segments = normalized.split('/').where((s) => s.isNotEmpty).toList();
+    final stack = <String>['/'];
+    var current = '';
+    for (final segment in segments) {
+      current = '$current/$segment';
+      stack.add(current);
+    }
+    _pathStack = stack;
+    await _navigateTo(stack.last);
+  }
+
+  /// Switches the current folder to [path], serving its listing straight
+  /// from the cache when that's still fresh (instant, no network call at
+  /// all) and only falling back to [refreshData] otherwise.
+  Future<void> _navigateTo(String path) async {
+    _currentFolderPath = path;
+    final cached = _directoryCache[path];
+    if (cached != null && _isCacheFresh(path)) {
+      debugPrint('[FilesController] Serving cached listing for $path');
+      _items = cached.items;
+      _errorMessage = null;
+      notifyListeners();
+      return;
+    }
+    await refreshData();
+  }
+
+  /// A destination-picker-only fetch: the current folder listing state
+  /// (`items`/`currentFolderPath`/`pathStack`/the directory cache) belongs
+  /// to whichever tab is actively browsing (Files), so the Move/Copy
+  /// destination picker deliberately doesn't touch any of it - it fetches
+  /// listings for its own local navigation state through this instead.
+  Future<List<NextcloudItem>> fetchFolderListing(String path) {
+    return session.service?.fetchDirectory(path) ?? Future.value([]);
+  }
+
+  void invalidateCache() => _directoryCache.clear();
+
+  /// Persists a per-account browsing pref under its `acct_<id>_`-namespaced
+  /// key. No-op if there's no active account (shouldn't normally happen -
+  /// these setters are only reachable from screens that require one).
+  void _persistAccountPref(
+    String baseKey,
+    void Function(SharedPreferences prefs, String key) write,
+  ) {
+    final id = session.activeAccountId;
+    if (id == null) return;
+    session.prefsFuture.then(
+      (p) => write(p, session.accountStore.accountPrefKey(id, baseKey)),
+    );
+  }
+
+  void setGridView(bool value) {
+    if (_isGridView == value) return;
+    _isGridView = value;
+    notifyListeners();
+    _persistAccountPref(_prefGridView, (p, key) => p.setBool(key, value));
+  }
+
+  void setStorageScope(StorageScope scope) {
+    if (_storageScope == scope) return;
+    _storageScope = scope;
+    notifyListeners();
+    _persistAccountPref(
+      _prefStorageScope,
+      (p, key) => p.setString(key, scope.name),
+    );
+  }
+
+  void setFilesTypeFilter(FilesTypeFilter filter) {
+    if (_filesTypeFilter == filter) return;
+    _filesTypeFilter = filter;
+    notifyListeners();
+    _persistAccountPref(
+      _prefFilesTypeFilter,
+      (p, key) => p.setString(key, filter.name),
+    );
+  }
+
+  /// Only *enabling* hidden-files visibility is gated - hiding them again
+  /// never exposes anything, so that direction is always allowed instantly.
+  Future<void> toggleShowHiddenFiles() async {
+    if (!_showHiddenFiles) {
+      if (!await session.passGate(
+        session.lockHiddenFiles,
+        'Unlock to show hidden files',
+      )) {
+        return;
+      }
+    }
+    _showHiddenFiles = !_showHiddenFiles;
+    notifyListeners();
+    _persistAccountPref(
+      _prefShowHiddenFiles,
+      (p, key) => p.setBool(key, _showHiddenFiles),
+    );
+  }
+
+  void _persistFolderSort() {
+    final combined = <String, dynamic>{};
+    for (final path in {
+      ..._folderSortField.keys,
+      ..._folderSortAscending.keys,
+    }) {
+      combined[path] = {
+        'field': _folderSortField[path]?.name,
+        'ascending': _folderSortAscending[path],
+      };
+    }
+    _persistAccountPref(
+      _prefFolderSort,
+      (p, key) => p.setString(key, jsonEncode(combined)),
+    );
+  }
+
+  void setFilesSortField(FileSortField field) {
+    if (filesSortField == field) return;
+    _folderSortField[_currentFolderPath] = field;
+    notifyListeners();
+    _persistFolderSort();
+  }
+
+  void toggleFilesSortOrder() {
+    _folderSortAscending[_currentFolderPath] = !filesSortAscending;
+    notifyListeners();
+    _persistFolderSort();
+  }
+
+  void setCachePolicy(CachePolicy policy) {
+    if (_cachePolicy == policy) return;
+    _cachePolicy = policy;
+    notifyListeners();
+    _persistAccountPref(
+      _prefCachePolicy,
+      (p, key) => p.setString(key, policy.name),
+    );
+    _startCacheRefreshTimerIfNeeded();
+  }
+
+  void setCacheIntervalMinutes(int minutes) {
+    final clamped = minutes.clamp(1, 60);
+    if (_cacheIntervalMinutes == clamped) return;
+    _cacheIntervalMinutes = clamped;
+    notifyListeners();
+    _persistAccountPref(
+      _prefCacheIntervalMinutes,
+      (p, key) => p.setInt(key, clamped),
+    );
+    _startCacheRefreshTimerIfNeeded();
+  }
+
+  Future<bool> createFolder(String folderName) async {
+    final service = session.service;
+    if (service == null) return false;
+    final success = await service.createFolder(_currentFolderPath, folderName);
+    if (success) {
+      await refreshData();
+    }
+    return success;
+  }
+
+  /// Patches a favorite-toggle result into [items] in place (no refetch) -
+  /// called by `ItemOperations.toggleItemFavorite` after a successful
+  /// server call.
+  void applyFavoriteToggle(NextcloudItem updated) {
+    final index = _items.indexWhere((i) => i.id == updated.id);
+    if (index != -1) _items[index] = updated;
+    notifyListeners();
+  }
+
+  @override
+  void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
+    _cacheRefreshTimer?.cancel();
+    super.dispose();
+  }
+}

lib/providers/item_operations.dart

@@ -0,0 +1,358 @@
+import 'package:flutter/foundation.dart';
+import '../models/move_copy_result.dart';
+import '../models/nextcloud_file_version.dart';
+import '../models/nextcloud_item.dart';
+import '../models/nextcloud_share.dart';
+import '../models/nextcloud_sharee.dart';
+import 'favorites_controller.dart';
+import 'files_controller.dart';
+import 'photos_controller.dart';
+import 'session_controller.dart';
+
+/// The one place that knows how an item mutation (delete/rename/move/copy/
+/// favorite-toggle/create-folder) ripples across Files/Photos/Favorites -
+/// those three each own their own item list, but a mutation triggered from
+/// *any* of them (see each call site in the views) needs to reconcile all
+/// three, since e.g. a delete removes an item Photos might also be
+/// showing. Deliberately holds direct references to the sibling
+/// controllers (constructed once in `main.dart`, after they already exist)
+/// rather than a generic event bus, so callers can still `await` a
+/// mutation and know every affected list has already been reconciled by
+/// the time it returns - exactly the same guarantee the single
+/// `ServerProvider` god object gave for free before this was split out.
+///
+/// Also home to the file-details sheet's per-item pass-throughs (shares/
+/// activity/versions) - stateless, no stored data, so they don't need a
+/// controller of their own.
+class ItemOperations {
+  final SessionController session;
+  final FilesController files;
+  final PhotosController photos;
+  final FavoritesController favorites;
+
+  const ItemOperations({
+    required this.session,
+    required this.files,
+    required this.photos,
+    required this.favorites,
+  });
+
+  Future<bool> deleteItem(String itemPath) async {
+    final service = session.service;
+    if (service == null) return false;
+    final success = await service.deleteItem(itemPath);
+    if (success) {
+      photos.applyDelete(itemPath);
+      await files.refreshData();
+      await favorites.syncIfLoaded();
+    }
+    return success;
+  }
+
+  Future<bool> renameItem(NextcloudItem item, String newName) async {
+    final service = session.service;
+    if (service == null) return false;
+    final success = await service.renameItem(item.path, newName);
+    if (success) {
+      await files.refreshData();
+      await favorites.syncIfLoaded();
+    }
+    return success;
+  }
+
+  /// True if [destFolderPath] is [folderPath] itself or one of its own
+  /// descendants - moving/copying a folder into itself (or a subfolder of
+  /// itself) is nonsensical and rejected client-side rather than left to
+  /// the server to (maybe) reject.
+  bool _isSelfOrDescendant(String destFolderPath, String folderPath) {
+    final dest = destFolderPath.endsWith('/')
+        ? destFolderPath
+        : '$destFolderPath/';
+    final folder = folderPath.endsWith('/') ? folderPath : '$folderPath/';
+    return dest == folder || dest.startsWith(folder);
+  }
+
+  Future<MoveCopyResult> _moveOrCopyItems(
+    List<NextcloudItem> items,
+    String destFolderPath, {
+    required bool copy,
+  }) async {
+    final service = session.service;
+    if (service == null || items.isEmpty) return const MoveCopyResult();
+    for (final item in items) {
+      if (item.isFolder && _isSelfOrDescendant(destFolderPath, item.path)) {
+        return const MoveCopyResult(
+          blockedReason:
+              "Can't move a folder into itself or one of its own subfolders",
+        );
+      }
+    }
+
+    var succeeded = 0;
+    var failed = 0;
+    final conflicts = <MoveCopyConflict>[];
+    for (final item in items) {
+      final status = copy
+          ? await service.copyItem(item.path, destFolderPath)
+          : await service.moveItem(item.path, destFolderPath);
+      if (status == 201 || status == 204) {
+        succeeded++;
+      } else if (status == 412) {
+        conflicts.add(MoveCopyConflict(item));
+      } else {
+        failed++;
+      }
+    }
+    if (succeeded > 0) {
+      files.invalidateCache();
+      await files.refreshData();
+      await favorites.syncIfLoaded();
+    }
+    return MoveCopyResult(
+      succeeded: succeeded,
+      conflicts: conflicts,
+      failed: failed,
+    );
+  }
+
+  /// Moves every item in [items] into [destFolderPath], keeping each
+  /// item's own filename. Items that would collide with something already
+  /// there come back in [MoveCopyResult.conflicts] rather than failing
+  /// outright - resolve those with [resolveConflicts].
+  Future<MoveCopyResult> moveItems(
+    List<NextcloudItem> items,
+    String destFolderPath,
+  ) {
+    return _moveOrCopyItems(items, destFolderPath, copy: false);
+  }
+
+  /// Same as [moveItems] but duplicates rather than relocates.
+  Future<MoveCopyResult> copyItems(
+    List<NextcloudItem> items,
+    String destFolderPath,
+  ) {
+    return _moveOrCopyItems(items, destFolderPath, copy: true);
+  }
+
+  /// Finds the first `name (n).ext` not already in [existing] - `existing`
+  /// is mutated as names are claimed, so a batch of "keep both" resolutions
+  /// never picks the same generated name twice.
+  String _nextAvailableName(String name, Set<String> existing) {
+    if (!existing.contains(name)) return name;
+    final dotIndex = name.lastIndexOf('.');
+    final hasExtension = dotIndex > 0 && dotIndex < name.length - 1;
+    final base = hasExtension ? name.substring(0, dotIndex) : name;
+    final ext = hasExtension ? name.substring(dotIndex) : '';
+    var n = 2;
+    while (existing.contains('$base ($n)$ext')) {
+      n++;
+    }
+    return '$base ($n)$ext';
+  }
+
+  /// Resolves a previous [moveItems]/[copyItems] call's conflicts per
+  /// [choices] (keyed by `item.id`): overwrite the existing item, keep
+  /// both (renamed against a fresh listing of [destFolderPath] so two
+  /// "keep both" picks in the same batch can't collide with each other),
+  /// or skip (left untouched at the source).
+  Future<MoveCopyResult> resolveConflicts(
+    List<MoveCopyConflict> conflicts,
+    String destFolderPath, {
+    required bool copy,
+    required Map<String, ConflictChoice> choices,
+  }) async {
+    final service = session.service;
+    if (service == null || conflicts.isEmpty) return const MoveCopyResult();
+
+    final needsKeepBoth = conflicts.any(
+      (c) => choices[c.item.id] == ConflictChoice.keepBoth,
+    );
+    final existingNames = needsKeepBoth
+        ? (await files.fetchFolderListing(destFolderPath))
+              .map((i) => i.name)
+              .toSet()
+        : <String>{};
+
+    var succeeded = 0;
+    var failed = 0;
+    for (final conflict in conflicts) {
+      final choice = choices[conflict.item.id] ?? ConflictChoice.skip;
+      if (choice == ConflictChoice.skip) continue;
+
+      final int status;
+      if (choice == ConflictChoice.overwrite) {
+        status = copy
+            ? await service.copyItem(
+                conflict.item.path,
+                destFolderPath,
+                overwrite: true,
+              )
+            : await service.moveItem(
+                conflict.item.path,
+                destFolderPath,
+                overwrite: true,
+              );
+      } else {
+        final newName = _nextAvailableName(conflict.item.name, existingNames);
+        existingNames.add(newName);
+        status = copy
+            ? await service.copyItem(
+                conflict.item.path,
+                destFolderPath,
+                newName: newName,
+              )
+            : await service.moveItem(
+                conflict.item.path,
+                destFolderPath,
+                newName: newName,
+              );
+      }
+      if (status == 201 || status == 204) {
+        succeeded++;
+      } else {
+        failed++;
+      }
+    }
+    if (succeeded > 0) {
+      files.invalidateCache();
+      await files.refreshData();
+      await favorites.syncIfLoaded();
+    }
+    return MoveCopyResult(succeeded: succeeded, failed: failed);
+  }
+
+  Future<void> toggleItemFavorite(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return;
+    final success = await service.toggleFavorite(item.path, item.isFavorite);
+    if (success) {
+      final updated = item.copyWith(isFavorite: !item.isFavorite);
+      files.applyFavoriteToggle(updated);
+      photos.applyFavoriteToggle(updated);
+      favorites.applyFavoriteToggle(updated);
+    }
+  }
+
+  /// Creates a public link share for [item] and returns its URL, or null on
+  /// failure (server error, unsupported item, etc).
+  Future<String?> createShareLink(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return null;
+    try {
+      return await service.createPublicShareLink(item.path);
+    } catch (e) {
+      debugPrint('[ItemOperations] createShareLink failed: $e');
+      return null;
+    }
+  }
+
+  // --- Details sheet: per-item sharing/activity/versions ---
+  //
+  // Thin pass-throughs (no stored state) - the data here is transient and
+  // scoped to whichever item's Details sheet happens to be open, so it
+  // lives in that sheet's own local widget state rather than a controller.
+
+  Future<List<NextcloudShare>> fetchItemShares(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return [];
+    try {
+      return await service.fetchSharesForPath(item.path);
+    } catch (e) {
+      debugPrint('[ItemOperations] fetchItemShares failed: $e');
+      return [];
+    }
+  }
+
+  Future<List<NextcloudShare>> fetchInheritedShares(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return [];
+    return service.fetchInheritedShares(item.path);
+  }
+
+  Future<List<NextcloudSharee>> searchSharees(String query) async {
+    final service = session.service;
+    if (service == null) return [];
+    try {
+      return await service.searchSharees(query);
+    } catch (e) {
+      debugPrint('[ItemOperations] searchSharees failed: $e');
+      return [];
+    }
+  }
+
+  Future<NextcloudShare?> createShare({
+    required String path,
+    required int shareType,
+    String? shareWith,
+    String? password,
+    DateTime? expireDate,
+  }) async {
+    final service = session.service;
+    if (service == null) return null;
+    try {
+      return await service.createShare(
+        path: path,
+        shareType: shareType,
+        shareWith: shareWith,
+        password: password,
+        expireDate: expireDate,
+      );
+    } catch (e) {
+      debugPrint('[ItemOperations] createShare failed: $e');
+      return null;
+    }
+  }
+
+  /// Deletes a share (from the file-details/Share sheet, not the Shares
+  /// tab itself - see `SharesController.deleteShare` for that one, which
+  /// additionally patches the tab's own list).
+  Future<bool> deleteShare(NextcloudShare share) async {
+    final service = session.service;
+    if (service == null) return false;
+    return service.deleteShare(share.id);
+  }
+
+  Future<List<NextcloudActivity>> fetchFileActivity(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return [];
+    return service.fetchFileActivity(item.id);
+  }
+
+  Future<List<NextcloudFileVersion>> fetchFileVersions(
+    NextcloudItem item,
+  ) async {
+    final service = session.service;
+    if (service == null) return [];
+    return service.fetchFileVersions(item.id);
+  }
+
+  Future<bool> restoreFileVersion(
+    NextcloudItem item,
+    String versionLabel,
+  ) async {
+    final service = session.service;
+    if (service == null) return false;
+    try {
+      return await service.restoreFileVersion(item.id, versionLabel);
+    } catch (e) {
+      debugPrint('[ItemOperations] restoreFileVersion failed: $e');
+      return false;
+    }
+  }
+
+  Future<bool> downloadVersion(
+    NextcloudItem item,
+    String versionLabel,
+    String savePath,
+  ) async {
+    final service = session.service;
+    if (service == null) return false;
+    try {
+      await service.downloadVersionToFile(item.id, versionLabel, savePath);
+      return true;
+    } catch (e) {
+      debugPrint('[ItemOperations] downloadVersion failed: $e');
+      return false;
+    }
+  }
+}

lib/providers/photos_controller.dart

@@ -0,0 +1,190 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/nextcloud_item.dart';
+import 'files_controller.dart';
+import 'session_controller.dart';
+
+/// The Photos tab: every image/video across the whole account (not just
+/// the currently browsed folder - see [fetchAllMedia]). Depends on
+/// [FilesController] only for the shared [StorageScope] toggle and
+/// [FilesController.applyCommonFilters] - Photos' own favorites-only/
+/// hidden toggles are independent of Files', but the storage-scope split
+/// (cloud vs external) is one shared setting across every tab.
+class PhotosController extends ChangeNotifier {
+  final SessionController session;
+  final FilesController files;
+
+  static const _prefShowFavoritesOnlyPhotos = 'ui_show_favorites_only_photos';
+  static const _prefShowHiddenPhotos = 'ui_show_hidden_photos';
+  static const _prefSortField = 'ui_sort_field';
+  static const _prefSortAscending = 'ui_sort_ascending';
+
+  List<NextcloudItem> _allMedia = [];
+  bool _isLoading = false;
+  String? _errorMessage;
+
+  bool _showFavoritesOnly = false;
+  bool _showHidden = false;
+  FileSortField _sortField = FileSortField.name;
+  bool _sortAscending = true;
+
+  PhotosController(this.session, this.files) {
+    session.addAccountClearedListener(_onAccountCleared);
+    session.addAccountActivatedListener(_onAccountActivated);
+  }
+
+  bool get isLoading => _isLoading;
+  String? get errorMessage => _errorMessage;
+  bool get showFavoritesOnly => _showFavoritesOnly;
+  bool get showHidden => _showHidden;
+  FileSortField get sortField => _sortField;
+  bool get sortAscending => _sortAscending;
+
+  /// All images/videos across the whole account (not just the currently
+  /// browsed folder) — see [fetchAllMedia].
+  List<NextcloudItem> get items {
+    final media = _allMedia.where((i) => i.isMedia).toList();
+    final filtered = files.applyCommonFilters(
+      media,
+      showFavoritesOnly: _showFavoritesOnly,
+      showHidden: _showHidden,
+    )..sort((a, b) => _compare(a, b));
+    return _sortAscending ? filtered : filtered.reversed.toList();
+  }
+
+  int _compare(NextcloudItem a, NextcloudItem b) {
+    switch (_sortField) {
+      case FileSortField.name:
+        return a.name.toLowerCase().compareTo(b.name.toLowerCase());
+      case FileSortField.dateCreated:
+        return a.dateCreated.compareTo(b.dateCreated);
+      case FileSortField.dateModified:
+        return a.lastModified.compareTo(b.lastModified);
+      case FileSortField.size:
+        return a.size.compareTo(b.size);
+    }
+  }
+
+  void _onAccountCleared() {
+    _allMedia = [];
+    _isLoading = false;
+    _errorMessage = null;
+    notifyListeners();
+  }
+
+  Future<void> _onAccountActivated() async {
+    final id = session.activeAccountId;
+    if (id != null) {
+      final prefs = await session.prefsFuture;
+      String k(String base) => session.accountStore.accountPrefKey(id, base);
+      _showFavoritesOnly =
+          prefs.getBool(k(_prefShowFavoritesOnlyPhotos)) ?? false;
+      _showHidden = prefs.getBool(k(_prefShowHiddenPhotos)) ?? false;
+      final sortFieldName = prefs.getString(k(_prefSortField));
+      _sortField = FileSortField.values.firstWhere(
+        (f) => f.name == sortFieldName,
+        orElse: () => FileSortField.name,
+      );
+      _sortAscending = prefs.getBool(k(_prefSortAscending)) ?? true;
+      notifyListeners();
+    }
+    unawaited(fetchAllMedia());
+  }
+
+  /// Loads every image/video across the whole account for the Photos tab.
+  Future<void> fetchAllMedia() async {
+    final service = session.service;
+    if (!session.isLoggedIn || service == null) return;
+    final gen = session.sessionGeneration;
+
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    try {
+      final media = await service.fetchAllMedia();
+      if (gen != session.sessionGeneration) return;
+      _allMedia = media;
+      debugPrint('[PhotosController] Loaded ${_allMedia.length} media items');
+    } catch (e) {
+      if (gen != session.sessionGeneration) return;
+      debugPrint('[PhotosController] Error fetching all media: $e');
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+    } finally {
+      if (gen == session.sessionGeneration) {
+        _isLoading = false;
+        notifyListeners();
+      }
+    }
+  }
+
+  void _persistAccountPref(
+    String baseKey,
+    void Function(SharedPreferences prefs, String key) write,
+  ) {
+    final id = session.activeAccountId;
+    if (id == null) return;
+    session.prefsFuture.then(
+      (p) => write(p, session.accountStore.accountPrefKey(id, baseKey)),
+    );
+  }
+
+  void toggleFavoritesFilter() {
+    _showFavoritesOnly = !_showFavoritesOnly;
+    notifyListeners();
+    _persistAccountPref(
+      _prefShowFavoritesOnlyPhotos,
+      (p, key) => p.setBool(key, _showFavoritesOnly),
+    );
+  }
+
+  Future<void> toggleShowHidden() async {
+    if (!_showHidden) {
+      if (!await session.passGate(
+        session.lockHiddenFiles,
+        'Unlock to show hidden files',
+      )) {
+        return;
+      }
+    }
+    _showHidden = !_showHidden;
+    notifyListeners();
+    _persistAccountPref(
+      _prefShowHiddenPhotos,
+      (p, key) => p.setBool(key, _showHidden),
+    );
+  }
+
+  void setSortField(FileSortField field) {
+    if (_sortField == field) return;
+    _sortField = field;
+    notifyListeners();
+    _persistAccountPref(_prefSortField, (p, key) => p.setString(key, field.name));
+  }
+
+  void toggleSortOrder() {
+    _sortAscending = !_sortAscending;
+    notifyListeners();
+    _persistAccountPref(
+      _prefSortAscending,
+      (p, key) => p.setBool(key, _sortAscending),
+    );
+  }
+
+  /// Removes an item by path (a delete elsewhere in the app) - called by
+  /// `ItemOperations.deleteItem` after a successful server call.
+  void applyDelete(String path) {
+    _allMedia = _allMedia.where((i) => i.path != path).toList();
+    notifyListeners();
+  }
+
+  /// Patches a favorite-toggle result into [items]' source list in place -
+  /// called by `ItemOperations.toggleItemFavorite` after a successful
+  /// server call.
+  void applyFavoriteToggle(NextcloudItem updated) {
+    final index = _allMedia.indexWhere((i) => i.id == updated.id);
+    if (index != -1) _allMedia[index] = updated;
+    notifyListeners();
+  }
+}

lib/providers/pick_controller.dart

@@ -0,0 +1,95 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:path/path.dart' as p;
+import 'package:path_provider/path_provider.dart';
+import '../models/nextcloud_item.dart';
+import '../models/pick_request.dart';
+import '../services/pick_intent_service.dart';
+import 'session_controller.dart';
+
+/// State for Noo acting as *another* app's GET_CONTENT picker (see
+/// `PickIntentService`/`MainActivity.kt`) - non-null [pickRequest] while
+/// active, set at startup/onNewPickRequest in `MainShellView`, cleared
+/// once the pick is confirmed or cancelled. Cross-cutting (both Files and
+/// Photos need to know when picking mode is active and route taps through
+/// [confirmPick] instead of their normal open/select behavior), so this is
+/// its own small controller rather than living on any one tab's.
+class PickController extends ChangeNotifier {
+  final SessionController session;
+
+  PickController(this.session);
+
+  PickRequest? _pickRequest;
+  bool _isDownloadingForPick = false;
+
+  PickRequest? get pickRequest => _pickRequest;
+  bool get isPicking => _pickRequest != null;
+  bool get isDownloadingForPick => _isDownloadingForPick;
+
+  /// Whether [item] can be handed back to the app that's currently picking
+  /// - always true for folders (still browsable), mime-filtered for files.
+  bool itemMatchesPickFilter(NextcloudItem item) {
+    if (item.isFolder) return true;
+    final request = _pickRequest;
+    return request == null || request.matches(item.mimeType);
+  }
+
+  /// Called once (from MainShellView) as soon as a pick request is known -
+  /// either the cold-start request or one that arrived via onNewPickRequest
+  /// while already running.
+  void setPickRequest(PickRequest request) {
+    _pickRequest = request;
+    notifyListeners();
+  }
+
+  /// Downloads each selected item to a scratch cache folder, then hands the
+  /// local paths back to the caller through PickIntentService, which closes
+  /// the picker Activity on success. Left in [pickRequest] (i.e. picking
+  /// mode stays visually active) if the download fails partway, so the user
+  /// can see the error and retry rather than the screen finishing under
+  /// them with nothing returned to the caller.
+  Future<bool> confirmPick(List<NextcloudItem> items) async {
+    final service = session.service;
+    if (_pickRequest == null || service == null || items.isEmpty) {
+      return false;
+    }
+    _isDownloadingForPick = true;
+    notifyListeners();
+    try {
+      final tempDir = await getTemporaryDirectory();
+      final pickDir = Directory(p.join(tempDir.path, 'picker'));
+      final localPaths = <String>[];
+      final mimeTypes = <String>[];
+      for (final item in items) {
+        // Each item gets its own subfolder (keyed by id, not smashed into
+        // the filename) so two different items can share a plain file
+        // name without colliding, while the file on disk - and therefore
+        // the display name the caller sees via the content:// Uri
+        // MainActivity.kt hands back - stays exactly `item.name`.
+        final itemDir = Directory(p.join(pickDir.path, item.id));
+        await itemDir.create(recursive: true);
+        final localPath = p.join(itemDir.path, item.name);
+        await service.downloadToFile(item.path, localPath);
+        localPaths.add(localPath);
+        mimeTypes.add(item.mimeType ?? 'application/octet-stream');
+      }
+      await PickIntentService.finishPick(localPaths, mimeTypes);
+      _pickRequest = null;
+      return true;
+    } catch (_) {
+      return false;
+    } finally {
+      _isDownloadingForPick = false;
+      notifyListeners();
+    }
+  }
+
+  /// Backs out of picking mode entirely, telling the caller nothing was
+  /// picked and closing the picker Activity.
+  Future<void> cancelPick() async {
+    if (_pickRequest == null) return;
+    _pickRequest = null;
+    notifyListeners();
+    await PickIntentService.cancelPick();
+  }
+}

lib/providers/recent_controller.dart

@@ -0,0 +1,59 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import '../models/nextcloud_item.dart';
+import 'session_controller.dart';
+
+/// The Recent Files tab. Kept separate from Files' own loading/error
+/// state, likewise.
+class RecentController extends ChangeNotifier {
+  final SessionController session;
+
+  List<NextcloudItem> _items = [];
+  bool _isLoading = false;
+  String? _errorMessage;
+
+  RecentController(this.session) {
+    session.addAccountClearedListener(_onAccountCleared);
+    session.addAccountActivatedListener(_onAccountActivated);
+  }
+
+  List<NextcloudItem> get items => _items;
+  bool get isLoading => _isLoading;
+  String? get errorMessage => _errorMessage;
+
+  void _onAccountCleared() {
+    _items = [];
+    _isLoading = false;
+    _errorMessage = null;
+    notifyListeners();
+  }
+
+  void _onAccountActivated() {
+    unawaited(fetchAll());
+  }
+
+  Future<void> fetchAll() async {
+    final service = session.service;
+    if (!session.isLoggedIn || service == null) return;
+    final gen = session.sessionGeneration;
+
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    try {
+      final recent = await service.fetchRecentFiles();
+      if (gen != session.sessionGeneration) return;
+      _items = recent;
+    } catch (e) {
+      if (gen != session.sessionGeneration) return;
+      debugPrint('[RecentController] Error fetching recent files: $e');
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+    } finally {
+      if (gen == session.sessionGeneration) {
+        _isLoading = false;
+        notifyListeners();
+      }
+    }
+  }
+}

lib/providers/session_controller.dart

@@ -0,0 +1,571 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/saved_account.dart';
+import '../services/account_store.dart';
+import '../services/app_lock_service.dart';
+import '../services/login_flow_service.dart';
+import '../services/nextcloud_service.dart';
+import '../services/sync_service.dart';
+
+enum LoginFlowStatus { idle, initiating, awaitingBrowser, error }
+
+/// Owns everything about *which* account is live and whether it's actually
+/// authenticated: the saved-accounts list, the active account, Login Flow
+/// v2, the live [NextcloudService] instance, the session-generation guard
+/// every other controller's fetches check against, and app lock. Doesn't
+/// hold a single byte of any tab's *content* - that's what
+/// [FilesController]/`PhotosController`/etc. own, each reacting to this
+/// controller's account-activated/cleared signals (below) rather than this
+/// controller reaching into them directly, since this is constructed
+/// before them (they depend on it, not the other way around).
+///
+/// Split out of the former single `ServerProvider` god object - see
+/// `.claude/context/architecture.md`'s "State management" section for the
+/// full rationale.
+class SessionController extends ChangeNotifier with WidgetsBindingObserver {
+  final Future<SharedPreferences> prefsFuture =
+      SharedPreferences.getInstance();
+  final AccountStore accountStore = AccountStore();
+
+  String _serverUrl = '';
+  String _username = '';
+  String _password = '';
+  bool _isLoggedIn = false;
+  bool _isLoading = false;
+  bool _isRestoringSession = true;
+  String? _errorMessage;
+
+  LoginFlowStatus _loginFlowStatus = LoginFlowStatus.idle;
+  Uri? _pendingLoginUrl;
+  Timer? _pollTimer;
+  Timer? _pollTimeoutTimer;
+  bool _addAccountFlowActive = false;
+
+  NextcloudService? _service;
+
+  List<SavedAccount> _accounts = [];
+  String? _activeAccountId;
+  // Bumped at the start of every account switch/removal/activation so an
+  // in-flight fetch from the account being left can recognize it's stale
+  // (by comparing against the generation it captured at its own start) and
+  // discard its result instead of writing it into the now-active account's
+  // state. Every other controller's fetch methods check this too.
+  int _sessionGeneration = 0;
+
+  bool _loginLockEnabled = false;
+  bool _lockAccountSwitching = false;
+  bool _lockHiddenFiles = false;
+  // Transient (never persisted) - starts locked whenever the app process
+  // starts, and re-locks on every backgrounding if a lock is configured;
+  // see didChangeAppLifecycleState.
+  bool _isUnlocked = false;
+
+  static const _prefLoginLockEnabled = 'ui_login_lock_enabled';
+  static const _prefLockAccountSwitching = 'ui_lock_account_switching';
+  static const _prefLockHiddenFiles = 'ui_lock_hidden_files';
+
+  // Sibling controllers (Files/Photos/Favorites/Trash/Shares/Recent/Sync)
+  // register here instead of this controller holding forward references to
+  // them - it's constructed first, they depend on it. `cleared` fires
+  // wherever `_clearActiveContent()` used to run (about to switch/log out -
+  // reset your own state); `activated` fires only once credentials are
+  // actually verified (fetch your own data now).
+  final List<VoidCallback> _accountClearedListeners = [];
+  final List<VoidCallback> _accountActivatedListeners = [];
+  void addAccountClearedListener(VoidCallback cb) =>
+      _accountClearedListeners.add(cb);
+  void addAccountActivatedListener(VoidCallback cb) =>
+      _accountActivatedListeners.add(cb);
+  void _notifyAccountCleared() {
+    for (final cb in _accountClearedListeners) {
+      cb();
+    }
+  }
+
+  void _notifyAccountActivated() {
+    for (final cb in _accountActivatedListeners) {
+      cb();
+    }
+  }
+
+  SessionController() {
+    WidgetsBinding.instance.addObserver(this);
+    _init();
+  }
+
+  Future<void> _init() async {
+    final prefs = await prefsFuture;
+    await accountStore.migrateLegacyIfNeeded(prefs);
+    _accounts = accountStore.loadAccounts(prefs);
+    _activeAccountId = accountStore.loadActiveAccountId(prefs);
+    await Future.wait([_loadPreferences(), _restoreSession()]);
+  }
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    // Re-locks the app on backgrounding when login lock is set up - a
+    // one-time unlock at cold start would give the feature no real
+    // security value, since the realistic threat is someone else picking
+    // up an already-running, unlocked phone.
+    if (state == AppLifecycleState.paused &&
+        _loginLockEnabled &&
+        _isUnlocked) {
+      _isUnlocked = false;
+      notifyListeners();
+    }
+  }
+
+  // Getters
+  String get serverUrl => _serverUrl;
+  String get username => _username;
+  bool get isLoggedIn => _isLoggedIn;
+  bool get isLoading => _isLoading;
+  bool get isRestoringSession => _isRestoringSession;
+  String? get errorMessage => _errorMessage;
+  int get sessionGeneration => _sessionGeneration;
+  NextcloudService? get service => _service;
+
+  LoginFlowStatus get loginFlowStatus => _loginFlowStatus;
+  Uri? get pendingLoginUrl => _pendingLoginUrl;
+
+  List<SavedAccount> get accounts => List.unmodifiable(_accounts);
+  String? get activeAccountId => _activeAccountId;
+  SavedAccount? get activeAccount =>
+      _accounts.where((a) => a.id == _activeAccountId).firstOrNull;
+  bool get isAddAccountFlow => _addAccountFlowActive;
+
+  bool get loginLockEnabled => _loginLockEnabled;
+  bool get lockAccountSwitching => _lockAccountSwitching;
+  bool get lockHiddenFiles => _lockHiddenFiles;
+  bool get needsUnlock => _loginLockEnabled && !_isUnlocked;
+
+  Future<void> _restoreSession() async {
+    try {
+      final id = _activeAccountId;
+      if (id == null) return;
+      final account = _accounts.where((a) => a.id == id).firstOrNull;
+      if (account == null) return;
+      final password = await accountStore.readPassword(id);
+      if (password == null) return;
+      await _applyCredentialsForAccount(account, password);
+    } catch (e) {
+      debugPrint('[SessionController] Session restore failed: $e');
+    } finally {
+      _isRestoringSession = false;
+      notifyListeners();
+    }
+  }
+
+  Future<void> _loadPreferences() async {
+    try {
+      final prefs = await prefsFuture;
+      _loginLockEnabled =
+          prefs.getBool(_prefLoginLockEnabled) ?? _loginLockEnabled;
+      _lockAccountSwitching =
+          prefs.getBool(_prefLockAccountSwitching) ?? _lockAccountSwitching;
+      _lockHiddenFiles =
+          prefs.getBool(_prefLockHiddenFiles) ?? _lockHiddenFiles;
+      notifyListeners();
+    } catch (e) {
+      debugPrint('[SessionController] Preference restore failed: $e');
+    }
+  }
+
+  /// Verifies [appPassword] for [account] and, on success, makes it the
+  /// live session, firing [_notifyAccountActivated] so every other
+  /// controller fetches its own data. The password is expected to already
+  /// be durably saved by the caller (either freshly, via
+  /// [_completeLoginFlow], or previously, since this is also how a saved
+  /// session is restored/switched to) - this method only writes to
+  /// [AccountStore] to drop a password that turns out to no longer work.
+  Future<bool> _applyCredentialsForAccount(
+    SavedAccount account,
+    String appPassword,
+  ) async {
+    final gen = _sessionGeneration;
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    _serverUrl = account.serverUrl;
+    _username = account.username;
+    _password = appPassword;
+
+    _service = NextcloudService(
+      serverUrl: _serverUrl,
+      username: _username,
+      password: _password,
+    );
+
+    try {
+      final success = await _service!.testConnection();
+      if (gen != _sessionGeneration) return false;
+      if (success) {
+        _isLoggedIn = true;
+        _isLoading = false;
+        notifyListeners();
+        _notifyAccountActivated();
+        return true;
+      }
+    } catch (e) {
+      if (gen != _sessionGeneration) return false;
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+      // Only drop the stored password on an actual auth rejection (401) -
+      // testConnection also throws for network-level failures (DNS,
+      // timeout, unreachable host), and those are transient: deleting a
+      // still-valid password on a dropped connection would permanently
+      // log the account out with no way back in short of Login Flow v2
+      // again, since activeAccountId is never cleared and switchAccount()
+      // no-ops when asked to "switch" to the account that's already
+      // (nominally) active.
+      if (_errorMessage?.contains('401') == true) {
+        await accountStore.deletePassword(account.id);
+      }
+    }
+
+    if (gen != _sessionGeneration) return false;
+    _isLoggedIn = false;
+    _service = null;
+    _isLoading = false;
+    notifyListeners();
+    return false;
+  }
+
+  /// Starts Nextcloud Login Flow v2: asks the server for a one-time login
+  /// URL, then polls until the user authorizes (in LoginWebViewView, pushed
+  /// by LoginView once loginFlowStatus flips to awaitingBrowser below) and
+  /// the server hands back a scoped app password. The app never sees the
+  /// user's real password. [addAccount] only marks the flow as "add
+  /// another account" for [isAddAccountFlow] - the pushed Add Account
+  /// screen reads that to decide when to pop itself; this method's own
+  /// persistence behavior on success ([_completeLoginFlow]) is the same
+  /// either way (create-or-refresh the resulting account, then activate
+  /// it).
+  Future<void> startLoginFlow(
+    String serverUrl, {
+    bool addAccount = false,
+  }) async {
+    _addAccountFlowActive = addAccount;
+    _loginFlowStatus = LoginFlowStatus.initiating;
+    _errorMessage = null;
+    notifyListeners();
+
+    try {
+      final init = await LoginFlowService.initiate(serverUrl);
+      _pendingLoginUrl = init.loginUrl;
+      _loginFlowStatus = LoginFlowStatus.awaitingBrowser;
+      notifyListeners();
+
+      _pollTimer?.cancel();
+      _pollTimeoutTimer?.cancel();
+
+      _pollTimeoutTimer = Timer(const Duration(minutes: 10), () {
+        if (_loginFlowStatus == LoginFlowStatus.awaitingBrowser) {
+          cancelLoginFlow(errorMessage: 'Login timed out. Please try again.');
+        }
+      });
+
+      _pollTimer = Timer.periodic(const Duration(seconds: 2), (timer) async {
+        try {
+          final result = await LoginFlowService.poll(
+            init.pollEndpoint,
+            init.pollToken,
+          );
+          if (result != null) {
+            timer.cancel();
+            _pollTimeoutTimer?.cancel();
+            _loginFlowStatus = LoginFlowStatus.idle;
+            _pendingLoginUrl = null;
+            await _completeLoginFlow(result);
+            _addAccountFlowActive = false;
+          }
+        } on http.ClientException catch (e) {
+          // A single dropped connection (e.g. the network briefly
+          // reconfiguring right as the login browser opens) used to abort
+          // the whole flow, forcing the user to start over even though
+          // they'd already granted access - just skip this tick and let
+          // the next scheduled poll (2s later) try again. The 10-minute
+          // timeout above is still the real ceiling.
+          debugPrint('[SessionController] Poll network hiccup, retrying: $e');
+        } catch (e) {
+          timer.cancel();
+          _pollTimeoutTimer?.cancel();
+          cancelLoginFlow(
+            errorMessage: e.toString().replaceAll('Exception: ', ''),
+          );
+        }
+      });
+    } catch (e) {
+      _loginFlowStatus = LoginFlowStatus.error;
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+      notifyListeners();
+    }
+  }
+
+  void cancelLoginFlow({String? errorMessage}) {
+    _pollTimer?.cancel();
+    _pollTimeoutTimer?.cancel();
+    _pendingLoginUrl = null;
+    _addAccountFlowActive = false;
+    _loginFlowStatus = errorMessage != null
+        ? LoginFlowStatus.error
+        : LoginFlowStatus.idle;
+    _errorMessage = errorMessage;
+    notifyListeners();
+  }
+
+  /// Turns a completed Login Flow v2 result into a saved account (creating
+  /// it, or refreshing its password if it already existed - e.g. an
+  /// expired app password re-authenticated) and makes it the active
+  /// session. Used for both the first/only login and "add account".
+  Future<void> _completeLoginFlow(LoginFlowResult result) async {
+    final serverUrl = LoginFlowService.normalizeServerUrl(result.serverUrl);
+    final id = SavedAccount.makeId(serverUrl, result.loginName);
+    final account = SavedAccount(
+      id: id,
+      serverUrl: serverUrl,
+      username: result.loginName,
+    );
+    _accounts = [
+      for (final a in _accounts)
+        if (a.id != id) a,
+      account,
+    ];
+
+    final prefs = await prefsFuture;
+    await accountStore.saveAccounts(prefs, _accounts);
+    await accountStore.writePassword(id, result.appPassword);
+    await _activateAccount(id);
+  }
+
+  /// The shared engine behind switching accounts, falling back to another
+  /// account after removing the active one, and landing on the newly
+  /// created/refreshed account after a login flow completes: tears down
+  /// the outgoing account's live content (without ever setting
+  /// [isLoggedIn] false - see below), then loads the target account's
+  /// credentials.
+  ///
+  /// Non-goal, by design: no simultaneous multi-account state. This is a
+  /// full teardown-and-reload of the active session every time, exactly
+  /// like [logout] already did - just without touching any *other* saved
+  /// account's stored credentials/prefs.
+  Future<void> _activateAccount(String accountId) async {
+    // Invalidates any fetch still in flight for the account being left, so
+    // a slow response can't land in the new account's state.
+    _sessionGeneration++;
+    // A pending "add account" flow can't stay pending through a manual
+    // switch/cycle - simplicity over blocking the gesture.
+    if (_loginFlowStatus != LoginFlowStatus.idle) cancelLoginFlow();
+
+    _notifyAccountCleared();
+    // Not `_isLoggedIn = false` - that would bounce main.dart's root
+    // routing through LoginView mid-switch. Each tab already shows its own
+    // spinner from its own loading state, so this alone is enough to
+    // avoid flashing the outgoing account's stale content.
+    _isLoading = true;
+    notifyListeners();
+
+    _activeAccountId = accountId;
+    final prefs = await prefsFuture;
+    await accountStore.saveActiveAccountId(prefs, accountId);
+    notifyListeners();
+
+    final account = _accounts.where((a) => a.id == accountId).firstOrNull;
+    final password = account == null
+        ? null
+        : await accountStore.readPassword(accountId);
+    if (account == null || password == null) {
+      _isLoading = false;
+      _isLoggedIn = false;
+      notifyListeners();
+      return;
+    }
+
+    await _applyCredentialsForAccount(account, password);
+  }
+
+  /// Switches to an already-saved account. No-op (returns true) if it's
+  /// already active and logged in; no-op (returns false) if unknown - but
+  /// if [accountId] is nominally "active" while [isLoggedIn] is false (a
+  /// session-restore that failed, e.g. transient network trouble at cold
+  /// start), this still retries rather than no-op, since that's exactly the
+  /// case LoginView's "Continue as" tile exists to recover from. Gated
+  /// behind login lock when [lockAccountSwitching] is on. Returns whether
+  /// the account ended up logged in, so callers (LoginView's saved-account
+  /// tile) can surface a failure - e.g. a stored app password that no
+  /// longer works and needs the account removed/re-added.
+  Future<bool> switchAccount(String accountId) async {
+    if (accountId == _activeAccountId && _isLoggedIn) return true;
+    if (!_accounts.any((a) => a.id == accountId)) return false;
+    if (!await passGate(_lockAccountSwitching, 'Unlock to switch accounts')) {
+      return false;
+    }
+    await _activateAccount(accountId);
+    return _isLoggedIn;
+  }
+
+  Future<SavedAccount?> _cycleAccount(int direction) async {
+    if (_accounts.length < 2) return null;
+    if (!await passGate(_lockAccountSwitching, 'Unlock to switch accounts')) {
+      return null;
+    }
+    final currentIndex = _accounts.indexWhere((a) => a.id == _activeAccountId);
+    final targetIndex = currentIndex == -1
+        ? 0
+        : (currentIndex + direction) % _accounts.length;
+    final target =
+        _accounts[(targetIndex + _accounts.length) % _accounts.length];
+    unawaited(_activateAccount(target.id));
+    return target;
+  }
+
+  /// Cycles to the next/previous saved account (by the order they were
+  /// added) - used by the avatar's swipe-up/down quick-switch gesture.
+  Future<SavedAccount?> cycleToNextAccount() => _cycleAccount(1);
+  Future<SavedAccount?> cycleToPreviousAccount() => _cycleAccount(-1);
+
+  /// Removes a saved account entirely: its stored password, its
+  /// namespaced prefs, and its entry in the saved-accounts list. If it was
+  /// the active account, falls back to another saved account, or - if none
+  /// remain - deactivates the session (the only path here that sets
+  /// [isLoggedIn] false; unlike [logout], there's nothing left to keep).
+  Future<void> removeAccount(String accountId) async {
+    final index = _accounts.indexWhere((a) => a.id == accountId);
+    if (index == -1) return;
+    final wasActive = accountId == _activeAccountId;
+
+    _accounts = [..._accounts]..removeAt(index);
+    final prefs = await prefsFuture;
+    await accountStore.saveAccounts(prefs, _accounts);
+    await accountStore.deletePassword(accountId);
+    for (final key in AccountStore.perAccountPrefKeys) {
+      await prefs.remove(accountStore.accountPrefKey(accountId, key));
+    }
+
+    if (!wasActive) {
+      notifyListeners();
+      return;
+    }
+
+    if (_accounts.isEmpty) {
+      await _deactivateSession();
+      return;
+    }
+
+    await _activateAccount(_accounts.first.id);
+  }
+
+  /// Clears the active session pointer and tears down its content, without
+  /// touching any saved account's own data - shared by [logout] (which
+  /// deliberately keeps the account around to resume later, no
+  /// re-authentication needed) and [removeAccount]'s "nothing left to fall
+  /// back to" branch (where the account's data has already been deleted by
+  /// the time this runs).
+  Future<void> _deactivateSession() async {
+    _sessionGeneration++;
+    _notifyAccountCleared();
+    _isLoggedIn = false;
+    _serverUrl = '';
+    _username = '';
+    _password = '';
+    _activeAccountId = null;
+    final prefs = await prefsFuture;
+    await accountStore.saveActiveAccountId(prefs, null);
+    notifyListeners();
+    unawaited(SyncService.cancel());
+  }
+
+  /// Ends the active session but keeps this account saved - unlike
+  /// [removeAccount], nothing is deleted (password, prefs, its entry in
+  /// [accounts] all remain), so it's available to resume with a single tap
+  /// from the login screen's saved-accounts list, no Login Flow v2 needed.
+  /// Always lands on the login screen even if other accounts are saved -
+  /// deliberately not the same as switching to one of them.
+  Future<void> logout() async {
+    if (_activeAccountId == null) return;
+    await _deactivateSession();
+  }
+
+  /// Confirms the device can do local auth and prompts once to enable login
+  /// lock. Returns false (leaving lock disabled) if the device has no
+  /// biometric/PIN capability or the user cancels/fails the confirmation.
+  Future<bool> setupLoginLock() async {
+    if (!await AppLockService.isDeviceSupported()) return false;
+    final confirmed = await AppLockService.authenticate(
+      'Confirm to turn on login lock',
+    );
+    if (!confirmed) return false;
+    _loginLockEnabled = true;
+    // Already just authenticated - don't immediately re-prompt behind it.
+    _isUnlocked = true;
+    notifyListeners();
+    prefsFuture.then((p) => p.setBool(_prefLoginLockEnabled, true));
+    return true;
+  }
+
+  /// Turns login lock off, along with both of its sub-toggles (meaningless
+  /// once the base lock is gone). Requires a successful auth first, same as
+  /// turning it on - otherwise anyone with momentary access to an unlocked
+  /// phone could just switch it off.
+  Future<bool> disableLoginLock() async {
+    if (!_loginLockEnabled) return true;
+    final confirmed = await AppLockService.authenticate(
+      'Confirm to turn off login lock',
+    );
+    if (!confirmed) return false;
+    _loginLockEnabled = false;
+    _lockAccountSwitching = false;
+    _lockHiddenFiles = false;
+    _isUnlocked = false;
+    notifyListeners();
+    prefsFuture.then((p) {
+      p.setBool(_prefLoginLockEnabled, false);
+      p.setBool(_prefLockAccountSwitching, false);
+      p.setBool(_prefLockHiddenFiles, false);
+    });
+    return true;
+  }
+
+  void setLockAccountSwitching(bool value) {
+    if (!_loginLockEnabled) return;
+    _lockAccountSwitching = value;
+    notifyListeners();
+    prefsFuture.then((p) => p.setBool(_prefLockAccountSwitching, value));
+  }
+
+  void setLockHiddenFiles(bool value) {
+    if (!_loginLockEnabled) return;
+    _lockHiddenFiles = value;
+    notifyListeners();
+    prefsFuture.then((p) => p.setBool(_prefLockHiddenFiles, value));
+  }
+
+  /// Called by the lock screen. Returns whether it actually unlocked.
+  Future<bool> attemptUnlock() async {
+    final success = await AppLockService.authenticate('Unlock Noo');
+    if (success) {
+      _isUnlocked = true;
+      notifyListeners();
+    }
+    return success;
+  }
+
+  /// Prompts for auth if [gate] is on and login lock is configured;
+  /// returns true immediately (no prompt) otherwise. Shared by the
+  /// account-switching gate above and [FilesController]'s/`PhotosController`'s
+  /// hidden-files gates.
+  Future<bool> passGate(bool gate, String reason) async {
+    if (!_loginLockEnabled || !gate) return true;
+    return AppLockService.authenticate(reason);
+  }
+
+  @override
+  void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
+    _pollTimer?.cancel();
+    _pollTimeoutTimer?.cancel();
+    super.dispose();
+  }
+}

lib/providers/settings_controller.dart

@@ -0,0 +1,327 @@
+import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/app_tab.dart';
+import '../theme/app_theme.dart';
+
+/// What swiping a Files list-view item left/right does, user-configurable
+/// in Settings.
+enum SwipeAction { none, favorite, delete, share }
+
+/// Thumb/track presets for the video player's seek bar, matching the four
+/// combinations offered by other Material You media players: a Material 3
+/// slider-style thumb ([classic]), an animated travelling wave with a round
+/// thumb ([wavy]), a thin flat bar with no distinct thumb ([slim]), and an
+/// animated wave with a tick-mark thumb ([squiggly]).
+enum MediaProgressBarStyle { classic, wavy, slim, squiggly }
+
+/// Global (not per-account) UI settings: theme, bottom-nav appearance, tab
+/// configuration, swipe actions. Independent of login state - these mean
+/// the same thing whether any account is signed in or not, unlike
+/// [FilesController]'s/etc. per-account display prefs. Split out of the
+/// former single `ServerProvider` god object.
+class SettingsController extends ChangeNotifier {
+  static const _prefThemeMode = 'ui_theme_mode';
+  static const _prefUseDynamicColor = 'ui_use_dynamic_color';
+  static const _prefSeedColor = 'ui_seed_color';
+  static const _prefBottomBarOpacity = 'ui_bottom_bar_opacity';
+  static const _prefBottomBarBlur = 'ui_bottom_bar_blur';
+  static const _prefTabOrder = 'ui_tab_order';
+  static const _prefHiddenTabs = 'ui_hidden_tabs';
+  static const _prefDefaultTab = 'ui_default_tab';
+  static const _prefSwipeLeftAction = 'ui_swipe_left_action';
+  static const _prefSwipeRightAction = 'ui_swipe_right_action';
+  static const _prefAmoledDark = 'ui_amoled_dark';
+  static const _prefMediaProgressBarStyle = 'ui_media_progress_bar_style';
+  static const _prefTapTabToScrollTop = 'ui_tap_tab_to_scroll_top';
+
+  final Future<SharedPreferences> _prefsFuture =
+      SharedPreferences.getInstance();
+
+  Color _seedColor = AppTheme.defaultNextcloudBlue;
+  ThemeMode _themeMode = ThemeMode.system;
+  bool _useDynamicColor = true;
+  bool _amoledDark = false;
+  MediaProgressBarStyle _mediaProgressBarStyle = MediaProgressBarStyle.wavy;
+
+  double _bottomBarOpacity = 0.55;
+  double _bottomBarBlur = 28;
+  bool _tapTabToScrollTop = true;
+
+  List<AppTab> _tabOrder = AppTab.values.toList();
+  Set<AppTab> _hiddenTabs = {};
+  AppTab _defaultTab = AppTab.files;
+
+  SwipeAction _swipeLeftAction = SwipeAction.delete;
+  SwipeAction _swipeRightAction = SwipeAction.favorite;
+
+  // A one-shot request for the shell to switch its active bottom-nav tab
+  // (e.g. a search result landing on Files) - consumed and cleared by
+  // MainShellView the next time it builds, not a persisted preference.
+  AppTab? _requestedTab;
+  AppTab? get requestedTab => _requestedTab;
+
+  /// Asks the shell to switch its active bottom-nav tab to [tab] - e.g. so
+  /// tapping a search result lands the user on the Files tab even if they
+  /// opened search from somewhere else.
+  void requestTab(AppTab tab) {
+    _requestedTab = tab;
+    notifyListeners();
+  }
+
+  /// Called by the shell once it's consumed [requestedTab].
+  void consumeRequestedTab() {
+    _requestedTab = null;
+  }
+
+  SettingsController() {
+    _load();
+  }
+
+  Color get seedColor => _seedColor;
+  ThemeMode get themeMode => _themeMode;
+  bool get useDynamicColor => _useDynamicColor;
+  bool get amoledDark => _amoledDark;
+  MediaProgressBarStyle get mediaProgressBarStyle => _mediaProgressBarStyle;
+  double get bottomBarOpacity => _bottomBarOpacity;
+  double get bottomBarBlur => _bottomBarBlur;
+  bool get tapTabToScrollTop => _tapTabToScrollTop;
+
+  /// Every tab in the user's configured order, including hidden ones — used
+  /// by the reorder/visibility settings UI.
+  List<AppTab> get tabOrder => _tabOrder;
+  Set<AppTab> get hiddenTabs => _hiddenTabs;
+  AppTab get defaultTab => _defaultTab;
+
+  /// The tabs the bottom nav bar should actually show, in order.
+  List<AppTab> get visibleTabs =>
+      _tabOrder.where((t) => !_hiddenTabs.contains(t)).toList();
+
+  SwipeAction get swipeLeftAction => _swipeLeftAction;
+  SwipeAction get swipeRightAction => _swipeRightAction;
+
+  Future<void> _load() async {
+    try {
+      final prefs = await _prefsFuture;
+
+      final themeModeName = prefs.getString(_prefThemeMode);
+      if (themeModeName != null) {
+        _themeMode = ThemeMode.values.firstWhere(
+          (m) => m.name == themeModeName,
+          orElse: () => ThemeMode.system,
+        );
+      }
+      _useDynamicColor =
+          prefs.getBool(_prefUseDynamicColor) ?? _useDynamicColor;
+      _amoledDark = prefs.getBool(_prefAmoledDark) ?? _amoledDark;
+      final progressBarStyleName = prefs.getString(_prefMediaProgressBarStyle);
+      if (progressBarStyleName != null) {
+        _mediaProgressBarStyle = MediaProgressBarStyle.values.firstWhere(
+          (s) => s.name == progressBarStyleName,
+          orElse: () => _mediaProgressBarStyle,
+        );
+      }
+      final seedColorValue = prefs.getInt(_prefSeedColor);
+      if (seedColorValue != null) _seedColor = Color(seedColorValue);
+      _bottomBarOpacity =
+          prefs.getDouble(_prefBottomBarOpacity) ?? _bottomBarOpacity;
+      _bottomBarBlur = prefs.getDouble(_prefBottomBarBlur) ?? _bottomBarBlur;
+      _tapTabToScrollTop =
+          prefs.getBool(_prefTapTabToScrollTop) ?? _tapTabToScrollTop;
+
+      final savedOrderNames = prefs.getStringList(_prefTabOrder);
+      if (savedOrderNames != null) {
+        final order = <AppTab>[];
+        for (final name in savedOrderNames) {
+          final match = AppTab.values.where((t) => t.name == name).firstOrNull;
+          if (match != null) order.add(match);
+        }
+        // Forward-compat: a tab added in a later app update won't be in an
+        // older saved order yet, so append anything missing.
+        for (final tab in AppTab.values) {
+          if (!order.contains(tab)) order.add(tab);
+        }
+        _tabOrder = order;
+      }
+
+      final savedHiddenNames = prefs.getStringList(_prefHiddenTabs);
+      if (savedHiddenNames != null) {
+        _hiddenTabs = savedHiddenNames
+            .map(
+              (name) => AppTab.values.where((t) => t.name == name).firstOrNull,
+            )
+            .whereType<AppTab>()
+            .toSet();
+        // Never let every tab end up hidden.
+        if (_hiddenTabs.length >= AppTab.values.length) {
+          _hiddenTabs = {};
+        }
+      }
+
+      final savedDefaultName = prefs.getString(_prefDefaultTab);
+      if (savedDefaultName != null) {
+        final match = AppTab.values
+            .where((t) => t.name == savedDefaultName)
+            .firstOrNull;
+        if (match != null) _defaultTab = match;
+      }
+      if (_hiddenTabs.contains(_defaultTab)) {
+        _defaultTab = _tabOrder.firstWhere(
+          (t) => !_hiddenTabs.contains(t),
+          orElse: () => _tabOrder.first,
+        );
+      }
+      _enforceMaxVisibleTabs();
+
+      final swipeLeftName = prefs.getString(_prefSwipeLeftAction);
+      if (swipeLeftName != null) {
+        _swipeLeftAction = SwipeAction.values.firstWhere(
+          (a) => a.name == swipeLeftName,
+          orElse: () => _swipeLeftAction,
+        );
+      }
+      final swipeRightName = prefs.getString(_prefSwipeRightAction);
+      if (swipeRightName != null) {
+        _swipeRightAction = SwipeAction.values.firstWhere(
+          (a) => a.name == swipeRightName,
+          orElse: () => _swipeRightAction,
+        );
+      }
+
+      notifyListeners();
+    } catch (e) {
+      debugPrint('[SettingsController] Preference restore failed: $e');
+    }
+  }
+
+  void setSeedColor(Color color) {
+    _seedColor = color;
+    _useDynamicColor = false;
+    notifyListeners();
+    _prefsFuture.then((p) {
+      p.setInt(_prefSeedColor, color.toARGB32());
+      p.setBool(_prefUseDynamicColor, false);
+    });
+  }
+
+  void setUseDynamicColor(bool value) {
+    _useDynamicColor = value;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setBool(_prefUseDynamicColor, value));
+  }
+
+  void setAmoledDark(bool value) {
+    _amoledDark = value;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setBool(_prefAmoledDark, value));
+  }
+
+  void setMediaProgressBarStyle(MediaProgressBarStyle style) {
+    _mediaProgressBarStyle = style;
+    notifyListeners();
+    _prefsFuture.then(
+      (p) => p.setString(_prefMediaProgressBarStyle, style.name),
+    );
+  }
+
+  void setBottomBarOpacity(double value) {
+    _bottomBarOpacity = value;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setDouble(_prefBottomBarOpacity, value));
+  }
+
+  void setBottomBarBlur(double value) {
+    _bottomBarBlur = value;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setDouble(_prefBottomBarBlur, value));
+  }
+
+  void setTapTabToScrollTop(bool value) {
+    _tapTabToScrollTop = value;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setBool(_prefTapTabToScrollTop, value));
+  }
+
+  void setThemeMode(ThemeMode mode) {
+    _themeMode = mode;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setString(_prefThemeMode, mode.name));
+  }
+
+  void setTabOrder(List<AppTab> order) {
+    _tabOrder = order;
+    notifyListeners();
+    _prefsFuture.then(
+      (p) => p.setStringList(_prefTabOrder, order.map((t) => t.name).toList()),
+    );
+  }
+
+  /// Shows or hides a tab in the bottom nav bar. Refuses to hide the last
+  /// remaining visible tab. If the tab being hidden is the current default,
+  /// the default falls back to the next visible tab.
+  /// Returns null on success, or a user-facing reason the change was
+  /// refused (hiding the last visible tab, or showing a 6th).
+  String? setTabHidden(AppTab tab, bool hidden) {
+    if (hidden) {
+      final remaining = _tabOrder
+          .where((t) => t != tab && !_hiddenTabs.contains(t))
+          .length;
+      if (remaining == 0) return 'At least one tab must stay visible';
+      _hiddenTabs = {..._hiddenTabs, tab};
+      if (_defaultTab == tab) {
+        _defaultTab = _tabOrder.firstWhere((t) => !_hiddenTabs.contains(t));
+        _prefsFuture.then(
+          (p) => p.setString(_prefDefaultTab, _defaultTab.name),
+        );
+      }
+    } else {
+      final currentlyVisible = _tabOrder
+          .where((t) => !_hiddenTabs.contains(t))
+          .length;
+      if (currentlyVisible >= maxVisibleTabs) {
+        return 'You can only show up to $maxVisibleTabs tabs at once';
+      }
+      _hiddenTabs = {..._hiddenTabs}..remove(tab);
+    }
+    notifyListeners();
+    _prefsFuture.then(
+      (p) => p.setStringList(
+        _prefHiddenTabs,
+        _hiddenTabs.map((t) => t.name).toList(),
+      ),
+    );
+    return null;
+  }
+
+  /// If more than [maxVisibleTabs] end up visible (e.g. a fresh install, or
+  /// an existing saved config from before a new tab was added to the app),
+  /// hide the overflow automatically rather than exceeding the cap.
+  void _enforceMaxVisibleTabs() {
+    final visible = _tabOrder.where((t) => !_hiddenTabs.contains(t)).toList();
+    if (visible.length <= maxVisibleTabs) return;
+    _hiddenTabs = {..._hiddenTabs, ...visible.sublist(maxVisibleTabs)};
+    if (_hiddenTabs.contains(_defaultTab)) {
+      _defaultTab = _tabOrder.firstWhere((t) => !_hiddenTabs.contains(t));
+    }
+  }
+
+  void setDefaultTab(AppTab tab) {
+    if (_hiddenTabs.contains(tab) || _defaultTab == tab) return;
+    _defaultTab = tab;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setString(_prefDefaultTab, tab.name));
+  }
+
+  void setSwipeLeftAction(SwipeAction action) {
+    if (_swipeLeftAction == action) return;
+    _swipeLeftAction = action;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setString(_prefSwipeLeftAction, action.name));
+  }
+
+  void setSwipeRightAction(SwipeAction action) {
+    if (_swipeRightAction == action) return;
+    _swipeRightAction = action;
+    notifyListeners();
+    _prefsFuture.then((p) => p.setString(_prefSwipeRightAction, action.name));
+  }
+}

lib/providers/shares_controller.dart

@@ -0,0 +1,81 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import '../models/nextcloud_share.dart';
+import 'session_controller.dart';
+
+/// The Shares tab. Kept separate from Files' own loading/error state,
+/// likewise.
+class SharesController extends ChangeNotifier {
+  final SessionController session;
+
+  List<NextcloudShare> _shares = [];
+  bool _isLoading = false;
+  String? _errorMessage;
+  bool _sharedWithMe = false;
+
+  SharesController(this.session) {
+    session.addAccountClearedListener(_onAccountCleared);
+    session.addAccountActivatedListener(_onAccountActivated);
+  }
+
+  List<NextcloudShare> get shares => _shares;
+  bool get isLoading => _isLoading;
+  String? get errorMessage => _errorMessage;
+  bool get sharedWithMe => _sharedWithMe;
+
+  void _onAccountCleared() {
+    _shares = [];
+    _isLoading = false;
+    _errorMessage = null;
+    _sharedWithMe = false;
+    notifyListeners();
+  }
+
+  void _onAccountActivated() {
+    unawaited(fetchAll());
+  }
+
+  Future<void> fetchAll() async {
+    final service = session.service;
+    if (!session.isLoggedIn || service == null) return;
+    final gen = session.sessionGeneration;
+
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    try {
+      final shares = await service.fetchShares(sharedWithMe: _sharedWithMe);
+      if (gen != session.sessionGeneration) return;
+      _shares = shares;
+    } catch (e) {
+      if (gen != session.sessionGeneration) return;
+      debugPrint('[SharesController] Error fetching shares: $e');
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+    } finally {
+      if (gen == session.sessionGeneration) {
+        _isLoading = false;
+        notifyListeners();
+      }
+    }
+  }
+
+  /// Switches between "shared by me" and "shared with me" and refetches.
+  void setSharedWithMe(bool value) {
+    if (_sharedWithMe == value) return;
+    _sharedWithMe = value;
+    notifyListeners();
+    fetchAll();
+  }
+
+  Future<bool> deleteShare(NextcloudShare share) async {
+    final service = session.service;
+    if (service == null) return false;
+    final success = await service.deleteShare(share.id);
+    if (success) {
+      _shares = _shares.where((s) => s.id != share.id).toList();
+      notifyListeners();
+    }
+    return success;
+  }
+}

lib/providers/sync_status_controller.dart

@@ -0,0 +1,215 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import '../models/nextcloud_item.dart';
+import '../models/sync_status.dart';
+import '../services/sync_service.dart';
+import 'session_controller.dart';
+
+/// Device-sync state and settings: which remote paths (files or folders,
+/// per account) get mirrored locally by the native `SyncWorker`, whether
+/// its periodic background runs are allowed on cellular, and live status
+/// pushed from `SyncStatusBus.kt` (syncing-now/per-file-syncing/synced/
+/// conflicts) - see `server.md`'s "Device sync" section. Split out of the
+/// former single `ServerProvider` god object specifically because this
+/// state used to reach directly into Files/Photos/Favorites item lists
+/// (`syncStatusFor`) despite living in an unrelated domain; now it's a
+/// second, focused provider those views read alongside their own tab
+/// controller.
+class SyncStatusController extends ChangeNotifier {
+  final SessionController session;
+
+  static const _prefSyncedPaths = 'ui_synced_folders';
+  static const _prefSyncEverything = 'ui_sync_everything';
+  static const _prefSyncOnCellular = 'ui_sync_on_cellular';
+
+  List<String> _syncedPaths = [];
+  bool _syncEverything = false;
+  bool _syncOnCellular = false;
+
+  bool _isSyncingNow = false;
+  Set<String> _syncingFileIds = {};
+  Set<String> _syncedFileIds = {};
+  List<SyncConflictInfo> _syncConflicts = [];
+  StreamSubscription<SyncStatusSnapshot>? _statusSub;
+
+  SyncStatusController(this.session) {
+    session.addAccountClearedListener(_onAccountCleared);
+    session.addAccountActivatedListener(_onAccountActivated);
+    _statusSub = SyncService.statusStream.listen(_applySnapshot);
+    _loadGlobalPrefs();
+  }
+
+  List<String> get syncedPaths => List.unmodifiable(_syncedPaths);
+  bool get syncEverything => _syncEverything;
+  bool get syncOnCellular => _syncOnCellular;
+
+  bool get isSyncingNow => _isSyncingNow;
+  List<SyncConflictInfo> get syncConflicts => List.unmodifiable(_syncConflicts);
+
+  SyncHeaderStatus get syncHeaderStatus {
+    if (_syncConflicts.isNotEmpty) return SyncHeaderStatus.alert;
+    if (_isSyncingNow) return SyncHeaderStatus.syncing;
+    if (!_syncEverything && _syncedPaths.isEmpty) return SyncHeaderStatus.off;
+    return SyncHeaderStatus.done;
+  }
+
+  SyncItemStatus syncStatusFor(NextcloudItem item) {
+    if (_syncingFileIds.contains(item.id)) return SyncItemStatus.syncing;
+    if (_syncConflicts.any((c) => c.fileId == item.id)) {
+      return SyncItemStatus.conflict;
+    }
+    if (_syncedFileIds.contains(item.id)) return SyncItemStatus.synced;
+    return SyncItemStatus.none;
+  }
+
+  Future<void> _loadGlobalPrefs() async {
+    final prefs = await session.prefsFuture;
+    _syncOnCellular = prefs.getBool(_prefSyncOnCellular) ?? _syncOnCellular;
+    notifyListeners();
+  }
+
+  void _onAccountCleared() {
+    _syncedPaths = [];
+    _syncEverything = false;
+    _isSyncingNow = false;
+    _syncingFileIds = {};
+    _syncedFileIds = {};
+    _syncConflicts = [];
+    notifyListeners();
+  }
+
+  Future<void> _onAccountActivated() async {
+    final id = session.activeAccountId;
+    if (id != null) {
+      final prefs = await session.prefsFuture;
+      String k(String base) => session.accountStore.accountPrefKey(id, base);
+      final pathsJson = prefs.getString(k(_prefSyncedPaths));
+      if (pathsJson != null) {
+        try {
+          _syncedPaths = (jsonDecode(pathsJson) as List).cast<String>();
+        } catch (e) {
+          debugPrint('[SyncStatusController] Synced paths restore failed: $e');
+          _syncedPaths = [];
+        }
+      } else {
+        _syncedPaths = [];
+      }
+      _syncEverything = prefs.getBool(k(_prefSyncEverything)) ?? false;
+      notifyListeners();
+    }
+    unawaited(SyncService.reschedule(session, this));
+    unawaited(SyncService.getStatus().then(_applySnapshot));
+  }
+
+  void _applySnapshot(SyncStatusSnapshot snapshot) {
+    if (snapshot.accountId != null &&
+        snapshot.accountId != session.activeAccountId) {
+      return;
+    }
+    _isSyncingNow = snapshot.syncing;
+    _syncingFileIds = snapshot.syncingFileIds;
+    _syncedFileIds = snapshot.syncedFileIds;
+    _syncConflicts = snapshot.conflicts;
+    notifyListeners();
+  }
+
+  void _persistSyncedPaths() {
+    final id = session.activeAccountId;
+    if (id == null) return;
+    session.prefsFuture.then(
+      (p) => p.setString(
+        session.accountStore.accountPrefKey(id, _prefSyncedPaths),
+        jsonEncode(_syncedPaths),
+      ),
+    );
+  }
+
+  bool isPathSynced(String path) => _syncedPaths.contains(path);
+
+  void addSyncedPath(String path) {
+    if (_syncedPaths.contains(path)) return;
+    _syncedPaths = [..._syncedPaths, path];
+    notifyListeners();
+    _persistSyncedPaths();
+    unawaited(SyncService.reschedule(session, this));
+  }
+
+  void removeSyncedPath(String path) {
+    if (!_syncedPaths.contains(path)) return;
+    _syncedPaths = _syncedPaths.where((f) => f != path).toList();
+    notifyListeners();
+    _persistSyncedPaths();
+    unawaited(SyncService.reschedule(session, this));
+  }
+
+  void setSyncEverything(bool value) {
+    if (_syncEverything == value) return;
+    _syncEverything = value;
+    notifyListeners();
+    final id = session.activeAccountId;
+    if (id != null) {
+      session.prefsFuture.then(
+        (p) => p.setBool(
+          session.accountStore.accountPrefKey(id, _prefSyncEverything),
+          value,
+        ),
+      );
+    }
+    unawaited(SyncService.reschedule(session, this));
+  }
+
+  void setSyncOnCellular(bool value) {
+    if (_syncOnCellular == value) return;
+    _syncOnCellular = value;
+    notifyListeners();
+    session.prefsFuture.then((p) => p.setBool(_prefSyncOnCellular, value));
+    unawaited(SyncService.reschedule(session, this));
+  }
+
+  /// In-app conflict resolution (the sync header's "Keep local"/"Use
+  /// server" buttons) - see `SyncService.resolveConflict`'s doc comment
+  /// for why this shares the exact same native path the notification
+  /// actions use.
+  Future<void> resolveSyncConflict(
+    SyncConflictInfo conflict, {
+    required bool useLocal,
+  }) {
+    return SyncService.resolveConflict(
+      session,
+      conflict,
+      useLocal ? 'local' : 'server',
+    );
+  }
+
+  /// The local mirror path for [item] if it falls under a synced folder
+  /// *and* has actually been synced down already - a pure function of the
+  /// remote path once a folder's marked synced (mirrors
+  /// `SyncEngine.kt#syncRoot`'s `<externalFilesDir>/sync/<accountId>/...`
+  /// layout exactly), so this never needs to read the native sync-state
+  /// SharedPreferences from Dart. Callers (Share/Download) use this to
+  /// skip a fresh WebDAV fetch when a local copy already exists.
+  Future<String?> localSyncedFilePath(NextcloudItem item) async {
+    final id = session.activeAccountId;
+    if (id == null) return null;
+    final itemPath = item.path.endsWith('/')
+        ? item.path.substring(0, item.path.length - 1)
+        : item.path;
+    final isSynced =
+        _syncEverything ||
+        _syncedPaths.any((folder) {
+          final f = folder.endsWith('/')
+              ? folder.substring(0, folder.length - 1)
+              : folder;
+          return itemPath == f || itemPath.startsWith('$f/');
+        });
+    if (!isSynced) return null;
+    return SyncService.localSyncedFilePath(id, item.path);
+  }
+
+  @override
+  void dispose() {
+    _statusSub?.cancel();
+    super.dispose();
+  }
+}

lib/providers/trash_controller.dart

@@ -0,0 +1,84 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import '../models/nextcloud_item.dart';
+import 'session_controller.dart';
+
+/// The Trash tab. Kept separate from Files' own loading/error state so a
+/// trash-fetch failure can't bleed a stale error into Files.
+class TrashController extends ChangeNotifier {
+  final SessionController session;
+
+  List<NextcloudItem> _items = [];
+  bool _isLoading = false;
+  String? _errorMessage;
+
+  TrashController(this.session) {
+    session.addAccountClearedListener(_onAccountCleared);
+    session.addAccountActivatedListener(_onAccountActivated);
+  }
+
+  List<NextcloudItem> get items => _items;
+  bool get isLoading => _isLoading;
+  String? get errorMessage => _errorMessage;
+
+  void _onAccountCleared() {
+    _items = [];
+    _isLoading = false;
+    _errorMessage = null;
+    notifyListeners();
+  }
+
+  void _onAccountActivated() {
+    unawaited(fetchAll());
+  }
+
+  Future<void> fetchAll() async {
+    final service = session.service;
+    if (!session.isLoggedIn || service == null) return;
+    final gen = session.sessionGeneration;
+
+    _isLoading = true;
+    _errorMessage = null;
+    notifyListeners();
+
+    try {
+      final trash = await service.fetchTrash();
+      if (gen != session.sessionGeneration) return;
+      _items = trash;
+    } catch (e) {
+      if (gen != session.sessionGeneration) return;
+      debugPrint('[TrashController] Error fetching trash: $e');
+      _errorMessage = e.toString().replaceAll('Exception: ', '');
+    } finally {
+      if (gen == session.sessionGeneration) {
+        _isLoading = false;
+        notifyListeners();
+      }
+    }
+  }
+
+  /// Restores a trashed item (identified by [NextcloudItem.path], the
+  /// trash-relative name) back to where it was deleted from.
+  Future<bool> restore(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return false;
+    final success = await service.restoreTrashItem(item.path);
+    if (success) {
+      _items = _items.where((i) => i.id != item.id).toList();
+      notifyListeners();
+    }
+    return success;
+  }
+
+  /// Permanently deletes a trashed item. Cannot be undone.
+  Future<bool> deleteForever(NextcloudItem item) async {
+    final service = session.service;
+    if (service == null) return false;
+    final success = await service.deleteTrashItemForever(item.path);
+    if (success) {
+      _items = _items.where((i) => i.id != item.id).toList();
+      notifyListeners();
+    }
+    return success;
+  }
+}

lib/services/download_service.dart

@@ -1,7 +1,8 @@
 import 'dart:convert';
 import 'package:flutter/services.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/session_controller.dart';
+import 'native_channel.dart';
 
 /// Hands a download off to `DownloadService.kt`'s Android foreground
 /// service - the download counterpart of `UploadService`/
@@ -20,15 +21,10 @@ class DownloadService {
   /// progress/completion/cancellation through its own notification, not
   /// back to the app.
   static Future<void> startDownload(
-    ServerProvider provider,
+    SessionController session,
     List<NextcloudItem> items,
   ) async {
-    final service = provider.service;
-    final authHeader = service?.authHeaders['Authorization'];
-    if (service == null || authHeader == null) {
-      throw Exception('Not logged in.');
-    }
-
+    final args = baseChannelArgs(session);
     final filesJson = jsonEncode(
       items
           .map(
@@ -42,11 +38,6 @@ class DownloadService {
           .toList(),
     );
 
-    await _channel.invokeMethod('startDownload', {
-      'files': filesJson,
-      'serverUrl': provider.serverUrl,
-      'username': provider.username,
-      'authHeader': authHeader,
-    });
+    await _channel.invokeMethod('startDownload', {...args, 'files': filesJson});
   }
 }

lib/services/native_channel.dart

@@ -0,0 +1,23 @@
+import '../providers/session_controller.dart';
+
+/// The "get this account's auth header, or bail" guard every native-
+/// MethodChannel service (`UploadService`/`DownloadService`/`SyncService`)
+/// needs before handing a batch off to Kotlin - was independently repeated
+/// in each of them.
+String requireAuthHeader(SessionController session) {
+  final authHeader = session.service?.authHeaders['Authorization'];
+  if (session.service == null || authHeader == null) {
+    throw Exception('Not logged in.');
+  }
+  return authHeader;
+}
+
+/// The `{serverUrl, username, authHeader}` trio every one of those
+/// services' `invokeMethod` argument maps includes.
+Map<String, String> baseChannelArgs(SessionController session) {
+  return {
+    'serverUrl': session.serverUrl,
+    'username': session.username,
+    'authHeader': requireAuthHeader(session),
+  };
+}

lib/services/sync_service.dart

@@ -1,7 +1,11 @@
 import 'dart:convert';
+import 'dart:io';
 import 'package:flutter/services.dart';
+import 'package:path/path.dart' as p;
+import 'package:path_provider/path_provider.dart';
 import '../models/sync_status.dart';
-import '../providers/server_provider.dart';
+import '../providers/session_controller.dart';
+import '../providers/sync_status_controller.dart';
 
 /// A snapshot of native device-sync status - see `SyncStatusBus.kt` (the
 /// in-process pub/sub it mirrors) and `MainActivity.kt`'s `syncStatusMap`.
@@ -43,34 +47,38 @@ class SyncStatusSnapshot {
 /// Dart's job here is only to gather what the native side needs, push a
 /// fresh config whenever it changes, and listen for live status; the actual
 /// PROPFIND-walk/diff/GET/PUT engine runs entirely in Kotlin, independent
-/// of the Flutter engine.
+/// of the Flutter engine. Takes [SessionController]/[SyncStatusController]
+/// directly rather than a single god-object provider, since those are the
+/// only two domains this ever needs.
 class SyncService {
   static const _channel = MethodChannel('dev.ayushya.noo/sync_service');
   static const _statusChannel = EventChannel(
     'dev.ayushya.noo/sync_service/status',
   );
 
-  /// Cancels (if [ServerProvider.syncedPaths] is now empty) or re-enqueues
-  /// the periodic sync job with fresh account/credentials/path-list/
-  /// network-constraint data - call this any time one of those changes,
-  /// since a periodic `WorkRequest`'s input is fixed at enqueue time and
-  /// can only be updated by re-enqueueing.
-  static Future<void> reschedule(ServerProvider provider) async {
-    final accountId = provider.activeAccountId;
-    final service = provider.service;
-    final authHeader = service?.authHeaders['Authorization'];
-    if (accountId == null || service == null || authHeader == null) {
+  /// Cancels (if [SyncStatusController.syncedPaths] is now empty) or
+  /// re-enqueues the periodic sync job with fresh account/credentials/
+  /// path-list/network-constraint data - call this any time one of those
+  /// changes, since a periodic `WorkRequest`'s input is fixed at enqueue
+  /// time and can only be updated by re-enqueueing.
+  static Future<void> reschedule(
+    SessionController session,
+    SyncStatusController sync,
+  ) async {
+    final accountId = session.activeAccountId;
+    final authHeader = session.service?.authHeaders['Authorization'];
+    if (accountId == null || authHeader == null) {
       return cancel();
     }
 
-    final paths = provider.syncEverything ? ['/'] : provider.syncedPaths;
+    final paths = sync.syncEverything ? ['/'] : sync.syncedPaths;
     await _channel.invokeMethod('reschedule', {
       'accountId': accountId,
-      'serverUrl': provider.serverUrl,
-      'username': provider.username,
+      'serverUrl': session.serverUrl,
+      'username': session.username,
       'authHeader': authHeader,
       'folders': jsonEncode(paths),
-      'wifiOnly': !provider.syncOnCellular,
+      'wifiOnly': !sync.syncOnCellular,
     });
   }
 
@@ -80,27 +88,29 @@ class SyncService {
 
   /// Runs a one-off sync pass immediately (Settings' "Sync now"),
   /// independent of the periodic schedule.
-  static Future<void> syncNow(ServerProvider provider) async {
-    final accountId = provider.activeAccountId;
-    final service = provider.service;
-    final authHeader = service?.authHeaders['Authorization'];
-    if (accountId == null || service == null || authHeader == null) {
+  static Future<void> syncNow(
+    SessionController session,
+    SyncStatusController sync,
+  ) async {
+    final accountId = session.activeAccountId;
+    final authHeader = session.service?.authHeaders['Authorization'];
+    if (accountId == null || authHeader == null) {
       throw Exception('Not logged in.');
     }
 
-    final paths = provider.syncEverything ? ['/'] : provider.syncedPaths;
+    final paths = sync.syncEverything ? ['/'] : sync.syncedPaths;
     await _channel.invokeMethod('syncNow', {
       'accountId': accountId,
-      'serverUrl': provider.serverUrl,
-      'username': provider.username,
+      'serverUrl': session.serverUrl,
+      'username': session.username,
       'authHeader': authHeader,
       'folders': jsonEncode(paths),
     });
   }
 
-  /// One-shot status snapshot - used to seed [ServerProvider]'s state right
-  /// after login/account-switch, before the first [statusStream] event
-  /// arrives.
+  /// One-shot status snapshot - used to seed [SyncStatusController]'s state
+  /// right after login/account-switch, before the first [statusStream]
+  /// event arrives.
   static Future<SyncStatusSnapshot> getStatus() async {
     final result = await _channel.invokeMethod<Map<dynamic, dynamic>>(
       'getSyncStatus',
@@ -121,19 +131,16 @@ class SyncService {
   /// enqueue path the notification actions use, just triggered from Dart
   /// instead of a `PendingIntent`.
   static Future<void> resolveConflict(
-    ServerProvider provider,
+    SessionController session,
     SyncConflictInfo conflict,
     String resolution,
   ) async {
-    final service = provider.service;
-    final authHeader = service?.authHeaders['Authorization'];
-    if (service == null || authHeader == null) {
-      throw Exception('Not logged in.');
-    }
+    final authHeader = session.service?.authHeaders['Authorization'];
+    if (authHeader == null) throw Exception('Not logged in.');
     await _channel.invokeMethod('resolveConflict', {
       'accountId': conflict.accountId,
-      'serverUrl': provider.serverUrl,
-      'username': provider.username,
+      'serverUrl': session.serverUrl,
+      'username': session.username,
       'authHeader': authHeader,
       'fileId': conflict.fileId,
       'remotePath': conflict.remotePath,
@@ -141,4 +148,22 @@ class SyncService {
       'resolution': resolution,
     });
   }
+
+  /// The deterministic local mirror path for [remoteItemPath] under
+  /// account [accountId] - mirrors `SyncEngine.kt#syncRoot`'s
+  /// `<externalFilesDir>/sync/<accountId>/...` layout exactly, so this
+  /// never needs to read native sync state. Returns null if nothing's
+  /// actually been synced there yet.
+  static Future<String?> localSyncedFilePath(
+    String accountId,
+    String remoteItemPath,
+  ) async {
+    final base = await getExternalStorageDirectory();
+    if (base == null) return null;
+    final relPath = remoteItemPath.startsWith('/')
+        ? remoteItemPath.substring(1)
+        : remoteItemPath;
+    final file = File(p.join(base.path, 'sync', accountId, relPath));
+    return file.existsSync() ? file.path : null;
+  }
 }

lib/services/upload_service.dart

@@ -1,6 +1,8 @@
 import 'dart:convert';
 import 'package:flutter/services.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/session_controller.dart';
+import 'native_channel.dart';
 import 'share_intent_service.dart';
 
 /// Hands a "Share to Noo" upload off to `ShareUploadService.kt`'s Android
@@ -18,25 +20,21 @@ class UploadService {
   /// service owns the rest and reports progress/completion/cancellation
   /// through its own notification, not back to the app.
   static Future<void> startUpload(
-    ServerProvider provider,
-    List<SharedFileRef> files,
+    SessionController session,
+    FilesController files,
+    List<SharedFileRef> sharedFiles,
   ) async {
-    final service = provider.service;
-    final authHeader = service?.authHeaders['Authorization'];
-    if (service == null || authHeader == null) {
-      throw Exception('Not logged in.');
-    }
-
+    final args = baseChannelArgs(session);
     final filesJson = jsonEncode(
-      files.map((f) => {'uri': f.uri, 'name': f.name, 'size': f.size}).toList(),
+      sharedFiles
+          .map((f) => {'uri': f.uri, 'name': f.name, 'size': f.size})
+          .toList(),
     );
 
     await _channel.invokeMethod('startUpload', {
+      ...args,
       'files': filesJson,
-      'serverUrl': provider.serverUrl,
-      'username': provider.username,
-      'authHeader': authHeader,
-      'remoteFolder': provider.currentFolderPath,
+      'remoteFolder': files.currentFolderPath,
     });
   }
 }

lib/views/account_view.dart

@@ -2,7 +2,10 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import '../models/app_tab.dart';
 import '../models/saved_account.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/session_controller.dart';
+import '../providers/settings_controller.dart';
+import '../providers/sync_status_controller.dart';
 import '../services/sync_service.dart';
 import '../theme/app_theme.dart';
 import '../widgets/frosted_glass_container.dart';
@@ -17,8 +20,10 @@ class AccountView extends StatelessWidget {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
-    final quota = provider.quota;
+    final session = context.watch<SessionController>();
+    final settings = context.watch<SettingsController>();
+    final files = context.watch<FilesController>();
+    final quota = files.quota;
 
     return Scaffold(
       appBar: AppBar(title: const Text('Settings')),
@@ -46,7 +51,7 @@ class AccountView extends StatelessWidget {
                         radius: 28,
                         backgroundColor: colorScheme.primary,
                         child: Text(
-                          (quota?.userName ?? provider.username)
+                          (quota?.userName ?? session.username)
                               .substring(0, 1)
                               .toUpperCase(),
                           style: theme.textTheme.headlineSmall?.copyWith(
@@ -61,14 +66,14 @@ class AccountView extends StatelessWidget {
                           crossAxisAlignment: CrossAxisAlignment.start,
                           children: [
                             Text(
-                              quota?.userName ?? provider.username,
+                              quota?.userName ?? session.username,
                               style: theme.textTheme.titleMedium?.copyWith(
                                 fontWeight: FontWeight.w700,
                               ),
                             ),
                             const SizedBox(height: 2),
                             Text(
-                              quota?.email ?? provider.username,
+                              quota?.email ?? session.username,
                               style: theme.textTheme.bodySmall?.copyWith(
                                 color: colorScheme.onSurfaceVariant,
                               ),
@@ -119,8 +124,8 @@ class AccountView extends StatelessWidget {
                     children: [
                       Expanded(
                         child: Text(
-                          Uri.tryParse(provider.serverUrl)?.host ??
-                              provider.serverUrl,
+                          Uri.tryParse(session.serverUrl)?.host ??
+                              session.serverUrl,
                           maxLines: 1,
                           overflow: TextOverflow.ellipsis,
                           style: theme.textTheme.bodySmall?.copyWith(
@@ -185,7 +190,7 @@ class AccountView extends StatelessWidget {
                         icon: const Icon(Icons.refresh_rounded),
                         tooltip: 'Refresh cached data',
                         onPressed: () async {
-                          await provider.refreshData();
+                          await files.refreshData();
                           if (context.mounted) {
                             ScaffoldMessenger.of(context).showSnackBar(
                               const SnackBar(
@@ -200,14 +205,14 @@ class AccountView extends StatelessWidget {
                         icon: const Icon(Icons.logout_rounded),
                         tooltip: 'Logout',
                         color: Colors.orange.shade700,
-                        onPressed: () => _handleLogout(context, provider),
+                        onPressed: () => _handleLogout(context, session),
                       ),
                       IconButton(
                         icon: const Icon(Icons.delete_outline_rounded),
                         tooltip: 'Remove account',
                         color: colorScheme.error,
                         onPressed: () =>
-                            _confirmRemoveActive(context, provider),
+                            _confirmRemoveActive(context, session),
                       ),
                     ],
                   ),
@@ -271,7 +276,7 @@ class AccountView extends StatelessWidget {
                     ),
                     const SizedBox(height: 4),
                     Text(
-                      provider.useDynamicColor
+                      settings.useDynamicColor
                           ? 'Matching your wallpaper'
                           : 'Custom color',
                       style: theme.textTheme.bodySmall?.copyWith(
@@ -283,8 +288,8 @@ class AccountView extends StatelessWidget {
                       mainAxisAlignment: MainAxisAlignment.spaceAround,
                       children: [
                         _AccentSwatch(
-                          isSelected: provider.useDynamicColor,
-                          onTap: () => provider.setUseDynamicColor(true),
+                          isSelected: settings.useDynamicColor,
+                          onTap: () => settings.setUseDynamicColor(true),
                           borderColor: colorScheme.onSurface,
                           background: colorScheme.surfaceContainerHighest,
                           child: Icon(
@@ -295,11 +300,11 @@ class AccountView extends StatelessWidget {
                         ),
                         ...AppTheme.seedColors.map((color) {
                           final isSelected =
-                              !provider.useDynamicColor &&
-                              provider.seedColor == color;
+                              !settings.useDynamicColor &&
+                              settings.seedColor == color;
                           return _AccentSwatch(
                             isSelected: isSelected,
-                            onTap: () => provider.setSeedColor(color),
+                            onTap: () => settings.setSeedColor(color),
                             borderColor: colorScheme.onSurface,
                             background: color,
                             child: isSelected
@@ -343,9 +348,9 @@ class AccountView extends StatelessWidget {
                             label: Text('Dark'),
                           ),
                         ],
-                        selected: {provider.themeMode},
+                        selected: {settings.themeMode},
                         onSelectionChanged: (set) =>
-                            provider.setThemeMode(set.first),
+                            settings.setThemeMode(set.first),
                       ),
                     ),
                     const SizedBox(height: 8),
@@ -355,8 +360,8 @@ class AccountView extends StatelessWidget {
                       subtitle: const Text(
                         'Use pure black backgrounds in dark mode',
                       ),
-                      value: provider.amoledDark,
-                      onChanged: provider.setAmoledDark,
+                      value: settings.amoledDark,
+                      onChanged: settings.setAmoledDark,
                     ),
                   ],
                 ),
@@ -380,8 +385,8 @@ class AccountView extends StatelessWidget {
                 subtitle: const Text(
                   'Tapping the current bottom bar tab scrolls its list back to the top',
                 ),
-                value: provider.tapTabToScrollTop,
-                onChanged: provider.setTapTabToScrollTop,
+                value: settings.tapTabToScrollTop,
+                onChanged: settings.setTapTabToScrollTop,
               ),
             ),
             const SizedBox(height: 24),
@@ -462,24 +467,24 @@ class AccountView extends StatelessWidget {
     );
   }
 
-  /// Logout keeps the account saved (see [ServerProvider.logout]) so it's
-  /// harmless/reversible from a one-tap resume on the login screen -
+  /// Logout keeps the account saved (see [SessionController.logout]) so
+  /// it's harmless/reversible from a one-tap resume on the login screen -
   /// doesn't need a confirmation dialog the way [_confirmRemoveActive] does.
   Future<void> _handleLogout(
     BuildContext context,
-    ServerProvider provider,
+    SessionController session,
   ) async {
     final navigator = Navigator.of(context);
-    await provider.logout();
+    await session.logout();
     navigator.popUntil((route) => route.isFirst);
   }
 
   Future<void> _confirmRemoveActive(
     BuildContext context,
-    ServerProvider provider,
+    SessionController session,
   ) async {
-    final host = Uri.tryParse(provider.serverUrl)?.host ?? provider.serverUrl;
-    final hasOtherAccounts = provider.accounts.length > 1;
+    final host = Uri.tryParse(session.serverUrl)?.host ?? session.serverUrl;
+    final hasOtherAccounts = session.accounts.length > 1;
     final confirmed = await showDialog<bool>(
       context: context,
       builder: (dialogContext) {
@@ -487,8 +492,8 @@ class AccountView extends StatelessWidget {
           title: const Text('Remove Account'),
           content: Text(
             hasOtherAccounts
-                ? 'Remove ${provider.username} ($host)? Another saved account will become active.'
-                : 'Remove ${provider.username} ($host)? You can add it again later.',
+                ? 'Remove ${session.username} ($host)? Another saved account will become active.'
+                : 'Remove ${session.username} ($host)? You can add it again later.',
           ),
           actions: [
             TextButton(
@@ -507,15 +512,15 @@ class AccountView extends StatelessWidget {
       },
     );
     if (confirmed != true) return;
-    final id = provider.activeAccountId;
+    final id = session.activeAccountId;
     if (id == null) return;
     if (!context.mounted) return;
     final navigator = Navigator.of(context);
-    await provider.removeAccount(id);
+    await session.removeAccount(id);
     // Only pop back to the root route if that was the last account and the
     // session actually ended - if it fell back to another saved account,
     // Settings just keeps showing (now for that account) instead.
-    if (!provider.isLoggedIn) {
+    if (!session.isLoggedIn) {
       navigator.popUntil((route) => route.isFirst);
     }
   }
@@ -529,10 +534,10 @@ class _AccountsCard extends StatelessWidget {
 
   Future<void> _confirmRemove(
     BuildContext context,
-    ServerProvider provider,
+    SessionController session,
     SavedAccount account,
   ) async {
-    final isActive = account.id == provider.activeAccountId;
+    final isActive = account.id == session.activeAccountId;
     final host = Uri.tryParse(account.serverUrl)?.host ?? account.serverUrl;
     final confirmed = await showDialog<bool>(
       context: context,
@@ -540,7 +545,7 @@ class _AccountsCard extends StatelessWidget {
         return AlertDialog(
           title: const Text('Remove Account'),
           content: Text(
-            isActive && provider.accounts.length > 1
+            isActive && session.accounts.length > 1
                 ? 'Remove ${account.username} ($host)? Another saved account will become active.'
                 : 'Remove ${account.username} ($host)? You can add it again later.',
           ),
@@ -563,13 +568,13 @@ class _AccountsCard extends StatelessWidget {
     if (confirmed == true) {
       if (!context.mounted) return;
       final navigator = Navigator.of(context);
-      await provider.removeAccount(account.id);
+      await session.removeAccount(account.id);
       // Only when this was the last saved account does isLoggedIn drop to
       // false and main.dart swap the root route to LoginView underneath -
       // pop back to it then, rather than leaving Settings stranded on top.
       // Removing a non-active account, or falling back to another one,
       // both keep the user logged in, so Settings should just stay put.
-      if (!provider.isLoggedIn) {
+      if (!session.isLoggedIn) {
         navigator.popUntil((route) => route.isFirst);
       }
     }
@@ -577,8 +582,8 @@ class _AccountsCard extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
-    final accounts = provider.accounts;
+    final session = context.watch<SessionController>();
+    final accounts = session.accounts;
 
     return Card(
       child: Column(
@@ -586,11 +591,11 @@ class _AccountsCard extends StatelessWidget {
           for (final account in accounts) ...[
             _AccountRow(
               account: account,
-              isActive: account.id == provider.activeAccountId,
-              onTap: account.id == provider.activeAccountId
+              isActive: account.id == session.activeAccountId,
+              onTap: account.id == session.activeAccountId
                   ? null
-                  : () => provider.switchAccount(account.id),
-              onRemove: () => _confirmRemove(context, provider, account),
+                  : () => session.switchAccount(account.id),
+              onRemove: () => _confirmRemove(context, session, account),
             ),
             const Divider(height: 1, indent: 16, endIndent: 16),
           ],
@@ -671,12 +676,12 @@ class _SecurityCard extends StatelessWidget {
 
   Future<void> _handleLoginLockChanged(
     BuildContext context,
-    ServerProvider provider,
+    SessionController session,
     bool value,
   ) async {
     final success = value
-        ? await provider.setupLoginLock()
-        : await provider.disableLoginLock();
+        ? await session.setupLoginLock()
+        : await session.disableLoginLock();
     if (!success && context.mounted) {
       ScaffoldMessenger.of(context).showSnackBar(
         SnackBar(
@@ -693,7 +698,7 @@ class _SecurityCard extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final session = context.watch<SessionController>();
 
     return Card(
       child: Column(
@@ -704,18 +709,18 @@ class _SecurityCard extends StatelessWidget {
             subtitle: const Text(
               "Require this device's PIN or biometric to open Noo",
             ),
-            value: provider.loginLockEnabled,
+            value: session.loginLockEnabled,
             onChanged: (value) =>
-                _handleLoginLockChanged(context, provider, value),
+                _handleLoginLockChanged(context, session, value),
           ),
           const Divider(height: 1, indent: 16, endIndent: 16),
           SwitchListTile(
             secondary: const Icon(Icons.swap_horiz_rounded),
             title: const Text('Lock account switching'),
             subtitle: const Text('Unlock to switch between saved accounts'),
-            value: provider.lockAccountSwitching,
-            onChanged: provider.loginLockEnabled
-                ? provider.setLockAccountSwitching
+            value: session.lockAccountSwitching,
+            onChanged: session.loginLockEnabled
+                ? session.setLockAccountSwitching
                 : null,
           ),
           const Divider(height: 1, indent: 16, endIndent: 16),
@@ -723,9 +728,9 @@ class _SecurityCard extends StatelessWidget {
             secondary: const Icon(Icons.visibility_off_rounded),
             title: const Text('Lock hidden files'),
             subtitle: const Text('Unlock to reveal hidden files and folders'),
-            value: provider.lockHiddenFiles,
-            onChanged: provider.loginLockEnabled
-                ? provider.setLockHiddenFiles
+            value: session.lockHiddenFiles,
+            onChanged: session.loginLockEnabled
+                ? session.setLockHiddenFiles
                 : null,
           ),
         ],
@@ -744,10 +749,13 @@ class _DeviceSyncCard extends StatefulWidget {
 class _DeviceSyncCardState extends State<_DeviceSyncCard> {
   bool _syncingNow = false;
 
-  Future<void> _syncNow(ServerProvider provider) async {
+  Future<void> _syncNow(
+    SessionController session,
+    SyncStatusController sync,
+  ) async {
     setState(() => _syncingNow = true);
     try {
-      await SyncService.syncNow(provider);
+      await SyncService.syncNow(session, sync);
     } catch (e) {
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
@@ -766,9 +774,10 @@ class _DeviceSyncCardState extends State<_DeviceSyncCard> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
-    final folders = provider.syncedPaths;
-    final everything = provider.syncEverything;
+    final session = context.watch<SessionController>();
+    final sync = context.watch<SyncStatusController>();
+    final folders = sync.syncedPaths;
+    final everything = sync.syncEverything;
 
     return Card(
       child: Column(
@@ -781,7 +790,7 @@ class _DeviceSyncCardState extends State<_DeviceSyncCard> {
               'Mirror the whole account instead of picking folders',
             ),
             value: everything,
-            onChanged: provider.setSyncEverything,
+            onChanged: sync.setSyncEverything,
           ),
           const Divider(height: 1, indent: 16, endIndent: 16),
           if (everything)
@@ -814,7 +823,7 @@ class _DeviceSyncCardState extends State<_DeviceSyncCard> {
                 trailing: IconButton(
                   icon: const Icon(Icons.close_rounded),
                   tooltip: 'Stop syncing',
-                  onPressed: () => provider.removeSyncedPath(folder),
+                  onPressed: () => sync.removeSyncedPath(folder),
                 ),
               ),
               const Divider(height: 1, indent: 16, endIndent: 16),
@@ -823,8 +832,8 @@ class _DeviceSyncCardState extends State<_DeviceSyncCard> {
             secondary: const Icon(Icons.signal_cellular_alt_rounded),
             title: const Text('Sync on cellular'),
             subtitle: const Text('Off = background sync only runs on Wi-Fi'),
-            value: provider.syncOnCellular,
-            onChanged: provider.setSyncOnCellular,
+            value: sync.syncOnCellular,
+            onChanged: sync.setSyncOnCellular,
           ),
           const Divider(height: 1, indent: 16, endIndent: 16),
           ListTile(
@@ -840,7 +849,7 @@ class _DeviceSyncCardState extends State<_DeviceSyncCard> {
                 : const Icon(Icons.sync_rounded),
             title: const Text('Sync now'),
             enabled: (everything || folders.isNotEmpty) && !_syncingNow,
-            onTap: () => _syncNow(provider),
+            onTap: () => _syncNow(session, sync),
           ),
         ],
       ),
@@ -857,9 +866,9 @@ class _BottomBarAppearanceCard extends StatefulWidget {
 }
 
 class _BottomBarAppearanceCardState extends State<_BottomBarAppearanceCard> {
-  // Mirrors the provider values locally so the slider thumb and the live
+  // Mirrors the controller values locally so the slider thumb and the live
   // preview track the drag gesture on every frame. Driving them straight off
-  // `provider.bottomBar*` instead would tie the slider's own responsiveness
+  // `settings.bottomBar*` instead would tie the slider's own responsiveness
   // to a full Provider-wide rebuild — including the expensive BackdropFilter
   // blur in the preview — which can't keep up with fast drag ticks and makes
   // the thumb appear stuck until the next unrelated rebuild.
@@ -870,9 +879,9 @@ class _BottomBarAppearanceCardState extends State<_BottomBarAppearanceCard> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
-    final opacity = _opacity ?? provider.bottomBarOpacity;
-    final blur = _blur ?? provider.bottomBarBlur;
+    final settings = context.watch<SettingsController>();
+    final opacity = _opacity ?? settings.bottomBarOpacity;
+    final blur = _blur ?? settings.bottomBarBlur;
 
     return Card(
       child: Padding(
@@ -974,7 +983,7 @@ class _BottomBarAppearanceCardState extends State<_BottomBarAppearanceCard> {
               min: 0.1,
               max: 1.0,
               onChanged: (value) => setState(() => _opacity = value),
-              onChangeEnd: provider.setBottomBarOpacity,
+              onChangeEnd: settings.setBottomBarOpacity,
             ),
 
             Row(
@@ -994,7 +1003,7 @@ class _BottomBarAppearanceCardState extends State<_BottomBarAppearanceCard> {
               min: 0,
               max: 40,
               onChanged: (value) => setState(() => _blur = value),
-              onChangeEnd: provider.setBottomBarBlur,
+              onChangeEnd: settings.setBottomBarBlur,
             ),
           ],
         ),
@@ -1075,7 +1084,7 @@ class _SwipeActionsCard extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
-    final provider = context.watch<ServerProvider>();
+    final settings = context.watch<SettingsController>();
 
     return Card(
       child: Padding(
@@ -1086,16 +1095,16 @@ class _SwipeActionsCard extends StatelessWidget {
               context,
               theme,
               label: 'Swipe right',
-              value: provider.swipeRightAction,
-              onChanged: provider.setSwipeRightAction,
+              value: settings.swipeRightAction,
+              onChanged: settings.setSwipeRightAction,
             ),
             const Divider(height: 1),
             _buildRow(
               context,
               theme,
               label: 'Swipe left',
-              value: provider.swipeLeftAction,
-              onChanged: provider.setSwipeLeftAction,
+              value: settings.swipeLeftAction,
+              onChanged: settings.setSwipeLeftAction,
             ),
           ],
         ),
@@ -1157,21 +1166,21 @@ class _MediaPlayerCard extends StatelessWidget {
 
   Future<void> _openPicker(
     BuildContext context,
-    ServerProvider provider,
+    SettingsController settings,
   ) async {
     final selected = await showDialog<MediaProgressBarStyle>(
       context: context,
       builder: (_) =>
-          _SeekBarStyleDialog(current: provider.mediaProgressBarStyle),
+          _SeekBarStyleDialog(current: settings.mediaProgressBarStyle),
     );
-    if (selected != null) provider.setMediaProgressBarStyle(selected);
+    if (selected != null) settings.setMediaProgressBarStyle(selected);
   }
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final settings = context.watch<SettingsController>();
 
     return Card(
       child: ListTile(
@@ -1182,17 +1191,17 @@ class _MediaPlayerCard extends StatelessWidget {
             fontWeight: FontWeight.w600,
           ),
         ),
-        subtitle: Text(_seekBarStyleLabel(provider.mediaProgressBarStyle)),
+        subtitle: Text(_seekBarStyleLabel(settings.mediaProgressBarStyle)),
         trailing: SizedBox(
           width: 64,
           height: 24,
           child: SeekBarPreview(
-            style: provider.mediaProgressBarStyle,
+            style: settings.mediaProgressBarStyle,
             playedColor: colorScheme.primary,
             trackColor: colorScheme.outlineVariant,
           ),
         ),
-        onTap: () => _openPicker(context, provider),
+        onTap: () => _openPicker(context, settings),
       ),
     );
   }
@@ -1354,7 +1363,7 @@ class _CacheSettingsCard extends StatelessWidget {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final files = context.watch<FilesController>();
 
     return Card(
       child: Padding(
@@ -1362,9 +1371,9 @@ class _CacheSettingsCard extends StatelessWidget {
         child: Column(
           children: [
             RadioGroup<CachePolicy>(
-              groupValue: provider.cachePolicy,
+              groupValue: files.cachePolicy,
               onChanged: (value) {
-                if (value != null) provider.setCachePolicy(value);
+                if (value != null) files.setCachePolicy(value);
               },
               child: Column(
                 children: [
@@ -1377,7 +1386,7 @@ class _CacheSettingsCard extends StatelessWidget {
                 ],
               ),
             ),
-            if (provider.cachePolicy == CachePolicy.interval)
+            if (files.cachePolicy == CachePolicy.interval)
               Padding(
                 padding: const EdgeInsets.fromLTRB(16, 0, 16, 12),
                 child: Column(
@@ -1392,7 +1401,7 @@ class _CacheSettingsCard extends StatelessWidget {
                           style: theme.textTheme.bodyMedium,
                         ),
                         Text(
-                          '${provider.cacheIntervalMinutes} min',
+                          '${files.cacheIntervalMinutes} min',
                           style: theme.textTheme.bodySmall?.copyWith(
                             color: colorScheme.onSurfaceVariant,
                           ),
@@ -1400,13 +1409,13 @@ class _CacheSettingsCard extends StatelessWidget {
                       ],
                     ),
                     Slider(
-                      value: provider.cacheIntervalMinutes.toDouble(),
+                      value: files.cacheIntervalMinutes.toDouble(),
                       min: 1,
                       max: 60,
                       divisions: 59,
-                      label: '${provider.cacheIntervalMinutes} min',
+                      label: '${files.cacheIntervalMinutes} min',
                       onChanged: (value) =>
-                          provider.setCacheIntervalMinutes(value.round()),
+                          files.setCacheIntervalMinutes(value.round()),
                     ),
                   ],
                 ),
@@ -1423,7 +1432,7 @@ class _TabSettingsCard extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final settings = context.watch<SettingsController>();
 
     return Card(
       clipBehavior: Clip.antiAlias,
@@ -1431,20 +1440,20 @@ class _TabSettingsCard extends StatelessWidget {
         shrinkWrap: true,
         physics: const NeverScrollableScrollPhysics(),
         onReorderItem: (oldIndex, newIndex) {
-          final order = List<AppTab>.from(provider.tabOrder);
+          final order = List<AppTab>.from(settings.tabOrder);
           final tab = order.removeAt(oldIndex);
           order.insert(newIndex, tab);
-          provider.setTabOrder(order);
+          settings.setTabOrder(order);
         },
         children: [
-          for (final tab in provider.tabOrder)
+          for (final tab in settings.tabOrder)
             _TabConfigRow(
               key: ValueKey(tab),
               tab: tab,
-              isVisible: !provider.hiddenTabs.contains(tab),
-              isDefault: provider.defaultTab == tab,
+              isVisible: !settings.hiddenTabs.contains(tab),
+              isDefault: settings.defaultTab == tab,
               onVisibilityChanged: (value) {
-                final error = provider.setTabHidden(tab, !value);
+                final error = settings.setTabHidden(tab, !value);
                 if (error != null && context.mounted) {
                   ScaffoldMessenger.of(context).showSnackBar(
                     SnackBar(
@@ -1454,7 +1463,7 @@ class _TabSettingsCard extends StatelessWidget {
                   );
                 }
               },
-              onSetDefault: () => provider.setDefaultTab(tab),
+              onSetDefault: () => settings.setDefaultTab(tab),
             ),
         ],
       ),

lib/views/activity_view.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
 import '../widgets/more_tabs_button.dart';
 import '../widgets/profile_avatar_button.dart';
 import '../widgets/synced_header_scaffold.dart';
@@ -15,13 +15,13 @@ class ActivityView extends StatelessWidget {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
-    final activities = provider.activities;
+    final files = context.watch<FilesController>();
+    final activities = files.activities;
 
     final List<Widget> contentSlivers = [
       const SliverToBoxAdapter(child: SizedBox(height: 16)),
 
-      if (provider.isLoading && activities.isEmpty)
+      if (files.isLoading && activities.isEmpty)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
@@ -134,7 +134,6 @@ class ActivityView extends StatelessWidget {
 
     return SyncedHeaderScaffold(
       scrollController: scrollController,
-      provider: provider,
       actions: const [MoreTabsButton(), ProfileAvatarButton()],
       contentSlivers: contentSlivers,
     );

lib/views/favorites_view.dart

@@ -7,7 +7,11 @@ import 'package:share_plus/share_plus.dart';
 import '../models/app_tab.dart';
 import '../models/nextcloud_item.dart';
 import '../models/selection_action.dart';
-import '../providers/server_provider.dart';
+import '../providers/favorites_controller.dart';
+import '../providers/files_controller.dart';
+import '../providers/item_operations.dart';
+import '../providers/session_controller.dart';
+import '../providers/settings_controller.dart';
 import '../services/download_service.dart';
 import '../widgets/details/details_sheet.dart';
 import '../widgets/item_icon.dart';
@@ -24,7 +28,7 @@ import 'move_copy_destination_picker.dart';
 
 /// Every favorited file/folder across the whole account, account-wide - a
 /// real tab rather than a filter toggle scoped to whatever folder the
-/// Files tab happens to be browsing (see `ServerProvider.fetchAllFavorites`
+/// Files tab happens to be browsing (see `FavoritesController.fetchAll`
 /// for why: a favorited item several folders deep needs to show up
 /// regardless of whether its parent folders are themselves favorited,
 /// which a current-folder-only filter can never do, and a flat account-
@@ -32,7 +36,7 @@ import 'move_copy_destination_picker.dart';
 /// toggle had - the trail showing wherever Files was last browsing while
 /// the content showed something else entirely - simply can't happen).
 /// Shares Files' own sort/hidden/storage-scope/grid-list display prefs
-/// (via `ServerProvider.applyFilesDisplayPrefs`) rather than a separate
+/// (via `FilesController.applyFilesDisplayPrefs`) rather than a separate
 /// parallel settings dimension.
 class FavoritesView extends StatefulWidget {
   final ScrollController scrollController;
@@ -128,13 +132,12 @@ class _FavoritesViewState extends State<FavoritesView>
   /// back on this tab either way.
   void _openFavorite(
     BuildContext context,
-    ServerProvider provider,
     NextcloudItem item,
     List<NextcloudItem> siblings,
   ) {
     if (item.isFolder) {
-      provider.navigateToAbsoluteFolder(item.path);
-      provider.requestTab(AppTab.files);
+      context.read<FilesController>().navigateToAbsoluteFolder(item.path);
+      context.read<SettingsController>().requestTab(AppTab.files);
     } else {
       Navigator.push(
         context,
@@ -145,42 +148,39 @@ class _FavoritesViewState extends State<FavoritesView>
 
   /// The bulk actions shown in the sticky selection toolbar for the
   /// currently-selected items - same set Files/Photos offer.
-  List<SelectionAction> _buildSelectionActions(
-    ServerProvider provider,
-    List<NextcloudItem> selected,
-  ) {
+  List<SelectionAction> _buildSelectionActions(List<NextcloudItem> selected) {
     return [
       SelectionAction(
         icon: Icons.favorite_border_rounded,
         label: 'Remove from favorites',
-        onTap: () => _unfavoriteSelected(provider, selected),
+        onTap: () => _unfavoriteSelected(selected),
       ),
       SelectionAction(
         icon: Icons.share_rounded,
         label: 'Share',
         onTap: () => selected.length == 1
             ? ShareSheet.show(context, selected.single)
-            : _shareSelected(context, provider, selected),
+            : _shareSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.download_rounded,
         label: 'Download',
-        onTap: () => _downloadSelected(context, provider, selected),
+        onTap: () => _downloadSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.delete_outline_rounded,
         label: 'Delete',
-        onTap: () => _confirmDeleteSelected(context, provider, selected),
+        onTap: () => _confirmDeleteSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.copy_rounded,
         label: 'Copy',
-        onTap: () => _moveOrCopySelected(provider, selected, copy: true),
+        onTap: () => _moveOrCopySelected(selected, copy: true),
       ),
       SelectionAction(
         icon: Icons.drive_file_move_rounded,
         label: 'Move',
-        onTap: () => _moveOrCopySelected(provider, selected, copy: false),
+        onTap: () => _moveOrCopySelected(selected, copy: false),
       ),
       if (selected.length == 1)
         SelectionAction(
@@ -191,21 +191,19 @@ class _FavoritesViewState extends State<FavoritesView>
     ];
   }
 
-  Future<void> _unfavoriteSelected(
-    ServerProvider provider,
-    List<NextcloudItem> items,
-  ) async {
+  Future<void> _unfavoriteSelected(List<NextcloudItem> items) async {
+    final ops = context.read<ItemOperations>();
     for (final item in items) {
-      await provider.toggleItemFavorite(item);
+      await ops.toggleItemFavorite(item);
     }
     _clearSelection();
   }
 
   Future<void> _shareSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
     messenger.showSnackBar(
       const SnackBar(
@@ -216,7 +214,7 @@ class _FavoritesViewState extends State<FavoritesView>
 
     final lines = <String>[];
     for (final item in items) {
-      final link = await provider.createShareLink(item);
+      final link = await ops.createShareLink(item);
       if (link != null) {
         lines.add(items.length > 1 ? '${item.name}: $link' : link);
       }
@@ -252,16 +250,16 @@ class _FavoritesViewState extends State<FavoritesView>
   /// `FilesView._downloadSelected`'s identical doc comment for why.
   Future<void> _downloadSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
+    final session = context.read<SessionController>();
     final files = items.where((i) => !i.isFolder).toList();
     _clearSelection();
     if (files.isEmpty) return;
 
     final messenger = ScaffoldMessenger.of(context);
     try {
-      await DownloadService.startDownload(provider, files);
+      await DownloadService.startDownload(session, files);
       messenger.showSnackBar(
         SnackBar(
           content: Text(
@@ -284,7 +282,6 @@ class _FavoritesViewState extends State<FavoritesView>
 
   Future<void> _confirmDeleteSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
     final confirmed = await showDialog<bool>(
@@ -313,10 +310,11 @@ class _FavoritesViewState extends State<FavoritesView>
     );
     if (confirmed != true || !context.mounted) return;
 
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
     var succeeded = 0;
     for (final item in items) {
-      final success = await provider.deleteItem(item.path);
+      final success = await ops.deleteItem(item.path);
       if (success) succeeded++;
     }
 
@@ -330,7 +328,6 @@ class _FavoritesViewState extends State<FavoritesView>
   }
 
   Future<void> _moveOrCopySelected(
-    ServerProvider provider,
     List<NextcloudItem> items, {
     required bool copy,
   }) async {
@@ -351,7 +348,7 @@ class _FavoritesViewState extends State<FavoritesView>
     );
   }
 
-  Widget _buildControlsRow(ServerProvider provider) {
+  Widget _buildControlsRow(FilesController files) {
     return SizedBox(
       height: 44,
       child: SingleChildScrollView(
@@ -360,28 +357,28 @@ class _FavoritesViewState extends State<FavoritesView>
           children: [
             IconButton(
               icon: Icon(
-                provider.filesSortAscending
+                files.filesSortAscending
                     ? Icons.arrow_upward_rounded
                     : Icons.arrow_downward_rounded,
                 size: 20,
               ),
               visualDensity: VisualDensity.compact,
-              tooltip: provider.filesSortAscending ? 'Ascending' : 'Descending',
-              onPressed: provider.toggleFilesSortOrder,
+              tooltip: files.filesSortAscending ? 'Ascending' : 'Descending',
+              onPressed: files.toggleFilesSortOrder,
             ),
             SizedBox(
               width: 130,
               child: SortMenuButton(
-                field: provider.filesSortField,
-                onChanged: provider.setFilesSortField,
+                field: files.filesSortField,
+                onChanged: files.setFilesSortField,
               ),
             ),
             ToggleIconButton(
-              icon: provider.showHiddenFiles
+              icon: files.showHiddenFiles
                   ? Icons.visibility_rounded
                   : Icons.visibility_off_rounded,
-              isSelected: provider.showHiddenFiles,
-              onTap: () => provider.toggleShowHiddenFiles(),
+              isSelected: files.showHiddenFiles,
+              onTap: () => files.toggleShowHiddenFiles(),
               tooltip: 'Show hidden files',
             ),
             const SizedBox(width: 4),
@@ -389,14 +386,14 @@ class _FavoritesViewState extends State<FavoritesView>
               children: [
                 ToggleIconButton(
                   icon: Symbols.circles_rounded,
-                  isSelected: provider.storageScope == StorageScope.cloud,
-                  onTap: () => provider.setStorageScope(StorageScope.cloud),
+                  isSelected: files.storageScope == StorageScope.cloud,
+                  onTap: () => files.setStorageScope(StorageScope.cloud),
                   tooltip: 'Cloud storage',
                 ),
                 ToggleIconButton(
                   icon: Symbols.hard_drive_rounded,
-                  isSelected: provider.storageScope == StorageScope.external,
-                  onTap: () => provider.setStorageScope(StorageScope.external),
+                  isSelected: files.storageScope == StorageScope.external,
+                  onTap: () => files.setStorageScope(StorageScope.external),
                   tooltip: 'External storage',
                 ),
               ],
@@ -406,14 +403,14 @@ class _FavoritesViewState extends State<FavoritesView>
               children: [
                 ToggleIconButton(
                   icon: Icons.view_list_rounded,
-                  isSelected: !provider.isGridView,
-                  onTap: () => provider.setGridView(false),
+                  isSelected: !files.isGridView,
+                  onTap: () => files.setGridView(false),
                   tooltip: 'List view',
                 ),
                 ToggleIconButton(
                   icon: Icons.grid_view_rounded,
-                  isSelected: provider.isGridView,
-                  onTap: () => provider.setGridView(true),
+                  isSelected: files.isGridView,
+                  onTap: () => files.setGridView(true),
                   tooltip: 'Grid view',
                 ),
               ],
@@ -427,11 +424,11 @@ class _FavoritesViewState extends State<FavoritesView>
   Widget _buildListTile(
     BuildContext context,
     NextcloudItem item,
-    ServerProvider provider,
     List<NextcloudItem> siblings,
   ) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
+    final session = context.watch<SessionController>();
     final isSelected = _selectedIds.contains(item.id);
 
     return Padding(
@@ -447,7 +444,7 @@ class _FavoritesViewState extends State<FavoritesView>
               if (_isSelecting) {
                 _toggleSelection(item);
               } else {
-                _openFavorite(context, provider, item, siblings);
+                _openFavorite(context, item, siblings);
               }
             },
             onLongPress: () => _toggleSelection(item),
@@ -461,7 +458,7 @@ class _FavoritesViewState extends State<FavoritesView>
                     checkmarkSize: 24,
                     child: ItemThumbnail(
                       item: item,
-                      provider: provider,
+                      service: session.service,
                       size: 44,
                       borderRadius: 12,
                       iconSize: 22,
@@ -503,10 +500,10 @@ class _FavoritesViewState extends State<FavoritesView>
   Widget _buildGridCard(
     BuildContext context,
     NextcloudItem item,
-    ServerProvider provider,
     List<NextcloudItem> siblings,
   ) {
     final theme = Theme.of(context);
+    final session = context.watch<SessionController>();
     final isSelected = _selectedIds.contains(item.id);
     final isMedia =
         (item.type == NextcloudItemType.image ||
@@ -523,7 +520,7 @@ class _FavoritesViewState extends State<FavoritesView>
             if (_isSelecting) {
               _toggleSelection(item);
             } else {
-              _openFavorite(context, provider, item, siblings);
+              _openFavorite(context, item, siblings);
             }
           },
           onLongPress: () => _toggleSelection(item),
@@ -533,7 +530,7 @@ class _FavoritesViewState extends State<FavoritesView>
             child: isMedia
                 ? Image.network(
                     item.previewUrl!,
-                    headers: provider.service?.authHeaders,
+                    headers: session.service?.authHeaders,
                     fit: BoxFit.cover,
                     filterQuality: FilterQuality.low,
                     gaplessPlayback: true,
@@ -587,16 +584,17 @@ class _FavoritesViewState extends State<FavoritesView>
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final favoritesController = context.watch<FavoritesController>();
+    final filesController = context.watch<FilesController>();
 
     if (!_requested) {
       _requested = true;
       WidgetsBinding.instance.addPostFrameCallback(
-        (_) => provider.fetchAllFavorites(),
+        (_) => favoritesController.fetchAll(),
       );
     }
 
-    final favorites = provider.favoriteItems;
+    final favorites = favoritesController.items;
     final siblings = favorites.where((i) => !i.isFolder).toList();
     final selectedItems = favorites
         .where((i) => _selectedIds.contains(i.id))
@@ -609,17 +607,17 @@ class _FavoritesViewState extends State<FavoritesView>
           height: 60,
           child: Padding(
             padding: const EdgeInsets.fromLTRB(16, 16, 16, 0),
-            child: _buildControlsRow(provider),
+            child: _buildControlsRow(filesController),
           ),
         ),
       ),
       const SliverToBoxAdapter(child: SizedBox(height: 8)),
-      if (provider.isFavoritesLoading && favorites.isEmpty)
+      if (favoritesController.isLoading && favorites.isEmpty)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
         )
-      else if (provider.favoritesErrorMessage != null)
+      else if (favoritesController.errorMessage != null)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -643,7 +641,7 @@ class _FavoritesViewState extends State<FavoritesView>
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    provider.favoritesErrorMessage!,
+                    favoritesController.errorMessage!,
                     textAlign: TextAlign.center,
                     style: theme.textTheme.bodyMedium?.copyWith(
                       color: colorScheme.onSurfaceVariant,
@@ -651,7 +649,7 @@ class _FavoritesViewState extends State<FavoritesView>
                   ),
                   const SizedBox(height: 20),
                   FilledButton.icon(
-                    onPressed: provider.fetchAllFavorites,
+                    onPressed: favoritesController.fetchAll,
                     icon: const Icon(Icons.refresh_rounded),
                     label: const Text('Retry'),
                   ),
@@ -683,7 +681,7 @@ class _FavoritesViewState extends State<FavoritesView>
             ),
           ),
         )
-      else if (provider.isGridView)
+      else if (filesController.isGridView)
         SliverPadding(
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverGrid(
@@ -694,12 +692,7 @@ class _FavoritesViewState extends State<FavoritesView>
               mainAxisSpacing: 12,
             ),
             delegate: SliverChildBuilderDelegate((context, index) {
-              return _buildGridCard(
-                context,
-                favorites[index],
-                provider,
-                siblings,
-              );
+              return _buildGridCard(context, favorites[index], siblings);
             }, childCount: favorites.length),
           ),
         )
@@ -708,12 +701,7 @@ class _FavoritesViewState extends State<FavoritesView>
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
-              return _buildListTile(
-                context,
-                favorites[index],
-                provider,
-                siblings,
-              );
+              return _buildListTile(context, favorites[index], siblings);
             }, childCount: favorites.length),
           ),
         ),
@@ -728,11 +716,10 @@ class _FavoritesViewState extends State<FavoritesView>
       },
       child: SyncedHeaderScaffold(
         scrollController: widget.scrollController,
-        provider: provider,
         actions: const [MoreTabsButton(), ProfileAvatarButton()],
-        onRefresh: provider.fetchAllFavorites,
+        onRefresh: favoritesController.fetchAll,
         selectionBar: _isSelecting
-            ? _buildSelectionBar(context, theme, provider, selectedItems)
+            ? _buildSelectionBar(context, theme, selectedItems)
             : null,
         contentSlivers: contentSlivers,
       ),
@@ -745,7 +732,6 @@ class _FavoritesViewState extends State<FavoritesView>
   Widget _buildSelectionBar(
     BuildContext context,
     ThemeData theme,
-    ServerProvider provider,
     List<NextcloudItem> selectedItems,
   ) {
     return Padding(
@@ -783,10 +769,7 @@ class _FavoritesViewState extends State<FavoritesView>
               child: Row(
                 mainAxisSize: MainAxisSize.min,
                 children: [
-                  for (final action in _buildSelectionActions(
-                    provider,
-                    selectedItems,
-                  ))
+                  for (final action in _buildSelectionActions(selectedItems))
                     IconButton(
                       icon: Icon(action.icon, size: 20),
                       tooltip: action.label,

lib/views/file_viewer_screen.dart

@@ -9,7 +9,9 @@ import 'package:pdfx/pdfx.dart';
 import 'package:provider/provider.dart';
 import 'package:video_player/video_player.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/item_operations.dart';
+import '../providers/session_controller.dart';
+import '../providers/settings_controller.dart';
 import '../services/download_service.dart';
 import '../widgets/details/details_sheet.dart';
 import '../widgets/frosted_glass_container.dart';
@@ -148,13 +150,13 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
   }
 
   Future<String> _downloadToTemp(
-    ServerProvider provider,
+    SessionController session,
     NextcloudItem item,
   ) async {
     final tempDir = await getTemporaryDirectory();
     final savePath = p.join(tempDir.path, item.name);
     setState(() => _downloadProgress = 0);
-    await provider.service!.downloadToFile(
+    await session.service!.downloadToFile(
       item.path,
       savePath,
       onProgress: (received, total) {
@@ -167,11 +169,11 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
     return savePath;
   }
 
-  Future<void> _openExternally(ServerProvider provider) async {
+  Future<void> _openExternally(SessionController session) async {
     final item = _currentItem;
     setState(() => _isBusy = true);
     try {
-      final path = await _downloadToTemp(provider, item);
+      final path = await _downloadToTemp(session, item);
       final result = await OpenFile.open(path);
       if (mounted && result.type != ResultType.done) {
         ScaffoldMessenger.of(context).showSnackBar(
@@ -194,10 +196,10 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
   /// `UploadService`/`ShareUploadService.kt` on the upload side: a real
   /// Android Service survives the app being closed mid-download, and one
   /// notification covers progress/cancel instead of blocking this screen.
-  Future<void> _downloadToDevice(ServerProvider provider) async {
+  Future<void> _downloadToDevice(SessionController session) async {
     final item = _currentItem;
     try {
-      await DownloadService.startDownload(provider, [item]);
+      await DownloadService.startDownload(session, [item]);
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
@@ -216,16 +218,16 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
     }
   }
 
-  Future<void> _toggleFavorite(ServerProvider provider) async {
+  Future<void> _toggleFavorite(ItemOperations ops) async {
     final item = _currentItem;
-    await provider.toggleItemFavorite(item);
+    await ops.toggleItemFavorite(item);
     if (!mounted) return;
     setState(() {
       _mediaItems[_currentIndex] = item.copyWith(isFavorite: !item.isFavorite);
     });
   }
 
-  Future<void> _deleteCurrentItem(ServerProvider provider) async {
+  Future<void> _deleteCurrentItem(ItemOperations ops) async {
     final item = _currentItem;
     final confirmed = await showDialog<bool>(
       context: context,
@@ -254,7 +256,7 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
     if (confirmed != true || !mounted) return;
 
     setState(() => _isBusy = true);
-    final success = await provider.deleteItem(item.path);
+    final success = await ops.deleteItem(item.path);
     if (!mounted) return;
     setState(() => _isBusy = false);
 
@@ -283,7 +285,9 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.read<ServerProvider>();
+    final session = context.read<SessionController>();
+    final settings = context.read<SettingsController>();
+    final ops = context.read<ItemOperations>();
     final colorScheme = Theme.of(context).colorScheme;
 
     return Scaffold(
@@ -296,7 +300,7 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
             Positioned.fill(
               child: Container(
                 color: colorScheme.surface,
-                child: _buildBody(context, provider),
+                child: _buildBody(context, session),
               ),
             ),
             if (_downloadProgress != null)
@@ -322,8 +326,8 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
                   child: Padding(
                     padding: const EdgeInsets.fromLTRB(20, 12, 20, 0),
                     child: FrostedGlassContainer(
-                      opacity: provider.bottomBarOpacity,
-                      blurSigma: provider.bottomBarBlur,
+                      opacity: settings.bottomBarOpacity,
+                      blurSigma: settings.bottomBarBlur,
                       child: Padding(
                         padding: const EdgeInsets.symmetric(
                           horizontal: 6,
@@ -367,13 +371,13 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
                   child: _MediaActionBar(
                     isFavorite: _currentItem.isFavorite,
                     isBusy: _isBusy,
-                    opacity: provider.bottomBarOpacity,
-                    blurSigma: provider.bottomBarBlur,
+                    opacity: settings.bottomBarOpacity,
+                    blurSigma: settings.bottomBarBlur,
                     onShare: () => ShareSheet.show(context, _currentItem),
-                    onFavorite: () => _toggleFavorite(provider),
-                    onDelete: () => _deleteCurrentItem(provider),
-                    onOpenExternally: () => _openExternally(provider),
-                    onDownload: () => _downloadToDevice(provider),
+                    onFavorite: () => _toggleFavorite(ops),
+                    onDelete: () => _deleteCurrentItem(ops),
+                    onOpenExternally: () => _openExternally(session),
+                    onDownload: () => _downloadToDevice(session),
                     onDetails: () => DetailsSheet.show(context, _currentItem),
                   ),
                 ),
@@ -385,10 +389,11 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
     );
   }
 
-  Widget _buildBody(BuildContext context, ServerProvider provider) {
+  Widget _buildBody(BuildContext context, SessionController session) {
     if (!_isSwipeable) {
-      return _buildStaticPreview(context, provider);
+      return _buildStaticPreview(context, session);
     }
+    final settings = context.read<SettingsController>();
 
     return PageView.builder(
       controller: _pageController,
@@ -399,24 +404,24 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
         if (mediaItem.type == NextcloudItemType.image) {
           return _ImagePreview(
             key: ValueKey(mediaItem.id),
-            url: provider.service!.fileUrl(mediaItem.path),
-            headers: provider.service!.authHeaders,
+            url: session.service!.fileUrl(mediaItem.path),
+            headers: session.service!.authHeaders,
           );
         }
         return _VideoPreview(
           key: ValueKey(mediaItem.id),
-          url: provider.service!.fileUrl(mediaItem.path),
-          headers: provider.service!.authHeaders,
+          url: session.service!.fileUrl(mediaItem.path),
+          headers: session.service!.authHeaders,
           isActive: index == _currentIndex,
           controlsBottomOffset: _controlsVisible ? 108 : 24,
-          opacity: provider.bottomBarOpacity,
-          blurSigma: provider.bottomBarBlur,
+          opacity: settings.bottomBarOpacity,
+          blurSigma: settings.bottomBarBlur,
         );
       },
     );
   }
 
-  Widget _buildStaticPreview(BuildContext context, ServerProvider provider) {
+  Widget _buildStaticPreview(BuildContext context, SessionController session) {
     switch (widget.item.type) {
       case NextcloudItemType.image:
       case NextcloudItemType.video:
@@ -424,15 +429,15 @@ class _FileViewerScreenState extends State<FileViewerScreen> {
         return const SizedBox.shrink();
       default:
         if (_isPdf) {
-          return _PdfPreview(item: widget.item, provider: provider);
+          return _PdfPreview(item: widget.item, session: session);
         }
         if (_isText) {
-          return _TextPreview(item: widget.item, provider: provider);
+          return _TextPreview(item: widget.item, session: session);
         }
         return _UnsupportedPreview(
           item: widget.item,
           isBusy: _isBusy,
-          onOpenExternally: () => _openExternally(provider),
+          onOpenExternally: () => _openExternally(session),
           onOpenDetails: () => DetailsSheet.show(context, widget.item),
         );
     }
@@ -752,7 +757,7 @@ class _VideoPreviewState extends State<_VideoPreview> {
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
     final progressBarStyle = context
-        .watch<ServerProvider>()
+        .watch<SettingsController>()
         .mediaProgressBarStyle;
     if (_error != null) {
       return Center(
@@ -966,9 +971,9 @@ class _WavySeekBarState extends State<_WavySeekBar>
 
 class _PdfPreview extends StatefulWidget {
   final NextcloudItem item;
-  final ServerProvider provider;
+  final SessionController session;
 
-  const _PdfPreview({required this.item, required this.provider});
+  const _PdfPreview({required this.item, required this.session});
 
   @override
   State<_PdfPreview> createState() => _PdfPreviewState();
@@ -986,7 +991,7 @@ class _PdfPreviewState extends State<_PdfPreview> {
 
   Future<void> _load() async {
     try {
-      final bytes = await widget.provider.service!.fetchBytes(widget.item.path);
+      final bytes = await widget.session.service!.fetchBytes(widget.item.path);
       if (!mounted) return;
       setState(() {
         _controller = PdfControllerPinch(
@@ -1033,9 +1038,9 @@ class _PdfPreviewState extends State<_PdfPreview> {
 
 class _TextPreview extends StatefulWidget {
   final NextcloudItem item;
-  final ServerProvider provider;
+  final SessionController session;
 
-  const _TextPreview({required this.item, required this.provider});
+  const _TextPreview({required this.item, required this.session});
 
   @override
   State<_TextPreview> createState() => _TextPreviewState();
@@ -1053,7 +1058,7 @@ class _TextPreviewState extends State<_TextPreview> {
 
   Future<void> _load() async {
     try {
-      final bytes = await widget.provider.service!.fetchBytes(widget.item.path);
+      final bytes = await widget.session.service!.fetchBytes(widget.item.path);
       if (mounted) {
         setState(() => _content = utf8.decode(bytes, allowMalformed: true));
       }

lib/views/files_view.dart

@@ -9,7 +9,12 @@ import 'package:provider/provider.dart';
 import 'package:share_plus/share_plus.dart';
 import '../models/nextcloud_item.dart';
 import '../models/selection_action.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/item_operations.dart';
+import '../providers/pick_controller.dart';
+import '../providers/session_controller.dart';
+import '../providers/settings_controller.dart';
+import '../providers/sync_status_controller.dart';
 import '../services/download_service.dart';
 import '../services/share_intent_service.dart';
 import '../widgets/breadcrumbs.dart';
@@ -204,16 +209,14 @@ class _FilesViewState extends State<FilesView>
   /// folders are still browsable, a matching file either toggles selection
   /// (multi-select requests) or immediately finishes the pick, and a
   /// non-matching file (wrong mime type for the caller) is rejected.
-  void _handlePickTap(
-    BuildContext context,
-    ServerProvider provider,
-    NextcloudItem item,
-  ) {
+  void _handlePickTap(BuildContext context, NextcloudItem item) {
+    final files = context.read<FilesController>();
+    final pick = context.read<PickController>();
     if (item.isFolder) {
-      provider.navigateToFolder(item.path);
+      files.navigateToFolder(item.path);
       return;
     }
-    if (!provider.itemMatchesPickFilter(item)) {
+    if (!pick.itemMatchesPickFilter(item)) {
       ScaffoldMessenger.of(context).showSnackBar(
         const SnackBar(
           content: Text("This app can't accept this file type"),
@@ -222,25 +225,27 @@ class _FilesViewState extends State<FilesView>
       );
       return;
     }
-    if (provider.pickRequest!.allowMultiple) {
+    if (pick.pickRequest!.allowMultiple) {
       _toggleSelection(item);
     } else {
-      provider.confirmPick([item]);
+      pick.confirmPick([item]);
     }
   }
 
   /// The bulk actions shown in the sticky selection toolbar for the
   /// currently-selected items.
   List<SelectionAction> _buildSelectionActions(
-    ServerProvider provider,
+    BuildContext context,
     List<NextcloudItem> selected,
   ) {
-    if (provider.isPicking) {
+    final pick = context.watch<PickController>();
+    final sync = context.watch<SyncStatusController>();
+    if (pick.isPicking) {
       return [
         SelectionAction(
           icon: Icons.check_rounded,
           label: 'Use ${selected.length} item(s)',
-          onTap: () => provider.confirmPick(selected),
+          onTap: () => pick.confirmPick(selected),
         ),
       ];
     }
@@ -252,52 +257,52 @@ class _FilesViewState extends State<FilesView>
         label: selected.every((i) => i.isFavorite)
             ? 'Remove from favorites'
             : 'Favorite',
-        onTap: () => _favoriteSelected(provider, selected),
+        onTap: () => _favoriteSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.share_rounded,
         label: 'Share',
         onTap: () => selected.length == 1
             ? ShareSheet.show(context, selected.single)
-            : _shareSelected(context, provider, selected),
+            : _shareSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.download_rounded,
         label: 'Download',
-        onTap: () => _downloadSelected(context, provider, selected),
+        onTap: () => _downloadSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.delete_outline_rounded,
         label: 'Delete',
-        onTap: () => _confirmDeleteSelected(context, provider, selected),
+        onTap: () => _confirmDeleteSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.copy_rounded,
         label: 'Copy',
-        onTap: () => _moveOrCopySelected(provider, selected, copy: true),
+        onTap: () => _moveOrCopySelected(context, selected, copy: true),
       ),
       SelectionAction(
         icon: Icons.drive_file_move_rounded,
         label: 'Move',
-        onTap: () => _moveOrCopySelected(provider, selected, copy: false),
+        onTap: () => _moveOrCopySelected(context, selected, copy: false),
       ),
       if (selected.length == 1)
         SelectionAction(
           icon: Icons.drive_file_rename_outline_rounded,
           label: 'Rename',
-          onTap: () => _renameItem(provider, selected.single),
+          onTap: () => _renameItem(selected.single),
         ),
       if (selected.length == 1)
         SelectionAction(
-          icon: provider.isPathSynced(selected.single.path)
+          icon: sync.isPathSynced(selected.single.path)
               ? Icons.sync_rounded
               : Icons.sync_outlined,
-          label: provider.isPathSynced(selected.single.path)
+          label: sync.isPathSynced(selected.single.path)
               ? 'Stop syncing to device'
               : 'Sync to device',
-          onTap: () => provider.isPathSynced(selected.single.path)
-              ? provider.removeSyncedPath(selected.single.path)
-              : provider.addSyncedPath(selected.single.path),
+          onTap: () => sync.isPathSynced(selected.single.path)
+              ? sync.removeSyncedPath(selected.single.path)
+              : sync.addSyncedPath(selected.single.path),
         ),
       if (selected.length == 1)
         SelectionAction(
@@ -308,7 +313,7 @@ class _FilesViewState extends State<FilesView>
     ];
   }
 
-  Future<void> _renameItem(ServerProvider provider, NextcloudItem item) async {
+  Future<void> _renameItem(NextcloudItem item) async {
     final controller = TextEditingController(text: item.name);
     final newName = await showDialog<String>(
       context: context,
@@ -345,7 +350,8 @@ class _FilesViewState extends State<FilesView>
     if (!mounted) return;
 
     final messenger = ScaffoldMessenger.of(context);
-    final success = await provider.renameItem(item, newName);
+    final ops = context.read<ItemOperations>();
+    final success = await ops.renameItem(item, newName);
     _clearSelection();
     messenger.showSnackBar(
       SnackBar(
@@ -359,9 +365,9 @@ class _FilesViewState extends State<FilesView>
 
   Future<void> _shareSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
     messenger.showSnackBar(
       const SnackBar(
@@ -372,7 +378,7 @@ class _FilesViewState extends State<FilesView>
 
     final lines = <String>[];
     for (final item in items) {
-      final link = await provider.createShareLink(item);
+      final link = await ops.createShareLink(item);
       if (link != null) {
         lines.add(items.length > 1 ? '${item.name}: $link' : link);
       }
@@ -408,14 +414,14 @@ class _FilesViewState extends State<FilesView>
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final files = context.watch<FilesController>();
 
-    final pathDepth = provider.pathStack.length;
+    final pathDepth = files.pathStack.length;
     final navigatingDeeper = pathDepth > _lastPathDepth;
     _lastPathDepth = pathDepth;
 
-    final hasBreadcrumbs = provider.pathStack.length > 1;
-    final selectedItems = provider.items
+    final hasBreadcrumbs = files.pathStack.length > 1;
+    final selectedItems = files.items
         .where((i) => _selectedIds.contains(i.id))
         .toList();
 
@@ -445,16 +451,16 @@ class _FilesViewState extends State<FilesView>
                 children: [
                   IconButton(
                     icon: Icon(
-                      provider.filesSortAscending
+                      files.filesSortAscending
                           ? Icons.arrow_upward_rounded
                           : Icons.arrow_downward_rounded,
                       size: 20,
                     ),
                     visualDensity: VisualDensity.compact,
-                    tooltip: provider.filesSortAscending
+                    tooltip: files.filesSortAscending
                         ? 'Ascending'
                         : 'Descending',
-                    onPressed: provider.toggleFilesSortOrder,
+                    onPressed: files.toggleFilesSortOrder,
                   ),
                   // A plain width, not Expanded - this row scrolls
                   // horizontally now, which gives every control unbounded
@@ -462,16 +468,16 @@ class _FilesViewState extends State<FilesView>
                   SizedBox(
                     width: 130,
                     child: SortMenuButton(
-                      field: provider.filesSortField,
-                      onChanged: provider.setFilesSortField,
+                      field: files.filesSortField,
+                      onChanged: files.setFilesSortField,
                     ),
                   ),
                   ToggleIconButton(
-                    icon: provider.showHiddenFiles
+                    icon: files.showHiddenFiles
                         ? Icons.visibility_rounded
                         : Icons.visibility_off_rounded,
-                    isSelected: provider.showHiddenFiles,
-                    onTap: () => provider.toggleShowHiddenFiles(),
+                    isSelected: files.showHiddenFiles,
+                    onTap: () => files.toggleShowHiddenFiles(),
                     tooltip: 'Show hidden files',
                   ),
                   const SizedBox(width: 4),
@@ -479,17 +485,17 @@ class _FilesViewState extends State<FilesView>
                     children: [
                       ToggleIconButton(
                         icon: Symbols.circles_rounded,
-                        isSelected: provider.storageScope == StorageScope.cloud,
+                        isSelected: files.storageScope == StorageScope.cloud,
                         onTap: () =>
-                            provider.setStorageScope(StorageScope.cloud),
+                            files.setStorageScope(StorageScope.cloud),
                         tooltip: 'Cloud storage',
                       ),
                       ToggleIconButton(
                         icon: Symbols.hard_drive_rounded,
                         isSelected:
-                            provider.storageScope == StorageScope.external,
+                            files.storageScope == StorageScope.external,
                         onTap: () =>
-                            provider.setStorageScope(StorageScope.external),
+                            files.setStorageScope(StorageScope.external),
                         tooltip: 'External storage',
                       ),
                     ],
@@ -500,17 +506,17 @@ class _FilesViewState extends State<FilesView>
                       ToggleIconButton(
                         icon: Icons.select_all_rounded,
                         isSelected:
-                            provider.filesTypeFilter == FilesTypeFilter.all,
+                            files.filesTypeFilter == FilesTypeFilter.all,
                         onTap: () =>
-                            provider.setFilesTypeFilter(FilesTypeFilter.all),
+                            files.setFilesTypeFilter(FilesTypeFilter.all),
                         tooltip: 'Files & folders',
                       ),
                       ToggleIconButton(
                         icon: Icons.insert_drive_file_outlined,
                         isSelected:
-                            provider.filesTypeFilter ==
+                            files.filesTypeFilter ==
                             FilesTypeFilter.filesOnly,
-                        onTap: () => provider.setFilesTypeFilter(
+                        onTap: () => files.setFilesTypeFilter(
                           FilesTypeFilter.filesOnly,
                         ),
                         tooltip: 'Files only',
@@ -518,9 +524,9 @@ class _FilesViewState extends State<FilesView>
                       ToggleIconButton(
                         icon: Icons.folder_outlined,
                         isSelected:
-                            provider.filesTypeFilter ==
+                            files.filesTypeFilter ==
                             FilesTypeFilter.foldersOnly,
-                        onTap: () => provider.setFilesTypeFilter(
+                        onTap: () => files.setFilesTypeFilter(
                           FilesTypeFilter.foldersOnly,
                         ),
                         tooltip: 'Folders only',
@@ -532,14 +538,14 @@ class _FilesViewState extends State<FilesView>
                     children: [
                       ToggleIconButton(
                         icon: Icons.view_list_rounded,
-                        isSelected: !provider.isGridView,
-                        onTap: () => provider.setGridView(false),
+                        isSelected: !files.isGridView,
+                        onTap: () => files.setGridView(false),
                         tooltip: 'List view',
                       ),
                       ToggleIconButton(
                         icon: Icons.grid_view_rounded,
-                        isSelected: provider.isGridView,
-                        onTap: () => provider.setGridView(true),
+                        isSelected: files.isGridView,
+                        onTap: () => files.setGridView(true),
                         tooltip: 'Grid view',
                       ),
                     ],
@@ -553,8 +559,8 @@ class _FilesViewState extends State<FilesView>
             SizedBox(
               height: 32,
               child: Breadcrumbs(
-                pathStack: provider.pathStack,
-                onTap: (index) => provider.navigateToPathIndex(index),
+                pathStack: files.pathStack,
+                onTap: (index) => files.navigateToPathIndex(index),
               ),
             ),
           ],
@@ -574,12 +580,12 @@ class _FilesViewState extends State<FilesView>
         ),
       ),
       // Files List / Grid
-      if (provider.isLoading)
+      if (files.isLoading)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
         )
-      else if (provider.errorMessage != null)
+      else if (files.errorMessage != null)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -603,7 +609,7 @@ class _FilesViewState extends State<FilesView>
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    provider.errorMessage!,
+                    files.errorMessage!,
                     textAlign: TextAlign.center,
                     style: theme.textTheme.bodyMedium?.copyWith(
                       color: colorScheme.onSurfaceVariant,
@@ -611,7 +617,7 @@ class _FilesViewState extends State<FilesView>
                   ),
                   const SizedBox(height: 20),
                   FilledButton.icon(
-                    onPressed: provider.refreshData,
+                    onPressed: files.refreshData,
                     icon: const Icon(Icons.refresh_rounded),
                     label: const Text('Retry Connection'),
                   ),
@@ -620,7 +626,7 @@ class _FilesViewState extends State<FilesView>
             ),
           ),
         )
-      else if (provider.items.isEmpty)
+      else if (files.items.isEmpty)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -643,7 +649,7 @@ class _FilesViewState extends State<FilesView>
             ),
           ),
         )
-      else if (provider.isGridView)
+      else if (files.isGridView)
         SliverPadding(
           key: const ValueKey('files-grid'),
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
@@ -655,14 +661,14 @@ class _FilesViewState extends State<FilesView>
               mainAxisSpacing: 12,
             ),
             delegate: SliverChildBuilderDelegate((context, index) {
-              final item = provider.items[index];
+              final item = files.items[index];
               return _FolderEnterAnimation(
-                key: ValueKey('${provider.currentFolderPath}::${item.id}'),
+                key: ValueKey('${files.currentFolderPath}::${item.id}'),
                 index: index,
                 fromRight: navigatingDeeper,
-                child: _buildGridCard(context, item, provider),
+                child: _buildGridCard(context, item),
               );
-            }, childCount: provider.items.length),
+            }, childCount: files.items.length),
           ),
         )
       else
@@ -671,14 +677,14 @@ class _FilesViewState extends State<FilesView>
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
-              final item = provider.items[index];
+              final item = files.items[index];
               return _FolderEnterAnimation(
-                key: ValueKey('${provider.currentFolderPath}::${item.id}'),
+                key: ValueKey('${files.currentFolderPath}::${item.id}'),
                 index: index,
                 fromRight: navigatingDeeper,
-                child: _buildListTile(context, item, provider),
+                child: _buildListTile(context, item),
               );
-            }, childCount: provider.items.length),
+            }, childCount: files.items.length),
           ),
         ),
 
@@ -693,29 +699,28 @@ class _FilesViewState extends State<FilesView>
     ];
 
     return PopScope(
-      canPop: !_isSelecting && provider.pathStack.length <= 1,
+      canPop: !_isSelecting && files.pathStack.length <= 1,
       onPopInvokedWithResult: (didPop, result) {
         if (didPop) return;
         if (_isSelecting) {
           _clearSelection();
         } else {
-          provider.navigateUp();
+          files.navigateUp();
         }
       },
       child: SyncedHeaderScaffold(
         scrollController: widget.scrollController,
-        provider: provider,
         actions: [
           IconButton(
             icon: const Icon(Icons.add_rounded),
             tooltip: 'New',
-            onPressed: () => _showCreateMenu(context, provider),
+            onPressed: () => _showCreateMenu(context),
           ),
           const MoreTabsButton(),
           const ProfileAvatarButton(),
         ],
         selectionBar: _isSelecting
-            ? _buildSelectionBar(context, theme, provider, selectedItems)
+            ? _buildSelectionBar(context, theme, selectedItems)
             : null,
         contentSlivers: contentSlivers,
       ),
@@ -728,7 +733,6 @@ class _FilesViewState extends State<FilesView>
   Widget _buildSelectionBar(
     BuildContext context,
     ThemeData theme,
-    ServerProvider provider,
     List<NextcloudItem> selectedItems,
   ) {
     return Padding(
@@ -771,7 +775,7 @@ class _FilesViewState extends State<FilesView>
                 mainAxisSize: MainAxisSize.min,
                 children: [
                   for (final action in _buildSelectionActions(
-                    provider,
+                    context,
                     selectedItems,
                   ))
                     IconButton(
@@ -790,13 +794,14 @@ class _FilesViewState extends State<FilesView>
   }
 
   Future<void> _favoriteSelected(
-    ServerProvider provider,
+    BuildContext context,
     List<NextcloudItem> items,
   ) async {
+    final ops = context.read<ItemOperations>();
     final allFavorited = items.every((i) => i.isFavorite);
     for (final item in items) {
       if (item.isFavorite == allFavorited) {
-        await provider.toggleItemFavorite(item);
+        await ops.toggleItemFavorite(item);
       }
     }
     _clearSelection();
@@ -810,9 +815,10 @@ class _FilesViewState extends State<FilesView>
   /// notification for the whole selection instead of blocking here.
   Future<void> _downloadSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
+    final session = context.read<SessionController>();
+    final sync = context.read<SyncStatusController>();
     final files = items.where((i) => !i.isFolder).toList();
     _clearSelection();
     if (files.isEmpty) return;
@@ -822,9 +828,9 @@ class _FilesViewState extends State<FilesView>
     // Already mirrored locally by device sync (every selected file, not
     // just some)? Save straight from the local copy instead of a fresh
     // network fetch through DownloadService - see
-    // ServerProvider.localSyncedFilePath.
+    // SyncStatusController.localSyncedFilePath.
     final localPaths = await Future.wait(
-      files.map(provider.localSyncedFilePath),
+      files.map(sync.localSyncedFilePath),
     );
     if (localPaths.every((path) => path != null)) {
       try {
@@ -859,7 +865,7 @@ class _FilesViewState extends State<FilesView>
     }
 
     try {
-      await DownloadService.startDownload(provider, files);
+      await DownloadService.startDownload(session, files);
       messenger.showSnackBar(
         SnackBar(
           content: Text(
@@ -882,7 +888,6 @@ class _FilesViewState extends State<FilesView>
 
   Future<void> _confirmDeleteSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
     final confirmed = await showDialog<bool>(
@@ -912,9 +917,10 @@ class _FilesViewState extends State<FilesView>
     if (confirmed != true || !context.mounted) return;
 
     final messenger = ScaffoldMessenger.of(context);
+    final ops = context.read<ItemOperations>();
     var succeeded = 0;
     for (final item in items) {
-      final success = await provider.deleteItem(item.path);
+      final success = await ops.deleteItem(item.path);
       if (success) succeeded++;
     }
 
@@ -928,7 +934,7 @@ class _FilesViewState extends State<FilesView>
   }
 
   Future<void> _moveOrCopySelected(
-    ServerProvider provider,
+    BuildContext context,
     List<NextcloudItem> items, {
     required bool copy,
   }) async {
@@ -937,7 +943,7 @@ class _FilesViewState extends State<FilesView>
       items,
       copy: copy,
     );
-    if (!mounted || result == null) return;
+    if (!context.mounted || result == null) return;
     _clearSelection();
     ScaffoldMessenger.of(context).showSnackBar(
       SnackBar(
@@ -949,13 +955,15 @@ class _FilesViewState extends State<FilesView>
     );
   }
 
-  Widget _buildListTile(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildListTile(BuildContext context, NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
+    final files = context.watch<FilesController>();
+    final pick = context.watch<PickController>();
+    final sync = context.watch<SyncStatusController>();
+    final session = context.watch<SessionController>();
+    final settings = context.watch<SettingsController>();
+    final ops = context.read<ItemOperations>();
     final isSelected = _selectedIds.contains(item.id);
 
     // No border radius here — the outer ClipRRect below is the only place
@@ -968,17 +976,17 @@ class _FilesViewState extends State<FilesView>
           : colorScheme.surfaceContainerLow,
       child: InkWell(
         onTap: () {
-          if (provider.isPicking) {
-            _handlePickTap(context, provider, item);
+          if (pick.isPicking) {
+            _handlePickTap(context, item);
           } else if (_isSelecting) {
             _toggleSelection(item);
           } else if (item.isFolder) {
-            provider.navigateToFolder(item.path);
+            files.navigateToFolder(item.path);
           } else {
-            _openFile(context, item, provider);
+            _openFile(context, item);
           }
         },
-        onLongPress: provider.isPicking && !provider.pickRequest!.allowMultiple
+        onLongPress: pick.isPicking && !pick.pickRequest!.allowMultiple
             ? null
             : () => _toggleSelection(item),
         child: Padding(
@@ -994,7 +1002,7 @@ class _FilesViewState extends State<FilesView>
                     checkmarkSize: 24,
                     child: ItemThumbnail(
                       item: item,
-                      provider: provider,
+                      service: session.service,
                       size: 44,
                       borderRadius: 12,
                       iconSize: 22,
@@ -1004,7 +1012,7 @@ class _FilesViewState extends State<FilesView>
                     right: -2,
                     bottom: -2,
                     child: SyncStatusBadge(
-                      status: provider.syncStatusFor(item),
+                      status: sync.syncStatusFor(item),
                     ),
                   ),
                 ],
@@ -1039,15 +1047,15 @@ class _FilesViewState extends State<FilesView>
       ),
     );
 
-    final content = _isSelecting || provider.isPicking
+    final content = _isSelecting || pick.isPicking
         ? card
         : SwipeableItem(
             itemKey: ValueKey('file-${item.id}'),
             itemName: item.name,
-            provider: provider,
-            onFavorite: () => provider.toggleItemFavorite(item),
+            settings: settings,
+            onFavorite: () => ops.toggleItemFavorite(item),
             onShare: () => ShareSheet.show(context, item),
-            onDelete: () => _deleteViaSwipe(provider, item),
+            onDelete: () => _deleteViaSwipe(item),
             child: card,
           );
 
@@ -1057,11 +1065,9 @@ class _FilesViewState extends State<FilesView>
     );
   }
 
-  Future<void> _deleteViaSwipe(
-    ServerProvider provider,
-    NextcloudItem item,
-  ) async {
-    final success = await provider.deleteItem(item.path);
+  Future<void> _deleteViaSwipe(NextcloudItem item) async {
+    final ops = context.read<ItemOperations>();
+    final success = await ops.deleteItem(item.path);
     if (!mounted) return;
     ScaffoldMessenger.of(context).showSnackBar(
       SnackBar(
@@ -1073,11 +1079,10 @@ class _FilesViewState extends State<FilesView>
     );
   }
 
-  Widget _buildGridCard(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildGridCard(BuildContext context, NextcloudItem item) {
+    final files = context.watch<FilesController>();
+    final pick = context.watch<PickController>();
+    final sync = context.watch<SyncStatusController>();
     final isSelected = _selectedIds.contains(item.id);
     final isMedia =
         (item.type == NextcloudItemType.image ||
@@ -1090,17 +1095,17 @@ class _FilesViewState extends State<FilesView>
       clipBehavior: Clip.antiAlias,
       child: InkWell(
         onTap: () {
-          if (provider.isPicking) {
-            _handlePickTap(context, provider, item);
+          if (pick.isPicking) {
+            _handlePickTap(context, item);
           } else if (_isSelecting) {
             _toggleSelection(item);
           } else if (item.isFolder) {
-            provider.navigateToFolder(item.path);
+            files.navigateToFolder(item.path);
           } else {
-            _openFile(context, item, provider);
+            _openFile(context, item);
           }
         },
-        onLongPress: provider.isPicking && !provider.pickRequest!.allowMultiple
+        onLongPress: pick.isPicking && !pick.pickRequest!.allowMultiple
             ? null
             : () => _toggleSelection(item),
         child: Stack(
@@ -1109,13 +1114,13 @@ class _FilesViewState extends State<FilesView>
               isSelected: isSelected,
               checkmarkSize: 32,
               child: isMedia
-                  ? _buildMediaGridContent(context, item, provider)
+                  ? _buildMediaGridContent(context, item)
                   : _buildPlainGridContent(context, item),
             ),
             Positioned(
               right: 6,
               bottom: 6,
-              child: SyncStatusBadge(status: provider.syncStatusFor(item)),
+              child: SyncStatusBadge(status: sync.syncStatusFor(item)),
             ),
           ],
         ),
@@ -1126,11 +1131,8 @@ class _FilesViewState extends State<FilesView>
   /// Grid content for images/videos: the actual preview fills the whole
   /// card as a background, with the name/size legible over a bottom scrim
   /// — matching a Google Photos-style grid instead of a small icon badge.
-  Widget _buildMediaGridContent(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildMediaGridContent(BuildContext context, NextcloudItem item) {
+    final session = context.watch<SessionController>();
     final theme = Theme.of(context);
 
     return LayoutBuilder(
@@ -1143,7 +1145,7 @@ class _FilesViewState extends State<FilesView>
           children: [
             Image.network(
               item.previewUrl!,
-              headers: provider.service?.authHeaders,
+              headers: session.service?.authHeaders,
               fit: BoxFit.cover,
               cacheWidth: cachePixels,
               cacheHeight: cachePixels,
@@ -1253,18 +1255,15 @@ class _FilesViewState extends State<FilesView>
     );
   }
 
-  void _openFile(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  void _openFile(BuildContext context, NextcloudItem item) {
+    final files = context.read<FilesController>();
     Navigator.push(
       context,
-      FileViewerScreen.route(item: item, siblings: provider.items),
+      FileViewerScreen.route(item: item, siblings: files.items),
     );
   }
 
-  void _showCreateMenu(BuildContext context, ServerProvider provider) {
+  void _showCreateMenu(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
     showModalBottomSheet(
       context: context,
@@ -1293,7 +1292,7 @@ class _FilesViewState extends State<FilesView>
                   title: const Text('New Folder'),
                   onTap: () {
                     Navigator.pop(sheetContext);
-                    _showCreateFolderDialog(context, provider);
+                    _showCreateFolderDialog(context);
                   },
                 ),
               ],
@@ -1304,7 +1303,8 @@ class _FilesViewState extends State<FilesView>
     );
   }
 
-  void _showCreateFolderDialog(BuildContext context, ServerProvider provider) {
+  void _showCreateFolderDialog(BuildContext context) {
+    final files = context.read<FilesController>();
     final controller = TextEditingController();
 
     showDialog(
@@ -1329,7 +1329,7 @@ class _FilesViewState extends State<FilesView>
                 final name = controller.text.trim();
                 if (name.isNotEmpty) {
                   Navigator.pop(context);
-                  final success = await provider.createFolder(name);
+                  final success = await files.createFolder(name);
                   if (context.mounted) {
                     ScaffoldMessenger.of(context).showSnackBar(
                       SnackBar(

lib/views/lock_screen_view.dart

@@ -1,8 +1,8 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
-import '../providers/server_provider.dart';
+import '../providers/session_controller.dart';
 
-/// Shown in place of the main shell whenever [ServerProvider.needsUnlock] is
+/// Shown in place of the main shell whenever [SessionController.needsUnlock] is
 /// true - a fresh app launch with login lock configured, or returning to the
 /// foreground after being backgrounded. Prompts automatically on first show
 /// and again whenever the app resumes while still locked (e.g. the user
@@ -36,13 +36,13 @@ class _LockScreenViewState extends State<LockScreenView>
     if (state != AppLifecycleState.resumed || !mounted || _authenticating) {
       return;
     }
-    if (context.read<ServerProvider>().needsUnlock) _attemptUnlock();
+    if (context.read<SessionController>().needsUnlock) _attemptUnlock();
   }
 
   Future<void> _attemptUnlock() async {
     if (_authenticating || !mounted) return;
     setState(() => _authenticating = true);
-    await context.read<ServerProvider>().attemptUnlock();
+    await context.read<SessionController>().attemptUnlock();
     if (mounted) setState(() => _authenticating = false);
   }
 

lib/views/login_view.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import '../models/saved_account.dart';
-import '../providers/server_provider.dart';
+import '../providers/session_controller.dart';
 import 'login_webview_view.dart';
 
 class LoginView extends StatefulWidget {
@@ -28,7 +28,7 @@ class _LoginViewState extends State<LoginView> {
   void initState() {
     super.initState();
     if (widget.isAddingAccount) {
-      _originalActiveAccountId = context.read<ServerProvider>().activeAccountId;
+      _originalActiveAccountId = context.read<SessionController>().activeAccountId;
     }
   }
 
@@ -41,13 +41,13 @@ class _LoginViewState extends State<LoginView> {
   void _handleContinue() {
     if (!_formKey.currentState!.validate()) return;
     FocusScope.of(context).unfocus();
-    context.read<ServerProvider>().startLoginFlow(
+    context.read<SessionController>().startLoginFlow(
       _urlController.text.trim(),
       addAccount: widget.isAddingAccount,
     );
   }
 
-  /// Resumes a saved account with one tap (see [ServerProvider.switchAccount]).
+  /// Resumes a saved account with one tap (see [SessionController.switchAccount]).
   /// That can fail silently from the account's own perspective - most often
   /// a stored app password that no longer works (revoked server-side, or
   /// left over from before a since-fixed bug that deleted it too eagerly on
@@ -55,8 +55,8 @@ class _LoginViewState extends State<LoginView> {
   /// silently failing every time - a delete button on the row itself (see
   /// [_SavedAccountRow]) is the way out.
   Future<void> _continueAsAccount(SavedAccount account) async {
-    final provider = context.read<ServerProvider>();
-    final success = await provider.switchAccount(account.id);
+    final session = context.read<SessionController>();
+    final success = await session.switchAccount(account.id);
     if (success || !mounted) return;
     ScaffoldMessenger.of(context)
       ..hideCurrentSnackBar()
@@ -98,25 +98,25 @@ class _LoginViewState extends State<LoginView> {
       },
     );
     if (confirmed != true || !mounted) return;
-    await context.read<ServerProvider>().removeAccount(account.id);
+    await context.read<SessionController>().removeAccount(account.id);
   }
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final session = context.watch<SessionController>();
 
     final isAwaitingBrowser =
-        provider.loginFlowStatus == LoginFlowStatus.awaitingBrowser;
-    final isInitiating = provider.loginFlowStatus == LoginFlowStatus.initiating;
+        session.loginFlowStatus == LoginFlowStatus.awaitingBrowser;
+    final isInitiating = session.loginFlowStatus == LoginFlowStatus.initiating;
 
     // A new/refreshed account has just become active - pop back to
     // Settings rather than leaving this form sitting on top of it.
     if (widget.isAddingAccount &&
         !_popped &&
-        provider.loginFlowStatus == LoginFlowStatus.idle &&
-        provider.activeAccountId != _originalActiveAccountId) {
+        session.loginFlowStatus == LoginFlowStatus.idle &&
+        session.activeAccountId != _originalActiveAccountId) {
       _popped = true;
       WidgetsBinding.instance.addPostFrameCallback((_) {
         if (mounted) Navigator.of(context).pop();
@@ -125,14 +125,14 @@ class _LoginViewState extends State<LoginView> {
 
     // Every login (first account or an additional one) shows its login
     // page in LoginWebViewView, a real screen this app owns - see
-    // ServerProvider.startLoginFlow's doc comment for why. Push it the
+    // SessionController.startLoginFlow's doc comment for why. Push it the
     // moment there's a URL to show; _webViewPushed resets once that route
     // pops (cancelled or done) so a retry after cancelling pushes it again.
     if (!_webViewPushed &&
         isAwaitingBrowser &&
-        provider.pendingLoginUrl != null) {
+        session.pendingLoginUrl != null) {
       _webViewPushed = true;
-      final url = provider.pendingLoginUrl!;
+      final url = session.pendingLoginUrl!;
       WidgetsBinding.instance.addPostFrameCallback((_) async {
         if (!mounted) return;
         // A plain MaterialPageRoute's animated slide/fade transition can
@@ -173,9 +173,9 @@ class _LoginViewState extends State<LoginView> {
                   // from here with one tap - no need to repeat
                   // Login Flow v2.
                   if (!widget.isAddingAccount &&
-                      provider.accounts.isNotEmpty) ...[
+                      session.accounts.isNotEmpty) ...[
                     _SavedAccountsSection(
-                      accounts: provider.accounts,
+                      accounts: session.accounts,
                       onSelect: (account) => _continueAsAccount(account),
                       onRemove: (account) => _confirmRemoveAccount(account),
                     ),
@@ -201,10 +201,10 @@ class _LoginViewState extends State<LoginView> {
                     formKey: _formKey,
                     urlController: _urlController,
                     isLoading:
-                        isInitiating || provider.isLoading || isAwaitingBrowser,
+                        isInitiating || session.isLoading || isAwaitingBrowser,
                     errorMessage:
-                        provider.loginFlowStatus == LoginFlowStatus.error
-                        ? provider.errorMessage
+                        session.loginFlowStatus == LoginFlowStatus.error
+                        ? session.errorMessage
                         : null,
                     onContinue: _handleContinue,
                     theme: theme,
@@ -226,9 +226,9 @@ class _LoginViewState extends State<LoginView> {
     // gone - this view could never be popped before "add account" existed,
     // so that case wasn't reachable until now.
     return PopScope(
-      canPop: provider.loginFlowStatus != LoginFlowStatus.awaitingBrowser,
+      canPop: session.loginFlowStatus != LoginFlowStatus.awaitingBrowser,
       onPopInvokedWithResult: (didPop, _) {
-        if (!didPop) provider.cancelLoginFlow();
+        if (!didPop) session.cancelLoginFlow();
       },
       child: body,
     );
@@ -392,7 +392,7 @@ class _ServerForm extends StatelessWidget {
 }
 
 /// Saved accounts a logout left recoverable - tapping one resumes it via
-/// [ServerProvider.switchAccount] instead of repeating Login Flow v2.
+/// [SessionController.switchAccount] instead of repeating Login Flow v2.
 class _SavedAccountsSection extends StatelessWidget {
   final List<SavedAccount> accounts;
   final ValueChanged<SavedAccount> onSelect;

lib/views/login_webview_view.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:webview_flutter/webview_flutter.dart';
-import '../providers/server_provider.dart';
+import '../providers/session_controller.dart';
 
 /// Every Login Flow v2 page - first login or an additional account -
 /// rendered in Flutter's own WebView rather than a Chrome Custom Tab or
@@ -13,7 +13,7 @@ import '../providers/server_provider.dart';
 /// exactly like every other screen in the app - and unlike a Custom Tab,
 /// this screen can close itself automatically once login succeeds.
 ///
-/// See ServerProvider.startLoginFlow's doc comment for the full rationale.
+/// See SessionController.startLoginFlow's doc comment for the full rationale.
 class LoginWebViewView extends StatefulWidget {
   final Uri url;
 
@@ -56,19 +56,19 @@ class _LoginWebViewViewState extends State<LoginWebViewView> {
   }
 
   void _cancel() {
-    context.read<ServerProvider>().cancelLoginFlow();
+    context.read<SessionController>().cancelLoginFlow();
     Navigator.of(context).pop();
   }
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final session = context.watch<SessionController>();
 
     // The login flow finished (success or error) or was cancelled
     // elsewhere - close this screen automatically rather than leaving it
     // sitting open over a flow that's no longer awaiting the browser.
     if (!_popped &&
-        provider.loginFlowStatus != LoginFlowStatus.awaitingBrowser) {
+        session.loginFlowStatus != LoginFlowStatus.awaitingBrowser) {
       _popped = true;
       WidgetsBinding.instance.addPostFrameCallback((_) {
         if (mounted) Navigator.of(context).pop();

lib/views/move_copy_destination_picker.dart

@@ -4,7 +4,9 @@ import 'package:material_symbols_icons/symbols.dart';
 import 'package:provider/provider.dart';
 import '../models/move_copy_result.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/item_operations.dart';
+import '../providers/session_controller.dart';
 import '../widgets/breadcrumbs.dart';
 import '../widgets/item_icon.dart';
 import '../widgets/more_tabs_button.dart';
@@ -18,13 +20,13 @@ import '../widgets/synced_header_scaffold.dart';
 /// Destination-folder browser for moving/copying [items] (a multi-select
 /// batch from Files or Photos). Visually mirrors `ShareUploadView`'s
 /// browser (same chrome/controls/listing), but deliberately does **not**
-/// reuse `ServerProvider`'s shared `currentFolderPath`/`pathStack`/`items`
+/// reuse `FilesController`'s shared `currentFolderPath`/`pathStack`/`items`
 /// navigation state the way that screen does - this is pushed mid-browsing
 /// session (the user was already looking at a specific Files-tab folder
 /// when they selected items and tapped Move/Copy), so clobbering that
 /// shared state here would strand the Files tab in whatever folder this
 /// picker last visited. Instead it owns its own local navigation state and
-/// fetches through `ServerProvider.fetchFolderListing`, a stateless
+/// fetches through `FilesController.fetchFolderListing`, a stateless
 /// pass-through that never touches shared fields - `ShareUploadView` gets
 /// away with the shared state precisely because it always resets to root
 /// and pops all the way to the app root afterward (a cold share-intent
@@ -83,7 +85,9 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
 
   Future<void> _fetch(String path) async {
     setState(() => _isLoading = true);
-    final raw = await context.read<ServerProvider>().fetchFolderListing(path);
+    final raw = await context.read<FilesController>().fetchFolderListing(
+      path,
+    );
     if (!mounted) return;
     setState(() {
       _rawItems = raw;
@@ -109,7 +113,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
     return true;
   }
 
-  /// Client-side mirror of `ServerProvider`'s own authoritative check (see
+  /// Client-side mirror of `ItemOperations`' own authoritative check (see
   /// `_isSelfOrDescendant`) - just for disabling the confirm button with an
   /// explanation up front instead of letting the request round-trip and
   /// fail.
@@ -123,11 +127,11 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
     return false;
   }
 
-  Future<void> _confirm(ServerProvider provider) async {
+  Future<void> _confirm(ItemOperations ops) async {
     setState(() => _isSubmitting = true);
     final result = widget.copy
-        ? await provider.copyItems(widget.items, _currentPath)
-        : await provider.moveItems(widget.items, _currentPath);
+        ? await ops.copyItems(widget.items, _currentPath)
+        : await ops.moveItems(widget.items, _currentPath);
     if (!mounted) return;
 
     if (result.blockedReason != null) {
@@ -151,7 +155,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
       );
       if (!mounted) return;
       if (choices != null) {
-        final resolved = await provider.resolveConflicts(
+        final resolved = await ops.resolveConflicts(
           result.conflicts,
           _currentPath,
           copy: widget.copy,
@@ -171,7 +175,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
     ).pop(MoveCopyResult(succeeded: succeeded, failed: failed));
   }
 
-  Widget _buildControlsRow(ServerProvider provider) {
+  Widget _buildControlsRow(FilesController files) {
     return SizedBox(
       height: 44,
       child: SingleChildScrollView(
@@ -180,28 +184,28 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
           children: [
             IconButton(
               icon: Icon(
-                provider.filesSortAscending
+                files.filesSortAscending
                     ? Icons.arrow_upward_rounded
                     : Icons.arrow_downward_rounded,
                 size: 20,
               ),
               visualDensity: VisualDensity.compact,
-              tooltip: provider.filesSortAscending ? 'Ascending' : 'Descending',
-              onPressed: provider.toggleFilesSortOrder,
+              tooltip: files.filesSortAscending ? 'Ascending' : 'Descending',
+              onPressed: files.toggleFilesSortOrder,
             ),
             SizedBox(
               width: 130,
               child: SortMenuButton(
-                field: provider.filesSortField,
-                onChanged: provider.setFilesSortField,
+                field: files.filesSortField,
+                onChanged: files.setFilesSortField,
               ),
             ),
             ToggleIconButton(
-              icon: provider.showHiddenFiles
+              icon: files.showHiddenFiles
                   ? Icons.visibility_rounded
                   : Icons.visibility_off_rounded,
-              isSelected: provider.showHiddenFiles,
-              onTap: () => provider.toggleShowHiddenFiles(),
+              isSelected: files.showHiddenFiles,
+              onTap: () => files.toggleShowHiddenFiles(),
               tooltip: 'Show hidden files',
             ),
             const SizedBox(width: 4),
@@ -209,14 +213,14 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
               children: [
                 ToggleIconButton(
                   icon: Symbols.circles_rounded,
-                  isSelected: provider.storageScope == StorageScope.cloud,
-                  onTap: () => provider.setStorageScope(StorageScope.cloud),
+                  isSelected: files.storageScope == StorageScope.cloud,
+                  onTap: () => files.setStorageScope(StorageScope.cloud),
                   tooltip: 'Cloud storage',
                 ),
                 ToggleIconButton(
                   icon: Symbols.hard_drive_rounded,
-                  isSelected: provider.storageScope == StorageScope.external,
-                  onTap: () => provider.setStorageScope(StorageScope.external),
+                  isSelected: files.storageScope == StorageScope.external,
+                  onTap: () => files.setStorageScope(StorageScope.external),
                   tooltip: 'External storage',
                 ),
               ],
@@ -226,14 +230,14 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
               children: [
                 ToggleIconButton(
                   icon: Icons.view_list_rounded,
-                  isSelected: !provider.isGridView,
-                  onTap: () => provider.setGridView(false),
+                  isSelected: !files.isGridView,
+                  onTap: () => files.setGridView(false),
                   tooltip: 'List view',
                 ),
                 ToggleIconButton(
                   icon: Icons.grid_view_rounded,
-                  isSelected: provider.isGridView,
-                  onTap: () => provider.setGridView(true),
+                  isSelected: files.isGridView,
+                  onTap: () => files.setGridView(true),
                   tooltip: 'Grid view',
                 ),
               ],
@@ -248,9 +252,10 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
   // the listing matches what the Files tab itself would show for this
   // folder) but are visually dimmed and inert, same treatment as
   // ShareUploadView's own destination browser.
-  Widget _buildListTile(NextcloudItem item, ServerProvider provider) {
+  Widget _buildListTile(NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
+    final session = context.watch<SessionController>();
     final isFolder = item.isFolder;
 
     return Padding(
@@ -272,7 +277,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
                   children: [
                     ItemThumbnail(
                       item: item,
-                      provider: provider,
+                      service: session.service,
                       size: 44,
                       borderRadius: 12,
                       iconSize: 22,
@@ -312,7 +317,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
     );
   }
 
-  Widget _buildGridCard(NextcloudItem item, ServerProvider provider) {
+  Widget _buildGridCard(NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
     final isFolder = item.isFolder;
@@ -379,12 +384,13 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final files = context.watch<FilesController>();
+    final ops = context.read<ItemOperations>();
     final hasBreadcrumbs = _pathStack.length > 1;
     final currentLabel = _currentPath == '/'
         ? 'Home'
         : _currentPath.split('/').where((s) => s.isNotEmpty).last;
-    final items = provider.applyFilesDisplayPrefs(_rawItems);
+    final items = files.applyFilesDisplayPrefs(_rawItems);
     final invalidDestination = _destinationIsInvalid();
 
     final controlsColumn = Padding(
@@ -392,7 +398,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: [
-          _buildControlsRow(provider),
+          _buildControlsRow(files),
           if (hasBreadcrumbs) ...[
             const SizedBox(height: 10),
             SizedBox(
@@ -430,7 +436,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
             ),
           ),
         )
-      else if (provider.isGridView)
+      else if (files.isGridView)
         SliverPadding(
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverGrid(
@@ -441,7 +447,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
               mainAxisSpacing: 12,
             ),
             delegate: SliverChildBuilderDelegate((context, index) {
-              return _buildGridCard(items[index], provider);
+              return _buildGridCard(items[index]);
             }, childCount: items.length),
           ),
         )
@@ -450,7 +456,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
-              return _buildListTile(items[index], provider);
+              return _buildListTile(items[index]);
             }, childCount: items.length),
           ),
         ),
@@ -465,7 +471,6 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
       child: Scaffold(
         body: SyncedHeaderScaffold(
           scrollController: _scrollController,
-          provider: provider,
           actions: const [MoreTabsButton(), ProfileAvatarButton()],
           contentSlivers: contentSlivers,
         ),
@@ -499,7 +504,7 @@ class _MoveCopyDestinationPickerState extends State<MoveCopyDestinationPicker> {
                     child: FilledButton.icon(
                       onPressed: invalidDestination || _isSubmitting
                           ? null
-                          : () => _confirm(provider),
+                          : () => _confirm(ops),
                       icon: _isSubmitting
                           ? const SizedBox(
                               width: 18,

lib/views/photos_view.dart

@@ -5,7 +5,11 @@ import 'package:provider/provider.dart';
 import 'package:share_plus/share_plus.dart';
 import '../models/nextcloud_item.dart';
 import '../models/selection_action.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/item_operations.dart';
+import '../providers/photos_controller.dart';
+import '../providers/pick_controller.dart';
+import '../providers/session_controller.dart';
 import '../services/download_service.dart';
 import '../widgets/details/details_sheet.dart';
 import '../widgets/more_tabs_button.dart';
@@ -111,10 +115,10 @@ class _PhotosViewState extends State<PhotosView>
   /// just the matching/toggle/immediate-confirm branch.
   void _handlePickTap(
     BuildContext context,
-    ServerProvider provider,
+    PickController pick,
     NextcloudItem item,
   ) {
-    if (!provider.itemMatchesPickFilter(item)) {
+    if (!pick.itemMatchesPickFilter(item)) {
       ScaffoldMessenger.of(context).showSnackBar(
         const SnackBar(
           content: Text("This app can't accept this file type"),
@@ -123,25 +127,25 @@ class _PhotosViewState extends State<PhotosView>
       );
       return;
     }
-    if (provider.pickRequest!.allowMultiple) {
+    if (pick.pickRequest!.allowMultiple) {
       _toggleSelection(item);
     } else {
-      provider.confirmPick([item]);
+      pick.confirmPick([item]);
     }
   }
 
   /// The bulk actions shown in the sticky selection toolbar for the
   /// currently-selected items.
   List<SelectionAction> _buildSelectionActions(
-    ServerProvider provider,
+    PickController pick,
     List<NextcloudItem> selected,
   ) {
-    if (provider.isPicking) {
+    if (pick.isPicking) {
       return [
         SelectionAction(
           icon: Icons.check_rounded,
           label: 'Use ${selected.length} item(s)',
-          onTap: () => provider.confirmPick(selected),
+          onTap: () => pick.confirmPick(selected),
         ),
       ];
     }
@@ -153,34 +157,34 @@ class _PhotosViewState extends State<PhotosView>
         label: selected.every((i) => i.isFavorite)
             ? 'Remove from favorites'
             : 'Favorite',
-        onTap: () => _favoriteSelected(provider, selected),
+        onTap: () => _favoriteSelected(selected),
       ),
       SelectionAction(
         icon: Icons.share_rounded,
         label: 'Share',
         onTap: () => selected.length == 1
             ? ShareSheet.show(context, selected.single)
-            : _shareSelected(context, provider, selected),
+            : _shareSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.download_rounded,
         label: 'Download',
-        onTap: () => _downloadSelected(context, provider, selected),
+        onTap: () => _downloadSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.delete_outline_rounded,
         label: 'Delete',
-        onTap: () => _confirmDeleteSelected(context, provider, selected),
+        onTap: () => _confirmDeleteSelected(context, selected),
       ),
       SelectionAction(
         icon: Icons.copy_rounded,
         label: 'Copy',
-        onTap: () => _moveOrCopySelected(provider, selected, copy: true),
+        onTap: () => _moveOrCopySelected(selected, copy: true),
       ),
       SelectionAction(
         icon: Icons.drive_file_move_rounded,
         label: 'Move',
-        onTap: () => _moveOrCopySelected(provider, selected, copy: false),
+        onTap: () => _moveOrCopySelected(selected, copy: false),
       ),
       if (selected.length == 1)
         SelectionAction(
@@ -195,16 +199,18 @@ class _PhotosViewState extends State<PhotosView>
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final photosController = context.watch<PhotosController>();
+    final filesController = context.watch<FilesController>();
+    final pick = context.watch<PickController>();
 
     if (!_requested) {
       _requested = true;
       WidgetsBinding.instance.addPostFrameCallback(
-        (_) => provider.fetchAllMedia(),
+        (_) => photosController.fetchAllMedia(),
       );
     }
 
-    final photos = provider.photoItems;
+    final photos = photosController.items;
     final selectedItems = photos
         .where((i) => _selectedIds.contains(i.id))
         .toList();
@@ -217,38 +223,38 @@ class _PhotosViewState extends State<PhotosView>
           children: [
             IconButton(
               icon: Icon(
-                provider.photosSortAscending
+                photosController.sortAscending
                     ? Icons.arrow_upward_rounded
                     : Icons.arrow_downward_rounded,
                 size: 20,
               ),
               visualDensity: VisualDensity.compact,
-              tooltip: provider.photosSortAscending
+              tooltip: photosController.sortAscending
                   ? 'Ascending'
                   : 'Descending',
-              onPressed: provider.togglePhotosSortOrder,
+              onPressed: photosController.toggleSortOrder,
             ),
             Expanded(
               child: SortMenuButton(
-                field: provider.photosSortField,
-                onChanged: provider.setPhotosSortField,
+                field: photosController.sortField,
+                onChanged: photosController.setSortField,
               ),
             ),
             ToggleIconButton(
-              icon: provider.showFavoritesOnlyPhotos
+              icon: photosController.showFavoritesOnly
                   ? Icons.favorite_rounded
                   : Icons.favorite_border_rounded,
-              isSelected: provider.showFavoritesOnlyPhotos,
-              onTap: provider.toggleFavoritesFilterPhotos,
+              isSelected: photosController.showFavoritesOnly,
+              onTap: photosController.toggleFavoritesFilter,
               tooltip: 'Favorites only',
             ),
             const SizedBox(width: 4),
             ToggleIconButton(
-              icon: provider.showHiddenPhotos
+              icon: photosController.showHidden
                   ? Icons.visibility_rounded
                   : Icons.visibility_off_rounded,
-              isSelected: provider.showHiddenPhotos,
-              onTap: () => provider.toggleShowHiddenPhotos(),
+              isSelected: photosController.showHidden,
+              onTap: () => photosController.toggleShowHidden(),
               tooltip: 'Show hidden files',
             ),
             const SizedBox(width: 4),
@@ -256,14 +262,17 @@ class _PhotosViewState extends State<PhotosView>
               children: [
                 ToggleIconButton(
                   icon: Symbols.circles_rounded,
-                  isSelected: provider.storageScope == StorageScope.cloud,
-                  onTap: () => provider.setStorageScope(StorageScope.cloud),
+                  isSelected: filesController.storageScope == StorageScope.cloud,
+                  onTap: () =>
+                      filesController.setStorageScope(StorageScope.cloud),
                   tooltip: 'Cloud storage',
                 ),
                 ToggleIconButton(
                   icon: Symbols.hard_drive_rounded,
-                  isSelected: provider.storageScope == StorageScope.external,
-                  onTap: () => provider.setStorageScope(StorageScope.external),
+                  isSelected:
+                      filesController.storageScope == StorageScope.external,
+                  onTap: () =>
+                      filesController.setStorageScope(StorageScope.external),
                   tooltip: 'External storage',
                 ),
               ],
@@ -283,12 +292,12 @@ class _PhotosViewState extends State<PhotosView>
       ),
       const SliverToBoxAdapter(child: SizedBox(height: 8)),
 
-      if (provider.isMediaLoading && photos.isEmpty)
+      if (photosController.isLoading && photos.isEmpty)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
         )
-      else if (provider.mediaErrorMessage != null)
+      else if (photosController.errorMessage != null)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -312,7 +321,7 @@ class _PhotosViewState extends State<PhotosView>
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    provider.mediaErrorMessage!,
+                    photosController.errorMessage!,
                     textAlign: TextAlign.center,
                     style: theme.textTheme.bodyMedium?.copyWith(
                       color: colorScheme.onSurfaceVariant,
@@ -320,7 +329,7 @@ class _PhotosViewState extends State<PhotosView>
                   ),
                   const SizedBox(height: 20),
                   FilledButton.icon(
-                    onPressed: provider.fetchAllMedia,
+                    onPressed: photosController.fetchAllMedia,
                     icon: const Icon(Icons.refresh_rounded),
                     label: const Text('Retry'),
                   ),
@@ -364,7 +373,7 @@ class _PhotosViewState extends State<PhotosView>
             ),
             delegate: SliverChildBuilderDelegate((context, index) {
               final photo = photos[index];
-              return _buildPhotoTile(context, photo, provider);
+              return _buildPhotoTile(context, photo);
             }, childCount: photos.length),
           ),
         ),
@@ -385,11 +394,10 @@ class _PhotosViewState extends State<PhotosView>
       },
       child: SyncedHeaderScaffold(
         scrollController: widget.scrollController,
-        provider: provider,
         actions: const [MoreTabsButton(), ProfileAvatarButton()],
-        onRefresh: provider.fetchAllMedia,
+        onRefresh: photosController.fetchAllMedia,
         selectionBar: _isSelecting
-            ? _buildSelectionBar(context, theme, provider, selectedItems)
+            ? _buildSelectionBar(context, theme, pick, selectedItems)
             : null,
         contentSlivers: contentSlivers,
       ),
@@ -402,7 +410,7 @@ class _PhotosViewState extends State<PhotosView>
   Widget _buildSelectionBar(
     BuildContext context,
     ThemeData theme,
-    ServerProvider provider,
+    PickController pick,
     List<NextcloudItem> selectedItems,
   ) {
     return Padding(
@@ -445,7 +453,7 @@ class _PhotosViewState extends State<PhotosView>
                 mainAxisSize: MainAxisSize.min,
                 children: [
                   for (final action in _buildSelectionActions(
-                    provider,
+                    pick,
                     selectedItems,
                   ))
                     IconButton(
@@ -463,12 +471,10 @@ class _PhotosViewState extends State<PhotosView>
     );
   }
 
-  Widget _buildPhotoTile(
-    BuildContext context,
-    NextcloudItem photo,
-    ServerProvider provider,
-  ) {
+  Widget _buildPhotoTile(BuildContext context, NextcloudItem photo) {
     final colorScheme = Theme.of(context).colorScheme;
+    final pick = context.watch<PickController>();
+    final session = context.watch<SessionController>();
     final isSelected = _selectedIds.contains(photo.id);
 
     // No border radius on the tile itself — the outer ClipRRect below is
@@ -476,15 +482,15 @@ class _PhotosViewState extends State<PhotosView>
     // floating rounded corner mid-drag (see the same fix in files_view).
     final tile = GestureDetector(
       onTap: () {
-        if (provider.isPicking) {
-          _handlePickTap(context, provider, photo);
+        if (pick.isPicking) {
+          _handlePickTap(context, pick, photo);
         } else if (_isSelecting) {
           _toggleSelection(photo);
         } else {
-          _openLightbox(context, photo, provider);
+          _openLightbox(context, photo);
         }
       },
-      onLongPress: provider.isPicking && !provider.pickRequest!.allowMultiple
+      onLongPress: pick.isPicking && !pick.pickRequest!.allowMultiple
           ? null
           : () => _toggleSelection(photo),
       child: ColoredBox(
@@ -507,7 +513,7 @@ class _PhotosViewState extends State<PhotosView>
                                 .round();
                         return Image.network(
                           photo.previewUrl!,
-                          headers: provider.service?.authHeaders,
+                          headers: session.service?.authHeaders,
                           fit: BoxFit.cover,
                           cacheWidth: cachePixels,
                           cacheHeight: cachePixels,
@@ -571,25 +577,20 @@ class _PhotosViewState extends State<PhotosView>
     );
   }
 
-  void _openLightbox(
-    BuildContext context,
-    NextcloudItem photo,
-    ServerProvider provider,
-  ) {
+  void _openLightbox(BuildContext context, NextcloudItem photo) {
+    final photos = context.read<PhotosController>().items;
     Navigator.push(
       context,
-      FileViewerScreen.route(item: photo, siblings: provider.photoItems),
+      FileViewerScreen.route(item: photo, siblings: photos),
     );
   }
 
-  Future<void> _favoriteSelected(
-    ServerProvider provider,
-    List<NextcloudItem> items,
-  ) async {
+  Future<void> _favoriteSelected(List<NextcloudItem> items) async {
+    final ops = context.read<ItemOperations>();
     final allFavorited = items.every((i) => i.isFavorite);
     for (final item in items) {
       if (item.isFavorite == allFavorited) {
-        await provider.toggleItemFavorite(item);
+        await ops.toggleItemFavorite(item);
       }
     }
     _clearSelection();
@@ -597,9 +598,9 @@ class _PhotosViewState extends State<PhotosView>
 
   Future<void> _shareSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
     messenger.showSnackBar(
       const SnackBar(
@@ -610,7 +611,7 @@ class _PhotosViewState extends State<PhotosView>
 
     final lines = <String>[];
     for (final item in items) {
-      final link = await provider.createShareLink(item);
+      final link = await ops.createShareLink(item);
       if (link != null) {
         lines.add(items.length > 1 ? '${item.name}: $link' : link);
       }
@@ -646,13 +647,13 @@ class _PhotosViewState extends State<PhotosView>
   /// `FilesView._downloadSelected`'s identical doc comment for why.
   Future<void> _downloadSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
+    final session = context.read<SessionController>();
     _clearSelection();
     final messenger = ScaffoldMessenger.of(context);
     try {
-      await DownloadService.startDownload(provider, items);
+      await DownloadService.startDownload(session, items);
       messenger.showSnackBar(
         SnackBar(
           content: Text(
@@ -675,7 +676,6 @@ class _PhotosViewState extends State<PhotosView>
 
   Future<void> _confirmDeleteSelected(
     BuildContext context,
-    ServerProvider provider,
     List<NextcloudItem> items,
   ) async {
     final confirmed = await showDialog<bool>(
@@ -704,10 +704,11 @@ class _PhotosViewState extends State<PhotosView>
     );
     if (confirmed != true || !context.mounted) return;
 
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
     var succeeded = 0;
     for (final item in items) {
-      final success = await provider.deleteItem(item.path);
+      final success = await ops.deleteItem(item.path);
       if (success) succeeded++;
     }
 
@@ -721,7 +722,6 @@ class _PhotosViewState extends State<PhotosView>
   }
 
   Future<void> _moveOrCopySelected(
-    ServerProvider provider,
     List<NextcloudItem> items, {
     required bool copy,
   }) async {

lib/views/recent_view.dart

@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/recent_controller.dart';
 import '../widgets/more_tabs_button.dart';
 import '../widgets/profile_avatar_button.dart';
 import '../widgets/synced_header_scaffold.dart';
@@ -48,7 +48,7 @@ Color _recentItemIconColor(BuildContext context, NextcloudItemType type) {
 }
 
 /// Recently modified files across the whole account (not folders), newest
-/// first — see [ServerProvider.fetchRecent].
+/// first — see [RecentController.fetchAll].
 class RecentView extends StatefulWidget {
   final ScrollController scrollController;
 
@@ -65,26 +65,24 @@ class _RecentViewState extends State<RecentView> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final recent = context.watch<RecentController>();
 
     if (!_requested) {
       _requested = true;
-      WidgetsBinding.instance.addPostFrameCallback(
-        (_) => provider.fetchRecent(),
-      );
+      WidgetsBinding.instance.addPostFrameCallback((_) => recent.fetchAll());
     }
 
-    final items = provider.recentItems;
+    final items = recent.items;
 
     final List<Widget> contentSlivers = [
       const SliverToBoxAdapter(child: SizedBox(height: 16)),
 
-      if (provider.isRecentLoading && items.isEmpty)
+      if (recent.isLoading && items.isEmpty)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
         )
-      else if (provider.recentErrorMessage != null)
+      else if (recent.errorMessage != null)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -108,7 +106,7 @@ class _RecentViewState extends State<RecentView> {
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    provider.recentErrorMessage!,
+                    recent.errorMessage!,
                     textAlign: TextAlign.center,
                     style: theme.textTheme.bodyMedium?.copyWith(
                       color: colorScheme.onSurfaceVariant,
@@ -116,7 +114,7 @@ class _RecentViewState extends State<RecentView> {
                   ),
                   const SizedBox(height: 20),
                   FilledButton.icon(
-                    onPressed: provider.fetchRecent,
+                    onPressed: recent.fetchAll,
                     icon: const Icon(Icons.refresh_rounded),
                     label: const Text('Retry'),
                   ),
@@ -154,7 +152,7 @@ class _RecentViewState extends State<RecentView> {
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
               final item = items[index];
-              return _buildTile(context, item, provider);
+              return _buildTile(context, item);
             }, childCount: items.length),
           ),
         ),
@@ -165,18 +163,13 @@ class _RecentViewState extends State<RecentView> {
 
     return SyncedHeaderScaffold(
       scrollController: widget.scrollController,
-      provider: provider,
       actions: const [MoreTabsButton(), ProfileAvatarButton()],
-      onRefresh: provider.fetchRecent,
+      onRefresh: recent.fetchAll,
       contentSlivers: contentSlivers,
     );
   }
 
-  Widget _buildTile(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildTile(BuildContext context, NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
     final iconColor = _recentItemIconColor(context, item.type);
@@ -192,7 +185,7 @@ class _RecentViewState extends State<RecentView> {
         borderRadius: BorderRadius.circular(16),
         child: InkWell(
           borderRadius: BorderRadius.circular(16),
-          onTap: () => _openFile(context, item, provider),
+          onTap: () => _openFile(context, item),
           child: Padding(
             padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
             child: Row(
@@ -248,12 +241,9 @@ class _RecentViewState extends State<RecentView> {
     );
   }
 
-  void _openFile(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
-    final siblings = provider.recentItems.where((i) => i.isMedia).toList();
+  void _openFile(BuildContext context, NextcloudItem item) {
+    final recent = context.read<RecentController>();
+    final siblings = recent.items.where((i) => i.isMedia).toList();
     Navigator.push(
       context,
       FileViewerScreen.route(item: item, siblings: siblings),

lib/views/search_view.dart

@@ -5,7 +5,8 @@ import 'package:path/path.dart' as p;
 import 'package:provider/provider.dart';
 import '../models/app_tab.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/settings_controller.dart';
 import 'file_viewer_screen.dart';
 
 class SearchView extends StatefulWidget {
@@ -50,13 +51,13 @@ class _SearchViewState extends State<SearchView> {
   }
 
   Future<void> _runSearch(String query) async {
-    final provider = context.read<ServerProvider>();
+    final files = context.read<FilesController>();
     setState(() {
       _isSearching = true;
       _error = null;
     });
     try {
-      final results = await provider.searchFiles(query);
+      final results = await files.searchFiles(query);
       if (!mounted) return;
       setState(() {
         _results = results;
@@ -98,12 +99,13 @@ class _SearchViewState extends State<SearchView> {
   /// browsing before), switches the shell to the Files tab, and closes
   /// search. For a file, also opens it once back on Files.
   Future<void> _openResult(NextcloudItem item) async {
-    final provider = context.read<ServerProvider>();
+    final files = context.read<FilesController>();
+    final settings = context.read<SettingsController>();
     final navigator = Navigator.of(context);
 
     final folderPath = item.isFolder ? item.path : p.dirname(item.path);
-    await provider.navigateToAbsoluteFolder(folderPath);
-    provider.requestTab(AppTab.files);
+    await files.navigateToAbsoluteFolder(folderPath);
+    settings.requestTab(AppTab.files);
     navigator.popUntil((route) => route.isFirst);
 
     if (!item.isFolder) {

lib/views/share_upload_view.dart

@@ -4,7 +4,9 @@ import 'package:material_symbols_icons/symbols.dart';
 import 'package:provider/provider.dart';
 import '../models/app_tab.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/session_controller.dart';
+import '../providers/settings_controller.dart';
 import '../services/share_intent_service.dart';
 import '../services/upload_service.dart';
 import '../widgets/breadcrumbs.dart';
@@ -43,7 +45,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
     // Shared files have no relationship to wherever the user was last
     // browsing, so start the destination picker fresh at the root.
     WidgetsBinding.instance.addPostFrameCallback((_) {
-      if (mounted) context.read<ServerProvider>().navigateToAbsoluteFolder('/');
+      if (mounted) context.read<FilesController>().navigateToAbsoluteFolder('/');
     });
   }
 
@@ -53,11 +55,13 @@ class _ShareUploadViewState extends State<ShareUploadView> {
     super.dispose();
   }
 
-  Future<void> _uploadHere(ServerProvider provider) async {
+  Future<void> _uploadHere(SessionController session) async {
     final messenger = ScaffoldMessenger.of(context);
     final navigator = Navigator.of(context);
+    final files = context.read<FilesController>();
+    final settings = context.read<SettingsController>();
     try {
-      await UploadService.startUpload(provider, widget.files);
+      await UploadService.startUpload(session, files, widget.files);
     } catch (e) {
       messenger.showSnackBar(
         SnackBar(
@@ -68,7 +72,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
       return;
     }
 
-    provider.requestTab(AppTab.files);
+    settings.requestTab(AppTab.files);
     navigator.popUntil((route) => route.isFirst);
     messenger.showSnackBar(
       SnackBar(
@@ -82,7 +86,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
     );
   }
 
-  Widget _buildControlsRow(ServerProvider provider) {
+  Widget _buildControlsRow(FilesController files) {
     return SizedBox(
       height: 44,
       child: SingleChildScrollView(
@@ -91,28 +95,28 @@ class _ShareUploadViewState extends State<ShareUploadView> {
           children: [
             IconButton(
               icon: Icon(
-                provider.filesSortAscending
+                files.filesSortAscending
                     ? Icons.arrow_upward_rounded
                     : Icons.arrow_downward_rounded,
                 size: 20,
               ),
               visualDensity: VisualDensity.compact,
-              tooltip: provider.filesSortAscending ? 'Ascending' : 'Descending',
-              onPressed: provider.toggleFilesSortOrder,
+              tooltip: files.filesSortAscending ? 'Ascending' : 'Descending',
+              onPressed: files.toggleFilesSortOrder,
             ),
             SizedBox(
               width: 130,
               child: SortMenuButton(
-                field: provider.filesSortField,
-                onChanged: provider.setFilesSortField,
+                field: files.filesSortField,
+                onChanged: files.setFilesSortField,
               ),
             ),
             ToggleIconButton(
-              icon: provider.showHiddenFiles
+              icon: files.showHiddenFiles
                   ? Icons.visibility_rounded
                   : Icons.visibility_off_rounded,
-              isSelected: provider.showHiddenFiles,
-              onTap: () => provider.toggleShowHiddenFiles(),
+              isSelected: files.showHiddenFiles,
+              onTap: () => files.toggleShowHiddenFiles(),
               tooltip: 'Show hidden files',
             ),
             const SizedBox(width: 4),
@@ -120,14 +124,14 @@ class _ShareUploadViewState extends State<ShareUploadView> {
               children: [
                 ToggleIconButton(
                   icon: Symbols.circles_rounded,
-                  isSelected: provider.storageScope == StorageScope.cloud,
-                  onTap: () => provider.setStorageScope(StorageScope.cloud),
+                  isSelected: files.storageScope == StorageScope.cloud,
+                  onTap: () => files.setStorageScope(StorageScope.cloud),
                   tooltip: 'Cloud storage',
                 ),
                 ToggleIconButton(
                   icon: Symbols.hard_drive_rounded,
-                  isSelected: provider.storageScope == StorageScope.external,
-                  onTap: () => provider.setStorageScope(StorageScope.external),
+                  isSelected: files.storageScope == StorageScope.external,
+                  onTap: () => files.setStorageScope(StorageScope.external),
                   tooltip: 'External storage',
                 ),
               ],
@@ -137,24 +141,24 @@ class _ShareUploadViewState extends State<ShareUploadView> {
               children: [
                 ToggleIconButton(
                   icon: Icons.select_all_rounded,
-                  isSelected: provider.filesTypeFilter == FilesTypeFilter.all,
-                  onTap: () => provider.setFilesTypeFilter(FilesTypeFilter.all),
+                  isSelected: files.filesTypeFilter == FilesTypeFilter.all,
+                  onTap: () => files.setFilesTypeFilter(FilesTypeFilter.all),
                   tooltip: 'Files & folders',
                 ),
                 ToggleIconButton(
                   icon: Icons.insert_drive_file_outlined,
                   isSelected:
-                      provider.filesTypeFilter == FilesTypeFilter.filesOnly,
+                      files.filesTypeFilter == FilesTypeFilter.filesOnly,
                   onTap: () =>
-                      provider.setFilesTypeFilter(FilesTypeFilter.filesOnly),
+                      files.setFilesTypeFilter(FilesTypeFilter.filesOnly),
                   tooltip: 'Files only',
                 ),
                 ToggleIconButton(
                   icon: Icons.folder_outlined,
                   isSelected:
-                      provider.filesTypeFilter == FilesTypeFilter.foldersOnly,
+                      files.filesTypeFilter == FilesTypeFilter.foldersOnly,
                   onTap: () =>
-                      provider.setFilesTypeFilter(FilesTypeFilter.foldersOnly),
+                      files.setFilesTypeFilter(FilesTypeFilter.foldersOnly),
                   tooltip: 'Folders only',
                 ),
               ],
@@ -164,14 +168,14 @@ class _ShareUploadViewState extends State<ShareUploadView> {
               children: [
                 ToggleIconButton(
                   icon: Icons.view_list_rounded,
-                  isSelected: !provider.isGridView,
-                  onTap: () => provider.setGridView(false),
+                  isSelected: !files.isGridView,
+                  onTap: () => files.setGridView(false),
                   tooltip: 'List view',
                 ),
                 ToggleIconButton(
                   icon: Icons.grid_view_rounded,
-                  isSelected: provider.isGridView,
-                  onTap: () => provider.setGridView(true),
+                  isSelected: files.isGridView,
+                  onTap: () => files.setGridView(true),
                   tooltip: 'Grid view',
                 ),
               ],
@@ -185,13 +189,11 @@ class _ShareUploadViewState extends State<ShareUploadView> {
   // Only folders are valid upload destinations - files still show (so the
   // listing matches what the Files tab itself would show for this folder)
   // but are visually dimmed and inert rather than hidden outright.
-  Widget _buildListTile(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildListTile(BuildContext context, NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
+    final files = context.read<FilesController>();
+    final session = context.watch<SessionController>();
     final isFolder = item.isFolder;
 
     return Padding(
@@ -203,9 +205,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
           child: Material(
             color: colorScheme.surfaceContainerLow,
             child: InkWell(
-              onTap: isFolder
-                  ? () => provider.navigateToFolder(item.path)
-                  : null,
+              onTap: isFolder ? () => files.navigateToFolder(item.path) : null,
               child: Padding(
                 padding: const EdgeInsets.symmetric(
                   horizontal: 16,
@@ -215,7 +215,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
                   children: [
                     ItemThumbnail(
                       item: item,
-                      provider: provider,
+                      service: session.service,
                       size: 44,
                       borderRadius: 12,
                       iconSize: 22,
@@ -255,13 +255,10 @@ class _ShareUploadViewState extends State<ShareUploadView> {
     );
   }
 
-  Widget _buildGridCard(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildGridCard(BuildContext context, NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
+    final files = context.read<FilesController>();
     final isFolder = item.isFolder;
     final iconColor = getIconColor(context, item.type);
 
@@ -272,7 +269,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
         borderRadius: BorderRadius.circular(20),
         clipBehavior: Clip.antiAlias,
         child: InkWell(
-          onTap: isFolder ? () => provider.navigateToFolder(item.path) : null,
+          onTap: isFolder ? () => files.navigateToFolder(item.path) : null,
           child: Padding(
             padding: const EdgeInsets.all(14),
             child: Column(
@@ -326,13 +323,14 @@ class _ShareUploadViewState extends State<ShareUploadView> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
-    final hasBreadcrumbs = provider.pathStack.length > 1;
-    final currentPath = provider.pathStack.last;
+    final files = context.watch<FilesController>();
+    final session = context.watch<SessionController>();
+    final hasBreadcrumbs = files.pathStack.length > 1;
+    final currentPath = files.pathStack.last;
     final currentLabel = currentPath == '/'
         ? 'Home'
         : currentPath.split('/').where((s) => s.isNotEmpty).last;
-    final items = provider.items;
+    final items = files.items;
 
     // Mirrors FilesView's own controls-row + breadcrumbs sticky header
     // exactly (padding, heights) so this reads as the same browser, just
@@ -342,14 +340,14 @@ class _ShareUploadViewState extends State<ShareUploadView> {
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: [
-          _buildControlsRow(provider),
+          _buildControlsRow(files),
           if (hasBreadcrumbs) ...[
             const SizedBox(height: 10),
             SizedBox(
               height: 32,
               child: Breadcrumbs(
-                pathStack: provider.pathStack,
-                onTap: (index) => provider.navigateToPathIndex(index),
+                pathStack: files.pathStack,
+                onTap: (index) => files.navigateToPathIndex(index),
               ),
             ),
           ],
@@ -365,7 +363,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
           child: controlsColumn,
         ),
       ),
-      if (provider.isLoading)
+      if (files.isLoading)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
@@ -380,7 +378,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
             ),
           ),
         )
-      else if (provider.isGridView)
+      else if (files.isGridView)
         SliverPadding(
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverGrid(
@@ -391,7 +389,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
               mainAxisSpacing: 12,
             ),
             delegate: SliverChildBuilderDelegate((context, index) {
-              return _buildGridCard(context, items[index], provider);
+              return _buildGridCard(context, items[index]);
             }, childCount: items.length),
           ),
         )
@@ -400,7 +398,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
           padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 8),
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
-              return _buildListTile(context, items[index], provider);
+              return _buildListTile(context, items[index]);
             }, childCount: items.length),
           ),
         ),
@@ -411,7 +409,6 @@ class _ShareUploadViewState extends State<ShareUploadView> {
     return Scaffold(
       body: SyncedHeaderScaffold(
         scrollController: _scrollController,
-        provider: provider,
         // Same trailing actions as every other tab except "More tabs" -
         // there's nowhere useful for it to go while mid-upload (jumping to
         // Trash/Shares/etc. would abandon this destination picker), so the
@@ -494,7 +491,7 @@ class _ShareUploadViewState extends State<ShareUploadView> {
                 SizedBox(
                   width: double.infinity,
                   child: FilledButton.icon(
-                    onPressed: () => _uploadHere(provider),
+                    onPressed: () => _uploadHere(session),
                     icon: const Icon(Icons.upload_rounded),
                     label: Text('Upload to $currentLabel'),
                   ),

lib/views/shares_view.dart

@@ -3,7 +3,7 @@ import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import '../models/nextcloud_item.dart';
 import '../models/nextcloud_share.dart';
-import '../providers/server_provider.dart';
+import '../providers/shares_controller.dart';
 import '../widgets/more_tabs_button.dart';
 import '../widgets/profile_avatar_button.dart';
 import '../widgets/synced_header_scaffold.dart';
@@ -60,16 +60,16 @@ class _SharesViewState extends State<SharesView> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final sharesController = context.watch<SharesController>();
 
     if (!_requested) {
       _requested = true;
       WidgetsBinding.instance.addPostFrameCallback(
-        (_) => provider.fetchShares(),
+        (_) => sharesController.fetchAll(),
       );
     }
 
-    final shares = provider.shares;
+    final shares = sharesController.shares;
 
     final List<Widget> contentSlivers = [
       SliverToBoxAdapter(
@@ -80,19 +80,20 @@ class _SharesViewState extends State<SharesView> {
               ButtonSegment(value: false, label: Text('Shared by me')),
               ButtonSegment(value: true, label: Text('Shared with me')),
             ],
-            selected: {provider.sharesWithMe},
-            onSelectionChanged: (set) => provider.setSharesWithMe(set.first),
+            selected: {sharesController.sharedWithMe},
+            onSelectionChanged: (set) =>
+                sharesController.setSharedWithMe(set.first),
           ),
         ),
       ),
       const SliverToBoxAdapter(child: SizedBox(height: 8)),
 
-      if (provider.isSharesLoading && shares.isEmpty)
+      if (sharesController.isLoading && shares.isEmpty)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
         )
-      else if (provider.sharesErrorMessage != null)
+      else if (sharesController.errorMessage != null)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -116,7 +117,7 @@ class _SharesViewState extends State<SharesView> {
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    provider.sharesErrorMessage!,
+                    sharesController.errorMessage!,
                     textAlign: TextAlign.center,
                     style: theme.textTheme.bodyMedium?.copyWith(
                       color: colorScheme.onSurfaceVariant,
@@ -124,7 +125,7 @@ class _SharesViewState extends State<SharesView> {
                   ),
                   const SizedBox(height: 20),
                   FilledButton.icon(
-                    onPressed: provider.fetchShares,
+                    onPressed: sharesController.fetchAll,
                     icon: const Icon(Icons.refresh_rounded),
                     label: const Text('Retry'),
                   ),
@@ -147,7 +148,7 @@ class _SharesViewState extends State<SharesView> {
                 ),
                 const SizedBox(height: 12),
                 Text(
-                  provider.sharesWithMe
+                  sharesController.sharedWithMe
                       ? 'Nothing has been shared with you'
                       : 'You haven\'t shared anything yet',
                   style: theme.textTheme.titleMedium?.copyWith(
@@ -164,7 +165,7 @@ class _SharesViewState extends State<SharesView> {
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
               final share = shares[index];
-              return _buildShareTile(context, share, provider);
+              return _buildShareTile(context, share);
             }, childCount: shares.length),
           ),
         ),
@@ -175,18 +176,13 @@ class _SharesViewState extends State<SharesView> {
 
     return SyncedHeaderScaffold(
       scrollController: widget.scrollController,
-      provider: provider,
       actions: const [MoreTabsButton(), ProfileAvatarButton()],
-      onRefresh: provider.fetchShares,
+      onRefresh: sharesController.fetchAll,
       contentSlivers: contentSlivers,
     );
   }
 
-  Widget _buildShareTile(
-    BuildContext context,
-    NextcloudShare share,
-    ServerProvider provider,
-  ) {
+  Widget _buildShareTile(BuildContext context, NextcloudShare share) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
     final iconColor = colorScheme.primary;
@@ -260,7 +256,7 @@ class _SharesViewState extends State<SharesView> {
               IconButton(
                 icon: Icon(Icons.link_off_rounded, color: colorScheme.error),
                 tooltip: share.sharedWithMe ? 'Remove' : 'Unshare',
-                onPressed: () => _confirmUnshare(context, provider, share),
+                onPressed: () => _confirmUnshare(context, share),
               ),
             ],
           ),
@@ -271,7 +267,6 @@ class _SharesViewState extends State<SharesView> {
 
   Future<void> _confirmUnshare(
     BuildContext context,
-    ServerProvider provider,
     NextcloudShare share,
   ) async {
     final confirmed = await showDialog<bool>(
@@ -303,7 +298,9 @@ class _SharesViewState extends State<SharesView> {
     if (confirmed != true || !context.mounted) return;
 
     final messenger = ScaffoldMessenger.of(context);
-    final success = await provider.deleteShare(share);
+    final success = await context.read<SharesController>().deleteShare(
+      share,
+    );
     messenger.showSnackBar(
       SnackBar(
         content: Text(

lib/views/trash_view.dart

@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../providers/trash_controller.dart';
 import '../widgets/more_tabs_button.dart';
 import '../widgets/profile_avatar_button.dart';
 import '../widgets/synced_header_scaffold.dart';
@@ -42,26 +42,26 @@ class _TrashViewState extends State<TrashView> {
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final trashController = context.watch<TrashController>();
 
     if (!_requested) {
       _requested = true;
       WidgetsBinding.instance.addPostFrameCallback(
-        (_) => provider.fetchTrash(),
+        (_) => trashController.fetchAll(),
       );
     }
 
-    final trash = provider.trashItems;
+    final trash = trashController.items;
 
     final List<Widget> contentSlivers = [
       const SliverToBoxAdapter(child: SizedBox(height: 16)),
 
-      if (provider.isTrashLoading && trash.isEmpty)
+      if (trashController.isLoading && trash.isEmpty)
         const SliverFillRemaining(
           hasScrollBody: false,
           child: Center(child: CircularProgressIndicator()),
         )
-      else if (provider.trashErrorMessage != null)
+      else if (trashController.errorMessage != null)
         SliverFillRemaining(
           hasScrollBody: false,
           child: Center(
@@ -85,7 +85,7 @@ class _TrashViewState extends State<TrashView> {
                   ),
                   const SizedBox(height: 8),
                   Text(
-                    provider.trashErrorMessage!,
+                    trashController.errorMessage!,
                     textAlign: TextAlign.center,
                     style: theme.textTheme.bodyMedium?.copyWith(
                       color: colorScheme.onSurfaceVariant,
@@ -93,7 +93,7 @@ class _TrashViewState extends State<TrashView> {
                   ),
                   const SizedBox(height: 20),
                   FilledButton.icon(
-                    onPressed: provider.fetchTrash,
+                    onPressed: trashController.fetchAll,
                     icon: const Icon(Icons.refresh_rounded),
                     label: const Text('Retry'),
                   ),
@@ -131,7 +131,7 @@ class _TrashViewState extends State<TrashView> {
           sliver: SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
               final item = trash[index];
-              return _buildTrashTile(context, item, provider);
+              return _buildTrashTile(context, item);
             }, childCount: trash.length),
           ),
         ),
@@ -142,18 +142,13 @@ class _TrashViewState extends State<TrashView> {
 
     return SyncedHeaderScaffold(
       scrollController: widget.scrollController,
-      provider: provider,
       actions: const [MoreTabsButton(), ProfileAvatarButton()],
-      onRefresh: provider.fetchTrash,
+      onRefresh: trashController.fetchAll,
       contentSlivers: contentSlivers,
     );
   }
 
-  Widget _buildTrashTile(
-    BuildContext context,
-    NextcloudItem item,
-    ServerProvider provider,
-  ) {
+  Widget _buildTrashTile(BuildContext context, NextcloudItem item) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
     final iconColor = colorScheme.outline;
@@ -210,7 +205,7 @@ class _TrashViewState extends State<TrashView> {
                 icon: const Icon(Icons.restore_rounded),
                 tooltip: 'Restore',
                 color: colorScheme.primary,
-                onPressed: () => _restore(context, provider, item),
+                onPressed: () => _restore(context, item),
               ),
               IconButton(
                 icon: Icon(
@@ -218,7 +213,7 @@ class _TrashViewState extends State<TrashView> {
                   color: colorScheme.error,
                 ),
                 tooltip: 'Delete forever',
-                onPressed: () => _confirmDeleteForever(context, provider, item),
+                onPressed: () => _confirmDeleteForever(context, item),
               ),
             ],
           ),
@@ -227,13 +222,9 @@ class _TrashViewState extends State<TrashView> {
     );
   }
 
-  Future<void> _restore(
-    BuildContext context,
-    ServerProvider provider,
-    NextcloudItem item,
-  ) async {
+  Future<void> _restore(BuildContext context, NextcloudItem item) async {
     final messenger = ScaffoldMessenger.of(context);
-    final success = await provider.restoreTrashItem(item);
+    final success = await context.read<TrashController>().restore(item);
     messenger.showSnackBar(
       SnackBar(
         content: Text(
@@ -246,7 +237,6 @@ class _TrashViewState extends State<TrashView> {
 
   Future<void> _confirmDeleteForever(
     BuildContext context,
-    ServerProvider provider,
     NextcloudItem item,
   ) async {
     final confirmed = await showDialog<bool>(
@@ -276,7 +266,7 @@ class _TrashViewState extends State<TrashView> {
     if (confirmed != true || !context.mounted) return;
 
     final messenger = ScaffoldMessenger.of(context);
-    final success = await provider.deleteTrashItemForever(item);
+    final success = await context.read<TrashController>().deleteForever(item);
     messenger.showSnackBar(
       SnackBar(
         content: Text(

lib/widgets/details/details_activity_tab.dart

@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import 'package:provider/provider.dart';
 import '../../models/nextcloud_item.dart';
-import '../../providers/server_provider.dart';
+import '../../providers/item_operations.dart';
 
 /// Per-file activity feed — same list-item look as the account-wide
 /// Activity tab (activity_view.dart), scoped to a single item.
@@ -21,8 +21,8 @@ class _DetailsActivityTabState extends State<DetailsActivityTab> {
   List<NextcloudActivity> _activities = [];
 
   Future<void> _load() async {
-    final provider = context.read<ServerProvider>();
-    final result = await provider.fetchFileActivity(widget.item);
+    final ops = context.read<ItemOperations>();
+    final result = await ops.fetchFileActivity(widget.item);
     if (!mounted) return;
     setState(() {
       _activities = result;

lib/widgets/details/details_versions_tab.dart

@@ -6,7 +6,7 @@ import 'package:path_provider/path_provider.dart';
 import 'package:provider/provider.dart';
 import '../../models/nextcloud_file_version.dart';
 import '../../models/nextcloud_item.dart';
-import '../../providers/server_provider.dart';
+import '../../providers/item_operations.dart';
 import '../synced_header_scaffold.dart' show formatBytes;
 
 /// File version history — a synthetic "Current version" row (from the
@@ -27,8 +27,8 @@ class _DetailsVersionsTabState extends State<DetailsVersionsTab> {
   List<NextcloudFileVersion> _versions = [];
 
   Future<void> _load() async {
-    final provider = context.read<ServerProvider>();
-    final result = await provider.fetchFileVersions(widget.item);
+    final ops = context.read<ItemOperations>();
+    final result = await ops.fetchFileVersions(widget.item);
     if (!mounted) return;
     setState(() {
       _versions = result;
@@ -37,9 +37,9 @@ class _DetailsVersionsTabState extends State<DetailsVersionsTab> {
   }
 
   Future<void> _restore(NextcloudFileVersion version) async {
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
-    final success = await provider.restoreFileVersion(
+    final success = await ops.restoreFileVersion(
       widget.item,
       version.versionLabel,
     );
@@ -56,7 +56,7 @@ class _DetailsVersionsTabState extends State<DetailsVersionsTab> {
   }
 
   Future<void> _download(NextcloudFileVersion version) async {
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
     try {
       final tempDir = await getTemporaryDirectory();
@@ -64,7 +64,7 @@ class _DetailsVersionsTabState extends State<DetailsVersionsTab> {
         tempDir.path,
         '${version.versionLabel}_${widget.item.name}',
       );
-      final success = await provider.downloadVersion(
+      final success = await ops.downloadVersion(
         widget.item,
         version.versionLabel,
         tempPath,

lib/widgets/item_icon.dart

@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import '../models/nextcloud_item.dart';
-import '../providers/server_provider.dart';
+import '../services/nextcloud_service.dart';
 
 /// The icon/color/thumbnail treatment for a file or folder, shared by any
 /// screen that lists [NextcloudItem]s the same way the Files tab does (see
@@ -51,7 +51,7 @@ Color getIconColor(BuildContext context, NextcloudItemType type) {
 /// the Photos tab.
 class ItemThumbnail extends StatelessWidget {
   final NextcloudItem item;
-  final ServerProvider provider;
+  final NextcloudService? service;
   final double size;
   final double borderRadius;
   final double iconSize;
@@ -59,7 +59,7 @@ class ItemThumbnail extends StatelessWidget {
   const ItemThumbnail({
     super.key,
     required this.item,
-    required this.provider,
+    required this.service,
     required this.size,
     required this.borderRadius,
     required this.iconSize,
@@ -92,7 +92,7 @@ class ItemThumbnail extends StatelessWidget {
               children: [
                 Image.network(
                   item.previewUrl!,
-                  headers: provider.service?.authHeaders,
+                  headers: service?.authHeaders,
                   fit: BoxFit.cover,
                   cacheWidth: cachePixels,
                   cacheHeight: cachePixels,

lib/widgets/more_tabs_button.dart

@@ -1,7 +1,8 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import '../models/app_tab.dart';
-import '../providers/server_provider.dart';
+import '../providers/pick_controller.dart';
+import '../providers/settings_controller.dart';
 import 'app_tab_view_builder.dart';
 
 /// Opens a tab that's currently hidden from the bottom nav bar as its own
@@ -13,23 +14,24 @@ class MoreTabsButton extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final pick = context.watch<PickController>();
+    final settings = context.watch<SettingsController>();
 
     // While picking (another app's GET_CONTENT request), MainShellView
     // already restricts the bottom nav to Files/Photos - this button would
     // otherwise be the one remaining way to reach a tab that isn't a valid
     // pick source (Trash, Shares, ...), so it hides entirely rather than
     // just disabling.
-    if (provider.isPicking) return const SizedBox.shrink();
+    if (pick.isPicking) return const SizedBox.shrink();
 
     return PopupMenuButton<AppTab>(
       icon: const Icon(Icons.apps_rounded),
       tooltip: 'More tabs',
-      enabled: provider.hiddenTabs.isNotEmpty,
+      enabled: settings.hiddenTabs.isNotEmpty,
       onSelected: (tab) => _openHiddenTab(context, tab),
       itemBuilder: (context) => [
-        for (final tab in provider.tabOrder.where(
-          (t) => provider.hiddenTabs.contains(t),
+        for (final tab in settings.tabOrder.where(
+          (t) => settings.hiddenTabs.contains(t),
         ))
           PopupMenuItem(
             value: tab,

lib/widgets/move_copy_conflict_sheet.dart

@@ -7,7 +7,7 @@ import 'gradual_bottom_sheet.dart';
 /// destination) - summarizes every conflict at once rather than prompting
 /// per item as they're hit, and lets the user resolve them all the same
 /// way (overwrite/keep both) or open a per-item breakdown. Returns the
-/// `ConflictChoice` map `ServerProvider.resolveConflicts` expects, or null
+/// `ConflictChoice` map `ItemOperations.resolveConflicts` expects, or null
 /// if dismissed without choosing.
 class MoveCopyConflictSheet extends StatefulWidget {
   final List<MoveCopyConflict> conflicts;

lib/widgets/profile_avatar_button.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
-import '../providers/server_provider.dart';
+import '../providers/session_controller.dart';
 import '../views/account_view.dart';
 
 /// Top-bar avatar button that opens the account screen. Replaces the old
@@ -20,7 +20,7 @@ class ProfileAvatarButton extends StatelessWidget {
     final velocity = details.primaryVelocity ?? 0;
     if (velocity.abs() < 250) return;
 
-    final provider = context.read<ServerProvider>();
+    final provider = context.read<SessionController>();
     final target = velocity < 0
         ? await provider.cycleToNextAccount()
         : await provider.cycleToPreviousAccount();
@@ -37,7 +37,7 @@ class ProfileAvatarButton extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final provider = context.watch<ServerProvider>();
+    final provider = context.watch<SessionController>();
     final colorScheme = Theme.of(context).colorScheme;
     final initial = provider.username.isNotEmpty
         ? provider.username[0].toUpperCase()

lib/widgets/seek_bar_painter.dart

@@ -1,6 +1,6 @@
 import 'dart:math' as math;
 import 'package:flutter/material.dart';
-import '../providers/server_provider.dart';
+import '../providers/settings_controller.dart';
 
 /// Draws a video seek bar in one of the four [MediaProgressBarStyle]
 /// presets. Shared by the actual in-player seek bar and the small previews

lib/widgets/share_sheet.dart

@@ -7,7 +7,9 @@ import 'package:share_plus/share_plus.dart';
 import '../models/nextcloud_item.dart';
 import '../models/nextcloud_share.dart';
 import '../models/nextcloud_sharee.dart';
-import '../providers/server_provider.dart';
+import '../providers/item_operations.dart';
+import '../providers/session_controller.dart';
+import '../providers/sync_status_controller.dart';
 import 'details/details_sheet.dart' show DetailsHeader;
 import 'gradual_bottom_sheet.dart';
 
@@ -83,10 +85,10 @@ class _ShareSheetState extends State<ShareSheet> {
   }
 
   Future<void> _load() async {
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final results = await Future.wait([
-      provider.fetchItemShares(widget.item),
-      provider.fetchInheritedShares(widget.item),
+      ops.fetchItemShares(widget.item),
+      ops.fetchInheritedShares(widget.item),
     ]);
     if (!mounted) return;
     setState(() {
@@ -103,8 +105,8 @@ class _ShareSheetState extends State<ShareSheet> {
       return;
     }
     setState(() => _isSearching = true);
-    final provider = context.read<ServerProvider>();
-    final results = await provider.searchSharees(trimmed);
+    final ops = context.read<ItemOperations>();
+    final results = await ops.searchSharees(trimmed);
     if (!mounted) return;
     setState(() {
       _searchResults = results;
@@ -113,9 +115,9 @@ class _ShareSheetState extends State<ShareSheet> {
   }
 
   Future<void> _addSharee(NextcloudSharee sharee) async {
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
-    final share = await provider.createShare(
+    final share = await ops.createShare(
       path: widget.item.path,
       shareType: sharee.shareTypeValue,
       shareWith: sharee.shareWith,
@@ -147,9 +149,9 @@ class _ShareSheetState extends State<ShareSheet> {
     final email = _emailController.text.trim();
     if (email.isEmpty) return;
     setState(() => _isAddingEmail = true);
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
-    final share = await provider.createShare(
+    final share = await ops.createShare(
       path: widget.item.path,
       shareType: 4,
       shareWith: email,
@@ -179,9 +181,9 @@ class _ShareSheetState extends State<ShareSheet> {
   }
 
   Future<void> _createPublicLink() async {
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
-    final share = await provider.createShare(
+    final share = await ops.createShare(
       path: widget.item.path,
       shareType: 3,
     );
@@ -199,9 +201,9 @@ class _ShareSheetState extends State<ShareSheet> {
   }
 
   Future<void> _removeShare(NextcloudShare share) async {
-    final provider = context.read<ServerProvider>();
+    final ops = context.read<ItemOperations>();
     final messenger = ScaffoldMessenger.of(context);
-    final success = await provider.deleteShare(share);
+    final success = await ops.deleteShare(share);
     if (!mounted) return;
     if (success) {
       setState(() => _shares = _shares.where((s) => s.id != share.id).toList());
@@ -231,20 +233,21 @@ class _ShareSheetState extends State<ShareSheet> {
   /// users/links) and the only one here that reads the file's actual
   /// bytes.
   Future<void> _shareFileDirectly() async {
-    final provider = context.read<ServerProvider>();
-    if (provider.service == null) return;
+    final session = context.read<SessionController>();
+    final sync = context.read<SyncStatusController>();
+    if (session.service == null) return;
     setState(() => _isSharingFile = true);
     final messenger = ScaffoldMessenger.of(context);
     try {
       // Already mirrored locally by device sync? Share that copy straight
       // away instead of a fresh WebDAV fetch - see
-      // ServerProvider.localSyncedFilePath.
+      // SyncStatusController.localSyncedFilePath.
       final tempPath =
-          await provider.localSyncedFilePath(widget.item) ??
+          await sync.localSyncedFilePath(widget.item) ??
           await () async {
             final tempDir = await getTemporaryDirectory();
             final path = p.join(tempDir.path, widget.item.name);
-            await provider.service!.downloadToFile(widget.item.path, path);
+            await session.service!.downloadToFile(widget.item.path, path);
             return path;
           }();
       if (!mounted) return;
@@ -334,7 +337,7 @@ class _ShareSheetState extends State<ShareSheet> {
     }
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final provider = context.watch<ServerProvider>();
+    final session = context.watch<SessionController>();
 
     if (_isLoading) {
       return const Center(child: CircularProgressIndicator());
@@ -352,7 +355,7 @@ class _ShareSheetState extends State<ShareSheet> {
     final emailShares = _shares
         .where((s) => s.shareType == ShareType.email)
         .toList();
-    final internalLink = internalLinkFor(provider.serverUrl, widget.item.id);
+    final internalLink = internalLinkFor(session.serverUrl, widget.item.id);
 
     return ListView(
       controller: widget.scrollController,

lib/widgets/sort_menu_button.dart

@@ -1,5 +1,5 @@
 import 'package:flutter/material.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
 
 String sortFieldLabel(FileSortField field) {
   switch (field) {

lib/widgets/swipeable_item.dart

@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
-import '../providers/server_provider.dart';
+import '../providers/settings_controller.dart';
 
 /// Wraps [child] with the user's configured swipe-left/swipe-right actions
 /// (favorite, delete, share, or none) — shared between the Files list view
@@ -10,7 +10,7 @@ import '../providers/server_provider.dart';
 class SwipeableItem extends StatelessWidget {
   final Key itemKey;
   final String itemName;
-  final ServerProvider provider;
+  final SettingsController settings;
   final Future<void> Function() onFavorite;
   final Future<void> Function() onShare;
   final Future<void> Function() onDelete;
@@ -20,7 +20,7 @@ class SwipeableItem extends StatelessWidget {
     super.key,
     required this.itemKey,
     required this.itemName,
-    required this.provider,
+    required this.settings,
     required this.onFavorite,
     required this.onShare,
     required this.onDelete,
@@ -69,8 +69,8 @@ class SwipeableItem extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final rightAction = provider.swipeRightAction;
-    final leftAction = provider.swipeLeftAction;
+    final rightAction = settings.swipeRightAction;
+    final leftAction = settings.swipeLeftAction;
     final direction = _directionFor(leftAction, rightAction);
     if (direction == DismissDirection.none) return child;
 

lib/widgets/synced_header_scaffold.dart

@@ -1,11 +1,14 @@
 import 'package:flutter/material.dart';
 import 'package:material_symbols_icons/symbols.dart';
+import 'package:provider/provider.dart';
 import '../models/nextcloud_item.dart';
 import '../models/sync_status.dart';
-import '../providers/server_provider.dart';
+import '../providers/files_controller.dart';
+import '../providers/session_controller.dart';
+import '../providers/sync_status_controller.dart';
 
 /// Icon/label for the persistent header chip/panel - reflects device-sync
-/// status (see `ServerProvider.syncHeaderStatus`), not the WebDAV
+/// status (see `SyncStatusController.syncHeaderStatus`), not the WebDAV
 /// directory-listing refresh the pull gesture itself triggers (that has
 /// its own, separate floating spinner bubble - see
 /// `_SyncedHeaderScaffoldState`'s `_isRefreshing`).
@@ -42,7 +45,6 @@ String formatQuota(NextcloudUserQuota quota) {
 /// holds the tab's own content slivers.
 class SyncedHeaderScaffold extends StatefulWidget {
   final ScrollController scrollController;
-  final ServerProvider provider;
 
   /// Trailing icons in the app bar (e.g. an upload button, the avatar).
   final List<Widget> actions;
@@ -53,8 +55,8 @@ class SyncedHeaderScaffold extends StatefulWidget {
   final List<Widget> contentSlivers;
 
   /// What a deliberate pull-to-sync should trigger. Defaults to
-  /// [ServerProvider.refreshData] (the current folder's listing); pass e.g.
-  /// `provider.fetchTrash` for a tab backed by different data.
+  /// [FilesController.refreshData] (the current folder's listing); pass
+  /// e.g. `trashController.fetchAll` for a tab backed by different data.
   final Future<void> Function()? onRefresh;
 
   /// When non-null (a tab is mid-selection), this takes over the pinned top
@@ -69,7 +71,6 @@ class SyncedHeaderScaffold extends StatefulWidget {
   const SyncedHeaderScaffold({
     super.key,
     required this.scrollController,
-    required this.provider,
     required this.actions,
     required this.contentSlivers,
     this.onRefresh,
@@ -118,7 +119,8 @@ class _SyncedHeaderScaffoldState extends State<SyncedHeaderScaffold> {
   }
 
   void _startRefresh() {
-    final refresh = widget.onRefresh ?? widget.provider.refreshData;
+    final refresh =
+        widget.onRefresh ?? context.read<FilesController>().refreshData;
     setState(() => _isRefreshing = true);
     refresh().whenComplete(() {
       if (mounted) setState(() => _isRefreshing = false);
@@ -163,7 +165,7 @@ class _SyncedHeaderScaffoldState extends State<SyncedHeaderScaffold> {
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
-    final provider = widget.provider;
+    final syncStatus = context.watch<SyncStatusController>();
 
     final Widget leadingWidget;
     if (_headerLocked) {
@@ -175,7 +177,7 @@ class _SyncedHeaderScaffoldState extends State<SyncedHeaderScaffold> {
     } else if (_isPulling) {
       leadingWidget = const SizedBox.shrink();
     } else {
-      leadingWidget = _SyncStatusChip(provider: provider, onTap: _lockOpen);
+      leadingWidget = _SyncStatusChip(onTap: _lockOpen);
     }
 
     final topInset = MediaQuery.of(context).padding.top;
@@ -205,7 +207,7 @@ class _SyncedHeaderScaffoldState extends State<SyncedHeaderScaffold> {
                   expandedHeight: widget.selectionBar != null
                       ? kToolbarHeight
                       : (_headerLocked
-                            ? 190.0 + provider.syncConflicts.length * 52.0
+                            ? 190.0 + syncStatus.syncConflicts.length * 52.0
                             : kToolbarHeight),
                   collapsedHeight: kToolbarHeight,
                   backgroundColor: colorScheme.surfaceContainer,
@@ -225,7 +227,6 @@ class _SyncedHeaderScaffoldState extends State<SyncedHeaderScaffold> {
                       ? null
                       : FlexibleSpaceBar(
                           background: _SyncedStretchPanel(
-                            provider: provider,
                             forceVisible: _headerLocked,
                           ),
                         ),
@@ -287,16 +288,15 @@ class _SyncedHeaderScaffoldState extends State<SyncedHeaderScaffold> {
 /// [_SyncedStretchPanel] — tapping it is a discoverable shortcut for pulling
 /// the header down to expand that same "Synced" view.
 class _SyncStatusChip extends StatelessWidget {
-  final ServerProvider provider;
   final VoidCallback onTap;
 
-  const _SyncStatusChip({required this.provider, required this.onTap});
+  const _SyncStatusChip({required this.onTap});
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
-    final status = provider.syncHeaderStatus;
+    final status = context.watch<SyncStatusController>().syncHeaderStatus;
     final (icon, label) = _syncHeaderDisplay(status);
     final iconColor = status == SyncHeaderStatus.alert
         ? colorScheme.error
@@ -337,36 +337,33 @@ class _SyncStatusChip extends StatelessWidget {
 /// [_SyncedHeaderScaffoldState] decides via [forceVisible] whether it stays
 /// locked open.
 class _SyncedStretchPanel extends StatelessWidget {
-  final ServerProvider provider;
-
   /// Keeps the panel fully shown even without live overscroll — used once
   /// the header has "locked" open after a deliberate pull-down.
   final bool forceVisible;
 
-  const _SyncedStretchPanel({
-    required this.provider,
-    this.forceVisible = false,
-  });
+  const _SyncedStretchPanel({this.forceVisible = false});
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
     final topInset = MediaQuery.of(context).padding.top;
+    final quota = context.watch<FilesController>().quota;
+    final serverUrl = context.watch<SessionController>().serverUrl;
+    final syncStatus = context.watch<SyncStatusController>();
 
     return LayoutBuilder(
       builder: (context, constraints) {
-        final settings = context
+        final spacerSettings = context
             .dependOnInheritedWidgetOfExactType<FlexibleSpaceBarSettings>();
-        final maxExtent = settings?.maxExtent ?? constraints.maxHeight;
+        final maxExtent = spacerSettings?.maxExtent ?? constraints.maxHeight;
         final stretch = (constraints.maxHeight - maxExtent).clamp(0.0, 80.0);
         // Reaches 1.0 (title fully hidden) at 50px of pull — comfortably
         // before the 100px lock threshold.
         final progress = forceVisible ? 1.0 : (stretch / 50).clamp(0.0, 1.0);
-        final quota = provider.quota;
-        final status = provider.syncHeaderStatus;
+        final status = syncStatus.syncHeaderStatus;
         final (_, statusLabel) = _syncHeaderDisplay(status);
-        final conflicts = provider.syncConflicts;
+        final conflicts = syncStatus.syncConflicts;
 
         return Stack(
           children: [
@@ -389,13 +386,10 @@ class _SyncedStretchPanel extends StatelessWidget {
                           fontWeight: FontWeight.w700,
                         ),
                       ),
-                      if (provider.serverUrl.isNotEmpty) ...[
+                      if (serverUrl.isNotEmpty) ...[
                         const SizedBox(height: 2),
                         Text(
-                          provider.serverUrl.replaceFirst(
-                            RegExp(r'^https?://'),
-                            '',
-                          ),
+                          serverUrl.replaceFirst(RegExp(r'^https?://'), ''),
                           maxLines: 1,
                           overflow: TextOverflow.ellipsis,
                           style: theme.textTheme.bodySmall?.copyWith(
@@ -438,10 +432,7 @@ class _SyncedStretchPanel extends StatelessWidget {
                         for (final conflict in conflicts)
                           Padding(
                             padding: const EdgeInsets.only(bottom: 8),
-                            child: _SyncConflictRow(
-                              conflict: conflict,
-                              provider: provider,
-                            ),
+                            child: _SyncConflictRow(conflict: conflict),
                           ),
                       ],
                     ],
@@ -462,9 +453,8 @@ class _SyncedStretchPanel extends StatelessWidget {
 /// side), just triggered in-app instead.
 class _SyncConflictRow extends StatefulWidget {
   final SyncConflictInfo conflict;
-  final ServerProvider provider;
 
-  const _SyncConflictRow({required this.conflict, required this.provider});
+  const _SyncConflictRow({required this.conflict});
 
   @override
   State<_SyncConflictRow> createState() => _SyncConflictRowState();
@@ -476,7 +466,7 @@ class _SyncConflictRowState extends State<_SyncConflictRow> {
   Future<void> _resolve(bool useLocal) async {
     setState(() => _resolving = true);
     try {
-      await widget.provider.resolveSyncConflict(
+      await context.read<SyncStatusController>().resolveSyncConflict(
         widget.conflict,
         useLocal: useLocal,
       );