Partager via

Informations de référence sur l’API du Kit de développement logiciel (SDK) React Native Client

  • Article

Important

Visual Studio App Center est prévu pour la mise hors service le 31 mars 2025. Bien que vous puissiez continuer à utiliser Visual Studio App Center jusqu’à ce qu’il soit entièrement mis hors service, il existe plusieurs alternatives recommandées que vous pouvez envisager de migrer vers.

En savoir plus sur les chronologies de support et les alternatives.

Le plug-in CodePush est constitué de deux composants :

  1. Un module JavaScript, qui peut être importé/obligatoire et permet à l’application d’interagir avec le service pendant l’exécution (par exemple, vérifier les mises à jour, inspecter les métadonnées relatives à la mise à jour de l’application en cours d’exécution).

  2. API native (Objective-C et Java) qui permet à l’hôte d’application React Native de démarrer lui-même avec l’emplacement de bundle JS approprié.

Les sections suivantes décrivent en détail la forme et le comportement de ces API :

Référence API JavaScript

Lorsque vous avez besoinreact-native-code-push, l’objet de module fournit les méthodes de niveau supérieur suivantes en plus du décorateur de composant de niveau racine :

  • allowRestart : Les redémarrages par programme réels se produisent suite à l’installation d’une mise à jour et, éventuellement, redémarre immédiatement l’application si une mise à jour en attente a tenté de redémarrer l’application pendant que les redémarrages ont été interdits. Cette méthode est une API avancée et n’est nécessaire que si votre application n’a pas explicitement autorisé les redémarrages via la disallowRestart méthode.

  • checkForUpdate : demande au service CodePush si le déploiement d’application configuré a une mise à jour disponible.

  • disallowRestart : interdit temporairement les redémarrages programmatiques à se produire suite à l’installation d’une mise à jour CodePush. Cette méthode est une API avancée et est utile lorsqu’un composant de votre application (par exemple, un processus d’intégration) doit s’assurer qu’aucune interruption de l’utilisateur final ne peut se produire pendant sa durée de vie.

  • getCurrentPackage : récupère les métadonnées relatives à la mise à jour actuellement installée (par exemple, description, heure d’installation, taille).

    Remarque

    À partir du v1.10.3-beta module CodePush, getCurrentPackage est déconseillé en faveur de getUpdateMetadata*.

  • getUpdateMetadata : récupère les métadonnées d’une mise à jour installée (par exemple, description, obligatoire).

  • notifyAppReady : avertit le runtime CodePush qu’une mise à jour installée est considérée comme réussie. Si vous recherchez et installez manuellement des mises à jour (qui n’utilisent pas la méthode de synchronisation pour gérer tout pour vous), cette méthode DOIT être appelée ; sinon, CodePush traite la mise à jour comme ayant échoué et revient à la version précédente lors du prochain redémarrage de l’application.

  • restartApp : redémarre immédiatement l’application. S’il existe une mise à jour en attente, elle s’affiche immédiatement à l’utilisateur final. Sinon, l’appel de cette méthode a le même comportement que l’utilisateur final qui tue et redémarre le processus.

  • synchronisation : permet de rechercher une mise à jour, de la télécharger et de l’installer, avec un seul appel. Sauf si vous avez besoin d’une interface utilisateur ou d’un comportement personnalisé, nous recommandons à la plupart des développeurs d’utiliser cette méthode lors de l’intégration de CodePush dans leurs applications.

codePush

// Wrapper function
codePush(rootComponent: React.Component): React.Component;
codePush(options: CodePushOptions)(rootComponent: React.Component): React.Component;

// Decorator; Requires ES7 support
@codePush
@codePush(options: CodePushOptions)

Utilisé pour encapsuler un composant React à l’intérieur d’un composant React « ordre supérieur » qui sait comment synchroniser le bundle JavaScript de votre application et les ressources d’image lorsqu’elle est montée. En interne, le composant de commande supérieure appelle sync à l’intérieur de son componentDidMount handle de cycle de vie, qui exécute une vérification de mise à jour, télécharge la mise à jour s’il existe et installe la mise à jour pour vous.

Ce décorateur offre une prise en charge pour vous permettre de personnaliser son comportement afin d’activer facilement les applications avec différentes exigences. Voici quelques exemples de façons de l’utiliser (vous pouvez en choisir une ou même utiliser une combinaison) :

  1. Synchronisation silencieuse au démarrage de l’application (comportement le plus simple, par défaut). Votre application télécharge automatiquement les mises à jour disponibles et les applique la prochaine fois que l’application redémarre (par exemple, le système d’exploitation ou l’utilisateur final l’a tué, ou l’appareil a été redémarré). De cette façon, toute l’expérience de mise à jour est « silencieuse » pour l’utilisateur final, car elle ne voit aucune invite de mise à jour ni redémarrage de l’application « synthétique ».

    // Fully silent update that keeps the app in
// sync with the server, without ever
// interrupting the end user
class MyApp extends Component {}
MyApp = codePush(MyApp);

  2. Synchronisation silencieuse chaque fois que l’application reprend. Identique à 1, sauf que nous vérifions les mises à jour, ou nous appliquons une mise à jour si une mise à jour existe chaque fois que l’application revient au premier plan après avoir été « en arrière-plan ».

    // Sync for updates every time the app resumes.
class MyApp extends Component {}
MyApp = codePush({ checkFrequency: codePush.CheckFrequency.ON_APP_RESUME, installMode: codePush.InstallMode.ON_NEXT_RESUME })(MyApp);

  3. Mode interactif. Lorsqu’une mise à jour est disponible, demandez à l’utilisateur final d’être autorisé avant de le télécharger, puis appliquez immédiatement la mise à jour. Si une mise à jour a été publiée à l’aide de l’indicateur mandatory , l’utilisateur final serait toujours informé de la mise à jour, mais il n’aurait pas le choix de l’ignorer.

    // Active update that lets the end user know
// about each update, and displays it to them
// immediately after downloading it
class MyApp extends Component {}
MyApp = codePush({ updateDialog: true, installMode: codePush.InstallMode.IMMEDIATE })(MyApp);

  4. Progression du journal/affichage. Pendant que l’application est synchronisée avec le serveur pour les mises à jour, utilisez les hooks d’événements ou codePushDownloadDidProgress les codePushStatusDidChange crochets d’événements pour déconnecter les différentes étapes de ce processus, ou même afficher une barre de progression à l’utilisateur.

    // Make use of the event hooks to keep track of
// the different stages of the sync process.
class MyApp extends Component {
    codePushStatusDidChange(status) {
        switch(status) {
            case codePush.SyncStatus.CHECKING_FOR_UPDATE:
                console.log("Checking for updates.");
                break;
            case codePush.SyncStatus.DOWNLOADING_PACKAGE:
                console.log("Downloading package.");
                break;
            case codePush.SyncStatus.INSTALLING_UPDATE:
                console.log("Installing update.");
                break;
            case codePush.SyncStatus.UP_TO_DATE:
                console.log("Up-to-date.");
                break;
            case codePush.SyncStatus.UPDATE_INSTALLED:
                console.log("Update installed.");
                break;
        }
    }

