public Session(AbstractLogger logger, IInternalLocalUser localUser, string guestControllerAccessToken, bool pushNotificationsEnabled, INotificationPoller notificationPoller, ICoroutineManager coroutineManager, IDatabase database, IUserDatabase userDatabase, IGuestControllerClient guestControllerClient, IMixWebCallFactory mixWebCallFactory, IEpochTime epochTime, DatabaseCorruptionHandler databaseCorruptionHandler, ISessionStatus sessionStatus, IKeychain keychain, IGetStateResponseParser getStateResponseParser, string clientVersion, INotificationQueue notificationQueue)
{
this.logger = logger;
this.localUser = localUser;
this.notificationPoller = notificationPoller;
this.coroutineManager = coroutineManager;
this.database = database;
this.userDatabase = userDatabase;
this.guestControllerClient = guestControllerClient;
this.mixWebCallFactory = mixWebCallFactory;
this.epochTime = epochTime;
this.databaseCorruptionHandler = databaseCorruptionHandler;
this.sessionStatus = sessionStatus;
this.keychain = keychain;
this.getStateResponseParser = getStateResponseParser;
this.clientVersion = clientVersion;
this.notificationQueue = notificationQueue;
GuestControllerAccessToken = guestControllerAccessToken;
guestControllerClient.OnAccessTokenChanged += HandleGuestControllerAccessTokenChanged;
guestControllerClient.OnAuthenticationLost += HandleAuthenticationLost;
mixWebCallFactory.OnAuthenticationLost += HandleAuthenticationLost;
localUser.OnPushNotificationsToggled += HandlePushNotificationsToggled;
localUser.OnPushNotificationReceived += HandlePushNotificationReceived;
localUser.OnDisplayNameUpdated += HandleDisplayNameUpdated;
databaseCorruptionHandler.OnCorruptionDetected += HandleCorruptionDetected;
updateEnumerator = Update();
coroutineManager.Start(updateEnumerator);
notificationPoller.OnNotificationsPolled += HandleNotificationsPolled;
notificationPoller.UsePollIntervals = !pushNotificationsEnabled;
this.sessionStatus.IsPaused = true;
notificationPoller.OnSynchronizationError += HandleNotificationPollerSynchronizationError;
}
private static void HandleFriendshipTrustRemoved(IUserDatabase userDatabase, IInternalLocalUser localUser, AbstractRemoveFriendshipTrustNotificationEventArgs e)
{
string friendUserId = e.Notification.FriendUserId;
userDatabase.SetFriendIsTrusted(friendUserId, isTrusted: false);
localUser.UntrustFriend(e.Notification.FriendUserId);
}
private static void HandleAlertAdded(IInternalLocalUser localUser, IUserDatabase userDatabase, AbstractAddAlertNotificationEventArgs e)
{
Alert alert = new Alert(e.Notification.Alert);
userDatabase.AddAlert(alert);
localUser.DispatchOnAlertsAdded(alert);
}
private void ReconcileFriendInvitations(GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
List <FriendshipInvitation> friendshipInvitations = response.FriendshipInvitations;
List <IInternalIncomingFriendInvitation> list = localUser.InternalIncomingFriendInvitations.ToList();
List <IInternalOutgoingFriendInvitation> list2 = localUser.InternalOutgoingFriendInvitations.ToList();
if (friendshipInvitations != null)
{
foreach (FriendshipInvitation friendInvitation in friendshipInvitations)
{
Func <IInternalIncomingFriendInvitation, bool> predicate = (IInternalIncomingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId;
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = list.FirstOrDefault(predicate);
if (internalIncomingFriendInvitation != null)
{
if (internalIncomingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalIncomingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list.Remove(internalIncomingFriendInvitation);
continue;
}
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = list2.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.InvitationId == friendInvitation.FriendshipInvitationId);
if (internalOutgoingFriendInvitation != null)
{
if (internalOutgoingFriendInvitation.RequestTrust != friendInvitation.IsTrusted)
{
internalOutgoingFriendInvitation.RequestTrust = friendInvitation.IsTrusted.Value;
}
list2.Remove(internalOutgoingFriendInvitation);
continue;
}
string firstName = response.Users.FirstOrDefault((User user) => user.DisplayName == friendInvitation.FriendDisplayName)?.FirstName;
if (friendInvitation.IsInviter.Value)
{
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(friendInvitation.FriendDisplayName, firstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, friendInvitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(friendInvitation.FriendshipInvitationId.Value);
localUser.AddOutgoingFriendInvitation(outgoingFriendInvitation);
}
else
{
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(friendInvitation.FriendDisplayName, firstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, localUser, friendInvitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(friendInvitation.FriendshipInvitationId.Value);
localUser.AddIncomingFriendInvitation(incomingFriendInvitation);
}
}
}
foreach (IInternalIncomingFriendInvitation item in list)
{
localUser.RemoveIncomingFriendInvitation(item);
item.Rejected();
}
foreach (IInternalOutgoingFriendInvitation item2 in list2)
{
localUser.RemoveOutgoingFriendInvitation(item2);
item2.Rejected();
}
}
private void ReconcileFriends(GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
List <IInternalFriend> list = localUser.InternalFriends.ToList();
List <IInternalIncomingFriendInvitation> list2 = localUser.InternalIncomingFriendInvitations.ToList();
List <IInternalOutgoingFriendInvitation> list3 = localUser.InternalOutgoingFriendInvitations.ToList();
if (response.Friendships != null)
{
foreach (Friendship friendship in response.Friendships)
{
string friendUserId = friendship.FriendUserId;
IInternalFriend internalFriend = list.FirstOrDefault((IInternalFriend f) => f.Swid == friendUserId);
User user = response.Users.First((User u) => u.UserId == friendUserId);
if (internalFriend != null)
{
if (internalFriend.IsTrusted != friendship.IsTrusted)
{
if (friendship.IsTrusted.Value)
{
internalFriend.ChangeTrust(isTrusted: true);
}
else
{
localUser.UntrustFriend(internalFriend);
}
}
list.Remove(internalFriend);
continue;
}
IInternalFriend internalFriend2 = RemoteUserFactory.CreateFriend(friendship.FriendUserId, friendship.IsTrusted.Value, user.DisplayName, user.FirstName, userDatabase);
IInternalIncomingFriendInvitation internalIncomingFriendInvitation = list2.FirstOrDefault((IInternalIncomingFriendInvitation i) => i.InternalInviter.DisplayName.Text == user.DisplayName);
if (internalIncomingFriendInvitation != null)
{
localUser.AddFriend(internalFriend2);
internalIncomingFriendInvitation.Accepted(internalFriend2.IsTrusted, internalFriend2);
list2.Remove(internalIncomingFriendInvitation);
localUser.RemoveIncomingFriendInvitation(internalIncomingFriendInvitation);
continue;
}
IInternalOutgoingFriendInvitation internalOutgoingFriendInvitation = list3.FirstOrDefault((IInternalOutgoingFriendInvitation i) => i.InternalInvitee.DisplayName.Text == user.DisplayName);
if (internalOutgoingFriendInvitation != null)
{
localUser.AddFriend(internalFriend2);
internalOutgoingFriendInvitation.Accepted(internalFriend2.IsTrusted, internalFriend2);
list3.Remove(internalOutgoingFriendInvitation);
localUser.RemoveOutgoingFriendInvitation(internalOutgoingFriendInvitation);
}
else
{
localUser.AddFriend(internalFriend2);
}
}
}
foreach (IInternalFriend item in list)
{
localUser.RemoveFriend(item);
}
}
private static void HandleAlertCleared(IInternalLocalUser localUser, IUserDatabase userDatabase, AbstractClearAlertNotificationEventArgs e)
{
IInternalAlert[] array = (from a in userDatabase.GetAlerts()
where e.Notification.AlertIds.Contains(a.AlertId)
select a).ToArray();
IInternalAlert[] array2 = array;
foreach (IInternalAlert internalAlert in array2)
{
userDatabase.RemoveAlert(internalAlert.AlertId);
}
localUser.DispatchOnAlertsCleared(array);
}
private static void HandleFriendshipRemoved(IUserDatabase userDatabase, IInternalLocalUser localUser, AbstractRemoveFriendshipNotificationEventArgs e)
{
string swid = e.Notification.FriendUserId;
string displayName = null;
IInternalFriend internalFriend = localUser.InternalFriends.FirstOrDefault((IInternalFriend f) => f.Swid == swid);
if (internalFriend != null)
{
displayName = internalFriend.DisplayName.Text;
}
else
{
UserDocument userBySwid = userDatabase.GetUserBySwid(swid);
if (userBySwid != null)
{
displayName = userBySwid.DisplayName;
}
}
userDatabase.DeleteFriend(swid);
localUser.RemoveFriend(swid, sendEvent: true);
if (displayName != null)
{
FriendInvitationDocument incomingInvitation = userDatabase.GetFriendInvitationDocuments(isInviter: false).FirstOrDefault((FriendInvitationDocument doc) => doc.DisplayName == displayName);
if (incomingInvitation != null)
{
foreach (IInternalIncomingFriendInvitation item in from i in localUser.InternalIncomingFriendInvitations
where i.InvitationId == incomingInvitation.FriendInvitationId
select i)
{
localUser.RemoveIncomingFriendInvitation(item);
}
userDatabase.DeleteFriendInvitation(incomingInvitation.FriendInvitationId);
}
FriendInvitationDocument outgoingInvitation = userDatabase.GetFriendInvitationDocuments(isInviter: true).FirstOrDefault((FriendInvitationDocument doc) => doc.DisplayName == displayName);
if (outgoingInvitation != null)
{
foreach (IInternalOutgoingFriendInvitation item2 in from i in localUser.InternalOutgoingFriendInvitations
where i.InvitationId == outgoingInvitation.FriendInvitationId
select i)
{
localUser.RemoveOutgoingFriendInvitation(item2);
}
userDatabase.DeleteFriendInvitation(outgoingInvitation.FriendInvitationId);
}
}
}
private void HandleMixSessionStartSuccess(IEnumerable <IInvalidProfileItemError> errorList, string swid, Profile profile, Disney.Mix.SDK.Internal.GuestControllerDomain.DisplayName displayName, IEnumerable <Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem> marketing, Action <IRegisterResult> callback)
{
try
{
IInternalSession session = sessionFactory.Create(swid);
IInternalLocalUser internalLocalUser = session.InternalLocalUser;
internalLocalUser.InternalRegistrationProfile.Update(profile, displayName, marketing);
session.Resume(delegate(IResumeSessionResult r)
{
HandleOfflineSessionResumed(r, session, errorList, callback);
});
}
catch (Exception ex)
{
logger.Critical("Error creating session: " + ex);
callback(new RegisterResult(success: false, null, null));
}
}
private void HandleMixSessionStartSuccess(Action <ILoginResult> callback, ILoginResult loginResult, string swid, GuestApiErrorCollection gcErrorCollection, Profile profile, Disney.Mix.SDK.Internal.GuestControllerDomain.DisplayName displayName, IEnumerable <Disney.Mix.SDK.Internal.GuestControllerDomain.MarketingItem> marketing)
{
try
{
IInternalSession session = sessionFactory.Create(swid);
IInternalLocalUser internalLocalUser = session.InternalLocalUser;
internalLocalUser.InternalRegistrationProfile.Update(profile, displayName, marketing);
session.Resume(delegate(IResumeSessionResult r)
{
HandleOfflineSessionResumed(r, session, loginResult, gcErrorCollection, callback);
});
}
catch (Exception arg)
{
logger.Critical("Error creating session: " + arg);
callback(new LoginResult(success: false, null));
}
}
private static void HandleFriendshipInvitationAdded(IUserDatabase userDatabase, IInternalLocalUser localUser, AbstractAddFriendshipInvitationNotificationEventArgs e)
{
AddFriendshipInvitationNotification notification = e.Notification;
FriendshipInvitation invitation = notification.Invitation;
User friend = notification.Friend;
userDatabase.PersistUser(null, null, invitation.FriendDisplayName, friend.FirstName, friend.Status);
FriendInvitationDocument friendInvitationDocument = new FriendInvitationDocument();
friendInvitationDocument.FriendInvitationId = invitation.FriendshipInvitationId.Value;
friendInvitationDocument.IsInviter = invitation.IsInviter.Value;
friendInvitationDocument.IsTrusted = invitation.IsTrusted.Value;
friendInvitationDocument.DisplayName = invitation.FriendDisplayName;
FriendInvitationDocument doc = friendInvitationDocument;
userDatabase.InsertOrUpdateFriendInvitation(doc);
localUser.AddFriendshipInvitation(invitation, friend);
}
private static void HandleFriendshipAdded(IUserDatabase userDatabase, IInternalLocalUser localUser, AbstractAddFriendshipNotificationEventArgs e)
{
AddFriendshipNotification notification = e.Notification;
User friend = notification.Friend;
userDatabase.PersistUser(friend.UserId, friend.HashedUserId, friend.DisplayName, friend.FirstName, friend.Status);
FriendDocument friendDocument = new FriendDocument();
friendDocument.Swid = friend.UserId;
friendDocument.IsTrusted = notification.IsTrusted.Value;
friendDocument.Nickname = null;
FriendDocument doc = friendDocument;
userDatabase.InsertFriend(doc);
long value = e.Notification.FriendshipInvitationId.Value;
userDatabase.DeleteFriendInvitation(value);
localUser.AddFriend(friend, notification.IsTrusted.Value, value);
}
public void ReconcileWithLocalUser(IMixWebCallFactory mixWebCallFactory, GetStateResponse response, IInternalLocalUser localUser, IUserDatabase userDatabase)
{
ReconcileFriends(response, localUser, userDatabase);
ReconcileFriendInvitations(response, localUser, userDatabase);
}
public void ParseFriendshipInvitations(GetStateResponse response, IUserDatabase userDatabase, IInternalLocalUser localUser, out IList <IInternalIncomingFriendInvitation> incomingFriendInvitations, out IList <IInternalOutgoingFriendInvitation> outgoingFriendInvitations)
{
incomingFriendInvitations = new List <IInternalIncomingFriendInvitation>();
outgoingFriendInvitations = new List <IInternalOutgoingFriendInvitation>();
if (response.FriendshipInvitations != null)
{
foreach (FriendshipInvitation invitation in response.FriendshipInvitations)
{
List <User> users = response.Users;
Func <User, bool> predicate = (User user) => user.DisplayName == invitation.FriendDisplayName;
string firstName = users.FirstOrDefault(predicate)?.FirstName;
if (invitation.IsInviter.Value)
{
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(invitation.FriendDisplayName, firstName, userDatabase);
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, invitation.IsTrusted.Value);
outgoingFriendInvitation.SendComplete(invitation.FriendshipInvitationId.Value);
outgoingFriendInvitations.Add(outgoingFriendInvitation);
}
else
{
IInternalUnidentifiedUser inviter = RemoteUserFactory.CreateUnidentifiedUser(invitation.FriendDisplayName, firstName, userDatabase);
IncomingFriendInvitation incomingFriendInvitation = new IncomingFriendInvitation(inviter, localUser, invitation.IsTrusted.Value);
incomingFriendInvitation.SendComplete(invitation.FriendshipInvitationId.Value);
incomingFriendInvitations.Add(incomingFriendInvitation);
}
}
}
}
public OutgoingFriendInvitation(IInternalLocalUser inviter, IInternalUnidentifiedUser invitee, bool requestTrust)
: base(requestTrust)
{
this.inviter = inviter;
this.invitee = invitee;
}
private static void HandleGetStateSuccess(AbstractLogger logger, IGetStateResponseParser getStateResponseParser, GetStateResponse response, IMixWebCallFactory mixWebCallFactory, IInternalLocalUser localUser, IUserDatabase userDatabase, INotificationPoller notificationPoller, Action <IResumeSessionResult> callback)
{
try
{
userDatabase.SyncToGetStateResponse(response, delegate
{
HandleGetStateSynced(getStateResponseParser, response, mixWebCallFactory, localUser, userDatabase, notificationPoller, callback);
});
}
catch (Exception ex)
{
logger.Critical("Unhandled exception: " + ex);
callback(new ResumeSessionResult(success: false));
}
}
private static IEnumerable <OutgoingFriendInvitation> GetOutgoingFriendInvitations(IUserDatabase userDatabase, IInternalLocalUser localUser)
{
return((from friendInvitationDoc in userDatabase.GetFriendInvitationDocuments(isInviter : true)
where userDatabase.GetUserByDisplayName(friendInvitationDoc.DisplayName) != null
select friendInvitationDoc).Select(delegate(FriendInvitationDocument friendInvitationDoc)
{
UserDocument userByDisplayName = userDatabase.GetUserByDisplayName(friendInvitationDoc.DisplayName);
string displayName = userByDisplayName.DisplayName;
IInternalUnidentifiedUser invitee = RemoteUserFactory.CreateUnidentifiedUser(displayName, userByDisplayName.FirstName, userDatabase);
bool isTrusted = friendInvitationDoc.IsTrusted;
OutgoingFriendInvitation outgoingFriendInvitation = new OutgoingFriendInvitation(localUser, invitee, isTrusted);
outgoingFriendInvitation.SendComplete(friendInvitationDoc.FriendInvitationId);
return outgoingFriendInvitation;
}).ToList());
}
public static void Handle(INotificationDispatcher dispatcher, IUserDatabase userDatabase, IInternalLocalUser localUser, IEpochTime epochTime)
{
dispatcher.OnAlertAdded += delegate(object sender, AbstractAddAlertNotificationEventArgs e)
{
HandleAlertAdded(localUser, userDatabase, e);
};
dispatcher.OnAlertCleared += delegate(object sender, AbstractClearAlertNotificationEventArgs e)
{
HandleAlertCleared(localUser, userDatabase, e);
};
dispatcher.OnFriendshipRemoved += delegate(object sender, AbstractRemoveFriendshipNotificationEventArgs e)
{
HandleFriendshipRemoved(userDatabase, localUser, e);
};
dispatcher.OnFriendshipTrustRemoved += delegate(object sender, AbstractRemoveFriendshipTrustNotificationEventArgs e)
{
HandleFriendshipTrustRemoved(userDatabase, localUser, e);
};
dispatcher.OnFriendshipInvitationAdded += delegate(object sender, AbstractAddFriendshipInvitationNotificationEventArgs e)
{
HandleFriendshipInvitationAdded(userDatabase, localUser, e);
};
dispatcher.OnFriendshipInvitationRemoved += delegate(object sender, AbstractRemoveFriendshipInvitationNotificationEventArgs e)
{
HandleFriendshipInvitationRemoved(userDatabase, localUser, e);
};
dispatcher.OnFriendshipAdded += delegate(object sender, AbstractAddFriendshipNotificationEventArgs e)
{
HandleFriendshipAdded(userDatabase, localUser, e);
};
}
private static void HandleFriendshipInvitationRemoved(IUserDatabase userDatabase, IInternalLocalUser localUser, AbstractRemoveFriendshipInvitationNotificationEventArgs e)
{
long value = e.Notification.InvitationId.Value;
userDatabase.DeleteFriendInvitation(value);
localUser.RemoveFriendshipInvitation(value);
}
private static void HandleGetStateSynced(IGetStateResponseParser getStateResponseParser, GetStateResponse response, IMixWebCallFactory mixWebCallFactory, IInternalLocalUser localUser, IUserDatabase userDatabase, INotificationPoller notificationPoller, Action <IResumeSessionResult> callback)
{
getStateResponseParser.ParsePollIntervals(response, out var pollIntervals, out var pokeIntervals);
notificationPoller.PollIntervals = pollIntervals;
notificationPoller.PokeIntervals = pokeIntervals;
notificationPoller.Jitter = response.NotificationIntervalsJitter.Value;
notificationPoller.MaximumMissingNotificationTime = response.NotificationSequenceThreshold.Value;
getStateResponseParser.ReconcileWithLocalUser(mixWebCallFactory, response, localUser, userDatabase);
callback(new ResumeSessionResult(success: true));
}
public static void Resume(AbstractLogger logger, IGetStateResponseParser getStateResponseParser, IEpochTime epochTime, string clientVersion, INotificationQueue notificationQueue, IMixWebCallFactory mixWebCallFactory, IInternalLocalUser localUser, IDatabase database, IUserDatabase userDatabase, INotificationPoller notificationPoller, Action <IResumeSessionResult> callback)
{
epochTime.OffsetMilliseconds = database.GetServerTimeOffsetMillis() ?? 0;
logger.Debug("Initial time offset: " + epochTime.Offset);
SessionDocument sessionDocument = database.GetSessionDocument(localUser.Swid);
long lastNotificationTime = sessionDocument.LastNotificationTime;
StateGetter.GetState(logger, epochTime, clientVersion, database, userDatabase, notificationQueue, mixWebCallFactory, localUser.Swid, lastNotificationTime, delegate(GetStateResponse response)
{
HandleGetStateSuccess(logger, getStateResponseParser, response, mixWebCallFactory, localUser, userDatabase, notificationPoller, callback);
}, delegate
{
callback(new ResumeSessionResult(success: false));
});
}
