react-native-update 10.39.1 → 10.40.0-beta.1

package/ios/RCTPushy/RCTPushy.mm

@@ -1,6 +1,6 @@
 #import "RCTPushy.h"
 #import "RCTPushyDownloader.h"
-#import "RCTPushyManager.h"
+#import "ZipArchive.h"
 #include "../../cpp/patch_core/archive_patch_core.h"
 #include "../../cpp/patch_core/patch_core.h"
 #include "../../cpp/patch_core/state_core.h"
@@ -8,14 +8,12 @@
 #if __has_include("RCTReloadCommand.h")
 #import "RCTReloadCommand.h"
 #endif
-// Thanks to this guard, we won't import this header when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 #import "RCTPushySpec.h"
 #endif
 
 #import <React/RCTConvert.h>
 #import <React/RCTLog.h>
-// #import <React/RCTReloadCommand.h>
 
 static NSString *const keyPushyInfo = @"REACTNATIVECN_PUSHY_INFO_KEY";
 static NSString *const paramPackageVersion = @"packageVersion";
@@ -29,10 +27,7 @@ static NSString *const keyHashInfo = @"REACTNATIVECN_PUSHY_HASH_";
 static NSString *const keyFirstLoadMarked = @"REACTNATIVECN_PUSHY_FIRSTLOADMARKED_KEY";
 static NSString *const keyRolledBackMarked = @"REACTNATIVECN_PUSHY_ROLLEDBACKMARKED_KEY";
 static NSString *const KeyPackageUpdatedMarked = @"REACTNATIVECN_PUSHY_ISPACKAGEUPDATEDMARKED_KEY";
-
-// app info
-static NSString * const AppVersionKey = @"appVersion";
-static NSString * const BuildVersionKey = @"buildVersion";
+static NSString *const PushyErrorDomain = @"cn.reactnative.pushy";
 
 // file def
 static NSString * const BUNDLE_FILE_NAME = @"index.bundlejs";
@@ -41,12 +36,10 @@ static NSString * const BUNDLE_PATCH_NAME = @"index.bundlejs.patch";
 
 // error def
 static NSString * const ERROR_OPTIONS = @"options error";
-static NSString * const ERROR_HDIFFPATCH = @"hdiffpatch error";
 static NSString * const ERROR_FILE_OPERATION = @"file operation error";
 
 // event def
 static NSString * const EVENT_PROGRESS_DOWNLOAD = @"RCTPushyDownloadProgress";
-// static NSString * const EVENT_PROGRESS_UNZIP = @"RCTPushyUnzipProgress";
 static NSString * const PARAM_PROGRESS_HASH = @"hash";
 static NSString * const PARAM_PROGRESS_RECEIVED = @"received";
 static NSString * const PARAM_PROGRESS_TOTAL = @"total";
