Skip to content

20.0

20.0.2 (2021-12-02)

Bug Fixes

  • Android: Release singleton managers properly during SygicContext.destroy
  • Map: Don't try to draw World Label if Font is not valid
  • Routing: Fix wrong behavior when stopping RoutePositionSimulator

20.0.1 (2021-11-26)

Bug Fixes

  • Android: Correctly set avoidables

    After creating a route, the engine would not return avoidable objects correctly. This has now been fixed.

  • iOS: Fix migration of auth settings, avoid sign out after update from SDK 19 to SDK 20

    When migrating from SDK19 to SDK20, an already logged in user would be logged out. This has now been fixed and the user should stay logged in.

  • Map: Fix crash in large polygon processing

    In some extreme cases, the processing of a large polygon would have caused a crash. This has now been fixed.

  • Search: Fix network error propagation

    It seems like in the past it was assumed that general error raised by HTTP client implementation would not trigger an exceptional future creation. This is false, exceptional future is indeed created and HTTP client implementation in SDK could not handle general error correctly.

  • Search: Fix reverse geocoding result when input location is outside available map

    We now return an empty list when triggering the offline reverse geocoding outside of a downloaded map.

20.0.0 (2021-11-08)

Bug Fixes

  • Android: Fix RouteSelector crash by using the 4.x version of OkHttp library
  • iOS: Fix probable rare attempt to use OpenGL in background on iOS 12
  • Map: Add labels for India states and fix font scaling bug

    When using a custom type of maps where India is represented as a country split map, not all of the state names were displayed on higher zoom levels. This has been fixed.

  • Map: Solve traffic flickering with multiple views

    When creating a new view, the traffic from the older one would not be correctly destroyed and would be copied to the new one. This would result in occasional flickering of traffic. This has now been fixed.

  • Navigation: Improve reading of road numbers in US and apply same rules for street names and road numbers

  • Navigation: Fix crash if location is updated during SDK termination
  • Navigation: Fix crash when playing empty audio input
  • Navigation: Read decimal numbers correctly when using Turkish TTS language
  • Online: Fix Incidents crash after deinitialization
  • Online: Remove fixed refresh period

    The token refresh period is no longer fixed. It is variable.

  • Routing: Apply avoid settings to EV route

    When calculating an EV route, avoids would not be applied. This has now been fixed

  • Routing: Do not compute EV Route with online POIs

    Sometimes the EV compute would try to look for POIs in online maps and it would result in a crash. This has now been fixed.

  • Routing: Fix incorrect road numbers

    When leaving a road with a road number, the TTS engine would say "go along" + the number of the road that you were leaving from, instead of the number of the road you were entering. This has now been fixed.

  • Routing: Prefer charging stations which do not break avoid conditions

    When avoiding a toll road or a highway, the EV compute algorithm would still look for charging stations that are in an area where the avoid strategy would be broken. This has now been fixed.

  • Routing: Resolve crash related to EV profile and EV station compatibility

