motorsignal
/
MotorSignal-App
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reconnect pending cloud sync after authentication changes

This commit is contained in:
bponders12-cell 2026-09-01 16:57:28 -04:00
parent 6d2d3494e3
commit 076c591251
1 changed files with 27 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
lib/services/sync/sync_providers.dart
View File

@ -9,74 +9,43 @@ import 'github_sync_provider.dart';
import 'r2_upload_service.dart'; import 'r2_upload_service.dart';
import 'sync_bundle_worker.dart'; import 'sync_bundle_worker.dart';
import 'sync_manager.dart'; import 'sync_manager.dart';
import 'sync_models.dart';
import 'sync_outbox.dart'; import 'sync_outbox.dart';
/// Provider for the Cloudflare R2 Upload Service final r2UploadServiceProvider = Provider<R2UploadService>((ref) => R2UploadService());
final r2UploadServiceProvider = Provider<R2UploadService>((ref) { final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) => SyncBundleWorker(ref.watch(databaseProvider)));
return R2UploadService(); final syncOutboxProvider = Provider<SyncOutbox>((ref) => SyncOutbox(ref.watch(sharedPreferencesProvider)));
});
/// Provider for the background bundle generation worker final firebaseSyncProvider = Provider<FirebaseSyncProvider>((ref) => FirebaseSyncProvider(
final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) { db: ref.watch(databaseProvider),
final db = ref.watch(databaseProvider); authService: ref.watch(authServiceProvider),
return SyncBundleWorker(db); bundleWorker: ref.watch(syncBundleWorkerProvider),
}); r2UploadService: ref.watch(r2UploadServiceProvider),
));
/// Provider for the local SyncOutbox backed by SharedPreferences final githubSyncProvider = Provider<GitHubSyncProvider>((ref) => GitHubSyncProvider(
final syncOutboxProvider = Provider<SyncOutbox>((ref) { service: ref.watch(githubSyncServiceProvider),
final prefs = ref.watch(sharedPreferencesProvider); auth: ref.watch(githubAuthServiceProvider),
return SyncOutbox(prefs); ));
});
/// Provider for the Firebase + Cloudflare R2 Cloud Sync Provider
final firebaseSyncProvider = Provider<FirebaseSyncProvider>((ref) {
final db = ref.watch(databaseProvider);
final authService = ref.watch(authServiceProvider);
final bundleWorker = ref.watch(syncBundleWorkerProvider);
final r2Service = ref.watch(r2UploadServiceProvider);
return FirebaseSyncProvider(
db: db,
authService: authService,
r2UploadService: r2Service,
bundleWorker: bundleWorker,
);
});
/// Provider for the GitHub Sync Provider wrapper
final githubSyncProvider = Provider<GitHubSyncProvider>((ref) {
final service = ref.watch(githubSyncServiceProvider);
final auth = ref.watch(githubAuthServiceProvider);
return GitHubSyncProvider(service: service, auth: auth);
});
/// Primary ChangeNotifierProvider for the SyncManager
final syncManagerProvider = ChangeNotifierProvider<SyncManager>((ref) { final syncManagerProvider = ChangeNotifierProvider<SyncManager>((ref) {
final outbox = ref.watch(syncOutboxProvider);
final firebaseProvider = ref.watch(firebaseSyncProvider);
final gitHubProvider = ref.watch(githubSyncProvider);
final manager = SyncManager( final manager = SyncManager(
outbox, ref.watch(syncOutboxProvider),
initialProviders: [firebaseProvider, gitHubProvider], initialProviders: [ref.watch(firebaseSyncProvider), ref.watch(githubSyncProvider)],
defaultProviderId: 'firebase', defaultProviderId: 'firebase',
); );
// A successful Firebase/Google/Email sign-in must automatically release
// rides that were durably parked in AUTH_REQUIRED. Sign-out does not delete
// or cancel them; they remain local/pending until another authenticated session.
ref.listen<AuthState>(authNotifierProvider, (previous, next) {
if (next.isAuthenticated && previous?.isAuthenticated != true) {
manager.retryAuthRequired();
}
});
ref.onDispose(manager.dispose);
return manager; return manager;
}); });
/// Reactive snapshot of the overall synchronization state final syncStateProvider = Provider<SyncManagerState>((ref) => ref.watch(syncManagerProvider).currentState);
final syncStateProvider = Provider<SyncManagerState>((ref) { final pendingSyncCountProvider = Provider<int>((ref) => ref.watch(syncStateProvider).pendingCount);
final manager = ref.watch(syncManagerProvider); final isSyncProcessingProvider = Provider<bool>((ref) => ref.watch(syncStateProvider).isProcessing);
return manager.currentState;
});
/// Reactive count of currently pending synchronization items
final pendingSyncCountProvider = Provider<int>((ref) {
return ref.watch(syncStateProvider).pendingCount;
});
/// Reactive boolean indicating if background synchronization is actively running
final isSyncProcessingProvider = Provider<bool>((ref) {
return ref.watch(syncStateProvider).isProcessing;
});