Como obter o número da versão / versão do seu aplicativo Android?

Preciso descobrir como obter ou criar um número de compilação para o meu aplicativo Android. Eu preciso do número da compilação para exibir na interface do usuário.

Eu tenho que fazer alguma coisa AndroidManifest.xml?

Usar:

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

E você pode obter o código da versão usando este

int verCode = pInfo.versionCode;

Se você estiver usando o plug-in Gradle / Android Studio, a partir da versão 0.7.0 , o código e o nome da versão estarão disponíveis estaticamente BuildConfig. Certifique-se de importar o pacote do seu aplicativo , e não outro BuildConfig:

import com.yourpackage.BuildConfig;
...
int versionCode = BuildConfig.VERSION_CODE;
String versionName = BuildConfig.VERSION_NAME;

Nenhum objeto de contexto é necessário!

Também certifique-se de especificá-los em seu build.gradlearquivo em vez de AndroidManifest.xml.

defaultConfig {
    versionCode 1
    versionName "1.0"
}

Versão ligeiramente mais curta se você quiser apenas o nome da versão.

String versionName = context.getPackageManager()
    .getPackageInfo(context.getPackageName(), 0).versionName;

Há duas partes que você precisa: android: versionCode android: versionName

versionCode é um número e todas as versões do aplicativo enviadas ao Market precisam ter um número maior que o último.

VersionName é uma string e pode ser o que você quiser. É aqui que você define seu aplicativo como "1.0" ou "2.5" ou "2 Alpha EXTREME!" como queiras.

Exemplo:

Kotlin:

val manager = this.packageManager
val info = manager.getPackageInfo(this.packageName, PackageManager.GET_ACTIVITIES)
toast("PackageName = " + info.packageName + "\nVersionCode = "
            + info.versionCode + "\nVersionName = "
            + info.versionName + "\nPermissions = " + info.permissions)

Java:

PackageManager manager = this.getPackageManager();
PackageInfo info = manager.getPackageInfo(this.getPackageName(), PackageManager.GET_ACTIVITIES);
Toast.makeText(this,
     "PackageName = " + info.packageName + "\nVersionCode = "
       + info.versionCode + "\nVersionName = "
       + info.versionName + "\nPermissions = " + info.permissions, Toast.LENGTH_SHORT).show();

Usando Gradle e BuildConfig

Obtendo o VERSION_NAME do BuildConfig

BuildConfig.VERSION_NAME

Sim, é tão fácil agora.

Está retornando uma string vazia para VERSION_NAME?

Se você estiver recebendo uma sequência vazia BuildConfig.VERSION_NAME, continue lendo.

Eu continuava recebendo uma string vazia BuildConfig.VERSION_NAMEporque não estava definindo o versionNamearquivo de compilação Grade (eu migrei do ANT para o Gradle). Então, aqui estão as instruções para garantir que você está configurando sua VERSION_NAMEvia Gradle.

build.gradle

def versionMajor = 3
def versionMinor = 0
def versionPatch = 0
def versionBuild = 0 // bump for dogfood builds, public betas, etc.

android {

  defaultConfig {
    versionCode versionMajor * 10000 + versionMinor * 1000 + versionPatch * 100 + versionBuild

    versionName "${versionMajor}.${versionMinor}.${versionPatch}"
  }

}

Nota: Isto é do mestre Jake Wharton .

Removendo versionNamee versionCodedeAndroidManifest.xml

E como você definiu o arquivo versionNamee versionCodeno build.gradlearquivo agora, também pode removê-los do AndroidManifest.xmlarquivo, se houver.

Aqui está uma solução limpa , baseada na solução de scottyab (editada por Xavi). Ele mostra como obter o contexto primeiro, se não for fornecido pelo seu método. Além disso, ele usa várias linhas em vez de chamar vários métodos por linha. Isso facilita quando você precisa depurar seu aplicativo.

