แผนที่ใน Maps SDK สำหรับ Android สามารถเอียงและบิดได้ด้วยท่าทางสัมผัสง่ายๆ ซึ่งช่วยให้ผู้ใช้ปรับแผนที่ให้อยู่ในแนวที่เหมาะกับตนเองได้ ในทุกระดับการซูม คุณสามารถเลื่อนแผนที่ หรือเปลี่ยนมุมมองด้วยเวลาในการตอบสนองที่น้อยมาก เนื่องด้วยรอยเท้าที่เล็กลงของชิ้นส่วนแผนที่ที่ใช้เวกเตอร์
ตัวอย่างโค้ด
ที่เก็บ ApiDemos ใน GitHub มีตัวอย่างที่แสดงให้เห็นถึงฟีเจอร์กล้อง ดังนี้
- cameraDemoActivity - Kotlin: เปลี่ยนตำแหน่งกล้อง
- CameraDemoActivity - Java: การเปลี่ยนตำแหน่งกล้อง
บทนำ
Maps SDK สำหรับ Android แสดงพื้นผิวของโลก (ทรงกลม) บนหน้าจออุปกรณ์ของคุณ (ระนาบแบน) โดยใช้เส้นโครงเมอร์ เช่นเดียวกับ Google Maps บนเว็บ ในทิศทางตะวันออกและตะวันตก แผนที่จะซ้อนกันซ้ำๆ ไม่มีที่สิ้นสุดขณะที่โลกหมุนรอบตัวเองอย่างราบรื่น ในทิศทางเหนือและใต้ แผนที่จำกัดอยู่ที่ประมาณ 85 องศาทางเหนือและ 85 องศาทางใต้
หมายเหตุ: เส้นโครงเมอร์เคเตอร์มีความกว้างจำกัดตามแนวยาว แต่มีความสูงไม่จำกัดทางละติจูด เรา "ตัด" ภาพแผนที่ฐานโดยใช้เส้นโครงของ Mercator ที่ตำแหน่งประมาณ +/- 85 องศา เพื่อทำให้ได้รูปร่างแผนที่ที่เป็นรูปสี่เหลี่ยมจัตุรัส ซึ่งช่วยให้ใช้ตรรกะสำหรับการเลือกชิ้นส่วนได้ง่ายขึ้น
Maps SDK สำหรับ Android ช่วยให้คุณเปลี่ยนมุมมองแผนที่ของผู้ใช้ได้โดยแก้ไขกล้องของแผนที่
การเปลี่ยนแปลงกล้องจะไม่ทำให้เกิดการเปลี่ยนแปลงใดๆ กับเครื่องหมาย การวางซ้อน หรือกราฟิกอื่นๆ ที่คุณเพิ่มไว้ แม้ว่าคุณอาจต้องเปลี่ยนส่วนที่เพิ่มไว้เพื่อให้เข้ากับมุมมองใหม่มากขึ้น
เนื่องจากคุณสามารถรับฟังท่าทางสัมผัสของผู้ใช้บนแผนที่ คุณจึงเปลี่ยนแผนที่เพื่อตอบสนองคำขอของผู้ใช้ได้ ตัวอย่างเช่น เมธอด Callback OnMapClickListener.onMapClick()
จะตอบสนองต่อการแตะเพียงครั้งเดียวบนแผนที่ เนื่องจากเมธอดนี้ได้รับละติจูดและลองจิจูดของตำแหน่งการแตะ คุณจึงตอบสนองด้วยการเลื่อนหรือซูมไปยังจุดนั้นได้
มีวิธีการที่คล้ายกันสำหรับการตอบสนองต่อการแตะฟองข้อความของเครื่องหมาย หรือสำหรับการตอบสนองต่อท่าทางสัมผัสการลากบนเครื่องหมาย
นอกจากนี้ คุณยังฟังการเคลื่อนไหวของกล้องเพื่อให้แอปได้รับการแจ้งเตือนเมื่อกล้องเริ่มเคลื่อนไหว กำลังเคลื่อนไหว หรือหยุดเคลื่อนไหวได้ด้วย โปรดดูรายละเอียดในคู่มือเหตุการณ์การเปลี่ยนแปลงของกล้อง
ตำแหน่งของกล้อง
มุมมองแผนที่จะจำลองเป็นกล้องที่มองลงมาบนพื้นผิวเรียบ ตำแหน่งของกล้อง (และการแสดงผลแผนที่) จะระบุด้วยพร็อพเพอร์ตี้ต่อไปนี้ target (latitude/longitude location), bearing, tilt และ zoom
เป้าหมาย (สถานที่ตั้ง)
เป้าหมายของกล้องคือตำแหน่งกึ่งกลางของแผนที่ ซึ่งระบุเป็นพิกัดละติจูดและลองจิจูด
ละติจูดอาจมีค่าระหว่าง -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 องศา องค์ประกอบระหว่างกล้องถ่ายรูปและตำแหน่งแผนที่จะปรากฏใหญ่ขึ้นตามสัดส่วน ส่วนองค์ประกอบที่อยู่นอกตำแหน่งแผนที่จะปรากฏเล็กลงตามสัดส่วน ซึ่งจะให้เอฟเฟกต์ภาพ 3 มิติ
ซูม
ระดับการซูมของกล้องจะเป็นตัวกำหนดมาตราส่วนของแผนที่ เมื่อซูมระดับสูงขึ้น จะเห็นรายละเอียดมากขึ้นบนหน้าจอ ขณะที่การซูมระดับต่ำลงจะทำให้เห็นพื้นที่บนโลกมากขึ้นบนหน้าจอ ที่ระดับการซูม 0 ขนาดของแผนที่คือโลกทั้งใบมีความกว้างประมาณ 256dp (พิกเซลที่ไม่ขึ้นกับความหนาแน่น)
การขยายระดับการซูม 1 จะเพิ่มความกว้างของโลกบนหน้าจอเป็น 2 เท่า ดังนั้น ที่ระดับการซูม N ความกว้างของโลกจึงเป็นประมาณ 256 * 2N dp เช่น เมื่อซูมระดับ 2 โลกทั้งใบจะกว้างประมาณ 1024 dp
ระดับการซูมไม่จำเป็นต้องเป็นจำนวนเต็ม ช่วงของระดับการซูมที่แผนที่อนุญาตจะขึ้นอยู่กับหลายปัจจัย เช่น เป้าหมาย ประเภทแผนที่ และขนาดหน้าจอ ตัวเลขใดๆ ที่อยู่นอกช่วงจะถูกแปลงเป็นค่าที่ถูกต้องถัดไป ซึ่งอาจเป็นระดับการซูมขั้นต่ำหรือระดับการซูมสูงสุดก็ได้ ระดับความละเอียดโดยประมาณที่คุณคาดว่าจะเห็นในแต่ละระดับการซูมมีดังนี้
- 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
ที่เพิ่ม (หรือลดลง หากค่าเป็นลบ) ระดับการซูมตามค่าที่ระบุ อุปกรณ์หลังแก้ไขจุดที่ระบุบนหน้าจอให้อยู่ในตำแหน่งเดิม (ละติจูด/ลองจิจูด) และอาจเปลี่ยนตำแหน่งของกล้องเพื่อให้บรรลุเป้าหมายนี้
การตั้งค่าระดับการซูมขั้นต่ำและ/หรือสูงสุดที่ต้องการอาจเป็นสิ่งที่เป็นประโยชน์ ตัวอย่างเช่น ฟีเจอร์นี้มีประโยชน์ในการควบคุมประสบการณ์ของผู้ใช้ในกรณีที่แอปแสดงพื้นที่ที่กําหนดไว้รอบๆ จุดที่น่าสนใจ หรือในกรณีที่คุณใช้การซ้อนทับไทล์ที่กําหนดเองซึ่งมีชุดระดับการซูมที่จํากัด
Kotlin
private lateinit var map: GoogleMap map.setMinZoomPreference(6.0f) map.setMaxZoomPreference(14.0f)
Java
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
Kotlin
val australiaBounds = LatLngBounds( LatLng((-44.0), 113.0), // SW bounds LatLng((-10.0), 154.0) // NE bounds ) map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 0))
Java
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)
กับ LatLngBounds
getCenter()
เมธอด getCenter() จะแสดงผลศูนย์กลางทางภูมิศาสตร์ของ LatLngBounds
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))
Java
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 จะคำนวณขอบเขตการแสดงผลจากอาร์กิวเมนต์ที่คุณส่ง
การจำกัดการแพนกล้องของผู้ใช้ไปยังพื้นที่ที่กำหนด
ในสถานการณ์ข้างต้น คุณสามารถตั้งค่าขอบเขตของแผนที่ แต่หลังจากนั้นผู้ใช้สามารถเลื่อนหรือเลื่อนออกนอกขอบเขตเหล่านี้ได้ คุณอาจต้องจำกัดขอบเขตจุดศูนย์กลางละติจูด/ลองจิจูดของจุดโฟกัสของแผนที่ (เป้าหมายของกล้อง) เพื่อให้ผู้ใช้เลื่อนและเลื่อนดูภายในขอบเขตเหล่านี้ได้เท่านั้น ตัวอย่างเช่น แอปค้าปลีกของศูนย์การค้าหรือสนามบินอาจต้องการจำกัดแผนที่ให้อยู่ในขอบเขตหนึ่งๆ เพื่อให้ผู้ใช้สามารถเลื่อนและเลื่อนภายในขอบเขตเหล่านั้นได้
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)
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);
แผนภาพต่อไปนี้แสดงสถานการณ์เมื่อเป้าหมายของกล้องถูกจำกัดให้อยู่ในบริเวณที่ใหญ่กว่าวิวพอร์ตเล็กน้อย ผู้ใช้สามารถเลื่อนและเลื่อนดูได้ ตราบใดที่เป้าหมายของกล้องยังคงอยู่ในขอบเขต เครื่องหมายกากบาทแสดงถึงเป้าหมายของกล้อง ดังนี้
แผนที่จะขยายเต็มวิวพอร์ตเสมอ แม้ว่าจะทำให้วิวพอร์ตแสดงพื้นที่ที่อยู่นอกขอบเขตที่กําหนดไว้ก็ตาม ตัวอย่างเช่น หากคุณวางตำแหน่งเป้าหมายของกล้องไว้ที่มุมของพื้นที่ที่มีขอบเขต พื้นที่ที่อยู่อีกมุมหนึ่งจะปรากฏในวิวพอร์ต แต่ผู้ใช้จะเลื่อนเข้าไปในพื้นที่นั้นไม่ได้ แผนภาพต่อไปนี้จะแสดงสถานการณ์นี้ เครื่องหมายกากบาทแสดงถึง เป้าหมายของกล้อง
ในแผนภาพต่อไปนี้ เป้าหมายของกล้องมีขอบเขตที่จำกัดมาก ซึ่งทำให้ผู้ใช้มีโอกาสเลื่อนหรือเลื่อนแผนที่ได้น้อยมาก เครื่องหมายกากบาทแสดงถึง เป้าหมายของกล้อง ดังนี้
อัปเดตมุมมองกล้อง
หากต้องการใช้ 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
ข้อมูลโค้ดต่อไปนี้แสดงวิธีทั่วไปในการเคลื่อนย้ายกล้อง
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))
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));