Example #1
0
        private void onMessage(Envelope message)
        {
            // Handle realtime messages
            switch (message.PayloadCase)
            {
            case Envelope.PayloadOneofCase.Heartbeat:
                ServerTime = message.Heartbeat.Timestamp;
                return;

            case Envelope.PayloadOneofCase.MatchData:
                if (OnMatchData != null)
                {
                    OnMatchData(this, new NMatchDataEventArgs(new NMatchData(message.MatchData)));
                }
                return;

            case Envelope.PayloadOneofCase.MatchPresence:
                if (OnMatchPresence != null)
                {
                    OnMatchPresence(this, new NMatchPresenceEventArgs(new NMatchPresence(message.MatchPresence)));
                }
                return;

            case Envelope.PayloadOneofCase.TopicMessage:
                if (OnTopicMessage != null)
                {
                    OnTopicMessage(this, new NTopicMessageEventArgs(new NTopicMessage(message.TopicMessage)));
                }
                return;

            case Envelope.PayloadOneofCase.TopicPresence:
                if (OnTopicPresence != null)
                {
                    OnTopicPresence(this, new NTopicPresenceEventArgs(new NTopicPresence(message.TopicPresence)));
                }
                return;
            }

            var collationId = message.CollationId;
            var pair        = collationIds[collationId];

            collationIds.Remove(collationId);

            switch (message.PayloadCase)
            {
            case Envelope.PayloadOneofCase.None:
                pair.Key(true);
                break;

            case Envelope.PayloadOneofCase.Error:
                var error = new NError(message.Error);
                if (collationId != null)
                {
                    pair.Value(error);
                }
                else
                {
                    if (OnError != null)
                    {
                        OnError(this, new NErrorEventArgs(error));
                    }
                }
                break;

            case Envelope.PayloadOneofCase.Friends:
                var friends = new List <INFriend>();
                foreach (var friend in message.Friends.Friends)
                {
                    friends.Add(new NFriend(friend));
                }
                pair.Key(new NResultSet <INFriend>(friends, null));
                break;

            case Envelope.PayloadOneofCase.Group:
                pair.Key(new NGroup(message.Group.Group));
                break;

            case Envelope.PayloadOneofCase.GroupUsers:
                var groupUsers = new List <INGroupUser>();
                foreach (var groupUser in message.GroupUsers.Users)
                {
                    groupUsers.Add(new NGroupUser(groupUser));
                }
                pair.Key(new NResultSet <INGroupUser>(groupUsers, null));
                break;

            case Envelope.PayloadOneofCase.Groups:
                var groups = new List <INGroup>();
                foreach (var group in message.Groups.Groups)
                {
                    groups.Add(new NGroup(group));
                }
                pair.Key(new NResultSet <INGroup>(groups, new NCursor(message.Groups.Cursor.ToByteArray())));
                break;

            case Envelope.PayloadOneofCase.Match:
                pair.Key(new NMatch(message.Match));
                break;

            case Envelope.PayloadOneofCase.Self:
                pair.Key(new NSelf(message.Self.Self));
                break;

            case Envelope.PayloadOneofCase.StorageKey:
                var keys = new List <INStorageKey>();
                foreach (var key in message.StorageKey.Keys)
                {
                    keys.Add(new NStorageKey(key));
                }
                pair.Key(new NResultSet <INStorageKey>(keys, null));
                break;

            case Envelope.PayloadOneofCase.StorageData:
                var storageData = new List <INStorageData>();
                foreach (var data in message.StorageData.Data)
                {
                    storageData.Add(new NStorageData(data));
                }
                pair.Key(new NResultSet <INStorageData>(storageData, null));
                break;

            case Envelope.PayloadOneofCase.Topic:
                pair.Key(new NTopic(message.Topic));
                break;

            case Envelope.PayloadOneofCase.TopicMessageAck:
                pair.Key(new NTopicMessageAck(message.TopicMessageAck));
                break;

            case Envelope.PayloadOneofCase.TopicMessages:
                var topicMessages = new List <INTopicMessage>();
                foreach (var topicMessage in message.TopicMessages.Messages)
                {
                    topicMessages.Add(new NTopicMessage(topicMessage));
                }
                pair.Key(new NResultSet <INTopicMessage>(topicMessages,
                                                         new NCursor(message.TopicMessages.Cursor.ToByteArray())));
                break;

            case Envelope.PayloadOneofCase.Users:
                var users = new List <INUser>();
                foreach (var user in message.Users.Users)
                {
                    users.Add(new NUser(user));
                }
                pair.Key(new NResultSet <INUser>(users, null));
                break;

            case Envelope.PayloadOneofCase.Leaderboards:
                var leaderboards = new List <INLeaderboard>();
                foreach (var leaderboard in message.Leaderboards.Leaderboards)
                {
                    leaderboards.Add(new NLeaderboard(leaderboard));
                }
                pair.Key(new NResultSet <INLeaderboard>(leaderboards, new NCursor(message.Leaderboards.Cursor.ToByteArray())));
                break;

            case Envelope.PayloadOneofCase.LeaderboardRecord:
                pair.Key(new NLeaderboardRecord(message.LeaderboardRecord.Record));
                break;

            case Envelope.PayloadOneofCase.LeaderboardRecords:
                var leaderboardRecords = new List <INLeaderboardRecord>();
                foreach (var leaderboardRecord in message.LeaderboardRecords.Records)
                {
                    leaderboardRecords.Add(new NLeaderboardRecord(leaderboardRecord));
                }
                pair.Key(new NResultSet <INLeaderboardRecord>(leaderboardRecords, new NCursor(message.LeaderboardRecords.Cursor.ToByteArray())));
                break;

            default:
                Logger.TraceFormatIf(Trace, "Unrecognized message: {0}", message);
                break;
            }
        }
