מצלמה ותצוגה

באמצעות Maps SDK ל-iOS, אפשר לשנות את נקודת המבט של המשתמש במפה על ידי שינוי המצלמה של המפה.

בעזרת SDK של מפות ל-iOS, המשתמשים יכולים להטות ולסובב את המפות כדי להתאים אותן לכיוון שמתאים להקשר שלהם. בכל רמת התמקדות, המשתמשים יכולים להזיז את המפה או לשנות את נקודת המבט שלה עם זמן אחזור קצר מאוד.

שינויים במצלמה לא משנים את הסמנים, הקווים הפוליגונים או רכיבי הגרפיקה האחרים שהוספתם, אבל כדאי לשנות את התוספות האלה כדי שיתאים יותר לתצוגה החדשה.

תצוגת המפה

ב-Maps SDK ל-iOS נעשה שימוש במישור מקרטור כדי לייצג את פני השטח של העולם (כדור) במסך של המכשיר (מישור שטוח).

מיקום המצלמה

תצוגת המפה מודללת כמצלמה שמביטה למטה על מישור שטוח. המיקום של המצלמה (ולכן הרינדור של המפה) מצוין באמצעות המאפיינים הבאים: target (מיקום קו רוחב/קו אורך),‏ bearing,‏ tilt ו-zoom.

יעד (מיקום)

יעד המצלמה הוא המיקום של מרכז המפה, שמצוין כקואורדינטות של רוחב וקו אורך.

כיוון (אוריינטציה)

כיוון המצלמה מציין את כיוון המצפן, שנמדד בזוויות מצפון אמיתי, ומתאים לקצה העליון של המפה. אם מציירים קו אנכי ממרכז המפה לקצה העליון שלה, המיקום תואם לכיוון המצלמה (שנמדד בדרגות) ביחס לצפון האמיתי.

כיוון של 0 מציין שהחלק העליון של המפה מצביע על צפון אמיתי. כשהערך של כיוון המצפן הוא 90, החלק העליון של המפה מצביע לכיוון מזרח (90 מעלות במצפן). ערך של 180 מציין שהחלק העליון של המפה מצביע ישירות דרומה.

באמצעות Maps API אפשר לשנות את כיוון המפה. לדוגמה, נהגים בדרך כלל מסובבים את מפת הכבישים כך שתתאים לכיוון הנסיעה שלהם, ואילו מטיילים שמשתמשים במפה ובמצפן בדרך כלל מסובבים את המפה כך שקו אנכי יצביע לכיוון צפון.

הטיה (זווית צפייה)

ההטיה מגדירה את מיקום המצלמה על קשת ישירות מעל מיקום המרכז של המפה, ומחושבת בזוויות מהנאדיר (הכיוון שמצביע ישירות מתחת למצלמה). ערך 0 מציין שמצלמה מופנית ישירות למטה. ערכים גדולים מ-0 מתאימים למצלמה שמשויכת לזווית מסוימת ביחס לאופק. כשמשנים את זווית התצוגה, המפה מוצגת בתצוגת תלת-ממד, שבה תכונות שנמצאות רחוק נראות קטנות יותר ותכונות שנמצאות קרוב נראות גדולות יותר. האיורים הבאים מדגימים זאת.

בתמונות הבאות, זווית הצפייה היא 0 מעלות. בתמונה הראשונה מוצגת תרשים של המצב הזה: המיקום 1 הוא מיקום המצלמה, והמיקום 2 הוא המיקום הנוכחי במפה. המפה שנוצרה מוצגת מתחתיו.

בתמונות הבאות, זווית הצפייה היא 45 מעלות. שימו לב שהמצלמה נעה למחצית קשת בין מיקום ישר מעל הראש (0 מעלות) לבין מיקום על הקרקע (90 מעלות), למיקום 3. המצלמה עדיין מכוונת לנקודת המרכז של המפה, אבל האזור שמיוצג על ידי הקו במיקום 4 גלוי עכשיו.

