Page MenuHomePhabricator
Differential D11599

[lib/native/web] move recordNotifPermissionAlertActionType into seperate actions file
ClosedPublic
Actions

Authored by ginsu on Apr 9 2024, 10:19 AM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Mar 21, 1:17 AM
Unknown Object (File)
Sat, Mar 15, 8:12 PM
Unknown Object (File)
Wed, Mar 5, 6:24 AM
Unknown Object (File)
Wed, Mar 5, 6:24 AM
Unknown Object (File)
Wed, Mar 5, 6:24 AM
Unknown Object (File)
Wed, Mar 5, 6:24 AM
Unknown Object (File)
Wed, Mar 5, 6:24 AM
Unknown Object (File)
Fri, Feb 28, 10:45 PM
View All 66 Files
Subscribers
ashoat
tomek

Details

Reviewers
atul
inka
Commits
rCOMMa9c0d8c0fcc9: [lib/native/web] move recordNotifPermissionAlertActionType into seperate…
Summary

Move diff. Took a second to move recordNotifPermissionAlertActionType into its own actions file to ensure + maintain consistency within our codebase

Depends on D11569

Test Plan

flow

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

ginsu created this revision.Apr 9 2024, 10:19 AM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptApr 9 2024, 10:19 AM
ginsu edited the summary of this revision. (Show Details)Apr 9 2024, 10:20 AM
ginsu added reviewers: atul, inka.
ginsu added a parent revision: D11569: [lib/native/web] introduce CONNECT_FARCASTER alert type.
Harbormaster completed remote builds in B28099: Diff 38954.Apr 9 2024, 10:35 AM
ginsu requested review of this revision.Apr 9 2024, 10:35 AM
ginsu added a child revision: D11600: [lib/native/web] refactor recordNotifPermissionAlertActionType to recordAlertActionType.Apr 9 2024, 12:06 PM
atul accepted this revision.Apr 10 2024, 10:05 AM
This revision is now accepted and ready to land.Apr 10 2024, 10:05 AM
ginsu updated this revision to Diff 39012.Apr 10 2024, 12:35 PM

rebase

Harbormaster completed remote builds in B28144: Diff 39012.Apr 10 2024, 1:08 PM
Closed by commit rCOMMa9c0d8c0fcc9: [lib/native/web] move recordNotifPermissionAlertActionType into seperate… (authored by ginsu). · Explain WhyApr 10 2024, 1:32 PM
This revision was automatically updated to reflect the committed changes.
ginsu added a commit: rCOMMa9c0d8c0fcc9: [lib/native/web] move recordNotifPermissionAlertActionType into seperate….

Revision Contents
Changeset List

PathSize
lib/
actions/
5 lines
reducers/
2 lines
utils/
4 lines
native/
push/
6 lines
web/
push-notif/
6 lines

Diff 38954

View Options