Features

  • Android: Add ability to set rectangle avoids in RoutingOptions

    You can now choose to avoid a list of Bounding Boxes during a compute.

  • Android: Add the possibility to add and remove a waypoint at a specific index

    The waypoints can now be added to a specific index using an index argument.

  • Android: Add floating point precision methods for speeds into SpeedLimitInfo class

    It sometimes happened that the conversion between kilometres and miles would not be correctly precise as we used integers for both. Now the function return floats.

  • Android: Add restriction for TLS 1.2 and TLS 1.3 protocols for HTTP connections

    We have added several TLS restrictions for HTTP connections to ensure secure communication.

  • Android: Auth-lib integration

    We have integrated our very own Authentication library that is distributed for Android and iOS, separately. The changes are integrated so very well implicitly that most of the changes don't cause a necessity of changing the integrator's code. However, there are some changes and you can read about them in the Breaking Changes section.

  • Android: Call onError instead of throwing exception if SDK is initializing

    When calling a new initialization while the SDK is being initialized, the engine no longer throws an exception that would have to be catched. Instead, we send an error callback to one of the listeners.

  • Android: Correct typo in ErrorCode

    INCIDENT_NOT_FOUNT has been renamed to INCIDENT_NOT_FOUND.

  • Android: Http client redesign

    Internal changes which should ameliorate the user experience, making the http client newer, faster and more reliable.

  • Android: Increase minimum Android API Level to 21

    In order to keep up with all of the new development, we dropped support for API levels older than 21. That means that the latest supported version is KitKat (5.0) instead of the older Jelly Bean (4.2).

  • Android: Make parameters in PositionChangeListener not null

    The parameters of callbacks in PositionChangeListener have been changed and they are no longer nullable.

  • Android: Update to a new routing interface

    The routing interface has been re-worked. Now the integrator has more control over the routing callbacks. More in the New Routing Interface section.

  • Android: Upgrade OkHttp to version 4.9

    To keep up with the pace of newest technologies and also to be able to work with HTTP more conveniently, we have updated the OkHttp version to 4.9. When importing SDK as api(), you might need to adjust your code because of breaking changes from OkHttp library

  • Core: Implement faster license checks

    The logic behind checking a license upon initialization has been changed, although it should not affect the user or integrator in any way. The engine now looks for an offline license and if any valid license is found, the SDK is initialized without needing to send a request for a new license and the request is sent while the application is running.

  • Core: Remove deprecated SygicEngine Builder and deprecate old init methods

    More in the Breaking Changes section.

  • Core: Remove LogTelemetry and GpsTelemetry appenders

    We have removed some unused telemetry appenders.

  • iOS: Allow to set scale factor for map view on iOS

    As drawing on secondary displays might have yielded unwanted results, we have added a scale factor to the SYMapView's interface. New initWithFrame: functions have been added.

  • iOS: Disable map rendering when UIScene in background (optional, on by default)

    From iOS 13 and up, there is an option to UIScene changes using the listensToSceneNotifications property of SYMapView.

  • iOS: Fix naming misprints

    Several typos have been corrected to ensure everyone's peaceful state of mind. More in the Breaking Changes section.

  • iOS: Integrate Auth Lib

    We have integrated our very own Authentication library that is distributed for Android and iOS, separately. The changes are integrated so very well implicitly that most of the changes don't cause a necessity of changing the integrator's code. However, there are some changes and you can read about them in the Breaking Changes section.

  • iOS: Update to a new routing API.

    The routing interface has been re-worked. Now the integrator has more control over the routing callbacks. More in the New Routing Interface section.

  • Map Add option to enable clustering of Map Markers

    A long-awaited and desperately needed function to cluster Map Markers has finally arrived. You can create a new Map Place object which can be added to the map and manager using the new Map Places Manager.

  • Map: Add drawing support for Truck Aid markers

    An ability to draw Truck Aid markers has been added to Map View interfaces.

  • Map: Add new autozoom processor, which controls camera distance and tilt based on the nearest junction distance

  • Map: Allow to add Map Markers on a specific screen position

    The MapMarkers can now not only be placed in the actual map using map coordinates, but can be placed on a specified place on a device's screen.

  • Map: Load global and local POI data on LOD 0

    Some of the POIs are defined as global - such as ferry terminals or airports. They have not been read on lower zoom levels until now.

  • Navigation: Create new Truck Aid analyzer

    A new listener has been added to the Navigation Manager. The listener provides information about an upcoming restriction on a predicted trajectory or close to it. This is intended to provide early warnings about upcoming important junctions or restrictions located on a trajectory-predicted path. Mostly, these warnings consist of restricted left/right turns or predicted blind roads.

  • Navigation: Enable EV profile to be null

    If you set the currentEVProfile as nil, the results received from functions such as exploreChargingStationsOnRoute or OnPlaceListener/didUpdatePlace will not be filtered. It means that you will receive all of the charging stations no matter the compatibiity with an EV Profile.

  • Navigation: Rename road class enum values to match their meaning

    We made the road class enum values more understandable for integrators. More in the Breaking Changes section.

  • Online: Add handling to a expired session refresh token with session expiration signal

    There's a new option to call the onSessionExpired function.

  • Routing: Add interface for getting the Route geometry

    It is now possible to retrieve the complete geometry of a route using the getRouteGeometry function.

  • Routing: Add new motorcycle navigation type

    We understand that there are many end-users who own a motorcycle which they love to take for a spin from time to time. Those people don't want to take lousy, boring motorways, but want to have fun at serpentine roads. This feature allows you to compute a route as curvy as it gets. Just choose the motorcycle vehicle type and let the compute algorithm do the rest for you. Warning: Available in offline compute mode only. Hint: The shortest routing type works wonders!

  • Routing: Add option to use delivery zones

    Some endpoints can be reached only by entering delivery zones. This option controls this behavior. In case this feature is disabled and Last Mile feature is also disabled, the routing engine will return an error. This feature is disabled by default.

  • Routing: Add option to inject an own executor for routing functions execution

    It is now possible to define executors for routing functions in case the device has a piece of redundant computing power and the process of computing multiple routes would profit from being spread over multiple threads.

  • Routing: Add possibility to disable Last Mile feature

    The last mile feature can now be disabled. You can find the option in the Routing Options. This feature causes routing to be more benevolent in vicinity of endpoints. The last mile is not suppressed by default.

  • Routing: Allow integrator to set charging waypoints manually

    It is now possible for the integrator to create a ChargingWaypoint or a SYChargingWaypoint object which can then be used in the EV compute. This way the users can define their own places where they want to charge their electric vehicle in addition to them being chosen automatically.

  • Routing: Remove detour option from routing settings

    The compute's suppressDetours option was removed from the Routing options as it was unused and unnecessary. There is no replacement.

  • Search: Add invalid radius Places error code

    A new error code when searching for Places has been added.

  • Traffic: Allow to register a custom traffic provider

  • Travelbook: Remove travelbook functionality

    Due to being unsupported and deprecated for a long period of time, we have completely removed the Travelbook from all interfaces.