המפה בצילום המסך הזה עדיין ממוקדת באותה נקודה כמו במפה המקורית, אבל תכונות נוספות הופיעו בחלק העליון של המפה. ככל שהזווית גדלה מעבר ל-45 מעלות, האובייקטים שבין המצלמה לבין מיקום המפה נראים גדולים יותר באופן יחסי, ואילו האובייקטים שמעבר למיקום המפה נראים קטנים יותר באופן יחסי, וכך נוצר אפקט תלת-ממדי.

שינוי מרחק התצוגה

רמת הזום של המצלמה קובעת את קנה המידה של המפה. ברמות זום גדולות יותר אפשר לראות יותר פרטים במסך, וברמות זום קטנות יותר אפשר לראות יותר מהעולם במסך. ברמת הזום 0, קנה המידה של המפה הוא כזה שרוחב העולם כולו הוא כ-256 נקודות.

הגדלת רמת הזום ב-1 מגדילה את רוחב העולם במסך פי 2. לכן ברמת הזום N, רוחב העולם הוא כ-256 * 2^N נקודות. לדוגמה, ברמת זום 2, העולם כולו רחב כ-1,024 נקודות.

רמת הזום לא חייבת להיות מספר שלם. טווח רמות הזום המותרות במפה תלוי בכמה גורמים, כולל היעד, סוג המפה וגודל המסך. כל מספר מחוץ לטווח יופיע כערך החוקי הקרוב ביותר, שיכול להיות רמת הזום המינימלית או רמת הזום המקסימלית. ברשימה הבאה מפורטת רמת הפירוט המשוערת שאפשר לראות בכל רמת זום:

• 1: עולם
• 5: יבשת
• 10: עיר
• 15: רחובות
• 20: מבנים

הגדרת המיקום הראשוני של המצלמה

מגדירים את מיקום המצלמה הראשוני באמצעות האובייקט GMSCameraPosition, שמאפשר להגדיר את קו הרוחב ואת קו האורך של היעד, יחד עם כיוון, הטיה וזום.

כדי להגדיר את המיקום הראשוני של המצלמה, יוצרים אובייקט GMSMapViewOptions ומגדירים את המאפיין camera ל-GMSCameraPosition. לאחר מכן מעבירים את האפשרויות ל-constructor הנוח GMSMapView.

let options = GMSMapViewOptions()
options.camera = GMSCameraPosition.camera(withLatitude: -33.8683, longitude: 151.2086, zoom: 16)
let mapView = GMSMapView(options:options)

GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.camera = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                        longitude:151.2086
                                                             zoom:16];
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];

אפשר גם ליצור את האובייקט GMSMapView באמצעות שיטת ה-init של UIView שמוגדרת כברירת מחדל. במקרה כזה, מיקום המצלמה מתחיל במיקום ברירת המחדל, ואפשר לשנות אותו אחרי היצירה.

let options = GMSMapViewOptions()
options.frame = self.view.bounds
let mapView = GMSMapView(options:options)

GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.frame = self.view.bounds;
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];

שינוי מיקום המצלמה

אפשר לשנות את מיקום המצלמה באופן פרוגרמטי כדי להגדיר את המיקום, כיוון המצלמה, ההטיה והמרחק. ב-GMSMapView יש כמה שיטות שאפשר להשתמש בהן כדי לשנות את מיקום המצלמה, אבל בדרך כלל משתמשים ב-GMSCameraPosition או ב-GMSCameraUpdate:

• GMSCameraPosition מכיל מאפיינים ושיטות שבהם משתמשים כדי לשנות כל פרמטר של מיקום המצלמה: יעד, כיוון, הטיה וזום.

• GMSCameraUpdate מאפשר לשנות את היעד, את הכיוון, את ההטיה ואת מרחק התצוגה. בנוסף, הוא מכיל שיטות נוחות נוספות לתמיכה בגלילה, בהגדלת התצוגה מתקדמת, בהצגת המצלמה במרכז תוך התמקדות בגבולות מוגדרים מראש ועוד.

