Place Autocomplete

iOS için Yerler SDK'sındaki otomatik tamamlama hizmeti, kullanıcı arama sorgularına yanıt olarak yer tahminlerini döndürür. Kullanıcı yazarken otomatik tamamlama hizmeti işletmeler, adresler, artı kodları ve önemli yerler gibi yerler için öneriler sunar.

Otomatik tamamlama özelliğini uygulamanıza aşağıdaki şekillerde ekleyebilirsiniz:

• Geliştirme zamanından tasarruf etmek ve tutarlı bir kullanıcı deneyimi sağlamak için otomatik tamamlama kullanıcı arayüzü denetimi ekleyin.
• Özelleştirilmiş bir kullanıcı deneyimi oluşturmak için yer tahminlerini programatik olarak alın.

Otomatik tamamlama kullanıcı arayüzü kontrolü ekleme

Otomatik tamamlama kullanıcı arayüzü kontrolü, yerleşik otomatik tamamlama işlevine sahip bir arama iletişim kutusudur. Kullanıcı arama terimlerini girdikçe kontrol, seçim yapılacak tahmini yerlerin listesini sunar. Kullanıcı bir seçim yaptığında, uygulamanızın seçili yer hakkındaki ayrıntıları almak için kullanabileceği bir GMSPlace örneği döndürülür.

Otomatik tamamlama kullanıcı arayüzü kontrolünü uygulamanıza aşağıdaki şekillerde ekleyebilirsiniz:

• Tam ekran kontrolü ekleme
• Sonuç denetleyici ekleyin
• Tablo veri kaynağını kullanma

Tam ekran kontrolü ekleme

Kalıcı bir bağlam istediğinizde tam ekran kontrolünü kullanın. Bu seçenekte, kullanıcı seçimi yapana kadar otomatik tamamlama kullanıcı arayüzü geçici olarak uygulamanızın kullanıcı arayüzünün yerini alır. Bu işlev GMSAutocompleteViewController sınıfı tarafından sağlanır. Kullanıcı bir yer seçtiğinde uygulamanız geri çağırma alır.

Uygulamanıza tam ekran denetimi eklemek için:

1. Otomatik tamamlama kullanıcı arayüzü kontrolünü (örneğin, bir UIButton üzerinde dokunma işleyicisi) başlatmak için ana uygulamanızda bir kullanıcı arayüzü öğesi oluşturun.
2. Üst görünüm denetleyicisinde GMSAutocompleteViewControllerDelegate protokolünü uygulayın.
3. Bir GMSAutocompleteViewController örneği oluşturun ve üst görünüm denetleyicisini yetki verilen mülk olarak atayın.
4. Döndürülecek yer veri türlerini tanımlamak için bir GMSPlaceField oluşturun.
5. Sorguyu belirli bir yer türüyle sınırlandırmak için GMSAutocompleteFilter ekleyin.
6. [self presentViewController...] kullanarak GMSAutocompleteViewController öğesini gösterin.
7. didAutocompleteWithPlace seçimi yönteminde kullanıcının seçimini yönetin.
8. didAutocompleteWithPlace, didFailAutocompleteWithError ve wasCancelled yetki yöntemlerinde kumandayı kapatın.

Aşağıdaki örnekte, bir düğmeye dokunan kullanıcıya yanıt olarak GMSAutocompleteViewController'i başlatmanın olası bir yolu gösterilmektedir.

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

Sonuç denetleyicisi ekleme

Metin giriş kullanıcı arayüzü üzerinde daha fazla kontrol sahibi olmak istiyorsanız sonuç denetleyicisi kullanın. Sonuç denetleyicisi, giriş kullanıcı arayüzü odağına göre sonuç listesinin görünürlüğünü dinamik şekilde açar.

Uygulamanıza sonuç denetleyicisi eklemek için:

1. GMSAutocompleteResultsViewController oluşturun.
2. Üst görünüm denetleyicide GMSAutocompleteResultsViewControllerDelegate protokolünü uygulayın ve üst görünüm denetleyiciyi yetki verme özelliği olarak atayın.
3. UISearchController nesnesi oluşturun ve GMSAutocompleteResultsViewController'i sonuç denetleyicisi bağımsız değişkeni olarak iletin.
4. GMSAutocompleteResultsViewController öğesini UISearchController için searchResultsUpdater özelliği olarak ayarlayın.
5. UISearchController için searchBar özelliğini uygulamanızın kullanıcı arayüzüne ekleyin.
6. didAutocompleteWithPlace seçimi yönteminde kullanıcının seçimini yönetin.

UISearchController uygulamasının arama çubuğunu uygulamanızın kullanıcı arayüzüne yerleştirmenin birkaç yolu vardır:

• Gezinme çubuğuna arama çubuğu ekleyin
• Görünümün üst kısmına arama çubuğu ekleme
• Pop-up sonuçlarını kullanarak arama çubuğu ekleme

Gezinme çubuğuna arama çubuğu ekleme

Aşağıdaki kod örneğinde sonuç denetleyicisi eklenme, gezinme çubuğuna searchBar ekleme ve kullanıcının seçimini işleme gösterilmiştir:

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

Görünümün üst kısmına arama çubuğu ekleme

Aşağıdaki kod örneği, searchBar'nin bir görünümün üst kısmına eklenmesini göstermektedir.

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

Varsayılan olarak, UISearchController sunum sırasında gezinme çubuğunu gizler (devre dışı bırakılabilir). Gezinme çubuğunun görünür ve opak olduğu durumlarda UISearchController, yerleşimi doğru şekilde ayarlamaz.

Geçici çözüm olarak aşağıdaki kodu kullanın:

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;

Pop-up sonuçları kullanarak arama çubuğu ekleme

Aşağıdaki kod örneği, gezinme çubuğunun sağ tarafına arama çubuğu yerleştirmeyi ve sonuçları bir pop-up'ta görüntülemeyi göstermektedir.

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

Tablo veri kaynağını kullanma

Uygulamanızın özel bir arama metni kullanıcı arayüzü varsa sonuçları görüntüleme denetleyicisinde gösteren tablo görünümünü yönlendirmek için GMSAutocompleteTableDataSource sınıfını kullanabilirsiniz.

Bir görünüm denetleyicide veri kaynağı ve UITableView yetkisini GMSAutocompleteTableDataSource olarak kullanmak için:

1. Görünüm denetleyicide GMSAutocompleteTableDataSourceDelegate ve UISearchBarDelegate protokollerini uygulayın.
2. Bir GMSAutocompleteTableDataSource örneği oluşturun ve görünüm denetleyiciyi yetki verilen mülk olarak atayın.
3. Görünüm denetleyicide UITableView örneğinin veri kaynağı ve yetki verme özellikleri olarak GMSAutocompleteTableDataSource değerini ayarlayın.
4. Arama metni girişi için işleyicide GMSAutocompleteTableDataSource üzerinden sourceTextHasChanged numarasını arayın.
5. didAutocompleteWithPlace yetki verme yönteminde kullanıcının seçimini yönetin.
6. didAutocompleteWithPlace, didFailAutocompleteWithError ve wasCancelled yetki verilen kumandada kumandayı kapatın.

Aşağıdaki kod örneği, UISearchBar ayrı olarak eklendiğinde UIViewController öğesinin tablo görünümünü artırmak için GMSAutocompleteTableDataSource sınıfının kullanılmasını göstermektedir.

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

      

Metin ve arka plan renklerini özelleştirme

Widget'ın uygulamanızın görsel görünümüyle daha yakından eşleşmesini sağlamak için tüm metin ve arka planların renklerini otomatik tamamlama kullanıcı arayüzü kontrolünde ayarlayabilirsiniz. Kullanıcı arayüzü kontrol renklerini ayarlamanın iki yolu vardır:

• Mümkün olduğunda kullanıcı arayüzü kontrollerini genel olarak şekillendirmek için yerel iOS UIGörünüm protokolü kullanılarak. Bu ayarlar, kullanıcı arayüzü kontrol öğelerinin hepsi için değil, birçoğu için geçerlidir.
• UIView protokolü tarafından desteklenmeyen özellikleri ayarlamak için widget sınıflarındaki SDK yöntemlerini kullanarak.

