कैमरा और व्यू

Android के लिए Maps SDK में उपलब्ध मैप को आसान जेस्चर से झुकाया और घुमाया जा सकता है. इससे उपयोगकर्ता अपने हिसाब से मैप को अपने हिसाब से सेट कर सकते हैं. किसी भी ज़ूम लेवल पर, वेक्टर पर आधारित मैप टाइल के छोटे फ़ुटप्रिंट की वजह से, मैप को पैन किया जा सकता है या बहुत कम इंतज़ार के समय के साथ उसका नतीजा बदला जा सकता है.

कोड सैंपल

GitHub पर ApiDemos रिपॉज़िटरी में एक सैंपल शामिल है, जो कैमरे की सुविधाओं को दिखाता है:

• CameraDemoActivity - Kotlin: कैमरे की स्थिति बदलना
• CameraDemoActivity - Java: कैमरे की स्थिति बदलना

शुरुआती जानकारी

वेब पर Google Maps की तरह, Android के लिए Maps SDK टूल मर्केटर प्रोजेक्शन का इस्तेमाल करके, आपके डिवाइस की स्क्रीन (एक गोल आकार) को दिखाता है. पूर्व और पश्चिम दिशा में, मैप को असीमित समय के लिए दोहराया जाता है. ऐसा इसलिए होता है, क्योंकि दुनिया अपने-आप में पूरी तरह घूम जाती है. उत्तर और दक्षिण दिशा में मैप का तापमान करीब 85 डिग्री उत्तर और दक्षिण दिशा में 85 डिग्री तक होता है.

ध्यान दें: मर्केटर प्रोजेक्शन में देशांतर की सीमा सीमित होती है, लेकिन अक्षांश और देशांतर के हिसाब से इसकी ऊंचाई असीमित होती है. हम मरकेटर प्रोजेक्शन के आधार पर करीब +/- 85 डिग्री का इस्तेमाल करके, बुनियादी मैप की तस्वीरों को "कट" देते हैं. इससे, बनने वाले मैप का आकार वर्गाकार हो जाता है, जिससे टाइल चुनना आसान हो जाता है.

Android के लिए Maps SDK टूल की मदद से, मैप के कैमरे में बदलाव करके, मैप को देखने वाले लोगों का व्यू पॉइंट बदला जा सकता है.

कैमरे में होने वाले बदलाव से मार्कर, ओवरले या जोड़े गए अन्य ग्राफ़िक में कोई बदलाव नहीं होगा. हालांकि, जोड़े गए कॉन्टेंट को नए व्यू के हिसाब से बेहतर बनाया जा सकता है.

मैप पर उपयोगकर्ता के जेस्चर सुने जा सकते हैं. इसलिए, उपयोगकर्ता के अनुरोधों के मुताबिक मैप में बदलाव किया जा सकता है. उदाहरण के लिए, कॉलबैक का तरीका OnMapClickListener.onMapClick() मैप पर एक बार टैप करने पर रिस्पॉन्स देता है. तरीके को टैप किए जाने की जगह का अक्षांश और देशांतर मिलता है. इसलिए, उस पॉइंट पर पैन या ज़ूम करके जवाब दिया जा सकता है. मार्कर के बबल पर टैप करने या मार्कर पर खींचने के लिए इस्तेमाल होने वाले जेस्चर का रिस्पॉन्स देने के लिए, इसी तरह के तरीके उपलब्ध हैं.

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

कैमरे की स्थिति

मैप व्यू को कैमरे की तरह दिखाया गया है, जो सपाट सतह पर नीचे की ओर दिखता है. कैमरे की स्थिति (और इसलिए मैप की रेंडरिंग) इन प्रॉपर्टी से तय होती है: टारगेट (अक्षांश/देशांतर की जगह), बेयरिंग, झुकना, और ज़ूम करें.

टारगेट (जगह)

कैमरा टारगेट, मैप के बीच की जगह होती है. इसे अक्षांश और देशांतर निर्देशांक के हिसाब से तय किया जाता है.

