Merge remote-tracking branch 'origin/master' into multiplayer-room-settings

osu.Game/Online/API/APIMessagesRequest.cs

@@ -0,0 +1,28 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Framework.IO.Network;
+using osu.Game.Online.Chat;
+
+namespace osu.Game.Online.API
+{
+    public abstract class APIMessagesRequest : APIRequest<List<Message>>
+    {
+        private readonly long? sinceId;
+
+        protected APIMessagesRequest(long? sinceId)
+        {
+            this.sinceId = sinceId;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+
+            if (sinceId.HasValue) req.AddParameter(@"since", sinceId.Value.ToString());
+
+            return req;
+        }
+    }
+}

osu.Game/Online/API/OAuth.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Diagnostics;
+using System.Net.Http;
 using osu.Framework.Configuration;
 using osu.Framework.IO.Network;
 
@@ -40,7 +41,7 @@ namespace osu.Game.Online.API
             using (var req = new AccessTokenRequestPassword(username, password)
             {
                 Url = $@"{endpoint}/oauth/token",
-                Method = HttpMethod.POST,
+                Method = HttpMethod.Post,
                 ClientId = clientId,
                 ClientSecret = clientSecret
             })
@@ -66,7 +67,7 @@ namespace osu.Game.Online.API
                 using (var req = new AccessTokenRequestRefresh(refresh)
                 {
                     Url = $@"{endpoint}/oauth/token",
-                    Method = HttpMethod.POST,
+                    Method = HttpMethod.Post,
                     ClientId = clientId,
                     ClientSecret = clientSecret
                 })

osu.Game/Online/API/Requests/CreateNewPrivateMessageRequest.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Net.Http;
+using osu.Framework.IO.Network;
+using osu.Game.Online.Chat;
+using osu.Game.Users;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class CreateNewPrivateMessageRequest : APIRequest<CreateNewPrivateMessageResponse>
+    {
+        private readonly User user;
+        private readonly Message message;
+
+        public CreateNewPrivateMessageRequest(User user, Message message)
+        {
+            this.user = user;
+            this.message = message;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.Method = HttpMethod.Post;
+            req.AddParameter(@"target_id", user.Id.ToString());
+            req.AddParameter(@"message", message.Content);
+            req.AddParameter(@"is_action", message.IsAction.ToString().ToLowerInvariant());
+            return req;
+        }
+
+        protected override string Target => @"chat/new";
+    }
+}

osu.Game/Online/API/Requests/CreateNewPrivateMessageResponse.cs

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using Newtonsoft.Json;
+using osu.Game.Online.Chat;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class CreateNewPrivateMessageResponse
+    {
+        [JsonProperty("new_channel_id")]
+        public int ChannelID;
+
+        public Message Message;
+    }
+}

osu.Game/Online/API/Requests/GetMessagesRequest.cs

@@ -2,34 +2,19 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.IO.Network;
 using osu.Game.Online.Chat;
 
 namespace osu.Game.Online.API.Requests
 {
     public class GetMessagesRequest : APIRequest<List<Message>>
     {
-        private readonly List<Channel> channels;
-        private readonly long? since;
+        private readonly Channel channel;
 
-        public GetMessagesRequest(List<Channel> channels, long? sinceId)
+        public GetMessagesRequest(Channel channel)
         {
-            this.channels = channels;
-            since = sinceId;
+            this.channel = channel;
         }
 
-        protected override WebRequest CreateWebRequest()
-        {
-            string channelString = string.Join(",", channels.Select(x => x.Id));
-
-            var req = base.CreateWebRequest();
-            req.AddParameter(@"channels", channelString);
-            if (since.HasValue) req.AddParameter(@"since", since.Value.ToString());
-
-            return req;
-        }
-
-        protected override string Target => @"chat/messages";
+        protected override string Target => $@"chat/channels/{channel.Id}/messages";
     }
 }

osu.Game/Online/API/Requests/GetUpdatesRequest.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using JetBrains.Annotations;
+using osu.Framework.IO.Network;
+using osu.Game.Online.Chat;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetUpdatesRequest : APIRequest<GetUpdatesResponse>
+    {
+        private readonly long since;
+        private readonly Channel channel;
+
+        public GetUpdatesRequest(long sinceId, [CanBeNull] Channel channel = null)
+        {
+            this.channel = channel;
+            since = sinceId;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            if (channel != null) req.AddParameter(@"channel", channel.Id.ToString());
+            req.AddParameter(@"since", since.ToString());
+
+            return req;
+        }
+
+        protected override string Target => @"chat/updates";
+    }
+}

