Release v1.11.0

Lane Guidance, Valhalla Integration, and Smarter Route Tracking

v1.11.0 brings professional-grade navigation features that help drivers navigate complex intersections with confidence. We've added turn lane information, direct Valhalla JSON route creation, and intelligent alternative route tracking.

Turn Lane Guidance: Navigate Complex Intersections Like a Pro

Ever missed a turn because you were in the wrong lane? Your users won't have to anymore.

We've added detailed lane information to GLRouteManeuver, enabling you to build navigation UI that shows exactly which lanes to use for upcoming turns – just like premium navigation apps.

Why Lane Guidance Matters

Modern highways and urban intersections can have 5+ lanes with different turn restrictions. Lane guidance helps users:

• Avoid last-minute lane changes – Get into the correct lane early
• Reduce navigation anxiety – Clear visual cues about which lanes work
• Navigate unfamiliar areas confidently – Especially useful for complex highway interchanges
• Minimize missed turns – Users know exactly where to be

New Lane Information API

/// Number of lanes at this maneuver
@property(readonly) NSUInteger lanesCount;

/// Returns possible turn directions for a specific lane.
/// @param index The index of the lane (starting from 0).
/// @return A mask indicating all valid turn directions for the lane.
- (GLRouteTurnLaneMask)turnDirectionsAtLine:(NSUInteger)index;

/// Returns valid turn directions for a lane that can be used to follow the route initially.
/// Valid turns indicate that the lane is suitable for the maneuver but may require further lane changes later.
/// @param index The index of the lane (starting from 0).
/// @return A mask indicating valid turns for the lane.
- (GLRouteTurnLaneMask)validTurnAtLine:(NSUInteger)index;

/// Returns active turn directions for a lane that should be used to follow the route without requiring additional lane changes.
/// Active turns indicate the optimal lane for continuing along the route as intended.
/// @param index The index of the lane (starting from 0).
/// @return A mask indicating active turns for the lane.
- (GLRouteTurnLaneMask)activeTurnAtLine:(NSUInteger)index;

Understanding the Lane States

• All possible turns (turnDirectionsAtLine) – What directions are legal from this lane
• Valid turns (validTurnAtLine) – Lanes that work for your route, but might need lane changes later
• Active turns (activeTurnAtLine) – The optimal lane(s) that keep you on route without future lane changes

This three-tier system lets you build UI that highlights the best lanes while showing acceptable alternatives.

---

Create Routes from Valhalla JSON

Building a hybrid navigation system? Now you can generate routes on your backend using Valhalla and seamlessly use them with GLRoute for turn-by-turn navigation on the device.

Use Cases

• Custom routing logic – Apply your own business rules server-side
• Hybrid offline/online – Generate routes online, navigate offline
• Route caching – Pre-calculate and cache routes for common trips
• Integration with existing systems – Use Valhalla responses from your current infrastructure

How It Works

If you already have a Valhalla JSON response from your backend or from the offline routing method:

+[GLRouteRequest offlineAction:(NSString *)action
                       request:(NSString *)request
                        config:(NSString *)config
                    startPoint:(GLMapGeoPoint)startPoint
                         error:(NSError **)error]

You can now convert that JSON directly into a GLRoute object and use it with GLRouteTracker for full turn-by-turn navigation. This creates a clean separation between route generation and route tracking.

---

Alternative Route Tracking

Real-world navigation is unpredictable. Users miss turns, take shortcuts, or deliberately choose alternate routes. v1.11.0 makes GLRouteTracker smarter about handling these scenarios.

What's New

Routes can now include both primary and alternative route segments. The tracker intelligently detects when users:

• Pass a junction without taking the suggested turn
• Merge onto an alternative route
• Switch between route options dynamically

New API Methods

/// Checks if the user has passed the specified route.
/// @param routeIndex The index of the route.
/// @return YES if the user has passed the route, NO otherwise.
- (BOOL)didPassRoute:(NSInteger)routeIndex;

/// Current route index. Can be changed when the tracker detects that the user moves along another route.
@property(assign) uint8_t currentRoute;

This enables more graceful handling of navigation deviations without immediate rerouting, creating a smoother user experience.

---

Breaking Changes

GLMapTapGestureBlock Simplification

In v1.10.0, we added a BOOL return value to gesture blocks. Based on usage patterns, we've refined this:

• GLMapTapGestureBlock – No longer returns BOOL (returns void)
• GLMapPanGestureBlock – Still returns BOOL for proper gesture handling

Migration:

// v1.10.0
[mapView setOnTapGestureBlock:^BOOL(UITapGestureRecognizer *gesture) {
    // Handle tap
    return YES;
}];

// v1.11.0
[mapView setOnTapGestureBlock:^(UITapGestureRecognizer *gesture) {
    // Handle tap - no return needed
}];

This change reflects how developers actually use tap vs. pan gestures and simplifies the most common gesture use case.