NextBillion.ai

https://docs.nextbillion.ai
Admin
NextBillion.ai provides APIs and SDKs for route optimization, navigation, real-time tracking, and...
Tokens:720,636
Snippets:6,859
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### POST /navigation/json

Source: https://docs.nextbillion.ai/routing/navigation-api

This example shows a POST request for flexible navigation, configured for a similar scenario as the GET examples.

```APIDOC
## POST /navigation/json

### Description
This endpoint supports flexible navigation routing via a POST request, allowing for complex configurations to be sent in the request body.

### Method
POST

### Endpoint
https://api.nextbillion.io/navigation/json

### Parameters
#### Query Parameters
- **key** (string) - Required - Your API key.
- **option** (string) - Required - Set to "flexible" for flexible routing.

#### Request Body
- **(object)** - Required - The request body should contain the navigation parameters, such as origin, destination, mode, etc. The exact structure is not detailed in the source but would typically mirror the GET query parameters.

### Request Example
```json
curl --location --request POST 'https://api.nextbillion.io/navigation/json?key=<your_api_key>&option=flexible' --header 'Content-Type: application/json' --data-raw '{...}'
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the request, e.g., "Ok".
- **routes** (array) - An array containing route information.
```

--------------------------------

### Start Navigation with NavViewConfig

Source: https://docs.nextbillion.ai/docs/navigation/sdk/android/customize-navigation-page

Start a navigation session by providing a NavViewConfig containing a DirectionsRoute. This example demonstrates creating a minimal configuration and initiating navigation.

```java
NavViewConfig.Builder config = 
NavViewConfig.builder().route(directionsRoute);
navigationView.startNavigation(config.build());
```

--------------------------------

### Fetch Route and Start Navigation

Source: https://docs.nextbillion.ai/routing/android-navigation-sdk/map-display-and-navigation

Fetch a route using origin and destination, then configure and start navigation. This snippet combines route fetching with navigation setup.

```Java
NBNavigation.fetchRoute(origin, destination, new Callback<DirectionsResponse>() {
            @Override
            public void onResponse(@NonNull Call<DirectionsResponse> call, @NonNull Response<DirectionsResponse> response) {
                DirectionsRoute route = response.body().routes().get(0);
                //start a navigation with the route we just fetched.
                NavLauncherConfig.Builder configBuilder = NavLauncherConfig.builder(route)
 .shouldSimulateRoute(true);
                configBuilder.locationLayerRenderMode(RenderMode.GPS);
                NavigationLauncher.startNavigation(activity, configBuilder.build());
            }

            @Override
            public void onFailure(@NonNull Call<DirectionsResponse> call, @NonNull Throwable t) {

            }
});
```

--------------------------------

### Map UI Page Setup

Source: https://docs.nextbillion.ai/maps/flutter-maps-sdk/examples/simple-user-interface

Sets up the main page for the map UI example, including necessary imports and widget structure. This serves as the entry point for map-related UI components.

```dart
import 'dart:math';

import 'package:flutter/material.dart';
import 'package:collection/collection.dart';
import 'package:nb_maps_flutter/nb_maps_flutter.dart';

import 'main.dart';
import 'page.dart';


final LatLngBounds sydneyBounds = LatLngBounds(
  southwest: const LatLng(-34.022631, 150.620685),
  northeast: const LatLng(-33.571835, 151.325952),
);

class MapUiPage extends ExamplePage {
  MapUiPage() : super(const Icon(Icons.map), 'User interface');

  @override
  Widget build(BuildContext context) {
    return const MapUiBody();
  }
}

class MapUiBody extends StatefulWidget {
  const MapUiBody();

  @override
  State<StatefulWidget> createState() => MapUiBodyState();
}

class MapUiBodyState extends State<MapUiBody> {
  MapUiBodyState();

  static final CameraPosition _kInitialPosition = const CameraPosition(
    target: LatLng(-33.852, 151.211),
    zoom: 11.0,
  );

  NextbillionMapController? mapController;
  CameraPosition _position = _kInitialPosition;
  bool _isMoving = false;
  bool _compassEnabled = true;
  bool _mapExpanded = true;
  CameraTargetBounds _cameraTargetBounds = CameraTargetBounds.unbounded;
  MinMaxZoomPreference _minMaxZoomPreference = MinMaxZoomPreference.unbounded;
  int _styleStringIndex = 0;
  // Style string can a reference to a local or remote resources.
  // On Android the raw JSON can also be passed via a styleString, on iOS this is not supported.
  List<String> _styleStrings = [
    "https://api.nextbillion.io/maps/streets/style.json",
    "https://api.nextbillion.io/maps/streets/style.json",
    "https://api.nextbillion.io/maps/streets/style.json"
  ];
  List<String> _styleStringLabels = [
    "NBMAP_STREETS",
    "SATELLITE",
    "LOCAL_ASSET"
  ];
  bool _rotateGesturesEnabled = true;
  bool _scrollGesturesEnabled = true;
  bool? _doubleClickToZoomEnabled;
  bool _tiltGesturesEnabled = true;
  bool _zoomGesturesEnabled = true;
  bool _myLocationEnabled = true;
  bool _telemetryEnabled = true;
  MyLocationTrackingMode _myLocationTrackingMode = MyLocationTrackingMode.None;
  List<Object>? _featureQueryFilter;
  Fill? _selectedFill;

  @override
  void initState() {
    super.initState();
  }

  void _onMapChanged() {
    setState(() {
      _extractMapInfo();
    });
  }

  void _extractMapInfo() {
    final position = mapController!.cameraPosition;
    if (position != null) _position = position;
    _isMoving = mapController!.isCameraMoving;
  }

  @override
  void dispose() {
    mapController?.removeListener(_onMapChanged);
    super.dispose();
  }

