SessionContent Creation

In this tutorial, we will cover a SessionContent interface in more detail.

When initializing RUI library, developers need to provide a function that creates an instance of SessionContent interface. That interface is used by the library to create a UI for client sessions.

The is only one method CreateRootView() available in this interface, and it's purpose is to create and return a user interface for the current session:

Go

CreateRootView(session Session) View

A View is a generic user interface element that could be a single UI control, such as TextView, or a complex one that describes multiple pages of the application, like a StackLayout container.

So, the fundamental code for initiating an application with a session content instance could appear as follows:

Go

package main

import (
    "github.com/anoshenko/rui"
)

type appSession struct {
}

// CreateRooView is an entry point for app UI creation
func (app appSession) CreateRootView(session rui.Session) rui.View {

    // Prepare and return a root view of the application

}

// createSessionContent creates an instance of our implementation of rui.SessionContent
func createSessionContent(session rui.Session) rui.SessionContent {
    return new(appSession)
}

// main entry point
func main() {
    // Prepare address to listen on
    const addr = "localhost:8080"

    // Initialize RUI library and wait for incoming connections
    rui.StartApp(addr, createSessionContent, rui.AppParams{
        Title: "Example",
    })
}

The appSession structure may contain any members that form a per-client session data.

To be able to listen for session events appSession can implement additional methods such as:

  • OnStart(session rui.Session) - this method is called after the creation of the session and root UI element, so it appear after the CreateRootView() function call.

  • OnFinish(session rui.Session) - this method is called before closing the session (when the user closes the page in the browser)

  • OnPause(session rui.Session) - method is called when the page in the browser becomes inactive (the user switches to another page or application).

  • OnResume(session rui.Session) - method is called when the page in the browser becomes active. It is also called immediately after OnStart().

  • OnDisconnect(session rui.Session) - method is called if the connection with the client has been lost.

  • OnReconnect(session rui.Session) - method is called after the connection with the client is restored.

All of these methods are optional and described in dedicated interfaces: SessionStartListener, SessionFinishListener, SessionPauseListener, SessionResumeListener, SessionDisconnectListener, and SessionReconnectListener.

The following example shows the use of the optional OnPause() and OnResume() methods to count how many seconds the client session has been active.

Go

package main

import (
    "fmt"
    "time"

    "github.com/anoshenko/rui"
)

// sessionContent implements SessionContent, SessionPauseListener and SessionResumeListener
type sessionContent struct {
    timer      *time.Ticker
    seconds    int
    resumeTime int64
    done       chan bool
}

func (content *sessionContent) CreateRootView(session rui.Session) rui.View {
    return rui.NewTextView(session, rui.Params{
        rui.Text: "0:00",
    })
}

// OnPause called when browser tab become inactive
func (content *sessionContent) OnPause(session rui.Session) {
    content.done <- true
    content.timer.Stop()
}

// OnResume called when browser tab become active
func (content *sessionContent) OnResume(session rui.Session) {
    content.resumeTime = time.Now().Unix()
    content.timer = time.NewTicker(time.Second)
    go content.timerFunc(session)
}

// timerFunc update UI to display client session active time.
// It will stop when browser tab become inactive
func (content *sessionContent) timerFunc(session rui.Session) {
    for {
        select {
        case <-content.done:
            return
        case <-content.timer.C:
            // Increment count and update UI
            content.seconds++
            session.RootView().Set(rui.Text, fmt.Sprintf("%d:%02d", content.seconds/60, content.seconds%60))
        }
    }
}

// createSessionContent create an instance of sessionContent
func createSessionContent(session rui.Session) rui.SessionContent {
    content := new(sessionContent)
    content.done = make(chan bool)
    return content
}

func main() {
    // Initialize RUI library and listen for incoming connections
    rui.StartApp("localhost:8080", createSessionContent, rui.AppParams{
        Title: "Session content example",
    })
}

In the OnResume() method, a timer is created and started which fires every second, increasing the counter by one and updating the counter text in the browser. The OnPause() function will stop the timer when the page becomes inactive. When running this application, try playing with the browser tabs to see the effect.

Session content example output

SessionContent example

In this example, we have only created one root UI element called TextView. To change the text of this element, we can use the session.RootView() method to query it and then update its "text" property using a Set() call.

© Alxanosoft inc.