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

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

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

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

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

บทนำ

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

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

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

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

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

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

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

มุมมองแผนที่จะจำลองเป็นกล้องที่มองลงมาบนพื้นผิวเรียบ ตำแหน่งของกล้อง (และการแสดงผลแผนที่) จะระบุด้วยพร็อพเพอร์ตี้ต่อไปนี้ เป้าหมาย (ตำแหน่งละติจูด/ลองจิจูด) ทิศทาง การเอียง และการซูม

แผนภาพพร็อพเพอร์ตี้ของกล้อง

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

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

ละติจูดต้องอยู่ระหว่าง -85 ถึง 85 องศา ค่าที่สูงกว่าหรือต่ำกว่าช่วงนี้จะถูกบีบให้อยู่ภายในค่าที่ใกล้เคียงที่สุดภายในช่วงนี้ เช่น การระบุละติจูด 100 จะตั้งค่าเป็น 85 ลองจิจูดอยู่ระหว่าง -180 ถึง 180 องศา ค่าที่สูงกว่าหรือต่ำกว่าช่วงนี้จะได้รับการปัดให้อยู่ในช่วง (-180, 180) เช่น 480, 840 และ 1200 จะปัดเศษเป็น 120 องศาทั้งหมด

ทิศทาง (การวางแนว)

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

ทิศทาง 0 หมายความว่าด้านบนของแผนที่ชี้ไปยังทิศเหนือจริง ค่าการทรงตัว 90 หมายถึงจุดบนสุดของแผนที่ชี้ไปทางทิศตะวันออก (90 องศาบนเข็มทิศ) ค่า 180 หมายความว่าด้านบนของแผนที่ชี้ไปทางทิศใต้

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

การเอียง (มุมมองในการดู)

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

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

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

KotlinJava
private lateinit var map: GoogleMap

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

      
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 องศา ตะวันออกจะหมายถึง "ขึ้น"

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

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

บางครั้งการย้ายกล้องเพื่อให้เห็นพื้นที่ทั้งหมดที่สนใจในระดับการซูมสูงสุดที่เป็นไปได้ก็มีประโยชน์ เช่น หากคุณแสดงปั๊มน้ำมันทั้งหมดที่อยู่ในระยะ 8 กิโลเมตรจากตำแหน่งปัจจุบันของผู้ใช้ คุณอาจต้องขยับกล้องเพื่อให้ปั๊มน้ำมันทั้งหมดปรากฏบนหน้าจอ โดยก่อนอื่นให้คำนวณ LatLngBounds ที่ต้องการแสดงบนหน้าจอ จากนั้นคุณสามารถใช้ CameraUpdateFactory.newLatLngBounds(LatLngBounds bounds, int padding) เพื่อรับ CameraUpdate ซึ่งจะเปลี่ยนตำแหน่งกล้องเพื่อให้ LatLngBounds ที่ระบุพอดีกับแผนที่โดยสมบูรณ์ โดยพิจารณาการเว้นวรรค (เป็นพิกเซล) ที่ระบุ CameraUpdate ที่แสดงผลจะตรวจสอบว่าช่องว่าง (เป็นพิกเซล) ระหว่างขอบเขตที่ระบุกับขอบของแผนที่จะมีอย่างน้อยเท่ากับการเว้นวรรคที่ระบุ โปรดทราบว่าทั้งการเอียงและการหมุนของแผนที่จะเป็น 0

KotlinJava
val australiaBounds = LatLngBounds(
    LatLng((-44.0), 113.0),  // SW bounds
    LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0))

      
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

KotlinJava
val australiaBounds = LatLngBounds(
    LatLng((-44.0), 113.0),  // SW bounds
    LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.center, 10f))

      
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 จะคํานวณขอบเขตการแสดงผลจากอาร์กิวเมนต์ที่คุณส่ง

จำกัดการแพนภาพของผู้ใช้ให้อยู่ในบริเวณที่กำหนด

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

KotlinJava
// 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)

      
// 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

ข้อมูลโค้ดต่อไปนี้แสดงวิธีทั่วไปในการเคลื่อนย้ายกล้อง

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

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