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

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

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

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

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

บทนำ

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

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

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 คือตำแหน่งแผนที่ปัจจุบัน แผนที่ที่ได้จะแสดงอยู่ด้านล่าง

ภาพหน้าจอของแผนที่ที่มีกล้องอยู่ในมุมมอง 0 องศาที่ระดับการซูม 18
แผนที่ที่แสดงด้วยมุมมองเริ่มต้นของกล้อง
แผนภาพที่แสดงตำแหน่งเริ่มต้นของกล้องเหนือตำแหน่งแผนที่โดยตรงที่มุม 0 องศา
มุมมองเริ่มต้นของกล้อง

ในรูปภาพด้านล่าง มุมมองคือ 45 องศา โปรดสังเกตว่ากล้องจะเคลื่อนที่ไปครึ่งทางตามส่วนโค้งระหว่างเหนือศีรษะโดยตรง (0 องศา) กับพื้น (90 องศา) ไปยังตำแหน่ง 3 กล้องยังคงชี้ไปที่จุดศูนย์กลางของแผนที่ แต่พื้นที่ที่เส้นในตำแหน่ง 4 แสดงอยู่จะมองเห็นได้แล้ว

ภาพหน้าจอของแผนที่ที่มีกล้องวางในมุมมอง 45 องศาที่ระดับการซูม 18
แผนที่ที่แสดงด้วยมุมมอง 45 องศา
แผนภาพที่แสดงมุมมองของกล้องซึ่งตั้งค่าไว้ที่ 45 องศา โดยที่ระดับการซูมยังคงตั้งค่าไว้ที่ 18
มุมมองของกล้อง 45 องศา

แผนที่ในภาพหน้าจอนี้ยังคงอยู่ตรงกลางจุดเดียวกับในแผนที่เดิม แต่มีฟีเจอร์เพิ่มเติมปรากฏขึ้นที่ด้านบนของแผนที่ เมื่อคุณเพิ่มมุมให้เกิน 45 องศา ฟีเจอร์ระหว่างกล้องกับตำแหน่งแผนที่จะปรากฏใหญ่ขึ้นตามสัดส่วน ในขณะที่ฟีเจอร์ที่อยู่เลยตำแหน่งแผนที่จะปรากฏเล็กลงตามสัดส่วน ซึ่งจะทำให้เกิดเอฟเฟกต์สามมิติ

ซูม

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

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

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

  • 1: โลก
  • 5: ผืนดินขนาดใหญ่/ทวีป
  • 10: เมือง
  • 15: ถนน
  • 20: สิ่งปลูกสร้าง
รูปภาพต่อไปนี้แสดงลักษณะที่ปรากฏของระดับการซูมต่างๆ
ภาพหน้าจอของแผนที่ที่ระดับการซูม 5
แผนที่ที่ระดับการซูม 5
ภาพหน้าจอของแผนที่ที่ระดับการซูม 15
แผนที่ที่ระดับการซูม 15
ภาพหน้าจอของแผนที่ที่ระดับการซูม 20
แผนที่ที่ระดับการซูม 20

การเคลื่อนกล้อง

Maps API ช่วยให้คุณเปลี่ยนส่วนต่างๆ ของโลกที่มองเห็นได้บนแผนที่ โดยการเปลี่ยนตำแหน่งของกล้อง (แทนที่จะย้ายแผนที่)

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

หากต้องการเปลี่ยนตำแหน่งของกล้อง คุณต้องระบุตำแหน่งที่ต้องการ ย้ายกล้องโดยใช้ CameraUpdate Maps API ช่วยให้คุณสร้าง CameraUpdate ได้หลายประเภทโดยใช้ CameraUpdateFactory โดยมีตัวเลือกดังต่อไปนี้

การเปลี่ยนระดับการซูมและการตั้งค่าการซูมต่ำสุด/สูงสุด

