public void RefreshAccessToken(PlayerIdentityCallback callback = null)
{
if (m_PendingRefreshCallbacks.Count > 0)
{
m_PendingRefreshCallbacks.Add(callback);
return;
}
m_PendingRefreshCallbacks.Add(callback);
m_State.status = LoginStatus.LoginInProgress;
m_Backend.RefreshAccessToken(result =>
{
PlayerIdentityCallback flushCallback = (IPlayerIdentityCore sender) =>
{
var currentPendings = new List <PlayerIdentityCallback>(m_PendingRefreshCallbacks);
m_PendingRefreshCallbacks.Clear();
foreach (var t in currentPendings)
{
if (t != null)
{
t.Invoke(sender);
}
}
};
if (HandleLoginResult(result, flushCallback))
{
ScheduleCallback(SendAccessTokenChangedEvent, flushCallback);
}
});
}
public void Link(string loginProviderId, PlayerIdentityCallback callback = null)
{
foreach (var loginProvider in m_LoginProviders)
{
if (loginProvider.SubsystemDescriptor.loginProviderID == loginProviderId)
{
loginProvider.Login(null, providerResult =>
{
// Make sure the callbacks from login providers are running in the main thread
ScheduleCallback(() =>
{
if (providerResult.error != null)
{
m_State.error = providerResult.error;
ScheduleCallback(SendErrorEvent, callback);
return;
}
m_Backend.Link(providerResult.externalToken, result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleCallback(SendLinkEvent, callback);
}
});
}, null);
});
return;
}
}
throw new ArgumentException("Invalid login provider ID: " + loginProviderId);
}
internal static void UpdateDisplayName(string displayName, PlayerIdentityCallback callback = null)
{
if (!MainController.Instance.SensitiveWordManager.CheckTextSart(displayName))
{
var mainController = MainController.Instance;
var identityCore = PlayerIdentityManager.Current;
mainController.ShowLoading(true);
identityCore.UpdateUser(new UserInfo
{
userId = identityCore.userInfo.userId,
email = identityCore.userInfo.email,
// only update the display name here
displayName = displayName,
emailVerified = identityCore.userInfo.emailVerified,
signInProviderId = identityCore.userInfo.signInProviderId,
externalId = identityCore.userInfo.signInProviderId,
isAnonymous = identityCore.userInfo.isAnonymous,
photoUrl = identityCore.userInfo.photoUrl,
disabled = identityCore.userInfo.disabled,
externalIds = identityCore.userInfo.externalIds
}, result =>
{
mainController.ShowLoading(false);
callback?.Invoke(result);
});
}
else
{
MainController.Instance.PopupController.ShowError(new Error()
{
message = "用户名格式错误"
});
}
}
public void Unlink(string[] idProviders, PlayerIdentityCallback callback = null)
{
m_Backend.Unlink(idProviders, result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleCallback(SendUnlinkEvent, callback);
}
});
}
public void ChangePassword(string password, string newPassword, PlayerIdentityCallback callback = null)
{
m_Backend.ChangePassword(password, newPassword, result =>
{
if (HandleResult(result, callback))
{
ScheduleCallback(SendChangePasswordEvent, callback);
}
});
}
public void UpdateUser(UserInfo userInfo, PlayerIdentityCallback callback = null)
{
m_Backend.UpdateUser(userInfo, result =>
{
if (HandleResult(result, callback))
{
ScheduleCallback(SendUpdateUserEvent, callback);
}
});
}
public void ResetPassword(string email, PlayerIdentityCallback callback = null)
{
m_Backend.ResetPassword(email, result =>
{
if (HandleResult(result, callback))
{
ScheduleCallback(SendResetPasswordEvent, callback);
}
});
}
public void LinkSmsCode(string code, string verificationId, PlayerIdentityCallback callback = null)
{
m_Backend.LinkSmsCode(userId, code, verificationId, result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleCallback(SendLinkEvent, callback);
}
});
}
public void VerifyEmail(string email, PlayerIdentityCallback callback = null)
{
m_Backend.VerifyEmail(email, result =>
{
if (HandleResult(result, callback))
{
ScheduleCallback(SendVerifyEmailEvent, callback);
}
});
}
private void ScheduleLoginEvent(PlayerIdentityCallback immediateCallback)
{
if (m_State.userInfo.isAnonymous)
{
ScheduleCallback(SendAnonymousLoginEvent, immediateCallback);
}
else
{
ScheduleCallback(SendLoginEvent, immediateCallback);
}
}
public void PhoneLogin(string smsCodeText, string verificationIdText, PlayerIdentityCallback callback = null)
{
m_State.status = LoginStatus.LoginInProgress;
m_Backend.PhoneLogin(smsCodeText, verificationIdText, result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleCallback(SendLoginEvent, callback);
}
});
}
public void LoginAnonymous(PlayerIdentityCallback callback = null)
{
m_State.status = LoginStatus.LoginInProgress;
m_Backend.LoginAnonymous(result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleCallback(SendAnonymousLoginEvent, callback);
}
});
}
public void Login(string email, string password, PlayerIdentityCallback callback = null)
{
m_State.status = LoginStatus.LoginInProgress;
m_Backend.Login(email, password, result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleCallback(SendLoginEvent, callback);
}
});
}
public void RestoreLogin(PlayerIdentityCallback callback = null)
{
m_State.status = LoginStatus.LoginInProgress;
m_Backend.RestoreLogin(result =>
{
if (HandleLoginResult(result, callback))
{
ScheduleLoginEvent(callback);
}
m_Started = true;
});
}
public void Register(string email, string password, PlayerIdentityCallback callback = null)
{
m_State.status = LoginStatus.LoginInProgress;
m_Backend.Register(email, password, result =>
{
if (HandleLoginResult(result, callback))
{
AutomaticallyVerifyEmail();
ScheduleCallback(SendLoginEvent, callback);
}
});
}
public void Logout(PlayerIdentityCallback callback = null)
{
m_Backend.Logout(result =>
{
if (HandleLoginResult(result, callback))
{
// Reset the state
m_State = new State();
ScheduleCallback(SendLogoutEvent, callback);
}
});
}
public void CreateCredential(string email, string password, PlayerIdentityCallback callback = null)
{
m_Backend.CreateCredential(email, password, result =>
{
if (HandleLoginResult(result, callback))
{
AutomaticallyVerifyEmail();
m_State.status = LoginStatus.LoggedIn;
ScheduleCallback(SendCreateCredentialEvent, callback);
}
});
}
private void ScheduleCallback(Callback callback, PlayerIdentityCallback immediateCallback)
{
if (callback != null)
{
m_EventBacklog.Enqueue(callback);
}
if (immediateCallback != null)
{
m_EventBacklog.Enqueue(() =>
{
immediateCallback.Invoke(this);
});
}
}
public void GetUser(PlayerIdentityCallback callback = null)
{
m_Backend.GetUser(userId, result =>
{
if (HandleResult(result, callback))
{
if (result.userInfo != null)
{
if (result.userInfo.userId != userId || result.userInfo.disabled)
{
ScheduleCallback(SendErrorEvent, callback);
}
// Update state user info
// Note that signInProviderId and externalId are only available by sign-in
// They are not available by GetUser
m_State.userInfo.email = result.userInfo.email;
m_State.userInfo.displayName = result.userInfo.displayName;
m_State.userInfo.emailVerified = result.userInfo.emailVerified;
m_State.userInfo.isAnonymous = result.userInfo.isAnonymous;
if (result.userInfo.externalIds != null)
{
m_State.userInfo.externalIds = result.userInfo.externalIds;
}
if (!string.IsNullOrEmpty(result.userInfo.photoUrl))
{
m_State.userInfo.photoUrl = result.userInfo.photoUrl;
}
}
ScheduleCallback(SendGetUserEvent, callback);
}
});
}
private bool HandleLoginResult(PlayerIdentityBackendSubsystem.IdentityCallbackArgs result, PlayerIdentityCallback callback)
{
if (result.error != null)
{
m_State.status = LoginStatus.NotLoggedIn;
m_State.error = result.error;
ScheduleCallback(SendErrorEvent, callback);
return(false);
}
m_State.error = null;
if (result.userInfo != null)
{
m_State.userInfo = result.userInfo;
}
if (result.accessToken != null)
{
m_State.accessToken = result.accessToken;
}
if (m_State.userInfo == null)
{
m_State.status = LoginStatus.NotLoggedIn;
}
else
{
m_State.status = m_State.userInfo.isAnonymous ? LoginStatus.AnonymouslyLoggedIn : LoginStatus.LoggedIn;
}
return(true);
}
/// <summary>
/// HandleResult handles the result errors and updates user info and access token.
/// </summary>
private bool HandleResult(PlayerIdentityBackendSubsystem.IdentityCallbackArgs result, PlayerIdentityCallback callback)
{
if (result.error != null)
{
m_State.error = result.error;
ScheduleCallback(SendErrorEvent, callback);
return(false);
}
m_State.error = null;
if (result.userInfo != null)
{
m_State.userInfo = result.userInfo;
}
if (result.accessToken != null)
{
m_State.accessToken = result.accessToken;
}
return(true);
}
