J'ai mis mon application sur le Google Play Store. Il a été installé par de nombreux clients de mon entreprise. Je comprends le mécanisme de mise à niveau de l'application.

Les utilisateurs doivent cocher la case de mise à jour automatique dans l'application Playstore pour chaque application qu'ils souhaitent mettre à jour automatiquement. Cependant, certains utilisateurs l'ont décoché ou ne l'ont pas vérifié en premier lieu.

L'application que j'ai écrite est destinée à l'industrie des soins et est utilisée par les soignants pour fournir des soins à domicile. Certains de nos clients ont 1200 soignants. Ils devraient appeler tous les soignants dans le bureau pour mettre à jour les téléphones individuellement. C'est évidemment inacceptable.

Existe-t-il un moyen de vérifier par programme s'il existe une version mise à jour de mon application sur le Play Store?

Puis-je avoir un code qui s'exécute chaque fois que l'utilisateur démarre l'application qui vérifie le Play Store? S'il existe une version mise à jour, l'utilisateur peut être dirigé vers le Playstore. Cela signifie qu'il n'est pas essentiel de faire vérifier la mise à jour automatique.

Merci d'avance

Mat

Mise à jour du 17 octobre 2019

https://developer.android.com/guide/app-bundle/in-app-updates

Mise à jour du 24 avril 2019:

Android a annoncé une fonctionnalité qui résoudra probablement ce problème. Utilisation de l'API des mises à jour intégrées à l'application: https://android-developers.googleblog.com/2018/11/unfolding-right-now-at-androiddevsummit.html

Original:

Pour autant que je sache, il n'y a pas d'API Google officielle qui prend en charge cela.

Vous devriez envisager d'obtenir un numéro de version à partir d'une API.

Au lieu de vous connecter à des API externes ou à des pages Web (comme Google Play Store). Il existe un risque que quelque chose change dans l'API ou la page Web, vous devez donc envisager de vérifier si le code de version de l'application actuelle est inférieur au numéro de version que vous obtenez de votre propre API.

N'oubliez pas que si vous mettez à jour votre application, vous devez changer la version dans votre propre API avec le numéro de version de l'application.

Je vous recommande de créer un fichier dans votre propre site Web ou API, avec le numéro de version. (Éventuellement, faites un cronjob et rendez la mise à jour automatique de la version, et envoyez une notification en cas de problème)

Vous devez obtenir cette valeur depuis votre page Google Play Store (est modifiée entre-temps, ne fonctionne plus):

<div class="content" itemprop="softwareVersion"> x.x.x  </div>

Vérifiez dans votre application si la version utilisée sur le mobile est inférieure au numéro de version affiché sur votre propre API.

Indiquez qu'il / elle a besoin de mettre à jour avec une notification, idéalement.

Les choses que vous pouvez faire

Numéro de version utilisant votre propre API

Avantages:

• Pas besoin de charger tout le code du Google Play Store (économise sur les données / bande passante)

Les inconvénients:

• L'utilisateur peut être hors ligne, ce qui rend la vérification inutile car l'API n'est pas accessible

Numéro de version sur la page Web Google Play Store

Avantages:

• Vous n'avez pas besoin d'une API

Les inconvénients:

• L'utilisateur peut être hors ligne, ce qui rend la vérification inutile car l'API n'est pas accessible
  • L'utilisation de cette méthode peut coûter plus de bande passante / données mobiles à vos utilisateurs
  • La page Web du Play Store peut changer, ce qui fait que votre version «ripper» ne fonctionne plus.

Incluez JSoup dans le fichier build.gradle de votre application:

dependencies {
    compile 'org.jsoup:jsoup:1.8.3'
}

et obtenez la version actuelle comme:

currentVersion = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;

Et exécutez le fil suivant:

private class GetVersionCode extends AsyncTask<Void, String, String> {
    @Override
    protected String doInBackground(Void... voids) {

    String newVersion = null;
    try {
        newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + MainActivity.this.getPackageName() + "&hl=it")
                .timeout(30000)
                .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                .referrer("http://www.google.com")
                .get()
                .select(".hAyfc .htlgb")
                .get(7)
                .ownText();
        return newVersion;
    } catch (Exception e) {
        return newVersion;
    }
    }

    @Override
    protected void onPostExecute(String onlineVersion) {
        super.onPostExecute(onlineVersion);
        Log.d("update", "Current version " + currentVersion + "playstore version " + onlineVersion);
        if (onlineVersion != null && !onlineVersion.isEmpty()) {
            if (Float.valueOf(currentVersion) < Float.valueOf(onlineVersion)) {
                //show dialog
            }
        }
    }

