Bike Demo

_{Last updated: June 19, 2026 | 4 minutes read}

This example is a complete bike navigation app. It shows the map at the current position, lets the user find a destination by free-text search, category, or by tapping the map, computes a route using a bicycle routing profile, and then runs turn-by-turn navigation or simulation along it. The bike profile is configurable: the user can switch between city, cross, mountain, and road bikes, toggle an electric bike and tune its parameters (hills factor, bike and biker weight, auxiliary consumption), and choose to avoid ferries or unpaved roads.

Map at current position

Free text search by typing a query

POI category search by tapping a chip

Calculate route to a destination

Bike route with start / simulate

Turn-by-turn bike navigation

Setting up the bike routing profile

Routing for a bicycle is driven entirely by the RoutePreferences. The view model builds them once the map is ready: the transport mode is set to ERouteTransportMode.Bicycle and an initial EBikeProfile is applied with setBikeProfile. When the electric-bike toggle is on, an ElectricBikeProfile is passed in so the route accounts for battery consumption; otherwise null is used.

MainActivityViewModel.ktView on Github

fun initPreferences() {
    electricBikeProfile = ElectricBikeProfile()
    routePreferences = RoutePreferences().apply {
        transportMode = ERouteTransportMode.Bicycle
        setBikeProfile(EBikeProfile.City, if (isElectric) electricBikeProfile else null)
        hillsFactor
    }
}

fun setBikeProfile(type: EBikeProfile) = SdkCall.execute {
    bikeProfile = type
    routePreferences.setBikeProfile(type, if (isElectric) electricBikeProfile else null)
}

Configuring the position source for cycling

As soon as the default map view is created, the position data source is configured for cycling. Setting ImprovedPositionDefTransportMode to "bike" makes the position arrow snap to bike-accessible roads even outside navigation, while enabling ImprovedPosPreferRouteSnap keeps it locked to the active route while navigating.

MainActivity.ktView on Github

val parametersList =
    arrayListOf(
        Parameter(ESConfigKeys.Position.ImprovedPosPreferRouteSnap, "1"),
        Parameter(ESConfigKeys.Position.ImprovedPositionDefTransportMode, "bike"),
    )
PositionService.dataSource?.setPreferences(EDataType.Position, parametersList)

Calculating the bike route

When the user confirms a destination, the route is computed from the current position with the RoutingService. The bike RoutePreferences built by the view model are assigned to the service right before calculateRoute, so every calculation reflects the currently selected bike profile and settings. calculateRoute only reports whether the calculation could be started: if it returns an error the request never began - so the progress UI is cleared and the failure is shown right away - whereas a successful start is followed later by the service's onCompleted callback.

MainActivity.ktView on Github

private fun calculateRoute(departure: Landmark, destination: Landmark) = SdkCall.execute {
    val waypoints = arrayListOf(
        departure,
        destination,
    )

    routingService.preferences = viewModel.routePreferences
    val error = routingService.calculateRoute(waypoints)
    if (error != GemError.NoError) {
        // The computation never started, so onStarted/onCompleted won't fire: clear any
        // progress UI and report the failure.
        val message = GemError.getMessage(error, this)
        runOnAliveUi {
            binding.progressBar.visibility = View.GONE
            binding.cancelButton.visibility = View.GONE
            showDialog(getString(R.string.routing_error, message))
        }
    }
}

Starting navigation or simulation

Once a route is ready it is presented on the map and the user can either Start real turn-by-turn navigation or run a Demo (simulation) along it. Both use the same NavigationService and NavigationListener; the only difference is startNavigationWithRoute versus startSimulationWithRoute.

MainActivity.ktView on Github

private fun startSimulationWithRoute() = SdkCall.execute {
    binding.gemSurfaceView.mapView?.preferences?.routes?.mainRoute?.let { mainRoute ->
        val error = navigationService.startSimulationWithRoute(
            mainRoute,
            navigationListener,
            navigationProgressListener,
        )

        if (error != GemError.NoError) {
            Util.postOnMain {
                showDialog(
                    getString(
                        R.string.route_simulation_error,
                        SdkCall.runSynced { GemError.getMessage(error, this) },
                    ),
                )
            }
        }

        clearRoutesData()
    }
}

Tuning the bike profile

The settings screen exposes the parameters that shape the route. The E-Bike switch turns the electric profile on or off, the Hills slider sets avoidBikingHillFactor, and additional switches and sliders let the user avoid ferries or unpaved roads and tune the electric profile's bike mass, biker mass, and auxiliary consumption. Each control writes straight back into the shared RoutePreferences / ElectricBikeProfile, so the next calculated route picks the changes up immediately.

MainActivityViewModel.ktView on Github

add(
    SettingsSwitchItem("E-Bike", isElectric) {
        setIsElectric(it)
    },
)
add(
    SettingsSliderItem("Hills", 0f, hillsFactor, 10f, "") {
        hillsFactor = it
        SdkCall.execute { routePreferences.avoidBikingHillFactor = it }
    },
)
add(
    SettingsSwitchItem("Avoid Ferries", avoidFerries) {
        avoidFerries = it
        SdkCall.execute { routePreferences.avoidFerries = it }
    },
)
add(
    SettingsSwitchItem("Avoid Unpaved Roads", avoidUnpavedRoads) {
        avoidUnpavedRoads = it
        SdkCall.execute { routePreferences.avoidUnpavedRoads = it }
    },
)