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

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

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

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

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

ข้อมูลเบื้องต้น

เช่นเดียวกับ Google Maps บนเว็บ Maps SDK สําหรับ Android จะแสดงพื้นโลก (ภาพ 360 องศา) บนหน้าจออุปกรณ์ (ระนาบราบ) โดยใช้เส้นโครงดาวเคราะห์ ในทิศทางตะวันออกและตะวันตก แผนที่ จะเล่นซ้ําไปเรื่อยๆ อย่างไม่หยุดยั้งในขณะที่โลกวนรอบตัวเอง ในทิศทางเหนือและใต้ แผนที่จํากัดที่ 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 หมายถึงด้านบนสุดของจุดบนแผนที่ที่ครบกําหนดทางใต้

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

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

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

ในภาพด้านล่าง มุมมองจะเป็น 0 องศา ภาพแรกแสดงแผนผังนี้ ตําแหน่ง 1 คือตําแหน่งของกล้อง และตําแหน่ง 2 คือตําแหน่งปัจจุบันของแผนที่ แผนที่ผลลัพธ์จะปรากฏที่ด้านล่าง

ภาพหน้าจอของแผนที่ที่มีกล้องอยู่ในมุม 0 องศา ที่ระดับการซูม 18
แผนที่ที่แสดงพร้อมมุมมองเริ่มต้นของกล้อง
แผนภาพที่แสดงตําแหน่งเริ่มต้นของกล้องโดยตรงเหนือตําแหน่งของแผนที่ทํามุม 0 องศา
มุมมองเริ่มต้นของกล้อง

ในภาพด้านล่าง มุมมองจะเป็น 45 องศา โปรดสังเกตว่ากล้องจะเคลื่อนไปตามแนวโค้งระหว่างตําแหน่งบนศีรษะตรง (0 องศา) กับพื้น (90 องศา) เพื่อวางตําแหน่ง 3 กล้องถ่ายรูปยังคงชี้ไปที่จุดกึ่งกลางของแผนที่ แต่ขณะนี้มองเห็นพื้นที่ซึ่งแสดงโดยเส้นตรงตําแหน่งที่ 4

ภาพหน้าจอของแผนที่ที่มีกล้องอยู่ในมุม 45 องศา ที่ระดับการซูม 18
แผนที่ที่แสดงมีมุมมอง 45 องศา
แผนภาพที่แสดงมุมกล้องที่ตั้งค่าเป็น 45 องศา พร้อมตั้งระดับการซูมเป็น 18
มุมมองกล้อง 45 องศา

แผนที่ในภาพหน้าจอนี้ยังคงอยู่ตรงกลางของจุดเดิมบนแผนที่ แต่มีคุณลักษณะเพิ่มเติมอยู่ที่ด้านบนของแผนที่ เมื่อคุณเพิ่มมุมที่เกินกว่า 45 องศา จุดสนใจต่างๆ ระหว่างกล้องและตําแหน่งบนแผนที่จะปรากฏตามสัดส่วนมากขึ้น ในขณะที่คุณลักษณะที่อยู่นอกตําแหน่งบนแผนที่จะมีขนาดเล็กลงเรื่อยๆ จนทําให้มีผลกระทบแบบสามมิติ

ซูม

ระดับการซูมของกล้องจะกําหนดขนาดของแผนที่ ระดับการซูมที่ใหญ่ขึ้นจะมีรายละเอียดมากขึ้นในหน้าจอ ส่วนระดับการซูมที่เล็กลงจะสามารถมองเห็นได้มากขึ้นในหน้าจอ ที่ระดับการซูม 0 ขนาดของแผนที่นั้น เท่ากับว่าทั้งโลกมีความกว้างประมาณ 256dp (ความหนาแน่นของพิกเซลอิสระ)

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

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

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 องศา ทิศตะวันออกจะเท่ากับ "ขึ้น"

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

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

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