Android के लिए अपना मौजूदा स्थान पिकर बनाएं (Java)

1. शुरू करने से पहले

अपने उपयोगकर्ताओं को उनकी मौजूदा जगहों की पहचान करने के लिए जगहों की सूची देने के लिए, Google Maps Platform और Android के लिए जगहें SDK टूल का इस्तेमाल करने का तरीका जानें.

bd07a9ad2cb27a06.png

ज़रूरी बातें

  • Java में बुनियादी कौशल

आप क्या कर पाएंगे!

  • Android ऐप्लिकेशन में मैप जोड़ें.
  • उपयोगकर्ता को भौगोलिक स्थान देने के लिए जगह की जानकारी की अनुमतियों का इस्तेमाल करें.
  • उपयोगकर्ता की मौजूदा जगह के आस-पास की जगहें फ़ेच करें.
  • उपयोगकर्ता को अपनी मौजूदा जगह की जानकारी देने के लिए, 'पसंदीदा जगह' दिखाएं.

आप क्या बनाएंगे #39;

आप अपने Android ऐप्लिकेशन को शुरू से ही बनाते हैं, लेकिन डीबग करते समय तुलना करने के लिए आप नमूना कोड डाउनलोड कर सकते हैं. GitHub से सैंपल कोड डाउनलोड करें. इसके अलावा, अगर आपने कमांड लाइन इस्तेमाल करने के लिए, GIF को सेट अप किया है, तो यह कोड डालें:

git clone https://github.com/googlecodelabs/current-place-picker-android.git

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

2. शुरू करें

इस कोडलैब (कोड बनाना सीखना) को शुरू करने से पहले, आपको ये सेट अप करने होंगे:

Android Studio

https://developer.android.com/studio से Android Studio डाउनलोड करें.

अगर आपके पास पहले से Android Studio है, तो Android Studio और अपडेट की जांच करें... पर क्लिक करके, पक्का करें कि आपके पास सबसे नया वर्शन है.

1f36bae83b64e33.png

यह लैब, Android Studio 3.4 का इस्तेमाल करके लिखा गया है.

Android SDK

Android Studio में, आप SDK टूल का इस्तेमाल करके, अपनी पसंद के SDK टूल कॉन्फ़िगर कर सकते हैं. यह लैब, Android Q SDK का इस्तेमाल करता है.

  1. Android Studio की वेलकम स्क्रीन से, कॉन्फ़िगर करें ;SDK मैनेजर पर क्लिक करें.

d3fa03c269ec231c.png

  1. अपनी पसंद का SDK चेकबॉक्स चुनें, फिर लागू करें पर क्लिक करें.

अगर आपके पास अभी तक SDK टूल नहीं है, तो यह आपकी मशीन पर SDK टूल को डाउनलोड करना शुरू कर देगा.

884e0aa1314f70d.png

Google Play सेवाएं

SDK टूल मैनेजर से, आपको Google Play सेवाएं भी इंस्टॉल करनी होंगी.

  1. SDK टूल टैब पर क्लिक करें और Google Play सेवाएं चेकबॉक्स चुनें.

अगर स्थिति में अपडेट उपलब्ध है लिखा हो, तो अपडेट करें.

विज्ञापन6211fd78f3b629.png

3. एम्युलेटर तैयार करें

ऐप्लिकेशन चलाने के लिए, आप अपना डिवाइस या Android Emulator का इस्तेमाल कर सकते हैं.

अगर आप अपने डिवाइस का इस्तेमाल कर रहे हैं, तो इस पेज के आखिर में जाकर असली डिवाइस के लिए निर्देश: Google Play सेवाएं अपडेट करें पर जाएं.

एम्युलेटर जोड़ें

  1. Android Studio की वेलकम स्क्रीन से, कॉन्फ़िगर करें > AVD मैनेजर पर क्लिक करें.

5dd2d14c9c56d3f9.png

इससे Android वर्चुअल डिवाइस मैनेजर डायलॉग खुलता है.

  1. आप जिन डिवाइसों में से चुन सकते हैं उनकी सूची खोलने के लिए, वर्चुअल डिवाइस बनाएं... पर क्लिक करें.

2d44eada384f8b35.png

  1. Play Store कॉलम में d5722488d80cd6be.png आइकॉन वाले डिवाइस को चुनें और आगे बढ़ें पर क्लिक करें.

e0248f1c6e85ab7c.png

आपको सिस्टम इमेज का एक सेट दिखेगा, जिसे आप इंस्टॉल कर सकते हैं. अगर Android 9.+ (Google Play) को टारगेट करने वाले Q के बगल में डाउनलोड करें शब्द मौजूद है, तो डाउनलोड करें पर क्लिक करें.

316d0d1efabd9f24.png

  1. अपने वर्चुअल डिवाइस को नाम देने के लिए, आगे बढ़ें पर क्लिक करें. इसके बाद, पूरा करें पर क्लिक करें.

आप अपने वर्चुअल डिवाइस की सूची पर वापस जाते हैं.

  1. अपने नए डिवाइस के आगे ba8adffe56d3b678.png पर क्लिक करें:

7605864ed27f77ea.png

कुछ देर बाद, एम्युलेटर खुल जाएगा.

एम्युलेटर के निर्देश—Google Play सेवाएं अपडेट करें

  1. एम्युलेटर लॉन्च होने के बाद, दिखने वाले नेविगेशन बार में, ... पर क्लिक करें**.**

2e1156e02643d018.png

इससे एक्सटेंडेड कंट्रोल डायलॉग खुलता है.

  1. मेन्यू में Google Play पर क्लिक करें.

अगर कोई अपडेट उपलब्ध है, तो अपडेट करें पर क्लिक करें.

5afd2686c5cad0e5.png

  1. Google खाते से एम्युलेटर में साइन इन करें.

आप अपनी जांच को निजी जानकारी से अलग रखने के लिए, खुद का खाता इस्तेमाल कर सकते हैं या नया खाता बना सकते हैं.

