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

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

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

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

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

บทนำ

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

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

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

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

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

แผนที่ 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

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

แผนที่ 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));