    codePushDownloadDidProgress(progress) {
        console.log(progress.receivedBytes + " of " + progress.totalBytes + " received.");
    }
}
MyApp = codePush(MyApp);

CodePushOptions

Le codePush décorateur accepte un objet « options » qui vous permet de personnaliser de nombreux aspects du comportement par défaut mentionné ci-dessus :

  • checkFrequency (codePush.CheckFrequency) : spécifie quand vous souhaitez rechercher les mises à jour. La valeur par défaut est codePush.CheckFrequency.ON_APP_START. Reportez-vous à la CheckFrequency référence d’énumération pour obtenir une description des options disponibles et de ce qu’elles font.

  • deploymentKey (string) : spécifie la clé de déploiement à laquelle vous souhaitez interroger une mise à jour. Par défaut, cette valeur est dérivée du fichier Info.plist (iOS) et du fichier MainActivity.java (Android), mais cette option vous permet de la remplacer du côté script si vous devez utiliser dynamiquement un autre déploiement.

  • installMode (codePush.InstallMode) : spécifie quand vous souhaitez installer des mises à jour facultatives (celles qui ne sont pas marquées comme obligatoires). La valeur par défaut est codePush.InstallMode.ON_NEXT_RESTART. Reportez-vous à la InstallMode référence d’énumération pour obtenir une description des options disponibles et de ce qu’elles font.

  • mandatoryInstallMode (codePush.InstallMode) : spécifie quand vous souhaitez installer des mises à jour, qui sont marquées comme obligatoires. La valeur par défaut est codePush.InstallMode.IMMEDIATE. Reportez-vous à la InstallMode référence d’énumération pour obtenir une description des options disponibles et de ce qu’elles font.

  • minimumBackgroundDuration (Nombre) : spécifie le nombre minimal de secondes pour que l’application soit en arrière-plan avant de redémarrer l’application. Cette propriété s’applique uniquement aux mises à jour installées à l’aide InstallMode.ON_NEXT_RESUME ou InstallMode.ON_NEXT_SUSPEND, et peut être utile pour obtenir votre mise à jour avant les utilisateurs finaux plus tôt, sans être trop obtrusive. 0La valeur par défaut est , qui applique la mise à jour immédiatement après une reprise, ou sauf si la suspension de l’application est suffisamment longue pour ne pas avoir d’importance, mais elle est en arrière-plan.

  • updateDialog (UpdateDialogOptions) : objet « options » utilisé pour déterminer si une boîte de dialogue de confirmation doit être affichée à l’utilisateur final lorsqu’une mise à jour est disponible et, le cas échéant, quelles chaînes utiliser. La valeur par défaut est null, ce qui désactive la boîte de dialogue. La définition de cette true valeur active la boîte de dialogue avec les chaînes par défaut et le passage d’un objet à ce paramètre permet d’activer la boîte de dialogue, ainsi que de remplacer une ou plusieurs des chaînes par défaut. Avant d’activer cette option dans une application distribuée par App Store, consultez cette note.

    La liste suivante représente les options disponibles et leurs valeurs par défaut :

    • appendReleaseDescription (booléen) : indique si vous souhaitez ajouter la description d’une version disponible au message de notification, qui s’affiche à l’utilisateur final. La valeur par défaut est false.

    • descriptionPrefix (chaîne) : indique la chaîne avec laquelle vous souhaitez préfixer la description de mise en production, le cas échéant, lors de l’affichage de la notification de mise à jour à l’utilisateur final. La valeur par défaut est " Description: "

    • mandatoryContinueButtonLabel (String) : texte à utiliser pour le bouton sur lequel l’utilisateur final doit appuyer pour installer une mise à jour obligatoire. La valeur par défaut est "Continue".

    • mandatoryUpdateMessage (String) : texte utilisé comme corps d’une notification de mise à jour, lorsque la mise à jour est spécifiée comme obligatoire. La valeur par défaut est "An update is available that must be installed.".

    • optionalIgnoreButtonLabel (String) : texte à utiliser pour le bouton sur lequel l’utilisateur final peut appuyer pour ignorer une mise à jour facultative disponible. La valeur par défaut est "Ignore".

    • optionalInstallButtonLabel (String) : texte à utiliser pour le bouton sur lequel l’utilisateur final peut appuyer pour installer une mise à jour facultative. La valeur par défaut est "Install".

    • optionalUpdateMessage (String) : texte utilisé comme corps d’une notification de mise à jour, lorsque la mise à jour est facultative. La valeur par défaut est "An update is available. Would you like to install it?".

    • title (String) : texte utilisé comme en-tête d’une notification de mise à jour qui s’affiche à l’utilisateur final. La valeur par défaut est "Update available".

  • rollbackRetryOptions (RollbackRetryOptions) : le mécanisme de nouvelle tentative de restauration permet à l’application de tenter de réinstaller une mise à jour qui a été restaurée précédemment (avec les restrictions spécifiées dans les options). Il s’agit d’un objet « options » utilisé pour déterminer si une nouvelle tentative de restauration doit se produire et, le cas échéant, quels paramètres utiliser pour la nouvelle tentative de restauration. Cette valeur par défaut est Null, ce qui a pour effet de désactiver le mécanisme de nouvelle tentative. Si vous définissez cette valeur sur la vérité, le mécanisme de nouvelle tentative avec les paramètres par défaut et le passage d’un objet à ce paramètre permet d’activer la nouvelle tentative de restauration, ainsi que de remplacer une ou plusieurs des valeurs par défaut.

    La liste suivante représente les options disponibles et leurs valeurs par défaut :

    • delayInHours (nombre) : spécifie la durée minimale en heures pendant laquelle l’application attend après la dernière restauration avant de tenter de réinstaller le même package restauré. Ne peut pas être inférieur à 0. Peut être un nombre flottant. La valeur par défaut est 24.

    • maxRetryAttempts (Nombre) : spécifie le nombre maximal de tentatives de nouvelle tentative que l’application peut effectuer avant d’arrêter d’essayer. Ne peut pas être inférieur à 1. La valeur par défaut est 1.

codePushStatusDidChange (hook d’événement)

Appelé lorsque le processus de synchronisation passe d’une étape à l’autre dans le processus de mise à jour globale. Le hook d’événement est appelé avec un code d’état qui représente l’état actuel et peut être l’une des SyncStatus valeurs.

codePushDownloadDidProgress (event hook)

Appelé régulièrement lorsqu’une mise à jour disponible est téléchargée à partir du serveur CodePush. La méthode est appelée avec un DownloadProgress objet, qui contient les deux propriétés suivantes :

  • totalBytes (Number) : nombre total d’octets attendu pour cette mise à jour (c’est la taille de l’ensemble de fichiers, qui a changé par rapport à la version précédente).

  • receivedBytes (Number) : nombre d’octets téléchargés jusqu’à présent, qui peuvent être utilisés pour suivre la progression du téléchargement.

