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

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

अपने ऐप्लिकेशन में, ऑटोकंप्लीट की सुविधा को इन तरीकों से जोड़ा जा सकता है:

• डेवलपमेंट में लगने वाला समय बचाने और उपयोगकर्ताओं को एक जैसा अनुभव देने के लिए, ऑटोकंप्लीट विजेट जोड़ें.
• प्रोग्राम के हिसाब से जगह के सुझाव पाएं, ताकि उपयोगकर्ताओं को उनकी पसंद के मुताबिक अनुभव दिया जा सके.

ऑटोकंप्लीट विजेट जोड़ना

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

अपने ऐप्लिकेशन में, अपने-आप पूरा होने वाले विजेट को जोड़ने के दो विकल्प हैं:

• पहला विकल्प: AutocompleteSupportFragment एंबेड करना.
• दूसरा विकल्प: अपने-आप पूरा होने की सुविधा को लॉन्च करने के लिए, इंटेंट का इस्तेमाल करें.

Option 1: Embed an AutocompleteSupportFragment

अपने ऐप्लिकेशन में AutocompleteSupportFragment जोड़ने के लिए, यह तरीका अपनाएं:

1. अपनी गतिविधि के एक्सएमएल लेआउट में फ़्रैगमेंट जोड़ें.
2. अपनी गतिविधि या फ़्रैगमेंट में लिसनर जोड़ें.

किसी गतिविधि में AutocompleteSupportFragment जोड़ना

किसी गतिविधि में AutocompleteSupportFragment जोड़ने के लिए, एक्सएमएल लेआउट में एक नया फ़्रैगमेंट जोड़ें. उदाहरण के लिए:

<fragment android:id="@+id/autocomplete_fragment"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:name="com.google.android.libraries.places.widget.AutocompleteSupportFragment"
  />

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

किसी गतिविधि में PlaceSelectionListener जोड़ना

PlaceSelectionListener, उपयोगकर्ता की चुनी गई जगह को जवाब के तौर पर दिखाता है. नीचे दिए गए कोड में, फ़्रैगमेंट का रेफ़रंस बनाने और AutocompleteSupportFragment में लिसनर जोड़ने का तरीका बताया गया है:

    // Build a BasicPlaceAutocomplete intent to allow the user to select a place.
    val basicAutocompleteIntent = BasicPlaceAutocomplete.createIntent(this) {
        setCountries(listOf("AU", "NZ"))
    }

      

    // Build a BasicPlaceAutocomplete intent to allow the user to select a place.
    Intent basicAutocompleteIntent =
            new BasicPlaceAutocomplete.IntentBuilder()
                    .setCountries(List.of("AU", "NZ"))
                    .build(this);

      

दूसरा विकल्प: ऑटोकंप्लीट की सुविधा वाली गतिविधि लॉन्च करने के लिए, इंटेंट का इस्तेमाल करना

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

इंटेंट का इस्तेमाल करके, ऑटोकंप्लीट विजेट लॉन्च करने के लिए, यह तरीका अपनाएं:

1. Autocomplete.IntentBuilder का इस्तेमाल करके, इंटेंट बनाएं और अपनी पसंद का Autocomplete मोड पास करें.
2. गतिविधि के नतीजे का लॉन्चर registerForActivityResult तय करें. इसका इस्तेमाल, इंटेंट को लॉन्च करने और नतीजे में उपयोगकर्ता की चुनी गई जगह के अनुमान को मैनेज करने के लिए किया जा सकता है.

ऑटोकंप्लीट इंटेंट बनाना

यहां दिए गए उदाहरण में, ऑटोकंप्लीट विजेट को इंटेंट के तौर पर लॉन्च करने के लिए, Autocomplete.IntentBuilder का इस्तेमाल किया गया है:

    val intent = PlaceAutocomplete.createIntent(this) {
        setTypesFilter(listOf(PlaceTypes.ESTABLISHMENT))
    }

    startAutocomplete.launch(intent)

      

    // Start the autocomplete intent.
    Intent intent =
            new PlaceAutocomplete.IntentBuilder()
                    .setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT))
                    .build(this);
    startAutocomplete.launch(intent);

      

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