@@ -69,11 +62,15 @@ static std::string PushyToStdString(NSString *value) {
 }
 
 static NSError *PushyNSErrorFromStatus(const pushy::patch::Status &status) {
-    return [NSError errorWithDomain:@"cn.reactnative.pushy"
+    return [NSError errorWithDomain:PushyErrorDomain
                                code:-1
                            userInfo:@{ NSLocalizedDescriptionKey: [NSString stringWithUTF8String:status.message.c_str()] }];
 }
 
+static NSUserDefaults *PushyDefaults(void) {
+    return [NSUserDefaults standardUserDefaults];
+}
+
 static NSString *PushyFromStdString(const std::string &value) {
     if (value.empty()) {
         return nil;
@@ -89,6 +86,37 @@ static void PushySetNullableString(NSUserDefaults *defaults, NSString *key, NSSt
     }
 }
 
+static NSString *PushyHashInfoKey(NSString *hash) {
+    return [keyHashInfo stringByAppendingString:hash ?: @""];
+}
+
+static NSString *PushyOptionString(NSDictionary *options, NSString *key) {
+    return [RCTConvert NSString:options[key]];
+}
+
+static BOOL PushyStringIsBlank(NSString *value) {
+    if (value == nil || [value isKindOfClass:[NSNull class]]) {
+        return YES;
+    }
+    return [[value stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] length] == 0;
+}
+
+static void PushyRejectError(RCTPromiseRejectBlock reject, NSError *error) {
+    reject([NSString stringWithFormat:@"%ld", (long)error.code], error.localizedDescription, error);
+}
+
+static NSError *PushyErrorWithMessage(NSString *message) {
+    return [NSError errorWithDomain:PushyErrorDomain
+                               code:-1
+                           userInfo:@{
+                               NSLocalizedDescriptionKey: message ?: @"unknown error",
+                           }];
+}
+
+static void PushyRejectMessage(RCTPromiseRejectBlock reject, NSString *message) {
+    PushyRejectError(reject, PushyErrorWithMessage(message));
+}
+
 static pushy::patch::PatchManifest PushyPatchManifestFromJson(NSDictionary *json) {
     pushy::patch::PatchManifest manifest;
 
@@ -155,36 +183,48 @@ static void PushyApplyStateToDefaults(NSUserDefaults *defaults, const pushy::sta
 }
 
 @interface RCTPushy ()
-- (void)_dopatch:(NSString *)hash
-            type:(PushyType)type
-      fromBundle:(NSString *)bundleOrigin
-          source:(NSString *)sourceOrigin
-        callback:(void (^)(NSError *error))callback;
-- (void)patch:(NSString *)hash
-         type:(PushyType)type
-   fromBundle:(NSString *)bundleOrigin
-       source:(NSString *)sourceOrigin
-     callback:(void (^)(NSError *error))callback;
+- (void)downloadUpdate:(PushyType)type
+               options:(NSDictionary *)options
+              resolver:(RCTPromiseResolveBlock)resolve
+              rejecter:(RCTPromiseRejectBlock)reject;
+- (void)performUpdate:(PushyType)type
+              options:(NSDictionary *)options
+             callback:(void (^)(NSError *error))callback;
+- (void)reloadBridgeWithReason:(NSString *)reason;
+- (void)unzipDownloadedPackage:(NSString *)zipFilePath
+                          hash:(NSString *)hash
+                          type:(PushyType)type
+                    originHash:(NSString *)originHash
+                      callback:(void (^)(NSError *error))callback;
+- (void)finishDownloadedPackage:(NSString *)hash
+                           type:(PushyType)type
+                     originHash:(NSString *)originHash
+                       callback:(void (^)(NSError *error))callback;
+- (void)applyPatchForHash:(NSString *)hash
+                     type:(PushyType)type
+               fromBundle:(NSString *)bundleOrigin
+                   source:(NSString *)sourceOrigin
+                 callback:(void (^)(NSError *error))callback;
+- (BOOL)switchVersion:(NSString *)hash error:(NSError **)error;
+- (BOOL)ensureDirectoryExistsAtPath:(NSString *)path;
+- (void)unzipFileAtPath:(NSString *)path
+          toDestination:(NSString *)destination
+      completionHandler:(void (^)(NSError *error))completionHandler;
 @end
 
 @implementation RCTPushy {
-    RCTPushyManager *_fileManager;
+    dispatch_queue_t _fileQueue;
     bool hasListeners;
 }
 
-@synthesize methodQueue = _methodQueue;
-
 RCT_EXPORT_MODULE(RCTPushy);
 
 + (NSURL *)bundleURL
 {
-    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+    NSUserDefaults *defaults = PushyDefaults();
     
-    // Check for version changes first 
     NSString *curPackageVersion = [RCTPushy packageVersion];
     NSString *curBuildTime = [RCTPushy buildTime];
-    NSString *storedPackageVersion = [defaults stringForKey:paramPackageVersion];
-    NSString *storedBuildTime = [defaults stringForKey:paramBuildTime];
     
     pushy::state::State state = PushyStateFromDefaults(defaults);
     pushy::state::BinaryVersionSyncResult sync = pushy::state::SyncBinaryVersion(
@@ -235,20 +275,20 @@ RCT_EXPORT_MODULE(RCTPushy);
 }
 
 + (NSString *) rollback {
-    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+    NSUserDefaults *defaults = PushyDefaults();
     pushy::state::State state = pushy::state::Rollback(PushyStateFromDefaults(defaults));
     PushyApplyStateToDefaults(defaults, state);
     return PushyFromStdString(state.current_version);
 }
 
-+ (BOOL)requiresMainQueueSetup {
-    // only set to YES if your module initialization relies on calling UIKit!
-	return NO;
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
 }
 
 - (NSDictionary *)constantsToExport
 {
-    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+    NSUserDefaults *defaults = PushyDefaults();
     
     NSMutableDictionary *ret = [NSMutableDictionary new];
     ret[@"downloadRootDir"] = [RCTPushy downloadDir];
@@ -261,23 +301,20 @@ RCT_EXPORT_MODULE(RCTPushy);
     NSString *currentVersion = [pushyInfo objectForKey:paramCurrentVersion];
     ret[@"currentVersion"] = currentVersion;
     if (currentVersion != nil) {
-        ret[@"currentVersionInfo"] = [defaults objectForKey:[keyHashInfo stringByAppendingString:currentVersion]];
+        ret[@"currentVersionInfo"] = [defaults objectForKey:PushyHashInfoKey(currentVersion)];
     }
     
-    // clear isFirstTimemarked
     if (ret[@"isFirstTime"]) {
-        [defaults setObject:nil forKey:keyFirstLoadMarked];
+        [defaults removeObjectForKey:keyFirstLoadMarked];
     }
     
-    // clear rolledbackmark
     if (ret[@"rolledBackVersion"] != nil) {
-        [defaults setObject:nil forKey:keyRolledBackMarked];
+        [defaults removeObjectForKey:keyRolledBackMarked];
         [self clearInvalidFiles];
     }
     
-    // clear packageupdatemarked
     if ([[defaults objectForKey:KeyPackageUpdatedMarked] boolValue]) {
-        [defaults setObject:nil forKey:KeyPackageUpdatedMarked];
+        [defaults removeObjectForKey:KeyPackageUpdatedMarked];
         [self clearInvalidFiles];
     }
     
@@ -289,7 +326,7 @@ RCT_EXPORT_MODULE(RCTPushy);
 {
     self = [super init];
     if (self) {
-        _fileManager = [RCTPushyManager new];
+        _fileQueue = dispatch_queue_create("cn.reactnative.pushy.file", DISPATCH_QUEUE_SERIAL);
     }
     return self;
 }
@@ -297,31 +334,35 @@ RCT_EXPORT_MODULE(RCTPushy);
 RCT_EXPORT_METHOD(setUuid:(NSString *)uuid  resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    @try {
-        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-        [defaults setObject:uuid forKey:keyUuid];
-        
-        resolve(@true);
-    }
-    @catch (NSException *exception) {
-        reject(@"json格式校验报错", nil, nil);
+    if (PushyStringIsBlank(uuid)) {
+        PushyRejectError(reject, PushyErrorWithMessage(ERROR_OPTIONS));
+        return;
     }
+
+    NSUserDefaults *defaults = PushyDefaults();
+    [defaults setObject:uuid forKey:keyUuid];
+    resolve(@true);
 }
 
 RCT_EXPORT_METHOD(setLocalHashInfo:(NSString *)hash
                   value:(NSString *)value resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
+    if (PushyStringIsBlank(hash) || PushyStringIsBlank(value)) {
+        PushyRejectMessage(reject, ERROR_OPTIONS);
+        return;
+    }
+
     NSData *data = [value dataUsingEncoding:NSUTF8StringEncoding];
     NSError *error = nil;
     id object = [NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
     if (object && [object isKindOfClass:[NSDictionary class]]) {
-        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-        [defaults setObject:value forKey:[keyHashInfo stringByAppendingString:hash]];
+        NSUserDefaults *defaults = PushyDefaults();
+        [defaults setObject:value forKey:PushyHashInfoKey(hash)];
         
         resolve(@true);
     } else {
-        reject(@"json格式校验报错", nil, nil);
+        PushyRejectError(reject, error ?: PushyErrorWithMessage(@"json格式校验报错"));
     }
 }
 
@@ -331,121 +372,63 @@ RCT_EXPORT_METHOD(getLocalHashInfo:(NSString *)hash
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
     
-    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-    resolve([defaults stringForKey:[keyHashInfo stringByAppendingString:hash]]);
+    NSUserDefaults *defaults = PushyDefaults();
+    resolve([defaults stringForKey:PushyHashInfoKey(hash)]);
 }
 
 RCT_EXPORT_METHOD(downloadFullUpdate:(NSDictionary *)options
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self doPushy:PushyTypeFullDownload options:options callback:^(NSError *error) {
-        if (error) {
-            reject([NSString stringWithFormat: @"%lu", (long)error.code], error.localizedDescription, error);
-        }
-        else {
-            resolve(nil);
-        }
-    }];
+    [self downloadUpdate:PushyTypeFullDownload options:options resolver:resolve rejecter:reject];
 }
 
 RCT_EXPORT_METHOD(downloadPatchFromPackage:(NSDictionary *)options
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self doPushy:PushyTypePatchFromPackage options:options callback:^(NSError *error) {
-        if (error) {
-            reject([NSString stringWithFormat: @"%lu", (long)error.code], error.localizedDescription, error);
-        }
-        else {
-            resolve(nil);
-        }
-    }];
+    [self downloadUpdate:PushyTypePatchFromPackage options:options resolver:resolve rejecter:reject];
 }
 
 RCT_EXPORT_METHOD(downloadPatchFromPpk:(NSDictionary *)options
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self doPushy:PushyTypePatchFromPpk options:options callback:^(NSError *error) {
-        if (error) {
-            reject([NSString stringWithFormat: @"%lu", (long)error.code], error.localizedDescription, error);
-        }
-        else {
-            resolve(nil);
-        }
-    }];
+    [self downloadUpdate:PushyTypePatchFromPpk options:options resolver:resolve rejecter:reject];
 }
 
 RCT_EXPORT_METHOD(setNeedUpdate:(NSDictionary *)options
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    NSString *hash = options[@"hash"];
-    
-    if (hash.length) {
-        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-        pushy::state::State next = pushy::state::SwitchVersion(
-            PushyStateFromDefaults(defaults),
-            PushyToStdString(hash)
-        );
-        PushyApplyStateToDefaults(defaults, next);
-        resolve(@true);
-    } else {
-        reject(@"执行报错", nil, nil);
+    NSError *error = nil;
+    if (![self switchVersion:PushyOptionString(options, @"hash") error:&error]) {
+        PushyRejectError(reject, error);
+        return;
     }
+
+    resolve(@true);
 }
 
 RCT_EXPORT_METHOD(reloadUpdate:(NSDictionary *)options
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    @try {
-        NSString *hash = options[@"hash"];
-        if (hash.length) {
-            // 只在 setNeedUpdate 成功后 resolve
-            [self setNeedUpdate:options resolver:^(id result) {
-                dispatch_async(dispatch_get_main_queue(), ^{
-                    #if __has_include("RCTReloadCommand.h")
-                        // reload 0.62+
-                        RCTReloadCommandSetBundleURL([[self class] bundleURL]);
-                        RCTTriggerReloadCommandListeners(@"pushy reloadUpdate");
-                    #else
-                        [self.bridge reload];
-                    #endif
-                });
-                resolve(@true);
-            } rejecter:^(NSString *code, NSString *message, NSError *error) {
-                reject(code, message, error);
-            }];
-        } else {
-            reject(@"执行报错", nil, nil);
-        }
-    }
-    @catch (NSException *exception) {
-        reject(@"执行报错", nil, nil);
+    NSError *error = nil;
+    if (![self switchVersion:PushyOptionString(options, @"hash") error:&error]) {
+        PushyRejectError(reject, error);
+        return;
     }
+
+    [self reloadBridgeWithReason:@"pushy reloadUpdate"];
+    resolve(@true);
 }
 
 RCT_EXPORT_METHOD(restartApp:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-    @try {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            #if __has_include("RCTReloadCommand.h")
-                // reload 0.62+
-                RCTReloadCommandSetBundleURL([[self class] bundleURL]);
-                RCTTriggerReloadCommandListeners(@"pushy restartApp");
-            #else
-                [self.bridge reload];
-            #endif
-        });
-
-        resolve(@true);
-    }
-    @catch (NSException *exception) {
-        reject(@"执行报错", exception.reason, nil);
-    }
+    [self reloadBridgeWithReason:@"pushy restartApp"];
+    resolve(@true);
 }
 
 RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
@@ -454,23 +437,17 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
     #if DEBUG
     resolve(@true);
     #else
-    
-    @try {
-        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-        pushy::state::MarkSuccessResult result =
-            pushy::state::MarkSuccess(PushyStateFromDefaults(defaults));
-        if (!result.stale_version_to_delete.empty()) {
-            [defaults removeObjectForKey:[keyHashInfo stringByAppendingString:PushyFromStdString(result.stale_version_to_delete)]];
-        }
-        PushyApplyStateToDefaults(defaults, result.state);
-        
-        // clear other package dir
-        [self clearInvalidFiles];
-        resolve(@true);
-    }
-    @catch (NSException *exception) {
-        reject(@"执行报错", nil, nil);
+
+    NSUserDefaults *defaults = PushyDefaults();
+    pushy::state::MarkSuccessResult result =
+        pushy::state::MarkSuccess(PushyStateFromDefaults(defaults));
+    if (!result.stale_version_to_delete.empty()) {
+        [defaults removeObjectForKey:PushyHashInfoKey(PushyFromStdString(result.stale_version_to_delete))];
     }
+    PushyApplyStateToDefaults(defaults, result.state);
+
+    [self clearInvalidFiles];
+    resolve(@true);
     #endif
 }
 
@@ -480,61 +457,67 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
 - (NSArray<NSString *> *)supportedEvents
 {
   return @[
-      EVENT_PROGRESS_DOWNLOAD, 
-    //   EVENT_PROGRESS_UNZIP
-      ];
+      EVENT_PROGRESS_DOWNLOAD,
+  ];
 }
 
-// Will be called when this module's first listener is added.
 -(void)startObserving {
     hasListeners = YES;
-    // Set up any upstream listeners or background tasks as necessary
 }
 
-// Will be called when this module's last listener is removed, or on dealloc.
 -(void)stopObserving {
     hasListeners = NO;
-    // Remove upstream listeners, stop unnecessary background tasks
 }
 
-- (BOOL) isBlankString:(NSString *)string {
-    if (string == nil || string == NULL) {
-        return YES;
-    }
-    if ([string isKindOfClass:[NSNull class]]) {
-        return YES;
-    }
-    if ([[string stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]] length]==0) {
-        return YES;
-    }
-    return NO;
+- (void)downloadUpdate:(PushyType)type
+               options:(NSDictionary *)options
+              resolver:(RCTPromiseResolveBlock)resolve
+              rejecter:(RCTPromiseRejectBlock)reject
+{
+    [self performUpdate:type options:options callback:^(NSError *error) {
+        if (error != nil) {
+            PushyRejectError(reject, error);
+            return;
+        }
+        resolve(nil);
+    }];
 }
 
+- (void)reloadBridgeWithReason:(NSString *)reason
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        #if __has_include("RCTReloadCommand.h")
+            RCTReloadCommandSetBundleURL([[self class] bundleURL]);
+            RCTTriggerReloadCommandListeners(reason);
+        #else
+            [self.bridge reload];
+        #endif
+    });
+}
 
