如何从另一项活动开始turn by turn NavigationLauncher

Question

我正在尝试从另一个活动启动NavigationLauncher.startNavigation，但无法这样做。我在第二个活动中有一个按钮，我想用它来开始导航。欢迎提出任何建议。谢谢

下面是我的代码：

/* 
fabstart.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        boolean simulateRoute = false;
        NavigationLauncherOptions options = NavigationLauncherOptions.builder()
            .directionsRoute(route)
            .shouldSimulateRoute(simulateRoute)
            .build();
        // Call this method with Context from within an Activity
        NavigationLauncher.startNavigation(MainActivity.this, options);

    }
});
*/
fabstart.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent intent = new Intent(MainActivity.this, Before_Go.class);
        startActivity(intent);

        // Here is where I want to go to a new activity, inside this activity have a button to
        // launch the "NavigationLauncher.startNavigation"
    }
});

Answer 1

NavigationLauncher.startnavigation()打开一个处理导航的新活动。因此，从哪里调用它并不重要。但是，无论从何处调用，都必须定义NavigationLauncher，并且作为第二个参数传递的options对象必须包含directionsRoute对象。

你能分享你调用它的活动的代码，以及你是如何初始化和定义options对象的吗？

Answer 2

感谢您对我的问题的回复。我是stakoverflow的新手，所以我希望我的这篇额外的代码是正确的。

MainActivity

