Customer SDK for iOS

$ gem install cocoapods

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

pod 'BringgTracking'

$ pod install

#define kBringgDeveloperToken @"YOUR_DEVELOPER_ACCESS_TOKEN"

self.trackingClient = [BringgTrackingClient clientWithDeveloperToken:kBringgDeveloperToken connectionDelegate:self];

- (void)signInWithName:(NSString * _Nullable)name
                 phone:(NSString * _Nullable)phone
                 email:(NSString * _Nullable)email
              password:(NSString * _Nullable)password
      confirmationCode:(NSString * _Nullable)confirmationCode
            merchantId:(NSString * _Nonnull)merchantId
                extras:(NSDictionary * _Nullable)extras
     completionHandler:(nullable GGCustomerResponseHandler)completionHandler

/**
 *  sends a findme request for a specific order
 *
 *  @param uuid                 UUID of order
 *  @param lat                 latitude
 *  @param lng                 longitude
 *  @param completionHandler    callback handler
 */
- (void)sendFindMeRequestForOrderWithUUID:(NSString *_Nonnull)uuid
                                 latitude:(double)lat
                                longitude:(double)lng
                    withCompletionHandler:(nullable GGActionResponseHandler)completionHandler

- (void)trackerDidConnect {
    NSLog(@"connected");
    
}

- (void)trackerDidDisconnectWithError:(NSError *)error {
    NSLog(@"disconnected %@", error);
   
}

// start tracking an order by UUID and set delegate to recieve order updates
[self.trackerManager startWatchingOrderWithUUID:order.uuid delegate:self];

- (void)watchOrderFailForOrder:(GGOrder *)order error:(NSError *)error{
   
  NSLog(@"Failed %@, error %@", order.uuid, error);
}

- (void)orderDidAssignWithOrder:(GGOrder *)order withDriver:(GGDriver *)driver{
    
    NSLog(@"Order assigned %@ for driver %@", order.uuid, driver.uuid)
}

- (void)orderDidAcceptWithOrder:(GGOrder *)order withDriver:(GGDriver *)driver{
  
	 NSLog(@"Order accepted %@ for driver %@", order.uuid, driver.uuid);
}

- (void)orderDidStartWithOrder:(GGOrder *)order withDriver:(GGDriver *)driver{

    NSLog(@"Order started %@ for driver %@", order.uuid, driver.uuid);
}

- (void)orderDidArrive:(GGOrder *)order withDriver:(GGDriver *)driver{
  
	NSLog(@"Order arrived %@", order.uuid);
}

- (void)orderDidFinish:(GGOrder *)order withDriver:(GGDriver *)driver{
    NSLog(@"Order finished %@", order.uuid);
  
}

- (void)orderDidCancel:(GGOrder *)order withDriver:(GGDriver *)driver{
	NSLog(@"Order canceled %@", order.uuid);
   
}

- (void)order:(nonnull GGOrder *)order didUpdateLocation:(nullable GGSharedLocation *)sharedLocation findMeConfiguration:(nullable GGFindMe *)findMeConfiguration{
  NSLog(@"order with ID %ld did update shared location %@ find me configuration to %@", (long)order.orderid, sharedLocation.locationUUID , findMeConfiguration);
}

// start tracking a driver using his UUID and the UUID of the shared location object (can be obtained from the GGOrder object). set the delegate to recieve driver updates
[self.trackerManager startWatchingDriverWithUUID:uuid shareUUID:shareuuid delegate:self];

- (void)watchDriverSucceedForDriver:(nullable GGDriver *)driver{
  NSLog(@"Monitoring success for %@" driver.uuid);
}

- (void)watchDriverFailedForDriver:(GGDriver *)driver error:(NSError *)error{
    NSLog(@"Monitoring failed for %@, error %@", driver.uuid, error);
}

- (void)driverLocationDidChangeWithDriver:(GGDriver *)driver{
    NSLog(@"driver %@  is at %f,%f",driver.uuid, driver.latitude, driver.longitude);
}

- (void)driverLocationDidChangedWithDriverUUID:(NSString *)driverUUID lat:(NSNumber *)lat lng:(NSNumber *)lng {
    NSLog(@"lat %@, lng %@", lat, lng);
    
}

/**
 creates the bringg tracking client singelton

 @param developerToken developer token as given by bringg platform
 @param delegate connection delegate to track connection status of tracking client
 @return singelton
 */
