An Introduction to the New TomTom Navigation SDK

TomTom’s Navigation SDK bring decades of experience in perfecting GPS navigation into our hands. This article explores how the Navigation SDK’s modularity makes it easy to add features like map visualization and location handling into our applications.

TomTom provides a wide range of geotechnology solutions developers can leverage in building software that solves human problems. One such solution is the new Navigation SDK, aimed at bringing decades of experience in perfecting GPS navigation into our hands in the form of easy-to-use SDKs available on different platforms, including Android and iOS operating systems.

TomTom’s Navigation SDK is a powerful and feature-rich tool provided as a set of lightweight modules that allows us to quickly integrate the parts we need into our applications. What this means is that we can readily add features like map visualization, location handling, and driver guidance into our applications without hassle. In this article, we’ll explore the Navigation SDK, its core features, and the advantages of its modular design.

TomTom Navigation SDK

Navigation is an integral part of the everyday lives of people all over the world. There are countless use cases where we need some form of geotechnology to aid navigation.

Imagine we’re building a food delivery app that connects drivers, restaurants, and customers. This app's core would be an effective navigation system with driver guidance. This is because there are restaurants and customers scattered all over the city, and the drivers are required to deliver orders to the correct location as quickly as possible.

It would be impossible to meet market demands if the drivers weren’t equipped with an effective navigation system. This is an example of how much value we can get from integrating the Navigation SDK.

The Navigation SDK enables us to build professional navigation applications that are tailored to the end users, which means that we can build navigation features into a wide variety of applications targeting different domains. For example, the navigation system in a food delivery app requires turn-by-turn navigation and voice instructions. If we’re integrating navigation into a ride sharing app, we’ll also need real-time traffic information and accurate ETAs.

Modularization

One of the major considerations for developers when integrating external services or adding packages to our applications is the impact of bundle size. The size of the applications we build and ship can have significant effects on performance especially for mobile applications where an end user has to download the whole pre-built binaries.

TomTom’s Navigation SDK is made of a set of modular components that are independent of each other. This means that we can pick specific components to bring into our applications depending on business and logical requirements, resulting in much less performance cost due to bundle size.

The modularization of the SDK also gives us the ability to either replace components with implementations from different sources or integrate specific components into existing implementations.

Let’s consider a scenario where we already have a navigation system baked into our application, but we just want to integrate the voice instructions feature. We can do that by adding the TomTomSDKSystemTextToSpeechEngine. In technical terms, these drop-in components are called engines and they are managed by the orchestrator. Here’s a list of engines that exist in the Navigation SDK:

• Map Matching Engine

• Route Replanning Engine

• Guidance Engine

• Route Deviation Engine

• Route Progress Detection Engine

• Location Context Detection Engine

• Arrival Detection Engine

Features of the Navigation SDK

TomTom’s new Navigation SDK is a feature-rich toolkit that we can leverage to integrate many geotechnology solutions into the applications we build. Let’s explore some of these features and the kind of solutions we can build with them.

Navigation Configuration

Navigation configuration is used to customize the Navigation experience to suit your needs. This is the entry point of the integration where we can specify the navigationKey, routingService, and locationEngine parameters. Using the iOS SDK, an example of the configuration would look like this:

let configuration = NavigationConfigurationBuilder(
    navigationKey: "<NAVIGATION-KEY>",
    locationEngine: locationEngine,
    routingService: routingService
)
.build()
locationEngine.start()

We can also specify the frequency of ETA updates and the distance and time setting for arrivals. Using the initialized configuration, we can create a navigation object which will enable us to perform some actions like starting and stopping navigation, updating the route, that will enable us to perform some actions like starting and stopping navigation, updating the route, and reporting specific events and reporting specific events that happen during navigation.

Returning to the example of a food delivery app, part of the business requirements might be to allow drivers to pick up multiple orders at once. This means that at each drop-off, the navigation system will need to re-route to the next drop-off location. We can achieve this by defining a set of route plans ahead of time and then using the update method on the navigation object to change the current route plan to the next drop-off location.

Route and Maneuver Information

Navigation is not always a straightforward or definitive process. Multiple factors can influence the route information provided. Weather conditions could cause a road blockage, or construction work could lead to heavy traffic on the road. It’s essential to take these factors into consideration. The Continuous Replanning component gives us this ability. With it, we can perform route refreshes in the background and check for better route alternatives without sacrificing user experience.

Additionally, the Continuous Replanning component is also fully customizable, meaning we can define configuration options like automatic or manual replanning mode or even disable continuous replanning entirely, depending on the kind of behavior we require.

We can also specify the time interval between route replans and the minimum time difference between routes before deciding to use an alternative route, and specify other configuration options like the route replanning policy and providing a custom better route selector.

One important factor to consider when building certain applications that require navigation is security. In a ride sharing app, it’s necessary to be able to tell in real-time when a driver deviates from the navigated route. Developers can easily integrate this feature using the Route Deviation configuration. The ability to make these types of granular configurations makes it easy for us to build rich navigation experiences that are tailored to specific use cases.

Maps Integration

Navigation and maps go hand-in-hand. We can think of maps as the visual tool necessary to build a complete navigation solution because they provide more context to navigation. TomTom provides a Maps SDK as a separate toolkit, but it’s easy to combine the Maps SDK and the Navigation SDK to create a highly interactive navigation experience using built-in UI components or custom components.

Planned or Unplanned

The Navigation SDK provides support for both unplanned journeys and planned routes. We’ve talked about navigation in the context of pre-defined routes. In planned routes, a RoutePlan is provided to the navigation object when the start method is called, and the route plan can be constantly updated throughout navigation.

On the other hand, unplanned journeys, also known as free driving, is navigation without a route. In free driving, we can get details about the current location, such as speed limit, country code, road characteristics, and so on, by setting up a location context.

There are many cases where this type of feature would be useful. Suppose we want to add a feature to our food delivery app that allows the driver to turn on an idle mode when they’re not picking up orders but still want access to navigation information like the speed limit. This is easy to implement because we can readily switch the driving mode between turn-by-turn navigation and free driving using the update method on the navigation object.

Instructions

Guidance instructions are a set of detailed information about navigation. They can be in the form of text or voice messages, and the developer can relay this information to the user as they see fit. Instructions and the channel in which we relay them are vital. If we’re integrating navigation into an app for drivers, then it’s necessary to have voice instructions because we cannot compromise road safety rules by having the driver read messages from the app.

The navigation module uses text-to-speech (TTS) functionality for generating voice instructions. Using the TTS engine, we can generate voice synthesis for messages. On the iOS SDK, initializing a TTS engine using the default SystemTextToSpeechEngine would look like this:

let languageCode = "en-Gb"
let tts = SystemTextToSpeechEngine(language: languageCode)
self.tts = makeTextToSpeech(ttsEngine: tts)

We can then call the play method to synthesize provided messages. Instructions can also be configured just like other parts of the Navigation SDK. For example, the underlying language of the engine can be changed. In the code snippet above, we specified en-Gb as the underlying language. This is particularly important for internationalization if the application we’re building will be used by people in different locations around the world.

Conclusion

In this article, we explored the new TomTom Navigation SDK at a high level. The Navigation SDK is a feature-rich toolkit that enables developers to build many different geotechnology solutions. The modular approach to designing the SDK makes it easy to integrate specific features without compromising on factors like bundle size.

You can learn more about integrating the Navigation SDK into your applications by trying TomTom’s Navigation SDK for yourself!