public class MainActivity extends AppCompatActivity implements OnMapReadyCallback, PermissionsListener,
        MapboxMap.OnMapLongClickListener, OnRouteSelectionChangeListener {

    private static final int REQUEST_CODE_AUTOCOMPLETE = 1;
    private static final int ONE_HUNDRED_MILLISECONDS = 100;
    //private static final String DROPPED_MARKER_LAYER_ID = "DROPPED_MARKER_LAYER_ID";

    //Mapbox
    private MapView mapView;
    private MapboxMap mapboxMap;
    private LocationComponent locationComponent;
    private PermissionsManager permissionsManager;
    private LocationEngine locationEngine;
    private long DEFAULT_INTERVAL_IN_MILLISECONDS = 1000L;
    private long DEFAULT_MAX_WAIT_TIME = DEFAULT_INTERVAL_IN_MILLISECONDS * 5;
    private final MainActivityLocationCallback callback = new MainActivityLocationCallback(this);
    private NavigationMapRoute mapRoute;
    private DirectionsRoute route;

    private String symbolIconId = "symbolIconId";
    private String geojsonSourceLayerId = "geojsonSourceLayerId";
    private StyleCycle styleCycle = new StyleCycle();
    CarmenFeature selectedCarmenFeature;
    CarmenFeature feature;
    Layer layer;

    private static final String TAG = "DirectionsActivity";

  

    // variables
    private FloatingActionButton fablocation;
    private FloatingActionButton fabstart;
    private FloatingActionButton fabRemoveRoute;
    private FloatingActionButton fabStyles;
    private TextView search;
    private TextView kmDisplay;
    private TextView timeDisplay;



    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);


        Mapbox.getInstance(this, getString(R.string.access_token));

        setContentView(R.layout.activity_main);
        mapView = findViewById(R.id.mapView);
        mapView.onCreate(savedInstanceState);
        mapView.getMapAsync(this);

        search=findViewById(R.id.search);
        kmDisplay = findViewById(R.id.kmDisplay);
        timeDisplay = findViewById(R.id.timeDisplay);
        fablocation=findViewById(R.id.fabLocation);
        fabstart=findViewById(R.id.fabStart);
        fabRemoveRoute=findViewById(R.id.fabRemoveRoute);
        fabStyles=findViewById(R.id.fabStyles);

        fablocation.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                Location lastKnownLocation = mapboxMap.getLocationComponent().getLastKnownLocation();

                // Move map camera back to current device location
                mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(
                        new CameraPosition.Builder()
                                .target(new LatLng(lastKnownLocation.getLatitude(), lastKnownLocation.getLongitude()))
                                .zoom(15)
                                .build()), 3000);

            }
        });


    }



    @Override
    public boolean onMapLongClick(@NonNull LatLng point) {
        vibrate();


        Point destinationPoint = Point.fromLngLat(point.getLongitude(), point.getLatitude());
        Point originPoint = Point.fromLngLat(locationComponent.getLastKnownLocation().getLongitude(),
                locationComponent.getLastKnownLocation().getLatitude());

        GeoJsonSource source = mapboxMap.getStyle().getSourceAs("destination-source-id");
        if (source != null) {
            source.setGeoJson(Feature.fromGeometry(destinationPoint));
        } else {

            // Use the map camera target's coordinates to make a reverse geocoding search
            reverseGeocode(Point.fromLngLat(point.getLongitude(), point.getLatitude()));
        }

        getRoute(originPoint, destinationPoint);

        if(destinationPoint !=originPoint) {

            

            fabRemoveRoute.setOnClickListener(new View.OnClickListener() {
                @SuppressLint("RestrictedApi")
                @Override
                public void onClick(View view) {
                    removeRouteAndMarkers();
                    fabstart.setVisibility(View.INVISIBLE);
                    fabRemoveRoute.setVisibility(View.INVISIBLE);
                    //fablocation.setVisibility(View.INVISIBLE);
                    kmDisplay.setText("");
                    timeDisplay.setText("");
                    search.setText(String.format(getString(R.string.hint_where_to)));


                    Location lastKnownLocation = mapboxMap.getLocationComponent().getLastKnownLocation();

                    // Move map camera back to current device location
                    mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(
                            new CameraPosition.Builder()
                                    .target(new LatLng(lastKnownLocation.getLatitude(), lastKnownLocation.getLongitude()))
                                    .zoom(15)
                                    .build()), 3000);
                }
            });


        }
        //imageView.setEnabled(true);
        //imageView.setBackgroundResource(R.color.mapboxBlue);

        return true;
    }

    private void getRoute(Point origin, Point destination) {
        NavigationRoute.builder(this)
                .accessToken(Mapbox.getAccessToken())
                .origin(origin)
                .destination(destination)
                .voiceUnits(DirectionsCriteria.METRIC)
                .alternatives(true)
                .build()
                .getRoute(new Callback<DirectionsResponse>() {
                    @SuppressLint("RestrictedApi")
                    @Override
                    public void onResponse(Call<DirectionsResponse> call, Response<DirectionsResponse> response) {
// You can get the generic HTTP info about the response
                        if (response.isSuccessful()
                                && response.body() != null
                                && !response.body().routes().isEmpty()) {
                            List<DirectionsRoute> routes = response.body().routes();
                            mapRoute.addRoutes(routes);
                            //routeLoading.setVisibility(View.INVISIBLE);
                            fabRemoveRoute.setVisibility(View.VISIBLE);
                            fablocation.setVisibility(View.VISIBLE);
                            fabstart.setVisibility(View.VISIBLE);

                            route = response.body().routes().get(0);

                            routeCalcs();
   
                        }

                        // Once you have the route zoom the camera out to show the route within the bounds of the device
                        mapboxMap.easeCamera(CameraUpdateFactory.newLatLngBounds(
                                new LatLngBounds.Builder()
                                        .include(new LatLng(origin.latitude(), origin.longitude()))
                                        .include(new LatLng(destination.latitude(), destination.longitude()))
                                        .build(), 150), 4000);

                  }

                    @Override
                    public void onFailure(Call<DirectionsResponse> call, Throwable throwable) {
                        Log.e(TAG, "Error: " + throwable.getMessage());
                    }
                });
    }

    private void removeRouteAndMarkers() {
        mapRoute.removeRoute();
        toggleLayer();

    }

    @Override
    public void onNewPrimaryRouteSelected(DirectionsRoute directionsRoute) {

        route = directionsRoute;
        routeCalcs();
    }



    private void routeCalcs(){

        // rounds the kilometer to zero decimals
        kmDisplay.setText((int) Math.ceil(route.distance()/1000) + " km");
        //Log.d(TAG1,(int) Math.ceil(currentRoute.distance()/1000) + " km");


        // This converts to output of duration() in seconds to minutes and hours format
        int minutes = (int) (route.duration() / 60);
          
        long hour = TimeUnit.MINUTES.toHours(minutes);
        long remainMinute = minutes - TimeUnit.HOURS.toMinutes(hour);

        if (hour >= 1) {

            timeDisplay.setText(String.format(getString(R.string.hours_textview),hour)
                    + String.format(getString(R.string.minutes_textview),remainMinute));


        } else {

            timeDisplay.setText(String.format(getString(R.string.minutes_textview), remainMinute));

        }
    }


    private void reverseGeocode(Point point) {

        if (selectedCarmenFeature == null) {

            try {
                MapboxGeocoding client = MapboxGeocoding.builder()
                        .accessToken(getString(R.string.access_token))
                        .query(Point.fromLngLat(point.longitude(), point.latitude()))
                        .geocodingTypes(GeocodingCriteria.TYPE_ADDRESS)
                        .build();

                client.enqueueCall(new Callback<GeocodingResponse>() {
                    @Override
                    public void onResponse(Call<GeocodingResponse> call, Response<GeocodingResponse> response) {

                        if (response.body() != null) {
                            List<CarmenFeature> results = response.body().features();
                            if (results.size() > 0) {
                                feature = results.get(0);

// If the geocoder returns a result, we take the first in the list and show a Toast with the place name.
                                mapboxMap.getStyle(new Style.OnStyleLoaded() {
                                    @Override
                                    public void onStyleLoaded(@NonNull Style style) {
                                        if (style.getLayer("SYMBOL_LAYER_ID") != null) {
                       
                                            search.setText(feature.placeName());
                                        }
                                    }
                                });

                            } else {
                                Toast.makeText(MainActivity.this,
                                        getString(R.string.location_picker_dropped_marker_snippet_no_results), Toast.LENGTH_SHORT).show();
                            }
                        }
                    }

                    @Override
                    public void onFailure(Call<GeocodingResponse> call, Throwable throwable) {
                        Timber.e("Geocoding Failure: %s", throwable.getMessage());
                    }
                });
            } catch (ServicesException servicesException) {
                Timber.e("Error geocoding: %s", servicesException.toString());
                servicesException.printStackTrace();
            }
        }
    }


    @Override
    public void onMapReady(@NonNull MapboxMap mapboxMap) {
        this.mapboxMap = mapboxMap;

        mapboxMap.setStyle(Style.MAPBOX_STREETS, new Style.OnStyleLoaded() {

            @Override
            public void onStyleLoaded(@NonNull Style style){
                mapRoute = new NavigationMapRoute(null, mapView, mapboxMap);
                mapRoute.setOnRouteSelectionChangeListener(MainActivity.this::onNewPrimaryRouteSelected);
                mapboxMap.addOnMapLongClickListener(MainActivity.this);
                initializeLocationComponent(style);


                // Add the symbol layer icon to map for future use
                style.addImage(symbolIconId, BitmapFactory.decodeResource(
                        MainActivity.this.getResources(), R.drawable.mapbox_marker_icon_default));

                // Create an empty GeoJSON source using the empty feature collection
                setUpSource(style);

                // Set up a new symbol layer for displaying the searched location's feature coordinates
                setupLayer(style);

                fabStyles.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        if (mapboxMap != null) {
                            mapboxMap.setStyle(styleCycle.getNextStyle());


                        }
                    }
                });

                initSearchFab(); 

            }
        });

        // This is the code in the docs, but this launches the turn by turn navigation inside this activity
        // and this is not what I need