Pour plus de détails, visitez: http://revisitingandroid.blogspot.in/2016/12/programmatically-check-play-store-for.html

Firebase Remote Config pourrait être une solution possible et fiable pour le moment, car Google ne lui a exposé aucune API.

Consultez la documentation de Firebase Remote Config

Étapes 1: créez un projet Firebase et ajoutez google_play_service.json à votre projet

2.Créez des clés telles que "android_latest_version_code" et "android_latest_version_name" dans la console Firebase-> Remote Config

3. Code Android

    public void initializeFirebase() {
        if (FirebaseApp.getApps(mContext).isEmpty()) {
            FirebaseApp.initializeApp(mContext, FirebaseOptions.fromResource(mContext));
        }
        final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
        FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
                                                              .setDeveloperModeEnabled(BuildConfig.DEBUG)
                                                              .build();
        config.setConfigSettings(configSettings);
}

Obtenir le nom et le code de la version actuelle

int playStoreVersionCode = FirebaseRemoteConfig.getInstance().getString(
                "android_latest_version_code");
PackageInfo pInfo = this.getPackageManager().getPackageInfo(getPackageName(), 0);
int currentAppVersionCode = pInfo.versionCode; 
if(playStoreVersionCode>currentAppVersionCode){
//Show update popup or whatever best for you
}

4. Et gardez Firebase "android_latest_version_code" et "android_latest_version_name" à jour avec le nom et le code de votre version de production actuelle.

La configuration à distance Firebase fonctionne à la fois sur Android et sur iPhone.

Vous pouvez obtenir en cours Playstore version en utilisant JSoupavec quelques modifications comme ci - dessous:

@Override
protected String doInBackground(Void... voids) {

    String newVersion = null;
    try {
        newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + MainActivity.this.getPackageName() + "&hl=it")
                .timeout(30000)
                .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                .referrer("http://www.google.com")
                .get()
                .select(".hAyfc .htlgb")
                .get(7)
                .ownText();
        return newVersion;
    } catch (Exception e) {
        return newVersion;
    }
}

@Override
protected void onPostExecute(String onlineVersion) {
    super.onPostExecute(onlineVersion);

    Log.d("update", "playstore version " + onlineVersion);
}

La réponse de @Tarun ne fonctionne plus.

La réponse @Tarun fonctionnait parfaitement, mais ce n'est plus le cas, en raison des récents changements de Google sur le site Web de Google Play.

Modifiez-les simplement depuis la réponse @Tarun.

class GetVersionCode extends AsyncTask<Void, String, String> {

    @Override