CameraUpdateFactory.zoomIn() และ CameraUpdateFactory.zoomOut() จะให้ CameraUpdate ที่เปลี่ยนระดับการซูมเป็น 1.0 โดยที่ พร็อพเพอร์ตี้อื่นๆ ทั้งหมดจะยังคงเหมือนเดิม

CameraUpdateFactory.zoomTo(float) จะให้ CameraUpdate ที่เปลี่ยนระดับการซูมเป็นค่าที่กำหนด โดยที่พร็อพเพอร์ตี้อื่นๆ ทั้งหมดจะยังคงเหมือนเดิม

CameraUpdateFactory.zoomBy(float) และ CameraUpdateFactory.zoomBy(float, Point) จะให้ CameraUpdate ที่เพิ่ม (หรือลด หากค่าเป็น ลบ) ระดับการซูมตามค่าที่กำหนด ส่วนตัวเลือกหลังจะกำหนดจุดที่ระบุบนหน้าจอเพื่อให้จุดนั้นยังคงอยู่ที่ตำแหน่งเดิม (ละติจูด/ลองจิจูด) และอาจเปลี่ยนตำแหน่งของกล้องเพื่อให้เป็นไปตามนี้

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

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 ไม่อนุญาตให้ผู้ใช้ซูมต่ำหรือสูงเกินไป เช่น ดาวเทียมหรือภูมิประเทศอาจมีการซูมสูงสุดต่ำกว่า Map Tiles แผนที่ฐาน

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

มีเมธอดอำนวยความสะดวก 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));

การจัดแผนที่ให้อยู่ตรงกลางภายในพื้นที่

ในบางกรณี คุณอาจต้องการจัดกล้องให้อยู่ตรงกลางภายในขอบเขตแทนที่จะรวมขอบเขตที่ไกลที่สุด เช่น จัดกล้องให้อยู่ตรงกลางประเทศหนึ่งๆ ขณะที่ยังคงการซูมไว้คงที่ ในกรณีนี้ คุณสามารถใช้วิธีที่คล้ายกันได้ โดยการสร้าง 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);

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

แผนภาพแสดง LatLngBounds ของกล้องที่ใหญ่กว่า วิวพอร์ต

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

แผนภาพแสดงเป้าหมายของกล้องซึ่งวางอยู่ที่มุมขวาล่างของ LatLngBounds ของกล้อง

ในแผนภาพต่อไปนี้ เป้าหมายของกล้องมีขอบเขตที่จำกัดมาก ทำให้ผู้ใช้มีโอกาสเลื่อนหรือแพนแผนที่น้อยมาก กากบาทแสดงถึงเป้าหมายของกล้อง

แผนภาพแสดง LatLngBounds ของกล้องที่มีขนาดเล็กกว่า วิวพอร์ต

การอัปเดตมุมมองกล้อง

หากต้องการใช้ CameraUpdate กับแผนที่ คุณสามารถย้าย กล้องทันทีหรือสร้างภาพเคลื่อนไหวให้กล้องเคลื่อนที่อย่างราบรื่นก็ได้ หากต้องการย้ายกล้อง ทันทีด้วย CameraUpdate ที่กำหนด ให้เรียกใช้ GoogleMap.moveCamera(CameraUpdate)

คุณสามารถทำให้ผู้ใช้ได้รับประสบการณ์การใช้งานที่ดียิ่งขึ้น โดยเฉพาะอย่างยิ่งสำหรับการเคลื่อนที่ระยะสั้น โดยการสร้างภาพเคลื่อนไหวของการเปลี่ยนแปลง หากต้องการทำเช่นนี้ ให้เรียกใช้ GoogleMap.animateCameraแทนการเรียกใช้ GoogleMap.moveCamera แผนที่จะเคลื่อนที่ไปยังแอตทริบิวต์ใหม่ได้อย่างราบรื่น GoogleMap.animateCamera(cameraUpdate, duration, callback) ซึ่งเป็นรูปแบบที่ละเอียดที่สุดของเมธอดนี้มีอาร์กิวเมนต์ 3 รายการดังนี้

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