Place Autocomplete (nouveau)

Le service Autocomplete (nouveau) est une API iOS qui renvoie des suggestions de lieux en réponse à une requête. Dans la requête, spécifiez chaîne de recherche de texte et les limites géographiques qui contrôlent la zone de recherche.

Le service de saisie semi-automatique (nouveau) peut correspondre mots et sous-chaînes de l'entrée, permettant de trouver des noms de lieux, des adresses et plus codes. Les applications peuvent donc envoyer des requêtes et vous proposer des suggestions de lieux à la volée.

Les suggestions de lieux sont des lieux (établissements, adresses et points de en fonction de la chaîne de texte d'entrée spécifiée et de la zone de recherche.

Par exemple, vous appelez l'API en utilisant comme entrée une chaîne contenant une chaîne partielle l'entrée utilisateur "Spagh", avec la zone de recherche limitée à New York. La réponse contient ensuite une liste de suggestions de lieux correspondant à la recherche chaîne et zone de recherche, par exemple le restaurant intitulé "Cafe Spaghetti", ainsi que des détails sur le lieu.

Les suggestions de lieux renvoyées sont conçues pour être présentées à l'utilisateur afin de sélectionner le lieu souhaité. Vous pouvez créer un Place Details (Nouveau) demandez-en plus des informations sur les suggestions de lieux affichées.

Requêtes Autocomplete (nouvelle)

Créez une requête de saisie semi-automatique en appelant une méthode au niveau de la méthode GMSPlaceClient Vous pouvez transmettre des paramètres GMSAutocompleteRequest . La réponse fournit des suggestions de saisie semi-automatique dans un GMSAutocompletePlaceSuggestion .

La clé API et les paramètres query sont obligatoires. Vous pouvez également inclure GMSAutocompleteSessionToken d'associer les requêtes à une session de facturation GMSAutocompleteFilter à appliquer aux résultats.

Pour en savoir plus sur les paramètres obligatoires et facultatifs, consultez la section Paramètres de ce document.

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

Réponses de la saisie semi-automatique (nouvelle version)

La saisie semi-automatique renvoie jusqu'à cinq tableaux GMSAutocompleteSuggestion instances. Le tableau contient:

• placeID
• types: types qui s'appliquent à ce lieu.
• distanceMeters: distance depuis le point de départ.
• attributedFullText: texte complet d'une suggestion, lisible par l'humain.
• attributedPrimaryText: texte principal d'une suggestion, lisible par l'humain.
• attributedSecondaryText: texte secondaire lisible d'une suggestion.
• structuredFormat: nom spécifique et texte clarifiant, comme "ville" ou dans la même région.

Paramètres obligatoires

requête

Chaîne de texte dans laquelle effectuer la recherche. Spécifiez des mots complets et des sous-chaînes, placez noms, adresses et plus codes. La Le service de saisie semi-automatique (nouveau) renvoie les correspondances de candidats basée sur cette chaîne et trie les résultats en fonction de leur pertinence estimée.

Paramètres facultatifs

Types

Un lieu ne peut avoir qu'un seul type principal de types Tableau A ou Tableau B qui lui est associée. Par exemple, le type principal peut être mexican_restaurant ou steak_house.

Par défaut, l'API renvoie tous les lieux en fonction du paramètre input, quelle que soit la valeur du type principal associé au lieu. Limiter les résultats d'un certain type principal en transmettant Paramètre types.

Utilisez ce paramètre pour spécifier jusqu'à cinq valeurs de type issues du Tableau A ou Tableau B. Un lieu doit correspondre l'une des valeurs de type principal spécifiées à inclure dans la réponse.

La requête est rejetée avec une erreur INVALID_REQUEST dans les cas suivants:

• Plus de cinq types sont spécifiés.
• Tous les types non reconnus sont spécifiés.

pays

Inclure uniquement les résultats de la liste des régions spécifiées, sous la forme d'un tableau jusqu'à 15 ccTLD ("premier niveau domaine") à deux caractères. Si cette valeur est omise, aucune restriction n'est appliquée à la réponse. Par exemple, pour limiter les régions à l'Allemagne et à la France:

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

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

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

Si vous spécifiez à la fois locationRestriction et countries, les résultats sont située dans la zone d'intersection des deux paramètres.

inputOffset

Décalage du caractère Unicode de base zéro indiquant la position du curseur dans input La position du curseur peut influencer les prédictions renvoyées. Si vide, la longueur par défaut est input.

locationBias ou locationRestriction

Vous pouvez spécifier locationBias ou locationRestriction, mais pas les deux, pour définir la zone de recherche. Considérez locationRestriction comme spécifiant la région les résultats doivent se trouver dans, et locationBias doit spécifier la région dans laquelle les résultats doivent être proches de la zone, mais peuvent se trouver en dehors.

• locationBias spécifie une zone à rechercher. Cet emplacement sert de biais, ce qui signifie que des résultats situés à proximité du lieu spécifié peuvent être renvoyés, y compris en dehors de la zone spécifiée.

• locationRestriction spécifie une zone à rechercher. Résultats en dehors de spécifié ne sont pas renvoyés.

Spécifiez la région locationBias ou locationRestriction sous forme de rectangle dans la fenêtre d'affichage ou sous forme de cercle.

Un cercle est défini par le point central et le rayon en mètres. Le rayon doit être compris entre 0.0 et 50000.0, inclus. La valeur par défaut est 0.0. Pour locationRestriction, vous devez définir le rayon sur une valeur supérieure à 0,0. Sinon, la requête ne renvoie aucun résultat.

Exemple :

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)      
  

