Place Autocomplete (novo)

O serviço Autocomplete (novo) é uma API do iOS que retorna sugestões de lugares em resposta a uma solicitação. Na solicitação, especifique string de pesquisa de texto e limites geográficos que controlam a área de pesquisa.

O serviço Autocomplete (novo) pode corresponder à totalidade palavras e substrings da entrada, resolvendo nomes de lugares, endereços e mais de código aberto. Os aplicativos podem enviar consultas, pois o usuário tipos, para fornecer sugestões de lugares instantaneamente.

As sugestões de lugares representam lugares como empresas, endereços e pontos de interesse, com base na string de texto de entrada e na área de pesquisa especificadas.

Por exemplo, você chama a API usando como entrada uma string que contém um valor entrada do usuário, "Spagh", com a área de pesquisa limitada à cidade de Nova York. A resposta contém uma lista de sugestões de lugares que correspondem à pesquisa e área de pesquisa, como o restaurante "Café espaguete", além de detalhes sobre o local.

As sugestões de local retornadas são projetadas para serem apresentadas ao usuário de forma que para selecionar o local desejado. Você pode fazer uma solicitação de Place Details (New) para receber mais informações sobre qualquer uma das sugestões de lugares retornadas.

Solicitações de Autocomplete (novo)

Crie uma solicitação de preenchimento automático chamando um método no GMSPlaceClient É possível transmitir parâmetros no GMSAutocompleteRequest objeto. A resposta fornece sugestões de preenchimento automático em uma GMSAutocompletePlaceSuggestion objeto.

A chave de API e os parâmetros query são obrigatórios. Você também pode incluir GMSAutocompleteSessionToken associar solicitações a uma sessão de faturamento e GMSAutocompleteFilter para aplicar aos resultados.

Para mais informações sobre os parâmetros obrigatórios e opcionais, consulte a seção de parâmetros deste documento.

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

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

Respostas de Autocomplete (novo)

O preenchimento automático retorna uma matriz de até cinco GMSAutocompleteSuggestion instâncias. A matriz contém:

• placeID
• types: tipos que se aplicam a este lugar.
• distanceMeters: distância da origem.
• attributedFullText: texto completo legível por humanos de uma sugestão.
• attributedPrimaryText: texto principal legível por humanos de uma sugestão.
• attributedSecondaryText: texto secundário legível por humanos de uma sugestão.
• structuredFormat: o nome específico e o texto que não tem ambiguidade, como cidade ou na mesma região.

Parâmetros obrigatórios

consulta

A string de texto na qual pesquisar. Especifique palavras completas e substrings, coloque nomes, endereços e Plus Codes. A O serviço Autocomplete (novo) retorna correspondências possíveis com base nessa string e ordena os resultados com base na relevância.

Parâmetros opcionais

tipos

Um lugar só pode ter um único tipo principal dos tipos Tabela A ou tabela B associada a ele. Por exemplo, o tipo principal pode ser mexican_restaurant ou steak_house.

Por padrão, a API retorna todos os locais com base no parâmetro input. independentemente do valor do tipo principal associado ao lugar. Restringir resultados sejam de um determinado tipo primário, ou tipos primários, passando o parâmetro types.

Use este parâmetro para especificar até cinco valores de tipo da Tabela A ou tabela B. O lugar precisa ser igual um dos valores de tipo primário especificados a serem incluídos na resposta.

A solicitação será rejeitada com um erro INVALID_REQUEST se:

• Mais de cinco tipos foram especificados.
• Quaisquer tipos não reconhecidos foram especificados.

países

Incluir apenas os resultados da lista de regiões especificadas, definidas como uma matriz de até 15 ccTLD ("nível superior domínio") valores de dois caracteres. Se omitido, nenhuma restrição será aplicada à resposta. Por exemplo, para limitar as regiões à Alemanha e França:

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

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

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

Se você especificar locationRestriction e countries, os resultados serão localizado na área de interseção das duas configurações.

inputOffset

O deslocamento de caracteres Unicode baseado em zero que indica a posição do cursor em input: A posição do cursor pode influenciar quais previsões são retornadas. Se vazio, o padrão é o comprimento de input.

locationBias ou locationRestriction

É possível especificar locationBias ou locationRestriction, mas não ambos, para definir área de pesquisa. Pense em locationRestriction como a especificação da região que os resultados precisam estar e locationBias como a especificação da região em que os resultados devem estar próximos, mas podem estar fora da área.

• locationBias especifica uma área a ser pesquisada. Essa localização serve como um viés, o que significa que os resultados em torno do local especificado podem ser retornados, incluindo resultados fora da área especificada.

• locationRestriction especifica uma área a ser pesquisada. Resultados fora do área especificada não são retornados.

