Informazioni di riferimento sulle API di React Native Client SDK

Il plug-in CodePush è costituito da due componenti:

1. Un modulo JavaScript, che può essere importato/obbligatorio e consente all'app di interagire con il servizio durante il runtime(ad esempio, controllare la disponibilità di aggiornamenti, esaminare i metadati relativi all'aggiornamento dell'app attualmente in esecuzione).

2. API nativa (Objective-C e Java) che consente all'host dell'app React Native di eseguire il bootstrap con il percorso di bundle JS corretto.

Le sezioni seguenti descrivono in dettaglio la forma e il comportamento di queste API:

Informazioni di riferimento sulle API JavaScript

Quando è necessario react-native-code-push, l'oggetto module fornisce i metodi di primo livello seguenti oltre all'elemento Decorator del componente radice:

• allowRestart: consente di eseguire riavvii a livello di codice in seguito all'installazione di un aggiornamento e, facoltativamente, riavvia immediatamente l'app se un aggiornamento in sospeso ha tentato di riavviare l'app mentre i riavvii non sono consentiti. Questo metodo è un'API avanzata ed è necessaria solo se l'app non è consentita in modo esplicito riavvii tramite il disallowRestart metodo .

• checkForUpdate: chiede al servizio CodePush se la distribuzione dell'app configurata ha un aggiornamento disponibile.

• disallowRestart: impedisce temporaneamente l'esecuzione di eventuali riavvii a livello di codice a causa dell'installazione di un aggiornamento CodePush. Questo metodo è un'API avanzata ed è utile quando un componente all'interno dell'app (ad esempio un processo di onboarding) deve garantire che non si verifichino interruzioni dell'utente finale durante la sua durata.

• getCurrentPackage: recupera i metadati relativi all'aggiornamento attualmente installato,ad esempio descrizione, tempo di installazione, dimensioni.

  Nota

  v1.10.3-beta A partire dal modulo CodePush, getCurrentPackage è deprecato a favore di getUpdateMetadata*.

• getUpdateMetadata: recupera i metadati per un aggiornamento installato ,ad esempio descrizione, obbligatorio.

• notifyAppReady: notifica al runtime CodePush che un aggiornamento installato è considerato riuscito. Se si sta controllando manualmente la disponibilità e l'installazione degli aggiornamenti (che non usa il metodo di sincronizzazione per gestirlo tutti), questo metodo DEVE essere chiamato. In caso contrario, CodePush considererà l'aggiornamento come non riuscito e eseguirà il rollback alla versione precedente al riavvio successivo dell'app.

• restartApp: riavvia immediatamente l'app. Se è presente un aggiornamento in sospeso, verrà visualizzato immediatamente all'utente finale. In caso contrario, la chiamata a questo metodo ha lo stesso comportamento dell'utente finale che uccide e riavvia il processo.

• sync: consente di verificare la presenza di un aggiornamento, scaricarlo e installarlo, tutto con una singola chiamata. A meno che non sia necessaria un'interfaccia utente o un comportamento personalizzato, è consigliabile che la maggior parte degli sviluppatori usi questo metodo durante l'integrazione di CodePush nelle app

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)

Usato per eseguire il wrapping di un componente React all'interno di un componente React "ordine superiore" che sa come sincronizzare l'aggregazione JavaScript e gli asset di immagine dell'app quando viene montato. Internamente, il componente di ordine superiore chiama sync all'interno del relativo componentDidMount handle del ciclo di vita, che esegue un controllo di aggiornamento, scarica l'aggiornamento, se esistente e installa automaticamente l'aggiornamento.

Questo elemento decorator fornisce supporto per consentire di personalizzarne il comportamento per abilitare facilmente le app con requisiti diversi. Di seguito sono riportati alcuni esempi di modi per usarlo (è possibile selezionarne uno o persino usare una combinazione):

1. Sincronizzazione invisibile all'utente all'avvio dell'app (il comportamento predefinito più semplice). L'app scaricherà automaticamente gli aggiornamenti disponibili e le applicherà alla successiva riavvio dell'app ( ad esempio il sistema operativo o l'utente finale lo ha ucciso o il dispositivo è stato riavviato). In questo modo, l'intera esperienza di aggiornamento è "invisibile all'utente finale", poiché non visualizza alcuna richiesta di aggiornamento o riavvii dell'app "sintetica".

   // 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. Sincronizzazione invisibile all'utente ogni volta che l'app riprende. Uguale a 1, ad eccezione di quando si controllano gli aggiornamenti o si applica un aggiornamento se ne esiste uno ogni volta che l'app torna in primo piano dopo essere stata "in background".

   // 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. Modo interattivo. Quando è disponibile un aggiornamento, richiedere all'utente finale l'autorizzazione prima di scaricarlo e quindi applicare immediatamente l'aggiornamento. Se un aggiornamento è stato rilasciato usando il mandatory flag , l'utente finale riceverà comunque una notifica sull'aggiornamento, ma non avrebbe la scelta di ignorarla.

   // 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. Stato di avanzamento del log/visualizzazione. Mentre l'app esegue la sincronizzazione con il server per gli aggiornamenti, usa gli codePushStatusDidChange hook degli eventi o codePushDownloadDidProgress per registrare le diverse fasi di questo processo o persino visualizzare un indicatore di stato per l'utente.

   // 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

L'elemento codePush Decorator accetta un oggetto "options" che consente di personalizzare numerosi aspetti del comportamento predefinito indicato in precedenza:

• checkFrequency (codePush.CheckFrequency): specifica quando si desidera verificare la disponibilità di aggiornamenti. Il valore predefinito è codePush.CheckFrequency.ON_APP_START. Fare riferimento alle CheckFrequency enumerazioni per una descrizione delle opzioni disponibili e delle relative operazioni.

• deploymentKey (String): specifica la chiave di distribuzione su cui eseguire una query per un aggiornamento. Per impostazione predefinita, questo valore è derivato dal file Info.plist (iOS) e dal file MainActivity.java (Android), ma questa opzione consente di eseguirne l'override dal lato script se è necessario usare in modo dinamico una distribuzione diversa.

