PubNub Swift SDK 8.2.2

This page outlines the steps to follow to create a simple Hello, World application with PubNub. This covers the basics of integrating PubNub in your application: setting up a connection to PubNub, and sending and receiving messages.

  1. PubNub account
  2. Download the SDK
  3. Send messages

PubNub account​

Sign in or create an account to create an app on the Admin Portal and get the keys to use in your application.

When you create a new app, the first set of keys is generated automatically, but a single app can have as many keysets as you like. We recommend that you create separate keysets for production and test environments.

Download the SDK​

Download the SDK from any of the following sources:

Use Swift Package Manager​

To integrate PubNub into your project using the Swift Package Manager, specify PubNub in the dependencies list of your Package.swift file:

dependencies: [
  .package(url: "https://github.com/pubnub/swift.git", from: "8.2.2")
]

Use CocoaPods​

To integrate PubNub into your project using CocoaPods:

  1. Install the latest cocoapods gem by running the gem install cocoapods command. If you already have this gem, make sure to update to the latest version by running the gem update cocoapods command.

  2. Add PubNub to your Podfile:

    pod 'PubNubSwift', '~> 8.2.2'

Use Carthage​

To build PubNub as a standalone bundle using Carthage and integrate it into your project:

  1. Install the latest release of Carthage, and either create a new file or open an existing Cartfile.

  2. Add a new line in the Cartfile to build the PubNub framework bundle:

    github "pubnub/swift" ~> 8.2.2

  3. Update and rebuild your project's dependencies.

Get the source code​

To integrate PubNub into your Xcode project using Embedded Framework do the following:

  1. In your top-level project directory add PubNub as a submodule:

    git submodule add https://github.com/pubnub/swift.git

  2. Open your app's Xcode project.

  3. In Finder, locate the PubNub.xcodeproj Xcode project inside the submodule directory, and drag it onto your app's project in the Project Navigator.

    This nests a reference to the framework project in the app project.

  4. Select your applications's project in the Project Navigator (blue project icon), navigate to the target configuration window, and select the application target under the "Targets" heading in the sidebar.

  5. Select your application project in the Project Navigator, and then select your application's Target under the TARGETS panel.

  6. Select the General tab in the top middle of the window, and then click + inside the EMBEDDED BINARIES section.

  7. Select PubNub.framework nested inside the top-most PubNub.xcodeproj/Products/ directory.

For more information, refer to Apple's guide on Adding Package Dependencies to Your App.

Configure PubNub​