BREAKING CHANGES

  • Routing:

    iOS: SYChargingWaypoint: link became nullable, alternatives became a nonnull array of SYChargingWaypoint. Android: Added new parameter ChargingType into ChargingWaypoint class constructor

  • Navigation:

    Android: Values of enum class RoadType were renamed to correctly represent their meaning, functional logic not changed. iOS: Values of enum SYRoadType were renamed to correctly represent their meaning, functional logic not changed.

    This concerns mostly the StreetInfo's (Android) and SYStreetInfo's (iOS) constructors.

    • RoadClass0 → InternationalImportance / SYRoadTypeInternationalImportance
    • RoadClass1 → NationalImportance / SYRoadTypeNationalImportance
    • RoadClass2 → RegionalImportance / SYRoadTypeRegionalImportance
    • RoadClass3 → LocalRoadWithHighImportance / SYRoadTypeLocalRoadWithHighImportance
    • RoadClass4 → LocalRoad / SYRoadTypeLocalRoad
    • Ferries → Ferry / SYRoadTypeFerry
    • Railway → Railway / SYRoadTypeRailway
    • Unknown → Unknown
  • Core: LogTelemetry and GpsTelemetry appenders are no longer supported

  • iOS: SYNavigationManager.currentEVProfile became nullable, default value is nil.
  • iOS: Fixed misprints: SYContexInitResult renamed to SYContextInitResult,

    SYRouteEventNotoficationsSettings renamed to SYRouteEventNotificationsSettings, SyProxyObjectType renamed to SYProxyObjectType, made consistent naming in SYMapInstaller: argument withCompletion renamed to completion.

  • Android: Enum's "fromValue" method was removed from the Java public interface and has been replaced by Parcelable interface.

  • Android: RoadElement is replaced by RouteElement

    MatchedRoadId is renamed to RoadId MatchedRoadDetail is replaced by Road, which can be retrieved using the RoadId

  • iOS: SYRoadElement is replaced by SYRouteElement

    SYMatchedRoadId is renamed to SYRoadId SyMatchedRoadDetail is replaced by SYRoadDetail, which can be retrieved using the SYRoadId

  • iOS: SYOnlineSession authentication methods renamed to signIn,

    Now the methods call a completion block instead of delivering a status to delegate.

  • Android: We dropped support for Android API Levels 17-20.

  • Android: Authenticate methods were removed from OnlineManager, use AuthManager to authenticate.
  • Core: The Android SygicEngine's Builder has been removed. Please use the initialize() method instead.

    Also, the initialization methods that do not accept the new Init Request parameter have been deprecated on both platforms.

    See how to initialize correctly here

  • Android: Arguments in onPositionChanged and onCourseChanged are never null, so it doesn't make sense to have them as nullable types

  • Android: When calling init while the SDK is initializing, we now call onError method of callback instead of throwing IllegalStateException
  • Navigation:

    Android: RoadClass is renamed to RoadType, values are renamed to more understandable. iOS: SYRoadType values are renamed to more understandable.

  • iOS: Maps SDK is now built with Xcode 12.4, which is based on LLVM 10. Newer version of compiler can introduce undesirable behaviour due to different optimizations at compile time.

  • Travelbook: Travelbook has been hereby completely removed from the project and all of its interfaces.

    After being deprecated for a longer period of time, the TravelBook functionality has been finally completely removed. To migrate your project, please remove or replace the SygicMapsSDK's travelbook functionality

  • Android: The enum INCIDENT_NOT_FOUNT has been renamed to INCIDENT_NOT_FOUND to correct the typo.

    To migrate your project, rename INCIDENT_NOT_FOUNT to INCIDENT_NOT_FOUND.

  • Android: Maps SDK is now built with Android NDK 22.1, which is based on LLVM 11. Newer version of compiler can introduce undesirable behaviour due to different optimizations at compile time.

  • iOS: We changed how we build and distribute iOS Framework

    • The distribution framework is now built with Xcode's New Build System.
    • Universal framework binary no longer contains arm64e architecture due to compatibility issues with ARC and PACs. Please use arm64 architecture for iphoneos platform instead.
  • Routing: The compute's suppressDetours option was removed from the Routing options as this was no longer functional and deemed necessary. There is no replacement.

  • Android: Router now works with RouteComputeListener and RouteComputeFinishedListener, alternatives are now compute arguments.

    New API works with a new routing interface.

  • iOS: SYRouting now works with completions instead of delegate.

    New API works with a new routing interface.

