GoPubNub Go V4 SDK v4.2.7

Get Code:

Get Code: Source

Hello World

Example

import (
    "fmt"

    pubnub "github.com/pubnub/go"
)

func main() {
    config := pubnub.NewConfig()
    config.SubscribeKey = "demo"
    config.PublishKey = "demo"

    pn := pubnub.NewPubNub(config)
    listener := pubnub.NewListener()
    doneConnect := make(chan bool)
    donePublish := make(chan bool)

    msg := map[string]interface{}{
        "msg": "hello",
    }
    go func() {
        for {
            select {
            case status := <-listener.Status:
                switch status.Category {
                case pubnub.PNDisconnectedCategory:
                    // This event happens when radio / connectivity is lost
                case pubnub.PNConnectedCategory:
                    // Connect event. You can do stuff like publish, and know you'll get it.
                    // Or just use the connected event to confirm you are subscribed for
                    // UI / internal notifications, etc
                    doneConnect <- true
                case pubnub.PNReconnectedCategory:
                    // Happens as part of our regular operation. This event happens when
                    // radio / connectivity is lost, then regained.
                }
            case message := <-listener.Message:
                // Handle new message stored in message.message
                if message.Channel != "" {
                    // Message has been received on channel group stored in
                    // message.Channel
                } else {
                    // Message has been received on channel stored in
                    // message.Subscription
                }
                if msg, ok := message.Message.(map[string]interface{}); ok {
                    fmt.Println(msg["msg"])
                }
                /*
                    log the following items with your favorite logger
                        - message.Message
                        - message.Subscription
                        - message.Timetoken
                */

                donePublish <- true
            case <-listener.Presence:
                // handle presence
            }
        }
    }()

    pn.AddListener(listener)

    pn.Subscribe().
       Channels([]string{"hello_world"}).
       Execute()

    <-doneConnect

    response, status, err := pn.Publish().
        Channel("hello_world").Message(msg).Execute()

    if err != nil {
        // Request processing failed.
        // Handle message publish error
    }

    fmt.Println(response, status, err)

    <-donePublish
}

Copy and paste examples

Init

Initializing the client

import (
    pubnub "github.com/pubnub/go"
)

config := pubnub.NewConfig()
config.PublishKey = "my-pub-key"
config.SubscribeKey = "my-sub-key"

pn := pubnub.NewPubNub(config)

Listeners

Adding Listeners

import (
    pubnub "github.com/pubnub/go"
)

listener := pubnub.NewListener()