बियरिंग (ओरिएंटेशन)

कैमरा बेयरिंग, कंपास की दिशा के बारे में बताता है, जिसे सही उत्तर से डिग्री में मापा जाता है. यह मैप के ऊपरी किनारे के हिसाब से होता है. अगर मैप के बीच से मैप के ऊपरी किनारे तक एक वर्टिकल लाइन बनाई जाती है, तो बियरिंग, कैमरे के हेडिंग (डिग्री में मापी गई) के हिसाब से होगी.

0 के बेयरिंग का मतलब है कि मैप का ऊपरी हिस्सा उत्तर की ओर है. बियरिंग की वैल्यू 90 होने का मतलब है कि मैप का सबसे ऊपरी हिस्सा, पूर्व दिशा में दिखता है (कपास पर 90 डिग्री). वैल्यू 180 का मतलब है, मैप पॉइंट का सबसे ऊपर वाला हिस्सा, जो आपको दक्षिण की ओर है.

Maps API की मदद से, मैप के बियरिंग में बदलाव किया जा सकता है. उदाहरण के लिए, अगर कोई व्यक्ति कार चलाता है, तो वह अक्सर रोड मैप को बदल देता है, ताकि वह अपनी यात्रा की दिशा के साथ अलाइन हो सके. वहीं, हाइकर मैप का इस्तेमाल करके मैप को इस तरह से घुमाते हैं कि एक वर्टिकल लाइन उत्तर की ओर हो.

झुकाएं (देखने का कोण)

झुकाव, आर्क पर कैमरे की पोज़िशन को सीधे मैप के बीच की पोज़िशन पर दिखाता है. इसे नीचे (कैमरे के ठीक नीचे दिखने वाली दिशा) से डिग्री में मापा जाता है. 0 वैल्यू कैमरे को सीधे नीचे की ओर रखने वाले कैमरे से दिखाती है. 0 से ज़्यादा वैल्यू ऐसे कैमरे से जुड़ी होती हैं जिसे तय की गई डिग्री से क्षितिज की ओर पिच किया जाता है. जब आप व्यूइंग ऐंगल बदलते हैं, तो मैप सामने की तरफ़ दिखता है. इसमें दूर की चीज़ें दिखती हैं, लेकिन आस-पास की चीज़ें ज़्यादा दिखती हैं. नीचे दिए गए इलस्ट्रेशन में यह दिखाया गया है.

नीचे दी गई इमेज में, देखने का ऐंगल 0 डिग्री है. पहली इमेज में इसका स्कीमा दिखाया गया है. रैंक 1 कैमरे की पोज़िशन है और मैप की मौजूदा पोज़िशन 2 है. इससे बनने वाला मैप इसके नीचे दिखाया गया है.

नीचे दी गई इमेज में, देखने का ऐंगल 45 डिग्री है. ध्यान दें कि कैमरा सीधे ऊपर के सिर (0 डिग्री) और ज़मीन (90 डिग्री) के बीच चाप के बीच में 3 मूव करता है. कैमरे को अब भी मैप के बीचो-बीच दिखाया गया है, लेकिन अब जगह 4 पर लाइन से दिखाया गया इलाका दिख रहा है.

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

ज़ूम करना

कैमरे का ज़ूम लेवल, मैप का स्केल तय करता है. बड़े ज़ूम लेवल पर स्क्रीन पर ज़्यादा जानकारी देखी जा सकती है. वहीं, छोटे ज़ूम लेवल पर स्क्रीन पर ज़्यादा जानकारी देखी जा सकती है. ज़ूम लेवल 0 पर, मैप का स्केल ऐसा होता है कि पूरी दुनिया की चौड़ाई करीब 256dp (डेंसिटी-इंडिपेंडेंट पिक्सल) होती है.

