Ta strona została przetłumaczona przez Cloud Translation API.

Autouzupełnianie miejsc

Wybierz platformę: Android iOS JavaScript Usługa internetowa

Powiadomienia o wycofaniu

Usługa autouzupełniania w pakiecie Places SDK na iOS zwraca prognozy w odpowiedzi na zapytania użytkowników. Gdy użytkownik wpisuje tekst, usługa autouzupełniania zwraca sugestie dotyczące takich miejsc jak firmy, adresy, kody plus i ciekawe miejsca.

Autouzupełnianie możesz dodawać do aplikacji na te sposoby:

Dodaj element sterujący autouzupełniania do interfejsu, aby skrócić czas programowania i zapewnić spójne wrażenia użytkowników.
Automatyczne pobieranie prognoz miejsc ułatwia dostosowywanie witryny do potrzeb użytkowników.

Dodawanie elementu sterującego interfejsu autouzupełniania

Element sterujący autouzupełniania to okno wyszukiwania z wbudowaną funkcją autouzupełniania. Gdy użytkownik wpisuje wyszukiwane hasło, element sterujący wyświetla listę przewidywanych miejsc do wyboru. Gdy użytkownik dokona wyboru, zwracane jest wystąpienie GMSPlace, za pomocą którego aplikacja może pobrać informacje o wybranym miejscu.

Oto jak możesz dodać do aplikacji element sterujący interfejsu autouzupełniania:

Dodawanie elementu sterującego na pełnym ekranie
Dodawanie kontrolera wyników
Korzystanie ze źródła danych tabeli

Dodawanie elementu sterującego pełnoekranowym

Użyj elementu sterującego na pełnym ekranie, jeśli chcesz mieć kontekst modalny, w którym interfejs autouzupełniania tymczasowo zastępuje interfejs użytkownika aplikacji do momentu, gdy użytkownik dokona wyboru. Tę funkcję udostępnia klasa GMSAutocompleteViewController. Gdy użytkownik wybierze miejsce, aplikacja oddzwoni.

Aby dodać do aplikacji element sterujący pełnoekranowy:

Utwórz element interfejsu w głównej aplikacji, aby uruchomić element sterujący autouzupełniania, np. moduł obsługi dotykowej w UIButton.
Zaimplementuj protokół GMSAutocompleteViewControllerDelegate w kontrolerze widoku nadrzędnego.
Utwórz instancję GMSAutocompleteViewController i przypisz nadrzędny kontroler widoku danych jako właściwość przedstawiciela.
Utwórz GMSPlaceField, aby określić typy danych o miejscach, które mają być zwracane.
Dodaj GMSAutocompleteFilter, aby ograniczyć zapytanie do określonego typu miejsca.
Zaprezentuj GMSAutocompleteViewController za pomocą [self presentViewController...].
Dokonaj wyboru użytkownika w metodzie przekazywania dostępu didAutocompleteWithPlace.
Zamknij kontroler w metodach przekazywania dostępu didAutocompleteWithPlace, didFailAutocompleteWithError i wasCancelled.

Ten przykład przedstawia jeden z możliwych sposobów uruchamiania GMSAutocompleteViewController w reakcji na kliknięcie przycisku przez użytkownika.

Swift

import UIKit
import GooglePlaces

class ViewController: UIViewController {

  override func viewDidLoad() {
    makeButton()
  }

  // Present the Autocomplete view controller when the button is pressed.
  @objc func autocompleteClicked(_ sender: UIButton) {
    let autocompleteController = GMSAutocompleteViewController()
    autocompleteController.delegate = self

    // Specify the place data types to return.
    let fields: GMSPlaceField = GMSPlaceField(rawValue: UInt(GMSPlaceField.name.rawValue) |
      UInt(GMSPlaceField.placeID.rawValue))!
    autocompleteController.placeFields = fields

    // Specify a filter.
    let filter = GMSAutocompleteFilter()
    filter.types = [.address]
    autocompleteController.autocompleteFilter = filter

    // Display the autocomplete view controller.
    present(autocompleteController, animated: true, completion: nil)
  }

  // Add a button to the view.
  func makeButton() {
    let btnLaunchAc = UIButton(frame: CGRect(x: 5, y: 150, width: 300, height: 35))
    btnLaunchAc.backgroundColor = .blue
    btnLaunchAc.setTitle("Launch autocomplete", for: .normal)
    btnLaunchAc.addTarget(self, action: #selector(autocompleteClicked), for: .touchUpInside)
    self.view.addSubview(btnLaunchAc)
  }

}

extension ViewController: GMSAutocompleteViewControllerDelegate {

  // Handle the user's selection.
  func viewController(_ viewController: GMSAutocompleteViewController, didAutocompleteWith place: GMSPlace) {
    print("Place name: \(place.name)")
    print("Place ID: \(place.placeID)")
    print("Place attributions: \(place.attributions)")
    dismiss(animated: true, completion: nil)
  }

  func viewController(_ viewController: GMSAutocompleteViewController, didFailAutocompleteWithError error: Error) {
    // TODO: handle the error.
    print("Error: ", error.localizedDescription)
  }

  // User canceled the operation.
  func wasCancelled(_ viewController: GMSAutocompleteViewController) {
    dismiss(animated: true, completion: nil)
  }

  // Turn the network activity indicator on and off again.
  func didRequestAutocompletePredictions(_ viewController: GMSAutocompleteViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = true
  }

  func didUpdateAutocompletePredictions(_ viewController: GMSAutocompleteViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = false
  }

}

Objective-C

#import "ViewController.h"
@import GooglePlaces;

@interface ViewController () <GMSAutocompleteViewControllerDelegate>

@end

@implementation ViewController {
  GMSAutocompleteFilter *_filter;
}

- (void)viewDidLoad {
  [super viewDidLoad];
  [self makeButton];
}

  // Present the autocomplete view controller when the button is pressed.
- (void)autocompleteClicked {
  GMSAutocompleteViewController *acController = [[GMSAutocompleteViewController alloc] init];
  acController.delegate = self;

  // Specify the place data types to return.
  GMSPlaceField fields = (GMSPlaceFieldName | GMSPlaceFieldPlaceID);
  acController.placeFields = fields;

  // Specify a filter.
  _filter = [[GMSAutocompleteFilter alloc] init];
  _filter.types = @[ kGMSPlaceTypeBank ];
  acController.autocompleteFilter = _filter;

  // Display the autocomplete view controller.
  [self presentViewController:acController animated:YES completion:nil];
}

  // Add a button to the view.
- (void)makeButton{
  UIButton *btnLaunchAc = [UIButton buttonWithType:UIButtonTypeCustom];
  [btnLaunchAc addTarget:self
             action:NSSelectorFromString(@"autocompleteClicked") forControlEvents:UIControlEventTouchUpInside];
  [btnLaunchAc setTitle:@"Launch autocomplete" forState:UIControlStateNormal];
  btnLaunchAc.frame = CGRectMake(5.0, 150.0, 300.0, 35.0);
  btnLaunchAc.backgroundColor = [UIColor blueColor];
  [self.view addSubview:btnLaunchAc];
}

  // Handle the user's selection.
- (void)viewController:(GMSAutocompleteViewController *)viewController
didAutocompleteWithPlace:(GMSPlace *)place {
  [self dismissViewControllerAnimated:YES completion:nil];
  // Do something with the selected place.
  NSLog(@"Place name %@", place.name);
  NSLog(@"Place ID %@", place.placeID);
  NSLog(@"Place attributions %@", place.attributions.string);
}

- (void)viewController:(GMSAutocompleteViewController *)viewController
didFailAutocompleteWithError:(NSError *)error {
  [self dismissViewControllerAnimated:YES completion:nil];
  // TODO: handle the error.
  NSLog(@"Error: %@", [error description]);
}

  // User canceled the operation.
- (void)wasCancelled:(GMSAutocompleteViewController *)viewController {
  [self dismissViewControllerAnimated:YES completion:nil];
}

  // Turn the network activity indicator on and off again.
- (void)didRequestAutocompletePredictions:(GMSAutocompleteViewController *)viewController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
}

- (void)didUpdateAutocompletePredictions:(GMSAutocompleteViewController *)viewController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
}

@end

Dodawanie kontrolera wyników

Użyj kontrolera wyników, jeśli chcesz mieć większą kontrolę nad interfejsem wprowadzania tekstu. Kontroler wyników dynamicznie przełącza widoczność listy wyników na podstawie fokusu w interfejsie wejściowym.

Aby dodać kontroler wyników do aplikacji:

Utwórz GMSAutocompleteResultsViewController.
Zaimplementuj protokół GMSAutocompleteResultsViewControllerDelegate w kontrolerze widoku nadrzędnego i przypisz kontroler widoku nadrzędnego jako właściwość delegacji.
Utwórz obiekt UISearchController, przekazując GMSAutocompleteResultsViewController jako argument kontrolera wyników.
Ustaw GMSAutocompleteResultsViewController jako właściwość searchResultsUpdater elementu UISearchController.
Dodaj do interfejsu aplikacji: searchBar dla elementu UISearchController.
Dokonaj wyboru użytkownika w metodzie przekazywania dostępu didAutocompleteWithPlace.

Pasek wyszukiwania elementu UISearchController można umieścić w interfejsie aplikacji na kilka sposobów:

Dodawanie paska wyszukiwania do paska nawigacyjnego
Dodawanie paska wyszukiwania u góry widoku
Dodawanie paska wyszukiwania z wykorzystaniem wyników wyświetlanych w wyskakujących okienkach

Dodawanie paska wyszukiwania do paska nawigacyjnego

Poniższy przykładowy kod pokazuje, jak dodać kontroler wyników, dodać element searchBar do paska nawigacyjnego i wykonać wybór użytkownika:

Swift

class ViewController: UIViewController {

  var resultsViewController: GMSAutocompleteResultsViewController?
  var searchController: UISearchController?
  var resultView: UITextView?

  override func viewDidLoad() {
    super.viewDidLoad()

    resultsViewController = GMSAutocompleteResultsViewController()
    resultsViewController?.delegate = self

    searchController = UISearchController(searchResultsController: resultsViewController)
    searchController?.searchResultsUpdater = resultsViewController

    // Put the search bar in the navigation bar.
    searchController?.searchBar.sizeToFit()
    navigationItem.titleView = searchController?.searchBar

    // When UISearchController presents the results view, present it in
    // this view controller, not one further up the chain.
    definesPresentationContext = true

    // Prevent the navigation bar from being hidden when searching.
    searchController?.hidesNavigationBarDuringPresentation = false
  }
}

// Handle the user's selection.
extension ViewController: GMSAutocompleteResultsViewControllerDelegate {
  func resultsController(_ resultsController: GMSAutocompleteResultsViewController,
                         didAutocompleteWith place: GMSPlace) {
    searchController?.isActive = false
    // Do something with the selected place.
    print("Place name: \(place.name)")
    print("Place address: \(place.formattedAddress)")
    print("Place attributions: \(place.attributions)")
  }

  func resultsController(_ resultsController: GMSAutocompleteResultsViewController,
                         didFailAutocompleteWithError error: Error){
    // TODO: handle the error.
    print("Error: ", error.localizedDescription)
  }

  // Turn the network activity indicator on and off again.
  func didRequestAutocompletePredictions(_ viewController: GMSAutocompleteViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = true
  }

  func didUpdateAutocompletePredictions(_ viewController: GMSAutocompleteViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = false
  }
}

Objective-C

- (void)viewDidLoad {
  _resultsViewController = [[GMSAutocompleteResultsViewController alloc] init];
  _resultsViewController.delegate = self;

  _searchController = [[UISearchController alloc]
                       initWithSearchResultsController:_resultsViewController];
  _searchController.searchResultsUpdater = _resultsViewController;

  // Put the search bar in the navigation bar.
  [_searchController.searchBar sizeToFit];
  self.navigationItem.titleView = _searchController.searchBar;

  // When UISearchController presents the results view, present it in
  // this view controller, not one further up the chain.
  self.definesPresentationContext = YES;

  // Prevent the navigation bar from being hidden when searching.
  _searchController.hidesNavigationBarDuringPresentation = NO;
}

// Handle the user's selection.
- (void)resultsController:(GMSAutocompleteResultsViewController *)resultsController
  didAutocompleteWithPlace:(GMSPlace *)place {
    _searchController.active = NO;
    // Do something with the selected place.
    NSLog(@"Place name %@", place.name);
    NSLog(@"Place address %@", place.formattedAddress);
    NSLog(@"Place attributions %@", place.attributions.string);
}

- (void)resultsController:(GMSAutocompleteResultsViewController *)resultsController
didFailAutocompleteWithError:(NSError *)error {
  [self dismissViewControllerAnimated:YES completion:nil];
  // TODO: handle the error.
  NSLog(@"Error: %@", [error description]);
}

// Turn the network activity indicator on and off again.
- (void)didRequestAutocompletePredictionsForResultsController:
    (GMSAutocompleteResultsViewController *)resultsController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
}

- (void)didUpdateAutocompletePredictionsForResultsController:
    (GMSAutocompleteResultsViewController *)resultsController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
}

Dodawanie paska wyszukiwania u góry widoku

Poniższy przykładowy kod pokazuje, jak dodać element searchBar u góry widoku.

Swift

import UIKit
import GooglePlaces

class ViewController: UIViewController {

  var resultsViewController: GMSAutocompleteResultsViewController?
  var searchController: UISearchController?
  var resultView: UITextView?

  override func viewDidLoad() {
    super.viewDidLoad()

    resultsViewController = GMSAutocompleteResultsViewController()
    resultsViewController?.delegate = self

    searchController = UISearchController(searchResultsController: resultsViewController)
    searchController?.searchResultsUpdater = resultsViewController

    let subView = UIView(frame: CGRect(x: 0, y: 65.0, width: 350.0, height: 45.0))

    subView.addSubview((searchController?.searchBar)!)
    view.addSubview(subView)
    searchController?.searchBar.sizeToFit()
    searchController?.hidesNavigationBarDuringPresentation = false

    // When UISearchController presents the results view, present it in
    // this view controller, not one further up the chain.
    definesPresentationContext = true
  }
}

// Handle the user's selection.
extension ViewController: GMSAutocompleteResultsViewControllerDelegate {
  func resultsController(_ resultsController: GMSAutocompleteResultsViewController,
                         didAutocompleteWith place: GMSPlace) {
    searchController?.isActive = false
    // Do something with the selected place.
    print("Place name: \(place.name)")
    print("Place address: \(place.formattedAddress)")
    print("Place attributions: \(place.attributions)")
  }

  func resultsController(_ resultsController: GMSAutocompleteResultsViewController,
                         didFailAutocompleteWithError error: Error){
    // TODO: handle the error.
    print("Error: ", error.localizedDescription)
  }

  // Turn the network activity indicator on and off again.
  func didRequestAutocompletePredictions(forResultsController resultsController: GMSAutocompleteResultsViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = true
  }

  func didUpdateAutocompletePredictions(forResultsController resultsController: GMSAutocompleteResultsViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = false
  }
}

Objective-C

- (void)viewDidLoad {
    [super viewDidLoad];

    _resultsViewController = [[GMSAutocompleteResultsViewController alloc] init];
    _resultsViewController.delegate = self;

    _searchController = [[UISearchController alloc]
                             initWithSearchResultsController:_resultsViewController];
    _searchController.searchResultsUpdater = _resultsViewController;

    UIView *subView = [[UIView alloc] initWithFrame:CGRectMake(0, 65.0, 250, 50)];

    [subView addSubview:_searchController.searchBar];
    [_searchController.searchBar sizeToFit];
    [self.view addSubview:subView];

    // When UISearchController presents the results view, present it in
    // this view controller, not one further up the chain.
    self.definesPresentationContext = YES;
}

// Handle the user's selection.
- (void)resultsController:(GMSAutocompleteResultsViewController *)resultsController
didAutocompleteWithPlace:(GMSPlace *)place {
  [self dismissViewControllerAnimated:YES completion:nil];
  // Do something with the selected place.
  NSLog(@"Place name %@", place.name);
  NSLog(@"Place address %@", place.formattedAddress);
  NSLog(@"Place attributions %@", place.attributions.string);
}

- (void)resultsController:(GMSAutocompleteResultsViewController *)resultsController
didFailAutocompleteWithError:(NSError *)error {
  [self dismissViewControllerAnimated:YES completion:nil];
  // TODO: handle the error.
  NSLog(@"Error: %@", [error description]);
}

// Turn the network activity indicator on and off again.
- (void)didRequestAutocompletePredictionsForResultsController:
    (GMSAutocompleteResultsViewController *)resultsController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
}

- (void)didUpdateAutocompletePredictionsForResultsController:
    (GMSAutocompleteResultsViewController *)resultsController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
}

Domyślnie UISearchController ukrywa pasek nawigacyjny podczas prezentacji (można to wyłączyć). Jeśli pasek nawigacyjny jest widoczny i nieprzezroczysty, właściwość UISearchController nie ustawia prawidłowo miejsca docelowego.

Aby obejść ten problem, użyj tego kodu:

Swift

navigationController?.navigationBar.translucent = false
searchController?.hidesNavigationBarDuringPresentation = false

// This makes the view area include the nav bar even though it is opaque.
// Adjust the view placement down.
self.extendedLayoutIncludesOpaqueBars = true
self.edgesForExtendedLayout = .top

