Page MenuHomePhabricator
Differential D14471

[native] Use getVideoInfo from MediaModule instead of ffmpeg
ClosedPublic
Actions

Authored by angelika on Thu, Mar 20, 4:34 AM.
Tags
None
Referenced Files
F5093037: D14471.id47482.diff
Sun, Mar 30, 10:56 AM
F5088905: D14471.id47547.diff
Sun, Mar 30, 12:34 AM
Unknown Object (File)
Sat, Mar 29, 10:10 AM
Unknown Object (File)
Fri, Mar 28, 3:00 PM
Unknown Object (File)
Thu, Mar 27, 5:47 PM
Unknown Object (File)
Wed, Mar 26, 1:42 PM
Unknown Object (File)
Wed, Mar 26, 10:13 AM
Unknown Object (File)
Wed, Mar 26, 2:42 AM
View All 14 Files
Subscribers
ashoat
tomek

Details

Reviewers
bartek
Commits
rCOMMe75c93028829: [native] Use getVideoInfo from MediaModule instead of ffmpeg
Summary

https://linear.app/comm/issue/ENG-10314/migrate-comm-app-to-use-new-media-module

Depends on D14470

Test Plan

Try to send a video and see video info

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

angelika created this revision.Thu, Mar 20, 4:34 AM
angelika held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptThu, Mar 20, 4:34 AM
angelika added a child revision: D14472: [android] Implement hasMultipleFrames() function on Android.Thu, Mar 20, 4:38 AM
Harbormaster completed remote builds in B33778: Diff 47482.Thu, Mar 20, 4:52 AM
angelika added inline comments.Thu, Mar 20, 5:01 AM
lib/types/media-types.js
135 ↗(On Diff #47482)

I don't know what format is in the original ffmpeg implementation. It's not documented anywhere and when I've tested it the ffmpeg implementation didn't even return it. Because it's later compared to "mp4" to check if format is correct I'm just returning the file extension. We can run more complicated checks but I think it's good enough for our usecase.

native/media/video-utils.js
261 ↗(On Diff #47482)

The native code can return all those values depending on a platform and a video and they're all h264.

angelika published this revision for review.Thu, Mar 20, 5:55 AM
bartek accepted this revision.Fri, Mar 21, 1:50 AM

Looking at this diff, the thing you did with format seems right

This revision is now accepted and ready to land.Fri, Mar 21, 1:50 AM
ashoat added inline comments.Fri, Mar 21, 10:08 AM
native/media/video-utils.js
261 ↗(On Diff #47482)

If format wasn’t being set by ffmpeg, wouldn’t this check always fail? What happens if the check fails? If it’s not failing, then perhaps it’s worth understanding what ffmpeg is actually returning. Not sure it matters a lot though

262 ↗(On Diff #47482)

Should this and the above one be factored out to the root level to avoid redeclaring on every invocation?

angelika updated this revision to Diff 47547.Tue, Mar 25, 10:01 PM

Rebase

angelika marked an inline comment as done.Tue, Mar 25, 10:12 PM
angelika added inline comments.
native/media/video-utils.js
261 ↗(On Diff #47482)

I checked it and I must have printed a wrong thing because now I can see the format. But still it doesn't tell me much, for mp4 video I've got an array like [mov, mp4, ... a bunch of formats I don't know...]. So I'm leaving it as it is.

Harbormaster completed remote builds in B33829: Diff 47547.Tue, Mar 25, 10:20 PM
Closed by commit rCOMMe75c93028829: [native] Use getVideoInfo from MediaModule instead of ffmpeg (authored by angelika). · Explain WhyThu, Mar 27, 12:21 PM
This revision was automatically updated to reflect the committed changes.
angelika added a commit: rCOMMe75c93028829: [native] Use getVideoInfo from MediaModule instead of ffmpeg.

Revision Contents
Changeset List

PathSize
lib/
types/
8 lines
native/
media/
40 lines
5 lines
utils/
17 lines

Diff 47597

View Options

lib/types/media-types.js

Show All 15 Linesimport {
cookieSelector, cookieSelector,
deviceTokenSelector, deviceTokenSelector,
} from '../selectors/keyserver-selectors.js'; } from '../selectors/keyserver-selectors.js';
import { isLoggedInToKeyserver } from '../selectors/user-selectors.js'; import { isLoggedInToKeyserver } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js'; import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
import type { BaseSocketProps } from '../socket/socket.react.js'; import type { BaseSocketProps } from '../socket/socket.react.js';
import { logInActionSources } from '../types/account-types.js'; import { logInActionSources } from '../types/account-types.js';
import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.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 { useSelector } from '../utils/redux-utils.js';
import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
type Props = { type Props = {
...BaseSocketProps, ...BaseSocketProps,
+socketComponent: React.ComponentType<BaseSocketProps>, +socketComponent: React.ComponentType<BaseSocketProps>,
}; };
const AUTH_RETRY_DELAY_MS = 60000; const AUTH_RETRY_DELAY_MS = 60000;
const CANCELLED_ERROR = 'cancelled'; const CANCELLED_ERROR = 'cancelled';
Show All 13 Linesfunction KeyserverConnectionHandler(props: Props) {
const dataLoaded = useSelector(state => state.dataLoaded); const dataLoaded = useSelector(state => state.dataLoaded);
const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID)); const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
// We have an assumption that we should be always connected to Ashoat's // We have an assumption that we should be always connected to Ashoat's
// keyserver. It is possible that a token which it has is correct, so we can // keyserver. It is possible that a token which it has is correct, so we can
// try to use it. In worst case it is invalid and our push-handler will try // try to use it. In worst case it is invalid and our push-handler will try
// to fix it. // to fix it.
const ashoatKeyserverDeviceToken = useSelector( const ashoatKeyserverDeviceToken = useSelector(
deviceTokenSelector(ashoatKeyserverID), deviceTokenSelector(authoritativeKeyserverID()),
); );
const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken; const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;
const navInfo = useSelector(state => state.navInfo); const navInfo = useSelector(state => state.navInfo);
const calendarFilters = useSelector(state => state.calendarFilters); const calendarFilters = useSelector(state => state.calendarFilters);
const calendarQuery = React.useMemo(() => { const calendarQuery = React.useMemo(() => {
const filters = filterThreadIDsInFilterList( const filters = filterThreadIDsInFilterList(
calendarFilters, calendarFilters,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines const promise = (async () => {
return; return;
} }
console.log( console.log(
`Error while authenticating to keyserver with id ${keyserverID}`, `Error while authenticating to keyserver with id ${keyserverID}`,
e, e,
); );
if (!dataLoaded && keyserverID === ashoatKeyserverID) { if (!dataLoaded && keyserverID === authoritativeKeyserverID()) {
await dispatchActionPromise(logOutActionTypes, callLogOut()); await dispatchActionPromise(logOutActionTypes, callLogOut());
} }
} finally { } finally {
if (!cancelled) { if (!cancelled) {
await sleep(AUTH_RETRY_DELAY_MS); await sleep(AUTH_RETRY_DELAY_MS);
setAuthInProgress(false); setAuthInProgress(false);
} }
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines React.useEffect(() => {
if (authInProgress) { if (authInProgress) {
return; return;
} }
const [, cancel] = performAuth(); const [, cancel] = performAuth();
cancelPendingAuth.current = cancel; cancelPendingAuth.current = cancel;
}, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]); }, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== authoritativeKeyserverID()) {
return null; return null;
} }
return <Socket {...socketProps} />; return <Socket {...socketProps} />;
} }
const Handler: React.ComponentType<Props> = React.memo<Props>( const Handler: React.ComponentType<Props> = React.memo<Props>(
KeyserverConnectionHandler, KeyserverConnectionHandler,
); );
export default Handler; export default Handler;
View Options

native/media/ffmpeg.js

Show All 15 Linesimport {
cookieSelector, cookieSelector,
deviceTokenSelector, deviceTokenSelector,
} from '../selectors/keyserver-selectors.js'; } from '../selectors/keyserver-selectors.js';
import { isLoggedInToKeyserver } from '../selectors/user-selectors.js'; import { isLoggedInToKeyserver } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js'; import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
import type { BaseSocketProps } from '../socket/socket.react.js'; import type { BaseSocketProps } from '../socket/socket.react.js';
import { logInActionSources } from '../types/account-types.js'; import { logInActionSources } from '../types/account-types.js';
import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.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 { useSelector } from '../utils/redux-utils.js';
import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
type Props = { type Props = {
...BaseSocketProps, ...BaseSocketProps,
+socketComponent: React.ComponentType<BaseSocketProps>, +socketComponent: React.ComponentType<BaseSocketProps>,
}; };
const AUTH_RETRY_DELAY_MS = 60000; const AUTH_RETRY_DELAY_MS = 60000;
const CANCELLED_ERROR = 'cancelled'; const CANCELLED_ERROR = 'cancelled';
Show All 13 Linesfunction KeyserverConnectionHandler(props: Props) {
const dataLoaded = useSelector(state => state.dataLoaded); const dataLoaded = useSelector(state => state.dataLoaded);
const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID)); const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
// We have an assumption that we should be always connected to Ashoat's // We have an assumption that we should be always connected to Ashoat's
// keyserver. It is possible that a token which it has is correct, so we can // keyserver. It is possible that a token which it has is correct, so we can
// try to use it. In worst case it is invalid and our push-handler will try // try to use it. In worst case it is invalid and our push-handler will try
// to fix it. // to fix it.
const ashoatKeyserverDeviceToken = useSelector( const ashoatKeyserverDeviceToken = useSelector(
deviceTokenSelector(ashoatKeyserverID), deviceTokenSelector(authoritativeKeyserverID()),
); );
const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken; const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;
const navInfo = useSelector(state => state.navInfo); const navInfo = useSelector(state => state.navInfo);
const calendarFilters = useSelector(state => state.calendarFilters); const calendarFilters = useSelector(state => state.calendarFilters);
const calendarQuery = React.useMemo(() => { const calendarQuery = React.useMemo(() => {
const filters = filterThreadIDsInFilterList( const filters = filterThreadIDsInFilterList(
calendarFilters, calendarFilters,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines const promise = (async () => {
return; return;
} }
console.log( console.log(
`Error while authenticating to keyserver with id ${keyserverID}`, `Error while authenticating to keyserver with id ${keyserverID}`,
e, e,
); );
if (!dataLoaded && keyserverID === ashoatKeyserverID) { if (!dataLoaded && keyserverID === authoritativeKeyserverID()) {
await dispatchActionPromise(logOutActionTypes, callLogOut()); await dispatchActionPromise(logOutActionTypes, callLogOut());
} }
} finally { } finally {
if (!cancelled) { if (!cancelled) {
await sleep(AUTH_RETRY_DELAY_MS); await sleep(AUTH_RETRY_DELAY_MS);
setAuthInProgress(false); setAuthInProgress(false);
} }
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines React.useEffect(() => {
if (authInProgress) { if (authInProgress) {
return; return;
} }
const [, cancel] = performAuth(); const [, cancel] = performAuth();
cancelPendingAuth.current = cancel; cancelPendingAuth.current = cancel;
}, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]); }, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== authoritativeKeyserverID()) {
return null; return null;
} }
return <Socket {...socketProps} />; return <Socket {...socketProps} />;
} }
const Handler: React.ComponentType<Props> = React.memo<Props>( const Handler: React.ComponentType<Props> = React.memo<Props>(
KeyserverConnectionHandler, KeyserverConnectionHandler,
); );
export default Handler; export default Handler;
View Options

native/media/video-utils.js

Show All 15 Linesimport {
cookieSelector, cookieSelector,
deviceTokenSelector, deviceTokenSelector,
} from '../selectors/keyserver-selectors.js'; } from '../selectors/keyserver-selectors.js';
import { isLoggedInToKeyserver } from '../selectors/user-selectors.js'; import { isLoggedInToKeyserver } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js'; import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
import type { BaseSocketProps } from '../socket/socket.react.js'; import type { BaseSocketProps } from '../socket/socket.react.js';
import { logInActionSources } from '../types/account-types.js'; import { logInActionSources } from '../types/account-types.js';
import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.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 { useSelector } from '../utils/redux-utils.js';
import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
type Props = { type Props = {
...BaseSocketProps, ...BaseSocketProps,
+socketComponent: React.ComponentType<BaseSocketProps>, +socketComponent: React.ComponentType<BaseSocketProps>,
}; };
const AUTH_RETRY_DELAY_MS = 60000; const AUTH_RETRY_DELAY_MS = 60000;
const CANCELLED_ERROR = 'cancelled'; const CANCELLED_ERROR = 'cancelled';
Show All 13 Linesfunction KeyserverConnectionHandler(props: Props) {
const dataLoaded = useSelector(state => state.dataLoaded); const dataLoaded = useSelector(state => state.dataLoaded);
const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID)); const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
// We have an assumption that we should be always connected to Ashoat's // We have an assumption that we should be always connected to Ashoat's
// keyserver. It is possible that a token which it has is correct, so we can // keyserver. It is possible that a token which it has is correct, so we can
// try to use it. In worst case it is invalid and our push-handler will try // try to use it. In worst case it is invalid and our push-handler will try
// to fix it. // to fix it.
const ashoatKeyserverDeviceToken = useSelector( const ashoatKeyserverDeviceToken = useSelector(
deviceTokenSelector(ashoatKeyserverID), deviceTokenSelector(authoritativeKeyserverID()),
); );
const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken; const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;
const navInfo = useSelector(state => state.navInfo); const navInfo = useSelector(state => state.navInfo);
const calendarFilters = useSelector(state => state.calendarFilters); const calendarFilters = useSelector(state => state.calendarFilters);
const calendarQuery = React.useMemo(() => { const calendarQuery = React.useMemo(() => {
const filters = filterThreadIDsInFilterList( const filters = filterThreadIDsInFilterList(
calendarFilters, calendarFilters,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines const promise = (async () => {
return; return;
} }
console.log( console.log(
`Error while authenticating to keyserver with id ${keyserverID}`, `Error while authenticating to keyserver with id ${keyserverID}`,
e, e,
); );
if (!dataLoaded && keyserverID === ashoatKeyserverID) { if (!dataLoaded && keyserverID === authoritativeKeyserverID()) {
await dispatchActionPromise(logOutActionTypes, callLogOut()); await dispatchActionPromise(logOutActionTypes, callLogOut());
} }
} finally { } finally {
if (!cancelled) { if (!cancelled) {
await sleep(AUTH_RETRY_DELAY_MS); await sleep(AUTH_RETRY_DELAY_MS);
setAuthInProgress(false); setAuthInProgress(false);
} }
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines React.useEffect(() => {
if (authInProgress) { if (authInProgress) {
return; return;
} }
const [, cancel] = performAuth(); const [, cancel] = performAuth();
cancelPendingAuth.current = cancel; cancelPendingAuth.current = cancel;
}, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]); }, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== authoritativeKeyserverID()) {
return null; return null;
} }
return <Socket {...socketProps} />; return <Socket {...socketProps} />;
} }
const Handler: React.ComponentType<Props> = React.memo<Props>( const Handler: React.ComponentType<Props> = React.memo<Props>(
KeyserverConnectionHandler, KeyserverConnectionHandler,
); );
export default Handler; export default Handler;
View Options

