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

เลือกแพลตฟอร์ม: Android iOS JavaScript

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

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

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

เกริ่นนำ

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

ภาพหน้าจอของแผนที่ที่มีกล้องอยู่ในตำแหน่งมุมมอง 0 องศา ที่ระดับการซูม 18 องศา
แผนที่ที่แสดงด้วยมุมมองเริ่มต้นของกล้อง
แผนภาพที่แสดงตำแหน่งเริ่มต้นของกล้องเหนือตำแหน่งแผนที่ โดยทำมุม 0 องศา
มุมมองเริ่มต้นของกล้อง

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

ภาพหน้าจอของแผนที่ที่มีกล้องอยู่ในตำแหน่งมุมมอง 45 องศา ที่ระดับการซูม 18
แผนที่ที่แสดงโดยมีมุมการดู 45 องศา
แผนภาพแสดงมุมมองของกล้องที่ตั้งค่าเป็น 45 องศา โดยยังคงตั้งค่าระดับการซูมเป็น 18 องศา
มุมมองของกล้อง 45 องศา

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

Zoom

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

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

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

  • 1: ข่าวทั่วโลก
  • 5: ผืนดินขนาดใหญ่/ทวีป
  • 10: เมือง
  • 15: ถนน
  • 20: อาคาร
รูปภาพต่อไปนี้จะแสดงลักษณะที่ปรากฏในระดับการซูมต่างๆ
ภาพหน้าจอของแผนที่ที่ระดับการซูม 5
แผนที่ที่ระดับการซูม 5
ภาพหน้าจอของแผนที่ที่ระดับการซูม 15
แผนที่ที่ระดับการซูม 15
ภาพหน้าจอของแผนที่ที่ระดับการซูม 20
แผนที่ที่ระดับการซูม 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) ร่วมกับ LatLngBoundsgetCenter() วิธี เมธอด 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);

      

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

แผนภาพแสดง LatLngBound ของกล้องที่มีขนาดใหญ่กว่าวิวพอร์ต

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

แผนภาพแสดงเป้าหมายของกล้องที่อยู่มุมขวาล่างของ LatLngBounds ของกล้อง

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

แผนภาพแสดง LatLngBound ของกล้องที่มีขนาดเล็กกว่าวิวพอร์ต

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

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