Page MenuHomePhabricator
Differential D12202

[native] update `olm` API to allow creating session without OTKs
ClosedPublic
Actions

Authored by kamil on May 23 2024, 4:20 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 9, 8:43 PM
Unknown Object (File)
Wed, Apr 9, 7:24 PM
Unknown Object (File)
Wed, Apr 2, 4:32 AM
Unknown Object (File)
Mar 12 2025, 1:18 PM
Unknown Object (File)
Mar 6 2025, 10:24 PM
Unknown Object (File)
Mar 6 2025, 6:01 AM
Unknown Object (File)
Mar 5 2025, 2:04 PM
Unknown Object (File)
Mar 5 2025, 3:56 AM
View All 73 Files
Subscribers
ashoat

Details

Reviewers
marcin
tomek
Commits
rCOMM84ed5f6bbfd4: [native] update `olm` API to allow creating session without OTKs
Summary

Modifying CryptoModule API.

Depends on D12201

Test Plan

Tested in D12204.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
CryptoTools/
2 lines
2 lines
3 lines
30 lines
NativeModules/
4 lines
35 lines
_generated/
schema/
4 lines

Diff 40575

View Options

native/cpp/CommonCpp/CryptoTools/CryptoModule.h

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import type { SecondaryTunnelbrokerConnection } from './secondary-tunnelbroker-connection.js';
import { tunnnelbrokerURL } from '../facts/tunnelbroker.js'; import { tunnnelbrokerURL } from '../facts/tunnelbroker.js';
import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js'; import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js'; import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js';
import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js'; import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js';
import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js'; import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js';
import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js'; import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js';
import { import {
Show All 38 Lines
const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> = const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> =
React.createContext<?TunnelbrokerContextType>(); React.createContext<?TunnelbrokerContextType>();
type Props = { type Props = {
+children: React.Node, +children: React.Node,
+shouldBeClosed?: boolean, +shouldBeClosed?: boolean,
+onClose?: () => mixed, +onClose?: () => mixed,
+initMessage: ?ConnectionInitializationMessage, +initMessage: ?ConnectionInitializationMessage,
+secondaryTunnelbrokerConnection?: SecondaryTunnelbrokerConnection,
}; };
function createAnonymousInitMessage( function createAnonymousInitMessage(
deviceID: string, deviceID: string,
): AnonymousInitializationMessage { ): AnonymousInitializationMessage {
return ({ return ({
type: 'AnonymousInitializationMessage', type: 'AnonymousInitializationMessage',
deviceID, deviceID,
deviceType: 'mobile', deviceType: 'mobile',
}: AnonymousInitializationMessage); }: AnonymousInitializationMessage);
} }
function TunnelbrokerProvider(props: Props): React.Node { function TunnelbrokerProvider(props: Props): React.Node {
const { const {
children, children,
shouldBeClosed, shouldBeClosed,
onClose, onClose,
initMessage: initMessageProp, initMessage: initMessageProp,
secondaryTunnelbrokerConnection,
} = props; } = props;
const [connected, setConnected] = React.useState(false); const [connected, setConnected] = React.useState(false);
const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set()); const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set());
const socket = React.useRef<?WebSocket>(null); const socket = React.useRef<?WebSocket>(null);
const promises = React.useRef<Promises>({}); const promises = React.useRef<Promises>({});
const heartbeatTimeoutID = React.useRef<?TimeoutID>(); const heartbeatTimeoutID = React.useRef<?TimeoutID>();
const [unauthorizedDeviceID, setUnauthorizedDeviceID] = const [unauthorizedDeviceID, setUnauthorizedDeviceID] =
React.useState<?string>(null); React.useState<?string>(null);
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines React.useEffect(() => {
isSocketActive, isSocketActive,
isAuthorized, isAuthorized,
resetHeartbeatTimeout, resetHeartbeatTimeout,
stopHeartbeatTimeout, stopHeartbeatTimeout,
identityClient, identityClient,
onClose, onClose,
]); ]);
const sendMessageToDeviceRequest: (
request: MessageToDeviceRequest,
) => Promise<void> = React.useCallback(
request => {
return new Promise((resolve, reject) => {
const socketActive = connected && socket.current;
if (!shouldBeClosed && !socketActive) {
throw new Error('Tunnelbroker not connected');
}
promises.current[request.clientMessageID] = {
resolve,
reject,
};
if (socketActive) {
socket.current?.send(JSON.stringify(request));
} else {
secondaryTunnelbrokerConnection?.sendMessage(request);
}
});
},
[connected, secondaryTunnelbrokerConnection, shouldBeClosed],
);
const sendMessage: (message: ClientMessageToDevice) => Promise<void> = const sendMessage: (message: ClientMessageToDevice) => Promise<void> =
React.useCallback( React.useCallback(
(message: ClientMessageToDevice) => { (message: ClientMessageToDevice) => {
if (!connected || !socket.current) {
throw new Error('Tunnelbroker not connected');
}
const clientMessageID = uuid.v4(); const clientMessageID = uuid.v4();
const messageToDevice: MessageToDeviceRequest = { const messageToDevice: MessageToDeviceRequest = {
type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST, type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST,
clientMessageID, clientMessageID,
deviceID: message.deviceID, deviceID: message.deviceID,
payload: message.payload, payload: message.payload,
}; };
return new Promise((resolve, reject) => { return sendMessageToDeviceRequest(messageToDevice);
promises.current[clientMessageID] = {
resolve,
reject,
};
socket.current?.send(JSON.stringify(messageToDevice));
});
}, },
[connected], [sendMessageToDeviceRequest],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onSendMessage(message => {
if (shouldBeClosed) {
// We aren't supposed to be handling it
return;
}
void (async () => {
try {
await sendMessageToDeviceRequest(message);
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
);
} catch (error) {
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
error,
);
}
})();
}),
[
secondaryTunnelbrokerConnection,
sendMessageToDeviceRequest,
shouldBeClosed,
],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onMessageStatus((messageID, error) => {
if (error) {
promises.current[messageID].reject(error);
} else {
promises.current[messageID].resolve();
}
delete promises.current[messageID];
}),
[secondaryTunnelbrokerConnection],
); );
const addListener = React.useCallback( const addListener = React.useCallback(
(listener: TunnelbrokerSocketListener) => { (listener: TunnelbrokerSocketListener) => {
listeners.current.add(listener); listeners.current.add(listener);
}, },
[], [],
); );
Show All 33 Lines
View Options