• installMode (codePush.InstallMode): specifica quando si desidera installare gli aggiornamenti facoltativi (quelli che non sono contrassegnati come obbligatori). Il valore predefinito è codePush.InstallMode.ON_NEXT_RESTART. Fare riferimento alle InstallMode enumerazioni per una descrizione delle opzioni disponibili e delle relative operazioni.

• mandatoryInstallMode (codePush.InstallMode): specifica quando si desidera installare gli aggiornamenti, contrassegnati come obbligatori. Il valore predefinito è codePush.InstallMode.IMMEDIATE. Fare riferimento alle InstallMode enumerazioni per una descrizione delle opzioni disponibili e delle relative operazioni.

• minimumBackgroundDuration (numero): specifica il numero minimo di secondi per l'app in background prima di riavviare l'app. Questa proprietà si applica solo agli aggiornamenti installati tramite InstallMode.ON_NEXT_RESUME o InstallMode.ON_NEXT_SUSPENDe può essere utile per ottenere prima l'aggiornamento davanti agli utenti finali, senza essere troppo invadente. L'impostazione predefinita è 0, che applica l'aggiornamento immediatamente dopo una ripresa o, a meno che la sospensione dell'app non sia sufficiente per non importare, ma per quanto tempo si trova in background.

• updateDialog (UpdateDialogOptions): oggetto "opzioni" usato per determinare se all'utente finale deve essere visualizzata una finestra di dialogo di conferma quando è disponibile un aggiornamento e, in tal caso, quali stringhe usare. L'impostazione predefinita è null, che disabilita la finestra di dialogo. L'impostazione di questo valore su qualsiasi true valore consentirà la finestra di dialogo con le stringhe predefinite e il passaggio di un oggetto a questo parametro consente di abilitare la finestra di dialogo e di eseguire l'override di una o più stringhe predefinite. Prima di abilitare questa opzione all'interno di un'app distribuita in App Store, vedere questa nota.

  L'elenco seguente rappresenta le opzioni disponibili e le relative impostazioni predefinite:

  • appendReleaseDescription (booleano): indica se si desidera aggiungere la descrizione di una versione disponibile al messaggio di notifica, visualizzato all'utente finale. Il valore predefinito è false.

  • descriptionPrefix (String) - Indica la stringa con cui si vuole anteporre la descrizione della versione, se presente, quando viene visualizzata la notifica di aggiornamento all'utente finale. L'impostazione predefinita è " Description: "

  • mandatoryContinueButtonLabel (String): il testo da usare per il pulsante che l'utente finale deve premere per installare un aggiornamento obbligatorio. Il valore predefinito è "Continue".

  • mandatoryUpdateMessage (String) - Testo usato come corpo di una notifica di aggiornamento, quando l'aggiornamento viene specificato come obbligatorio. Il valore predefinito è "An update is available that must be installed.".

  • optionalIgnoreButtonLabel (String): il testo da usare per il pulsante che l'utente finale può premere per ignorare un aggiornamento facoltativo disponibile. Il valore predefinito è "Ignore".

  • optionalInstallButtonLabel (String): il testo da usare per il pulsante che l'utente finale può premere per installare un aggiornamento facoltativo. Il valore predefinito è "Install".

  • optionalUpdateMessage (String): testo usato come corpo di una notifica di aggiornamento, quando l'aggiornamento è facoltativo. Il valore predefinito è "An update is available. Would you like to install it?".

  • title (String) - Testo usato come intestazione di una notifica di aggiornamento visualizzata all'utente finale. Il valore predefinito è "Update available".

• rollbackRetryOptions (RollbackRetryOptions): il meccanismo di ripetizione dei tentativi di rollback consente all'applicazione di tentare di reinstallare un aggiornamento precedentemente eseguito il rollback (con le restrizioni specificate nelle opzioni). Si tratta di un oggetto "opzioni" usato per determinare se deve verificarsi un nuovo tentativo di rollback e, in tal caso, quali impostazioni usare per il nuovo tentativo di rollback. L'impostazione predefinita è Null, che ha l'effetto di disabilitare il meccanismo di ripetizione dei tentativi. L'impostazione di questo valore su qualsiasi valore di verità consentirà il meccanismo di ripetizione dei tentativi con le impostazioni predefinite e il passaggio di un oggetto a questo parametro consente di abilitare il nuovo tentativo di rollback e di eseguire l'override di uno o più valori predefiniti.

  L'elenco seguente rappresenta le opzioni disponibili e le relative impostazioni predefinite:

  • delayInHours (numero): specifica il tempo minimo in ore in cui l'app attenderà dopo l'ultimo rollback prima di tentare di reinstallare lo stesso pacchetto di cui è stato eseguito il rollback. Non può essere minore di 0. Può essere un numero float. Il valore predefinito è 24.

  • maxRetryAttempts (Numero): specifica il numero massimo di tentativi che l'app può eseguire prima di interrompere il tentativo. Non può essere minore di 1. Il valore predefinito è 1.

codePushStatusDidChange (hook eventi)

Chiamato quando il processo di sincronizzazione passa da una fase a un'altra nel processo di aggiornamento complessivo. L'hook eventi viene chiamato con un codice di stato che rappresenta lo stato corrente e può essere uno qualsiasi dei SyncStatus valori.

codePushDownloadDidProgress (hook eventi)

Chiamato periodicamente quando viene scaricato un aggiornamento disponibile dal server CodePush. Il metodo viene chiamato con un DownloadProgress oggetto , che contiene le due proprietà seguenti:

• totalBytes (Numero): numero totale di byte che dovrebbero essere ricevuti per questo aggiornamento (ovvero le dimensioni del set di file, che sono state modificate rispetto alla versione precedente).

• receivedBytes (Numero): numero di byte scaricati finora, che possono essere usati per tenere traccia dello stato di avanzamento del download.

codePush.allowRestart

codePush.allowRestart(): void;

Reallows programmatic restarts to occur, that would've otherwise been rejected because of a previous call to disallowRestart. Se disallowRestart non è mai stato chiamato in primo luogo, la chiamata a questo metodo comporta una mancata esecuzione.

