Autouzupełnianie miejsc (nowość)

Deweloperzy z Europejskiego Obszaru Gospodarczego (EOG)

Usługa Autocomplete (New) 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 kontrolują obszar wyszukiwania.

Usługa Autouzupełnianie (nowa) może dopasowywać całe 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 o nazwie „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:

Programowe uzyskiwanie prognoz dotyczących miejsc

Żądania autouzupełniania (nowe)

Utwórz żądanie autouzupełniania, wywołując metodę w obiekcie 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.

Wersja pakietu Places SDK na Swift

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

Klucz interfejsu API i parametry query są wymagane. Możesz też dodać parametr AutocompleteSessionToken , aby powiązać żądania z sesją rozliczeniową, oraz parametr AutocompleteFilter , aby zastosować go do wyników.

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

Pakiet SDK Miejsc w Swift

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.
}

Swift

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))")
        }
      }
    })

Objective-C

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 autouzupełniania (nowość)

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

  • placeID
  • types: typy, które mają zastosowanie do tego miejsca.
  • distanceMeters: odległość od punktu początkowego.
  • attributedFullText: pełny tekst sugestii czytelny dla człowieka.
  • attributedPrimaryText: tekst główny sugestii czytelny dla człowieka.
  • attributedSecondaryText: czytelny dla człowieka tekst dodatkowy sugestii.
  • 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 plusowe. 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 wygenerowane przez użytkownika ciągi znaków, które śledzą wywołania funkcji autouzupełniania (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ń. Więcej informacji znajdziesz w artykule Tokeny sesji.

Opcjonalne parametry AutocompleteFilter

typy

Miejsce może mieć tylko jeden typ podstawowy z typów Tabela A lub Tabela B. Podstawowym typem 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:

Pakiet SDK Miejsc w Swift

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

Swift

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

Objective-C

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

kraje

Uwzględniaj tylko wyniki z listy określonych regionów, podanych 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:

Pakiet SDK Miejsc w Swift

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

Swift

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

Objective-C

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

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

inputOffset

Indeks znaku Unicode liczony od zera, który wskazuje 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:

Pakiet SDK Miejsc w Swift

let center = CLLocationCoordinate2DMake(40.477398, -74.259087)

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

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

Swift

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

filter.locationBias = GMSPlaceCircularLocationOption(center, radius)

Objective-C

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 lowhigh. Widoczny obszar jest uważany za obszar 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 lowhigh, a reprezentowane pole nie może być puste. Pusty widok spowoduje błąd.

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

Pakiet SDK Miejsc w Swift

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

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

Swift

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

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

Objective-C

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:

Pakiet SDK Miejsc w Swift

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

Swift

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

Objective-C

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 znaczącymi 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:

Pakiet SDK Miejsc w Swift

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

Swift

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

Objective-C

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

Dodawanie widżetu autouzupełniania 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.

Widżet autouzupełniania miejsc

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

Jeśli nie podasz tokena sesji, widżet utworzy dla Ciebie token sesji Autocomplete, który można 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 zobaczy widok pełnoekranowy, 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 moduł 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.

AutocompleteUICustomization

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 domyślna ikona.

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.

Zobacz przykład pełnego kodu

Przykłady autouzupełniania (nowa wersja)

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 jednocześnie, 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:

Pakiet SDK Miejsc w Swift

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.
}
  

Swift

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))")
        }
      }
    })

Objective-C

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 następnym przykładzie zmieniamy poprzednie żądanie, aby używać odchylenia lokalizacji:

Pakiet SDK Miejsc w Swift

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.
}
  

Swift

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))")
        }
      }
    })

Objective-C

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 Atabeli 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":

Pakiet SDK Miejsc w Swift

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.
}
    

Swift

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))")
        }
      }
    })

Objective-C

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 między punktem początkowym a miejscem docelowym. Odpowiedź zwraca odległość jako distanceMeters.

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

Pakiet SDK Miejsc w Swift

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.
}
  

Swift

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))")
        }
      }
    })

Objective-C

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.
      }
    }
}];

Dodawanie widżetu autouzupełniania Miejsc

Pakiet SDK Miejsc w Swift

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
        }
      )
    }
  }
}