תחילת העבודה עם SDK SDK ל-iOS

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

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

דרישות מערכת מינימליות

  • במכשיר הנייד צריכה לפעול מערכת iOS מגרסה 14 ואילך.
  • Xcode מגרסה 15 ואילך.

    • הגדרות אישיות של פרויקט

    מנהל חבילות Swift

    אפשר להתקין את Consumer SDK דרך מנהל החבילות של Swift. כדי להוסיף את ה-SDK, צריך להסיר את כל יחסי התלות של ה-SDK של הצרכן.

    כדי להוסיף את ה-SDK לפרויקט חדש או קיים, מבצעים את השלבים הבאים:

    1. פותחים את ה-Xcode project או את workspace, ואז עוברים אל 'קובץ' > 'הוספת יחסי תלות של חבילה'.
    2. מזינים את הכתובת https://github.com/googlemaps/ios-consumer-sdk, מקישים על Enter כדי לצרף את החבילה ולוחצים על Add Package (הוספת חבילה).
    3. כדי להתקין version ספציפי, מגדירים את השדה כלל תלות לאחת מהאפשרויות שמבוססות על גרסה. בפרויקטים חדשים, מומלץ לציין את הגרסה העדכנית ביותר ולהשתמש באפשרות 'גרסה מדויקת'. בסיום, לוחצים על 'הוספת חבילה'.
    4. בחלון בחירת מוצרי חבילה, מוודאים שהשדה GoogleRidesharingConsumer יתווסף ליעד ה-main הייעודי. בסיום, לוחצים על 'הוספת חבילה'.
    5. כדי לאמת את ההתקנה, עוברים לחלונית General של היעד. ב-Frameworks, בספריות ובתוכן מוטמע אתם אמורים לראות את החבילות המותקנות. אפשר גם להציג את הקטע 'תלויי חבילה' ב-'Project Navigator' כדי לאמת את החבילה והגרסה שלה.

    כדי לעדכן את package בפרויקט קיים:

    1. מ-Xcode, עוברים אל 'קובץ > חבילות > עדכון לגרסאות האחרונות של החבילה'.
    2. כדי לאמת את ההתקנה, עוברים לקטע תלויי חבילה ב-Project Navigator ומאמתים את החבילה והגרסה שלה.

    כדי להסיר יחסי תלות קיימים של Consumer SDK שנוספו באמצעות CocoaPods, צריך לפעול לפי השלבים הבאים:

    1. סגירת סביבת העבודה של Xcode. פותחים את הטרמינל ומריצים את הפקודה הבאה: 
      sudo gem install cocoapods-deintegrate cocoapods-clean 
