Refactor

2023-12-01 12:56:24 +03:30
parent 9c165e178b
commit ed614988a2
181 changed files with 3092 additions and 2341 deletions
--- a/lib/features/connection/notifier/connection_notifier.dart
+++ b/lib/features/connection/notifier/connection_notifier.dart
@@ -0,0 +1,114 @@
+import 'package:hiddify/core/preferences/general_preferences.dart';
+import 'package:hiddify/core/preferences/service_preferences.dart';
+import 'package:hiddify/features/connection/data/connection_data_providers.dart';
+import 'package:hiddify/features/connection/data/connection_repository.dart';
+import 'package:hiddify/features/connection/model/connection_status.dart';
+import 'package:hiddify/features/profile/notifier/active_profile_notifier.dart';
+import 'package:hiddify/utils/utils.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:rxdart/rxdart.dart';
+
+part 'connection_notifier.g.dart';
+
+@Riverpod(keepAlive: true)
+class ConnectionNotifier extends _$ConnectionNotifier with AppLogger {
+  @override
+  Stream<ConnectionStatus> build() {
+    ref.listen(
+      activeProfileProvider.select((value) => value.asData?.value),
+      (previous, next) async {
+        if (previous == null) return;
+        final shouldReconnect = next == null || previous.id != next.id;
+        if (shouldReconnect) {
+          await reconnect(next?.id);
+        }
+      },
+    );
+    return _connectionRepo.watchConnectionStatus().doOnData((event) {
+      if (event case Disconnected(connectionFailure: final _?)
+          when PlatformUtils.isDesktop) {
+        ref.read(startedByUserProvider.notifier).update(false);
+      }
+      loggy.info("connection status: ${event.format()}");
+    });
+  }
+
+  ConnectionRepository get _connectionRepo =>
+      ref.read(connectionRepositoryProvider);
+
+  Future<void> mayConnect() async {
+    if (state case AsyncData(:final value)) {
+      if (value case Disconnected()) return _connect();
+    }
+  }
+
+  Future<void> toggleConnection() async {
+    if (state case AsyncError()) {
+      await _connect();
+    } else if (state case AsyncData(:final value)) {
+      switch (value) {
+        case Disconnected():
+          await ref.read(startedByUserProvider.notifier).update(true);
+          await _connect();
+        case Connected():
+          await ref.read(startedByUserProvider.notifier).update(false);
+          await _disconnect();
+        default:
+          loggy.warning("switching status, debounce");
+      }
+    }
+  }
+
+  Future<void> reconnect(String? profileId) async {
+    if (state case AsyncData(:final value) when value == const Connected()) {
+      if (profileId == null) {
+        loggy.info("no active profile, disconnecting");
+        return _disconnect();
+      }
+      loggy.info("active profile changed, reconnecting");
+      await ref.read(startedByUserProvider.notifier).update(true);
+      await _connectionRepo
+          .reconnect(profileId, ref.read(disableMemoryLimitProvider))
+          .mapLeft((err) {
+        loggy.warning("error reconnecting", err);
+        state = AsyncError(err, StackTrace.current);
+      }).run();
+    }
+  }
+
+  Future<void> abortConnection() async {
+    if (state case AsyncData(:final value)) {
+      switch (value) {
+        case Connected() || Connecting():
+          loggy.debug("aborting connection");
+          await _disconnect();
+        default:
+      }
+    }
+  }
+
+  Future<void> _connect() async {
+    final activeProfile = await ref.read(activeProfileProvider.future);
+    await _connectionRepo
+        .connect(activeProfile!.id, ref.read(disableMemoryLimitProvider))
+        .mapLeft((err) async {
+      loggy.warning("error connecting", err);
+      await ref.read(startedByUserProvider.notifier).update(false);
+      state = AsyncError(err, StackTrace.current);
+    }).run();
+  }
+
+  Future<void> _disconnect() async {
+    await _connectionRepo.disconnect().mapLeft((err) {
+      loggy.warning("error disconnecting", err);
+      state = AsyncError(err, StackTrace.current);
+    }).run();
+  }
+}
+
+@Riverpod(keepAlive: true)
+Future<bool> serviceRunning(ServiceRunningRef ref) => ref
+    .watch(
+      connectionNotifierProvider.selectAsync((data) => data.isConnected),
+    )
+    .onError((error, stackTrace) => false);