Objective-C

self.navigationController.navigationBar.translucent = NO;
_searchController.hidesNavigationBarDuringPresentation = NO;

// This makes the view area include the nav bar even though it is opaque.
// Adjust the view placement down.
self.extendedLayoutIncludesOpaqueBars = YES;
self.edgesForExtendedLayout = UIRectEdgeTop;

Poniższy przykładowy kod pokazuje, jak umieścić pasek wyszukiwania po prawej stronie paska nawigacyjnego i wyświetlić wyniki w wyskakującym okienku.

Swift

import UIKit
import GooglePlaces

class ViewController: UIViewController {

  var resultsViewController: GMSAutocompleteResultsViewController?
  var searchController: UISearchController?
  var resultView: UITextView?

  override func viewDidLoad() {
    super.viewDidLoad()

    resultsViewController = GMSAutocompleteResultsViewController()
    resultsViewController?.delegate = self

    searchController = UISearchController(searchResultsController: resultsViewController)
    searchController?.searchResultsUpdater = resultsViewController

    // Add the search bar to the right of the nav bar,
    // use a popover to display the results.
    // Set an explicit size as we don't want to use the entire nav bar.
    searchController?.searchBar.frame = (CGRect(x: 0, y: 0, width: 250.0, height: 44.0))
    navigationItem.rightBarButtonItem = UIBarButtonItem(customView: (searchController?.searchBar)!)

    // When UISearchController presents the results view, present it in
    // this view controller, not one further up the chain.
    definesPresentationContext = true

    // Keep the navigation bar visible.
    searchController?.hidesNavigationBarDuringPresentation = false
    searchController?.modalPresentationStyle = .popover
  }
}
// Handle the user's selection.
extension ViewController: GMSAutocompleteResultsViewControllerDelegate {
  func resultsController(_ resultsController: GMSAutocompleteResultsViewController,
                         didAutocompleteWith place: GMSPlace) {
    searchController?.isActive = false
    // Do something with the selected place.
    print("Place name: \(place.name)")
    print("Place address: \(place.formattedAddress)")
    print("Place attributions: \(place.attributions)")
  }

  func resultsController(_ resultsController: GMSAutocompleteResultsViewController,
                         didFailAutocompleteWithError error: Error){
    // TODO: handle the error.
    print("Error: ", error.localizedDescription)
  }

  // Turn the network activity indicator on and off again.
  func didRequestAutocompletePredictions(forResultsController resultsController: GMSAutocompleteResultsViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = true
  }

  func didUpdateAutocompletePredictions(forResultsController resultsController: GMSAutocompleteResultsViewController) {
    UIApplication.shared.isNetworkActivityIndicatorVisible = false
  }
}

Objective-C

- (void)viewDidLoad {
  [super viewDidLoad];

  _resultsViewController = [[GMSAutocompleteResultsViewController alloc] init];
  _resultsViewController.delegate = self;

  _searchController = [[UISearchController alloc]
                           initWithSearchResultsController:_resultsViewController];
  _searchController.searchResultsUpdater = _resultsViewController;

  // Add the search bar to the right of the nav bar,
  // use a popover to display the results.
  // Set an explicit size as we don't want to use the entire nav bar.
  _searchController.searchBar.frame = CGRectMake(0, 0, 250.0f, 44.0f);
  self.navigationItem.rightBarButtonItem =
  [[UIBarButtonItem alloc] initWithCustomView:_searchController.searchBar];

  // When UISearchController presents the results view, present it in
  // this view controller, not one further up the chain.
  self.definesPresentationContext = YES;

  // Keep the navigation bar visible.
  _searchController.hidesNavigationBarDuringPresentation = NO;

  _searchController.modalPresentationStyle = UIModalPresentationPopover;
}

// Handle the user's selection.
- (void)resultsController:(GMSAutocompleteResultsViewController *)resultsController
didAutocompleteWithPlace:(GMSPlace *)place {
  [self dismissViewControllerAnimated:YES completion:nil];
  NSLog(@"Place name %@", place.name);
  NSLog(@"Place address %@", place.formattedAddress);
  NSLog(@"Place attributions %@", place.attributions.string);
}

- (void)resultsController:(GMSAutocompleteResultsViewController *)resultsController
didFailAutocompleteWithError:(NSError *)error {
  [self dismissViewControllerAnimated:YES completion:nil];
  // TODO: handle the error.
  NSLog(@"Error: %@", [error description]);
}

// Turn the network activity indicator on and off again.
- (void)didRequestAutocompletePredictionsForResultsController:
    (GMSAutocompleteResultsViewController *)resultsController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
}

- (void)didUpdateAutocompletePredictionsForResultsController:
    (GMSAutocompleteResultsViewController *)resultsController {
  [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
}

Korzystanie ze źródła danych tabeli

Jeśli Twoja aplikacja ma interfejs niestandardowego tekstu wyszukiwania, możesz użyć klasy GMSAutocompleteTableDataSource, aby umożliwić wyświetlanie wyników w widoku tabeli za pomocą kontrolera widoku.

Aby używać GMSAutocompleteTableDataSource jako źródła danych i przekazywania dostępu do UITableView w kontrolerze widoku:

Zaimplementuj protokoły GMSAutocompleteTableDataSourceDelegate i UISearchBarDelegate w kontrolerze widoków.
Utwórz instancję GMSAutocompleteTableDataSource i przypisz kontroler widoku danych jako właściwość przedstawiciela.
Ustaw GMSAutocompleteTableDataSource jako źródło danych i przekaż właściwości instancji UITableView w kontrolerze widoków.
W module obsługi wpisywania wyszukiwanego tekstu wywołaj sourceTextHasChanged w: GMSAutocompleteTableDataSource.
Obsługuj wybór użytkownika w metodzie delegowania didAutocompleteWithPlace.
Zamknij kontroler w metodach przekazywania dostępu didAutocompleteWithPlace, didFailAutocompleteWithError i wasCancelled.

Poniższy przykładowy kod ilustruje użycie klasy GMSAutocompleteTableDataSource do kierowania widoku tabeli elementu UIViewController, gdy element UISearchBar jest dodany oddzielnie.

Swift

// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import GooglePlaces
import UIKit

class PlaceAutocompleteViewController: UIViewController {

  private var tableView: UITableView!
  private var tableDataSource: GMSAutocompleteTableDataSource!

  override func viewDidLoad() {
    super.viewDidLoad()

    let searchBar = UISearchBar(frame: CGRect(x: 0, y: 20, width: self.view.frame.size.width, height: 44.0))
    searchBar.delegate = self
    view.addSubview(searchBar)

    tableDataSource = GMSAutocompleteTableDataSource()
    tableDataSource.delegate = self

    tableView = UITableView(frame: CGRect(x: 0, y: 64, width: self.view.frame.size.width, height: self.view.frame.size.height - 44))
    tableView.delegate = tableDataSource
    tableView.dataSource = tableDataSource

    view.addSubview(tableView)
  }
}

extension PlaceAutocompleteViewController: UISearchBarDelegate {
  func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
    // Update the GMSAutocompleteTableDataSource with the search text.
    tableDataSource.sourceTextHasChanged(searchText)
  }
}

extension PlaceAutocompleteViewController: GMSAutocompleteTableDataSourceDelegate {
  func didUpdateAutocompletePredictions(for tableDataSource: GMSAutocompleteTableDataSource) {
    // Turn the network activity indicator off.
    UIApplication.shared.isNetworkActivityIndicatorVisible = false
    // Reload table data.
    tableView.reloadData()
  }

  func didRequestAutocompletePredictions(for tableDataSource: GMSAutocompleteTableDataSource) {
    // Turn the network activity indicator on.
    UIApplication.shared.isNetworkActivityIndicatorVisible = true
    // Reload table data.
    tableView.reloadData()
  }

  func tableDataSource(_ tableDataSource: GMSAutocompleteTableDataSource, didAutocompleteWith place: GMSPlace) {
    // Do something with the selected place.
    print("Place name: \(place.name)")
    print("Place address: \(place.formattedAddress)")
    print("Place attributions: \(place.attributions)")
  }

  func tableDataSource(_ tableDataSource: GMSAutocompleteTableDataSource, didFailAutocompleteWithError error: Error) {
    // Handle the error.
    print("Error: \(error.localizedDescription)")
  }

  func tableDataSource(_ tableDataSource: GMSAutocompleteTableDataSource, didSelect prediction: GMSAutocompletePrediction) -> Bool {
    return true
  }
}

Objective-C

// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#import "PlaceAutocompleteViewController.h"
@import GooglePlaces;
@import UIKit;

@interface PlaceAutocompleteViewController () <GMSAutocompleteTableDataSourceDelegate, UISearchBarDelegate>