+ (nonnull instancetype)clientWithDeveloperToken:(nonnull NSString *)developerToken connectionDelegate:(nonnull id<RealTimeDelegate>)delegate;



//MARK: -- Connection

/**
 connects the tracking client to Bringg platform
 */
- (void)connect;

/**
 disconnects tracking.
 */
- (void)disconnect;


/**
 check if client is connected to Bringg platform

 @return BOOL
 */
- (BOOL)isConnected;

/**
 *  perform a sign in request with a specific customers credentials
 *  @warning do not call this method before setting a valid developer token. also notice method call won't work without valid confirmation code and merchant Id
 *  @param name              name of customer (don't use email here)
 *  @param phone             phone number of customer
 *  @param confirmationCode  sms confirmation code
 *  @param merchantId        merchant id registered for the customer
 *  @param extras            additional arguments to add to the call
 *  @param completionHandler block to handle async service response
 */
- (void)signInWithName:(NSString * _Nullable)name
                 phone:(NSString * _Nullable)phone
                 email:(NSString * _Nullable)email
              password:(NSString * _Nullable)password
      confirmationCode:(NSString * _Nullable)confirmationCode
            merchantId:(NSString * _Nonnull)merchantId
                extras:(NSDictionary * _Nullable)extras
     completionHandler:(nullable GGCustomerResponseHandler)completionHandler;


/**
 *  tels if the customer is signed in
 *
 *  @return BOOL
 */
- (BOOL)isSignedIn;

/**
 *  retriesve the customer object of the signed in customer
 *
 *  @return GGCustomer
 */
- (nullable GGCustomer *)signedInCustomer;




//MARK: -- Tracking


/**
 *  starts watching an order using both order uuid and shared uuid
 *
 *  @param uuid       order uuid
 *  @param shareUUID share uuid
 *  @param delegate   delegate
 *  @throws if invalid or missing either order UUID or shared UUID
 */
- (void)startWatchingOrderWithUUID:(NSString *_Nonnull)uuid
                         shareUUID:(NSString *_Nonnull)shareUUID
                          delegate:(id <OrderDelegate> _Nullable)delegate;


/**
 *  starts watching an order using both order uuid and shared uuid
 *
 *  @param uuid       order uuid
 *  @param customerAccessToken customer access token
 *  @param delegate   delegate
 *  @throws if invalid or missing either order UUID or shared UUID
 */
- (void)startWatchingOrderWithUUID:(NSString *_Nonnull)uuid
               customerAccessToken:(NSString *_Nonnull)customerAccessToken
                          delegate:(id <OrderDelegate> _Nullable)delegate;


/**
 *  asks the real time service to start tracking a specific driver
 *
 *  @param uuid      uuid of driver
 *  @param shareUUID uuid of shared location object associated with a specific order
 *  @param delegate  object to recieve driver callbacks
 *  @see DriverDelegate
 */
- (void)startWatchingDriverWithUUID:(NSString *_Nonnull)driveruuid
                          shareUUID:(NSString *_Nonnull)shareUUID
                           delegate:(id <DriverDelegate> _Nullable)delegate;


/**
 *  asks the real time service to start tracking a specific driver using driver uuid and customer access token
 *
 *  @param uuid      uuid of driver
 *  @param delegate  object to recieve driver callbacks
 *  @see DriverDelegate
 */
- (void)startWatchingCustomerDriverWithUUID:(NSString *_Nonnull)uuid
                                   delegate:(id <DriverDelegate> _Nullable)delegate;

/**
 *  asks the real time service to start tracking a specific waypoint
 *
 *  @param waypointId id of waypoint
 *  @param order uuid of of order handling the waypoint
 *  @param delegate   object to recieve waypoint callbacks
 *  @see WaypointDelegate
 */
- (void)startWatchingWaypointWithWaypointId:(NSNumber *_Nonnull)waypointId
                               andOrderUUID:(NSString * _Nonnull)orderUUID
                                   delegate:(id <WaypointDelegate> _Nullable)delegate;


/**
 *  sends a findme request for a specific order
 *
 *  @param uuid                 UUID of order
 *  @param lat                 latitude
 *  @param lng                 longitude
 *  @param completionHandler    callback handler
 */
- (void)sendFindMeRequestForOrderWithUUID:(NSString *_Nonnull)uuid
                                 latitude:(double)lat
                                longitude:(double)lng
                    withCompletionHandler:(nullable GGActionResponseHandler)completionHandler;


