Place Autocomplete (nouveau)

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

Le service Autocomplete (nouveau) peut établir une correspondance avec des mots complets et des sous-chaînes de l'entrée afin de trouver des noms de lieux, des adresses et des Plus Codes. Ainsi, les applications peuvent envoyer des requêtes lors de la frappe pour indiquer les lieux possibles à la volée.

Les suggestions de lieux sont des lieux (comme des établissements, des adresses et des points d'intérêt) basés sur la chaîne de texte saisie et la zone de recherche spécifiées.

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

Les suggestions de lieux renvoyées sont conçues pour être présentées à l'utilisateur afin qu'il puisse sélectionner le lieu souhaité. Vous pouvez effectuer une requête Place Details (nouveau) pour obtenir plus d'informations sur les suggestions de lieux renvoyées.

Vous pouvez intégrer la fonctionnalité Saisie semi-automatique (nouveau) à votre application de deux manières principales :

• Obtenir des prédictions de lieux de manière programmatique : appelez l'API directement pour récupérer les prédictions et les afficher dans une interface utilisateur personnalisée.
• Ajoutez le widget Place Autocomplete : il fournit une expérience de saisie semi-automatique de recherche prête à l'emploi qui affiche des prédictions à mesure que l'utilisateur saisit du texte.

Obtenir des prédictions de lieux de manière programmatique

Requêtes Autocomplete (nouveau)

Créez une requête de saisie semi-automatique en appelant une méthode sur GMSPlacesClient. Vous pouvez transmettre des paramètres dans l'objet GMSAutocompleteRequest. La réponse fournit des suggestions de saisie semi-automatique dans un objet GMSAutocompletePlaceSuggestion.

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

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

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

Réponses Autocomplete (nouveau)

La saisie semi-automatique renvoie un tableau comportant jusqu'à cinq instances GMSAutocompleteSuggestion. Le tableau contient les éléments suivants :

• placeID
• types : types qui s'appliquent à ce lieu.
• distanceMeters : distance par rapport à l'origine.
• attributedFullText : texte complet et lisible d'une suggestion.
• attributedPrimaryText : texte principal lisible d'une suggestion.
• attributedSecondaryText : texte secondaire lisible d'une suggestion.
• structuredFormat : nom spécifique et texte permettant de lever toute ambiguïté, comme la ville ou la région.

Paramètres obligatoires

requête

Chaîne de texte sur laquelle effectuer la recherche. Spécifiez des mots et des sous-chaînes complets, des noms de lieux, des adresses et des Plus Codes. Le service Autocomplete (New) renvoie les résultats correspondant à cette chaîne et les classe en fonction de leur pertinence estimée.

Paramètres facultatifs

sessionToken

Les jetons de session sont des chaînes générées par l'utilisateur qui suivent les appels Autocomplete (New) (à la fois ceux effectués via le widget et les appels programmatiques) en tant que "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 de saisie semi-automatique d'un utilisateur dans une session distincte à des fins de facturation.

Vous pouvez exposer votre jeton de session Places Autocomplete afin de le transmettre à d'autres services qui ne font pas partie du SDK Places pour iOS, comme Address Validation :

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

Pour en savoir plus, consultez Jetons de session.

Paramètres AutocompleteFilter facultatifs

Types

Un lieu ne peut être associé qu'à un seul type principal des tableaux A ou B. 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ée au lieu. Limitez les résultats à un ou plusieurs types principaux en transmettant le paramètre types.

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

La requête est rejetée avec une erreur INVALID_REQUEST si :

• Plus de cinq types sont spécifiés.
• vous spécifiez des types non reconnus ;

Par exemple, pour limiter les résultats aux magasins d'articles de sport, spécifiez ce type dans votre 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" ];

pays

N'incluez que les résultats de la liste des régions spécifiées, sous la forme d'un tableau de valeurs ccTLD ("domaine de premier niveau") à deux caractères (15 maximum). Si elle 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 = AutocompleteFilter(countries: ["DE", "FR"])
  

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

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

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

inputOffset

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

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 dans laquelle les résultats doivent se trouver, et locationBias comme spécifiant la région dont les résultats doivent être proches, mais qui peut être en dehors de la zone.

• locationBias spécifie une zone de recherche. Cet emplacement sert de biais, ce qui signifie que des résultats autour de l'emplacement spécifié peuvent être renvoyés, y compris des résultats en dehors de la zone spécifiée.

• locationRestriction spécifie une zone de recherche. Les résultats en dehors de la zone spécifiée ne sont pas renvoyés.

Spécifiez la région locationBias ou locationRestriction sous la forme d'une fenêtre rectangulaire ou d'un cercle.

Un cercle est défini par un point central et un rayon en mètres. Le rayon doit être compris entre 0,0 et 50 000,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.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);