Example #2
0
 internal NErrorEventArgs(NError error)
 {
     Error = error;
 }
Example #3
0
        private void onMessage(Envelope message)
        {
            // Handle realtime messages
            switch (message.PayloadCase)
            {
            case Envelope.PayloadOneofCase.Heartbeat:
                ServerTime = message.Heartbeat.Timestamp;
                return;

            case Envelope.PayloadOneofCase.MatchmakeMatched:
                if (OnMatchmakeMatched != null)
                {
                    OnMatchmakeMatched(new NMatchmakeMatched(message.MatchmakeMatched));
                }
                return;

            case Envelope.PayloadOneofCase.MatchData:
                if (OnMatchData != null)
                {
                    OnMatchData(new NMatchData(message.MatchData));
                }
                return;

            case Envelope.PayloadOneofCase.MatchPresence:
                if (OnMatchPresence != null)
                {
                    OnMatchPresence(new NMatchPresence(message.MatchPresence));
                }
                return;

            case Envelope.PayloadOneofCase.TopicMessage:
                if (OnTopicMessage != null)
                {
                    OnTopicMessage(new NTopicMessage(message.TopicMessage));
                }
                return;

            case Envelope.PayloadOneofCase.TopicPresence:
                if (OnTopicPresence != null)
                {
                    OnTopicPresence(new NTopicPresence(message.TopicPresence));
                }
                return;

            case Envelope.PayloadOneofCase.LiveNotifications:
                if (OnNotification != null)
                {
                    foreach (var n in message.LiveNotifications.Notifications_)
                    {
                        OnNotification(new NNotification(n));
                    }
                }
                return;
            }

            var collationId = message.CollationId;
            var pair        = collationIds[collationId];

            collationIds.Remove(collationId);

            switch (message.PayloadCase)
            {
            case Envelope.PayloadOneofCase.None:
                pair.Key(true);
                break;

            case Envelope.PayloadOneofCase.Error:
                var error = new NError(message.Error, collationId);
                if (collationId != null)
                {
                    pair.Value(error);
                }
                else
                {
                    if (OnError != null)
                    {
                        OnError(error);
                    }
                }
                break;

            case Envelope.PayloadOneofCase.Friends:
                var friends = new List <INFriend>();
                foreach (var friend in message.Friends.Friends)
                {
                    friends.Add(new NFriend(friend));
                }
                pair.Key(new NResultSet <INFriend>(friends, null));
                break;

            case Envelope.PayloadOneofCase.GroupUsers:
                var groupUsers = new List <INGroupUser>();
                foreach (var groupUser in message.GroupUsers.Users)
                {
                    groupUsers.Add(new NGroupUser(groupUser));
                }
                pair.Key(new NResultSet <INGroupUser>(groupUsers, null));
                break;

            case Envelope.PayloadOneofCase.Groups:
                var groups = new List <INGroup>();
                foreach (var group in message.Groups.Groups)
                {
                    groups.Add(new NGroup(group));
                }
                pair.Key(new NResultSet <INGroup>(groups, new NCursor(message.Groups.Cursor)));
                break;

            case Envelope.PayloadOneofCase.GroupsSelf:
                var groupsSelf = new List <INGroupSelf>();
                foreach (var gs in message.GroupsSelf.GroupsSelf)
                {
                    groupsSelf.Add(new NGroupSelf(gs));
                }
                pair.Key(new NResultSet <INGroupSelf>(groupsSelf, null));
                break;

            case Envelope.PayloadOneofCase.MatchmakeTicket:
                pair.Key(new NMatchmakeTicket(message.MatchmakeTicket));
                break;

            case Envelope.PayloadOneofCase.Match:
                pair.Key(new NMatch(message.Match));
                break;

            case Envelope.PayloadOneofCase.Matches:
                var matches = new List <INMatch>();
                foreach (var m in message.Matches.Matches)
                {
                    matches.Add(new NMatch(m));
                }
                pair.Key(new NResultSet <INMatch>(matches, null));
                break;

            case Envelope.PayloadOneofCase.Self:
                pair.Key(new NSelf(message.Self.Self));
                break;

            case Envelope.PayloadOneofCase.StorageKeys:
                var keys = new List <INStorageKey>();
                foreach (var key in message.StorageKeys.Keys)
                {
                    keys.Add(new NStorageKey(key));
                }
                pair.Key(new NResultSet <INStorageKey>(keys, null));
                break;

            case Envelope.PayloadOneofCase.StorageData:
                var storageData = new List <INStorageData>();
                foreach (var data in message.StorageData.Data)
                {
                    storageData.Add(new NStorageData(data));
                }
                pair.Key(new NResultSet <INStorageData>(storageData, null));
                break;

            case Envelope.PayloadOneofCase.Topics:
                var topics = new List <INTopic>();
                foreach (var topic in message.Topics.Topics)
                {
                    topics.Add(new NTopic(topic));
                }
                pair.Key(new NResultSet <INTopic>(topics, null));
                break;

            case Envelope.PayloadOneofCase.TopicMessageAck:
                pair.Key(new NTopicMessageAck(message.TopicMessageAck));
                break;

            case Envelope.PayloadOneofCase.TopicMessages:
                var topicMessages = new List <INTopicMessage>();
                foreach (var topicMessage in message.TopicMessages.Messages)
                {
                    topicMessages.Add(new NTopicMessage(topicMessage));
                }
                pair.Key(new NResultSet <INTopicMessage>(topicMessages,
                                                         new NCursor(message.TopicMessages.Cursor)));
                break;

            case Envelope.PayloadOneofCase.Users:
                var users = new List <INUser>();
                foreach (var user in message.Users.Users)
                {
                    users.Add(new NUser(user));
                }
                pair.Key(new NResultSet <INUser>(users, null));
                break;

            case Envelope.PayloadOneofCase.Leaderboards:
                var leaderboards = new List <INLeaderboard>();
                foreach (var leaderboard in message.Leaderboards.Leaderboards)
                {
                    leaderboards.Add(new NLeaderboard(leaderboard));
                }
                pair.Key(new NResultSet <INLeaderboard>(leaderboards, new NCursor(message.Leaderboards.Cursor)));
                break;

            case Envelope.PayloadOneofCase.LeaderboardRecords:
                var leaderboardRecords = new List <INLeaderboardRecord>();
                foreach (var leaderboardRecord in message.LeaderboardRecords.Records)
                {
                    leaderboardRecords.Add(new NLeaderboardRecord(leaderboardRecord));
                }
                var cursor = message.LeaderboardRecords.Cursor == null ? null : new NCursor(message.LeaderboardRecords.Cursor);
                pair.Key(new NResultSet <INLeaderboardRecord>(leaderboardRecords, cursor));
                break;

            case Envelope.PayloadOneofCase.Rpc:
                pair.Key(new NRuntimeRpc(message.Rpc));
                break;

            case Envelope.PayloadOneofCase.Notifications:
                var notifications = new List <INNotification>();
                foreach (var n in message.Notifications.Notifications)
                {
                    notifications.Add(new NNotification(n));
                }
                var resumableCursor = message.Notifications.ResumableCursor == null ? null : new NCursor(message.Notifications.ResumableCursor);
                pair.Key(new NResultSet <INNotification>(notifications, resumableCursor));
                break;

            case Envelope.PayloadOneofCase.PurchaseRecord:
                pair.Key(new NPurchaseRecord(message.PurchaseRecord));
                break;

            default:
                Logger.TraceFormatIf(Trace, "Unrecognized protocol message: {0}", message);
                break;
            }
        }