@end

@implementation PlaceAutocompleteViewController {
  UITableView *tableView;
  GMSAutocompleteTableDataSource *tableDataSource;
}

- (void)viewDidLoad {
  [super viewDidLoad];

  UISearchBar *searchBar = [[UISearchBar alloc] initWithFrame:CGRectMake(0, 20, self.view.frame.size.width, 44)];
  searchBar.delegate = self;

  [self.view addSubview:searchBar];

  tableDataSource = [[GMSAutocompleteTableDataSource alloc] init];
  tableDataSource.delegate = self;

  tableView = [[UITableView alloc] initWithFrame:CGRectMake(0, 64, self.view.frame.size.width, self.view.frame.size.height - 44)];
  tableView.delegate = tableDataSource;
  tableView.dataSource = tableDataSource;

  [self.view addSubview:tableView];
}

#pragma mark - GMSAutocompleteTableDataSourceDelegate

- (void)didUpdateAutocompletePredictionsForTableDataSource:(GMSAutocompleteTableDataSource *)tableDataSource {
  // Turn the network activity indicator off.
  UIApplication.sharedApplication.networkActivityIndicatorVisible = NO;

  // Reload table data.
  [tableView reloadData];
}

- (void)didRequestAutocompletePredictionsForTableDataSource:(GMSAutocompleteTableDataSource *)tableDataSource {
  // Turn the network activity indicator on.
  UIApplication.sharedApplication.networkActivityIndicatorVisible = YES;

  // Reload table data.
  [tableView reloadData];
}

- (void)tableDataSource:(GMSAutocompleteTableDataSource *)tableDataSource didAutocompleteWithPlace:(GMSPlace *)place {
  // Do something with the selected place.
  NSLog(@"Place name: %@", place.name);
  NSLog(@"Place address: %@", place.formattedAddress);
  NSLog(@"Place attributions: %@", place.attributions);
}

- (void)tableDataSource:(GMSAutocompleteTableDataSource *)tableDataSource didFailAutocompleteWithError:(NSError *)error {
  // Handle the error
  NSLog(@"Error %@", error.description);
}

- (BOOL)tableDataSource:(GMSAutocompleteTableDataSource *)tableDataSource didSelectPrediction:(GMSAutocompletePrediction *)prediction {
  return YES;
}

#pragma mark - UISearchBarDelegate

- (void)searchBar:(UISearchBar *)searchBar textDidChange:(NSString *)searchText {
  // Update the GMSAutocompleteTableDataSource with the search text.
  [tableDataSource sourceTextHasChanged:searchText];
}

@end

Dostosowywanie kolorów tekstu i tła

Za pomocą elementów sterujących autouzupełniania w interfejsie możesz ustawić kolory całego tekstu i tła, aby widżet lepiej pasował do wyglądu aplikacji. Kolory elementów sterujących interfejsu można ustawić na 2 sposoby:

Przez używanie natywnego protokołu UI Wygląd na iOS, aby w miarę możliwości globalnie określać styl elementów interfejsu. Te ustawienia dotyczą wielu elementów sterujących interfejsu, ale nie wszystkich.
Przez używanie metod pakietu SDK w klasach widżetu do ustawiania właściwości, które nie są obsługiwane przez protokół UIPrezentacja.

Zwykle aplikacja używa kombinacji metod protokołu UILook i pakietu SDK. Ten diagram pokazuje, których elementów można nadać styl:

Kolory elementów sterujących autouzupełniania w interfejsie

W tabeli poniżej znajdziesz listę wszystkich elementów interfejsu wraz z informacjami o sposobie ich określania (zgodnie z interfejsem UIinterfejs lub SDK).

Element interfejsu	Metoda	Poradniki i styl
Odcień paska nawigacyjnego (w tle)	Protokół UIPrezentacja	Wywołaj `setBarTintColor` przez serwer proxy `UINavigationBar`.
Kolor odcienia paska nawigacyjnego (wskaźnik tekstu paska wyszukiwania i przycisk Anuluj)	Protokół UIPrezentacja	Wywołaj `setTintColor` przez serwer proxy `UINavigationBar`.
Kolor tekstu paska wyszukiwania	Protokół UIPrezentacja	Ustaw wartość `NSForegroundColorAttributeName` w polu `searchBarTextAttributes`.
Kolor odcienia paska wyszukiwania	Nie dotyczy	Pasek wyszukiwania jest półprzezroczysty i wyświetla się jako zacieniona wersja paska nawigacyjnego.
Kolor tekstu obiektu zastępczego paska wyszukiwania (domyślny tekst wyszukiwania)	Protokół UIPrezentacja	Ustaw wartość `NSForegroundColorAttributeName` w polu `placeholderAttributes`.
Tekst główny (również stosowany do tekstu błędu i komunikatu)	Metoda z pakietu SDK	Zadzwoń do firmy `primaryTextColor`.
Wyróżnienie tekstu głównego	Metoda z pakietu SDK	Zadzwoń do firmy `primaryTextHighlightColor`.
Tekst dodatkowy	Metoda z pakietu SDK	Zadzwoń do firmy `secondaryTextColor`.
Błąd i treść wiadomości	Metoda z pakietu SDK	Zadzwoń do firmy `primaryTextColor`.
Tło komórki tabeli	Metoda z pakietu SDK	Zadzwoń do firmy `tableCellBackgroundColor`.
Kolor separatora komórek tabeli	Metoda z pakietu SDK	Zadzwoń do firmy `tableCellSeparatorColor`.
Przycisk „Spróbuj ponownie”	Metoda z pakietu SDK	Zadzwoń do firmy `tintColor`.
Wskaźnik aktywności (wskaźnik postępu)	Protokół UIPrezentacja	Wywołaj `setColor` przez serwer proxy `UIActivityIndicatorView`.
Logo „Powered by Google”, obraz chmury Sad	Nie dotyczy	Wersja biała lub szara jest wybierana automatycznie na podstawie kontrastu tła.
Lupa i ikony z czystym tekstem w polu tekstowym na pasku wyszukiwania	Nie dotyczy	Aby określić styl, zastąp obrazy domyślne obrazami w wybranym kolorze.

Korzystanie z protokołu UIVisual

Aby uzyskać serwer proxy wyglądu dla danego elementu interfejsu, możesz użyć protokołu UIPreview, za pomocą którego można ustawić kolor tego elementu. Modyfikacja ma wpływ na wszystkie wystąpienia danego elementu interfejsu. Na przykład ten przykład globalnie zmienia kolor tekstu klas UITextField na zielony, gdy są zawarte w elemencie UISearchBar:

[[UITextField appearanceWhenContainedIn:[UISearchBar class], nil]
    setDefaultTextAttributes:@{NSForegroundColorAttributeName:[UIColor greenColor]}];

Więcej informacji na temat definiowania wartości kolorów znajdziesz w dokumentacji klasy UIColor.

Poniższe fragmenty kodu zawierają wszystkie polecenia serwera proxy potrzebne do określenia stylu wszystkiego w elemencie sterującym autouzupełnianiem na pełnym ekranie w interfejsie użytkownika. Dodaj ten kod do metody didFinishLaunchingWithOptions w Appdelegate.m:

// Define some colors.
UIColor *darkGray = [UIColor darkGrayColor];
UIColor *lightGray = [UIColor lightGrayColor];

// Navigation bar background.
[[UINavigationBar appearance] setBarTintColor:darkGray];
[[UINavigationBar appearance] setTintColor:lightGray];

// Color of typed text in the search bar.
NSDictionary *searchBarTextAttributes = @{
                                          NSForegroundColorAttributeName: lightGray,
                                          NSFontAttributeName : [UIFont systemFontOfSize:[UIFont systemFontSize]]
                                          };
[UITextField appearanceWhenContainedInInstancesOfClasses:@[[UISearchBar class]]]
    .defaultTextAttributes = searchBarTextAttributes;

// Color of the placeholder text in the search bar prior to text entry.
NSDictionary *placeholderAttributes = @{
                                        NSForegroundColorAttributeName: lightGray,
                                        NSFontAttributeName : [UIFont systemFontOfSize:[UIFont systemFontSize]]
                                        };

// Color of the default search text.
// NOTE: In a production scenario, "Search" would be a localized string.
NSAttributedString *attributedPlaceholder =
[[NSAttributedString alloc] initWithString:@"Search"
                                attributes:placeholderAttributes];
[UITextField appearanceWhenContainedInInstancesOfClasses:@[[UISearchBar class]]]
    .attributedPlaceholder = attributedPlaceholder;

// Color of the in-progress spinner.
[[UIActivityIndicatorView appearance] setColor:lightGray];

