Força a atualização de um aplicativo Android quando uma nova versão estiver disponível

Eu tenho um aplicativo na Google Play Store. Quando uma versão de atualização está disponível, a versão mais antiga se torna inutilizável - ou seja, se os usuários não atualizarem o aplicativo, eles não entrarão no aplicativo. Como posso forçar os usuários a atualizar o aplicativo quando uma nova versão estiver disponível?

Concordo com o ponto de Scott Helme em outra resposta aqui. Mas em algumas situações extremas (problemas de segurança, alterações de quebra de API ...) onde você absolutamente precisa que os usuários atualizem para continuar usando o aplicativo, você pode fornecer uma API de controle de versão simples. A API ficaria assim:

API versionCheck:

Parâmetros de solicitação:

• int appVersion

Resposta

1. boolean forceUpgrade
2. boolean recommendUpgrade

Quando seu aplicativo é iniciado, você pode chamar essa API que passa na versão atual do aplicativo e verificar a resposta da chamada da API de controle de versão.

Se forceUpgradeestiver true, mostre uma caixa de diálogo pop-up com opções para permitir que o usuário saia do aplicativo ou vá para a Google Play Store para atualizar o aplicativo.

Else if recommendUpgradeé true, mostrar a janela pop-up com opções para atualizar ou continuar usando o aplicativo.

Mesmo com essa capacidade de atualização forçada em vigor, você deve continuar a oferecer suporte a versões mais antigas, a menos que seja absolutamente necessário.

tente isto: primeiro você precisa fazer uma chamada de solicitação para o link da playstore, buscar a versão atual de lá e compará-la com a sua versão atual.

String currentVersion, latestVersion;
Dialog dialog;
private void getCurrentVersion(){
 PackageManager pm = this.getPackageManager();
        PackageInfo pInfo = null;

        try {
            pInfo =  pm.getPackageInfo(this.getPackageName(),0);

        } catch (PackageManager.NameNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        currentVersion = pInfo.versionName;

   new GetLatestVersion().execute();

}

private class GetLatestVersion extends AsyncTask<String, String, JSONObject> {

        private ProgressDialog progressDialog;

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected JSONObject doInBackground(String... params) {
            try {
//It retrieves the latest version by scraping the content of current version from play store at runtime
                Document doc = Jsoup.connect(urlOfAppFromPlayStore).get();
                latestVersion = doc.getElementsByClass("htlgb").get(6).text();

            }catch (Exception e){
                e.printStackTrace();

            }

            return new JSONObject();
        }

        @Override
        protected void onPostExecute(JSONObject jsonObject) {
            if(latestVersion!=null) {
                if (!currentVersion.equalsIgnoreCase(latestVersion)){
                   if(!isFinishing()){ //This would help to prevent Error : BinderProxy@45d459c0 is not valid; is your activity running? error
                    showUpdateDialog();
                    }
                }
            }
            else
                background.start();
            super.onPostExecute(jsonObject);
        }
    }

private void showUpdateDialog(){
        final AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("A New Update is Available");
        builder.setPositiveButton("Update", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse
                        ("market://details?id=yourAppPackageName")));
                dialog.dismiss();
            }
        });

        builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                background.start();
            }
        });

        builder.setCancelable(false);
        dialog = builder.show();
    }

Você não deve parar de oferecer suporte a uma versão mais antiga assim que uma nova versão for lançada. Isso resultará em uma experiência de usuário terrível. Não conheço nenhum fornecedor de software que faça isso, por um bom motivo.

O que acontece se o usuário não puder atualizar ou não quiser naquele momento? Eles simplesmente não podem usar seu aplicativo, o que é ruim.

O Google não fornece nenhuma opção para rastreamento de versão como essa, então você teria que fazer a sua própria. Um serviço da web simples para retornar a versão ativa atual que seu aplicativo pode verificar seria suficiente. Você pode então atualizar a versão e o aplicativo saberá que está desatualizado. Eu só recomendo usar isso para que seus usuários saibam que há uma atualização mais rapidamente do que dependendo do Google Play. Na verdade, não deve ser usado para impedir que o aplicativo funcione, apenas para solicitar que o usuário atualize.

