जगह का अपने-आप पूरा होना (नया)

ऑटोकंप्लीट (नया) सेवा, iOS एपीआई है. यह अनुरोध के जवाब में जगह के सुझाव देती है. अनुरोध में, टेक्स्ट खोजने के लिए स्ट्रिंग और भौगोलिक सीमाएं तय करें. इससे खोज के दायरे को कंट्रोल किया जा सकता है.

ऑटोकंप्लीट (नया) सेवा, पूरे शब्दों और इनपुट के सबस्ट्रिंग से मैच कर सकती है. इससे जगहों के नाम, पते, और प्लस कोड का पता लगाया जा सकता है. इसलिए, ऐप्लिकेशन उपयोगकर्ता के टाइप करते ही क्वेरी भेज सकते हैं, ताकि जगह के सुझाव तुरंत दिए जा सकें.

जगहों के सुझाव, कारोबारों, पतों, और लोकप्रिय जगहों के बारे में होते हैं. ये सुझाव, खोज के लिए इस्तेमाल की गई टेक्स्ट स्ट्रिंग और खोज के दायरे के आधार पर दिए जाते हैं.

उदाहरण के लिए, आपने एपीआई को कॉल किया. इसमें आपने "Spagh" स्ट्रिंग को इनपुट के तौर पर इस्तेमाल किया. यह स्ट्रिंग, उपयोगकर्ता के इनपुट का कुछ हिस्सा है. साथ ही, खोज के लिए न्यूयॉर्क शहर को चुना गया है. इसके बाद, जवाब में जगह के सुझावों की एक सूची होती है. ये सुझाव, खोज स्ट्रिंग और खोज क्षेत्र से मेल खाते हैं. जैसे, "कैफ़े स्पेगेटी" नाम का रेस्टोरेंट और जगह के बारे में जानकारी.

जगह के सुझाव, उपयोगकर्ता को दिखाने के लिए डिज़ाइन किए गए हैं, ताकि वह अपनी पसंद की जगह चुन सके. जगह के बारे में मिले सुझावों के बारे में ज़्यादा जानकारी पाने के लिए, जगह की जानकारी (नई) का अनुरोध किया जा सकता है.

अपने ऐप्लिकेशन में, खोज क्वेरी के अपने-आप पूरे होने की सुविधा (नई) को इन दो मुख्य तरीकों से इंटिग्रेट किया जा सकता है:

• प्रोग्राम के हिसाब से जगह के बारे में अनुमान पाएं: अनुमान पाने के लिए, सीधे तौर पर एपीआई को कॉल करें और उन्हें कस्टम यूज़र इंटरफ़ेस में दिखाएं.
• जगह के नाम अपने-आप पूरे होने की सुविधा वाला विजेट जोड़ें: यह खोज के लिए, अपने-आप पूरे होने की सुविधा का इस्तेमाल करने का विकल्प देता है. इससे उपयोगकर्ता के टाइप करते समय ही सुझाव दिखने लगते हैं.

प्रोग्राम के हिसाब से जगह के अनुमान पाना

ऑटोकंप्लीट (नया) सुविधा के अनुरोध

GMSPlacesClient पर किसी तरीके को कॉल करके, ऑटोकंप्लीट करने का अनुरोध बनाएं. GMSAutocompleteRequest ऑब्जेक्ट में पैरामीटर पास किए जा सकते हैं. जवाब में, GMSAutocompletePlaceSuggestion ऑब्जेक्ट में ऑटोकंप्लीट के सुझाव दिए जाते हैं.

एपीआई पासकोड और query पैरामीटर ज़रूरी हैं. बिलिंग सेशन से अनुरोधों को जोड़ने के लिए, GMSAutocompleteSessionToken और नतीजों पर लागू करने के लिए, GMSAutocompleteFilter को भी शामिल किया जा सकता है.

ज़रूरी और वैकल्पिक पैरामीटर के बारे में ज़्यादा जानकारी के लिए, इस दस्तावेज़ का पैरामीटर सेक्शन देखें.

let center = (37.3913916, -122.0879074)
let northEast = (37.388162, -122.088137)
let southWest = (37.395804, -122.077023)

let bias = RectangularCoordinateRegion(northEast: northEast, southWest: southWest)
let filter = AutocompleteFilter(types: [ .restaurant ], origin: center, coordinateRegionBias: bias)

let autocompleteRequest = AutocompleteRequest(query: "Sicilian piz", filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  // Handle suggestions.
case .failure(let placesError):
  // Handle error.
}

let token = GMSAutocompleteSessionToken()

let northWestBounds = CLLocationCoordinate2DMake(40.921628, -73.700051)
let southEastBounds = CLLocationCoordinate2DMake(40.477398, -74.259087)

let filter = GMSAutocompleteFilter()
filter.types = [kGMSPlaceTypeRestaurant]
filter.locationBias = GMSPlaceRectangularLocationOption(northWestBounds, southEastBounds)

let request = GMSAutocompleteRequest(query:"Spagh")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