Se un aggiornamento CodePush è attualmente in sospeso, che ha tentato di riavviare l'app (ad esempio è stato usato InstallMode.IMMEDIATE), ma è stato bloccato a causa della disallowRestart chiamata, la chiamata allowRestart comporterà un riavvio immediato. Questo riavvio consente di applicare l'aggiornamento il prima possibile, senza interrompere l'utente finale durante i flussi di lavoro critici , ad esempio un processo di onboarding.

Ad esempio, la chiamata allowRestart attiva un riavvio immediato se uno dei tre scenari indicati nella disallowRestart documentazione si è verificato dopo disallowRestart la chiamata. Tuttavia, la chiamata allowRestart non attiverà un riavvio se i punti seguenti sono veri:

1. Non sono stati installati aggiornamenti CodePush dall'ultima chiamata disallowRestart , quindi non è necessario riavviare comunque.

2. Attualmente è disponibile un aggiornamento CodePush in sospeso, ma è stato installato tramite InstallMode.ON_NEXT_RESTART, quindi non è necessario un riavvio a livello di codice.

3. Attualmente è disponibile un aggiornamento CodePush in sospeso, ma è stato installato tramite InstallMode.ON_NEXT_RESUME e l'app non è ancora stata inserita in background, quindi non è ancora necessario riavviare a livello di codice.

4. Nessuna chiamata a restartApp è stata effettuata dall'ultima chiamata disallowRestart .

Questo comportamento garantisce che non venga attivato alcun riavvio in seguito alla chiamata allowRestart , a meno che non ne sia stato richiesto esplicitamente uno durante il periodo non consentito. In questo modo, allowRestart è simile alla chiamata restartApp(true)a , ad eccezione del precedente attiverà un riavvio solo se l'aggiornamento attualmente in sospeso desiderava riavviare, ma quest'ultimo verrà riavviato fino a quando un aggiornamento è in sospeso.

Per un esempio di come questo metodo può essere usato, vedere disallowRestart .

codePush.checkForUpdate

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

Esegue una query sul servizio CodePush per verificare se la distribuzione dell'app configurata ha un aggiornamento disponibile. Per impostazione predefinita, userà la chiave di distribuzione configurata nel file Info.plist (iOS) o MainActivity.java file (Android), ma è possibile eseguirne l'override specificando un valore tramite il parametro facoltativo deploymentKey . Ciò può essere utile quando si vuole "reindirizzare" dinamicamente un utente a una distribuzione specifica, ad esempio consentire l'accesso anticipato tramite un uovo di pasqua o un cambio di impostazione utente.

Il secondo parametro handleBinaryVersionMismatchCallback facoltativo è una funzione di callback facoltativa che può essere usata per notificare all'utente se sono presenti aggiornamenti binari. Si consideri ad esempio un caso d'uso in cui la versione binaria attualmente installata è 1.0.1 con un'etichetta (etichetta push del codice) v1. Il codice nativo successivo è stato modificato nel ciclo di sviluppo e la versione binaria è stata aggiornata alla versione 1.0.2. Quando viene attivato un controllo di aggiornamento codepush, gli aggiornamenti hanno una mancata corrispondenza della versione binaria perché l'aggiornamento non è destinato alla versione binaria dell'app attualmente installata. In questo caso, l'app installata (1.0.1) ignorerà l'aggiornamento destinato alla versione 1.0.2. È possibile usare handleBinaryVersionMismatchCallback per fornire un hook per gestire tali situazioni.

Questo metodo restituisce un Promiseoggetto , che viene risolto in uno dei due valori possibili:

1. null se non è disponibile un aggiornamento. Ciò può verificarsi nei seguenti scenari:

   1. La distribuzione configurata non contiene versioni e quindi non è necessario eseguire alcun aggiornamento.
   2. La versione più recente all'interno della distribuzione configurata è destinata a una versione binaria diversa rispetto a quella attualmente in esecuzione (precedente o successiva).
   3. L'app attualmente in esecuzione ha già la versione più recente della distribuzione configurata e quindi non è più necessaria.
   4. La versione più recente all'interno della distribuzione configurata è attualmente contrassegnata come disabilitata, quindi non può essere scaricata.
   5. La versione più recente all'interno della distribuzione configurata è in uno stato di implementazione attiva e il dispositivo richiedente non rientra nella percentuale di utenti idonei.

2. RemotePackage Istanza di , che rappresenta un aggiornamento disponibile che può essere controllato o scaricato in un secondo momento.

Esempio di utilizzo:

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;

Impedisce temporaneamente il riavvio a livello di codice in seguito a uno degli scenari seguenti:

1. Un aggiornamento codePush viene installato tramite InstallMode.IMMEDIATE

2. Un aggiornamento CodePush viene installato usando InstallMode.ON_NEXT_RESUME e l'app viene ripresa in background (facoltativamente limitata dalla minimumBackgroundDuration proprietà)

3. Il restartApp metodo è stato chiamato

   Nota

   I passaggi 1 e 2 funzionano in modo efficace chiamando restartApp per te, quindi puoi pensare a disallowRestart bloccare qualsiasi chiamata a restartApp, indipendentemente dal fatto che l'app la chiami direttamente o indirettamente.

Dopo aver chiamato questo metodo, tutte le chiamate a sync sarebbero ancora autorizzate a verificare la presenza di un aggiornamento, scaricarlo e installarlo, ma un tentativo di riavviare l'app verrebbe accodato fino a quando allowRestart non viene chiamato. In questo modo, la richiesta di riavvio viene acquisita e può essere "scaricata" ogni volta che si desidera consentirne l'esecuzione.

Si tratta di un'API avanzata ed è particolarmente utile quando i singoli componenti all'interno dell'app (ad esempio un processo di onboarding) devono assicurarsi che non si verifichino interruzioni dell'utente finale durante la loro durata, continuando a consentire all'app di mantenere la sincronizzazione con il server CodePush al proprio ritmo e usando le modalità di installazione appropriate. Ciò offre il vantaggio di consentire all'app di individuare e scaricare gli aggiornamenti disponibili il prima possibile, impedendo al tempo stesso eventuali interruzioni durante le esperienze chiave dell'utente finale.

