int pubnub_send(char *p_data)
{
enum pubnub_res l_response;
char const *l_responseChannel = "parkingdevice-resp";
struct Pubnub_UUID uuid;
struct Pubnub_UUID_String str_uuid;
pubnub_t *l_publish = pubnub_alloc();
if (NULL == l_publish)
{
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(l_publish, pub_key, sub_key);
if (0 != pubnub_generate_uuid_v4_random(&uuid))
{
pubnub_set_uuid(l_publish, "zeka-peka-iz-jendeka");
}
else
{
str_uuid = pubnub_uuid_to_string(&uuid);
pubnub_set_uuid(l_publish, str_uuid.uuid);
printf("Generated UUID: %s\n", str_uuid.uuid);
}
pubnub_set_auth(l_publish, "danaske");
puts("Publishing...");
l_response = pubnub_publish(l_publish, l_responseChannel, p_data);
if(l_response != PNR_STARTED)
{
printf("pubnub_publish() returned unexpected: %d\n", l_response);
pubnub_free(l_publish);
return -1;
}
l_response = pubnub_await(l_publish);
if (l_response == PNR_STARTED)
{
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", l_response);
pubnub_free(l_publish);
return -1;
}
if (PNR_OK == l_response) {
printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(l_publish));
return 0;
}
else if (PNR_PUBLISH_FAILED == l_response) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(l_publish));
}
else {
printf("Publishing failed with code: %d\n", l_response);
}
pubnub_free(l_publish);
return 0;
}
int main()
{
enum pubnub_res pbresult;
pubnub_t *ctx = pubnub_alloc();
if (NULL == ctx) {
puts("Couldn't allocate a Pubnub context");
return -1;
}
char pubkey[] = "pub-c-9e002851-755d-4197-9037-cfe897af871d";
char subkey[] = "sub-c-82c22366-19a3-11e6-9a17-0619f8945a4f";
char chnlname[] = "hello_world";
printf("pubnub info\npubkey %s\nsubkey %s\nchnlname %s\n",pubkey, subkey, chnlname);
fflush(stdout);
pubnub_init(ctx, pubkey, subkey);
pubnub_subscribe(ctx, chnlname, NULL);
pbresult = pubnub_await(ctx);
if (pbresult != PNR_OK) {
printf("Failed to subscribe, error %d\n", pbresult);
pubnub_free(ctx);
return -1;
}
while (1) {
fflush(stdout);
pubnub_subscribe(ctx, chnlname, NULL);
pbresult = pubnub_await(ctx);
if (pbresult != PNR_OK) {
printf("Failed to subscribe, error %d\n", pbresult);
pubnub_free(ctx);
return -1;
}
else {
char const *msg = pubnub_get(ctx);
while (msg != NULL) {
// printf("Got message: %s\n", msg);
put_data_buf(msg);
msg = pubnub_get(ctx);
// printf("Got message2: %s\n", msg);
}
}
}
pubnub_free(ctx);
return 0;
}
static void srand_from_pubnub(char const* pubkey, char const* keysub)
{
pubnub_t* pbp = pubnub_alloc();
if (pbp != NULL) {
pubnub_init(pbp, pubkey, keysub);
srand_from_pubnub_time(pbp);
pubnub_free(pbp);
}
}
int pubnub_publishStatus(char *p_data){
enum pubnub_res res;
char const *chan = "sensorStatus-resp";
pubnub_t *pbp = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(pbp, g_pub_key,g_sub_key);
pubnub_set_transaction_timeout(pbp, PUBNUB_DEFAULT_NON_SUBSCRIBE_TIMEOUT);
/* Leave this commented out to use the default - which is
blocking I/O on most platforms. Uncomment to use non-
blocking I/O.
*/
// pubnub_set_non_blocking_io(pbp);
generate_uuid(pbp);
pubnub_set_auth(pbp, "danaske");
res = pubnub_publish(pbp, chan, p_data);
if (res != PNR_STARTED) {
printf("pubnub_publish() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
//printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp));
}
else if (PNR_PUBLISH_FAILED == res) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp));
}
else {
printf("Publishing failed with code: %d\n", res);
}
return 0;
}
int pubnub_free_with_timeout(pubnub_t* pbp, unsigned millisec)
{
const clock_t t0 = clock();
const clock_t clocks_till_timeout = (millisec * CLOCKS_PER_SEC) / 1000;
PUBNUB_ASSERT_OPT(pbp != NULL);
while (pubnub_free(pbp) != 0) {
const clock_t elapsed = clock() - t0;
if (elapsed > clocks_till_timeout) {
PUBNUB_LOG_ERROR("Failed to free the context in %u milli seconds\n", millisec);
return -1;
}
}
PUBNUB_LOG_TRACE("Freed the context in %lf seconds\n", ((float)clock() - t0) / CLOCKS_PER_SEC);
return 0;
}
int main()
{
char const *msg;
enum pubnub_res res;
char const *chan = "hello_world";
pubnub_t *pbp = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(pbp, "demo", "demo");
pubnub_set_transaction_timeout(pbp, PUBNUB_DEFAULT_NON_SUBSCRIBE_TIMEOUT);
/* Leave this commented out to use the default - which is
blocking I/O on most platforms. Uncomment to use non-
blocking I/O.
*/
// pubnub_set_non_blocking_io(pbp);
generate_uuid(pbp);
pubnub_set_auth(pbp, "danaske");
puts("Publishing...");
res = pubnub_publish(pbp, chan, "\"Hello world from sync!\"");
if (res != PNR_STARTED) {
printf("pubnub_publish() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp));
}
else if (PNR_PUBLISH_FAILED == res) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp));
}
else {
printf("Publishing failed with code: %d\n", res);
}
puts("Subscribing...");
res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Subscribed!");
}
else {
printf("Subscribing failed with code: %d\n", res);
}
res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_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);
}
puts("Getting time...");
res = pubnub_time(pbp);
if (res != PNR_STARTED) {
printf("pubnub_time() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
printf("Gotten time: %s; last time token=%s\n", pubnub_get(pbp), pubnub_last_time_token(pbp));
}
else {
printf("Getting time failed with code: %d\n", res);
}
puts("Getting history with include_token...");
res = pubnub_history(pbp, chan, 10, true);
if (res != PNR_STARTED) {
printf("pubnub_history() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got history! Elements:");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting history v2 with include_token failed with code: %d\n", res);
}
puts("Getting here_now presence...");
res = pubnub_here_now(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_here_now() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got here now presence!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting here-now presence failed with code: %d\n", res);
}
/** Global here_now presence for "demo" subscribe key is _very_
long, but we have it here to show that we can handle very long
response if the PUBNUB_DYNAMIC_REPLY_BUFFER is "on".
*/
if (PUBNUB_DYNAMIC_REPLY_BUFFER) {
puts("Getting global here_now presence...");
res = pubnub_global_here_now(pbp);
if (res != PNR_STARTED) {
printf("pubnub_global_here_now() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got global here now presence!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting global here-now presence failed with code: %d\n", res);
}
}
puts("Getting where_now presence...");
res = pubnub_where_now(pbp, pubnub_uuid_get(pbp));
if (res != PNR_STARTED) {
printf("pubnub_where_now() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got where now presence!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting where-now presence failed with code: %d\n", res);
}
puts("Setting state...");
res = pubnub_set_state(pbp, chan, NULL, pubnub_uuid_get(pbp), "{\"x\":5}");
if (res != PNR_STARTED) {
printf("pubnub_set_state() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got set state response!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Setting state failed with code: %d\n", res);
}
puts("Getting state...");
res = pubnub_state_get(pbp, chan, NULL, pubnub_uuid_get(pbp));
if (res != PNR_STARTED) {
printf("pubnub_state_get() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got state!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting state failed with code: %d\n", res);
}
puts("List channel group...");
res = pubnub_list_channel_group(pbp, "channel-group");
if (res != PNR_STARTED) {
printf("pubnub_state_get() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got channel group list!");
for (;;) {
msg = pubnub_get_channel(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting channel group list failed with code: %d ('%s')\n", res, pubnub_res_2_string(res));
}
/* We're done */
if (pubnub_free(pbp) != 0) {
printf("Failed to free the Pubnub context\n");
}
puts("Pubnub sync demo over.");
return 0;
}
int main()
{
int option;
char opt_string[4];
char channel[PNC_CHANNEL_NAME_SIZE];
char channel_group[PNC_CHANNEL_NAME_SIZE];
char auth_key[PNC_AUTH_KEY_SIZE];
char uuid[PNC_UUID_SIZE + 1];
char state[2048];
pubnub_t *pn = pubnub_alloc();
pubnub_t *pn_sub = pubnub_alloc();
if (NULL == pn || NULL == pn_sub) {
printf("Failed to allocate pubnub context");
return -1;
}
pubnub_init(pn, pubkey, pubkey);
pubnub_init(pn_sub, pubkey, pubkey);
pubnub_set_uuid(pn, PNC_DEFAULT_UUID);
pubnub_set_uuid(pn, PNC_DEFAULT_SUBSCRIBE_UUID);
pnc_ops_init(pn, pn_sub);
displayMenuOptions(pn);
option = 0;
while (option != MENU_EXIT) {
fgets(opt_string, sizeof(opt_string), stdin);
opt_string[strlen(opt_string) - 1] = '\0';
option = atoi(opt_string);
printf("You entered %d(%s)\n", option, opt_string);
switch (option) {
case MENU_DISPLAY:
break;
case MENU_PUBLISH:
{
char message[PNC_READ_STRING_SIZE];
bool store = false;
// TODO: add json built string
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_read_bool_from_console_optional("Store", &store, true);
puts("Enter the message for publish. To exit loop enter Q");
while (fgets(message, PNC_READ_STRING_SIZE, stdin) != NULL && strcmp(message, "Q\n")) {
if (strlen(message) == 1) {
puts("Invalid input");
continue;
}
message[strlen(message) - 1] = '\0';
if (message[0] == '{' && message[strlen(message) - 1] == '}') {
pnc_ops_parse_response("pubnub_publish()",
pubnub_publish(pn, channel, message), pn);
}
else {
char encoded[PNC_READ_STRING_SIZE];
snprintf(encoded, sizeof encoded, "\"%s\"", message);
pnc_ops_parse_response("pubnub_publish()",
pubnub_publish(pn, channel, encoded), pn);
}
puts("Enter the message for publish. To exit loop enter Q.");
}
break;
}
case MENU_HISTORY:
{
int count = 100;
bool include_token = false;
pnc_read_int_from_console_optional("Count", &count, true);
if (count <= 0) {
count = 100;
puts("Count value cannot be less than 1. Default value(100) was applied.");
}
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
// WARNING: Default buffer can be not big enough to get 100-items
// history response with timetokens
pnc_read_bool_from_console("Include timetokens", &include_token);
pnc_ops_parse_response("pubnub_history()",
pubnub_history(pn, channel, count, include_token), pn);
break;
}
case MENU_HERE_NOW:
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_here_now()",
pubnub_here_now(pn, channel, NULL), pn);
break;
case MENU_TIME:
pnc_ops_parse_response("pubnub_time()", pubnub_time(pn), pn);
break;
case MENU_AUTH:
pnc_read_string_from_console("Auth key", auth_key, PNC_AUTH_KEY_SIZE);
pubnub_set_auth(pn, auth_key);
break;
case MENU_UUID:
pnc_read_string_from_console("UUID", uuid, PNC_UUID_SIZE);
pubnub_set_uuid(pn, uuid);
break;
case MENU_STATE_GET:
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console_optional("UUID",
uuid, PNC_UUID_SIZE, true);
if (strlen(uuid) == 0) {
strcpy(uuid, pubnub_uuid_get(pn));
}
pnc_ops_parse_response("pubnub_get_state()",
pubnub_state_get(pn, channel, NULL, uuid), pn);
break;
case MENU_SET_STATE:
// Set State
pnc_read_string_from_console("Channel Name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console("JSON state without escaping",
state, PNC_READ_STRING_SIZE);
pnc_ops_parse_response("pubnub_set_state()",
pubnub_set_state(pn, channel, NULL, pubnub_uuid_get(pn), state), pn);
break;
case MENU_WHERE_NOW:
pnc_read_string_from_console_optional("UUID", uuid, PNC_UUID_SIZE, true);
if (strlen(uuid) == 0) {
puts("Using current UUID");
strcpy(uuid, PNC_DEFAULT_UUID);
}
pnc_ops_parse_response("pubnub_where_now()",
pubnub_where_now(pn, uuid), pn);
break;
case MENU_ADD_PRESENCE_CHANNEL:
{
char presence_channel[PNC_CHANNEL_NAME_SIZE + sizeof(PNC_PRESENCE_SUFFIX)];
pnc_read_string_from_console("Channel name", channel, PNC_CHANNEL_NAME_SIZE);
strcpy(presence_channel, channel);
strcat(presence_channel, PNC_PRESENCE_SUFFIX);
pnc_subscribe_add_channel(presence_channel);
break;
}
case MENU_SUBSCRIBE:
pnc_ops_subscribe(pn_sub);
break;
case MENU_UNSUBSCRIBE:
pnc_ops_unsubscribe(pn_sub);
break;
case MENU_SUBSCRIPTION_ADD_CHANNEL:
pnc_read_string_from_console("Enter Channel name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_add_channel(channel);
break;
case MENU_SUBSCRIPTION_ADD_GROUP:
pnc_read_string_from_console("Enter Group name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_add_channel_group(channel);
break;
case MENU_SUBSCRIPTION_REMOVE_CHANNEL:
pnc_read_string_from_console("Enter Channel name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_remove_channel(channel);
break;
case MENU_SUBSCRIPTION_REMOVE_GROUP:
pnc_read_string_from_console("Enter Group name",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_subscribe_remove_channel_group(channel);
break;
case MENU_GROUP_ADD_CHANNEL:
pnc_read_string_from_console("Group name",
channel_group, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console("Channel to add",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_add_channel_to_group()",
pubnub_add_channel_to_group(pn, channel, channel_group), pn);
break;
case MENU_GROUP_REMOVE_CHANNEL:
pnc_read_string_from_console("Group name",
channel_group, PNC_CHANNEL_NAME_SIZE);
pnc_read_string_from_console("Channel to remove",
channel, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_remove_channel_from_group()",
pubnub_remove_channel_from_group(pn, channel, channel_group), pn);
break;
case MENU_GROUP_LIST_CHANNELS:
pnc_read_string_from_console("Group to list",
channel_group, PNC_CHANNEL_NAME_SIZE);
pnc_ops_parse_response("pubnub_list_channel_group()",
pubnub_list_channel_group(pn, channel_group), pn);
break;
case MENU_GROUP_REMOVE_GROUP:
pnc_read_string_from_console("Group to remove",
channel, PNC_CHANNEL_NAME_SIZE);
pubnub_remove_channel_group(pn, channel);
break;
default:
printf("Invalid input: %d\n", option);
break;
}
printf("\n================================\n\n");
displayMenuOptions(pn);
}
puts("Exiting");
if (pubnub_free(pn) != 0) {
puts("Failed to free the Pubnub context");
}
return 0;
}
int main()
{
/* This is a widely use channel, something should happen there
from time to time
*/
char const *chan = "hello_world";
pubnub_t *pbp = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(pbp, "demo", "demo");
srand(time(NULL));
/* This is essential, as otherwise waiting for incoming data will
block! Since we're doing this, be sure to not enable verbose
debugging, as you won't see a thing except endless lines of
some tracing.
*/
pubnub_set_non_blocking_io(pbp);
puts("--------------------------");
puts("Subscribe loop starting...");
puts("--------------------------");
for (;;) {
time_t t = time(NULL);
bool stop = false;
enum pubnub_res res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
break;;
}
/* Don't await here, 'cause it will loop until done */
while (!stop) {
res = pubnub_last_result(pbp);
if (res == PNR_STARTED) {
/* Here we simulate the "get out of subscribe loop"
external signal with a random number. Basically,
this has a 4% chance of stopping the wait every
second.
*/
if (time(NULL) != t) {
stop = (rand() % 25) == 3;
t = time(NULL);
}
}
else {
if (PNR_OK == res) {
puts("Subscribed! Got messages:");
for (;;) {
char const *msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Subscribing failed with code: %d\n", res);
}
break;
}
}
if (stop) {
puts("---------------------------");
puts("Cancelling the Subscribe...");
puts("---------------------------");
pubnub_cancel(pbp);
/* Now it's OK to await, since we don't have anything else
to do
*/
pubnub_await(pbp);
break;
}
}
/* We're done */
if (pubnub_free(pbp) != 0) {
printf("Failed to free the Pubnub context `pbp`\n");
}
puts("Pubnub callback demo over.");
return 0;
}
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;
}
