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

אתם יכולים להשתמש ב-Driver SDK כדי לשפר את הניווט והמעקב באפליקציה שלכם ל-Trip and Order Progress. Driver SDK מספק עדכונים לגבי מיקום הרכב ועדכונים לגבי משימות במנוע Fleet לחבילות ולנסיעות לפי דרישה.

ה-SDK של Drive מעדכן את שירותי Fleet Engine ואת השירותים בהתאמה אישית לגבי המיקום והמצב של הרכב. לדוגמה, הרכב יכול להיות ONLINE או OFFLINE, ומיקום הרכב משתנה עם התקדמות הנסיעה.

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

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

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

    בנוסף, עליכם להפעיל את Maps SDK ל-iOS בפרויקט ב-Google Cloud ולקבל מפתח API.

    הגדרת הפרויקט

    אתם יכולים להגדיר את ה-SDK של Drive באמצעות CocoaPods.

    CocoaPods

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

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

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

    1. יוצרים קובץ Podfile ל-Driver SDK ומשתמשים בו כדי להתקין את ה-API ואת יחסי התלות שלו: יוצרים קובץ בשם Podfile בספריית הפרויקט. הקובץ הזה מגדיר את יחסי התלות של הפרויקט שלכם. עורכים את ה-Podfile ומוסיפים את יחסי התלות שלכם. הנה דוגמה שכוללת את יחסי התלות:
    source "https://github.com/CocoaPods/Specs.git"
    
    target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
      pod 'GoogleRidesharingDriver'
    end
    

    הדוגמה הבאה כוללת את רצפי האלפא והבטא של Driver SDK כתלות:

    source "https://cpdc-eap.googlesource.com/ridesharing-driver-sdk.git"
    source "https://github.com/CocoaPods/Specs.git"
    
    target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
      pod 'GoogleRidesharingDriver'
    end
    
    1. שומרים את קובץ ה-Podfile. פותחים טרמינל ועוברים לספרייה שמכילה את ה-Podfile:
    cd <path-to-project>
    
    1. מריצים את הפקודה להתקנת pod. הפעולה הזו תתקין את ממשקי ה-API שצוינו ב-Podfile, יחד עם כל יחסי התלות שלהם.
    pod install
    
    1. סוגרים את Xcode ופותחים (לחיצה כפולה) את קובץ ה- .xcworkspace של הפרויקט כדי להפעיל את Xcode. מרגע זה ואילך צריך להשתמש בקובץ .xcworkspace כדי לפתוח את הפרויקט.

    התקנה ידנית

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

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

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

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

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

    4. גוררים את הקובץ gRPCCertificates.bundle לספרייה ברמה העליונה של פרויקט ה-Xcode. כשתתבקשו, בחרו באפשרות 'העתקת פריטים' לפי הצורך.

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

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

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

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

      • Accelerate.framework
      • AudioToolbox.framework
      • AVFoundation.framework
      • CoreData.framework
      • CoreGraphics.framework
      • CoreLocation.framework
      • CoreTelephony.framework
      • CoreText.framework
      • GLKit.framework
      • ImageIO.framework
      • libc++.tbd
      • libxml2.tbd
      • libz.tbd
      • LocalAuthentication.framework
      • OpenGLES.framework
      • QuartzCore.framework
      • SystemConfiguration.framework
      • UIKit.framework
      • WebKit.framework
    9. בוחרים את הפרויקט במקום ביעד ספציפי, ופותחים את הכרטיסייה Build Settings (הגדרות הפיתוח). בקטע Other Linker flags מוסיפים את -ObjC לניפוי הבאגים ולשחרור הנתונים. במקרה שההגדרות האלה לא מוצגות, משנים את המסנן בסרגל של Build Settings מ-Basic ל-All.

    גרסאות אלפא/בטא של SDK

    כדי להגדיר גרסאות אלפא או בטא של Driver SDK ל-iOS, צריך את הפריטים הבאים:

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

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

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

    כשהפרויקט נמצא ברשימת הגישה, אפשר לגשת ל-pod.

    1. יוצרים Podfile ל-SDK להעברת נתונים ל-iOS, ומשתמשים בו כדי להתקין את ה-API ואת יחסי התלות שלו: יוצרים קובץ בשם Podfile בספריית הפרויקט. הקובץ הזה מגדיר את יחסי התלות של הפרויקט שלכם. עורכים את ה-Podfile ומוסיפים את יחסי התלות. הדוגמה הבאה כוללת את יחסי התלות:
    source "https://cpdc-eap.googlesource.com/ridesharing-driver-sdk.git"
    source "https://github.com/CocoaPods/Specs.git"
    
    target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
      pod 'GoogleRidesharingDriver'
    end
    
    1. שומרים את קובץ ה-Podfile. פותחים טרמינל ועוברים לספרייה שמכילה את ה-Podfile:
    cd <path-to-project>
    
    1. מריצים את הפקודה להתקנת pod. הפקודה הזו מתקינה את ממשקי ה-API שצוינו ב-Podfile, יחד עם כל יחסי התלות שלהם.
    pod install
    
    1. סוגרים את Xcode ופותחים (לחיצה כפולה) את קובץ ה- .xcworkspace של הפרויקט כדי להפעיל את Xcode. מרגע זה ואילך צריך להשתמש בקובץ .xcworkspace כדי לפתוח את הפרויקט.

    יישום הרשאה ואימות

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

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

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

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

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

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

    Swift

    import GoogleRidesharingDriver
    
    private let providerURL = "INSERT_YOUR_TOKEN_PROVIDER_URL"
    
    class SampleAccessTokenProvider: NSObject, GMTDAuthorization {
      private struct AuthToken {
        // The cached vehicle token.
        let token: String
        // Keep track of when the token expires for caching.
        let expiration: TimeInterval
        // Keep track of the vehicle ID the cached token is for.
        let vehicleID: String
      }
    
      enum AccessTokenError: Error {
        case missingAuthorizationContext
        case missingData
      }
    
      private var authToken: AuthToken?
    
      func fetchToken(
        with authorizationContext: GMTDAuthorizationContext?,
        completion: @escaping GMTDAuthTokenFetchCompletionHandler
      ) {
        // Get the vehicle ID from the authorizationContext. This is set by the Driver SDK.
        guard let authorizationContext = authorizationContext else {
          completion(nil, AccessTokenError.missingAuthorizationContext)
          return
        }
        let vehicleID = authorizationContext.vehicleID
    
        // If appropriate, use the cached token.
        if let authToken = authToken,
          authToken.expiration > Date.now.timeIntervalSince1970 && authToken.vehicleID == vehicleID
        {
          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 vehicleTokenKey = "VEHICLE_TOKEN_KEY"
          let tokenExpirationKey = "TOKEN_EXPIRATION"
          guard let data = data,
            let fetchData = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
            let token = fetchData[vehicleTokenKey] as? String,
            let expiration = fetchData[tokenExpirationKey] as? Double
          else {
            completion(nil, AccessTokenError.missingData)
            return
          }
    
          strongSelf.authToken = AuthToken(
            token: token, expiration: expiration, vehicleID: vehicleID)
          completion(token, nil)
        }
        task.resume()
      }
    }
    

    Objective-C

    #import "SampleAccessTokenProvider.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    // SampleAccessTokenProvider.h
    @interface SampleAccessTokenProvider : NSObject<GMTDAuthorization>
    @end
    
    static NSString *const PROVIDER_URL = @"INSERT_YOUR_TOKEN_PROVIDER_URL";
    
    // SampleAccessTokenProvider.m
    @implementation SampleAccessTokenProvider{
      // The cached vehicle token.
      NSString *_cachedVehicleToken;
      // Keep track of the vehicle ID the cached token is for.
      NSString *_lastKnownVehicleID;
      // Keep track of when tokens expire for caching.
      NSTimeInterval _tokenExpiration;
    }
    
    -   (void)fetchTokenWithContext:(nullable GMTDAuthorizationContext *)authorizationContext
                       completion:(nonnull GMTDAuthTokenFetchCompletionHandler)completion {
      // Get the vehicle ID from the authorizationContext. This is set by the Driver SDK.
      NSString *vehicleID = authorizationContext.vehicleID;
      if (!vehicleID) {
        NSAssert(NO, @"Vehicle ID is missing from authorizationContext.");
        return;
      }
    
      // Clear cached vehicle token if vehicle ID has changed.
      if (![_lastKnownVehicleID isEqual:vehicleID]) {
        _tokenExpiration = 0.0;
        _cachedVehicleToken = nil;
      }
      _lastKnownVehicleID = vehicleID;
    
      // Clear cached vehicletoken if it has expired.
      if ([[NSDate date] timeIntervalSince1970] > _tokenExpiration) {
        _cachedVehicleToken = nil;
      }
    
      // If appropriate, use the cached token.
      if (_cachedVehicleToken) {
        completion(_cachedVehicleToken, 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 *vehicleTokenKey = @"VEHICLE_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->_cachedVehicleToken = JSONResponse[vehicleTokenKey];
              completion(JSONResponse[vehicleTokenKey], 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
    

    יצירת מופע של RidesharingDriverAPI

    כדי לקבל מכונה של GMTDVehicleReporter, קודם צריך ליצור מכונה GMTDRidesharingDriverAPI באמצעות ה-providerID, ה-VehicleID, driverContext ו-accessTokenProvider. ה-providerID זהה למזהה הפרויקט ב-Google Cloud. ואפשר לגשת למכונה GMTDVehicleReporter ישירות מה-API של מנהל ההתקן.

    הדוגמה הבאה יוצרת מופע של GMTDRidesharingDriverAPI:

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        super.viewDidLoad()
    
        let vehicleID = "INSERT_CREATED_VEHICLE_ID"
        let accessTokenProvider = SampleAccessTokenProvider()
        let driverContext = GMTDDriverContext(
          accessTokenProvider: accessTokenProvider,
          providerID: providerID,
          vehicleID: vehicleID,
          navigator: mapView.navigator)
        let ridesharingDriverAPI = GMTDRidesharingDriverAPI(driverContext: driverContext)
      }
    }
    

    Objective-C

    #import "SampleViewController.h"
    #import "SampleAccessTokenProvider.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";
    
    @implementation SampleViewController {
      GMSMapView *_mapView;
    }
    
    -   (void)viewDidLoad {
      NSString *vehicleID = @"INSERT_CREATED_VEHICLE_ID";
      SampleAccessTokenProvider *accessTokenProvider =
                                    [[SampleAccessTokenProvider alloc] init];
      GMTDDriverContext *driverContext =
        [[GMTDDriverContext alloc] initWithAccessTokenProvider:accessTokenProvider
                                                    providerID:PROVIDER_ID
                                                     vehicleID:vehicleID
                                                     navigator:_mapView.navigator];
    
      GMTDRidesharingDriverAPI *ridesharingDriverAPI = [[GMTDRidesharingDriverAPI alloc] initWithDriverContext:driverContext];
    }
    

    אופציונלי: אפשר להאזין לאירועים של VehicleReporter

    מערכת GMTDVehicleReporter מעדכנת מדי פעם את הרכב כאשר locationTrackingEnabled הוא true. כדי להגיב לעדכונים התקופתיים האלה, כל אובייקט יכול להירשם לאירועי GMTDVehicleReporter בהתאם לפרוטוקול GMTDVehicleReporterListener.

    אפשר לטפל באירועים הבאים:

    • vehicleReporter(_:didSucceed:)

      האפליקציה מודיעה לאפליקציית Drive שהשירותים לקצה העורפי קיבלו את עדכון המצב והמיקום של הרכב.

    • vehicleReporter(_:didFail:withError:)

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

    הדוגמה הבאה מטפלת באירועים האלה:

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        ridesharingDriverAPI.vehicleReporter.add(self)
      }
    
      func vehicleReporter(_ vehicleReporter: GMTDVehicleReporter, didSucceed vehicleUpdate: GMTDVehicleUpdate) {
        // Handle update succeeded.
      }
    
      func vehicleReporter(_ vehicleReporter: GMTDVehicleReporter, didFail vehicleUpdate: GMTDVehicleUpdate, withError error: Error) {
        // Handle update failed.
      }
    }
    

    Objective-C

    /*
    
        *   SampleViewController.h
     */
    @interface SampleViewController : UIViewController<GMTDVehicleReporterListener>
    @end
    
    /*
    
        *   SampleViewController.m
     */
    #import "SampleViewController.h"
    #import "SampleAccessTokenProvider.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";
    
    @implementation SampleViewController {
      GMSMapView *_mapView;
    }
    
    -   (void)viewDidLoad {
      // Assumes you have implemented the sample code up to this step.
      [ridesharingDriverAPI.vehicleReporter addListener:self];
    }
    
    -   (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter didSucceedVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate {
      // Handle update succeeded.
    }
    
    -   (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate withError:(NSError *)error {
      // Handle update failed.
    }
    
    @end
    

    הוספת GMTDVehicleReporter כמאזין ל-GMSRoadSnappedLocationProvider

    כדי לספק עדכוני מיקום ל-Driver SDK, צריך להגדיר את GMTDVehicleReporter כהאזנה לGMSRoadSnappedLocationProvider.

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        if let roadSnappedLocationProvider = mapView.roadSnappedLocationProvider {
          roadSnappedLocationProvider.add(ridesharingDriverAPI.vehicleReporter)
          roadSnappedLocationProvider.startUpdatingLocation()
        }
      }
    }
    

    Objective-C

    /*
    
        *   SampleViewController.h
     */
    @interface SampleViewController : UIViewController<GMTDVehicleReporterListener>
    @end
    
    /*
    
        *   SampleViewController.m
     */
    #import "SampleViewController.h"
    #import "SampleAccessTokenProvider.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";
    
    @implementation SampleViewController {
      GMSMapView *_mapView;
    }
    
    -   (void)viewDidLoad {
      // Assumes you have implemented the sample code up to this step.
      [_mapView.roadSnappedLocationProvider addListener:ridesharingDriverAPI.vehicleReporter];
      [_mapView.roadSnappedLocationProvider startUpdatingLocation];
    }
    
    @end
    

    הפעלת מעקב אחר מיקום

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

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

    אם המדיניות locationTrackingEnabled מוגדרת לערך true, עדכוני הנסיעה והרכב נשלחים לקצה העורפי של Fleet Engine במרווחי זמן קבועים על סמך הערך שהוגדר עבור locationUpdateInterval. אם המדיניות locationTrackingEnabled מוגדרת לערך false, העדכונים מופסקים ובקשה סופית לעדכון הרכב נשלחת לקצה העורפי של Fleet Engine כדי להגדיר את מצב הרכב ל-GMTDVehicleState.offline. ראו updateVehicleState שיקולים מיוחדים לגבי טיפול בכשלים כשlocationTrackingEnabled מוגדר ל-false.

    הדוגמה הבאה מפעילה מעקב אחר מיקום:

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        ridesharingDriverAPI.vehicleReporter.locationTrackingEnabled = true
      }
    }
    

    Objective-C

    /*
      * SampleViewController.m
     */
    #import "SampleViewController.h"
    #import "SampleAccessTokenProvider.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";
    
    @implementation SampleViewController {
      GMSMapView *_mapView;
    }
    
    -   (void)viewDidLoad {
      // Assumes you have implemented the sample code up to this step.
      ridesharingDriverAPI.vehicleReporter.locationTrackingEnabled = YES;
    }
    
    @end
    

    כברירת מחדל, מרווח הדיווח הוא 10 שניות, אבל אפשר לשנות את מרווח הדיווח באמצעות locationUpdateInterval. מרווח העדכון המינימלי הנתמך הוא 5 שניות. מרווח העדכון המקסימלי הנתמך הוא 60 שניות. עדכונים תכופים יותר עלולים לגרום לשגיאות ולבקשות איטיות יותר.

    עדכון מצב הרכב

    הדוגמה הבאה מציגה איך להגדיר את מצב הרכב ל-ONLINE. לפרטים נוספים, ראו updateVehicleState.

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        ridesharingDriverAPI.vehicleReporter.update(.online)
      }
    }
    

    Objective-C

    #import "SampleViewController.h"
    #import "SampleAccessTokenProvider.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";
    
    @implementation SampleViewController {
      GMSMapView *_mapView;
    }
    
    -   (void)viewDidLoad {
      // Assumes you have implemented the sample code up to this step.
      [ridesharingDriverAPI.vehicleReporter
                                       updateVehicleState:GMTDVehicleStateOnline];
    }
    
    @end
    

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

    Swift

    import GoogleRidesharingDriver
    
    class VehicleReporterListener: NSObject, GMTDVehicleReporterListener {
      func vehicleReporter(
        _ vehicleReporter: GMTDVehicleReporter,
        didFail vehicleUpdate: GMTDVehicleUpdate,
        withError error: Error
      ) {
        let fullError = error as NSError
        if let innerError = fullError.userInfo[NSUnderlyingErrorKey] as? NSError {
          let innerFullError = innerError as NSError
          if innerFullError.localizedDescription.contains("update_mask cannot be empty") {
            emptyMaskUpdates += 1
            return
          }
        }
        failedUpdates += 1
      }
    
      override init() {
        emptyMaskUpdates = 0
        failedUpdates = 0
      }
    }
    
    

    Objective-C

    #import "VehicleReporterListener.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    @implementation VehicleReporterListener {
      NSInteger emptyMaskUpdates = 0;
      NSInteger failedUpdates = 0;
    }
    
    -   (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter
       didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate
                  withError:(NSError *)error {
      for (NSError *underlyingError in error.underlyingErrors) {
        if ([underlyingError.localizedDescription containsString:@"update_mask cannot be empty"]) {
          emptyMaskUpdates += 1;
          return;
        }
      }
      failedUpdates += 1
    }
    
    @end
    

    השבתה של עדכוני מיקום והעברת הרכב למצב אופליין

    האפליקציה יכולה להשבית עדכונים ולהעביר את הרכב למצב אופליין. לדוגמה, כשמשמרת נהג/ת מסתיימת, האפליקציה יכולה להגדיר את locationTrackingEnabled לערך false. השבתת העדכונים מגדירה את סטטוס הרכב גם ל-OFFLINE בקצה העורפי של Fleet Engine.

    Swift

    vehicleReporter.locationTrackingEnabled = false
    

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;