public void Register(object userData, Action <INSession> successCallback, Action <INError> failCallback)
{
string id;
if (userData == null)
{
id = Guid.NewGuid().ToString();
}
else
{
if (userData.GetType() != typeof(Guid))
{
throw new ArgumentException("Userdata has to be typeof (Guid).");
}
id = ((Guid)userData).ToString();
}
var authenticationMessage = NAuthenticateMessage.Device(id);
_client.Register(
authenticationMessage,
successCallback,
failCallback
);
}
public void GetFriendId()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
var client2 = new NClient.Builder(DefaultServerKey).Build();
var message = NAuthenticateMessage.Device(DeviceId);
client2.Register(message, (INSession friendSession) =>
{
client2.Connect(friendSession);
var selfMessage = NSelfFetchMessage.Default();
client2.Send(selfMessage, (INSelf result) =>
{
UserId = result.Id;
client2.Logout();
}, (INError err) => {
error = err;
});
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(5000, false);
Assert.IsNull(error);
}
public void LoginGoogle_Invalid([ValueSource("BlankCases")] string oauthToken)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Google(oauthToken);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
if (oauthToken == string.Empty)
{
Assert.AreEqual("Access token is required", result.Message);
}
else
{
Assert.AreEqual("Invalid Google access token, no spaces or control characters allowed", result.Message);
}
}
public void LoginDevice_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
string id = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession _) =>
{
client.Login(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(1000, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
private void LoginOrRegister()
{
// See if we have a cached id in PlayerPrefs.
var id = PlayerPrefs.GetString("nk.id");
if (string.IsNullOrEmpty(id))
{
// We'll use device ID for the user account. Have a look at the docs
// for other options: https://heroiclabs.com/docs/development/authentication/
id = SystemInfo.deviceUniqueIdentifier;
// Store the identifier for next game start.
PlayerPrefs.SetString("nk.id", id);
}
var message = NAuthenticateMessage.Device(id);
_client.Login(message, SessionHandler, (INError error) => {
if (error.Message.Equals("ID not found"))
{
_client.Register(message, SessionHandler, ErrorHandler);
return;
}
Debug.LogErrorFormat("Login error: code '{0}' - '{1}'.", error.Code, error.Message);
});
}
public void RegisterCustom_Invalid([ValueSource("BlankCases")] string id)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Custom(id);
client.Register(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
if (id == string.Empty)
{
Assert.AreEqual("Custom ID is required", result.Message);
}
else
{
Assert.AreEqual("Invalid custom ID, no spaces or control characters allowed", result.Message);
}
}
public void LoginEmail_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
string piece = random.GetString().Substring(8);
string email = String.Format("{0}@{0}.com", piece);
string password = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Register(message, (INSession _) =>
{
client.Login(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(1000, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
public void LoginEmail_Invalid([ValueSource("BlankCases")] string email,
[ValueSource("BlankCases")] string password)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
if (email == string.Empty)
{
Assert.AreEqual("Email address is required", result.Message);
}
else
{
Assert.AreEqual("Invalid email address, no spaces or control characters allowed", result.Message);
}
}
public void SetUp()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
client = new NClient.Builder(DefaultServerKey).Build();
var message = NAuthenticateMessage.Device(DeviceId);
client.Login(message, (INSession session) =>
{
userId = session.Id;
client.Connect(session);
evt.Set();
}, (INError err) => {
client.Register(message, (INSession session) =>
{
userId = session.Id;
client.Connect(session);
evt.Set();
}, (INError err2) => {
error = err2;
evt.Set();
});
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
}
public void ClientRegister()
{
if (userNameInputField.text.Length < 8)
{
loginErrorString = "Invalid UserName. Must be at least 8 characters!";
return;
}
if (serverIPInputField.text.Length < 11)
{
loginErrorString = "Invalid IP!";
return;
}
ServerIP = serverIPInputField.text;
ClientBuilder();
deviceID = userNameInputField.text;
Debug.Log("Logging in as: " + deviceID + " to IP: " + ServerIP);
PlayerPrefs.SetString("UserName", deviceID);
ManualResetEvent registerEvent = new ManualResetEvent(false);
//Register and connect client
Debug.Log("Trying to register");
var request = NAuthenticateMessage.Device(deviceID);
client.Register(request, (INSession session) =>
{
this.session = session;
ServerInstance.session = session;
client.Connect(session);
clientConnected = true;
NakamaData.Singleton.Session = session;
registerEvent.Set();
}, (INError err) =>
{
if (err.Code == ErrorCode.AuthError)
{
loginErrorString = "This UserName is already registered!";
}
else
{
loginErrorString = "ID register " + deviceID + " failed: " + err;
}
registerEvent.Set();
});
registerEvent.WaitOne(1000, false);
if (clientConnected)
{
FetchClientInfo();
UpdateUserInfo();
JoinDefaultRoom();
CompleteLogin();
}
}
public void ClientLogin()
{
if (userNameInputField.text.Length < 10)
{
loginErrorString = "Invalid UserName. Must be at least 10 characters. UserName entered was only " + userNameInputField.text.Length + " characters";
return;
}
if (serverIPInputField.text.Length < 11)
{
loginErrorString = "Invalid IP!";
return;
}
ServerIP = serverIPInputField.text;
ClientBuilder(); //Build the Nakama client object
deviceID = userNameInputField.text;
Debug.Log("Logging in as: " + deviceID + " to IP: " + ServerIP);
PlayerPrefs.SetString("UserName", deviceID);
//Allows us to wait until the register check is complete before moving onto login
ManualResetEvent loginEvent = new ManualResetEvent(false);
////Try to Login
var request = NAuthenticateMessage.Device(deviceID);
client.Login(request, (INSession session) =>
{
if (ServerInstance.session == session)
{
loginErrorString = "This user is already logged in!";
loginEvent.Set();
return;
}
//outputText += "Player logged in successfully. ID: " + deviceID.ToString() + "\n";
this.session = session;
ServerInstance.session = session;
client.Connect(session);
clientConnected = true;
NakamaData.Singleton.Session = session;
loginEvent.Set();
}, (INError err) =>
{
loginErrorString = "Player failed to login! ID: " + deviceID.ToString() + " Error: " + err.ToString() + "\n";
loginEvent.Set();
});
loginEvent.WaitOne(1000, false);
if (clientConnected)
{
FetchClientInfo();
UpdateUserInfo();
JoinDefaultRoom();
CompleteLogin();
}
}
public void Player2RegisterClick()
{
var request = NAuthenticateMessage.Email(EMAIL, PASSWORD);
client2.Register(request, (INSession session) => {
Debug.Log("Player 2 Registration successful");
RegisterButtonPlayer2Enable = false;
}, (INError error) => {
Debug.LogErrorFormat("Email register '{0}' failed: {1}", EMAIL, error);
});
}
public void Player1RegisterClick()
{
string id = SystemInfo.deviceUniqueIdentifier;
var request = NAuthenticateMessage.Device(id);
client1.Register(request, (INSession session) => {
Debug.Log("Player 1 Registration successful");
RegisterButtonPlayer1Enable = false;
}, (INError error) => {
Debug.LogErrorFormat("ID register '{0}' failed: {1}", id, error);
});
}
private static NAuthenticateMessage BuildDeviceAuthenticateMessage()
{
var id = PlayerPrefs.GetString("nk.deviceid");
if (string.IsNullOrEmpty(id))
{
id = SystemInfo.deviceUniqueIdentifier;
PlayerPrefs.SetString("nk.deviceid", id);
}
Debug.LogFormat("Device Id: '{0}'.", id);
return(NAuthenticateMessage.Device(id));
}
// register button clicked
public void RegisterBtnClick()
{
// register
var request = NAuthenticateMessage.Email(this.emailInput.text, this.passwordInput.text);
Application.client.Register(request, (INSession session) => {
Debug.Log("Player Registration successful");
msg = "Player Registration successful";
}, (INError error) => {
Debug.LogErrorFormat("Email register '{0}' failed: {1}", this.emailInput.text, error);
msg = "Player Registration failed";
});
}
public void Player2LoginClick()
{
var request = NAuthenticateMessage.Email(EMAIL, PASSWORD);
client2.Login(request, (INSession session) => {
Debug.Log("Player 2 Logged in successfully");
this.session2 = session;
RegisterButtonPlayer2Enable = false;
LoginButtonPlayer2Enable = false;
ConnectPlayer2Enable = true;
}, (INError error) => {
Debug.LogErrorFormat("Email login '{0}' failed: {1}", EMAIL, error);
});
}
public void Player1LoginClick()
{
string id = SystemInfo.deviceUniqueIdentifier;
var request = NAuthenticateMessage.Device(id);
client1.Login(request, (INSession session) => {
Debug.Log("Player 1 Logged in successfully");
this.session1 = session;
RegisterButtonPlayer1Enable = false;
LoginButtonPlayer1Enable = false;
ConnectPlayer1Enable = true;
}, (INError error) => {
Debug.LogErrorFormat("ID login '{0}' failed: {1}", id, error);
});
}
public void GetFriendId()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
var client2 = new NClient.Builder(DefaultServerKey).Build();
client2.OnDisconnect = (INDisconnectEvent _) =>
{
var message = NAuthenticateMessage.Device(DeviceId);
client2.Register(message, (INSession session) =>
{
MyUserId = ((NSession)session).Id;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
};
var friendAuthMessage = NAuthenticateMessage.Device(random.GetString());
client2.Register(friendAuthMessage, (INSession friendSession) =>
{
FriendUserId = ((NSession)friendSession).Id;
client2.Connect(friendSession);
var message = new NGroupCreateMessage.Builder(GroupName)
.Description(GroupDescription)
.Lang("fa")
.Private(PrivateGroup)
.Build();
client2.Send(message, (INResultSet <INGroup> result) =>
{
FriendGroup = result.Results[0];
client2.Logout();
}, (INError err) => {
error = err;
});
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(5000, false);
Assert.IsNull(error);
}
public void CheckTestLeaderboardExists()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
var client2 = new NClient.Builder(DefaultServerKey).Build();
var message = NAuthenticateMessage.Device(DeviceId);
client2.Register(message, (INSession ses) =>
{
client2.Connect(ses);
var selfMessage = NSelfFetchMessage.Default();
client2.Send(selfMessage, (INSelf self) =>
{
this.self = self;
var leaderboardListMessage = new NLeaderboardsListMessage.Builder().Build();
client2.Send(leaderboardListMessage, (INResultSet <INLeaderboard> results) =>
{
bool found = false;
foreach (var leaderboard in results.Results)
{
if (LeaderboardId.Equals(leaderboard.Id))
{
serverLeaderboardId = leaderboard.Id;
found = true;
break;
}
}
client2.Logout();
Assert.IsTrue(found, "Leaderboard not found. Setup the leaderboard ('{0}') in Nakama and run this test again.", LeaderboardIdName);
evt.Set();
}, (INError err) => {
error = err;
evt.Set();
});
}, (INError err) => {
error = err;
evt.Set();
});
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(5000, false);
Assert.IsNull(error);
}
// login button clicked
public void LoginBtnClick()
{
// login
var request = NAuthenticateMessage.Email(this.emailInput.text, this.passwordInput.text);
Application.client.Login(request, (INSession session) => {
Debug.Log("Player Logged in successfully");
msg = "Player Logged in successfully";
// save session
Application.session = session;
// connect client
Application.client.Connect(session);
// get self informations
this.PlayerGetSelf();
}, (INError error) => {
Debug.LogErrorFormat("Email login '{0}' failed: {1}", this.emailInput.text, error);
msg = "Player Logged in failed";
});
}
public void GetFriendId()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
var client2 = new NClient.Builder(DefaultServerKey).Build();
client2.OnDisconnect = (INDisconnectEvent _) =>
{
var message = NAuthenticateMessage.Device(DeviceId);
client2.Register(message, (INSession session) =>
{
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
};
var friendAuthMessage = NAuthenticateMessage.Device(random.GetString());
client2.Register(friendAuthMessage, (INSession friendSession) =>
{
client2.Connect(friendSession);
var friendSelfMessage = NSelfFetchMessage.Default();
client2.Send(friendSelfMessage, (INSelf result) =>
{
FriendUserId = result.Id;
FriendHandle = result.Handle;
client2.Logout();
}, (INError err) => {
error = err;
});
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(5000, false);
Assert.IsNull(error);
}
private static INError RegisterEmailError(string email, string password)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Register(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
return(result);
}
public void ReadPublicStorageOtherUsers()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageData> storageData = null;
INError error = null;
var client2 = new NClient.Builder(DefaultServerKey).Build();
var regMessage = NAuthenticateMessage.Custom(CustomId);
client2.Register(regMessage, (INSession friendSession) =>
{
client2.Connect(friendSession);
var message = new NStorageFetchMessage.Builder()
.Fetch(Bucket, Collection, Record, UserId)
.Build();
client2.Send(message, (INResultSet <INStorageData> results) =>
{
storageData = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(2000, false);
Assert.IsNull(error);
Assert.NotNull(storageData);
Assert.NotNull(storageData.Results);
Assert.AreEqual(1, storageData.Results.Count);
Assert.NotNull(storageData.Results[0]);
Assert.AreEqual(Bucket, storageData.Results[0].Bucket);
Assert.AreEqual(Collection, storageData.Results[0].Collection);
Assert.AreEqual(Record, storageData.Results[0].Record);
Assert.AreEqual(StorageValue, storageData.Results[0].Value);
}
public void LoginSteam_Invalid([ValueSource("BlankCases")] string sessionToken)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Steam(sessionToken);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("Steam login not available", result.Message);
}
public void RegisterCustom_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Custom(random.GetString());
client.Register(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
public void ClientWithServerKey_Invalid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = new NClient.Builder("notvalid").Build();
var message = NAuthenticateMessage.Device("mydeviceid");
client.Register(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("Invalid server key", result.Message);
}
public void LoginDevice_Invalid_NoId()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
string id = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("ID not found", result.Message);
}
public void SetUp()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
client = new NClient.Builder(DefaultServerKey).Build();
string id = TestContext.CurrentContext.Random.GetString();
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession authenticated) =>
{
session = authenticated;
client.Connect(session);
evt.Set();
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
}
// +++ ICustomAuthenticator implementation ++++++++++++++++++++++++++++++++++++++++++++++++++++
public void Login(object userData, Action <INSession> successCallback, Action <INError> failCallback)
{
string id;
if (userData == null)
{
id = System.Guid.NewGuid().ToString();
}
else
{
if (userData.GetType() != typeof(Guid))
{
throw new ArgumentException("Userdata has to be typeof (Guid).");
}
id = ((Guid)userData).ToString();
}
var authenticationMessage = NAuthenticateMessage.Device(id);
_client.Login(authenticationMessage,
successCallback,
(INError error) =>
{
if (error.Code == ErrorCode.UserNotFound)
{
_client.Register(
authenticationMessage,
successCallback,
failCallback
);
}
else
{
failCallback(error);
}
}
);
}
public void LoginOrRegisterWithCustomId(string customId, Action onLoginSucceeded, Action onLoginError)
{
var message = NAuthenticateMessage.Custom(customId);
_client.Login(message,
(INSession session) =>
{
Debug.Log("Login Callback");
SessionHandler(session);
},
(INError err) =>
{
if (err.Code == ErrorCode.UserNotFound)
{
_client.Register(message, SessionHandler, ErrorHandler);
}
else
{
ErrorHandler(err);
}
}
);
}