lib/actions/alert-actions.js

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [
identityClient, identityClient,
primaryDeviceRequestedLogOut, primaryDeviceRequestedLogOut,
], ],
); );
} }
function usePeerToPeerMessageHandler(): ( function usePeerToPeerMessageHandler(): (
message: PeerToPeerMessage, message: PeerToPeerMessage,
messageID: string,
) => Promise<void> { ) => Promise<void> {
const { olmAPI, sqliteAPI } = getConfig(); const { olmAPI, sqliteAPI } = getConfig();
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 handleOlmMessageToDevice = useHandleOlmMessageToDevice(); const handleOlmMessageToDevice = useHandleOlmMessageToDevice();
return React.useCallback( return React.useCallback(
async (message: PeerToPeerMessage, messageID: string) => { async (message: PeerToPeerMessage) => {
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;
let deviceKeys: ?DeviceOlmInboundKeys = null; let deviceKeys: ?DeviceOlmInboundKeys = null;
try { try {
const { keys } = const { keys } =
await identityClient.getInboundKeysForUser(senderUserID); await identityClient.getInboundKeysForUser(senderUserID);
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines async (message: PeerToPeerMessage) => {
`${senderDeviceID}: ${e.message}, ` + `${senderDeviceID}: ${e.message}, ` +
`session version: ${sessionVersion}`, `session version: ${sessionVersion}`,
); );
} }
} }
} else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) { } else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) {
try { try {
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const decrypted = await olmAPI.decryptSequentialAndPersist( const decrypted = await olmAPI.decrypt(
message.encryptedData, message.encryptedData,
message.senderInfo.deviceID, message.senderInfo.deviceID,
messageID,
); );
console.log( console.log(
'Decrypted message from device ' + 'Decrypted message from device ' +
`${message.senderInfo.deviceID}: ${decrypted}`, `${message.senderInfo.deviceID}: ${decrypted}`,
); );
try { try {
await handleOlmMessageToDevice(decrypted, message.senderInfo); await handleOlmMessageToDevice(decrypted, message.senderInfo);
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines
View Options

lib/reducers/alert-reducer.js

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [
identityClient, identityClient,
primaryDeviceRequestedLogOut, primaryDeviceRequestedLogOut,
], ],
); );
} }
function usePeerToPeerMessageHandler(): ( function usePeerToPeerMessageHandler(): (
message: PeerToPeerMessage, message: PeerToPeerMessage,
messageID: string,
) => Promise<void> { ) => Promise<void> {
const { olmAPI, sqliteAPI } = getConfig(); const { olmAPI, sqliteAPI } = getConfig();
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 handleOlmMessageToDevice = useHandleOlmMessageToDevice(); const handleOlmMessageToDevice = useHandleOlmMessageToDevice();
return React.useCallback( return React.useCallback(
async (message: PeerToPeerMessage, messageID: string) => { async (message: PeerToPeerMessage) => {
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;
let deviceKeys: ?DeviceOlmInboundKeys = null; let deviceKeys: ?DeviceOlmInboundKeys = null;
try { try {
const { keys } = const { keys } =
await identityClient.getInboundKeysForUser(senderUserID); await identityClient.getInboundKeysForUser(senderUserID);
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines async (message: PeerToPeerMessage) => {
`${senderDeviceID}: ${e.message}, ` + `${senderDeviceID}: ${e.message}, ` +
`session version: ${sessionVersion}`, `session version: ${sessionVersion}`,
); );
} }
} }
} else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) { } else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) {
try { try {
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const decrypted = await olmAPI.decryptSequentialAndPersist( const decrypted = await olmAPI.decrypt(
message.encryptedData, message.encryptedData,
message.senderInfo.deviceID, message.senderInfo.deviceID,
messageID,
); );
console.log( console.log(
'Decrypted message from device ' + 'Decrypted message from device ' +
`${message.senderInfo.deviceID}: ${decrypted}`, `${message.senderInfo.deviceID}: ${decrypted}`,
); );
try { try {
await handleOlmMessageToDevice(decrypted, message.senderInfo); await handleOlmMessageToDevice(decrypted, message.senderInfo);
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines
View Options

lib/utils/push-alerts.js

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [
identityClient, identityClient,
primaryDeviceRequestedLogOut, primaryDeviceRequestedLogOut,
], ],
); );
} }
function usePeerToPeerMessageHandler(): ( function usePeerToPeerMessageHandler(): (
message: PeerToPeerMessage, message: PeerToPeerMessage,
messageID: string,
) => Promise<void> { ) => Promise<void> {
const { olmAPI, sqliteAPI } = getConfig(); const { olmAPI, sqliteAPI } = getConfig();
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 handleOlmMessageToDevice = useHandleOlmMessageToDevice(); const handleOlmMessageToDevice = useHandleOlmMessageToDevice();
return React.useCallback( return React.useCallback(
async (message: PeerToPeerMessage, messageID: string) => { async (message: PeerToPeerMessage) => {
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;
let deviceKeys: ?DeviceOlmInboundKeys = null; let deviceKeys: ?DeviceOlmInboundKeys = null;
try { try {
const { keys } = const { keys } =
await identityClient.getInboundKeysForUser(senderUserID); await identityClient.getInboundKeysForUser(senderUserID);
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines async (message: PeerToPeerMessage) => {
`${senderDeviceID}: ${e.message}, ` + `${senderDeviceID}: ${e.message}, ` +
`session version: ${sessionVersion}`, `session version: ${sessionVersion}`,
); );
} }
} }
} else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) { } else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) {
try { try {
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const decrypted = await olmAPI.decryptSequentialAndPersist( const decrypted = await olmAPI.decrypt(
message.encryptedData, message.encryptedData,
message.senderInfo.deviceID, message.senderInfo.deviceID,
messageID,
); );
console.log( console.log(
'Decrypted message from device ' + 'Decrypted message from device ' +
`${message.senderInfo.deviceID}: ${decrypted}`, `${message.senderInfo.deviceID}: ${decrypted}`,
); );
try { try {
await handleOlmMessageToDevice(decrypted, message.senderInfo); await handleOlmMessageToDevice(decrypted, message.senderInfo);
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines
View Options

native/push/push-handler.react.js

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines [
identityClient, identityClient,
primaryDeviceRequestedLogOut, primaryDeviceRequestedLogOut,
], ],
); );
} }
function usePeerToPeerMessageHandler(): ( function usePeerToPeerMessageHandler(): (
message: PeerToPeerMessage, message: PeerToPeerMessage,
messageID: string,
) => Promise<void> { ) => Promise<void> {
const { olmAPI, sqliteAPI } = getConfig(); const { olmAPI, sqliteAPI } = getConfig();
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 handleOlmMessageToDevice = useHandleOlmMessageToDevice(); const handleOlmMessageToDevice = useHandleOlmMessageToDevice();
return React.useCallback( return React.useCallback(
async (message: PeerToPeerMessage, messageID: string) => { async (message: PeerToPeerMessage) => {
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;
let deviceKeys: ?DeviceOlmInboundKeys = null; let deviceKeys: ?DeviceOlmInboundKeys = null;
try { try {
const { keys } = const { keys } =
await identityClient.getInboundKeysForUser(senderUserID); await identityClient.getInboundKeysForUser(senderUserID);
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines async (message: PeerToPeerMessage) => {
`${senderDeviceID}: ${e.message}, ` + `${senderDeviceID}: ${e.message}, ` +
`session version: ${sessionVersion}`, `session version: ${sessionVersion}`,
); );
} }
} }
} else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) { } else if (message.type === peerToPeerMessageTypes.ENCRYPTED_MESSAGE) {
try { try {
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const decrypted = await olmAPI.decryptSequentialAndPersist( const decrypted = await olmAPI.decrypt(
message.encryptedData, message.encryptedData,
message.senderInfo.deviceID, message.senderInfo.deviceID,
messageID,
); );
console.log( console.log(
'Decrypted message from device ' + 'Decrypted message from device ' +
`${message.senderInfo.deviceID}: ${decrypted}`, `${message.senderInfo.deviceID}: ${decrypted}`,
); );
try { try {
await handleOlmMessageToDevice(decrypted, message.senderInfo); await handleOlmMessageToDevice(decrypted, message.senderInfo);
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines
View Options

web/push-notif/push-notifs-handler.js

Loading...