इंटेंट के नतीजे के लिए कॉलबैक रजिस्टर करना

जब उपयोगकर्ता कोई जगह चुनता है, तो सूचना पाने के लिए, registerForActivityResult() लॉन्चर तय करें. यह लॉन्चर, गतिविधि को लॉन्च करता है और नतीजे को भी मैनेज करता है. इसके बारे में यहां दिए गए उदाहरण में बताया गया है. अगर उपयोगकर्ता ने कोई अनुमान चुना है, तो उसे नतीजे वाले ऑब्जेक्ट में मौजूद इंटेंट में डिलीवर किया जाएगा. इंटेंट को Autocomplete.IntentBuilder ने बनाया है. इसलिए, Autocomplete.getPlaceFromIntent() वाला तरीका इससे Place ऑब्जेक्ट को निकाल सकता है.

private val startAutocomplete =
    registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
        if (result.resultCode == RESULT_OK) {
            val intent = result.data
            if (intent != null) {
                val prediction = PlaceAutocomplete.getPredictionFromIntent(intent)
                if (prediction != null) {
                    binding.autocompleteResult.text = getString(
                        R.string.place_selection,
                        prediction.getPrimaryText(null),
                        prediction.placeId,
                        prediction.getSecondaryText(null),
                    )
                    Log.i(
                        TAG,
                        "Place: ${prediction.getPrimaryText(null)}, ${prediction.placeId}",
                    )
                }
            }
        } else if (result.resultCode == RESULT_CANCELED) {
            // The user canceled the operation.
            binding.autocompleteResult.setText(R.string.user_canceled_autocomplete)
            Log.i(TAG, "User canceled autocomplete")
        } else if (result.resultCode == PlacesSdkAutocompleteActivity.RESULT_ERROR) {
            val intent = result.data
            if (intent != null) {
                val status = PlaceAutocomplete.getResultStatusFromIntent(intent)
                Log.e(TAG, "An error occurred: ${status?.statusMessage}")
            }
        }
    }

      

private final ActivityResultLauncher<Intent> startAutocomplete =
        registerForActivityResult(
                new ActivityResultContracts.StartActivityForResult(),
                result -> {
                    if (result.getResultCode() == Activity.RESULT_OK) {
                        Intent intent = result.getData();
                        if (intent != null) {
                            AutocompletePrediction prediction =
                                    PlaceAutocomplete.getPredictionFromIntent(intent);
                            if (prediction != null) {
                                binding.autocompleteResult.setText(
                                        getString(
                                                R.string.place_selection,
                                                prediction.getPrimaryText(null),
                                                prediction.getPlaceId(),
                                                prediction.getSecondaryText(null)));
                                Log.i(
                                        TAG,
                                        "Place: "
                                                + prediction.getPrimaryText(null)
                                                + ", "
                                                + prediction.getPlaceId());
                            }
                        }
                    } else if (result.getResultCode() == Activity.RESULT_CANCELED) {
                        // The user canceled the operation.
                        binding.autocompleteResult.setText(R.string.user_canceled_autocomplete);
                        Log.i(TAG, "User canceled autocomplete");
                    } else if (result.getResultCode()
                            == com.google.android.libraries.places.widget
                                    .PlaceAutocompleteActivity.RESULT_ERROR) {
                        Intent intent = result.getData();
                        if (intent != null) {
                            Status status = PlaceAutocomplete.getResultStatusFromIntent(intent);
                            if (status != null) {
                                Log.e(TAG, "An error occurred: " + status.getStatusMessage());
                            }
                        }
                    }
                });


      

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

अपने-आप पूरा होने वाले विजेट से मिलने वाले यूज़र इंटरफ़ेस (यूआई) के विकल्प के तौर पर, पसंद के मुताबिक खोज यूज़र इंटरफ़ेस (यूआई) बनाया जा सकता है. इसके लिए, आपके ऐप्लिकेशन को प्रोग्राम के हिसाब से जगह के सुझाव मिलने चाहिए. आपका ऐप्लिकेशन, ऑटोकंप्लीट एपीआई से जगहों के अनुमानित नामों और/या पतों की सूची पा सकता है. इसके लिए, उसे PlacesClient.findAutocompletePredictions() को कॉल करना होगा और इन पैरामीटर के साथ FindAutocompletePredictionsRequest ऑब्जेक्ट को पास करना होगा:

• ज़रूरी है: query स्ट्रिंग, जिसमें उपयोगकर्ता का टाइप किया गया टेक्स्ट शामिल हो.
• सुझाया गया: AutocompleteSessionToken, जो बिलिंग के मकसद से, उपयोगकर्ता की खोज की क्वेरी और चुने गए चरणों को अलग-अलग सेशन में ग्रुप करता है. सेशन तब शुरू होता है, जब उपयोगकर्ता कोई क्वेरी टाइप करना शुरू करता है. साथ ही, यह तब खत्म होता है, जब वह कोई जगह चुनता है.
• सुझाया गया: RectangularBounds ऑब्जेक्ट, जो अक्षांश और देशांतर की सीमाओं के बारे में बताता है, ताकि नतीजों को तय किए गए इलाके तक सीमित किया जा सके.
• ज़रूरी नहीं: दो अक्षर वाले एक या उससे ज़्यादा देश के कोड (ISO 3166-1 ऐल्फ़ा-2). इससे उस देश या उन देशों के बारे में पता चलता है जहां नतीजे सीमित होने चाहिए.

• ज़रूरी नहीं: TypeFilter, जिसका इस्तेमाल करके नतीजों को किसी खास तरह की जगह तक सीमित किया जा सकता है. इन जगहों के टाइप इस्तेमाल किए जा सकते हैं:

  • TypeFilter.GEOCODE – यह कारोबारों के बजाय, सिर्फ़ जियोकोडिंग के नतीजे दिखाता है. इस अनुरोध का इस्तेमाल करके, उन नतीजों को साफ़ तौर पर समझा जा सकता है जिनमें बताई गई जगह की जानकारी साफ़ तौर पर नहीं दी गई है.
  • TypeFilter.ADDRESS – इससे ऑटोकंप्लीट की सुविधा के सिर्फ़ वे नतीजे दिखते हैं जिनमें सटीक पता होता है. इस टाइप का इस्तेमाल तब करें, जब आपको पता हो कि उपयोगकर्ता को पूरा पता चाहिए.
  • TypeFilter.ESTABLISHMENT – इससे सिर्फ़ कारोबार वाली जगहों की जानकारी मिलती है.

  • TypeFilter.REGIONS – सिर्फ़ ऐसी जगहों की जानकारी दिखाता है जो इनमें से किसी एक टाइप से मेल खाती हैं:

  • LOCALITY

  • SUBLOCALITY

  • POSTAL_CODE

  • COUNTRY

  • ADMINISTRATIVE_AREA_LEVEL_1

  • ADMINISTRATIVE_AREA_LEVEL_2

  • TypeFilter.CITIES – सिर्फ़ LOCALITY या ADMINISTRATIVE_AREA_LEVEL_3 से मैच होने वाले नतीजे दिखाता है.

• ज़रूरी नहीं: अनुरोध की जगह की जानकारी देने वाला LatLng. setOrigin() को कॉल करने पर, यह सेवा रिस्पॉन्स में ऑटोकंप्लीट के हर सुझाव के लिए, तय की गई शुरुआती जगह से दूरी को मीटर (distanceMeters) में दिखाती है.

जगह के टाइप के बारे में जानकारी के लिए, जगह के टाइप की गाइड देखें.