CLLocationCoordinate2D northEast = CLLocationCoordinate2DMake(37.388162, -122.088137);
CLLocationCoordinate2D southWest = CLLocationCoordinate2DMake(37.395804, -122.077023);

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.types = @[ kGMSPlaceTypeRestaurant ];
filter.locationBias = GMSPlaceRectangularLocationOption(northEast, southWest);
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Sicilian piz"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

अपने-आप पूरा होने की सुविधा (नई) के जवाब

ऑटोकंप्लीट सुविधा, ज़्यादा से ज़्यादा पांच GMSAutocompleteSuggestion इंस्टेंस की एक कैटगरी दिखाती है. ऐरे में ये शामिल हैं:

• placeID
• types: इस जगह पर लागू होने वाले टाइप.
• distanceMeters: ऑरिजिन से दूरी.
• attributedFullText: सुझाव का पूरा टेक्स्ट, जिसे आसानी से पढ़ा जा सकता है.
• attributedPrimaryText: सुझाव का प्राइमरी टेक्स्ट, जिसे इंसान पढ़ सकें.
• attributedSecondaryText: सुझाव का ऐसा सेकंडरी टेक्स्ट जिसे आसानी से पढ़ा जा सके.
• structuredFormat: खास नाम और अलग-अलग टेक्स्ट, जैसे कि शहर या क्षेत्र.

ज़रूरी पैरामीटर

क्वेरी

वह टेक्स्ट स्ट्रिंग जिसमें खोजना है. पूरे शब्द और सबस्ट्रिंग, जगहों के नाम, पते, और प्लस कोड डालें. Autocomplete (New) सेवा, इस स्ट्रिंग के आधार पर संभावित मैच दिखाती है. साथ ही, नतीजों को उनकी अहमियत के हिसाब से क्रम में लगाती है.

ज़रूरी नहीं पैरामीटर

sessionToken

सेशन टोकन, उपयोगकर्ता के जनरेट किए गए ऐसे स्ट्रिंग होते हैं जो "सेशन" के तौर पर, अपने-आप भरने की सुविधा (नई) के कॉल को ट्रैक करते हैं. ये कॉल, विजेट और प्रोग्राम के हिसाब से किए गए कॉल, दोनों के लिए होते हैं. Autocomplete (नया) सुविधा, सेशन टोकन का इस्तेमाल करती है. इससे, उपयोगकर्ता की ऑटोकंप्लीट खोज के क्वेरी और चुनने के चरणों को बिलिंग के लिए अलग सेशन में ग्रुप किया जाता है.

Places SDK for iOS का हिस्सा न होने वाली अन्य सेवाओं को पास करने के लिए, Places Autocomplete सेशन टोकन को दिखाया जा सकता है. जैसे, Address Validation:

let token = AutocompleteSessionToken()
let filter = AutocompleteFilter(origin: CLLocationCoordinate2DMake(39.7, -94.5))
let request = AutocompleteRequest(query: "Piz", sessionToken: token, filter: filter)

PlacesClient.shared.fetchAutocompleteSuggestions(request: request) {
    case .success(let suggestions):
      ...
    case .failure(let placesError):
      print(placesError) 
}

// pass token's string format to use with a service that is not a part of iOS SDK.
print("token: \(token)")

GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Piz"];
GMSAutocompleteSessionToken *token = [[GMSAutocompleteSessionToken alloc] init];
request.sessionToken = token;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.origin = [[CLLocation alloc] initWithLatitude:39.7 longitude:-94.5];
filter.locationBias = GMSPlaceRectangularLocationOption(topLocation, bottomLocation);