Uygulamanız genellikle UIView protokolü ile SDK yöntemlerinin bir kombinasyonunu kullanır. Aşağıdaki şemada, hangi öğelerin stilinin ayarlanabileceği gösterilmiştir:

Aşağıdaki tabloda tüm kullanıcı arayüzü öğeleri listelenmiştir ve her birinde nasıl stil oluşturulacağı (kullanıcı arayüzü protokolü veya SDK yöntemi) gösterilmektedir.

UIView protokolünü kullanma

Belirli bir kullanıcı arayüzü öğesine ait görünüm proxy'sini almak için kullanıcı arayüzü protokolünü kullanabilirsiniz. Daha sonra bu arayüzü kullanarak kullanıcı arayüzü öğesinin rengini ayarlayabilirsiniz. Değişiklik yapıldığında, belirli bir kullanıcı arayüzü öğesinin tüm örnekleri etkilenir. Örneğin, aşağıdaki örnek global olarak UITextField sınıflarının metin rengini, bir UISearchBar içerdiğinde yeşil olarak değiştirir:

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

Renk değerlerini tanımlama hakkında daha fazla bilgi için UIColor Sınıf Referansı'na bakın.

Aşağıdaki kod snippet'leri, tam ekran otomatik tamamlama kullanıcı arayüzü kontrolündeki her şeyi biçimlendirmek için kullanmanız gereken tüm proxy komutlarını gösterir. Bu kodu Appdelegate.m'deki didFinishLaunchingWithOptions yöntemine ekleyin:

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

Kullanıcı arayüzü kontrol stili özelliklerini ayarlama

Kullanıcı arayüzü kontrol öğelerinin bir alt kümesi, Kullanıcı Arayüzü Protokolü'nden etkilenmeyen özellikler içerdiğinden doğrudan ayarlanmalıdır. Aşağıdaki kod örneği, ön plan ve arka plan renklerini tanımlayıp bunları acController adlı bir kullanıcı arayüzü kontrol örneğine uygulamayı göstermektedir. Bu kodu ViewController.m içindeki onLaunchClicked yöntemine ekleyin:

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;

Programatik olarak yer tahminleri alma

Otomatik tamamlama widget'ının sağladığı kullanıcı arayüzüne alternatif olarak bir özel arama kullanıcı arayüzü oluşturabilirsiniz. Bunu yapmak için uygulamanızın yer tahminlerini programatik olarak alması gerekir. Uygulamanız aşağıdaki yöntemlerden birini kullanarak tahmin edilen yer adlarının ve/veya adreslerin listesini alabilir:

• GMSPlacesClient findAutocompletePredictionsFromQuery: numaralı telefonu arayın
• Alıcıyı kullanma

GMSPlacesClient findAutocompletePredictionsFromQuery: aranıyor

Tahmin edilen yer adlarının ve/veya adreslerin listesini almak için önce GMSPlacesClient yöntemini çalıştırın, ardından aşağıdaki parametrelerle GMSPlacesClient findAutocompletePredictionsFromQuery: yöntemini çağırın:

• Kullanıcı tarafından yazılan metni içeren bir autocompleteQuery dizesi.
• Her bir oturumu tanımlamak için kullanılan GMSAutocompleteSessionToken. Uygulamanız, kullanıcı tarafından seçilen yerin Yer Ayrıntılarını almak için her otomatik tamamlama isteği çağrısında aynı jetonu, ardından bir fetchPlacefromPlaceID: çağrısında Yer Kimliği ile birlikte iletmelidir.
• Aşağıdaki işlemleri yapmak için bir GMSAutocompleteFilter:
  • Sonuçları taraflı hale getirin veya belirli bir bölgeyle sınırlayın.
  • Sonuçları belirli bir yer türüyle sınırlandırın.
  • Enlem ve boylam sınırlarıyla belirtilen belirli bir alana göre ağırlık veren GMSPlaceLocationBias/Kısıtlama nesnesi.