codePush.allowRestart

codePush.allowRestart(): void;

Réaffecte les redémarrages programmatiques à effectuer, qui auraient autrement été rejetés en raison d’un appel précédent à disallowRestart. Si disallowRestart elle n’a jamais été appelée en premier lieu, l’appel de cette méthode entraîne une opération sans opération.

Si une mise à jour CodePush est actuellement en attente, qui a tenté de redémarrer l’application (par exemple, elle a été utilisée InstallMode.IMMEDIATE), mais a été bloquée en raison d’avoir disallowRestart été appelée, l’appel allowRestart entraîne un redémarrage immédiat. Ce redémarrage permet l’application de la mise à jour dès que possible, sans interrompre l’utilisateur final pendant les flux de travail critiques (par exemple, un processus d’intégration).

Par exemple, l’appel allowRestart déclencherait un redémarrage immédiat si l’un des trois scénarios mentionnés dans la disallowRestart documentation s’est produit après disallowRestart avoir été appelé. Toutefois, l’appel allowRestart ne déclencherait pas de redémarrage si les points suivants sont vrais :

  1. Aucune mise à jour CodePush n’a été installée depuis la dernière fois disallowRestart , et il n’est donc pas nécessaire de redémarrer.

  2. Il existe actuellement une mise à jour CodePush en attente, mais elle a été installée via InstallMode.ON_NEXT_RESTART, donc un redémarrage programmatique n’est pas nécessaire.

  3. Il existe actuellement une mise à jour CodePush en attente, mais elle a été installée via InstallMode.ON_NEXT_RESUME et l’application n’a pas encore été mise en arrière-plan. Il n’est donc pas nécessaire de redémarrer par programmation.

  4. Aucun appel n’a restartApp été effectué depuis la dernière fois disallowRestart .

Ce comportement garantit qu’aucun redémarrage ne sera déclenché suite à l’appel, sauf si un redémarrage allowRestart a été explicitement demandé pendant la période non autorisée. De cette façon, allowRestart est similaire à l’appel restartApp(true), sauf que l’ancien déclenchera un redémarrage uniquement si la mise à jour en attente souhaitait redémarrer, mais ce dernier redémarrerait tant qu’une mise à jour est en attente.

Consultez disallowRestart pour obtenir un exemple de la façon dont cette méthode peut être utilisée.

codePush.checkForUpdate

codePush.checkForUpdate(deploymentKey: String = null, handleBinaryVersionMismatchCallback: (update: RemotePackage) => void): Promise<RemotePackage>;

Interroge le service CodePush pour déterminer si le déploiement d’application configuré dispose d’une mise à jour disponible. Par défaut, elle utilise la clé de déploiement configurée dans votre fichier Info.plist (iOS) ou MainActivity.java fichier (Android), mais vous pouvez la remplacer en spécifiant une valeur via le paramètre facultatif deploymentKey . Cela peut être utile lorsque vous souhaitez « rediriger » dynamiquement un utilisateur vers un déploiement spécifique, par exemple autoriser un « accès anticipé » via un œuf de pâques ou un commutateur de paramètre utilisateur.

Le deuxième paramètre handleBinaryVersionMismatchCallback facultatif est une fonction de rappel facultative qui peut être utilisée pour avertir l’utilisateur s’il existe une mise à jour binaire. Par exemple, considérez un cas d’usage où la version binaire actuellement installée est 1.0.1 avec une étiquette (étiquette push de code) v1. Le code natif ultérieur a été modifié dans le cycle de développement et la version binaire a été mise à jour vers la version 1.0.2. Lorsqu’une vérification de mise à jour codepush est déclenchée, nous ignorons les mises à jour ayant une incompatibilité de version binaire (car la mise à jour ne cible pas la version binaire de l’application actuellement installée). Dans ce cas, l’application installée (1.0.1) ignore la mise à jour ciblant la version 1.0.2. Vous pouvez utiliser handleBinaryVersionMismatchCallback pour fournir un crochet pour gérer ces situations.

Important

Soyez prudent pour utiliser les alertes dans ce rappel si vous développez une application iOS, en raison du processus de révision d’App Store : les applications ne doivent pas forcer les utilisateurs à évaluer l’application, à passer en revue l’application, à télécharger d’autres applications ou à d’autres actions similaires pour accéder aux fonctionnalités, au contenu ou à l’utilisation de l’application.

Cette méthode retourne un Promise, qui se résout à l’une des deux valeurs possibles :

  1. null s’il n’existe pas de mise à jour disponible. Cela peut se produire dans les scénarios suivants :

    1. Le déploiement configuré ne contient aucune version, et donc rien à mettre à jour.
    2. La dernière version du déploiement configuré cible une version binaire différente de celle que vous exécutez actuellement (plus ancienne ou ultérieure).
    3. L’application en cours d’exécution dispose déjà de la dernière version du déploiement configuré. Par conséquent, elle n’en a pas besoin à nouveau.
    4. La dernière version du déploiement configuré est actuellement marquée comme étant désactivée, elle n’est donc pas autorisée à être téléchargée.
    5. La dernière version du déploiement configuré est dans un état de « déploiement actif » et l’appareil demandeur ne se trouve pas dans le pourcentage d’utilisateurs qui y sont éligibles.

  2. Instance RemotePackage qui représente une mise à jour disponible qui peut être inspectée ou téléchargée ultérieurement.

Exemple d’utilisation :

codePush.checkForUpdate()
.then((update) => {
    if (!update) {
        console.log("The app is up to date!");
    } else {
        console.log("An update is available! Should we download it?");
    }
});

codePush.disallowRestart

codePush.disallowRestart(): void;

Interdit temporairement les redémarrages programmatiques de se produire suite à l’un des scénarios suivants :

  1. Une mise à jour CodePush est installée à l’aide de InstallMode.IMMEDIATE

  2. Une mise à jour CodePush est installée à l’aide InstallMode.ON_NEXT_RESUME de laquelle l’application est reprise à partir de l’arrière-plan (éventuellement limitée par la minimumBackgroundDuration propriété)

  3. La restartApp méthode a été appelée

    Remarque

    Les étapes 1 et 2 fonctionnent efficacement en vous appelant restartApp , de sorte que vous pouvez considérer comme disallowRestart bloquant tout appel à restartApp, que votre application l’appelle directement ou indirectement.

Après avoir appelé cette méthode, tous les appels à sync devront toujours être autorisés à rechercher une mise à jour, à le télécharger et à l’installer, mais une tentative de redémarrage de l’application serait mise en file d’attente jusqu’à ce qu’elle allowRestart soit appelée. De cette façon, la demande de redémarrage est capturée et peut être « vidée » chaque fois que vous souhaitez l’autoriser à se produire.