// To style the two image icons in the search bar (the magnifying glass
// icon and the 'clear text' icon), replace them with different images.
[[UISearchBar appearance] setImage:[UIImage imageNamed:@"custom_clear_x_high"]
                  forSearchBarIcon:UISearchBarIconClear
                            state:UIControlStateHighlighted];
[[UISearchBar appearance] setImage:[UIImage imageNamed:@"custom_clear_x"]
                  forSearchBarIcon:UISearchBarIconClear
                            state:UIControlStateNormal];
[[UISearchBar appearance] setImage:[UIImage imageNamed:@"custom_search"]
                    forSearchBarIcon:UISearchBarIconSearch
                            state:UIControlStateNormal];

// Color of selected table cells.
UIView *selectedBackgroundView = [[UIView alloc] init];
selectedBackgroundView.backgroundColor = [UIColor lightGrayColor];
[UITableViewCell appearanceWhenContainedIn:[GMSAutocompleteViewController class], nil]
    .selectedBackgroundView = selectedBackgroundView;

Ustawianie właściwości stylu elementów sterujących interfejsu

Podzbiór elementów sterujących interfejsu ma właściwości, na które nie ma wpływu protokół UILook, więc należy go ustawić bezpośrednio. Poniższy przykładowy kod pokazuje, jak określić kolory pierwszego planu i tła oraz zastosować je do instancji sterującej UI o nazwie acController. Dodaj ten kod do metody onLaunchClicked w ViewController.m:

UIColor *darkGray = [UIColor darkGrayColor];
UIColor *lightGray = [UIColor lightGrayColor];

acController.secondaryTextColor = [UIColor colorWithWhite:1.0f alpha:0.5f];
acController.primaryTextColor = lightGray;
acController.primaryTextHighlightColor = [UIColor grayColor];
acController.tableCellBackgroundColor = darkGray;
acController.tableCellSeparatorColor = lightGray;
acController.tintColor = lightGray;

Automatyczne uzyskiwanie prognoz dotyczących miejsc

Zamiast interfejsu użytkownika udostępnianego przez widżet autouzupełniania możesz utworzyć niestandardowy interfejs wyszukiwania. W tym celu aplikacja musi automatycznie uzyskiwać prognozy miejsc. Aplikacja może pobrać listę przewidywanych nazw miejsc lub adresów na jeden z tych sposobów:

Zadzwoń: GMSPlacesClient findAutocompletePredictionsFromQuery:
Używanie modułu pobierania

Dzwonię do: `GMSPlacesClient findAutocompletePredictionsFromQuery:`

Aby uzyskać listę przewidywanych nazw miejsc lub adresów, najpierw uruchom GMSPlacesClient, a następnie wywołaj metodę GMSPlacesClient findAutocompletePredictionsFromQuery: z następującymi parametrami:

Ciąg tekstowy autocompleteQuery zawierający tekst wpisany przez użytkownika.
GMSAutocompleteSessionToken, który służy do identyfikowania poszczególnych sesji. Aplikacja powinna przekazywać ten sam token przy każdym wywołaniu żądania autouzupełniania. Następnie należy przekazać ten token wraz z identyfikatorem miejsca w kolejnym wywołaniu do fetchPlacefromPlaceID:, aby pobrać szczegóły miejsca wybranego przez użytkownika.
GMSAutocompleteFilter do:
- stronniczości lub ograniczania wyników do konkretnego regionu;
- Ogranicz wyniki do określonego typu miejsca.
- Obiekt GMSPlaceLocationBias/Restriction promujący wyniki do konkretnego obszaru określony za pomocą granic szerokości i długości geograficznej.
Metoda wywołania zwrotnego do obsługi zwróconych prognoz.

Poniższe przykłady kodu pokazują wywołanie findAutocompletePredictionsFromQuery:.

Swift

/**
 * Create a new session token. Be sure to use the same token for calling
 * findAutocompletePredictions, as well as the subsequent place details request.
 * This ensures that the user's query and selection are billed as a single session.
 */
let token = GMSAutocompleteSessionToken.init()

// Create a type filter.
let filter = GMSAutocompleteFilter()
filter.types = [.bank] 
filter.locationBias = GMSPlaceRectangularLocationOption( northEastBounds,
                                   southWestBounds);

placesClient?.findAutocompletePredictions(fromQuery: "cheesebu",

                                          filter: filter,
                                          sessionToken: token,
                                          callback: { (results, error) in
    if let error = error {
      print("Autocomplete error: \(error)")
      return
    }
    if let results = results {
      for result in results {
        print("Result \(result.attributedFullText) with placeID \(result.placeID)")
      }
    }
})

Objective-C

/**
 * Create a new session token. Be sure to use the same token for calling
 * findAutocompletePredictionsFromQuery:, as well as the subsequent place details request.
 * This ensures that the user's query and selection are billed as a single session.
 */
GMSAutocompleteSessionToken *token = [[GMSAutocompleteSessionToken alloc] init];

// Create a type filter.
GMSAutocompleteFilter *_filter = [[GMSAutocompleteFilter alloc] init];
_filter.types = @[ kGMSPlaceTypeBank ];

[_placesClient findAutocompletePredictionsFromQuery:@"cheesebu"
filter:_filter sessionToken:token callback:^(NSArray<GMSAutocompletePrediction *> * _Nullable results, NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"An error occurred %@", [error localizedDescription]);
    return;
  }
  if (results != nil) {
    for (GMSAutocompletePrediction *result in results) {
      NSLog(@"Result %@ with PlaceID %@", result.attributedFullText, result.placeID);
    }
  }
}];

Interfejs API wywołuje określoną metodę wywołania zwrotnego, przekazując tablicę obiektów GMSAutocompletePrediction.

Każdy obiekt GMSAutocompletePrediction zawiera te informacje:

attributedFullText – pełny tekst prognozy w postaci NSAttributedString. na przykład „Sydney Opera House, Sydney, Nowa Południowa Walia, Australia”. Każdy zakres tekstu, który pasuje do danych wejściowych użytkownika, ma atrybut kGMSAutocompleteMatchAttribute. Możesz użyć tego atrybutu, aby wyróżnić pasujący tekst w zapytaniu użytkownika, np. tak jak poniżej.
placeID – identyfikator prognozowanego miejsca. Identyfikator miejsca to identyfikator tekstowy, który jednoznacznie identyfikuje miejsce. Więcej informacji o identyfikatorach miejsc znajdziesz w omówieniu identyfikatorów miejsc.
distanceMeters – odległość w linii prostej z określonego miejsca (origin) do miejsca docelowego. Jeśli właściwość origin nie jest ustawiona, wartość odległości nie jest zwracana.

Poniższy przykładowy kod pokazuje, jak za pomocą pogrubionego tekstu zaznaczyć fragmenty wyniku pasujące do tekstu w zapytaniu użytkownika za pomocą funkcji enumerateAttribute:

Swift

let regularFont = UIFont.systemFont(ofSize: UIFont.labelFontSize)
let boldFont = UIFont.boldSystemFont(ofSize: UIFont.labelFontSize)

let bolded = prediction.attributedFullText.mutableCopy() as! NSMutableAttributedString
bolded.enumerateAttribute(kGMSAutocompleteMatchAttribute, in: NSMakeRange(0, bolded.length), options: []) {
  (value, range: NSRange, stop: UnsafeMutablePointer<ObjCBool>) -> Void in
    let font = (value == nil) ? regularFont : boldFont
    bolded.addAttribute(NSFontAttributeName, value: font, range: range)
}

label.attributedText = bolded

Objective-C

UIFont *regularFont = [UIFont systemFontOfSize:[UIFont labelFontSize]];
UIFont *boldFont = [UIFont boldSystemFontOfSize:[UIFont labelFontSize]];

NSMutableAttributedString *bolded = [prediction.attributedFullText mutableCopy];
[bolded enumerateAttribute:kGMSAutocompleteMatchAttribute
                   inRange:NSMakeRange(0, bolded.length)
                   options:0
                usingBlock:^(id value, NSRange range, BOOL *stop) {
                  UIFont *font = (value == nil) ? regularFont : boldFont;
                  [bolded addAttribute:NSFontAttributeName value:font range:range];
                }];

label.attributedText = bolded;

Korzystanie z modułu pobierania

Jeśli chcesz utworzyć od podstaw własną opcję autouzupełniania, możesz użyć metody GMSAutocompleteFetcher, która opakowuje metodę autocompleteQuery w elemencie GMSPlacesClient. Moduł pobierania ogranicza liczbę żądań i zwraca tylko wyniki dotyczące ostatniego wpisanego tekstu. Nie zawiera żadnych elementów interfejsu.

Aby wdrożyć GMSAutocompleteFetcher, wykonaj te czynności:

Zaimplementuj protokół GMSAutocompleteFetcherDelegate.
Utwórz obiekt GMSAutocompleteFetcher.
Wywołuj metodę sourceTextHasChanged w narzędziu pobierającym podczas wpisywania tekstu przez użytkownika.
Obsługuj prognozy i błędy za pomocą metod protokołów didAutcompleteWithPredictions i didFailAutocompleteWithError.

Poniższy przykładowy kod pokazuje, jak używać modułu pobierania do pobierania danych wejściowych użytkownika i wyświetlania dopasowań miejsc w widoku tekstowym. Funkcja wyboru miejsca została pominięta. FetcherSampleViewController pochodzi z pliku UIViewController w pliku FetcherSampleViewController.h.

Swift

import UIKit
import GooglePlaces

class ViewController: UIViewController {

  var textField: UITextField?
  var resultText: UITextView?
  var fetcher: GMSAutocompleteFetcher?

  override func viewDidLoad() {
    super.viewDidLoad()

    view.backgroundColor = .white
    edgesForExtendedLayout = []

    // Set bounds to inner-west Sydney Australia.
    let neBoundsCorner = CLLocationCoordinate2D(latitude: -33.843366,
                                                longitude: 151.134002)
    let swBoundsCorner = CLLocationCoordinate2D(latitude: -33.875725,
                                                longitude: 151.200349)

    // Set up the autocomplete filter.
    let filter = GMSAutocompleteFilter()
    filter.locationRestriction = GMSPlaceRectangularLocationOption(neBoundsCorner, swBoundsCorner)

    // Create a new session token.
    let token: GMSAutocompleteSessionToken = GMSAutocompleteSessionToken.init()

    // Create the fetcher.
    fetcher = GMSAutocompleteFetcher(bounds: nil, filter: filter)
    fetcher?.delegate = self
    fetcher?.provide(token)

    textField = UITextField(frame: CGRect(x: 5.0, y: 10.0,
                                          width: view.bounds.size.width - 5.0,
                                          height: 64.0))
    textField?.autoresizingMask = .flexibleWidth
    textField?.addTarget(self, action: #selector(textFieldDidChange(textField:)),
                         for: .editingChanged)
    let placeholder = NSAttributedString(string: "Type a query...")

    textField?.attributedPlaceholder = placeholder

    resultText = UITextView(frame: CGRect(x: 0, y: 65.0,
                                          width: view.bounds.size.width,
                                          height: view.bounds.size.height - 65.0))
    resultText?.backgroundColor = UIColor(white: 0.95, alpha: 1.0)
    resultText?.text = "No Results"
    resultText?.isEditable = false

    self.view.addSubview(textField!)
    self.view.addSubview(resultText!)
  }

  @objc func textFieldDidChange(textField: UITextField) {
    fetcher?.sourceTextHasChanged(textField.text!)
  }

}

extension ViewController: GMSAutocompleteFetcherDelegate {
  func didAutocomplete(with predictions: [GMSAutocompletePrediction]) {
    let resultsStr = NSMutableString()
    for prediction in predictions {
      resultsStr.appendFormat("\n Primary text: %@\n", prediction.attributedPrimaryText)
      resultsStr.appendFormat("Place ID: %@\n", prediction.placeID)
    }

    resultText?.text = resultsStr as String
  }

  func didFailAutocompleteWithError(_ error: Error) {
    resultText?.text = error.localizedDescription
  }
}

Objective-C

#import "FetcherSampleViewController.h"
#import <GooglePlaces/GooglePlaces.h>
#import <GoogleMapsBase/GoogleMapsBase.h>

@interface FetcherSampleViewController () <GMSAutocompleteFetcherDelegate>

@end

@implementation FetcherSampleViewController {
  UITextField *_textField;
  UITextView *_resultText;
  GMSAutocompleteFetcher* _fetcher;
}

- (void)viewDidLoad {
  [super viewDidLoad];

  self.view.backgroundColor = [UIColor whiteColor];
  self.edgesForExtendedLayout = UIRectEdgeNone;

  // Set bounds to inner-west Sydney Australia.
  CLLocationCoordinate2D neBoundsCorner = CLLocationCoordinate2DMake(-33.843366, 151.134002);
  CLLocationCoordinate2D swBoundsCorner = CLLocationCoordinate2DMake(-33.875725, 151.200349);

  GMSAutocompleteFilter *autocompleteFilter = [[GMSAutocompleteFilter alloc] init];
  autocompleteFilter.locationRestriction =
        GMSPlaceRectangularLocationOption(neBoundsCorner, swBoundsCorner);

  // Create the fetcher.
  _fetcher = [[GMSAutocompleteFetcher alloc] initWithBounds:nil
                                                     filter:filter];
  _fetcher.delegate = self;

  // Set up the UITextField and UITextView.
  _textField = [[UITextField alloc] initWithFrame:CGRectMake(5.0f,
                                                             0,
                                                             self.view.bounds.size.width - 5.0f,
                                                             44.0f)];
  _textField.autoresizingMask = UIViewAutoresizingFlexibleWidth;
  [_textField addTarget:self
                 action:@selector(textFieldDidChange:)
       forControlEvents:UIControlEventEditingChanged];
  _resultText =[[UITextView alloc] initWithFrame:CGRectMake(0,
                                                            45.0f,
                                                            self.view.bounds.size.width,
                                                            self.view.bounds.size.height - 45.0f)];
  _resultText.backgroundColor = [UIColor colorWithWhite:0.95f alpha:1.0f];
  _resultText.text = @"No Results";
  _resultText.editable = NO;
  [self.view addSubview:_textField];
  [self.view addSubview:_resultText];
}

- (void)textFieldDidChange:(UITextField *)textField {
  NSLog(@"%@", textField.text);
  [_fetcher sourceTextHasChanged:textField.text];
}

#pragma mark - GMSAutocompleteFetcherDelegate
- (void)didAutocompleteWithPredictions:(NSArray *)predictions {
  NSMutableString *resultsStr = [NSMutableString string];
  for (GMSAutocompletePrediction *prediction in predictions) {
      [resultsStr appendFormat:@"%@\n", [prediction.attributedPrimaryText string]];
  }
  _resultText.text = resultsStr;
}

- (void)didFailAutocompleteWithError:(NSError *)error {
  _resultText.text = [NSString stringWithFormat:@"%@", error.localizedDescription];
}

@end

Tokeny sesji

Tokeny sesji grupują fazy zapytania i wyboru użytkownika autouzupełniania wyszukiwania w oddzielną sesję na potrzeby rozliczeń. Sesja rozpoczyna się, gdy użytkownik zaczyna wpisywać zapytanie, i kończy, gdy wybiera miejsce. Każda sesja może zawierać wiele zapytań, po których następuje wybór jednego miejsca. Po zakończeniu sesji token przestaje być ważny. Aplikacja musi wygenerować nowy token dla każdej sesji. Zalecamy używanie tokenów sesji we wszystkich sesjach autouzupełniania (jeśli używasz kontrolera pełnoekranowego lub kontrolera wyników, interfejs API robi to automatycznie).

Pakiet Miejsca SDK na iOS używa kodu GMSAutocompleteSessionToken do identyfikowania każdej sesji. Na początku każdej nowej sesji aplikacja powinna przekazywać nowy token sesji, a potem przekazywać ten sam token wraz z identyfikatorem miejsca w kolejnym wywołaniu do fetchPlacefromPlaceID:, aby pobrać szczegóły miejsca wybranego przez użytkownika.

Więcej informacji o tokenach sesji

Aby wygenerować nowy token sesji, użyj tego kodu:

let token: GMSAutocompleteSessionToken = GMSAutocompleteSessionToken.init()

Limity wykorzystania

Użycie metody GMSPlacesClient findAutocompletePredictionsFromQuery podlega kilkupoziomowym limitom zapytań. Zapoznaj się z dokumentacją dotyczącą limitów wykorzystania.

Wyświetlanie atrybucji w aplikacji

Jeśli Twoja aplikacja automatycznie korzysta z usługi autouzupełniania, interfejs użytkownika musi zawierać informację „Technologia Google” lub pojawiać się na mapie marki Google.
Jeśli Twoja aplikacja korzysta z elementu sterującego autouzupełniania w interfejsie, nie musisz nic więcej robić (wymagane informacje o autouzupełnianiu są wyświetlane domyślnie).
Jeśli po zdobyciu miejsca na podstawie identyfikatora pobierasz i wyświetlasz dodatkowe informacje o miejscu, musisz też uwzględniać informacje o pochodzeniu danych od innych firm.

Więcej informacji na ten temat znajdziesz w dokumentacji dotyczącej atrybucji.

Sterowanie wskaźnikiem aktywności sieci

Aby kontrolować wskaźnik aktywności sieci na pasku stanu aplikacji, musisz zaimplementować odpowiednie opcjonalne metody przekazywania dostępu do używanej klasy autouzupełniania oraz samodzielnie włączyć i wyłączyć wskaźnik sieci.