-- (void)doPushy:(PushyType)type options:(NSDictionary *)options callback:(void (^)(NSError *error))callback
+- (void)performUpdate:(PushyType)type options:(NSDictionary *)options callback:(void (^)(NSError *error))callback
 {
-    NSString *updateUrl = [RCTConvert NSString:options[@"updateUrl"]];
-    NSString *hash = [RCTConvert NSString:options[@"hash"]];
+    NSString *updateUrl = PushyOptionString(options, @"updateUrl");
+    NSString *hash = PushyOptionString(options, @"hash");
 
-    if (updateUrl.length <= 0 || hash.length <= 0) {
-        callback([self errorWithMessage:ERROR_OPTIONS]);
+    if (PushyStringIsBlank(updateUrl) || PushyStringIsBlank(hash)) {
+        callback(PushyErrorWithMessage(ERROR_OPTIONS));
         return;
     }
-    NSString *originHash = [RCTConvert NSString:options[@"originHash"]];
-    if (type == PushyTypePatchFromPpk && [self isBlankString:originHash]) {
-        callback([self errorWithMessage:ERROR_OPTIONS]);
+    NSString *originHash = PushyOptionString(options, @"originHash");
+    if (type == PushyTypePatchFromPpk && PushyStringIsBlank(originHash)) {
+        callback(PushyErrorWithMessage(ERROR_OPTIONS));
         return;
     }
     
     NSString *dir = [RCTPushy downloadDir];
-    BOOL success = [_fileManager createDir:dir];
+    BOOL success = [self ensureDirectoryExistsAtPath:dir];
     if (!success) {
-        callback([self errorWithMessage:ERROR_FILE_OPERATION]);
+        callback(PushyErrorWithMessage(ERROR_FILE_OPERATION));
         return;
     }
 
     NSString *zipFilePath = [dir stringByAppendingPathComponent:[NSString stringWithFormat:@"%@%@",hash, [self zipExtension:type]]];
-//    NSString *unzipDir = [dir stringByAppendingPathComponent:hash];
 
     RCTLogInfo(@"RCTPushy -- download file %@", updateUrl);
     [RCTPushyDownloader download:updateUrl savePath:zipFilePath progressHandler:^(long long receivedBytes, long long totalBytes) {
@@ -546,61 +529,72 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
             }];
         }
     } completionHandler:^(NSString *path, NSError *error) {
-        if (error) {
+        if (error != nil) {
             callback(error);
+            return;
         }
-        else {
-            RCTLogInfo(@"RCTPushy -- unzip file %@", zipFilePath);
-            NSString *unzipFilePath = [dir stringByAppendingPathComponent:hash];
-            [self->_fileManager unzipFileAtPath:zipFilePath toDestination:unzipFilePath progressHandler:^(NSString *entry,long entryNumber, long total) {
-                // if (self->hasListeners) {
-                //     [self sendEventWithName:EVENT_PROGRESS_UNZIP
-                //                        body:@{
-                //                            PARAM_PROGRESS_HASH:hash,
-                //                            PARAM_PROGRESS_RECEIVED:[NSNumber numberWithLong:entryNumber],
-                //                            PARAM_PROGRESS_TOTAL:[NSNumber numberWithLong:total]
-                //                        }];
-                // }
-                
-            } completionHandler:^(NSString *path, BOOL succeeded, NSError *error) {
-                dispatch_async(self->_methodQueue, ^{
-                    if (error) {
-                        callback(error);
-                    }
-                    else {
-                        switch (type) {
-                            case PushyTypePatchFromPackage:
-                            {
-                                NSString *sourceOrigin = [[NSBundle mainBundle] resourcePath];
-                                NSString *bundleOrigin = [[RCTPushy binaryBundleURL] path];
-                                [self patch:hash type:type fromBundle:bundleOrigin source:sourceOrigin callback:callback];
-                            }
-                                break;
-                            case PushyTypePatchFromPpk:
-                            {
-                                NSString *lastVersionDir = [dir stringByAppendingPathComponent:originHash];
-                                
-                                NSString *sourceOrigin = lastVersionDir;
-                                NSString *bundleOrigin = [lastVersionDir stringByAppendingPathComponent:BUNDLE_FILE_NAME];
-                                [self patch:hash type:type fromBundle:bundleOrigin source:sourceOrigin callback:callback];
-                            }
-                                break;
-                            default:
-                                callback(nil);
-                                break;
-                        }
-                    }
-                });
-            }];
-        }
+        [self unzipDownloadedPackage:zipFilePath
+                                hash:hash
+                                type:type
+                          originHash:originHash
+                            callback:callback];
     }];
 }
 