• Döndürülen tahminleri işlemek için geri çağırma yöntemi.

Aşağıdaki kod örnekleri findAutocompletePredictionsFromQuery: çağrısını göstermektedir.

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

API, bir dizi GMSAutocompletePrediction nesnesiyle geçirerek belirtilen geri çağırma yöntemini çağırır.

Her GMSAutocompletePrediction nesnesi aşağıdaki bilgileri içerir:

• attributedFullText – Tahmini tam metin olarak NSAttributedString biçiminde sunulur. Örneğin, "Sidney Opera Binası, Sidney, New South Waales, Avustralya". Kullanıcı girişiyle eşleşen her metin aralığının bir özelliği (kGMSAutocompleteMatchAttribute) vardır. Bu özelliği, kullanıcının sorgusuyla eşleşen metni (örneğin, aşağıda gösterildiği gibi) vurgulamak için kullanabilirsiniz.
• placeID – Tahmin edilen yerin yer kimliği. Yer kimliği, bir yeri benzersiz şekilde tanımlayan metin tanımlayıcısıdır. Yer kimlikleri hakkında daha fazla bilgi için Yer kimliğine genel bakış konusuna bakın.
• distanceMeters – Belirtilen origin ile varış noktası arasındaki düz çizgi mesafesi. origin özelliği ayarlanmazsa mesafe değeri döndürülmez.

Aşağıdaki kod örneği, kullanıcının sorgusunda sonuçla eşleşen kısmın enumerateAttribute kullanılarak kalın metinle nasıl vurgulanacağını gösterir:

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;
    

Getirme aracını kullanma

Kendi otomatik tamamlama kontrolünüzü sıfırdan oluşturmak istiyorsanız autocompleteQuery yöntemini GMSPlacesClient üzerinde sarmalayan GMSAutocompleteFetcher aracını kullanabilirsiniz. Getirme, istekleri kısıtlayıp yalnızca en son girilen arama metniyle ilgili sonuçları döndürür. Kullanıcı arayüzü öğesi sağlamaz.

GMSAutocompleteFetcher aracını uygulamak için aşağıdaki adımları uygulayın:

1. GMSAutocompleteFetcherDelegate protokolünü uygulayın.
2. Bir GMSAutocompleteFetcher nesnesi oluşturun.
3. Kullanıcı yazarken alıcıda sourceTextHasChanged adlı kişiyi arayın.
4. Tahminleri ve hataları yönetmek için didAutcompleteWithPredictions ve didFailAutocompleteWithError protokol yöntemlerini kullanın.

Aşağıdaki kod örneği, metin girişini kullanarak kullanıcı girdisini almak ve yer eşleşmelerini göstermek için getirme aracını kullanmayı göstermektedir. Yer seçme işlevi artık kullanılamamaktadır. FetcherSampleViewController, FetcherSampleViewController.h'deki UIViewController kaynağından türetilir.

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

Oturum jetonları

Oturum jetonları, bir kullanıcı otomatik tamamlama sorgusunun sorgu ve seçim aşamalarını faturalandırma amacıyla ayrı bir oturumda gruplandırır. Oturum, kullanıcı bir sorgu yazmaya başladığında başlar ve bir yer seçildiğinde sona erer. Her oturumda birden fazla sorgu ve ardından tek bir yer seçimi olabilir. Oturum sona erdiğinde jeton artık geçerli olmaz. Uygulamanız her oturum için yeni bir jeton oluşturmalıdır. Tüm programatik otomatik tamamlama oturumları için oturum jetonlarını kullanmanızı öneririz (tam ekran denetleyiciyi veya sonuç denetleyicisini kullandığınızda API bu işlemi otomatik olarak gerçekleştirir).

iOS için Yerler SDK'sı, her oturumu tanımlamak için GMSAutocompleteSessionToken kullanır. Uygulamanız her yeni oturuma başladığında yeni bir oturum jetonu iletmeli, ardından kullanıcı tarafından seçilen yerin Yer Ayrıntılarını almak için sonraki çağrıda fetchPlacefromPlaceID: çağrısıyla aynı jetonu iletmelidir.