native/utils/media-module.js

Show All 15 Linesimport {
cookieSelector, cookieSelector,
deviceTokenSelector, deviceTokenSelector,
} from '../selectors/keyserver-selectors.js'; } from '../selectors/keyserver-selectors.js';
import { isLoggedInToKeyserver } from '../selectors/user-selectors.js'; import { isLoggedInToKeyserver } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js'; import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
import type { BaseSocketProps } from '../socket/socket.react.js'; import type { BaseSocketProps } from '../socket/socket.react.js';
import { logInActionSources } from '../types/account-types.js'; import { logInActionSources } from '../types/account-types.js';
import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.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 { useSelector } from '../utils/redux-utils.js';
import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
type Props = { type Props = {
...BaseSocketProps, ...BaseSocketProps,
+socketComponent: React.ComponentType<BaseSocketProps>, +socketComponent: React.ComponentType<BaseSocketProps>,
}; };
const AUTH_RETRY_DELAY_MS = 60000; const AUTH_RETRY_DELAY_MS = 60000;
const CANCELLED_ERROR = 'cancelled'; const CANCELLED_ERROR = 'cancelled';
Show All 13 Linesfunction KeyserverConnectionHandler(props: Props) {
const dataLoaded = useSelector(state => state.dataLoaded); const dataLoaded = useSelector(state => state.dataLoaded);
const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID)); const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
// We have an assumption that we should be always connected to Ashoat's // We have an assumption that we should be always connected to Ashoat's
// keyserver. It is possible that a token which it has is correct, so we can // keyserver. It is possible that a token which it has is correct, so we can
// try to use it. In worst case it is invalid and our push-handler will try // try to use it. In worst case it is invalid and our push-handler will try
// to fix it. // to fix it.
const ashoatKeyserverDeviceToken = useSelector( const ashoatKeyserverDeviceToken = useSelector(
deviceTokenSelector(ashoatKeyserverID), deviceTokenSelector(authoritativeKeyserverID()),
); );
const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken; const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;
const navInfo = useSelector(state => state.navInfo); const navInfo = useSelector(state => state.navInfo);
const calendarFilters = useSelector(state => state.calendarFilters); const calendarFilters = useSelector(state => state.calendarFilters);
const calendarQuery = React.useMemo(() => { const calendarQuery = React.useMemo(() => {
const filters = filterThreadIDsInFilterList( const filters = filterThreadIDsInFilterList(
calendarFilters, calendarFilters,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines const promise = (async () => {
return; return;
} }
console.log( console.log(
`Error while authenticating to keyserver with id ${keyserverID}`, `Error while authenticating to keyserver with id ${keyserverID}`,
e, e,
); );
if (!dataLoaded && keyserverID === ashoatKeyserverID) { if (!dataLoaded && keyserverID === authoritativeKeyserverID()) {
await dispatchActionPromise(logOutActionTypes, callLogOut()); await dispatchActionPromise(logOutActionTypes, callLogOut());
} }
} finally { } finally {
if (!cancelled) { if (!cancelled) {
await sleep(AUTH_RETRY_DELAY_MS); await sleep(AUTH_RETRY_DELAY_MS);
setAuthInProgress(false); setAuthInProgress(false);
} }
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines React.useEffect(() => {
if (authInProgress) { if (authInProgress) {
return; return;
} }
const [, cancel] = performAuth(); const [, cancel] = performAuth();
cancelPendingAuth.current = cancel; cancelPendingAuth.current = cancel;
}, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]); }, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== authoritativeKeyserverID()) {
return null; return null;
} }
return <Socket {...socketProps} />; return <Socket {...socketProps} />;
} }
const Handler: React.ComponentType<Props> = React.memo<Props>( const Handler: React.ComponentType<Props> = React.memo<Props>(
KeyserverConnectionHandler, KeyserverConnectionHandler,
); );
export default Handler; export default Handler;