You will use the workspace you generated with Swift Package Manager in this procedure.

  1. Create a new Xcode project as a Single View App, using a Storyboard user interface.

  2. Navigate to File > Swift Packages > Add Package Dependency.

  3. Search for PubNub and select the swift package owned by pubnub, and click Next.

  4. Use the Up to Next Major Version rule spanning from 8.0.0 < 9.0.0, and click Next.

  5. Import the module named PubNub inside your AppDelegate:

    import UIKit
    import PubNubSDK // <- Here is our PubNub module import.

  6. Create a PubNub object and pass it to your root view controller.

    This is the minimum configuration you need to send and receive messages with PubNub. Make sure to replace myPublishKey and mySubscribeKey with your app's publish and subscribe keys from the PubNub Dashboard.

    import UIKit
    import PubNubSDK

    @UIApplicationMain
    class AppDelegate: UIResponder, UIApplicationDelegate {
      var pubnub: PubNub!
      var window: UIWindow?
      
      func application(
        _ application: UIApplication,
        willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
      ) -> Bool {
        PubNub.log.levels = [.all]
        PubNub.log.writers = [ConsoleLogWriter(), FileLogWriter()]
    show all 47 lines

    For more information, refer to the Configuration section of the SDK documentation.

  7. If using multiple Scenes, use the SceneDelegate to pass your PubNub instance to your view controllers:

    import UIKit
    import PubNubSDK

    @available(iOS 13.0, *)
    class SceneDelegate: UIResponder, UIWindowSceneDelegate {
      var window: UIWindow?
      var pubnub: PubNub?
      
      func scene(
        _ scene: UIScene,
        willConnectTo session: UISceneSession,
        options connectionOptions: UIScene.ConnectionOptions
      ) {
        guard 
          let windowScene = scene as? UIWindowScene,
    show all 32 lines

Add listeners, subscribe, and publish​

Listeners help your app react to events and messages. You can implement custom app logic to respond to each type of message or event received. To receive messages sent to a particular channel, you subscribe to it. When you publish a message to a channel, PubNub delivers that message to everyone who subscribes.

In this app, publishing a message is triggered when the status listener connects to a channel.

Understanding the ViewController​

The ViewController is a critical component of your Swift application. It manages a portion of your app's user interface and is responsible for handling interactions between the user and the app. In our context, it integrates PubNub's real-time messaging capabilities.

The rootViewController acts as the main entry point for interacting with this component. It is set within the app's window and is responsible for displaying the app's interface to the user. By initializing ViewController as the rootViewController, we ensure that it is the focal point for handling PubNub subscriptions and events.

Setting up the rootViewController​

The setup involves assigning the ViewController to the window's rootViewController. This process provides the main view of your app, allowing the controller to manage UI updates and data interactions effectively.

Subscribing to Real-Time Updates​

To subscribe to real-time updates, you must create a subscription or a subscription set and send a subscribe() call.

It is best to define the subscription before you introduce the listeners and then send the subscribe() call, so place the relevant code in the appropriate places within your app.

Copy the code below to configure your app such that when it successfully connects to a channel, it calls the publish() function. The following code also subscribes to the channel awesomeChannel and prints out the message when it is received.

Set up your root ViewController:

class ViewController: UIViewController {
  private let pubnub = PubNub(
    configuration: PubNubConfiguration(
      publishKey: "myPublishKey",
      subscribeKey: "mySubscribeKey",
      userId: "userId"
    )
  )
  private lazy var subscription = pubnub.channel(channel).subscription(
    options: ReceivePresenceEvents()
  )
  private let channel = "awesomeChannel"

  override func viewDidLoad() {
    super.viewDidLoad()
show all 35 lines

For more information, refer to the Listeners, Publish and Subscribe, and Message Publish sections of the documentation.

Now, run your app to see if you did everything correctly. You should see "Hello world" printed in the console.

Congratulations! You've just subscribed to a channel and sent your first message.

Walkthrough​

Instead of focusing on the order in which you wrote the code, let's focus on the order in which it runs. The app you just created does a few things:

  • configures a PubNub connection
  • creates a subscription
  • adds the status and message event listeners
  • subscribes to a channel
  • publishes a message

Configuring PubNub​

The following code is the minimum configuration you need to send and receive messages with PubNub. For more information, refer to the Configuration section of the SDK documentation.

let pubnub = PubNub(
  configuration: PubNubConfiguration(
    publishKey: "myPublishKey",
    subscribeKey: "mySubscribeKey",
    userId: "userId"
  )
)

Add event listeners​

Listeners help your app react to events and messages. You can implement custom app logic to respond to each type of message or event.

You added two listeners to the app: message and status. The message listener listens for incoming messages on a particular channel. When it receives a message, the app displays the message.

You can register the same listener for different subscriptions. Even though they listen for the same event, they can behave entirely differently. This is why you see "Hello, PubNub Swift!"

The status listener triggers the publishing of the message.

subscription.onMessage = { message in
  print("Message Received: \(message)")
}
pubnub.onConnectionStateChange = { [weak self] newStatus in
  guard let self = self else {
    return
  }
  if newStatus == .connected {
    self.pubnub.publish(
      channel: self.channel,
      message: "Hello, PubNub Swift!"
    ) { result in
      print(result.map { "Publish Response at \($0.timetokenDate)" })
    }
  }
show all 16 lines

For more information, refer to the Listeners section of the SDK documentation.

Publishing and subscribing​

PubNub uses the Publish/Subscribe model for real-time communication. This model involves two essential parts:

  • Channels are transient paths over which your data is transmitted
  • Messages contain the data you want to transmit to one or more recipients

When you want to receive messages sent to a particular channel, you subscribe to it. When you publish a message to a channel, PubNub delivers that message to everyone who is subscribed to that channel. In this example, you subscribe to a channel named awesomeChannel.

A message can be any JSON-serializable data (such as objects, arrays, integers, strings) smaller than 32 KiB. PubNub will, in most cases, deliver your message to its intended recipients in fewer than 100 ms, regardless of their location. You can also share files up to 5MB.

When your app successfully connects to a channel, it calls the publish() method, which sends the message.

pubnub.onConnectionStateChange = { [weak self] newStatus in
  guard let self = self else {
    return
  }
  if newStatus == .connected {
    self.pubnub.publish(
      channel: self.channel,
      message: "Hello, PubNub Swift!"
    ) { result in
      print(result.map { "Publish Response at \($0.timetokenDate)" })
    }
  }
}

You can subscribe to more than one channel with a single subscribe call, but in this example, you subscribe to a single channel. To subscribe to real-time updates, you must create a subscription or a subscription set and send a subscribe() call.

It is best to define the subscription before you introduce the listeners and then send the subscribe() call, so place the relevant code in the appropriate places within your app.

private let channel = "awesomeChannel"

private lazy var subscription = pubnub.channel(channel).subscription(
  options: ReceivePresenceEvents()
)

For more information, refer to the Publish and Subscribe and Message Publish sections of the documentation.

Next steps​

You have just learned how to use the Swift SDK to send and receive messages using PubNub. Next, take a look at the SDK's reference documentation, which covers PubNub API in more detail.

Last updated on
Related Resources
On this page