19e52f659f
Skipped 1 file(s) >100MB (GitHub limit): source/__polyfill/04xxx/module_4973.js (118.4 MB)
450 lines
16 KiB
TypeScript
450 lines
16 KiB
TypeScript
// Module ID: 4827
|
|
// Function ID: 4828
|
|
// Name: StreamRTCConnectionStore
|
|
// Dependencies: [1999, 502, 1992, 4828, 4811, 1074, 4830, 38, 4832, 12, 4840, 8012, 573, 4843, 1364, 504, 14099, 2]
|
|
|
|
// Module 4827 (StreamRTCConnectionStore)
|
|
import _modDef12 from "module_12" /* 12 */;
|
|
import _modDef38 from "module_38" /* 38 */;
|
|
import initializeDefault from "initialize" /* 504 */;
|
|
import StreamRTCConnectionDefault from "StreamRTCConnection" /* 4832 */;
|
|
import StreamKeyUtils from "StreamKeyUtils" /* 4840 */;
|
|
import BaseConnectionEvent from "BaseConnectionEvent" /* 4843 */;
|
|
import canSpectateDefault from "canSpectate" /* 14099 */;
|
|
import RunningGameStore from "RunningGameStore" /* 1999 */;
|
|
import AuthenticationStore from "AuthenticationStore" /* 502 */;
|
|
import MediaEngineStore from "MediaEngineStore" /* 1992 */;
|
|
import PresenceStore from "PresenceStore" /* 4828 */;
|
|
import RTCConnectionStore from "RTCConnectionStore" /* 4811 */;
|
|
import Dispatcher from "Dispatcher" /* 573 */;
|
|
|
|
require = fn;
|
|
const Constants = fn(1074);
|
|
({ RTCConnectionQuality: closure_9, StreamLayouts } = Constants);
|
|
const StreamTypes = fn(4830).StreamTypes;
|
|
let dependencyMap = {};
|
|
dependencyMap = {};
|
|
let closure_13 = {};
|
|
const dependencyMap2 = {};
|
|
let closure_15 = {};
|
|
let closure_16 = {};
|
|
let layout = StreamLayouts.PORTRAIT;
|
|
const dependencyMap3 = {};
|
|
const Store = initializeDefault.Store;
|
|
class StreamRTCConnectionStore extends Store {
|
|
}
|
|
const prototype = StreamRTCConnectionStore.prototype;
|
|
prototype["initialize"] = function initialize() {
|
|
this.waitFor(AuthenticationStore, MediaEngineStore, RTCConnectionStore, RunningGameStore);
|
|
};
|
|
prototype["getRTCConnections"] = function getRTCConnections() {
|
|
return closure_18;
|
|
};
|
|
prototype["getAllActiveStreamKeys"] = function getAllActiveStreamKeys() {
|
|
return Object.keys(closure_18);
|
|
};
|
|
prototype["getRTCConnection"] = function getRTCConnection(arg0) {
|
|
return dependencyMap3[arg0];
|
|
};
|
|
prototype["getQuality"] = function getQuality(arg0) {
|
|
if (canSpectateDefault(MediaEngineStore)) {
|
|
if (null != arg0) {
|
|
let quality;
|
|
if (dependencyMap3[arg0] != null) {
|
|
quality = tmp4.quality;
|
|
}
|
|
if (quality == null) {
|
|
quality = constants.UNKNOWN;
|
|
}
|
|
let UNKNOWN = quality;
|
|
}
|
|
return UNKNOWN;
|
|
}
|
|
UNKNOWN = constants.UNKNOWN;
|
|
};
|
|
prototype["getMediaSessionId"] = function getMediaSessionId(arg0) {
|
|
if (null == arg0) {
|
|
return null;
|
|
} else {
|
|
let tmp2;
|
|
if (null != dependencyMap3[arg0]) {
|
|
let mediaSessionId = null;
|
|
if (null != obj) {
|
|
mediaSessionId = obj.getMediaSessionId();
|
|
}
|
|
tmp2 = mediaSessionId;
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
prototype["getRtcConnectionId"] = function getRtcConnectionId(encodeStreamKeyResult) {
|
|
if (null == encodeStreamKeyResult) {
|
|
return null;
|
|
} else {
|
|
let tmp2;
|
|
if (null != dependencyMap3[encodeStreamKeyResult]) {
|
|
let rTCConnectionId = null;
|
|
if (null != obj) {
|
|
rTCConnectionId = obj.getRTCConnectionId();
|
|
}
|
|
tmp2 = rTCConnectionId;
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
prototype["getVideoStats"] = function getVideoStats(arg0) {
|
|
if (null == arg0) {
|
|
return null;
|
|
} else {
|
|
let videoStats = null;
|
|
if (null != dependencyMap3[arg0]) {
|
|
videoStats = obj.getVideoStats();
|
|
}
|
|
return videoStats;
|
|
}
|
|
};
|
|
prototype["getHostname"] = function getHostname(arg0) {
|
|
if (null == arg0) {
|
|
return "";
|
|
} else {
|
|
let str2 = "";
|
|
if (null != dependencyMap3[arg0]) {
|
|
str2 = "";
|
|
if (null != tmp2.hostname) {
|
|
str2 = tmp2.hostname;
|
|
}
|
|
}
|
|
return str2;
|
|
}
|
|
};
|
|
prototype["getRegion"] = function getRegion(arg0) {
|
|
if (null == arg0) {
|
|
return null;
|
|
} else {
|
|
let region = null;
|
|
if (null != dependencyMap3[arg0]) {
|
|
region = obj.getRegion();
|
|
}
|
|
return region;
|
|
}
|
|
};
|
|
prototype["getMaxViewers"] = function getMaxViewers(arg0) {
|
|
if (null == arg0) {
|
|
return null;
|
|
} else {
|
|
let maxViewers = null;
|
|
if (null != dependencyMap3[arg0]) {
|
|
maxViewers = obj.getMaxViewers();
|
|
}
|
|
return maxViewers;
|
|
}
|
|
};
|
|
prototype["getStreamSourceId"] = function getStreamSourceId(arg0) {
|
|
return dependencyMap2[arg0];
|
|
};
|
|
prototype["getLastNonZeroRemoteVideoSinkWantsTime"] = function getLastNonZeroRemoteVideoSinkWantsTime(arg0) {
|
|
return closure_16[arg0];
|
|
};
|
|
prototype["getUserIds"] = function getUserIds(arg0) {
|
|
let userIds;
|
|
if (dependencyMap3[arg0] != null) {
|
|
userIds = obj.getUserIds();
|
|
}
|
|
return userIds;
|
|
};
|
|
prototype["isUserConnected"] = function isUserConnected(arg0, arg1) {
|
|
let isUserConnected;
|
|
if (dependencyMap3[arg0] != null) {
|
|
isUserConnected = obj.getIsUserConnected(arg1);
|
|
}
|
|
return isUserConnected;
|
|
};
|
|
prototype["getSecureFramesState"] = function getSecureFramesState(arg0) {
|
|
let secureFramesState;
|
|
if (dependencyMap3[arg0] != null) {
|
|
secureFramesState = obj.getSecureFramesState();
|
|
}
|
|
return secureFramesState;
|
|
};
|
|
prototype["getSecureFramesRosterMapEntry"] = function getSecureFramesRosterMapEntry(arg0, arg1) {
|
|
let secureFramesRosterMap;
|
|
if (dependencyMap3[arg0] != null) {
|
|
secureFramesRosterMap = obj.getSecureFramesRosterMap();
|
|
}
|
|
value = undefined;
|
|
if (secureFramesRosterMap != null) {
|
|
value = secureFramesRosterMap.get(arg1);
|
|
}
|
|
return value;
|
|
};
|
|
StreamRTCConnectionStore.displayName = "StreamRTCConnectionStore";
|
|
if (MediaEngineStore.isSupported()) {
|
|
function handleRtcAction() {
|
|
return true;
|
|
}
|
|
let obj = {
|
|
CONNECTION_OPEN: function handleConnectionOpen(sessionId) {
|
|
sessionId = sessionId.sessionId;
|
|
const item = _modDef12.forEach(closure_18, (isOwner, arg1) => {
|
|
let str = "receiver-disconnect";
|
|
if (isOwner.isOwner) {
|
|
str = "sender-disconnect";
|
|
}
|
|
isOwner.destroy(str);
|
|
delete tmp3[tmp2];
|
|
delete tmp[tmp2];
|
|
});
|
|
},
|
|
CONNECTION_CLOSED: function handleConnectionClosed() {
|
|
c3 = null;
|
|
const item = _modDef12.forEach(closure_18, (isOwner, arg1) => {
|
|
let str = "receiver-disconnect";
|
|
if (isOwner.isOwner) {
|
|
str = "sender-disconnect";
|
|
}
|
|
isOwner.destroy(str);
|
|
delete tmp3[tmp2];
|
|
delete tmp[tmp2];
|
|
});
|
|
},
|
|
RTC_CONNECTION_STATE: handleRtcAction,
|
|
RTC_CONNECTION_PING: handleRtcAction,
|
|
RTC_CONNECTION_LOSS_RATE: handleRtcAction,
|
|
RTC_CONNECTION_UPDATE_ID: function handleRtcConnectionUpdateId(arg0) {
|
|
const connection = arg0;
|
|
return _modDef12.some(closure_18, (arg0) => arg0 === connection.connection);
|
|
},
|
|
RTC_CONNECTION_SECURE_FRAMES_UPDATE: handleRtcAction,
|
|
RTC_CONNECTION_REMOTE_VIDEO_SINK_WANTS: function handleRtcConnectionRemoteVideoSinkWants(guildId) {
|
|
guildId = guildId.guildId;
|
|
({ context, wants, userId, channelId } = guildId);
|
|
if (null == guildId) {
|
|
let GUILD = StreamTypes.CALL;
|
|
} else {
|
|
GUILD = StreamTypes.GUILD;
|
|
}
|
|
const encodeStreamKeyResult = StreamKeyUtils.encodeStreamKey({ streamType: GUILD, guildId, channelId, ownerId: userId });
|
|
let tmp6 = context === BaseConnectionEvent.MediaEngineContextTypes.STREAM;
|
|
if (tmp6) {
|
|
tmp6 = null != dependencyMap3[encodeStreamKeyResult];
|
|
}
|
|
if (tmp6) {
|
|
const _Object = Object;
|
|
const entries = Object.entries(wants);
|
|
const someResult = entries.some((item) => {
|
|
[tmp, tmp2] = item;
|
|
let tmp3 = "any" !== tmp;
|
|
if (tmp3) {
|
|
tmp3 = 0 !== tmp2;
|
|
}
|
|
return tmp3;
|
|
});
|
|
if (someResult) {
|
|
const _performance = performance;
|
|
closure_16[encodeStreamKeyResult] = performance.now();
|
|
}
|
|
tmp6 = someResult;
|
|
}
|
|
return tmp6;
|
|
},
|
|
STREAM_START: function handleStreamStart(appContext) {
|
|
appContext = appContext.appContext;
|
|
({ pid, nativePickerStyleUsed: importDefault, goLiveModalDurationMs } = appContext);
|
|
({ streamType, guildId, channelId, sourceId, sourcePid, analyticsLocations } = appContext);
|
|
const obj = StreamKeyUtils;
|
|
const encodeStreamKeyResult = obj.encodeStreamKey({ streamType, guildId, channelId, ownerId: AuthenticationStore.getId() });
|
|
closure_11[encodeStreamKeyResult] = { appContext, analyticsLocations };
|
|
const obj2 = { streamType, guildId, channelId, ownerId: AuthenticationStore.getId() };
|
|
const item = _modDef12.forEach(closure_18, (analyticsContext) => {
|
|
analyticsContext = analyticsContext.analyticsContext;
|
|
analyticsContext.setActionContext(appContext);
|
|
const result = analyticsContext.setNativePickerStyleUsed(importDefault);
|
|
if (analyticsContext.isOwner) {
|
|
analyticsContext.trackStart();
|
|
}
|
|
});
|
|
if (null == pid) {
|
|
pid = sourcePid;
|
|
}
|
|
closure_14[encodeStreamKeyResult] = sourceId;
|
|
closure_13[encodeStreamKeyResult] = pid;
|
|
if (null != pid) {
|
|
const gameForPID = RunningGameStore.getGameForPID(pid);
|
|
if (null != gameForPID) {
|
|
({ name: obj3.name, id: obj3.id, exeName: obj3.exe, distributor: obj3.distributor, sku: obj3.sku, gameMetadata: obj3.gameMetadata } = gameForPID);
|
|
dependencyMap[encodeStreamKeyResult] = { name: null, id: null, exe: null, distributor: null, sku: null, gameMetadata: null };
|
|
const obj5 = { name: null, id: null, exe: null, distributor: null, sku: null, gameMetadata: null };
|
|
}
|
|
if (tmp4[encodeStreamKeyResult] != null) {
|
|
let analyticsContext = tmp10.analyticsContext;
|
|
let result = analyticsContext.updateStreamApplication(dependencyMap[encodeStreamKeyResult]);
|
|
}
|
|
} else if (tmp4[encodeStreamKeyResult] != null) {
|
|
const analyticsContext2 = tmp6.analyticsContext;
|
|
const result1 = analyticsContext2.updateStreamApplication(null);
|
|
}
|
|
if (null != goLiveModalDurationMs) {
|
|
closure_15[encodeStreamKeyResult] = goLiveModalDurationMs;
|
|
} else {
|
|
delete tmp2[tmp];
|
|
}
|
|
},
|
|
STREAM_STOP: function handleStreamStop(appContext) {
|
|
appContext = appContext.appContext;
|
|
const streamKey = appContext.streamKey;
|
|
closure_11[streamKey] = { appContext, analyticsLocations: "a" };
|
|
const item = _modDef12.forEach(closure_18, (analyticsContext) => {
|
|
analyticsContext = analyticsContext.analyticsContext;
|
|
analyticsContext.setActionContext(appContext);
|
|
if (analyticsContext.isOwner) {
|
|
analyticsContext.trackEnd();
|
|
}
|
|
});
|
|
closure_14[streamKey] = null;
|
|
closure_13[streamKey] = null;
|
|
delete tmp[tmp2];
|
|
},
|
|
STREAM_CREATE: function handleStreamCreate(arg0) {
|
|
({ streamKey, rtcServerId, viewerIds } = arg0);
|
|
let obj = dependencyMap3[streamKey];
|
|
({ rtcChannelId, region } = arg0);
|
|
let tmp7 = null == obj;
|
|
const tmp3 = dependencyMap3;
|
|
if (tmp7) {
|
|
tmp7 = null != rtcServerId;
|
|
}
|
|
if (tmp7) {
|
|
if (null == closure_13[streamKey]) {
|
|
dependencyMap[streamKey] = null;
|
|
}
|
|
let tmp11 = null == dependencyMap[streamKey];
|
|
if (tmp11) {
|
|
tmp11 = null == dependencyMap2[streamKey];
|
|
}
|
|
if (tmp11) {
|
|
tmp10[streamKey] = tmp4(8012).getStreamerApplication(decodeStreamKeyResult, PresenceStore);
|
|
const tmp4Result = tmp4(8012);
|
|
}
|
|
const obj3 = { streamRegion: region, streamApplication: dependencyMap[streamKey], streamSourceType: null, actionContext: null, numViewers: null, goLiveModalDurationMs: null, analyticsLocations: null };
|
|
let str2 = "unknown";
|
|
if (null != dependencyMap2[streamKey]) {
|
|
if (!tmp4(1364).isPlatformEmbedded) {
|
|
let name;
|
|
if (globalThis.platform != null) {
|
|
name = globalThis.platform.name;
|
|
}
|
|
if ("Chrome" !== name) {
|
|
let name1;
|
|
if (globalThis.platform != null) {
|
|
name1 = globalThis.platform.name;
|
|
}
|
|
if ("Firefox" === name1) {
|
|
let str6 = "screen";
|
|
if ("" !== obj5) {
|
|
str6 = "window";
|
|
}
|
|
str2 = str6;
|
|
} else {
|
|
let name2;
|
|
if (globalThis.platform != null) {
|
|
name2 = globalThis.platform.name;
|
|
}
|
|
str2 = "unknown";
|
|
if ("Safari" === name2) {
|
|
str2 = "window";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
str2 = "tab";
|
|
if (!obj5.startsWith("web-contents-media-stream:")) {
|
|
str2 = "window";
|
|
if (!obj5.startsWith("window:")) {
|
|
str2 = "unknown";
|
|
if (obj5.startsWith("screen:")) {
|
|
str2 = "screen";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
obj3.streamSourceType = str2;
|
|
let appContext;
|
|
if (dependencyMap[streamKey] != null) {
|
|
appContext = tmp20.appContext;
|
|
}
|
|
obj3.actionContext = appContext;
|
|
let num = 0;
|
|
if (null != viewerIds) {
|
|
num = viewerIds.length;
|
|
}
|
|
obj3.numViewers = num;
|
|
obj3.goLiveModalDurationMs = closure_15[streamKey];
|
|
let analyticsLocations;
|
|
if (dependencyMap[streamKey] != null) {
|
|
analyticsLocations = tmp23.analyticsLocations;
|
|
}
|
|
obj3.analyticsLocations = analyticsLocations;
|
|
const streamRTCAnalyticsContext = new tmp4(4832).StreamRTCAnalyticsContext(obj3);
|
|
_modDef38(null != sessionId, "Creating RTCConnection without session.");
|
|
const obj4 = { sessionId, streamKey, serverId: rtcServerId, channelId: rtcChannelId, initialLayout: layout, analyticsContext: streamRTCAnalyticsContext, parentMediaSessionId: RTCConnectionStore.getMediaSessionId() };
|
|
const tmp322 = new StreamRTCConnectionDefault(obj4);
|
|
tmp3[streamKey] = tmp322;
|
|
obj = tmp322;
|
|
}
|
|
delete tmp[tmp2];
|
|
decodeStreamKeyResult = StreamKeyUtils.decodeStreamKey(streamKey);
|
|
const obj7 = Dispatcher;
|
|
obj7.dispatch({ type: "MEDIA_ENGINE_CONNECTION_STATS_HISTORY_RESET", mediaEngineConnectionId: obj.getMediaEngineConnectionId() });
|
|
},
|
|
STREAM_SERVER_UPDATE: function handleStreamServerUpdate(endpoint) {
|
|
if (null == dependencyMap3[endpoint.streamKey]) {
|
|
return false;
|
|
} else {
|
|
obj.connect(endpoint.endpoint, endpoint.token);
|
|
}
|
|
},
|
|
STREAM_UPDATE: function handleStreamUpdate(viewerIds) {
|
|
viewerIds = viewerIds.viewerIds;
|
|
if (null == dependencyMap3[viewerIds.streamKey]) {
|
|
return false;
|
|
} else {
|
|
if (null != viewerIds) {
|
|
const analyticsContext = obj.analyticsContext;
|
|
analyticsContext.trackViewerCount(viewerIds.length);
|
|
}
|
|
obj.streamUpdate(tmp);
|
|
}
|
|
},
|
|
STREAM_DELETE: function handleStreamDelete(arg0) {
|
|
if (null == dependencyMap3[arg0.streamKey]) {
|
|
return false;
|
|
} else {
|
|
const obj3 = { type: "MEDIA_ENGINE_CONNECTION_STATS_HISTORY_RESET", mediaEngineConnectionId: obj.getMediaEngineConnectionId() };
|
|
Dispatcher.dispatch(obj3);
|
|
obj.destroy("stream-end");
|
|
delete tmp[tmp2];
|
|
}
|
|
},
|
|
STREAM_LAYOUT_UPDATE: function handleLayoutUpdate(layout) {
|
|
layout = layout.layout;
|
|
const values = Object.values(closure_18);
|
|
const item = values.forEach((layoutChange) => layoutChange.layoutChange(layout));
|
|
},
|
|
VIDEO_SIZE_UPDATE: function handleVideoSizeUpdate(arg0) {
|
|
({ streamId: require, dimensions: importDefault, zoom: dependencyMap } = arg0);
|
|
const item = _modDef12.forEach(closure_18, (setVideoSize) => {
|
|
if (setVideoSize != null) {
|
|
setVideoSize.setVideoSize(require, importDefault, dependencyMap);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
let obj2 = obj;
|
|
} else {
|
|
obj2 = {};
|
|
}
|
|
const streamRTCConnectionStore = new StreamRTCConnectionStore(Dispatcher, obj2);
|
|
const size = fn(2);
|
|
let result = size.fileFinishedImporting("stores/StreamRTCConnectionStore.tsx");
|
|
|
|
export default streamRTCConnectionStore;
|