Line data Source code
1 : import 'dart:async'; 2 : import 'package:flutter/foundation.dart'; 3 : import 'message.dart'; 4 : 5 : // we only count up to 100 unread messages, if more than that we can't accurately resync message cache, just reset 6 : // https://git.openprivacy.ca/cwtch.im/libcwtch-go/src/branch/trunk/utils/eventHandler.go#L210 7 : const MaxUnreadBeforeCacheReset = 100; 8 : 9 : class MessageInfo { 10 : late MessageMetadata metadata; 11 : late String wrapper; 12 : 13 0 : MessageInfo(this.metadata, this.wrapper); 14 : 15 0 : int size() { 16 0 : var wrapperSize = wrapper.length * 2; 17 : return wrapperSize; 18 : } 19 : } 20 : 21 : class LocalIndexMessage { 22 : late bool cacheOnly; 23 : late bool isLoading; 24 : late Future<void> loaded; 25 : late Completer<void> loader; 26 : 27 : late int? messageId; 28 : 29 0 : LocalIndexMessage(int? messageId, {cacheOnly = false, isLoading = false}) { 30 0 : this.messageId = messageId; 31 0 : this.cacheOnly = cacheOnly; 32 0 : this.isLoading = isLoading; 33 0 : loader = Completer<void>(); 34 0 : loaded = loader.future; 35 : if (!isLoading) { 36 0 : loader.complete(); // complete this 37 : } 38 : } 39 : 40 0 : void finishLoad(int messageId) { 41 0 : this.messageId = messageId; 42 0 : if (!loader.isCompleted) { 43 0 : isLoading = false; 44 0 : loader.complete(true); 45 : } 46 : } 47 : 48 0 : void failLoad() { 49 0 : this.messageId = null; 50 0 : if (!loader.isCompleted) { 51 0 : isLoading = false; 52 0 : loader.complete(true); 53 : } 54 : } 55 : 56 0 : Future<void> waitForLoad() { 57 0 : return loaded; 58 : } 59 : 60 0 : Future<int?> get() async { 61 0 : if (isLoading) { 62 0 : await waitForLoad(); 63 : } 64 0 : return messageId; 65 : } 66 : } 67 : 68 : // Message cache stores messages for use by the UI and uses MessageHandler and associated ByX loaders 69 : // the cache stores messages in a cache indexed by their storage Id, and has two secondary indexes into it, content hash, and local index 70 : // Index is the primary way to access the cache as it is a sequential ordered access and is used by the message pane 71 : // contentHash is used for fetching replies 72 : // by Id is used when composing a reply 73 : // cacheByIndex supports additional features than just a direct index into the cache (byID) 74 : // it allows locking of ranges in order to support bulk sequential loading (see ByIndex in message.dart) 75 : // cacheByIndex allows allows inserting temporarily non storage backed messages so that Send Message can be respected instantly and then updated upon insertion into backend 76 : // the message cache needs storageMessageCount maintained by the system so it can inform bulk loading when it's reaching the end of fetchable messages 77 : class MessageCache extends ChangeNotifier { 78 : // cache of MessageId to Message 79 : late Map<int, MessageInfo> cache; 80 : 81 : // local index to MessageId 82 : late List<LocalIndexMessage> cacheByIndex; 83 : // index unsynced is used on android on reconnect to tell us new messages are in the backend that should be at the front of the index cache 84 : int _indexUnsynced = 0; 85 : 86 : // map of content hash to MessageId 87 : late Map<String, int> cacheByHash; 88 : 89 : late int _storageMessageCount; 90 : 91 0 : MessageCache(int storageMessageCount) { 92 0 : cache = {}; 93 0 : cacheByIndex = List.empty(growable: true); 94 0 : cacheByHash = {}; 95 0 : this._storageMessageCount = storageMessageCount; 96 : } 97 : 98 0 : int get storageMessageCount => _storageMessageCount; 99 0 : set storageMessageCount(int newval) { 100 0 : this._storageMessageCount = newval; 101 : } 102 : 103 : // On android reconnect, if backend supplied message count > UI message count, add the difference to the front of the index 104 0 : void addFrontIndexGap(int count) { 105 0 : this._indexUnsynced = count; 106 : } 107 : 108 0 : int get indexUnsynced => _indexUnsynced; 109 : 110 0 : MessageInfo? getById(int id) => cache[id]; 111 : 112 0 : Future<MessageInfo?> getByIndex(int index) async { 113 0 : if (index >= cacheByIndex.length) { 114 : return null; 115 : } 116 0 : var id = await cacheByIndex[index].get(); 117 : if (id == null) { 118 0 : return Future<MessageInfo?>.value(null); 119 : } 120 0 : return cache[id]; 121 : } 122 : 123 0 : int findIndex(int id) { 124 0 : return cacheByIndex.indexWhere((element) => element.messageId == id); 125 : } 126 : 127 0 : MessageInfo? getByContentHash(String contenthash) => cache[cacheByHash[contenthash]]; 128 : 129 0 : void addNew(String profileOnion, int conversation, int messageID, DateTime timestamp, String senderHandle, String senderImage, bool isAuto, String data, String contenthash) { 130 0 : this.cache[messageID] = MessageInfo(MessageMetadata(profileOnion, conversation, messageID, timestamp, senderHandle, senderImage, "", {}, false, false, isAuto, contenthash), data); 131 0 : this.cacheByIndex.insert(0, LocalIndexMessage(messageID)); 132 0 : if (contenthash != "") { 133 0 : this.cacheByHash[contenthash] = messageID; 134 : } 135 : } 136 : 137 : // inserts place holder values into the index cache that will block on .get() until .finishLoad() is called on them with message contents 138 : // or .failLoad() is called on them to mark them malformed 139 : // this prevents successive ui message build requests from triggering multiple GetMesssage requests to the backend, as the first one locks a block of messages and the rest wait on that 140 0 : void lockIndexes(int start, int end) { 141 0 : for (var i = start; i < end; i++) { 142 0 : this.cacheByIndex.insert(i, LocalIndexMessage(null, isLoading: true)); 143 : // if there are unsynced messages on the index cache it means there are messages at the front, and by the logic in message/ByIndex/get() we will be loading those 144 : // there for we can decrement the count as this will be one of them 145 0 : if (this._indexUnsynced > 0) { 146 0 : this._indexUnsynced--; 147 : } 148 : } 149 : } 150 : 151 0 : void malformIndexes(int start, int end) { 152 0 : for (var i = start; i < end; i++) { 153 0 : this.cacheByIndex[i].failLoad(); 154 : } 155 : } 156 : 157 0 : void addIndexed(MessageInfo messageInfo, int index) { 158 0 : this.cache[messageInfo.metadata.messageID] = messageInfo; 159 0 : if (index < this.cacheByIndex.length) { 160 0 : this.cacheByIndex[index].finishLoad(messageInfo.metadata.messageID); 161 : } else { 162 0 : this.cacheByIndex.insert(index, LocalIndexMessage(messageInfo.metadata.messageID)); 163 : } 164 0 : this.cacheByHash[messageInfo.metadata.contenthash] = messageInfo.metadata.messageID; 165 : } 166 : 167 0 : void addUnindexed(MessageInfo messageInfo) { 168 0 : this.cache[messageInfo.metadata.messageID] = messageInfo; 169 0 : if (messageInfo.metadata.contenthash != "") { 170 0 : this.cacheByHash[messageInfo.metadata.contenthash] = messageInfo.metadata.messageID; 171 : } 172 : } 173 : 174 0 : void ackCache(int messageID) { 175 0 : cache[messageID]?.metadata.ackd = true; 176 0 : notifyListeners(); 177 : } 178 : 179 0 : void errCache(int messageID) { 180 0 : cache[messageID]?.metadata.error = true; 181 0 : notifyListeners(); 182 : } 183 : 184 0 : void notifyUpdate(int messageID) { 185 0 : notifyListeners(); 186 : } 187 : 188 0 : int size() { 189 : // very naive cache size, assuming MessageInfo are fairly large on average 190 : // and everything else is small in comparison 191 0 : int cacheSize = cache.entries.map((e) => e.value.size()).fold(0, (previousValue, element) => previousValue + element); 192 0 : return cacheSize + cacheByHash.length * 64 + cacheByIndex.length * 16; 193 : } 194 : 195 0 : void updateTranslationEvent(int messageID, String translation) { 196 0 : cache[messageID]?.metadata.updateTranslationEvent(translation); 197 0 : notifyListeners(); 198 : } 199 : }