ज़ूम के लेवल को 1 बढ़ाने से, स्क्रीन पर मौजूद दुनिया की चौड़ाई दोगुनी हो जाती है. इसलिए, ज़ूम लेवल N पर, दुनिया की चौड़ाई करीब 256 * 2^N 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 मिलता है, जो ज़ूम लेवल को दी गई वैल्यू के हिसाब से बढ़ाता या घटाता है. ऐसा तब होता है, जब वैल्यू नेगेटिव होने पर यह घटती है. बाद वाला पॉइंट, स्क्रीन पर दिए गए पॉइंट को इस तरह से ठीक करता है कि वह समान जगह (अक्षांश/देशांतर) पर ही रहे, ताकि इसे पाने के लिए कैमरे की जगह में बदलाव किया जा सके.

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

private lateinit var map: GoogleMap

    map.setMinZoomPreference(6.0f)
    map.setMaxZoomPreference(14.0f)

      

private GoogleMap map;
    map.setMinZoomPreference(6.0f);
    map.setMaxZoomPreference(14.0f);

      

ध्यान दें कि कुछ तकनीकी पहलुओं की वजह से हो सकता है कि एपीआई, उपयोगकर्ताओं को बहुत कम या बहुत ज़्यादा ज़ूम करने की अनुमति न दे. उदाहरण के लिए, सैटलाइट या इलाके की जानकारी में, बेस मैप की टाइल की तुलना में ज़्यादा से ज़्यादा ज़ूम कम हो सकता है.

कैमरे की जगह बदली जा रही है

जगह में आम तौर पर किए जाने वाले बदलावों के लिए सुविधा के दो तरीके हैं. CameraUpdateFactory.newLatLng(LatLng) से आपको एक CameraUpdate मिलता है, जो कैमरे के अक्षांश और देशांतर को बदलता है. साथ ही, दूसरी सभी प्रॉपर्टी को सुरक्षित रखता है. CameraUpdateFactory.newLatLngZoom(LatLng, float) से आपको एक CameraUpdate मिलता है, जो कैमरे के अक्षांश, देशांतर, और ज़ूम में बदलाव करता है. साथ ही, इससे बाकी सभी प्रॉपर्टी पर असर पड़ता है.

कैमरे की जगह को पूरी तरह से बदलने के लिए, CameraUpdateFactory.newCameraPosition(CameraPosition) का इस्तेमाल करें. यह CameraUpdate मिलने पर, कैमरा तय की गई पोज़िशन पर चला जाता है. CameraPosition को सीधे, new CameraPosition() का इस्तेमाल करके या new CameraPosition.Builder() का इस्तेमाल करके CameraPosition.Builder की मदद से लिया जा सकता है.

पैन करना (स्क्रोल करना)

CameraUpdateFactory.scrollBy(float, float) से आपको कैमरे के अक्षांश और देशांतर में बदलाव करने के लिए CameraUpdate मिलता है. इससे मैप में पिक्सल की तय संख्या के हिसाब से मूव करता है. पॉज़िटिव x वैल्यू से कैमरा दाईं ओर मूव हो जाता है, ताकि मैप बाईं ओर मूव हो जाए. पॉज़िटिव y वैल्यू की वजह से कैमरा नीचे की ओर खिसक जाता है, ताकि मैप ऊपर की ओर खिसक गया हो. इसके उलट, नेगेटिव x वैल्यू की वजह से कैमरा बाईं ओर मूव हो जाता है. इससे ऐसा लगता है कि मैप दाईं ओर खिसक गया है और नेगेटिव y वैल्यू की वजह से कैमरा ऊपर की ओर चला गया है. स्क्रोलिंग कैमरे के मौजूदा ओरिएंटेशन के हिसाब से होती है. उदाहरण के लिए, अगर कैमरे का बियरिंग 90 डिग्री है, तो पूर्व की ओर, "ऊपर" होगा.

सीमाएं तय करना

मैप की सीमाएं सेट करना