Un rectangle est une fenêtre d'affichage de latitude-longitude représentée par deux en face des points low et high. Une fenêtre d'affichage est considérée comme une région fermée. ce qui signifie qu'elle inclut ses limites. La latitude doit être comprise entre -90 et 90 degrés inclus, et la longitude doit être comprise entre -180 et 180 degrés inclus:

• Si low = high, la fenêtre d'affichage est constituée de ce seul point.
• Si low.longitude > high.longitude, la plage de longitudes est inversée traverse la ligne de longitude à 180 degrés).
• Si low.longitude = -180 degrés et high.longitude= 180 degrés, la la fenêtre d'affichage inclut toutes les longitudes.
• Si low.longitude = 180 degrés et high.longitude = -180 degrés, la la plage de longitudes est vide.

Les champs low et high doivent tous les deux être renseignés, et la zone représentée ne peut pas l'être vide. Une fenêtre d'affichage vide entraîne une erreur.

Par exemple, cette fenêtre d'affichage englobe entièrement New 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)
  

origine

Point de départ à partir duquel calculer la distance en ligne droite par rapport à la destination (renvoyée sous la forme distanceMeters). Si cette valeur est omise, la distance en ligne droite n'est pas renvoyée. Doit être spécifié en tant que latitude et 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

Le code régional utilisé pour formater la réponse, spécifié en tant que ccTLD ("premier niveau domaine") à deux caractères. La plupart des codes ccTLD sont identiques aux codes ISO 3166-1, avec quelques exceptions notables. Par exemple, le ccTLD au Royaume-Uni est "uk". (.co.uk), tandis que son code ISO 3166-1 est "gb". (d'un point de vue technique pour l'entité Royaume-Uni de Grande-Bretagne et d'Irlande du Nord").

Si vous spécifiez un code de région non valide, l'API renvoie un INVALID_ARGUMENT . Ce paramètre peut avoir un impact sur les résultats en fonction de la législation applicable.

sessionToken

Les jetons de session sont des chaînes générées par l'utilisateur qui suivent La saisie semi-automatique (nouvelle version) appelle les "sessions". La saisie semi-automatique (nouveau) utilise des jetons de session pour regrouper les Phases de requête et de sélection d'une recherche avec saisie semi-automatique de l'utilisateur dans une session distincte à des fins de facturation. Pour en savoir plus, consultez la page Session les jetons.

Exemples de saisie semi-automatique (nouveau)

Utiliser locationRestriction et locationBias

La saisie semi-automatique (nouvelle version) utilise par défaut la pondération de l'adresse IP pour contrôler la zone de recherche. Avec la pondération des adresses IP, l'API utilise l'adresse IP du appareil pour fausser les résultats. Vous pouvez éventuellement utiliser locationRestriction ou locationBias, mais pas les deux, pour spécifier une zone à rechercher.

Une restriction géographique permet de spécifier la zone dans laquelle effectuer la recherche. Résultats en dehors de la plage de dates spécifiée ne sont pas renvoyées. L'exemple suivant utilise une restriction d'emplacement pour limiter Requête d'une restriction d'emplacement circulaire avec un rayon de 5 000 mètres centré à San 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.
}
  

En cas de biais de localisation, l'emplacement est utilisé comme un biais, c'est-à-dire que les résultats situés autour l'emplacement spécifié peut être renvoyé, y compris des résultats situés en dehors de la plage dans une zone géographique spécifique. L'exemple suivant modifie la requête précédente pour utiliser un biais de localisation:

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

Types d'utilisation

Utilisez le paramètre types pour limiter les résultats d'une demande à un certain type comme indiqué dans le Tableau A et Tableau B. Vous pouvez spécifier comportant jusqu'à cinq valeurs. Si cette valeur est omise, tous les types sont renvoyés.

L'exemple suivant spécifie une chaîne de requête de "Soccer" et utilise les types pour limiter les résultats aux établissements de type "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.
}
    

Utiliser l'origine

Lorsque vous incluez le paramètre origin dans la requête, spécifié en tant que coordonnées de latitude et de longitude, l'API inclut la distance en ligne droite de l'origine à la destination dans la réponse. La réponse renvoie la distance est de distanceMeters.

Dans l'exemple ci-dessous, le point de départ est défini sur le centre de San 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.
}
  

Attributions

Vous pouvez utiliser la saisie semi-automatique (nouveauté) même sans sur une carte. Si vous affichez une carte, il doit s'agir d'une carte Google. Lorsque vous affichez Suggestions du service Autocomplete (nouveau) sans carte, vous devez inclure le logo Google affiché dans la barre de recherche champ/résultats. Pour en savoir plus, consultez la section Afficher le logo Google et attributions.