Poruszanie się po trasie obejmującej jedno miejsce docelowe

Uwaga: usługi fromLatLng() i fromPlaceId() zostały wycofane, ale pozostaną dostępne bez dalszych aktualizacji. Zalecamy przejście na nową wersję Waypoint.Builder.

Z tego przewodnika dowiesz się, jak wyznaczyć trasę w aplikacji za pomocą pakietu Navigation SDK na Androida. W tym przewodniku zakładamy, że pakiet SDK Navigation został już zintegrowany z aplikacją zgodnie z opisem w sekcji Konfigurowanie projektu.

Podsumowanie

1. Dodaj do aplikacji element interfejsu, który będzie fragmentem nawigacji lub widokiem nawigacji. Ten element interfejsu dodaje do aktywności interaktywną mapę i interfejs nawigacji krok po kroku.
2. Poproś o dostęp do lokalizacji. Aby określić lokalizację urządzenia, aplikacja musi poprosić o dostęp do lokalizacji.
3. Zainicjuj pakiet SDK za pomocą klasy NavigationApi.

4. Ustaw cel podróży i steruj szczegółową nawigacją za pomocą klasy Navigator. Obejmuje to 3 etapy:

   • Ustaw miejsce docelowe za pomocą funkcji setDestination().
   • Rozpocznij nawigację za pomocą startGuidance().
   • Użyj getSimulator(), aby symulować postęp pojazdu na trasie na potrzeby testowania, debugowania i demonstrowania aplikacji.

5. Skompiluj i uruchom aplikację.

Wyświetlanie kodu

Wyświetlanie i ukrywanie kodu Java w przypadku aktywności nawigacji do jednego miejsca docelowego.

package com.example.navsdksingledestination;

import android.content.pm.PackageManager;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import com.google.android.gms.maps.GoogleMap.CameraPerspective;
import com.google.android.libraries.navigation.ListenableResultFuture;
import com.google.android.libraries.navigation.NavigationApi;
import com.google.android.libraries.navigation.Navigator;
import com.google.android.libraries.navigation.RoutingOptions;
import com.google.android.libraries.navigation.SimulationOptions;
import com.google.android.libraries.navigation.SupportNavigationFragment;
import com.google.android.libraries.navigation.Waypoint;

/**
 * An activity that displays a map and a navigation UI, guiding the user from their current location
 * to a single, given destination.
 */
public class NavigationActivitySingleDestination extends AppCompatActivity {

  private static final String TAG = NavigationActivitySingleDestination.class.getSimpleName();
  private Navigator mNavigator;
  private SupportNavigationFragment mNavFragment;
  private RoutingOptions mRoutingOptions;

  // Define the Sydney Opera House by specifying its place ID.
  private static final String SYDNEY_OPERA_HOUSE = "ChIJ3S-JXmauEmsRUcIaWtf4MzE";

  // Set fields for requesting location permission.
  private static final int PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 1;
  private boolean mLocationPermissionGranted;

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