כשמזיזים את המצלמה, אפשר לבחור אם להעביר אותה למיקום החדש 'בבת אחת', כלומר בלי אנימציה, או להוסיף אנימציה לתנועה. לדוגמה, אם תוסיפו אנימציה לשינוי במיקום היעד של המצלמה, האנימציה תזוז מהמיקום הקודם למיקום החדש.

האנימציה מבצעת אינטרפולציה בין מאפייני המצלמה הנוכחיים לבין מאפייני המצלמה החדשים. אפשר לשלוט במשך האנימציה באמצעות Core Animation.

שימוש ב-GMSCameraPosition

כדי לשנות את המצלמה באמצעות GMSCameraPosition, יוצרים או מעתיקים אובייקט קיים ומגדירים אותו באובייקט GMSMapView. משתמשים באובייקט GMSCameraPosition כדי להעביר את המצלמה למיקום החדש, עם או בלי אנימציה.

משתמשים באובייקט GMSCameraPosition כדי להגדיר את מאפייני המצלמה, כמו קו הרוחב, קו האורך, הזום, כיוון הצפון וזווית הצפייה. לאחר מכן משתמשים באובייקט הזה כדי להגדיר את המאפיין camera של GMSMapView.

let fancy = GMSCameraPosition(
  latitude: -33,
  longitude: 151,
  zoom: 6,
  bearing: 270,
  viewingAngle: 45
)
mapView.camera = fancy
      

GMSCameraPosition *fancy = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                       longitude:151.2086
                                                            zoom:6
                                                         bearing:30
                                                    viewingAngle:45];
[mapView setCamera:fancy];
      

משמיטים כל מאפיין GMSCameraPosition שרוצים להגדיר לערך ברירת המחדל שלו.

כדי ליצור אנימציה של המעבר, משתמשים בשיטה animateToCameraPosition: במקום להגדיר את המאפיין camera.

שימוש ב-GMSCameraUpdate

GMSCameraUpdate מאפשרת לעדכן את מיקום המצלמה ולבחור אם להצמיד את המצלמה למיקום החדש או להציג אנימציה של המעבר למיקום החדש. היתרון של GMSCameraUpdate הוא הנוחות. אפשר להשתמש ב-GMSCameraPosition כדי לבצע את אותן משימות כמו GMSCameraUpdate, אבל GMSCameraUpdate מספק שיטות עזר נוספות שמקלות על מניפולציה במצלמה.

לדוגמה, כדי להשתמש ב-GMSCameraPosition כדי להגדיל את רמת הזום הנוכחית, קודם צריך לקבוע את רמת הזום הנוכחית ואז ליצור אובייקט GMSCameraPosition שבו מגדירים את הזום לערך גבוה באחד מהזום הנוכחי.

לחלופין, אפשר ליצור אובייקט GMSCameraUpdate באמצעות השיטה zoomIn:. לאחר מכן מעדכנים את המצלמה על ידי העברת האובייקט GMSCameraUpdate לשיטה animateWithCameraUpdate: של GMSMapView.

// Zoom in one zoom level
let zoomCamera = GMSCameraUpdate.zoomIn()
mapView.animate(with: zoomCamera)
      

// Zoom in one zoom level
GMSCameraUpdate *zoomCamera = [GMSCameraUpdate zoomIn];
[mapView animateWithCameraUpdate:zoomCamera];
      

במקום זאת, משתמשים בשיטה GMSMapView moveCamera: כדי להצמיד את המצלמה למיקום החדש.

בדוגמה הבאה נעשה שימוש ב-GMSCameraUpdate כדי ליצור אנימציה של תנועת המצלמה כדי למרכז אותה בוונקובר.