Solução da equipe do Google

A partir do Android 5.0, isso é facilmente alcançável por meio do novo mecanismo de atualizações do Google Play In App. Os requisitos são ter a biblioteca Play Core da versão 1.5.0+ e usar a distribuição de App Bundles em vez de apks.

A biblioteca oferece 2 maneiras diferentes de notificar os usuários sobre a atualização:

1. Flexível, quando os usuários podem continuar usando o aplicativo enquanto ele está sendo atualizado em segundo plano.

2. Imediato - tela de bloqueio que não permite que um usuário entre no aplicativo até que o atualize.

Existem próximas etapas para implementá-lo:

1. Verifique a disponibilidade de atualizações
2. Inicie uma atualização
3. Receba um retorno de chamada para atualizar o status
4. Lidar com a atualização

Todas essas implementações de etapas são descritas em detalhes no site oficial: https://developer.android.com/guide/app-bundle/in-app-updates

As respostas de Scott e Michael estão corretas. Hospede um serviço que forneça um número mínimo de versão compatível e compare-o com a versão instalada. Espero que você nunca precise usar isso, mas é um salva-vidas se alguma versão estiver disponível, você absolutamente deve matar devido a alguma falha séria.

Eu só queria adicionar o código para o que fazer a seguir. É assim que você inicia o Google Play Intent e leva-o para sua nova versão na loja após avisar ao usuário que deve fazer o upgrade.

public class UpgradeActivity extends Activity {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_upgrade);
        final String appName = "com.appname";
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                    startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id="+appName)));

            }
        });
    }
}

Você deve reconsiderar seu design se precisar forçar atualizações em cada versão.