Oturum jetonları hakkında daha fazla bilgi edinin.

Yeni bir oturum jetonu oluşturmak için aşağıdaki kodu kullanın:

let token: GMSAutocompleteSessionToken = GMSAutocompleteSessionToken.init()

Kullanım sınırları

• GMSPlacesClient findAutocompletePredictionsFromQuery yönteminin kullanımı, katmanlı sorgu sınırlarına tabidir. Kullanım sınırları ile ilgili belgelere bakın.

İlişkilendirmeleri uygulamanızda gösterme

• Uygulamanız otomatik olarak otomatik tamamlama hizmetini kullanıyorsa kullanıcı arayüzünüz "Google tarafından desteklenmektedir" ilişkilendirmesi görüntülemeli veya Google markalı bir harita içinde görünmelidir.
• Uygulamanız otomatik tamamlama kullanıcı arayüzü kontrolünü kullanıyorsa ek bir işleme gerek yoktur (varsayılan olarak gerekli ilişkilendirme görüntülenir).
• Yere göre kimlik aldıktan sonra ek yer bilgileri alıp gösterirseniz, üçüncü taraf atıflarını da göstermeniz gerekir.

Daha fazla ayrıntı için ilişkilendirmelere ilişkin belgeleri inceleyin.

Ağ etkinliği göstergesini kontrol etme

Uygulama durum çubuğundaki ağ etkinliği göstergesini kontrol etmek için, kullandığınız otomatik tamamlama sınıfı için uygun isteğe bağlı yetki verme yöntemlerini uygulamanız ve ağ göstergesini kendiniz etkinleştirip devre dışı bırakmanız gerekir.

• GMSAutocompleteViewController için didRequestAutocompletePredictions: ve didUpdateAutocompletePredictions: yetki verme yöntemlerini uygulamanız gerekir.
• GMSAutocompleteResultsViewController için didRequestAutocompletePredictionsForResultsController: ve didUpdateAutocompletePredictionsForResultsController: yetki verme yöntemlerini uygulamanız gerekir.
• GMSAutocompleteTableDataSource için didRequestAutocompletePredictionsForTableDataSource: ve didUpdateAutocompletePredictionsForTableDataSource: yetki verme yöntemlerini uygulamanız gerekir.

Bu yöntemleri uygulayıp [UIApplication sharedApplication].networkActivityIndicatorVisible özelliğini sırasıyla YES ve NO olarak ayarladığınızda, durum çubuğu otomatik tamamlama kullanıcı arayüzüyle doğru şekilde eşleşir.

Otomatik tamamlama sonuçlarını kısıtla

Otomatik tamamlama kullanıcı arayüzü kontrolünü, sonuçları belirli bir coğrafi bölgeyle sınırlayacak şekilde ayarlayabilir ve/veya sonuçları bir ya da daha fazla yer türüne veya belirli bir ülke ya da ülkeye göre filtreleyebilirsiniz. Sonuçları kısıtlamak için aşağıdakileri yapabilirsiniz:

• Tanımlanan bölgedeki sonuçları tercih etmek (ön yargılı) için GMSAutocompleteFilter üzerinde locationBias değerini ayarlayın (tanımlanmış bölgenin dışındaki sonuçlar yine de döndürülebilir). locationRestriction de ayarlanırsa locationBias yoksayılır.

• Tanımlanan bölgedeki sonuçları göstermek (kısıtlamak) için GMSAutocompleteFilter üzerinde locationRestriction değerini ayarlayın (yalnızca tanımlanan bölgedeki sonuçlar döndürülür).

  • Not: Bu kısıtlama yalnızca rotaların tümüne uygulanır. Konum kısıtlamasıyla çakışan bir rotaya dayalı, dikdörtgen sınırların dışında kalan yapay sonuçlar döndürülebilir.

