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

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

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

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

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

• CameraDemoActivity - Java: การเปลี่ยนแปลงตําแหน่งของกล้อง
• CameraDemoActivity - Kotlin: เปลี่ยนตําแหน่งกล้อง

บทนำ

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 คือตําแหน่งในแผนที่ปัจจุบัน แผนที่ที่เกิดขึ้นจะแสดงอยู่ด้านล่าง

แผนที่ที่แสดงด้วยมุมมองเริ่มต้นของกล้อง

มุมมองเริ่มต้นของกล้อง

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

แผนที่แสดงโดยมีมุมมอง 45 องศา

มุมมองกล้อง 45 องศา

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

ซูม

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

การเพิ่มระดับการซูมเป็น 1 เท่าของความกว้างของโลกบนหน้าจอ ดังนั้นที่ระดับการซูม N ความกว้างของโลกจะอยู่ที่ประมาณ 256 * 2^N dp เช่น ที่ระดับการซูม 2 โลกทั้งใบมีความกว้างประมาณ 1024 dp

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

• 1: โลก
• 5: ผืนดิน/ทวีป
• 10: เมือง
• 15: ถนน
• 20: อาคาร

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

รูปภาพต่อไปนี้แสดงลักษณะของระดับการซูมต่างๆ

แผนที่ที่ระดับการซูม 5

แผนที่ที่ระดับการซูม 15

แผนที่ที่ระดับการซูม 20

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

Maps API ทําให้คุณเปลี่ยนพื้นที่ของโลกที่แสดงบนแผนที่ได้ ซึ่งทําได้โดยการเปลี่ยนตําแหน่งของกล้อง (แทนที่จะย้ายแผนที่)

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

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

หากต้องการเปลี่ยนตําแหน่งของกล้อง คุณต้องระบุตําแหน่งที่ต้องการย้ายกล้อง โดยใช้ 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))

      

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

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

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

      

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

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

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

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

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