    protected String doInBackground(Void... voids) {

        String newVersion = null;

        try {
            Document document = Jsoup.connect("https://play.google.com/store/apps/details?id=" + MainActivity.this.getPackageName()  + "&hl=en")
                    .timeout(30000)
                    .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                    .referrer("http://www.google.com")
                    .get();
            if (document != null) {
                Elements element = document.getElementsContainingOwnText("Current Version");
                for (Element ele : element) {
                    if (ele.siblingElements() != null) {
                        Elements sibElemets = ele.siblingElements();
                        for (Element sibElemet : sibElemets) {
                            newVersion = sibElemet.text();
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return newVersion;

    }


    @Override

    protected void onPostExecute(String onlineVersion) {

        super.onPostExecute(onlineVersion);

        if (onlineVersion != null && !onlineVersion.isEmpty()) {

            if (Float.valueOf(currentVersion) < Float.valueOf(onlineVersion)) {
                //show anything
            }

        }

        Log.d("update", "Current version " + currentVersion + "playstore version " + onlineVersion);

    }
}

et n'oubliez pas d'ajouter la bibliothèque JSoup

dependencies {
compile 'org.jsoup:jsoup:1.8.3'}

et sur Oncreate ()

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);


    String currentVersion;
    try {
        currentVersion = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }

    new GetVersionCode().execute();

}

c'est tout .. Merci à ce lien

Google a introduit l' API de mises à jour dans l'application

L'API prend actuellement en charge deux flux:

• Le flux «immédiat» est une expérience utilisateur en plein écran qui guide l'utilisateur du téléchargement à la mise à jour avant de pouvoir utiliser votre application.
• Le «flux flexible» permet aux utilisateurs de télécharger la mise à jour tout en continuant à utiliser votre application.

Il y a la bibliothèque AppUpdater . Comment inclure:

1. Ajoutez le référentiel à votre projet build.gradle :

allprojects {
    repositories {
        jcenter()
        maven {
            url "https://jitpack.io"
        }
    }
}

2. Ajoutez la bibliothèque à votre module build.gradle :

dependencies {
    compile 'com.github.javiersantos:AppUpdater:2.6.4'
}

3. Ajoutez les autorisations INTERNET et ACCESS_NETWORK_STATE au manifeste de votre application:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

4. Ajoutez ceci à votre activité:

AppUpdater appUpdater = new AppUpdater(this); 
appUpdater.start();

Provenant d'un PDV d'application hybride. Ceci est un exemple javascript, j'ai un pied de page Mise à jour disponible dans mon menu principal. Si une mise à jour est disponible (c'est-à-dire que mon numéro de version dans le fichier de configuration est inférieur à la version récupérée, affichez le pied de page) Cela dirigera alors l'utilisateur vers l'app / play store, où l'utilisateur peut alors cliquer sur le bouton de mise à jour.

Je reçois également les nouvelles données (c'est-à-dire les notes de publication) et les affiche dans un modal lors de la connexion si c'est la première fois sur cette version.

Sur l'appareil prêt, définissez l'URL de votre boutique

        if (device.platform == 'iOS')
           storeURL = 'https://itunes.apple.com/lookup?bundleId=BUNDLEID';
        else
           storeURL = 'https://play.google.com/store/apps/details?id=BUNDLEID';

La méthode Update Available peut être exécutée aussi souvent que vous le souhaitez. Le mien est exécuté chaque fois que l'utilisateur accède à l'écran d'accueil.

function isUpdateAvailable() {
    if (device.platform == 'iOS') {
        $.ajax(storeURL, {
            type: "GET",
            cache: false,
            dataType: 'json'
        }).done(function (data) {
            isUpdateAvailable_iOS(data.results[0]);
        }).fail(function (jqXHR, textStatus, errorThrown) {
            commsErrorHandler(jqXHR, textStatus, false);
        });
    } else {
        $.ajax(storeURL, {
            type: "GET",
            cache: false
        }).done(function (data) {
            isUpdateAvailable_Android(data);
        }).fail(function (jqXHR, textStatus, errorThrown) {
            commsErrorHandler(jqXHR, textStatus, false);
        });
    }
}

Rappel iOS: Apple a une API, donc très facile à obtenir

function isUpdateAvailable_iOS (data) {
    var storeVersion = data.version;
    var releaseNotes = data.releaseNotes;
    // Check store Version Against My App Version ('1.14.3' -> 1143)
    var _storeV = parseInt(storeVersion.replace(/\./g, ''));
    var _appV = parseInt(appVersion.substring(1).replace(/\./g, ''));
    $('#ft-main-menu-btn').off();
    if (_storeV > _appV) {
        // Update Available
        $('#ft-main-menu-btn').text('Update Available');
        $('#ft-main-menu-btn').click(function () {
            openStore();
        });

    } else {
        $('#ft-main-menu-btn').html(' ');
        // Release Notes
        settings.updateReleaseNotes('v' + storeVersion, releaseNotes);
    }
}

Rappel Android: PlayStore vous devez gratter, comme vous pouvez le voir, la version est relativement facile à saisir et les nouveautés, je prends le html au lieu du texte, car de cette façon, je peux utiliser leur mise en forme (c'est-à-dire de nouvelles lignes, etc.)

function isUpdateAvailable_Android(data) {
    var html = $(data);
    var storeVersion = html.find('div[itemprop=softwareVersion]').text().trim();
    var releaseNotes = html.find('.whatsnew')[0].innerHTML;
    // Check store Version Against My App Version ('1.14.3' -> 1143)
    var _storeV = parseInt(storeVersion.replace(/\./g, ''));
    var _appV = parseInt(appVersion.substring(1).replace(/\./g, ''));
    $('#ft-main-menu-btn').off();
    if (_storeV > _appV) {
        // Update Available
        $('#ft-main-menu-btn').text('Update Available');
        $('#ft-main-menu-btn').click(function () {
            openStore();
        });

    } else {
        $('#ft-main-menu-btn').html(' ');
        // Release Notes
        settings.updateReleaseNotes('v' + storeVersion, releaseNotes);
    }
}

La logique du magasin ouvert est simple, mais par souci d'exhaustivité

function openStore() {
    var url = 'https://itunes.apple.com/us/app/appname/idUniqueID';
    if (device.platform != 'iOS')
       url = 'https://play.google.com/store/apps/details?id=appid'
   window.open(url, '_system')
}

Assurez-vous que le Play Store et l'App Store ont été ajoutés à la liste blanche:

  <access origin="https://itunes.apple.com"/>
  <access origin="https://play.google.com"/>

Firebase Remote Config est meilleur.

• Mettez à jour rapidement et facilement nos applications sans avoir besoin de publier une nouvelle version sur l'application

Implémentation de Remote Config sur Android

Ajout de la dépendance Remote Config

compile 'com.google.firebase:firebase-config:9.6.0'

Une fois cela fait, nous pouvons accéder à l'instance FirebaseRemoteConfig dans toute notre application si nécessaire:

FirebaseRemoteConfig firebaseRemoteConfig = FirebaseRemoteConfig.getInstance();

Récupération des valeurs de configuration à distance

boolean someBoolean = firebaseRemoteConfig.getBoolean("some_boolean");
byte[] someArray = firebaseRemoteConfig.getByteArray("some_array");
double someDouble = firebaseRemoteConfig.getDouble("some_double");
long someLong = firebaseRemoteConfig.getLong("some_long");
String appVersion = firebaseRemoteConfig.getString("appVersion");

Récupérer les valeurs côté serveur

firebaseRemoteConfig.fetch(cacheExpiration)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        mFirebaseRemoteConfig.activateFetched();
                        // We got our config, let's do something with it!
                        if(appVersion < CurrentVersion){
                           //show update dialog
                        }
                    } else {
                        // Looks like there was a problem getting the config...
                    }
                }
            });