  Widget _myLocationTrackingModeCycler() {
    final MyLocationTrackingMode nextType = MyLocationTrackingMode.values[
        (_myLocationTrackingMode.index + 1) %
            MyLocationTrackingMode.values.length];
    return TextButton(
      child: Text('change to $nextType'),
      onPressed: () {
        setState(() {
          _myLocationTrackingMode = nextType;
        });
      },
    );
  }

  Widget _queryFilterToggler() {
    return TextButton(
      child: Text(
          'filter zoo on click ${_featureQueryFilter == null ? 'disabled' : 'enabled'}'),
      onPressed: () {
        setState(() {
          if (_featureQueryFilter == null) {
            _featureQueryFilter = [
              "==",
              ["get", "type"],
              "zoo"
            ];
          } else {
            _featureQueryFilter = null;
          }
        });
      },
    );
  }

  Widget _mapSizeToggler() {
    return TextButton(
      child: Text('${_mapExpanded ? 'shrink' : 'expand'} map'),
      onPressed: () {
        setState(() {
          _mapExpanded = !_mapExpanded;
        });
      },
    );
  }

  Widget _compassToggler() {
    return TextButton(
      child: Text('${_compassEnabled ? 'disable' : 'enable'} compasss'),
      onPressed: () {
        setState(() {
          _compassEnabled = !_compassEnabled;
        });
      },
    );
  }

```

--------------------------------

### PolygonActivity Setup

Source: https://docs.nextbillion.ai/maps/android-maps-sdk/examples/mapview-polygon

This is the main activity for the polygon map example. It initializes the MapView, sets up listeners, and prepares UI elements for polygon manipulation.

```java
public class PolygonActivity extends AppCompatActivity implements View.OnClickListener {


   private NextbillionMap mMap;
   private MapView mapView;
   private BottomSheetBehavior bottomSheetBehavior;
   private Polygon polygon;
   // for stroke
   private Polyline polyline;


   // polygon
   private List<LatLng> polygonPoints = new ArrayList<>();
   private List<Marker> polygonMarkers = new ArrayList<>();
   private LatLngBounds latLngBounds;
   private Marker clickMarker;


   // menu
   private ColorSelectorView polygonColorSelectorView;
   private ColorSelectorView polygonStrokeColorSelectorView;
   private SliderBarView polygonStrokeWidthSliderBarView;
   private SettingSwitchView pointSettingSwitchView;
   private FloatingActionButton fbInfoFloatingActionButton;
   private TextView fbNoticeButton;


   private String polygonColor = "#1E58A5";
   private String polygonStrokeColor = "#FF0000";
   private float stockWidth = 2;
   private int polygonIndex = 1;
   private boolean showPolygonVertex = true;


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_polygon);
       mapView = findViewById(R.id.map_view);
       mapView.onCreate(savedInstanceState);
       mapView.getMapAsync(this::onMapSync);
       // button
       findViewById(R.id.fb_clean).setOnClickListener(this);
       fbInfoFloatingActionButton = findViewById(R.id.fb_expand);
       fbInfoFloatingActionButton.setOnClickListener(this);
       fbNoticeButton = findViewById(R.id.fb_check);
       fbNoticeButton.setOnClickListener(this);
       // menu
       polygonColorSelectorView = findViewById(R.id.polygon_color);
       polygonStrokeColorSelectorView = findViewById(R.id.polygon_stroke_Color);
       polygonStrokeWidthSliderBarView = findViewById(R.id.lineWidth);
       pointSettingSwitchView = findViewById(R.id.pointEnable);
       findViewById(R.id.iv_back).setOnClickListener(this);
       initData();
       initBottomSheet();
   }

}
```

--------------------------------

### LinePage Widget Setup

Source: https://docs.nextbillion.ai/maps/flutter-maps-sdk/examples/mapview-polyline

Defines the main widget for the line example, setting up the page title and returning the LineBody widget.

```dart
class LinePage extends ExamplePage {
 LinePage() : super(const Icon(Icons.share), 'Line');

 @override
 Widget build(BuildContext context) {
   return const LineBody();
 }
}
```

--------------------------------

### Get Asset Information Example

Source: https://docs.nextbillion.ai/tracking/ios-tracking-sdk/examples/asset-profile-operations

Illustrates how to retrieve the details of a specific asset. This example includes encoding the response data to JSON for display and handling potential errors during the API call.

```swift
AssetTracking.shared.getAssetDetail(){
    getAssetResponse in
    let data: GetAssetResponseData = getAssetResponse.data
    do {
        let encoder = JSONEncoder()
        let jsonData = try encoder.encode(data)
        if let jsonString = String(data: jsonData, encoding: .utf8) {
            self.assetInfo.text = jsonString
        }
    } catch {
        print("Error encoding JSON: \(error)")
    }
} errorHandler: {
    error in
    let errorMessage = error.localizedDescription
    let toastView = ToastView(message: "Get asset profile failed: " + errorMessage)
    toastView.show()
}
```

--------------------------------

### Popup Example

Source: https://docs.nextbillion.ai/maps/web-maps-sdk-v2/references/markers-and-controls

Example demonstrating how to create and customize a popup with offset and HTML content.

```APIDOC
## Popup Example