/**
 send customer rating for a specific order

 @param order order to rate
 @param rating rating for order's driver - must be between (1-5)
 @param completionHandler block to handle async service response
 */
- (void)rateOrder:(nonnull GGOrder *)order
       withRating:(int)rating
completionHandler:(nullable GGRatingResponseHandler)completionHandler;

/**
 *  stops tracking a specific order
 *
 *  @param uuid uuid of order
 */
- (void)stopWatchingOrderWithUUID:(NSString *_Nonnull)uuid;


/**
 *  stop watching all orders
 */
- (void)stopWatchingAllOrders;

/**
 *  stops tracking a specific driver
 *
 *  @param uuid      uuid of driver
 */
- (void)stopWatchingDriverWithUUID:(NSString *_Nonnull)uuid;

/**
 *  stops watching all drivers
 */
- (void)stopWatchingAllDrivers;

/**
 *  stops tracking a specific waypoint
 *
 *  @param waypointId id of waypoint
 *  @param orderUUID uuid of order with waypoint
 */
- (void)stopWatchingWaypointWithWaypointId:(NSNumber * _Nonnull)waypointId andOrderUUID:(NSString * _Nonnull)orderUUID;

/**
 *  stops tracking all waypoints
 */
- (void)stopWatchingAllWaypoints;


/**
 *  return an order matching a uuid
 *
 *  @param uuid order uuid to search
 *
 *  @return GGOrder
 */
- (nullable GGOrder *)orderWithUUID:(nonnull NSString *)uuid;

/**
 *  tell if a specific order is being watched
 *
 *  @param uuid uuid of order in question
 *
 *  @return BOOL
 */
- (BOOL)isWatchingOrderWithUUID:(NSString *_Nonnull)uuid;



/**
 *  return a driver matching a uuid
 *
 *  @param uuid driver uuid to search
 *
 *  @return GGDriver
 */
- (nullable GGDriver *)driverWithUUID:(nonnull NSString *)uuid;

/**
 *  tell if a specific driver is being watched
 *
 *  @param uuid uuid of driver
 *
 *  @return BOOL
 */
- (BOOL)isWatchingDriverWithUUID:(NSString *_Nonnull)uuid;


/**
 *  return a shared uuid object matching a driver uuid
 *
 *  @param uuid driver uuid to search by
 *
 *  @return NSString
 */
- (nullable NSString *)shareUUIDForDriverWithUUID:(nonnull NSString*)driverUUID;

/**
 *  tell if a specific waypoint is being watched
 *
 *  @param waypointId id of waypoint
 *  @param orderUUID uuid of order
 *  @return BOOL
 */
- (BOOL)isWatchingWaypointWithWaypointId:(NSNumber *_Nonnull)waypointId andOrderUUID:(NSString * _Nonnull)orderUUID;

/**
 *  notifies delegate that a socket connection has been made
 */
- (void)trackerDidConnect;

/**
 *  notifies the delegate that the tracker has disconnected the socket connection w/o and error
 *  @usage the tracker manager handles connection recoveries by its own if network allows it. so this notifications is just to give the delegete a change to updates its own model to whatever he desiers
 *  @param error an error describing connection error (might be nill if forced)
 */
- (void)trackerDidDisconnectWithError:(NSError * _Nullable)error;


@optional
/**
 *  delegate method to track the last date the tracker manager recieved data
 *
 *  @param eventDate date of event
 */
-(void)trackerDidRecieveDataEventAtDate:(NSDate * _Nonnull)eventDate;

/**
 *  notifies watch action for an order has succeed
 *
 *  @param order the order requesting watch
 */
- (void)watchOrderSucceedForOrder:(nonnull GGOrder *)order;

/**
 *  notifies watch action for an order has failed
 *
 *  @param order the order requesting watch
 *  @param error failure reason
 */
- (void)watchOrderFailForOrder:(nonnull GGOrder *)order error:(nonnull NSError *)error;


/**
 *  notifies an order was assigned to a driver
 *
 *  @param order  order
 *  @param driver driver assigned
 */
- (void)orderDidAssignWithOrder:(nonnull GGOrder *)order withDriver:(nonnull GGDriver *)driver;

/**
 *  notfies an order was accepted by a certain driver
 *
 *  @param order  order
 *  @param driver accepting driver
 */