इसके बाद Google Play, Google Play सेवाओं पर खुलेगा.

  1. Google Play सेवाओं का नया वर्शन पाने के लिए अपडेट करें पर क्लिक करें.

f4bc067e80630b9c.png

अगर आपसे खाता सेट अप पूरा करने और पैसे चुकाने का विकल्प जोड़ने के लिए कहा जाता है, तो अभी नहीं पर क्लिक करें.

एम्युलेटर में जगह की जानकारी सेट करें

  1. एम्युलेटर लॉन्च होने के बाद, Google Maps ऐप्लिकेशन का आइकॉन लाने के लिए, होम स्क्रीन पर खोज बार में "maps&quat; टाइप करें.

2d996aadd53685a6.png

  1. लॉन्च करने के लिए, आइकॉन पर क्लिक करें.

आपको डिफ़ॉल्ट मैप दिखेगा.

  1. मैप के नीचे दाईं ओर आपकी जगहc5b4e2fda57a7e71.png पर क्लिक करें.

आपसे फ़ोन इस्तेमाल करने की जगह की जानकारी का इस्तेमाल करने की अनुमति मांगी जाती है.

f2b68044eabca151

  1. एक्सटेंडेड कंट्रोल मेन्यू खोलने के लिए, ... पर क्लिक करें.
  2. स्थान टैब पर क्लिक करें.
  3. अक्षांश और देशांतर डालें.

आप जो भी पसंद करते हैं उसे यहां डालें, लेकिन पक्का करें कि यह बहुत सारी जगहों पर हो.

(इस कोडलैब से मिले नतीजों की नकल करने के लिए, हवाई के मावी पर किहाई शहर के लिए, अक्षांश 20.7818 और देशांतर -156.4624 का इस्तेमाल करें.)

  1. भेजें पर क्लिक करें और इस जगह से जुड़े मैप को अपडेट करें.

f9576b35218f4187.png

आप अपना ऐप्लिकेशन चलाने और इसकी जगह की जानकारी के साथ टेस्ट करने के लिए तैयार हैं.

डिवाइस से जुड़े असली निर्देश—Google Play सेवाएं अपडेट करें

अगर आप किसी असली Android डिवाइस का इस्तेमाल कर रहे हैं, तब ये काम करें:

  1. खोजने और Google Play सेवाएं खोलने के लिए, होम स्क्रीन पर खोज बार का इस्तेमाल करें.
  2. ज़्यादा जानकारी पर क्लिक करें.

अगर उपलब्ध हो, तो अपडेट करें पर क्लिक करें.

विज्ञापन16cdb975b5c3f7.png बाफ़3399889c88c.png

4. Google Maps गतिविधि के ज़रिए ऐप्लिकेशन शेल बनाएं

  1. Android Studio की वेलकम स्क्रीन पर, नया Android Studio प्रोजेक्ट शुरू करें चुनें.
  2. फ़ोन और टैबलेट टैब पर, Google Maps गतिविधि चुनें.

c9c80aa8211a8761.png

अपना प्रोजेक्ट कॉन्फ़िगर करें डायलॉग खुलता है. यहां आप अपने ऐप्लिकेशन को नाम देते हैं और अपने डोमेन के आधार पर पैकेज बनाते हैं.

यहां 'मौजूदा जगह' नाम के ऐप्लिकेशन की सेटिंग दी गई हैं, जो पैकेज com.google.codelab.currentplace के मुताबिक हैं.

37f5b93b94ee118c.png

  1. भाषा के तौर पर Java चुनें और Androidx के आर्टफ़ैक्ट का इस्तेमाल करें* चुनें.

बाकी सेटिंग के लिए डिफ़ॉल्ट सेटिंग रखें.

  1. पूरा करें पर क्लिक करें.

5. Gradle बिल्ड फ़ाइल में Google की सेवाएं डिपेंडेंसी जोड़ना

Android में जगह की जानकारी ऐक्सेस करने की अनुमतियों को ऐक्सेस करने के लिए, आपको Google Play सेवाओं में जाकर, Google की जगह की जानकारी और गतिविधि की पहचान करने वाले एपीआई की ज़रूरत होगी. इसे और Google Play सेवाओं के अन्य एपीआई को जोड़ने के बारे में ज़्यादा जानकारी के लिए, Google Play की सेवाएं सेट अप करें देखें.

Android Studio प्रोजेक्ट में आम तौर पर दो build.gradle फ़ाइलें होती हैं. एक प्रोजेक्ट के लिए है और एक ऐप्लिकेशन के लिए है. अगर आपके पास Android व्यू में Android Studio प्रोजेक्ट एक्सप्लोरर है, तो आप दोनों को Gradle Scripts फ़ोल्डर में देखें. Google की सेवाएं जोड़ने के लिए, आपको build.gradle (Module: app) फ़ाइल में बदलाव करना होगा.

आमने-सामने

  1. जगह की जानकारी और जगहें एपीआई ( संदर्भ के लिए सैंपल कोड) के लिए, dependencies सेक्शन में दो लाइनें जोड़ें.

build.gradle (मॉड्यूल: ऐप्लिकेशन)

plugins {
  id 'com.android.application'
}

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.google.codelab.currentplace"
        minSdkVersion 19
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'androidx.appcompat:appcompat:1.0.2'
    implementation 'com.google.android.gms:play-services-maps:16.1.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test:runner:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'

    implementation 'com.google.android.gms:play-services-location:16.0.0'
    implementation 'com.google.android.libraries.places:places:1.1.0'
}

6. Google Maps Platform API चालू करें और एपीआई कुंजी पाएं

नीचे दिए गए चालू करने के चरण के लिए , आपको Android के लिए Maps SDK टूल और जगहों के लिए एपीआई चालू करना होगा.

Google Maps Platform सेट अप करना

