private IEnumerator Send()
{
if (false == socket.IsConnected())
{
yield return(GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.WEBSOCKET_TYPE, RetryConnect()));
yield break;
}
else
{
if (0 < requestQueueItem.retryCount)
{
GamebaseLog.Debug(string.Format("Reconnect succeeded. Index of queue item:{0}", requestQueueItem.index), this);
}
}
GamebaseLog.Debug(string.Format("request:{0}", GamebaseJsonUtil.ToPrettyJsonString(requestQueueItem.requestVO)), this);
yield return(GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.WEBSOCKET_TYPE, socket.Send(JsonMapper.ToJson(requestQueueItem.requestVO), (error) =>
{
if (null == error)
{
return;
}
error.transactionId = requestQueueItem.requestVO.transactionId;
requestQueueItem.callback(string.Empty, error);
})));
socket.SetPollingInterval(PollingIntervalType.SHORT_INTERVAL);
GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.WEBSOCKET_TYPE, CheckTimeout());
}
public void OnServerPush(string response)
{
GamebaseLog.Debug(response, this, "OnServerPush");
ServerPushMessage message = JsonMapper.ToObject <ServerPushMessage>(response);
CommonResponse.Header.ServerPush serverPush = message.header.serverPush;
if (true == serverPush.type.Equals(GamebaseServerPushType.APP_KICKOUT) && true == string.IsNullOrEmpty(GamebaseImplementation.Instance.GetUserID()))
{
return;
}
if (false == stampSet.Add(serverPush.stamp))
{
return;
}
if (true == serverPush.disconnect)
{
WebSocket.Instance.Disconnect();
}
if (true == serverPush.stopHeartbeat)
{
Heartbeat.Instance.StopHeartbeat();
}
GamebaseSystemPopup.Instance.ShowServerPushPopup(message.popup);
SendServerPushMessage(serverPush.type, message.result);
}
public void ShowHeartbeatErrorPopup(GamebaseError error)
{
if (true == Gamebase.IsSuccess(error))
{
return;
}
GamebaseLog.Debug(string.Format("ErrorCode : {0}", error.code), this);
switch (error.code)
{
case GamebaseErrorCode.BANNED_MEMBER: // 이용정지 KickOut
{
ShowKickOutPopup();
break;
}
case GamebaseErrorCode.INVALID_MEMBER: // 잘못된 사용자 KickOut
{
break;
}
default:
{
break;
}
}
}
public IEnumerator Connect(GamebaseCallback.ErrorDelegate callback)
{
CreateSocket();
float waitTime = 0;
while (false == IsConnected() && null == GetErrorMessage() && waitTime < CommunicatorConfiguration.connectionTimeout)
{
waitTime += Time.unscaledDeltaTime;
yield return(null);
}
GamebaseError error = null;
if (false == string.IsNullOrEmpty(GetErrorMessage()))
{
error = new GamebaseError(GamebaseErrorCode.SOCKET_ERROR, message: GetErrorMessage());
}
else
{
if (waitTime >= CommunicatorConfiguration.connectionTimeout)
{
error = new GamebaseError(GamebaseErrorCode.SOCKET_ERROR);
}
else
{
GamebaseLog.Debug("socket connected.", this, "Connect");
}
}
StartRecvPolling();
callback(error);
}
private IEnumerator Send()
{
if (false == socket.IsConnected())
{
yield return(GamebaseUnitySDKSettings.Instance.StartCoroutine(RetryConnect()));
yield break;
}
else
{
if (0 < requestQueueItem.retryCount)
{
GamebaseLog.Debug(string.Format("Reconnect succeeded. Index of queue item:{0}", requestQueueItem.index), this, "Send");
}
}
GamebaseLog.Debug(string.Format("request:{0}", JsonMapper.ToJson(requestQueueItem.requestVO)), this, "Send");
yield return(GamebaseUnitySDKSettings.Instance.StartCoroutine(socket.Send(JsonMapper.ToJson(requestQueueItem.requestVO), (error) =>
{
if (null == error)
{
return;
}
error.transactionId = requestQueueItem.requestVO.transactionId;
requestQueueItem.callback(string.Empty, error);
})));
socket.SetPollingInterval(PollingIntervalType.SHORT_INTERVAL);
GamebaseUnitySDKSettings.Instance.StartCoroutine(CheckTimeout());
}
public void SetRemoteSettings(GamebaseResponse.Launching.LaunchingInfo launchingInfo)
{
if (launchingInfo == null ||
launchingInfo.launching == null ||
launchingInfo.launching.tcgbClient == null)
{
return;
}
var forceRemoteSettings = launchingInfo.launching.tcgbClient.forceRemoteSettings;
if (forceRemoteSettings != null)
{
GamebaseLog.Debug(GamebaseJsonUtil.ToPrettyJsonString(forceRemoteSettings), this);
logSetting.Initialize(forceRemoteSettings.log.policy, forceRemoteSettings.log.indicator);
GamebaseLog.SetDebugLog(logSetting.IsDebugMode(isDebugMode));
GamebaseLogReport.Instance.Initialize(
logSetting.IsIndicatorMode(),
forceRemoteSettings.log.appKeyIndicator,
forceRemoteSettings.log.appKeyLog);
}
else
{
GamebaseLog.Debug("ForceRemoteSettings is null", this);
}
}
public void ShowErrorPopup(GamebaseError error, BaseVO vo = null)
{
if (true == Gamebase.IsSuccess(error))
{
return;
}
GamebaseLog.Debug(
string.Format("ErrorCode : {0}", error.code),
this,
"ShowErrorPopup");
switch (error.code)
{
case GamebaseErrorCode.AUTH_BANNED_MEMBER: // 이용정지
{
ShowBanPopup((AuthResponse.LoginInfo)vo);
break;
}
default:
{
break;
}
}
}
public void OnAsyncEvent(string jsonString)
{
GamebaseLog.Debug(string.Format("jsonString : {0}", jsonString), this);
NativeMessage message = JsonMapper.ToObject <NativeMessage>(jsonString);
if (message == null)
{
GamebaseLog.Debug("JSON parsing error. message object is null.", this);
return;
}
DelegateManager.DelegateData delegateData = DelegateManager.GetDelegate(message.scheme);
if (delegateData != null)
{
if (delegateData.pluginEventDelegate != null)
{
delegateData.pluginEventDelegate(message);
}
if (delegateData.eventDelegate != null)
{
delegateData.eventDelegate(message);
}
}
}
internal JsonException(ParserToken token,
Exception inner_exception) :
base(String.Format(
"Invalid token '{0}' in input string", token),
inner_exception)
{
GamebaseLog.Debug(string.Format("JsonException token:{0}, inner_exception:{1}", token, inner_exception), this);
}
virtual protected void InvokeCredentialInfoMethod(string providerName, int handle, string methodName, string forcingMappingKey = null)
{
bool hasAdapter = AuthAdapterManager.Instance.CreateIDPAdapter(providerName);
if (hasAdapter == true)
{
AuthAdapterManager.Instance.GetIDPCredentialInfo(providerName, (credentialInfo, adapterError) =>
{
if (Gamebase.IsSuccess(adapterError) == true)
{
GamebaseExtraDataHandler.RegisterExtraData(handle, providerName);
if (methodName.Equals("Login", StringComparison.Ordinal) == true)
{
Login(credentialInfo, handle);
}
else if (methodName.Equals("AddMapping", StringComparison.Ordinal) == true)
{
AddMapping(credentialInfo, handle);
}
else if (methodName.Equals("AddMappingForcibly", StringComparison.Ordinal) == true)
{
AddMappingForcibly(credentialInfo, forcingMappingKey, handle);
}
}
else
{
var callback = GamebaseCallbackHandler.GetCallback <GamebaseCallback.GamebaseDelegate <GamebaseResponse.Auth.AuthToken> >(handle);
if (callback == null)
{
return;
}
AuthAdapterManager.Instance.IDPLogout(providerName);
callback(null, new GamebaseError(GamebaseErrorCode.AUTH_IDP_LOGIN_FAILED, "AndroidGamebaseAuth", error: adapterError));
}
});
}
else
{
GamebaseLog.Debug("Call native method", this);
if (methodName.Equals("Login", StringComparison.Ordinal) == true)
{
CallNativeLogin(providerName, handle);
}
else if (methodName.Equals("AddMapping", StringComparison.Ordinal) == true)
{
CallNativeMapping(providerName, handle);
}
else if (methodName.Equals("AddMappingForcibly", StringComparison.Ordinal) == true)
{
CallNativeMappingForcibly(providerName, forcingMappingKey, handle);
}
}
}
public void RequestLaunchingStatus(int handle = -1)
{
GamebaseLog.Debug("Check Launching Status", this);
statusElaspedTime = 0;
requestVO.apiId = Lighthouse.API.Launching.ID.GET_LAUNCHING_STATUS;
WebSocket.Instance.Request(requestVO, (response, error) =>
{
GamebaseSystemPopup.Instance.ShowErrorPopup(error);
if (null != error)
{
return;
}
var launchingInfo = DataContainer.GetData <LaunchingResponse.LaunchingInfo>(VOKey.Launching.LAUNCHING_INFO);
var launchingStatus = JsonMapper.ToObject <LaunchingResponse.LaunchingStatus>(response);
if (launchingInfo.launching.status.code == launchingStatus.launching.status.code)
{
OnLaunchingInfoCallback(handle);
return;
}
GamebaseLog.Debug("Check Launching Info", this);
GamebaseCallback.GamebaseDelegate <GamebaseResponse.Launching.LaunchingInfo> launchingInfoCallback = (launchingInfoTemp, errorTemp) =>
{
var launchingStatusCallback = GamebaseCallbackHandler.GetCallback <GamebaseCallback.DataDelegate <GamebaseResponse.Launching.LaunchingStatus> >(scheduleHandle);
if (null != launchingStatusCallback)
{
var vo = new GamebaseResponse.Launching.LaunchingStatus();
vo.code = launchingStatus.launching.status.code;
vo.message = launchingStatus.launching.status.message;
launchingStatusCallback(vo);
}
var observerCallback = GamebaseCallbackHandler.GetCallback <GamebaseCallback.DataDelegate <GamebaseResponse.SDK.ObserverMessage> >(GamebaseObserverManager.Instance.Handle);
if (null != observerCallback)
{
var vo = new GamebaseResponse.SDK.ObserverMessage();
vo.type = GamebaseObserverType.LAUNCHING;
vo.data = new System.Collections.Generic.Dictionary <string, object>();
vo.data.Add("code", launchingStatus.launching.status.code);
vo.data.Add("message", launchingStatus.launching.status.message);
observerCallback(vo);
}
OnLaunchingInfoCallback(handle);
};
int handleTemp = GamebaseCallbackHandler.RegisterCallback(launchingInfoCallback);
GetLaunchingInfo(handleTemp);
});
}
public void SetExtraData(Dictionary <string, string> extraData)
{
if (adapter == null)
{
GamebaseLog.Debug(GamebaseStrings.PURCHASE_ADAPTER_NOT_FOUND, this);
return;
}
adapter.SetExtraData(extraData);
}
public void SetConfiguration(GamebaseRequest.Purchase.Configuration iapConfiguration)
{
if (adapter == null)
{
GamebaseLog.Debug(GamebaseStrings.PURCHASE_ADAPTER_NOT_FOUND, this);
return;
}
adapter.SetConfiguration(iapConfiguration);
}
public void Initialize()
{
if (adapter == null)
{
GamebaseLog.Debug(GamebaseStrings.PURCHASE_ADAPTER_NOT_FOUND, this);
return;
}
adapter.Initialize();
}
public void StopHeartbeat()
{
if (HeartbeatStatus.Stop == status)
{
return;
}
GamebaseLog.Debug("Stop Heartbeat", this, "StopHeartbeat");
status = HeartbeatStatus.Stop;
}
public void StartHeartbeat()
{
if (false == IsSendable())
{
return;
}
GamebaseLog.Debug("Start Heartbeat", this, "StartHeartbeat");
status = HeartbeatStatus.Start;
GamebaseUnitySDKSettings.Instance.StartCoroutine(ExecuteHeartbeat());
}
private void ExecuteSchedule()
{
GamebaseLog.Debug("Start Launching Status Schedule", this);
if (isPlaySchedule == true)
{
return;
}
isPlaySchedule = true;
GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.LAUNCHING_TYPE, ScheduleLaunchingStatus());
}
public string GetSync(string jsonString)
{
GamebaseLog.Debug(string.Format("jsonString : {0}", jsonString), this, "GetSync");
string retValue = string.Empty;
IntPtr result = getSync(jsonString);
if (result != IntPtr.Zero)
{
retValue = Marshal.PtrToStringAnsi(result);
}
return(retValue);
}
public void StartHeartbeat()
{
if (false == IsSendable())
{
return;
}
GamebaseLog.Debug("Start Heartbeat", this);
status = HeartbeatStatus.Start;
GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.HEARTBEAT_TYPE, ExecuteHeartbeat());
}
private void ExecuteSchedule()
{
GamebaseLog.Debug("Start Launching Status Schedule", this, "ExecuteSchedule");
if (true == isPlaySchedule)
{
return;
}
isPlaySchedule = true;
GamebaseUnitySDKSettings.Instance.StartCoroutine(ScheduleLaunchingStatus());
}
public void SetUserMeta(RequestType type)
{
if (string.IsNullOrEmpty(Gamebase.GetUserID()) == true)
{
GamebaseLog.Warn("Not LoggedIn", this, "SetUserMeta");
return;
}
GamebaseLog.Debug(
string.Format("SetUserMeta Type : {0}", type.ToString()),
this,
"SetUserMeta");
AnalyticsRequest.UserMetaVO vo = new AnalyticsRequest.UserMetaVO();
vo.payload.appId = GamebaseUnitySDK.AppID;
vo.parameter.userId = Gamebase.GetUserID();
switch (type)
{
case RequestType.USER_DATA:
{
vo.payload.userMetaData = MakeUserMetaData();
break;
}
case RequestType.LEVEL_UP:
{
vo.payload.userMetaData = MakeLevelUpData();
break;
}
}
var requestVO = new WebSocketRequest.RequestVO(PRODUCT_ID, Lighthouse.API.VERSION, GamebaseUnitySDK.AppID);
requestVO.apiId = ID.SET_USER_META;
requestVO.payload = JsonMapper.ToJson(vo.payload);
requestVO.parameters = vo.parameter;
WebSocket.Instance.Request(requestVO, (response, error) =>
{
if (Gamebase.IsSuccess(error) == false)
{
GamebaseLog.Warn(
string.Format(
"{0}\n{1}",
"Failed request.",
GamebaseJsonUtil.ToPrettyJsonString(error)),
this,
"SetUserMeta");
}
});
}
public string GetSync(string jsonString)
{
GamebaseLog.Debug(string.Format("jsonString : {0}", GamebaseJsonUtil.ToPrettyJsonString(jsonString)), this);
string retValue = jc.CallStatic <string>("getSync", jsonString);
if (string.IsNullOrEmpty(retValue) == false)
{
GamebaseLog.Debug(string.Format("retValue : {0}", retValue), this);
}
return(retValue);
}
private void SetIapExtraData(string providerName)
{
GamebaseLog.Debug("SetIapExtraData", this);
ToastSdk.UserId = Gamebase.GetUserID();
var userId = Gamebase.GetAuthProviderUserID(providerName);
PurchaseAdapterManager.Instance.SetExtraData(
new Dictionary <string, string>()
{
{ KEY_IAP_EXTRA_USER_ID, userId }
});
}
private void SendServerPushMessage(string type, string data)
{
GamebaseLog.Debug(string.Format("type : {0}, data : {1}", type, data), this);
GamebaseResponse.SDK.ServerPushMessage serverPushMessage = new GamebaseResponse.SDK.ServerPushMessage();
serverPushMessage.type = type;
serverPushMessage.data = data;
var pushCallback = GamebaseCallbackHandler.GetCallback<GamebaseCallback.DataDelegate<GamebaseResponse.SDK.ServerPushMessage>>(GamebaseServerPushEventManager.Instance.Handle);
if (null != pushCallback)
{
pushCallback(serverPushMessage);
}
}
public void StartIntrospect()
{
if (IsSendable() == false)
{
return;
}
GamebaseLog.Debug("Start Introspect", this);
sentIntervalTime = refrashIntervalTime;
sentStandardTime = Time.realtimeSinceStartup;
GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.INTROSPECT_TYPE, ExecuteIntrospect());
}
public IEnumerator Reconnect(GamebaseCallback.ErrorDelegate callback)
{
GamebaseLog.Debug(string.Format("SocketState:{0}", SocketState(nativeRef)), this);
if (DEFAULT_NATIVE_REF != nativeRef)
{
if ((int)WebSocketState.Open == SocketState(nativeRef))
{
callback(null);
yield break;
}
}
Close();
yield return(GamebaseCoroutineManager.StartCoroutine(GamebaseGameObjectManager.GameObjectType.WEBSOCKET_TYPE, Connect(callback)));
}
public IEnumerator Reconnect(GamebaseCallback.ErrorDelegate callback)
{
GamebaseLog.Debug(string.Format("SocketState:{0}", SocketState(nativeRef)), this, "Reconnect");
if (DEFAULT_NATIVE_REF != nativeRef)
{
if ((int)WebSocketState.Open == SocketState(nativeRef))
{
callback(null);
yield break;
}
}
Close();
yield return(GamebaseUnitySDKSettings.Instance.StartCoroutine(Connect(callback)));
}
public GamebaseResponse.Auth.AuthProviderProfile GetAuthProviderProfile(string providerName)
{
if (GamebaseAuthProvider.GUEST == providerName)
{
GamebaseLog.Debug("Guest does not have profile information.", this);
return(null);
}
if (true == string.IsNullOrEmpty(Gamebase.GetUserID()))
{
GamebaseLog.Debug(GamebaseStrings.NOT_LOGGED_IN, this);
return(null);
}
return(AuthAdapterManager.Instance.GetIDPData <GamebaseResponse.Auth.AuthProviderProfile>(providerName, AuthAdapterManager.MethodName.GET_IDP_PROFILE));
}
public void ShowKickOutPopup()
{
GamebaseLog.Debug("ShowKickOutPopup", this);
if (false == GamebaseUnitySDK.EnablePopup || false == GamebaseUnitySDK.EnableKickoutPopup)
{
return;
}
ShowSystemPopup(
GamebaseUtilAlertType.ALERT_OK,
DisplayLanguage.Instance.GetString("common_notice_title"),
DisplayLanguage.Instance.GetString("ban_user_message"),
string.Empty,
DisplayLanguage.Instance.GetString("common_close_button"),
string.Empty,
(buttonID) => { });
}
public bool CanLaunchingStatusUpdate()
{
float statusElaspedTime = GamebaseLaunchingImplementation.Instance.GetStatusElaspedTime();
if (statusElaspedTime >= LAUNCHING_STATUS_EXPIRE_TIME)
{
GamebaseLog.Debug(
string.Format(
"LaunchingStatusElaspedTime : {0} (Standard is more than {1})",
statusElaspedTime,
LAUNCHING_STATUS_EXPIRE_TIME),
this);
return(true);
}
return(false);
}