- (void)orderDidAcceptWithOrder:(nonnull GGOrder *)order withDriver:(nonnull GGDriver *)driver;


/**
 *  notifies an order is starting its course to its destination
 *
 *  @param order  order
 *  @param driver driver of order
 */
- (void)orderDidStartWithOrder:(nonnull GGOrder *)order withDriver:(nonnull GGDriver *)driver;
@optional

/**
 *  notifies an order has arrived to one of it's destinations
 *
 *  @param order  order
 *  @param driver driver of order
 */
- (void)orderDidArrive:(nonnull GGOrder *)order withDriver:(nonnull GGDriver *)driver;


/**
 *  notifies an order delivery has been completed
 *
 *  @param order  order
 *  @param driver driver of order
 */
- (void)orderDidFinish:(nonnull GGOrder *)order withDriver:(nonnull GGDriver *)driver;

/**
 *  notifies an order has been cancled
 *
 *  @param order  order
 *  @param driver driver of order
 */
- (void)orderDidCancel:(nonnull GGOrder *)order withDriver:(nullable GGDriver *)driver;

/**
 *  notifies updates for shared locations and findme configuration for specific orders
 *
 *  @param order               the order
 *  @param sharedLocation      orders shared location object
 *  @param findMeConfiguration findme configuration object
 */
- (void)order:(nonnull GGOrder *)order didUpdateLocation:(nullable GGSharedLocation *)sharedLocation findMeConfiguration:(nullable GGFindMe *)findMeConfiguration;

/**
 *  notifies that the tracker is about to revive all previously monitored orders
 *
 *  @param orderUUID uuid of order
 */
- (void)trackerWillReviveWatchedOrder:(nonnull NSString *)orderUUID;

/**
 *  notifies if watching a driver succeed
 *
 *  @param waypointId id of driver
 */
- (void)watchDriverSucceedForDriver:(nullable GGDriver *)driver;

/**
 *  notifies if watching a driver failed
 *
 *  @param waypointId id of driver
 *  @param error      error
 */
- (void)watchDriverFailedForDriver:(nullable GGDriver *)driver error:(nonnull NSError *)error;
@optional

/**
 *  notifies a driver has changed location
 *
 *  @param driver the updated driver object
 */
- (void)driverLocationDidChangeWithDriver:(nonnull GGDriver *)driver;

/**
 *  notifies that the tracker is about to revive all previously monitored drivers
 *
 *  @param driverUUID uuid of driver
 *  @param sharedUUID uuid of shared
 */
- (void)trackerWillReviveWatchedDriver:(nonnull NSString *)driverUUID withSharedUUID:(nonnull NSString *)sharedUUID;

/**
 *  notifies if watching a waypoint failed
 *
 *  @param waypointId id of waypoint
 *  @param error      error
 */
- (void)watchWaypointFailedForWaypointId:(nonnull NSNumber *)waypointId error:(nonnull NSError *)error;




/**
 notifies if watching waypoint succeeded

 @param waypointId id of waypoint
 @param waypoint the model of the waypoint
 */
- (void)watchWaypointSucceededForWaypointId:(nonnull NSNumber *)waypointId waypoint:(nonnull GGWaypoint *)waypoint;


/**
 *  notifies ETA updates to a waypoint
 *
 *  @param waypointId id of waypoint
 *  @param eta        ETA
 */
- (void)waypointDidUpdatedWaypointId:(nonnull NSNumber *)waypointId eta:(nullable NSDate *)eta;

@optional

/**
 *  notifies waypoint changed location
 *
 *  @param lat lat
 *  @param lng lng
 */
- (void)waypoint:(nonnull NSNumber *)waypointId didUpdatedCoordinatesToLat:(nonnull NSNumber *)lat lng:(nonnull NSNumber *)lng;


/**
 *  notifies a driver has arrvied a waypoint
 *
 *  @param waypointId id of waypoint
 */
- (void)waypointDidArrivedWaypointId:(nonnull NSNumber *)waypointId;

/**
 *  notifies a waypoint has finished
 *
 *  @param waypointId id of waypoint
 */
- (void)waypointDidFinishedWaypointId:(nonnull NSNumber *)waypointId;


/**
 *  notifies that the tracker is about to revive all previously monitored waypoints
 *
 *  @param waypointId id of waypoint
 */
- (void)trackerWillReviveWatchedWaypoint:(nonnull NSNumber *)waypointId;