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

1288

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?

Fahad Ali Shaikh
fonte
2
Não tenho certeza, mas acho que você pode obtê-lo analisando o arquivo AndroidManifest.xml.
Sunit Kumar Gupta
Para obter o código da versão, use int versionCode = BuildConfig.VERSION_CODE;e obtenha o nome da versãoString versionName = BuildConfig.VERSION_NAME;
Lukas

Respostas:

2041

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;
mais-
fonte
52
@Felix que você não pode chamar getPackageManager () fora do contexto, portanto, getApplicationContext () (ou contexto passado) pode ser necessário.
Sver
2
e se você precisar desse número dentro de algum método estático em que não possa passar o contexto? projeto ruim da minha parte?
Gubatron
35
E não se esqueça de try... catch..quandogetPackageInfo()
anticafe
4
@Gubatron minha resposta abaixo permite recuperar esses valores estaticamente.
Sam Dozor
25
Se você deseja obter apenas a versão do aplicativo, isso é duas coisas complicadas. Você deve usar BuildConfig.VERSION_**como sugerido aqui .
Timo Bähr
1920

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"
}
Sam Dozor
fonte
178
Na verdade, isso é muito melhor do que todo o gerenciador de contexto e pacote, obrigado.
Superjugy 20/05
16
Na verdade, essas são as melhores soluções após o lançamento do Android Studio !!! 1 do meu lado
Dhruvil Patel 3/11
15
Não é muito confiável. O nome da versão aparece como uma sequência vazia na maioria das vezes.
Binoy Babu
20
@BinoyBabu, nunca deve aparecer como uma sequência vazia se você especificou um versionNamepara o seu aplicativo no seu build.gradlearquivo.
Sam Dozor
39
Você precisará importar o pacote correto para que isso funcione:import com.yourapppackage.android.BuildConfig
Eric B.
438

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

String versionName = context.getPackageManager()
    .getPackageInfo(context.getPackageName(), 0).versionName;
scottyab
fonte
81
Excelente. Provavelmente, isso deve estar cercado de try / catch para NameNotFoundException.
IgorGanapolsky 6/12/12
6
+1 Eu implementei sua solução, que funciona muito bem! No entanto, essa solução deve ser cercada por try and catch, como Igor disse, e é uma boa prática (por exemplo, para depuração) colocar cada chamada de método em uma linha separada em vez de chamar context.methodName (). SubMethod (). AnotherSubMethod () etc em uma única linha. Portanto, eu forneci uma solução mais limpa abaixo
Michael
1
Essa é a solução certa, graças;) Mas, como sugerido por @IgorGanapolsky, ele precisa ser cercado com try / catch :)
andrea.rinaldi
2
para aqueles que usam Gradle - existe uma solução mais simples. Veja minha resposta abaixo.
Sam Dozor
1
@ Erwinus Não concordo plenamente com a noção de usar uma exceção genérica para capturar coisas como esta. Exceções mais refinadas demonstram a compreensão do desenvolvedor sobre possíveis erros.
IgorGanapolsky
174

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();
Merkidemis
fonte
6
Descrição oficial do Android da android:versionCodee android:versionNamepode ser encontrada aqui: developer.android.com/tools/publishing/...
Jeffro
2
neste caso, é Contexto .ie Atividade, Serviço .etc
peterchaula
3
quando você colar um código de exemplo é útil para explicar o significado dos parâmetros .... althoug todos podem compreender o que this.getPackageName()representa o 0que você acabou de cuspir não tem nenhuma pista sobre o significado
Rafael Lima
Estúdio Android afirma versionCode está obsoleto
Roman Gherta
1
@RomanGherta É a partir da API 28. Se você está escrevendo código usando algo menos (ou há 8 anos quando essa resposta foi escrita), você ainda deve estar pronto. Outra resposta aqui tem o método atualizado.
Merkidemis 01/05/19
146

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.

