10182571597

Committed 31 Jul 2024 02:53PM UTC coverage: 63.276% (+0.09%) from 63.185%

Build # 10182571597

Build Type

push

github

Committed by

web-flow

Commit Message

sync: Upgrade from SCNetworkReachability -> nw_path_monitor (#1406)

Run Details

5656 of 13372 branches covered (42.3%)

Branch coverage included in aggregate %.

0 of 29 new or added lines in 2 files covered. (0.0%)

10 existing lines in 3 files now uncovered.

18819 of 25308 relevant lines covered (74.36%)

6723.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/Source/santasyncservice/SNTSyncFCM.m

/// Copyright 2021 Google Inc. All rights reserved.
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///    http://www.apache.org/licenses/LICENSE-2.0
///
///    Unless required by applicable law or agreed to in writing, software
///    distributed under the License is distributed on an "AS IS" BASIS,
///    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
///    See the License for the specific language governing permissions and
///    limitations under the License.

#import "Source/santasyncservice/SNTSyncFCM.h"

#import <Network/Network.h>

#import <MOLAuthenticatingURLSession/MOLAuthenticatingURLSession.h>

#ifdef DEBUG
#define LOGD(format, ...) NSLog(format, ##__VA_ARGS__);
#else  // DEBUG
#define LOGD(format, ...)
#endif  // DEBUG

/**  FCM checkin and register components */
static NSString *const kFCMCheckinHost = @"https://android.clients.google.com";
static NSString *const kFCMCheckin = @"/checkin";
static NSString *const kFCMCheckinBody = @"{'checkin':{}, 'version':3}";
static NSString *const kFCMRegister = @"/c2dm/register3";

/**  FCM connect and ack components */
static NSString *const kFCMConnectHost = @"https://fcmconnection.googleapis.com";
static NSString *const kFCMConnect = @"/v1alpha1:connectDownstream";
static NSString *const kFCMAck = @"/v1alpha1:ack";

/**  FCM client keys */
static NSString *const kAndroidIDKey = @"android_id";
static NSString *const kVersionInfoKey = @"version_info";
static NSString *const kSecurityTokenKey = @"security_token";

/**  HTTP Header Constants */
static NSString *const kFCMApplicationForm = @"application/x-www-form-urlencoded";
static NSString *const kFCMApplicationJSON = @"application/json";
static NSString *const kFCMContentType = @"Content-Type";

/**  Default 15 minute backoff maximum */
static const uint32_t kDefaultBackoffMaxSeconds = 900;

/**  Default 10 sec connect delay maximum */
static const uint32_t kDefaultConnectDelayMaxSeconds = 10;

#pragma mark MOLFCMClient Extension

@interface SNTSyncFCM () {
  /**  URL components for client registration, receiving and acknowledging messages. */
  NSURLComponents *_checkinComponents;
  NSURLComponents *_registerComponents;
  NSURLComponents *_connectComponents;
  NSURLComponents *_ackComponents;

  /**  Holds the NSURLSession object generated by the MOLAuthenticatingURLSession object. */
  NSURLSession *_session;

  /**  Holds the current backoff seconds. */
  uint32_t _backoffSeconds;

  /**  Holds the max connect and backoff seconds. */
  uint32_t _connectDelayMaxSeconds;
  uint32_t _backoffMaxSeconds;

  NSArray<NSNumber *> *_fatalHTTPStatusCodes;
}

/**  NSURLSession wrapper used for https communication with the FCM service. */
@property(nonatomic) MOLAuthenticatingURLSession *authSession;

/**  The block to be called for every message. */
@property(copy, nonatomic) SNTSyncFCMMessageHandler messageHandler;

/**  Is used throughout the class to reconnect to FCM after a connection loss. */
@property nw_path_monitor_t pathMonitor;

/**  FCM client identities. */
@property(nonatomic, readonly) NSString *project;
@property(nonatomic, readonly) NSString *entity;
@property(nonatomic, readonly) NSString *apiKey;

/**  FCM client checkin data */
@property NSString *androidID;
@property NSString *versionInfo;
@property NSString *securityToken;

/**  Called by the reachability handler when the host becomes reachable. */
- (void)reachabilityRestored;

@end

@implementation SNTSyncFCM

#pragma mark init/dealloc methods

- (instancetype)initWithProject:(NSString *)project
                         entity:(NSString *)entity
                         apiKey:(NSString *)apiKey
                connectDelayMax:(uint32_t)connectDelayMax
                     backoffMax:(uint32_t)backoffMax
                     fatalCodes:(NSArray<NSNumber *> *)fatalCodes
           sessionConfiguration:(NSURLSessionConfiguration *)sessionConfiguration
                 messageHandler:(SNTSyncFCMMessageHandler)messageHandler {
  self = [super init];
  if (self) {
    _project = project;
    _entity = entity;
    _apiKey = apiKey;
    _checkinComponents = [NSURLComponents componentsWithString:kFCMCheckinHost];
    _checkinComponents.path = kFCMCheckin;
    _registerComponents = [NSURLComponents componentsWithString:kFCMCheckinHost];
    _registerComponents.path = kFCMRegister;
    _connectComponents = [NSURLComponents componentsWithString:kFCMConnectHost];
    _connectComponents.path = kFCMConnect;
    _ackComponents = [NSURLComponents componentsWithString:kFCMConnectHost];
    _ackComponents.path = kFCMAck;

    _messageHandler = messageHandler;

    _authSession = [[MOLAuthenticatingURLSession alloc]
      initWithSessionConfiguration:sessionConfiguration
                                     ?: [NSURLSessionConfiguration defaultSessionConfiguration]];
    _authSession.dataTaskDidReceiveDataBlock = [self dataTaskDidReceiveDataBlock];
    _authSession.taskDidCompleteWithErrorBlock = [self taskDidCompleteWithErrorBlock];

    _session = _authSession.session;

    _connectDelayMaxSeconds = connectDelayMax ?: kDefaultConnectDelayMaxSeconds;
    _backoffMaxSeconds = backoffMax ?: kDefaultBackoffMaxSeconds;
    _fatalHTTPStatusCodes = fatalCodes ?: @[ @302, @400, @401, @403, @404 ];
  }
  return self;
}

- (instancetype)initWithProject:(NSString *)project
                         entity:(NSString *)entity
                         apiKey:(NSString *)apiKey
           sessionConfiguration:(NSURLSessionConfiguration *)sessionConfiguration
                 messageHandler:(SNTSyncFCMMessageHandler)messageHandler {
  return [self initWithProject:project
                        entity:entity
                        apiKey:apiKey
               connectDelayMax:0
                    backoffMax:0
                    fatalCodes:nil
          sessionConfiguration:sessionConfiguration
                messageHandler:messageHandler];
}

- (instancetype)initWithProject:(NSString *)project
                         entity:(NSString *)entity
                         apiKey:(NSString *)apiKey
                 messageHandler:(SNTSyncFCMMessageHandler)messageHandler {
  return [self initWithProject:project
                        entity:entity
                        apiKey:apiKey
               connectDelayMax:0
                    backoffMax:0
                    fatalCodes:nil
          sessionConfiguration:nil
                messageHandler:messageHandler];
}

#pragma mark property methods

- (BOOL)isConnected {
  if (!self.androidID || !self.securityToken) return NO;
  for (NSURLSessionDataTask *dataTask in [self dataTasks]) {
    if (dataTask.state == NSURLSessionTaskStateRunning) return YES;
  }
  return NO;
}

#pragma mark reachability methods

- (void)reachabilityRestored {
  LOGD(@"Reachability restored. Reconnect after a backoff of %i seconds", _backoffSeconds);
  [self stopReachability];
  dispatch_time_t t = dispatch_time(DISPATCH_TIME_NOW, _backoffSeconds * NSEC_PER_SEC);
  dispatch_after(t, dispatch_get_main_queue(), ^{
    [self connectHelper];
  });
}

/**  Start listening for network state changes on a background thread. */
- (void)startReachability {
  if (self.pathMonitor) return;
  self.pathMonitor = nw_path_monitor_create();
  nw_path_monitor_set_queue(self.pathMonitor, dispatch_get_main_queue());
  nw_path_monitor_set_update_handler(self.pathMonitor, ^(nw_path_t path) {
    if (nw_path_get_status(path) == nw_path_status_satisfied) {
      SEL s = @selector(reachabilityRestored);
      [NSObject cancelPreviousPerformRequestsWithTarget:self selector:s object:nil];
      [self performSelector:s withObject:nil afterDelay:1];
    }
  });
  nw_path_monitor_set_cancel_handler(self.pathMonitor, ^{
    self.pathMonitor = nil;
  });
  nw_path_monitor_start(self.pathMonitor);
  LOGD(@"Reachability started.");
}

/**  Stop listening for network state changes. */
- (void)stopReachability {
  if (!self.pathMonitor) return;
  nw_path_monitor_cancel(self.pathMonitor);
}

#pragma mark message methods

- (void)connect {
  uint32_t ms = arc4random_uniform(_connectDelayMaxSeconds * 1000);
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, ms * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
    [self connectHelper];
  });
}

