mirror of
https://github.com/Eaglercraft-Archive/Eaglercraftx-1.8.8-src.git
synced 2025-06-27 18:38:14 -05:00
Update #44 - WebAssembly GC support, fix more WebRTC bugs
This commit is contained in:
lax1dude
651
sources/wasm-gc-teavm/js/platformWebRTC.js
Normal file
651
sources/wasm-gc-teavm/js/platformWebRTC.js
Normal file
@ -0,0 +1,651 @@
|
||||
/*
|
||||
* Copyright (c) 2024 lax1dude, ayunami2000. All Rights Reserved.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
||||
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
const READYSTATE_INIT_FAILED = -2;
|
||||
const READYSTATE_FAILED = -1;
|
||||
const READYSTATE_DISCONNECTED = 0;
|
||||
const READYSTATE_CONNECTING = 1;
|
||||
const READYSTATE_CONNECTED = 2;
|
||||
|
||||
const EVENT_WEBRTC_ICE = 0;
|
||||
const EVENT_WEBRTC_DESC = 1;
|
||||
const EVENT_WEBRTC_OPEN = 2;
|
||||
const EVENT_WEBRTC_PACKET = 3;
|
||||
const EVENT_WEBRTC_CLOSE = 4;
|
||||
|
||||
const platfWebRTCName = "platformWebRTC";
|
||||
|
||||
/**
|
||||
* @typedef {{
|
||||
* peerId:string,
|
||||
* peerConnection:!RTCPeerConnection,
|
||||
* dataChannel:RTCDataChannel,
|
||||
* ipcChannel:(string|null),
|
||||
* pushEvent:function(number,*),
|
||||
* disconnect:function()
|
||||
* }}
|
||||
*/
|
||||
let LANPeerInternal;
|
||||
|
||||
function initializePlatfWebRTC(webrtcImports) {
|
||||
|
||||
const clientLANPacketBuffer = new EaglerLinkedQueue();
|
||||
|
||||
let lanClient;
|
||||
lanClient = {
|
||||
iceServers: [],
|
||||
/** @type {RTCPeerConnection|null} */
|
||||
peerConnection: null,
|
||||
/** @type {RTCDataChannel|null} */
|
||||
dataChannel: null,
|
||||
readyState: READYSTATE_CONNECTING,
|
||||
/** @type {string|null} */
|
||||
iceCandidate: null,
|
||||
/** @type {string|null} */
|
||||
description: null,
|
||||
dataChannelOpen: false,
|
||||
dataChannelClosed: true,
|
||||
disconnect: function(quiet) {
|
||||
if (lanClient.dataChannel) {
|
||||
try {
|
||||
lanClient.dataChannel.close();
|
||||
} catch (t) {
|
||||
}
|
||||
lanClient.dataChannel = null;
|
||||
}
|
||||
if (lanClient.peerConnection) {
|
||||
try {
|
||||
lanClient.peerConnection.close();
|
||||
} catch (t) {
|
||||
}
|
||||
lanClient.peerConnection = null;
|
||||
}
|
||||
if (!quiet) lanClient.dataChannelClosed = true;
|
||||
lanClient.readyState = READYSTATE_DISCONNECTED;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {boolean}
|
||||
*/
|
||||
webrtcImports["supported"] = function() {
|
||||
return typeof RTCPeerConnection !== "undefined";
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {number}
|
||||
*/
|
||||
webrtcImports["clientLANReadyState"] = function() {
|
||||
return lanClient.readyState;
|
||||
};
|
||||
|
||||
webrtcImports["clientLANCloseConnection"] = function() {
|
||||
lanClient.disconnect(false);
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {!Uint8Array} pkt
|
||||
*/
|
||||
webrtcImports["clientLANSendPacket"] = function(pkt) {
|
||||
if (lanClient.dataChannel !== null && "open" === lanClient.dataChannel.readyState) {
|
||||
try {
|
||||
lanClient.dataChannel.send(pkt);
|
||||
} catch (e) {
|
||||
lanClient.disconnect(false);
|
||||
}
|
||||
}else {
|
||||
lanClient.disconnect(false);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {Uint8Array}
|
||||
*/
|
||||
webrtcImports["clientLANReadPacket"] = function() {
|
||||
const ret = clientLANPacketBuffer.shift();
|
||||
return ret ? new Uint8Array(ret["data"]) : null;
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {number}
|
||||
*/
|
||||
webrtcImports["clientLANAvailable"] = function() {
|
||||
return clientLANPacketBuffer.getLength();
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {!Array<string>} servers
|
||||
*/
|
||||
webrtcImports["clientLANSetICEServersAndConnect"] = function(servers) {
|
||||
lanClient.iceServers.length = 0;
|
||||
for (let url of servers) {
|
||||
let etr = url.split(";");
|
||||
if(etr.length === 1) {
|
||||
lanClient.iceServers.push({
|
||||
urls: etr[0]
|
||||
});
|
||||
}else if(etr.length === 3) {
|
||||
lanClient.iceServers.push({
|
||||
urls: etr[0],
|
||||
username: etr[1],
|
||||
credential: etr[2]
|
||||
});
|
||||
}
|
||||
}
|
||||
if(lanClient.readyState === READYSTATE_CONNECTED || lanClient.readyState === READYSTATE_CONNECTING) {
|
||||
lanClient.disconnect(true);
|
||||
}
|
||||
try {
|
||||
if (lanClient.dataChannel) {
|
||||
try {
|
||||
lanClient.dataChannel.close();
|
||||
} catch (t) {
|
||||
}
|
||||
lanClient.dataChannel = null;
|
||||
}
|
||||
if (lanClient.peerConnection) {
|
||||
try {
|
||||
lanClient.peerConnection.close();
|
||||
} catch (t) {
|
||||
}
|
||||
}
|
||||
lanClient.peerConnection = new RTCPeerConnection({
|
||||
iceServers: lanClient.iceServers,
|
||||
optional: [
|
||||
{
|
||||
DtlsSrtpKeyAgreement: true
|
||||
}
|
||||
]
|
||||
});
|
||||
lanClient.readyState = READYSTATE_CONNECTING;
|
||||
} catch (/** Error */ t) {
|
||||
eagStackTrace(ERROR, "Could not create LAN client RTCPeerConnection!", t);
|
||||
lanClient.readyState = READYSTATE_INIT_FAILED;
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const iceCandidates = [];
|
||||
|
||||
lanClient.peerConnection.addEventListener("icecandidate", /** @type {function(Event)} */ ((/** !RTCPeerConnectionIceEvent */ evt) => {
|
||||
if(evt.candidate) {
|
||||
if(iceCandidates.length === 0) {
|
||||
const candidateState = [0, 0];
|
||||
const runnable = () => {
|
||||
if(lanClient.peerConnection !== null && lanClient.peerConnection.connectionState !== "disconnected") {
|
||||
const trial = ++candidateState[1];
|
||||
if(candidateState[0] !== iceCandidates.length && trial < 3) {
|
||||
candidateState[0] = iceCandidates.length;
|
||||
setTimeout(runnable, 2000);
|
||||
return;
|
||||
}
|
||||
lanClient.iceCandidate = JSON.stringify(iceCandidates);
|
||||
iceCandidates.length = 0;
|
||||
}
|
||||
};
|
||||
setTimeout(runnable, 2000);
|
||||
}
|
||||
iceCandidates.push({
|
||||
"sdpMLineIndex": evt.candidate.sdpMLineIndex,
|
||||
"candidate": evt.candidate.candidate
|
||||
});
|
||||
}
|
||||
}));
|
||||
|
||||
lanClient.dataChannel = lanClient.peerConnection.createDataChannel("lan");
|
||||
lanClient.dataChannel.binaryType = "arraybuffer";
|
||||
|
||||
let evtHandler;
|
||||
evtHandler = () => {
|
||||
if (iceCandidates.length > 0) {
|
||||
setTimeout(evtHandler, 10);
|
||||
return;
|
||||
}
|
||||
lanClient.dataChannelClosed = false;
|
||||
lanClient.dataChannelOpen = true;
|
||||
};
|
||||
|
||||
lanClient.dataChannel.addEventListener("open", evtHandler);
|
||||
|
||||
lanClient.dataChannel.addEventListener("message", /** @type {function(Event)} */ ((/** MessageEvent */ evt) => {
|
||||
clientLANPacketBuffer.push({ "data": evt.data, "_next": null });
|
||||
}));
|
||||
|
||||
lanClient.peerConnection.createOffer().then((/** !RTCSessionDescription */ desc) => {
|
||||
lanClient.peerConnection.setLocalDescription(desc).then(() => {
|
||||
lanClient.description = JSON.stringify(desc);
|
||||
}).catch((err) => {
|
||||
eagError("Failed to set local description! {}", /** @type {string} */ (err.message));
|
||||
lanClient.readyState = READYSTATE_FAILED;
|
||||
lanClient.disconnect(false);
|
||||
});
|
||||
}).catch((err) => {
|
||||
eagError("Failed to set create offer! {}", /** @type {string} */ (err.message));
|
||||
lanClient.readyState = READYSTATE_FAILED;
|
||||
lanClient.disconnect(false);
|
||||
});
|
||||
|
||||
lanClient.peerConnection.addEventListener("connectionstatechange", /** @type {function(Event)} */ ((evt) => {
|
||||
var connectionState = lanClient.peerConnection.connectionState;
|
||||
if ("disconnected" === connectionState) {
|
||||
lanClient.disconnect(false);
|
||||
} else if ("connected" === connectionState) {
|
||||
lanClient.readyState = READYSTATE_CONNECTED;
|
||||
} else if ("failed" === connectionState) {
|
||||
lanClient.readyState = READYSTATE_FAILED;
|
||||
lanClient.disconnect(false);
|
||||
}
|
||||
}));
|
||||
} catch (t) {
|
||||
if (lanClient.dataChannel) {
|
||||
try {
|
||||
lanClient.dataChannel.close();
|
||||
} catch (tt) {
|
||||
}
|
||||
lanClient.dataChannel = null;
|
||||
}
|
||||
if (lanClient.peerConnection) {
|
||||
try {
|
||||
lanClient.peerConnection.close();
|
||||
} catch (tt) {
|
||||
}
|
||||
lanClient.peerConnection = null;
|
||||
}
|
||||
eagStackTrace(ERROR, "Could not create LAN client RTCDataChannel!", t);
|
||||
lanClient.readyState = READYSTATE_INIT_FAILED;
|
||||
}
|
||||
};
|
||||
|
||||
webrtcImports["clearLANClientState"] = function() {
|
||||
lanClient.iceCandidate = lanClient.description = null;
|
||||
lanClient.dataChannelOpen = false;
|
||||
lanClient.dataChannelClosed = true;
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {string|null}
|
||||
*/
|
||||
webrtcImports["clientLANAwaitICECandidate"] = function() {
|
||||
if (lanClient.iceCandidate === null) {
|
||||
return null;
|
||||
}
|
||||
const ret = lanClient.iceCandidate;
|
||||
lanClient.iceCandidate = null;
|
||||
return ret;
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {string|null}
|
||||
*/
|
||||
webrtcImports["clientLANAwaitDescription"] = function() {
|
||||
if (lanClient.description === null) {
|
||||
return null;
|
||||
}
|
||||
const ret = lanClient.description;
|
||||
lanClient.description = null;
|
||||
return ret;
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {boolean}
|
||||
*/
|
||||
webrtcImports["clientLANAwaitChannel"] = function() {
|
||||
if (lanClient.dataChannelOpen) {
|
||||
lanClient.dataChannelOpen = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {boolean}
|
||||
*/
|
||||
webrtcImports["clientLANClosed"] = function() {
|
||||
return lanClient.dataChannelClosed;
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {string} candidate
|
||||
*/
|
||||
webrtcImports["clientLANSetICECandidate"] = function(candidate) {
|
||||
try {
|
||||
const lst = /** @type {Array<!Object>} */ (JSON.parse(candidate));
|
||||
for (var i = 0; i < lst.length; ++i) {
|
||||
lanClient.peerConnection.addIceCandidate(new RTCIceCandidate(lst[i]));
|
||||
}
|
||||
}catch(/** Error */ ex) {
|
||||
eagStackTrace(ERROR, "Uncaught exception setting remote ICE candidates", ex);
|
||||
lanClient.readyState = READYSTATE_FAILED;
|
||||
lanClient.disconnect(false);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {string} description
|
||||
*/
|
||||
webrtcImports["clientLANSetDescription"] = function(description) {
|
||||
try {
|
||||
lanClient.peerConnection.setRemoteDescription(/** @type {!RTCSessionDescription} */ (JSON.parse(description)));
|
||||
}catch(/** Error */ ex) {
|
||||
eagStackTrace(ERROR, "Uncaught exception setting remote description", ex);
|
||||
lanClient.readyState = READYSTATE_FAILED;
|
||||
lanClient.disconnect(false);
|
||||
}
|
||||
};
|
||||
|
||||
let lanServer;
|
||||
lanServer = {
|
||||
/** @type {!Array<Object>} */
|
||||
iceServers: [],
|
||||
/** @type {!Map<string, !LANPeerInternal>} */
|
||||
peerList: new Map(),
|
||||
/** @type {!Map<string, !LANPeerInternal>} */
|
||||
ipcMapList: new Map(),
|
||||
disconnect: function(/** string */ peerId) {
|
||||
const thePeer = lanServer.peerList.get(peerId);
|
||||
if(thePeer) {
|
||||
lanServer.peerList.delete(peerId);
|
||||
if(thePeer.ipcChannel) {
|
||||
lanServer.ipcMapList.delete(thePeer.ipcChannel);
|
||||
}
|
||||
try {
|
||||
thePeer.disconnect();
|
||||
} catch (ignored) {}
|
||||
thePeer.pushEvent(EVENT_WEBRTC_CLOSE, null);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {!Array<string>} servers
|
||||
*/
|
||||
webrtcImports["serverLANInitializeServer"] = function(servers) {
|
||||
lanServer.iceServers.length = 0;
|
||||
for (let url of servers) {
|
||||
let etr = url.split(";");
|
||||
if(etr.length === 1) {
|
||||
lanServer.iceServers.push({
|
||||
"urls": etr[0]
|
||||
});
|
||||
}else if(etr.length === 3) {
|
||||
lanServer.iceServers.push({
|
||||
"urls": etr[0],
|
||||
"username": etr[1],
|
||||
"credential": etr[2]
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
webrtcImports["serverLANCloseServer"] = function() {
|
||||
for (let thePeer of Object.values(lanServer.peerList)) {
|
||||
if (thePeer) {
|
||||
try {
|
||||
thePeer.disconnect();
|
||||
} catch (e) {}
|
||||
thePeer.pushEvent(EVENT_WEBRTC_CLOSE, null);
|
||||
}
|
||||
}
|
||||
lanServer.peerList.clear();
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {string} peer
|
||||
*/
|
||||
webrtcImports["serverLANCreatePeer"] = function(peer) {
|
||||
try {
|
||||
const events = new EaglerLinkedQueue();
|
||||
|
||||
/** @type {!LANPeerInternal} */
|
||||
let peerInstance;
|
||||
peerInstance = {
|
||||
peerId: peer,
|
||||
peerConnection: new RTCPeerConnection(/** @type {RTCConfiguration} */ ({
|
||||
"iceServers": lanServer.iceServers,
|
||||
"optional": [
|
||||
{
|
||||
"DtlsSrtpKeyAgreement": true
|
||||
}
|
||||
]
|
||||
})),
|
||||
/** @type {RTCDataChannel} */
|
||||
dataChannel: null,
|
||||
/** @type {string|null} */
|
||||
ipcChannel: null,
|
||||
pushEvent: function(type, data) {
|
||||
events.push({
|
||||
"type": type,
|
||||
"data": data,
|
||||
"_next": null
|
||||
});
|
||||
},
|
||||
disconnect: function() {
|
||||
if (peerInstance.dataChannel) peerInstance.dataChannel.close();
|
||||
peerInstance.peerConnection.close();
|
||||
}
|
||||
};
|
||||
|
||||
lanServer.peerList.set(peerInstance.peerId, peerInstance);
|
||||
|
||||
const iceCandidates = [];
|
||||
|
||||
peerInstance.peerConnection.addEventListener("icecandidate", /** @type {function(Event)} */ ((/** RTCPeerConnectionIceEvent */ evt) => {
|
||||
if(evt.candidate) {
|
||||
if(iceCandidates.length === 0) {
|
||||
const candidateState = [0, 0];
|
||||
const runnable = () => {
|
||||
if(peerInstance.peerConnection !== null && peerInstance.peerConnection.connectionState !== "disconnected") {
|
||||
const trial = ++candidateState[1];
|
||||
if(candidateState[0] !== iceCandidates.length && trial < 3) {
|
||||
candidateState[0] = iceCandidates.length;
|
||||
setTimeout(runnable, 2000);
|
||||
return;
|
||||
}
|
||||
peerInstance.pushEvent(EVENT_WEBRTC_ICE, JSON.stringify(iceCandidates));
|
||||
iceCandidates.length = 0;
|
||||
}
|
||||
};
|
||||
setTimeout(runnable, 2000);
|
||||
}
|
||||
iceCandidates.push({
|
||||
"sdpMLineIndex": evt.candidate.sdpMLineIndex,
|
||||
"candidate": evt.candidate.candidate
|
||||
});
|
||||
}
|
||||
}));
|
||||
|
||||
let evtHandler;
|
||||
evtHandler = (/** RTCDataChannelEvent */ evt) => {
|
||||
if (iceCandidates.length > 0) {
|
||||
setTimeout(evtHandler, 10, evt);
|
||||
return;
|
||||
}
|
||||
if (!evt.channel) return;
|
||||
const newDataChannel = evt.channel;
|
||||
if(peerInstance.dataChannel !== null) {
|
||||
newDataChannel.close();
|
||||
return;
|
||||
}
|
||||
peerInstance.dataChannel = newDataChannel;
|
||||
peerInstance.pushEvent(EVENT_WEBRTC_OPEN, null);
|
||||
peerInstance.dataChannel.addEventListener("message", (evt2) => {
|
||||
const data = evt2.data;
|
||||
if(peerInstance.ipcChannel) {
|
||||
sendIPCPacketFunc(peerInstance.ipcChannel, data);
|
||||
}else {
|
||||
peerInstance.pushEvent(EVENT_WEBRTC_PACKET, new Uint8Array(data));
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
peerInstance.peerConnection.addEventListener("datachannel", /** @type {function(Event)} */ (evtHandler));
|
||||
|
||||
peerInstance.peerConnection.addEventListener("connectionstatechange", (evt) => {
|
||||
const connectionState = peerInstance.peerConnection.connectionState;
|
||||
if ("disconnected" === connectionState || "failed" === connectionState) {
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
}
|
||||
});
|
||||
|
||||
return {
|
||||
"peerId": peerInstance.peerId,
|
||||
/**
|
||||
* @return {number}
|
||||
*/
|
||||
"countAvailableEvents": function() {
|
||||
return events.getLength();
|
||||
},
|
||||
/**
|
||||
* @return {Object}
|
||||
*/
|
||||
"nextEvent": function() {
|
||||
return events.shift();
|
||||
},
|
||||
/**
|
||||
* @param {!Uint8Array} dat
|
||||
*/
|
||||
"writePacket": function(dat) {
|
||||
let b = false;
|
||||
if (peerInstance.dataChannel !== null && "open" === peerInstance.dataChannel.readyState) {
|
||||
try {
|
||||
peerInstance.dataChannel.send(dat);
|
||||
} catch (e) {
|
||||
b = true;
|
||||
}
|
||||
} else {
|
||||
b = true;
|
||||
}
|
||||
if(b) {
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
}
|
||||
},
|
||||
/**
|
||||
* @param {string} iceCandidates
|
||||
*/
|
||||
"handleRemoteICECandidates": function(iceCandidates) {
|
||||
try {
|
||||
const candidateList = /** @type {!Array<!RTCIceCandidateInit>} */ (JSON.parse(iceCandidates));
|
||||
for (let candidate of candidateList) {
|
||||
peerInstance.peerConnection.addIceCandidate(new RTCIceCandidate(candidate));
|
||||
}
|
||||
} catch (err) {
|
||||
eagError("Failed to parse ice candidate for \"{}\"! {}", peerInstance.peerId, err.message);
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
}
|
||||
},
|
||||
/**
|
||||
* @param {string} desc
|
||||
*/
|
||||
"handleRemoteDescription": function(desc) {
|
||||
try {
|
||||
const remoteDesc = /** @type {!RTCSessionDescription} */ (JSON.parse(desc));
|
||||
peerInstance.peerConnection.setRemoteDescription(remoteDesc).then(() => {
|
||||
if (remoteDesc.hasOwnProperty("type") && "offer" === remoteDesc["type"]) {
|
||||
peerInstance.peerConnection.createAnswer().then((desc) => {
|
||||
peerInstance.peerConnection.setLocalDescription(desc).then(() => {
|
||||
peerInstance.pushEvent(EVENT_WEBRTC_DESC, JSON.stringify(desc));
|
||||
}).catch((err) => {
|
||||
eagError("Failed to set local description for \"{}\"! {}", peerInstance.peerId, err.message);
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
});
|
||||
}).catch((err) => {
|
||||
eagError("Failed to create answer for \"{}\"! {}", peerInstance.peerId, err.message);
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
});
|
||||
}
|
||||
}).catch((err) => {
|
||||
eagError("Failed to set remote description for \"{}\"! {}", peerInstance.peerId, err.message);
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
});
|
||||
} catch (err) {
|
||||
eagError("Failed to parse remote description for \"{}\"! {}", peerInstance.peerId, err.message);
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
}
|
||||
},
|
||||
/**
|
||||
* @param {string|null} ipcChannel
|
||||
*/
|
||||
"mapIPC": function(ipcChannel) {
|
||||
if(!peerInstance.ipcChannel) {
|
||||
if(ipcChannel) {
|
||||
peerInstance.ipcChannel = ipcChannel;
|
||||
lanServer.ipcMapList.set(ipcChannel, peerInstance);
|
||||
}
|
||||
}else {
|
||||
if(!ipcChannel) {
|
||||
lanServer.ipcMapList.delete(peerInstance.ipcChannel);
|
||||
peerInstance.ipcChannel = null;
|
||||
}
|
||||
}
|
||||
},
|
||||
"disconnect": function() {
|
||||
lanServer.disconnect(peerInstance.peerId);
|
||||
}
|
||||
};
|
||||
}catch(/** Error */ tt) {
|
||||
eagStackTrace(ERROR, "Failed to create WebRTC LAN peer!", tt);
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {string} channel
|
||||
* @param {!ArrayBuffer} arr
|
||||
*/
|
||||
serverLANPeerPassIPCFunc = function(channel, arr) {
|
||||
const peer = lanServer.ipcMapList.get(channel);
|
||||
if(peer) {
|
||||
let b = false;
|
||||
if (peer.dataChannel && "open" === peer.dataChannel.readyState) {
|
||||
try {
|
||||
peer.dataChannel.send(arr);
|
||||
} catch (e) {
|
||||
b = true;
|
||||
}
|
||||
} else {
|
||||
b = true;
|
||||
}
|
||||
if(b) {
|
||||
lanServer.disconnect(peer.peerId);
|
||||
}
|
||||
return true;
|
||||
}else {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
function initializeNoPlatfWebRTC(webrtcImports) {
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "supported");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANReadyState");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANCloseConnection");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANSendPacket");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANReadPacket");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANAvailable");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANSetICEServersAndConnect");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clearLANClientState");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANAwaitICECandidate");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANAwaitDescription");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANAwaitChannel");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANClosed");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANSetICECandidate");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANSetDescription");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "clientLANClosed");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "serverLANInitializeServer");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "serverLANCloseServer");
|
||||
setUnsupportedFunc(webrtcImports, platfWebRTCName, "serverLANCreatePeer");
|
||||
}
|
||||
Reference in New Issue
Block a user