अगर आपके पास पहले से Google Cloud Platform खाता नहीं है और बिलिंग की सुविधा चालू की गई है, तो कृपया बिलिंग खाता और प्रोजेक्ट बनाने के लिए, Google Maps Platform का इस्तेमाल शुरू करना गाइड देखें.

  1. Cloud Console में, प्रोजेक्ट ड्रॉप-डाउन मेन्यू पर क्लिक करें और वह प्रोजेक्ट चुनें जिसे आप इस कोडलैब के लिए इस्तेमाल करना चाहते हैं.

  1. Google Cloud Marketplace में, इस कोडलैब के लिए ज़रूरी Google Maps Platform API और SDK टूल चालू करें. ऐसा करने के लिए, इस वीडियो या इस दस्तावेज़ में दिया गया तरीका अपनाएं.
  2. Cloud Console के क्रेडेंशियल पेज में एपीआई कुंजी जनरेट करें. आप इस वीडियो या इस दस्तावेज़ में दिया गया तरीका अपना सकते हैं. Google Maps Platform पर सभी अनुरोधों के लिए एपीआई कुंजी ज़रूरी है.

हाल ही में बनाई गई API (एपीआई) कुंजी को कॉपी करें. Android Studio पर वापस जाएं और Android > app > res > values में google_maps_api.xml फ़ाइल ढूंढें.

YOUR_KEY_HERE को उस एपीआई कुंजी से बदलें जिसे आपने कॉपी किया है.

aa576e551a7a1009.png

अब आपका ऐप्लिकेशन कॉन्फ़िगर हो गया.

7. लेआउट फ़ाइल में बदलाव करें

  1. अपने प्रोजेक्ट एक्सप्लोरर में, activity_maps.xml फ़ाइल को Android > app > res > layout में खोलें.

4e0d986480c57efa.png

  1. आपको #39;स्क्रीन के दाईं ओर बेसिक यूज़र इंटरफ़ेस (यूआई) दिखेगा. सबसे नीचे टैब के साथ, आपको अपने लेआउट के लिए डिज़ाइन या टेक्स्ट एडिटर चुनने की सुविधा है. टेक्स्ट चुनें, और लेआउट फ़ाइल का पूरा कॉन्टेंट इसके साथ बदलें:

activity_maps.xml

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    android:orientation="vertical">

    <androidx.appcompat.widget.Toolbar
        android:id="@+id/toolbar"
        android:minHeight="?attr/actionBarSize"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:titleTextColor="@android:color/white"
        android:background="@color/colorPrimary" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <fragment
            android:id="@+id/map"
            android:name="com.google.android.gms.maps.SupportMapFragment"
            android:layout_width="match_parent"
            android:layout_height="349dp"
            tools:context=".MapsActivity" />

        <ListView
            android:id="@+id/listPlaces"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    </LinearLayout>

</LinearLayout>

इससे आपको यूज़र इंटरफ़ेस दिखेगा, जो ऐसा दिखेगा:

1bf786808a4697ce.png

8. ऐप्लिकेशन बार को सेट अप करना

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

3a17c92b613a26c5.png

फ़ोन पर, सिर्फ़ आइकॉन दिखता है. टैबलेट में ज़्यादा जगह होने पर, वह भी टेक्स्ट में शामिल होता है.

आइकॉन बनाना

  1. प्रोजेक्ट एक्सप्लोरर में, Android &gt app पर क्लिक करें, फिर res फ़ोल्डर पर दायां क्लिक करें और नया > इमेज एसेट चुनें.

एसेट स्टूडियो खुल जाएगा.

  1. आइकॉन टाइप मेन्यू में, कार्रवाई बार और टैब आइकॉन पर क्लिक करें.
  2. अपनी एसेट को ic_geolocate नाम दें.
  3. एसेट टाइप के तौर पर क्लिप आर्ट चुनें**.**
  4. क्लिप आर्ट के बगल में बने ग्राफ़िक पर क्लिक करें.

इससे आइकॉन चुनें विंडो खुलती है.

  1. कोई आइकॉन चुनें.

आप अपने इंटेंट से जुड़े आइकॉन ढूंढने के लिए खोज बार का इस्तेमाल कर सकते हैं.

  1. location खोजें और जगह से जुड़ा आइकॉन चुनें.

मेरा जगह का आइकॉन वही होता है जो Google Maps ऐप्लिकेशन में इस्तेमाल किया जाता है और जब कोई उपयोगकर्ता कैमरा को अपनी मौजूदा जगह पर ले जाना चाहता है.

  1. ठीक है> आगे बढ़ें; पूरा करें पर क्लिक करें और पुष्टि करें कि drawable नाम का एक नया फ़ोल्डर है जिसमें आपकी नई आइकॉन फ़ाइलें हैं.

b9e0196137ed18ae.png

स्ट्रिंग रिसॉर्स जोड़ना

  1. प्रोजेक्ट एक्सप्लोरर में, Android > app > res > values पर क्लिक करें और strings.xml फ़ाइल खोलें.
  2. <string name="title_activity_maps">Map</string> के बाद, ये लाइनें जोड़ें:

strings.xml

    <string name="action_geolocate">Pick Place</string>
    <string name="default_info_title">Default Location</string>
    <string name="default_info_snippet">No places found, because location permission is disabled.</string>

आपके ऐप्लिकेशन बार में आइकॉन के बगल में टेक्स्ट लेबल शामिल करने की जगह होने पर, पहली लाइन का इस्तेमाल किया जाता है. दूसरों का इस्तेमाल उन मार्कर के लिए किया जाता है जिन्हें आप मैप पर जोड़ते हैं.

अब फ़ाइल का कोड इस तरह दिखेगा:

<resources>
    <string name="app_name">Current Place</string>
    <string name="title_activity_maps">Map</string>
    <string name="action_geolocate">Pick Place</string>
    <string name="default_info_title">Default Location</string>
    <string name="default_info_snippet">No places found, because location permission is disabled.</string>
</resources>

