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

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

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

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

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

บทนำ

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

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

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

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

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

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

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

มุมมองแผนที่จะจำลองเป็นกล้องที่มองลงมาบนพื้นผิวเรียบ ตำแหน่งของกล้อง (และการแสดงผลแผนที่) จะระบุด้วยพร็อพเพอร์ตี้ต่อไปนี้ target (latitude/longitude location), 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 คือตำแหน่งแผนที่ปัจจุบัน แผนที่ที่ได้จะแสดงอยู่ด้านล่าง

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

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

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

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

ซูม

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

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

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

  • 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 ที่เพิ่ม (หรือลดหากค่าเป็นลบ) ระดับการซูมตามค่าที่ระบุ ส่วนหลังจะแก้ไขจุดที่ระบุบนหน้าจอให้อยู่ในตำแหน่งเดิม (ละติจูด/ลองจิจูด) และอาจเปลี่ยนตำแหน่งของกล้องเพื่อให้บรรลุเป้าหมายนี้

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

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

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

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

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

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

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

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

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

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

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

หากต้องการใช้ 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));