इस विषय में बताया गया है कि Android के लिए Maps SDK टूल का इस्तेमाल करने के लिए, प्रोजेक्ट को कॉन्फ़िगर करने के बाद, Android ऐप्लिकेशन में बुनियादी मैप कैसे जोड़ा जा सकता है. मैप जोड़ने के बाद, मैप का टाइप और सुविधाएं बदली जा सकती हैं.
खास जानकारी
Android के लिए Maps SDK टूल ऐसी कई कक्षाएं उपलब्ध कराता है जिनकी मदद से आपका ऐप्लिकेशन, मैप की लाइफ़साइकल, उसके फ़ंक्शन, और डेटा को मैनेज कर सकता है. ये क्लास, Android यूज़र इंटरफ़ेस (यूआई) मॉडल के आधार पर उपयोगकर्ता के इंटरैक्शन की सुविधा देती हैं. जैसे, मैप की शुरुआती स्थिति सेट करना, और रनटाइम के दौरान उपयोगकर्ता के जेस्चर इनपुट का जवाब देना.
मैप को हैंडल करने का मुख्य इंटरफ़ेस और क्लास:
GoogleMap— यह मैप की सुविधाओं और डेटा को मैनेज करने का एंट्री पॉइंट है. आपका ऐप्लिकेशनSupportMapFragmentयाMapViewऑब्जेक्ट से वापस पाने के बाद ही, सिर्फ़GoogleMapऑब्जेक्ट को ऐक्सेस कर सकता है.SupportMapFragment—GoogleMapऑब्जेक्ट की लाइफ़साइकल मैनेज करने के लिए, फ़्रैगमेंट.MapView— किसीGoogleMapऑब्जेक्ट के लाइफ़साइकल को मैनेज करने के लिए, व्यू.OnMapReadyCallback— यह एक कॉलबैक इंटरफ़ेस है, जोGoogleMapऑब्जेक्ट के लिए इवेंट और उपयोगकर्ता इंटरैक्शन को हैंडल करता है.
GoogleMap ऑब्जेक्ट अपने-आप ये कार्रवाइयां करता है:
- Google मैप सेवा से कनेक्ट किया जा रहा है.
- मैप टाइल डाउनलोड हो रही हैं.
- डिवाइस की स्क्रीन पर टाइल दिखाई जा रही हैं.
- पैन और ज़ूम जैसे अलग-अलग कंट्रोल दिखाना.
- मैप को मूव करके या ज़ूम आउट करके, पैन और ज़ूम जेस्चर का जवाब देना.
अपने ऐप्लिकेशन में GoogleMap ऑब्जेक्ट का इस्तेमाल करने के लिए, आपको
SupportMapFragment के लिए SupportMapFragment ऑब्जेक्ट या कंटेनर ऑब्जेक्ट के तौर पर MapView ऑब्जेक्ट इस्तेमाल करना होगा. इसके बाद,
कंटेनर से GoogleMap ऑब्जेक्ट हासिल करना होगा. कंटेनर क्लास, Android फ़्रैगमेंट या व्यू से मिलती हैं, इसलिए वे मैप को लाइफ़साइकल मैनेजमेंट और अपने Android बेस क्लास की यूज़र इंटरफ़ेस (यूआई) क्षमताओं के साथ मुहैया कराती हैं.
SupportMapFragment क्लास,
GoogleMap ऑब्जेक्ट के लिए ज़्यादा आधुनिक और सामान्य कंटेनर है.
कोड देखें
यह कोड, पूरी तरह से फ़्रैगमेंट जोड़ते समय, इस विषय में इस्तेमाल की गई पूरी Java गतिविधि से लिया गया है. Android प्रोजेक्ट को खाली प्रोजेक्ट टेंप्लेट से बनाया गया था और फिर प्रोजेक्ट कॉन्फ़िगरेशन गाइड के आधार पर अपडेट किया गया. इस विषय में दिए गए चरणों को पूरा करने के बाद, प्रोजेक्ट टेंप्लेट के आधार पर आपके कोड में अंतर हो सकता है.
package com.example.mapsetup;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
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;
// Implement OnMapReadyCallback.
public class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Set the layout file as the content view.
setContentView(R.layout.activity_main);
// Get a handle to the fragment and register the callback.
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
.findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
}
// Get a handle to the GoogleMap object and display marker.
@Override
public void onMapReady(GoogleMap googleMap) {
googleMap.addMarker(new MarkerOptions()
.position(new LatLng(0, 0))
.title("Marker"));
}
}
मैप जोड़ने के लिए
इस सेक्शन में यह बताया गया है कि मैप कंटेनर के तौर पर फ़्रैगमेंट का इस्तेमाल करके, बुनियादी मैप कैसे जोड़ें. हालांकि, इसके बजाय व्यू का इस्तेमाल किया जा सकता है. उदाहरण के लिए, GitHub पर RawMapViewDemoActivity देखें.
बुनियादी तरीका:
SDK टूल पाने, एपीआई कुंजी पाने, और ज़रूरी फ़्रेमवर्क जोड़ने के लिए, यह तरीका अपनाएं:
उस गतिविधि में
SupportMapFragmentऑब्जेक्ट जोड़ें जो मैप को मैनेज करेगा. फ़्रैगमेंट को स्टैटिक या डाइनैमिक तरीके से जोड़ा जा सकता है.OnMapReadyCallbackइंटरफ़ेस लागू करें.कॉन्टेंट व्यू के रूप में लेआउट फ़ाइल सेट करें.
फ़्रैगमेंट को स्टैटिक तरीके से जोड़ने पर, फ़्रैगमेंट को हैंडल मिलता है.
कॉलबैक रजिस्टर करें.
GoogleMapऑब्जेक्ट के लिए एक हैंडल पाएं.
SupportMapFragment ऑब्जेक्ट जोड़ें
आप अपने ऐप्लिकेशन में स्टैटिक या डाइनैमिक तरीके से SupportMapFragment ऑब्जेक्ट जोड़ सकते हैं.
सबसे आसान तरीका है कि इसे स्टैटिक तरीके से जोड़ें. फ़्रैगमेंट को डाइनैमिक तौर पर जोड़ने पर,
फ़्रैगमेंट पर अन्य कार्रवाइयां की जा सकती हैं. जैसे, उसे रनटाइम के दौरान हटाना और
बदलना.
फ़्रैगमेंट को आंकड़ों के तौर पर जोड़ने के लिए
उस गतिविधि की लेआउट फ़ाइल में जो मैप को मैनेज करेगी:
fragmentएलिमेंट जोड़ें.- नाम का एलान जोड़ें
xmlns:map="http://schemas.android.com/apk/res-auto". यहmapsकस्टम एक्सएमएल एट्रिब्यूट के इस्तेमाल की अनुमति देता है. fragmentएलिमेंट में,android:nameएट्रिब्यूट कोcom.google.android.gms.maps.SupportMapFragmentपर सेट करें.fragmentएलिमेंट में,android:idएट्रिब्यूट जोड़ें और उसे R.id.map रिसॉर्स आईडी (@+id/map) पर सेट करें.
उदाहरण के लिए, यहां एक पूरी लेआउट फ़ाइल दी गई है, जिसमें fragment एलिमेंट शामिल है:
<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:map="http://schemas.android.com/apk/res-auto"
android:name="com.google.android.gms.maps.SupportMapFragment"
android:id="@+id/map"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
फ़्रैगमेंट को डाइनैमिक तौर पर जोड़ने के लिए
गतिविधि में:
SupportMapFragmentइंस्टेंस बनाएं.- गतिविधि में फ़्रैगमेंट जोड़ने वाला लेन-देन करें. ज़्यादा जानकारी के लिए, फ़्रैगमेंट से जुड़े लेन-देन देखें.
उदाहरण के लिए:
Java
SupportMapFragment mapFragment = SupportMapFragment.newInstance();
getSupportFragmentManager()
.beginTransaction()
.add(R.id.my_container, mapFragment)
.commit();
Kotlin
val mapFragment = SupportMapFragment.newInstance()
supportFragmentManager
.beginTransaction()
.add(R.id.my_container, mapFragment)
.commit()
OnMapReadyCallback इंटरफ़ेस लागू करें
गतिविधि के एलान का तरीका अपडेट करें:
Java
class MainActivity extends AppCompatActivity implements OnMapReadyCallback {
// ...
}
Kotlin
class MainActivity : AppCompatActivity(), OnMapReadyCallback {
// ...
}
कॉन्टेंट व्यू सेट करना
अपनी गतिविधि के onCreate तरीके में, setContentView मैथड को कॉल करें और लेआउट फ़ाइल को कॉन्टेंट व्यू के तौर पर सेट करें.
उदाहरण के लिए, अगर लेआउट फ़ाइल का नाम main.xml है, तो:
Java
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
Kotlin
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.main)
}
फ़्रैगमेंट का हैंडल पाएं और कॉलबैक को रजिस्टर करें
फ़्रैगमेंट में हैंडल पाने के लिए,
FragmentManager.findFragmentByIdमैथड को कॉल करें और उसे अपनी लेआउट फ़ाइल में फ़्रैगमेंट का रिसॉर्स आईडी पास करें. फ़्रैगमेंट को डाइनैमिक तौर पर जोड़ा गया हो, तो इस चरण को छोड़ दें. ऐसा इसलिए, क्योंकि आपने पहले ही हैंडल वापस ले लिया है.फ़्रैगमेंट पर कॉलबैक सेट करने के लिए,
getMapAsyncमैथड को कॉल करें.
उदाहरण के लिए, अगर आपने फ़्रैगमेंट को स्टैटिक तौर पर जोड़ा है, तो:
Java
SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager()
.findFragmentById(R.id.map);
mapFragment.getMapAsync(this);
Kotlin
val mapFragment = supportFragmentManager
.findFragmentById(R.id.map) as SupportMapFragment
mapFragment.getMapAsync(this)
GoogleMap ऑब्जेक्ट के लिए हैंडल पाएं
GoogleMapऑब्जेक्ट को हैंडल करने के लिए, onMapReady कॉलबैक मैथड का इस्तेमाल करें. कॉलबैक तब ट्रिगर होता है, जब मैप, उपयोगकर्ता का इनपुट पाने के लिए तैयार हो. यह GoogleMap क्लास का गैर-शून्य इंस्टेंस देता है. इसका इस्तेमाल मैप को अपडेट करने के लिए किया जा सकता है.
इस उदाहरण में, onMapReady कॉलबैक GoogleMap ऑब्जेक्ट के लिए एक हैंडल वापस लाता है और फिर मैप में एक मार्कर जोड़ा जाता है:
Java
@Override
public void onMapReady(GoogleMap googleMap) {
googleMap.addMarker(new MarkerOptions()
.position(new LatLng(0, 0))
.title("Marker"));
}
Kotlin
override fun onMapReady(googleMap: GoogleMap) {
googleMap.addMarker(
MarkerOptions()
.position(LatLng(0.0, 0.0))
.title("Marker")
)
}
जब आप ऐप्लिकेशन को बनाने और चलाने का काम पूरा करेंगे, तब वह न्यूल द्वीप पर मार्कर (शून्य डिग्री अक्षांश और शून्य डिग्री देशांतर) के साथ एक मैप दिखाएगा.
पूरी गतिविधि के लिए कोड देखें:
आगे क्या
इन चरणों को पूरा करने के बाद, मैप की सेटिंग कॉन्फ़िगर की जा सकती है.