ऐप्लिकेशन बार जोड़ना

  1. प्रोजेक्ट एक्सप्लोरर में, Android &gt पर क्लिक करें
  2. डायरेक्ट्री का नाम menu रखें.
  3. menu फ़ोल्डर पर दायां क्लिक करें और नया &g; फ़ाइल को चुनें.
  4. फ़ाइल को menu.xml नाम दें.
  5. इस कोड को चिपकाएं:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <!-- "Locate me", should appear as action button if possible -->
    <item
        android:id="@+id/action_geolocate"
        android:icon="@drawable/ic_geolocate"
        android:title="@string/action_geolocate"
        app:showAsAction="always|withText" />

</menu>

ऐप्लिकेशन बार की स्टाइल अपडेट करना

  1. प्रोजेक्ट एक्सप्लोरर में, Android > app > res > values को बड़ा करें और फ़ाइल styles.xml को इसके अंदर खोलें.
  2. <style> टैग में, पैरंट प्रॉपर्टी में बदलाव करें, ताकि वह "Theme.AppCompat.NoActionBar" हो.
  3. name प्रॉपर्टी को ध्यान में रखें, जिसे आप अगले चरण में इस्तेमाल करेंगे.

styles.xml

<style name="AppTheme" parent="Theme.AppCompat.NoActionBar">

AndroidManifest.xml ऐप्लिकेशन में ऐप्लिकेशन की थीम अपडेट करना

  1. Android > app > manifests पर क्लिक करें और AndroidManifest.xml फ़ाइल खोलें.
  2. android:theme लाइन को खोजें और @style/AppTheme के मान में बदलाव करें या उसकी पुष्टि करें.

AndroidManifest.xml

   <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

अब आप कोडिंग शुरू करने के लिए तैयार हैं!

9. ऐप्लिकेशन शुरू करें

  1. अपने प्रोजेक्ट एक्सप्लोरर में MapsActivity.java फ़ाइल ढूंढें.

इसमें मौजूद पैकेज में, पहले चरण में आपके ऐप्लिकेशन के लिए बनाए गए पैकेज से जुड़ा #&9 है.

8b0fa27d417f5f55.png

  1. फ़ाइल खोलें और आप #39;Java कोड एडिटर में हैं.

जगहों के SDK टूल और दूसरी डिपेंडेंसी इंपोर्ट करना

मौजूदा इंपोर्ट स्टेटमेंट की जगह, MapsActivity.java के ऊपर ये लाइनें जोड़ें.

इनमें मौजूदा इंपोर्ट शामिल होते हैं और इस कोडलैब के कोड में और इस्तेमाल किए गए इंपोर्ट शामिल होते हैं.

MapsActivity.java

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;

import com.google.android.gms.common.api.ApiException;
import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;
import com.google.android.libraries.places.api.Places;
import com.google.android.libraries.places.api.model.Place;
import com.google.android.libraries.places.api.model.PlaceLikelihood;
import com.google.android.libraries.places.api.net.FindCurrentPlaceRequest;
import com.google.android.libraries.places.api.net.FindCurrentPlaceResponse;
import com.google.android.libraries.places.api.net.PlacesClient;

import java.util.Arrays;
import java.util.List;

कक्षा के हस्ताक्षर को अपडेट करना

जगहें एपीआई, साथ काम करने वाले बैक अप के लिए AndroidX कॉम्पोनेंट का इस्तेमाल करता है. इसलिए, आपको AppCompatActivity को बढ़ाने के लिए इसे तय करना होगा. यह FragmentActivity एक्सटेंशन को बदलता है जो मैप की गतिविधि के लिए डिफ़ॉल्ट रूप से तय होता है.

public class MapsActivity extends AppCompatActivity implements OnMapReadyCallback {

क्लास के वैरिएबल जोड़ें

इसके बाद, क्लास के अलग-अलग तरीकों में इस्तेमाल किए जाने वाले क्लास क्लास वैरिएबल का एलान करें. इनमें यूज़र इंटरफ़ेस (यूआई) एलिमेंट और स्टेटस कोड शामिल हैं. ये GoogleMap mMap के लिए, वैरिएबल के एलान से ठीक नीचे होने चाहिए.

    // New variables for Current Place picker
    private static final String TAG = "MapsActivity";
    ListView lstPlaces;
    private PlacesClient mPlacesClient;
    private FusedLocationProviderClient mFusedLocationProviderClient;

    // The geographical location where the device is currently located. That is, the last-known
    // location retrieved by the Fused Location Provider.
    private Location mLastKnownLocation;

    // A default location (Sydney, Australia) and default zoom to use when location permission is
    // not granted.
    private final LatLng mDefaultLocation = new LatLng(-33.8523341, 151.2106085);
    private static final int DEFAULT_ZOOM = 15;
    private static final int PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 1;
    private boolean mLocationPermissionGranted;

    // Used for selecting the Current Place.
    private static final int M_MAX_ENTRIES = 5;
    private String[] mLikelyPlaceNames;
    private String[] mLikelyPlaceAddresses;
    private String[] mLikelyPlaceAttributions;
    private LatLng[] mLikelyPlaceLatLngs;

onCreate का तरीका अपडेट करना

जगह की जानकारी के लिए रनटाइम उपयोगकर्ता अनुमतियों को मैनेज करने, यूज़र इंटरफ़ेस (यूआई) एलिमेंट सेट अप करने, और Places API क्लाइंट बनाने के लिए, आपको onCreate तरीका अपडेट करना होगा.

मौजूदा onCreate() तरीके के आखिर में ऐक्शन टूलबार, व्यू सेट अप, और जगहें क्लाइंट के बारे में नीचे दी गई कोड लाइनें जोड़ें.

MapsActivity.java onCreate()

   @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_maps);
        // Obtain the SupportMapFragment and get notified when the map is ready to be used.
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
                .findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);

        //
        // PASTE THE LINES BELOW THIS COMMENT
        //
        
        // Set up the action toolbar
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        // Set up the views
        lstPlaces = (ListView) findViewById(R.id.listPlaces);

        // Initialize the Places client
        String apiKey = getString(R.string.google_maps_key);
        Places.initialize(getApplicationContext(), apiKey);
        mPlacesClient = Places.createClient(this);
        mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
    }

अपने ऐप्लिकेशन बार के मेन्यू के लिए कोड जोड़ना

