[sqlite] Implement C++ code for native to get sqlite thread activity entries
ClosedPublic
Actions

Authored by will on Apr 9 2024, 10:53 PM.

Details

Reviewers

atul
kamil

Commits

rCOMM9567929ea151: [sqlite] Implement C++ code for native to get sqlite thread activity entries

Summary

This implements C++ code to allow native to get sqlite thread activity entries

Depends on D11584

Test Plan

Ran the following code and console logged the thread activity store successfully:

let data = await commCoreModule.getClientDBStore();
console.log(data.threadActivityEntries);

await commCoreModule.processThreadActivityStoreOperations([
  {
    type: 'replace_thread_activity_entry',
    payload: {
      id: 'test_A_id',
      threadActivityStoreEntry: JSON.stringify({
        lastNavigatedTo: 1,
        lastPruned: 2,
      }),
    },
  },
  {
    type: 'remove_all_thread_activity_entries',
  },
  {
    type: 'replace_thread_activity_entry',
    payload: {
      id: 'test_B_id',
      threadActivityStoreEntry: JSON.stringify({
        lastNavigatedTo: 3,
        lastPruned: 4,
      }),
    },
  },
  {
    type: 'replace_thread_activity_entry',
    payload: {
      id: 'test_C_id',
      threadActivityStoreEntry: JSON.stringify({
        lastNavigatedTo: 5,
        lastPruned: 6,
      }),
    },
  },
  {
    type: 'remove_thread_activity_entries',
    payload: {
      ids: ['test_B_id'],
    },
  },
]);

data = await commCoreModule.getClientDBStore();
console.log(data.threadActivityEntries);

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

will created this revision.Apr 9 2024, 10:53 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptApr 9 2024, 10:53 PM

will edited the test plan for this revision. (Show Details)Apr 9 2024, 10:54 PM

will edited the test plan for this revision. (Show Details)

will edited the summary of this revision. (Show Details)

will added a parent revision: D11584: [sqlite/native] Make C++ thread activity sqlite ops available to native.

will added a child revision: D11615: [sqlite] Implement processing thread activity on web worker.Apr 9 2024, 10:59 PM

Harbormaster completed remote builds in B28117: Diff 38973.Apr 9 2024, 11:10 PM

will requested review of this revision.Apr 9 2024, 11:10 PM

kamil accepted this revision.Apr 10 2024, 5:40 AM

This revision is now accepted and ready to land.Apr 10 2024, 5:40 AM

thread_activity_store_entry => threadActivityStoreEntry

Harbormaster completed remote builds in B28255: Diff 39166.Apr 16 2024, 9:14 PM

Closed by commit rCOMM9567929ea151: [sqlite] Implement C++ code for native to get sqlite thread activity entries (authored by will). · Explain WhyApr 19 2024, 1:08 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM9567929ea151: [sqlite] Implement C++ code for native to get sqlite thread activity entries.

Revision Contents
Changeset List

Path

Size

lib/

types/

store-ops-types.js

2 lines

native/

cpp/

CommonCpp/

NativeModules/

CommCoreModule.cpp

16 lines

PersistentStorageUtilities/

DataStores/

ThreadActivityStore.cpp

18 lines

web/

shared-worker/

worker/

process-operations.js

1 line

Diff 39320

View Options

lib/types/store-ops-types.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/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

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/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadActivityStore.cpp

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/shared-worker/worker/process-operations.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,
				};

[sqlite] Implement C++ code for native to get sqlite thread activity entriesClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 39320

lib/types/store-ops-types.js

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadActivityStore.cpp

web/shared-worker/worker/process-operations.js

[sqlite] Implement C++ code for native to get sqlite thread activity entries
ClosedPublic
Actions

Revision Contents
Changeset List