แผนที่ใน 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 องศา ฟีเจอร์ระหว่างกล้องและตําแหน่งในแผนที่จะมีสัดส่วนที่มากขึ้น ส่วนฟีเจอร์ที่อยู่นอกตําแหน่งแผนที่จะมีสัดส่วนน้อยลง ทําให้ได้เอฟเฟกต์ 3 มิติ
ซูม
ระดับการซูมของกล้องจะเป็นตัวกําหนดขนาดของแผนที่ สําหรับระดับการซูมที่มากขึ้น คุณดูรายละเอียดเพิ่มเติมบนหน้าจอได้ ส่วนระดับการซูมที่เล็กลงจะยิ่งเห็นโลกได้ง่ายขึ้น ในระดับการซูม 0 ขนาดของแผนที่ จะหมายความว่าทั่วโลกมีความกว้างประมาณ 256dp (ความหนาแน่นของพิกเซล)
การเพิ่มระดับการซูมเป็น 1 เท่าของความกว้างของโลกบนหน้าจอ ดังนั้นที่ระดับการซูม N ความกว้างของโลกจะอยู่ที่ประมาณ 256 * 2N dp เช่น ที่ระดับการซูม 2 โลกทั้งใบมีความกว้างประมาณ 1024 dp
ระดับการซูมต้องเป็นจํานวนเต็ม ช่วงระดับการซูมที่แผนที่อนุญาตขึ้นอยู่กับปัจจัยหลายอย่าง ซึ่งรวมถึงเป้าหมาย ประเภทแผนที่ และขนาดหน้าจอ ระบบจะแปลงตัวเลขที่ไม่ใช่ช่วงเป็นค่าที่ใช้ได้ใกล้เคียงที่สุด ซึ่งอาจเป็นระดับการซูมขั้นต่ําหรือระดับการซูมสูงสุด รายการต่อไปนี้แสดงรายละเอียดระดับโดยประมาณที่คุณจะพบที่การซูมแต่ละระดับ
- 1: โลก
- 5: ผืนดิน/ทวีป
- 10: เมือง
- 15: ถนน
- 20: อาคาร
![]() |
![]() |
![]() |
การเคลื่อนย้ายกล้อง
Maps 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 องศา ทิศตะวันออกจะแสดงเป็น "ขึ้น"
การกําหนดขอบเขต
การกําหนดขอบเขตของแผนที่
บางครั้งก็มีประโยชน์ในการขยับกล้องโดยให้พื้นที่ที่สนใจทั้งหมดมองเห็นได้ที่ระดับการซูมที่ดีที่สุด เช่น หากแสดงปั๊มน้ํามันทั้งหมดภายในระยะทาง 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))
การดูแผนที่อยู่ตรงกลางภายในพื้นที่
ในบางกรณี คุณอาจต้องจัดกล้องให้อยู่กลางขอบเขตแทนที่จะใส่เส้นขอบมากเกินไป เช่น เพื่อจัดตําแหน่งกล้องให้อยู่กึ่งกลางของประเทศ
โดยรักษาการซูมให้คงที่ ในกรณีนี้ คุณอาจใช้วิธีการที่คล้ายกันได้โดยสร้าง 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))