- (void)connectHelper {
  LOGD(@"Connecting...");
  [self cancelConnections];

  // Reuse checkin credentials / FCM token if allready registered.
  if (!self.androidID || !self.securityToken) return [self checkin];

  NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_connectComponents.URL];
  [URLRequest addValue:kFCMApplicationJSON forHTTPHeaderField:kFCMContentType];
  URLRequest.HTTPMethod = @"GET";
  [self setCheckinAuthorization:URLRequest];
  [[_session dataTaskWithRequest:URLRequest] resume];
}

- (void)checkin {
  NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_checkinComponents.URL];
  [URLRequest addValue:kFCMApplicationJSON forHTTPHeaderField:kFCMContentType];
  URLRequest.HTTPMethod = @"POST";
  URLRequest.HTTPBody = [kFCMCheckinBody dataUsingEncoding:NSUTF8StringEncoding];
  [[_session dataTaskWithRequest:URLRequest] resume];
}

- (void)checkinDataHandler:(NSData *)data {
  id jo = [NSJSONSerialization JSONObjectWithData:data options:0 error:NULL];
  LOGD(@"checkin: %@", jo);
  NSDictionary *checkin = [self extractCheckinFrom:jo];
  if (!checkin) return;
  self.androidID = [(NSNumber *)checkin[kAndroidIDKey] stringValue];
  self.versionInfo = checkin[kVersionInfoKey];
  self.securityToken = [(NSNumber *)checkin[kSecurityTokenKey] stringValue];
}

