Poruszanie się po trasie obejmującej wiele miejsc docelowych

Z tego przewodnika dowiesz się, jak wyznaczyć w aplikacji trasę do wielu miejsc docelowych (zwanych też punktami pośrednimi) za pomocą pakietu Navigation SDK na Androida.

Przegląd

  1. Zintegruj pakiet SDK nawigacji z aplikacją zgodnie z opisem w sekcji Konfigurowanie projektu.
  2. Dodaj do aplikacji element SupportNavigationFragment lub NavigationView. Ten element interfejsu dodaje do aktywności interaktywną mapę i interfejs nawigacji krok po kroku.
  3. Aby zainicjować pakiet SDK, użyj klasy NavigationApi.

  4. Zdefiniuj Navigator, aby sterować nawigacją zakręt po zakręcie:

    • Dodaj miejsca docelowe za pomocą ikony setDestinations().
    • Rozpocznij nawigację za pomocą funkcji startGuidance().
    • Użyj getSimulator(), aby symulować postępy pojazdu na trasie na potrzeby testowania, debugowania i demonstrowania aplikacji.

  5. Skompiluj i uruchom aplikację.

Wyświetlanie kodu

Dodawanie fragmentu nawigacji

SupportNavigationFragment to komponent interfejsu, który wyświetla wizualne dane wyjściowe nawigacji, w tym interaktywną mapę i szczegółowe wskazówki dojazdu. Fragment możesz zadeklarować w pliku układu XML w ten sposób:

<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="com.google.android.libraries.navigation.SupportNavigationFragment"
    android:id="@+id/navigation_fragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

Możesz też utworzyć fragment programowo, zgodnie z opisem w dokumentacji Androida, używając FragmentActivity.getSupportFragmentManager().

Komponent interfejsu jest też dostępny jako NavigationView. W większości przypadków zalecamy używanie SupportNavigationFragment, która jest otoczką NavigationView, zamiast bezpośredniego korzystania z NavigationView. Więcej informacji znajdziesz w artykule Sprawdzone metody interakcji z mapą nawigacyjną .

Poproś o dostęp do lokalizacji

Aby określić lokalizację urządzenia, aplikacja musi poprosić o dostęp do lokalizacji.

W tym samouczku znajdziesz kod potrzebny do wysłania prośby o zezwolenie na dostęp do dokładnej lokalizacji. Więcej informacji znajdziesz w przewodniku po uprawnieniach na Androidzie.

  1. Dodaj uprawnienie jako element podrzędny elementu <manifest> w pliku manifestu Androida:

        <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.navsdkmultidestination">
        <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    </manifest>

  2. Poproś o uprawnienia w czasie działania aplikacji, dając użytkownikowi możliwość przyznania lub odmowy uprawnień do lokalizacji. Poniższy kod sprawdza, czy użytkownik przyznał uprawnienia do dokładnej lokalizacji. Jeśli nie, prosi o uprawnienia:

        if (ContextCompat.checkSelfPermission(this.getApplicationContext(),
            android.Manifest.permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
        mLocationPermissionGranted = true;
    } else {
        ActivityCompat.requestPermissions(this,
                new String[] { android.Manifest.permission.ACCESS_FINE_LOCATION },
                PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
    }

    if (!mLocationPermissionGranted) {
        displayMessage("Error loading Navigation SDK: "
                + "The user has not granted location permission.", DISPLAY_BOTH);
        return;
    }

  3. Zastąp wywołanie zwrotne onRequestPermissionsResult(), aby obsłużyć wynik prośby o uprawnienia:

        @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[],
                                           @NonNull int[] grantResults) {
        mLocationPermissionGranted = false;
        switch (requestCode) {
            case PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION: {
                // If request is canceled, the result arrays are empty.
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    mLocationPermissionGranted = true;
                }
            }
        }
    }

Inicjowanie pakietu Navigation SDK i konfigurowanie podróży