यहां दिए गए उदाहरण में, PlacesClient.findAutocompletePredictions() को किया गया पूरा कॉल दिखाया गया है.

    // Create a new token for the autocomplete session. Pass this to FindAutocompletePredictionsRequest,
    // and once again when the user makes a selection (for example when calling fetchPlace()).
    val token = AutocompleteSessionToken.newInstance()

    // Create a RectangularBounds object.
    val bounds = RectangularBounds.newInstance(
        LatLng(-33.880490, 151.184363),
        LatLng(-33.858754, 151.229596),
    )
    // Use the builder to create a FindAutocompletePredictionsRequest.
    val request =
        FindAutocompletePredictionsRequest.builder()
            // Call either setLocationBias() OR setLocationRestriction().
            .setLocationBias(bounds)
            // .setLocationRestriction(bounds)
            .setOrigin(LatLng(-33.8749937, 151.2041382))
            .setCountries("AU", "NZ")
            .setTypesFilter(listOf(PlaceTypes.ESTABLISHMENT))
            .setSessionToken(token)
            .setQuery(query)
            .build()
    placesClient.findAutocompletePredictions(request)
        .addOnSuccessListener { response: FindAutocompletePredictionsResponse ->
            val builder = StringBuilder()
            for (prediction in response.autocompletePredictions) {
                builder.append(prediction.getPrimaryText(null).toString()).append("\n")
                Log.i(TAG, prediction.placeId)
                Log.i(TAG, prediction.getPrimaryText(null).toString())
            }
            binding.autocompleteResult.text = builder.toString()
        }.addOnFailureListener { exception: Exception? ->
            if (exception is ApiException) {
                Log.e(TAG, "Place not found: ${exception.statusCode}")
                binding.autocompleteResult.text = getString(R.string.place_not_found, exception.message)
            }
        }

      

    // Create a new token for the autocomplete session. Pass this to
    // FindAutocompletePredictionsRequest,
    // and once again when the user makes a selection (for example when calling fetchPlace()).
    AutocompleteSessionToken token = AutocompleteSessionToken.newInstance();

    // Create a RectangularBounds object.
    RectangularBounds bounds =
            RectangularBounds.newInstance(
                    new LatLng(-33.880490, 151.184363), new LatLng(-33.858754, 151.229596));
    // Use the builder to create a FindAutocompletePredictionsRequest.
    FindAutocompletePredictionsRequest request =
            FindAutocompletePredictionsRequest.builder()
                    // Call either setLocationBias() OR setLocationRestriction().
                    .setLocationBias(bounds)
                    // .setLocationRestriction(bounds)
                    .setOrigin(new LatLng(-33.8749937, 151.2041382))
                    .setCountries("AU", "NZ")
                    .setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT))
                    .setSessionToken(token)
                    .setQuery(query)
                    .build();

    placesClient
            .findAutocompletePredictions(request)
            .addOnSuccessListener(
                    (response) -> {
                        StringBuilder builder = new StringBuilder();
                        for (AutocompletePrediction prediction :
                                response.getAutocompletePredictions()) {
                            builder.append(prediction.getPrimaryText(null).toString())
                                    .append("\n");
                            Log.i(TAG, prediction.getPlaceId());
                            Log.i(TAG, prediction.getPrimaryText(null).toString());
                        }
                        binding.autocompleteResult.setText(builder.toString());
                    })
            .addOnFailureListener(
                    (exception) -> {
                        if (exception instanceof ApiException apiException) {
                            Log.e(TAG, "Place not found: " + apiException.getStatusCode());
                            binding.autocompleteResult.setText(
                                    getString(
                                            R.string.place_not_found,
                                            apiException.getMessage()));
                        }
                    });

      

एपीआई, Task में FindAutocompletePredictionsResponse दिखाता है. FindAutocompletePredictionsResponse में AutocompletePrediction ऑब्जेक्ट की सूची होती है. ये ऑब्जेक्ट, अनुमानित जगहों के बारे में बताते हैं. अगर क्वेरी और फ़िल्टर करने की शर्तों के हिसाब से कोई जगह नहीं मिलती है, तो हो सकता है कि सूची खाली हो.

अनुमानित हर जगह के लिए, यहां दिए गए तरीके इस्तेमाल करके जगह की जानकारी हासिल की जा सकती है:

• getFullText(CharacterStyle), किसी जगह की जानकारी का पूरा टेक्स्ट दिखाता है. यह प्राइमरी और सेकंडरी टेक्स्ट का कॉम्बिनेशन है. उदाहरण: "Eiffel Tower, Avenue Anatole France, Paris, France". इसके अलावा, इस तरीके से ब्यौरे के उन सेक्शन को हाइलाइट किया जा सकता है जो आपकी पसंद की स्टाइल के साथ खोज से मैच करते हैं. इसके लिए, CharacterStyle का इस्तेमाल करें. CharacterStyle पैरामीटर ज़रूरी नहीं है. अगर आपको कोई हाइलाइट नहीं चाहिए, तो इसे शून्य पर सेट करें.
• getPrimaryText(CharacterStyle) किसी जगह के बारे में बताने वाला मुख्य टेक्स्ट दिखाता है. आम तौर पर, यह जगह का नाम होता है. उदाहरण: "कुतुब मीनार" और "123 पिट स्ट्रीट".
• getSecondaryText(CharacterStyle) किसी जगह की जानकारी का सहायक टेक्स्ट दिखाता है. उदाहरण के लिए, ऑटोकंप्लीट के सुझाव दिखाते समय, यह दूसरी लाइन के तौर पर काम आता है. उदाहरण: "एवेन्यू एनाटोल फ़्रांस, पेरिस, फ़्रांस" और "सिडनी, न्यू साउथ वेल्स".
• getPlaceId() अनुमानित जगह का आईडी दिखाता है. जगह का आईडी, टेक्स्ट के तौर पर मौजूद एक आइडेंटिफ़ायर होता है. इससे किसी जगह की खास तौर पर पहचान की जाती है. इसका इस्तेमाल करके, Place ऑब्जेक्ट को बाद में फिर से वापस लाया जा सकता है. Places SDK for Android में जगह के आईडी के बारे में ज़्यादा जानने के लिए, जगह की जानकारी देखें. जगह के आईडी के बारे में सामान्य जानकारी के लिए, जगह के आईडी के बारे में खास जानकारी देखें.
• getPlaceTypes() इस जगह से जुड़े टाइप की सूची दिखाता है.
• getDistanceMeters() इस जगह और अनुरोध में बताई गई शुरुआती जगह के बीच की सीधी दूरी को मीटर में दिखाता है.

सेशन टोकन

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

Places SDK for Android, हर सेशन की पहचान करने के लिए AutocompleteSessionToken का इस्तेमाल करता है. आपके ऐप्लिकेशन को हर नया सेशन शुरू होने पर, एक नया सेशन टोकन पास करना चाहिए. इसके बाद, उपयोगकर्ता की चुनी गई जगह की जानकारी पाने के लिए, fetchPlace() को किए जाने वाले अगले कॉल में, जगह के आईडी के साथ वही टोकन पास करना चाहिए.

सेशन टोकन के बारे में ज़्यादा जानें.

ऑटोकंप्लीट के नतीजों को सीमित करना

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

नतीजों को सीमित करने के लिए, यह तरीका अपनाएं:

• तय किए गए इलाके के नतीजों को प्राथमिकता देने के लिए, setLocationBias() को कॉल करें. हालांकि, तय किए गए इलाके के बाहर के कुछ नतीजे अब भी दिखाए जा सकते हैं.
• तय किए गए इलाके के सिर्फ़ नतीजे दिखाने के लिए, setLocationRestriction() को कॉल करें. इससे, सिर्फ़ तय किए गए इलाके के नतीजे दिखेंगे.
• सिर्फ़ किसी खास तरह की जगह से जुड़े नतीजे पाने के लिए, setTypesFilter() को कॉल करें. उदाहरण के लिए, TypeFilter.ADDRESS की जानकारी देने पर, सिर्फ़ सटीक पते वाले नतीजे दिखेंगे.
• सिर्फ़ पांच देशों के नतीजे पाने के लिए, setCountries() को कॉल करें. देशों के नाम, दो वर्णों वाले ISO 3166-1 Alpha-2 के साथ काम करने वाले देश के कोड के तौर पर पास किए जाने चाहिए.

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

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

        intentBuilder.setLocationBias(bounds)

      

        intentBuilder.setLocationBias(
                RectangularBounds.newInstance(
                        new LatLng(-33.880490, 151.184363),
                        new LatLng(-33.858754, 151.229596)));

      

नतीजों को किसी खास इलाके तक सीमित करना

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

        intentBuilder.setLocationRestriction(bounds)

      

        intentBuilder.setLocationRestriction(
                RectangularBounds.newInstance(
                        new LatLng(-33.880490, 151.184363),
                        new LatLng(-33.858754, 151.229596)));

      