Il s’agit d’une API avancée et est principalement utile lorsque des composants individuels au sein de votre application (comme un processus d’intégration) doivent s’assurer qu’aucune interruption de l’utilisateur final ne peut se produire pendant sa durée de vie, tout en continuant à permettre à l’application de continuer à se synchroniser avec le serveur CodePush à son propre rythme et en utilisant les modes d’installation appropriés. Cela offre l’avantage de permettre à l’application de découvrir et de télécharger les mises à jour disponibles dès que possible, tout en empêchant les interruptions pendant les expériences clés de l’utilisateur final.

En guise d’alternative, vous pouvez également utiliser InstallMode.ON_NEXT_RESTART chaque fois que vous appelez sync (qui n’essaiera jamais de redémarrer l’application par programmation), puis d’appeler restartApp explicitement à des points de votre application qui sont « sécurisés » pour le faire. disallowRestart fournit une autre approche pour cela lorsque le code qui se synchronise avec le serveur CodePush est distinct du code/composants qui souhaitent appliquer une stratégie de non-redémarrage.

Exemple d’utilisation :

class OnboardingProcess extends Component {
    ...

    componentWillMount() {
        // Ensure that any CodePush updates that are
        // synchronized in the background can't trigger
        // a restart while this component is mounted.
        codePush.disallowRestart();
    }

    componentWillUnmount() {
        // Reallow restarts, and optionally trigger
        // a restart if one was currently pending.
        codePush.allowRestart();
    }

    ...
}

codePush.getCurrentPackage

Remarque

Cette méthode est considérée comme déconseillée à partir du v1.10.3-beta module CodePush. Si vous exécutez cette version (ou une version ultérieure), nous vous recommandons d’utiliser la version à la codePush.getUpdateMetadata place, car elle a un comportement plus prévisible.

codePush.getCurrentPackage(): Promise<LocalPackage>;

Récupère les métadonnées relatives au « package » actuellement installé (par exemple, description, heure d’installation). Cela peut être utile pour les scénarios tels que l’affichage d’une boîte de dialogue « Nouveautés ? » une fois qu’une mise à jour a été appliquée ou vérifie s’il existe une mise à jour en attente qui attend d’être appliquée via un cv ou un redémarrage.

Cette méthode retourne un Promise, qui se résout à l’une des deux valeurs possibles :

  1. null si l’application exécute actuellement le bundle JS à partir du fichier binaire et non d’une mise à jour CodePush. Cela se produit dans les scénarios suivants :

    1. L’utilisateur final a installé le fichier binaire de l’application et n’a pas encore installé une mise à jour CodePush
    2. L’utilisateur final a installé une mise à jour du fichier binaire (par exemple à partir du magasin), qui a effacé les anciennes mises à jour CodePush et a donné priorité au binaire JS dans le fichier binaire.

  2. Instance LocalPackage qui représente les métadonnées de la mise à jour CodePush en cours d’exécution.

Exemple d’utilisation :

codePush.getCurrentPackage()
.then((update) => {
    // If the current app "session" represents the first time
    // this update has run, and it had a description provided
    // with it upon release, let's show it to the end user
    if (update.isFirstRun && update.description) {
        // Display a "what's new?" modal
    }
});

codePush.getUpdateMetadata

codePush.getUpdateMetadata(updateState: UpdateState = UpdateState.RUNNING): Promise<LocalPackage>;

Récupère les métadonnées d’une mise à jour installée (comme la description, obligatoire) dont l’état correspond au paramètre spécifié updateState . Cela peut être utile pour les scénarios tels que l’affichage d’une boîte de dialogue « Nouveautés ? » une fois qu’une mise à jour a été appliquée ou vérifie s’il existe une mise à jour en attente qui attend d’être appliquée via un cv ou un redémarrage. Pour plus d’informations sur les états de mise à jour possibles et ce qu’ils représentent, consultez la référence UpdateState.

Cette méthode retourne un Promise, qui se résout à l’une des deux valeurs possibles :

  1. null si une mise à jour avec l’état spécifié n’existe pas actuellement. Cela se produit dans les scénarios suivants :

    1. L’utilisateur final n’a pas encore installé de mises à jour CodePush et c’est pourquoi aucune métadonnées n’est disponible pour les mises à jour, quel que soit le updateState paramètre que vous spécifiez.

    2. L’utilisateur final a installé une mise à jour du fichier binaire (par exemple à partir du magasin), qui a effacé les anciennes mises à jour CodePush et a donné priorité au binaire JS dans le fichier binaire. Il présenterait le même comportement que #1

    3. Le updateState paramètre est défini sur UpdateState.RUNNING, mais l’application n’exécute pas actuellement de mise à jour CodePush. Il peut y avoir une mise à jour en attente, mais l’application n’a pas encore été redémarrée pour la rendre active.

    4. Le updateState paramètre est défini sur UpdateState.PENDING, mais l’application n’a pas de mises à jour en attente.

  2. Instance LocalPackage qui représente les métadonnées de la mise à jour CodePush actuellement demandée (en cours d’exécution ou en attente).

Exemple d’utilisation :

// Check if there's currently a CodePush update running, and if
// so, register it with the HockeyApp SDK (https://github.com/slowpath/react-native-hockeyapp)
// so that crash reports will correctly display the JS bundle version the user was running.
codePush.getUpdateMetadata().then((update) => {
    if (update) {
        hockeyApp.addMetadata({ CodePushRelease: update.label });
    }
});

// Check to see if there's still an update pending.
codePush.getUpdateMetadata(UpdateState.PENDING).then((update) => {
    if (update) {
        // There's a pending update, do we want to force a restart?
    }
});

codePush.notifyAppReady

codePush.notifyAppReady(): Promise<void>;

Avertit le runtime CodePush qu’une mise à jour fraîchement installée doit être considérée comme réussie. Par conséquent, une restauration automatique côté client n’est pas nécessaire. Il est obligatoire d’appeler cette fonction quelque part dans le code du bundle mis à jour. Dans le cas contraire, lorsque l’application redémarre ensuite, le runtime CodePush suppose que la mise à jour installée a échoué et revient à la version précédente. Ce comportement existe pour vous assurer que vos utilisateurs finaux ne sont pas bloqués par une mise à jour interrompue.

Si vous utilisez la sync fonction et que vous effectuez votre vérification de mise à jour au démarrage de l’application, vous n’avez pas besoin d’appeler notifyAppReady manuellement, car sync vous l’appelez pour vous. Ce comportement existe en raison de l’hypothèse que, lorsqu’il sync est appelé dans votre application, il représente une bonne approximation d’un démarrage réussi.

Remarque

Cette méthode est également alias ( notifyApplicationReady pour la compatibilité descendante).

codePush.restartApp

codePush.restartApp(onlyIfUpdateIsPending: Boolean = false): void;

Redémarre immédiatement l’application. Si une valeur de vérité est fournie au onlyIfUpdateIsPending paramètre, l’application redémarre uniquement s’il existe en fait une mise à jour en attente en attente d’application.

Cette méthode est destinée aux scénarios avancés et est principalement utile lorsque les conditions suivantes sont remplies :

  1. Votre application spécifie une valeur de mode d’installation de ou ON_NEXT_RESUME lors de ON_NEXT_RESTART l’appel des méthodes ou LocalPackage.install des sync méthodes. Cela n’applique pas votre mise à jour tant que l’application n’a pas redémarré (par l’utilisateur final ou le système d’exploitation) ou repris, et ainsi, la mise à jour ne s’affiche pas immédiatement à l’utilisateur final.

  2. Vous disposez d’un événement utilisateur spécifique à l’application (par exemple, l’utilisateur final a accédé à la route d’accueil de l’application) qui vous permet d’appliquer la mise à jour de manière discrète et d’obtenir potentiellement la mise à jour à l’utilisateur final plus tôt que d’attendre le redémarrage ou la reprise suivant.

codePush.sync

codePush.sync(options: Object, syncStatusChangeCallback: function(syncStatus: Number), downloadProgressCallback: function(progress: DownloadProgress), handleBinaryVersionMismatchCallback: function(update: RemotePackage)): Promise<Number>;

Synchronise le bundle JavaScript de votre application et les ressources d’image avec la dernière version du déploiement configuré. Contrairement à la méthode checkForUpdate , qui vérifie la présence d’une mise à jour, et nous allons contrôler ce qu’il faut faire ensuite, sync gère la vérification de la mise à jour, le téléchargement et l’expérience d’installation pour vous.

Cette méthode prend en charge deux « modes » différents (mais personnalisables) pour activer facilement les applications avec des exigences différentes :

  1. Le mode silencieux (comportement par défaut) télécharge automatiquement les mises à jour disponibles et les applique la prochaine fois que l’application redémarre (par exemple, le système d’exploitation ou l’utilisateur final l’a tué, ou l’appareil a été redémarré). De cette façon, toute l’expérience de mise à jour est « silencieuse » pour l’utilisateur final, car elle ne voit aucune invite de mise à jour ni redémarrage de l’application « synthétique ».

  2. Mode actif, qui, lorsqu’une mise à jour est disponible, invite l’utilisateur final à obtenir l’autorisation avant de le télécharger, puis applique immédiatement la mise à jour. Si une mise à jour a été publiée à l’aide de l’indicateur mandatory , l’utilisateur final serait toujours informé de la mise à jour, mais il n’aurait pas le choix de l’ignorer.

Exemple d’utilisation :

// Fully silent update that keeps the app in
// sync with the server, without ever
// interrupting the end user
codePush.sync();

// Active update, which lets the end user know
// about each update, and displays it to them
// immediately after downloading it
codePush.sync({ updateDialog: true, installMode: codePush.InstallMode.IMMEDIATE });

Conseil

Si vous souhaitez décider si vous vérifiez ou téléchargez une mise à jour disponible en fonction du niveau de batterie de l’appareil de l’utilisateur final, des conditions réseau, etc. encapsulez l’appel dans sync une condition qui garantit que vous l’appelez uniquement lorsque vous le souhaitez.

SyncOptions

Bien que la sync méthode tente de faciliter l’utilisation de mises à jour silencieuses et actives avec peu de configuration, elle accepte un objet « options » qui vous permet de personnaliser de nombreux aspects du comportement par défaut mentionné ci-dessus. Les options disponibles sont identiques à CodePushOptions, à l’exception de l’option checkFrequency :

Exemple d’utilisation :

// Use a different deployment key for this
// specific call, instead of the one configured
// in the Info.plist file
codePush.sync({ deploymentKey: "KEY" });

// Download the update silently, but install it on
// the next resume, as long as at least 5 minutes
// has passed since the app was put into the background.
codePush.sync({ installMode: codePush.InstallMode.ON_NEXT_RESUME, minimumBackgroundDuration: 60 * 5 });

// Download the update silently, and install optional updates
// on the next restart, but install mandatory updates on the next resume.
codePush.sync({ mandatoryInstallMode: codePush.InstallMode.ON_NEXT_RESUME });

// Changing the title displayed in the
// confirmation dialog of an "active" update
codePush.sync({ updateDialog: { title: "An update is available!" } });

// Displaying an update prompt which includes the
// description for the CodePush release
codePush.sync({
   updateDialog: {
    appendReleaseDescription: true,
    descriptionPrefix: "\n\nChange log:\n"
   },
   installMode: codePush.InstallMode.IMMEDIATE
});

// Shortening the retry delay and increasing
// the number of maximum retry attempts
// in comparison to defaults
codePush.sync({
   rollbackRetryOptions: {
    delayInHours: 8,
    maxRetryAttempts: 3
   }
});

Outre les options, la sync méthode accepte également plusieurs paramètres de fonction facultatifs, ce qui vous permet de vous abonner au cycle de vie du sync « pipeline » pour afficher une interface utilisateur supplémentaire si nécessaire (par exemple, une « vérification de la mise à jour modale ou d’un mode de progression du téléchargement) :

  • syncStatusChangedCallback ((syncStatus : Number) => void) : appelé lorsque le processus de synchronisation passe d’une étape à l’autre dans le processus de mise à jour global. La méthode est appelée avec un code d’état, qui représente l’état actuel et peut être l’une des SyncStatus valeurs.

  • downloadProgressCallback ((progress : DownloadProgress) => void) : appelé régulièrement lorsqu’une mise à jour disponible est téléchargée à partir du serveur CodePush. La méthode est appelée avec un DownloadProgress objet, qui contient les deux propriétés suivantes :

    • totalBytes (Number) : nombre total d’octets attendu pour cette mise à jour (c’est la taille de l’ensemble de fichiers, qui a changé par rapport à la version précédente).

    • receivedBytes (Number) : nombre d’octets téléchargés jusqu’à présent, qui peuvent être utilisés pour suivre la progression du téléchargement.

  • handleBinaryVersionMismatchCallback ((update : RemotePackage) => void) : appelé lorsqu’il existe une mise à jour binaire disponible. La méthode est appelée avec un RemotePackage objet. Pour plus d’informations, consultez la section codePush.checkForUpdate .

Exemple d’utilisation :

// Prompt the user when an update is available
// and then display a "downloading" modal
codePush.sync({ updateDialog: true },
  (status) => {
      switch (status) {
          case codePush.SyncStatus.DOWNLOADING_PACKAGE:
              // Show "downloading" modal
              break;
          case codePush.SyncStatus.INSTALLING_UPDATE:
              // Hide "downloading" modal
              break;
      }
  },
  ({ receivedBytes, totalBytes, }) => {
    /* Update download modal progress */
  }
);

