//listen to the channel
public void Listen()
{
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt(
(pubnubObj, message) =>
{
//Call the notification windows from the UI thread
Application.Current.Dispatcher.Invoke(new Action(() =>
{
//Show the message as a WPF window message like WIN-10 toast
NotificationWindow ts = new NotificationWindow();
//Convert the message to JSON
JsonMsg bsObj = JsonConvert.DeserializeObject <JsonMsg>(message.Message.ToString());
string messageBoxText = "Name: " + bsObj.Name + Environment.NewLine + "Description: " + bsObj.Description + Environment.NewLine + "Date: " + bsObj.Date;
ts.NotifText.Text = messageBoxText;
ts.Show();
}));
},
(pubnubObj, presence) =>
{
// handle incoming presence data
},
(pubnubObj, status) =>
{
// the status object returned is always related to subscribe but could contain
// information about subscribe, heartbeat, or errors
// use the PNOperationType to switch on different options
});
pubnub.AddListener(listenerSubscribeCallack);
}
public PubNubMessageHandler(ChatOutputControl chatOutputControl)
{
this.chatOutputControl = chatOutputControl;
//Configure PubNub
PNConfiguration pnConfiguration = new PNConfiguration
{
PublishKey = PublishKey,
SubscribeKey = SubscribeKey,
Uuid = userId,
Secure = false
};
this.pubnub = new Pubnub(pnConfiguration);
//Add listener to receive Publish messages and Presence events
SubscribeCallbackExt generalSubscribeCallack = new SubscribeCallbackExt(
(Pubnub pubnubObj, PNMessageResult <object> message) => {
Console.WriteLine(message.Message);
//Determine if the message publisher is the current user
bool messageFromCurrentUser = message.Publisher.ToString() == userId;
//Deserialize the JSON message
EnrichedChatMessage chatMessage = JsonConvert.DeserializeObject <EnrichedChatMessage>(message.Message.ToString());
//Verify that both the message text and extraction properties were defined in the message
if (chatMessage.Text == null || chatMessage.Extractions == null)
{
Console.WriteLine("Message arrived with an unexpected format:", message.Message);
}
else
{
//Update the output user control with the new message text
chatOutputControl.NewMessage(chatMessage.Text, messageFromCurrentUser);
//Convert the message enrichment data into formatted JSON to be displayed
string formattedJsonMetadata = JsonConvert.SerializeObject(chatMessage.Extractions, Formatting.Indented);
chatOutputControl.UpdateMetadata(formattedJsonMetadata == "[]" ? "No additional metadata" : formattedJsonMetadata);
}
},
(pubnubObj, presence) => { },
(pubnubObj, status) => { }
);
pubnub.AddListener(generalSubscribeCallack);
//Subscribe to the chat channel
pubnub.Subscribe <string>()
.Channels(new string[] {
ChannelName
})
.Execute();
}
void Listener()
{
Pubnub pubnub = new Pubnub(pnConfiguration);
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt(
(pubnubObj, message) => { },
(pubnubObj, presence) => { },
(pubnubObj, status) => { });
pubnub.AddListener(listenerSubscribeCallack);
// some time later
pubnub.RemoveListener(listenerSubscribeCallack);
}
public void Dispose()
{
if (_Disposed)
{
return;
}
// TODO: check this - it looks dodgy
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt((pubnubObj, message) => { }, (pubnubObj, presence) => { }, (pubnubObj, status) => { });
_Pubnub.AddListener(listenerSubscribeCallack);
// some time later
_Pubnub.RemoveListener(listenerSubscribeCallack);
_Pubnub.Destroy();
_Disposed = true;
}
/// <summary>
/// The methods provided in this section are simply used to allow
/// NavigationHelper to respond to the page's navigation methods.
/// <para>
/// Page specific logic should be placed in event handlers for the
/// <see cref="NavigationHelper.LoadState"/>
/// and <see cref="NavigationHelper.SaveState"/>.
/// The navigation parameter is available in the LoadState method
/// in addition to page state preserved during an earlier session.
/// </para>
/// </summary>
/// <param name="e">Provides data for navigation methods and event
/// handlers that cannot cancel the navigation request.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
data = e.Parameter as PubnubConfigData;
if (data != null)
{
config = new PNConfiguration();
config.PublishKey = data.publishKey;
config.SubscribeKey = data.subscribeKey;
config.SecretKey = data.secretKey;
config.CipherKey = data.cipherKey;
config.Secure = data.ssl;
config.Origin = data.origin;
config.Uuid = data.sessionUUID;
config.AuthKey = data.authKey;
config.PresenceTimeout = data.presenceHeartbeat;
config.SubscribeTimeout = data.subscribeTimeout;
config.NonSubscribeRequestTimeout = data.nonSubscribeTimeout;
config.UseClassicHttpWebRequest = true;
config.PubnubLog = new PlatformPubnubLog();
config.LogVerbosity = PNLogVerbosity.BODY;
pubnub = new Pubnub(config);
listener = new SubscribeCallbackExt(
(o, m) =>
{
DisplayMessageInTextBox(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
},
(o, p) =>
{
DisplayMessageInTextBox(pubnub.JsonPluggableLibrary.SerializeToJsonString(p));
},
(o, s) =>
{
DisplayMessageInTextBox(pubnub.JsonPluggableLibrary.SerializeToJsonString(s));
});
//pubnub.NetworkCheckMaxRetries = data.maxRetries;
//pubnub.NetworkCheckRetryInterval = data.retryInterval;
//pubnub.LocalClientHeartbeatInterval = data.localClientHeartbeatInterval;
//pubnub.EnableResumeOnReconnect = data.resumeOnReconnect;
//pubnub.PresenceHeartbeat = data.presenceHeartbeat;
//pubnub.PresenceHeartbeatInterval = data.presenceHeartbeatInterval;
}
}
/// <summary>
/// The methods provided in this section are simply used to allow
/// NavigationHelper to respond to the page's navigation methods.
/// <para>
/// Page specific logic should be placed in event handlers for the
/// <see cref="NavigationHelper.LoadState"/>
/// and <see cref="NavigationHelper.SaveState"/>.
/// The navigation parameter is available in the LoadState method
/// in addition to page state preserved during an earlier session.
/// </para>
/// </summary>
/// <param name="e">Provides data for navigation methods and event
/// handlers that cannot cancel the navigation request.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
data = e.Parameter as PubnubConfigData;
if (data != null)
{
config = new PNConfiguration();
config.PublishKey = data.publishKey;
config.SubscribeKey = data.subscribeKey;
config.SecretKey = data.secretKey;
config.CipherKey = data.cipherKey;
config.Secure = data.ssl;
config.Origin = data.origin;
config.Uuid = data.sessionUUID;
config.AuthKey = data.authKey;
config.PresenceTimeout = data.presenceHeartbeat;
config.SubscribeTimeout = data.subscribeTimeout;
config.NonSubscribeRequestTimeout = data.nonSubscribeTimeout;
config.UseClassicHttpWebRequest = true;
config.PubnubLog = new PlatformPubnubLog();
config.LogVerbosity = PNLogVerbosity.BODY;
pubnub = new Pubnub(config);
listener = new SubscribeCallbackExt(
async(o, m) =>
{
await DisplayMessageInTextBox(pubnub.JsonPluggableLibrary.SerializeToJsonString(m)).ConfigureAwait(false);
},
async(o, p) =>
{
await DisplayMessageInTextBox(pubnub.JsonPluggableLibrary.SerializeToJsonString(p)).ConfigureAwait(false);
},
async(o, s) =>
{
await DisplayMessageInTextBox(pubnub.JsonPluggableLibrary.SerializeToJsonString(s)).ConfigureAwait(false);
});
}
}
public static void ThenSubscriberShouldBeAbleToReceiveManyMessages()
{
server.ClearRequests();
bool receivedMessage = false;
bool receivedErrorMessage = false;
int numberOfReceivedMessages = 0;
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(false);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) =>
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
if (m != null)
{
Debug.WriteLine("SubscribeCallback: PNMessageResult: {0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(m.Message));
numberOfReceivedMessages++;
if (numberOfReceivedMessages >= 10)
{
receivedMessage = true;
subscribeManualEvent.Set();
}
}
},
(o, p) => {
subscribeManualEvent.Set();
},
(o, s) => {
Debug.WriteLine(string.Format("{0} {1} {2}", s.Operation, s.Category, s.StatusCode));
if (s.StatusCode != 200 || s.Error)
{
receivedErrorMessage = true;
if (s.ErrorData != null)
{
Debug.WriteLine(s.ErrorData.Information);
}
subscribeManualEvent.Set();
}
else if (s.StatusCode == 200 && s.Category == PNStatusCategory.PNConnectedCategory)
{
receivedMessage = true;
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
manualResetEventWaitTimeout = 310 * 1000;
string channel = "hello_my_channel";
numberOfReceivedMessages = 0;
string expected = "{\"t\":{\"t\":\"14839022442039237\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().Channels(new [] { channel }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
if (!receivedErrorMessage)
{
if (receivedMessage && !PubnubCommon.EnableStubTest)
{
for (int index = 0; index < 10; index++)
{
Debug.WriteLine("ThenSubscriberShouldBeAbleToReceiveManyMessages..Publishing " + index.ToString());
ManualResetEvent publishManualEvent = new ManualResetEvent(false);
pubnub.Publish().Channel(channel).Message(index.ToString())
.Execute(new PNPublishResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
receivedMessage = true;
}
publishManualEvent.Set();
}));
publishManualEvent.WaitOne(manualResetEventWaitTimeout);
}
}
pubnub.Unsubscribe <string>().Channels(new[] { channel }).Execute();
Thread.Sleep(1000);
}
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannel --> ThenSubscriberShouldBeAbleToReceiveManyMessages Failed");
}
public static void ThenMultiSubscribeShouldReturnConnectStatusSSL()
{
server.ClearRequests();
bool receivedMessage = false;
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = true,
LogVerbosity = PNLogVerbosity.BODY,
PubnubLog = new TestLog(),
NonSubscribeRequestTimeout = 120
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(true);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) => { },
(o, p) => { },
(o, s) => {
Debug.WriteLine(string.Format("{0} {1} {2}", s.Operation, s.Category, s.StatusCode));
if (s.StatusCode == 200 && s.Category == PNStatusCategory.PNConnectedCategory)
{
receivedMessage = true;
}
subscribeManualEvent.Set();
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
manualResetEventWaitTimeout = 310 * 1000;
string channel1 = "hello_my_channel1";
string expected = "{\"t\":{\"t\":\"14839022442039237\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel1))
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().Channels(new [] { channel1 }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
string channel2 = "hello_my_channel2";
if (receivedMessage)
{
receivedMessage = false;
subscribeManualEvent = new ManualResetEvent(false);
expected = "{\"t\":{\"t\":\"14836303477713304\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel1 + "," + channel2))
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel1 + "," + channel2))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
Thread.Sleep(1000);
pubnub.Subscribe <string>().Channels(new [] { channel2 }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
}
Thread.Sleep(1000);
pubnub.Unsubscribe <string>().Channels(new [] { channel1, channel2 }).Execute();
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannel --> ThenMultiSubscribeShouldReturnConnectStatusSSL Failed");
}
private static void CommonComplexMessageSubscribeShouldReturnReceivedMessageBasedOnParams(string secretKey, string cipherKey, bool ssl, out bool receivedMessage)
{
if (PubnubCommon.PAMServerSideRun && string.IsNullOrEmpty(secretKey))
{
Assert.Ignore("Ignored for Server side run");
}
bool internalReceivedMessage = false;
bool receivedErrorMessage = false;
CustomClass publishedMessage = new CustomClass();
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
CipherKey = cipherKey,
Uuid = "mytestuuid",
Secure = ssl
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = secretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(ssl);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) =>
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
if (m != null)
{
Debug.WriteLine("SubscribeCallback: PNMessageResult: {0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(m.Message));
if (pubnub.JsonPluggableLibrary.SerializeToJsonString(publishedMessage) == m.Message.ToString())
{
internalReceivedMessage = true;
}
subscribeManualEvent.Set();
}
},
(o, p) => {
subscribeManualEvent.Set();
},
(o, s) => {
Debug.WriteLine(string.Format("{0} {1} {2}", s.Operation, s.Category, s.StatusCode));
if (s.StatusCode != 200 || s.Error)
{
receivedErrorMessage = true;
if (s.ErrorData != null)
{
Debug.WriteLine(s.ErrorData.Information);
}
subscribeManualEvent.Set();
}
else if (s.StatusCode == 200 && s.Category == PNStatusCategory.PNConnectedCategory)
{
internalReceivedMessage = true;
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
string channel = "hello_my_channel";
manualResetEventWaitTimeout = 310 * 1000;
string expected = "{\"t\":{\"t\":\"14836303477713304\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithParameter("auth", authKey)
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("timestamp", "1356998400")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithParameter("signature", "zJpO1HpSZxGkOr3EALbOk-vQgjIZTZ6AU5svzNU9l_A=")
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithParameter("auth", authKey)
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("timestamp", "1356998400")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().Channels(new [] { channel }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
expected = "[1,\"Sent\",\"14836234233392078\"]";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(string.Format("/publish/demo-36/{0}/0/{1}/0/{2}", PubnubCommon.SubscribeKey, channel, "%7B%22foo%22%3A%22hi%21%22%2C%22bar%22%3A%5B1%2C2%2C3%2C4%2C5%5D%7D"))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(string.Format("/publish/demo-36/{0}/0/{1}/0/{2}", PubnubCommon.SubscribeKey, channel, "%22Zbr7pEF%2FGFGKj1rOstp0tWzA4nwJXEfj%2BezLtAr8qqE%3D%22"))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
Thread.Sleep(1000);
if (!receivedErrorMessage)
{
ManualResetEvent publishManualEvent = new ManualResetEvent(false);
pubnub.Publish().Channel(channel).Message(publishedMessage)
.Execute(new PNPublishResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
internalReceivedMessage = true;
}
publishManualEvent.Set();
}));
publishManualEvent.WaitOne(manualResetEventWaitTimeout);
pubnub.Unsubscribe <string>().Channels(new[] { channel }).Execute();
Thread.Sleep(1000);
}
receivedMessage = internalReceivedMessage;
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
}
public static void ThenSubscribeShouldReturnReceivedMessage()
{
server.ClearRequests();
bool receivedMessage = false;
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false,
LogVerbosity = PNLogVerbosity.BODY,
PubnubLog = new TestLog(),
NonSubscribeRequestTimeout = 120
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(false);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) => {
if (m != null)
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
if (string.Compare(publishedMessage.ToString(), m.Message.ToString(), true) == 0)
{
receivedMessage = true;
}
}
subscribeManualEvent.Set();
},
(o, p) => { /* Catch the presence events */ },
(o, s) => {
Debug.WriteLine("SubscribeCallback: PNStatus: " + s.StatusCode.ToString());
if (s.StatusCode != 200 || s.Error)
{
subscribeManualEvent.Set();
if (s.ErrorData != null)
{
Debug.WriteLine(s.ErrorData.Information);
}
}
else if (s.StatusCode == 200 && (s.Category == PNStatusCategory.PNConnectedCategory || s.Category == PNStatusCategory.PNDisconnectedCategory))
{
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
string expected = "{\"status\": 200, \"message\": \"OK\", \"service\": \"channel-registry\", \"error\": false}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(string.Format("/v1/channel-registration/sub-key/{0}/channel-group/{1}", PubnubCommon.SubscribeKey, channelGroupName))
.WithParameter("add", channelName)
.WithParameter("auth", config.AuthKey)
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
ManualResetEvent channelGroupManualEvent = new ManualResetEvent(false);
pubnub.AddChannelsToChannelGroup().Channels(new [] { channelName }).ChannelGroup(channelGroupName).QueryParam(new Dictionary <string, object> {
{ "ut", "ThenSubscribeShouldReturnReceivedMessage" }
})
.Execute(new PNChannelGroupsAddChannelResultExt((r, s) => {
try
{
Debug.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(s));
if (r != null)
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(r));
if (s.StatusCode == 200 && s.Error == false && s.AffectedChannelGroups.Contains(channelGroupName))
{
receivedMessage = true;
}
}
}
catch { /* ignore */ }
finally { channelGroupManualEvent.Set(); }
}));
channelGroupManualEvent.WaitOne(manualResetEventWaitTimeout);
if (receivedMessage)
{
receivedMessage = false;
expected = "{\"t\":{\"t\":\"14839022442039237\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, ","))
.WithParameter("auth", authKey)
.WithParameter("channel-group", "hello_my_group")
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, ","))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().ChannelGroups(new [] { channelGroupName }).QueryParam(new Dictionary <string, object> {
{ "ut", "ThenSubscribeShouldReturnReceivedMessage" }
}).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
subscribeManualEvent = new ManualResetEvent(false);
publishedMessage = "Test for WhenSubscribedToAChannelGroup ThenItShouldReturnReceivedMessage";
expected = "[1,\"Sent\",\"14722484585147754\"]";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/publish/{0}/{1}/0/{2}/0/%22Test%20for%20WhenSubscribedToAChannelGroup%20ThenItShouldReturnReceivedMessage%22", PubnubCommon.PublishKey, PubnubCommon.SubscribeKey, channelName))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
Thread.Sleep(1000);
ManualResetEvent publishManualEvent = new ManualResetEvent(false);
pubnub.Publish().Channel(channelName).Message(publishedMessage).QueryParam(new Dictionary <string, object> {
{ "ut", "ThenSubscribeShouldReturnReceivedMessage" }
})
.Execute(new PNPublishResultExt((r, s) =>
{
Debug.WriteLine("Publish PNStatus => Status = : " + s.StatusCode.ToString());
if (r != null && s.StatusCode == 200 && !s.Error)
{
Debug.WriteLine("Publish Response: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(r));
publishTimetoken = r.Timetoken;
receivedMessage = true;
}
publishManualEvent.Set();
}));
publishManualEvent.WaitOne(manualResetEventWaitTimeout);
Thread.Sleep(1000);
pubnub.Unsubscribe <string>().ChannelGroups(new [] { channelGroupName }).QueryParam(new Dictionary <string, object> {
{ "ut", "ThenSubscribeShouldReturnReceivedMessage" }
}).Execute();
Thread.Sleep(1000);
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannelGroup --> ThenItShouldReturnReceivedMessage Failed");
}
else
{
Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannelGroup --> ThenItShouldReturnReceivedMessage Failed");
}
}
public void Initialize(string userId, long lastActivity = 0)
{
try
{
// we can only initialize if the user is registered
if (string.IsNullOrEmpty(userId))
{
return;
}
_UserId = userId;
PNConfiguration config = new PNConfiguration();
config.PublishKey = _PublishKey;
config.SubscribeKey = _SubscribeKey;
config.Uuid = _UserId;
config.Secure = true;
_Pubnub = new Pubnub(config);
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt((pubnubObj, message) =>
{
try
{
// get the message base to determine type
BaseMessage m = Serializer.Deserialize <BaseMessage>(message.Message.ToString());
// deserialize to actual type
m = (BaseMessage)Serializer.Deserialize(GetType().Assembly.GetType(m.Type), message.Message.ToString());
// let listeners know
MessageReceived?.Invoke(this, new MessageEventArgs <BaseMessage>(m));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.MessageReceived - Unable to deserialize message: {0}", message.Message.ToString()));
}
}, (pubnubObj, presence) =>
{
// handle incoming presence data
if (presence.Event.Equals("join"))
{
RaiseChannelJoined(presence.Channel, presence.Uuid);
}
else if (presence.Event.Equals("leave"))
{
RaiseChannelLeft(presence.Channel, presence.Uuid);
}
else if (presence.Event.Equals("state-change"))
{
// listen for status events - eg: typing, etc
if ((presence.State == null) || (presence.State.Count == 0))
{
return;
}
foreach (var key in presence.State.Keys)
{
var state = (ChatState)Enum.Parse(typeof(ChatState), presence.State[key].ToString());
RaiseChannelState(presence.Channel, presence.Uuid, state);
}
}
else if (presence.Event.Equals("timeout"))
{
}
else if (presence.Event.Equals("interval"))
{
// find the ids that have joined
if ((presence.Join != null) && (presence.Join.Length > 0))
{
foreach (var uuid in presence.Join)
{
RaiseChannelJoined(presence.Channel, uuid);
}
}
if ((presence.Leave != null) && (presence.Leave.Length > 0))
{
foreach (var uuid in presence.Leave)
{
RaiseChannelJoined(presence.Channel, uuid);
}
}
}
else if (presence.HereNowRefresh)
{
// TODO: request state for channels
//GetState();
}
}, (pubnubObj, status) =>
{
if (status.Operation == PNOperationType.PNHeartbeatOperation)
{
Connected = !status.Error;
ConnectedChanged?.Invoke(this, new EventArgs());
}
else if ((status.Operation != PNOperationType.PNSubscribeOperation) && (status.Operation != PNOperationType.PNUnsubscribeOperation))
{
return;
}
if (status.Category == PNStatusCategory.PNConnectedCategory)
{
// this is expected for a subscribe, this means there is no error or issue whatsoever
}
else if (status.Category == PNStatusCategory.PNReconnectedCategory)
{
// this usually occurs if subscribe temporarily fails but reconnects. This means
// there was an error but there is no longer any issue
}
else if (status.Category == PNStatusCategory.PNDisconnectedCategory)
{
// this is the expected category for an unsubscribe. This means there
// was no error in unsubscribing from everything
}
else if (status.Category == PNStatusCategory.PNUnexpectedDisconnectCategory)
{
// this is usually an issue with the internet connection, this is an error, handle appropriately
}
else if (status.Category == PNStatusCategory.PNAccessDeniedCategory)
{
// this means that PAM does allow this client to subscribe to this
// channel and channel group configuration. This is another explicit error
}
});
_Pubnub.AddListener(listenerSubscribeCallack);
// create and subscribe to the lobby channel
_Pubnub
.Subscribe <string>()
.Channels(new string[] { _UserId })
.WithPresence()
.Execute();
Initialized = true;
InitializedChanged?.Invoke(this, new EventArgs());
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.Initialize - Exception: {0}", ex));
}
}
public static void ThenShouldReturnUnsubscribedMessage()
{
server.RunOnHttps(false);
bool receivedMessage = false;
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(false);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) => { if (m != null)
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
}
},
(o, p) => { /* Catch the presence events */ },
(o, s) => {
Debug.WriteLine("SubscribeCallback: PNStatus: " + s.StatusCode.ToString());
if (s.StatusCode != 200 || s.Error)
{
subscribeManualEvent.Set();
if (s.ErrorData != null)
{
Debug.WriteLine(s.ErrorData.Information);
}
}
else if (s.StatusCode == 200 && (s.Category == PNStatusCategory.PNConnectedCategory || s.Category == PNStatusCategory.PNDisconnectedCategory))
{
receivedMessage = true;
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
channelGroupName = "hello_my_group";
string channelName = "hello_my_channel";
int manualResetEventWaitTimeout = 310 * 1000;
string expected = "{\"status\": 200, \"message\": \"OK\", \"service\": \"channel-registry\", \"error\": false}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(string.Format("/v1/channel-registration/sub-key/{0}/channel-group/{1}", PubnubCommon.SubscribeKey, channelGroupName))
.WithParameter("add", channelName)
.WithParameter("auth", config.AuthKey)
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
ManualResetEvent cgManualEvent = new ManualResetEvent(false);
pubnub.AddChannelsToChannelGroup().Channels(new [] { channelName }).ChannelGroup(channelGroupName)
.Execute(new PNChannelGroupsAddChannelResultExt((r, s) => {
try
{
Debug.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(s));
if (r != null)
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(r));
if (s.StatusCode == 200 && s.Error == false && s.AffectedChannelGroups.Contains(channelGroupName))
{
receivedMessage = true;
}
}
}
catch { /* ignore */ }
finally { cgManualEvent.Set(); }
}));
cgManualEvent.WaitOne(manualResetEventWaitTimeout);
if (receivedMessage)
{
receivedMessage = false;
expected = "{\"t\":{\"t\":\"14839022442039237\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, ","))
.WithParameter("auth", authKey)
.WithParameter("channel-group", channelGroupName)
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, ","))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().ChannelGroups(new [] { channelGroupName }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
if (receivedMessage)
{
receivedMessage = false;
subscribeManualEvent = new ManualResetEvent(false);
expected = "{\"status\": 200, \"action\": \"leave\", \"message\": \"OK\", \"service\": \"Presence\"}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/presence/sub_key/{0}/channel/{1}/leave", PubnubCommon.SubscribeKey, channelGroupName))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Unsubscribe <string>().ChannelGroups(new [] { channelGroupName }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout);
}
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage, "WhenUnsubscribedToAChannelGroup --> ThenShouldReturnUnsubscribedMessage Failed");
}
else
{
Assert.IsTrue(receivedMessage, "WhenUnsubscribedToAChannelGroup --> ThenShouldReturnUnsubscribedMessage Failed");
}
}
public static void ThenMultiSubscribeShouldReturnConnectStatus()
{
server.ClearRequests();
bool receivedMessage = false;
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
AuthKey = authKey,
Secure = false
};
server.RunOnHttps(false);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) => { if (m != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
}
},
(o, p) => { /* Catch the presence events */ },
(o, s) => {
Console.WriteLine("SubscribeCallback: PNStatus: " + s.StatusCode.ToString());
if (s.StatusCode != 200 || s.Error)
{
Console.ForegroundColor = ConsoleColor.Red;
if (s.ErrorData != null)
{
Console.WriteLine(s.ErrorData.Information);
}
Console.ForegroundColor = ConsoleColor.White;
}
else if (s.StatusCode == 200 &&
(s.AffectedChannelGroups != null && s.AffectedChannelGroups.Contains(channelGroupName1) && s.AffectedChannelGroups.Contains(channelGroupName2)) &&
s.Category == PNStatusCategory.PNConnectedCategory)
{
receivedMessage = true;
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
manualResetEventWaitTimeout = 310 * 1000;
channelGroupName1 = "hello_my_group1";
channelGroupName2 = "hello_my_group2";
string channelName1 = "hello_my_channel1";
string channelName2 = "hello_my_channel2";
string expected = "{\"status\": 200, \"message\": \"OK\", \"service\": \"channel-registry\", \"error\": false}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(string.Format("/v1/channel-registration/sub-key/{0}/channel-group/{1}", PubnubCommon.SubscribeKey, channelGroupName1))
.WithParameter("add", channelName1)
.WithParameter("auth", config.AuthKey)
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
ManualResetEvent channelGroupManualEvent = new ManualResetEvent(false);
pubnub.AddChannelsToChannelGroup().Channels(new [] { channelName1 }).ChannelGroup(channelGroupName1)
.Async(new PNChannelGroupsAddChannelResultExt((r, s) => {
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(s));
if (r != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(r));
if (s.StatusCode == 200 && s.Error == false && (s.AffectedChannelGroups.Contains(channelGroupName1) || s.AffectedChannelGroups.Contains(channelGroupName2)))
{
receivedMessage = true;
}
}
}
catch { /* ignore */ }
finally { channelGroupManualEvent.Set(); }
}));
channelGroupManualEvent.WaitOne(manualResetEventWaitTimeout);
if (receivedMessage)
{
receivedMessage = false;
expected = "{\"status\": 200, \"message\": \"OK\", \"service\": \"channel-registry\", \"error\": false}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(string.Format("/v1/channel-registration/sub-key/{0}/channel-group/{1}", PubnubCommon.SubscribeKey, channelGroupName2))
.WithParameter("add", channelName2)
.WithParameter("auth", config.AuthKey)
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
channelGroupManualEvent = new ManualResetEvent(false);
pubnub.AddChannelsToChannelGroup().Channels(new [] { channelName2 }).ChannelGroup(channelGroupName2)
.Async(new PNChannelGroupsAddChannelResultExt((r, s) => {
try
{
Console.WriteLine("PNStatus={0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(s));
if (r != null)
{
Console.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(r));
if (s.StatusCode == 200 && s.Error == false && (s.AffectedChannelGroups.Contains(channelGroupName1) || s.AffectedChannelGroups.Contains(channelGroupName2)))
{
receivedMessage = true;
}
}
}
catch { /* ignore */ }
finally { channelGroupManualEvent.Set(); }
}));
channelGroupManualEvent.WaitOne(manualResetEventWaitTimeout);
}
if (receivedMessage)
{
receivedMessage = false;
expected = "{\"t\":{\"t\":\"14839022442039237\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, ","))
.WithParameter("auth", config.AuthKey)
.WithParameter("channel-group", "hello_my_group1,hello_my_group2")
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, ","))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().ChannelGroups(new [] { channelGroupName1, channelGroupName2 }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
}
Thread.Sleep(1000);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannelGroup --> ThenMultiSubscribeShouldReturnConnectStatusFailed");
}
using PE.Plugins.PubnubChat.Models;
using PubnubApi;
using System;
namespace PE.Plugins.PubnubChat
{
public enum ChatState
{
None,
Waiting,
Typing,
InCall
}
public class ChatService : IChatService, IDisposable
{
#region Events
public event InitializationChangedEventHandler InitializedChanged;
public event EventHandler ConnectedChanged;
public event EventHandler<MessageEventArgs> MessageReceived;
public event EventHandler<PresenceEventArgs> ChannelJoined;
public event EventHandler<PresenceEventArgs> ChannelLeft;
public event EventHandler<PresenceEventArgs> ChannelTimeout;
public event EventHandler<PresenceEventArgs> ChannelState;
public event EventHandler<MessageEventArgs> PublishComplete;
#endregion Events
#region Fields
private Pubnub _Pubnub;
private readonly string _PublishKey = string.Empty;
private readonly string _SubscribeKey = string.Empty;
private SubscribeCallbackExt _ListenerSubscribeCallack;
private string _UserId = string.Empty;
private string _AuthKey = string.Empty;
private bool _Disposed = false;
private int _FailCount = 0;
private string _PushData = string.Empty;
#endregion Fields
#region Constructors
public ChatService(ChatConfiguration configuration)
{
_PublishKey = configuration.PublishKey;
_SubscribeKey = configuration.SubscribeKey;
}
~ChatService()
{
Dispose();
}
#endregion Constructors
#region Properties
public bool Connected { get; private set; }
public bool Initialized { get; private set; } = false;
#endregion Properties
#region Init
public void Initialize(string userId, string authKey = null, bool reset = true, string push = "")
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.Uninitialize - Initializing Chat for user {_UserId}, Reset: {reset}");
if (reset) _FailCount = 0;
// we can only initialize if the user is registered
if (string.IsNullOrEmpty(userId)) return;
_UserId = userId;
_AuthKey = authKey;
_PushData = push;
PNConfiguration config = new PNConfiguration();
config.PublishKey = _PublishKey;
config.SubscribeKey = _SubscribeKey;
config.Uuid = _UserId;
config.Secure = true;
config.HeartbeatNotificationOption = PNHeartbeatNotificationOption.All;
if (!string.IsNullOrEmpty(authKey)) config.AuthKey = authKey;
_Pubnub = new Pubnub(config);
_ListenerSubscribeCallack = new SubscribeCallbackExt(
(pubnub, message) => OnMessageReceived(pubnub, message),
(pubnub, presence) => OnPresenceReceived(pubnub, presence),
(pubnub, status) => OnStatusReceived(pubnub, status));
_Pubnub.AddListener(_ListenerSubscribeCallack);
// create and subscribe to the lobby channel
_Pubnub
.Subscribe<string>()
.Channels(new string[] { _UserId })
.WithPresence()
.Execute();
// add push if necessary
if (!string.IsNullOrEmpty(_PushData))
{
var data = _PushData.Split(new char[] { '|' });
if (data.Length != 2) throw new ArgumentException("Push initialization data.");
var type = (PNPushType)Enum.Parse(typeof(PNPushType), data[0]);
_Pubnub.AddPushNotificationsOnChannels()
.PushType(type)
.Channels(new string[] { _UserId })
//.DeviceId(data[1])
.DeviceId(data[1])
.Async(new AddPushChannelCallback());
}
Initialized = true;
InitializedChanged?.Invoke(Initialized);
}
public void Uninitialize()
{
// this can be called before Initialize
if (_Pubnub == null) return;
try
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.Uninitialize - Uninitializing Chat for user {_UserId}");
_Pubnub.RemoveListener(_ListenerSubscribeCallack);
_Pubnub.Unsubscribe<string>().Channels(new string[] { _UserId }).Execute();
// TODO: consider removing push channel association here
Initialized = false;
InitializedChanged?.Invoke(Initialized);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"{ GetType().Name}.Uninitialize - Exception: { ex}");
}
}
#endregion Init
#region Callbacks
private void OnMessageReceived(Pubnub pubnub, PNMessageResult<object> result)
{
try
{
MessageReceived?.Invoke(this, new MessageEventArgs(result.Message.ToString()));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.MessageReceived - Unable to deserialize message: { result.Message}\r\n\tException: { ex}");
}
}
private void OnPresenceReceived(Pubnub pubnub, PNPresenceEventResult result)
{
System.Diagnostics.Debug.WriteLine($"*** { GetType().Name}.OnPresenceReceived\r\n -> Event: { result.Event}");
{
// handle incoming presence data
if (result.Event.Equals("join"))
{
RaiseChannelJoined(result.Channel, result.Uuid);
}
else if (result.Event.Equals("leave"))
{
RaiseChannelLeft(result.Channel, result.Uuid);
}
else if (result.Event.Equals("state-change"))
{
// listen for status events - eg: typing, etc
if ((result.State == null) || (result.State.Count == 0)) return;
foreach (var key in result.State.Keys)
{
var state = (ChatState)Enum.Parse(typeof(ChatState), result.State[key].ToString());
RaiseChannelState(result.Channel, result.Uuid, state);
}
}
else if (result.Event.Equals("timeout"))
{
}
else if (result.Event.Equals("interval"))
{
// find the ids that have joined
if ((result.Join != null) && (result.Join.Length > 0))
{
foreach (var uuid in result.Join) RaiseChannelJoined(result.Channel, uuid);
}
if ((result.Leave != null) && (result.Leave.Length > 0))
{
foreach (var uuid in result.Leave) RaiseChannelJoined(result.Channel, uuid);
}
}
else if (result.HereNowRefresh)
{
// TODO: request state for channels
//GetState();
}
}
}
private void OnStatusReceived(Pubnub pubnub, PNStatus status)
{
{
System.Diagnostics.Debug.WriteLine($"*** {GetType().Name}.OnStatusReceived\r\n -> Operation: { status.Operation}\r\n -> Category: { status.Category}\r\n -> Error: { status.Error}\r\n -> Data: { status.ErrorData}\r\n -> Status Code: { status.StatusCode}");
if (status.Operation == PNOperationType.PNHeartbeatOperation)
{
Connected = !status.Error;
ConnectedChanged?.Invoke(this, new EventArgs());
}
if ((status.Operation == PNOperationType.PNSubscribeOperation) && (status.Category == PNStatusCategory.PNUnknownCategory) && (status.StatusCode == 404))
{
try
{
_FailCount++;
if (_FailCount > 3)
public static async Task ThenWithAsyncSendFileShouldReturnSuccess()
#endif
{
server.ClearRequests();
receivedMessage = false;
bool receivedEvent = false;
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNFileEventResult eventResult)
{
receivedEvent = true;
System.Diagnostics.Debug.WriteLine("FILE EVENT: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
//CipherKey = "enigma",
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
mre = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { channelName }).Execute();
mre.WaitOne(2000);
string expected = "{\"status\": 200, \"message\": \"OK\", \"service\": \"channel-registry\", \"error\": false}";
mre = new ManualResetEvent(false);
string fileId = "";
string fileName = "";
receivedMessage = false;
string targetFileUpload = @"C:\Pandu\pubnub\word_test.txt";
Dictionary <string, object> myInternalMsg = new Dictionary <string, object>();
myInternalMsg.Add("color", "red");
myInternalMsg.Add("name", "John Doe");
#if NET40
PNResult <PNFileUploadResult> sendFileResult = Task.Factory.StartNew(async() => await pubnub.SendFile().Channel(channelName).File(targetFileUpload).Message(myInternalMsg).ExecuteAsync()).Result.Result;
#else
PNResult <PNFileUploadResult> sendFileResult = await pubnub.SendFile().Channel(channelName).File(targetFileUpload).Message(myInternalMsg).ExecuteAsync();
#endif
if (sendFileResult.Result != null && !string.IsNullOrEmpty(sendFileResult.Result.FileId) && sendFileResult.Result.Timetoken > 0)
{
System.Diagnostics.Debug.WriteLine("SendFile result = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(sendFileResult.Result));
fileId = sendFileResult.Result.FileId;
fileName = sendFileResult.Result.FileName;
receivedMessage = true;
}
receivedMessage = false;
mre = new ManualResetEvent(false);
pubnub.ListFiles().Channel(channelName)
.Execute(new PNListFilesResultExt((result, status) =>
{
if (result != null)
{
System.Diagnostics.Debug.WriteLine("ListFiles result = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
receivedMessage = true;
}
mre.Set();
}));
Thread.Sleep(1000);
mre.WaitOne();
if (receivedMessage)
{
receivedMessage = false;
mre = new ManualResetEvent(false);
pubnub.DownloadFile().Channel(channelName).FileId(fileId).FileName(fileName).Execute(new PNDownloadFileResultExt((result, status) =>
{
if (result != null && result.FileBytes != null && result.FileBytes.Length > 0)
{
System.Diagnostics.Debug.WriteLine("DownloadFile result = " + result.FileBytes.Length);
receivedMessage = true;
}
mre.Set();
}));
mre.WaitOne();
}
if (receivedMessage)
{
receivedMessage = false;
mre = new ManualResetEvent(false);
pubnub.DeleteFile().Channel(channelName).FileId(fileId).FileName(fileName)
.Execute(new PNDeleteFileResultExt((result, status) =>
{
if (result != null)
{
System.Diagnostics.Debug.WriteLine("DeleteFile result = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
receivedMessage = true;
}
mre.Set();
}));
Thread.Sleep(1000);
mre.WaitOne();
}
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage && receivedEvent, "WhenFileIsRequested -> ThenWithAsyncSendFileShouldReturnSuccess failed.");
}
public static void ThenSubscribeShouldReturnConnectStatus()
{
server.ClearRequests();
bool receivedMessage = false;
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false
};
server.RunOnHttps(false);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) => { },
(o, p) => { },
(o, s) => {
Console.WriteLine("{0} {1} {2}", s.Operation, s.Category, s.StatusCode);
if (s.StatusCode == 200 && s.Category == PNStatusCategory.PNConnectedCategory)
{
receivedMessage = true;
}
subscribeManualEvent.Set();
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
string channel = "hello_my_channel";
manualResetEventWaitTimeout = 310 * 1000;
string expected = "{\"t\":{\"t\":\"14836303477713304\",\"r\":7},\"m\":[]}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithParameter("heartbeat", "300")
.WithParameter("pnsdk", PubnubCommon.EncodedSDK)
.WithParameter("requestid", "myRequestId")
.WithParameter("tt", "0")
.WithParameter("uuid", config.Uuid)
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
expected = "{}";
server.AddRequest(new Request()
.WithMethod("GET")
.WithPath(String.Format("/v2/subscribe/{0}/{1}/0", PubnubCommon.SubscribeKey, channel))
.WithResponse(expected)
.WithStatusCode(System.Net.HttpStatusCode.OK));
pubnub.Subscribe <string>().Channels(new [] { channel }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for Connect Status
Thread.Sleep(1000);
pubnub.Unsubscribe <string>().Channels(new [] { channel }).Execute();
Thread.Sleep(1000);
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannel --> ThenSubscribeShouldReturnConnectStatus Failed");
}
public static void ThenUserUpdateDeleteShouldReturnEventInfo()
{
server.ClearRequests();
if (PubnubCommon.EnableStubTest)
{
Assert.Ignore("Ignored ThenUserUpdateDeleteShouldReturnEventInfo");
return;
}
bool receivedMessage = false;
bool receivedDeleteEvent = false;
bool receivedUpdateEvent = false;
string userId = "pandu-ut-uid";
manualResetEventWaitTimeout = 310 * 1000;
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNObjectApiEventResult eventResult)
{
System.Diagnostics.Debug.WriteLine("EVENT:" + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
if (eventResult.Type.ToLowerInvariant() == "user")
{
if (eventResult.Event.ToLowerInvariant() == "update")
{
receivedUpdateEvent = true;
}
else if (eventResult.Event.ToLowerInvariant() == "delete")
{
receivedDeleteEvent = true;
}
}
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMEnabled)
{
config.SecretKey = PubnubCommon.SecretKey;
}
server.RunOnHttps(false);
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
ManualResetEvent manualEvent = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { "pnuser-" + userId }).Execute();
manualEvent.WaitOne(2000);
manualEvent = new ManualResetEvent(false);
System.Diagnostics.Debug.WriteLine("pubnub.DeleteUser() STARTED");
pubnub.DeleteUser().Id(userId).Execute(new PNDeleteUserResultExt(
delegate(PNDeleteUserResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
manualEvent = new ManualResetEvent(false);
#region "CreateUser"
System.Diagnostics.Debug.WriteLine("pubnub.CreateUser() STARTED");
pubnub.CreateUser().Id(userId).Name("pandu-ut-un")
.Execute(new PNCreateUserResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (userId == r.Id)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
if (receivedMessage)
{
receivedMessage = false;
manualEvent = new ManualResetEvent(false);
#region "UpdateUser"
System.Diagnostics.Debug.WriteLine("pubnub.UpdateUser() STARTED");
pubnub.UpdateUser().Id(userId).Name("pandu-ut-un-upd")
.ProfileUrl("pandu-sample-profile-url").ExternalId("pandu-sample-ext-id")
.Email("*****@*****.**")
.CustomObject(new Dictionary <string, object>()
{
{ "color", "red" }
})
.Execute(new PNUpdateUserResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (userId == r.Id)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
}
if (!receivedDeleteEvent)
{
manualEvent = new ManualResetEvent(false);
System.Diagnostics.Debug.WriteLine("pubnub.DeleteUser() 2 STARTED");
pubnub.DeleteUser().Id(userId).Execute(new PNDeleteUserResultExt(
delegate(PNDeleteUserResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
}
pubnub.Unsubscribe <string>().Channels(new string[] { "pnuser-" + userId }).Execute();
pubnub.RemoveListener(eventListener);
Assert.IsTrue(receivedDeleteEvent && receivedUpdateEvent, "User events Failed");
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
}
// Where pair like "BTC_USD"
// TODO: change interface so SubscribeWebSocket takes (at least) a currency pair argument
public void SubscribeWebSocket(string[] args = null)
{
var config = new PNConfiguration();
config.SubscribeKey = "sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f";
//config.AuthKey = this.ApiKey;
//config.CipherKey = this.ApiSecret;
var pubnub = new Pubnub(config);
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt(
(pubnubObj, message) => {
// Handle new message stored in message.Message
string channel = message.Channel;
long timeToken = message.Timetoken;
//cout("channel: {0}", channel);
if (channel == "lightning_ticker_BTC_USD")
{
var ticker = JsonConvert.DeserializeObject <BitFlyerWebsocketTicker>((string)message.Message);
//cout(ticker.ToString());
}
else if (channel == "lightning_board_BTC_USD")
{
var obupdate = JsonConvert.DeserializeObject <BitFlyerOrderBookUpdate>((string)message.Message);
foreach (var b in obupdate.bids)
{
m_orderBook.UpdateBid(b.price, b.size);
}
foreach (var a in obupdate.asks)
{
m_orderBook.UpdateAsk(a.price, a.size);
}
FireOrderBookUpdate();
//cout(obupdate.ToString());
}
},
(pubnubObj, presence) => {
// handle incoming presence data
},
(pubnubObj, status) => {
// the status object returned is always related to subscribe but could contain
// information about subscribe, heartbeat, or errors
// use the PNOperationType to switch on different options
switch (status.Operation)
{
// let's combine unsubscribe and subscribe handling for ease of use
case PNOperationType.PNSubscribeOperation:
case PNOperationType.PNUnsubscribeOperation:
// note: subscribe statuses never have traditional
// errors, they just have categories to represent the
// different issues or successes that occur as part of subscribe
switch (status.Category)
{
case PNStatusCategory.PNConnectedCategory:
// this is expected for a subscribe, this means there is no error or issue whatsoever
break;
case PNStatusCategory.PNReconnectedCategory:
// this usually occurs if subscribe temporarily fails but reconnects. This means
// there was an error but there is no longer any issue
break;
case PNStatusCategory.PNDisconnectedCategory:
// this is the expected category for an unsubscribe. This means there
// was no error in unsubscribing from everything
break;
case PNStatusCategory.PNUnexpectedDisconnectCategory:
// this is usually an issue with the internet connection, this is an error, handle appropriately
break;
case PNStatusCategory.PNAccessDeniedCategory:
// this means that PAM does allow this client to subscribe to this
// channel and channel group configuration. This is another explicit error
break;
default:
// More errors can be directly specified by creating explicit cases for other
// error categories of `PNStatusCategory` such as `PNTimeoutCategory` or `PNMalformedFilterExpressionCategory` or `PNDecryptionErrorCategory`
break;
}
break;
case PNOperationType.PNHeartbeatOperation:
// heartbeat operations can in fact have errors, so it is important to check first for an error.
if (status.Error)
{
// There was an error with the heartbeat operation, handle here
}
else
{
// heartbeat operation was successful
}
break;
default:
// Encountered unknown status type
break;
}
});
pubnub.AddListener(listenerSubscribeCallack);
pubnub.Subscribe <string>()
.Channels(new string[] {
//"lightning_ticker_BTC_JPY",
"lightning_ticker_BTC_USD",
"lightning_board_BTC_USD"
})
.Execute();
}
public static async Task ThenWithAsyncIgnoreCipherKeyUnencryptSignalListenerShouldGetMessagae()
#endif
{
server.ClearRequests();
bool internalReceivedMessage = false;
bool receivedErrorMessage = false;
if (PubnubCommon.EnableStubTest)
{
Assert.Ignore("Ignored ThenWithAsyncIgnoreCipherKeyUnencryptSignalListenerShouldGetMessagae");
return;
}
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
CipherKey = "testcipherkey",
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(config.Secure);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
delegate(Pubnub o, PNSignalResult <object> m)
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
if (m != null)
{
Debug.WriteLine(string.Format("Signal SubscribeCallback: PNMessageResult: {0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(m.Message)));
if (pubnub.JsonPluggableLibrary.SerializeToJsonString(messageForUnencryptSignal) == m.Message.ToString())
{
internalReceivedMessage = true;
}
subscribeManualEvent.Set();
}
},
delegate(Pubnub o, PNStatus s) {
Debug.WriteLine(string.Format("{0} {1} {2}", s.Operation, s.Category, s.StatusCode));
if (s.StatusCode != 200 || s.Error)
{
receivedErrorMessage = true;
if (s.ErrorData != null)
{
Debug.WriteLine(s.ErrorData.Information);
}
subscribeManualEvent.Set();
}
else if (s.StatusCode == 200 && s.Category == PNStatusCategory.PNConnectedCategory)
{
internalReceivedMessage = true;
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
string channel = "hello_my_channel";
manualResetEventWaitTimeout = 310 * 1000;
pubnub.Subscribe <string>().Channels(new[] { channel }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for connect
Thread.Sleep(1000);
if (!receivedErrorMessage)
{
subscribeManualEvent = new ManualResetEvent(false); //Reset to wait for message
internalReceivedMessage = false;
#if NET40
PNResult <PNPublishResult> signalResult = Task.Factory.StartNew(async() => await pubnub.Signal().Channel(channel).Message(messageForUnencryptSignal).ExecuteAsync()).Result.Result;
#else
PNResult <PNPublishResult> signalResult = await pubnub.Signal().Channel(channel).Message(messageForUnencryptSignal).ExecuteAsync();
#endif
if (signalResult.Result != null && signalResult.Status.StatusCode == 200 && !signalResult.Status.Error)
{
internalReceivedMessage = true;
}
pubnub.Unsubscribe <string>().Channels(new[] { channel }).Execute();
Thread.Sleep(1000);
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
if (receivedErrorMessage)
{
internalReceivedMessage = false;
}
Assert.IsTrue(internalReceivedMessage, "WhenSubscribedToAChannel --> ThenWithAsyncIgnoreCipherKeyUnencryptSignalListenerShouldGetMessagae Failed");
}
}
public static void ThenMemberAddUpdateRemoveShouldReturnEventInfo()
{
server.ClearRequests();
if (PubnubCommon.EnableStubTest)
{
Assert.Ignore("Ignored ThenMemberAddUpdateRemoveShouldReturnEventInfo");
return;
}
bool receivedMessage = false;
bool receivedCreateEvent = false;
bool receivedDeleteEvent = false;
bool receivedUpdateEvent = false;
string spaceId = "pandu-ut-sid";
string userId1 = "pandu-ut-uid1";
string userId2 = "pandu-ut-uid2";
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNObjectApiEventResult eventResult)
{
System.Diagnostics.Debug.WriteLine("EVENT:" + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
if (eventResult.Type.ToLowerInvariant() == "membership")
{
if (eventResult.Event.ToLowerInvariant() == "create")
{
receivedCreateEvent = true;
}
else if (eventResult.Event.ToLowerInvariant() == "update")
{
receivedUpdateEvent = true;
}
else if (eventResult.Event.ToLowerInvariant() == "delete")
{
receivedDeleteEvent = true;
}
}
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMEnabled)
{
config.SecretKey = PubnubCommon.SecretKey;
}
server.RunOnHttps(false);
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
ManualResetEvent manualEvent = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { "pnuser-" + userId1, "pnuser-" + userId2, spaceId }).Execute();
manualEvent.WaitOne(2000);
manualResetEventWaitTimeout = 310 * 1000;
System.Diagnostics.Debug.WriteLine("pubnub.DeleteUser() 1 STARTED");
manualEvent = new ManualResetEvent(false);
pubnub.DeleteUser().Id(userId1).Execute(new PNDeleteUserResultExt(
delegate(PNDeleteUserResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
System.Diagnostics.Debug.WriteLine("pubnub.DeleteUser() 2 STARTED");
manualEvent = new ManualResetEvent(false);
pubnub.DeleteUser().Id(userId2).Execute(new PNDeleteUserResultExt(
delegate(PNDeleteUserResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
System.Diagnostics.Debug.WriteLine("pubnub.DeleteSpace() STARTED");
manualEvent = new ManualResetEvent(false);
pubnub.DeleteSpace().Id(spaceId).Execute(new PNDeleteSpaceResultExt(
delegate(PNDeleteSpaceResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
manualEvent = new ManualResetEvent(false);
receivedMessage = false;
#region "CreateUser 1"
System.Diagnostics.Debug.WriteLine("pubnub.CreateUser() 1 STARTED");
pubnub.CreateUser().Id(userId1).Name("pandu-ut-un1")
.Execute(new PNCreateUserResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (userId1 == r.Id)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
if (receivedMessage)
{
receivedMessage = false;
manualEvent = new ManualResetEvent(false);
#region "CreateUser 2"
System.Diagnostics.Debug.WriteLine("pubnub.CreateUser() 2 STARTED");
pubnub.CreateUser().Id(userId2).Name("pandu-ut-un2")
.Execute(new PNCreateUserResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (userId2 == r.Id)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
}
if (receivedMessage)
{
receivedMessage = false;
manualEvent = new ManualResetEvent(false);
#region "CreateSpace"
System.Diagnostics.Debug.WriteLine("pubnub.CreateSpace() STARTED");
pubnub.CreateSpace().Id(spaceId).Name("pandu-ut-spname")
.Execute(new PNCreateSpaceResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (spaceId == r.Id)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
}
if (receivedMessage)
{
receivedMessage = false;
manualEvent = new ManualResetEvent(false);
#region "Members Add"
System.Diagnostics.Debug.WriteLine("pubnub.Members() ADD STARTED");
pubnub.Members().SpaceId(spaceId)
.Add(new List <PNMember>()
{
new PNMember()
{
UserId = userId1
},
new PNMember()
{
UserId = userId2
}
})
.Execute(new PNMembersResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (r.Members != null &&
r.Members.Find(x => x.UserId == userId1) != null &&
r.Members.Find(x => x.UserId == userId2) != null)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
}
if (receivedMessage)
{
receivedMessage = false;
manualEvent = new ManualResetEvent(false);
#region "Members Update/Remove"
System.Diagnostics.Debug.WriteLine("pubnub.Members() UPDATE/REMOVE STARTED");
pubnub.Members().SpaceId(spaceId)
.Update(new List <PNMember>()
{
new PNMember()
{
UserId = userId1, Custom = new Dictionary <string, object>()
{
{ "color", "green1" }
}
}
})
.Remove(new List <string>()
{
userId2
})
.Execute(new PNMembersResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (r.Members != null &&
r.Members.Find(x => x.UserId == userId1) != null)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
}
pubnub.Unsubscribe <string>().Channels(new string[] { "pnuser-" + userId1, "pnuser-" + userId2, spaceId }).Execute();
pubnub.RemoveListener(eventListener);
Assert.IsTrue(receivedDeleteEvent && receivedUpdateEvent && receivedCreateEvent, "Member events Failed");
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
}
public void AddListener(Func <MessageDTO, bool> func)
{
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt(
(pubnubObj, message) =>
{
func(new MessageDTO(message.Message.ToString()));
},
(pubnubObj, presence) =>
{
// handle incoming presence data
},
(pubnubObj, status) =>
{
// the status object returned is always related to subscribe but could contain
// information about subscribe, heartbeat, or errors
// use the PNOperationType to switch on different options
switch (status.Operation)
{
// let's combine unsubscribe and subscribe handling for ease of use
case PNOperationType.PNSubscribeOperation:
case PNOperationType.PNUnsubscribeOperation:
// note: subscribe statuses never have traditional
// errors, they just have categories to represent the
// different issues or successes that occur as part of subscribe
switch (status.Category)
{
case PNStatusCategory.PNConnectedCategory:
// this is expected for a subscribe, this means there is no error or issue whatsoever
break;
case PNStatusCategory.PNReconnectedCategory:
// this usually occurs if subscribe temporarily fails but reconnects. This means
// there was an error but there is no longer any issue
break;
case PNStatusCategory.PNDisconnectedCategory:
// this is the expected category for an unsubscribe. This means there
// was no error in unsubscribing from everything
break;
case PNStatusCategory.PNUnexpectedDisconnectCategory:
// this is usually an issue with the internet connection, this is an error, handle appropriately
break;
case PNStatusCategory.PNAccessDeniedCategory:
// this means that PAM does allow this client to subscribe to this
// channel and channel group configuration. This is another explicit error
break;
default:
// More errors can be directly specified by creating explicit cases for other
// error categories of `PNStatusCategory` such as `PNTimeoutCategory` or `PNMalformedFilterExpressionCategory` or `PNDecryptionErrorCategory`
break;
}
break;
case PNOperationType.PNHeartbeatOperation:
// heartbeat operations can in fact have errors, so it is important to check first for an error.
if (status.Error)
{
// There was an error with the heartbeat operation, handle here
}
else
{
// heartbeat operation was successful
}
break;
default:
// Encountered unknown status type
break;
}
}
);
pubnub.AddListener(listenerSubscribeCallack);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.PageHomeView);
string channelName = Intent.GetStringExtra("Channel");
string channelGroupName = Intent.GetStringExtra("ChannelGroup");
bool enableSSL = Convert.ToBoolean((Intent.GetStringExtra("SslOn")));
string cipher = (Intent.GetStringExtra("Cipher"));
string ssl = "";
if (enableSSL)
{
ssl = "SSL,";
}
if (!String.IsNullOrWhiteSpace(cipher))
{
cipher = " Cipher";
}
string head = String.Format("{0}{1}", ssl, cipher);
pubnub = LaunchScreen.pubnub;
config = pubnub.PNConfig;
config.PubnubLog = new LocalLog();
config.LogVerbosity = PNLogVerbosity.BODY;
config.ReconnectionPolicy = PNReconnectionPolicy.LINEAR;
listener = new SubscribeCallbackExt(
(o, m) =>
{
if (m != null)
{
Display(pubnub.JsonPluggableLibrary.SerializeToJsonString(m.Message));
}
},
(o, p) =>
{
if (p != null)
{
Display(p.Event);
}
},
(o, s) =>
{
if (s != null)
{
Display(s.Category + " " + s.Operation + " " + s.StatusCode);
}
});
Title = head;
this.m_Title = this.m_DrawerTitle = this.Title;
TextView txtSubscribedChannel = FindViewById <TextView> (Resource.Id.newChannels);
txtSubscribedChannel.Text = channelName;
channel = txtSubscribedChannel.Text;
TextView txtSubscribedChannelGroup = FindViewById <TextView> (Resource.Id.newChannelGroups);
txtSubscribedChannelGroup.Text = channelGroupName;
channelGroup = txtSubscribedChannelGroup.Text;
TextView txtViewLog = FindViewById <TextView> (Resource.Id.txtViewLog);
txtViewLog.Text = "";
try {
this.m_Drawer = this.FindViewById <DrawerLayout> (Resource.Id.drawer_layout);
this.m_DrawerList = this.FindViewById <ListView> (Resource.Id.left_drawer);
this.m_DrawerList.Adapter = new ArrayAdapter <string> (this, Resource.Layout.ItemMenu, Sections);
this.m_DrawerList.ItemClick += (sender, args) => ListItemClicked(args.Position);
this.m_Drawer.SetDrawerShadow(Resource.Drawable.drawer_shadow_dark, (int)GravityFlags.Start);
//DrawerToggle is the animation that happens with the indicator next to the actionbar
this.m_DrawerToggle = new MyActionBarDrawerToggle(this, this.m_Drawer,
Resource.Drawable.ic_drawer_light,
Resource.String.drawer_open,
Resource.String.drawer_close);
//Display the current fragments title and update the options menu
this.m_DrawerToggle.DrawerClosed += (o, args) => {
this.ActionBar.Title = this.m_Title;
this.InvalidateOptionsMenu();
};
//Display the drawer title and update the options menu
this.m_DrawerToggle.DrawerOpened += (o, args) => {
this.ActionBar.Title = this.m_DrawerTitle;
this.InvalidateOptionsMenu();
};
//Set the drawer lister to be the toggle.
this.m_Drawer.SetDrawerListener(this.m_DrawerToggle);
//if first time you will want to go ahead and click first item.
this.ActionBar.SetDisplayHomeAsUpEnabled(true);
this.ActionBar.SetHomeButtonEnabled(true);
} catch (Exception ex) {
System.Diagnostics.Debug.WriteLine(ex.ToString());
}
}
void CallingPubnub()
{
Dictionary <string, string> message = new Dictionary <string, string>();
message.Add("msg", "Hello World!");
Pubnub pubnub = new Pubnub(pnConfiguration);
SubscribeCallbackExt subscribeCallback = new SubscribeCallbackExt(
(pubnubObj, messageResult) =>
{
if (messageResult != null)
{
Debug.WriteLine("In Example, SusbcribeCallback received PNMessageResult");
Debug.WriteLine("In Example, SusbcribeCallback messsage channel = " + messageResult.Channel);
Debug.WriteLine("In Example, SusbcribeCallback messsage channelGroup = " + messageResult.Subscription);
Debug.WriteLine("In Example, SusbcribeCallback messsage publishTimetoken = " + messageResult.Timetoken);
Debug.WriteLine("In Example, SusbcribeCallback messsage publisher = " + messageResult.Publisher);
string jsonString = messageResult.Message.ToString();
Dictionary <string, string> msg = pubnub.JsonPluggableLibrary.DeserializeToObject <Dictionary <string, string> >(jsonString);
Debug.WriteLine("msg: " + msg["msg"]);
// MyList.Add(msg["msg"]);
}
},
(pubnubObj, presencResult) =>
{
if (presencResult != null)
{
Debug.WriteLine("In Example, SusbcribeCallback received PNPresenceEventResult");
Debug.WriteLine(presencResult.Channel + " " + presencResult.Occupancy + " " + presencResult.Event);
}
},
(pubnubObj, statusResult) =>
{
if (statusResult.Category == PNStatusCategory.PNConnectedCategory)
{
pubnub.Publish()
.Channel("my_channel")
.Message(message)
.Async(new PNPublishResultExt((publishResult, publishStatus) =>
{
if (!publishStatus.Error)
{
Debug.WriteLine(string.Format("DateTime {0}, In Publish Example, Timetoken: {1}", DateTime.UtcNow, publishResult.Timetoken));
}
else
{
Debug.WriteLine(publishStatus.Error);
Debug.WriteLine(publishStatus.ErrorData.Information);
}
}));
}
}
);
pubnub.AddListener(subscribeCallback);
pubnub.Subscribe <string>()
.Channels(new string[] {
"my_channel"
}).Execute();
}
public static void ThenChannelMetadataSetDeleteShouldReturnEventInfo()
{
server.ClearRequests();
if (PubnubCommon.EnableStubTest)
{
Assert.Ignore("Ignored ThenChannelMetadataSetDeleteShouldReturnEventInfo");
return;
}
bool receivedMessage = false;
bool receivedDeleteEvent = false;
bool receivedUpdateEvent = false;
string channelMetadataId = "pandu-ut-sid";
manualResetEventWaitTimeout = 310 * 1000;
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNObjectEventResult eventResult)
{
System.Diagnostics.Debug.WriteLine("EVENT:" + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
if (eventResult.Type.ToLowerInvariant() == "channel")
{
if (eventResult.Event.ToLowerInvariant() == "set")
{
receivedUpdateEvent = true;
}
else if (eventResult.Event.ToLowerInvariant() == "delete")
{
receivedDeleteEvent = true;
}
}
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false,
AuthKey = "myauth"
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(false);
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
ManualResetEvent manualEvent = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { channelMetadataId }).Execute();
manualEvent.WaitOne(2000);
manualEvent = new ManualResetEvent(false);
System.Diagnostics.Debug.WriteLine("pubnub.RemoveChannelMetadata() STARTED");
pubnub.RemoveChannelMetadata().Channel(channelMetadataId).Execute(new PNRemoveChannelMetadataResultExt(
delegate(PNRemoveChannelMetadataResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
manualEvent = new ManualResetEvent(false);
#region "SetChannelMetadata"
System.Diagnostics.Debug.WriteLine("pubnub.SetChannelMetadata() STARTED");
pubnub.SetChannelMetadata().Channel(channelMetadataId).Name("pandu-ut-spname")
.Execute(new PNSetChannelMetadataResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (channelMetadataId == r.Channel)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
if (receivedMessage)
{
receivedMessage = false;
manualEvent = new ManualResetEvent(false);
#region "SetChannelMetadata"
System.Diagnostics.Debug.WriteLine("pubnub.SetChannelMetadata() STARTED");
pubnub.SetChannelMetadata().Channel(channelMetadataId).Name("pandu-ut-spname-upd")
.Description("pandu-ut-spdesc")
.Custom(new Dictionary <string, object>()
{
{ "color", "red" }
})
.Execute(new PNSetChannelMetadataResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(r);
if (channelMetadataId == r.Channel)
{
receivedMessage = true;
}
}
manualEvent.Set();
}));
#endregion
manualEvent.WaitOne(manualResetEventWaitTimeout);
}
if (!receivedDeleteEvent)
{
manualEvent = new ManualResetEvent(false);
System.Diagnostics.Debug.WriteLine("pubnub.RemoveChannelMetadata() 2 STARTED");
pubnub.RemoveChannelMetadata().Channel(channelMetadataId).Execute(new PNRemoveChannelMetadataResultExt(
delegate(PNRemoveChannelMetadataResult result, PNStatus status) { }));
manualEvent.WaitOne(2000);
}
Thread.Sleep(2000);
pubnub.Unsubscribe <string>().Channels(new string[] { channelMetadataId }).Execute();
pubnub.RemoveListener(eventListener);
Assert.IsTrue(receivedDeleteEvent && receivedUpdateEvent, "Channel Metadata events Failed");
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
}
public static async Task ThenWithAsyncAddRemoveMessageActionReturnEventInfo()
#endif
{
server.ClearRequests();
if (!PubnubCommon.PAMServerSideRun)
{
Assert.Ignore("ThenWithAsyncAddRemoveMessageActionReturnEventInfo needs Secret Key");
return;
}
bool receivedMessage = false;
bool receivedAddEvent = false;
bool receivedRemoveEvent = false;
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNMessageActionEventResult eventResult)
{
System.Diagnostics.Debug.WriteLine("EVENT:" + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
if (eventResult.Event == "added")
{
receivedAddEvent = true;
}
else if (eventResult.Event == "removed")
{
receivedRemoveEvent = true;
}
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(false);
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
string channel = "hello_my_channel";
manualResetEventWaitTimeout = (PubnubCommon.EnableStubTest) ? 1000 : 310 * 1000;
long currentMessageTimetoken = new Random().Next(Int32.MaxValue);
long currentActionTimetoken = 0;
string currentUUID = "";
ManualResetEvent me = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { channel }).Execute();
me.WaitOne(2000);
System.Diagnostics.Debug.WriteLine("GetMessageActions STARTED");
#if NET40
PNResult <PNGetMessageActionsResult> getMsgActionResult = Task.Factory.StartNew(async() => await pubnub.GetMessageActions().Channel(channel).ExecuteAsync()).Result.Result;
#else
PNResult <PNGetMessageActionsResult> getMsgActionResult = await pubnub.GetMessageActions().Channel(channel).ExecuteAsync();
#endif
if (getMsgActionResult.Result != null && getMsgActionResult.Status.StatusCode == 200 && !getMsgActionResult.Status.Error)
{
System.Diagnostics.Debug.WriteLine("GetMessageActions = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(getMsgActionResult.Result));
if (getMsgActionResult.Result.MessageActions != null && getMsgActionResult.Result.MessageActions.Exists(x => x.MessageTimetoken == currentMessageTimetoken))
{
PNMessageActionItem actionItem = getMsgActionResult.Result.MessageActions.Find(x => x.MessageTimetoken == currentMessageTimetoken);
currentActionTimetoken = actionItem.ActionTimetoken;
currentUUID = actionItem.Uuid;
}
}
Thread.Sleep(2000);
if (currentMessageTimetoken > 0 && currentActionTimetoken > 0)
{
System.Diagnostics.Debug.WriteLine("RemoveMessageAction STARTED");
#if NET40
PNResult <PNRemoveMessageActionResult> removeMsgActionResult = Task.Factory.StartNew(async() => await pubnub.RemoveMessageAction()
.Channel(channel)
.MessageTimetoken(currentMessageTimetoken)
.ActionTimetoken(currentActionTimetoken)
.Uuid(currentUUID)
.ExecuteAsync()).Result.Result;
#else
PNResult <PNRemoveMessageActionResult> removeMsgActionResult = await pubnub.RemoveMessageAction()
.Channel(channel)
.MessageTimetoken(currentMessageTimetoken)
.ActionTimetoken(currentActionTimetoken)
.Uuid(currentUUID)
.ExecuteAsync();
#endif
if (removeMsgActionResult.Result != null && removeMsgActionResult.Status.StatusCode == 200 && !removeMsgActionResult.Status.Error)
{
System.Diagnostics.Debug.WriteLine("RemoveMessageAction = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(removeMsgActionResult.Result));
receivedMessage = true;
}
}
System.Diagnostics.Debug.WriteLine("AddMessageAction STARTED");
#if NET40
PNResult <PNAddMessageActionResult> addMsgActionResult = Task.Factory.StartNew(async() => await pubnub.AddMessageAction()
.Channel(channel)
.MessageTimetoken(currentMessageTimetoken)
.Action(new PNMessageAction {
Type = "reaction", Value = "smily_face"
})
.ExecuteAsync()).Result.Result;
#else
PNResult <PNAddMessageActionResult> addMsgActionResult = await pubnub.AddMessageAction()
.Channel(channel)
.MessageTimetoken(currentMessageTimetoken)
.Action(new PNMessageAction {
Type = "reaction", Value = "smily_face"
})
.ExecuteAsync();
#endif
if (addMsgActionResult.Result != null && addMsgActionResult.Status.StatusCode == 200 && !addMsgActionResult.Status.Error && addMsgActionResult.Result.MessageTimetoken == currentMessageTimetoken)
{
System.Diagnostics.Debug.WriteLine("AddMessageAction = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(addMsgActionResult.Result));
receivedMessage = true;
currentActionTimetoken = addMsgActionResult.Result.ActionTimetoken;
currentUUID = addMsgActionResult.Result.Uuid;
}
Thread.Sleep(2000);
if (receivedMessage && currentActionTimetoken > 0 && currentMessageTimetoken > 0 && !receivedRemoveEvent)
{
System.Diagnostics.Debug.WriteLine("RemoveMessageAction To Confirm STARTED");
#if NET40
Task.Factory.StartNew(async() => await pubnub.RemoveMessageAction()
.Channel(channel)
.MessageTimetoken(currentMessageTimetoken)
.ActionTimetoken(currentActionTimetoken)
.Uuid(currentUUID)
.ExecuteAsync());
#else
await pubnub.RemoveMessageAction()
.Channel(channel)
.MessageTimetoken(currentMessageTimetoken)
.ActionTimetoken(currentActionTimetoken)
.Uuid(currentUUID)
.ExecuteAsync();
#endif
}
Thread.Sleep(4000);
pubnub.Unsubscribe <string>().Channels(new string[] { channel }).Execute();
pubnub.RemoveListener(eventListener);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedAddEvent && receivedRemoveEvent, "Message Action events Failed");
}
public static void ThenSendFileShouldReturnSuccess()
{
server.ClearRequests();
receivedMessage = false;
bool receivedEvent = false;
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNFileEventResult eventResult)
{
receivedEvent = true;
System.Diagnostics.Debug.WriteLine("FILE EVENT: " + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
//CipherKey = "enigma",
Uuid = "mytestuuid",
Secure = false
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
mre = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { channelName }).Execute();
mre.WaitOne(2000);
string expected = "{\"status\": 200, \"message\": \"OK\", \"service\": \"channel-registry\", \"error\": false}";
mre = new ManualResetEvent(false);
string fileId = "";
string fileName = "";
receivedMessage = false;
string targetFileUpload = @"C:\Pandu\pubnub\word_test.txt";
//string targetFileDownload = @"c:\pandu\temp\pandu_test.gif";
pubnub.SendFile().Channel(channelName).File(targetFileUpload).CipherKey("enigma").Message("This is my sample file")
.Execute(new PNFileUploadResultExt((result, status) =>
{
if (result != null)
{
System.Diagnostics.Debug.WriteLine("SendFile result = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
fileId = result.FileId;
fileName = result.FileName;
receivedMessage = true;
}
else
{
System.Diagnostics.Debug.WriteLine("SendFile failed = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(status));
}
mre.Set();
}));
Thread.Sleep(1000);
mre.WaitOne();
receivedMessage = false;
mre = new ManualResetEvent(false);
pubnub.ListFiles().Channel(channelName)
.Execute(new PNListFilesResultExt((result, status) =>
{
if (result != null)
{
System.Diagnostics.Debug.WriteLine("ListFiles result = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
receivedMessage = true;
}
mre.Set();
}));
Thread.Sleep(1000);
mre.WaitOne();
if (receivedMessage)
{
receivedMessage = false;
mre = new ManualResetEvent(false);
pubnub.DownloadFile().Channel(channelName).FileId(fileId).FileName(fileName).Execute(new PNDownloadFileResultExt((result, status) =>
{
if (result != null && result.FileBytes != null && result.FileBytes.Length > 0)
{
System.Diagnostics.Debug.WriteLine("DownloadFile result = " + result.FileBytes.Length);
receivedMessage = true;
//System.IO.File.WriteAllBytes(targetFileDownload, result.FileBytes);
}
mre.Set();
}));
mre.WaitOne();
}
if (receivedMessage)
{
receivedMessage = false;
mre = new ManualResetEvent(false);
pubnub.DeleteFile().Channel(channelName).FileId(fileId).FileName(fileName)
.Execute(new PNDeleteFileResultExt((result, status) =>
{
if (result != null)
{
System.Diagnostics.Debug.WriteLine("DeleteFile result = " + pubnub.JsonPluggableLibrary.SerializeToJsonString(result));
receivedMessage = true;
}
mre.Set();
}));
Thread.Sleep(1000);
mre.WaitOne();
}
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(receivedMessage && receivedEvent, "WhenFileIsRequested -> TheSendFileShouldReturnSuccess failed.");
}
public static async Task ThenWithAsyncUuidMetadataUpdateDeleteShouldReturnEventInfo()
#endif
{
server.ClearRequests();
if (PubnubCommon.EnableStubTest)
{
Assert.Ignore("Ignored ThenWithAsyncUuidUpdateDeleteShouldReturnEventInfo");
return;
}
bool receivedMessage = false;
bool receivedDeleteEvent = false;
bool receivedUpdateEvent = false;
string uuidMetadataId = "pandu-ut-uid";
manualResetEventWaitTimeout = 310 * 1000;
SubscribeCallbackExt eventListener = new SubscribeCallbackExt(
delegate(Pubnub pnObj, PNObjectEventResult eventResult)
{
System.Diagnostics.Debug.WriteLine("EVENT:" + pubnub.JsonPluggableLibrary.SerializeToJsonString(eventResult));
if (eventResult.Type.ToLowerInvariant() == "uuid")
{
if (eventResult.Event.ToLowerInvariant() == "set")
{
receivedUpdateEvent = true;
}
else if (eventResult.Event.ToLowerInvariant() == "delete")
{
receivedDeleteEvent = true;
}
}
},
delegate(Pubnub pnObj, PNStatus status)
{
}
);
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
Uuid = "mytestuuid",
Secure = false,
AuthKey = "myauth"
};
if (PubnubCommon.PAMServerSideRun)
{
config.SecretKey = PubnubCommon.SecretKey;
}
else if (!string.IsNullOrEmpty(authKey) && !PubnubCommon.SuppressAuthKey)
{
config.AuthKey = authKey;
}
server.RunOnHttps(false);
pubnub = createPubNubInstance(config);
pubnub.AddListener(eventListener);
ManualResetEvent manualEvent = new ManualResetEvent(false);
pubnub.Subscribe <string>().Channels(new string[] { uuidMetadataId }).Execute();
manualEvent.WaitOne(2000);
System.Diagnostics.Debug.WriteLine("pubnub.DeleteUuidMetadata() STARTED");
#if NET40
Task.Factory.StartNew(async() => await pubnub.RemoveUuidMetadata().Uuid(uuidMetadataId).ExecuteAsync());
#else
await pubnub.RemoveUuidMetadata().Uuid(uuidMetadataId).ExecuteAsync();
#endif
#region "SetUuidMetadata"
System.Diagnostics.Debug.WriteLine("pubnub.SetUuidMetadata() STARTED");
#if NET40
PNResult <PNSetUuidMetadataResult> createUserResult = Task.Factory.StartNew(async() => await pubnub.SetUuidMetadata().Uuid(uuidMetadataId).Name("pandu-ut-un").ExecuteAsync()).Result.Result;
#else
PNResult <PNSetUuidMetadataResult> createUserResult = await pubnub.SetUuidMetadata().Uuid(uuidMetadataId).Name("pandu-ut-un").ExecuteAsync();
#endif
if (createUserResult.Result != null && createUserResult.Status.StatusCode == 200 && !createUserResult.Status.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(createUserResult.Result);
if (uuidMetadataId == createUserResult.Result.Uuid)
{
receivedMessage = true;
}
}
#endregion
if (receivedMessage)
{
receivedMessage = false;
#region "SetUuidMetadata"
System.Diagnostics.Debug.WriteLine("pubnub.UpdateUser() STARTED");
#if NET40
PNResult <PNSetUuidMetadataResult> updateUserResult = Task.Factory.StartNew(async() => await pubnub.SetUuidMetadata().Uuid(uuidMetadataId).Name("pandu-ut-un-upd")
.ProfileUrl("pandu-sample-profile-url").ExternalId("pandu-sample-ext-id")
.Email("*****@*****.**")
.Custom(new Dictionary <string, object>()
{
{ "color", "red" }
})
.ExecuteAsync()).Result.Result;
#else
PNResult <PNSetUuidMetadataResult> updateUserResult = await pubnub.SetUuidMetadata().Uuid(uuidMetadataId).Name("pandu-ut-un-upd")
.ProfileUrl("pandu-sample-profile-url").ExternalId("pandu-sample-ext-id")
.Email("*****@*****.**")
.Custom(new Dictionary <string, object>()
{
{ "color", "red" }
})
.ExecuteAsync();
#endif
if (updateUserResult.Result != null && updateUserResult.Status.StatusCode == 200 && !updateUserResult.Status.Error)
{
pubnub.JsonPluggableLibrary.SerializeToJsonString(updateUserResult.Result);
if (uuidMetadataId == updateUserResult.Result.Uuid)
{
receivedMessage = true;
}
}
#endregion
}
if (!receivedDeleteEvent)
{
System.Diagnostics.Debug.WriteLine("pubnub.DeleteUuidMetadata() 2 STARTED");
#if NET40
Task.Factory.StartNew(async() => await pubnub.RemoveUuidMetadata().Uuid(uuidMetadataId).ExecuteAsync());
#else
await pubnub.RemoveUuidMetadata().Uuid(uuidMetadataId).ExecuteAsync();
#endif
}
Thread.Sleep(2000);
pubnub.Unsubscribe <string>().Channels(new string[] { uuidMetadataId }).Execute();
pubnub.RemoveListener(eventListener);
Assert.IsTrue(receivedDeleteEvent && receivedUpdateEvent, "User events Failed");
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
}
}
System.Diagnostics.Debug.WriteLine(" -> Not found error, attempting to reinitialize");
// disconnect
//System.Diagnostics.Debug.WriteLine(" -> -> uninitialize");
//Uninitialize();
// reconnect
System.Diagnostics.Debug.WriteLine(" -> -> reinitialize");
Initialize(_UserId, _AuthKey, false, _PushData);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.Initialize - Exception: {0}", ex));
}
}
if (status.Category == PNStatusCategory.PNConnectedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Connected");
// this is expected for a subscribe, this means there is no error or issue whatsoever
// reset fail count
_FailCount = 0;
}
else if (status.Category == PNStatusCategory.PNReconnectedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Reconnected");
// this usually occurs if subscribe temporarily fails but reconnects. This means
// there was an error but there is no longer any issue
}
else if (status.Category == PNStatusCategory.PNDisconnectedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Disconnected");
// this is the expected category for an unsubscribe. This means there
// was no error in unsubscribing from everything
}
else if (status.Category == PNStatusCategory.PNUnexpectedDisconnectCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Unexpected disconnected");
// this is usually an issue with the internet connection, this is an error, handle appropriately
}
else if (status.Category == PNStatusCategory.PNAccessDeniedCategory)
{
System.Diagnostics.Debug.WriteLine(" -> Access Denied");
// this means that PAM does allow this client to subscribe to this
// channel and channel group configuration. This is another explicit error
}
}
}
#endregion Callbacks
#region Operations
public void GetHistory(long timeStamp)
{
try
{
if (!Initialized || string.IsNullOrEmpty(_UserId)) return;
_Pubnub.History()
.Channel(_UserId)
.Start(timeStamp)
.Count(20)
.Async(new PNHistoryResultExt((result, status) =>
{
if ((result.Messages == null) || (result.Messages.Count == 0)) return;
foreach (var message in result.Messages)
{
// let listeners know
MessageReceived?.Invoke(this, new MessageEventArgs(message.Entry.ToString()));
}
}));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.GetHistory - Exception: {0}", ex));
}
}
public void Publish(string to, string message, object state)
{
try
{
if (!Initialized || string.IsNullOrEmpty(_UserId)) throw new ArgumentException("Cannot publish before initialize.");
// publish message
_Pubnub.Publish()
.Channel(to)
.Message(message)
.Async(new PNPublishResultExt((result, status) =>
{
if (message == null) return;
// get the message
PublishComplete?.Invoke(this, new MessageEventArgs(message)
{
State = state,
Success = !status.Error,
Timestamp = new DateTime(result.Timetoken)
});
}));
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("*** ChatService.Publish - Exception: {0}", ex));
}
}
#endregion Operations
#region Event Triggers
private void RaiseChannelJoined(string channel, string uuid)
{
ChannelJoined?.Invoke(this, new PresenceEventArgs(channel, uuid));
}
private void RaiseChannelLeft(string channel, string uuid)
{
ChannelLeft?.Invoke(this, new PresenceEventArgs(channel, uuid));
}
private void RaiseChannelTimeout(string channel, string uuid)
{
ChannelTimeout?.Invoke(this, new PresenceEventArgs(channel, uuid));
}
private void RaiseChannelState(string channel, string uuid, ChatState state)
{
ChannelState?.Invoke(this, new PresenceEventArgs(channel, uuid, state));
}
#endregion Event Triggers
#region Cleanup
public void Dispose()
{
if (_Disposed) return;
// TODO: check this - it looks dodgy
SubscribeCallbackExt listenerSubscribeCallack = new SubscribeCallbackExt((pubnubObj, message) => { }, (pubnubObj, presence) => { }, (pubnubObj, status) => { });
_Pubnub.AddListener(listenerSubscribeCallack);
// some time later
_Pubnub.RemoveListener(listenerSubscribeCallack);
_Pubnub.Destroy();
_Disposed = true;
}
#endregion Cleanup
}
}
public static void ThenUnencryptSignalListenerShouldGetMessagae()
{
server.ClearRequests();
bool internalReceivedMessage = false;
bool receivedErrorMessage = false;
if (PubnubCommon.EnableStubTest)
{
Assert.Ignore("Ignored ThenUnencryptSignalListenerShouldGetMessagae");
return;
}
PNConfiguration config = new PNConfiguration
{
PublishKey = PubnubCommon.PublishKey,
SubscribeKey = PubnubCommon.SubscribeKey,
SecretKey = PubnubCommon.SecretKey,
Uuid = "mytestuuid",
Secure = false
};
server.RunOnHttps(config.Secure);
ManualResetEvent subscribeManualEvent = new ManualResetEvent(false);
SubscribeCallback listenerSubCallack = new SubscribeCallbackExt(
(o, m) =>
{
Debug.WriteLine(pubnub.JsonPluggableLibrary.SerializeToJsonString(m));
if (m != null)
{
Debug.WriteLine(string.Format("Signal SubscribeCallback: PNMessageResult: {0}", pubnub.JsonPluggableLibrary.SerializeToJsonString(m.Message)));
if (pubnub.JsonPluggableLibrary.SerializeToJsonString(messageForUnencryptSignal) == m.Message.ToString())
{
internalReceivedMessage = true;
}
subscribeManualEvent.Set();
}
},
(o, s) => {
Debug.WriteLine("{0} {1} {2}", s.Operation, s.Category, s.StatusCode);
if (s.StatusCode != 200 || s.Error)
{
receivedErrorMessage = true;
if (s.ErrorData != null)
{
Debug.WriteLine(s.ErrorData.Information);
}
subscribeManualEvent.Set();
}
else if (s.StatusCode == 200 && s.Category == PNStatusCategory.PNConnectedCategory)
{
internalReceivedMessage = true;
subscribeManualEvent.Set();
}
});
pubnub = createPubNubInstance(config);
pubnub.AddListener(listenerSubCallack);
string channel = "hello_my_channel";
manualResetEventWaitTimeout = 310 * 1000;
pubnub.Subscribe <string>().Channels(new[] { channel }).Execute();
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout); //Wait for connect
Thread.Sleep(1000);
if (!receivedErrorMessage)
{
subscribeManualEvent = new ManualResetEvent(false); //Reset to wait for message
internalReceivedMessage = false;
ManualResetEvent signalManualEvent = new ManualResetEvent(false);
pubnub.Signal().Channel(channel).Message(messageForUnencryptSignal)
.Execute(new PNPublishResultExt((r, s) =>
{
if (r != null && s.StatusCode == 200 && !s.Error)
{
internalReceivedMessage = true;
}
signalManualEvent.Set();
}));
signalManualEvent.WaitOne(manualResetEventWaitTimeout);
subscribeManualEvent.WaitOne(manualResetEventWaitTimeout);
pubnub.Unsubscribe <string>().Channels(new[] { channel }).Execute();
Thread.Sleep(1000);
pubnub.RemoveListener(listenerSubCallack);
pubnub.Destroy();
pubnub.PubnubUnitTest = null;
pubnub = null;
if (receivedErrorMessage)
{
internalReceivedMessage = false;
}
Assert.IsTrue(internalReceivedMessage, "WhenSubscribedToAChannel --> ThenUnencryptSignalListenerShouldGetMessagae Failed");
}
}
