@revopush/react-native-code-push 2.5.0 → 2.5.2

package/android/src/main/java/com/microsoft/codepush/react/CodePushUpdateManager.java

@@ -43,6 +43,10 @@ public class CodePushUpdateManager {
         return appendPathComponent(getCodePushPath(), CodePushConstants.UNZIPPED_FOLDER_NAME);
     }
 
+    private BaseBundleStore getBaseBundleStore() {
+        return new BaseBundleStore(appendPathComponent(getCodePushPath(), CodePushConstants.BASES_FOLDER_NAME));
+    }
+
     private String getDocumentsDirectory() {
         return mDocumentsDirectory;
     }
@@ -94,22 +98,22 @@ public class CodePushUpdateManager {
     }
 
     public String getCurrentPackageBundlePath(String bundleFileName) {
-        String packageFolder = getCurrentPackageFolderPath();
-        if (packageFolder == null) {
+        return getPackageBundlePath(getCurrentPackageHash(), bundleFileName);
+    }
+
+    private String getPackageBundlePath(String packageHash, String bundleFileName) {
+        if (packageHash == null) {
             return null;
         }
 
-        JSONObject currentPackage = getCurrentPackage();
-        if (currentPackage == null) {
+        JSONObject packageMetadata = getPackage(packageHash);
+        if (packageMetadata == null) {
             return null;
         }
 
-        String relativeBundlePath = currentPackage.optString(CodePushConstants.RELATIVE_BUNDLE_PATH_KEY, null);
-        if (relativeBundlePath == null) {
-            return appendPathComponent(packageFolder, bundleFileName);
-        } else {
-            return appendPathComponent(packageFolder, relativeBundlePath);
-        }
+        String relativeBundlePath = packageMetadata.optString(CodePushConstants.RELATIVE_BUNDLE_PATH_KEY, null);
+        return appendPathComponent(getPackageFolderPath(packageHash),
+                relativeBundlePath != null ? relativeBundlePath : bundleFileName);
     }
 
     public String getPackageFolderPath(String packageHash) {
@@ -154,7 +158,47 @@ public class CodePushUpdateManager {
         }
     }
 
+    /** A base bundle on disk, and the package hash it is stored under. */
+    private static final class BaseBundle {
+        final File file;
+        final String packageHash;
+
+        BaseBundle(File file, String packageHash) {
+            this.file = file;
+            this.packageHash = packageHash;
+        }
+    }
+
+    /** The base named by basePackage: the saved copy, else that package's own bundle. */
+    private BaseBundle findBaseBundle(JSONObject updatePackage, String expectedBundleFileName) {
+        JSONObject basePackage = updatePackage.optJSONObject(CodePushConstants.BASE_PACKAGE_KEY);
+        if (basePackage == null) {
+            return null;
+        }
+        String packageHash = basePackage.optString(CODE_PUSH_PACKAGE_HASH, null);
+        if (packageHash == null || packageHash.isEmpty()) {
+            // Named a base with no hash: server and SDK disagree on the field name.
+            CodePushUtils.log("basePackage has no packageHash; patching against the binary.");
+            return null;
+        }
+        File bundle = getBaseBundleStore().lookup(packageHash);
+        if (bundle == null) {
+            String bundlePath = getPackageBundlePath(packageHash, expectedBundleFileName);
+            bundle = bundlePath == null ? null : new File(bundlePath);
+        }
+        if (bundle == null || !bundle.isFile()) {
+            CodePushUtils.log("Base " + packageHash + " not held; patching against the binary.");
+            return null;
+        }
+        return new BaseBundle(bundle, packageHash);
+    }
+
     public void downloadPackage(JSONObject updatePackage, String expectedBundleFileName, DownloadProgressCallback progressCallback, String stringPublicKey) throws IOException {
+        BaseBundle base = findBaseBundle(updatePackage, expectedBundleFileName);
+        if (base != null) {
+            getBaseBundleStore().save(base.file, base.packageHash);
+        }
+
         UpdatePackage updatePack = fromJson(updatePackage);
 
         String newUpdateFolderPath = getPackageFolderPath(updatePack.getNewUpdateHash());
@@ -164,7 +208,8 @@ public class CodePushUpdateManager {
                 expectedBundleFileName, // exp bundle filename
                 stringPublicKey, // pub key
                 updatePack.getNewUpdateHash(), // new update hash
-                getCurrentPackage() // current package
+                getCurrentPackage(), // current package
+                base == null ? null : base.file.getAbsolutePath() // base bundle
         );
 
 

package/android/src/main/java/com/microsoft/codepush/react/FileUtils.java

@@ -27,11 +27,13 @@ public class FileUtils {
     public static void deleteFileOrFolderSilently(File file) {
         if (file.isDirectory()) {
             File[] files = file.listFiles();
-            for (File fileEntry : files) {
-                if (fileEntry.isDirectory()) {
-                    deleteFileOrFolderSilently(fileEntry);
-                } else {
-                    fileEntry.delete();
+            if (files != null) {
+                for (File fileEntry : files) {
+                    if (fileEntry.isDirectory()) {
+                        deleteFileOrFolderSilently(fileEntry);
+                    } else {
+                        fileEntry.delete();
+                    }
                 }
             }
         }

package/docs/setup-android.md

@@ -18,7 +18,7 @@ In order to integrate CodePush into your Android project, please perform the fol
 
 2. Update the `MainApplication` file to use CodePush via the following changes:
 
-   For React Native 0.76 and above: update the `MainApplication.kt`
+   For React Native 0.76 - 0.82: update the `MainApplication.kt`
 
    **Important! : PackageList must be instantiated only one in application lifetime.**
 
@@ -45,6 +45,32 @@ In order to integrate CodePush into your Android project, please perform the fol
     }
     ```
 
+    For React Native 0.83 and above: update the `MainApplication.kt`
+
+    ```kotlin
+    ...
+    // 1. Import the plugin class.
+    import com.microsoft.codepush.react.CodePush
+
+    class MainApplication : Application(), ReactApplication {
+
+        override val reactHost: ReactHost by lazy {
+            getDefaultReactHost(
+            context = applicationContext,
+            packageList =
+                PackageList(this).packages.apply {
+                // Packages that cannot be autolinked yet can be added manually here, for example:
+                // add(MyReactNativePackage())
+                },
+            // 2. Override the jsBundleFilePath in order to let
+            // the CodePush runtime determine where to get the JS
+            // bundle location from on each app start
+            jsBundleFilePath = CodePush.getJSBundleFile(),
+            )
+        }
+    }
+    ```
+
 
 3. Add the Deployment key to `strings.xml`:
 

package/ios/CodePush/CodePush.h

@@ -136,6 +136,7 @@
                        error:(NSError **)error;
 
 + (NSString *)getPackageFolderPath:(NSString *)packageHash;
++ (NSString *)getCodePushPath;
 
 + (BOOL)installPackage:(NSDictionary *)updatePackage
    removePendingUpdate:(BOOL)removePendingUpdate
@@ -149,6 +150,19 @@
 
 @end
 
+/**
+ * Bundles kept as diff bases, named by the package hash of the release they came from.
+ * A base a package folder no longer holds is still findable here.
+ */
+@interface CodePushBaseBundleStore : NSObject
+
+/** Path of the retained bundle for this package hash, or nil if the store does not hold it. */
++ (NSString *)lookup:(NSString *)packageHash;
+
++ (BOOL)save:(NSString *)sourceBundlePath forPackageHash:(NSString *)packageHash;
+
+@end
+
 @interface CodePushTelemetryManager : NSObject
 
 + (NSDictionary *)getBinaryUpdateReport:(NSString *)appVersion;

package/ios/CodePush/CodePush.m

@@ -19,7 +19,7 @@
 
 #import "CodePush.h"
 
-@interface CodePush () <RCTBridgeModule, RCTFrameUpdateObserver>
+@interface CodePush () <RCTBridgeModule>
 @end
 
 @implementation CodePush {
@@ -32,8 +32,8 @@
 
     // Used to coordinate the dispatching of download progress events to JS.
     long long _latestExpectedContentLength;
-    long long _latestReceivedConentLength;
-    BOOL _didUpdateProgress;
+    long long _latestReceivedContentLength;
+    NSTimeInterval _lastProgressEmitTimestamp;
 
     BOOL _allowed;
     BOOL _restartInProgress;
@@ -263,18 +263,6 @@ static NSString *const LatestRollbackCountKey = @"count";
 #pragma mark - Private API methods
 
 @synthesize methodQueue = _methodQueue;
-@synthesize pauseCallback = _pauseCallback;
-@synthesize paused = _paused;
-
-- (void)setPaused:(BOOL)paused
-{
-    if (_paused != paused) {
-        _paused = paused;
-        if (_pauseCallback) {
-            _pauseCallback();
-        }
-    }
-}
 
 /*
  * This method is used to clear updates that are installed
@@ -340,7 +328,7 @@ static NSString *const LatestRollbackCountKey = @"count";
                        @"totalBytes" : [NSNumber
                            numberWithLongLong:_latestExpectedContentLength],
                        @"receivedBytes" : [NSNumber
-                           numberWithLongLong:_latestReceivedConentLength]
+                           numberWithLongLong:_latestReceivedContentLength]
                      }];
 }
 
@@ -404,7 +392,6 @@ static NSString *const LatestRollbackCountKey = @"count";
 #ifdef DEBUG
     [self clearDebugUpdates];
 #endif
-    self.paused = YES;
     NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
     NSDictionary *pendingUpdate = [preferences objectForKey:PendingUpdateKey];
     if (pendingUpdate) {
@@ -546,7 +533,7 @@ static NSString *const LatestRollbackCountKey = @"count";
         // file (since Chrome wouldn't support it). Otherwise, update
         // the current bundle URL to point at the latest update
         if ([CodePush isUsingTestConfiguration] || ![super.bridge.bundleURL.scheme hasPrefix:@"http"]) {
-            [super.bridge setValue:[CodePush bundleURL] forKey:@"bundleURL"];
+            RCTReloadCommandSetBundleURL([CodePush bundleURL]);
         }
 
         RCTTriggerReloadCommandListeners(@"react-native-code-push: Restart");
@@ -727,10 +714,7 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
     }
 
     if (notifyProgress) {
-        // Set up and unpause the frame observer so that it can emit
-        // progress events every frame if the progress is updated.
-        _didUpdateProgress = NO;
-        self.paused = NO;
+        _lastProgressEmitTimestamp = 0;
     }
 
     NSString * publicKey = [[CodePushConfig current] publicKey];
@@ -742,17 +726,21 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
         operationQueue:_methodQueue
         // The download is progressing forward
         progressCallback:^(long long expectedContentLength, long long receivedContentLength) {
-            // Update the download progress so that the frame observer can notify the JS side
+            if (!notifyProgress) {
+                return;
+            }
+
             _latestExpectedContentLength = expectedContentLength;
-            _latestReceivedConentLength = receivedContentLength;
-            _didUpdateProgress = YES;
+            _latestReceivedContentLength = receivedContentLength;
 
-            // If the download is completed, stop observing frame
-            // updates and synchronously send the last event.
             if (expectedContentLength == receivedContentLength) {
-                _didUpdateProgress = NO;
-                self.paused = YES;
                 [self dispatchDownloadProgressEvent];
+            } else {
+                NSTimeInterval timestamp = [[NSDate date] timeIntervalSince1970];
+                if (timestamp - _lastProgressEmitTimestamp > 0.3) {
+                    _lastProgressEmitTimestamp = timestamp;
+                    [self dispatchDownloadProgressEvent];
+                }
             }
         }
         // The download completed
@@ -773,9 +761,6 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
                 [self saveFailedUpdate:mutableUpdatePackage];
             }
 
-            // Stop observing frame updates if the download fails.
-            _didUpdateProgress = NO;
-            self.paused = YES;
             reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
         }];
 }
@@ -1128,16 +1113,4 @@ RCT_EXPORT_METHOD(saveStatusReportForRetry:(NSDictionary *)statusReport)
     [CodePushTelemetryManager saveStatusReportForRetry:statusReport];
 }
 
-#pragma mark - RCTFrameUpdateObserver Methods
-
-- (void)didUpdateFrame:(RCTFrameUpdate *)update
-{
-    if (!_didUpdateProgress) {
-        return;
-    }
-
-    [self dispatchDownloadProgressEvent];
-    _didUpdateProgress = NO;
-}
-
 @end

package/ios/CodePush/CodePushBaseBundleStore.m

@@ -0,0 +1,104 @@
+#import "CodePush.h"
+
+// CPLog
+#import <DiffUpdates/DiffUpdates.h>
+
+@implementation CodePushBaseBundleStore
+
+static NSString *const BasesFolderName = @"bases";
+static const NSUInteger MaxSavedBases = 3;
+
++ (NSString *)lookup:(NSString *)packageHash
+{
+    NSString *path = [self pathForPackageHash:packageHash];
+    return path && [[NSFileManager defaultManager] fileExistsAtPath:path] ? path : nil;
+}
+
+/**
+ * Copies the bundle into the store so it outlives its package folder: installPackage deletes the
+ * previous package on every install, but the server can still name that release as a diff base.
+ * Never fails an update - a base we could not save is simply one we do not hold.
+ */
++ (BOOL)save:(NSString *)sourceBundlePath forPackageHash:(NSString *)packageHash
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSString *destinationPath = [self pathForPackageHash:packageHash];
+    if (!destinationPath || ![fileManager fileExistsAtPath:sourceBundlePath]) {
+        return NO;
+    }
+
+    if ([fileManager fileExistsAtPath:destinationPath]) {
+        [self touch:destinationPath];
+        return YES;
+    }
+
+    // Copied aside and renamed: a copy cut short by process death must not leave a truncated file
+    // under the hash, which lookup would then hand out forever.
+    NSString *tempPath = [destinationPath stringByAppendingPathExtension:@"tmp"];
+    [fileManager removeItemAtPath:tempPath error:nil];
+
+    NSError *error = nil;
+    if (![fileManager createDirectoryAtPath:[self basesFolderPath] withIntermediateDirectories:YES attributes:nil error:&error]
+            || ![fileManager copyItemAtPath:sourceBundlePath toPath:tempPath error:&error]
+            || ![fileManager moveItemAtPath:tempPath toPath:destinationPath error:&error]) {
+        CPLog(@"Could not save base bundle %@: %@", packageHash, error);
+        [fileManager removeItemAtPath:tempPath error:nil];
+        return NO;
+    }
+
+    [self touch:destinationPath];
+    [self evict];
+    return YES;
+}
+
++ (NSString *)basesFolderPath
+{
+    return [[CodePushPackage getCodePushPath] stringByAppendingPathComponent:BasesFolderName];
+}
+
+/** An entry is named by its hash alone, so a hash naming anything else is refused. */
++ (NSString *)pathForPackageHash:(NSString *)packageHash
+{
+    if (packageHash.length == 0
+            || [packageHash isEqualToString:@".."]
+            || ![packageHash isEqualToString:packageHash.lastPathComponent]) {
+        return nil;
+    }
+
+    return [[self basesFolderPath] stringByAppendingPathComponent:packageHash];
+}
+
+// A copy keeps the source's timestamp and reuse has to count as use, so the store stamps every
+// save itself. evict orders by this.
++ (void)touch:(NSString *)path
+{
+    [[NSFileManager defaultManager] setAttributes:@{NSFileModificationDate: [NSDate date]}
+                                     ofItemAtPath:path
+                                            error:nil];
+}
+
+/** Keeps the MaxSavedBases most recently saved entries. */
++ (void)evict
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSArray<NSURL *> *entries = [fileManager contentsOfDirectoryAtURL:[NSURL fileURLWithPath:[self basesFolderPath]]
+                                          includingPropertiesForKeys:@[NSURLContentModificationDateKey]
+                                                             options:0
+                                                               error:nil];
+    if (entries.count <= MaxSavedBases) {
+        return;
+    }
+
+    NSArray<NSURL *> *oldestFirst = [entries sortedArrayUsingComparator:^(NSURL *a, NSURL *b) {
+        NSDate *dateA = nil, *dateB = nil;
+        [a getResourceValue:&dateA forKey:NSURLContentModificationDateKey error:nil];
+        [b getResourceValue:&dateB forKey:NSURLContentModificationDateKey error:nil];
+        return [dateA compare:dateB];
+    }];
+
+    for (NSUInteger i = 0; i < oldestFirst.count - MaxSavedBases; i++) {
+        [fileManager removeItemAtURL:oldestFirst[i] error:nil];
+    }
+}
+
+@end

package/ios/CodePush/CodePushPackage.m

@@ -90,12 +90,26 @@ static NSString *const UnzippedFolderName = @"unzipped";
     NSString *singleUrl = updatePackage[@"downloadUrl"] ?: updatePackage[@"download_url"];
 
     __block BOOL cameFromDiffHandler = (bundleDiffUrl.length > 0);
-
+    __block BOOL fallbackStarted = NO;
+    // Assigned below. commonDone reaches back into it to retry a diff that verified badly.
+    __block void (^startFullDownload)(void) = nil;
 
     void (^commonDone)(BOOL) = ^(BOOL isZip) {
         NSError *error = nil;
         NSString * unzippedFolderPath = [CodePushPackage getUnzippedFolderPath];
         NSMutableDictionary * mutableUpdatePackage = [updatePackage mutableCopy];
+
+        // A diff patched against the wrong base still produces a well-formed folder, just one
+        // holding the wrong bytes. Retry as a full download rather than failing the update.
+        BOOL (^recoverFromIntegrityFailure)(void) = ^BOOL {
+            if (!cameFromDiffHandler || fallbackStarted || singleUrl.length == 0) {
+                return NO;
+            }
+            CPLog(@"Falling back to a full download.");
+            startFullDownload();
+            return YES;
+        };
+
         if (isZip) {
             if ([[NSFileManager defaultManager] fileExistsAtPath:unzippedFolderPath]) {
                 // This removes any unzipped download data that could have been left
@@ -257,6 +271,9 @@ static NSString *const UnzippedFolderName = @"unzipped";
                                                   expectedHash:newUpdateHash
                                                          error:&error]) {
                         CPLog(@"The update contents failed the data integrity check.");
+                        if (recoverFromIntegrityFailure()) {
+                            return;
+                        }
                         if (!error) {
                             error = [CodePushErrorUtils errorWithMessage:@"The update contents failed the data integrity check."];
                         }
@@ -305,6 +322,9 @@ static NSString *const UnzippedFolderName = @"unzipped";
                                                   expectedHash:newUpdateHash
                                                          error:&error]) {
                         CPLog(@"The update contents failed the data integrity check.");
+                        if (recoverFromIntegrityFailure()) {
+                            return;
+                        }
                         if (!error) {
                             error = [CodePushErrorUtils errorWithMessage:@"The update contents failed the data integrity check."];
                         }
@@ -347,15 +367,16 @@ static NSString *const UnzippedFolderName = @"unzipped";
         }
     };
 
-    __block BOOL fallbackStarted = NO;
-
-    void (^startFullDownload)(void) = ^{
+    startFullDownload = ^{
         if (fallbackStarted) return;
         fallbackStarted = YES;
 
         NSError *cleanupErr = nil;
         [[NSFileManager defaultManager] removeItemAtPath:downloadFilePath error:&cleanupErr];
         [[NSFileManager defaultManager] removeItemAtPath:[CodePushPackage getUnzippedFolderPath] error:nil];
+        // A diff that got as far as the integrity check already assembled this folder. Whatever it
+        // left behind is wrong, and copyEntriesInFolder overlays rather than replaces.
+        [[NSFileManager defaultManager] removeItemAtPath:newUpdateFolderPath error:nil];
 
         CodePushDownloadHandler *downloadHandler = [[CodePushDownloadHandler alloc]
             init:downloadFilePath
@@ -378,8 +399,12 @@ static NSString *const UnzippedFolderName = @"unzipped";
 
 
     if (cameFromDiffHandler) {
-        NSString *assetsUrl = updatePackage[@"assetDownloadUrl"] ?: updatePackage[@"asset_download_url"];
-        NSString *assetHash = updatePackage[@"assetHash"] ?: updatePackage[@"asset_hash"];
+        // Retained now: this is the last moment we know the release naming it is still on disk.
+        NSString *baseHash = [self basePackageHash:updatePackage];
+        NSString *baseBundlePath = [self findBaseBundleForPackageHash:baseHash];
+        if (baseBundlePath) {
+            [CodePushBaseBundleStore save:baseBundlePath forPackageHash:baseHash];
+        }
 
         NSError *pkgErr = nil;
         NSDictionary *currentPackage = [CodePushPackage getCurrentPackage:&pkgErr];
@@ -396,10 +421,13 @@ static NSString *const UnzippedFolderName = @"unzipped";
 
         CPLog(@"Diff download handler");
 
-        [diffHandler downloadWithDiffUrl:bundleDiffUrl assetsUrl:assetsUrl assetHash:assetHash nativeAssetHash:nativeAssetHash currentPackage:currentPackage];
+        [diffHandler downloadWithDiffUrl:bundleDiffUrl
+                               assetsUrl:assetsUrl
+                               assetHash:assetHash
+                         nativeAssetHash:nativeAssetHash
+                          currentPackage:currentPackage
+                          baseBundlePath:baseBundlePath];
     } else {
-        NSString *singleUrl = updatePackage[@"downloadUrl"] ?: updatePackage[@"download_url"];
-
         CodePushDownloadHandler *downloadHandler = [[CodePushDownloadHandler alloc]
                 init:downloadFilePath
                 operationQueue:operationQueue
@@ -540,6 +568,51 @@ static NSString *const UnzippedFolderName = @"unzipped";
     return [[self getCodePushPath] stringByAppendingPathComponent:packageHash];
 }
 
+/** The package hash the server named as the diff base, or nil if it named none we can use. */
++ (NSString *)basePackageHash:(NSDictionary *)updatePackage
+{
+    NSDictionary *basePackage = updatePackage[@"basePackage"];
+    if (![basePackage isKindOfClass:NSDictionary.class]) {
+        return nil;
+    }
+
+    NSString *packageHash = basePackage[@"packageHash"];
+    if (packageHash.length == 0) {
+        // Named a base with no hash: server and SDK disagree on the field name.
+        CPLog(@"basePackage has no packageHash. Patching against the binary.");
+        return nil;
+    }
+
+    return packageHash;
+}
+
+/**
+ * The bundle to patch against: the retained copy of that release, else the release's own bundle
+ * while its package folder still exists. nil means patch against the binary's bundle instead.
+ */
++ (NSString *)findBaseBundleForPackageHash:(NSString *)packageHash
+{
+    if (packageHash.length == 0) {
+        return nil;
+    }
+
+    NSString *bundlePath = [CodePushBaseBundleStore lookup:packageHash];
+    if (bundlePath) {
+        return bundlePath;
+    }
+
+    NSString *relativeBundlePath = [self getPackage:packageHash error:nil][RelativeBundlePathKey];
+    bundlePath = relativeBundlePath.length > 0
+            ? [[self getPackageFolderPath:packageHash] stringByAppendingPathComponent:relativeBundlePath]
+            : nil;
+    if (bundlePath && [[NSFileManager defaultManager] fileExistsAtPath:bundlePath]) {
+        return bundlePath;
+    }
+
+    CPLog(@"Base %@ not held. Patching against the binary.", packageHash);
+    return nil;
+}
+
 + (NSDictionary *)getPreviousPackage:(NSError **)error
 {
     NSString *packageHash = [self getPreviousPackageHash:error];

package/ios/CodePush/CodePushUpdateUtils.m

@@ -197,16 +197,24 @@ NSString * const IgnoreCodePushMetadata = @".codepushrelease";
     return AssetsFolderName;
 }
 
++ (NSString *)cacheKeyForBinaryAtURL:(NSURL *)binaryBundleUrl
+{
+    NSString *bundleModifiedDate = [self modifiedDateStringOfFileAtURL:binaryBundleUrl];
+    return [NSString stringWithFormat:@"%@:%@",
+            [[NSBundle mainBundle] bundlePath],
+            bundleModifiedDate ?: @"unknown"];
+}
+
 + (NSString *)getHashForBinaryContents:(NSURL *)binaryBundleUrl
                                  error:(NSError **)error
 {
     // Get the cached hash from user preferences if it exists.
-    NSString *binaryModifiedDate = [self modifiedDateStringOfFileAtURL:binaryBundleUrl];
+    NSString *binaryCacheKey = [self cacheKeyForBinaryAtURL:binaryBundleUrl];
     NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
     NSMutableDictionary *binaryHashDictionary = [preferences objectForKey:BinaryHashKey];
     NSString *binaryHash = nil;
     if (binaryHashDictionary != nil) {
-        binaryHash = [binaryHashDictionary objectForKey:binaryModifiedDate];
+        binaryHash = [binaryHashDictionary objectForKey:binaryCacheKey];
         if (binaryHash == nil) {
             [preferences removeObjectForKey:BinaryHashKey];
             [preferences synchronize];
@@ -237,9 +245,7 @@ NSString * const IgnoreCodePushMetadata = @".codepushrelease";
 
     binaryHash = [self computeFinalHashFromManifest:manifest error:error];
 
-    // Cache the hash in user preferences. This assumes that the modified date for the
-    // JS bundle changes every time a new bundle is generated by the packager.
-    [binaryHashDictionary setObject:binaryHash forKey:binaryModifiedDate];
+    [binaryHashDictionary setObject:binaryHash forKey:binaryCacheKey];
     [preferences setObject:binaryHashDictionary forKey:BinaryHashKey];
     [preferences synchronize];
     return binaryHash;
@@ -255,11 +261,10 @@ NSString * const IgnoreCodePushMetadata = @".codepushrelease";
     NSUserDefaults *preferences = [NSUserDefaults standardUserDefaults];
     NSMutableDictionary *assetsHashDictionary = [preferences objectForKey:BinaryAssetsHashKey];
 
-    NSString *assetsModifiedDate = [self modifiedDateStringOfFileAtURL:
-                                    [NSURL fileURLWithPath:assetsPath isDirectory:YES]];
+    NSString *assetsCacheKey = [self cacheKeyForBinaryAtURL:[CodePush binaryBundleURL]];
 
     if (assetsHashDictionary != nil) {
-        NSString *cached = [assetsHashDictionary objectForKey:assetsModifiedDate];
+        NSString *cached = [assetsHashDictionary objectForKey:assetsCacheKey];
         if (cached != nil) {
             return cached;
         } else {
@@ -285,7 +290,7 @@ NSString * const IgnoreCodePushMetadata = @".codepushrelease";
         return nil;
     }
 
-    [assetsHashDictionary setObject:assetsHash forKey:assetsModifiedDate];
+    [assetsHashDictionary setObject:assetsHash forKey:assetsCacheKey];
     [preferences setObject:assetsHashDictionary forKey:BinaryAssetsHashKey];
     [preferences synchronize];