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));
}
public void Delay(int delayMS, Action action)
{
if (action == null || delayMS < 0)
{
FizzLogger.W("Invalid timer scheduled");
return;
}
lock (synclock)
{
timers.Add(FizzUtils.Now() + delayMS, action);
}
}
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);
}
FizzChannelModel GetChannelById(string channelId)
{
try
{
return(FizzService.Instance.GetChannel(channelId));
}
catch (Exception)
{
FizzLogger.W("ChannelList unable to get channel with id " + channelId);
}
return(null);
}
protected virtual void OnDisable()
{
try
{
FizzService.Instance.OnConnected -= HandleOnConnected;
FizzService.Instance.OnDisconnected -= HandleOnDisconnected;
}
catch
{
FizzLogger.E("Something went wrong while binding event of FizzService.");
}
}
public void RemoveGroup(string groupId, Action <FizzException> cb)
{
if (Client.State == FizzClientState.Closed)
{
FizzLogger.W("FizzClient should be opened before removing group.");
return;
}
Client.Chat.Users.RemoveGroup(UserId, groupId, ex =>
{
FizzUtils.DoCallback(ex, cb);
});
}
void RemoveInternalListeners()
{
try
{
Client.Chat.Listener.OnConnected -= Listener_OnConnected;
Client.Chat.Listener.OnDisconnected -= Listener_OnDisconnected;
Client.Chat.UserListener.OnUserUpdated -= Listener_OnUserUpdated;
}
catch (FizzException ex)
{
FizzLogger.E("Unable to unbind group listeners. " + ex.Message);
}
}
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 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);
}
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);
}
}
protected override void OnDisable()
{
base.OnDisable();
try
{
FizzService.Instance.OnChannelSubscribed -= HandleOnChannelSubscribe;
FizzService.Instance.OnChannelUnsubscribed -= HandleOnChannelUnsubscribe;
}
catch
{
FizzLogger.E("Unable to call FizzService.");
}
}
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);
}
}
private string GetLanguageCode()
{
string langCode = FizzLanguageCodes.English.Code;
try
{
langCode = FizzService.Instance.Language.Code;
}
catch (Exception)
{
FizzLogger.E("Unable to get LanguageCode");
}
return(langCode);
}
void RemoveInternalListeners()
{
try
{
Client.Chat.Listener.OnConnected -= Listener_OnConnected;
Client.Chat.Listener.OnDisconnected -= Listener_OnDisconnected;
Client.Chat.Listener.OnMessageUpdated -= Listener_OnMessageUpdated;
Client.Chat.Listener.OnMessageDeleted -= Listener_OnMessageDeleted;
Client.Chat.Listener.OnMessagePublished -= Listener_OnMessagePublished;
}
catch (FizzException ex)
{
FizzLogger.E("Unable to unbind chat listeners. " + ex.Message);
}
}
public void RollTo(FizzEvent item)
{
try
{
int index = log.IndexOfValue(item);
for (int i = index; i >= 0; i--)
{
log.RemoveAt(i);
}
}
catch (Exception e)
{
FizzLogger.E("Fizz Event Log RollTo " + e);
}
}
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);
}
}
void AddInternalListeners()
{
try
{
Client.Chat.Listener.OnConnected += Listener_OnConnected;
Client.Chat.Listener.OnDisconnected += Listener_OnDisconnected;
Client.Chat.GroupListener.OnGroupUpdated += Listener_OnGroupUpdated;
Client.Chat.GroupListener.OnGroupMemberAdded += Listener_OnGroupMemberAdded;
Client.Chat.GroupListener.OnGroupMemberRemoved += Listener_OnGroupMemberRemoved;
Client.Chat.GroupListener.OnGroupMemberUpdated += Listener_OnGroupMemberUpdated;
}
catch (FizzException ex)
{
FizzLogger.E("Unable to bind group listeners. " + ex.Message);
}
}
public void Flush()
{
if (_flushInProgress)
{
FizzUtils.DoCallback(_onLogEmpty);
return;
}
_flushInProgress = true;
_eventLog.Read(128, items =>
{
if (items.Count <= 0)
{
_flushInProgress = false;
FizzUtils.DoCallback(_onLogEmpty);
return;
}
PostEvents(items, (response, ex) =>
{
bool rollLog = true;
if (ex != null)
{
if (ex.Code == FizzError.ERROR_REQUEST_FAILED)
{
FizzLogger.W("Failed to submit events to service");
rollLog = false;
}
else
if (ex.Code == FizzError.ERROR_INVALID_REQUEST)
{
FizzLogger.E("Submission of some events failed: " + ex.Message);
}
}
if (rollLog)
{
_eventLog.RollTo(items[items.Count - 1]);
}
FizzUtils.DoCallback(_onLogEmpty);
_flushInProgress = false;
});
});
}
public void Open(string userId, string userName, IFizzLanguageCode lang, FizzServices services, bool tranlation, Action <bool> onDone)
{
if (!_isIntialized)
{
Initialize();
}
if (string.IsNullOrEmpty(userId))
{
FizzLogger.E("FizzService can not open client with null of empty userId.");
return;
}
if (string.IsNullOrEmpty(userName))
{
FizzLogger.E("FizzService can not open client with null of empty userName.");
return;
}
if (lang == null)
{
FizzLogger.E("FizzService can not open client with null language code.");
return;
}
UserId = userId;
UserName = userName;
Language = lang;
IsTranslationEnabled = tranlation;
Client.Open(userId, lang, services, ex =>
{
if (onDone != null)
{
onDone(ex == null);
}
if (ex != null)
{
FizzLogger.E("Something went wrong while connecting to FizzClient. " + ex);
}
else
{
AddInternalListeners();
}
});
}
public void UpdateGroup(string groupId, Action <FizzException> cb)
{
if (Client.State == FizzClientState.Closed)
{
FizzLogger.W("FizzClient should be opened before joining group.");
return;
}
Client.Chat.Users.UpdateGroup(UserId, groupId, null, null, ex =>
{
if (ex == null)
{
GroupInvites.Remove(groupId);
groupLookup[groupId].Channel.SubscribeAndQueryLatest();
}
FizzUtils.DoCallback(ex, cb);
});
}
public bool SetGroup(FizzGroupModel group)
{
if (!_initialized)
{
Initialize();
}
if (_channelsLookup.ContainsKey(group.Channel.Id))
{
HandleChannelSelected(group.Channel);
return(true);
}
else
{
FizzLogger.W("FizzChatView: Unable to set group");
return(false);
}
}
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.");
}
}
public void Subscribe(Action <FizzException> cb)
{
if (Client.State == FizzClientState.Closed)
{
FizzLogger.W("FizzClient should be opened before subscribing user.");
return;
}
Client.Chat.Users.Subscribe(Id, ex =>
{
if (ex == null)
{
IsSubscribed = true;
}
FizzUtils.DoCallback(ex, cb);
});
}
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 void RemoveListeners()
{
try
{
FizzService.Instance.OnConnected -= OnConnected;
FizzService.Instance.OnDisconnected -= OnDisconnected;
}
catch
{
FizzLogger.E("Something went wrong with binding events with FizzService.");
}
userNameInputField.onEndEdit.RemoveListener(HandleUserCradChange);
userNameInputField.onEndEdit.RemoveListener(HandleUserCradChange);
langCodeDropDown.onValueChanged.RemoveListener(HandleLangCodeChange);
translationToggle.onValueChanged.RemoveListener(HandleTranslationToggleChange);
}
public bool FetchHistory(Action complete)
{
long beforeId = -1;
if (_messageList.Count > 0)
{
beforeId = _messageList.First().Value.Id;
}
if (beforeId == -1)
{
return(false);
}
try
{
FizzService.Instance.Client.Chat.QueryLatest(Id, _channelMeta.InitialQueryMessageCount, beforeId, (msgs, qEx) =>
{
if (qEx == null)
{
if (msgs != null && msgs.Count > 0)
{
AddMessages(msgs);
}
if (FizzService.Instance.OnChannelMessagesAvailable != null)
{
FizzService.Instance.OnChannelMessagesAvailable.Invoke(Id);
}
}
if (complete != null)
{
complete.Invoke();
}
});
}
catch (FizzException ex)
{
FizzLogger.E("FetchHistory ex " + ex.Message);
}
return(true);
}
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);
}
}
RectTransform IFizzCustomMessageCellViewDataSource.GetCustomMessageCellViewNode(FizzChannelMessage message)
{
try
{
if (message != null && message.Data != null &&
(message.Data.ContainsKey(KEY_DATA_TYPE) && message.Data[KEY_DATA_TYPE] == "status"))
{
StatusNode node = Instantiate(Resources.Load <StatusNode>("StatusNode"));
node.SetData(FizzService.Instance.UserId, message);
return(node.GetComponent <RectTransform>());
}
}
catch
{
FizzLogger.E("Unable to add custom node in message cell.");
}
return(null);
}
