state change notifications

Author: pierre-lehnen-rc

apps/meteor/app/push/server/definition.ts

@@ -42,5 +42,5 @@ export type PendingPushNotification = {
 	priority?: number;
 
 	contentAvailable?: 1 | 0;
-	voip?: boolean;
+	useVoipToken?: boolean;
 };

apps/meteor/app/push/server/push.ts

@@ -18,6 +18,7 @@ export const _matchToken = Match.OneOf({ apn: String }, { gcm: String });
 
 const PUSH_TITLE_LIMIT = 65;
 const PUSH_MESSAGE_BODY_LIMIT = 240;
+const PUSH_GATEWAY_MAX_ATTEMPTS = 5;
 
 type FCMCredentials = {
 	type: string;
@@ -185,8 +186,8 @@ class PushClass {
 		logger.debug({ msg: 'send to token', token: app.token });
 
 		if ('apn' in app.token && app.token.apn) {
-			const userToken = notification.voip ? app.voipToken : app.token.apn;
-			const topic = notification.voip ? `${app.appName}.voip` : app.appName;
+			const userToken = notification.useVoipToken ? app.voipToken : app.token.apn;
+			const topic = notification.useVoipToken ? `${app.appName}.voip` : app.appName;
 
 			countApn.push(app._id);
 			// Send to APN
@@ -254,7 +255,7 @@ class PushClass {
 		service: 'apn' | 'gcm',
 		token: string,
 		notification: Optional<GatewayNotification, 'uniqueId'>,
-		tries = 0,
+		retryOptions: { tries: number; maxTries: number } = { tries: 0, maxTries: PUSH_GATEWAY_MAX_ATTEMPTS },
 	): Promise<void> {
 		notification.uniqueId = this.options.uniqueId;
 
@@ -292,15 +293,17 @@ class PushClass {
 			return;
 		}
 
+		const { tries, maxTries } = retryOptions;
+
 		logger.error({ msg: 'Error sending push to gateway', tries, err: response });
 
-		if (tries <= 4) {
+		if (tries < maxTries) {
 			// [1, 2, 4, 8, 16] minutes (total 31)
 			const ms = 60000 * Math.pow(2, tries);
 
 			logger.log({ msg: 'Retrying push to gateway', tries: tries + 1, in: ms });
 
-			setTimeout(() => this.sendGatewayPush(gateway, service, token, notification, tries + 1), ms);
+			setTimeout(() => this.sendGatewayPush(gateway, service, token, notification, { tries: tries + 1, maxTries }), ms);
 		}
 	}
 
@@ -325,40 +328,47 @@ class PushClass {
 		}
 
 		const gatewayNotification = this.getGatewayNotificationData(notification);
+		const retryOptions = {
+			tries: 0,
+			maxTries: notification.useVoipToken ? 1 : PUSH_GATEWAY_MAX_ATTEMPTS,
+		};
 
 		for (const gateway of this.options.gateways) {
 			logger.debug({ msg: 'send to token', token: app.token });
 
 			if ('apn' in app.token && app.token.apn) {
-				const token = notification.voip ? app.voipToken : app.token.apn;
-				const topic = notification.voip ? `${app.appName}.voip` : app.appName;
+				const token = notification.useVoipToken ? app.voipToken : app.token.apn;
+				const topic = notification.useVoipToken ? `${app.appName}.voip` : app.appName;
 
 				if (token) {
 					countApn.push(app._id);
-					return this.sendGatewayPush(gateway, 'apn', token, { topic, ...gatewayNotification });
+					return this.sendGatewayPush(gateway, 'apn', token, { topic, ...gatewayNotification }, retryOptions);
 				}
 			}
 
 			if ('gcm' in app.token && app.token.gcm) {
 				countGcm.push(app._id);
-				return this.sendGatewayPush(gateway, 'gcm', app.token.gcm, gatewayNotification);
+				return this.sendGatewayPush(gateway, 'gcm', app.token.gcm, gatewayNotification, retryOptions);
 			}
 		}
 	}
 
-	private async sendNotification(notification: PendingPushNotification): Promise<{ apn: string[]; gcm: string[] }> {
+	private async sendNotification(
+		notification: PendingPushNotification,
+		options: { skipTokenId?: IPushToken['_id'] } = {},
+	): Promise<{ apn: string[]; gcm: string[] }> {
 		logger.debug({ msg: 'Sending notification', notification });
 
 		const countApn: string[] = [];
 		const countGcm: string[] = [];
 
-		if (notification.from !== String(notification.from)) {
+		if (notification.from && notification.from !== String(notification.from)) {
 			throw new Error('Push.send: option "from" not a string');
 		}
-		if (notification.title !== String(notification.title)) {
+		if (notification.title && notification.title !== String(notification.title)) {
 			throw new Error('Push.send: option "title" not a string');
 		}
-		if (notification.text !== String(notification.text)) {
+		if (notification.text && notification.text !== String(notification.text)) {
 			throw new Error('Push.send: option "text" not a string');
 		}
 
@@ -368,7 +378,9 @@ class PushClass {
 			userId: notification.userId,
 		});
 
-		const appTokens = PushToken.findAllTokensByUserId(notification.userId);
+		const appTokens = options.skipTokenId
+			? PushToken.findTokensByUserIdExceptId(notification.userId, options.skipTokenId)
+			: PushToken.findAllTokensByUserId(notification.userId);
 
 		for await (const app of appTokens) {
 			logger.debug({ msg: 'send to token', token: app.token });
@@ -438,7 +450,7 @@ class PushClass {
 			createdAt: Date,
 			createdBy: Match.OneOf(String, null),
 			priority: Match.Optional(Match.Integer),
-			voip: Match.Optional(Boolean),
+			useVoipToken: Match.Optional(Boolean),
 		});
 
 		if (!notification.userId) {
@@ -455,13 +467,13 @@ class PushClass {
 	}
 
 	public async send(options: IPushNotificationConfig) {
-		const notification = {
+		const notification: PendingPushNotification = {
 			createdAt: new Date(),
 			// createdBy is no longer used, but the gateway still expects it
 			createdBy: '<SERVER>',
 			sent: false,
 			sending: 0,
-			...pick(options, 'from', 'userId', 'payload', 'badge', 'sound', 'notId', 'priority', 'voip'),
+			...pick(options, 'from', 'userId', 'payload', 'badge', 'sound', 'notId', 'priority', 'useVoipToken'),
 			...(options.title && { title: truncateString(options.title, PUSH_TITLE_LIMIT) }),
 			...(options.text && { text: truncateString(options.text, PUSH_MESSAGE_BODY_LIMIT) }),
 
@@ -485,7 +497,7 @@ class PushClass {
 		this._validateDocument(notification);
 
 		try {
-			await this.sendNotification(notification);
+			await this.sendNotification(notification, pick(options, 'skipTokenId'));
 		} catch (error: any) {
 			logger.debug({
 				msg: 'Could not send notification to user',

apps/meteor/server/services/media-call/logger.ts

@@ -0,0 +1,3 @@
+import { Logger } from '@rocket.chat/logger';
+
+export const logger = new Logger('media-call service');

apps/meteor/server/services/media-call/push/getPushNotificationType.ts

@@ -0,0 +1,23 @@
+import type { IMediaCall } from '@rocket.chat/core-typings';
+
+export type VoipPushNotificationType = 'incoming_call' | 'remoteEnded' | 'answeredElsewhere' | 'declinedElsewhere' | 'unanswered';
+
+export function getPushNotificationType(call: IMediaCall): VoipPushNotificationType {
+	if (call.acceptedAt) {
+		return 'answeredElsewhere';
+	}
+
+	if (call.endedBy?.id === call.callee.id || call.hangupReason === 'rejected') {
+		return 'declinedElsewhere';
+	}
+
+	if (call.endedBy?.id === call.caller.id) {
+		return 'remoteEnded';
+	}
+
+	if (call.ended) {
+		return 'unanswered';
+	}
+
+	return 'incoming_call';
+}

apps/meteor/server/services/media-call/push/sendVoipPushNotification.ts

@@ -0,0 +1,103 @@
+import type { IMediaCall, IUser, MediaCallContact, MediaCallActorType } from '@rocket.chat/core-typings';
+import type { VoipPushNotificationEventType } from '@rocket.chat/media-calls';
+import { MediaCalls, Users } from '@rocket.chat/models';
+
+import { getPushNotificationType } from './getPushNotificationType';
+import { metrics } from '../../../../app/metrics/server/lib/metrics';
+import { Push } from '../../../../app/push/server/push';
+import PushNotification from '../../../../app/push-notifications/server/lib/PushNotification';
+import { settings } from '../../../../app/settings/server';
+import { getUserAvatarURL } from '../../../../app/utils/server/getUserAvatarURL';
+import { logger } from '../logger';
+
+async function getActorUser<T extends Pick<IUser, '_id' | 'name' | 'username' | 'freeSwitchExtension'>>(
+	actor: MediaCallContact,
+): Promise<T | null> {
+	const options = { projection: { name: 1, username: 1 } };
+
+	switch (actor.type) {
+		case 'user':
+			return Users.findOneById<T>(actor.id, options);
+		case 'sip':
+			return Users.findOneByFreeSwitchExtension<T>(actor.id, options);
+	}
+}
+
+async function getActorUserData(
+	actor: MediaCallContact,
+): Promise<{ type: MediaCallActorType; id: string; name: string; avatarUrl?: string }> {
+	const actorUsername = actor.type === 'user' ? actor.username : undefined;
+	const actorExtension = actor.sipExtension || (actor.type === 'sip' ? actor.id : undefined);
+
+	const data = {
+		type: actor.type,
+		id: actor.id,
+		name: actor.displayName || actorUsername || actorExtension || '',
+	};
+
+	const user = await getActorUser(actor);
+
+	if (user) {
+		const username = user.username || actorUsername;
+
+		return {
+			...data,
+			name: user.name || user.username || user.freeSwitchExtension || data.name,
+			...(username && { avatarUrl: getUserAvatarURL(username) }),
+		};
+	}
+
+	return {
+		...data,
+		...(actorUsername && { avatarUrl: getUserAvatarURL(actorUsername) }),
+	};
+}
+
+export async function sendVoipPushNotification(callId: IMediaCall['_id'], event: VoipPushNotificationEventType): Promise<void> {
+	const call = await MediaCalls.findOneById(callId);
+	if (!call) {
+		logger.error({ msg: 'Failed to send push notification: Media Call not found', callId });
+		return;
+	}
+
+	if (call.callee.type !== 'user') {
+		logger.error({ msg: 'Failed to send push notification: Invalid Callee Type', callId });
+		return;
+	}
+
+	// If the call was accepted, we don't need to notify when it ends
+	if (call.acceptedAt && event !== 'answer') {
+		return;
+	}
+
+	const type = getPushNotificationType(call);
+	// If the state changed before we had a chance to send the incoming call, skip it altogether
+	if (event === 'new' && type !== 'incoming_call') {
+		return;
+	}
+	if (type === 'incoming_call' && event !== 'new') {
+		return;
+	}
+
+	const { id: userId, username } = call.callee;
+	const caller = await getActorUserData(call.caller);
+
+	metrics.notificationsSent.inc({ notification_type: 'mobile' });
+	await Push.send({
+		useVoipToken: type === 'incoming_call',
+		priority: 10,
+		payload: {
+			host: Meteor.absoluteUrl(),
+			hostName: settings.get<string>('Site_Name'),
+			notificationType: 'voip',
+			type,
+			callId: call._id,
+			caller,
+			username,
+		},
+		userId,
+		notId: PushNotification.getNotificationId(call._id),
+		// We should not send state change notifications to the device where the call was accepted/rejected
+		...(call.callee.contractId && { skipTokenId: call.callee.contractId }),
+	});
+}