// Center the camera on Vancouver, Canada
let vancouver = CLLocationCoordinate2D(latitude: 49.26, longitude: -123.11)
let vancouverCam = GMSCameraUpdate.setTarget(vancouver)
mapView.animate(with: vancouverCam)
      

// Center the camera on Vancouver, Canada
CLLocationCoordinate2D vancouver = CLLocationCoordinate2DMake(49.26, -123.11);
GMSCameraUpdate *vancouverCam = [GMSCameraUpdate setTarget:vancouver];
[mapView animateWithCameraUpdate:vancouverCam];
      

יצירה של אובייקט GMSCameraUpdate

יוצרים אובייקט GMSCameraUpdate באמצעות אחת מהשיטות שלו.

zoomIn: וגם zoomOut:

שינוי רמת הזום הנוכחית ב-1.0, תוך שמירה על כל המאפיינים האחרים.

zoomTo:

שינוי רמת הזום לערך שצוין, תוך שמירה על כל שאר המאפיינים.

zoomBy:

הגדלת (או הפחתת, אם הערך שלילי) רמת הזום לפי הערך שצוין.

zoomBy:atPoint:

הגדלת (או הפחתת, אם הערך שלילי) רמת הזום לפי הערך שצוין, תוך שמירה על המיקום של הנקודה שצוינה במסך.

setTarget:

שינוי קו הרוחב ואורך הגלובוס של המצלמה, תוך שמירה על כל שאר המאפיינים.

setTarget:zoom:

שינוי קו הרוחב, קו האורך והזום של המצלמה, תוך שמירה על כל המאפיינים האחרים.

setCamera:

הגדרת GMSCameraPosition חדש.

scrollByX:Y:

שינוי קו הרוחב ואורך הגלובוס של המצלמה כדי להזיז את המפה במספר הנקודות שצוין. ערך x חיובי גורם למצלמה לזוז ימינה, כך שנראה שהמפה זזה שמאלה. ערך y חיובי גורם למצלמה לזוז למטה, כך שהמפה נראית כאילו היא זזה למעלה. הגלילה היא ביחס לכיוון הנוכחי של המצלמה. לדוגמה, אם למצלמה יש כיוון של 90 מעלות, אז מזרח הוא 'למעלה'.

fitBounds:

המרת המצלמה כדי למרכז את הגבולות שצוינו במסך ברמת הזום הגבוהה ביותר האפשרית. החלת ברירת מחדל של 64 נקודות למרווחים.

fitBounds:withPadding:

המרת המצלמה כדי למקם את הגבולות שצוינו במרכז המסך ברמת הזום הגבוהה ביותר האפשרית. משתמשים בשיטה הזו כדי לציין את אותו רווח, בפונקציית point, לכל הצדדים של תיבת הגבול.

fitBounds:withEdgeInsets:

המרת המצלמה כדי למקם את הגבולות שצוינו במרכז המסך ברמת הזום הגבוהה ביותר האפשרית. בעזרת UIEdgeInsets, אפשר לציין את המילוי לכל צד של תיבת הגבול בנפרד.

שימוש ב-GMSMapView כדי לשנות נכס יחיד

GMSMapView מכיל כמה שיטות שמאפשרות להזיז את המצלמה בלי להשתמש באובייקט GMSCameraPosition או באובייקט GMSCameraUpdate. באמצעות השיטות האלה, כמו animateToLocation: או animateToZoom:, אפשר ליצור אנימציה של שינוי במאפיין יחיד של מצלמה.

לדוגמה, אפשר להשתמש בשיטה toViewingAngle: כדי ליצור אנימציה של שינוי בנטייה של המצלמה.

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

הגדרת יעד (מיקום)

המיקום קובע את מרכז המפה. המיקומים מצוינים לפי קו רוחב וקו אורך, ונציגים באופן פרוגרמטי באמצעות CLLocationCoordinate2D שנוצר באמצעות CLLocationCoordinate2DMake.