Cette méthode retourne un Promisecode résolu en code SyncStatus qui indique pourquoi l’appel sync a réussi. Ce code peut être l’une des valeurs suivantes SyncStatus :

  • codePush.SyncStatus.UP_TO_DATE (4) : l’application est à jour avec le serveur CodePush.

  • codePush.SyncStatus.UPDATE_IGNORED (5) : l’application avait une mise à jour facultative, que l’utilisateur final a choisi d’ignorer. (Cela s’applique uniquement lorsque celui-ci updateDialog est utilisé)

  • codePush.SyncStatus.UPDATE_INSTALLED (6) : la mise à jour a été installée et sera exécutée immédiatement après le retour de la syncStatusChangedCallback fonction ou la prochaine fois que l’application reprend/redémarre, en fonction de l’élément InstallMode spécifié dans SyncOptions.

  • codePush.SyncStatus.SYNC_IN_PROGRESS (7) : une opération en cours sync d’exécution empêche l’exécution de l’appel actuel.

La sync méthode peut être appelée partout où vous souhaitez rechercher une mise à jour. Cela peut être dans l’événement componentWillMount de cycle de vie de votre composant racine, le gestionnaire onPress d’un <TouchableHighlight> composant, dans le rappel d’un minuteur périodique, ou tout autre élément logique pour vos besoins. Comme la checkForUpdate méthode, elle effectue la requête réseau pour rechercher une mise à jour en arrière-plan. Elle n’aura donc pas d’impact sur la réactivité de votre thread d’interface utilisateur ou du thread JavaScript.

Objets de package

Les checkForUpdate méthodes et getUpdateMetadata les méthodes retournent Promise des objets, qui, lorsqu’ils sont résolus, fournissent l’accès aux objets « package ». Le package représente votre mise à jour de code et toutes les métadonnées supplémentaires (telles que la description, obligatoire ?). L’API CodePush a la distinction entre les types de packages suivants :

  • LocalPackage : représente une mise à jour téléchargée qui est déjà en cours d’exécution ou qui a été installée et qui est en attente de redémarrage d’une application.

  • RemotePackage : représente une mise à jour disponible sur le serveur CodePush qui n’a pas encore été téléchargé.

LocalPackage

Contient des détails sur une mise à jour qui a été téléchargée localement ou déjà installée. Vous pouvez obtenir une référence à une instance de cet objet en appelant la méthode au niveau getUpdateMetadata du module ou en tant que valeur de la promesse retournée par la RemotePackage.download méthode.

Propriétés
  • appVersion : version binaire de l’application sur laquelle cette mise à jour dépend. Il s’agit de la valeur spécifiée via le paramètre lors de l’appel appStoreVersion de la commande cli release . (String)
  • deploymentKey : clé de déploiement utilisée pour télécharger cette mise à jour à l’origine. (String)
  • description : description de la mise à jour. Il s’agit de la même valeur que celle que vous avez spécifiée dans l’interface CLI lorsque vous avez publié la mise à jour. (String)
  • ÉchecInstall : indique si cette mise à jour a été précédemment installée, mais a été restaurée. La sync méthode ignore automatiquement les mises à jour, qui ont échoué précédemment. Vous devez donc uniquement vous soucier de cette propriété si vous utilisez checkForUpdate. (Boolean)
  • isFirstRun : indique si c’est la première fois que la mise à jour a été exécutée après avoir été installée. Cela est utile pour déterminer si vous souhaitez afficher un « Nouveautés ? » Interface utilisateur à l’utilisateur final après avoir installé une mise à jour. (Boolean)
  • isMandatory : indique si la mise à jour est considérée comme obligatoire. Il s’agit de la valeur spécifiée dans l’interface CLI lors de la publication de la mise à jour. (Boolean)
  • isPending : indique si cette mise à jour est dans un état « en attente ». Quand true, cela signifie que la mise à jour a été téléchargée et installée, mais que le redémarrage de l’application nécessaire pour l’appliquer n’a pas encore eu lieu, et c’est pourquoi ses modifications ne sont pas actuellement visibles pour l’utilisateur final. (Boolean)
  • étiquette : étiquette interne automatiquement donnée à la mise à jour par le serveur CodePush, par v5exemple . Cette valeur identifie de manière unique la mise à jour au sein de son déploiement. (String)
  • packageHash : valeur de hachage SHA de la mise à jour. (String)
  • packageSize : taille du code contenu dans la mise à jour, en octets. (Nombre)
Méthodes
  • install(installMode : codePush.InstallMode = codePush.InstallMode.ON_NEXT_RESTART, minimumBackgroundDuration = 0) : Promise<void> : installe la mise à jour en l’enregistrant sur le disque où le runtime s’attend à trouver la dernière version de l’application. Le installMode paramètre contrôle lorsque les modifications sont présentées à l’utilisateur final. La valeur par défaut est d’attendre que l’application suivante redémarre pour afficher les modifications, mais vous pouvez faire référence à la InstallMode référence d’énumération pour obtenir une description des options disponibles et de ce qu’elles font. Si le installMode paramètre est défini InstallMode.ON_NEXT_RESUMEsur , le minimumBackgroundDuration paramètre vous permet de contrôler la durée pendant laquelle l’application doit avoir été en arrière-plan avant de forcer l’installation après sa reprise.

RemotePackage

Contient des détails sur une mise à jour disponible pour le téléchargement à partir du serveur CodePush. Vous obtenez une référence à une instance de cet objet en appelant la checkForUpdate méthode lorsqu’une mise à jour est disponible. Si vous utilisez l’API sync , vous n’avez pas besoin de vous soucier RemotePackagedu processus de téléchargement et d’installation automatiquement.

Propriétés

Il RemotePackage hérite de toutes les mêmes propriétés que le LocalPackage, mais inclut un autre :

  • downloadUrl : URL où le package est disponible pour le téléchargement. Cette propriété n’est nécessaire qu’à une utilisation avancée, car la download méthode gère automatiquement l’acquisition des mises à jour pour vous. (String)
Méthodes
  • download(downloadProgressCallback ?: Function) : Promise<LocalPackage> : Télécharge la mise à jour disponible à partir du service CodePush. Si une downloadProgressCallback valeur est spécifiée, elle est appelée régulièrement avec un DownloadProgress objet ({ totalBytes: Number, receivedBytes: Number }) qui signale la progression du téléchargement jusqu’à ce qu’il se termine. Retourne une promesse qui se résout avec le LocalPackage.

Énumérations

L’API CodePush inclut les énumérations suivantes, qui peuvent être utilisées pour personnaliser l’expérience de mise à jour :

InstallMode

