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

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

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

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

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

บทนำ

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

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

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

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

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

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

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

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

แผนภาพคุณสมบัติของกล้อง

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

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

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

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

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

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

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

เอียง (มุมมอง)

การเอียงจะกำหนดตำแหน่งของกล้องในแนวโค้งเหนือแผนที่โดยตรง ตำแหน่งกึ่งกลาง วัดเป็นองศาจากองศา nadir (ทิศทางที่ชี้ไปใต้กล้องโดยตรง) ค่า 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 โลกทั้งใบจะมีขนาดประมาณ กว้าง 1024dp

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

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

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

แผนภาพแสดงขอบเขตละติจูดและลองจิจูดของกล้องที่มีขนาดใหญ่กว่า วิวพอร์ต

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

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

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

แผนภาพแสดงขอบเขตละติจูดและลองจิจูดของกล้องถ่ายรูปที่เล็กกว่า วิวพอร์ต

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

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