Android के लिए मैप SDK में मैप को झुकाया जा सकता है और आसान जेस्चर से घुमाया जा सकता है, जिससे उपयोगकर्ता के लिए मैप को उनके लिए उपयुक्त ओरिएंटेशन के साथ एडजस्ट करने की सुविधा मिलती है. किसी भी ज़ूम लेवल पर, आप मैप को पैन कर सकते हैं. इसके अलावा, वेक्टर-आधारित मैप टाइल के छोटे फ़ुटप्रिंट की वजह से, इंतज़ार का समय बहुत कम हो सकता है.
कोड सैंपल
GitHub पर ApiDemos डेटा स्टोर करने की जगह में एक नमूना शामिल है, जो कैमरे की सुविधाओं को दिखाता है:
- CameraDemoActivity - Java: कैमरे की जगह बदलना
- CameraDemoActivity - Kotlin: कैमरे की जगह बदलना
सुविधा के बारे में जानकारी
वेब पर Google Maps की तरह, Android के लिए Maps SDK टूल, मीटरेटर प्रोजेक्शन का इस्तेमाल करके आपके डिवाइस की स्क्रीन (एक समतल) पर दुनिया की सतह दिखाता है. पूर्वी और पश्चिमी दिशा में, मैप को असीमित तौर पर दोहराया जाता है, क्योंकि दुनिया अपने-आप घूमती रहती है. उत्तर और उत्तर दिशा में मैप उत्तर में करीब 85 डिग्री और दक्षिण में 85 डिग्री तक सीमित है.
ध्यान दें: मरकेटर प्रोजेक्शन की चौड़ाई देशांतर के हिसाब से बहुत कम होती है. हालांकि, ऊंचाई की सीमा कभी खत्म नहीं होती. मैप को आकार देने के लिए +/- 85 डिग्री पर मर्केटर प्रोजेक्शन का इस्तेमाल करके, आधार मैप की तस्वीरों को "काटा" जाता है. इससे, टाइल चुनने में आसानी होती है.
Android के लिए मैप SDK आपको मैप के कैमरा में बदलाव करके उपयोगकर्ता के व्यूपॉइंट को बदलने की सुविधा देता है.
कैमरे में किए गए बदलाव से, आपके जोड़े हुए मार्कर, ओवरले या दूसरे ग्राफ़िक में कोई बदलाव नहीं होगा. हालांकि, हो सकता है कि किसी नए व्यू के साथ अपने हिसाब से बदलाव करें.
मैप पर उपयोगकर्ता के हाथ के जेस्चर के बारे में सुना जा सकता है. इसलिए, उपयोगकर्ता के अनुरोध के आधार पर मैप में बदलाव किया जा सकता है. जैसे, कॉलबैक मैथड
OnMapClickListener.onMapClick() मैप पर एक बार टैप करके जवाब देता है. जैसे कि विधि को टैप स्थान का अक्षांश और देशांतर मिलता है, इसलिए आप उस बिंदु पर पैन या ज़ूम करके जवाब दे सकते हैं.
मार्कर के बबल पर टैप का जवाब देने या मार्कर पर
खींचने के जेस्चर का जवाब देने के लिए इसी तरह के तरीके उपलब्ध हैं.
साथ ही, आप कैमरा की आवाज़ों को भी सुन सकते हैं, ताकि कैमरे के चालू होने, मौजूदा जगह में हलचल होने या डिवाइस हिलने पर आपके ऐप्लिकेशन को सूचना मिले. ज़्यादा जानकारी के लिए, कैमरा बदलने के इवेंट की गाइड देखें.
कैमरे की स्थिति
मैप व्यू को कैमरा के तौर पर मॉडल किया जाता है, जो सपाट मैदान में नीचे की ओर दिखता है. कैमरे की स्थिति (और इसलिए मैप की रेंडरिंग) नीचे दी गई प्रॉपर्टी से तय की गई है: टारगेट (अक्षांश/देशांतर की जगह),ध्यान रखें, झुकाएं, और ज़ूम करें.
टारगेट (जगह)
कैमरा टारगेट, मैप के बीच की जगह होता है. इसे अक्षांश और देशांतर निर्देशांक के तौर पर दिखाया जाता है.
अक्षांश -85 और 85 डिग्री के बीच हो सकता है. इस रेंज से ऊपर या नीचे की वैल्यू को, इस रेंज के सबसे नज़दीकी वैल्यू के साथ जोड़ दिया जाएगा. उदाहरण के लिए, 100 का अक्षांश तय करने से वैल्यू 85 पर सेट हो जाएगी. देशांतर, -180 से 180 डिग्री के बीच होता है. इस सीमा से ज़्यादा या कम की जाने वाली वैल्यू को रैप किया जाएगा, ताकि वे रेंज (-180, 180) के अंदर आ सकें. जैसे, 480, 840, और 1200 को 120 डिग्री तक रैप किया जाएगा.बियरिंग (ओरिएंटेशन)
कैमरा बेयरिंग, कंपास की दिशा के बारे में बताता है. इसे मैप के ऊपरी किनारे से सच्ची दूरी पर मापा जाता है. अगर आप मैप के केंद्र से मैप के ऊपरी किनारे की ओर एक वर्टिकल लाइन बनाते हैं, तो बियरिंग कैमरे के हेडिंग (डिग्री में मापी गई) के मुताबिक होती है.
0 होने का मतलब है कि मैप का ऊपर वाला हिस्सा सही उत्तर की ओर है. बियरिंग वैल्यू 90 का मतलब है कि मैप पर सबसे ऊपर, पूर्व दिशा में है (कंपास पर 90 डिग्री). वैल्यू 180 का मतलब है मैप पर सबसे ऊपर, दक्षिण की ओर.
Maps API से, मैप के असर को बदला जा सकता है. उदाहरण के लिए, कार चलाने वाला कोई व्यक्ति आम तौर पर सड़क के मैप को यात्रा की दिशा में बदलने के लिए उसे मोड़ता है. हाइकिंग और मैप का इस्तेमाल करने वाले लोग आम तौर पर मैप को दिशा में इस तरह पेश करते हैं कि सीधी रेखा में उत्तर दिशा की तरफ़ जाए.
झुकाव (देखने का कोण)
झुकाव, चाप पर कैमरे की स्थिति को सीधे मैप की मध्य स्थिति पर मापता है, जिसे नादिर से डिग्री में मापा जाता है (कैमरे के ठीक नीचे दिखने वाली दिशा). 0 का मान कैमरे को सीधे नीचे की ओर संकेत करता है. 0 से ज़्यादा मान ऐसे कैमरे के अनुरूप है जिसे डिग्री की तय संख्या से क्षितिज की ओर पिच किया गया है. जब आप व्यूइंग ऐंगल में बदलाव करते हैं, तो मैप सही तरीके से दिखता है. इसमें, दूर से दिखने वाली सुविधाएं पहले से छोटी दिखती हैं और आस-पास की सुविधाएं दिखती हैं. यहां दिए गए इमेज में यह दिखाया गया है.
नीचे दी गई इमेज में, व्यू करने का ऐंगल 0 डिग्री है. पहली इमेज में इसका स्कीमा दिखाया जाता है; रैंक 1 कैमरे की स्थिति है और रैंक 2 मैप की मौजूदा स्थिति है. इसके बाद मिलने वाला मैप इसके नीचे दिखाया जाता है.
|
|
नीचे दी गई इमेज में, व्यू करने का ऐंगल 45 डिग्री है. ध्यान दें कि कैमरा सीधे ऊपर की ओर (0 डिग्री) और ज़मीन (90 डिग्री) के बीच की चाप के पास जाता है और पोज़िशन 3 होता है. कैमरा अब भी मैप के बीच के बिंदु की ओर संकेत कर रहा है, लेकिन स्थिति 4 पर लाइन से दिखाया गया क्षेत्र अब दिखाई दे रहा है.
|
|
इस स्क्रीनशॉट में मौजूद मैप, अब भी उसी जगह पर मौजूद है जो मूल मैप में है. हालांकि, मैप के सबसे ऊपर इसके लिए और सुविधाएं दिखाई गई हैं. जब आप 45 डिग्री से ज़्यादा के कोण को बढ़ाते हैं, तो कैमरे और मैप पर दिखाई जाने वाली जगहों के बीच की सुविधाएं आनुपातिक रूप से बड़ी दिखाई देती हैं, जबकि मैप की स्थिति से परे सुविधाएं आनुपातिक रूप से छोटी दिखाई देती हैं, जिससे तीन-डाइमेंशन वाला प्रभाव मिलता है.
तारीख की सीमा बढ़ाकर
कैमरे का ज़ूम स्तर मैप का स्केल तय करता है. ज़ूम के ज़्यादा लेवल पर, स्क्रीन पर ज़्यादा जानकारी देखी जा सकती है. वहीं, छोटे ज़ूम के लेवल पर, स्क्रीन पर दुनिया के ज़्यादातर हिस्से देखे जा सकते हैं. ज़ूम लेवल 0 पर, मैप का स्केल ऐसा होता है कि पूरी दुनिया की चौड़ाई करीब 256dp (डेंसिटी-इंडिपेंडेंट पिक्सल) है.
ज़ूम लेवल को 1 तक बढ़ाने से, स्क्रीन पर दुनिया की चौड़ाई दोगुनी हो जाती है. इसलिए, ज़ूम लेवल N पर, दुनिया की चौड़ाई करीब 256 * 2N dp है. उदाहरण के लिए, ज़ूम लेवल 2 पर, पूरी दुनिया करीब 1024dp चौड़ी है.
ज़ूम स्तर के लिए पूर्णांक नहीं होना चाहिए. मैप के ज़रिए मंज़ूर किए गए ज़ूम के लेवल की सीमा कई चीज़ों पर निर्भर करती है. इनमें टारगेट, मैप का प्रकार, और स्क्रीन का आकार शामिल हैं. इस सीमा से बाहर का कोई भी नंबर अगले सबसे करीबी मान्य मान में बदल दिया जाएगा, जो या तो कम से कम ज़ूम स्तर या अधिकतम ज़ूम स्तर हो सकता है. नीचे दी गई सूची में, जानकारी का वह अनुमानित लेवल दिखता है जो आपको ज़ूम लेवल पर दिख सकती है:
- 1: दुनिया
- 5: लैंडमास/महाद्वीप
- 10: शहर
- 15: सड़कें
- 20: इमारतें
|
|
|
कैमरा ले जाना
Maps API से यह तय किया जा सकता है कि मैप पर दुनिया का कौनसा हिस्सा दिखे. यह कैमरे की जगह बदलकर (मैप को मूव करने के बजाय) किया जाता है.
जब आप कैमरा बदलते हैं, तो आपके पास नतीजे के तौर पर कैमरे की हलचल को ऐनिमेट करने का विकल्प होता है. ऐनिमेशन, मौजूदा कैमरा एट्रिब्यूट और नए कैमरा एट्रिब्यूट के बीच अंतर दिखाता है. आप ऐनिमेशन की अवधि को भी नियंत्रित कर सकते हैं.
कैमरे की जगह बदलने के लिए, आपको CameraUpdate का इस्तेमाल करके यह बताना होगा कि आप कैमरे को कहां ले जाना चाहते हैं. Maps API की मदद से, CameraUpdateFactory का इस्तेमाल करके कई अलग-अलग तरह के CameraUpdate बनाए जा सकते हैं. फ़िल्टर के लिए, यहां दिए गए विकल्प उपलब्ध होते हैं:
ज़ूम स्तर बदलना और कम से कम/ज़्यादा से ज़्यादा ज़ूम सेट करना
CameraUpdateFactory.zoomIn() और
CameraUpdateFactory.zoomOut()
आपको एक CameraUpdate मिलता है, जो ज़ूम लेवल को 1.0 तक बदल देता है और बाकी सभी प्रॉपर्टी को पहले जैसा ही रखता है.
CameraUpdateFactory.zoomTo(float)
आपको एक CameraUpdate देता है, जो ज़ूम लेवल को दी गई वैल्यू में बदल देता है. साथ ही, बाकी सभी प्रॉपर्टी को पहले जैसा ही रखता है.
CameraUpdateFactory.zoomBy(float)
और
CameraUpdateFactory.zoomBy(float, Point)
आपको एक CameraUpdate मिलता है, जो दी गई वैल्यू से ज़ूम लेवल को बढ़ाता या घटाता है (अगर वैल्यू नेगेटिव है
तो). बाद वाला स्क्रीन पर दिए गए बिंदु को
ठीक करता है ताकि यह उसी स्थान (अक्षांश/देशांतर) पर बना रहे
और इसे प्राप्त करने के लिए कैमरे का स्थान बदल सकता है.
आपके हिसाब से, सबसे कम और/या ज़्यादा से ज़्यादा ज़ूम लेवल सेट करना मददगार हो सकता है. उदाहरण के लिए, अगर आपका ऐप्लिकेशन, लोकप्रिय जगह के आस-पास कोई तय जगह दिखाता है या कस्टम टाइल ओवरले का इस्तेमाल करके ज़ूम लेवल की सीमा तय करता है, तो उपयोगकर्ता के अनुभव को कंट्रोल करना कारगर होगा.
Java
private GoogleMap map;
map.setMinZoomPreference(6.0f);
map.setMaxZoomPreference(14.0f);
Kotlin
private lateinit var map: GoogleMap
map.setMinZoomPreference(6.0f)
map.setMaxZoomPreference(14.0f)
ध्यान दें कि कुछ तकनीकी वजहों से एपीआई, उपयोगकर्ताओं को बहुत कम या बहुत ज़्यादा ज़ूम करने से रोक सकता है. उदाहरण के लिए, उपग्रह या भू-भाग में, आधार मैप टाइलों की तुलना में कम अधिकतम ज़ूम हो सकता है.
कैमरे की स्थिति बदलना
सामान्य स्थान परिवर्तन के लिए सुविधा के दो तरीके हैं.
CameraUpdateFactory.newLatLng(LatLng)
आपको एक CameraUpdate देता है, जो अन्य सभी प्रॉपर्टी को सुरक्षित रखते हुए, कैमरे का अक्षांश और देशांतर बदलता है.
CameraUpdateFactory.newLatLngZoom(LatLng, float)
आपको एक CameraUpdate देता है, जो अन्य सभी प्रॉपर्टी को सुरक्षित रखते हुए कैमरे का अक्षांश, देशांतर, और ज़ूम बदलता है.
कैमरे की जगह को पूरी तरह से बदलने के लिए,
CameraUpdateFactory.newCameraPosition(CameraPosition)
का इस्तेमाल करें. यह आपको CameraUpdate की सुविधा देता है, जो कैमरे को खास जगह पर ले जाता है. new CameraPosition() का इस्तेमाल करके या new CameraPosition.Builder() का इस्तेमाल करके, CameraPosition.Builder वाले CameraPosition कोड को सीधे तौर पर ऐक्सेस किया जा सकता है.
पैन करना (स्क्रोल करना)
CameraUpdateFactory.scrollBy(float, float) आपको CameraUpdate देता है, जो कैमरे के अक्षांश और देशांतर को इस तरह बदलता है कि मैप, पिक्सल की तय संख्या से आगे बढ़ जाए. पॉज़िटिव x मान की वजह से कैमरा दाईं ओर चला जाता है, ताकि ऐसा लगता है कि मैप बाईं ओर चला गया है. सकारात्मक y
मान के आधार पर कैमरा नीचे की ओर जाता है, ताकि ऐसा लगे कि मैप ऊपर चला गया है. इसके उलट, x के नेगेटिव मान देने पर कैमरा बाईं ओर चला जाता है, ऐसा लगता है कि मैप दाईं ओर चला गया है और नेगेटिव y के मान
की वजह से कैमरा ऊपर चला गया है. स्क्रोलिंग, कैमरे के मौजूदा ओरिएंटेशन के हिसाब से होती है. उदाहरण के लिए, अगर कैमरे की असर 90 डिग्री है, तो पूर्व में "ऊपर" माना जाता है.
सीमाएं सेट करना
मैप की सीमाएं सेट करना
कैमरे को कभी-कभी इस तरह ले जाना फ़ायदेमंद होता है, ताकि ज़्यादा से ज़्यादा लोग बेहतर तरीके से ज़ूम कर सकें. उदाहरण के लिए, अगर आप उपयोगकर्ता के वर्तमान स्थान से पांच मील के अंदर सभी पेट्रोल पंप दिखा रहे हैं, तो आप कैमरे को इस तरह से खिसका सकते हैं कि वे सभी स्क्रीन पर दिखाई दें. ऐसा करने के लिए, पहले वह
LatLngBounds कैलकुलेट करें जिसे आप स्क्रीन पर दिखाना चाहते हैं. इसके बाद, CameraUpdateFactory.newLatLngBounds(LatLngBounds bounds, int
padding) का इस्तेमाल करके, ऐसा CameraUpdate लिया जा सकता है जो कैमरे की पोज़िशन में बदलाव करता है. इस तरह, दी गई LatLngBounds, मैप में मौजूद पूरी तरह से फ़िट हो जाती है. इसके लिए, दी गई पैडिंग (जगह) को ध्यान में रखा जाता है. दिया गया CameraUpdate
यह पक्का करता है कि दी गई सीमाओं और मैप के किनारे के बीच का अंतर, तय की गई पैडिंग जितना हो. ध्यान रखें कि मैप का झुकाव और उसका
दोनों होना 0 होगा.
Java
LatLngBounds australiaBounds = new LatLngBounds(
new LatLng(-44, 113), // SW bounds
new LatLng(-10, 154) // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0));
Kotlin
val australiaBounds = LatLngBounds(
LatLng((-44.0), 113.0), // SW bounds
LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0))
किसी क्षेत्र में मैप को केंद्रित करना
कुछ मामलों में, हो सकता है कि आप बहुत ज़्यादा बॉर्डर के बजाय, अपने कैमरे को सीमाओं के अंदर रखें. उदाहरण के लिए, कैमरे को लगातार ज़ूम बनाए रखते हुए कैमरे को बीच में लाने के लिए. इस मामले में, LatLngBounds बनाकर और
CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) के साथ
LatLngBounds का इस्तेमाल करके,
एक जैसे तरीके का इस्तेमाल किया जा सकता है.getCenter() तरीका. getCenter() तरीके से
LatLngBounds का भौगोलिक केंद्र मिलेगा.
Java
LatLngBounds australiaBounds = new LatLngBounds(
new LatLng(-44, 113), // SW bounds
new LatLng(-10, 154) // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.getCenter(), 10));
Kotlin
val australiaBounds = LatLngBounds(
LatLng((-44.0), 113.0), // SW bounds
LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.center, 10f))
मेथड के ओवरलोड होने पर, newLatLngBounds(boundary, width, height,
padding) आपको आयत के हिसाब से पिक्सल में चौड़ाई और ऊंचाई तय करने की सुविधा देता है. इससे यह पता चलता है कि ये मैप के डाइमेंशन से मेल खाते हैं. आयत को इस तरह रखा जाता है कि उसका बीच, मैप के व्यू जैसा ही होता है (ताकि अगर बताए गए डाइमेंशन, मैप के व्यू के डाइमेंशन के समान हों, तो आयत, मैप के व्यू से मेल खाए). CameraUpdate
को लौटाने पर, कैमरे को इस तरह
दिया जाएगा कि बताए गए
LatLngBounds को स्क्रीन पर फ़ोकस किया जाए, ताकि कर्सर को ज़्यादा से ज़्यादा
ज़ूम लेवल पर रखा जा सके. इसके लिए, पैडिंग की ज़रूरत को ध्यान में रखा जाता है.
ध्यान दें: CameraUpdate को जनरेट करने के लिए,
सिर्फ़ आसान तरीके का इस्तेमाल करें. CameraUpdate का इस्तेमाल तब ही किया जा सकता है, जब मैप से लेआउट हटाने के बाद, कैमरे को दूसरी जगह ले जाना हो. लेआउट के दौरान, एपीआई मैप की डिसप्ले सीमाओं का हिसाब लगाता है. ऐसा करने के लिए, बाउंडिंग बॉक्स को सही तरीके से दिखाना ज़रूरी होता है. इसकी तुलना में, मैप के लेआउट से गुज़रने से पहले भी, किसी भी समय
newLatLngBounds(boundary, width, height, padding) के लिए ज़्यादा कॉम्प्लेक्स तरीके से लौटाए गए newLatLngBounds(boundary, width, height, padding) का इस्तेमाल किया जा सकता है, क्योंकि एपीआई आपके पास किए गए तर्कों से डिसप्ले की सीमाओं की गिनती करता है.
किसी दिए गए क्षेत्र में उपयोगकर्ता को पैन करना प्रतिबंधित करना
ऊपर की स्थितियों में, आप मैप की सीमाएं सेट करें, लेकिन उपयोगकर्ता इन सीमाओं के बाहर स्क्रोल या पैन कर सकता है. इसके बजाय, आप मैप के फ़ोकल पॉइंट (कैमरा टारगेट) के अक्षांश/देशांतर केंद्र की सीमाएं तय कर सकते हैं, ताकि उपयोगकर्ता सिर्फ़ इन सीमाओं के अंदर स्क्रोल और पैन कर सकें. उदाहरण के लिए, हो सकता है कि किसी शॉपिंग सेंटर या हवाई अड्डे के लिए बनाया गया कोई खुदरा ऐप्लिकेशन, मैप को किसी खास सीमा तक सीमित करना चाहे, जिससे उपयोगकर्ता उन सीमाओं के अंदर स्क्रोल और पैन कर सकें.
Java
// Create a LatLngBounds that includes the city of Adelaide in Australia.
LatLngBounds adelaideBounds = new LatLngBounds(
new LatLng(-35.0, 138.58), // SW bounds
new LatLng(-34.9, 138.61) // NE bounds
);
// Constrain the camera target to the Adelaide bounds.
map.setLatLngBoundsForCameraTarget(adelaideBounds);
Kotlin
// Create a LatLngBounds that includes the city of Adelaide in Australia.
val adelaideBounds = LatLngBounds(
LatLng(-35.0, 138.58), // SW bounds
LatLng(-34.9, 138.61) // NE bounds
)
// Constrain the camera target to the Adelaide bounds.
map.setLatLngBoundsForCameraTarget(adelaideBounds)
यहां दिया गया डायग्राम, उस स्थिति को दिखाता है जब कैमरे को ऐसे इलाके तक सीमित किया जाता है जो व्यूपोर्ट से थोड़ा बड़ा है. उपयोगकर्ता, स्क्रोल और पैन कर सकता है. हालांकि, ऐसा कैमरे के टारगेट के आस-पास की जगह में ही होना चाहिए. क्रॉस कैमरा लक्ष्य को दर्शाता है:
मैप हमेशा व्यूपोर्ट को पूरा भरता है, भले ही व्यूपोर्ट के ज़रिए तय सीमाओं से बाहर के इलाके दिखाए जाएं. उदाहरण के लिए, अगर आप बाउंड्री वाले इलाके के किसी कोने पर कैमरे को टारगेट करते हैं, तो व्यूपोर्ट में कोने से बाहर का हिस्सा दिखता है, लेकिन उपयोगकर्ता उस हिस्से को और स्क्रोल नहीं कर सकते. इस डायग्राम में इस स्थिति के बारे में बताया गया है. क्रॉस कैमरे के टारगेट को दिखाता है:
नीचे दिए गए डायग्राम में, कैमरे के टारगेट की एक तय सीमा है. इससे उपयोगकर्ता को मैप को स्क्रोल या पैन करने के लिए कम मौके मिलेंगे. क्रॉस कैमरे के टारगेट को दिखाता है:
कैमरा व्यू अपडेट किया जा रहा है
मैप पर CameraUpdate लगाने के लिए, कैमरे को तुरंत ले जाएं या कैमरे को ऐनिमेट करें. CameraUpdate को
तुरंत ले जाने के लिए, GoogleMap.moveCamera(CameraUpdate) पर कॉल करें.
उपयोगकर्ता को बेहतर अनुभव दिया जा सकता है, खास तौर पर बदलावों के बारे में ऐनिमेट करके,
थोड़ी-बहुत मूव करने के लिए. ऐसा करने के लिए, कॉल करने के बजाय
GoogleMap.moveCamera
GoogleMap.animateCamera पर कॉल करें.
मैप आसानी से नए एट्रिब्यूट पर चला जाएगा. इस तरीके का सबसे ज़्यादा फ़ॉर्म,
GoogleMap.animateCamera(cameraUpdate, duration, callback),
तीन आर्ग्युमेंट देता है:
cameraUpdateCameraUpdateबताता है कि कैमरे को कहां ले जाना है.callback- ऐसा ऑब्जेक्ट जो
GoogleMap.CancellableCallbackको लागू करता है. कामों को मैनेज करने के लिए, यह सामान्य इंटरफ़ेस दो तरीकों से `oncancel()` और `onFinish()` के बारे में बताता है. ऐनिमेशन के लिए, इन तरीकों को इन स्थितियों में कॉल किया जाता है:onFinish()- अगर ऐनिमेशन बिना किसी रुकावट के पूरा हो जाता है, तो इसे शुरू किया जाएगा.
onCancel()-
अगर
stopAnimation()को कॉल करके या कैमरे की नई हलचल शुरू करके, ऐनिमेशन में रुकावट पैदा की जाए.इसके अलावा,
GoogleMap.stopAnimation()को कॉल करने पर भी ऐसा हो सकता है.
duration- ऐनिमेशन की मनमुताबिक अवधि, मिलीसेकंड में,
intके तौर पर.
नीचे दिए गए कोड स्निपेट, कैमरे को एक जगह से दूसरी जगह ले जाने के कुछ आम तरीकों के बारे में बताते हैं.
Java
LatLng sydney = new LatLng(-33.88,151.21);
LatLng mountainView = new LatLng(37.4, -122.1);
// Move the camera instantly to Sydney with a zoom of 15.
map.moveCamera(CameraUpdateFactory.newLatLngZoom(sydney, 15));
// Zoom in, animating the camera.
map.animateCamera(CameraUpdateFactory.zoomIn());
// Zoom out to zoom level 10, animating with a duration of 2 seconds.
map.animateCamera(CameraUpdateFactory.zoomTo(10), 2000, null);
// Construct a CameraPosition focusing on Mountain View and animate the camera to that position.
CameraPosition cameraPosition = new CameraPosition.Builder()
.target(mountainView ) // Sets the center of the map to Mountain View
.zoom(17) // Sets the zoom
.bearing(90) // Sets the orientation of the camera to east
.tilt(30) // Sets the tilt of the camera to 30 degrees
.build(); // Creates a CameraPosition from the builder
map.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
Kotlin
val sydney = LatLng(-33.88, 151.21)
val mountainView = LatLng(37.4, -122.1)
// Move the camera instantly to Sydney with a zoom of 15.
map.moveCamera(CameraUpdateFactory.newLatLngZoom(sydney, 15f))
// Zoom in, animating the camera.
map.animateCamera(CameraUpdateFactory.zoomIn())
// Zoom out to zoom level 10, animating with a duration of 2 seconds.
map.animateCamera(CameraUpdateFactory.zoomTo(10f), 2000, null)
// Construct a CameraPosition focusing on Mountain View and animate the camera to that position.
val cameraPosition = CameraPosition.Builder()
.target(mountainView) // Sets the center of the map to Mountain View
.zoom(17f) // Sets the zoom
.bearing(90f) // Sets the orientation of the camera to east
.tilt(30f) // Sets the tilt of the camera to 30 degrees
.build() // Creates a CameraPosition from the builder
map.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))