private void OnConnDisconnected(object sender, FizzMqttDisconnectedArgs args)
{
FizzLogger.D("MQTT - OnDisconnected: " + args.ClientWasConnected.ToString());
if (OnDisconnected != null)
{
if (args.Exception == null)
{
OnDisconnected.Invoke(null);
}
else
{
if (args.Exception.GetType() == typeof(FizzMqttAuthException))
{
OnDisconnected.Invoke(ERROR_AUTH_FAILED);
if (_sessionRepo != null)
{
_sessionRepo.FetchToken(null);
}
}
else
{
OnDisconnected.Invoke(ERROR_CONNECTION_FAILED);
}
}
}
if (_closeCallback != null)
{
FizzUtils.DoCallback(_closeCallback);
}
}
public void ProductPurchased(string productId, double amount, string currency, string receipt)
{
IfOpened(() =>
{
FizzLogger.D("Product Purchased => id:" + productId + " amount:" + amount + " currency:" + currency + " receipt:" + receipt);
JSONClass fields = new JSONClass();
if (productId != null)
{
fields["product_id"] = productId;
}
if (currency != null)
{
fields["currency"] = currency;
}
if (receipt != null)
{
fields["receipt"] = receipt;
}
fields["amount"].AsDouble = amount;
_eventLog.Put(BuildEvent(_sessionId, FizzEventType.product_purchased, FizzUtils.Now() + _timeOffset, fields));
});
}
private void OnConnDisconnected(int connId, object sender, MqttClientDisconnectedEventArgs args)
{
if (_connection != null && _connection.Id != connId)
{
FizzLogger.W("Received disconnected event for old connection.");
}
FizzLogger.D("MQTT - OnDisconnected: " + args.ClientWasConnected.ToString());
if (OnDisconnected != null)
{
if (args.Exception == null)
{
OnDisconnected.Invoke(null);
}
else
{
if (args.Exception.GetType() == typeof(MQTTnet.Adapter.MqttConnectingFailedException))
{
OnDisconnected.Invoke(ERROR_AUTH_FAILED);
if (_sessionRepo != null)
{
_sessionRepo.FetchToken(null);
}
}
else
{
OnDisconnected.Invoke(ERROR_CONNECTION_FAILED);
}
}
}
}
public void HandleConnect()
{
try
{
if (FizzService.Instance.IsConnected)
{
return;
}
FizzService.Instance.Open(
userIdInputField.text, //UserId
userNameInputField.text, //UserName
FizzLanguageCodes.AllLanguages[langCodeDropDown.value], //LanguageCode
FizzServices.All,
translationToggle.isOn, //Translation
(success) =>
{
if (success)
{
FizzLogger.D("FizzClient Opened Successfully!!");
FizzService.Instance.SubscribeChannel(hypercasualInputChannel);
}
});
}
catch { FizzLogger.E("Unable to connect to Fizz!"); }
}
private void UpdateStatus(string status)
{
if (_message == null)
{
return;
}
// Update message with updated data
try
{
Dictionary <string, string> data = _message.Data;
data[CustomCellSample.KEY_DATA_STATUS] = status;
FizzService.Instance.Client.Chat.UpdateMessage(_message.To, _message.Id, _message.Nick, _message.Body, string.Empty, data, false, false, true, ex =>
{
if (ex == null)
{
FizzLogger.D("Status Updated");
}
});
}
catch
{
FizzLogger.E("Something went wrong while calling UpdateMessage of FizzService.");
}
}
private void OnConnConnected(object sender, bool sessionPresent)
{
FizzLogger.D("MQTT - OnConnected: " + sessionPresent);
if (OnConnected != null)
{
OnConnected.Invoke(!sessionPresent);
}
}
void HandleOpenButton()
{
FizzService.Instance.Open(userId, userId, FizzLanguageCodes.English, FizzServices.All, false, isDone =>
{
if (isDone)
{
FizzLogger.D("HandleOpenButton " + isDone);
}
});
}
private void SessionStarted()
{
FizzLogger.D("Session Started");
//Persist Session Start
UnityEngine.PlayerPrefs.SetString(KEY_SESSION, _sessionId);
UnityEngine.PlayerPrefs.SetString(KEY_SESSION_START_TS, (_startTime).ToString());
UnityEngine.PlayerPrefs.Save();
_eventLog.Put(BuildEvent(_sessionId, FizzEventType.session_started, _startTime, null));
}
private FizzUserUpdateEventData ParsePresenceUpdateEventData(FizzTopicMessage message)
{
JSONClass payload = JSONNode.Parse(message.Data).AsObject;
FizzUserUpdateEventData update = new FizzUserUpdateEventData();
FizzLogger.D(message.Data);
update.Reason = FizzUserUpdateEventData.UpdateReason.Presence;
update.UserId = message.From;
update.Online = payload["is_online"].AsBool;
return(update);
}
private void SessionEnded(string sessionId, long sessionStartTime, long sessionEndTime)
{
JSONClass fields = new JSONClass();
long duration = (sessionEndTime - sessionStartTime) / 1000;
fields["duration"].AsDouble = duration;
FizzLogger.D("Session Ended Duration " + duration);
_eventLog.Put(BuildEvent(sessionId, FizzEventType.session_ended, sessionEndTime, fields));
}
private void OnConnConnected(object sender, bool sessionPresent)
{
if (_connection != null)
{
FizzLogger.W("Received connected event for old connection.");
}
FizzLogger.D("MQTT - OnConnected: " + sessionPresent);
if (OnConnected != null)
{
OnConnected.Invoke(!sessionPresent);
}
}
private void OnConnConnected(int connId, object sender, MqttClientConnectedEventArgs args)
{
if (_connection != null && _connection.Id != connId)
{
FizzLogger.W("Received conneced event for old connection.");
}
FizzLogger.D("MQTT - OnConnected: " + args.IsSessionPresent.ToString());
if (OnConnected != null)
{
OnConnected.Invoke(!args.IsSessionPresent);
}
}
private FizzUserUpdateEventData ParseUserUpdateEventData(FizzTopicMessage message)
{
JSONClass payload = JSONNode.Parse(message.Data).AsObject;
FizzUserUpdateEventData update = new FizzUserUpdateEventData();
FizzLogger.D(message.Data);
update.Reason = FizzUserUpdateEventData.UpdateReason.Profile;
update.UserId = message.From;
update.Nick = payload["nick"];
update.StatusMessage = payload["status_message"];
update.ProfileUrl = payload["profile_url"];
return(update);
}
public override void SubscribeAndQueryLatest()
{
try
{
if (FizzService.Instance.GroupRepository.GroupInvites.ContainsKey(GroupId))
{
// Can't fetch messages of group with pending membership
return;
}
Subscribe(subEx =>
{
if (subEx != null)
{
FizzLogger.E("Subscribe Error " + Id + " ex " + subEx.Message);
}
else
{
FizzLogger.D("Subscribed " + Id);
FizzService.Instance.Client.Chat.Groups.QueryLatest(GroupId, _channelMeta.InitialQueryMessageCount, (msgs, qEx) =>
{
if (qEx == null)
{
Reset();
if (msgs != null && msgs.Count > 0)
{
AddMessages(msgs);
}
if (FizzService.Instance.OnChannelMessagesAvailable != null)
{
FizzService.Instance.OnChannelMessagesAvailable.Invoke(Id);
}
}
else
{
FizzLogger.E("QueryLatest " + qEx.Message);
}
});
}
});
}
catch (FizzException ex)
{
FizzLogger.E("SubscribeAndQuery ex " + ex.Message);
}
}
void Listener_OnConnected(bool syncRequired)
{
FizzLogger.D("FizzService Listener_OnConnected = " + syncRequired);
if (syncRequired)
{
foreach (FizzChannelModel channel in Channels)
{
channel.SubscribeAndQueryLatest();
}
}
if (OnConnected != null)
{
OnConnected.Invoke(syncRequired);
}
}
private void OnRejectButtonPressed()
{
// Reject Group Invite
try
{
FizzService.Instance.GroupRepository.RemoveGroup(_groupId, ex =>
{
if (ex == null)
{
FizzLogger.D("Invite Rejected");
}
});
}
catch
{
FizzLogger.E("Something went wrong while calling Reject Group of FizzService.");
}
}
private void OnAcceptButtonPressed()
{
// Accept Group Invite
try
{
FizzService.Instance.GroupRepository.UpdateGroup(_groupId, ex =>
{
if (ex == null)
{
FizzLogger.D("Invite Accepted");
}
});
}
catch
{
FizzLogger.E("Something went wrong while calling Join Group of FizzService.");
}
}
private IList <IFizzUserGroup> ParseResponse(string response)
{
FizzLogger.D("query parse links: " + response);
JSONClass json = JSONNode.Parse(response).AsObject;
if (!json.HasKey("links") || !json.HasKey("groups"))
{
throw FizzRestClient.ERROR_INVALID_RESPONSE_FORMAT;
}
JSONClass links = json["links"].AsObject;
ParseLinks(links);
JSONArray groupsElement = json["groups"].AsArray;
return(ParseGroups(groupsElement));
}
public void SubscribeAndQuery()
{
try
{
Subscribe(subEx =>
{
if (subEx != null)
{
FizzLogger.E("Subscribe Error " + Id + " ex " + subEx.Message);
}
else
{
FizzLogger.D("Subscribed " + Id);
FizzService.Instance.Client.Chat.QueryLatest(Id, _channelMeta.InitialQueryMessageCount, (msgs, qEx) =>
{
if (qEx == null)
{
Reset();
if (msgs != null && msgs.Count > 0)
{
AddMessages(msgs);
}
if (FizzService.Instance.OnChannelMessagesAvailable != null)
{
FizzService.Instance.OnChannelMessagesAvailable.Invoke(Id);
}
}
else
{
FizzLogger.E("QueryLatest " + qEx.Message);
}
});
}
});
}
catch (FizzException ex)
{
FizzLogger.E("SubscribeAndQuery ex " + ex.Message);
}
}
public void SubscribeAndQuery()
{
try
{
Subscribe(subEx =>
{
if (subEx != null)
{
FizzLogger.E("Subscribe Error " + Id + " ex " + subEx.Message);
}
else
{
FizzLogger.D("Subscribed " + Id);
FizzService.Instance.Client.Chat.QueryLatest(Id, FizzService.QUERY_MESSAGES_COUNT, (msgs, qEx) =>
{
if (qEx == null)
{
FizzLogger.D("QueryLatest " + msgs.Count);
Reset();
if (msgs != null && msgs.Count > 0)
{
AddMessages(msgs);
}
if (FizzService.Instance.OnChannelHistoryUpdated != null)
{
FizzService.Instance.OnChannelHistoryUpdated.Invoke(Id);
}
}
else
{
FizzLogger.E("QueryLatest " + qEx.Message);
}
});
}
});
}
catch (FizzException ex)
{
FizzLogger.E("SubscribeAndQuery ex " + ex.Message);
}
}
private void OnMessage(object sender, byte[] messagePayload)
{
try
{
string payload = Encoding.UTF8.GetString(messagePayload);
FizzTopicMessage message = new FizzTopicMessage(payload);
FizzLogger.D("OnMessage with id: " + message.Id);
switch (message.Type)
{
case "CMSGP":
if (OnMessagePublished != null)
{
OnMessagePublished.Invoke(AdaptTo(message));
}
break;
case "CMSGU":
if (OnMessageUpdated != null)
{
OnMessageUpdated.Invoke(AdaptTo(message));
}
break;
case "CMSGD":
if (OnMessageDeleted != null)
{
OnMessageDeleted.Invoke(AdaptTo(message));
}
break;
default:
FizzLogger.W("unrecognized packet received: " + payload);
break;
}
}
catch
{
FizzLogger.W("received invalid message: " + messagePayload);
}
}
private FizzGroupUpdateEventData ParseGroupUpdateEventData(FizzTopicMessage message)
{
JSONClass payload = JSONNode.Parse(message.Data).AsObject;
FizzGroupUpdateEventData update = new FizzGroupUpdateEventData();
update.GroupId = message.From;
string reason = payload["reason"];
FizzLogger.D(message.Data);
if (reason == "profile")
{
update.Reason = FizzGroupUpdateEventData.UpdateReason.Profile;
update.Title = payload["title"];
update.ImageURL = payload["image_url"];
update.Description = payload["description"];
update.Type = payload["type"];
}
return(update);
}
private void OnDeleteButtonPressed()
{
if (_message == null)
{
return;
}
// Delete message
try
{
FizzService.Instance.Client.Chat.DeleteMessage(_message.To, _message.Id, ex =>
{
if (ex == null)
{
FizzLogger.D("Status Deleted");
}
});
}
catch
{
FizzLogger.E("Something went wrong while calling DeleteMessage of FizzService.");
}
}
public void Unsubscribe(Action <FizzException> cb)
{
try
{
FizzService.Instance.Client.Chat.Unsubscribe(Id, ex =>
{
if (ex == null)
{
FizzLogger.D("Unsubscribed " + Id);
if (FizzService.Instance.OnChannelUnsubscribed != null)
{
FizzService.Instance.OnChannelUnsubscribed.Invoke(Id);
}
}
FizzUtils.DoCallback(ex, cb);
});
}
catch
{
FizzLogger.E("Something went wrong while calling Unsubscribe of FizzService.");
}
}
public void TextMessageSent(string channelId, string content, string senderNick)
{
IfOpened(() =>
{
FizzLogger.D("Text Message Sent => channel:" + channelId + " content:" + content + " nick:" + senderNick);
JSONClass fields = new JSONClass();
if (channelId != null)
{
fields["channel_id"] = channelId;
}
if (content != null)
{
fields["content"] = content;
}
if (senderNick != null)
{
fields["nick"] = senderNick;
}
_eventLog.Put(BuildEvent(_sessionId, FizzEventType.text_msg_sent, FizzUtils.Now() + _timeOffset, fields));
});
}
private void OnMessage(object sender, byte[] messagePayload)
{
try
{
string payload = Encoding.UTF8.GetString(messagePayload);
FizzTopicMessage message = new FizzTopicMessage(payload);
FizzLogger.D("OnMessage with id: " + message.Id);
switch (message.Type)
{
case "CMSGP":
if (OnMessagePublished != null)
{
OnMessagePublished.Invoke(AdaptTo(message));
}
break;
case "CMSGU":
if (OnMessageUpdated != null)
{
OnMessageUpdated.Invoke(AdaptTo(message));
}
break;
case "CMSGD":
if (OnMessageDeleted != null)
{
OnMessageDeleted.Invoke(AdaptTo(message));
}
break;
case "GRPMA":
if (OnGroupMemberAdded != null)
{
OnGroupMemberAdded.Invoke(ParseMemberEventData(message));
}
break;
case "GRPMU":
if (OnGroupMemberUpdated != null)
{
OnGroupMemberUpdated.Invoke(ParseMemberEventData(message));
}
break;
case "GRPMR":
if (OnGroupMemberRemoved != null)
{
OnGroupMemberRemoved.Invoke(ParseMemberEventData(message));
}
break;
case "GRPU":
if (OnGroupUpdated != null)
{
OnGroupUpdated.Invoke(ParseGroupUpdateEventData(message));
}
break;
case "USRPU":
if (OnUserUpdated != null)
{
OnUserUpdated.Invoke(ParsePresenceUpdateEventData(message));
}
break;
case "USRU":
if (OnUserUpdated != null)
{
OnUserUpdated.Invoke(ParseUserUpdateEventData(message));
}
break;
default:
FizzLogger.W("unrecognized packet received: " + payload);
break;
}
}
catch
{
FizzLogger.W("received invalid message: " + messagePayload);
}
}
protected override void OnConnectionStateChange(bool isConnected)
{
base.OnConnectionStateChange(isConnected);
FizzLogger.D("OnConnectionStateChange isConnected " + isConnected);
}