- (NSDictionary *)extractCheckinFrom:(id)jo {
  if (!jo) return nil;
  if (![jo isKindOfClass:[NSDictionary class]]) return nil;
  if (!jo[kAndroidIDKey]) return nil;
  if (![jo[kAndroidIDKey] isKindOfClass:[NSNumber class]]) return nil;
  if (!jo[kVersionInfoKey]) return nil;
  if (![jo[kVersionInfoKey] isKindOfClass:[NSString class]]) return nil;
  if (!jo[kSecurityTokenKey]) return nil;
  if (![jo[kSecurityTokenKey] isKindOfClass:[NSNumber class]]) return nil;
  return jo;
}

- (void)register {
  NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_registerComponents.URL];
  URLRequest.HTTPMethod = @"POST";
  URLRequest.HTTPBody = [kFCMCheckinBody dataUsingEncoding:NSUTF8StringEncoding];
  NSURLComponents *params = [[NSURLComponents alloc] init];
  params.queryItems = @[
    [NSURLQueryItem queryItemWithName:@"app" value:self.project],
    [NSURLQueryItem queryItemWithName:@"info" value:self.versionInfo],
    [NSURLQueryItem queryItemWithName:@"sender" value:self.entity],
    [NSURLQueryItem queryItemWithName:@"device" value:self.androidID],
    [NSURLQueryItem queryItemWithName:@"X-scope" value:@"*"],
  ];
  URLRequest.HTTPBody = [params.query dataUsingEncoding:NSUTF8StringEncoding];
  [URLRequest addValue:kFCMApplicationForm forHTTPHeaderField:kFCMContentType];
  NSString *aid = [NSString stringWithFormat:@"AidLogin %@:%@", self.androidID, self.securityToken];
  [URLRequest addValue:aid forHTTPHeaderField:@"Authorization"];
  [[_session dataTaskWithRequest:URLRequest] resume];
}

- (void)registerDataHandler:(NSData *)data {
  NSString *t = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  NSArray *c = [t componentsSeparatedByString:@"="];
  if (c.count == 2) {
    NSString *tok = c[1];
    if ([tok isEqualToString:@"PHONE_REGISTRATION_ERROR"]) {
      LOGD(@"register: PHONE_REGISTRATION_ERROR - retrying");
      sleep(1);
      return [self register];
    }
    if (self.tokenHandler) self.tokenHandler(tok);
  }
}

- (void)acknowledgeMessage:(NSDictionary *)message {
  if (!message[@"messageId"]) return;
  NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_ackComponents.URL];
  URLRequest.HTTPMethod = @"POST";
  [URLRequest addValue:kFCMApplicationJSON forHTTPHeaderField:kFCMContentType];
  [self setCheckinAuthorization:URLRequest];
  NSDictionary *b = @{@"ack" : @{@"messageId" : message[@"messageId"]}};
  NSData *body = [NSJSONSerialization dataWithJSONObject:b options:0 error:NULL];
  URLRequest.HTTPBody = body;
  [[_session dataTaskWithRequest:URLRequest
               completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                 if (((NSHTTPURLResponse *)response).statusCode != 200) {
                   if (self.acknowledgeErrorHandler) {
                     self.acknowledgeErrorHandler(message, error);
                   }
                 }
               }] resume];
}

- (void)disconnect {
  [self stopReachability];
  [_session invalidateAndCancel];
  _session = nil;
}

- (void)cancelConnections {
  for (NSURLSessionDataTask *dataTask in [self dataTasks]) {
    [dataTask cancel];
  }
}

- (NSArray<NSURLSessionDataTask *> *)dataTasks {
  __block NSArray *dataTasks;
  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
  [_session getTasksWithCompletionHandler:^(NSArray *data, NSArray *upload, NSArray *download) {
    dataTasks = data;
    dispatch_semaphore_signal(sema);
  }];
  dispatch_semaphore_wait(sema, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC));
  return dataTasks;
}

/**
 *  Parse FCM data; extract and call self.messageHandler for each message.
 *
 *  Expected format:
 *   [{
 *     "noOp": {}
 *   }
 *   , <-- start of new chunk
 *   {
 *     "noOp": {}
 *   }
 *
 */
