mirror of
https://github.com/firebase/firebase-ios-sdk
synced 2026-11-11 22:55:59 +05:45
Ryan Wilson
19159a4b25
* Fix tvOS storage issues. On tvOS devices, the ApplicationSupport directory cannot be used. Unfortunately this doesn't come up in simulator testing, only on device. This hasn't been fully tested on device but given that any writes to the ApplicationSupport directory fail on tvOS, this change can't break much. Fixes #6612 @defagos can you please give this a test? * Fixed changed dir name for RC * Fixed test naming, too. * Fix the documentation comment for GoogleUtilities. * Updated changelog. * Review feedback
767 lines
31 KiB
Objective-C
767 lines
31 KiB
Objective-C
// Copyright 2017 Google
|
|
//
|
|
// 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 <Foundation/Foundation.h>
|
|
|
|
#import "GoogleUtilities/Network/Public/GoogleUtilities/GULNetworkURLSession.h"
|
|
|
|
#import "GoogleUtilities/Logger/Public/GoogleUtilities/GULLogger.h"
|
|
#import "GoogleUtilities/Network/GULNetworkInternal.h"
|
|
#import "GoogleUtilities/Network/Public/GoogleUtilities/GULMutableDictionary.h"
|
|
#import "GoogleUtilities/Network/Public/GoogleUtilities/GULNetworkConstants.h"
|
|
#import "GoogleUtilities/Network/Public/GoogleUtilities/GULNetworkMessageCode.h"
|
|
|
|
@interface GULNetworkURLSession () <NSURLSessionDelegate,
|
|
NSURLSessionDataDelegate,
|
|
NSURLSessionDownloadDelegate,
|
|
NSURLSessionTaskDelegate>
|
|
@end
|
|
|
|
@implementation GULNetworkURLSession {
|
|
/// The handler to be called when the request completes or error has occurs.
|
|
GULNetworkURLSessionCompletionHandler _completionHandler;
|
|
|
|
/// Session ID generated randomly with a fixed prefix.
|
|
NSString *_sessionID;
|
|
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wunguarded-availability"
|
|
/// The session configuration. NSURLSessionConfiguration' is only available on iOS 7.0 or newer.
|
|
NSURLSessionConfiguration *_sessionConfig;
|
|
|
|
/// The current NSURLSession.
|
|
NSURLSession *__weak _Nullable _URLSession;
|
|
#pragma clang diagnostic pop
|
|
|
|
/// The path to the directory where all temporary files are stored before uploading.
|
|
NSURL *_networkDirectoryURL;
|
|
|
|
/// The downloaded data from fetching.
|
|
NSData *_downloadedData;
|
|
|
|
/// The path to the temporary file which stores the uploading data.
|
|
NSURL *_uploadingFileURL;
|
|
|
|
/// The current request.
|
|
NSURLRequest *_request;
|
|
}
|
|
|
|
#pragma mark - Init
|
|
|
|
- (instancetype)initWithNetworkLoggerDelegate:(id<GULNetworkLoggerDelegate>)networkLoggerDelegate {
|
|
self = [super init];
|
|
if (self) {
|
|
// Create URL to the directory where all temporary files to upload have to be stored.
|
|
#if TARGET_OS_TV
|
|
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
|
|
#else
|
|
NSArray *paths =
|
|
NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES);
|
|
#endif
|
|
NSString *storageDirectory = paths.firstObject;
|
|
NSArray *tempPathComponents = @[
|
|
storageDirectory, kGULNetworkApplicationSupportSubdirectory, kGULNetworkTempDirectoryName
|
|
];
|
|
_networkDirectoryURL = [NSURL fileURLWithPathComponents:tempPathComponents];
|
|
_sessionID = [NSString stringWithFormat:@"%@-%@", kGULNetworkBackgroundSessionConfigIDPrefix,
|
|
[[NSUUID UUID] UUIDString]];
|
|
_loggerDelegate = networkLoggerDelegate;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
#pragma mark - External Methods
|
|
|
|
#pragma mark - To be called from AppDelegate
|
|
|
|
+ (void)handleEventsForBackgroundURLSessionID:(NSString *)sessionID
|
|
completionHandler:
|
|
(GULNetworkSystemCompletionHandler)systemCompletionHandler {
|
|
// The session may not be Analytics background. Ignore those that do not have the prefix.
|
|
if (![sessionID hasPrefix:kGULNetworkBackgroundSessionConfigIDPrefix]) {
|
|
return;
|
|
}
|
|
GULNetworkURLSession *fetcher = [self fetcherWithSessionIdentifier:sessionID];
|
|
if (fetcher != nil) {
|
|
[fetcher addSystemCompletionHandler:systemCompletionHandler forSession:sessionID];
|
|
} else {
|
|
GULLogError(kGULLoggerNetwork, NO,
|
|
[NSString stringWithFormat:@"I-NET%06ld", (long)kGULNetworkMessageCodeNetwork003],
|
|
@"Failed to retrieve background session with ID %@ after app is relaunched.",
|
|
sessionID);
|
|
}
|
|
}
|
|
|
|
#pragma mark - External Methods
|
|
|
|
/// Sends an async POST request using NSURLSession for iOS >= 7.0, and returns an ID of the
|
|
/// connection.
|
|
- (nullable NSString *)sessionIDFromAsyncPOSTRequest:(NSURLRequest *)request
|
|
completionHandler:(GULNetworkURLSessionCompletionHandler)handler
|
|
API_AVAILABLE(ios(7.0)) {
|
|
// NSURLSessionUploadTask does not work with NSData in the background.
|
|
// To avoid this issue, write the data to a temporary file to upload it.
|
|
// Make a temporary file with the data subset.
|
|
_uploadingFileURL = [self temporaryFilePathWithSessionID:_sessionID];
|
|
NSError *writeError;
|
|
NSURLSessionUploadTask *postRequestTask;
|
|
NSURLSession *session;
|
|
BOOL didWriteFile = NO;
|
|
|
|
// Clean up the entire temp folder to avoid temp files that remain in case the previous session
|
|
// crashed and did not clean up.
|
|
[self maybeRemoveTempFilesAtURL:_networkDirectoryURL
|
|
expiringTime:kGULNetworkTempFolderExpireTime];
|
|
|
|
// If there is no background network enabled, no need to write to file. This will allow default
|
|
// network session which runs on the foreground.
|
|
if (_backgroundNetworkEnabled && [self ensureTemporaryDirectoryExists]) {
|
|
didWriteFile = [request.HTTPBody writeToFile:_uploadingFileURL.path
|
|
options:NSDataWritingAtomic
|
|
error:&writeError];
|
|
|
|
if (writeError) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession000
|
|
message:@"Failed to write request data to file"
|
|
context:writeError];
|
|
}
|
|
}
|
|
|
|
if (didWriteFile) {
|
|
// Exclude this file from backing up to iTunes. There are conflicting reports that excluding
|
|
// directory from backing up does not exclude files of that directory from backing up.
|
|
[self excludeFromBackupForURL:_uploadingFileURL];
|
|
|
|
_sessionConfig = [self backgroundSessionConfigWithSessionID:_sessionID];
|
|
[self populateSessionConfig:_sessionConfig withRequest:request];
|
|
session = [NSURLSession sessionWithConfiguration:_sessionConfig
|
|
delegate:self
|
|
delegateQueue:[NSOperationQueue mainQueue]];
|
|
postRequestTask = [session uploadTaskWithRequest:request fromFile:_uploadingFileURL];
|
|
} else {
|
|
// If we cannot write to file, just send it in the foreground.
|
|
_sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
|
|
[self populateSessionConfig:_sessionConfig withRequest:request];
|
|
session = [NSURLSession sessionWithConfiguration:_sessionConfig
|
|
delegate:self
|
|
delegateQueue:[NSOperationQueue mainQueue]];
|
|
postRequestTask = [session uploadTaskWithRequest:request fromData:request.HTTPBody];
|
|
}
|
|
|
|
if (!session || !postRequestTask) {
|
|
NSError *error = [[NSError alloc]
|
|
initWithDomain:kGULNetworkErrorDomain
|
|
code:GULErrorCodeNetworkRequestCreation
|
|
userInfo:@{kGULNetworkErrorContext : @"Cannot create network session"}];
|
|
[self callCompletionHandler:handler withResponse:nil data:nil error:error];
|
|
return nil;
|
|
}
|
|
|
|
_URLSession = session;
|
|
|
|
// Save the session into memory.
|
|
[[self class] setSessionInFetcherMap:self forSessionID:_sessionID];
|
|
|
|
_request = [request copy];
|
|
|
|
// Store completion handler because background session does not accept handler block but custom
|
|
// delegate.
|
|
_completionHandler = [handler copy];
|
|
[postRequestTask resume];
|
|
|
|
return _sessionID;
|
|
}
|
|
|
|
/// Sends an async GET request using NSURLSession for iOS >= 7.0, and returns an ID of the session.
|
|
- (nullable NSString *)sessionIDFromAsyncGETRequest:(NSURLRequest *)request
|
|
completionHandler:(GULNetworkURLSessionCompletionHandler)handler
|
|
API_AVAILABLE(ios(7.0)) {
|
|
if (_backgroundNetworkEnabled) {
|
|
_sessionConfig = [self backgroundSessionConfigWithSessionID:_sessionID];
|
|
} else {
|
|
_sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
|
|
}
|
|
|
|
[self populateSessionConfig:_sessionConfig withRequest:request];
|
|
|
|
// Do not cache the GET request.
|
|
_sessionConfig.URLCache = nil;
|
|
|
|
NSURLSession *session = [NSURLSession sessionWithConfiguration:_sessionConfig
|
|
delegate:self
|
|
delegateQueue:[NSOperationQueue mainQueue]];
|
|
NSURLSessionDownloadTask *downloadTask = [session downloadTaskWithRequest:request];
|
|
|
|
if (!session || !downloadTask) {
|
|
NSError *error = [[NSError alloc]
|
|
initWithDomain:kGULNetworkErrorDomain
|
|
code:GULErrorCodeNetworkRequestCreation
|
|
userInfo:@{kGULNetworkErrorContext : @"Cannot create network session"}];
|
|
[self callCompletionHandler:handler withResponse:nil data:nil error:error];
|
|
return nil;
|
|
}
|
|
|
|
_URLSession = session;
|
|
|
|
// Save the session into memory.
|
|
[[self class] setSessionInFetcherMap:self forSessionID:_sessionID];
|
|
|
|
_request = [request copy];
|
|
|
|
_completionHandler = [handler copy];
|
|
[downloadTask resume];
|
|
|
|
return _sessionID;
|
|
}
|
|
|
|
#pragma mark - NSURLSessionDataDelegate
|
|
|
|
/// Called by the NSURLSession when the data task has received some of the expected data.
|
|
/// Once the session is completed, URLSession:task:didCompleteWithError will be called and the
|
|
/// completion handler will be called with the downloaded data.
|
|
- (void)URLSession:(NSURLSession *)session
|
|
dataTask:(NSURLSessionDataTask *)dataTask
|
|
didReceiveData:(NSData *)data {
|
|
@synchronized(self) {
|
|
NSMutableData *mutableData = [[NSMutableData alloc] init];
|
|
if (_downloadedData) {
|
|
mutableData = _downloadedData.mutableCopy;
|
|
}
|
|
[mutableData appendData:data];
|
|
_downloadedData = mutableData;
|
|
}
|
|
}
|
|
|
|
#pragma mark - NSURLSessionTaskDelegate
|
|
|
|
/// Called by the NSURLSession once the download task is completed. The file is saved in the
|
|
/// provided URL so we need to read the data and store into _downloadedData. Once the session is
|
|
/// completed, URLSession:task:didCompleteWithError will be called and the completion handler will
|
|
/// be called with the downloaded data.
|
|
- (void)URLSession:(NSURLSession *)session
|
|
downloadTask:(NSURLSessionDownloadTask *)task
|
|
didFinishDownloadingToURL:(NSURL *)url API_AVAILABLE(ios(7.0)) {
|
|
if (!url.path) {
|
|
[_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession001
|
|
message:@"Unable to read downloaded data from empty temp path"];
|
|
_downloadedData = nil;
|
|
return;
|
|
}
|
|
|
|
NSError *error;
|
|
_downloadedData = [NSData dataWithContentsOfFile:url.path options:0 error:&error];
|
|
|
|
if (error) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession002
|
|
message:@"Cannot read the content of downloaded data"
|
|
context:error];
|
|
_downloadedData = nil;
|
|
}
|
|
}
|
|
|
|
#if TARGET_OS_IOS || TARGET_OS_TV
|
|
- (void)URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
|
|
API_AVAILABLE(ios(7.0)) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelDebug
|
|
messageCode:kGULNetworkMessageCodeURLSession003
|
|
message:@"Background session finished"
|
|
context:session.configuration.identifier];
|
|
[self callSystemCompletionHandler:session.configuration.identifier];
|
|
}
|
|
#endif
|
|
|
|
- (void)URLSession:(NSURLSession *)session
|
|
task:(NSURLSessionTask *)task
|
|
didCompleteWithError:(NSError *)error API_AVAILABLE(ios(7.0)) {
|
|
// Avoid any chance of recursive behavior leading to it being used repeatedly.
|
|
GULNetworkURLSessionCompletionHandler handler = _completionHandler;
|
|
_completionHandler = nil;
|
|
|
|
if (task.response) {
|
|
// The following assertion should always be true for HTTP requests, see https://goo.gl/gVLxT7.
|
|
NSAssert([task.response isKindOfClass:[NSHTTPURLResponse class]], @"URL response must be HTTP");
|
|
|
|
// The server responded so ignore the error created by the system.
|
|
error = nil;
|
|
} else if (!error) {
|
|
error = [[NSError alloc]
|
|
initWithDomain:kGULNetworkErrorDomain
|
|
code:GULErrorCodeNetworkInvalidResponse
|
|
userInfo:@{kGULNetworkErrorContext : @"Network Error: Empty network response"}];
|
|
}
|
|
|
|
[self callCompletionHandler:handler
|
|
withResponse:(NSHTTPURLResponse *)task.response
|
|
data:_downloadedData
|
|
error:error];
|
|
|
|
// Remove the temp file to avoid trashing devices with lots of temp files.
|
|
[self removeTempItemAtURL:_uploadingFileURL];
|
|
|
|
// Try to clean up stale files again.
|
|
[self maybeRemoveTempFilesAtURL:_networkDirectoryURL
|
|
expiringTime:kGULNetworkTempFolderExpireTime];
|
|
|
|
// This is called without checking the sessionID here since non-background sessions
|
|
// won't have an ID.
|
|
[session finishTasksAndInvalidate];
|
|
|
|
// Explicitly remove the session so it won't be reused. The weak map table should
|
|
// remove the session on deallocation, but dealloc may not happen immediately after
|
|
// calling `finishTasksAndInvalidate`.
|
|
NSString *sessionID = session.configuration.identifier;
|
|
[[self class] setSessionInFetcherMap:nil forSessionID:sessionID];
|
|
}
|
|
|
|
- (void)URLSession:(NSURLSession *)session
|
|
task:(NSURLSessionTask *)task
|
|
didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge
|
|
completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition,
|
|
NSURLCredential *credential))completionHandler
|
|
API_AVAILABLE(ios(7.0)) {
|
|
// The handling is modeled after GTMSessionFetcher.
|
|
if ([challenge.protectionSpace.authenticationMethod
|
|
isEqualToString:NSURLAuthenticationMethodServerTrust]) {
|
|
SecTrustRef serverTrust = challenge.protectionSpace.serverTrust;
|
|
if (serverTrust == NULL) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelDebug
|
|
messageCode:kGULNetworkMessageCodeURLSession004
|
|
message:@"Received empty server trust for host. Host"
|
|
context:_request.URL];
|
|
completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil);
|
|
return;
|
|
}
|
|
NSURLCredential *credential = [NSURLCredential credentialForTrust:serverTrust];
|
|
if (!credential) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelWarning
|
|
messageCode:kGULNetworkMessageCodeURLSession005
|
|
message:@"Unable to verify server identity. Host"
|
|
context:_request.URL];
|
|
completionHandler(NSURLSessionAuthChallengeCancelAuthenticationChallenge, nil);
|
|
return;
|
|
}
|
|
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelDebug
|
|
messageCode:kGULNetworkMessageCodeURLSession006
|
|
message:@"Received SSL challenge for host. Host"
|
|
context:_request.URL];
|
|
|
|
void (^callback)(BOOL) = ^(BOOL allow) {
|
|
if (allow) {
|
|
completionHandler(NSURLSessionAuthChallengeUseCredential, credential);
|
|
} else {
|
|
[self->_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelDebug
|
|
messageCode:kGULNetworkMessageCodeURLSession007
|
|
message:@"Cancelling authentication challenge for host. Host"
|
|
context:self->_request.URL];
|
|
completionHandler(NSURLSessionAuthChallengeCancelAuthenticationChallenge, nil);
|
|
}
|
|
};
|
|
|
|
// Retain the trust object to avoid a SecTrustEvaluate() crash on iOS 7.
|
|
CFRetain(serverTrust);
|
|
|
|
// Evaluate the certificate chain.
|
|
//
|
|
// The delegate queue may be the main thread. Trust evaluation could cause some
|
|
// blocking network activity, so we must evaluate async, as documented at
|
|
// https://developer.apple.com/library/ios/technotes/tn2232/
|
|
dispatch_queue_t evaluateBackgroundQueue =
|
|
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
|
|
|
|
dispatch_async(evaluateBackgroundQueue, ^{
|
|
SecTrustResultType trustEval = kSecTrustResultInvalid;
|
|
BOOL shouldAllow;
|
|
OSStatus trustError;
|
|
|
|
@synchronized([GULNetworkURLSession class]) {
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
|
trustError = SecTrustEvaluate(serverTrust, &trustEval);
|
|
#pragma clang dianostic pop
|
|
}
|
|
|
|
if (trustError != errSecSuccess) {
|
|
[self->_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession008
|
|
message:@"Cannot evaluate server trust. Error, host"
|
|
contexts:@[ @(trustError), self->_request.URL ]];
|
|
shouldAllow = NO;
|
|
} else {
|
|
// Having a trust level "unspecified" by the user is the usual result, described at
|
|
// https://developer.apple.com/library/mac/qa/qa1360
|
|
shouldAllow =
|
|
(trustEval == kSecTrustResultUnspecified || trustEval == kSecTrustResultProceed);
|
|
}
|
|
|
|
// Call the call back with the permission.
|
|
callback(shouldAllow);
|
|
|
|
CFRelease(serverTrust);
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Default handling for other Auth Challenges.
|
|
completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil);
|
|
}
|
|
|
|
#pragma mark - Internal Methods
|
|
|
|
/// Stores system completion handler with session ID as key.
|
|
- (void)addSystemCompletionHandler:(GULNetworkSystemCompletionHandler)handler
|
|
forSession:(NSString *)identifier {
|
|
if (!handler) {
|
|
[_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession009
|
|
message:@"Cannot store nil system completion handler in network"];
|
|
return;
|
|
}
|
|
|
|
if (!identifier.length) {
|
|
[_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession010
|
|
message:@"Cannot store system completion handler with empty network "
|
|
"session identifier"];
|
|
return;
|
|
}
|
|
|
|
GULMutableDictionary *systemCompletionHandlers =
|
|
[[self class] sessionIDToSystemCompletionHandlerDictionary];
|
|
if (systemCompletionHandlers[identifier]) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelWarning
|
|
messageCode:kGULNetworkMessageCodeURLSession011
|
|
message:@"Got multiple system handlers for a single session ID"
|
|
context:identifier];
|
|
}
|
|
|
|
systemCompletionHandlers[identifier] = handler;
|
|
}
|
|
|
|
/// Calls the system provided completion handler with the session ID stored in the dictionary.
|
|
/// The handler will be removed from the dictionary after being called.
|
|
- (void)callSystemCompletionHandler:(NSString *)identifier {
|
|
GULMutableDictionary *systemCompletionHandlers =
|
|
[[self class] sessionIDToSystemCompletionHandlerDictionary];
|
|
GULNetworkSystemCompletionHandler handler = [systemCompletionHandlers objectForKey:identifier];
|
|
|
|
if (handler) {
|
|
[systemCompletionHandlers removeObjectForKey:identifier];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
handler();
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Sets or updates the session ID of this session.
|
|
- (void)setSessionID:(NSString *)sessionID {
|
|
_sessionID = [sessionID copy];
|
|
}
|
|
|
|
/// Creates a background session configuration with the session ID using the supported method.
|
|
- (NSURLSessionConfiguration *)backgroundSessionConfigWithSessionID:(NSString *)sessionID
|
|
API_AVAILABLE(ios(7.0)) {
|
|
#if (TARGET_OS_OSX && defined(MAC_OS_X_VERSION_10_10) && \
|
|
MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_10) || \
|
|
TARGET_OS_TV || \
|
|
(TARGET_OS_IOS && defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_8_0)
|
|
|
|
// iOS 8/10.10 builds require the new backgroundSessionConfiguration method name.
|
|
return [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:sessionID];
|
|
|
|
#elif (TARGET_OS_OSX && defined(MAC_OS_X_VERSION_10_10) && \
|
|
MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_10) || \
|
|
(TARGET_OS_IOS && defined(__IPHONE_8_0) && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_8_0)
|
|
|
|
// Do a runtime check to avoid a deprecation warning about using
|
|
// +backgroundSessionConfiguration: on iOS 8.
|
|
if ([NSURLSessionConfiguration
|
|
respondsToSelector:@selector(backgroundSessionConfigurationWithIdentifier:)]) {
|
|
// Running on iOS 8+/OS X 10.10+.
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wunguarded-availability"
|
|
return [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:sessionID];
|
|
#pragma clang diagnostic pop
|
|
} else {
|
|
// Running on iOS 7/OS X 10.9.
|
|
return [NSURLSessionConfiguration backgroundSessionConfiguration:sessionID];
|
|
}
|
|
|
|
#else
|
|
// Building with an SDK earlier than iOS 8/OS X 10.10.
|
|
return [NSURLSessionConfiguration backgroundSessionConfiguration:sessionID];
|
|
#endif
|
|
}
|
|
|
|
- (void)maybeRemoveTempFilesAtURL:(NSURL *)folderURL expiringTime:(NSTimeInterval)staleTime {
|
|
if (!folderURL.absoluteString.length) {
|
|
return;
|
|
}
|
|
|
|
NSFileManager *fileManager = [NSFileManager defaultManager];
|
|
NSError *error = nil;
|
|
|
|
NSArray *properties = @[ NSURLCreationDateKey ];
|
|
NSArray *directoryContent =
|
|
[fileManager contentsOfDirectoryAtURL:folderURL
|
|
includingPropertiesForKeys:properties
|
|
options:NSDirectoryEnumerationSkipsSubdirectoryDescendants
|
|
error:&error];
|
|
if (error && error.code != NSFileReadNoSuchFileError) {
|
|
[_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelDebug
|
|
messageCode:kGULNetworkMessageCodeURLSession012
|
|
message:@"Cannot get files from the temporary network folder. Error"
|
|
context:error];
|
|
return;
|
|
}
|
|
|
|
if (!directoryContent.count) {
|
|
return;
|
|
}
|
|
|
|
NSTimeInterval now = [NSDate date].timeIntervalSince1970;
|
|
for (NSURL *tempFile in directoryContent) {
|
|
NSDate *creationDate;
|
|
BOOL getCreationDate = [tempFile getResourceValue:&creationDate
|
|
forKey:NSURLCreationDateKey
|
|
error:NULL];
|
|
if (!getCreationDate) {
|
|
continue;
|
|
}
|
|
NSTimeInterval creationTimeInterval = creationDate.timeIntervalSince1970;
|
|
if (fabs(now - creationTimeInterval) > staleTime) {
|
|
[self removeTempItemAtURL:tempFile];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Removes the temporary file written to disk for sending the request. It has to be cleaned up
|
|
/// after the session is done.
|
|
- (void)removeTempItemAtURL:(NSURL *)fileURL {
|
|
if (!fileURL.absoluteString.length) {
|
|
return;
|
|
}
|
|
|
|
NSFileManager *fileManager = [NSFileManager defaultManager];
|
|
NSError *error = nil;
|
|
|
|
if (![fileManager removeItemAtURL:fileURL error:&error] && error.code != NSFileNoSuchFileError) {
|
|
[_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession013
|
|
message:@"Failed to remove temporary uploading data file. Error"
|
|
context:error.localizedDescription];
|
|
}
|
|
}
|
|
|
|
/// Gets the fetcher with the session ID.
|
|
+ (instancetype)fetcherWithSessionIdentifier:(NSString *)sessionIdentifier {
|
|
GULNetworkURLSession *session = [self sessionFromFetcherMapForSessionID:sessionIdentifier];
|
|
if (!session && [sessionIdentifier hasPrefix:kGULNetworkBackgroundSessionConfigIDPrefix]) {
|
|
session = [[GULNetworkURLSession alloc] initWithNetworkLoggerDelegate:nil];
|
|
[session setSessionID:sessionIdentifier];
|
|
[self setSessionInFetcherMap:session forSessionID:sessionIdentifier];
|
|
}
|
|
return session;
|
|
}
|
|
|
|
/// Returns a map of the fetcher by session ID. Creates a map if it is not created.
|
|
/// When reading and writing from/to the session map, don't use this method directly.
|
|
/// To avoid thread safety issues, use one of the helper methods at the bottom of the
|
|
/// file: setSessionInFetcherMap:forSessionID:, sessionFromFetcherMapForSessionID:
|
|
+ (NSMapTable<NSString *, GULNetworkURLSession *> *)sessionIDToFetcherMap {
|
|
static NSMapTable *sessionIDToFetcherMap;
|
|
|
|
static dispatch_once_t sessionMapOnceToken;
|
|
dispatch_once(&sessionMapOnceToken, ^{
|
|
sessionIDToFetcherMap = [NSMapTable strongToWeakObjectsMapTable];
|
|
});
|
|
return sessionIDToFetcherMap;
|
|
}
|
|
|
|
+ (NSLock *)sessionIDToFetcherMapReadWriteLock {
|
|
static NSLock *lock;
|
|
|
|
static dispatch_once_t onceToken;
|
|
dispatch_once(&onceToken, ^{
|
|
lock = [[NSLock alloc] init];
|
|
});
|
|
return lock;
|
|
}
|
|
|
|
/// Returns a map of system provided completion handler by session ID. Creates a map if it is not
|
|
/// created.
|
|
+ (GULMutableDictionary *)sessionIDToSystemCompletionHandlerDictionary {
|
|
static GULMutableDictionary *systemCompletionHandlers;
|
|
|
|
static dispatch_once_t systemCompletionHandlerOnceToken;
|
|
dispatch_once(&systemCompletionHandlerOnceToken, ^{
|
|
systemCompletionHandlers = [[GULMutableDictionary alloc] init];
|
|
});
|
|
return systemCompletionHandlers;
|
|
}
|
|
|
|
- (NSURL *)temporaryFilePathWithSessionID:(NSString *)sessionID {
|
|
NSString *tempName = [NSString stringWithFormat:@"GULUpload_temp_%@", sessionID];
|
|
return [_networkDirectoryURL URLByAppendingPathComponent:tempName];
|
|
}
|
|
|
|
/// Makes sure that the directory to store temp files exists. If not, tries to create it and returns
|
|
/// YES. If there is anything wrong, returns NO.
|
|
- (BOOL)ensureTemporaryDirectoryExists {
|
|
NSFileManager *fileManager = [NSFileManager defaultManager];
|
|
NSError *error = nil;
|
|
|
|
// Create a temporary directory if it does not exist or was deleted.
|
|
if ([_networkDirectoryURL checkResourceIsReachableAndReturnError:&error]) {
|
|
return YES;
|
|
}
|
|
|
|
if (error && error.code != NSFileReadNoSuchFileError) {
|
|
[_loggerDelegate
|
|
GULNetwork_logWithLevel:kGULNetworkLogLevelWarning
|
|
messageCode:kGULNetworkMessageCodeURLSession014
|
|
message:@"Error while trying to access Network temp folder. Error"
|
|
context:error];
|
|
}
|
|
|
|
NSError *writeError = nil;
|
|
|
|
[fileManager createDirectoryAtURL:_networkDirectoryURL
|
|
withIntermediateDirectories:YES
|
|
attributes:nil
|
|
error:&writeError];
|
|
if (writeError) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession015
|
|
message:@"Cannot create temporary directory. Error"
|
|
context:writeError];
|
|
return NO;
|
|
}
|
|
|
|
// Set the iCloud exclusion attribute on the Documents URL.
|
|
[self excludeFromBackupForURL:_networkDirectoryURL];
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (void)excludeFromBackupForURL:(NSURL *)url {
|
|
if (!url.path) {
|
|
return;
|
|
}
|
|
|
|
// Set the iCloud exclusion attribute on the Documents URL.
|
|
NSError *preventBackupError = nil;
|
|
[url setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:&preventBackupError];
|
|
if (preventBackupError) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession016
|
|
message:@"Cannot exclude temporary folder from iTunes backup"];
|
|
}
|
|
}
|
|
|
|
- (void)URLSession:(NSURLSession *)session
|
|
task:(NSURLSessionTask *)task
|
|
willPerformHTTPRedirection:(NSHTTPURLResponse *)response
|
|
newRequest:(NSURLRequest *)request
|
|
completionHandler:(void (^)(NSURLRequest *))completionHandler API_AVAILABLE(ios(7.0)) {
|
|
NSArray *nonAllowedRedirectionCodes = @[
|
|
@(kGULNetworkHTTPStatusCodeFound), @(kGULNetworkHTTPStatusCodeMovedPermanently),
|
|
@(kGULNetworkHTTPStatusCodeMovedTemporarily), @(kGULNetworkHTTPStatusCodeMultipleChoices)
|
|
];
|
|
|
|
// Allow those not in the non allowed list to be followed.
|
|
if (![nonAllowedRedirectionCodes containsObject:@(response.statusCode)]) {
|
|
completionHandler(request);
|
|
return;
|
|
}
|
|
|
|
// Do not allow redirection if the response code is in the non-allowed list.
|
|
NSURLRequest *newRequest = request;
|
|
|
|
if (response) {
|
|
newRequest = nil;
|
|
}
|
|
|
|
completionHandler(newRequest);
|
|
}
|
|
|
|
#pragma mark - Helper Methods
|
|
|
|
+ (void)setSessionInFetcherMap:(GULNetworkURLSession *)session forSessionID:(NSString *)sessionID {
|
|
[[self sessionIDToFetcherMapReadWriteLock] lock];
|
|
GULNetworkURLSession *existingSession =
|
|
[[[self class] sessionIDToFetcherMap] objectForKey:sessionID];
|
|
if (existingSession) {
|
|
if (session) {
|
|
NSString *message = [NSString stringWithFormat:@"Discarding session: %@", existingSession];
|
|
[existingSession->_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelInfo
|
|
messageCode:kGULNetworkMessageCodeURLSession019
|
|
message:message];
|
|
}
|
|
[existingSession->_URLSession finishTasksAndInvalidate];
|
|
}
|
|
if (session) {
|
|
[[[self class] sessionIDToFetcherMap] setObject:session forKey:sessionID];
|
|
} else {
|
|
[[[self class] sessionIDToFetcherMap] removeObjectForKey:sessionID];
|
|
}
|
|
[[self sessionIDToFetcherMapReadWriteLock] unlock];
|
|
}
|
|
|
|
+ (nullable GULNetworkURLSession *)sessionFromFetcherMapForSessionID:(NSString *)sessionID {
|
|
[[self sessionIDToFetcherMapReadWriteLock] lock];
|
|
GULNetworkURLSession *session = [[[self class] sessionIDToFetcherMap] objectForKey:sessionID];
|
|
[[self sessionIDToFetcherMapReadWriteLock] unlock];
|
|
return session;
|
|
}
|
|
|
|
- (void)callCompletionHandler:(GULNetworkURLSessionCompletionHandler)handler
|
|
withResponse:(NSHTTPURLResponse *)response
|
|
data:(NSData *)data
|
|
error:(NSError *)error {
|
|
if (error) {
|
|
[_loggerDelegate GULNetwork_logWithLevel:kGULNetworkLogLevelError
|
|
messageCode:kGULNetworkMessageCodeURLSession017
|
|
message:@"Encounter network error. Code, error"
|
|
contexts:@[ @(error.code), error ]];
|
|
}
|
|
|
|
if (handler) {
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
handler(response, data, self->_sessionID, error);
|
|
});
|
|
}
|
|
}
|
|
|
|
// Always use the request parameters even if the default session configuration is more restrictive.
|
|
- (void)populateSessionConfig:(NSURLSessionConfiguration *)sessionConfig
|
|
withRequest:(NSURLRequest *)request API_AVAILABLE(ios(7.0)) {
|
|
sessionConfig.HTTPAdditionalHeaders = request.allHTTPHeaderFields;
|
|
sessionConfig.timeoutIntervalForRequest = request.timeoutInterval;
|
|
sessionConfig.timeoutIntervalForResource = request.timeoutInterval;
|
|
sessionConfig.requestCachePolicy = request.cachePolicy;
|
|
}
|
|
|
|
@end
|