Un rectangle est une fenêtre d'affichage de latitude et de longitude, représentée par deux points low et high diagonalement opposés. Une fenêtre d'affichage est considérée comme une région fermée, ce qui signifie qu'elle inclut sa limite. Les limites de latitude doivent être comprises entre -90 et 90 degrés inclus, et les limites de longitude doivent être comprises entre -180 et 180 degrés inclus :

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

low et high doivent être renseignés, et la boîte représentée ne peut pas être vide. Un viewport vide génère une erreur.

Par exemple, cette fenêtre d'affichage englobe entièrement la ville de New York :

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

origin

Point d'origine à partir duquel calculer la distance à vol d'oiseau jusqu'à la destination (renvoyée sous la forme distanceMeters). Si cette valeur est omise, la distance à vol d'oiseau ne sera pas renvoyée. Elles doivent être spécifiées sous la forme de coordonnées de latitude et de longitude :

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

Code régional utilisé pour mettre en forme la réponse, spécifié sous la forme d'une valeur ccTLD ("domaine de premier niveau") à deux caractères. La plupart des codes de TLDcc sont identiques aux codes ISO 3166-1, à quelques exceptions près. Par exemple, le ccTLD du Royaume-Uni est "uk" (.co.uk), tandis que son code ISO 3166-1 est "gb" (techniquement 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 une erreur INVALID_ARGUMENT. Ce paramètre peut avoir une incidence sur les résultats en fonction de la loi applicable.

shouldIncludePureServiceAreaBusinesses

Si la valeur est true, renvoie les établissements de services à proximité à domicile dans le tableau de réponse. Un établissement de services de proximité à domicile est un établissement qui se rend directement chez les clients pour effectuer une prestation ou leur livrer des produits, mais qui n'accueille pas les clients dans ses locaux.

Exemple :

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

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

Ajouter le widget Place Autocomplete

Pour proposer plus facilement une expérience de saisie semi-automatique de lieux cohérente, vous pouvez ajouter le widget Place Autocomplete à votre application. Ce widget fournit une interface dédiée en plein écran qui gère la saisie de l'utilisateur et affiche des prédictions de lieux à l'utilisateur tout en renvoyant des objets AutocompletePlaceSuggestion à l'application. Vous pouvez ensuite envoyer une requête Place Details (New) pour obtenir des informations supplémentaires sur l'une des prédictions de lieux.

Comme pour obtenir des prédictions de lieux de manière programmatique, le widget Place Autocomplete vous permet d'utiliser des jetons de session pour regrouper les requêtes de saisie semi-automatique en sessions à des fins de facturation. Vous pouvez transmettre un jeton de session en appelant AutocompleteSessionToken().

Si vous ne fournissez pas de jeton de session, le widget en créera un pour vous, que vous pourrez ensuite obtenir à partir du rappel onSelection. Pour en savoir plus sur l'utilisation des jetons de session, consultez À propos des jetons de session.

