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

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

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

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

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

• CameraDemoActivity - Java: การเปลี่ยนตำแหน่งของกล้อง
• กิจกรรมการสาธิตกล้อง - Kotlin: การเปลี่ยนตำแหน่งของกล้อง

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

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

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

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

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

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

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

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

ซูม

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

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

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

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

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

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

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

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

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

การย้ายกล้อง

แผนที่ 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) ที่อธิบายไว้ด้านล่าง

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

ในบางกรณี คุณอาจต้องตั้งกล้องให้อยู่ตรงกลางภายใน 2 ขอบเขต แทนที่จะรวมขอบที่อยู่ไกลสุด เช่น เพื่อตั้งกล้องไว้ตรงกลาง ประเทศในขณะที่รักษาการซูมคงที่ ในกรณีนี้ คุณอาจใช้วิธีการที่คล้ายกันนี้ นั่นคือการสร้าง LatLngBounds และใช้ CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) ร่วมกับ LatLngBoundsเมธอด getCenter() เมธอด 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))