कैमरा और व्यू

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 डिग्री है. ध्यान दें कि कैमरा 3 पोज़िशन पर जाने के लिए, सीधे ऊपर (0 डिग्री) और ज़मीन (90 डिग्री) के बीच आर्क के आधे हिस्से तक चलता है. कैमरा अब भी मैप के केंद्र बिंदु की ओर इशारा कर रहा है, लेकिन इलाका अब आपको 4 स्थिति की लाइन से दिखाया जाएगा.

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

ज़ूम करें

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

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

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

• 1: दुनिया
• 5: देश/इलाका/महाद्वीप
• 10: शहर
• 15: सड़कें
• 20: बिल्डिंग

कैमरे को मूव करना

Maps API से आप यह बदल सकते हैं कि Maps पर दुनिया का कौनसा हिस्सा दिखाई दे मैप. ऐसा करने के लिए, मैप को हिलाने के बजाय कैमरे की पोज़िशन बदली जाती है.

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

कैमरे की पोज़िशन बदलने के लिए, आपको 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 डिग्री है, तो पूर्व की ओर "ऊपर" है.

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

मैप के दायरे को सेट करना

कभी-कभी कैमरे को इस तरह से घुमाना मददगार होता है कि दिलचस्पी का पूरा इलाका, ज़ूम किए गए सबसे ज़्यादा लेवल पर दिखे. उदाहरण के लिए, अगर आपके स्टोर में मौजूद सभी पेट्रोल पंप दिखाए जा रहे हैं की दूरी 5 मील की दूरी पर है, तो आप कैमरे को वे सभी स्क्रीन पर दिख रहे हों. ऐसा करने के लिए, पहले उस 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 बनाकर और CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) LatLngBounds.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 दिए गए आयत के अंदर स्क्रीन पर केंद्र में हैं ज़रूरी पैडिंग (जगह) को ध्यान में रखते हुए, ज़ूम करने का सबसे बेहतर लेवल.

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