CodePush.js

import { AcquisitionManager as Sdk, DownloadStatus } from "./lib/commonjs/acquisition-sdk/acquisition-sdk";
import { createCodePushProvider } from "./lib/commonjs/react/code-push-provider";
import { useCodePush } from "./lib/commonjs/react/use-code-push";
import { useDownloadProgress } from "./lib/commonjs/react/use-download-progress";
import { createUpdateStore } from "./lib/commonjs/update-state/update-store";
import { trackDownload, trackInstall } from "./lib/commonjs/update-state/track-update";
import { onceUntilRejected } from "./lib/commonjs/once-until-rejected";
import { packageMetadata } from "./lib/commonjs/package-metadata";
import { Alert } from "./AlertAdapter";
import requestFetchAdapter from "./request-fetch-adapter";
import { AppState, NativeEventEmitter, Platform } from "react-native";
import log, { logFields, packageLogFields, redactUrl } from "./lib/commonjs/logging";
import hoistStatics from 'hoist-non-react-statics';

let NativeCodePush = require("react-native").NativeModules.CodePush;

// Reporting this event is important, but avoid blocking install()/restartApp() indefinitely
// on a stalled network request.
const REPORT_STATUS_DOWNLOAD_TIMEOUT_MS = 5000;

async function withTimeout(promise, timeoutMs) {
  let timer;
  const timeout = new Promise((_, reject) => {
    timer = setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs);
  });

  try {
    return await Promise.race([promise, timeout]);
  } finally {
    clearTimeout(timer);
  }
}

// Downloads a remote package, augmenting it with a bound install() method
// beyond what's included in the metadata sent by the server.
function downloadUpdate(remotePackage, downloadProgressCallback, reportStatusDownload) {
  return trackDownload(updateStore, () => downloadUpdateInternal(remotePackage, downloadProgressCallback, reportStatusDownload));
}

async function downloadUpdateInternal(remotePackage, downloadProgressCallback, reportStatusDownload) {
  if (!remotePackage.downloadUrl) {
    throw new Error("Cannot download an update without a download url");
  }

  const codePushEventEmitter = new NativeEventEmitter(NativeCodePush);
  const downloadProgressSubscription = codePushEventEmitter.addListener("CodePushDownloadProgress", (progress) => {
    updateStore.dispatch({ type: "downloadProgressed", progress });
    downloadProgressCallback && downloadProgressCallback(progress);
  });

  log.info(`Downloading update. ${logFields({ ...packageLogFields(remotePackage), packageSize: remotePackage.packageSize, url: redactUrl(remotePackage.downloadUrl) })}`);
  const downloadStartTime = Date.now();
  // Only report a duration on success: on failure, this would be the time until
  // the download broke rather than a completed download's duration, and could be misleading.
  const reportDownloadStatus = async (status, downloadDurationMs, updateType) => {
    if (!reportStatusDownload) return;
    try {
      await withTimeout(reportStatusDownload({ ...remotePackage, downloadDurationMs, status, updateType }), REPORT_STATUS_DOWNLOAD_TIMEOUT_MS);
    } catch (err) {
      log.warn("Failed to report download status.", err);
    }
  };

  // Use the downloaded package info. Native code will save the package info
  // so that the client knows what the current package version is.
  try {
    // Functions cannot cross the bridge.
    const updatePackageCopy = packageMetadata(remotePackage);

    let downloadedPackage;
    try {
      downloadedPackage = await NativeCodePush.downloadUpdate(updatePackageCopy, true);
    } catch (err) {
      await reportDownloadStatus(DownloadStatus.Failed, undefined, err?.userInfo?.updateType);
      throw err;
    }

    const downloadDurationMs = Date.now() - downloadStartTime;
    log.info(`Downloaded update. ${logFields({ ...packageLogFields(remotePackage), durationMs: downloadDurationMs })}`);
    await reportDownloadStatus(DownloadStatus.Succeeded, downloadDurationMs, downloadedPackage.updateType);

    return attachLocalPackageMethods({ ...downloadedPackage, isPending: false }); // A freshly downloaded package hasn't been installed yet
  } finally {
    downloadProgressSubscription.remove();
  }
}

// The state that useCodePush() returns. It lives at module level, outside React, because the legacy public functions
// (checkForUpdate(), sync(), the codePush() HOC) must keep updating it. sync() and the HOC check through
// checkForUpdate(), so reporting here covers every check.
const updateStore = createUpdateStore();