/*        fabstart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                boolean simulateRoute = false;
                NavigationLauncherOptions options = NavigationLauncherOptions.builder()
                        .directionsRoute(route)
                        .shouldSimulateRoute(simulateRoute)
                        .build();
                // Call this method with Context from within an Activity
                NavigationLauncher.startNavigation(MainActivity.this, options);

            }
        });*/

        fabstart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, Before_Go.class);
                startActivity(intent);

                // Here is where I want to go to a new activity, inside this activity have a button to
                // launch the "NavigationLauncher.startNavigation"
            }
        });


    }
  
    private static class StyleCycle {
        private static final String[] STYLES = new String[] {
                Style.MAPBOX_STREETS,
                Style.OUTDOORS,
                Style.LIGHT,
                Style.DARK,
                //Style.SATELLITE_STREETS,
                Style.TRAFFIC_DAY,
                Style.TRAFFIC_NIGHT
        };

        private int index;

        private String getNextStyle() {
            index++;
            if (index == STYLES.length) {
                index = 0;
            }
            return getStyle();
        }

        private String getStyle() {
            return STYLES[index];
        }
    }

    private void initSearchFab() {

        findViewById(R.id.search).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new PlaceAutocomplete.IntentBuilder()
                        .accessToken(Mapbox.getAccessToken())
                        .placeOptions(PlaceOptions.builder()
                                .backgroundColor(Color.parseColor("#EEEEEE"))
                                .limit(10)
                                //.addInjectedFeature(home)
                                //.addInjectedFeature(work)
                                .build(PlaceOptions.MODE_CARDS))
                        .build(MainActivity.this);
                startActivityForResult(intent, REQUEST_CODE_AUTOCOMPLETE);

            }

        });
    }

    @SuppressWarnings( {"MissingPermission"})
    private void initializeLocationComponent(@NonNull Style loadedMapStyle) {

        // Check if permissions are enabled and if not request
        if (PermissionsManager.areLocationPermissionsGranted(this)) {

            locationComponent = mapboxMap.getLocationComponent();
            // Set the LocationComponent activation options
            LocationComponentActivationOptions locationComponentActivationOptions =
                    LocationComponentActivationOptions.builder(this, loadedMapStyle)
                            .useDefaultLocationEngine(false)
                            .build();


            // Activate with the LocationComponentActivationOptions object
            locationComponent.activateLocationComponent(locationComponentActivationOptions);
            locationComponent.setLocationComponentEnabled(true);
            locationComponent.setRenderMode(RenderMode.NORMAL);
            locationComponent.setCameraMode(CameraMode.TRACKING);
            //locationComponent.zoomWhileTracking(10d);

            initLocationEngine();

        } else {

            permissionsManager = new PermissionsManager(this);
            permissionsManager.requestLocationPermissions(this);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == Activity.RESULT_OK && requestCode == REQUEST_CODE_AUTOCOMPLETE) {

            // Retrieve selected location's CarmenFeature
            selectedCarmenFeature = PlaceAutocomplete.getPlace(data);
            search.setText(selectedCarmenFeature.placeName());

            // Create a new FeatureCollection and add a new Feature to it using selectedCarmenFeature above.
            // Then retrieve and update the source designated for showing a selected location's symbol layer icon

            if (mapboxMap != null) {
                Style style = mapboxMap.getStyle();
                if (style != null) {
                    GeoJsonSource source = style.getSourceAs(geojsonSourceLayerId);
                    if (source != null) {
                        source.setGeoJson(FeatureCollection.fromFeatures(
                                new Feature[] {Feature.fromJson(selectedCarmenFeature.toJson())}));
                    }

                    // Move map camera to the selected location
                    mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(
                            new CameraPosition.Builder()
                                    .target(new LatLng(((Point) selectedCarmenFeature.geometry()).latitude(),
                                            ((Point) selectedCarmenFeature.geometry()).longitude()))
                                    .zoom(14)
                                    .build()), 4000);

                }
            }
        }
    }  

    @SuppressLint("MissingPermission")
    private void vibrate() {
        Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
        if (vibrator == null) {
            return;
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            vibrator.vibrate(VibrationEffect.createOneShot(ONE_HUNDRED_MILLISECONDS, VibrationEffect.DEFAULT_AMPLITUDE));
        } else {
            vibrator.vibrate(ONE_HUNDRED_MILLISECONDS);
        }
    }

    /**
     * Set up the LocationEngine and the parameters for querying the device's location
     */
    @SuppressLint("MissingPermission")
    private void initLocationEngine() {
        locationEngine = LocationEngineProvider.getBestLocationEngine(this);

        LocationEngineRequest request = new LocationEngineRequest.Builder(DEFAULT_INTERVAL_IN_MILLISECONDS)
                .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
                .setMaxWaitTime(DEFAULT_MAX_WAIT_TIME).build();

        locationEngine.requestLocationUpdates(request, callback, getMainLooper());
        locationEngine.getLastLocation(callback);
    }

    @Override
    public void onExplanationNeeded(List<String> permissionsToExplain) {
        Toast.makeText(this, R.string.user_location_permission_explanation, Toast.LENGTH_LONG).show();
    }

    @Override
    public void onPermissionResult(boolean granted) {
        if (granted) {
            if (mapboxMap.getStyle() != null) {
                initializeLocationComponent(mapboxMap.getStyle());
            }
        } else {
            Toast.makeText(this, R.string.user_location_permission_not_granted, Toast.LENGTH_LONG).show();
            finish();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        permissionsManager.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    private static class MainActivityLocationCallback
            implements LocationEngineCallback<LocationEngineResult> {

        private final WeakReference<MainActivity> activityWeakReference;

        MainActivityLocationCallback(MainActivity activity) {
            this.activityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void onSuccess(LocationEngineResult result) {
            MainActivity activity = activityWeakReference.get();
            if (activity != null) {
                Location location = result.getLastLocation();
                if (location == null) {
                    return;
                }
                if (activity.mapboxMap != null && result.getLastLocation() != null) {
                    activity.mapboxMap.getLocationComponent().forceLocationUpdate(result.getLastLocation());
                }
            }
        }

        @Override
        public void onFailure(@NonNull Exception exception) {
            Timber.d(exception.getLocalizedMessage());
            MainActivity activity = activityWeakReference.get();
            if (activity != null) {
                Toast.makeText(activity, exception.getLocalizedMessage(),
                        Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * Adds the GeoJSON source to the map
     */
    private void setUpSource(@NonNull Style loadedMapStyle) {
        loadedMapStyle.addSource(new GeoJsonSource(geojsonSourceLayerId));
    }

    /**
     * Setup a layer with maki icons, eg. west coast city.
     */
    private void setupLayer(@NonNull Style loadedMapStyle) {
        loadedMapStyle.addLayer(new SymbolLayer("SYMBOL_LAYER_ID", geojsonSourceLayerId).withProperties(
                iconImage(symbolIconId),
                iconOffset(new Float[] {0f, -8f})
        ));


    }

    // This method will remove the destination icon
    private void toggleLayer() {
        mapboxMap.getStyle(new Style.OnStyleLoaded() {
            @Override
            public void onStyleLoaded(@NonNull Style style) {
                layer = style.getLayer("SYMBOL_LAYER_ID");
                if (layer != null) {
                    if (VISIBLE.equals(layer.getVisibility().getValue())) {
                        layer.setProperties(visibility(NONE));
                    } else {
                        layer.setProperties(visibility(VISIBLE));
                    }
                }
            }
        });
    }


    // Add the mapView lifecycle to the activity's lifecycle methods
    @Override
    public void onResume() {
        super.onResume();
        mapView.onResume();
    }

    @Override
    protected void onStart() {
        super.onStart();
        mapView.onStart();

        if (mapRoute != null) {
            mapRoute.onStart();
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        mapView.onStop();

        if (mapRoute != null) {
            mapRoute.onStop();
        }

    }

    @Override
    public void onPause() {
        super.onPause();
        mapView.onPause();
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();
        mapView.onLowMemory();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mapView.onDestroy();
    }


    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mapView.onSaveInstanceState(outState);
    }
}

Before_Go -这是我想要单击按钮并启动导航启动器的活动

公共类Before_Go扩展了AppCompatActivity {

Button btnGo;

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

    btnGo=findViewById(R.id.btnGo);

    btnGo.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Intent btnGo = new Intent(Before_Go.this, Go.class);
            startActivity(btnGo);
        }
    });
}

}

Answer 3

    GoActivity, this is where the navigation launcher needs to launch after the button click in the Before_Go activity
    
    public class Go extends AppCompatActivity implements OnNavigationReadyCallback,
            NavigationListener {
    
        private NavigationView navigationView;
        private DirectionsRoute route;
    
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            setTheme(R.style.Theme_AppCompat_NoActionBar);
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_go);
            navigationView = findViewById(R.id.navigationViewB);
            navigationView.onCreate(savedInstanceState);
    
        }
            /*fabstart.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        boolean simulateRoute = false;
                        NavigationLauncherOptions options = NavigationLauncherOptions.builder()
                                .directionsRoute(route)
                                .shouldSimulateRoute(simulateRoute)
                                .build();
                        // Call this method with Context from within an Activity
                        NavigationLauncher.startNavigation(MainActivity.this, options);
    
                    }
                });*/
    
        @Override
        public void onNavigationReady(boolean isRunning) {
            MapboxNavigationOptions.Builder navigationOptions = MapboxNavigationOptions.builder();
            NavigationViewOptions.Builder options = NavigationViewOptions.builder();
            options.navigationListener(this);
            extractRoute(options);
            extractConfiguration(options);
            options.navigationOptions(navigationOptions.build());
            //options.navigationOptions(new MapboxNavigationOptions.Builder().build());
            launchNavigationWithRoute();
            //navigationView.startNavigation(options.build());
            navigationView.initialize(this);
    
    /*MapboxNavigationOptions.Builder navigationOptions = MapboxNavigationOptions.builder();
            NavigationViewOptions.Builder options = NavigationViewOptions.builder();
            options.navigationListener(this);
    
            extractRoute(options);
    
            options.navigationOptions(navigationOptions.build());
            //navigationView = NavigationLauncher.startNavigation(options.build());
            navigationView.startNavigation(options.build());
            initialize();*/
    
        }
    
        @Override
        public void onCancelNavigation() {
            // Navigation canceled, finish the activity
            showCustomCancel();
            finishNavigation();
        }
    
        @Override
        public void onNavigationFinished() {
    
        }
    
        @Override
        public void onNavigationRunning() {
    
        }
    
        private void launchNavigationWithRoute() {
            if (route != null) {
                NavigationLauncher.startNavigation(this, route);
            }
        }
    
        private void extractRoute(NavigationViewOptions.Builder options) {
            route = NavigationLauncher.extractRoute(this);
            options.directionsRoute(route);
        }
    
        private void extractConfiguration(NavigationViewOptions.Builder options) {
            SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
            options.shouldSimulateRoute(preferences.getBoolean(NavigationConstants.NAVIGATION_VIEW_SIMULATE_ROUTE, false));
    
    
        }
    
        private void finishNavigation() {
            NavigationLauncher.cleanUpPreferences(this);
            finish();
        }
    
        private void showCustomCancel(){
            ViewGroup viewGroup = findViewById(android.R.id.content);
            View dialogView2 = LayoutInflater.from(this).inflate(R.layout.my_dialog_logout, viewGroup, false);
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setView(dialogView2);
            AlertDialog alertDialog2 = builder.create();
            Button buttonNo = dialogView2.findViewById(R.id.buttonNo);
            Button buttonYes = dialogView2.findViewById(R.id.buttonYes);
    
            buttonYes.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (alertDialog2 != null && alertDialog2.isShowing()) {
                        alertDialog2.dismiss();
                    }
                    Intent intentCancelTrip_Yes = new Intent(getApplicationContext(),MainActivity.class);
                    startActivity(intentCancelTrip_Yes);
                    finish();
                    navigationView.stopNavigation();
                }
            });
    
            buttonNo.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (alertDialog2 != null && alertDialog2.isShowing()) {
                        alertDialog2.dismiss();
    
                    }
                    navigationView.onResume();
    
                }
            });
    
    
            alertDialog2.show();
    
    
        }
    
    /*    private void initialize() {
            Parcelable position = getIntent().getParcelableExtra(NavigationConstants.NAVIGATION_VIEW_INITIAL_MAP_POSITION);
            if (position != null) {
                navigationView.initialize(this, (CameraPosition) position);
            } else {
                navigationView.initialize(this);
            }
        }*/
    
        @Override
        public void onStart() {
            super.onStart();
            navigationView.onStart();
        }
    
        @Override
        public void onResume() {
            super.onResume();
            navigationView.onResume();
        }
    
        @Override
        public void onLowMemory() {
            super.onLowMemory();
            navigationView.onLowMemory();
        }
    
        @Override
        public void onBackPressed() {
            // If the navigation view didn't need to do anything, call super
            if (!navigationView.onBackPressed()) {
                super.onBackPressed();
            }
        }
    
        @Override
        protected void onSaveInstanceState(Bundle outState) {
            navigationView.onSaveInstanceState(outState);
            super.onSaveInstanceState(outState);
        }
    
        @Override
        protected void onRestoreInstanceState(Bundle savedInstanceState) {
            super.onRestoreInstanceState(savedInstanceState);
            navigationView.onRestoreInstanceState(savedInstanceState);
        }
    
        @Override
        public void onPause() {
            super.onPause();
            navigationView.onPause();
        }
    
        @Override
        public void onStop() {
            super.onStop();
            navigationView.onStop();
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            navigationView.onDestroy();
        }
    }