request.filter = filter;
 [[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request
                     callback:^(NSArray<GMSAutocompleteSuggestion *> *_Nullable results,
                                NSError *_Nullable error) {
  ...
}];

// pass token's string format to use with a service that is not a part of iOS SDK.
NSLog(@"%@", token.description);

ज़्यादा जानकारी के लिए, सेशन टोकन देखें.

AutocompleteFilter के ऐसे पैरामीटर जिनकी वैल्यू देना ज़रूरी नहीं है

प्रकार

किसी जगह के लिए, टेबल ए या टेबल बी में से सिर्फ़ एक मुख्य टाइप चुना जा सकता है. उदाहरण के लिए, प्राइमरी टाइप mexican_restaurant या steak_house हो सकता है.

डिफ़ॉल्ट रूप से, एपीआई input पैरामीटर के आधार पर सभी जगहों की जानकारी दिखाता है. भले ही, जगह से जुड़ी मुख्य टाइप वैल्यू कुछ भी हो. types पैरामीटर पास करके, नतीजों को किसी खास प्राइमरी टाइप या प्राइमरी टाइप तक सीमित करें.

इस पैरामीटर का इस्तेमाल करके, टेबल A या टेबल B से ज़्यादा से ज़्यादा पांच टाइप वैल्यू तय करें. जवाब में किसी जगह को शामिल करने के लिए, यह ज़रूरी है कि वह बताए गए प्राइमरी टाइप की वैल्यू में से किसी एक से मेल खाती हो.

अगर:INVALID_REQUEST

• पांच से ज़्यादा टाइप दिए गए हैं.
• ऐसे टाइप के बारे में बताया जाता है जिनकी पहचान नहीं हुई है.

उदाहरण के लिए, नतीजों को खेल के सामान के स्टोर तक सीमित करने के लिए, अपनी AutocompleteFilter में उस तरह के स्टोर के बारे में बताएं:

let filter = AutocompleteFilter(types: [ PlaceType(rawValue: "sporting_goods_store") ])
  

let filter = GMSAutocompleteFilter()
filter.types = ["sporting_goods_store"]
  

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.types = @[ "sporting_goods_store" ];

देश

नतीजों में सिर्फ़ उन क्षेत्रों की सूची शामिल करें जिनके बारे में बताया गया है. इन्हें ज़्यादा से ज़्यादा 15 ccTLD ("टॉप-लेवल डोमेन") की दो वर्ण वाली वैल्यू के ऐरे के तौर पर बताया गया है. अगर इसे शामिल नहीं किया जाता है, तो जवाब पर कोई पाबंदी नहीं लगाई जाती है. उदाहरण के लिए, जर्मनी और फ़्रांस को टारगेट करने के लिए:

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

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

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

अगर आपने locationRestriction और countries, दोनों को चुना है, तो नतीजे उन जगहों के लिए दिखाए जाएंगे जहां ये दोनों सेटिंग लागू होती हैं.

inputOffset

शून्य पर आधारित यूनिकोड वर्ण ऑफ़सेट, जो input में कर्सर की जगह दिखाता है. कर्सर की पोज़िशन से, इस बात पर असर पड़ सकता है कि कौनसे अनुमान दिखाए जाएंगे. अगर यह खाली है, तो यह डिफ़ॉल्ट रूप से input की लंबाई पर सेट हो जाता है.

locationBias या locationRestriction

खोज के दायरे को तय करने के लिए, locationBias या locationRestriction में से किसी एक को चुना जा सकता है. हालांकि, दोनों को एक साथ नहीं चुना जा सकता. locationRestriction का मतलब है कि नतीजे उस इलाके के होने चाहिए जिसके लिए खोज की गई है. वहीं, locationBias का मतलब है कि नतीजे उस इलाके के आस-पास के होने चाहिए जिसके लिए खोज की गई है. हालांकि, वे उस इलाके से बाहर के भी हो सकते हैं.

• locationBias में, खोज के लिए कोई इलाका तय किया जाता है. यह जगह, खोज के नतीजों को प्रभावित करती है. इसका मतलब है कि बताई गई जगह के आस-पास के नतीजे दिखाए जा सकते हैं. इसमें बताई गई जगह के बाहर के नतीजे भी शामिल हो सकते हैं.

• locationRestriction में, खोज के लिए कोई इलाका तय किया जाता है. नतीजे, बताई गई जगह के बाहर के नहीं दिखाए जाते.

locationBias या locationRestriction क्षेत्र को आयताकार व्यूपोर्ट या सर्कल के तौर पर तय करें.

किसी सर्कल को उसके सेंटर पॉइंट और मीटर में दी गई त्रिज्या से तय किया जाता है. रेडियस, 0.0 और 50000.0 के बीच होना चाहिए. हालांकि, इन दोनों में से भी कोई संख्या हो सकती है. डिफ़ॉल्ट वैल्यू 0.0 होती है. locationRestriction के लिए, आपको रेडियस को 0.0 से ज़्यादा पर सेट करना होगा. ऐसा न होने पर, अनुरोध के लिए कोई नतीजा नहीं मिलता.

उदाहरण के लिए:

let center = CLLocationCoordinate2DMake(40.477398, -74.259087)

let bias = CircularCoordinateRegion(center: center, radius: 1000.0)

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

let center = CLLocationCoordinate2DMake(40.730610, -73.935242)
let radius = 1000.0

filter.locationBias = GMSPlaceCircularLocationOption(center, radius)

CLLocationCoordinate2D center = CLLocationCoordinate2DMake(40.730610, -73.935242);
radius = 1000.0;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationBias = GMSPlaceCircularLocationOption(center, radius);

रेक्टैंगल, अक्षांश-देशांतर का व्यूपोर्ट होता है. इसे डायगनल या तिरछे तौर पर एक-दूसरे के विपरीत low और high पॉइंट के तौर पर दिखाया जाता है. व्यूपोर्ट को एक बंद क्षेत्र माना जाता है. इसका मतलब है कि इसमें इसकी सीमा शामिल होती है. अक्षांश की सीमाएं -90 से 90 डिग्री के बीच होनी चाहिए. इसमें ये दोनों वैल्यू शामिल हैं. साथ ही, देशांतर की सीमाएं -180 से 180 डिग्री के बीच होनी चाहिए. इसमें ये दोनों वैल्यू शामिल हैं:

• अगर low = high है, तो व्यूपोर्ट में सिर्फ़ एक पॉइंट होता है.
• अगर low.longitude > high.longitude है, तो देशांतर की रेंज उल्टी हो जाती है. इसका मतलब है कि व्यूपोर्ट, 180 डिग्री देशांतर वाली लाइन को पार कर जाता है.
• अगर low.longitude = -180 डिग्री और high.longitude= 180 डिग्री है, तो व्यूपोर्ट में सभी देशांतर शामिल होते हैं.
• अगर low.longitude = 180 डिग्री और high.longitude = -180 डिग्री है, तो देशांतर की रेंज खाली होती है.

low और high, दोनों फ़ील्ड में वैल्यू होनी चाहिए. साथ ही, दिखाए गए बॉक्स में वैल्यू होना ज़रूरी है. व्यूपोर्ट खाली होने पर गड़बड़ी होती है.

उदाहरण के लिए, इस व्यूपोर्ट में न्यूयॉर्क शहर पूरी तरह से शामिल है:

let northEast = CLLocationCoordinate2DMake(40.477398, -74.259087)
let southWest = CLLocationCoordinate2DMake(40.921628, -73.700051)

let filter = AutocompleteFilter(coordinateRegionBias: bias)
  

let high = CLLocationCoordinate2DMake(40.921628, -73.700051)
let low = CLLocationCoordinate2DMake(40.477398, -74.259087)

let filter = GMSAutocompleteFilter()
filter.locationBias = GMSPlaceRectangularLocationOption(high, low)

CLLocationCoordinate2D high = CLLocationCoordinate2DMake(40.477398, -74.259087);
CLLocationCoordinate2D low = CLLocationCoordinate2DMake(440.921628, -73.700051);

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationBias = GMSPlaceRectangularLocationOption(high, low);

origin

वह शुरुआती पॉइंट जहां से मंज़िल तक की सीधी दूरी (distanceMeters के तौर पर दिखाई गई) का हिसाब लगाया जाना है. अगर इस वैल्यू को शामिल नहीं किया जाता है, तो सीधी दूरी नहीं दिखाई जाएगी. इसे अक्षांश और देशांतर निर्देशांक के तौर पर तय किया जाना चाहिए:

let filter = AutocompleteFilter(origin: CLLocation(latitude: 37.395804, longitude: -122.077023))
  

let filter = GMSAutocompleteFilter()
filter.origin =  CLLocation(latitude: 37.395804, longitude: -122.077023)
 

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];

