Page MenuHomePhabricator
Differential D13350

[native][web] use tunnelbroker for online status of thick threaded entries instead of keyserver
ClosedPublic
Actions

Authored by will on Sep 16 2024, 1:36 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 2, 8:26 PM
Unknown Object (File)
Wed, Apr 2, 12:14 PM
Unknown Object (File)
Tue, Apr 1, 10:48 PM
Unknown Object (File)
Tue, Apr 1, 2:27 PM
Unknown Object (File)
Mar 12 2025, 9:21 PM
Unknown Object (File)
Mar 10 2025, 3:39 AM
Unknown Object (File)
Mar 10 2025, 12:09 AM
Unknown Object (File)
Feb 28 2025, 5:46 AM
View All 61 Files
Subscribers
None

Details

Reviewers
marcin
ashoat
tomek
Commits
rCOMM264bde56ab4a: [native][web] use tunnelbroker for online status of thick threaded entries…
Summary

Entry online status shouldn't be decided by keyserver for thick threaded entries. We're changing it to use tunnelbroker status instead

Depends on D13349

Test Plan

console logged on native. Will figure out how to test this on web

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
calendar/
11 lines
web/
calendar/
10 lines

Diff 44256

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,
};