sync initial
This commit is contained in:
Fabian Freund
@@ -0,0 +1,411 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:collection/collection.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:flutter_mozilla_components/flutter_mozilla_components.dart';
|
||||
import 'package:hooks_riverpod/hooks_riverpod.dart';
|
||||
import 'package:riverpod_annotation/riverpod_annotation.dart';
|
||||
import 'package:weblibre/core/logger.dart';
|
||||
import 'package:weblibre/features/geckoview/domain/repositories/tab.dart';
|
||||
import 'package:weblibre/features/geckoview/features/tabs/domain/repositories/container.dart';
|
||||
import 'package:weblibre/features/sync/domain/entities/sync_repository_state.dart';
|
||||
import 'package:weblibre/features/sync/domain/entities/synced_tab_item.dart';
|
||||
|
||||
part 'sync.g.dart';
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
bool syncIsAuthenticated(Ref ref) {
|
||||
return ref.watch(
|
||||
syncRepositoryProvider.select(
|
||||
(value) => value.value?.account.authenticated == true,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
enum TabsTrayScope { local, synced }
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
class TabsTrayScopeController extends _$TabsTrayScopeController {
|
||||
@override
|
||||
TabsTrayScope build() => TabsTrayScope.local;
|
||||
|
||||
void showLocal() {
|
||||
state = TabsTrayScope.local;
|
||||
}
|
||||
|
||||
void showSynced() {
|
||||
state = TabsTrayScope.synced;
|
||||
}
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
TabsTrayScope effectiveTabsTrayScope(Ref ref) {
|
||||
final scope = ref.watch(tabsTrayScopeControllerProvider);
|
||||
final isAuthenticated = ref.watch(syncIsAuthenticatedProvider);
|
||||
|
||||
if (!isAuthenticated && scope == TabsTrayScope.synced) {
|
||||
return TabsTrayScope.local;
|
||||
}
|
||||
|
||||
return scope;
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
class SelectedSyncedTabsDeviceId extends _$SelectedSyncedTabsDeviceId {
|
||||
@override
|
||||
String? build() => null;
|
||||
|
||||
// ignore: use_setters_to_change_properties
|
||||
void selectDevice(String? value) {
|
||||
state = value;
|
||||
}
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<int> syncedTabsTotalCount(Ref ref) {
|
||||
return ref.watch(
|
||||
syncRemoteTabsProvider.selectAsync(
|
||||
(devices) =>
|
||||
devices.fold<int>(0, (count, device) => count + device.tabs.length),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<String?> effectiveSyncedTabsDeviceId(Ref ref) async {
|
||||
final devices = await ref.watch(
|
||||
syncRemoteTabsProvider.selectAsync((tabs) => tabs),
|
||||
);
|
||||
final selectedDeviceId = ref.watch(selectedSyncedTabsDeviceIdProvider);
|
||||
|
||||
if (devices.isEmpty) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (selectedDeviceId != null &&
|
||||
devices.any((device) => device.deviceId == selectedDeviceId)) {
|
||||
return selectedDeviceId;
|
||||
}
|
||||
|
||||
return devices.first.deviceId;
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<List<SyncedTabItem>> syncedTabsForSelectedDevice(Ref ref) async {
|
||||
final devices = await ref.watch(
|
||||
syncRemoteTabsProvider.selectAsync((tabs) => tabs),
|
||||
);
|
||||
|
||||
final selectedDeviceId = ref.watch(selectedSyncedTabsDeviceIdProvider);
|
||||
|
||||
final effectiveSelectedDeviceId =
|
||||
selectedDeviceId != null &&
|
||||
devices.any((device) => device.deviceId == selectedDeviceId)
|
||||
? selectedDeviceId
|
||||
: devices.firstOrNull?.deviceId;
|
||||
|
||||
if (effectiveSelectedDeviceId == null) {
|
||||
return const <SyncedTabItem>[];
|
||||
}
|
||||
|
||||
final device = devices.firstWhereOrNull(
|
||||
(item) => item.deviceId == effectiveSelectedDeviceId,
|
||||
);
|
||||
|
||||
if (device == null) {
|
||||
return const <SyncedTabItem>[];
|
||||
}
|
||||
|
||||
final tabs = device.tabs
|
||||
.map(
|
||||
(tab) => SyncedTabItem(
|
||||
deviceId: device.deviceId,
|
||||
deviceName: device.deviceName,
|
||||
tab: tab,
|
||||
),
|
||||
)
|
||||
.toList(growable: false);
|
||||
|
||||
tabs.sort((a, b) => b.tab.lastUsed.compareTo(a.tab.lastUsed));
|
||||
return tabs;
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
class SyncRepository extends _$SyncRepository {
|
||||
final _service = GeckoSyncService();
|
||||
|
||||
StreamSubscription<SyncAccountInfo>? _authStateSub;
|
||||
StreamSubscription<void>? _syncStartedSub;
|
||||
StreamSubscription<void>? _syncCompletedSub;
|
||||
StreamSubscription<String?>? _syncErrorSub;
|
||||
|
||||
Future<void> _awaitInitialized() => future;
|
||||
|
||||
void _update(SyncRepositoryState Function(SyncRepositoryState) updater) {
|
||||
final current = state.value;
|
||||
if (current != null) {
|
||||
state = AsyncData(updater(current));
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _refreshAccount() async {
|
||||
await _awaitInitialized();
|
||||
|
||||
final account = await _service.getAccountInfo();
|
||||
_update((s) => s.copyWith(account: account));
|
||||
}
|
||||
|
||||
Future<void> _refreshTabs() async {
|
||||
await _awaitInitialized();
|
||||
|
||||
try {
|
||||
final tabs = await _service.getSyncedTabs();
|
||||
_update((s) => s.copyWith(remoteTabs: tabs));
|
||||
} on Exception catch (e) {
|
||||
logger.e('Failed to refresh synced tabs', error: e);
|
||||
_update(
|
||||
(s) => s.copyWith(
|
||||
lastSyncEvent: SyncEvent.error,
|
||||
lastSyncError: e.toString(),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _refreshDevices() async {
|
||||
await _awaitInitialized();
|
||||
|
||||
try {
|
||||
final devices = await _service.getDevices();
|
||||
_update((s) => s.copyWith(devices: devices));
|
||||
} on Exception catch (e) {
|
||||
logger.e('Failed to refresh devices', error: e);
|
||||
_update(
|
||||
(s) => s.copyWith(
|
||||
lastSyncEvent: SyncEvent.error,
|
||||
lastSyncError: e.toString(),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _refreshDeviceName() async {
|
||||
await _awaitInitialized();
|
||||
|
||||
final deviceName = await _service.getDeviceName();
|
||||
_update((s) => s.copyWith(deviceName: deviceName));
|
||||
}
|
||||
|
||||
Future<SyncAccountInfo> refresh() async {
|
||||
await _refreshAccount();
|
||||
return state.value!.account;
|
||||
}
|
||||
|
||||
Future<void> signIn() async {
|
||||
await _service.beginAuthentication();
|
||||
}
|
||||
|
||||
Future<void> signInWithPairing(String pairingUrl) async {
|
||||
await _service.beginPairingAuthentication(pairingUrl);
|
||||
}
|
||||
|
||||
Future<void> signOut() async {
|
||||
await _service.logout();
|
||||
}
|
||||
|
||||
Future<void> syncNow() async {
|
||||
await _service.syncNow();
|
||||
await Future.wait([_refreshAccount(), _refreshTabs(), _refreshDevices()]);
|
||||
}
|
||||
|
||||
Future<void> setEngineEnabled(SyncEngineValue engine, bool enabled) async {
|
||||
await _service.setEngineEnabled(engine, enabled);
|
||||
await Future.wait([_refreshAccount(), _refreshTabs(), _refreshDevices()]);
|
||||
}
|
||||
|
||||
Future<bool> sendTabToDevice({
|
||||
required String deviceId,
|
||||
required String title,
|
||||
required String url,
|
||||
}) {
|
||||
return _service.sendTabToDevice(deviceId, title, url);
|
||||
}
|
||||
|
||||
Future<bool> setDeviceName(String newName) async {
|
||||
final result = await _service.setDeviceName(newName);
|
||||
|
||||
if (result) {
|
||||
await Future.wait([_refreshDevices(), _refreshDeviceName()]);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
Future<void> refreshDevices() async {
|
||||
await _service.refreshDevices();
|
||||
await _refreshDevices();
|
||||
}
|
||||
|
||||
Future<int> pollIncomingTabsAndOpen() async {
|
||||
await _service.pollDeviceCommands();
|
||||
final incomingTabs = await _service.drainIncomingTabs();
|
||||
|
||||
for (final tab in incomingTabs) {
|
||||
await _openUrlInAssignedContainer(tab.url);
|
||||
}
|
||||
|
||||
await _refreshTabs();
|
||||
return incomingTabs.length;
|
||||
}
|
||||
|
||||
Future<void> openSyncedTab(SyncRemoteTab tab) async {
|
||||
await _openUrlInAssignedContainer(tab.url);
|
||||
}
|
||||
|
||||
Future<void> _openUrlInAssignedContainer(String url) async {
|
||||
final uri = Uri.tryParse(url);
|
||||
if (uri == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
final containerRepository = ref.read(containerRepositoryProvider.notifier);
|
||||
|
||||
final containerId = await containerRepository.siteAssignedContainerId(uri);
|
||||
|
||||
final assignedContainer = containerId == null
|
||||
? null
|
||||
: await containerRepository.getContainerData(containerId);
|
||||
|
||||
await ref
|
||||
.read(tabRepositoryProvider.notifier)
|
||||
.addTab(
|
||||
url: uri,
|
||||
selectTab: true,
|
||||
private: false,
|
||||
container: Value(assignedContainer),
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<SyncRepositoryState> build() async {
|
||||
final syncStateService = ref.read(geckoSyncStateServiceProvider);
|
||||
|
||||
_syncStartedSub = syncStateService.syncStartedEvents.listen((_) {
|
||||
_update(
|
||||
(s) => s.copyWith(
|
||||
lastSyncEvent: SyncEvent.started,
|
||||
// ignore: avoid_redundant_argument_values
|
||||
lastSyncError: null,
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
_syncCompletedSub = syncStateService.syncCompletedEvents.listen((_) {
|
||||
_update(
|
||||
(s) => s.copyWith(
|
||||
lastSyncEvent: SyncEvent.completed,
|
||||
// ignore: avoid_redundant_argument_values
|
||||
lastSyncError: null,
|
||||
),
|
||||
);
|
||||
unawaited(Future.wait([_refreshTabs(), _refreshDevices()]));
|
||||
});
|
||||
|
||||
_syncErrorSub = syncStateService.syncErrorEvents.listen((error) {
|
||||
logger.e('Sync failed', error: error ?? 'Unknown synchronization error');
|
||||
_update(
|
||||
(s) => s.copyWith(lastSyncEvent: SyncEvent.error, lastSyncError: error),
|
||||
);
|
||||
unawaited(Future.wait([_refreshTabs(), _refreshDevices()]));
|
||||
});
|
||||
|
||||
_authStateSub = syncStateService.authStateEvents.listen((info) {
|
||||
final previous = state.value;
|
||||
|
||||
if (previous == null) {
|
||||
state = AsyncData(SyncRepositoryState(account: info));
|
||||
return;
|
||||
}
|
||||
|
||||
final unauthenticated = !info.authenticated;
|
||||
state = AsyncData(
|
||||
unauthenticated
|
||||
? SyncRepositoryState(account: info)
|
||||
: previous.copyWith(account: info),
|
||||
);
|
||||
|
||||
final authStateChanged =
|
||||
previous.account.authenticated != info.authenticated ||
|
||||
previous.account.needsReauth != info.needsReauth;
|
||||
|
||||
if (authStateChanged && info.authenticated) {
|
||||
unawaited(
|
||||
Future.wait([
|
||||
_refreshAccount(),
|
||||
_refreshTabs(),
|
||||
_refreshDevices(),
|
||||
_refreshDeviceName(),
|
||||
]),
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
ref.onDispose(() {
|
||||
unawaited(_authStateSub?.cancel());
|
||||
unawaited(_syncStartedSub?.cancel());
|
||||
unawaited(_syncCompletedSub?.cancel());
|
||||
unawaited(_syncErrorSub?.cancel());
|
||||
});
|
||||
|
||||
final (account, tabs, devices, deviceName) = await (
|
||||
_service.getAccountInfo(),
|
||||
_service.getSyncedTabs(),
|
||||
_service.getDevices(),
|
||||
_service.getDeviceName(),
|
||||
).wait;
|
||||
|
||||
return SyncRepositoryState(
|
||||
account: account,
|
||||
remoteTabs: tabs,
|
||||
devices: devices,
|
||||
deviceName: deviceName,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Riverpod(keepAlive: true)
|
||||
GeckoSyncStateService geckoSyncStateService(Ref ref) {
|
||||
final service = GeckoSyncStateService.setUp();
|
||||
ref.onDispose(() => service.dispose());
|
||||
return service;
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<String?> syncDeviceName(Ref ref) {
|
||||
return ref.watch(
|
||||
syncRepositoryProvider.selectAsync((value) => value.deviceName),
|
||||
);
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<List<SyncDeviceTabs>> syncRemoteTabs(Ref ref) {
|
||||
return ref.watch(
|
||||
syncRepositoryProvider.selectAsync((value) => value.remoteTabs),
|
||||
);
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<List<SyncDevice>> syncDevices(Ref ref) {
|
||||
return ref.watch(
|
||||
syncRepositoryProvider.selectAsync((value) => value.devices),
|
||||
);
|
||||
}
|
||||
|
||||
@riverpod
|
||||
Future<(SyncEvent?, String?)> syncEvent(Ref ref) {
|
||||
return ref.watch(
|
||||
syncRepositoryProvider.selectAsync(
|
||||
(s) => (s.lastSyncEvent, s.lastSyncError),
|
||||
),
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user