filter.origin = [[CLLocation alloc] initWithLatitude:37.395804 longitude: -122.077023];

regionCode

जवाब को फ़ॉर्मैट करने के लिए इस्तेमाल किया गया क्षेत्र कोड. इसे ccTLD ("टॉप-लेवल डोमेन") के तौर पर तय किया जाता है. इसकी वैल्यू दो वर्णों की होती है. ज़्यादातर ccTLD कोड, ISO 3166-1 कोड के जैसे ही होते हैं. हालांकि, कुछ मामलों में ये अलग होते हैं. उदाहरण के लिए, यूनाइटेड किंगडम का ccTLD "uk" (.co.uk) है, जबकि इसका ISO 3166-1 कोड "gb" है. तकनीकी तौर पर, यह "ग्रेट ब्रिटेन और उत्तरी आयरलैंड के यूनाइटेड किंगडम" के लिए है.

अगर आपने क्षेत्र का अमान्य कोड डाला है, तो एपीआई INVALID_ARGUMENT गड़बड़ी का मैसेज दिखाता है. लागू कानून के आधार पर, इस पैरामीटर से नतीजों पर असर पड़ सकता है.

shouldIncludePureServiceAreaBusinesses

अगर true है, तो जवाब के तौर पर मिले ऐरे में, घर या दुकान पर सेवा देने वाले कारोबारों की जानकारी मिलती है. घर या दुकान पर सेवा देने वाला कारोबार, ग्राहकों के पते पर जाकर सेवाएं देता है या डिलीवरी करता है. हालांकि, वह अपने कारोबार के पते पर ग्राहकों को सेवा नहीं देता.

उदाहरण के लिए:

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

let filter = AutocompleteFilter()
filter.shouldIncludePureServiceAreaBusinesses = true

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

जगह के नाम के शुरुआती अक्षर लिखने पर पूरा नाम सुझाने की सुविधा वाला विजेट जोड़ना

जगह के नाम अपने-आप पूरे होने की सुविधा को आसानी से इस्तेमाल करने के लिए, अपने ऐप्लिकेशन में जगह के नाम अपने-आप पूरे होने की सुविधा वाला विजेट जोड़ा जा सकता है. यह विजेट, एक खास और फ़ुल-स्क्रीन इंटरफ़ेस उपलब्ध कराता है. यह इंटरफ़ेस, उपयोगकर्ता के इनपुट को हैंडल करता है और उपयोगकर्ता को जगह के नाम अपने-आप पूरे होने की सुविधा के सुझाव दिखाता है. साथ ही, ऐप्लिकेशन को AutocompletePlaceSuggestion ऑब्जेक्ट दिखाता है. इसके बाद, जगह के नाम अपने-आप पूरे होने की सुविधा के किसी भी सुझाव के बारे में ज़्यादा जानकारी पाने के लिए, जगह की जानकारी (नई) का अनुरोध किया जा सकता है.

