कैमरा और व्यू

प्लैटफ़ॉर्म चुनें: 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 डीपी (डेंसिटी-इंडिपेंडेंट पिक्सल) होती है.

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

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

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

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

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

पांचवें ज़ूम पर मौजूद मैप.

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

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

कैमरे को एक जगह से दूसरी जगह ले जाया जा रहा है

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

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

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

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

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

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() या 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() का इस्तेमाल करें.

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

कुछ मामलों में, हो सकता है कि आपको कैमरे को किनारों के बजाय, बीच में फ़ोकस करना हो. उदाहरण के लिए, कैमरे को किसी देश के ठीक सामने रखने के लिए और स्थिर ज़ूम बनाए रखते हैं. इस मामले में, 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, स्क्रीन पर दिए गए रेक्टैंगल के बीच में दिखें. साथ ही, ज़्यादा से ज़्यादा ज़ूम लेवल पर दिखें. इसके लिए, पैडिंग की ज़रूरत को ध्यान में रखा जाएगा.

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