osu.Game/Online/API/Requests/GetUpdatesResponse.cs

@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Game.Online.Chat;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetUpdatesResponse
+    {
+        [JsonProperty]
+        public List<Channel> Presence;
+
+        [JsonProperty]
+        public List<Message> Messages;
+    }
+}

osu.Game/Online/API/Requests/JoinChannelRequest.cs

@@ -0,0 +1,31 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Net.Http;
+using osu.Framework.IO.Network;
+using osu.Game.Online.Chat;
+using osu.Game.Users;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class JoinChannelRequest : APIRequest
+    {
+        private readonly Channel channel;
+        private readonly User user;
+
+        public JoinChannelRequest(Channel channel, User user)
+        {
+            this.channel = channel;
+            this.user = user;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.Method = HttpMethod.Put;
+            return req;
+        }
+
+        protected override string Target => $@"chat/channels/{channel.Id}/users/{user.Id}";
+    }
+}

osu.Game/Online/API/Requests/LeaveChannelRequest.cs

@@ -0,0 +1,31 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Net.Http;
+using osu.Framework.IO.Network;
+using osu.Game.Online.Chat;
+using osu.Game.Users;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class LeaveChannelRequest : APIRequest
+    {
+        private readonly Channel channel;
+        private readonly User user;
+
+        public LeaveChannelRequest(Channel channel, User user)
+        {
+            this.channel = channel;
+            this.user = user;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.Method = HttpMethod.Delete;
+            return req;
+        }
+
+        protected override string Target => $@"chat/channels/{channel.Id}/users/{user.Id}";
+    }
+}

osu.Game/Online/API/Requests/PostMessageRequest.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Extensions;
+using System.Net.Http;
 using osu.Framework.IO.Network;
 using osu.Game.Online.Chat;
 
@@ -20,15 +20,13 @@ namespace osu.Game.Online.API.Requests
         {
             var req = base.CreateWebRequest();
 
-            req.Method = HttpMethod.POST;
-            req.AddParameter(@"target_type", message.TargetType.GetDescription());
-            req.AddParameter(@"target_id", message.TargetId.ToString());
+            req.Method = HttpMethod.Post;
             req.AddParameter(@"is_action", message.IsAction.ToString().ToLowerInvariant());
             req.AddParameter(@"message", message.Content);
 
             return req;
         }
 
-        protected override string Target => @"chat/messages";
+        protected override string Target => $@"chat/channels/{message.ChannelId}/messages";
     }
 }

osu.Game/Online/API/Requests/Responses/APIBeatmap.cs

@@ -15,6 +15,12 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"beatmapset_id")]
         public int OnlineBeatmapSetID { get; set; }
 
+        [JsonProperty(@"status")]
+        public BeatmapSetOnlineStatus Status { get; set; }
+
+        [JsonProperty(@"beatmapset")]
+        public APIBeatmapSet BeatmapSet { get; set; }
+
         [JsonProperty(@"playcount")]
         private int playCount { get; set; }
 
@@ -59,11 +65,13 @@ namespace osu.Game.Online.API.Requests.Responses
                 Ruleset = rulesets.GetRuleset(ruleset),
                 StarDifficulty = starDifficulty,
                 OnlineBeatmapID = OnlineBeatmapID,
+                Version = version,
+                Status = Status,
                 BeatmapSet = new BeatmapSetInfo
                 {
                     OnlineBeatmapSetID = OnlineBeatmapSetID,
+                    Status = BeatmapSet?.Status ?? BeatmapSetOnlineStatus.None
                 },
-                Version = version,
                 BaseDifficulty = new BeatmapDifficulty
                 {
                     DrainRate = drainRate,

osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs

@@ -20,10 +20,13 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"id")]
         public int? OnlineBeatmapSetID
         {
-            get { return onlineBeatmapSetID; }
-            set { onlineBeatmapSetID = value > 0 ? value : null; }
+            get => onlineBeatmapSetID;
+            set => onlineBeatmapSetID = value > 0 ? value : null;
         }
 
+        [JsonProperty(@"status")]
+        public BeatmapSetOnlineStatus Status { get; set; }
+
         [JsonProperty(@"preview_url")]
         private string preview { get; set; }
 
