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

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

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

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

• cameraDemoActivity - Kotlin: เปลี่ยนตำแหน่งกล้อง
• cameraDemoActivity - Java: เปลี่ยนตำแหน่งกล้อง

เกริ่นนำ

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

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

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

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

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

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

ตำแหน่งของกล้อง

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

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

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

ทิศทาง (การวางแนว)

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

เครื่องหมาย 0 หมายความว่าส่วนบนสุดของแผนที่ชี้ไปยังทิศเหนือจริง ค่าทิศทาง 90 หมายถึงด้านบนของจุดบนแผนที่ที่ครบกำหนดในทิศตะวันออก (90 องศาบนเข็มทิศ) ค่า 180 หมายถึงด้านบนของจุดบนแผนที่เนื่องจากอยู่ทางใต้

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

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

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

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

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

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

Zoom

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

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

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

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

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

private lateinit var map: GoogleMap

    map.setMinZoomPreference(6.0f)
    map.setMaxZoomPreference(14.0f)

      

private GoogleMap map;
    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

val australiaBounds = LatLngBounds(
    LatLng((-44.0), 113.0),  // SW bounds
    LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0))

      

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

      

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

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

val australiaBounds = LatLngBounds(
    LatLng((-44.0), 113.0),  // SW bounds
    LatLng((-10.0), 154.0) // NE bounds
)
map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.center, 10f))

      

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

      

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

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

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

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

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

      

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

      

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

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

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

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

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

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

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

      

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