इन दो तरीकों में ऐप्लिकेशन बार मेन्यू (सिर्फ़ एक आइटम, 'जगह चुनें' आइकॉन) के साथ शामिल होता है. साथ ही, आइकॉन पर उपयोगकर्ता के क्लिक # को मैनेज करता है.

onCreate तरीके के बाद, इन दो तरीकों को अपनी फ़ाइल में कॉपी करें.

MapsActivity.java onCreateOptionsMenu() और onOptionsItemSelected()

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu, menu);

        return super.onCreateOptionsMenu(menu);
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
           case R.id.action_geolocate:
                
                // COMMENTED OUT UNTIL WE DEFINE THE METHOD
                // Present the current place picker
                // pickCurrentPlace();
                return true;

            default:
                // If we got here, the user's action was not recognized.
                // Invoke the superclass to handle it.
                return super.onOptionsItemSelected(item);

        }
    }

इसे आज़माएं

  1. Android Studio में, चलाएं या चलाएं मेन्यू > 'ऐप्लिकेशन' चलाएं पर क्लिक करें.

28bea91c68c36fb2.png

  1. आपसे अपना डिप्लॉयमेंट टारगेट चुनने के लिए कहा जाता है. इस सूची में चल रहा एम्युलेटर दिखाई देना चाहिए. इसे चुनें और Android Studio, ऐप्लिकेशन को आपके लिए एम्युलेटर पर डिप्लॉय कर देगा.

f44658ca91f6f41a.png

कुछ देर बाद, ऐप्लिकेशन लॉन्च होगा. आपको ऑस्ट्रेलिया, ऑस्ट्रेलिया के मैप पर एक बटन और खाली जगहों की सूची दिखेगी.

68eb8c70f4748350.png

मैप का मकसद तब तक उपयोगकर्ता की जगह पर नहीं जाता, जब तक आप डिवाइस की जगह की जानकारी ऐक्सेस करने का अनुरोध नहीं करते.

10. जगह की जानकारी की अनुमतियों का अनुरोध करना और उन्हें मैनेज करना

मैप तैयार होने के बाद, जगह की जानकारी की अनुमतियों का अनुरोध करें

  1. getLocationPermission अनुमति वाला तरीका तय करें, जो उपयोगकर्ता की अनुमतियों का अनुरोध करे.

इस कोड को onOptionsSelected अभी-अभी बनाए गए तरीके के नीचे चिपकाएं.

MapsActivity.java getLocationPermission()

    private void getLocationPermission() {
        /*
         * Request location permission, so that we can get the location of the
         * device. The result of the permission request is handled by a callback,
         * onRequestPermissionsResult.
         */
        mLocationPermissionGranted = false;
        if (ContextCompat.checkSelfPermission(this.getApplicationContext(),
                android.Manifest.permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
            mLocationPermissionGranted = true;
        } else {
            ActivityCompat.requestPermissions(this,
                    new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
                    PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
        }
    }
  1. ज़ूम कंट्रोल चालू करने और उपयोगकर्ता से जगह की जानकारी इस्तेमाल करने की अनुमति पाने के लिए, मौजूदा onMapReady तरीके के आखिर में दो लाइनें जोड़ें.

MapsActivity.Java onMapReady()

   @Override
    public void onMapReady(GoogleMap googleMap) {
        mMap = googleMap;

        // Add a marker in Sydney and move the camera
        LatLng sydney = new LatLng(-34, 151);
        mMap.addMarker(new MarkerOptions().position(sydney).title("Marker in Sydney"));
        mMap.moveCamera(CameraUpdateFactory.newLatLng(sydney));

        //
        // PASTE THE LINES BELOW THIS COMMENT
        //

        // Enable the zoom controls for the map
        mMap.getUiSettings().setZoomControlsEnabled(true);

        // Prompt the user for permission.
        getLocationPermission();

    }

अनुरोध की गई अनुमतियों के नतीजों को मैनेज करना

जब उपयोगकर्ता अनुरोध की अनुमति वाले डायलॉग का जवाब देता है, तो इस कॉलबैक को Android कॉल करता है.

getLocationPermission() कोड के बाद यह कोड चिपकाएं:

MapsActivity.java onRequestAllowedResult()

   /**
     * Handles the result of the request for location permissions
     */
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           @NonNull String permissions[],
                                           @NonNull int[] grantResults) {
        mLocationPermissionGranted = false;
        switch (requestCode) {
            case PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION: {
                // If request is cancelled, the result arrays are empty.
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    mLocationPermissionGranted = true;
                }
            }
        }
    }

11. वर्तमान स्थान पाएं और संभावित स्थान पाएं

जब उपयोगकर्ता ऐप्लिकेशन बार में जगह चुनें पर क्लिक करता है, तो ऐप्लिकेशन pickCurrentPlace() तरीके को कॉल करता है, जो आपके बताए getDeviceLocation() तरीके का इस्तेमाल करता है. डिवाइस का नया पता वापस पाने के बाद, getDeviceLocation वाले तरीके से किसी दूसरे तरीके, getCurrentPlaceLikelihoods, का इस्तेमाल किया जाता है.

findcurrentPlace API को कॉल करना और रिस्पॉन्स मैनेज करना

getCurrentPlaceLikelihoods एक findCurrentPlaceRequest बनाता है और स्पेस एपीआई findCurrentPlace टास्क को कॉल करता है. अगर टास्क पूरा हो जाता है, तो यह findCurrentPlaceResponse दिखाता है, जिसमें placeLikelihood ऑब्जेक्ट की सूची होती है. इनमें से हर प्रॉपर्टी की कई प्रॉपर्टी होती हैं, जिनमें जगह का नाम और पता शामिल है. साथ ही, इनमें वह संभावना भी होती है कि आप उस जगह पर हैं (0 से 1 तक की डबल वैल्यू). यह तरीका, placeLikelihoods से जगह की जानकारी की सूची बनाकर रिस्पॉन्स को मैनेज करता है.

