Using the SDKs

The client requires authentication in order to establish a connection with Ably. There are three methods that can be used:

1. Basic authentication
2. Token authentication
3. JWT authentication

Usually a client will use either token or JWT authentication, as basic authentication would require exposing the API keys on the client.

Examples of establishing a connection using the three methods are given in the following sections. While the examples shown are for either the Publishing or Subscribing SDK, you can use the same approach for both SDKs.

The following example demonstrates establishing a connection using basic authentication:

KotlinJavaScript
JavaScript

val publisher = Publisher.publishers() // get the Publisher builder in default state
  .connection(ConnectionConfiguration(Authentication.basic(CLIENT_ID, ABLY_API_KEY)))

Copy
Copied!

This method should not be used on a client however, as it exposes the API key.

You can read more about basic authentication in our documentation.

The following example demonstrates establishing a connection using token authentication:

KotlinJavaScript
JavaScript

val publisher = Publisher.publishers() // get the Publisher builder in default state
    .connection(ConnectionConfiguration(Authentication.tokenRequest(CLIENT_ID) { requestParameters ->
        // get TokenRequest from your server
        getTokenRequestFromAuthServer(requestParameters); // customer implements this function
        }))

Copy
Copied!

You can read more about token authentication in our documentation.

The following example demonstrates establishing a connection using JWT authentication:

KotlinJavaScript
JavaScript

val publisher = Publisher.publishers() // get the Publisher builder in default state
  .connection(ConnectionConfiguration(Authentication.jwt(CLIENT_ID) { tokenParameters ->
        // get JWT from your server
        getJWTFromAuthServer(tokenParameters); // customer implements this function
        }))

Copy
Copied!

You can read more about JWT authentication in our documentation.

Common operations you need to carry out on the publisher include:

• Initialize the publisher.
• Start tracking an asset.
• Stop tracking an asset.
• Set the resolution constraints on an asset.

During initialization of the publisher various methods can be called to configure the Builder interface of the Publisher.

The required methods are:

connection

Called to provide Ably connection information, such as API keys, and any other configuration parameters as needed.

map

Called to provide Mapbox configuration, such as API keys, any other configuration parameters as needed.

androidContext

Called to provide the Android runtime context (on Android only).

resolutionPolicy

Sets the policy factory to be used to define the target resolution for publishers created from this builder.

backgroundTrackingNotificationProvider

Sets the notification that will be displayed for the background tracking service. Please note that this notification will be removed when you call the stop method (on Android only).

start

Creates a Publisher and starts publishing. The returned publisher instance does not start in a state whereby it is actively tracking anything. If tracking is required from the outset then the Publisher.track or Publisher.add method must be subsequently called. In order to detect the device’s location ACCESS_COARSE_LOCATION or ACCESS_FINE_LOCATION permission must be granted.

The optional methods are:

profile

Called to set the means of transport being used for the initial state of publishers created from this builder. If not set then the default value is RoutingProfile.DRIVING.

locationSource

Sets the location source to be used instead of the GPS. The location source provides location updates for the Publisher.

logHandler

Sets the log handler (experimental API).

rawLocations

Enables sending of raw location updates. This should only be enabled for diagnostics. In the production environment this should be always disabled. By default this is disabled (experimental API).

sendResolution

Enables sending of calculated resolutions. By default this is enabled.

rawHistoryDataCallback

Specifies a callback that will be called with the filepath of raw history data from the Navigation SDK component. This will be probably removed in the future. Do not use this in the production environment (experimental API).

constantLocationEngineResolution

Enables using a constant location engine resolution. If the resolution is not null then instead of using ResolutionPolicy to calculate a dynamic resolution for the location engine the resolution will be used as the location engine resolution. If the resolution is null then the constant resolution is disabled and the location engine resolution will be calculated by the ResolutionPolicy. By default this is disabled.

vehicleProfile

Set the type of vehicle being used by the publisher user. If not set then the default value is VehicleProfile.CAR.

Other publisher methods of note are:

track

Adds a Trackable object and makes it the actively tracked object, meaning that the state of the active field will be updated to this object, if that wasn’t already the case. If this object was already in this publisher’s tracked set then this method only serves to change the actively tracked object. This method returns a StateFlow that represents the TrackableState of the added Trackable.

add

Adds a Trackable object, but does not make it the actively tracked object, meaning that the state of the active field will not change. If this object was already in this publisher’s tracked set then this method does nothing. This method returns a StateFlow that represents the TrackableState of the added Trackable.

remove

Removes a Trackable object if it is known to this publisher, otherwise does nothing and returns false. If the removed object is the current actively active object then that state will be cleared, meaning that for another object to become the actively tracked delivery then the track method must be subsequently called.

getTrackableState

Returns a trackable state flow representing the TrackableState for an already added Trackable.

stop

Stops this publisher from publishing locations. Once a publisher has been stopped, it cannot be restarted. Please note that calling this method will remove the notification provided by Builder.backgroundTrackingNotificationProvider.

Publisher properties of note:

active