pod deintegrate 
pod cache clean --all
    2. יש להסיר את ה-Podfile, Podfile.resolved ואת ה-Xcode workspace אם לא משתמשים בהם למטרה אחרת מלבד CocoaPods.

    כדי להסיר באופן ידני את Consumer SDK הקיים, בצע את השלבים הבאים:

    1. בהגדרות של פרויקט Xcode, מאתרים את Frameworks, ספריות ותוכן מוטמע. משתמשים בסימן המינוס(-) כדי להסיר את המסגרת הבאה:

      • GoogleRidesharingConsumer.xcframework

    2. מהספרייה ברמה העליונה של פרויקט Xcode, מסירים את החבילה GoogleRidesharingConsumer.

    CocoaPods

    כדי להגדיר את Consumer SDK באמצעות CocoaPods, נדרשים הפריטים הבאים:

    • הכלי CocoaPods: כדי להתקין את הכלי הזה, פותחים את Terminal ומריצים את הפקודה הבאה.

      sudo gem install cocoapods

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

    1. יצירת Podfile עבור Consumer SDK ושימוש בו כדי להתקין את ה-API ואת יחסי התלות שלו. תחילה, צרו קובץ בשם Podfile בספריית הפרויקט. הקובץ הזה מגדיר את יחסי התלות של הפרויקט שלכם. לאחר מכן עורכים את ה-Podfile ומוסיפים את יחסי התלות. הדוגמה הבאה כוללת את יחסי התלות:

        source "https://github.com/CocoaPods/Specs.git"

  target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
    pod 'GoogleRidesharingConsumer'
  end

    2. שומרים את קובץ ה-Podfile. פותחים טרמינל ועוברים לספרייה שמכילה את ה-Podfile:

      cd <path-to-project>

    3. מריצים את הפקודה להתקנת pod. הפעולה הזו תתקין את ממשקי ה-API שצוינו ב-Podfile, יחד עם כל יחסי התלות שלהם.

      pod install

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

    התקנה ידנית

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

    צריך להוריד את הקובץ הבינארי ואת המשאבים של ה-SDK:

    1. מחלצים את הקבצים הדחוסים כדי לגשת ל-XCFramework ולמשאבים.

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

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

    4. כדי להתקין את ה-SDK לצרכן, גוררים את הקובץ GoogleRidesharingConsumer.xcframework אל הפרויקט בקטע מסגרות, ספריות ותוכן מוטמע. כשתתבקשו, בחרו באפשרות 'העתקת פריטים' לפי הצורך.

    5. גוררים את הקובץ GoogleRidesharingConsumer.bundle שהורדתם לספרייה ברמה העליונה של פרויקט ה-Xcode. כשמופיעה בקשה, בוחרים Copy items if needed.

    6. בוחרים את הפרויקט מתוך Project Navigator, ובוחרים את היעד של האפליקציה.

    7. פותחים את הכרטיסייה Build Phases, וב-Link Binary with Libraries מוסיפים את ה-frameworks והספריות הבאים, אם הם עדיין לא קיימים:

      • Accelerate.framework
      • CoreData.framework
      • CoreGraphics.framework
      • CoreImage.framework
      • CoreLocation.framework
      • CoreTelephony.framework
      • CoreText.framework
      • GLKit.framework
      • ImageIO.framework
      • libc++.tbd
      • libz.tbd
      • Metal.framework
      • OpenGLES.framework
      • QuartzCore.framework
      • SystemConfiguration.framework
      • UIKit.framework

    8. בוחרים את הפרויקט במקום ביעד ספציפי, ופותחים את הכרטיסייה Build Settings (הגדרות הפיתוח). בקטע Other Linker flags מוסיפים את -ObjC לניפוי הבאגים ולשחרור הנתונים. במקרה שההגדרות האלה לא מוצגות, משנים את המסנן בסרגל של Build Settings מ-Basic ל-All.

    הוספת קובץ מניפסט הפרטיות של Apple

    1. להורדת חבילת מניפסט הפרטיות עבור ה-SDK לצרכן ל-iOS: GoogleRidesharingConsumerPrivacy.
    2. צריך לחלץ את הקובץ כדי לגשת אל GoogleRidesharingConsumerPrivacy.bundle.
    3. מוסיפים את GoogleRidesharingConsumerPrivacy.bundle ל-ניווט בפרויקט Xcode באמצעות אחת מהשיטות האלה. מוודאים שהתיבה 'הוספה ליעדים' מסומנת לגבי היעד של האפליקציה. לאחר ההוספה, הקובץ PrivacyInfo יופיע בסרגל הניווט בפרויקט ותוכלו לבדוק את הערכים.
      4. צילום מסך של מידע על פרטיות ב-Xcode
    4. מוודאים שמניפסט הפרטיות נוסף על ידי יצירת ארכיון של האפליקציה ויצירת דוח פרטיות מהארכיון.

    שילוב אפליקציה

    יש לספק אסימון אימות

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

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

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

    לפרטים על האסימונים הצפויים על ידי שרת Fleet Engine, ראו יצירת אסימון אינטרנט מסוג JSON (JWT) להרשאה.

    מזהה הספק זהה למזהה הפרויקט ב-Google Cloud. למידע נוסף, קראו את המאמר תחילת העבודה עם מנוע Fleet.

    בדוגמה הבאה מוטמע ספק של אסימון גישה:

    Swift

    /*

    *   SampleAccessTokenProvider.swift
 */
