Channel 88 Go

Overview

The Channel API creates a persistent connection between your application and Google servers, allowing your application to send messages to JavaScript clients in real time without the use of polling. This is useful for applications designed to update users about new information immediately. Some example use-cases include collaborative applications, multi-player games, or chat rooms. In general, using the Channel API is a better choice than polling in situations where updates can't be predicted or scripted, such as when relaying information between human users or from events not generated systematically.

Javascript client

The user interacts with a JavaScript client built into a webpage. The JavaScript client is primarily responsible for three things:

• Connecting to the channel once it receives the channel’s unique token from the server
• Listening on the channel for updates regarding other clients and making appropriate use of the data (e.g. updating the interface, etc.)
• Sending update messages to the server so they may be passed on to remote clients

The server

The server is responsible for:

• Creating a unique channel for individual JavaScript clients
• Creating and sending a unique token to each JavaScript client so they may connect and listen to their channel
• Receiving update messages from clients via HTTP requests
• Sending update messages to clients via their channels
• Optionally, managing client connection state.

The client ID

The Client ID is responsible for identifying individual JavaScript clients on the server. The server knows what channel on which to send a particular message because of the Client ID.

A Client ID can be anything that makes sense in the design of your application. For example, you can use something like cookie or login information, randomized numerical ID, or a user-selected name.

You may also create Client IDs in whatever way makes sense in your application. For example, you may choose to create the Client ID on the client and pass it to the server in an explicit request for a token, or create it on the server and inject it into the page’s HTML when the server replies to the browser’s request for the page.

Tokens

Tokens are responsible for allowing the JavaScript Client to connect and listen to the channel created for it. The server creates one token for each client using information such as the client’s Client ID and expiration time.

Tokens expire after two hours and should also be treated as secret. See the section for more details.

The channel

A channel is a one-way communication path through which the server sends updates to a specific JavaScript client identified by its Client ID. The server receives updates from clients via HTTP requests, then sends the messages to relevant clients via their channels.

The message

Messages are sent via HTTP requests from one client to the server. Once received, the server passes the message to the designated client via the correct channel identified by the Client ID. Messages are limited to 32K.

Socket

The JavaScript client opens a socket using the token provided by the server. It uses the socket to listen for updates on the channel.

Presence

The server can register to receive a notification when a client connects to or disconnects from a channel.

Life of a typical channel message

These two diagrams illustrate the life of a typical example message sent via Channel API between two different clients using one possible implementation of Channel API.

This diagram shows the creation of a channel on the server. In this example, it shows the JavaScript client explicitly requests a token and sends its Client ID to the server. In contrast, you could choose to design your application to inject the token into the client before the page loads in the browser, or some other implementation if preferred.