void pnc_ops_init(pubnub_t *pn, pubnub_t *pn_sub)
{
pubnub_mutex_init(m_loop_enabled_mutex);
InitUserData(&m_user_data, pn);
InitUserData(&m_user_data_sub, pn_sub);
pubnub_register_callback(pn, ops_callback, &m_user_data);
pubnub_register_callback(pn_sub, subscribe_callback, &m_user_data_sub);
}
futres::futres(futres const &x) :
d_pb(x.d_pb), d_ctx(x.d_ctx), d_result(x.d_result), d_pimpl(new impl)
{
if (PNR_OK != pubnub_register_callback(d_pb, futres_callback, d_pimpl)) {
throw std::logic_error("Failed to register callback");
}
}
futres::futres(pubnub_t *pb, context &ctx, pubnub_res initial) :
d_pb(pb), d_ctx(ctx), d_result(initial), d_pimpl(new impl)
{
if (PNR_OK != pubnub_register_callback(d_pb, futres_callback, d_pimpl)) {
throw std::logic_error("Failed to register callback");
}
}
void pubnub_subloop_stop(pubnub_subloop_t* pbsld)
{
PUBNUB_ASSERT_OPT(NULL != pbsld);
pubnub_mutex_lock(pbsld->monitor);
PUBNUB_ASSERT_OPT(NULL != pbsld->pbp);
pubnub_register_callback(
pbsld->pbp, pbsld->saved_context_cb, pbsld->saved_context_user_data);
pubnub_cancel(pbsld->pbp);
pbsld->saved_context_cb = NULL;
pbsld->saved_context_user_data = NULL;
pubnub_mutex_unlock(pbsld->monitor);
}
void pubnub_subloop_undef(pubnub_subloop_t* pbsld)
{
PUBNUB_ASSERT_OPT(NULL != pbsld);
pubnub_mutex_lock(pbsld->monitor);
if (sublup_context_callback == pubnub_get_callback(pbsld->pbp)) {
pubnub_register_callback(
pbsld->pbp, pbsld->saved_context_cb, pbsld->saved_context_user_data);
pubnub_cancel(pbsld->pbp);
}
pbsld->pbp = NULL;
pubnub_mutex_unlock(pbsld->monitor);
pubnub_mutex_destroy(pbsld->monitor);
free(pbsld);
}
enum pubnub_res pubnub_subloop_start(pubnub_subloop_t* pbsld)
{
enum pubnub_res rslt;
pubnub_callback_t saved_ctx_cb;
void* saved_ctx_data;
PUBNUB_ASSERT_OPT(NULL != pbsld);
pubnub_mutex_lock(pbsld->monitor);
PUBNUB_ASSERT_OPT(NULL != pbsld->pbp);
saved_ctx_cb = pubnub_get_callback(pbsld->pbp);
saved_ctx_data = pubnub_get_user_data(pbsld->pbp);
rslt = pubnub_register_callback(pbsld->pbp, sublup_context_callback, pbsld);
if (PNR_OK == rslt) {
pbsld->saved_context_cb = saved_ctx_cb;
pbsld->saved_context_user_data = saved_ctx_data;
rslt = pubnub_subscribe_ex(pbsld->pbp, pbsld->channel, pbsld->options);
}
pubnub_mutex_unlock(pbsld->monitor);
return rslt;
}
int main()
{
char const *msg;
enum pubnub_res res;
struct UserData user_data;
struct UserData user_data_2;
char const *chan = "hello_world";
pubnub_t *pbp = pubnub_alloc();
pubnub_t *pbp_2 = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
if (NULL == pbp_2) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
InitUserData(&user_data, pbp);
InitUserData(&user_data_2, pbp_2);
pubnub_init(pbp, "demo", "demo");
pubnub_register_callback(pbp, sample_callback, &user_data);
pubnub_init(pbp_2, "demo", "demo");
pubnub_register_callback(pbp_2, sample_callback, &user_data_2);
puts("-----------------------");
puts("Subscribing...");
puts("-----------------------");
/* First subscribe, to get the time token */
res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
pubnub_free(pbp);
pubnub_free(pbp_2);
return -1;
}
puts("Await subscribe");
res = await(&user_data);
if (res == PNR_STARTED) {
printf("await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
pubnub_free(pbp_2);
return -1;
}
if (PNR_OK == res) {
puts("Subscribed!");
}
else {
printf("Subscribing failed with code: %d\n", res);
}
/* The "real" subscribe, with the just acquired time token */
res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
pubnub_free(pbp);
pubnub_free(pbp_2);
return -1;
}
/* Don't do "full" await here, because we didn't publish anything yet! */
start_await(&user_data);
puts("-----------------------");
puts("Publishing...");
puts("-----------------------");
/* Since the subscribe is ongoing in the `pbp` context, we can't
publish on it, so we use a different context to publish
*/
res = pubnub_publish(pbp_2, chan, "\"Hello world from subscribe-publish callback sample!\"");
if (res != PNR_STARTED) {
printf("pubnub_publish() returned unexpected: %d\n", res);
pubnub_free(pbp);
pubnub_free(pbp_2);
return -1;
}
puts("Await publish");
res = await(&user_data_2);
if (res == PNR_STARTED) {
printf("await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
pubnub_free(pbp_2);
return -1;
}
if (PNR_OK == res) {
printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp_2));
}
else if (PNR_PUBLISH_FAILED == res) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp_2));
}
else {
printf("Publishing failed with code: %d\n", res);
}
/* Don't need `pbp_2` no more */
if (pubnub_free(pbp_2) != 0) {
printf("Failed to free the Pubnub context `pbp_2`\n");
}
/* Now we await the subscribe on `pbp` */
puts("Await subscribe");
res = end_await(&user_data);
if (res == PNR_STARTED) {
printf("await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Subscribed! Got messages:");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Subscribing failed with code: %d\n", res);
}
/* We're done */
if (pubnub_free(pbp) != 0) {
printf("Failed to free the Pubnub context `pbp`\n");
}
puts("Pubnub subscribe-publish callback demo over.");
return 0;
}