कैमरा और व्यू

प्लैटफ़ॉर्म चुनें: 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 डिग्री है. पहली इमेज में इसका क्रम बेहतर तरीके से दिखाया गया है. रैंक 1 कैमरे की पोज़िशन और पोज़िशन 2 मैप की मौजूदा पोज़िशन है. आपको जो मैप मिला है उसे नीचे दिखाया गया है.

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

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

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

मैप में 45 डिग्री देखने का कोण दिखाया गया है.

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

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

Zoom

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

ज़ूम के लेवल को 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 कैमरे को दी गई जगह पर ले जाया जाएगा. 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 होंगे.

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