W przypadku GMSAutocompleteViewController musisz wdrożyć metody przekazywania dostępu didRequestAutocompletePredictions: i didUpdateAutocompletePredictions:.
W przypadku GMSAutocompleteResultsViewController musisz wdrożyć metody przekazywania dostępu didRequestAutocompletePredictionsForResultsController: i didUpdateAutocompletePredictionsForResultsController:.
W przypadku GMSAutocompleteTableDataSource musisz wdrożyć metody przekazywania dostępu didRequestAutocompletePredictionsForTableDataSource: i didUpdateAutocompletePredictionsForTableDataSource:.

Po zaimplementowaniu tych metod i ustawieniu elementu [UIApplication sharedApplication].networkActivityIndicatorVisible na YES i NO pasek stanu będzie poprawnie dopasowany do interfejsu autouzupełniania.

Ograniczanie wyników autouzupełniania

W interfejsie autouzupełniania możesz ustawić ograniczenie wyników do konkretnego regionu geograficznego lub filtrowanie wyników według jednego bądź kilku typów miejsc albo konkretnego kraju lub kraju. Aby ograniczyć wyniki, wykonaj te czynności:

Aby preferować (odchylenie) wyników w zdefiniowanym regionie, ustaw locationBias w GMSAutocompleteFilter (niektóre wyniki spoza zdefiniowanego regionu mogą nadal być zwracane). Jeśli zasada locationRestriction jest też skonfigurowana, zasada locationBias jest ignorowana.
Aby wyświetlać tylko (ograniczać) wyniki w zdefiniowanym regionie, ustaw locationRestriction w GMSAutocompleteFilter (zostaną zwrócone tylko wyniki z określonego regionu).
- Uwaga: to ograniczenie dotyczy tylko całych tras. Wyniki syntetyczne znajdujące się poza prostokątnymi granicami mogą być zwracane w przypadku trasy, która pokrywa się z ograniczeniem dotyczącym lokalizacji.
Aby zwracać tylko wyniki zgodne z konkretnym typem miejsca, ustaw types w GMSAutocompleteFilter. Na przykład określenie filtra TypeFilter.ADDRESS spowoduje, że widżet będzie zwracać tylko wyniki z precyzyjnym adresem.
Aby zwracać tylko wyniki z maksymalnie 5 określonych krajów, w polu GMSAutocompleteFilter ustaw wartość countries.

Uprzedzenia w konkretnym regionie

Aby preferować (odchylenie) wyników w zdefiniowanym regionie, ustaw locationBias w GMSAutocompleteFilter w ten sposób:

  northEast = CLLocationCoordinate2DMake(39.0, -95.0);
  southWest = CLLocationCoordinate2DMake(37.5, -100.0);
  GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
  filter.locationBias = GMSPlaceRectangularLocationOption(northEast, southWest);

Ograniczanie wyników do konkretnego regionu

Aby wyświetlać (ograniczać) wyniki tylko w określonym regionie, ustaw wartość locationRestriction w polu GMSAutocompleteFilter w ten sposób:

  northEast = CLLocationCoordinate2DMake(39.0, -95.0);
  southWest = CLLocationCoordinate2DMake(37.5, -100.0);
  GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
  filter.locationRestriction = GMSPlaceRectangularLocationOption(northEast, southWest);

Filtrowanie wyników według kraju

Aby filtrować wyniki z maksymalnie 5 wybranych krajów, ustaw countries na GMSAutocompleteFilter, jak pokazano tutaj:

  GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
  filter.countries = @[ @"au", @"nz" ];

Filtrowanie wyników według typu miejsca lub kolekcji typów

Ogranicz wyniki do określonego typu lub kolekcji, ustawiając właściwość types na GMSAutoCompleteFilter. Ta właściwość służy do określania filtrów wymienionych w tabelach 1, 2 i 3 dotyczących typów miejsc. Jeśli niczego nie podasz, zwracane będą wszystkie typy.

Aby określić filtr kolekcji typów lub typów:

Użyj właściwości types, aby określić do 5 wartości type z tabel 1 i 2 widocznych w typach miejsc. Wartości typu są definiowane przez stałe w GMSPlaceType.
Użyj właściwości types, aby określić zbiór typów z tabeli 3 wyświetlanej w typach miejsc. Wartości zbioru typów są definiowane przez stałe w GMSPlaceType.

W żądaniu dozwolony jest tylko jeden typ z tabeli 3. Jeśli podasz wartość z tabeli 3, nie możesz podać wartości z tabeli 1 ani 2. Jeśli to zrobisz, wystąpi błąd.

Aby na przykład zwracać tylko wyniki zgodne z określonym typem miejsca, w kolumnie GMSAutocompleteFilter ustaw types. Poniższy przykład pokazuje ustawienie filtra tak, aby zwracał tylko wyniki z precyzyjnym adresem:

  GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
  filter.types = @[ kGMSPlaceTypeAirport, kGMSPlaceTypeAmusementPark ];

Optymalizacja autouzupełniania miejsc

W tej sekcji znajdziesz opis sprawdzonych metod, które pomogą Ci w pełni wykorzystać możliwości usługi autouzupełniania miejsc.

Oto kilka ogólnych wskazówek:

Najszybszym sposobem na opracowanie działającego interfejsu jest użycie widżetu autouzupełniania interfejsu Maps JavaScript API, widżetu autouzupełniania na Androidzie lub widżetu autouzupełniania w interfejsie Places SDK na iOS.

Opanuj od samego początku najważniejsze pola danych autouzupełniania miejsc.
Pola promowania lokalizacji i ograniczeń dotyczących lokalizacji są opcjonalne, ale mogą mieć znaczny wpływ na wydajność autouzupełniania.
Obsługuj błędy, aby zadbać o płynne działanie aplikacji, gdy interfejs API zwróci błąd.
Sprawdź, czy aplikacja obsługuje, gdy nie ma możliwości wyboru, i zapewni użytkownikom możliwość kontynuowania.

Sprawdzone metody optymalizacji kosztów

Podstawowa optymalizacja kosztów

Aby zoptymalizować koszty korzystania z usługi autouzupełniania miejsc, użyj masek pól w szczegółach miejsca i widżetów autouzupełniania miejsc, aby zwracać tylko te pola danych miejsc, których potrzebujesz.

Zaawansowana optymalizacja kosztów

Rozważ automatyczną implementację autouzupełniania miejsca, aby mieć dostęp do cen według żądania i wysyłać żądania wyników interfejsu Geocoding API dotyczące wybranego miejsca zamiast szczegółów miejsca. Ceny za żądanie w połączeniu z interfejsem Geocoding API są bardziej ekonomiczne niż ceny na sesję (ustalane na podstawie sesji), jeśli są spełnione oba te warunki:

Jeśli potrzebujesz tylko szerokości i długości geograficznej lub adresu wybranego przez użytkownika, interfejs Geocoding API dostarcza te informacje do wartości krótszych niż wywołanie szczegółów miejsca.
Jeśli użytkownicy wybiorą prognozę autouzupełniania nie więcej niż cztery żądania, model cenowy na żądanie może być bardziej opłacalny niż model cenowy na sesję.

Aby uzyskać pomoc przy wyborze implementacji autouzupełniania miejsc, która odpowiada Twoim potrzebom, kliknij kartę odpowiadającą Twojej odpowiedzi na poniższe pytanie.

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

Tak, potrzebuję więcej szczegółów

Korzystaj z autouzupełniania miejsc na podstawie sesji.
Aplikacja wymaga informacji o miejscu, takich jak nazwa miejsca, status firmy czy godziny otwarcia, więc implementacja autouzupełniania miejsca powinna korzystać z tokena sesji (programowo lub wbudowanych w widżety JavaScript, Androida lub iOS). Łączny koszt wynosi 0, 017 USD za sesję plus odpowiednie Kody SKU danych miejsc w zależności od żądanego pola danych o miejscu.

Implementacja widżetu
Zarządzanie sesjami jest automatycznie wbudowane w widżety JavaScript, Androida i iOS. Dotyczy to zarówno żądań autouzupełniania miejsc, jak i żądań szczegółów miejsca w przypadku wybranej podpowiedzi. Określ parametr fields, aby mieć pewność, że wysyłasz tylko żądania pól danych miejsc, których potrzebujesz.

Implementacja automatyczna
W żądaniach autouzupełniania miejsc używaj tokena sesji. Wysyłając żądanie Szczegóły miejsca dotyczące wybranej prognozy, podaj te parametry:

identyfikator miejsca z odpowiedzi autouzupełniania miejsca,
Token sesji używany w żądaniu autouzupełniania miejsca.
Parametr fields określający potrzebne pola danych miejsc

Nie, potrzebuje tylko adresu i lokalizacji