native/cpp/CommonCpp/CryptoTools/CryptoModule.cpp

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import type { SecondaryTunnelbrokerConnection } from './secondary-tunnelbroker-connection.js';
import { tunnnelbrokerURL } from '../facts/tunnelbroker.js'; import { tunnnelbrokerURL } from '../facts/tunnelbroker.js';
import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js'; import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js'; import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js';
import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js'; import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js';
import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js'; import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js';
import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js'; import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js';
import { import {
Show All 38 Lines
const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> = const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> =
React.createContext<?TunnelbrokerContextType>(); React.createContext<?TunnelbrokerContextType>();
type Props = { type Props = {
+children: React.Node, +children: React.Node,
+shouldBeClosed?: boolean, +shouldBeClosed?: boolean,
+onClose?: () => mixed, +onClose?: () => mixed,
+initMessage: ?ConnectionInitializationMessage, +initMessage: ?ConnectionInitializationMessage,
+secondaryTunnelbrokerConnection?: SecondaryTunnelbrokerConnection,
}; };
function createAnonymousInitMessage( function createAnonymousInitMessage(
deviceID: string, deviceID: string,
): AnonymousInitializationMessage { ): AnonymousInitializationMessage {
return ({ return ({
type: 'AnonymousInitializationMessage', type: 'AnonymousInitializationMessage',
deviceID, deviceID,
deviceType: 'mobile', deviceType: 'mobile',
}: AnonymousInitializationMessage); }: AnonymousInitializationMessage);
} }
function TunnelbrokerProvider(props: Props): React.Node { function TunnelbrokerProvider(props: Props): React.Node {
const { const {
children, children,
shouldBeClosed, shouldBeClosed,
onClose, onClose,
initMessage: initMessageProp, initMessage: initMessageProp,
secondaryTunnelbrokerConnection,
} = props; } = props;
const [connected, setConnected] = React.useState(false); const [connected, setConnected] = React.useState(false);
const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set()); const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set());
const socket = React.useRef<?WebSocket>(null); const socket = React.useRef<?WebSocket>(null);
const promises = React.useRef<Promises>({}); const promises = React.useRef<Promises>({});
const heartbeatTimeoutID = React.useRef<?TimeoutID>(); const heartbeatTimeoutID = React.useRef<?TimeoutID>();
const [unauthorizedDeviceID, setUnauthorizedDeviceID] = const [unauthorizedDeviceID, setUnauthorizedDeviceID] =
React.useState<?string>(null); React.useState<?string>(null);
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines React.useEffect(() => {
isSocketActive, isSocketActive,
isAuthorized, isAuthorized,
resetHeartbeatTimeout, resetHeartbeatTimeout,
stopHeartbeatTimeout, stopHeartbeatTimeout,
identityClient, identityClient,
onClose, onClose,
]); ]);
const sendMessageToDeviceRequest: (
request: MessageToDeviceRequest,
) => Promise<void> = React.useCallback(
request => {
return new Promise((resolve, reject) => {
const socketActive = connected && socket.current;
if (!shouldBeClosed && !socketActive) {
throw new Error('Tunnelbroker not connected');
}
promises.current[request.clientMessageID] = {
resolve,
reject,
};
if (socketActive) {
socket.current?.send(JSON.stringify(request));
} else {
secondaryTunnelbrokerConnection?.sendMessage(request);
}
});
},
[connected, secondaryTunnelbrokerConnection, shouldBeClosed],
);
const sendMessage: (message: ClientMessageToDevice) => Promise<void> = const sendMessage: (message: ClientMessageToDevice) => Promise<void> =
React.useCallback( React.useCallback(
(message: ClientMessageToDevice) => { (message: ClientMessageToDevice) => {
if (!connected || !socket.current) {
throw new Error('Tunnelbroker not connected');
}
const clientMessageID = uuid.v4(); const clientMessageID = uuid.v4();
const messageToDevice: MessageToDeviceRequest = { const messageToDevice: MessageToDeviceRequest = {
type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST, type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST,
clientMessageID, clientMessageID,
deviceID: message.deviceID, deviceID: message.deviceID,
payload: message.payload, payload: message.payload,
}; };
return new Promise((resolve, reject) => { return sendMessageToDeviceRequest(messageToDevice);
promises.current[clientMessageID] = {
resolve,
reject,
};
socket.current?.send(JSON.stringify(messageToDevice));
});
}, },
[connected], [sendMessageToDeviceRequest],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onSendMessage(message => {
if (shouldBeClosed) {
// We aren't supposed to be handling it
return;
}
void (async () => {
try {
await sendMessageToDeviceRequest(message);
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
);
} catch (error) {
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
error,
);
}
})();
}),
[
secondaryTunnelbrokerConnection,
sendMessageToDeviceRequest,
shouldBeClosed,
],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onMessageStatus((messageID, error) => {
if (error) {
promises.current[messageID].reject(error);
} else {
promises.current[messageID].resolve();
}
delete promises.current[messageID];
}),
[secondaryTunnelbrokerConnection],
); );
const addListener = React.useCallback( const addListener = React.useCallback(
(listener: TunnelbrokerSocketListener) => { (listener: TunnelbrokerSocketListener) => {
listeners.current.add(listener); listeners.current.add(listener);
}, },
[], [],
); );
Show All 33 Lines
View Options

