Autouzupełnianie miejsc (starsza wersja)

Autouzupełnianie miejsc (starsza wersja) zwraca podpowiedzi miejsc w odpowiedzi na zapytania użytkownika. Gdy użytkownik wpisuje tekst, usługa autouzupełniania zwraca sugestie dotyczące miejsc, takich jak firmy, adresy, plus kody i ciekawe miejsca.

Autouzupełnianie możesz dodać do aplikacji na te sposoby:

• Dodaj widżet autouzupełniania, aby skrócić czas programowania i zapewnić spójne środowisko użytkownika.
• Uzyskuj podpowiedzi miejsc automatycznie, aby dostosować wrażenia użytkowników.

Dodawanie widżetu autouzupełniania

Widżet autouzupełniania to okno wyszukiwania z wbudowaną funkcją autouzupełniania. Gdy użytkownik wpisuje wyszukiwane słowa, widżet wyświetla listę podpowiedzi miejsc do wyboru. Gdy użytkownik dokona wyboru, zwracane jest wystąpienie Place, którego aplikacja może użyć do uzyskania szczegółowych informacji o wybranym miejscu.

Widżet autouzupełniania możesz dodać do aplikacji na 2 sposoby:

• Opcja 1. Umieść AutocompleteSupportFragment.
• Opcja 2. Użycie intencji do uruchomienia aktywności autouzupełniania

Opcja 1. Umieść fragment AutocompleteSupportFragment

Aby dodać AutocompleteSupportFragment do aplikacji, wykonaj te czynności:

1. Dodaj fragment do układu XML aktywności.
2. Dodaj detektor do aktywności lub fragmentu.

Dodawanie fragmentu AutocompleteSupportFragment do aktywności

Aby dodać AutocompleteSupportFragment do aktywności, dodaj nowy fragment do układu XML. Na przykład:

<fragment android:id="@+id/autocomplete_fragment"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:name="com.google.android.libraries.places.widget.AutocompleteSupportFragment"
  />

• Domyślnie fragment nie ma obramowania ani tła. Aby zapewnić spójny wygląd, umieść fragment w innym elemencie układu, takim jak CardView.
• Jeśli używasz fragmentu autouzupełniania i musisz zastąpić metodę onActivityResult, musisz wywołać metodę super.onActivityResult. W przeciwnym razie fragment nie będzie działać prawidłowo.

Dodawanie do aktywności detektora PlaceSelectionListener

PlaceSelectionListener obsługuje zwracanie miejsca w odpowiedzi na wybór użytkownika. Ten kod ilustruje utworzenie odwołania do fragmentu i dodanie detektora do fragmentu AutocompleteSupportFragment:

    // Build a BasicPlaceAutocomplete intent to allow the user to select a place.
    val basicAutocompleteIntent = BasicPlaceAutocomplete.createIntent(this) {
        setCountries(listOf("AU", "NZ"))
    }

      

    // Build a BasicPlaceAutocomplete intent to allow the user to select a place.
    Intent basicAutocompleteIntent =
            new BasicPlaceAutocomplete.IntentBuilder()
                    .setCountries(List.of("AU", "NZ"))
                    .build(this);

      

Opcja 2. Użycie intencji do uruchomienia aktywności autouzupełniania

Jeśli chcesz, aby aplikacja korzystała z innego sposobu nawigacji (np. aby uruchamiała autouzupełnianie za pomocą ikony, a nie pola wyszukiwania), możesz uruchomić autouzupełnianie za pomocą intencji.

Aby uruchomić widżet autouzupełniania za pomocą intencji, wykonaj te czynności:

1. Użyj Autocomplete.IntentBuilder, aby utworzyć intencję, przekazując odpowiedni tryb Autocomplete.
2. Zdefiniuj program uruchamiający wyniki aktywności registerForActivityResult, który może służyć do uruchamiania intencji i obsługi wybranej przez użytkownika prognozy miejsca w wyniku.

Tworzenie intencji autouzupełniania

