// @flow		// @flow

import invariant from 'invariant';		import invariant from 'invariant';
import _isEqual from 'lodash/fp/isEqual.js';		import _isEqual from 'lodash/fp/isEqual.js';
import * as React from 'react';		import * as React from 'react';

		import { invalidateTunnelbrokerDeviceToken } from '../actions/tunnelbroker-actions.js';
import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';		import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';
import {		import {
useBroadcastDeviceListUpdates,		useBroadcastDeviceListUpdates,
useGetAndUpdateDeviceListsForUsers,		useGetAndUpdateDeviceListsForUsers,
} from '../hooks/peer-list-hooks.js';		} from '../hooks/peer-list-hooks.js';
import {		import {
getAllPeerDevices,		getAllPeerDevices,
getForeignPeerDevices,		getForeignPeerDevices,
Show All 16 Lines	import {
type UserActionP2PMessage,		type UserActionP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';		} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import { getConfig } from '../utils/config.js';		import { getConfig } from '../utils/config.js';
import { getContentSigningKey } from '../utils/crypto-utils.js';		import { getContentSigningKey } from '../utils/crypto-utils.js';
import { getMessageForException } from '../utils/errors.js';		import { getMessageForException } from '../utils/errors.js';
import { hasHigherDeviceID, olmSessionErrors } from '../utils/olm-utils.js';		import { hasHigherDeviceID, olmSessionErrors } from '../utils/olm-utils.js';
import { getClientMessageIDFromTunnelbrokerMessageID } from '../utils/peer-to-peer-communication-utils.js';		import { getClientMessageIDFromTunnelbrokerMessageID } from '../utils/peer-to-peer-communication-utils.js';
import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';		import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
import { useSelector } from '../utils/redux-utils.js';		import { useDispatch, useSelector } from '../utils/redux-utils.js';

// When logout is requested by primary device, logging out of Identity Service		// When logout is requested by primary device, logging out of Identity Service
// is already handled by the primary device		// is already handled by the primary device
const primaryRequestLogoutOptions = Object.freeze({ skipIdentityLogOut: true });		const primaryRequestLogoutOptions = Object.freeze({ skipIdentityLogOut: true });

// handles `peerToPeerMessageTypes.ENCRYPTED_MESSAGE`		// handles `peerToPeerMessageTypes.ENCRYPTED_MESSAGE`
function useHandleOlmMessageToDevice() {		function useHandleOlmMessageToDevice() {
const identityContext = React.useContext(IdentityClientContext);		const identityContext = React.useContext(IdentityClientContext);
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines	) => Promise<void> {
const identityContext = React.useContext(IdentityClientContext);		const identityContext = React.useContext(IdentityClientContext);
invariant(identityContext, 'Identity context should be set');		invariant(identityContext, 'Identity context should be set');
const { identityClient, getAuthMetadata } = identityContext;		const { identityClient, getAuthMetadata } = identityContext;

const foreignPeerDevices = useSelector(getForeignPeerDevices);		const foreignPeerDevices = useSelector(getForeignPeerDevices);
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();		const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const getAndUpdateDeviceListsForUsers = useGetAndUpdateDeviceListsForUsers();		const getAndUpdateDeviceListsForUsers = useGetAndUpdateDeviceListsForUsers();

		const dispatch = useDispatch();

const handleOlmMessageToDevice = useHandleOlmMessageToDevice();		const handleOlmMessageToDevice = useHandleOlmMessageToDevice();

return React.useCallback(		return React.useCallback(
async (message: PeerToPeerMessage, messageID: string) => {		async (message: PeerToPeerMessage, messageID: string) => {
if (message.type === peerToPeerMessageTypes.OUTBOUND_SESSION_CREATION) {		if (message.type === peerToPeerMessageTypes.OUTBOUND_SESSION_CREATION) {
const { senderInfo, encryptedData, sessionVersion } = message;		const { senderInfo, encryptedData, sessionVersion } = message;
const { userID: senderUserID, deviceID: senderDeviceID } = senderInfo;		const { userID: senderUserID, deviceID: senderDeviceID } = senderInfo;

▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines	async (message: PeerToPeerMessage, messageID: string) => {
);		);
} catch (e) {		} catch (e) {
console.log(		console.log(
`Error removing message after processing: ${		`Error removing message after processing: ${
getMessageForException(e) ?? 'unknown error'		getMessageForException(e) ?? 'unknown error'
}`,		}`,
);		);
}		}
		} else if (message.type === peerToPeerMessageTypes.BAD_DEVICE_TOKEN) {
		dispatch({
		type: invalidateTunnelbrokerDeviceToken,
		payload: {
		deviceToken: message.invalidatedToken,
		},
		});
}		}
},		},
[		[
broadcastDeviceListUpdates,		broadcastDeviceListUpdates,
		dispatch,
foreignPeerDevices,		foreignPeerDevices,
getAndUpdateDeviceListsForUsers,		getAndUpdateDeviceListsForUsers,
getAuthMetadata,		getAuthMetadata,
handleOlmMessageToDevice,		handleOlmMessageToDevice,
identityClient,		identityClient,
olmAPI,		olmAPI,
sqliteAPI,		sqliteAPI,
],		],
);		);
}		}

export { usePeerToPeerMessageHandler };		export { usePeerToPeerMessageHandler };

Delete iOS XCTest GitHub Actions CI workflowClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 24925

.github/workflows/ios_xctest.yml

Delete iOS XCTest GitHub Actions CI workflow
ClosedPublic
Actions

Revision Contents
Changeset List