async function checkForUpdate(deploymentKey = null, handleBinaryVersionMismatchCallback = null) {
  updateStore.dispatch({ type: "checkStarted" });
  try {
    // The legacy API reports a binary mismatch only through this callback (the check resolves to null), so it is
    // wrapped to also capture it for the state.
    let incompatibleUpdate;
    const update = await queryUpdate(deploymentKey, (mismatch) => {
      incompatibleUpdate = { targetBinaryVersion: mismatch.appVersion };
      if (typeof handleBinaryVersionMismatchCallback === "function") {
        handleBinaryVersionMismatchCallback(mismatch);
      }
    });
    updateStore.dispatch({ type: "checkCompleted", update, incompatibleUpdate });
    return update;
  } catch (error) {
    updateStore.dispatch({ type: "checkFailed", error });
    throw error;
  }
}

async function queryUpdate(deploymentKey, handleBinaryVersionMismatchCallback) {
  /*
   * Before we ask the server if an update exists, we
   * need to retrieve three pieces of information from the
   * native side: deployment key, app version (e.g. 1.0.1)
   * and the hash of the currently running update (if there is one).
   * This allows the client to only receive updates which are targetted
   * for their specific deployment and version and which are actually
   * different from the CodePush update they have already installed.
   */
  const nativeConfig = await getConfiguration();
  /*
   * If a deployment key was explicitly provided,
   * then let's override the one we retrieved
   * from the native-side of the app. This allows
   * dynamically "redirecting" end-users at different
   * deployments (e.g. an early access deployment for insiders).
   */
  const config = deploymentKey ? { ...nativeConfig, ...{ deploymentKey } } : nativeConfig;
  const sdk = getPromisifiedSdk(requestFetchAdapter, config);

  // Use dynamically overridden getCurrentPackage() during tests.
  const localPackage = await module.exports.getCurrentPackage();

  /*
   * If the app has a previously installed update, and that update
   * was targetted at the same app version that is currently running,
   * then we want to use its package hash to determine whether a new
   * release has been made on the server. Otherwise, we only need
   * to send the app version to the server, since we are interested
   * in any updates for current binary version, regardless of hash.
   */
  let queryPackage;
  if (localPackage) {
    queryPackage = localPackage;
  } else {
    queryPackage = { appVersion: config.appVersion };
    if (Platform.OS === "ios" && config.packageHash) {
      queryPackage.packageHash = config.packageHash;
    }
  }

  log.info(`Checking for update. ${logFields({ appVersion: queryPackage.appVersion, ...packageLogFields(queryPackage), deploymentKey: config.deploymentKey })}`);
  const update = await sdk.queryUpdateWithCurrentPackage(queryPackage);

  /*
   * There are four cases where checkForUpdate will resolve to null:
   * ----------------------------------------------------------------
   * 1) The server said there isn't an update. This is the most common case.
   * 2) The server said there is an update but it requires a newer binary version.
   *    This would occur when end-users are running an older binary version than
   *    is available, and CodePush is making sure they don't get an update that
   *    potentially wouldn't be compatible with what they are running.
   * 3) The server said there is an update, but the update's hash is the same as
   *    the currently running update. This should _never_ happen, unless there is a
   *    bug in the server, but we're adding this check just to double-check that the
   *    client app is resilient to a potential issue with the update check.
   * 4) The server said there is an update, but the update's hash is the same as that
   *    of the binary's currently running version. This should only happen in Android -
   *    unlike iOS, we don't attach the binary's hash to the updateCheck request
   *    because we want to avoid having to install diff updates against the binary's
   *    version, which we can't do yet on Android.
   */
  if (!update) {
    log.info("No update available.");
    return null;
  } else if (update.updateAppVersion) {
    log.info(`An update is available but it is not targeting the binary version of your app. ${logFields({ targetBinaryVersion: update.appVersion })}`);
    if (handleBinaryVersionMismatchCallback && typeof handleBinaryVersionMismatchCallback === "function") {
      handleBinaryVersionMismatchCallback(update)
    }
    return null;
  } else if (localPackage && (update.packageHash === localPackage.packageHash)) {
    log.info(`The server returned the update that is already installed, ignoring it. ${logFields(packageLogFields(update))}`);
    return null;
  } else if ((!localPackage || localPackage._isDebugOnly) && config.packageHash === update.packageHash) {
    log.info(`The server returned the update that is already in the binary, ignoring it. ${logFields(packageLogFields(update))}`);
    return null;
  } else {
    const remotePackage = { ...update, isPending: false }; // A remote package could never be in a pending state
    remotePackage.download = (downloadProgressCallback) => downloadUpdate(remotePackage, downloadProgressCallback, sdk.reportStatusDownload);
    remotePackage.failedInstall = await NativeCodePush.isFailedUpdate(remotePackage.packageHash);
    remotePackage.deploymentKey = deploymentKey || nativeConfig.deploymentKey;
    log.info(`Update available. ${logFields({ ...packageLogFields(remotePackage), packageSize: remotePackage.packageSize, mandatory: !!remotePackage.isMandatory, failedInstall: remotePackage.failedInstall })}`);
    return remotePackage;
  }
}

