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

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

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

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

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

บทนำ

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

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

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

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

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

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

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

มุมมองแผนที่จะจำลองเป็นกล้องที่มองลงมายังระนาบแบน ตำแหน่ง ของกล้อง (และด้วยเหตุนี้การแสดงผลของแผนที่) จะระบุโดย พร็อพเพอร์ตี้ต่อไปนี้: เป้าหมาย (ตำแหน่งละติจูด/ลองจิจูด), ทิศ, การเอียง, และ การซูม

เป้าหมาย (ตำแหน่ง)

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

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

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

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

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

การเอียง (มุมมอง)

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

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

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

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

ซูม

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

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

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

• 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 ที่เพิ่ม (หรือลด หากค่าเป็น ลบ) ระดับการซูมตามค่าที่กำหนด ส่วนตัวเลือกหลังจะตรึงจุดที่กำหนดบนหน้าจอไว้เพื่อให้จุดนั้นยังคงอยู่ที่ตำแหน่งเดิม (ละติจูด/ลองจิจูด) และอาจเปลี่ยนตำแหน่งของกล้องเพื่อให้เป็นไปตามนี้

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

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 ไม่อนุญาตให้ผู้ใช้ซูมต่ำหรือสูงเกินไป เช่น ดาวเทียมหรือภูมิประเทศอาจมีการซูมสูงสุดต่ำกว่า Map Tiles แผนที่ฐาน

การเปลี่ยนตำแหน่งกล้อง

มีเมธอดอำนวยความสะดวก 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) กับ LatLngBoundsเมธอด getCenter() เมธอด 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);

      

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

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

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

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

หากต้องการใช้ CameraUpdate กับแผนที่ คุณสามารถย้าย กล้องทันทีหรือสร้างภาพเคลื่อนไหวให้กล้องเคลื่อนที่อย่างราบรื่นก็ได้ หากต้องการย้ายกล้อง ทันทีด้วย CameraUpdate ที่กำหนด คุณสามารถเรียกใช้ GoogleMap.moveCamera(CameraUpdate)

คุณสามารถทำให้ประสบการณ์การใช้งานของผู้ใช้ดียิ่งขึ้นได้ โดยเฉพาะอย่างยิ่งสำหรับการเคลื่อนที่ระยะสั้น โดยการสร้างภาพเคลื่อนไหวของการเปลี่ยนแปลง หากต้องการทำเช่นนี้ ให้เรียกใช้ GoogleMap.animateCameraแทนการเรียกใช้ GoogleMap.moveCamera แผนที่จะเคลื่อนที่อย่างราบรื่นไปยังแอตทริบิวต์ใหม่ รูปแบบที่ละเอียดที่สุดของเมธอดนี้ GoogleMap.animateCamera(cameraUpdate, duration, callback) มีอาร์กิวเมนต์ 3 รายการดังนี้

cameraUpdate

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