यह कोड सबसे ज़्यादा संभावना वाली पांच जगहों पर जाता है और 0 से ज़्यादा होने की संभावना वाली सूची में उसे जोड़ता है और फिर उसे रेंडर करता है. अगर आप पांच से कम या ज़्यादा दिखाना चाहते हैं, तो M_MAX_ENTRIES के मान में बदलाव करें.

इस कोड को onMapReady वाले तरीके के बाद चिपकाएं.

MapsActivity.java getcurrentPlaceलाइकलाइड()

   private void getCurrentPlaceLikelihoods() {
        // Use fields to define the data types to return.
        List<Place.Field> placeFields = Arrays.asList(Place.Field.NAME, Place.Field.ADDRESS,
                Place.Field.LAT_LNG);

        // Get the likely places - that is, the businesses and other points of interest that
        // are the best match for the device's current location.
        @SuppressWarnings("MissingPermission") final FindCurrentPlaceRequest request =
                FindCurrentPlaceRequest.builder(placeFields).build();
        Task<FindCurrentPlaceResponse> placeResponse = mPlacesClient.findCurrentPlace(request);
        placeResponse.addOnCompleteListener(this,
                new OnCompleteListener<FindCurrentPlaceResponse>() {
                    @Override
                    public void onComplete(@NonNull Task<FindCurrentPlaceResponse> task) {
                        if (task.isSuccessful()) {
                            FindCurrentPlaceResponse response = task.getResult();
                            // Set the count, handling cases where less than 5 entries are returned.
                            int count;
                            if (response.getPlaceLikelihoods().size() < M_MAX_ENTRIES) {
                                count = response.getPlaceLikelihoods().size();
                            } else {
                                count = M_MAX_ENTRIES;
                            }

                            int i = 0;
                            mLikelyPlaceNames = new String[count];
                            mLikelyPlaceAddresses = new String[count];
                            mLikelyPlaceAttributions = new String[count];
                            mLikelyPlaceLatLngs = new LatLng[count];

                            for (PlaceLikelihood placeLikelihood : response.getPlaceLikelihoods()) {
                                Place currPlace = placeLikelihood.getPlace();
                                mLikelyPlaceNames[i] = currPlace.getName();
                                mLikelyPlaceAddresses[i] = currPlace.getAddress();
                                mLikelyPlaceAttributions[i] = (currPlace.getAttributions() == null) ?
                                        null : TextUtils.join(" ", currPlace.getAttributions());
                                mLikelyPlaceLatLngs[i] = currPlace.getLatLng();

                                String currLatLng = (mLikelyPlaceLatLngs[i] == null) ?
                                        "" : mLikelyPlaceLatLngs[i].toString();

                                Log.i(TAG, String.format("Place " + currPlace.getName()
                                        + " has likelihood: " + placeLikelihood.getLikelihood()
                                        + " at " + currLatLng));

                                i++;
                                if (i > (count - 1)) {
                                    break;
                                }
                            }


                            // COMMENTED OUT UNTIL WE DEFINE THE METHOD
                            // Populate the ListView
                            // fillPlacesList();
                        } else {
                            Exception exception = task.getException();
                            if (exception instanceof ApiException) {
                                ApiException apiException = (ApiException) exception;
                                Log.e(TAG, "Place not found: " + apiException.getStatusCode());
                            }
                        }
                    }
                });
    }

मैप कैमरे को डिवाइस की मौजूदा जगह पर ले जाएं

अगर उपयोगकर्ता अनुमति देता है, तो ऐप्लिकेशन उपयोगकर्ता की # जगह की जानकारी फ़ेच करता है और कैमरे को उस जगह के आस-पास सेंटर में ले जाता है.

अगर उपयोगकर्ता अनुमति नहीं देता है, तो ऐप्लिकेशन कैमरा को इस पेज की शुरुआत में कॉन्सटेंट के तौर पर तय डिफ़ॉल्ट जगह पर ले जाता है (सैंपल कोड में, यह सिडनी, ऑस्ट्रेलिया है).

getPlaceLikelihoods() कोड के बाद यह कोड चिपकाएं:

MapsActivity.java getDeviceLocation()

    private void getDeviceLocation() {
        /*
         * Get the best and most recent location of the device, which may be null in rare
         * cases when a location is not available.
         */
        try {
            if (mLocationPermissionGranted) {
                Task<Location> locationResult = mFusedLocationProviderClient.getLastLocation();
                locationResult.addOnCompleteListener(this, new OnCompleteListener<Location>() {
                    @Override
                    public void onComplete(@NonNull Task<Location> task) {
                        if (task.isSuccessful()) {
                            // Set the map's camera position to the current location of the device.
                            mLastKnownLocation = task.getResult();
                            Log.d(TAG, "Latitude: " + mLastKnownLocation.getLatitude());
                            Log.d(TAG, "Longitude: " + mLastKnownLocation.getLongitude());
                            mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(
                                    new LatLng(mLastKnownLocation.getLatitude(),
                                            mLastKnownLocation.getLongitude()), DEFAULT_ZOOM));
                        } else {
                            Log.d(TAG, "Current location is null. Using defaults.");
                            Log.e(TAG, "Exception: %s", task.getException());
                            mMap.moveCamera(CameraUpdateFactory
                                    .newLatLngZoom(mDefaultLocation, DEFAULT_ZOOM));
                        }

                       getCurrentPlaceLikelihoods();
                    }
                });
            }
        } catch (SecurityException e)  {
            Log.e("Exception: %s", e.getMessage());
        }
    }

जब उपयोगकर्ता 'जगह चुनें' पर क्लिक करे, तब जगह की जानकारी की अनुमतियां देखें

जब उपयोगकर्ता जगह चुनें पर टैप करता है, तो यह तरीका जगह की जानकारी की अनुमति की जांच करता है. साथ ही, अगर उपयोगकर्ता को #39 नहीं दिया गया है, तो उसे इसकी अनुमति देने के लिए कहा जाता है.

