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

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

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

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

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

บทนำ

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

หมายเหตุ: การฉายภาพของ Mercator มีความกว้างที่ไม่หยุดนิ่งแต่มีความสูงที่ไม่สิ้นสุด เรา "ตัด" ภาพแผนที่ฐานโดยใช้การฉายภาพของ 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 จะสอดคล้องกับกล้องที่เอียงไปทางขอบฟ้าตามจํานวนองศาที่ระบุ เมื่อเปลี่ยนมุมมอง แผนที่จะปรากฏในมุมมองโดยแสดงสถานที่ที่อยู่ไกลออกไป ดูเหมือนว่าจะมีขนาดเล็กลง และฟีเจอร์ใกล้เคียงจะปรากฏมากขึ้น ภาพประกอบต่อไปนี้แสดงให้เห็นถึงเรื่องนี้

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

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

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 องศา ทิศตะวันออกจะแสดงเป็น "ขึ้น"

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

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

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