```javascript
var markerHeight = 50, markerRadius = 10, linearOffset = 25;
var popupOffsets = {
 'top': [0, 0],
 'top-left': [0,0],
 'top-right': [0,0],
 'bottom': [0, -markerHeight],
 'bottom-left': [linearOffset, (markerHeight - markerRadius + linearOffset) * -1],
 'bottom-right': [-linearOffset, (markerHeight - markerRadius + linearOffset) * -1],
 'left': [markerRadius, (markerHeight - markerRadius) * -1],
 'right': [-markerRadius, (markerHeight - markerRadius) * -1]
 };
var popup = new nextbillion.maps.Popup({offset: popupOffsets, className: 'my-class'})
  .setLngLat(e.lngLat)
  .setHTML("<h1>Hello World!</h1>")
  .setMaxWidth("300px")
  .addTo(map);
```
```

--------------------------------

### Start Asset Tracking

Source: https://docs.nextbillion.ai/tracking/ios-tracking-sdk/examples/asset-tracking-extended

Starts the asset tracking process by calling the assetTracking.startTracking() method.

```swift
func startTracking() {
    assetTracking.startTracking()
}
```

--------------------------------

### Samsara GET Webhook Response Example

Source: https://docs.nextbillion.ai/integrations/samsara/dispatching-optimized-routes-to-telematics

Example of a successful GET webhook response from Samsara, indicating the configuration status.

```json
{
  "status": "Ok",
  "data": {
    "config": {
      "webhook": []
    }
  }
}
```

--------------------------------

### SDK Usage Example

Source: https://docs.nextbillion.ai/maps/web-maps-sdk-v2/references

A practical example demonstrating how to initialize the map with an API key and set map options.

```APIDOC
## Example
```javascript
nextbillion.setApiKey("your_api_key")
var map = new nextbillion.maps.Map({
  container: 'map',
  center: [-122.420679, 37.772537],
  zoom: 13,
  style: 'https://api.nextbillion.io/maps/streets/style.json',
  hash: true,
});
```
```

--------------------------------

### Basic Navigation App Setup

Source: https://docs.nextbillion.ai/docs/navigation/sdk/ios/examples/basic-navigation-app

This snippet demonstrates how to set up a basic navigation app. It defines origin and destination, calculates a route, and initializes the NavigationViewController.

```swift
import UIKit
import NbmapNavigation
import NbmapCoreNavigation


class BasicNavigationViewController: UIViewController {
  
   override func viewDidLoad() {
       super.viewDidLoad()
      
      
       let origin = CLLocation(latitude: 37.77440680146262, longitude: -122.43539772352648)
       let destination = CLLocation(latitude: 37.76556957793795, longitude: -122.42409811526268)
       let options = NavigationRouteOptions(origin: origin, destination: destination)
       Directions.shared.calculate(options) { [weak self] routes, error in
           guard let strongSelf = self else {
               return
           }
           guard error == nil else {
               print(error!)
               return
           }
          
           guard let routes = routes else { return }
          
          
           // Initialize  NBNavigationService with the fetched routes, set routeIndex of the primary route to 0
           let navigationService = NBNavigationService(routes: routes, routeIndex: 0)
          
           let navigationOptions = NavigationOptions(navigationService: navigationService)
          
           // Initialize the NavigationViewController
           let navigationViewController = NavigationViewController(for: routes,navigationOptions: navigationOptions)
          
           // Set the delegate of navigationViewController to subscribe for NavigationView's events, This is optional
           navigationViewController.modalPresentationStyle = .fullScreen
          
           // Render part of the route that has been traversed with full transparency, to give the illusion of a disappearing route.
           navigationViewController.routeLineTracksTraversal = true
          
           // Start navigation
           strongSelf.present(navigationViewController, animated: true, completion: nil)
       }
      
   }
  
}
```

--------------------------------

### Directions Fast API GET Request Example

Source: https://docs.nextbillion.ai/routing/directions-api

Example of how to make a GET request to the Directions Fast API. Replace {your_api_key} with your actual API key.

```HTTP
https://api.nextbillion.io/directions/json?key={your_api_key}
```

--------------------------------

### Samsara GET API Request Example

Source: https://docs.nextbillion.ai/integrations/samsara/dispatching-optimized-routes-to-telematics

Example of a GET API request to configure NextBillion.ai's Skynet. Ensure you replace '<your_api_key>' with your actual API key.

```json
{
  "request": {
    "url": "https://api.nextbillion.io/skynet/config?key=<your_api_key>",
    "method": "GET",
    "body": null,
    "headers": "{..}"
  },
  "response": "{...}"
}
```

--------------------------------

### Start Navigation

Source: https://docs.nextbillion.ai/routing/android-navigation-sdk/map-display-and-navigation

Initiate the navigation session with the prepared launcher configuration. Ensure the activity context and built configuration are provided.

```Java
NavigationLauncher.startNavigation(activity, configBuilder.build());
```

--------------------------------

### Custom Info Window Activity Setup

Source: https://docs.nextbillion.ai/maps/android-maps-sdk/examples/custom-infowindow

Sets up the activity, initializes the MapView, and loads the map style. The `onStyleLoaded` callback is crucial for customizing the info window and adding markers.

```java
package ai.nextbillion;

import android.graphics.Bitmap;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;

import ai.nextbillion.maps.annotations.BaseMarkerOptions;
import ai.nextbillion.maps.annotations.Icon;
import ai.nextbillion.maps.annotations.IconFactory;
import ai.nextbillion.maps.annotations.Marker;
import ai.nextbillion.maps.core.MapView;
import ai.nextbillion.maps.core.NextbillionMap;
import ai.nextbillion.maps.core.OnMapReadyCallback;
import ai.nextbillion.maps.core.Style;
import ai.nextbillion.maps.geometry.LatLng;
import ai.nextbillion.utils.SymbolGenerator;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

public class CustomInfoWindowActivity extends AppCompatActivity implements OnMapReadyCallback {

