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

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

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

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

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

บทนำ

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

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

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

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

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

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

ตําแหน่งของกล้อง

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

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

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

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

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

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

Java


private GoogleMap map;
    map.setMinZoomPreference(6.0f);
    map.setMaxZoomPreference(14.0f);

Kotlin


private lateinit var map: GoogleMap

    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 องศา ทิศตะวันออกจะเป็น "up"

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

การตั้งค่าขอบเขตของแผนที่

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

Java


LatLngBounds australiaBounds = new LatLngBounds(
    new LatLng(-44, 113), // SW bounds
    new LatLng(-10, 154)  // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 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))

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

ในบางกรณี คุณอาจต้องการจัดกล้องให้อยู่ตรงกลางภายในขอบเขตแทนที่จะใส่ขอบนอกสุด เช่น หากต้องการจัดตําแหน่งกล้องให้อยู่ตรงกลางประเทศ แต่ก็ยังซูมได้ต่อเนื่อง ในกรณีนี้ คุณสามารถใช้วิธีการที่คล้ายกันได้โดยสร้าง LatLngBounds แล้วใช้ CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) กับ LatLngBoundsgetCenter() เมธอด getCenter() จะส่งคืน ศูนย์ภูมิศาสตร์ของ LatLngBounds

Java


LatLngBounds australiaBounds = new LatLngBounds(
    new LatLng(-44, 113), // SW bounds
    new LatLng(-10, 154)  // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.getCenter(), 10));

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

เมธอดมากเกินไป newLatLngBounds(boundary, width, height, padding) ช่วยให้คุณระบุความกว้างและความสูงในหน่วยพิกเซลของสี่เหลี่ยมผืนผ้าได้ โดยมีลักษณะการทํางานที่สอดคล้องกับขนาดดังกล่าวของแผนที่ สี่เหลี่ยมผืนผ้าดังกล่าววางอยู่กึ่งกลางของศูนย์กลาง CameraUpdate ที่ส่งคืนจะขยับกล้องเพื่อให้ LatLngBounds ที่ระบุอยู่กึ่งกลางภายในกรอบสี่เหลี่ยมในระดับการซูมที่เป็นไปได้มากที่สุด โดยคํานึงถึงระยะห่างจากขอบที่ให้มา

หมายเหตุ: โปรดใช้วิธีการที่ง่ายยิ่งขึ้น newLatLngBounds(boundary, padding) เพื่อสร้าง CameraUpdate หากจะใช้วิธีนี้เพื่อ ย้ายกล้องหลังจากแผนที่อยู่ในเลย์เอาต์ที่กําหนด ในระหว่างเลย์เอาต์ API จะคํานวณขอบเขตการแสดงผลของแผนที่ซึ่งจําเป็นต่อการแสดงช่องขอบเขตอย่างถูกต้อง ในการเปรียบเทียบ คุณสามารถใช้ CameraUpdate ที่แสดงผลโดยวิธีการที่ซับซ้อนมากขึ้น newLatLngBounds(boundary, width, height, padding) ได้ทุกเมื่อ แม้ก่อนที่แผนที่จะอยู่ระหว่างการจัดวาง เนื่องจาก API จะคํานวณขอบเขตการแสดงผลจากอาร์กิวเมนต์ที่คุณส่ง

จํากัดการเลื่อนของผู้ใช้ไปยังพื้นที่ที่กําหนด

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

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

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)

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

แผนภาพที่แสดงกล้อง 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

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

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

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