Une fois la nouvelle version téléchargée sur Playstore, nous devons mettre à jour le numéro de version dans Firebase. Maintenant, s'il s'agit d'une nouvelle version, la boîte de dialogue de mise à jour s'affiche

Dans la méthode OnCreate, écrivez sous le code.

VersionChecker versionChecker = new VersionChecker();
    try {
        latestVersion = versionChecker.execute().get();
        Toast.makeText(getBaseContext(), latestVersion , Toast.LENGTH_SHORT).show();

    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }

cela vous donne la version Play Store de l'application.

alors vous devez vérifier la version de l'application comme ci-dessous

PackageManager manager = getPackageManager();
    PackageInfo info = null;
    try {
        info = manager.getPackageInfo(getPackageName(), 0);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    assert info != null;
    version = info.versionName;

après cela, vous pouvez le comparer avec la version du magasin et configurer vos propres écrans de mise à jour

if(version.equals(latestVersion)){
        Toast.makeText(getBaseContext(), "No Update" , Toast.LENGTH_SHORT).show();
    }else {
        Toast.makeText(getBaseContext(), "Update" , Toast.LENGTH_SHORT).show();

    }

Et ajoutez VersionChecker.class comme ci-dessous

public class VersionChecker extends AsyncTask<String, String, String> {

    private String newVersion;

    @Override
    protected String doInBackground(String... params) {

        try {
            newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + "package name" + "&hl=en")
                    .timeout(30000)
                    .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                    .referrer("http://www.google.com")
                    .get()
                    .select(".hAyfc .htlgb")
                    .get(7)
                    .ownText();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return newVersion;
    }
}

Configurez un serveur qui expose une URL HTTP qui signale la dernière version, puis utilisez un AlarmManager pour appeler cette URL et voir si la version sur l'appareil est la même que la dernière version. Si ce n'est pas le cas, affichez un message ou une notification et envoyez-les au marché pour une mise à niveau.

Il existe quelques exemples de code: Comment autoriser les utilisateurs à vérifier la dernière version de l'application à l'intérieur de l'application?

Outre l'utilisation de JSoup, nous pouvons également effectuer une correspondance de modèles pour obtenir la version de l'application à partir de playStore.

Pour correspondre au dernier modèle de google playstore, <div class="BgcNfc">Current Version</div><span class="htlgb"><div><span class="htlgb">X.X.X</span></div> nous devons d'abord faire correspondre la séquence de nœuds ci-dessus, puis à partir de la séquence ci-dessus, obtenir la valeur de la version. Vous trouverez ci-dessous l'extrait de code pour le même:

    private String getAppVersion(String patternString, String inputString) {
        try{
            //Create a pattern
            Pattern pattern = Pattern.compile(patternString);
            if (null == pattern) {
                return null;
            }

            //Match the pattern string in provided string
            Matcher matcher = pattern.matcher(inputString);
            if (null != matcher && matcher.find()) {
                return matcher.group(1);
            }

        }catch (PatternSyntaxException ex) {

            ex.printStackTrace();
        }

        return null;
    }


    private String getPlayStoreAppVersion(String appUrlString) {
        final String currentVersion_PatternSeq = "<div[^>]*?>Current\\sVersion</div><span[^>]*?>(.*?)><div[^>]*?>(.*?)><span[^>]*?>(.*?)</span>";
        final String appVersion_PatternSeq = "htlgb\">([^<]*)</s";
        String playStoreAppVersion = null;

        BufferedReader inReader = null;
        URLConnection uc = null;
        StringBuilder urlData = new StringBuilder();

        final URL url = new URL(appUrlString);
        uc = url.openConnection();
        if(uc == null) {
           return null;
        }
        uc.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6");
        inReader = new BufferedReader(new InputStreamReader(uc.getInputStream()));
        if (null != inReader) {
            String str = "";
            while ((str = inReader.readLine()) != null) {
                           urlData.append(str);
            }
        }

        // Get the current version pattern sequence 
        String versionString = getAppVersion (currentVersion_PatternSeq, urlData.toString());
        if(null == versionString){ 
            return null;
        }else{
            // get version from "htlgb">X.X.X</span>
            playStoreAppVersion = getAppVersion (appVersion_PatternSeq, versionString);
        }

        return playStoreAppVersion;
    }

Je l'ai résolu grâce à cela, car cela fonctionne également pour les derniers changements de Google Playstore. J'espère que ça t'as aidé.

private void CheckUPdate() {
    VersionChecker versionChecker = new VersionChecker();
    try
    {   String appVersionName = BuildConfig.VERSION_NAME;
        String mLatestVersionName = versionChecker.execute().get();
        if(!appVersionName.equals(mLatestVersionName)){
            AlertDialog.Builder alertDialog = new AlertDialog.Builder(Activity.this);
            alertDialog.setTitle("Please update your app");
            alertDialog.setMessage("This app version is no longer supported. Please update your app from the Play Store.");
            alertDialog.setPositiveButton("UPDATE NOW", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    final String appPackageName = getPackageName();
                    try {
                        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + appPackageName)));
                    } catch (android.content.ActivityNotFoundException anfe) {
                        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=" + appPackageName)));
                    }
                }
            });
            alertDialog.show();
        }

    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

