CodenameOne Publish/Subscribe Tutorial

Publish and Subscribe Overview

PubNub utilizes a Publish/Subscribe model for real-time data streaming and device signaling which lets you establish and maintain persistent socket connections to any device and push data to global audiences in less than ¼ of a second.

The atomic components that make up a data stream are API Keys, Messages, and Channels.

API KEYS

To build an application that leverages the PubNub Network for Data Streams with Publish and Subscribe, you will need PubNub API Keys which we provide when you Sign-Up.

You will need at the minimum a subscribe_key and publish_key. If a client will only subscribe, and not publish, then the client only need to initialize with the subscribe_key. For clients who will be publishing only, or publishing and subscribing (a client can both publish and subscribe), it will need to initialize with both the subscribe_key and the publish_key.

You only need to supply the publish_key to clients that will publish (send) data to your application over the PubNub network. A read-only client for example would not need to initialize with this key.

Although a secret_key is also provided to you along with your publish and subscribe keys in the admin portal, it is not required for plain-old publish and subscribe. You'll only need the secret_key if you are using PAM functionality, which we discuss more in the PAM Feature Tutorial.

MESSAGES OVERVIEW

A message consists of a channel, and its associated data payload. A publishing client publishes messages to a given channel, and a subscribing client receives only the messages associated with the channels its subscribed to.

PubNub Message payloads can contain any JSON data including Booleans, Strings, Numbers, Arrays, and Objects. Simply publish the native type per your platform, and the clients will JSON serialize the data for you. Subscribers will automatically deserialize the JSON for you into your platform's associated native type.

MESSAGE DESIGN CONSIDERATIONS

When creating a message, keep these limits in mind:

Maximum message size is 32KB
The message size includes the channel name
The message size is calculated after all URL encoding and JSON serialization has occured. Depending on your data, this could add > 4X the original message size.

Keeping your messages < 1.5KB in size will allow them to fit into a single TCP packet!

For further details please check: https://support.pubnub.com/support/discussions/topics/14000006322

CHANNEL DESIGN PATTERNS: UNICAST VS MULTICAST

Channels are created on-the-fly, and do not incur any additional charges to use one or many in your application. When you create a PubNub application, all messages will be associated with a channel.

In a unicast (AKA 1:1) design pattern, the channels can be unique for each client in one-to-one communication. For example, user1 subscribes to user1-private, and user2 subscribes to user2-private. Using this pattern, each client listens on a channel which only relevant data to that client is sent. It has the advantage of minimal network usage (each client receives only the data it needs) and minimal processing (no need for filtering unneeded data).

In a multicast (AKA 1:Many) design pattern, a public (AKA system, global, or admin) channel is used for global communications amongst all clients. For example, building off our previous example, while a user can speak to any other user on their private channel, since each client in the application is listening on their private channel AND the public channel, they can receive on either. When receiving a message on the public channel, it may or may not be relevant for that particular receiving client -- to get around this, the client can filter on some sort of key, allowing them to selectively process messages with specific interest to them.

In many cases, based on the use case of your application, the pattern you choose may be unicast, multicast, or a combination. There is no right or wrong pattern to implement, but based on your use case, there may be an optimal, most efficient pattern.

CHANNEL NAME DESIGN CONSIDERATIONS

Since the text length of the channel name is counted as part of the entire message, and as such, as part of the maximum message length, it is best to keep the channel name as short as efficiency and utility allows.

Channel names are UTF-8 compatible. Prohibited chars in a channel name are:

comma: ,
slash: /
backslash: \
period: .
asterisks: *
colon: :

Data Streams Code Samples

Publishing and Subscribing requires only a few simple-to-use APIs:

Include the PubNub library
Pubnub() - instantiate a PubNub instance.
subscribe() - additively subscribe to a specific channel.
publish() - send a message on a specific channel.
unsubscribe() - additively unsubscribe to a specific channel.

Include the PubNub library

Importing the code:

Add new project with java as the root
Set the new project source as java/srcPubnubApi
Add Pubnub-CodeNameOne-3.7.10.cn1lib and libs/*.jar as project libraries

 import com.pubnub.api.*;
 import org.json.*;

Initialize the API

If this PubNub instance will only be subscribing, you only need to pass the subscribe_key to initialize the instance. If this instance will be subscribing and publishing, you must also include the publish_key parameter.

Pubnub pubnub = new Pubnub("demo", "demo");

Publishing and Subscribing to a Channel

The channel the messages will be published over is called my_channel. For this example, we want the same instance to both publish and subscribe. To do this, we'll publish a message to the channel, but only after we're sure we've first successfully subscribed to the channel.

The publish() and subscribe() methods are pretty simple to use. For both publish() and subscribe(), the channel attribute defines the channel in use.

For subscribe() the message callback is where received messages are called-back to:

pubnub.subscribe("my_channel", new Callback() {

      @Override
      public void connectCallback(String channel, Object message) {
          System.out.println("SUBSCRIBE : CONNECT on channel:" + channel
                     + " : " + message.getClass() + " : "
                     + message.toString());
      }

      @Override
      public void disconnectCallback(String channel, Object message) {
          System.out.println("SUBSCRIBE : DISCONNECT on channel:" + channel
                     + " : " + message.getClass() + " : "
                     + message.toString());
      }

      public void reconnectCallback(String channel, Object message) {
          System.out.println("SUBSCRIBE : RECONNECT on channel:" + channel
                     + " : " + message.getClass() + " : "
                     + message.toString());
      }

      @Override
      public void successCallback(String channel, Object message) {
          System.out.println("SUBSCRIBE : " + channel + " : "
                     + message.getClass() + " : " + message.toString());
      }

      @Override
      public void errorCallback(String channel, PubnubError error) {
          System.out.println("SUBSCRIBE : ERROR on channel " + channel
                     + " : " + error.toString());
      }
    }
  );

NOTE: During your application's lifecycle, you can call subscribe() repeatedly to additively subscribe to additional channels.

For publish(), the message attribute contains the data you are sending.

Callback callback = new Callback() {
  public void successCallback(String channel, Object response) {
    System.out.println(response.toString());
  }
  public void errorCallback(String channel, PubnubError error) {
	System.out.println(error.toString());
  }
};
pubnub.publish("my_channel", "Hello from the PubNub Java SDK!" , callback);

The above code demonstrates how to subscribe, and how to publish. But what if your use-case requires that client instance not only subscribes and publishes, but also that its guaranteed to start publishing only AFTER it's successfully subscribed? -- In other words, you want to guarantee it receives all of its own publishes?

The JavaScript Web client SDK, like many of the PubNub SDKs, is asynchronous -- publish() can, and most likely will, fire before the previously executed subscribe() call completes. The result is, for a single-client instance, you would never receive (via subscribing) the message you just published, because the subscribe operation did not complete before the message was published.

To get around this common case, we can take advantage of the optional connect callback in the subscribe method:

pubnub.subscribe("my_channel", new Callback() {
    @Override
    public void connectCallback(String channel, Object message) {
        pubnub.publish("my_channel", "Hello from the PubNub Java SDK", new Callback() {});
    }
});

By following this pattern on a client that both subscribes and publishes when you want to be sure to subscribe to your own publishes, you’ll never miss receiving a message.

Unsubscribing from a Channel

While you are subscribed to a channel, you will continue to receive messages published to that channel. To stop receiving messages on a given channel, you must unsubscribe() from the channel.

pubnub.unsubscribe("my_channel");

Like subscribe(), unsubscribe() can be called multiple times to successively remove different channels from the active subscription list.

Additional Resources for Data Streams with Publish and Subscribe:

Inbound Channel Pattern

Additional Resources

PubNub Publish/Subscribe Tutorial

referance content

SelectCodenameOne Publish/Subscribe Tutorial for Realtime Apps