कैमरा और दृश्य

प्लैटफ़ॉर्म चुनें: Android iOS JavaScript

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

कोड सैंपल

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

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

सुविधा के बारे में जानकारी

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

ध्यान दें: किसी Mercator प्रोजेक्शन की चौड़ाई सीमित है और इसकी सीमा अक्षांश के हिसाब से है. हमने मर्केटर प्रोजेक्शन का इस्तेमाल करके, मैप की अनुमानित तस्वीरों को "कट ऑफ़" किया. इससे डेटा को करीब 8 से 85 डिग्री पर बनाया गया. ऐसा करने से, मैप के आकार का स्क्वेयर बन जाता है. इससे, टाइल चुनने में आसानी होती है.

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

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

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

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

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

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

टारगेट (जगह)

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

अक्षांश, -85 और 85 डिग्री के बीच हो सकता है. इस रेंज से ऊपर या नीचे की वैल्यू को, इस सीमा में मौजूद सबसे नज़दीकी वैल्यू से जोड़ा जाएगा. उदाहरण के लिए, 100 का अक्षांश तय करने से वैल्यू 85 पर सेट हो जाएगी. देशांतर, -180 से 180 डिग्री के बीच होता है. इस रेंज के ऊपर या नीचे की वैल्यू को इस तरह से रैप किया जाएगा कि वे इस रेंज (-180, 180) के अंदर आती हैं. उदाहरण के लिए, 480, 840, और 1200 को 120 डिग्री में रैप कर दिया जाएगा.

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

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

0 के भालू का मतलब है कि मैप के ऊपर बिलकुल उत्तर की ओर है. बियरिंग वैल्यू 90 का मतलब है कि मैप पर सबसे ऊपर, पूर्व की ओर जाने वाले पॉइंट हैं. कंपास पर 90 डिग्री. वैल्यू 180 का मतलब है, मैप के सबसे ऊपर की तरफ़ दक्षिण की ओर.

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

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

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

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

कैमरे में वीडियो देखने के डिफ़ॉल्ट ऐंगल से दिखाया गया मैप.

कैमरे का डिफ़ॉल्ट व्यू ऐंगल.

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

मैप में 45 डिग्री का व्यूइंग ऐंगल दिखाया गया है.

45 डिग्री का कैमरा व्यू ऐंगल.

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

तारीख की सीमा बढ़ाकर

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

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

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

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

ध्यान दें: स्क्रीन के साइज़ और डेंसिटी की वजह से, हो सकता है कि कुछ डिवाइस पर सबसे कम ज़ूम लेवल काम न करें. मैप के लिए कम से कम ज़ूम लेवल पाने के लिए GoogleMap.getMinimumZoomLevel() का इस्तेमाल करें. अगर आपको व्यूपोर्ट में पूरी दुनिया दिखाना है, तो लाइट मोड का इस्तेमाल करना बेहतर हो सकता है.

नीचे दी गई इमेज, ज़ूम के अलग-अलग लेवल को विज़ुअल के तौर पर दिखाती हैं:

ज़ूम लेवल पर लेवल 5 का मैप.

ज़ूम लेवल पर मैप 15.

ज़ूम लेवल पर मैप 20.

कैमरा ले जाना

Maps API से आपको यह बदलने की सुविधा मिलती है कि दुनिया का कौनसा हिस्सा, मैप पर दिखे. मैप को बदलने के बजाय, कैमरे की जगह बदलकर ऐसा किया जाता है.

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

ध्यान दें: मैप में जोड़ी गई किसी भी पैडिंग (जगह) को ध्यान में रखते हुए, सभी ऑब्जेक्ट के हिसाब से कैमरे की गतिविधियों को GoogleMap ऑब्जेक्ट के साइज़ के हिसाब से कैलकुलेट किया जाता है. उदाहरण के लिए, अपने मैप के बाएं किनारे पर 100 पिक्सल की पैडिंग जोड़ने से आपके मैप के बीच का हिस्सा दाईं ओर 50 पिक्सल की ओर शिफ़्ट हो जाएगा. ज़्यादा जानकारी के लिए, मैप पैडिंग के दस्तावेज़ देखें.

कैमरे की जगह बदलने के लिए, आपको CameraUpdate का इस्तेमाल करके यह बताना होगा कि कैमरे को कहां ले जाना है. Maps API की मदद से, CameraUpdateFactory का इस्तेमाल करके कई अलग-अलग तरह के 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 देता है, जो कैमरे को मौजूदा पोज़िशन पर ले जाता है. CameraPosition को सीधे तौर पर या new CameraPosition() का इस्तेमाल करके, या CameraPosition.Builder का इस्तेमाल करके new CameraPosition.Builder() से पाया जा सकता है.

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

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

      

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

किसी इलाके में मैप को बीच में दिखाना

कुछ मामलों में, हो सकता है कि आप अपने कैमरे को चरम सीमाओं के बजाय किसी सीमा के अंदर केंद्रित करना चाहें. उदाहरण के लिए, लगातार ज़ूम बनाए रखते हुए कैमरे को किसी देश पर केंद्रित करना. इस मामले में, LatLngBounds बनाकर और LatLngBounds के साथ CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) का इस्तेमाल करके, इससे मिलते-जुलते तरीके इस्तेमाल किया जा सकता है.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 को जनरेट करने के लिए, सिर्फ़ आसान तरीके newLatLngBounds(boundary, padding) का इस्तेमाल करें. ऐसा तभी किया जा सकता है, जब मैप का लेआउट बदलने के बाद, कैमरे को दूसरी जगह ले जाया जाए. एपीआई, मैप में उन डिसप्ले सीमाओं की गणना करता है जो बाउंडिंग बॉक्स को सही तरीके से दिखाने के लिए ज़रूरी हैं. इसमें, आप मैप के लेआउट से पहले भी, किसी भी समय newLatLngBounds(boundary, width, height, padding) के दिए गए ज़्यादा मुश्किल तरीके CameraUpdate का इस्तेमाल कर सकते हैं. ऐसा इसलिए होता है, क्योंकि एपीआई आपके पास दिए गए तर्कों में दिखाई गई सीमाओं का हिसाब लगाता है.

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

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

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), तीन आर्ग्युमेंट उपलब्ध कराता है:

cameraUpdate

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

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