Context context = getApplicationContext(); // or activity.getApplicationContext()
PackageManager packageManager = context.getPackageManager();
String packageName = context.getPackageName();

String myVersionName = "not available"; // initialize String

try {
    myVersionName = packageManager.getPackageInfo(packageName, 0).versionName;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

Agora que você recebeu o nome da versão na String myVersionName, pode configurá-lo para um TextView ou o que quiser.

// set version name to a TextView
TextView tvVersionName = (TextView) findViewById(R.id.tv_versionName);
tvVersionName.setText(myVersionName);

Para obter a versão do aplicativo ou criar o código usado para identificar o apk pelo seu código de versão. O código da versão é usado para detectar a configuração de compilação real no momento da atualização, publicação etc.

int versionCode = BuildConfig.VERSION_CODE;

O nome da versão é usado para mostrar os usuários ou os desenvolvedores da sequência de desenvolvimento. Você pode adicionar qualquer tipo de nome de versão como desejar

String versionName = BuildConfig.VERSION_NAME;

Use a classe BuildConfig

String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;

build.gradle (aplicativo)

 defaultConfig {
    applicationId "com.myapp"
    minSdkVersion 19
    targetSdkVersion 27
    versionCode 17
    versionName "1.0"
   }

Se você estiver usando o PhoneGap, crie um plug-in PhoneGap personalizado:

Crie uma nova classe no pacote do seu aplicativo:

package com.Demo; //replace with your package name

import org.json.JSONArray;

import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;

import com.phonegap.api.Plugin;
import com.phonegap.api.PluginResult;
import com.phonegap.api.PluginResult.Status;

public class PackageManagerPlugin extends Plugin {

    public final String ACTION_GET_VERSION_NAME = "GetVersionName";

    @Override
    public PluginResult execute(String action, JSONArray args, String callbackId) {
        PluginResult result = new PluginResult(Status.INVALID_ACTION);
        PackageManager packageManager = this.ctx.getPackageManager();

        if(action.equals(ACTION_GET_VERSION_NAME)) {
            try {
                PackageInfo packageInfo = packageManager.getPackageInfo(
                                              this.ctx.getPackageName(), 0);
                result = new PluginResult(Status.OK, packageInfo.versionName);
            }
            catch (NameNotFoundException nnfe) {
                result = new PluginResult(Status.ERROR, nnfe.getMessage());
            }
        }

        return result;
    }
}

No plugins.xml, adicione a seguinte linha:

<plugin name="PackageManagerPlugin" value="com.Demo.PackageManagerPlugin" />

No seu evento de deviceready , adicione o seguinte código:

var PackageManagerPlugin = function() {

};
PackageManagerPlugin.prototype.getVersionName = function(successCallback, failureCallback) {
    return PhoneGap.exec(successCallback, failureCallback, 'PackageManagerPlugin', 'GetVersionName', []);
};
PhoneGap.addConstructor(function() {
    PhoneGap.addPlugin('packageManager', new PackageManagerPlugin());
});

Em seguida, você pode obter o atributo versionName fazendo:

window.plugins.packageManager.getVersionName(
    function(versionName) {
        //do something with versionName
    },
    function(errorMessage) {
        //do something with errorMessage
    }
);

Derivado daqui e aqui .

One-liners Kotlin

  val versionCode = BuildConfig.VERSION_CODE
  val versionName = BuildConfig.VERSION_NAME

Certifique-se de importar BuildConfigpara sua classe

Para usuários do xamarin, use este código para obter o nome e o código da versão

1) Nome da versão:

public string getVersionName(){
      return Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionName;
}

2) Código da versão:

public string getVersionCode(){
      return Application.Context.ApplicationContext.PackageManager.GetPackageInfo(Application.Context.ApplicationContext.PackageName, 0).VersionCode;
}

Se você quiser usá-lo no xml, adicione a linha abaixo no seu arquivo gradle:

applicationVariants.all { variant ->
    variant.resValue "string", "versionName", variant.versionName
}

E então use-o no seu xml assim:

<TextView
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/versionName" />

Não, você não precisa fazer nada com o AndroidManifest.xml

Basicamente, o nome da versão do aplicativo e o código da versão no arquivo gradle no nível do aplicativo , na tag defaultConfig :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

Nota: Quando você deseja fazer o upload do aplicativo no playstore, pode atribuir qualquer nome como nome da versão, mas o código da versão deve ser diferente do código da versão atual, se esse aplicativo já estiver na play store.

Basta usar o seguinte snippet de código para obter o código e o nome da versão de qualquer lugar do seu aplicativo:

try {  
    PackageInfo pInfo =   context.getPackageManager().getPackageInfo(context.getPackageName(), 0);  
    String version = pInfo.versionName;  
    int verCode = pInfo.versionCode;  
} catch (PackageManager.NameNotFoundException e) {  
    e.printStackTrace();  
}  

para a Api 28, o PackageInfo.versionCode está obsoleto, portanto, use este código abaixo:

    Context context = getApplicationContext();
    PackageManager manager = context.getPackageManager();
    try {
        PackageInfo info = manager.getPackageInfo(context.getPackageName(), 0);
        myversionName = info.versionName;
        versionCode = (int) PackageInfoCompat.getLongVersionCode(info);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
        myversionName = "Unknown-01";
    }

Sempre faça isso com o try catchbloco:

String versionName = "Version not found";

try {
    versionName = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
    Log.i(TAG, "Version Name: " + versionName);
} catch (NameNotFoundException e) {
    // TODO Auto-generated catch block
    Log.e(TAG, "Exception Version Name: " + e.getLocalizedMessage());
}

Aqui está o método para obter o código da versão:

public String getAppVersion() {
    String versionCode = "1.0";
    try {
        versionCode = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;
    } catch (PackageManager.NameNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return versionCode;
}

Eu resolvi isso usando a classe Preference.

package com.example.android;

import android.content.Context;
import android.preference.Preference;
import android.util.AttributeSet;

public class VersionPreference extends Preference {
    public VersionPreference(Context context, AttributeSet attrs) {
        super(context, attrs);
        String versionName;
        final PackageManager packageManager = context.getPackageManager();
        if (packageManager != null) {
            try {
                PackageInfo packageInfo = packageManager.getPackageInfo(context.getPackageName(), 0);
                versionName = packageInfo.versionName;
            } catch (PackageManager.NameNotFoundException e) {
                versionName = null;
            }
            setSummary(versionName);
        }
    }
}

Existem algumas maneiras de obter versionCodee versionNameprogramaticamente.

1. Obter versão de PackageManager. Essa é a melhor maneira para a maioria dos casos.

try {
    String versionName = packageManager.getPackageInfo(packageName, 0).versionName;
    int versionCode = packageManager.getPackageInfo(packageName, 0).versionCode;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

2. Obtê-lo de gerado BuildConfig.java. Mas observe que, se você acessar esses valores na biblioteca, ele retornará a versão da biblioteca, não os aplicativos um, que usa essa biblioteca. Portanto, use apenas em projetos que não são de biblioteca!

String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;

Existem alguns detalhes, exceto o uso de segunda via no projeto da biblioteca. No novo plugin Android Gradle (3.0.0+), algumas funcionalidades foram removidas . Então, por enquanto, ou seja, definindo uma versão diferente para diferentes sabores, não está funcionando corretamente.

Maneira incorreta:

applicationVariants.all { variant ->
    println('variantApp: ' + variant.getName())

    def versionCode = {SOME_GENERATED_VALUE_IE_TIMESTAMP}
    def versionName = {SOME_GENERATED_VALUE_IE_TIMESTAMP}

    variant.mergedFlavor.versionCode = versionCode
    variant.mergedFlavor.versionName = versionName
}

O código acima definirá os valores corretamente BuildConfig, mas PackageManagervocê receberá 0e, nullse não tiver definido a versão na defaultconfiguração. Portanto, seu aplicativo terá 0código de versão no dispositivo.

Existe uma solução alternativa - defina a versão para o apkarquivo de saída manualmente:

applicationVariants.all { variant ->
    println('variantApp: ' + variant.getName())

    def versionCode = {SOME_GENERATED_VALUE_IE_TIMESTAMP}
    def versionName = {SOME_GENERATED_VALUE_IE_TIMESTAMP}

    variant.outputs.all { output ->
        output.versionCodeOverride = versionCode
        output.versionNameOverride = versionName
    }
}

Este código foi mencionado acima em partes, mas aqui está novamente tudo incluído. Você precisa de um bloco try / catch porque ele pode gerar uma "NameNotFoundException".

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

Espero que isso simplifique as coisas para alguém no caminho. :)

Alguém que não precisa das informações do BuildConfig para a interface do usuário do aplicativo, no entanto, deseja usá-las para definir uma configuração de tarefa de IC ou outras pessoas, como eu.

Há um arquivo gerado automaticamente, BuildConfig.java, no diretório do projeto, desde que você construa o projeto com êxito.

{WORKSPACE} / build / gerados / source / buildConfig / {debug | release} / {PACKAGE} /BuildConfig.java

/**
* Automatically generated file. DO NOT MODIFY
*/
package com.XXX.Project;

public final class BuildConfig {
    public static final boolean DEBUG = Boolean.parseBoolean("true");
    public static final String APPLICATION_ID = "com.XXX.Project";
    public static final String BUILD_TYPE = "debug";
    public static final String FLAVOR = "";
    public static final int VERSION_CODE = 1;
    public static final String VERSION_NAME = "1.0.0";
}

Divida as informações necessárias por script python ou outras ferramentas. Aqui está um exemplo:

import subprocess
#find your BuildConfig.java
_BuildConfig = subprocess.check_output('find {WORKSPACE} -name BuildConfig.java', shell=True).rstrip()
#get the version name
_Android_version = subprocess.check_output('grep -n "VERSION_NAME" '+_BuildConfig, shell=True).split('"')[1]
print('Android version :’+_Android_version)

Desculpe minha capacidade limitada de inglês, mas espero que isso ajude.

 package com.sqisland.android.versionview;

import android.app.Activity;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity {
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    TextView textViewversionName = (TextView) findViewById(R.id.text);

    try {
        PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        textViewversionName.setText(packageInfo.versionName);

    }
    catch (PackageManager.NameNotFoundException e) {

    }

  }
}

tente este:

try 
{
    device_version =  getPackageManager().getPackageInfo("com.google.android.gms", 0).versionName;
}
catch (PackageManager.NameNotFoundException e)
{
    e.printStackTrace();
}

Primeiro:

import android.content.pm.PackageManager.NameNotFoundException;

e depois use isso:

PackageInfo pInfo = null;
try {
     pInfo = getPackageManager().getPackageInfo(getPackageName(), 0);
} catch (NameNotFoundException e) {
     e.printStackTrace();
            }
String versionName = pInfo.versionName;

private String GetAppVersion(){
        try {
            PackageInfo _info = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            return _info.versionName;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return "";
        }
    }

    private int GetVersionCode(){
        try {
            PackageInfo _info = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
            return _info.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return -1;
        }
    }

Exemplo para uso interno do fragmento.

        import android.content.pm.PackageManager;
        .......

        private String VersionName;
        private String VersionCode;
        .......


        Context context = getActivity().getApplicationContext();

        /*Getting Application Version Name and Code*/
        try
        {

             VersionName = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;

             /*I find usefull to convert vervion code into String, so it's ready for TextViev/server side checks*/ 

             VersionCode = Integer.toString(context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode);
        } catch (PackageManager.NameNotFoundException e)
        {
             e.printStackTrace();
        }

// DO SOMETHING USEFULL WITH THAT

Exemplo de Kotlin:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.act_signin)

    packageManager.getPackageInfo(packageName, PackageManager.GET_ACTIVITIES).apply {
        findViewById<TextView>(R.id.text_version_name).text = versionName
        findViewById<TextView>(R.id.text_version_code).text =
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) "$longVersionCode" else "$versionCode"
    }

    packageManager.getApplicationInfo(packageName, 0).apply{
        findViewById<TextView>(R.id.text_build_date).text =
            SimpleDateFormat("yy-MM-dd hh:mm").format(java.io.File(sourceDir).lastModified())
    }
}