अगर उपयोगकर्ता ने अनुमति दी है, तो यह तरीका, मौजूदा मौजूदा जगहों की जानकारी पाने की प्रोसेस शुरू करने के लिए getDeviceLocation को कॉल करता है.

  1. इस तरीके को getDeviceLocation() के बाद जोड़ें:

MapsActivity.java pickupCurrentPlace()

   private void pickCurrentPlace() {
        if (mMap == null) {
            return;
        }

        if (mLocationPermissionGranted) {
            getDeviceLocation();
        } else {
            // The user has not granted permission.
            Log.i(TAG, "The user did not grant location permission.");

            // Add a default marker, because the user hasn't selected a place.
            mMap.addMarker(new MarkerOptions()
                    .title(getString(R.string.default_info_title))
                    .position(mDefaultLocation)
                    .snippet(getString(R.string.default_info_snippet)));

            // Prompt the user for permission.
            getLocationPermission();
        }
    }
  1. अब जबकि pickCurrentPlace तय हो गया है, onOptionsItemSelected() में उस लाइन को ढूंढें जो pickCurrentPlace को कॉल करती है और उस पर टिप्पणी नहीं करती.

MapsActivity.java onOptionItemSelected()

           case R.id.action_geolocate:

                // COMMENTED OUT UNTIL WE DEFINE THE METHOD
                // Present the Current Place picker
                pickCurrentPlace();
                return true;

इसे आज़माएं

अगर आप किसी ऐप्लिकेशन को अभी चलाते हैं और जगह चुनें पर टैप करते हैं, तो जगह की जानकारी की अनुमतियों का अनुरोध किया जाना चाहिए.

  • अगर आप अनुमति देते हैं, तो यह प्राथमिकता सेव हो जाएगी और आपको सूचना नहीं मिलेगी. अगर आप अनुमति नहीं देते हैं, तो अगली बार बटन पर टैप करने पर आपको सूचना मिलेगी.
  • हालांकि, getPlaceLikelihoods की ओर से मौजूदा जगहों को फ़ेच किया गया है, लेकिन ListView उन्हें अभी तक नहीं दिखाता है. Android Studio में, ⌘6 पर क्लिक करके, CatActivity के टैग वाले स्टेटमेंट के लॉगकैट में लॉग की जांच की जा सकती है. इससे यह पुष्टि होती है कि आपके नए तरीके ठीक से काम कर रहे हैं या नहीं.
  • अगर आपने अनुमति दी है, तो लॉग में Latitude: के लिए स्टेटमेंट और Longitude: के लिए स्टेटमेंट शामिल होता है जो डिवाइस की पहचानी गई जगह की जानकारी दिखाता है. अगर आप एम्युलेटर के लिए कोई जगह बताने के लिए, Google Maps और एम्युलेटर के # अन्य मेन्यू का इस्तेमाल पहले कर चुके हैं, तो ये स्टेटमेंट उस जगह की जानकारी दिखाते हैं.
  • अगर findCurrentPlace को कॉल सफल रहा, तो लॉग में पांच स्टेटमेंट शामिल होते हैं, जिनमें पांच सबसे ज़्यादा संभावित जगहों के नाम और जगहें प्रिंट होती हैं.

d9896a245b81bf3.png

12. मौजूदा जगह के पिकर को पॉप्युलेट करें

चुने गए स्थानों के लिए हैंडलर सेट अप करना

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

pickCurrentPlace क्लिक के बाद इस क्लिक हैंडलर को चिपकाएं.

MapsActivity.java सूची ClickedHandler

    private AdapterView.OnItemClickListener listClickedHandler = new AdapterView.OnItemClickListener() {
        public void onItemClick(AdapterView parent, View v, int position, long id) {
            // position will give us the index of which place was selected in the array
            LatLng markerLatLng = mLikelyPlaceLatLngs[position];
            String markerSnippet = mLikelyPlaceAddresses[position];
            if (mLikelyPlaceAttributions[position] != null) {
                markerSnippet = markerSnippet + "\n" + mLikelyPlaceAttributions[position];
            }

            // Add a marker for the selected place, with an info window
            // showing information about that place.
            mMap.addMarker(new MarkerOptions()
                    .title(mLikelyPlaceNames[position])
                    .position(markerLatLng)
                    .snippet(markerSnippet));

           // Position the map's camera at the location of the marker.
            mMap.moveCamera(CameraUpdateFactory.newLatLng(markerLatLng));
        }
    };

ListView को पॉप्युलेट करना

अब आपके पास उन ज़्यादातर जगहों की सूची है जहां उपयोगकर्ता फ़िलहाल जा रहा है. ऐसे में, उन विकल्पों को ListView में उपयोगकर्ता को दिखाया जा सकता है. आपने अभी-अभी जो क्लिक हैंडलर इस्तेमाल किया है उसे इस्तेमाल करने के लिए, आप ListView क्लिक लिसनर भी सेट कर सकते हैं.

क्लिक हैंडलर के बाद इस तरीके को चिपकाएं:

MapsActivity.javafillPlaceList()

    private void fillPlacesList() {
        // Set up an ArrayAdapter to convert likely places into TextViews to populate the ListView
        ArrayAdapter<String> placesAdapter =
                new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, mLikelyPlaceNames);
        lstPlaces.setAdapter(placesAdapter);
        lstPlaces.setOnItemClickListener(listClickedHandler);
    }

अब जब fillPlacesList तय हो गया है, तो findPlaceLikelihoods के आखिर में वह लाइन ढूंढें जो fillPlacesList को कॉल करती है और उस पर टिप्पणी न करे.

MapsActivity.java भरने के लिए लाइकलाइड()

               // COMMENTED OUT UNTIL WE DEFINE THE METHOD
                // Populate the ListView
                fillPlacesList();

यह मौजूदा जगह पिकर के लिए ज़रूरी कोड है!

13. ऐप्लिकेशन चलाएं

कोई जगह चुनने के लिए टेस्ट करें

  1. ऐप्लिकेशन फिर से चलाएं.