    // Initialize the Navigation SDK.
    initializeNavigationSdk();
  }

  /**
   * Starts the Navigation SDK and sets the camera to follow the device's location. Calls the
   * navigateToPlace() method when the navigator is ready.
   */
  private void initializeNavigationSdk() {
    /*
     * Request location permission, so that we can get the location of the
     * device. The result of the permission request is handled by a callback,
     * onRequestPermissionsResult.
     */
    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.");
      return;
    }

    // Get a navigator.
    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.");
            mNavigator = navigator;
            mNavFragment =
                (SupportNavigationFragment)
                    getSupportFragmentManager().findFragmentById(R.id.navigation_fragment);

            // Set the last digit of the car's license plate to get route restrictions
            // in supported countries. (optional)
            // mNavigator.setLicensePlateRestrictionInfo(getLastDigit(), "BZ");

            // Set the camera to follow the device location with 'TILTED' driving view.
            mNavFragment.getMapAsync(
                googleMap -> googleMap.followMyLocation(CameraPerspective.TILTED));

            // Set the travel mode (DRIVING, WALKING, CYCLING, or TWO_WHEELER).
            mRoutingOptions = new RoutingOptions();
            mRoutingOptions.travelMode(RoutingOptions.TravelMode.DRIVING);

            // Navigate to a place, specified by Place ID.
            navigateToPlace(SYDNEY_OPERA_HOUSE, mRoutingOptions);
          }

          /**
           * 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.");
                break;
              case NavigationApi.ErrorCode.TERMS_NOT_ACCEPTED:
                displayMessage(
                    "Error loading Navigation SDK: User did not accept "
                        + "the Navigation Terms of Use.");
                break;
              case NavigationApi.ErrorCode.NETWORK_ERROR:
                displayMessage("Error loading Navigation SDK: Network error.");
                break;
              case NavigationApi.ErrorCode.LOCATION_PERMISSION_MISSING:
                displayMessage(
                    "Error loading Navigation SDK: Location permission " + "is missing.");
                break;
              default:
                displayMessage("Error loading Navigation SDK: " + errorCode);
            }
          }
        });
  }

  /**
   * Requests directions from the user's current location to a specific place (provided by the
   * Google Places API).
   */
  private void navigateToPlace(String placeId, RoutingOptions travelMode) {
    Waypoint destination;
    try {
      destination = Waypoint.builder().setPlaceIdString(placeId).build();
    } catch (Waypoint.UnsupportedPlaceIdException e) {
      displayMessage("Error starting navigation: Place ID is not supported.");
      return;
    }

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

    // 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:
                // Hide the toolbar to maximize the navigation UI.
                if (getActionBar() != null) {
                  getActionBar().hide();
                }

                // 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.");
                break;
              case NETWORK_ERROR:
                displayMessage("Error starting navigation: Network error.");
                break;
              case ROUTE_CANCELED:
                displayMessage("Error starting navigation: Route canceled.");
                break;
              default:
                displayMessage("Error starting navigation: " + String.valueOf(code));
            }
          }
        });
  }

  /** Handles the result of the request for location permissions. */
  @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;
          }
        }
    }
  }

  /**
   * Shows a message on screen and in the log. Used when something goes wrong.
   *
   * @param errorMessage The message to display.
   */
  private void displayMessage(String errorMessage) {
    Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
    Log.d(TAG, errorMessage);
  }
}

Dodawanie elementu interfejsu do aplikacji

W tej sekcji opisujemy 2 sposoby dodawania interaktywnej mapy i interfejsu do wyświetlania nawigacji zakręt po zakręcie. 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ą .

Używanie fragmentu nawigacji

SupportNavigationFragment to komponent interfejsu, który wyświetla wizualne dane wyjściowe nawigacji, w tym interaktywną mapę i wskazówki dojazdu zakręt po zakręcie. 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().

Korzystanie z widoku nawigacji

Alternatywnie do fragmentu komponent interfejsu do wyświetlania mapy na potrzeby nawigacji jest też dostępny jako NavigationView.

Ostrzeżenie: przeczytaj wskazówki u góry opisu klasy NavigationView, a zwłaszcza porady dotyczące prawidłowego przekazywania i wywoływania metod cyklu życia z działania lub fragmentu zawierającego widok.

Poproś o dostęp do lokalizacji

W tej sekcji pokazujemy, jak poprosić o uprawnienia do precyzyjnej 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.navsdksingledestination">
       <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   </manifest>
   

2. Poproś o uprawnienia w czasie działania w 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.");
           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

Klasa NavigationApi zawiera logikę inicjowania, która autoryzuje aplikację do korzystania z nawigacji Google. W tej sekcji opisujemy, jak zainicjować nawigatora, oraz inne konfiguracje, które możesz włączyć w swojej aplikacji:

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

2. Opcjonalnie. Skonfiguruj aplikację tak, aby powiadomienia z wskazówkami i usługi działające w tle wyłączały się, gdy użytkownik zamknie aplikację na urządzeniu. Ten wybór zależy od Twojego modelu biznesowego. Możesz użyć domyślnego działania nawigatora, który nadal wyświetla wskazówki dotyczące skrętu i aktualizacje lokalizacji nawet po zamknięciu aplikacji. Jeśli chcesz wyłączyć nawigację i aktualizacje lokalizacji, gdy użytkownik zamknie aplikację, użyj tej konfiguracji.

