checkpoint

lib/tick.dart

@@ -0,0 +1,165 @@
+// XXX Eliminate this when we have ValueChanged
+import 'dart:async';
+
+import 'package:fast_immutable_collections/fast_immutable_collections.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../entities/proto.dart' as proto;
+import 'providers/account.dart';
+import 'providers/chat.dart';
+import 'providers/contact.dart';
+import 'providers/contact_invite.dart';
+import 'providers/conversation.dart';
+
+const int ticksPerContactInvitationCheck = 5;
+const int ticksPerNewMessageCheck = 5;
+
+class BackgroundTicker extends ConsumerStatefulWidget {
+  const BackgroundTicker({required this.builder, super.key});
+
+  final Widget Function(BuildContext) builder;
+
+  @override
+  BackgroundTickerState createState() => BackgroundTickerState();
+}
+
+class BackgroundTickerState extends ConsumerState<BackgroundTicker> {
+  Timer? _tickTimer;
+  bool _inTick = false;
+  int _contactInvitationCheckTick = 0;
+  int _newMessageCheckTick = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    _tickTimer = Timer.periodic(const Duration(seconds: 1), (timer) {
+      if (!_inTick) {
+        unawaited(_onTick());
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    final tickTimer = _tickTimer;
+    if (tickTimer != null) {
+      tickTimer.cancel();
+    }
+
+    super.dispose();
+  }
+
+  @override
+  // ignore: prefer_expression_function_bodies
+  Widget build(BuildContext context) {
+    return widget.builder(context);
+  }
+
+  Future<void> _onTick() async {
+    _inTick = true;
+    try {
+      final unord = <Future<void>>[];
+      // Check extant contact invitations once every N seconds
+      _contactInvitationCheckTick += 1;
+      if (_contactInvitationCheckTick >= ticksPerContactInvitationCheck) {
+        _contactInvitationCheckTick = 0;
+        unord.add(_doContactInvitationCheck());
+      }
+
+      // Check new messages once every N seconds
+      _newMessageCheckTick += 1;
+      if (_newMessageCheckTick >= ticksPerNewMessageCheck) {
+        _newMessageCheckTick = 0;
+        unord.add(_doNewMessageCheck());
+      }
+      if (unord.isNotEmpty) {
+        await Future.wait(unord);
+      }
+    } finally {
+      _inTick = false;
+    }
+  }
+
+  Future<void> _doContactInvitationCheck() async {
+    final contactInvitationRecords =
+        await ref.read(fetchContactInvitationRecordsProvider.future);
+    final activeAccountInfo = await ref.read(fetchActiveAccountProvider.future);
+    if (contactInvitationRecords == null || activeAccountInfo == null) {
+      return;
+    }
+
+    final allChecks = <Future<void>>[];
+    for (final contactInvitationRecord in contactInvitationRecords) {
+      allChecks.add(() async {
+        final acceptReject = await checkAcceptRejectContact(
+            activeAccountInfo: activeAccountInfo,
+            contactInvitationRecord: contactInvitationRecord);
+        if (acceptReject != null) {
+          final acceptedContact = acceptReject.acceptedContact;
+          if (acceptedContact != null) {
+            // Accept
+            await createContact(
+              activeAccountInfo: activeAccountInfo,
+              profile: acceptedContact.profile,
+              remoteIdentity: acceptedContact.remoteIdentity,
+              remoteConversationRecordKey:
+                  acceptedContact.remoteConversationRecordKey,
+              localConversationRecordKey:
+                  acceptedContact.localConversationRecordKey,
+            );
+            ref
+              ..invalidate(fetchContactInvitationRecordsProvider)
+              ..invalidate(fetchContactListProvider);
+          } else {
+            // Reject
+            ref.invalidate(fetchContactInvitationRecordsProvider);
+          }
+        }
+      }());
+    }
+    await Future.wait(allChecks);
+  }
+
+  Future<void> _doNewMessageCheck() async {
+    final activeChat = activeChatState.currentState;
+    if (activeChat == null) {
+      return;
+    }
+    final activeAccountInfo = await ref.read(fetchActiveAccountProvider.future);
+    if (activeAccountInfo == null) {
+      return;
+    }
+
+    final contactList = ref.read(fetchContactListProvider).asData?.value ??
+        const IListConst([]);
+
+    final activeChatContactIdx = contactList.indexWhere(
+      (c) =>
+          proto.TypedKeyProto.fromProto(c.remoteConversationRecordKey) ==
+          activeChat,
+    );
+    if (activeChatContactIdx == -1) {
+      return;
+    }
+    final activeChatContact = contactList[activeChatContactIdx];
+    final remoteIdentityPublicKey =
+        proto.TypedKeyProto.fromProto(activeChatContact.identityPublicKey);
+    final remoteConversationRecordKey = proto.TypedKeyProto.fromProto(
+        activeChatContact.remoteConversationRecordKey);
+    final localConversationRecordKey = proto.TypedKeyProto.fromProto(
+        activeChatContact.localConversationRecordKey);
+
+    final newMessages = await getRemoteConversationMessages(
+        activeAccountInfo: activeAccountInfo,
+        remoteIdentityPublicKey: remoteIdentityPublicKey,
+        remoteConversationRecordKey: remoteConversationRecordKey);
+    if (newMessages != null) {
+      await mergeLocalConversationMessages(
+          activeAccountInfo: activeAccountInfo,
+          localConversationRecordKey: localConversationRecordKey,
+          remoteIdentityPublicKey: remoteIdentityPublicKey,
+          newMessages: newMessages);
+    }
+  }
+}