import GoogleRidesharingConsumer

private let providerURL = "INSERT_YOUR_TOKEN_PROVIDER_URL"

class SampleAccessTokenProvider: NSObject, GMTCAuthorization {
  private struct AuthToken {
    // The cached trip token.
    let token: String
    // Keep track of when the token expires for caching.
    let expiration: TimeInterval
    // Keep track of the trip ID the cached token is for.
    let tripID: String
  }

  enum AccessTokenError: Error {
    case missingAuthorizationContext
    case missingData
  }

  private var authToken: AuthToken?

  func fetchToken(
    with authorizationContext: GMTCAuthorizationContext?,
    completion: @escaping GMTCAuthTokenFetchCompletionHandler
  ) {
    // Get the trip ID from the authorizationContext. This is set by the Consumer SDK.
    guard let authorizationContext = authorizationContext else {
      completion(nil, AccessTokenError.missingAuthorizationContext)
      return
    }
    let tripID = authorizationContext.tripID

    // If appropriate, use the cached token.
    if let authToken = authToken,
      authToken.expiration > Date.now.timeIntervalSince1970 && authToken.tripID == tripID
    {
      completion(authToken.token, nil)
      return
    }

    // Otherwise, try to fetch a new token from your server.
    let request = URLRequest(url: URL(string: providerURL))
    let task = URLSession.shared.dataTask(with: request) { [weak self] data, _, error in
      guard let strongSelf = self else { return }
      guard error == nil else {
        completion(nil, error)
        return
      }

      // Replace the following key values with the appropriate keys based on your
      // server's expected response.
      let tripTokenKey = "TRIP_TOKEN_KEY"
      let tokenExpirationKey = "TOKEN_EXPIRATION"
      guard let data = data,
        let fetchData = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
        let token = fetchData[tripTokenKey] as? String,
        let expiration = fetchData[tokenExpirationKey] as? Double
      else {
        completion(nil, AccessTokenError.missingData)
        return
      }

      strongSelf.authToken = AuthToken(token: token, expiration: expiration, tripID: tripID)
      completion(token, nil)
    }
    task.resume()
  }
}

    Objective-C

    /*

    *   SampleAccessTokenProvider.h
 */
#import <Foundation/Foundation.h>
#import <GoogleRidesharingConsumer/GoogleRidesharingConsumer.h>

NS_ASSUME_NONNULL_BEGIN

@interface SampleAccessTokenProvider : NSObject <GMTCAuthorization>

@end

NS_ASSUME_NONNULL_END

/*

    *   SampleAccessTokenProvider.m
 */
#import "SampleAccessTokenProvider.h"
#import "GoogleRidesharingConsumer/GoogleRidesharingConsumer.h"

static NSString *const PROVIDER_URL = @"INSERT_YOUR_TOKEN_PROVIDER_URL";

// SampleAccessTokenProvider.m
@implementation SampleAccessTokenProvider {
  // The cached token with claims to the current trip.
  NSString *_cachedTripToken;
  // Keep track of the Trip ID the cached token is for.
  NSString *_lastKnownTripID;
  // Keep track of when tokens expire for caching.
  NSTimeInterval _tokenExpiration;
}