Não agradeça :-)

  PackageInfo pinfo = null;
    try {
        pinfo = getPackageManager().getPackageInfo(getPackageName(), 0);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    int versionNumber = pinfo.versionCode;
    String versionName = pinfo.versionName;

Como eu precisava obter apenas o código da versão e verificar se o aplicativo está atualizado ou não, se sim, tive que iniciar o playstore para atualizar um. Eu fiz assim.

public class CheckForUpdate {

public static final String ACTION_APP_VERSION_CHECK="app-version-check";

public static void launchPlayStoreApp(Context context)
{

    final String appPackageName = context.getPackageName(); // getPackageName() from Context or Activity object
    try {
        context.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + appPackageName)));
    } catch (android.content.ActivityNotFoundException anfe) {
        context.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=" + appPackageName)));
    }

}

public static int getRemoteVersionNumber(Context context)
{
    int versionCode=0;
    try {
        PackageInfo pInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
        String version = pInfo.versionName;
        versionCode=pInfo.versionCode;
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    return versionCode;
}

}

Em seguida, salvei o código da versão usando preferência compartilhada, criando uma classe util.

public class PreferenceUtils {

// this is for version code
private  final String APP_VERSION_CODE = "APP_VERSION_CODE";
private  SharedPreferences sharedPreferencesAppVersionCode;
private SharedPreferences.Editor editorAppVersionCode;
private static Context mContext;

public PreferenceUtils(Context context)
{
    this.mContext=context;
    // this is for app versioncode
    sharedPreferencesAppVersionCode=mContext.getSharedPreferences(APP_VERSION_CODE,MODE_PRIVATE);
    editorAppVersionCode=sharedPreferencesAppVersionCode.edit();
}

public void createAppVersionCode(int versionCode) {

    editorAppVersionCode.putInt(APP_VERSION_CODE, versionCode);
    editorAppVersionCode.apply();
}

public int getAppVersionCode()
{
    return sharedPreferencesAppVersionCode.getInt(APP_VERSION_CODE,0); // as default  version code is 0
     }
   }

Como em 2020: a API 28 "versionCode" foi descontinuada, para que possamos usar "longVersionCode"

Código de exemplo no kotlin

  val manager = context?.packageManager
        val info = manager?.getPackageInfo(
            context?.packageName, 0
        )

        val versionName = info?.versionName
        val versionNumber = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            info?.longVersionCode
        } else {
            info?.versionCode
        }

Útil para sistemas de compilação: existe um arquivo gerado com seu apk chamado, output.jsonque contém uma matriz de informações para cada APK gerado, incluindo o versionName e o versionCode.

por exemplo

[
    {
        "apkInfo": {
            "baseName": "x86-release",
            "enabled": true,
            "filterName": "x86",
            "fullName": "86Release",
            "outputFile": "x86-release-1.0.apk",
            "splits": [
                {
                    "filterType": "ABI",
                    "value": "x86"
                }
            ],
            "type": "FULL_SPLIT",
            "versionCode": 42,
            "versionName": "1.0"
        },
        "outputType": {
            "type": "APK"
        },
        "path": "app-x86-release-1.0.apk",
        "properties": {}
    }
]