-- (void)_dopatch:(NSString *)hash
-            type:(PushyType)type
-      fromBundle:(NSString *)bundleOrigin
-          source:(NSString *)sourceOrigin
-        callback:(void (^)(NSError *error))callback
+- (void)unzipDownloadedPackage:(NSString *)zipFilePath
+                          hash:(NSString *)hash
+                          type:(PushyType)type
+                    originHash:(NSString *)originHash
+                      callback:(void (^)(NSError *error))callback
+{
+    RCTLogInfo(@"RCTPushy -- unzip file %@", zipFilePath);
+    NSString *unzipFilePath = [[RCTPushy downloadDir] stringByAppendingPathComponent:hash];
+    [self unzipFileAtPath:zipFilePath
+            toDestination:unzipFilePath
+        completionHandler:^(NSError *error) {
+        dispatch_async(self->_fileQueue, ^{
+            if (error != nil) {
+                callback(error);
+                return;
+            }
+            [self finishDownloadedPackage:hash type:type originHash:originHash callback:callback];
+        });
+    }];
+}
+
+- (void)finishDownloadedPackage:(NSString *)hash
+                           type:(PushyType)type
+                     originHash:(NSString *)originHash
+                       callback:(void (^)(NSError *error))callback
+{
+    switch (type) {
+        case PushyTypePatchFromPackage:
+            [self applyPatchForHash:hash
+                               type:type
+                         fromBundle:[[RCTPushy binaryBundleURL] path]
+                             source:[[NSBundle mainBundle] resourcePath]
+                           callback:callback];
+            return;
+        case PushyTypePatchFromPpk: {
+            NSString *lastVersionDir = [[RCTPushy downloadDir] stringByAppendingPathComponent:originHash];
+            [self applyPatchForHash:hash
+                               type:type
+                         fromBundle:[lastVersionDir stringByAppendingPathComponent:BUNDLE_FILE_NAME]
+                             source:lastVersionDir
+                           callback:callback];
+            return;
+        }
+        case PushyTypeFullDownload:
+            callback(nil);
+            return;
+    }
+}
+
+- (void)applyPatchForHash:(NSString *)hash
+                     type:(PushyType)type
+               fromBundle:(NSString *)bundleOrigin
+                   source:(NSString *)sourceOrigin
+                 callback:(void (^)(NSError *error))callback
 {
     NSString *unzipDir = [[RCTPushy downloadDir] stringByAppendingPathComponent:hash];
     NSString *sourcePatch = [unzipDir stringByAppendingPathComponent:SOURCE_PATCH_NAME];
@@ -608,12 +602,22 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
     
     NSString *destination = [unzipDir stringByAppendingPathComponent:BUNDLE_FILE_NAME];
     NSData *data = [NSData dataWithContentsOfFile:sourcePatch];
+    if (data == nil) {
+        callback(PushyErrorWithMessage(@"missing patch manifest"));
+        return;
+    }
+
     NSError *error = nil;
-    NSDictionary *json = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingAllowFragments error:&error];
-    if (error) {
+    id jsonObject = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingAllowFragments error:&error];
+    if (error != nil) {
         callback(error);
         return;
     }