इस समय, जब आप जगह चुनें पर टैप करते हैं, तो ऐप्लिकेशन सूची के आस-पास की बताई गई जगहों की जानकारी भर देता है. माउई में इस जगह के पास उल्लानी और #39; हवायन शेव आइस और शुगर बीच बेक शॉप जैसी जगहें हैं. बहुत सारी जगहें, लोकेशन निर्देशांक के काफ़ी करीब हैं. इसलिए, यहां उन जगहों की सूची दी गई है जहां शायद आप जा सकते हैं.

  1. ListView में जगह के नाम पर क्लिक करें.

मैप में आपको एक मार्कर जुड़ा हुआ दिखेगा.

  1. मार्कर पर टैप करें.

आप जगह की जानकारी देख सकते हैं.

e52303cc0de6a513.png 864c74342fb52a01.png

किसी दूसरी जगह की जांच करें

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

इसके बारे में जानने के लिए, मूल Google Maps ऐप्लिकेशन का इस्तेमाल करके एम्युलेटर&#39 की जगह पर अपडेट लागू करें:

  1. Google मानचित्र खोलें.
  2. अक्षांश और देशांतर को नए निर्देशांकों पर बदलने के लिए, ... &g; Location पर टैप करें. इसके बाद, भेजें पर टैप करें.
  3. उदाहरण के लिए, आप डाउनटाउन को कनाडा के वैंकूवर में सेट करने के लिए, अक्षांश: 49.2768 और देशांतर: -123.1142 का इस्तेमाल कर सकते हैं.
  4. पुष्टि करें कि Google Maps ने आपके नए निर्देशांकों को फिर से शामिल किया है. हाल ही के अनुरोध का अनुरोध करने के लिए, आपको Google Maps ऐप्लिकेशन में मेरी जगह बटन पर टैप करना होगा.
  5. अपने मौजूदा स्थान ऐप्लिकेशन पर वापस जाएं और नए निर्देशांकों पर मैप पाने के लिए जगह चुनें पर टैप करें और मौजूदा जगहों की नई सूची देखें.

CANNOT TRANSLATE

इसके साथ ही, काम हो गया! आपने एक आसान ऐप्लिकेशन बनाया है, जो मौजूदा जगह की जगहों की जांच करता है और आपको यह बताता है कि आप किन जगहों पर हैं. आनंद लें!

अब आगे बढ़ें और इस बोनस चरण को पूरा करने के लिए आपने जो बदलाव किए हैं उनसे रन ऐप्लिकेशन चलाएं!

14. अगले चरण

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

अपना SHA-1 प्रमाणपत्र पाएं

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

Linux या macOS के लिए, टर्मिनल विंडो खोलें और ये चीज़ें डालें:

keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

Windows Vista और Windows 7 के लिए, यह निर्देश चलाएं:

keytool -list -v -keystore "%USERPROFILE%\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

आपको इस तरह का आउटपुट दिखेगा:

Alias name: androiddebugkey
Creation date: Jan 01, 2013
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Android Debug, O=Android, C=US
Issuer: CN=Android Debug, O=Android, C=US
Serial number: 4aa9b300
Valid from: Mon Jan 01 08:04:04 UTC 2013 until: Mon Jan 01 18:04:04 PST 2033
Certificate fingerprints:
     MD5:  AE:9F:95:D0:A6:86:89:BC:A8:70:BA:34:FF:6A:AC:F9
     SHA1: BB:0D:AC:74:D3:21:E1:43:07:71:9B:62:90:AF:A1:66:6E:44:5D:75
     Signature algorithm name: SHA1withRSA
     Version: 3

SHA1 से शुरू होने वाली लाइन में प्रमाणपत्र's SHA-1 फ़िंगरप्रिंट होता है. फ़िंगरप्रिंट, कोलन से अलग की गई 20 अंकों वाली हेक्साडेसिमल संख्याओं का क्रम होता है.

जब आप कोई ऐप्लिकेशन रिलीज़ करने के लिए तैयार हों, तो अपना रिलीज़ प्रमाणपत्र पाने के लिए इस दस्तावेज़ में दिए गए निर्देशों का इस्तेमाल करें.

अपनी एपीआई कुंजी में पाबंदियां लगाना

  1. Cloud Console में, एपीआई और सेवाओं; > क्रेडेंशियल पर जाएं.

इस ऐप्लिकेशन के लिए जिस कुंजी का इस्तेमाल किया गया था वह एपीआई कुंजियों के तहत होनी चाहिए.

  1. कुंजी सेटिंग में बदलाव करने के लिए 6454a04865d551e6.png पर क्लिक करें.

316b052c621ee91c.png

  1. एपीआई कुंजी पेज पर, मुख्य पाबंदियों के बाद, ये काम करके ऐप्लिकेशन पाबंदियां सेट करें:
  2. Android ऐप्लिकेशन चुनें और निर्देशों का पालन करें.
  3. कोई आइटम जोड़ें पर क्लिक करें.
  4. अपने पैकेज का नाम और SHA-1 सर्टिफ़िकेट फ़िंगरप्रिंट डालें (पिछले सेक्शन में फिर से किया गया).

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

com.google.codelab.currentplace

BB:0D:AC:74:D3:21:E1:43:07:71:9B:62:90:AF:A1:66:6E:44:5D:75s
  1. ज़्यादा सुरक्षा के लिए, नीचे दिए गए तरीके अपनाकर एपीआई से जुड़ी पाबंदियां सेट करें.
  2. एपीआई पाबंदियों के बाद, कुंजी पर पाबंदी लगाएं चुनें.
  3. Android और जगहें एपीआई के लिए Maps SDK टूल चुनें.
  4. हो गया और सेव करें पर क्लिक करें.

15. बधाई हो

आपने एक आसान ऐप्लिकेशन बनाया है, जो मौजूदा जगह पर सबसे ज़्यादा संभावना वाली जगहों की जांच करता है और उपयोगकर्ता के चुने गए स्थान के लिए मैप में एक मार्कर जोड़ता है.

ज़्यादा जानें