इस विषय में बताया गया है कि Android के लिए Maps SDK टूल का इस्तेमाल करने के लिए, प्रोजेक्ट को कॉन्फ़िगर करने के बाद, किसी Android ऐप्लिकेशन में बेसिक मैप कैसे जोड़ा जा सकता है. कोई मैप जोड़ने के बाद, आप मैप का प्रकार और सुविधाएं बदल सकते हैं.
खास जानकारी
Android के लिए Maps SDK टूल से कई ऐसी क्लास की सुविधाएं मिलती हैं जिनका इस्तेमाल करके आपका ऐप्लिकेशन, मैप की लाइफ़साइकल, सुविधा, और डेटा मैनेज कर सकता है. क्लास, Android यूज़र इंटरफ़ेस (यूआई) मॉडल के आधार पर उपयोगकर्ता के इंटरैक्शन का समर्थन करती हैं, जैसे कि मैप की शुरुआती स्थिति सेट करना और रनटाइम के समय उपयोगकर्ता के हाथ के जेस्चर इनपुट का जवाब देना.
मैप हैंडल करने के लिए मुख्य इंटरफ़ेस और क्लास:
GoogleMap— मैप की सुविधाओं और डेटा को मैनेज करने का एंट्री पॉइंट. आपका ऐप्लिकेशनSupportMapFragmentयाMapViewऑब्जेक्ट से मिलने के बाद ही,GoogleMapऑब्जेक्ट को ऐक्सेस कर सकता है.SupportMapFragment—GoogleMapऑब्जेक्ट की लाइफ़साइकल को मैनेज करने के लिए एक फ़्रैगमेंट.MapView— किसीGoogleMapऑब्जेक्ट की लाइफ़साइकल को मैनेज करने के लिए व्यू.OnMapReadyCallback— यह एक कॉलबैक इंटरफ़ेस है, जोGoogleMapऑब्जेक्ट के लिए इवेंट और उपयोगकर्ता इंटरैक्शन को मैनेज करता है.
GoogleMap ऑब्जेक्ट अपने-आप ये कार्रवाइयां करता है:
- Google Maps सेवा से कनेक्ट किया जा रहा है.
- मैप टाइल डाउनलोड हो रही हैं.
- डिवाइस की स्क्रीन पर टाइल दिखाई जा रही हैं.
- पैन और ज़ूम जैसे कई तरह के कंट्रोल दिखाना.
- मैप को हिलाकर और ज़ूम इन या ज़ूम आउट करके, पैन और ज़ूम जेस्चर का जवाब देना.
अपने ऐप्लिकेशन में किसी GoogleMap ऑब्जेक्ट का उपयोग करने के लिए, आपको
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")
)
}
जब आप ऐप्लिकेशन को बनाएं और चलाएं, तो यह 'शून्य द्वीप समूह' पर मार्कर के साथ एक मैप दिखाएगा. इसमें शून्य डिग्री वाला अक्षांश और शून्य डिग्री वाला देशांतर शामिल है.
पूरी गतिविधि के लिए कोड देखें:
आगे क्या
इन चरणों को पूरा करने के बाद, मैप की सेटिंग कॉन्फ़िगर की जा सकती है.