O Google introduziu atualizações lib no aplicativo, ( https://developer.android.com/guide/app-bundle/in-app-updates ) que funciona no Lollipop + e oferece a capacidade de solicitar ao usuário uma atualização com um bom diálogo (FLEXÍVEL) ou com mensagem obrigatória em tela cheia (IMEDIATA).

Você precisa implementar o último. É assim que vai ficar:

Abordei todo o código nesta resposta: https://stackoverflow.com/a/56808529/5502121

Eu recomendo fortemente verificar a funcionalidade de configuração remota do Firebase para isso.

Eu implementei usando um parâmetro - app_version_enabled - com uma condição "Disabled Android Versions" que se parece com isto:

applies if App ID == com.example.myapp and App version regular expression ^(5.6.1|5.4.2) 

O padrão para o parâmetro é "true", mas Disabled Android Versions tem um valor false. No meu regex para versões desativadas do Android, você pode adicionar mais versões desativadas simplesmente com outra |{version name}dentro desses parênteses.

Então, eu apenas verifico se a configuração diz que a versão está habilitada ou não - eu tenho uma atividade que inicio que força o usuário a atualizar. Eu verifico os únicos dois lugares em que o aplicativo pode ser iniciado externamente (minha atividade de iniciador padrão e uma atividade de manipulação de intenção). Como o Remote config funciona com base em cache, ele não capturará imediatamente as versões "desativadas" do aplicativo se não tiver passado o tempo necessário para o cache ser invalidado, mas isso é no máximo 12 horas se você estiver passando seu valor de expiração de cache recomendado.

Oficialmente, o Google fornece uma API Android para isso.

A API está sendo testada com vários parceiros e estará disponível para todos os desenvolvedores em breve.

A API de atualização já está disponível - https://developer.android.com/guide/app-bundle/in-app-updates

verifique o código da versão do apk local e da Play Store

try {
        versionChecker VersionChecker = new versionChecker();
        String versionUpdated = VersionChecker.execute().get().toString();
        Log.i("version code is", versionUpdated);


        PackageInfo packageInfo = null;
        try {
            packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        int version_code = packageInfo.versionCode;
        String version_name = packageInfo.versionName;
        Log.i("updated version code", String.valueOf(version_code) + "  " + version_name);
        if (version_name != versionUpdated) {
            String packageName = getApplicationContext().getPackageName();//
            UpdateMeeDialog updateMeeDialog = new UpdateMeeDialog();
            updateMeeDialog.showDialogAddRoute(MainActivity.this, packageName);
            Toast.makeText(getApplicationContext(), "please updated", Toast.LENGTH_LONG).show();
        }
    } catch (Exception e) {
        e.getStackTrace();
    }

implementar classe para verificação de versão

class versionChecker extends AsyncTask<String, String, String> {
String newVersion;

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

    try {
        newVersion = Jsoup.connect("https://play.google.com/store/apps/details?id=+YOR_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("div[itemprop=softwareVersion]")
                .first()
                .ownText();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return newVersion;
}
}

caixa dialob para atualização

public class UpdateMeeDialog {

ActivityManager am;
TextView rootName;
Context context;
Dialog dialog;
String key1,schoolId;
public void showDialogAddRoute(Activity activity, final String packageName){
    context=activity;
    dialog = new Dialog(context);

    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    dialog.setCancelable(false);
    dialog.setContentView(R.layout.dialog_update);
    am = (ActivityManager)activity.getSystemService(Context.ACTIVITY_SERVICE);

    Button cancelDialogue=(Button)dialog.findViewById(R.id.buttonUpdate);
    Log.i("package name",packageName);
    cancelDialogue.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Intent intent=new Intent(Intent.ACTION_VIEW);                
    intent.setData(Uri.parse("https://play.google.com/store/apps/details?
    id="+packageName+"&hl=en"));
            context.startActivity(intent);
        }
    });
    dialog.show();
}
}

layout de diálogo

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#d4e9f2">


<TextView
    android:layout_width="match_parent"
    android:layout_height="40dp"

    android:text="Please Update First..!!"
    android:textSize="20dp"
    android:textColor="#46a5df"
    android:textAlignment="center"
    android:layout_marginTop="50dp"
    android:id="@+id/textMessage"
    />
<LinearLayout
    android:layout_width="match_parent"
    android:orientation="horizontal"
    android:weightSum="1"
    android:layout_marginTop="50dp"
    android:layout_below="@+id/textMessage"
    android:layout_height="50dp">

    <Button
        android:id="@+id/buttonUpdate"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Update"
        android:background="#67C6F1"
        android:textAlignment="center" />
</LinearLayout>

É melhor definir nosso próprio processo para atualização.

1. Crie um serviço web que forneça a versão mais recente do aplicativo (ios, android) de nosso servidor.
2. Ou Qualquer serviço da web que você usou no aplicativo (por exemplo, Login) retornará a versão mais recente do aplicativo do servidor.
3. Uma vez que o aplicativo obterá a versão # 1 ou 2. O aplicativo fará a verificação cruzada com a versão do aplicativo local / cuurent. se houver diferença, podemos mostrar o alerta da seguinte maneira,

Android e iOS: se a versão mais recente do aplicativo estiver disponível, ele mostrará um alerta como “Última versão disponível com mais recursos. Para atualizar, clique no botão de atualização” (Alerta com “Upgarde” e o botão “Não. Obrigado”.) Em seguida, o aplicativo redirecionará para playstore / Appstore e abrirá a versão mais recente.

 --- we can do upgrade compulsory or optionally.

Antes do processo de atualização, certifique-se de lidar com o processo de migração de banco de dados adequado se houver qualquer alteração no esquema de banco de dados.

Para forçar o usuário do aplicativo a atualizar se uma atualização estiver disponível no mercado, você deve primeiro verificar a versão do aplicativo no mercado e compará-la com a versão do aplicativo no dispositivo. Se forem diferentes, pode haver uma atualização disponível. Neste post eu escrevi o código para obter a versão atual do market e a versão atual do dispositivo e compará-las. Também mostrei como mostrar a caixa de diálogo de atualização e redirecionar o usuário para a página de atualização. Visite este link: https://stackoverflow.com/a/33925032/5475941 Apenas certifique-se de que na caixa de diálogo você mostre apenas o botão de atualização do usuário e não mostre a ele o botão cancelar. Nesse caso, ele será forçado a atualizar, antes de usar o aplicativo.

O que definitivamente deve ser mencionado aqui é a API de atualizações no aplicativo que será lançada em breve .

Você terá duas opções com esta API; a primeira é uma experiência de tela inteira para atualizações críticas quando você espera que o usuário espere a atualização ser aplicada imediatamente. A segunda opção é uma atualização flexível, o que significa que o usuário pode continuar usando o aplicativo enquanto a atualização é baixada. Você pode personalizar completamente o fluxo de atualização para que pareça parte do seu aplicativo.

É uma boa ideia usar a configuração remota para a versão do aplicativo e sempre verificar a atividade de inicialização se a versão atual do aplicativo é a mesma que a versão remota ou não, se não forçar para atualização da app store.

Codificação feliz lógica simples ..

https://firebase.google.com/docs/remote-config/android

Você pode usar as atualizações do aplicativo Play Core Library para resolver isso. Você pode verificar a disponibilidade de atualizações e instalá-las perfeitamente.

As atualizações no aplicativo não são compatíveis com aplicativos que usam arquivos de expansão APK (arquivos .obb). Você pode ir para downloads flexíveis ou atualizações imediatas que o Google Play se encarrega de baixar e instalar a atualização para você.

dependencies {
    implementation 'com.google.android.play:core:1.5.0'
    ...
}

Consulte esta resposta https://stackoverflow.com/a/58212818/7579041

você pode fazer isso fazendo uma correspondência entre um número de versão que é mantido no aplicativo em uma variável e da mesma forma a versão atual do aplicativo é mantida no lado do servidor e cada vez que o usuário abre o aplicativo, a primeira solicitação deve ser enviada para verificar se ele encontra a correspondência não faz nada, simplesmente permite que o usuário use seu aplicativo, caso contrário, acione um intent no google playstore ou abra uma janela de visualização da web para seu aplicativo (window.open (" https://play.google.com/store/apps/details?id= package_name ", '_system', 'location = yes');) e lá eles terão automaticamente o botão pedindo atualização que é o que o google playstore faz por você se você não tiver as atualizações automáticas ativadas.

Você pode notificar seus usuários de que há uma nova versão do aplicativo atual disponível para atualização. Além disso, se essa condição for verdadeira, você pode bloquear o login no aplicativo.

Por favor, veja se isso fornece a você a solução.

Bem, pode haver muitas soluções para esse problema, como copiar o código da versão da página do aplicativo (página do aplicativo do Google Play), etc.

Mas vou mostrar a solução definitiva que não custará um centavo e funcionará como mágica.

1. Basta salvar o código da versão mais recente do seu aplicativo no
   painel do Firebase Remote config
2. Busque o valor do código da versão sempre que o aplicativo for aberto

3. Compare-o com o código da versão atual do aplicativo, que você pode obter pelo seguinte código

   private int getCurrentVersionCode() {
   try {
       return getPackageManager().getPackageInfo(getPackageName(), 0).versionCode;
   } catch (NameNotFoundException e) {
       e.printStackTrace();
   }
   return -1;

   }

Se o código da versão buscada for maior que a versão atual, mostre um AlertDialog pedindo para atualizar o aplicativo. Caso contrário, o aplicativo já está atualizado.

Portanto, sempre que lançar a nova versão, você precisará colocar o código da nova versão no painel de configuração remota do Firebase

Você pode ler todo o tutorial sobre como forçar os usuários a atualizar o aplicativo usando o Firebase Remote config

O Google lançou atualizações no aplicativo para a biblioteca Play Core.

Implementei uma biblioteca leve para implementar facilmente atualizações no aplicativo. Você pode encontrar no link a seguir um exemplo sobre como forçar o usuário a realizar a atualização.

https://github.com/dnKaratzas/android-inapp-update#forced-updates