Reconnection Issue about objective-c HOT 11 CLOSED

- (void)pubnubClient:(PubNub *)client didDisconnectFromOrigin:(NSString *)origin withError:(PNError *)error {
    PNLog(PNLogGeneralLevel, self, @"PubNub client closed connection because of error: %@", error);
}

- (void)connectionChannel:(PNConnectionChannel *)channel didDisconnectFromOrigin:(NSString *)host {

    // Check whether host name arrived or not
    // (it may not arrive if event sending instance
    // was dismissed/deallocated)
    if (host == nil) {

        host = self.configuration.origin;
    }


    // Check whether received event from same host on which client
    // is configured or not and all communication channels are closed
    if([self.configuration.origin isEqualToString:host] &&
       ![self.messagingChannel isConnected] && ![self.serviceChannel isConnected]) {

        // Check whether all communication channels disconnected and whether
        // client in corresponding state or not
        if (self.state == PNPubNubClientStateDisconnecting ||
            self.state == PNPubNubClientStateDisconnectingOnNetworkError) {

            PNPubNubClientState state = PNPubNubClientStateDisconnected;
            if (self.state == PNPubNubClientStateDisconnectingOnNetworkError) {

                state = PNPubNubClientStateDisconnectedOnNetworkError;
            }
            self.state = state;

            SEL selectorForCheck = @selector(pubnubClient:didDisconnectFromOrigin:);
            if (state == PNPubNubClientStateDisconnectedOnNetworkError) {

                selectorForCheck = @selector(pubnubClient:didDisconnectFromOrigin:withError:);
            }
            if ([self.delegate respondsToSelector:selectorForCheck]) {

                if (self.state == PNPubNubClientStateDisconnected) {

                    [self.delegate pubnubClient:self didDisconnectFromOrigin:host];

                    [self sendNotification:kPNClientDidDisconnectFromOriginNotification withObject:host];
                }
                else {

                    PNError *connectionError = [PNError errorWithCode:kPNClientConnectionClosedOnInternetFailureError];

                    if ([self.delegate respondsToSelector:@selector(pubnubClient:didDisconnectFromOrigin:withError:)]) {

                        [self.delegate pubnubClient:self didDisconnectFromOrigin:host withError:connectionError];
                    }

                    [self sendNotification:kPNClientConnectionDidFailWithErrorNotification withObject:connectionError];


                    // Check whether error is caused by network error or not
                    switch (connectionError.code) {
                        case kPNClientConnectionFailedOnInternetFailureError:
                        case kPNClientConnectionClosedOnInternetFailureError:

                            // Try to refresh reachability state (there is situation when reachability state
                            // changed within library to handle sockets timeout/error)
                            [self.reachability refreshReachabilityState];
                            break;

                        default:
                            break;
                    }
                }
            }


            if(self.state == PNPubNubClientStateDisconnected) {

                // Clean up cached data
                [PNChannel purgeChannelsCache];
            }
            else {

                // Check whether service is available
                // (this event may arrive after device was unlocked
                // so basically connection is available and only
                // sockets closed by remote server or internal kernel
                // layer)
                if ([self.reachability isServiceReachabilityChecked] && [self.reachability isServiceAvailable]) {

                    // Check whether should restore connection or not
                    if ([self shouldRestoreConnection]) {

                        self.restoringConnection = YES;

                        // Try to restore connection to remote PubNub services
                        [[self class] connect];
                    }
                }
            }
        }
        // Check whether server unexpectedly closed connection
        // while client was active or not
        else if(self.state == PNPubNubClientStateConnected) {

            self.state = PNPubNubClientStateDisconnected;

            if([self shouldRestoreConnection]) {

                // Try to restore connection to remote PubNub services
                [[self class] connect];
            }
        }
        // Check whether connection has been closed because
        // PubNub client updates it's configuration
        else if (self.state == PNPubNubClientStateDisconnectingOnConfigurationChange) {

            // Close connection to PubNub services
            [[self class] disconnect];


            // Delay connection restore to give some time internal
            // components to complete their tasks
            int64_t delayInSeconds = 1;
            dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
            dispatch_after(popTime, dispatch_get_main_queue(), ^(void) {

                self.state = PNPubNubClientStateCreated;
                self.configuration = self.temporaryConfiguration;
                self.temporaryConfiguration = nil;

                [self prepareCryptoHelper];


                // Restore connection which will use new configuration
                [[self class] connect];
            });
        }
    }
}

 PNError *connectionError;
            PNPubNubClientState state = PNPubNubClientStateDisconnected;
            if (self.state == PNPubNubClientStateDisconnectingOnNetworkError) {
                state = PNPubNubClientStateDisconnectedOnNetworkError;
            }
            self.state = state;

            SEL selectorForCheck = @selector(pubnubClient:didDisconnectFromOrigin:);
            if (state == PNPubNubClientStateDisconnectedOnNetworkError) {

                selectorForCheck = @selector(pubnubClient:didDisconnectFromOrigin:withError:);
            }
            if ([self.delegate respondsToSelector:selectorForCheck]) {

                if (self.state == PNPubNubClientStateDisconnected) {

                    [self.delegate pubnubClient:self didDisconnectFromOrigin:host];

                    [self sendNotification:kPNClientDidDisconnectFromOriginNotification withObject:host];
                }
                else {

                    connectionError = [PNError errorWithCode:kPNClientConnectionClosedOnInternetFailureError];

                    [self.delegate pubnubClient:self didDisconnectFromOrigin:host withError:connectionError];

                    [self sendNotification:kPNClientConnectionDidFailWithErrorNotification withObject:connectionError];
                }
            }


            // Check whether error is caused by network error or not
            switch (connectionError.code) {
                case kPNClientConnectionFailedOnInternetFailureError:
                case kPNClientConnectionClosedOnInternetFailureError:

                    // Try to refresh reachability state (there is situation whem reachability state
                    // changed within library to handle sockets timeout/error)
                    [self.reachability refreshReachabilityState];
                    break;

                default:
                    break;
            }