-   (void)fetchTokenWithContext:(nullable GMTCAuthorizationContext *)authorizationContext
                   completion:(nonnull GMTCAuthTokenFetchCompletionHandler)completion {
  // Get the trip ID from the authorizationContext. This is set by the Consumer SDK.
  NSString *tripID = authorizationContext.tripID;

  // Clear cached trip token if trip ID has changed.
  if (![_lastKnownTripID isEqual:tripID]) {
    _tokenExpiration = 0.0;
    _cachedTripToken = nil;
  }
  _lastKnownTripID = tripID;

  // Clear cached tripToken if it has expired.
  if ([[NSDate date] timeIntervalSince1970] > _tokenExpiration) {
    _cachedTripToken = nil;
  }

  // If appropriate, use the cached token.
  if (_cachedTripToken) {
    completion(_cachedTripToken, nil);
    return;
  }
  // Otherwise, try to fetch a new token from your server.
  NSURL *requestURL = [NSURL URLWithString:PROVIDER_URL];
  NSMutableURLRequest *request =
      [[NSMutableURLRequest alloc] initWithURL:requestURL];
  request.HTTPMethod = @"GET";

  // Replace the following key values with the appropriate keys based on your
  // server's expected response.
  NSString *tripTokenKey = @"TRIP_TOKEN_KEY";
  NSString *tokenExpirationKey = @"TOKEN_EXPIRATION";

  __weak typeof(self) weakSelf = self;
  void (^handler)(NSData *_Nullable data, NSURLResponse *_Nullable response,
                  NSError *_Nullable error) =
      ^(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error) {
        typeof(self) strongSelf = weakSelf;
        if (error) {
          completion(nil, error);
          return;
        }

        NSError *JSONError;
        NSMutableDictionary *JSONResponse =
            [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:&JSONError];

        if (JSONError) {
          completion(nil, JSONError);
          return;
        } else {
          // Sample code only. No validation logic.
          id expirationData = JSONResponse[tokenExpirationKey];
          if ([expirationData isKindOfClass:[NSNumber class]]) {
            NSTimeInterval expirationTime = ((NSNumber *)expirationData).doubleValue;
            strongSelf->_tokenExpiration = [[NSDate date] timeIntervalSince1970] + expirationTime;
          }
          strongSelf->_cachedTripToken = JSONResponse[tripTokenKey];
          completion(JSONResponse[tripTokenKey], nil);
        }
      };
  NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
  NSURLSession *mainQueueURLSession =
      [NSURLSession sessionWithConfiguration:config delegate:nil
                               delegateQueue:[NSOperationQueue mainQueue]];
  NSURLSessionDataTask *task = [mainQueueURLSession dataTaskWithRequest:request completionHandler:handler];
  [task resume];
}

@end

    אתחול אפליקציה

    Swift

    /*

    *   AppDelegate.swift
 */
import GoogleRidesharingConsumer
import GoogleMaps

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

  func application(_ application: UIApplication,
      didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Register your API key for GMSServices.
    GMSServices.provideAPIKey(yourMapsAPIKey)

    // Set the instance of the SampleAccessTokenProvider.
    GMTCServices.setAccessTokenProvider(SampleAccessTokenProvider(), providerID: yourProviderID)

    // Other initialization code ...
    return true
  }
}

    Objective-C

    /*

    *   AppDelegate.m
 */
#import <GoogleMaps/GoogleMaps.h>
#import <GoogleRidesharingConsumer/GoogleRidesharingConsumer.h>

@implementation AppDelegate

-   (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  //Register your API key for GMSServices.
  [GMSServices provideAPIKey:yourMapsAPIKey];

  //Set the instance of the AccessTokenFactory.
  [GMTCServices setAccessTokenProvider:[[SampleAccessTokenProvider alloc] init]
                            providerID:yourProviderID];

  // Other initialization code ...
  return YES;
}

@end

    שילוב של תצוגת מפה

    הפעלה של תצוגת המפה

    הדוגמה הבאה מציגה איך לאתחל את GMTCMapView.

    Swift

    /*

    *   MapViewController.swift
 */
class ViewController: UIViewController, GMTCMapViewDelegate {
  private var rideSharingMap: GMTCMapView?

  override func viewDidLoad() {
    super.viewDidLoad()

    self.rideSharingMap = GMTCMapView(frame: UIScreen.main.bounds)
    self.rideSharingMap.delegate = self
    self.rideSharingMap?.settings.myLocationButton = true
    self.view.addSubview(self.rideSharingMap!)
    ...
  }

    Objective-C