जैसे, जगह के सुझाव प्रोग्राम के हिसाब से पाने के लिए, Place Autocomplete विजेट की मदद से सेशन टोकन का इस्तेमाल किया जा सकता है. इससे, बिलिंग के लिए ऑटोकंप्लीट अनुरोधों को सेशन में ग्रुप किया जा सकता है. AutocompleteSessionToken() को कॉल करके, सेशन टोकन पास किया जा सकता है.

अगर आपने सेशन टोकन नहीं दिया है, तो विजेट आपके लिए अपने-आप पूरा होने वाले सुझावों का सेशन टोकन बनाएगा. इसे onSelection कॉलबैक से पाया जा सकता है. सेशन टोकन इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, सेशन टोकन के बारे में जानकारी लेख पढ़ें.

show बाइंडिंग वैल्यू को true पर सेट करने पर, उपयोगकर्ता को फ़ुल स्क्रीन व्यू पर ले जाया जाएगा. यहां वे कोई जगह चुन सकते हैं. उपयोगकर्ता के टाइप करने के दौरान, विजेट कारोबारों, पतों, और लोकप्रिय जगहों के सुझाव दिखाता है. जब उपयोगकर्ता किसी जगह को चुनता है, तो विजेट, चुनी गई जगह के साथ onSelection हैंडलर को कॉल करता है. साथ ही, फ़ुलस्क्रीन व्यू को बंद कर देता है.

जगह के नाम के शुरुआती अक्षर लिखने पर पूरा नाम सुझाने की सुविधा वाले विजेट के पैरामीटर

प्रोग्राम के हिसाब से उपलब्ध पैरामीटर के अलावा, Place Autocomplete विजेट में ये पैरामीटर भी उपलब्ध होते हैं.

दिखाएं

show से यह तय होता है कि विजेट दिखाया जाएगा या नहीं.

onSelection

जगह चुने जाने पर, बंद होने की स्थिति को लागू करने वाला क्लोज़र.

onError

गड़बड़ी होने पर इस क्लोज़र को चलाया जाता है. कोई गड़बड़ी होने पर, A PlacesError पास किया जाएगा.

कॉन्टेंट और थीम को पसंद के मुताबिक बनाना

AutocompleteUICustomization पैरामीटर, विजेट पर लागू होने वाले यूज़र इंटरफ़ेस (यूआई) के कस्टमर के हिसाब से बनाए गए वर्शन के बारे में बताते हैं. कस्टमाइज़ेशन के ये विकल्प हैं:

• AutocompleteListDensity. इस पैरामीटर की मदद से, सुझावों की सूची में दिखने वाले आइटम की संख्या चुनी जा सकती है. इसके लिए, multiLine या twoLine में से कोई एक विकल्प चुनें.
• AutocompleteUIIcon. इस पैरामीटर की मदद से, यह चुना जा सकता है कि हर सूची आइटम के लिए डिफ़ॉल्ट आइकॉन दिखाना है या नहीं.
• theme. यह पैरामीटर, कस्टम थीम के बारे में बताता है. यह डिफ़ॉल्ट स्टाइल एट्रिब्यूट में से किसी एक को बदल देता है. Place Autocomplete कॉम्पोनेंट के रंग, टाइपोग्राफ़ी, स्पेसिंग, बॉर्डर, और कोनों को पसंद के मुताबिक बनाया जा सकता है. डिफ़ॉल्ट वैल्यू PlacesMaterialTheme है. जिन थीम एट्रिब्यूट को बदला नहीं गया है वे डिफ़ॉल्ट स्टाइल का इस्तेमाल करते हैं.

पूरे कोड का उदाहरण देखें.

ऑटोकंप्लीट (नई सुविधा) के उदाहरण

locationRestriction और locationBias का इस्तेमाल करना

'अपने-आप पूरा होने की सुविधा (नई)' में, खोज के दायरे को कंट्रोल करने के लिए, डिफ़ॉल्ट रूप से आईपी बायसिंग का इस्तेमाल किया जाता है. आईपी पते के आधार पर नतीजे दिखाने की सुविधा में, एपीआई डिवाइस के आईपी पते का इस्तेमाल करके नतीजों को प्राथमिकता देता है. खोज के लिए किसी इलाके की जानकारी देने के लिए, locationRestriction या locationBias का इस्तेमाल किया जा सकता है. हालांकि, दोनों का इस्तेमाल नहीं किया जा सकता.

जगह के हिसाब से पाबंदी लगाने पर, खोज के लिए जगह तय की जाती है. तय की गई जगह के बाहर के नतीजे नहीं दिखाए जाते. इस उदाहरण में, सैन फ़्रांसिस्को के 5,000 मीटर के दायरे में मौजूद जगहों के लिए अनुरोध को सीमित करने के लिए, जगह के हिसाब से पाबंदी लगाने की सुविधा का इस्तेमाल किया गया है:

let center = (37.775061, -122.419400)
let radius = 5000.0
let restriction = CircularCoordinateRegion(center: center, radius: radius)
let filter = AutocompleteFilter(coordinateRegionRestriction: restriction)
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Sicilian piz", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
  

let token = GMSAutocompleteSessionToken()

let center = CLLocationCoordinate2DMake(37.775061, -122.419400)
let radius = 5000.0

let filter = GMSAutocompleteFilter()
filter.locationRestriction = GMSPlaceCircularLocationOption(center, radius)

let request = GMSAutocompleteRequest(query:"Piz")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

CLLocationCoordinate2D center = CLLocationCoordinate2DMake(37.775061, -122.419400);
radius = 5000.0;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationRestriction = GMSPlaceCircularLocationOption(center, radius);
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Sicilian piz"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

लोकेशन के हिसाब से खोज के नतीजों में बदलाव करने की सुविधा का इस्तेमाल करने पर, लोकेशन को प्राथमिकता दी जाती है. इसका मतलब है कि खोज के नतीजों में, दी गई लोकेशन के आस-पास के नतीजे शामिल किए जा सकते हैं. साथ ही, इसमें दी गई लोकेशन के बाहर के नतीजे भी शामिल किए जा सकते हैं. इस उदाहरण में, जगह के हिसाब से खोज के नतीजों को प्राथमिकता देने के लिए, पिछले अनुरोध में बदलाव किया गया है:

let center = (37.775061, -122.419400)
let radius = 5000.0
let bias = CircularCoordinateRegion(center: center, radius: radius)
let filter = AutocompleteFilter(coordinateRegionBias: bias)
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Sicilian piz", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
  

let token = GMSAutocompleteSessionToken()

let center = CLLocationCoordinate2DMake(37.775061, -122.419400)
let radius = 5000.0

let filter = GMSAutocompleteFilter()
filter.locationBias = GMSPlaceCircularLocationOption(center, radius)

let request = GMSAutocompleteRequest(query:"Piz")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

CLLocationCoordinate2D center = CLLocationCoordinate2DMake(37.775061, -122.419400);
radius = 5000.0;

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.locationBias = GMSPlaceCircularLocationOption(center, radius);
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Sicilian piz"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

इस्तेमाल के टाइप

टाइप पैरामीटर का इस्तेमाल करके, अनुरोध के नतीजों को किसी खास टाइप तक सीमित किया जा सकता है. टेबल A और टेबल B में दिए गए टाइप का इस्तेमाल किया जा सकता है. ज़्यादा से ज़्यादा पांच वैल्यू का कलेक्शन तय किया जा सकता है. अगर इसे शामिल नहीं किया जाता है, तो सभी टाइप दिखाए जाते हैं.

इस उदाहरण में, "फ़ुटबॉल" की क्वेरी स्ट्रिंग दी गई है. साथ ही, इसमें types पैरामीटर का इस्तेमाल करके, नतीजों को "sporting_goods_store" टाइप के कारोबारों तक सीमित किया गया है:

let filter = AutocompleteFilter(types: [ PlaceType(rawValue: "sporting_goods_store") ])
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Soccer", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
    

let token = GMSAutocompleteSessionToken()

let filter = GMSAutocompleteFilter()
filter.types = ["sporting_goods_store"]

let request = GMSAutocompleteRequest(query:"Soccer")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText))")
        }
      }
    })

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.types = @[ "sporting_goods_store" ];
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Soccer"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
    }
  }
}];

ऑरिजिन का इस्तेमाल करना

अनुरोध में origin पैरामीटर शामिल करने पर, एपीआई जवाब में शुरुआती जगह से मंज़िल तक की सीधी दूरी शामिल करता है. इस पैरामीटर को अक्षांश और देशांतर निर्देशांक के तौर पर तय किया जाता है. जवाब में दूरी को distanceMeters के तौर पर दिखाया गया है.

इस उदाहरण में, सैन फ़्रांसिस्को के सेंटर को ऑरिजिन के तौर पर सेट किया गया है:

let filter = AutocompleteFilter(origin: CLLocation(latitude: 37.7749, longitude: -122.4194))
let token = AutocompleteSessionToken()

let autocompleteRequest = AutocompleteRequest(query: "Amoeba", sessionToken: token, filter: filter)
switch await placesClient.fetchAutocompleteSuggestions(with: autocompleteRequest) {
case .success(let autocompleteSuggestions):
  for suggestion in autocompleteSuggestions {
    switch suggestion {
    case .place:
      // Show place suggestion data.
    }
  }
case .failure(let placesError):
  // Handle error.
}
  

let token = GMSAutocompleteSessionToken()

let origin = CLLocation(latitude: 37.7749, longitude: -122.4194)

let filter = GMSAutocompleteFilter()

filter.origin =  origin

let request = GMSAutocompleteRequest(query:"Amoeba")
request.filter = filter
request.sessionToken = token