In alternativa, puoi anche usare InstallMode.ON_NEXT_RESTART ogni volta che chiamerai sync (che non tenterà mai di riavviare l'app a livello di codice) e quindi di chiamare restartApp in modo esplicito nei punti della tua app che è "sicuro" per farlo. disallowRestart fornisce un approccio alternativo a questo quando il codice che si sincronizza con il server CodePush è separato dal codice o dai componenti che vogliono applicare un criterio di nessun riavvio.

Esempio di utilizzo:

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

codePush.getCurrentPackage(): Promise<LocalPackage>;

Recupera i metadati relativi al "pacchetto" attualmente installato (ad esempio, la descrizione, l'ora di installazione). Ciò può essere utile per scenari come la visualizzazione di una finestra di dialogo "Novità?" dopo l'applicazione di un aggiornamento o la verifica dell'eventuale presenza di un aggiornamento in sospeso che è in attesa di essere applicata tramite un curriculum o un riavvio.

Questo metodo restituisce un Promiseoggetto , che viene risolto in uno dei due valori possibili:

1. null se l'app esegue attualmente il bundle JS dal file binario e non da un aggiornamento CodePush. Ciò si verifica negli scenari seguenti:

   1. L'utente finale ha installato il file binario dell'app e ha ancora installato un aggiornamento codePush
   2. L'utente finale ha installato un aggiornamento del file binario (ad esempio dall'archivio), che ha cancellato gli aggiornamenti codePush precedenti e ha restituito la precedenza al file binario JS nel file binario.

2. LocalPackage Istanza di , che rappresenta i metadati per l'aggiornamento CodePush attualmente in esecuzione.

Esempio di utilizzo:

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>;

Recupera i metadati per un aggiornamento installato (ad esempio descrizione, obbligatorio) il cui stato corrisponde al parametro specificato updateState . Ciò può essere utile per scenari come la visualizzazione di una finestra di dialogo "Novità?" dopo l'applicazione di un aggiornamento o la verifica dell'eventuale presenza di un aggiornamento in sospeso che è in attesa di essere applicata tramite un curriculum o un riavvio. Per altre informazioni sui possibili stati di aggiornamento e sulle relative rappresentazioni, vedere le informazioni di riferimento su UpdateState.

Questo metodo restituisce un Promiseoggetto , che viene risolto in uno dei due valori possibili:

1. null se non esiste un aggiornamento con lo stato specificato. Ciò si verifica negli scenari seguenti:

   1. L'utente finale non ha ancora installato gli aggiornamenti di CodePush ed è per questo che non sono disponibili metadati per gli aggiornamenti, indipendentemente dal parametro specificato updateState .

   2. L'utente finale ha installato un aggiornamento del file binario (ad esempio dall'archivio), che ha cancellato gli aggiornamenti codePush precedenti e ha restituito la precedenza al file binario JS nel file binario. Mostra lo stesso comportamento di #1

   3. Il updateState parametro è impostato su UpdateState.RUNNING, ma l'app non esegue attualmente un aggiornamento CodePush. Potrebbe esserci un aggiornamento in sospeso, ma l'app non è stata ancora riavviata per renderla attiva.

   4. Il updateState parametro è impostato su UpdateState.PENDING, ma l'app non dispone di aggiornamenti attualmente in sospeso.

2. LocalPackage Istanza di , che rappresenta i metadati per l'aggiornamento CodePush attualmente richiesto (in esecuzione o in sospeso).

Esempio di utilizzo:

// 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>;

Notifica al runtime CodePush che un aggiornamento appena installato deve essere considerato corretto e quindi non è necessario un rollback lato client automatico. È obbligatorio chiamare questa funzione in un punto qualsiasi nel codice del bundle aggiornato. In caso contrario, al successivo riavvio dell'app, il runtime CodePush presuppone che l'aggiornamento installato non sia riuscito e che venga eseguito il rollback alla versione precedente. Questo comportamento esiste per garantire che gli utenti finali non siano bloccati da un aggiornamento interrotto.

Se si usa la sync funzione e si esegue il controllo degli aggiornamenti all'avvio dell'app, non è necessario chiamare notifyAppReady manualmente perché sync lo chiamerà automaticamente. Questo comportamento esiste a causa del presupposto che quando sync viene chiamato nell'app, rappresenta una buona approssimazione di un avvio riuscito.

codePush.restartApp

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

Riavvia immediatamente l'app. Se al parametro viene fornito onlyIfUpdateIsPending un valore di verità, l'app verrà riavviata solo se è effettivamente in attesa di essere applicato un aggiornamento in sospeso.

Questo metodo è destinato a scenari avanzati ed è particolarmente utile quando si verificano le condizioni seguenti:

1. L'app specifica un valore della modalità di installazione pari ON_NEXT_RESTART o ON_NEXT_RESUME quando si chiamano i sync metodi o LocalPackage.install . Questo non applica l'aggiornamento finché l'app non viene riavviata (dall'utente finale o dal sistema operativo) o ripresa e quindi l'aggiornamento non verrà visualizzato immediatamente all'utente finale.

2. Si dispone di un evento utente specifico dell'app (ad esempio l'utente finale è tornato alla home route dell'app) che consente di applicare l'aggiornamento in modo non invadente e potenzialmente ottiene l'aggiornamento all'utente finale prima dell'attesa fino al successivo riavvio o ripreso.

codePush.sync

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

Sincronizza l'aggregazione JavaScript e gli asset di immagine dell'app con la versione più recente alla distribuzione configurata. A differenza del metodo checkForUpdate , che verifica la presenza di un aggiornamento e controlliamo le operazioni da eseguire successivamente, sync gestisce automaticamente il controllo degli aggiornamenti, il download e l'esperienza di installazione.

Questo metodo fornisce supporto per due diverse "modalità" (ma personalizzabili) per abilitare facilmente le app con requisiti diversi:

1. La modalità invisibile all'utente (il comportamento predefinito) scarica automaticamente gli aggiornamenti disponibili e li applica alla successiva riavvio dell'app ( ad esempio il sistema operativo o l'utente finale lo ha ucciso o il dispositivo è stato riavviato). In questo modo, l'intera esperienza di aggiornamento è "invisibile all'utente finale", poiché non visualizza alcuna richiesta di aggiornamento o riavvii dell'app "sintetica".

2. Modalità attiva, che quando è disponibile un aggiornamento, richiede all'utente finale l'autorizzazione prima di scaricarla e quindi applica immediatamente l'aggiornamento. Se un aggiornamento è stato rilasciato usando il mandatory flag , l'utente finale riceverà comunque una notifica sull'aggiornamento, ma non avrebbe la scelta di ignorarla.

Esempio di utilizzo:

// 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 });

SyncOptions

Mentre il sync metodo tenta di semplificare l'esecuzione di aggiornamenti invisibile all'utente e attivi con una configurazione piccola, accetta un oggetto "opzioni" che consente di personalizzare molti aspetti del comportamento predefinito indicato in precedenza. Le opzioni disponibili sono identiche a CodePushOptions, ad eccezione dell'opzione checkFrequency :

• deploymentKey (String) - Fare riferimento a CodePushOptions.

• installMode (codePush.InstallMode) - Fare riferimento a CodePushOptions.

• mandatoryInstallMode (codePush.InstallMode) - Fare riferimento a CodePushOptions.

• minimumBackgroundDuration (numero): fare riferimento a CodePushOptions.

• updateDialog (UpdateDialogOptions) - Fare riferimento a CodePushOptions.

• rollbackRetryOptions (RollbackRetryOptions) - Fare riferimento a CodePushOptions.

Esempio di utilizzo:

// 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
   }
});

Oltre alle opzioni, il sync metodo accetta anche diversi parametri di funzione facoltativi, che consentono di sottoscrivere il ciclo di vita della sync "pipeline" per visualizzare un'interfaccia utente aggiuntiva in base alle esigenze(ad esempio un "controllo della modale di aggiornamento o un modale di avanzamento del download):

• syncStatusChangedCallback ((syncStatus: Number) => void): chiamato quando il processo di sincronizzazione passa da una fase a un'altra nel processo di aggiornamento complessivo. Il metodo viene chiamato con un codice di stato, che rappresenta lo stato corrente e può essere uno qualsiasi dei SyncStatus valori.

• downloadProgressCallback ((progress: DownloadProgress) => void) - Chiamato periodicamente quando viene scaricato un aggiornamento disponibile dal server CodePush. Il metodo viene chiamato con un DownloadProgress oggetto , che contiene le due proprietà seguenti:

  • totalBytes (Numero): numero totale di byte che dovrebbero essere ricevuti per questo aggiornamento (ovvero le dimensioni del set di file, che sono state modificate rispetto alla versione precedente).

  • receivedBytes (Numero): numero di byte scaricati finora, che possono essere usati per tenere traccia dello stato di avanzamento del download.

• handleBinaryVersionMismatchCallback ((update: RemotePackage) => void) - Chiamato quando sono disponibili aggiornamenti binari. Il metodo viene chiamato con un RemotePackage oggetto . Per altri dettagli, vedere la sezione codePush.checkForUpdate .

Esempio di utilizzo:

// 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 */
  }
);

Questo metodo restituisce un Promiseoggetto , risolto in un SyncStatus codice che indica il motivo per cui la sync chiamata ha avuto esito positivo. Questo codice può essere uno dei valori seguenti SyncStatus :

• codePush.SyncStatus.UP_TO_DATE (4): l'app è aggiornata con il server CodePush.

• codePush.SyncStatus.UPDATE_IGNORED (5): l'app ha avuto un aggiornamento facoltativo, che l'utente finale ha scelto di ignorare. (Questo è applicabile solo quando updateDialog viene usato )

• codePush.SyncStatus.UPDATE_INSTALLED (6): l'aggiornamento è stato installato e verrà eseguito immediatamente dopo la restituzione della syncStatusChangedCallback funzione o la successiva ripresa/riavvio dell'app, a seconda dell'oggetto InstallMode specificato in SyncOptions.

• codePush.SyncStatus.SYNC_IN_PROGRESS (7): è in esecuzione un'operazione in corso sync che impedisce l'esecuzione della chiamata corrente.

Il sync metodo può essere chiamato ovunque si voglia verificare la presenza di un aggiornamento. Questo potrebbe essere nell'evento componentWillMount del ciclo di vita del componente radice, il gestore onPress di un <TouchableHighlight> componente, nel callback di un timer periodico o qualsiasi altro aspetto ha senso per le proprie esigenze. Analogamente al checkForUpdate metodo , esegue la richiesta di rete di verificare la presenza di un aggiornamento in background, in modo che non influisca sulla velocità di risposta del thread dell'interfaccia utente o del thread JavaScript.

Oggetti pacchetto

I checkForUpdate metodi e getUpdateMetadata restituiscono Promise oggetti, che, quando risolti, forniscono l'accesso agli oggetti "package". Il pacchetto rappresenta l'aggiornamento del codice ed eventuali metadati aggiuntivi (ad esempio descrizione, obbligatorio?). L'API CodePush ha la distinzione tra i tipi di pacchetti seguenti:

• LocalPackage: rappresenta un aggiornamento scaricato già in esecuzione oppure è stato installato ed è in attesa di un riavvio dell'app.

• RemotePackage: rappresenta un aggiornamento disponibile nel server CodePush che non è ancora stato scaricato.

LocalPackage

Contiene informazioni dettagliate su un aggiornamento scaricato in locale o già installato. È possibile ottenere un riferimento a un'istanza di questo oggetto chiamando il metodo a livello getUpdateMetadata di modulo o come valore della promessa restituita dal RemotePackage.download metodo .

Proprietà

