public void SessionClosed(int ClosedByErrorCode)
{
if (questProcessor != null)
{
questProcessor.SessionClosed(ClosedByErrorCode);
}
RTMControlCenter.UnregisterSession(connectionId);
}
public Answer Kickout(Int64 connectionId, string endpoint, Quest quest)
{
RTMControlCenter.CloseSession(connectionId);
if (questProcessor != null)
{
questProcessor.Kickout();
}
return(null);
}
public Answer Kickout(Int64 connectionId, string endpoint, Quest quest)
{
bool closed = RTMControlCenter.GetClientStatus(connectionId) == RTMClient.ClientStatus.Closed;
RTMControlCenter.CloseSession(connectionId);
if (questProcessor != null && closed == false)
{
questProcessor.Kickout();
}
return(null);
}
private void AuthFinish(bool authStatus, int errorCode)
{
AuthStatusInfo currInfo;
TCPClient client = null;
long connectionId = 0;
long currUid;
lock (interLocker)
{
if (status != ClientStatus.Connecting)
{
return;
}
if (authStatus)
{
status = ClientStatus.Connected;
authStatsInfo.rtmClients.Remove(rtmGate);
}
else
{
status = ClientStatus.Closed;
connectionId = rtmGateConnectionId;
rtmGateConnectionId = 0;
client = rtmGate;
rtmGate = null;
}
currInfo = authStatsInfo;
authStatsInfo = null;
currUid = uid;
syncConnectingEvent.Set();
}
if (currInfo != null)
{
currInfo.authCallback(pid, currUid, authStatus, errorCode);
}
if (connectionId != 0)
{
RTMControlCenter.UnregisterSession(connectionId);
}
if (client != null)
{
client.Close();
}
}
public bool ReloginWillStart(int lastErrorCode, int retriedCount)
{
bool startRelogin = true;
if (questProcessor != null)
{
startRelogin = questProcessor.ReloginWillStart(lastErrorCode, retriedCount);
}
if (startRelogin) //-- if startRelogin == false, will call SessionClosed(), the UnregisterSession() will be called in SessionClosed().
{
RTMControlCenter.UnregisterSession(connectionId);
}
return(startRelogin);
}
private void RedirectToNewRtmGate(string endpoint, bool addressConverted)
{
TCPClient client = TCPClient.Create(endpoint, false);
lock (interLocker)
{
rtmGate = client;
authStatsInfo.rtmClients.Add(client);
}
ConfigRtmGateClient(client, (Int64 connectionId, string rtmGateEndpoint, bool connected) => {
if (requireClose)
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_CONNECTION_CLOSED);
return;
}
if (connected)
{
rtmGateConnectionId = connectionId;
lastAvailableRtmGateEndpoint = endpoint;
RTMControlCenter.RegisterSession(rtmGateConnectionId, this);
Auth();
}
else
{
if (addressConverted)
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_INVALID_CONNECTION);
return;
}
if (!AdjustAuthRemainedTimeout())
{
return;
}
if (!ConvertIPv4EndpointToIPv6IPPort(endpoint, out string ipv6, out int port))
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_INVALID_CONNECTION);
return;
}
RedirectToNewRtmGate(ipv6 + ":" + port, true);
}
//-------------[ Relogin interfaces ]--------------------------//
private void StartNextRelogin()
{
if (autoReloginInfo.reloginCount <= regressiveStrategy.startConnectFailedCount)
{
StartRelogin();
return;
}
int regressiveCount = autoReloginInfo.reloginCount - regressiveStrategy.startConnectFailedCount;
long interval = regressiveStrategy.maxIntervalSeconds * 1000;
if (regressiveCount < regressiveStrategy.linearRegressiveCount)
{
interval = interval * regressiveCount / regressiveStrategy.linearRegressiveCount;
}
RTMControlCenter.DelayRelogin(this, ClientEngine.GetCurrentMilliseconds() + interval);
}
private int SendFileWithClient(SendFileInfo info, TCPClient client)
{
UpdateTimeout(ref info.remainTimeout, ref info.lastActionTimestamp);
if (info.remainTimeout <= 0)
{
return(fpnn.ErrorCode.FPNN_EC_CORE_TIMEOUT);
}
long messageId = 0;
Quest quest = BuildSendFileQuest(out messageId, info);
bool success = client.SendQuest(quest, (Answer answer, int errorCode) => {
if (errorCode == fpnn.ErrorCode.FPNN_EC_OK)
{
try
{
//-- long mtime = answer.Want<long>("mtime");
info.callback(messageId, fpnn.ErrorCode.FPNN_EC_OK);
RTMControlCenter.ActiveFileGateClient(info.endpoint, client);
return;
}
catch (Exception)
{
errorCode = fpnn.ErrorCode.FPNN_EC_CORE_INVALID_PACKAGE;
}
}
info.callback(0, errorCode);
}, info.remainTimeout);
if (success)
{
return(fpnn.ErrorCode.FPNN_EC_OK);
}
else
{
return(fpnn.ErrorCode.FPNN_EC_CORE_INVALID_CONNECTION);
}
}
private static void CheckRoutineInit()
{
if (routineInited)
{
return;
}
lock (interLocker)
{
if (routineInited)
{
return;
}
routineRunning = true;
routineThread = new Thread(RoutineFunc)
{
Name = "RTM.ControlCenter.RoutineThread",
#if UNITY_2017_1_OR_NEWER
#else
IsBackground = true
#endif
};
routineThread.Start();
routineInited = true;
}
#if UNITY_2017_1_OR_NEWER
Application.quitting += () => {
RTMControlCenter.Close();
};
#endif
}
private void ParallelConnectToRtmGate(string endpoint, ParallelLoginStatusInfo info)
{
if (!AdjustAuthRemainedTimeout(info))
{
DecreaseParallelConnectingCount();
return;
}
TCPClient client = TCPClient.Create(endpoint, false);
lock (interLocker)
{
if (status != ClientStatus.Connecting)
{
return;
}
authStatsInfo.rtmClients.Add(client);
}
ConfigRtmGateClient(client, (Int64 connectionId, string rtmGateEndpoint, bool connected) => {
if (requireClose)
{
DecreaseParallelConnectingCount();
return;
}
if (connected)
{
lock (interLocker)
{
if (status != ClientStatus.Connecting)
{
return;
}
authStatsInfo.parallelConnectingCount -= 1;
if (authStatsInfo.parallelCompleted)
{
return;
}
authStatsInfo.parallelCompleted = true;
authStatsInfo.remainedTimeout = info.remainedTimeout;
authStatsInfo.lastActionMsecTimeStamp = info.lastActionMsecTimeStamp;
rtmGate = client;
}
rtmGateConnectionId = connectionId;
lastAvailableRtmGateEndpoint = endpoint;
RTMControlCenter.RegisterSession(rtmGateConnectionId, this);
Auth();
}
else
{
DecreaseParallelConnectingCount();
}
}, info.remainedTimeout);
client.AsyncConnect();
if (requireClose)
{
client.Close();
}
}
static void NetworkStatusCallback(int networkStatus)
{
RTMControlCenter.NetworkChanged((NetworkType)networkStatus);
}
private void DispatchCallBack_Which_IPv4(Answer answer, int errorCode)
{
if (requireClose)
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_CONNECTION_CLOSED);
return;
}
if (errorCode == fpnn.ErrorCode.FPNN_EC_OK)
{
if (!AdjustAuthRemainedTimeout())
{
return;
}
string ipv4endpoint = answer.Get <string>("endpoint", string.Empty);
if (ipv4endpoint.Length > 0)
{
TCPClient client = TCPClient.Create(ipv4endpoint, false);
lock (interLocker)
{
rtmGate = client;
authStatsInfo.rtmClients.Add(client);
}
ConfigRtmGateClient(client, (Int64 connectionId, string endpoint, bool connected) => {
if (requireClose)
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_CONNECTION_CLOSED);
return;
}
if (connected)
{
rtmGateConnectionId = connectionId;
lastAvailableRtmGateEndpoint = ipv4endpoint;
RTMControlCenter.RegisterSession(rtmGateConnectionId, this);
Auth();
}
else
{
if (!AdjustAuthRemainedTimeout())
{
return;
}
StartParallelConnect(ipv4endpoint);
}
}, authStatsInfo.remainedTimeout);
client.AsyncConnect();
if (requireClose)
{
client.Close();
}
return;
}
else
{
StartParallelConnect(string.Empty);
}
}
else
{
AuthFinish(false, errorCode);
}
}
//-------------[ Auth(Login) processing functions ]--------------------------//
private void AuthFinish(bool authStatus, int errorCode)
{
AuthStatusInfo currInfo;
long currUid;
bool isRelogin = false;
Int64 reservedRtmGateConnectionId = 0;
lock (interLocker)
{
if (status != ClientStatus.Connecting)
{
return;
}
if (authStatus)
{
status = ClientStatus.Connected;
}
else
{
status = ClientStatus.Closed;
reservedRtmGateConnectionId = rtmGateConnectionId;
rtmGateConnectionId = 0;
//-- Reserving rtmGate without closing for quick relogin.
}
if (autoReloginInfo != null)
{
isRelogin = autoReloginInfo.canRelogin;
if (authStatsInfo != null)
{
autoReloginInfo.token = authStatsInfo.token;
autoReloginInfo.attr = authStatsInfo.attr;
autoReloginInfo.lang = authStatsInfo.lang;
}
if (authStatus && !autoReloginInfo.canRelogin)
{
autoReloginInfo.LoginSuccessful();
}
}
currInfo = authStatsInfo;
authStatsInfo = null;
currUid = uid;
syncConnectingEvent.Set();
}
if (reservedRtmGateConnectionId != 0)
{
RTMControlCenter.UnregisterSession(reservedRtmGateConnectionId);
}
if (currInfo != null)
{
foreach (AuthDelegate callback in currInfo.authDelegates)
{
callback(projectId, currUid, authStatus, errorCode);
}
}
if (authStatus)
{
processor.BeginCheckPingInterval();
}
}
private void BuildRtmGateClient(string originalEndpoint)
{
rtmGate = TCPClient.Create(adjustEndpoint(originalEndpoint), true);
if (errorRecorder != null)
{
rtmGate.SetErrorRecorder(errorRecorder);
}
rtmGate.SetQuestProcessor(processor);
rtmGate.SetConnectionConnectedDelegate((Int64 connectionId, string endpoint, bool connected) => {
if (requireClose)
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_CONNECTION_CLOSED);
return;
}
if (connected)
{
rtmGateConnectionId = connectionId;
RTMControlCenter.RegisterSession(rtmGateConnectionId, this);
Auth(true);
}
else
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_INVALID_CONNECTION);
}
});
rtmGate.SetConnectionCloseDelegate((Int64 connectionId, string endpoint, bool causedByError) => {
bool trigger = false;
bool isConnecting = false;
bool startRelogin = false;
lock (interLocker)
{
trigger = rtmGateConnectionId == connectionId;
if (trigger)
{
if (status == ClientStatus.Connecting)
{
isConnecting = true;
}
else
{
status = ClientStatus.Closed;
}
}
if (autoReloginInfo != null)
{
startRelogin = (autoReloginInfo.disabled == false && autoReloginInfo.canRelogin);
autoReloginInfo.lastErrorCode = (causedByError ? fpnn.ErrorCode.FPNN_EC_CORE_CONNECTION_CLOSED : fpnn.ErrorCode.FPNN_EC_OK);
}
}
if (trigger)
{
if (isConnecting)
{
AuthFinish(false, fpnn.ErrorCode.FPNN_EC_CORE_INVALID_CONNECTION);
}
else
{
if (startRelogin)
{
StartRelogin();
}
else
{
processor.SessionClosed(causedByError ? fpnn.ErrorCode.FPNN_EC_CORE_UNKNOWN_ERROR : fpnn.ErrorCode.FPNN_EC_OK);
}
}
}
});
}
private bool Login(AuthDelegate callback, string token, Dictionary <string, string> attr, string lang = "", int timeout = 0)
{
lock (interLocker)
{
if (status == ClientStatus.Connected)
{
ClientEngine.RunTask(() =>
{
callback(projectId, uid, true, fpnn.ErrorCode.FPNN_EC_OK);
});
return(true);
}
if (status == ClientStatus.Connecting)
{
authStatsInfo.authDelegates.Add(callback);
return(true);
}
status = ClientStatus.Connecting;
syncConnectingEvent.Reset();
requireClose = false;
if (autoReloginInfo != null)
{
autoReloginInfo.Login();
}
}
authStatsInfo = new AuthStatusInfo
{
authDelegates = new HashSet <AuthDelegate>()
{
callback
},
remainedTimeout = timeout,
};
authStatsInfo.token = token;
authStatsInfo.attr = attr;
authStatsInfo.lang = lang;
authStatsInfo.lastActionMsecTimeStamp = ClientEngine.GetCurrentMilliseconds();
if (rtmGate.IsConnected())
{
if (authStatsInfo.remainedTimeout == 0)
{
authStatsInfo.remainedTimeout = RTMConfig.globalQuestTimeoutSeconds;
}
RTMControlCenter.RegisterSession(rtmGateConnectionId, this);
Auth(false);
}
else
{
if (authStatsInfo.remainedTimeout == 0)
{
authStatsInfo.remainedTimeout = ((ConnectTimeout == 0) ? RTMConfig.globalConnectTimeoutSeconds : ConnectTimeout)
+ ((QuestTimeout == 0) ? RTMConfig.globalQuestTimeoutSeconds : QuestTimeout);
}
rtmGate.AsyncConnect();
}
return(true);
}