W przykładzie poniżej użyto Autocomplete.IntentBuilder, aby utworzyć intencję uruchomienia widżetu autouzupełniania jako intencji:

    val intent = PlaceAutocomplete.createIntent(this) {
        setTypesFilter(listOf(PlaceTypes.ESTABLISHMENT))
    }

    startAutocomplete.launch(intent)

      

    // Start the autocomplete intent.
    Intent intent =
            new PlaceAutocomplete.IntentBuilder()
                    .setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT))
                    .build(this);
    startAutocomplete.launch(intent);

      

Gdy używasz intencji do uruchomienia widżetu autouzupełniania, możesz wybrać tryb wyświetlania nakładki lub pełnego ekranu. Poniższe zrzuty ekranu pokazują poszczególne tryby wyświetlania:

Zarejestruj wywołanie zwrotne dla wyniku intencji

Aby otrzymywać powiadomienia, gdy użytkownik wybierze miejsce, zdefiniuj program uruchamiający registerForActivityResult(), który uruchamia aktywność i obsługuje wynik, jak pokazano w tym przykładzie. Jeśli użytkownik wybrał podpowiedź, zostanie ona dostarczona w intencji zawartej w obiekcie wyniku. Ponieważ intencja została utworzona przez Autocomplete.IntentBuilder, metoda Autocomplete.getPlaceFromIntent() może wyodrębnić z niej obiekt Place.

private val startAutocomplete =
    registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
        if (result.resultCode == RESULT_OK) {
            val intent = result.data
            if (intent != null) {
                val prediction = PlaceAutocomplete.getPredictionFromIntent(intent)
                if (prediction != null) {
                    binding.autocompleteResult.text = getString(
                        R.string.place_selection,
                        prediction.getPrimaryText(null),
                        prediction.placeId,
                        prediction.getSecondaryText(null),
                    )
                    Log.i(
                        TAG,
                        "Place: ${prediction.getPrimaryText(null)}, ${prediction.placeId}",
                    )
                }
            }
        } else if (result.resultCode == RESULT_CANCELED) {
            // The user canceled the operation.
            binding.autocompleteResult.setText(R.string.user_canceled_autocomplete)
            Log.i(TAG, "User canceled autocomplete")
        } else if (result.resultCode == PlacesSdkAutocompleteActivity.RESULT_ERROR) {
            val intent = result.data
            if (intent != null) {
                val status = PlaceAutocomplete.getResultStatusFromIntent(intent)
                Log.e(TAG, "An error occurred: ${status?.statusMessage}")
            }
        }
    }

      

private final ActivityResultLauncher<Intent> startAutocomplete =
        registerForActivityResult(
                new ActivityResultContracts.StartActivityForResult(),
                result -> {
                    if (result.getResultCode() == Activity.RESULT_OK) {
                        Intent intent = result.getData();
                        if (intent != null) {
                            AutocompletePrediction prediction =
                                    PlaceAutocomplete.getPredictionFromIntent(intent);
                            if (prediction != null) {
                                binding.autocompleteResult.setText(
                                        getString(
                                                R.string.place_selection,
                                                prediction.getPrimaryText(null),
                                                prediction.getPlaceId(),
                                                prediction.getSecondaryText(null)));
                                Log.i(
                                        TAG,
                                        "Place: "
                                                + prediction.getPrimaryText(null)
                                                + ", "
                                                + prediction.getPlaceId());
                            }
                        }
                    } else if (result.getResultCode() == Activity.RESULT_CANCELED) {
                        // The user canceled the operation.
                        binding.autocompleteResult.setText(R.string.user_canceled_autocomplete);
                        Log.i(TAG, "User canceled autocomplete");
                    } else if (result.getResultCode()
                            == com.google.android.libraries.places.widget
                                    .PlaceAutocompleteActivity.RESULT_ERROR) {
                        Intent intent = result.getData();
                        if (intent != null) {
                            Status status = PlaceAutocomplete.getResultStatusFromIntent(intent);
                            if (status != null) {
                                Log.e(TAG, "An error occurred: " + status.getStatusMessage());
                            }
                        }
                    }
                });


      