Lorsque la valeur de liaison show est définie sur true, l'utilisateur est redirigé vers une vue en plein écran où il peut sélectionner un lieu. Au fur et à mesure que l'utilisateur saisit du texte, le widget renvoie des suggestions de lieux (établissements, adresses ou points d'intérêt, par exemple). Lorsque l'utilisateur sélectionne un lieu, le widget appelle le gestionnaire onSelection avec le lieu sélectionné et ferme la vue en plein écran.

Paramètres du widget Place Autocomplete

En plus des paramètres disponibles par programmation, le widget Place Autocomplete propose également les paramètres suivants.

afficher

show indique si le widget est affiché.

onSelection

Fermeture à exécuter lorsqu'un lieu est sélectionné.

onError

Fermeture à exécuter en cas d'erreur. Un PlacesError sera transmis en cas d'erreur.

Personnalisation du contenu et du thème

Les paramètres AutocompleteUICustomization spécifient les personnalisations de l'UI à appliquer au widget. Les options de personnalisation sont les suivantes :

• AutocompleteListDensity. Ce paramètre vous permet de choisir la densité de la liste de suggestions, soit multiLine, soit twoLine.
• AutocompleteUIIcon : ce paramètre vous permet de choisir d'afficher ou non l'icône par défaut pour chaque élément de la liste.
• theme : ce paramètre spécifie un thème personnalisé qui remplace tous les attributs de style par défaut. Vous pouvez personnaliser les couleurs, la typographie, l'espacement, les bordures et les angles de votre composant Place Autocomplete. La valeur par défaut est PlacesMaterialTheme. Tous les attributs de thème qui ne sont pas remplacés utilisent les styles par défaut.

Consultez un exemple de code complet.

Exemples de saisie semi-automatique (nouveau)

Utiliser locationRestriction et locationBias

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

La restriction géographique spécifie la zone à rechercher. Les résultats en dehors de la zone spécifiée ne sont pas renvoyés. L'exemple suivant utilise une restriction géographique pour limiter la requête à une restriction géographique circulaire d'un rayon de 5 000 mètres centrée sur 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.
    }
  }
}];

Avec le biais de localisation, la position sert de biais, ce qui signifie que des résultats autour de la position spécifiée peuvent être renvoyés, y compris des résultats en dehors de la zone spécifiée. L'exemple suivant modifie la requête précédente pour utiliser le biais de localisation :

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

Types d'utilisation

Utilisez le paramètre types pour limiter les résultats d'une requête à un certain type, comme indiqué dans le Tableau A et le Tableau B. Vous pouvez spécifier un tableau contenant jusqu'à cinq valeurs. Si ce paramètre est omis, tous les types sont renvoyés.

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

Utiliser l'origine

Lorsque vous incluez le paramètre origin dans la requête, spécifié sous forme de coordonnées de latitude et de longitude, l'API inclut la distance à vol d'oiseau entre l'origine et la destination dans la réponse. La réponse renvoie la distance sous la forme distanceMeters.

Cet exemple définit l'origine au centre de 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.
      }
    }
}];

Personnaliser le contenu et le thème

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

Ajouter un widget Places Autocomplete (code complet)

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

Optimisation d'Autocomplete (nouveau)

Cette section décrit les bonnes pratiques pour vous aider à exploiter au mieux le service Autocomplete (nouveau).

Voici quelques consignes générales :

• La méthode la plus rapide pour développer une interface utilisateur fonctionnelle consiste à utiliser le widget de saisie semi-automatique (nouveau) de l'API Maps JavaScript, le widget de saisie semi-automatique (nouveau) du SDK Places pour Android ou le widget de saisie semi-automatique (nouveau) du SDK Places pour iOS.
• Développez dès le départ vos connaissances des champs de données Autocomplete (nouveau) essentiels.
• Les champs de pondération et de restriction de lieu sont facultatifs, mais peuvent avoir un impact important sur les performances de la saisie semi-automatique.
• Utilisez la gestion des erreurs pour vérifier que votre application se dégrade correctement si l'API renvoie une erreur.
• Assurez-vous que votre application fonctionne lorsqu'il n'y a aucune sélection et qu'elle propose aux utilisateurs un moyen de poursuivre.

Bonnes pratiques liées à l'optimisation des coûts