• appVersion: versione binaria dell'app da cui dipende questo aggiornamento. Si tratta del valore specificato tramite il appStoreVersion parametro quando si chiama il comando dell'interfaccia della riga di release comando. (String)
• deploymentKey: chiave di distribuzione usata per scaricare originariamente questo aggiornamento. (String)
• description: descrizione dell'aggiornamento. Questo è lo stesso valore specificato nell'interfaccia della riga di comando quando è stato rilasciato l'aggiornamento. (String)
• failedInstall: indica se questo aggiornamento è stato installato in precedenza ma è stato eseguito il rollback. Il sync metodo ignorerà automaticamente gli aggiornamenti, che in precedenza non sono riusciti, pertanto è sufficiente preoccuparsi di questa proprietà se si usa checkForUpdate. (Boolean)
• isFirstRun: indica se è la prima volta che l'aggiornamento è stato eseguito dopo l'installazione. Ciò è utile per determinare se si vuole visualizzare un messaggio "Novità?" Interfaccia utente all'utente finale dopo l'installazione di un aggiornamento. (Boolean)
• isMandatory: indica se l'aggiornamento è considerato obbligatorio. Questo è il valore specificato nell'interfaccia della riga di comando quando è stato rilasciato l'aggiornamento. (Boolean)
• isPending( In sospeso): indica se l'aggiornamento è in stato "in sospeso". Quando true, significa che l'aggiornamento è stato scaricato e installato, ma il riavvio dell'app necessario per applicarlo non è ancora stato eseguito e questo è il motivo per cui le modifiche non sono attualmente visibili all'utente finale. (Boolean)
• label: etichetta interna assegnata automaticamente all'aggiornamento dal server CodePush, ad esempio v5. Questo valore identifica in modo univoco l'aggiornamento all'interno della distribuzione. (String)
• packageHash: valore hash SHA dell'aggiornamento. (String)
• packageSize: dimensioni del codice contenuto nell'aggiornamento, in byte. (Numero)

Metodi

• install(installMode: codePush.InstallMode = codePush.InstallMode.ON_NEXT_RESTART, minimumBackgroundDuration = 0): Promise<void>: installa l'aggiornamento salvandolo nel percorso su disco in cui il runtime prevede di trovare la versione più recente dell'app. Il installMode parametro controlla quando le modifiche vengono presentate all'utente finale. Il valore predefinito è attendere fino al riavvio successivo dell'app per visualizzare le modifiche, ma è possibile fare riferimento al riferimento all'enumerazione InstallMode per una descrizione delle opzioni disponibili e delle relative operazioni. Se il installMode parametro è impostato su InstallMode.ON_NEXT_RESUME, il minimumBackgroundDuration parametro consente di controllare per quanto tempo l'app deve essere stata in background prima di forzare l'installazione dopo la ripresa.

RemotePackage

Contiene informazioni dettagliate su un aggiornamento disponibile per il download dal server CodePush. Si ottiene un riferimento a un'istanza di questo oggetto chiamando il checkForUpdate metodo quando è disponibile un aggiornamento. Se si usa l'API sync , non è necessario preoccuparsi di RemotePackage, perché gestirà automaticamente il processo di download e installazione.

Proprietà

RemotePackage eredita tutte le stesse proprietà LocalPackagedi , ma ne include uno aggiuntivo:

• downloadUrl: URL in cui è disponibile il pacchetto per il download. Questa proprietà è necessaria solo per l'utilizzo avanzato, poiché il download metodo gestirà automaticamente l'acquisizione degli aggiornamenti. (String)

Metodi

• download(downloadProgressCallback?: Funzione): Promise<LocalPackage>: scarica l'aggiornamento disponibile dal servizio CodePush. Se si specifica un downloadProgressCallback oggetto , verrà chiamato periodicamente con un DownloadProgress oggetto ({ totalBytes: Number, receivedBytes: Number }) che segnala lo stato di avanzamento del download fino al completamento. Restituisce una promessa che viene risolta con .LocalPackage

Enumerazioni

L'API CodePush include le enumerazioni seguenti, che possono essere usate per personalizzare l'esperienza di aggiornamento:

InstallMode

Questa enumerazione specifica quando si desidera che un aggiornamento installato venga effettivamente applicato e può essere passato ai sync metodi o LocalPackage.install . Include i valori seguenti:

• codePush.InstallMode.IMMEDIATE (0): indica che si vuole installare l'aggiornamento e riavviare immediatamente l'app. Questo valore è appropriato per gli scenari di debug e per la visualizzazione di una richiesta di aggiornamento all'utente, poiché si prevede di visualizzare le modifiche immediatamente dopo l'accettazione dell'installazione. Inoltre, questa modalità può essere usata per applicare gli aggiornamenti obbligatori, poiché rimuove la latenza potenzialmente indesiderata tra l'installazione dell'aggiornamento e la successiva riavvio dell'utente finale o riprende l'app.

• codePush.InstallMode.ON_NEXT_RESTART (1): indica che si vuole installare l'aggiornamento, ma non riavviare forzatamente l'app. Quando l'app viene riavviata "naturalmente" (a causa del sistema operativo o dell'utente finale che lo uccide), l'aggiornamento verrà prelevato senza problemi. Questo valore è appropriato quando si eseguono aggiornamenti invisibile all'utente invisibile all'utente, poiché è probabile che l'utente finale si riavvii improvvisamente fuori dal nulla. Non si renderebbero conto che un aggiornamento è stato anche scaricato. Questa è la modalità predefinita usata per entrambi i sync metodi e LocalPackage.install .

• codePush.InstallMode.ON_NEXT_RESUME (2): indica che si vuole installare l'aggiornamento, ma non si vuole riavviare l'app fino alla successiva ripresa dall'utente finale dallo sfondo. In questo modo, non si interrompe la sessione corrente, ma è possibile ottenere l'aggiornamento davanti a loro prima di dover attendere il successivo riavvio naturale. Questo valore è appropriato per le installazioni invisibile all'utente che possono essere applicate al curriculum in modo non invasivo.

• codePush.InstallMode.ON_NEXT_SUSPEND (3) - Indica che si vuole installare l'aggiornamento mentre è in background, ma solo dopo che è stato in background per minimumBackgroundDuration secondi (0 per impostazione predefinita), in modo che il contesto utente non venga perso a meno che la sospensione dell'app non sia abbastanza lunga da non importare.

