iOS/Pods/FirebaseMessaging/Firebase/Messaging/FIRMessagingClient.m

   1 /*
   2  * Copyright 2017 Google
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #import "FIRMessagingClient.h"
  18
  19 #import <GoogleUtilities/GULReachabilityChecker.h>
  20
  21 #import "FIRMessaging.h"
  22 #import "FIRMessagingConnection.h"
  23 #import "FIRMessagingConstants.h"
  24 #import "FIRMessagingDataMessageManager.h"
  25 #import "FIRMessagingDefines.h"
  26 #import "FIRMessagingLogger.h"
  27 #import "FIRMessagingRegistrar.h"
  28 #import "FIRMessagingRmqManager.h"
  29 #import "FIRMessagingTopicsCommon.h"
  30 #import "FIRMessagingUtilities.h"
  31 #import "NSError+FIRMessaging.h"
  32
  33 static const NSTimeInterval kConnectTimeoutInterval = 40.0;
  34 static const NSTimeInterval kReconnectDelayInSeconds = 2 * 60; // 2 minutes
  35
  36 static const NSUInteger kMaxRetryExponent = 10;  // 2^10 = 1024 seconds ~= 17 minutes
  37
  38 static NSString *const kFIRMessagingMCSServerHost = @"mtalk.google.com";
  39 static NSUInteger const kFIRMessagingMCSServerPort = 5228;
  40
  41 // register device with checkin
  42 typedef void(^FIRMessagingRegisterDeviceHandler)(NSError *error);
  43
  44 static NSString *FIRMessagingServerHost() {
  45   static NSString *serverHost = nil;
  46   static dispatch_once_t onceToken;
  47   dispatch_once(&onceToken, ^{
  48     NSDictionary *environment = [[NSProcessInfo processInfo] environment];
  49     NSString *customServerHostAndPort = environment[@"FCM_MCS_HOST"];
  50     NSString *host = [customServerHostAndPort componentsSeparatedByString:@":"].firstObject;
  51     if (host) {
  52       serverHost = host;
  53     } else {
  54       serverHost = kFIRMessagingMCSServerHost;
  55     }
  56   });
  57   return serverHost;
  58 }
  59
  60 static NSUInteger FIRMessagingServerPort() {
  61   static NSUInteger serverPort = kFIRMessagingMCSServerPort;
  62   static dispatch_once_t onceToken;
  63   dispatch_once(&onceToken, ^{
  64     NSDictionary *environment = [[NSProcessInfo processInfo] environment];
  65     NSString *customServerHostAndPort = environment[@"FCM_MCS_HOST"];
  66     NSArray<NSString *> *components = [customServerHostAndPort componentsSeparatedByString:@":"];
  67     NSUInteger port = (NSUInteger)[components.lastObject integerValue];
  68     if (port != 0) {
  69       serverPort = port;
  70     }
  71   });
  72   return serverPort;
  73 }
  74
  75 @interface FIRMessagingClient () <FIRMessagingConnectionDelegate>
  76
  77 @property(nonatomic, readwrite, weak) id<FIRMessagingClientDelegate> clientDelegate;
  78 @property(nonatomic, readwrite, strong) FIRMessagingConnection *connection;
  79 @property(nonatomic, readwrite, strong) FIRMessagingRegistrar *registrar;
  80
  81 @property(nonatomic, readwrite, strong) NSString *senderId;
  82
  83 // FIRMessagingService owns these instances
  84 @property(nonatomic, readwrite, weak) FIRMessagingRmqManager *rmq2Manager;
  85 @property(nonatomic, readwrite, weak) GULReachabilityChecker *reachability;
  86
  87 @property(nonatomic, readwrite, assign) int64_t lastConnectedTimestamp;
  88 @property(nonatomic, readwrite, assign) int64_t lastDisconnectedTimestamp;
  89 @property(nonatomic, readwrite, assign) NSUInteger connectRetryCount;
  90
  91 // Should we stay connected to MCS or not. Should be YES throughout the lifetime
  92 // of a MCS connection. If set to NO it signifies that an existing MCS connection
  93 // should be disconnected.
  94 @property(nonatomic, readwrite, assign) BOOL stayConnected;
  95 @property(nonatomic, readwrite, assign) NSTimeInterval connectionTimeoutInterval;
  96
  97 // Used if the MCS connection suddenly breaksdown in the middle and we want to reconnect
  98 // with some permissible delay we schedule a reconnect and set it to YES and when it's
  99 // scheduled this will be set back to NO.
 100 @property(nonatomic, readwrite, assign) BOOL didScheduleReconnect;
 101
 102 // handlers
 103 @property(nonatomic, readwrite, copy) FIRMessagingConnectCompletionHandler connectHandler;
 104
 105 @end
 106
 107 @implementation FIRMessagingClient
 108
 109 - (instancetype)init {
 110   FIRMessagingInvalidateInitializer();
 111 }
 112
 113 - (instancetype)initWithDelegate:(id<FIRMessagingClientDelegate>)delegate
 114                     reachability:(GULReachabilityChecker *)reachability
 115                      rmq2Manager:(FIRMessagingRmqManager *)rmq2Manager {
 116   self = [super init];
 117   if (self) {
 118     _reachability = reachability;
 119     _clientDelegate = delegate;
 120     _rmq2Manager = rmq2Manager;
 121     _registrar = [[FIRMessagingRegistrar alloc] init];
 122     _connectionTimeoutInterval = kConnectTimeoutInterval;
 123     // Listen for checkin fetch notifications, as connecting to MCS may have failed due to
 124     // missing checkin info (while it was being fetched).
 125     [[NSNotificationCenter defaultCenter] addObserver:self
 126                                              selector:@selector(checkinFetched:)
 127                                                  name:kFIRMessagingCheckinFetchedNotification
 128                                                object:nil];
 129   }
 130   return self;
 131 }
 132
 133 - (void)teardown {
 134   FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient000, @"");
 135   self.stayConnected = NO;
 136
 137   // Clear all the handlers
 138   self.connectHandler = nil;
 139
 140   [self.connection teardown];
 141
 142   // Stop all subscription requests
 143   [self.registrar cancelAllRequests];
 144
 145   _FIRMessagingDevAssert(self.connection.state == kFIRMessagingConnectionNotConnected, @"Did not disconnect");
 146   [NSObject cancelPreviousPerformRequestsWithTarget:self];
 147
 148   [[NSNotificationCenter defaultCenter] removeObserver:self];
 149 }
 150
 151 - (void)cancelAllRequests {
 152   // Stop any checkin requests or any subscription requests
 153   [self.registrar cancelAllRequests];
 154
 155   // Stop any future connection requests to MCS
 156   if (self.stayConnected && self.isConnected && !self.isConnectionActive) {
 157     self.stayConnected = NO;
 158     [NSObject cancelPreviousPerformRequestsWithTarget:self];
 159   }
 160 }
 161
 162 #pragma mark - FIRMessaging subscribe
 163
 164 - (void)updateSubscriptionWithToken:(NSString *)token
 165                               topic:(NSString *)topic
 166                             options:(NSDictionary *)options
 167                        shouldDelete:(BOOL)shouldDelete
 168                             handler:(FIRMessagingTopicOperationCompletion)handler {
 169
 170   _FIRMessagingDevAssert(handler != nil, @"Invalid handler to FIRMessaging subscribe");
 171
 172   FIRMessagingTopicOperationCompletion completion = ^void(NSError *error) {
 173     if (error) {
 174       FIRMessagingLoggerError(kFIRMessagingMessageCodeClient001, @"Failed to subscribe to topic %@",
 175                               error);
 176     } else {
 177       if (shouldDelete) {
 178         FIRMessagingLoggerInfo(kFIRMessagingMessageCodeClient002,
 179                                @"Successfully unsubscribed from topic %@", topic);
 180       } else {
 181         FIRMessagingLoggerInfo(kFIRMessagingMessageCodeClient003,
 182                                @"Successfully subscribed to topic %@", topic);
 183       }
 184     }
 185     handler(error);
 186   };
 187
 188   [self.registrar updateSubscriptionToTopic:topic
 189                                   withToken:token
 190                                     options:options
 191                                shouldDelete:shouldDelete
 192                                     handler:completion];
 193 }
 194
 195 #pragma mark - MCS Connection
 196
 197 - (BOOL)isConnected {
 198   return self.stayConnected && self.connection.state != kFIRMessagingConnectionNotConnected;
 199 }
 200
 201 - (BOOL)isConnectionActive {
 202   return self.stayConnected && self.connection.state == kFIRMessagingConnectionSignedIn;
 203 }
 204
 205 - (BOOL)shouldStayConnected {
 206   return self.stayConnected;
 207 }
 208
 209 - (void)retryConnectionImmediately:(BOOL)immediately {
 210   // Do not connect to an invalid host or an invalid port
 211   if (!self.stayConnected || !self.connection.host || self.connection.port == 0) {
 212     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient004,
 213                             @"FIRMessaging connection will not reconnect to MCS. "
 214                             @"Stay connected: %d",
 215                             self.stayConnected);
 216     return;
 217   }
 218   if (self.isConnectionActive) {
 219     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient005,
 220                             @"FIRMessaging Connection skip retry, active");
 221     // already connected and logged in.
 222     // Heartbeat alarm is set and will force close the connection
 223     return;
 224   }
 225   if (self.isConnected) {
 226     // already connected and logged in.
 227     // Heartbeat alarm is set and will force close the connection
 228     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient006,
 229                             @"FIRMessaging Connection skip retry, connected");
 230     return;
 231   }
 232
 233   if (immediately) {
 234     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient007,
 235                             @"Try to connect to MCS immediately");
 236     [self tryToConnect];
 237   } else {
 238     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient008, @"Try to connect to MCS lazily");
 239     // Avoid all the other logic that we have in other clients, since this would always happen
 240     // when the app is in the foreground and since the FIRMessaging connection isn't shared with any other
 241     // app we can be more aggressive in reconnections
 242     if (!self.didScheduleReconnect) {
 243       FIRMessaging_WEAKIFY(self);
 244       dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
 245                                    (int64_t)(kReconnectDelayInSeconds * NSEC_PER_SEC)),
 246                      dispatch_get_main_queue(), ^{
 247                          FIRMessaging_STRONGIFY(self);
 248                          self.didScheduleReconnect = NO;
 249                          [self tryToConnect];
 250                      });
 251
 252       self.didScheduleReconnect = YES;
 253     }
 254   }
 255 }
 256
 257 - (void)connectWithHandler:(FIRMessagingConnectCompletionHandler)handler {
 258   if (self.isConnected) {
 259     NSError *error = [NSError fcm_errorWithCode:kFIRMessagingErrorCodeAlreadyConnected
 260                                        userInfo:@{
 261         NSLocalizedFailureReasonErrorKey: @"FIRMessaging is already connected",
 262         }];
 263     handler(error);
 264     return;
 265   }
 266   self.lastDisconnectedTimestamp = FIRMessagingCurrentTimestampInMilliseconds();
 267   self.connectHandler = handler;
 268   [self connect];
 269 }
 270
 271 - (void)connect {
 272   // reset retry counts
 273   self.connectRetryCount = 0;
 274
 275   if (self.isConnected) {
 276     return;
 277   }
 278
 279   self.stayConnected = YES;
 280   if (![self.registrar tryToLoadValidCheckinInfo]) {
 281     // Checkin info is not available. This may be due to the checkin still being fetched.
 282     if (self.connectHandler) {
 283       NSError *error = [NSError errorWithFCMErrorCode:kFIRMessagingErrorCodeMissingDeviceID];
 284       self.connectHandler(error);
 285     }
 286     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient009,
 287                             @"Failed to connect to MCS. No deviceID and secret found.");
 288     // Return for now. If checkin is, in fact, retrieved, the
 289     // |kFIRMessagingCheckinFetchedNotification| will be fired.
 290     return;
 291   }
 292   [self setupConnectionAndConnect];
 293 }
 294
 295 - (void)disconnect {
 296   // user called disconnect
 297   // We don't want to connect later even if no network is available.
 298   [self disconnectWithTryToConnectLater:NO];
 299 }
 300
 301 /**
 302  *  Disconnect the current client connection. Also explicitly stop and connction retries.
 303  *
 304  *  @param tryToConnectLater If YES will try to connect later when sending upstream messages
 305  *                           else if NO do not connect again until user explicitly calls
 306  *                           connect.
 307  */
 308 - (void)disconnectWithTryToConnectLater:(BOOL)tryToConnectLater {
 309
 310   self.stayConnected = tryToConnectLater;
 311   [self.connection signOut];
 312   _FIRMessagingDevAssert(self.connection.state == kFIRMessagingConnectionNotConnected,
 313                 @"FIRMessaging connection did not disconnect");
 314
 315   // since we can disconnect while still trying to establish the connection it's required to
 316   // cancel all performSelectors else the object might be retained
 317   [NSObject cancelPreviousPerformRequestsWithTarget:self
 318                                            selector:@selector(tryToConnect)
 319                                              object:nil];
 320   [NSObject cancelPreviousPerformRequestsWithTarget:self
 321                                            selector:@selector(didConnectTimeout)
 322                                              object:nil];
 323   self.connectHandler = nil;
 324 }
 325
 326 #pragma mark - Checkin Notification
 327 - (void)checkinFetched:(NSNotification *)notification {
 328   // A failed checkin may have been the reason for the connection failure. Attempt a connection
 329   // if the checkin fetched notification is fired.
 330   if (self.stayConnected && !self.isConnected) {
 331     [self connect];
 332   }
 333 }
 334
 335 #pragma mark - Messages
 336
 337 - (void)sendMessage:(GPBMessage *)message {
 338   [self.connection sendProto:message];
 339 }
 340
 341 - (void)sendOnConnectOrDrop:(GPBMessage *)message {
 342   [self.connection sendOnConnectOrDrop:message];
 343 }
 344
 345 #pragma mark - FIRMessagingConnectionDelegate
 346
 347 - (void)connection:(FIRMessagingConnection *)fcmConnection
 348     didCloseForReason:(FIRMessagingConnectionCloseReason)reason {
 349
 350   self.lastDisconnectedTimestamp = FIRMessagingCurrentTimestampInMilliseconds();
 351
 352   if (reason == kFIRMessagingConnectionCloseReasonSocketDisconnected) {
 353     // Cancel the not-yet-triggered timeout task before rescheduling, in case the previous sign in
 354     // failed, due to a connection error caused by bad network.
 355     [NSObject cancelPreviousPerformRequestsWithTarget:self
 356                                              selector:@selector(didConnectTimeout)
 357                                                object:nil];
 358   }
 359   if (self.stayConnected) {
 360     [self scheduleConnectRetry];
 361   }
 362 }
 363
 364 - (void)didLoginWithConnection:(FIRMessagingConnection *)fcmConnection {
 365   // Cancel the not-yet-triggered timeout task.
 366   [NSObject cancelPreviousPerformRequestsWithTarget:self
 367                                            selector:@selector(didConnectTimeout)
 368                                              object:nil];
 369   self.connectRetryCount = 0;
 370   self.lastConnectedTimestamp = FIRMessagingCurrentTimestampInMilliseconds();
 371
 372
 373   [self.dataMessageManager setDeviceAuthID:self.registrar.deviceAuthID
 374                                secretToken:self.registrar.secretToken];
 375   if (self.connectHandler) {
 376     self.connectHandler(nil);
 377     // notified the third party app with the registrationId.
 378     // we don't want them to know about the connection status and how it changes
 379     // so remove this handler
 380     self.connectHandler = nil;
 381   }
 382 }
 383
 384 - (void)connectionDidRecieveMessage:(GtalkDataMessageStanza *)message {
 385   NSDictionary *parsedMessage = [self.dataMessageManager processPacket:message];
 386   if ([parsedMessage count]) {
 387     [self.dataMessageManager didReceiveParsedMessage:parsedMessage];
 388   }
 389 }
 390
 391 - (int)connectionDidReceiveAckForRmqIds:(NSArray *)rmqIds {
 392   NSSet *rmqIDSet = [NSSet setWithArray:rmqIds];
 393   NSMutableArray *messagesSent = [NSMutableArray arrayWithCapacity:rmqIds.count];
 394   [self.rmq2Manager scanWithRmqMessageHandler:nil
 395                            dataMessageHandler:^(int64_t rmqId, GtalkDataMessageStanza *stanza) {
 396                              NSString *rmqIdString = [NSString stringWithFormat:@"%lld", rmqId];
 397                              if ([rmqIDSet containsObject:rmqIdString]) {
 398                                [messagesSent addObject:stanza];
 399                              }
 400                            }];
 401   for (GtalkDataMessageStanza *message in messagesSent) {
 402     [self.dataMessageManager didSendDataMessageStanza:message];
 403   }
 404   return [self.rmq2Manager removeRmqMessagesWithRmqIds:rmqIds];
 405 }
 406
 407 #pragma mark - Private
 408
 409 - (void)setupConnectionAndConnect {
 410   [self setupConnection];
 411   [self tryToConnect];
 412 }
 413
 414 - (void)setupConnection {
 415   NSString *host = FIRMessagingServerHost();
 416   NSUInteger port = FIRMessagingServerPort();
 417   _FIRMessagingDevAssert([host length] > 0 && port != 0, @"Invalid port or host");
 418
 419   if (self.connection != nil) {
 420     // if there is an old connection, explicitly sign it off.
 421     [self.connection signOut];
 422     self.connection.delegate = nil;
 423   }
 424   self.connection = [[FIRMessagingConnection alloc] initWithAuthID:self.registrar.deviceAuthID
 425                                                     token:self.registrar.secretToken
 426                                                      host:host
 427                                                      port:port
 428                                                   runLoop:[NSRunLoop mainRunLoop]
 429                                               rmq2Manager:self.rmq2Manager
 430                                                fcmManager:self.dataMessageManager];
 431   self.connection.delegate = self;
 432 }
 433
 434 - (void)tryToConnect {
 435   if (!self.stayConnected) {
 436     return;
 437   }
 438
 439   // Cancel any other pending signin requests.
 440   [NSObject cancelPreviousPerformRequestsWithTarget:self
 441                                            selector:@selector(tryToConnect)
 442                                              object:nil];
 443
 444   // Do not re-sign in if there is already a connection in progress.
 445   if (self.connection.state != kFIRMessagingConnectionNotConnected) {
 446     return;
 447   }
 448
 449   _FIRMessagingDevAssert(self.registrar.deviceAuthID.length > 0 &&
 450                  self.registrar.secretToken.length > 0 &&
 451                  self.connection != nil,
 452                  @"Invalid state cannot connect");
 453
 454   self.connectRetryCount = MIN(kMaxRetryExponent, self.connectRetryCount + 1);
 455   [self performSelector:@selector(didConnectTimeout)
 456              withObject:nil
 457              afterDelay:self.connectionTimeoutInterval];
 458   [self.connection signIn];
 459 }
 460
 461 - (void)didConnectTimeout {
 462   _FIRMessagingDevAssert(self.connection.state != kFIRMessagingConnectionSignedIn,
 463                 @"Invalid state for MCS connection");
 464
 465   if (self.stayConnected) {
 466     [self.connection signOut];
 467     [self scheduleConnectRetry];
 468   }
 469 }
 470
 471 #pragma mark - Schedulers
 472
 473 - (void)scheduleConnectRetry {
 474   GULReachabilityStatus status = self.reachability.reachabilityStatus;
 475   BOOL isReachable = (status == kGULReachabilityViaWifi || status == kGULReachabilityViaCellular);
 476   if (!isReachable) {
 477     FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient010,
 478                             @"Internet not reachable when signing into MCS during a retry");
 479
 480     FIRMessagingConnectCompletionHandler handler = [self.connectHandler copy];
 481     // disconnect before issuing a callback
 482     [self disconnectWithTryToConnectLater:YES];
 483     NSError *error =
 484         [NSError errorWithDomain:@"No internet available, cannot connect to FIRMessaging"
 485                             code:kFIRMessagingErrorCodeNetwork
 486                         userInfo:nil];
 487     if (handler) {
 488       handler(error);
 489       self.connectHandler = nil;
 490     }
 491     return;
 492   }
 493
 494   NSUInteger retryInterval = [self nextRetryInterval];
 495
 496   FIRMessagingLoggerDebug(kFIRMessagingMessageCodeClient011,
 497                           @"Failed to sign in to MCS, retry in %lu seconds",
 498                           _FIRMessaging_UL(retryInterval));
 499   [self performSelector:@selector(tryToConnect) withObject:nil afterDelay:retryInterval];
 500 }
 501
 502 - (NSUInteger)nextRetryInterval {
 503   return 1u << self.connectRetryCount;
 504 }
 505
 506 @end