Optimisation de base des coûts

Pour optimiser le coût d'utilisation du service Autocomplete (New), utilisez des masques de champ dans les widgets Place Details (New) et Autocomplete (New) afin de ne renvoyer que les champs de données Autocomplete (New) dont vous avez besoin.

Optimisation avancée des coûts

Envisagez d'implémenter Autocomplete (nouveau) de manière programmatique pour accéder au tarif par requête Autocomplete et demander des résultats d'API Geocoding pour le lieu sélectionné plutôt que pour Place Details (nouveau). La tarification par requête associée à l'API Geocoding est plus rentable que la tarification par session (basée sur la session) si les deux conditions suivantes sont remplies :

• Si vous n'avez besoin que de la latitude/longitude ou de l'adresse du lieu sélectionné par l'utilisateur, l'API Geocoding fournit ces informations à un prix inférieur à celui d'un appel Place Details (nouveau).
• Si les utilisateurs sélectionnent une prédiction de saisie semi-automatique toutes les quatre requêtes de prédiction Autocomplete (New) ou moins en moyenne, la tarification par requête peut être plus rentable que celle par session.

Votre application nécessite-t-elle des informations autres que l'adresse et la latitude/longitude de la prédiction sélectionnée ?

Bonnes pratiques en matière de performances

Les consignes suivantes décrivent les méthodes permettant d'optimiser les performances d'Autocomplete (nouveau) :

• Ajoutez des restrictions locales, une pondération géographique et des préférences linguistiques (pour les implémentations programmatiques) à votre implémentation Autocomplete (New). La préférence linguistique n'est pas obligatoire pour les widgets, car ils sélectionnent cette option dans le navigateur ou l'appareil mobile de l'utilisateur.
• Si la saisie semi-automatique (nouvelle version) est accompagnée d'une carte, vous pouvez pondérer la position en fonction de la fenêtre d'affichage de la carte.
• Dans les cas où l'utilisateur ne choisit pas l'une des prédictions de la saisie semi-automatique (nouvelle), généralement parce qu'aucune d'entre elles n'est l'adresse souhaitée, vous pouvez réutiliser l'entrée utilisateur d'origine pour essayer d'obtenir des résultats plus pertinents :
  • Si vous pensez que l'utilisateur ne saisira que des informations d'adresse, réutilisez son entrée d'origine dans un appel à l'API Geocoding.
  • Si vous pensez que l'utilisateur saisira des requêtes pour un lieu spécifique avec un nom ou une adresse, utilisez une requête Place Details (New). Si les résultats ne sont attendus que dans une région spécifique, utilisez la pondération géographique.
  Voici d'autres scénarios dans lesquels il est préférable de revenir à l'API Geocoding :
  • Les utilisateurs saisissent des adresses de sous-lieux, comme des adresses d'unités ou d'appartements spécifiques dans un bâtiment. Par exemple, l'adresse tchèque "Stroupežnického 3191/17, Praha" génère une prédiction partielle dans Autocomplete (New).
  • Lorsque des utilisateurs saisissent des adresses qui contiennent un préfixe identifiant une portion de route, par exemple "23-30 29th St, Queens" à New York ou "47-380 Kamehameha Hwy, Kaneohe" sur l'île de Kauai, à Hawaï.

Biais de localisation

Limitez les résultats à une zone spécifique en transmettant les paramètres location et radius. Cela indique à la saisie semi-automatique (nouvelle version) de privilégier les résultats dans la zone définie. Des résultats en dehors de la zone définie peuvent toutefois être affichés. Vous pouvez utiliser le paramètre components pour filtrer les résultats et n'afficher que les lieux situés dans un pays spécifique.

Restriction géographique

Limitez les résultats à une zone spécifique en transmettant un paramètre locationRestriction.

Vous pouvez également limiter les résultats à la région définie par les paramètres location et radius en ajoutant le paramètre locationRestriction. Cela indique à Autocomplete (New) de ne renvoyer que les résultats dans cette région.