- (void)processMessagesFromData:(NSData *)data {
  if (!data) return;
  NSMutableString *raw = [[NSMutableString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  if (raw.length < 2) return;
  // Add an opening bracket if this is a message in the middle of the stream.
  [raw replaceOccurrencesOfString:@",\r" withString:@"[" options:0 range:NSMakeRange(0, 2)];
  // Always add a closing bracket.
  [raw appendString:@"]"];
  NSError *err;
  id jo = [NSJSONSerialization JSONObjectWithData:[raw dataUsingEncoding:NSUTF8StringEncoding]
                                          options:0
                                            error:&err];
  if (!jo) {
    if (err) LOGD(@"processMessagesFromData err: %@", err);
    return;
  }
  LOGD(@"processMessagesFromData: %@", jo);

  if (![jo isKindOfClass:[NSArray class]]) return;
  for (id md in jo) {
    if (![md isKindOfClass:[NSDictionary class]]) continue;
    NSDictionary *m = md[@"message"];
    if ([m isKindOfClass:[NSDictionary class]]) self.messageHandler(m);
  }
}

- (void)handleHTTPReponse:(NSHTTPURLResponse *)HTTPResponse error:(NSError *)error {
  if (HTTPResponse.statusCode == 200) {
    _backoffSeconds = 0;
    if ([HTTPResponse.URL.path isEqualToString:kFCMCheckin]) {
      // If checkin was successful, start listening for messages and continue to register.
      [self connectHelper];
      return [self register];
    } else if ([HTTPResponse.URL.path isEqualToString:kFCMConnect]) {
      // connect will re-connect.
      return [self connectHelper];
    }  // register may be called more than once, don't do anything in response.
  } else if ([_fatalHTTPStatusCodes containsObject:@(HTTPResponse.statusCode)]) {
    if (self.connectionErrorHandler) self.connectionErrorHandler(HTTPResponse, error);
  } else {
    // If no backoff is set, start out with 5 - 15 seconds.
    // If a backoff is already set, double it, with a max of kBackoffMaxSeconds.
    _backoffSeconds = _backoffSeconds * 2 ?: arc4random_uniform(11) + 5;
    if (_backoffSeconds > _backoffMaxSeconds) _backoffSeconds = _backoffMaxSeconds;
    if (error) LOGD(@"handleHTTPReponse err: %@", error);
    [self startReachability];
  }
}

- (void)setCheckinAuthorization:(NSMutableURLRequest *)URLRequest {
  NSString *a = [NSString
    stringWithFormat:@"checkin %@:%@ %@", self.androidID, self.securityToken, self.versionInfo];
  [URLRequest addValue:a forHTTPHeaderField:@"Authorization"];
  [URLRequest addValue:self.apiKey forHTTPHeaderField:@"X-Goog-Api-Key"];
}

#pragma mark NSURLSession block property and methods

/**
 *  MOLAuthenticatingURLSession is the NSURLSessionDelegate. It will call this block every time
 *  the URLSession:task:didCompleteWithError: is called. This allows MOLFCMClient to be notified
 *  when a task ends while using delegate methods.
 */
- (void (^)(NSURLSession *, NSURLSessionDataTask *, NSData *))dataTaskDidReceiveDataBlock {
  __weak __typeof(self) weakSelf = self;
  return ^(NSURLSession *session, NSURLSessionDataTask *dataTask, NSData *data) {
    __typeof(self) strongSelf = weakSelf;
    NSString *path = dataTask.originalRequest.URL.path;
    if ([path isEqualToString:kFCMCheckin]) {
      return [strongSelf checkinDataHandler:data];
    } else if ([path isEqualToString:kFCMRegister]) {
      return [strongSelf registerDataHandler:data];
    } else if ([dataTask.originalRequest.URL.path isEqualToString:kFCMConnect]) {
      [strongSelf processMessagesFromData:data];
    }
  };
}

/**
 *  MOLAuthenticatingURLSession is the NSURLSessionDataDelegate. It will call this block every time
 *  the URLSession:dataTask:didReceiveData: is called. This allows for message data chunks to be
 *  processed as they appear in the FCM buffer. For Content-Type: text/html there is a 512 byte
 *  buffer that must be filled before data is returned. Content-Type: application/json does not use
 *  a buffer and data is returned as soon as it is available.
 *
 *  TODO:(bur) Follow up with FCM on Content-Type: application/json. Currently FCM returns data with
 *  Content-Type: text/html. Messages under 512 bytes will not be processed until the connection
 *  drains.
 */
- (void (^)(NSURLSession *, NSURLSessionTask *, NSError *))taskDidCompleteWithErrorBlock {
  __weak __typeof(self) weakSelf = self;
  return ^(NSURLSession *session, NSURLSessionTask *task, NSError *error) {
    __typeof(self) strongSelf = weakSelf;
    // task.response can be nil when an NSURLError* occurs
    if (task.response && ![task.response isKindOfClass:[NSHTTPURLResponse class]]) {
      if (strongSelf.connectionErrorHandler) strongSelf.connectionErrorHandler(nil, error);
      return;
    }
    NSHTTPURLResponse *HTTPResponse = (NSHTTPURLResponse *)task.response;
    [strongSelf handleHTTPReponse:HTTPResponse error:error];
  };
}

@end

1	/// Copyright 2021 Google Inc. All rights reserved.
2	///
3	/// Licensed under the Apache License, Version 2.0 (the "License");
4	/// you may not use this file except in compliance with the License.
5	/// You may obtain a copy of the License at
6	///
7	/// http://www.apache.org/licenses/LICENSE-2.0
8	///
9	/// Unless required by applicable law or agreed to in writing, software
10	/// distributed under the License is distributed on an "AS IS" BASIS,
11	/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	/// See the License for the specific language governing permissions and
13	/// limitations under the License.
14
15	#import "Source/santasyncservice/SNTSyncFCM.h"
16
17	#import <Network/Network.h>
18
19	#import <MOLAuthenticatingURLSession/MOLAuthenticatingURLSession.h>
20
21	#ifdef DEBUG
22	#define LOGD(format, ...) NSLog(format, ##__VA_ARGS__);	×
23	#else // DEBUG
24	#define LOGD(format, ...)
25	#endif // DEBUG
26
27	/** FCM checkin and register components */
28	static NSString *const kFCMCheckinHost = @"https://android.clients.google.com";
29	static NSString *const kFCMCheckin = @"/checkin";
30	static NSString *const kFCMCheckinBody = @"{'checkin':{}, 'version':3}";
31	static NSString *const kFCMRegister = @"/c2dm/register3";
32
33	/** FCM connect and ack components */
34	static NSString *const kFCMConnectHost = @"https://fcmconnection.googleapis.com";
35	static NSString *const kFCMConnect = @"/v1alpha1:connectDownstream";
36	static NSString *const kFCMAck = @"/v1alpha1:ack";
37
38	/** FCM client keys */
39	static NSString *const kAndroidIDKey = @"android_id";
40	static NSString *const kVersionInfoKey = @"version_info";
41	static NSString *const kSecurityTokenKey = @"security_token";
42
43	/** HTTP Header Constants */
44	static NSString *const kFCMApplicationForm = @"application/x-www-form-urlencoded";
45	static NSString *const kFCMApplicationJSON = @"application/json";
46	static NSString *const kFCMContentType = @"Content-Type";
47
48	/** Default 15 minute backoff maximum */
49	static const uint32_t kDefaultBackoffMaxSeconds = 900;
50
51	/** Default 10 sec connect delay maximum */
52	static const uint32_t kDefaultConnectDelayMaxSeconds = 10;
53
54	#pragma mark MOLFCMClient Extension
55
56	@interface SNTSyncFCM () {
57	/** URL components for client registration, receiving and acknowledging messages. */
58	NSURLComponents *_checkinComponents;
59	NSURLComponents *_registerComponents;
60	NSURLComponents *_connectComponents;
61	NSURLComponents *_ackComponents;
62
63	/** Holds the NSURLSession object generated by the MOLAuthenticatingURLSession object. */
64	NSURLSession *_session;
65
66	/** Holds the current backoff seconds. */
67	uint32_t _backoffSeconds;
68
69	/** Holds the max connect and backoff seconds. */
70	uint32_t _connectDelayMaxSeconds;
71	uint32_t _backoffMaxSeconds;
72
73	NSArray<NSNumber > _fatalHTTPStatusCodes;
74	}
75
76	/** NSURLSession wrapper used for https communication with the FCM service. */
77	@property(nonatomic) MOLAuthenticatingURLSession *authSession;
78
79	/** The block to be called for every message. */
80	@property(copy, nonatomic) SNTSyncFCMMessageHandler messageHandler;
81
82	/** Is used throughout the class to reconnect to FCM after a connection loss. */
83	@property nw_path_monitor_t pathMonitor;
84
85	/** FCM client identities. */
86	@property(nonatomic, readonly) NSString *project;
87	@property(nonatomic, readonly) NSString *entity;
88	@property(nonatomic, readonly) NSString *apiKey;
89
90	/** FCM client checkin data */
91	@property NSString *androidID;
92	@property NSString *versionInfo;
93	@property NSString *securityToken;
94
95	/** Called by the reachability handler when the host becomes reachable. */
96	- (void)reachabilityRestored;
97
98	@end
99
100	@implementation SNTSyncFCM
101
102	#pragma mark init/dealloc methods
103
104	- (instancetype)initWithProject:(NSString *)project
105	entity:(NSString *)entity
106	apiKey:(NSString *)apiKey
107	connectDelayMax:(uint32_t)connectDelayMax
108	backoffMax:(uint32_t)backoffMax
109	fatalCodes:(NSArray<NSNumber > )fatalCodes
110	sessionConfiguration:(NSURLSessionConfiguration *)sessionConfiguration
111	messageHandler:(SNTSyncFCMMessageHandler)messageHandler {	×
112	self = [super init];	×
113	if (self) {	×
114	_project = project;	×
115	_entity = entity;	×
116	_apiKey = apiKey;	×
117	_checkinComponents = [NSURLComponents componentsWithString:kFCMCheckinHost];	×
118	_checkinComponents.path = kFCMCheckin;	×
119	_registerComponents = [NSURLComponents componentsWithString:kFCMCheckinHost];	×
120	_registerComponents.path = kFCMRegister;	×
121	_connectComponents = [NSURLComponents componentsWithString:kFCMConnectHost];	×
122	_connectComponents.path = kFCMConnect;	×
123	_ackComponents = [NSURLComponents componentsWithString:kFCMConnectHost];	×
124	_ackComponents.path = kFCMAck;	×
125
126	_messageHandler = messageHandler;	×
127
128	_authSession = [[MOLAuthenticatingURLSession alloc]	×
129	initWithSessionConfiguration:sessionConfiguration	×
130	?: [NSURLSessionConfiguration defaultSessionConfiguration]];	×
131	_authSession.dataTaskDidReceiveDataBlock = [self dataTaskDidReceiveDataBlock];	×
132	_authSession.taskDidCompleteWithErrorBlock = [self taskDidCompleteWithErrorBlock];	×
133
134	_session = _authSession.session;	×
135
136	_connectDelayMaxSeconds = connectDelayMax ?: kDefaultConnectDelayMaxSeconds;	×
137	_backoffMaxSeconds = backoffMax ?: kDefaultBackoffMaxSeconds;	×
138	_fatalHTTPStatusCodes = fatalCodes ?: @[ @302, @400, @401, @403, @404 ];	×
139	}	×
140	return self;	×
141	}	×
142
143	- (instancetype)initWithProject:(NSString *)project
144	entity:(NSString *)entity
145	apiKey:(NSString *)apiKey
146	sessionConfiguration:(NSURLSessionConfiguration *)sessionConfiguration
147	messageHandler:(SNTSyncFCMMessageHandler)messageHandler {	×
148	return [self initWithProject:project	×
149	entity:entity	×
150	apiKey:apiKey	×
151	connectDelayMax:0	×
152	backoffMax:0	×
153	fatalCodes:nil	×
154	sessionConfiguration:sessionConfiguration	×
155	messageHandler:messageHandler];	×
156	}	×
157
158	- (instancetype)initWithProject:(NSString *)project
159	entity:(NSString *)entity
160	apiKey:(NSString *)apiKey
161	messageHandler:(SNTSyncFCMMessageHandler)messageHandler {	×
162	return [self initWithProject:project	×
163	entity:entity	×
164	apiKey:apiKey	×
165	connectDelayMax:0	×
166	backoffMax:0	×
167	fatalCodes:nil	×
168	sessionConfiguration:nil	×
169	messageHandler:messageHandler];	×
170	}	×
171
172	#pragma mark property methods
173
174	- (BOOL)isConnected {	×
175	if (!self.androidID \|\| !self.securityToken) return NO;	×
176	for (NSURLSessionDataTask *dataTask in [self dataTasks]) {	×
177	if (dataTask.state == NSURLSessionTaskStateRunning) return YES;	×
178	}	×
179	return NO;	×
180	}	×
181
182	#pragma mark reachability methods
183
184	- (void)reachabilityRestored {	×
185	LOGD(@"Reachability restored. Reconnect after a backoff of %i seconds", _backoffSeconds);	×
186	[self stopReachability];	×
187	dispatch_time_t t = dispatch_time(DISPATCH_TIME_NOW, _backoffSeconds * NSEC_PER_SEC);	×
188	dispatch_after(t, dispatch_get_main_queue(), ^{	×
189	[self connectHelper];	×
190	});	×
191	}	×
192
193	/** Start listening for network state changes on a background thread. */
194	- (void)startReachability {	×
NEW 195	if (self.pathMonitor) return;	×
NEW 196	self.pathMonitor = nw_path_monitor_create();	×
NEW 197	nw_path_monitor_set_queue(self.pathMonitor, dispatch_get_main_queue());	×
NEW 198	nw_path_monitor_set_update_handler(self.pathMonitor, ^(nw_path_t path) {	×
NEW 199	if (nw_path_get_status(path) == nw_path_status_satisfied) {	×
NEW 200	SEL s = @selector(reachabilityRestored);	×
NEW 201	[NSObject cancelPreviousPerformRequestsWithTarget:self selector:s object:nil];	×
NEW 202	[self performSelector:s withObject:nil afterDelay:1];	×
NEW 203	}	×
NEW 204	});	×
NEW 205	nw_path_monitor_set_cancel_handler(self.pathMonitor, ^{	×
NEW 206	self.pathMonitor = nil;	×
NEW 207	});	×
NEW 208	nw_path_monitor_start(self.pathMonitor);	×
209	LOGD(@"Reachability started.");	×
210	}	×
211
212	/** Stop listening for network state changes. */
213	- (void)stopReachability {	×
NEW 214	if (!self.pathMonitor) return;	×
NEW 215	nw_path_monitor_cancel(self.pathMonitor);	×
UNCOV 216	}	×
217
218	#pragma mark message methods
219
220	- (void)connect {	×
221	uint32_t ms = arc4random_uniform(_connectDelayMaxSeconds * 1000);	×
222	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, ms * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{	×
223	[self connectHelper];	×
224	});	×
225	}	×
226
227	- (void)connectHelper {	×
228	LOGD(@"Connecting...");	×
229	[self cancelConnections];	×
230
231	// Reuse checkin credentials / FCM token if allready registered.
232	if (!self.androidID \|\| !self.securityToken) return [self checkin];	×
233
234	NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_connectComponents.URL];	×
235	[URLRequest addValue:kFCMApplicationJSON forHTTPHeaderField:kFCMContentType];	×
236	URLRequest.HTTPMethod = @"GET";	×
237	[self setCheckinAuthorization:URLRequest];	×
238	[[_session dataTaskWithRequest:URLRequest] resume];	×
239	}	×
240
241	- (void)checkin {	×
242	NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_checkinComponents.URL];	×
243	[URLRequest addValue:kFCMApplicationJSON forHTTPHeaderField:kFCMContentType];	×
244	URLRequest.HTTPMethod = @"POST";	×
245	URLRequest.HTTPBody = [kFCMCheckinBody dataUsingEncoding:NSUTF8StringEncoding];	×
246	[[_session dataTaskWithRequest:URLRequest] resume];	×
247	}	×
248
249	- (void)checkinDataHandler:(NSData *)data {	×
250	id jo = [NSJSONSerialization JSONObjectWithData:data options:0 error:NULL];	×
251	LOGD(@"checkin: %@", jo);	×
252	NSDictionary *checkin = [self extractCheckinFrom:jo];	×
253	if (!checkin) return;	×
254	self.androidID = [(NSNumber *)checkin[kAndroidIDKey] stringValue];	×
255	self.versionInfo = checkin[kVersionInfoKey];	×
256	self.securityToken = [(NSNumber *)checkin[kSecurityTokenKey] stringValue];	×
257	}	×
258
259	- (NSDictionary *)extractCheckinFrom:(id)jo {	×
260	if (!jo) return nil;	×
261	if (![jo isKindOfClass:[NSDictionary class]]) return nil;	×
262	if (!jo[kAndroidIDKey]) return nil;	×
263	if (![jo[kAndroidIDKey] isKindOfClass:[NSNumber class]]) return nil;	×
264	if (!jo[kVersionInfoKey]) return nil;	×
265	if (![jo[kVersionInfoKey] isKindOfClass:[NSString class]]) return nil;	×
266	if (!jo[kSecurityTokenKey]) return nil;	×
267	if (![jo[kSecurityTokenKey] isKindOfClass:[NSNumber class]]) return nil;	×
268	return jo;	×
269	}	×
270
271	- (void)register {	×
272	NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_registerComponents.URL];	×
273	URLRequest.HTTPMethod = @"POST";	×
274	URLRequest.HTTPBody = [kFCMCheckinBody dataUsingEncoding:NSUTF8StringEncoding];	×
275	NSURLComponents *params = [[NSURLComponents alloc] init];	×
276	params.queryItems = @[	×
277	[NSURLQueryItem queryItemWithName:@"app" value:self.project],	×
278	[NSURLQueryItem queryItemWithName:@"info" value:self.versionInfo],	×
279	[NSURLQueryItem queryItemWithName:@"sender" value:self.entity],	×
280	[NSURLQueryItem queryItemWithName:@"device" value:self.androidID],	×
281	[NSURLQueryItem queryItemWithName:@"X-scope" value:@"*"],	×
282	];	×
283	URLRequest.HTTPBody = [params.query dataUsingEncoding:NSUTF8StringEncoding];	×
284	[URLRequest addValue:kFCMApplicationForm forHTTPHeaderField:kFCMContentType];	×
285	NSString *aid = [NSString stringWithFormat:@"AidLogin %@:%@", self.androidID, self.securityToken];	×
286	[URLRequest addValue:aid forHTTPHeaderField:@"Authorization"];	×
287	[[_session dataTaskWithRequest:URLRequest] resume];	×
288	}	×
289
290	- (void)registerDataHandler:(NSData *)data {	×
291	NSString *t = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];	×
292	NSArray *c = [t componentsSeparatedByString:@"="];	×
293	if (c.count == 2) {	×
294	NSString *tok = c[1];	×
295	if ([tok isEqualToString:@"PHONE_REGISTRATION_ERROR"]) {	×
296	LOGD(@"register: PHONE_REGISTRATION_ERROR - retrying");	×
297	sleep(1);	×
298	return [self register];	×
299	}	×
300	if (self.tokenHandler) self.tokenHandler(tok);	×
301	}	×
302	}	×
303
304	- (void)acknowledgeMessage:(NSDictionary *)message {	×
305	if (!message[@"messageId"]) return;	×
306	NSMutableURLRequest *URLRequest = [NSMutableURLRequest requestWithURL:_ackComponents.URL];	×
307	URLRequest.HTTPMethod = @"POST";	×
308	[URLRequest addValue:kFCMApplicationJSON forHTTPHeaderField:kFCMContentType];	×
309	[self setCheckinAuthorization:URLRequest];	×
310	NSDictionary *b = @{@"ack" : @{@"messageId" : message[@"messageId"]}};	×
311	NSData *body = [NSJSONSerialization dataWithJSONObject:b options:0 error:NULL];	×
312	URLRequest.HTTPBody = body;	×
313	[[_session dataTaskWithRequest:URLRequest	×
314	completionHandler:^(NSData data, NSURLResponse response, NSError *error) {	×
315	if (((NSHTTPURLResponse *)response).statusCode != 200) {	×
316	if (self.acknowledgeErrorHandler) {	×
317	self.acknowledgeErrorHandler(message, error);	×
318	}	×
319	}	×
320	}] resume];	×
321	}	×
322
323	- (void)disconnect {	×
324	[self stopReachability];	×
325	[_session invalidateAndCancel];	×
326	_session = nil;	×
327	}	×
328
329	- (void)cancelConnections {	×
330	for (NSURLSessionDataTask *dataTask in [self dataTasks]) {	×
331	[dataTask cancel];	×
332	}	×
333	}	×
334
335	- (NSArray<NSURLSessionDataTask > )dataTasks {	×
336	__block NSArray *dataTasks;	×
337	dispatch_semaphore_t sema = dispatch_semaphore_create(0);	×
338	[_session getTasksWithCompletionHandler:^(NSArray data, NSArray upload, NSArray *download) {	×
339	dataTasks = data;	×
340	dispatch_semaphore_signal(sema);	×
341	}];	×
342	dispatch_semaphore_wait(sema, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC));	×
343	return dataTasks;	×
344	}	×
345
346	/**
347	* Parse FCM data; extract and call self.messageHandler for each message.
348	*
349	* Expected format:
350	* [{
351	* "noOp": {}
352	* }
353	* , <-- start of new chunk
354	* {
355	* "noOp": {}
356	* }
357	*
358	*/
359	- (void)processMessagesFromData:(NSData *)data {	×
360	if (!data) return;	×
361	NSMutableString *raw = [[NSMutableString alloc] initWithData:data encoding:NSUTF8StringEncoding];	×
362	if (raw.length < 2) return;	×
363	// Add an opening bracket if this is a message in the middle of the stream.
364	[raw replaceOccurrencesOfString:@",\r" withString:@"[" options:0 range:NSMakeRange(0, 2)];	×
365	// Always add a closing bracket.
366	[raw appendString:@"]"];	×
367	NSError *err;	×
368	id jo = [NSJSONSerialization JSONObjectWithData:[raw dataUsingEncoding:NSUTF8StringEncoding]	×
369	options:0	×
370	error:&err];	×
371	if (!jo) {	×
372	if (err) LOGD(@"processMessagesFromData err: %@", err);	×
373	return;	×
374	}	×
375	LOGD(@"processMessagesFromData: %@", jo);	×
376
377	if (![jo isKindOfClass:[NSArray class]]) return;	×
378	for (id md in jo) {	×
379	if (![md isKindOfClass:[NSDictionary class]]) continue;	×
380	NSDictionary *m = md[@"message"];	×
381	if ([m isKindOfClass:[NSDictionary class]]) self.messageHandler(m);	×
382	}	×
383	}	×
384
385	- (void)handleHTTPReponse:(NSHTTPURLResponse )HTTPResponse error:(NSError )error {	×
386	if (HTTPResponse.statusCode == 200) {	×
387	_backoffSeconds = 0;	×
388	if ([HTTPResponse.URL.path isEqualToString:kFCMCheckin]) {	×
389	// If checkin was successful, start listening for messages and continue to register.
390	[self connectHelper];	×
391	return [self register];	×
392	} else if ([HTTPResponse.URL.path isEqualToString:kFCMConnect]) {	×
393	// connect will re-connect.
394	return [self connectHelper];	×
395	} // register may be called more than once, don't do anything in response.	×
396	} else if ([_fatalHTTPStatusCodes containsObject:@(HTTPResponse.statusCode)]) {	×
397	if (self.connectionErrorHandler) self.connectionErrorHandler(HTTPResponse, error);	×
398	} else {	×
399	// If no backoff is set, start out with 5 - 15 seconds.
400	// If a backoff is already set, double it, with a max of kBackoffMaxSeconds.
401	_backoffSeconds = _backoffSeconds * 2 ?: arc4random_uniform(11) + 5;	×
402	if (_backoffSeconds > _backoffMaxSeconds) _backoffSeconds = _backoffMaxSeconds;	×
403	if (error) LOGD(@"handleHTTPReponse err: %@", error);	×
404	[self startReachability];	×
405	}	×
406	}	×
407
408	- (void)setCheckinAuthorization:(NSMutableURLRequest *)URLRequest {	×
409	NSString *a = [NSString	×
410	stringWithFormat:@"checkin %@:%@ %@", self.androidID, self.securityToken, self.versionInfo];	×
411	[URLRequest addValue:a forHTTPHeaderField:@"Authorization"];	×
412	[URLRequest addValue:self.apiKey forHTTPHeaderField:@"X-Goog-Api-Key"];	×
413	}	×
414
415	#pragma mark NSURLSession block property and methods
416
417	/**
418	* MOLAuthenticatingURLSession is the NSURLSessionDelegate. It will call this block every time
419	* the URLSession:task:didCompleteWithError: is called. This allows MOLFCMClient to be notified
420	* when a task ends while using delegate methods.
421	*/
422	- (void (^)(NSURLSession , NSURLSessionDataTask , NSData *))dataTaskDidReceiveDataBlock {	×
423	__weak __typeof(self) weakSelf = self;	×
424	return ^(NSURLSession session, NSURLSessionDataTask dataTask, NSData *data) {	×
425	__typeof(self) strongSelf = weakSelf;	×
426	NSString *path = dataTask.originalRequest.URL.path;	×
427	if ([path isEqualToString:kFCMCheckin]) {	×
428	return [strongSelf checkinDataHandler:data];	×
429	} else if ([path isEqualToString:kFCMRegister]) {	×
430	return [strongSelf registerDataHandler:data];	×
431	} else if ([dataTask.originalRequest.URL.path isEqualToString:kFCMConnect]) {	×
432	[strongSelf processMessagesFromData:data];	×
433	}	×
434	};	×
435	}	×
436
437	/**
438	* MOLAuthenticatingURLSession is the NSURLSessionDataDelegate. It will call this block every time
439	* the URLSession:dataTask:didReceiveData: is called. This allows for message data chunks to be
440	* processed as they appear in the FCM buffer. For Content-Type: text/html there is a 512 byte
441	* buffer that must be filled before data is returned. Content-Type: application/json does not use
442	* a buffer and data is returned as soon as it is available.
443	*
444	* TODO:(bur) Follow up with FCM on Content-Type: application/json. Currently FCM returns data with
445	* Content-Type: text/html. Messages under 512 bytes will not be processed until the connection
446	* drains.
447	*/
448	- (void (^)(NSURLSession , NSURLSessionTask , NSError *))taskDidCompleteWithErrorBlock {	×
449	__weak __typeof(self) weakSelf = self;	×
450	return ^(NSURLSession session, NSURLSessionTask task, NSError *error) {	×
451	__typeof(self) strongSelf = weakSelf;	×
452	// task.response can be nil when an NSURLError* occurs
453	if (task.response && ![task.response isKindOfClass:[NSHTTPURLResponse class]]) {	×
454	if (strongSelf.connectionErrorHandler) strongSelf.connectionErrorHandler(nil, error);	×
455	return;	×
456	}	×
457	NSHTTPURLResponse HTTPResponse = (NSHTTPURLResponse )task.response;	×
458	[strongSelf handleHTTPReponse:HTTPResponse error:error];	×
459	};	×
460	}	×
461
462	@end

google / santa / 10182571597

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous