style(CodePush): Minor cosmetic changes throughout project (#549)

rozele · geof90 · commit 9396824ba14a · 2016-10-04T12:57:30.000-07:00
Includes the following changes:
* UpdateState.Lastest -&gt; UpdateState.Latest
* Added *Async suffix to Task returning methods
* Using DateTimeOffset in MinimumBackgroundListener
* Disposing IDisposable streams in UpdateManager.DownloadPackage
diff --git a/windows/CodePushConstants.cs b/windows/CodePushConstants.cs
@@ -21,7 +21,7 @@ internal class CodePushConstants
         internal const string PendingUpdateKey = "CODE_PUSH_PENDING_UPDATE";
         internal const string PendingUpdateIsLoadingKey = "isLoading";
         internal const string PreviousPackageKey = "previousPackage";
-        // This needs to be kept in sync with https://github.com/facebook/react-native/blob/master/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManager.java#L78
+        // This needs to be kept in sync with https://github.com/ReactWindows/react-native-windows/blob/master/ReactWindows/ReactNative/DevSupport/DevSupportManager.cs#L22
         internal const string ReactDevBundleCacheFileName = "ReactNativeDevBundle.js";
         internal const string ReactNativeLogCategory = "ReactNative";
         internal const string RelativeBundlePathKey = "bundlePath";
diff --git a/windows/CodePushNativeModule.cs b/windows/CodePushNativeModule.cs
@@ -42,7 +42,7 @@ public override IReadOnlyDictionary<string, object> Constants
                     { "codePushInstallModeOnNextRestart", InstallMode.OnNextRestart },
                     { "codePushUpdateStateRunning", UpdateState.Running },
                     { "codePushUpdateStatePending", UpdateState.Pending },
-                    { "codePushUpdateStateLatest", UpdateState.Lastest },
+                    { "codePushUpdateStateLatest", UpdateState.Latest },
                 };
             }
         }
@@ -59,8 +59,8 @@ public void downloadUpdate(JObject updatePackage, bool notifyProgress, IPromise
             {
                 try
                 {
-                    updatePackage[CodePushConstants.BinaryModifiedTimeKey] = "" + await _codePush.GetBinaryResourcesModifiedTime();
-                    await _codePush.UpdateManager.DownloadPackage(
+                    updatePackage[CodePushConstants.BinaryModifiedTimeKey] = "" + await _codePush.GetBinaryResourcesModifiedTimeAsync();
+                    await _codePush.UpdateManager.DownloadPackageAsync(
                         updatePackage,
                         _codePush.AssetsBundleFileName,
                         new Progress<HttpProgress>(
@@ -84,7 +84,7 @@ await _codePush.UpdateManager.DownloadPackage(
                         )
                     );
 
-                    JObject newPackage = await _codePush.UpdateManager.GetPackage((string)updatePackage[CodePushConstants.PackageHashKey]);
+                    JObject newPackage = await _codePush.UpdateManager.GetPackageAsync((string)updatePackage[CodePushConstants.PackageHashKey]);
                     promise.Resolve(newPackage);
                 }
                 catch (InvalidDataException e)
@@ -128,7 +128,7 @@ public void getUpdateMetadata(UpdateState updateState, IPromise promise)
         {
             Action getCurrentPackageAction = async () =>
             {
-                JObject currentPackage = await _codePush.UpdateManager.GetCurrentPackage();
+                JObject currentPackage = await _codePush.UpdateManager.GetCurrentPackageAsync();
                 if (currentPackage == null)
                 {
                     promise.Resolve("");
@@ -153,7 +153,7 @@ public void getUpdateMetadata(UpdateState updateState, IPromise promise)
                 {
                     // The caller wants the running update, but the current
                     // one is pending, so we need to grab the previous.
-                    promise.Resolve(await _codePush.UpdateManager.GetPreviousPackage());
+                    promise.Resolve(await _codePush.UpdateManager.GetPreviousPackageAsync());
                 }
                 else
                 {
@@ -191,7 +191,7 @@ public void installUpdate(JObject updatePackage, InstallMode installMode, int mi
         {
             Action installUpdateAction = async () =>
             {
-                await _codePush.UpdateManager.InstallPackage(updatePackage, SettingsManager.IsPendingUpdate(null));
+                await _codePush.UpdateManager.InstallPackageAsync(updatePackage, SettingsManager.IsPendingUpdate(null));
                 var pendingHash = (string)updatePackage[CodePushConstants.PackageHashKey];
                 SettingsManager.SavePendingUpdate(pendingHash, /* isLoading */false);
                 if (installMode == InstallMode.OnNextResume)
@@ -203,7 +203,7 @@ public void installUpdate(JObject updatePackage, InstallMode installMode, int mi
                         {
                             Context.RunOnNativeModulesQueueThread(async () =>
                             {
-                                await LoadBundle();
+                                await LoadBundleAsync();
                             });
                         };
                         
@@ -236,7 +236,7 @@ public void isFirstRun(string packageHash, IPromise promise)
                 bool isFirstRun = _codePush.DidUpdate
                     && packageHash != null
                     && packageHash.Length > 0
-                    && packageHash.Equals(await _codePush.UpdateManager.GetCurrentPackageHash());
+                    && packageHash.Equals(await _codePush.UpdateManager.GetCurrentPackageHashAsync());
                 promise.Resolve(isFirstRun);
             };
 
@@ -259,14 +259,14 @@ public void restartApp(bool onlyIfUpdateIsPending)
                 // is current pending update, then reload the app.
                 if (!onlyIfUpdateIsPending || SettingsManager.IsPendingUpdate(null))
                 {
-                    await LoadBundle();
+                    await LoadBundleAsync();
                 }
             };
 
             Context.RunOnNativeModulesQueueThread(restartAppAction);
         }
         
-        internal async Task LoadBundle()
+        internal async Task LoadBundleAsync()
         {
             // #1) Get the private ReactInstanceManager, which is what includes
             //     the logic to reload the current React context.
diff --git a/windows/CodePushReactPackage.cs b/windows/CodePushReactPackage.cs
@@ -85,8 +85,8 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa
         {
             AssetsBundleFileName = assetsBundleFileName;
             string binaryJsBundleUrl = CodePushConstants.AssetsBundlePrefix + assetsBundleFileName;
-            var binaryResourcesModifiedTime = await GetBinaryResourcesModifiedTime();
-            var packageFile = await UpdateManager.GetCurrentPackageBundle(AssetsBundleFileName);
+            var binaryResourcesModifiedTime = await GetBinaryResourcesModifiedTimeAsync();
+            var packageFile = await UpdateManager.GetCurrentPackageBundleAsync(AssetsBundleFileName);
             if (packageFile == null)
             {
                 // There has not been any downloaded updates.
@@ -95,7 +95,7 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa
                 return binaryJsBundleUrl;
             }
 
-            var packageMetadata = await UpdateManager.GetCurrentPackage();
+            var packageMetadata = await UpdateManager.GetCurrentPackageAsync();
             long? binaryModifiedDateDuringPackageInstall = null;
             var binaryModifiedDateDuringPackageInstallString = (string)packageMetadata[CodePushConstants.BinaryModifiedTimeKey];
             if (binaryModifiedDateDuringPackageInstallString != null)
@@ -119,7 +119,7 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa
                 DidUpdate = false;
                 if (!MainPage.UseDeveloperSupport || !AppVersion.Equals(packageAppVersion))
                 {
-                    await ClearUpdates();
+                    await ClearUpdatesAsync();
                 }
 
                 CodePushUtils.LogBundleUrl(binaryJsBundleUrl);
@@ -132,7 +132,7 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa
 
         #region Internal methods
 
-        internal async Task<long> GetBinaryResourcesModifiedTime()
+        internal async Task<long> GetBinaryResourcesModifiedTimeAsync()
         {
             var assetJSBundleFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(CodePushConstants.AssetsBundlePrefix + AssetsBundleFileName));
             var fileProperties = await assetJSBundleFile.GetBasicPropertiesAsync();
@@ -151,15 +151,15 @@ internal void InitializeUpdateAfterRestart()
                     // Therefore, deduce that it is a broken update and rollback.
                     CodePushUtils.Log("Update did not finish loading the last time, rolling back to a previous version.");
                     NeedToReportRollback = true;
-                    RollbackPackage().Wait();
+                    RollbackPackageAsync().Wait();
                 }
                 else
                 {
                     DidUpdate = true;
                     // Clear the React dev bundle cache so that new updates can be loaded.
                     if (MainPage.UseDeveloperSupport)
                     {
-                        ClearReactDevBundleCache().Wait();
+                        ClearReactDevBundleCacheAsync().Wait();
                     }
                     // Mark that we tried to initialize the new update, so that if it crashes,
                     // we will know that we need to rollback when the app next starts.
@@ -168,9 +168,9 @@ internal void InitializeUpdateAfterRestart()
             }
         }
 
-        internal async Task ClearUpdates()
+        internal async Task ClearUpdatesAsync()
         {
-            await UpdateManager.ClearUpdates();
+            await UpdateManager.ClearUpdatesAsync();
             SettingsManager.RemovePendingUpdate();
             SettingsManager.RemoveFailedUpdates();
         }
@@ -179,7 +179,7 @@ internal async Task ClearUpdates()
 
         #region Private methods
 
-        private async Task ClearReactDevBundleCache()
+        private async Task ClearReactDevBundleCacheAsync()
         {
             var devBundleCacheFile = (StorageFile) await ApplicationData.Current.LocalFolder.TryGetItemAsync(CodePushConstants.ReactDevBundleCacheFileName);
             if (devBundleCacheFile != null)
@@ -188,11 +188,11 @@ private async Task ClearReactDevBundleCache()
             }
         }
 
-        private async Task RollbackPackage()
+        private async Task RollbackPackageAsync()
         {
-            JObject failedPackage = await UpdateManager.GetCurrentPackage();
+            JObject failedPackage = await UpdateManager.GetCurrentPackageAsync();
             SettingsManager.SaveFailedUpdate(failedPackage);
-            await UpdateManager.RollbackPackage();
+            await UpdateManager.RollbackPackageAsync();
             SettingsManager.RemovePendingUpdate();
         }
 
diff --git a/windows/MinimumBackgroundListener.cs b/windows/MinimumBackgroundListener.cs
@@ -5,7 +5,7 @@ namespace CodePush.ReactNative
 {
     internal class MinimumBackgroundListener : ILifecycleEventListener
     {
-        private DateTime? _lastSuspendDate;
+        private DateTimeOffset? _lastSuspendDate;
         private Action _resumeAction;
 
         internal int MinimumBackgroundDuration { get; set; }
@@ -26,7 +26,7 @@ public void OnResume()
             {
                 // Determine how long the app was in the background and ensure
                 // that it meets the minimum duration amount of time.
-                double durationInBackground = (new DateTime() - (DateTime)_lastSuspendDate).TotalSeconds;
+                double durationInBackground = (DateTimeOffset.Now - _lastSuspendDate.Value).TotalSeconds;
                 if (durationInBackground >= MinimumBackgroundDuration)
                 {
                     _resumeAction.Invoke();
@@ -38,7 +38,7 @@ public void OnSuspend()
         {
             // Save the current time so that when the app is later
             // resumed, we can detect how long it was in the background.
-            _lastSuspendDate = new DateTime();
+            _lastSuspendDate = DateTimeOffset.Now;
         }
     }
 }
diff --git a/windows/UpdateManager.cs b/windows/UpdateManager.cs
diff --git a/windows/UpdateState.cs b/windows/UpdateState.cs

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public override IReadOnlyDictionary<string, object> Constants`
`42`	`42`	`{ "codePushInstallModeOnNextRestart", InstallMode.OnNextRestart },`
`43`	`43`	`{ "codePushUpdateStateRunning", UpdateState.Running },`
`44`	`44`	`{ "codePushUpdateStatePending", UpdateState.Pending },`
`45`		`- { "codePushUpdateStateLatest", UpdateState.Lastest },`
	`45`	`+ { "codePushUpdateStateLatest", UpdateState.Latest },`
`46`	`46`	`};`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -59,8 +59,8 @@ public void downloadUpdate(JObject updatePackage, bool notifyProgress, IPromise`
`59`	`59`	`{`
`60`	`60`	`try`
`61`	`61`	`{`
`62`		`- updatePackage[CodePushConstants.BinaryModifiedTimeKey] = "" + await _codePush.GetBinaryResourcesModifiedTime();`
`63`		`- await _codePush.UpdateManager.DownloadPackage(`
	`62`	`+ updatePackage[CodePushConstants.BinaryModifiedTimeKey] = "" + await _codePush.GetBinaryResourcesModifiedTimeAsync();`
	`63`	`+ await _codePush.UpdateManager.DownloadPackageAsync(`
`64`	`64`	`updatePackage,`
`65`	`65`	`_codePush.AssetsBundleFileName,`
`66`	`66`	`new Progress<HttpProgress>(`
`@@ -84,7 +84,7 @@ await _codePush.UpdateManager.DownloadPackage(`
`84`	`84`	`)`
`85`	`85`	`);`
`86`	`86`
`87`		`- JObject newPackage = await _codePush.UpdateManager.GetPackage((string)updatePackage[CodePushConstants.PackageHashKey]);`
	`87`	`+ JObject newPackage = await _codePush.UpdateManager.GetPackageAsync((string)updatePackage[CodePushConstants.PackageHashKey]);`
`88`	`88`	`promise.Resolve(newPackage);`
`89`	`89`	`}`
`90`	`90`	`catch (InvalidDataException e)`
`@@ -128,7 +128,7 @@ public void getUpdateMetadata(UpdateState updateState, IPromise promise)`
`128`	`128`	`{`
`129`	`129`	`Action getCurrentPackageAction = async () =>`
`130`	`130`	`{`
`131`		`- JObject currentPackage = await _codePush.UpdateManager.GetCurrentPackage();`
	`131`	`+ JObject currentPackage = await _codePush.UpdateManager.GetCurrentPackageAsync();`
`132`	`132`	`if (currentPackage == null)`
`133`	`133`	`{`
`134`	`134`	`promise.Resolve("");`
`@@ -153,7 +153,7 @@ public void getUpdateMetadata(UpdateState updateState, IPromise promise)`
`153`	`153`	`{`
`154`	`154`	`// The caller wants the running update, but the current`
`155`	`155`	`// one is pending, so we need to grab the previous.`
`156`		`- promise.Resolve(await _codePush.UpdateManager.GetPreviousPackage());`
	`156`	`+ promise.Resolve(await _codePush.UpdateManager.GetPreviousPackageAsync());`
`157`	`157`	`}`
`158`	`158`	`else`
`159`	`159`	`{`
`@@ -191,7 +191,7 @@ public void installUpdate(JObject updatePackage, InstallMode installMode, int mi`
`191`	`191`	`{`
`192`	`192`	`Action installUpdateAction = async () =>`
`193`	`193`	`{`
`194`		`- await _codePush.UpdateManager.InstallPackage(updatePackage, SettingsManager.IsPendingUpdate(null));`
	`194`	`+ await _codePush.UpdateManager.InstallPackageAsync(updatePackage, SettingsManager.IsPendingUpdate(null));`
`195`	`195`	`var pendingHash = (string)updatePackage[CodePushConstants.PackageHashKey];`
`196`	`196`	`SettingsManager.SavePendingUpdate(pendingHash, /* isLoading */false);`
`197`	`197`	`if (installMode == InstallMode.OnNextResume)`
`@@ -203,7 +203,7 @@ public void installUpdate(JObject updatePackage, InstallMode installMode, int mi`
`203`	`203`	`{`
`204`	`204`	`Context.RunOnNativeModulesQueueThread(async () =>`
`205`	`205`	`{`
`206`		`- await LoadBundle();`
	`206`	`+ await LoadBundleAsync();`
`207`	`207`	`});`
`208`	`208`	`};`
`209`	`209`
`@@ -236,7 +236,7 @@ public void isFirstRun(string packageHash, IPromise promise)`
`236`	`236`	`bool isFirstRun = _codePush.DidUpdate`
`237`	`237`	`&& packageHash != null`
`238`	`238`	`&& packageHash.Length > 0`
`239`		`- && packageHash.Equals(await _codePush.UpdateManager.GetCurrentPackageHash());`
	`239`	`+ && packageHash.Equals(await _codePush.UpdateManager.GetCurrentPackageHashAsync());`
`240`	`240`	`promise.Resolve(isFirstRun);`
`241`	`241`	`};`
`242`	`242`
`@@ -259,14 +259,14 @@ public void restartApp(bool onlyIfUpdateIsPending)`
`259`	`259`	`// is current pending update, then reload the app.`
`260`	`260`	`if (!onlyIfUpdateIsPending \|\| SettingsManager.IsPendingUpdate(null))`
`261`	`261`	`{`
`262`		`- await LoadBundle();`
	`262`	`+ await LoadBundleAsync();`
`263`	`263`	`}`
`264`	`264`	`};`
`265`	`265`
`266`	`266`	`Context.RunOnNativeModulesQueueThread(restartAppAction);`
`267`	`267`	`}`
`268`	`268`
`269`		`- internal async Task LoadBundle()`
	`269`	`+ internal async Task LoadBundleAsync()`
`270`	`270`	`{`
`271`	`271`	`// #1) Get the private ReactInstanceManager, which is what includes`
`272`	`272`	`// the logic to reload the current React context.`
Original file line number	Diff line number	Diff line change
`@@ -85,8 +85,8 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa`
`85`	`85`	`{`
`86`	`86`	`AssetsBundleFileName = assetsBundleFileName;`
`87`	`87`	`string binaryJsBundleUrl = CodePushConstants.AssetsBundlePrefix + assetsBundleFileName;`
`88`		`- var binaryResourcesModifiedTime = await GetBinaryResourcesModifiedTime();`
`89`		`- var packageFile = await UpdateManager.GetCurrentPackageBundle(AssetsBundleFileName);`
	`88`	`+ var binaryResourcesModifiedTime = await GetBinaryResourcesModifiedTimeAsync();`
	`89`	`+ var packageFile = await UpdateManager.GetCurrentPackageBundleAsync(AssetsBundleFileName);`
`90`	`90`	`if (packageFile == null)`
`91`	`91`	`{`
`92`	`92`	`// There has not been any downloaded updates.`
`@@ -95,7 +95,7 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa`
`95`	`95`	`return binaryJsBundleUrl;`
`96`	`96`	`}`
`97`	`97`
`98`		`- var packageMetadata = await UpdateManager.GetCurrentPackage();`
	`98`	`+ var packageMetadata = await UpdateManager.GetCurrentPackageAsync();`
`99`	`99`	`long? binaryModifiedDateDuringPackageInstall = null;`
`100`	`100`	`var binaryModifiedDateDuringPackageInstallString = (string)packageMetadata[CodePushConstants.BinaryModifiedTimeKey];`
`101`	`101`	`if (binaryModifiedDateDuringPackageInstallString != null)`
`@@ -119,7 +119,7 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa`
`119`	`119`	`DidUpdate = false;`
`120`	`120`	`if (!MainPage.UseDeveloperSupport \|\| !AppVersion.Equals(packageAppVersion))`
`121`	`121`	`{`
`122`		`- await ClearUpdates();`
	`122`	`+ await ClearUpdatesAsync();`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`CodePushUtils.LogBundleUrl(binaryJsBundleUrl);`
`@@ -132,7 +132,7 @@ public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileNa`
`132`	`132`
`133`	`133`	`#region Internal methods`
`134`	`134`
`135`		`- internal async Task<long> GetBinaryResourcesModifiedTime()`
	`135`	`+ internal async Task<long> GetBinaryResourcesModifiedTimeAsync()`
`136`	`136`	`{`
`137`	`137`	`var assetJSBundleFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(CodePushConstants.AssetsBundlePrefix + AssetsBundleFileName));`
`138`	`138`	`var fileProperties = await assetJSBundleFile.GetBasicPropertiesAsync();`
`@@ -151,15 +151,15 @@ internal void InitializeUpdateAfterRestart()`
`151`	`151`	`// Therefore, deduce that it is a broken update and rollback.`
`152`	`152`	`CodePushUtils.Log("Update did not finish loading the last time, rolling back to a previous version.");`
`153`	`153`	`NeedToReportRollback = true;`
`154`		`- RollbackPackage().Wait();`
	`154`	`+ RollbackPackageAsync().Wait();`
`155`	`155`	`}`
`156`	`156`	`else`
`157`	`157`	`{`
`158`	`158`	`DidUpdate = true;`
`159`	`159`	`// Clear the React dev bundle cache so that new updates can be loaded.`
`160`	`160`	`if (MainPage.UseDeveloperSupport)`
`161`	`161`	`{`
`162`		`- ClearReactDevBundleCache().Wait();`
	`162`	`+ ClearReactDevBundleCacheAsync().Wait();`
`163`	`163`	`}`
`164`	`164`	`// Mark that we tried to initialize the new update, so that if it crashes,`
`165`	`165`	`// we will know that we need to rollback when the app next starts.`
`@@ -168,9 +168,9 @@ internal void InitializeUpdateAfterRestart()`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`- internal async Task ClearUpdates()`
	`171`	`+ internal async Task ClearUpdatesAsync()`
`172`	`172`	`{`
`173`		`- await UpdateManager.ClearUpdates();`
	`173`	`+ await UpdateManager.ClearUpdatesAsync();`
`174`	`174`	`SettingsManager.RemovePendingUpdate();`
`175`	`175`	`SettingsManager.RemoveFailedUpdates();`
`176`	`176`	`}`
`@@ -179,7 +179,7 @@ internal async Task ClearUpdates()`
`179`	`179`
`180`	`180`	`#region Private methods`
`181`	`181`
`182`		`- private async Task ClearReactDevBundleCache()`
	`182`	`+ private async Task ClearReactDevBundleCacheAsync()`
`183`	`183`	`{`
`184`	`184`	`var devBundleCacheFile = (StorageFile) await ApplicationData.Current.LocalFolder.TryGetItemAsync(CodePushConstants.ReactDevBundleCacheFileName);`
`185`	`185`	`if (devBundleCacheFile != null)`
`@@ -188,11 +188,11 @@ private async Task ClearReactDevBundleCache()`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`191`		`- private async Task RollbackPackage()`
	`191`	`+ private async Task RollbackPackageAsync()`
`192`	`192`	`{`
`193`		`- JObject failedPackage = await UpdateManager.GetCurrentPackage();`
	`193`	`+ JObject failedPackage = await UpdateManager.GetCurrentPackageAsync();`
`194`	`194`	`SettingsManager.SaveFailedUpdate(failedPackage);`
`195`		`- await UpdateManager.RollbackPackage();`
	`195`	`+ await UpdateManager.RollbackPackageAsync();`
`196`	`196`	`SettingsManager.RemovePendingUpdate();`
`197`	`197`	`}`
`198`	`198`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace CodePush.ReactNative`
`5`	`5`	`{`
`6`	`6`	`internal class MinimumBackgroundListener : ILifecycleEventListener`
`7`	`7`	`{`
`8`		`- private DateTime? _lastSuspendDate;`
	`8`	`+ private DateTimeOffset? _lastSuspendDate;`
`9`	`9`	`private Action _resumeAction;`
`10`	`10`
`11`	`11`	`internal int MinimumBackgroundDuration { get; set; }`
`@@ -26,7 +26,7 @@ public void OnResume()`
`26`	`26`	`{`
`27`	`27`	`// Determine how long the app was in the background and ensure`
`28`	`28`	`// that it meets the minimum duration amount of time.`
`29`		`- double durationInBackground = (new DateTime() - (DateTime)_lastSuspendDate).TotalSeconds;`
	`29`	`+ double durationInBackground = (DateTimeOffset.Now - _lastSuspendDate.Value).TotalSeconds;`
`30`	`30`	`if (durationInBackground >= MinimumBackgroundDuration)`
`31`	`31`	`{`
`32`	`32`	`_resumeAction.Invoke();`
`@@ -38,7 +38,7 @@ public void OnSuspend()`
`38`	`38`	`{`
`39`	`39`	`// Save the current time so that when the app is later`
`40`	`40`	`// resumed, we can detect how long it was in the background.`
`41`		`- _lastSuspendDate = new DateTime();`
	`41`	`+ _lastSuspendDate = DateTimeOffset.Now;`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`}`