    /*

    *   MapViewController.h
 */
@interface MapViewController : UIViewController<GMTCMapViewDelegate>
...
@end

/*

    *   MapViewController.m
 */
@implementation MapViewController

-   (void)viewDidLoad {
  [super viewDidLoad];
  ...
  self.mapView = [[GMTCMapView alloc] initWithFrame:CGRectZero];
  self.mapView.settings.myLocationButton = YES;
  self.mapView.delegate = self;
  ...
}

...

@end

    טיפול באירועים של הצגת מפה

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

    Swift

    func mapViewDidInitialize(_ mapview: GMTCMapView) {
  // Handle the update to the state of the map view to browsing.
}

func mapView(_ mapView: GMSMapView, didTapConsumerMarker mapMarker: GMSMarker, markerType: GMTCMapViewMarkerType) -> Bool {
  // Handle the mapView marker was tapped.
}

    Objective-C

    /*

    *   MapViewController.m
 */
#pragma mark - GMTCMapViewDelegate implementation

// Handle state update of map view.

-   (void)mapViewDidInitializeCustomerState:(GMTCMapView *)mapview {
  // Handle the update to the state of the map view to browsing.
}

-   (void)mapView:(GMSMapView *)mapView
    didTapConsumerMarker:(nonnull GMSMarker *)mapMarker
              markerType:(GMTCMapViewMarkerType)markerType {
  // Handle the mapView marker was tapped.
}

    שיתוף נסיעה

    התחלת נסיעה חדשה לאחר שהתצוגה נטענה

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

    Swift

    /*

    *   MapViewController.swift
 */
override func viewDidLoad() {
  super.viewDidLoad()
  ...
  self.mapView = GMTCMapView(frame: UIScreen.main.bounds)
  self.mapView.delegate = self
  self.view.addSubview(self.mapView)
}

func mapViewDidInitializeCustomerState(_: GMTCMapView) {
  self.mapView.pickupLocation = self.selectedPickupLocation
  self.mapView.dropoffLocation = self.selectedDropoffLocation

  self.startConsumerMatchWithLocations(
    pickupLocation: self.mapView.pickupLocation!,
    dropoffLocation: self.mapView.dropoffLocation!
  ) { [weak self] (tripName, error) in
    guard let strongSelf = self else { return }
    if error != nil {
      // print error message.
      return
    }
    let tripService = GMTCServices.shared().tripService
    // Create a tripModel instance for listening the update of the trip
    // specified by this trip name.
    let tripModel = tripService.tripModel(forTripName: tripName)
    // Create a journeySharingSession instance based on the tripModel
    let journeySharingSession = GMTCJourneySharingSession(tripModel: tripModel)
    // Add the journeySharingSession instance on the mapView for UI updating.
    strongSelf.mapView.show(journeySharingSession)
    // Register for the trip update events.
    tripModel.register(strongSelf)

    strongSelf.currentTripModel = tripModel
    strongSelf.currentJourneySharingSession = journeySharingSession
    strongSelf.hideLoadingView()
  }

  self.showLoadingView()
}

    Objective-C

    /*

    *   MapViewController.m
 */
-   (void)viewDidLoad {
  [super viewDidLoad];
  ...
  self.mapView = [[GMTCMapView alloc] initWithFrame:CGRectZero];
  self.mapView.delegate = self;
  [self.view addSubview:self.mapView];
}

// Handle the callback when the GMTCMapView did initialized.

-   (void)mapViewDidInitializeCustomerState:(GMTCMapView *)mapview {
  self.mapView.pickupLocation = self.selectedPickupLocation;
  self.mapView.dropoffLocation = self.selectedDropoffLocation;

  __weak __typeof(self) weakSelf = self;
  [self startTripBookingWithPickupLocation:self.selectedPickupLocation
                           dropoffLocation:self.selectedDropoffLocation
                                completion:^(NSString *tripName, NSError *error) {
                                  __typeof(self) strongSelf = weakSelf;
                                  GMTCTripService *tripService = [GMTCServices sharedServices].tripService;
                                  // Create a tripModel instance for listening to updates to the trip specified by this trip name.
                                  GMTCTripModel *tripModel = [tripService tripModelForTripName:tripName];
                                  // Create a journeySharingSession instance based on the tripModel.
                                  GMTCJourneySharingSession *journeySharingSession =
                                    [[GMTCJourneySharingSession alloc] initWithTripModel:tripModel];
                                  // Add the journeySharingSession instance on the mapView for updating the UI.
                                  [strongSelf.mapView showMapViewSession:journeySharingSession];
                                  // Register for trip update events.
                                  [tripModel registerSubscriber:self];

                                  strongSelf.currentTripModel = tripModel;
                                  strongSelf.currentJourneySharingSession = journeySharingSession;
                                  [strongSelf hideLoadingView];
                                }];
    [self showLoadingView];
}

