कैमरा और व्यू

प्लैटफ़ॉर्म चुनें: 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 डिग्री से ज़्यादा का ऐंगल चुनने पर, कैमरे और मैप की पोज़िशन के बीच की चीज़ें, अनुपात के हिसाब से बड़ी दिखती हैं. वहीं, मैप की पोज़िशन से आगे की चीज़ें, अनुपात के हिसाब से छोटी दिखती हैं. इससे 3D इफ़ेक्ट मिलता है.

ज़ूम करें

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

ज़ूम लेवल को एक लेवल बढ़ाने पर, स्क्रीन पर दुनिया की चौड़ाई दोगुनी हो जाती है. इसलिए, ज़ूम लेवल 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 बनाया जा सकता है. यह 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() का इस्तेमाल करें.

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

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

उपयोगकर्ता को किसी खास जगह पर पैन करने से रोकना

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

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