משנים את המיקום באמצעות GMSCameraPosition. בדוגמה הזו, המפה מתמקדת במיקום החדש.

let target = CLLocationCoordinate2D(latitude: -33.868, longitude: 151.208)
mapView.camera = GMSCameraPosition(target: target, zoom: 6)
      

CLLocationCoordinate2D target =
    CLLocationCoordinate2DMake(-33.868, 151.208);
mapView.camera = [GMSCameraPosition cameraWithTarget:target zoom:6];
      

כדי להציג את השינוי באנימציה ולהזיז את המפה למיקום החדש, אפשר להשתמש ב-method‏ animateToCameraPosition: במקום להגדיר את המאפיין camera. לחלופין, אפשר להשתמש בשיטה animateToLocation: ב-GMSMapView.

mapView.animate(toLocation: CLLocationCoordinate2D(latitude: -33.868, longitude: 151.208))
      

[mapView animateToLocation:CLLocationCoordinate2DMake(-33.868, 151.208)];
      

אפשר גם ליצור אובייקט GMSCameraUpdate כדי להזיז את המצלמה. משתמשים בשיטה המובנית scrollByX:Y: כדי לציין את מספר הנקודות שעליהן רוצים לגלול את המצלמה בכיוונים X ו-Y. בדוגמה הזו, גוללים במצלמה 200 נקודות ימינה ו-100 נקודות למטה:

// Move the camera 200 points to the right, and 100 points downwards
let downwards = GMSCameraUpdate.scrollBy(x: 200, y: 100)
mapView.animate(with: downwards)
      

// Move the camera 200 points to the right, and 100 points downwards
GMSCameraUpdate *downwards = [GMSCameraUpdate scrollByX:200.0 Y:100.0];
[mapView animateWithCameraUpdate:downwards];
      

הגדרת כיוון (כיוון)

כיוון המצפן הוא כיוון הקצה העליון של המפה, שנמדד בדרגות מצפון אמיתי. לדוגמה, כיוון של 90 מעלות גורם לכך שהקצה העליון של המפה יצביע לכיוון מזרח.

מגדירים את הכיוון באופן פרוגרמטי באמצעות GMSCameraPosition או GMSCameraUpdate, או באמצעות השיטה animateToBearing: של GMSMapView.

mapView.animate(toBearing: 0)
      

[mapView animateToBearing:0];
      

הגדרת הטיה (זווית צפייה)

זווית התצוגה היא המיקום של המצלמה על קשת בין מיקום מרכז המפה לבין פני כדור הארץ, שנמדדת בזוויות מנקודת הנדיאר (הכיוון שמצביע ישירות מתחת למצלמה). כשמשנים את זווית הצפייה, המפה מוצגת בתצוגת תלת-ממד, שבה תכונות שבין המצלמה לבין מיקום המפה נראות גדולות יותר באופן יחסי, ותכונות שמעבר למיקום המפה נראות קטנות יותר באופן יחסי.

זווית הצפייה יכולה לנוע בין 0 (מצב שבו המכשיר מכוון ישירות למטה אל המפה) ועד למקסימום שנקבע לפי רמת הזום. ברמת זום 16 ואילך, הזווית המקסימלית היא 65 מעלות. ברמת זום 10 ומטה, הזווית המקסימלית היא 30 מעלות.

מגדירים את זווית הצפייה באופן פרוגרמטי באמצעות GMSCameraPosition או GMSCameraUpdate, או באמצעות השיטה animateToViewingAngle: של GMSMapView.

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

הגדרת מרחק התצוגה

רמת הזום של המצלמה קובעת את קנה המידה של המפה. ברמות זום גדולות יותר אפשר לראות יותר פרטים במסך, וברמות זום קטנות יותר אפשר לראות יותר מהעולם.

מגדירים את הזום באופן פרוגרמטי באמצעות GMSCameraPosition או GMSCameraUpdate, או באמצעות השיטה animateToZoom: של GMSMapView.