NavigationLauncher class i am using to try initiate the navigation inside the Go activity

public class NavigationLauncher {


    public static void startNavigation(Activity activity, DirectionsRoute route) {

        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(activity);
        SharedPreferences.Editor editor = preferences.edit();
        editor.putString(NavigationConstants.NAVIGATION_VIEW_ROUTE_KEY, new Gson().toJson(route));

        //editor.putString(NavigationConstants.NAVIGATION_VIEW_AWS_POOL_ID, awsPoolId);
        //editor.putBoolean(NavigationConstants.NAVIGATION_VIEW_SIMULATE_ROUTE, simulateRoute);
        editor.apply();

        Intent navigationActivity = new Intent(activity, Go.class);
        activity.startActivity(navigationActivity);

    }

   /* public static void startNavigation(Activity activity, NavigationLauncherOptions options){

           SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(activity);
        SharedPreferences.Editor editor = preferences.edit();
        storeDirectionsRouteValue(options, editor);
        storeConfiguration(options, editor);
        editor.apply();


        Intent navigationActivity = new Intent(activity, Go.class);
        storeInitialMapPosition(options, navigationActivity);
        activity.startActivity(navigationActivity);

    }*/

    private static void storeConfiguration(NavigationLauncherOptions options, SharedPreferences.Editor editor) {
        editor.putBoolean(NavigationConstants.NAVIGATION_VIEW_SIMULATE_ROUTE, options.shouldSimulateRoute());
    }