+    if (![jsonObject isKindOfClass:[NSDictionary class]]) {
+        callback(PushyErrorWithMessage(@"invalid patch manifest"));
+        return;
+    }
+    NSDictionary *json = (NSDictionary *)jsonObject;
 
     std::vector<std::string> entryNames;
     if ([[NSFileManager defaultManager] fileExistsAtPath:sourcePatch isDirectory:NULL]) {
@@ -661,30 +665,93 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
     callback(nil);
 }
 
-- (void)patch:(NSString *)hash
-         type:(PushyType)type
-   fromBundle:(NSString *)bundleOrigin
-       source:(NSString *)sourceOrigin
-     callback:(void (^)(NSError *error))callback
+- (BOOL)switchVersion:(NSString *)hash error:(NSError **)error
 {
-    [self _dopatch:hash type:type fromBundle:bundleOrigin source:sourceOrigin callback:callback];
+    if (PushyStringIsBlank(hash)) {
+        if (error != NULL) {
+            *error = PushyErrorWithMessage(ERROR_OPTIONS);
+        }
+        return NO;
+    }
+
+    NSUserDefaults *defaults = PushyDefaults();
+    pushy::state::State next = pushy::state::SwitchVersion(
+        PushyStateFromDefaults(defaults),
+        PushyToStdString(hash)
+    );
+    PushyApplyStateToDefaults(defaults, next);
+    return YES;
+}
+
+- (BOOL)ensureDirectoryExistsAtPath:(NSString *)path
+{
+    __block BOOL success = NO;
+
+    dispatch_sync(_fileQueue, ^{
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        BOOL isDirectory = NO;
+        if ([fileManager fileExistsAtPath:path isDirectory:&isDirectory]) {
+            success = isDirectory;
+            return;
+        }
+
+        NSError *error = nil;
+        success = [fileManager createDirectoryAtPath:path
+                         withIntermediateDirectories:YES
+                                          attributes:nil
+                                               error:&error];
+        if (!success && error != nil) {
+            RCTLogWarn(@"Pushy create directory error: %@", error.localizedDescription);
+        }
+    });
+
+    return success;
+}
+
+- (void)unzipFileAtPath:(NSString *)path
+          toDestination:(NSString *)destination
+      completionHandler:(void (^)(NSError *error))completionHandler
+{
+    dispatch_async(_fileQueue, ^{
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        if ([fileManager fileExistsAtPath:destination]) {
+            [fileManager removeItemAtPath:destination error:nil];
+        }
+
+        [SSZipArchive unzipFileAtPath:path
+                        toDestination:destination
+                      progressHandler:nil
+                    completionHandler:^(NSString *archivePath, BOOL succeeded, NSError *error) {
+            [fileManager removeItemAtPath:archivePath error:nil];
+            if (completionHandler == nil) {
+                return;
+            }
+
+            NSError *unzipError = error;
+            if (!succeeded && unzipError == nil) {
+                unzipError = PushyErrorWithMessage(@"unzip failed");
+            }
+            completionHandler(unzipError);
+        }];
+    });
 }
 
 - (void)clearInvalidFiles
 {
-    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-    pushy::state::State state = PushyStateFromDefaults(defaults);
-    
-    NSString *downloadDir = [RCTPushy downloadDir];
-    pushy::patch::Status status = pushy::patch::CleanupOldEntries(
-        PushyToStdString(downloadDir),
-        state.current_version,
-        state.last_version,
-        7
-    );
-    if (!status.ok) {
-        NSLog(@"Pushy cleanup error: %s", status.message.c_str());
-    }
+    dispatch_async(_fileQueue, ^{
+        NSUserDefaults *defaults = PushyDefaults();
+        pushy::state::State state = PushyStateFromDefaults(defaults);
+        NSString *downloadDir = [RCTPushy downloadDir];
+        pushy::patch::Status status = pushy::patch::CleanupOldEntries(
+            PushyToStdString(downloadDir),
+            state.current_version,
+            state.last_version,
+            7
+        );
+        if (!status.ok) {
+            RCTLogWarn(@"Pushy cleanup error: %s", status.message.c_str());
+        }
+    });
 }
 
 - (NSString *)zipExtension:(PushyType)type
@@ -697,29 +764,19 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
         case PushyTypePatchFromPpk:
             return @".ppk.patch";
         default:
-            break;
+            return @"";
     }
 }
 
-- (NSError *)errorWithMessage:(NSString *)errorMessage
-{
-    return [NSError errorWithDomain:@"cn.reactnative.pushy"
-                               code:-1
-                           userInfo:@{ NSLocalizedDescriptionKey: errorMessage}];
-}
-
 + (NSString *)downloadDir
 {
     NSString *directory = [NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES) firstObject];
-    NSString *downloadDir = [directory stringByAppendingPathComponent:@"rctpushy"];
-    
-    return downloadDir;
+    return [directory stringByAppendingPathComponent:@"rctpushy"];
 }
 
 + (NSURL *)binaryBundleURL
 {
-    NSURL *url = [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
-    return url;
+    return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
 }
 
 + (NSString *)packageVersion
@@ -750,7 +807,6 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
 #endif
 }
 
-// Thanks to this guard, we won't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params