CheckFrequency

Questa enumerazione specifica quando si vuole che l'app si sincronizzi con il server per gli aggiornamenti e possa essere passata all'elemento codePushify Decorator. Include i valori seguenti:

• codePush.CheckFrequency.ON_APP_START (0): indica che si vuole verificare la disponibilità di aggiornamenti ogni volta che viene avviato il processo dell'app.

• codePush.CheckFrequency.ON_APP_RESUME (1) - Indica che vuoi verificare la disponibilità di aggiornamenti ogni volta che l'app viene riportata in primo piano dopo essere stata "in background" (l'utente ha premuto il pulsante Home, l'app avvia un processo di pagamento separato e così via).

• codePush.CheckFrequency.MANUAL (2): disabilita il controllo automatico degli aggiornamenti, ma controlla solo quando codePush.sync() viene chiamato nel codice dell'app.

SyncStatus

Questa enumerazione viene fornita alla syncStatusChangedCallback funzione che può essere passata al metodo , per eseguire l'hook sync nel processo di aggiornamento complessivo. Include i valori seguenti:

• codePush.SyncStatus.CHECKING_FOR_UPDATE (0): viene eseguita una query sul server CodePush per un aggiornamento.
• codePush.SyncStatus.AWAITING_USER_ACTION (1): è disponibile un aggiornamento e viene visualizzata una finestra di dialogo di conferma all'utente finale. (Questo è applicabile solo quando updateDialog viene usato )
• codePush.SyncStatus.DOWNLOADING_PACKAGE (2): un aggiornamento disponibile viene scaricato dal server CodePush.
• codePush.SyncStatus.INSTALLING_UPDATE (3): è stato scaricato un aggiornamento disponibile che sta per essere installato.
• codePush.SyncStatus.UP_TO_DATE (4): l'app è completamente aggiornata con la distribuzione configurata.
• codePush.SyncStatus.UPDATE_IGNORED (5): l'app ha un aggiornamento facoltativo, che l'utente finale ha scelto di ignorare. (Questo è applicabile solo quando updateDialog viene usato )
• codePush.SyncStatus.UPDATE_INSTALLED (6): un aggiornamento disponibile è stato installato e verrà eseguito immediatamente dopo la restituzione della syncStatusChangedCallback funzione o la successiva ripresa/riavvio dell'app, a seconda dell'oggetto InstallMode specificato in SyncOptions.
• codePush.SyncStatus.SYNC_IN_PROGRESS (7): è in corso sync un'operazione che impedisce l'esecuzione della chiamata corrente.
• codePush.SyncStatus.UNKNOWN_ERROR (-1): l'operazione di sincronizzazione ha rilevato un errore sconosciuto.

UpdateState

Questa enumerazione specifica lo stato in cui è attualmente presente un aggiornamento e può essere specificato quando si chiama il getUpdateMetadata metodo . Include i valori seguenti:

• codePush.UpdateState.RUNNING (0): indica che un aggiornamento rappresenta la versione dell'app attualmente in esecuzione. Ciò può essere utile per identificare gli attributi relativi all'app, per scenari come la visualizzazione della descrizione della versione in una finestra di dialogo "Novità?" o la segnalazione della versione più recente a un servizio di analisi o segnalazione di arresti anomali.

• codePush.UpdateState.PENDING (1): indica che è stato installato un aggiornamento, ma l'app non è stata ancora riavviata per applicarla. Ciò può essere utile per determinare se è presente un aggiornamento in sospeso, che può essere necessario forzare l'applicazione di un riavvio a livello di codice (tramite restartApp).

• codePush.UpdateState.LATEST (2): indica che un aggiornamento rappresenta la versione disponibile più recente e può essere attualmente in esecuzione o in sospeso.

Informazioni di riferimento sulle API Objective-C (iOS)

L'API Objective-C viene resa disponibile importando l'intestazione CodePush.h nel file AppDelegate.m ed è costituita da una singola classe pubblica denominata CodePush.

CodePush

Contiene metodi statici per il recupero NSURL di che rappresenta il file di bundle JavaScript più recente e può essere passato al metodo 's initWithBundleURL durante il RCTRootViewbootstrap dell'app nel file AppDelegate.m.

I CodePush metodi della classe possono essere considerati come resolver compositi, che caricano sempre il bundle appropriato, per soddisfare gli scenari seguenti:

1. Quando un utente finale installa l'app dallo Store (ad esempio 1.0.0), otterrà il bundle JS contenuto nel file binario. Questo è il comportamento che si otterrà senza usare CodePush, ma è necessario assicurarsi che non si interrompa :)

2. Non appena si inizia a rilasciare gli aggiornamenti codePush, gli utenti finali otterranno il bundle JS che rappresenta la versione più recente per la distribuzione configurata. Questo è il comportamento che consente di eseguire un'iterazione oltre ciò che è stato spedito al negozio.

3. Non appena si rilascia un aggiornamento all'App Store (ad esempio 1.1.0) e gli utenti finali lo aggiornano, riceveranno nuovamente il bundle JS contenuto nel file binario. Questo comportamento garantisce che gli aggiornamenti codePush destinati a una versione binaria precedente non vengano usati (poiché non lo sappiamo che funzionerebbero) e gli utenti finali hanno sempre una versione funzionante dell'app.

4. Ripetere #2 e #3 man mano che le versioni codePush e app store continuano a entrare in infinito (e oltre?)

A causa di questo comportamento, è possibile distribuire gli aggiornamenti in modo sicuro sia negli Store app che in CodePush in base alle esigenze e assicurarsi che gli utenti finali ottengano sempre la versione più recente.

Metodi

• (NSURL *)bundleURL : restituisce il bundle NSURL JS più recente come descritto in precedenza. Questo metodo presuppone che il nome del bundle JS contenuto nel file binario dell'app sia main.jsbundle.