// Caches the promise, so that concurrent first calls (e.g. the status report
// and the update check of sync) fetch and log the configuration only once.
// The log line does not delay the configuration, and cannot make it fail.
const getConfiguration = (() => {
  let configPromise;
  return async function getConfiguration() {
    if (configPromise) {
      return configPromise;
    } else if (testConfig) {
      return testConfig;
    } else {
      configPromise = NativeCodePush.getConfiguration().then((config) => {
        logConfiguration(config).catch(() => {});
        return config;
      });
      configPromise.catch(() => { configPromise = null; });
      return configPromise;
    }
  }
})();

async function logConfiguration(config) {
  let activePackage = null;
  try {
    activePackage = await NativeCodePush.getUpdateMetadata(NativeCodePush.codePushUpdateStateRunning);
  } catch (err) {
    // The running package is only informational here.
  }

  // Native returns the package on disk with _isDebugOnly when the binary bundle runs instead
  // (a debug build keeps an outdated update after the binary changed).
  const isBinaryRunning = !activePackage || activePackage._isDebugOnly;

  log.info(`Configuration: ${logFields({
    sdkVersion: require("./package.json").version,
    appVersion: config.appVersion,
    deltaUpdates: !!config.enableDeltaUpdates,
    binaryHash: config.packageHash,
    activePackage: isBinaryRunning ? "fromBinary" : "fromCodePush",
    activePackageLabel: isBinaryRunning ? undefined : activePackage.versionLabel,
    packageHash: isBinaryRunning ? undefined : activePackage.packageHash,
  })}`);
}

async function getCurrentPackage() {
  return await getUpdateMetadata(CodePush.UpdateState.LATEST);
}

async function installUpdate(localPackage, installMode = NativeCodePush.codePushInstallModeOnNextRestart, minimumBackgroundDuration = 0, updateInstalledCallback) {
  const localPackageCopy = Object.assign({}, localPackage); // In dev mode, React Native deep freezes any object queued over the bridge
  log.info(`Installing update. ${logFields({ ...packageLogFields(localPackage), installMode: installModeName(installMode), minimumBackgroundDuration })}`);
  await trackInstall(updateStore, localPackage, () => NativeCodePush.installUpdate(localPackageCopy, installMode, minimumBackgroundDuration));
  log.info(`Installed update. ${installedUpdateNextStep(installMode, minimumBackgroundDuration)}`);
  updateInstalledCallback && updateInstalledCallback();
  if (installMode == NativeCodePush.codePushInstallModeImmediate) {
    NativeCodePush.restartApp(false);
  } else {
    NativeCodePush.clearPendingRestart();
    localPackage.isPending = true; // Mark the package as pending since it hasn't been applied yet
  }
}

function installModeName(installMode) {
  const name = Object.keys(CodePush.InstallMode).find((key) => CodePush.InstallMode[key] === installMode);
  return name || installMode;
}

function installedUpdateNextStep(installMode, minimumBackgroundDuration) {
  switch (installMode) {
    case CodePush.InstallMode.IMMEDIATE:
      // Native logs whether the restart happens now or is queued (e.g. restarts are disallowed).
      return "Requesting an app restart now.";
    case CodePush.InstallMode.ON_NEXT_RESUME:
      return minimumBackgroundDuration > 0
        ? `It will run when the app resumes after at least ${minimumBackgroundDuration} seconds in the background.`
        : "It will run when the app next resumes.";
    case CodePush.InstallMode.ON_NEXT_SUSPEND:
      return minimumBackgroundDuration > 0
        ? `It will run when the app has been in the background for at least ${minimumBackgroundDuration} seconds.`
        : "It will run when the app goes to the background.";
    default:
      return "It will run on the next app restart.";
  }
}

