title: Get latitude and longitude from onSuccess(LocationEngineResult result)
body: <p>I get user current location by using override method </p>
  
  <pre><code>     public void onSuccess(LocationEngineResult result) {
       location = Point.fromLngLat(result.getLastLocation().getLongitude(),result.getLastLocation().getLatitude());
      }
  
  </code></pre>
  
  <p>but I don't know how to replace the latitude and longitude on variable </p>
  
  <pre><code>private final Point ROUTE_ORIGIN=Point.fromLngLat(location.longitude(),location.latitude());
  </code></pre>
  
  <p>with the location i get from public void <code>onSuccess(LocationEngineResult result)</code> is there any solution for this? </p>
  
  <p>The app crashed with error</p>
  
  <pre><code>Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'double com.mapbox.geojson.Point.longitude()' on a null object reference
  </code></pre>
  
  <p>Can anyone give me some idea or solution? I tried to find sources but still can't solve it. </p>
  
  <pre class="lang-java prettyprint-override"><code>    public class ArActivity extends BaseActivity implements RouteListener, ProgressChangeListener, OffRouteListener {
  
      private static final String TAG = ArActivity.class.getSimpleName();
  
      // Handles navigation.
      private MapboxNavigation mapboxNavigation;
      // Fetches route from points.
      private RouteFetcher routeFetcher;
      private RouteProgress lastRouteProgress;
      private PermissionsManager permissionsManager;
      private LocationEngine locationEngine;
  
      private LocationEngineCallback&lt;LocationEngineResult&gt; locationCallback;
      public Point location;
  
      private boolean visionManagerWasInit = false;
      private boolean navigationWasStarted = false;
      TextView tvlocation;
  
      // This dummy points will be used to build route. For real world test this needs to be changed to real values for
      // source and target location
      private final Point ROUTE_ORIGIN=Point.fromLngLat(location.longitude(),location.latitude());
      private final Point ROUTE_DESTINATION = Point.fromLngLat(101.769116, 2.923220);
  
      @Override
      protected void initViews() {
  
          setContentView(R.layout.activity_ar_navigation);
          tvlocation = findViewById(R.id.location);
  
      }
  
      @Override
      protected void onPermissionsGranted() {
          startVisionManager();
          startNavigation();
  
      }
  
      @Override
      protected void onStart() {
          super.onStart();
          startVisionManager();
          startNavigation();
  
      }
  
      @Override
      protected void onStop() {
          super.onStop();
          stopVisionManager();
          stopNavigation();
      }
  
      private void startVisionManager() {
          if (allPermissionsGranted() &amp;&amp; !visionManagerWasInit) {
              // Create and start VisionManager.
  
              VisionManager.create();
              VisionManager.setModelPerformanceConfig(new Merged(new On(ModelPerformanceMode.DYNAMIC, ModelPerformanceRate.LOW)));
              VisionManager.start();
              VisionManager.setVisionEventsListener(new VisionEventsListener() {
                  @Override
                  public void onAuthorizationStatusUpdated(@NotNull AuthorizationStatus authorizationStatus) {
                  }
  
                  @Override
                  public void onFrameSegmentationUpdated(@NotNull FrameSegmentation frameSegmentation) {
                  }
  
                  @Override
                  public void onFrameDetectionsUpdated(@NotNull FrameDetections frameDetections) {
                  }
  
                  @Override
                  public void onFrameSignClassificationsUpdated(@NotNull FrameSignClassifications frameSignClassifications) {
                  }
  
                  @Override
                  public void onRoadDescriptionUpdated(@NotNull RoadDescription roadDescription) {
                  }
  
                  @Override
                  public void onWorldDescriptionUpdated(@NotNull WorldDescription worldDescription) {
                  }
  
                  @Override
                  public void onVehicleStateUpdated(@NotNull VehicleState vehicleState) {
                  }
  
                  @Override
                  public void onCameraUpdated(@NotNull Camera camera) {
                  }
  
                  @Override
                  public void onCountryUpdated(@NotNull Country country) {
                  }
  
                  @Override
                  public void onUpdateCompleted() {
                  }
              });
  
              VisionArView visionArView = findViewById(R.id.mapbox_ar_view);
  
              // Create VisionArManager.
              VisionArManager.create(VisionManager.INSTANCE);
              visionArView.setArManager(VisionArManager.INSTANCE);
              visionArView.setFenceVisible(true);
              visionManagerWasInit = true;
          }
      }
  
      private void stopVisionManager() {
          if (visionManagerWasInit) {
              VisionArManager.destroy();
              VisionManager.stop();
              VisionManager.destroy();
              visionManagerWasInit = false;
          }
      }
  
      private void startNavigation() {
          if (allPermissionsGranted() &amp;&amp; !navigationWasStarted) {
              // Initialize navigation with your Mapbox access token.
              mapboxNavigation = new MapboxNavigation(
                      this,
                      getString(R.string.mapbox_access_token),
                      MapboxNavigationOptions.builder().build()
              );
  
              // Initialize route fetcher with your Mapbox access token.
              routeFetcher = new RouteFetcher(this, getString(R.string.mapbox_access_token));
              routeFetcher.addRouteListener(this);
  
              locationEngine = LocationEngineProvider.getBestLocationEngine(this);
  
              LocationEngineRequest arLocationEngineRequest = new LocationEngineRequest.Builder(0)
                      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
                      .setFastestInterval(1000)
                      .build();
  
  
              locationCallback = new LocationEngineCallback&lt;LocationEngineResult&gt; () {
                  @Override
                  public void onSuccess(LocationEngineResult result) {
  
                          location = Point.fromLngLat(result.getLastLocation().getLongitude(),result.getLastLocation().getLatitude());
                                         }
  
                  @Override
                  public void onFailure(@NonNull Exception exception) {
  
                  }
              };
  
              try {
                  locationEngine.requestLocationUpdates(arLocationEngineRequest, locationCallback, Looper.getMainLooper());
              } catch (SecurityException se) {
                  VisionLogger.Companion.e(TAG, se.toString());
              }
  
              initDirectionsRoute();
  
              // Route need to be reestablished if off route happens.
              mapboxNavigation.addOffRouteListener(this);
              mapboxNavigation.addProgressChangeListener(this);
  
              navigationWasStarted = true;
          }
      }
  
      private void stopNavigation() {
          if (navigationWasStarted) {
              locationEngine.removeLocationUpdates(locationCallback);
  
              mapboxNavigation.removeProgressChangeListener(this);
              mapboxNavigation.removeOffRouteListener(this);
              mapboxNavigation.stopNavigation();
  
              navigationWasStarted = false;
          }
      }
  
      private void initDirectionsRoute() {
          // Get route from predefined points.
          NavigationRoute.builder(this)
                  .accessToken(getString(R.string.mapbox_access_token))
                  .origin(ROUTE_ORIGIN)
                  .destination(ROUTE_DESTINATION)
                  .build()
                  .getRoute(new Callback&lt;DirectionsResponse&gt;() {
                      @Override
                      public void onResponse(Call&lt;DirectionsResponse&gt; call, Response&lt;DirectionsResponse&gt; response) {
                          if (response.body() == null || response.body().routes().isEmpty()) {
                              return;
                          }
  
                          // Start navigation session with retrieved route.
                          DirectionsRoute route = response.body().routes().get(0);
                          mapboxNavigation.startNavigation(route);
  
                          // Set route progress.
                          VisionArManager.setRoute(new Route(
                                  getRoutePoints(route),
                                  route.duration().floatValue(),
                                  "",
                                  ""
                          ));
                      }
  
                      @Override
                      public void onFailure(Call&lt;DirectionsResponse&gt; call, Throwable t) {
                      }
                  });
      }
  
      @Override
      public void onErrorReceived(Throwable throwable) {
          if (throwable != null) {
              throwable.printStackTrace();
          }
  
          mapboxNavigation.stopNavigation();
          Toast.makeText(this, "Can not calculate the route requested", Toast.LENGTH_SHORT).show();
      }
  
      @Override
      public void onResponseReceived(@NotNull DirectionsResponse response, RouteProgress routeProgress) {
          mapboxNavigation.stopNavigation();
          if (response.routes().isEmpty()) {
              Toast.makeText(this, "Can not calculate the route requested", Toast.LENGTH_SHORT).show();
          } else {
              DirectionsRoute route = response.routes().get(0);
  
              mapboxNavigation.startNavigation(route);
  
              // Set route progress.
              VisionArManager.setRoute(new Route(
                      getRoutePoints(route),
                      (float) routeProgress.durationRemaining(),
                      "",
                      ""
              ));
          }
      }
  
      @Override
      public void onProgressChange(Location location, RouteProgress routeProgress) {
          lastRouteProgress = routeProgress;
      }
  
      @Override
      public void userOffRoute(Location location) {
          routeFetcher.findRouteFromRouteProgress(location, lastRouteProgress);
      }
  
  
  
      private RoutePoint[] getRoutePoints(@NotNull DirectionsRoute route) {
          ArrayList&lt;RoutePoint&gt; routePoints = new ArrayList&lt;&gt;();
  
          List&lt;RouteLeg&gt; legs = route.legs();
          if (legs != null) {
              for (RouteLeg leg : legs) {
  
                  List&lt;LegStep&gt; steps = leg.steps();
                  if (steps != null) {
                      for (LegStep step : steps) {
                          RoutePoint point = new RoutePoint((new GeoCoordinate(
                                  step.maneuver().location().latitude(),
                                  step.maneuver().location().longitude()
                          )), mapToManeuverType(step.maneuver().type()));
  
                          routePoints.add(point);
  
                          List&lt;Point&gt; geometryPoints = buildStepPointsFromGeometry(step.geometry());
                          for (Point geometryPoint : geometryPoints) {
                              point = new RoutePoint((new GeoCoordinate(
                                      geometryPoint.latitude(),
                                      geometryPoint.longitude()
                              )), ManeuverType.None);
  
                              routePoints.add(point);
                          }
                      }
                  }
              }
          }
  
          return routePoints.toArray(new RoutePoint[0]);
      }
  
      private List&lt;Point&gt; buildStepPointsFromGeometry(String geometry) {
          return PolylineUtils.decode(geometry, Constants.PRECISION_6);
      }
  
      private ManeuverType mapToManeuverType(@Nullable String maneuver) {
          if (maneuver == null) {
              return ManeuverType.None;
          }
          switch (maneuver) {
              case "turn":
                  return ManeuverType.Turn;
              case "depart":
                  return ManeuverType.Depart;
              case "arrive":
                  return ManeuverType.Arrive;
              case "merge":
                  return ManeuverType.Merge;
              case "on ramp":
                  return ManeuverType.OnRamp;
              case "off ramp":
                  return ManeuverType.OffRamp;
              case "fork":
                  return ManeuverType.Fork;
              case "roundabout":
                  return ManeuverType.Roundabout;
              case "exit roundabout":
                  return ManeuverType.RoundaboutExit;
              case "end of road":
                  return ManeuverType.EndOfRoad;
              case "new name":
                  return ManeuverType.NewName;
              case "continue":
                  return ManeuverType.Continue;
              case "rotary":
                  return ManeuverType.Rotary;
              case "roundabout turn":
                  return ManeuverType.RoundaboutTurn;
              case "notification":
                  return ManeuverType.Notification;
              case "exit rotary":
                  return ManeuverType.RotaryExit;
              default:
                  return ManeuverType.None;
          }
      }
  </code></pre>