Cette énumération spécifie quand vous souhaitez qu’une mise à jour installée soit appliquée, et peut être passée aux méthodes ou LocalPackage.install aux sync méthodes. Il inclut les valeurs suivantes :

  • codePush.InstallMode.IMMEDIATE (0) : indique que vous souhaitez installer la mise à jour et redémarrer l’application immédiatement. Cette valeur est appropriée pour les scénarios de débogage ainsi que lors de l’affichage d’une invite de mise à jour à l’utilisateur, car elle s’attend à voir les modifications immédiatement après avoir accepté l’installation. En outre, ce mode peut être utilisé pour appliquer des mises à jour obligatoires, car il supprime la latence potentiellement indésirable entre l’installation de la mise à jour et la prochaine fois que l’utilisateur final redémarre ou reprend l’application.

  • codePush.InstallMode.ON_NEXT_RESTART (1) : indique que vous souhaitez installer la mise à jour, mais pas redémarrer l’application de force. Lorsque l’application est « naturellement » redémarrée (en raison du système d’exploitation ou de l’utilisateur final qui l’a tué), la mise à jour sera récupérée en toute transparence. Cette valeur est appropriée lorsque vous effectuez des mises à jour silencieuses, car elle est probablement perturbante pour l’utilisateur final si l’application redémarre soudainement hors de nulle part. Ils ne se rendaient pas compte qu’une mise à jour était même téléchargée. Il s’agit du mode par défaut utilisé pour les méthodes et LocalPackage.install les sync méthodes.

  • codePush.InstallMode.ON_NEXT_RESUME (2) : indique que vous souhaitez installer la mise à jour, mais ne souhaitez pas redémarrer l’application tant que l’utilisateur final ne le reprend pas à partir de l’arrière-plan. De cette façon, vous n’interrompez pas leur session actuelle, mais vous pouvez obtenir la mise à jour devant eux plus tôt que de devoir attendre le prochain redémarrage naturel. Cette valeur est appropriée pour les installations silencieuses qui peuvent être appliquées à la reprise de manière non invasive.

  • codePush.InstallMode.ON_NEXT_SUSPEND (3) : indique que vous souhaitez installer la mise à jour pendant qu’elle se trouve en arrière-plan, mais uniquement après avoir été en arrière-plan pendant minimumBackgroundDuration quelques secondes (0 par défaut), afin que le contexte utilisateur ne soit pas perdu, sauf si la suspension de l’application est suffisamment longue pour ne pas avoir d’importance.

CheckFrequency

Cette énumération spécifie quand vous souhaitez que votre application se synchronise avec le serveur pour les mises à jour et peut être transmise au codePushify décorateur. Il inclut les valeurs suivantes :

  • codePush.CheckFrequency.ON_APP_START (0) : indique que vous souhaitez rechercher les mises à jour chaque fois que le processus de l’application est démarré.

  • codePush.CheckFrequency.ON_APP_RESUME (1) : indique que vous souhaitez vérifier les mises à jour chaque fois que l’application est renvoyée au premier plan après avoir été « en arrière-plan » (l’utilisateur a appuyé sur le bouton Accueil, l’application lance un processus de paiement distinct, etc.).

  • codePush.CheckFrequency.MANUAL (2) : désactivez la vérification automatique des mises à jour, mais vérifiez uniquement quand codePush.sync() il est appelé dans le code de l’application.

SyncStatus

Cette énumération est fournie à la syncStatusChangedCallback fonction qui peut être passée à la sync méthode, pour se connecter au processus de mise à jour global. Il inclut les valeurs suivantes :

  • codePush.SyncStatus.CHECKING_FOR_UPDATE (0) : le serveur CodePush est interrogé pour une mise à jour.
  • codePush.SyncStatus.AWAITING_USER_ACTION (1) : une mise à jour est disponible et une boîte de dialogue de confirmation a été affichée à l’utilisateur final. (Cela s’applique uniquement lorsque celui-ci updateDialog est utilisé)
  • codePush.SyncStatus.DOWNLOADING_PACKAGE (2) : une mise à jour disponible est téléchargée à partir du serveur CodePush.
  • codePush.SyncStatus.INSTALLING_UPDATE (3) : une mise à jour disponible a été téléchargée et est sur le point d’être installée.
  • codePush.SyncStatus.UP_TO_DATE (4) : l’application est entièrement à jour avec le déploiement configuré.
  • codePush.SyncStatus.UPDATE_IGNORED (5) : l’application a une mise à jour facultative, que l’utilisateur final a choisi d’ignorer. (Cela s’applique uniquement lorsque celui-ci updateDialog est utilisé)
  • codePush.SyncStatus.UPDATE_INSTALLED (6) : une mise à jour disponible a été installée et sera exécutée immédiatement après le retour de la syncStatusChangedCallback fonction ou la prochaine fois que l’application reprend/redémarre, selon la InstallMode valeur spécifiée dans SyncOptions.
  • codePush.SyncStatus.SYNC_IN_PROGRESS (7) : une opération en cours sync empêche l’exécution de l’appel actuel.
  • codePush.SyncStatus.UNKNOWN_ERROR (-1) : l’opération de synchronisation a trouvé une erreur inconnue.

UpdateState

Cette énumération spécifie l’état dans lequel une mise à jour est actuellement disponible et peut être spécifiée lors de l’appel de la getUpdateMetadata méthode. Il inclut les valeurs suivantes :

  • codePush.UpdateState.RUNNING (0) : indique qu’une mise à jour représente la version de l’application en cours d’exécution. Cela peut être utile pour identifier les attributs de l’application, pour des scénarios tels que l’affichage de la description de la version dans une boîte de dialogue « nouveautés ? » ou la création de rapports de la dernière version à un service de création de rapports d’analyse ou d’incident.

  • codePush.UpdateState.PENDING (1) : indique qu’une mise à jour a été installée, mais que l’application n’a pas encore été redémarrée pour l’appliquer. Cela peut être utile pour déterminer s’il existe une mise à jour en attente, que vous pouvez forcer un redémarrage programmatique (via restartApp) à appliquer.

  • codePush.UpdateState.LATEST (2) : indique qu’une mise à jour représente la dernière version disponible et peut être en cours d’exécution ou en attente.

Référence de l’API Objective-C (iOS)

L’API Objective-C est rendue disponible en important l’en-tête CodePush.h dans votre fichier AppDelegate.m et se compose d’une classe publique unique nommée CodePush.

CodePush

Contient des méthodes statiques pour récupérer le NSURL fichier groupé JavaScript le plus récent et peut être passée à la méthode ' lors de l’amorçage RCTRootViewde initWithBundleURL votre application dans le fichier AppDelegate.m .

Les méthodes de la CodePush classe peuvent être considérées comme des résolveurs composites, qui chargent toujours le bundle approprié, pour prendre en charge les scénarios suivants :

  1. Lorsqu’un utilisateur final installe votre application à partir du Store (par exemple 1.0.0), il obtient le bundle JS contenu dans le fichier binaire. Il s’agit du comportement que vous obtiendriez sans utiliser CodePush, mais nous nous assurons qu’il ne s’arrête pas :)

  2. Dès que vous commencez à publier des mises à jour CodePush, vos utilisateurs finaux obtiennent le bundle JS qui représente la dernière version du déploiement configuré. Il s’agit du comportement qui vous permet d’itérer au-delà de ce que vous avez expédié au magasin.

  3. Dès que vous publiez une mise à jour vers l’App Store (par 1.1.0exemple), et que vos utilisateurs finaux le mettent à jour, ils obtiendront à nouveau le bundle JS contenu dans le fichier binaire. Ce comportement garantit que les mises à jour CodePush ciblant une version binaire précédente ne sont pas utilisées (car nous ne savons pas qu’elles fonctionnent) et que vos utilisateurs finaux disposent toujours d’une version opérationnelle de votre application.

  4. Répétez #2 et #3 à mesure que les versions codePush et les versions du Magasin d’applications continuent vers l’infini (et au-delà ?)

