161 lines
4.9 KiB
TypeScript
161 lines
4.9 KiB
TypeScript
// Copyright 2017 Signal Messenger, LLC
|
|
// SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
/* eslint-disable max-classes-per-file */
|
|
|
|
import { Collection, Model } from 'backbone';
|
|
|
|
import type { MessageModel } from '../models/messages';
|
|
import { isIncoming } from '../state/selectors/message';
|
|
import { isMessageUnread } from '../util/isMessageUnread';
|
|
import { notificationService } from '../services/notifications';
|
|
import * as log from '../logging/log';
|
|
import * as Errors from '../types/errors';
|
|
import type { AciString } from '../types/ServiceId';
|
|
import { StartupQueue } from '../util/StartupQueue';
|
|
import { queueUpdateMessage } from '../util/messageBatcher';
|
|
import { getMessageSentTimestamp } from '../util/getMessageSentTimestamp';
|
|
|
|
export type ReadSyncAttributesType = {
|
|
senderId: string;
|
|
sender?: string;
|
|
senderAci: AciString;
|
|
timestamp: number;
|
|
readAt: number;
|
|
};
|
|
|
|
class ReadSyncModel extends Model<ReadSyncAttributesType> {}
|
|
|
|
let singleton: ReadSyncs | undefined;
|
|
|
|
async function maybeItIsAReactionReadSync(sync: ReadSyncModel): Promise<void> {
|
|
const readReaction = await window.Signal.Data.markReactionAsRead(
|
|
sync.get('senderAci'),
|
|
Number(sync.get('timestamp'))
|
|
);
|
|
|
|
if (!readReaction) {
|
|
log.info(
|
|
'Nothing found for read sync',
|
|
sync.get('senderId'),
|
|
sync.get('sender'),
|
|
sync.get('senderAci'),
|
|
sync.get('timestamp')
|
|
);
|
|
return;
|
|
}
|
|
|
|
notificationService.removeBy({
|
|
conversationId: readReaction.conversationId,
|
|
emoji: readReaction.emoji,
|
|
targetAuthorAci: readReaction.targetAuthorAci,
|
|
targetTimestamp: readReaction.targetTimestamp,
|
|
});
|
|
}
|
|
|
|
export class ReadSyncs extends Collection {
|
|
static getSingleton(): ReadSyncs {
|
|
if (!singleton) {
|
|
singleton = new ReadSyncs();
|
|
}
|
|
|
|
return singleton;
|
|
}
|
|
|
|
forMessage(message: MessageModel): ReadSyncModel | null {
|
|
const sender = window.ConversationController.lookupOrCreate({
|
|
e164: message.get('source'),
|
|
serviceId: message.get('sourceServiceId'),
|
|
reason: 'ReadSyncs.forMessage',
|
|
});
|
|
const messageTimestamp = getMessageSentTimestamp(message.attributes, {
|
|
log,
|
|
});
|
|
const sync = this.find(item => {
|
|
return (
|
|
item.get('senderId') === sender?.id &&
|
|
item.get('timestamp') === messageTimestamp
|
|
);
|
|
});
|
|
if (sync) {
|
|
log.info(`Found early read sync for message ${sync.get('timestamp')}`);
|
|
this.remove(sync);
|
|
return sync;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
async onSync(sync: ReadSyncModel): Promise<void> {
|
|
try {
|
|
const messages = await window.Signal.Data.getMessagesBySentAt(
|
|
sync.get('timestamp')
|
|
);
|
|
|
|
const found = messages.find(item => {
|
|
const sender = window.ConversationController.lookupOrCreate({
|
|
e164: item.source,
|
|
serviceId: item.sourceServiceId,
|
|
reason: 'ReadSyncs.onSync',
|
|
});
|
|
|
|
return isIncoming(item) && sender?.id === sync.get('senderId');
|
|
});
|
|
|
|
if (!found) {
|
|
await maybeItIsAReactionReadSync(sync);
|
|
return;
|
|
}
|
|
|
|
notificationService.removeBy({ messageId: found.id });
|
|
|
|
const message = window.MessageController.register(found.id, found);
|
|
const readAt = Math.min(sync.get('readAt'), Date.now());
|
|
|
|
// If message is unread, we mark it read. Otherwise, we update the expiration
|
|
// timer to the time specified by the read sync if it's earlier than
|
|
// the previous read time.
|
|
if (isMessageUnread(message.attributes)) {
|
|
// TODO DESKTOP-1509: use MessageUpdater.markRead once this is TS
|
|
message.markRead(readAt, { skipSave: true });
|
|
|
|
const updateConversation = async () => {
|
|
// onReadMessage may result in messages older than this one being
|
|
// marked read. We want those messages to have the same expire timer
|
|
// start time as this one, so we pass the readAt value through.
|
|
void message.getConversation()?.onReadMessage(message, readAt);
|
|
};
|
|
|
|
// only available during initialization
|
|
if (StartupQueue.isAvailable()) {
|
|
const conversation = message.getConversation();
|
|
if (conversation) {
|
|
StartupQueue.add(
|
|
conversation.get('id'),
|
|
message.get('sent_at'),
|
|
updateConversation
|
|
);
|
|
}
|
|
} else {
|
|
// not awaiting since we don't want to block work happening in the
|
|
// eventHandlerQueue
|
|
void updateConversation();
|
|
}
|
|
} else {
|
|
const now = Date.now();
|
|
const existingTimestamp = message.get('expirationStartTimestamp');
|
|
const expirationStartTimestamp = Math.min(
|
|
now,
|
|
Math.min(existingTimestamp || now, readAt || now)
|
|
);
|
|
message.set({ expirationStartTimestamp });
|
|
}
|
|
|
|
queueUpdateMessage(message.attributes);
|
|
|
|
this.remove(sync);
|
|
} catch (error) {
|
|
log.error('ReadSyncs.onSync error:', Errors.toLogFormat(error));
|
|
}
|
|
}
|
|
}
|