@@ -42,9 +45,6 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"storyboard")]
         private bool hasStoryboard { get; set; }
 
-        [JsonProperty(@"status")]
-        private BeatmapSetOnlineStatus status { get; set; }
-
         [JsonProperty(@"submitted_date")]
         private DateTimeOffset submitted { get; set; }
 
@@ -57,7 +57,7 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"user_id")]
         private long creatorId
         {
-            set { Author.Id = value; }
+            set => Author.Id = value;
         }
 
         [JsonProperty(@"beatmaps")]
@@ -69,6 +69,7 @@ namespace osu.Game.Online.API.Requests.Responses
             {
                 OnlineBeatmapSetID = OnlineBeatmapSetID,
                 Metadata = this,
+                Status = Status,
                 OnlineInfo = new BeatmapSetOnlineInfo
                 {
                     Covers = covers,
@@ -76,7 +77,7 @@ namespace osu.Game.Online.API.Requests.Responses
                     PlayCount = playCount,
                     FavouriteCount = favouriteCount,
                     BPM = bpm,
-                    Status = status,
+                    Status = Status,
                     HasVideo = hasVideo,
                     HasStoryboard = hasStoryboard,
                     Submitted = submitted,

osu.Game/Online/API/Requests/SearchBeatmapSetsRequest.cs

@@ -1,16 +1,14 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using System.ComponentModel;
-using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Direct;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class SearchBeatmapSetsRequest : APIRequest<IEnumerable<APIBeatmapSet>>
+    public class SearchBeatmapSetsRequest : APIRequest<SearchBeatmapSetsResponse>
     {
         private readonly string query;
         private readonly RulesetInfo ruleset;
@@ -35,6 +33,7 @@ namespace osu.Game.Online.API.Requests
     public enum BeatmapSearchCategory
     {
         Any = 7,
+
         [Description("Ranked & Approved")]
         RankedApproved = 0,
         Approved = 1,
@@ -43,6 +42,7 @@ namespace osu.Game.Online.API.Requests
         Qualified = 3,
         Pending = 4,
         Graveyard = 5,
+
         [Description("My Maps")]
         MyMaps = 6,
     }

osu.Game/Online/API/Requests/SearchBeatmapSetsResponse.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class SearchBeatmapSetsResponse
+    {
+        public IEnumerable<APIBeatmapSet> BeatmapSets;
+
+        /// <summary>
+        /// A collection of parameters which should be passed to the search endpoint to fetch the next page.
+        /// </summary>
+        [JsonProperty("cursor")]
+        public dynamic CursorJson;
+    }
+}

osu.Game/Online/Chat/Channel.cs

@@ -3,15 +3,64 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using Newtonsoft.Json;
 using osu.Framework.Configuration;
 using osu.Framework.Lists;
+using osu.Game.Users;
 
 namespace osu.Game.Online.Chat
 {
     public class Channel
     {
+        public readonly int MaxHistory = 300;
+
+        /// <summary>
+        /// Contains every joined user except the current logged in user. Currently only returned for PM channels.
+        /// </summary>
+        public readonly ObservableCollection<User> Users = new ObservableCollection<User>();
+
+        [JsonProperty(@"users")]
+        private long[] userIds
+        {
+            set
+            {
+                foreach (var id in value)
+                    Users.Add(new User { Id = id });
+            }
+        }
+
+        /// <summary>
+        /// Contains all the messages send in the channel.
+        /// </summary>
+        public readonly SortedList<Message> Messages = new SortedList<Message>(Comparer<Message>.Default);
+
+        /// <summary>
+        /// Contains all the messages that are still pending for submission to the server.
+        /// </summary>
+        private readonly List<LocalEchoMessage> pendingMessages = new List<LocalEchoMessage>();
+
+
+        /// <summary>
+        /// An event that fires when new messages arrived.
+        /// </summary>
+        public event Action<IEnumerable<Message>> NewMessagesArrived;
+
+        /// <summary>
+        /// An event that fires when a pending message gets resolved.
+        /// </summary>
+        public event Action<LocalEchoMessage, Message> PendingMessageResolved;
+
+        /// <summary>
+        /// An event that fires when a pending message gets removed.
+        /// </summary>
+        public event Action<Message> MessageRemoved;
+
+        public bool ReadOnly => false; //todo not yet used.
+
+        public override string ToString() => Name;
+
         [JsonProperty(@"name")]
         public string Name;
 
@@ -19,19 +68,19 @@ namespace osu.Game.Online.Chat
         public string Topic;
 
         [JsonProperty(@"type")]
-        public string Type;
+        public ChannelType Type;
 
         [JsonProperty(@"channel_id")]
-        public int Id;
+        public long Id;
 
-        public readonly SortedList<Message> Messages = new SortedList<Message>(Comparer<Message>.Default);
-
-        private readonly List<LocalEchoMessage> pendingMessages = new List<LocalEchoMessage>();
+        [JsonProperty(@"last_message_id")]
+        public long? LastMessageId;
 
+        /// <summary>
+        /// Signalles if the current user joined this channel or not. Defaults to false.
+        /// </summary>
         public Bindable<bool> Joined = new Bindable<bool>();
 
-        public bool ReadOnly => false;
-
         public const int MAX_HISTORY = 300;
 
         [JsonConstructor]
@@ -39,10 +88,10 @@ namespace osu.Game.Online.Chat
         {
         }
 
-        public event Action<IEnumerable<Message>> NewMessagesArrived;
-        public event Action<LocalEchoMessage, Message> PendingMessageResolved;
-        public event Action<Message> MessageRemoved;
-
+        /// <summary>
+        /// Adds the argument message as a local echo. When this local echo is resolved <see cref="PendingMessageResolved"/> will get called.
+        /// </summary>
+        /// <param name="message"></param>
         public void AddLocalEcho(LocalEchoMessage message)
         {
             pendingMessages.Add(message);
@@ -51,25 +100,29 @@ namespace osu.Game.Online.Chat
             NewMessagesArrived?.Invoke(new[] { message });
         }
 
+        public bool MessagesLoaded;
+
+        /// <summary>
+        /// Adds new messages to the channel and purges old messages. Triggers the <see cref="NewMessagesArrived"/> event.
+        /// </summary>
+        /// <param name="messages"></param>
         public void AddNewMessages(params Message[] messages)
         {
             messages = messages.Except(Messages).ToArray();
 
+            if (messages.Length == 0) return;
+
             Messages.AddRange(messages);
 
+            var maxMessageId = messages.Max(m => m.Id);
+            if (maxMessageId > LastMessageId)
+                LastMessageId = maxMessageId;
+
             purgeOldMessages();
 
             NewMessagesArrived?.Invoke(messages);
         }
 
-        private void purgeOldMessages()
-        {
-            // never purge local echos
-            int messageCount = Messages.Count - pendingMessages.Count;
-            if (messageCount > MAX_HISTORY)
-                Messages.RemoveRange(0, messageCount - MAX_HISTORY);
-        }
-
         /// <summary>
         /// Replace or remove a message from the channel.
         /// </summary>
@@ -89,17 +142,18 @@ namespace osu.Game.Online.Chat
             }
 
             if (Messages.Contains(final))
-            {
-                // message already inserted, so let's throw away this update.
-                // we may want to handle this better in the future, but for the time being api requests are single-threaded so order is assumed.
-                MessageRemoved?.Invoke(echo);
-                return;
-            }
+                throw new InvalidOperationException("Attempted to add the same message again");
 
             Messages.Add(final);
             PendingMessageResolved?.Invoke(echo, final);
         }
 
-        public override string ToString() => Name;
+        private void purgeOldMessages()
+        {
+            // never purge local echos
+            int messageCount = Messages.Count - pendingMessages.Count;
+            if (messageCount > MaxHistory)
+                Messages.RemoveRange(0, messageCount - MaxHistory);
+        }
     }
 }