Especifique a região locationBias ou locationRestriction como um retângulo janela de visualização ou como um círculo.

Um círculo é definido pelo ponto central e pelo raio em metros. O raio deve ser entre 0,0 e 50.000,0. O valor padrão é 0,0. Para locationRestriction, você precisa definir o raio como um valor maior que 0,0. Caso contrário, a solicitação não retornará resultados.

Exemplo:

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

let center = CLLocationCoordinate2DMake(40.477398, -74.259087)

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

let filter = AutocompleteFilter(coordinateRegionBias: bias)      
  

Um retângulo é uma janela de visualização de latitude e longitude, representada como dois eixos em frente a low e high pontos. Uma janela de visualização é considerada uma região fechada, ou seja, ela inclui seus limites. Os limites de latitude devem variar entre -90 e 90 graus inclusive, e os limites de longitude devem variar entre -180 e 180 graus, inclusive:

• Se low = high, a janela de visualização consistirá nesse único ponto.
• Se low.longitude > high.longitude, o intervalo de longitude está invertido (o janela de visualização cruza a linha de 180 graus de longitude).
• Se low.longitude = -180 graus e high.longitude= 180 graus, o a janela de visualização inclui todas as longitudes.
• Se low.longitude = 180 graus e high.longitude = -180 graus, o o intervalo de longitude está vazio.

low e high precisam ser preenchidos, e a caixa representada não pode ser vazio. Uma janela de visualização vazia resulta em erro.

Por exemplo, esta janela de visualização abrange totalmente Nova York:

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

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

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

origem

O ponto de origem a partir do qual calcular a distância em linha reta até o destino (retornado como distanceMeters). Se esse valor for omitido, a distância em linha reta não será retornada. Deve ser especificado como latitude e coordenadas de longitude:

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

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

regionCode

O código da região usado para formatar a resposta, especificado como ccTLD ("top-level domínio") um valor de dois caracteres. A maioria dos códigos ccTLD é idêntica aos códigos ISO 3166-1, com com algumas exceções notáveis. Por exemplo, o ccTLD do Reino Unido é "uk" (.co.uk), enquanto o código ISO 3166-1 é "gb" (tecnicamente para a entidade "The Reino Unido da Grã-Bretanha e Irlanda do Norte").

Se você especificar um código de região inválido, a API retornará um INVALID_ARGUMENT. erro. O parâmetro pode afetar os resultados com base na legislação aplicável.

sessionToken

Os tokens de sessão são strings geradas pelo usuário que rastreiam Autocomplete (novo) como "sessions". O Autocomplete (novo) usa tokens de sessão para agrupar os fases de consulta e seleção de uma pesquisa de preenchimento automático do usuário em uma sessão discreta para fins de faturamento. Para mais informações, consulte Sessão tokens.

Exemplos de preenchimento automático (novo)

Usar locationRestriction e locationBias

O Autocomplete (novo) usa a polarização de IP por padrão para controlar a área de pesquisa. Com a polarização de IP, a API usa o endereço IP da dispositivo para influenciar os resultados. Como opção, é possível usar locationRestriction ou locationBias, mas não ambos, para especificar uma área para pesquisar.

A restrição de local especifica a área a ser pesquisada. Resultados fora do especificado não serão retornadas. O exemplo a seguir usa a restrição de local para limitar a solicitação para uma restrição de local circular com um raio de 5.000 metros centrado em São Francisco:

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

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

Com o direcionamento de localização, o local serve como um viés, o que significa que os resultados o local especificado pode ser retornado, incluindo resultados fora do área O próximo exemplo muda a solicitação anterior para usar a polarização de local:

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

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

Tipos de uso

Use o parâmetro "types" para restringir os resultados de uma solicitação a um determinado tipo conforme listado na Tabela A e Table B. É possível especificar matriz de até cinco valores. Se omitido, todos os tipos são retornados.

O exemplo a seguir especifica a string de consulta "Futebol" e usa os tipos parâmetro para restringir os resultados a estabelecimentos do tipo "sporting_goods_store":

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

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

Usar origem

Quando você inclui o parâmetro origin na solicitação, especificado como coordenadas de latitude e longitude, a API inclui a distância em linha reta da origem ao destino na resposta. A resposta retorna o distância como distanceMeters.

Este exemplo define a origem como o centro de São Francisco:

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

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

Atribuições

Você pode usar o Autocomplete (novo) mesmo um mapa. Se você exibir um mapa, ele deverá ser do Google. Quando você exibe sugestões do serviço Autocomplete (novo) sem um mapa, é necessário incluir o logotipo do Google exibido alinhado com a pesquisa campo/resultados. Para mais informações, consulte Como exibir o logotipo do Google e de atributos.