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

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

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

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

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

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

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

ซูม

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

การเพิ่มระดับการซูมเป็น 1 เท่าของความกว้างของโลกในหน้าจอ ดังนั้น ที่ระดับการซูม 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 GoogleMap map;
    map.setMinZoomPreference(6.0f);
    map.setMaxZoomPreference(14.0f);

      

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 องศา ทิศตะวันออกจะเท่ากับ "ขึ้น"

การกําหนดขอบเขต

การกําหนดขอบเขตของแผนที่

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

LatLngBounds australiaBounds = new LatLngBounds(
    new LatLng(-44, 113), // SW bounds
    new LatLng(-10, 154)  // NE bounds
);
map.moveCamera(CameraUpdateFactory.newLatLngBounds(australiaBounds, 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 และใช้ CameraUpdateFactory.newLatLngZoom(LatLng latLng, float zoom) กับ LatLngBoundsgetCenter() เมธอด getCenter() จะส่งคืน ศูนย์ทางภูมิศาสตร์ของ LatLngBounds

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

      

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 จะคํานวณขอบเขตการแสดงผลจากอาร์กิวเมนต์ที่คุณส่ง

จํากัดการแพนกล้องของผู้ใช้ตามพื้นที่ที่กําหนด

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

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

      

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

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

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

      

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