mapView.animate(toZoom: 12)
      

[mapView animateToZoom:12];
      

בדוגמה הבאה נעשה שימוש בשיטה zoomIn: כדי ליצור אובייקט GMSCameraUpdate שמציג אנימציה של הגדלת התצוגה ברמה אחת מהרמה הנוכחית.

// Zoom in one zoom level
let zoomCamera = GMSCameraUpdate.zoomIn()
mapView.animate(with: zoomCamera)
      

// Zoom in one zoom level
GMSCameraUpdate *zoomCamera = [GMSCameraUpdate zoomIn];
[mapView animateWithCameraUpdate:zoomCamera];
      

הגדרת גבולות

כדי להזיז את המצלמה כך שכל אזור העניין יהיה גלוי ברמת הזום הגבוהה ביותר, מגדירים גבולות לתצוגה של המצלמה. לדוגמה, אם רוצים להציג את כל תחנות הדלק שנמצאות בטווח של 8 ק"מ מהמיקום הנוכחי של המשתמש, צריך להזיז את המצלמה כך שכל התחנות יהיו גלויות במסך:

1. מחשבים את GMSCoordinateBounds שרוצים שיוצג במסך.
2. משתמשים בשיטה cameraForBounds:insets: של GMSMapView כדי להחזיר GMSCameraPosition חדש.

הגדרת הגבולות האלה מבטיחה ש-GMSCoordinateBounds יתאים לחלוטין לגודל המפה הנוכחית. שימו לב שבשיטה הזו, השיפוע והכיוון של המפה מוגדרים ל-0.

בדוגמה הבאה מוסבר איך לשנות את המיקום של המצלמה כדי ששתי הערים, וונקובר וקלגרי, יופיעו באותה תצוגה.

let vancouver = CLLocationCoordinate2D(latitude: 49.26, longitude: -123.11)
let calgary = CLLocationCoordinate2D(latitude: 51.05,longitude: -114.05)
let bounds = GMSCoordinateBounds(coordinate: vancouver, coordinate: calgary)
let camera = mapView.camera(for: bounds, insets: UIEdgeInsets())!
mapView.camera = camera
      

CLLocationCoordinate2D vancouver = CLLocationCoordinate2DMake(49.26, -123.11);
CLLocationCoordinate2D calgary = CLLocationCoordinate2DMake(51.05, -114.05);
GMSCoordinateBounds *bounds =
    [[GMSCoordinateBounds alloc] initWithCoordinate:vancouver coordinate:calgary];
GMSCameraPosition *camera = [mapView cameraForBounds:bounds insets:UIEdgeInsetsZero];
mapView.camera = camera;
      

הגבלת התנועת הצידה של המשתמש לאזור נתון

התרחישים האלה מגדירים את גבולות המפה, אבל המשתמש יכול לגלול או להזיז את המפה מחוץ לגבולות האלה. במקום זאת, כדאי להגביל את גבולות מרכז הקואורדינטות של נקודת המוקד במפה (יעד המצלמה) כך שמשתמשים יוכלו לגלול ולסובב רק בתוך הגבולות האלה.

לדוגמה, באפליקציה של מרכז קניות או של שדה תעופה יכול להיות שתרצו להגביל את המפה לגבולות ספציפיים, כדי לאפשר למשתמשים לגלול ולזוז בתוך הגבולות האלה.

כדי להגביל את ההחלקה לגבולות ספציפיים, מגדירים את המאפיין cameraTargetBounds של GMSMapView לאובייקט GMSCoordinateBounds שמגדיר את הגבולות הנדרשים. כדי להסיר את ההגבלה מאוחר יותר, מגדירים את cameraTargetBounds לאפס.

mapView.cameraTargetBounds = bounds
      

mapView.cameraTargetBounds = bounds;
      

