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

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

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

תוכלו גם להשתמש באפליקציות לדוגמה ל-iOS או בדוגמאות משולבות כדוגמה קונקרטית.

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

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

Xcode מגרסה 15 ואילך.

דרישות מוקדמות

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

צריך גם להפעיל את ה-SDK של מפות Google ל-iOS בפרויקט ב-Google Cloud וקבלת מפתח API.

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

מנהל חבילות SWIFT

אפשר להתקין את Driver SDK דרך Swift Package Manager. כדי להוסיף את ה-SDK, צריך לוודא שהסרתם את כל יחסי התלות הקיימים של Driver SDK.

חשוב: ההוראות האלה מבוססות על ההנחה שנעשה שימוש ב-Xcode מגרסה 15 ואילך, אבל הן צריכות להיות דומות לגרסאות קודמות של Xcode.

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

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

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

1. אם משדרגים מגרסה קודמת מ-9.0.0, צריך להסיר את יחסי התלות הבאים: GoogleMapsBase, GoogleMapsCore ו-GoogleMapsM4B לאחר השדרוג. אין להסיר את התלות של GoogleMaps. למידע נוסף, ראו את נתוני הגרסה של גרסה 9.0.0.

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

   • GoogleMapsBase (רק לשדרוגים מגרסאות מוקדמות יותר מ-9.0.0)
   • GoogleMapsCore (רק לשדרוגים מגרסאות מוקדמות יותר מ-9.0.0)
   • GoogleMapsM4B (רק לשדרוגים מגרסאות מוקדמות יותר מ-9.0.0)
2. מ-Xcode, עוברים אל 'קובץ' > 'חבילות' > 'עדכון לגרסאות האחרונות של החבילה'.
3. כדי לאמת את ההתקנה, עוברים לקטע Package Dependencies של Project Navigator כדי לאמת את החבילה ואת הגרסה שלה.

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

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

1. סוגרים את סביבת העבודה של Xcode. פותחים את הטרמינל ומריצים את הפקודה הבאה:

   sudo gem install cocoapods-deintegrate cocoapods-clean 
   pod deintegrate 
   pod cache clean --all

2. מסירים את Podfile, Podfile.resolved ואת ה-Xcode workspace אם אתם לא משתמשים בהם לכל מטרה אחרת מלבד CocoaPods.

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

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

   • GoogleRidesharingDriver.xcframework

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

CocoaPods

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

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

   sudo gem install 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
   

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

   cd <path-to-project>
   

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

   pod install
   

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

הערה: הקפידו להריץ מדי פעם את pod outdated כדי לזהות מתי יש גרסה חדשה יותר של ה-SDK. למידע נוסף, ראו Driver SDK לגרסאות iOS.

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

התקנה ידנית

זהירות: מומלץ להשתמש ככל האפשר ב-Cocoapods כדי להתקין את Driver SDK. לפני שתבצעו את המדריך הזה, ודאו שהורדתם את ה-XCFramework.

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

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

• GoogleRidesharingDriver.xcframework
• GoogleRidesharingDriver.bundle

חשוב: לפני השימוש במדריך הזה, צריך להתקין את Navigation SDK.

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

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

3. אם עדיין לא קיימת קבוצה, יוצרים קבוצת Frameworks תחת קבוצת הפרויקט.

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

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

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

7. פותחים את הכרטיסייה 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

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

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

Apple דורשת פרטים לגבי הפרטיות של אפליקציות ב-App Store. עדכונים ומידע נוסף זמינים בדף פרטי הפרטיות של Apple App Store.

חשוב: ההוראות האלה לגבי קובץ מניפסט הפרטיות של Apple רלוונטיות רק לגרסת ה-SDK האחרונה.

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

4. כדי לוודא שמניפסט הפרטיות נוסף, צריך ליצור ארכיון של האפליקציה וליצור דוח פרטיות מהארכיון.

הטמעת הרשאה ואימות

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

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

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

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

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

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

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

יצירת מכונה של RideshareDriverAPI

כדי לקבל מכונה של GMTDVehicleReporter, קודם צריך ליצור מכונה של GMTDRidesharingDriverAPI באמצעות providerID, vehicleID, driverContext ו-accessTokenProvider. מזהה הספק זהה למזהה הפרויקט ב-Google Cloud. בנוסף, אפשר לגשת למכונה GMTDVehicleReporter ישירות מ-driver 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:)

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

• 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 כ-listener ל-GMSRoadSnappedLocationProvider

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

הערה: כאופטימיזציה מכוונת, ייתכן שעדכוני המיקום לא יישלחו על ידי GMSRoadSnappedLocationProvider באופן רציף אם המכשיר לא זז מאז עדכון המיקום האחרון. מצב כזה יכול לקרות אם הנהג/ת מחכה ללא פעילות ברכב. אם יש מצבים שבהם GMTDVehicleReporter מוגדר כהאזנה אחרי הקריאה של startUpdatingLocation ב-GMSRoadSnappedLocationProvider, צריך להפסיק ולהפעיל את 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;