कभी-कभी कैमरे को इस तरह से मूव करना, ताकि आपकी पसंद का पूरा एरिया, ज़ूम के ज़्यादा से ज़्यादा लेवल पर दिखे. उदाहरण के लिए, अगर उपयोगकर्ता की मौजूदा जगह से पांच मील के अंदर सभी पेट्रोल पंप दिखाए जा रहे हैं, तो कैमरे को इस तरह से मूव करें कि वे स्क्रीन पर दिखें. ऐसा करने के लिए, पहले उस LatLngBounds को कैलकुलेट करें जिसे आपको स्क्रीन पर दिखाना है. इसके बाद, CameraUpdateFactory.newLatLngBounds(LatLngBounds bounds, int padding) का इस्तेमाल करके CameraUpdate पाएं, जो कैमरे की पोज़िशन को इस तरह बदलता है कि दिया गया LatLngBounds, मैप में पूरी तरह फ़िट हो जाए. इसके लिए, बताई गई पैडिंग (पिक्सल में) को भी ध्यान में रखा जाएगा. लौटाया गया CameraUpdate, यह पक्का करता है कि मैप की दी गई सीमाओं और मैप के किनारे के बीच का अंतराल (पिक्सल में) कम से कम, तय की गई पैडिंग (जगह) के बराबर होगा. ध्यान दें कि मैप का झुकाव और बियरिंग, दोनों 0 होंगे.

val australiaBounds = LatLngBounds(
    LatLng((-44.0), 113.0),  // SW bounds
    LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0))

      

LatLngBounds australiaBounds = new LatLngBounds(
    new LatLng(-44, 113), // SW bounds
    new LatLng(-10, 154)  // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0));

      

मैप को किसी क्षेत्र में केंद्रित करना

कुछ मामलों में, हो सकता है कि आप कैमरे को एक्सट्रीम बॉर्डर के बजाय, एक सीमा के अंदर रखना चाहें. उदाहरण के लिए, लगातार ज़ूम बनाए रखते हुए किसी देश पर कैमरे को फ़ोकस करना. इस मामले में, LatLngBounds बनाकर और LatLngBounds के साथ CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) का इस्तेमाल करके, मिलता-जुलता तरीका इस्तेमाल किया जा सकता है.getCenter() तरीका. getCenter() तरीका, LatLngBounds का भौगोलिक केंद्र दिखाएगा.

val australiaBounds = LatLngBounds(
    LatLng((-44.0), 113.0),  // SW bounds
    LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.center, 10f))

      