    ביטול הנסיעה הפעילה

    הדוגמה הבאה מראה איך לאפס את הנסיעה הפעילה הנוכחית.

    Swift

    /*

    *   MapViewController.swift
 */
func cancelCurrentActiveTrip() {
  // Stop the tripModel
  self.currentTripModel.unregisterSubscriber(self)

  // Remove the journey sharing session from the mapView's UI stack.
  self.mapView.hide(journeySharingSession)
}

    Objective-C

    /*

    *   MapViewController.m
 */
-   (void)cancelCurrentActiveTrip {
  // Stop the tripModel
  [self.currentTripModel unregisterSubscriber:self];

  // Remove the journey sharing session from the mapView's UI stack.
  [self.mapView hideMapViewSession:journeySharingSession];
}

    האזנה לעדכוני נסיעות

    בדוגמה הבאה אפשר לראות איך לרשום את הקריאה החוזרת (callback) של tripModel.

    Swift

    /*

    *   MapViewController.swift
 */
override func viewDidLoad() {
  super.viewDidLoad()
  // Register for trip update events.
  self.currentTripModel.register(self)
}

    Objective-C

    /*

    *   MapViewController.m
 */
-   (void)viewDidLoad {
  [super viewDidLoad];
  // Register for trip update events.
  [self.currentTripModel registerSubscriber:self];
  ...
}

    הדוגמה הבאה מציגה איך לבטל את הרישום של הקריאה החוזרת (callback) tripModel.

    Swift

    /*

    *   MapViewController.swift
 */
deinit {
  self.currentTripModel.unregisterSubscriber(self)
}

    Objective-C

    /*

    *   MapViewController.m
 */
-   (void)dealloc {
  [self.currentTripModel unregisterSubscriber:self];
  ...
}

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

    Swift

    /*

    *   MapViewController.swift
 */
func tripModel(_: GMTCTripModel, didUpdate trip: GMTSTrip?, updatedPropertyFields: GMTSTripPropertyFields) {
  // Update the UI with the new `trip` data.
  self.updateUI(with: trip)
}

func tripModel(_: GMTCTripModel, didUpdate tripStatus: GMTSTripStatus) {
  // Handle trip status did change.
}

func tripModel(_: GMTCTripModel, didUpdateActiveRouteRemainingDistance activeRouteRemainingDistance: Int32) {
  // Handle remaining distance of active route did update.
}

func tripModel(_: GMTCTripModel, didUpdateActiveRoute activeRoute: [GMTSLatLng]?) {
  // Handle trip active route did update.
}

func tripModel(_: GMTCTripModel, didUpdate vehicleLocation: GMTSVehicleLocation?) {
  // Handle vehicle location did update.
}

func tripModel(_: GMTCTripModel, didUpdatePickupLocation pickupLocation: GMTSTerminalLocation?) {
  // Handle pickup location did update.
}

func tripModel(_: GMTCTripModel, didUpdateDropoffLocation dropoffLocation: GMTSTerminalLocation?) {
  // Handle drop off location did update.
}

func tripModel(_: GMTCTripModel, didUpdatePickupETA pickupETA: TimeInterval) {
  // Handle the pickup ETA did update.
}

func tripModel(_: GMTCTripModel, didUpdateDropoffETA dropoffETA: TimeInterval) {
  // Handle the drop off ETA did update.
}

func tripModel(_: GMTCTripModel, didUpdateRemaining remainingWaypoints: [GMTSTripWaypoint]?) {
  // Handle updates to the pickup, dropoff or intermediate destinations of the trip.
}

func tripModel(_: GMTCTripModel, didFailUpdateTripWithError error: Error?) {
  // Handle the error.
}

func tripModel(_: GMTCTripModel, didUpdateIntermediateDestinations intermediateDestinations: [GMTSTerminalLocation]?) {
  // Handle the intermediate destinations being updated.
}

func tripModel(_: GMTCTripModel, didUpdateActiveRouteTraffic activeRouteTraffic: GMTSTrafficData?) {
  // Handle trip active route traffic being updated.
}

