@appzung/react-native-code-push 5.7.1

package/ios/CodePush/CodePushConfig.m

@@ -0,0 +1,116 @@
+#import "CodePush.h"
+#import <UIKit/UIKit.h>
+
+@implementation CodePushConfig {
+    NSMutableDictionary *_configDictionary;
+}
+
+static CodePushConfig *_currentConfig;
+
+static NSString * const AppVersionConfigKey = @"appVersion";
+static NSString * const BuildVersionConfigKey = @"buildVersion";
+static NSString * const ClientUniqueIDConfigKey = @"clientUniqueId";
+static NSString * const DeploymentKeyConfigKey = @"deploymentKey";
+static NSString * const ServerURLConfigKey = @"serverUrl";
+static NSString * const PublicKeyKey = @"publicKey";
+
++ (instancetype)current
+{
+    return _currentConfig;
+}
+
++ (void)initialize
+{
+    if (self == [CodePushConfig class]) {
+        _currentConfig = [[CodePushConfig alloc] init];
+    }
+}
+
+- (instancetype)init
+{
+    self = [super init];
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+
+    NSString *appVersion = [infoDictionary objectForKey:@"CFBundleShortVersionString"];
+    NSString *buildVersion = [infoDictionary objectForKey:(NSString *)kCFBundleVersionKey];
+    NSString *deploymentKey = [infoDictionary objectForKey:@"CodePushDeploymentKey"];
+    NSString *serverURL = [infoDictionary objectForKey:@"CodePushServerURL"];
+    NSString *publicKey = [infoDictionary objectForKey:@"CodePushPublicKey"];
+    
+    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
+    NSString *clientUniqueId = [userDefaults stringForKey:ClientUniqueIDConfigKey];
+    if (clientUniqueId == nil) {
+        clientUniqueId = [[[UIDevice currentDevice] identifierForVendor] UUIDString];
+        [userDefaults setObject:clientUniqueId forKey:ClientUniqueIDConfigKey];
+        [userDefaults synchronize];
+    }
+
+    if (!serverURL) {
+        serverURL = @"https://codepush.appzung.com/";
+    }
+
+    _configDictionary = [NSMutableDictionary dictionary];
+
+    if (appVersion) [_configDictionary setObject:appVersion forKey:AppVersionConfigKey];
+    if (buildVersion) [_configDictionary setObject:buildVersion forKey:BuildVersionConfigKey];
+    if (serverURL) [_configDictionary setObject:serverURL forKey:ServerURLConfigKey];
+    if (clientUniqueId) [_configDictionary setObject:clientUniqueId forKey:ClientUniqueIDConfigKey];
+    if (deploymentKey) [_configDictionary setObject:deploymentKey forKey:DeploymentKeyConfigKey];
+    if (publicKey) [_configDictionary setObject:publicKey forKey:PublicKeyKey];
+
+    return self;
+}
+
+- (NSString *)appVersion
+{
+    return [_configDictionary objectForKey:AppVersionConfigKey];
+}
+
+- (NSString *)buildVersion
+{
+    return [_configDictionary objectForKey:BuildVersionConfigKey];
+}
+
+- (NSDictionary *)configuration
+{
+    return _configDictionary;
+}
+
+- (NSString *)deploymentKey
+{
+    return [_configDictionary objectForKey:DeploymentKeyConfigKey];
+}
+
+- (NSString *)serverURL
+{
+    return [_configDictionary objectForKey:ServerURLConfigKey];
+}
+
+- (NSString *)clientUniqueId
+{
+    return [_configDictionary objectForKey:ClientUniqueIDConfigKey];
+}
+
+- (NSString *)publicKey
+{
+    return [_configDictionary objectForKey:PublicKeyKey];
+}
+
+- (void)setAppVersion:(NSString *)appVersion
+{
+    [_configDictionary setValue:appVersion forKey:AppVersionConfigKey];
+}
+
+- (void)setDeploymentKey:(NSString *)deploymentKey
+{
+    [_configDictionary setValue:deploymentKey forKey:DeploymentKeyConfigKey];
+}
+
+- (void)setServerURL:(NSString *)serverURL
+{
+    [_configDictionary setValue:serverURL forKey:ServerURLConfigKey];
+}
+
+//no setter for PublicKey, because it's need to be hard coded within Info.plist for safety
+
+@end

package/ios/CodePush/CodePushDownloadHandler.m

