कैमरा और व्यू

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

कोड सैंपल

GitHub पर मौजूद ApiDemos डेटा स्टोर में एक सैंपल शामिल है, जिसमें कैमरे की सुविधाओं को दिखाया गया है:

• CameraDemoActivity - Kotlin: कैमरे की पोज़िशन बदलना
• CameraDemoActivity - Java: कैमरे की पोज़िशन बदलना

परिचय

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

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

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

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

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

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

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

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

टारगेट (जगह)

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

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

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

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

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

झुकाव (देखने का ऐंगल)

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

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

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

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

ज़ूम करें

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

ज़ूम लेवल को एक लेवल बढ़ाने पर, स्क्रीन पर दुनिया की चौड़ाई दोगुनी हो जाती है. इसलिए, ज़ूम लेवल N पर, दुनिया की चौड़ाई करीब 256 * 2^N डीपी होती है. उदाहरण के लिए, ज़ूम लेवल 2 पर, दुनिया का दायरा करीब 1,024 डीपी होता है.

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

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

उपयोगकर्ता को किसी खास जगह पर पैन करने से रोकना

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

// 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.moveCamera को कॉल करने के बजाय, GoogleMap.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));