osu.Game/Online/Chat/ChannelManager.cs

@@ -0,0 +1,440 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Logging;
+using osu.Framework.Threading;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Users;
+
+namespace osu.Game.Online.Chat
+{
+    /// <summary>
+    /// Manages everything channel related
+    /// </summary>
+    public class ChannelManager : Component, IOnlineComponent
+    {
+        /// <summary>
+        /// The channels the player joins on startup
+        /// </summary>
+        private readonly string[] defaultChannels =
+        {
+            @"#lazer",
+            @"#osu",
+            @"#lobby"
+        };
+
+        /// <summary>
+        /// The currently opened channel
+        /// </summary>
+        public Bindable<Channel> CurrentChannel { get; } = new Bindable<Channel>();
+
+        /// <summary>
+        /// The Channels the player has joined
+        /// </summary>
+        public ObservableCollection<Channel> JoinedChannels { get; } = new ObservableCollection<Channel>(); //todo: should be publicly readonly
+
+        /// <summary>
+        /// The channels available for the player to join
+        /// </summary>
+        public ObservableCollection<Channel> AvailableChannels { get; } = new ObservableCollection<Channel>(); //todo: should be publicly readonly
+
+        private IAPIProvider api;
+        private ScheduledDelegate fetchMessagesScheduleder;
+
+        public ChannelManager()
+        {
+            CurrentChannel.ValueChanged += currentChannelChanged;
+        }
+
+        /// <summary>
+        /// Opens a channel or switches to the channel if already opened.
+        /// </summary>
+        /// <exception cref="ChannelNotFoundException">If the name of the specifed channel was not found this exception will be thrown.</exception>
+        /// <param name="name"></param>
+        public void OpenChannel(string name)
+        {
+            if (name == null)
+                throw new ArgumentNullException(nameof(name));
+
+            CurrentChannel.Value = AvailableChannels.FirstOrDefault(c => c.Name == name) ?? throw new ChannelNotFoundException(name);
+        }
+
+        /// <summary>
+        /// Opens a new private channel.
+        /// </summary>
+        /// <param name="user">The user the private channel is opened with.</param>
+        public void OpenPrivateChannel(User user)
+        {
+            if (user == null)
+                throw new ArgumentNullException(nameof(user));
+
+            CurrentChannel.Value = JoinedChannels.FirstOrDefault(c => c.Type == ChannelType.PM && c.Users.Count == 1 && c.Users.Any(u => u.Id == user.Id))
+                                   ?? new Channel { Name = user.Username, Users = { user }, Type = ChannelType.PM };
+        }
+
+        private void currentChannelChanged(Channel channel) => JoinChannel(channel);
+
+        /// <summary>
+        /// Ensure we run post actions in sequence, once at a time.
+        /// </summary>
+        private readonly Queue<Action> postQueue = new Queue<Action>();
+
+        /// <summary>
+        /// Posts a message to the currently opened channel.
+        /// </summary>
+        /// <param name="text">The message text that is going to be posted</param>
+        /// <param name="isAction">Is true if the message is an action, e.g.: user is currently eating </param>
+        public void PostMessage(string text, bool isAction = false)
+        {
+            if (CurrentChannel.Value == null)
+                return;
+
+            var currentChannel = CurrentChannel.Value;
+
+            void dequeueAndRun()
+            {
+                if (postQueue.Count > 0)
+                    postQueue.Dequeue().Invoke();
+            }
+
+            postQueue.Enqueue(() =>
+            {
+                if (!api.IsLoggedIn)
+                {
+                    currentChannel.AddNewMessages(new ErrorMessage("Please sign in to participate in chat!"));
+                    return;
+                }
+
+                var message = new LocalEchoMessage
+                {
+                    Sender = api.LocalUser.Value,
+                    Timestamp = DateTimeOffset.Now,
+                    ChannelId = CurrentChannel.Value.Id,
+                    IsAction = isAction,
+                    Content = text
+                };
+
+                currentChannel.AddLocalEcho(message);
+
+                // if this is a PM and the first message, we need to do a special request to create the PM channel
+                if (currentChannel.Type == ChannelType.PM && !currentChannel.Joined)
+                {
+                    var createNewPrivateMessageRequest = new CreateNewPrivateMessageRequest(currentChannel.Users.First(), message);
+
+                    createNewPrivateMessageRequest.Success += createRes =>
+                    {
+                        currentChannel.Id = createRes.ChannelID;
+                        currentChannel.ReplaceMessage(message, createRes.Message);
+                        dequeueAndRun();
+                    };
+
+                    createNewPrivateMessageRequest.Failure += exception =>
+                    {
+                        Logger.Error(exception, "Posting message failed.");
+                        currentChannel.ReplaceMessage(message, null);
+                        dequeueAndRun();
+                    };
+
+                    api.Queue(createNewPrivateMessageRequest);
+                    return;
+                }
+
+                var req = new PostMessageRequest(message);
+
+                req.Success += m =>
+                {
+                    currentChannel.ReplaceMessage(message, m);
+                    dequeueAndRun();
+                };
+
+                req.Failure += exception =>
+                {
+                    Logger.Error(exception, "Posting message failed.");
+                    currentChannel.ReplaceMessage(message, null);
+                    dequeueAndRun();
+                };
+
+                api.Queue(req);
+            });
+
+            // always run if the queue is empty
+            if (postQueue.Count == 1)
+                dequeueAndRun();
+        }
+
+        /// <summary>
+        /// Posts a command locally. Commands like /help will result in a help message written in the current channel.
+        /// </summary>
+        /// <param name="text">the text containing the command identifier and command parameters.</param>
+        public void PostCommand(string text)
+        {
+            if (CurrentChannel.Value == null)
+                return;
+
+            var parameters = text.Split(new[] { ' ' }, 2);
+            string command = parameters[0];
+            string content = parameters.Length == 2 ? parameters[1] : string.Empty;
+
+            switch (command)
+            {
+                case "me":
+                    if (string.IsNullOrWhiteSpace(content))
+                    {
+                        CurrentChannel.Value.AddNewMessages(new ErrorMessage("Usage: /me [action]"));
+                        break;
+                    }
+
+                    PostMessage(content, true);
+                    break;
+
+                case "help":
+                    CurrentChannel.Value.AddNewMessages(new InfoMessage("Supported commands: /help, /me [action]"));
+                    break;
+
+                default:
+                    CurrentChannel.Value.AddNewMessages(new ErrorMessage($@"""/{command}"" is not supported! For a list of supported commands see /help"));
+                    break;
+            }
+        }
+
+        private void handleChannelMessages(IEnumerable<Message> messages)
+        {
+            var channels = JoinedChannels.ToList();
+
+            foreach (var group in messages.GroupBy(m => m.ChannelId))
+                channels.Find(c => c.Id == group.Key)?.AddNewMessages(group.ToArray());
+        }
+
+        private void initializeChannels()
+        {
+            var req = new ListChannelsRequest();
+
+            var joinDefaults = JoinedChannels.Count == 0;
+
+            req.Success += channels =>
+            {
+                foreach (var channel in channels)
+                {
+                    var ch = getChannel(channel, addToAvailable: true);
+
+                    // join any channels classified as "defaults"
+                    if (joinDefaults && defaultChannels.Any(c => c.Equals(channel.Name, StringComparison.OrdinalIgnoreCase)))
+                        JoinChannel(ch);
+                }
+            };
+            req.Failure += error =>
+            {
+                Logger.Error(error, "Fetching channel list failed");
+                initializeChannels();
+            };
+
+            api.Queue(req);
+        }
+
+        /// <summary>
+        /// Fetches inital messages of a channel
+        ///
+        /// TODO: remove this when the API supports returning initial fetch messages for more than one channel by specifying the last message id per channel instead of one last message id globally.
+        /// right now it caps out at 50 messages and therefore only returns one channel's worth of content.
+        /// </summary>
+        /// <param name="channel">The channel </param>
+        private void fetchInitalMessages(Channel channel)
+        {
+            if (channel.Id <= 0) return;
+
+            var fetchInitialMsgReq = new GetMessagesRequest(channel);
+            fetchInitialMsgReq.Success += messages =>
+            {
+                handleChannelMessages(messages);
+                channel.MessagesLoaded = true; // this will mark the channel as having received messages even if there were none.
+            };
+
+            api.Queue(fetchInitialMsgReq);
+        }
+
+        /// <summary>
+        /// Find an existing channel instance for the provided channel. Lookup is performed basd on ID.
+        /// The provided channel may be used if an existing instance is not found.
+        /// </summary>
+        /// <param name="lookup">A candidate channel to be used for lookup or permanently on lookup failure.</param>
+        /// <param name="addToAvailable">Whether the channel should be added to <see cref="AvailableChannels"/> if not already.</param>
+        /// <param name="addToJoined">Whether the channel should be added to <see cref="JoinedChannels"/> if not already.</param>
+        /// <returns>The found channel.</returns>
+        private Channel getChannel(Channel lookup, bool addToAvailable = false, bool addToJoined = false)
+        {
+            Channel found = null;
+
+            bool lookupCondition(Channel ch) => lookup.Id > 0 ? ch.Id == lookup.Id : lookup.Name == ch.Name;
+
+            var available = AvailableChannels.FirstOrDefault(lookupCondition);
+            if (available != null)
+                found = available;
+
+            var joined = JoinedChannels.FirstOrDefault(lookupCondition);
+            if (found == null && joined != null)
+                found = joined;
+
+            if (found == null)
+            {
+                found = lookup;
+
+                // if we're using a channel object from the server, we want to remove ourselves from the users list.
+                // this is because we check the first user in the channel to display a name/icon on tabs for now.
+                var foundSelf = found.Users.FirstOrDefault(u => u.Id == api.LocalUser.Value.Id);
+                if (foundSelf != null)
+                    found.Users.Remove(foundSelf);
+            }
+
+            if (joined == null && addToJoined) JoinedChannels.Add(found);
+            if (available == null && addToAvailable) AvailableChannels.Add(found);
+
+            return found;
+        }
+
+        /// <summary>
+        /// Joins a channel if it has not already been joined.
+        /// </summary>
+        /// <param name="channel">The channel to join.</param>
+        /// <param name="alreadyJoined">Whether the channel has already been joined server-side. Will skip a join request.</param>
+        /// <returns>The joined channel. Note that this may not match the parameter channel as it is a backed object.</returns>
+        public Channel JoinChannel(Channel channel, bool alreadyJoined = false)
+        {
+            if (channel == null) return null;
+
+            channel = getChannel(channel, addToJoined: true);
+
+            // ensure we are joined to the channel
+            if (!channel.Joined.Value)
+            {
+                if (alreadyJoined)
+                    channel.Joined.Value = true;
+                else
+                {
+                    switch (channel.Type)
+                    {
+                        case ChannelType.Public:
+                            var req = new JoinChannelRequest(channel, api.LocalUser);
+                            req.Success += () => JoinChannel(channel, true);
+                            req.Failure += ex => LeaveChannel(channel);
+                            api.Queue(req);
+                            return channel;
+                    }
+                }
+            }
+
+            if (CurrentChannel.Value == null)
+                CurrentChannel.Value = channel;
+
+            if (!channel.MessagesLoaded)
+            {
+                // let's fetch a small number of messages to bring us up-to-date with the backlog.
+                fetchInitalMessages(channel);
+            }
+
+            return channel;
+        }
+
+        public void LeaveChannel(Channel channel)
+        {
+            if (channel == null) return;
+
+            if (channel == CurrentChannel.Value) CurrentChannel.Value = null;
+
+            JoinedChannels.Remove(channel);
+
+            if (channel.Joined.Value)
+            {
+                api.Queue(new LeaveChannelRequest(channel, api.LocalUser));
+                channel.Joined.Value = false;
+            }
+        }
+
+        public void APIStateChanged(APIAccess api, APIState state)
+        {
+            switch (state)
+            {
+                case APIState.Online:
+                    fetchUpdates();
+                    break;
+                default:
+                    fetchMessagesScheduleder?.Cancel();
+                    fetchMessagesScheduleder = null;
+                    break;
+            }
+        }
+
+        private long lastMessageId;
+        private const int update_poll_interval = 1000;
+
+        private bool channelsInitialised;
+
+        private void fetchUpdates()
+        {
+            fetchMessagesScheduleder?.Cancel();
+            fetchMessagesScheduleder = Scheduler.AddDelayed(() =>
+            {
+                var fetchReq = new GetUpdatesRequest(lastMessageId);
+
+                fetchReq.Success += updates =>
+                {
+                    if (updates?.Presence != null)
+                    {
+                        foreach (var channel in updates.Presence)
+                        {
+                            // we received this from the server so should mark the channel already joined.
+                            JoinChannel(channel, true);
+                        }
+
+                        //todo: handle left channels
+
+                        handleChannelMessages(updates.Messages);
+
+                        foreach (var group in updates.Messages.GroupBy(m => m.ChannelId))
+                            JoinedChannels.FirstOrDefault(c => c.Id == group.Key)?.AddNewMessages(group.ToArray());
+
+                        lastMessageId = updates.Messages.LastOrDefault()?.Id ?? lastMessageId;
+                    }
+
+                    if (!channelsInitialised)
+                    {
+                        channelsInitialised = true;
+                        // we want this to run after the first presence so we can see if the user is in any channels already.
+                        initializeChannels();
+                    }
+
+                    fetchUpdates();
+                };
+
+                fetchReq.Failure += delegate { fetchUpdates(); };
+
+                api.Queue(fetchReq);
+            }, update_poll_interval);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IAPIProvider api)
+        {
+            this.api = api;
+            api.Register(this);
+        }
+    }
+
+    /// <summary>
+    /// An exception thrown when a channel could not been found.
+    /// </summary>
+    public class ChannelNotFoundException : Exception
+    {
+        public ChannelNotFoundException(string channelName)
+            : base($"A channel with the name {channelName} could not be found.")
+        {
+        }
+    }
+}

osu.Game/Online/Chat/ChannelType.cs

@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Online.Chat
+{
+    public enum ChannelType
+    {
+        Public,
+        Private,
+        Multiplayer,
+        Spectator,
+        Temporary,
+        PM,
+        Group,
+    }
+}

osu.Game/Online/Chat/DrawableLinkCompiler.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Online.Chat
 {
@@ -24,7 +24,7 @@ namespace osu.Game.Online.Chat
         /// </summary>
         public List<SpriteText> Parts;
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => Parts.Any(d => d.ReceiveMouseInputAt(screenSpacePos));
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Parts.Any(d => d.ReceivePositionalInputAt(screenSpacePos));
 
         protected override HoverClickSounds CreateHoverClickSounds(HoverSampleSet sampleSet) => new LinkHoverSounds(sampleSet, Parts);
 
@@ -53,7 +53,7 @@ namespace osu.Game.Online.Chat
                 this.parts = parts;
             }
 
-            public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => parts.Any(d => d.ReceiveMouseInputAt(screenSpacePos));
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => parts.Any(d => d.ReceivePositionalInputAt(screenSpacePos));
         }
     }
 }

osu.Game/Online/Chat/ExternalLinkOpener.cs

@@ -0,0 +1,36 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Platform;
+using osu.Game.Configuration;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Chat;
+
+namespace osu.Game.Online.Chat
+{
+    public class ExternalLinkOpener : Component
+    {
+        private GameHost host;
+        private DialogOverlay dialogOverlay;
+        private Bindable<bool> externalLinkWarning;
+
+        [BackgroundDependencyLoader(true)]
+        private void load(GameHost host, DialogOverlay dialogOverlay, OsuConfigManager config)
+        {
+            this.host = host;
+            this.dialogOverlay = dialogOverlay;
+            externalLinkWarning = config.GetBindable<bool>(OsuSetting.ExternalLinkWarning);
+        }
+
+        public void OpenUrlExternally(string url)
+        {
+            if (externalLinkWarning)
+                dialogOverlay.Push(new ExternalLinkDialog(url, () => host.OpenUrlExternally(url)));
+            else
+                host.OpenUrlExternally(url);
+        }
+    }
+}

osu.Game/Online/Chat/InfoMessage.cs

@@ -15,11 +15,7 @@ namespace osu.Game.Online.Chat
             Timestamp = DateTimeOffset.Now;
             Content = message;
 
-            Sender = new User
-            {
-                Username = @"system",
-                Colour = @"0000ff",
-            };
+            Sender = User.SYSTEM_USER;
         }
     }
 }

osu.Game/Online/Chat/Message.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using Newtonsoft.Json;
 using osu.Game.Users;
 
@@ -16,13 +15,10 @@ namespace osu.Game.Online.Chat
 
         //todo: this should be inside sender.
         [JsonProperty(@"sender_id")]
-        public int UserId;
+        public long UserId;
 
-        [JsonProperty(@"target_type")]
-        public TargetType TargetType;
-
-        [JsonProperty(@"target_id")]
-        public int TargetId;
+        [JsonProperty(@"channel_id")]
+        public long ChannelId;
 
         [JsonProperty(@"is_action")]
         public bool IsAction;
@@ -72,12 +68,4 @@ namespace osu.Game.Online.Chat
         // ReSharper disable once ImpureMethodCallOnReadonlyValueField
         public override int GetHashCode() => Id.GetHashCode();
     }
-
-    public enum TargetType
-    {
-        [Description(@"channel")]
-        Channel,
-        [Description(@"user")]
-        User
-    }
 }

osu.Game/Online/Multiplayer/GameType.cs

@@ -1,8 +1,8 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;

osu.Game/Online/Multiplayer/RoomStatus.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Game.Graphics;
 
 namespace osu.Game.Online.Multiplayer