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 'sync_bundle_worker.dart';
import 'sync_manager.dart';
import 'sync_models.dart';
import 'sync_outbox.dart';
/// Provider for the Cloudflare R2 Upload Service
final r2UploadServiceProvider = Provider<R2UploadService>((ref) {
return R2UploadService();
});
final r2UploadServiceProvider = Provider<R2UploadService>((ref) => R2UploadService());
final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) => SyncBundleWorker(ref.watch(databaseProvider)));
final syncOutboxProvider = Provider<SyncOutbox>((ref) => SyncOutbox(ref.watch(sharedPreferencesProvider)));
/// Provider for the background bundle generation worker
final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) {
final db = ref.watch(databaseProvider);
return SyncBundleWorker(db);
});
final firebaseSyncProvider = Provider<FirebaseSyncProvider>((ref) => FirebaseSyncProvider(
db: ref.watch(databaseProvider),
authService: ref.watch(authServiceProvider),
bundleWorker: ref.watch(syncBundleWorkerProvider),
r2UploadService: ref.watch(r2UploadServiceProvider),
));
/// Provider for the local SyncOutbox backed by SharedPreferences
final syncOutboxProvider = Provider<SyncOutbox>((ref) {
final prefs = ref.watch(sharedPreferencesProvider);
return SyncOutbox(prefs);
});
final githubSyncProvider = Provider<GitHubSyncProvider>((ref) => GitHubSyncProvider(
service: ref.watch(githubSyncServiceProvider),
auth: ref.watch(githubAuthServiceProvider),
));
/// 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 outbox = ref.watch(syncOutboxProvider);
final firebaseProvider = ref.watch(firebaseSyncProvider);
final gitHubProvider = ref.watch(githubSyncProvider);
final manager = SyncManager(
outbox,
initialProviders: [firebaseProvider, gitHubProvider],
ref.watch(syncOutboxProvider),
initialProviders: [ref.watch(firebaseSyncProvider), ref.watch(githubSyncProvider)],
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;
});
/// Reactive snapshot of the overall synchronization state
final syncStateProvider = Provider<SyncManagerState>((ref) {
final manager = ref.watch(syncManagerProvider);
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;
});
final syncStateProvider = Provider<SyncManagerState>((ref) => ref.watch(syncManagerProvider).currentState);
final pendingSyncCountProvider = Provider<int>((ref) => ref.watch(syncStateProvider).pendingCount);
final isSyncProcessingProvider = Provider<bool>((ref) => ref.watch(syncStateProvider).isProcessing);