    Objective-C

    /*

    *   MapViewController.m
 */
#pragma mark - GMTCTripModelSubscriber implementation

-   (void)tripModel:(GMTCTripModel *)tripModel
            didUpdateTrip:(nullable GMTSTrip *)trip
    updatedPropertyFields:(enum GMTSTripPropertyFields)updatedPropertyFields {
  // Update the UI with the new `trip` data.
  [self updateUIWithTrip:trip];
  ...
}

-   (void)tripModel:(GMTCTripModel *)tripModel didUpdateTripStatus:(enum GMTSTripStatus)tripStatus {
  // Handle trip status did change.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateActiveRouteRemainingDistance:(int32_t)activeRouteRemainingDistance {
   // Handle remaining distance of active route did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateActiveRoute:(nullable NSArray<GMTSLatLng *> *)activeRoute {
  // Handle trip active route did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateVehicleLocation:(nullable GMTSVehicleLocation *)vehicleLocation {
  // Handle vehicle location did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdatePickupLocation:(nullable GMTSTerminalLocation *)pickupLocation {
  // Handle pickup location did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateDropoffLocation:(nullable GMTSTerminalLocation *)dropoffLocation {
  // Handle drop off location did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel didUpdatePickupETA:(NSTimeInterval)pickupETA {
  // Handle the pickup ETA did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateRemainingWaypoints:(nullable NSArray<GMTSTripWaypoint *> *)remainingWaypoints {
  // Handle updates to the pickup, dropoff or intermediate destinations of the trip.
}

-   (void)tripModel:(GMTCTripModel *)tripModel didUpdateDropoffETA:(NSTimeInterval)dropoffETA {
  // Handle the drop off ETA did update.
}

-   (void)tripModel:(GMTCTripModel *)tripModel didFailUpdateTripWithError:(nullable NSError *)error {
  // Handle the error.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateIntermediateDestinations:
        (nullable NSArray<GMTSTerminalLocation *> *)intermediateDestinations {
  // Handle the intermediate destinations being updated.
}

-   (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateActiveRouteTraffic:(nullable GMTSTrafficData *)activeRouteTraffic {
  // Handle trip active route traffic being updated.
}

    טיפול בשגיאות

    אם נרשמת ל-TripModel ומופיעה שגיאה, אפשר לקבל קריאה חוזרת (callback) של tripModel על ידי הטמעה של שיטת הענקת הגישה tripModel(_:didFailUpdateTripWithError:). Fleet Engine יצר את הודעת השגיאה לפי תקן השגיאה של Google Cloud. למידע על ההגדרה של הודעות שגיאה מפורטות וכל קודי השגיאה, עיינו במסמכי התיעוד של השגיאות ב-Google Cloud.

    באופן ספציפי, כדי לעקוב אחרי נסיעות, צריך לספק אסימון אימות תקף. 401 UNAUTHENTICATED יועלה אם אין פרטי כניסה תקפים לאימות, למשל אם פג התוקף של האסימון.403 PERMISSION_DENIED יועלה אם למתקשר אין הרשאה לקרוא לממשק API ספציפי (למשל, משתמש בעל תפקיד צרכן מנסה לקרוא ל-updateTrip), או אם הבקשה לא כוללת אסימון רכב_id/trip_id חוקי באסימון JWT.

    מידע נוסף זמין במאמר טיפול בשגיאות של Consumer SDK.

    התאמה אישית של ממשק המשתמש

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

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

    Swift

    /** MapViewController.swift */

func updatePolylineUIOptions() {
  // The polyline type that you would like to set custom UI options for.
  let customizablePolylineType = GMTCPolylineType.activeRoute

  let polylineStyleOptions = GMTCMutablePolylineStyleOptions()
  polylineStyleOptions.strokeWidth = 8.0
  polylineStyleOptions.strokeColor = .blue
  polylineStyleOptions.isVisible = true
  polylineStyleOptions.zIndex = 1000
  polylineStyleOptions.isGeodesic = true
  let coordinator = self.mapView.consumerMapStyleCoordinator
  coordinator.setPolylineStyleOptions(polylineStyleOptions, polylineType:customizablePolylineType)
}

    Objective-C

    /** MapViewController.m */

-   (void)updatePolylineUIOptions {
  // The polyline type that you would like to set custom UI options for.
  GMTCPolylineType customizablePolylineType = GMTCPolylineTypeActiveRoute;

  GMTCMutablePolylineStyleOptions *polylineStyleOptions =
      [[GMTCMutablePolylineStyleOptions alloc] init];
  polylineStyleOptions.strokeWidth = 8.0;
  polylineStyleOptions.strokeColor = [UIColor blueColor];
  polylineStyleOptions.isVisible = YES;
  polylineStyleOptions.zIndex = 1000;
  polylineStyleOptions.isGeodesic = YES;
  [[_mapView consumerMapStyleCoordinator] setPolylineStyleOptions:polylineStyleOptions
                                                polylineType:customizablePolylineType];
}

    קבלה והגדרה של אפשרויות ממשק משתמש של סמנים מותאמים אישית

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

    Swift

    /** MapViewController.swift */

func updateMarkerUIOptions() {
  let customizableMarkerType = GMTCCustomizableMarkerType.tripVehicle
  let markerStyleOptions = GMTCMutableMarkerStyleOptions()
  markerStyleOptions.groundAnchor = groundAnchor
  markerStyleOptions.isVisible = true
  markerStyleOptions.icon = icon
  markerStyleOptions.zIndex = 100
  markerStyleOptions.isFlat = false
  let coordinator = self.mapView.consumerMapStyleCoordinator
  coordinator.setMarkerStyleOptions(markerStyleOptions, markerType: customizableMarkerType)
}

    Objective-C

    /** MapViewController.m */

-   (void)updateMarkerUIOptions {
  // The marker type that you would like to set custom UI options for.
  GMTCCustomizableMarkerType customizableMarkerType = GMTCCustomizableMarkerTypeTripVehicle;

  GMTCMutableMarkerStyleOptions *markerStyleOptions =
      [[GMTCMutableMarkerStyleOptions alloc] init];
  markerStyleOptions.groundAnchor = groundAnchor;
  markerStyleOptions.isVisible = YES;
  markerStyleOptions.icon = icon;
  markerStyleOptions.zIndex = 100;
  markerStyleOptions.isFlat = NO;

  [[_mapView consumerMapStyleCoordinator] setMarkerStyleOptions:markerStyleOptions markerType:customizableMarkerType];
}

    כוונון זום המצלמה

    הלחצן 'המיקום שלי' ב-SDK של מפות Google ל-iOS מרכז את המצלמה למיקום של המכשיר.

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

    Consumer SDK כולל תכונה של מצלמה אוטומטית שמופעלת כברירת מחדל. המצלמה משנה את מרחק התצוגה כדי להתמקד במסלול שיתוף הנסיעה ובציון הדרך הבא.

    AutoCamera

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

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