กล้องและมุมมอง

เลือกแพลตฟอร์ม: Android iOS JavaScript

แผนที่ใน Maps SDK สำหรับ Android สามารถเอียงและหมุนได้ด้วยท่าทางสัมผัสที่ง่ายดาย ซึ่งช่วยให้ผู้ใช้ปรับแผนที่ด้วยการวางแนวที่เหมาะสมกับตนเองได้ คุณสามารถเลื่อนแผนที่หรือเปลี่ยนมุมมองได้ที่ระดับการซูมใดก็ได้โดยมีเวลาในการตอบสนองน้อยมาก เนื่องจากไทล์แผนที่แบบเวกเตอร์มีขนาดเล็กลง

ตัวอย่างโค้ด

ที่เก็บ ApiDemos ใน GitHub มีตัวอย่างที่สาธิตฟีเจอร์กล้องดังนี้

• CameraDemoActivity - Kotlin: การเปลี่ยนตำแหน่งกล้อง
• CameraDemoActivity - Java: การเปลี่ยนตำแหน่งกล้อง

บทนำ

Maps SDK สำหรับ Android แสดงพื้นผิวโลก (ทรงกลม) บนหน้าจออุปกรณ์ (ระนาบแบน) โดยใช้การฉายภาพแบบเมอร์เคเตอร์ เช่นเดียวกับ Google Maps บนเว็บ ในทิศตะวันออกและตะวันตก แผนที่จะแสดงซ้ำไปเรื่อยๆ เนื่องจากโลกหมุนรอบตัวเองอย่างราบรื่น ในทิศเหนือและทิศใต้ แผนที่จะจำกัดอยู่ที่ประมาณ 85 องศาเหนือและ 85 องศาใต้

หมายเหตุ: การฉายภาพแบบเมอร์เคเตอร์มีความกว้างจำกัดตามลองจิจูด แต่มีความสูงไม่จำกัดตามละติจูด เรา "ตัด" ภาพแผนที่ฐานโดยใช้การฉายภาพแบบเมอร์เคเตอร์ที่ประมาณ +/- 85 องศาเพื่อให้แผนที่ที่ได้มีรูปร่างเป็นสี่เหลี่ยมจัตุรัส ซึ่งช่วยให้ตรรกะในการเลือกไทล์ง่ายขึ้น

Maps SDK สำหรับ Android ช่วยให้คุณเปลี่ยนจุดมุมมองของผู้ใช้ในแผนที่ได้โดยการแก้ไขกล้องของแผนที่

การเปลี่ยนแปลงกล้องจะไม่ส่งผลต่อเครื่องหมาย การวางซ้อน หรือกราฟิกอื่นๆ ที่คุณเพิ่มไว้ แม้ว่าคุณอาจต้องการเปลี่ยนสิ่งที่เพิ่มเข้ามาเพื่อให้พอดีกับมุมมองใหม่ก็ตาม

เนื่องจากคุณสามารถรอกิจกรรมท่าทางผู้ใช้บนแผนที่ได้ คุณจึงเปลี่ยนแผนที่เพื่อตอบสนองต่อคำขอของผู้ใช้ได้ เช่น เมธอด Callback 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 มิติ

ซูม

ระดับการซูมของกล้องจะเป็นตัวกำหนดมาตราส่วนของแผนที่ ที่ระดับการซูมที่สูงขึ้น คุณจะเห็นรายละเอียดมากขึ้นบนหน้าจอ ขณะที่ระดับการซูมที่ต่ำลง คุณจะเห็นโลกมากขึ้นบนหน้าจอ ที่ระดับการซูม 0 มาตราส่วนของแผนที่จะแสดงให้เห็นทั้งโลกโดยมีความกว้างประมาณ 256dp (ความหนาแน่นของพิกเซลอิสระ)

การเพิ่มระดับการซูมขึ้น 1 ระดับจะเพิ่มความกว้างของโลกบนหน้าจอเป็น 2 เท่า ดังนั้นที่ระดับการซูม N ความกว้างของโลกจะอยู่ที่ประมาณ 256 * 2^N dp เช่น ที่ระดับการซูม 2 โลกทั้งใบจะมีความกว้างประมาณ 1024dp

ระดับการซูมไม่จำเป็นต้องเป็นจำนวนเต็ม ช่วงของระดับการซูมที่แผนที่อนุญาตขึ้นอยู่กับหลายปัจจัย ซึ่งรวมถึงเป้าหมาย ประเภทแผนที่ และขนาดหน้าจอ ระบบจะแปลงตัวเลขที่อยู่นอกช่วงเป็นค่าที่ถูกต้องที่ใกล้เคียงที่สุดถัดไป ซึ่งอาจเป็นระดับการซูมต่ำสุดหรือระดับการซูมสูงสุดก็ได้ รายการต่อไปนี้แสดงระดับรายละเอียดโดยประมาณที่คุณจะเห็นในระดับการซูมแต่ละระดับ

• 1: โลก
• 5: ผืนดิน/ทวีป
• 10: เมือง
• 15: ถนน
• 20: อาคาร

