कैमरा और व्यू

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

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

कैमरे का व्यू ऐंगल 45 डिग्री होना चाहिए.

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

ज़ूम करें

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

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

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

• 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 बनाया जा सकता है. यह 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() का इस्तेमाल करें.

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()` और `onFinished()`. ऐनिमेशन के लिए, इन तरीकों को इन स्थितियों में कॉल किया जाता है:

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