Autouzupełnianie miejsc (nowość)

Usługa Autocomplete (nowa) to interfejs API na iOS, który w odpowiedzi na żądanie zwraca sugestie dotyczące miejsc. W żądaniu podaj ciąg tekstowy wyszukiwania i granice geograficzne, które określają obszar wyszukiwania.

Usługa Autouzupełnianie (nowa) może dopasowywać pełne słowa i podciągi wejściowe, rozwiązując nazwy miejsc, adresy i kody plus. Dzięki temu aplikacje mogą wysyłać zapytania w trakcie pisania przez użytkownika, aby na bieżąco podawać sugestie dotyczące miejsc.

Sugestie miejsc to miejsca, takie jak firmy, adresy i ciekawe miejsca, które są wyświetlane na podstawie podanego ciągu tekstowego i obszaru wyszukiwania.

Na przykład wywołujesz interfejs API, używając jako danych wejściowych ciągu znaków zawierającego częściowe dane wejściowe użytkownika „Spagh”, a obszar wyszukiwania jest ograniczony do Nowego Jorku. Odpowiedź zawiera listę sugestii miejsc pasujących do ciągu wyszukiwania i obszaru wyszukiwania, np. restauracji „Cafe Spaghetti”, wraz ze szczegółowymi informacjami o tym miejscu.

Zwrócone sugestie miejsc są przeznaczone do wyświetlania użytkownikowi, aby mógł wybrać odpowiednie miejsce. Możesz wysłać żądanie Place Details (New), aby uzyskać więcej informacji o dowolnej z proponowanych lokalizacji.

Funkcję autouzupełniania (nową) możesz zintegrować z aplikacją na 2 główne sposoby:

• Pobieranie prognoz dotyczących miejsc w sposób automatyczny: wywołuj interfejs API bezpośrednio, aby pobierać prognozy i wyświetlać je w niestandardowym interfejsie użytkownika.
• Dodaj widżet autouzupełniania miejsc: zapewnia gotowe do użycia autouzupełnianie wyszukiwania, które wyświetla prognozy podczas wpisywania przez użytkownika.

Programowe uzyskiwanie prognoz dotyczących miejsc

Żądania autouzupełniania (nowe)

Utwórz żądanie autouzupełniania, wywołując metodę w GMSPlacesClient. Parametry możesz przekazywać w obiekcie GMSAutocompleteRequest. Odpowiedź zawiera sugestie autouzupełniania w obiekcie GMSAutocompletePlaceSuggestion.

Wymagane są klucz interfejsu API i parametry query. Możesz też dodać parametr GMSAutocompleteSessionToken , aby powiązać żądania z sesją rozliczeniową, oraz parametr GMSAutocompleteFilter , aby zastosować go do wyników.

Więcej informacji o parametrach wymaganych i opcjonalnych znajdziesz w sekcji parametrów w tym dokumencie.

let center = (37.3913916, -122.0879074)
let northEast = (37.388162, -122.088137)
let southWest = (37.395804, -122.077023)

let bias = RectangularCoordinateRegion(northEast: northEast, southWest: southWest)
let filter = AutocompleteFilter(types: [ .restaurant ], origin: center, coordinateRegionBias: bias)

let autocompleteRequest = AutocompleteRequest(query: "Sicilian piz", filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  // Handle suggestions.
case .failure(let placesError):
  // Handle error.
}

let token = GMSAutocompleteSessionToken()

let northWestBounds = CLLocationCoordinate2DMake(40.921628, -73.700051)
let southEastBounds = CLLocationCoordinate2DMake(40.477398, -74.259087)

let filter = GMSAutocompleteFilter()
filter.types = [kGMSPlaceTypeRestaurant]
filter.locationBias = GMSPlaceRectangularLocationOption(northWestBounds, southEastBounds)

let request = GMSAutocompleteRequest(query:"Spagh")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

CLLocationCoordinate2D northEast = CLLocationCoordinate2DMake(37.388162, -122.088137);
CLLocationCoordinate2D southWest = CLLocationCoordinate2DMake(37.395804, -122.077023);

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.types = @[ kGMSPlaceTypeRestaurant ];
filter.locationBias = GMSPlaceRectangularLocationOption(northEast, southWest);
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Sicilian piz"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

