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 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 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);
}
// +++ nakama event handler +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private void OnConnectedToNakamaServer(INSession currentSession)
{
if (currentSession != null)
{
nakamaSession = currentSession;
_connected = true;
}
}
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();
}
}
private string getWebsocketUri(INSession session)
{
// Init base WebSocket connection
var scheme = (SSL) ? "wss" : "ws";
var bUri = new UriBuilder(scheme, Host, unchecked ((int)Port), "api");
bUri.Query = String.Format("token={0}&lang={1}", session.Token, Lang);
return(bUri.Uri.ToString());
}
public void OnSessionConnected(INSession session)
{
Debug.Log("On Session Connected");
Enqueue(() =>
{
Debug.Log("Main thread");
pageLogin.enabled = false;
pageMatchMaking.enabled = true;
}
);
}
private void SessionHandler(INSession session)
{
Debug.LogFormat("Session: '{0}'.", session.Token);
_session = session;
_client.Connect(_session, (bool done) => {
Debug.Log("Session connected.");
// We'll set a UI label from the socket.
_uiLabelMessage = "Connected.";
// Store session for quick reconnects.
PlayerPrefs.SetString("nk.session", session.Token);
});
}
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);
});
}
private NakamaManager()
{
_client = new NClient.Builder(ServerKey).Host(HostIp).Port(Port).SSL(UseSsl).Build();
_client.OnTopicMessage = message =>
{
var chatMessages = StateManager.Instance.ChatMessages;
foreach (var topic in chatMessages.Keys)
{
if (topic.Id.Equals(message.Topic.Id))
{
chatMessages[topic].Add(message.MessageId, message);
}
}
};
_sessionHandler = session =>
{
Logger.LogFormat("Session: '{0}'.", session.Token);
_client.Connect(session, done =>
{
Session = session;
_reconnectCount = 0;
// cache session for quick reconnects
_dispatchQueue.Enqueue(() =>
{
PlayerPrefs.SetString("nk.session", session.Token);
AfterConnected(this, EventArgs.Empty);
});
});
};
_client.OnDisconnect = evt =>
{
Logger.Log("Disconnected from server.");
if (_doReconnect && _reconnectCount < MaxReconnectAttempts)
{
_reconnectCount++;
_dispatchQueue.Enqueue(() => { Reconnect(); });
}
else
{
_dispatchQueue.Clear();
_dispatchQueue.Enqueue(() => { AfterDisconnected(this, EventArgs.Empty); });
}
};
_client.OnError = error => ErrorHandler(error);
}
private void SessionHandler(INSession session)
{
_session = session;
Debug.LogFormat("Session: '{0}'.", session.Token);
_client.Connect(_session, (bool done) => {
// We enqueue callbacks which contain code which must be dispatched on
// the Unity main thread.
// foreach(Action a in OnSessionConnectedActions) {
// a();
// }
Enqueue(() => {
Debug.Log("Session connected.");
// Store session for quick reconnects.
onSessionConnected(session);
PlayerPrefs.SetString("nk.session", session.Token);
});
});
}
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);
}
// This initializes the server with fake data so that views are not empty when loaded.
// This assumes that the current user is connected to the system.
public static void Init()
{
if (_initializedFakeData)
{
return;
}
Client.Register(BuildAuthenticationMessage(), session =>
{
_user1Session = session;
Client.Connect(_user1Session, c =>
{
SetupUser1();
Client.Disconnect();
Client.Register(BuildAuthenticationMessage(), session2 =>
{
_user2Session = session2;
Client.Connect(_user2Session, c2 =>
{
SetupUser2();
Client.Disconnect();
Client.Register(BuildAuthenticationMessage(), session3 =>
{
_user3Session = session3;
Client.Connect(_user3Session, c3 =>
{
SetupUser3();
Client.Disconnect();
SetupMainUser();
_initializedFakeData = true;
});
}, ErrorHandler);
});
}, ErrorHandler);
});
}, ErrorHandler);
}
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);
}
void OnServerSessionCreatedOrRestored(INSession session)
{
Debug.Log("Session created or restored");
client.Connect(session, OnConnected);
}
// clear all application cached data
public static void clear()
{
session = null;
client = null;
data = new Dictionary <string, Object> ();
}
public void Connect(INSession session, Action <bool> callback)
{
transport.ConnectAsync(getWebsocketUri(session), callback);
}
public void Connect(INSession session)
{
transport.Connect(getWebsocketUri(session));
}
public void Connect(INSession session)
{
transport.Connect(getWebsocketUri(session), session.UdpToken);
}
public void Connect(INSession session, Action <bool> callback)
{
_client.Connect(session, (bool done) => {
Enqueue(() => callback(done));
});
}
public void Connect(INSession session)
{
_client.Connect(session);
}