@appzung/react-native-code-push 9.0.2 → 10.0.0

package/windows-legacy/CodePush.Shared/CodePushNativeModule.cs

@@ -1,329 +0,0 @@
-using Newtonsoft.Json.Linq;
-using ReactNative;
-using ReactNative.Bridge;
-using ReactNative.Modules.Core;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
-#if WINDOWS_UWP
-using Windows.Web.Http;
-#else
-using CodePush.Net46.Adapters.Http;
-#endif
-
-namespace CodePush.ReactNative
-{
-    internal class CodePushNativeModule : ReactContextNativeModuleBase
-    {
-        private CodePushReactPackage _codePush;
-        private MinimumBackgroundListener _minimumBackgroundListener;
-        private ReactContext _reactContext;
-
-        public CodePushNativeModule(ReactContext reactContext, CodePushReactPackage codePush)
-            : base(reactContext)
-        {
-            _reactContext = reactContext;
-            _codePush = codePush;
-        }
-
-        public override string Name
-        {
-            get
-            {
-                return "CodePush";
-            }
-        }
-
-        public override IReadOnlyDictionary<string, object> Constants
-        {
-            get
-            {
-                return new Dictionary<string, object>
-                {
-                    { "codePushInstallModeImmediate", InstallMode.Immediate },
-                    { "codePushInstallModeOnNextResume", InstallMode.OnNextResume },
-                    { "codePushInstallModeOnNextRestart", InstallMode.OnNextRestart },
-                    { "codePushUpdateStateRunning", UpdateState.Running },
-                    { "codePushUpdateStatePending", UpdateState.Pending },
-                    { "codePushUpdateStateLatest", UpdateState.Latest },
-                };
-            }
-        }
-
-        public override void Initialize()
-        {
-            _codePush.InitializeUpdateAfterRestart();
-        }
-
-        [ReactMethod]
-        public async void downloadUpdate(JObject updatePackage, bool notifyProgress, IPromise promise)
-        {
-            try
-            {
-                updatePackage[CodePushConstants.BinaryModifiedTimeKey] = "" + await FileUtils.GetBinaryResourcesModifiedTimeAsync(_codePush.AssetsBundleFileName).ConfigureAwait(false);
-                await _codePush.UpdateManager.DownloadPackageAsync(
-                    updatePackage,
-                    _codePush.AssetsBundleFileName,
-                    new Progress<HttpProgress>(
-                        (HttpProgress progress) =>
-                        {
-                            if (!notifyProgress)
-                            {
-                                return;
-                            }
-
-                            var downloadProgress = new JObject()
-                            {
-                                { "totalBytes", progress.TotalBytesToReceive },
-                                { "receivedBytes", progress.BytesReceived }
-                            };
-
-                            _reactContext
-                                .GetJavaScriptModule<RCTDeviceEventEmitter>()
-                                .emit(CodePushConstants.DownloadProgressEventName, downloadProgress);
-                        }
-                    )
-                ).ConfigureAwait(false);
-
-                JObject newPackage = await _codePush.UpdateManager.GetPackageAsync((string)updatePackage[CodePushConstants.PackageHashKey]).ConfigureAwait(false);
-                promise.Resolve(newPackage);
-            }
-            catch (InvalidDataException e)
-            {
-                CodePushUtils.Log(e.ToString());
-                SettingsManager.SaveFailedUpdate(updatePackage);
-                promise.Reject(e);
-            }
-            catch (Exception e)
-            {
-                CodePushUtils.Log(e.ToString());
-                promise.Reject(e);
-            }
-        }
-
-        [ReactMethod]
-        public void getConfiguration(IPromise promise)
-        {
-            var config = new JObject
-            {
-                { "appVersion", _codePush.AppVersion },
-                { "clientUniqueId", CodePushUtils.GetDeviceId() },
-                { "deploymentKey", _codePush.DeploymentKey },
-                { "serverUrl", CodePushConstants.CodePushServerUrl }
-            };
-
-            // TODO generate binary hash
-            // string binaryHash = CodePushUpdateUtils.getHashForBinaryContents(mainActivity, isDebugMode);
-            /*if (binaryHash != null)
-            {
-                configMap.putString(PACKAGE_HASH_KEY, binaryHash);
-            }*/
-            promise.Resolve(config);
-        }
-
-        [ReactMethod]
-        public async void getUpdateMetadata(UpdateState updateState, IPromise promise)
-        {
-            JObject currentPackage = await _codePush.UpdateManager.GetCurrentPackageAsync().ConfigureAwait(false);
-            if (currentPackage == null)
-            {
-                promise.Resolve("");
-                return;
-            }
-
-            var currentUpdateIsPending = false;
-
-            if (currentPackage[CodePushConstants.PackageHashKey] != null)
-            {
-                var currentHash = (string)currentPackage[CodePushConstants.PackageHashKey];
-                currentUpdateIsPending = SettingsManager.IsPendingUpdate(currentHash);
-            }
-
-            if (updateState == UpdateState.Pending && !currentUpdateIsPending)
-            {
-                // The caller wanted a pending update
-                // but there isn't currently one.
-                promise.Resolve("");
-            }
-            else if (updateState == UpdateState.Running && currentUpdateIsPending)
-            {
-                // The caller wants the running update, but the current
-                // one is pending, so we need to grab the previous.
-                promise.Resolve(await _codePush.UpdateManager.GetPreviousPackageAsync().ConfigureAwait(false));
-            }
-            else
-            {
-                // The current package satisfies the request:
-                // 1) Caller wanted a pending, and there is a pending update
-                // 2) Caller wanted the running update, and there isn't a pending
-                // 3) Caller wants the latest update, regardless if it's pending or not
-                if (_codePush.IsRunningBinaryVersion)
-                {
-                    // This only matters in Debug builds. Since we do not clear "outdated" updates,
-                    // we need to indicate to the JS side that somehow we have a current update on
-                    // disk that is not actually running.
-                    currentPackage["_isDebugOnly"] = true;
-                }
-
-                // Enable differentiating pending vs. non-pending updates
-                currentPackage["isPending"] = currentUpdateIsPending;
-                promise.Resolve(currentPackage);
-            }
-        }
-
-
-        [ReactMethod]
-        public async void getNewStatusReport(IPromise promise)
-        {
-            await Task.Run(() =>
-            {
-                if (_codePush.NeedToReportRollback)
-                {
-                    _codePush.NeedToReportRollback = false;
-
-                    var failedUpdates = SettingsManager.GetFailedUpdates();
-                    if (failedUpdates != null && failedUpdates.Count > 0)
-                    {
-                        var lastFailedPackage = (JObject)failedUpdates[failedUpdates.Count - 1];
-                        var failedStatusReport = TelemetryManager.GetRollbackReport(lastFailedPackage);
-                        if (failedStatusReport != null)
-                        {
-                            promise.Resolve(failedStatusReport);
-                            return;
-                        }
-                    }
-                }
-                else if (_codePush.DidUpdate)
-                {
-                    var currentPackage = _codePush.UpdateManager.GetCurrentPackageAsync().Result;
-                    if (currentPackage != null)
-                    {
-                        var newPackageStatusReport = TelemetryManager.GetUpdateReport(currentPackage);
-                        if (newPackageStatusReport != null)
-                        {
-                            promise.Resolve(newPackageStatusReport);
-                            return;
-                        }
-                    }
-                }
-                else if (_codePush.IsRunningBinaryVersion)
-                {
-                    var newAppVersionStatusReport = TelemetryManager.GetBinaryUpdateReport(_codePush.AppVersion);
-                    if (newAppVersionStatusReport != null)
-                    {
-                        promise.Resolve(newAppVersionStatusReport);
-                        return;
-                    }
-                }
-                else
-                {
-                    var retryStatusReport = TelemetryManager.GetRetryStatusReport();
-                    if (retryStatusReport != null)
-                    {
-                        promise.Resolve(retryStatusReport);
-                        return;
-                    }
-                }
-
-                promise.Resolve("");
-            }).ConfigureAwait(false);
-        }
-
-        [ReactMethod]
-        public async void installUpdate(JObject updatePackage, InstallMode installMode, int minimumBackgroundDuration, IPromise promise)
-        {
-            await _codePush.UpdateManager.InstallPackageAsync(updatePackage, SettingsManager.IsPendingUpdate(null)).ConfigureAwait(false);
-            var pendingHash = (string)updatePackage[CodePushConstants.PackageHashKey];
-            SettingsManager.SavePendingUpdate(pendingHash, /* isLoading */false);
-            if (installMode == InstallMode.OnNextResume)
-            {
-                if (_minimumBackgroundListener == null)
-                {
-                    // Ensure we do not add the listener twice.
-                    Action loadBundleAction = () =>
-                    {
-                        Context.RunOnNativeModulesQueueThread(async () =>
-                        {
-                            await LoadBundleAsync().ConfigureAwait(false);
-                        });
-                    };
-
-                    _minimumBackgroundListener = new MinimumBackgroundListener(loadBundleAction, minimumBackgroundDuration);
-                    _reactContext.AddLifecycleEventListener(_minimumBackgroundListener);
-                }
-                else
-                {
-                    _minimumBackgroundListener.MinimumBackgroundDuration = minimumBackgroundDuration;
-                }
-            }
-
-            promise.Resolve("");
-        }
-
-        [ReactMethod]
-        public void isFailedUpdate(string packageHash, IPromise promise)
-        {
-            promise.Resolve(SettingsManager.IsFailedHash(packageHash));
-        }
-
-        [ReactMethod]
-        public async void isFirstRun(string packageHash, IPromise promise)
-        {
-            bool isFirstRun = _codePush.DidUpdate
-                && packageHash != null
-                && packageHash.Length > 0
-                && packageHash.Equals(await _codePush.UpdateManager.GetCurrentPackageHashAsync().ConfigureAwait(false));
-            promise.Resolve(isFirstRun);
-        }
-
-        [ReactMethod]
-        public void notifyApplicationReady(IPromise promise)
-        {
-            SettingsManager.RemovePendingUpdate();
-            promise.Resolve("");
-        }
-
-        [ReactMethod]
-        public async void restartApp(bool onlyIfUpdateIsPending)
-        {
-            // If this is an unconditional restart request, or there
-            // is current pending update, then reload the app.
-            if (!onlyIfUpdateIsPending || SettingsManager.IsPendingUpdate(null))
-            {
-                await LoadBundleAsync().ConfigureAwait(false);
-            }
-        }
-
-        [ReactMethod]
-        public async void recordStatusReported(JObject statusReport)
-        {
-            await Task.Run(() => TelemetryManager.RecordStatusReported(statusReport)).ConfigureAwait(false);
-        }
-
-        [ReactMethod]
-        public async void saveStatusReportForRetry(JObject statusReport)
-        {
-            await Task.Run(() => TelemetryManager.SaveStatusReportForRetry(statusReport)).ConfigureAwait(false);
-        }
-
-        internal async Task LoadBundleAsync()
-        {
-            // #1) Get the private ReactInstanceManager, which is what includes
-            //     the logic to reload the current React context.
-            var reactInstanceManager = _codePush.ReactInstanceManager;
-
-            // #2) Update the locally stored JS bundle file path
-            Type reactInstanceManagerType = typeof(ReactInstanceManager);
-            string latestJSBundleFile = await _codePush.GetJavaScriptBundleFileAsync(_codePush.AssetsBundleFileName).ConfigureAwait(false);
-            reactInstanceManagerType
-                .GetField("_jsBundleFile", BindingFlags.NonPublic | BindingFlags.Instance)
-                .SetValue(reactInstanceManager, latestJSBundleFile);
-
-            // #3) Get the context creation method and fire it on the UI thread (which RN enforces)
-            Context.RunOnDispatcherQueueThread(() => reactInstanceManager.RecreateReactContextAsync(CancellationToken.None));
-        }
-    }
-}