Odpowiedzi dotyczące autouzupełniania (nowe)

Autouzupełnianie zwraca tablicę zawierającą maksymalnie 5 instancjiGMSAutocompleteSuggestion. Tablica zawiera:

• placeID
• types: typy, które dotyczą tego miejsca.
• distanceMeters: odległość od punktu początkowego.
• attributedFullText: pełny tekst sugestii w formacie czytelnym dla człowieka.
• attributedPrimaryText: tekst główny sugestii czytelny dla człowieka.
• attributedSecondaryText: dodatkowy tekst sugestii czytelny dla człowieka.
• structuredFormat: konkretna nazwa i tekst rozróżniający, np. miasto lub region.

Wymagane parametry

zapytanie

Ciąg tekstowy, w którym ma zostać przeprowadzone wyszukiwanie. Podaj pełne słowa i podciągi, nazwy miejsc, adresy i kody plus. Usługa Autocomplete (New) zwraca pasujące propozycje na podstawie tego ciągu znaków i porządkuje wyniki według ich trafności.

Parametry opcjonalne

sessionToken

Tokeny sesji to ciągi znaków generowane przez użytkownika, które śledzą wywołania funkcji Autocomplete (nowej) – zarówno wywołania za pomocą widżetu, jak i wywołania programowe – jako „sesje”. Autouzupełnianie (nowe) używa tokenów sesji do grupowania faz zapytania i wyboru w wyszukiwaniu autouzupełniania użytkownika w osobną sesję na potrzeby rozliczeń.

Możesz udostępnić token sesji autouzupełniania Miejsc, aby przekazać go do innych usług, które nie są częścią pakietu Places SDK na iOS, np. do weryfikacji adresu:

let token = AutocompleteSessionToken()
let filter = AutocompleteFilter(origin: CLLocationCoordinate2DMake(39.7, -94.5))
let request = AutocompleteRequest(query: "Piz", sessionToken: token, filter: filter)

PlacesClient.shared.fetchAutocompleteSuggestions(request: request) {
    case .success(let suggestions):
      ...
    case .failure(let placesError):
      print(placesError) 
}

// pass token's string format to use with a service that is not a part of iOS SDK.
print("token: \(token)")

GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Piz"];
GMSAutocompleteSessionToken *token = [[GMSAutocompleteSessionToken alloc] init];
request.sessionToken = token;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.origin = [[CLLocation alloc] initWithLatitude:39.7 longitude:-94.5];
filter.locationBias = GMSPlaceRectangularLocationOption(topLocation, bottomLocation);

