कैमरा और व्यू

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

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

कोड सैंपल

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

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

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

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

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

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

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

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

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

कैमरे की पोज़िशन

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

टारगेट (जगह)

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

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

बियरिंग (स्क्रीन की दिशा)

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

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

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

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

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

नीचे दी गई इमेज में, देखने का कोण 0 डिग्री है. पहली इमेज में इसकी स्कीमा दिखाया गया है. रैंक पहली कैमरे की स्थिति है और दूसरी जगह, मैप की मौजूदा जगह है. नतीजे में मिला मैप इसके नीचे दिखाया गया है.

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

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

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

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

कैमरा देखने के लिए 45 डिग्री का ऐंगल.

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

Zoom

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

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

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

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

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

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

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

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

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

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

Maps API की मदद से, यह तय किया जा सकता है कि मैप पर दुनिया का कौनसा हिस्सा दिखेगा. ऐसा कैमरे की स्थिति बदलकर किया जाता है (मैप को इधर-उधर ले जाने के बजाय).

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

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

कैमरे की जगह बदलने के लिए, आपको CameraUpdate का इस्तेमाल करके यह बताना होगा कि आपको कैमरा कहां ले जाना है. Maps API की मदद से, CameraUpdateFactory का इस्तेमाल करके कई तरह के CameraUpdate बनाए जा सकते हैं. फ़िल्टर के लिए, यहां दिए गए विकल्प उपलब्ध होते हैं:

ज़ूम का लेवल बदलना और कम से कम/ज़्यादा से ज़्यादा ज़ूम की सेटिंग करना

CameraUpdateFactory.zoomIn() और CameraUpdateFactory.zoomOut() आपको ऐसा CameraUpdate मिलता है जो ज़ूम के लेवल को 1.0 तक बदल देता है. हालांकि, यह बाकी सभी प्रॉपर्टी को पहले जैसा ही रखता है.

CameraUpdateFactory.zoomTo(float) आपको एक CameraUpdate देता है, जो दूसरी सभी प्रॉपर्टी को पहले जैसा रखते हुए, ज़ूम लेवल को दिए गए वैल्यू में बदलता है.

CameraUpdateFactory.zoomBy(float) और CameraUpdateFactory.zoomBy(float, Point) आपको एक CameraUpdate देता है, जो दी गई वैल्यू के हिसाब से ज़ूम का लेवल बढ़ाता या कम करता है. ऐसा तब होता है, जब वैल्यू नेगेटिव हो. बाद वाली टेक्नोलॉजी, स्क्रीन पर दिए गए पॉइंट को इस तरह ठीक करती है जिससे वह उसी जगह पर बना रहता है (जिसकी जगह अक्षांश/देशांतर) होता है. इसलिए, इसे पाने के लिए यह कैमरे की जगह बदल सकता है.

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

Kotlin

private lateinit var map: GoogleMap

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

      

Java

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

      

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

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

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

कैमरे की जगह बदलने के लिए, CameraUpdateFactory.newCameraPosition(CameraPosition) का इस्तेमाल करें. इससे आपको CameraUpdate मिलता है, जो कैमरे को बताई गई जगह पर ले जाता है. A 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 होंगे.

Kotlin

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

      

Java

LatLngBounds australiaBounds = new LatLngBounds(
    new LatLng(-44, 113), // SW bounds
    new LatLng(-10, 154)  // 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 का भौगोलिक केंद्र दिखेगा.

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

      

Java

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 का इस्तेमाल किया जा सकता है. इसकी वजह यह है कि एपीआई, आपके पास किए गए तर्कों से डिसप्ले सीमाओं का हिसाब लगाता है.

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

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

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)

      

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

      

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

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

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

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

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

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

cameraUpdate

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

callback

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

onFinish()

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

onCancel()

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

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

duration

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

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

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

      

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