Page MenuHomePhabricator
Differential D13344

[lib][native][web] send encrypted dms on web and native when editing entries on thick threads
ClosedPublic
Actions

Authored by will on Sep 16 2024, 1:24 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 2, 9:09 AM
Unknown Object (File)
Wed, Apr 2, 9:01 AM
Unknown Object (File)
Wed, Apr 2, 3:58 AM
Unknown Object (File)
Tue, Apr 1, 8:25 PM
Unknown Object (File)
Tue, Apr 1, 8:24 PM
Unknown Object (File)
Tue, Apr 1, 5:21 PM
Unknown Object (File)
Mar 17 2025, 9:14 PM
Unknown Object (File)
Mar 11 2025, 7:08 AM
View All Files
Subscribers
None

Details

Reviewers
marcin
ashoat
tomek
kamil
Commits
rCOMM33107c27386d: [lib][native][web] send encrypted dms on web and native when editing entries on…
Summary

This uses e2ee dm ops with the save entry hook instead of the keyserver when sending entries in a thick thread

Depends on D13343

Test Plan

two accounts each with a web app and iOS simulator. Ensured on all four platforms/devices that editing entries showed between the four platforms when sending entries in a thick thread.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

will created this revision.Sep 16 2024, 1:24 AM
will added a child revision: D13345: [lib][native][web] send encrypted dms on web and native when deleting on thick threads.Sep 16 2024, 1:39 AM
Harbormaster completed remote builds in B31626: Diff 44198.Sep 16 2024, 1:50 AM
will requested review of this revision.Sep 16 2024, 1:50 AM
tomek accepted this revision.Sep 16 2024, 5:34 AM
tomek added a reviewer: kamil.
kamil accepted this revision.Sep 16 2024, 8:19 AM
kamil added inline comments.
lib/actions/entry-actions.js
364 ↗(On Diff #44198)
This revision is now accepted and ready to land.Sep 16 2024, 8:19 AM
will updated this revision to Diff 44238.Sep 16 2024, 1:35 PM

review feedback

Harbormaster failed remote builds in B31650: Diff 44238!Sep 16 2024, 1:52 PM
Harbormaster completed remote builds in B31650: Diff 44238.Sep 16 2024, 1:58 PM
will updated this revision to Diff 44241.Sep 16 2024, 2:00 PM

rebase

Harbormaster completed remote builds in B31653: Diff 44241.Sep 16 2024, 2:21 PM
Closed by commit rCOMM33107c27386d: [lib][native][web] send encrypted dms on web and native when editing entries on… (authored by will). · Explain WhySep 16 2024, 2:27 PM
This revision was automatically updated to reflect the committed changes.
will added a commit: rCOMM33107c27386d: [lib][native][web] send encrypted dms on web and native when editing entries on….

Revision Contents
Changeset List

PathSize
lib/
actions/
86 lines
native/
calendar/
21 lines
web/
calendar/
21 lines

Diff 44250

View Options

lib/actions/entry-actions.js

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};
View Options

native/calendar/entry.react.js

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};
View Options

web/calendar/entry.react.js

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};