native/cpp/CommonCpp/CryptoTools/Session.h

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import type { SecondaryTunnelbrokerConnection } from './secondary-tunnelbroker-connection.js';
import { tunnnelbrokerURL } from '../facts/tunnelbroker.js'; import { tunnnelbrokerURL } from '../facts/tunnelbroker.js';
import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js'; import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js'; import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js';
import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js'; import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js';
import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js'; import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js';
import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js'; import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js';
import { import {
Show All 38 Lines
const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> = const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> =
React.createContext<?TunnelbrokerContextType>(); React.createContext<?TunnelbrokerContextType>();
type Props = { type Props = {
+children: React.Node, +children: React.Node,
+shouldBeClosed?: boolean, +shouldBeClosed?: boolean,
+onClose?: () => mixed, +onClose?: () => mixed,
+initMessage: ?ConnectionInitializationMessage, +initMessage: ?ConnectionInitializationMessage,
+secondaryTunnelbrokerConnection?: SecondaryTunnelbrokerConnection,
}; };
function createAnonymousInitMessage( function createAnonymousInitMessage(
deviceID: string, deviceID: string,
): AnonymousInitializationMessage { ): AnonymousInitializationMessage {
return ({ return ({
type: 'AnonymousInitializationMessage', type: 'AnonymousInitializationMessage',
deviceID, deviceID,
deviceType: 'mobile', deviceType: 'mobile',
}: AnonymousInitializationMessage); }: AnonymousInitializationMessage);
} }
function TunnelbrokerProvider(props: Props): React.Node { function TunnelbrokerProvider(props: Props): React.Node {
const { const {
children, children,
shouldBeClosed, shouldBeClosed,
onClose, onClose,
initMessage: initMessageProp, initMessage: initMessageProp,
secondaryTunnelbrokerConnection,
} = props; } = props;
const [connected, setConnected] = React.useState(false); const [connected, setConnected] = React.useState(false);
const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set()); const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set());
const socket = React.useRef<?WebSocket>(null); const socket = React.useRef<?WebSocket>(null);
const promises = React.useRef<Promises>({}); const promises = React.useRef<Promises>({});
const heartbeatTimeoutID = React.useRef<?TimeoutID>(); const heartbeatTimeoutID = React.useRef<?TimeoutID>();
const [unauthorizedDeviceID, setUnauthorizedDeviceID] = const [unauthorizedDeviceID, setUnauthorizedDeviceID] =
React.useState<?string>(null); React.useState<?string>(null);
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines React.useEffect(() => {
isSocketActive, isSocketActive,
isAuthorized, isAuthorized,
resetHeartbeatTimeout, resetHeartbeatTimeout,
stopHeartbeatTimeout, stopHeartbeatTimeout,
identityClient, identityClient,
onClose, onClose,
]); ]);
const sendMessageToDeviceRequest: (
request: MessageToDeviceRequest,
) => Promise<void> = React.useCallback(
request => {
return new Promise((resolve, reject) => {
const socketActive = connected && socket.current;
if (!shouldBeClosed && !socketActive) {
throw new Error('Tunnelbroker not connected');
}
promises.current[request.clientMessageID] = {
resolve,
reject,
};
if (socketActive) {
socket.current?.send(JSON.stringify(request));
} else {
secondaryTunnelbrokerConnection?.sendMessage(request);
}
});
},
[connected, secondaryTunnelbrokerConnection, shouldBeClosed],
);
const sendMessage: (message: ClientMessageToDevice) => Promise<void> = const sendMessage: (message: ClientMessageToDevice) => Promise<void> =
React.useCallback( React.useCallback(
(message: ClientMessageToDevice) => { (message: ClientMessageToDevice) => {
if (!connected || !socket.current) {
throw new Error('Tunnelbroker not connected');
}
const clientMessageID = uuid.v4(); const clientMessageID = uuid.v4();
const messageToDevice: MessageToDeviceRequest = { const messageToDevice: MessageToDeviceRequest = {
type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST, type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST,
clientMessageID, clientMessageID,
deviceID: message.deviceID, deviceID: message.deviceID,
payload: message.payload, payload: message.payload,
}; };
return new Promise((resolve, reject) => { return sendMessageToDeviceRequest(messageToDevice);
promises.current[clientMessageID] = {
resolve,
reject,
};
socket.current?.send(JSON.stringify(messageToDevice));
});
}, },
[connected], [sendMessageToDeviceRequest],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onSendMessage(message => {
if (shouldBeClosed) {
// We aren't supposed to be handling it
return;
}
void (async () => {
try {
await sendMessageToDeviceRequest(message);
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
);
} catch (error) {
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
error,
);
}
})();
}),
[
secondaryTunnelbrokerConnection,
sendMessageToDeviceRequest,
shouldBeClosed,
],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onMessageStatus((messageID, error) => {
if (error) {
promises.current[messageID].reject(error);
} else {
promises.current[messageID].resolve();
}
delete promises.current[messageID];
}),
[secondaryTunnelbrokerConnection],
); );
const addListener = React.useCallback( const addListener = React.useCallback(
(listener: TunnelbrokerSocketListener) => { (listener: TunnelbrokerSocketListener) => {
listeners.current.add(listener); listeners.current.add(listener);
}, },
[], [],
); );
Show All 33 Lines
View Options