Uzyskiwanie podpowiedzi miejsc w sposób zautomatyzowany

Możesz utworzyć niestandardowy interfejs wyszukiwania jako alternatywę dla interfejsu udostępnianego przez widżet autouzupełniania. Aby to zrobić, aplikacja musi pobierać podpowiedzi miejsc automatycznie. Aplikacja może uzyskać listę przewidywanych nazw miejsc lub adresów z interfejsu Autocomplete API, wywołując metodę PlacesClient.findAutocompletePredictions() i przekazując obiekt FindAutocompletePredictionsRequest z tymi parametrami:

• Wymagany: ciąg tekstowy query zawierający tekst wpisany przez użytkownika.
• Zalecane: AutocompleteSessionToken, która grupuje fazy zapytania i wyboru wyszukiwania użytkownika w osobną sesję na potrzeby rozliczeń. Sesja rozpoczyna się, gdy użytkownik zaczyna wpisywać zapytanie, a kończy, gdy wybiera miejsce.
• Zalecany: obiekt RectangularBounds, który określa granice szerokości i długości geograficznej, aby ograniczyć wyniki do określonego regionu.
• Opcjonalnie: co najmniej 1 dwuliterowy kod kraju (ISO 3166-1 Alpha-2) wskazujący kraj lub kraje, do których mają być ograniczone wyniki.

• Opcjonalnie: TypeFilter, którego możesz użyć, aby ograniczyć wyniki do określonego typu miejsca. Obsługiwane są te typy miejsc:

  • TypeFilter.GEOCODE – zwraca tylko wyniki geokodowania, a nie firmy. Użyj tego żądania, aby uściślić wyniki, gdy określona lokalizacja może być nieokreślona.
  • TypeFilter.ADDRESS – zwraca tylko wyniki autouzupełniania z dokładnym adresem. Używaj tego typu, gdy wiesz, że użytkownik szuka w pełni określonego adresu.
  • TypeFilter.ESTABLISHMENT – zwraca tylko miejsca, które są firmami.

  • TypeFilter.REGIONS – zwraca tylko miejsca, które pasują do jednego z tych typów:

  • LOCALITY

  • SUBLOCALITY

  • POSTAL_CODE

  • COUNTRY

  • ADMINISTRATIVE_AREA_LEVEL_1

  • ADMINISTRATIVE_AREA_LEVEL_2

  • TypeFilter.CITIES – zwraca tylko wyniki pasujące do LOCALITY lub ADMINISTRATIVE_AREA_LEVEL_3.

• Opcjonalnie: LatLng określający lokalizację źródła żądania. Gdy wywołasz metodę setOrigin(), usługa zwróci odległość w metrach (distanceMeters) od określonego punktu początkowego dla każdej podpowiedzi autouzupełniania w odpowiedzi.

Informacje o typach miejsc znajdziesz w przewodniku po typach miejsc.