ध्यान दें: यह पाबंदी सिर्फ़ पूरे रास्तों पर लागू होती है. आयताकार सीमाओं के बाहर मौजूद सिंथेटिक नतीजे, उस रास्ते के आधार पर दिखाए जा सकते हैं जो जगह की जानकारी से जुड़ी पाबंदी के साथ ओवरलैप होता है.

जगह के टाइप या टाइप कलेक्शन के हिसाब से नतीजे फ़िल्टर करना

ऑटोकंप्लीट की सुविधा के अनुरोध से मिलने वाले नतीजों को सीमित किया जा सकता है, ताकि वे सिर्फ़ किसी खास तरह की जगह के नतीजे दिखाएं. जगह के टाइप पेज पर मौजूद टेबल 1, 2, और 3 में दी गई जगह के टाइप या टाइप कलेक्शन का इस्तेमाल करके, फ़िल्टर तय करें. अगर कुछ भी तय नहीं किया गया है, तो सभी टाइप दिखाए जाते हैं.

ऑटोकंप्लीट के नतीजों को फ़िल्टर करने के लिए, फ़िल्टर सेट करें. इसके लिए, setTypesFilter() को कॉल करें.

किसी टाइप या टाइप कलेक्शन फ़िल्टर को तय करने के लिए:

• जगह के टाइप पर दिखाई गई टेबल 1 और टेबल 2 से, setTypesFilter() को कॉल करें और ज़्यादा से ज़्यादा पांच टाइप वैल्यू तय करें. टाइप की वैल्यू, PlaceTypes में मौजूद कॉन्स्टेंट से तय होती हैं.

• setTypesFilter() को कॉल करें और जगह के टाइप पर दिखाई गई टेबल 3 से टाइप कलेक्शन की जानकारी दें. कलेक्शन की वैल्यू, PlaceTypes में मौजूद कॉन्स्टेंट से तय होती हैं.

  अनुरोध में, टेबल 3 में से सिर्फ़ एक टाइप की अनुमति है. अगर आपने टेबल 3 से कोई वैल्यू चुनी है, तो टेबल 1 या टेबल 2 से कोई वैल्यू नहीं चुनी जा सकती. ऐसा करने पर, गड़बड़ी होती है.

कोड के इस उदाहरण में, AutocompleteSupportFragment पर setTypesFilter() को कॉल किया गया है. साथ ही, टाइप की कई वैल्यू दी गई हैं.

    intentBuilder.setTypesFilter(listOf("landmark", "restaurant", "store"))

      

    intentBuilder.setTypesFilter(List.of("landmark", "restaurant", "store"));

      

यहां दिए गए कोड के उदाहरण में, setTypesFilter() को AutocompleteSupportFragment पर कॉल करने का तरीका बताया गया है. इससे, फ़िल्टर सेट करके सिर्फ़ सटीक पते वाले नतीजे दिखाए जा सकते हैं. इसके लिए, टाइप कलेक्शन की जानकारी देनी होगी.

    intentBuilder.setTypesFilter(listOf(PlaceTypes.ADDRESS))

      

    intentBuilder.setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT));

      

कोड के इस उदाहरण में, IntentBuilder पर setTypesFilter() को कॉल करने का तरीका दिखाया गया है. इससे, टाइप कलेक्शन की जानकारी देकर, सिर्फ़ सटीक पते वाले नतीजे दिखाने वाला फ़िल्टर सेट किया जा सकता है.

    val intent = PlaceAutocomplete.createIntent(this) {
        setTypesFilter(listOf(PlaceTypes.ESTABLISHMENT))
    }

      

    Intent intent =
            new PlaceAutocomplete.IntentBuilder()
                    .setTypesFilter(List.of(PlaceTypes.ESTABLISHMENT))
                    .build(this);

      

देश के हिसाब से नतीजे फ़िल्टर करना