The actively tracked object, being the Trackable object whose destination will be used for location enhancement, if available. This state can be changed by calling the track method.

routingProfile

The active means of transport for this publisher.

locations

The shared flow emitting location values when they become available.

trackables

The shared flow emitting all trackables tracked by the publisher.

locationHistory

The shared flow emitting trip location history when it becomes available.

In the following sections you will learn how to set up some resolution constraints and then start publishing.

The following code example creates some example resolution constraints

KotlinSwift
Select...

// Prepare Resolution Constraints for an asset that will be used in the Resolution Policy
val exampleConstraints = DefaultResolutionConstraints(
    DefaultResolutionSet( // this constructor provides one Resolution for all states
        Resolution(
            accuracy = Accuracy.BALANCED,
            desiredInterval = 1000L,
            minimumDisplacement = 1.0
        )
    ),
    proximityThreshold = DefaultProximity(spatial = 1.0),
    batteryLevelThreshold = 10.0f,
    lowBatteryMultiplier = 2.0f
)

Copy
Copied!

The next step is create a default resolution to be used:

KotlinSwift
Select...

// Prepare the default resolution for the Resolution Policy
val defaultResolution = Resolution(Accuracy.BALANCED,
                                   desiredInterval = 1000L,
                                   minimumDisplacement = 1.0)

Copy
Copied!

Once these are created you can then initialize the publisher with the constraints and default resolution, and start the publisher:

KotlinSwift
Select...

// Initialize and Start the Publisher
val publisher = Publisher.publishers() // get the Publisher builder in default state
  // Required configuration
  .connection(ConnectionConfiguration(Authentication.basic(CLIENT_ID, ABLY_API_KEY))) // provide Ably configuration with credentials
  .map(MapConfiguration(MAPBOX_ACCESS_TOKEN)) // provide Mapbox configuration with credentials
  .androidContext(this) // provide Android runtime context
  .resolutionPolicy(DefaultResolutionPolicyFactory(defaultResolution, this)) // provide either the default resolution policy factory or your custom implementation
  .backgroundTrackingNotificationProvider(
    object : PublisherNotificationProvider {
      override fun getNotification(): Notification {
          // TODO: create the notification for location updates background service
      }
    },
    NOTIFICATION_ID
  )
  // Optional configuration
  .profile(RoutingProfile.DRIVING) // provide mode of transportation for better location enhancements
  .logHandler(object : LogHandler {
      override fun logMessage(level: LogLevel, message: String, throwable: Throwable?) {
        // TODO: log the message to internal or external loggers
      }
    })
  .rawLocations(false) // send raw location updates to subscribers
  .sendResolution(true) // send calculated trackable network resolution to subscribers
  .constantLocationEngineResolution(constantLocationEngineResolution) // provide a constant resolution for the GPS engine
  .vehicleProfile(VehicleProfile.CAR) // provide vehicle type for better location enhancements
  .locationSource(LocationSourceRaw.create(historyData)) // use an alternative location source for GPS locations
  // Create and start the publisher
  .start()

Copy
Copied!

You can start tracking an asset (a Trackable), by calling the track or add method of the publisher. A Trackable is composed of the following:

trackingID

The tracking identifier for the asset.

destination

A Destination object, which is a latitude and longitude.

constraints

A set of resolution constraints.

The track method adds a Trackable object, and makes it the actively tracked object, meaning that the state of the active field will be updated to this object, if that wasn’t already the case. If this object was already in this publisher’s tracked set, then this method only serves to change the actively tracked object. Takes a trackable as a parameter, which is the object to be added to this publisher’s tracked set, if it’s not already there, and which will be made the actively tracked object.

The add method adds a Trackable object, but does not make it the actively tracked object, meaning that the state of the active field will not change. If this object was already in this publisher’s tracked set then this method does nothing. Takes a trackable as a parameter, which is the object to be added to this publisher’s tracked set, if it’s not already there.

Both of these methods return a StateFlow that represents the TrackableState of the added Trackable.

During initialization of the subscriber various methods can be called to configure the Subscriber.

The required methods are:

connection

Called to provide Ably connection information, such as API keys, and any other configuration parameters as needed.

trackingId

Sets the asset to be tracked, using the unique tracking identifier of the asset.

The optional methods are:

resolution

Request a specific resolution of updates to be requested from the remote publisher.

logHandler

Sets the log handler (experimental API).

start

Creates a Subscriber and starts listening for location updates.

The following code example demonstrates initializing and starting the subscriber:

You can subscribe to asset state changes from the publisher, specifying a function that is called when each state change is received. This is shown in the following example:

KotlinJavaScript
JavaScript

// Listen for asset state changes
subscriber.trackableStates
    .onEach { } // provide a function to be called when the asset changes its state
    .launchIn(scope) // coroutines scope on which the statuses are received

Copy
Copied!

The subscriber can always request a different resolution preference by calling the resolutionPreference method, passing in the required Resolution. This is shown in the following example:

Stop receiving updates from the publisher by calling the stop() method:

await subscriber.stop()

Copy
Copied!