    private static void storeDirectionsRouteValue(NavigationLauncherOptions options, SharedPreferences.Editor editor) {
        editor.putString(NavigationConstants.NAVIGATION_VIEW_ROUTE_KEY, options.directionsRoute().toJson());

        /*if (options.directionsRoute() != null) {
            storeDirectionsRouteValue(options, editor);
        }
         else {
            throw new RuntimeException("A valid DirectionsRoute or origin and "
                    + "destination must be provided in NavigationViewOptions");
        }*/
    }

    static DirectionsRoute extractRoute(Context context) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        String directionsRouteJson = preferences.getString(NavigationConstants.NAVIGATION_VIEW_ROUTE_KEY, "");
        return DirectionsRoute.fromJson(directionsRouteJson);
    }

    static void cleanUpPreferences(Context context) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        SharedPreferences.Editor editor = preferences.edit();
        editor
                .remove(NavigationConstants.NAVIGATION_VIEW_ROUTE_KEY)
                .remove(NavigationConstants.NAVIGATION_VIEW_SIMULATE_ROUTE)
                .apply();
    }

    private static void  storeInitialMapPosition(NavigationLauncherOptions options, Intent navigationActivity) {
        if (options.initialMapCameraPosition() != null) {
            navigationActivity.putExtra(
                    NavigationConstants.NAVIGATION_VIEW_INITIAL_MAP_POSITION, options.initialMapCameraPosition()
            );
        }
    }


}