public static void LoginAsGuestInBackground(Action <BacktoryResponse <LoginResponse> > callback)
{
// Simplifying this by removing "BacktoryUser" type parameter leads to error though compiler suggests, but why?!
Backtory.RestClient.ExecuteAsync <BacktoryUser>(GuestRegisterRequest(), response =>
{
// **this part will be called on background thread! (Since we're using restsharp async method)**
// if guest register failed don't proceed to login
if (!response.IsSuccessful())
{
Backtory.Dispatch(() => BacktoryResponse <LoginResponse> .Unknown(response.ErrorMessage));
return;
}
var guest = response.Data;
var loginResponse = Backtory.Execute <LoginResponse>(LoginRequest(guest.Username, guest.Password));
if (loginResponse.Successful)
{
DispatchSaveCurrentUser(guest);
DispatchSaveGuestPassword(guest.Password);
DispatchSaveLoginInfo(loginResponse.Body);
}
Backtory.Dispatch(() => callback(loginResponse));
});
}
private BacktoryResponse <ConnectResponse> connectSynchronized()
{
connectLatch = new CountDownLatch(LATCH_COUNT);
Debug.Log(TAG + "connecting");
connectorStateEngine.ChangeState(ConnectorStateEngine.StateChangeEvent.CONNECT);
try {
if (connectLatch.Wait(TIMEOUT_IN_SECONDS * 1000))
{
if (connectorStateEngine.getConnectionState() == ConnectorStateEngine.ConnectorState.CONNECTED)
{
ConnectResponse response = new ConnectResponse(webSocket.userId, webSocket.username);
return(BacktoryResponse <ConnectResponse> .Success((int)BacktoryHttpStatusCode.OK, response));
}
else
{
return(new BacktoryResponse <ConnectResponse> (1000, "Error connecting", default(ConnectResponse), false));
}
}
else
{
Debug.LogError(TAG + "Timeout waiting to connect");
connectorStateEngine.ChangeState(ConnectorStateEngine.StateChangeEvent.GENERAL_ERROR);
return(new BacktoryResponse <ConnectResponse> (1000, "Timeout waiting to connect", default(ConnectResponse), false));
}
} catch (Exception e) {
Debug.LogError(TAG + e.Data);
return(new BacktoryResponse <ConnectResponse> (1000, "Error while connecting", default(ConnectResponse), false));
}
}
public static void LoginInBackground(string username, string password,
Action <BacktoryResponse <LoginResponse> > callback)
{
Backtory.ExecuteAsync <LoginResponse>(LoginRequest(username, password), loginResopnse =>
{
// this will be called in main thread since we're using backtory API
if (loginResopnse.Successful)
{
Backtory.ExecuteAsync <BacktoryUser>(UserByUsernameRequest(username, loginResopnse.Body.AccessToken), userResponse =>
{
// also on main thread
if (userResponse.Successful)
{
//DispatchSaveCurrentUser(userResponse.Body);
//DispatchSaveLoginInfo(loginResopnse.Body);
SaveAsCurrentUserInMemoryAndStorage(userResponse.Body);
SaveLoginInfo(loginResopnse.Body);
callback(loginResopnse);
}
else
{
callback(BacktoryResponse <LoginResponse> .Unknown(userResponse.Message));
}
});
}
else
{
callback(loginResopnse);
}
});
}
/// <summary>
/// Create a new response from another, converting generic type
/// </summary>
/// <typeparam name="RAW"></typeparam>
/// <typeparam name="TRANSFORMED"></typeparam>
/// <param name="backtoryResponse"></param>
/// <returns></returns>
public static BacktoryResponse <TRANSFORMED> Error <RAW, TRANSFORMED>(BacktoryResponse <RAW> backtoryResponse)
where TRANSFORMED : class
where RAW : class
{
return(new BacktoryResponse <TRANSFORMED>(backtoryResponse.Code,
backtoryResponse.Message, /*backtoryResponse.Message*/ null, false));
}
internal BacktoryResponse <T> SendAndReceive <T> (string destination, Dictionary <string, object> apiParamData, Type clazz) where T : class
{
BacktorySender sender = GetSender(destination, apiParamData);
string responseStr;
try {
responseStr = sender.Send();
} catch (Exception) {
return(BacktoryResponse <T> .Error(1000, "Not Connected"));
}
return(GenerateBacktoryResponse <T> (responseStr, clazz));
}
private void createChatGroup(ChatGroupType type)
{
BacktoryResponse <ChatGroupCreationResponse> response = backtoryApi.CreateChatGroup(getMessage(), type);
if (response.Successful)
{
writeLine("--+group created. id: " + response.Body.GroupId);
}
else
{
writeLine("--+group creation failed with code: " + response.Code + " and message " + response.Message);
}
}
private void connect()
{
BacktoryResponse <ConnectResponse> response = backtoryApi.Connect();
if (response.Successful)
{
writeLine("---connected: " + response.Body.Username + ":" + response.Body.UserId);
}
else
{
writeLine("---connect failed with code: " + response.Code + " and message: " + response.Message);
}
}
private void addClickListeners()
{
btnEvent.onClick.AddListener(() => {
Dictionary <string, string> data = new Dictionary <string, string> ();
data.Add("key1", "added data 1");
data.Add("key2", "added data 2");
matchApi.SendEvent(getMessage(), data);
});
btnGroupChat.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = matchApi.SendChatToMatch(getMessage());
if (response.Successful)
{
writeLine("-+-match chat sent");
}
else
{
writeLine("-+-group list failed with code: " + response.Code + " and message " + response.Message);
}
});
btnDirectChat.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = matchApi.DirectToUser(getUserId(), getMessage());
if (response.Successful)
{
writeLine("-+-direct chat sent");
}
else
{
writeLine("-+-direct chat failed with code: " + response.Code + " and message " + response.Message);
}
});
btnSendResult.onClick.AddListener(() => {
List <string> winners = new List <string> ();
winners.Add(getUserId());
BacktoryResponse <BacktoryVoid> response = matchApi.SendMatchResult(winners);
if (response.Successful)
{
writeLine("-+-winners sent");
}
else
{
writeLine("-+-sending winners failed with code: " + response.Code + " and message " + response.Message);
}
});
}
private BacktoryResponse <T> GenerateBacktoryResponse <T> (string responseJson, Type clazz) where T : class
{
Debug.Log("jsonnode: " + responseJson);
if (responseJson == null)
{
return(BacktoryResponse <T> .Error((int)BacktoryHttpStatusCode.RequestTimeout, null));
}
JSONNode jsonNode = JSONNode.Parse(responseJson);
string _type = jsonNode ["_type"];
if (_type.Equals(".ExceptionResponse"))
{
ExceptionResponse exceptionResponse = Backtory.FromJson <ExceptionResponse> (responseJson);
string message = exceptionResponse.Exception.Message;
int errorCode = (int)exceptionResponse.Exception.Code;
return(BacktoryResponse <T> .Error(errorCode, message));
}
else if (typeof(T).Equals(typeof(GroupChatHistoryResponse)))
{
T body = GroupChatHistoryResponse.Get(responseJson) as T;
return(BacktoryResponse <T> .Success(200, body));
}
else if (typeof(T).Equals(typeof(UserChatHistoryResponse)))
{
T body = UserChatHistoryResponse.Get(responseJson) as T;
return(BacktoryResponse <T> .Success(200, body));
}
else if (typeof(T).Equals(typeof(OfflineMessageResponse)))
{
T body = OfflineMessageResponse.Get(responseJson) as T;
return(BacktoryResponse <T> .Success(200, body));
}
else
{
T body;
if (clazz != typeof(BacktoryVoid))
{
body = Backtory.FromJson(responseJson, clazz) as T;
}
else
{
body = default(BacktoryVoid) as T;
}
return(BacktoryResponse <T> .Success(200, body));
}
}
public static BacktoryResponse <LoginResponse> LoginAsGuest()
{
var regResponse = Backtory.Execute <BacktoryUser>(GuestRegisterRequest());
if (!regResponse.Successful)
{
return(BacktoryResponse.Error <BacktoryUser, LoginResponse>(regResponse));
}
var guest = regResponse.Body;
var loginResponse = Backtory.Execute <LoginResponse>(LoginRequest(guest.Username, guest.Password));
if (loginResponse.Successful)
{
DispatchSaveCurrentUser(guest);
DispatchSaveGuestPassword(guest.Password);
DispatchSaveLoginInfo(loginResponse.Body);
}
return(loginResponse);
}
public static BacktoryResponse <LoginResponse> Login(string username, string password)
{
var loginResponse = Backtory.Execute <LoginResponse>(LoginRequest(username, password));
if (loginResponse.Successful)
{
var userResponse = Backtory.Execute <BacktoryUser>(UserByUsernameRequest(username, loginResponse.Body.AccessToken));
if (userResponse.Successful)
{
DispatchSaveCurrentUser(userResponse.Body);
DispatchSaveLoginInfo(loginResponse.Body);
}
else
{
BacktoryResponse <LoginResponse> .Unknown(userResponse.Message);
Debug.Log("error getting user info by username\n" + userResponse.Message);
}
}
return(loginResponse);
}
private BacktoryResponse <BacktoryVoid> disconnectSyncronized()
{
disconnectLatch = new CountDownLatch(LATCH_COUNT);
Debug.Log(TAG + "disconnecting");
connectorStateEngine.ChangeState(ConnectorStateEngine.StateChangeEvent.DISCONNECT);
try {
if (disconnectLatch.Wait(TIMEOUT_IN_SECONDS * 1000))
{
return(BacktoryResponse <BacktoryVoid> .Success(200, default(BacktoryVoid)));
}
else
{
Debug.LogError(TAG + "Timeout waiting to connect");
connectorStateEngine.ChangeState(ConnectorStateEngine.StateChangeEvent.GENERAL_ERROR);
return(new BacktoryResponse <BacktoryVoid> (1000, "Timeout waiting to connect", default(BacktoryVoid), false));
}
} catch (Exception e) {
Debug.LogError(TAG + e.Data);
return(new BacktoryResponse <BacktoryVoid> (1000, "Error while connecting", default(BacktoryVoid), false));
}
}
// Use this for initialization
void Start()
{
// UnityThreadHelper.EnsureHelperForce ();
matchApi = BacktoryRealtimeUnityApi.GetMatchApi(MainScript.LastFoundedGameId);
matchApi.SetRealtimeSdkListener(this);
matchApi.SetMatchListener(this);
addClickListeners();
// TODO use better name like JoinAndStart or ConnectAndJoin
BacktoryResponse <ConnectResponse> response = matchApi.ConnectAndJoin();
if (response.Successful)
{
writeLine("---connected: " + response.Body.Username + ":" + response.Body.UserId);
}
else
{
writeLine("---connect failed with code: " + response.Code + " and message: " + response.Message);
}
}
private void addClickListeners()
{
btnCreatePri.onClick.AddListener(() => {
createChatGroup(ChatGroupType.Private);
});
btnCreatePub.onClick.AddListener(() => {
createChatGroup(ChatGroupType.Public);
});
btnListGroups.onClick.AddListener(() => {
BacktoryResponse <ChatGroupsListResponse> response = backtoryApi.RequestListOfChatGroups();
if (response.Successful)
{
writeLine("--+group list returned with json: " + Backtory.ToJson(response.Body, true));
}
else
{
writeLine("--+group list failed with code: " + response.Code + " and message " + response.Message);
}
});
btnListMembers.onClick.AddListener(() => {
BacktoryResponse <ChatGroupMembersListResponse> response = backtoryApi.RequestListOfChatGroupMembers(getGroupId());
if (response.Successful)
{
writeLine("--+group member list returned with json: " + Backtory.ToJson(response.Body, true));
}
else
{
writeLine("--+group member list failed with code: " + response.Code + " and message " + response.Message);
}
});
btnAddMember.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.AddMemberToChatGroup(getGroupId(), getUserId());
if (response.Successful)
{
writeLine("--+member added");
}
else
{
writeLine("--+member adding failed with code: " + response.Code + " and message " + response.Message);
}
});
btnRemoveMember.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.RemoveMemberFromChatGroup(getGroupId(), getUserId());
if (response.Successful)
{
writeLine("--+member removed");
}
else
{
writeLine("--+member removing failed with code: " + response.Code + " and message " + response.Message);
}
});
btnAddOwner.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.AddOwnerToChatGroup(getGroupId(), getUserId());
if (response.Successful)
{
writeLine("--+owner added");
}
else
{
writeLine("--+owner adding failed with code: " + response.Code + " and message " + response.Message);
}
});
btnGroupChat.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.SendChatToGroup(getGroupId(), getMessage());
if (response.Successful)
{
writeLine("--+group chat sent");
}
else
{
writeLine("--+group chat sending failed with code: " + response.Code + " and message " + response.Message);
}
});
btnDirectChat.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.SendChatToUser(getUserId(), getMessage());
if (response.Successful)
{
writeLine("--+direct chat sent");
}
else
{
writeLine("--+direct chat sending failed with code: " + response.Code + " and message " + response.Message);
}
});
btnJoin.onClick.AddListener(() => {
string groupId = getGroupId();
BacktoryResponse <BacktoryVoid> response = backtoryApi.JoinChatGroup(groupId);
if (response.Successful)
{
writeLine("--+you joined to group with id " + groupId);
}
else
{
writeLine("--+group creation failed with code: " + response.Code + " and message " + response.Message);
}
});
btnLeave.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.LeaveChatGroup(getGroupId());
if (response.Successful)
{
writeLine("--+you left chat group");
}
else
{
writeLine("--+group leaving failed with code: " + response.Code + " and message " + response.Message);
}
});
btnInvite.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.InviteUserToChatGroup(getGroupId(), getUserId());
if (response.Successful)
{
writeLine("--+invitation sent");
}
else
{
writeLine("--+invitation sending failed with code: " + response.Code + " and message " + response.Message);
}
});
btnOffline.onClick.AddListener(() => {
BacktoryResponse <OfflineMessageResponse> response = backtoryApi.RequestOfflineMessages();
if (response.Successful)
{
writeLine("--+offline list: ");
List <ChatMessage> list = response.Body.ChatMessageList;
for (int i = 0; i < list.Count; i++)
{
list[i].OnMessageReceived(this);
}
}
else
{
writeLine("--+offline request failed with code: " + response.Code + " and message " + response.Message);
}
});
btnGroupHist.onClick.AddListener(() => {
BacktoryResponse <GroupChatHistoryResponse> response = backtoryApi.RequestGroupChatHistory(getGroupId(), lastGroupDate);
if (response.Successful)
{
writeLine("--+group history");
List <ChatMessage> list = response.Body.ChatMessageList;
if (list.Count > 0)
{
lastGroupDate = list[list.Count - 1].Date;
}
else
{
lastGroupDate = 0;
}
for (int i = 0; i < list.Count; i++)
{
list[i].OnMessageReceived(this);
}
}
else
{
writeLine("--+group history request failed with code: " + response.Code + " and message " + response.Message);
}
});
btnDirectHist.onClick.AddListener(() => {
BacktoryResponse <UserChatHistoryResponse> response = backtoryApi.RequestUserChatHistory(lastDirectDate);
if (response.Successful)
{
writeLine("--+direct history");
List <ChatMessage> list = response.Body.ChatMessageList;
if (list.Count > 0)
{
lastDirectDate = list[list.Count - 1].Date;
}
else
{
lastDirectDate = 0;
}
for (int i = 0; i < list.Count; i++)
{
list[i].OnMessageReceived(this);
}
}
else
{
writeLine("--+direct history request failed with code: " + response.Code + " and message " + response.Message);
}
});
btnReturn.onClick.AddListener(() => {
int previousLevel = PlayerPrefs.GetInt("MainLevel");
Application.LoadLevel(previousLevel);
});
}
private void addClickListeners()
{
btnLogin.onClick.AddListener(() => {
string username = ifUsername.text;
string password = ifPassword.text;
BacktoryUser.LoginInBackground(username, password, loginResponse =>
{
if (loginResponse.Successful)
{
writeLine("logged in!");
}
else
{
writeLine("Unable to login=> " + loginResponse.Code + ":" + loginResponse.Message);
}
});
});
btnConnect.onClick.AddListener(() => {
Debug.Log("AccessToken: " + BacktoryUser.GetAccessToken());
if (BacktoryUser.GetAccessToken() == null)
{
writeLine("login first");
return;
}
connect();
});
btnDisconnect.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.Disconnect();
if (response.Successful)
{
writeLine("---disconnect successful");
}
else
{
writeLine("---disconnect failed with code: " + response.Code + " and message " + response.Message);
}
});
btnMatchmaking.onClick.AddListener(() => {
BacktoryResponse <MatchmakingResponse> response = backtoryApi.RequestMatchmaking(matchmakingName, 55, "sample meta data");
if (response.Successful)
{
lastMatchmakingRequestId = response.Body.RequestId;
writeLine("---matchmaking successful. id: " + lastMatchmakingRequestId);
}
else
{
writeLine("---matchmaking failed with code: " + response.Code + " and message " + response.Message);
}
});
btnCancelMM.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.CancelMatchmaking(matchmakingName, lastMatchmakingRequestId);
if (response.Successful)
{
writeLine("---matchmaking cancelled successful.");
}
else
{
writeLine("---matchmaking cancellation failed with code: " + response.Code + " and message " + response.Message);
}
});
btnChallenge.onClick.AddListener(() => {
List <String> users = new List <String> ();
users.Add("5720b016e4b0bf11f90cdee6"); // ali
users.Add("5720b01be4b0bf11f90cdee7"); // mamad
users.Add("5720b01ee4b0bf11f90cdee8"); // farib
BacktoryResponse <ChallengeResponse> response = backtoryApi.RequestChallenge(users, 15, 2);
if (response.Successful)
{
writeLine("---challenge request successful. challenge id: " + response.Body.ChallengeId);
}
else
{
writeLine("---challenge request failed with code: " + response.Code + " and message " + response.Message);
}
});
btnChallengeList.onClick.AddListener(() => {
BacktoryResponse <ActiveChallengesListResponse> response = backtoryApi.RequestListOfActiveChallenges();
if (response.Successful)
{
writeLine("---active challenges list json: " + Backtory.ToJson((response.Body), true));
}
else
{
writeLine("---active challenges list failed with code: " + response.Code + " and message " + response.Message);
}
});
btnAccept.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.AcceptChallenge(lastChallengeInvitationId);
if (response.Successful)
{
writeLine("---challenge accepted successful.");
}
else
{
writeLine("---accepting challenge failed with code: " + response.Code + " and message " + response.Message);
}
});
btnDecline.onClick.AddListener(() => {
BacktoryResponse <BacktoryVoid> response = backtoryApi.DeclineChallenge(lastChallengeInvitationId);
if (response.Successful)
{
writeLine("---challenge declined successful.");
}
else
{
writeLine("---declining challenge failed with code: " + response.Code + " and message " + response.Message);
}
});
btnChat.onClick.AddListener(() => SceneManager.LoadScene("ChatScene"));
}