request.filter = filter;
 [[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request
                     callback:^(NSArray<GMSAutocompleteSuggestion *> *_Nullable results,
                                NSError *_Nullable error) {
  ...
}];

// pass token's string format to use with a service that is not a part of iOS SDK.
NSLog(@"%@", token.description);

Więcej informacji znajdziesz w sekcji Tokeny sesji.

Opcjonalne parametry AutocompleteFilter

typy

Miejsce może mieć tylko jeden typ podstawowy z typów Tabela A lub Tabela B. Typem podstawowym może być np. mexican_restaurant lub steak_house.

Domyślnie interfejs API zwraca wszystkie miejsca na podstawie parametru input, niezależnie od wartości typu podstawowego powiązanej z miejscem. Ogranicz wyniki do określonego typu podstawowego lub typów podstawowych, przekazując parametr types.

Użyj tego parametru, aby określić maksymalnie 5 wartości typu z tabeli A lub tabeli B. Aby miejsce zostało uwzględnione w odpowiedzi, musi pasować do jednej z określonych wartości typu podstawowego.

Żądanie zostanie odrzucone z błędem INVALID_REQUEST, jeśli:

• Określono więcej niż 5 typów.
• Wszystkie nierozpoznane typy są określone.

Aby na przykład ograniczyć wyniki do sklepów z artykułami sportowymi, określ ten typ w AutocompleteFilter:

let filter = AutocompleteFilter(types: [ PlaceType(rawValue: "sporting_goods_store") ])
  

let filter = GMSAutocompleteFilter()
filter.types = ["sporting_goods_store"]
  

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.types = @[ "sporting_goods_store" ];

kraje

Uwzględniaj tylko wyniki z listy określonych regionów, podanej jako tablica zawierająca maksymalnie 15 dwuznakowych wartości ccTLD („domena najwyższego poziomu”). Jeśli ten parametr zostanie pominięty, do odpowiedzi nie zostaną zastosowane żadne ograniczenia. Aby ograniczyć regiony do Niemiec i Francji:

let filter = AutocompleteFilter(countries: ["DE", "FR"])
  

let filter = GMSAutocompleteFilter()
filter.countries = ["DE", "FR"]

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.countries = @[ @"DE", @"FR" ];

Jeśli określisz zarówno parametr locationRestriction, jak i parametr countries, wyniki będą znajdować się w obszarze przecięcia tych dwóch ustawień.

inputOffset

Odsunięcie znaku Unicode od zera wskazujące pozycję kursora w input. Pozycja kursora może wpływać na zwracane prognozy. Jeśli jest pusta, domyślnie przyjmuje długość input.

locationBias lub locationRestriction

Aby określić obszar wyszukiwania, możesz podać locationBias lub locationRestriction, ale nie oba te parametry. locationRestriction określa region, w którym muszą się znajdować wyniki, a locationBias określa region, w pobliżu którego muszą się znajdować wyniki, ale mogą być poza tym obszarem.

• locationBias określa obszar wyszukiwania. Ta lokalizacja służy jako punkt odniesienia, co oznacza, że mogą być zwracane wyniki z okolic określonej lokalizacji, w tym wyniki spoza określonego obszaru.

• locationRestriction określa obszar wyszukiwania. Wyniki spoza określonego obszaru nie są zwracane.

Określ region locationBias lub locationRestriction jako prostokątny obszar widoku lub jako okrąg.

Okrąg jest definiowany przez punkt środkowy i promień w metrach. Promień musi mieścić się w zakresie od 0,0 do 50 000,0 (włącznie). Wartością domyślną jest 0,0. W przypadku locationRestriction musisz ustawić promień na wartość większą niż 0, 0. W przeciwnym razie żądanie nie zwraca żadnych wyników.

Na przykład:

let center = CLLocationCoordinate2DMake(40.477398, -74.259087)

let bias = CircularCoordinateRegion(center: center, radius: 1000.0)

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

let center = CLLocationCoordinate2DMake(40.730610, -73.935242)
let radius = 1000.0

filter.locationBias = GMSPlaceCircularLocationOption(center, radius)

CLLocationCoordinate2D center = CLLocationCoordinate2DMake(40.730610, -73.935242);
radius = 1000.0;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationBias = GMSPlaceCircularLocationOption(center, radius);

Prostokąt to widoczny obszar określony przez szerokość i długość geograficzną, reprezentowany przez 2 przeciwległe punkty low i high. Widoczny obszar jest uważany za region zamknięty, co oznacza, że obejmuje swoje granice. Zakres szerokości geograficznej musi się mieścić w przedziale od -90 do 90 stopni włącznie, a zakres długości geograficznej – od -180 do 180 stopni włącznie:

• Jeśli low = high, widoczny obszar składa się z tego jednego punktu.
• Jeśli low.longitude > high.longitude, zakres długości geograficznej jest odwrócony (obszar widoczny przekracza linię długości geograficznej 180°).
• Jeśli low.longitude = -180 stopni, a high.longitude= 180 stopni, obszar widoczny obejmuje wszystkie długości geograficzne.
• Jeśli low.longitude = 180 stopni, a high.longitude = -180 stopni, zakres długości geograficznej jest pusty.

Musisz wypełnić oba pola low i high, a reprezentowane pole nie może być puste. Pusty widoczny obszar powoduje błąd.

Na przykład ten widoczny obszar w całości obejmuje Nowy Jork:

let northEast = CLLocationCoordinate2DMake(40.477398, -74.259087)
let southWest = CLLocationCoordinate2DMake(40.921628, -73.700051)

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

let high = CLLocationCoordinate2DMake(40.921628, -73.700051)
let low = CLLocationCoordinate2DMake(40.477398, -74.259087)

let filter = GMSAutocompleteFilter()
filter.locationBias = GMSPlaceRectangularLocationOption(high, low)

CLLocationCoordinate2D high = CLLocationCoordinate2DMake(40.477398, -74.259087);
CLLocationCoordinate2D low = CLLocationCoordinate2DMake(440.921628, -73.700051);

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationBias = GMSPlaceRectangularLocationOption(high, low);

pochodzenie

Punkt początkowy, od którego należy obliczyć odległość w linii prostej do miejsca docelowego (zwracana jako distanceMeters). Jeśli ta wartość zostanie pominięta, odległość w linii prostej nie zostanie zwrócona. Musi być określony jako współrzędne szerokości i długości geograficznej:

let filter = AutocompleteFilter(origin: CLLocation(latitude: 37.395804, longitude: -122.077023))
  

let filter = GMSAutocompleteFilter()
filter.origin =  CLLocation(latitude: 37.395804, longitude: -122.077023)
 

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];