अपने-आप पूरा होने वाले नतीजों को ज़्यादा से ज़्यादा पांच देशों के हिसाब से फ़िल्टर करने के लिए, setCountries() को कॉल करें. इससे देश का कोड सेट किया जा सकेगा. इसके बाद, फ़िल्टर को किसी फ़्रैगमेंट या इंटेंट में पास करें. देशों के नाम, दो वर्णों वाले आईएसओ 3166-1 ऐल्फ़ा-2 के साथ काम करने वाले देश के कोड के तौर पर पास किए जाने चाहिए.

यहां दिए गए कोड के उदाहरण में, AutocompleteSupportFragment पर setCountries() को कॉल करने का तरीका बताया गया है. इससे, सिर्फ़ उन देशों के नतीजे दिखाने वाला फ़िल्टर सेट किया जा सकता है जिन्हें आपने चुना है.

    intentBuilder.setCountries(listOf("AU", "NZ"))

      

    intentBuilder.setCountries(List.of("AU", "NZ"));

      

इस्तेमाल करने की सीमाएँ

Places API (लेगसी) और Places SDK for Android (लेगसी) का इस्तेमाल करने पर, अब हर दिन किए जाने वाले अनुरोधों की संख्या (क्यूपीडी) की कोई सीमा नहीं है. हालांकि, इस्तेमाल करने की ये सीमाएं अब भी लागू होंगी:

• अनुरोध संख्या सीमित करने की दर 6,000 क्यूपीएम (हर मिनट में अनुरोध) है. इसकी गिनती, एक ही प्रोजेक्ट के क्रेडेंशियल का इस्तेमाल करने वाले सभी ऐप्लिकेशन के लिए, क्लाइंट-साइड और सर्वर-साइड अनुरोधों के योग के तौर पर की जाती है.

अपने ऐप्लिकेशन में एट्रिब्यूशन दिखाना

• अगर आपका ऐप्लिकेशन, प्रोग्राम के हिसाब से ऑटोकंप्लीट सेवा का इस्तेमाल करता है, तो आपके यूज़र इंटरफ़ेस (यूआई) में 'Google की मदद से' एट्रिब्यूशन दिखना चाहिए या Google के ब्रैंड वाले मैप में दिखना चाहिए.
• अगर आपका ऐप्लिकेशन, ऑटोकंप्लीट विजेट का इस्तेमाल करता है, तो आपको कुछ और करने की ज़रूरत नहीं है. ज़रूरी एट्रिब्यूशन डिफ़ॉल्ट रूप से दिखता है.
• अगर आईडी से जगह की जानकारी पाने के बाद, जगह की अतिरिक्त जानकारी को वापस लाया जाता है और दिखाया जाता है, तो आपको तीसरे पक्ष के एट्रिब्यूशन भी दिखाने होंगे.

ज़्यादा जानकारी के लिए, एट्रिब्यूशन से जुड़ा दस्तावेज़ देखें.

Place Autocomplete (लेगसी) को ऑप्टिमाइज़ करना

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

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

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

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

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

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

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

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

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

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

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

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

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

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

location पैरामीटर और radius पैरामीटर को पास करके, नतीजों को किसी खास इलाके के हिसाब से बायस करें. इससे, किसी जगह के शुरुआती अक्षर लिखने पर पूरा नाम सुझाने की सुविधा (लेगसी) को तय किए गए इलाके के अंदर नतीजे दिखाने को प्राथमिकता देने का निर्देश मिलता है. तय किए गए इलाके से बाहर के नतीजे अब भी दिख सकते हैं. includedRegionCodes पैरामीटर का इस्तेमाल करके, नतीजों को फ़िल्टर किया जा सकता है. इससे सिर्फ़ किसी देश में मौजूद जगहों को दिखाया जा सकता है.

जगह की जानकारी से जुड़ी पाबंदी

locationRestriction पैरामीटर पास करके, नतीजों को किसी खास इलाके तक सीमित करना.

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

समस्या का हल

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

ऑटोकंप्लीट कंट्रोल का इस्तेमाल करने पर होने वाली गड़बड़ियां, onActivityResult() कॉलबैक में दिखती हैं. नतीजे के लिए स्टेटस मैसेज पाने के लिए, Autocomplete.getStatus() को कॉल करें.