New Routing Interface

In SDK 19 and lower, the flow to compute a route was following:

  • create a Route Plan object, to which you feed start, destination, via points and routing options if you have them
  • pass the route plan object to Router along with a listener that contained several callbacks, such as onProgress, onPrimaryComputeFinished, onAlternatives etc.
  • there were also more methods such as one for a normal compute, another one for EV compute, another one for AETR compute

now all of this has changed:

  • the base for computing a route is a Route Request
  • the route request has start, destination, routing options (which work as before), via points and as arguments, you can feed it an EV profile with EVPreferences or and AETR profile or a Guided route profile
  • compute is then determined on whether the Route Request has any of those arguments or not.
  • i.e. if you create a route request with aetr profile : RouteRequest(AetrProfile) , the AETR compute will be chosen

the method for compute has been changed to computeRouteWithAlternatives to which you feed a PrimaryRouteRequest, which consists of :

  • the route request
  • and the listener for the primary route, which has the onComputeFinished and onProgress callbacks

then, can create separate Alternative route requests, which you feed to the computeRouteWithAlternatives()

Each alternative route request has its type (Avoid (the avoids as we know them - tries to avoid the primary route, reasonably), Shortest, Fastest and Economic) and its listener - you can now have a different listener for each alternative route.

Finally, you need one last compute listener, which is the RouteComputeFinishedListener which is called with the Route and Alternative route results when all of the computes end.

On Android, a simple compute with alternatives would look something like this:

val routeRequest = RouteRequest()
routeRequest.apply {
    setStart(start)
    setDestination(end)
}

val routingOptions = RoutingOptions()
routingOptions.apply {
    isUnpavedRoadAvoided = true
    routingService = RoutingOptions.RoutingService.Offline
    transportMode = RoutingOptions.TransportMode.Car
    routingType = RoutingOptions.RoutingType.Fastest

}
routeRequest.routingOptions = routingOptions

val router = RouterProvider.getInstance().get()

val alternativesComputeListener = object : RouteComputeListener {
    override fun onComputeFinished(
        route: Route?,
        status: Router.RouteComputeStatus
    ) {
        route?.let {
            mMapView.mapDataModel.addMapObject(
                MapRoute.from(it).setType(MapRoute.RouteType.Alternative)
                    .build()
            )
        }
    }

    override fun onProgress(progress: Int) {

    }
}

val alternatives = listOf(
    AlternativeRouteRequest(
        AlternativeRouteRequest.RouteAlternativeType.Shortest,
        alternativesComputeListener
    ),
    AlternativeRouteRequest(
        AlternativeRouteRequest.RouteAlternativeType.Economic,
        alternativesComputeListener
    )
)

router.computeRouteWithAlternatives(PrimaryRouteRequest(routeRequest, object: RouteComputeListener {
    override fun onComputeFinished(
        route: Route?,
        status: Router.RouteComputeStatus
    ) {
        TODO("Not yet implemented")
    }

    override fun onProgress(progress: Int) {
        TODO("Not yet implemented")
    }
}), alternatives, object: RouteComputeFinishedListener {
    override fun onComputeFinished(
        route: Route?,
        alternatives: List<AlternativeRouteResult>
    ) {
        TODO("Not yet implemented")
    }
})