filter.origin = [[CLLocation alloc] initWithLatitude:37.395804 longitude: -122.077023];

regionCode

Kod regionu użyty do sformatowania odpowiedzi, określony jako 2-znakowa wartość ccTLD („domena najwyższego poziomu”). Większość kodów ccTLD jest identyczna z kodami ISO 3166-1, z kilkoma istotnymi wyjątkami. Na przykład krajowa domena najwyższego poziomu Zjednoczonego Królestwa to „uk” (.co.uk), a kod ISO 3166-1 to „gb” (technicznie dla podmiotu „Zjednoczone Królestwo Wielkiej Brytanii i Irlandii Północnej”).

Jeśli podasz nieprawidłowy kod regionu, interfejs API zwróci błąd INVALID_ARGUMENT. W zależności od obowiązujących przepisów parametr może wpływać na wyniki.

shouldIncludePureServiceAreaBusinesses

Jeśli true, zwraca w tablicy odpowiedzi firmy działające na określonym obszarze. Firma działająca na określonym obszarze to firma, która świadczy usługi na miejscu u klienta lub samodzielnie dostarcza produkty odbiorcom, ale nie obsługuje klientów pod swoim adresem.

Na przykład:

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.shouldIncludePureServiceAreaBusinesses = YES;

Dodawanie widżetu Autouzupełnianie miejsc

Aby łatwiej zapewnić spójne działanie autouzupełniania miejsc, możesz dodać do aplikacji widżet autouzupełniania miejsc. Widżet udostępnia dedykowany interfejs pełnoekranowy, który obsługuje dane wejściowe użytkownika i wyświetla prognozowane miejsca, a jednocześnie zwraca do aplikacji obiekty AutocompletePlaceSuggestion. Następnie możesz wysłać żądanie Szczegóły miejsca (nowe), aby uzyskać dodatkowe informacje o dowolnym z prognozowanych miejsc.

Podobnie jak w przypadku programowego uzyskiwania prognoz dotyczących miejsc, widżet autouzupełniania miejsc umożliwia używanie tokenów sesji do grupowania żądań autouzupełniania w sesje na potrzeby rozliczeń. Możesz przekazać token sesji, wywołując funkcję AutocompleteSessionToken().

Jeśli nie podasz tokena sesji, widżet utworzy dla Ciebie token sesji Autocomplete, który możesz następnie uzyskać z wywołania zwrotnego onSelection. Więcej informacji o używaniu tokenów sesji znajdziesz w artykule Tokeny sesji.

Gdy wartość powiązania show jest ustawiona na true, użytkownik zostanie przeniesiony do widoku pełnoekranowego, w którym może wybrać miejsce. Gdy użytkownik wpisuje tekst, widżet zwraca sugestie dotyczące miejsc, takich jak firmy, adresy i ciekawe miejsca. Gdy użytkownik wybierze miejsce, widżet wywoła funkcję obsługi onSelection z wybranym miejscem i zamknie widok pełnoekranowy.

Parametry widżetu Autouzupełnianie miejsc

Oprócz parametrów dostępnych programowo widżet autouzupełniania miejsc oferuje też te parametry:

pokaż

show określa, czy widżet jest wyświetlany.

onSelection

Funkcja do uruchomienia po wybraniu miejsca.

onError

Funkcja do uruchomienia w przypadku wystąpienia błędu. W przypadku wystąpienia błędu zostanie przekazana wartość A PlacesError.

Dostosowywanie treści i motywów

Parametry AutocompleteUICustomization określają dostosowania interfejsu, które mają być zastosowane do widżetu. Opcje dostosowywania:

• AutocompleteListDensity. Ten parametr pozwala wybrać gęstość listy sugestii:multiLine lub twoLine.
• AutocompleteUIIcon. Ten parametr umożliwia określenie, czy dla każdego elementu listy ma być wyświetlana ikona domyślna.
• themeTen parametr określa motyw niestandardowy, który zastępuje dowolny z domyślnych atrybutów stylu. Możesz dostosować kolory, typografię, odstępy, obramowania i rogi komponentu autouzupełniania miejsc. Wartość domyślna to PlacesMaterialTheme. Wszystkie atrybuty motywu, które nie zostały zastąpione, używają stylów domyślnych.

Zobacz przykład pełnego kodu

Przykłady autouzupełniania (nowość)

Używanie parametrów locationRestriction i locationBias

Autouzupełnianie (nowe) domyślnie korzysta z określania obszaru wyszukiwania na podstawie adresu IP. W przypadku określania preferencji na podstawie adresu IP interfejs API używa adresu IP urządzenia do określania preferencji wyników. Opcjonalnie możesz użyć locationRestriction lub locationBias, ale nie obu tych parametrów, aby określić obszar wyszukiwania.

Ograniczenie lokalizacji określa obszar wyszukiwania. Wyniki spoza określonego obszaru nie są zwracane. W tym przykładzie użyto ograniczenia lokalizacji, aby ograniczyć żądanie do okrągłego obszaru o promieniu 5000 metrów, którego środek znajduje się w San Francisco:

let center = (37.775061, -122.419400)
let radius = 5000.0
let restriction = CircularCoordinateRegion(center: center, radius: radius)
let filter = AutocompleteFilter(coordinateRegionRestriction: restriction)
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Sicilian piz", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
  

let token = GMSAutocompleteSessionToken()

let center = CLLocationCoordinate2DMake(37.775061, -122.419400)
let radius = 5000.0

let filter = GMSAutocompleteFilter()
filter.locationRestriction = GMSPlaceCircularLocationOption(center, radius)

let request = GMSAutocompleteRequest(query:"Piz")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

CLLocationCoordinate2D center = CLLocationCoordinate2DMake(37.775061, -122.419400);
radius = 5000.0;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationRestriction = GMSPlaceCircularLocationOption(center, radius);
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Sicilian piz"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

W przypadku odchylenia związanego z lokalizacją lokalizacja służy jako odchylenie, co oznacza, że mogą być zwracane wyniki w pobliżu określonej lokalizacji, w tym wyniki spoza określonego obszaru. W kolejnym przykładzie zmieniamy poprzednie żądanie, aby używać odchylenia lokalizacji:

let center = (37.775061, -122.419400)
let radius = 5000.0
let bias = CircularCoordinateRegion(center: center, radius: radius)
let filter = AutocompleteFilter(coordinateRegionBias: bias)
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Sicilian piz", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
  

let token = GMSAutocompleteSessionToken()

let center = CLLocationCoordinate2DMake(37.775061, -122.419400)
let radius = 5000.0

let filter = GMSAutocompleteFilter()
filter.locationBias = GMSPlaceCircularLocationOption(center, radius)

let request = GMSAutocompleteRequest(query:"Piz")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