หมายเหตุ: อุปกรณ์บางรุ่นอาจไม่รองรับระดับการซูมต่ำสุดเนื่องจากขนาดและความหนาแน่นของหน้าจอ ใช้ GoogleMap.getMinimumZoomLevel() เพื่อรับระดับการซูมต่ำสุดที่เป็นไปได้สำหรับแผนที่ หากต้องการแสดงทั้งโลกในวิวพอร์ต คุณควรใช้โหมด Lite

รูปภาพต่อไปนี้แสดงลักษณะที่ปรากฏของระดับการซูมที่แตกต่างกัน

แผนที่ที่ระดับการซูม 5

แผนที่ที่ระดับการซูม 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

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

      

Java

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

      

โปรดทราบว่ามีข้อพิจารณาทางเทคนิคที่อาจทำให้ API ไม่อนุญาตให้ผู้ใช้ซูมต่ำเกินไปหรือสูงเกินไป เช่น ดาวเทียมหรือภูมิประเทศอาจมีการซูมสูงสุดต่ำกว่าไทล์แผนที่ฐาน

การเปลี่ยนตำแหน่งกล้อง

มีวิธีที่สะดวก 2 วิธีสำหรับการเปลี่ยนตำแหน่งทั่วไป 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 องศา ทิศตะวันออกจะอยู่ "ด้านบน"

การกำหนดขอบเขต

การกำหนดขอบเขตของแผนที่

บางครั้งการย้ายกล้องเพื่อให้มองเห็นพื้นที่ที่สนใจทั้งหมดในระดับการซูมสูงสุดที่เป็นไปได้ก็มีประโยชน์ ตัวอย่างเช่น หากคุณแสดงปั๊มน้ำมันทั้งหมดภายในรัศมี 5 ไมล์จากตำแหน่งปัจจุบันของผู้ใช้ คุณอาจต้องการย้ายกล้องเพื่อให้ปั๊มน้ำมันทั้งหมดปรากฏบนหน้าจอ โดยก่อนอื่นให้คำนวณ 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) เพื่อเปลี่ยนกล้องได้หลังจากที่เลย์เอาต์แผนที่เสร็จสมบูรณ์แล้วเท่านั้น เนื่องจาก API จะคำนวณขอบเขตการแสดงผลของแผนที่ระหว่างการจัดเลย์เอาต์ หากต้องการเรียกใช้ newLatLngBounds() ก่อนที่เลย์เอาต์จะเกิดขึ้น คุณสามารถใช้ newLatLngBounds(boundary, width, height, padding) ที่อธิบายไว้ด้านล่าง

การแสดงพื้นที่กลางแผนที่

ในบางกรณี คุณอาจต้องการจัดกล้องให้อยู่กึ่งกลางภายในขอบเขตแทนที่จะรวมขอบเขตสุดโต่ง เช่น เพื่อจัดกล้องให้อยู่ตรงกลางประเทศโดยที่ยังคงการซูมคงที่ไว้ ในกรณีนี้ คุณสามารถใช้วิธีการที่คล้ายกันได้โดยสร้าง LatLngBounds และใช้ CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) กับ LatLngBoundsเมธอด 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 หากจะใช้เพื่อย้าย กล้องหลังจากที่แผนที่ได้รับการจัดวางแล้ว ในระหว่างการจัดเลย์เอาต์ API จะคำนวณขอบเขตการแสดงผลของแผนที่ซึ่งจำเป็นต่อการฉายภาพกรอบล้อมรอบอย่างถูกต้อง ในทางกลับกัน คุณสามารถใช้ CameraUpdate ที่แสดงผลโดยเมธอด newLatLngBounds(boundary, width, height, padding) ที่ซับซ้อนกว่าได้ทุกเมื่อ แม้กระทั่งก่อนที่แผนที่จะมีการจัดเลย์เอาต์ เนื่องจาก API จะคำนวณขอบเขตการแสดงผลจากอาร์กิวเมนต์ที่คุณส่ง

การจำกัดการเลื่อนของผู้ใช้ให้อยู่ในพื้นที่ที่กำหนด

ในสถานการณ์ข้างต้น คุณกำหนดขอบเขตของแผนที่ แต่ผู้ใช้สามารถเลื่อนหรือเลื่อนออกนอกขอบเขตเหล่านี้ได้ แต่คุณอาจต้องการจำกัดขอบเขตละติจูด/ลองจิจูดของจุดโฟกัสของแผนที่ (เป้าหมายกล้อง) เพื่อให้ผู้ใช้เลื่อนและแพนได้ภายในขอบเขตเหล่านี้เท่านั้น ตัวอย่างเช่น แอปค้าปลีกสำหรับศูนย์การค้าหรือสนามบินอาจต้องการจำกัดแผนที่ให้อยู่ในขอบเขตที่เฉพาะเจาะจง เพื่อให้ผู้ใช้เลื่อนและแพนภายในขอบเขตเหล่านั้นได้

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) ซึ่งมีอาร์กิวเมนต์ 3 รายการ ได้แก่

cameraUpdate

CameraUpdate ที่อธิบายตำแหน่งที่จะย้ายกล้อง

callback

ออบเจ็กต์ที่ใช้ GoogleMap.CancellableCallback อินเทอร์เฟซทั่วไปสำหรับการจัดการงานนี้กำหนดเมธอด 2 รายการ ได้แก่ `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));