package/windows-legacy/CodePush.Shared/CodePushReactPackage.cs

@@ -1,235 +0,0 @@
-using Newtonsoft.Json.Linq;
-using ReactNative;
-using ReactNative.Bridge;
-using ReactNative.Modules.Core;
-using ReactNative.UIManager;
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Threading.Tasks;
-
-
-namespace CodePush.ReactNative
-{
-    public sealed class CodePushReactPackage : IReactPackage
-    {
-        private static CodePushReactPackage CurrentInstance;
-
-        internal string AppVersion { get; private set; }
-        internal string DeploymentKey { get; private set; }
-        internal string AssetsBundleFileName { get; private set; }
-        internal bool NeedToReportRollback { get; set; } = false;
-        internal bool DidUpdate { get; private set; } = false;
-        internal bool IsRunningBinaryVersion { get; private set; } = false;
-#pragma warning disable CS0618 // Keeping for backward compatibility
-        internal ReactPage MainPage { get; private set; }
-#pragma warning restore CS0618 // Keeping for backward compatibility
-        internal ReactNativeHost Host { get; private set; }
-        internal UpdateManager UpdateManager { get; private set; }
-
-        internal ReactInstanceManager ReactInstanceManager
-        {
-            get
-            {
-                if (Host != null)
-                {
-                    return Host.ReactInstanceManager;
-                }
-
-#if WINDOWS_UWP
-#pragma warning disable CS0618 // Keeping for backward compatibility
-                return (ReactInstanceManager)typeof(ReactPage)
-#pragma warning restore CS0618 // Keeping for backward compatibility
-                    .GetField("_reactInstanceManager", BindingFlags.NonPublic | BindingFlags.Instance)
-                    .GetValue(MainPage);
-#else
-                return ((Lazy<ReactInstanceManager>)typeof(ReactPage)
-                    .GetField("_reactInstanceManager", BindingFlags.NonPublic | BindingFlags.Instance)
-                    .GetValue(MainPage)).Value as ReactInstanceManager;
-#endif
-            }
-        }
-
-        internal bool UseDeveloperSupport
-        {
-            get
-            {
-                return Host?.UseDeveloperSupport ?? MainPage.UseDeveloperSupport;
-            }
-        }
-
-
-#pragma warning disable CS0618 // Keeping for backward compatibility
-        public CodePushReactPackage(string deploymentKey, ReactPage mainPage)
-#pragma warning restore CS0618 // Keeping for backward compatibility
-        {
-            AppVersion = CodePushUtils.GetAppVersion();
-            DeploymentKey = deploymentKey;
-            MainPage = mainPage;
-            UpdateManager = new UpdateManager();
-
-            if (CurrentInstance != null)
-            {
-                CodePushUtils.Log("More than one CodePush instance has been initialized. Please use the instance method codePush.getBundleUrlInternal() to get the correct bundleURL for a particular instance.");
-            }
-
-            CurrentInstance = this;
-        }
-
-        public CodePushReactPackage(string deploymentKey, ReactNativeHost host)
-        {
-            AppVersion = CodePushUtils.GetAppVersion();
-            DeploymentKey = deploymentKey;
-            Host = host;
-            UpdateManager = new UpdateManager();
-
-            if (CurrentInstance != null)
-            {
-                CodePushUtils.Log("More than one CodePush instance has been initialized. Please use the instance method codePush.getBundleUrlInternal() to get the correct bundleURL for a particular instance.");
-            }
-
-            CurrentInstance = this;
-        }
-
-#region Public methods
-        public IReadOnlyList<Type> CreateJavaScriptModulesConfig()
-        {
-            return new List<Type>();
-        }
-
-        public IReadOnlyList<INativeModule> CreateNativeModules(ReactContext reactContext)
-        {
-            return new List<INativeModule>
-            {
-                 new CodePushNativeModule(reactContext, this)
-            };
-        }
-
-        public IReadOnlyList<IViewManager> CreateViewManagers(ReactContext reactContext)
-        {
-            return new List<IViewManager>();
-        }
-
-        public string GetJavaScriptBundleFile()
-        {
-            return GetJavaScriptBundleFile(CodePushConstants.DefaultJsBundleName);
-        }
-
-        public string GetJavaScriptBundleFile(string assetsBundleFileName)
-        {
-            if (CurrentInstance == null)
-            {
-                throw new InvalidOperationException("A CodePush instance has not been created yet. Have you added it to your app's list of ReactPackages?");
-            }
-
-            return CurrentInstance.GetJavaScriptBundleFileAsync(assetsBundleFileName).Result;
-        }
-
-        public async Task<string> GetJavaScriptBundleFileAsync(string assetsBundleFileName)
-        {
-            AssetsBundleFileName = assetsBundleFileName;
-            string binaryJsBundleUrl = CodePushUtils.GetAssetsBundlePrefix() + assetsBundleFileName;
-
-            var binaryResourcesModifiedTime = await FileUtils.GetBinaryResourcesModifiedTimeAsync(AssetsBundleFileName).ConfigureAwait(false);
-            var packageFile = await UpdateManager.GetCurrentPackageBundleAsync(AssetsBundleFileName).ConfigureAwait(false);
-            if (packageFile == null)
-            {
-                // There has not been any downloaded updates.
-                CodePushUtils.LogBundleUrl(binaryJsBundleUrl);
-                IsRunningBinaryVersion = true;
-                return binaryJsBundleUrl;
-            }
-
-            var packageMetadata = await UpdateManager.GetCurrentPackageAsync().ConfigureAwait(false);
-            long? binaryModifiedDateDuringPackageInstall = null;
-            var binaryModifiedDateDuringPackageInstallString = (string)packageMetadata[CodePushConstants.BinaryModifiedTimeKey];
-            if (binaryModifiedDateDuringPackageInstallString != null)
-            {
-                binaryModifiedDateDuringPackageInstall = long.Parse(binaryModifiedDateDuringPackageInstallString);
-            }
-
-            var packageAppVersion = (string)packageMetadata["appVersion"];
-
-            if (binaryModifiedDateDuringPackageInstall != null &&
-                    binaryModifiedDateDuringPackageInstall == binaryResourcesModifiedTime &&
-                    AppVersion.Equals(packageAppVersion))
-            {
-                CodePushUtils.LogBundleUrl(packageFile.Path);
-                IsRunningBinaryVersion = false;
-
-                return CodePushUtils.GetFileBundlePrefix() + CodePushUtils.ExtractSubFolder(packageFile.Path);
-            }
-            else
-            {
-                // The binary version is newer.
-                DidUpdate = false;
-                if (!UseDeveloperSupport || !AppVersion.Equals(packageAppVersion))
-                {
-                    await ClearUpdatesAsync().ConfigureAwait(false);
-                }
-
-                CodePushUtils.LogBundleUrl(binaryJsBundleUrl);
-                IsRunningBinaryVersion = true;
-                return binaryJsBundleUrl;
-            }
-        }
-
-#endregion
-
-#region Internal methods
-
-        internal void InitializeUpdateAfterRestart()
-        {
-            // Reset the state which indicates that
-            // the app was just freshly updated.
-            DidUpdate = false;
-
-            JObject pendingUpdate = SettingsManager.GetPendingUpdate();
-            if (pendingUpdate != null)
-            {
-                var updateIsLoading = (bool)pendingUpdate[CodePushConstants.PendingUpdateIsLoadingKey];
-                if (updateIsLoading)
-                {
-                    // Pending update was initialized, but notifyApplicationReady was not called.
-                    // 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;
-                    RollbackPackageAsync().Wait();
-                }
-                else
-                {
-                    DidUpdate = true;
-                    // Clear the React dev bundle cache so that new updates can be loaded.
-                    if (UseDeveloperSupport)
-                    {
-                        FileUtils.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.
-                    SettingsManager.SavePendingUpdate((string)pendingUpdate[CodePushConstants.PendingUpdateHashKey], /* isLoading */true);
-                }
-            }
-        }
-
-        internal async Task ClearUpdatesAsync()
-        {
-            await UpdateManager.ClearUpdatesAsync().ConfigureAwait(false);
-            SettingsManager.RemovePendingUpdate();
-            SettingsManager.RemoveFailedUpdates();
-        }
-
-#endregion
-
-#region Private methods
-
-        private async Task RollbackPackageAsync()
-        {
-            JObject failedPackage = await UpdateManager.GetCurrentPackageAsync().ConfigureAwait(false);
-            SettingsManager.SaveFailedUpdate(failedPackage);
-            await UpdateManager.RollbackPackageAsync().ConfigureAwait(false);
-            SettingsManager.RemovePendingUpdate();
-        }
-
-#endregion
-    }
-}

package/windows-legacy/CodePush.Shared/CodePushUtils.cs

@@ -1,70 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Linq;
-using System.IO;
-#if WINDOWS_UWP
-using Windows.ApplicationModel;
-using Windows.Storage;
-#endif
-
-namespace CodePush.ReactNative
-{
-    internal partial class CodePushUtils
-    {
-        internal static void Log(string message)
-        {
-            Debug.WriteLine("[CodePush] " + message, CodePushConstants.ReactNativeLogCategory);
-        }
-
-        internal static void LogBundleUrl(string path)
-        {
-            Log("Loading JS bundle from \"" + path + "\"");
-        }
-
-        static string _deviceId = String.Empty;
-
-        internal static string GetDeviceId()
-        {
-            //It's quite long operation, cache it
-            if (!String.IsNullOrEmpty(_deviceId))
-                return _deviceId;
-
-            _deviceId = GetDeviceIdImpl();
-            return _deviceId;
-        }
-
-        internal static string GetAppVersion()
-        {
-#if WINDOWS_UWP
-            return Package.Current.Id.Version.Major + "." + Package.Current.Id.Version.Minor + "." + Package.Current.Id.Version.Build;
-#else
-            return applicationInfo.Version;
-#endif
-        }
-
-        internal static string GetAppFolder()
-        {
-#if WINDOWS_UWP
-            return ApplicationData.Current.LocalFolder.Path;
-#else
-            return AppDomain.CurrentDomain.BaseDirectory;
-#endif
-        }
-
-        internal static string GetAssetsBundlePrefix()
-        {
-#if WINDOWS_UWP
-            return CodePushConstants.AssetsBundlePrefix;
-#else
-            return Path.Combine(GetAppFolder(), CodePushConstants.AssetsBundlePrefix);
-#endif
-        }
-
-        internal static string ExtractSubFolder(string fullPath)
-        {
-            var codePushSubPathArray = fullPath.Split(Path.DirectorySeparatorChar);
-            return String.Join("/", codePushSubPathArray.SkipWhile((value, index) => codePushSubPathArray.Length - index > 4).ToArray());
-        }
-
-    }
-}

package/windows-legacy/CodePush.Shared/InstallMode.cs

@@ -1,9 +0,0 @@
-namespace CodePush.ReactNative
-{
-    enum InstallMode
-    {
-        Immediate,
-        OnNextRestart,
-        OnNextResume
-    }
-}

package/windows-legacy/CodePush.Shared/MinimumBackgroundListener.cs

@@ -1,44 +0,0 @@
-using ReactNative.Bridge;
-using System;
-
-namespace CodePush.ReactNative
-{
-    internal class MinimumBackgroundListener : ILifecycleEventListener
-    {
-        private DateTimeOffset? _lastSuspendDate;
-        private Action _resumeAction;
-
-        internal int MinimumBackgroundDuration { get; set; }
-
-        internal MinimumBackgroundListener(Action resumeAction, int minimumBackgroundDuration)
-        {
-            _resumeAction = resumeAction;
-            MinimumBackgroundDuration = minimumBackgroundDuration;
-        }
-
-        public void OnDestroy()
-        {
-        }
-
-        public void OnResume()
-        {
-            if (_lastSuspendDate != null)
-            {
-                // Determine how long the app was in the background and ensure
-                // that it meets the minimum duration amount of time.
-                double durationInBackground = (DateTimeOffset.Now - _lastSuspendDate.Value).TotalSeconds;
-                if (durationInBackground >= MinimumBackgroundDuration)
-                {
-                    _resumeAction.Invoke();
-                }
-            }
-        }
-
-        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 = DateTimeOffset.Now;
-        }
-    }
-}