@@ -0,0 +1,130 @@
+#import "CodePush.h"
+
+@implementation CodePushDownloadHandler {
+    // Header chars used to determine if the file is a zip.
+    char _header[4];
+}
+
+- (id)init:(NSString *)downloadFilePath
+operationQueue:(dispatch_queue_t)operationQueue
+progressCallback:(void (^)(long long, long long))progressCallback
+doneCallback:(void (^)(BOOL))doneCallback
+failCallback:(void (^)(NSError *err))failCallback {
+    self.outputFileStream = [NSOutputStream outputStreamToFileAtPath:downloadFilePath
+                                                              append:NO];
+    self.receivedContentLength = 0;
+    self.operationQueue = operationQueue;
+    self.progressCallback = progressCallback;
+    self.doneCallback = doneCallback;
+    self.failCallback = failCallback;
+    return self;
+}
+
+- (void)download:(NSString *)url {
+    self.downloadUrl = url;
+    NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:url]
+                                             cachePolicy:NSURLRequestUseProtocolCachePolicy
+                                         timeoutInterval:60.0];
+    NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:request
+                                                                  delegate:self
+                                                          startImmediately:NO];
+    if ([NSOperationQueue instancesRespondToSelector:@selector(setUnderlyingQueue:)]) {
+        NSOperationQueue *delegateQueue = [NSOperationQueue new];
+        delegateQueue.underlyingQueue = self.operationQueue;
+        [connection setDelegateQueue:delegateQueue];
+    } else {
+        [connection scheduleInRunLoop:[NSRunLoop mainRunLoop]
+                              forMode:NSDefaultRunLoopMode];
+    }
+
+    [connection start];
+}
+
+#pragma mark NSURLConnection Delegate Methods
+
+- (NSCachedURLResponse *)connection:(NSURLConnection *)connection
+                  willCacheResponse:(NSCachedURLResponse*)cachedResponse {
+    // Return nil to indicate not necessary to store a cached response for this connection
+    return nil;
+}
+
+- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response {
+    if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+        NSInteger statusCode = [(NSHTTPURLResponse *)response statusCode];
+        if (statusCode >= 400) {
+            [self.outputFileStream close];
+            [connection cancel];
+            NSError *err = [CodePushErrorUtils errorWithMessage:[NSString stringWithFormat: @"Received %ld response from %@", (long)statusCode, self.downloadUrl]];
+            self.failCallback(err);
+            return;
+        }
+    }
+    
+    self.expectedContentLength = response.expectedContentLength;
+    [self.outputFileStream open];
+}
+
+- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
+    if (self.receivedContentLength < 4) {
+        for (int i = 0; i < [data length]; i++) {
+            int headerOffset = (int)self.receivedContentLength + i;
+            if (headerOffset >= 4) {
+                break;
+            }
+
+            const char *bytes = [data bytes];
+            _header[headerOffset] = bytes[i];
+        }
+    }
+
+    self.receivedContentLength = self.receivedContentLength + [data length];
+
+    NSInteger bytesLeft = [data length];
+
+    do {
+        NSInteger bytesWritten = [self.outputFileStream write:[data bytes]
+                                                     maxLength:bytesLeft];
+        if (bytesWritten == -1) {
+            break;
+        }
+
+        bytesLeft -= bytesWritten;
+    } while (bytesLeft > 0);
+
+    self.progressCallback(self.expectedContentLength, self.receivedContentLength);
+
+    // bytesLeft should not be negative.
+    assert(bytesLeft >= 0);
+
+    if (bytesLeft) {
+        [self.outputFileStream close];
+        [connection cancel];
+        self.failCallback([self.outputFileStream streamError]);
+    }
+}
+
+- (void)connection:(NSURLConnection*)connection didFailWithError:(NSError*)error
+{
+    [self.outputFileStream close];
+    self.failCallback(error);
+}
+
+- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
+    [self.outputFileStream close];
+    if (self.receivedContentLength < 1) {
+        NSError *err = [CodePushErrorUtils errorWithMessage:[NSString stringWithFormat:@"Received empty response from %@", self.downloadUrl]];
+        self.failCallback(err);
+        return;
+    }
+    
+    // expectedContentLength might be -1 when NSURLConnection don't know the length(e.g. response encode with gzip)
+    if (self.expectedContentLength > 0) {
+        // We should have received all of the bytes if this is called.
+        assert(self.receivedContentLength == self.expectedContentLength);
+    }
+
+    BOOL isZip = _header[0] == 'P' && _header[1] == 'K' && _header[2] == 3 && _header[3] == 4;
+    self.doneCallback(isZip);
+}
+
+@end

package/ios/CodePush/CodePushErrorUtils.m

@@ -0,0 +1,20 @@
+#import "CodePush.h"
+
+@implementation CodePushErrorUtils
+
+static NSString *const CodePushErrorDomain = @"CodePushError";
+static const int CodePushErrorCode = -1;
+
++ (NSError *)errorWithMessage:(NSString *)errorMessage
+{
+    return [NSError errorWithDomain:CodePushErrorDomain
+                               code:CodePushErrorCode
+                           userInfo:@{ NSLocalizedDescriptionKey: NSLocalizedString(errorMessage, nil) }];
+}
+
++ (BOOL)isCodePushError:(NSError *)err
+{
+    return err != nil && [CodePushErrorDomain isEqualToString:err.domain];
+}
+
+@end