Poniższy przykład pokazuje pełne wywołanie metody PlacesClient.findAutocompletePredictions().

    // Create a new token for the autocomplete session. Pass this to FindAutocompletePredictionsRequest,
    // and once again when the user makes a selection (for example when calling fetchPlace()).
    val token = AutocompleteSessionToken.newInstance()

    // Create a RectangularBounds object.
    val bounds = RectangularBounds.newInstance(
        LatLng(-33.880490, 151.184363),
        LatLng(-33.858754, 151.229596),
    )
    // Use the builder to create a FindAutocompletePredictionsRequest.
    val request =
        FindAutocompletePredictionsRequest.builder()
            // Call either setLocationBias() OR setLocationRestriction().
            .setLocationBias(bounds)
            // .setLocationRestriction(bounds)
            .setOrigin(LatLng(-33.8749937, 151.2041382))
            .setCountries("AU", "NZ")
            .setTypesFilter(listOf(PlaceTypes.ESTABLISHMENT))
            .setSessionToken(token)
            .setQuery(query)
            .build()
    placesClient.findAutocompletePredictions(request)
        .addOnSuccessListener { response: FindAutocompletePredictionsResponse ->
            val builder = StringBuilder()
            for (prediction in response.autocompletePredictions) {
                builder.append(prediction.getPrimaryText(null).toString()).append("\n")
                Log.i(TAG, prediction.placeId)
                Log.i(TAG, prediction.getPrimaryText(null).toString())
            }
            binding.autocompleteResult.text = builder.toString()
        }.addOnFailureListener { exception: Exception? ->
            if (exception is ApiException) {
                Log.e(TAG, "Place not found: ${exception.statusCode}")
                binding.autocompleteResult.text = getString(R.string.place_not_found, exception.message)
            }
        }

      

    // Create a new token for the autocomplete session. Pass this to
    // FindAutocompletePredictionsRequest,
    // and once again when the user makes a selection (for example when calling fetchPlace()).
    AutocompleteSessionToken token = AutocompleteSessionToken.newInstance();

    // Create a RectangularBounds object.
    RectangularBounds bounds =
            RectangularBounds.newInstance(
                    new LatLng(-33.880490, 151.184363), new LatLng(-33.858754, 151.229596));
    // Use the builder to create a FindAutocompletePredictionsRequest.
    FindAutocompletePredictionsRequest request =
            FindAutocompletePredictionsRequest.builder()
                    // Call either setLocationBias() OR setLocationRestriction().
                    .setLocationBias(bounds)
                    // .setLocationRestriction(bounds)
                    .setOrigin(new LatLng(-33.8749937, 151.2041382))
                    .setCountries("AU", "NZ")
                    .setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT))
                    .setSessionToken(token)
                    .setQuery(query)
                    .build();

    placesClient
            .findAutocompletePredictions(request)
            .addOnSuccessListener(
                    (response) -> {
                        StringBuilder builder = new StringBuilder();
                        for (AutocompletePrediction prediction :
                                response.getAutocompletePredictions()) {
                            builder.append(prediction.getPrimaryText(null).toString())
                                    .append("\n");
                            Log.i(TAG, prediction.getPlaceId());
                            Log.i(TAG, prediction.getPrimaryText(null).toString());
                        }
                        binding.autocompleteResult.setText(builder.toString());
                    })
            .addOnFailureListener(
                    (exception) -> {
                        if (exception instanceof ApiException apiException) {
                            Log.e(TAG, "Place not found: " + apiException.getStatusCode());
                            binding.autocompleteResult.setText(
                                    getString(
                                            R.string.place_not_found,
                                            apiException.getMessage()));
                        }
                    });

      

Interfejs API zwraca obiekt FindAutocompletePredictionsResponse w  Task. FindAutocompletePredictionsResponse zawiera listę obiektów AutocompletePrediction reprezentujących prognozowane miejsca. Lista może być pusta, jeśli nie ma znanego miejsca odpowiadającego zapytaniu i kryteriom filtra.

W przypadku każdego przewidywanego miejsca możesz wywołać te metody, aby pobrać szczegółowe informacje o miejscu:

• getFullText(CharacterStyle) zwraca pełny tekst opisu miejsca. Jest to połączenie tekstu głównego i dodatkowego. Przykład: „Wieża Eiffla, Avenue Anatole France, Paryż, Francja”. Dodatkowo ta metoda pozwala wyróżnić sekcje opisu, które pasują do wyszukiwania, za pomocą wybranego stylu, używając CharacterStyle. Parametr CharacterStyle jest opcjonalny. Jeśli nie potrzebujesz wyróżniania, ustaw wartość null.
• getPrimaryText(CharacterStyle) zwraca główny tekst opisujący miejsce. Zwykle jest to nazwa miejsca. Przykłady: „Wieża Eiffla” i „ul. Piotrkowska 123”.
• getSecondaryText(CharacterStyle) zwraca tekst dodatkowy opisu miejsca. Jest to przydatne na przykład jako drugi wiersz podczas wyświetlania podpowiedzi autouzupełniania. Przykłady: „Avenue Anatole France, Paryż, Francja” i „Sydney, Nowa Południowa Walia”.
• getPlaceId() zwraca identyfikator miejsca, które zostało przewidziane. Identyfikator miejsca to identyfikator tekstowy, który jednoznacznie identyfikuje miejsce. Możesz go użyć, aby później ponownie pobrać obiekt Place. Więcej informacji o identyfikatorach miejsc w pakiecie SDK Miejsc na Androida znajdziesz w artykule Szczegóły miejsca. Ogólne informacje o identyfikatorach miejsc znajdziesz w omówieniu identyfikatorów miejsc.
• getPlaceTypes() zwraca listę typów miejsc powiązanych z danym miejscem.
• getDistanceMeters() zwraca odległość w linii prostej w metrach między tym miejscem a miejscem początkowym określonym w żądaniu.

Tokeny sesji

Tokeny sesji grupują etapy zapytania i wyboru wyszukiwania z autouzupełnianiem przez użytkownika w osobną sesję na potrzeby rozliczeń. Sesja rozpoczyna się, gdy użytkownik zaczyna wpisywać zapytanie, a kończy, gdy wybiera miejsce. Każda sesja może zawierać wiele zapytań, po których następuje wybór jednego miejsca. Po zakończeniu sesji token traci ważność. Aplikacja musi wygenerować nowy token dla każdej sesji. Zalecamy używanie tokenów sesji we wszystkich sesjach autouzupełniania wywoływanych automatycznie (gdy umieszczasz fragment lub uruchamiasz autouzupełnianie za pomocą intencji, interfejs API zajmuje się tym automatycznie).

Pakiet SDK Miejsc na Androida używa AutocompleteSessionToken do identyfikowania każdej sesji. Aplikacja powinna przekazywać nowy token sesji na początku każdej nowej sesji, a następnie przekazywać ten sam token wraz z identyfikatorem miejsca w kolejnym wywołaniu metody fetchPlace(), aby pobrać informacje o miejscu wybranego przez użytkownika.

Więcej informacji o tokenach sesji

Ograniczanie wyników autouzupełniania

Możesz ograniczyć wyniki autouzupełniania do określonego regionu geograficznego lub przefiltrować je według co najmniej jednego typu miejsca albo maksymalnie 5 krajów. Te ograniczenia możesz stosować do aktywności autouzupełniania, AutocompleteSupportFragment i interfejsów API do automatycznego uzupełniania.

Aby ograniczyć wyniki:

• Aby preferować wyniki w zdefiniowanym regionie, wywołaj setLocationBias() (mogą być nadal zwracane niektóre wyniki spoza zdefiniowanego regionu).
• Aby wyświetlać tylko wyniki z określonego regionu, wywołaj setLocationRestriction() (zwracane będą tylko wyniki z określonego regionu).
• Aby zwracać tylko wyniki zgodne z określonym typem miejsca, wywołaj setTypesFilter() (np. podanie TypeFilter.ADDRESS spowoduje zwrócenie tylko wyników z dokładnym adresem).
• Aby zwracać tylko wyniki z maksymalnie 5 określonych krajów, wywołaj setCountries(). Kraje muszą być przekazywane jako dwuznakowy kod kraju zgodny ze standardem ISO 3166-1 alfa-2.

Faworyzowanie wyników z określonego regionu

Aby wyniki autouzupełniania były ukierunkowane na określony region geograficzny, wywołaj metodę setLocationBias(), przekazując obiekt RectangularBounds. Poniższy przykładowy kod pokazuje wywołanie metody setLocationBias() w instancji fragmentu, aby zawęzić sugestie autouzupełniania do regionu Sydney w Australii.

        intentBuilder.setLocationBias(bounds)

      

        intentBuilder.setLocationBias(
                RectangularBounds.newInstance(
                        new LatLng(-33.880490, 151.184363),
                        new LatLng(-33.858754, 151.229596)));

      

Ograniczanie wyników do określonego regionu

Aby ograniczyć wyniki autouzupełniania do określonego regionu geograficznego, wywołaj funkcję setLocationRestriction(), przekazując obiekt RectangularBounds. Poniższy przykładowy kod pokazuje wywołanie setLocationRestriction() w instancji fragmentu, aby ukierunkować sugestie autouzupełniania na region Sydney w Australii.

        intentBuilder.setLocationRestriction(bounds)

      

        intentBuilder.setLocationRestriction(
                RectangularBounds.newInstance(
                        new LatLng(-33.880490, 151.184363),
                        new LatLng(-33.858754, 151.229596)));

      

Uwaga: to ograniczenie dotyczy tylko całych tras. Wyniki syntetyczne znajdujące się poza prostokątnymi granicami mogą być zwracane na podstawie trasy, która pokrywa się z ograniczeniem lokalizacji.

Filtrowanie wyników według typów miejsc lub kolekcji typów

Możesz ograniczyć wyniki żądania autouzupełniania, aby zwracały tylko określony typ miejsca. Określ filtr, używając typów miejsc lub kolekcji typów wymienionych w tabelach 1, 2 i 3 na stronie Typy miejsc. Jeśli nic nie określisz, zwracane są wszystkie typy.

Aby filtrować wyniki autouzupełniania, wywołaj metodę setTypesFilter() i ustaw filtr.

Aby określić filtr typu lub zbioru typów:

• Wywołaj setTypesFilter() i podaj maksymalnie 5 wartości type z tabeli 1 i 2 widocznych w sekcji Typy miejsc. Wartości typów są definiowane przez stałe w PlaceTypes.

• Wywołaj setTypesFilter() i określ kolekcję typów z tabeli 3 pokazanej w sekcji Typy miejsc. Wartości kolekcji są definiowane przez stałe w PlaceTypes.

  W żądaniu dozwolony jest tylko 1 typ z tabeli 3. Jeśli podasz wartość z tabeli 3, nie możesz podać wartości z tabeli 1 ani 2. Jeśli to zrobisz, wystąpi błąd.

Poniższy przykładowy kod wywołuje metodę setTypesFilter() na obiekcie AutocompleteSupportFragment i określa wiele wartości typu.

    intentBuilder.setTypesFilter(listOf("landmark", "restaurant", "store"))

      

    intentBuilder.setTypesFilter(List.of("landmark", "restaurant", "store"));

      

Poniższy przykładowy kod pokazuje wywołanie setTypesFilter() w AutocompleteSupportFragment, aby ustawić filtr zwracający tylko wyniki z dokładnym adresem przez określenie kolekcji typów.

    intentBuilder.setTypesFilter(listOf(PlaceTypes.ADDRESS))

      

    intentBuilder.setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT));

      

Poniższy przykładowy kod pokazuje wywołanie setTypesFilter() w IntentBuilder, aby ustawić filtr zwracający tylko wyniki z dokładnym adresem przez określenie kolekcji typów.

    val intent = PlaceAutocomplete.createIntent(this) {
        setTypesFilter(listOf(PlaceTypes.ESTABLISHMENT))
    }

      

    Intent intent =
            new PlaceAutocomplete.IntentBuilder()
                    .setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT))
                    .build(this);

      

Filtrowanie wyników według kraju

Aby filtrować wyniki autouzupełniania do maksymalnie 5 krajów, wywołaj setCountries(), aby ustawić kod kraju. Następnie przekaż filtr do fragmentu lub intencji. Kraje muszą być przekazywane jako dwuznakowy kod kraju zgodny ze standardem ISO 3166-1 alfa-2.

Poniższy przykładowy kod pokazuje wywołanie setCountries() w AutocompleteSupportFragment, aby ustawić filtr zwracający tylko wyniki w określonych krajach.

    intentBuilder.setCountries(listOf("AU", "NZ"))

      

    intentBuilder.setCountries(List.of("AU", "NZ"));

      

Limity wykorzystania

Korzystanie z interfejsu Places API (starsza wersja), w tym z pakietu Places SDK for Android (starsza wersja), nie jest już ograniczone do maksymalnej liczby żądań dziennie. Nadal obowiązują jednak te limity wykorzystania:

• Limit wynosi 6000 żądań na minutę. Jest on obliczany jako suma żądań po stronie klienta i po stronie serwera dla wszystkich aplikacji korzystających z danych logowania tego samego projektu.

Wyświetlanie atrybucji w aplikacji

• Jeśli Twoja aplikacja korzysta z usługi autouzupełniania automatycznie, interfejs musi wyświetlać atrybucję „Powered by Google” lub mapę z logo Google.
• Jeśli Twoja aplikacja korzysta z widżetu autouzupełniania, nie musisz nic robić (wymagane informacje o autorstwie są wyświetlane domyślnie).
• Jeśli po pobraniu miejsca według identyfikatora pobierzesz i wyświetlisz dodatkowe informacje o miejscu, musisz też wyświetlić informacje o autorze pochodzące od innych firm.

Więcej informacji znajdziesz w dokumentacji dotyczącej atrybucji.

Optymalizacja Autouzupełniania miejsc (starsza wersja)

W tej sekcji opisujemy sprawdzone metody, które pomogą Ci w pełni wykorzystać możliwości usługi autouzupełniania miejsc (starszej wersji).

Oto ogólne wskazówki:

• Najszybszym sposobem na stworzenie działającego interfejsu użytkownika jest użycie widżetu autouzupełniania miejsc (starsza wersja) z Maps JavaScript API, widżetu autouzupełniania miejsc (starsza wersja) z pakietu SDK Miejsc na Androida lub elementu sterującego interfejsu autouzupełniania miejsc (starsza wersja) z pakietu SDK Miejsc na iOS.
• Od samego początku poznaj najważniejsze pola danych Autouzupełniania miejsc (starsza wersja).
• Pola ukierunkowania na lokalizację i ograniczenia lokalizacji są opcjonalne, ale mogą mieć znaczący wpływ na działanie autouzupełniania.
• Użyj obsługi błędów, aby upewnić się, że aplikacja będzie działać prawidłowo, jeśli interfejs API zwróci błąd.
• Upewnij się, że aplikacja obsługuje sytuację, gdy nie ma wyboru, i oferuje użytkownikom sposób na kontynuowanie.

Sprawdzone metody optymalizacji kosztów

Podstawowa optymalizacja kosztów

Aby zoptymalizować koszty korzystania z usługi Autouzupełnianie miejsc (starsza wersja), użyj masek pól w widżetach Informacje o miejscu (starsza wersja) i Autouzupełnianie miejsc (starsza wersja), aby zwracać tylko te pola danych Autouzupełniania miejsc (starsza wersja), których potrzebujesz.

Zaawansowana optymalizacja kosztów

Rozważ automatyczne wdrożenie autouzupełniania miejsc (starsza wersja), aby uzyskać dostęp do SKU: Autouzupełnianie – cena za żądanie i poprosić o wyniki z interfejsu Geocoding API dotyczące wybranego miejsca zamiast informacji o miejscu (starsza wersja). Ceny za żądanie w połączeniu z Geocoding API są bardziej opłacalne niż ceny za sesję, jeśli spełnione są oba te warunki:

• Jeśli potrzebujesz tylko szerokości i długości geograficznej lub adresu miejsca wybranego przez użytkownika, interfejs Geocoding API dostarcza te informacje za mniejszą opłatą niż wywołanie interfejsu Place Details (starsza wersja).
• Jeśli użytkownicy wybierają podpowiedź autouzupełniania średnio w ciągu maksymalnie 4 żądań podpowiedzi autouzupełniania miejsc (starsza wersja), ceny za żądanie mogą być bardziej opłacalne niż ceny za sesję.

Czy Twoja aplikacja wymaga innych informacji niż adres i szerokość/długość geograficzna wybranej podpowiedzi?

Sprawdzone metody dotyczące skuteczności

Poniższe wytyczne opisują sposoby optymalizacji wydajności autouzupełniania miejsc (starsza wersja):

• Dodaj do implementacji Autouzupełniania miejsc (starszej wersji) ograniczenia związane z krajem, ustawienia lokalizacji i (w przypadku implementacji automatycznych) preferencje językowe. Ustawienia języka nie są potrzebne w przypadku widżetów, ponieważ pobierają one ustawienia języka z przeglądarki lub urządzenia mobilnego użytkownika.
• Jeśli autouzupełnianiu miejsc (starsza wersja) towarzyszy mapa, możesz ustawić preferencje lokalizacji według widocznego obszaru mapy.
• W sytuacjach, gdy użytkownik nie wybierze żadnej z podpowiedzi autouzupełniania miejsc (starsza wersja), zwykle dlatego, że żadna z nich nie jest adresem, którego szuka, możesz ponownie użyć pierwotnych danych wejściowych użytkownika, aby spróbować uzyskać trafniejsze wyniki:
  • Jeśli oczekujesz, że użytkownik wpisze tylko informacje o adresie, użyj ponownie oryginalnych danych wejściowych użytkownika w wywołaniu interfejsu Geocoding API.
  • Jeśli oczekujesz, że użytkownik będzie wpisywać zapytania dotyczące konkretnego miejsca według nazwy lub adresu, użyj żądania informacji o miejscu (starsza wersja). Jeśli wyniki są oczekiwane tylko w określonym regionie, użyj ustawienia lokalizacji.
  Inne scenariusze, w których najlepiej jest użyć Geocoding API:
  • Użytkownicy wpisują adresy podlokali, np. adresy konkretnych lokali lub mieszkań w budynku. Na przykład czeski adres „Stroupežnického 3191/17, Praha” zwraca częściową podpowiedź w Autouzupełnianiu miejsc (starsza wersja).
  • Użytkownicy wpisują adresy z prefiksami segmentów dróg, np. „23-30 29th St, Queens” w Nowym Jorku lub „47-380 Kamehameha Hwy, Kaneohe” na wyspie Kauai na Hawajach.

Uwzględnianie lokalizacji

Możesz faworyzować wyniki z określonego obszaru, przekazując parametry location i radius. Dzięki temu Autouzupełnianie miejsc (starsza wersja) będzie preferować wyświetlanie wyników w określonym obszarze. Wyniki spoza zdefiniowanego obszaru mogą być nadal wyświetlane. Możesz użyć parametru includedRegionCodes, aby filtrować wyniki i wyświetlać tylko miejsca w określonym kraju.

Ograniczanie lokalizacji

Ogranicz wyniki do określonego obszaru, przekazując parametr locationRestriction.

Możesz też ograniczyć wyniki do regionu określonego przez parametry location i radius, dodając parametr strictbounds. Dzięki temu autouzupełnianie miejsc (starsza wersja) zwraca tylko wyniki z tego regionu.

Rozwiązywanie problemów

Chociaż może wystąpić wiele różnych błędów, większość z nich jest zwykle spowodowana błędami konfiguracji (np. użyto nieprawidłowego klucza interfejsu API lub klucz interfejsu API został nieprawidłowo skonfigurowany) lub błędami limitu (aplikacja przekroczyła limit). Więcej informacji o limitach znajdziesz w sekcji Limity wykorzystania.

Błędy, które wystąpiły podczas korzystania z elementów sterujących autouzupełniania, są zwracane w wywołaniu zwrotnym onActivityResult(). Wywołaj Autocomplete.getStatus(), aby uzyskać komunikat o stanie wyniku.