Autouzupełnianie miejsc

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

Autouzupełnianie w aplikacji możesz włączyć na kilka sposobów:

• Dodaj do interfejsu element sterujący autouzupełniania, aby skrócić czas programowania i zapewnić spójne wrażenia użytkownika.
• Automatyczne pobieranie prognoz miejsc pozwala dostosować usługi do potrzeb użytkowników.

Dodawanie elementu sterującego interfejsu autouzupełniania

Element sterujący autouzupełniania w interfejsie to okno wyszukiwania z wbudowaną funkcją autouzupełniania. Gdy użytkownik wpisuje wyszukiwane słowa, element sterujący powoduje wyświetlenie listy przewidywanych miejsc do wyboru. Gdy użytkownik dokona wyboru, zwracane jest wystąpienie GMSPlace, za pomocą którego aplikacja może uzyskać informacje o wybranym miejscu.

Element sterujący autouzupełniania możesz dodać do aplikacji na te sposoby:

• Dodawanie elementu sterującego na pełnym ekranie
• Dodawanie kontrolera wyników
• Używanie źródła danych tabeli

Dodawanie elementu sterującego pełnoekranowego

Używaj elementu sterującego pełnego ekranu, jeśli chcesz uzyskać kontekst modalny – interfejs autouzupełniania tymczasowo zastępuje UI aplikacji do momentu dokonania wyboru przez użytkownika. Ta funkcja jest udostępniana przez klasę GMSAutocompleteViewController. Gdy użytkownik wybierze miejsce, do aplikacji zostanie oddzwonione.

Aby dodać do aplikacji element sterujący na pełnym ekranie:

1. Utwórz element interfejsu w głównej aplikacji, aby uruchomić element sterujący autouzupełniania, np. moduł obsługi dotyku w UIButton.
2. Zaimplementuj protokół GMSAutocompleteViewControllerDelegate w kontrolerze widoku nadrzędnego.
3. Utwórz instancję GMSAutocompleteViewController i przypisz nadrzędny kontroler widoku danych jako właściwość delegata.
4. Utwórz GMSPlaceField, aby określić typy danych miejsc, które mają być zwracane.
5. Dodaj GMSAutocompleteFilter, by ograniczyć zapytanie do określonego typu miejsca.
6. Prezentuj GMSAutocompleteViewController za pomocą [self presentViewController...].
7. Zmień wybór użytkownika w metodzie przekazywania dostępu didAutocompleteWithPlace.
8. Zamknij kontroler w metodach didAutocompleteWithPlace, didFailAutocompleteWithError i wasCancelled.

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

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
  }

}

#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 w zależności od fokusu interfejsu wejściowego.

Aby dodać kontroler wyników do aplikacji:

1. Utwórz GMSAutocompleteResultsViewController.
2. Zaimplementuj protokół GMSAutocompleteResultsViewControllerDelegate w kontrolerze widoku nadrzędnego i przypisz nadrzędny kontroler widoku jako właściwość delegowania.
3. Utwórz obiekt UISearchController, przekazując GMSAutocompleteResultsViewController jako argument kontrolera wyników.
4. Ustaw GMSAutocompleteResultsViewController jako właściwość searchResultsUpdater elementu UISearchController.
5. Dodaj do interfejsu aplikacji: searchBar dla: UISearchController.
6. Zmień wybór 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 na górze widoku
• Dodawanie paska wyszukiwania z wykorzystaniem wyników w wyskakującym okienku

Dodawanie paska wyszukiwania do paska nawigacyjnego

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

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