    private MapView mapView;
    private NextbillionMap mMap;
    private ImageView ivBack;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_animate_markers);

        ivBack = findViewById(R.id.iv_back);
        mapView = findViewById(R.id.map_view);
        mapView.onCreate(savedInstanceState);
        mapView.getMapAsync(this);

        ivBack.setOnClickListener(v -> finish());
    }

    @Override
    public void onMapReady(@NonNull NextbillionMap nextbillionMap) {
        mMap = nextbillionMap;
        mMap.getStyle(new Style.OnStyleLoaded() {
            @Override
            public void onStyleLoaded(@NonNull Style style) {
                customiseInfoWindow();
                addMarker();
            }
        });
    }


    ///////////////////////////////////////////////////////////////////////////
    //
    ///////////////////////////////////////////////////////////////////////////


    private Bitmap generateTextIcon() {
//        View view = LayoutInflater.from(this).inflate(R.layout.text_marker_layout, mapView, false);
        View view = LayoutInflater.from(this).inflate(R.layout.custom_marker_layout, mapView, false);
        return SymbolGenerator.generate(view);
    }

    private void addMarker() {
        Bitmap iconBitmap = generateTextIcon();
        Icon icon = IconFactory.getInstance(this).fromBitmap(iconBitmap);
        mMap.addMarker(new CustomMarkerOptions().icon(icon).position(new LatLng(53.55095026373886, 9.992248999933745)));
    }



    ///////////////////////////////////////////////////////////////////////////
    // Customise InfoWindow
    ///////////////////////////////////////////////////////////////////////////

    // Placeholder for customiseInfoWindow() method implementation
    private void customiseInfoWindow() {
        // Implementation would go here to set the InfoWindowAdapter
    }
}
```

--------------------------------

### Implement viewDidLoad for Setup

Source: https://docs.nextbillion.ai/docs/navigation/sdk/ios/examples/basic-navigation-app

Implement the viewDidLoad method to perform initial setup when the view controller's view is loaded. This is where you configure the navigation elements.

```swift
override func viewDidLoad() {
       super.viewDidLoad()
```

--------------------------------

### Route Optimization GET Response Example

Source: https://docs.nextbillion.ai/solutions/on-demand-delivery/optimize-multi-delivery-routes

The GET response contains the optimization results, including suggested routes and task assignments for each vehicle.

```json
{
"description": "Optimize Routes",
"result": '{...}'
}
```

--------------------------------

### Route Optimization GET Response Example

Source: https://docs.nextbillion.ai/solutions/on-demand-delivery/group-nearby-orders

The GET response contains the optimization description and the detailed results, including projected locations for grouped orders.

```json
{
"description": "Group Nearby Orders",
"result": '{...}'
}
```

--------------------------------

### NextBillion SDK Initialization and Configuration

Source: https://docs.nextbillion.ai/maps/web-maps-sdk-v2/references/entry

Demonstrates how to initialize the NextBillion SDK by setting the API key and creating a new NBMap instance.

```APIDOC
## NextBillion SDK Initialization and Configuration

### Description
This section shows how to set the API key for the NextBillion SDK and then create a new map instance using the `NBMap` class. It covers essential setup steps for using the SDK.

### Methods

#### `setApiKey(token: null | string)`

*   **Description**: Sets the API key for the web SDK.
*   **Parameters**:
    *   `token` (string): The API key to be set.
*   **Return Value**: void

#### `new NBMap(options: NBMapOptions)`

*   **Description**: Constructs a new NBMap instance.
*   **Parameters**:
    *   `options` (NBMapOptions): An object containing map configuration options.
*   **Return Value**: NBMap

### Example
```javascript
nextbillion.setApiKey("your_api_key");
var map = new nextbillion.maps.Map({
  container: 'map',
  center: [-122.420679, 37.772537],
  zoom: 13,
  style: 'https://api.nextbillion.io/maps/streets/style.json',
  hash: true,
});
```
```

--------------------------------

### Navigation GET Request with Waypoints and Avoidances

Source: https://docs.nextbillion.ai/routing/navigation-api

This example shows a GET request that includes waypoints and specifies preferences to avoid highways and tolls during the navigation.

```APIDOC
## GET /navigation/json with Waypoints and Avoidances

### Description
Customizes a navigation request by adding waypoints and specifying preferences to avoid highways and tolls in the route.

### Method
GET

### Endpoint
https://api.nextbillion.io/navigation/json

### Parameters
#### Query Parameters
- **key** (string) - Required - Your API key.
- **origin** (string) - Required - The starting point of the route (latitude,longitude).
- **destination** (string) - Required - The ending point of the route (latitude,longitude).
- **waypoints** (string) - Optional - A list of intermediate points to pass through (latitude,longitude separated by '|').
- **mode** (string) - Optional - The mode of transportation (e.g., 'car'). Defaults to 'driving'.
- **overview** (string) - Optional - Specifies the level of detail for the route geometry ('simplified', 'full', or 'false'). Defaults to 'false'.
- **avoid** (string) - Optional - Specifies features to avoid in the route, separated by '|' (e.g., 'highway|toll').

### Request Example
```bash
curl --location 'https://api.nextbillion.io/navigation/json?waypoints=34.05264456,-118.24405323&overview=simplified&origin=34.05605379,-118.24495386&destination=34.05023939,-118.24885017&key=<your_api_key>&mode=car&avoid=highway|toll'
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the request ('Ok' or 'Error').
- **routes** (array) - An array containing route information.
```

--------------------------------

### Initialize SDK with Default Configurations

Source: https://docs.nextbillion.ai/tracking/android-tracking-sdk/examples/update-configurations-at-runtime

Set up the initial configurations for the Asset Tracking SDK, including default settings, location tracking, notifications, and data tracking parameters.

```kotlin
defaultConfig = DefaultConfig(
    debug = false,
    enhanceService = true,
    repeatInterval = 5L,
    workerEnabled = true,
    crashRestartEnabled = true,
    workOnMainThread = true,
    restartIntent = null
)

locationConfig = LocationConfig(
    trackingMode = TrackingMode.ACTIVE,
    maxWaitTime = 10000,
    fastestInterval = 1000,
    enableStationaryCheck = false
)

notificationConfig = NotificationConfig(channelId = "Custom.ID", channelName = "Custom.Name")

dataTrackingConfig = DataTrackingConfig(
    baseUrl = "https://api.nextbillion.io",
    dataUploadingBatchSize = 30,
    dataUploadingBatchWindow = 20,
    dataStorageSize = 5000,
    shouldClearLocalDataWhenCollision = true
)

AssetTracking {
    setDefaultConfig(defaultConfig)
    setLocationConfig(locationConfig)
    setNotificationConfig(notificationConfig)
    setDataTrackingConfig(dataTrackingConfig)
}

initialize("PUT YOUR API KEY HERE")
```

--------------------------------

### Create AppDataInitStartup Class for SDK Initialization

Source: https://docs.nextbillion.ai/maps/maps-sdk-jetpack-compose-extension/tutorial

Implement the Initializer interface to create a class that initializes the NextBillion SDK. Replace 'YOUR-ACCESS-KEY' with your actual key. This code runs at application startup.

```kotlin
class AppDataInitStartup : Initializer<Boolean> {

    override fun create(context: Context): Boolean {
        Nextbillion.getInstance(context, "YOUR-ACCESS-KEY")
        return true
    }

    override fun dependencies(): List<Class<out Initializer<*>>> {
        return emptyList()
    }
}
```

--------------------------------

### Snap To Roads GET Request Example 2

Source: https://docs.nextbillion.ai/docs/navigation/api/snap-to-roads

An expanded GET request to obtain geoJSON geometry of the snapped path and a route suitable for a truck.

```curl
curl --location 'https://api.nextbillion.io/snapToRoads/json?key=<your_api_key>&path=34.02632257,-118.31353281|34.05029825,-118.29896811|34.04873267,-118.24571761|34.02951637,-118.23833125&radiuses=20|25|15|30&timestamps=1681834632|1681835232|1681835832|1681836632&mode=truck&geometry=geojson'
```

--------------------------------

### Transition Configuration Example

Source: https://docs.nextbillion.ai/maps/web-maps-sdk-v2/style-specification/root

Defines global transition settings for properties, specifying duration and delay for smooth visual changes.

```json
"transition": { "duration": 300, "delay": 0 }
```

--------------------------------

### Route Optimization GET Response Example

Source: https://docs.nextbillion.ai/solutions/field-services/extend-agent-shift-timings

The GET response indicates if all tasks were assigned and shows the `vehicle_overtime` field detailing any extended work duration by the agent.

```json
{
  "description": "Shift Timings",
  "result": {
      "code": 0,
      "summary": "{...}",
      "routes": "[....]"
  }
}
```

--------------------------------

### Directions Flexible API GET Request

Source: https://docs.nextbillion.ai/routing/directions-api

Example of making a GET request to the Directions Flexible API. Ensure to replace {your_api_key} with your actual API key.

```HTTP
https://api.nextbillion.io/directions/json?option=flexible&key={your_api_key}
```

--------------------------------

### NBMap Widget Example

Source: https://docs.nextbillion.ai/maps/flutter-maps-sdk/getting-started

A complete example demonstrating how to use the NBMap widget within a Flutter StatefulWidget, including handling the onMapCreated callback to get the map controller.

```dart
class MyMapScreen extends StatefulWidget {
  @override
  _MyMapScreenState createState() => _MyMapScreenState();
}

class _MyMapScreenState extends State<MyMapScreen> {
  NextBillionMapController? mapController;

  void onMapCreated(NextBillionMapController controller) {
    mapController = controller;
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('My Map Screen'),
      ),
      body: NBMap(
        onMapCreated: onMapCreated,
        initialCameraPosition: const CameraPosition(
          target: LatLng(-33.894372606072309, 151.17576679759523),
          zoom: 11.0,
        ),
      ),
    );
  }
}
```

--------------------------------

### Basic NBNavigationView Setup

Source: https://docs.nextbillion.ai/routing/flutter-navigation-sdk/usage

Demonstrates the basic setup of the NBNavigationView widget with essential configuration options like route, routes, and theme mode. It also shows how to handle various navigation events.

```dart
NBNavigationView(
  navigationOptions: NavigationLauncherConfig(
    route: selectedRoute,
    routes: allRoutes,
    themeMode: NavigationThemeMode.system,
  ),
  onNavigationViewReady: (controller) {
    // Handle navigation view ready
  },
  onProgressChange: (progress) {
    // Handle progress change
  },
  onNavigationCancelling: () {
    // Handle navigation canceling
  },
  onArriveAtWaypoint: (waypoint) {
    // Handle arriving at waypoint
  },
  onRerouteFromLocation: (location) {
    // Handle rerouting from location
  },
);
```

--------------------------------

### Snap To Roads GET Request Example 1

Source: https://docs.nextbillion.ai/docs/navigation/api/snap-to-roads

A basic GET request to snap 4 coordinate points to the nearest road, including radiuses and timestamps for each point.

```curl
curl --location 'https://api.nextbillion.io/snapToRoads/json?key=<your_api_key>&path=34.02632257,-118.31353281|34.05029825,-118.29896811|34.04873267,-118.24571761|34.02951637,-118.23833125&radiuses=20|25|15|30&timestamps=1681834632|1681835232|1681835832|1681836632'
```

--------------------------------

### Basic Navigation GET Request

Source: https://docs.nextbillion.ai/routing/navigation-api

This example demonstrates a basic GET request to the Navigation API for a car trip between a specified origin and destination, requesting a simplified route overview.

```APIDOC
## GET /navigation/json

### Description
Creates a basic navigation request for a trip by car between a given origin and destination with a simplified overview of the route geometry.

### Method
GET

### Endpoint
https://api.nextbillion.io/navigation/json

### Parameters
#### Query Parameters
- **key** (string) - Required - Your API key.
- **origin** (string) - Required - The starting point of the route (latitude,longitude).
- **destination** (string) - Required - The ending point of the route (latitude,longitude).
- **mode** (string) - Optional - The mode of transportation (e.g., 'car'). Defaults to 'driving'.
- **overview** (string) - Optional - Specifies the level of detail for the route geometry ('simplified', 'full', or 'false'). Defaults to 'false'.

### Request Example
```
https://api.nextbillion.io/navigation/json?key={your_api_key}&origin=34.05605379,-118.24495386&destination=34.05023939,-118.24885017&mode=car&overview=simplified
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the request ('Ok' or 'Error').
- **routes** (array) - An array containing route information.
```

--------------------------------

### Start Navigation with Custom Configuration

Source: https://docs.nextbillion.ai/routing/android-navigation-sdk/examples/customize-navigation-view-ui-elements

This snippet shows how to start navigation with a custom configuration, including setting route information, controlling speedometer visibility, and enabling route simulation. It also demonstrates how to load and modify a backend response before passing it to the navigation view.

```Java
    @Override
    public void onNavigationReady(boolean b) {
        // read original backend response from file
        DirectionsResponse response = DirectionsResponse.fromJson(loadJsonFromAsset());
        // modify the backend response following normal api call process
        DirectionsResponse modifiedResponse = new RequestParamsWrapper().wrapRequestParams(response, RouteRequestParams.builder().build());
        NavViewConfig.Builder config = 
                NavViewConfig.builder().route(modifiedResponse.routes().get(0))
                        // The visibility of speedometer can be set here before starting navigation
                        .showSpeedometer(true)
                        // add this so the exit button in Navigation view would work
                        .navigationListener(this)
                        .shouldSimulateRoute(true);
        navigationView.startNavigation(config.build());
    }
```

--------------------------------

### Configure and Start Navigation

Source: https://docs.nextbillion.ai/routing/flutter-navigation-sdk/usage

Use NavigationLauncherConfig to set up navigation parameters like routes and simulation. Then, call NBNavigation.startNavigation with the configuration to initiate the navigation session.

```dart
NavigationLauncherConfig config = NavigationLauncherConfig(route: routes.first, routes: routes, shouldSimulateRoute: true);
NBNavigation.startNavigation(config);
```

--------------------------------

### Get Zone IDs

Source: https://docs.nextbillion.ai/integrations/geotab/dispatch-routes

Retrieve the zone IDs for the start and end locations from dropdown elements.

```javascript
const startZoneId = select1.value;
const endZoneId = select2.value;
```

--------------------------------

### Optimization GET Request Example

Source: https://docs.nextbillion.ai/optimization/route-optimization-api/tutorials/maximum-waiting-time

This cURL command demonstrates how to retrieve the results of an optimization job using the Optimization GET request. You need to provide the job ID obtained from the POST response and your API key.

```bash
curl --location 'https://api.nextbillion.io/optimization/v2/result?id=233c943dd6da56486f5cf6a36cddc5fa
&key=<your_api_key>'
```

--------------------------------

### Initialize SDK with NextBillion.ai Tiles

Source: https://docs.nextbillion.ai/maps/android-maps-sdk/switching-tile-servers

Set the NextBillion.ai tile server and provide the corresponding access token during SDK initialization.

```java
// Use NextBillion.ai Map Tiles
Nextbillion.getInstance(
    getApplicationContext(),
    accessToken,
    NGLWellKnownTileServer.NGLMapTiler
);
```

--------------------------------

### Sample Weather API Request

Source: https://docs.nextbillion.ai/map-data/weather-api

Example of how to make a request to the Weather API to get data for a specific region.

```shell
curl --location 'https://api.nextbillion.io/map/weather?key=<your_api_key>&region=europe'
```

--------------------------------

### Light Configuration Example

Source: https://docs.nextbillion.ai/maps/web-maps-sdk-v2/style-specification/root

Configures the global light source for the map, including its anchor, color, and intensity.

```json
"light": {  "anchor": "viewport",  "color": "white",  "intensity": 0.4 }
```

--------------------------------

### Initialize SDK with API Key

Source: https://docs.nextbillion.ai/tracking/flutter-tracking-sdk/usage

Initialize the SDK by providing your NextBillion.ai API key for authentication.

```dart
await assetTracking.initialize(apiKey: '<your_api_key>');
```

--------------------------------

### Get Place Response Example

Source: https://docs.nextbillion.ai/docs/places/api/multi-geocode

This is a sample successful response when retrieving place details. It indicates the status and a confirmation message.

```json
{
  "status": 200,
  "msg": "Ok"
}
```

--------------------------------

### Create Asset Example

Source: https://docs.nextbillion.ai/tracking/ios-tracking-sdk/examples/asset-profile-operations

Demonstrates how to create a new asset using the AssetTracking SDK. It includes handling the success response by displaying the JSON string and a failure response with a toast message.

```swift
if let jsonString = String(data: jsonData, encoding: .utf8) {
    self.assetInfo.text = jsonString
} else {
    print("Error converting data to string")
}
```

--------------------------------

### Start Navigation

Source: https://docs.nextbillion.ai/routing/ios-navigation-sdk/map-display-and-navigation

Constructs NavigationOptions using fetched routes and navigation service, then presents a NavigationViewController to begin the navigation session. Optionally sets the delegate for event handling.

```swift
let navigationService = NBNavigationService(routes: routes, routeIndex: 0)

let styles = [DayStyle(), NightStyle()]
let navigationOptions = NavigationOptions(styles:styles, navigationService: navigationService)

let navigationViewController = NavigationViewController(for: routes, navigationOptions: navigationOptions)

navigationViewController.delegate = self

navigationViewController.modalPresentationStyle = .fullScreen

present(navigationViewController, animated: true) {
}
```

--------------------------------

### Get Asset Detail Example

Source: https://docs.nextbillion.ai/tracking/android-tracking-sdk/examples/asset-profile-operations

Retrieves and displays the full details of a bound asset. This operation requires the asset to be bound first.

```kotlin
private fun getAssetDetail() {
        getAssetInfo(object : AssetApiCallback<GetAssetResponse> {
            @SuppressLint("SetTextI18n")
            override fun onSuccess(result: GetAssetResponse) {
                val asset: Asset = result.data.asset
                val assetJsonString = Gson().toJson(asset)
                assetDetailView.text = "full asset info: $assetJsonString"
            }

            override fun onFailure(exception: Exception) {
                val exceptionMessage = exception.message ?: ""
                Toast.makeText(
                    this@AssetProfileOperations,
                    "bind asset failed: $exceptionMessage",
                    Toast.LENGTH_LONG
                ).show()
            }
        })
    }
```

--------------------------------

### Marker Creation and Usage

Source: https://docs.nextbillion.ai/maps/web-maps-sdk-v1/references/marker

Demonstrates how to instantiate a marker with various options and how to interact with its element and methods.

```APIDOC
## Marker

Creates a marker.

### Parameters

- **position** (object) - The coordinates of the marker.
- **map** (object) - The map instance to which the marker attaches to.
- **icon** (string) - Optional. Specifies the icon for the marker. Accepts predefined colors ('green', 'blue', 'black', 'gold', 'grey', 'red', 'orange', 'violet', 'yellow') or a valid image URL. Defaults to 'green'.
- **title** (string) - Optional. Adds an HTML tooltip to the marker that shows on hovering. Defaults to ''. (Not available for NextBillion.ai Maps GL).

### Methods

- **getElement()**: Returns the HTML element of the marker instance.
- **moveTo({lng: number, lat: number}, speed: number)**: Moves the marker to a set of coordinates with animation. `speed` ranges from 0 to 10.
- **remove()**: Removes the marker instance from the map.

### Example

```javascript
var marker = new nextbillion.maps.Marker({
  position: loc,
  map: map,
  title: 'Hello World!',
  icon: 'gold',
});

// To listen to the click events and execute a callback
marker.getElement().addEventListener('click', (event) => {
  console.log('marker clicked', event);
});

// To move the marker to a new set of coordinates
marker.moveTo({ lng: 1, lat: 0 }, 9);
```
```

--------------------------------

### GET /navigation/json (Avoid Sharp Turns)

Source: https://docs.nextbillion.ai/routing/navigation-api

This example demonstrates how to configure a flexible navigation request for a truck to avoid sharp turns.

```APIDOC
## GET /navigation/json (Avoid Sharp Turns)

### Description
This endpoint allows for flexible navigation routing for trucks, with an option to avoid sharp turns for safer travel.

### Method
GET

### Endpoint
https://api.nextbillion.io/navigation/json

### Parameters
#### Query Parameters
- **key** (string) - Required - Your API key.
- **origin** (string) - Required - The starting point coordinates (latitude,longitude).
- **destination** (string) - Required - The ending point coordinates (latitude,longitude).
- **mode** (string) - Required - The mode of transport, e.g., "truck".
- **option** (string) - Required - Set to "flexible" for flexible routing.
- **avoid** (string) - Required - Specifies what to avoid, e.g., "sharp_turn".

### Request Example
```json
curl --location 'https://api.nextbillion.io/navigation/json?key=<your_api_key>&origin=32.75800890,-117.14624755&destination=32.75777097,-117.14546261&mode=truck&option=flexible&avoid=sharp_turn'
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the request, e.g., "Ok".
- **routes** (array) - An array containing route information.
```

--------------------------------

### Reverse Geocode API Request

Source: https://docs.nextbillion.ai/docs/places/api/reverse-geocode

This example demonstrates how to use the Reverse Geocode API to get address details for a specific location.

```APIDOC
## GET /revgeocode

### Description
Returns the detailed address information of a given location coordinate.

### Method
GET

### Endpoint
https://api.nextbillion.io/revgeocode

### Query Parameters
- **at** (string) - Required - The latitude and longitude of the location, separated by a comma (e.g., "36.164760,-115.147690").
- **key** (string) - Required - Your NextBillion.ai API key.

### Request Example
```
curl --location 'https://api.nextbillion.io/revgeocode?at=36.164760,-115.147690&key=<your_api_key>'
```

### Response
#### Success Response (200)
- **items** (array) - Contains a list of address items.
  - **title** (string) - The formatted address string.
  - **id** (string) - A unique identifier for the address.
  - **speedLimit** (string) - The speed limit for the associated road.
  - **address** (object) - Detailed address components.
    - **label** (string) - Formatted address.
    - **countryCode** (string) - ISO 3166-1 alpha-3 country code.
    - **countryName** (string) - Full country name.
    - **stateCode** (string) - State or province code.
    - **state** (string) - State or province name.
    - **county** (string) - County name.
    - **city** (string) - City name.
    - **street** (string) - Street name.
    - **postalCode** (string) - Postal code.
    - **houseNumber** (string) - House number.
  - **position** (object) - The geographic coordinates.
    - **lat** (number) - Latitude.
    - **lng** (number) - Longitude.
  - **access** (array) - Access points for the location.
    - **lat** (number) - Latitude of access point.
    - **lng** (number) - Longitude of access point.
  - **distance** (number) - Distance from the query point to the address.
  - **mapView** (object) - Bounding box for the map view.
    - **west** (number) - Western longitude.
    - **south** (number) - Southern latitude.
    - **east** (number) - Eastern longitude.
    - **north** (number) - Northern latitude.

#### Response Example
```json
{
   "items": [
       {
           "title": "255 East Bonneville Avenue, Las Vegas, NV 89101, United States",
           "id": "orUEyi4DUtelbGzeFXvTeA",
           "speedLimit": "30.00MPH",
           "address": {
               "label": "255 East Bonneville Avenue, Las Vegas, NV 89101, United States",
               "countryCode": "USA",
               "countryName": "United States",
               "stateCode": "NV",
               "state": "Nevada",
               "county": "Clark",
               "city": "Las Vegas",
               "street": "East Bonneville Avenue",
               "postalCode": "89101",
               "houseNumber": "255"
           },
           "position": {
               "lat": 36.164551,
               "lng": -115.147057
           },
           "access": [
               {
                   "lat": 36.164551,
                   "lng": -115.147057
               }
           ],
           "distance": 61,
           "mapView": {
               "west": -115.147807,
               "south": 36.164413,
               "east": -115.146727,
               "north": 36.164873
           }
       }
   ]
}
```
```

--------------------------------

### Initialize SDK

Source: https://docs.nextbillion.ai/docs/tracking/sdk/android-tracking/getting-started

Initialize the NextBillion.ai SDK with your access key in your Application's onCreate() callback or before using any SDK features. Replace 'YOUR_ACCESS_KEY' with your actual key.

```kotlin
AssetTracking {
   setDefaultConfig(
       DefaultConfig()
   )
   setLocationConfig(
       LocationConfig()
   )
   setNotificationConfig(
       NotificationConfig()
   )
   setDataTrackingConfig(
       DataTrackingConfig()
   )
   initialize("YOUR_ACCESS_KEY")
}
```

--------------------------------

### Geocoding API Request Example

Source: https://docs.nextbillion.ai/places/places-tt-orbis/geocoding-api

This example shows how to make a GET request to the Geocoding API to find an address in Boston, Massachusetts. It includes parameters for the API key, search query, a radius around a specific point, country code, and language.

```curl
curl --location 'https://api.nextbillion.io/orbis/geocode?key=<your_api_key>&in=circle:42.3148375,-71.0353054;r=100&q=Columbia Point, Dorchester&in=countryCode:USA&lang=en-US&'
```

--------------------------------

### Fetch Route and Start Navigation with Custom Style

Source: https://docs.nextbillion.ai/routing/android-navigation-sdk/examples/customize-instruction-list-style

This activity fetches a route and then starts navigation, applying custom themes for the instruction list. It requires setting up theme resources for light and dark modes.

```java
package ai.nextbillion.navigation.demo.activity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;

import ai.nextbillion.kits.directions.models.DirectionsResponse;
import ai.nextbillion.kits.directions.models.DirectionsRoute;
import ai.nextbillion.kits.geojson.Point;
import ai.nextbillion.maps.location.modes.RenderMode;
import ai.nextbillion.navigation.demo.R;
import ai.nextbillion.navigation.ui.NBNavigation;
import ai.nextbillion.navigation.ui.NavLauncherConfig;
import ai.nextbillion.navigation.ui.NavigationLauncher;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public class CustomInstructionListStyleActivity extends AppCompatActivity implements View.OnClickListener {

    private Button fetchRoute;
    private Button startNav;
    private TextView routeGeometry;
    private DirectionsRoute directionsRoute;
    private ProgressBar progress;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_custom_instruction_list_style);
        fetchRoute = findViewById(R.id.fetchRoute);
        startNav = findViewById(R.id.startNav);
        routeGeometry = findViewById(R.id.routeGeometry);
        progress = findViewById(R.id.progress);
        fetchRoute.setOnClickListener(this);
        startNav.setOnClickListener(this);
        startNav.setEnabled(false);
    }

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.fetchRoute) {
            progress.setVisibility(View.VISIBLE);
            Point origin = Point.fromLngLat(103.75986708439264, 1.312533169133601);
            Point destination = Point.fromLngLat(103.77982271935586, 1.310473772283314);

            NBNavigation.fetchRoute(origin, destination, new Callback<DirectionsResponse>() {
                @Override
                public void onResponse(@NonNull Call<DirectionsResponse> call, @NonNull Response<DirectionsResponse> response) {
                    progress.setVisibility(View.GONE);
                    //start navigation with the route we just fetched.
                    if (response.body() != null && !response.body().routes().isEmpty()) {
                        directionsRoute = response.body().routes().get(0);
                        routeGeometry.setText(String.format("Route Geometry: %s", directionsRoute.geometry()));
                        startNav.setEnabled(true);
                    }
                }

                @Override
                public void onFailure(@NonNull Call<DirectionsResponse> call, @NonNull Throwable t) {
                    progress.setVisibility(View.GONE);
                }
            });
        } else if (view.getId() == R.id.startNav) {
            NavLauncherConfig.Builder configBuilder = NavLauncherConfig.builder(directionsRoute);
            configBuilder.locationLayerRenderMode(RenderMode.GPS);
            configBuilder.shouldSimulateRoute(true);
            configBuilder.lightThemeResId(R.style.Theme_CustomNavInstructionList);
			configBuilder.darkThemeResId(R.style.Theme_CustomNavInstructionListDark);
            NavigationLauncher.startNavigation(CustomInstructionListStyleActivity.this, configBuilder.build());
        }
    }
}

```

--------------------------------

### Initialize Map and UI Elements

Source: https://docs.nextbillion.ai/routing/android-navigation-sdk/examples/draw-route-line-with-alternative-routes

Sets up the MapView, fetches UI elements, and initializes the NavNextbillionMap. The map is ready to be used after the style is loaded.

```java
private Button fetchRoute;
    private Button fetchRouteWithoutDuration;
    private Button startNav;
    private DirectionsRoute directionsRoute;
    private List<DirectionsRoute> directionsRoutes;
    private ProgressBar progress;
    boolean showRouteDurationSymbol = true;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_draw_route_line_with_alt);
        mapView = findViewById(R.id.mapView);
        mapView.onCreate(savedInstanceState);
        mapView.getMapAsync(this);
        fetchRoute = findViewById(R.id.fetchRoute);
        startNav = findViewById(R.id.startNav);
        progress = findViewById(R.id.progress);
        fetchRoute.setOnClickListener(this);
        startNav.setOnClickListener(this);
        fetchRouteWithoutDuration.setOnClickListener(this);
        fetchRouteWithoutDuration.setEnabled(false);
        startNav.setEnabled(false);
        fetchRoute.setEnabled(false);
    }


    @Override
    public void onMapReady(@NonNull NextbillionMap nextbillionMap) {
        nextbillionMap.getStyle(style -> {
            navMap = new NavNextbillionMap(mapView, nextbillionMap);
            CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngZoom(new LatLng(origin.latitude(),origin.longitude()), DEFAULT_CAMERA_ZOOM);
            NavigationCameraUpdate navigationCameraUpdate = new NavigationCameraUpdate(cameraUpdate);
            navigationCameraUpdate.setMode(CameraUpdateMode.OVERRIDE);
            navMap.retrieveCamera().update(navigationCameraUpdate, 1000);
            fetchRoute.setEnabled(true);
            fetchRouteWithoutDuration.setEnabled(true);
        });
    }
```
Tokens:
Raw