3. Opcjonalnie. Włącz ograniczenia dotyczące dróg w obsługiwanych krajach. Ustaw ostatnią cyfrę numeru rejestracyjnego. To wywołanie musi zostać wykonane tylko raz: kolejne żądania wskazówek dojazdu nadal będą z niego korzystać. Połączenie jest możliwe tylko w obsługiwanych regionach. Zobacz kraje, w których jest dostępny pakiet Navigation SDK.

       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.");
                       mNavigator = navigator;
                       mNavFragment = (NavigationFragment) getFragmentManager()
                               .findFragmentById(R.id.navigation_fragment);
   
                       // Optional. Disable the guidance notifications and shut down the app
                       // and background service when the user closes the app.
                       // mNavigator.setTaskRemovedBehavior(Navigator.TaskRemovedBehavior.QUIT_SERVICE)
   
                       // Optional. Set the last digit of the car's license plate to get
                       // route restrictions for supported countries.
                       // mNavigator.setLicensePlateRestrictionInfo(getLastDigit(), "BZ");
   
                       // Set the camera to follow the device location with 'TILTED' driving view.
                       mNavFragment.getCamera().followMyLocation(Camera.Perspective.TILTED);
   
                       // Set the travel mode (DRIVING, WALKING, CYCLING, TWO_WHEELER, or TAXI).
                       mRoutingOptions = new RoutingOptions();
                       mRoutingOptions.travelMode(RoutingOptions.TravelMode.DRIVING);
   
                       // Navigate to a place, specified by Place ID.
                       navigateToPlace(SYDNEY_OPERA_HOUSE, mRoutingOptions);
                   }
   
                   /**
                    * 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.");
                               break;
                           case NavigationApi.ErrorCode.TERMS_NOT_ACCEPTED:
                               displayMessage("Error loading Navigation SDK: User did not accept "
                                       + "the Navigation Terms of Use.");
                               break;
                           case NavigationApi.ErrorCode.NETWORK_ERROR:
                               displayMessage("Error loading Navigation SDK: Network error.");
                               break;
                           case NavigationApi.ErrorCode.LOCATION_PERMISSION_MISSING:
                               displayMessage("Error loading Navigation SDK: Location permission "
                                       + "is missing.");
                               break;
                           default:
                               displayMessage("Error loading Navigation SDK: " + errorCode);
                       }
                   }
               });
   

Ustaw miejsce docelowe

Klasa Navigator umożliwia konfigurowanie, rozpoczynanie i zatrzymywanie podróży z nawigacją.

Używając Navigator uzyskanego w poprzedniej sekcji, ustaw miejsce docelowe Waypoint tej podróży. Po obliczeniu wskazówek dojazdu ikona SupportNavigationFragment wyświetla na mapie linię łamaną reprezentującą trasę oraz znacznik w miejscu docelowym.

```none
    private void navigateToPlace(String placeId, RoutingOptions travelMode) {
        Waypoint destination;
        try {
            destination = Waypoint.builder().setPlaceIdString(placeId).build();
        } catch (Waypoint.UnsupportedPlaceIdException e) {
            displayMessage("Error starting navigation: Place ID is not supported.");
            return;
        }

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

        // 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:
                                // Hide the toolbar to maximize the navigation UI.
                                if (getActionBar() != null) {
                                    getActionBar().hide();
                                }

                                // 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.");
                                break;
                            case NETWORK_ERROR:
                                displayMessage("Error starting navigation: Network error.");
                                break;
                            case ROUTE_CANCELED:
                                displayMessage("Error starting navigation: Route canceled.");
                                break;
                            default:
                                displayMessage("Error starting navigation: "
                                        + String.valueOf(code));
                        }
                    }
                });
    }
```

Tworzenie i uruchamianie aplikacji

1. Podłącz urządzenie z Androidem do komputera. Postępuj zgodnie z instrukcjami Android Studio dotyczącymi uruchamiania aplikacji na urządzeniu. Możesz też skonfigurować urządzenie wirtualne za pomocą menedżera urządzenia wirtualnego z Androidem (AVD). 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 TermsAndConditionsCheckOption.
• Aby znacznie poprawić jakość nawigacji i dokładność szacowanego czasu przybycia, używaj identyfikatorów miejsc do inicjowania punktu pośredniego zamiast współrzędnych geograficznych.
• Ten przykład pobiera punkt docelowy z określonego identyfikatora miejsca dla Sydney Opera House. Aby uzyskać identyfikatory miejsc dla innych konkretnych lokalizacji, możesz użyć wyszukiwarki identyfikatorów miejsc.