Klasa NavigationApi zawiera logikę inicjowania, która autoryzuje aplikację do korzystania z nawigacji Google. Klasa Navigator umożliwia konfigurowanie, rozpoczynanie i zatrzymywanie podróży nawigacyjnej.

  1. Utwórz metodę pomocniczą, która będzie wyświetlać komunikat na ekranie i w logu.

        private void displayMessage(String errorMessage, String displayMedium) {
        if (displayMedium.equals(DISPLAY_BOTH) || displayMedium.equals(DISPLAY_TOAST)) {
            Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
        }

        if (displayMedium.equals(DISPLAY_BOTH) || displayMedium.equals(DISPLAY_LOG)) {
            Log.d(TAG, errorMessage);
        }
    }

  2. Zainicjuj pakiet Navigation SDK i zastąp wywołanie zwrotne onNavigatorReady(), aby rozpocząć nawigację, gdy nawigator będzie gotowy:

        NavigationApi.getNavigator(this, new NavigationApi.NavigatorListener() {
                /**
                 * Sets up the navigation UI when the navigator is ready for use.
                 */
                @Override
                public void onNavigatorReady(Navigator navigator) {
                    displayMessage("Navigator ready.", DISPLAY_BOTH);
                    mNavigator = navigator;
                    mNavFragment = (SupportNavigationFragment) getFragmentManager()
                            .findFragmentById(R.id.navigation_fragment);

                    // Set the camera to follow the device location with 'TILTED' driving view.
                    mNavFragment.getCamera().followMyLocation(Camera.Perspective.TILTED);

                    // Navigate to the specified places.
                    navigateToPlaces();
                }

                /**
                 * Handles errors from the Navigation SDK.
                 * @param errorCode The error code returned by the navigator.
                 */
                @Override
                public void onError(@NavigationApi.ErrorCode int errorCode) {
                    switch (errorCode) {
                        case NavigationApi.ErrorCode.NOT_AUTHORIZED:
                            displayMessage("Error loading Navigation SDK: Your API key is "
                                    + "invalid or not authorized to use the Navigation SDK.",
                                    DISPLAY_BOTH);
                            break;
                        case NavigationApi.ErrorCode.TERMS_NOT_ACCEPTED:
                            displayMessage("Error loading Navigation SDK: User did not accept "
                                    + "the Navigation Terms of Use.", DISPLAY_BOTH);
                            break;
                        case NavigationApi.ErrorCode.NETWORK_ERROR:
                            displayMessage("Error loading Navigation SDK: Network error.",
                                    DISPLAY_BOTH);
                            break;
                        case NavigationApi.ErrorCode.LOCATION_PERMISSION_MISSING:
                            displayMessage("Error loading Navigation SDK: Location permission "
                                    + "is missing.", DISPLAY_BOTH);
                            break;
                        default:
                            displayMessage("Error loading Navigation SDK: " + errorCode,
                                    DISPLAY_BOTH);
                    }
                }
            });

  3. Dodaj metodę tworzenia obiektu Waypoint na podstawie podanego identyfikatora miejsca i tytułu.

        private void createWaypoint(String placeId, String title) {
        try {
            mWaypoints.add(
              Waypoint.builder()
                     .setPlaceIdString(placeId)
                     .setTitle(title)
                     .build()
            );
        } catch (Waypoint.UnsupportedPlaceIdException e) {
            displayMessage("Error starting navigation: Place ID is not supported: " + placeId,
                    DISPLAY_BOTH);
        }
    }

  4. Dodaj metodę wyświetlania obliczonego czasu podróży i odległości do każdego punktu pośredniego.

        private void displayTimesAndDistances() {
        List<TimeAndDistance> timesAndDistances = mNavigator.getTimeAndDistanceList();
        int leg = 1;
        String message = "You're on your way!";
        for (TimeAndDistance timeAndDistance : timesAndDistances) {
            message = message + "\nRoute leg: " + leg++
                    + ": Travel time (seconds): " + timeAndDistance.getSeconds()
                    + ". Distance (meters): " + timeAndDistance.getMeters();
        }
        displayMessage(message, DISPLAY_BOTH);
    }

  5. Ustaw wszystkie punkty pośrednie tej podróży. (Pamiętaj, że jeśli użyjesz identyfikatorów miejsc, dla których nawigator nie może wyznaczyć trasy, możesz otrzymać błąd. Przykładowa aplikacja w tym samouczku używa identyfikatorów miejsc jako punktów pośrednich w Australii. (Uwagi dotyczące uzyskiwania różnych identyfikatorów miejsc znajdziesz poniżej). Po obliczeniu wskazówek dojazdu SupportNavigationFragment wyświetla na mapie linię łamaną reprezentującą trasę, ze znacznikiem w każdym punkcie pośrednim.

        private void navigateToPlaces() {

        // Set up a waypoint for each place that we want to go to.
        createWaypoint("ChIJq6qq6jauEmsRJAf7FjrKnXI", "Sydney Star");
        createWaypoint("ChIJ3S-JXmauEmsRUcIaWtf4MzE", "Sydney Opera House");
        createWaypoint("ChIJLwgLFGmuEmsRzpDhHQuyyoU", "Sydney Conservatorium of Music");

        // If this journey is already in progress, no need to restart navigation.
        // This can happen when the user rotates the device, or sends the app to the background.
        if (mSavedInstanceState != null
                && mSavedInstanceState.containsKey(KEY_JOURNEY_IN_PROGRESS)
                && mSavedInstanceState.getInt(KEY_JOURNEY_IN_PROGRESS) == 1) {
            return;
        }

        // Create a future to await the result of the asynchronous navigator task.
        ListenableResultFuture<Navigator.RouteStatus> pendingRoute =
                mNavigator.setDestinations(mWaypoints);

        // Define the action to perform when the SDK has determined the route.
        pendingRoute.setOnResultListener(
                new ListenableResultFuture.OnResultListener<Navigator.RouteStatus>() {
                    @Override
                    public void onResult(Navigator.RouteStatus code) {
                        switch (code) {
                            case OK:
                                mJourneyInProgress = true;
                                // Hide the toolbar to maximize the navigation UI.
                                if (getActionBar() != null) {
                                    getActionBar().hide();
                                }

                                // Register some listeners for navigation events.
                                registerNavigationListeners();

                                // Display the time and distance to each waypoint.
                                displayTimesAndDistances();

                                // Enable voice audio guidance (through the device speaker).
                                mNavigator.setAudioGuidance(
                                        Navigator.AudioGuidance.VOICE_ALERTS_AND_GUIDANCE);

                                // Simulate vehicle progress along the route for demo/debug builds.
                                if (BuildConfig.DEBUG) {
                                    mNavigator.getSimulator().simulateLocationsAlongExistingRoute(
                                            new SimulationOptions().speedMultiplier(5));
                                }

                                // Start turn-by-turn guidance along the current route.
                                mNavigator.startGuidance();
                                break;
                            // Handle error conditions returned by the navigator.
                            case NO_ROUTE_FOUND:
                                displayMessage("Error starting navigation: No route found.",
                                        DISPLAY_BOTH);
                                break;
                            case NETWORK_ERROR:
                                displayMessage("Error starting navigation: Network error.",
                                        DISPLAY_BOTH);
                                break;
                            case ROUTE_CANCELED:
                                displayMessage("Error starting navigation: Route canceled.",
                                        DISPLAY_BOTH);
                                break;
                            default:
                                displayMessage("Error starting navigation: "
                                        + String.valueOf(code), DISPLAY_BOTH);
                        }
                    }
                });
    }

Tworzenie i uruchamianie aplikacji

  1. Podłącz urządzenie z Androidem do komputera. Postępuj zgodnie z instrukcjami, aby włączyć opcje programisty na urządzeniu z Androidem i skonfigurować system tak, aby wykrywał urządzenie. (Możesz też użyć menedżera urządzenia wirtualnego z Androidem (AVD), aby skonfigurować urządzenie wirtualne. Wybierając emulator, pamiętaj, aby wybrać obraz, który zawiera interfejsy API Google).
  2. W Android Studio kliknij opcję menu Uruchom (lub ikonę przycisku odtwarzania). Wybierz urządzenie zgodnie z instrukcjami.

Wskazówki dotyczące poprawy wrażeń użytkowników

  • Zanim nawigacja stanie się dostępna, użytkownik musi zaakceptować Warunki korzystania z Nawigacji Google. Wystarczy zaakceptować je tylko raz. Domyślnie pakiet SDK wyświetla prośbę o zaakceptowanie za pierwszym razem, gdy zostanie wywołany nawigator. Jeśli wolisz, możesz wywołać okno Warunków korzystania z nawigacji na wcześniejszym etapie procesu UX aplikacji, np. podczas rejestracji lub logowania, używając funkcji showTermsAndConditionsDialog().
  • Jakość nawigacji i dokładność szacowanego czasu przybycia znacznie się poprawiają, jeśli do zainicjowania punktu pośredniego używasz identyfikatorów miejsc, a nie współrzędnych geograficznych miejsca docelowego.

  • Ten przykład pobiera punkty pośrednie z określonych identyfikatorów miejsc. Inne sposoby uzyskania identyfikatora miejsca:

  • Użyj wyszukiwarki identyfikatorów miejsc, aby uzyskać identyfikatory miejsc dla konkretnych lokalizacji.

  • Użyj interfejsu Geocoding API, aby znaleźć identyfikator miejsca dla danego adresu. Interfejs Geocoding API sprawdza się, gdy masz kompletne, jednoznaczne adresy punktów pośrednich. Zapoznaj się z przewodnikiem ze sprawdzonymi metodami geokodowania.

  • Użyj wyszukiwania tekstowego w interfejsie Places API, aby znaleźć identyfikator miejsca dla danego adresu. Interfejs Places API sprawdza się w przypadku niepełnych lub niejednoznacznych adresów punktów pośrednich. Zapoznaj się z przewodnikiem ze sprawdzonymi metodami geokodowania.