Interfejs Geocoding API może być bardziej opłacalny niż „Place Details” (Szczegóły miejsca) w przypadku danej aplikacji, w zależności od wydajności funkcji autouzupełniania. Skuteczność autouzupełniania aplikacji różni się w zależności od tego, co wpisują użytkownicy, gdzie jest ona używana i od tego, czy zostały wdrożone sprawdzone metody optymalizacji skuteczności.

Aby odpowiedzieć na to pytanie, sprawdź, ile znaków średnio wpisuje użytkownik, zanim wybierzesz podpowiedź autouzupełniania w swojej aplikacji.

Czy Twoi użytkownicy korzystają średnio z podpowiedzi autouzupełniania miejsc w maksymalnie 4 żądaniach?

Tak

Zaimplementuj autouzupełnianie miejsc automatycznie bez tokenów sesji i wywołaj interfejs Geocoding API w przypadku prognozowania wybranego miejsca.
Geocoding API dostarcza adresów oraz współrzędnych szerokości i długości geograficznej za 0,005 USD za żądanie. Realizacja 4 żądań autouzupełniania miejsc na żądanie kosztuje 0,01132 USD, więc łączny koszt 4 żądań plus wywołanie Geocoding API dla prognozy wybranego miejsca wynosi 0,01632 USD, czyli mniej niż cena autouzupełniania za sesję, która wynosi 0,017 USD za sesję¹.

Rozważ stosowanie sprawdzonych metod dotyczących skuteczności, aby pomóc użytkownikom uzyskiwać interesujące ich prognozy, używając jeszcze mniejszej liczby znaków.

Nie

Korzystaj z autouzupełniania miejsc na podstawie sesji.
Ponieważ średnia liczba żądań, które spodziewasz się wysłać przed wybraniem prognozy autouzupełniania miejsca przez użytkownika, przekracza koszt za sesję, Twoja implementacja autouzupełniania miejsc powinna korzystać z tokena sesji zarówno w przypadku żądań autouzupełniania miejsc, jak i powiązanych z nimi żądań szczegółów miejsca.Łączny koszt wynosi 0,017 USD za sesję¹.

Implementacja automatyczna
W żądaniach autouzupełniania miejsc używaj tokena sesji. Wysyłając żądanie Szczegóły miejsca dotyczące wybranej prognozy, podaj te parametry:

identyfikator miejsca z odpowiedzi autouzupełniania miejsca,
Token sesji używany w żądaniu autouzupełniania miejsca.
Parametr fields określający pola Dane podstawowe, takie jak adres i geometria

Rozważ opóźnienie żądań autouzupełniania miejsc
Możesz użyć strategii, takich jak opóźnianie żądania autouzupełniania miejsca do momentu, w którym użytkownik wpisał pierwsze 3 lub 4 znaki. Dzięki temu aplikacja będzie wysyłać mniej żądań. Na przykład wysyłanie żądań autouzupełniania miejsc dla każdego znaku po wpisaniu trzeciego znaku przez użytkownika oznacza, że jeśli użytkownik wpisze 7 znaków, a następnie wybierze podpowiedź, dla której tworzysz jedno żądanie do interfejsu Geocoding API, łączny koszt wyniesie 0,01632 USD (4 * 0,00283 USD autouzupełniania na żądanie + 0,005 USD za geokodowanie)¹.

Jeśli opóźnione żądania mogą spowodować, że średnie żądania zautomatyzowanych żądań znikają poniżej 4, zapoznaj się ze wskazówkami dotyczącymi implementacji wydajnego autouzupełniania miejsc za pomocą interfejsu Geocoding API. Pamiętaj, że opóźnione żądania mogą być postrzegane jako czas oczekiwania dla użytkownika, który może oczekiwać, że prognozy będą pojawiać się po każdym nowym naciśnięciu klawisza.

Rozważ zastosowanie sprawdzonych metod dotyczących skuteczności, aby pomóc użytkownikom uzyskiwać interesujące ich informacje przy użyciu mniejszej liczby znaków.

Wymienione tutaj koszty są podane w dolarach amerykańskich. Pełne informacje o cenach znajdziesz na stronie Rozliczenia za Google Maps Platform.

Sprawdzone metody zwiększania skuteczności

Poniższe wskazówki opisują sposoby optymalizacji skuteczności autouzupełniania miejsc:

Dodaj do implementacji autouzupełniania miejsc ograniczenia związane z krajem, promowaniem lokalizacji i ustawienia języka (w przypadku implementacji zautomatyzowanych). Widżety nie wymagają wyboru języka, ponieważ są one wybierane w przeglądarce lub na urządzeniu mobilnym użytkownika.
Jeśli autouzupełnianie miejsc towarzyszy mapie, możesz odchylać lokalizację według widocznego obszaru mapy.
Jeśli użytkownik nie wybierze jednego z podpowiedzi autouzupełniania, zwykle dlatego, że żadne z nich nie jest pożądanym adresem wyniku, możesz ponownie wykorzystać pierwotne dane wejściowe, aby uzyskać trafniejsze wyniki:
- Jeśli oczekujesz, że użytkownik będzie podawać tylko informacje adresowe, użyj tych samych danych w wywołaniu Geocoding API.
- Jeśli spodziewasz się, że użytkownik będzie wpisywać zapytanie o konkretne miejsce, podając jego nazwę lub adres, skorzystaj z funkcji Znajdź prośbę o miejsce. Jeśli wyniki są oczekiwane tylko w konkretnym regionie, użyj promowania lokalizacji.
Inne scenariusze, w których warto wrócić do interfejsu Geocoding API, to między innymi:
- Użytkownicy podający adresy podrzędne w krajach, w których autouzupełnianie miejsc nie obsługuje adresów podrzędnych, np. w Czechach, Estonii i Litwie. Na przykład czeski adres „Stroupežnického 3191/17, Praha” generuje częściowe podpowiedzi w funkcji autouzupełniania miejsc.
- Użytkownicy wpisują adresy z prefiksem segmentu drogi, np. „23-30 29th St, Queens” w Nowym Jorku lub „47-380 Kamehameha Hwy, Kaneohe” na wyspie Kauai na Hawai.

Rozwiązywanie problemów

Chociaż może występować wiele różnych błędów, większość błędów występujących w aplikacji jest zwykle spowodowanych przez błędy w konfiguracji (np. użyto niewłaściwego klucza interfejsu API lub nieprawidłowo skonfigurowany klucz interfejsu API) albo błędy limitu (aplikacja przekroczyła limit). Więcej informacji o limitach znajdziesz w artykule Limity wykorzystania.

Błędy występujące podczas korzystania z elementów sterujących autouzupełniania są zwracane w metodzie didFailAutocompleteWithError() różnych protokołów delegacji. Właściwość code podanego obiektu NSError jest ustawiona na jedną z wartości wyliczenia GMSPlacesErrorCode.

Autouzupełnianie miejsc

Dodawanie elementu sterującego interfejsu autouzupełniania

Dodawanie elementu sterującego pełnoekranowym

Swift

Objective-C

Dodawanie kontrolera wyników

Dodawanie paska wyszukiwania do paska nawigacyjnego

Swift

Objective-C

Dodawanie paska wyszukiwania u góry widoku

Swift

Objective-C

Swift

Objective-C

Dodawanie paska wyszukiwania z wykorzystaniem wyników wyświetlanych w wyskakujących okienkach

Swift

Objective-C

Korzystanie ze źródła danych tabeli

Swift

Objective-C

Dostosowywanie kolorów tekstu i tła

Korzystanie z protokołu UIVisual

Ustawianie właściwości stylu elementów sterujących interfejsu

Automatyczne uzyskiwanie prognoz dotyczących miejsc

Dzwonię do: GMSPlacesClient findAutocompletePredictionsFromQuery:

Swift

Objective-C

Swift

Objective-C

Korzystanie z modułu pobierania

Swift

Objective-C

Tokeny sesji

Limity wykorzystania

Wyświetlanie atrybucji w aplikacji

Sterowanie wskaźnikiem aktywności sieci

Ograniczanie wyników autouzupełniania

Uprzedzenia w konkretnym regionie

Ograniczanie wyników do konkretnego regionu

Filtrowanie wyników według kraju

Filtrowanie wyników według typu miejsca lub kolekcji typów

Optymalizacja autouzupełniania miejsc

Sprawdzone metody optymalizacji kosztów

Podstawowa optymalizacja kosztów

Zaawansowana optymalizacja kosztów

Tak, potrzebuję więcej szczegółów

Nie, potrzebuje tylko adresu i lokalizacji

Tak

Nie

Sprawdzone metody zwiększania skuteczności

Rozwiązywanie problemów

Dzwonię do: `GMSPlacesClient findAutocompletePredictionsFromQuery:`