native/cpp/CommonCpp/CryptoTools/Session.cpp

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import type { SecondaryTunnelbrokerConnection } from './secondary-tunnelbroker-connection.js';
import { tunnnelbrokerURL } from '../facts/tunnelbroker.js'; import { tunnnelbrokerURL } from '../facts/tunnelbroker.js';
import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js'; import { peerToPeerMessageHandler } from '../handlers/peer-to-peer-message-handler.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js'; import { tunnelbrokerHeartbeatTimeout } from '../shared/timeouts.js';
import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js'; import type { MessageReceiveConfirmation } from '../types/tunnelbroker/message-receive-confirmation-types.js';
import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js'; import type { MessageSentStatus } from '../types/tunnelbroker/message-to-device-request-status-types.js';
import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js'; import type { MessageToDeviceRequest } from '../types/tunnelbroker/message-to-device-request-types.js';
import { import {
Show All 38 Lines
const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> = const TunnelbrokerContext: React.Context<?TunnelbrokerContextType> =
React.createContext<?TunnelbrokerContextType>(); React.createContext<?TunnelbrokerContextType>();
type Props = { type Props = {
+children: React.Node, +children: React.Node,
+shouldBeClosed?: boolean, +shouldBeClosed?: boolean,
+onClose?: () => mixed, +onClose?: () => mixed,
+initMessage: ?ConnectionInitializationMessage, +initMessage: ?ConnectionInitializationMessage,
+secondaryTunnelbrokerConnection?: SecondaryTunnelbrokerConnection,
}; };
function createAnonymousInitMessage( function createAnonymousInitMessage(
deviceID: string, deviceID: string,
): AnonymousInitializationMessage { ): AnonymousInitializationMessage {
return ({ return ({
type: 'AnonymousInitializationMessage', type: 'AnonymousInitializationMessage',
deviceID, deviceID,
deviceType: 'mobile', deviceType: 'mobile',
}: AnonymousInitializationMessage); }: AnonymousInitializationMessage);
} }
function TunnelbrokerProvider(props: Props): React.Node { function TunnelbrokerProvider(props: Props): React.Node {
const { const {
children, children,
shouldBeClosed, shouldBeClosed,
onClose, onClose,
initMessage: initMessageProp, initMessage: initMessageProp,
secondaryTunnelbrokerConnection,
} = props; } = props;
const [connected, setConnected] = React.useState(false); const [connected, setConnected] = React.useState(false);
const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set()); const listeners = React.useRef<Set<TunnelbrokerSocketListener>>(new Set());
const socket = React.useRef<?WebSocket>(null); const socket = React.useRef<?WebSocket>(null);
const promises = React.useRef<Promises>({}); const promises = React.useRef<Promises>({});
const heartbeatTimeoutID = React.useRef<?TimeoutID>(); const heartbeatTimeoutID = React.useRef<?TimeoutID>();
const [unauthorizedDeviceID, setUnauthorizedDeviceID] = const [unauthorizedDeviceID, setUnauthorizedDeviceID] =
React.useState<?string>(null); React.useState<?string>(null);
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines React.useEffect(() => {
isSocketActive, isSocketActive,
isAuthorized, isAuthorized,
resetHeartbeatTimeout, resetHeartbeatTimeout,
stopHeartbeatTimeout, stopHeartbeatTimeout,
identityClient, identityClient,
onClose, onClose,
]); ]);
const sendMessageToDeviceRequest: (
request: MessageToDeviceRequest,
) => Promise<void> = React.useCallback(
request => {
return new Promise((resolve, reject) => {
const socketActive = connected && socket.current;
if (!shouldBeClosed && !socketActive) {
throw new Error('Tunnelbroker not connected');
}
promises.current[request.clientMessageID] = {
resolve,
reject,
};
if (socketActive) {
socket.current?.send(JSON.stringify(request));
} else {
secondaryTunnelbrokerConnection?.sendMessage(request);
}
});
},
[connected, secondaryTunnelbrokerConnection, shouldBeClosed],
);
const sendMessage: (message: ClientMessageToDevice) => Promise<void> = const sendMessage: (message: ClientMessageToDevice) => Promise<void> =
React.useCallback( React.useCallback(
(message: ClientMessageToDevice) => { (message: ClientMessageToDevice) => {
if (!connected || !socket.current) {
throw new Error('Tunnelbroker not connected');
}
const clientMessageID = uuid.v4(); const clientMessageID = uuid.v4();
const messageToDevice: MessageToDeviceRequest = { const messageToDevice: MessageToDeviceRequest = {
type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST, type: tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE_REQUEST,
clientMessageID, clientMessageID,
deviceID: message.deviceID, deviceID: message.deviceID,
payload: message.payload, payload: message.payload,
}; };
return new Promise((resolve, reject) => { return sendMessageToDeviceRequest(messageToDevice);
promises.current[clientMessageID] = {
resolve,
reject,
};
socket.current?.send(JSON.stringify(messageToDevice));
});
}, },
[connected], [sendMessageToDeviceRequest],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onSendMessage(message => {
if (shouldBeClosed) {
// We aren't supposed to be handling it
return;
}
void (async () => {
try {
await sendMessageToDeviceRequest(message);
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
);
} catch (error) {
secondaryTunnelbrokerConnection.setMessageStatus(
message.clientMessageID,
error,
);
}
})();
}),
[
secondaryTunnelbrokerConnection,
sendMessageToDeviceRequest,
shouldBeClosed,
],
);
React.useEffect(
() =>
secondaryTunnelbrokerConnection?.onMessageStatus((messageID, error) => {
if (error) {
promises.current[messageID].reject(error);
} else {
promises.current[messageID].resolve();
}
delete promises.current[messageID];
}),
[secondaryTunnelbrokerConnection],
); );
const addListener = React.useCallback( const addListener = React.useCallback(
(listener: TunnelbrokerSocketListener) => { (listener: TunnelbrokerSocketListener) => {
listeners.current.add(listener); listeners.current.add(listener);
}, },
[], [],
); );
Show All 33 Lines
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

Loading...
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

Loading...
View Options

native/cpp/CommonCpp/_generated/commJSI-generated.cpp

Loading...
View Options

native/cpp/CommonCpp/_generated/commJSI.h

Loading...
View Options

native/schema/CommCoreModuleSchema.js

Loading...