1829 lines
87 KiB
C#
1829 lines
87 KiB
C#
|
// ----------------------------------------------------------------------------------------------------------------------
|
|||
|
|
// <summary>The Photon Chat Api enables clients to connect to a chat server and communicate with other clients.</summary>
|
|||
|
|
// <remarks>ChatClient is the main class of this api.</remarks>
|
|||
|
|
// <copyright company="Exit Games GmbH">Photon Chat Api - Copyright (C) 2014 Exit Games GmbH</copyright>
|
|||
|
|
// ----------------------------------------------------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
#if UNITY_4_7 || UNITY_5 || UNITY_5_3_OR_NEWER
|
|||
|
|
#define SUPPORTED_UNITY
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
namespace Photon.Chat
|
|||
|
|
{
|
|||
|
|
using System;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using System.Diagnostics;
|
|||
|
|
using ExitGames.Client.Photon;
|
|||
|
|
|
|||
|
|
#if SUPPORTED_UNITY || NETFX_CORE
|
|||
|
|
using Hashtable = ExitGames.Client.Photon.Hashtable;
|
|||
|
|
using SupportClass = ExitGames.Client.Photon.SupportClass;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
|
|||
|
|
/// <summary>Central class of the Photon Chat API to connect, handle channels and messages.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// This class must be instantiated with a IChatClientListener instance to get the callbacks.
|
|||
|
|
/// Integrate it into your game loop by calling Service regularly. If the target platform supports Threads/Tasks,
|
|||
|
|
/// set UseBackgroundWorkerForSending = true, to let the ChatClient keep the connection by sending from
|
|||
|
|
/// an independent thread.
|
|||
|
|
///
|
|||
|
|
/// Call Connect with an AppId that is setup as Photon Chat application. Note: Connect covers multiple
|
|||
|
|
/// messages between this client and the servers. A short workflow will connect you to a chat server.
|
|||
|
|
///
|
|||
|
|
/// Each ChatClient resembles a user in chat (set in Connect). Each user automatically subscribes a channel
|
|||
|
|
/// for incoming private messages and can message any other user privately.
|
|||
|
|
/// Before you publish messages in any non-private channel, that channel must be subscribed.
|
|||
|
|
///
|
|||
|
|
/// PublicChannels is a list of subscribed channels, containing messages and senders.
|
|||
|
|
/// PrivateChannels contains all incoming and sent private messages.
|
|||
|
|
/// </remarks>
|
|||
|
|
public class ChatClient : IPhotonPeerListener
|
|||
|
|
{
|
|||
|
|
const int FriendRequestListMax = 1024;
|
|||
|
|
|
|||
|
|
/// <summary> Default maximum value possible for <see cref="ChatChannel.MaxSubscribers"/> when <see cref="ChatChannel.PublishSubscribers"/> is enabled</summary>
|
|||
|
|
public const int DefaultMaxSubscribers = 100;
|
|||
|
|
|
|||
|
|
private const byte HttpForwardWebFlag = 0x01;
|
|||
|
|
|
|||
|
|
/// <summary>Enables a fallback to another protocol in case a connect to the Name Server fails.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// When connecting to the Name Server fails for a first time, the client will select an alternative
|
|||
|
|
/// network protocol and re-try to connect.
|
|||
|
|
///
|
|||
|
|
/// The fallback will use the default Name Server port as defined by ProtocolToNameServerPort.
|
|||
|
|
///
|
|||
|
|
/// The fallback for TCP is UDP. All other protocols fallback to TCP.
|
|||
|
|
/// </remarks>
|
|||
|
|
public bool EnableProtocolFallback { get; set; }
|
|||
|
|
|
|||
|
|
/// <summary>The address of last connected Name Server.</summary>
|
|||
|
|
public string NameServerAddress { get; private set; }
|
|||
|
|
|
|||
|
|
/// <summary>The address of the actual chat server assigned from NameServer. Public for read only.</summary>
|
|||
|
|
public string FrontendAddress { get; private set; }
|
|||
|
|
|
|||
|
|
/// <summary>Region used to connect to. Currently all chat is done in EU. It can make sense to use only one region for the whole game.</summary>
|
|||
|
|
private string chatRegion = "EU";
|
|||
|
|
|
|||
|
|
/// <summary>Settable only before you connect! Defaults to "EU".</summary>
|
|||
|
|
public string ChatRegion
|
|||
|
|
{
|
|||
|
|
get { return this.chatRegion; }
|
|||
|
|
set { this.chatRegion = value; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Current state of the ChatClient. Also use CanChat.</summary>
|
|||
|
|
public ChatState State { get; private set; }
|
|||
|
|
|
|||
|
|
/// <summary> Disconnection cause. Check this inside <see cref="IChatClientListener.OnDisconnected"/>. </summary>
|
|||
|
|
public ChatDisconnectCause DisconnectedCause { get; private set; }
|
|||
|
|
/// <summary>
|
|||
|
|
/// Checks if this client is ready to send messages.
|
|||
|
|
/// </summary>
|
|||
|
|
public bool CanChat
|
|||
|
|
{
|
|||
|
|
get { return this.State == ChatState.ConnectedToFrontEnd && this.HasPeer; }
|
|||
|
|
}
|
|||
|
|
/// <summary>
|
|||
|
|
/// Checks if this client is ready to publish messages inside a public channel.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="channelName">The channel to do the check with.</param>
|
|||
|
|
/// <returns>Whether or not this client is ready to publish messages inside the public channel with the specified channelName.</returns>
|
|||
|
|
public bool CanChatInChannel(string channelName)
|
|||
|
|
{
|
|||
|
|
return this.CanChat && this.PublicChannels.ContainsKey(channelName) && !this.PublicChannelsUnsubscribing.Contains(channelName);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool HasPeer
|
|||
|
|
{
|
|||
|
|
get { return this.chatPeer != null; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>The version of your client. A new version also creates a new "virtual app" to separate players from older client versions.</summary>
|
|||
|
|
public string AppVersion { get; private set; }
|
|||
|
|
|
|||
|
|
/// <summary>The AppID as assigned from the Photon Cloud.</summary>
|
|||
|
|
public string AppId { get; private set; }
|
|||
|
|
|
|||
|
|
|
|||
|
|
/// <summary>Settable only before you connect!</summary>
|
|||
|
|
public AuthenticationValues AuthValues { get; set; }
|
|||
|
|
|
|||
|
|
/// <summary>The unique ID of a user/person, stored in AuthValues.UserId. Set it before you connect.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// This value wraps AuthValues.UserId.
|
|||
|
|
/// It's not a nickname and we assume users with the same userID are the same person.</remarks>
|
|||
|
|
public string UserId
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
return (this.AuthValues != null) ? this.AuthValues.UserId : null;
|
|||
|
|
}
|
|||
|
|
private set
|
|||
|
|
{
|
|||
|
|
if (this.AuthValues == null)
|
|||
|
|
{
|
|||
|
|
this.AuthValues = new AuthenticationValues();
|
|||
|
|
}
|
|||
|
|
this.AuthValues.UserId = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>If greater than 0, new channels will limit the number of messages they cache locally.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// This can be useful to limit the amount of memory used by chats.
|
|||
|
|
/// You can set a MessageLimit per channel but this value gets applied to new ones.
|
|||
|
|
///
|
|||
|
|
/// Note:
|
|||
|
|
/// Changing this value, does not affect ChatChannels that are already in use!
|
|||
|
|
/// </remarks>
|
|||
|
|
public int MessageLimit;
|
|||
|
|
|
|||
|
|
/// <summary>Limits the number of messages from private channel histories.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// This is applied to all private channels on reconnect, as there is no explicit re-joining private channels.<br/>
|
|||
|
|
/// Default is -1, which gets available messages up to a maximum set by the server.<br/>
|
|||
|
|
/// A value of 0 gets you zero messages.<br/>
|
|||
|
|
/// The server's limit of messages may be lower. If so, the server's value will overrule this.<br/>
|
|||
|
|
/// </remarks>
|
|||
|
|
public int PrivateChatHistoryLength = -1;
|
|||
|
|
|
|||
|
|
/// <summary> Public channels this client is subscribed to. </summary>
|
|||
|
|
public readonly Dictionary<string, ChatChannel> PublicChannels;
|
|||
|
|
/// <summary> Private channels in which this client has exchanged messages. </summary>
|
|||
|
|
public readonly Dictionary<string, ChatChannel> PrivateChannels;
|
|||
|
|
|
|||
|
|
// channels being in unsubscribing process
|
|||
|
|
// items will be removed on successful unsubscription or subscription (the latter required after attempt to unsubscribe from not existing channel)
|
|||
|
|
private readonly HashSet<string> PublicChannelsUnsubscribing;
|
|||
|
|
|
|||
|
|
private readonly IChatClientListener listener = null;
|
|||
|
|
/// <summary> The Chat Peer used by this client. </summary>
|
|||
|
|
public ChatPeer chatPeer = null;
|
|||
|
|
private const string ChatAppName = "chat";
|
|||
|
|
private bool didAuthenticate;
|
|||
|
|
|
|||
|
|
private int? statusToSetWhenConnected;
|
|||
|
|
private object messageToSetWhenConnected;
|
|||
|
|
|
|||
|
|
private int msDeltaForServiceCalls = 50;
|
|||
|
|
private int msTimestampOfLastServiceCall;
|
|||
|
|
|
|||
|
|
/// <summary>Defines if a background thread will call SendOutgoingCommands, while your code calls Service to dispatch received messages.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// The benefit of using a background thread to call SendOutgoingCommands is this:
|
|||
|
|
///
|
|||
|
|
/// Even if your game logic is being paused, the background thread will keep the connection to the server up.
|
|||
|
|
/// On a lower level, acknowledgements and pings will prevent a server-side timeout while (e.g.) Unity loads assets.
|
|||
|
|
///
|
|||
|
|
/// Your game logic still has to call Service regularly, or else incoming messages are not dispatched.
|
|||
|
|
/// As this typically triggers UI updates, it's easier to call Service from the main/UI thread.
|
|||
|
|
/// </remarks>
|
|||
|
|
public bool UseBackgroundWorkerForSending { get; set; }
|
|||
|
|
|
|||
|
|
/// <summary>Exposes the TransportProtocol of the used PhotonPeer. Settable while not connected.</summary>
|
|||
|
|
public ConnectionProtocol TransportProtocol
|
|||
|
|
{
|
|||
|
|
get { return this.chatPeer.TransportProtocol; }
|
|||
|
|
set
|
|||
|
|
{
|
|||
|
|
if (this.chatPeer == null || this.chatPeer.PeerState != PeerStateValue.Disconnected)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "Can't set TransportProtocol. Disconnect first! " + ((this.chatPeer != null) ? "PeerState: " + this.chatPeer.PeerState : "The chatPeer is null."));
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
this.chatPeer.TransportProtocol = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Defines which IPhotonSocket class to use per ConnectionProtocol.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// Several platforms have special Socket implementations and slightly different APIs.
|
|||
|
|
/// To accomodate this, switching the socket implementation for a network protocol was made available.
|
|||
|
|
/// By default, UDP and TCP have socket implementations assigned.
|
|||
|
|
///
|
|||
|
|
/// You only need to set the SocketImplementationConfig once, after creating a PhotonPeer
|
|||
|
|
/// and before connecting. If you switch the TransportProtocol, the correct implementation is being used.
|
|||
|
|
/// </remarks>
|
|||
|
|
public Dictionary<ConnectionProtocol, Type> SocketImplementationConfig
|
|||
|
|
{
|
|||
|
|
get { return this.chatPeer.SocketImplementationConfig; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Chat client constructor.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="listener">The chat listener implementation.</param>
|
|||
|
|
/// <param name="protocol">Connection protocol to be used by this client. Default is <see cref="ConnectionProtocol.Udp"/>.</param>
|
|||
|
|
public ChatClient(IChatClientListener listener, ConnectionProtocol protocol = ConnectionProtocol.Udp)
|
|||
|
|
{
|
|||
|
|
this.listener = listener;
|
|||
|
|
this.State = ChatState.Uninitialized;
|
|||
|
|
|
|||
|
|
this.chatPeer = new ChatPeer(this, protocol);
|
|||
|
|
this.chatPeer.SerializationProtocolType = SerializationProtocol.GpBinaryV18;
|
|||
|
|
|
|||
|
|
this.PublicChannels = new Dictionary<string, ChatChannel>();
|
|||
|
|
this.PrivateChannels = new Dictionary<string, ChatChannel>();
|
|||
|
|
|
|||
|
|
this.PublicChannelsUnsubscribing = new HashSet<string>();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
public bool ConnectUsingSettings(ChatAppSettings appSettings)
|
|||
|
|
{
|
|||
|
|
if (appSettings == null)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "ConnectUsingSettings failed. The appSettings can't be null.'");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!string.IsNullOrEmpty(appSettings.FixedRegion))
|
|||
|
|
{
|
|||
|
|
this.ChatRegion = appSettings.FixedRegion;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.DebugOut = appSettings.NetworkLogging;
|
|||
|
|
|
|||
|
|
this.TransportProtocol = appSettings.Protocol;
|
|||
|
|
this.EnableProtocolFallback = appSettings.EnableProtocolFallback;
|
|||
|
|
|
|||
|
|
if (!appSettings.IsDefaultNameServer)
|
|||
|
|
{
|
|||
|
|
this.chatPeer.NameServerHost = appSettings.Server;
|
|||
|
|
this.chatPeer.NameServerPortOverride = appSettings.Port;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.Connect(appSettings.AppIdChat, appSettings.AppVersion, this.AuthValues);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Connects this client to the Photon Chat Cloud service, which will also authenticate the user (and set a UserId).
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="appId">Get your Photon Chat AppId from the <a href="https://dashboard.photonengine.com">Dashboard</a>.</param>
|
|||
|
|
/// <param name="appVersion">Any version string you make up. Used to separate users and variants of your clients, which might be incompatible.</param>
|
|||
|
|
/// <param name="authValues">Values for authentication. You can leave this null, if you set a UserId before. If you set authValues, they will override any UserId set before.</param>
|
|||
|
|
/// <returns></returns>
|
|||
|
|
public bool Connect(string appId, string appVersion, AuthenticationValues authValues)
|
|||
|
|
{
|
|||
|
|
this.chatPeer.TimePingInterval = 3000;
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.None;
|
|||
|
|
|
|||
|
|
if (authValues != null)
|
|||
|
|
{
|
|||
|
|
this.AuthValues = authValues;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.AppId = appId;
|
|||
|
|
this.AppVersion = appVersion;
|
|||
|
|
this.didAuthenticate = false;
|
|||
|
|
this.chatPeer.QuickResendAttempts = 2;
|
|||
|
|
this.chatPeer.SentCountAllowance = 7;
|
|||
|
|
|
|||
|
|
// clean all channels
|
|||
|
|
this.PublicChannels.Clear();
|
|||
|
|
this.PrivateChannels.Clear();
|
|||
|
|
this.PublicChannelsUnsubscribing.Clear();
|
|||
|
|
|
|||
|
|
#if UNITY_WEBGL
|
|||
|
|
if (this.TransportProtocol == ConnectionProtocol.Tcp || this.TransportProtocol == ConnectionProtocol.Udp)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "WebGL requires WebSockets. Switching TransportProtocol to WebSocketSecure.");
|
|||
|
|
this.TransportProtocol = ConnectionProtocol.WebSocketSecure;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
this.NameServerAddress = this.chatPeer.NameServerAddress;
|
|||
|
|
|
|||
|
|
bool isConnecting = this.chatPeer.Connect();
|
|||
|
|
if (isConnecting)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.ConnectingToNameServer;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (this.UseBackgroundWorkerForSending)
|
|||
|
|
{
|
|||
|
|
#if UNITY_SWITCH
|
|||
|
|
SupportClass.StartBackgroundCalls(this.SendOutgoingInBackground, this.msDeltaForServiceCalls); // as workaround, we don't name the Thread.
|
|||
|
|
#else
|
|||
|
|
SupportClass.StartBackgroundCalls(this.SendOutgoingInBackground, this.msDeltaForServiceCalls, "ChatClient Service Thread");
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return isConnecting;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Connects this client to the Photon Chat Cloud service, which will also authenticate the user (and set a UserId).
|
|||
|
|
/// This also sets an online status once connected. By default it will set user status to <see cref="ChatUserStatus.Online"/>.
|
|||
|
|
/// See <see cref="SetOnlineStatus(int,object)"/> for more information.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="appId">Get your Photon Chat AppId from the <a href="https://dashboard.photonengine.com">Dashboard</a>.</param>
|
|||
|
|
/// <param name="appVersion">Any version string you make up. Used to separate users and variants of your clients, which might be incompatible.</param>
|
|||
|
|
/// <param name="authValues">Values for authentication. You can leave this null, if you set a UserId before. If you set authValues, they will override any UserId set before.</param>
|
|||
|
|
/// <param name="status">User status to set when connected. Predefined states are in class <see cref="ChatUserStatus"/>. Other values can be used at will.</param>
|
|||
|
|
/// <param name="message">Optional status Also sets a status-message which your friends can get.</param>
|
|||
|
|
/// <returns>If the connection attempt could be sent at all.</returns>
|
|||
|
|
public bool ConnectAndSetStatus(string appId, string appVersion, AuthenticationValues authValues,
|
|||
|
|
int status = ChatUserStatus.Online, object message = null)
|
|||
|
|
{
|
|||
|
|
statusToSetWhenConnected = status;
|
|||
|
|
messageToSetWhenConnected = message;
|
|||
|
|
return Connect(appId, appVersion, authValues);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Must be called regularly to keep connection between client and server alive and to process incoming messages.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// This method limits the effort it does automatically using the private variable msDeltaForServiceCalls.
|
|||
|
|
/// That value is lower for connect and multiplied by 4 when chat-server connection is ready.
|
|||
|
|
/// </remarks>
|
|||
|
|
public void Service()
|
|||
|
|
{
|
|||
|
|
// Dispatch until every already-received message got dispatched
|
|||
|
|
while (this.HasPeer && this.chatPeer.DispatchIncomingCommands())
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// if there is no background thread for sending, Service() will do that as well, in intervals
|
|||
|
|
if (!this.UseBackgroundWorkerForSending)
|
|||
|
|
{
|
|||
|
|
if (Environment.TickCount - this.msTimestampOfLastServiceCall > this.msDeltaForServiceCalls || this.msTimestampOfLastServiceCall == 0)
|
|||
|
|
{
|
|||
|
|
this.msTimestampOfLastServiceCall = Environment.TickCount;
|
|||
|
|
|
|||
|
|
while (this.HasPeer && this.chatPeer.SendOutgoingCommands())
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Called by a separate thread, this sends outgoing commands of this peer, as long as it's connected.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <returns>True as long as the client is not disconnected.</returns>
|
|||
|
|
private bool SendOutgoingInBackground()
|
|||
|
|
{
|
|||
|
|
while (this.HasPeer && this.chatPeer.SendOutgoingCommands())
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.State != ChatState.Disconnected;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary> Obsolete: Better use UseBackgroundWorkerForSending and Service(). </summary>
|
|||
|
|
[Obsolete("Better use UseBackgroundWorkerForSending and Service().")]
|
|||
|
|
public void SendAcksOnly()
|
|||
|
|
{
|
|||
|
|
if (this.HasPeer) this.chatPeer.SendAcksOnly();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Disconnects from the Chat Server by sending a "disconnect command", which prevents a timeout server-side.
|
|||
|
|
/// </summary>
|
|||
|
|
public void Disconnect(ChatDisconnectCause cause = ChatDisconnectCause.DisconnectByClientLogic)
|
|||
|
|
{
|
|||
|
|
if (this.HasPeer && this.chatPeer.PeerState != PeerStateValue.Disconnected)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.Disconnecting;
|
|||
|
|
this.DisconnectedCause = cause;
|
|||
|
|
this.chatPeer.Disconnect();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Locally shuts down the connection to the Chat Server. This resets states locally but the server will have to timeout this peer.
|
|||
|
|
/// </summary>
|
|||
|
|
public void StopThread()
|
|||
|
|
{
|
|||
|
|
if (this.HasPeer)
|
|||
|
|
{
|
|||
|
|
this.chatPeer.StopThread();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Sends operation to subscribe to a list of channels by name.</summary>
|
|||
|
|
/// <param name="channels">List of channels to subscribe to. Avoid null or empty values.</param>
|
|||
|
|
/// <returns>If the operation could be sent at all (Example: Fails if not connected to Chat Server).</returns>
|
|||
|
|
public bool Subscribe(string[] channels)
|
|||
|
|
{
|
|||
|
|
return this.Subscribe(channels, 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sends operation to subscribe to a list of channels by name and possibly retrieve messages we did not receive while unsubscribed.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="channels">List of channels to subscribe to. Avoid null or empty values.</param>
|
|||
|
|
/// <param name="lastMsgIds">ID of last message received per channel. Useful when re subscribing to receive only messages we missed.</param>
|
|||
|
|
/// <returns>If the operation could be sent at all (Example: Fails if not connected to Chat Server).</returns>
|
|||
|
|
public bool Subscribe(string[] channels, int[] lastMsgIds)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Subscribe called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (channels == null || channels.Length == 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "Subscribe can't be called for empty or null channels-list.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (int i = 0; i < channels.Length; i++)
|
|||
|
|
{
|
|||
|
|
if (string.IsNullOrEmpty(channels[i]))
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("Subscribe can't be called with a null or empty channel name at index {0}.", i));
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (lastMsgIds == null || lastMsgIds.Length != channels.Length)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Subscribe can't be called when \"lastMsgIds\" array is null or does not have the same length as \"channels\" array.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Dictionary<byte, object> opParameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.Channels, channels },
|
|||
|
|
{ ChatParameterCode.MsgIds, lastMsgIds},
|
|||
|
|
{ ChatParameterCode.HistoryLength, -1 } // server will decide how many messages to send to client
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.Subscribe, opParameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sends operation to subscribe client to channels, optionally fetching a number of messages from the cache.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// Subscribes channels will forward new messages to this user. Use PublishMessage to do so.
|
|||
|
|
/// The messages cache is limited but can be useful to get into ongoing conversations, if that's needed.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="channels">List of channels to subscribe to. Avoid null or empty values.</param>
|
|||
|
|
/// <param name="messagesFromHistory">0: no history. 1 and higher: number of messages in history. -1: all available history.</param>
|
|||
|
|
/// <returns>If the operation could be sent at all (Example: Fails if not connected to Chat Server).</returns>
|
|||
|
|
public bool Subscribe(string[] channels, int messagesFromHistory)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Subscribe called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (channels == null || channels.Length == 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "Subscribe can't be called for empty or null channels-list.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.SendChannelOperation(channels, (byte)ChatOperationCode.Subscribe, messagesFromHistory);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Unsubscribes from a list of channels, which stops getting messages from those.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// The client will remove these channels from the PublicChannels dictionary once the server sent a response to this request.
|
|||
|
|
///
|
|||
|
|
/// The request will be sent to the server and IChatClientListener.OnUnsubscribed gets called when the server
|
|||
|
|
/// actually removed the channel subscriptions.
|
|||
|
|
///
|
|||
|
|
/// Unsubscribe will fail if you include null or empty channel names.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="channels">Names of channels to unsubscribe.</param>
|
|||
|
|
/// <returns>False, if not connected to a chat server.</returns>
|
|||
|
|
public bool Unsubscribe(string[] channels)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Unsubscribe called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (channels == null || channels.Length == 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "Unsubscribe can't be called for empty or null channels-list.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
foreach (string ch in channels)
|
|||
|
|
{
|
|||
|
|
this.PublicChannelsUnsubscribing.Add(ch);
|
|||
|
|
}
|
|||
|
|
return this.SendChannelOperation(channels, ChatOperationCode.Unsubscribe, 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Sends a message to a public channel which this client subscribed to.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// Before you publish to a channel, you have to subscribe it.
|
|||
|
|
/// Everyone in that channel will get the message.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="channelName">Name of the channel to publish to.</param>
|
|||
|
|
/// <param name="message">Your message (string or any serializable data).</param>
|
|||
|
|
/// <param name="forwardAsWebhook">Optionally, public messages can be forwarded as webhooks. Configure webhooks for your Chat app to use this.</param>
|
|||
|
|
/// <returns>False if the client is not yet ready to send messages.</returns>
|
|||
|
|
public bool PublishMessage(string channelName, object message, bool forwardAsWebhook = false)
|
|||
|
|
{
|
|||
|
|
return this.publishMessage(channelName, message, true, forwardAsWebhook);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal bool PublishMessageUnreliable(string channelName, object message, bool forwardAsWebhook = false)
|
|||
|
|
{
|
|||
|
|
return this.publishMessage(channelName, message, false, forwardAsWebhook);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool publishMessage(string channelName, object message, bool reliable, bool forwardAsWebhook = false)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "PublishMessage called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (string.IsNullOrEmpty(channelName) || message == null)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "PublishMessage parameters must be non-null and not empty.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ (byte)ChatParameterCode.Channel, channelName },
|
|||
|
|
{ (byte)ChatParameterCode.Message, message }
|
|||
|
|
};
|
|||
|
|
if (forwardAsWebhook)
|
|||
|
|
{
|
|||
|
|
parameters.Add(ChatParameterCode.WebFlags, (byte)0x1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.Publish, parameters, new SendOptions() { Reliability = reliable });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sends a private message to a single target user. Calls OnPrivateMessage on the receiving client.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="target">Username to send this message to.</param>
|
|||
|
|
/// <param name="message">The message you want to send. Can be a simple string or anything serializable.</param>
|
|||
|
|
/// <param name="forwardAsWebhook">Optionally, private messages can be forwarded as webhooks. Configure webhooks for your Chat app to use this.</param>
|
|||
|
|
/// <returns>True if this clients can send the message to the server.</returns>
|
|||
|
|
public bool SendPrivateMessage(string target, object message, bool forwardAsWebhook = false)
|
|||
|
|
{
|
|||
|
|
return this.SendPrivateMessage(target, message, false, forwardAsWebhook);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sends a private message to a single target user. Calls OnPrivateMessage on the receiving client.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="target">Username to send this message to.</param>
|
|||
|
|
/// <param name="message">The message you want to send. Can be a simple string or anything serializable.</param>
|
|||
|
|
/// <param name="encrypt">Optionally, private messages can be encrypted. Encryption is not end-to-end as the server decrypts the message.</param>
|
|||
|
|
/// <param name="forwardAsWebhook">Optionally, private messages can be forwarded as webhooks. Configure webhooks for your Chat app to use this.</param>
|
|||
|
|
/// <returns>True if this clients can send the message to the server.</returns>
|
|||
|
|
public bool SendPrivateMessage(string target, object message, bool encrypt, bool forwardAsWebhook)
|
|||
|
|
{
|
|||
|
|
return this.sendPrivateMessage(target, message, encrypt, true, forwardAsWebhook);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal bool SendPrivateMessageUnreliable(string target, object message, bool encrypt, bool forwardAsWebhook = false)
|
|||
|
|
{
|
|||
|
|
return this.sendPrivateMessage(target, message, encrypt, false, forwardAsWebhook);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool sendPrivateMessage(string target, object message, bool encrypt, bool reliable, bool forwardAsWebhook = false)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "SendPrivateMessage called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (string.IsNullOrEmpty(target) || message == null)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "SendPrivateMessage parameters must be non-null and not empty.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.UserId, target },
|
|||
|
|
{ ChatParameterCode.Message, message }
|
|||
|
|
};
|
|||
|
|
if (forwardAsWebhook)
|
|||
|
|
{
|
|||
|
|
parameters.Add(ChatParameterCode.WebFlags, (byte)0x1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.SendPrivate, parameters, new SendOptions() { Reliability = reliable, Encrypt = encrypt });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Sets the user's status (pre-defined or custom) and an optional message.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// The predefined status values can be found in class ChatUserStatus.
|
|||
|
|
/// State ChatUserStatus.Invisible will make you offline for everyone and send no message.
|
|||
|
|
///
|
|||
|
|
/// You can set custom values in the status integer. Aside from the pre-configured ones,
|
|||
|
|
/// all states will be considered visible and online. Else, no one would see the custom state.
|
|||
|
|
///
|
|||
|
|
/// The message object can be anything that Photon can serialize, including (but not limited to)
|
|||
|
|
/// Hashtable, object[] and string. This value is defined by your own conventions.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="status">Predefined states are in class ChatUserStatus. Other values can be used at will.</param>
|
|||
|
|
/// <param name="message">Optional string message or null.</param>
|
|||
|
|
/// <param name="skipMessage">If true, the message gets ignored. It can be null but won't replace any current message.</param>
|
|||
|
|
/// <returns>True if the operation gets called on the server.</returns>
|
|||
|
|
private bool SetOnlineStatus(int status, object message, bool skipMessage)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "SetOnlineStatus called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.Status, status },
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
if (skipMessage)
|
|||
|
|
{
|
|||
|
|
parameters[ChatParameterCode.SkipMessage] = true;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
parameters[ChatParameterCode.Message] = message;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.UpdateStatus, parameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Sets the user's status without changing your status-message.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// The predefined status values can be found in class ChatUserStatus.
|
|||
|
|
/// State ChatUserStatus.Invisible will make you offline for everyone and send no message.
|
|||
|
|
///
|
|||
|
|
/// You can set custom values in the status integer. Aside from the pre-configured ones,
|
|||
|
|
/// all states will be considered visible and online. Else, no one would see the custom state.
|
|||
|
|
///
|
|||
|
|
/// This overload does not change the set message.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="status">Predefined states are in class ChatUserStatus. Other values can be used at will.</param>
|
|||
|
|
/// <returns>True if the operation gets called on the server.</returns>
|
|||
|
|
public bool SetOnlineStatus(int status)
|
|||
|
|
{
|
|||
|
|
return this.SetOnlineStatus(status, null, true);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>Sets the user's status without changing your status-message.</summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// The predefined status values can be found in class ChatUserStatus.
|
|||
|
|
/// State ChatUserStatus.Invisible will make you offline for everyone and send no message.
|
|||
|
|
///
|
|||
|
|
/// You can set custom values in the status integer. Aside from the pre-configured ones,
|
|||
|
|
/// all states will be considered visible and online. Else, no one would see the custom state.
|
|||
|
|
///
|
|||
|
|
/// The message object can be anything that Photon can serialize, including (but not limited to)
|
|||
|
|
/// Hashtable, object[] and string. This value is defined by your own conventions.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="status">Predefined states are in class ChatUserStatus. Other values can be used at will.</param>
|
|||
|
|
/// <param name="message">Also sets a status-message which your friends can get.</param>
|
|||
|
|
/// <returns>True if the operation gets called on the server.</returns>
|
|||
|
|
public bool SetOnlineStatus(int status, object message)
|
|||
|
|
{
|
|||
|
|
return this.SetOnlineStatus(status, message, false);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Adds friends to a list on the Chat Server which will send you status updates for those.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// AddFriends and RemoveFriends enable clients to handle their friend list
|
|||
|
|
/// in the Photon Chat server. Having users on your friends list gives you access
|
|||
|
|
/// to their current online status (and whatever info your client sets in it).
|
|||
|
|
///
|
|||
|
|
/// Each user can set an online status consisting of an integer and an arbitrary
|
|||
|
|
/// (serializable) object. The object can be null, Hashtable, object[] or anything
|
|||
|
|
/// else Photon can serialize.
|
|||
|
|
///
|
|||
|
|
/// The status is published automatically to friends (anyone who set your user ID
|
|||
|
|
/// with AddFriends).
|
|||
|
|
///
|
|||
|
|
/// Photon flushes friends-list when a chat client disconnects, so it has to be
|
|||
|
|
/// set each time. If your community API gives you access to online status already,
|
|||
|
|
/// you could filter and set online friends in AddFriends.
|
|||
|
|
///
|
|||
|
|
/// Actual friend relations are not persistent and have to be stored outside
|
|||
|
|
/// of Photon.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="friends">Array of friend userIds.</param>
|
|||
|
|
/// <returns>If the operation could be sent.</returns>
|
|||
|
|
public bool AddFriends(string[] friends)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "AddFriends called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (friends == null || friends.Length == 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "AddFriends can't be called for empty or null list.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (friends.Length > FriendRequestListMax)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "AddFriends max list size exceeded: " + friends.Length + " > " + FriendRequestListMax);
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.Friends, friends },
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.AddFriends, parameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Removes the provided entries from the list on the Chat Server and stops their status updates.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// Photon flushes friends-list when a chat client disconnects. Unless you want to
|
|||
|
|
/// remove individual entries, you don't have to RemoveFriends.
|
|||
|
|
///
|
|||
|
|
/// AddFriends and RemoveFriends enable clients to handle their friend list
|
|||
|
|
/// in the Photon Chat server. Having users on your friends list gives you access
|
|||
|
|
/// to their current online status (and whatever info your client sets in it).
|
|||
|
|
///
|
|||
|
|
/// Each user can set an online status consisting of an integer and an arbitratry
|
|||
|
|
/// (serializable) object. The object can be null, Hashtable, object[] or anything
|
|||
|
|
/// else Photon can serialize.
|
|||
|
|
///
|
|||
|
|
/// The status is published automatically to friends (anyone who set your user ID
|
|||
|
|
/// with AddFriends).
|
|||
|
|
///
|
|||
|
|
/// Photon flushes friends-list when a chat client disconnects, so it has to be
|
|||
|
|
/// set each time. If your community API gives you access to online status already,
|
|||
|
|
/// you could filter and set online friends in AddFriends.
|
|||
|
|
///
|
|||
|
|
/// Actual friend relations are not persistent and have to be stored outside
|
|||
|
|
/// of Photon.
|
|||
|
|
///
|
|||
|
|
/// AddFriends and RemoveFriends enable clients to handle their friend list
|
|||
|
|
/// in the Photon Chat server. Having users on your friends list gives you access
|
|||
|
|
/// to their current online status (and whatever info your client sets in it).
|
|||
|
|
///
|
|||
|
|
/// Each user can set an online status consisting of an integer and an arbitratry
|
|||
|
|
/// (serializable) object. The object can be null, Hashtable, object[] or anything
|
|||
|
|
/// else Photon can serialize.
|
|||
|
|
///
|
|||
|
|
/// The status is published automatically to friends (anyone who set your user ID
|
|||
|
|
/// with AddFriends).
|
|||
|
|
///
|
|||
|
|
///
|
|||
|
|
/// Actual friend relations are not persistent and have to be stored outside
|
|||
|
|
/// of Photon.
|
|||
|
|
/// </remarks>
|
|||
|
|
/// <param name="friends">Array of friend userIds.</param>
|
|||
|
|
/// <returns>If the operation could be sent.</returns>
|
|||
|
|
public bool RemoveFriends(string[] friends)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "RemoveFriends called while not connected to front end server.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (friends == null || friends.Length == 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "RemoveFriends can't be called for empty or null list.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (friends.Length > FriendRequestListMax)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "RemoveFriends max list size exceeded: " + friends.Length + " > " + FriendRequestListMax);
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.Friends, friends },
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.RemoveFriends, parameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Get you the (locally used) channel name for the chat between this client and another user.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="userName">Remote user's name or UserId.</param>
|
|||
|
|
/// <returns>The (locally used) channel name for a private channel.</returns>
|
|||
|
|
/// <remarks>Do not subscribe to this channel.
|
|||
|
|
/// Private channels do not need to be explicitly subscribed to.
|
|||
|
|
/// Use this for debugging purposes mainly.</remarks>
|
|||
|
|
public string GetPrivateChannelNameByUser(string userName)
|
|||
|
|
{
|
|||
|
|
return string.Format("{0}:{1}", this.UserId, userName);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Simplified access to either private or public channels by name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="channelName">Name of the channel to get. For private channels, the channel-name is composed of both user's names.</param>
|
|||
|
|
/// <param name="isPrivate">Define if you expect a private or public channel.</param>
|
|||
|
|
/// <param name="channel">Out parameter gives you the found channel, if any.</param>
|
|||
|
|
/// <returns>True if the channel was found.</returns>
|
|||
|
|
/// <remarks>Public channels exist only when subscribed to them.
|
|||
|
|
/// Private channels exist only when at least one message is exchanged with the target user privately.</remarks>
|
|||
|
|
public bool TryGetChannel(string channelName, bool isPrivate, out ChatChannel channel)
|
|||
|
|
{
|
|||
|
|
if (!isPrivate)
|
|||
|
|
{
|
|||
|
|
return this.PublicChannels.TryGetValue(channelName, out channel);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
return this.PrivateChannels.TryGetValue(channelName, out channel);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Simplified access to all channels by name. Checks public channels first, then private ones.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="channelName">Name of the channel to get.</param>
|
|||
|
|
/// <param name="channel">Out parameter gives you the found channel, if any.</param>
|
|||
|
|
/// <returns>True if the channel was found.</returns>
|
|||
|
|
/// <remarks>Public channels exist only when subscribed to them.
|
|||
|
|
/// Private channels exist only when at least one message is exchanged with the target user privately.</remarks>
|
|||
|
|
public bool TryGetChannel(string channelName, out ChatChannel channel)
|
|||
|
|
{
|
|||
|
|
bool found = false;
|
|||
|
|
found = this.PublicChannels.TryGetValue(channelName, out channel);
|
|||
|
|
if (found) return true;
|
|||
|
|
|
|||
|
|
found = this.PrivateChannels.TryGetValue(channelName, out channel);
|
|||
|
|
return found;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Simplified access to private channels by target user.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="userId">UserId of the target user in the private channel.</param>
|
|||
|
|
/// <param name="channel">Out parameter gives you the found channel, if any.</param>
|
|||
|
|
/// <returns>True if the channel was found.</returns>
|
|||
|
|
public bool TryGetPrivateChannelByUser(string userId, out ChatChannel channel)
|
|||
|
|
{
|
|||
|
|
channel = null;
|
|||
|
|
if (string.IsNullOrEmpty(userId))
|
|||
|
|
{
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
string channelName = this.GetPrivateChannelNameByUser(userId);
|
|||
|
|
return this.TryGetChannel(channelName, true, out channel);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sets the level (and amount) of debug output provided by the library.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <remarks>
|
|||
|
|
/// This affects the callbacks to IChatClientListener.DebugReturn.
|
|||
|
|
/// Default Level: Error.
|
|||
|
|
/// </remarks>
|
|||
|
|
public DebugLevel DebugOut
|
|||
|
|
{
|
|||
|
|
set { this.chatPeer.DebugOut = value; }
|
|||
|
|
get { return this.chatPeer.DebugOut; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#region Private methods area
|
|||
|
|
|
|||
|
|
#region IPhotonPeerListener implementation
|
|||
|
|
|
|||
|
|
void IPhotonPeerListener.DebugReturn(DebugLevel level, string message)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(level, message);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void IPhotonPeerListener.OnEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
switch (eventData.Code)
|
|||
|
|
{
|
|||
|
|
case ChatEventCode.ChatMessages:
|
|||
|
|
this.HandleChatMessagesEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.PrivateMessage:
|
|||
|
|
this.HandlePrivateMessageEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.StatusUpdate:
|
|||
|
|
this.HandleStatusUpdate(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.Subscribe:
|
|||
|
|
this.HandleSubscribeEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.Unsubscribe:
|
|||
|
|
this.HandleUnsubscribeEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.UserSubscribed:
|
|||
|
|
this.HandleUserSubscribedEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.UserUnsubscribed:
|
|||
|
|
this.HandleUserUnsubscribedEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
#if CHAT_EXTENDED
|
|||
|
|
case ChatEventCode.PropertiesChanged:
|
|||
|
|
this.HandlePropertiesChanged(eventData);
|
|||
|
|
break;
|
|||
|
|
case ChatEventCode.ErrorInfo:
|
|||
|
|
this.HandleErrorInfoEvent(eventData);
|
|||
|
|
break;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void IPhotonPeerListener.OnOperationResponse(OperationResponse operationResponse)
|
|||
|
|
{
|
|||
|
|
switch (operationResponse.OperationCode)
|
|||
|
|
{
|
|||
|
|
case (byte)ChatOperationCode.Authenticate:
|
|||
|
|
this.HandleAuthResponse(operationResponse);
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
// the following operations usually don't return useful data and no error.
|
|||
|
|
case (byte)ChatOperationCode.Subscribe:
|
|||
|
|
case (byte)ChatOperationCode.Unsubscribe:
|
|||
|
|
case (byte)ChatOperationCode.Publish:
|
|||
|
|
case (byte)ChatOperationCode.SendPrivate:
|
|||
|
|
default:
|
|||
|
|
if ((operationResponse.ReturnCode != 0) && (this.DebugOut >= DebugLevel.ERROR))
|
|||
|
|
{
|
|||
|
|
if (operationResponse.ReturnCode == -2)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("Chat Operation {0} unknown on server. Check your AppId and make sure it's for a Chat application.", operationResponse.OperationCode));
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("Chat Operation {0} failed (Code: {1}). Debug Message: {2}", operationResponse.OperationCode, operationResponse.ReturnCode, operationResponse.DebugMessage));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void IPhotonPeerListener.OnStatusChanged(StatusCode statusCode)
|
|||
|
|
{
|
|||
|
|
switch (statusCode)
|
|||
|
|
{
|
|||
|
|
case StatusCode.Connect:
|
|||
|
|
if (!this.chatPeer.IsProtocolSecure)
|
|||
|
|
{
|
|||
|
|
if (!this.chatPeer.EstablishEncryption())
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Error establishing encryption");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
this.TryAuthenticateOnNameServer();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (this.State == ChatState.ConnectingToNameServer)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.ConnectedToNameServer;
|
|||
|
|
this.listener.OnChatStateChange(this.State);
|
|||
|
|
}
|
|||
|
|
else if (this.State == ChatState.ConnectingToFrontEnd)
|
|||
|
|
{
|
|||
|
|
if (!this.AuthenticateOnFrontEnd())
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("Error authenticating on frontend! Check log output, AuthValues and if you're connected. State: {0}", this.State));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
case StatusCode.EncryptionEstablished:
|
|||
|
|
// once encryption is available, the client should send one (secure) authenticate. it includes the AppId (which identifies your app on the Photon Cloud)
|
|||
|
|
this.TryAuthenticateOnNameServer();
|
|||
|
|
break;
|
|||
|
|
case StatusCode.Disconnect:
|
|||
|
|
switch (this.State)
|
|||
|
|
{
|
|||
|
|
case ChatState.ConnectWithFallbackProtocol:
|
|||
|
|
this.EnableProtocolFallback = false; // the client does a fallback only one time
|
|||
|
|
this.chatPeer.NameServerPortOverride = 0; // resets a value in the peer only (as we change the protocol, the port has to change, too)
|
|||
|
|
this.chatPeer.TransportProtocol = (this.chatPeer.TransportProtocol == ConnectionProtocol.Tcp) ? ConnectionProtocol.Udp : ConnectionProtocol.Tcp;
|
|||
|
|
this.Connect(this.AppId, this.AppVersion, null);
|
|||
|
|
|
|||
|
|
// the client now has to return, instead of break, to avoid further processing of the disconnect call
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
case ChatState.Authenticated:
|
|||
|
|
this.ConnectToFrontEnd();
|
|||
|
|
// client disconnected from nameserver after authentication
|
|||
|
|
// to switch to frontend
|
|||
|
|
return;
|
|||
|
|
case ChatState.Disconnecting:
|
|||
|
|
// expected disconnect
|
|||
|
|
break;
|
|||
|
|
default:
|
|||
|
|
// unexpected disconnect, we log warning and stacktrace
|
|||
|
|
string stacktrace = string.Empty;
|
|||
|
|
#if DEBUG && !NETFX_CORE
|
|||
|
|
stacktrace = new System.Diagnostics.StackTrace(true).ToString();
|
|||
|
|
#endif
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Got a unexpected Disconnect in ChatState: {0}. Server: {1} Trace: {2}", this.State, this.chatPeer.ServerAddress, stacktrace));
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (this.AuthValues != null)
|
|||
|
|
{
|
|||
|
|
this.AuthValues.Token = null; // when leaving the server, invalidate the secret (but not the auth values)
|
|||
|
|
}
|
|||
|
|
this.State = ChatState.Disconnected;
|
|||
|
|
this.listener.OnChatStateChange(ChatState.Disconnected);
|
|||
|
|
this.listener.OnDisconnected();
|
|||
|
|
break;
|
|||
|
|
case StatusCode.DisconnectByServerUserLimit:
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "This connection was rejected due to the apps CCU limit.");
|
|||
|
|
this.Disconnect(ChatDisconnectCause.MaxCcuReached);
|
|||
|
|
break;
|
|||
|
|
case StatusCode.ExceptionOnConnect:
|
|||
|
|
case StatusCode.SecurityExceptionOnConnect:
|
|||
|
|
case StatusCode.EncryptionFailedToEstablish:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.ExceptionOnConnect;
|
|||
|
|
|
|||
|
|
// if enabled, the client can attempt to connect with another networking-protocol to check if that connects
|
|||
|
|
if (this.EnableProtocolFallback && this.State == ChatState.ConnectingToNameServer)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.ConnectWithFallbackProtocol;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
this.Disconnect(ChatDisconnectCause.ExceptionOnConnect);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
break;
|
|||
|
|
case StatusCode.Exception:
|
|||
|
|
case StatusCode.ExceptionOnReceive:
|
|||
|
|
this.Disconnect(ChatDisconnectCause.Exception);
|
|||
|
|
break;
|
|||
|
|
case StatusCode.DisconnectByServerTimeout:
|
|||
|
|
this.Disconnect(ChatDisconnectCause.ServerTimeout);
|
|||
|
|
break;
|
|||
|
|
case StatusCode.DisconnectByServerLogic:
|
|||
|
|
this.Disconnect(ChatDisconnectCause.DisconnectByServerLogic);
|
|||
|
|
break;
|
|||
|
|
case StatusCode.DisconnectByServerReasonUnknown:
|
|||
|
|
this.Disconnect(ChatDisconnectCause.DisconnectByServerReasonUnknown);
|
|||
|
|
break;
|
|||
|
|
case StatusCode.TimeoutDisconnect:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.ClientTimeout;
|
|||
|
|
|
|||
|
|
// if enabled, the client can attempt to connect with another networking-protocol to check if that connects
|
|||
|
|
if (this.EnableProtocolFallback && this.State == ChatState.ConnectingToNameServer)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.ConnectWithFallbackProtocol;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
this.Disconnect(ChatDisconnectCause.ClientTimeout);
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if SDK_V4
|
|||
|
|
void IPhotonPeerListener.OnMessage(object msg)
|
|||
|
|
{
|
|||
|
|
string channelName = null;
|
|||
|
|
var receivedBytes = (byte[])msg;
|
|||
|
|
var channelId = BitConverter.ToInt32(receivedBytes, 0);
|
|||
|
|
var messageBytes = new byte[receivedBytes.Length - 4];
|
|||
|
|
Array.Copy(receivedBytes, 4, messageBytes, 0, receivedBytes.Length - 4);
|
|||
|
|
|
|||
|
|
foreach (var channel in this.PublicChannels)
|
|||
|
|
{
|
|||
|
|
if (channel.Value.ChannelID == channelId)
|
|||
|
|
{
|
|||
|
|
channelName = channel.Key;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (channelName != null)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ALL, string.Format("got OnMessage in channel {0}", channelName));
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("got OnMessage in unknown channel {0}", channelId));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.listener.OnReceiveBroadcastMessage(channelName, messageBytes);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
private void TryAuthenticateOnNameServer()
|
|||
|
|
{
|
|||
|
|
if (!this.didAuthenticate)
|
|||
|
|
{
|
|||
|
|
this.didAuthenticate = this.chatPeer.AuthenticateOnNameServer(this.AppId, this.AppVersion, this.ChatRegion, this.AuthValues);
|
|||
|
|
if (!this.didAuthenticate)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("Error calling OpAuthenticate! Did not work on NameServer. Check log output, AuthValues and if you're connected. State: {0}", this.State));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool SendChannelOperation(string[] channels, byte operation, int historyLength)
|
|||
|
|
{
|
|||
|
|
Dictionary<byte, object> opParameters = new Dictionary<byte, object> { { (byte)ChatParameterCode.Channels, channels } };
|
|||
|
|
|
|||
|
|
if (historyLength != 0)
|
|||
|
|
{
|
|||
|
|
opParameters.Add((byte)ChatParameterCode.HistoryLength, historyLength);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(operation, opParameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandlePrivateMessageEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
//Console.WriteLine(SupportClass.DictionaryToString(eventData.Parameters));
|
|||
|
|
|
|||
|
|
object message = (object)eventData.Parameters[(byte)ChatParameterCode.Message];
|
|||
|
|
string sender = (string)eventData.Parameters[(byte)ChatParameterCode.Sender];
|
|||
|
|
int msgId = (int)eventData.Parameters[ChatParameterCode.MsgId];
|
|||
|
|
|
|||
|
|
string channelName;
|
|||
|
|
if (this.UserId != null && this.UserId.Equals(sender))
|
|||
|
|
{
|
|||
|
|
string target = (string)eventData.Parameters[(byte)ChatParameterCode.UserId];
|
|||
|
|
channelName = this.GetPrivateChannelNameByUser(target);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
channelName = this.GetPrivateChannelNameByUser(sender);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ChatChannel channel;
|
|||
|
|
if (!this.PrivateChannels.TryGetValue(channelName, out channel))
|
|||
|
|
{
|
|||
|
|
channel = new ChatChannel(channelName);
|
|||
|
|
channel.IsPrivate = true;
|
|||
|
|
channel.MessageLimit = this.MessageLimit;
|
|||
|
|
this.PrivateChannels.Add(channel.Name, channel);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
channel.Add(sender, message, msgId);
|
|||
|
|
this.listener.OnPrivateMessage(sender, message, channelName);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleChatMessagesEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
object[] messages = (object[])eventData.Parameters[(byte)ChatParameterCode.Messages];
|
|||
|
|
string[] senders = (string[])eventData.Parameters[(byte)ChatParameterCode.Senders];
|
|||
|
|
string channelName = (string)eventData.Parameters[(byte)ChatParameterCode.Channel];
|
|||
|
|
int lastMsgId = (int)eventData.Parameters[ChatParameterCode.MsgId];
|
|||
|
|
|
|||
|
|
ChatChannel channel;
|
|||
|
|
if (!this.PublicChannels.TryGetValue(channelName, out channel))
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "Channel " + channelName + " for incoming message event not found.");
|
|||
|
|
}
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
channel.Add(senders, messages, lastMsgId);
|
|||
|
|
this.listener.OnGetMessages(channelName, senders, messages);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleSubscribeEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
string[] channelsInResponse = (string[])eventData.Parameters[ChatParameterCode.Channels];
|
|||
|
|
bool[] results = (bool[])eventData.Parameters[ChatParameterCode.SubscribeResults];
|
|||
|
|
for (int i = 0; i < channelsInResponse.Length; i++)
|
|||
|
|
{
|
|||
|
|
if (results[i])
|
|||
|
|
{
|
|||
|
|
string channelName = channelsInResponse[i];
|
|||
|
|
ChatChannel channel;
|
|||
|
|
if (!this.PublicChannels.TryGetValue(channelName, out channel))
|
|||
|
|
{
|
|||
|
|
channel = new ChatChannel(channelName);
|
|||
|
|
channel.MessageLimit = this.MessageLimit;
|
|||
|
|
this.PublicChannels.Add(channel.Name, channel);
|
|||
|
|
}
|
|||
|
|
object temp;
|
|||
|
|
if (eventData.Parameters.TryGetValue(ChatParameterCode.Properties, out temp))
|
|||
|
|
{
|
|||
|
|
Dictionary<object, object> channelProperties = temp as Dictionary<object, object>;
|
|||
|
|
channel.ReadChannelProperties(channelProperties);
|
|||
|
|
}
|
|||
|
|
if (channel.PublishSubscribers) // or maybe remove check & always add anyway?
|
|||
|
|
{
|
|||
|
|
channel.Subscribers.Add(this.UserId);
|
|||
|
|
}
|
|||
|
|
if (eventData.Parameters.TryGetValue(ChatParameterCode.ChannelSubscribers, out temp))
|
|||
|
|
{
|
|||
|
|
string[] subscribers = temp as string[];
|
|||
|
|
channel.AddSubscribers(subscribers);
|
|||
|
|
}
|
|||
|
|
#if CHAT_EXTENDED
|
|||
|
|
if (eventData.Parameters.TryGetValue(ChatParameterCode.UserProperties, out temp))
|
|||
|
|
{
|
|||
|
|
Dictionary<string, Dictionary<object, object>> userProperties = temp as Dictionary<string, Dictionary<object, object>>;
|
|||
|
|
foreach (var pair in userProperties)
|
|||
|
|
{
|
|||
|
|
channel.ReadUserProperties(pair.Key, pair.Value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.listener.OnSubscribed(channelsInResponse, results);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
private void HandleUnsubscribeEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
string[] channelsInRequest = (string[])eventData[ChatParameterCode.Channels];
|
|||
|
|
for (int i = 0; i < channelsInRequest.Length; i++)
|
|||
|
|
{
|
|||
|
|
string channelName = channelsInRequest[i];
|
|||
|
|
this.PublicChannels.Remove(channelName);
|
|||
|
|
this.PublicChannelsUnsubscribing.Remove(channelName);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.listener.OnUnsubscribed(channelsInRequest);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleAuthResponse(OperationResponse operationResponse)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.INFO)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.INFO, operationResponse.ToStringFull() + " on: " + this.chatPeer.NameServerAddress);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (operationResponse.ReturnCode == 0)
|
|||
|
|
{
|
|||
|
|
if (this.State == ChatState.ConnectedToNameServer)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.Authenticated;
|
|||
|
|
this.listener.OnChatStateChange(this.State);
|
|||
|
|
|
|||
|
|
if (operationResponse.Parameters.ContainsKey(ParameterCode.Secret))
|
|||
|
|
{
|
|||
|
|
if (this.AuthValues == null)
|
|||
|
|
{
|
|||
|
|
this.AuthValues = new AuthenticationValues();
|
|||
|
|
}
|
|||
|
|
this.AuthValues.Token = operationResponse[ParameterCode.Secret] as string;
|
|||
|
|
|
|||
|
|
this.FrontendAddress = (string)operationResponse[ParameterCode.Address];
|
|||
|
|
|
|||
|
|
// we disconnect and status handler starts to connect to front end
|
|||
|
|
this.chatPeer.Disconnect();
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "No secret in authentication response.");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (operationResponse.Parameters.ContainsKey(ParameterCode.UserId))
|
|||
|
|
{
|
|||
|
|
string incomingId = operationResponse.Parameters[ParameterCode.UserId] as string;
|
|||
|
|
if (!string.IsNullOrEmpty(incomingId))
|
|||
|
|
{
|
|||
|
|
this.UserId = incomingId;
|
|||
|
|
this.listener.DebugReturn(DebugLevel.INFO, string.Format("Received your UserID from server. Updating local value to: {0}", this.UserId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (this.State == ChatState.ConnectingToFrontEnd)
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.ConnectedToFrontEnd;
|
|||
|
|
this.listener.OnChatStateChange(this.State);
|
|||
|
|
this.listener.OnConnected();
|
|||
|
|
if (statusToSetWhenConnected.HasValue)
|
|||
|
|
{
|
|||
|
|
SetOnlineStatus(statusToSetWhenConnected.Value, messageToSetWhenConnected);
|
|||
|
|
statusToSetWhenConnected = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
//this.listener.DebugReturn(DebugLevel.INFO, operationResponse.ToStringFull() + " NS: " + this.NameServerAddress + " FrontEnd: " + this.frontEndAddress);
|
|||
|
|
|
|||
|
|
switch (operationResponse.ReturnCode)
|
|||
|
|
{
|
|||
|
|
case ErrorCode.InvalidAuthentication:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.InvalidAuthentication;
|
|||
|
|
break;
|
|||
|
|
case ErrorCode.CustomAuthenticationFailed:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.CustomAuthenticationFailed;
|
|||
|
|
break;
|
|||
|
|
case ErrorCode.InvalidRegion:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.InvalidRegion;
|
|||
|
|
break;
|
|||
|
|
case ErrorCode.MaxCcuReached:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.MaxCcuReached;
|
|||
|
|
break;
|
|||
|
|
case ErrorCode.OperationNotAllowedInCurrentState:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.OperationNotAllowedInCurrentState;
|
|||
|
|
break;
|
|||
|
|
case ErrorCode.AuthenticationTicketExpired:
|
|||
|
|
this.DisconnectedCause = ChatDisconnectCause.AuthenticationTicketExpired;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("{0} ClientState: {1} ServerAddress: {2}", operationResponse.ToStringFull(), this.State, this.chatPeer.ServerAddress));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
this.Disconnect(this.DisconnectedCause);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleStatusUpdate(EventData eventData)
|
|||
|
|
{
|
|||
|
|
string user = (string)eventData.Parameters[ChatParameterCode.Sender];
|
|||
|
|
int status = (int)eventData.Parameters[ChatParameterCode.Status];
|
|||
|
|
|
|||
|
|
object message = null;
|
|||
|
|
bool gotMessage = eventData.Parameters.ContainsKey(ChatParameterCode.Message);
|
|||
|
|
if (gotMessage)
|
|||
|
|
{
|
|||
|
|
message = eventData.Parameters[ChatParameterCode.Message];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.listener.OnStatusUpdate(user, status, gotMessage, message);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool ConnectToFrontEnd()
|
|||
|
|
{
|
|||
|
|
this.State = ChatState.ConnectingToFrontEnd;
|
|||
|
|
|
|||
|
|
if (this.DebugOut >= DebugLevel.INFO)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.INFO, "Connecting to frontend " + this.FrontendAddress);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if UNITY_WEBGL
|
|||
|
|
if (this.TransportProtocol == ConnectionProtocol.Tcp || this.TransportProtocol == ConnectionProtocol.Udp)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "WebGL requires WebSockets. Switching TransportProtocol to WebSocketSecure.");
|
|||
|
|
this.TransportProtocol = ConnectionProtocol.WebSocketSecure;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (!this.chatPeer.Connect(this.FrontendAddress, ChatAppName))
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, string.Format("Connecting to frontend {0} failed.", this.FrontendAddress));
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private bool AuthenticateOnFrontEnd()
|
|||
|
|
{
|
|||
|
|
if (this.AuthValues != null)
|
|||
|
|
{
|
|||
|
|
if (this.AuthValues.Token == null)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Can't authenticate on front end server. Secret (AuthValues.Token) is not set");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Dictionary<byte, object> opParameters = new Dictionary<byte, object> { { (byte)ChatParameterCode.Secret, this.AuthValues.Token } };
|
|||
|
|
if (this.PrivateChatHistoryLength > -1)
|
|||
|
|
{
|
|||
|
|
opParameters[(byte)ChatParameterCode.HistoryLength] = this.PrivateChatHistoryLength;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.Authenticate, opParameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Can't authenticate on front end server. Authentication Values are not set");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleUserUnsubscribedEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
string channelName = eventData.Parameters[ChatParameterCode.Channel] as string;
|
|||
|
|
string userId = eventData.Parameters[ChatParameterCode.UserId] as string;
|
|||
|
|
ChatChannel channel;
|
|||
|
|
if (this.PublicChannels.TryGetValue(channelName, out channel))
|
|||
|
|
{
|
|||
|
|
if (!channel.PublishSubscribers)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\" for incoming UserUnsubscribed (\"{1}\") event does not have PublishSubscribers enabled.", channelName, userId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (!channel.Subscribers.Remove(userId)) // user not found!
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\" does not contain unsubscribed user \"{1}\".", channelName, userId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\" not found for incoming UserUnsubscribed (\"{1}\") event.", channelName, userId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.listener.OnUserUnsubscribed(channelName, userId);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleUserSubscribedEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
//TODO: Handle user properties!
|
|||
|
|
|
|||
|
|
string channelName = eventData.Parameters[ChatParameterCode.Channel] as string;
|
|||
|
|
string userId = eventData.Parameters[ChatParameterCode.UserId] as string;
|
|||
|
|
ChatChannel channel;
|
|||
|
|
if (this.PublicChannels.TryGetValue(channelName, out channel))
|
|||
|
|
{
|
|||
|
|
if (!channel.PublishSubscribers)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\" for incoming UserSubscribed (\"{1}\") event does not have PublishSubscribers enabled.", channelName, userId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (!channel.Subscribers.Add(userId)) // user came back from the dead ?
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\" already contains newly subscribed user \"{1}\".", channelName, userId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (channel.MaxSubscribers > 0 && channel.Subscribers.Count > channel.MaxSubscribers)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\"'s MaxSubscribers exceeded. count={1} > MaxSubscribers={2}.", channelName, channel.Subscribers.Count, channel.MaxSubscribers));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel \"{0}\" not found for incoming UserSubscribed (\"{1}\") event.", channelName, userId));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.listener.OnUserSubscribed(channelName, userId);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Subscribe to a single channel and optionally sets its well-know channel properties in case the channel is created.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="channel">name of the channel to subscribe to</param>
|
|||
|
|
/// <param name="lastMsgId">ID of the last received message from this channel when re subscribing to receive only missed messages, default is 0</param>
|
|||
|
|
/// <param name="messagesFromHistory">how many missed messages to receive from history, default is -1 (available history). 0 will get you no items. Positive values are capped by a server side limit.</param>
|
|||
|
|
/// <param name="creationOptions">options to be used in case the channel to subscribe to will be created.</param>
|
|||
|
|
/// <returns></returns>
|
|||
|
|
public bool Subscribe(string channel, int lastMsgId = 0, int messagesFromHistory = -1, ChannelCreationOptions creationOptions = null)
|
|||
|
|
{
|
|||
|
|
if (creationOptions == null)
|
|||
|
|
{
|
|||
|
|
creationOptions = ChannelCreationOptions.Default;
|
|||
|
|
}
|
|||
|
|
int maxSubscribers = creationOptions.MaxSubscribers;
|
|||
|
|
bool publishSubscribers = creationOptions.PublishSubscribers;
|
|||
|
|
if (maxSubscribers < 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "Cannot set MaxSubscribers < 0.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (lastMsgId < 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "lastMsgId cannot be < 0.");
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (messagesFromHistory < -1)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "messagesFromHistory < -1, setting it to -1");
|
|||
|
|
}
|
|||
|
|
messagesFromHistory = -1;
|
|||
|
|
}
|
|||
|
|
if (lastMsgId > 0 && messagesFromHistory == 0)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.WARNING)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "lastMsgId will be ignored because messagesFromHistory == 0");
|
|||
|
|
}
|
|||
|
|
lastMsgId = 0;
|
|||
|
|
}
|
|||
|
|
Dictionary<object, object> properties = null;
|
|||
|
|
if (publishSubscribers)
|
|||
|
|
{
|
|||
|
|
if (maxSubscribers > DefaultMaxSubscribers)
|
|||
|
|
{
|
|||
|
|
if (this.DebugOut >= DebugLevel.ERROR)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR,
|
|||
|
|
string.Format("Cannot set MaxSubscribers > {0} when PublishSubscribers == true.", DefaultMaxSubscribers));
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
properties = new Dictionary<object, object>();
|
|||
|
|
properties[ChannelWellKnownProperties.PublishSubscribers] = true;
|
|||
|
|
}
|
|||
|
|
if (maxSubscribers > 0)
|
|||
|
|
{
|
|||
|
|
if (properties == null)
|
|||
|
|
{
|
|||
|
|
properties = new Dictionary<object, object>();
|
|||
|
|
}
|
|||
|
|
properties[ChannelWellKnownProperties.MaxSubscribers] = maxSubscribers;
|
|||
|
|
}
|
|||
|
|
#if CHAT_EXTENDED
|
|||
|
|
if (creationOptions.CustomProperties != null && creationOptions.CustomProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
foreach (var pair in creationOptions.CustomProperties)
|
|||
|
|
{
|
|||
|
|
properties.Add(pair.Key, pair.Value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
Dictionary<byte, object> opParameters = new Dictionary<byte, object> { { ChatParameterCode.Channels, new[] { channel } } };
|
|||
|
|
if (messagesFromHistory != 0)
|
|||
|
|
{
|
|||
|
|
opParameters.Add(ChatParameterCode.HistoryLength, messagesFromHistory);
|
|||
|
|
}
|
|||
|
|
if (lastMsgId > 0)
|
|||
|
|
{
|
|||
|
|
opParameters.Add(ChatParameterCode.MsgIds, new[] { lastMsgId });
|
|||
|
|
}
|
|||
|
|
if (properties != null && properties.Count > 0)
|
|||
|
|
{
|
|||
|
|
opParameters.Add(ChatParameterCode.Properties, properties);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.Subscribe, opParameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if CHAT_EXTENDED
|
|||
|
|
|
|||
|
|
internal bool SetChannelProperties(string channelName, Dictionary<object, object> channelProperties, Dictionary<object, object> expectedProperties = null, bool httpForward = false)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "SetChannelProperties called while not connected to front end server.");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (string.IsNullOrEmpty(channelName) || channelProperties == null || channelProperties.Count == 0)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "SetChannelProperties parameters must be non-null and not empty.");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.Channel, channelName },
|
|||
|
|
{ ChatParameterCode.Properties, channelProperties },
|
|||
|
|
{ ChatParameterCode.Broadcast, true }
|
|||
|
|
};
|
|||
|
|
if (httpForward)
|
|||
|
|
{
|
|||
|
|
parameters.Add(ChatParameterCode.WebFlags, HttpForwardWebFlag);
|
|||
|
|
}
|
|||
|
|
if (expectedProperties != null && expectedProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
parameters.Add(ChatParameterCode.ExpectedValues, expectedProperties);
|
|||
|
|
}
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.SetProperties, parameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool SetCustomChannelProperties(string channelName, Dictionary<string, object> channelProperties, Dictionary<string, object> expectedProperties = null, bool httpForward = false)
|
|||
|
|
{
|
|||
|
|
if (channelProperties != null && channelProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
Dictionary<object, object> properties = new Dictionary<object, object>(channelProperties.Count);
|
|||
|
|
foreach (var pair in channelProperties)
|
|||
|
|
{
|
|||
|
|
properties.Add(pair.Key, pair.Value);
|
|||
|
|
}
|
|||
|
|
Dictionary<object, object> expected = null;
|
|||
|
|
if (expectedProperties != null && expectedProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
expected = new Dictionary<object, object>(expectedProperties.Count);
|
|||
|
|
foreach (var pair in expectedProperties)
|
|||
|
|
{
|
|||
|
|
expected.Add(pair.Key, pair.Value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return this.SetChannelProperties(channelName, properties, expected, httpForward);
|
|||
|
|
}
|
|||
|
|
return this.SetChannelProperties(channelName, null);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public bool SetCustomUserProperties(string channelName, string userId, Dictionary<string, object> userProperties, Dictionary<string, object> expectedProperties = null, bool httpForward = false)
|
|||
|
|
{
|
|||
|
|
if (userProperties != null && userProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
Dictionary<object, object> properties = new Dictionary<object, object>(userProperties.Count);
|
|||
|
|
foreach (var pair in userProperties)
|
|||
|
|
{
|
|||
|
|
properties.Add(pair.Key, pair.Value);
|
|||
|
|
}
|
|||
|
|
Dictionary<object, object> expected = null;
|
|||
|
|
if (expectedProperties != null && expectedProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
expected = new Dictionary<object, object>(expectedProperties.Count);
|
|||
|
|
foreach (var pair in expectedProperties)
|
|||
|
|
{
|
|||
|
|
expected.Add(pair.Key, pair.Value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return this.SetUserProperties(channelName, userId, properties, expected, httpForward);
|
|||
|
|
}
|
|||
|
|
return this.SetUserProperties(channelName, userId, null);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal bool SetUserProperties(string channelName, string userId, Dictionary<object, object> channelProperties, Dictionary<object, object> expectedProperties = null, bool httpForward = false)
|
|||
|
|
{
|
|||
|
|
if (!this.CanChat)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.ERROR, "SetUserProperties called while not connected to front end server.");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (string.IsNullOrEmpty(channelName))
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "SetUserProperties \"channelName\" parameter must be non-null and not empty.");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (channelProperties == null || channelProperties.Count == 0)
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "SetUserProperties \"channelProperties\" parameter must be non-null and not empty.");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (string.IsNullOrEmpty(userId))
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, "SetUserProperties \"userId\" parameter must be non-null and not empty.");
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
Dictionary<byte, object> parameters = new Dictionary<byte, object>
|
|||
|
|
{
|
|||
|
|
{ ChatParameterCode.Channel, channelName },
|
|||
|
|
{ ChatParameterCode.Properties, channelProperties },
|
|||
|
|
{ ChatParameterCode.UserId, userId },
|
|||
|
|
{ ChatParameterCode.Broadcast, true }
|
|||
|
|
};
|
|||
|
|
if (httpForward)
|
|||
|
|
{
|
|||
|
|
parameters.Add(ChatParameterCode.WebFlags, HttpForwardWebFlag);
|
|||
|
|
}
|
|||
|
|
if (expectedProperties != null && expectedProperties.Count > 0)
|
|||
|
|
{
|
|||
|
|
parameters.Add(ChatParameterCode.ExpectedValues, expectedProperties);
|
|||
|
|
}
|
|||
|
|
return this.chatPeer.SendOperation(ChatOperationCode.SetProperties, parameters, SendOptions.SendReliable);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandlePropertiesChanged(EventData eventData)
|
|||
|
|
{
|
|||
|
|
string channelName = eventData.Parameters[ChatParameterCode.Channel] as string;
|
|||
|
|
ChatChannel channel;
|
|||
|
|
if (!this.PublicChannels.TryGetValue(channelName, out channel))
|
|||
|
|
{
|
|||
|
|
this.listener.DebugReturn(DebugLevel.WARNING, string.Format("Channel {0} for incoming ChannelPropertiesUpdated event not found.", channelName));
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
string senderId = eventData.Parameters[ChatParameterCode.Sender] as string;
|
|||
|
|
Dictionary<object, object> changedProperties = eventData.Parameters[ChatParameterCode.Properties] as Dictionary<object, object>;
|
|||
|
|
object temp;
|
|||
|
|
if (eventData.Parameters.TryGetValue(ChatParameterCode.UserId, out temp))
|
|||
|
|
{
|
|||
|
|
string targetUserId = temp as string;
|
|||
|
|
channel.ReadUserProperties(targetUserId, changedProperties);
|
|||
|
|
this.listener.OnUserPropertiesChanged(channelName, targetUserId, senderId, changedProperties);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
channel.ReadChannelProperties(changedProperties);
|
|||
|
|
this.listener.OnChannelPropertiesChanged(channelName, senderId, changedProperties);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void HandleErrorInfoEvent(EventData eventData)
|
|||
|
|
{
|
|||
|
|
string channel = eventData.Parameters[ChatParameterCode.Channel] as string;
|
|||
|
|
string msg = eventData.Parameters[ChatParameterCode.DebugMessage] as string;
|
|||
|
|
object data = eventData.Parameters[ChatParameterCode.DebugData];
|
|||
|
|
this.listener.OnErrorInfo(channel, msg, data);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|