• (NSURL *)bundleURLForResource:(NSString *)resourceName - Equivalente al bundleURL metodo , ma consente anche di personalizzare il nome del bundle JS cercato all'interno del file binario dell'app. Questa opzione è utile se non si assegna un nome a questo file main (ovvero la convenzione predefinita). Questo metodo presuppone che l'estensione del bundle JS sia *.jsbundle.

• (NSURL *)bundleURLForResource:(NSString *)resourceName withExtension:(NSString *)resourceExtension: equivalente al bundleURLForResource: metodo, ma consente anche di personalizzare l'estensione usata dal bundle JS cercato all'interno del file binario dell'app. Questa opzione è utile se non si assegna un nome a questo file *.jsbundle (ovvero la convenzione predefinita).

• (void)overrideAppVersion:(NSString *)appVersionOverride - Imposta la versione dell'interfaccia binaria dell'applicazione, che altrimenti corrisponde alla versione di App Store specificata come CFBundleShortVersionString nell'Info.plist. Questa operazione deve essere chiamata una sola volta, prima del caricamento dell'URL del bundle.

• (void)setDeploymentKey:(NSString *)deploymentKey : imposta la chiave di distribuzione che l'app deve usare durante l'esecuzione di query per gli aggiornamenti. Si tratta di un'alternativa dinamica all'impostazione della chiave di distribuzione in Info.plist o alla specifica di una chiave di distribuzione in JS quando si chiama checkForUpdate o sync.

Informazioni di riferimento sulle API Java (Android)

API per React Native 0.60 versione e successive

Poiché autolinking usa react-native.config.js per collegare i plug-in, i costruttori vengono specificati in tale file. È tuttavia possibile eseguire l'override delle variabili personalizzate per gestire il plug-in CodePush inserendo questi valori nelle risorse stringa.

• Chiave pubblica: usata per la verifica del bundle nella funzionalità di firma del codice. Per altre informazioni sulla funzionalità di firma del codice, vedere la sezione Firma codice. Per impostare la chiave pubblica, è necessario aggiungere il contenuto della chiave pubblica a strings.xml con il nome CodePushPublicKey. CodePush ottiene automaticamente questa proprietà e abilita la funzionalità Firma codice. Ad esempio:

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

• URL del server: usato per specificare l'URL del server CodePush. Il valore predefinito: "https://codepush.appcenter.ms/" viene sottoposto a override aggiungendo il percorso a strings.xml con il nome CodePushServerUrl. CodePush ottiene automaticamente questa proprietà e userà questo percorso per inviare richieste. Ad esempio:

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

API per React Native inferiore a 0.60

L'API Java viene resa disponibile importando la com.microsoft.codepush.react.CodePush classe nel file MainActivity.java ed è costituita da una singola classe pubblica denominata CodePush.

CodePush

Costruisce il runtime del client CodePush e rappresenta l'istanza ReactPackage aggiunta all'elenco di pacchetti dell'app.

Costruttori

• CodePush(String deploymentKey, Activity mainActivity): crea una nuova istanza del runtime CodePush, che verrà usata per eseguire query sul servizio per gli aggiornamenti tramite la chiave di distribuzione fornita. Il mainActivity parametro deve essere sempre impostato su this quando si configura l'elenco di pacchetti React all'interno della MainActivity classe . Questo costruttore inserisce il runtime CodePush in "modalità di rilascio", quindi se si vuole abilitare il comportamento di debug, usare invece il costruttore seguente.

• CodePush(String deploymentKey, Activity mainActivity, bool isDebugMode): equivale al costruttore precedente, ma consente di specificare se si vuole che il runtime CodePush sia in modalità di debug o meno. Quando si usa questo costruttore, il isDebugMode parametro deve sempre essere impostato su BuildConfig.DEBUG per rimanere sincronizzato con il tipo di compilazione. Quando si inserisce CodePush in modalità di debug, sono abilitati i comportamenti seguenti:

  1. Gli aggiornamenti di CodePush precedenti non vengono eliminati dalla risorsa di archiviazione ogni volta che viene distribuito un nuovo file binario nell'emulatore o nel dispositivo. Questo comportamento consente di distribuire nuovi file binari, senza urtare la versione durante lo sviluppo e senza ricevere continuamente lo stesso aggiornamento ogni volta che l'app chiama sync.

  2. La cache locale gestita dal runtime React Native in modalità di debug viene eliminata ogni volta che viene installato un aggiornamento CodePush. Ciò garantisce che quando l'app viene riavviata dopo l'applicazione di un aggiornamento, è possibile visualizzare le modifiche previste. Non appena questa richiesta pull viene unita, non è più necessario eseguire questa operazione.

• CodePush(String deploymentKey, Context, boolean isDebugMode, Integer publicKeyResourceDescriptor) - Equivalente al costruttore precedente, ma consente di specificare il descrittore della risorsa chiave pubblica necessario per leggere il contenuto della chiave pubblica. Per altre informazioni sulla funzionalità di firma del codice, vedere la sezione Firma codice.

• CodePush(String deploymentKey, Context, boolean isDebugMode, String serverUrl): il costruttore consente di specificare l'URL del server CodePush. Il valore predefinito: "https://codepush.appcenter.ms/" viene sottoposto a override dal valore specificato in serverUrl.

Metodi statici

• getBundleUrl() - Restituisce il percorso alla versione più recente del file bundle JS dell'app, presupponendo che il nome della risorsa sia index.android.bundle. Se l'app usa un nome di bundle diverso, usa la versione di overload di questo metodo, che consente di specificarla. Questo metodo ha lo stesso comportamento di risoluzione dell'equivalente Objective-C descritto in precedenza.

• getBundleUrl(String bundleName): restituisce il percorso alla versione più recente del file di bundle JS dell'app, usando il nome della risorsa specificato (ad esempio index.android.bundle). Questo metodo ha lo stesso comportamento di risoluzione dell'equivalente Objective-C descritto in precedenza.

• overrideAppVersion(String appVersionOverride): imposta la versione dell'interfaccia binaria dell'applicazione, che altrimenti corrisponde alla versione di Play Store specificata come versionName nella build.gradle. Questa operazione deve essere chiamata una sola volta, prima che l'istanza codePush venga costruita.