LatLngBounds australiaBounds = new LatLngBounds(
    new LatLng(-44, 113), // SW bounds
    new LatLng(-10, 154)  // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.getCenter(), 10));

      

तरीके के ओवरलोड से, newLatLngBounds(boundary, width, height, padding) की मदद से किसी रेक्टैंगल के लिए, पिक्सल में चौड़ाई और ऊंचाई तय की जा सकती है. इसका मकसद, मैप के डाइमेंशन से मेल खाना होता है. आयत को इस तरह से सही जगह पर रखा जाता है कि उसका केंद्र, मैप के व्यू के केंद्र जैसा ही हो (ताकि अगर बताए गए डाइमेंशन और मैप के व्यू के डाइमेंशन एक जैसे हों, तो आयत का मिलान मैप के व्यू से होगा). वापस दिखाया गया CameraUpdate, कैमरे को इस तरह मूव करेगा कि LatLngBounds दिए गए रेक्टैंगल में, सबसे ज़्यादा ज़ूम लेवल पर स्क्रीन के बीच में हों. इसके लिए, ज़रूरी पैडिंग (जगह) को ध्यान में रखा जाएगा.

ध्यान दें: CameraUpdate जनरेट करने के लिए, सबसे आसान तरीके newLatLngBounds(boundary, padding) का ही इस्तेमाल करें. ऐसा तब ही करें, जब मैप का लेआउट बदलने के बाद कैमरे को मूव करने के लिए इसका इस्तेमाल किया जा रहा हो. लेआउट के दौरान एपीआई, मैप की डिसप्ले सीमाओं का हिसाब लगाता है. ये सीमाएं बाउंडिंग बॉक्स को सही तरीके से प्रोजेक्ट करने के लिए ज़रूरी होती हैं. इसके मुकाबले, ज़्यादा मुश्किल तरीके से दिए गए CameraUpdate को किसी भी समय इस्तेमाल किया जा सकता है. newLatLngBounds(boundary, width, height, padding) का इस्तेमाल, मैप के लेआउट में बदलाव होने से पहले ही किया जा सकता है. ऐसा इसलिए किया जाता है, क्योंकि एपीआई आपके पास किए गए आर्ग्युमेंट की मदद से, डिसप्ले की सीमाओं का आकलन करता है.

उपयोगकर्ता को किसी इलाके में पैन करने पर पाबंदी लगाना

ऊपर दी गई स्थितियों में, मैप की सीमाएं सेट की जाती हैं. हालांकि, उपयोगकर्ता इन सीमाओं के बाहर स्क्रोल या पैन कर सकता है. इसके बजाय, मैप के फ़ोकल पॉइंट (कैमरे का टारगेट) के अक्षांश/देशांतर की सीमाओं को तय करें, ताकि उपयोगकर्ता सिर्फ़ इन सीमाओं में स्क्रोल और पैन कर सकें. उदाहरण के लिए, हो सकता है कि किसी शॉपिंग सेंटर या हवाई अड्डे के लिए रीटेल ऐप्लिकेशन में मैप को एक खास सीमा तक ही सीमित रखा जाए, ताकि उपयोगकर्ता उन सीमाओं में स्क्रोल और पैन कर सकें.

// 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)

      

// 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);

      

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

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

नीचे दिए गए डायग्राम में, कैमरे के टारगेट की सीमाएं बहुत सीमित हैं. इससे उपयोगकर्ता को मैप को स्क्रोल या पैन करने का बहुत कम मौका मिलता है. क्रॉस, कैमरे के टारगेट को दिखाता है:

कैमरा व्यू को अपडेट किया जा रहा है

मैप पर CameraUpdate लागू करने के लिए, कैमरे को तुरंत मूव किया जा सकता है या कैमरे को आसानी से ऐनिमेट किया जा सकता है. कैमरे को दिए गए CameraUpdate से तुरंत मूव करने के लिए, GoogleMap.moveCamera(CameraUpdate) को कॉल करें.

आपके पास बदलाव को ऐनिमेट करके, खास तौर पर छोटी-छोटी चीज़ों में उपयोगकर्ता अनुभव को बेहतर बनाने का विकल्प है. ऐसा करने के लिए, GoogleMap.moveCameraGoogleMap.animateCamera को कॉल करें. नया मैप आसानी से नए एट्रिब्यूट का इस्तेमाल करने लगेगा. इस तरीके के सबसे ज़्यादा जानकारी वाले रूप, GoogleMap.animateCamera(cameraUpdate, duration, callback) में तीन तर्क दिए गए हैं:

cameraUpdate

CameraUpdate में बताया गया है कि कैमरे को कहां ले जाना है.

callback

एक ऑब्जेक्ट जो GoogleMap.CancellableCallback को लागू करता है. टास्क को मैनेज करने के लिए बना यह सामान्य इंटरफ़ेस, दो तरीकों `onCancel()` और `onFinished()` के बारे में बताता है. ऐनिमेशन के लिए, इन तरीकों को इन स्थितियों में कॉल किया जाता है:

onFinish()

यह तब लागू होता है, जब ऐनिमेशन बिना किसी रुकावट के पूरा हो जाता है.

onCancel()

stopAnimation() को कॉल करने या कैमरे की नई गतिविधि शुरू करने पर ऐनिमेशन में रुकावट आने पर शुरू किया गया.

इसके अलावा, GoogleMap.stopAnimation() को कॉल करने पर भी ऐसा हो सकता है.

duration

int के तौर पर, ऐनिमेशन की अवधि, मिलीसेकंड में.

नीचे दिए गए कोड स्निपेट में, कैमरे को एक जगह से दूसरी जगह ले जाने के कुछ सामान्य तरीके बताए गए हैं.

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))

      

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));