• Yalnızca belirli bir yer türüne uygun sonuçları döndürmek için GMSAutocompleteFilter üzerinde type özelliğini ayarlayın (örneğin, TypeFiltre.ADDRESS belirtmek widget'ın yalnızca tam adresli sonuçları döndürmesine neden olur).

• En fazla beş ülke için yalnızca sonuç döndürmek isterseniz GMSAutocompleteFilter üzerinde countries ayarlayın.

Belirli bir bölgeye ilişkin sonuçları ön yargılama

Tanımlanan bölge içinde sonuçları tercih etmek (ön yargılı) için GMSAutocompleteFilter üzerinde locationBias öğesini aşağıda gösterildiği gibi ayarlayın:

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

Sonuçları belirli bir bölgeyle kısıtla

Sonuçları yalnızca tanımlanan bölgede göstermek (kısıtlamak) için aşağıda gösterildiği gibi GMSAutocompleteFilter üzerinde locationRestriction ayarlayın:

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

Sonuçları ülkeye göre filtrele

En fazla beş ülke için sonuçları filtrelemek üzere aşağıda gösterildiği gibi GMSAutocompleteFilter üzerinde countries özelliğini ayarlayın:

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

Sonuçları yer türüne veya tür koleksiyonuna göre filtreleyin

GMSAutoCompleteFilter özelliğinin types özelliğini ayarlayarak sonuçları belirli bir tür veya tür koleksiyonunda olacak şekilde kısıtlayabilirsiniz. Yer Türleri konusunda Tablo 1, 2 ve 3'te listelenen filtreleri belirtmek için bu özelliği kullanın. Hiçbir şey belirtilmezse tüm türler döndürülür.

Bir tür veya tür koleksiyonu filtresi belirtmek için:

• Yer Türleri'nde gösterilen 1. Tablo ve 2. Tablo'da en fazla beş tür değeri belirtmek için types özelliğini kullanın. Tür değerleri, GMSPlaceType'teki sabitlerle tanımlanır.

• Yer Türleri bölümünde gösterilen 3. Tablo'daki tür koleksiyonu belirtmek için types özelliğini kullanın. Tür koleksiyonu değerleri, GMSPlaceType içindeki sabitlerle tanımlanır.

  İstekte Tablo 3'ten yalnızca bir türe izin verilir. Tablo 3'ten bir değer belirtirseniz 1. Tablo'dan veya 2. Tablo'dan bir değer belirtemezsiniz. Aksi takdirde bir hata oluşur.

Örneğin, yalnızca belirli bir yer türüne uygun sonuçları döndürmek için GMSAutocompleteFilter üzerinde types özelliğini ayarlayın. Aşağıdaki örnekte filtrenin yalnızca tam adresli sonuçları döndürecek şekilde ayarlanması gösterilmektedir:

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

Yer otomatik tamamlama optimizasyonu

Bu bölümde, Otomatik Yer Tamamlama hizmetinden en iyi şekilde yararlanmanıza yardımcı olacak en iyi uygulamalar açıklanmaktadır.

Bazı genel yönergeler şunlardır:

• Çalışan bir kullanıcı arayüzü geliştirmenin en hızlı yolu, Haritalar JavaScript API'si Otomatik tamamlama widget'ını, Android için Yerler SDK'sını Otomatik tamamlama widget'ı veya iOS için Yerler SDK'sını kullanmaktır Otomatik tamamlama kullanıcı arayüzü kontrolü
• Temel Otomatik Tamamlama veri alanları'nı başından itibaren anlayın.
• Konuma ağırlık verme ve konum kısıtlama alanları isteğe bağlıdır ancak otomatik tamamlama performansını önemli ölçüde etkileyebilir.
• API hata döndürürse uygulamanızın düzgün bir şekilde bozulmasını sağlamak için hata işleme yöntemini kullanın.
• Uygulamanızın seçenek olmadığında işlendiğinden ve kullanıcılara devam etmek için bir yol sunduğundan emin olun.

Maliyet optimizasyonu en iyi uygulamaları

Temel maliyet optimizasyonu

Yer Otomatik Tamamlama hizmetini kullanmanın maliyetini optimize etmek için yalnızca ihtiyacınız olan yer verisi alanlarını döndürmek amacıyla Yer Ayrıntıları ve Otomatik Yer Tamamlama widget'larındaki alan maskelerini kullanın.

Gelişmiş maliyet optimizasyonu

İstek Başına Fiyatlandırma özelliğine erişmek için Yer Otomatik Tamamlama özelliğinin programatik olarak uygulanmasını düşünebilirsiniz. Ayrıca, Yer Ayrıntıları yerine seçilen yer hakkında Geocoded API sonuçları isteğinde bulunabilirsiniz. Aşağıdaki koşulların her ikisi de sağlanıyorsa istek başına fiyatlandırma, Geocode API ile eşlenmiş oturum başına fiyatlandırmaya (oturuma dayalı) fiyatlandırmadan daha maliyetlidir:

• Kullanıcının seçtiği yerin enlem/boylamı veya adresine ihtiyacınız varsa Geo kodlama API'si, bu bilgileri Yer Ayrıntıları çağrısından daha düşük bir fiyatla sunar.
• Kullanıcılar ortalama dört veya daha az otomatik tamamlama tahmin isteği içinde bir otomatik tamamlama tahmini seçerse İstek Başına fiyatlandırma, Oturum Başına fiyatlandırmadan daha uygun maliyetli olabilir.

Uygulamanız, seçilen tahminin adresi ve enlem/boylam bilgileri dışında bir bilgi gerektiriyor mu?

Performansla ilgili en iyi uygulamalar

Aşağıdaki yönergelerde, Yer Otomatik Tamamlama performansını optimize etmenin yolları açıklanmaktadır:

• Yer Otomatik Tamamlama uygulamanıza ülke kısıtlamaları, konum ön yargısı ve (programatik uygulamalar için) dil tercihi ekleyin. Widget'larda dil tercihi gerekmez. Çünkü widget'lar, kullanıcının tarayıcısından veya mobil cihazından dil tercihlerini seçer.
• Yer Otomatik Tamamlama'ya bir harita eşlik ediyorsa, harita görüntü alanına göre konuma ağırlık verebilirsiniz.
• Bir kullanıcının Otomatik tamamlama tahminlerinden birini seçmediği durumlarda, genellikle bu tahminlerden hiçbiri istenen sonuç adresi olmadığı için daha alakalı sonuçlar almaya çalışmak için orijinal kullanıcı girişini yeniden kullanabilirsiniz:
  • Kullanıcının yalnızca adres bilgilerini girmesini bekliyorsanız Geocode API çağrısında orijinal kullanıcı girişini yeniden kullanın.
  • Kullanıcının ada veya adrese göre belirli bir yer için sorgu girmesini bekliyorsanız Yer Bulma isteği kullanın. Yalnızca belirli bir bölgede sonuçlar bekleniyorsa konum ağırlıklandırma kullanın.
  Geocode API'yi kullanmanın en iyi olduğu diğer senaryolar:
  • Çek Cumhuriyeti, Estonya ve Litvanya gibi alt kuruluş adreslerini otomatik tamamlama özelliğinin eksik olduğu ülkelerde alt kuruluş adresleri giren kullanıcılar. Örneğin, Çek adresi "Stroupežnického 3191/17, Praha", Yer Otomatik Tamamlama'da kısmi bir tahmin verir.
  • Kullanıcılar, New York City'de "23-30 29th St, Queens" gibi yol segmenti ön ekleri veya Hawai'i'deki Kauai adasında yer alan "47-380 Kamehameha Hwy, Kaneohe" gibi adresler giriyor.

Sorun giderme

Uygulamanızın çeşitli hataları oluşsa da genellikle hatalı yapılandırmalar (örneğin, yanlış API anahtarının kullanılması veya API anahtarının yanlış yapılandırılmış olması) ya da kota hataları (uygulamanız kotasını aştı) ortaya çıkar. Kotalar hakkında daha fazla bilgi için Kullanım Sınırları bölümüne bakın.

Otomatik tamamlama kontrollerinin kullanımında oluşan hatalar, çeşitli yetki verme protokollerinin didFailAutocompleteWithError() yönteminde döndürülür. Sağlanan NSError nesnesinin code özelliği GMSPlacesErrorCode sıralama değerinden birine ayarlanır.