GMSPlacesClient.shared().fetchAutocompleteSuggestions(from: request, callback: { ( results, error ) in
      if let error = error {
        print("Autocomplete error: \(error)")
        return
      }
      if let autocompleteResults = results {
        for result in autocompleteResults {
          print("Result \(String(describing: result.placeSuggestion?.placeID)) with \(String(describing: result.placeSuggestion?.attributedFullText)) and distance: \(String(describing: result.placeSuggestion?.distanceMeters))")
        }
      }
    })

GMSAutocompleteFilter *filter = [[GMSAutocompleteFilter alloc] init];
filter.origin = [[CLLocation alloc] initWithLatitude:37.395804 longitude:-122.077023];
GMSAutocompleteRequest *request = [[GMSAutocompleteRequest alloc] initWithQuery:@"Amoeba"];
request.sessionToken = token;
request.filter = filter;

[[GMSPlacesClient sharedClient] fetchAutocompleteSuggestionsFromRequest:request callback:^(NSArray<GMSAutocompleteSuggestion *> * results, NSError * error){
  // Handle response
  for (GMSAutocompleteSuggestion *suggestion in results) {
    if (suggestion.placeSuggestion) {
      // Show place suggestion data.
      }
    }
}];

कॉन्टेंट और थीम को पसंद के मुताबिक बनाना

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

जगहों के नाम के शुरुआती अक्षर लिखने पर पूरा नाम सुझाने की सुविधा वाला विजेट जोड़ना (पूरा कोड)

struct PlaceAutocompleteDemoView: View {

  @State private var fetchedPlace: Place?
  @State private var placesError: PlacesError?
  @State private var showWidget = false

  public var body: some View {
    VStack {
      Button("Search for a place") {
        showWidget.toggle()
      }
      .placeAutocomplete(
        show: $showWidget,
        onSelection: { (autocompletePlaceSuggestion, autocompleteSessionToken) in
          Task {
            let placesClient = await PlacesClient.shared
            let fetchPlaceRequest = FetchPlaceRequest(
              placeID: autocompletePlaceSuggestion.placeID,
              placeProperties: [.displayName, .formattedAddress],
              sessionToken: autocompleteSessionToken
            )

            switch await placesClient.fetchPlace(with: fetchPlaceRequest) {
            case .success(let place):
              print("Fetched place: \(place)")
              self.fetchedPlace = place
            case .failure(let placesError):
              print("Failed to fetch place: \(placesError)")
              self.placesError = placesError
            }
          }
        },
        onError: { placesError in
          self.placesError = placesError
        }
      )
    }
  }
}

ऑटोकंप्लीट (नई) सुविधा के लिए ऑप्टिमाइज़ेशन

इस सेक्शन में, अपने-आप भरने की सुविधा (नई) का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए, सबसे सही तरीकों के बारे में बताया गया है.

यहां कुछ सामान्य दिशा-निर्देश दिए गए हैं:

• उपयोगकर्ता इंटरफ़ेस को तुरंत डेवलप करने के लिए, इनमें से किसी एक का इस्तेमाल करें: Maps JavaScript API Autocomplete (New) widget, Places SDK for Android Autocomplete (New) widget, या Places SDK for iOS Autocomplete (New) widget.
• शुरू से ही, अपने-आप भरने की सुविधा (नई) के डेटा फ़ील्ड के बारे में ज़रूरी जानकारी पाएं.
• जगह के हिसाब से खोज के नतीजों को प्राथमिकता देने और जगह के हिसाब से पाबंदी लगाने वाले फ़ील्ड का इस्तेमाल करना ज़रूरी नहीं है. हालांकि, इससे अपने-आप भरने की सुविधा की परफ़ॉर्मेंस पर काफ़ी असर पड़ सकता है.
• गड़बड़ी को मैनेज करने की सुविधा का इस्तेमाल करें, ताकि एपीआई से गड़बड़ी का मैसेज मिलने पर आपका ऐप्लिकेशन ठीक से काम करे.
• पक्का करें कि आपके ऐप्लिकेशन में, बिना किसी विकल्प को चुने आगे बढ़ने की सुविधा हो.

लागत ऑप्टिमाइज़ करने के सबसे सही तरीके

लागत को ऑप्टिमाइज़ करने की बुनियादी सेटिंग

Autocomplete (New) सेवा का इस्तेमाल करने की लागत को ऑप्टिमाइज़ करने के लिए, Place Details (New) और Autocomplete (New) विजेट में फ़ील्ड मास्क का इस्तेमाल करें. इससे आपको सिर्फ़ ज़रूरी Autocomplete (New) डेटा फ़ील्ड मिलेंगे.

लागत को ऑप्टिमाइज़ करने की बेहतर सुविधा

ऑटोकंप्लीट (नया) को प्रोग्राम के हिसाब से लागू करें, ताकि आपको एसकेयू: ऑटोकंप्लीट अनुरोध की कीमत का ऐक्सेस मिल सके. साथ ही, Place Details (नया) के बजाय, चुनी गई जगह के बारे में Geocoding API के नतीजे पाने का अनुरोध किया जा सके. अगर ये दोनों शर्तें पूरी होती हैं, तो Geocoding API के साथ हर अनुरोध के लिए तय की गई कीमत, हर सेशन (सेशन के आधार पर) के लिए तय की गई कीमत से ज़्यादा किफ़ायती होती है:

• अगर आपको सिर्फ़ उपयोगकर्ता की चुनी गई जगह का अक्षांश/देशांतर या पता चाहिए, तो Geocoding API, Place Details (New) API के कॉल की तुलना में कम समय में यह जानकारी उपलब्ध कराता है.
• अगर उपयोगकर्ता, अपने-आप पूरा होने की सुविधा (नई) के लिए औसतन चार या इससे कम अनुरोधों में से किसी एक को चुनते हैं, तो अनुरोध के हिसाब से तय की गई कीमत, सेशन के हिसाब से तय की गई कीमत से ज़्यादा किफ़ायती हो सकती है.

क्या आपके ऐप्लिकेशन को चुने गए अनुमान के पते और अक्षांश/देशांतर के अलावा किसी अन्य जानकारी की ज़रूरत है?

परफ़ॉर्मेंस के सबसे सही तरीके

यहां दिए गए दिशा-निर्देशों में, ऑटोकंप्लीट (नया वर्शन) की परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के तरीके बताए गए हैं:

• अपने Autocomplete (New) को लागू करने के लिए, देश के हिसाब से पाबंदियां, जगह के हिसाब से पक्षपात, और (प्रोग्राम के हिसाब से लागू करने के लिए) भाषा की प्राथमिकता जोड़ें. विजेट के लिए भाषा की प्राथमिकता सेट करने की ज़रूरत नहीं होती, क्योंकि वे उपयोगकर्ता के ब्राउज़र या मोबाइल डिवाइस से भाषा की प्राथमिकताएं चुनते हैं.
• अगर अपने-आप भरने की सुविधा (नई) के साथ मैप दिखाया जाता है, तो मैप व्यूपोर्ट के हिसाब से जगह की जानकारी को प्राथमिकता दी जा सकती है.
• जब कोई उपयोगकर्ता, ऑटोकंप्लीट (नया) सुविधा के सुझावों में से किसी को नहीं चुनता है, तो आम तौर पर ऐसा इसलिए होता है, क्योंकि इनमें से कोई भी सुझाव, उपयोगकर्ता के हिसाब से नहीं होता. ऐसे में, ज़्यादा काम के नतीजे पाने के लिए, उपयोगकर्ता के ओरिजनल इनपुट का फिर से इस्तेमाल किया जा सकता है:
  • अगर आपको लगता है कि उपयोगकर्ता सिर्फ़ पते की जानकारी डालेगा, तो Geocoding API को कॉल करने के लिए, उपयोगकर्ता के ओरिजनल इनपुट का फिर से इस्तेमाल करें.
  • अगर आपको लगता है कि उपयोगकर्ता किसी जगह का नाम या पता डालकर क्वेरी करेगा, तो Place Details (New) अनुरोध का इस्तेमाल करें. अगर आपको नतीजे सिर्फ़ किसी खास इलाके में चाहिए, तो जगह के हिसाब से नतीजों को प्राथमिकता देने की सुविधा का इस्तेमाल करें.
  Geocoding API का इस्तेमाल करने के लिए, यहां कुछ और उदाहरण दिए गए हैं:
  • ऐसे उपयोगकर्ता जो सबप्रीमाइज़ के पते डालते हैं. जैसे, किसी बिल्डिंग में मौजूद खास यूनिट या अपार्टमेंट के पते. उदाहरण के लिए, चेक गणराज्य के पते "Stroupežnického 3191/17, Praha" के लिए, ऑटोकंप्लीट (नया) सुविधा की मदद से आंशिक सुझाव मिलता है.
  • ऐसे उपयोगकर्ता जो न्यूयॉर्क शहर में "23-30 29th St, Queens" या हवाई के काउआई द्वीप पर "47-380 Kamehameha Hwy, Kaneohe" जैसे सड़क-सेगमेंट के प्रीफ़िक्स वाले पते डालते हैं.

जगह के हिसाब से नतीजे दिखाना

location पैरामीटर और radius पैरामीटर पास करके, नतीजों को किसी खास इलाके के हिसाब से दिखाएं. इससे Autocomplete (New) को यह निर्देश मिलता है कि वह तय किए गए इलाके में खोज के नतीजे दिखाने को प्राथमिकता दे. हालांकि, तय की गई जगह से बाहर के नतीजे भी दिख सकते हैं. components पैरामीटर का इस्तेमाल करके, नतीजों को फ़िल्टर किया जा सकता है. इससे सिर्फ़ किसी देश में मौजूद जगहों के नतीजे दिखते हैं.

जगह की जानकारी को सीमित करना

locationRestriction पैरामीटर पास करके, नतीजों को किसी तय जगह के लिए सीमित करें.

location और radius पैरामीटर से तय किए गए क्षेत्र के हिसाब से भी नतीजों को सीमित किया जा सकता है. इसके लिए, locationRestriction पैरामीटर जोड़ें. इससे Autocomplete (New) को उस इलाके के सिर्फ़ नतीजे दिखाने का निर्देश मिलता है.