En raison de ce comportement, vous pouvez déployer en toute sécurité des mises à jour dans les magasins d’applications et CodePush si nécessaire, et vous assurerez que vos utilisateurs finaux obtiendront toujours la version la plus récente.

Méthodes

  • (NSURL *)bundleURL : retourne le bundle NSURL JS le plus récent, comme décrit ci-dessus. Cette méthode suppose que le nom du bundle JS contenu dans le fichier binaire de votre application est main.jsbundle.

  • (NSURL *)bundleURLForResource :(NSString *)resourceName - Équivalent à la bundleURL méthode, mais permet également de personnaliser le nom du bundle JS recherché dans le fichier binaire de l’application. Cela est utile si vous ne nommez pas ce fichier main (qui est la convention par défaut). Cette méthode suppose que l’extension du bundle JS est *.jsbundle.

  • (NSURL *)bundleURLForResource :(NSString *)resourceName withExtension :(NSString *)resourceExtension : Équivalent à la bundleURLForResource: méthode, mais permet également de personnaliser l’extension utilisée par le bundle JS recherché dans le fichier binaire de l’application. Cela est utile si vous ne nommez pas ce fichier *.jsbundle (qui est la convention par défaut).

  • (void)overrideAppVersion :(NSString *)appVersionOverride - Définit la version de l’interface binaire de l’application, qui serait sinon définie par défaut sur la version de l’App Store spécifiée comme dans CFBundleShortVersionString info.plist. Il doit s’agir d’une seule fois, avant le chargement de l’URL du bundle.

  • (void)setDeploymentKey :(NSString *)deploymentKey : définit la clé de déploiement que l’application doit utiliser lors de l’interrogation des mises à jour. Il s’agit d’une alternative dynamique à la définition de la clé de déploiement dans votre info.plist ou à la spécification d’une clé de déploiement dans JS lors de l’appel checkForUpdate ou sync.

Informations de référence sur l’API Java (Android)

API pour React Native 0.60 version et versions ultérieures

Étant donné que autolinking les utilisations react-native.config.js pour lier des plug-ins, les constructeurs sont spécifiés dans ce fichier. Toutefois, vous pouvez remplacer les variables personnalisées pour gérer le plug-in CodePush en plaçant ces valeurs dans les ressources de chaîne.

  • Clé publique : utilisée pour la vérification groupée dans la fonctionnalité de signature de code. Pour plus d’informations sur la fonctionnalité signature de code, consultez la section Signature de code. Pour définir la clé publique, vous devez ajouter le contenu de la clé publique au strings.xml nom CodePushPublicKey. CodePush obtient automatiquement cette propriété et active la fonctionnalité Signature de code. Par exemple :

    <string moduleConfig="true" name="CodePushPublicKey">your-public-key</string>

  • URL du serveur : utilisée pour spécifier l’URL du serveur CodePush. Valeur par défaut : «https://codepush.appcenter.ms/" ; est substitué en ajoutant votre chemin d’accès au strings.xml nom CodePushServerUrl. CodePush obtient automatiquement cette propriété et utilise ce chemin d’accès pour envoyer des demandes. Par exemple :

    <string moduleConfig="true" name="CodePushServerUrl">https://yourcodepush.server.com</string>

API pour React Native inférieure à 0,60

L’API Java est rendue disponible en important la com.microsoft.codepush.react.CodePush classe dans votre fichier MainActivity.java et se compose d’une classe publique unique nommée CodePush.

CodePush

Construit le runtime du client CodePush et représente l’instance que vous ajoutez à la ReactPackage liste des packages de votre application.

Constructeurs

  • CodePush(String deploymentKey, Activity mainActivity) : crée une instance du runtime CodePush, qui sera utilisée pour interroger le service pour les mises à jour via la clé de déploiement fournie. Le mainActivity paramètre doit toujours être défini this lors de la configuration de votre liste de packages React à l’intérieur de la MainActivity classe. Ce constructeur place le runtime CodePush en « mode de mise en production », donc si vous souhaitez activer le comportement de débogage, utilisez plutôt le constructeur suivant.

  • CodePush(String deploymentKey, Activity mainActivity, bool isDebugMode) : équivalent au constructeur précédent, mais vous permet de spécifier si le runtime CodePush doit être en mode débogage ou non. Lorsque vous utilisez ce constructeur, le isDebugMode paramètre doit toujours être défini pour BuildConfig.DEBUG rester synchronisé avec votre type de build. Lorsque vous placez CodePush en mode débogage, les comportements suivants sont activés :

    1. Les anciennes mises à jour CodePush ne sont pas supprimées du stockage chaque fois qu’un nouveau binaire est déployé sur l’émulateur/l’appareil. Ce comportement vous permet de déployer de nouveaux fichiers binaires, sans avoir à modifier la version pendant le développement, et sans obtenir continuellement la même mise à jour chaque fois que votre application appelle sync.

    2. Le cache local que le runtime React Native gère en mode débogage est supprimé chaque fois qu’une mise à jour CodePush est installée. Cela garantit que lorsque l’application est redémarrée après l’application d’une mise à jour, il est possible de voir les modifications attendues. Dès que cette demande de tirage est fusionnée, nous n’aurons plus besoin de le faire.

  • CodePush(String deploymentKey, context, boolean isDebugMode, Integer publicKeyResourceDescriptor) : équivalent au constructeur précédent, mais vous permet de spécifier le descripteur de ressource de clé publique nécessaire pour lire le contenu de clé publique. Pour plus d’informations sur la fonctionnalité signature de code, consultez la section Signature de code.

  • CodePush(String deploymentKey, context, boolean isDebugMode, String serverUrl) : le constructeur vous permet de spécifier l’URL du serveur CodePush. Valeur par défaut : "https://codepush.appcenter.ms/" est substituée par la valeur spécifiée dans serverUrl.

Méthodes statiques

  • getBundleUrl() : retourne le chemin d’accès à la version la plus récente du fichier groupé JS de votre application, en supposant que le nom de la ressource est index.android.bundle. Si votre application utilise un autre nom d’offre groupée, utilisez la version surchargée de cette méthode, ce qui permet de le spécifier. Cette méthode a le même comportement de résolution que l’équivalent Objective-C décrit ci-dessus.

  • getBundleUrl(String bundleName) : retourne le chemin d’accès à la version la plus récente du fichier groupé JS de votre application, à l’aide du nom de ressource spécifié (par exemple index.android.bundle). Cette méthode a le même comportement de résolution que l’équivalent Objective-C décrit ci-dessus.

  • overrideAppVersion(String appVersionOverride) : définit la version de l’interface binaire de l’application, qui serait sinon définie par défaut sur la version du Play Store spécifiée comme versionName dans build.gradle. Cela doit être appelé une seule fois, avant la construction de l’instance CodePush.