CLLocationCoordinate2D center = CLLocationCoordinate2DMake(37.775061, -122.419400);
radius = 5000.0;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationBias = GMSPlaceCircularLocationOption(center, radius);
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Sicilian piz"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

Typy użycia

Użyj parametru types, aby ograniczyć wyniki żądania do określonego typu wymienionego w tabeli A i tabeli B. Możesz określić tablicę zawierającą maksymalnie 5 wartości. Jeśli nie zostanie podany, zwracane są wszystkie typy.

W tym przykładzie ciąg zapytania to „Soccer”, a parametr types ogranicza wyniki do obiektów typu "sporting_goods_store":

let filter = AutocompleteFilter(types: [ PlaceType(rawValue: "sporting_goods_store") ])
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Soccer", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
    

let token = GMSAutocompleteSessionToken()

let filter = GMSAutocompleteFilter()
filter.types = ["sporting_goods_store"]

let request = GMSAutocompleteRequest(query:"Soccer")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.types = @[ "sporting_goods_store" ];
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Soccer"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

Użyj punktu początkowego

Jeśli w żądaniu uwzględnisz parametr origin określony jako współrzędne szerokości i długości geograficznej, interfejs API uwzględni w odpowiedzi odległość w linii prostej od punktu początkowego do miejsca docelowego. Odpowiedź zwraca odległość jako distanceMeters.

W tym przykładzie punkt początkowy jest ustawiony na środek San Francisco:

let filter = AutocompleteFilter(origin: CLLocation(latitude: 37.7749, longitude: -122.4194))
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Amoeba", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
  

let token = GMSAutocompleteSessionToken()

let origin = CLLocation(latitude: 37.7749, longitude: -122.4194)

let filter = GMSAutocompleteFilter()

filter.origin =  origin

let request = GMSAutocompleteRequest(query:"Amoeba")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText)) and distance: \(String(describing: result.placeSuggestion?.distanceMeters))")
        }
      }
    })

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.origin = [[CLLocation alloc] initWithLatitude:37.395804 longitude:-122.077023];
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Amoeba"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
      }
    }
}];

Dostosowywanie treści i motywu

let uiCustomization = AutocompleteUICustomization(
    listDensity: .multiLine,
    listItemIcon: .noIcon,
    theme: PlacesMaterialTheme()
)

Dodawanie widżetu Autouzupełnianie miejsc (pełny kod)

struct PlaceAutocompleteDemoView: View {

  @State private var fetchedPlace: Place?
  @State private var placesError: PlacesError?
  @State private var showWidget = false

  public var body: some View {
    VStack {
      Button("Search for a place") {
        showWidget.toggle()
      }
      .placeAutocomplete(
        show: $showWidget,
        onSelection: { (autocompletePlaceSuggestion, autocompleteSessionToken) in
          Task {
            let placesClient = await PlacesClient.shared
            let fetchPlaceRequest = FetchPlaceRequest(
              placeID: autocompletePlaceSuggestion.placeID,
              placeProperties: [.displayName, .formattedAddress],
              sessionToken: autocompleteSessionToken
            )

            switch await placesClient.fetchPlace(with: fetchPlaceRequest) {
            case .success(let place):
              print("Fetched place: \(place)")
              self.fetchedPlace = place
            case .failure(let placesError):
              print("Failed to fetch place: \(placesError)")
              self.placesError = placesError
            }
          }
        },
        onError: { placesError in
          self.placesError = placesError
        }
      )
    }
  }
}

Optymalizacja autouzupełniania (nowość)

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

Oto kilka ogólnych wskazówek:

• Najszybszym sposobem na stworzenie działającego interfejsu użytkownika jest użycie widżetu autouzupełniania (nowego) w interfejsie Maps JavaScript API, widżetu autouzupełniania (nowego) w pakiecie SDK Miejsc na Androida lub widżetu autouzupełniania (nowego) w pakiecie SDK Miejsc na iOS.
• Poznaj najważniejsze pola danych autouzupełniania (nowość) od samego początku.
• Pola dotyczące preferowania lokalizacji i ograniczania lokalizacji są opcjonalne, ale mogą mieć znaczący wpływ na skuteczność autouzupełniania.
• Używaj obsługi błędów, aby zapewnić prawidłowe działanie aplikacji, gdy interfejs API zwróci błąd.
• Sprawdź, czy aplikacja obsługuje sytuacje, w których użytkownik nie dokonał wyboru, i czy oferuje mu możliwość kontynuowania.

