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

เลือกแพลตฟอร์ม แอนดรอยด์ iOS JavaScript

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

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

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

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

บทนำ

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

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

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

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

เนื่องจากคุณสามารถฟังท่าทางสัมผัสของผู้ใช้บนแผนที่ คุณจึงสามารถเปลี่ยนแผนที่ได้ใน การตอบสนองต่อคำขอของผู้ใช้ ตัวอย่างเช่น เมธอด Callback OnMapClickListener.onMapClick() ตอบสนองต่อ แตะครั้งเดียวบนแผนที่ เนื่องจากเมธอดจะได้รับละติจูดและลองจิจูด ของตำแหน่งที่แตะ คุณสามารถตอบสนองโดยการเลื่อนหรือซูมไปยังจุดนั้น สามารถใช้วิธีการที่คล้ายกันนี้ในการตอบกลับการแตะบนลูกโป่งของเครื่องหมาย หรือ สำหรับการตอบสนองต่อท่าทางสัมผัสการลากบนเครื่องหมาย

นอกจากนี้ คุณยังฟังการเคลื่อนไหวของกล้องเพื่อให้แอปได้รับการแจ้งเตือนเมื่อกล้องเริ่มเคลื่อนไหว กำลังเคลื่อนไหว หรือหยุดเคลื่อนไหวได้ด้วย โปรดดูรายละเอียดในคำแนะนำเกี่ยวกับเหตุการณ์การเปลี่ยนแปลงของกล้อง

ตำแหน่งกล้อง

มุมมองแผนที่ถูกจำลองแบบกล้องที่มองลงไปยังระนาบแบน ตำแหน่งของกล้อง (และการแสดงผลแผนที่) จะระบุด้วยพร็อพเพอร์ตี้ต่อไปนี้ target (location latitude/longitude), bearing, tilt และ zoom

เป้าหมาย (สถานที่ตั้ง)

เป้าหมายของกล้องคือตำแหน่งกึ่งกลางของแผนที่ ระบุเป็น พิกัดละติจูดและลองจิจูด

ละติจูดอาจมีค่าระหว่าง -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

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

      

โปรดทราบว่ามีข้อควรพิจารณาด้านเทคนิคที่อาจป้องกันไม่ให้ 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) กับ LatLngBoundsgetCenter() วิธี เมธอด 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));