התרשים הבא מדגים תרחיש שבו יעד המצלמה מוגבל לאזור שהוא גדול במעט מאזור התצוגה. המשתמש יכול לגלול ולזוז, בתנאי שהמטרה של המצלמה נשארת בתוך האזור המוגדר. הצלב מייצג את יעד המצלמה:

המפה תמיד ממלאת את אזור התצוגה, גם אם כתוצאה מכך מוצגים באזור התצוגה אזורים מחוץ לגבולות שהוגדרו. לדוגמה, אם ממקמים את יעד המצלמה בפינה של האזור המוגדר, האזור שמעבר לפינה גלוי באזור התצוגה, אבל המשתמשים לא יכולים לגלול לאזור הזה. התרחיש הזה מתואר בתרשים הבא. הצלב מייצג את היעד של המצלמה:

בתרשים הבא, לטווח המצלמה יש גבולות מוגבלים מאוד, ולמשתמש יש מעט מאוד אפשרויות לגלול במפה או לשנות את זווית התצוגה שלה. הצלב מייצג את היעד של המצלמה:

הגדרת זום מינימלי או מקסימלי

הקבועים הגלובליים kGMSMinZoomLevel ו-kGMSMaxZoomLevel מגדירים את ערכי הזום המינימלי או המקסימלי. כברירת מחדל, המאפיינים minZoom ו-maxZoom של GMSMapView מוגדרים לערכים הקבועים האלה.

כדי להגביל את טווח רמות הזום שזמינות במפה, מגדירים רמת זום מינימלית ורמת זום מקסימלית. הקוד הבא מגביל את רמת הזום לטווח שבין 10 ל-15.

let camera = GMSCameraPosition(
  latitude: 41.887,
  longitude: -87.622,
  zoom: 12
)
let mapView = GMSMapView(frame: .zero, camera: camera)
mapView.setMinZoom(10, maxZoom: 15)
      

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:41.887
                                                       longitude:-87.622
                                                             zoom:12];
GMSMapView *mapView = [GMSMapView mapWithFrame:CGRectZero
                                        camera:camera];
[mapView setMinZoom:10 maxZoom:15];
      

צריך להגדיר את טווח הזום באמצעות השיטה setMinZoom:maxZoom:, אבל אפשר לקרוא את הערכים הנוכחיים באמצעות המאפיינים minZoom ו-maxZoom. הגישה הזו שימושית כשרוצים להגביל רק אחד מהערכים. הקוד הבא משנה רק את רמת הזום המינימלית.

mapView.setMinZoom(12, maxZoom: mapView.maxZoom)
      

[mapView setMinZoom:12 maxZoom:mapView.maxZoom];
      

אם אחרי עדכון רמת הזום המינימלית והמקסימלית, רמת הזום של המצלמה מוגדרת לערך מחוץ לטווח החדש, רמת הזום הנוכחית מתעדכנת באופן אוטומטי כדי להציג את הערך החוקי הקרוב ביותר. לדוגמה, בקוד הבא, התצוגה המקורית מוגדרת כ-4. כשמרחק התצוגה יוגדר מאוחר יותר ל-10-15, מרחק התצוגה הנוכחי יתעדכן ל-10.

// Sets the zoom level to 4.
let camera2 = GMSCameraPosition(
  latitude: 41.887,
  longitude: -87.622,
  zoom: 4
)
let mapView2 = GMSMapView(frame: .zero, camera: camera)

// The current zoom, 4, is outside of the range. The zoom will change to 10.
mapView.setMinZoom(10, maxZoom: 15)
      

// Sets the zoom level to 4.
GMSCameraPosition *camera2 = [GMSCameraPosition cameraWithLatitude:41.887
                                                         longitude:-87.622
                                                              zoom:4];
GMSMapView *mapView2 = [GMSMapView mapWithFrame:CGRectZero
                                         camera:camera];
// The current zoom, 4, is outside of the range. The zoom will change to 10.
[mapView setMinZoom:10 maxZoom:15];