Sprawdzone metody optymalizacji kosztów

Podstawowa optymalizacja kosztów

Aby zoptymalizować koszt korzystania z usługi Autouzupełnianie (nowa), użyj masek pól w widżetach Szczegóły miejsca (nowe) i Autouzupełnianie (nowe), aby zwracać tylko potrzebne pola danych Autouzupełniania (nowego).

Zaawansowana optymalizacja kosztów

Rozważ programowe wdrożenie Autocomplete (New), aby uzyskać dostęp do SKU: Autocomplete Request pricing i wysyłać zapytania o wyniki interfejsu Geocoding API dotyczące wybranego miejsca zamiast szczegółów miejsca (nowych). Ceny za żądanie w połączeniu z interfejsem Geocoding API są bardziej opłacalne niż ceny za sesję (oparte na sesjach), jeśli spełnione są oba te warunki:

• Jeśli potrzebujesz tylko szerokości i długości geograficznej lub adresu wybranego miejsca, interfejs Geocoding API dostarczy te informacje za niższą cenę niż wywołanie interfejsu Place Details (New).
• Jeśli użytkownicy wybierają prognozę autouzupełniania w ramach średnio 4 lub mniej żądań prognoz autouzupełniania (nowych), cena za żądanie może być bardziej opłacalna niż cena za sesję.

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

Sprawdzone metody dotyczące wydajności

Poniższe wytyczne opisują sposoby optymalizacji skuteczności autouzupełniania (nowego):

• Dodaj do implementacji Autocomplete (New) ograniczenia dotyczące kraju, ustawienia lokalizacji i (w przypadku implementacji programowych) preferencje językowe. W przypadku widżetów nie trzeba określać preferencji językowych, ponieważ są one pobierane z przeglądarki lub urządzenia mobilnego użytkownika.
• Jeśli usłudze Autouzupełnianie (nowa) towarzyszy mapa, możesz określić lokalizację na podstawie widocznego obszaru mapy.
• Jeśli użytkownik nie wybierze żadnej z podpowiedzi Autocomplete (New), zwykle dlatego, że żadna z nich nie jest szukanym adresem, możesz ponownie użyć pierwotnego tekstu wpisanego przez użytkownika, aby uzyskać bardziej trafne wyniki:
  • Jeśli oczekujesz, że użytkownik wpisze tylko informacje o adresie, użyj ponownie pierwotnych 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 Szczegóły miejsca (nowe). Jeśli wyniki mają być wyświetlane tylko w określonym regionie, użyj ustawień lokalizacji.
  Inne scenariusze, w których warto wrócić do Geocoding API:
  • użytkownicy wpisujący adresy podrzędne, np. adresy konkretnych lokali lub mieszkań w budynku; Na przykład czeski adres „Stroupežnického 3191/17, Praha” generuje częściową podpowiedź w usłudze Autouzupełnianie (nowa wersja).
  • Użytkownicy wpisujący adresy z prefiksami odcinków dróg, np. „23–30 29th St, Queens” w Nowym Jorku lub „47–380 Kamehameha Hwy, Kaneohe” na wyspie Kauai na Hawajach.

Preferowanie lokalizacji

Aby zawęzić wyniki do określonego obszaru, przekaż parametr location i parametr radius. To polecenie informuje usługę Autocomplete (New), że ma preferować wyświetlanie wyników w określonym obszarze. Wyniki spoza zdefiniowanego obszaru mogą być nadal wyświetlane. Możesz użyć parametru components, 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 zdefiniowanego przez parametr location i radius, dodając parametr locationRestriction. To polecenie informuje interfejs Autocomplete (New), że ma zwracać tylko wyniki z tego regionu.