go func() {
    for {
        select {
        case signal := <-listener.Signal:
            //Channel
            fmt.Println(signal.Channel)
            //Subscription
            fmt.Println(signal.Subscription)
            //Payload
            fmt.Println(signal.Message)
            //Publisher ID
            fmt.Println(signal.Publisher)
            //Timetoken
            fmt.Println(signal.Timetoken)
        case status := <-listener.Status:
            switch status.Category {
            case pubnub.PNDisconnectedCategory:
                // this is the expected category for an unsubscribe. This means there
                // was no error in unsubscribing from everything
            case pubnub.PNConnectedCategory:
                // this is expected for a subscribe, this means there is no error or issue whatsoever
            case pubnub.PNReconnectedCategory:
                // this usually occurs if subscribe temporarily fails but reconnects. This means
                // there was an error but there is no longer any issue
            case pubnub.PNAccessDeniedCategory:
                // this means that PAM does allow this client to subscribe to this
                // channel and channel group configuration. This is another explicit error
            }
        case message := <-listener.Message:
            //Channel
            fmt.Println(message.Channel)
            //Subscription
            fmt.Println(message.Subscription)
            //Payload
            fmt.Println(message.Message)
            //Publisher ID
            fmt.Println(message.Publisher)
            //Timetoken
            fmt.Println(message.Timetoken)
        case presence := <-listener.Presence:
            fmt.Println(presence.Event)
            //Channel
            fmt.Println(presence.Channel)
            //Subscription
            fmt.Println(presence.Subscription)
           //Timetoken
            fmt.Println(presence.Timetoken)
           //Occupancy
            fmt.Println(presence.Occupancy)
        case userEvent := <-listener.UserEvent:
            fmt.Println(fmt.Sprintf("userEvent.Channel: %s", userEvent.Channel))
            fmt.Println(fmt.Sprintf("userEvent.SubscribedChannel: %s", userEvent.SubscribedChannel))
            fmt.Println(fmt.Sprintf("userEvent.Event: %s", userEvent.Event))
            fmt.Println(fmt.Sprintf("userEvent.UserID: %s", userEvent.UserID))
            fmt.Println(fmt.Sprintf("userEvent.Description: %s", userEvent.Description))
            fmt.Println(fmt.Sprintf("userEvent.Timestamp: %s", userEvent.Timestamp))
            fmt.Println(fmt.Sprintf("userEvent.Name: %s", userEvent.Name))
            fmt.Println(fmt.Sprintf("userEvent.ExternalID: %s", userEvent.ExternalID))
            fmt.Println(fmt.Sprintf("userEvent.ProfileURL: %s", userEvent.ProfileURL))
            fmt.Println(fmt.Sprintf("userEvent.Email: %s", userEvent.Email))
            fmt.Println(fmt.Sprintf("userEvent.Created: %s", userEvent.Created))
            fmt.Println(fmt.Sprintf("userEvent.Updated: %s", userEvent.Updated))
            fmt.Println(fmt.Sprintf("userEvent.ETag: %s", userEvent.ETag))
            fmt.Println(fmt.Sprintf("userEvent.Custom: %v", userEvent.Custom))
        case spaceEvent := <-listener.SpaceEvent:
            fmt.Println(fmt.Sprintf("spaceEvent.Channel: %s", spaceEvent.Channel))
            fmt.Println(fmt.Sprintf("spaceEvent.SubscribedChannel: %s", spaceEvent.SubscribedChannel))
            fmt.Println(fmt.Sprintf("spaceEvent.Event: %s", spaceEvent.Event))
            fmt.Println(fmt.Sprintf("spaceEvent.SpaceID: %s", spaceEvent.SpaceID))
            fmt.Println(fmt.Sprintf("spaceEvent.Description: %s", spaceEvent.Description))
            fmt.Println(fmt.Sprintf("spaceEvent.Timestamp: %s", spaceEvent.Timestamp))
            fmt.Println(fmt.Sprintf("spaceEvent.Created: %s", spaceEvent.Created))
            fmt.Println(fmt.Sprintf("spaceEvent.Updated: %s", spaceEvent.Updated))
            fmt.Println(fmt.Sprintf("spaceEvent.ETag: %s", spaceEvent.ETag))
            fmt.Println(fmt.Sprintf("spaceEvent.Custom: %v", spaceEvent.Custom))
        case membershipEvent := <-listener.MembershipEvent:
            fmt.Println(fmt.Sprintf("membershipEvent.Channel: %s", membershipEvent.Channel))
            fmt.Println(fmt.Sprintf("membershipEvent.SubscribedChannel: %s", membershipEvent.SubscribedChannel))
            fmt.Println(fmt.Sprintf("membershipEvent.Event: %s", membershipEvent.Event))
            fmt.Println(fmt.Sprintf("membershipEvent.SpaceID: %s", membershipEvent.SpaceID))
            fmt.Println(fmt.Sprintf("membershipEvent.UserID: %s", membershipEvent.UserID))
            fmt.Println(fmt.Sprintf("membershipEvent.Description: %s", membershipEvent.Description))
            fmt.Println(fmt.Sprintf("membershipEvent.Timestamp: %s", membershipEvent.Timestamp))
            fmt.Println(fmt.Sprintf("membershipEvent.Custom: %v", membershipEvent.Custom))
        } 
    }
}()

Removing Listeners

listener := pubnub.NewListener()

pn.AddListener(listener)

// some time later
pn.RemoveListener(listener)

listeners status events

Time

res, status, err := pn.Time().Execute()

fmt.Println(res, status, err)

Subscribe

Subscribe (listen on) a channel

pn.Subscribe().
    Channels([]string{"my-channel"}). // subscribe to channels
    Execute()

Publish

res, status, err := pn.Publish().
    Channel("ch").
    Message("hey").
    Execute()

// handle publish result
fmt.Println(res, status, err)

Here Now

res, status, err := pn.HereNow().
    Channels([]string{"my-channel-1"}).
    IncludeUUIDs(true).
    Execute()

for _, v := range res.Channels {
    fmt.Println("---")
    fmt.Println("Channel: ", v.ChannelName)
    fmt.Println("Occupancy: ", v.Occupancy)
    fmt.Println("Occupants")

    for _, v := range v.Occupants {
        fmt.Println("UUID: ", v.UUID, ", state: ", v.State)
    }
}

fmt.Println(status, err)

Presence

pn.Subscribe().
    Channels([]string{"my-channel"}).
    WithPresence(true).
    Execute()

History

res, status, err := pn.History().
    Channel("history_channel"). // where to fetch history from
    Count(2). // how many items to fetch
    Execute()

fmt.Println(res, status, err)

Unsubscribe

Stop subscribing (listening) to a channel.

pn.Unsubscribe().
    Channels([]string{"my-channel"}).
    Execute()