// Augments a raw local package (as returned by native code) with a bound
// install() method beyond what's included in the metadata sent by the server.
function attachLocalPackageMethods(localPackage) {
  localPackage.install = (installMode, minimumBackgroundDuration, updateInstalledCallback) =>
    installUpdate(localPackage, installMode, minimumBackgroundDuration, updateInstalledCallback);
  return localPackage;
}

async function getUpdateMetadata(updateState) {
  let updateMetadata = await NativeCodePush.getUpdateMetadata(updateState || CodePush.UpdateState.RUNNING);
  if (updateMetadata) {
    updateMetadata = attachLocalPackageMethods({ ...updateMetadata });
    updateMetadata.failedInstall = await NativeCodePush.isFailedUpdate(updateMetadata.packageHash);
    updateMetadata.isFirstRun = await NativeCodePush.isFirstRun(updateMetadata.packageHash);
  }
  return updateMetadata;
}

function getPromisifiedSdk(requestFetchAdapter, config) {
  // Use dynamically overridden AcquisitionSdk during tests.
  const sdk = new module.exports.AcquisitionSdk(requestFetchAdapter, config);
  sdk.queryUpdateWithCurrentPackage = (queryPackage) => {
    return new Promise((resolve, reject) => {
      module.exports.AcquisitionSdk.prototype.queryUpdateWithCurrentPackage.call(sdk, queryPackage, (err, update) => {
        if (err) {
          reject(err);
        } else {
          resolve(update);
        }
      });
    });
  };

  sdk.reportStatusDeploy = (deployedPackage, status, previousLabelOrAppVersion, previousDeploymentKey) => {
    return new Promise((resolve, reject) => {
      module.exports.AcquisitionSdk.prototype.reportStatusDeploy.call(sdk, deployedPackage, status, previousLabelOrAppVersion, previousDeploymentKey, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  };

  sdk.reportStatusDownload = (downloadedPackage) => {
    log.info(`Reporting download status. ${logFields({ status: downloadedPackage.status, ...packageLogFields(downloadedPackage), durationMs: downloadedPackage.downloadDurationMs, updateType: downloadedPackage.updateType })}`);
    return new Promise((resolve, reject) => {
      module.exports.AcquisitionSdk.prototype.reportStatusDownload.call(sdk, downloadedPackage, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  };

  return sdk;
}

// Succeeds once per module instance; a failed call is retried by the next caller (e.g. sync()).
const notifyApplicationReady = onceUntilRejected(notifyApplicationReadyInternal);

async function notifyApplicationReadyInternal() {
  try {
    await NativeCodePush.notifyApplicationReady();
    const statusReport = await NativeCodePush.getNewStatusReport();
    statusReport && tryReportStatus(statusReport); // Don't wait for this to complete.

    return statusReport;
  } catch (error) {
    log.error("notifyAppReady failed.", error);
    throw error;
  }
}

async function tryReportStatus(statusReport, retryOnAppResume) {
  const config = await getConfiguration();
  const previousLabelOrAppVersion = statusReport.previousLabelOrAppVersion;
  const previousDeploymentKey = statusReport.previousDeploymentKey || config.deploymentKey;
  try {
    if (statusReport.appVersion) {
      log.info(`Reporting the first run of this binary version. ${logFields({ appVersion: statusReport.appVersion, previousLabelOrAppVersion, previousDeploymentKey })}`);

      if (!config.deploymentKey) {
        throw new Error("Deployment key is missed");
      }

      const sdk = getPromisifiedSdk(requestFetchAdapter, config);
      await sdk.reportStatusDeploy(/* deployedPackage */ null, /* status */ null, previousLabelOrAppVersion, previousDeploymentKey);
    } else {
      const fields = logFields({ ...packageLogFields(statusReport.package), updateType: statusReport.package.updateType, previousLabelOrAppVersion, previousDeploymentKey });
      if (statusReport.status === "DeploymentSucceeded") {
        log.info(`Reporting update success. ${fields}`);
      } else {
        log.info(`Reporting update rollback. ${fields}`);
        await NativeCodePush.setLatestRollbackInfo(statusReport.package.packageHash);
      }

      config.deploymentKey = statusReport.package.deploymentKey;
      const sdk = getPromisifiedSdk(requestFetchAdapter, config);
      await sdk.reportStatusDeploy(statusReport.package, statusReport.status, previousLabelOrAppVersion, previousDeploymentKey);
    }

    NativeCodePush.recordStatusReported(statusReport);
    retryOnAppResume && retryOnAppResume.remove();
  } catch (e) {
    log.warn(`Failed to report deployment status, will retry when the app resumes. ${logFields({ status: statusReport.status, ...packageLogFields(statusReport.package), appVersion: statusReport.appVersion })}`, e);
    NativeCodePush.saveStatusReportForRetry(statusReport);
    // Try again when the app resumes
    if (!retryOnAppResume) {
      const resumeListener = AppState.addEventListener("change", async (newState) => {
        if (newState !== "active") return;
        const refreshedStatusReport = await NativeCodePush.getNewStatusReport();
        if (refreshedStatusReport) {
          tryReportStatus(refreshedStatusReport, resumeListener);
        } else {
          resumeListener && resumeListener.remove();
        }
      });
    }
  }
}

async function shouldUpdateBeIgnored(remotePackage, syncOptions) {
  let { rollbackRetryOptions } = syncOptions;

  const isFailedPackage = remotePackage && remotePackage.failedInstall;
  if (!isFailedPackage || !syncOptions.ignoreFailedUpdates) {
    return false;
  }

  if (!rollbackRetryOptions) {
    return true;
  }

  if (typeof rollbackRetryOptions !== "object") {
    rollbackRetryOptions = CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS;
  } else {
    rollbackRetryOptions = { ...CodePush.DEFAULT_ROLLBACK_RETRY_OPTIONS, ...rollbackRetryOptions };
  }

  if (!validateRollbackRetryOptions(rollbackRetryOptions)) {
    return true;
  }

  const latestRollbackInfo = await NativeCodePush.getLatestRollbackInfo();
  if (!validateLatestRollbackInfo(latestRollbackInfo, remotePackage.packageHash)) {
    log.info("The latest rollback info is not valid.");
    return true;
  }

  const { delayInHours, maxRetryAttempts } = rollbackRetryOptions;
  const hoursSinceLatestRollback = (Date.now() - latestRollbackInfo.time) / (1000 * 60 * 60);
  if (hoursSinceLatestRollback >= delayInHours && maxRetryAttempts >= latestRollbackInfo.count) {
    log.info("Previous rollback should be ignored due to rollback retry options.");
    return false;
  }

  return true;
}

function validateLatestRollbackInfo(latestRollbackInfo, packageHash) {
  return latestRollbackInfo &&
    latestRollbackInfo.time &&
    latestRollbackInfo.count &&
    latestRollbackInfo.packageHash &&
    latestRollbackInfo.packageHash === packageHash;
}

function validateRollbackRetryOptions(rollbackRetryOptions) {
  if (typeof rollbackRetryOptions.delayInHours !== "number") {
    log.warn("The 'delayInHours' rollback retry parameter must be a number.");
    return false;
  }

  if (typeof rollbackRetryOptions.maxRetryAttempts !== "number") {
    log.warn("The 'maxRetryAttempts' rollback retry parameter must be a number.");
    return false;
  }

  if (rollbackRetryOptions.maxRetryAttempts < 1) {
    log.warn("The 'maxRetryAttempts' rollback retry parameter cannot be less then 1.");
    return false;
  }

  return true;
}

var testConfig;

// This function is only used for tests. Replaces the default SDK, configuration and native bridge
function setUpTestDependencies(testSdk, providedTestConfig, testNativeBridge) {
  if (testSdk) module.exports.AcquisitionSdk = testSdk;
  if (providedTestConfig) testConfig = providedTestConfig;
  if (testNativeBridge) NativeCodePush = testNativeBridge;
}

function clearUpdates() {
  NativeCodePush.clearUpdates();
  updateStore.dispatch({ type: "updatesCleared" });
}

async function restartApp(onlyIfUpdateIsPending = false) {
  NativeCodePush.restartApp(onlyIfUpdateIsPending);
}

// This function allows only one syncInternal operation to proceed at any given time.
// Parallel calls to sync() while one is ongoing yields CodePush.SyncStatus.SYNC_IN_PROGRESS.
const sync = (() => {
  let syncInProgress = false;
  const setSyncCompleted = () => { syncInProgress = false; };

  return (options = {}, syncStatusChangeCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback) => {
    let syncStatusCallbackWithTryCatch, downloadProgressCallbackWithTryCatch;
    if (typeof syncStatusChangeCallback === "function") {
      syncStatusCallbackWithTryCatch = (...args) => {
        try {
          syncStatusChangeCallback(...args);
        } catch (error) {
          log.error("The sync status callback threw an error.", error);
        }
      }
    }

    if (typeof downloadProgressCallback === "function") {
      downloadProgressCallbackWithTryCatch = (...args) => {
        try {
          downloadProgressCallback(...args);
        } catch (error) {
          log.error("The download progress callback threw an error.", error);
        }
      }
    }

    if (syncInProgress) {
      log.info("Sync already in progress.");
      typeof syncStatusCallbackWithTryCatch === "function" && syncStatusCallbackWithTryCatch(CodePush.SyncStatus.SYNC_IN_PROGRESS);
      return Promise.resolve(CodePush.SyncStatus.SYNC_IN_PROGRESS);
    }

    syncInProgress = true;
    const syncPromise = syncInternal(options, syncStatusCallbackWithTryCatch, downloadProgressCallbackWithTryCatch, handleBinaryVersionMismatchCallback);
    syncPromise
      .then(setSyncCompleted)
      .catch(setSyncCompleted);

    return syncPromise;
  };
})();

/*
 * The syncInternal method provides a simple, one-line experience for
 * incorporating the check, download and installation of an update.
 *
 * It simply composes the existing API methods together and adds additional
 * support for respecting mandatory updates, ignoring previously failed
 * releases, and displaying a standard confirmation UI to the end-user
 * when an update is available.
 */
async function syncInternal(options = {}, syncStatusChangeCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback) {
  const syncOptions = {
    deploymentKey: null,
    ignoreFailedUpdates: true,
    rollbackRetryOptions: null,
    installMode: CodePush.InstallMode.ON_NEXT_RESTART,
    mandatoryInstallMode: CodePush.InstallMode.IMMEDIATE,
    minimumBackgroundDuration: 0,
    updateDialog: null,
    // A key set to undefined would replace its default (for example `mandatoryInstallMode: undefined`
    // would turn IMMEDIATE into ON_NEXT_RESTART).
    ...Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
  };

  // The outcomes are logged below and in the API functions, whether or not a custom callback is passed.
  syncStatusChangeCallback = typeof syncStatusChangeCallback === "function"
    ? syncStatusChangeCallback
    : () => {};

  try {
    await CodePush.notifyApplicationReady();

    syncStatusChangeCallback(CodePush.SyncStatus.CHECKING_FOR_UPDATE);
    const remotePackage = await checkForUpdate(syncOptions.deploymentKey, handleBinaryVersionMismatchCallback);

    const doDownloadAndInstall = async () => {
      syncStatusChangeCallback(CodePush.SyncStatus.DOWNLOADING_PACKAGE);
      const localPackage = await remotePackage.download(downloadProgressCallback);

      // Determine the correct install mode based on whether the update is mandatory or not.
      const resolvedInstallMode = localPackage.isMandatory ? syncOptions.mandatoryInstallMode : syncOptions.installMode;

      syncStatusChangeCallback(CodePush.SyncStatus.INSTALLING_UPDATE);
      await localPackage.install(resolvedInstallMode, syncOptions.minimumBackgroundDuration, () => {
        syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED);
      });

      return CodePush.SyncStatus.UPDATE_INSTALLED;
    };

    const updateShouldBeIgnored = await shouldUpdateBeIgnored(remotePackage, syncOptions);

    if (!remotePackage || updateShouldBeIgnored) {
      if (updateShouldBeIgnored) {
          log.warn(`An update is available, but it is being ignored due to having been previously rolled back. ${logFields(packageLogFields(remotePackage))}`);
      }

      const currentPackage = await CodePush.getCurrentPackage();
      if (currentPackage && currentPackage.isPending) {
        log.info(`An installed update waits for the app to restart. ${logFields(packageLogFields(currentPackage))}`);
        syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_INSTALLED);
        return CodePush.SyncStatus.UPDATE_INSTALLED;
      } else {
        log.info("App is up to date.");
        syncStatusChangeCallback(CodePush.SyncStatus.UP_TO_DATE);
        return CodePush.SyncStatus.UP_TO_DATE;
      }
    } else if (syncOptions.updateDialog) {
      // updateDialog supports any truthy value (e.g. true, "goo", 12),
      // but we should treat a non-object value as just the default dialog
      if (typeof syncOptions.updateDialog !== "object") {
        syncOptions.updateDialog = CodePush.DEFAULT_UPDATE_DIALOG;
      } else {
        syncOptions.updateDialog = { ...CodePush.DEFAULT_UPDATE_DIALOG, ...syncOptions.updateDialog };
      }

      return await new Promise((resolve, reject) => {
        let message = null;
        let installButtonText = null;

        const dialogButtons = [];

        if (remotePackage.isMandatory) {
          message = syncOptions.updateDialog.mandatoryUpdateMessage;
          installButtonText = syncOptions.updateDialog.mandatoryContinueButtonLabel;
        } else {
          message = syncOptions.updateDialog.optionalUpdateMessage;
          installButtonText = syncOptions.updateDialog.optionalInstallButtonLabel;
          // Since this is an optional update, add a button
          // to allow the end-user to ignore it
          dialogButtons.push({
            text: syncOptions.updateDialog.optionalIgnoreButtonLabel,
            onPress: () => {
              log.info(`The user ignored the update. ${logFields(packageLogFields(remotePackage))}`);
              syncStatusChangeCallback(CodePush.SyncStatus.UPDATE_IGNORED);
              resolve(CodePush.SyncStatus.UPDATE_IGNORED);
            }
          });
        }
        
        // Since the install button should be placed to the 
        // right of any other button, add it last
        dialogButtons.push({
          text: installButtonText,
          onPress:() => {
            doDownloadAndInstall()
              .then(resolve, reject);
          }
        })

        // If the update has a description, and the developer
        // explicitly chose to display it, then set that as the message
        if (syncOptions.updateDialog.appendReleaseDescription && remotePackage.description) {
          message += `${syncOptions.updateDialog.descriptionPrefix} ${remotePackage.description}`;
        }

        log.info("Showing the update dialog, waiting for user.");
        syncStatusChangeCallback(CodePush.SyncStatus.AWAITING_USER_ACTION);
        Alert.alert(syncOptions.updateDialog.title, message, dialogButtons);
      });
    } else {
      return await doDownloadAndInstall();
    }
  } catch (error) {
    log.error("Sync failed.", error);
    syncStatusChangeCallback(CodePush.SyncStatus.UNKNOWN_ERROR);
    throw error;
  }
};

let CodePush;

function codePushify(options = {}) {
  let React;
  let ReactNative = require("react-native");

  try { React = require("react"); } catch (e) { }
  if (!React) {
    try { React = ReactNative.React; } catch (e) { }
    if (!React) {
      throw new Error("Unable to find the 'React' module.");
    }
  }

  if (!React.Component) {
    throw new Error(
`Unable to find the "Component" class, please either:
1. Upgrade to a newer version of React Native that supports it, or
2. Call the codePush.sync API in your component instead of using the @codePush decorator`
    );
  }

  const decorator = (RootComponent) => {
    class CodePushComponent extends React.Component {
      constructor(props) {
        super(props);
        this.rootComponentRef = React.createRef();
      }

      componentDidMount() {
        if (options.checkFrequency === CodePush.CheckFrequency.MANUAL) {
          CodePush.notifyAppReady();
        } else {
          const rootComponentInstance = this.rootComponentRef.current;

          let syncStatusCallback;
          if (rootComponentInstance && rootComponentInstance.codePushStatusDidChange) {
            syncStatusCallback = rootComponentInstance.codePushStatusDidChange.bind(rootComponentInstance);
          }

          let downloadProgressCallback;
          if (rootComponentInstance && rootComponentInstance.codePushDownloadDidProgress) {
            downloadProgressCallback = rootComponentInstance.codePushDownloadDidProgress.bind(rootComponentInstance);
          }

          let handleBinaryVersionMismatchCallback;
          if (rootComponentInstance && rootComponentInstance.codePushOnBinaryVersionMismatch) {
            handleBinaryVersionMismatchCallback = rootComponentInstance.codePushOnBinaryVersionMismatch.bind(rootComponentInstance);
          }

          CodePush.sync(options, syncStatusCallback, downloadProgressCallback, handleBinaryVersionMismatchCallback);

          if (options.checkFrequency === CodePush.CheckFrequency.ON_APP_RESUME) {
            ReactNative.AppState.addEventListener("change", (newState) => {
              if (newState === "active") {
                CodePush.sync(options, syncStatusCallback, downloadProgressCallback);
              }
            });
          }
        }
      }

      render() {
        const props = {...this.props};

        // We can set ref property on class components only (not stateless)
        // Check it by render method
        if (RootComponent.prototype && RootComponent.prototype.render) {
          props.ref = this.rootComponentRef;
        }

        return <RootComponent {...props} />
      }
    }

    return hoistStatics(CodePushComponent, RootComponent);
  }

  if (typeof options === "function") {
    // Infer that the root component was directly passed to us.
    return decorator(options);
  } else {
    return decorator;
  }
}

// If the "NativeCodePush" variable isn't defined, then
// the app didn't properly install the native module,
// and therefore, it doesn't make sense initializing
// the JS interface when it wouldn't work anyways.
if (NativeCodePush) {
  CodePush = codePushify;
  Object.assign(CodePush, {
    AcquisitionSdk: Sdk,
    checkForUpdate,
    getConfiguration,
    getCurrentPackage,
    getUpdateMetadata,
    notifyAppReady: notifyApplicationReady,
    notifyApplicationReady,
    restartApp,
    setUpTestDependencies,
    sync,
    disallowRestart: NativeCodePush.disallow,
    allowRestart: NativeCodePush.allow,
    clearUpdates,
    InstallMode: {
      IMMEDIATE: NativeCodePush.codePushInstallModeImmediate, // Restart the app immediately
      ON_NEXT_RESTART: NativeCodePush.codePushInstallModeOnNextRestart, // Don't artificially restart the app. Allow the update to be "picked up" on the next app restart
      ON_NEXT_RESUME: NativeCodePush.codePushInstallModeOnNextResume, // Restart the app the next time it is resumed from the background
      ON_NEXT_SUSPEND: NativeCodePush.codePushInstallModeOnNextSuspend // Restart the app _while_ it is in the background,
      // but only after it has been in the background for "minimumBackgroundDuration" seconds (0 by default),
      // so that user context isn't lost unless the app suspension is long enough to not matter
    },
    SyncStatus: {
      UP_TO_DATE: 0, // The running app is up-to-date
      UPDATE_INSTALLED: 1, // The app had an optional/mandatory update that was successfully downloaded and is about to be installed.
      UPDATE_IGNORED: 2, // The app had an optional update and the end-user chose to ignore it
      UNKNOWN_ERROR: 3,
      SYNC_IN_PROGRESS: 4, // There is an ongoing "sync" operation in progress.
      CHECKING_FOR_UPDATE: 5,
      AWAITING_USER_ACTION: 6,
      DOWNLOADING_PACKAGE: 7,
      INSTALLING_UPDATE: 8
    },
    CheckFrequency: {
      ON_APP_START: 0,
      ON_APP_RESUME: 1,
      MANUAL: 2
    },
    UpdateState: {
      RUNNING: NativeCodePush.codePushUpdateStateRunning,
      PENDING: NativeCodePush.codePushUpdateStatePending,
      LATEST: NativeCodePush.codePushUpdateStateLatest
    },
    DeploymentStatus: {
      FAILED: "DeploymentFailed",
      SUCCEEDED: "DeploymentSucceeded",
    },
    DEFAULT_UPDATE_DIALOG: {
      appendReleaseDescription: false,
      descriptionPrefix: " Description: ",
      mandatoryContinueButtonLabel: "Continue",
      mandatoryUpdateMessage: "An update is available that must be installed.",
      optionalIgnoreButtonLabel: "Ignore",
      optionalInstallButtonLabel: "Install",
      optionalUpdateMessage: "An update is available. Would you like to install it?",
      title: "Update available"
    },
    DEFAULT_ROLLBACK_RETRY_OPTIONS: {
      delayInHours: 24,
      maxRetryAttempts: 1
    }
  });
} else {
  log.error("The CodePush module doesn't appear to be properly installed. Please double-check that everything is setup correctly.");
}

module.exports = CodePush;

// Named exports, outside the legacy Object.assign namespace. In CommonJS they are still properties of the CodePush
// function, so they need the same native-module check (module.exports is undefined without it).
if (NativeCodePush) {
  module.exports.CodePushProvider = createCodePushProvider({
    sync: (options) => CodePush.sync(options),
    notifyAppReady: () => CodePush.notifyAppReady(),
    appState: AppState,
    CheckFrequency: CodePush.CheckFrequency,
  }, {
    store: updateStore,
    // Narrower than the legacy functions they wrap: the hook takes no positional callbacks, and reports through the
    // state instead.
    actions: {
      checkForUpdate: (options = {}) => checkForUpdate(options.deploymentKey),
      sync: (options) => sync(options),
      restartApp,
    },
  });
  module.exports.useCodePush = useCodePush;
  module.exports.useDownloadProgress = useDownloadProgress;
}