- (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 na górze widoku

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

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

- (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 wyłączyć). Jeśli pasek nawigacyjny jest widoczny i nieprzezroczysty, UISearchController nieprawidłowo ustawia miejsce docelowe.

Aby obejść ten problem, użyj następującego kodu:

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

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;

Dodawanie paska wyszukiwania z wykorzystaniem wyników w wyskakującym okienku

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

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

- (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 wyświetlić widok tabeli, który wyświetla wyniki na kontrolerze widoków.

Aby używać GMSAutocompleteTableDataSource jako źródła danych i przekazywać UITableView w kontrolerze widoków danych:

1. Zaimplementuj protokoły GMSAutocompleteTableDataSourceDelegate i UISearchBarDelegate w kontrolerze widoków.
2. Utwórz instancję GMSAutocompleteTableDataSource i przypisz kontroler widoku danych jako właściwość delegata.
3. Ustaw GMSAutocompleteTableDataSource jako źródło danych i przekaż właściwości instancji UITableView na kontrolerze widoków.
4. W module obsługi wpisywania wyszukiwanego tekstu wywołaj sourceTextHasChanged w żądaniu GMSAutocompleteTableDataSource.
5. Zmień wybór użytkownika w metodzie przekazywania dostępu didAutocompleteWithPlace.
6. Zamknij kontroler w metodach przekazywania dostępu didAutocompleteWithPlace, didFailAutocompleteWithError i wasCancelled.

W poniższym przykładzie kodu pokazano użycie klasy GMSAutocompleteTableDataSource do sterowania widokiem tabeli w UIViewController, gdy element UISearchBar zostanie dodany oddzielnie.

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

      

// 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

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

• Przez używanie natywnego protokołu UI Wygląd na iOS, aby w miarę możliwości stosować globalne style elementów interfejsu. Te ustawienia dotyczą wielu elementów sterujących interfejsu, ale nie wszystkich.
• Za pomocą metod pakietu SDK dostępnych w klasach widżetu do ustawiania właściwości, które nie są obsługiwane przez protokół UI Pojawi się.

Zwykle aplikacja korzysta z pewnej kombinacji metod protokołu UIPerspective i pakietu SDK. Ten diagram pokazuje, do których elementów można dodać styl:

W tabeli poniżej znajdziesz listę wszystkich elementów interfejsu wraz z informacjami o sposobie ich stylu (protokół UIinterfejs lub metoda SDK).

Korzystanie z protokołu UIPreview

Aby uzyskać serwer proxy wyglądu dla danego elementu interfejsu, możesz użyć protokołu UIVisual, a potem 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, jeśli zawierają one element UISearchBar:

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

Więcej informacji o definiowaniu wartości kolorów znajdziesz w dokumentacji klasy UIColor.

Poniższe fragmenty kodu pokazują wszystkie polecenia serwera proxy, których należy używać do zmiany stylu wszystkich elementów w interfejsie autouzupełniania na pełnym ekranie. 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 użytkownika ma właściwości, na które protokół UIPreview nie ma wpływu, dlatego 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 kontroli interfejsu o nazwie acController. Dodaj ten kod do metody onLaunchClicked w narzędziu 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

Jako alternatywę dla interfejsu udostępnianego przez widżet autouzupełniania możesz utworzyć niestandardowy interfejs wyszukiwania. Aby było to możliwe, aplikacja musi automatycznie uzyskiwać prognozy miejsc. Aplikacja może pobrać listę przewidywanych nazw miejsc lub adresów na jeden z tych sposobów:

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

Dzwonię do: GMSPlacesClient findAutocompletePredictionsFromQuery:

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

• Ciąg 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:
  • Promowanie stronniczości lub ograniczanie wyników do konkretnego regionu.
  • Ogranicz wyniki do określonego typu miejsca.
  • Obiekt GMSPlaceLocationBias/ograniczenie promujący wyniki do konkretnego obszaru określonego 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:.

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

/**
 * 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 formacie NSAttributedString. np. „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, na przykład w podany niżej sposób.
• placeID – identyfikator prognozowanego miejsca. Identyfikator miejsca to identyfikator tekstowy, który jednoznacznie identyfikuje miejsce. Więcej informacji na temat identyfikatorów miejsc znajdziesz w artykule Omówienie identyfikatora miejsca.
• 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.

W podanym niżej przykładzie kodu widać, jak za pomocą funkcji enumerateAttribute wyróżniać pogrubioną czcionką te części wyniku, które pasują do tekstu w zapytaniu użytkownika:

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
    

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ć narzędzia GMSAutocompleteFetcher, które opakowuje metodę autocompleteQuery w GMSPlacesClient. Moduł pobierania ogranicza żądania i zwraca tylko wyniki dotyczące ostatnio wpisanego wyszukiwanego tekstu. Nie zawiera elementów interfejsu.

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

1. Zaimplementuj protokół GMSAutocompleteFetcherDelegate.
2. Utwórz obiekt GMSAutocompleteFetcher.
3. Wywołuj metodę sourceTextHasChanged w module pobierania podczas pisania przez użytkownika.
4. Obsługuj prognozy i błędy za pomocą metod protokołów didAutcompleteWithPredictions i didFailAutocompleteWithError.

W poniższym przykładzie kodu pokazano, jak używać modułu pobierania do pobierania danych wejściowych użytkownika i wyświetlania dopasowań miejsc w widoku tekstu. Funkcja wyboru miejsca została pominięta. FetcherSampleViewController pochodzi z elementu UIViewController w pliku FetcherSampleViewController.h.

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

#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 autouzupełniania wyszukiwania użytkownika w oddzielną sesję na potrzeby płatności. Sesja rozpoczyna się, gdy użytkownik zaczyna wpisywać zapytanie, a kończy się, gdy wybiera miejsce. Każda sesja może obejmować wiele zapytań, po których następuje wybór jednego miejsca. Po zakończeniu sesji token traci ważność. Aplikacja musi wygenerować nowy token dla każdej sesji. Zalecamy używanie tokenów sesji we wszystkich automatycznych sesjach autouzupełniania (jeśli używasz kontrolera pełnoekranowego lub kontrolera wyników, interfejs API dba o to automatycznie).

Pakiet Miejsc SDK na iOS używa do identyfikowania każdej sesji elementu GMSAutocompleteSessionToken. Na początku każdej nowej sesji aplikacja powinna przekazywać nowy token sesji. Następnie w kolejnym wywołaniu do fetchPlacefromPlaceID: przekazuje ten sam token razem z identyfikatorem miejsca, 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

• Korzystanie z metody GMSPlacesClient findAutocompletePredictionsFromQuery podlega zróżnicowanym limitom zapytań. Zapoznaj się z dokumentacją limitów wykorzystania.

Wyświetlanie atrybucji w aplikacji

• Jeśli Twoja aplikacja automatycznie korzysta z usługi autouzupełniania, interfejs użytkownika musi wyświetlać informację „Technologia Google” lub pojawiać się na mapie z logo Google.
• Jeśli Twoja aplikacja korzysta z opcji interfejsu autouzupełniania, nie musisz podejmować żadnych dodatkowych działań (wymagane źródło danych jest wyświetlane domyślnie).
• Jeśli po uzyskaniu miejsca za pomocą identyfikatora pobierasz i wyświetlasz dodatkowe informacje o miejscu, musisz też wyświetlać informacje o atrybucji pochodzące od firm zewnętrznych.

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 klasy autouzupełniania, której używasz, oraz samodzielnie włączyć lub 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:.

Dzięki zaimplementowaniu tych metod i ustawieniu [UIApplication sharedApplication].networkActivityIndicatorVisible odpowiednio na YES i NO pasek stanu będzie poprawnie odpowiadać interfejsowi 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 lub kilku typów miejsc bądź konkretnego kraju bądź 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 ustawiona jest też wartość locationRestriction, zasada locationBias jest ignorowana.

• Aby wyświetlać tylko (ograniczać) wyniki w zdefiniowanym regionie, ustaw locationRestriction w GMSAutocompleteFilter (zostaną zwrócone tylko wyniki ze wskazanego regionu).

  • Uwaga: to ograniczenie dotyczy tylko całych tras. Wyniki syntetyczne znajdujące się poza prostokątnymi granicami mogą być zwracane dla trasy, która pokrywa się z ograniczeniem.

• Aby wyświetlić tylko wyniki zgodne z określonym typem miejsca, ustaw types w GMSAutocompleteFilter (na przykład wprowadzenie wartości TypeFilter.ADDRESS spowoduje, że widżet zwróci tylko wyniki z dokładnym adresem).

• Aby zwracać tylko wyniki z maksymalnie 5 określonych krajów, w polu GMSAutocompleteFilter ustaw countries.

Wyniki stronnicze wobec określonego regionu

Aby preferować (odchylenia) 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 określonego regionu

Aby wyświetlać (ograniczać) wyniki tylko w określonym regionie, ustaw locationRestriction w 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 określonych krajów, ustaw countries w GMSAutocompleteFilter, jak w tym przykładzie:

  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 za pomocą właściwości types GMSAutoCompleteFilter. Ta właściwość pozwala określić filtry typów miejsc wymienione w tabelach 1, 2 i 3. Jeśli nic nie zostanie określone, zwracane będą wszystkie typy.

Aby określić typ lub filtr kolekcji typu:

• Użyj właściwości types, aby określić do 5 wartości type z tabel 1 i 2 typów 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 widocznej w typach miejsc. Wartości zbioru typu 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 polu GMSAutocompleteFilter ustaw types. Z przykładu poniżej dowiesz się, jak skonfigurować filtr, aby zwracał tylko wyniki z dokładnym adresem:

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

Optymalizacja autouzupełniania miejsc

W tej sekcji opisujemy sprawdzone metody, 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 użytkownika jest użycie widżetu autouzupełniania interfejsu Maps JavaScript API, widżetu autouzupełniania w pakiecie Miejsca SDK na Androida lub elementu autouzupełniania w interfejsie pakietu Miejsca SDK na iOS.
• Opanuj od razu najważniejsze pola danych autouzupełniania miejsc.
• Pola odchyleń dotyczących lokalizacji i ograniczeń dotyczących lokalizacji są opcjonalne, ale mogą mieć znaczny wpływ na działanie autouzupełniania.
• Skorzystaj z obsługi błędów, by zapewnić płynne działanie aplikacji, gdy interfejs API zwróci błąd.
• Zadbaj o to, aby aplikacja obsługiwała aplikację, gdy nie ma możliwości wyboru, i umożliwiała użytkownikom kontynuowanie pracy.

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 widżetach Szczegóły miejsca i Autouzupełnianie miejsc, aby zwracać tylko potrzebne pola danych miejsc.

Zaawansowana optymalizacja kosztów

Rozważ automatyczną implementację autouzupełniania miejsc, aby mieć dostęp do oceny według żądania i wysyłać prośby o wyniki interfejsu Geocoding API dotyczące wybranego miejsca, a nie szczegółów miejsca. Ceny za żądanie w połączeniu z interfejsem Geocoding API są bardziej opłacalne niż model cenowy na sesję (na podstawie sesji), jeśli są spełnione oba poniższe warunki:

• Jeśli potrzebujesz tylko szerokości/długości geograficznej lub adresu wybranego miejsca przez użytkownika, interfejs Geocoding API dostarcza te informacje dla mniej niż wywołania Place Details.
• Jeśli użytkownicy wybiorą prognozę autouzupełniania średnio w ciągu maksymalnie 4 żądań podpowiedzi autouzupełniania, cena za żądanie może być bardziej opłacalna niż stawka za sesję.

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

Sprawdzone metody

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

• Dodaj do implementacji autouzupełniania miejsca ograniczenia związane z krajem, promowaniem lokalizacji i (w przypadku implementacji zautomatyzowanych) ustawienia języka. Widżety nie wymagają wyboru języka, ponieważ ustawienia języka są wybierane w przeglądarce i na urządzeniu mobilnym użytkownika.
• Jeśli autouzupełnianiem miejsc towarzyszy mapa, możesz orientować lokalizację w zależności od widocznego obszaru mapy.
• W sytuacjach, gdy użytkownik nie wybierze jednej z podpowiedzi autouzupełniania (zwykle jest to spowodowane tym, że żadne z nich nie jest pożądanym adresem wyniku), możesz użyć oryginalnych danych wejściowych użytkownika, aby uzyskać trafniejsze wyniki:
  • Jeśli oczekujesz, że użytkownik będzie podawać tylko informacje adresowe, w wywołaniu Geocoding API użyj tych samych danych.
  • Jeśli oczekujesz, że użytkownik będzie wpisywać zapytania dotyczące konkretnego miejsca, podając jego nazwę lub adres, skorzystaj z funkcji Znajdź prośbę o miejsce. Jeśli wyniki są oczekiwane tylko w określonym regionie, użyj promowania lokalizacji.
  Inne scenariusze, w których warto wrócić do interfejsu Geocoding API:
  • Użytkownicy wpisują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” zwraca częściową prognozę miejsca w autouzupełnianiu miejsc.
  • Użytkownicy wpisują adresy z prefiksem segmentu drogi, takim jak „23-30 29th St, Queens” w Nowym Jorku lub „47-380 Kamehameha, Kaneohe” na wyspie Kauai na Hawai'i.

Rozwiązywanie problemów

Chociaż może wystąpić wiele różnych błędów, większość z nich jest prawdopodobnie spowodowanych przez błędy w konfiguracji (np. użyto niewłaściwego klucza interfejsu API lub nieprawidłowo skonfigurowano klucz interfejsu API) albo błędy w limitach (aplikacja przekroczyła limit). Więcej informacji o limitach znajdziesz w sekcji Limity wykorzystania.

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