@SuppressLint("StaticFieldLeak")
public class VersionChecker extends AsyncTask<String, String, String> {
    private String newVersion;
    @Override
    protected String doInBackground(String... params) {

        try {
            newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id="+getPackageName())
                    .timeout(30000)
                    .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                    .referrer("http://www.google.com")
                    .get()
                    .select(".hAyfc .htlgb")
                    .get(7)
                    .ownText();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return newVersion;
    }
}

Il n'y a pas d'API GooglePlay officielle pour le faire.

Mais vous pouvez utiliser cette bibliothèque non officielle pour obtenir des données de version d'application.

Et, si ce qui précède ne fonctionne pas pour vous, vous pouvez toujours http vous connecter à la page de votre application (par exemple https://play.google.com/store/apps/details?id=com.shots.android&hl=fr ) et analyser le champ "Version actuelle".

Vous pouvez essayer de suivre le code en utilisant Jsoup

String latestVersion = doc.getElementsContainingOwnText("Current Version").parents().first().getAllElements().last().text();

Google a introduit l'API de mise à jour dans l'application. En utilisant cela, nous pouvons demander à l'utilisateur de mettre à jour l'application dans l'application. si l'utilisateur accepte, nous pouvons directement télécharger la dernière application et l'installer sans rediriger vers le Playstore. pour plus de détails, veuillez consulter le lien ci-dessous

link1 lien2

confirmé que seule cette méthode fonctionne maintenant:

newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=" + AcMainPage.this.getPackageName() + "&hl=it")
                        .timeout(30000)
                        .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")
                        .referrer("http://www.google.com")
                        .get()
                        .select(".hAyfc .htlgb")
                        .get(5)
                        .ownText();

Google a introduit la fonctionnalité de mises à jour dans l'application , ( https://developer.android.com/guide/app-bundle/in-app-updates ) cela fonctionne sur Lollipop + et vous donne la possibilité de demander à l'utilisateur une mise à jour avec un joli dialogue (FLEXIBLE) ou avec un message plein écran obligatoire (IMMEDIATE).

Voici à quoi ressemblera la mise à jour flexible :

et voici le flux de mise à jour Immedtiate :

Vous pouvez vérifier ma réponse ici https://stackoverflow.com/a/56808529/5502121 pour obtenir l'exemple de code complet de mise en œuvre des flux de mise à jour flexibles et immédiats . J'espère que cela aide!