Joshua Pinter
fonte
5
Isso funciona muito bem desde que você esteja acessando o BuildConfig a partir do projeto de aplicativo, não uma biblioteca usada no projeto de aplicativo. Caso contrário, você obterá o BuildConfig para o projeto da biblioteca, não o aplicativo.
John Cummings
@JohnCummings Interessante ... não pensei nisso.
Joshua Pinter
Não está funcionando versionName "1.2", e BuildConfig.VERSION_NAMEretorne empty. API> 21
Sojtin 10/08/16
Como acompanhamento, paramos de usar esse método em favor de apenas um número inteiro estático e uma String estática para versionCodee versionName, respectivamente. Somente porque algumas ferramentas como o Code Push tentam obter o número da sua versão analisando seu build.gradlearquivo e elas não conseguem atingir um valor dinâmico.
Joshua Pinter
O @JoshuaPinter PackageManager é realmente a opção mais segura. Se você usar substituições de código de versão para divisões, a constante BuildConfig ainda manterá o valor original (embora com sabor).
Eugen Pechanec
54

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);
Michael
fonte
Você acha que a NNFE pode ser realmente jogada? Seria estranho não encontrar um aplicativo em execução no gerenciador de pacotes :)
TWiStErRob
Estou com você que pode ser estranho, mas é a exceção padrão deste método - veja API : diz Throws PackageManager.NameNotFoundException if a package with the given name can not be found on the system.. No entanto, eu não conseguia imaginar um cenário para isso!
Michael
38

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;
Rohit Patil
fonte
34

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"
   }
Velayutham M
fonte
23

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 .

Sean Hall
fonte
9
A questão não era sobre o PhoneGap. Sua resposta pode confundir as pessoas.
likebobby
8
@BobbyJ Em nenhum lugar da pergunta, título ou tag ele especifica que a pergunta era sobre um aplicativo nativo. Foi isso que surgiu no google quando eu estava procurando a resposta e teria me poupado várias horas.
Sean Hall
Obrigado Hall72215. Ficarei feliz com isso ... se realmente não houver outra maneira de obter seu próprio número de versão? Prefiro evitar um plugin, se possível!
Magnus Smith
@MagnusSmith Não, a menos que o PhoneGap / Cordova o tenha adicionado às funções incorporadas.
Sean Salão
Neste exemplo, você pode ver o quão tolo é usar soluções de terceiros para criar aplicativos. Quando você escreveu do zero, foram apenas algumas linhas para codificar.
Codebeat
19

One-liners Kotlin

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

Certifique-se de importar BuildConfigpara sua classe

Gastón Saillén
fonte
13

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;
}
Tushar patel
fonte
12

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" />
Irfan Raza
fonte
Estou recebendo no meu xml o erro: Não é possível resolver o símbolo '@ string / versionName'
RJB
12

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();  
}  
Monir Zzaman
fonte
1
versionCode foi descontinuado na API 28. Conforme declarado nos documentos, use longVersionCode; developer.android.com/reference/android/content/pm/…
Dan Abnormal
11

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";
    }
Amir jodat
fonte
9

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());
}
Pratik Butani
fonte
9

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;
}
Gevaria Purva
fonte
3
Melhor método - BuildConfig.VERSION_CODE
jaydev
8

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);
        }
    }
}
Shubham Gupta
fonte
8

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();
}
  1. 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
    }
}
mohax
fonte
6

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. :)

Jeff.H
fonte
5

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.

JasonChiu
fonte
4
 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) {

    }

  }
}
Durul Dalkanat
fonte
Olá, @donmj. Se você estiver usando uma raiz oficial para dispositivo Android. Eu acho que você vai precisar. Esta é a minha abordagem.
você precisa saber é o seguinte
Obrigado pela ajuda @Durul Dalkanat :).
donmj
4

tente este:

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

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;
meduvigo
fonte
1
nenhum corpo tem tempo para isso.
BlaShadow 15/10
3
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;
        }
    }
Atif Mahmood
fonte
3

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
Sapphire91140
fonte
Você deve procurar outras respostas antes de postar sua resposta. por exemplo, para o contexto que você está fazendo getActivity.getApplicationContext se você estiver no fragmento então eu posso entender, mas se você estiver em atividade Eu não acho que você precisa chamar getActivity
Sahil Manchanda
No meu caso, fiz isso para Fragment. O código é usado dentro do onCreate
Sapphire91140
3

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 :-)

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

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
     }
   }
Ishwor Khanal
fonte
2

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
        }
Mayank Sharma
fonte
0

Ú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": {}
    }
]
Tom
fonte